agent_top_core/harness/
mod.rs

1//! Per-harness transcript readers.
2//!
3//! Each harness writes a different append-only log. A `SessionTracker` turns
4//! one of those logs into the harness-neutral `SessionSummary` incrementally.
5
6pub mod claude;
7pub mod codex;
8
9use crate::model::{Activity, Harness, TokenUsage, ToolSpan};
10use std::collections::VecDeque;
11use std::path::{Path, PathBuf};
12use std::time::SystemTime;
13
14#[derive(Debug, Clone, Default)]
15pub struct SessionSummary {
16    pub harness: Option<Harness>,
17    pub session_id: Option<String>,
18    pub cwd: Option<PathBuf>,
19    pub model: Option<String>,
20    pub harness_version: Option<String>,
21    pub usage: TokenUsage,
22    pub cost_usd: f64,
23    pub unpriced_tokens: u64,
24    pub turns: u64,
25    pub subagent_turns: u64,
26    pub tool_calls: u64,
27    pub spans: SpanLog,
28    pub activity: Activity,
29    pub started_at: Option<SystemTime>,
30    pub last_activity: Option<SystemTime>,
31}
32
33/// Spans kept per session. A screenful of waterfall is a few dozen rows; the
34/// rest is history nobody scrolls to in a live view, and every span costs a
35/// clone on each refresh.
36pub const MAX_SPANS: usize = 128;
37
38/// A bounded, in-order log of tool spans, built by pairing a harness's
39/// "call started" and "call finished" records by call id.
40///
41/// Records arrive interleaved and out of order (agents run tools in parallel),
42/// so a span is closed by searching back for the still-open span with that id
43/// rather than assuming the most recent one.
44#[derive(Debug, Clone, Default)]
45pub struct SpanLog {
46    spans: VecDeque<ToolSpan>,
47}
48
49impl SpanLog {
50    /// Record the start of a call. Ignored when that id is already open, so a
51    /// transcript line replayed by the harness does not double-count.
52    pub fn open(&mut self, id: String, name: String, at: SystemTime, sidechain: bool) {
53        if id.is_empty() || self.spans.iter().any(|s| s.is_open() && s.id == id) {
54            return;
55        }
56        if self.spans.len() == MAX_SPANS {
57            self.spans.pop_front();
58        }
59        self.spans.push_back(ToolSpan { id, name, started_at: at, duration_ms: None, sidechain, error: false });
60    }
61
62    /// Close the open call with this id. A result whose call scrolled out of
63    /// the window, or that we never saw start, is dropped.
64    pub fn close(&mut self, id: &str, at: SystemTime, error: bool) {
65        let Some(s) = self.spans.iter_mut().rev().find(|s| s.is_open() && s.id == id) else { return };
66        s.duration_ms = Some(at.duration_since(s.started_at).map(|d| d.as_millis() as u64).unwrap_or(0));
67        s.error = error;
68    }
69
70    pub fn len(&self) -> usize {
71        self.spans.len()
72    }
73
74    pub fn is_empty(&self) -> bool {
75        self.spans.is_empty()
76    }
77
78    /// Oldest first.
79    pub fn iter(&self) -> impl Iterator<Item = &ToolSpan> {
80        self.spans.iter()
81    }
82
83    pub fn to_vec(&self) -> Vec<ToolSpan> {
84        self.spans.iter().cloned().collect()
85    }
86}
87
88pub trait SessionTracker {
89    /// Ingest whatever was appended since the last call. Returns true when
90    /// there is still unread data (the byte budget was exhausted).
91    fn refresh(&mut self) -> anyhow::Result<bool>;
92    fn summary(&self) -> &SessionSummary;
93    fn path(&self) -> &Path;
94}
95
96/// Bytes ingested per tracker per refresh. Keeps a cold start on a 100 MB
97/// transcript from freezing the first frame; the rest streams in on later ticks.
98pub const REFRESH_BUDGET_BYTES: usize = 8 * 1024 * 1024;
99
100/// Parse an RFC 3339 timestamp like `2026-09-03T07:15:34.123Z` into SystemTime
101/// without pulling in a date crate. Only the UTC `Z` form is handled, which is
102/// what both Claude Code and Codex write.
103pub fn parse_rfc3339_utc(s: &str) -> Option<SystemTime> {
104    let s = s.strip_suffix('Z')?;
105    let (date, time) = s.split_once('T')?;
106    let mut d = date.split('-');
107    let (y, mo, da) = (d.next()?.parse::<i64>().ok()?, d.next()?.parse::<u32>().ok()?, d.next()?.parse::<u32>().ok()?);
108    let mut t = time.split(':');
109    let (h, mi) = (t.next()?.parse::<u64>().ok()?, t.next()?.parse::<u64>().ok()?);
110    let sec_str = t.next()?;
111    let (sec, frac) = match sec_str.split_once('.') {
112        Some((s, f)) => (s.parse::<u64>().ok()?, f),
113        None => (sec_str.parse::<u64>().ok()?, ""),
114    };
115    let nanos: u32 = if frac.is_empty() {
116        0
117    } else {
118        let mut f = frac.to_string();
119        f.truncate(9);
120        while f.len() < 9 {
121            f.push('0');
122        }
123        f.parse().ok()?
124    };
125    let days = days_from_civil(y, mo, da);
126    let secs = days * 86_400 + (h * 3600 + mi * 60 + sec) as i64;
127    if secs < 0 {
128        return None;
129    }
130    Some(SystemTime::UNIX_EPOCH + std::time::Duration::new(secs as u64, nanos))
131}
132
133// Howard Hinnant's days-from-civil algorithm.
134fn days_from_civil(y: i64, m: u32, d: u32) -> i64 {
135    let y = if m <= 2 { y - 1 } else { y };
136    let era = if y >= 0 { y } else { y - 399 } / 400;
137    let yoe = y - era * 400;
138    let mp = (m as i64 + 9) % 12;
139    let doy = (153 * mp + 2) / 5 + d as i64 - 1;
140    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
141    era * 146_097 + doe - 719_468
142}
143
144#[cfg(test)]
145mod tests {
146    use super::*;
147    use std::time::Duration;
148
149    fn at(secs: u64) -> SystemTime {
150        SystemTime::UNIX_EPOCH + Duration::from_secs(secs)
151    }
152
153    #[test]
154    fn pairs_spans_by_id_out_of_order() {
155        let mut log = SpanLog::default();
156        log.open("a".into(), "Bash".into(), at(10), false);
157        log.open("b".into(), "Read".into(), at(11), true);
158        // Replay of the same start line must not open a second span.
159        log.open("a".into(), "Bash".into(), at(10), false);
160        // Results come back in the other order.
161        log.close("b", at(12), false);
162        log.close("a", at(14), true);
163        // A result with no matching call is ignored.
164        log.close("zzz", at(15), false);
165        let v = log.to_vec();
166        assert_eq!(v.len(), 2);
167        assert_eq!(v[0].name, "Bash");
168        assert_eq!(v[0].duration_ms, Some(4_000));
169        assert!(v[0].error);
170        assert_eq!(v[1].duration_ms, Some(1_000));
171        assert!(v[1].sidechain);
172        assert!(!v[1].error);
173    }
174
175    #[test]
176    fn keeps_the_newest_spans_and_reports_open_ones() {
177        let mut log = SpanLog::default();
178        for i in 0..(MAX_SPANS + 10) {
179            log.open(format!("id{i}"), "T".into(), at(i as u64), false);
180            log.close(&format!("id{i}"), at(i as u64), false);
181        }
182        assert_eq!(log.len(), MAX_SPANS);
183        assert_eq!(log.iter().next().unwrap().id, "id10");
184        log.open("live".into(), "Bash".into(), at(500), false);
185        let last = log.to_vec().pop().unwrap();
186        assert!(last.is_open());
187        assert_eq!(last.elapsed_ms(at(503)), 3_000);
188    }
189
190    #[test]
191    fn parses_timestamps() {
192        let t = parse_rfc3339_utc("1970-01-02T00:00:00.000Z").unwrap();
193        assert_eq!(t, SystemTime::UNIX_EPOCH + Duration::from_secs(86_400));
194        let t = parse_rfc3339_utc("2026-09-03T07:15:34.5Z").unwrap();
195        let secs = t.duration_since(SystemTime::UNIX_EPOCH).unwrap();
196        assert_eq!(secs.as_secs(), 1_788_419_734);
197        assert_eq!(secs.subsec_millis(), 500);
198        assert!(parse_rfc3339_utc("nope").is_none());
199    }
200}
agent_top_core/harness/mod.rs

agent_top_core/harness/
mod.rs
