Skip to main content

glass_dev/development/
agent.rs

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