Skip to main content

glass_dev/
agents.rs

1//! Glass-owned scheduling for independent resident Pi agent sessions.
2
3use 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
162/// Registry and scheduler for independent Pi subprocesses.
163///
164/// Each running agent owns a distinct Pi process and persistent session. The
165/// registry only starts dependency-ready work, bounds all queues and retained
166/// evidence, and never silently promotes a failed dependency to success.
167pub 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    /// Active user-global and trusted-project instructions supplied to Pi.
240    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}