Skip to main content

glass_dev/
agents.rs

1//! Glass-owned scheduling for independent resident Pi agent sessions.
2
3use 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
148/// Registry and scheduler for independent Pi subprocesses.
149///
150/// Each running agent owns a distinct Pi process and persistent session. The
151/// registry only starts dependency-ready work, bounds all queues and retained
152/// evidence, and never silently promotes a failed dependency to success.
153pub 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}