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_save",
1737                    "glass_editor_diff",
1738                    "glass_editor_buffers",
1739                    "glass_browser_state",
1740                    "glass_browser_start",
1741                    "glass_browser_stop",
1742                    "glass_browser_observe",
1743                    "glass_browser_targets",
1744                    "glass_browser_select_target",
1745                    "glass_browser_navigate",
1746                    "glass_browser_act",
1747                    "glass_browser_screenshot",
1748                    "glass_workflow_run",
1749                    "glass_workflow_pause",
1750                    "glass_workflow_resume",
1751                    "glass_git_diff",
1752                    "glass_git_stage",
1753                    "glass_git_unstage",
1754                    "glass_git_commit",
1755                    "glass_git_branches",
1756                    "glass_git_branch_create",
1757                    "glass_git_branch_switch",
1758                    "glass_git_blame",
1759                    "glass_git_worktrees",
1760                    "glass_git_worktree_create",
1761                    "glass_git_worktree_remove",
1762                    "glass_test_discover",
1763                    "glass_test_run_suite",
1764                    "glass_test_results",
1765                    "glass_test_cancel",
1766                    "glass_test_watch",
1767                    "glass_eval_start",
1768                    "glass_eval_execute",
1769                    "glass_eval_list",
1770                    "glass_eval_reset",
1771                    "glass_eval_stop",
1772                    "glass_lsp_diagnostics",
1773                    "glass_lsp_hover",
1774                    "glass_lsp_completion",
1775                    "glass_lsp_definition",
1776                    "glass_lsp_declaration",
1777                    "glass_lsp_implementation",
1778                    "glass_lsp_references",
1779                    "glass_lsp_document_symbols",
1780                    "glass_lsp_workspace_symbols",
1781                    "glass_lsp_signature_help",
1782                    "glass_lsp_code_actions",
1783                    "glass_lsp_formatting",
1784                    "glass_lsp_range_formatting",
1785                    "glass_lsp_semantic_tokens",
1786                    "glass_lsp_rename",
1787                    "glass_debug_start",
1788                    "glass_debug_launch",
1789                    "glass_debug_attach",
1790                    "glass_debug_breakpoint_set",
1791                    "glass_debug_continue",
1792                    "glass_debug_pause",
1793                    "glass_debug_step",
1794                    "glass_debug_stack",
1795                    "glass_debug_scopes",
1796                    "glass_debug_variables",
1797                    "glass_debug_evaluate",
1798                    "glass_debug_events",
1799                    "glass_debug_stop",
1800                    "glass_agent_list",
1801                    "glass_agent_spawn",
1802                    "glass_agent_prompt",
1803                    "glass_agent_steer",
1804                    "glass_agent_follow_up",
1805                    "glass_agent_abort",
1806                    "glass_agent_compact",
1807                    "glass_agent_model",
1808                    "glass_agent_thinking",
1809                    "glass_agent_new_session",
1810                    "glass_agent_clone_session",
1811                    "glass_agent_fork",
1812                    "glass_agent_switch_session",
1813                    "glass_agent_messages",
1814                    "glass_agent_entries",
1815                    "glass_agent_stats",
1816                    "glass_agent_name",
1817                    "glass_graph_query",
1818                    "glass_graph_path",
1819                    "glass_replay_list",
1820                    "glass_replay_diff",
1821                ]
1822                .join(","),
1823            );
1824        }
1825        let mut child = command
1826            .env("GLASS_PI_BROKER_BIN", broker)
1827            .env(
1828                "GLASS_PI_YOLO",
1829                if options.unrestricted { "1" } else { "0" },
1830            )
1831            .current_dir(root)
1832            .stdin(Stdio::piped())
1833            .stdout(Stdio::piped())
1834            .stderr(Stdio::null())
1835            .spawn()
1836            .map_err(|error| DevelopmentError::Process(format!("failed to start Pi: {error}")))?;
1837        let input = child
1838            .stdin
1839            .take()
1840            .ok_or_else(|| DevelopmentError::Process("Pi stdin is unavailable".into()))?;
1841        let output = child
1842            .stdout
1843            .take()
1844            .ok_or_else(|| DevelopmentError::Process("Pi stdout is unavailable".into()))?;
1845        let (sender, receiver) = mpsc::sync_channel(PI_EVENT_CHANNEL_CAPACITY);
1846        thread::Builder::new()
1847            .name("glass-pi-rpc".into())
1848            .spawn(move || {
1849                for line in BufReader::new(output).split(b'\n') {
1850                    let Ok(mut line) = line else { break };
1851                    if line.last() == Some(&b'\r') {
1852                        line.pop();
1853                    }
1854                    if line.len() > MAX_PI_EVENT_BYTES {
1855                        continue;
1856                    }
1857                    if let Ok(value) = serde_json::from_slice::<Value>(&line)
1858                        && sender.send(value).is_err()
1859                    {
1860                        break;
1861                    }
1862                }
1863            })
1864            .map_err(DevelopmentError::Io)?;
1865        Ok(Self {
1866            child,
1867            input,
1868            output: receiver,
1869            next_id: 1,
1870            extension_path,
1871            pending_ui_requests: BTreeSet::new(),
1872            unrestricted: options.unrestricted,
1873        })
1874    }
1875
1876    pub fn request(&mut self, request: HarnessRequest) -> DevelopmentResult<Vec<Value>> {
1877        let wait_for_agent = matches!(request, HarnessRequest::Prompt { .. });
1878        let id = self.start_request(request)?;
1879        let mut events = VecDeque::with_capacity(MAX_PI_BUFFERED_EVENTS);
1880        let mut response_received = false;
1881        let mut observed = 0_usize;
1882        loop {
1883            let value = self
1884                .recv_event_timeout(if response_received {
1885                    Duration::from_secs(120)
1886                } else {
1887                    PI_RESPONSE_TIMEOUT
1888                })?
1889                .ok_or_else(|| {
1890                    DevelopmentError::Process(if response_received {
1891                        "Pi agent event stream timed out".into()
1892                    } else {
1893                        "Pi RPC response timed out".into()
1894                    })
1895                })?;
1896            observed = observed.saturating_add(1);
1897            let is_response = pi_response_matches(&value, &id);
1898            let failed =
1899                is_response && value.get("success").and_then(Value::as_bool) == Some(false);
1900            let settled = pi_agent_settled(&value);
1901            if let Some(request) = pi_ui_request(&value)? {
1902                if !self.unrestricted {
1903                    // A one-shot/non-interactive caller has nowhere safe to ask a
1904                    // human. Deny immediately instead of hanging or inheriting
1905                    // ambient authority.
1906                    self.respond_extension_ui(&request.id, false)?;
1907                }
1908                continue;
1909            }
1910            if pi_event_visible(&value) {
1911                if events.len() == MAX_PI_BUFFERED_EVENTS {
1912                    events.pop_front();
1913                }
1914                events.push_back(value);
1915            }
1916            if failed {
1917                return Err(DevelopmentError::Process(format!(
1918                    "Pi rejected RPC command {id}"
1919                )));
1920            }
1921            if is_response {
1922                response_received = true;
1923                if !wait_for_agent {
1924                    return Ok(events.into());
1925                }
1926            }
1927            if response_received && settled {
1928                return Ok(events.into());
1929            }
1930            if observed >= 4096 {
1931                return Err(DevelopmentError::Process(
1932                    "Pi emitted too many events before settling".into(),
1933                ));
1934            }
1935        }
1936    }
1937
1938    pub fn start_request(&mut self, request: HarnessRequest) -> DevelopmentResult<String> {
1939        let (command, private_text) = match request {
1940            HarnessRequest::Hello | HarnessRequest::State => {
1941                (serde_json::json!({"type": "get_state"}), None)
1942            }
1943            HarnessRequest::Prompt { text } => (
1944                serde_json::json!({"type": "prompt", "message": text}),
1945                Some(()),
1946            ),
1947            HarnessRequest::Steer { text } => (
1948                serde_json::json!({"type": "steer", "message": text}),
1949                Some(()),
1950            ),
1951            HarnessRequest::FollowUp { text } => (
1952                serde_json::json!({"type": "follow_up", "message": text}),
1953                Some(()),
1954            ),
1955            HarnessRequest::Abort => (serde_json::json!({"type": "abort"}), None),
1956            HarnessRequest::Models => (serde_json::json!({"type": "get_available_models"}), None),
1957            HarnessRequest::SetModel { provider, model_id } => (
1958                serde_json::json!({"type": "set_model", "provider": provider, "modelId": model_id}),
1959                None,
1960            ),
1961            HarnessRequest::SetThinking { level } => (
1962                serde_json::json!({"type": "set_thinking_level", "level": level}),
1963                None,
1964            ),
1965            HarnessRequest::NewSession => (serde_json::json!({"type": "new_session"}), None),
1966            HarnessRequest::Compact { instructions } => (
1967                serde_json::json!({"type": "compact", "customInstructions": instructions}),
1968                None,
1969            ),
1970            HarnessRequest::CloneSession => (serde_json::json!({"type": "clone"}), None),
1971            HarnessRequest::Fork { entry_id } => (
1972                serde_json::json!({"type": "fork", "entryId": entry_id}),
1973                None,
1974            ),
1975            HarnessRequest::SwitchSession { path } => (
1976                serde_json::json!({"type": "switch_session", "sessionPath": path}),
1977                None,
1978            ),
1979            HarnessRequest::Entries { since } => (
1980                serde_json::json!({"type": "get_entries", "since": since}),
1981                None,
1982            ),
1983            HarnessRequest::Messages => (serde_json::json!({"type": "get_messages"}), None),
1984            HarnessRequest::SessionStats => {
1985                (serde_json::json!({"type": "get_session_stats"}), None)
1986            }
1987            HarnessRequest::SetSessionName { name } => (
1988                serde_json::json!({"type": "set_session_name", "name": name}),
1989                None,
1990            ),
1991        };
1992        let _private_text = private_text;
1993        self.send(command)
1994    }
1995
1996    fn send(&mut self, mut command: Value) -> DevelopmentResult<String> {
1997        let id = format!("glass-{}", self.next_id);
1998        self.next_id = self.next_id.saturating_add(1);
1999        command["id"] = Value::String(id.clone());
2000        let encoded = serde_json::to_vec(&command)?;
2001        if encoded.len() > 1024 * 1024 {
2002            return Err(DevelopmentError::InvalidInput(
2003                "Pi RPC command exceeds the 1 MiB limit".into(),
2004            ));
2005        }
2006        self.input.write_all(&encoded)?;
2007        self.input.write_all(b"\n")?;
2008        self.input.flush()?;
2009        Ok(id)
2010    }
2011
2012    pub fn respond_extension_ui(&mut self, id: &str, confirmed: bool) -> DevelopmentResult<()> {
2013        if !self.pending_ui_requests.remove(id) {
2014            return Err(DevelopmentError::Conflict(format!(
2015                "stale or unknown Pi UI request: {id}"
2016            )));
2017        }
2018        let encoded = serde_json::to_vec(&serde_json::json!({
2019            "type": "extension_ui_response",
2020            "id": id,
2021            "confirmed": confirmed,
2022        }))?;
2023        self.input.write_all(&encoded)?;
2024        self.input.write_all(b"\n")?;
2025        self.input.flush()?;
2026        Ok(())
2027    }
2028
2029    pub fn recv_event_timeout(&mut self, timeout: Duration) -> DevelopmentResult<Option<Value>> {
2030        match self.output.recv_timeout(timeout) {
2031            Ok(value) => {
2032                if let Some(request) = pi_ui_request(&value)?
2033                    && !self.pending_ui_requests.insert(request.id.clone())
2034                {
2035                    return Err(DevelopmentError::Conflict(format!(
2036                        "duplicate Pi UI request: {}",
2037                        request.id
2038                    )));
2039                }
2040                if self.pending_ui_requests.len() > 8 {
2041                    return Err(DevelopmentError::Conflict(
2042                        "too many pending Pi UI requests".into(),
2043                    ));
2044                }
2045                if self.unrestricted
2046                    && let Some(request) = pi_ui_request(&value)?
2047                {
2048                    self.respond_extension_ui(&request.id, true)?;
2049                }
2050                Ok(Some(value))
2051            }
2052            Err(RecvTimeoutError::Timeout) => Ok(None),
2053            Err(RecvTimeoutError::Disconnected) => Err(DevelopmentError::Process(
2054                "Pi RPC event stream closed".into(),
2055            )),
2056        }
2057    }
2058}
2059
2060fn validate_pi_harness_options(options: &PiHarnessOptions) -> DevelopmentResult<()> {
2061    let broker_fields = [
2062        options.broker_socket.is_some(),
2063        options.broker_token.is_some(),
2064        options.broker_workspace_id.is_some(),
2065    ];
2066    if broker_fields.iter().any(|present| *present) && !broker_fields.iter().all(|present| *present)
2067    {
2068        return Err(DevelopmentError::InvalidInput(
2069            "Pi resident broker socket, token, and workspace must be configured together".into(),
2070        ));
2071    }
2072    if let Some(socket) = &options.broker_socket
2073        && (!socket.is_absolute() || socket == Path::new("/"))
2074    {
2075        return Err(DevelopmentError::InvalidInput(
2076            "Pi resident broker socket must be an explicit absolute path".into(),
2077        ));
2078    }
2079    for (description, value, limit) in [
2080        ("broker token", options.broker_token.as_deref(), 256),
2081        (
2082            "broker workspace",
2083            options.broker_workspace_id.as_deref(),
2084            128,
2085        ),
2086    ] {
2087        if let Some(value) = value
2088            && (value.is_empty() || value.len() > limit || value.chars().any(char::is_control))
2089        {
2090            return Err(DevelopmentError::InvalidInput(format!(
2091                "Pi {description} must contain 1..={limit} non-control bytes"
2092            )));
2093        }
2094    }
2095    if options.session_id.is_some() && options.fork.is_some() {
2096        return Err(DevelopmentError::InvalidInput(
2097            "Pi session ID and fork source are mutually exclusive".into(),
2098        ));
2099    }
2100    if (options.session_id.is_some()
2101        || options.fork.is_some()
2102        || options.session_dir.is_some()
2103        || options.name.is_some())
2104        && !options.persist_session
2105    {
2106        return Err(DevelopmentError::InvalidInput(
2107            "Pi session options require persistent session storage".into(),
2108        ));
2109    }
2110    for (description, value, limit) in [
2111        ("session ID", options.session_id.as_deref(), 256),
2112        ("fork source", options.fork.as_deref(), 4096),
2113        ("session name", options.name.as_deref(), 256),
2114        ("model", options.model.as_deref(), 512),
2115    ] {
2116        if let Some(value) = value
2117            && (value.is_empty()
2118                || value.len() > limit
2119                || value.chars().any(|character| character.is_control()))
2120        {
2121            return Err(DevelopmentError::InvalidInput(format!(
2122                "Pi {description} must contain 1..={limit} non-control bytes"
2123            )));
2124        }
2125    }
2126    if let Some(thinking) = options.thinking.as_deref()
2127        && !matches!(
2128            thinking,
2129            "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"
2130        )
2131    {
2132        return Err(DevelopmentError::InvalidInput(
2133            "Pi thinking level must be off, minimal, low, medium, high, xhigh, or max".into(),
2134        ));
2135    }
2136    if let Some(directory) = &options.session_dir
2137        && (!directory.is_absolute() || directory == Path::new("/"))
2138    {
2139        return Err(DevelopmentError::InvalidInput(
2140            "Pi session directory must be an explicit absolute path".into(),
2141        ));
2142    }
2143    Ok(())
2144}
2145
2146fn env_enabled(name: &str) -> bool {
2147    std::env::var(name).is_ok_and(|value| value == "1" || value.eq_ignore_ascii_case("true"))
2148}
2149
2150#[derive(Debug, Clone, PartialEq, Eq)]
2151pub(crate) struct PiUiRequest {
2152    pub id: String,
2153    pub title: String,
2154    pub message: String,
2155}
2156
2157pub(crate) fn pi_ui_request(value: &Value) -> DevelopmentResult<Option<PiUiRequest>> {
2158    if value.get("type").and_then(Value::as_str) != Some("extension_ui_request") {
2159        return Ok(None);
2160    }
2161    let id = value
2162        .get("id")
2163        .and_then(Value::as_str)
2164        .filter(|id| !id.is_empty() && id.len() <= 128 && !id.chars().any(char::is_control))
2165        .ok_or_else(|| DevelopmentError::InvalidInput("invalid Pi UI request id".into()))?;
2166    let method = value.get("method").and_then(Value::as_str).unwrap_or("");
2167    if method != "confirm" {
2168        return Err(DevelopmentError::InvalidInput(format!(
2169            "unsupported Pi UI request method: {method}"
2170        )));
2171    }
2172    let bounded_field = |name: &str, limit: usize| -> DevelopmentResult<String> {
2173        let field = value.get(name).and_then(Value::as_str).unwrap_or("");
2174        if field.len() > limit || field.chars().any(|character| character == '\0') {
2175            return Err(DevelopmentError::InvalidInput(format!(
2176                "invalid Pi UI request {name}"
2177            )));
2178        }
2179        Ok(field.to_string())
2180    };
2181    Ok(Some(PiUiRequest {
2182        id: id.to_string(),
2183        title: bounded_field("title", 256)?,
2184        message: bounded_field("message", 2048)?,
2185    }))
2186}
2187
2188pub(crate) fn pi_response_matches(value: &Value, id: &str) -> bool {
2189    value.get("type").and_then(Value::as_str) == Some("response")
2190        && value.get("id").and_then(Value::as_str) == Some(id)
2191}
2192
2193pub(crate) fn pi_agent_settled(value: &Value) -> bool {
2194    value.get("type").and_then(Value::as_str) == Some("agent_settled")
2195}
2196
2197pub(crate) fn pi_event_visible(value: &Value) -> bool {
2198    if value.get("type").and_then(Value::as_str) == Some("message_end") {
2199        return value
2200            .get("message")
2201            .and_then(|message| message.get("role"))
2202            .and_then(Value::as_str)
2203            == Some("assistant");
2204    }
2205    matches!(
2206        value.get("type").and_then(Value::as_str),
2207        Some(
2208            "response"
2209                | "tool_execution_start"
2210                | "tool_execution_end"
2211                | "agent_settled"
2212                | "extension_error"
2213                | "extension_ui_request"
2214        )
2215    )
2216}
2217
2218pub fn pi_event_display(value: &Value) -> Option<String> {
2219    match value.get("type").and_then(Value::as_str)? {
2220        "message_end" => {
2221            let message = value.get("message")?;
2222            if message.get("role").and_then(Value::as_str) != Some("assistant") {
2223                return None;
2224            }
2225            let content = message.get("content")?;
2226            if let Some(text) = content.as_str() {
2227                return (!text.is_empty()).then(|| text.to_string());
2228            }
2229            let text = content
2230                .as_array()?
2231                .iter()
2232                .filter(|part| part.get("type").and_then(Value::as_str) == Some("text"))
2233                .filter_map(|part| part.get("text").and_then(Value::as_str))
2234                .collect::<Vec<_>>()
2235                .join("\n");
2236            (!text.is_empty()).then_some(text)
2237        }
2238        "tool_execution_start" => Some(format!(
2239            "Pi tool running: {}",
2240            value
2241                .get("toolName")
2242                .and_then(Value::as_str)
2243                .unwrap_or("unknown")
2244        )),
2245        "tool_execution_end" => Some(format!(
2246            "Pi tool {}: {}",
2247            value
2248                .get("toolName")
2249                .and_then(Value::as_str)
2250                .unwrap_or("unknown"),
2251            if value.get("isError").and_then(Value::as_bool) == Some(true) {
2252                "failed"
2253            } else {
2254                "completed"
2255            }
2256        )),
2257        "extension_error" => Some(format!(
2258            "Pi extension error: {}",
2259            value
2260                .get("error")
2261                .and_then(Value::as_str)
2262                .unwrap_or("unknown error")
2263        )),
2264        "response" => serde_json::to_string_pretty(value).ok(),
2265        "agent_settled" | "extension_ui_request" => None,
2266        _ => None,
2267    }
2268}
2269
2270impl Drop for PiHarness {
2271    fn drop(&mut self) {
2272        let _ = self.child.kill();
2273        let _ = self.child.wait();
2274        let _ = std::fs::remove_file(&self.extension_path);
2275    }
2276}
2277
2278fn prompt_evidence(text: &str) -> Value {
2279    let digest = Sha256::digest(text.as_bytes());
2280    serde_json::json!({
2281        "bytes": text.len(),
2282        "sha256": digest.iter().map(|byte| format!("{byte:02x}")).collect::<String>()
2283    })
2284}
2285
2286#[cfg(test)]
2287mod tests {
2288    use super::*;
2289    use std::fs;
2290
2291    #[test]
2292    fn pi_session_options_require_safe_persistent_configuration() {
2293        let directory = std::env::temp_dir().join("glass-pi-sessions");
2294        assert!(
2295            validate_pi_harness_options(&PiHarnessOptions {
2296                persist_session: true,
2297                session_id: Some("session-1".into()),
2298                session_dir: Some(directory),
2299                thinking: Some("high".into()),
2300                ..PiHarnessOptions::default()
2301            })
2302            .is_ok()
2303        );
2304        assert!(
2305            validate_pi_harness_options(&PiHarnessOptions {
2306                session_id: Some("session-1".into()),
2307                ..PiHarnessOptions::default()
2308            })
2309            .is_err()
2310        );
2311        assert!(
2312            validate_pi_harness_options(&PiHarnessOptions {
2313                persist_session: true,
2314                thinking: Some("unbounded".into()),
2315                ..PiHarnessOptions::default()
2316            })
2317            .is_err()
2318        );
2319    }
2320
2321    #[test]
2322    fn local_harness_proves_prompt_tool_result_and_steer_events() {
2323        let root = std::env::temp_dir().join(format!("glass-agent-{}", std::process::id()));
2324        let _ = fs::remove_dir_all(&root);
2325        fs::create_dir_all(&root).unwrap();
2326        fs::write(root.join("note.txt"), "hello agent").unwrap();
2327        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2328        let mut harness = LocalHarness::default();
2329        assert!(matches!(
2330            harness
2331                .handle(&mut workspace, HarnessRequest::Hello)
2332                .unwrap()[0],
2333            HarnessEvent::Hello { .. }
2334        ));
2335        let events = harness
2336            .handle(
2337                &mut workspace,
2338                HarnessRequest::Prompt {
2339                    text: "read note.txt".into(),
2340                },
2341            )
2342            .unwrap();
2343        assert!(
2344            events
2345                .iter()
2346                .any(|event| matches!(event, HarnessEvent::ToolCall(_)))
2347        );
2348        assert!(
2349            events
2350                .iter()
2351                .any(|event| matches!(event, HarnessEvent::ToolResult { .. }))
2352        );
2353        assert!(matches!(
2354            harness
2355                .handle(
2356                    &mut workspace,
2357                    HarnessRequest::Steer {
2358                        text: "stop".into()
2359                    }
2360                )
2361                .unwrap()[0],
2362            HarnessEvent::State { .. }
2363        ));
2364        assert!(workspace.timeline().events().all(|event| {
2365            !event.payload.to_string().contains("read note.txt")
2366                && !event.payload.to_string().contains("stop")
2367        }));
2368        let _ = fs::remove_dir_all(root);
2369    }
2370
2371    #[test]
2372    fn pi_adapter_negotiates_real_rpc_state_when_pi_is_available() {
2373        if Command::new("pi").arg("--version").output().is_err() {
2374            return;
2375        }
2376        let mut harness = PiHarness::spawn(Path::new(".")).unwrap();
2377        let events = harness.request(HarnessRequest::Hello).unwrap();
2378        assert!(
2379            !events.iter().any(|event| {
2380                event.get("type").and_then(Value::as_str) == Some("extension_error")
2381            })
2382        );
2383        assert!(events.iter().any(|event| {
2384            event.get("type").and_then(Value::as_str) == Some("response")
2385                && event.get("command").and_then(Value::as_str) == Some("get_state")
2386                && event.get("success").and_then(Value::as_bool) == Some(true)
2387        }));
2388    }
2389
2390    #[test]
2391    fn pi_contract_is_glass_specific_approved_and_event_bounded() {
2392        let prompt = include_str!("../../assets/pi-glass-system.md");
2393        let tools = include_str!("../../assets/pi-glass-tools.ts");
2394        assert!(prompt.contains("embedded inside Glass Dev"));
2395        assert!(prompt.contains("Structured browser observation is the default"));
2396        assert!(prompt.contains("per-call approval"));
2397        assert!(prompt.contains("queued, running, indeterminate, stale, or background"));
2398        assert!(prompt.contains("300 seconds"));
2399        for tool in [
2400            "glass_git_status",
2401            "glass_semantic_inspect",
2402            "glass_web_ir_inspect",
2403            "glass_web_ir_diff",
2404            "glass_web_ir_continuity",
2405            "glass_task_plan",
2406            "glass_runtime_inspect",
2407            "glass_capabilities",
2408            "glass_diagnostics_run",
2409            "glass_file_mkdir",
2410            "glass_file_rename",
2411            "glass_file_delete",
2412            "glass_test_run",
2413            "glass_process_start",
2414            "glass_process_stop",
2415            "\"read\"",
2416            "\"write\"",
2417            "\"edit\"",
2418            "\"bash\"",
2419            "\"grep\"",
2420            "\"find\"",
2421            "\"ls\"",
2422        ] {
2423            assert!(tools.contains(tool), "missing Pi tool {tool}");
2424        }
2425        assert!(tools.contains("ctx.ui.confirm"));
2426        assert!(tools.contains("GLASS_PI_YOLO"));
2427        assert!(tools.contains("mutating && !unrestricted"));
2428        assert!(tools.contains("--allow-mutation"));
2429        assert!(tools.contains("exact serialized call once"));
2430        assert!(tools.contains("register(\"glass_process_start\", \"glass.process.start\""));
2431        assert!(tools.contains("register(\"glass_process_stop\", \"glass.process.stop\""));
2432
2433        let response = serde_json::json!({
2434            "type": "response",
2435            "id": "glass-9",
2436            "command": "prompt",
2437            "success": true
2438        });
2439        assert!(pi_response_matches(&response, "glass-9"));
2440        assert!(pi_event_visible(&response));
2441        assert!(!pi_agent_settled(&response));
2442        assert!(!pi_event_visible(
2443            &serde_json::json!({"type":"message_update"})
2444        ));
2445        assert!(!pi_event_visible(&serde_json::json!({
2446            "type":"message_end",
2447            "message":{"role":"user","content":"private prompt"}
2448        })));
2449        assert!(!pi_agent_settled(&serde_json::json!({"type":"agent_end"})));
2450        assert!(pi_agent_settled(
2451            &serde_json::json!({"type":"agent_settled"})
2452        ));
2453        assert_eq!(
2454            pi_event_display(&serde_json::json!({
2455                "type":"message_end",
2456                "message":{"role":"assistant","content":[{"type":"text","text":"done"}]}
2457            })),
2458            Some("done".into())
2459        );
2460    }
2461
2462    #[test]
2463    fn pi_ui_requests_accept_only_bounded_confirm_dialogs() {
2464        let request = serde_json::json!({
2465            "type":"extension_ui_request",
2466            "id":"approval-7",
2467            "method":"confirm",
2468            "title":"Approve glass.file.patch?",
2469            "message":"File: src/main.rs"
2470        });
2471        assert_eq!(
2472            pi_ui_request(&request).unwrap(),
2473            Some(PiUiRequest {
2474                id: "approval-7".into(),
2475                title: "Approve glass.file.patch?".into(),
2476                message: "File: src/main.rs".into(),
2477            })
2478        );
2479        assert!(
2480            pi_ui_request(&serde_json::json!({
2481                "type":"extension_ui_request", "id":"x", "method":"input"
2482            }))
2483            .is_err()
2484        );
2485        assert!(
2486            pi_ui_request(&serde_json::json!({
2487                "type":"extension_ui_request", "id":"bad\nid", "method":"confirm"
2488            }))
2489            .is_err()
2490        );
2491    }
2492
2493    #[test]
2494    fn tool_registry_executes_attributed_file_patch_and_fails_closed_for_unattached_browser() {
2495        let root = std::env::temp_dir().join(format!("glass-tools-{}", std::process::id()));
2496        let _ = fs::remove_dir_all(&root);
2497        fs::create_dir_all(&root).unwrap();
2498        fs::write(root.join("note.txt"), "before\n").unwrap();
2499        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2500        let gateway = AgentToolGateway::default();
2501        let result = gateway
2502            .execute(
2503                &mut workspace,
2504                &ToolCall {
2505                    id: "tool-1".into(),
2506                    name: "glass.file.patch".into(),
2507                    arguments: serde_json::json!({"path":"note.txt","search":"before","replace":"after"}),
2508                },
2509                &ToolAuthorization {
2510                    actor: Actor::embedded(),
2511                    allow_mutation: true,
2512                    confirmed: true,
2513                },
2514            )
2515            .unwrap();
2516        assert_eq!(result["replacements"], 1);
2517        assert_eq!(
2518            fs::read_to_string(root.join("note.txt")).unwrap(),
2519            "after\n"
2520        );
2521        assert!(
2522            gateway
2523                .execute(
2524                    &mut workspace,
2525                    &ToolCall {
2526                        id: "tool-2".into(),
2527                        name: "glass.browser.observe".into(),
2528                        arguments: serde_json::json!({}),
2529                    },
2530                    &ToolAuthorization::read_only(Actor::embedded()),
2531                )
2532                .is_err()
2533        );
2534        let _ = fs::remove_dir_all(root);
2535    }
2536
2537    #[test]
2538    fn tool_gateway_rejects_unconfirmed_mutation_and_unknown_arguments_without_audit_leaks() {
2539        let root = std::env::temp_dir().join(format!("glass-tool-policy-{}", std::process::id()));
2540        let _ = fs::remove_dir_all(&root);
2541        fs::create_dir_all(&root).unwrap();
2542        fs::write(root.join("note.txt"), "private-before\n").unwrap();
2543        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2544        let gateway = AgentToolGateway::default();
2545        let mutating = ToolCall {
2546            id: "denied".into(),
2547            name: "glass.file.patch".into(),
2548            arguments: serde_json::json!({
2549                "path":"note.txt",
2550                "search":"private-before",
2551                "replace":"private-after"
2552            }),
2553        };
2554        assert!(
2555            gateway
2556                .execute(
2557                    &mut workspace,
2558                    &mutating,
2559                    &ToolAuthorization::read_only(Actor::embedded()),
2560                )
2561                .is_err()
2562        );
2563        assert_eq!(
2564            fs::read_to_string(root.join("note.txt")).unwrap(),
2565            "private-before\n"
2566        );
2567
2568        let invalid = ToolCall {
2569            id: "invalid".into(),
2570            name: "glass.file.list".into(),
2571            arguments: serde_json::json!({"unexpected":"private-value"}),
2572        };
2573        assert!(
2574            gateway
2575                .execute(
2576                    &mut workspace,
2577                    &invalid,
2578                    &ToolAuthorization::read_only(Actor::embedded()),
2579                )
2580                .is_err()
2581        );
2582        let audit =
2583            serde_json::to_string(&workspace.timeline().events().collect::<Vec<_>>()).unwrap();
2584        assert!(!audit.contains("private-before"));
2585        assert!(!audit.contains("private-after"));
2586        assert!(!audit.contains("private-value"));
2587        let _ = fs::remove_dir_all(root);
2588    }
2589
2590    #[test]
2591    fn coding_gateway_writes_and_applies_atomic_multi_edits() {
2592        let root = std::env::temp_dir().join(format!("glass-coding-tools-{}", std::process::id()));
2593        let _ = fs::remove_dir_all(&root);
2594        fs::create_dir_all(&root).unwrap();
2595        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2596        let gateway = AgentToolGateway::default();
2597        let authority = ToolAuthorization {
2598            actor: Actor::external("pi"),
2599            allow_mutation: true,
2600            confirmed: true,
2601        };
2602        gateway
2603            .execute(
2604                &mut workspace,
2605                &ToolCall {
2606                    id: "write-1".into(),
2607                    name: "glass.file.write".into(),
2608                    arguments: serde_json::json!({
2609                        "path":"src/example.rs",
2610                        "content":"fn alpha() {}\nfn beta() {}\n"
2611                    }),
2612                },
2613                &authority,
2614            )
2615            .unwrap();
2616        let result = gateway
2617            .execute(
2618                &mut workspace,
2619                &ToolCall {
2620                    id: "edit-1".into(),
2621                    name: "glass.file.edit".into(),
2622                    arguments: serde_json::json!({
2623                        "path":"src/example.rs",
2624                        "edits":[
2625                            {"oldText":"alpha", "newText":"first"},
2626                            {"oldText":"beta", "newText":"second"}
2627                        ]
2628                    }),
2629                },
2630                &authority,
2631            )
2632            .unwrap();
2633        assert_eq!(result["replacements"], 2);
2634        assert_eq!(
2635            fs::read_to_string(root.join("src/example.rs")).unwrap(),
2636            "fn first() {}\nfn second() {}\n"
2637        );
2638        let read = gateway
2639            .execute(
2640                &mut workspace,
2641                &ToolCall {
2642                    id: "read-page".into(),
2643                    name: "glass.file.read".into(),
2644                    arguments: serde_json::json!({"path":"src/example.rs","offset":2,"limit":1}),
2645                },
2646                &ToolAuthorization::read_only(Actor::external("pi")),
2647            )
2648            .unwrap();
2649        assert_eq!(read["content"], "fn second() {}\n");
2650        assert_eq!(read["offset"], 2);
2651        assert!(
2652            read["sha256"]
2653                .as_str()
2654                .is_some_and(|value| value.len() == 64)
2655        );
2656
2657        {
2658            let command = "printf command-private-value";
2659            let command_result = gateway
2660                .execute(
2661                    &mut workspace,
2662                    &ToolCall {
2663                        id: "command-1".into(),
2664                        name: "glass.command.run".into(),
2665                        arguments: serde_json::json!({
2666                            "name":"pi-command-test", "command":command, "timeoutSeconds":5
2667                        }),
2668                    },
2669                    &authority,
2670                )
2671                .unwrap();
2672            assert!(
2673                command_result["output"]
2674                    .as_str()
2675                    .is_some_and(|value| value.contains("command-private-value"))
2676            );
2677            assert!(
2678                workspace
2679                    .timeline()
2680                    .events()
2681                    .all(|event| !event.payload.to_string().contains(command))
2682            );
2683            assert!(workspace.timeline().events().all(|event| !matches!(
2684                event.kind,
2685                DevelopmentEventKind::TestStarted | DevelopmentEventKind::TestCompleted
2686            )));
2687        }
2688        let _ = fs::remove_dir_all(root);
2689    }
2690
2691    #[test]
2692    fn coding_gateway_lists_finds_and_greps_with_bounded_standard_semantics() {
2693        let root = std::env::temp_dir().join(format!("glass-coding-search-{}", std::process::id()));
2694        let _ = fs::remove_dir_all(&root);
2695        fs::create_dir_all(root.join("src/nested")).unwrap();
2696        fs::write(root.join("src/lib.rs"), "alpha\nNeedle target\nomega\n").unwrap();
2697        fs::write(root.join("src/nested/mod.rs"), "needle second\n").unwrap();
2698        fs::write(root.join("README.md"), "Needle outside\n").unwrap();
2699        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2700        let gateway = AgentToolGateway::default();
2701        let authority = ToolAuthorization::read_only(Actor::external("pi"));
2702
2703        let listed = gateway
2704            .execute(
2705                &mut workspace,
2706                &ToolCall {
2707                    id: "list-src".into(),
2708                    name: "glass.file.list".into(),
2709                    arguments: serde_json::json!({"path":"src","limit":2}),
2710                },
2711                &authority,
2712            )
2713            .unwrap();
2714        assert_eq!(listed["entries"].as_array().unwrap().len(), 2);
2715        assert_eq!(listed["truncated"], true);
2716        assert!(
2717            listed["entries"]
2718                .as_array()
2719                .unwrap()
2720                .iter()
2721                .all(|entry| entry["path"].as_str().unwrap().starts_with("src"))
2722        );
2723
2724        let found = gateway
2725            .execute(
2726                &mut workspace,
2727                &ToolCall {
2728                    id: "find-rs".into(),
2729                    name: "glass.file.find".into(),
2730                    arguments: serde_json::json!({"pattern":"src/*.rs","limit":20}),
2731                },
2732                &authority,
2733            )
2734            .unwrap();
2735        assert_eq!(found["paths"].as_array().unwrap().len(), 2);
2736
2737        let grep = gateway
2738            .execute(
2739                &mut workspace,
2740                &ToolCall {
2741                    id: "grep-needle".into(),
2742                    name: "glass.file.grep".into(),
2743                    arguments: serde_json::json!({
2744                        "pattern":"needle", "path":"src", "glob":"*.rs",
2745                        "ignoreCase":true, "context":1, "limit":10
2746                    }),
2747                },
2748                &authority,
2749            )
2750            .unwrap();
2751        assert_eq!(grep["matches"].as_array().unwrap().len(), 2);
2752        assert_eq!(grep["literal"], true);
2753        assert_eq!(grep["matches"][0]["contextBefore"][0], "alpha");
2754        let _ = fs::remove_dir_all(root);
2755    }
2756
2757    #[test]
2758    fn tool_gateway_bounds_envelopes_and_reuses_its_descriptor_catalog() {
2759        let root = std::env::temp_dir().join(format!("glass-tool-envelope-{}", std::process::id()));
2760        let _ = fs::remove_dir_all(&root);
2761        fs::create_dir_all(&root).unwrap();
2762        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2763        let gateway = AgentToolGateway::default();
2764        let descriptor_storage = gateway.descriptors.as_ptr();
2765
2766        for (id, name) in [("", "glass.file.list"), ("valid", "bad name")] {
2767            let error = gateway
2768                .execute(
2769                    &mut workspace,
2770                    &ToolCall {
2771                        id: id.into(),
2772                        name: name.into(),
2773                        arguments: serde_json::json!({}),
2774                    },
2775                    &ToolAuthorization::read_only(Actor::embedded()),
2776                )
2777                .unwrap_err();
2778            assert!(matches!(error, DevelopmentError::InvalidInput(_)));
2779        }
2780        let oversized_id = "x".repeat(MAX_TOOL_CALL_ID_BYTES + 1);
2781        assert!(
2782            gateway
2783                .execute(
2784                    &mut workspace,
2785                    &ToolCall {
2786                        id: oversized_id,
2787                        name: "glass.file.list".into(),
2788                        arguments: serde_json::json!({}),
2789                    },
2790                    &ToolAuthorization::read_only(Actor::embedded()),
2791                )
2792                .is_err()
2793        );
2794        assert_eq!(descriptor_storage, gateway.descriptors.as_ptr());
2795        let _ = fs::remove_dir_all(root);
2796    }
2797
2798    #[test]
2799    fn subprocess_broker_reports_resident_process_tools_as_unavailable() {
2800        let gateway = AgentToolGateway::subprocess_broker();
2801        for name in [
2802            "glass.process.start",
2803            "glass.process.stop",
2804            "glass.process.logs",
2805            "glass.process.list",
2806        ] {
2807            let descriptor = gateway
2808                .descriptors()
2809                .into_iter()
2810                .find(|descriptor| descriptor.name == name)
2811                .unwrap();
2812            assert!(!descriptor.available);
2813            assert!(
2814                descriptor
2815                    .unavailable_reason
2816                    .as_deref()
2817                    .is_some_and(|reason| reason.contains("resident Glass Dev"))
2818            );
2819        }
2820        let root = std::env::temp_dir().join(format!("glass-capabilities-{}", std::process::id()));
2821        let _ = fs::remove_dir_all(&root);
2822        fs::create_dir_all(&root).unwrap();
2823        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2824        let result = gateway
2825            .execute(
2826                &mut workspace,
2827                &ToolCall {
2828                    id: "capabilities".into(),
2829                    name: "glass.capabilities.inspect".into(),
2830                    arguments: serde_json::json!({}),
2831                },
2832                &ToolAuthorization::read_only(Actor::external("pi")),
2833            )
2834            .unwrap();
2835        let processes = result
2836            .as_array()
2837            .unwrap()
2838            .iter()
2839            .filter(|descriptor| {
2840                descriptor["name"]
2841                    .as_str()
2842                    .is_some_and(|name| name.starts_with("glass.process."))
2843            })
2844            .collect::<Vec<_>>();
2845        assert_eq!(processes.len(), 5);
2846        assert!(
2847            processes
2848                .iter()
2849                .all(|descriptor| descriptor["available"] == false)
2850        );
2851        let _ = fs::remove_dir_all(root);
2852    }
2853
2854    #[test]
2855    fn attached_browser_enables_structured_observation_without_mutation_authority() {
2856        let root = std::env::temp_dir().join(format!("glass-tool-browser-{}", std::process::id()));
2857        let _ = fs::remove_dir_all(&root);
2858        fs::create_dir_all(&root).unwrap();
2859        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2860        let mut gateway = AgentToolGateway::default();
2861        gateway.set_browser_context(Some(BrowserAgentContext {
2862            connected: true,
2863            target_id: Some("page-1".into()),
2864            origin: Some("https://example.test".into()),
2865            url: "https://example.test/".into(),
2866            title: "Example".into(),
2867            browser_revision: 42,
2868            semantic_summary: "button Continue".into(),
2869            semantic_entity_count: 1,
2870            selected_entity: Some(serde_json::json!({"reference":"e1","name":"Continue"})),
2871            workflow_state: "idle".into(),
2872            input_owner: "Glass".into(),
2873            freshness: "current".into(),
2874            memory_scope: "profile/default".into(),
2875        }));
2876        let descriptor = gateway
2877            .descriptors()
2878            .into_iter()
2879            .find(|item| item.name == "glass.browser.observe")
2880            .unwrap();
2881        assert!(descriptor.available);
2882        let result = gateway
2883            .execute(
2884                &mut workspace,
2885                &ToolCall {
2886                    id: "observe-1".into(),
2887                    name: "glass.browser.observe".into(),
2888                    arguments: serde_json::json!({}),
2889                },
2890                &ToolAuthorization::read_only(Actor::embedded()),
2891            )
2892            .unwrap();
2893        assert_eq!(result["browserRevision"], 42);
2894        assert_eq!(result["structured"], true);
2895        assert!(
2896            !gateway
2897                .descriptors()
2898                .into_iter()
2899                .find(|item| item.name == "glass.browser.act")
2900                .unwrap()
2901                .available
2902        );
2903        let _ = fs::remove_dir_all(root);
2904    }
2905
2906    #[test]
2907    fn tool_argument_evidence_is_streamed_once_and_stays_canonical() {
2908        let registry = ToolRegistry;
2909        let descriptor = registry
2910            .descriptors()
2911            .into_iter()
2912            .find(|descriptor| descriptor.name == "glass.file.read")
2913            .unwrap();
2914        let arguments = serde_json::json!({"path":"src/lib.rs"});
2915        let evidence = validate_tool_arguments(&descriptor, &arguments).unwrap();
2916        let canonical = serde_json::to_vec(&arguments).unwrap();
2917        assert_eq!(evidence.bytes, canonical.len());
2918        assert_eq!(evidence.sha256, digest_hex(&Sha256::digest(&canonical)));
2919
2920        let oversized = serde_json::json!({"path":"x".repeat(MAX_TOOL_ARGUMENT_BYTES)});
2921        let error = validate_tool_arguments(&descriptor, &oversized)
2922            .err()
2923            .expect("oversized arguments must fail");
2924        assert!(error.to_string().contains("tool arguments exceed"));
2925    }
2926
2927    #[test]
2928    fn semantic_context_resolves_explicit_references_without_dumping_file_contents() {
2929        let root = std::env::temp_dir().join(format!("glass-context-{}", std::process::id()));
2930        let _ = fs::remove_dir_all(&root);
2931        fs::create_dir_all(&root).unwrap();
2932        fs::write(root.join("secret.txt"), "do not inline this source").unwrap();
2933        let mut workspace = ProjectWorkspace::open(&root).unwrap();
2934        let packet =
2935            resolve_context(&mut workspace, "Inspect @workspace and @file:secret.txt").unwrap();
2936        let serialized = serde_json::to_string(&packet).unwrap();
2937        assert!(!serialized.contains("do not inline this source"));
2938        assert_eq!(packet.references.len(), 2);
2939    }
2940}