Skip to main content

glass_dev/
tools.rs

1//! Governed tool routing into one resident development workspace.
2
3use 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/// Routes Glass Agent operations through authoritative resident services.
35#[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}