codetether-agent 4.6.0

A2A-native AI coding agent for the CodeTether ecosystem
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! Materialized view of a task log: current goal + open tasks.

use chrono::{DateTime, Utc};
use std::collections::BTreeMap;

use super::event::{TaskEvent, TaskStatus};

/// The session's currently-declared goal.
#[derive(Clone, Debug)]
pub struct Goal {
    pub objective: String,
    pub success_criteria: Vec<String>,
    pub forbidden: Vec<String>,
    pub set_at: DateTime<Utc>,
    pub last_reaffirmed_at: DateTime<Utc>,
}

/// A task with its latest status.
#[derive(Clone, Debug)]
pub struct Task {
    pub id: String,
    pub content: String,
    pub parent_id: Option<String>,
    pub status: TaskStatus,
    pub last_note: Option<String>,
}

/// Folded state derived from a [`super::TaskLog`].
#[derive(Clone, Debug, Default)]
pub struct TaskState {
    pub goal: Option<Goal>,
    pub tasks: BTreeMap<String, Task>,
    pub tool_calls_since_reaffirm: u32,
    pub errors_since_reaffirm: u32,
}

impl TaskState {
    /// Fold a sequence of events into current state.
    pub fn from_log(events: &[TaskEvent]) -> Self {
        let mut state = Self::default();
        for ev in events {
            state.apply(ev);
        }
        state
    }

    /// Tasks in a non-terminal state, in id order.
    pub fn open_tasks(&self) -> Vec<&Task> {
        self.tasks
            .values()
            .filter(|t| matches!(t.status, TaskStatus::Pending | TaskStatus::InProgress))
            .collect()
    }

    fn apply(&mut self, ev: &TaskEvent) {
        match ev {
            TaskEvent::GoalSet {
                at,
                objective,
                success_criteria,
                forbidden,
            } => {
                self.goal = Some(Goal {
                    objective: objective.clone(),
                    success_criteria: success_criteria.clone(),
                    forbidden: forbidden.clone(),
                    set_at: *at,
                    last_reaffirmed_at: *at,
                });
            }
            TaskEvent::GoalReaffirmed { at, .. } => {
                if let Some(g) = self.goal.as_mut() {
                    g.last_reaffirmed_at = *at;
                }
                self.tool_calls_since_reaffirm = 0;
                self.errors_since_reaffirm = 0;
            }
            TaskEvent::GoalCleared { .. } => {
                self.goal = None;
            }
            TaskEvent::TaskAdded {
                id,
                content,
                parent_id,
                ..
            } => {
                self.tasks.insert(
                    id.clone(),
                    Task {
                        id: id.clone(),
                        content: content.clone(),
                        parent_id: parent_id.clone(),
                        status: TaskStatus::Pending,
                        last_note: None,
                    },
                );
            }
            TaskEvent::TaskStatus {
                id, status, note, ..
            } => {
                if let Some(t) = self.tasks.get_mut(id) {
                    t.status = status.clone();
                    t.last_note = note.clone();
                }
            }
            TaskEvent::DriftDetected { .. } => {}
        }
    }
}