Skip to main content

glass_dev/development/
agent.rs

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