Skip to main content

glass_dev/tui/
state.rs

1use super::command;
2use super::editor::{
3    self as native, EditorEngine, EditorMode, GhostText, Motion, Operator, TextObject,
4    apply_motion, compile_prove_it, complete_mention, evidence_card, expand_mentions,
5    inferred_app_path, join_app_url, line_hunks, local_fim, multi_delete, multi_insert,
6    next_edit_after_accept, pair_apply_caret, pair_apply_step, parse_inlay_hints, same_word_ranges,
7    split_ghost_word, textobject_from_key, textobject_selection,
8};
9use super::parse::IncrementalSyntax;
10use crate::development::TextSelection;
11use crate::{ExperimentComparison, SharedDevelopmentWorkspace};
12use glass_browser::browser::WorkflowRecorder;
13use glass_browser::browser::policy::PolicyPreset;
14use glass_browser::browser::session::VerificationPredicate;
15use glass_browser::browser_workspace::{
16    BrowserConnectionPhase, BrowserWorkspaceAction, BrowserWorkspaceAdapterKind,
17    BrowserWorkspaceController, BrowserWorkspaceEntity, BrowserWorkspaceIntent,
18    BrowserWorkspaceLayout, BrowserWorkspaceTarget,
19};
20use glass_browser::cli::args::TuiLayout;
21use glass_browser::terminal_graphics::AnsiCanvas;
22use glass_browser::tui::live_view::AnsiPane;
23use serde::{Deserialize, Serialize};
24use std::path::Path;
25use std::sync::atomic::{AtomicU64, Ordering};
26
27static NEXT_BROWSER_TOOL: AtomicU64 = AtomicU64::new(1);
28
29pub struct PendingConfirmation {
30    pub call: crate::development::ToolCall,
31    pub context: crate::tools::DevelopmentToolContext,
32    pub summary: String,
33}
34
35#[derive(Debug, Clone)]
36pub struct TuiWorkflowRecording {
37    pub name: String,
38    pub recorder: WorkflowRecorder,
39    step: usize,
40}
41
42impl TuiWorkflowRecording {
43    fn next_id(&mut self) -> String {
44        self.step += 1;
45        format!("step-{}", self.step)
46    }
47}
48
49enum PendingFim {
50    Thread {
51        path: String,
52        offset: usize,
53        rx: std::sync::mpsc::Receiver<Option<String>>,
54    },
55    Pi {
56        path: String,
57        offset: usize,
58        agent_id: crate::AgentId,
59        since: u64,
60    },
61}
62
63impl PendingFim {
64    fn path(&self) -> &str {
65        match self {
66            Self::Thread { path, .. } | Self::Pi { path, .. } => path,
67        }
68    }
69
70    fn offset(&self) -> usize {
71        match self {
72            Self::Thread { offset, .. } | Self::Pi { offset, .. } => *offset,
73        }
74    }
75}
76
77#[derive(Debug, Clone)]
78pub struct PendingAgentApproval {
79    pub agent_id: String,
80    pub frame_id: String,
81    pub tool_name: String,
82    pub arguments: serde_json::Value,
83}
84
85#[derive(Debug, Clone, Copy, PartialEq, Eq)]
86pub enum ChatMessageState {
87    Sending,
88    Sent,
89    Failed,
90}
91
92#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
93pub struct WorkspacePlan {
94    pub id: String,
95    pub goal: String,
96    pub body: String,
97    pub accepted: bool,
98}
99
100#[derive(Debug, Clone, PartialEq, Eq)]
101pub struct SessionPickerItem {
102    pub path: String,
103    pub label: String,
104}
105
106#[derive(Debug, Clone, PartialEq, Eq)]
107pub struct ProcessRow {
108    pub name: String,
109    pub command: String,
110    pub pid: Option<u32>,
111    pub health: crate::development::ProcessHealth,
112    pub url: Option<String>,
113}
114
115impl ProcessRow {
116    pub fn from_snapshot(item: &crate::development::ProcessSnapshot) -> Self {
117        Self {
118            name: item.name.clone(),
119            command: item.command.clone(),
120            pid: item.pid,
121            health: item.health.clone(),
122            url: item.detected_urls.first().cloned(),
123        }
124    }
125}
126
127#[derive(Debug, Clone, PartialEq, Eq)]
128pub struct DebugSessionRow {
129    pub name: String,
130    pub state: crate::debugger::DebugSessionState,
131    pub pid: u32,
132    pub breakpoints: usize,
133    pub watches: usize,
134}
135
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub struct DebugScopeRow {
138    pub name: String,
139    pub variables_reference: i64,
140}
141
142#[derive(Debug, Clone, PartialEq, Eq)]
143pub struct DebugVariableRow {
144    pub name: String,
145    pub value: String,
146}
147
148#[derive(Debug, Clone, PartialEq, Eq)]
149pub struct DebugThreadRow {
150    pub id: i64,
151    pub name: String,
152}
153
154#[derive(Debug, Clone, PartialEq, Eq)]
155pub struct DebugFrameRow {
156    pub id: i64,
157    pub name: String,
158    pub path: Option<String>,
159    pub line: Option<u64>,
160}
161
162#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
163pub enum DebugPane {
164    #[default]
165    Sessions,
166    Threads,
167    Frames,
168}
169
170impl DebugPane {
171    pub fn label(self) -> &'static str {
172        match self {
173            Self::Sessions => "sessions",
174            Self::Threads => "threads",
175            Self::Frames => "frames",
176        }
177    }
178
179    fn next(self) -> Self {
180        match self {
181            Self::Sessions => Self::Threads,
182            Self::Threads => Self::Frames,
183            Self::Frames => Self::Sessions,
184        }
185    }
186
187    fn previous(self) -> Self {
188        match self {
189            Self::Sessions => Self::Frames,
190            Self::Threads => Self::Sessions,
191            Self::Frames => Self::Threads,
192        }
193    }
194}
195
196#[derive(Debug, Clone, PartialEq, Eq)]
197pub struct PendingChatMessage {
198    pub text: String,
199    pub state: ChatMessageState,
200    pub job_id: Option<u64>,
201    pub error: Option<String>,
202}
203
204/// In-TUI recovery choices offered when a browser start collides or fails.
205#[derive(Debug, Clone, PartialEq, Eq)]
206pub struct BrowserRecoveryOffer {
207    pub reason: String,
208    pub port: u16,
209    /// A healthy Chrome CDP endpoint answered on the preferred port.
210    pub compatible_endpoint: bool,
211}
212
213impl BrowserRecoveryOffer {
214    pub fn from_error(error: &str, port: u16) -> Self {
215        let lower = error.to_ascii_lowercase();
216        Self {
217            reason: error.to_string(),
218            port,
219            compatible_endpoint: ["attach", "devtools", "page target", "multiple page targets"]
220                .iter()
221                .any(|marker| lower.contains(marker)),
222        }
223    }
224
225    pub fn actions(&self) -> &'static [(&'static str, &'static str)] {
226        if self.compatible_endpoint {
227            &[
228                ("1", "attach after checking the running browser"),
229                ("2", "launch an isolated browser on an automatic free port"),
230                ("3", "retry the preferred port"),
231                ("Esc", "dismiss"),
232            ]
233        } else {
234            &[
235                ("1", "launch an isolated browser on an automatic free port"),
236                ("2", "retry the preferred port"),
237                ("Esc", "dismiss"),
238            ]
239        }
240    }
241
242    pub fn guidance(&self) -> &'static str {
243        let lower = self.reason.to_ascii_lowercase();
244        if self.compatible_endpoint {
245            "A DevTools endpoint answered. Attach only when its page is the intended browser; otherwise launch an isolated session."
246        } else if lower.contains("occup") || lower.contains("address") || lower.contains("port") {
247            "The preferred endpoint is busy or unavailable. Glass keeps the project and agent alive while you retry or move to an automatic free port."
248        } else {
249            "The browser did not become usable. Check Chrome/Chromium availability, then retry; the workspace remains intact."
250        }
251    }
252}
253
254#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
255pub enum DevSurface {
256    Trust,
257    Agent,
258    Code,
259    App,
260    Terminal,
261    Tasks,
262    Git,
263    Debug,
264    More,
265}
266
267impl DevSurface {
268    pub const ALL: [Self; 8] = [
269        Self::Agent,
270        Self::Code,
271        Self::App,
272        Self::Terminal,
273        Self::Tasks,
274        Self::Git,
275        Self::Debug,
276        Self::More,
277    ];
278
279    pub const PRIMARY: [Self; 8] = [
280        Self::Agent,
281        Self::Code,
282        Self::App,
283        Self::Terminal,
284        Self::Tasks,
285        Self::Git,
286        Self::Debug,
287        Self::More,
288    ];
289
290    pub const PHONE: [Self; 5] = [Self::Agent, Self::Code, Self::App, Self::Tasks, Self::More];
291
292    pub fn label(self) -> &'static str {
293        match self {
294            Self::Trust => "Trust",
295            Self::Agent => "Agent",
296            Self::Code => "Code",
297            Self::App => "App",
298            Self::Terminal => "Terminal",
299            Self::Tasks => "Tasks",
300            Self::Git => "Git",
301            Self::Debug => "Debug",
302            Self::More => "More",
303        }
304    }
305}
306
307#[derive(Debug, Clone, Copy, PartialEq, Eq)]
308pub enum ResponsiveClass {
309    Desktop,
310    Compact,
311    Phone,
312}
313
314#[derive(Debug, Clone, Copy, PartialEq, Eq)]
315pub enum EditorExitPrompt {
316    Clean,
317    Unsaved,
318}
319
320#[derive(Debug, Clone, Copy, PartialEq, Eq)]
321pub enum ProductMode {
322    Build,
323    Agent,
324    RunApp,
325    Debug,
326}
327
328impl ProductMode {
329    pub fn label(self) -> &'static str {
330        match self {
331            Self::Build => "build",
332            Self::Agent => "agent",
333            Self::RunApp => "run",
334            Self::Debug => "debug",
335        }
336    }
337}
338
339pub struct DevTuiState {
340    pub workspace: SharedDevelopmentWorkspace,
341    pub surface: DevSurface,
342    pub layout: TuiLayout,
343    /// Process-scoped unrestricted development mode from `glass --yolo`.
344    pub yolo_mode: bool,
345    pub quit_confirmation: bool,
346    pub quit: bool,
347    pub command_mode: bool,
348    pub command_input: String,
349    pub command_cursor: usize,
350    pub command_history: Vec<String>,
351    pub command_history_index: Option<usize>,
352    pub palette_error: Option<String>,
353    pub palette_scroll: u16,
354    /// Index in the filtered, arrow-selectable palette action list.
355    pub palette_selection: usize,
356    pub menu_open: bool,
357    pub menu_selection: usize,
358    pub help_open: bool,
359    pub help_scroll: u16,
360    pub composer_mode: bool,
361    pub composer_run_mode: crate::AgentTurnMode,
362    pub pending_plan: Option<WorkspacePlan>,
363    pub composer_input: String,
364    pub composer_cursor: usize,
365    pub composer_steer: bool,
366    pub last_app_comment: Option<String>,
367    pub session_todos: crate::SessionTodoList,
368    pub composer_history: Vec<String>,
369    pub composer_history_index: Option<usize>,
370    pub composer_history_draft: String,
371    pub file_picker_open: bool,
372    pub file_picker_query: String,
373    pub file_picker_cursor: usize,
374    pub file_picker_selection: usize,
375    pub transcript_selection: usize,
376    pub transcript_expanded: bool,
377    pub session_picker_open: bool,
378    pub session_picker_items: Vec<SessionPickerItem>,
379    pub session_picker_selection: usize,
380    pub conversation_items: Vec<super::projection::ConversationEntry>,
381    pub agent_model: String,
382    pub agent_thinking: String,
383    pub agent_session_name: String,
384    pub agent_token_summary: String,
385    pub git_branch: String,
386    pub git_dirty: bool,
387    pub git_ahead: u64,
388    pub git_behind: u64,
389    pub git_conflicts: Vec<String>,
390    pub github_review_requested: bool,
391    pub pending_trust: Option<crate::LocalTrustDecision>,
392    pub pending_open_file: Option<String>,
393    pub pending_chat_messages: Vec<PendingChatMessage>,
394    pub agent_send_job: Option<u64>,
395    pub selected_agent: Option<crate::AgentId>,
396    pub pending_confirmation: Option<PendingConfirmation>,
397    /// URL retained while the TUI launches a detached browser before navigation.
398    pub pending_browser_navigation: Option<String>,
399    pub pending_page_entity: Option<String>,
400    pub process_urls: Vec<String>,
401    pub pending_agent_approval: Option<PendingAgentApproval>,
402    pub editor_exit_prompt: Option<EditorExitPrompt>,
403    pub queued_tool_request: Option<(
404        crate::development::ToolCall,
405        crate::tools::DevelopmentToolContext,
406    )>,
407    pub running_tool_job: Option<u64>,
408    pub surface_scroll: std::collections::BTreeMap<DevSurface, usize>,
409    pub terminal_width: u16,
410    pub terminal_height: u16,
411    pub status: String,
412    pub snapshot_root: String,
413    pub snapshot_trust_label: String,
414    pub snapshot_trust_inspection: Vec<crate::customization::CustomizationInspectionItem>,
415    pub snapshot_project_revision: u64,
416    pub snapshot_generation: u64,
417    pub snapshot_skills_count: usize,
418    pub snapshot_tools_count: usize,
419    /// Wall-clock cost of the last background refresh pass.
420    pub refresh_latency_ms: u64,
421    /// Highest agent event sequence folded into the live conversation.
422    pub conversation_cursor: u64,
423    /// Index of the editor buffer focused by the Code surface.
424    pub editor_buffer_index: usize,
425    pub focused_editor_path: String,
426    /// Cached editor content used while the shared workspace is busy.
427    pub focused_editor_content: String,
428    pub focused_editor_dirty: bool,
429    pub focused_editor_line: u32,
430    pub focused_editor_column: u32,
431    pub focused_editor_selection: Option<crate::development::TextSelection>,
432    pub editor_comments: Vec<crate::development::EditorComment>,
433    pub editor_proposals: Vec<crate::development::EditorProposal>,
434    pub editor_checkpoints: Vec<crate::development::EditorCheckpoint>,
435    pub editor_diagnostics: Vec<crate::development::LanguageDiagnostic>,
436    pub editor_inlays: Vec<(u32, String)>,
437    pub last_crew_wake: Option<String>,
438    pub agents: String,
439    pub agent_readiness: String,
440    pub harnesses: String,
441    /// Set by an in-TUI login action; the event loop temporarily hands the
442    /// terminal to Pi so `/login` can receive interactive input.
443    pub agent_login_requested: bool,
444    /// Set by a palette action; the event loop hands the terminal to the
445    /// selected external harness and resumes Glass after it exits.
446    pub harness_launch_requested: Option<String>,
447    pub agent_conversation: String,
448    pub tasks: String,
449    pub editor: String,
450    pub files: Vec<String>,
451    pub selected_file: usize,
452    pub code_edit_mode: bool,
453    pub editor_soft_wrap: bool,
454    pub editor_scroll_line: usize,
455    pub editor_scroll_column: usize,
456    pub editor_engine: EditorEngine,
457    pub syntax: IncrementalSyntax,
458    pub last_verify: Option<String>,
459    pub last_proof_ok: Option<bool>,
460    pub pending_verify: Option<serde_json::Value>,
461    pub factory_split: bool,
462    pub lsp: String,
463    pub processes: String,
464    pub process_entries: Vec<ProcessRow>,
465    pub selected_process: usize,
466    pub process_logs: String,
467    pub process_logs_requested: bool,
468    pub git: String,
469    pub git_entries: Vec<crate::git::GitStatusEntry>,
470    pub github: crate::github::GitHubStatus,
471    pub github_review: String,
472    pub selected_git_file: usize,
473    pub git_diff_path: Option<String>,
474    pub git_diff: String,
475    pub git_diff_open: bool,
476    pub git_diff_requested: bool,
477    pub tests: String,
478    pub kernels: String,
479    pub debugger: String,
480    pub debug_sessions: Vec<DebugSessionRow>,
481    pub selected_debug_session: usize,
482    pub debug_threads: Vec<DebugThreadRow>,
483    pub selected_debug_thread: usize,
484    pub debug_frames: Vec<DebugFrameRow>,
485    pub selected_debug_frame: usize,
486    pub debug_pane: DebugPane,
487    pub debug_threads_requested: bool,
488    pub debug_stack_requested: bool,
489    pub debug_scopes: Vec<DebugScopeRow>,
490    pub selected_debug_scope: usize,
491    pub debug_variables: Vec<DebugVariableRow>,
492    pub debug_scopes_requested: bool,
493    pub debug_variables_requested: bool,
494    pub selected_todo: usize,
495    pub selected_more: usize,
496    pub more_result: String,
497    pub replay: String,
498    pub browser: String,
499    pub browser_detail: String,
500    pub browser_workspace: BrowserWorkspaceController,
501    pub browser_recovery: Option<BrowserRecoveryOffer>,
502    pub browser_target_picker: bool,
503    pub browser_target_picker_requested: bool,
504    pub browser_target_query: String,
505    pub browser_target_selection: usize,
506    pub browser_visual_live: bool,
507    pub browser_observe_pending: bool,
508    pub browser_ansi: AnsiCanvas,
509    pub browser_pane: Option<AnsiPane>,
510    pub workflow: String,
511    pub workspace_status: String,
512    pub experiment_comparison: Option<ExperimentComparison>,
513    pub experiments: String,
514    pub cockpit_url: String,
515    pub private_cockpit: Option<crate::development::LocalCockpit>,
516    pub workflow_recording: Option<TuiWorkflowRecording>,
517    pending_fim: Option<PendingFim>,
518}
519
520impl DevTuiState {
521    /// Lock the shared workspace, mapping errors to strings for the palette.
522    pub fn ws(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
523        self.workspace.try_lock().map_err(|error| error.to_string())
524    }
525
526    /// Lock the shared workspace for mutation, mapping errors to strings.
527    pub fn ws_mut(&self) -> Result<std::sync::MutexGuard<'_, crate::DevelopmentWorkspace>, String> {
528        self.workspace.try_lock().map_err(|error| error.to_string())
529    }
530
531    /// Lock the workspace for mutation inside UI callbacks; reports lock
532    /// failures through the status line instead of `?`.
533    fn locked<F, T>(&mut self, operation: F) -> Option<T>
534    where
535        F: FnOnce(&mut crate::DevelopmentWorkspace) -> T,
536    {
537        match self.workspace.try_lock() {
538            Ok(mut workspace) => Some(operation(&mut workspace)),
539            Err(error) => {
540                self.status = format!("Workspace lock failed: {error}");
541                None
542            }
543        }
544    }
545
546    pub fn product_mode(&self) -> ProductMode {
547        match self.surface {
548            DevSurface::Agent => ProductMode::Agent,
549            DevSurface::App => ProductMode::RunApp,
550            DevSurface::Debug => ProductMode::Debug,
551            _ => ProductMode::Build,
552        }
553    }
554    pub fn open(
555        root: impl AsRef<Path>,
556        layout: TuiLayout,
557    ) -> Result<Self, Box<dyn std::error::Error>> {
558        Self::open_internal(root, layout, true, false, PolicyPreset::Development)
559    }
560
561    /// Construct the interactive TUI without doing a full synchronous
562    /// projection pass. The snapshot worker fills resident projections after
563    /// the first frame, so a large repository can show the cockpit immediately.
564    pub fn open_for_tui(
565        root: impl AsRef<Path>,
566        layout: TuiLayout,
567    ) -> Result<Self, Box<dyn std::error::Error>> {
568        Self::open_internal(root, layout, false, false, PolicyPreset::Development)
569    }
570
571    /// Construct the TUI with an explicit process-scoped development mode.
572    pub fn open_for_tui_with_mode(
573        root: impl AsRef<Path>,
574        layout: TuiLayout,
575        yolo_mode: bool,
576    ) -> Result<Self, Box<dyn std::error::Error>> {
577        Self::open_for_tui_with_policy(root, layout, yolo_mode, PolicyPreset::Development)
578    }
579
580    /// Construct the TUI with explicit development and browser policies.
581    pub fn open_for_tui_with_policy(
582        root: impl AsRef<Path>,
583        layout: TuiLayout,
584        yolo_mode: bool,
585        policy_preset: PolicyPreset,
586    ) -> Result<Self, Box<dyn std::error::Error>> {
587        Self::open_internal(root, layout, false, yolo_mode, policy_preset)
588    }
589
590    fn open_internal(
591        root: impl AsRef<Path>,
592        layout: TuiLayout,
593        initial_refresh: bool,
594        yolo_mode: bool,
595        policy_preset: PolicyPreset,
596    ) -> Result<Self, Box<dyn std::error::Error>> {
597        let workspace = SharedDevelopmentWorkspace::open_with_policy(root, policy_preset)?;
598        if yolo_mode {
599            let mut workspace = workspace.lock()?;
600            workspace.agents().set_default_unrestricted(true);
601        }
602        let locked = workspace.lock()?;
603        let trust = locked.trust();
604        let trust_inspection = locked.trust_inspection();
605        let snapshot_root = locked.root().display().to_string();
606        let snapshot_project_revision = locked.project().revision();
607        let snapshot_generation = locked.generation();
608        let snapshot_skills_count = locked.customization().skills().count();
609        let snapshot_tools_count = locked.customization().config().tools.len();
610        let trust_prompt = trust == crate::WorkspaceTrust::Untrusted
611            && trust_inspection.iter().any(|item| item.trust_required);
612        drop(locked);
613        let agent_readiness = crate::pi_runtime::pi_readiness()
614            .map(|readiness| format_pi_readiness(&readiness))
615            .unwrap_or_else(|error| format!("Agent unavailable · {error}"));
616        let initial_status = if trust_prompt {
617            "Trust required · I inspect · O untrusted · 1 once · T project".to_string()
618        } else if agent_readiness.starts_with("✓ Ready") {
619            "Ready · Enter chat · Ctrl-P files · : commands · ? help".to_string()
620        } else {
621            "Pi setup required · press :actions or Enter to continue".to_string()
622        };
623        let mut state = Self {
624            workspace,
625            surface: if trust_prompt {
626                DevSurface::Trust
627            } else {
628                DevSurface::Agent
629            },
630            layout,
631            yolo_mode,
632            quit: false,
633            quit_confirmation: false,
634            command_mode: false,
635            command_input: String::new(),
636            command_cursor: 0,
637            command_history: Vec::new(),
638            command_history_index: None,
639            palette_error: None,
640            palette_scroll: 0,
641            palette_selection: 0,
642            menu_open: false,
643            menu_selection: 0,
644            help_open: false,
645            help_scroll: 0,
646            composer_mode: false,
647            composer_run_mode: crate::AgentTurnMode::Agent,
648            pending_plan: None,
649            composer_input: String::new(),
650            composer_cursor: 0,
651            composer_steer: false,
652            last_app_comment: None,
653            session_todos: crate::SessionTodoList::default(),
654            composer_history: Vec::new(),
655            composer_history_index: None,
656            composer_history_draft: String::new(),
657            file_picker_open: false,
658            file_picker_query: String::new(),
659            file_picker_cursor: 0,
660            file_picker_selection: 0,
661            transcript_selection: 0,
662            transcript_expanded: false,
663            session_picker_open: false,
664            session_picker_items: Vec::new(),
665            session_picker_selection: 0,
666            conversation_items: Vec::new(),
667            agent_model: String::new(),
668            agent_thinking: String::new(),
669            agent_session_name: String::new(),
670            agent_token_summary: String::new(),
671            git_branch: String::new(),
672            git_dirty: false,
673            git_ahead: 0,
674            git_behind: 0,
675            git_conflicts: Vec::new(),
676            github_review_requested: false,
677            pending_trust: None,
678            pending_open_file: None,
679            pending_chat_messages: Vec::new(),
680            agent_send_job: None,
681            selected_agent: None,
682            pending_confirmation: None,
683            editor_exit_prompt: None,
684            pending_agent_approval: None,
685            pending_browser_navigation: None,
686            pending_page_entity: None,
687            process_urls: Vec::new(),
688            queued_tool_request: None,
689            running_tool_job: None,
690            surface_scroll: std::collections::BTreeMap::new(),
691            terminal_width: 80,
692            terminal_height: 24,
693            snapshot_root,
694            snapshot_trust_label: trust.label().into(),
695            snapshot_trust_inspection: trust_inspection,
696            snapshot_project_revision,
697            snapshot_generation,
698            snapshot_skills_count,
699            snapshot_tools_count,
700            refresh_latency_ms: 0,
701            conversation_cursor: 0,
702            editor_buffer_index: 0,
703            focused_editor_path: String::new(),
704            focused_editor_content: String::new(),
705            focused_editor_dirty: false,
706            focused_editor_line: 0,
707            focused_editor_column: 0,
708            focused_editor_selection: None,
709            editor_comments: Vec::new(),
710            editor_proposals: Vec::new(),
711            editor_checkpoints: Vec::new(),
712            editor_diagnostics: Vec::new(),
713            editor_inlays: Vec::new(),
714            last_crew_wake: None,
715            status: initial_status,
716            agents: String::new(),
717            agent_readiness,
718            harnesses: crate::harness::summary(),
719            agent_login_requested: false,
720            harness_launch_requested: None,
721            agent_conversation:
722                "No conversation yet. Press Enter or start typing to compose a message.".into(),
723            tasks: String::new(),
724            editor: String::new(),
725            files: Vec::new(),
726            selected_file: 0,
727            code_edit_mode: false,
728            editor_soft_wrap: false,
729            editor_scroll_line: 0,
730            editor_scroll_column: 0,
731            editor_engine: EditorEngine {
732                mode: EditorMode::Insert,
733                ..EditorEngine::default()
734            },
735            syntax: IncrementalSyntax::new(),
736            last_verify: None,
737            last_proof_ok: None,
738            pending_verify: None,
739            factory_split: true,
740            lsp: String::new(),
741            processes: String::new(),
742            process_entries: Vec::new(),
743            selected_process: 0,
744            process_logs: String::new(),
745            process_logs_requested: false,
746            git: String::new(),
747            git_entries: Vec::new(),
748            github: crate::github::GitHubStatus::default(),
749            github_review: "No GitHub review yet".into(),
750            selected_git_file: 0,
751            git_diff_path: None,
752            git_diff: String::new(),
753            git_diff_open: false,
754            git_diff_requested: false,
755            tests: String::new(),
756            kernels: String::new(),
757            debugger: String::new(),
758            debug_sessions: Vec::new(),
759            selected_debug_session: 0,
760            debug_threads: Vec::new(),
761            selected_debug_thread: 0,
762            debug_frames: Vec::new(),
763            selected_debug_frame: 0,
764            debug_pane: DebugPane::Sessions,
765            debug_threads_requested: false,
766            debug_stack_requested: false,
767            debug_scopes: Vec::new(),
768            selected_debug_scope: 0,
769            debug_variables: Vec::new(),
770            debug_scopes_requested: false,
771            debug_variables_requested: false,
772            selected_todo: 0,
773            selected_more: 0,
774            more_result: String::new(),
775            replay: String::new(),
776            browser: String::new(),
777            browser_detail: "No browser observation yet".into(),
778            browser_workspace: BrowserWorkspaceController::for_adapter(
779                match layout {
780                    TuiLayout::Mobile => BrowserWorkspaceLayout::Phone,
781                    TuiLayout::Compact => BrowserWorkspaceLayout::Compact,
782                    TuiLayout::Auto | TuiLayout::Desktop => BrowserWorkspaceLayout::Desktop,
783                },
784                BrowserWorkspaceAdapterKind::EmbeddedDevelopment,
785            ),
786            browser_recovery: None,
787            browser_target_picker: false,
788            browser_target_picker_requested: false,
789            browser_target_query: String::new(),
790            browser_target_selection: 0,
791            browser_visual_live: false,
792            browser_observe_pending: false,
793            browser_ansi: AnsiCanvas::default(),
794            browser_pane: None,
795            workflow: "No workflow evidence yet".into(),
796            workspace_status: String::new(),
797            experiment_comparison: None,
798            experiments: "No experiments. :experiment create ID BRANCH [PORT]".into(),
799            cockpit_url: String::new(),
800            private_cockpit: None,
801            workflow_recording: None,
802            pending_fim: None,
803        };
804        if initial_refresh {
805            state.refresh();
806        }
807        Ok(state)
808    }
809
810    pub fn responsive_class(&self, width: u16, height: u16) -> ResponsiveClass {
811        match self.layout {
812            TuiLayout::Desktop => ResponsiveClass::Desktop,
813            TuiLayout::Compact => ResponsiveClass::Compact,
814            TuiLayout::Mobile => ResponsiveClass::Phone,
815            TuiLayout::Auto if width < 72 || height < 22 => ResponsiveClass::Phone,
816            TuiLayout::Auto if width < 118 || height < 32 => ResponsiveClass::Compact,
817            TuiLayout::Auto => ResponsiveClass::Desktop,
818        }
819    }
820
821    pub fn request_quit(&mut self) {
822        if self.quit {
823            return;
824        }
825        self.quit_confirmation = true;
826        self.status = "Quit confirmation · Enter exits · Esc stays".into();
827    }
828
829    pub fn confirm_quit(&mut self) {
830        self.quit_confirmation = false;
831        self.quit = true;
832        self.status = "Closing Glass Dev".into();
833    }
834
835    pub fn cancel_quit(&mut self) {
836        self.quit_confirmation = false;
837        self.status = "Quit dismissed · workspace remains open".into();
838    }
839
840    pub fn quit_menu_index(&self) -> usize {
841        self.surface_actions().len() + 1
842    }
843
844    /// Guided launchers for the current surface. `:actions` opens the command center.
845    pub fn surface_actions(&self) -> &'static [command::SurfaceAction] {
846        command::surface_actions(self.surface)
847    }
848
849    pub fn toggle_help(&mut self) {
850        self.help_open = !self.help_open;
851        self.help_scroll = 0;
852        self.status = if self.help_open {
853            "Help · j/k scroll · ? or Esc closes".into()
854        } else {
855            "Help closed".into()
856        };
857    }
858
859    pub fn scroll_help(&mut self, delta: i32) {
860        self.help_scroll = (self.help_scroll as i32 + delta).max(0) as u16;
861    }
862
863    pub fn open_menu(&mut self) {
864        self.menu_open = true;
865        self.menu_selection = 0;
866        self.status = format!("Command center · {}", self.surface.label());
867    }
868
869    pub fn close_menu(&mut self) {
870        self.menu_open = false;
871    }
872
873    pub fn start_private_cockpit(&mut self) -> Result<String, String> {
874        if let Some(cockpit) = self.private_cockpit.as_ref() {
875            return Ok(cockpit.local_url());
876        }
877        let cockpit = crate::development::LocalCockpit::start(self.workspace.clone())
878            .map_err(|error| error.to_string())?;
879        let url = cockpit.local_url();
880        self.cockpit_url = url.clone();
881        self.private_cockpit = Some(cockpit);
882        self.status = format!("Private cockpit ready · {url}");
883        Ok(url)
884    }
885
886    pub fn stop_private_cockpit(&mut self) {
887        if self.private_cockpit.take().is_some() {
888            self.cockpit_url.clear();
889            self.status = "Private cockpit stopped".into();
890        } else {
891            self.status = "Private cockpit is not running".into();
892        }
893    }
894
895    pub fn private_cockpit_status(&self) -> String {
896        self.private_cockpit
897            .as_ref()
898            .map(|cockpit| format!("running · {}", cockpit.local_url()))
899            .unwrap_or_else(|| "not running · use `cockpit start`".into())
900    }
901
902    pub fn start_workflow_recording(&mut self, name: &str) -> Result<String, String> {
903        if let Some(recording) = &self.workflow_recording {
904            return Err(format!(
905                "already recording {} · :workflow record stop first",
906                recording.name
907            ));
908        }
909        let name = workflow_slug(name);
910        self.workflow_recording = Some(TuiWorkflowRecording {
911            name: name.clone(),
912            recorder: WorkflowRecorder::new(name.clone(), "1.0.0"),
913            step: 0,
914        });
915        self.surface = DevSurface::App;
916        self.refresh_workflow_recording_status();
917        self.status = format!("Recording {name} · Enter activates and records locators");
918        Ok(self.status.clone())
919    }
920
921    pub fn workflow_recording_status(&self) -> String {
922        match &self.workflow_recording {
923            Some(recording) => format!(
924                "recording {} · {} step(s)",
925                recording.name,
926                recording.recorder.draft().steps.len()
927            ),
928            None => "not recording · :workflow record start NAME".into(),
929        }
930    }
931
932    pub fn capture_workflow_click(&mut self) -> Result<bool, String> {
933        if self.workflow_recording.is_none() {
934            return Ok(false);
935        }
936        let selected = self
937            .browser_workspace
938            .state()
939            .selected()
940            .cloned()
941            .filter(|entity| entity.actionable)
942            .ok_or("no actionable semantic entity is selected")?;
943        let Some(recording) = self.workflow_recording.as_mut() else {
944            return Ok(false);
945        };
946        let id = recording.next_id();
947        recording
948            .recorder
949            .record_click(id, selected.role, selected.name, None)
950            .map_err(|error| error.to_string())?;
951        self.refresh_workflow_recording_status();
952        Ok(true)
953    }
954
955    pub fn record_workflow_type(&mut self, input_name: &str) -> Result<String, String> {
956        let selected = self
957            .browser_workspace
958            .state()
959            .selected()
960            .cloned()
961            .ok_or("no semantic entity is selected")?;
962        let recording = self
963            .workflow_recording
964            .as_mut()
965            .ok_or("start a recording first")?;
966        let id = recording.next_id();
967        let input = workflow_slug(input_name);
968        recording
969            .recorder
970            .record_type_input(id, selected.role, selected.name, input.clone())
971            .map_err(|error| error.to_string())?;
972        let steps = recording.recorder.draft().steps.len();
973        self.refresh_workflow_recording_status();
974        self.status = format!("REC {steps} · typed ${{inputs.{input}}}");
975        Ok(self.status.clone())
976    }
977
978    pub fn record_workflow_verify(&mut self) -> Result<String, String> {
979        let value = self
980            .pending_verify
981            .clone()
982            .ok_or("no pending prove-it predicate to attach")?;
983        let expect: VerificationPredicate = serde_json::from_value(value)
984            .map_err(|error| format!("pending verify is not a workflow predicate: {error}"))?;
985        let recording = self
986            .workflow_recording
987            .as_mut()
988            .ok_or("start a recording first")?;
989        recording
990            .recorder
991            .attach_expect_to_last(expect)
992            .map_err(|error| error.to_string())?;
993        let steps = recording.recorder.draft().steps.len();
994        self.refresh_workflow_recording_status();
995        self.status = format!("REC {steps} · attached prove-it to the last step");
996        Ok(self.status.clone())
997    }
998
999    pub fn stop_workflow_recording(&mut self) -> Result<String, String> {
1000        let recording = self
1001            .workflow_recording
1002            .take()
1003            .ok_or("no click-path recording is active")?;
1004        let draft = recording.recorder.draft();
1005        if draft.steps.is_empty() {
1006            self.workflow = "No workflow evidence yet".into();
1007            return Err("recording had no steps · activate entities before stop".into());
1008        }
1009        let dir = Path::new(&self.snapshot_root)
1010            .join(".glass")
1011            .join("workflows");
1012        std::fs::create_dir_all(&dir).map_err(|error| error.to_string())?;
1013        let path = dir.join(format!("{}.draft.json", recording.name));
1014        let encoded = serde_json::to_vec_pretty(draft).map_err(|error| error.to_string())?;
1015        std::fs::write(&path, &encoded).map_err(|error| error.to_string())?;
1016        self.workflow = format!(
1017            "Draft {} · {} step(s) · {}",
1018            recording.name,
1019            draft.steps.len(),
1020            path.display()
1021        );
1022        self.status = format!(
1023            "Recorded {} step(s) · {}",
1024            draft.steps.len(),
1025            path.display()
1026        );
1027        Ok(self.status.clone())
1028    }
1029
1030    fn refresh_workflow_recording_status(&mut self) {
1031        if let Some(recording) = &self.workflow_recording {
1032            self.workflow = format!(
1033                "REC {} · {} step(s) · :workflow record stop",
1034                recording.name,
1035                recording.recorder.draft().steps.len()
1036            );
1037        }
1038    }
1039
1040    fn capture_workflow_type_from_selection(&mut self) {
1041        if self.workflow_recording.is_none() {
1042            return;
1043        }
1044        let input = self
1045            .browser_workspace
1046            .state()
1047            .selected()
1048            .map(|entity| slug_input_name(&entity.name))
1049            .unwrap_or_else(|| "value".into());
1050        let _ = self.record_workflow_type(&input);
1051    }
1052
1053    /// Run the selected command-center launcher. Keyboard hints apply
1054    /// directly; strings starting with `:` open the palette prefilled with
1055    /// the command.
1056    pub fn run_menu_action(&mut self) {
1057        let search_index = self.surface_actions().len();
1058        let quit_index = self.quit_menu_index();
1059        if self.menu_selection == search_index {
1060            self.menu_open = false;
1061            self.open_palette();
1062            return;
1063        }
1064        if self.menu_selection == quit_index {
1065            self.menu_open = false;
1066            self.request_quit();
1067            return;
1068        }
1069        let Some(action) = self.surface_actions().get(self.menu_selection).copied() else {
1070            return;
1071        };
1072        self.menu_open = false;
1073        let name = action.label;
1074        let hint = action.command;
1075        if hint == "browser view" {
1076            self.surface = DevSurface::App;
1077            self.browser_visual_live = !self.browser_visual_live;
1078            self.status = if self.browser_visual_live {
1079                "Live view starting · command palette can stop it".into()
1080            } else {
1081                "Live view off · semantic inspection remains available".into()
1082            };
1083            return;
1084        }
1085        if hint == "process start dev" {
1086            self.request_detected_dev();
1087            return;
1088        }
1089        if hint == "git diff" && self.surface == DevSurface::Git {
1090            self.git_diff_requested = true;
1091            self.status = "Git diff queued · loading off-thread".into();
1092            return;
1093        }
1094        if self.surface == DevSurface::Trust && matches!(hint, "I" | "O" | "1" | "T") {
1095            self.handle_printable(hint.chars().next().expect("trust action hint is non-empty"));
1096            return;
1097        }
1098        let prefix = action.key;
1099        if prefix == ":" {
1100            // Strip documentation placeholders from the editable command so
1101            // users can type values immediately instead of backspacing
1102            // `NAME`, `QUERY`, or `RUN_ID` out of the input line.
1103            let prefill = hint
1104                .split_whitespace()
1105                .take_while(|token| {
1106                    !token
1107                        .chars()
1108                        .all(|character| character.is_ascii_uppercase() || character == '_')
1109                })
1110                .collect::<Vec<_>>()
1111                .join(" ");
1112            if prefill.is_empty() || prefill == hint {
1113                self.open_palette_with(hint);
1114            } else {
1115                self.open_palette_with(&format!("{prefill} "));
1116            }
1117        } else if hint == "i" {
1118            if self.surface == DevSurface::Agent {
1119                self.open_composer();
1120            } else {
1121                self.enter_code_edit();
1122            }
1123        } else if hint == "Enter" {
1124            if self.surface == DevSurface::Code {
1125                self.open_selected_file();
1126            }
1127        } else if hint == "Ctrl-S" && self.surface == DevSurface::Code {
1128            self.edit_code_key(
1129                crossterm::event::KeyCode::Char('s'),
1130                crossterm::event::KeyModifiers::CONTROL,
1131            );
1132        } else {
1133            self.status = format!("{name} is available from this surface");
1134        }
1135    }
1136
1137    pub fn move_menu_selection(&mut self, delta: i32) {
1138        let count = self.surface_actions().len() as i32 + 2;
1139        self.menu_selection =
1140            (self.menu_selection as i32 + delta).rem_euclid(count.max(1)) as usize;
1141    }
1142
1143    pub fn open_palette(&mut self) {
1144        self.close_file_picker();
1145        self.command_mode = true;
1146        self.command_input.clear();
1147        self.command_cursor = 0;
1148        self.command_history_index = None;
1149        self.palette_error = None;
1150        self.palette_scroll = 0;
1151        self.palette_selection = 0;
1152        self.status = format!(
1153            "Command search · {} actions · ↑↓ select · Enter run · Ctrl-P files",
1154            self.surface.label()
1155        );
1156    }
1157
1158    pub fn close_palette(&mut self) {
1159        self.command_mode = false;
1160        self.command_input.clear();
1161        self.command_cursor = 0;
1162        self.command_history_index = None;
1163        self.palette_error = None;
1164        self.palette_scroll = 0;
1165        self.palette_selection = 0;
1166        self.status = "Command palette closed · press : for guided launchers".into();
1167    }
1168
1169    pub fn palette_action_indices(&self) -> Vec<usize> {
1170        let query = self.command_input.trim();
1171        self.surface_actions()
1172            .iter()
1173            .enumerate()
1174            .filter_map(|(index, action)| {
1175                let haystack =
1176                    format!("{} {} {}", action.label, action.command, action.description);
1177                fuzzy_contains(&haystack, query).then_some(index)
1178            })
1179            .collect()
1180    }
1181
1182    pub fn selected_palette_action(&self) -> Option<command::SurfaceAction> {
1183        let indices = self.palette_action_indices();
1184        indices
1185            .get(self.palette_selection)
1186            .and_then(|index| self.surface_actions().get(*index))
1187            .copied()
1188    }
1189
1190    pub fn move_palette_selection(&mut self, delta: i32) {
1191        let count = self.palette_action_indices().len();
1192        if count == 0 {
1193            return;
1194        }
1195        self.palette_selection =
1196            (self.palette_selection as i32 + delta).rem_euclid(count as i32) as usize;
1197        self.palette_error = None;
1198        self.palette_scroll = 0;
1199        if let Some(action) = self.selected_palette_action() {
1200            self.status = format!("{} · Enter runs", action.label);
1201        }
1202    }
1203
1204    pub fn submit_palette(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1205        let typed = self.command_input.trim().to_string();
1206        let typed_root = typed.split_whitespace().next().unwrap_or("");
1207        let command = match (typed_root, self.selected_palette_action()) {
1208            ("a" | "actions" | "help" | "?" | "q" | "quit" | "open" | "search" | "doctor", _) => {
1209                self.command_mode = false;
1210                self.command_input.clear();
1211                self.command_cursor = 0;
1212                self.command_history_index = None;
1213                self.palette_scroll = 0;
1214                self.palette_selection = 0;
1215                Some(typed)
1216            }
1217            (_, Some(action)) => self.prepare_palette_action(action),
1218            (_, None) if typed.is_empty() => {
1219                self.status = "No matching palette action · Esc closes".into();
1220                return;
1221            }
1222            (_, None) => {
1223                self.command_mode = false;
1224                self.command_input.clear();
1225                self.command_cursor = 0;
1226                self.command_history_index = None;
1227                self.palette_scroll = 0;
1228                self.palette_selection = 0;
1229                Some(typed)
1230            }
1231        };
1232
1233        let Some(input) = command else {
1234            if !self.command_mode {
1235                self.submit_queued_tool(worker);
1236                worker.request_refresh();
1237            }
1238            return;
1239        };
1240
1241        if self.command_history.last() != Some(&input) {
1242            self.command_history.push(input.clone());
1243            if self.command_history.len() > 32 {
1244                self.command_history.remove(0);
1245            }
1246        }
1247        match command::execute(self, &input) {
1248            Ok(message) => {
1249                self.palette_error = None;
1250                self.status = message;
1251            }
1252            Err(error) => {
1253                self.palette_error = Some(error.clone());
1254                self.status = format!("Error: {error}");
1255            }
1256        }
1257        self.submit_queued_tool(worker);
1258        worker.request_refresh();
1259    }
1260
1261    fn prepare_palette_action(&mut self, action: command::SurfaceAction) -> Option<String> {
1262        self.palette_error = None;
1263        match action.command {
1264            "i" => {
1265                self.command_mode = false;
1266                if self.surface == DevSurface::Agent {
1267                    self.open_composer();
1268                } else {
1269                    self.enter_code_edit();
1270                }
1271                None
1272            }
1273            "Enter" => {
1274                self.command_mode = false;
1275                if self.surface == DevSurface::Code {
1276                    self.open_selected_file();
1277                }
1278                None
1279            }
1280            "browser navigate URL" => {
1281                self.surface = DevSurface::App;
1282                self.open_palette_with("browser navigate ");
1283                self.status =
1284                    "Navigate · type a URL or domain (https:// optional), then press Enter".into();
1285                None
1286            }
1287            "browser type TARGET TEXT" => {
1288                self.surface = DevSurface::App;
1289                self.open_palette_with("browser type ");
1290                self.status = "Type · enter the target and text, then press Enter".into();
1291                None
1292            }
1293            "browser view" => {
1294                self.command_mode = false;
1295                self.browser_visual_live = !self.browser_visual_live;
1296                self.status = if self.browser_visual_live {
1297                    "Live view starting · command palette can stop it".into()
1298                } else {
1299                    "Live view off · semantic inspection remains available".into()
1300                };
1301                None
1302            }
1303            "process start dev"
1304                if matches!(self.surface, DevSurface::Terminal | DevSurface::More) =>
1305            {
1306                self.command_mode = false;
1307                self.request_detected_dev();
1308                None
1309            }
1310            "debug threads SESSION" | "debug continue SESSION THREAD_ID" => {
1311                if let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) {
1312                    let action = action
1313                        .command
1314                        .split_whitespace()
1315                        .nth(1)
1316                        .unwrap_or("threads");
1317                    if action == "continue" {
1318                        if let Some(thread) = self.selected_debug_thread() {
1319                            self.open_palette_with(&format!(
1320                                "debug continue {session} {}",
1321                                thread.id
1322                            ));
1323                        } else {
1324                            self.open_palette_with(&format!("debug continue {session} "));
1325                        }
1326                    } else {
1327                        self.open_palette_with(&format!("debug threads {session}"));
1328                    }
1329                    None
1330                } else {
1331                    self.open_palette_with("debug threads ");
1332                    None
1333                }
1334            }
1335            "process logs NAME" | "process stop NAME" | "process restart NAME" => {
1336                if let Some(name) = self
1337                    .selected_process_entry()
1338                    .map(|entry| entry.name.clone())
1339                {
1340                    let action = action.command.split_whitespace().nth(1).unwrap_or("logs");
1341                    self.open_palette_with(&format!("process {action} {name}"));
1342                    None
1343                } else {
1344                    self.open_palette_with(&format!(
1345                        "{} ",
1346                        action
1347                            .command
1348                            .split_whitespace()
1349                            .take(2)
1350                            .collect::<Vec<_>>()
1351                            .join(" ")
1352                    ));
1353                    None
1354                }
1355            }
1356            "git diff" if self.surface == DevSurface::Git => {
1357                self.command_mode = false;
1358                self.git_diff_requested = true;
1359                self.status = "Git diff queued · loading off-thread".into();
1360                None
1361            }
1362            "1" | "T" | "I" | "O" => {
1363                self.command_mode = false;
1364                self.handle_printable(action.command.chars().next().unwrap());
1365                None
1366            }
1367            "Ctrl-S" if self.surface == DevSurface::Code => {
1368                self.command_mode = false;
1369                self.edit_code_key(
1370                    crossterm::event::KeyCode::Char('s'),
1371                    crossterm::event::KeyModifiers::CONTROL,
1372                );
1373                None
1374            }
1375            command => {
1376                let prefill = command
1377                    .split_whitespace()
1378                    .take_while(|token| {
1379                        !token
1380                            .chars()
1381                            .all(|character| character.is_ascii_uppercase() || character == '_')
1382                    })
1383                    .collect::<Vec<_>>()
1384                    .join(" ");
1385                if prefill != command {
1386                    self.open_palette_with(&format!("{prefill} "));
1387                    self.status = format!(
1388                        "{} · enter only the required value(s), then press Enter",
1389                        action.label
1390                    );
1391                    None
1392                } else {
1393                    self.command_mode = false;
1394                    self.command_input.clear();
1395                    self.command_cursor = 0;
1396                    self.command_history_index = None;
1397                    self.palette_scroll = 0;
1398                    self.palette_selection = 0;
1399                    Some(command.into())
1400                }
1401            }
1402        }
1403    }
1404
1405    pub fn insert_palette_char(&mut self, character: char) {
1406        self.command_input.insert(self.command_cursor, character);
1407        self.command_cursor += character.len_utf8();
1408        self.palette_error = None;
1409        self.command_history_index = None;
1410        self.palette_scroll = 0;
1411        self.palette_selection = 0;
1412    }
1413
1414    pub fn insert_palette_text(&mut self, text: &str) {
1415        for character in text.replace(['\r', '\n'], " ").chars().take(8_192) {
1416            self.insert_palette_char(character);
1417        }
1418    }
1419
1420    pub fn palette_backspace(&mut self) {
1421        if self.command_cursor == 0 {
1422            return;
1423        }
1424        let previous = self.command_input[..self.command_cursor]
1425            .char_indices()
1426            .next_back()
1427            .map(|(index, _)| index)
1428            .unwrap_or(0);
1429        self.command_input.drain(previous..self.command_cursor);
1430        self.command_cursor = previous;
1431        self.command_history_index = None;
1432        self.palette_scroll = 0;
1433        self.palette_selection = 0;
1434    }
1435
1436    fn palette_history_indices(&self) -> Vec<usize> {
1437        let visible = command::palette_order(self.surface);
1438        self.command_history
1439            .iter()
1440            .enumerate()
1441            .filter_map(|(index, input)| {
1442                let root = input.split_whitespace().next()?;
1443                let root = match root {
1444                    "?" => "help",
1445                    "q" => "quit",
1446                    "gh" => "github",
1447                    "tasks" => "task",
1448                    "tests" => "test",
1449                    "experiments" => "experiment",
1450                    "knowledge" => "memory",
1451                    "surfaces" | "backend" => "surface",
1452                    "tools" => "tool",
1453                    _ => root,
1454                };
1455                visible.contains(&root).then_some(index)
1456            })
1457            .collect()
1458    }
1459
1460    pub fn navigate_palette_history(&mut self, older: bool) {
1461        let history = self.palette_history_indices();
1462        if history.is_empty() {
1463            return;
1464        }
1465        let position = self
1466            .command_history_index
1467            .and_then(|index| history.iter().position(|candidate| *candidate == index));
1468        let next_position = match (position, older) {
1469            (None, true) => history.len() - 1,
1470            (None, false) => return,
1471            (Some(position), true) => position.saturating_sub(1),
1472            (Some(position), false) if position + 1 < history.len() => position + 1,
1473            (Some(_), false) => {
1474                self.command_history_index = None;
1475                self.command_input.clear();
1476                self.command_cursor = 0;
1477                self.palette_scroll = 0;
1478                self.palette_selection = 0;
1479                return;
1480            }
1481        };
1482        let index = history[next_position];
1483        self.command_history_index = Some(index);
1484        self.command_input.clone_from(&self.command_history[index]);
1485        self.command_cursor = self.command_input.len();
1486        self.palette_scroll = 0;
1487        self.palette_selection = 0;
1488    }
1489
1490    pub fn complete_palette(&mut self) {
1491        let Some(completion) = self.palette_matches().first().copied() else {
1492            return;
1493        };
1494        let suffix = self
1495            .command_input
1496            .find(char::is_whitespace)
1497            .map(|index| self.command_input[index..].to_string())
1498            .unwrap_or_default();
1499        self.command_input = format!("{completion}{suffix}");
1500        self.command_cursor = self.command_input.len();
1501        self.command_history_index = None;
1502        self.palette_scroll = 0;
1503        self.palette_selection = 0;
1504        self.status = format!("Completed `{completion}` · Enter runs · Ctrl-P/N history");
1505    }
1506
1507    pub fn open_palette_with(&mut self, prefix: &str) {
1508        self.open_palette();
1509        self.command_input = prefix.into();
1510        self.command_cursor = self.command_input.len();
1511    }
1512
1513    pub fn move_palette_cursor(&mut self, right: bool) {
1514        if right {
1515            self.command_cursor = self.command_input[self.command_cursor..]
1516                .char_indices()
1517                .nth(1)
1518                .map(|(offset, _)| self.command_cursor + offset)
1519                .unwrap_or(self.command_input.len());
1520        } else if self.command_cursor > 0 {
1521            self.command_cursor = self.command_input[..self.command_cursor]
1522                .char_indices()
1523                .next_back()
1524                .map(|(index, _)| index)
1525                .unwrap_or(0);
1526        }
1527    }
1528
1529    pub fn scroll_palette(&mut self, delta: i32) {
1530        self.move_palette_selection(delta.saturating_mul(5));
1531    }
1532
1533    pub fn palette_matches(&self) -> Vec<&'static str> {
1534        let query = self
1535            .command_input
1536            .split_whitespace()
1537            .next()
1538            .unwrap_or_default();
1539        command::palette_order(self.surface)
1540            .into_iter()
1541            .filter(|candidate| fuzzy_contains(candidate, query))
1542            .take(6)
1543            .collect()
1544    }
1545
1546    pub fn background_action_running(&self) -> bool {
1547        self.pending_confirmation.is_some()
1548            || self.pending_agent_approval.is_some()
1549            || self.running_tool_job.is_some()
1550            || self.queued_tool_request.is_some()
1551            || self.agent_send_job.is_some()
1552    }
1553
1554    pub fn agent_browser_context(&self) -> serde_json::Value {
1555        let semantic_summary = self.browser_workspace_summary();
1556        let state = self.browser_workspace.state();
1557        let selected_entity = state.selected().map(|entity| {
1558            serde_json::json!({
1559                "reference": entity.reference,
1560                "role": entity.role,
1561                "name": entity.name,
1562                "actionable": entity.actionable,
1563                "revision": entity.revision,
1564            })
1565        });
1566        let selected_target = state
1567            .targets
1568            .iter()
1569            .find(|target| target.selected)
1570            .map(|target| {
1571                serde_json::json!({
1572                    "id": target.id,
1573                    "title": target.title,
1574                    "url": safe_browser_url(&target.url),
1575                })
1576            });
1577        serde_json::json!({
1578            "schemaVersion": "glass.agent-context.v1",
1579            "browser": {
1580                "attached": state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected,
1581                "connection": serde_json::to_value(state.connection).unwrap_or(serde_json::Value::Null),
1582                "targetId": selected_target.as_ref().and_then(|target| target.get("id")).cloned(),
1583                "origin": page_origin(&state.url),
1584                "url": safe_browser_url(&state.url),
1585                "title": state.title,
1586                "browserRevision": state.browser_revision,
1587                "semanticSummary": semantic_summary,
1588                "selectedEntity": selected_entity,
1589                "workflowState": state.workflow,
1590                "inputOwner": serde_json::to_value(state.input_owner).unwrap_or(serde_json::Value::Null),
1591                "freshness": if state.semantic_invalidated { "stale" } else { "current" },
1592                "target": selected_target,
1593                "bootstrap": if state.connection == glass_browser::browser_workspace::BrowserConnectionPhase::Connected {
1594                    "attached; observe before acting"
1595                } else {
1596                    "detached; call glass.browser.start, then navigate and observe the requested URL"
1597                },
1598            },
1599            "authority": {
1600                "source": "Glass browser workspace",
1601                "mutationLeaseRequired": selected_entity.as_ref().is_some_and(|entity| {
1602                    entity.get("actionable").and_then(serde_json::Value::as_bool).unwrap_or(false)
1603                }),
1604            },
1605            "project": {
1606                "root": self.snapshot_root,
1607            },
1608        })
1609    }
1610    /// Snapshot the focused editor buffer for the shared workspace chat.
1611    ///
1612    /// Chat must see the same unsaved text the human sees, not only the
1613    /// on-disk file. Keep the attachment bounded; the agent can request the
1614    /// remainder through its file tools.
1615    pub fn agent_editor_context(&self) -> serde_json::Value {
1616        let buffer = self.focused_buffer();
1617        let focused = buffer.as_ref().map(|buffer| {
1618            let (content, truncated) = bounded_editor_content(&buffer.content);
1619            serde_json::json!({
1620                "path": buffer.path,
1621                "cursor": {
1622                    "line": buffer.cursor_line,
1623                    "column": buffer.cursor_column,
1624                },
1625                "selection": buffer.selection,
1626                "dirty": buffer.dirty,
1627                "actor": buffer.actor,
1628                "content": content,
1629                "contentTruncated": truncated,
1630            })
1631        });
1632        let project_revision = self
1633            .workspace
1634            .try_lock()
1635            .ok()
1636            .map(|workspace| workspace.project().revision());
1637        let comments = self
1638            .editor_comments
1639            .iter()
1640            .filter(|comment| {
1641                self.focused_editor_path.is_empty() || comment.path == self.focused_editor_path
1642            })
1643            .cloned()
1644            .collect::<Vec<_>>();
1645        let proposals = self
1646            .editor_proposals
1647            .iter()
1648            .filter(|proposal| {
1649                self.focused_editor_path.is_empty() || proposal.path == self.focused_editor_path
1650            })
1651            .cloned()
1652            .collect::<Vec<_>>();
1653        serde_json::json!({
1654            "focusedPath": self.focused_editor_path,
1655            "cursor": {
1656                "line": self.focused_editor_line,
1657                "column": self.focused_editor_column,
1658            },
1659            "dirty": self.focused_editor_dirty,
1660            "projectRevision": project_revision,
1661            "focusedBuffer": focused,
1662            "comments": comments,
1663            "proposals": proposals,
1664        })
1665    }
1666
1667    pub fn browser_chat_header(&self) -> String {
1668        let browser = self.browser_workspace.state();
1669        let page = if browser.url.is_empty() {
1670            "no page".to_string()
1671        } else {
1672            safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into())
1673        };
1674        let title = browser.title.trim();
1675        let include_title = !title.is_empty() && !title.eq_ignore_ascii_case(&page);
1676        let revision = browser
1677            .browser_revision
1678            .map_or_else(|| "—".to_string(), |revision| revision.to_string());
1679        let bootstrap = if browser.connection
1680            == glass_browser::browser_workspace::BrowserConnectionPhase::Connected
1681        {
1682            "observe before acting"
1683        } else {
1684            "ask `open <url>` to attach"
1685        };
1686        let mut header = format!("APP · {}", browser.connection_label());
1687        if include_title {
1688            header.push_str(" · ");
1689            header.push_str(title);
1690        }
1691        header.push_str(&format!(" · {} · rev {} · {}", page, revision, bootstrap));
1692        if let Some(entity) = browser.selected() {
1693            header.push_str(" · selected ");
1694            header.push_str(&entity.name);
1695        }
1696        header
1697    }
1698
1699    pub fn conversation_view(&self) -> String {
1700        let mut conversation = if self.agent_conversation.starts_with("No conversation yet.")
1701            && !self.pending_chat_messages.is_empty()
1702        {
1703            String::new()
1704        } else {
1705            self.agent_conversation.clone()
1706        };
1707        let mut observed = std::collections::BTreeMap::<String, usize>::new();
1708        for message in &self.pending_chat_messages {
1709            if message.state != ChatMessageState::Failed {
1710                let marker = format!("YOU\n{}", message.text);
1711                let seen = observed.entry(message.text.clone()).or_default();
1712                if *seen < conversation.matches(&marker).count() {
1713                    *seen += 1;
1714                    continue;
1715                }
1716            }
1717            if !conversation.is_empty() {
1718                conversation.push_str("\n\n");
1719            }
1720            conversation.push_str("YOU\n");
1721            conversation.push_str(&message.text);
1722            conversation.push('\n');
1723            match message.state {
1724                ChatMessageState::Sending => conversation.push_str("· sending…"),
1725                ChatMessageState::Sent => {
1726                    conversation.push_str("· sent · Glass Agent is thinking…")
1727                }
1728                ChatMessageState::Failed => {
1729                    conversation.push_str("× send failed");
1730                    if let Some(error) = message.error.as_deref() {
1731                        conversation.push_str(": ");
1732                        conversation.push_str(error);
1733                    }
1734                    conversation.push_str(" · press Enter to retry");
1735                }
1736            }
1737        }
1738        conversation
1739    }
1740
1741    pub fn conversation_entries_view(&self) -> Vec<super::projection::ConversationEntry> {
1742        let mut entries = self.conversation_items.clone();
1743        if entries.is_empty() && !self.agent_conversation.starts_with("No conversation yet.") {
1744            entries = parse_conversation_view(&self.agent_conversation);
1745        }
1746        let mut observed = std::collections::BTreeMap::<String, usize>::new();
1747        for message in &self.pending_chat_messages {
1748            if message.state != ChatMessageState::Failed {
1749                let seen = observed.entry(message.text.clone()).or_default();
1750                let existing = entries
1751                    .iter()
1752                    .filter(|entry| {
1753                        entry.kind == super::projection::ConversationKind::User
1754                            && entry.text == message.text
1755                    })
1756                    .count();
1757                if *seen < existing {
1758                    *seen += 1;
1759                    continue;
1760                }
1761            }
1762            let suffix = match message.state {
1763                ChatMessageState::Sending => "· sending…",
1764                ChatMessageState::Sent => "· sent · Glass Agent is thinking…",
1765                ChatMessageState::Failed => "× send failed · press Enter to retry",
1766            };
1767            entries.push(super::projection::ConversationEntry {
1768                kind: super::projection::ConversationKind::User,
1769                text: format!("{}\n{suffix}", message.text),
1770                streaming: false,
1771                entry_id: None,
1772                tool_name: None,
1773            });
1774        }
1775        entries
1776    }
1777
1778    pub fn composer_context_chips(&self) -> String {
1779        let mut chips = Vec::new();
1780        if !self.focused_editor_path.is_empty() {
1781            chips.push(format!("@{}", self.focused_editor_path));
1782        } else if let Some(path) = self.files.get(self.selected_file) {
1783            chips.push(format!("@{path}"));
1784        }
1785        if self.focused_editor_selection.is_some() {
1786            chips.push("selection".into());
1787        }
1788        if let Some(entity) = self.browser_workspace.state().selected() {
1789            chips.push(format!("app {}", entity.name));
1790        }
1791        if self.pending_verify.is_some() {
1792            chips.push("prove-it".into());
1793        }
1794        if self.composer_steer {
1795            chips.push("steer".into());
1796        }
1797        chips.join(" · ")
1798    }
1799
1800    pub fn agent_chrome_line(&self) -> String {
1801        let mut parts = Vec::new();
1802        if !self.agent_model.is_empty() {
1803            parts.push(self.agent_model.clone());
1804        }
1805        if !self.agent_thinking.is_empty() {
1806            parts.push(format!("think {}", self.agent_thinking));
1807        }
1808        if !self.agent_session_name.is_empty() {
1809            parts.push(self.agent_session_name.clone());
1810        }
1811        if !self.agent_token_summary.is_empty() {
1812            parts.push(self.agent_token_summary.clone());
1813        }
1814        let queued = self
1815            .pending_chat_messages
1816            .iter()
1817            .filter(|message| matches!(message.state, ChatMessageState::Sending))
1818            .count();
1819        if queued > 0 {
1820            parts.push(format!("queued {queued}"));
1821        }
1822        parts.join(" · ")
1823    }
1824
1825    pub fn move_transcript_selection(&mut self, delta: i32) {
1826        let len = self.conversation_entries_view().len();
1827        if len == 0 {
1828            self.scroll_surface(delta);
1829            return;
1830        }
1831        let next = self.transcript_selection as i32 + delta;
1832        self.transcript_selection = next.clamp(0, len as i32 - 1) as usize;
1833        self.transcript_expanded = false;
1834        self.status = format!(
1835            "Bubble {}/{} · f fork · r rewind · e edit last · o expand",
1836            self.transcript_selection + 1,
1837            len
1838        );
1839    }
1840
1841    pub fn toggle_transcript_expand(&mut self) {
1842        self.transcript_expanded = !self.transcript_expanded;
1843        self.status = if self.transcript_expanded {
1844            "Expanded tool card · o collapse".into()
1845        } else {
1846            "Collapsed · o expand".into()
1847        };
1848    }
1849
1850    pub fn fork_selected_transcript(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1851        self.branch_selected_transcript("glass.agent.fork", worker);
1852    }
1853
1854    pub fn rewind_selected_transcript(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1855        self.branch_selected_transcript("glass.agent.rewind", worker);
1856    }
1857
1858    fn branch_selected_transcript(
1859        &mut self,
1860        tool: &str,
1861        worker: &mut super::snapshot::SnapshotWorker,
1862    ) {
1863        let Some(entry) = self
1864            .conversation_entries_view()
1865            .get(self.transcript_selection)
1866            .cloned()
1867        else {
1868            self.status = "No transcript bubble to branch".into();
1869            return;
1870        };
1871        let Some(entry_id) = entry.entry_id.clone() else {
1872            self.status = "Selected bubble has no Pi entry · send a turn first".into();
1873            return;
1874        };
1875        let mut arguments = serde_json::json!({"entryId": entry_id});
1876        if let Some(agent) = self.selected_agent.as_ref() {
1877            arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1878        }
1879        match self.tool_request(tool, arguments, true) {
1880            Ok((call, context)) => match worker.submit_tool(call, context) {
1881                Ok(_) => {
1882                    self.status = format!("{tool} · branching at {entry_id}");
1883                    worker.request_conversation();
1884                }
1885                Err(error) => self.status = format!("Could not {tool}: {error}"),
1886            },
1887            Err(error) => self.status = format!("Could not {tool}: {error}"),
1888        }
1889    }
1890
1891    pub fn edit_last_user_message(&mut self) {
1892        let entries = self.conversation_entries_view();
1893        let Some(entry) = entries
1894            .iter()
1895            .rev()
1896            .find(|entry| entry.kind == super::projection::ConversationKind::User)
1897        else {
1898            self.status = "No user message to edit".into();
1899            return;
1900        };
1901        let text = entry
1902            .text
1903            .lines()
1904            .next()
1905            .unwrap_or(entry.text.as_str())
1906            .to_string();
1907        self.composer_input = text;
1908        self.composer_cursor = self.composer_input.len();
1909        self.composer_steer = false;
1910        self.open_composer();
1911        if let Some(entry_id) = entry.entry_id.clone() {
1912            self.status = format!("Editing last user message · rewind {entry_id} on send");
1913        } else {
1914            self.status = "Editing last user message · Enter resends".into();
1915        }
1916    }
1917
1918    pub fn open_session_picker(&mut self, value: &serde_json::Value) {
1919        self.session_picker_items = parse_session_picker_items(value);
1920        self.session_picker_selection = 0;
1921        self.session_picker_open = !self.session_picker_items.is_empty();
1922        self.status = if self.session_picker_open {
1923            format!(
1924                "{} Pi session(s) · Enter switch · Esc close",
1925                self.session_picker_items.len()
1926            )
1927        } else {
1928            "No persisted Pi sessions".into()
1929        };
1930    }
1931
1932    pub fn close_session_picker(&mut self) {
1933        self.session_picker_open = false;
1934    }
1935
1936    pub fn move_session_picker_selection(&mut self, delta: i32) {
1937        if self.session_picker_items.is_empty() {
1938            return;
1939        }
1940        let next = self.session_picker_selection as i32 + delta;
1941        self.session_picker_selection =
1942            next.clamp(0, self.session_picker_items.len() as i32 - 1) as usize;
1943    }
1944
1945    pub fn submit_session_picker(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
1946        let Some(item) = self.session_picker_items.get(self.session_picker_selection) else {
1947            self.status = "No session selected".into();
1948            return;
1949        };
1950        let mut arguments = serde_json::json!({"path": item.path});
1951        if let Some(agent) = self.selected_agent.as_ref() {
1952            arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
1953        }
1954        match self.tool_request("glass.agent.switch-session", arguments, true) {
1955            Ok((call, context)) => match worker.submit_tool(call, context) {
1956                Ok(_) => {
1957                    self.agent_session_name = item.label.clone();
1958                    self.session_picker_open = false;
1959                    self.status = format!("Switching to {}", item.label);
1960                    worker.request_conversation();
1961                }
1962                Err(error) => self.status = format!("Could not switch session: {error}"),
1963            },
1964            Err(error) => self.status = format!("Could not switch session: {error}"),
1965        }
1966    }
1967
1968    fn composer_send_blocked(&self) -> bool {
1969        self.pending_confirmation.is_some()
1970            || self.pending_agent_approval.is_some()
1971            || self.queued_tool_request.is_some()
1972            || (self.running_tool_job.is_some() && self.agent_send_job.is_none())
1973    }
1974
1975    fn reconcile_pending_chat(&mut self) {
1976        let conversation = self.agent_conversation.clone();
1977        let mut confirmed = std::collections::BTreeMap::<String, usize>::new();
1978        self.pending_chat_messages.retain(|message| {
1979            if message.state == ChatMessageState::Failed {
1980                return true;
1981            }
1982            let marker = format!("YOU\n{}", message.text);
1983            let observed = conversation.matches(&marker).count();
1984            let seen = confirmed.entry(message.text.clone()).or_default();
1985            if *seen < observed {
1986                *seen += 1;
1987                false
1988            } else {
1989                true
1990            }
1991        });
1992    }
1993    /// Start the shortest in-TUI path to a usable agent conversation.
1994    pub fn start_agent_interaction(&mut self) {
1995        if self.snapshot_trust_label == "untrusted" {
1996            self.surface = DevSurface::Trust;
1997            self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
1998            return;
1999        }
2000        match crate::pi_runtime::pi_readiness() {
2001            Ok(readiness) if readiness.ready => self.open_composer(),
2002            Ok(readiness)
2003                if readiness.node.state != crate::pi_runtime::PiReadinessState::Ready
2004                    || readiness.sdk.state != crate::pi_runtime::PiReadinessState::Ready =>
2005            {
2006                self.request_agent_setup();
2007            }
2008            Ok(_) => {
2009                let _ = self.request_agent_login();
2010            }
2011            Err(error) => {
2012                self.status = format!("Pi readiness unavailable · use :agent setup: {error}");
2013            }
2014        }
2015    }
2016
2017    /// Select a resident agent without forcing the user through the command
2018    /// palette. The selected agent becomes the target for follow-up and
2019    /// session-control actions.
2020    pub fn cycle_agent_selection(&mut self, delta: i32) {
2021        let agents = match self.workspace.try_lock() {
2022            Ok(mut workspace) => match workspace.agents().list() {
2023                Ok(agents) => agents,
2024                Err(error) => {
2025                    self.status = format!("Agent list unavailable: {error}");
2026                    return;
2027                }
2028            },
2029            Err(error) => {
2030                self.status = format!("Agent list unavailable: {error}");
2031                return;
2032            }
2033        };
2034        if agents.is_empty() {
2035            self.selected_agent = None;
2036            self.status = "No resident agents · Enter starts the Glass Agent".into();
2037            return;
2038        }
2039        let current = self
2040            .selected_agent
2041            .as_ref()
2042            .and_then(|selected| agents.iter().position(|agent| &agent.id == selected))
2043            .unwrap_or(0);
2044        let next = if delta.is_negative() {
2045            (current + agents.len() - (delta.unsigned_abs() as usize % agents.len())) % agents.len()
2046        } else {
2047            (current + (delta as usize % agents.len())) % agents.len()
2048        };
2049        let selected = agents[next].id.clone();
2050        self.selected_agent = Some(selected.clone());
2051        self.status = format!(
2052            "Selected {} · Enter chats · ]/[ switches agent",
2053            selected.as_str()
2054        );
2055    }
2056
2057    pub fn open_composer(&mut self) {
2058        self.close_file_picker();
2059        self.composer_mode = true;
2060        self.composer_cursor = self.composer_input.len();
2061        self.status = format!(
2062            "{} dock on {} · Enter sends · Tab @mention · Shift-Enter newline · Ctrl-Shift-A mode · Esc back",
2063            self.composer_run_mode.label(),
2064            self.surface.label()
2065        );
2066    }
2067
2068    /// Focus the shared chat dock without changing the active surface.
2069    pub fn focus_composer_dock(&mut self) {
2070        if self.snapshot_trust_label == "untrusted" {
2071            self.surface = DevSurface::Trust;
2072            self.status = "Trust this workspace before chatting · T or 1".into();
2073            return;
2074        }
2075        if !self.agent_readiness.starts_with("✓ Ready") {
2076            self.start_agent_interaction();
2077            return;
2078        }
2079        self.open_composer();
2080    }
2081
2082    pub fn cycle_composer_run_mode(&mut self) {
2083        self.composer_run_mode = self.composer_run_mode.next();
2084        let _ = self.ws_mut().map(|mut workspace| {
2085            workspace.set_agent_turn_mode(self.composer_run_mode);
2086        });
2087        self.status = format!(
2088            "{} mode · Ask is read-only · Plan writes a reviewable plan · Agent proposes",
2089            self.composer_run_mode.label()
2090        );
2091        if self.composer_mode {
2092            self.open_composer();
2093        }
2094    }
2095
2096    pub fn set_composer_run_mode(&mut self, mode: crate::AgentTurnMode) {
2097        self.composer_run_mode = mode;
2098        let _ = self.ws_mut().map(|mut workspace| {
2099            workspace.set_agent_turn_mode(mode);
2100        });
2101        self.status = format!("{} mode", mode.label());
2102    }
2103
2104    pub fn toggle_selected_git_stage(&mut self) {
2105        let Some(entry) = self.selected_git_entry().cloned() else {
2106            self.status = "Select a changed file · Space stages or unstages".into();
2107            return;
2108        };
2109        let staged = entry.index_status != ' ' && !entry.untracked;
2110        let tool = if staged {
2111            "glass.git.unstage"
2112        } else {
2113            "glass.git.stage"
2114        };
2115        let arguments = serde_json::json!({"paths": [entry.path]});
2116        match self.tool_request(tool, arguments, true) {
2117            Ok((call, context)) => {
2118                let summary = format!(
2119                    "{} {}",
2120                    if staged { "Unstage" } else { "Stage" },
2121                    self.selected_git_entry()
2122                        .map(|entry| entry.path.as_str())
2123                        .unwrap_or("path")
2124                );
2125                let _ = self.queue_or_confirm(call, context, summary);
2126            }
2127            Err(error) => self.status = format!("Git stage unavailable: {error}"),
2128        }
2129    }
2130
2131    pub fn jump_to_app_keep_dock(&mut self) {
2132        self.surface = DevSurface::App;
2133        self.status = if self.composer_mode {
2134            "App · dock stays open · watch the agent or type a follow-up".into()
2135        } else {
2136            "App selected · Ctrl-L talks about this page".into()
2137        };
2138    }
2139
2140    pub fn watch_agent_on_app(&mut self, tool: &str, value: &serde_json::Value) {
2141        self.browser_workspace.state_mut().input_owner =
2142            glass_browser::browser_workspace::BrowserInputOwner::Agent;
2143        if !self.browser_visual_live {
2144            self.browser_visual_live = true;
2145        }
2146        let target = value
2147            .get("target")
2148            .or_else(|| value.get("name"))
2149            .and_then(serde_json::Value::as_str)
2150            .unwrap_or("page");
2151        let action = tool.rsplit('.').next().unwrap_or("act");
2152        self.status = format!("Agent {action} {target} · watching · Ctrl-L to steer");
2153    }
2154
2155    pub fn comment_selected_app_entity(&mut self) {
2156        let Some(entity) = self.browser_workspace.state().selected().cloned() else {
2157            self.status = "No App entity selected · ↑/↓ then C comments".into();
2158            return;
2159        };
2160        self.last_app_comment = Some(format!("{} ({})", entity.name, entity.role));
2161        self.composer_input = format!(
2162            "About the selected App control [{}] {}: ",
2163            entity.role, entity.name
2164        );
2165        self.composer_cursor = self.composer_input.len();
2166        self.focus_composer_dock();
2167        self.status = format!(
2168            "App comment on {} · finish the note, then Enter",
2169            entity.name
2170        );
2171    }
2172
2173    pub fn capture_plan_from_goal(&mut self, goal: &str) {
2174        self.pending_plan = Some(WorkspacePlan {
2175            id: format!(
2176                "plan-{}",
2177                std::time::SystemTime::now()
2178                    .duration_since(std::time::UNIX_EPOCH)
2179                    .map(|duration| duration.as_millis())
2180                    .unwrap_or(0)
2181            ),
2182            goal: goal.chars().take(240).collect(),
2183            body: String::new(),
2184            accepted: false,
2185        });
2186    }
2187
2188    pub fn accept_pending_plan(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2189        let Some(mut plan) = self.pending_plan.clone() else {
2190            self.status = "No plan to accept · switch to Plan and send a goal".into();
2191            return;
2192        };
2193        if plan.body.is_empty()
2194            && let Some(entry) = self
2195                .conversation_entries_view()
2196                .into_iter()
2197                .rev()
2198                .find(|entry| entry.kind == super::projection::ConversationKind::Assistant)
2199        {
2200            plan.body = entry.text;
2201        }
2202        plan.accepted = true;
2203        self.persist_plan(&plan);
2204        if let Ok(list) = self.ws_mut().and_then(|mut workspace| {
2205            workspace
2206                .seed_todos_from_plan(&plan.goal, &plan.body)
2207                .map_err(|error| error.to_string())
2208        }) {
2209            self.session_todos = list;
2210        }
2211        self.pending_plan = Some(plan.clone());
2212        self.set_composer_run_mode(crate::AgentTurnMode::Agent);
2213        self.composer_input = format!(
2214            "Implement this accepted plan. Stay in proposals unless I say otherwise.\n\nGoal: {}\n\n{}",
2215            plan.goal, plan.body
2216        );
2217        self.composer_cursor = self.composer_input.len();
2218        self.open_composer();
2219        self.submit_composer(worker);
2220        self.status = format!("Plan {} accepted · Agent implementing", plan.id);
2221    }
2222
2223    pub fn reject_pending_plan(&mut self) {
2224        if let Some(plan) = self.pending_plan.as_mut() {
2225            plan.accepted = false;
2226            self.status = format!("Plan {} rejected · stay in Plan and revise", plan.id);
2227        } else {
2228            self.status = "No plan to reject".into();
2229        }
2230        self.set_composer_run_mode(crate::AgentTurnMode::Plan);
2231    }
2232
2233    fn persist_plan(&self, plan: &WorkspacePlan) {
2234        let Ok(workspace) = self.ws() else {
2235            return;
2236        };
2237        let dir = workspace.root().join(".glass/plans");
2238        let _ = std::fs::create_dir_all(&dir);
2239        let _ = std::fs::write(
2240            dir.join("latest.json"),
2241            serde_json::to_vec_pretty(plan).unwrap_or_default(),
2242        );
2243    }
2244
2245    /// Move from the native editor into the shared agent conversation with
2246    /// the focused buffer attached as unsaved, bounded context.
2247    pub fn prepare_editor_agent_prompt(&mut self) {
2248        let Some(buffer) = self.focused_buffer() else {
2249            self.status = "No open buffer · open a file before asking Pi".into();
2250            return;
2251        };
2252        let line = buffer
2253            .content
2254            .lines()
2255            .nth(buffer.cursor_line.saturating_sub(1) as usize)
2256            .unwrap_or_default()
2257            .trim();
2258        let line_preview = line.chars().take(240).collect::<String>();
2259        self.composer_input = format!(
2260            "Help me with {}:{}:{}.\nInspect the attached editor buffer and explain the safest minimal change. Current line: `{line_preview}`. Do not edit files until I approve a concrete proposal.",
2261            buffer.path, buffer.cursor_line, buffer.cursor_column
2262        );
2263        self.composer_cursor = self.composer_input.len();
2264        self.composer_steer = false;
2265        self.code_edit_mode = false;
2266        self.editor_exit_prompt = None;
2267        self.open_composer();
2268        self.status = format!(
2269            "Editor context attached · stay on Code · {}:{} · Enter sends",
2270            buffer.path, buffer.cursor_line
2271        );
2272    }
2273
2274    pub fn review_object_text(&self) -> String {
2275        let proposals = self
2276            .editor_proposals
2277            .iter()
2278            .map(|item| {
2279                (
2280                    item.id.clone(),
2281                    item.path.clone(),
2282                    format!("{:?}", item.state),
2283                )
2284            })
2285            .collect::<Vec<_>>();
2286        let checkpoint = self
2287            .editor_checkpoints
2288            .last()
2289            .map(|item| item.name.as_str());
2290        let diff = if self.git_diff.starts_with("REVIEW") {
2291            None
2292        } else {
2293            Some(self.git_diff.as_str()).filter(|diff| !diff.trim().is_empty())
2294        };
2295        let wake = self.last_crew_wake.as_deref();
2296        let packed = wake.is_some_and(|wake| wake.starts_with("WAKE"));
2297        super::editor::review_object(
2298            &self.github.summary(),
2299            &self.github_review,
2300            &proposals,
2301            super::editor::ReviewEvidence {
2302                last_verify: if packed {
2303                    None
2304                } else {
2305                    self.last_verify.as_deref()
2306                },
2307                git_diff: if packed { None } else { diff },
2308                tasks: if packed {
2309                    None
2310                } else {
2311                    Some(self.tasks.as_str()).filter(|tasks| !tasks.trim().is_empty())
2312                },
2313                checkpoint: if packed { None } else { checkpoint },
2314                wake,
2315            },
2316        )
2317    }
2318
2319    pub fn refresh_review_object(&mut self) {
2320        self.refresh_crew_wake_from_live();
2321        let text = self.review_object_text();
2322        self.editor = text.clone();
2323        self.git_diff = text;
2324        self.git_diff_path = Some("REVIEW".into());
2325        self.git_diff_open = true;
2326        self.status = "REVIEW · :review accept applies the pack · ship TITLE · ask".into();
2327    }
2328
2329    pub fn accept_review_pack(&mut self) -> Result<String, String> {
2330        self.auto_checkpoint("before-review-accept");
2331        match self.locked(|workspace| {
2332            workspace
2333                .project_mut()
2334                .accept_pending_editor_proposals(crate::development::Actor::local())
2335        }) {
2336            Some(Ok(buffers)) => {
2337                self.refresh_editor_hunks();
2338                self.refresh_editor_projection();
2339                self.refresh_review_object();
2340                Ok(format!(
2341                    "Accepted {} proposal(s) from the wake pack",
2342                    buffers.len()
2343                ))
2344            }
2345            Some(Err(crate::development::DevelopmentError::NotFound(_))) => {
2346                Err("No pending proposals in the wake pack".into())
2347            }
2348            Some(Err(error)) => Err(error.to_string()),
2349            None => Err("Accept failed · workspace busy".into()),
2350        }
2351    }
2352
2353    pub fn accept_review_proposal(&mut self, id: Option<&str>) -> Result<String, String> {
2354        let id = self.resolve_review_proposal_id(id)?;
2355        self.auto_checkpoint("before-review-accept");
2356        match self.locked(|workspace| {
2357            workspace
2358                .project_mut()
2359                .accept_editor_proposal(&id, crate::development::Actor::local())
2360                .map(|_| ())
2361        }) {
2362            Some(Ok(())) => {
2363                self.refresh_editor_hunks();
2364                self.refresh_editor_projection();
2365                self.refresh_review_object();
2366                Ok(format!("Accepted proposal {id}"))
2367            }
2368            Some(Err(error)) => Err(error.to_string()),
2369            None => Err("Accept failed · workspace busy".into()),
2370        }
2371    }
2372
2373    pub fn reject_review_proposal(&mut self, id: Option<&str>) -> Result<String, String> {
2374        let id = self.resolve_review_proposal_id(id)?;
2375        match self.locked(|workspace| {
2376            workspace
2377                .project_mut()
2378                .reject_editor_proposal(&id, crate::development::Actor::local())
2379                .map(|_| ())
2380        }) {
2381            Some(Ok(())) => {
2382                self.refresh_editor_hunks();
2383                self.refresh_review_object();
2384                Ok(format!("Rejected proposal {id}"))
2385            }
2386            Some(Err(error)) => Err(error.to_string()),
2387            None => Err("Reject failed · workspace busy".into()),
2388        }
2389    }
2390
2391    fn resolve_review_proposal_id(&self, id: Option<&str>) -> Result<String, String> {
2392        if let Some(id) = id {
2393            return Ok(id.to_string());
2394        }
2395        self.editor_proposals
2396            .iter()
2397            .find(|item| item.state == crate::development::EditorProposalState::Pending)
2398            .map(|item| item.id.clone())
2399            .ok_or_else(|| "No pending editor proposal".into())
2400    }
2401
2402    fn refresh_crew_wake_from_live(&mut self) {
2403        let accept = self
2404            .editor_proposals
2405            .iter()
2406            .find(|proposal| proposal.state == crate::development::EditorProposalState::Pending)
2407            .map(|proposal| proposal.id.clone());
2408        let browser = self.browser_workspace.state();
2409        let page = if browser.url.is_empty() && browser.selected().is_none() {
2410            None
2411        } else {
2412            Some(self.page_evidence())
2413        };
2414        let live = crate::CrewWakeLiveEvidence {
2415            verify: self.last_verify.clone(),
2416            page,
2417            accept,
2418        };
2419        if let Some(Ok(Some(wake))) = self.locked(|workspace| workspace.refresh_crew_wake(live)) {
2420            self.last_crew_wake = Some(wake.render());
2421        }
2422    }
2423
2424    fn page_evidence(&self) -> String {
2425        let browser = self.browser_workspace.state();
2426        let url = safe_browser_url(&browser.url).unwrap_or_else(|| "—".into());
2427        let entity = browser
2428            .selected()
2429            .map(|entity| entity.reference.as_str())
2430            .unwrap_or("—");
2431        format!(
2432            "url {url}\n  entity {entity}\n  revision {}",
2433            browser.browser_revision.unwrap_or(0)
2434        )
2435    }
2436
2437    /// Prepare an editable review prompt using the current workspace evidence.
2438    pub fn prepare_review_prompt(&mut self) {
2439        self.composer_input = "Review the current workspace changes. Inspect the Git diff, changed files, diagnostics, and latest test results. Report concrete correctness, security, regression, and missing-test risks. Do not edit files until I approve a fix.".into();
2440        self.composer_cursor = self.composer_input.len();
2441        self.composer_steer = false;
2442        self.open_composer();
2443        self.status =
2444            "Review prompt ready · edit it, then press Enter to ask the Glass Agent".into();
2445    }
2446
2447    pub fn toggle_composer_steer(&mut self) {
2448        self.composer_steer = !self.composer_steer;
2449        self.status = if self.composer_steer {
2450            "Steer mode · Enter interrupts the running agent".into()
2451        } else {
2452            "Follow-up mode · Enter sends during or after the current turn".into()
2453        };
2454    }
2455
2456    /// Queue the managed Pi SDK install behind the same one-use confirmation
2457    /// sheet used by every other mutating TUI action.
2458    pub fn request_agent_setup(&mut self) {
2459        self.request_agent_setup_mode(false);
2460    }
2461
2462    /// Queue a forced reinstall of the pinned managed Pi SDK.
2463    pub fn request_agent_update(&mut self) {
2464        self.request_agent_setup_mode(true);
2465    }
2466
2467    fn request_agent_setup_mode(&mut self, update: bool) {
2468        if self.background_action_running() {
2469            self.status = "Another background action is still running".into();
2470            return;
2471        }
2472        let (call, context) = match self.tool_request(
2473            "glass.agent.setup",
2474            serde_json::json!({"login": false, "update": update}),
2475            true,
2476        ) {
2477            Ok(request) => request,
2478            Err(error) => {
2479                self.status = if update {
2480                    format!("Pi update unavailable: {error}")
2481                } else {
2482                    format!("Pi setup unavailable: {error}")
2483                };
2484                return;
2485            }
2486        };
2487        let summary = if update {
2488            "Refresh the pinned managed Pi SDK"
2489        } else {
2490            "Install or repair the pinned managed Pi SDK"
2491        };
2492        let queued = match self.queue_or_confirm(call, context, summary.into()) {
2493            Ok(queued) => queued,
2494            Err(error) => {
2495                self.status = format!("Could not queue Pi setup: {error}");
2496                return;
2497            }
2498        };
2499        self.surface = DevSurface::Agent;
2500        if !queued {
2501            self.status = if update {
2502                "Pi update ready · Enter approves once · Esc cancels".into()
2503            } else {
2504                "Pi setup ready · Enter approves once · Esc cancels".into()
2505            };
2506        }
2507    }
2508
2509    /// Request an interactive Pi login; the outer TUI loop performs the
2510    /// terminal handoff because the login program must own stdin.
2511    pub fn request_agent_login(&mut self) -> Result<(), String> {
2512        if self.background_action_running() {
2513            let error = "Finish the current background action before signing in".to_string();
2514            self.status = error.clone();
2515            return Err(error);
2516        }
2517        self.agent_login_requested = true;
2518        self.surface = DevSurface::Agent;
2519        self.status = "Pi login will open in this terminal · exit Pi to return".into();
2520        Ok(())
2521    }
2522
2523    pub fn close_composer(&mut self) {
2524        self.composer_mode = false;
2525        self.composer_steer = false;
2526        self.status = "Composer closed".into();
2527    }
2528
2529    pub fn move_composer_cursor(&mut self, right: bool) {
2530        if right {
2531            self.composer_cursor = self.composer_input[self.composer_cursor..]
2532                .char_indices()
2533                .nth(1)
2534                .map(|(offset, _)| self.composer_cursor + offset)
2535                .unwrap_or(self.composer_input.len());
2536        } else if self.composer_cursor > 0 {
2537            self.composer_cursor = self.composer_input[..self.composer_cursor]
2538                .char_indices()
2539                .next_back()
2540                .map(|(index, _)| index)
2541                .unwrap_or(0);
2542        }
2543    }
2544
2545    pub fn delete_composer_word(&mut self) {
2546        let before = self.composer_input[..self.composer_cursor].trim_end();
2547        let start = before.len();
2548        let target = before[..start]
2549            .trim_end_matches(|c: char| c.is_whitespace())
2550            .char_indices()
2551            .rev()
2552            .find_map(|(index, character)| character.is_whitespace().then_some(index))
2553            .map(|index| before[..index].trim_end().len())
2554            .unwrap_or(0);
2555        self.composer_input.drain(target..self.composer_cursor);
2556        self.composer_cursor = target;
2557    }
2558
2559    pub fn abort_selected_agent(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2560        let Some(agent) = self.selected_agent.clone() else {
2561            self.status = "No active agent to abort".into();
2562            return;
2563        };
2564        let (call, context) = match self.tool_request(
2565            "glass.agent.abort",
2566            serde_json::json!({"agentId": agent.as_str()}),
2567            true,
2568        ) {
2569            Ok(request) => request,
2570            Err(error) => {
2571                self.status = format!("Abort unavailable: {error}");
2572                return;
2573            }
2574        };
2575        match worker.submit_tool(call, context) {
2576            Ok(id) => {
2577                self.running_tool_job = Some(id);
2578                self.status = format!("Stopping {} in background…", agent.as_str());
2579            }
2580            Err(error) => self.status = format!("Abort unavailable: {error}"),
2581        }
2582    }
2583
2584    pub fn insert_composer_newline(&mut self) {
2585        self.insert_composer_text("\n");
2586        self.status = "Shift-Enter newline · Enter send · ↑ history".into();
2587    }
2588
2589    pub fn navigate_composer_history(&mut self, previous: bool) {
2590        if previous && !self.composer_on_first_line() {
2591            self.move_composer_line(-1);
2592            return;
2593        }
2594        if !previous && !self.composer_on_last_line() {
2595            self.move_composer_line(1);
2596            return;
2597        }
2598        if self.composer_history.is_empty() {
2599            return;
2600        }
2601        if previous {
2602            let index = match self.composer_history_index {
2603                None => {
2604                    self.composer_history_draft = self.composer_input.clone();
2605                    self.composer_history.len().saturating_sub(1)
2606                }
2607                Some(0) => 0,
2608                Some(index) => index - 1,
2609            };
2610            self.composer_history_index = Some(index);
2611            self.composer_input = self.composer_history[index].clone();
2612            self.composer_cursor = self.composer_input.len();
2613            return;
2614        }
2615        match self.composer_history_index {
2616            None => {}
2617            Some(index) if index + 1 < self.composer_history.len() => {
2618                self.composer_history_index = Some(index + 1);
2619                self.composer_input = self.composer_history[index + 1].clone();
2620                self.composer_cursor = self.composer_input.len();
2621            }
2622            Some(_) => {
2623                self.composer_history_index = None;
2624                self.composer_input = std::mem::take(&mut self.composer_history_draft);
2625                self.composer_cursor = self.composer_input.len();
2626            }
2627        }
2628    }
2629
2630    fn composer_on_first_line(&self) -> bool {
2631        !self.composer_input[..self.composer_cursor.min(self.composer_input.len())].contains('\n')
2632    }
2633
2634    fn composer_on_last_line(&self) -> bool {
2635        !self.composer_input[self.composer_cursor.min(self.composer_input.len())..].contains('\n')
2636    }
2637
2638    fn move_composer_line(&mut self, delta: i32) {
2639        let cursor = self.composer_cursor.min(self.composer_input.len());
2640        if delta < 0 {
2641            if let Some(offset) = self.composer_input[..cursor].rfind('\n') {
2642                self.composer_cursor = offset;
2643            }
2644            return;
2645        }
2646        if let Some(relative) = self.composer_input[cursor..].find('\n') {
2647            self.composer_cursor = (cursor + relative + 1).min(self.composer_input.len());
2648        }
2649    }
2650
2651    pub fn remember_composer_history(&mut self, text: &str) {
2652        let trimmed = text.trim();
2653        if trimmed.is_empty() {
2654            return;
2655        }
2656        if self.composer_history.last().map(String::as_str) != Some(trimmed) {
2657            self.composer_history.push(text.to_string());
2658            if self.composer_history.len() > 64 {
2659                self.composer_history.remove(0);
2660            }
2661        }
2662        self.composer_history_index = None;
2663        self.composer_history_draft.clear();
2664    }
2665
2666    pub fn open_file_picker(&mut self) {
2667        self.command_mode = false;
2668        self.file_picker_open = true;
2669        self.file_picker_query.clear();
2670        self.file_picker_cursor = 0;
2671        self.file_picker_selection = 0;
2672        self.status = if self.files.is_empty() {
2673            "Open file · no files yet · wait for refresh or Esc close".into()
2674        } else {
2675            format!(
2676                "Open file · {} paths · type to filter · Enter open · Esc close",
2677                self.files.len()
2678            )
2679        };
2680    }
2681
2682    pub fn close_file_picker(&mut self) {
2683        if !self.file_picker_open {
2684            return;
2685        }
2686        self.file_picker_open = false;
2687        self.file_picker_query.clear();
2688        self.file_picker_cursor = 0;
2689        self.file_picker_selection = 0;
2690        self.status = "File picker closed · Ctrl-P to reopen".into();
2691    }
2692
2693    pub fn file_picker_matches(&self) -> Vec<usize> {
2694        self.files
2695            .iter()
2696            .enumerate()
2697            .filter_map(|(index, path)| {
2698                fuzzy_contains(path, self.file_picker_query.trim()).then_some(index)
2699            })
2700            .collect()
2701    }
2702
2703    pub fn insert_file_picker_char(&mut self, character: char) {
2704        if character.is_control() {
2705            return;
2706        }
2707        self.file_picker_query
2708            .insert(self.file_picker_cursor, character);
2709        self.file_picker_cursor += character.len_utf8();
2710        self.file_picker_selection = 0;
2711    }
2712
2713    pub fn file_picker_backspace(&mut self) {
2714        if self.file_picker_cursor == 0 {
2715            return;
2716        }
2717        let previous = self.file_picker_query[..self.file_picker_cursor]
2718            .char_indices()
2719            .next_back()
2720            .map(|(index, _)| index)
2721            .unwrap_or(0);
2722        self.file_picker_query
2723            .drain(previous..self.file_picker_cursor);
2724        self.file_picker_cursor = previous;
2725        self.file_picker_selection = 0;
2726    }
2727
2728    pub fn move_file_picker_selection(&mut self, delta: i32) {
2729        let count = self.file_picker_matches().len();
2730        if count == 0 {
2731            self.file_picker_selection = 0;
2732            return;
2733        }
2734        self.file_picker_selection =
2735            (self.file_picker_selection as i32 + delta).rem_euclid(count as i32) as usize;
2736    }
2737
2738    pub fn submit_file_picker(&mut self) {
2739        let matches = self.file_picker_matches();
2740        let Some(&index) = matches.get(self.file_picker_selection) else {
2741            self.status = "No matching file".into();
2742            return;
2743        };
2744        self.selected_file = index;
2745        self.close_file_picker();
2746        self.open_selected_file_for_edit();
2747    }
2748
2749    pub fn open_path(&mut self, path: &str) -> Result<String, String> {
2750        if path.trim().is_empty() {
2751            return Err("open requires PATH".into());
2752        }
2753        if let Some(index) = self.files.iter().position(|item| {
2754            item == path || item.ends_with(path) || item.rsplit('/').next() == Some(path)
2755        }) {
2756            self.selected_file = index;
2757        } else {
2758            self.files.insert(0, path.to_string());
2759            self.selected_file = 0;
2760        }
2761        self.open_selected_file_for_edit();
2762        Ok(format!("Opened {path}"))
2763    }
2764
2765    pub fn insert_composer_text(&mut self, text: &str) {
2766        for character in text.chars().take(16_384) {
2767            self.composer_input.insert(self.composer_cursor, character);
2768            self.composer_cursor += character.len_utf8();
2769        }
2770    }
2771
2772    pub fn complete_composer_mention(&mut self) {
2773        match complete_mention(&self.composer_input, self.composer_cursor, &self.files) {
2774            Some((text, cursor)) => {
2775                self.composer_input = text;
2776                self.composer_cursor = cursor;
2777                self.status = "Mention completed · Tab cycles @file".into();
2778            }
2779            None => {
2780                self.status = "Mentions: @file @page @entity @workflow @workspace".into();
2781            }
2782        }
2783    }
2784
2785    pub fn composer_backspace(&mut self) {
2786        if self.composer_cursor == 0 {
2787            return;
2788        }
2789        let previous = self.composer_input[..self.composer_cursor]
2790            .char_indices()
2791            .next_back()
2792            .map(|(index, _)| index)
2793            .unwrap_or(0);
2794        self.composer_input.drain(previous..self.composer_cursor);
2795        self.composer_cursor = previous;
2796    }
2797
2798    pub fn submit_composer(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2799        if self.composer_input.trim_start().starts_with('/') {
2800            self.submit_composer_slash(worker);
2801            return;
2802        }
2803        if self.composer_send_blocked() {
2804            self.status = "Background operation running · message kept in composer".into();
2805            return;
2806        }
2807        if self.snapshot_trust_label == "untrusted" {
2808            self.composer_mode = false;
2809            self.surface = DevSurface::Trust;
2810            self.status = "Trust this workspace before starting the Glass Agent · T or 1".into();
2811            return;
2812        }
2813        if !self.agent_readiness.starts_with("✓ Ready") {
2814            self.status = "Pi is not ready · use :agent setup or :agent setup login".into();
2815            return;
2816        }
2817        if self.composer_input.trim().is_empty() {
2818            self.status = "Message is empty · type a prompt, then press Enter".into();
2819            return;
2820        }
2821        let file = if !self.focused_editor_path.is_empty() {
2822            Some(self.focused_editor_path.as_str())
2823        } else {
2824            self.files.get(self.selected_file).map(String::as_str)
2825        };
2826        let display_text = expand_mentions(&self.composer_input, file);
2827        let text = expand_mentions(&std::mem::take(&mut self.composer_input), file);
2828        self.remember_composer_history(&text);
2829        if self.composer_run_mode == crate::AgentTurnMode::Plan {
2830            self.capture_plan_from_goal(&text);
2831        }
2832        let prove = compile_prove_it(&text);
2833        let steer = self.composer_steer;
2834        let queued_follow_up = self.agent_send_job.is_some();
2835        self.composer_cursor = 0;
2836        self.composer_steer = false;
2837        self.composer_mode = true;
2838        let _ = self.ws_mut().map(|mut workspace| {
2839            workspace.set_agent_turn_mode(self.composer_run_mode);
2840        });
2841        let mut context = self.agent_browser_context();
2842        context["editor"] = self.agent_editor_context();
2843        context["surface"] = serde_json::Value::String(self.surface.label().to_ascii_lowercase());
2844        context["runMode"] =
2845            serde_json::Value::String(self.composer_run_mode.label().to_ascii_lowercase());
2846        context["playbook"] =
2847            serde_json::Value::String(super::playbooks::playbook_name(self.surface).into());
2848        context["playbookText"] =
2849            serde_json::Value::String(super::playbooks::playbook(self.surface).into());
2850        context["todos"] =
2851            serde_json::to_value(&self.session_todos).unwrap_or(serde_json::json!({}));
2852        if let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) {
2853            context["git"] = serde_json::json!({
2854                "branch": self.git_branch,
2855                "selectedPath": path,
2856            });
2857        }
2858        if let Some(process) = self.selected_process_entry() {
2859            context["process"] = serde_json::json!({
2860                "name": process.name,
2861                "health": process.health.label(),
2862                "pid": process.pid,
2863                "url": process.url,
2864            });
2865        }
2866        if let Some(session) = self.selected_debug_session() {
2867            context["debug"] = serde_json::json!({
2868                "session": session.name,
2869                "state": session.state.label(),
2870                "threadId": self.selected_debug_thread().map(|thread| thread.id),
2871                "frameId": self.selected_debug_frame().map(|frame| frame.id),
2872                "path": self.selected_debug_frame().and_then(|frame| frame.path.clone()),
2873                "line": self.selected_debug_frame().and_then(|frame| frame.line),
2874            });
2875        }
2876        if let Some(plan) = &self.pending_plan {
2877            context["plan"] = serde_json::json!({
2878                "id": plan.id,
2879                "goal": plan.goal,
2880                "accepted": plan.accepted,
2881            });
2882        }
2883        if let Some(comment) = &self.last_app_comment {
2884            context["appComment"] = serde_json::Value::String(comment.clone());
2885        }
2886        if context["browser"]["selectedEntity"].is_object() {
2887            self.browser_workspace.state_mut().input_owner =
2888                glass_browser::browser_workspace::BrowserInputOwner::Agent;
2889        }
2890        let playbook = super::playbooks::playbook(self.surface);
2891        let prefixed = match self.composer_run_mode.instruction() {
2892            "" => format!("{playbook}\n\n{text}"),
2893            instruction => format!("{instruction}\n\n{playbook}\n\n{text}"),
2894        };
2895        let mut arguments = serde_json::json!({
2896            "text": prefixed,
2897            "mode": if steer { "steer" } else { "follow-up" },
2898            "context": context,
2899        });
2900        if let Some(prove) = prove {
2901            arguments["verify"] = prove.verify.clone();
2902            arguments["intent"] = serde_json::Value::String(prove.intent);
2903            self.pending_verify = Some(prove.verify);
2904            self.last_proof_ok = None;
2905            self.last_verify = Some(evidence_card(
2906                arguments["context"]["browser"]["url"]
2907                    .as_str()
2908                    .unwrap_or("about:blank"),
2909                arguments["context"]["browser"]["revision"]
2910                    .as_u64()
2911                    .unwrap_or(0),
2912                arguments["context"]["browser"]["selectedEntity"].as_str(),
2913                "composer prove-it queued",
2914                false,
2915            ));
2916            self.auto_checkpoint("before-prove-it");
2917        }
2918        if let Some(agent) = self.selected_agent.as_ref() {
2919            arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
2920        }
2921        let (call, context) = match self.tool_request("glass.agent.send", arguments, true) {
2922            Ok(request) => request,
2923            Err(error) => {
2924                self.composer_input = display_text;
2925                self.composer_cursor = self.composer_input.len();
2926                self.status = format!("Message unavailable · edit and retry: {error}");
2927                return;
2928            }
2929        };
2930        match worker.submit_tool(call, context) {
2931            Ok(id) => {
2932                self.agent_send_job = Some(id);
2933                self.pending_chat_messages.push(PendingChatMessage {
2934                    text: display_text,
2935                    state: ChatMessageState::Sending,
2936                    job_id: Some(id),
2937                    error: None,
2938                });
2939                self.status = if steer {
2940                    "Sent · steering Glass Agent…".into()
2941                } else if self.composer_run_mode == crate::AgentTurnMode::Plan {
2942                    "Plan turn · inspect only · :plan accept when ready".into()
2943                } else if queued_follow_up {
2944                    "Queued follow-up · Glass Agent will continue".into()
2945                } else {
2946                    format!("Sent · {} is thinking…", self.composer_run_mode.label())
2947                };
2948                worker.request_conversation();
2949            }
2950            Err(error) => {
2951                self.composer_input = display_text;
2952                self.composer_cursor = self.composer_input.len();
2953                self.status = format!("Message unavailable · edit and retry: {error}");
2954            }
2955        }
2956    }
2957
2958    fn submit_composer_slash(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
2959        let raw = self.composer_input.trim().to_string();
2960        let mut parts = raw.trim_start_matches('/').split_whitespace();
2961        let Some(command) = parts.next() else {
2962            self.status = "Empty slash command".into();
2963            return;
2964        };
2965        let rest = parts.collect::<Vec<_>>();
2966        let mut arguments = serde_json::json!({});
2967        if let Some(agent) = self.selected_agent.as_ref() {
2968            arguments["agentId"] = serde_json::Value::String(agent.as_str().to_string());
2969        }
2970        let (tool, mutating) = match command {
2971            "compact" => {
2972                if !rest.is_empty() {
2973                    arguments["instructions"] = serde_json::Value::String(rest.join(" "));
2974                }
2975                ("glass.agent.compact", true)
2976            }
2977            "model" => {
2978                let provider = rest.first().copied().unwrap_or("");
2979                let model = rest.get(1).copied().unwrap_or("");
2980                if provider.is_empty() || model.is_empty() {
2981                    self.status = "/model requires PROVIDER MODEL".into();
2982                    return;
2983                }
2984                arguments["provider"] = serde_json::Value::String(provider.into());
2985                arguments["modelId"] = serde_json::Value::String(model.into());
2986                self.agent_model = format!("{provider}/{model}");
2987                ("glass.agent.model", true)
2988            }
2989            "think" | "thinking" => {
2990                let level = rest.first().copied().unwrap_or("");
2991                if level.is_empty() {
2992                    self.status = "/think requires LEVEL".into();
2993                    return;
2994                }
2995                arguments["level"] = serde_json::Value::String(level.into());
2996                self.agent_thinking = level.into();
2997                ("glass.agent.thinking", true)
2998            }
2999            "new" => ("glass.agent.new-session", true),
3000            "clone" => ("glass.agent.clone-session", true),
3001            "name" => {
3002                let name = rest.join(" ");
3003                if name.is_empty() {
3004                    self.status = "/name requires TITLE".into();
3005                    return;
3006                }
3007                arguments["name"] = serde_json::Value::String(name.clone());
3008                self.agent_session_name = name;
3009                ("glass.agent.name", true)
3010            }
3011            "stats" => ("glass.agent.stats", false),
3012            "sessions" => ("glass.agent.sessions", false),
3013            "tree" => ("glass.agent.tree", false),
3014            "todo" => {
3015                self.composer_input = self.session_todos.render();
3016                self.composer_cursor = 0;
3017                self.status = "Session todos · edit or Esc".into();
3018                return;
3019            }
3020            "ask" | "plan" | "agent" => {
3021                let mode = match command {
3022                    "ask" => crate::AgentTurnMode::Ask,
3023                    "plan" => crate::AgentTurnMode::Plan,
3024                    _ => crate::AgentTurnMode::Agent,
3025                };
3026                self.set_composer_run_mode(mode);
3027                self.remember_composer_history(&raw);
3028                self.composer_input = rest.join(" ");
3029                self.composer_cursor = self.composer_input.len();
3030                if self.composer_input.trim().is_empty() {
3031                    return;
3032                }
3033                self.submit_composer(worker);
3034                return;
3035            }
3036            _ => {
3037                self.status = format!("Unknown slash command /{command}");
3038                return;
3039            }
3040        };
3041        match self.tool_request(tool, arguments, mutating) {
3042            Ok((call, context)) => match worker.submit_tool(call, context) {
3043                Ok(id) => {
3044                    self.running_tool_job = Some(id);
3045                    self.remember_composer_history(&raw);
3046                    self.composer_input.clear();
3047                    self.composer_cursor = 0;
3048                    self.status = format!("{tool} · queued from composer");
3049                }
3050                Err(error) => self.status = format!("{tool} failed: {error}"),
3051            },
3052            Err(error) => self.status = format!("{tool} unavailable: {error}"),
3053        }
3054    }
3055
3056    pub fn approve_confirmation_async(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3057        let Some(pending) = self.pending_confirmation.take() else {
3058            return;
3059        };
3060        match worker.submit_tool(pending.call, pending.context) {
3061            Ok(id) => {
3062                self.running_tool_job = Some(id);
3063                self.status = format!(
3064                    "Running {} · Esc keeps the workspace responsive",
3065                    pending.summary
3066                );
3067            }
3068            Err(error) => self.status = format!("Could not queue mutation: {error}"),
3069        }
3070    }
3071
3072    pub fn resolve_agent_approval(
3073        &mut self,
3074        approved: bool,
3075        worker: &mut super::snapshot::SnapshotWorker,
3076    ) {
3077        let Some(pending) = self.pending_agent_approval.take() else {
3078            return;
3079        };
3080        let arguments = serde_json::json!({
3081            "agentId": pending.agent_id,
3082            "frameId": pending.frame_id,
3083            "approved": approved,
3084        });
3085        let (call, context) = match self.tool_request("glass.agent.approve", arguments, true) {
3086            Ok(request) => request,
3087            Err(error) => {
3088                self.pending_agent_approval = Some(pending);
3089                self.status = format!("Agent approval unavailable: {error}");
3090                return;
3091            }
3092        };
3093        match worker.submit_tool(call, context) {
3094            Ok(id) => {
3095                self.running_tool_job = Some(id);
3096                self.status = if approved {
3097                    format!("Approved {} · Glass Agent continues…", pending.tool_name)
3098                } else {
3099                    format!("Denied {} · Glass Agent continues…", pending.tool_name)
3100                };
3101            }
3102            Err(error) => {
3103                self.pending_agent_approval = Some(pending);
3104                self.status = format!("Could not queue agent approval: {error}");
3105            }
3106        }
3107    }
3108
3109    pub fn apply_visual_job_result(&mut self, result: super::snapshot::VisualJobResult) {
3110        self.apply_visual_job_result_with_fit(
3111            result,
3112            glass_browser::terminal_graphics::FrameFit::Contain,
3113        );
3114    }
3115
3116    pub fn apply_visual_job_result_with_fit(
3117        &mut self,
3118        result: super::snapshot::VisualJobResult,
3119        fit: glass_browser::terminal_graphics::FrameFit,
3120    ) {
3121        let png = match result.result {
3122            Ok(value) => {
3123                let Some(encoded) = value.get("base64").and_then(serde_json::Value::as_str) else {
3124                    self.browser_visual_live = false;
3125                    self.browser_workspace.state_mut().presentation_reason =
3126                        Some("screenshot payload did not contain base64 PNG data".into());
3127                    self.status = "Live view unavailable · screenshot payload was empty".into();
3128                    return;
3129                };
3130                use base64::Engine as _;
3131                match base64::engine::general_purpose::STANDARD.decode(encoded) {
3132                    Ok(png) => png,
3133                    Err(error) => {
3134                        self.browser_visual_live = false;
3135                        self.browser_workspace.state_mut().presentation_reason =
3136                            Some(format!("screenshot payload was not valid base64: {error}"));
3137                        self.status = "Live view unavailable · invalid screenshot payload".into();
3138                        return;
3139                    }
3140                }
3141            }
3142            Err(error) => {
3143                self.browser_visual_live = false;
3144                self.browser_workspace.state_mut().presentation_reason =
3145                    Some(format!("browser screenshot failed: {error}"));
3146                self.status = format!("Live view unavailable · {error}");
3147                return;
3148            }
3149        };
3150        match AnsiPane::from_png(
3151            &mut self.browser_ansi,
3152            &png,
3153            result.columns.clamp(8, 80),
3154            result.rows.clamp(4, 40),
3155            fit,
3156        ) {
3157            Ok(pane) => {
3158                self.browser_pane = Some(pane);
3159                let browser = self.browser_workspace.state_mut();
3160                browser.presentation =
3161                    glass_browser::browser_workspace::BrowserPresentationPath::Ansi;
3162                browser.frame_revision = browser.browser_revision;
3163                browser.presentation_reason = Some(
3164                    "bounded ANSI half-block frame · semantic controls remain authoritative".into(),
3165                );
3166                self.status = "Live view updated · ANSI half-block".into();
3167            }
3168            Err(error) => {
3169                self.browser_visual_live = false;
3170                self.browser_workspace.state_mut().presentation_reason = Some(error.to_string());
3171                self.status = format!("Live view unavailable: {error}");
3172            }
3173        }
3174    }
3175
3176    pub fn queue_tool_request(
3177        &mut self,
3178        call: crate::development::ToolCall,
3179        context: crate::tools::DevelopmentToolContext,
3180    ) -> Result<(), String> {
3181        if self.background_action_running() {
3182            return Err("another background tool is already running".into());
3183        }
3184        self.queued_tool_request = Some((call, context));
3185        Ok(())
3186    }
3187    pub(super) fn queue_or_confirm(
3188        &mut self,
3189        call: crate::development::ToolCall,
3190        context: crate::tools::DevelopmentToolContext,
3191        summary: String,
3192    ) -> Result<bool, String> {
3193        if self.yolo_mode {
3194            self.queue_tool_request(call, context)?;
3195            self.status = format!("YOLO · {summary} queued");
3196            Ok(true)
3197        } else {
3198            self.pending_confirmation = Some(PendingConfirmation {
3199                call,
3200                context,
3201                summary,
3202            });
3203            Ok(false)
3204        }
3205    }
3206
3207    pub fn submit_pending_verify(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3208        let Some(predicate) = self.pending_verify.take() else {
3209            return;
3210        };
3211        let arguments = serde_json::json!({ "predicate": predicate, "timeoutSeconds": 8 });
3212        let (call, context) = match self.tool_request("glass.browser.verify", arguments, false) {
3213            Ok(request) => request,
3214            Err(error) => {
3215                self.last_proof_ok = Some(false);
3216                self.status = format!("Prove-it unavailable: {error}");
3217                return;
3218            }
3219        };
3220        match worker.submit_tool(call, context) {
3221            Ok(id) => {
3222                self.running_tool_job = Some(id);
3223                self.status = "Prove-it running against the live page".into();
3224            }
3225            Err(error) => {
3226                self.last_proof_ok = Some(false);
3227                self.status = format!("Prove-it failed to start: {error}");
3228            }
3229        }
3230    }
3231
3232    pub fn submit_queued_tool(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3233        let Some((call, context)) = self.queued_tool_request.take() else {
3234            return;
3235        };
3236        match worker.submit_tool(call, context) {
3237            Ok(id) => {
3238                self.running_tool_job = Some(id);
3239                self.status.push_str(" · running in background");
3240            }
3241            Err(error) => self.status = format!("Could not queue tool: {error}"),
3242        }
3243    }
3244
3245    pub fn apply_tool_job_result(&mut self, result: super::snapshot::ToolJobResult) {
3246        if result.tool == "glass.agent.send" && self.agent_send_job == Some(result.id) {
3247            self.agent_send_job = None;
3248            match result.result {
3249                Ok(value) => {
3250                    let agent = value
3251                        .get("agentId")
3252                        .and_then(serde_json::Value::as_str)
3253                        .and_then(|value| crate::AgentId::parse(value).ok());
3254                    let restarted = value
3255                        .get("restarted")
3256                        .and_then(serde_json::Value::as_bool)
3257                        .unwrap_or(false);
3258                    if let Some(agent_id) = agent {
3259                        self.selected_agent = Some(agent_id.clone());
3260                        self.status = if restarted {
3261                            format!("Restarted {} · Glass Agent is thinking…", agent_id.as_str())
3262                        } else {
3263                            format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str())
3264                        };
3265                    } else {
3266                        self.status = if restarted {
3267                            "Restarted Glass Agent · thinking…".into()
3268                        } else {
3269                            "Sent · Glass Agent is thinking…".into()
3270                        };
3271                    }
3272                    if let Some(message) = self
3273                        .pending_chat_messages
3274                        .iter_mut()
3275                        .find(|message| message.job_id == Some(result.id))
3276                    {
3277                        message.state = ChatMessageState::Sent;
3278                        message.job_id = None;
3279                    }
3280                }
3281                Err(error) => {
3282                    let failed_text = self
3283                        .pending_chat_messages
3284                        .iter_mut()
3285                        .find(|message| message.job_id == Some(result.id))
3286                        .map(|message| {
3287                            message.state = ChatMessageState::Failed;
3288                            message.job_id = None;
3289                            message.error = Some(error.clone());
3290                            message.text.clone()
3291                        });
3292                    if self.composer_input.is_empty()
3293                        && let Some(text) = failed_text
3294                    {
3295                        self.composer_input = text;
3296                        self.composer_cursor = self.composer_input.len();
3297                    }
3298                    self.composer_mode = true;
3299                    self.status = format!("Could not send message · edit and retry: {error}");
3300                }
3301            }
3302            return;
3303        }
3304
3305        if self.running_tool_job != Some(result.id) {
3306            return;
3307        }
3308        self.running_tool_job = None;
3309        match result.result {
3310            Ok(value) => {
3311                if result.tool == "glass.agent.sessions" {
3312                    self.open_session_picker(&value);
3313                    return;
3314                }
3315                if result.tool == "glass.agent.stats" {
3316                    self.agent_token_summary = stats_summary(&value);
3317                    self.status = format!("Session stats · {}", self.agent_token_summary);
3318                    return;
3319                }
3320                if result.tool == "glass.browser.verify" {
3321                    let ok = value.get("status").and_then(serde_json::Value::as_str)
3322                        == Some("satisfied");
3323                    self.last_proof_ok = Some(ok);
3324                    self.last_verify = Some(evidence_card(
3325                        value
3326                            .pointer("/predicate/urlEquals")
3327                            .and_then(serde_json::Value::as_str)
3328                            .or_else(|| value.get("state").and_then(serde_json::Value::as_str))
3329                            .unwrap_or("live page"),
3330                        value
3331                            .get("elapsedMs")
3332                            .and_then(serde_json::Value::as_u64)
3333                            .unwrap_or(0),
3334                        None,
3335                        value
3336                            .get("state")
3337                            .and_then(serde_json::Value::as_str)
3338                            .unwrap_or("verify"),
3339                        ok,
3340                    ));
3341                    self.status = if ok {
3342                        "Prove-it passed · gutter ✓".into()
3343                    } else {
3344                        "Prove-it failed · inspect last verify".into()
3345                    };
3346                } else if result.tool.starts_with("glass.browser") {
3347                    self.apply_browser_result(&result.tool, &value);
3348                    self.browser_detail = super::projection::browser_result(&result.tool, &value);
3349                    if result.tool == "glass.browser.act" || result.tool == "glass.browser.navigate"
3350                    {
3351                        self.browser_observe_pending = true;
3352                        self.watch_agent_on_app(&result.tool, &value);
3353                    }
3354                } else if result.tool == "glass.process.logs" {
3355                    self.process_logs = value
3356                        .get("output")
3357                        .and_then(serde_json::Value::as_str)
3358                        .unwrap_or_default()
3359                        .chars()
3360                        .rev()
3361                        .take(8 * 1024)
3362                        .collect::<String>()
3363                        .chars()
3364                        .rev()
3365                        .collect();
3366                    self.surface = DevSurface::Terminal;
3367                    self.status = format!(
3368                        "Logs · {}",
3369                        value
3370                            .get("name")
3371                            .and_then(serde_json::Value::as_str)
3372                            .unwrap_or("process")
3373                    );
3374                } else if result.tool == "glass.debug.threads" {
3375                    self.debug_threads = parse_debug_threads(&value);
3376                    self.selected_debug_thread = self
3377                        .selected_debug_thread
3378                        .min(self.debug_threads.len().saturating_sub(1));
3379                    self.debug_frames.clear();
3380                    if !self.debug_threads.is_empty() {
3381                        self.debug_pane = DebugPane::Threads;
3382                        self.debug_stack_requested = true;
3383                    }
3384                    self.status = format!(
3385                        "{} thread(s) · Enter stack · Space continue",
3386                        self.debug_threads.len()
3387                    );
3388                } else if result.tool == "glass.debug.stack" {
3389                    self.debug_frames = parse_debug_frames(&value);
3390                    self.selected_debug_frame = 0;
3391                    if !self.debug_frames.is_empty() {
3392                        self.debug_pane = DebugPane::Frames;
3393                        self.debug_scopes_requested = true;
3394                    }
3395                    self.status = format!(
3396                        "{} frame(s) · Enter jumps to source",
3397                        self.debug_frames.len()
3398                    );
3399                } else if result.tool == "glass.debug.scopes" {
3400                    self.debug_scopes = parse_debug_scopes(&value);
3401                    self.selected_debug_scope = 0;
3402                    self.debug_variables.clear();
3403                    if !self.debug_scopes.is_empty() {
3404                        self.debug_variables_requested = true;
3405                    }
3406                    self.status = format!("{} scope(s)", self.debug_scopes.len());
3407                } else if result.tool == "glass.debug.variables" {
3408                    self.debug_variables = parse_debug_variables(&value);
3409                    self.status = format!("{} variable(s)", self.debug_variables.len());
3410                } else if result.tool == "glass.git.diff" {
3411                    let empty = value.as_str().is_none_or(|diff| diff.trim().is_empty());
3412                    self.git_diff = if empty {
3413                        self.git_diff_path
3414                            .as_deref()
3415                            .map(|path| format!("{path}\n\nNo tracked diff for this file."))
3416                            .unwrap_or_else(|| "Working tree clean · no diff to show".into())
3417                    } else {
3418                        value.as_str().unwrap_or_default().to_string()
3419                    };
3420                    self.git_diff_open = true;
3421                    self.status = self
3422                        .git_diff_path
3423                        .as_deref()
3424                        .map(|path| format!("Git diff · {path} · PgUp/PgDn scroll · Esc closes"))
3425                        .unwrap_or_else(|| "Git diff · PgUp/PgDn scroll · Esc closes".into());
3426                } else if result.tool == "glass.agent.setup" {
3427                    match self.refresh_agent_readiness() {
3428                        Ok(true) => {
3429                            self.open_composer();
3430                            self.status =
3431                                "Pi runtime ready · type a prompt, then press Enter".into();
3432                        }
3433                        Ok(false) => {
3434                            self.status =
3435                                "Pi runtime installed · use :agent setup login, then Enter to chat"
3436                                    .into();
3437                        }
3438                        Err(error) => self.status = format!("Pi readiness check failed: {error}"),
3439                    }
3440                } else if result.tool == "glass.agent.send" {
3441                    if let Some(agent_id) = value
3442                        .get("agentId")
3443                        .and_then(serde_json::Value::as_str)
3444                        .and_then(|value| crate::AgentId::parse(value).ok())
3445                    {
3446                        self.selected_agent = Some(agent_id.clone());
3447                        self.status =
3448                            format!("Sent to {} · Glass Agent is thinking…", agent_id.as_str());
3449                    } else {
3450                        self.status = "Sent · Glass Agent is thinking…".into();
3451                    }
3452                } else if result.tool == "glass.agent.delegate" {
3453                    self.surface = DevSurface::Agent;
3454                    let harness = value
3455                        .get("harness")
3456                        .and_then(serde_json::Value::as_str)
3457                        .unwrap_or("external harness");
3458                    let outcome = if value.get("success").and_then(serde_json::Value::as_bool)
3459                        == Some(true)
3460                    {
3461                        "completed"
3462                    } else if value.get("timedOut").and_then(serde_json::Value::as_bool)
3463                        == Some(true)
3464                    {
3465                        "timed out"
3466                    } else {
3467                        "failed"
3468                    };
3469                    let detail = super::projection::external_agent_output(&value);
3470                    self.status = format!("Temporary {harness} {outcome} · {detail}");
3471                } else if result.tool == "glass.github.review" {
3472                    match serde_json::from_value::<crate::github::GitHubReview>(value) {
3473                        Ok(review) => {
3474                            self.github = crate::github::GitHubStatus {
3475                                repository: review.repository.clone(),
3476                                availability: review.availability,
3477                            };
3478                            self.github_review = review.display();
3479                            self.surface = DevSurface::Git;
3480                            self.status = "GitHub review refreshed".into();
3481                        }
3482                        Err(error) => {
3483                            self.status = format!("GitHub review response invalid: {error}");
3484                        }
3485                    }
3486                } else if result.tool == "glass.github.ship" {
3487                    self.surface = DevSurface::Git;
3488                    self.status = value
3489                        .get("url")
3490                        .and_then(serde_json::Value::as_str)
3491                        .map(|url| format!("Pull request created · {url}"))
3492                        .unwrap_or_else(|| "Pull request created · review GitHub status".into());
3493                } else if result.tool == "glass.task.wake" {
3494                    self.last_crew_wake = serde_json::from_value::<crate::CrewWake>(value.clone())
3495                        .ok()
3496                        .map(|wake| wake.render());
3497                    self.surface = DevSurface::Tasks;
3498                    self.status = "Crew wake loaded · :review".into();
3499                } else if result.tool == "glass.task.crew" {
3500                    let wake = value.get("wake").cloned().unwrap_or_else(|| value.clone());
3501                    self.last_crew_wake = serde_json::from_value::<crate::CrewWake>(wake)
3502                        .ok()
3503                        .map(|wake| wake.render())
3504                        .or_else(|| {
3505                            value
3506                                .get("goal")
3507                                .and_then(serde_json::Value::as_str)
3508                                .map(|goal| format!("WAKE\n  goal {goal}"))
3509                        });
3510                    self.surface = DevSurface::Tasks;
3511                    self.status = format!(
3512                        "Crew wake {} · :review",
3513                        value
3514                            .pointer("/wake/id")
3515                            .and_then(serde_json::Value::as_str)
3516                            .unwrap_or("queued")
3517                    );
3518                } else if result.tool.starts_with("glass.lsp") {
3519                    if result.tool == "glass.lsp.inlay_hints" {
3520                        self.editor_inlays =
3521                            parse_inlay_hints(value.get("result").unwrap_or(&value));
3522                    }
3523                    if result.tool == "glass.lsp.diagnostics" {
3524                        self.editor_diagnostics =
3525                            parse_editor_diagnostics(value.get("result").unwrap_or(&value));
3526                    }
3527                    self.editor = if result.tool == "glass.lsp.diagnostics" {
3528                        super::projection::lsp(Some(&value))
3529                    } else {
3530                        super::projection::first_meaningful(&value)
3531                    };
3532                }
3533                if !matches!(
3534                    result.tool.as_str(),
3535                    "glass.agent.send"
3536                        | "glass.agent.setup"
3537                        | "glass.agent.delegate"
3538                        | "glass.git.diff"
3539                        | "glass.github.review"
3540                        | "glass.github.ship"
3541                        | "glass.browser.verify"
3542                        | "glass.task.crew"
3543                        | "glass.task.wake"
3544                        | "glass.process.logs"
3545                        | "glass.debug.threads"
3546                        | "glass.debug.stack"
3547                        | "glass.debug.scopes"
3548                        | "glass.debug.variables"
3549                ) {
3550                    self.status = format!("Completed {} · workspace refreshed", result.tool);
3551                }
3552            }
3553            Err(error) => {
3554                if result.tool == "glass.browser.verify" {
3555                    self.last_proof_ok = Some(false);
3556                    self.last_verify = Some(evidence_card("live page", 0, None, &error, false));
3557                }
3558                if result.tool.starts_with("glass.browser") {
3559                    self.note_browser_failure(&result.tool, &error);
3560                }
3561                if result.tool == "glass.git.diff" {
3562                    self.git_diff = format!("Git diff unavailable: {error}");
3563                    self.git_diff_open = true;
3564                }
3565                self.status = format!("{} failed: {error}", result.tool);
3566            }
3567        }
3568    }
3569
3570    pub fn deny_confirmation(&mut self) {
3571        self.pending_browser_navigation = None;
3572        self.pending_page_entity = None;
3573        if let Some(pending) = self.pending_confirmation.take() {
3574            self.status = format!("Denied · {}", pending.summary);
3575        }
3576    }
3577
3578    /// Queue browser startup or a fresh observation as part of a requested navigation.
3579    pub fn prepare_browser_navigation(&mut self, url: &str) -> Result<String, String> {
3580        if self.background_action_running() {
3581            return Err("another browser action is already awaiting or running".into());
3582        }
3583        if self.browser_workspace.state().connection == BrowserConnectionPhase::Connected {
3584            let (call, context) =
3585                self.tool_request("glass.browser.observe", serde_json::json!({}), false)?;
3586            self.pending_browser_navigation = Some(url.to_string());
3587            self.queued_tool_request = Some((call, context));
3588            self.surface = DevSurface::App;
3589            return Ok("Browser connected · refreshing page before navigation".into());
3590        }
3591        let (call, context) =
3592            self.tool_request("glass.browser.start", serde_json::json!({}), true)?;
3593        self.pending_browser_navigation = Some(url.to_string());
3594        let queued = self.queue_or_confirm(
3595            call,
3596            context,
3597            format!("Start browser before navigating to {url}"),
3598        )?;
3599        self.surface = DevSurface::App;
3600        Ok(if queued {
3601            "Browser detached · launching; navigation continues automatically".into()
3602        } else {
3603            "Browser detached · Enter approves launch; navigation continues automatically".into()
3604        })
3605    }
3606
3607    pub fn handle_printable(&mut self, character: char) {
3608        if character == ':' {
3609            self.open_palette();
3610            return;
3611        }
3612        if character == 'a' && self.surface != DevSurface::Agent {
3613            self.open_menu();
3614            return;
3615        }
3616        if self.surface == DevSurface::Trust {
3617            let decision = match character {
3618                'i' | 'I' => {
3619                    self.status = "Inspecting exact repository configuration".into();
3620                    return;
3621                }
3622                'o' | 'O' => Some(crate::LocalTrustDecision::OpenUntrusted),
3623                '1' => Some(crate::LocalTrustDecision::TrustOnce),
3624                'T' => Some(crate::LocalTrustDecision::TrustProject),
3625                _ => None,
3626            };
3627            if let Some(decision) = decision {
3628                self.queue_trust(decision);
3629                return;
3630            }
3631        }
3632        if self.surface == DevSurface::Agent && self.snapshot_trust_label == "untrusted" {
3633            let decision = match character {
3634                't' => Some(crate::LocalTrustDecision::TrustOnce),
3635                'T' => Some(crate::LocalTrustDecision::TrustProject),
3636                _ => None,
3637            };
3638            if let Some(decision) = decision {
3639                self.queue_trust(decision);
3640                return;
3641            }
3642        }
3643
3644        // Agent text wins over navigation. The event loop reserves only
3645        // explicit modal controls and the `:` command prefix.
3646        if self.surface == DevSurface::Agent
3647            && self.snapshot_trust_label != "untrusted"
3648            && !character.is_ascii_digit()
3649        {
3650            if self.agent_readiness.starts_with("✓ Ready") {
3651                self.open_composer();
3652            } else {
3653                self.start_agent_interaction();
3654            }
3655            if self.composer_mode {
3656                self.insert_composer_text(&character.to_string());
3657            }
3658            return;
3659        }
3660
3661        if self.surface == DevSurface::Code && character == 'i' {
3662            self.enter_code_edit();
3663            return;
3664        }
3665        if self.responsive_class(self.terminal_width, self.terminal_height)
3666            == ResponsiveClass::Phone
3667        {
3668            let surface = match character {
3669                '1' => Some(DevSurface::Agent),
3670                '2' => Some(DevSurface::Code),
3671                '3' => Some(DevSurface::App),
3672                '4' => Some(DevSurface::Tasks),
3673                '5' => Some(DevSurface::More),
3674                _ => None,
3675            };
3676            if let Some(surface) = surface {
3677                self.show_surface(surface);
3678                return;
3679            }
3680        }
3681        let surface = match character {
3682            '1' => Some(DevSurface::Agent),
3683            '2' | 'c' => Some(DevSurface::Code),
3684            '3' | 'v' => Some(DevSurface::App),
3685            '4' => Some(DevSurface::Terminal),
3686            '5' | 'w' => Some(DevSurface::Tasks),
3687            '6' | 'g' => Some(DevSurface::Git),
3688            '7' | 'd' => Some(DevSurface::Debug),
3689            '8' | 'm' => Some(DevSurface::More),
3690            _ => None,
3691        };
3692        if let Some(surface) = surface {
3693            self.show_surface(surface);
3694        } else if self.surface == DevSurface::Agent && self.snapshot_trust_label != "untrusted" {
3695            self.open_composer();
3696            self.insert_composer_text(&character.to_string());
3697        }
3698    }
3699    /// Queue the project-detected development command without making users
3700    /// copy it from project inspection into the command palette.
3701    pub fn request_detected_dev(&mut self) {
3702        if self.background_action_running() {
3703            self.status = "Another background action is still running".into();
3704            return;
3705        }
3706        let command_result = {
3707            match self.ws() {
3708                Ok(workspace) => workspace
3709                    .project()
3710                    .detection()
3711                    .dev_command
3712                    .clone()
3713                    .ok_or_else(|| "no detected dev command".to_string()),
3714                Err(error) => Err(error),
3715            }
3716        };
3717        let command = match command_result {
3718            Ok(command) => command,
3719            Err(error) if error == "no detected dev command" => {
3720                self.status =
3721                    "No development command detected · use :process start NAME COMMAND".into();
3722                return;
3723            }
3724            Err(error) => {
3725                self.status = if error.to_string().contains("workspace busy") {
3726                    "Development suite unavailable: workspace refresh is still running · use :s again"
3727                        .into()
3728                } else {
3729                    format!("Development command unavailable: {error}")
3730                };
3731                return;
3732            }
3733        };
3734        let (call, context) = match self.tool_request(
3735            "glass.process.start",
3736            serde_json::json!({"name": "dev", "command": command}),
3737            true,
3738        ) {
3739            Ok(request) => request,
3740            Err(error) => {
3741                self.status = format!("Development suite unavailable: {error}");
3742                return;
3743            }
3744        };
3745        let queued = match self.queue_or_confirm(
3746            call,
3747            context,
3748            "Start the detected development suite".into(),
3749        ) {
3750            Ok(queued) => queued,
3751            Err(error) => {
3752                self.status = format!("Development suite unavailable: {error}");
3753                return;
3754            }
3755        };
3756        self.surface = DevSurface::Terminal;
3757        if !queued {
3758            self.status = "Development suite ready · Enter approves once · Esc cancels".into();
3759        }
3760    }
3761
3762    pub fn show_surface(&mut self, surface: DevSurface) {
3763        self.surface = surface;
3764        self.status = format!("{} selected", surface.label());
3765        if surface != DevSurface::Code {
3766            self.pending_open_file = None;
3767        }
3768        if surface == DevSurface::Code && !self.code_edit_mode {
3769            self.queue_selected_file_preview();
3770        }
3771        if surface == DevSurface::Git {
3772            self.request_selected_git_diff();
3773        }
3774    }
3775
3776    pub fn queue_trust(&mut self, decision: crate::LocalTrustDecision) {
3777        if self.apply_trust(decision) {
3778            return;
3779        }
3780        self.pending_trust = Some(decision);
3781        self.status = "Trust queued · applying when the workspace is free".into();
3782    }
3783
3784    fn apply_trust(&mut self, decision: crate::LocalTrustDecision) -> bool {
3785        match self
3786            .workspace
3787            .try_lock()
3788            .and_then(|mut workspace| workspace.apply_local_trust_decision(decision))
3789        {
3790            Ok(trust) => {
3791                if self.surface == DevSurface::Trust {
3792                    self.surface = DevSurface::Agent;
3793                }
3794                self.snapshot_trust_label = trust.label().into();
3795                self.status = format!("Workspace opened with {} authority", trust.label());
3796                true
3797            }
3798            Err(error) if error.to_string().contains("workspace busy") => false,
3799            Err(error) => {
3800                self.status = format!("Trust decision failed: {error}");
3801                true
3802            }
3803        }
3804    }
3805
3806    pub fn flush_pending_trust(&mut self) {
3807        let Some(decision) = self.pending_trust else {
3808            return;
3809        };
3810        if self.apply_trust(decision) {
3811            self.pending_trust = None;
3812        }
3813    }
3814
3815    fn queue_selected_file_preview(&mut self) {
3816        if self.files.is_empty() {
3817            self.pending_open_file = Some(String::new());
3818            return;
3819        }
3820        self.open_selected_file();
3821    }
3822
3823    pub fn flush_pending_open_file(&mut self) {
3824        if self.pending_open_file.is_none() {
3825            return;
3826        }
3827        if self.surface != DevSurface::Code || self.code_edit_mode {
3828            return;
3829        }
3830        if self.files.is_empty() {
3831            return;
3832        }
3833        let queued = self.pending_open_file.take().unwrap_or_default();
3834        if !queued.is_empty()
3835            && let Some(index) = self.files.iter().position(|path| path == &queued)
3836        {
3837            self.selected_file = index;
3838        }
3839        self.open_selected_file();
3840    }
3841
3842    fn request_selected_git_diff(&mut self) {
3843        if self.git_entries.is_empty() {
3844            return;
3845        }
3846        self.git_diff_requested = true;
3847        if let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) {
3848            self.git_diff_path = Some(path);
3849        }
3850        if !self.git_diff_open {
3851            self.git_diff_open = true;
3852            self.git_diff = "Loading Git diff…".into();
3853        }
3854    }
3855
3856    fn is_workspace_busy(error: &impl std::fmt::Display) -> bool {
3857        error.to_string().contains("workspace busy")
3858    }
3859
3860    pub fn next_surface(&mut self) {
3861        let surfaces: &[DevSurface] = if self
3862            .responsive_class(self.terminal_width, self.terminal_height)
3863            == ResponsiveClass::Phone
3864        {
3865            &DevSurface::PHONE
3866        } else {
3867            &DevSurface::PRIMARY
3868        };
3869        let index = surfaces
3870            .iter()
3871            .position(|surface| *surface == self.surface)
3872            .unwrap_or(0);
3873        self.show_surface(surfaces[(index + 1) % surfaces.len()]);
3874    }
3875
3876    pub fn scroll_surface(&mut self, delta: i32) {
3877        let scroll = self.surface_scroll.entry(self.surface).or_default();
3878        *scroll = (*scroll as i64 + i64::from(delta)).max(0) as usize;
3879    }
3880
3881    pub fn scroll_home(&mut self) {
3882        self.surface_scroll.insert(self.surface, 0);
3883    }
3884
3885    pub fn scroll_end(&mut self) {
3886        let end = self.surface_content_height().saturating_sub(1);
3887        self.surface_scroll.insert(self.surface, end);
3888    }
3889
3890    /// Bounded logical height of the current surface's content, used for End.
3891    fn surface_content_height(&self) -> usize {
3892        if self.surface == DevSurface::Agent {
3893            return self.conversation_view().lines().count().max(1);
3894        }
3895        let content = match self.surface {
3896            DevSurface::Code => &self.editor,
3897            DevSurface::App => &self.browser,
3898            DevSurface::Terminal => &self.processes,
3899            DevSurface::Tasks => &self.tasks,
3900            DevSurface::Git => &self.git,
3901            DevSurface::Debug => &self.debugger,
3902            DevSurface::More | DevSurface::Trust => &self.workspace_status,
3903            DevSurface::Agent => unreachable!("agent content handled above"),
3904        };
3905        content.lines().count().max(1)
3906    }
3907
3908    pub fn current_scroll(&self) -> u16 {
3909        self.surface_scroll
3910            .get(&self.surface)
3911            .copied()
3912            .unwrap_or(0)
3913            .min(u16::MAX as usize) as u16
3914    }
3915
3916    pub fn move_file_selection(&mut self, delta: i32) {
3917        if self.files.is_empty() {
3918            self.selected_file = 0;
3919            return;
3920        }
3921        self.selected_file = (self.selected_file as i32 + delta)
3922            .clamp(0, self.files.len().saturating_sub(1) as i32)
3923            as usize;
3924        if !self.code_edit_mode {
3925            self.open_selected_file();
3926        }
3927    }
3928    pub fn move_git_selection(&mut self, delta: i32) {
3929        if self.git_entries.is_empty() {
3930            self.selected_git_file = 0;
3931            self.status = "No changed files selected".into();
3932            return;
3933        }
3934        self.selected_git_file = (self.selected_git_file as i32 + delta)
3935            .clamp(0, self.git_entries.len().saturating_sub(1) as i32)
3936            as usize;
3937        if let Some(entry) = self.git_entries.get(self.selected_git_file) {
3938            self.status = format!(
3939                "{} · Enter diff · Space stage · c commit · o open",
3940                entry.path
3941            );
3942            self.git_diff_requested = true;
3943        }
3944    }
3945
3946    pub fn selected_git_entry(&self) -> Option<&crate::git::GitStatusEntry> {
3947        self.git_entries.get(self.selected_git_file)
3948    }
3949
3950    pub fn open_selected_git_file(&mut self) {
3951        let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) else {
3952            self.status = "Select a changed file · o opens it in Code".into();
3953            return;
3954        };
3955        match self.open_path(&path) {
3956            Ok(_) => self.status = format!("Opened {path} in Code"),
3957            Err(error) => self.status = format!("Could not open {path}: {error}"),
3958        }
3959    }
3960
3961    pub fn compose_git_commit(&mut self) {
3962        self.open_palette_with("git commit ");
3963        self.status = "Commit · type a message, then Enter".into();
3964    }
3965
3966    pub fn discard_selected_git_file(&mut self) {
3967        let Some(path) = self.selected_git_entry().map(|entry| entry.path.clone()) else {
3968            self.status = "Select a changed file · x discards working-tree changes".into();
3969            return;
3970        };
3971        match self.tool_request(
3972            "glass.git.discard",
3973            serde_json::json!({"paths": [path.clone()]}),
3974            true,
3975        ) {
3976            Ok((call, context)) => {
3977                let _ = self.queue_or_confirm(call, context, format!("Discard {path}"));
3978            }
3979            Err(error) => self.status = format!("Git discard unavailable: {error}"),
3980        }
3981    }
3982
3983    pub fn queue_github_review(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
3984        if self.background_action_running() {
3985            self.status = "GitHub review waits for the current background operation".into();
3986            return;
3987        }
3988        let (call, context) =
3989            match self.tool_request("glass.github.review", serde_json::json!({}), false) {
3990                Ok(request) => request,
3991                Err(error) => {
3992                    self.status = format!("GitHub review unavailable: {error}");
3993                    return;
3994                }
3995            };
3996        match worker.submit_tool(call, context) {
3997            Ok(id) => {
3998                self.running_tool_job = Some(id);
3999                self.status = "Loading pull-request review…".into();
4000            }
4001            Err(error) => self.status = format!("GitHub review unavailable: {error}"),
4002        }
4003    }
4004
4005    pub fn move_process_selection(&mut self, delta: i32) {
4006        if self.process_entries.is_empty() {
4007            self.selected_process = 0;
4008            self.status = "No managed process selected".into();
4009            return;
4010        }
4011        self.selected_process = (self.selected_process as i32 + delta)
4012            .clamp(0, self.process_entries.len().saturating_sub(1) as i32)
4013            as usize;
4014        if let Some(entry) = self.selected_process_entry() {
4015            self.status = format!(
4016                "{} · {} · Enter logs · Space restart · u App · x stop",
4017                entry.name,
4018                entry.health.label()
4019            );
4020            self.process_logs_requested = true;
4021        }
4022    }
4023
4024    pub fn selected_process_entry(&self) -> Option<&ProcessRow> {
4025        self.process_entries.get(self.selected_process)
4026    }
4027
4028    pub fn queue_selected_process_logs(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4029        let Some(name) = self
4030            .selected_process_entry()
4031            .map(|entry| entry.name.clone())
4032        else {
4033            self.status = "Select a process · j/k then Enter logs".into();
4034            return;
4035        };
4036        if self.background_action_running() {
4037            self.status = "Process logs wait for the current background operation".into();
4038            return;
4039        }
4040        let (call, context) = match self.tool_request(
4041            "glass.process.logs",
4042            serde_json::json!({"name": name}),
4043            false,
4044        ) {
4045            Ok(request) => request,
4046            Err(error) => {
4047                self.status = format!("Process logs unavailable: {error}");
4048                return;
4049            }
4050        };
4051        match worker.submit_tool(call, context) {
4052            Ok(id) => {
4053                self.running_tool_job = Some(id);
4054                self.status = format!("Loading logs for {name}…");
4055            }
4056            Err(error) => self.status = format!("Process logs unavailable: {error}"),
4057        }
4058    }
4059
4060    pub fn restart_selected_process(&mut self) {
4061        let Some(name) = self
4062            .selected_process_entry()
4063            .map(|entry| entry.name.clone())
4064        else {
4065            self.status = "Select a process · j/k then Space restarts".into();
4066            return;
4067        };
4068        match self.tool_request(
4069            "glass.process.restart",
4070            serde_json::json!({"name": name}),
4071            true,
4072        ) {
4073            Ok((call, context)) => {
4074                let _ = self.queue_or_confirm(call, context, format!("Restart {name}"));
4075            }
4076            Err(error) => self.status = format!("Process restart unavailable: {error}"),
4077        }
4078    }
4079
4080    pub fn stop_selected_process(&mut self) {
4081        let Some(name) = self
4082            .selected_process_entry()
4083            .map(|entry| entry.name.clone())
4084        else {
4085            self.status = "Select a process · x stops it".into();
4086            return;
4087        };
4088        match self.tool_request(
4089            "glass.process.stop",
4090            serde_json::json!({"name": name}),
4091            true,
4092        ) {
4093            Ok((call, context)) => {
4094                let _ = self.queue_or_confirm(call, context, format!("Stop {name}"));
4095            }
4096            Err(error) => self.status = format!("Process stop unavailable: {error}"),
4097        }
4098    }
4099
4100    pub fn attach_selected_process_url(&mut self) -> Result<String, String> {
4101        let url = self
4102            .selected_process_entry()
4103            .and_then(|entry| entry.url.clone())
4104            .or_else(|| self.resolved_app_url())
4105            .ok_or_else(|| {
4106                "No URL on the selected process · start a suite that prints one".to_string()
4107            })?;
4108        self.auto_checkpoint("before-app-attach");
4109        self.prepare_browser_navigation(&url)
4110    }
4111
4112    pub fn cycle_debug_pane(&mut self, delta: i32) {
4113        self.debug_pane = if delta < 0 {
4114            self.debug_pane.previous()
4115        } else {
4116            self.debug_pane.next()
4117        };
4118        self.status = format!(
4119            "Debug {} · j/k select · Enter · Space continue",
4120            self.debug_pane.label()
4121        );
4122    }
4123
4124    pub fn move_debug_selection(&mut self, delta: i32) {
4125        match self.debug_pane {
4126            DebugPane::Sessions => {
4127                if self.debug_sessions.is_empty() {
4128                    self.selected_debug_session = 0;
4129                    self.status = "No debugger session · :debug start NAME COMMAND".into();
4130                    return;
4131                }
4132                self.selected_debug_session = (self.selected_debug_session as i32 + delta)
4133                    .clamp(0, self.debug_sessions.len().saturating_sub(1) as i32)
4134                    as usize;
4135                if let Some(session) = self.selected_debug_session() {
4136                    self.status = format!(
4137                        "{} · {} · Enter threads",
4138                        session.name,
4139                        session.state.label()
4140                    );
4141                }
4142            }
4143            DebugPane::Threads => {
4144                if self.debug_threads.is_empty() {
4145                    self.status = "No threads · Enter on a session to refresh".into();
4146                    return;
4147                }
4148                self.selected_debug_thread = (self.selected_debug_thread as i32 + delta)
4149                    .clamp(0, self.debug_threads.len().saturating_sub(1) as i32)
4150                    as usize;
4151                if let Some(thread) = self.selected_debug_thread() {
4152                    self.status = format!("{} · Enter stack · Space continue", thread.name);
4153                }
4154            }
4155            DebugPane::Frames => {
4156                if self.debug_frames.is_empty() {
4157                    self.status = "No frames · Enter on a thread to load the stack".into();
4158                    return;
4159                }
4160                self.selected_debug_frame = (self.selected_debug_frame as i32 + delta)
4161                    .clamp(0, self.debug_frames.len().saturating_sub(1) as i32)
4162                    as usize;
4163                if let Some(frame) = self.selected_debug_frame() {
4164                    self.status = format!(
4165                        "{} · Enter jumps to {}",
4166                        frame.name,
4167                        frame.path.as_deref().unwrap_or("source")
4168                    );
4169                }
4170            }
4171        }
4172    }
4173
4174    pub fn selected_debug_session(&self) -> Option<&DebugSessionRow> {
4175        self.debug_sessions.get(self.selected_debug_session)
4176    }
4177
4178    pub fn selected_debug_thread(&self) -> Option<&DebugThreadRow> {
4179        self.debug_threads.get(self.selected_debug_thread)
4180    }
4181
4182    pub fn selected_debug_frame(&self) -> Option<&DebugFrameRow> {
4183        self.debug_frames.get(self.selected_debug_frame)
4184    }
4185
4186    pub fn activate_debug_selection(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4187        match self.debug_pane {
4188            DebugPane::Sessions => self.queue_debug_threads(worker),
4189            DebugPane::Threads => self.queue_debug_stack(worker),
4190            DebugPane::Frames => self.jump_selected_debug_frame(),
4191        }
4192    }
4193
4194    pub fn queue_debug_threads(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4195        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4196            self.status = "Start a debugger with :debug start NAME COMMAND".into();
4197            return;
4198        };
4199        if self.background_action_running() {
4200            self.status = "Debug threads wait for the current background operation".into();
4201            return;
4202        }
4203        let (call, context) = match self.tool_request(
4204            "glass.debug.threads",
4205            serde_json::json!({"session": session}),
4206            false,
4207        ) {
4208            Ok(request) => request,
4209            Err(error) => {
4210                self.status = format!("Debug threads unavailable: {error}");
4211                return;
4212            }
4213        };
4214        match worker.submit_tool(call, context) {
4215            Ok(id) => {
4216                self.running_tool_job = Some(id);
4217                self.status = format!("Loading threads for {session}…");
4218            }
4219            Err(error) => self.status = format!("Debug threads unavailable: {error}"),
4220        }
4221    }
4222
4223    pub fn queue_debug_stack(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4224        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4225            self.status = "Select a debugger session first".into();
4226            return;
4227        };
4228        let Some(thread_id) = self.selected_debug_thread().map(|thread| thread.id) else {
4229            self.status = "Select a thread · Enter on a session first".into();
4230            return;
4231        };
4232        if self.background_action_running() {
4233            self.status = "Debug stack waits for the current background operation".into();
4234            return;
4235        }
4236        let (call, context) = match self.tool_request(
4237            "glass.debug.stack",
4238            serde_json::json!({"session": session, "threadId": thread_id}),
4239            false,
4240        ) {
4241            Ok(request) => request,
4242            Err(error) => {
4243                self.status = format!("Debug stack unavailable: {error}");
4244                return;
4245            }
4246        };
4247        match worker.submit_tool(call, context) {
4248            Ok(id) => {
4249                self.running_tool_job = Some(id);
4250                self.status = format!("Loading stack for thread {thread_id}…");
4251            }
4252            Err(error) => self.status = format!("Debug stack unavailable: {error}"),
4253        }
4254    }
4255
4256    pub fn continue_selected_debug(&mut self) {
4257        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4258            self.status = "Select a debugger session · Space continues".into();
4259            return;
4260        };
4261        let Some(thread_id) = self.selected_debug_thread().map(|thread| thread.id) else {
4262            self.status = "Refresh threads before continue".into();
4263            return;
4264        };
4265        match self.tool_request(
4266            "glass.debug.continue",
4267            serde_json::json!({"session": session, "threadId": thread_id}),
4268            true,
4269        ) {
4270            Ok((call, context)) => {
4271                let _ = self.queue_or_confirm(
4272                    call,
4273                    context,
4274                    format!("Continue {session} thread {thread_id}"),
4275                );
4276            }
4277            Err(error) => self.status = format!("Debug continue unavailable: {error}"),
4278        }
4279    }
4280
4281    pub fn step_selected_debug(&mut self, kind: &str) {
4282        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4283            self.status = "Select a debugger session · n over · i in · o out".into();
4284            return;
4285        };
4286        let Some(thread_id) = self.selected_debug_thread().map(|thread| thread.id) else {
4287            self.status = "Refresh threads before stepping".into();
4288            return;
4289        };
4290        match self.tool_request(
4291            "glass.debug.step",
4292            serde_json::json!({"session": session, "threadId": thread_id, "kind": kind}),
4293            true,
4294        ) {
4295            Ok((call, context)) => {
4296                let _ = self.queue_or_confirm(
4297                    call,
4298                    context,
4299                    format!("Step {kind} {session} thread {thread_id}"),
4300                );
4301            }
4302            Err(error) => self.status = format!("Debug step unavailable: {error}"),
4303        }
4304    }
4305
4306    pub fn pause_selected_debug(&mut self) {
4307        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4308            self.status = "Select a debugger session · p pauses".into();
4309            return;
4310        };
4311        let thread_id = self
4312            .selected_debug_thread()
4313            .map(|thread| thread.id)
4314            .unwrap_or(1);
4315        match self.tool_request(
4316            "glass.debug.pause",
4317            serde_json::json!({"session": session, "threadId": thread_id}),
4318            true,
4319        ) {
4320            Ok((call, context)) => {
4321                let _ = self.queue_or_confirm(call, context, format!("Pause {session}"));
4322            }
4323            Err(error) => self.status = format!("Debug pause unavailable: {error}"),
4324        }
4325    }
4326
4327    pub fn breakpoint_focused_line(&mut self) {
4328        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4329            self.status = "Start a debugger before setting breakpoints".into();
4330            return;
4331        };
4332        if self.focused_editor_path.is_empty() {
4333            self.status = "Open a file in Code · b sets a breakpoint on the cursor line".into();
4334            return;
4335        }
4336        let line = u64::from(self.focused_editor_line.max(1));
4337        match self.tool_request(
4338            "glass.debug.breakpoint.set",
4339            serde_json::json!({
4340                "session": session,
4341                "path": self.focused_editor_path,
4342                "lines": [line],
4343            }),
4344            true,
4345        ) {
4346            Ok((call, context)) => {
4347                let _ = self.queue_or_confirm(
4348                    call,
4349                    context,
4350                    format!("Breakpoint {}:{}", self.focused_editor_path, line),
4351                );
4352            }
4353            Err(error) => self.status = format!("Breakpoint unavailable: {error}"),
4354        }
4355    }
4356
4357    pub fn queue_debug_scopes(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4358        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4359            return;
4360        };
4361        let Some(frame_id) = self.selected_debug_frame().map(|frame| frame.id) else {
4362            return;
4363        };
4364        if self.background_action_running() {
4365            return;
4366        }
4367        let Ok((call, context)) = self.tool_request(
4368            "glass.debug.scopes",
4369            serde_json::json!({"session": session, "frameId": frame_id}),
4370            false,
4371        ) else {
4372            return;
4373        };
4374        if let Ok(id) = worker.submit_tool(call, context) {
4375            self.running_tool_job = Some(id);
4376            self.status = "Loading scopes…".into();
4377        }
4378    }
4379
4380    pub fn queue_debug_variables(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4381        let Some(session) = self.selected_debug_session().map(|row| row.name.clone()) else {
4382            return;
4383        };
4384        let Some(reference) = self
4385            .debug_scopes
4386            .get(self.selected_debug_scope)
4387            .map(|scope| scope.variables_reference)
4388        else {
4389            return;
4390        };
4391        if reference <= 0 || self.background_action_running() {
4392            return;
4393        }
4394        let Ok((call, context)) = self.tool_request(
4395            "glass.debug.variables",
4396            serde_json::json!({"session": session, "variablesReference": reference}),
4397            false,
4398        ) else {
4399            return;
4400        };
4401        if let Ok(id) = worker.submit_tool(call, context) {
4402            self.running_tool_job = Some(id);
4403            self.status = "Loading variables…".into();
4404        }
4405    }
4406
4407    pub fn jump_selected_debug_frame(&mut self) {
4408        let Some(frame) = self.selected_debug_frame().cloned() else {
4409            self.status = "Select a stack frame · Enter jumps to source".into();
4410            return;
4411        };
4412        let Some(path) = frame.path.clone() else {
4413            self.status = format!("{} has no source path", frame.name);
4414            return;
4415        };
4416        match self.open_path(&path) {
4417            Ok(_) => {
4418                if let Some(line) = frame.line {
4419                    let _ = self.set_editor_cursor(
4420                        &self.focused_editor_path.clone(),
4421                        crate::development::TextPosition {
4422                            line: u32::try_from(line).unwrap_or(u32::MAX).max(1),
4423                            column: 1,
4424                        },
4425                        false,
4426                    );
4427                    self.refresh_editor_projection();
4428                }
4429                self.status = format!(
4430                    "Debug {} · {}{}",
4431                    frame.name,
4432                    path,
4433                    frame
4434                        .line
4435                        .map(|line| format!(":{line}"))
4436                        .unwrap_or_default()
4437                );
4438                self.debug_scopes_requested = true;
4439            }
4440            Err(error) => self.status = format!("Could not open {path}: {error}"),
4441        }
4442    }
4443
4444    pub fn move_todo_selection(&mut self, delta: i32) {
4445        if self.session_todos.items.is_empty() {
4446            self.selected_todo = 0;
4447            self.status = "No session todos · Plan accept or glass.todo.write".into();
4448            return;
4449        }
4450        self.selected_todo = (self.selected_todo as i32 + delta)
4451            .clamp(0, self.session_todos.items.len().saturating_sub(1) as i32)
4452            as usize;
4453        if let Some(item) = self.session_todos.items.get(self.selected_todo) {
4454            self.status = format!(
4455                "{} · {} · Enter complete · Space activate",
4456                item.id,
4457                item.status.label()
4458            );
4459        }
4460    }
4461
4462    pub fn complete_selected_todo(&mut self) {
4463        let Some(id) = self
4464            .session_todos
4465            .items
4466            .get(self.selected_todo)
4467            .map(|item| item.id.clone())
4468        else {
4469            self.status = "Select a session todo · Enter marks it done".into();
4470            return;
4471        };
4472        match self.ws_mut().and_then(|mut workspace| {
4473            workspace
4474                .complete_todo(&id)
4475                .map_err(|error| error.to_string())
4476        }) {
4477            Ok(item) => {
4478                if let Ok(list) = self.ws().map(|workspace| workspace.todos()) {
4479                    self.session_todos = list;
4480                    self.selected_todo = self
4481                        .selected_todo
4482                        .min(self.session_todos.items.len().saturating_sub(1));
4483                }
4484                self.status = format!("Todo {} done · {}", item.id, item.title);
4485            }
4486            Err(error) => self.status = format!("Todo complete unavailable: {error}"),
4487        }
4488    }
4489
4490    pub fn activate_selected_todo(&mut self) {
4491        let Some(id) = self
4492            .session_todos
4493            .items
4494            .get(self.selected_todo)
4495            .map(|item| item.id.clone())
4496        else {
4497            self.status = "Select a session todo · Space makes it active".into();
4498            return;
4499        };
4500        match self.ws_mut().and_then(|mut workspace| {
4501            workspace
4502                .activate_todo(&id)
4503                .map_err(|error| error.to_string())
4504        }) {
4505            Ok(item) => {
4506                if let Ok(list) = self.ws().map(|workspace| workspace.todos()) {
4507                    self.session_todos = list;
4508                }
4509                self.status = format!("Todo {} active · {}", item.id, item.title);
4510            }
4511            Err(error) => self.status = format!("Todo activate unavailable: {error}"),
4512        }
4513    }
4514
4515    pub const MORE_ROUTES: [&'static str; 5] = [
4516        "doctor",
4517        "cockpit start",
4518        "kernel start",
4519        "experiment",
4520        "harness list",
4521    ];
4522
4523    pub fn move_more_selection(&mut self, delta: i32) {
4524        let last = Self::MORE_ROUTES.len().saturating_sub(1) as i32;
4525        self.selected_more = (self.selected_more as i32 + delta).clamp(0, last) as usize;
4526        self.status = format!("{} · Enter runs", Self::MORE_ROUTES[self.selected_more]);
4527    }
4528
4529    pub fn activate_more_selection(&mut self) {
4530        let command = Self::MORE_ROUTES[self.selected_more.min(Self::MORE_ROUTES.len() - 1)];
4531        if command == "kernel start" {
4532            self.open_palette_with("kernel start ");
4533            self.status = "kernel start · NAME KIND, then Enter".into();
4534            return;
4535        }
4536        match super::command::execute(self, command) {
4537            Ok(message) => {
4538                self.surface = DevSurface::More;
4539                self.more_result = message.clone();
4540                self.status = more_route_status(command, &message);
4541            }
4542            Err(error) => {
4543                self.surface = DevSurface::More;
4544                self.open_palette_with(command);
4545                self.status = format!("{command} · {error}");
4546            }
4547        }
4548    }
4549
4550    pub fn open_selected_file(&mut self) {
4551        let Some(path) = self.files.get(self.selected_file).cloned() else {
4552            self.status = "No project file selected".into();
4553            return;
4554        };
4555        let already_open = self
4556            .workspace
4557            .try_lock()
4558            .map(|workspace| workspace.project().buffer(&path).is_some())
4559            .unwrap_or(false);
4560        let result = if already_open {
4561            Ok(())
4562        } else {
4563            self.workspace.try_lock().and_then(|mut workspace| {
4564                workspace
4565                    .project_mut()
4566                    .open_buffer(&path, crate::development::Actor::local())
4567                    .map(|_| ())
4568            })
4569        };
4570        match result {
4571            Ok(()) => {
4572                self.pending_open_file = None;
4573                self.editor_buffer_index = self
4574                    .workspace
4575                    .try_lock()
4576                    .ok()
4577                    .and_then(|workspace| {
4578                        workspace
4579                            .project()
4580                            .buffers()
4581                            .position(|buffer| buffer.path == path)
4582                    })
4583                    .unwrap_or(0);
4584                self.refresh_editor_projection();
4585                self.status = if already_open {
4586                    format!("Selected {path} · Enter opens the full-screen editor")
4587                } else {
4588                    format!("Opened {path} · Enter opens the full-screen editor")
4589                };
4590            }
4591            Err(error) if Self::is_workspace_busy(&error) => {
4592                self.pending_open_file = Some(path.clone());
4593                self.status = format!("Opening {path} when the workspace is free");
4594            }
4595            Err(error) => self.status = format!("Open failed: {error}"),
4596        }
4597    }
4598
4599    pub fn open_selected_file_for_edit(&mut self) {
4600        let selected_path = self.files.get(self.selected_file).cloned();
4601        self.open_selected_file();
4602        if selected_path.as_deref() == Some(self.focused_editor_path.as_str()) {
4603            self.surface = DevSurface::Code;
4604            self.enter_code_edit();
4605        }
4606    }
4607
4608    /// Load the current Git diff without blocking key handling.
4609    pub fn queue_git_diff(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
4610        if self.background_action_running() {
4611            self.status = "Git diff waits for the current background operation".into();
4612            return;
4613        }
4614        let selected = self.selected_git_entry().map(|entry| {
4615            (
4616                entry.path.clone(),
4617                entry.untracked,
4618                entry.index_status,
4619                entry.worktree_status,
4620            )
4621        });
4622        if let Some((path, true, _, _)) = selected.as_ref() {
4623            self.git_diff_path = Some(path.clone());
4624            self.git_diff = format!(
4625                "{path}\n\nUntracked file · Git has no tracked diff yet.\nUse Enter on Code to inspect the file."
4626            );
4627            self.git_diff_open = true;
4628            self.surface_scroll.insert(DevSurface::Git, 0);
4629            self.status = format!("{path} is untracked · no Git diff to show");
4630            return;
4631        }
4632        let staged = selected
4633            .as_ref()
4634            .is_some_and(|(_, _, index, worktree)| *index != ' ' && *worktree == ' ');
4635        let mut arguments = serde_json::json!({"staged": staged});
4636        if let Some((path, _, _, _)) = selected.as_ref() {
4637            arguments["path"] = serde_json::Value::String(path.clone());
4638        }
4639        let (call, context) = match self.tool_request("glass.git.diff", arguments, false) {
4640            Ok(request) => request,
4641            Err(error) => {
4642                self.status = format!("Git diff unavailable: {error}");
4643                return;
4644            }
4645        };
4646        match worker.submit_tool(call, context) {
4647            Ok(id) => {
4648                self.running_tool_job = Some(id);
4649                self.git_diff_path = selected.map(|(path, _, _, _)| path);
4650                self.git_diff_open = true;
4651                self.surface_scroll.insert(DevSurface::Git, 0);
4652                self.git_diff = "Loading Git diff…".into();
4653                self.status = self
4654                    .git_diff_path
4655                    .as_deref()
4656                    .map(|path| format!("Loading diff for {path} in background…"))
4657                    .unwrap_or_else(|| "Loading full worktree diff in background…".into());
4658            }
4659            Err(error) => self.status = format!("Git diff unavailable: {error}"),
4660        }
4661    }
4662
4663    /// Synchronous helper retained for callers outside the terminal event loop.
4664    pub fn open_git_diff(&mut self) {
4665        let diff = self.workspace.try_lock().and_then(|workspace| {
4666            workspace
4667                .git()
4668                .ok_or_else(|| {
4669                    crate::development::DevelopmentError::NotFound("not a Git repository".into())
4670                })?
4671                .diff(false, None)
4672                .map_err(|error| crate::development::DevelopmentError::Process(error.to_string()))
4673        });
4674        self.git_diff_path = None;
4675        match diff {
4676            Ok(diff) if diff.trim().is_empty() => {
4677                self.git_diff = "Working tree clean · no diff to show".into();
4678                self.git_diff_open = true;
4679                self.surface_scroll.insert(DevSurface::Git, 0);
4680                self.status = "Git diff · no changes".into();
4681            }
4682            Ok(diff) => {
4683                self.git_diff = diff;
4684                self.git_diff_open = true;
4685                self.surface_scroll.insert(DevSurface::Git, 0);
4686                self.status = "Git diff · PgUp/PgDn scroll · Esc closes".into();
4687            }
4688            Err(error) => self.status = format!("Git diff unavailable: {error}"),
4689        }
4690    }
4691
4692    pub fn close_git_diff(&mut self) {
4693        self.git_diff_open = false;
4694        self.git_diff_requested = false;
4695        self.git_diff_path = None;
4696        self.surface_scroll.insert(DevSurface::Git, 0);
4697        self.status = "Git status · select a file with ↑/↓".into();
4698    }
4699
4700    pub fn focused_buffer(&self) -> Option<crate::development::EditorBuffer> {
4701        self.workspace.try_lock().ok().and_then(|workspace| {
4702            workspace
4703                .project()
4704                .buffers()
4705                .nth(self.editor_buffer_index)
4706                .cloned()
4707        })
4708    }
4709
4710    pub fn refresh_editor_projection(&mut self) {
4711        let (buffers, comments, proposals, checkpoints, diagnostics) = self
4712            .workspace
4713            .lock()
4714            .map(|workspace| {
4715                (
4716                    workspace.project().buffers().cloned().collect::<Vec<_>>(),
4717                    workspace.project().editor_comments(None),
4718                    workspace.project().editor_proposals(),
4719                    workspace.project().editor_checkpoints(),
4720                    workspace.project().diagnostics().clone(),
4721                )
4722            })
4723            .unwrap_or_default();
4724        self.editor_comments = comments;
4725        self.editor_proposals = proposals;
4726        self.editor_checkpoints = checkpoints;
4727        if let Some(buffer) = buffers.get(self.editor_buffer_index) {
4728            self.focused_editor_path = buffer.path.clone();
4729            self.focused_editor_content = buffer.content.clone();
4730            self.focused_editor_dirty = buffer.dirty;
4731            self.focused_editor_line = buffer.cursor_line;
4732            self.focused_editor_column = buffer.cursor_column;
4733            self.focused_editor_selection = buffer.selection.clone();
4734            self.editor_diagnostics = diagnostics.get(&buffer.path).cloned().unwrap_or_default();
4735            self.ensure_editor_cursor_visible();
4736            let path = self.focused_editor_path.clone();
4737            let content = self.focused_editor_content.clone();
4738            self.syntax.sync(&path, &content);
4739            if let Some(proposal) = self.editor_proposals.iter().find(|item| {
4740                item.path == path && item.state == crate::development::EditorProposalState::Pending
4741            }) {
4742                let line = native::line_hunks(&proposal.original, &proposal.proposed)
4743                    .first()
4744                    .map(|hunk| hunk.start_line)
4745                    .unwrap_or(1);
4746                self.editor_engine.agent_caret = Some(native::Jump {
4747                    path: path.clone(),
4748                    line,
4749                    column: 1,
4750                });
4751            } else {
4752                self.editor_engine.agent_caret = None;
4753            }
4754            self.maybe_begin_pair_apply();
4755        } else {
4756            self.focused_editor_path.clear();
4757            self.focused_editor_content.clear();
4758            self.focused_editor_dirty = false;
4759            self.focused_editor_line = 0;
4760            self.focused_editor_column = 0;
4761            self.focused_editor_selection = None;
4762            self.editor_scroll_line = 0;
4763            self.editor_scroll_column = 0;
4764            self.editor_inlays.clear();
4765            self.editor_diagnostics.clear();
4766        }
4767        self.editor = format_editor_buffers(&buffers);
4768    }
4769
4770    fn refresh_editor_inlays(&mut self) {
4771        let path = self.focused_editor_path.clone();
4772        if path.is_empty() {
4773            self.editor_inlays.clear();
4774            return;
4775        }
4776        let response = self.workspace.try_lock().ok().and_then(|mut workspace| {
4777            let name = workspace.language().names().next()?.to_string();
4778            workspace.language().inlay_hints(&name, "local", &path).ok()
4779        });
4780        self.editor_inlays = response
4781            .map(|response| parse_inlay_hints(&response.result))
4782            .unwrap_or_default();
4783    }
4784
4785    pub fn editor_collaboration_summary(&self) -> String {
4786        let open_comments = self
4787            .editor_comments
4788            .iter()
4789            .filter(|comment| comment.state == crate::development::EditorCommentState::Open)
4790            .count();
4791        let pending = self
4792            .editor_proposals
4793            .iter()
4794            .filter(|proposal| proposal.state == crate::development::EditorProposalState::Pending)
4795            .count();
4796        format!(
4797            "comments {} open · proposals {} pending · checkpoints {}",
4798            open_comments,
4799            pending,
4800            self.editor_checkpoints.len()
4801        )
4802    }
4803
4804    pub fn cycle_editor_buffer(&mut self, delta: i32) {
4805        let count = self
4806            .workspace
4807            .lock()
4808            .map(|workspace| workspace.project().buffers().count())
4809            .unwrap_or(0);
4810        if count == 0 {
4811            self.status = "No open buffers · open a file from the list".into();
4812            return;
4813        }
4814        let index = self.editor_buffer_index as i32 + delta;
4815        self.editor_buffer_index = index.rem_euclid(count as i32) as usize;
4816        let name = self
4817            .workspace
4818            .lock()
4819            .ok()
4820            .and_then(|workspace| {
4821                workspace
4822                    .project()
4823                    .buffers()
4824                    .nth(self.editor_buffer_index)
4825                    .map(|buffer| buffer.path.clone())
4826            })
4827            .unwrap_or_default();
4828        self.refresh_editor_projection();
4829        self.status = format!("Buffer {}/{} · {name}", self.editor_buffer_index + 1, count);
4830    }
4831
4832    pub fn enter_code_edit(&mut self) {
4833        let has_buffer = self.focused_buffer().is_some();
4834        if !has_buffer {
4835            self.open_selected_file();
4836        }
4837        if self.focused_buffer().is_some() || !self.focused_editor_path.is_empty() {
4838            self.surface = DevSurface::Code;
4839            self.code_edit_mode = true;
4840            self.editor_exit_prompt = None;
4841            self.ensure_editor_cursor_visible();
4842            self.editor_engine.enter_insert();
4843            self.refresh_editor_hunks();
4844            self.refresh_editor_inlays();
4845            self.status = "INSERT · Esc normal · gm/gn extra carets · dif · gd · Ctrl-S".into();
4846        }
4847    }
4848
4849    pub fn handle_editor_escape(&mut self) {
4850        if self.editor_engine.overlay.take().is_some()
4851            || !self.editor_engine.symbols.is_empty()
4852            || self.editor_engine.ghost.take().is_some()
4853        {
4854            self.editor_engine.symbols.clear();
4855            self.editor_engine.clear_pending();
4856            self.status = format!("{} · overlay closed", self.editor_engine.mode.label());
4857            return;
4858        }
4859        match self.editor_engine.mode {
4860            EditorMode::Agent => {
4861                self.editor_engine.stop_pair_apply();
4862                self.status = "NORMAL · agent yielded · hjkl · i insert · Esc exit".into();
4863            }
4864            EditorMode::Insert | EditorMode::Select => {
4865                self.editor_engine.enter_normal();
4866                self.status = self.editor_normal_status();
4867            }
4868            EditorMode::Normal => {
4869                if self.editor_engine.clear_extra_cursors() {
4870                    self.status = "NORMAL · extra carets cleared".into();
4871                    self.refresh_editor_projection();
4872                    return;
4873                }
4874                if !self.focused_editor_dirty {
4875                    self.close_code_edit();
4876                    return;
4877                }
4878                self.request_editor_exit();
4879            }
4880        }
4881    }
4882
4883    fn editor_normal_status(&self) -> String {
4884        let extras = self.editor_engine.extra_caret_count();
4885        if extras > 0 {
4886            format!(
4887                "NORMAL · {} carets · gm match · gn next · d/c/i apply to all · Esc clear",
4888                extras + 1
4889            )
4890        } else {
4891            "NORMAL · hjkl · d/c/y · iw/if/ia · gm/gn extra carets · i insert · Esc exit".into()
4892        }
4893    }
4894
4895    pub fn close_code_edit(&mut self) {
4896        self.code_edit_mode = false;
4897        self.editor_exit_prompt = None;
4898        self.surface = DevSurface::Code;
4899        self.status = "Code navigation · select a file and press Enter to edit".into();
4900    }
4901
4902    pub fn request_editor_exit(&mut self) {
4903        if !self.code_edit_mode {
4904            return;
4905        }
4906        self.refresh_editor_projection();
4907        let prompt = if self.focused_editor_dirty {
4908            EditorExitPrompt::Unsaved
4909        } else {
4910            EditorExitPrompt::Clean
4911        };
4912        self.editor_exit_prompt = Some(prompt);
4913        self.status = match prompt {
4914            EditorExitPrompt::Clean => "Exit editor? Enter leaves · Esc stays".into(),
4915            EditorExitPrompt::Unsaved => {
4916                "Unsaved changes · S save · D discard · Q discard and quit · Esc stays".into()
4917            }
4918        };
4919    }
4920
4921    pub fn cancel_editor_exit(&mut self) {
4922        self.editor_exit_prompt = None;
4923        self.status = "Still editing · Esc opens exit choices".into();
4924    }
4925
4926    pub fn handle_editor_exit_key(&mut self, code: crossterm::event::KeyCode) {
4927        let Some(prompt) = self.editor_exit_prompt else {
4928            return;
4929        };
4930        match prompt {
4931            EditorExitPrompt::Clean => match code {
4932                crossterm::event::KeyCode::Enter
4933                | crossterm::event::KeyCode::Char('q' | 'Q' | 'y' | 'Y') => {
4934                    self.close_code_edit();
4935                }
4936                crossterm::event::KeyCode::Esc | crossterm::event::KeyCode::Char('n' | 'N') => {
4937                    self.cancel_editor_exit()
4938                }
4939                _ => {}
4940            },
4941            EditorExitPrompt::Unsaved => match code {
4942                crossterm::event::KeyCode::Char('s' | 'S') => match self.save_editor_buffer() {
4943                    Ok(()) => {
4944                        let path = self.focused_editor_path.clone();
4945                        self.refresh_editor_projection();
4946                        self.close_code_edit();
4947                        self.status = format!("Saved {path} · editor closed");
4948                    }
4949                    Err(error) => {
4950                        self.status =
4951                            format!("Save failed: {error} · S retry · D discard · Q quit");
4952                    }
4953                },
4954                crossterm::event::KeyCode::Char('d' | 'D') => match self.discard_editor_buffer() {
4955                    Ok(()) => {
4956                        let path = self.focused_editor_path.clone();
4957                        self.refresh_editor_projection();
4958                        self.close_code_edit();
4959                        self.status = format!("Discarded changes in {path} · editor closed");
4960                    }
4961                    Err(error) => {
4962                        self.status =
4963                            format!("Discard failed: {error} · S save · D retry · Q quit");
4964                    }
4965                },
4966                crossterm::event::KeyCode::Char('q' | 'Q') => match self.discard_editor_buffer() {
4967                    Ok(()) => {
4968                        self.code_edit_mode = false;
4969                        self.editor_exit_prompt = None;
4970                        self.surface = DevSurface::Code;
4971                        self.quit = true;
4972                        self.status = "Changes discarded · closing Glass Dev".into();
4973                    }
4974                    Err(error) => {
4975                        self.status =
4976                            format!("Discard failed: {error} · S save · D retry · Q quit");
4977                    }
4978                },
4979                crossterm::event::KeyCode::Esc => self.cancel_editor_exit(),
4980                _ => {}
4981            },
4982        }
4983    }
4984
4985    fn save_editor_buffer(&mut self) -> Result<(), String> {
4986        let path = self.focused_editor_path.clone();
4987        self.workspace
4988            .try_lock()
4989            .map_err(|error| error.to_string())?
4990            .project_mut()
4991            .save_buffer(&path)
4992            .map(|_| ())
4993            .map_err(|error| error.to_string())
4994    }
4995
4996    fn discard_editor_buffer(&mut self) -> Result<(), String> {
4997        let path = self.focused_editor_path.clone();
4998        self.workspace
4999            .try_lock()
5000            .map_err(|error| error.to_string())?
5001            .project_mut()
5002            .open_buffer(&path, crate::development::Actor::local())
5003            .map(|_| ())
5004            .map_err(|error| error.to_string())
5005    }
5006
5007    fn ensure_editor_cursor_visible(&mut self) {
5008        if self.focused_editor_path.is_empty() {
5009            return;
5010        }
5011        let viewport_height = usize::from(self.terminal_height.saturating_sub(8).max(1));
5012        if self.editor_soft_wrap {
5013            let marks = self
5014                .editor_gutter_marks()
5015                .into_iter()
5016                .map(|(line, mark)| (line, mark.glyph()))
5017                .collect::<Vec<_>>();
5018            let notes = self.editor_source_notes();
5019            let decorations = super::file_view::EditorDecorations {
5020                marks: &marks,
5021                inlays: &notes,
5022                extra_selections: &self.editor_engine.extra_selections,
5023            };
5024            let wrapped = super::file_view::render_editable_source_wrapped(
5025                &self.focused_editor_path,
5026                &self.focused_editor_content,
5027                self.focused_editor_line,
5028                self.focused_editor_column,
5029                self.focused_editor_selection.as_ref(),
5030                self.terminal_width.saturating_sub(4).max(1),
5031                &decorations,
5032            );
5033            let Some(cursor) = wrapped.cursor else {
5034                return;
5035            };
5036            self.editor_scroll_column = 0;
5037            if cursor.row < self.editor_scroll_line {
5038                self.editor_scroll_line = cursor.row;
5039            } else if cursor.row >= self.editor_scroll_line + viewport_height {
5040                self.editor_scroll_line = cursor.row + 1 - viewport_height;
5041            }
5042            return;
5043        }
5044        let lines = self.focused_editor_content.split('\n').collect::<Vec<_>>();
5045        let cursor_line = self.focused_editor_line.saturating_sub(1) as usize;
5046        if cursor_line < self.editor_scroll_line {
5047            self.editor_scroll_line = cursor_line;
5048        } else if cursor_line >= self.editor_scroll_line + viewport_height {
5049            self.editor_scroll_line = cursor_line + 1 - viewport_height;
5050        }
5051        let gutter_width = lines.len().max(1).to_string().len().max(3);
5052        let viewport_width = usize::from(
5053            self.terminal_width
5054                .saturating_sub((gutter_width + 8).min(u16::MAX as usize) as u16)
5055                .max(1),
5056        );
5057        let cursor_column = self.focused_editor_column.saturating_sub(1) as usize;
5058        if cursor_column < self.editor_scroll_column {
5059            self.editor_scroll_column = cursor_column;
5060        } else if cursor_column >= self.editor_scroll_column + viewport_width {
5061            self.editor_scroll_column = cursor_column + 1 - viewport_width;
5062        }
5063    }
5064
5065    pub fn toggle_editor_soft_wrap(&mut self) {
5066        self.editor_soft_wrap = !self.editor_soft_wrap;
5067        self.editor_scroll_line = 0;
5068        self.editor_scroll_column = 0;
5069        self.ensure_editor_cursor_visible();
5070        self.status = if self.editor_soft_wrap {
5071            "Soft wrap ON · source lines reflow to the editor width".into()
5072        } else {
5073            "Soft wrap OFF · horizontal scrolling follows source columns".into()
5074        };
5075    }
5076
5077    pub fn edit_code_key(
5078        &mut self,
5079        code: crossterm::event::KeyCode,
5080        modifiers: crossterm::event::KeyModifiers,
5081    ) {
5082        if code == crossterm::event::KeyCode::Char('w')
5083            && modifiers.contains(crossterm::event::KeyModifiers::ALT)
5084        {
5085            self.toggle_editor_soft_wrap();
5086            return;
5087        }
5088        if self.editor_engine.mode == EditorMode::Agent {
5089            self.edit_agent_key(code, modifiers);
5090            return;
5091        }
5092        if self.editor_engine.mode == EditorMode::Insert
5093            || modifiers.contains(crossterm::event::KeyModifiers::CONTROL)
5094            || modifiers.contains(crossterm::event::KeyModifiers::ALT)
5095        {
5096            self.edit_insert_or_chords(code, modifiers);
5097            return;
5098        }
5099        self.edit_normal_key(code, modifiers);
5100    }
5101
5102    fn edit_agent_key(
5103        &mut self,
5104        code: crossterm::event::KeyCode,
5105        modifiers: crossterm::event::KeyModifiers,
5106    ) {
5107        match code {
5108            crossterm::event::KeyCode::Enter => {
5109                let id = self
5110                    .editor_engine
5111                    .pair_apply
5112                    .as_ref()
5113                    .map(|apply| apply.proposal_id.clone());
5114                self.editor_engine.stop_pair_apply();
5115                if let Some(id) = id {
5116                    match self.accept_review_proposal(Some(&id)) {
5117                        Ok(message) => self.status = message,
5118                        Err(error) => self.status = error,
5119                    }
5120                }
5121            }
5122            crossterm::event::KeyCode::Char('n') => {
5123                let id = self
5124                    .editor_engine
5125                    .pair_apply
5126                    .as_ref()
5127                    .map(|apply| apply.proposal_id.clone());
5128                self.editor_engine.stop_pair_apply();
5129                if let Some(id) = id {
5130                    match self.reject_review_proposal(Some(&id)) {
5131                        Ok(message) => self.status = message,
5132                        Err(error) => self.status = error,
5133                    }
5134                }
5135            }
5136            crossterm::event::KeyCode::Esc => self.handle_editor_escape(),
5137            _ => {
5138                self.editor_engine.stop_pair_apply();
5139                self.editor_engine.enter_insert();
5140                self.edit_insert_or_chords(code, modifiers);
5141            }
5142        }
5143        self.refresh_editor_projection();
5144    }
5145
5146    fn edit_insert_or_chords(
5147        &mut self,
5148        code: crossterm::event::KeyCode,
5149        modifiers: crossterm::event::KeyModifiers,
5150    ) {
5151        let Some(buffer) = self.focused_buffer() else {
5152            self.status = "No open buffer".into();
5153            return;
5154        };
5155        let path = buffer.path.clone();
5156        if code == crossterm::event::KeyCode::Tab
5157            && let Some(ghost) = self.editor_engine.ghost.take()
5158        {
5159            self.accept_ghost_text(&path, &ghost.text);
5160            return;
5161        }
5162        if matches!(
5163            code,
5164            crossterm::event::KeyCode::Right | crossterm::event::KeyCode::Char('f')
5165        ) && modifiers.contains(crossterm::event::KeyModifiers::CONTROL)
5166            && !modifiers.contains(crossterm::event::KeyModifiers::SHIFT)
5167            && self.editor_engine.ghost.is_some()
5168        {
5169            self.accept_ghost_word(&path);
5170            return;
5171        }
5172        let result = match (code, modifiers) {
5173            (crossterm::event::KeyCode::Char('a'), value)
5174                if value.contains(crossterm::event::KeyModifiers::ALT) =>
5175            {
5176                self.prepare_editor_agent_prompt();
5177                Ok(())
5178            }
5179            (crossterm::event::KeyCode::Char('s'), value)
5180                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5181            {
5182                self.locked(|workspace| workspace.project_mut().save_buffer(&path).map(|_| ()))
5183                    .unwrap_or_else(|| {
5184                        Err(crate::development::DevelopmentError::Conflict(
5185                            "workspace lock failed".into(),
5186                        ))
5187                    })
5188            }
5189            (crossterm::event::KeyCode::Char('z'), value)
5190                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5191            {
5192                self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()))
5193                    .unwrap_or_else(|| {
5194                        Err(crate::development::DevelopmentError::Conflict(
5195                            "workspace lock failed".into(),
5196                        ))
5197                    })
5198            }
5199            (crossterm::event::KeyCode::Char('y'), value)
5200                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5201            {
5202                self.locked(|workspace| workspace.project_mut().redo_buffer(&path).map(|_| ()))
5203                    .unwrap_or_else(|| {
5204                        Err(crate::development::DevelopmentError::Conflict(
5205                            "workspace lock failed".into(),
5206                        ))
5207                    })
5208            }
5209            (crossterm::event::KeyCode::Char('o'), value)
5210                if value.contains(crossterm::event::KeyModifiers::CONTROL) =>
5211            {
5212                self.open_symbol_picker();
5213                Ok(())
5214            }
5215            (crossterm::event::KeyCode::Left, value) => self.move_editor_cursor(
5216                &path,
5217                0,
5218                -1,
5219                value.contains(crossterm::event::KeyModifiers::SHIFT),
5220            ),
5221            (crossterm::event::KeyCode::Right, value) => self.move_editor_cursor(
5222                &path,
5223                0,
5224                1,
5225                value.contains(crossterm::event::KeyModifiers::SHIFT),
5226            ),
5227            (crossterm::event::KeyCode::Up, value) => self.move_editor_cursor(
5228                &path,
5229                -1,
5230                0,
5231                value.contains(crossterm::event::KeyModifiers::SHIFT),
5232            ),
5233            (crossterm::event::KeyCode::Down, value) => self.move_editor_cursor(
5234                &path,
5235                1,
5236                0,
5237                value.contains(crossterm::event::KeyModifiers::SHIFT),
5238            ),
5239            (crossterm::event::KeyCode::Enter, _) => self.insert_editor_text(&path, "\n"),
5240            (crossterm::event::KeyCode::Backspace, _) => self.backspace_editor(&path),
5241            (crossterm::event::KeyCode::Char(character), _)
5242                if self.editor_engine.mode == EditorMode::Insert =>
5243            {
5244                let result = self.insert_editor_text(&path, &character.to_string());
5245                self.request_ghost_from_line();
5246                result
5247            }
5248            _ => Ok(()),
5249        };
5250        if let Err(error) = result {
5251            self.status = format!("Editor action failed: {error}");
5252        }
5253        self.refresh_editor_projection();
5254    }
5255
5256    fn edit_normal_key(
5257        &mut self,
5258        code: crossterm::event::KeyCode,
5259        modifiers: crossterm::event::KeyModifiers,
5260    ) {
5261        let Some(buffer) = self.focused_buffer() else {
5262            self.status = "No open buffer".into();
5263            return;
5264        };
5265        let path = buffer.path.clone();
5266        let content = buffer.content.clone();
5267        let cursor = crate::development::TextPosition {
5268            line: buffer.cursor_line,
5269            column: buffer.cursor_column,
5270        };
5271        if let crossterm::event::KeyCode::Char(digit) = code
5272            && digit.is_ascii_digit()
5273            && !(digit == '0' && self.editor_engine.pending_count == 0)
5274        {
5275            self.editor_engine
5276                .push_digit(digit.to_digit(10).unwrap_or(0));
5277            return;
5278        }
5279        let count = self.editor_engine.count();
5280        if self.editor_engine.pending_find.is_some() {
5281            if let crossterm::event::KeyCode::Char(needle) = code {
5282                let jumping_mark = self.editor_engine.pending_find == Some('\'');
5283                self.editor_engine.pending_find = None;
5284                if jumping_mark {
5285                    if let Some(mark) = self.editor_engine.marks.get(&needle).cloned() {
5286                        self.editor_engine
5287                            .record_jump(&path, cursor.line, cursor.column);
5288                        if mark.path == path {
5289                            let _ = self.set_editor_cursor(
5290                                &path,
5291                                crate::development::TextPosition {
5292                                    line: mark.line,
5293                                    column: mark.column,
5294                                },
5295                                false,
5296                            );
5297                        } else {
5298                            self.status = format!("Mark '{needle}' is {}", mark.path);
5299                        }
5300                    } else {
5301                        self.status = format!("Mark '{needle}' is empty");
5302                    }
5303                } else {
5304                    let motion = Motion::Find {
5305                        needle,
5306                        till: self.editor_engine.pending_find_till,
5307                        reverse: self.editor_engine.pending_find_reverse,
5308                    };
5309                    if let Some(operator) = self.editor_engine.pending_operator.take() {
5310                        let _ = self.apply_operator(&path, &content, cursor, operator, motion);
5311                    } else {
5312                        let next = apply_motion(&content, cursor, motion);
5313                        let _ = self.set_editor_cursor(&path, next, false);
5314                    }
5315                }
5316                self.refresh_editor_projection();
5317            } else {
5318                self.editor_engine.clear_pending();
5319            }
5320            return;
5321        }
5322        if self.editor_engine.pending_mark {
5323            if let crossterm::event::KeyCode::Char(name) = code {
5324                self.editor_engine.marks.insert(
5325                    name,
5326                    native::Jump {
5327                        path: path.clone(),
5328                        line: cursor.line,
5329                        column: cursor.column,
5330                    },
5331                );
5332                self.status = format!("Mark '{name}' set");
5333            }
5334            self.editor_engine.pending_mark = false;
5335            return;
5336        }
5337        if let crossterm::event::KeyCode::Char(character) = code
5338            && let Some(around) = self.editor_engine.pending_around
5339        {
5340            if let Some(object) = textobject_from_key(character, around) {
5341                self.apply_textobject(&path, &content, cursor, object);
5342            } else {
5343                self.editor_engine.clear_pending();
5344                self.status = format!("Unknown textobject '{character}'");
5345            }
5346            return;
5347        }
5348        if self.editor_engine.pending_operator.is_some() {
5349            match code {
5350                crossterm::event::KeyCode::Char('i') => {
5351                    self.editor_engine.pending_around = Some(false);
5352                    self.status =
5353                        "inner textobject · w word · f fn · a arg · c comment · s string".into();
5354                    return;
5355                }
5356                crossterm::event::KeyCode::Char('a') => {
5357                    self.editor_engine.pending_around = Some(true);
5358                    self.status =
5359                        "around textobject · w word · f fn · a arg · c comment · s string".into();
5360                    return;
5361                }
5362                crossterm::event::KeyCode::Char('f') => {
5363                    self.apply_textobject(
5364                        &path,
5365                        &content,
5366                        cursor,
5367                        TextObject::Function { around: true },
5368                    );
5369                    return;
5370                }
5371                _ => {}
5372            }
5373        }
5374        let motion = match code {
5375            crossterm::event::KeyCode::Char('h') | crossterm::event::KeyCode::Left => {
5376                Some(Motion::Left)
5377            }
5378            crossterm::event::KeyCode::Char('l') | crossterm::event::KeyCode::Right => {
5379                Some(Motion::Right)
5380            }
5381            crossterm::event::KeyCode::Char('j') | crossterm::event::KeyCode::Down => {
5382                Some(Motion::Down)
5383            }
5384            crossterm::event::KeyCode::Char('k') | crossterm::event::KeyCode::Up => {
5385                Some(Motion::Up)
5386            }
5387            crossterm::event::KeyCode::Char('w') => Some(Motion::WordForward),
5388            crossterm::event::KeyCode::Char('b') => Some(Motion::WordBackward),
5389            crossterm::event::KeyCode::Char('e') => Some(Motion::WordEnd),
5390            crossterm::event::KeyCode::Char('0') => Some(Motion::LineStart),
5391            crossterm::event::KeyCode::Char('$') => Some(Motion::LineEnd),
5392            crossterm::event::KeyCode::Char('%') => Some(Motion::MatchPair),
5393            crossterm::event::KeyCode::Char('G') => Some(Motion::FileEnd),
5394            _ => None,
5395        };
5396        if code == crossterm::event::KeyCode::Char('g') {
5397            if self.editor_engine.pending_g {
5398                self.editor_engine.pending_g = false;
5399                self.apply_editor_motion(&path, &content, cursor, Motion::FileStart, false);
5400            } else {
5401                self.editor_engine.pending_g = true;
5402            }
5403            return;
5404        }
5405        if let Some(motion) = motion {
5406            if let Some(operator) = self.editor_engine.pending_operator.take() {
5407                let _ = self.apply_operator(&path, &content, cursor, operator, motion);
5408            } else {
5409                let mut position = cursor;
5410                for _ in 0..count {
5411                    position = apply_motion(&content, position, motion);
5412                }
5413                self.editor_engine.clear_pending();
5414                let extend = self.editor_engine.mode == EditorMode::Select
5415                    || modifiers.contains(crossterm::event::KeyModifiers::SHIFT);
5416                let _ = self.set_editor_cursor(&path, position, extend);
5417            }
5418            self.refresh_editor_projection();
5419            return;
5420        }
5421        match code {
5422            crossterm::event::KeyCode::Char('i') => self.editor_engine.enter_insert(),
5423            crossterm::event::KeyCode::Char('a') => {
5424                let next = apply_motion(&content, cursor, Motion::Right);
5425                let _ = self.set_editor_cursor(&path, next, false);
5426                self.editor_engine.enter_insert();
5427            }
5428            crossterm::event::KeyCode::Char('v') => self.editor_engine.enter_select(),
5429            crossterm::event::KeyCode::Char('W') => {
5430                self.apply_textobject(&path, &content, cursor, TextObject::Word { around: true });
5431            }
5432            crossterm::event::KeyCode::Char('d') if self.editor_engine.pending_g => {
5433                self.editor_engine.pending_g = false;
5434                self.editor_go_to_definition();
5435            }
5436            crossterm::event::KeyCode::Char('r') if self.editor_engine.pending_g => {
5437                self.editor_engine.pending_g = false;
5438                self.editor_references();
5439            }
5440            crossterm::event::KeyCode::Char('p') if self.editor_engine.pending_g => {
5441                self.editor_engine.pending_g = false;
5442                self.jump_page_from_source();
5443            }
5444            crossterm::event::KeyCode::Char('c') if self.editor_engine.pending_g => {
5445                self.editor_engine.pending_g = false;
5446                self.show_comment_thread();
5447            }
5448            crossterm::event::KeyCode::Char('m') if self.editor_engine.pending_g => {
5449                self.editor_engine.pending_g = false;
5450                self.match_same_objects(&path, &content, cursor, true);
5451            }
5452            crossterm::event::KeyCode::Char('n') if self.editor_engine.pending_g => {
5453                self.editor_engine.pending_g = false;
5454                self.match_same_objects(&path, &content, cursor, false);
5455            }
5456            crossterm::event::KeyCode::Char('d') => {
5457                self.editor_engine.pending_operator = Some(Operator::Delete);
5458            }
5459            crossterm::event::KeyCode::Char('c') => {
5460                self.editor_engine.pending_operator = Some(Operator::Change);
5461            }
5462            crossterm::event::KeyCode::Char('y')
5463                if !modifiers.contains(crossterm::event::KeyModifiers::CONTROL) =>
5464            {
5465                self.editor_engine.pending_operator = Some(Operator::Yank);
5466            }
5467            crossterm::event::KeyCode::Char('x') => {
5468                let _ =
5469                    self.apply_operator(&path, &content, cursor, Operator::Delete, Motion::Right);
5470            }
5471            crossterm::event::KeyCode::Char('u') => {
5472                let _ =
5473                    self.locked(|workspace| workspace.project_mut().undo_buffer(&path).map(|_| ()));
5474            }
5475            crossterm::event::KeyCode::Char('p') => {
5476                if !self.editor_engine.yank.is_empty() {
5477                    let _ = self.insert_editor_text(&path, &self.editor_engine.yank.clone());
5478                }
5479            }
5480            crossterm::event::KeyCode::Char('m') => {
5481                self.editor_engine.pending_mark = true;
5482                self.status = "Mark · next character names the mark".into();
5483            }
5484            crossterm::event::KeyCode::Char('\'') => {
5485                self.status = "Jump to mark · next character".into();
5486                self.editor_engine.pending_find = Some('\'');
5487            }
5488            crossterm::event::KeyCode::Char('K') => self.editor_hover(),
5489            crossterm::event::KeyCode::Char(']') => {
5490                if let Some(hunk) = self.editor_engine.step_hunk(1).cloned() {
5491                    let _ = self.set_editor_cursor(
5492                        &path,
5493                        crate::development::TextPosition {
5494                            line: hunk.start_line,
5495                            column: 1,
5496                        },
5497                        false,
5498                    );
5499                    self.status = format!(
5500                        "Hunk {}/{}",
5501                        self.editor_engine.hunk_index + 1,
5502                        self.editor_engine.hunks.len()
5503                    );
5504                }
5505            }
5506            crossterm::event::KeyCode::Char('[') => {
5507                if let Some(hunk) = self.editor_engine.step_hunk(-1).cloned() {
5508                    let _ = self.set_editor_cursor(
5509                        &path,
5510                        crate::development::TextPosition {
5511                            line: hunk.start_line,
5512                            column: 1,
5513                        },
5514                        false,
5515                    );
5516                }
5517            }
5518            crossterm::event::KeyCode::Enter => self.accept_current_hunk(),
5519            crossterm::event::KeyCode::Char('n') => self.reject_current_hunk(),
5520            crossterm::event::KeyCode::Char('o') => self.open_symbol_picker(),
5521            crossterm::event::KeyCode::Char('f') => {
5522                self.editor_engine.pending_find = Some('f');
5523                self.editor_engine.pending_find_till = false;
5524                self.editor_engine.pending_find_reverse = false;
5525                self.status = "find · next character".into();
5526            }
5527            crossterm::event::KeyCode::Char('t') => {
5528                self.editor_engine.pending_find = Some('t');
5529                self.editor_engine.pending_find_till = true;
5530                self.editor_engine.pending_find_reverse = false;
5531                self.status = "till · next character".into();
5532            }
5533            crossterm::event::KeyCode::Char('F') => {
5534                self.editor_engine.pending_find = Some('F');
5535                self.editor_engine.pending_find_till = false;
5536                self.editor_engine.pending_find_reverse = true;
5537                self.status = "find back · next character".into();
5538            }
5539            crossterm::event::KeyCode::Char('T') => {
5540                self.editor_engine.pending_find = Some('T');
5541                self.editor_engine.pending_find_till = true;
5542                self.editor_engine.pending_find_reverse = true;
5543                self.status = "till back · next character".into();
5544            }
5545            _ => {}
5546        }
5547        self.refresh_editor_projection();
5548    }
5549
5550    fn set_editor_cursor(
5551        &mut self,
5552        path: &str,
5553        position: crate::development::TextPosition,
5554        extend: bool,
5555    ) -> crate::development::DevelopmentResult<()> {
5556        let buffer = self
5557            .workspace
5558            .try_lock()?
5559            .project()
5560            .buffer(path)
5561            .cloned()
5562            .ok_or_else(|| {
5563                crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
5564            })?;
5565        let position = native::clamp_position(&buffer.content, position);
5566        let anchor = if extend {
5567            buffer
5568                .selection
5569                .map(|selection| selection.anchor)
5570                .unwrap_or(crate::development::TextPosition {
5571                    line: buffer.cursor_line,
5572                    column: buffer.cursor_column,
5573                })
5574        } else {
5575            position
5576        };
5577        let mut workspace = self.workspace.try_lock()?;
5578        workspace
5579            .project_mut()
5580            .set_buffer_cursor(path, position.line, position.column)?;
5581        workspace.project_mut().set_buffer_selection(
5582            path,
5583            extend.then_some(crate::development::TextSelection {
5584                anchor,
5585                active: position,
5586            }),
5587            crate::development::Actor::local(),
5588        )?;
5589        Ok(())
5590    }
5591
5592    fn apply_editor_motion(
5593        &mut self,
5594        path: &str,
5595        content: &str,
5596        cursor: crate::development::TextPosition,
5597        motion: Motion,
5598        extend: bool,
5599    ) {
5600        let next = apply_motion(content, cursor, motion);
5601        let _ = self.set_editor_cursor(path, next, extend);
5602    }
5603
5604    fn apply_textobject(
5605        &mut self,
5606        path: &str,
5607        content: &str,
5608        cursor: crate::development::TextPosition,
5609        object: TextObject,
5610    ) {
5611        let selection = self
5612            .syntax
5613            .textobject(path, content, cursor, object)
5614            .or_else(|| textobject_selection(content, cursor, object));
5615        let Some(selection) = selection else {
5616            self.editor_engine.clear_pending();
5617            self.status = "No textobject under cursor".into();
5618            return;
5619        };
5620        self.editor_engine.last_textobject = Some(object);
5621        if let Some(operator) = self.editor_engine.pending_operator.take() {
5622            let mut ranges = vec![selection];
5623            for extra in self.editor_engine.extra_selections.clone() {
5624                let origin = extra.active;
5625                if let Some(range) = self
5626                    .syntax
5627                    .textobject(path, content, origin, object)
5628                    .or_else(|| textobject_selection(content, origin, object))
5629                {
5630                    ranges.push(range);
5631                }
5632            }
5633            if let Err(error) = self.apply_operator_ranges(path, content, operator, ranges) {
5634                self.status = format!("Operator failed: {error}");
5635            }
5636        } else {
5637            self.editor_engine.enter_select();
5638            let _ = self.set_editor_cursor(path, selection.anchor, false);
5639            let _ = self.set_editor_cursor(path, selection.active, true);
5640            self.status = format!("{} · textobject selected", self.editor_engine.mode.label());
5641        }
5642        self.refresh_editor_projection();
5643    }
5644
5645    fn match_same_objects(
5646        &mut self,
5647        path: &str,
5648        content: &str,
5649        cursor: crate::development::TextPosition,
5650        all: bool,
5651    ) {
5652        let object = self
5653            .editor_engine
5654            .last_textobject
5655            .unwrap_or(TextObject::Word { around: false });
5656        let mut ranges = if matches!(object, TextObject::Word { .. }) {
5657            same_word_ranges(
5658                content,
5659                cursor,
5660                matches!(object, TextObject::Word { around: true }),
5661            )
5662        } else {
5663            let mut found = self.syntax.same_textobjects(path, content, cursor, object);
5664            if found.is_empty() {
5665                found = textobject_selection(content, cursor, object)
5666                    .into_iter()
5667                    .collect();
5668            }
5669            found
5670        };
5671        if ranges.is_empty() {
5672            self.status = "No matching objects under the caret".into();
5673            return;
5674        }
5675        ranges.sort_by_key(|selection| (selection.anchor.line, selection.anchor.column));
5676        let primary_index = ranges
5677            .iter()
5678            .position(|selection| selection_covers(content, selection, cursor))
5679            .unwrap_or(0);
5680        if all {
5681            let primary = ranges.remove(primary_index.min(ranges.len().saturating_sub(1)));
5682            self.editor_engine.extra_selections = ranges;
5683            let _ = self.set_editor_cursor(path, primary.anchor, false);
5684            let _ = self.set_editor_cursor(path, primary.active, true);
5685            self.editor_engine.last_textobject = Some(object);
5686            self.status = self.editor_normal_status();
5687        } else {
5688            let extras = &self.editor_engine.extra_selections;
5689            let next = ranges
5690                .iter()
5691                .cycle()
5692                .skip(primary_index + 1)
5693                .take(ranges.len().saturating_sub(1))
5694                .find(|candidate| {
5695                    !extras.iter().any(|existing| {
5696                        existing.anchor == candidate.anchor && existing.active == candidate.active
5697                    })
5698                })
5699                .cloned();
5700            if let Some(next) = next {
5701                self.editor_engine.extra_selections.push(next);
5702                self.editor_engine.last_textobject = Some(object);
5703                self.status = self.editor_normal_status();
5704            } else {
5705                self.status = "No further matching objects".into();
5706            }
5707        }
5708        self.refresh_editor_projection();
5709    }
5710
5711    fn apply_operator(
5712        &mut self,
5713        path: &str,
5714        content: &str,
5715        cursor: crate::development::TextPosition,
5716        operator: Operator,
5717        motion: Motion,
5718    ) -> crate::development::DevelopmentResult<()> {
5719        let mut ranges = vec![TextSelection {
5720            anchor: cursor,
5721            active: apply_motion(content, cursor, motion),
5722        }];
5723        for extra in &self.editor_engine.extra_selections {
5724            let origin = extra.active;
5725            ranges.push(TextSelection {
5726                anchor: origin,
5727                active: apply_motion(content, origin, motion),
5728            });
5729        }
5730        self.apply_operator_ranges(path, content, operator, ranges)
5731    }
5732
5733    fn apply_operator_ranges(
5734        &mut self,
5735        path: &str,
5736        content: &str,
5737        operator: Operator,
5738        ranges: Vec<TextSelection>,
5739    ) -> crate::development::DevelopmentResult<()> {
5740        let mut offsets = ranges
5741            .iter()
5742            .filter_map(|selection| {
5743                crate::development::editor::selection_offsets(content, selection)
5744            })
5745            .collect::<Vec<_>>();
5746        offsets.sort_by_key(|(start, _)| *start);
5747        offsets.dedup();
5748        if offsets.is_empty() {
5749            self.editor_engine.clear_pending();
5750            return Ok(());
5751        }
5752        self.auto_checkpoint("before-operator");
5753        match operator {
5754            Operator::Yank => {
5755                self.editor_engine.yank = offsets
5756                    .iter()
5757                    .map(|(start, stop)| content[*start..*stop].to_string())
5758                    .collect::<Vec<_>>()
5759                    .join("\n");
5760                self.status = format!("Yanked {} bytes", self.editor_engine.yank.len());
5761            }
5762            Operator::Delete | Operator::Change => {
5763                let (next, carets) = multi_delete(content, &offsets);
5764                let mut extras = Vec::new();
5765                let mut primary = crate::development::TextPosition { line: 1, column: 1 };
5766                for (index, offset) in carets.into_iter().enumerate() {
5767                    let position =
5768                        crate::development::editor::text_position_at_offset(&next, offset)
5769                            .unwrap_or(primary);
5770                    if index == 0 {
5771                        primary = position;
5772                    } else {
5773                        extras.push(TextSelection::collapsed(position));
5774                    }
5775                }
5776                let actor = crate::development::Actor::local();
5777                let mut workspace = self.workspace.try_lock()?;
5778                workspace
5779                    .project_mut()
5780                    .edit_buffer(path, next, actor.clone())?;
5781                workspace
5782                    .project_mut()
5783                    .set_buffer_cursor(path, primary.line, primary.column)?;
5784                workspace
5785                    .project_mut()
5786                    .set_buffer_selection(path, None, actor)?;
5787                drop(workspace);
5788                self.editor_engine.extra_selections = extras;
5789                if operator == Operator::Change {
5790                    self.editor_engine.enter_insert();
5791                }
5792            }
5793        }
5794        self.editor_engine.clear_pending();
5795        Ok(())
5796    }
5797
5798    fn maybe_begin_pair_apply(&mut self) {
5799        if self.editor_engine.pair_apply.is_some() {
5800            return;
5801        }
5802        let path = self.focused_editor_path.clone();
5803        if path.is_empty() {
5804            return;
5805        }
5806        let Some(proposal) = self
5807            .editor_proposals
5808            .iter()
5809            .find(|item| {
5810                item.path == path
5811                    && item.state == crate::development::EditorProposalState::Pending
5812                    && item.original == self.focused_editor_content
5813                    && item.original != item.proposed
5814            })
5815            .cloned()
5816        else {
5817            return;
5818        };
5819        self.editor_engine.begin_pair_apply(
5820            proposal.id,
5821            proposal.actor.name.clone(),
5822            proposal.path,
5823            proposal.original,
5824            proposal.proposed,
5825        );
5826        self.status = format!(
5827            "AGENT · {} pair-apply · Enter accept · n reject · type to yield",
5828            proposal.actor.name
5829        );
5830    }
5831
5832    pub fn tick_pair_apply(&mut self) -> bool {
5833        let Some(apply) = self.editor_engine.pair_apply.clone() else {
5834            return false;
5835        };
5836        if self.focused_editor_content == apply.proposed {
5837            return false;
5838        }
5839        let (content, revealed, _done) =
5840            pair_apply_step(&apply.original, &apply.proposed, apply.revealed, 24);
5841        let path = apply.path.clone();
5842        let actor = apply.actor.clone();
5843        let _ = self.locked(|workspace| {
5844            workspace
5845                .project_mut()
5846                .edit_buffer(
5847                    &path,
5848                    content.clone(),
5849                    crate::development::Actor::embedded(),
5850                )
5851                .map(|_| ())
5852        });
5853        if let Some(live) = self.editor_engine.pair_apply.as_mut() {
5854            live.revealed = revealed;
5855        }
5856        self.focused_editor_content = content.clone();
5857        self.focused_editor_dirty = true;
5858        let caret_offset = pair_apply_caret(&apply.original, &apply.proposed, revealed);
5859        if let Some(position) =
5860            crate::development::editor::text_position_at_offset(&content, caret_offset)
5861        {
5862            self.focused_editor_line = position.line;
5863            self.focused_editor_column = position.column;
5864            self.editor_engine.agent_caret = Some(native::Jump {
5865                path,
5866                line: position.line,
5867                column: position.column,
5868            });
5869            let _ = self.set_editor_cursor(&self.focused_editor_path.clone(), position, false);
5870        }
5871        self.editor_engine.mode = EditorMode::Agent;
5872        self.status = format!("AGENT · {actor} pair-apply · Enter accept · n reject");
5873        self.ensure_editor_cursor_visible();
5874        true
5875    }
5876
5877    pub fn editor_gutter_marks(&self) -> Vec<(u32, native::GutterMark)> {
5878        let mut marks = Vec::new();
5879        let path = &self.focused_editor_path;
5880        for diagnostic in &self.editor_diagnostics {
5881            if diagnostic_matches_path(diagnostic, path) {
5882                marks.push((
5883                    diagnostic.start.line.saturating_add(1),
5884                    native::GutterMark::Lsp,
5885                ));
5886            }
5887        }
5888        let page_lines = self.page_source_lines(path);
5889        match self.last_proof_ok {
5890            Some(true) => {
5891                for line in &page_lines {
5892                    marks.push((*line, native::GutterMark::Proof));
5893                }
5894            }
5895            Some(false) => {
5896                for line in &page_lines {
5897                    marks.push((*line, native::GutterMark::Lsp));
5898                }
5899            }
5900            None => {}
5901        }
5902        for hunk in &self.editor_engine.hunks {
5903            marks.push((hunk.start_line, native::GutterMark::Git));
5904        }
5905        if let Some(caret) = &self.editor_engine.agent_caret
5906            && caret.path == *path
5907        {
5908            marks.push((caret.line, native::GutterMark::Agent));
5909        }
5910        for line in page_lines {
5911            marks.push((line, native::GutterMark::Page));
5912        }
5913        for comment in &self.editor_comments {
5914            if comment.state == crate::development::EditorCommentState::Open
5915                && (path.is_empty() || comment.path == *path)
5916            {
5917                marks.push((comment.start_line, native::GutterMark::Comment));
5918            }
5919        }
5920        marks
5921    }
5922
5923    pub fn editor_source_notes(&self) -> Vec<(u32, String)> {
5924        let mut by_line = std::collections::BTreeMap::<u32, Vec<String>>::new();
5925        for (line, hint) in &self.editor_inlays {
5926            by_line.entry(*line).or_default().push(hint.clone());
5927        }
5928        let path = &self.focused_editor_path;
5929        for diagnostic in &self.editor_diagnostics {
5930            if diagnostic_matches_path(diagnostic, path) {
5931                by_line
5932                    .entry(diagnostic.start.line.saturating_add(1))
5933                    .or_default()
5934                    .push(format!("! {}", truncate_note(&diagnostic.message)));
5935            }
5936        }
5937        for comment in &self.editor_comments {
5938            if comment.state == crate::development::EditorCommentState::Open
5939                && (path.is_empty() || comment.path == *path)
5940            {
5941                by_line
5942                    .entry(comment.start_line)
5943                    .or_default()
5944                    .push(format!("# {}", truncate_note(&comment.text)));
5945            }
5946        }
5947        by_line
5948            .into_iter()
5949            .map(|(line, parts)| (line, parts.join("  ")))
5950            .collect()
5951    }
5952
5953    fn page_source_lines(&self, path: &str) -> Vec<u32> {
5954        self.workspace
5955            .try_lock()
5956            .ok()
5957            .map(|workspace| {
5958                workspace
5959                    .project()
5960                    .graph()
5961                    .entities_for_source(path, None)
5962                    .into_iter()
5963                    .map(|link| link.source.start_line)
5964                    .collect()
5965            })
5966            .unwrap_or_default()
5967    }
5968
5969    fn show_comment_thread(&mut self) {
5970        let path = self.focused_editor_path.clone();
5971        let line = self.focused_editor_line.max(1);
5972        let thread = self
5973            .editor_comments
5974            .iter()
5975            .filter(|comment| {
5976                comment.state == crate::development::EditorCommentState::Open
5977                    && (path.is_empty() || comment.path == path)
5978                    && line >= comment.start_line
5979                    && line <= comment.end_line
5980            })
5981            .map(|comment| {
5982                format!(
5983                    "{} · {}:{}\n  {}",
5984                    comment.actor.name, comment.path, comment.start_line, comment.text
5985                )
5986            })
5987            .collect::<Vec<_>>();
5988        if thread.is_empty() {
5989            self.status = "No open comment on this line · :editor comment-selection".into();
5990            return;
5991        }
5992        self.editor_engine.overlay = Some(thread.join("\n\n"));
5993        self.status = "Comment thread · Esc closes".into();
5994    }
5995
5996    fn refresh_editor_hunks(&mut self) {
5997        let path = self.focused_editor_path.clone();
5998        if path.is_empty() {
5999            return;
6000        }
6001        let proposal = self.editor_proposals.iter().find(|item| item.path == path);
6002        if let Some(proposal) = proposal {
6003            self.editor_engine
6004                .set_hunks(line_hunks(&proposal.original, &proposal.proposed));
6005        }
6006    }
6007
6008    fn auto_checkpoint(&mut self, name: &str) {
6009        let _ = self.locked(|workspace| {
6010            workspace
6011                .project_mut()
6012                .create_editor_checkpoint(name.to_string(), crate::development::Actor::local())
6013                .map(|_| ())
6014        });
6015    }
6016
6017    fn editor_hover(&mut self) {
6018        let path = self.focused_editor_path.clone();
6019        let line = self.focused_editor_line.saturating_sub(1);
6020        let character = self.focused_editor_column.saturating_sub(1);
6021        match self.locked(|workspace| {
6022            let server = workspace
6023                .language()
6024                .names()
6025                .next()
6026                .ok_or_else(|| {
6027                    crate::development::DevelopmentError::NotFound("language server".into())
6028                })?
6029                .to_string();
6030            workspace
6031                .language()
6032                .hover(&server, "local", &path, line, character)
6033        }) {
6034            Some(Ok(response)) => {
6035                self.editor_engine.overlay = Some(response.result.to_string());
6036                self.status = "Hover · Esc closes".into();
6037            }
6038            Some(Err(error)) => self.status = format!("Hover unavailable: {error}"),
6039            None => self.status = "Hover unavailable · workspace busy".into(),
6040        }
6041    }
6042
6043    fn editor_references(&mut self) {
6044        let path = self.focused_editor_path.clone();
6045        let line = self.focused_editor_line.saturating_sub(1);
6046        let character = self.focused_editor_column.saturating_sub(1);
6047        match self.locked(|workspace| {
6048            let server = workspace
6049                .language()
6050                .names()
6051                .next()
6052                .ok_or_else(|| {
6053                    crate::development::DevelopmentError::NotFound("language server".into())
6054                })?
6055                .to_string();
6056            workspace
6057                .language()
6058                .references(&server, "local", &path, line, character)
6059        }) {
6060            Some(Ok(response)) => {
6061                self.editor_engine.overlay = Some(format_lsp_locations(&response.result));
6062                self.status = "References · Esc closes".into();
6063            }
6064            Some(Err(error)) => self.status = format!("References unavailable: {error}"),
6065            None => self.status = "References unavailable · workspace busy".into(),
6066        }
6067    }
6068
6069    fn editor_go_to_definition(&mut self) {
6070        let path = self.focused_editor_path.clone();
6071        let line = self.focused_editor_line.saturating_sub(1);
6072        let character = self.focused_editor_column.saturating_sub(1);
6073        self.editor_engine
6074            .record_jump(&path, self.focused_editor_line, self.focused_editor_column);
6075        match self.locked(|workspace| {
6076            let server = workspace
6077                .language()
6078                .names()
6079                .next()
6080                .ok_or_else(|| {
6081                    crate::development::DevelopmentError::NotFound("language server".into())
6082                })?
6083                .to_string();
6084            workspace
6085                .language()
6086                .definition(&server, "local", &path, line, character)
6087        }) {
6088            Some(Ok(response)) => {
6089                self.editor_engine.overlay = Some(format!("definition {}", response.result));
6090                if let Some(target) = parse_lsp_location(&response.result) {
6091                    let _ = self.open_path(&target.path);
6092                    let _ = self.set_editor_cursor(
6093                        &self.focused_editor_path.clone(),
6094                        crate::development::TextPosition {
6095                            line: target.line.max(1),
6096                            column: target.column.max(1),
6097                        },
6098                        false,
6099                    );
6100                }
6101                self.status = "Definition · Ctrl-O symbols · Enter jump".into();
6102            }
6103            Some(Err(error)) => self.status = format!("Definition unavailable: {error}"),
6104            None => self.status = "Definition unavailable · workspace busy".into(),
6105        }
6106    }
6107
6108    fn open_symbol_picker(&mut self) {
6109        let path = self.focused_editor_path.clone();
6110        match self.locked(|workspace| {
6111            let server = workspace
6112                .language()
6113                .names()
6114                .next()
6115                .ok_or_else(|| {
6116                    crate::development::DevelopmentError::NotFound("language server".into())
6117                })?
6118                .to_string();
6119            workspace
6120                .language()
6121                .document_symbols(&server, "local", &path)
6122        }) {
6123            Some(Ok(response)) => {
6124                self.editor_engine.symbols = parse_lsp_symbols(&response.result);
6125                self.editor_engine.symbol_selection = 0;
6126                self.status = format!(
6127                    "Symbols · {} · Enter jumps",
6128                    self.editor_engine.symbols.len()
6129                );
6130            }
6131            _ => {
6132                self.editor_engine.symbols = self
6133                    .focused_editor_content
6134                    .lines()
6135                    .enumerate()
6136                    .filter(|(_, line)| {
6137                        let trimmed = line.trim_start();
6138                        trimmed.starts_with("fn ")
6139                            || trimmed.starts_with("struct ")
6140                            || trimmed.starts_with("impl ")
6141                            || trimmed.starts_with("pub ")
6142                    })
6143                    .map(|(index, line)| (line.trim().to_string(), index as u32 + 1))
6144                    .collect();
6145                self.status = format!("Symbols (lexical) · {}", self.editor_engine.symbols.len());
6146            }
6147        }
6148    }
6149
6150    fn accept_current_hunk(&mut self) {
6151        let path = self.focused_editor_path.clone();
6152        let Some(proposal) = self
6153            .editor_proposals
6154            .iter()
6155            .find(|item| item.path == path)
6156            .cloned()
6157        else {
6158            self.status = "No proposal hunk on this buffer".into();
6159            return;
6160        };
6161        self.auto_checkpoint("before-hunk-accept");
6162        match self.locked(|workspace| {
6163            workspace
6164                .project_mut()
6165                .accept_editor_proposal(&proposal.id, crate::development::Actor::local())
6166                .map(|_| ())
6167        }) {
6168            Some(Ok(())) => {
6169                self.status = format!("Accepted proposal {}", proposal.id);
6170                self.refresh_editor_hunks();
6171            }
6172            Some(Err(error)) => self.status = format!("Accept failed: {error}"),
6173            None => self.status = "Accept failed · workspace busy".into(),
6174        }
6175    }
6176
6177    fn reject_current_hunk(&mut self) {
6178        let path = self.focused_editor_path.clone();
6179        let Some(proposal) = self
6180            .editor_proposals
6181            .iter()
6182            .find(|item| item.path == path)
6183            .cloned()
6184        else {
6185            return;
6186        };
6187        let _ = self.locked(|workspace| {
6188            workspace
6189                .project_mut()
6190                .reject_editor_proposal(&proposal.id, crate::development::Actor::local())
6191                .map(|_| ())
6192        });
6193        self.status = format!("Rejected proposal {}", proposal.id);
6194        self.refresh_editor_hunks();
6195    }
6196
6197    pub fn jump_page_from_source(&mut self) {
6198        let path = self.focused_editor_path.clone();
6199        if path.is_empty() {
6200            self.status = "Open a buffer, then gp jumps to App".into();
6201            return;
6202        }
6203        let line = self.focused_editor_line.max(1);
6204        let entity = self
6205            .locked(|workspace| {
6206                let _ = workspace.project_mut().discover_runtime_links();
6207                workspace
6208                    .project()
6209                    .graph()
6210                    .entities_for_source(&path, Some(line))
6211                    .first()
6212                    .map(|link| link.entity_id.clone())
6213            })
6214            .flatten();
6215        if let Some(entity) = entity.clone() {
6216            self.pending_page_entity = Some(entity.clone());
6217            if self.select_page_entity(&entity) {
6218                self.surface = DevSurface::App;
6219                self.code_edit_mode = false;
6220                self.status = format!("Page bound · entity {entity}");
6221            }
6222        }
6223        let route = inferred_app_path(&path);
6224        let Some(base) = self.resolved_app_url() else {
6225            if entity.is_none() {
6226                self.status = "No App URL · start the detected suite, then gp".into();
6227            }
6228            return;
6229        };
6230        let url = join_app_url(&base, route.as_deref());
6231        let current = self.browser_workspace.state().url.clone();
6232        let current_origin = current.trim_end_matches('/');
6233        if entity.is_some()
6234            && !current.is_empty()
6235            && (current == url || current.starts_with(&url) || url.starts_with(current_origin))
6236        {
6237            self.surface = DevSurface::App;
6238            self.code_edit_mode = false;
6239            return;
6240        }
6241        self.auto_checkpoint("before-app-jump");
6242        match self.prepare_browser_navigation(&url) {
6243            Ok(message) => {
6244                self.status = if entity.is_some() {
6245                    format!("{message} · will bind page entity")
6246                } else {
6247                    message
6248                };
6249            }
6250            Err(error) => self.status = error,
6251        }
6252    }
6253
6254    pub fn jump_source_from_page(&mut self) {
6255        let Some(entity) = self.browser_workspace.state().selected().cloned() else {
6256            self.status = "Select an App entity, then g jumps to source".into();
6257            return;
6258        };
6259        let reference = entity.reference.clone();
6260        let name = entity.name.clone();
6261        let link = self
6262            .locked(|workspace| {
6263                let _ = workspace.project_mut().discover_runtime_links();
6264                let graph = workspace.project().graph();
6265                graph
6266                    .best_link(&reference)
6267                    .cloned()
6268                    .or_else(|| graph.best_link(&name).cloned())
6269                    .or_else(|| {
6270                        graph
6271                            .links
6272                            .values()
6273                            .flatten()
6274                            .find(|link| {
6275                                reference.ends_with(&link.entity_id)
6276                                    || name.contains(&link.entity_id)
6277                            })
6278                            .cloned()
6279                    })
6280            })
6281            .flatten();
6282        let Some(link) = link else {
6283            self.status = format!("No source link for {reference} · :project graph discover");
6284            return;
6285        };
6286        self.open_source_at(&link.source.path, link.source.start_line);
6287    }
6288
6289    pub fn attach_detected_app(&mut self) -> Result<String, String> {
6290        let url = self
6291            .resolved_app_url()
6292            .ok_or_else(|| "No App URL · start the detected suite".to_string())?;
6293        self.auto_checkpoint("before-app-attach");
6294        self.prepare_browser_navigation(&url)
6295    }
6296
6297    pub fn resolved_app_url(&self) -> Option<String> {
6298        self.process_urls
6299            .iter()
6300            .find(|url| !url.is_empty())
6301            .cloned()
6302            .or_else(|| {
6303                self.workspace.try_lock().ok().and_then(|workspace| {
6304                    let detection = workspace.project().detection();
6305                    detection.browser_url.clone().or_else(|| {
6306                        detection
6307                            .local_development_urls
6308                            .iter()
6309                            .find(|url| !url.is_empty())
6310                            .cloned()
6311                    })
6312                })
6313            })
6314            .map(|url| join_app_url(&url, None))
6315    }
6316
6317    fn select_page_entity(&mut self, entity_id: &str) -> bool {
6318        let index = self
6319            .browser_workspace
6320            .state()
6321            .entities
6322            .iter()
6323            .position(|entity| {
6324                entity.reference == entity_id
6325                    || entity.reference.ends_with(entity_id)
6326                    || entity.name == entity_id
6327                    || (!entity_id.is_empty() && entity.name.contains(entity_id))
6328            });
6329        let Some(index) = index else {
6330            return false;
6331        };
6332        self.browser_workspace.state_mut().selected_entity = Some(index);
6333        self.browser = self.browser_workspace_summary();
6334        true
6335    }
6336
6337    fn open_source_at(&mut self, path: &str, line: u32) {
6338        match self.open_path(path) {
6339            Ok(_) => {
6340                let focused = self.focused_editor_path.clone();
6341                let _ = self.set_editor_cursor(
6342                    &focused,
6343                    crate::development::TextPosition {
6344                        line: line.max(1),
6345                        column: 1,
6346                    },
6347                    false,
6348                );
6349                self.refresh_editor_projection();
6350                self.ensure_editor_cursor_visible();
6351                self.status = format!("Source · {path}:{line}");
6352            }
6353            Err(error) => self.status = format!("Source jump failed: {error}"),
6354        }
6355    }
6356
6357    fn accept_ghost_text(&mut self, path: &str, text: &str) {
6358        let _ = self.insert_editor_text(path, text);
6359        self.refresh_editor_projection();
6360        self.advance_next_edit();
6361    }
6362
6363    fn accept_ghost_word(&mut self, path: &str) {
6364        let Some(ghost) = self.editor_engine.ghost.take() else {
6365            return;
6366        };
6367        match split_ghost_word(&ghost.text) {
6368            Some((word, rest)) if !rest.is_empty() => {
6369                let _ = self.insert_editor_text(path, word);
6370                self.refresh_editor_projection();
6371                self.editor_engine.ghost = Some(GhostText {
6372                    text: rest.to_string(),
6373                });
6374                self.status = "Ghost word accepted · Tab rest · Ctrl-Right another word".into();
6375            }
6376            Some((word, _)) => self.accept_ghost_text(path, word),
6377            None => self.accept_ghost_text(path, &ghost.text),
6378        }
6379    }
6380
6381    fn advance_next_edit(&mut self) {
6382        let content = self.focused_editor_content.clone();
6383        let caret = crate::development::editor::text_position_offset(
6384            &content,
6385            crate::development::TextPosition {
6386                line: self.focused_editor_line.max(1),
6387                column: self.focused_editor_column.max(1),
6388            },
6389        )
6390        .unwrap_or(content.len());
6391        let Some(offset) = next_edit_after_accept(&content, caret) else {
6392            self.request_ghost_from_line();
6393            self.status = if self.editor_engine.ghost.is_some() {
6394                "Ghost accepted · next edit here".into()
6395            } else {
6396                "Ghost accepted".into()
6397            };
6398            return;
6399        };
6400        let Some(position) = crate::development::editor::text_position_at_offset(&content, offset)
6401        else {
6402            self.request_ghost_from_line();
6403            self.status = "Ghost accepted".into();
6404            return;
6405        };
6406        let path = self.focused_editor_path.clone();
6407        self.editor_engine
6408            .record_jump(&path, position.line, position.column);
6409        let _ = self.set_editor_cursor(&path, position, false);
6410        self.refresh_editor_projection();
6411        self.request_ghost_from_line();
6412        self.status = format!(
6413            "Ghost accepted · next edit {}:{}",
6414            position.line, position.column
6415        );
6416    }
6417
6418    pub fn request_ghost_from_line(&mut self) {
6419        let path = self.focused_editor_path.clone();
6420        let Some(offset) = crate::development::editor::text_position_offset(
6421            &self.focused_editor_content,
6422            crate::development::TextPosition {
6423                line: self.focused_editor_line.max(1),
6424                column: self.focused_editor_column.max(1),
6425            },
6426        ) else {
6427            return;
6428        };
6429        if let Some(text) = local_fim(&self.focused_editor_content, offset) {
6430            self.editor_engine.ghost = Some(GhostText { text });
6431            return;
6432        }
6433        if self.take_ready_fim(&path, offset) {
6434            return;
6435        }
6436        self.spawn_hosted_fim(&path, offset);
6437        let line = self.focused_editor_line.saturating_sub(1);
6438        let character = self.focused_editor_column.saturating_sub(1);
6439        if let Some(text) = self.lsp_ghost_insert(&path, line, character) {
6440            self.editor_engine.ghost = Some(GhostText { text });
6441            return;
6442        }
6443        let line = self
6444            .focused_editor_content
6445            .lines()
6446            .nth(self.focused_editor_line.saturating_sub(1) as usize)
6447            .unwrap_or("")
6448            .trim()
6449            .to_string();
6450        if line.is_empty() {
6451            return;
6452        }
6453        let ghost = if line.ends_with('{') {
6454            "\n    \n}"
6455        } else if line.contains("todo") || line.contains("TODO") {
6456            " // implemented"
6457        } else {
6458            return;
6459        };
6460        self.editor_engine.ghost = Some(GhostText { text: ghost.into() });
6461    }
6462
6463    pub fn tick_fim(&mut self) -> bool {
6464        let path = self.focused_editor_path.clone();
6465        let Some(offset) = crate::development::editor::text_position_offset(
6466            &self.focused_editor_content,
6467            crate::development::TextPosition {
6468                line: self.focused_editor_line.max(1),
6469                column: self.focused_editor_column.max(1),
6470            },
6471        ) else {
6472            return false;
6473        };
6474        self.take_ready_fim(&path, offset)
6475    }
6476
6477    fn take_ready_fim(&mut self, path: &str, offset: usize) -> bool {
6478        let stale = self
6479            .pending_fim
6480            .as_ref()
6481            .is_some_and(|pending| pending.path() != path || pending.offset() != offset);
6482        if stale {
6483            self.pending_fim = None;
6484            return false;
6485        }
6486        let pi = match &self.pending_fim {
6487            Some(PendingFim::Pi {
6488                agent_id, since, ..
6489            }) => Some((agent_id.clone(), *since)),
6490            _ => None,
6491        };
6492        if let Some((agent_id, since)) = pi {
6493            let text = self
6494                .locked(|workspace| {
6495                    workspace
6496                        .agents()
6497                        .history(since)
6498                        .ok()?
6499                        .into_iter()
6500                        .rev()
6501                        .find_map(|event| {
6502                            if event.agent_id != agent_id {
6503                                return None;
6504                            }
6505                            if event
6506                                .payload
6507                                .get("operation")
6508                                .and_then(serde_json::Value::as_str)
6509                                != Some("complete")
6510                            {
6511                                return None;
6512                            }
6513                            crate::fim::parse_fim_text(&event.payload)
6514                        })
6515                })
6516                .flatten();
6517            return match text {
6518                Some(text) => {
6519                    self.pending_fim = None;
6520                    self.editor_engine.ghost = Some(GhostText { text });
6521                    true
6522                }
6523                None => false,
6524            };
6525        }
6526        let Some(PendingFim::Thread { rx, .. }) = self.pending_fim.as_mut() else {
6527            return false;
6528        };
6529        match rx.try_recv() {
6530            Ok(Some(text)) if !text.is_empty() => {
6531                self.pending_fim = None;
6532                self.editor_engine.ghost = Some(GhostText { text });
6533                true
6534            }
6535            Ok(_) | Err(std::sync::mpsc::TryRecvError::Disconnected) => {
6536                self.pending_fim = None;
6537                false
6538            }
6539            Err(std::sync::mpsc::TryRecvError::Empty) => false,
6540        }
6541    }
6542
6543    fn spawn_hosted_fim(&mut self, path: &str, offset: usize) {
6544        if self
6545            .pending_fim
6546            .as_ref()
6547            .is_some_and(|pending| pending.path() == path && pending.offset() == offset)
6548        {
6549            return;
6550        }
6551        let Some(provider) = self.workspace.try_lock().ok().and_then(|workspace| {
6552            crate::fim::FimProvider::from_editor(&workspace.customization().config().editor)
6553        }) else {
6554            return;
6555        };
6556        let prefix = self.focused_editor_content[..offset].to_string();
6557        let suffix = self.focused_editor_content[offset..].to_string();
6558        match provider.backend {
6559            crate::fim::FimBackend::Stub => {
6560                let (tx, rx) = std::sync::mpsc::channel();
6561                let _ = std::thread::Builder::new()
6562                    .name("glass-fim".into())
6563                    .spawn(move || {
6564                        let _ = tx.send(provider.complete(&prefix, &suffix).ok());
6565                    });
6566                self.pending_fim = Some(PendingFim::Thread {
6567                    path: path.to_string(),
6568                    offset,
6569                    rx,
6570                });
6571            }
6572            crate::fim::FimBackend::Pi => {
6573                let selected = self.selected_agent.clone();
6574                let queued = self
6575                    .locked(|workspace| {
6576                        let since = workspace
6577                            .agents()
6578                            .history(0)
6579                            .ok()?
6580                            .last()
6581                            .map(|event| event.sequence)
6582                            .unwrap_or(0);
6583                        let snapshots = workspace.agents().list().ok()?;
6584                        let id = selected
6585                            .as_ref()
6586                            .filter(|id| {
6587                                snapshots.iter().any(|item| {
6588                                    &item.id == *id && item.status == crate::AgentStatus::Idle
6589                                })
6590                            })
6591                            .cloned()
6592                            .or_else(|| {
6593                                snapshots.into_iter().find_map(|item| {
6594                                    (item.status == crate::AgentStatus::Idle).then_some(item.id)
6595                                })
6596                            })?;
6597                        workspace
6598                            .agents()
6599                            .request(
6600                                &id,
6601                                crate::pi_runtime::PiSessionRequest::Complete { prefix, suffix },
6602                            )
6603                            .ok()?;
6604                        Some((id, since))
6605                    })
6606                    .flatten();
6607                if let Some((agent_id, since)) = queued {
6608                    self.pending_fim = Some(PendingFim::Pi {
6609                        path: path.to_string(),
6610                        offset,
6611                        agent_id,
6612                        since,
6613                    });
6614                }
6615            }
6616        }
6617    }
6618
6619    fn lsp_ghost_insert(&mut self, path: &str, line: u32, character: u32) -> Option<String> {
6620        let response = self.locked(|workspace| {
6621            let server = workspace
6622                .language()
6623                .names()
6624                .next()
6625                .ok_or_else(|| {
6626                    crate::development::DevelopmentError::NotFound("language server".into())
6627                })?
6628                .to_string();
6629            workspace
6630                .language()
6631                .completion(&server, "local", path, line, character)
6632        })?;
6633        parse_completion_insert(&response.ok()?.result)
6634    }
6635
6636    fn move_editor_cursor(
6637        &mut self,
6638        path: &str,
6639        line_delta: i32,
6640        column_delta: i32,
6641        extend_selection: bool,
6642    ) -> crate::development::DevelopmentResult<()> {
6643        let buffer = self
6644            .workspace
6645            .try_lock()?
6646            .project()
6647            .buffer(path)
6648            .cloned()
6649            .ok_or_else(|| {
6650                crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
6651            })?;
6652        let lines = buffer.content.split('\n').collect::<Vec<_>>();
6653        let line =
6654            (buffer.cursor_line as i32 + line_delta).clamp(1, lines.len().max(1) as i32) as u32;
6655        let max_column = lines
6656            .get(line.saturating_sub(1) as usize)
6657            .map(|line| line.chars().count() + 1)
6658            .unwrap_or(1) as u32;
6659        let column = if line_delta != 0 {
6660            buffer.cursor_column.min(max_column)
6661        } else {
6662            (buffer.cursor_column as i32 + column_delta).clamp(1, max_column as i32) as u32
6663        };
6664        let anchor = if extend_selection {
6665            buffer
6666                .selection
6667                .map(|selection| selection.anchor)
6668                .unwrap_or(crate::development::TextPosition {
6669                    line: buffer.cursor_line,
6670                    column: buffer.cursor_column,
6671                })
6672        } else {
6673            crate::development::TextPosition { line, column }
6674        };
6675        let mut workspace = self.workspace.try_lock()?;
6676        workspace
6677            .project_mut()
6678            .set_buffer_cursor(path, line, column)?;
6679        workspace.project_mut().set_buffer_selection(
6680            path,
6681            extend_selection.then_some(crate::development::TextSelection {
6682                anchor,
6683                active: crate::development::TextPosition { line, column },
6684            }),
6685            crate::development::Actor::local(),
6686        )?;
6687        Ok(())
6688    }
6689
6690    fn insert_editor_text(
6691        &mut self,
6692        path: &str,
6693        text: &str,
6694    ) -> crate::development::DevelopmentResult<()> {
6695        let extras = self.editor_engine.extra_selections.clone();
6696        let mut workspace = self.workspace.try_lock()?;
6697        let project = workspace.project_mut();
6698        let buffer = project.buffer(path).cloned().ok_or_else(|| {
6699            crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
6700        })?;
6701        if buffer
6702            .selection
6703            .as_ref()
6704            .is_some_and(|selection| !selection.is_empty())
6705            && extras.is_empty()
6706        {
6707            project.replace_buffer_selection(
6708                path,
6709                text.to_string(),
6710                crate::development::Actor::local(),
6711            )?;
6712            return Ok(());
6713        }
6714        let primary = editor_offset(&buffer.content, buffer.cursor_line, buffer.cursor_column);
6715        if extras.is_empty() {
6716            let mut content = buffer.content;
6717            content.insert_str(primary, text);
6718            let cursor =
6719                crate::development::editor::text_position_at_offset(&content, primary + text.len())
6720                    .ok_or_else(|| {
6721                        crate::development::DevelopmentError::InvalidInput(
6722                            "inserted text ended at an invalid UTF-8 boundary".into(),
6723                        )
6724                    })?;
6725            let actor = crate::development::Actor::local();
6726            project.edit_buffer(path, content, actor.clone())?;
6727            project.set_buffer_cursor(path, cursor.line, cursor.column)?;
6728            project.set_buffer_selection(path, None, actor)?;
6729            return Ok(());
6730        }
6731        let mut sites = vec![primary];
6732        for extra in &extras {
6733            if let Some(offset) =
6734                crate::development::editor::text_position_offset(&buffer.content, extra.active)
6735            {
6736                sites.push(offset);
6737            }
6738        }
6739        let (content, carets) = multi_insert(&buffer.content, &sites, text);
6740        let mut next_extras = Vec::new();
6741        let mut primary_pos = crate::development::TextPosition { line: 1, column: 1 };
6742        for (index, offset) in carets.into_iter().enumerate() {
6743            let position = crate::development::editor::text_position_at_offset(&content, offset)
6744                .ok_or_else(|| {
6745                    crate::development::DevelopmentError::InvalidInput(
6746                        "inserted text ended at an invalid UTF-8 boundary".into(),
6747                    )
6748                })?;
6749            if index == 0 {
6750                primary_pos = position;
6751            } else {
6752                next_extras.push(TextSelection::collapsed(position));
6753            }
6754        }
6755        let actor = crate::development::Actor::local();
6756        project.edit_buffer(path, content, actor.clone())?;
6757        project.set_buffer_cursor(path, primary_pos.line, primary_pos.column)?;
6758        project.set_buffer_selection(path, None, actor)?;
6759        drop(workspace);
6760        self.editor_engine.extra_selections = next_extras;
6761        Ok(())
6762    }
6763
6764    fn backspace_editor(&mut self, path: &str) -> crate::development::DevelopmentResult<()> {
6765        let extras = self.editor_engine.extra_selections.clone();
6766        let mut workspace = self.workspace.try_lock()?;
6767        let project = workspace.project_mut();
6768        let buffer = project.buffer(path).cloned().ok_or_else(|| {
6769            crate::development::DevelopmentError::NotFound(format!("buffer {path}"))
6770        })?;
6771        if buffer
6772            .selection
6773            .as_ref()
6774            .is_some_and(|selection| !selection.is_empty())
6775            && extras.is_empty()
6776        {
6777            project.replace_buffer_selection(
6778                path,
6779                String::new(),
6780                crate::development::Actor::local(),
6781            )?;
6782            return Ok(());
6783        }
6784        let mut sites = vec![editor_offset(
6785            &buffer.content,
6786            buffer.cursor_line,
6787            buffer.cursor_column,
6788        )];
6789        for extra in &extras {
6790            if let Some(offset) =
6791                crate::development::editor::text_position_offset(&buffer.content, extra.active)
6792            {
6793                sites.push(offset);
6794            }
6795        }
6796        let mut ranges = Vec::new();
6797        for offset in sites {
6798            if offset == 0 {
6799                continue;
6800            }
6801            let previous = buffer.content[..offset]
6802                .char_indices()
6803                .next_back()
6804                .map(|(index, _)| index)
6805                .unwrap_or(0);
6806            ranges.push((previous, offset));
6807        }
6808        if ranges.is_empty() {
6809            return Ok(());
6810        }
6811        if extras.is_empty() && ranges.len() == 1 {
6812            let (previous, offset) = ranges[0];
6813            let mut content = buffer.content;
6814            content.drain(previous..offset);
6815            let cursor = crate::development::editor::text_position_at_offset(&content, previous)
6816                .ok_or_else(|| {
6817                    crate::development::DevelopmentError::InvalidInput(
6818                        "backspace ended at an invalid UTF-8 boundary".into(),
6819                    )
6820                })?;
6821            let actor = crate::development::Actor::local();
6822            project.edit_buffer(path, content, actor.clone())?;
6823            project.set_buffer_cursor(path, cursor.line, cursor.column)?;
6824            project.set_buffer_selection(path, None, actor)?;
6825            return Ok(());
6826        }
6827        let (content, carets) = multi_delete(&buffer.content, &ranges);
6828        let mut next_extras = Vec::new();
6829        let mut primary_pos = crate::development::TextPosition { line: 1, column: 1 };
6830        for (index, offset) in carets.into_iter().enumerate() {
6831            let position = crate::development::editor::text_position_at_offset(&content, offset)
6832                .ok_or_else(|| {
6833                    crate::development::DevelopmentError::InvalidInput(
6834                        "backspace ended at an invalid UTF-8 boundary".into(),
6835                    )
6836                })?;
6837            if index == 0 {
6838                primary_pos = position;
6839            } else {
6840                next_extras.push(TextSelection::collapsed(position));
6841            }
6842        }
6843        let actor = crate::development::Actor::local();
6844        project.edit_buffer(path, content, actor.clone())?;
6845        project.set_buffer_cursor(path, primary_pos.line, primary_pos.column)?;
6846        project.set_buffer_selection(path, None, actor)?;
6847        drop(workspace);
6848        self.editor_engine.extra_selections = next_extras;
6849        Ok(())
6850    }
6851
6852    pub fn previous_surface(&mut self) {
6853        let surfaces: &[DevSurface] = if self
6854            .responsive_class(self.terminal_width, self.terminal_height)
6855            == ResponsiveClass::Phone
6856        {
6857            &DevSurface::PHONE
6858        } else {
6859            &DevSurface::PRIMARY
6860        };
6861        let index = surfaces
6862            .iter()
6863            .position(|surface| *surface == self.surface)
6864            .unwrap_or(0);
6865        self.show_surface(surfaces[(index + surfaces.len() - 1) % surfaces.len()]);
6866    }
6867
6868    /// Apply one background snapshot without touching UI-only fields.
6869    pub fn apply_snapshot(&mut self, snapshot: &super::snapshot::DisplaySnapshot) {
6870        self.refresh_latency_ms = snapshot.duration.as_millis() as u64;
6871        let selected_agent_status = self.selected_agent.as_ref().and_then(|selected| {
6872            snapshot
6873                .agent_states
6874                .iter()
6875                .find(|(id, _)| id == selected)
6876                .map(|(_, status)| *status)
6877        });
6878        if let super::snapshot::BrowserHealth::Crashed {
6879            last_process_id,
6880            last_revision,
6881        } = &snapshot.browser_health
6882            && self.browser_recovery.is_none()
6883        {
6884            let pid_label = last_process_id
6885                .map(|pid| pid.to_string())
6886                .unwrap_or_else(|| "unknown".into());
6887            let revision_label = last_revision
6888                .map(|revision| revision.to_string())
6889                .unwrap_or_else(|| "none".into());
6890            self.surface = DevSurface::App;
6891            self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
6892                &format!(
6893                    "browser endpoint crashed unexpectedly (pid {pid_label}, last revision {revision_label})"
6894                ),
6895                9222,
6896            ));
6897            self.browser_workspace
6898                .disconnected("browser endpoint crashed".to_string(), true);
6899            self.status = "Browser endpoint crashed · recovery choices below".into();
6900        }
6901        self.harnesses = snapshot.harnesses.clone();
6902        if let Ok(list) = self.ws().map(|workspace| workspace.todos()) {
6903            self.session_todos = list;
6904            self.selected_todo = self
6905                .selected_todo
6906                .min(self.session_todos.items.len().saturating_sub(1));
6907        }
6908        self.agents = snapshot.agents.clone();
6909        self.agent_conversation = snapshot.agent_conversation.clone();
6910        self.conversation_items = snapshot.conversation_items.clone();
6911        if let Some(chrome) = self
6912            .selected_agent
6913            .as_ref()
6914            .and_then(|selected| {
6915                snapshot
6916                    .agent_chrome
6917                    .iter()
6918                    .find(|item| item.id == *selected)
6919            })
6920            .or_else(|| snapshot.agent_chrome.first())
6921        {
6922            if self.selected_agent.is_none() {
6923                self.selected_agent = Some(chrome.id.clone());
6924            }
6925            self.agent_model = chrome.model.clone().unwrap_or_default();
6926            self.agent_thinking = chrome.thinking.clone().unwrap_or_default();
6927            if let Some(path) = chrome.session_file.as_deref() {
6928                self.agent_session_name = std::path::Path::new(path)
6929                    .file_name()
6930                    .and_then(|name| name.to_str())
6931                    .unwrap_or(path)
6932                    .to_string();
6933            }
6934        }
6935        let entry_count = self.conversation_entries_view().len();
6936        if entry_count == 0 {
6937            self.transcript_selection = 0;
6938        } else {
6939            self.transcript_selection = self.transcript_selection.min(entry_count - 1);
6940        }
6941        self.reconcile_pending_chat();
6942        if self.agent_send_job.is_none()
6943            && self.pending_chat_messages.is_empty()
6944            && self.status.contains("Glass Agent is thinking")
6945        {
6946            match selected_agent_status {
6947                Some(crate::AgentStatus::Idle) => {
6948                    self.status = "Glass Agent ready · response received".into();
6949                }
6950                Some(crate::AgentStatus::Failed) => {
6951                    self.status = "Glass Agent failed · press Enter to retry".into();
6952                }
6953                Some(crate::AgentStatus::Cancelled) => {
6954                    self.status = "Glass Agent stopped · press Enter to retry".into();
6955                }
6956                Some(crate::AgentStatus::Waiting) => {
6957                    self.status = "Glass Agent waiting for approval".into();
6958                }
6959                _ => {}
6960            }
6961        }
6962        self.tasks = snapshot.tasks.clone();
6963        if !snapshot.editor.is_empty() {
6964            self.editor = snapshot.editor.clone();
6965        }
6966        self.lsp = snapshot.lsp.clone();
6967        self.processes = snapshot.processes.clone();
6968        self.process_entries = snapshot.process_entries.clone();
6969        if self.process_entries.is_empty() {
6970            self.selected_process = 0;
6971            self.process_urls.clear();
6972        } else {
6973            self.selected_process = self
6974                .selected_process
6975                .min(self.process_entries.len().saturating_sub(1));
6976            self.process_urls = self
6977                .process_entries
6978                .iter()
6979                .filter_map(|entry| entry.url.clone())
6980                .collect();
6981            self.process_urls.sort();
6982            self.process_urls.dedup();
6983        }
6984        self.git = snapshot.git.clone();
6985        self.git_entries = snapshot.git_entries.clone();
6986        self.git_branch = snapshot.git_branch.clone();
6987        self.git_dirty = snapshot.git_dirty;
6988        self.git_ahead = snapshot.git_ahead;
6989        self.git_behind = snapshot.git_behind;
6990        self.git_conflicts = snapshot.git_conflicts.clone();
6991        self.github = snapshot.github.clone();
6992        self.github_review = snapshot.github_review.clone();
6993        if self.git_entries.is_empty() {
6994            self.selected_git_file = 0;
6995        } else {
6996            self.selected_git_file = self
6997                .selected_git_file
6998                .min(self.git_entries.len().saturating_sub(1));
6999            if self.surface == DevSurface::Git && !self.git_diff_requested {
7000                let selected_path = self.selected_git_entry().map(|entry| entry.path.as_str());
7001                if !self.git_diff_open || selected_path != self.git_diff_path.as_deref() {
7002                    self.request_selected_git_diff();
7003                }
7004            }
7005        }
7006        self.tests = snapshot.tests.clone();
7007        self.kernels = snapshot.kernels.clone();
7008        self.debugger = snapshot.debugger.clone();
7009        let previous_debug = self
7010            .selected_debug_session()
7011            .map(|session| session.name.clone());
7012        self.debug_sessions = snapshot.debug_sessions.clone();
7013        if self.debug_sessions.is_empty() {
7014            self.selected_debug_session = 0;
7015            self.debug_threads.clear();
7016            self.debug_frames.clear();
7017        } else {
7018            self.selected_debug_session = self
7019                .selected_debug_session
7020                .min(self.debug_sessions.len().saturating_sub(1));
7021            let current = self
7022                .selected_debug_session()
7023                .map(|session| session.name.clone());
7024            if previous_debug != current {
7025                self.debug_threads.clear();
7026                self.debug_frames.clear();
7027                self.selected_debug_thread = 0;
7028                self.selected_debug_frame = 0;
7029            }
7030        }
7031        self.replay = snapshot.replay.clone();
7032        self.workflow = snapshot.workflow.clone();
7033        self.workspace_status = snapshot.workspace_status.clone();
7034        self.browser = snapshot.browser.clone();
7035        self.snapshot_root = snapshot.root.clone();
7036        self.snapshot_trust_label = snapshot.trust_label.clone();
7037        self.snapshot_trust_inspection = snapshot.trust_inspection.clone();
7038        self.snapshot_project_revision = snapshot.project_revision;
7039        self.snapshot_generation = snapshot.generation;
7040        self.snapshot_skills_count = snapshot.skills_count;
7041        self.snapshot_tools_count = snapshot.tools_count;
7042        self.experiments = snapshot.experiments.clone();
7043        if !snapshot.files.is_empty() {
7044            self.files = snapshot.files.clone();
7045            if !self.files.is_empty() {
7046                self.selected_file = self.selected_file.min(self.files.len() - 1);
7047            }
7048        }
7049        if self.surface == DevSurface::Code
7050            && !self.code_edit_mode
7051            && self.pending_open_file.is_some()
7052            && !self.files.is_empty()
7053        {
7054            self.flush_pending_open_file();
7055        }
7056    }
7057
7058    pub fn set_terminal_size(&mut self, width: u16, height: u16) {
7059        self.terminal_width = width;
7060        self.terminal_height = height;
7061        self.ensure_editor_cursor_visible();
7062    }
7063
7064    pub fn refresh(&mut self) {
7065        self.harnesses = crate::harness::summary();
7066        let Ok(mut workspace) = self.workspace.try_lock() else {
7067            self.status = "Workspace lock failed".into();
7068            return;
7069        };
7070        self.files = workspace
7071            .project()
7072            .list_files()
7073            .map(|entries| {
7074                entries
7075                    .into_iter()
7076                    .filter(|entry| matches!(entry.kind, crate::development::FileKind::File))
7077                    .map(|entry| entry.path)
7078                    .take(512)
7079                    .collect()
7080            })
7081            .unwrap_or_default();
7082        if let Some(wake) = workspace.latest_crew_wake() {
7083            self.last_crew_wake = Some(wake.render());
7084        }
7085        if !self.files.is_empty() {
7086            self.selected_file = self.selected_file.min(self.files.len() - 1);
7087        }
7088        let agent_snapshots = workspace.agents().list();
7089        self.pending_agent_approval = pending_agent_approval(agent_snapshots.as_ref().ok());
7090        self.agents = match agent_snapshots {
7091            Ok(agents) if agents.is_empty() => "No agents. :agent spawn ROLE TASK".into(),
7092            Ok(agents) => agents
7093                .iter()
7094                .map(|agent| {
7095                    format!(
7096                        "{}  {}  {} · {}\n  target {} · model {} · thinking {} · events {} · dropped {}{}\n  evidence {}",
7097                        agent.id.as_str(),
7098                        agent.status.label(),
7099                        agent.role,
7100                        agent.task,
7101                        agent.worktree.display(),
7102                        agent.model.as_deref().unwrap_or("default"),
7103                        agent.thinking.as_deref().unwrap_or("default"),
7104                        agent.event_count,
7105                        agent.dropped_event_count,
7106                        agent
7107                            .last_error
7108                            .as_deref()
7109                            .map(|error| format!(" · {error}"))
7110                            .unwrap_or_default(),
7111                        agent
7112                            .evidence
7113                            .iter()
7114                            .rev()
7115                            .take(3)
7116                            .map(|evidence| evidence.to_string())
7117                            .collect::<Vec<_>>()
7118                            .join(" · ")
7119                    )
7120                })
7121                .collect::<Vec<_>>()
7122                .join("\n\n"),
7123            Err(error) => format!("Agent registry failed: {error}"),
7124        };
7125        self.agent_conversation = match workspace.agents().history(0) {
7126            Ok(events) if events.is_empty() => {
7127                "No conversation yet. Press Enter or start typing to compose a message.".into()
7128            }
7129            Ok(events) => super::projection::conversation(
7130                &events
7131                    .iter()
7132                    .rev()
7133                    .take(40)
7134                    .rev()
7135                    .cloned()
7136                    .collect::<Vec<_>>(),
7137            ),
7138            Err(error) => format!("Conversation unavailable · {error}"),
7139        };
7140        self.tasks = match workspace.tasks() {
7141            Ok(tasks) if tasks.is_empty() => {
7142                "No tasks. :task create TITLE PROMPT creates an autonomous task".into()
7143            }
7144            Ok(tasks) => tasks
7145                .iter()
7146                .map(|task| {
7147                    let glyph = match task.state {
7148                        crate::TaskState::Succeeded
7149                            if task.verification == crate::VerificationRequirement::Settled => "◇",
7150                        crate::TaskState::Succeeded => "✓",
7151                        crate::TaskState::Failed | crate::TaskState::Cancelled => "×",
7152                        crate::TaskState::Blocked => "!",
7153                        crate::TaskState::Running | crate::TaskState::Verifying => "●",
7154                        _ => "○",
7155                    };
7156                    format!(
7157                        "{} {}  {}  {}\n  goal {}\n  agent {} · attempt {} · model {} · thinking {}\n  depends {}\n  verification {}{}\n  evidence {}",
7158                        glyph,
7159                        task.id.as_str(),
7160                        task.state.label(),
7161                        task.title,
7162                        task.goal,
7163                        task.assigned_agent
7164                            .as_ref()
7165                            .map(|agent| agent.as_str())
7166                            .unwrap_or("unassigned"),
7167                        task.attempt,
7168                        task.model.as_deref().unwrap_or("default"),
7169                        task.thinking.as_deref().unwrap_or("default"),
7170                        task.dependencies
7171                            .iter()
7172                            .map(|dependency| dependency.as_str())
7173                            .collect::<Vec<_>>()
7174                            .join(", "),
7175                        serde_json::to_string(&task.verification).unwrap_or_default(),
7176                        task.last_error
7177                            .as_deref()
7178                            .map(|error| format!(" · {error}"))
7179                            .unwrap_or_default(),
7180                        task.evidence
7181                            .iter()
7182                            .rev()
7183                            .take(3)
7184                            .map(|evidence| {
7185                                format!(
7186                                    "{}={}",
7187                                    evidence.kind,
7188                                    evidence.passed.map_or("?".into(), |passed| passed.to_string())
7189                                )
7190                            })
7191                            .collect::<Vec<_>>()
7192                            .join(" · ")
7193                    )
7194                })
7195                .collect::<Vec<_>>()
7196                .join("\n\n"),
7197            Err(error) => format!("Task scheduler failed: {error}"),
7198        };
7199        match workspace.project_mut().processes().list_checked() {
7200            Ok(items) => {
7201                self.process_urls = items
7202                    .iter()
7203                    .flat_map(|item| item.detected_urls.iter().cloned())
7204                    .collect();
7205                self.process_urls.sort();
7206                self.process_urls.dedup();
7207                self.process_entries = items.iter().map(ProcessRow::from_snapshot).collect();
7208                self.selected_process = if self.process_entries.is_empty() {
7209                    0
7210                } else {
7211                    self.selected_process
7212                        .min(self.process_entries.len().saturating_sub(1))
7213                };
7214                self.processes = if items.is_empty() {
7215                    "No managed terminals. Start the detected development command from More.".into()
7216                } else {
7217                    items
7218                        .into_iter()
7219                        .map(|item| {
7220                            format!(
7221                                "{} {} · health {} · pid {} · {}\n  {}",
7222                                if matches!(item.health, crate::development::ProcessHealth::Healthy)
7223                                {
7224                                    "●"
7225                                } else {
7226                                    "○"
7227                                },
7228                                item.name,
7229                                item.health.label(),
7230                                item.pid.map_or_else(|| "—".into(), |pid| pid.to_string()),
7231                                if item.pty { "PTY" } else { "pipes" },
7232                                item.detected_urls
7233                                    .first()
7234                                    .map_or(item.command.as_str(), String::as_str),
7235                            )
7236                        })
7237                        .collect::<Vec<_>>()
7238                        .join("\n\n")
7239                };
7240            }
7241            Err(error) => {
7242                self.process_urls.clear();
7243                self.process_entries.clear();
7244                self.selected_process = 0;
7245                self.processes = format!("Process state failed: {error}");
7246            }
7247        }
7248        let buffers = workspace.project().buffers().cloned().collect::<Vec<_>>();
7249        self.editor = if buffers.is_empty() {
7250            "No file open. Select a file below and press Enter to open the full-screen editor."
7251                .into()
7252        } else {
7253            buffers
7254                .iter()
7255                .map(|buffer| {
7256                    // Viewport follows the cursor; long files stay editable.
7257                    let lines: Vec<&str> = buffer.content.lines().collect();
7258                    let cursor = buffer.cursor_line as usize;
7259                    let viewport_rows = 16;
7260                    let start = cursor
7261                        .saturating_sub(viewport_rows / 2)
7262                        .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
7263                    let end = (start + viewport_rows).min(lines.len());
7264                    let gutter_width = lines.len().to_string().len().max(3);
7265                    let viewport = lines[start..end]
7266                        .iter()
7267                        .enumerate()
7268                        .map(|(index, line)| {
7269                            let number = start + index + 1;
7270                            let marker = if number == cursor { "▶" } else { " " };
7271                            format!(
7272                                "{marker}{:>gutter_width$} │ {line}",
7273                                number,
7274                                gutter_width = gutter_width
7275                            )
7276                        })
7277                        .collect::<Vec<_>>()
7278                        .join("\n");
7279                    format!(
7280                        "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
7281                        if buffer.dirty { "● " } else { "○ " },
7282                        buffer.path,
7283                        buffer.cursor_line,
7284                        buffer.cursor_column,
7285                        buffer.actor.id,
7286                        lines.len(),
7287                        viewport
7288                    )
7289                })
7290                .collect::<Vec<_>>()
7291                .join("\n\n")
7292        };
7293        self.editor_comments = workspace.project().editor_comments(None);
7294        self.editor_proposals = workspace.project().editor_proposals();
7295        self.editor_checkpoints = workspace.project().editor_checkpoints();
7296        if let Some(buffer) = buffers.get(self.editor_buffer_index) {
7297            self.focused_editor_path = buffer.path.clone();
7298            self.focused_editor_dirty = buffer.dirty;
7299            self.focused_editor_line = buffer.cursor_line;
7300            self.focused_editor_column = buffer.cursor_column;
7301            self.focused_editor_selection = buffer.selection.clone();
7302        }
7303        self.lsp = {
7304            let language = workspace.language();
7305            let servers = language.names().collect::<Vec<_>>();
7306            let event_count = language.events(0).len();
7307            if servers.is_empty() {
7308                "No language server active · diagnostics unavailable".into()
7309            } else {
7310                format!("● {} · {} recent events", servers.join(" · "), event_count)
7311            }
7312        };
7313        let git_status = workspace.git().map(|git| git.status());
7314        self.git = match git_status {
7315            Some(Ok(status)) => {
7316                self.git_entries = status.sorted_entries();
7317                self.git_branch = status.branch.clone().unwrap_or_else(|| "detached".into());
7318                self.git_ahead = status.ahead;
7319                self.git_behind = status.behind;
7320                self.git_conflicts = status.conflicts.clone();
7321                self.git_dirty = !status.conflicts.is_empty()
7322                    || status.ahead > 0
7323                    || status.behind > 0
7324                    || status.entries.iter().any(|entry| {
7325                        entry.untracked || entry.index_status != ' ' || entry.worktree_status != ' '
7326                    });
7327                let header = format!(
7328                    "branch {} · ↑{} ↓{} · upstream {}",
7329                    status.branch.as_deref().unwrap_or("detached"),
7330                    status.ahead,
7331                    status.behind,
7332                    status.upstream.as_deref().unwrap_or("none")
7333                );
7334                let entries = status
7335                    .entries
7336                    .iter()
7337                    .map(|entry| {
7338                        format!(
7339                            "{}{} {}{}",
7340                            if entry.untracked { "?" } else { "●" },
7341                            if status.conflicts.contains(&entry.path) {
7342                                "!"
7343                            } else {
7344                                " "
7345                            },
7346                            entry.index_status,
7347                            entry.path
7348                        )
7349                    })
7350                    .collect::<Vec<_>>();
7351                if entries.is_empty() {
7352                    format!("{header}\n✓ working tree clean")
7353                } else {
7354                    format!("{header}\n{}", entries.join("\n"))
7355                }
7356            }
7357            Some(Err(error)) => {
7358                self.git_entries.clear();
7359                self.git_branch.clear();
7360                self.git_ahead = 0;
7361                self.git_behind = 0;
7362                self.git_conflicts.clear();
7363                self.git_dirty = false;
7364                format!("Git state failed: {error}")
7365            }
7366            None => {
7367                self.git_entries.clear();
7368                self.git_branch.clear();
7369                self.git_ahead = 0;
7370                self.git_behind = 0;
7371                self.git_conflicts.clear();
7372                self.git_dirty = false;
7373                "Not a Git repository".into()
7374            }
7375        };
7376        if self.git_entries.is_empty() {
7377            self.selected_git_file = 0;
7378        } else {
7379            self.selected_git_file = self
7380                .selected_git_file
7381                .min(self.git_entries.len().saturating_sub(1));
7382        }
7383        let _ = workspace.tests_mut().poll();
7384        let test_runs = workspace
7385            .tests()
7386            .results()
7387            .rev()
7388            .take(32)
7389            .collect::<Vec<_>>();
7390        self.tests = if test_runs.is_empty() {
7391            "No test runs".into()
7392        } else {
7393            test_runs
7394                .iter()
7395                .map(|run| {
7396                    format!(
7397                        "{} {} · {} · {} ms · {} cases",
7398                        if run.exit_code == Some(0) {
7399                            "✓"
7400                        } else {
7401                            "×"
7402                        },
7403                        run.suite_id,
7404                        run.state.label(),
7405                        run.duration_ms.unwrap_or_default(),
7406                        run.cases.len()
7407                    )
7408                })
7409                .collect::<Vec<_>>()
7410                .join("\n")
7411        };
7412        let kernels = workspace.kernels().snapshots().collect::<Vec<_>>();
7413        self.kernels = if kernels.is_empty() {
7414            "No persistent kernels".into()
7415        } else {
7416            kernels
7417                .iter()
7418                .map(|kernel| {
7419                    format!(
7420                        "{} {} · {} · {} executions · rev {}",
7421                        if matches!(kernel.state, crate::kernels::KernelState::Ready) {
7422                            "●"
7423                        } else {
7424                            "○"
7425                        },
7426                        kernel.name,
7427                        kernel.kind.label(),
7428                        kernel.executions,
7429                        kernel.workspace_revision
7430                    )
7431                })
7432                .collect::<Vec<_>>()
7433                .join("\n")
7434        };
7435        let debugger_names = workspace
7436            .debugger_names()
7437            .map(str::to_string)
7438            .collect::<Vec<_>>();
7439        self.debugger = if debugger_names.is_empty() {
7440            self.debug_sessions.clear();
7441            self.selected_debug_session = 0;
7442            "No debugger sessions. :debug start NAME COMMAND [ARGS...]".into()
7443        } else {
7444            let snapshots: Result<Vec<_>, _> = debugger_names
7445                .iter()
7446                .map(|name| {
7447                    workspace
7448                        .debugger_mut(name)
7449                        .and_then(|debugger| debugger.snapshot())
7450                        .map(|snapshot| (name.to_string(), snapshot))
7451                })
7452                .collect();
7453            match snapshots {
7454                Ok(snapshots) => {
7455                    self.debug_sessions = snapshots
7456                        .iter()
7457                        .map(|(name, snapshot)| DebugSessionRow {
7458                            name: name.clone(),
7459                            state: snapshot.state,
7460                            pid: snapshot.adapter_process_id,
7461                            breakpoints: snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
7462                            watches: snapshot.watches.len(),
7463                        })
7464                        .collect();
7465                    self.selected_debug_session = self
7466                        .selected_debug_session
7467                        .min(self.debug_sessions.len().saturating_sub(1));
7468                    snapshots
7469                    .iter()
7470                    .map(|(name, snapshot)| {
7471                        format!(
7472                            "● {} · {} · pid {} · {} breakpoints · {} watches · {} threads/processes",
7473                            name,
7474                            snapshot.state.label(),
7475                            snapshot.adapter_process_id,
7476                            snapshot.breakpoints.values().map(Vec::len).sum::<usize>(),
7477                            snapshot.watches.len(),
7478                            snapshot.debuggee_processes.len()
7479                        )
7480                    })
7481                    .collect::<Vec<_>>()
7482                    .join("\n")
7483                }
7484                Err(error) => format!("Debugger state failed: {error}"),
7485            }
7486        };
7487        self.replay = workspace
7488            .intelligence()
7489            .replay(0, 128)
7490            .map(|events| {
7491                if events.is_empty() {
7492                    "No observable replay events".into()
7493                } else {
7494                    events
7495                        .iter()
7496                        .rev()
7497                        .take(24)
7498                        .rev()
7499                        .map(|event| {
7500                            format!(
7501                                "{} {} · {} · {} · rev {}",
7502                                event.sequence,
7503                                event.actor,
7504                                event.subsystem,
7505                                event.kind,
7506                                event.workspace_revision
7507                            )
7508                        })
7509                        .collect::<Vec<_>>()
7510                        .join("\n")
7511                }
7512            })
7513            .unwrap_or_else(|error| format!("Replay failed: {error}"));
7514        self.browser = match workspace.browser().state() {
7515            Ok(state) => {
7516                let connected = state
7517                    .get("connected")
7518                    .and_then(serde_json::Value::as_bool)
7519                    .unwrap_or(false);
7520                let revision = state
7521                    .get("browserRevision")
7522                    .and_then(serde_json::Value::as_u64);
7523                if connected {
7524                    if self.browser_workspace.state().connection
7525                        != BrowserConnectionPhase::Connected
7526                    {
7527                        self.browser_workspace.connected(true, None, revision);
7528                    } else if let Some(revision) = revision {
7529                        self.browser_workspace.state_mut().browser_revision = Some(revision);
7530                    }
7531                } else {
7532                    self.browser_workspace.state_mut().connection =
7533                        BrowserConnectionPhase::Detached;
7534                }
7535                self.browser_workspace_summary()
7536            }
7537            Err(error) => format!("Browser state failed: {error}"),
7538        };
7539        self.workflow = workspace
7540            .browser()
7541            .list_workflows()
7542            .map(|state| super::projection::workflow(Some(&state)))
7543            .unwrap_or_else(|error| format!("Workflow state failed: {error}"));
7544        let root = workspace.root().display().to_string();
7545        let generation = workspace.generation();
7546        let project_revision = workspace.project().revision();
7547        let agent_count = workspace
7548            .agents()
7549            .list()
7550            .map(|items| items.len())
7551            .unwrap_or(0);
7552        let task_count = workspace.tasks().map(|items| items.len()).unwrap_or(0);
7553        let kernel_count = workspace.kernels().snapshots().count();
7554        let debugger_count = workspace.debugger_names().count();
7555        let detection = workspace.project().detection().clone();
7556        let trust = workspace.trust();
7557        let trust_ready = trust.permits_project_execution();
7558        let dev_hint = detection
7559            .dev_command
7560            .as_deref()
7561            .map(|command| format!("● run `{command}`"))
7562            .unwrap_or_else(|| "○ configure a dev command".into());
7563        let app_hint = detection
7564            .browser_url
7565            .as_deref()
7566            .map(|url| format!("● open App {url}"))
7567            .unwrap_or_else(|| "○ start App after a URL is detected".into());
7568        let project_line = if detection.languages.is_empty() {
7569            "○ project type unknown".to_string()
7570        } else {
7571            format!("✓ {} project", detection.languages.join("/"))
7572        };
7573        let workspace_line = format!("✓ workspace {}", trust.label());
7574        let agent_hint = if self.agent_readiness.starts_with("✓ Ready") {
7575            ":agent ready · type a message or press Enter to chat"
7576        } else {
7577            "○ Pi onboarding · use :agent setup or :agent setup login"
7578        };
7579        self.workspace_status = format!(
7580            "WELCOME · {}\n{}\n\n{}\n{}\n\nNEXT ACTIONS\n◆ :actions guided launchers · per-surface flows\n◆ type a message or press Enter to talk to Glass Agent\n◆ :process start dev · start the detected dev suite\n◆ Enter · open the selected file\n{}\n{}\n\nSTATE\nroot {}\ngeneration {} · project revision {} · trust {}\nresident: {} agents · {} tasks · {} kernels · {} debuggers",
7581            detection.git_branch.as_deref().unwrap_or("no branch"),
7582            project_line,
7583            agent_hint,
7584            workspace_line,
7585            dev_hint,
7586            app_hint,
7587            root,
7588            generation,
7589            project_revision,
7590            trust_ready,
7591            agent_count,
7592            task_count,
7593            kernel_count,
7594            debugger_count,
7595        );
7596        if workspace.trust().permits_project_execution()
7597            && let Ok(experiments) = workspace.experiments()
7598        {
7599            let snapshots = experiments.snapshots();
7600            self.experiments = if snapshots.is_empty() {
7601                "No experiments".into()
7602            } else {
7603                snapshots
7604                    .iter()
7605                    .map(|experiment| {
7606                        format!(
7607                            "{} {} · {} · port {} · agent {}",
7608                            if experiment.evidence.tests_failed == 0
7609                                && experiment.evidence.tests_passed > 0
7610                            {
7611                                "✓"
7612                            } else {
7613                                "○"
7614                            },
7615                            experiment.id,
7616                            experiment.state.label(),
7617                            experiment
7618                                .port
7619                                .map_or_else(|| "—".into(), |port| port.to_string()),
7620                            experiment
7621                                .agent_id
7622                                .as_ref()
7623                                .map(|id| id.as_str())
7624                                .unwrap_or("none")
7625                        )
7626                    })
7627                    .collect::<Vec<_>>()
7628                    .join("\n")
7629            };
7630            self.experiment_comparison = Some(experiments.compare());
7631        }
7632        drop(workspace);
7633        self.reconcile_pending_chat();
7634    }
7635
7636    pub fn apply_browser_result(&mut self, tool: &str, result: &serde_json::Value) {
7637        match tool {
7638            "glass.browser.observe" => {
7639                let revision = result
7640                    .pointer("/accessibility/revision")
7641                    .and_then(serde_json::Value::as_u64);
7642                let title = result
7643                    .pointer("/page/title")
7644                    .and_then(serde_json::Value::as_str)
7645                    .unwrap_or("Untitled");
7646                let url = result
7647                    .pointer("/page/url")
7648                    .and_then(serde_json::Value::as_str)
7649                    .unwrap_or_default();
7650                let loading = result
7651                    .pointer("/page/loading")
7652                    .and_then(serde_json::Value::as_bool)
7653                    .unwrap_or(false);
7654                if let Some(revision) = revision {
7655                    self.browser_workspace
7656                        .update_page(title, url, loading, Some(revision));
7657                    let entities = result
7658                        .pointer("/accessibility/interactive")
7659                        .and_then(serde_json::Value::as_array)
7660                        .into_iter()
7661                        .flatten()
7662                        .filter_map(|entity| {
7663                            Some(BrowserWorkspaceEntity {
7664                                reference: entity.get("reference")?.as_str()?.into(),
7665                                role: entity
7666                                    .get("role")
7667                                    .and_then(serde_json::Value::as_str)
7668                                    .unwrap_or("unknown")
7669                                    .into(),
7670                                name: entity
7671                                    .get("name")
7672                                    .and_then(serde_json::Value::as_str)
7673                                    .unwrap_or("unnamed")
7674                                    .into(),
7675                                actionable: entity
7676                                    .get("actionable")
7677                                    .and_then(serde_json::Value::as_bool)
7678                                    .unwrap_or(true),
7679                                revision,
7680                            })
7681                        })
7682                        .collect();
7683                    self.browser_workspace.replace_entities(revision, entities);
7684                    if let Some(entity) = self.pending_page_entity.clone()
7685                        && self.select_page_entity(&entity)
7686                    {
7687                        self.pending_page_entity = None;
7688                        self.status = format!("Page bound · {entity}");
7689                    }
7690                }
7691            }
7692            "glass.browser.targets" => {
7693                let values = result
7694                    .get("targets")
7695                    .and_then(serde_json::Value::as_array)
7696                    .or_else(|| result.as_array());
7697                let targets = values
7698                    .into_iter()
7699                    .flatten()
7700                    .filter_map(|target| {
7701                        Some(BrowserWorkspaceTarget {
7702                            id: target.get("id")?.as_str()?.into(),
7703                            title: target
7704                                .get("title")
7705                                .and_then(serde_json::Value::as_str)
7706                                .unwrap_or("Untitled")
7707                                .into(),
7708                            url: target
7709                                .get("url")
7710                                .and_then(serde_json::Value::as_str)
7711                                .unwrap_or_default()
7712                                .into(),
7713                            selected: target
7714                                .get("active")
7715                                .and_then(serde_json::Value::as_bool)
7716                                .unwrap_or(false),
7717                        })
7718                    })
7719                    .collect();
7720                self.browser_workspace.replace_targets(targets);
7721                if self.browser_target_picker_requested {
7722                    self.browser_target_picker_requested = false;
7723                    self.browser_target_picker = true;
7724                    self.browser_target_selection = 0;
7725                    self.status = if self.browser_workspace.state().targets.is_empty() {
7726                        "No page targets found · Esc closes".into()
7727                    } else {
7728                        "Target picker · type to filter · j/k select · Enter choose · Esc close"
7729                            .into()
7730                    };
7731                }
7732            }
7733            "glass.browser.target.select" => {
7734                if let Some(target_id) = result
7735                    .pointer("/target/id")
7736                    .and_then(serde_json::Value::as_str)
7737                {
7738                    let mut targets = self.browser_workspace.state().targets.clone();
7739                    for target in &mut targets {
7740                        target.selected = target.id == target_id;
7741                    }
7742                    self.browser_workspace.replace_targets(targets);
7743                }
7744                if let Some(observation) = result.get("observation") {
7745                    self.apply_browser_result("glass.browser.observe", observation);
7746                }
7747            }
7748            "glass.browser.start" => {
7749                let connected = result
7750                    .get("connected")
7751                    .and_then(serde_json::Value::as_bool)
7752                    .unwrap_or(true);
7753                let revision = result
7754                    .get("browserRevision")
7755                    .and_then(serde_json::Value::as_u64);
7756                if connected {
7757                    self.browser_workspace.connected(true, None, revision);
7758                    self.browser_recovery = None;
7759                }
7760            }
7761            "glass.browser.stop" => {
7762                self.browser_workspace.state_mut().connection = BrowserConnectionPhase::Detached;
7763            }
7764            _ => {}
7765        }
7766        self.browser = self.browser_workspace_summary();
7767    }
7768
7769    pub fn browser_workspace_summary(&self) -> String {
7770        let browser = self.browser_workspace.state();
7771        let entities = if browser.entities.is_empty() {
7772            "No current semantic entities".into()
7773        } else {
7774            browser
7775                .entities
7776                .iter()
7777                .enumerate()
7778                .skip(browser.semantic_scroll)
7779                .take(24)
7780                .map(|(index, entity)| {
7781                    format!(
7782                        "{} {} · {} · {}",
7783                        if Some(index) == browser.selected_entity {
7784                            "◆"
7785                        } else {
7786                            "○"
7787                        },
7788                        entity.name,
7789                        entity.role,
7790                        entity.reference
7791                    )
7792                })
7793                .collect::<Vec<_>>()
7794                .join("\n")
7795        };
7796        let targets = if browser.targets.is_empty() {
7797            "No page targets loaded · use `browser targets`".into()
7798        } else {
7799            browser
7800                .targets
7801                .iter()
7802                .take(8)
7803                .map(|target| {
7804                    format!(
7805                        "{} {} · {}",
7806                        if target.selected { "◆" } else { "○" },
7807                        target.title,
7808                        safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into())
7809                    )
7810                })
7811                .collect::<Vec<_>>()
7812                .join("\n")
7813        };
7814        format!(
7815            "{} · rev {} · {} · owner {}\n{}\n{}\n\nTARGETS\n{}\n\nUNDERSTANDING\n{}\n\nWORKFLOW\n{}",
7816            browser.connection_label(),
7817            browser
7818                .browser_revision
7819                .map_or_else(|| "—".into(), |revision| revision.to_string()),
7820            browser.presentation_label(),
7821            browser.input_owner_label(),
7822            browser.title,
7823            safe_browser_url(&browser.url).unwrap_or_else(|| "no page".into()),
7824            targets,
7825            entities,
7826            browser.workflow
7827        )
7828    }
7829
7830    pub fn queue_browser_targets(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
7831        if self.background_action_running() {
7832            self.status = "Target picker waits for the current background operation".into();
7833            return;
7834        }
7835        if let Err(error) = self.request_browser_target_picker("") {
7836            self.status = format!("Could not load browser targets: {error}");
7837            return;
7838        }
7839        let Some((call, context)) = self.queued_tool_request.take() else {
7840            return;
7841        };
7842        match worker.submit_tool(call, context) {
7843            Ok(id) => {
7844                self.running_tool_job = Some(id);
7845                self.status = "Loading browser targets…".into();
7846            }
7847            Err(error) => {
7848                self.browser_target_picker_requested = false;
7849                self.status = format!("Could not load browser targets: {error}");
7850            }
7851        }
7852    }
7853
7854    pub fn request_browser_target_picker(
7855        &mut self,
7856        query: impl Into<String>,
7857    ) -> Result<(), String> {
7858        if self.background_action_running() {
7859            return Err("Target picker waits for the current background operation".into());
7860        }
7861        self.browser_target_query = query.into();
7862        self.browser_target_selection = 0;
7863        self.browser_target_picker = false;
7864        self.browser_target_picker_requested = true;
7865        let (call, context) =
7866            match self.tool_request("glass.browser.targets", serde_json::json!({}), false) {
7867                Ok(request) => request,
7868                Err(error) => {
7869                    self.browser_target_picker_requested = false;
7870                    return Err(error);
7871                }
7872            };
7873        self.queued_tool_request = Some((call, context));
7874        self.status = "Loading browser targets…".into();
7875        Ok(())
7876    }
7877
7878    pub fn close_browser_target_picker(&mut self) {
7879        self.browser_target_picker = false;
7880        self.browser_target_picker_requested = false;
7881        self.status = "Target picker closed".into();
7882    }
7883
7884    pub fn browser_target_matches(&self) -> Vec<usize> {
7885        let query = self.browser_target_query.to_ascii_lowercase();
7886        let terms = query.split_whitespace().collect::<Vec<_>>();
7887        self.browser_workspace
7888            .state()
7889            .targets
7890            .iter()
7891            .enumerate()
7892            .filter(|(_, target)| {
7893                terms.iter().all(|term| {
7894                    target.id.to_ascii_lowercase().contains(term)
7895                        || target.title.to_ascii_lowercase().contains(term)
7896                        || target.url.to_ascii_lowercase().contains(term)
7897                })
7898            })
7899            .map(|(index, _)| index)
7900            .collect()
7901    }
7902
7903    pub fn insert_browser_target_query(&mut self, character: char) {
7904        if self.browser_target_query.len() < 512 {
7905            self.browser_target_query.push(character);
7906            self.browser_target_selection = 0;
7907        }
7908    }
7909
7910    pub fn browser_target_backspace(&mut self) {
7911        self.browser_target_query.pop();
7912        self.browser_target_selection = 0;
7913    }
7914
7915    pub fn clear_browser_target_query(&mut self) {
7916        self.browser_target_query.clear();
7917        self.browser_target_selection = 0;
7918    }
7919
7920    pub fn move_browser_target_selection(&mut self, delta: i32) {
7921        let count = self.browser_target_matches().len();
7922        if count == 0 {
7923            self.browser_target_selection = 0;
7924            return;
7925        }
7926        self.browser_target_selection =
7927            (self.browser_target_selection as i32 + delta).rem_euclid(count as i32) as usize;
7928    }
7929
7930    pub fn select_browser_target(&mut self) {
7931        if self.background_action_running() {
7932            self.status = "Finish the current browser operation before selecting a target".into();
7933            return;
7934        }
7935        let matches = self.browser_target_matches();
7936        let Some(index) = matches.get(self.browser_target_selection).copied() else {
7937            self.status = "No matching browser target".into();
7938            return;
7939        };
7940        let Some(target) = self.browser_workspace.state().targets.get(index).cloned() else {
7941            self.status = "Selected browser target disappeared".into();
7942            return;
7943        };
7944        let (call, context) = match self.tool_request(
7945            "glass.browser.target.select",
7946            serde_json::json!({"targetId": target.id}),
7947            true,
7948        ) {
7949            Ok(request) => request,
7950            Err(error) => {
7951                self.status = format!("Target selection unavailable: {error}");
7952                return;
7953            }
7954        };
7955        self.browser_target_picker = false;
7956        let queued = match self.queue_or_confirm(
7957            call,
7958            context,
7959            format!("Select browser target · {}", target.title),
7960        ) {
7961            Ok(queued) => queued,
7962            Err(error) => {
7963                self.status = format!("Target selection unavailable: {error}");
7964                return;
7965            }
7966        };
7967        if !queued {
7968            self.status = "Target selection ready · Enter approves once · Esc cancels".into();
7969        }
7970    }
7971
7972    pub fn browser_target_picker_view(&self) -> String {
7973        let matches = self.browser_target_matches();
7974        let mut lines = vec![
7975            format!(
7976                "FILTER  {}",
7977                if self.browser_target_query.is_empty() {
7978                    "all pages"
7979                } else {
7980                    self.browser_target_query.as_str()
7981                }
7982            ),
7983            String::new(),
7984        ];
7985        if matches.is_empty() {
7986            lines.push("No matching page targets.".into());
7987        } else {
7988            for (position, index) in matches.iter().take(16).enumerate() {
7989                let Some(target) = self.browser_workspace.state().targets.get(*index) else {
7990                    continue;
7991                };
7992                let marker = if position == self.browser_target_selection {
7993                    "›"
7994                } else {
7995                    " "
7996                };
7997                let url = safe_browser_url(&target.url).unwrap_or_else(|| "no URL".into());
7998                lines.push(format!(
7999                    "{marker} {} · {} · {}",
8000                    target.title, url, target.id
8001                ));
8002            }
8003        }
8004        lines.push(String::new());
8005        lines.push("Type filters · Backspace edits · Ctrl-U clears".into());
8006        lines.push("j/k or ↑/↓ selects · Enter chooses · Esc closes".into());
8007        lines.join("\n")
8008    }
8009
8010    pub fn queue_browser_observe(&mut self, worker: &mut super::snapshot::SnapshotWorker) {
8011        if !self.browser_observe_pending || self.background_action_running() {
8012            return;
8013        }
8014        self.browser_observe_pending = false;
8015        let (call, context) =
8016            match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
8017                Ok(request) => request,
8018                Err(error) => {
8019                    self.status = format!("Could not refresh browser evidence: {error}");
8020                    return;
8021                }
8022            };
8023        match worker.submit_tool(call, context) {
8024            Ok(id) => {
8025                self.running_tool_job = Some(id);
8026                self.status = "Refreshing semantic browser evidence…".into();
8027            }
8028            Err(error) => self.status = format!("Could not refresh browser evidence: {error}"),
8029        }
8030    }
8031
8032    /// Refresh the newly started page before issuing a revision-bound navigation.
8033    pub fn continue_pending_browser_navigation(
8034        &mut self,
8035        worker: &mut super::snapshot::SnapshotWorker,
8036    ) {
8037        let Some(url) = self.pending_browser_navigation.as_deref() else {
8038            return;
8039        };
8040        let (call, context) =
8041            match self.tool_request("glass.browser.observe", serde_json::json!({}), false) {
8042                Ok(request) => request,
8043                Err(error) => {
8044                    let url = self.pending_browser_navigation.take().unwrap_or_default();
8045                    self.open_palette_with(&format!("browser navigate {url}"));
8046                    self.status = format!("Browser ready · navigation retry required: {error}");
8047                    return;
8048                }
8049            };
8050        match worker.submit_tool(call, context) {
8051            Ok(id) => {
8052                self.running_tool_job = Some(id);
8053                self.status = format!("Browser ready · preparing navigation to {url}…");
8054            }
8055            Err(error) => {
8056                let url = self.pending_browser_navigation.take().unwrap_or_default();
8057                self.open_palette_with(&format!("browser navigate {url}"));
8058                self.status = format!("Browser ready · navigation retry required: {error}");
8059            }
8060        }
8061    }
8062
8063    /// Submit the retained navigation after its fresh page revision arrives.
8064    pub fn submit_pending_browser_navigation(
8065        &mut self,
8066        worker: &mut super::snapshot::SnapshotWorker,
8067    ) {
8068        let Some(url) = self.pending_browser_navigation.take() else {
8069            return;
8070        };
8071        let Some(revision) = self.browser_workspace.state().browser_revision else {
8072            self.open_palette_with(&format!("browser navigate {url}"));
8073            self.status = "Browser launch completed without a usable revision".into();
8074            return;
8075        };
8076        let (call, context) = match self.tool_request(
8077            "glass.browser.navigate",
8078            serde_json::json!({"url": url, "browserRevision": revision}),
8079            true,
8080        ) {
8081            Ok(request) => request,
8082            Err(error) => {
8083                self.open_palette_with(&format!("browser navigate {url}"));
8084                self.status = format!("Browser ready · navigation retry required: {error}");
8085                return;
8086            }
8087        };
8088        match worker.submit_tool(call, context) {
8089            Ok(id) => {
8090                self.running_tool_job = Some(id);
8091                self.status = format!("Browser ready · navigating to {url}…");
8092            }
8093            Err(error) => {
8094                self.open_palette_with(&format!("browser navigate {url}"));
8095                self.status = format!("Browser ready · navigation retry required: {error}");
8096            }
8097        }
8098    }
8099
8100    pub fn queue_browser_intent(&mut self, intent: BrowserWorkspaceIntent) {
8101        if self.background_action_running() {
8102            self.status = "Browser action waits for the current background operation".into();
8103            return;
8104        }
8105        let action = match self.browser_workspace.reduce(intent) {
8106            Ok(Some(action)) => action,
8107            Ok(None) => return,
8108            Err(error) => {
8109                self.status = format!("App action unavailable: {error}");
8110                return;
8111            }
8112        };
8113        let (tool, arguments) = match action {
8114            BrowserWorkspaceAction::Navigate {
8115                url,
8116                expected_revision,
8117            } => (
8118                "glass.browser.navigate",
8119                serde_json::json!({"url": url, "browserRevision": expected_revision}),
8120            ),
8121            BrowserWorkspaceAction::Back { expected_revision }
8122            | BrowserWorkspaceAction::Forward { expected_revision }
8123            | BrowserWorkspaceAction::Reload { expected_revision }
8124            | BrowserWorkspaceAction::StopLoading { expected_revision } => {
8125                let action = match action {
8126                    BrowserWorkspaceAction::Back { .. } => "back",
8127                    BrowserWorkspaceAction::Forward { .. } => "forward",
8128                    BrowserWorkspaceAction::Reload { .. } => "reload",
8129                    BrowserWorkspaceAction::StopLoading { .. } => "stopLoading",
8130                    _ => unreachable!(),
8131                };
8132                (
8133                    "glass.browser.act",
8134                    serde_json::json!({"action": action, "browserRevision": expected_revision}),
8135                )
8136            }
8137            BrowserWorkspaceAction::Click {
8138                target,
8139                expected_revision,
8140            } => {
8141                let _ = self.capture_workflow_click();
8142                (
8143                    "glass.browser.act",
8144                    serde_json::json!({"action":"click", "target": target, "browserRevision": expected_revision}),
8145                )
8146            }
8147            BrowserWorkspaceAction::Type {
8148                target,
8149                text,
8150                expected_revision,
8151            } => {
8152                self.capture_workflow_type_from_selection();
8153                (
8154                    "glass.browser.act",
8155                    serde_json::json!({"action":"type", "target": target, "text": text, "browserRevision": expected_revision}),
8156                )
8157            }
8158            BrowserWorkspaceAction::Scroll {
8159                dx,
8160                dy,
8161                expected_revision,
8162            } => (
8163                "glass.browser.act",
8164                serde_json::json!({"action":"scroll", "dx": dx, "dy": dy, "browserRevision": expected_revision}),
8165            ),
8166            _ => return,
8167        };
8168        let (call, context) = match self.tool_request(tool, arguments, true) {
8169            Ok(request) => request,
8170            Err(error) => {
8171                self.status = format!("App action unavailable: {error}");
8172                return;
8173            }
8174        };
8175        let queued = match self.queue_or_confirm(
8176            call,
8177            context,
8178            format!("{tool} · browser revision guarded"),
8179        ) {
8180            Ok(queued) => queued,
8181            Err(error) => {
8182                self.status = format!("App action unavailable: {error}");
8183                return;
8184            }
8185        };
8186        if !queued {
8187            self.status = "Browser mutation ready · Enter approves once · Esc cancels".into();
8188        }
8189    }
8190
8191    pub(super) fn tool_request(
8192        &self,
8193        name: &str,
8194        arguments: serde_json::Value,
8195        mutating: bool,
8196    ) -> Result<
8197        (
8198            crate::development::ToolCall,
8199            crate::tools::DevelopmentToolContext,
8200        ),
8201        String,
8202    > {
8203        // Snapshot refresh owns the workspace lock while it performs filesystem
8204        // and process inspection. Cached revisions keep chat and actions
8205        // responsive; the executor still rejects stale guards before mutation.
8206        let expected_generation = self.snapshot_generation;
8207        let expected_project_revision = self.snapshot_project_revision;
8208        Ok((
8209            crate::development::ToolCall {
8210                id: format!(
8211                    "tui-browser-{}",
8212                    NEXT_BROWSER_TOOL.fetch_add(1, Ordering::Relaxed)
8213                ),
8214                name: name.into(),
8215                arguments,
8216            },
8217            crate::tools::DevelopmentToolContext {
8218                authorization: crate::development::ToolAuthorization {
8219                    actor: crate::development::Actor::local(),
8220                    allow_mutation: mutating,
8221                    confirmed: mutating,
8222                    unrestricted: self.yolo_mode,
8223                },
8224                initiator: None,
8225                expected_generation,
8226                expected_project_revision,
8227            },
8228        ))
8229    }
8230
8231    /// Offer in-TUI recovery whenever a browser tool fails with a launch or
8232    /// connection error, so a port collision never strands the session.
8233    pub fn note_browser_failure(&mut self, tool: &str, error: &str) {
8234        let lower = error.to_ascii_lowercase();
8235        if tool.contains("browser")
8236            && (lower.contains("occupied")
8237                || lower.contains("attach")
8238                || lower.contains("connect")
8239                || lower.contains("launch")
8240                || lower.contains("timeout")
8241                || lower.contains("devtools"))
8242        {
8243            self.browser_target_picker = false;
8244            self.browser_target_picker_requested = false;
8245            self.surface = DevSurface::App;
8246            self.browser_recovery = Some(BrowserRecoveryOffer::from_error(
8247                error,
8248                self.browser_recovery
8249                    .as_ref()
8250                    .map_or(9222, |offer| offer.port),
8251            ));
8252            self.browser_workspace.disconnected(error.to_string(), true);
8253        }
8254    }
8255
8256    /// Queue a recovery choice without blocking the terminal on browser launch.
8257    pub fn accept_browser_recovery(
8258        &mut self,
8259        choice: usize,
8260        worker: &mut super::snapshot::SnapshotWorker,
8261    ) {
8262        let Some(offer) = self.browser_recovery.take() else {
8263            return;
8264        };
8265        let (port, attach) = match (offer.compatible_endpoint, choice) {
8266            (true, 0) => (offer.port, true),
8267            (true, 1) | (false, 0) => (free_local_port().unwrap_or(0), false),
8268            (true, 2) | (false, 1) => (offer.port, false),
8269            _ => {
8270                self.status = "Recovery dismissed · project and agent remain available".into();
8271                return;
8272            }
8273        };
8274        if port == 0 {
8275            self.status =
8276                "No free local port was available · retry or use an existing browser".into();
8277            return;
8278        }
8279        let (call, context) = match self.tool_request(
8280            "glass.browser.start",
8281            browser_recovery_arguments(port, attach),
8282            true,
8283        ) {
8284            Ok(request) => request,
8285            Err(error) => {
8286                self.status = format!("Could not queue recovery: {error}");
8287                return;
8288            }
8289        };
8290        match worker.submit_tool(call, context) {
8291            Ok(id) => {
8292                self.running_tool_job = Some(id);
8293                self.status = if attach {
8294                    format!("Attaching to browser on port {port} in background…")
8295                } else {
8296                    format!("Recovering browser on port {port} in background…")
8297                };
8298            }
8299            Err(error) => self.status = format!("Could not queue recovery: {error}"),
8300        }
8301    }
8302
8303    pub fn refresh_agent_readiness(&mut self) -> Result<bool, String> {
8304        let readiness = crate::pi_runtime::pi_readiness().map_err(|error| error.to_string())?;
8305        let ready = readiness.ready;
8306        self.agent_readiness = format_pi_readiness(&readiness);
8307        Ok(ready)
8308    }
8309}
8310
8311fn diagnostic_matches_path(
8312    diagnostic: &crate::development::LanguageDiagnostic,
8313    path: &str,
8314) -> bool {
8315    path.is_empty()
8316        || diagnostic.path == path
8317        || diagnostic.path.ends_with(path)
8318        || path.ends_with(&diagnostic.path)
8319}
8320
8321fn truncate_note(text: &str) -> String {
8322    let text = text.trim().replace('\n', " ");
8323    if text.chars().count() <= 80 {
8324        text
8325    } else {
8326        format!("{}…", text.chars().take(79).collect::<String>())
8327    }
8328}
8329
8330fn parse_editor_diagnostics(
8331    value: &serde_json::Value,
8332) -> Vec<crate::development::LanguageDiagnostic> {
8333    if let Ok(list) =
8334        serde_json::from_value::<Vec<crate::development::LanguageDiagnostic>>(value.clone())
8335    {
8336        return list;
8337    }
8338    value
8339        .get("diagnostics")
8340        .and_then(|item| {
8341            serde_json::from_value::<Vec<crate::development::LanguageDiagnostic>>(item.clone()).ok()
8342        })
8343        .unwrap_or_default()
8344}
8345
8346fn more_route_status(command: &str, message: &str) -> String {
8347    match command {
8348        "doctor" if message.contains("is ready") => {
8349            "Doctor · Agent is ready · PI panel updated · 1 opens chat".into()
8350        }
8351        "doctor" => format!("Doctor · {message}"),
8352        "harness list" => "Harness catalog listed in ROUTES".into(),
8353        _ => message.to_string(),
8354    }
8355}
8356
8357fn format_editor_buffers(buffers: &[crate::development::EditorBuffer]) -> String {
8358    if buffers.is_empty() {
8359        return "No file open. Select a file below and press Enter to open the full-screen editor."
8360            .into();
8361    }
8362    buffers
8363        .iter()
8364        .map(|buffer| {
8365            let lines: Vec<&str> = buffer.content.lines().collect();
8366            let cursor = buffer.cursor_line as usize;
8367            let viewport_rows = 16;
8368            let start = cursor
8369                .saturating_sub(viewport_rows / 2)
8370                .min(lines.len().saturating_sub(viewport_rows.min(lines.len())));
8371            let end = (start + viewport_rows).min(lines.len());
8372            let gutter_width = lines.len().to_string().len().max(3);
8373            let viewport = lines[start..end]
8374                .iter()
8375                .enumerate()
8376                .map(|(index, line)| {
8377                    let number = start + index + 1;
8378                    let marker = if number == cursor { "▶" } else { " " };
8379                    format!(
8380                        "{marker}{:>gutter_width$} │ {line}",
8381                        number,
8382                        gutter_width = gutter_width
8383                    )
8384                })
8385                .collect::<Vec<_>>()
8386                .join("\n");
8387            format!(
8388                "{}{} · cursor {}:{} · actor {} · {} lines\n{}",
8389                if buffer.dirty { "● " } else { "○ " },
8390                buffer.path,
8391                buffer.cursor_line,
8392                buffer.cursor_column,
8393                buffer.actor.id,
8394                lines.len(),
8395                viewport
8396            )
8397        })
8398        .collect::<Vec<_>>()
8399        .join("\n\n")
8400}
8401
8402fn parse_conversation_view(conversation: &str) -> Vec<super::projection::ConversationEntry> {
8403    let mut entries = Vec::new();
8404    for block in conversation.split("\n\n") {
8405        let mut lines = block.lines();
8406        let Some(first) = lines.next() else {
8407            continue;
8408        };
8409        let body = lines.collect::<Vec<_>>().join("\n");
8410        let (kind, text) = match first.trim() {
8411            "YOU" => (super::projection::ConversationKind::User, body),
8412            "GLASS AGENT" => (super::projection::ConversationKind::Assistant, body),
8413            "ALERT" => (super::projection::ConversationKind::Alert, body),
8414            "ERROR" => (super::projection::ConversationKind::Error, body),
8415            "SYSTEM" => (super::projection::ConversationKind::System, body),
8416            _ => continue,
8417        };
8418        entries.push(super::projection::ConversationEntry {
8419            kind,
8420            text,
8421            streaming: false,
8422            entry_id: None,
8423            tool_name: None,
8424        });
8425    }
8426    entries
8427}
8428
8429fn parse_debug_threads(value: &serde_json::Value) -> Vec<DebugThreadRow> {
8430    value
8431        .get("threads")
8432        .and_then(serde_json::Value::as_array)
8433        .into_iter()
8434        .flatten()
8435        .filter_map(|thread| {
8436            Some(DebugThreadRow {
8437                id: thread.get("id").and_then(serde_json::Value::as_i64)?,
8438                name: thread
8439                    .get("name")
8440                    .and_then(serde_json::Value::as_str)
8441                    .unwrap_or("thread")
8442                    .to_string(),
8443            })
8444        })
8445        .collect()
8446}
8447
8448fn parse_debug_scopes(value: &serde_json::Value) -> Vec<DebugScopeRow> {
8449    value
8450        .get("scopes")
8451        .and_then(serde_json::Value::as_array)
8452        .into_iter()
8453        .flatten()
8454        .map(|scope| DebugScopeRow {
8455            name: scope
8456                .get("name")
8457                .and_then(serde_json::Value::as_str)
8458                .unwrap_or("scope")
8459                .to_string(),
8460            variables_reference: scope
8461                .get("variablesReference")
8462                .and_then(serde_json::Value::as_i64)
8463                .unwrap_or(0),
8464        })
8465        .collect()
8466}
8467
8468fn parse_debug_variables(value: &serde_json::Value) -> Vec<DebugVariableRow> {
8469    value
8470        .get("variables")
8471        .and_then(serde_json::Value::as_array)
8472        .into_iter()
8473        .flatten()
8474        .filter_map(|variable| {
8475            Some(DebugVariableRow {
8476                name: variable
8477                    .get("name")
8478                    .and_then(serde_json::Value::as_str)?
8479                    .to_string(),
8480                value: variable
8481                    .get("value")
8482                    .and_then(serde_json::Value::as_str)
8483                    .unwrap_or("")
8484                    .chars()
8485                    .take(120)
8486                    .collect(),
8487            })
8488        })
8489        .take(64)
8490        .collect()
8491}
8492
8493fn parse_debug_frames(value: &serde_json::Value) -> Vec<DebugFrameRow> {
8494    value
8495        .get("stackFrames")
8496        .and_then(serde_json::Value::as_array)
8497        .into_iter()
8498        .flatten()
8499        .filter_map(|frame| {
8500            Some(DebugFrameRow {
8501                id: frame.get("id").and_then(serde_json::Value::as_i64)?,
8502                name: frame
8503                    .get("name")
8504                    .and_then(serde_json::Value::as_str)
8505                    .unwrap_or("frame")
8506                    .to_string(),
8507                path: frame
8508                    .pointer("/source/path")
8509                    .and_then(serde_json::Value::as_str)
8510                    .map(str::to_string),
8511                line: frame.get("line").and_then(serde_json::Value::as_u64),
8512            })
8513        })
8514        .collect()
8515}
8516
8517fn parse_session_picker_items(value: &serde_json::Value) -> Vec<SessionPickerItem> {
8518    let items = value
8519        .as_array()
8520        .or_else(|| value.get("sessions").and_then(serde_json::Value::as_array))
8521        .cloned()
8522        .unwrap_or_default();
8523    items
8524        .into_iter()
8525        .filter_map(|item| {
8526            if let Some(path) = item.as_str() {
8527                return Some(SessionPickerItem {
8528                    label: std::path::Path::new(path)
8529                        .file_name()
8530                        .and_then(|name| name.to_str())
8531                        .unwrap_or(path)
8532                        .to_string(),
8533                    path: path.to_string(),
8534                });
8535            }
8536            let path = item
8537                .get("path")
8538                .or_else(|| item.get("file"))
8539                .or_else(|| item.get("sessionFile"))
8540                .and_then(serde_json::Value::as_str)?;
8541            let label = item
8542                .get("name")
8543                .or_else(|| item.get("sessionName"))
8544                .and_then(serde_json::Value::as_str)
8545                .map(str::to_string)
8546                .unwrap_or_else(|| {
8547                    std::path::Path::new(path)
8548                        .file_name()
8549                        .and_then(|name| name.to_str())
8550                        .unwrap_or(path)
8551                        .to_string()
8552                });
8553            Some(SessionPickerItem {
8554                path: path.to_string(),
8555                label,
8556            })
8557        })
8558        .collect()
8559}
8560
8561fn stats_summary(value: &serde_json::Value) -> String {
8562    let input = value
8563        .pointer("/inputTokens")
8564        .or_else(|| value.pointer("/tokens/input"))
8565        .or_else(|| value.get("input"))
8566        .and_then(serde_json::Value::as_u64);
8567    let output = value
8568        .pointer("/outputTokens")
8569        .or_else(|| value.pointer("/tokens/output"))
8570        .or_else(|| value.get("output"))
8571        .and_then(serde_json::Value::as_u64);
8572    match (input, output) {
8573        (Some(input), Some(output)) => format!("{input} in · {output} out"),
8574        (Some(input), None) => format!("{input} tokens"),
8575        _ => super::projection::first_meaningful(value)
8576            .lines()
8577            .next()
8578            .unwrap_or("stats")
8579            .to_string(),
8580    }
8581}
8582
8583fn format_pi_readiness(readiness: &crate::PiReadiness) -> String {
8584    let provider = readiness.provider.as_deref().unwrap_or("not selected");
8585    let session = readiness.session.as_deref().unwrap_or("new session");
8586    let remediation = readiness
8587        .remediation
8588        .first()
8589        .map(|item| format!(" · next: {item}"))
8590        .unwrap_or_default();
8591    let state_line = format!(
8592        "{} · Node {} · SDK {} · auth {}",
8593        if readiness.ready {
8594            "✓ Ready"
8595        } else {
8596            "○ Needs setup"
8597        },
8598        component_label(&readiness.node),
8599        readiness.sdk.version.as_deref().unwrap_or("missing"),
8600        component_label(&readiness.authentication),
8601    );
8602    if readiness.ready {
8603        format!("{state_line}\nprovider {provider} · {session}")
8604    } else {
8605        format!(
8606            "{state_line}\nprovider {provider} · {session}{remediation}\n\nUse `:agent setup` to repair the pinned runtime · `:agent update` to refresh it · `:agent setup login` to open Pi `/login`"
8607        )
8608    }
8609}
8610
8611fn component_label(component: &crate::pi_runtime::PiReadinessComponent) -> String {
8612    match component.state {
8613        crate::pi_runtime::PiReadinessState::Ready => "✓".into(),
8614        crate::pi_runtime::PiReadinessState::Missing => "× missing".into(),
8615        crate::pi_runtime::PiReadinessState::Incompatible => "! incompatible".into(),
8616        crate::pi_runtime::PiReadinessState::Expired => "! expired".into(),
8617        crate::pi_runtime::PiReadinessState::Unknown => "? unknown".into(),
8618    }
8619}
8620
8621fn safe_browser_url(url: &str) -> Option<String> {
8622    let url = url.trim();
8623    if url.is_empty() {
8624        return None;
8625    }
8626    let sanitized = url
8627        .split(['?', '#'])
8628        .next()
8629        .unwrap_or(url)
8630        .chars()
8631        .take(2_048)
8632        .collect::<String>();
8633    (!sanitized.is_empty()).then_some(sanitized)
8634}
8635
8636fn page_origin(url: &str) -> Option<String> {
8637    let url = safe_browser_url(url)?;
8638    let scheme_end = url.find("://")?;
8639    let authority_start = scheme_end + 3;
8640    let authority_end = url[authority_start..]
8641        .find('/')
8642        .map(|offset| authority_start + offset)
8643        .unwrap_or(url.len());
8644    Some(url[..authority_end].to_string())
8645}
8646fn bounded_editor_content(content: &str) -> (String, bool) {
8647    const MAX_CONTEXT_BYTES: usize = 64 * 1024;
8648    if content.len() <= MAX_CONTEXT_BYTES {
8649        return (content.to_string(), false);
8650    }
8651    let mut end = MAX_CONTEXT_BYTES;
8652    while end > 0 && !content.is_char_boundary(end) {
8653        end -= 1;
8654    }
8655    (content[..end].to_string(), true)
8656}
8657
8658fn pending_agent_approval(
8659    agents: Option<&Vec<crate::AgentSnapshot>>,
8660) -> Option<PendingAgentApproval> {
8661    let agents = agents?;
8662    for agent in agents {
8663        let mut pending = None;
8664        for event in &agent.evidence {
8665            match event.get("type").and_then(serde_json::Value::as_str) {
8666                Some("glass_tool_approval_request") => {
8667                    let Some(frame_id) = event.get("frameId").and_then(serde_json::Value::as_str)
8668                    else {
8669                        continue;
8670                    };
8671                    pending = Some(PendingAgentApproval {
8672                        agent_id: agent.id.as_str().to_string(),
8673                        frame_id: frame_id.to_string(),
8674                        tool_name: event
8675                            .get("toolName")
8676                            .and_then(serde_json::Value::as_str)
8677                            .unwrap_or("unknown tool")
8678                            .to_string(),
8679                        arguments: event.get("arguments").cloned().unwrap_or_default(),
8680                    });
8681                }
8682                Some("glass_tool_approval_resolved") => {
8683                    let frame_id = event.get("frameId").and_then(serde_json::Value::as_str);
8684                    if pending
8685                        .as_ref()
8686                        .is_some_and(|approval| Some(approval.frame_id.as_str()) == frame_id)
8687                    {
8688                        pending = None;
8689                    }
8690                }
8691                _ => {}
8692            }
8693        }
8694        if pending.is_some() {
8695            return pending;
8696        }
8697    }
8698    None
8699}
8700
8701fn fuzzy_contains(candidate: &str, query: &str) -> bool {
8702    if query.is_empty() {
8703        return true;
8704    }
8705    let mut query = query
8706        .chars()
8707        .map(|character| character.to_ascii_lowercase());
8708    let mut expected = query.next();
8709    for character in candidate
8710        .chars()
8711        .map(|character| character.to_ascii_lowercase())
8712    {
8713        if Some(character) == expected {
8714            expected = query.next();
8715            if expected.is_none() {
8716                return true;
8717            }
8718        }
8719    }
8720    false
8721}
8722
8723fn browser_recovery_arguments(port: u16, attach: bool) -> serde_json::Value {
8724    serde_json::json!({
8725        "port": port,
8726        "attach": attach,
8727        "incognito": !attach,
8728    })
8729}
8730
8731/// Bind an ephemeral localhost port to discover a free one.
8732fn free_local_port() -> Option<u16> {
8733    std::net::TcpListener::bind((std::net::Ipv4Addr::LOCALHOST, 0))
8734        .ok()
8735        .and_then(|listener| listener.local_addr().ok())
8736        .map(|address| address.port())
8737}
8738
8739struct LspLocation {
8740    path: String,
8741    line: u32,
8742    column: u32,
8743}
8744
8745fn parse_completion_insert(value: &serde_json::Value) -> Option<String> {
8746    let items = value
8747        .get("items")
8748        .and_then(serde_json::Value::as_array)
8749        .or_else(|| value.as_array())?;
8750    let item = items.first()?;
8751    item.pointer("/textEdit/newText")
8752        .or_else(|| item.pointer("/textEdit/insert/newText"))
8753        .or_else(|| item.get("insertText"))
8754        .or_else(|| item.get("label"))
8755        .and_then(serde_json::Value::as_str)
8756        .map(str::to_string)
8757        .filter(|text| !text.is_empty())
8758}
8759
8760fn format_lsp_locations(value: &serde_json::Value) -> String {
8761    let items = value
8762        .as_array()
8763        .map(|items| items.as_slice())
8764        .unwrap_or_else(|| std::slice::from_ref(value));
8765    let mut lines = vec!["REFERENCES".to_string()];
8766    for item in items.iter().take(32) {
8767        if let Some(location) = parse_lsp_location(item) {
8768            lines.push(format!(
8769                "  {}:{}:{}",
8770                location.path, location.line, location.column
8771            ));
8772        }
8773    }
8774    if lines.len() == 1 {
8775        lines.push("  none".into());
8776    }
8777    lines.join("\n")
8778}
8779
8780fn parse_lsp_location(value: &serde_json::Value) -> Option<LspLocation> {
8781    let target = value
8782        .as_array()
8783        .and_then(|items| items.first())
8784        .unwrap_or(value);
8785    let uri = target
8786        .get("uri")
8787        .or_else(|| target.get("targetUri"))
8788        .and_then(serde_json::Value::as_str)?;
8789    let range = target
8790        .get("range")
8791        .or_else(|| target.get("targetRange"))
8792        .or_else(|| target.get("targetSelectionRange"))?;
8793    let line = range
8794        .pointer("/start/line")
8795        .and_then(serde_json::Value::as_u64)? as u32
8796        + 1;
8797    let column = range
8798        .pointer("/start/character")
8799        .and_then(serde_json::Value::as_u64)? as u32
8800        + 1;
8801    let path = uri
8802        .rsplit("://")
8803        .next()
8804        .unwrap_or(uri)
8805        .rsplit('/')
8806        .take(3)
8807        .collect::<Vec<_>>()
8808        .into_iter()
8809        .rev()
8810        .collect::<Vec<_>>()
8811        .join("/");
8812    Some(LspLocation {
8813        path: path.trim_start_matches('/').to_string(),
8814        line,
8815        column,
8816    })
8817}
8818
8819fn parse_lsp_symbols(value: &serde_json::Value) -> Vec<(String, u32)> {
8820    let mut symbols = Vec::new();
8821    let items = value
8822        .get("result")
8823        .or(Some(value))
8824        .and_then(serde_json::Value::as_array)
8825        .cloned()
8826        .unwrap_or_default();
8827    for item in items {
8828        let name = item
8829            .get("name")
8830            .and_then(serde_json::Value::as_str)
8831            .unwrap_or("symbol")
8832            .to_string();
8833        let line = item
8834            .pointer("/range/start/line")
8835            .or_else(|| item.pointer("/location/range/start/line"))
8836            .and_then(serde_json::Value::as_u64)
8837            .unwrap_or(0) as u32
8838            + 1;
8839        symbols.push((name, line));
8840    }
8841    symbols
8842}
8843
8844fn workflow_slug(name: &str) -> String {
8845    let mut slug = String::new();
8846    for character in name.chars() {
8847        if character.is_ascii_alphanumeric() {
8848            slug.push(character.to_ascii_lowercase());
8849        } else if matches!(character, '-' | '_' | ' ' | '.')
8850            && !slug.is_empty()
8851            && !slug.ends_with('-')
8852        {
8853            slug.push('-');
8854        }
8855    }
8856    let slug = slug.trim_matches('-').to_string();
8857    if slug.is_empty() {
8858        "click-path".into()
8859    } else {
8860        slug
8861    }
8862}
8863
8864fn slug_input_name(name: &str) -> String {
8865    workflow_slug(name).replace('-', "_")
8866}
8867
8868fn selection_covers(
8869    content: &str,
8870    selection: &crate::development::TextSelection,
8871    cursor: crate::development::TextPosition,
8872) -> bool {
8873    let Some(offset) = crate::development::editor::text_position_offset(content, cursor) else {
8874        return false;
8875    };
8876    let Some((start, end)) = crate::development::editor::selection_offsets(content, selection)
8877    else {
8878        return false;
8879    };
8880    offset >= start && offset <= end
8881}
8882
8883fn editor_offset(content: &str, line: u32, column: u32) -> usize {
8884    let mut offset = 0;
8885    for (index, value) in content.split_inclusive('\n').enumerate() {
8886        if index + 1 == line as usize {
8887            let column_bytes = value
8888                .trim_end_matches('\n')
8889                .char_indices()
8890                .nth(column.saturating_sub(1) as usize)
8891                .map(|(offset, _)| offset)
8892                .unwrap_or_else(|| value.trim_end_matches('\n').len());
8893            return offset + column_bytes;
8894        }
8895        offset += value.len();
8896    }
8897    content.len()
8898}
8899
8900#[cfg(test)]
8901mod tests {
8902    use super::*;
8903
8904    #[test]
8905    fn debug_thread_and_frame_packets_parse_source_locations() {
8906        let threads = parse_debug_threads(&serde_json::json!({
8907            "threads": [{"id": 1, "name": "main"}, {"id": 2, "name": "worker"}]
8908        }));
8909        assert_eq!(threads.len(), 2);
8910        assert_eq!(threads[1].name, "worker");
8911        let frames = parse_debug_frames(&serde_json::json!({
8912            "stackFrames": [{
8913                "id": 12,
8914                "name": "checkout",
8915                "line": 40,
8916                "source": {"path": "src/main.rs"}
8917            }]
8918        }));
8919        assert_eq!(frames[0].path.as_deref(), Some("src/main.rs"));
8920        assert_eq!(frames[0].line, Some(40));
8921        let scopes = parse_debug_scopes(&serde_json::json!({
8922            "scopes": [{"name": "Locals", "variablesReference": 7}]
8923        }));
8924        assert_eq!(scopes[0].variables_reference, 7);
8925        let variables = parse_debug_variables(&serde_json::json!({
8926            "variables": [{"name": "x", "value": "1"}]
8927        }));
8928        assert_eq!(variables[0].name, "x");
8929    }
8930
8931    #[test]
8932    fn quit_confirmation_requires_explicit_follow_through() {
8933        let root = std::env::temp_dir().join(format!("glass-tui-quit-{}", std::process::id()));
8934        std::fs::create_dir_all(&root).expect("create temporary workspace");
8935        let mut state =
8936            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
8937
8938        state.request_quit();
8939        assert!(state.quit_confirmation);
8940        assert!(!state.quit);
8941        assert_eq!(state.status, "Quit confirmation · Enter exits · Esc stays");
8942
8943        state.cancel_quit();
8944        assert!(!state.quit_confirmation);
8945        assert!(!state.quit);
8946
8947        state.request_quit();
8948        state.confirm_quit();
8949        assert!(!state.quit_confirmation);
8950        assert!(state.quit);
8951        assert_eq!(state.status, "Closing Glass Dev");
8952
8953        std::fs::remove_dir_all(root).expect("remove temporary workspace");
8954    }
8955    #[test]
8956    fn trust_action_menu_dispatches_keyboard_hints() {
8957        let root = std::env::temp_dir().join(format!("glass-trust-menu-{}", std::process::id()));
8958        std::fs::create_dir_all(&root).expect("create temporary workspace");
8959        let mut state =
8960            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
8961        state.surface = DevSurface::Trust;
8962
8963        state.open_menu();
8964        state.menu_selection = 0;
8965        state.run_menu_action();
8966        assert!(!state.menu_open);
8967        assert!(
8968            state
8969                .status
8970                .contains("Inspecting exact repository configuration")
8971        );
8972
8973        state.open_menu();
8974        state.menu_selection = 1;
8975        state.run_menu_action();
8976        assert_eq!(state.surface, DevSurface::Agent);
8977        assert!(
8978            state
8979                .status
8980                .contains("Workspace opened with untrusted authority")
8981        );
8982
8983        std::fs::remove_dir_all(root).expect("remove temporary workspace");
8984    }
8985
8986    #[test]
8987    fn browser_context_url_redaction_preserves_path_only() {
8988        assert_eq!(
8989            safe_browser_url("https://example.test/orders/7?token=secret#receipt"),
8990            Some("https://example.test/orders/7".into())
8991        );
8992        assert_eq!(
8993            page_origin("https://example.test/orders/7?token=secret"),
8994            Some("https://example.test".into())
8995        );
8996        assert_eq!(safe_browser_url(""), None);
8997    }
8998
8999    #[test]
9000    fn browser_recovery_offer_explains_port_collision_choices() {
9001        let offer = BrowserRecoveryOffer::from_error("address already in use on port 9222", 9222);
9002        assert!(!offer.compatible_endpoint);
9003        assert_eq!(offer.actions().len(), 3);
9004        assert!(offer.guidance().contains("preferred endpoint"));
9005
9006        let attach =
9007            BrowserRecoveryOffer::from_error("DevTools page target is available for attach", 9222);
9008        assert!(attach.compatible_endpoint);
9009        assert_eq!(attach.actions().len(), 4);
9010        assert!(attach.guidance().contains("Attach"));
9011    }
9012
9013    #[test]
9014    fn browser_recovery_attach_disables_incognito() {
9015        assert_eq!(
9016            browser_recovery_arguments(9222, true),
9017            serde_json::json!({
9018                "port": 9222,
9019                "attach": true,
9020                "incognito": false,
9021            })
9022        );
9023        assert_eq!(
9024            browser_recovery_arguments(42123, false),
9025            serde_json::json!({
9026                "port": 42123,
9027                "attach": false,
9028                "incognito": true,
9029            })
9030        );
9031    }
9032
9033    #[test]
9034    fn browser_target_picker_filters_and_redacts_urls() {
9035        let root = std::env::temp_dir().join(format!("glass-target-picker-{}", std::process::id()));
9036        std::fs::create_dir_all(&root).expect("create temporary workspace");
9037        let mut state =
9038            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9039        state.browser_workspace.replace_targets(vec![
9040            BrowserWorkspaceTarget {
9041                id: "page-docs".into(),
9042                title: "Project docs".into(),
9043                url: "https://example.test/docs?token=secret".into(),
9044                selected: false,
9045            },
9046            BrowserWorkspaceTarget {
9047                id: "page-app".into(),
9048                title: "Application".into(),
9049                url: "http://localhost:3000".into(),
9050                selected: false,
9051            },
9052        ]);
9053        state
9054            .request_browser_target_picker("docs")
9055            .expect("queue target picker");
9056        state.queued_tool_request = None;
9057        let matches = state.browser_target_matches();
9058        assert_eq!(matches, vec![0]);
9059        let view = state.browser_target_picker_view();
9060        assert!(view.contains("Project docs"));
9061        assert!(view.contains("https://example.test/docs"));
9062        assert!(!view.contains("token=secret"));
9063        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9064    }
9065    #[test]
9066    fn agent_typing_opens_composer_before_surface_aliases() {
9067        let root = std::env::temp_dir().join(format!("glass-agent-compose-{}", std::process::id()));
9068        std::fs::create_dir_all(&root).expect("create temporary workspace");
9069        let mut state =
9070            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9071        state.surface = DevSurface::Agent;
9072        state.snapshot_trust_label = "trusted".into();
9073        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
9074
9075        state.handle_printable('c');
9076
9077        assert_eq!(state.surface, DevSurface::Agent);
9078        assert!(state.composer_mode);
9079        assert_eq!(state.composer_input, "c");
9080        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9081    }
9082
9083    #[test]
9084    fn leading_agent_message_characters_are_not_commands() {
9085        for character in ['a', 'q', 's', 'u', 'l', 'i', 'n'] {
9086            let root = std::env::temp_dir().join(format!(
9087                "glass-agent-leading-{character}-{}",
9088                std::process::id()
9089            ));
9090            std::fs::create_dir_all(&root).expect("create temporary workspace");
9091            let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
9092                .expect("open temporary workspace");
9093            state.surface = DevSurface::Agent;
9094            state.snapshot_trust_label = "trusted".into();
9095            state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
9096
9097            state.handle_printable(character);
9098
9099            assert!(
9100                state.composer_mode,
9101                "character {character:?} did not open composer"
9102            );
9103            assert_eq!(state.composer_input, character.to_string());
9104            std::fs::remove_dir_all(root).expect("remove temporary workspace");
9105        }
9106    }
9107    #[test]
9108    fn action_shortcut_opens_menu_without_stealing_ready_agent_text() {
9109        let root =
9110            std::env::temp_dir().join(format!("glass-action-shortcut-{}", std::process::id()));
9111        std::fs::create_dir_all(&root).expect("create temporary workspace");
9112        let mut state =
9113            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9114
9115        state.surface = DevSurface::Terminal;
9116        state.handle_printable('a');
9117        assert!(state.menu_open);
9118        state.close_menu();
9119
9120        state.surface = DevSurface::Agent;
9121        state.snapshot_trust_label = "trusted".into();
9122        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
9123        state.handle_printable('a');
9124        assert!(state.composer_mode);
9125        assert_eq!(state.composer_input, "a");
9126
9127        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9128    }
9129
9130    #[test]
9131    fn typed_open_in_palette_runs_instead_of_fuzzy_action() {
9132        let root = std::env::temp_dir().join(format!("glass-typed-open-{}", std::process::id()));
9133        std::fs::create_dir_all(&root).expect("create temporary workspace");
9134        let mut state =
9135            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9136        state.files = vec!["src/lib.rs".into(), "Cargo.toml".into()];
9137        state.open_palette();
9138        state.command_input = "open".into();
9139        state.command_cursor = 4;
9140        let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
9141        state.submit_palette(&mut worker);
9142        drop(worker);
9143        assert!(
9144            state.file_picker_open,
9145            "typed :open must open the file picker, not a fuzzy action"
9146        );
9147        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9148    }
9149
9150    #[test]
9151    fn colon_opens_palette_from_every_surface() {
9152        for surface in DevSurface::ALL {
9153            let root = std::env::temp_dir().join(format!(
9154                "glass-palette-surface-{}-{}",
9155                surface.label(),
9156                std::process::id()
9157            ));
9158            std::fs::create_dir_all(&root).expect("create temporary workspace");
9159            let mut state = DevTuiState::open_for_tui(&root, TuiLayout::Desktop)
9160                .expect("open temporary workspace");
9161            state.surface = surface;
9162
9163            state.handle_printable(':');
9164
9165            assert!(
9166                state.command_mode,
9167                "colon did not open palette on {surface:?}"
9168            );
9169            assert!(!state.composer_mode);
9170            std::fs::remove_dir_all(root).expect("remove temporary workspace");
9171        }
9172    }
9173
9174    #[test]
9175    fn file_picker_filters_and_opens_a_matching_path() {
9176        let root = std::env::temp_dir().join(format!("glass-file-picker-{}", std::process::id()));
9177        std::fs::create_dir_all(root.join("src")).expect("create temporary workspace");
9178        std::fs::write(root.join("src/lib.rs"), "fn lib() {}\n").unwrap();
9179        std::fs::write(root.join("src/main.rs"), "fn main() {}\n").unwrap();
9180        let mut state =
9181            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9182        state.files = vec![
9183            "src/lib.rs".into(),
9184            "src/main.rs".into(),
9185            "README.md".into(),
9186        ];
9187        state.open_file_picker();
9188        assert!(state.file_picker_open);
9189        for character in "main".chars() {
9190            state.insert_file_picker_char(character);
9191        }
9192        let matches = state.file_picker_matches();
9193        assert_eq!(matches.len(), 1);
9194        assert_eq!(state.files[matches[0]], "src/main.rs");
9195        state.submit_file_picker();
9196        assert!(!state.file_picker_open);
9197        assert_eq!(state.focused_editor_path, "src/main.rs");
9198        assert!(state.code_edit_mode);
9199        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9200    }
9201
9202    #[test]
9203    fn composer_shift_enter_and_history_are_local_edits() {
9204        let root =
9205            std::env::temp_dir().join(format!("glass-composer-history-{}", std::process::id()));
9206        std::fs::create_dir_all(&root).expect("create temporary workspace");
9207        let mut state =
9208            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9209        state.open_composer();
9210        state.insert_composer_text("first");
9211        state.remember_composer_history("first");
9212        state.composer_input.clear();
9213        state.composer_cursor = 0;
9214        state.insert_composer_text("second");
9215        state.navigate_composer_history(true);
9216        assert_eq!(state.composer_input, "first");
9217        state.navigate_composer_history(false);
9218        assert_eq!(state.composer_input, "second");
9219        state.insert_composer_newline();
9220        assert_eq!(state.composer_input, "second\n");
9221        state.navigate_composer_history(true);
9222        assert!(
9223            state.composer_cursor < state.composer_input.len(),
9224            "Up on a wrapped draft should move to the previous line before history"
9225        );
9226        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9227    }
9228
9229    #[test]
9230    fn external_delegate_result_is_visible_in_tui_status() {
9231        let root =
9232            std::env::temp_dir().join(format!("glass-delegate-status-{}", std::process::id()));
9233        std::fs::create_dir_all(&root).expect("create temporary workspace");
9234        let mut state =
9235            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9236        state.running_tool_job = Some(7);
9237        state.apply_tool_job_result(super::super::snapshot::ToolJobResult {
9238            id: 7,
9239            tool: "glass.agent.delegate".into(),
9240            result: Ok(serde_json::json!({
9241                "harness": "codex",
9242                "success": true,
9243                "timedOut": false,
9244                "output": "REAL_RESULT\nsecond line\n",
9245                "stderr": "",
9246            })),
9247        });
9248        assert!(state.status.contains("Temporary codex completed"));
9249        assert!(state.status.contains("REAL_RESULT"));
9250        assert_eq!(state.surface, DevSurface::Agent);
9251        assert!(state.running_tool_job.is_none());
9252        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9253    }
9254
9255    #[test]
9256    fn composer_tab_completes_file_mentions_and_submit_pins_the_path() {
9257        let root =
9258            std::env::temp_dir().join(format!("glass-composer-mention-{}", std::process::id()));
9259        std::fs::create_dir_all(&root).expect("create temporary workspace");
9260        let mut state =
9261            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9262        state.files = vec!["src/main.rs".into(), "src/lib.rs".into()];
9263        state.focused_editor_path = "src/main.rs".into();
9264        state.open_composer();
9265        state.insert_composer_text("inspect @fi");
9266        state.complete_composer_mention();
9267        assert_eq!(state.composer_input, "inspect @file");
9268        state.complete_composer_mention();
9269        assert_eq!(state.composer_input, "inspect @file:src/main.rs");
9270        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9271    }
9272
9273    #[test]
9274    fn editor_gutter_marks_open_comments_on_the_focused_buffer() {
9275        let root = std::env::temp_dir().join(format!(
9276            "glass-editor-comment-gutter-{}",
9277            std::process::id()
9278        ));
9279        std::fs::create_dir_all(&root).expect("create temporary workspace");
9280        let mut state =
9281            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9282        state.focused_editor_path = "src/main.rs".into();
9283        state
9284            .editor_comments
9285            .push(crate::development::EditorComment {
9286                id: "comment-1".into(),
9287                path: "src/main.rs".into(),
9288                start_line: 4,
9289                end_line: 4,
9290                text: "simplify this".into(),
9291                actor: crate::development::Actor::local(),
9292                state: crate::development::EditorCommentState::Open,
9293                created_revision: 1,
9294                updated_revision: 1,
9295            });
9296        let marks = state.editor_gutter_marks();
9297        assert!(marks.contains(&(4, native::GutterMark::Comment)));
9298        let notes = state.editor_source_notes();
9299        assert!(
9300            notes
9301                .iter()
9302                .any(|(line, note)| *line == 4 && note.contains("simplify this"))
9303        );
9304        state.focused_editor_line = 4;
9305        state.show_comment_thread();
9306        assert!(
9307            state
9308                .editor_engine
9309                .overlay
9310                .as_deref()
9311                .is_some_and(|overlay| overlay.contains("simplify this"))
9312        );
9313        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9314    }
9315
9316    #[test]
9317    fn gutter_marks_diagnostics_and_proof_on_source_lines() {
9318        let root = std::env::temp_dir().join(format!("glass-gutter-proof-{}", std::process::id()));
9319        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9320        std::fs::write(root.join("src/main.rs"), "fn main() {}\nfn extra() {}\n")
9321            .expect("write source");
9322        let mut state =
9323            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9324        state.focused_editor_path = "src/main.rs".into();
9325        state.focused_editor_line = 2;
9326        state
9327            .editor_diagnostics
9328            .push(crate::development::LanguageDiagnostic {
9329                path: "src/main.rs".into(),
9330                start: crate::development::DiagnosticPosition {
9331                    line: 0,
9332                    character: 3,
9333                },
9334                end: crate::development::DiagnosticPosition {
9335                    line: 0,
9336                    character: 7,
9337                },
9338                severity: Some(1),
9339                code: None,
9340                source: Some("rustc".into()),
9341                message: "unused variable".into(),
9342            });
9343        state
9344            .ws_mut()
9345            .expect("workspace lock")
9346            .project_mut()
9347            .link_runtime_source(
9348                "action.main",
9349                "src/main.rs",
9350                1,
9351                1,
9352                crate::development::LinkProvenance::ExplicitMarker,
9353                "handler",
9354                1.0,
9355                crate::development::Actor::local(),
9356            )
9357            .expect("link");
9358        state.last_proof_ok = Some(true);
9359        let marks = state.editor_gutter_marks();
9360        assert!(
9361            marks.contains(&(1, native::GutterMark::Lsp)),
9362            "diagnostic is on LSP line 0 → editor line 1: {marks:?}"
9363        );
9364        assert!(
9365            marks.contains(&(1, native::GutterMark::Proof)),
9366            "proof sits on the handler, not the cursor: {marks:?}"
9367        );
9368        assert!(!marks.contains(&(2, native::GutterMark::Proof)));
9369        let notes = state.editor_source_notes();
9370        assert!(
9371            notes
9372                .iter()
9373                .any(|(line, note)| *line == 1 && note.contains("unused variable"))
9374        );
9375        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9376    }
9377
9378    #[test]
9379    fn page_gutter_marks_graph_linked_handlers() {
9380        let root = std::env::temp_dir().join(format!("glass-page-gutter-{}", std::process::id()));
9381        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9382        std::fs::write(root.join("src/button.tsx"), "export function Pay() {}\n")
9383            .expect("write source");
9384        let mut state =
9385            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9386        state
9387            .ws_mut()
9388            .expect("workspace lock")
9389            .project_mut()
9390            .link_runtime_source(
9391                "action.checkout.submit",
9392                "src/button.tsx",
9393                1,
9394                1,
9395                crate::development::LinkProvenance::ExplicitMarker,
9396                "test link",
9397                1.0,
9398                crate::development::Actor::local(),
9399            )
9400            .expect("link source");
9401        state.focused_editor_path = "src/button.tsx".into();
9402        let marks = state.editor_gutter_marks();
9403        assert!(marks.contains(&(1, native::GutterMark::Page)));
9404        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9405    }
9406
9407    #[test]
9408    fn gp_navigates_to_the_inferred_app_route() {
9409        let root = std::env::temp_dir().join(format!("glass-gp-app-{}", std::process::id()));
9410        std::fs::create_dir_all(&root).expect("create temporary workspace");
9411        let mut state =
9412            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9413        state.focused_editor_path = "app/settings/page.tsx".into();
9414        state.focused_editor_line = 1;
9415        state.process_urls = vec!["http://localhost:3000/".into()];
9416        state.jump_page_from_source();
9417        assert_eq!(
9418            state.pending_browser_navigation.as_deref(),
9419            Some("http://localhost:3000/settings")
9420        );
9421        assert_eq!(state.surface, DevSurface::App);
9422        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9423    }
9424
9425    #[test]
9426    fn g_on_app_opens_the_linked_source() {
9427        let root = std::env::temp_dir().join(format!("glass-app-source-{}", std::process::id()));
9428        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9429        std::fs::write(
9430            root.join("src/button.tsx"),
9431            "<button data-glass-entity=\"action.checkout.submit\">Pay</button>\n",
9432        )
9433        .expect("write source");
9434        let mut state =
9435            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9436        state.files = vec!["src/button.tsx".into()];
9437        state.browser_workspace.replace_entities(
9438            1,
9439            vec![BrowserWorkspaceEntity {
9440                reference: "action.checkout.submit".into(),
9441                role: "button".into(),
9442                name: "Pay".into(),
9443                actionable: true,
9444                revision: 1,
9445            }],
9446        );
9447        state.browser_workspace.state_mut().selected_entity = Some(0);
9448        state.jump_source_from_page();
9449        assert_eq!(state.focused_editor_path, "src/button.tsx");
9450        assert_eq!(state.focused_editor_line, 1);
9451        assert!(state.code_edit_mode);
9452        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9453    }
9454
9455    #[test]
9456    fn hosted_fim_stub_fills_an_empty_block() {
9457        let root = std::env::temp_dir().join(format!("glass-fim-stub-{}", std::process::id()));
9458        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9459        std::fs::write(
9460            root.join("glass.toml"),
9461            "[editor.fim]\nendpoint = \"stub://test\"\nmodel = \"stub\"\n",
9462        )
9463        .expect("write fim config");
9464        std::fs::write(root.join("src/main.rs"), "fn main() {\n    \n}\n").expect("write source");
9465        let mut state =
9466            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9467        state
9468            .ws_mut()
9469            .expect("lock")
9470            .project_mut()
9471            .open_buffer("src/main.rs", crate::development::Actor::local())
9472            .expect("open");
9473        state.refresh_editor_projection();
9474        state
9475            .ws_mut()
9476            .expect("lock")
9477            .project_mut()
9478            .set_buffer_cursor("src/main.rs", 2, 5)
9479            .expect("cursor");
9480        state.refresh_editor_projection();
9481        state.request_ghost_from_line();
9482        let mut attempts = 0;
9483        while state.editor_engine.ghost.is_none() && attempts < 50 {
9484            let _ = state.tick_fim();
9485            std::thread::sleep(std::time::Duration::from_millis(5));
9486            attempts += 1;
9487        }
9488        assert_eq!(
9489            state
9490                .editor_engine
9491                .ghost
9492                .as_ref()
9493                .map(|ghost| ghost.text.as_str()),
9494            Some("todo!()"),
9495            "configured stub FIM should fill the empty block"
9496        );
9497        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9498    }
9499
9500    #[test]
9501    fn ghost_tab_jumps_to_the_next_incomplete_ident() {
9502        let root = std::env::temp_dir().join(format!("glass-ghost-next-{}", std::process::id()));
9503        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9504        let source = "fn hello_world() {}\nfn hello_\nfn greet_user() {}\nfn greet_\n";
9505        std::fs::write(root.join("src/main.rs"), source).expect("write source");
9506        let mut state =
9507            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9508        state
9509            .ws_mut()
9510            .expect("workspace lock")
9511            .project_mut()
9512            .open_buffer("src/main.rs", crate::development::Actor::local())
9513            .expect("open buffer");
9514        state.refresh_editor_projection();
9515        state.enter_code_edit();
9516        let _ = state.set_editor_cursor(
9517            "src/main.rs",
9518            crate::development::TextPosition {
9519                line: 2,
9520                column: 10,
9521            },
9522            false,
9523        );
9524        state.refresh_editor_projection();
9525        state.editor_engine.ghost = Some(GhostText {
9526            text: "world".into(),
9527        });
9528        state.edit_code_key(
9529            crossterm::event::KeyCode::Tab,
9530            crossterm::event::KeyModifiers::NONE,
9531        );
9532        assert!(
9533            state.focused_editor_content.contains("fn hello_world\n"),
9534            "tab should apply the ghost: {}",
9535            state.focused_editor_content
9536        );
9537        assert_eq!(state.focused_editor_line, 4);
9538        assert_eq!(
9539            state
9540                .editor_engine
9541                .ghost
9542                .as_ref()
9543                .map(|ghost| ghost.text.as_str()),
9544            Some("user")
9545        );
9546        assert!(state.status.contains("next edit"));
9547        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9548    }
9549
9550    #[test]
9551    fn crew_tool_result_stores_the_wake_artifact() {
9552        let root = std::env::temp_dir().join(format!("glass-crew-wake-tui-{}", std::process::id()));
9553        std::fs::create_dir_all(&root).expect("create temporary workspace");
9554        let mut state =
9555            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9556        state.running_tool_job = Some(3);
9557        state.apply_tool_job_result(super::super::snapshot::ToolJobResult {
9558            id: 3,
9559            tool: "glass.task.crew".into(),
9560            result: Ok(serde_json::json!({
9561                "goal": "add settings toggle",
9562                "wake": {
9563                    "id": "add-settings-toggle",
9564                    "goal": "add settings toggle",
9565                    "worktree": "/tmp/worktree",
9566                    "checkpoint": "before-crew:add settings toggle",
9567                    "createdAtMs": 1,
9568                    "tasks": [{"id":"task-0001","role":"architect","title":"architect: add settings toggle","state":"queued"}]
9569                }
9570            })),
9571        });
9572        let wake = state.last_crew_wake.expect("wake");
9573        assert!(wake.contains("WAKE add-settings-toggle"));
9574        assert!(wake.contains("architect task-0001 queued"));
9575        assert_eq!(state.surface, DevSurface::Tasks);
9576        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9577    }
9578
9579    #[test]
9580    fn review_accept_applies_the_wake_proposal_pack() {
9581        let root = std::env::temp_dir().join(format!("glass-review-pack-{}", std::process::id()));
9582        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9583        std::fs::write(root.join("src/main.rs"), "fn main() {}\n").expect("write source");
9584        let mut state =
9585            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9586        state
9587            .ws_mut()
9588            .expect("workspace lock")
9589            .project_mut()
9590            .open_buffer("src/main.rs", crate::development::Actor::local())
9591            .expect("open buffer");
9592        state
9593            .ws_mut()
9594            .expect("workspace lock")
9595            .project_mut()
9596            .propose_editor_change(
9597                "src/main.rs",
9598                "fn main() {}\n".into(),
9599                "fn main() { 1 }\n".into(),
9600                "add one".into(),
9601                crate::development::Actor::local(),
9602            )
9603            .expect("propose");
9604        state.refresh_editor_projection();
9605        let accepted = state.accept_review_pack().expect("accept pack");
9606        assert!(accepted.contains("1 proposal"));
9607        assert_eq!(
9608            state.focused_editor_content, "fn main() { 1 }\n",
9609            "pack accept must write the proposed buffer"
9610        );
9611        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9612    }
9613
9614    #[test]
9615    fn gm_adds_structural_carets_and_inserts_at_each() {
9616        let root = std::env::temp_dir().join(format!("glass-multi-cursor-{}", std::process::id()));
9617        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9618        std::fs::write(root.join("src/main.rs"), "fn foo() { foo(); foo }\n").expect("write");
9619        let mut state =
9620            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9621        state
9622            .ws_mut()
9623            .expect("lock")
9624            .project_mut()
9625            .open_buffer("src/main.rs", crate::development::Actor::local())
9626            .expect("open");
9627        state.refresh_editor_projection();
9628        state.enter_code_edit();
9629        state.handle_editor_escape();
9630        state
9631            .ws_mut()
9632            .expect("lock")
9633            .project_mut()
9634            .set_buffer_cursor("src/main.rs", 1, 4)
9635            .expect("cursor");
9636        state.refresh_editor_projection();
9637        state.edit_code_key(
9638            crossterm::event::KeyCode::Char('g'),
9639            crossterm::event::KeyModifiers::empty(),
9640        );
9641        state.edit_code_key(
9642            crossterm::event::KeyCode::Char('m'),
9643            crossterm::event::KeyModifiers::empty(),
9644        );
9645        assert_eq!(
9646            state.editor_engine.extra_selections.len(),
9647            2,
9648            "gm should add a caret on every other foo"
9649        );
9650        state.edit_code_key(
9651            crossterm::event::KeyCode::Char('i'),
9652            crossterm::event::KeyModifiers::empty(),
9653        );
9654        state.edit_code_key(
9655            crossterm::event::KeyCode::Char('X'),
9656            crossterm::event::KeyModifiers::empty(),
9657        );
9658        let content = state.focused_editor_content.clone();
9659        assert_eq!(
9660            content.matches('X').count(),
9661            3,
9662            "insert should hit every caret: {content}"
9663        );
9664        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9665    }
9666
9667    #[test]
9668    fn app_enter_records_role_name_locators_into_a_workflow_draft() {
9669        let root =
9670            std::env::temp_dir().join(format!("glass-workflow-record-{}", std::process::id()));
9671        std::fs::create_dir_all(&root).expect("create temporary workspace");
9672        let mut state =
9673            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9674        state.browser_workspace.replace_entities(
9675            7,
9676            vec![BrowserWorkspaceEntity {
9677                reference: "r7:save".into(),
9678                role: "button".into(),
9679                name: "Save settings".into(),
9680                actionable: true,
9681                revision: 7,
9682            }],
9683        );
9684        state
9685            .start_workflow_recording("Save Settings")
9686            .expect("start recording");
9687        state.queue_browser_intent(BrowserWorkspaceIntent::ActivateSelected);
9688        let draft = serde_json::to_string(
9689            state
9690                .workflow_recording
9691                .as_ref()
9692                .expect("recording")
9693                .recorder
9694                .draft(),
9695        )
9696        .expect("serialize draft");
9697        assert!(draft.contains("role=button;name=Save settings"));
9698        let stopped = state.stop_workflow_recording().expect("stop recording");
9699        assert!(stopped.contains("1 step"));
9700        let path = root.join(".glass/workflows/save-settings.draft.json");
9701        let persisted = std::fs::read_to_string(&path).expect("read draft");
9702        assert!(persisted.contains("role=button;name=Save settings"));
9703        assert!(persisted.contains("\"reviewRequired\": true"));
9704        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9705    }
9706
9707    #[test]
9708    fn agent_editor_context_attaches_unsaved_buffer_and_inline_prompt() {
9709        let root =
9710            std::env::temp_dir().join(format!("glass-editor-agent-context-{}", std::process::id()));
9711        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9712        std::fs::write(root.join("src/main.rs"), "fn main() {}\n").expect("write source");
9713        let mut state =
9714            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9715        state
9716            .ws_mut()
9717            .expect("workspace lock")
9718            .project_mut()
9719            .open_buffer("src/main.rs", crate::development::Actor::local())
9720            .expect("open editor buffer");
9721        state
9722            .ws_mut()
9723            .expect("workspace lock")
9724            .project_mut()
9725            .edit_buffer(
9726                "src/main.rs",
9727                "fn main() {\n    println!(\"unsaved\");\n}\n".into(),
9728                crate::development::Actor::local(),
9729            )
9730            .expect("edit buffer");
9731        state.refresh_editor_projection();
9732
9733        let context = state.agent_editor_context();
9734        assert_eq!(context["focusedPath"], "src/main.rs");
9735        assert_eq!(
9736            context["focusedBuffer"]["content"],
9737            "fn main() {\n    println!(\"unsaved\");\n}\n"
9738        );
9739        assert_eq!(context["focusedBuffer"]["dirty"], true);
9740
9741        state.enter_code_edit();
9742        state.edit_code_key(
9743            crossterm::event::KeyCode::Char('a'),
9744            crossterm::event::KeyModifiers::ALT,
9745        );
9746        assert_eq!(state.surface, DevSurface::Code);
9747        assert!(state.composer_mode);
9748        assert!(!state.code_edit_mode);
9749        assert!(state.composer_input.contains("src/main.rs:1:1"));
9750        assert!(state.composer_input.contains("Do not edit files"));
9751
9752        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9753    }
9754
9755    #[test]
9756    fn editor_soft_wrap_toggle_scrolls_visual_rows_and_resets_horizontal_scroll() {
9757        let root =
9758            std::env::temp_dir().join(format!("glass-editor-soft-wrap-{}", std::process::id()));
9759        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9760        let content = format!("{}\n", "word ".repeat(80));
9761        std::fs::write(root.join("src/main.rs"), content).expect("write source");
9762        let mut state =
9763            DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open temporary workspace");
9764        state
9765            .ws_mut()
9766            .expect("workspace lock")
9767            .project_mut()
9768            .open_buffer("src/main.rs", crate::development::Actor::local())
9769            .expect("open editor buffer");
9770        state
9771            .ws_mut()
9772            .expect("workspace lock")
9773            .project_mut()
9774            .set_buffer_cursor("src/main.rs", 1, 180)
9775            .expect("set editor cursor");
9776        state.refresh_editor_projection();
9777        state.set_terminal_size(32, 16);
9778        state.enter_code_edit();
9779        state.edit_code_key(
9780            crossterm::event::KeyCode::Char('w'),
9781            crossterm::event::KeyModifiers::ALT,
9782        );
9783
9784        assert!(state.editor_soft_wrap);
9785        assert!(state.editor_scroll_line > 0);
9786        assert_eq!(state.editor_scroll_column, 0);
9787        assert!(state.status.contains("Soft wrap ON"));
9788
9789        state.edit_code_key(
9790            crossterm::event::KeyCode::Char('w'),
9791            crossterm::event::KeyModifiers::ALT,
9792        );
9793        assert!(!state.editor_soft_wrap);
9794        assert!(state.editor_scroll_column > 0);
9795        assert!(state.status.contains("Soft wrap OFF"));
9796        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9797    }
9798
9799    #[test]
9800    fn editor_cursor_scroll_matches_fullscreen_source_height() {
9801        let root =
9802            std::env::temp_dir().join(format!("glass-editor-viewport-{}", std::process::id()));
9803        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9804        let content = (1..=30)
9805            .map(|line| format!("line {line}\n"))
9806            .collect::<String>();
9807        std::fs::write(root.join("src/main.rs"), content).expect("write source");
9808        let mut state =
9809            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9810        state
9811            .ws_mut()
9812            .expect("workspace lock")
9813            .project_mut()
9814            .open_buffer("src/main.rs", crate::development::Actor::local())
9815            .expect("open editor buffer");
9816        state
9817            .ws_mut()
9818            .expect("workspace lock")
9819            .project_mut()
9820            .set_buffer_cursor("src/main.rs", 23, 1)
9821            .expect("set editor cursor");
9822        state.refresh_editor_projection();
9823        state.editor_scroll_line = 0;
9824        state.set_terminal_size(100, 30);
9825
9826        assert_eq!(state.focused_editor_line, 23);
9827        assert_eq!(
9828            state.editor_scroll_line, 1,
9829            "line 23 must scroll into the 22-row source viewport"
9830        );
9831        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9832    }
9833
9834    #[test]
9835    fn editor_shift_selection_replaces_text_and_clears_anchor() {
9836        let root =
9837            std::env::temp_dir().join(format!("glass-editor-selection-{}", std::process::id()));
9838        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9839        std::fs::write(root.join("src/main.rs"), "alpha\nbeta\n").expect("write source");
9840        let mut state =
9841            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9842        state
9843            .ws_mut()
9844            .expect("workspace lock")
9845            .project_mut()
9846            .open_buffer("src/main.rs", crate::development::Actor::local())
9847            .expect("open editor buffer");
9848        state.refresh_editor_projection();
9849        state.enter_code_edit();
9850        for _ in 0..5 {
9851            state.edit_code_key(
9852                crossterm::event::KeyCode::Right,
9853                crossterm::event::KeyModifiers::SHIFT,
9854            );
9855        }
9856        assert!(
9857            state
9858                .focused_editor_selection
9859                .as_ref()
9860                .is_some_and(|selection| !selection.is_empty())
9861        );
9862        state.edit_code_key(
9863            crossterm::event::KeyCode::Char('X'),
9864            crossterm::event::KeyModifiers::empty(),
9865        );
9866        let buffer = state.focused_buffer().expect("focused editor buffer");
9867        assert_eq!(buffer.content, "X\nbeta\n");
9868        assert_eq!((buffer.cursor_line, buffer.cursor_column), (1, 2));
9869        assert!(buffer.selection.is_none());
9870        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9871    }
9872
9873    #[test]
9874    fn editor_exit_prompts_save_discard_and_discard_quit() {
9875        let root = std::env::temp_dir().join(format!("glass-editor-exit-{}", std::process::id()));
9876        std::fs::create_dir_all(root.join("src")).expect("create source directory");
9877        let original = "fn main() {}\n";
9878        std::fs::write(root.join("src/main.rs"), original).expect("write source");
9879        let mut state =
9880            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9881        state
9882            .ws_mut()
9883            .expect("workspace lock")
9884            .project_mut()
9885            .open_buffer("src/main.rs", crate::development::Actor::local())
9886            .expect("open editor buffer");
9887        state.refresh_editor_projection();
9888        state.enter_code_edit();
9889        state.edit_code_key(
9890            crossterm::event::KeyCode::Char('#'),
9891            crossterm::event::KeyModifiers::NONE,
9892        );
9893        state.request_editor_exit();
9894        assert_eq!(state.editor_exit_prompt, Some(EditorExitPrompt::Unsaved));
9895        state.handle_editor_exit_key(crossterm::event::KeyCode::Char('d'));
9896        assert!(!state.code_edit_mode);
9897        assert_eq!(
9898            std::fs::read_to_string(root.join("src/main.rs")).expect("read source"),
9899            original
9900        );
9901
9902        state.enter_code_edit();
9903        state.edit_code_key(
9904            crossterm::event::KeyCode::Char('#'),
9905            crossterm::event::KeyModifiers::NONE,
9906        );
9907        state.request_editor_exit();
9908        state.handle_editor_exit_key(crossterm::event::KeyCode::Char('s'));
9909        assert!(!state.code_edit_mode);
9910        assert!(
9911            std::fs::read_to_string(root.join("src/main.rs"))
9912                .expect("read saved source")
9913                .starts_with('#')
9914        );
9915        let saved = std::fs::read_to_string(root.join("src/main.rs")).expect("read saved source");
9916
9917        state.enter_code_edit();
9918        state.edit_code_key(
9919            crossterm::event::KeyCode::Char('!'),
9920            crossterm::event::KeyModifiers::NONE,
9921        );
9922        state.request_editor_exit();
9923        state.handle_editor_exit_key(crossterm::event::KeyCode::Char('q'));
9924        assert!(state.quit);
9925        assert_eq!(
9926            std::fs::read_to_string(root.join("src/main.rs")).expect("read discarded source"),
9927            saved
9928        );
9929        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9930    }
9931
9932    #[test]
9933    fn conversation_view_does_not_echo_pending_message_after_snapshot() {
9934        let root = std::env::temp_dir().join(format!("glass-chat-merge-{}", std::process::id()));
9935        std::fs::create_dir_all(&root).expect("create temporary workspace");
9936        let mut state =
9937            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9938        state.agent_conversation = "YOU\ninspect the failing test\n\nGLASS AGENT\nworking".into();
9939        state.pending_chat_messages.push(PendingChatMessage {
9940            text: "inspect the failing test".into(),
9941            state: ChatMessageState::Sent,
9942            job_id: None,
9943            error: None,
9944        });
9945
9946        let view = state.conversation_view();
9947        assert_eq!(view.matches("YOU\ninspect the failing test").count(), 1);
9948        assert!(!view.contains("Glass Agent is thinking"));
9949
9950        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9951    }
9952
9953    #[test]
9954    fn palette_filters_actions_and_prefills_selected_arguments() {
9955        let root =
9956            std::env::temp_dir().join(format!("glass-palette-actions-{}", std::process::id()));
9957        std::fs::create_dir_all(&root).expect("create temporary workspace");
9958        let mut state =
9959            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
9960        state.surface = DevSurface::Agent;
9961        state.open_palette();
9962        state.insert_palette_text("agent setup");
9963        assert_eq!(
9964            state.selected_palette_action().map(|action| action.label),
9965            Some("Setup Pi runtime")
9966        );
9967        state.move_palette_selection(1);
9968        assert_eq!(
9969            state.selected_palette_action().map(|action| action.label),
9970            Some("Authenticate")
9971        );
9972
9973        state.open_palette_with("agent rewind ENTRY_ID");
9974        let action = state.selected_palette_action().expect("rewind action");
9975        assert_eq!(action.label, "Rewind Pi session");
9976        assert!(state.prepare_palette_action(action).is_none());
9977        assert!(state.command_mode);
9978        assert_eq!(state.command_input, "agent rewind ");
9979        assert!(state.status.contains("required value"));
9980
9981        std::fs::remove_dir_all(root).expect("remove temporary workspace");
9982    }
9983
9984    #[test]
9985    fn arrow_surface_cycle_matches_layout_order() {
9986        let root =
9987            std::env::temp_dir().join(format!("glass-surface-arrows-{}", std::process::id()));
9988        std::fs::create_dir_all(&root).expect("create temporary workspace");
9989        let mut desktop =
9990            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open desktop workspace");
9991        desktop.surface = DevSurface::Agent;
9992        desktop.next_surface();
9993        assert_eq!(desktop.surface, DevSurface::Code);
9994        assert_eq!(desktop.status, "Code selected");
9995        desktop.previous_surface();
9996        assert_eq!(desktop.surface, DevSurface::Agent);
9997        desktop.surface = DevSurface::Debug;
9998        desktop.next_surface();
9999        assert_eq!(desktop.surface, DevSurface::More);
10000        desktop.next_surface();
10001        assert_eq!(desktop.surface, DevSurface::Agent);
10002
10003        let mut phone =
10004            DevTuiState::open_for_tui(&root, TuiLayout::Mobile).expect("open phone workspace");
10005        phone.surface = DevSurface::Agent;
10006        phone.previous_surface();
10007        assert_eq!(phone.surface, DevSurface::More);
10008        assert_eq!(phone.status, "More selected");
10009        phone.next_surface();
10010        assert_eq!(phone.surface, DevSurface::Agent);
10011
10012        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10013    }
10014
10015    #[test]
10016    fn composer_queues_follow_up_while_a_send_is_in_flight() {
10017        let root = std::env::temp_dir().join(format!("glass-follow-up-{}", std::process::id()));
10018        std::fs::create_dir_all(&root).expect("create temporary workspace");
10019        let mut state =
10020            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10021        state.surface = DevSurface::Agent;
10022        state.snapshot_trust_label = "trusted".into();
10023        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
10024        state.agent_send_job = Some(9);
10025        state.open_composer();
10026        state.composer_input = "keep going".into();
10027        state.composer_cursor = state.composer_input.len();
10028        let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
10029        state.submit_composer(&mut worker);
10030        assert_ne!(
10031            state.status,
10032            "Background operation running · message kept in composer"
10033        );
10034        assert!(
10035            state.status.contains("Queued follow-up")
10036                || state.status.contains("thinking")
10037                || state.status.contains("retry")
10038                || state.status.contains("Sent")
10039        );
10040        drop(worker);
10041        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10042    }
10043
10044    #[test]
10045    fn composer_slash_compact_routes_to_pi_compact() {
10046        let root = std::env::temp_dir().join(format!("glass-slash-{}", std::process::id()));
10047        std::fs::create_dir_all(&root).expect("create temporary workspace");
10048        let mut state =
10049            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10050        state.surface = DevSurface::Agent;
10051        state.snapshot_trust_label = "trusted".into();
10052        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
10053        state.open_composer();
10054        state.composer_input = "/compact keep the review".into();
10055        state.composer_cursor = state.composer_input.len();
10056        let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
10057        state.submit_composer(&mut worker);
10058        assert!(
10059            state.status.contains("glass.agent.compact")
10060                || state.status.contains("unavailable")
10061                || state.status.contains("failed")
10062        );
10063        drop(worker);
10064        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10065    }
10066
10067    #[test]
10068    fn transcript_fork_uses_selected_entry_id() {
10069        let root = std::env::temp_dir().join(format!("glass-fork-{}", std::process::id()));
10070        std::fs::create_dir_all(&root).expect("create temporary workspace");
10071        let mut state =
10072            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10073        state.conversation_items = vec![super::super::projection::ConversationEntry {
10074            kind: super::super::projection::ConversationKind::User,
10075            text: "ship the review".into(),
10076            streaming: false,
10077            entry_id: Some("entry-7".into()),
10078            tool_name: None,
10079        }];
10080        state.transcript_selection = 0;
10081        let mut worker = super::super::snapshot::SnapshotWorker::spawn(&state);
10082        state.fork_selected_transcript(&mut worker);
10083        assert!(
10084            state.status.contains("entry-7")
10085                || state.status.contains("glass.agent.fork")
10086                || state.status.contains("branch")
10087        );
10088        drop(worker);
10089        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10090    }
10091
10092    #[test]
10093    fn agent_chrome_and_session_picker_and_context_chips() {
10094        let root = std::env::temp_dir().join(format!("glass-chrome-{}", std::process::id()));
10095        std::fs::create_dir_all(&root).expect("create temporary workspace");
10096        let mut state =
10097            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10098        state.agent_model = "xai/grok".into();
10099        state.agent_thinking = "medium".into();
10100        state.agent_session_name = "review".into();
10101        state.agent_token_summary = "12 in · 40 out".into();
10102        state.focused_editor_path = "src/lib.rs".into();
10103        state.composer_steer = true;
10104        let chrome = state.agent_chrome_line();
10105        assert!(chrome.contains("xai/grok"));
10106        assert!(chrome.contains("think medium"));
10107        assert!(chrome.contains("review"));
10108        assert!(chrome.contains("12 in"));
10109        assert!(state.composer_context_chips().contains("@src/lib.rs"));
10110        assert!(state.composer_context_chips().contains("steer"));
10111        state.open_session_picker(&serde_json::json!([
10112            {"path": "/tmp/alpha.jsonl", "name": "alpha"},
10113            {"path": "/tmp/beta.jsonl"}
10114        ]));
10115        assert!(state.session_picker_open);
10116        assert_eq!(state.session_picker_items[0].label, "alpha");
10117        assert_eq!(state.session_picker_items[1].label, "beta.jsonl");
10118        state.edit_last_user_message();
10119        state.conversation_items = vec![super::super::projection::ConversationEntry {
10120            kind: super::super::projection::ConversationKind::User,
10121            text: "previous prompt\n· sending…".into(),
10122            streaming: false,
10123            entry_id: Some("entry-1".into()),
10124            tool_name: None,
10125        }];
10126        state.edit_last_user_message();
10127        assert!(state.composer_mode);
10128        assert_eq!(state.composer_input, "previous prompt");
10129        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10130    }
10131
10132    #[test]
10133    fn chat_dock_stays_on_code_and_app() {
10134        let root = std::env::temp_dir().join(format!("glass-dock-{}", std::process::id()));
10135        std::fs::create_dir_all(&root).expect("create temporary workspace");
10136        let mut state =
10137            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10138        state.snapshot_trust_label = "trusted".into();
10139        state.agent_readiness = "✓ Ready · Node ✓ · SDK 0.84.3 · auth ✓".into();
10140        state.surface = DevSurface::Code;
10141        std::fs::create_dir_all(root.join("src")).expect("src");
10142        std::fs::write(root.join("src/lib.rs"), "fn main() {}\n").expect("write");
10143        state
10144            .ws_mut()
10145            .expect("lock")
10146            .project_mut()
10147            .open_buffer("src/lib.rs", crate::development::Actor::local())
10148            .expect("open buffer");
10149        state.refresh_editor_projection();
10150        state.prepare_editor_agent_prompt();
10151        assert_eq!(state.surface, DevSurface::Code);
10152        assert!(state.composer_mode);
10153        state.close_composer();
10154        state.surface = DevSurface::App;
10155        state.focus_composer_dock();
10156        assert_eq!(state.surface, DevSurface::App);
10157        assert!(state.composer_mode);
10158        state.cycle_composer_run_mode();
10159        assert_eq!(state.composer_run_mode, crate::AgentTurnMode::Ask);
10160        state.cycle_composer_run_mode();
10161        assert_eq!(state.composer_run_mode, crate::AgentTurnMode::Plan);
10162        state.capture_plan_from_goal("ship the checkout");
10163        state.pending_plan.as_mut().unwrap().body = "1. open App\n2. click Sign in".into();
10164        assert!(!state.pending_plan.as_ref().unwrap().accepted);
10165        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10166    }
10167
10168    #[test]
10169    fn watching_agent_browser_act_enables_live_view() {
10170        let root = std::env::temp_dir().join(format!("glass-watch-{}", std::process::id()));
10171        std::fs::create_dir_all(&root).expect("create temporary workspace");
10172        let mut state =
10173            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10174        state.watch_agent_on_app(
10175            "glass.browser.act",
10176            &serde_json::json!({"target": "Sign in"}),
10177        );
10178        assert!(state.browser_visual_live);
10179        assert!(state.status.contains("Sign in"));
10180        assert!(state.status.contains("watching"));
10181        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10182    }
10183
10184    #[test]
10185    fn code_preview_queues_when_workspace_is_busy() {
10186        let root = std::env::temp_dir().join(format!("glass-open-busy-{}", std::process::id()));
10187        std::fs::create_dir_all(&root).expect("create temporary workspace");
10188        std::fs::write(root.join("notes.txt"), "hello\n").expect("write preview file");
10189        let mut state =
10190            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10191        state.files = vec!["notes.txt".into()];
10192        let workspace = state.workspace.clone();
10193        let _guard = workspace.lock().expect("hold workspace lock");
10194
10195        state.show_surface(DevSurface::Code);
10196        assert_eq!(state.pending_open_file.as_deref(), Some("notes.txt"));
10197        assert!(state.status.contains("when the workspace is free"));
10198        assert!(
10199            !state.status.contains("Open failed"),
10200            "busy preview must queue instead of failing: {}",
10201            state.status
10202        );
10203
10204        drop(_guard);
10205        state.flush_pending_open_file();
10206        assert!(state.pending_open_file.is_none());
10207        assert_eq!(state.focused_editor_path, "notes.txt");
10208        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10209    }
10210
10211    #[test]
10212    fn more_doctor_stays_on_more_and_git_loads_the_selected_diff() {
10213        let root = std::env::temp_dir().join(format!("glass-more-git-{}", std::process::id()));
10214        std::fs::create_dir_all(&root).expect("create temporary workspace");
10215        let mut state =
10216            DevTuiState::open_for_tui(&root, TuiLayout::Desktop).expect("open temporary workspace");
10217        state
10218            .ws_mut()
10219            .expect("workspace lock")
10220            .apply_local_trust_decision(crate::LocalTrustDecision::TrustProject)
10221            .expect("trust project");
10222        state.snapshot_trust_label = "trusted-project".into();
10223
10224        state.show_surface(DevSurface::More);
10225        state.selected_more = 0;
10226        state.activate_more_selection();
10227        assert_eq!(state.surface, DevSurface::More);
10228        assert!(
10229            state.status.to_ascii_lowercase().contains("doctor")
10230                || state.status.contains("PI panel"),
10231            "doctor should stay on More: {}",
10232            state.status
10233        );
10234
10235        state.git_entries = vec![crate::git::GitStatusEntry {
10236            path: "notes.txt".into(),
10237            original_path: None,
10238            index_status: ' ',
10239            worktree_status: 'M',
10240            untracked: false,
10241        }];
10242        state.show_surface(DevSurface::Git);
10243        assert!(state.git_diff_requested);
10244        assert!(state.git_diff_open);
10245        assert!(state.git_diff.contains("Loading"));
10246        assert_eq!(state.git_diff_path.as_deref(), Some("notes.txt"));
10247        std::fs::remove_dir_all(root).expect("remove temporary workspace");
10248    }
10249}