1use crate::agents::AgentSpec;
4use crate::browser::BrowserStartConfig;
5use crate::debugger::{DebugAdapterConfig, SourceBreakpoint};
6use crate::development::{
7 AgentToolGateway, DevelopmentError, DevelopmentResult, ToolAuthorization, ToolCall,
8 ToolDescriptor,
9};
10use crate::kernels::KernelKind;
11use crate::pi_runtime::PiSessionRequest;
12use crate::tasks::{TaskId, TaskSpec};
13use crate::workspace::DevelopmentWorkspace;
14use crate::{DevelopmentNode, DevelopmentNodeKind, ObservableEventInput, WorkspaceTrust};
15use glass_browser::browser::session::{
16 SemanticObservationLevel, VerificationPredicate, WorkflowRecordingSession,
17 record_semantic_events,
18};
19use glass_browser::workspace::{WorkspaceId, WorkspaceStore};
20use serde_json::Value;
21use std::path::{Path, PathBuf};
22use std::time::Duration;
23
24const RESULT_LIMIT: usize = 512 * 1024;
25
26#[derive(Debug, Clone)]
27pub struct DevelopmentToolContext {
28 pub authorization: ToolAuthorization,
29 pub initiator: Option<crate::development::Actor>,
30 pub expected_generation: u64,
31 pub expected_project_revision: u64,
32}
33
34#[derive(Debug, Clone)]
36pub struct DevelopmentToolRouter {
37 core: AgentToolGateway,
38 descriptors: Vec<ToolDescriptor>,
39}
40
41impl Default for DevelopmentToolRouter {
42 fn default() -> Self {
43 let core = AgentToolGateway::default();
44 let service = service_descriptors();
45 let mut descriptors = core
46 .descriptors()
47 .into_iter()
48 .filter(|descriptor| {
49 !service
50 .iter()
51 .any(|candidate| candidate.name == descriptor.name)
52 })
53 .collect::<Vec<_>>();
54 descriptors.extend(service);
55 Self { core, descriptors }
56 }
57}
58
59impl DevelopmentToolRouter {
60 pub fn with_customization(customization: &crate::Customization, trust: WorkspaceTrust) -> Self {
61 let mut router = Self::default();
62 let custom = customization.descriptors(trust);
63 router
64 .descriptors
65 .retain(|descriptor| !custom.iter().any(|item| item.name == descriptor.name));
66 router.descriptors.extend(custom);
67 router
68 }
69
70 pub fn descriptors(&self) -> Vec<ToolDescriptor> {
71 self.descriptors.clone()
72 }
73
74 pub fn execute(
75 &self,
76 workspace: &mut DevelopmentWorkspace,
77 call: &ToolCall,
78 context: &DevelopmentToolContext,
79 ) -> DevelopmentResult<Value> {
80 if workspace.generation() != context.expected_generation {
81 return Err(DevelopmentError::Conflict(format!(
82 "stale workspace generation {}; current generation is {}",
83 context.expected_generation,
84 workspace.generation()
85 )));
86 }
87 if workspace.project().revision() != context.expected_project_revision {
88 return Err(DevelopmentError::Conflict(format!(
89 "stale project revision {}; current revision is {}",
90 context.expected_project_revision,
91 workspace.project().revision()
92 )));
93 }
94 let descriptor = self
95 .descriptors
96 .iter()
97 .find(|descriptor| descriptor.name == call.name)
98 .ok_or_else(|| DevelopmentError::NotFound(format!("tool {}", call.name)))?;
99 if !descriptor.available {
100 return Err(DevelopmentError::Conflict(
101 descriptor
102 .unavailable_reason
103 .clone()
104 .unwrap_or_else(|| format!("tool {} is unavailable", call.name)),
105 ));
106 }
107 if workspace.trust() == WorkspaceTrust::Untrusted && !untrusted_tool_allowed(&call.name) {
108 return Err(DevelopmentError::Conflict(format!(
109 "tool {} is blocked until the workspace is trusted",
110 call.name
111 )));
112 }
113 if descriptor.mutating
114 && (!context.authorization.allow_mutation || !context.authorization.confirmed)
115 {
116 return Err(DevelopmentError::Conflict(format!(
117 "tool {} requires mutation authority and confirmation",
118 call.name
119 )));
120 }
121 let actor_id = context.authorization.actor.id.clone();
122 let initiator_id = context
123 .initiator
124 .as_ref()
125 .map(|actor| actor.id.as_str())
126 .unwrap_or(actor_id.as_str());
127 let project_revision = workspace.project().revision();
128 let resource = format!("tool:{}", call.id);
129 let argument_bytes = serde_json::to_vec(&call.arguments)?.len();
130 workspace.intelligence_mut().upsert_node(DevelopmentNode {
131 id: resource.clone(),
132 kind: DevelopmentNodeKind::ToolCall,
133 label: call.name.clone(),
134 revision: project_revision,
135 stale: false,
136 evidence: serde_json::json!({
137 "toolCallId":call.id,
138 "name":call.name,
139 "mutating":descriptor.mutating,
140 "argumentBytes":argument_bytes
141 }),
142 })?;
143 workspace.intelligence_mut().link(
144 "repository:root",
145 &resource,
146 "receivedToolCall",
147 project_revision,
148 &actor_id,
149 serde_json::json!({"name":call.name,"initiator":initiator_id,"executor":actor_id}),
150 )?;
151 workspace.intelligence_mut().record(ObservableEventInput {
152 actor: &actor_id,
153 subsystem: "tool",
154 kind: "called",
155 resource: Some(&resource),
156 workspace_revision: project_revision,
157 evidence: serde_json::json!({"name":call.name,"mutating":descriptor.mutating,"initiator":initiator_id,"executor":actor_id}),
158 rationale: None,
159 })?;
160 if workspace.trust().permits_project_execution() {
161 workspace.customization().run_hooks(
162 "tool.before",
163 &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id}),
164 workspace.trust(),
165 &actor_id,
166 )?;
167 }
168 let result = if service_descriptors()
169 .iter()
170 .any(|descriptor| descriptor.name == call.name)
171 {
172 self.execute_service(workspace, call, context)
173 } else if workspace.customization().custom_tool(&call.name).is_some() {
174 workspace.customization().execute_tool(
175 &call.name,
176 &call.arguments,
177 workspace.trust(),
178 &actor_id,
179 )
180 } else if let Some(name) = call.name.strip_prefix("glass.command.") {
181 workspace
182 .customization()
183 .execute_command(name, workspace.trust(), &actor_id)
184 } else {
185 self.core
186 .execute(workspace.project_mut(), call, &context.authorization)
187 };
188 match result {
189 Ok(result) => {
190 if workspace.trust().permits_project_execution() {
191 workspace.customization().run_hooks(
192 "tool.after",
193 &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id,"ok":true}),
194 workspace.trust(),
195 &actor_id,
196 )?;
197 }
198 let result_bytes = serde_json::to_vec(&result)?.len();
199 if result_bytes > RESULT_LIMIT {
200 return Err(DevelopmentError::InvalidInput(format!(
201 "tool result exceeds the {RESULT_LIMIT} byte limit"
202 )));
203 }
204 let resulting_revision = workspace.project().revision();
205 project_observable_result(
206 workspace,
207 call,
208 &actor_id,
209 project_revision,
210 resulting_revision,
211 &result,
212 )?;
213 workspace.intelligence_mut().record(ObservableEventInput {
214 actor: &actor_id,
215 subsystem: "tool",
216 kind: "completed",
217 resource: Some(&resource),
218 workspace_revision: resulting_revision,
219 evidence: serde_json::json!({"name":call.name,"resultBytes":result_bytes}),
220 rationale: None,
221 })?;
222 Ok(result)
223 }
224 Err(error) => {
225 if workspace.trust().permits_project_execution() {
226 workspace.customization().run_hooks(
227 "tool.after",
228 &serde_json::json!({"id":call.id,"name":call.name,"actor":&actor_id,"ok":false,"error":error.to_string()}),
229 workspace.trust(),
230 &actor_id,
231 )?;
232 }
233 let resulting_revision = workspace.project().revision();
234 workspace.intelligence_mut().record(ObservableEventInput {
235 actor: &actor_id,
236 subsystem: "tool",
237 kind: "failed",
238 resource: Some(&resource),
239 workspace_revision: resulting_revision,
240 evidence: serde_json::json!({"name":call.name,"error":error.to_string()}),
241 rationale: None,
242 })?;
243 Err(error)
244 }
245 }
246 }
247
248 fn execute_service(
249 &self,
250 workspace: &mut DevelopmentWorkspace,
251 call: &ToolCall,
252 context: &DevelopmentToolContext,
253 ) -> DevelopmentResult<Value> {
254 let string = |name: &str| required_string(call, name);
255 let actor = normalized_actor_id(&context.authorization.actor.id);
256 match call.name.as_str() {
257 "glass.agent.delegate" => {
258 let sandbox = crate::external_agents::ExternalSandbox::parse(
259 optional_string(call, "sandbox").unwrap_or("read-only"),
260 )
261 .map_err(DevelopmentError::InvalidInput)?;
262 if sandbox == crate::external_agents::ExternalSandbox::WorkspaceWrite
263 && (!context.authorization.allow_mutation
264 || !context.authorization.confirmed)
265 {
266 return Err(DevelopmentError::Conflict(
267 "workspace-write delegation requires explicit mutation authority and confirmation"
268 .into(),
269 ));
270 }
271 let timeout = call
272 .arguments
273 .get("timeoutSeconds")
274 .and_then(Value::as_u64)
275 .unwrap_or(crate::external_agents::DEFAULT_TIMEOUT_SECS);
276 let result = crate::external_agents::delegate(
277 crate::external_agents::ExternalAgentRequest {
278 harness: string("harness")?.into(),
279 root: workspace.root().to_path_buf(),
280 prompt: string("prompt")?.into(),
281 sandbox,
282 timeout: Duration::from_secs(timeout),
283 allow_mutation: context.authorization.allow_mutation
284 && context.authorization.confirmed,
285 },
286 )
287 .map_err(DevelopmentError::Process)?;
288 Ok(serde_json::to_value(result)?)
289 }
290 "glass.editor.open" => map_service(
291 workspace
292 .project_mut()
293 .open_buffer(string("path")?, context.authorization.actor.clone()),
294 ),
295 "glass.editor.selection" => {
296 let path = string("path")?;
297 let buffer = workspace
298 .project()
299 .buffer(path)
300 .cloned()
301 .ok_or_else(|| DevelopmentError::NotFound(format!("buffer {path}")))?;
302 let selected_text = workspace.project().selected_editor_text(path)?;
303 Ok(serde_json::json!({
304 "path":buffer.path,
305 "line":buffer.cursor_line,
306 "column":buffer.cursor_column,
307 "selection":buffer.selection,
308 "selectedText":selected_text,
309 "actor":buffer.actor,
310 "dirty":buffer.dirty
311 }))
312 }
313 "glass.editor.replace_selection" => {
314 let buffer = workspace.project_mut().replace_buffer_selection(
315 string("path")?,
316 string("replacement")?.to_string(),
317 context.authorization.actor.clone(),
318 )?;
319 Ok(serde_json::to_value(buffer)?)
320 }
321 "glass.editor.replace" => {
322 let matches = workspace.project_mut().replace_in_buffer(
323 string("path")?,
324 string("oldText")?,
325 string("newText")?,
326 context.authorization.actor.clone(),
327 )?;
328 Ok(serde_json::json!({"replacements":matches}))
329 }
330 "glass.editor.save" => {
331 map_service(workspace.project_mut().save_buffer(string("path")?))
332 }
333 "glass.editor.diff" => map_service(workspace.project_mut().diff()),
334 "glass.editor.buffers" => Ok(serde_json::to_value(
335 workspace.project().buffers().cloned().collect::<Vec<_>>(),
336 )?),
337 "glass.editor.comments" => Ok(serde_json::to_value(
338 workspace.project().editor_comments(optional_string(call, "path")),
339 )?),
340 "glass.editor.proposals" => Ok(serde_json::to_value(
341 workspace.project().editor_proposals(),
342 )?),
343 "glass.editor.fim" => {
344 let provider = crate::fim::FimProvider::from_editor(
345 &workspace.customization().config().editor,
346 )
347 .ok_or_else(|| {
348 DevelopmentError::NotFound("FIM is disabled".into())
349 })?;
350 match provider.backend {
351 crate::fim::FimBackend::Stub => {
352 let text = provider.complete(
353 string("prefix")?,
354 optional_string(call, "suffix").unwrap_or(""),
355 )
356 .map_err(DevelopmentError::InvalidInput)?;
357 Ok(serde_json::json!({"text": text, "backend": "stub"}))
358 }
359 crate::fim::FimBackend::Pi => {
360 let prefix = string("prefix")?.to_string();
361 let suffix = optional_string(call, "suffix")
362 .unwrap_or("")
363 .to_string();
364 let snapshots = workspace.agents().list()?;
365 let id = snapshots
366 .into_iter()
367 .find(|item| item.status == crate::AgentStatus::Idle)
368 .map(|item| item.id)
369 .ok_or_else(|| {
370 DevelopmentError::NotFound(
371 "no idle Pi session for FIM; start an agent first".into(),
372 )
373 })?;
374 workspace.agents().request(
375 &id,
376 crate::pi_runtime::PiSessionRequest::Complete { prefix, suffix },
377 )?;
378 Ok(serde_json::json!({
379 "queued": true,
380 "backend": "pi",
381 "agentId": id.as_str(),
382 }))
383 }
384 }
385 },
386 "glass.editor.checkpoints" => Ok(serde_json::to_value(
387 workspace.project().editor_checkpoints(),
388 )?),
389 "glass.editor.comment.add" => map_service(workspace.project_mut().add_editor_comment(
390 string("path")?,
391 u32_value(call, "startLine")?,
392 u32_value(call, "endLine")?,
393 string("text")?.to_string(),
394 context.authorization.actor.clone(),
395 )),
396 "glass.editor.comment.resolve" => map_service(
397 workspace
398 .project_mut()
399 .resolve_editor_comment(string("id")?, context.authorization.actor.clone()),
400 ),
401 "glass.editor.proposal.create" => map_service(
402 workspace.project_mut().propose_editor_change(
403 string("path")?,
404 string("original")?.to_string(),
405 string("proposed")?.to_string(),
406 string("summary")?.to_string(),
407 context.authorization.actor.clone(),
408 ),
409 ),
410 "glass.editor.proposal.accept" => map_service(
411 workspace
412 .project_mut()
413 .accept_editor_proposal(string("id")?, context.authorization.actor.clone()),
414 ),
415 "glass.editor.proposal.accept_pack" => map_service(
416 workspace
417 .project_mut()
418 .accept_pending_editor_proposals(context.authorization.actor.clone()),
419 ),
420 "glass.editor.proposal.reject" => map_service(
421 workspace
422 .project_mut()
423 .reject_editor_proposal(string("id")?, context.authorization.actor.clone()),
424 ),
425 "glass.editor.checkpoint.create" => map_service(
426 workspace
427 .project_mut()
428 .create_editor_checkpoint(
429 string("name")?.to_string(),
430 context.authorization.actor.clone(),
431 ),
432 ),
433 "glass.editor.checkpoint.restore" => map_service(
434 workspace
435 .project_mut()
436 .restore_editor_checkpoint(string("id")?, context.authorization.actor.clone()),
437 ),
438 "glass.process.start" => map_service(workspace.project_mut().start_process(
439 string("name")?,
440 required_string(call, "command")?,
441 )),
442 "glass.process.stop" => {
443 map_service(workspace.project_mut().stop_process(string("name")?))
444 }
445 "glass.process.logs" => {
446 let name = string("name")?;
447 let processes = workspace.project_mut().processes();
448 processes.poll()?;
449 Ok(serde_json::json!({
450 "name": name,
451 "output": processes.output(name)?,
452 }))
453 }
454 "glass.process.list" => {
455 map_service(workspace.project_mut().processes().list_checked())
456 }
457
458 "glass.process.restart" => {
459 map_service(workspace.project_mut().processes().restart(string("name")?))
460 }
461 "glass.process.input" => {
462 workspace
463 .project_mut()
464 .processes()
465 .send_input(string("name")?, string("input")?)?;
466 Ok(serde_json::json!({"sent":true}))
467 }
468 "glass.process.resize" => {
469 let cols = u16_value(call, "cols")?;
470 let rows = u16_value(call, "rows")?;
471 workspace
472 .project_mut()
473 .processes()
474 .resize(string("name")?, cols, rows)?;
475 Ok(serde_json::json!({"resized":true,"cols":cols,"rows":rows}))
476 }
477 "glass.process.health" => {
478 let name = string("name")?;
479 let snapshot = workspace
480 .project_mut()
481 .processes()
482 .list_checked()?
483 .into_iter()
484 .find(|snapshot| snapshot.name == name)
485 .ok_or_else(|| DevelopmentError::NotFound(format!("process {name}")))?;
486 Ok(serde_json::json!({
487 "name":snapshot.name,
488 "pid":snapshot.pid,
489 "state":snapshot.state,
490 "health":snapshot.health,
491 "detectedUrls":snapshot.detected_urls
492 }))
493 }
494 "glass.process.ports" => {
495 let snapshots = workspace.project_mut().processes().list_checked()?;
496 Ok(serde_json::json!({
497 "processes":snapshots.into_iter().map(|snapshot| serde_json::json!({
498 "name":snapshot.name,
499 "pid":snapshot.pid,
500 "urls":snapshot.detected_urls
501 })).collect::<Vec<_>>()
502 }))
503 }
504 "glass.browser.start" => {
505 let config: BrowserStartConfig = serde_json::from_value(call.arguments.clone())?;
506 workspace.browser().start(config)
507 }
508 "glass.browser.stop" => workspace.browser().stop(),
509 "glass.browser.attach" => {
510 let mut config: BrowserStartConfig = serde_json::from_value(call.arguments.clone())?;
511 config.attach = true;
512 workspace.browser().start(config)
513 }
514 "glass.browser.reconnect" => workspace.browser().reconnect(),
515 "glass.browser.state" => workspace.browser().state(),
516 "glass.browser.observe" => workspace.browser().observe(),
517 "glass.browser.verify" => {
518 let predicate: VerificationPredicate = serde_json::from_value(
519 required_value(call, "predicate")?.clone(),
520 )
521 .map_err(|error| {
522 DevelopmentError::InvalidInput(format!(
523 "glass.browser.verify predicate is invalid: {error}"
524 ))
525 })?;
526 let timeout = timeout(call, 30)?.unwrap_or(Duration::from_secs(8));
527 workspace.browser().verify_predicate(predicate, timeout)
528 }
529 "glass.browser.snapshot" => workspace.browser().snapshot(),
530 "glass.browser.semantic" => workspace.browser().semantic(match optional_string(call, "level").unwrap_or("structured") {
531 "summary" => SemanticObservationLevel::Summary,
532 "interactive" => SemanticObservationLevel::Interactive,
533 "structured" => SemanticObservationLevel::Structured,
534 "detailed" => SemanticObservationLevel::Detailed,
535 "raw" => SemanticObservationLevel::Raw,
536 _ => return Err(DevelopmentError::InvalidInput("browser semantic level must be summary, interactive, structured, detailed, or raw".into())),
537 }),
538 "glass.browser.web_ir" => workspace.browser().web_ir(),
539 "glass.browser.diff" => workspace.browser().diff(),
540 "glass.browser.targets" => workspace.browser().targets(),
541 "glass.browser.target.select" => workspace
542 .browser()
543 .select_target(string("targetId")?.into()),
544 "glass.browser.navigate" => workspace.browser().navigate(
545 string("url")?.into(),
546 unsigned(call, "browserRevision", 0)?,
547 timeout(call, 180)?.unwrap_or(Duration::from_secs(30)),
548 ),
549 "glass.browser.act" => {
550 let revision = unsigned(call, "browserRevision", 0)?;
551 match string("action")? {
552 "back" => workspace.browser().back(revision),
553 "forward" => workspace.browser().forward(revision),
554 "reload" => workspace.browser().reload(revision),
555 "stopLoading" => workspace.browser().stop_loading(revision),
556 "click" => workspace
557 .browser()
558 .click(string("target")?.into(), revision),
559 "type" => workspace.browser().type_text(
560 string("text")?.into(),
561 optional_string(call, "target").map(str::to_string),
562 revision,
563 ),
564 "scroll" => workspace.browser().scroll(
565 number(call, "dx", 0.0)?,
566 number(call, "dy", 0.0)?,
567 revision,
568 ),
569 action => Err(DevelopmentError::InvalidInput(format!(
570 "unsupported browser action {action}; expected back, forward, reload, stopLoading, click, type, or scroll"
571 ))),
572 }
573 }
574 "glass.browser.screenshot" => workspace.browser().screenshot(),
575 "glass.browser.remote-view.open" => workspace.browser().open_remote_view(),
576 "glass.browser.remote-view.status" => workspace.browser().remote_view_status(),
577 "glass.browser.remote-view.revoke" => workspace.browser().revoke_remote_view(),
578 "glass.workflow.list" => workspace.browser().list_workflows(),
579 "glass.workflow.run" => workspace.browser().run_workflow(
580 required_value(call, "definition")?.clone(),
581 value_map(call, "inputs")?,
582 ),
583 "glass.workflow.pause" => workspace.browser().pause_workflow(),
584 "glass.workflow.resume" => workspace.browser().resume_workflow(
585 required_value(call, "definition")?.clone(),
586 value_map(call, "inputs")?,
587 required_value(call, "checkpoint")?.clone(),
588 ),
589 "glass.workflow.cancel" => workspace.browser().cancel_workflow(),
590 "glass.workflow.verify" => workspace.browser().verify_workflow(),
591 "glass.workflow.record" => {
592 let session: WorkflowRecordingSession = serde_json::from_value(
593 required_value(call, "session")?.clone(),
594 )?;
595 Ok(serde_json::to_value(record_semantic_events(session).map_err(|error| {
596 DevelopmentError::InvalidInput(error.to_string())
597 })?)?)
598 }
599 "glass.memory.retrieve" => {
600 if let Some(record_id) = optional_string(call, "recordId") {
601 Ok(serde_json::to_value(
602 workspace
603 .knowledge()
604 .get(record_id)
605 .ok_or_else(|| DevelopmentError::NotFound(format!("memory record {record_id}")))?,
606 )?)
607 } else {
608 Ok(serde_json::json!({
609 "records":workspace.knowledge().records(),
610 "stats":workspace.knowledge().stats().map_err(|error| DevelopmentError::Process(error.to_string()))?
611 }))
612 }
613 }
614 "glass.memory.explain" => {
615 let record_id = string("recordId")?;
616 let record = workspace
617 .knowledge()
618 .get(record_id)
619 .ok_or_else(|| DevelopmentError::NotFound(format!("memory record {record_id}")))?;
620 Ok(serde_json::json!({
621 "record":record,
622 "advisory":true,
623 "authority":"fresh browser evidence remains authoritative"
624 }))
625 }
626 "glass.memory.forget" => {
627 let record_id = string("recordId")?;
628 let change = workspace
629 .knowledge_mut()
630 .remove(record_id)
631 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
632 Ok(serde_json::to_value(change)?)
633 }
634 "glass.semantic.diff" => workspace.browser().diff(),
635 "glass.semantic.links" => Ok(serde_json::json!({
636 "nodes":workspace.intelligence().nodes().collect::<Vec<_>>(),
637 "edges":workspace.intelligence().edges().collect::<Vec<_>>()
638 })),
639 "glass.github.review" => Ok(serde_json::to_value(crate::github::review(
640 workspace.root(),
641 )?)?),
642 "glass.github.ship" => {
643 let request: crate::github::GitHubShipRequest =
644 serde_json::from_value(call.arguments.clone())?;
645 Ok(serde_json::to_value(crate::github::ship(
646 workspace.root(),
647 &request,
648 )?)?)
649 }
650 "glass.git.status" => git_value(workspace.git(), |git| git.status()),
651 "glass.git.diff" => git_value(workspace.git(), |git| {
652 git.diff(
653 boolean(call, "staged", false),
654 optional_string(call, "path"),
655 )
656 }),
657 "glass.git.stage" => {
658 let paths = string_array(call, "paths")?;
659 git_mutation(workspace.git(), |git| git.stage(&paths))?;
660 Ok(serde_json::json!({"staged":paths}))
661 }
662 "glass.git.unstage" => {
663 let paths = string_array(call, "paths")?;
664 git_mutation(workspace.git(), |git| git.unstage(&paths))?;
665 Ok(serde_json::json!({"unstaged":paths}))
666 }
667 "glass.git.discard" => {
668 let paths = string_array(call, "paths")?;
669 git_mutation(workspace.git(), |git| git.discard(&paths))?;
670 Ok(serde_json::json!({"discarded":paths}))
671 }
672 "glass.git.push" => {
673 git_mutation(workspace.git(), |git| {
674 git.push(optional_string(call, "remote"), optional_string(call, "branch"))
675 })?;
676 Ok(serde_json::json!({"pushed":true}))
677 }
678 "glass.git.fetch" => {
679 git_mutation(workspace.git(), |git| {
680 git.fetch(optional_string(call, "remote"))
681 })?;
682 Ok(serde_json::json!({"fetched":true}))
683 }
684 "glass.git.pull" => {
685 git_mutation(workspace.git(), |git| {
686 git.pull(optional_string(call, "remote"), optional_string(call, "branch"))
687 })?;
688 Ok(serde_json::json!({"pulled":true}))
689 }
690 "glass.git.merge" => {
691 let branch = string("branch")?;
692 git_mutation(workspace.git(), |git| git.merge(branch))?;
693 Ok(serde_json::json!({"merged":branch}))
694 }
695 "glass.git.rebase" => {
696 let onto = string("onto")?;
697 git_mutation(workspace.git(), |git| git.rebase(onto))?;
698 Ok(serde_json::json!({"rebased":onto}))
699 }
700 "glass.git.commit" => {
701 let message = string("message")?;
702 git_value(workspace.git(), |git| git.commit(message))
703 }
704 "glass.git.branches" => git_value(workspace.git(), |git| git.branches()),
705 "glass.git.branch.create" => {
706 let name = string("name")?;
707 let start_point = optional_string(call, "startPoint");
708 git_mutation(workspace.git(), |git| git.create_branch(name, start_point))?;
709 Ok(serde_json::json!({"created":name}))
710 }
711 "glass.git.branch.switch" => {
712 let name = string("name")?;
713 let create = boolean(call, "create", false);
714 git_mutation(workspace.git(), |git| git.switch_branch(name, create))?;
715 Ok(serde_json::json!({"current":name}))
716 }
717 "glass.git.blame" => {
718 let path = string("path")?;
719 let start = unsigned(call, "startLine", 1)?;
720 let end = unsigned(call, "endLine", 1)?;
721 git_value(workspace.git(), |git| git.blame(path, start, end))
722 }
723 "glass.git.conflicts" => git_value(workspace.git(), |git| git.conflicts()),
724 "glass.git.stash.list" => git_value(workspace.git(), |git| git.stash_list()),
725 "glass.git.stash.push" => {
726 let message = string("message")?;
727 let include_untracked = boolean(call, "includeUntracked", false);
728 git_mutation(workspace.git(), |git| {
729 git.stash_push(message, include_untracked)
730 })?;
731 Ok(serde_json::json!({"stashed":true}))
732 }
733 "glass.git.stash.pop" => {
734 let reference = string("reference")?;
735 git_mutation(workspace.git(), |git| git.stash_pop(reference))?;
736 Ok(serde_json::json!({"restored":reference}))
737 }
738 "glass.git.worktree.list" => git_value(workspace.git(), |git| git.worktrees()),
739 "glass.git.worktree.create" => {
740 let path = confined_worktree_path(workspace.root(), Path::new(string("path")?))?;
741 let branch = string("branch")?;
742 let create_branch = boolean(call, "createBranch", true);
743 git_mutation(workspace.git(), |git| {
744 git.create_worktree(&path, branch, create_branch)
745 })?;
746 Ok(serde_json::json!({"path":path,"created":true}))
747 }
748 "glass.git.worktree.remove" => {
749 let path = confined_worktree_path(workspace.root(), Path::new(string("path")?))?;
750 git_mutation(workspace.git(), |git| {
751 git.remove_worktree(&path, boolean(call, "force", false))
752 })?;
753 Ok(serde_json::json!({"path":path,"removed":true}))
754 }
755 "glass.test.discover" => Ok(serde_json::to_value(
756 workspace.tests().suites().collect::<Vec<_>>(),
757 )?),
758 "glass.test.run" => {
759 let revision = workspace.project().revision();
760 map_service(workspace.tests_mut().start(
761 string("runId")?,
762 string("suiteId")?,
763 &actor,
764 revision,
765 timeout(call, 3_600)?,
766 ))
767 }
768 "glass.test.run-affected" => {
769 let paths = string_array(call, "changedPaths")?;
770 let suite_ids = workspace
771 .tests()
772 .affected_suites(paths.iter().map(String::as_str))
773 .into_iter()
774 .map(|suite| suite.id.clone())
775 .collect::<Vec<_>>();
776 let revision = workspace.project().revision();
777 let prefix = optional_string(call, "runPrefix").unwrap_or("affected");
778 let mut runs = Vec::new();
779 for (index, suite_id) in suite_ids.into_iter().enumerate() {
780 runs.push(map_service(workspace.tests_mut().start(
781 &format!("{prefix}-{index}"),
782 &suite_id,
783 &actor,
784 revision,
785 timeout(call, 3_600)?,
786 ))?);
787 }
788 Ok(serde_json::to_value(runs)?)
789 }
790 "glass.test.cancel" => {
791 map_service(workspace.tests_mut().cancel(string("runId")?))?;
792 Ok(serde_json::json!({"cancelled":string("runId")?}))
793 }
794 "glass.test.results" => {
795 let finished = map_service(workspace.tests_mut().poll())?;
796 Ok(serde_json::json!({
797 "finished":finished,
798 "running":workspace.tests().running().collect::<Vec<_>>(),
799 "results":workspace.tests().results().collect::<Vec<_>>()
800 }))
801 }
802 "glass.test.watch" => {
803 let revision = workspace.project().revision();
804 map_service(workspace.tests_mut().watch(string("suiteId")?, revision))?;
805 Ok(serde_json::json!({"watching":string("suiteId")?}))
806 }
807 "glass.eval.start" => {
808 let kind = parse_kernel_kind(string("kind")?)?;
809 let name = string("name")?;
810 let capabilities = string_array_or_empty(call, "capabilities")?;
811 let mutation_authority = boolean(call, "mutationAuthority", false)
812 && context.authorization.allow_mutation
813 && context.authorization.confirmed;
814 map_service(workspace.kernels_mut().start_governed(
815 name,
816 kind,
817 &format!("kernel:{name}"),
818 &capabilities,
819 mutation_authority,
820 ))?;
821 Ok(serde_json::json!({"started":name,"kind":kind,"capabilities":capabilities,"mutationAuthority":mutation_authority}))
822 }
823 "glass.eval.execute" => {
824 map_service(workspace.execute_kernel(
825 string("name")?,
826 string("code")?,
827 &context.authorization,
828 timeout(call, 600)?,
829 ))
830 }
831 "glass.eval.list" => Ok(serde_json::to_value(
832 workspace.kernels().snapshots().collect::<Vec<_>>(),
833 )?),
834 "glass.eval.reset" => {
835 map_service(workspace.kernels_mut().reset(string("name")?, &actor))?;
836 Ok(serde_json::json!({"reset":string("name")?}))
837 }
838 "glass.eval.cancel" => map_service(workspace.kernels_mut().cancel(string("name")?)),
839 "glass.eval.stop" => map_service(workspace.kernels_mut().stop(string("name")?)),
840 "glass.lsp.start" => {
841 let server = string("server")?;
842 let configured = workspace.customization().config().lsp.get(server).cloned();
843 let config = match (optional_string(call, "command"), configured) {
844 (Some(command), _) => crate::lsp::LanguageServerConfig {
845 command: command.to_string(),
846 arguments: string_array_or_empty(call, "arguments")?,
847 },
848 (None, Some(config)) => crate::lsp::LanguageServerConfig {
849 command: config.command,
850 arguments: config.args,
851 },
852 (None, None) => return Err(DevelopmentError::InvalidInput(
853 "lsp start requires command or a matching glass.toml lsp entry".into(),
854 )),
855 };
856 map_service(workspace.language().start(server, &config))?;
857 Ok(serde_json::json!({"started":server}))
858 }
859 "glass.lsp.stop" => {
860 map_service(workspace.language().stop(string("server")?))?;
861 Ok(serde_json::json!({"stopped":string("server")?}))
862 }
863 "glass.lsp.list" => Ok(serde_json::json!({
864 "servers":workspace.language().names().collect::<Vec<_>>()
865 })),
866 "glass.lsp.events" => Ok(serde_json::to_value(
867 workspace.language().events(unsigned(call, "since", 0)?),
868 )?),
869 "glass.lsp.raw" => map_service(workspace.language().raw_request(
870 string("server")?,
871 &actor,
872 string("method")?,
873 call.arguments
874 .get("params")
875 .cloned()
876 .unwrap_or_else(|| serde_json::json!({})),
877 timeout(call, 60)?.unwrap_or(Duration::from_secs(10)),
878 )),
879 "glass.lsp.diagnostics" => map_service(workspace.language().diagnostics(
880 string("server")?,
881 &actor,
882 string("path")?,
883 )),
884 "glass.lsp.hover" => map_service(workspace.language().hover(
885 string("server")?,
886 &actor,
887 string("path")?,
888 unsigned(call, "line", 1)? as u32,
889 unsigned(call, "character", 1)? as u32,
890 )),
891 "glass.lsp.completion" => map_service(workspace.language().completion(
892 string("server")?,
893 &actor,
894 string("path")?,
895 unsigned(call, "line", 1)? as u32,
896 unsigned(call, "character", 1)? as u32,
897 )),
898 "glass.lsp.definition" => map_service(workspace.language().definition(
899 string("server")?,
900 &actor,
901 string("path")?,
902 u32_value(call, "line")?,
903 u32_value(call, "character")?,
904 )),
905 "glass.lsp.declaration" => map_service(workspace.language().declaration(
906 string("server")?,
907 &actor,
908 string("path")?,
909 u32_value(call, "line")?,
910 u32_value(call, "character")?,
911 )),
912 "glass.lsp.implementation" => map_service(workspace.language().implementation(
913 string("server")?,
914 &actor,
915 string("path")?,
916 u32_value(call, "line")?,
917 u32_value(call, "character")?,
918 )),
919 "glass.lsp.references" => map_service(workspace.language().references(
920 string("server")?,
921 &actor,
922 string("path")?,
923 u32_value(call, "line")?,
924 u32_value(call, "character")?,
925 )),
926 "glass.lsp.document_symbols" => map_service(workspace.language().document_symbols(
927 string("server")?,
928 &actor,
929 string("path")?,
930 )),
931 "glass.lsp.workspace_symbols" => map_service(workspace.language().workspace_symbols(
932 string("server")?,
933 &actor,
934 string("query")?,
935 )),
936 "glass.lsp.inlay_hints" => map_service(workspace.language().inlay_hints(
937 string("server")?,
938 &actor,
939 string("path")?,
940 )),
941 "glass.lsp.signature_help" => map_service(workspace.language().signature_help(
942 string("server")?,
943 &actor,
944 string("path")?,
945 u32_value(call, "line")?,
946 u32_value(call, "character")?,
947 )),
948 "glass.lsp.code_actions" => map_service(workspace.language().code_actions(
949 string("server")?,
950 &actor,
951 string("path")?,
952 position(call, "start")?,
953 position(call, "end")?,
954 value_array_or_empty(call, "diagnostics")?,
955 )),
956 "glass.lsp.formatting" => map_service(workspace.language().formatting(
957 string("server")?,
958 &actor,
959 string("path")?,
960 )),
961 "glass.lsp.range_formatting" => map_service(workspace.language().range_formatting(
962 string("server")?,
963 &actor,
964 string("path")?,
965 position(call, "start")?,
966 position(call, "end")?,
967 )),
968 "glass.lsp.semantic_tokens" => map_service(workspace.language().semantic_tokens(
969 string("server")?,
970 &actor,
971 string("path")?,
972 )),
973 "glass.lsp.rename" => map_service(workspace.language().rename(
974 string("server")?,
975 &actor,
976 string("path")?,
977 u32_value(call, "line")?,
978 u32_value(call, "character")?,
979 string("newName")?,
980 )),
981 "glass.debug.start" => {
982 let session = string("session")?;
983 let configured = workspace.customization().config().dap.get(session).cloned();
984 let (mut config, configured_tcp, configured_connect_timeout_ms) =
985 match (optional_string(call, "command"), configured) {
986 (Some(command), _) => (
987 DebugAdapterConfig::new(
988 command,
989 string_array_or_empty(call, "arguments")?,
990 ),
991 None,
992 5_000,
993 ),
994 (None, Some(config)) => (
995 DebugAdapterConfig::new(config.command, config.args),
996 config.tcp_address,
997 config.connect_timeout_ms,
998 ),
999 (None, None) => return Err(DevelopmentError::InvalidInput(
1000 "debug start requires command or a matching glass.toml dap entry".into(),
1001 )),
1002 };
1003 if let Some(address) = optional_string(call, "tcpAddress")
1004 .map(str::to_string)
1005 .or(configured_tcp)
1006 {
1007 let address = address.parse().map_err(|_| {
1008 DevelopmentError::InvalidInput(
1009 "debug tcpAddress must be a loopback IP socket address".into(),
1010 )
1011 })?;
1012 config = config.with_tcp(
1013 address,
1014 Duration::from_millis(unsigned(
1015 call,
1016 "connectTimeoutMs",
1017 configured_connect_timeout_ms,
1018 )?),
1019 );
1020 }
1021 map_debug(workspace.start_debugger(
1022 session,
1023 &config,
1024 Duration::from_secs(unsigned(call, "timeoutSeconds", 30)?),
1025 ))?;
1026 Ok(serde_json::json!({"started":session}))
1027 }
1028 "glass.debug.launch" => map_debug(
1029 debugger(workspace, string("session")?)?.launch(
1030 call.arguments
1031 .get("configuration")
1032 .cloned()
1033 .unwrap_or(Value::Null),
1034 ),
1035 ),
1036 "glass.debug.attach" => map_debug(
1037 debugger(workspace, string("session")?)?.attach(
1038 call.arguments
1039 .get("configuration")
1040 .cloned()
1041 .unwrap_or(Value::Null),
1042 ),
1043 ),
1044 "glass.debug.configuration_done" => {
1045 map_debug(debugger(workspace, string("session")?)?.configuration_done())
1046 }
1047 "glass.debug.restart" => map_debug(
1048 debugger(workspace, string("session")?)?.restart(
1049 call.arguments
1050 .get("configuration")
1051 .cloned()
1052 .unwrap_or_else(|| serde_json::json!({})),
1053 ),
1054 ),
1055 "glass.debug.breakpoint.set" => {
1056 let lines = unsigned_array(call, "lines")?;
1057 let breakpoints = lines
1058 .iter()
1059 .copied()
1060 .map(SourceBreakpoint::line)
1061 .collect::<Vec<_>>();
1062 map_debug(
1063 debugger(workspace, string("session")?)?
1064 .set_source_breakpoints(&PathBuf::from(string("path")?), &breakpoints),
1065 )
1066 }
1067 "glass.debug.breakpoint.remove" => map_debug(
1068 debugger(workspace, string("session")?)?
1069 .set_source_breakpoints(&PathBuf::from(string("path")?), &[]),
1070 ),
1071 "glass.debug.exception.set" => map_debug(
1072 debugger(workspace, string("session")?)?
1073 .set_exception_breakpoints(&string_array_or_empty(call, "filters")?),
1074 ),
1075 "glass.debug.continue" => map_debug(
1076 debugger(workspace, string("session")?)?
1077 .continue_thread(integer(call, "threadId")?),
1078 ),
1079 "glass.debug.pause" => map_debug(
1080 debugger(workspace, string("session")?)?.pause(integer(call, "threadId")?),
1081 ),
1082 "glass.debug.step" => {
1083 let debugger = debugger(workspace, string("session")?)?;
1084 let thread = integer(call, "threadId")?;
1085 match string("kind")? {
1086 "over" => map_debug(debugger.next(thread)),
1087 "in" => map_debug(debugger.step_in(thread)),
1088 "out" => map_debug(debugger.step_out(thread)),
1089 _ => Err(DevelopmentError::InvalidInput(
1090 "debug step kind must be over, in, or out".into(),
1091 )),
1092 }
1093 }
1094 "glass.debug.threads" => map_debug(debugger(workspace, string("session")?)?.threads()),
1095 "glass.debug.stack" => map_debug(
1096 debugger(workspace, string("session")?)?.stack_trace(integer(call, "threadId")?),
1097 ),
1098 "glass.debug.scopes" => map_debug(
1099 debugger(workspace, string("session")?)?.scopes(integer(call, "frameId")?),
1100 ),
1101 "glass.debug.variables" => map_debug(
1102 debugger(workspace, string("session")?)?
1103 .variables(integer(call, "variablesReference")?),
1104 ),
1105 "glass.debug.evaluate" => map_debug(debugger(workspace, string("session")?)?.evaluate(
1106 string("expression")?,
1107 call.arguments.get("frameId").and_then(Value::as_i64),
1108 optional_string(call, "context").unwrap_or("repl"),
1109 )),
1110 "glass.debug.events" => {
1111 map_debug(debugger(workspace, string("session")?)?.poll_events())
1112 }
1113 "glass.debug.inspect" => {
1114 map_debug(debugger(workspace, string("session")?)?.snapshot())
1115 }
1116 "glass.debug.processes" => map_debug(
1117 debugger(workspace, string("session")?)?.debuggee_processes(),
1118 ),
1119 "glass.debug.disconnect" => map_debug(
1120 debugger(workspace, string("session")?)?
1121 .disconnect(boolean(call, "terminateDebuggee", false)),
1122 ),
1123 "glass.debug.terminate" => map_debug(
1124 debugger(workspace, string("session")?)?
1125 .terminate(boolean(call, "restart", false)),
1126 ),
1127 "glass.debug.stop" => {
1128 map_debug(workspace.stop_debugger(string("session")?))?;
1129 Ok(serde_json::json!({"stopped":string("session")?}))
1130 }
1131 "glass.agent.list" => map_service(workspace.agents().list()),
1132 "glass.agent.setup" => map_service(crate::pi_runtime::setup_pi_runtime(
1133 None,
1134 None,
1135 boolean(call, "update", false),
1136 boolean(call, "login", false),
1137 )),
1138 "glass.agent.spawn" => {
1139 let spec: AgentSpec =
1140 serde_json::from_value(call.arguments.get("spec").cloned().ok_or_else(
1141 || DevelopmentError::InvalidInput("agent spawn requires spec".into()),
1142 )?)?;
1143 map_service(workspace.agents().create(spec))
1144 }
1145 "glass.agent.prompt" => {
1146 let id = agent_id(workspace, string("agentId")?)?;
1147 let text = string("text")?;
1148 map_service(workspace.agents().prompt_with_context(
1149 &id,
1150 text,
1151 call.arguments.get("context").cloned(),
1152 ))?;
1153 Ok(serde_json::json!({"queued":true}))
1154 }
1155 "glass.agent.send" => {
1156 let text = string("text")?;
1157 let context = call.arguments.get("context").cloned();
1158 let mode = optional_string(call, "mode").unwrap_or("follow-up");
1159 let selected = optional_string(call, "agentId")
1160 .map(|value| agent_id(workspace, value))
1161 .transpose()?;
1162 let agent = selected.or_else(|| {
1163 workspace
1164 .agents()
1165 .list()
1166 .ok()?
1167 .into_iter()
1168 .find(|item| {
1169 !matches!(
1170 item.status,
1171 crate::AgentStatus::Completed
1172 | crate::AgentStatus::Failed
1173 | crate::AgentStatus::Cancelled
1174 )
1175 })
1176 .map(|item| item.id)
1177 });
1178 let agent = match agent {
1179 Some(agent) => agent,
1180 None => {
1181 let readiness = crate::pi_runtime::pi_readiness()?;
1182 if !readiness.ready {
1183 return Err(DevelopmentError::Conflict(
1184 "Pi is not ready; use Agent [s] to install the runtime and [l] to sign in"
1185 .into(),
1186 ));
1187 }
1188 let id = workspace
1189 .agents()
1190 .create(AgentSpec::new(
1191 "assistant",
1192 "interactive Glass Agent session",
1193 ))?;
1194 map_service(workspace.agents().prompt_with_context(&id, text, context))?;
1195 return Ok(serde_json::json!({"queued":true,"agentId":id}));
1196 }
1197 };
1198 let mut status = workspace.agents().snapshot(&agent)?.status;
1199 let restarted = matches!(
1200 status,
1201 crate::AgentStatus::Failed | crate::AgentStatus::Cancelled
1202 );
1203 if restarted {
1204 workspace.agents().restart(&agent)?;
1205 status = workspace.agents().snapshot(&agent)?.status;
1206 }
1207 if mode == "steer" && status == crate::AgentStatus::Working {
1208 map_service(workspace.agents().steer_with_context(&agent, text, context.clone()))?;
1209 } else if mode == "follow-up" && status == crate::AgentStatus::Working {
1210 map_service(workspace.agents().follow_up_with_context(&agent, text, context.clone()))?;
1211 } else {
1212 map_service(workspace.agents().prompt_with_context(&agent, text, context))?;
1213 }
1214 let mut response = serde_json::json!({"queued":true,"agentId":agent});
1215 if restarted {
1216 response["restarted"] = Value::Bool(true);
1217 }
1218 Ok(response)
1219 }
1220 "glass.agent.steer" => {
1221 let id = agent_id(workspace, string("agentId")?)?;
1222 let text = string("text")?;
1223 map_service(workspace.agents().steer_with_context(
1224 &id,
1225 text,
1226 call.arguments.get("context").cloned(),
1227 ))?;
1228 Ok(serde_json::json!({"queued":true}))
1229 }
1230 "glass.agent.follow-up" => {
1231 let id = agent_id(workspace, string("agentId")?)?;
1232 let text = string("text")?;
1233 map_service(workspace.agents().follow_up_with_context(
1234 &id,
1235 text,
1236 call.arguments.get("context").cloned(),
1237 ))?;
1238 Ok(serde_json::json!({"queued":true}))
1239 }
1240 "glass.agent.approve" => {
1241 let id = agent_id(workspace, string("agentId")?)?;
1242 map_service(workspace.agents().approve_tool(
1243 &id,
1244 string("frameId")?,
1245 boolean(call, "approved", false),
1246 ))?;
1247 Ok(serde_json::json!({"queued":true}))
1248 }
1249 "glass.agent.abort" => {
1250 let id = agent_id(workspace, string("agentId")?)?;
1251 map_service(workspace.agents().cancel(&id))?;
1252 Ok(serde_json::json!({"cancelled":true}))
1253 }
1254 "glass.agent.compact" => {
1255 let id = agent_id(workspace, string("agentId")?)?;
1256 map_service(workspace.agents().request(
1257 &id,
1258 PiSessionRequest::Compact {
1259 instructions: optional_string(call, "instructions").map(str::to_string),
1260 },
1261 ))?;
1262 Ok(serde_json::json!({"queued":true}))
1263 }
1264 "glass.agent.model" => {
1265 let id = agent_id(workspace, string("agentId")?)?;
1266 map_service(workspace.agents().request(
1267 &id,
1268 PiSessionRequest::SetModel {
1269 provider: string("provider")?.into(),
1270 model_id: string("modelId")?.into(),
1271 },
1272 ))?;
1273 Ok(serde_json::json!({"queued":true}))
1274 }
1275 "glass.agent.thinking" => {
1276 let id = agent_id(workspace, string("agentId")?)?;
1277 map_service(workspace.agents().request(
1278 &id,
1279 PiSessionRequest::SetThinking {
1280 level: string("level")?.into(),
1281 },
1282 ))?;
1283 Ok(serde_json::json!({"queued":true}))
1284 }
1285 "glass.agent.new-session" => {
1286 agent_request(workspace, call, PiSessionRequest::NewSession)
1287 }
1288 "glass.agent.clone-session" => {
1289 agent_request(workspace, call, PiSessionRequest::CloneSession)
1290 }
1291 "glass.agent.rewind" => agent_request(
1292 workspace,
1293 call,
1294 PiSessionRequest::Rewind {
1295 entry_id: string("entryId")?.into(),
1296 },
1297 ),
1298 "glass.agent.fork" => agent_request(
1299 workspace,
1300 call,
1301 PiSessionRequest::Fork {
1302 entry_id: string("entryId")?.into(),
1303 },
1304 ),
1305 "glass.agent.switch-session" => agent_request(
1306 workspace,
1307 call,
1308 PiSessionRequest::SwitchSession {
1309 path: string("path")?.into(),
1310 },
1311 ),
1312 "glass.agent.sessions" => agent_request(workspace, call, PiSessionRequest::ListSessions),
1313 "glass.agent.tree" => agent_request(workspace, call, PiSessionRequest::Tree),
1314 "glass.agent.messages" => agent_request(workspace, call, PiSessionRequest::Messages),
1315 "glass.agent.entries" => agent_request(
1316 workspace,
1317 call,
1318 PiSessionRequest::Entries {
1319 since: optional_string(call, "since").map(str::to_string),
1320 },
1321 ),
1322 "glass.agent.stats" => agent_request(workspace, call, PiSessionRequest::SessionStats),
1323 "glass.agent.name" => agent_request(
1324 workspace,
1325 call,
1326 PiSessionRequest::SetSessionName {
1327 name: string("name")?.into(),
1328 },
1329 ),
1330 "glass.todo.list" => Ok(serde_json::to_value(workspace.todos())?),
1331 "glass.todo.write" => {
1332 let items = call
1333 .arguments
1334 .get("items")
1335 .cloned()
1336 .ok_or_else(|| DevelopmentError::InvalidInput("todo write requires items".into()))?;
1337 let items: Vec<crate::SessionTodo> = serde_json::from_value(items)?;
1338 Ok(serde_json::to_value(workspace.write_todos(items)?)?)
1339 }
1340 "glass.todo.complete" => {
1341 Ok(serde_json::to_value(workspace.complete_todo(string("id")?)?)?)
1342 }
1343 "glass.task.create" => {
1344 let spec = serde_json::from_value::<TaskSpec>(call.arguments.clone())?;
1345 Ok(serde_json::to_value(workspace.create_task(spec)?)?)
1346 }
1347 "glass.task.crew" => {
1348 let goal = string("goal")?;
1349 let wake = workspace.create_crew(goal)?;
1350 let crew = wake.tasks.clone();
1351 Ok(serde_json::json!({
1352 "goal": goal,
1353 "wake": wake,
1354 "crew": crew,
1355 }))
1356 }
1357 "glass.task.list" => Ok(serde_json::to_value(workspace.tasks()?)?),
1358 "glass.task.wake" => Ok(serde_json::to_value(workspace.latest_crew_wake())?),
1359 "glass.task.get" | "glass.task.inspect" => {
1360 let id = TaskId::parse(string("taskId")?)?;
1361 Ok(serde_json::to_value(workspace.task(&id)?)?)
1362 }
1363 "glass.task.pause" => task_action(workspace, call, |workspace, id| {
1364 workspace.pause_task(id)
1365 }),
1366 "glass.task.resume" => task_action(workspace, call, |workspace, id| {
1367 workspace.resume_task(id)
1368 }),
1369 "glass.task.cancel" => task_action(workspace, call, |workspace, id| {
1370 workspace.cancel_task(id)
1371 }),
1372 "glass.task.retry" => task_action(workspace, call, |workspace, id| {
1373 workspace.retry_task(id)
1374 }),
1375 "glass.task.override-blocked" => task_action(workspace, call, |workspace, id| {
1376 workspace.override_blocked_task(id)
1377 }),
1378 "glass.task.reassign" => {
1379 let id = TaskId::parse(string("taskId")?)?;
1380 workspace.reassign_task(
1381 &id,
1382 string("role")?.into(),
1383 optional_string(call, "model").map(str::to_string),
1384 optional_string(call, "thinking").map(str::to_string),
1385 )?;
1386 Ok(serde_json::json!({"reassigned":true}))
1387 }
1388 "glass.task.evidence" | "glass.task.verify" => {
1389 let id = TaskId::parse(string("taskId")?)?;
1390 workspace.submit_task_evidence(
1391 &id,
1392 string("kind")?.into(),
1393 context.authorization.actor.id.clone(),
1394 boolean(call, "passed", false),
1395 call.arguments
1396 .get("details")
1397 .cloned()
1398 .unwrap_or(Value::Null),
1399 )?;
1400 Ok(serde_json::json!({"recorded":true}))
1401 }
1402 "glass.experiment.create" => {
1403 let port = call
1404 .arguments
1405 .get("port")
1406 .and_then(Value::as_u64)
1407 .map(u16::try_from)
1408 .transpose()
1409 .map_err(|_| DevelopmentError::InvalidInput("invalid experiment port".into()))?;
1410 Ok(serde_json::to_value(workspace.experiments()?.create(
1411 string("id")?,
1412 string("branch")?,
1413 port,
1414 )?)?)
1415 }
1416 "glass.experiment.collect" => Ok(serde_json::to_value(
1417 workspace
1418 .experiments()?
1419 .collect_automatic(string("id")?)?,
1420 )?),
1421 "glass.experiment.list" => Ok(serde_json::to_value(
1422 workspace.experiments()?.snapshots(),
1423 )?),
1424 "glass.experiment.compare" => Ok(serde_json::to_value(
1425 workspace.experiments()?.compare(),
1426 )?),
1427 "glass.experiment.select" => Ok(serde_json::to_value(
1428 workspace.experiments()?.select(string("id")?)?,
1429 )?),
1430 "glass.experiment.remove" => {
1431 workspace
1432 .experiments()?
1433 .remove(string("id")?, boolean(call, "force", false))?;
1434 Ok(serde_json::json!({"removed":true}))
1435 }
1436 "glass.graph.query" => Ok(serde_json::to_value(
1437 workspace.intelligence().node(string("id")?),
1438 )?),
1439 "glass.graph.source" => {
1440 let line = call
1441 .arguments
1442 .get("line")
1443 .and_then(Value::as_u64)
1444 .map(u32::try_from)
1445 .transpose()
1446 .map_err(|_| DevelopmentError::InvalidInput("invalid graph line".into()))?;
1447 Ok(serde_json::to_value(
1448 workspace
1449 .project()
1450 .graph()
1451 .entities_for_source(string("path")?, line),
1452 )?)
1453 }
1454 "glass.graph.path" | "glass.graph.explain" => Ok(serde_json::to_value(
1455 workspace
1456 .intelligence()
1457 .path(string("from")?, string("to")?)?,
1458 )?),
1459 "glass.graph.link" => {
1460 let revision = workspace.project().revision();
1461 let edge = workspace.intelligence_mut().link(
1462 string("from")?,
1463 string("to")?,
1464 string("relation")?,
1465 revision,
1466 &actor,
1467 call.arguments
1468 .get("evidence")
1469 .cloned()
1470 .unwrap_or(Value::Null),
1471 )?;
1472 workspace.intelligence_mut().record(ObservableEventInput {
1473 actor: &actor,
1474 subsystem: "graph",
1475 kind: "linked",
1476 resource: None,
1477 workspace_revision: revision,
1478 evidence: serde_json::json!({"edgeId":edge,"from":string("from")?,"to":string("to")?,"relation":string("relation")?}),
1479 rationale: None,
1480 })?;
1481 Ok(serde_json::json!({"edgeId":edge}))
1482 }
1483 "glass.replay.list" | "glass.replay.inspect" => {
1484 Ok(serde_json::to_value(workspace.intelligence().replay(
1485 unsigned(call, "since", 0)?,
1486 usize::try_from(unsigned(call, "limit", 128)?).unwrap_or(4096),
1487 )?)?)
1488 }
1489 "glass.replay.diff" => Ok(serde_json::to_value(
1490 workspace
1491 .intelligence()
1492 .replay_diff(unsigned(call, "from", 0)?, unsigned(call, "to", 1)?)?,
1493 )?),
1494 "glass.workspace.list" => {
1495 let store = WorkspaceStore::open_default()
1496 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1497 Ok(serde_json::to_value(store.list().map_err(|error| {
1498 DevelopmentError::Process(error.to_string())
1499 })?)?)
1500 }
1501 "glass.workspace.inspect" => {
1502 let id = WorkspaceId::new(string("id")?)
1503 .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
1504 let store = WorkspaceStore::open_default()
1505 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1506 Ok(serde_json::to_value(
1507 store
1508 .open(&id)
1509 .map_err(|error| DevelopmentError::Process(error.to_string()))?,
1510 )?)
1511 }
1512 "glass.workspace.suspend" | "glass.workspace.resume" => {
1513 let id = WorkspaceId::new(string("id")?)
1514 .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
1515 let store = WorkspaceStore::open_default()
1516 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1517 let workspace = if call.name.ends_with("suspend") {
1518 store.suspend(&id)
1519 } else {
1520 store.resume(&id)
1521 }
1522 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1523 Ok(serde_json::to_value(workspace)?)
1524 }
1525 "glass.workspace.delete" => {
1526 let id = WorkspaceId::new(string("id")?)
1527 .map_err(|error| DevelopmentError::InvalidInput(error.to_string()))?;
1528 let store = WorkspaceStore::open_default()
1529 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1530 store
1531 .delete(&id)
1532 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1533 Ok(serde_json::json!({"id":id,"deleted":true}))
1534 }
1535 "glass.daemon.start" => {
1536 let runtime = tokio::runtime::Builder::new_current_thread()
1537 .enable_all()
1538 .build()
1539 .map_err(|error| DevelopmentError::Process(error.to_string()))?;
1540 map_service(runtime.block_on(crate::daemon::start(None, None)))
1541 }
1542 "glass.daemon.status" | "glass.daemon.doctor" => map_service(
1543 crate::daemon::read_status_checked(None, None)
1544 .map_err(|error| DevelopmentError::Process(error.to_string())),
1545 ),
1546 "glass.daemon.stop" => map_service(
1547 crate::daemon::stop(None, None)
1548 .map(|_| serde_json::json!({"status":"stopped"}))
1549 .map_err(|error| DevelopmentError::Process(error.to_string())),
1550 ),
1551 "glass.daemon.logs" => map_service(
1552 crate::daemon::log_tail(None)
1553 .map_err(|error| DevelopmentError::Process(error.to_string())),
1554 ),
1555 "glass.agent.hello" | "glass.agent.models" => {
1556 let id = optional_string(call, "agentId")
1557 .map(|value| agent_id(workspace, value))
1558 .transpose()?
1559 .or_else(|| active_agent_id(workspace))
1560 .ok_or_else(|| {
1561 DevelopmentError::Conflict(
1562 "start an interactive agent session before requesting Pi state"
1563 .into(),
1564 )
1565 })?;
1566 let request = if call.name.ends_with("hello") {
1567 PiSessionRequest::Hello
1568 } else {
1569 PiSessionRequest::Models
1570 };
1571 map_service(workspace.agents().request(&id, request))?;
1572 Ok(serde_json::json!({"queued":true,"agentId":id.as_str()}))
1573 }
1574 "glass.project.attach" => {
1575 let actor = crate::development::Actor::external(string("actor")?);
1576 workspace.project_mut().attach_actor(actor.clone())?;
1577 Ok(serde_json::to_value(actor)?)
1578 }
1579 "glass.workspace.trust.status" => Ok(serde_json::json!({
1580 "trust":workspace.trust(),
1581 "identity":workspace.trust_identity(),
1582 "store":workspace.trust_store_path(),
1583 "localDecisionRequired":true
1584 })),
1585 "glass.workspace.trust.inspect" => Ok(serde_json::json!({
1586 "trust":workspace.trust(),
1587 "items":workspace.trust_inspection(),
1588 "localDecisionRequired":true
1589 })),
1590 _ => Err(DevelopmentError::NotFound(format!("tool {}", call.name))),
1591 }
1592 }
1593}
1594
1595fn service_descriptors() -> Vec<ToolDescriptor> {
1596 const READ: &[&str] = &[
1597 "glass.process.list",
1598 "glass.process.logs",
1599 "glass.github.review",
1600 "glass.git.status",
1601 "glass.git.branches",
1602 "glass.git.blame",
1603 "glass.git.conflicts",
1604 "glass.git.diff",
1605 "glass.git.stash.list",
1606 "glass.git.worktree.list",
1607 "glass.editor.selection",
1608 "glass.editor.diff",
1609 "glass.editor.buffers",
1610 "glass.editor.comments",
1611 "glass.editor.proposals",
1612 "glass.editor.fim",
1613 "glass.editor.checkpoints",
1614 "glass.eval.list",
1615 "glass.lsp.diagnostics",
1616 "glass.workspace.list",
1617 "glass.workspace.inspect",
1618 "glass.daemon.status",
1619 "glass.daemon.doctor",
1620 "glass.daemon.logs",
1621 "glass.agent.hello",
1622 "glass.agent.models",
1623 "glass.workspace.trust.status",
1624 "glass.workspace.trust.inspect",
1625 "glass.lsp.list",
1626 "glass.lsp.events",
1627 "glass.lsp.hover",
1628 "glass.lsp.completion",
1629 "glass.lsp.definition",
1630 "glass.lsp.declaration",
1631 "glass.lsp.implementation",
1632 "glass.lsp.references",
1633 "glass.lsp.document_symbols",
1634 "glass.lsp.workspace_symbols",
1635 "glass.lsp.inlay_hints",
1636 "glass.lsp.signature_help",
1637 "glass.lsp.code_actions",
1638 "glass.lsp.formatting",
1639 "glass.lsp.range_formatting",
1640 "glass.lsp.semantic_tokens",
1641 "glass.lsp.rename",
1642 "glass.agent.list",
1643 "glass.agent.sessions",
1644 "glass.agent.tree",
1645 "glass.agent.messages",
1646 "glass.agent.entries",
1647 "glass.agent.stats",
1648 "glass.debug.events",
1649 "glass.debug.inspect",
1650 "glass.debug.processes",
1651 "glass.debug.threads",
1652 "glass.graph.source",
1653 "glass.todo.list",
1654 "glass.task.list",
1655 "glass.task.wake",
1656 "glass.task.get",
1657 "glass.task.inspect",
1658 "glass.test.results",
1659 "glass.test.discover",
1660 "glass.experiment.list",
1661 "glass.experiment.compare",
1662 "glass.graph.query",
1663 "glass.graph.path",
1664 "glass.graph.explain",
1665 "glass.replay.list",
1666 "glass.replay.inspect",
1667 "glass.replay.diff",
1668 "glass.process.health",
1669 "glass.process.ports",
1670 "glass.browser.state",
1671 "glass.browser.observe",
1672 "glass.browser.verify",
1673 "glass.browser.snapshot",
1674 "glass.browser.semantic",
1675 "glass.browser.web_ir",
1676 "glass.browser.diff",
1677 "glass.browser.targets",
1678 "glass.browser.screenshot",
1679 "glass.browser.remote-view.status",
1680 "glass.workflow.list",
1681 "glass.workflow.verify",
1682 "glass.workflow.record",
1683 "glass.memory.retrieve",
1684 "glass.memory.explain",
1685 "glass.semantic.diff",
1686 "glass.semantic.links",
1687 ];
1688 const MUTATE: &[&str] = &[
1689 "glass.workspace.suspend",
1690 "glass.workspace.resume",
1691 "glass.workspace.delete",
1692 "glass.daemon.start",
1693 "glass.daemon.stop",
1694 "glass.project.attach",
1695 "glass.github.ship",
1696 "glass.git.stage",
1697 "glass.git.unstage",
1698 "glass.git.discard",
1699 "glass.git.push",
1700 "glass.git.fetch",
1701 "glass.git.pull",
1702 "glass.git.merge",
1703 "glass.git.rebase",
1704 "glass.git.commit",
1705 "glass.todo.write",
1706 "glass.todo.complete",
1707 "glass.git.branch.create",
1708 "glass.git.branch.switch",
1709 "glass.git.stash.push",
1710 "glass.git.stash.pop",
1711 "glass.git.worktree.create",
1712 "glass.git.worktree.remove",
1713 "glass.graph.link",
1714 "glass.test.run",
1715 "glass.test.run-affected",
1716 "glass.test.cancel",
1717 "glass.test.watch",
1718 "glass.eval.start",
1719 "glass.eval.execute",
1720 "glass.eval.cancel",
1721 "glass.eval.reset",
1722 "glass.eval.stop",
1723 "glass.debug.start",
1724 "glass.lsp.start",
1725 "glass.lsp.stop",
1726 "glass.lsp.raw",
1727 "glass.debug.launch",
1728 "glass.debug.attach",
1729 "glass.debug.configuration_done",
1730 "glass.debug.restart",
1731 "glass.debug.breakpoint.set",
1732 "glass.debug.breakpoint.remove",
1733 "glass.debug.exception.set",
1734 "glass.debug.continue",
1735 "glass.debug.pause",
1736 "glass.debug.step",
1737 "glass.debug.disconnect",
1738 "glass.debug.terminate",
1739 "glass.debug.stop",
1740 "glass.agent.spawn",
1741 "glass.agent.setup",
1742 "glass.agent.delegate",
1743 "glass.agent.prompt",
1744 "glass.agent.send",
1745 "glass.agent.steer",
1746 "glass.agent.follow-up",
1747 "glass.agent.approve",
1748 "glass.agent.abort",
1749 "glass.agent.compact",
1750 "glass.agent.model",
1751 "glass.agent.thinking",
1752 "glass.agent.new-session",
1753 "glass.agent.clone-session",
1754 "glass.agent.rewind",
1755 "glass.agent.fork",
1756 "glass.agent.switch-session",
1757 "glass.agent.name",
1758 "glass.task.create",
1759 "glass.task.crew",
1760 "glass.task.pause",
1761 "glass.task.resume",
1762 "glass.task.cancel",
1763 "glass.task.retry",
1764 "glass.task.reassign",
1765 "glass.task.override-blocked",
1766 "glass.task.evidence",
1767 "glass.task.verify",
1768 "glass.experiment.create",
1769 "glass.experiment.collect",
1770 "glass.experiment.select",
1771 "glass.experiment.remove",
1772 "glass.editor.open",
1773 "glass.editor.replace",
1774 "glass.editor.replace_selection",
1775 "glass.editor.save",
1776 "glass.editor.comment.add",
1777 "glass.editor.comment.resolve",
1778 "glass.editor.proposal.create",
1779 "glass.editor.proposal.accept",
1780 "glass.editor.proposal.accept_pack",
1781 "glass.editor.proposal.reject",
1782 "glass.editor.checkpoint.create",
1783 "glass.editor.checkpoint.restore",
1784 "glass.process.start",
1785 "glass.process.stop",
1786 "glass.process.restart",
1787 "glass.process.input",
1788 "glass.process.resize",
1789 "glass.browser.start",
1790 "glass.browser.attach",
1791 "glass.browser.reconnect",
1792 "glass.browser.stop",
1793 "glass.browser.target.select",
1794 "glass.browser.navigate",
1795 "glass.browser.act",
1796 "glass.browser.remote-view.open",
1797 "glass.browser.remote-view.revoke",
1798 "glass.workflow.run",
1799 "glass.workflow.pause",
1800 "glass.workflow.resume",
1801 "glass.workflow.cancel",
1802 "glass.memory.forget",
1803 ];
1804 READ.iter()
1805 .map(|name| service_descriptor(name, false))
1806 .chain(MUTATE.iter().map(|name| service_descriptor(name, true)))
1807 .collect()
1808}
1809
1810pub(crate) fn tool_requires_mutation(name: &str) -> bool {
1811 static MUTATING: std::sync::LazyLock<Vec<String>> = std::sync::LazyLock::new(|| {
1812 service_descriptors()
1813 .into_iter()
1814 .filter(|descriptor| descriptor.mutating)
1815 .map(|descriptor| descriptor.name)
1816 .collect()
1817 });
1818 MUTATING.iter().any(|candidate| candidate == name)
1819}
1820
1821fn untrusted_tool_allowed(name: &str) -> bool {
1822 matches!(
1823 name,
1824 "glass.file.read"
1825 | "glass.file.list"
1826 | "glass.file.search"
1827 | "glass.file.grep"
1828 | "glass.file.find"
1829 | "glass.github.review"
1830 | "glass.git.status"
1831 | "glass.git.diff"
1832 | "glass.git.branches"
1833 | "glass.git.blame"
1834 | "glass.git.conflicts"
1835 | "glass.git.stash.list"
1836 | "glass.git.worktree.list"
1837 | "glass.browser.start"
1838 | "glass.browser.attach"
1839 | "glass.browser.reconnect"
1840 | "glass.browser.stop"
1841 | "glass.browser.state"
1842 | "glass.browser.observe"
1843 | "glass.browser.verify"
1844 | "glass.browser.snapshot"
1845 | "glass.browser.semantic"
1846 | "glass.browser.web_ir"
1847 | "glass.browser.diff"
1848 | "glass.browser.targets"
1849 | "glass.browser.target.select"
1850 | "glass.browser.navigate"
1851 | "glass.browser.act"
1852 | "glass.browser.screenshot"
1853 | "glass.browser.remote-view.open"
1854 | "glass.browser.remote-view.status"
1855 | "glass.browser.remote-view.revoke"
1856 | "glass.agent.setup"
1857 | "glass.agent.list"
1858 | "glass.agent.sessions"
1859 | "glass.agent.tree"
1860 | "glass.agent.messages"
1861 | "glass.agent.entries"
1862 | "glass.agent.stats"
1863 | "glass.graph.source"
1864 | "glass.agent.hello"
1865 | "glass.agent.models"
1866 | "glass.editor.open"
1867 | "glass.editor.selection"
1868 | "glass.editor.diff"
1869 | "glass.editor.buffers"
1870 | "glass.editor.comments"
1871 | "glass.editor.proposals"
1872 | "glass.editor.fim"
1873 | "glass.editor.checkpoints"
1874 | "glass.daemon.logs"
1875 | "glass.neovim.probe"
1876 | "glass.memory.retrieve"
1877 | "glass.memory.explain"
1878 | "glass.semantic.inspect"
1879 | "glass.semantic.diff"
1880 | "glass.semantic.links"
1881 | "glass.graph.query"
1882 | "glass.graph.path"
1883 | "glass.graph.explain"
1884 | "glass.replay.list"
1885 | "glass.replay.inspect"
1886 | "glass.replay.diff"
1887 | "glass.process.logs"
1888 | "glass.process.list"
1889 | "glass.process.health"
1890 | "glass.process.ports"
1891 | "glass.workspace.trust.status"
1892 | "glass.workspace.trust.inspect"
1893 | "glass.runtime.inspect"
1894 | "glass.todo.list"
1895 | "glass.task.list"
1896 | "glass.task.wake"
1897 | "glass.task.get"
1898 | "glass.task.inspect"
1899 )
1900}
1901
1902fn confined_worktree_path(workspace_root: &Path, path: &Path) -> DevelopmentResult<PathBuf> {
1903 if path.as_os_str().is_empty() {
1904 return Err(DevelopmentError::InvalidInput(
1905 "worktree path must be a non-empty relative or workspace worktree path".into(),
1906 ));
1907 }
1908 let base = workspace_root.join(".glass").join("worktrees");
1909 std::fs::create_dir_all(&base)?;
1910 let canonical_base = base.canonicalize()?;
1911 let candidate = if path.is_absolute() {
1912 path.to_path_buf()
1913 } else if path.components().any(|component| {
1914 matches!(
1915 component,
1916 std::path::Component::ParentDir
1917 | std::path::Component::RootDir
1918 | std::path::Component::Prefix(_)
1919 )
1920 }) {
1921 return Err(DevelopmentError::PathOutsideWorkspace(path.to_path_buf()));
1922 } else {
1923 base.join(path)
1924 };
1925 let name = candidate.file_name().ok_or_else(|| {
1926 DevelopmentError::InvalidInput("worktree path must name a directory".into())
1927 })?;
1928 if name == "." || name == ".." {
1929 return Err(DevelopmentError::InvalidInput(
1930 "worktree path must name a directory".into(),
1931 ));
1932 }
1933 let parent = candidate.parent().ok_or_else(|| {
1934 DevelopmentError::InvalidInput("worktree path must name a directory".into())
1935 })?;
1936 let mut existing_parent = parent;
1937 while !existing_parent.exists() {
1938 existing_parent = existing_parent
1939 .parent()
1940 .ok_or_else(|| DevelopmentError::PathOutsideWorkspace(candidate.clone()))?;
1941 }
1942 let canonical_existing = existing_parent.canonicalize()?;
1943 if !canonical_existing.starts_with(&canonical_base) {
1944 return Err(DevelopmentError::PathOutsideWorkspace(candidate));
1945 }
1946 std::fs::create_dir_all(parent)?;
1947 let canonical_parent = parent.canonicalize()?;
1948 if !canonical_parent.starts_with(&canonical_base) {
1949 return Err(DevelopmentError::PathOutsideWorkspace(candidate));
1950 }
1951 Ok(canonical_parent.join(name))
1952}
1953
1954fn service_descriptor(name: &str, mutating: bool) -> ToolDescriptor {
1955 let (description, input_schema) = if name == "glass.agent.delegate" {
1956 (
1957 "Delegate one bounded prompt to a temporary installed external agent".to_string(),
1958 serde_json::json!({
1959 "type": "object",
1960 "properties": {
1961 "harness": {"type": "string", "enum": ["codex", "claude", "opencode"]},
1962 "prompt": {"type": "string", "minLength": 1, "maxLength": 65536},
1963 "sandbox": {"type": "string", "enum": ["read-only", "workspace-write"]},
1964 "timeoutSeconds": {"type": "integer", "minimum": 1, "maximum": 3600}
1965 },
1966 "required": ["harness", "prompt"],
1967 "additionalProperties": false
1968 }),
1969 )
1970 } else {
1971 (
1972 format!("Resident Glass Dev operation {name}"),
1973 serde_json::json!({"type": "object"}),
1974 )
1975 };
1976 ToolDescriptor {
1977 name: name.into(),
1978 description,
1979 input_schema,
1980 mutating,
1981 available: true,
1982 unavailable_reason: None,
1983 }
1984}
1985
1986fn required_string<'a>(call: &'a ToolCall, name: &str) -> DevelopmentResult<&'a str> {
1987 call.arguments
1988 .get(name)
1989 .and_then(Value::as_str)
1990 .filter(|value| !value.is_empty() && value.len() <= 64 * 1024 && !value.contains('\0'))
1991 .ok_or_else(|| {
1992 DevelopmentError::InvalidInput(format!("{} requires bounded string {name}", call.name))
1993 })
1994}
1995
1996fn optional_string<'a>(call: &'a ToolCall, name: &str) -> Option<&'a str> {
1997 call.arguments.get(name).and_then(Value::as_str)
1998}
1999
2000fn required_value<'a>(call: &'a ToolCall, name: &str) -> DevelopmentResult<&'a Value> {
2001 call.arguments
2002 .get(name)
2003 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))
2004}
2005
2006fn value_map(
2007 call: &ToolCall,
2008 name: &str,
2009) -> DevelopmentResult<std::collections::BTreeMap<String, Value>> {
2010 match call.arguments.get(name) {
2011 None => Ok(std::collections::BTreeMap::new()),
2012 Some(value) => serde_json::from_value(value.clone()).map_err(DevelopmentError::from),
2013 }
2014}
2015
2016fn boolean(call: &ToolCall, name: &str, default: bool) -> bool {
2017 call.arguments
2018 .get(name)
2019 .and_then(Value::as_bool)
2020 .unwrap_or(default)
2021}
2022
2023fn unsigned(call: &ToolCall, name: &str, default: u64) -> DevelopmentResult<u64> {
2024 let value = call
2025 .arguments
2026 .get(name)
2027 .and_then(Value::as_u64)
2028 .unwrap_or(default);
2029 (value <= i64::MAX as u64).then_some(value).ok_or_else(|| {
2030 DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
2031 })
2032}
2033
2034fn integer(call: &ToolCall, name: &str) -> DevelopmentResult<i64> {
2035 call.arguments
2036 .get(name)
2037 .and_then(Value::as_i64)
2038 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))
2039}
2040
2041fn u32_value(call: &ToolCall, name: &str) -> DevelopmentResult<u32> {
2042 u32::try_from(unsigned(call, name, 0)?).map_err(|_| {
2043 DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
2044 })
2045}
2046
2047fn u16_value(call: &ToolCall, name: &str) -> DevelopmentResult<u16> {
2048 let value = u16::try_from(unsigned(call, name, 0)?).map_err(|_| {
2049 DevelopmentError::InvalidInput(format!("{}.{} is out of range", call.name, name))
2050 })?;
2051 (value > 0).then_some(value).ok_or_else(|| {
2052 DevelopmentError::InvalidInput(format!("{}.{} must be non-zero", call.name, name))
2053 })
2054}
2055
2056fn position(
2057 call: &ToolCall,
2058 name: &str,
2059) -> DevelopmentResult<crate::development::DiagnosticPosition> {
2060 serde_json::from_value(required_value(call, name)?.clone()).map_err(DevelopmentError::from)
2061}
2062
2063fn value_array_or_empty(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<Value>> {
2064 match call.arguments.get(name) {
2065 None => Ok(Vec::new()),
2066 Some(Value::Array(values)) if values.len() <= 512 => Ok(values.clone()),
2067 Some(_) => Err(DevelopmentError::InvalidInput(format!(
2068 "{}.{} must be an array of at most 512 values",
2069 call.name, name
2070 ))),
2071 }
2072}
2073
2074fn number(call: &ToolCall, name: &str, default: f64) -> DevelopmentResult<f64> {
2075 let value = call
2076 .arguments
2077 .get(name)
2078 .and_then(Value::as_f64)
2079 .unwrap_or(default);
2080 value.is_finite().then_some(value).ok_or_else(|| {
2081 DevelopmentError::InvalidInput(format!("{}.{} must be finite", call.name, name))
2082 })
2083}
2084
2085fn string_array(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<String>> {
2086 let values = call
2087 .arguments
2088 .get(name)
2089 .and_then(Value::as_array)
2090 .filter(|values| !values.is_empty() && values.len() <= 256)
2091 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))?;
2092 values
2093 .iter()
2094 .map(|value| {
2095 value
2096 .as_str()
2097 .filter(|value| !value.is_empty() && value.len() <= 4096 && !value.contains('\0'))
2098 .map(str::to_string)
2099 .ok_or_else(|| DevelopmentError::InvalidInput(format!("invalid {name} item")))
2100 })
2101 .collect()
2102}
2103
2104fn string_array_or_empty(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<String>> {
2105 if call.arguments.get(name).is_none() {
2106 Ok(Vec::new())
2107 } else {
2108 string_array(call, name)
2109 }
2110}
2111
2112fn unsigned_array(call: &ToolCall, name: &str) -> DevelopmentResult<Vec<u64>> {
2113 call.arguments
2114 .get(name)
2115 .and_then(Value::as_array)
2116 .filter(|values| !values.is_empty() && values.len() <= 512)
2117 .ok_or_else(|| DevelopmentError::InvalidInput(format!("{} requires {name}", call.name)))?
2118 .iter()
2119 .map(|value| {
2120 value
2121 .as_u64()
2122 .filter(|value| *value > 0)
2123 .ok_or_else(|| DevelopmentError::InvalidInput(format!("invalid {name} item")))
2124 })
2125 .collect()
2126}
2127
2128fn timeout(call: &ToolCall, maximum_seconds: u64) -> DevelopmentResult<Option<Duration>> {
2129 call.arguments
2130 .get("timeoutSeconds")
2131 .map(|_| unsigned(call, "timeoutSeconds", maximum_seconds))
2132 .transpose()?
2133 .map(|seconds| {
2134 if seconds == 0 || seconds > maximum_seconds {
2135 Err(DevelopmentError::InvalidInput(format!(
2136 "timeoutSeconds must be 1..={maximum_seconds}"
2137 )))
2138 } else {
2139 Ok(Duration::from_secs(seconds))
2140 }
2141 })
2142 .transpose()
2143}
2144
2145fn parse_kernel_kind(value: &str) -> DevelopmentResult<KernelKind> {
2146 match value {
2147 "python" => Ok(KernelKind::Python),
2148 "javascript" => Ok(KernelKind::JavaScript),
2149 "shell" => Ok(KernelKind::Shell),
2150 "sql" => Ok(KernelKind::Sql),
2151 _ => Err(DevelopmentError::InvalidInput(
2152 "kernel kind must be python, javascript, shell, or sql".into(),
2153 )),
2154 }
2155}
2156
2157fn normalized_actor_id(value: &str) -> String {
2158 let normalized: String = value
2159 .chars()
2160 .filter(|character| character.is_ascii_alphanumeric() || "-_.".contains(*character))
2161 .take(128)
2162 .collect();
2163 if normalized.is_empty() {
2164 "actor".into()
2165 } else {
2166 normalized
2167 }
2168}
2169
2170fn agent_id(
2171 workspace: &mut DevelopmentWorkspace,
2172 value: &str,
2173) -> DevelopmentResult<crate::agents::AgentId> {
2174 workspace
2175 .agents()
2176 .list()?
2177 .into_iter()
2178 .find(|snapshot| snapshot.id.as_str() == value)
2179 .map(|snapshot| snapshot.id)
2180 .ok_or_else(|| DevelopmentError::NotFound(format!("agent {value}")))
2181}
2182fn active_agent_id(workspace: &mut DevelopmentWorkspace) -> Option<crate::agents::AgentId> {
2183 workspace
2184 .agents()
2185 .list()
2186 .ok()?
2187 .into_iter()
2188 .find(|snapshot| {
2189 !matches!(
2190 snapshot.status,
2191 crate::agents::AgentStatus::Completed
2192 | crate::agents::AgentStatus::Failed
2193 | crate::agents::AgentStatus::Cancelled
2194 )
2195 })
2196 .map(|snapshot| snapshot.id)
2197}
2198
2199fn agent_request(
2200 workspace: &mut DevelopmentWorkspace,
2201 call: &ToolCall,
2202 request: PiSessionRequest,
2203) -> DevelopmentResult<Value> {
2204 let id = agent_id(workspace, required_string(call, "agentId")?)?;
2205 map_service(workspace.agents().request(&id, request))?;
2206 Ok(serde_json::json!({"queued":true}))
2207}
2208
2209fn task_action(
2210 workspace: &mut DevelopmentWorkspace,
2211 call: &ToolCall,
2212 action: impl FnOnce(&mut DevelopmentWorkspace, &TaskId) -> DevelopmentResult<()>,
2213) -> DevelopmentResult<Value> {
2214 let id = TaskId::parse(required_string(call, "taskId")?)?;
2215 action(workspace, &id)?;
2216 Ok(serde_json::json!({"updated":true}))
2217}
2218
2219fn map_service<T: serde::Serialize, E: std::fmt::Display>(
2220 result: Result<T, E>,
2221) -> DevelopmentResult<Value> {
2222 result
2223 .map_err(|error| DevelopmentError::Process(error.to_string()))
2224 .and_then(|value| serde_json::to_value(value).map_err(DevelopmentError::from))
2225}
2226
2227fn map_debug<T: serde::Serialize>(
2228 result: crate::debugger::DebugResult<T>,
2229) -> DevelopmentResult<Value> {
2230 map_service(result)
2231}
2232
2233fn debugger<'a>(
2234 workspace: &'a mut DevelopmentWorkspace,
2235 name: &str,
2236) -> DevelopmentResult<&'a mut crate::debugger::DebuggerSession> {
2237 workspace
2238 .debugger_mut(name)
2239 .map_err(|error| DevelopmentError::Process(error.to_string()))
2240}
2241
2242fn git_value<T: serde::Serialize>(
2243 git: Option<&crate::git::GitService>,
2244 operation: impl FnOnce(&crate::git::GitService) -> crate::git::GitResult<T>,
2245) -> DevelopmentResult<Value> {
2246 map_service(operation(git.ok_or_else(|| {
2247 DevelopmentError::NotFound("Git repository".into())
2248 })?))
2249}
2250
2251fn git_mutation(
2252 git: Option<&crate::git::GitService>,
2253 operation: impl FnOnce(&crate::git::GitService) -> crate::git::GitResult<()>,
2254) -> DevelopmentResult<()> {
2255 operation(git.ok_or_else(|| DevelopmentError::NotFound("Git repository".into()))?)
2256 .map_err(|error| DevelopmentError::Process(error.to_string()))
2257}
2258
2259fn project_observable_result(
2260 workspace: &mut DevelopmentWorkspace,
2261 call: &ToolCall,
2262 actor: &str,
2263 before_revision: u64,
2264 after_revision: u64,
2265 result: &Value,
2266) -> DevelopmentResult<()> {
2267 let tool_node = format!("tool:{}", call.id);
2268 let result_bytes = serde_json::to_vec(result)?.len();
2269 let summary = serde_json::json!({
2270 "tool":call.name,
2271 "callId":call.id,
2272 "beforeRevision":before_revision,
2273 "afterRevision":after_revision,
2274 "resultBytes":result_bytes,
2275 });
2276 let argument = |name: &str| {
2277 call.arguments.get(name).and_then(|value| {
2278 value
2279 .as_str()
2280 .map(str::to_string)
2281 .or_else(|| value.as_u64().map(|value| value.to_string()))
2282 .or_else(|| value.as_i64().map(|value| value.to_string()))
2283 })
2284 };
2285 let resource_name = |preferred: &[&str], fallback: &str| {
2286 preferred
2287 .iter()
2288 .find_map(|name| argument(name).filter(|value| !value.is_empty()))
2289 .unwrap_or_else(|| fallback.to_string())
2290 };
2291 let mut observed = Vec::<(String, DevelopmentNodeKind, String, String)>::new();
2292
2293 if call.name.starts_with("glass.file.") || call.name.starts_with("glass.editor.") {
2294 let path = resource_name(&["path", "from", "to"], &call.id);
2295 let file = format!("file:{}", id_component(&path));
2296 observed.push((
2297 file.clone(),
2298 DevelopmentNodeKind::File,
2299 path,
2300 "referencesFile".into(),
2301 ));
2302 if call.name.starts_with("glass.editor.") {
2303 observed.push((
2304 format!("editorRevision:{}", id_component(&call.id)),
2305 DevelopmentNodeKind::EditorRevision,
2306 format!("editor revision {after_revision}"),
2307 "producedEditorRevision".into(),
2308 ));
2309 }
2310 }
2311 if call.name.starts_with("glass.lsp.") {
2312 let path = resource_name(&["path"], &call.id);
2313 if call.name == "glass.lsp.diagnostics" || call.name == "glass.diagnostics.run" {
2314 observed.push((
2315 format!("diagnostic:{}", id_component(&call.id)),
2316 DevelopmentNodeKind::Diagnostic,
2317 path,
2318 "reportedDiagnostic".into(),
2319 ));
2320 } else if !matches!(
2321 call.name.as_str(),
2322 "glass.lsp.start" | "glass.lsp.stop" | "glass.lsp.list" | "glass.lsp.events"
2323 ) {
2324 observed.push((
2325 format!("symbol:{}", id_component(&call.id)),
2326 DevelopmentNodeKind::Symbol,
2327 path,
2328 "resolvedSymbol".into(),
2329 ));
2330 }
2331 }
2332 if call.name.starts_with("glass.git.") {
2333 let kind = if call.name == "glass.git.commit" {
2334 DevelopmentNodeKind::GitCommit
2335 } else {
2336 DevelopmentNodeKind::GitChange
2337 };
2338 observed.push((
2339 format!("gitChange:{}", id_component(&call.id)),
2340 kind,
2341 call.name.clone(),
2342 "observedGitChange".into(),
2343 ));
2344 }
2345 if call.name.starts_with("glass.process.") {
2346 let name = resource_name(&["name"], &call.id);
2347 observed.push((
2348 format!("process:{}", id_component(&name)),
2349 DevelopmentNodeKind::Process,
2350 name,
2351 "observedProcess".into(),
2352 ));
2353 if let Some(port) = find_scalar(result, &["port", "debugPort", "assignedPort"], 0) {
2354 observed.push((
2355 format!("port:{}", id_component(&port)),
2356 DevelopmentNodeKind::Port,
2357 port,
2358 "observedPort".into(),
2359 ));
2360 }
2361 }
2362 if call.name.starts_with("glass.debug.") {
2363 let session = resource_name(&["session"], &call.id);
2364 observed.push((
2365 format!("debugger:{}", id_component(&session)),
2366 DevelopmentNodeKind::Debugger,
2367 session.clone(),
2368 "observedDebugSession".into(),
2369 ));
2370 if call.name.contains("breakpoint") {
2371 observed.push((
2372 format!("breakpoint:{}", id_component(&call.id)),
2373 DevelopmentNodeKind::Breakpoint,
2374 resource_name(&["path"], &call.id),
2375 "configuredBreakpoint".into(),
2376 ));
2377 }
2378 if let Some(thread) = argument("threadId").or_else(|| find_scalar(result, &["threadId"], 0))
2379 {
2380 observed.push((
2381 format!(
2382 "thread:{}:{}",
2383 id_component(&session),
2384 id_component(&thread)
2385 ),
2386 DevelopmentNodeKind::Thread,
2387 thread,
2388 "observedThread".into(),
2389 ));
2390 }
2391 if let Some(frame) =
2392 argument("frameId").or_else(|| find_scalar(result, &["frameId", "id"], 0))
2393 {
2394 observed.push((
2395 format!(
2396 "stackFrame:{}:{}",
2397 id_component(&session),
2398 id_component(&frame)
2399 ),
2400 DevelopmentNodeKind::StackFrame,
2401 frame,
2402 "observedStackFrame".into(),
2403 ));
2404 }
2405 }
2406 if call.name.starts_with("glass.browser.") {
2407 let target = argument("targetId")
2408 .or_else(|| find_scalar(result, &["targetId", "id"], 0))
2409 .unwrap_or_else(|| "active".into());
2410 observed.push((
2411 format!("browserTarget:{}", id_component(&target)),
2412 DevelopmentNodeKind::BrowserTarget,
2413 target,
2414 "observedBrowserTarget".into(),
2415 ));
2416 if let Some(revision) = find_scalar(result, &["revision", "browserRevision"], 0) {
2417 observed.push((
2418 format!("browserRevision:{}", id_component(&revision)),
2419 DevelopmentNodeKind::BrowserRevision,
2420 revision,
2421 "observedBrowserRevision".into(),
2422 ));
2423 }
2424 }
2425 if call.name.starts_with("glass.semantic.")
2426 || call.name.starts_with("glass.web_ir.")
2427 || call.name == "glass.browser.web_ir"
2428 {
2429 observed.push((
2430 format!("webIr:{}", id_component(&call.id)),
2431 DevelopmentNodeKind::WebIrEntity,
2432 call.name.clone(),
2433 "observedWebIr".into(),
2434 ));
2435 }
2436 if call.name.starts_with("glass.workflow.") {
2437 let run = resource_name(&["runId", "id", "name"], &call.id);
2438 observed.push((
2439 format!("workflow:{}", id_component(&run)),
2440 DevelopmentNodeKind::Workflow,
2441 run,
2442 "observedWorkflow".into(),
2443 ));
2444 }
2445 if call.name.starts_with("glass.test.") {
2446 let run = resource_name(&["runId", "suiteId"], &call.id);
2447 observed.push((
2448 format!("test:{}", id_component(&run)),
2449 DevelopmentNodeKind::Test,
2450 run,
2451 "observedTest".into(),
2452 ));
2453 }
2454 if call.name.starts_with("glass.eval.") {
2455 let name = resource_name(&["name"], &call.id);
2456 observed.push((
2457 format!("kernel:{}", id_component(&name)),
2458 DevelopmentNodeKind::Kernel,
2459 name,
2460 "observedKernel".into(),
2461 ));
2462 }
2463 if call.name.starts_with("glass.agent.") {
2464 let agent = argument("agentId")
2465 .or_else(|| find_scalar(result, &["agentId", "id"], 0))
2466 .unwrap_or_else(|| call.id.clone());
2467 observed.push((
2468 format!("agent:{}", id_component(&agent)),
2469 DevelopmentNodeKind::Agent,
2470 agent,
2471 "observedAgent".into(),
2472 ));
2473 }
2474 if call.name.starts_with("glass.task.") {
2475 let task = resource_name(&["taskId", "id"], &call.id);
2476 observed.push((
2477 format!("task:{}", id_component(&task)),
2478 DevelopmentNodeKind::Task,
2479 task,
2480 "observedTask".into(),
2481 ));
2482 }
2483 if call.name.starts_with("glass.experiment.") {
2484 let experiment = resource_name(&["id"], &call.id);
2485 observed.push((
2486 format!("experiment:{}", id_component(&experiment)),
2487 DevelopmentNodeKind::Experiment,
2488 experiment,
2489 "observedExperiment".into(),
2490 ));
2491 }
2492
2493 let mut previous: Option<String> = None;
2494 for (id, kind, label, relation) in observed {
2495 workspace.intelligence_mut().upsert_node(DevelopmentNode {
2496 id: id.clone(),
2497 kind,
2498 label,
2499 revision: after_revision,
2500 stale: false,
2501 evidence: summary.clone(),
2502 })?;
2503 workspace.intelligence_mut().link(
2504 previous.as_deref().unwrap_or(&tool_node),
2505 &id,
2506 &relation,
2507 after_revision,
2508 actor,
2509 summary.clone(),
2510 )?;
2511 workspace.intelligence_mut().record(ObservableEventInput {
2512 actor,
2513 subsystem: subsystem_for_tool(&call.name),
2514 kind: "observed",
2515 resource: Some(&id),
2516 workspace_revision: after_revision,
2517 evidence: summary.clone(),
2518 rationale: None,
2519 })?;
2520 previous = Some(id);
2521 }
2522 Ok(())
2523}
2524
2525fn subsystem_for_tool(tool: &str) -> &str {
2526 tool.strip_prefix("glass.")
2527 .and_then(|value| value.split('.').next())
2528 .unwrap_or("project")
2529}
2530
2531fn id_component(value: &str) -> String {
2532 value
2533 .chars()
2534 .map(|character| {
2535 if character.is_control() {
2536 '_'
2537 } else {
2538 character
2539 }
2540 })
2541 .take(240)
2542 .collect()
2543}
2544
2545fn find_scalar(value: &Value, keys: &[&str], depth: usize) -> Option<String> {
2546 if depth > 6 {
2547 return None;
2548 }
2549 match value {
2550 Value::Object(values) => {
2551 for key in keys {
2552 if let Some(value) = values.get(*key) {
2553 if let Some(value) = value.as_str() {
2554 return Some(value.to_string());
2555 }
2556 if let Some(value) = value.as_u64() {
2557 return Some(value.to_string());
2558 }
2559 }
2560 }
2561 values
2562 .values()
2563 .find_map(|value| find_scalar(value, keys, depth + 1))
2564 }
2565 Value::Array(values) => values
2566 .iter()
2567 .find_map(|value| find_scalar(value, keys, depth + 1)),
2568 _ => None,
2569 }
2570}
2571
2572#[cfg(test)]
2573mod tests {
2574 use super::*;
2575 use crate::development::Actor;
2576 use serde_json::json;
2577 use std::path::Path;
2578 use std::sync::atomic::{AtomicU64, Ordering};
2579
2580 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
2581
2582 fn workspace() -> DevelopmentWorkspace {
2583 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
2584 let root = std::env::temp_dir().join(format!(
2585 "glass-tool-router-{}-{sequence}",
2586 std::process::id()
2587 ));
2588 std::fs::create_dir_all(&root).unwrap();
2589 std::fs::write(
2590 root.join("Cargo.toml"),
2591 "[package]\nname='x'\nversion='0.1.0'\n",
2592 )
2593 .unwrap();
2594 let mut workspace = DevelopmentWorkspace::open(root).unwrap();
2595 workspace
2596 .apply_local_trust_decision(crate::LocalTrustDecision::TrustOnce)
2597 .unwrap();
2598 workspace
2599 }
2600
2601 fn context(workspace: &DevelopmentWorkspace, mutate: bool) -> DevelopmentToolContext {
2602 DevelopmentToolContext {
2603 authorization: ToolAuthorization {
2604 actor: Actor::embedded(),
2605 allow_mutation: mutate,
2606 confirmed: mutate,
2607 unrestricted: mutate,
2608 },
2609 initiator: None,
2610 expected_generation: workspace.generation(),
2611 expected_project_revision: workspace.project().revision(),
2612 }
2613 }
2614
2615 #[test]
2616 fn worktree_paths_are_confined_to_glass_worktrees() {
2617 let root = std::env::temp_dir().join(format!(
2618 "glass-worktree-confine-{}-{}",
2619 std::process::id(),
2620 NEXT_ROOT.fetch_add(1, Ordering::Relaxed)
2621 ));
2622 std::fs::create_dir_all(&root).unwrap();
2623 let root = root.canonicalize().unwrap();
2624
2625 let relative = confined_worktree_path(&root, Path::new("feature")).unwrap();
2626 assert!(relative.starts_with(root.join(".glass").join("worktrees")));
2627 assert_eq!(relative.file_name().unwrap(), "feature");
2628
2629 let nested = confined_worktree_path(&root, Path::new("nested/leaf")).unwrap();
2630 assert_eq!(nested.file_name().unwrap(), "leaf");
2631 assert!(nested.starts_with(root.join(".glass").join("worktrees").join("nested")));
2632
2633 let allowed_abs = root.join(".glass").join("worktrees").join("abs");
2634 let confined_abs = confined_worktree_path(&root, &allowed_abs).unwrap();
2635 assert_eq!(confined_abs.file_name().unwrap(), "abs");
2636
2637 assert!(confined_worktree_path(&root, Path::new("../escape")).is_err());
2638 assert!(confined_worktree_path(&root, Path::new("")).is_err());
2639
2640 let outside = std::env::temp_dir().join(format!(
2641 "glass-worktree-outside-{}-{}",
2642 std::process::id(),
2643 NEXT_ROOT.fetch_add(1, Ordering::Relaxed)
2644 ));
2645 let outside_child = outside.join("leaf");
2646 assert!(confined_worktree_path(&root, &outside_child).is_err());
2647 assert!(!outside.exists());
2648
2649 std::fs::remove_dir_all(&root).unwrap();
2650 }
2651
2652 #[test]
2653 fn git_unstage_is_registered_as_a_mutating_tool() {
2654 let unstage = service_descriptors()
2655 .into_iter()
2656 .find(|descriptor| descriptor.name == "glass.git.unstage")
2657 .expect("glass.git.unstage must be advertised");
2658 assert!(unstage.mutating);
2659 assert!(unstage.available);
2660 assert!(tool_requires_mutation("glass.git.unstage"));
2661 assert!(tool_requires_mutation("glass.lsp.raw"));
2662 }
2663
2664 #[test]
2665 fn root_file_listing_with_empty_path_keeps_tool_successful() {
2666 let mut workspace = workspace();
2667 let router = DevelopmentToolRouter::default();
2668 let call = ToolCall {
2669 id: "list-root".into(),
2670 name: "glass.file.list".into(),
2671 arguments: json!({"path":""}),
2672 };
2673 let read_only = context(&workspace, false);
2674 let result = router
2675 .execute(&mut workspace, &call, &read_only)
2676 .expect("listing the project root must succeed");
2677 assert!(result["entries"].is_array());
2678 assert_eq!(
2679 workspace
2680 .intelligence()
2681 .node("file:list-root")
2682 .unwrap()
2683 .label,
2684 "list-root"
2685 );
2686 }
2687
2688 #[test]
2689 fn router_rejects_stale_or_unauthorized_mutations() {
2690 let mut workspace = workspace();
2691 let router = DevelopmentToolRouter::default();
2692 let call = ToolCall {
2693 id: "write-1".into(),
2694 name: "glass.file.write".into(),
2695 arguments: serde_json::json!({"path":"src/lib.rs","content":"pub fn ok() {}\n"}),
2696 };
2697 let read_only = context(&workspace, false);
2698 assert!(router.execute(&mut workspace, &call, &read_only).is_err());
2699 let mut stale = context(&workspace, true);
2700 stale.expected_project_revision = stale.expected_project_revision.saturating_add(1);
2701 assert!(router.execute(&mut workspace, &call, &stale).is_err());
2702 let valid = context(&workspace, true);
2703 workspace.execute_tool(&call, &valid).unwrap();
2704 assert!(workspace.root().join("src/lib.rs").exists());
2705 let replay = workspace.intelligence().replay(0, 16).unwrap();
2706 assert_eq!(
2707 replay
2708 .iter()
2709 .map(|event| event.kind.as_str())
2710 .collect::<Vec<_>>(),
2711 vec!["called", "observed", "completed"]
2712 );
2713 assert!(
2714 workspace
2715 .intelligence()
2716 .path("repository:root", "tool:write-1")
2717 .is_ok()
2718 );
2719 }
2720
2721 #[test]
2722 fn router_uses_resident_kernel_and_test_services() {
2723 let mut workspace = workspace();
2724 let router = DevelopmentToolRouter::default();
2725 let start = ToolCall {
2726 id: "kernel-1".into(),
2727 name: "glass.eval.start".into(),
2728 arguments: serde_json::json!({"name":"analysis","kind":"sql"}),
2729 };
2730 let mutation = context(&workspace, true);
2731 router.execute(&mut workspace, &start, &mutation).unwrap();
2732 let execute = ToolCall {
2733 id: "kernel-2".into(),
2734 name: "glass.eval.execute".into(),
2735 arguments: serde_json::json!({"name":"analysis","code":"SELECT 40 + 2 AS answer"}),
2736 };
2737 let result = router.execute(&mut workspace, &execute, &mutation).unwrap();
2738 assert_eq!(result["value"][0]["answer"], 42);
2739 assert!(
2740 router
2741 .descriptors()
2742 .iter()
2743 .any(|descriptor| descriptor.name == "glass.debug.launch")
2744 );
2745 }
2746
2747 #[test]
2748 fn kernel_bindings_reenter_the_same_router_with_dual_provenance() {
2749 let mut workspace = workspace();
2750 std::fs::write(workspace.root().join("evidence.txt"), "governed\n").unwrap();
2751 let router = DevelopmentToolRouter::default();
2752 let mutation = context(&workspace, true);
2753 router
2754 .execute(
2755 &mut workspace,
2756 &ToolCall {
2757 id: "kernel-binding-start".into(),
2758 name: "glass.eval.start".into(),
2759 arguments: serde_json::json!({
2760 "name":"analysis",
2761 "kind":"sql",
2762 "capabilities":["glass.file.read","glass.file.write"]
2763 }),
2764 },
2765 &mutation,
2766 )
2767 .unwrap();
2768 let result = router
2769 .execute(
2770 &mut workspace,
2771 &ToolCall {
2772 id: "kernel-binding-execute".into(),
2773 name: "glass.eval.execute".into(),
2774 arguments: serde_json::json!({
2775 "name":"analysis",
2776 "code":r#"GLASS CALL {"id":"sql-1","tool":"glass.file.read","arguments":{"path":"evidence.txt"}}"#
2777 }),
2778 },
2779 &mutation,
2780 )
2781 .unwrap();
2782 assert_eq!(result["value"]["content"], "governed\n");
2783 assert_eq!(result["initiatorId"], "embedded:glass-agent");
2784 assert_eq!(result["executorId"], "kernel:analysis");
2785 let replay = workspace.intelligence().replay(0, 32).unwrap();
2786 let nested = replay
2787 .iter()
2788 .find(|event| event.resource.as_deref() == Some("tool:kernel-analysis-sql-1"))
2789 .unwrap();
2790 assert_eq!(nested.actor, "kernel:analysis");
2791 assert_eq!(nested.evidence["initiator"], "embedded:glass-agent");
2792 assert_eq!(nested.evidence["executor"], "kernel:analysis");
2793
2794 let denied = router.execute(
2795 &mut workspace,
2796 &ToolCall {
2797 id: "kernel-binding-denied".into(),
2798 name: "glass.eval.execute".into(),
2799 arguments: serde_json::json!({
2800 "name":"analysis",
2801 "code":r#"GLASS CALL {"id":"sql-2","tool":"glass.file.write","arguments":{"path":"denied.txt","content":"no"}}"#
2802 }),
2803 },
2804 &mutation,
2805 );
2806 assert!(denied.unwrap_err().to_string().contains("mutation"));
2807 assert!(!workspace.root().join("denied.txt").exists());
2808 }
2809
2810 #[test]
2811 fn governed_python_queries_browser_tests_and_graph_before_approved_mutation() {
2812 let mut workspace = workspace();
2813 let router = DevelopmentToolRouter::default();
2814 let mutation = context(&workspace, true);
2815 router
2816 .execute(
2817 &mut workspace,
2818 &ToolCall {
2819 id: "governed-python-start".into(),
2820 name: "glass.eval.start".into(),
2821 arguments: serde_json::json!({
2822 "name":"analysis",
2823 "kind":"python",
2824 "capabilities":[
2825 "glass.browser.state",
2826 "glass.test.results",
2827 "glass.graph.path",
2828 "glass.file.write"
2829 ]
2830 }),
2831 },
2832 &mutation,
2833 )
2834 .unwrap();
2835
2836 for (id, code, expected) in [
2837 (
2838 "governed-python-browser",
2839 "glass.call('glass.browser.state')",
2840 "'connected': False",
2841 ),
2842 (
2843 "governed-python-tests",
2844 "glass.call('glass.test.results')",
2845 "results",
2846 ),
2847 (
2848 "governed-python-graph",
2849 "glass.call('glass.graph.path', {'from': 'repository:root', 'to': 'tool:kernel-analysis-python-1'})",
2850 "repository:root",
2851 ),
2852 ] {
2853 let result = router
2854 .execute(
2855 &mut workspace,
2856 &ToolCall {
2857 id: id.into(),
2858 name: "glass.eval.execute".into(),
2859 arguments: serde_json::json!({"name":"analysis","code":code}),
2860 },
2861 &mutation,
2862 )
2863 .unwrap();
2864 assert!(
2865 result["value"].as_str().unwrap().contains(expected),
2866 "{id} must return governed {expected} evidence: {result}"
2867 );
2868 assert_eq!(result["initiatorId"], "embedded:glass-agent");
2869 assert_eq!(result["executorId"], "kernel:analysis");
2870 }
2871
2872 let denied = router.execute(
2873 &mut workspace,
2874 &ToolCall {
2875 id: "governed-python-denied".into(),
2876 name: "glass.eval.execute".into(),
2877 arguments: serde_json::json!({
2878 "name":"analysis",
2879 "code":"glass.call('glass.file.write', {'path': 'denied.py', 'content': 'no'})"
2880 }),
2881 },
2882 &mutation,
2883 );
2884 assert!(denied.unwrap_err().to_string().contains("mutation"));
2885 assert!(!workspace.root().join("denied.py").exists());
2886
2887 router
2888 .execute(
2889 &mut workspace,
2890 &ToolCall {
2891 id: "approved-python-start".into(),
2892 name: "glass.eval.start".into(),
2893 arguments: serde_json::json!({
2894 "name":"approved",
2895 "kind":"python",
2896 "capabilities":["glass.file.write"],
2897 "mutationAuthority":true
2898 }),
2899 },
2900 &mutation,
2901 )
2902 .unwrap();
2903 let approved = router
2904 .execute(
2905 &mut workspace,
2906 &ToolCall {
2907 id: "approved-python-write".into(),
2908 name: "glass.eval.execute".into(),
2909 arguments: serde_json::json!({
2910 "name":"approved",
2911 "code":"glass.call('glass.file.write', {'path': 'approved.py', 'content': 'approved\\n'})"
2912 }),
2913 },
2914 &mutation,
2915 )
2916 .unwrap();
2917 assert_eq!(approved["initiatorId"], "embedded:glass-agent");
2918 assert_eq!(approved["executorId"], "kernel:approved");
2919 assert_eq!(
2920 std::fs::read_to_string(workspace.root().join("approved.py")).unwrap(),
2921 "approved\n"
2922 );
2923
2924 let replay = workspace.intelligence().replay(0, 128).unwrap();
2925 for resource in [
2926 "tool:kernel-analysis-python-1",
2927 "tool:kernel-analysis-python-2",
2928 "tool:kernel-analysis-python-3",
2929 "tool:kernel-approved-python-1",
2930 ] {
2931 let nested = replay
2932 .iter()
2933 .find(|event| event.resource.as_deref() == Some(resource))
2934 .unwrap_or_else(|| panic!("missing provenance for {resource}"));
2935 assert_eq!(nested.evidence["initiator"], "embedded:glass-agent");
2936 assert!(
2937 nested.evidence["executor"]
2938 .as_str()
2939 .unwrap()
2940 .starts_with("kernel:")
2941 );
2942 }
2943 }
2944
2945 #[test]
2946 fn router_exposes_shared_editor_process_browser_and_complete_lsp_tools() {
2947 let mut workspace = workspace();
2948 std::fs::create_dir_all(workspace.root().join("src")).unwrap();
2949 std::fs::write(workspace.root().join("src/lib.rs"), "pub fn old() {}\n").unwrap();
2950 let router = DevelopmentToolRouter::default();
2951 let descriptors = router.descriptors();
2952 for name in [
2953 "glass.editor.open",
2954 "glass.editor.selection",
2955 "glass.editor.replace",
2956 "glass.editor.replace_selection",
2957 "glass.editor.save",
2958 "glass.editor.comments",
2959 "glass.editor.proposals",
2960 "glass.editor.fim",
2961 "glass.editor.checkpoints",
2962 "glass.editor.comment.add",
2963 "glass.editor.comment.resolve",
2964 "glass.editor.proposal.create",
2965 "glass.editor.proposal.accept",
2966 "glass.editor.proposal.accept_pack",
2967 "glass.editor.proposal.reject",
2968 "glass.editor.checkpoint.create",
2969 "glass.editor.checkpoint.restore",
2970 "glass.process.list",
2971 "glass.process.logs",
2972 "glass.process.start",
2973 "glass.github.review",
2974 "glass.github.ship",
2975 "glass.process.stop",
2976 "glass.process.restart",
2977 "glass.browser.observe",
2978 "glass.browser.verify",
2979 "glass.browser.snapshot",
2980 "glass.browser.attach",
2981 "glass.browser.reconnect",
2982 "glass.browser.semantic",
2983 "glass.browser.web_ir",
2984 "glass.browser.diff",
2985 "glass.browser.navigate",
2986 "glass.browser.act",
2987 "glass.workflow.list",
2988 "glass.workflow.run",
2989 "glass.workflow.pause",
2990 "glass.workflow.resume",
2991 "glass.workflow.cancel",
2992 "glass.workflow.verify",
2993 "glass.workflow.record",
2994 "glass.memory.retrieve",
2995 "glass.memory.explain",
2996 "glass.memory.forget",
2997 "glass.semantic.inspect",
2998 "glass.semantic.diff",
2999 "glass.semantic.links",
3000 "glass.lsp.start",
3001 "glass.lsp.stop",
3002 "glass.lsp.list",
3003 "glass.lsp.events",
3004 "glass.lsp.definition",
3005 "glass.lsp.declaration",
3006 "glass.lsp.implementation",
3007 "glass.lsp.references",
3008 "glass.lsp.document_symbols",
3009 "glass.lsp.workspace_symbols",
3010 "glass.lsp.inlay_hints",
3011 "glass.lsp.signature_help",
3012 "glass.lsp.code_actions",
3013 "glass.lsp.formatting",
3014 "glass.lsp.range_formatting",
3015 "glass.lsp.semantic_tokens",
3016 "glass.lsp.rename",
3017 "glass.lsp.raw",
3018 "glass.debug.configuration_done",
3019 "glass.debug.restart",
3020 "glass.debug.breakpoint.remove",
3021 "glass.debug.exception.set",
3022 "glass.debug.threads",
3023 "glass.debug.disconnect",
3024 "glass.debug.terminate",
3025 "glass.agent.model",
3026 "glass.agent.thinking",
3027 "glass.agent.new-session",
3028 "glass.agent.clone-session",
3029 "glass.agent.rewind",
3030 "glass.agent.fork",
3031 "glass.agent.switch-session",
3032 "glass.agent.sessions",
3033 "glass.agent.tree",
3034 "glass.agent.messages",
3035 "glass.agent.entries",
3036 "glass.agent.stats",
3037 "glass.agent.name",
3038 "glass.todo.list",
3039 "glass.todo.write",
3040 "glass.todo.complete",
3041 "glass.task.create",
3042 "glass.task.crew",
3043 "glass.task.list",
3044 "glass.task.wake",
3045 "glass.task.get",
3046 "glass.task.inspect",
3047 "glass.task.pause",
3048 "glass.task.resume",
3049 "glass.task.cancel",
3050 "glass.task.retry",
3051 "glass.task.reassign",
3052 "glass.task.override-blocked",
3053 "glass.task.evidence",
3054 "glass.task.verify",
3055 "glass.experiment.create",
3056 "glass.experiment.collect",
3057 "glass.experiment.list",
3058 "glass.experiment.compare",
3059 "glass.experiment.select",
3060 "glass.experiment.remove",
3061 ] {
3062 let descriptor = descriptors
3063 .iter()
3064 .find(|descriptor| descriptor.name == name)
3065 .unwrap_or_else(|| panic!("missing {name}"));
3066 assert!(
3067 descriptor.available,
3068 "{name} must execute, not be a placeholder"
3069 );
3070 }
3071 let semantic_descriptors = descriptors
3072 .iter()
3073 .filter(|descriptor| descriptor.name == "glass.semantic.inspect")
3074 .collect::<Vec<_>>();
3075 assert_eq!(semantic_descriptors.len(), 1);
3076 assert_eq!(
3077 semantic_descriptors[0].input_schema["required"],
3078 serde_json::json!(["entity"])
3079 );
3080
3081 for (id, name, arguments) in [
3082 (
3083 "open",
3084 "glass.editor.open",
3085 serde_json::json!({"path":"src/lib.rs"}),
3086 ),
3087 (
3088 "replace",
3089 "glass.editor.replace",
3090 serde_json::json!({"path":"src/lib.rs","oldText":"old","newText":"resident"}),
3091 ),
3092 (
3093 "save",
3094 "glass.editor.save",
3095 serde_json::json!({"path":"src/lib.rs"}),
3096 ),
3097 ] {
3098 let call = ToolCall {
3099 id: id.into(),
3100 name: name.into(),
3101 arguments,
3102 };
3103 let authorized = context(&workspace, true);
3104 router.execute(&mut workspace, &call, &authorized).unwrap();
3105 }
3106 assert_eq!(
3107 std::fs::read_to_string(workspace.root().join("src/lib.rs")).unwrap(),
3108 "pub fn resident() {}\n"
3109 );
3110 }
3111 #[test]
3112 fn editor_selection_tool_returns_text_and_replaces_only_that_range() {
3113 let mut workspace = workspace();
3114 std::fs::create_dir_all(workspace.root().join("src")).unwrap();
3115 std::fs::write(workspace.root().join("src/lib.rs"), "alpha\nbeta\n").unwrap();
3116 let router = DevelopmentToolRouter::default();
3117 let authorized = context(&workspace, true);
3118 router
3119 .execute(
3120 &mut workspace,
3121 &ToolCall {
3122 id: "selection-open".into(),
3123 name: "glass.editor.open".into(),
3124 arguments: serde_json::json!({"path":"src/lib.rs"}),
3125 },
3126 &authorized,
3127 )
3128 .unwrap();
3129 workspace
3130 .project_mut()
3131 .set_buffer_selection(
3132 "src/lib.rs",
3133 Some(crate::development::TextSelection {
3134 anchor: crate::development::TextPosition { line: 1, column: 2 },
3135 active: crate::development::TextPosition { line: 2, column: 3 },
3136 }),
3137 crate::development::Actor::local(),
3138 )
3139 .unwrap();
3140 let read_only = context(&workspace, false);
3141 let selection = router
3142 .execute(
3143 &mut workspace,
3144 &ToolCall {
3145 id: "selection-read".into(),
3146 name: "glass.editor.selection".into(),
3147 arguments: serde_json::json!({"path":"src/lib.rs"}),
3148 },
3149 &read_only,
3150 )
3151 .unwrap();
3152 assert_eq!(selection["selectedText"], "lpha\nbe");
3153 let authorized = context(&workspace, true);
3154 router
3155 .execute(
3156 &mut workspace,
3157 &ToolCall {
3158 id: "selection-replace".into(),
3159 name: "glass.editor.replace_selection".into(),
3160 arguments: serde_json::json!({
3161 "path":"src/lib.rs",
3162 "replacement":"X\nY"
3163 }),
3164 },
3165 &authorized,
3166 )
3167 .unwrap();
3168 assert_eq!(
3169 workspace.project().buffer("src/lib.rs").unwrap().content,
3170 "aX\nYta\n"
3171 );
3172 assert!(
3173 workspace
3174 .project()
3175 .buffer("src/lib.rs")
3176 .unwrap()
3177 .selection
3178 .is_none()
3179 );
3180 }
3181
3182 #[test]
3183 fn live_web_ir_route_is_read_only_and_requires_browser() {
3184 let mut workspace = workspace();
3185 let router = DevelopmentToolRouter::default();
3186 let descriptor = router
3187 .descriptors()
3188 .into_iter()
3189 .find(|descriptor| descriptor.name == "glass.browser.web_ir")
3190 .expect("live Web IR descriptor");
3191 assert!(descriptor.available);
3192 assert!(!descriptor.mutating);
3193
3194 let read_only = context(&workspace, false);
3195 let error = router
3196 .execute(
3197 &mut workspace,
3198 &ToolCall {
3199 id: "web-ir-disconnected".into(),
3200 name: "glass.browser.web_ir".into(),
3201 arguments: json!({}),
3202 },
3203 &read_only,
3204 )
3205 .unwrap_err();
3206 assert!(error.to_string().contains("glass.browser.start"));
3207 }
3208
3209 #[test]
3210 fn observable_projection_populates_every_issue_35_graph_resource_kind() {
3211 let mut workspace = workspace();
3212 let samples = vec![
3213 ("glass.editor.save", json!({"path":"src/lib.rs"}), json!({})),
3214 ("glass.lsp.hover", json!({"path":"src/lib.rs"}), json!({})),
3215 (
3216 "glass.lsp.diagnostics",
3217 json!({"path":"src/lib.rs"}),
3218 json!([]),
3219 ),
3220 ("glass.git.diff", json!({}), json!({"changed":true})),
3221 (
3222 "glass.process.ports",
3223 json!({"name":"web"}),
3224 json!({"port":8080}),
3225 ),
3226 (
3227 "glass.debug.stack",
3228 json!({"session":"rust","threadId":3}),
3229 json!({"stackFrames":[{"id":9}]}),
3230 ),
3231 (
3232 "glass.browser.state",
3233 json!({}),
3234 json!({"targetId":"page-1","revision":12}),
3235 ),
3236 ("glass.web_ir.inspect", json!({}), json!({"entities":[]})),
3237 (
3238 "glass.browser.web_ir",
3239 json!({}),
3240 json!({"targetId":"page-1","revision":12,"entityCount":3}),
3241 ),
3242 (
3243 "glass.workflow.verify",
3244 json!({"runId":"checkout"}),
3245 json!({"passed":false}),
3246 ),
3247 (
3248 "glass.test.results",
3249 json!({"runId":"unit"}),
3250 json!({"passed":true}),
3251 ),
3252 (
3253 "glass.eval.execute",
3254 json!({"name":"analysis"}),
3255 json!({"value":42}),
3256 ),
3257 ("glass.agent.list", json!({}), json!({"agentId":"agent-1"})),
3258 (
3259 "glass.task.get",
3260 json!({"taskId":"task-1"}),
3261 json!({"state":"failed"}),
3262 ),
3263 (
3264 "glass.experiment.collect",
3265 json!({"id":"approach-a"}),
3266 json!({"measured":true}),
3267 ),
3268 ];
3269 for (index, (name, arguments, result)) in samples.into_iter().enumerate() {
3270 let call = ToolCall {
3271 id: format!("projection-{index}"),
3272 name: name.into(),
3273 arguments,
3274 };
3275 let tool_node = format!("tool:{}", call.id);
3276 workspace
3277 .intelligence_mut()
3278 .upsert_node(DevelopmentNode {
3279 id: tool_node.clone(),
3280 kind: DevelopmentNodeKind::ToolCall,
3281 label: call.name.clone(),
3282 revision: 1,
3283 stale: false,
3284 evidence: Value::Null,
3285 })
3286 .unwrap();
3287 workspace
3288 .intelligence_mut()
3289 .link(
3290 "repository:root",
3291 &tool_node,
3292 "receivedToolCall",
3293 1,
3294 "test",
3295 Value::Null,
3296 )
3297 .unwrap();
3298 project_observable_result(&mut workspace, &call, "test", 1, 1, &result).unwrap();
3299 }
3300 assert!(
3301 workspace
3302 .intelligence()
3303 .query_kind(DevelopmentNodeKind::WebIrEntity)
3304 .iter()
3305 .any(|node| node.id == "webIr:projection-8"),
3306 "live browser Web IR must be projected into the graph"
3307 );
3308 for kind in [
3309 DevelopmentNodeKind::Repository,
3310 DevelopmentNodeKind::File,
3311 DevelopmentNodeKind::Symbol,
3312 DevelopmentNodeKind::EditorRevision,
3313 DevelopmentNodeKind::GitChange,
3314 DevelopmentNodeKind::Process,
3315 DevelopmentNodeKind::Port,
3316 DevelopmentNodeKind::Diagnostic,
3317 DevelopmentNodeKind::Debugger,
3318 DevelopmentNodeKind::Thread,
3319 DevelopmentNodeKind::StackFrame,
3320 DevelopmentNodeKind::BrowserTarget,
3321 DevelopmentNodeKind::BrowserRevision,
3322 DevelopmentNodeKind::WebIrEntity,
3323 DevelopmentNodeKind::Workflow,
3324 DevelopmentNodeKind::Test,
3325 DevelopmentNodeKind::Kernel,
3326 DevelopmentNodeKind::Agent,
3327 DevelopmentNodeKind::Task,
3328 DevelopmentNodeKind::Experiment,
3329 DevelopmentNodeKind::ToolCall,
3330 ] {
3331 assert!(
3332 !workspace.intelligence().query_kind(kind).is_empty(),
3333 "missing {kind:?}"
3334 );
3335 }
3336 let router = DevelopmentToolRouter::default();
3337 for (index, (from, to, relation)) in [
3338 ("file:src/lib.rs", "gitChange:projection-3", "changedBy"),
3339 ("gitChange:projection-3", "test:unit", "verifiedBy"),
3340 ("test:unit", "webIr:projection-7", "observedRegression"),
3341 ]
3342 .into_iter()
3343 .enumerate()
3344 {
3345 let context = context(&workspace, true);
3346 router
3347 .execute(
3348 &mut workspace,
3349 &ToolCall {
3350 id: format!("causal-link-{index}"),
3351 name: "glass.graph.link".into(),
3352 arguments: json!({
3353 "from":from,
3354 "to":to,
3355 "relation":relation,
3356 "evidence":{"source":"resident-verification"}
3357 }),
3358 },
3359 &context,
3360 )
3361 .unwrap();
3362 }
3363 let path = workspace
3364 .intelligence()
3365 .path("file:src/lib.rs", "webIr:projection-7")
3366 .unwrap();
3367 assert_eq!(
3368 path.edges
3369 .iter()
3370 .map(|edge| edge.relation.as_str())
3371 .collect::<Vec<_>>(),
3372 vec!["changedBy", "verifiedBy", "observedRegression"]
3373 );
3374 assert!(path.edges.iter().all(|edge| !edge.provenance.is_empty()));
3375 let replay = workspace.intelligence().replay(0, 128).unwrap();
3376 assert!(replay.iter().any(|event| event.subsystem == "task"));
3377 assert!(replay.iter().all(|event| event.rationale.is_none()));
3378 }
3379
3380 #[test]
3381 fn external_delegate_is_registered_as_approval_gated_capability() {
3382 let descriptor = DevelopmentToolRouter::default()
3383 .descriptors()
3384 .into_iter()
3385 .find(|descriptor| descriptor.name == "glass.agent.delegate")
3386 .expect("external delegate descriptor");
3387 assert!(descriptor.mutating);
3388 assert_eq!(
3389 descriptor.input_schema["properties"]["sandbox"]["enum"],
3390 json!(["read-only", "workspace-write"])
3391 );
3392 assert!(tool_requires_mutation("glass.agent.delegate"));
3393 }
3394
3395 const AGENT_HIDDEN_TOOLS: &[&str] = &[
3396 "glass.workspace.list",
3397 "glass.workspace.inspect",
3398 "glass.workspace.suspend",
3399 "glass.workspace.resume",
3400 "glass.workspace.delete",
3401 "glass.daemon.start",
3402 "glass.daemon.stop",
3403 "glass.daemon.status",
3404 "glass.daemon.doctor",
3405 "glass.daemon.logs",
3406 "glass.workspace.trust.status",
3407 "glass.workspace.trust.inspect",
3408 "glass.project.attach",
3409 "glass.agent.setup",
3410 ];
3411
3412 #[test]
3413 fn pi_named_catalog_covers_agent_visible_glass_tools() {
3414 let tools = include_str!("../assets/pi-glass-tools.ts");
3415 let prompt = include_str!("../assets/pi-glass-system.md");
3416 let runtime = include_str!("../assets/pi-runtime.mjs");
3417 for required in [
3418 "glass.browser.verify",
3419 "glass.editor.fim",
3420 "glass.editor.proposal.accept_pack",
3421 "glass.task.crew",
3422 "glass.github.ship",
3423 "glass.file.search",
3424 "glass.lsp.inlay_hints",
3425 ] {
3426 assert!(
3427 tools.contains(&format!("\"{required}\"")),
3428 "Pi named catalog missing {required}"
3429 );
3430 assert!(
3431 prompt.contains(required),
3432 "system prompt missing {required}"
3433 );
3434 }
3435 assert!(runtime.contains("glass.browser.verify"));
3436 assert!(runtime.contains("glass.task.crew"));
3437 let registered = registered_glass_names(tools);
3438 for descriptor in service_descriptors() {
3439 if AGENT_HIDDEN_TOOLS.contains(&descriptor.name.as_str()) {
3440 continue;
3441 }
3442 assert!(
3443 registered.contains(&descriptor.name),
3444 "Pi named catalog missing agent-visible {}",
3445 descriptor.name
3446 );
3447 }
3448 }
3449
3450 fn registered_glass_names(source: &str) -> std::collections::BTreeSet<String> {
3451 let mut names = std::collections::BTreeSet::new();
3452 let mut rest = source;
3453 while let Some(start) = rest.find("register(") {
3454 rest = &rest[start + 9..];
3455 let Some(first) = quoted_string(rest) else {
3456 continue;
3457 };
3458 let after_first = rest
3459 .find(&format!("\"{first}\""))
3460 .map(|index| index + first.len() + 2)
3461 .unwrap_or(0);
3462 let Some(glass) = quoted_string(&rest[after_first..]) else {
3463 continue;
3464 };
3465 if glass.starts_with("glass.") {
3466 names.insert(glass);
3467 }
3468 }
3469 names
3470 }
3471
3472 fn quoted_string(source: &str) -> Option<String> {
3473 let start = source.find('"')?;
3474 let rest = &source[start + 1..];
3475 let end = rest.find('"')?;
3476 Some(rest[..end].to_string())
3477 }
3478}