Skip to main content

eidos_kernel/workflow/
schema.rs

1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Serialize};
4
5/// The kind of work a task node represents.
6#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
7#[serde(rename_all = "snake_case")]
8pub enum TaskOperator {
9    ReadContext,
10    Decompose,
11    Edit,
12    Check,
13    Review,
14    ProposeDoc,
15    HumanApproval,
16}
17
18/// Runtime state vocabulary for future executors. The planner emits `Pending` only.
19#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
20#[serde(rename_all = "snake_case")]
21pub enum TaskState {
22    #[default]
23    Pending,
24    Ready,
25    Running,
26    Blocked,
27    Passed,
28    Failed,
29    Skipped,
30}
31
32/// Coarse execution risk, used by future schedulers to gate writes/tests differently from reads.
33#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
34#[serde(rename_all = "snake_case")]
35pub enum TaskRisk {
36    Low,
37    #[default]
38    Medium,
39    High,
40}
41
42/// Deterministic retry policy metadata. This is descriptive in v0.1; no executor consumes it yet.
43#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
44pub struct RetryPolicy {
45    pub max_attempts: u8,
46    pub backoff_ms: u64,
47}
48
49impl Default for RetryPolicy {
50    fn default() -> Self {
51        Self {
52            max_attempts: 1,
53            backoff_ms: 0,
54        }
55    }
56}
57
58/// A receipt-backed context item that can seed a grounded task brief.
59#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
60pub struct TaskContextItem {
61    pub id: String,
62    pub title: String,
63    pub kind: String,
64    pub source: String,
65}
66
67/// One node in a task DAG.
68#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
69pub struct TaskNode {
70    pub id: String,
71    pub title: String,
72    pub operator: TaskOperator,
73    #[serde(default)]
74    pub state: TaskState,
75    #[serde(default)]
76    pub depends_on: Vec<String>,
77    #[serde(default)]
78    pub inputs: Vec<String>,
79    #[serde(default)]
80    pub outputs: Vec<String>,
81    #[serde(default)]
82    pub required_checks: Vec<String>,
83    #[serde(default)]
84    pub tools: Vec<String>,
85    #[serde(default)]
86    pub retry: RetryPolicy,
87    #[serde(default)]
88    pub risk: TaskRisk,
89    #[serde(default)]
90    pub receipts: Vec<String>,
91}
92
93/// An internal acyclic decomposition for an agent task brief.
94#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
95pub struct TaskDag {
96    pub id: String,
97    pub title: String,
98    pub nodes: Vec<TaskNode>,
99}
100
101/// A single state transition, with optional evidence attached by a future executor/reviewer.
102#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
103pub struct TaskEvent {
104    pub task_id: String,
105    pub to: TaskState,
106    #[serde(default)]
107    pub evidence: Vec<String>,
108    #[serde(default)]
109    pub note: Option<String>,
110}
111
112/// A deterministic readiness projection for an internal decomposition.
113#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
114pub struct TaskRun {
115    pub dag_id: String,
116    pub states: BTreeMap<String, TaskState>,
117    #[serde(default)]
118    pub events: Vec<TaskEvent>,
119}