Skip to main content

glass_dev/development/
agent.rs

1use super::{Actor, DevelopmentError, DevelopmentEventKind, DevelopmentResult, ProjectWorkspace};
2use serde::{Deserialize, Serialize};
3use serde_json::Value;
4use sha2::{Digest, Sha256};
5use std::{
6    collections::{BTreeSet, VecDeque},
7    io::{BufRead, BufReader, Write},
8    path::{Path, PathBuf},
9    process::{Child, ChildStdin, Command, Stdio},
10    sync::mpsc::{self, Receiver, RecvTimeoutError},
11    thread,
12    time::Duration,
13};
14
15const MAX_PI_EVENT_BYTES: usize = 512 * 1024;
16const MAX_PI_BUFFERED_EVENTS: usize = 64;
17const PI_EVENT_CHANNEL_CAPACITY: usize = 32;
18const PI_RESPONSE_TIMEOUT: Duration = Duration::from_secs(30);
19
20#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
21#[serde(rename_all = "camelCase")]
22pub struct ToolDescriptor {
23    pub name: String,
24    pub description: String,
25    pub input_schema: Value,
26    pub mutating: bool,
27    pub available: bool,
28    #[serde(default, skip_serializing_if = "Option::is_none")]
29    pub unavailable_reason: Option<String>,
30}
31
32#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
33#[serde(rename_all = "camelCase")]
34pub struct AgentContextPacket {
35    pub schema_version: String,
36    pub references: Vec<String>,
37    pub project: Value,
38    pub diagnostics: Value,
39    pub processes: Value,
40    pub recent_events: Value,
41    pub resolved: Value,
42    pub browser: Option<BrowserAgentContext>,
43    pub authority: AgentAuthorityContext,
44}
45
46#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
47#[serde(rename_all = "camelCase")]
48pub struct BrowserAgentContext {
49    pub connected: bool,
50    pub target_id: Option<String>,
51    pub origin: Option<String>,
52    pub url: String,
53    pub title: String,
54    pub browser_revision: u64,
55    pub semantic_summary: String,
56    pub semantic_entity_count: usize,
57    pub selected_entity: Option<Value>,
58    pub workflow_state: String,
59    pub input_owner: String,
60    pub freshness: String,
61    pub memory_scope: String,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
65#[serde(rename_all = "camelCase")]
66pub struct AgentAuthorityContext {
67    pub project_revision: u64,
68    pub browser_revision: Option<u64>,
69    pub mutation_lease_required: bool,
70    pub stale_context_rejected: bool,
71}
72
73pub fn resolve_context(
74    workspace: &mut ProjectWorkspace,
75    prompt: &str,
76) -> DevelopmentResult<AgentContextPacket> {
77    resolve_context_with_browser(workspace, prompt, None)
78}
79
80pub fn resolve_context_with_browser(
81    workspace: &mut ProjectWorkspace,
82    prompt: &str,
83    browser: Option<&BrowserAgentContext>,
84) -> DevelopmentResult<AgentContextPacket> {
85    if prompt.len() > 8 * 1024 {
86        return Err(DevelopmentError::InvalidInput(
87            "prompt exceeds the 8192 byte context limit".into(),
88        ));
89    }
90    let mut references = prompt
91        .split_whitespace()
92        .filter(|token| token.starts_with('@'))
93        .map(|token| {
94            token
95                .trim_matches(|character: char| {
96                    matches!(character, ',' | '.' | '?' | '!' | ')' | ']')
97                })
98                .to_string()
99        })
100        .collect::<Vec<_>>();
101    references.sort();
102    references.dedup();
103    if references.len() > 32 {
104        return Err(DevelopmentError::InvalidInput(
105            "agent context cannot contain more than 32 references".into(),
106        ));
107    }
108    let mut resolved = serde_json::Map::new();
109    for reference in &references {
110        let value = match reference.as_str() {
111            "@workspace" => serde_json::to_value(workspace.detection())?,
112            "@diagnostic" => serde_json::to_value(workspace.diagnostics())?,
113            "@run:last" => workspace
114                .timeline()
115                .events()
116                .next_back()
117                .map(serde_json::to_value)
118                .transpose()?
119                .unwrap_or(Value::Null),
120            "@page" | "@browser" => browser.map(serde_json::to_value).transpose()?.unwrap_or_else(|| serde_json::json!({
121                "status": "requires-attached-browser-workspace", "defaultObservation": "structured"
122            })),
123            "@selection" => browser
124                .and_then(|value| value.selected_entity.clone())
125                .unwrap_or_else(|| serde_json::json!({"status": "not-selected"})),
126            "@file" | "@symbol" => serde_json::json!({"status": "not-selected"}),
127            value if value.starts_with("@entity:") => {
128                serde_json::to_value(workspace.graph().links_for(&value[8..]))?
129            }
130            value if value.starts_with("@file:") => {
131                let path = &value[6..];
132                let content = workspace.read_file(path)?;
133                serde_json::json!({"path": path, "bytes": content.len(), "sha256": prompt_evidence(&content)["sha256"]})
134            }
135            value if value.starts_with("@revision:") => {
136                let index = value[10..].parse::<usize>().map_err(|_| {
137                    DevelopmentError::InvalidInput(format!("invalid revision reference: {value}"))
138                })?;
139                serde_json::to_value(workspace.replay(index, 1)?)?
140            }
141            "@workflow" => browser.map(|value| serde_json::json!({"state":value.workflow_state,"browserRevision":value.browser_revision})).unwrap_or_else(|| serde_json::json!({"status":"not-attached"})),
142            "@memory" => browser.map(|value| serde_json::json!({"scope":value.memory_scope,"authoritative":false})).unwrap_or_else(|| serde_json::json!({"status":"not-attached"})),
143            value => {
144                return Err(DevelopmentError::InvalidInput(format!(
145                    "unsupported agent context reference: {value}"
146                )));
147            }
148        };
149        resolved.insert(reference.clone(), value);
150    }
151    let processes = workspace.processes().list_checked()?;
152    let events = workspace
153        .timeline()
154        .events()
155        .rev()
156        .take(32)
157        .collect::<Vec<_>>();
158    let project_revision = workspace.revision();
159    Ok(AgentContextPacket {
160        schema_version: "glass.agent-context.v1".into(),
161        references,
162        project: serde_json::to_value(workspace.detection())?,
163        diagnostics: serde_json::to_value(workspace.diagnostics())?,
164        processes: serde_json::to_value(processes)?,
165        recent_events: serde_json::to_value(events)?,
166        resolved: Value::Object(resolved),
167        browser: browser.cloned(),
168        authority: AgentAuthorityContext {
169            project_revision,
170            browser_revision: browser.map(|value| value.browser_revision),
171            mutation_lease_required: true,
172            stale_context_rejected: true,
173        },
174    })
175}
176
177#[derive(Debug, Clone, Default)]
178pub struct ToolRegistry;
179
180const MAX_TOOL_ARGUMENT_BYTES: usize = 256 * 1024;
181const MAX_TOOL_RESULT_BYTES: usize = 64 * 1024;
182const MAX_TOOL_CALL_ID_BYTES: usize = 128;
183const MAX_TOOL_NAME_BYTES: usize = 128;
184const MAX_GREP_FILES: usize = 512;
185const MAX_GREP_BYTES: u64 = 32 * 1024 * 1024;
186
187#[derive(Debug, Clone)]
188pub struct ToolAuthorization {
189    pub actor: Actor,
190    pub allow_mutation: bool,
191    pub confirmed: bool,
192}
193
194impl ToolAuthorization {
195    pub fn read_only(actor: Actor) -> Self {
196        Self {
197            actor,
198            allow_mutation: false,
199            confirmed: false,
200        }
201    }
202}
203
204#[derive(Debug, Clone)]
205pub struct AgentToolGateway {
206    registry: ToolRegistry,
207    descriptors: Vec<ToolDescriptor>,
208    browser_context: Option<BrowserAgentContext>,
209}
210
211impl Default for AgentToolGateway {
212    fn default() -> Self {
213        let registry = ToolRegistry;
214        let descriptors = registry.descriptors();
215        Self {
216            registry,
217            descriptors,
218            browser_context: None,
219        }
220    }
221}
222
223impl AgentToolGateway {
224    pub fn subprocess_broker() -> Self {
225        let mut gateway = Self::default();
226        for descriptor in &mut gateway.descriptors {
227            if matches!(
228                descriptor.name.as_str(),
229                "glass.process.start"
230                    | "glass.process.stop"
231                    | "glass.process.remove"
232                    | "glass.process.logs"
233                    | "glass.process.list"
234            ) {
235                descriptor.available = false;
236                descriptor.unavailable_reason =
237                    Some("Requires a resident Glass Dev session that owns the managed PTY".into());
238            }
239        }
240        gateway
241    }
242
243    pub fn set_browser_context(&mut self, context: Option<BrowserAgentContext>) {
244        self.browser_context = context;
245        for descriptor in &mut self.descriptors {
246            let available = match descriptor.name.as_str() {
247                "glass.browser.observe" | "glass.memory.retrieve" => self
248                    .browser_context
249                    .as_ref()
250                    .is_some_and(|value| value.connected),
251                "glass.workflow.pause" | "glass.workflow.resume" => self
252                    .browser_context
253                    .as_ref()
254                    .is_some_and(|value| value.connected && value.workflow_state == "active"),
255                _ => continue,
256            };
257            descriptor.available = available;
258            descriptor.unavailable_reason = (!available).then(|| match descriptor.name.as_str() {
259                "glass.memory.retrieve" => {
260                    "Requires an attached profile-scoped semantic memory store".into()
261                }
262                name if name.starts_with("glass.workflow") => {
263                    "Requires an active browser workflow run".into()
264                }
265                _ => "Requires an attached Browser Workspace".into(),
266            });
267        }
268    }
269
270    pub fn descriptors(&self) -> Vec<ToolDescriptor> {
271        self.descriptors.clone()
272    }
273
274    pub fn execute(
275        &self,
276        workspace: &mut ProjectWorkspace,
277        call: &ToolCall,
278        authorization: &ToolAuthorization,
279    ) -> DevelopmentResult<Value> {
280        validate_tool_call_envelope(call)?;
281        let descriptor = self
282            .descriptors
283            .iter()
284            .find(|descriptor| descriptor.name == call.name)
285            .ok_or_else(|| DevelopmentError::NotFound(format!("tool {}", call.name)))?;
286        if !descriptor.available {
287            return Err(DevelopmentError::InvalidInput(
288                descriptor
289                    .unavailable_reason
290                    .clone()
291                    .unwrap_or_else(|| format!("tool {} is unavailable", descriptor.name)),
292            ));
293        }
294        let argument_evidence = validate_tool_arguments(descriptor, &call.arguments)?;
295        if descriptor.mutating && (!authorization.allow_mutation || !authorization.confirmed) {
296            return Err(DevelopmentError::Conflict(format!(
297                "tool {} requires explicit mutation authority and confirmation",
298                descriptor.name
299            )));
300        }
301        workspace.record_as(
302            authorization.actor.clone(),
303            DevelopmentEventKind::AgentToolCalled,
304            tool_call_evidence(call, descriptor.mutating, &argument_evidence),
305        )?;
306        let result = if call.name == "glass.capabilities.inspect" {
307            Ok(serde_json::to_value(&self.descriptors)?)
308        } else {
309            self.execute_attached(call).unwrap_or_else(|| {
310                self.registry
311                    .execute_unchecked(workspace, call, authorization.actor.clone())
312            })
313        };
314        let (ok, bytes) = match &result {
315            Ok(value) => {
316                let mut counter = BoundedJsonWriter::new(MAX_TOOL_RESULT_BYTES);
317                let serialized = serde_json::to_writer(&mut counter, value);
318                if counter.exceeded {
319                    workspace.record_as(
320                        authorization.actor.clone(),
321                        DevelopmentEventKind::AgentToolResult,
322                        serde_json::json!({"id": call.id, "name": call.name, "ok": false, "reason": "result-limit", "bytes": counter.bytes}),
323                    )?;
324                    return Err(DevelopmentError::InvalidInput(format!(
325                        "tool result exceeds the {MAX_TOOL_RESULT_BYTES} byte limit"
326                    )));
327                }
328                serialized?;
329                (true, counter.bytes)
330            }
331            Err(_) => (false, 0),
332        };
333        workspace.record_as(
334            authorization.actor.clone(),
335            DevelopmentEventKind::AgentToolResult,
336            serde_json::json!({"id": call.id, "name": call.name, "ok": ok, "bytes": bytes}),
337        )?;
338        result
339    }
340
341    fn execute_attached(&self, call: &ToolCall) -> Option<DevelopmentResult<Value>> {
342        let context = self.browser_context.as_ref()?;
343        match call.name.as_str() {
344            "glass.browser.observe" => Some(Ok(serde_json::json!({
345                "structured": true,
346                "targetId": context.target_id,
347                "origin": context.origin,
348                "url": context.url,
349                "title": context.title,
350                "browserRevision": context.browser_revision,
351                "semanticSummary": context.semantic_summary,
352                "semanticEntityCount": context.semantic_entity_count,
353                "selectedEntity": context.selected_entity,
354                "workflowState": context.workflow_state,
355                "inputOwner": context.input_owner,
356                "freshness": context.freshness,
357            }))),
358            "glass.memory.retrieve" => Some(Ok(serde_json::json!({
359                "scope": context.memory_scope,
360                "authoritative": false,
361                "requiresFreshSemanticEvidence": true
362            }))),
363            "glass.workflow.pause" | "glass.workflow.resume" => Some(Ok(serde_json::json!({
364                "workflowState": context.workflow_state,
365                "browserRevision": context.browser_revision,
366                "requiresMutationLease": true
367            }))),
368            _ => None,
369        }
370    }
371}
372
373impl ToolRegistry {
374    pub fn descriptors(&self) -> Vec<ToolDescriptor> {
375        let schema = |properties: Value, required: &[&str]| serde_json::json!({"type":"object", "properties": properties, "required": required, "additionalProperties": false});
376        vec![
377            descriptor(
378                "glass.file.read",
379                "Read one bounded project file",
380                schema(
381                    serde_json::json!({"path":{"type":"string"},"offset":{"type":"integer"},"limit":{"type":"integer"}}),
382                    &["path"],
383                ),
384                false,
385            ),
386            descriptor(
387                "glass.file.list",
388                "List bounded project files",
389                schema(
390                    serde_json::json!({"path":{"type":"string"},"limit":{"type":"integer"}}),
391                    &[],
392                ),
393                false,
394            ),
395            descriptor(
396                "glass.file.search",
397                "Search files, entities, processes, events, and commands",
398                schema(serde_json::json!({"query":{"type":"string"}}), &["query"]),
399                false,
400            ),
401            descriptor(
402                "glass.file.grep",
403                "Search bounded UTF-8 project files for a literal text pattern",
404                schema(
405                    serde_json::json!({"pattern":{"type":"string"},"path":{"type":"string"},"glob":{"type":"string"},"ignoreCase":{"type":"boolean"},"context":{"type":"integer"},"limit":{"type":"integer"}}),
406                    &["pattern"],
407                ),
408                false,
409            ),
410            descriptor(
411                "glass.file.find",
412                "Find bounded project paths with shell-style star and question-mark matching",
413                schema(
414                    serde_json::json!({"pattern":{"type":"string"},"path":{"type":"string"},"limit":{"type":"integer"}}),
415                    &["pattern"],
416                ),
417                false,
418            ),
419            descriptor(
420                "glass.file.patch",
421                "Replace bounded text through an attributed editor buffer",
422                schema(
423                    serde_json::json!({"path":{"type":"string"},"search":{"type":"string"},"replace":{"type":"string"}}),
424                    &["path", "search", "replace"],
425                ),
426                true,
427            ),
428            descriptor(
429                "glass.file.edit",
430                "Apply one atomic set of exact non-overlapping replacements",
431                schema(
432                    serde_json::json!({"path":{"type":"string"},"edits":{"type":"array"}}),
433                    &["path", "edits"],
434                ),
435                true,
436            ),
437            descriptor(
438                "glass.file.write",
439                "Create or replace one bounded project file",
440                schema(
441                    serde_json::json!({"path":{"type":"string"},"content":{"type":"string"}}),
442                    &["path", "content"],
443                ),
444                true,
445            ),
446            descriptor(
447                "glass.file.mkdir",
448                "Create one workspace-confined directory tree",
449                schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
450                true,
451            ),
452            descriptor(
453                "glass.file.rename",
454                "Rename one workspace-confined path",
455                schema(
456                    serde_json::json!({"from":{"type":"string"},"to":{"type":"string"}}),
457                    &["from", "to"],
458                ),
459                true,
460            ),
461            descriptor(
462                "glass.file.delete",
463                "Delete one file or empty directory",
464                schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
465                true,
466            ),
467            descriptor(
468                "glass.process.start",
469                "Start a named PTY process",
470                schema(
471                    serde_json::json!({"name":{"type":"string"},"command":{"type":"string"}}),
472                    &["name", "command"],
473                ),
474                true,
475            ),
476            descriptor(
477                "glass.process.stop",
478                "Stop a named managed process",
479                schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
480                true,
481            ),
482            descriptor(
483                "glass.process.remove",
484                "Remove a stopped managed process",
485                schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
486                true,
487            ),
488            descriptor(
489                "glass.neovim.probe",
490                "Probe the local Neovim PTY and RPC capabilities",
491                schema(serde_json::json!({}), &[]),
492                false,
493            ),
494            descriptor(
495                "glass.neovim.start",
496                "Start Neovim under Glass process ownership",
497                schema(
498                    serde_json::json!({"name":{"type":"string"},"path":{"type":"string"}}),
499                    &["name"],
500                ),
501                true,
502            ),
503            descriptor(
504                "glass.process.logs",
505                "Read a bounded managed-process output tail",
506                schema(serde_json::json!({"name":{"type":"string"}}), &["name"]),
507                false,
508            ),
509            descriptor(
510                "glass.process.list",
511                "List managed processes",
512                schema(serde_json::json!({}), &[]),
513                false,
514            ),
515            descriptor(
516                "glass.git.status",
517                "Inspect code and runtime impact",
518                schema(serde_json::json!({}), &[]),
519                false,
520            ),
521            descriptor(
522                "glass.semantic.inspect",
523                "Inspect source/runtime graph links",
524                schema(serde_json::json!({"entity":{"type":"string"}}), &["entity"]),
525                false,
526            ),
527            descriptor(
528                "glass.test.run",
529                "Run a command as attributed verification",
530                schema(
531                    serde_json::json!({"name":{"type":"string"},"command":{"type":"string"}}),
532                    &["name", "command"],
533                ),
534                true,
535            ),
536            descriptor(
537                "glass.command.run",
538                "Run one bounded command to completion as the Pi actor",
539                schema(
540                    serde_json::json!({"name":{"type":"string"},"command":{"type":"string"},"timeoutSeconds":{"type":"integer"}}),
541                    &["name", "command"],
542                ),
543                true,
544            ),
545            descriptor(
546                "glass.diagnostics.run",
547                "Publish bounded rust-analyzer diagnostics for one file",
548                schema(serde_json::json!({"path":{"type":"string"}}), &["path"]),
549                false,
550            ),
551            descriptor(
552                "glass.runtime.inspect",
553                "Inspect project, processes, actors, and diagnostics",
554                schema(serde_json::json!({}), &[]),
555                false,
556            ),
557            descriptor(
558                "glass.capabilities.inspect",
559                "Inspect the current Glass agent tool inventory and unavailable reasons",
560                schema(serde_json::json!({}), &[]),
561                false,
562            ),
563            descriptor(
564                "glass.web_ir.inspect",
565                "Validate and inspect one bounded Web IR document",
566                schema(serde_json::json!({"ir":{"type":"object"}}), &["ir"]),
567                false,
568            ),
569            descriptor(
570                "glass.web_ir.diff",
571                "Summarize a validated Web IR revision transition",
572                schema(
573                    serde_json::json!({"before":{"type":"object"},"after":{"type":"object"}}),
574                    &["before", "after"],
575                ),
576                false,
577            ),
578            descriptor(
579                "glass.web_ir.continuity",
580                "Classify graph-scoped entity continuity across two Web IR revisions",
581                schema(
582                    serde_json::json!({"before":{"type":"object"},"after":{"type":"object"},"entityId":{"type":"string"}}),
583                    &["before", "after", "entityId"],
584                ),
585                false,
586            ),
587            descriptor(
588                "glass.task.plan",
589                "Compile a value-free task and return a compact explanation",
590                schema(
591                    serde_json::json!({"task":{"type":"object"},"ir":{"type":"object"}}),
592                    &["task", "ir"],
593                ),
594                false,
595            ),
596            unavailable_descriptor(
597                "glass.browser.observe",
598                "Requires an attached Browser Workspace; structured observation remains the default",
599            ),
600            unavailable_descriptor(
601                "glass.browser.navigate",
602                "Requires an attached Browser Workspace and navigation policy",
603            ),
604            unavailable_descriptor(
605                "glass.browser.act",
606                "Requires an attached Browser Workspace and mutation lease",
607            ),
608            unavailable_descriptor(
609                "glass.workflow.pause",
610                "Requires an active browser workflow run",
611            ),
612            unavailable_descriptor(
613                "glass.workflow.resume",
614                "Requires an active browser workflow checkpoint",
615            ),
616            unavailable_descriptor(
617                "glass.memory.retrieve",
618                "Requires an attached profile-scoped semantic memory store",
619            ),
620        ]
621    }
622
623    fn execute_unchecked(
624        &self,
625        workspace: &mut ProjectWorkspace,
626        call: &ToolCall,
627        actor: Actor,
628    ) -> DevelopmentResult<Value> {
629        let string = |name: &str| {
630            call.arguments
631                .get(name)
632                .and_then(Value::as_str)
633                .ok_or_else(|| {
634                    DevelopmentError::InvalidInput(format!(
635                        "{} requires string argument {name}",
636                        call.name
637                    ))
638                })
639        };
640        match call.name.as_str() {
641            "glass.file.read" => read_tool_file(workspace, call, string("path")?),
642            "glass.file.list" => list_tool_files(workspace, call),
643            "glass.file.search" => Ok(serde_json::to_value(
644                workspace.search(string("query")?, 64)?,
645            )?),
646            "glass.file.grep" => grep_tool_files(workspace, call, string("pattern")?),
647            "glass.file.find" => find_tool_files(workspace, call, string("pattern")?),
648            "glass.file.patch" => {
649                let count = workspace.replace_in_buffer(
650                    string("path")?,
651                    string("search")?,
652                    string("replace")?,
653                    actor,
654                )?;
655                if count == 0 {
656                    return Err(DevelopmentError::Conflict(
657                        "patch search text was not found".into(),
658                    ));
659                }
660                let path = string("path")?.to_string();
661                let buffer = workspace.save_buffer(&path)?;
662                Ok(serde_json::json!({"path": path, "replacements": count, "dirty": buffer.dirty}))
663            }
664            "glass.file.edit" => execute_atomic_edits(workspace, call, actor),
665            "glass.file.write" => {
666                let path = string("path")?.to_string();
667                workspace.write_file(&path, string("content")?, actor)?;
668                Ok(serde_json::json!({"path":path,"written":true}))
669            }
670            "glass.file.mkdir" => {
671                let path = string("path")?.to_string();
672                workspace.create_directory(&path, actor)?;
673                Ok(serde_json::json!({"path":path,"created":true}))
674            }
675            "glass.file.rename" => {
676                let from = string("from")?.to_string();
677                let to = string("to")?.to_string();
678                workspace.rename_path(&from, &to, actor)?;
679                Ok(serde_json::json!({"from":from,"to":to,"renamed":true}))
680            }
681            "glass.neovim.probe" => Ok(serde_json::to_value(super::probe_neovim()?)?),
682            "glass.neovim.start" => Ok(serde_json::to_value(super::start_neovim(
683                workspace.processes(),
684                string("name")?,
685                call.arguments
686                    .get("path")
687                    .and_then(Value::as_str)
688                    .map(std::path::Path::new),
689            )?)?),
690            "glass.file.delete" => {
691                let path = string("path")?.to_string();
692                workspace.delete_path(&path, actor)?;
693                Ok(serde_json::json!({"path":path,"deleted":true}))
694            }
695            "glass.process.start" => Ok(serde_json::to_value(
696                workspace.start_process(string("name")?, string("command")?)?,
697            )?),
698            "glass.process.stop" => Ok(serde_json::to_value(
699                workspace.stop_process(string("name")?)?,
700            )?),
701            "glass.process.remove" => Ok(serde_json::to_value(
702                workspace.processes().remove(string("name")?)?,
703            )?),
704            "glass.process.logs" => {
705                Ok(serde_json::json!({"output": workspace.processes().output(string("name")?)?}))
706            }
707            "glass.process.list" => {
708                Ok(serde_json::to_value(workspace.processes().list_checked()?)?)
709            }
710            "glass.git.status" => Ok(serde_json::to_value(workspace.diff()?)?),
711            "glass.semantic.inspect" => Ok(serde_json::to_value(
712                workspace.graph().links_for(string("entity")?),
713            )?),
714            "glass.test.run" => Ok(serde_json::to_value(workspace.run_verification(
715                string("name")?,
716                string("command")?,
717                Duration::from_secs(120),
718            )?)?),
719            "glass.command.run" => {
720                let timeout = call
721                    .arguments
722                    .get("timeoutSeconds")
723                    .and_then(Value::as_u64)
724                    .unwrap_or(120);
725                if !(1..=300).contains(&timeout) {
726                    return Err(DevelopmentError::InvalidInput(
727                        "glass.command.run timeoutSeconds must be between 1 and 300".into(),
728                    ));
729                }
730                Ok(serde_json::to_value(workspace.run_command_to_completion(
731                    string("name")?,
732                    string("command")?,
733                    Duration::from_secs(timeout),
734                )?)?)
735            }
736            "glass.diagnostics.run" => Ok(serde_json::to_value(
737                workspace.publish_rust_diagnostics(string("path")?)?,
738            )?),
739            "glass.runtime.inspect" => Ok(serde_json::json!({
740                "project": workspace.detection(),
741                "processes": workspace.processes().list_checked()?,
742                "actors": workspace.actors().collect::<Vec<_>>(),
743                "diagnostics": workspace.diagnostics(),
744                "revision": workspace.revision()
745            })),
746            "glass.web_ir.inspect" => {
747                let ir: glass_browser::web_ir::GlassWebIrV1 =
748                    serde_json::from_value(call.arguments["ir"].clone())?;
749                ir.validate().map_err(|error| {
750                    DevelopmentError::InvalidInput(format!("invalid Web IR: {error}"))
751                })?;
752                Ok(serde_json::to_value(
753                    glass_browser::protocol::WebIrInspectionResult::from_ir(&ir),
754                )?)
755            }
756            "glass.web_ir.diff" => {
757                let before: glass_browser::web_ir::GlassWebIrV1 =
758                    serde_json::from_value(call.arguments["before"].clone())?;
759                let after: glass_browser::web_ir::GlassWebIrV1 =
760                    serde_json::from_value(call.arguments["after"].clone())?;
761                let diff = before.diff(&after).map_err(|error| {
762                    DevelopmentError::InvalidInput(format!("invalid Web IR transition: {error}"))
763                })?;
764                Ok(serde_json::json!({
765                    "fromRevision": diff.from_revision,
766                    "toRevision": diff.to_revision,
767                    "entityChanges": diff.entity_changes.len(),
768                    "relationshipChanges": diff.relationship_changes.len(),
769                    "coverageChanged": diff.coverage_changed,
770                    "limitsChanged": diff.limits_changed
771                }))
772            }
773            "glass.web_ir.continuity" => {
774                let before: glass_browser::web_ir::GlassWebIrV1 =
775                    serde_json::from_value(call.arguments["before"].clone())?;
776                let after: glass_browser::web_ir::GlassWebIrV1 =
777                    serde_json::from_value(call.arguments["after"].clone())?;
778                let entity_id = string("entityId")?;
779                Ok(serde_json::to_value(
780                    before
781                        .classify_entity_continuity(&after, entity_id)
782                        .map_err(|error| {
783                            DevelopmentError::InvalidInput(format!(
784                                "invalid Web IR transition: {error}"
785                            ))
786                        })?,
787                )?)
788            }
789            "glass.task.plan" => {
790                let task: glass_browser::task_protocol::GlassTask =
791                    serde_json::from_value(call.arguments["task"].clone())?;
792                let ir: glass_browser::web_ir::GlassWebIrV1 =
793                    serde_json::from_value(call.arguments["ir"].clone())?;
794                let plan =
795                    glass_browser::task_compiler::compile_task(&task, &ir).map_err(|error| {
796                        DevelopmentError::InvalidInput(format!("task compilation failed: {error}"))
797                    })?;
798                Ok(serde_json::json!({
799                    "sourceRevision": plan.source_ir_revision,
800                    "task": plan.task,
801                    "risk": plan.risk,
802                    "confirmationRequired": plan.confirmation_required,
803                    "selectedEntityIds": plan.selected_entity_ids,
804                    "requiredRuntimeCapabilities": plan.required_runtime_capabilities,
805                    "entityEvidenceRequirements": plan.entity_evidence_requirements,
806                    "steps": plan.steps,
807                    "postconditions": plan.postconditions
808                }))
809            }
810            _ => Err(DevelopmentError::NotFound(format!("tool {}", call.name))),
811        }
812    }
813}
814
815struct ToolArgumentEvidence {
816    bytes: usize,
817    sha256: String,
818}
819
820struct BoundedJsonWriter {
821    limit: usize,
822    bytes: usize,
823    exceeded: bool,
824    digest: Sha256,
825}
826
827impl BoundedJsonWriter {
828    fn new(limit: usize) -> Self {
829        Self {
830            limit,
831            bytes: 0,
832            exceeded: false,
833            digest: Sha256::new(),
834        }
835    }
836
837    fn evidence(self) -> ToolArgumentEvidence {
838        let digest = self.digest.finalize();
839        ToolArgumentEvidence {
840            bytes: self.bytes,
841            sha256: digest_hex(&digest),
842        }
843    }
844}
845
846impl Write for BoundedJsonWriter {
847    fn write(&mut self, buffer: &[u8]) -> std::io::Result<usize> {
848        let remaining = self.limit.saturating_sub(self.bytes);
849        if buffer.len() > remaining {
850            self.bytes = self.bytes.saturating_add(buffer.len());
851            self.exceeded = true;
852            return Err(std::io::Error::other("bounded JSON limit exceeded"));
853        }
854        self.bytes += buffer.len();
855        self.digest.update(buffer);
856        Ok(buffer.len())
857    }
858
859    fn flush(&mut self) -> std::io::Result<()> {
860        Ok(())
861    }
862}
863
864fn read_tool_file(
865    workspace: &mut ProjectWorkspace,
866    call: &ToolCall,
867    path: &str,
868) -> DevelopmentResult<Value> {
869    let content = workspace.read_file(path)?;
870    let content_sha256 = digest_hex(&Sha256::digest(content.as_bytes()));
871    let offset = call
872        .arguments
873        .get("offset")
874        .and_then(Value::as_u64)
875        .unwrap_or(1);
876    let limit = call
877        .arguments
878        .get("limit")
879        .and_then(Value::as_u64)
880        .unwrap_or(500);
881    if offset == 0 || !(1..=2_000).contains(&limit) {
882        return Err(DevelopmentError::InvalidInput(
883            "glass.file.read offset must be positive and limit must be between 1 and 2000".into(),
884        ));
885    }
886    let total_lines = content
887        .lines()
888        .count()
889        .max(usize::from(!content.is_empty())) as u64;
890    let mut selected = content
891        .split_inclusive('\n')
892        .skip(offset.saturating_sub(1) as usize)
893        .take(limit as usize)
894        .collect::<String>();
895    let selected_lines = selected.lines().count() as u64;
896    let mut bytes_truncated = false;
897    if selected.len() > 60 * 1024 {
898        let mut boundary = 60 * 1024;
899        while !selected.is_char_boundary(boundary) {
900            boundary -= 1;
901        }
902        selected.truncate(boundary);
903        bytes_truncated = true;
904    }
905    Ok(serde_json::json!({
906        "path": path,
907        "content": selected,
908        "offset": offset,
909        "lines": selected_lines,
910        "totalLines": total_lines,
911        "sha256": content_sha256,
912        "truncated": bytes_truncated || offset.saturating_sub(1) + selected_lines < total_lines,
913    }))
914}
915
916fn list_tool_files(workspace: &ProjectWorkspace, call: &ToolCall) -> DevelopmentResult<Value> {
917    let path_prefix = optional_string_argument(call, "path")
918        .map(|path| path.trim_matches('/').to_string())
919        .unwrap_or_default();
920    let limit = bounded_u64_argument(call, "limit", 1, 2_000, 500)? as usize;
921    let tree = workspace.list_files_result()?;
922    let mut entries = Vec::new();
923    let mut truncated = tree.truncated;
924    for entry in tree.entries {
925        if !path_prefix.is_empty()
926            && entry.path != path_prefix
927            && !entry.path.starts_with(&format!("{path_prefix}/"))
928        {
929            continue;
930        }
931        entries.push(entry);
932        if entries.len() == limit {
933            truncated = true;
934            break;
935        }
936    }
937    Ok(serde_json::json!({
938        "entries": entries,
939        "limit": limit,
940        "truncated": truncated,
941        "ignoredDirectories": tree.ignored_directories,
942        "skippedSymlinks": tree.skipped_symlinks,
943    }))
944}
945
946fn grep_tool_files(
947    workspace: &mut ProjectWorkspace,
948    call: &ToolCall,
949    pattern: &str,
950) -> DevelopmentResult<Value> {
951    if pattern.is_empty() {
952        return Err(DevelopmentError::InvalidInput(
953            "glass.file.grep pattern must not be empty".into(),
954        ));
955    }
956    let path_prefix = optional_string_argument(call, "path")
957        .map(|path| path.trim_matches('/').to_string())
958        .unwrap_or_default();
959    let glob = optional_string_argument(call, "glob");
960    let ignore_case = call
961        .arguments
962        .get("ignoreCase")
963        .and_then(Value::as_bool)
964        .unwrap_or(false);
965    let context = bounded_u64_argument(call, "context", 0, 10, 0)? as usize;
966    let limit = bounded_u64_argument(call, "limit", 1, 500, 100)? as usize;
967    let needle = ignore_case.then(|| pattern.to_lowercase());
968    let entries = workspace.list_files_result()?;
969    let mut matches = Vec::new();
970    let mut files_searched = 0usize;
971    let mut bytes_searched = 0u64;
972    let mut files_skipped = 0usize;
973    let mut truncated = entries.truncated;
974    for entry in entries.entries {
975        if entry.kind != super::project::FileKind::File
976            || (!path_prefix.is_empty()
977                && entry.path != path_prefix
978                && !entry.path.starts_with(&format!("{path_prefix}/")))
979            || glob.is_some_and(|glob| !wildcard_matches(glob, &entry.path))
980        {
981            continue;
982        }
983        let bytes = entry.bytes.unwrap_or(0);
984        if files_searched == MAX_GREP_FILES || bytes_searched.saturating_add(bytes) > MAX_GREP_BYTES
985        {
986            truncated = true;
987            break;
988        }
989        let Ok(content) = workspace.read_file_snapshot(&entry.path) else {
990            files_skipped += 1;
991            continue;
992        };
993        files_searched += 1;
994        bytes_searched = bytes_searched.saturating_add(content.len() as u64);
995        let lines = content.lines().collect::<Vec<_>>();
996        for (index, line) in lines.iter().enumerate() {
997            let found = needle.as_ref().map_or_else(
998                || line.contains(pattern),
999                |needle| line.to_lowercase().contains(needle),
1000            );
1001            if !found {
1002                continue;
1003            }
1004            let start = index.saturating_sub(context);
1005            let end = (index + context + 1).min(lines.len());
1006            matches.push(serde_json::json!({
1007                "path": entry.path,
1008                "line": index + 1,
1009                "text": line,
1010                "contextBefore": lines[start..index],
1011                "contextAfter": lines[index + 1..end],
1012            }));
1013            if matches.len() == limit {
1014                return Ok(serde_json::json!({
1015                    "matches": matches,
1016                    "filesSearched": files_searched,
1017                    "bytesSearched": bytes_searched,
1018                    "filesSkipped": files_skipped,
1019                    "limit": limit,
1020                    "truncated": true,
1021                    "literal": true,
1022                }));
1023            }
1024        }
1025    }
1026    Ok(serde_json::json!({
1027        "matches": matches,
1028        "filesSearched": files_searched,
1029        "bytesSearched": bytes_searched,
1030        "filesSkipped": files_skipped,
1031        "limit": limit,
1032        "truncated": truncated,
1033        "literal": true,
1034    }))
1035}
1036
1037fn find_tool_files(
1038    workspace: &ProjectWorkspace,
1039    call: &ToolCall,
1040    pattern: &str,
1041) -> DevelopmentResult<Value> {
1042    if pattern.is_empty() {
1043        return Err(DevelopmentError::InvalidInput(
1044            "glass.file.find pattern must not be empty".into(),
1045        ));
1046    }
1047    let path_prefix = optional_string_argument(call, "path")
1048        .map(|path| path.trim_matches('/').to_string())
1049        .unwrap_or_default();
1050    let limit = bounded_u64_argument(call, "limit", 1, 2_000, 500)? as usize;
1051    let tree = workspace.list_files_result()?;
1052    let mut paths = Vec::new();
1053    let mut truncated = tree.truncated;
1054    for entry in tree.entries {
1055        if (!path_prefix.is_empty()
1056            && entry.path != path_prefix
1057            && !entry.path.starts_with(&format!("{path_prefix}/")))
1058            || !wildcard_matches(pattern, &entry.path)
1059        {
1060            continue;
1061        }
1062        paths.push(serde_json::json!({"path":entry.path,"kind":entry.kind}));
1063        if paths.len() == limit {
1064            truncated = true;
1065            break;
1066        }
1067    }
1068    Ok(serde_json::json!({"paths":paths,"limit":limit,"truncated":truncated}))
1069}
1070
1071fn optional_string_argument<'a>(call: &'a ToolCall, name: &str) -> Option<&'a str> {
1072    call.arguments.get(name).and_then(Value::as_str)
1073}
1074
1075fn bounded_u64_argument(
1076    call: &ToolCall,
1077    name: &str,
1078    minimum: u64,
1079    maximum: u64,
1080    default: u64,
1081) -> DevelopmentResult<u64> {
1082    let value = call
1083        .arguments
1084        .get(name)
1085        .and_then(Value::as_u64)
1086        .unwrap_or(default);
1087    if !(minimum..=maximum).contains(&value) {
1088        return Err(DevelopmentError::InvalidInput(format!(
1089            "{} {name} must be between {minimum} and {maximum}",
1090            call.name
1091        )));
1092    }
1093    Ok(value)
1094}
1095
1096fn wildcard_matches(pattern: &str, value: &str) -> bool {
1097    let pattern = pattern.chars().collect::<Vec<_>>();
1098    let value = value.chars().collect::<Vec<_>>();
1099    let (mut pattern_index, mut value_index) = (0usize, 0usize);
1100    let (mut star, mut retry) = (None, 0usize);
1101    while value_index < value.len() {
1102        if pattern_index < pattern.len()
1103            && (pattern[pattern_index] == '?' || pattern[pattern_index] == value[value_index])
1104        {
1105            pattern_index += 1;
1106            value_index += 1;
1107        } else if pattern_index < pattern.len() && pattern[pattern_index] == '*' {
1108            star = Some(pattern_index);
1109            pattern_index += 1;
1110            retry = value_index;
1111        } else if let Some(star_index) = star {
1112            pattern_index = star_index + 1;
1113            retry += 1;
1114            value_index = retry;
1115        } else {
1116            return false;
1117        }
1118    }
1119    while pattern_index < pattern.len() && pattern[pattern_index] == '*' {
1120        pattern_index += 1;
1121    }
1122    pattern_index == pattern.len()
1123}
1124
1125fn execute_atomic_edits(
1126    workspace: &mut ProjectWorkspace,
1127    call: &ToolCall,
1128    actor: Actor,
1129) -> DevelopmentResult<Value> {
1130    let path = call.arguments["path"]
1131        .as_str()
1132        .ok_or_else(|| DevelopmentError::InvalidInput("glass.file.edit requires path".into()))?;
1133    let edits = call.arguments["edits"]
1134        .as_array()
1135        .filter(|edits| !edits.is_empty() && edits.len() <= 64)
1136        .ok_or_else(|| {
1137            DevelopmentError::InvalidInput("glass.file.edit requires between 1 and 64 edits".into())
1138        })?;
1139    let original = workspace.read_file(path)?;
1140    let mut replacements = Vec::with_capacity(edits.len());
1141    for edit in edits {
1142        let old_text = edit.get("oldText").and_then(Value::as_str).ok_or_else(|| {
1143            DevelopmentError::InvalidInput("every edit requires string oldText".into())
1144        })?;
1145        let new_text = edit.get("newText").and_then(Value::as_str).ok_or_else(|| {
1146            DevelopmentError::InvalidInput("every edit requires string newText".into())
1147        })?;
1148        if old_text.is_empty() {
1149            return Err(DevelopmentError::InvalidInput(
1150                "glass.file.edit oldText must not be empty".into(),
1151            ));
1152        }
1153        let matches = original.match_indices(old_text).collect::<Vec<_>>();
1154        if matches.len() != 1 {
1155            return Err(DevelopmentError::Conflict(format!(
1156                "glass.file.edit oldText must match exactly once; matched {} times",
1157                matches.len()
1158            )));
1159        }
1160        let start = matches[0].0;
1161        replacements.push((start, start + old_text.len(), new_text));
1162    }
1163    replacements.sort_by_key(|replacement| replacement.0);
1164    if replacements.windows(2).any(|pair| pair[0].1 > pair[1].0) {
1165        return Err(DevelopmentError::Conflict(
1166            "glass.file.edit replacements overlap".into(),
1167        ));
1168    }
1169    let mut content = original;
1170    for (start, end, new_text) in replacements.iter().rev() {
1171        content.replace_range(*start..*end, new_text);
1172    }
1173    workspace.edit_buffer(path, content, actor)?;
1174    let buffer = workspace.save_buffer(path)?;
1175    Ok(serde_json::json!({
1176        "path": path,
1177        "replacements": replacements.len(),
1178        "dirty": buffer.dirty,
1179    }))
1180}
1181
1182fn validate_tool_call_envelope(call: &ToolCall) -> DevelopmentResult<()> {
1183    if call.id.is_empty()
1184        || call.id.len() > MAX_TOOL_CALL_ID_BYTES
1185        || call.id.chars().any(char::is_control)
1186    {
1187        return Err(DevelopmentError::InvalidInput(format!(
1188            "tool call id must contain 1 to {MAX_TOOL_CALL_ID_BYTES} non-control bytes"
1189        )));
1190    }
1191    if call.name.is_empty()
1192        || call.name.len() > MAX_TOOL_NAME_BYTES
1193        || !call
1194            .name
1195            .bytes()
1196            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
1197    {
1198        return Err(DevelopmentError::InvalidInput(format!(
1199            "tool name must contain 1 to {MAX_TOOL_NAME_BYTES} ASCII identifier bytes"
1200        )));
1201    }
1202    Ok(())
1203}
1204
1205fn validate_tool_arguments(
1206    descriptor: &ToolDescriptor,
1207    arguments: &Value,
1208) -> DevelopmentResult<ToolArgumentEvidence> {
1209    let mut writer = BoundedJsonWriter::new(MAX_TOOL_ARGUMENT_BYTES);
1210    let serialized = serde_json::to_writer(&mut writer, arguments);
1211    if writer.exceeded {
1212        return Err(DevelopmentError::InvalidInput(format!(
1213            "tool arguments exceed the {MAX_TOOL_ARGUMENT_BYTES} byte limit"
1214        )));
1215    }
1216    serialized?;
1217    let object = arguments.as_object().ok_or_else(|| {
1218        DevelopmentError::InvalidInput(format!("{} arguments must be an object", descriptor.name))
1219    })?;
1220    let properties = descriptor.input_schema["properties"]
1221        .as_object()
1222        .cloned()
1223        .unwrap_or_default();
1224    for required in descriptor.input_schema["required"]
1225        .as_array()
1226        .into_iter()
1227        .flatten()
1228        .filter_map(Value::as_str)
1229    {
1230        if !object.contains_key(required) {
1231            return Err(DevelopmentError::InvalidInput(format!(
1232                "{} requires argument {required}",
1233                descriptor.name
1234            )));
1235        }
1236    }
1237    for (name, value) in object {
1238        let Some(property) = properties.get(name) else {
1239            return Err(DevelopmentError::InvalidInput(format!(
1240                "{} does not accept argument {name}",
1241                descriptor.name
1242            )));
1243        };
1244        let valid = match property["type"].as_str() {
1245            Some("string") => value.is_string(),
1246            Some("object") => value.is_object(),
1247            Some("integer") => value.as_u64().is_some(),
1248            _ => true,
1249        };
1250        if !valid {
1251            return Err(DevelopmentError::InvalidInput(format!(
1252                "{}.{} has the wrong type",
1253                descriptor.name, name
1254            )));
1255        }
1256    }
1257    Ok(writer.evidence())
1258}
1259
1260fn tool_call_evidence(call: &ToolCall, mutating: bool, evidence: &ToolArgumentEvidence) -> Value {
1261    serde_json::json!({
1262        "id": call.id,
1263        "name": call.name,
1264        "mutating": mutating,
1265        "argumentBytes": evidence.bytes,
1266        "argumentSha256": evidence.sha256
1267    })
1268}
1269
1270fn digest_hex(bytes: &[u8]) -> String {
1271    const DIGITS: &[u8; 16] = b"0123456789abcdef";
1272    let mut encoded = String::with_capacity(bytes.len() * 2);
1273    for byte in bytes {
1274        encoded.push(DIGITS[(byte >> 4) as usize] as char);
1275        encoded.push(DIGITS[(byte & 0x0f) as usize] as char);
1276    }
1277    encoded
1278}
1279
1280fn descriptor(
1281    name: &str,
1282    description: &str,
1283    input_schema: Value,
1284    mutating: bool,
1285) -> ToolDescriptor {
1286    ToolDescriptor {
1287        name: name.into(),
1288        description: description.into(),
1289        input_schema,
1290        mutating,
1291        available: true,
1292        unavailable_reason: None,
1293    }
1294}
1295
1296fn unavailable_descriptor(name: &str, reason: &str) -> ToolDescriptor {
1297    ToolDescriptor {
1298        name: name.into(),
1299        description: reason.into(),
1300        input_schema: serde_json::json!({"type":"object"}),
1301        mutating: false,
1302        available: false,
1303        unavailable_reason: Some(reason.into()),
1304    }
1305}
1306
1307#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1308#[serde(tag = "type", rename_all = "camelCase")]
1309pub enum HarnessRequest {
1310    Hello,
1311    Prompt { text: String },
1312    Steer { text: String },
1313    FollowUp { text: String },
1314    Abort,
1315    State,
1316    Models,
1317    SetModel { provider: String, model_id: String },
1318    SetThinking { level: String },
1319    NewSession,
1320    Compact { instructions: Option<String> },
1321    CloneSession,
1322    Fork { entry_id: String },
1323    SwitchSession { path: String },
1324    Entries { since: Option<String> },
1325    Messages,
1326    SessionStats,
1327    SetSessionName { name: String },
1328}
1329
1330#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1331#[serde(tag = "type", rename_all = "camelCase")]
1332pub enum HarnessEvent {
1333    Hello {
1334        protocol: String,
1335        actor: Actor,
1336        capabilities: Vec<String>,
1337    },
1338    State {
1339        state: String,
1340    },
1341    Text {
1342        text: String,
1343    },
1344    ToolCall(ToolCall),
1345    ToolResult {
1346        id: String,
1347        result: Value,
1348    },
1349    Error {
1350        message: String,
1351    },
1352}
1353
1354#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
1355#[serde(rename_all = "camelCase")]
1356pub struct ToolCall {
1357    pub id: String,
1358    pub name: String,
1359    pub arguments: Value,
1360}
1361
1362#[derive(Debug, Clone)]
1363pub struct LocalHarness {
1364    actor: Actor,
1365    gateway: AgentToolGateway,
1366    next_tool_id: u64,
1367    state: String,
1368    browser_context: Option<BrowserAgentContext>,
1369}
1370
1371impl Default for LocalHarness {
1372    fn default() -> Self {
1373        Self {
1374            actor: Actor::embedded(),
1375            gateway: AgentToolGateway::default(),
1376            next_tool_id: 1,
1377            state: "idle".into(),
1378            browser_context: None,
1379        }
1380    }
1381}
1382
1383impl LocalHarness {
1384    pub fn set_browser_context(&mut self, context: Option<BrowserAgentContext>) {
1385        self.browser_context = context.clone();
1386        self.gateway.set_browser_context(context);
1387    }
1388    pub fn actor(&self) -> &Actor {
1389        &self.actor
1390    }
1391
1392    pub fn handle(
1393        &mut self,
1394        workspace: &mut ProjectWorkspace,
1395        request: HarnessRequest,
1396    ) -> DevelopmentResult<Vec<HarnessEvent>> {
1397        match request {
1398            HarnessRequest::Hello => Ok(vec![HarnessEvent::Hello {
1399                protocol: "glass.harness.v1".into(),
1400                actor: self.actor.clone(),
1401                capabilities: vec![
1402                    "prompt".into(),
1403                    "stream".into(),
1404                    "tool.call".into(),
1405                    "steer".into(),
1406                    "follow_up".into(),
1407                    "abort".into(),
1408                    "session.new".into(),
1409                    "model.list".into(),
1410                ],
1411            }]),
1412            HarnessRequest::Prompt { text } => self.prompt(workspace, text),
1413            HarnessRequest::Steer { text } => {
1414                let evidence = prompt_evidence(&text);
1415                workspace.record_as(
1416                    self.actor.clone(),
1417                    DevelopmentEventKind::AgentSteered,
1418                    evidence,
1419                )?;
1420                self.state = "steered".into();
1421                Ok(vec![
1422                    HarnessEvent::State {
1423                        state: self.state.clone(),
1424                    },
1425                    HarnessEvent::Text {
1426                        text: "Steering accepted by the Glass harness.".into(),
1427                    },
1428                ])
1429            }
1430            HarnessRequest::Abort => {
1431                self.state = "aborted".into();
1432                Ok(vec![HarnessEvent::State {
1433                    state: self.state.clone(),
1434                }])
1435            }
1436            HarnessRequest::FollowUp { text } => self.prompt(workspace, text),
1437            HarnessRequest::State => Ok(vec![HarnessEvent::State {
1438                state: self.state.clone(),
1439            }]),
1440            HarnessRequest::Models => Ok(vec![HarnessEvent::Text {
1441                text: "The local harness has no model provider; configure the Pi adapter.".into(),
1442            }]),
1443            HarnessRequest::SetModel { .. } | HarnessRequest::SetThinking { .. } => {
1444                Ok(vec![HarnessEvent::Error {
1445                    message: "model controls require the Pi harness adapter".into(),
1446                }])
1447            }
1448            HarnessRequest::NewSession => {
1449                self.state = "idle".into();
1450                Ok(vec![HarnessEvent::State {
1451                    state: self.state.clone(),
1452                }])
1453            }
1454            HarnessRequest::Compact { .. }
1455            | HarnessRequest::CloneSession
1456            | HarnessRequest::Fork { .. }
1457            | HarnessRequest::SwitchSession { .. }
1458            | HarnessRequest::Entries { .. }
1459            | HarnessRequest::Messages
1460            | HarnessRequest::SessionStats
1461            | HarnessRequest::SetSessionName { .. } => Ok(vec![HarnessEvent::Error {
1462                message: "persistent session controls require the Pi runtime".into(),
1463            }]),
1464        }
1465    }
1466
1467    fn prompt(
1468        &mut self,
1469        workspace: &mut ProjectWorkspace,
1470        text: String,
1471    ) -> DevelopmentResult<Vec<HarnessEvent>> {
1472        if text.trim().is_empty() || text.len() > 8 * 1024 {
1473            return Ok(vec![HarnessEvent::Error {
1474                message: "prompt must be non-empty and at most 8192 bytes".into(),
1475            }]);
1476        }
1477        workspace.record_as(
1478            self.actor.clone(),
1479            DevelopmentEventKind::AgentPrompt,
1480            prompt_evidence(&text),
1481        )?;
1482        self.state = "working".into();
1483        let mut events = vec![HarnessEvent::State {
1484            state: self.state.clone(),
1485        }];
1486        let lower = text.to_ascii_lowercase();
1487        if text.split_whitespace().any(|token| token.starts_with('@')) {
1488            let packet =
1489                resolve_context_with_browser(workspace, &text, self.browser_context.as_ref())?;
1490            events.push(HarnessEvent::Text {
1491                text: serde_json::to_string(&packet)?,
1492            });
1493        } else if let Some(path) = text
1494            .strip_prefix("read ")
1495            .map(str::trim)
1496            .filter(|value| !value.is_empty())
1497        {
1498            let call = self.tool_call("glass.file.read", serde_json::json!({"path": path}));
1499            let id = call.id.clone();
1500            events.push(HarnessEvent::ToolCall(call.clone()));
1501            match self.gateway.execute(
1502                workspace,
1503                &call,
1504                &ToolAuthorization::read_only(self.actor.clone()),
1505            ) {
1506                Ok(result) => {
1507                    events.push(HarnessEvent::ToolResult { id, result });
1508                }
1509                Err(error) => events.push(HarnessEvent::Error {
1510                    message: error.to_string(),
1511                }),
1512            }
1513        } else if lower == "files" || lower == "list files" {
1514            let call = self.tool_call("glass.file.list", serde_json::json!({}));
1515            let id = call.id.clone();
1516            events.push(HarnessEvent::ToolCall(call.clone()));
1517            let result = self.gateway.execute(
1518                workspace,
1519                &call,
1520                &ToolAuthorization::read_only(self.actor.clone()),
1521            )?;
1522            events.push(HarnessEvent::ToolResult { id, result });
1523        } else if lower == "process list" || lower == "processes" {
1524            let call = self.tool_call("glass.process.list", serde_json::json!({}));
1525            let id = call.id.clone();
1526            events.push(HarnessEvent::ToolCall(call.clone()));
1527            let result = self.gateway.execute(
1528                workspace,
1529                &call,
1530                &ToolAuthorization::read_only(self.actor.clone()),
1531            )?;
1532            events.push(HarnessEvent::ToolResult { id, result });
1533        } else if lower == "diff" {
1534            let call = self.tool_call("glass.git.status", serde_json::json!({}));
1535            let id = call.id.clone();
1536            events.push(HarnessEvent::ToolCall(call.clone()));
1537            let result = self.gateway.execute(
1538                workspace,
1539                &call,
1540                &ToolAuthorization::read_only(self.actor.clone()),
1541            )?;
1542            events.push(HarnessEvent::ToolResult { id, result });
1543        } else {
1544            events.push(HarnessEvent::Text {
1545                text: "Glass local harness is ready. Try `read <path>`, `files`, `process list`, or `diff`.".into(),
1546            });
1547        }
1548        self.state = "idle".into();
1549        events.push(HarnessEvent::State {
1550            state: self.state.clone(),
1551        });
1552        Ok(events)
1553    }
1554
1555    fn tool_call(&mut self, name: &str, arguments: Value) -> ToolCall {
1556        let id = format!("tool-{}", self.next_tool_id);
1557        self.next_tool_id = self.next_tool_id.saturating_add(1);
1558        ToolCall {
1559            id,
1560            name: name.into(),
1561            arguments,
1562        }
1563    }
1564}
1565
1566/// Long-lived adapter for Pi's strict LF-delimited JSON RPC mode.
1567///
1568/// Glass owns the stable request/event model; this type only translates that
1569/// model to Pi. No prompt text is persisted by this adapter.
1570pub struct PiHarness {
1571    child: Child,
1572    input: ChildStdin,
1573    output: Receiver<Value>,
1574    next_id: u64,
1575    extension_path: PathBuf,
1576    pending_ui_requests: BTreeSet<String>,
1577    unrestricted: bool,
1578}
1579
1580#[derive(Debug, Clone, Default)]
1581pub struct PiHarnessOptions {
1582    pub unrestricted: bool,
1583    pub persist_session: bool,
1584    pub session_id: Option<String>,
1585    pub fork: Option<String>,
1586    pub session_dir: Option<PathBuf>,
1587    pub name: Option<String>,
1588    pub model: Option<String>,
1589    pub thinking: Option<String>,
1590    pub broker_socket: Option<PathBuf>,
1591    pub broker_token: Option<String>,
1592    pub broker_workspace_id: Option<String>,
1593    pub additional_system_prompt: Option<String>,
1594}
1595
1596impl std::fmt::Debug for PiHarness {
1597    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1598        formatter
1599            .debug_struct("PiHarness")
1600            .field("pid", &self.child.id())
1601            .field("next_id", &self.next_id)
1602            .finish()
1603    }
1604}
1605
1606impl PiHarness {
1607    pub fn spawn(root: &Path) -> DevelopmentResult<Self> {
1608        Self::spawn_with_unrestricted(root, false)
1609    }
1610
1611    pub fn spawn_with_unrestricted(root: &Path, unrestricted: bool) -> DevelopmentResult<Self> {
1612        Self::spawn_with_options(
1613            root,
1614            PiHarnessOptions {
1615                unrestricted,
1616                persist_session: env_enabled("GLASS_PI_PERSIST_SESSION"),
1617                ..PiHarnessOptions::default()
1618            },
1619        )
1620    }
1621
1622    pub fn spawn_with_options(root: &Path, options: PiHarnessOptions) -> DevelopmentResult<Self> {
1623        validate_pi_harness_options(&options)?;
1624        static NEXT_EXTENSION_ID: std::sync::atomic::AtomicU64 =
1625            std::sync::atomic::AtomicU64::new(1);
1626        let extension_id = NEXT_EXTENSION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
1627        let extension_path = std::env::temp_dir().join(format!(
1628            "glass-pi-tools-{}-{extension_id}.ts",
1629            std::process::id()
1630        ));
1631        std::fs::write(
1632            &extension_path,
1633            include_str!("../../assets/pi-glass-tools.ts"),
1634        )?;
1635        let broker = std::env::current_exe().map_err(DevelopmentError::Io)?;
1636        let trusted_resources = options.unrestricted || env_enabled("GLASS_PI_TRUSTED_RESOURCES");
1637        let mut system_prompt = if options.unrestricted {
1638            format!(
1639                "{}\n- UNRESTRICTED MODE is active. Glass will not ask for tool approval; execute requested local development work directly and report effects truthfully.",
1640                include_str!("../../assets/pi-glass-system.md")
1641            )
1642        } else {
1643            include_str!("../../assets/pi-glass-system.md").to_string()
1644        };
1645        if let Some(additional) = &options.additional_system_prompt {
1646            if additional.len() > 128 * 1024 || additional.contains('\0') {
1647                return Err(DevelopmentError::InvalidInput(
1648                    "additional Pi system prompt exceeds 128 KiB or contains NUL".into(),
1649                ));
1650            }
1651            system_prompt.push_str(additional);
1652        }
1653        let mut command = Command::new("pi");
1654        command.args(["--mode", "rpc", "--no-approve", "--no-builtin-tools"]);
1655        if !env_enabled("GLASS_PI_ONLINE_CATALOG") {
1656            command.arg("--offline");
1657        }
1658        if !trusted_resources {
1659            command.args([
1660                "--no-context-files",
1661                "--no-extensions",
1662                "--no-skills",
1663                "--no-prompt-templates",
1664                "--no-themes",
1665            ]);
1666        }
1667        if !options.persist_session {
1668            command.arg("--no-session");
1669        }
1670        if let Some(session_id) = &options.session_id {
1671            command.args(["--session-id", session_id]);
1672        }
1673        if let Some(fork) = &options.fork {
1674            command.args(["--fork", fork]);
1675        }
1676        if let Some(session_dir) = &options.session_dir {
1677            std::fs::create_dir_all(session_dir)?;
1678            command.arg("--session-dir").arg(session_dir);
1679        }
1680        if let Some(name) = &options.name {
1681            command.args(["--name", name]);
1682        }
1683        if let Some(model) = &options.model {
1684            command.args(["--model", model]);
1685        }
1686        if let Some(thinking) = &options.thinking {
1687            command.args(["--thinking", thinking]);
1688        }
1689        if let Some(socket) = &options.broker_socket {
1690            command.env("GLASS_DEV_DAEMON_SOCKET", socket);
1691        }
1692        if let Some(token) = &options.broker_token {
1693            command.env("GLASS_DEV_DAEMON_TOKEN", token);
1694        }
1695        if let Some(workspace_id) = &options.broker_workspace_id {
1696            command.env("GLASS_DEV_DAEMON_WORKSPACE", workspace_id);
1697        }
1698        command
1699            .args(["--system-prompt", &system_prompt, "--extension"])
1700            .arg(&extension_path);
1701        if !trusted_resources {
1702            command.arg("--tools").arg(
1703                [
1704                    "read",
1705                    "write",
1706                    "edit",
1707                    "bash",
1708                    "grep",
1709                    "find",
1710                    "ls",
1711                    "glass_git_status",
1712                    "glass_semantic_inspect",
1713                    "glass_web_ir_inspect",
1714                    "glass_web_ir_diff",
1715                    "glass_web_ir_continuity",
1716                    "glass_task_plan",
1717                    "glass_runtime_inspect",
1718                    "glass_capabilities",
1719                    "glass_diagnostics_run",
1720                    "glass_file_mkdir",
1721                    "glass_file_rename",
1722                    "glass_file_delete",
1723                    "glass_test_run",
1724                    "glass_process_list",
1725                    "glass_process_start",
1726                    "glass_process_stop",
1727                    "glass_process_logs",
1728                    "glass_process_restart",
1729                    "glass_process_input",
1730                    "glass_process_resize",
1731                    "glass_process_health",
1732                    "glass_process_ports",
1733                    "glass_editor_open",
1734                    "glass_editor_selection",
1735                    "glass_editor_replace",
1736                    "glass_editor_replace_selection",
1737                    "glass_editor_save",
1738                    "glass_editor_diff",
1739                    "glass_editor_buffers",
1740                    "glass_browser_state",
1741                    "glass_browser_start",
1742                    "glass_browser_stop",
1743                    "glass_browser_observe",
1744                    "glass_browser_targets",
1745                    "glass_browser_select_target",
1746                    "glass_browser_navigate",
1747                    "glass_browser_act",
1748                    "glass_browser_screenshot",
1749                    "glass_workflow_run",
1750                    "glass_workflow_pause",
1751                    "glass_workflow_resume",
1752                    "glass_git_diff",
1753                    "glass_git_stage",
1754                    "glass_git_unstage",
1755                    "glass_git_commit",
1756                    "glass_git_branches",
1757                    "glass_git_branch_create",
1758                    "glass_git_branch_switch",
1759                    "glass_git_blame",
1760                    "glass_git_worktrees",
1761                    "glass_git_worktree_create",
1762                    "glass_git_worktree_remove",
1763                    "glass_test_discover",
1764                    "glass_test_run_suite",
1765                    "glass_test_results",
1766                    "glass_test_cancel",
1767                    "glass_test_watch",
1768                    "glass_eval_start",
1769                    "glass_eval_execute",
1770                    "glass_eval_list",
1771                    "glass_eval_reset",
1772                    "glass_eval_stop",
1773                    "glass_lsp_diagnostics",
1774                    "glass_lsp_hover",
1775                    "glass_lsp_completion",
1776                    "glass_lsp_definition",
1777                    "glass_lsp_declaration",
1778                    "glass_lsp_implementation",
1779                    "glass_lsp_references",
1780                    "glass_lsp_document_symbols",
1781                    "glass_lsp_workspace_symbols",
1782                    "glass_lsp_signature_help",
1783                    "glass_lsp_code_actions",
1784                    "glass_lsp_formatting",
1785                    "glass_lsp_range_formatting",
1786                    "glass_lsp_semantic_tokens",
1787                    "glass_lsp_rename",
1788                    "glass_debug_start",
1789                    "glass_debug_launch",
1790                    "glass_debug_attach",
1791                    "glass_debug_breakpoint_set",
1792                    "glass_debug_continue",
1793                    "glass_debug_pause",
1794                    "glass_debug_step",
1795                    "glass_debug_stack",
1796                    "glass_debug_scopes",
1797                    "glass_debug_variables",
1798                    "glass_debug_evaluate",
1799                    "glass_debug_events",
1800                    "glass_debug_stop",
1801                    "glass_agent_list",
1802                    "glass_agent_spawn",
1803                    "glass_agent_prompt",
1804                    "glass_agent_steer",
1805                    "glass_agent_follow_up",
1806                    "glass_agent_abort",
1807                    "glass_agent_compact",
1808                    "glass_agent_model",
1809                    "glass_agent_thinking",
1810                    "glass_agent_new_session",
1811                    "glass_agent_clone_session",
1812                    "glass_agent_fork",
1813                    "glass_agent_switch_session",
1814                    "glass_agent_messages",
1815                    "glass_agent_entries",
1816                    "glass_agent_stats",
1817                    "glass_agent_name",
1818                    "glass_graph_query",
1819                    "glass_graph_path",
1820                    "glass_replay_list",
1821                    "glass_replay_diff",
1822                ]
1823                .join(","),
1824            );
1825        }
1826        let mut child = command
1827            .env("GLASS_PI_BROKER_BIN", broker)
1828            .env(
1829                "GLASS_PI_YOLO",
1830                if options.unrestricted { "1" } else { "0" },
1831            )
1832            .current_dir(root)
1833            .stdin(Stdio::piped())
1834            .stdout(Stdio::piped())
1835            .stderr(Stdio::null())
1836            .spawn()
1837            .map_err(|error| DevelopmentError::Process(format!("failed to start Pi: {error}")))?;
1838        let input = child
1839            .stdin
1840            .take()
1841            .ok_or_else(|| DevelopmentError::Process("Pi stdin is unavailable".into()))?;
1842        let output = child
1843            .stdout
1844            .take()
1845            .ok_or_else(|| DevelopmentError::Process("Pi stdout is unavailable".into()))?;
1846        let (sender, receiver) = mpsc::sync_channel(PI_EVENT_CHANNEL_CAPACITY);
1847        thread::Builder::new()
1848            .name("glass-pi-rpc".into())
1849            .spawn(move || {
1850                for line in BufReader::new(output).split(b'\n') {
1851                    let Ok(mut line) = line else { break };
1852                    if line.last() == Some(&b'\r') {
1853                        line.pop();
1854                    }
1855                    if line.len() > MAX_PI_EVENT_BYTES {
1856                        continue;
1857                    }
1858                    if let Ok(value) = serde_json::from_slice::<Value>(&line)
1859                        && sender.send(value).is_err()
1860                    {
1861                        break;
1862                    }
1863                }
1864            })
1865            .map_err(DevelopmentError::Io)?;
1866        Ok(Self {
1867            child,
1868            input,
1869            output: receiver,
1870            next_id: 1,
1871            extension_path,
1872            pending_ui_requests: BTreeSet::new(),
1873            unrestricted: options.unrestricted,
1874        })
1875    }
1876
1877    pub fn request(&mut self, request: HarnessRequest) -> DevelopmentResult<Vec<Value>> {
1878        let wait_for_agent = matches!(request, HarnessRequest::Prompt { .. });
1879        let id = self.start_request(request)?;
1880        let mut events = VecDeque::with_capacity(MAX_PI_BUFFERED_EVENTS);
1881        let mut response_received = false;
1882        let mut observed = 0_usize;
1883        loop {
1884            let value = self
1885                .recv_event_timeout(if response_received {
1886                    Duration::from_secs(120)
1887                } else {
1888                    PI_RESPONSE_TIMEOUT
1889                })?
1890                .ok_or_else(|| {
1891                    DevelopmentError::Process(if response_received {
1892                        "Pi agent event stream timed out".into()
1893                    } else {
1894                        "Pi RPC response timed out".into()
1895                    })
1896                })?;
1897            observed = observed.saturating_add(1);
1898            let is_response = pi_response_matches(&value, &id);
1899            let failed =
1900                is_response && value.get("success").and_then(Value::as_bool) == Some(false);
1901            let settled = pi_agent_settled(&value);
1902            if let Some(request) = pi_ui_request(&value)? {
1903                if !self.unrestricted {
1904                    // A one-shot/non-interactive caller has nowhere safe to ask a
1905                    // human. Deny immediately instead of hanging or inheriting
1906                    // ambient authority.
1907                    self.respond_extension_ui(&request.id, false)?;
1908                }
1909                continue;
1910            }
1911            if pi_event_visible(&value) {
1912                if events.len() == MAX_PI_BUFFERED_EVENTS {
1913                    events.pop_front();
1914                }
1915                events.push_back(value);
1916            }
1917            if failed {
1918                return Err(DevelopmentError::Process(format!(
1919                    "Pi rejected RPC command {id}"
1920                )));
1921            }
1922            if is_response {
1923                response_received = true;
1924                if !wait_for_agent {
1925                    return Ok(events.into());
1926                }
1927            }
1928            if response_received && settled {
1929                return Ok(events.into());
1930            }
1931            if observed >= 4096 {
1932                return Err(DevelopmentError::Process(
1933                    "Pi emitted too many events before settling".into(),
1934                ));
1935            }
1936        }
1937    }
1938
1939    pub fn start_request(&mut self, request: HarnessRequest) -> DevelopmentResult<String> {
1940        let (command, private_text) = match request {
1941            HarnessRequest::Hello | HarnessRequest::State => {
1942                (serde_json::json!({"type": "get_state"}), None)
1943            }
1944            HarnessRequest::Prompt { text } => (
1945                serde_json::json!({"type": "prompt", "message": text}),
1946                Some(()),
1947            ),
1948            HarnessRequest::Steer { text } => (
1949                serde_json::json!({"type": "steer", "message": text}),
1950                Some(()),
1951            ),
1952            HarnessRequest::FollowUp { text } => (
1953                serde_json::json!({"type": "follow_up", "message": text}),
1954                Some(()),
1955            ),
1956            HarnessRequest::Abort => (serde_json::json!({"type": "abort"}), None),
1957            HarnessRequest::Models => (serde_json::json!({"type": "get_available_models"}), None),
1958            HarnessRequest::SetModel { provider, model_id } => (
1959                serde_json::json!({"type": "set_model", "provider": provider, "modelId": model_id}),
1960                None,
1961            ),
1962            HarnessRequest::SetThinking { level } => (
1963                serde_json::json!({"type": "set_thinking_level", "level": level}),
1964                None,
1965            ),
1966            HarnessRequest::NewSession => (serde_json::json!({"type": "new_session"}), None),
1967            HarnessRequest::Compact { instructions } => (
1968                serde_json::json!({"type": "compact", "customInstructions": instructions}),
1969                None,
1970            ),
1971            HarnessRequest::CloneSession => (serde_json::json!({"type": "clone"}), None),
1972            HarnessRequest::Fork { entry_id } => (
1973                serde_json::json!({"type": "fork", "entryId": entry_id}),
1974                None,
1975            ),
1976            HarnessRequest::SwitchSession { path } => (
1977                serde_json::json!({"type": "switch_session", "sessionPath": path}),
1978                None,
1979            ),
1980            HarnessRequest::Entries { since } => (
1981                serde_json::json!({"type": "get_entries", "since": since}),
1982                None,
1983            ),
1984            HarnessRequest::Messages => (serde_json::json!({"type": "get_messages"}), None),
1985            HarnessRequest::SessionStats => {
1986                (serde_json::json!({"type": "get_session_stats"}), None)
1987            }
1988            HarnessRequest::SetSessionName { name } => (
1989                serde_json::json!({"type": "set_session_name", "name": name}),
1990                None,
1991            ),
1992        };
1993        let _private_text = private_text;
1994        self.send(command)
1995    }
1996
1997    fn send(&mut self, mut command: Value) -> DevelopmentResult<String> {
1998        let id = format!("glass-{}", self.next_id);
1999        self.next_id = self.next_id.saturating_add(1);
2000        command["id"] = Value::String(id.clone());
2001        let encoded = serde_json::to_vec(&command)?;
2002        if encoded.len() > 1024 * 1024 {
2003            return Err(DevelopmentError::InvalidInput(
2004                "Pi RPC command exceeds the 1 MiB limit".into(),
2005            ));
2006        }
2007        self.input.write_all(&encoded)?;
2008        self.input.write_all(b"\n")?;
2009        self.input.flush()?;
2010        Ok(id)
2011    }
2012
2013    pub fn respond_extension_ui(&mut self, id: &str, confirmed: bool) -> DevelopmentResult<()> {
2014        if !self.pending_ui_requests.remove(id) {
2015            return Err(DevelopmentError::Conflict(format!(
2016                "stale or unknown Pi UI request: {id}"
2017            )));
2018        }
2019        let encoded = serde_json::to_vec(&serde_json::json!({
2020            "type": "extension_ui_response",
2021            "id": id,
2022            "confirmed": confirmed,
2023        }))?;
2024        self.input.write_all(&encoded)?;
2025        self.input.write_all(b"\n")?;
2026        self.input.flush()?;
2027        Ok(())
2028    }
2029
2030    pub fn recv_event_timeout(&mut self, timeout: Duration) -> DevelopmentResult<Option<Value>> {
2031        match self.output.recv_timeout(timeout) {
2032            Ok(value) => {
2033                if let Some(request) = pi_ui_request(&value)?
2034                    && !self.pending_ui_requests.insert(request.id.clone())
2035                {
2036                    return Err(DevelopmentError::Conflict(format!(
2037                        "duplicate Pi UI request: {}",
2038                        request.id
2039                    )));
2040                }
2041                if self.pending_ui_requests.len() > 8 {
2042                    return Err(DevelopmentError::Conflict(
2043                        "too many pending Pi UI requests".into(),
2044                    ));
2045                }
2046                if self.unrestricted
2047                    && let Some(request) = pi_ui_request(&value)?
2048                {
2049                    self.respond_extension_ui(&request.id, true)?;
2050                }
2051                Ok(Some(value))
2052            }
2053            Err(RecvTimeoutError::Timeout) => Ok(None),
2054            Err(RecvTimeoutError::Disconnected) => Err(DevelopmentError::Process(
2055                "Pi RPC event stream closed".into(),
2056            )),
2057        }
2058    }
2059}
2060
2061fn validate_pi_harness_options(options: &PiHarnessOptions) -> DevelopmentResult<()> {
2062    let broker_fields = [
2063        options.broker_socket.is_some(),
2064        options.broker_token.is_some(),
2065        options.broker_workspace_id.is_some(),
2066    ];
2067    if broker_fields.iter().any(|present| *present) && !broker_fields.iter().all(|present| *present)
2068    {
2069        return Err(DevelopmentError::InvalidInput(
2070            "Pi resident broker socket, token, and workspace must be configured together".into(),
2071        ));
2072    }
2073    if let Some(socket) = &options.broker_socket
2074        && (!socket.is_absolute() || socket == Path::new("/"))
2075    {
2076        return Err(DevelopmentError::InvalidInput(
2077            "Pi resident broker socket must be an explicit absolute path".into(),
2078        ));
2079    }
2080    for (description, value, limit) in [
2081        ("broker token", options.broker_token.as_deref(), 256),
2082        (
2083            "broker workspace",
2084            options.broker_workspace_id.as_deref(),
2085            128,
2086        ),
2087    ] {
2088        if let Some(value) = value
2089            && (value.is_empty() || value.len() > limit || value.chars().any(char::is_control))
2090        {
2091            return Err(DevelopmentError::InvalidInput(format!(
2092                "Pi {description} must contain 1..={limit} non-control bytes"
2093            )));
2094        }
2095    }
2096    if options.session_id.is_some() && options.fork.is_some() {
2097        return Err(DevelopmentError::InvalidInput(
2098            "Pi session ID and fork source are mutually exclusive".into(),
2099        ));
2100    }
2101    if (options.session_id.is_some()
2102        || options.fork.is_some()
2103        || options.session_dir.is_some()
2104        || options.name.is_some())
2105        && !options.persist_session
2106    {
2107        return Err(DevelopmentError::InvalidInput(
2108            "Pi session options require persistent session storage".into(),
2109        ));
2110    }
2111    for (description, value, limit) in [
2112        ("session ID", options.session_id.as_deref(), 256),
2113        ("fork source", options.fork.as_deref(), 4096),
2114        ("session name", options.name.as_deref(), 256),
2115        ("model", options.model.as_deref(), 512),
2116    ] {
2117        if let Some(value) = value
2118            && (value.is_empty()
2119                || value.len() > limit
2120                || value.chars().any(|character| character.is_control()))
2121        {
2122            return Err(DevelopmentError::InvalidInput(format!(
2123                "Pi {description} must contain 1..={limit} non-control bytes"
2124            )));
2125        }
2126    }
2127    if let Some(thinking) = options.thinking.as_deref()
2128        && !matches!(
2129            thinking,
2130            "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
2131        )
2132    {
2133        return Err(DevelopmentError::InvalidInput(
2134            "Pi thinking level must be off, minimal, low, medium, high, xhigh, or max".into(),
2135        ));
2136    }
2137    if let Some(directory) = &options.session_dir
2138        && (!directory.is_absolute() || directory == Path::new("/"))
2139    {
2140        return Err(DevelopmentError::InvalidInput(
2141            "Pi session directory must be an explicit absolute path".into(),
2142        ));
2143    }
2144    Ok(())
2145}
2146
2147fn env_enabled(name: &str) -> bool {
2148    std::env::var(name).is_ok_and(|value| value == "1" || value.eq_ignore_ascii_case("true"))
2149}
2150
2151#[derive(Debug, Clone, PartialEq, Eq)]
2152pub(crate) struct PiUiRequest {
2153    pub id: String,
2154    pub title: String,
2155    pub message: String,
2156}
2157
2158pub(crate) fn pi_ui_request(value: &Value) -> DevelopmentResult<Option<PiUiRequest>> {
2159    if value.get("type").and_then(Value::as_str) != Some("extension_ui_request") {
2160        return Ok(None);
2161    }
2162    let id = value
2163        .get("id")
2164        .and_then(Value::as_str)
2165        .filter(|id| !id.is_empty() && id.len() <= 128 && !id.chars().any(char::is_control))
2166        .ok_or_else(|| DevelopmentError::InvalidInput("invalid Pi UI request id".into()))?;
2167    let method = value.get("method").and_then(Value::as_str).unwrap_or("");
2168    if method != "confirm" {
2169        return Err(DevelopmentError::InvalidInput(format!(
2170            "unsupported Pi UI request method: {method}"
2171        )));
2172    }
2173    let bounded_field = |name: &str, limit: usize| -> DevelopmentResult<String> {
2174        let field = value.get(name).and_then(Value::as_str).unwrap_or("");
2175        if field.len() > limit || field.chars().any(|character| character == '\0') {
2176            return Err(DevelopmentError::InvalidInput(format!(
2177                "invalid Pi UI request {name}"
2178            )));
2179        }
2180        Ok(field.to_string())
2181    };
2182    Ok(Some(PiUiRequest {
2183        id: id.to_string(),
2184        title: bounded_field("title", 256)?,
2185        message: bounded_field("message", 2048)?,
2186    }))
2187}
2188
2189pub(crate) fn pi_response_matches(value: &Value, id: &str) -> bool {
2190    value.get("type").and_then(Value::as_str) == Some("response")
2191        && value.get("id").and_then(Value::as_str) == Some(id)
2192}
2193
2194pub(crate) fn pi_agent_settled(value: &Value) -> bool {
2195    value.get("type").and_then(Value::as_str) == Some("agent_settled")
2196}
2197
2198pub(crate) fn pi_event_visible(value: &Value) -> bool {
2199    if value.get("type").and_then(Value::as_str) == Some("message_end") {
2200        return value
2201            .get("message")
2202            .and_then(|message| message.get("role"))
2203            .and_then(Value::as_str)
2204            == Some("assistant");
2205    }
2206    matches!(
2207        value.get("type").and_then(Value::as_str),
2208        Some(
2209            "response"
2210                | "tool_execution_start"
2211                | "tool_execution_end"
2212                | "agent_settled"
2213                | "extension_error"
2214                | "extension_ui_request"
2215        )
2216    )
2217}
2218
2219pub fn pi_event_display(value: &Value) -> Option<String> {
2220    match value.get("type").and_then(Value::as_str)? {
2221        "message_end" => {
2222            let message = value.get("message")?;
2223            if message.get("role").and_then(Value::as_str) != Some("assistant") {
2224                return None;
2225            }
2226            let content = message.get("content")?;
2227            if let Some(text) = content.as_str() {
2228                return (!text.is_empty()).then(|| text.to_string());
2229            }
2230            let text = content
2231                .as_array()?
2232                .iter()
2233                .filter(|part| part.get("type").and_then(Value::as_str) == Some("text"))
2234                .filter_map(|part| part.get("text").and_then(Value::as_str))
2235                .collect::<Vec<_>>()
2236                .join("\n");
2237            (!text.is_empty()).then_some(text)
2238        }
2239        "tool_execution_start" => Some(format!(
2240            "Pi tool running: {}",
2241            value
2242                .get("toolName")
2243                .and_then(Value::as_str)
2244                .unwrap_or("unknown")
2245        )),
2246        "tool_execution_end" => Some(format!(
2247            "Pi tool {}: {}",
2248            value
2249                .get("toolName")
2250                .and_then(Value::as_str)
2251                .unwrap_or("unknown"),
2252            if value.get("isError").and_then(Value::as_bool) == Some(true) {
2253                "failed"
2254            } else {
2255                "completed"
2256            }
2257        )),
2258        "extension_error" => Some(format!(
2259            "Pi extension error: {}",
2260            value
2261                .get("error")
2262                .and_then(Value::as_str)
2263                .unwrap_or("unknown error")
2264        )),
2265        "response" => serde_json::to_string_pretty(value).ok(),
2266        "agent_settled" | "extension_ui_request" => None,
2267        _ => None,
2268    }
2269}
2270
2271impl Drop for PiHarness {
2272    fn drop(&mut self) {
2273        let _ = self.child.kill();
2274        let _ = self.child.wait();
2275        let _ = std::fs::remove_file(&self.extension_path);
2276    }
2277}
2278
2279fn prompt_evidence(text: &str) -> Value {
2280    let digest = Sha256::digest(text.as_bytes());
2281    serde_json::json!({
2282        "bytes": text.len(),
2283        "sha256": digest.iter().map(|byte| format!("{byte:02x}")).collect::<String>()
2284    })
2285}
2286
2287#[cfg(test)]
2288mod tests {
2289    use super::*;
2290    use std::fs;
2291
2292    #[test]
2293    fn pi_session_options_require_safe_persistent_configuration() {
2294        let directory = std::env::temp_dir().join("glass-pi-sessions");
2295        assert!(
2296            validate_pi_harness_options(&PiHarnessOptions {
2297                persist_session: true,
2298                session_id: Some("session-1".into()),
2299                session_dir: Some(directory),
2300                thinking: Some("high".into()),
2301                ..PiHarnessOptions::default()
2302            })
2303            .is_ok()
2304        );
2305        assert!(
2306            validate_pi_harness_options(&PiHarnessOptions {
2307                session_id: Some("session-1".into()),
2308                ..PiHarnessOptions::default()
2309            })
2310            .is_err()
2311        );
2312        assert!(
2313            validate_pi_harness_options(&PiHarnessOptions {
2314                persist_session: true,
2315                thinking: Some("unbounded".into()),
2316                ..PiHarnessOptions::default()
2317            })
2318            .is_err()
2319        );
2320    }
2321
2322    #[test]
2323    fn local_harness_proves_prompt_tool_result_and_steer_events() {
2324        let root = std::env::temp_dir().join(format!("glass-agent-{}", std::process::id()));
2325        let _ = fs::remove_dir_all(&root);
2326        fs::create_dir_all(&root).unwrap();
2327        fs::write(root.join("note.txt"), "hello agent").unwrap();
2328        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2329        let mut harness = LocalHarness::default();
2330        assert!(matches!(
2331            harness
2332                .handle(&mut workspace, HarnessRequest::Hello)
2333                .unwrap()[0],
2334            HarnessEvent::Hello { .. }
2335        ));
2336        let events = harness
2337            .handle(
2338                &mut workspace,
2339                HarnessRequest::Prompt {
2340                    text: "read note.txt".into(),
2341                },
2342            )
2343            .unwrap();
2344        assert!(
2345            events
2346                .iter()
2347                .any(|event| matches!(event, HarnessEvent::ToolCall(_)))
2348        );
2349        assert!(
2350            events
2351                .iter()
2352                .any(|event| matches!(event, HarnessEvent::ToolResult { .. }))
2353        );
2354        assert!(matches!(
2355            harness
2356                .handle(
2357                    &mut workspace,
2358                    HarnessRequest::Steer {
2359                        text: "stop".into()
2360                    }
2361                )
2362                .unwrap()[0],
2363            HarnessEvent::State { .. }
2364        ));
2365        assert!(workspace.timeline().events().all(|event| {
2366            !event.payload.to_string().contains("read note.txt")
2367                && !event.payload.to_string().contains("stop")
2368        }));
2369        let _ = fs::remove_dir_all(root);
2370    }
2371
2372    #[test]
2373    fn pi_adapter_negotiates_real_rpc_state_when_pi_is_available() {
2374        if Command::new("pi").arg("--version").output().is_err() {
2375            return;
2376        }
2377        let mut harness = PiHarness::spawn(Path::new(".")).unwrap();
2378        let events = harness.request(HarnessRequest::Hello).unwrap();
2379        assert!(
2380            !events.iter().any(|event| {
2381                event.get("type").and_then(Value::as_str) == Some("extension_error")
2382            })
2383        );
2384        assert!(events.iter().any(|event| {
2385            event.get("type").and_then(Value::as_str) == Some("response")
2386                && event.get("command").and_then(Value::as_str) == Some("get_state")
2387                && event.get("success").and_then(Value::as_bool) == Some(true)
2388        }));
2389    }
2390
2391    #[test]
2392    fn pi_contract_is_glass_specific_approved_and_event_bounded() {
2393        let prompt = include_str!("../../assets/pi-glass-system.md");
2394        let tools = include_str!("../../assets/pi-glass-tools.ts");
2395        assert!(prompt.contains("embedded inside Glass Dev"));
2396        assert!(prompt.contains("Structured browser observation is the default"));
2397        assert!(prompt.contains("per-call approval"));
2398        assert!(prompt.contains("glass.editor.proposal.create"));
2399        assert!(prompt.contains("stale proposal"));
2400        assert!(prompt.contains("queued, running, indeterminate, stale, or background"));
2401        assert!(prompt.contains("300 seconds"));
2402        for tool in [
2403            "glass_git_status",
2404            "glass_semantic_inspect",
2405            "glass_web_ir_inspect",
2406            "glass_web_ir_diff",
2407            "glass_web_ir_continuity",
2408            "glass_task_plan",
2409            "glass_runtime_inspect",
2410            "glass_capabilities",
2411            "glass_diagnostics_run",
2412            "glass_file_mkdir",
2413            "glass_file_rename",
2414            "glass_process_start",
2415            "glass_process_stop",
2416            "glass_editor_comments",
2417            "glass_editor_proposal_create",
2418            "glass_editor_proposal_accept",
2419            "glass_editor_checkpoint_create",
2420            "\"read\"",
2421            "\"write\"",
2422            "\"edit\"",
2423            "\"bash\"",
2424            "\"grep\"",
2425            "\"find\"",
2426            "\"ls\"",
2427        ] {
2428            assert!(tools.contains(tool), "missing Pi tool {tool}");
2429        }
2430        assert!(tools.contains("ctx.ui.confirm"));
2431        assert!(tools.contains("GLASS_PI_YOLO"));
2432        assert!(tools.contains("mutating && !unrestricted"));
2433        assert!(tools.contains("--allow-mutation"));
2434        assert!(tools.contains("exact serialized call once"));
2435        assert!(tools.contains("register(\"glass_process_start\", \"glass.process.start\""));
2436        assert!(tools.contains("register(\"glass_process_stop\", \"glass.process.stop\""));
2437
2438        let response = serde_json::json!({
2439            "type": "response",
2440            "id": "glass-9",
2441            "command": "prompt",
2442            "success": true
2443        });
2444        assert!(pi_response_matches(&response, "glass-9"));
2445        assert!(pi_event_visible(&response));
2446        assert!(!pi_agent_settled(&response));
2447        assert!(!pi_event_visible(
2448            &serde_json::json!({"type":"message_update"})
2449        ));
2450        assert!(!pi_event_visible(&serde_json::json!({
2451            "type":"message_end",
2452            "message":{"role":"user","content":"private prompt"}
2453        })));
2454        assert!(!pi_agent_settled(&serde_json::json!({"type":"agent_end"})));
2455        assert!(pi_agent_settled(
2456            &serde_json::json!({"type":"agent_settled"})
2457        ));
2458        assert_eq!(
2459            pi_event_display(&serde_json::json!({
2460                "type":"message_end",
2461                "message":{"role":"assistant","content":[{"type":"text","text":"done"}]}
2462            })),
2463            Some("done".into())
2464        );
2465    }
2466
2467    #[test]
2468    fn pi_ui_requests_accept_only_bounded_confirm_dialogs() {
2469        let request = serde_json::json!({
2470            "type":"extension_ui_request",
2471            "id":"approval-7",
2472            "method":"confirm",
2473            "title":"Approve glass.file.patch?",
2474            "message":"File: src/main.rs"
2475        });
2476        assert_eq!(
2477            pi_ui_request(&request).unwrap(),
2478            Some(PiUiRequest {
2479                id: "approval-7".into(),
2480                title: "Approve glass.file.patch?".into(),
2481                message: "File: src/main.rs".into(),
2482            })
2483        );
2484        assert!(
2485            pi_ui_request(&serde_json::json!({
2486                "type":"extension_ui_request", "id":"x", "method":"input"
2487            }))
2488            .is_err()
2489        );
2490        assert!(
2491            pi_ui_request(&serde_json::json!({
2492                "type":"extension_ui_request", "id":"bad\nid", "method":"confirm"
2493            }))
2494            .is_err()
2495        );
2496    }
2497
2498    #[test]
2499    fn tool_registry_executes_attributed_file_patch_and_fails_closed_for_unattached_browser() {
2500        let root = std::env::temp_dir().join(format!("glass-tools-{}", std::process::id()));
2501        let _ = fs::remove_dir_all(&root);
2502        fs::create_dir_all(&root).unwrap();
2503        fs::write(root.join("note.txt"), "before\n").unwrap();
2504        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2505        let gateway = AgentToolGateway::default();
2506        let result = gateway
2507            .execute(
2508                &mut workspace,
2509                &ToolCall {
2510                    id: "tool-1".into(),
2511                    name: "glass.file.patch".into(),
2512                    arguments: serde_json::json!({"path":"note.txt","search":"before","replace":"after"}),
2513                },
2514                &ToolAuthorization {
2515                    actor: Actor::embedded(),
2516                    allow_mutation: true,
2517                    confirmed: true,
2518                },
2519            )
2520            .unwrap();
2521        assert_eq!(result["replacements"], 1);
2522        assert_eq!(
2523            fs::read_to_string(root.join("note.txt")).unwrap(),
2524            "after\n"
2525        );
2526        assert!(
2527            gateway
2528                .execute(
2529                    &mut workspace,
2530                    &ToolCall {
2531                        id: "tool-2".into(),
2532                        name: "glass.browser.observe".into(),
2533                        arguments: serde_json::json!({}),
2534                    },
2535                    &ToolAuthorization::read_only(Actor::embedded()),
2536                )
2537                .is_err()
2538        );
2539        let _ = fs::remove_dir_all(root);
2540    }
2541
2542    #[test]
2543    fn tool_gateway_rejects_unconfirmed_mutation_and_unknown_arguments_without_audit_leaks() {
2544        let root = std::env::temp_dir().join(format!("glass-tool-policy-{}", std::process::id()));
2545        let _ = fs::remove_dir_all(&root);
2546        fs::create_dir_all(&root).unwrap();
2547        fs::write(root.join("note.txt"), "private-before\n").unwrap();
2548        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2549        let gateway = AgentToolGateway::default();
2550        let mutating = ToolCall {
2551            id: "denied".into(),
2552            name: "glass.file.patch".into(),
2553            arguments: serde_json::json!({
2554                "path":"note.txt",
2555                "search":"private-before",
2556                "replace":"private-after"
2557            }),
2558        };
2559        assert!(
2560            gateway
2561                .execute(
2562                    &mut workspace,
2563                    &mutating,
2564                    &ToolAuthorization::read_only(Actor::embedded()),
2565                )
2566                .is_err()
2567        );
2568        assert_eq!(
2569            fs::read_to_string(root.join("note.txt")).unwrap(),
2570            "private-before\n"
2571        );
2572
2573        let invalid = ToolCall {
2574            id: "invalid".into(),
2575            name: "glass.file.list".into(),
2576            arguments: serde_json::json!({"unexpected":"private-value"}),
2577        };
2578        assert!(
2579            gateway
2580                .execute(
2581                    &mut workspace,
2582                    &invalid,
2583                    &ToolAuthorization::read_only(Actor::embedded()),
2584                )
2585                .is_err()
2586        );
2587        let audit =
2588            serde_json::to_string(&workspace.timeline().events().collect::<Vec<_>>()).unwrap();
2589        assert!(!audit.contains("private-before"));
2590        assert!(!audit.contains("private-after"));
2591        assert!(!audit.contains("private-value"));
2592        let _ = fs::remove_dir_all(root);
2593    }
2594
2595    #[test]
2596    fn coding_gateway_writes_and_applies_atomic_multi_edits() {
2597        let root = std::env::temp_dir().join(format!("glass-coding-tools-{}", std::process::id()));
2598        let _ = fs::remove_dir_all(&root);
2599        fs::create_dir_all(&root).unwrap();
2600        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2601        let gateway = AgentToolGateway::default();
2602        let authority = ToolAuthorization {
2603            actor: Actor::external("pi"),
2604            allow_mutation: true,
2605            confirmed: true,
2606        };
2607        gateway
2608            .execute(
2609                &mut workspace,
2610                &ToolCall {
2611                    id: "write-1".into(),
2612                    name: "glass.file.write".into(),
2613                    arguments: serde_json::json!({
2614                        "path":"src/example.rs",
2615                        "content":"fn alpha() {}\nfn beta() {}\n"
2616                    }),
2617                },
2618                &authority,
2619            )
2620            .unwrap();
2621        let result = gateway
2622            .execute(
2623                &mut workspace,
2624                &ToolCall {
2625                    id: "edit-1".into(),
2626                    name: "glass.file.edit".into(),
2627                    arguments: serde_json::json!({
2628                        "path":"src/example.rs",
2629                        "edits":[
2630                            {"oldText":"alpha", "newText":"first"},
2631                            {"oldText":"beta", "newText":"second"}
2632                        ]
2633                    }),
2634                },
2635                &authority,
2636            )
2637            .unwrap();
2638        assert_eq!(result["replacements"], 2);
2639        assert_eq!(
2640            fs::read_to_string(root.join("src/example.rs")).unwrap(),
2641            "fn first() {}\nfn second() {}\n"
2642        );
2643        let read = gateway
2644            .execute(
2645                &mut workspace,
2646                &ToolCall {
2647                    id: "read-page".into(),
2648                    name: "glass.file.read".into(),
2649                    arguments: serde_json::json!({"path":"src/example.rs","offset":2,"limit":1}),
2650                },
2651                &ToolAuthorization::read_only(Actor::external("pi")),
2652            )
2653            .unwrap();
2654        assert_eq!(read["content"], "fn second() {}\n");
2655        assert_eq!(read["offset"], 2);
2656        assert!(
2657            read["sha256"]
2658                .as_str()
2659                .is_some_and(|value| value.len() == 64)
2660        );
2661
2662        {
2663            let command = "printf command-private-value";
2664            let command_result = gateway
2665                .execute(
2666                    &mut workspace,
2667                    &ToolCall {
2668                        id: "command-1".into(),
2669                        name: "glass.command.run".into(),
2670                        arguments: serde_json::json!({
2671                            "name":"pi-command-test", "command":command, "timeoutSeconds":5
2672                        }),
2673                    },
2674                    &authority,
2675                )
2676                .unwrap();
2677            assert!(
2678                command_result["output"]
2679                    .as_str()
2680                    .is_some_and(|value| value.contains("command-private-value"))
2681            );
2682            assert!(
2683                workspace
2684                    .timeline()
2685                    .events()
2686                    .all(|event| !event.payload.to_string().contains(command))
2687            );
2688            assert!(workspace.timeline().events().all(|event| !matches!(
2689                event.kind,
2690                DevelopmentEventKind::TestStarted | DevelopmentEventKind::TestCompleted
2691            )));
2692        }
2693        let _ = fs::remove_dir_all(root);
2694    }
2695
2696    #[test]
2697    fn coding_gateway_lists_finds_and_greps_with_bounded_standard_semantics() {
2698        let root = std::env::temp_dir().join(format!("glass-coding-search-{}", std::process::id()));
2699        let _ = fs::remove_dir_all(&root);
2700        fs::create_dir_all(root.join("src/nested")).unwrap();
2701        fs::write(root.join("src/lib.rs"), "alpha\nNeedle target\nomega\n").unwrap();
2702        fs::write(root.join("src/nested/mod.rs"), "needle second\n").unwrap();
2703        fs::write(root.join("README.md"), "Needle outside\n").unwrap();
2704        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2705        let gateway = AgentToolGateway::default();
2706        let authority = ToolAuthorization::read_only(Actor::external("pi"));
2707
2708        let listed = gateway
2709            .execute(
2710                &mut workspace,
2711                &ToolCall {
2712                    id: "list-src".into(),
2713                    name: "glass.file.list".into(),
2714                    arguments: serde_json::json!({"path":"src","limit":2}),
2715                },
2716                &authority,
2717            )
2718            .unwrap();
2719        assert_eq!(listed["entries"].as_array().unwrap().len(), 2);
2720        assert_eq!(listed["truncated"], true);
2721        assert!(
2722            listed["entries"]
2723                .as_array()
2724                .unwrap()
2725                .iter()
2726                .all(|entry| entry["path"].as_str().unwrap().starts_with("src"))
2727        );
2728
2729        let found = gateway
2730            .execute(
2731                &mut workspace,
2732                &ToolCall {
2733                    id: "find-rs".into(),
2734                    name: "glass.file.find".into(),
2735                    arguments: serde_json::json!({"pattern":"src/*.rs","limit":20}),
2736                },
2737                &authority,
2738            )
2739            .unwrap();
2740        assert_eq!(found["paths"].as_array().unwrap().len(), 2);
2741
2742        let grep = gateway
2743            .execute(
2744                &mut workspace,
2745                &ToolCall {
2746                    id: "grep-needle".into(),
2747                    name: "glass.file.grep".into(),
2748                    arguments: serde_json::json!({
2749                        "pattern":"needle", "path":"src", "glob":"*.rs",
2750                        "ignoreCase":true, "context":1, "limit":10
2751                    }),
2752                },
2753                &authority,
2754            )
2755            .unwrap();
2756        assert_eq!(grep["matches"].as_array().unwrap().len(), 2);
2757        assert_eq!(grep["literal"], true);
2758        assert_eq!(grep["matches"][0]["contextBefore"][0], "alpha");
2759        let _ = fs::remove_dir_all(root);
2760    }
2761
2762    #[test]
2763    fn tool_gateway_bounds_envelopes_and_reuses_its_descriptor_catalog() {
2764        let root = std::env::temp_dir().join(format!("glass-tool-envelope-{}", std::process::id()));
2765        let _ = fs::remove_dir_all(&root);
2766        fs::create_dir_all(&root).unwrap();
2767        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2768        let gateway = AgentToolGateway::default();
2769        let descriptor_storage = gateway.descriptors.as_ptr();
2770
2771        for (id, name) in [("", "glass.file.list"), ("valid", "bad name")] {
2772            let error = gateway
2773                .execute(
2774                    &mut workspace,
2775                    &ToolCall {
2776                        id: id.into(),
2777                        name: name.into(),
2778                        arguments: serde_json::json!({}),
2779                    },
2780                    &ToolAuthorization::read_only(Actor::embedded()),
2781                )
2782                .unwrap_err();
2783            assert!(matches!(error, DevelopmentError::InvalidInput(_)));
2784        }
2785        let oversized_id = "x".repeat(MAX_TOOL_CALL_ID_BYTES + 1);
2786        assert!(
2787            gateway
2788                .execute(
2789                    &mut workspace,
2790                    &ToolCall {
2791                        id: oversized_id,
2792                        name: "glass.file.list".into(),
2793                        arguments: serde_json::json!({}),
2794                    },
2795                    &ToolAuthorization::read_only(Actor::embedded()),
2796                )
2797                .is_err()
2798        );
2799        assert_eq!(descriptor_storage, gateway.descriptors.as_ptr());
2800        let _ = fs::remove_dir_all(root);
2801    }
2802
2803    #[test]
2804    fn subprocess_broker_reports_resident_process_tools_as_unavailable() {
2805        let gateway = AgentToolGateway::subprocess_broker();
2806        for name in [
2807            "glass.process.start",
2808            "glass.process.stop",
2809            "glass.process.logs",
2810            "glass.process.list",
2811        ] {
2812            let descriptor = gateway
2813                .descriptors()
2814                .into_iter()
2815                .find(|descriptor| descriptor.name == name)
2816                .unwrap();
2817            assert!(!descriptor.available);
2818            assert!(
2819                descriptor
2820                    .unavailable_reason
2821                    .as_deref()
2822                    .is_some_and(|reason| reason.contains("resident Glass Dev"))
2823            );
2824        }
2825        let root = std::env::temp_dir().join(format!("glass-capabilities-{}", std::process::id()));
2826        let _ = fs::remove_dir_all(&root);
2827        fs::create_dir_all(&root).unwrap();
2828        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2829        let result = gateway
2830            .execute(
2831                &mut workspace,
2832                &ToolCall {
2833                    id: "capabilities".into(),
2834                    name: "glass.capabilities.inspect".into(),
2835                    arguments: serde_json::json!({}),
2836                },
2837                &ToolAuthorization::read_only(Actor::external("pi")),
2838            )
2839            .unwrap();
2840        let processes = result
2841            .as_array()
2842            .unwrap()
2843            .iter()
2844            .filter(|descriptor| {
2845                descriptor["name"]
2846                    .as_str()
2847                    .is_some_and(|name| name.starts_with("glass.process."))
2848            })
2849            .collect::<Vec<_>>();
2850        assert_eq!(processes.len(), 5);
2851        assert!(
2852            processes
2853                .iter()
2854                .all(|descriptor| descriptor["available"] == false)
2855        );
2856        let _ = fs::remove_dir_all(root);
2857    }
2858
2859    #[test]
2860    fn attached_browser_enables_structured_observation_without_mutation_authority() {
2861        let root = std::env::temp_dir().join(format!("glass-tool-browser-{}", std::process::id()));
2862        let _ = fs::remove_dir_all(&root);
2863        fs::create_dir_all(&root).unwrap();
2864        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2865        let mut gateway = AgentToolGateway::default();
2866        gateway.set_browser_context(Some(BrowserAgentContext {
2867            connected: true,
2868            target_id: Some("page-1".into()),
2869            origin: Some("https://example.test".into()),
2870            url: "https://example.test/".into(),
2871            title: "Example".into(),
2872            browser_revision: 42,
2873            semantic_summary: "button Continue".into(),
2874            semantic_entity_count: 1,
2875            selected_entity: Some(serde_json::json!({"reference":"e1","name":"Continue"})),
2876            workflow_state: "idle".into(),
2877            input_owner: "Glass".into(),
2878            freshness: "current".into(),
2879            memory_scope: "profile/default".into(),
2880        }));
2881        let descriptor = gateway
2882            .descriptors()
2883            .into_iter()
2884            .find(|item| item.name == "glass.browser.observe")
2885            .unwrap();
2886        assert!(descriptor.available);
2887        let result = gateway
2888            .execute(
2889                &mut workspace,
2890                &ToolCall {
2891                    id: "observe-1".into(),
2892                    name: "glass.browser.observe".into(),
2893                    arguments: serde_json::json!({}),
2894                },
2895                &ToolAuthorization::read_only(Actor::embedded()),
2896            )
2897            .unwrap();
2898        assert_eq!(result["browserRevision"], 42);
2899        assert_eq!(result["structured"], true);
2900        assert!(
2901            !gateway
2902                .descriptors()
2903                .into_iter()
2904                .find(|item| item.name == "glass.browser.act")
2905                .unwrap()
2906                .available
2907        );
2908        let _ = fs::remove_dir_all(root);
2909    }
2910
2911    #[test]
2912    fn tool_argument_evidence_is_streamed_once_and_stays_canonical() {
2913        let registry = ToolRegistry;
2914        let descriptor = registry
2915            .descriptors()
2916            .into_iter()
2917            .find(|descriptor| descriptor.name == "glass.file.read")
2918            .unwrap();
2919        let arguments = serde_json::json!({"path":"src/lib.rs"});
2920        let evidence = validate_tool_arguments(&descriptor, &arguments).unwrap();
2921        let canonical = serde_json::to_vec(&arguments).unwrap();
2922        assert_eq!(evidence.bytes, canonical.len());
2923        assert_eq!(evidence.sha256, digest_hex(&Sha256::digest(&canonical)));
2924
2925        let oversized = serde_json::json!({"path":"x".repeat(MAX_TOOL_ARGUMENT_BYTES)});
2926        let error = validate_tool_arguments(&descriptor, &oversized)
2927            .err()
2928            .expect("oversized arguments must fail");
2929        assert!(error.to_string().contains("tool arguments exceed"));
2930    }
2931
2932    #[test]
2933    fn semantic_context_resolves_explicit_references_without_dumping_file_contents() {
2934        let root = std::env::temp_dir().join(format!("glass-context-{}", std::process::id()));
2935        let _ = fs::remove_dir_all(&root);
2936        fs::create_dir_all(&root).unwrap();
2937        fs::write(root.join("secret.txt"), "do not inline this source").unwrap();
2938        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2939        let packet =
2940            resolve_context(&mut workspace, "Inspect @workspace and @file:secret.txt").unwrap();
2941        let serialized = serde_json::to_string(&packet).unwrap();
2942        assert!(!serialized.contains("do not inline this source"));
2943        assert_eq!(packet.references.len(), 2);
2944    }
2945}