1use glass_browser::development::{
4 DevelopmentError, DevelopmentResult, HarnessRequest, PiHarness, PiHarnessOptions,
5};
6use serde::{Deserialize, Serialize};
7use serde_json::Value;
8use std::collections::{BTreeMap, BTreeSet, VecDeque};
9use std::path::{Path, PathBuf};
10use std::sync::mpsc::{self, Receiver, SyncSender, TryRecvError, TrySendError};
11use std::thread;
12use std::time::{Duration, SystemTime, UNIX_EPOCH};
13
14const COMMAND_CAPACITY: usize = 32;
15const EVENT_CAPACITY: usize = 256;
16const HISTORY_CAPACITY: usize = 512;
17const AGENT_EVIDENCE_CAPACITY: usize = 64;
18const MAX_AGENTS: usize = 32;
19const MAX_PROMPT_BYTES: usize = 64 * 1024;
20
21#[derive(Debug, Clone)]
22pub struct ResidentAgentBroker {
23 pub socket: PathBuf,
24 pub token: String,
25 pub workspace_id: String,
26}
27
28#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
29pub struct AgentId(String);
30
31impl AgentId {
32 pub fn as_str(&self) -> &str {
33 &self.0
34 }
35}
36
37#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
38#[serde(rename_all = "camelCase")]
39pub enum AgentStatus {
40 Queued,
41 Starting,
42 Idle,
43 Working,
44 Waiting,
45 Completed,
46 Failed,
47 Cancelled,
48}
49
50impl AgentStatus {
51 fn terminal(self) -> bool {
52 matches!(self, Self::Completed | Self::Failed | Self::Cancelled)
53 }
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
57#[serde(rename_all = "camelCase")]
58pub struct AgentSpec {
59 pub role: String,
60 pub task: String,
61 #[serde(default)]
62 pub dependencies: Vec<AgentId>,
63 pub model: Option<String>,
64 pub thinking: Option<String>,
65 pub worktree: Option<PathBuf>,
66 #[serde(default)]
67 pub unrestricted: bool,
68 pub max_runtime_seconds: Option<u64>,
69 pub max_events: Option<u64>,
70}
71
72impl AgentSpec {
73 pub fn new(role: impl Into<String>, task: impl Into<String>) -> Self {
74 Self {
75 role: role.into(),
76 task: task.into(),
77 dependencies: Vec::new(),
78 model: None,
79 thinking: None,
80 worktree: None,
81 unrestricted: false,
82 max_runtime_seconds: Some(3_600),
83 max_events: Some(10_000),
84 }
85 }
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize)]
89#[serde(rename_all = "camelCase")]
90pub struct AgentSnapshot {
91 pub id: AgentId,
92 pub role: String,
93 pub task: String,
94 pub status: AgentStatus,
95 pub dependencies: Vec<AgentId>,
96 pub model: Option<String>,
97 pub thinking: Option<String>,
98 pub worktree: PathBuf,
99 pub unrestricted: bool,
100 pub created_at_ms: u128,
101 pub started_at_ms: Option<u128>,
102 pub updated_at_ms: u128,
103 pub event_count: u64,
104 pub last_error: Option<String>,
105 pub last_response_id: Option<String>,
106 pub evidence: Vec<Value>,
107}
108
109#[derive(Debug, Clone, Serialize, Deserialize)]
110#[serde(rename_all = "camelCase")]
111pub struct AgentEvent {
112 pub sequence: u64,
113 pub agent_id: AgentId,
114 pub timestamp_ms: u128,
115 pub kind: String,
116 pub payload: Value,
117}
118
119#[derive(Debug)]
120enum WorkerCommand {
121 Request(HarnessRequest),
122 Shutdown,
123}
124
125#[derive(Debug)]
126enum WorkerEvent {
127 Ready(AgentId),
128 RequestStarted(AgentId, String, bool),
129 Pi(AgentId, Value),
130 Failed(AgentId, String),
131 Stopped(AgentId),
132}
133
134struct AgentRecord {
135 snapshot: AgentSnapshot,
136 spec: AgentSpec,
137 command: Option<SyncSender<WorkerCommand>>,
138 awaiting_agent_settle: bool,
139}
140
141struct WorkerRuntime {
142 worktree: PathBuf,
143 sessions_dir: PathBuf,
144 broker: Option<ResidentAgentBroker>,
145 additional_system_prompt: Option<String>,
146}
147
148pub struct AgentRegistry {
154 root: PathBuf,
155 sessions_dir: PathBuf,
156 records: BTreeMap<AgentId, AgentRecord>,
157 events_tx: SyncSender<WorkerEvent>,
158 events_rx: Receiver<WorkerEvent>,
159 history: VecDeque<AgentEvent>,
160 next_agent: u64,
161 next_event: u64,
162 broker: Option<ResidentAgentBroker>,
163 additional_system_prompt: Option<String>,
164 default_model: Option<String>,
165 default_thinking: Option<String>,
166}
167
168impl AgentRegistry {
169 pub fn new(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
170 let root = std::fs::canonicalize(root)?;
171 let sessions_dir = root.join(".glass").join("pi-sessions");
172 let (events_tx, events_rx) = mpsc::sync_channel(EVENT_CAPACITY);
173 Ok(Self {
174 root,
175 sessions_dir,
176 records: BTreeMap::new(),
177 events_tx,
178 events_rx,
179 history: VecDeque::new(),
180 next_agent: 1,
181 next_event: 1,
182 broker: None,
183 additional_system_prompt: None,
184 default_model: None,
185 default_thinking: None,
186 })
187 }
188
189 pub fn set_resident_broker(&mut self, broker: ResidentAgentBroker) -> DevelopmentResult<()> {
190 if !broker.socket.is_absolute()
191 || broker.socket == Path::new("/")
192 || broker.token.is_empty()
193 || broker.token.len() > 256
194 || broker.workspace_id.is_empty()
195 || broker.workspace_id.len() > 128
196 || broker
197 .workspace_id
198 .chars()
199 .any(|character| character.is_control())
200 {
201 return Err(DevelopmentError::InvalidInput(
202 "invalid resident agent broker context".into(),
203 ));
204 }
205 self.broker = Some(broker);
206 Ok(())
207 }
208
209 pub fn set_additional_system_prompt(
210 &mut self,
211 prompt: Option<String>,
212 ) -> DevelopmentResult<()> {
213 if prompt
214 .as_ref()
215 .is_some_and(|prompt| prompt.len() > 128 * 1024 || prompt.contains('\0'))
216 {
217 return Err(DevelopmentError::InvalidInput(
218 "agent project instructions exceed 128 KiB or contain NUL".into(),
219 ));
220 }
221 self.additional_system_prompt = prompt;
222 Ok(())
223 }
224
225 pub fn set_defaults(
226 &mut self,
227 model: Option<String>,
228 thinking: Option<String>,
229 ) -> DevelopmentResult<()> {
230 for (label, value) in [("model", &model), ("thinking", &thinking)] {
231 if value
232 .as_ref()
233 .is_some_and(|value| value.is_empty() || value.len() > 256 || value.contains('\0'))
234 {
235 return Err(DevelopmentError::InvalidInput(format!(
236 "default agent {label} must contain 1..=256 bytes without NUL"
237 )));
238 }
239 }
240 self.default_model = model;
241 self.default_thinking = thinking;
242 Ok(())
243 }
244
245 pub fn create(&mut self, mut spec: AgentSpec) -> DevelopmentResult<AgentId> {
246 self.refresh()?;
247 if spec.model.is_none() {
248 spec.model.clone_from(&self.default_model);
249 }
250 if spec.thinking.is_none() {
251 spec.thinking.clone_from(&self.default_thinking);
252 }
253 validate_spec(&self.root, &self.records, &spec)?;
254 if self.records.len() >= MAX_AGENTS {
255 return Err(DevelopmentError::Conflict(format!(
256 "agent registry reached its {MAX_AGENTS} session limit"
257 )));
258 }
259 let id = AgentId(format!("agent-{:04}", self.next_agent));
260 self.next_agent = self
261 .next_agent
262 .checked_add(1)
263 .ok_or_else(|| DevelopmentError::Conflict("agent identifier space exhausted".into()))?;
264 let now = now_ms();
265 let worktree = spec.worktree.clone().unwrap_or_else(|| self.root.clone());
266 let status = if spec.dependencies.is_empty() {
267 AgentStatus::Starting
268 } else {
269 AgentStatus::Queued
270 };
271 self.records.insert(
272 id.clone(),
273 AgentRecord {
274 snapshot: AgentSnapshot {
275 id: id.clone(),
276 role: spec.role.clone(),
277 task: spec.task.clone(),
278 status,
279 dependencies: spec.dependencies.clone(),
280 model: spec.model.clone(),
281 thinking: spec.thinking.clone(),
282 worktree,
283 unrestricted: spec.unrestricted,
284 created_at_ms: now,
285 started_at_ms: None,
286 updated_at_ms: now,
287 event_count: 0,
288 last_error: None,
289 last_response_id: None,
290 evidence: Vec::new(),
291 },
292 spec,
293 command: None,
294 awaiting_agent_settle: false,
295 },
296 );
297 if status == AgentStatus::Starting {
298 self.spawn(&id)?;
299 }
300 Ok(id)
301 }
302
303 pub fn refresh(&mut self) -> DevelopmentResult<()> {
304 loop {
305 match self.events_rx.try_recv() {
306 Ok(event) => self.apply_worker_event(event),
307 Err(TryRecvError::Empty) => break,
308 Err(TryRecvError::Disconnected) => {
309 return Err(DevelopmentError::Process(
310 "agent scheduler event channel closed".into(),
311 ));
312 }
313 }
314 }
315 self.enforce_budgets();
316 self.fail_blocked_dependents();
317 self.start_ready_agents()?;
318 Ok(())
319 }
320
321 pub fn snapshot(&mut self, id: &AgentId) -> DevelopmentResult<AgentSnapshot> {
322 self.refresh()?;
323 self.records
324 .get(id)
325 .map(|record| record.snapshot.clone())
326 .ok_or_else(|| DevelopmentError::NotFound(format!("agent {}", id.as_str())))
327 }
328
329 pub fn list(&mut self) -> DevelopmentResult<Vec<AgentSnapshot>> {
330 self.refresh()?;
331 Ok(self
332 .records
333 .values()
334 .map(|record| record.snapshot.clone())
335 .collect())
336 }
337
338 pub fn history(&mut self, since: u64) -> DevelopmentResult<Vec<AgentEvent>> {
339 self.refresh()?;
340 Ok(self
341 .history
342 .iter()
343 .filter(|event| event.sequence > since)
344 .cloned()
345 .collect())
346 }
347
348 pub fn prompt(&mut self, id: &AgentId, text: impl Into<String>) -> DevelopmentResult<()> {
349 let text = text.into();
350 validate_text("agent prompt", &text, MAX_PROMPT_BYTES)?;
351 self.send(id, HarnessRequest::Prompt { text })
352 }
353
354 pub fn steer(&mut self, id: &AgentId, text: impl Into<String>) -> DevelopmentResult<()> {
355 let text = text.into();
356 validate_text("agent steering", &text, MAX_PROMPT_BYTES)?;
357 self.send(id, HarnessRequest::Steer { text })
358 }
359
360 pub fn follow_up(&mut self, id: &AgentId, text: impl Into<String>) -> DevelopmentResult<()> {
361 let text = text.into();
362 validate_text("agent follow-up", &text, MAX_PROMPT_BYTES)?;
363 self.send(id, HarnessRequest::FollowUp { text })
364 }
365
366 pub fn request(&mut self, id: &AgentId, request: HarnessRequest) -> DevelopmentResult<()> {
367 self.send(id, request)
368 }
369
370 pub fn complete(&mut self, id: &AgentId) -> DevelopmentResult<()> {
371 self.refresh()?;
372 let record = self.record_mut(id)?;
373 if record.snapshot.status.terminal() {
374 return Err(DevelopmentError::Conflict(format!(
375 "agent {} is already terminal",
376 id.as_str()
377 )));
378 }
379 record.snapshot.status = AgentStatus::Completed;
380 record.snapshot.updated_at_ms = now_ms();
381 if let Some(sender) = record.command.take() {
382 let _ = sender.try_send(WorkerCommand::Shutdown);
383 }
384 self.record_event(id, "completed", Value::Null);
385 self.start_ready_agents()?;
386 Ok(())
387 }
388
389 pub fn cancel(&mut self, id: &AgentId) -> DevelopmentResult<()> {
390 self.refresh()?;
391 let record = self.record_mut(id)?;
392 if record.snapshot.status.terminal() {
393 return Ok(());
394 }
395 if let Some(sender) = &record.command {
396 let _ = sender.try_send(WorkerCommand::Request(HarnessRequest::Abort));
397 let _ = sender.try_send(WorkerCommand::Shutdown);
398 }
399 record.command = None;
400 record.snapshot.status = AgentStatus::Cancelled;
401 record.snapshot.updated_at_ms = now_ms();
402 self.record_event(id, "cancelled", Value::Null);
403 self.fail_blocked_dependents();
404 Ok(())
405 }
406
407 fn send(&mut self, id: &AgentId, request: HarnessRequest) -> DevelopmentResult<()> {
408 self.refresh()?;
409 let record = self.record_mut(id)?;
410 if record.snapshot.status.terminal() || record.snapshot.status == AgentStatus::Queued {
411 return Err(DevelopmentError::Conflict(format!(
412 "agent {} cannot accept requests while {:?}",
413 id.as_str(),
414 record.snapshot.status
415 )));
416 }
417 let sender = record.command.as_ref().ok_or_else(|| {
418 DevelopmentError::Conflict(format!("agent {} is still starting", id.as_str()))
419 })?;
420 sender
421 .try_send(WorkerCommand::Request(request))
422 .map_err(|error| match error {
423 TrySendError::Full(_) => DevelopmentError::Conflict(format!(
424 "agent {} command queue is full",
425 id.as_str()
426 )),
427 TrySendError::Disconnected(_) => DevelopmentError::Process(format!(
428 "agent {} command channel closed",
429 id.as_str()
430 )),
431 })?;
432 Ok(())
433 }
434
435 fn spawn(&mut self, id: &AgentId) -> DevelopmentResult<()> {
436 let sessions_dir = self.sessions_dir.clone();
437 let events = self.events_tx.clone();
438 let broker = self.broker.clone();
439 let additional_system_prompt = self.additional_system_prompt.clone();
440 let record = self.record_mut(id)?;
441 let spec = record.spec.clone();
442 let worktree = record.snapshot.worktree.clone();
443 let worker_id = id.clone();
444 let (commands_tx, commands_rx) = mpsc::sync_channel(COMMAND_CAPACITY);
445 record.command = Some(commands_tx);
446 record.snapshot.status = AgentStatus::Starting;
447 record.snapshot.started_at_ms = Some(now_ms());
448 record.snapshot.updated_at_ms = now_ms();
449 thread::Builder::new()
450 .name(format!("glass-{}", id.as_str()))
451 .spawn(move || {
452 run_worker(
453 worker_id,
454 spec,
455 WorkerRuntime {
456 worktree,
457 sessions_dir,
458 broker,
459 additional_system_prompt,
460 },
461 commands_rx,
462 events,
463 )
464 })
465 .map_err(DevelopmentError::Io)?;
466 self.record_event(id, "starting", Value::Null);
467 Ok(())
468 }
469
470 fn start_ready_agents(&mut self) -> DevelopmentResult<()> {
471 let ready: Vec<_> = self
472 .records
473 .iter()
474 .filter(|(_, record)| record.snapshot.status == AgentStatus::Queued)
475 .filter(|(_, record)| {
476 record.spec.dependencies.iter().all(|dependency| {
477 self.records.get(dependency).is_some_and(|dependency| {
478 dependency.snapshot.status == AgentStatus::Completed
479 })
480 })
481 })
482 .map(|(id, _)| id.clone())
483 .collect();
484 for id in ready {
485 self.spawn(&id)?;
486 }
487 Ok(())
488 }
489
490 fn fail_blocked_dependents(&mut self) {
491 let terminal_failures: BTreeSet<_> = self
492 .records
493 .iter()
494 .filter(|(_, record)| {
495 matches!(
496 record.snapshot.status,
497 AgentStatus::Failed | AgentStatus::Cancelled
498 )
499 })
500 .map(|(id, _)| id.clone())
501 .collect();
502 let blocked: Vec<_> = self
503 .records
504 .iter()
505 .filter(|(_, record)| record.snapshot.status == AgentStatus::Queued)
506 .filter(|(_, record)| {
507 record
508 .spec
509 .dependencies
510 .iter()
511 .any(|dependency| terminal_failures.contains(dependency))
512 })
513 .map(|(id, _)| id.clone())
514 .collect();
515 for id in blocked {
516 if let Some(record) = self.records.get_mut(&id) {
517 record.snapshot.status = AgentStatus::Failed;
518 record.snapshot.last_error = Some("a required agent did not complete".into());
519 record.snapshot.updated_at_ms = now_ms();
520 }
521 self.record_event(
522 &id,
523 "dependencyFailed",
524 Value::String("a required agent did not complete".into()),
525 );
526 }
527 }
528
529 fn enforce_budgets(&mut self) {
530 let now = now_ms();
531 let exceeded: Vec<_> = self
532 .records
533 .iter()
534 .filter(|(_, record)| !record.snapshot.status.terminal())
535 .filter(|(_, record)| {
536 record
537 .spec
538 .max_runtime_seconds
539 .zip(record.snapshot.started_at_ms)
540 .is_some_and(|(seconds, started)| {
541 now.saturating_sub(started) > u128::from(seconds) * 1_000
542 })
543 || record
544 .spec
545 .max_events
546 .is_some_and(|limit| record.snapshot.event_count >= limit)
547 })
548 .map(|(id, _)| id.clone())
549 .collect();
550 for id in exceeded {
551 if let Some(record) = self.records.get_mut(&id) {
552 if let Some(sender) = record.command.take() {
553 let _ = sender.try_send(WorkerCommand::Request(HarnessRequest::Abort));
554 let _ = sender.try_send(WorkerCommand::Shutdown);
555 }
556 record.snapshot.status = AgentStatus::Failed;
557 record.snapshot.last_error = Some("agent budget exceeded".into());
558 record.snapshot.updated_at_ms = now;
559 }
560 self.record_event(&id, "budgetExceeded", Value::Null);
561 }
562 }
563
564 fn apply_worker_event(&mut self, event: WorkerEvent) {
565 match event {
566 WorkerEvent::Ready(id) => {
567 if let Some(record) = self.records.get_mut(&id)
568 && !record.snapshot.status.terminal()
569 {
570 record.snapshot.status = AgentStatus::Idle;
571 record.snapshot.updated_at_ms = now_ms();
572 }
573 self.record_event(&id, "ready", Value::Null);
574 }
575 WorkerEvent::RequestStarted(id, request_id, waits_for_agent) => {
576 if let Some(record) = self.records.get_mut(&id)
577 && !record.snapshot.status.terminal()
578 {
579 record.snapshot.last_response_id = Some(request_id.clone());
580 record.snapshot.status = AgentStatus::Working;
581 record.awaiting_agent_settle |= waits_for_agent;
582 record.snapshot.updated_at_ms = now_ms();
583 }
584 self.record_event(&id, "requestStarted", Value::String(request_id));
585 }
586 WorkerEvent::Pi(id, value) => {
587 if let Some(record) = self.records.get_mut(&id) {
588 let event_type = value.get("type").and_then(Value::as_str);
589 if event_type == Some("agent_settled") && !record.snapshot.status.terminal() {
590 record.awaiting_agent_settle = false;
591 record.snapshot.status = AgentStatus::Idle;
592 }
593 if event_type == Some("response")
594 && !record.awaiting_agent_settle
595 && !record.snapshot.status.terminal()
596 {
597 record.snapshot.status = AgentStatus::Idle;
598 }
599 record.snapshot.event_count = record.snapshot.event_count.saturating_add(1);
600 record.snapshot.updated_at_ms = now_ms();
601 if record.snapshot.evidence.len() == AGENT_EVIDENCE_CAPACITY {
602 record.snapshot.evidence.remove(0);
603 }
604 record.snapshot.evidence.push(value.clone());
605 }
606 let kind = value
607 .get("type")
608 .and_then(Value::as_str)
609 .unwrap_or("piEvent")
610 .to_string();
611 self.record_event(&id, &kind, value);
612 }
613 WorkerEvent::Failed(id, error) => {
614 if let Some(record) = self.records.get_mut(&id)
615 && !record.snapshot.status.terminal()
616 {
617 record.snapshot.status = AgentStatus::Failed;
618 record.snapshot.last_error = Some(error.clone());
619 record.snapshot.updated_at_ms = now_ms();
620 record.command = None;
621 }
622 self.record_event(&id, "failed", Value::String(error));
623 }
624 WorkerEvent::Stopped(id) => {
625 if let Some(record) = self.records.get_mut(&id) {
626 record.command = None;
627 }
628 self.record_event(&id, "stopped", Value::Null);
629 }
630 }
631 }
632
633 fn record_event(&mut self, id: &AgentId, kind: &str, payload: Value) {
634 if self.history.len() == HISTORY_CAPACITY {
635 self.history.pop_front();
636 }
637 self.history.push_back(AgentEvent {
638 sequence: self.next_event,
639 agent_id: id.clone(),
640 timestamp_ms: now_ms(),
641 kind: kind.into(),
642 payload,
643 });
644 self.next_event = self.next_event.saturating_add(1);
645 }
646
647 fn record_mut(&mut self, id: &AgentId) -> DevelopmentResult<&mut AgentRecord> {
648 self.records
649 .get_mut(id)
650 .ok_or_else(|| DevelopmentError::NotFound(format!("agent {}", id.as_str())))
651 }
652}
653
654impl Drop for AgentRegistry {
655 fn drop(&mut self) {
656 for record in self.records.values_mut() {
657 if let Some(sender) = record.command.take() {
658 let _ = sender.try_send(WorkerCommand::Shutdown);
659 }
660 }
661 }
662}
663
664fn run_worker(
665 id: AgentId,
666 spec: AgentSpec,
667 runtime: WorkerRuntime,
668 commands: Receiver<WorkerCommand>,
669 events: SyncSender<WorkerEvent>,
670) {
671 let options = PiHarnessOptions {
672 unrestricted: spec.unrestricted,
673 persist_session: true,
674 session_dir: Some(runtime.sessions_dir),
675 name: Some(format!("{}: {}", spec.role, id.as_str())),
676 model: spec.model,
677 thinking: spec.thinking,
678 broker_socket: runtime.broker.as_ref().map(|broker| broker.socket.clone()),
679 broker_token: runtime.broker.as_ref().map(|broker| broker.token.clone()),
680 broker_workspace_id: runtime.broker.map(|broker| broker.workspace_id),
681 additional_system_prompt: runtime.additional_system_prompt,
682 ..PiHarnessOptions::default()
683 };
684 let mut harness = match PiHarness::spawn_with_options(&runtime.worktree, options) {
685 Ok(harness) => harness,
686 Err(error) => {
687 send_critical_worker_event(&events, WorkerEvent::Failed(id, error.to_string()));
688 return;
689 }
690 };
691 send_critical_worker_event(&events, WorkerEvent::Ready(id.clone()));
692 loop {
693 loop {
694 match commands.try_recv() {
695 Ok(WorkerCommand::Request(request)) => {
696 let waits_for_agent = matches!(
697 request,
698 HarnessRequest::Prompt { .. } | HarnessRequest::FollowUp { .. }
699 );
700 match harness.start_request(request) {
701 Ok(request_id) => send_critical_worker_event(
702 &events,
703 WorkerEvent::RequestStarted(id.clone(), request_id, waits_for_agent),
704 ),
705 Err(error) => {
706 send_critical_worker_event(
707 &events,
708 WorkerEvent::Failed(id.clone(), error.to_string()),
709 );
710 return;
711 }
712 }
713 }
714 Ok(WorkerCommand::Shutdown) | Err(TryRecvError::Disconnected) => {
715 send_critical_worker_event(&events, WorkerEvent::Stopped(id));
716 return;
717 }
718 Err(TryRecvError::Empty) => break,
719 }
720 }
721 match harness.recv_event_timeout(Duration::from_millis(25)) {
722 Ok(Some(value)) => send_lossy_worker_event(&events, WorkerEvent::Pi(id.clone(), value)),
723 Ok(None) => {}
724 Err(error) => {
725 send_critical_worker_event(&events, WorkerEvent::Failed(id, error.to_string()));
726 return;
727 }
728 }
729 }
730}
731
732fn send_lossy_worker_event(events: &SyncSender<WorkerEvent>, event: WorkerEvent) {
733 let _ = events.try_send(event);
734}
735
736fn send_critical_worker_event(events: &SyncSender<WorkerEvent>, event: WorkerEvent) {
737 let _ = events.send(event);
738}
739
740fn validate_spec(
741 root: &Path,
742 records: &BTreeMap<AgentId, AgentRecord>,
743 spec: &AgentSpec,
744) -> DevelopmentResult<()> {
745 validate_text("agent role", &spec.role, 128)?;
746 validate_text("agent task", &spec.task, MAX_PROMPT_BYTES)?;
747 if spec.dependencies.len() > MAX_AGENTS {
748 return Err(DevelopmentError::InvalidInput(
749 "agent dependency list is too large".into(),
750 ));
751 }
752 let mut unique = BTreeSet::new();
753 for dependency in &spec.dependencies {
754 if !unique.insert(dependency) {
755 return Err(DevelopmentError::InvalidInput(format!(
756 "duplicate dependency {}",
757 dependency.as_str()
758 )));
759 }
760 if !records.contains_key(dependency) {
761 return Err(DevelopmentError::NotFound(format!(
762 "dependency agent {}",
763 dependency.as_str()
764 )));
765 }
766 }
767 if let Some(worktree) = &spec.worktree {
768 let worktree = std::fs::canonicalize(worktree)?;
769 if worktree == Path::new("/")
770 || (!worktree.starts_with(root) && !worktree.join(".git").exists())
771 {
772 return Err(DevelopmentError::PathOutsideWorkspace(worktree));
773 }
774 }
775 if spec.max_runtime_seconds == Some(0) || spec.max_events == Some(0) {
776 return Err(DevelopmentError::InvalidInput(
777 "agent budgets must be greater than zero".into(),
778 ));
779 }
780 Ok(())
781}
782
783fn validate_text(description: &str, text: &str, limit: usize) -> DevelopmentResult<()> {
784 if text.trim().is_empty() || text.len() > limit || text.contains('\0') {
785 return Err(DevelopmentError::InvalidInput(format!(
786 "{description} must contain 1..={limit} bytes without NUL"
787 )));
788 }
789 Ok(())
790}
791
792fn now_ms() -> u128 {
793 SystemTime::now()
794 .duration_since(UNIX_EPOCH)
795 .unwrap_or_default()
796 .as_millis()
797}
798
799#[cfg(test)]
800mod tests {
801 use super::*;
802 use std::sync::atomic::{AtomicU64, Ordering};
803
804 static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
805
806 fn test_root() -> PathBuf {
807 let sequence = NEXT_ROOT.fetch_add(1, Ordering::Relaxed);
808 let root = std::env::temp_dir().join(format!(
809 "glass-agent-registry-{}-{sequence}",
810 std::process::id()
811 ));
812 std::fs::create_dir_all(&root).unwrap();
813 root
814 }
815
816 fn wait_for_status(
817 registry: &mut AgentRegistry,
818 id: &AgentId,
819 expected: AgentStatus,
820 ) -> AgentSnapshot {
821 for _ in 0..200 {
822 let snapshot = registry.snapshot(id).unwrap();
823 if snapshot.status == expected {
824 return snapshot;
825 }
826 if snapshot.status == AgentStatus::Failed {
827 panic!("agent failed: {:?}", snapshot.last_error);
828 }
829 thread::sleep(Duration::from_millis(25));
830 }
831 panic!("agent did not reach {expected:?}");
832 }
833
834 #[test]
835 fn independent_pi_sessions_schedule_dependencies_and_stream_state() {
836 if std::process::Command::new("pi")
837 .arg("--version")
838 .output()
839 .is_err()
840 {
841 return;
842 }
843 let root = test_root();
844 let mut registry = AgentRegistry::new(&root).unwrap();
845 let first = registry
846 .create(AgentSpec::new("implementer", "inspect state"))
847 .unwrap();
848 let peer = registry
849 .create(AgentSpec::new("researcher", "inspect independent state"))
850 .unwrap();
851 wait_for_status(&mut registry, &first, AgentStatus::Idle);
852 wait_for_status(&mut registry, &peer, AgentStatus::Idle);
853 registry.request(&first, HarnessRequest::State).unwrap();
854 registry.request(&peer, HarnessRequest::State).unwrap();
855 for _ in 0..200 {
856 let snapshot = registry.snapshot(&first).unwrap();
857 if snapshot
858 .evidence
859 .iter()
860 .any(|event| event.get("type").and_then(Value::as_str) == Some("response"))
861 {
862 break;
863 }
864 thread::sleep(Duration::from_millis(25));
865 }
866 assert!(registry.snapshot(&first).unwrap().event_count > 0);
867 for _ in 0..200 {
868 if registry.snapshot(&peer).unwrap().event_count > 0 {
869 break;
870 }
871 thread::sleep(Duration::from_millis(25));
872 }
873 assert!(registry.snapshot(&peer).unwrap().event_count > 0);
874
875 let mut dependent = AgentSpec::new("reviewer", "review evidence");
876 dependent.dependencies.push(first.clone());
877 let second = registry.create(dependent).unwrap();
878 assert_eq!(
879 registry.snapshot(&second).unwrap().status,
880 AgentStatus::Queued
881 );
882 registry.complete(&first).unwrap();
883 wait_for_status(&mut registry, &second, AgentStatus::Idle);
884 assert_ne!(first, second);
885 registry.cancel(&second).unwrap();
886 registry.cancel(&peer).unwrap();
887 assert_eq!(
888 registry.snapshot(&second).unwrap().status,
889 AgentStatus::Cancelled
890 );
891 drop(registry);
892 std::fs::remove_dir_all(root).unwrap();
893 }
894
895 #[test]
896 fn invalid_agent_specs_and_failed_dependencies_fail_closed() {
897 let root = test_root();
898 let mut registry = AgentRegistry::new(&root).unwrap();
899 assert!(registry.create(AgentSpec::new("", "task")).is_err());
900 let first = registry.create(AgentSpec::new("lead", "task")).unwrap();
901 let mut dependent = AgentSpec::new("review", "task");
902 dependent.dependencies.push(first.clone());
903 let second = registry.create(dependent).unwrap();
904 registry.cancel(&first).unwrap();
905 assert_eq!(
906 registry.snapshot(&second).unwrap().status,
907 AgentStatus::Failed
908 );
909 drop(registry);
910 std::fs::remove_dir_all(root).unwrap();
911 }
912}