use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use crate::model::Pane;
pub const SUBAGENT_ROSTER_TOKEN: &str = "vsh-subagents";
pub const ROSTER_VERSION: u32 = 1;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SubagentStatus {
Working,
Idle,
Done,
#[default]
Unknown,
}
impl SubagentStatus {
pub fn as_str(self) -> &'static str {
match self {
Self::Working => "working",
Self::Idle => "idle",
Self::Done => "done",
Self::Unknown => "unknown",
}
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Subagent {
pub name: String,
pub id: Option<String>,
pub kind: Option<String>,
pub subject: Option<String>,
pub status: SubagentStatus,
pub started_unix_ms: Option<u64>,
pub tokens: Option<u64>,
pub cwd: Option<String>,
}
impl Subagent {
pub fn working_dir(&self) -> Option<&Path> {
self.cwd
.as_deref()
.filter(|value| !value.is_empty())
.map(Path::new)
}
pub fn key(&self) -> &str {
self.id
.as_deref()
.filter(|value| !value.is_empty())
.unwrap_or(&self.name)
}
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct SubagentRoster {
pub version: u32,
pub updated_unix_ms: u64,
pub subagents: Vec<Subagent>,
#[serde(skip_serializing_if = "Option::is_none")]
pub cwd: Option<String>,
}
impl SubagentRoster {
pub fn working_dir(&self) -> Option<&Path> {
self.cwd
.as_deref()
.filter(|value| !value.is_empty())
.map(Path::new)
}
pub fn understood(&self) -> bool {
self.version == 0 || self.version <= ROSTER_VERSION
}
}
pub fn roster_path(pane: &Pane) -> Option<PathBuf> {
pane.tokens
.get(SUBAGENT_ROSTER_TOKEN)
.and_then(Option::as_deref)
.filter(|value| !value.is_empty())
.map(PathBuf::from)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_pane_with_no_token_has_no_roster() {
assert_eq!(roster_path(&Pane::default()), None);
}
#[test]
fn an_erased_or_empty_token_is_not_a_path() {
let mut pane = Pane::default();
pane.tokens.insert(SUBAGENT_ROSTER_TOKEN.into(), None);
assert_eq!(roster_path(&pane), None);
pane.tokens
.insert(SUBAGENT_ROSTER_TOKEN.into(), Some(String::new()));
assert_eq!(roster_path(&pane), None);
}
#[test]
fn the_token_is_read_as_a_path() {
let mut pane = Pane::default();
pane.tokens.insert(
SUBAGENT_ROSTER_TOKEN.into(),
Some("/Users/operator/.claude/herdr/subagents/wA-p1.json".into()),
);
assert_eq!(
roster_path(&pane),
Some(PathBuf::from("/Users/operator/.claude/herdr/subagents/wA-p1.json"))
);
}
#[test]
fn a_realistic_roster_path_fits_the_eighty_character_token_limit() {
let path = format!(
"{}/.claude/herdr/subagents/w65378006dc6cb1-p1.json",
"/Users/operator"
);
assert!(path.len() <= 80, "{} chars: {path}", path.len());
}
#[test]
fn a_roster_survives_a_round_trip() {
let roster = SubagentRoster {
version: ROSTER_VERSION,
updated_unix_ms: 1_785_000_000_000,
subagents: vec![Subagent {
name: "explorer".into(),
id: Some("a1b2".into()),
kind: Some("general-purpose".into()),
subject: Some("Build agent-aware explorer".into()),
status: SubagentStatus::Working,
started_unix_ms: Some(1_785_000_000_000),
tokens: Some(120_000),
cwd: Some("/repo/_worktrees/explorer".into()),
}],
cwd: Some("/repo".into()),
};
let back: SubagentRoster =
serde_json::from_str(&serde_json::to_string(&roster).unwrap()).unwrap();
assert_eq!(back.subagents[0].name, "explorer");
assert_eq!(back.subagents[0].status, SubagentStatus::Working);
assert_eq!(
back.subagents[0].working_dir(),
Some(Path::new("/repo/_worktrees/explorer"))
);
}
#[test]
fn a_roster_with_only_names_still_parses() {
let roster: SubagentRoster =
serde_json::from_str(r#"{"subagents":[{"name":"release"}]}"#).unwrap();
assert!(roster.understood());
assert_eq!(roster.subagents[0].name, "release");
assert_eq!(roster.subagents[0].status, SubagentStatus::Unknown);
assert_eq!(roster.subagents[0].working_dir(), None);
assert_eq!(roster.subagents[0].key(), "release");
}
#[test]
fn an_id_is_preferred_over_a_name_as_the_state_key() {
let subagent = Subagent {
name: "release".into(),
id: Some("a9".into()),
..Subagent::default()
};
assert_eq!(subagent.key(), "a9");
}
#[test]
fn a_roster_from_a_newer_writer_is_refused_rather_than_guessed_at() {
let roster = SubagentRoster {
version: ROSTER_VERSION + 1,
..SubagentRoster::default()
};
assert!(!roster.understood());
}
}