Skip to main content

glass_dev/tui/
state.rs

1use super::command;
2use crate::{ExperimentComparison, SharedDevelopmentWorkspace};
3use glass_browser::browser_workspace::{
4    BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
5    BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
6    BrowserWorkspaceLayout, BrowserWorkspaceTarget,
7};
8use glass_browser::cli::args::TuiLayout;
9use glass_browser::terminal_graphics::AnsiCanvas;
10use glass_browser::tui::live_view::AnsiPane;
11use serde::{Deserialize, Serialize};
12use std::path::Path;
13use std::sync::atomic::{AtomicU64, Ordering};
14
15static NEXT_BROWSER_TOOL: AtomicU64 = AtomicU64::new(1);
16
17pub struct PendingConfirmation {
18    pub call: crate::development::ToolCall,
19    pub context: crate::tools::DevelopmentToolContext,
20    pub summary: String,
21}
22
23#[derive(Debug, Clone)]
24pub struct PendingAgentApproval {
25    pub agent_id: String,
26    pub frame_id: String,
27    pub tool_name: String,
28    pub arguments: serde_json::Value,
29}
30
31#[derive(Debug, Clone, Copy, PartialEq, Eq)]
32pub enum ChatMessageState {
33    Sending,
34    Sent,
35    Failed,
36}
37
38#[derive(Debug, Clone, PartialEq, Eq)]
39pub struct PendingChatMessage {
40    pub text: String,
41    pub state: ChatMessageState,
42    pub job_id: Option<u64>,
43    pub error: Option<String>,
44}
45
46/// In-TUI recovery choices offered when a browser start collides or fails.
47#[derive(Debug, Clone, PartialEq, Eq)]
48pub struct BrowserRecoveryOffer {
49    pub reason: String,
50    pub port: u16,
51    /// A healthy Chrome CDP endpoint answered on the preferred port.
52    pub compatible_endpoint: bool,
53}
54
55impl BrowserRecoveryOffer {
56    pub fn from_error(error: &str, port: u16) -> Self {
57        let lower = error.to_ascii_lowercase();
58        Self {
59            reason: error.to_string(),
60            port,
61            compatible_endpoint: ["attach", "devtools", "page target", "multiple page targets"]
62                .iter()
63                .any(|marker| lower.contains(marker)),
64        }
65    }
66
67    pub fn actions(&self) -> &'static [(&'static str, &'static str)] {
68        if self.compatible_endpoint {
69            &[
70                ("1", "attach after checking the running browser"),
71                ("2", "launch an isolated browser on an automatic free port"),
72                ("3", "retry the preferred port"),
73                ("Esc", "dismiss"),
74            ]
75        } else {
76            &[
77                ("1", "launch an isolated browser on an automatic free port"),
78                ("2", "retry the preferred port"),
79                ("Esc", "dismiss"),
80            ]
81        }
82    }
83
84    pub fn guidance(&self) -> &'static str {
85        let lower = self.reason.to_ascii_lowercase();
86        if self.compatible_endpoint {
87            "A DevTools endpoint answered. Attach only when its page is the intended browser; otherwise launch an isolated session."
88        } else if lower.contains("occup") || lower.contains("address") || lower.contains("port") {
89            "The preferred endpoint is busy or unavailable. Glass keeps the project and agent alive while you retry or move to an automatic free port."
90        } else {
91            "The browser did not become usable. Check Chrome/Chromium availability, then retry; the workspace remains intact."
92        }
93    }
94}
95
96#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
97pub enum DevSurface {
98    Trust,
99    Agent,
100    Code,
101    App,
102    Terminal,
103    Tasks,
104    Git,
105    Debug,
106    More,
107}
108
109impl DevSurface {
110    pub const ALL: [Self; 8] = [
111        Self::Agent,
112        Self::Code,
113        Self::App,
114        Self::Terminal,
115        Self::Tasks,
116        Self::Git,
117        Self::Debug,
118        Self::More,
119    ];
120
121    pub const PRIMARY: [Self; 7] = [
122        Self::Agent,
123        Self::Code,
124        Self::App,
125        Self::Terminal,
126        Self::Tasks,
127        Self::Git,
128        Self::Debug,
129    ];
130
131    pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
132
133    pub fn label(self) -> &'static str {
134        match self {
135            Self::Trust => "Trust",
136            Self::Agent => "Agent",
137            Self::Code => "Code",
138            Self::App => "App",
139            Self::Terminal => "Terminal",
140            Self::Tasks => "Tasks",
141            Self::Git => "Git",
142            Self::Debug => "Debug",
143            Self::More => "More",
144        }
145    }
146}
147
148#[derive(Debug, Clone, Copy, PartialEq, Eq)]
149pub enum ResponsiveClass {
150    Desktop,
151    Compact,
152    Phone,
153}
154
155#[derive(Debug, Clone, Copy, PartialEq, Eq)]
156pub enum ProductMode {
157    Build,
158    Agent,
159    RunApp,
160    Debug,
161}
162
163impl ProductMode {
164    pub fn label(self) -> &'static str {
165        match self {
166            Self::Build => "build",
167            Self::Agent => "agent",
168            Self::RunApp => "run",
169            Self::Debug => "debug",
170        }
171    }
172}
173
174pub struct DevTuiState {
175    pub workspace: SharedDevelopmentWorkspace,
176    pub surface: DevSurface,
177    pub layout: TuiLayout,
178    pub quit: bool,
179    pub quit_confirmation: bool,
180    pub command_mode: bool,
181    pub command_input: String,
182    pub command_cursor: usize,
183    pub command_history: Vec<String>,
184    pub command_history_index: Option<usize>,
185    pub palette_error: Option<String>,
186    pub menu_open: bool,
187    pub menu_selection: usize,
188    pub help_open: bool,
189    pub help_scroll: u16,
190    pub composer_mode: bool,
191    pub composer_input: String,
192    pub composer_cursor: usize,
193    pub composer_steer: bool,
194    pub pending_chat_messages: Vec<PendingChatMessage>,
195    pub agent_send_job: Option<u64>,
196    pub selected_agent: Option<crate::AgentId>,
197    pub pending_confirmation: Option<PendingConfirmation>,
198    pub pending_agent_approval: Option<PendingAgentApproval>,
199    pub queued_tool_request: Option<(
200        crate::development::ToolCall,
201        crate::tools::DevelopmentToolContext,
202    )>,
203    pub running_tool_job: Option<u64>,
204    pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
205    pub terminal_width: u16,
206    pub terminal_height: u16,
207    pub status: String,
208    pub snapshot_root: String,
209    pub snapshot_trust_label: String,
210    pub snapshot_trust_inspection: Vec<crate::customization::CustomizationInspectionItem>,
211    pub snapshot_project_revision: u64,
212    pub snapshot_generation: u64,
213    pub snapshot_skills_count: usize,
214    pub snapshot_tools_count: usize,
215    /// Wall-clock cost of the last background refresh pass.
216    pub refresh_latency_ms: u64,
217    /// Highest agent event sequence folded into the live conversation.
218    pub conversation_cursor: u64,
219    /// Index of the editor buffer focused by the Code surface.
220    pub editor_buffer_index: usize,
221    pub focused_editor_path: String,
222    pub focused_editor_dirty: bool,
223    pub focused_editor_line: u32,
224    pub agents: String,
225    pub agent_readiness: String,
226    /// Set by an in-TUI login action; the event loop temporarily hands the
227    /// terminal to Pi so `/login` can receive interactive input.
228    pub agent_login_requested: bool,
229    pub agent_conversation: String,
230    pub tasks: String,
231    pub editor: String,
232    pub files: Vec<String>,
233    pub selected_file: usize,
234    pub code_edit_mode: bool,
235    pub lsp: String,
236    pub processes: String,
237    pub git: String,
238    pub git_diff: String,
239    pub git_diff_open: bool,
240    pub git_diff_requested: bool,
241    pub tests: String,
242    pub kernels: String,
243    pub debugger: String,
244    pub replay: String,
245    pub browser: String,
246    pub browser_detail: String,
247    pub browser_workspace: BrowserWorkspaceController,
248    pub browser_recovery: Option<BrowserRecoveryOffer>,
249    pub browser_target_picker: bool,
250    pub browser_target_picker_requested: bool,
251    pub browser_target_query: String,
252    pub browser_target_selection: usize,
253    pub browser_visual_live: bool,
254    pub browser_observe_pending: bool,
255    pub browser_ansi: AnsiCanvas,
256    pub browser_pane: Option<AnsiPane>,
257    pub workflow: String,
258    pub workspace_status: String,
259    pub experiment_comparison: Option<ExperimentComparison>,
260    pub experiments: String,
261}
262
263impl DevTuiState {
264    /// Lock the shared workspace, mapping errors to strings for the palette.
265    pub fn ws(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
266        self.workspace.try_lock().map_err(|error| error.to_string())
267    }
268
269    /// Lock the shared workspace for mutation, mapping errors to strings.
270    pub fn ws_mut(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
271        self.workspace.try_lock().map_err(|error| error.to_string())
272    }
273
274    /// Lock the workspace for mutation inside UI callbacks; reports lock
275    /// failures through the status line instead of `?`.
276    fn locked<F, T>(&mut self, operation: F) -> Option<T>
277    where
278        F: FnOnce(&mut crate::DevelopmentWorkspace) -> T,
279    {
280        match self.workspace.try_lock() {
281            Ok(mut workspace) => Some(operation(&mut workspace)),
282            Err(error) => {
283                self.status = format!("Workspace lock failed: {error}");
284                None
285            }
286        }
287    }
288
289    pub fn product_mode(&self) -> ProductMode {
290        match self.surface {
291            DevSurface::Agent => ProductMode::Agent,
292            DevSurface::App => ProductMode::RunApp,
293            DevSurface::Debug => ProductMode::Debug,
294            _ => ProductMode::Build,
295        }
296    }
297    pub fn open(
298        root: impl AsRef<Path>,
299        layout: TuiLayout,
300    ) -> Result<Self, Box<dyn std::error::Error>> {
301        Self::open_internal(root, layout, true)
302    }
303
304    /// Construct the interactive TUI without doing a full synchronous
305    /// projection pass. The snapshot worker fills resident projections after
306    /// the first frame, so a large repository can show the cockpit immediately.
307    pub fn open_for_tui(
308        root: impl AsRef<Path>,
309        layout: TuiLayout,
310    ) -> Result<Self, Box<dyn std::error::Error>> {
311        Self::open_internal(root, layout, false)
312    }
313
314    fn open_internal(
315        root: impl AsRef<Path>,
316        layout: TuiLayout,
317        initial_refresh: bool,
318    ) -> Result<Self, Box<dyn std::error::Error>> {
319        let workspace = SharedDevelopmentWorkspace::open(root)?;
320        let locked = workspace.lock()?;
321        let trust = locked.trust();
322        let trust_inspection = locked.trust_inspection();
323        let snapshot_root = locked.root().display().to_string();
324        let snapshot_project_revision = locked.project().revision();
325        let snapshot_generation = locked.generation();
326        let snapshot_skills_count = locked.customization().skills().count();
327        let snapshot_tools_count = locked.customization().config().tools.len();
328        let trust_prompt = trust == crate::WorkspaceTrust::Untrusted
329            && trust_inspection.iter().any(|item| item.trust_required);
330        drop(locked);
331        let mut state = Self {
332            workspace,
333            surface: if trust_prompt {
334                DevSurface::Trust
335            } else {
336                DevSurface::Agent
337            },
338            layout,
339            quit: false,
340            quit_confirmation: false,
341            command_mode: false,
342            command_input: String::new(),
343            command_cursor: 0,
344            command_history: Vec::new(),
345            command_history_index: None,
346            palette_error: None,
347            menu_open: false,
348            menu_selection: 0,
349            help_open: false,
350            help_scroll: 0,
351            composer_mode: false,
352            composer_input: String::new(),
353            composer_cursor: 0,
354            composer_steer: false,
355            pending_chat_messages: Vec::new(),
356            agent_send_job: None,
357            selected_agent: None,
358            pending_confirmation: None,
359            pending_agent_approval: None,
360            queued_tool_request: None,
361            running_tool_job: None,
362            surface_scroll: std::collections::BTreeMap::new(),
363            terminal_width: 80,
364            terminal_height: 24,
365            snapshot_root,
366            snapshot_trust_label: trust.label().into(),
367            snapshot_trust_inspection: trust_inspection,
368            snapshot_project_revision,
369            snapshot_generation,
370            snapshot_skills_count,
371            snapshot_tools_count,
372            refresh_latency_ms: 0,
373            conversation_cursor: 0,
374            editor_buffer_index: 0,
375            focused_editor_path: String::new(),
376            focused_editor_dirty: false,
377            focused_editor_line: 0,
378            status: if trust_prompt {
379                "Trust required · I inspect · O untrusted · 1 once · T project".into()
380            } else {
381                "Ready · a launch · : routes · ? help".into()
382            },
383            agents: String::new(),
384            agent_readiness: crate::pi_runtime::pi_readiness()
385                .map(|readiness| format_pi_readiness(&readiness))
386                .unwrap_or_else(|error| format!("Agent unavailable · {error}")),
387            agent_login_requested: false,
388            agent_conversation: "No conversation yet. Press i to compose a message.".into(),
389            tasks: String::new(),
390            editor: String::new(),
391            files: Vec::new(),
392            selected_file: 0,
393            code_edit_mode: false,
394            lsp: String::new(),
395            processes: String::new(),
396            git: String::new(),
397            git_diff: String::new(),
398            git_diff_open: false,
399            git_diff_requested: false,
400            tests: String::new(),
401            kernels: String::new(),
402            debugger: String::new(),
403            replay: String::new(),
404            browser: String::new(),
405            browser_detail: "No browser observation yet".into(),
406            browser_workspace: BrowserWorkspaceController::for_adapter(
407                match layout {
408                    TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
409                    TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
410                    TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
411                },
412                BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
413            ),
414            browser_recovery: None,
415            browser_target_picker: false,
416            browser_target_picker_requested: false,
417            browser_target_query: String::new(),
418            browser_target_selection: 0,
419            browser_visual_live: false,
420            browser_observe_pending: false,
421            browser_ansi: AnsiCanvas::default(),
422            browser_pane: None,
423            workflow: "No workflow evidence yet".into(),
424            workspace_status: String::new(),
425            experiment_comparison: None,
426            experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
427        };
428        if initial_refresh {
429            state.refresh();
430        }
431        Ok(state)
432    }
433
434    pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
435        match self.layout {
436            TuiLayout::Desktop => ResponsiveClass::Desktop,
437            TuiLayout::Compact => ResponsiveClass::Compact,
438            TuiLayout::Mobile => ResponsiveClass::Phone,
439            TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
440            TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
441            TuiLayout::Auto => ResponsiveClass::Desktop,
442        }
443    }
444
445    pub fn request_quit(&mut self) {
446        if self.quit {
447            return;
448        }
449        self.quit_confirmation = true;
450        self.status = "Quit confirmation · Enter exits · Esc stays".into();
451    }
452
453    pub fn confirm_quit(&mut self) {
454        self.quit_confirmation = false;
455        self.quit = true;
456        self.status = "Closing Glass Dev".into();
457    }
458
459    pub fn cancel_quit(&mut self) {
460        self.quit_confirmation = false;
461        self.status = "Quit dismissed · workspace remains open".into();
462    }
463
464    pub fn quit_menu_index(&self) -> usize {
465        self.surface_actions().len() + 1
466    }
467
468    /// Guided launchers for the current surface. `a` opens the command center.
469    pub fn surface_actions(&self) -> &'static [command::SurfaceAction] {
470        command::surface_actions(self.surface)
471    }
472
473    pub fn toggle_help(&mut self) {
474        self.help_open = !self.help_open;
475        self.help_scroll = 0;
476        self.status = if self.help_open {
477            "Help · j/k scroll · ? or Esc closes".into()
478        } else {
479            "Help closed".into()
480        };
481    }
482
483    pub fn scroll_help(&mut self, delta: i32) {
484        self.help_scroll = (self.help_scroll as i32 + delta).max(0) as u16;
485    }
486
487    pub fn open_menu(&mut self) {
488        self.menu_open = true;
489        self.menu_selection = 0;
490        self.status = format!(
491            "Command center · {} launchers first · : searches all routes · Enter runs",
492            self.surface.label()
493        );
494    }
495
496    pub fn close_menu(&mut self) {
497        self.menu_open = false;
498    }
499
500    /// Run the selected command-center launcher. Keyboard hints apply
501    /// directly; strings starting with `:` open the palette prefilled with
502    /// the command.
503    pub fn run_menu_action(&mut self) {
504        let search_index = self.surface_actions().len();
505        let quit_index = self.quit_menu_index();
506        if self.menu_selection == search_index {
507            self.menu_open = false;
508            self.open_palette();
509            return;
510        }
511        if self.menu_selection == quit_index {
512            self.menu_open = false;
513            self.request_quit();
514            return;
515        }
516        let Some(action) = self.surface_actions().get(self.menu_selection).copied() else {
517            return;
518        };
519        self.menu_open = false;
520        let name = action.label;
521        let hint = action.command;
522        let prefix = action.key;
523        if prefix == ":" {
524            // Strip documentation placeholders from the editable command so
525            // users can type values immediately instead of backspacing
526            // `NAME`, `QUERY`, or `RUN_ID` out of the input line.
527            let prefill = hint
528                .split_whitespace()
529                .take_while(|token| {
530                    !token
531                        .chars()
532                        .all(|character| character.is_ascii_uppercase() || character == '_')
533                })
534                .collect::<Vec<_>>()
535                .join(" ");
536            if prefill.is_empty() || prefill == hint {
537                self.open_palette_with(hint);
538            } else {
539                self.open_palette_with(&format!("{prefill} "));
540            }
541        } else if hint == "i" {
542            if self.surface == DevSurface::Agent {
543                self.open_composer();
544            } else {
545                self.enter_code_edit();
546            }
547        } else if hint == "Enter" {
548            if self.surface == DevSurface::Code {
549                self.open_selected_file();
550            }
551        } else if hint == "d" && self.surface == DevSurface::Git {
552            self.git_diff_requested = true;
553            self.status = "Git diff queued · loading off-thread".into();
554        }
555        // Command-center entries must do what their visible hint promises.
556        // Do not make users close the center and repeat a key from another
557        // mode.
558        else {
559            match hint {
560                "n" => {
561                    self.surface = DevSurface::App;
562                    self.open_palette_with("browser navigate ");
563                }
564                "t" => {
565                    self.surface = DevSurface::App;
566                    self.open_palette_with("browser type ");
567                }
568                "v" => {
569                    self.surface = DevSurface::App;
570                    self.browser_visual_live = true;
571                    self.status = "Live view starting · v stops".into();
572                }
573                "agent update" if self.surface == DevSurface::Agent => {
574                    self.request_agent_update();
575                }
576                "s" if matches!(self.surface, DevSurface::Terminal | DevSurface::More) => {
577                    self.request_detected_dev();
578                }
579                "1" | "T" | "I" | "O" => self.handle_printable(hint.chars().next().unwrap()),
580                "Ctrl-S" if self.surface == DevSurface::Code => self.edit_code_key(
581                    crossterm::event::KeyCode::Char('s'),
582                    crossterm::event::KeyModifiers::CONTROL,
583                ),
584                _ => self.status = format!("{name} is available from this surface"),
585            }
586        }
587    }
588
589    pub fn move_menu_selection(&mut self, delta: i32) {
590        let count = self.surface_actions().len() as i32 + 2;
591        self.menu_selection =
592            (self.menu_selection as i32 + delta).rem_euclid(count.max(1)) as usize;
593    }
594
595    pub fn open_palette(&mut self) {
596        self.command_mode = true;
597        self.command_input.clear();
598        self.command_cursor = 0;
599        self.command_history_index = None;
600        self.palette_error = None;
601        let group = command::command_group_for(self.surface);
602        self.status = format!(
603            "Command search · {} routes first · Tab completes · Esc closes",
604            group.label
605        );
606    }
607
608    pub fn close_palette(&mut self) {
609        self.command_mode = false;
610        self.command_input.clear();
611        self.command_cursor = 0;
612        self.command_history_index = None;
613        self.palette_error = None;
614        self.status = "Command search cancelled · press a for guided launchers".into();
615    }
616
617    pub fn submit_palette(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
618        let input = std::mem::take(&mut self.command_input);
619        self.command_cursor = 0;
620        self.command_history_index = None;
621        self.command_mode = false;
622        if !input.trim().is_empty() && self.command_history.last() != Some(&input) {
623            self.command_history.push(input.clone());
624            if self.command_history.len() > 32 {
625                self.command_history.remove(0);
626            }
627        }
628        match command::execute(self, &input) {
629            Ok(message) => {
630                self.palette_error = None;
631                self.status = message;
632            }
633            Err(error) => {
634                self.palette_error = Some(error.clone());
635                self.status = format!("Error: {error}");
636            }
637        }
638        if let Some((call, context)) = self.queued_tool_request.take() {
639            match worker.submit_tool(call, context) {
640                Ok(id) => {
641                    self.running_tool_job = Some(id);
642                    self.status.push_str(" · running in background");
643                }
644                Err(error) => self.status = format!("Could not queue tool: {error}"),
645            }
646        }
647        worker.request_refresh();
648    }
649
650    pub fn insert_palette_char(&mut self, character: char) {
651        self.command_input.insert(self.command_cursor, character);
652        self.command_cursor += character.len_utf8();
653        self.palette_error = None;
654        self.command_history_index = None;
655    }
656
657    pub fn insert_palette_text(&mut self, text: &str) {
658        for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
659            self.insert_palette_char(character);
660        }
661    }
662
663    pub fn palette_backspace(&mut self) {
664        if self.command_cursor == 0 {
665            return;
666        }
667        let previous = self.command_input[..self.command_cursor]
668            .char_indices()
669            .next_back()
670            .map(|(index, _)| index)
671            .unwrap_or(0);
672        self.command_input.drain(previous..self.command_cursor);
673        self.command_cursor = previous;
674        self.command_history_index = None;
675    }
676
677    pub fn navigate_palette_history(&mut self, older: bool) {
678        if self.command_history.is_empty() {
679            return;
680        }
681        let last = self.command_history.len() - 1;
682        let index = match (self.command_history_index, older) {
683            (None, true) => last,
684            (None, false) => return,
685            (Some(index), true) => index.saturating_sub(1),
686            (Some(index), false) if index < last => index + 1,
687            (Some(_), false) => {
688                self.command_history_index = None;
689                self.command_input.clear();
690                self.command_cursor = 0;
691                return;
692            }
693        };
694        self.command_history_index = Some(index);
695        self.command_input.clone_from(&self.command_history[index]);
696        self.command_cursor = self.command_input.len();
697    }
698
699    pub fn complete_palette(&mut self) {
700        let Some(completion) = self.palette_matches().first().copied() else {
701            return;
702        };
703        let suffix = self
704            .command_input
705            .find(char::is_whitespace)
706            .map(|index| self.command_input[index..].to_string())
707            .unwrap_or_default();
708        self.command_input = format!("{completion}{suffix}");
709        self.command_cursor = self.command_input.len();
710        self.command_history_index = None;
711        self.status = format!("Completed `{completion}` · Enter runs · ↑/↓ history");
712    }
713
714    pub fn open_palette_with(&mut self, prefix: &str) {
715        self.open_palette();
716        self.command_input = prefix.into();
717        self.command_cursor = self.command_input.len();
718    }
719
720    pub fn move_palette_cursor(&mut self, right: bool) {
721        if right {
722            self.command_cursor = self.command_input[self.command_cursor..]
723                .char_indices()
724                .nth(1)
725                .map(|(offset, _)| self.command_cursor + offset)
726                .unwrap_or(self.command_input.len());
727        } else if self.command_cursor > 0 {
728            self.command_cursor = self.command_input[..self.command_cursor]
729                .char_indices()
730                .next_back()
731                .map(|(index, _)| index)
732                .unwrap_or(0);
733        }
734    }
735
736    pub fn palette_matches(&self) -> Vec<&'static str> {
737        let query = self
738            .command_input
739            .split_whitespace()
740            .next()
741            .unwrap_or_default();
742        command::palette_order(self.surface)
743            .into_iter()
744            .filter(|candidate| fuzzy_contains(candidate, query))
745            .take(6)
746            .collect()
747    }
748
749    pub fn background_action_running(&self) -> bool {
750        self.pending_confirmation.is_some()
751            || self.pending_agent_approval.is_some()
752            || self.running_tool_job.is_some()
753            || self.queued_tool_request.is_some()
754            || self.agent_send_job.is_some()
755    }
756
757    pub fn agent_browser_context(&self) -> serde_json::Value {
758        let semantic_summary = self.browser_workspace_summary();
759        let state = self.browser_workspace.state();
760        let selected_entity = state.selected().map(|entity| {
761            serde_json::json!({
762                "reference": entity.reference,
763                "role": entity.role,
764                "name": entity.name,
765                "actionable": entity.actionable,
766                "revision": entity.revision,
767            })
768        });
769        let selected_target = state
770            .targets
771            .iter()
772            .find(|target| target.selected)
773            .map(|target| {
774                serde_json::json!({
775                    "id": target.id,
776                    "title": target.title,
777                    "url": safe_browser_url(&target.url),
778                })
779            });
780        serde_json::json!({
781            "schemaVersion": "glass.agent-context.v1",
782            "browser": {
783                "attached": state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected,
784                "connection": serde_json::to_value(state.connection).unwrap_or(serde_json::Value::Null),
785                "targetId": selected_target.as_ref().and_then(|target| target.get("id")).cloned(),
786                "origin": page_origin(&state.url),
787                "url": safe_browser_url(&state.url),
788                "title": state.title,
789                "browserRevision": state.browser_revision,
790                "semanticSummary": semantic_summary,
791                "selectedEntity": selected_entity,
792                "workflowState": state.workflow,
793                "inputOwner": serde_json::to_value(state.input_owner).unwrap_or(serde_json::Value::Null),
794                "freshness": if state.semantic_invalidated { "stale" } else { "current" },
795                "target": selected_target,
796                "bootstrap": if state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected {
797                    "attached; observe before acting"
798                } else {
799                    "detached; call glass.browser.start, then navigate and observe the requested URL"
800                },
801            },
802            "authority": {
803                "source": "Glass browser workspace",
804                "mutationLeaseRequired": selected_entity.as_ref().is_some_and(|entity| {
805                    entity.get("actionable").and_then(serde_json::Value::as_bool).unwrap_or(false)
806                }),
807            },
808            "project": {
809                "root": self.snapshot_root,
810            },
811        })
812    }
813
814    pub fn browser_chat_header(&self) -> String {
815        let browser = self.browser_workspace.state();
816        let page = if browser.url.is_empty() {
817            "no page".to_string()
818        } else {
819            safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into())
820        };
821        let title = browser.title.trim();
822        let include_title = !title.is_empty() && !title.eq_ignore_ascii_case(&page);
823        let revision = browser
824            .browser_revision
825            .map_or_else(|| "—".to_string(), |revision| revision.to_string());
826        let bootstrap = if browser.connection
827            == glass_browser::browser_workspace::BrowserConnectionPhase::Connected
828        {
829            "observe before acting"
830        } else {
831            "ask `open <url>` to attach"
832        };
833        let mut header = format!("APP · {}", browser.connection_label());
834        if include_title {
835            header.push_str(" · ");
836            header.push_str(title);
837        }
838        header.push_str(&format!(" · {} · rev {} · {}", page, revision, bootstrap));
839        if let Some(entity) = browser.selected() {
840            header.push_str(" · selected ");
841            header.push_str(&entity.name);
842        }
843        header
844    }
845
846    pub fn conversation_view(&self) -> String {
847        let mut conversation = if self.agent_conversation.starts_with("No conversation yet.")
848            && !self.pending_chat_messages.is_empty()
849        {
850            String::new()
851        } else {
852            self.agent_conversation.clone()
853        };
854        for message in &self.pending_chat_messages {
855            if !conversation.is_empty() {
856                conversation.push_str("\n\n");
857            }
858            conversation.push_str("YOU\n");
859            conversation.push_str(&message.text);
860            conversation.push('\n');
861            match message.state {
862                ChatMessageState::Sending => conversation.push_str("· sending…"),
863                ChatMessageState::Sent => {
864                    conversation.push_str("· sent · Glass Agent is thinking…")
865                }
866                ChatMessageState::Failed => {
867                    conversation.push_str("× send failed");
868                    if let Some(error) = message.error.as_deref() {
869                        conversation.push_str(": ");
870                        conversation.push_str(error);
871                    }
872                    conversation.push_str(" · press Enter to retry");
873                }
874            }
875        }
876        conversation
877    }
878
879    fn reconcile_pending_chat(&mut self) {
880        let conversation = self.agent_conversation.clone();
881        let mut confirmed = std::collections::BTreeMap::<String, usize>::new();
882        self.pending_chat_messages.retain(|message| {
883            if message.state == ChatMessageState::Failed {
884                return true;
885            }
886            let marker = format!("YOU\n{}", message.text);
887            let observed = conversation.matches(&marker).count();
888            let seen = confirmed.entry(message.text.clone()).or_default();
889            if *seen < observed {
890                *seen += 1;
891                false
892            } else {
893                true
894            }
895        });
896    }
897
898    pub fn open_composer(&mut self) {
899        self.composer_mode = true;
900        self.composer_cursor = self.composer_input.len();
901        self.status = "Agent composer · Enter sends · draft stays open · Esc cancels".into();
902    }
903
904    pub fn toggle_composer_steer(&mut self) {
905        self.composer_steer = !self.composer_steer;
906        self.status = if self.composer_steer {
907            "Steer mode · Enter interrupts the running agent".into()
908        } else {
909            "Follow-up mode · Enter sends during or after the current turn".into()
910        };
911    }
912
913    /// Queue the managed Pi SDK install behind the same one-use confirmation
914    /// sheet used by every other mutating TUI action.
915    pub fn request_agent_setup(&mut self) {
916        self.request_agent_setup_mode(false);
917    }
918
919    /// Queue a forced reinstall of the pinned managed Pi SDK.
920    pub fn request_agent_update(&mut self) {
921        self.request_agent_setup_mode(true);
922    }
923
924    fn request_agent_setup_mode(&mut self, update: bool) {
925        if self.background_action_running() {
926            self.status = "Another background action is still running".into();
927            return;
928        }
929        let (call, context) = match self.tool_request(
930            "glass.agent.setup",
931            serde_json::json!({"login": false, "update": update}),
932            true,
933        ) {
934            Ok(request) => request,
935            Err(error) => {
936                self.status = if update {
937                    format!("Pi update unavailable: {error}")
938                } else {
939                    format!("Pi setup unavailable: {error}")
940                };
941                return;
942            }
943        };
944        self.pending_confirmation = Some(PendingConfirmation {
945            call,
946            context,
947            summary: if update {
948                "Refresh the pinned managed Pi SDK".into()
949            } else {
950                "Install or repair the pinned managed Pi SDK".into()
951            },
952        });
953        self.surface = DevSurface::Agent;
954        self.status = if update {
955            "Pi update ready · Enter approves once · Esc cancels".into()
956        } else {
957            "Pi setup ready · Enter approves once · Esc cancels".into()
958        };
959    }
960
961    /// Request an interactive Pi login; the outer TUI loop performs the
962    /// terminal handoff because the login program must own stdin.
963    pub fn request_agent_login(&mut self) -> Result<(), String> {
964        if self.background_action_running() {
965            let error = "Finish the current background action before signing in".to_string();
966            self.status = error.clone();
967            return Err(error);
968        }
969        self.agent_login_requested = true;
970        self.surface = DevSurface::Agent;
971        self.status = "Pi login will open in this terminal · exit Pi to return".into();
972        Ok(())
973    }
974
975    pub fn close_composer(&mut self) {
976        self.composer_mode = false;
977        self.composer_steer = false;
978        self.status = "Composer closed".into();
979    }
980
981    pub fn move_composer_cursor(&mut self, right: bool) {
982        if right {
983            self.composer_cursor = self.composer_input[self.composer_cursor..]
984                .char_indices()
985                .nth(1)
986                .map(|(offset, _)| self.composer_cursor + offset)
987                .unwrap_or(self.composer_input.len());
988        } else if self.composer_cursor > 0 {
989            self.composer_cursor = self.composer_input[..self.composer_cursor]
990                .char_indices()
991                .next_back()
992                .map(|(index, _)| index)
993                .unwrap_or(0);
994        }
995    }
996
997    pub fn delete_composer_word(&mut self) {
998        let before = self.composer_input[..self.composer_cursor].trim_end();
999        let start = before.len();
1000        let target = before[..start]
1001            .trim_end_matches(|c: char| c.is_whitespace())
1002            .char_indices()
1003            .rev()
1004            .find_map(|(index, character)| character.is_whitespace().then_some(index))
1005            .map(|index| before[..index].trim_end().len())
1006            .unwrap_or(0);
1007        self.composer_input.drain(target..self.composer_cursor);
1008        self.composer_cursor = target;
1009    }
1010
1011    pub fn abort_selected_agent(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1012        let Some(agent) = self.selected_agent.clone() else {
1013            self.status = "No active agent to abort".into();
1014            return;
1015        };
1016        let (call, context) = match self.tool_request(
1017            "glass.agent.abort",
1018            serde_json::json!({"agentId": agent.as_str()}),
1019            true,
1020        ) {
1021            Ok(request) => request,
1022            Err(error) => {
1023                self.status = format!("Abort unavailable: {error}");
1024                return;
1025            }
1026        };
1027        match worker.submit_tool(call, context) {
1028            Ok(id) => {
1029                self.running_tool_job = Some(id);
1030                self.status = format!("Stopping {} in background…", agent.as_str());
1031            }
1032            Err(error) => self.status = format!("Abort unavailable: {error}"),
1033        }
1034    }
1035
1036    pub fn insert_composer_text(&mut self, text: &str) {
1037        for character in text.chars().take(16_384) {
1038            self.composer_input.insert(self.composer_cursor, character);
1039            self.composer_cursor += character.len_utf8();
1040        }
1041    }
1042
1043    pub fn composer_backspace(&mut self) {
1044        if self.composer_cursor == 0 {
1045            return;
1046        }
1047        let previous = self.composer_input[..self.composer_cursor]
1048            .char_indices()
1049            .next_back()
1050            .map(|(index, _)| index)
1051            .unwrap_or(0);
1052        self.composer_input.drain(previous..self.composer_cursor);
1053        self.composer_cursor = previous;
1054    }
1055
1056    pub fn submit_composer(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1057        if self.background_action_running() {
1058            self.status = if self.agent_send_job.is_some() {
1059                "Sending the previous message · keep typing, then press Enter again".into()
1060            } else {
1061                "Background operation running · message kept in composer".into()
1062            };
1063            return;
1064        }
1065        if self.snapshot_trust_label == "untrusted" {
1066            self.composer_mode = false;
1067            self.surface = DevSurface::Trust;
1068            self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1069            return;
1070        }
1071        if !self.agent_readiness.starts_with("✓ Ready") {
1072            self.status = "Pi is not ready · press Esc, then s to install or l to sign in".into();
1073            return;
1074        }
1075        if self.composer_input.trim().is_empty() {
1076            self.status = "Message is empty · type a prompt, then press Enter".into();
1077            return;
1078        }
1079        let display_text = self.composer_input.clone();
1080        let text = std::mem::take(&mut self.composer_input);
1081        let steer = self.composer_steer;
1082        self.composer_cursor = 0;
1083        self.composer_steer = false;
1084        self.composer_mode = true;
1085        let context = self.agent_browser_context();
1086        if context["browser"]["selectedEntity"].is_object() {
1087            self.browser_workspace.state_mut().input_owner =
1088                glass_browser::browser_workspace::BrowserInputOwner::Agent;
1089        }
1090        let mut arguments = serde_json::json!({
1091            "text": text,
1092            "mode": if steer { "steer" } else { "follow-up" },
1093            "context": context,
1094        });
1095        if let Some(agent) = self.selected_agent.as_ref() {
1096            arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1097        }
1098        let (call, context) = match self.tool_request("glass.agent.send", arguments, true) {
1099            Ok(request) => request,
1100            Err(error) => {
1101                self.composer_input = display_text;
1102                self.composer_cursor = self.composer_input.len();
1103                self.status = format!("Message unavailable · edit and retry: {error}");
1104                return;
1105            }
1106        };
1107        match worker.submit_tool(call, context) {
1108            Ok(id) => {
1109                self.agent_send_job = Some(id);
1110                self.pending_chat_messages.push(PendingChatMessage {
1111                    text: display_text,
1112                    state: ChatMessageState::Sending,
1113                    job_id: Some(id),
1114                    error: None,
1115                });
1116                self.status = if steer {
1117                    "Sent · steering Glass Agent…".into()
1118                } else {
1119                    "Sent · Glass Agent is thinking…".into()
1120                };
1121                worker.request_conversation();
1122            }
1123            Err(error) => {
1124                self.composer_input = display_text;
1125                self.composer_cursor = self.composer_input.len();
1126                self.status = format!("Message unavailable · edit and retry: {error}");
1127            }
1128        }
1129    }
1130
1131    pub fn approve_confirmation_async(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1132        let Some(pending) = self.pending_confirmation.take() else {
1133            return;
1134        };
1135        match worker.submit_tool(pending.call, pending.context) {
1136            Ok(id) => {
1137                self.running_tool_job = Some(id);
1138                self.status = format!(
1139                    "Running {} · Esc keeps the workspace responsive",
1140                    pending.summary
1141                );
1142            }
1143            Err(error) => self.status = format!("Could not queue mutation: {error}"),
1144        }
1145    }
1146
1147    pub fn resolve_agent_approval(
1148        &mut self,
1149        approved: bool,
1150        worker: &mut super::snapshot::SnapshotWorker,
1151    ) {
1152        let Some(pending) = self.pending_agent_approval.take() else {
1153            return;
1154        };
1155        let arguments = serde_json::json!({
1156            "agentId": pending.agent_id,
1157            "frameId": pending.frame_id,
1158            "approved": approved,
1159        });
1160        let (call, context) = match self.tool_request("glass.agent.approve", arguments, true) {
1161            Ok(request) => request,
1162            Err(error) => {
1163                self.pending_agent_approval = Some(pending);
1164                self.status = format!("Agent approval unavailable: {error}");
1165                return;
1166            }
1167        };
1168        match worker.submit_tool(call, context) {
1169            Ok(id) => {
1170                self.running_tool_job = Some(id);
1171                self.status = if approved {
1172                    format!("Approved {} · Glass Agent continues…", pending.tool_name)
1173                } else {
1174                    format!("Denied {} · Glass Agent continues…", pending.tool_name)
1175                };
1176            }
1177            Err(error) => {
1178                self.pending_agent_approval = Some(pending);
1179                self.status = format!("Could not queue agent approval: {error}");
1180            }
1181        }
1182    }
1183
1184    pub fn apply_visual_job_result(&mut self, result: super::snapshot::VisualJobResult) {
1185        self.apply_visual_job_result_with_fit(
1186            result,
1187            glass_browser::terminal_graphics::FrameFit::Contain,
1188        );
1189    }
1190
1191    pub fn apply_visual_job_result_with_fit(
1192        &mut self,
1193        result: super::snapshot::VisualJobResult,
1194        fit: glass_browser::terminal_graphics::FrameFit,
1195    ) {
1196        let png = match result.result {
1197            Ok(value) => {
1198                let Some(encoded) = value.get("base64").and_then(serde_json::Value::as_str) else {
1199                    self.browser_visual_live = false;
1200                    self.browser_workspace.state_mut().presentation_reason =
1201                        Some("screenshot payload did not contain base64 PNG data".into());
1202                    self.status = "Live view unavailable · screenshot payload was empty".into();
1203                    return;
1204                };
1205                use base64::Engine as _;
1206                match base64::engine::general_purpose::STANDARD.decode(encoded) {
1207                    Ok(png) => png,
1208                    Err(error) => {
1209                        self.browser_visual_live = false;
1210                        self.browser_workspace.state_mut().presentation_reason =
1211                            Some(format!("screenshot payload was not valid base64: {error}"));
1212                        self.status = "Live view unavailable · invalid screenshot payload".into();
1213                        return;
1214                    }
1215                }
1216            }
1217            Err(error) => {
1218                self.browser_visual_live = false;
1219                self.browser_workspace.state_mut().presentation_reason =
1220                    Some(format!("browser screenshot failed: {error}"));
1221                self.status = format!("Live view unavailable · {error}");
1222                return;
1223            }
1224        };
1225        match AnsiPane::from_png(
1226            &mut self.browser_ansi,
1227            &png,
1228            result.columns.clamp(8, 80),
1229            result.rows.clamp(4, 40),
1230            fit,
1231        ) {
1232            Ok(pane) => {
1233                self.browser_pane = Some(pane);
1234                let browser = self.browser_workspace.state_mut();
1235                browser.presentation =
1236                    glass_browser::browser_workspace::BrowserPresentationPath::Ansi;
1237                browser.frame_revision = browser.browser_revision;
1238                browser.presentation_reason = Some(
1239                    "bounded ANSI half-block frame · semantic controls remain authoritative".into(),
1240                );
1241                self.status = "Live view updated · ANSI half-block".into();
1242            }
1243            Err(error) => {
1244                self.browser_visual_live = false;
1245                self.browser_workspace.state_mut().presentation_reason = Some(error.to_string());
1246                self.status = format!("Live view unavailable: {error}");
1247            }
1248        }
1249    }
1250
1251    pub fn queue_tool_request(
1252        &mut self,
1253        call: crate::development::ToolCall,
1254        context: crate::tools::DevelopmentToolContext,
1255    ) -> Result<(), String> {
1256        if self.background_action_running() {
1257            return Err("another background tool is already running".into());
1258        }
1259        self.queued_tool_request = Some((call, context));
1260        Ok(())
1261    }
1262
1263    pub fn apply_tool_job_result(&mut self, result: super::snapshot::ToolJobResult) {
1264        if result.tool == "glass.agent.send" && self.agent_send_job == Some(result.id) {
1265            self.agent_send_job = None;
1266            match result.result {
1267                Ok(value) => {
1268                    let agent = value
1269                        .get("agentId")
1270                        .and_then(serde_json::Value::as_str)
1271                        .and_then(|value| crate::AgentId::parse(value).ok());
1272                    let restarted = value
1273                        .get("restarted")
1274                        .and_then(serde_json::Value::as_bool)
1275                        .unwrap_or(false);
1276                    if let Some(agent_id) = agent {
1277                        self.selected_agent = Some(agent_id.clone());
1278                        self.status = if restarted {
1279                            format!("Restarted {} · Glass Agent is thinking…", agent_id.as_str())
1280                        } else {
1281                            format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str())
1282                        };
1283                    } else {
1284                        self.status = if restarted {
1285                            "Restarted Glass Agent · thinking…".into()
1286                        } else {
1287                            "Sent · Glass Agent is thinking…".into()
1288                        };
1289                    }
1290                    if let Some(message) = self
1291                        .pending_chat_messages
1292                        .iter_mut()
1293                        .find(|message| message.job_id == Some(result.id))
1294                    {
1295                        message.state = ChatMessageState::Sent;
1296                        message.job_id = None;
1297                    }
1298                }
1299                Err(error) => {
1300                    let failed_text = self
1301                        .pending_chat_messages
1302                        .iter_mut()
1303                        .find(|message| message.job_id == Some(result.id))
1304                        .map(|message| {
1305                            message.state = ChatMessageState::Failed;
1306                            message.job_id = None;
1307                            message.error = Some(error.clone());
1308                            message.text.clone()
1309                        });
1310                    if self.composer_input.is_empty()
1311                        && let Some(text) = failed_text
1312                    {
1313                        self.composer_input = text;
1314                        self.composer_cursor = self.composer_input.len();
1315                    }
1316                    self.composer_mode = true;
1317                    self.status = format!("Could not send message · edit and retry: {error}");
1318                }
1319            }
1320            return;
1321        }
1322
1323        if self.running_tool_job != Some(result.id) {
1324            return;
1325        }
1326        self.running_tool_job = None;
1327        match result.result {
1328            Ok(value) => {
1329                if result.tool.starts_with("glass.browser") {
1330                    self.apply_browser_result(&result.tool, &value);
1331                    self.browser_detail = super::projection::browser_result(&result.tool, &value);
1332                    if result.tool == "glass.browser.act" || result.tool == "glass.browser.navigate"
1333                    {
1334                        self.browser_observe_pending = true;
1335                    }
1336                } else if result.tool == "glass.git.diff" {
1337                    self.git_diff = value
1338                        .as_str()
1339                        .filter(|diff| !diff.trim().is_empty())
1340                        .unwrap_or("Working tree clean · no diff to show")
1341                        .to_string();
1342                    self.git_diff_open = true;
1343                    self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
1344                } else if result.tool == "glass.agent.setup" {
1345                    match self.refresh_agent_readiness() {
1346                        Ok(true) => {
1347                            self.status =
1348                                "Pi runtime ready · press l to sign in if no provider is selected"
1349                                    .into();
1350                        }
1351                        Ok(false) => {
1352                            self.status =
1353                                "Pi runtime installed · press l to sign in, then i to chat".into();
1354                        }
1355                        Err(error) => self.status = format!("Pi readiness check failed: {error}"),
1356                    }
1357                } else if result.tool == "glass.agent.send" {
1358                    if let Some(agent_id) = value
1359                        .get("agentId")
1360                        .and_then(serde_json::Value::as_str)
1361                        .and_then(|value| crate::AgentId::parse(value).ok())
1362                    {
1363                        self.selected_agent = Some(agent_id.clone());
1364                        self.status =
1365                            format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str());
1366                    } else {
1367                        self.status = "Sent · Glass Agent is thinking…".into();
1368                    }
1369                } else if result.tool.starts_with("glass.lsp") {
1370                    self.editor = if result.tool == "glass.lsp.diagnostics" {
1371                        super::projection::lsp(Some(&value))
1372                    } else {
1373                        super::projection::first_meaningful(&value)
1374                    };
1375                }
1376                if !matches!(
1377                    result.tool.as_str(),
1378                    "glass.agent.send" | "glass.agent.setup" | "glass.git.diff"
1379                ) {
1380                    self.status = format!("Completed {} · workspace refreshed", result.tool);
1381                }
1382            }
1383            Err(error) => {
1384                if result.tool.starts_with("glass.browser") {
1385                    self.note_browser_failure(&result.tool, &error);
1386                }
1387                if result.tool == "glass.git.diff" {
1388                    self.git_diff = format!("Git diff unavailable: {error}");
1389                    self.git_diff_open = true;
1390                }
1391                self.status = format!("{} failed: {error}", result.tool);
1392            }
1393        }
1394    }
1395
1396    pub fn deny_confirmation(&mut self) {
1397        if let Some(pending) = self.pending_confirmation.take() {
1398            self.status = format!("Denied · {}", pending.summary);
1399        }
1400    }
1401
1402    pub fn handle_printable(&mut self, character: char) {
1403        if self.surface == DevSurface::Trust {
1404            let decision = match character {
1405                'i' | 'I' => {
1406                    self.status = "Inspecting exact repository configuration".into();
1407                    return;
1408                }
1409                'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
1410                '1' => Some(crate::LocalTrustDecision::TrustOnce),
1411                'T' => Some(crate::LocalTrustDecision::TrustProject),
1412                _ => None,
1413            };
1414            if let Some(decision) = decision {
1415                match self
1416                    .workspace
1417                    .try_lock()
1418                    .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
1419                {
1420                    Ok(trust) => {
1421                        self.surface = DevSurface::Agent;
1422                        self.snapshot_trust_label = trust.label().into();
1423                        self.status = format!("Workspace opened with {} authority", trust.label());
1424                    }
1425                    Err(error) => self.status = format!("Trust decision failed: {error}"),
1426                }
1427                return;
1428            }
1429        }
1430        if self.surface == DevSurface::Agent && self.snapshot_trust_label == "untrusted" {
1431            let decision = match character {
1432                't' => Some(crate::LocalTrustDecision::TrustOnce),
1433                'T' => Some(crate::LocalTrustDecision::TrustProject),
1434                _ => None,
1435            };
1436            if let Some(decision) = decision {
1437                match self
1438                    .workspace
1439                    .try_lock()
1440                    .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
1441                {
1442                    Ok(trust) => {
1443                        self.snapshot_trust_label = trust.label().into();
1444                        self.status = format!("Workspace opened with {} authority", trust.label());
1445                    }
1446                    Err(error) => self.status = format!("Trust decision failed: {error}"),
1447                }
1448                return;
1449            }
1450        }
1451
1452        if self.responsive_class(self.terminal_width, self.terminal_height)
1453            == ResponsiveClass::Phone
1454        {
1455            let surface = match character {
1456                '1' => Some(DevSurface::Agent),
1457                '2' => Some(DevSurface::Code),
1458                '3' => Some(DevSurface::App),
1459                '4' => Some(DevSurface::Tasks),
1460                '5' => Some(DevSurface::More),
1461                _ => None,
1462            };
1463            if let Some(surface) = surface {
1464                self.surface = surface;
1465                self.status = format!("{} · a launcher · : routes", surface.label());
1466                return;
1467            }
1468        }
1469        let surface = match character {
1470            '1' => Some(DevSurface::Agent),
1471            '2' | 'c' => Some(DevSurface::Code),
1472            '3' | 'v' => Some(DevSurface::App),
1473            '4' => Some(DevSurface::Terminal),
1474            '5' | 'w' => Some(DevSurface::Tasks),
1475            '6' | 'g' => Some(DevSurface::Git),
1476            '7' | 'd' => Some(DevSurface::Debug),
1477            '8' | 'm' => Some(DevSurface::More),
1478            _ => None,
1479        };
1480        if let Some(surface) = surface {
1481            self.surface = surface;
1482            self.status = format!("{} · a launcher · : routes", surface.label());
1483        }
1484    }
1485    /// Queue the project-detected development command without making users
1486    /// copy it from project inspection into the command palette.
1487    pub fn request_detected_dev(&mut self) {
1488        if self.background_action_running() {
1489            self.status = "Another background action is still running".into();
1490            return;
1491        }
1492        let command_result = {
1493            match self.ws() {
1494                Ok(workspace) => workspace
1495                    .project()
1496                    .detection()
1497                    .dev_command
1498                    .clone()
1499                    .ok_or_else(|| "no detected dev command".to_string()),
1500                Err(error) => Err(error),
1501            }
1502        };
1503        let command = match command_result {
1504            Ok(command) => command,
1505            Err(error) if error == "no detected dev command" => {
1506                self.status =
1507                    "No development command detected · use :process start NAME COMMAND".into();
1508                return;
1509            }
1510            Err(error) => {
1511                self.status = format!("Development command unavailable: {error}");
1512                return;
1513            }
1514        };
1515        let (call, context) = match self.tool_request(
1516            "glass.process.start",
1517            serde_json::json!({"name": "dev", "command": command}),
1518            true,
1519        ) {
1520            Ok(request) => request,
1521            Err(error) => {
1522                self.status = format!("Development suite unavailable: {error}");
1523                return;
1524            }
1525        };
1526        self.pending_confirmation = Some(PendingConfirmation {
1527            call,
1528            context,
1529            summary: "Start the detected development suite".into(),
1530        });
1531        self.surface = DevSurface::Terminal;
1532        self.status = "Development suite ready · Enter approves once · Esc cancels".into();
1533    }
1534
1535    pub fn next_surface(&mut self) {
1536        let surfaces: &[DevSurface] = if self
1537            .responsive_class(self.terminal_width, self.terminal_height)
1538            == ResponsiveClass::Phone
1539        {
1540            &DevSurface::PHONE
1541        } else {
1542            &DevSurface::PRIMARY
1543        };
1544        let index = surfaces
1545            .iter()
1546            .position(|surface| *surface == self.surface)
1547            .unwrap_or(0);
1548        self.surface = surfaces[(index + 1) % surfaces.len()];
1549    }
1550
1551    pub fn scroll_surface(&mut self, delta: i32) {
1552        let scroll = self.surface_scroll.entry(self.surface).or_default();
1553        *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
1554    }
1555
1556    pub fn scroll_home(&mut self) {
1557        self.surface_scroll.insert(self.surface, 0);
1558    }
1559
1560    pub fn scroll_end(&mut self) {
1561        let end = self.surface_content_height().saturating_sub(1);
1562        self.surface_scroll.insert(self.surface, end);
1563    }
1564
1565    /// Bounded logical height of the current surface's content, used for End.
1566    fn surface_content_height(&self) -> usize {
1567        if self.surface == DevSurface::Agent {
1568            return self.conversation_view().lines().count().max(1);
1569        }
1570        let content = match self.surface {
1571            DevSurface::Code => &self.editor,
1572            DevSurface::App => &self.browser,
1573            DevSurface::Terminal => &self.processes,
1574            DevSurface::Tasks => &self.tasks,
1575            DevSurface::Git => &self.git,
1576            DevSurface::Debug => &self.debugger,
1577            DevSurface::More | DevSurface::Trust => &self.workspace_status,
1578            DevSurface::Agent => unreachable!("agent content handled above"),
1579        };
1580        content.lines().count().max(1)
1581    }
1582
1583    pub fn current_scroll(&self) -> u16 {
1584        self.surface_scroll
1585            .get(&self.surface)
1586            .copied()
1587            .unwrap_or(0)
1588            .min(u16::MAX as usize) as u16
1589    }
1590
1591    pub fn move_file_selection(&mut self, delta: i32) {
1592        if self.files.is_empty() {
1593            self.selected_file = 0;
1594            return;
1595        }
1596        self.selected_file = (self.selected_file as i32 + delta)
1597            .clamp(0, self.files.len().saturating_sub(1) as i32)
1598            as usize;
1599    }
1600
1601    pub fn open_selected_file(&mut self) {
1602        let Some(path) = self.files.get(self.selected_file).cloned() else {
1603            self.status = "No project file selected".into();
1604            return;
1605        };
1606        match self.workspace.try_lock().and_then(|mut workspace| {
1607            workspace
1608                .project_mut()
1609                .open_buffer(&path, crate::development::Actor::local())
1610        }) {
1611            Ok(_) => {
1612                self.status = format!("Opened {path} · press i to edit");
1613                self.refresh_editor_projection();
1614            }
1615            Err(error) => self.status = format!("Open failed: {error}"),
1616        }
1617    }
1618
1619    /// Load the current Git diff without blocking key handling.
1620    pub fn queue_git_diff(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1621        if self.background_action_running() {
1622            self.status = "Git diff waits for the current background operation".into();
1623            return;
1624        }
1625        let (call, context) =
1626            match self.tool_request("glass.git.diff", serde_json::json!({}), false) {
1627                Ok(request) => request,
1628                Err(error) => {
1629                    self.status = format!("Git diff unavailable: {error}");
1630                    return;
1631                }
1632            };
1633        match worker.submit_tool(call, context) {
1634            Ok(id) => {
1635                self.running_tool_job = Some(id);
1636                self.git_diff_open = true;
1637                self.git_diff = "Loading Git diff…".into();
1638                self.status = "Loading Git diff in background…".into();
1639            }
1640            Err(error) => self.status = format!("Git diff unavailable: {error}"),
1641        }
1642    }
1643
1644    /// Synchronous helper retained for callers outside the terminal event loop.
1645    pub fn open_git_diff(&mut self) {
1646        let diff = self.workspace.try_lock().and_then(|workspace| {
1647            workspace
1648                .git()
1649                .ok_or_else(|| {
1650                    crate::development::DevelopmentError::NotFound("not a Git repository".into())
1651                })?
1652                .diff(false, None)
1653                .map_err(|error| crate::development::DevelopmentError::Process(error.to_string()))
1654        });
1655        match diff {
1656            Ok(diff) if diff.trim().is_empty() => {
1657                self.git_diff = "Working tree clean · no diff to show".into();
1658                self.git_diff_open = true;
1659            }
1660            Ok(diff) => {
1661                self.git_diff = diff;
1662                self.git_diff_open = true;
1663                self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
1664            }
1665            Err(error) => self.status = format!("Git diff unavailable: {error}"),
1666        }
1667    }
1668
1669    pub fn close_git_diff(&mut self) {
1670        self.git_diff_open = false;
1671        self.git_diff_requested = false;
1672        self.status = "Git status".into();
1673    }
1674
1675    pub fn focused_buffer(&self) -> Option<crate::development::EditorBuffer> {
1676        self.workspace.try_lock().ok().and_then(|workspace| {
1677            workspace
1678                .project()
1679                .buffers()
1680                .nth(self.editor_buffer_index)
1681                .cloned()
1682        })
1683    }
1684
1685    pub fn refresh_editor_projection(&mut self) {
1686        let buffers = self
1687            .workspace
1688            .lock()
1689            .map(|workspace| workspace.project().buffers().cloned().collect::<Vec<_>>())
1690            .unwrap_or_default();
1691        if let Some(buffer) = buffers.get(self.editor_buffer_index) {
1692            self.focused_editor_path = buffer.path.clone();
1693            self.focused_editor_dirty = buffer.dirty;
1694            self.focused_editor_line = buffer.cursor_line;
1695        }
1696        self.editor = format_editor_buffers(&buffers);
1697    }
1698
1699    pub fn cycle_editor_buffer(&mut self, delta: i32) {
1700        let count = self
1701            .workspace
1702            .lock()
1703            .map(|workspace| workspace.project().buffers().count())
1704            .unwrap_or(0);
1705        if count == 0 {
1706            self.status = "No open buffers · open a file from the list".into();
1707            return;
1708        }
1709        let index = self.editor_buffer_index as i32 + delta;
1710        self.editor_buffer_index = index.rem_euclid(count as i32) as usize;
1711        let name = self
1712            .workspace
1713            .lock()
1714            .ok()
1715            .and_then(|workspace| {
1716                workspace
1717                    .project()
1718                    .buffers()
1719                    .nth(self.editor_buffer_index)
1720                    .map(|buffer| buffer.path.clone())
1721            })
1722            .unwrap_or_default();
1723        self.refresh_editor_projection();
1724        self.status = format!("Buffer {}/{} · {name}", self.editor_buffer_index + 1, count);
1725    }
1726
1727    pub fn enter_code_edit(&mut self) {
1728        let has_buffer = self.focused_buffer().is_some();
1729        if !has_buffer {
1730            self.open_selected_file();
1731        }
1732        let has_buffer = self.focused_buffer().is_some();
1733        if has_buffer {
1734            self.code_edit_mode = true;
1735            self.status =
1736                "EDIT · arrows move · Ctrl-S save · Ctrl-Z/Y undo/redo · Esc close".into();
1737        }
1738    }
1739
1740    pub fn close_code_edit(&mut self) {
1741        self.code_edit_mode = false;
1742        self.status = "Code navigation".into();
1743    }
1744
1745    pub fn edit_code_key(
1746        &mut self,
1747        code: crossterm::event::KeyCode,
1748        modifiers: crossterm::event::KeyModifiers,
1749    ) {
1750        let Some(buffer) = self.focused_buffer() else {
1751            self.status = "No open buffer".into();
1752            return;
1753        };
1754        let path = buffer.path.clone();
1755        let result = match (code, modifiers) {
1756            (crossterm::event::KeyCode::Char('s'), value)
1757                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
1758            {
1759                self.locked(|workspace| workspace.project_mut().save_buffer(&path).map(|_| ()))
1760                    .unwrap_or_else(|| {
1761                        Err(crate::development::DevelopmentError::Conflict(
1762                            "workspace lock failed".into(),
1763                        ))
1764                    })
1765            }
1766            (crossterm::event::KeyCode::Char('z'), value)
1767                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
1768            {
1769                self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()))
1770                    .unwrap_or_else(|| {
1771                        Err(crate::development::DevelopmentError::Conflict(
1772                            "workspace lock failed".into(),
1773                        ))
1774                    })
1775            }
1776            (crossterm::event::KeyCode::Char('y'), value)
1777                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
1778            {
1779                self.locked(|workspace| workspace.project_mut().redo_buffer(&path).map(|_| ()))
1780                    .unwrap_or_else(|| {
1781                        Err(crate::development::DevelopmentError::Conflict(
1782                            "workspace lock failed".into(),
1783                        ))
1784                    })
1785            }
1786            (crossterm::event::KeyCode::Left, _) => self.move_editor_cursor(&path, 0, -1),
1787            (crossterm::event::KeyCode::Right, _) => self.move_editor_cursor(&path, 0, 1),
1788            (crossterm::event::KeyCode::Up, _) => self.move_editor_cursor(&path, -1, 0),
1789            (crossterm::event::KeyCode::Down, _) => self.move_editor_cursor(&path, 1, 0),
1790            (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
1791            (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
1792            (crossterm::event::KeyCode::Char(character), _) => {
1793                self.insert_editor_text(&path, &character.to_string())
1794            }
1795            _ => Ok(()),
1796        };
1797        if let Err(error) = result {
1798            self.status = format!("Editor action failed: {error}");
1799        }
1800        self.refresh_editor_projection();
1801    }
1802
1803    fn move_editor_cursor(
1804        &mut self,
1805        path: &str,
1806        line_delta: i32,
1807        column_delta: i32,
1808    ) -> crate::development::DevelopmentResult<()> {
1809        let buffer = self
1810            .workspace
1811            .try_lock()?
1812            .project()
1813            .buffer(path)
1814            .cloned()
1815            .ok_or_else(|| {
1816                crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
1817            })?;
1818        let lines = buffer.content.split('\n').collect::<Vec<_>>();
1819        let line =
1820            (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
1821        let max_column = lines
1822            .get(line.saturating_sub(1) as usize)
1823            .map(|line| line.chars().count() + 1)
1824            .unwrap_or(1) as u32;
1825        let column = if line_delta != 0 {
1826            buffer.cursor_column.min(max_column)
1827        } else {
1828            (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
1829        };
1830        self.workspace
1831            .try_lock()?
1832            .project_mut()
1833            .set_buffer_cursor(path, line, column)
1834    }
1835
1836    fn insert_editor_text(
1837        &mut self,
1838        path: &str,
1839        text: &str,
1840    ) -> crate::development::DevelopmentResult<()> {
1841        let buffer = self
1842            .workspace
1843            .try_lock()?
1844            .project()
1845            .buffer(path)
1846            .cloned()
1847            .ok_or_else(|| {
1848                crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
1849            })?;
1850        let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
1851        let mut content = buffer.content.clone();
1852        content.insert_str(offset, text);
1853        self.workspace.try_lock()?.project_mut().edit_buffer(
1854            path,
1855            content,
1856            crate::development::Actor::local(),
1857        )?;
1858        let (line, column) = if text == "\n" {
1859            (buffer.cursor_line + 1, 1)
1860        } else {
1861            (
1862                buffer.cursor_line,
1863                buffer.cursor_column + text.chars().count() as u32,
1864            )
1865        };
1866        self.workspace
1867            .try_lock()?
1868            .project_mut()
1869            .set_buffer_cursor(path, line, column)
1870    }
1871
1872    fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
1873        let buffer = self
1874            .workspace
1875            .lock()?
1876            .project()
1877            .buffer(path)
1878            .cloned()
1879            .ok_or_else(|| {
1880                crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
1881            })?;
1882        let offset = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
1883        if offset == 0 {
1884            return Ok(());
1885        }
1886        let previous = buffer.content[..offset]
1887            .char_indices()
1888            .next_back()
1889            .map(|(index, _)| index)
1890            .unwrap_or(0);
1891        let removed_newline = &buffer.content[previous..offset] == "\n";
1892        let mut content = buffer.content.clone();
1893        content.drain(previous..offset);
1894        self.workspace.try_lock()?.project_mut().edit_buffer(
1895            path,
1896            content.clone(),
1897            crate::development::Actor::local(),
1898        )?;
1899        let (line, column) = if removed_newline {
1900            let line = buffer.cursor_line.saturating_sub(1).max(1);
1901            let column = content
1902                .split('\n')
1903                .nth(line.saturating_sub(1) as usize)
1904                .map(|line| line.chars().count() + 1)
1905                .unwrap_or(1) as u32;
1906            (line, column)
1907        } else {
1908            (
1909                buffer.cursor_line,
1910                buffer.cursor_column.saturating_sub(1).max(1),
1911            )
1912        };
1913        self.workspace
1914            .try_lock()?
1915            .project_mut()
1916            .set_buffer_cursor(path, line, column)
1917    }
1918
1919    pub fn previous_surface(&mut self) {
1920        let surfaces: &[DevSurface] = if self
1921            .responsive_class(self.terminal_width, self.terminal_height)
1922            == ResponsiveClass::Phone
1923        {
1924            &DevSurface::PHONE
1925        } else {
1926            &DevSurface::PRIMARY
1927        };
1928        let index = surfaces
1929            .iter()
1930            .position(|surface| *surface == self.surface)
1931            .unwrap_or(0);
1932        self.surface = surfaces[(index + surfaces.len() - 1) % surfaces.len()];
1933    }
1934
1935    /// Apply one background snapshot without touching UI-only fields.
1936    pub fn apply_snapshot(&mut self, snapshot: &super::snapshot::DisplaySnapshot) {
1937        self.refresh_latency_ms = snapshot.duration.as_millis() as u64;
1938        if let super::snapshot::BrowserHealth::Crashed {
1939            last_process_id,
1940            last_revision,
1941        } = &snapshot.browser_health
1942            && self.browser_recovery.is_none()
1943        {
1944            let pid_label = last_process_id
1945                .map(|pid| pid.to_string())
1946                .unwrap_or_else(|| "unknown".into());
1947            let revision_label = last_revision
1948                .map(|revision| revision.to_string())
1949                .unwrap_or_else(|| "none".into());
1950            self.surface = DevSurface::App;
1951            self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
1952                &format!(
1953                    "browser endpoint crashed unexpectedly (pid {pid_label}, last revision {revision_label})"
1954                ),
1955                9222,
1956            ));
1957            self.browser_workspace
1958                .disconnected("browser endpoint crashed".to_string(), true);
1959            self.status = "Browser endpoint crashed · recovery choices below".into();
1960        }
1961        self.agents = snapshot.agents.clone();
1962        self.agent_conversation = snapshot.agent_conversation.clone();
1963        self.reconcile_pending_chat();
1964        self.tasks = snapshot.tasks.clone();
1965        self.editor = snapshot.editor.clone();
1966        self.lsp = snapshot.lsp.clone();
1967        self.processes = snapshot.processes.clone();
1968        self.git = snapshot.git.clone();
1969        self.tests = snapshot.tests.clone();
1970        self.kernels = snapshot.kernels.clone();
1971        self.debugger = snapshot.debugger.clone();
1972        self.replay = snapshot.replay.clone();
1973        self.workflow = snapshot.workflow.clone();
1974        self.workspace_status = snapshot.workspace_status.clone();
1975        self.browser = snapshot.browser.clone();
1976        self.snapshot_root = snapshot.root.clone();
1977        self.snapshot_trust_label = snapshot.trust_label.clone();
1978        self.snapshot_trust_inspection = snapshot.trust_inspection.clone();
1979        self.snapshot_project_revision = snapshot.project_revision;
1980        self.snapshot_generation = snapshot.generation;
1981        self.snapshot_skills_count = snapshot.skills_count;
1982        self.snapshot_tools_count = snapshot.tools_count;
1983        self.experiments = snapshot.experiments.clone();
1984        if !snapshot.files.is_empty() {
1985            self.files = snapshot.files.clone();
1986            if !self.files.is_empty() {
1987                self.selected_file = self.selected_file.min(self.files.len() - 1);
1988            }
1989        }
1990    }
1991
1992    pub fn set_terminal_size(&mut self, width: u16, height: u16) {
1993        self.terminal_width = width;
1994        self.terminal_height = height;
1995    }
1996
1997    pub fn refresh(&mut self) {
1998        let Ok(mut workspace) = self.workspace.try_lock() else {
1999            self.status = "Workspace lock failed".into();
2000            return;
2001        };
2002        self.files = workspace
2003            .project()
2004            .list_files()
2005            .map(|entries| {
2006                entries
2007                    .into_iter()
2008                    .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
2009                    .map(|entry| entry.path)
2010                    .take(512)
2011                    .collect()
2012            })
2013            .unwrap_or_default();
2014        if !self.files.is_empty() {
2015            self.selected_file = self.selected_file.min(self.files.len() - 1);
2016        }
2017        let agent_snapshots = workspace.agents().list();
2018        self.pending_agent_approval = pending_agent_approval(agent_snapshots.as_ref().ok());
2019        self.agents = match agent_snapshots {
2020            Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
2021            Ok(agents) => agents
2022                .iter()
2023                .map(|agent| {
2024                    format!(
2025                        "{}  {}  {} · {}\n  target {} · model {} · thinking {} · events {} · dropped {}{}\n  evidence {}",
2026                        agent.id.as_str(),
2027                        agent.status.label(),
2028                        agent.role,
2029                        agent.task,
2030                        agent.worktree.display(),
2031                        agent.model.as_deref().unwrap_or("default"),
2032                        agent.thinking.as_deref().unwrap_or("default"),
2033                        agent.event_count,
2034                        agent.dropped_event_count,
2035                        agent
2036                            .last_error
2037                            .as_deref()
2038                            .map(|error| format!(" · {error}"))
2039                            .unwrap_or_default(),
2040                        agent
2041                            .evidence
2042                            .iter()
2043                            .rev()
2044                            .take(3)
2045                            .map(|evidence| evidence.to_string())
2046                            .collect::<Vec<_>>()
2047                            .join(" · ")
2048                    )
2049                })
2050                .collect::<Vec<_>>()
2051                .join("\n\n"),
2052            Err(error) => format!("Agent registry failed: {error}"),
2053        };
2054        self.agent_conversation = match workspace.agents().history(0) {
2055            Ok(events) if events.is_empty() => {
2056                "No conversation yet. Press i to compose a message.".into()
2057            }
2058            Ok(events) => super::projection::conversation(
2059                &events
2060                    .iter()
2061                    .rev()
2062                    .take(40)
2063                    .rev()
2064                    .cloned()
2065                    .collect::<Vec<_>>(),
2066            ),
2067            Err(error) => format!("Conversation unavailable · {error}"),
2068        };
2069        self.tasks = match workspace.tasks() {
2070            Ok(tasks) if tasks.is_empty() => {
2071                "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
2072            }
2073            Ok(tasks) => tasks
2074                .iter()
2075                .map(|task| {
2076                    let glyph = match task.state {
2077                        crate::TaskState::Succeeded
2078                            if task.verification == crate::VerificationRequirement::Settled => "◇",
2079                        crate::TaskState::Succeeded => "✓",
2080                        crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
2081                        crate::TaskState::Blocked => "!",
2082                        crate::TaskState::Running | crate::TaskState::Verifying => "●",
2083                        _ => "○",
2084                    };
2085                    format!(
2086                        "{} {}  {}  {}\n  goal {}\n  agent {} · attempt {} · model {} · thinking {}\n  depends {}\n  verification {}{}\n  evidence {}",
2087                        glyph,
2088                        task.id.as_str(),
2089                        task.state.label(),
2090                        task.title,
2091                        task.goal,
2092                        task.assigned_agent
2093                            .as_ref()
2094                            .map(|agent| agent.as_str())
2095                            .unwrap_or("unassigned"),
2096                        task.attempt,
2097                        task.model.as_deref().unwrap_or("default"),
2098                        task.thinking.as_deref().unwrap_or("default"),
2099                        task.dependencies
2100                            .iter()
2101                            .map(|dependency| dependency.as_str())
2102                            .collect::<Vec<_>>()
2103                            .join(", "),
2104                        serde_json::to_string(&task.verification).unwrap_or_default(),
2105                        task.last_error
2106                            .as_deref()
2107                            .map(|error| format!(" · {error}"))
2108                            .unwrap_or_default(),
2109                        task.evidence
2110                            .iter()
2111                            .rev()
2112                            .take(3)
2113                            .map(|evidence| {
2114                                format!(
2115                                    "{}={}",
2116                                    evidence.kind,
2117                                    evidence.passed.map_or("?".into(), |passed| passed.to_string())
2118                                )
2119                            })
2120                            .collect::<Vec<_>>()
2121                            .join(" · ")
2122                    )
2123                })
2124                .collect::<Vec<_>>()
2125                .join("\n\n"),
2126            Err(error) => format!("Task scheduler failed: {error}"),
2127        };
2128        self.processes = workspace
2129            .project_mut()
2130            .processes()
2131            .list_checked()
2132            .map(|items| {
2133                if items.is_empty() {
2134                    "No managed terminals. Start the detected development command from More.".into()
2135                } else {
2136                    items
2137                        .into_iter()
2138                        .map(|item| {
2139                            format!(
2140                                "{} {} · health {} · pid {} · {}\n  {}",
2141                                if matches!(item.health, crate::development::ProcessHealth::Healthy)
2142                                {
2143                                    "●"
2144                                } else {
2145                                    "○"
2146                                },
2147                                item.name,
2148                                item.health.label(),
2149                                item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
2150                                if item.pty { "PTY" } else { "pipes" },
2151                                item.detected_urls
2152                                    .first()
2153                                    .map_or(item.command.as_str(), String::as_str),
2154                            )
2155                        })
2156                        .collect::<Vec<_>>()
2157                        .join("\n\n")
2158                }
2159            })
2160            .unwrap_or_else(|error| format!("Process state failed: {error}"));
2161        let buffers = workspace.project().buffers().cloned().collect::<Vec<_>>();
2162        self.editor = if buffers.is_empty() {
2163            "No file open. Select a file below and press Enter, then i to edit.".into()
2164        } else {
2165            buffers
2166                .iter()
2167                .map(|buffer| {
2168                    // Viewport follows the cursor; long files stay editable.
2169                    let lines: Vec<&str> = buffer.content.lines().collect();
2170                    let cursor = buffer.cursor_line as usize;
2171                    let viewport_rows = 16;
2172                    let start = cursor
2173                        .saturating_sub(viewport_rows / 2)
2174                        .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
2175                    let end = (start + viewport_rows).min(lines.len());
2176                    let gutter_width = lines.len().to_string().len().max(3);
2177                    let viewport = lines[start..end]
2178                        .iter()
2179                        .enumerate()
2180                        .map(|(index, line)| {
2181                            let number = start + index + 1;
2182                            let marker = if number == cursor { "▶" } else { " " };
2183                            format!(
2184                                "{marker}{:>gutter_width$} │ {line}",
2185                                number,
2186                                gutter_width = gutter_width
2187                            )
2188                        })
2189                        .collect::<Vec<_>>()
2190                        .join("\n");
2191                    format!(
2192                        "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
2193                        if buffer.dirty { "● " } else { "○ " },
2194                        buffer.path,
2195                        buffer.cursor_line,
2196                        buffer.cursor_column,
2197                        buffer.actor.id,
2198                        lines.len(),
2199                        viewport
2200                    )
2201                })
2202                .collect::<Vec<_>>()
2203                .join("\n\n")
2204        };
2205        self.lsp = {
2206            let language = workspace.language();
2207            let servers = language.names().collect::<Vec<_>>();
2208            let event_count = language.events(0).len();
2209            if servers.is_empty() {
2210                "No language server active · diagnostics unavailable".into()
2211            } else {
2212                format!("● {} · {} recent events", servers.join(" · "), event_count)
2213            }
2214        };
2215        self.git = workspace
2216            .git()
2217            .map(|git| match git.status() {
2218                Ok(status) => {
2219                    let header = format!(
2220                        "branch {} · ↑{} ↓{} · upstream {}",
2221                        status.branch.as_deref().unwrap_or("detached"),
2222                        status.ahead,
2223                        status.behind,
2224                        status.upstream.as_deref().unwrap_or("none")
2225                    );
2226                    let entries = status
2227                        .entries
2228                        .iter()
2229                        .map(|entry| {
2230                            format!(
2231                                "{}{} {}{}",
2232                                if entry.untracked { "?" } else { "●" },
2233                                if status.conflicts.contains(&entry.path) {
2234                                    "!"
2235                                } else {
2236                                    " "
2237                                },
2238                                entry.index_status,
2239                                entry.path
2240                            )
2241                        })
2242                        .collect::<Vec<_>>();
2243                    if entries.is_empty() {
2244                        format!("{header}\n✓ working tree clean")
2245                    } else {
2246                        format!("{header}\n{}", entries.join("\n"))
2247                    }
2248                }
2249                Err(error) => format!("Git state failed: {error}"),
2250            })
2251            .unwrap_or_else(|| "Not a Git repository".into());
2252        let _ = workspace.tests_mut().poll();
2253        let test_runs = workspace
2254            .tests()
2255            .results()
2256            .rev()
2257            .take(32)
2258            .collect::<Vec<_>>();
2259        self.tests = if test_runs.is_empty() {
2260            "No test runs".into()
2261        } else {
2262            test_runs
2263                .iter()
2264                .map(|run| {
2265                    format!(
2266                        "{} {} · {} · {} ms · {} cases",
2267                        if run.exit_code == Some(0) {
2268                            "✓"
2269                        } else {
2270                            "×"
2271                        },
2272                        run.suite_id,
2273                        run.state.label(),
2274                        run.duration_ms.unwrap_or_default(),
2275                        run.cases.len()
2276                    )
2277                })
2278                .collect::<Vec<_>>()
2279                .join("\n")
2280        };
2281        let kernels = workspace.kernels().snapshots().collect::<Vec<_>>();
2282        self.kernels = if kernels.is_empty() {
2283            "No persistent kernels".into()
2284        } else {
2285            kernels
2286                .iter()
2287                .map(|kernel| {
2288                    format!(
2289                        "{} {} · {} · {} executions · rev {}",
2290                        if matches!(kernel.state, crate::kernels::KernelState::Ready) {
2291                            "●"
2292                        } else {
2293                            "○"
2294                        },
2295                        kernel.name,
2296                        kernel.kind.label(),
2297                        kernel.executions,
2298                        kernel.workspace_revision
2299                    )
2300                })
2301                .collect::<Vec<_>>()
2302                .join("\n")
2303        };
2304        let debugger_names = workspace
2305            .debugger_names()
2306            .map(str::to_string)
2307            .collect::<Vec<_>>();
2308        self.debugger = if debugger_names.is_empty() {
2309            "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
2310        } else {
2311            let snapshots: Result<Vec<_>, _> = debugger_names
2312                .iter()
2313                .map(|name| {
2314                    workspace
2315                        .debugger_mut(name)
2316                        .and_then(|debugger| debugger.snapshot())
2317                        .map(|snapshot| (name.to_string(), snapshot))
2318                })
2319                .collect();
2320            match snapshots {
2321                Ok(snapshots) => snapshots
2322                    .iter()
2323                    .map(|(name, snapshot)| {
2324                        format!(
2325                            "● {} · {} · pid {} · {} breakpoints · {} watches · {} threads/processes",
2326                            name,
2327                            match snapshot.state {
2328                                crate::debugger::DebugSessionState::Starting => "starting",
2329                                crate::debugger::DebugSessionState::Initialized => "initialized",
2330                                crate::debugger::DebugSessionState::Running => "running",
2331                                crate::debugger::DebugSessionState::Stopped => "stopped",
2332                                crate::debugger::DebugSessionState::Terminated => "terminated",
2333                                crate::debugger::DebugSessionState::Failed => "failed",
2334                            },
2335                            snapshot.adapter_process_id,
2336                            snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
2337                            snapshot.watches.len(),
2338                            snapshot.debuggee_processes.len()
2339                        )
2340                    })
2341                    .collect::<Vec<_>>()
2342                    .join("\n"),
2343                Err(error) => format!("Debugger state failed: {error}"),
2344            }
2345        };
2346        self.replay = workspace
2347            .intelligence()
2348            .replay(0, 128)
2349            .map(|events| {
2350                if events.is_empty() {
2351                    "No observable replay events".into()
2352                } else {
2353                    events
2354                        .iter()
2355                        .rev()
2356                        .take(24)
2357                        .rev()
2358                        .map(|event| {
2359                            format!(
2360                                "{} {} · {} · {} · rev {}",
2361                                event.sequence,
2362                                event.actor,
2363                                event.subsystem,
2364                                event.kind,
2365                                event.workspace_revision
2366                            )
2367                        })
2368                        .collect::<Vec<_>>()
2369                        .join("\n")
2370                }
2371            })
2372            .unwrap_or_else(|error| format!("Replay failed: {error}"));
2373        self.browser = match workspace.browser().state() {
2374            Ok(state) => {
2375                let connected = state
2376                    .get("connected")
2377                    .and_then(serde_json::Value::as_bool)
2378                    .unwrap_or(false);
2379                let revision = state
2380                    .get("browserRevision")
2381                    .and_then(serde_json::Value::as_u64);
2382                if connected {
2383                    if self.browser_workspace.state().connection
2384                        != BrowserConnectionPhase::Connected
2385                    {
2386                        self.browser_workspace.connected(true, None, revision);
2387                    } else if let Some(revision) = revision {
2388                        self.browser_workspace.state_mut().browser_revision = Some(revision);
2389                    }
2390                } else {
2391                    self.browser_workspace.state_mut().connection =
2392                        BrowserConnectionPhase::Detached;
2393                }
2394                self.browser_workspace_summary()
2395            }
2396            Err(error) => format!("Browser state failed: {error}"),
2397        };
2398        self.workflow = workspace
2399            .browser()
2400            .list_workflows()
2401            .map(|state| super::projection::workflow(Some(&state)))
2402            .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
2403        let root = workspace.root().display().to_string();
2404        let generation = workspace.generation();
2405        let project_revision = workspace.project().revision();
2406        let agent_count = workspace
2407            .agents()
2408            .list()
2409            .map(|items| items.len())
2410            .unwrap_or(0);
2411        let task_count = workspace.tasks().map(|items| items.len()).unwrap_or(0);
2412        let kernel_count = workspace.kernels().snapshots().count();
2413        let debugger_count = workspace.debugger_names().count();
2414        let detection = workspace.project().detection().clone();
2415        let trust = workspace.trust();
2416        let trust_ready = trust.permits_project_execution();
2417        let dev_hint = detection
2418            .dev_command
2419            .as_deref()
2420            .map(|command| format!("● run `{command}`"))
2421            .unwrap_or_else(|| "○ configure a dev command".into());
2422        let app_hint = detection
2423            .browser_url
2424            .as_deref()
2425            .map(|url| format!("● open App {url}"))
2426            .unwrap_or_else(|| "○ start App after a URL is detected".into());
2427        let project_line = if detection.languages.is_empty() {
2428            "○ project type unknown".to_string()
2429        } else {
2430            format!("✓ {} project", detection.languages.join("/"))
2431        };
2432        let workspace_line = format!("✓ workspace {}", trust.label());
2433        let agent_hint = if self.agent_readiness.starts_with("✓ Ready") {
2434            "✓ Glass Agent ready · [i] chat"
2435        } else {
2436            "○ Pi onboarding · [s] install · [l] sign in"
2437        };
2438        self.workspace_status = format!(
2439            "WELCOME · {}\n{}\n\n{}\n{}\n\nNEXT ACTIONS\n◆ [a] actions menu · per-surface flows\n◆ [i] talk to Glass Agent\n◆ [4] terminal · [s] 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",
2440            detection.git_branch.as_deref().unwrap_or("no branch"),
2441            project_line,
2442            agent_hint,
2443            workspace_line,
2444            dev_hint,
2445            app_hint,
2446            root,
2447            generation,
2448            project_revision,
2449            trust_ready,
2450            agent_count,
2451            task_count,
2452            kernel_count,
2453            debugger_count,
2454        );
2455        if workspace.trust().permits_project_execution()
2456            && let Ok(experiments) = workspace.experiments()
2457        {
2458            let snapshots = experiments.snapshots();
2459            self.experiments = if snapshots.is_empty() {
2460                "No experiments".into()
2461            } else {
2462                snapshots
2463                    .iter()
2464                    .map(|experiment| {
2465                        format!(
2466                            "{} {} · {} · port {} · agent {}",
2467                            if experiment.evidence.tests_failed == 0
2468                                && experiment.evidence.tests_passed > 0
2469                            {
2470                                "✓"
2471                            } else {
2472                                "○"
2473                            },
2474                            experiment.id,
2475                            experiment.state.label(),
2476                            experiment
2477                                .port
2478                                .map_or_else(|| "—".into(), |port| port.to_string()),
2479                            experiment
2480                                .agent_id
2481                                .as_ref()
2482                                .map(|id| id.as_str())
2483                                .unwrap_or("none")
2484                        )
2485                    })
2486                    .collect::<Vec<_>>()
2487                    .join("\n")
2488            };
2489            self.experiment_comparison = Some(experiments.compare());
2490        }
2491        drop(workspace);
2492        self.reconcile_pending_chat();
2493    }
2494
2495    pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
2496        match tool {
2497            "glass.browser.observe" => {
2498                let revision = result
2499                    .pointer("/accessibility/revision")
2500                    .and_then(serde_json::Value::as_u64);
2501                let title = result
2502                    .pointer("/page/title")
2503                    .and_then(serde_json::Value::as_str)
2504                    .unwrap_or("Untitled");
2505                let url = result
2506                    .pointer("/page/url")
2507                    .and_then(serde_json::Value::as_str)
2508                    .unwrap_or_default();
2509                let loading = result
2510                    .pointer("/page/loading")
2511                    .and_then(serde_json::Value::as_bool)
2512                    .unwrap_or(false);
2513                if let Some(revision) = revision {
2514                    self.browser_workspace
2515                        .update_page(title, url, loading, Some(revision));
2516                    let entities = result
2517                        .pointer("/accessibility/interactive")
2518                        .and_then(serde_json::Value::as_array)
2519                        .into_iter()
2520                        .flatten()
2521                        .filter_map(|entity| {
2522                            Some(BrowserWorkspaceEntity {
2523                                reference: entity.get("reference")?.as_str()?.into(),
2524                                role: entity
2525                                    .get("role")
2526                                    .and_then(serde_json::Value::as_str)
2527                                    .unwrap_or("unknown")
2528                                    .into(),
2529                                name: entity
2530                                    .get("name")
2531                                    .and_then(serde_json::Value::as_str)
2532                                    .unwrap_or("unnamed")
2533                                    .into(),
2534                                actionable: entity
2535                                    .get("actionable")
2536                                    .and_then(serde_json::Value::as_bool)
2537                                    .unwrap_or(true),
2538                                revision,
2539                            })
2540                        })
2541                        .collect();
2542                    self.browser_workspace.replace_entities(revision, entities);
2543                }
2544            }
2545            "glass.browser.targets" => {
2546                let values = result
2547                    .get("targets")
2548                    .and_then(serde_json::Value::as_array)
2549                    .or_else(|| result.as_array());
2550                let targets = values
2551                    .into_iter()
2552                    .flatten()
2553                    .filter_map(|target| {
2554                        Some(BrowserWorkspaceTarget {
2555                            id: target.get("id")?.as_str()?.into(),
2556                            title: target
2557                                .get("title")
2558                                .and_then(serde_json::Value::as_str)
2559                                .unwrap_or("Untitled")
2560                                .into(),
2561                            url: target
2562                                .get("url")
2563                                .and_then(serde_json::Value::as_str)
2564                                .unwrap_or_default()
2565                                .into(),
2566                            selected: target
2567                                .get("active")
2568                                .and_then(serde_json::Value::as_bool)
2569                                .unwrap_or(false),
2570                        })
2571                    })
2572                    .collect();
2573                self.browser_workspace.replace_targets(targets);
2574                if self.browser_target_picker_requested {
2575                    self.browser_target_picker_requested = false;
2576                    self.browser_target_picker = true;
2577                    self.browser_target_selection = 0;
2578                    self.status = if self.browser_workspace.state().targets.is_empty() {
2579                        "No page targets found · Esc closes".into()
2580                    } else {
2581                        "Target picker · type to filter · j/k select · Enter choose · Esc close"
2582                            .into()
2583                    };
2584                }
2585            }
2586            "glass.browser.target.select" => {
2587                if let Some(target_id) = result
2588                    .pointer("/target/id")
2589                    .and_then(serde_json::Value::as_str)
2590                {
2591                    let mut targets = self.browser_workspace.state().targets.clone();
2592                    for target in &mut targets {
2593                        target.selected = target.id == target_id;
2594                    }
2595                    self.browser_workspace.replace_targets(targets);
2596                }
2597                if let Some(observation) = result.get("observation") {
2598                    self.apply_browser_result("glass.browser.observe", observation);
2599                }
2600            }
2601            "glass.browser.start" => {
2602                let connected = result
2603                    .get("connected")
2604                    .and_then(serde_json::Value::as_bool)
2605                    .unwrap_or(true);
2606                let revision = result
2607                    .get("browserRevision")
2608                    .and_then(serde_json::Value::as_u64);
2609                if connected {
2610                    self.browser_workspace.connected(true, None, revision);
2611                    self.browser_recovery = None;
2612                }
2613            }
2614            "glass.browser.stop" => {
2615                self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
2616            }
2617            _ => {}
2618        }
2619        self.browser = self.browser_workspace_summary();
2620    }
2621
2622    pub fn browser_workspace_summary(&self) -> String {
2623        let browser = self.browser_workspace.state();
2624        let entities = if browser.entities.is_empty() {
2625            "No current semantic entities".into()
2626        } else {
2627            browser
2628                .entities
2629                .iter()
2630                .enumerate()
2631                .skip(browser.semantic_scroll)
2632                .take(24)
2633                .map(|(index, entity)| {
2634                    format!(
2635                        "{} {} · {} · {}",
2636                        if Some(index) == browser.selected_entity {
2637                            "◆"
2638                        } else {
2639                            "○"
2640                        },
2641                        entity.name,
2642                        entity.role,
2643                        entity.reference
2644                    )
2645                })
2646                .collect::<Vec<_>>()
2647                .join("\n")
2648        };
2649        let targets = if browser.targets.is_empty() {
2650            "No page targets loaded · use `browser targets`".into()
2651        } else {
2652            browser
2653                .targets
2654                .iter()
2655                .take(8)
2656                .map(|target| {
2657                    format!(
2658                        "{} {} · {}",
2659                        if target.selected { "◆" } else { "○" },
2660                        target.title,
2661                        safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into())
2662                    )
2663                })
2664                .collect::<Vec<_>>()
2665                .join("\n")
2666        };
2667        format!(
2668            "{} · rev {} · {} · owner {}\n{}\n{}\n\nTARGETS\n{}\n\nUNDERSTANDING\n{}\n\nWORKFLOW\n{}",
2669            browser.connection_label(),
2670            browser
2671                .browser_revision
2672                .map_or_else(|| "—".into(), |revision| revision.to_string()),
2673            browser.presentation_label(),
2674            browser.input_owner_label(),
2675            browser.title,
2676            safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into()),
2677            targets,
2678            entities,
2679            browser.workflow
2680        )
2681    }
2682
2683    pub fn queue_browser_targets(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2684        if self.background_action_running() {
2685            self.status = "Target picker waits for the current background operation".into();
2686            return;
2687        }
2688        if let Err(error) = self.request_browser_target_picker("") {
2689            self.status = format!("Could not load browser targets: {error}");
2690            return;
2691        }
2692        let Some((call, context)) = self.queued_tool_request.take() else {
2693            return;
2694        };
2695        match worker.submit_tool(call, context) {
2696            Ok(id) => {
2697                self.running_tool_job = Some(id);
2698                self.status = "Loading browser targets…".into();
2699            }
2700            Err(error) => {
2701                self.browser_target_picker_requested = false;
2702                self.status = format!("Could not load browser targets: {error}");
2703            }
2704        }
2705    }
2706
2707    pub fn request_browser_target_picker(
2708        &mut self,
2709        query: impl Into<String>,
2710    ) -> Result<(), String> {
2711        if self.background_action_running() {
2712            return Err("Target picker waits for the current background operation".into());
2713        }
2714        self.browser_target_query = query.into();
2715        self.browser_target_selection = 0;
2716        self.browser_target_picker = false;
2717        self.browser_target_picker_requested = true;
2718        let (call, context) =
2719            match self.tool_request("glass.browser.targets", serde_json::json!({}), false) {
2720                Ok(request) => request,
2721                Err(error) => {
2722                    self.browser_target_picker_requested = false;
2723                    return Err(error);
2724                }
2725            };
2726        self.queued_tool_request = Some((call, context));
2727        self.status = "Loading browser targets…".into();
2728        Ok(())
2729    }
2730
2731    pub fn close_browser_target_picker(&mut self) {
2732        self.browser_target_picker = false;
2733        self.browser_target_picker_requested = false;
2734        self.status = "Target picker closed".into();
2735    }
2736
2737    pub fn browser_target_matches(&self) -> Vec<usize> {
2738        let query = self.browser_target_query.to_ascii_lowercase();
2739        let terms = query.split_whitespace().collect::<Vec<_>>();
2740        self.browser_workspace
2741            .state()
2742            .targets
2743            .iter()
2744            .enumerate()
2745            .filter(|(_, target)| {
2746                terms.iter().all(|term| {
2747                    target.id.to_ascii_lowercase().contains(term)
2748                        || target.title.to_ascii_lowercase().contains(term)
2749                        || target.url.to_ascii_lowercase().contains(term)
2750                })
2751            })
2752            .map(|(index, _)| index)
2753            .collect()
2754    }
2755
2756    pub fn insert_browser_target_query(&mut self, character: char) {
2757        if self.browser_target_query.len() < 512 {
2758            self.browser_target_query.push(character);
2759            self.browser_target_selection = 0;
2760        }
2761    }
2762
2763    pub fn browser_target_backspace(&mut self) {
2764        self.browser_target_query.pop();
2765        self.browser_target_selection = 0;
2766    }
2767
2768    pub fn clear_browser_target_query(&mut self) {
2769        self.browser_target_query.clear();
2770        self.browser_target_selection = 0;
2771    }
2772
2773    pub fn move_browser_target_selection(&mut self, delta: i32) {
2774        let count = self.browser_target_matches().len();
2775        if count == 0 {
2776            self.browser_target_selection = 0;
2777            return;
2778        }
2779        self.browser_target_selection =
2780            (self.browser_target_selection as i32 + delta).rem_euclid(count as i32) as usize;
2781    }
2782
2783    pub fn select_browser_target(&mut self) {
2784        if self.background_action_running() {
2785            self.status = "Finish the current browser operation before selecting a target".into();
2786            return;
2787        }
2788        let matches = self.browser_target_matches();
2789        let Some(index) = matches.get(self.browser_target_selection).copied() else {
2790            self.status = "No matching browser target".into();
2791            return;
2792        };
2793        let Some(target) = self.browser_workspace.state().targets.get(index).cloned() else {
2794            self.status = "Selected browser target disappeared".into();
2795            return;
2796        };
2797        let (call, context) = match self.tool_request(
2798            "glass.browser.target.select",
2799            serde_json::json!({"targetId": target.id}),
2800            true,
2801        ) {
2802            Ok(request) => request,
2803            Err(error) => {
2804                self.status = format!("Target selection unavailable: {error}");
2805                return;
2806            }
2807        };
2808        self.browser_target_picker = false;
2809        self.pending_confirmation = Some(PendingConfirmation {
2810            call,
2811            context,
2812            summary: format!("Select browser target · {}", target.title),
2813        });
2814        self.status = "Target selection ready · Enter approves once · Esc cancels".into();
2815    }
2816
2817    pub fn browser_target_picker_view(&self) -> String {
2818        let matches = self.browser_target_matches();
2819        let mut lines = vec![
2820            format!(
2821                "FILTER  {}",
2822                if self.browser_target_query.is_empty() {
2823                    "all pages"
2824                } else {
2825                    self.browser_target_query.as_str()
2826                }
2827            ),
2828            String::new(),
2829        ];
2830        if matches.is_empty() {
2831            lines.push("No matching page targets.".into());
2832        } else {
2833            for (position, index) in matches.iter().take(16).enumerate() {
2834                let Some(target) = self.browser_workspace.state().targets.get(*index) else {
2835                    continue;
2836                };
2837                let marker = if position == self.browser_target_selection {
2838                    "›"
2839                } else {
2840                    " "
2841                };
2842                let url = safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into());
2843                lines.push(format!(
2844                    "{marker} {} · {} · {}",
2845                    target.title, url, target.id
2846                ));
2847            }
2848        }
2849        lines.push(String::new());
2850        lines.push("Type filters · Backspace edits · Ctrl-U clears".into());
2851        lines.push("j/k or ↑/↓ selects · Enter chooses · Esc closes".into());
2852        lines.join("\n")
2853    }
2854
2855    pub fn queue_browser_observe(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2856        if !self.browser_observe_pending || self.background_action_running() {
2857            return;
2858        }
2859        self.browser_observe_pending = false;
2860        let (call, context) =
2861            match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
2862                Ok(request) => request,
2863                Err(error) => {
2864                    self.status = format!("Could not refresh browser evidence: {error}");
2865                    return;
2866                }
2867            };
2868        match worker.submit_tool(call, context) {
2869            Ok(id) => {
2870                self.running_tool_job = Some(id);
2871                self.status = "Refreshing semantic browser evidence…".into();
2872            }
2873            Err(error) => self.status = format!("Could not refresh browser evidence: {error}"),
2874        }
2875    }
2876
2877    pub fn queue_browser_intent(&mut self, intent: BrowserWorkspaceIntent) {
2878        if self.background_action_running() {
2879            self.status = "Browser action waits for the current background operation".into();
2880            return;
2881        }
2882        let action = match self.browser_workspace.reduce(intent) {
2883            Ok(Some(action)) => action,
2884            Ok(None) => return,
2885            Err(error) => {
2886                self.status = format!("App action unavailable: {error}");
2887                return;
2888            }
2889        };
2890        let (tool, arguments) = match action {
2891            BrowserWorkspaceAction::Navigate {
2892                url,
2893                expected_revision,
2894            } => (
2895                "glass.browser.navigate",
2896                serde_json::json!({"url": url, "browserRevision": expected_revision}),
2897            ),
2898            BrowserWorkspaceAction::Back { expected_revision }
2899            | BrowserWorkspaceAction::Forward { expected_revision }
2900            | BrowserWorkspaceAction::Reload { expected_revision }
2901            | BrowserWorkspaceAction::StopLoading { expected_revision } => {
2902                let action = match action {
2903                    BrowserWorkspaceAction::Back { .. } => "back",
2904                    BrowserWorkspaceAction::Forward { .. } => "forward",
2905                    BrowserWorkspaceAction::Reload { .. } => "reload",
2906                    BrowserWorkspaceAction::StopLoading { .. } => "stopLoading",
2907                    _ => unreachable!(),
2908                };
2909                (
2910                    "glass.browser.act",
2911                    serde_json::json!({"action": action, "browserRevision": expected_revision}),
2912                )
2913            }
2914            BrowserWorkspaceAction::Click {
2915                target,
2916                expected_revision,
2917            } => (
2918                "glass.browser.act",
2919                serde_json::json!({"action":"click", "target": target, "browserRevision": expected_revision}),
2920            ),
2921            BrowserWorkspaceAction::Type {
2922                target,
2923                text,
2924                expected_revision,
2925            } => (
2926                "glass.browser.act",
2927                serde_json::json!({"action":"type", "target": target, "text": text, "browserRevision": expected_revision}),
2928            ),
2929            BrowserWorkspaceAction::Scroll {
2930                dx,
2931                dy,
2932                expected_revision,
2933            } => (
2934                "glass.browser.act",
2935                serde_json::json!({"action":"scroll", "dx": dx, "dy": dy, "browserRevision": expected_revision}),
2936            ),
2937            _ => return,
2938        };
2939        let (call, context) = match self.tool_request(tool, arguments, true) {
2940            Ok(request) => request,
2941            Err(error) => {
2942                self.status = format!("App action unavailable: {error}");
2943                return;
2944            }
2945        };
2946        self.pending_confirmation = Some(PendingConfirmation {
2947            summary: format!("{tool} · browser revision guarded"),
2948            call,
2949            context,
2950        });
2951        self.status = "Browser mutation ready · Enter approves once · Esc cancels".into();
2952    }
2953
2954    pub(super) fn tool_request(
2955        &self,
2956        name: &str,
2957        arguments: serde_json::Value,
2958        mutating: bool,
2959    ) -> Result<
2960        (
2961            crate::development::ToolCall,
2962            crate::tools::DevelopmentToolContext,
2963        ),
2964        String,
2965    > {
2966        // Snapshot refresh owns the workspace lock while it performs filesystem
2967        // and process inspection. Cached revisions keep chat and actions
2968        // responsive; the executor still rejects stale guards before mutation.
2969        let expected_generation = self.snapshot_generation;
2970        let expected_project_revision = self.snapshot_project_revision;
2971        Ok((
2972            crate::development::ToolCall {
2973                id: format!(
2974                    "tui-browser-{}",
2975                    NEXT_BROWSER_TOOL.fetch_add(1, Ordering::Relaxed)
2976                ),
2977                name: name.into(),
2978                arguments,
2979            },
2980            crate::tools::DevelopmentToolContext {
2981                authorization: crate::development::ToolAuthorization {
2982                    actor: crate::development::Actor::local(),
2983                    allow_mutation: mutating,
2984                    confirmed: mutating,
2985                },
2986                initiator: None,
2987                expected_generation,
2988                expected_project_revision,
2989            },
2990        ))
2991    }
2992
2993    /// Offer in-TUI recovery whenever a browser tool fails with a launch or
2994    /// connection error, so a port collision never strands the session.
2995    pub fn note_browser_failure(&mut self, tool: &str, error: &str) {
2996        let lower = error.to_ascii_lowercase();
2997        if tool.contains("browser")
2998            && (lower.contains("occupied")
2999                || lower.contains("attach")
3000                || lower.contains("connect")
3001                || lower.contains("launch")
3002                || lower.contains("timeout")
3003                || lower.contains("devtools"))
3004        {
3005            self.browser_target_picker = false;
3006            self.browser_target_picker_requested = false;
3007            self.surface = DevSurface::App;
3008            self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
3009                error,
3010                self.browser_recovery
3011                    .as_ref()
3012                    .map_or(9222, |offer| offer.port),
3013            ));
3014            self.browser_workspace.disconnected(error.to_string(), true);
3015        }
3016    }
3017
3018    /// Queue a recovery choice without blocking the terminal on browser launch.
3019    pub fn accept_browser_recovery(
3020        &mut self,
3021        choice: usize,
3022        worker: &mut super::snapshot::SnapshotWorker,
3023    ) {
3024        let Some(offer) = self.browser_recovery.take() else {
3025            return;
3026        };
3027        let (port, attach) = match (offer.compatible_endpoint, choice) {
3028            (true, 0) => (offer.port, true),
3029            (true, 1) | (false, 0) => (free_local_port().unwrap_or(0), false),
3030            (true, 2) | (false, 1) => (offer.port, false),
3031            _ => {
3032                self.status = "Recovery dismissed · project and agent remain available".into();
3033                return;
3034            }
3035        };
3036        if port == 0 {
3037            self.status =
3038                "No free local port was available · retry or use an existing browser".into();
3039            return;
3040        }
3041        let (call, context) = match self.tool_request(
3042            "glass.browser.start",
3043            browser_recovery_arguments(port, attach),
3044            true,
3045        ) {
3046            Ok(request) => request,
3047            Err(error) => {
3048                self.status = format!("Could not queue recovery: {error}");
3049                return;
3050            }
3051        };
3052        match worker.submit_tool(call, context) {
3053            Ok(id) => {
3054                self.running_tool_job = Some(id);
3055                self.status = if attach {
3056                    format!("Attaching to browser on port {port} in background…")
3057                } else {
3058                    format!("Recovering browser on port {port} in background…")
3059                };
3060            }
3061            Err(error) => self.status = format!("Could not queue recovery: {error}"),
3062        }
3063    }
3064
3065    pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
3066        let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
3067        let ready = readiness.ready;
3068        self.agent_readiness = format_pi_readiness(&readiness);
3069        Ok(ready)
3070    }
3071}
3072
3073fn format_editor_buffers(buffers: &[crate::development::EditorBuffer]) -> String {
3074    if buffers.is_empty() {
3075        return "No file open. Select a file below and press Enter, then i to edit.".into();
3076    }
3077    buffers
3078        .iter()
3079        .map(|buffer| {
3080            let lines: Vec<&str> = buffer.content.lines().collect();
3081            let cursor = buffer.cursor_line as usize;
3082            let viewport_rows = 16;
3083            let start = cursor
3084                .saturating_sub(viewport_rows / 2)
3085                .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
3086            let end = (start + viewport_rows).min(lines.len());
3087            let gutter_width = lines.len().to_string().len().max(3);
3088            let viewport = lines[start..end]
3089                .iter()
3090                .enumerate()
3091                .map(|(index, line)| {
3092                    let number = start + index + 1;
3093                    let marker = if number == cursor { "▶" } else { " " };
3094                    format!(
3095                        "{marker}{:>gutter_width$} │ {line}",
3096                        number,
3097                        gutter_width = gutter_width
3098                    )
3099                })
3100                .collect::<Vec<_>>()
3101                .join("\n");
3102            format!(
3103                "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
3104                if buffer.dirty { "● " } else { "○ " },
3105                buffer.path,
3106                buffer.cursor_line,
3107                buffer.cursor_column,
3108                buffer.actor.id,
3109                lines.len(),
3110                viewport
3111            )
3112        })
3113        .collect::<Vec<_>>()
3114        .join("\n\n")
3115}
3116
3117fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
3118    let provider = readiness.provider.as_deref().unwrap_or("not selected");
3119    let session = readiness.session.as_deref().unwrap_or("new session");
3120    let remediation = readiness
3121        .remediation
3122        .first()
3123        .map(|item| format!(" · next: {item}"))
3124        .unwrap_or_default();
3125    let state_line = format!(
3126        "{} · Node {} · SDK {} · auth {}",
3127        if readiness.ready {
3128            "✓ Ready"
3129        } else {
3130            "○ Needs setup"
3131        },
3132        component_label(&readiness.node),
3133        readiness.sdk.version.as_deref().unwrap_or("missing"),
3134        component_label(&readiness.authentication),
3135    );
3136    if readiness.ready {
3137        format!("{state_line}\nprovider {provider} · {session}")
3138    } else {
3139        format!(
3140            "{state_line}\nprovider {provider} · {session}{remediation}\n\n[s] `agent setup` repairs the pinned runtime · [u] `agent update` refreshes it · [l] opens Pi `/login`"
3141        )
3142    }
3143}
3144
3145fn component_label(component: &crate::pi_runtime::PiReadinessComponent) -> String {
3146    match component.state {
3147        crate::pi_runtime::PiReadinessState::Ready => "✓".into(),
3148        crate::pi_runtime::PiReadinessState::Missing => "× missing".into(),
3149        crate::pi_runtime::PiReadinessState::Incompatible => "! incompatible".into(),
3150        crate::pi_runtime::PiReadinessState::Expired => "! expired".into(),
3151        crate::pi_runtime::PiReadinessState::Unknown => "? unknown".into(),
3152    }
3153}
3154
3155fn safe_browser_url(url: &str) -> Option<String> {
3156    let url = url.trim();
3157    if url.is_empty() {
3158        return None;
3159    }
3160    let sanitized = url
3161        .split(['?', '#'])
3162        .next()
3163        .unwrap_or(url)
3164        .chars()
3165        .take(2_048)
3166        .collect::<String>();
3167    (!sanitized.is_empty()).then_some(sanitized)
3168}
3169
3170fn page_origin(url: &str) -> Option<String> {
3171    let url = safe_browser_url(url)?;
3172    let scheme_end = url.find("://")?;
3173    let authority_start = scheme_end + 3;
3174    let authority_end = url[authority_start..]
3175        .find('/')
3176        .map(|offset| authority_start + offset)
3177        .unwrap_or(url.len());
3178    Some(url[..authority_end].to_string())
3179}
3180
3181fn pending_agent_approval(
3182    agents: Option<&Vec<crate::AgentSnapshot>>,
3183) -> Option<PendingAgentApproval> {
3184    let agents = agents?;
3185    for agent in agents {
3186        let mut pending = None;
3187        for event in &agent.evidence {
3188            match event.get("type").and_then(serde_json::Value::as_str) {
3189                Some("glass_tool_approval_request") => {
3190                    let Some(frame_id) = event.get("frameId").and_then(serde_json::Value::as_str)
3191                    else {
3192                        continue;
3193                    };
3194                    pending = Some(PendingAgentApproval {
3195                        agent_id: agent.id.as_str().to_string(),
3196                        frame_id: frame_id.to_string(),
3197                        tool_name: event
3198                            .get("toolName")
3199                            .and_then(serde_json::Value::as_str)
3200                            .unwrap_or("unknown tool")
3201                            .to_string(),
3202                        arguments: event.get("arguments").cloned().unwrap_or_default(),
3203                    });
3204                }
3205                Some("glass_tool_approval_resolved") => {
3206                    let frame_id = event.get("frameId").and_then(serde_json::Value::as_str);
3207                    if pending
3208                        .as_ref()
3209                        .is_some_and(|approval| Some(approval.frame_id.as_str()) == frame_id)
3210                    {
3211                        pending = None;
3212                    }
3213                }
3214                _ => {}
3215            }
3216        }
3217        if pending.is_some() {
3218            return pending;
3219        }
3220    }
3221    None
3222}
3223
3224fn fuzzy_contains(candidate: &str, query: &str) -> bool {
3225    if query.is_empty() {
3226        return true;
3227    }
3228    let mut query = query
3229        .chars()
3230        .map(|character| character.to_ascii_lowercase());
3231    let mut expected = query.next();
3232    for character in candidate
3233        .chars()
3234        .map(|character| character.to_ascii_lowercase())
3235    {
3236        if Some(character) == expected {
3237            expected = query.next();
3238            if expected.is_none() {
3239                return true;
3240            }
3241        }
3242    }
3243    false
3244}
3245
3246fn browser_recovery_arguments(port: u16, attach: bool) -> serde_json::Value {
3247    serde_json::json!({
3248        "port": port,
3249        "attach": attach,
3250        "incognito": !attach,
3251    })
3252}
3253
3254/// Bind an ephemeral localhost port to discover a free one.
3255fn free_local_port() -> Option<u16> {
3256    std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
3257        .ok()
3258        .and_then(|listener| listener.local_addr().ok())
3259        .map(|address| address.port())
3260}
3261
3262fn editor_offset(content: &str, line: u32, column: u32) -> usize {
3263    let mut offset = 0;
3264    for (index, value) in content.split_inclusive('\n').enumerate() {
3265        if index + 1 == line as usize {
3266            let column_bytes = value
3267                .trim_end_matches('\n')
3268                .char_indices()
3269                .nth(column.saturating_sub(1) as usize)
3270                .map(|(offset, _)| offset)
3271                .unwrap_or_else(|| value.trim_end_matches('\n').len());
3272            return offset + column_bytes;
3273        }
3274        offset += value.len();
3275    }
3276    content.len()
3277}
3278
3279#[cfg(test)]
3280mod tests {
3281    use super::*;
3282
3283    #[test]
3284    fn quit_confirmation_requires_explicit_follow_through() {
3285        let root = std::env::temp_dir().join(format!("glass-tui-quit-{}", std::process::id()));
3286        std::fs::create_dir_all(&root).expect("create temporary workspace");
3287        let mut state =
3288            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
3289
3290        state.request_quit();
3291        assert!(state.quit_confirmation);
3292        assert!(!state.quit);
3293        assert_eq!(state.status, "Quit confirmation · Enter exits · Esc stays");
3294
3295        state.cancel_quit();
3296        assert!(!state.quit_confirmation);
3297        assert!(!state.quit);
3298
3299        state.request_quit();
3300        state.confirm_quit();
3301        assert!(!state.quit_confirmation);
3302        assert!(state.quit);
3303        assert_eq!(state.status, "Closing Glass Dev");
3304
3305        std::fs::remove_dir_all(root).expect("remove temporary workspace");
3306    }
3307
3308    #[test]
3309    fn browser_context_url_redaction_preserves_path_only() {
3310        assert_eq!(
3311            safe_browser_url("https://example.test/orders/7?token=secret#receipt"),
3312            Some("https://example.test/orders/7".into())
3313        );
3314        assert_eq!(
3315            page_origin("https://example.test/orders/7?token=secret"),
3316            Some("https://example.test".into())
3317        );
3318        assert_eq!(safe_browser_url(""), None);
3319    }
3320
3321    #[test]
3322    fn browser_recovery_offer_explains_port_collision_choices() {
3323        let offer = BrowserRecoveryOffer::from_error("address already in use on port 9222", 9222);
3324        assert!(!offer.compatible_endpoint);
3325        assert_eq!(offer.actions().len(), 3);
3326        assert!(offer.guidance().contains("preferred endpoint"));
3327
3328        let attach =
3329            BrowserRecoveryOffer::from_error("DevTools page target is available for attach", 9222);
3330        assert!(attach.compatible_endpoint);
3331        assert_eq!(attach.actions().len(), 4);
3332        assert!(attach.guidance().contains("Attach"));
3333    }
3334
3335    #[test]
3336    fn browser_recovery_attach_disables_incognito() {
3337        assert_eq!(
3338            browser_recovery_arguments(9222, true),
3339            serde_json::json!({
3340                "port": 9222,
3341                "attach": true,
3342                "incognito": false,
3343            })
3344        );
3345        assert_eq!(
3346            browser_recovery_arguments(42123, false),
3347            serde_json::json!({
3348                "port": 42123,
3349                "attach": false,
3350                "incognito": true,
3351            })
3352        );
3353    }
3354
3355    #[test]
3356    fn browser_target_picker_filters_and_redacts_urls() {
3357        let root = std::env::temp_dir().join(format!("glass-target-picker-{}", std::process::id()));
3358        std::fs::create_dir_all(&root).expect("create temporary workspace");
3359        let mut state =
3360            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
3361        state.browser_workspace.replace_targets(vec![
3362            BrowserWorkspaceTarget {
3363                id: "page-docs".into(),
3364                title: "Project docs".into(),
3365                url: "https://example.test/docs?token=secret".into(),
3366                selected: false,
3367            },
3368            BrowserWorkspaceTarget {
3369                id: "page-app".into(),
3370                title: "Application".into(),
3371                url: "http://localhost:3000".into(),
3372                selected: false,
3373            },
3374        ]);
3375        state
3376            .request_browser_target_picker("docs")
3377            .expect("queue target picker");
3378        state.queued_tool_request = None;
3379        let matches = state.browser_target_matches();
3380        assert_eq!(matches, vec![0]);
3381        let view = state.browser_target_picker_view();
3382        assert!(view.contains("Project docs"));
3383        assert!(view.contains("https://example.test/docs"));
3384        assert!(!view.contains("token=secret"));
3385        std::fs::remove_dir_all(root).expect("remove temporary workspace");
3386    }
3387}