Skip to main content

glass_dev/
tasks.rs

1//! Autonomous, verified task DAG scheduling above resident Pi agents.
2
3use 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    /// Human-readable label for terminal and TUI surfaces.
56    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    /// Resolve a deterministic project verifier when the task is created.
116    #[default]
117    Inferred,
118    /// Deliberately accept agent settlement without deterministic proof.
119    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/// Durable overnight-crew artifact written under `{root}/.glass/crew`.
309#[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/// Live TUI evidence folded into a crew wake on review.
342#[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
401/// Persist a crew wake object and replace `{root}/.glass/crew/latest.json`.
402pub 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
411/// Load the most recently queued overnight crew, if one exists.
412pub 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    /// Queue the overnight factory crew with isolated implementer worktrees.
538    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}