1use crate::agents::{AgentEvent, AgentId, AgentRegistry, AgentSnapshot, AgentSpec, AgentStatus};
4use crate::development::{DevelopmentError, DevelopmentResult};
5use serde::{Deserialize, Serialize};
6use serde_json::Value;
7use std::collections::{BTreeMap, BTreeSet};
8use std::path::{Path, PathBuf};
9use std::process::{Command, Stdio};
10use std::thread;
11use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
12
13const MAX_TASKS: usize = 128;
14const MAX_DEPENDENCIES: usize = 32;
15const MAX_TASK_EVIDENCE: usize = 128;
16const MAX_TASK_TEXT_BYTES: usize = 128 * 1024;
17const MAX_VERIFIER_COMMAND_BYTES: usize = 16 * 1024;
18
19#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
20pub struct TaskId(String);
21
22impl TaskId {
23 pub fn as_str(&self) -> &str {
24 &self.0
25 }
26
27 pub fn parse(value: impl Into<String>) -> DevelopmentResult<Self> {
28 let value = value.into();
29 if !value.starts_with("task-")
30 || value.len() > 64
31 || value.chars().any(|character| character.is_control())
32 {
33 return Err(DevelopmentError::InvalidInput("invalid task id".into()));
34 }
35 Ok(Self(value))
36 }
37}
38
39#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
40#[serde(rename_all = "camelCase")]
41pub enum TaskState {
42 Queued,
43 Ready,
44 Running,
45 Waiting,
46 Verifying,
47 Succeeded,
48 Failed,
49 Cancelled,
50 Paused,
51 Blocked,
52}
53
54impl TaskState {
55 pub fn label(&self) -> &'static str {
57 match self {
58 Self::Queued => "queued",
59 Self::Ready => "ready",
60 Self::Running => "running",
61 Self::Waiting => "waiting",
62 Self::Verifying => "verifying",
63 Self::Succeeded => "succeeded",
64 Self::Failed => "failed",
65 Self::Cancelled => "cancelled",
66 Self::Paused => "paused",
67 Self::Blocked => "blocked",
68 }
69 }
70}
71
72impl TaskState {
73 fn terminal(self) -> bool {
74 matches!(self, Self::Succeeded | Self::Failed | Self::Cancelled)
75 }
76}
77
78#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
79#[serde(rename_all = "camelCase")]
80pub struct TaskBudget {
81 pub max_runtime_seconds: u64,
82 pub max_events: u64,
83 pub max_tokens: Option<u64>,
84}
85
86impl Default for TaskBudget {
87 fn default() -> Self {
88 Self {
89 max_runtime_seconds: 3_600,
90 max_events: 10_000,
91 max_tokens: None,
92 }
93 }
94}
95
96#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
97#[serde(rename_all = "camelCase")]
98pub struct RetryPolicy {
99 pub max_retries: u32,
100 pub backoff_seconds: u64,
101}
102
103impl Default for RetryPolicy {
104 fn default() -> Self {
105 Self {
106 max_retries: 0,
107 backoff_seconds: 1,
108 }
109 }
110}
111
112#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
113#[serde(tag = "kind", rename_all = "camelCase")]
114pub enum VerificationRequirement {
115 #[default]
117 Inferred,
118 Settled,
120 Command {
121 command: String,
122 expected_exit: i32,
123 timeout_seconds: u64,
124 },
125 LspDiagnostics {
126 max_errors: u64,
127 },
128 BrowserWorkflow {
129 assertion: String,
130 },
131 SemanticRegression {
132 baseline: String,
133 maximum_regressions: u64,
134 },
135 DebuggerAssertion {
136 session: String,
137 expression: String,
138 },
139 GitChange {
140 require_changes: bool,
141 require_clean: bool,
142 },
143 TrustedCustom {
144 name: String,
145 },
146 All {
147 requirements: Vec<VerificationRequirement>,
148 },
149}
150
151#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
152#[serde(rename_all = "camelCase")]
153pub struct TaskEvidence {
154 pub kind: String,
155 pub actor: String,
156 pub source: String,
157 pub passed: Option<bool>,
158 pub observed_at_ms: u128,
159 pub details: Value,
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize)]
163#[serde(rename_all = "camelCase")]
164pub struct TaskSpec {
165 pub title: String,
166 pub goal: String,
167 pub prompt: String,
168 #[serde(default = "default_role")]
169 pub role: String,
170 #[serde(default)]
171 pub dependencies: Vec<TaskId>,
172 pub worktree: Option<PathBuf>,
173 pub model: Option<String>,
174 pub thinking: Option<String>,
175 #[serde(default)]
176 pub unrestricted: bool,
177 #[serde(default)]
178 pub budget: TaskBudget,
179 #[serde(default)]
180 pub verification: VerificationRequirement,
181 #[serde(default)]
182 pub retry: RetryPolicy,
183}
184
185fn default_role() -> String {
186 "developer".into()
187}
188
189fn crew_spec(role: &str, title: impl Into<String>, goal: &str, prompt: String) -> TaskSpec {
190 let mut spec = TaskSpec::new(title, prompt);
191 spec.role = role.to_string();
192 spec.goal = goal.to_string();
193 spec
194}
195
196fn crew_prompt(role: &str, goal: &str) -> String {
197 match role {
198 "architect" => format!(
199 "You are the architect for: {goal}\nWrite a bounded plan, file-level proposals, and UI verify predicates. Do not implement production code."
200 ),
201 "implementer" => format!(
202 "You are the implementer for: {goal}\nFollow the architect plan. Default file writes are editor proposals; do not write through unless unrestricted mode is on. Keep the change minimal."
203 ),
204 "tester" => format!(
205 "You are the tester for: {goal}\nRun the detected project suite. Do not edit production code. Record failing tests as evidence."
206 ),
207 "reviewer" => format!(
208 "You are the reviewer for: {goal}\nYou cannot write, patch, or save files. Inspect each implementer's proposals in their isolated worktrees and return accept or reject with file-level reasons."
209 ),
210 "browser" => format!(
211 "You are the browser operator for: {goal}\nDrive the running app. Do not touch src/. Prove the UI with causal verify predicates and attach evidence."
212 ),
213 other => format!("You are {other} for: {goal}"),
214 }
215}
216
217fn implementer_prompt(goal: &str, index: usize, total: usize, worktree: &Path) -> String {
218 let slice = if index == 1 {
219 "production source from the architect plan"
220 } else {
221 "tests, types, and remaining files from the architect plan"
222 };
223 format!(
224 "You are implementer {index} of {total} for: {goal}\nYou work only in this isolated worktree: {}\nYou continue from a forked Pi session of the architect when one exists. Do not edit other implementers' trees. Own {slice}. Follow the architect plan. Default file writes are editor proposals; do not write through unless unrestricted mode is on. Keep the change minimal.",
225 worktree.display()
226 )
227}
228
229fn architect_session_file<B: TaskAgentBackend>(
230 scheduler: &TaskScheduler,
231 agents: &mut B,
232 snapshot: &TaskSnapshot,
233) -> Option<PathBuf> {
234 if snapshot.role != "implementer" {
235 return None;
236 }
237 let architect = snapshot.dependencies.iter().find_map(|dep| {
238 let task = scheduler.tasks.get(dep)?;
239 (task.snapshot.role == "architect")
240 .then(|| task.snapshot.assigned_agent.clone())
241 .flatten()
242 })?;
243 agents
244 .agent_snapshots()
245 .ok()?
246 .into_iter()
247 .find(|item| item.id == architect)?
248 .session_file
249 .map(PathBuf::from)
250}
251
252fn tester_prompt(goal: &str, worktree: &Path) -> String {
253 format!(
254 "You are the tester for: {goal}\nRun the detected project suite in this isolated worktree: {}\nDo not edit production code. Record failing tests as evidence.",
255 worktree.display()
256 )
257}
258
259impl TaskSpec {
260 pub fn new(title: impl Into<String>, prompt: impl Into<String>) -> Self {
261 let title = title.into();
262 Self {
263 goal: title.clone(),
264 title,
265 prompt: prompt.into(),
266 role: default_role(),
267 dependencies: Vec::new(),
268 worktree: None,
269 model: None,
270 thinking: None,
271 unrestricted: false,
272 budget: TaskBudget::default(),
273 verification: VerificationRequirement::default(),
274 retry: RetryPolicy::default(),
275 }
276 }
277}
278
279#[derive(Debug, Clone, Serialize, Deserialize)]
280#[serde(rename_all = "camelCase")]
281pub struct TaskSnapshot {
282 pub id: TaskId,
283 pub title: String,
284 pub goal: String,
285 pub prompt: String,
286 pub role: String,
287 pub dependencies: Vec<TaskId>,
288 pub assigned_agent: Option<AgentId>,
289 pub worktree: PathBuf,
290 pub model: Option<String>,
291 pub thinking: Option<String>,
292 pub unrestricted: bool,
293 pub budget: TaskBudget,
294 pub verification: VerificationRequirement,
295 pub retry: RetryPolicy,
296 pub state: TaskState,
297 pub attempt: u32,
298 pub observed_tokens: u64,
299 pub created_at_ms: u128,
300 pub started_at_ms: Option<u128>,
301 pub completed_at_ms: Option<u128>,
302 pub updated_at_ms: u128,
303 pub last_error: Option<String>,
304 pub evidence: Vec<TaskEvidence>,
305 pub blocked_override: bool,
306}
307
308#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
310#[serde(rename_all = "camelCase")]
311pub struct CrewWake {
312 pub id: String,
313 pub goal: String,
314 pub worktree: Option<String>,
315 pub checkpoint: String,
316 pub created_at_ms: u128,
317 pub tasks: Vec<CrewWakeMember>,
318 #[serde(default)]
319 pub diff: String,
320 #[serde(default)]
321 pub tests: String,
322 #[serde(default)]
323 pub verify: String,
324 #[serde(default)]
325 pub page: String,
326 #[serde(default)]
327 pub accept: String,
328}
329
330#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
331#[serde(rename_all = "camelCase")]
332pub struct CrewWakeMember {
333 pub id: String,
334 pub role: String,
335 pub title: String,
336 pub state: String,
337 #[serde(default)]
338 pub worktree: Option<String>,
339}
340
341#[derive(Debug, Clone, Default)]
343pub struct CrewWakeLiveEvidence {
344 pub verify: Option<String>,
345 pub page: Option<String>,
346 pub accept: Option<String>,
347}
348
349impl CrewWake {
350 pub fn render(&self) -> String {
351 let mut lines = vec![
352 format!("WAKE {}", self.id),
353 format!(" goal {}", self.goal),
354 format!(" worktree {}", self.worktree.as_deref().unwrap_or("—")),
355 format!(" checkpoint {}", self.checkpoint),
356 format!(
357 " accept {}",
358 if self.accept.is_empty() {
359 "none"
360 } else {
361 self.accept.as_str()
362 }
363 ),
364 ];
365 append_wake_section(&mut lines, "VERIFY", &self.verify, 12);
366 append_wake_section(&mut lines, "TESTS", &self.tests, 16);
367 append_wake_section(&mut lines, "PAGE", &self.page, 8);
368 append_wake_section(&mut lines, "DIFF", &self.diff, 40);
369 lines.push(String::new());
370 lines.push("CREW".into());
371 if self.tasks.is_empty() {
372 lines.push(" none queued".into());
373 } else {
374 for task in &self.tasks {
375 match task.worktree.as_deref() {
376 Some(worktree) if !worktree.is_empty() => {
377 lines.push(format!(
378 " {} {} {} · {worktree}",
379 task.role, task.id, task.state
380 ));
381 }
382 _ => lines.push(format!(" {} {} {}", task.role, task.id, task.state)),
383 }
384 }
385 }
386 lines.join("\n")
387 }
388}
389
390fn append_wake_section(lines: &mut Vec<String>, title: &str, body: &str, limit: usize) {
391 if body.trim().is_empty() {
392 return;
393 }
394 lines.push(String::new());
395 lines.push(title.into());
396 for line in body.lines().take(limit) {
397 lines.push(format!(" {line}"));
398 }
399}
400
401pub fn persist_crew_wake(root: &Path, wake: &CrewWake) -> DevelopmentResult<()> {
403 let dir = root.join(".glass").join("crew");
404 std::fs::create_dir_all(&dir)?;
405 let encoded = serde_json::to_vec_pretty(wake)?;
406 std::fs::write(dir.join(format!("{}.json", wake.id)), &encoded)?;
407 std::fs::write(dir.join("latest.json"), encoded)?;
408 Ok(())
409}
410
411pub fn load_latest_crew_wake(root: &Path) -> Option<CrewWake> {
413 let path = root.join(".glass").join("crew").join("latest.json");
414 serde_json::from_slice(&std::fs::read(path).ok()?).ok()
415}
416
417struct TaskRecord {
418 snapshot: TaskSnapshot,
419 next_retry_at_ms: Option<u128>,
420}
421
422pub trait TaskAgentBackend {
423 fn refresh_agents(&mut self) -> DevelopmentResult<()>;
424 fn create_agent(&mut self, spec: AgentSpec) -> DevelopmentResult<AgentId>;
425 fn agent_snapshots(&mut self) -> DevelopmentResult<Vec<AgentSnapshot>>;
426 fn agent_events(&mut self, since: u64) -> DevelopmentResult<Vec<AgentEvent>>;
427 fn prompt_agent(&mut self, id: &AgentId, prompt: String) -> DevelopmentResult<()>;
428 fn cancel_agent(&mut self, id: &AgentId) -> DevelopmentResult<()>;
429 fn complete_agent(&mut self, id: &AgentId) -> DevelopmentResult<()>;
430}
431
432impl TaskAgentBackend for AgentRegistry {
433 fn refresh_agents(&mut self) -> DevelopmentResult<()> {
434 self.refresh()
435 }
436
437 fn create_agent(&mut self, spec: AgentSpec) -> DevelopmentResult<AgentId> {
438 self.create(spec)
439 }
440
441 fn agent_snapshots(&mut self) -> DevelopmentResult<Vec<AgentSnapshot>> {
442 self.list()
443 }
444
445 fn agent_events(&mut self, since: u64) -> DevelopmentResult<Vec<AgentEvent>> {
446 self.history(since)
447 }
448
449 fn prompt_agent(&mut self, id: &AgentId, prompt: String) -> DevelopmentResult<()> {
450 self.prompt(id, prompt)
451 }
452
453 fn cancel_agent(&mut self, id: &AgentId) -> DevelopmentResult<()> {
454 self.cancel(id)
455 }
456
457 fn complete_agent(&mut self, id: &AgentId) -> DevelopmentResult<()> {
458 self.complete(id)
459 }
460}
461
462pub struct TaskScheduler {
463 root: PathBuf,
464 tasks: BTreeMap<TaskId, TaskRecord>,
465 next_task: u64,
466 agent_event_cursor: u64,
467}
468
469impl TaskScheduler {
470 pub fn new(root: impl AsRef<Path>) -> DevelopmentResult<Self> {
471 Ok(Self {
472 root: std::fs::canonicalize(root)?,
473 tasks: BTreeMap::new(),
474 next_task: 1,
475 agent_event_cursor: 0,
476 })
477 }
478
479 pub fn create<B: TaskAgentBackend>(
480 &mut self,
481 agents: &mut B,
482 mut spec: TaskSpec,
483 ) -> DevelopmentResult<TaskId> {
484 self.refresh(agents)?;
485 if spec.verification == VerificationRequirement::Inferred {
486 let worktree = spec.worktree.as_deref().unwrap_or(&self.root);
487 spec.verification = infer_verification(worktree);
488 }
489 self.validate_spec(&spec)?;
490 if self.tasks.len() >= MAX_TASKS {
491 return Err(DevelopmentError::Conflict(format!(
492 "task scheduler reached its {MAX_TASKS} task limit"
493 )));
494 }
495 let id = TaskId(format!("task-{:04}", self.next_task));
496 self.next_task = self
497 .next_task
498 .checked_add(1)
499 .ok_or_else(|| DevelopmentError::Conflict("task identifier space exhausted".into()))?;
500 let now = now_ms();
501 self.tasks.insert(
502 id.clone(),
503 TaskRecord {
504 snapshot: TaskSnapshot {
505 id: id.clone(),
506 title: spec.title,
507 goal: spec.goal,
508 prompt: spec.prompt,
509 role: spec.role,
510 dependencies: spec.dependencies,
511 assigned_agent: None,
512 worktree: spec.worktree.unwrap_or_else(|| self.root.clone()),
513 model: spec.model,
514 thinking: spec.thinking,
515 unrestricted: spec.unrestricted,
516 budget: spec.budget,
517 verification: spec.verification,
518 retry: spec.retry,
519 state: TaskState::Queued,
520 attempt: 0,
521 observed_tokens: 0,
522 created_at_ms: now,
523 started_at_ms: None,
524 completed_at_ms: None,
525 updated_at_ms: now,
526 last_error: None,
527 evidence: Vec::new(),
528 blocked_override: false,
529 },
530 next_retry_at_ms: None,
531 },
532 );
533 self.schedule_ready(agents)?;
534 Ok(id)
535 }
536
537 pub fn create_crew<B: TaskAgentBackend>(
539 &mut self,
540 agents: &mut B,
541 goal: &str,
542 shared: Option<PathBuf>,
543 implementer_trees: Vec<PathBuf>,
544 unrestricted: bool,
545 ) -> DevelopmentResult<Vec<TaskId>> {
546 validate_text("crew goal", goal)?;
547 let trees = if implementer_trees.is_empty() {
548 vec![shared.clone().unwrap_or_else(|| self.root.clone())]
549 } else {
550 implementer_trees
551 };
552 let mut architect = crew_spec(
553 "architect",
554 format!("architect: {goal}"),
555 goal,
556 crew_prompt("architect", goal),
557 );
558 architect.worktree = shared.clone();
559 architect.verification = VerificationRequirement::Settled;
560 let architect = self.create(agents, architect)?;
561 let mut implementers = Vec::new();
562 let mut testers = Vec::new();
563 let total = trees.len();
564 for (index, tree) in trees.into_iter().enumerate() {
565 let label = if total == 1 {
566 "implementer".into()
567 } else {
568 format!("implementer-{}", (b'a' + index as u8) as char)
569 };
570 let mut implementer = crew_spec(
571 "implementer",
572 format!("{label}: {goal}"),
573 goal,
574 implementer_prompt(goal, index + 1, total, &tree),
575 );
576 implementer.worktree = Some(tree.clone());
577 implementer.unrestricted = unrestricted;
578 implementer.verification = VerificationRequirement::Inferred;
579 implementer.dependencies = vec![architect.clone()];
580 let implementer = self.create(agents, implementer)?;
581 let tester_label = if total == 1 {
582 "tester".into()
583 } else {
584 format!("tester-{}", (b'a' + index as u8) as char)
585 };
586 let mut tester = crew_spec(
587 "tester",
588 format!("{tester_label}: {goal}"),
589 goal,
590 tester_prompt(goal, &tree),
591 );
592 tester.worktree = Some(tree);
593 tester.verification = VerificationRequirement::Inferred;
594 tester.dependencies = vec![implementer.clone()];
595 let tester = self.create(agents, tester)?;
596 implementers.push(implementer);
597 testers.push(tester);
598 }
599 let mut reviewer = crew_spec(
600 "reviewer",
601 format!("reviewer: {goal}"),
602 goal,
603 crew_prompt("reviewer", goal),
604 );
605 reviewer.worktree = shared;
606 reviewer.verification = VerificationRequirement::Settled;
607 reviewer.dependencies = implementers.clone();
608 let reviewer = self.create(agents, reviewer)?;
609 let mut browser = crew_spec(
610 "browser",
611 format!("browser: {goal}"),
612 goal,
613 crew_prompt("browser", goal),
614 );
615 browser.verification = VerificationRequirement::BrowserWorkflow {
616 assertion: goal.to_string(),
617 };
618 browser.dependencies = testers.clone();
619 let browser = self.create(agents, browser)?;
620 let mut ids = vec![architect];
621 ids.extend(implementers);
622 ids.extend(testers);
623 ids.push(reviewer);
624 ids.push(browser);
625 Ok(ids)
626 }
627
628 pub fn refresh<B: TaskAgentBackend>(&mut self, agents: &mut B) -> DevelopmentResult<()> {
629 agents.refresh_agents()?;
630 let snapshots = agents.agent_snapshots()?;
631 let events = agents.agent_events(self.agent_event_cursor)?;
632 for event in events {
633 self.agent_event_cursor = self.agent_event_cursor.max(event.sequence);
634 self.apply_agent_event(agents, &event)?;
635 }
636 self.apply_agent_failures(&snapshots);
637 self.enforce_task_budgets(agents)?;
638 self.verify_pending(agents)?;
639 self.propagate_blocked();
640 self.schedule_ready(agents)
641 }
642
643 pub fn list<B: TaskAgentBackend>(
644 &mut self,
645 agents: &mut B,
646 ) -> DevelopmentResult<Vec<TaskSnapshot>> {
647 self.refresh(agents)?;
648 Ok(self
649 .tasks
650 .values()
651 .map(|record| record.snapshot.clone())
652 .collect())
653 }
654
655 pub fn snapshot<B: TaskAgentBackend>(
656 &mut self,
657 agents: &mut B,
658 id: &TaskId,
659 ) -> DevelopmentResult<TaskSnapshot> {
660 self.refresh(agents)?;
661 self.tasks
662 .get(id)
663 .map(|record| record.snapshot.clone())
664 .ok_or_else(|| DevelopmentError::NotFound(format!("task {}", id.as_str())))
665 }
666
667 pub fn submit_evidence(
668 &mut self,
669 id: &TaskId,
670 kind: impl Into<String>,
671 actor: impl Into<String>,
672 source: impl Into<String>,
673 passed: bool,
674 details: Value,
675 ) -> DevelopmentResult<()> {
676 let record = self.record_mut(id)?;
677 push_evidence(
678 record,
679 TaskEvidence {
680 kind: kind.into(),
681 actor: actor.into(),
682 source: source.into(),
683 passed: Some(passed),
684 observed_at_ms: now_ms(),
685 details,
686 },
687 );
688 if record.snapshot.state == TaskState::Waiting {
689 record.snapshot.state = TaskState::Verifying;
690 }
691 Ok(())
692 }
693
694 pub fn pause<B: TaskAgentBackend>(
695 &mut self,
696 agents: &mut B,
697 id: &TaskId,
698 ) -> DevelopmentResult<()> {
699 self.refresh(agents)?;
700 let agent = self.record(id)?.snapshot.assigned_agent.clone();
701 if let Some(agent) = agent {
702 agents.cancel_agent(&agent)?;
703 }
704 let record = self.record_mut(id)?;
705 if record.snapshot.state.terminal() {
706 return Err(DevelopmentError::Conflict(
707 "terminal task cannot be paused".into(),
708 ));
709 }
710 record.snapshot.assigned_agent = None;
711 record.snapshot.state = TaskState::Paused;
712 record.snapshot.updated_at_ms = now_ms();
713 Ok(())
714 }
715
716 pub fn resume<B: TaskAgentBackend>(
717 &mut self,
718 agents: &mut B,
719 id: &TaskId,
720 ) -> DevelopmentResult<()> {
721 let record = self.record_mut(id)?;
722 if record.snapshot.state != TaskState::Paused {
723 return Err(DevelopmentError::Conflict("task is not paused".into()));
724 }
725 record.snapshot.state = TaskState::Queued;
726 record.snapshot.updated_at_ms = now_ms();
727 self.schedule_ready(agents)
728 }
729
730 pub fn cancel<B: TaskAgentBackend>(
731 &mut self,
732 agents: &mut B,
733 id: &TaskId,
734 ) -> DevelopmentResult<()> {
735 self.refresh(agents)?;
736 let agent = self.record(id)?.snapshot.assigned_agent.clone();
737 if let Some(agent) = agent {
738 agents.cancel_agent(&agent)?;
739 }
740 let record = self.record_mut(id)?;
741 if !record.snapshot.state.terminal() {
742 record.snapshot.state = TaskState::Cancelled;
743 record.snapshot.completed_at_ms = Some(now_ms());
744 record.snapshot.updated_at_ms = now_ms();
745 }
746 self.propagate_blocked();
747 Ok(())
748 }
749
750 pub fn retry<B: TaskAgentBackend>(
751 &mut self,
752 agents: &mut B,
753 id: &TaskId,
754 ) -> DevelopmentResult<()> {
755 let record = self.record_mut(id)?;
756 if !matches!(
757 record.snapshot.state,
758 TaskState::Failed | TaskState::Blocked
759 ) {
760 return Err(DevelopmentError::Conflict(
761 "only failed or blocked tasks can be retried".into(),
762 ));
763 }
764 record.snapshot.state = TaskState::Queued;
765 record.snapshot.assigned_agent = None;
766 record.snapshot.completed_at_ms = None;
767 record.snapshot.last_error = None;
768 record.snapshot.updated_at_ms = now_ms();
769 record.next_retry_at_ms = None;
770 self.schedule_ready(agents)
771 }
772
773 pub fn reassign<B: TaskAgentBackend>(
774 &mut self,
775 agents: &mut B,
776 id: &TaskId,
777 role: String,
778 model: Option<String>,
779 thinking: Option<String>,
780 ) -> DevelopmentResult<()> {
781 validate_text("task role", &role)?;
782 let agent = self.record(id)?.snapshot.assigned_agent.clone();
783 if let Some(agent) = agent {
784 agents.cancel_agent(&agent)?;
785 }
786 let record = self.record_mut(id)?;
787 if record.snapshot.state.terminal() {
788 return Err(DevelopmentError::Conflict(
789 "terminal task cannot be reassigned".into(),
790 ));
791 }
792 record.snapshot.role = role;
793 record.snapshot.model = model;
794 record.snapshot.thinking = thinking;
795 record.snapshot.assigned_agent = None;
796 record.snapshot.state = TaskState::Queued;
797 record.snapshot.updated_at_ms = now_ms();
798 self.schedule_ready(agents)
799 }
800
801 pub fn override_blocked<B: TaskAgentBackend>(
802 &mut self,
803 agents: &mut B,
804 id: &TaskId,
805 ) -> DevelopmentResult<()> {
806 let record = self.record_mut(id)?;
807 if record.snapshot.state != TaskState::Blocked {
808 return Err(DevelopmentError::Conflict("task is not blocked".into()));
809 }
810 record.snapshot.blocked_override = true;
811 record.snapshot.state = TaskState::Queued;
812 record.snapshot.last_error = None;
813 record.snapshot.updated_at_ms = now_ms();
814 self.schedule_ready(agents)
815 }
816
817 fn schedule_ready<B: TaskAgentBackend>(&mut self, agents: &mut B) -> DevelopmentResult<()> {
818 let now = now_ms();
819 let ready = self
820 .tasks
821 .iter()
822 .filter(|(_, record)| record.snapshot.state == TaskState::Queued)
823 .filter(|(_, record)| record.next_retry_at_ms.is_none_or(|at| at <= now))
824 .filter(|(_, record)| {
825 record.snapshot.blocked_override
826 || record.snapshot.dependencies.iter().all(|dependency| {
827 self.tasks.get(dependency).is_some_and(|dependency| {
828 dependency.snapshot.state == TaskState::Succeeded
829 })
830 })
831 })
832 .map(|(id, _)| id.clone())
833 .collect::<Vec<_>>();
834 for id in ready {
835 let snapshot = self.record(&id)?.snapshot.clone();
836 let mut spec = AgentSpec::new(
837 snapshot.role.clone(),
838 format!("task {}: {}", id.as_str(), snapshot.title),
839 );
840 spec.model.clone_from(&snapshot.model);
841 spec.thinking.clone_from(&snapshot.thinking);
842 spec.worktree = Some(snapshot.worktree.clone());
843 spec.fork_from = architect_session_file(self, agents, &snapshot);
844 spec.unrestricted = snapshot.unrestricted;
845 spec.max_runtime_seconds = Some(snapshot.budget.max_runtime_seconds);
846 spec.max_events = Some(snapshot.budget.max_events);
847 let agent = agents.create_agent(spec)?;
848 let record = self.record_mut(&id)?;
849 record.snapshot.assigned_agent = Some(agent);
850 record.snapshot.state = TaskState::Ready;
851 record.snapshot.attempt = record.snapshot.attempt.saturating_add(1);
852 record.snapshot.updated_at_ms = now_ms();
853 record.next_retry_at_ms = None;
854 }
855 Ok(())
856 }
857
858 fn apply_agent_event<B: TaskAgentBackend>(
859 &mut self,
860 agents: &mut B,
861 event: &AgentEvent,
862 ) -> DevelopmentResult<()> {
863 let Some(task_id) = self.task_for_agent(&event.agent_id) else {
864 return Ok(());
865 };
866 let state = self.record(&task_id)?.snapshot.state;
867 match event.kind.as_str() {
868 "ready" if state == TaskState::Ready => {
869 let prompt = self.record(&task_id)?.snapshot.prompt.clone();
870 agents.prompt_agent(&event.agent_id, prompt)?;
871 let record = self.record_mut(&task_id)?;
872 record.snapshot.state = TaskState::Running;
873 record.snapshot.started_at_ms.get_or_insert_with(now_ms);
874 record.snapshot.updated_at_ms = now_ms();
875 }
876 "agent_settled" if state == TaskState::Running => {
877 let record = self.record_mut(&task_id)?;
878 record.snapshot.state = TaskState::Verifying;
879 record.snapshot.updated_at_ms = now_ms();
880 push_evidence(
881 record,
882 TaskEvidence {
883 kind: "agent.settled".into(),
884 actor: event.agent_id.as_str().into(),
885 source: "pi-agent-session".into(),
886 passed: Some(true),
887 observed_at_ms: event.timestamp_ms,
888 details: event.payload.clone(),
889 },
890 );
891 }
892 kind => {
893 let record = self.record_mut(&task_id)?;
894 if kind == "message_end" {
895 record.snapshot.observed_tokens = record
896 .snapshot
897 .observed_tokens
898 .saturating_add(event_tokens(&event.payload));
899 }
900 push_evidence(
901 record,
902 TaskEvidence {
903 kind: format!("agent.{kind}"),
904 actor: event.agent_id.as_str().into(),
905 source: "pi-agent-session".into(),
906 passed: None,
907 observed_at_ms: event.timestamp_ms,
908 details: event.payload.clone(),
909 },
910 );
911 }
912 }
913 Ok(())
914 }
915
916 fn apply_agent_failures(&mut self, snapshots: &[AgentSnapshot]) {
917 for snapshot in snapshots {
918 if !matches!(
919 snapshot.status,
920 AgentStatus::Failed | AgentStatus::Cancelled
921 ) {
922 continue;
923 }
924 let Some(id) = self.task_for_agent(&snapshot.id) else {
925 continue;
926 };
927 let record = self.tasks.get_mut(&id).expect("task exists");
928 if !record.snapshot.state.terminal() {
929 record.snapshot.state = TaskState::Failed;
930 record.snapshot.last_error = snapshot
931 .last_error
932 .clone()
933 .or_else(|| Some("assigned agent stopped before verification".into()));
934 record.snapshot.completed_at_ms = Some(now_ms());
935 record.snapshot.updated_at_ms = now_ms();
936 }
937 }
938 }
939
940 fn verify_pending<B: TaskAgentBackend>(&mut self, agents: &mut B) -> DevelopmentResult<()> {
941 let pending = self
942 .tasks
943 .iter()
944 .filter(|(_, record)| record.snapshot.state == TaskState::Verifying)
945 .map(|(id, _)| id.clone())
946 .collect::<Vec<_>>();
947 for id in pending {
948 let (requirement, worktree, evidence) = {
949 let record = self.record(&id)?;
950 (
951 record.snapshot.verification.clone(),
952 record.snapshot.worktree.clone(),
953 record.snapshot.evidence.clone(),
954 )
955 };
956 match verify(&requirement, &worktree, &evidence)? {
957 VerificationOutcome::Passed(new_evidence) => {
958 let agent = self.record(&id)?.snapshot.assigned_agent.clone();
959 if let Some(agent) = agent {
960 agents.complete_agent(&agent)?;
961 }
962 let record = self.record_mut(&id)?;
963 for evidence in new_evidence {
964 push_evidence(record, evidence);
965 }
966 record.snapshot.state = TaskState::Succeeded;
967 record.snapshot.completed_at_ms = Some(now_ms());
968 record.snapshot.updated_at_ms = now_ms();
969 record.snapshot.last_error = None;
970 }
971 VerificationOutcome::Waiting => {
972 let record = self.record_mut(&id)?;
973 record.snapshot.state = TaskState::Waiting;
974 record.snapshot.updated_at_ms = now_ms();
975 }
976 VerificationOutcome::Failed(error, new_evidence) => {
977 let (agent, retry, attempt) = {
978 let record = self.record(&id)?;
979 (
980 record.snapshot.assigned_agent.clone(),
981 record.snapshot.retry.clone(),
982 record.snapshot.attempt,
983 )
984 };
985 if let Some(agent) = agent {
986 agents.cancel_agent(&agent)?;
987 }
988 let record = self.record_mut(&id)?;
989 for evidence in new_evidence {
990 push_evidence(record, evidence);
991 }
992 record.snapshot.assigned_agent = None;
993 record.snapshot.last_error = Some(error);
994 record.snapshot.updated_at_ms = now_ms();
995 if attempt <= retry.max_retries {
996 record.snapshot.state = TaskState::Queued;
997 record.next_retry_at_ms = Some(
998 now_ms().saturating_add(u128::from(retry.backoff_seconds) * 1_000),
999 );
1000 } else {
1001 record.snapshot.state = TaskState::Failed;
1002 record.snapshot.completed_at_ms = Some(now_ms());
1003 }
1004 }
1005 }
1006 }
1007 Ok(())
1008 }
1009
1010 fn enforce_task_budgets<B: TaskAgentBackend>(
1011 &mut self,
1012 agents: &mut B,
1013 ) -> DevelopmentResult<()> {
1014 let now = now_ms();
1015 let exceeded = self
1016 .tasks
1017 .iter()
1018 .filter(|(_, record)| {
1019 matches!(
1020 record.snapshot.state,
1021 TaskState::Running | TaskState::Waiting
1022 )
1023 })
1024 .filter(|(_, record)| {
1025 record.snapshot.started_at_ms.is_some_and(|started| {
1026 now.saturating_sub(started)
1027 > u128::from(record.snapshot.budget.max_runtime_seconds) * 1_000
1028 }) || record
1029 .snapshot
1030 .budget
1031 .max_tokens
1032 .is_some_and(|limit| record.snapshot.observed_tokens >= limit)
1033 })
1034 .map(|(id, _)| id.clone())
1035 .collect::<Vec<_>>();
1036 for id in exceeded {
1037 if let Some(agent) = self.record(&id)?.snapshot.assigned_agent.clone() {
1038 agents.cancel_agent(&agent)?;
1039 }
1040 let record = self.record_mut(&id)?;
1041 record.snapshot.state = TaskState::Failed;
1042 record.snapshot.last_error = Some("task runtime or token budget exceeded".into());
1043 record.snapshot.completed_at_ms = Some(now);
1044 record.snapshot.updated_at_ms = now;
1045 }
1046 Ok(())
1047 }
1048
1049 fn propagate_blocked(&mut self) {
1050 loop {
1051 let failed = self
1052 .tasks
1053 .iter()
1054 .filter(|(_, record)| {
1055 matches!(
1056 record.snapshot.state,
1057 TaskState::Failed | TaskState::Cancelled | TaskState::Blocked
1058 )
1059 })
1060 .map(|(id, _)| id.clone())
1061 .collect::<BTreeSet<_>>();
1062 let blocked = self
1063 .tasks
1064 .iter()
1065 .filter(|(_, record)| {
1066 record.snapshot.state == TaskState::Queued && !record.snapshot.blocked_override
1067 })
1068 .filter(|(_, record)| {
1069 record
1070 .snapshot
1071 .dependencies
1072 .iter()
1073 .any(|dependency| failed.contains(dependency))
1074 })
1075 .map(|(id, _)| id.clone())
1076 .collect::<Vec<_>>();
1077 if blocked.is_empty() {
1078 break;
1079 }
1080 for id in blocked {
1081 let record = self.tasks.get_mut(&id).expect("task exists");
1082 record.snapshot.state = TaskState::Blocked;
1083 record.snapshot.last_error = Some("a prerequisite task did not succeed".into());
1084 record.snapshot.updated_at_ms = now_ms();
1085 }
1086 }
1087 }
1088
1089 fn validate_spec(&self, spec: &TaskSpec) -> DevelopmentResult<()> {
1090 for (label, value) in [
1091 ("task title", spec.title.as_str()),
1092 ("task goal", spec.goal.as_str()),
1093 ("task prompt", spec.prompt.as_str()),
1094 ("task role", spec.role.as_str()),
1095 ] {
1096 validate_text(label, value)?;
1097 }
1098 if spec.dependencies.len() > MAX_DEPENDENCIES {
1099 return Err(DevelopmentError::InvalidInput(
1100 "task has too many dependencies".into(),
1101 ));
1102 }
1103 let mut unique = BTreeSet::new();
1104 for dependency in &spec.dependencies {
1105 if !unique.insert(dependency) {
1106 return Err(DevelopmentError::InvalidInput(format!(
1107 "duplicate task dependency {}",
1108 dependency.as_str()
1109 )));
1110 }
1111 if !self.tasks.contains_key(dependency) {
1112 return Err(DevelopmentError::NotFound(format!(
1113 "task dependency {}",
1114 dependency.as_str()
1115 )));
1116 }
1117 }
1118 if spec.budget.max_runtime_seconds == 0 || spec.budget.max_events == 0 {
1119 return Err(DevelopmentError::InvalidInput(
1120 "task budgets must be positive".into(),
1121 ));
1122 }
1123 validate_verification(&spec.verification, 0)?;
1124 if let Some(worktree) = &spec.worktree {
1125 let worktree = std::fs::canonicalize(worktree)?;
1126 if worktree == Path::new("/")
1127 || (!worktree.starts_with(&self.root) && !worktree.join(".git").exists())
1128 {
1129 return Err(DevelopmentError::PathOutsideWorkspace(worktree));
1130 }
1131 }
1132 Ok(())
1133 }
1134
1135 fn task_for_agent(&self, agent: &AgentId) -> Option<TaskId> {
1136 self.tasks
1137 .iter()
1138 .find(|(_, record)| record.snapshot.assigned_agent.as_ref() == Some(agent))
1139 .map(|(id, _)| id.clone())
1140 }
1141
1142 fn record(&self, id: &TaskId) -> DevelopmentResult<&TaskRecord> {
1143 self.tasks
1144 .get(id)
1145 .ok_or_else(|| DevelopmentError::NotFound(format!("task {}", id.as_str())))
1146 }
1147
1148 fn record_mut(&mut self, id: &TaskId) -> DevelopmentResult<&mut TaskRecord> {
1149 self.tasks
1150 .get_mut(id)
1151 .ok_or_else(|| DevelopmentError::NotFound(format!("task {}", id.as_str())))
1152 }
1153}
1154
1155enum VerificationOutcome {
1156 Passed(Vec<TaskEvidence>),
1157 Waiting,
1158 Failed(String, Vec<TaskEvidence>),
1159}
1160
1161fn verify(
1162 requirement: &VerificationRequirement,
1163 worktree: &Path,
1164 evidence: &[TaskEvidence],
1165) -> DevelopmentResult<VerificationOutcome> {
1166 match requirement {
1167 VerificationRequirement::Inferred => Err(DevelopmentError::Conflict(
1168 "inferred task verification was not resolved at creation".into(),
1169 )),
1170 VerificationRequirement::Settled => Ok(VerificationOutcome::Passed(Vec::new())),
1171 VerificationRequirement::Command {
1172 command,
1173 expected_exit,
1174 timeout_seconds,
1175 } => verify_command(worktree, command, *expected_exit, *timeout_seconds),
1176 VerificationRequirement::All { requirements } => {
1177 let mut collected = Vec::new();
1178 for requirement in requirements {
1179 match verify(requirement, worktree, evidence)? {
1180 VerificationOutcome::Passed(mut current) => collected.append(&mut current),
1181 VerificationOutcome::Waiting => return Ok(VerificationOutcome::Waiting),
1182 VerificationOutcome::Failed(error, mut current) => {
1183 collected.append(&mut current);
1184 return Ok(VerificationOutcome::Failed(error, collected));
1185 }
1186 }
1187 }
1188 Ok(VerificationOutcome::Passed(collected))
1189 }
1190 requirement => {
1191 let kind = verification_kind(requirement);
1192 match evidence.iter().rev().find(|item| item.kind == kind) {
1193 Some(item) if evidence_satisfies(requirement, item) => {
1194 Ok(VerificationOutcome::Passed(Vec::new()))
1195 }
1196 Some(item) if item.passed == Some(false) => Ok(VerificationOutcome::Failed(
1197 format!("{kind} verification failed"),
1198 Vec::new(),
1199 )),
1200 _ => Ok(VerificationOutcome::Waiting),
1201 }
1202 }
1203 }
1204}
1205
1206fn evidence_satisfies(requirement: &VerificationRequirement, evidence: &TaskEvidence) -> bool {
1207 if evidence.passed != Some(true) {
1208 return false;
1209 }
1210 match requirement {
1211 VerificationRequirement::LspDiagnostics { max_errors } => evidence
1212 .details
1213 .get("errors")
1214 .and_then(Value::as_u64)
1215 .is_some_and(|errors| errors <= *max_errors),
1216 VerificationRequirement::SemanticRegression {
1217 maximum_regressions,
1218 ..
1219 } => evidence
1220 .details
1221 .get("regressions")
1222 .and_then(Value::as_u64)
1223 .is_some_and(|regressions| regressions <= *maximum_regressions),
1224 VerificationRequirement::GitChange {
1225 require_changes,
1226 require_clean,
1227 } => {
1228 evidence.details.get("hasChanges").and_then(Value::as_bool) == Some(*require_changes)
1229 && (!*require_clean
1230 || evidence.details.get("clean").and_then(Value::as_bool) == Some(true))
1231 }
1232 _ => true,
1233 }
1234}
1235
1236fn verify_command(
1237 worktree: &Path,
1238 command: &str,
1239 expected_exit: i32,
1240 timeout_seconds: u64,
1241) -> DevelopmentResult<VerificationOutcome> {
1242 let mut process = if cfg!(windows) {
1243 let mut command_process = Command::new("cmd.exe");
1244 command_process.args(["/d", "/s", "/c", command]);
1245 command_process
1246 } else {
1247 let mut command_process = Command::new("sh");
1248 command_process.args(["-lc", command]);
1249 command_process
1250 };
1251 let mut child = process
1252 .current_dir(worktree)
1253 .stdin(Stdio::null())
1254 .stdout(Stdio::null())
1255 .stderr(Stdio::null())
1256 .spawn()?;
1257 let deadline = Instant::now() + Duration::from_secs(timeout_seconds);
1258 loop {
1259 if let Some(status) = child.try_wait()? {
1260 let actual = status.code().unwrap_or(-1);
1261 let passed = actual == expected_exit;
1262 let observed = TaskEvidence {
1263 kind: "command".into(),
1264 actor: "glass-task-verifier".into(),
1265 source: "trusted-command".into(),
1266 passed: Some(passed),
1267 observed_at_ms: now_ms(),
1268 details: serde_json::json!({
1269 "command": command,
1270 "expectedExit": expected_exit,
1271 "actualExit": actual,
1272 }),
1273 };
1274 return Ok(if passed {
1275 VerificationOutcome::Passed(vec![observed])
1276 } else {
1277 VerificationOutcome::Failed(
1278 format!("verification command exited {actual}, expected {expected_exit}"),
1279 vec![observed],
1280 )
1281 });
1282 }
1283 if Instant::now() >= deadline {
1284 child.kill()?;
1285 child.wait()?;
1286 return Ok(VerificationOutcome::Failed(
1287 "verification command timed out".into(),
1288 vec![TaskEvidence {
1289 kind: "command".into(),
1290 actor: "glass-task-verifier".into(),
1291 source: "trusted-command".into(),
1292 passed: Some(false),
1293 observed_at_ms: now_ms(),
1294 details: serde_json::json!({"command":command,"timedOut":true}),
1295 }],
1296 ));
1297 }
1298 thread::sleep(Duration::from_millis(10));
1299 }
1300}
1301
1302fn verification_kind(requirement: &VerificationRequirement) -> &'static str {
1303 match requirement {
1304 VerificationRequirement::LspDiagnostics { .. } => "lspDiagnostics",
1305 VerificationRequirement::BrowserWorkflow { .. } => "browserWorkflow",
1306 VerificationRequirement::SemanticRegression { .. } => "semanticRegression",
1307 VerificationRequirement::DebuggerAssertion { .. } => "debuggerAssertion",
1308 VerificationRequirement::GitChange { .. } => "gitChange",
1309 VerificationRequirement::TrustedCustom { .. } => "trustedCustom",
1310 _ => "unknown",
1311 }
1312}
1313
1314fn infer_verification(worktree: &Path) -> VerificationRequirement {
1315 let command = if worktree.join("Cargo.lock").is_file() {
1316 Some("cargo test --workspace --all-targets --locked")
1317 } else if worktree.join("Cargo.toml").is_file() {
1318 Some("cargo test --workspace --all-targets")
1319 } else if worktree.join("package.json").is_file() {
1320 Some("npm test")
1321 } else if worktree.join("pyproject.toml").is_file() || worktree.join("pytest.ini").is_file() {
1322 Some("python -m pytest")
1323 } else if worktree.join("go.mod").is_file() {
1324 Some("go test ./...")
1325 } else {
1326 None
1327 };
1328 command.map_or(
1329 VerificationRequirement::GitChange {
1330 require_changes: true,
1331 require_clean: false,
1332 },
1333 |command| VerificationRequirement::Command {
1334 command: command.into(),
1335 expected_exit: 0,
1336 timeout_seconds: 600,
1337 },
1338 )
1339}
1340
1341fn event_tokens(value: &Value) -> u64 {
1342 value
1343 .pointer("/message/usage/totalTokens")
1344 .or_else(|| value.pointer("/usage/totalTokens"))
1345 .and_then(Value::as_u64)
1346 .or_else(|| {
1347 let usage = value
1348 .pointer("/message/usage")
1349 .or_else(|| value.get("usage"))?;
1350 Some(
1351 ["input", "output", "cacheRead", "cacheWrite"]
1352 .iter()
1353 .filter_map(|name| usage.get(name).and_then(Value::as_u64))
1354 .fold(0_u64, u64::saturating_add),
1355 )
1356 })
1357 .unwrap_or(0)
1358}
1359
1360fn validate_verification(
1361 requirement: &VerificationRequirement,
1362 depth: usize,
1363) -> DevelopmentResult<()> {
1364 if depth > 8 {
1365 return Err(DevelopmentError::InvalidInput(
1366 "task verification nesting exceeds 8".into(),
1367 ));
1368 }
1369 match requirement {
1370 VerificationRequirement::Command {
1371 command,
1372 timeout_seconds,
1373 ..
1374 } => {
1375 if command.is_empty()
1376 || command.len() > MAX_VERIFIER_COMMAND_BYTES
1377 || command.contains('\0')
1378 || *timeout_seconds == 0
1379 || *timeout_seconds > 600
1380 {
1381 return Err(DevelopmentError::InvalidInput(
1382 "invalid task verification command".into(),
1383 ));
1384 }
1385 }
1386 VerificationRequirement::All { requirements } => {
1387 if requirements.is_empty() || requirements.len() > 16 {
1388 return Err(DevelopmentError::InvalidInput(
1389 "task verification group must contain 1..=16 requirements".into(),
1390 ));
1391 }
1392 for requirement in requirements {
1393 validate_verification(requirement, depth + 1)?;
1394 }
1395 }
1396 _ => {}
1397 }
1398 Ok(())
1399}
1400
1401fn push_evidence(record: &mut TaskRecord, evidence: TaskEvidence) {
1402 if record.snapshot.evidence.len() == MAX_TASK_EVIDENCE {
1403 record.snapshot.evidence.remove(0);
1404 }
1405 record.snapshot.evidence.push(evidence);
1406 record.snapshot.updated_at_ms = now_ms();
1407}
1408
1409fn validate_text(label: &str, value: &str) -> DevelopmentResult<()> {
1410 if value.is_empty() || value.len() > MAX_TASK_TEXT_BYTES || value.contains('\0') {
1411 return Err(DevelopmentError::InvalidInput(format!(
1412 "{label} must contain 1..={MAX_TASK_TEXT_BYTES} bytes without NUL"
1413 )));
1414 }
1415 Ok(())
1416}
1417
1418fn now_ms() -> u128 {
1419 SystemTime::now()
1420 .duration_since(UNIX_EPOCH)
1421 .unwrap_or_default()
1422 .as_millis()
1423}
1424
1425#[cfg(test)]
1426mod tests {
1427 use super::*;
1428 use std::sync::atomic::{AtomicU64, Ordering};
1429
1430 static NEXT_TEST_ROOT: AtomicU64 = AtomicU64::new(1);
1431
1432 #[derive(Default)]
1433 struct FakeAgents {
1434 next: u64,
1435 next_event: u64,
1436 snapshots: BTreeMap<AgentId, AgentSnapshot>,
1437 events: Vec<AgentEvent>,
1438 prompts: Vec<(AgentId, String)>,
1439 }
1440
1441 impl FakeAgents {
1442 fn emit(&mut self, id: &AgentId, kind: &str, payload: Value) {
1443 self.next_event += 1;
1444 self.events.push(AgentEvent {
1445 sequence: self.next_event,
1446 agent_id: id.clone(),
1447 timestamp_ms: now_ms(),
1448 kind: kind.into(),
1449 payload,
1450 });
1451 }
1452
1453 fn snapshot(id: AgentId, spec: AgentSpec) -> AgentSnapshot {
1454 AgentSnapshot {
1455 id,
1456 role: spec.role,
1457 task: spec.task,
1458 status: AgentStatus::Idle,
1459 dependencies: Vec::new(),
1460 model: spec.model,
1461 thinking: spec.thinking,
1462 worktree: spec.worktree.unwrap(),
1463 session_file: None,
1464 unrestricted: spec.unrestricted,
1465 created_at_ms: now_ms(),
1466 started_at_ms: Some(now_ms()),
1467 updated_at_ms: now_ms(),
1468 event_count: 0,
1469 dropped_event_count: 0,
1470 last_error: None,
1471 last_response_id: None,
1472 evidence: Vec::new(),
1473 }
1474 }
1475 }
1476
1477 impl TaskAgentBackend for FakeAgents {
1478 fn refresh_agents(&mut self) -> DevelopmentResult<()> {
1479 Ok(())
1480 }
1481
1482 fn create_agent(&mut self, spec: AgentSpec) -> DevelopmentResult<AgentId> {
1483 self.next += 1;
1484 let id = AgentId::parse(format!("agent-{:04}", self.next))?;
1485 self.snapshots
1486 .insert(id.clone(), Self::snapshot(id.clone(), spec));
1487 self.emit(&id, "ready", Value::Null);
1488 Ok(id)
1489 }
1490
1491 fn agent_snapshots(&mut self) -> DevelopmentResult<Vec<AgentSnapshot>> {
1492 Ok(self.snapshots.values().cloned().collect())
1493 }
1494
1495 fn agent_events(&mut self, since: u64) -> DevelopmentResult<Vec<AgentEvent>> {
1496 Ok(self
1497 .events
1498 .iter()
1499 .filter(|event| event.sequence > since)
1500 .cloned()
1501 .collect())
1502 }
1503
1504 fn prompt_agent(&mut self, id: &AgentId, prompt: String) -> DevelopmentResult<()> {
1505 self.prompts.push((id.clone(), prompt));
1506 self.emit(id, "requestStarted", Value::String("request-1".into()));
1507 self.emit(id, "agent_settled", Value::Null);
1508 Ok(())
1509 }
1510
1511 fn cancel_agent(&mut self, id: &AgentId) -> DevelopmentResult<()> {
1512 self.snapshots.get_mut(id).unwrap().status = AgentStatus::Cancelled;
1513 Ok(())
1514 }
1515
1516 fn complete_agent(&mut self, id: &AgentId) -> DevelopmentResult<()> {
1517 self.snapshots.get_mut(id).unwrap().status = AgentStatus::Completed;
1518 Ok(())
1519 }
1520 }
1521
1522 fn scheduler() -> (PathBuf, TaskScheduler, FakeAgents) {
1523 let root = std::env::temp_dir().join(format!(
1524 "glass-task-scheduler-test-{}-{}",
1525 std::process::id(),
1526 NEXT_TEST_ROOT.fetch_add(1, Ordering::Relaxed)
1527 ));
1528 std::fs::create_dir_all(&root).unwrap();
1529 let scheduler = TaskScheduler::new(&root).unwrap();
1530 (root, scheduler, FakeAgents::default())
1531 }
1532
1533 fn settle(scheduler: &mut TaskScheduler, agents: &mut FakeAgents) {
1534 scheduler.refresh(agents).unwrap();
1535 scheduler.refresh(agents).unwrap();
1536 }
1537
1538 fn settle_only(title: impl Into<String>, prompt: impl Into<String>) -> TaskSpec {
1539 let mut spec = TaskSpec::new(title, prompt);
1540 spec.verification = VerificationRequirement::Settled;
1541 spec
1542 }
1543
1544 #[test]
1545 fn tasks_dispatch_prompts_verify_and_wake_dag_dependents() {
1546 let (root, mut scheduler, mut agents) = scheduler();
1547 let first = scheduler
1548 .create(&mut agents, settle_only("investigate", "inspect failure"))
1549 .unwrap();
1550 settle(&mut scheduler, &mut agents);
1551 assert_eq!(
1552 scheduler.snapshot(&mut agents, &first).unwrap().state,
1553 TaskState::Succeeded
1554 );
1555 assert_eq!(agents.prompts[0].1, "inspect failure");
1556
1557 let mut dependent = settle_only("repair", "apply repair");
1558 dependent.dependencies.push(first);
1559 let dependent = scheduler.create(&mut agents, dependent).unwrap();
1560 settle(&mut scheduler, &mut agents);
1561 assert_eq!(
1562 scheduler.snapshot(&mut agents, &dependent).unwrap().state,
1563 TaskState::Succeeded
1564 );
1565 assert_eq!(agents.prompts[1].1, "apply repair");
1566 std::fs::remove_dir_all(root).unwrap();
1567 }
1568
1569 #[test]
1570 fn eight_ready_tasks_dispatch_before_integration_dependency_wakes() {
1571 let (root, mut scheduler, mut agents) = scheduler();
1572 let mut leaves = Vec::new();
1573 for index in 0..8 {
1574 leaves.push(
1575 scheduler
1576 .create(
1577 &mut agents,
1578 settle_only(format!("worker-{index}"), format!("inspect shard {index}")),
1579 )
1580 .unwrap(),
1581 );
1582 }
1583 assert_eq!(scheduler.tasks.len(), 8);
1584
1585 let mut integration = settle_only("integration", "verify all shards");
1586 integration.dependencies = leaves.clone();
1587 let integration = scheduler.create(&mut agents, integration).unwrap();
1588 assert_eq!(scheduler.tasks.len(), 9);
1589 settle(&mut scheduler, &mut agents);
1590 settle(&mut scheduler, &mut agents);
1591
1592 for leaf in leaves {
1593 assert_eq!(
1594 scheduler.snapshot(&mut agents, &leaf).unwrap().state,
1595 TaskState::Succeeded
1596 );
1597 }
1598 assert_eq!(
1599 scheduler.snapshot(&mut agents, &integration).unwrap().state,
1600 TaskState::Succeeded
1601 );
1602 assert_eq!(agents.prompts.len(), 9);
1603 std::fs::remove_dir_all(root).unwrap();
1604 }
1605
1606 #[test]
1607 fn verification_failure_retries_then_blocks_descendants() {
1608 let (root, mut scheduler, mut agents) = scheduler();
1609 let mut failing = TaskSpec::new("verify", "produce candidate");
1610 failing.verification = VerificationRequirement::Command {
1611 command: "exit 7".into(),
1612 expected_exit: 0,
1613 timeout_seconds: 2,
1614 };
1615 failing.retry = RetryPolicy {
1616 max_retries: 1,
1617 backoff_seconds: 0,
1618 };
1619 let failing = scheduler.create(&mut agents, failing).unwrap();
1620 let mut child = TaskSpec::new("integration", "integrate candidate");
1621 child.dependencies.push(failing.clone());
1622 let child = scheduler.create(&mut agents, child).unwrap();
1623 for _ in 0..6 {
1624 scheduler.refresh(&mut agents).unwrap();
1625 }
1626 let failed = scheduler.snapshot(&mut agents, &failing).unwrap();
1627 assert_eq!(failed.state, TaskState::Failed);
1628 assert_eq!(failed.attempt, 2);
1629 assert_eq!(
1630 scheduler.snapshot(&mut agents, &child).unwrap().state,
1631 TaskState::Blocked
1632 );
1633 assert_eq!(agents.prompts.len(), 2);
1634 std::fs::remove_dir_all(root).unwrap();
1635 }
1636
1637 #[test]
1638 fn external_verification_evidence_is_proof_not_agent_claim() {
1639 let (root, mut scheduler, mut agents) = scheduler();
1640 let mut spec = TaskSpec::new("diagnostics", "repair diagnostics");
1641 spec.verification = VerificationRequirement::LspDiagnostics { max_errors: 0 };
1642 let id = scheduler.create(&mut agents, spec).unwrap();
1643 settle(&mut scheduler, &mut agents);
1644 assert_eq!(
1645 scheduler.snapshot(&mut agents, &id).unwrap().state,
1646 TaskState::Waiting
1647 );
1648 scheduler
1649 .submit_evidence(
1650 &id,
1651 "lspDiagnostics",
1652 "resident-lsp",
1653 "task-test",
1654 true,
1655 serde_json::json!({"errors":0,"source":"resident-lsp"}),
1656 )
1657 .unwrap();
1658 scheduler.refresh(&mut agents).unwrap();
1659 assert_eq!(
1660 scheduler.snapshot(&mut agents, &id).unwrap().state,
1661 TaskState::Succeeded
1662 );
1663 std::fs::remove_dir_all(root).unwrap();
1664 }
1665
1666 #[test]
1667 fn implementation_tasks_infer_project_verification_and_settle_only_is_explicit() {
1668 let (root, mut scheduler, mut agents) = scheduler();
1669 std::fs::write(
1670 root.join("Cargo.toml"),
1671 "[package]\nname='verification-fixture'\nversion='0.1.0'\n",
1672 )
1673 .unwrap();
1674 let inferred = scheduler
1675 .create(
1676 &mut agents,
1677 TaskSpec::new("implement repair", "change the implementation"),
1678 )
1679 .unwrap();
1680 assert!(matches!(
1681 scheduler.tasks[&inferred].snapshot.verification,
1682 VerificationRequirement::Command { ref command, .. }
1683 if command == "cargo test --workspace --all-targets"
1684 ));
1685
1686 let research = scheduler
1687 .create(
1688 &mut agents,
1689 settle_only("research alternatives", "compare approaches"),
1690 )
1691 .unwrap();
1692 assert_eq!(
1693 scheduler.tasks[&research].snapshot.verification,
1694 VerificationRequirement::Settled
1695 );
1696 std::fs::remove_dir_all(root).unwrap();
1697 }
1698
1699 #[test]
1700 fn factory_crew_queues_architect_implementer_tester_reviewer_and_browser() {
1701 let (root, mut scheduler, mut agents) = scheduler();
1702 let tree_a = root.join("impl-a");
1703 let tree_b = root.join("impl-b");
1704 std::fs::create_dir_all(&tree_a).unwrap();
1705 std::fs::create_dir_all(&tree_b).unwrap();
1706 let ids = scheduler
1707 .create_crew(
1708 &mut agents,
1709 "add settings toggle",
1710 Some(root.clone()),
1711 vec![tree_a.clone(), tree_b.clone()],
1712 false,
1713 )
1714 .unwrap();
1715 assert_eq!(ids.len(), 7);
1716 let snapshots = ids
1717 .iter()
1718 .map(|id| scheduler.snapshot(&mut agents, id).unwrap())
1719 .collect::<Vec<_>>();
1720 let roles = snapshots
1721 .iter()
1722 .map(|snapshot| snapshot.role.as_str())
1723 .collect::<Vec<_>>();
1724 assert_eq!(
1725 roles,
1726 [
1727 "architect",
1728 "implementer",
1729 "implementer",
1730 "tester",
1731 "tester",
1732 "reviewer",
1733 "browser"
1734 ]
1735 );
1736 assert_eq!(snapshots[1].worktree, tree_a);
1737 assert_eq!(snapshots[2].worktree, tree_b);
1738 assert_eq!(snapshots[3].worktree, tree_a);
1739 assert_eq!(snapshots[4].worktree, tree_b);
1740 assert!(snapshots[1].dependencies.contains(&ids[0]));
1741 assert!(snapshots[2].dependencies.contains(&ids[0]));
1742 assert!(snapshots[3].dependencies.contains(&ids[1]));
1743 assert!(snapshots[4].dependencies.contains(&ids[2]));
1744 assert!(snapshots[5].dependencies.contains(&ids[1]));
1745 assert!(snapshots[5].dependencies.contains(&ids[2]));
1746 assert!(snapshots[6].dependencies.contains(&ids[3]));
1747 assert!(snapshots[6].dependencies.contains(&ids[4]));
1748 assert!(snapshots[1].prompt.contains("isolated worktree"));
1749 assert!(snapshots[1].prompt.contains("1 of 2"));
1750 assert!(snapshots[2].prompt.contains("2 of 2"));
1751 assert!(!snapshots[5].unrestricted);
1752 assert!(snapshots[0].prompt.contains("Do not implement"));
1753 assert!(snapshots[5].prompt.contains("cannot write"));
1754 assert!(matches!(
1755 snapshots[6].verification,
1756 VerificationRequirement::BrowserWorkflow { .. }
1757 ));
1758 std::fs::remove_dir_all(root).unwrap();
1759 }
1760
1761 #[test]
1762 fn crew_wake_persists_and_reloads_from_glass_crew() {
1763 let root = std::env::temp_dir().join(format!(
1764 "glass-crew-wake-{}-{}",
1765 std::process::id(),
1766 std::time::SystemTime::now()
1767 .duration_since(std::time::UNIX_EPOCH)
1768 .unwrap()
1769 .as_nanos()
1770 ));
1771 std::fs::create_dir_all(&root).unwrap();
1772 let wake = CrewWake {
1773 id: "add-settings-toggle".into(),
1774 goal: "add settings toggle".into(),
1775 worktree: Some(
1776 root.join(".glass/worktrees/add-settings-toggle")
1777 .display()
1778 .to_string(),
1779 ),
1780 checkpoint: "before-crew:add settings toggle".into(),
1781 created_at_ms: 1,
1782 tasks: vec![CrewWakeMember {
1783 id: "task-0001".into(),
1784 role: "architect".into(),
1785 title: "architect: add settings toggle".into(),
1786 state: "queued".into(),
1787 worktree: None,
1788 }],
1789 verify: "PROOF ✓\n url /settings".into(),
1790 tests: "cargo passed · 12 ms · exit 0".into(),
1791 page: "url http://localhost:3000".into(),
1792 diff: "diff --git a/src/lib.rs b/src/lib.rs".into(),
1793 accept: "proposal-1".into(),
1794 };
1795 persist_crew_wake(&root, &wake).unwrap();
1796 let loaded = load_latest_crew_wake(&root).expect("latest wake");
1797 assert_eq!(loaded, wake);
1798 let rendered = loaded.render();
1799 assert!(rendered.contains("WAKE add-settings-toggle"));
1800 assert!(rendered.contains("VERIFY"));
1801 assert!(rendered.contains("TESTS"));
1802 assert!(rendered.contains("PAGE"));
1803 assert!(rendered.contains("DIFF"));
1804 assert!(rendered.contains("accept proposal-1"));
1805 let legacy = serde_json::from_str::<CrewWake>(
1806 r#"{"id":"legacy","goal":"g","checkpoint":"c","createdAtMs":1,"tasks":[]}"#,
1807 )
1808 .unwrap();
1809 assert!(legacy.diff.is_empty());
1810 assert_eq!(legacy.accept, "");
1811 std::fs::remove_dir_all(root).unwrap();
1812 }
1813}