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