The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: add ecc2 agent profiles
Affaan Mustafa1e4d6a416106
diff --git a/ecc2/src/config/mod.rs b/ecc2/src/config/mod.rsindex ffe9cdbcb..938903a11 100644--- a/ecc2/src/config/mod.rs+++ b/ecc2/src/config/mod.rs@@ -1,6 +1,7 @@use anyhow::{Context, Result};use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};use serde::{Deserialize, Serialize};+use std::collections::BTreeMap;use std::path::PathBuf;use crate::notifications::{@@ -48,6 +49,35 @@ pub struct ConflictResolutionConfig {pub notify_lead: bool,}+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]+#[serde(default)]+pub struct AgentProfileConfig {+ pub inherits: Option<String>,+ pub agent: Option<String>,+ pub model: Option<String>,+ pub allowed_tools: Vec<String>,+ pub disallowed_tools: Vec<String>,+ pub permission_mode: Option<String>,+ pub add_dirs: Vec<PathBuf>,+ pub max_budget_usd: Option<f64>,+ pub token_budget: Option<u64>,+ pub append_system_prompt: Option<String>,+}++#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]+pub struct ResolvedAgentProfile {+ pub profile_name: String,+ pub agent: Option<String>,+ pub model: Option<String>,+ pub allowed_tools: Vec<String>,+ pub disallowed_tools: Vec<String>,+ pub permission_mode: Option<String>,+ pub add_dirs: Vec<PathBuf>,+ pub max_budget_usd: Option<f64>,+ pub token_budget: Option<u64>,+ pub append_system_prompt: Option<String>,+}+#[derive(Debug, Clone, Serialize, Deserialize)]#[serde(default)]pub struct Config {@@ -61,6 +91,8 @@ pub struct Config {pub heartbeat_interval_secs: u64,pub auto_terminate_stale_sessions: bool,pub default_agent: String,+ pub default_agent_profile: Option<String>,+ pub agent_profiles: BTreeMap<String, AgentProfileConfig>,pub auto_dispatch_unread_handoffs: bool,pub auto_dispatch_limit_per_session: usize,pub auto_create_worktrees: bool,@@ -122,6 +154,8 @@ impl Default for Config {heartbeat_interval_secs: 30,auto_terminate_stale_sessions: false,default_agent: "claude".to_string(),+ default_agent_profile: None,+ agent_profiles: BTreeMap::new(),auto_dispatch_unread_handoffs: false,auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,@@ -180,6 +214,41 @@ impl Config {self.budget_alert_thresholds.sanitized()}+ pub fn resolve_agent_profile(&self, name: &str) -> Result<ResolvedAgentProfile> {+ let mut chain = Vec::new();+ self.resolve_agent_profile_inner(name, &mut chain)+ }++ fn resolve_agent_profile_inner(+ &self,+ name: &str,+ chain: &mut Vec<String>,+ ) -> Result<ResolvedAgentProfile> {+ if chain.iter().any(|existing| existing == name) {+ chain.push(name.to_string());+ anyhow::bail!(+ "agent profile inheritance cycle: {}",+ chain.join(" -> ")+ );+ }++ let profile = self+ .agent_profiles+ .get(name)+ .ok_or_else(|| anyhow::anyhow!("Unknown agent profile: {name}"))?;++ chain.push(name.to_string());+ let mut resolved = if let Some(parent) = profile.inherits.as_deref() {+ self.resolve_agent_profile_inner(parent, chain)?+ } else {+ ResolvedAgentProfile::default()+ };+ chain.pop();++ resolved.apply(name, profile);+ Ok(resolved)+ }+pub fn load() -> Result<Self> {let global_paths = Self::global_config_paths();let project_paths = std::env::current_dir()@@ -437,6 +506,50 @@ impl Default for ConflictResolutionConfig {}}+impl ResolvedAgentProfile {+ fn apply(&mut self, profile_name: &str, config: &AgentProfileConfig) {+ self.profile_name = profile_name.to_string();+ if let Some(agent) = config.agent.as_ref() {+ self.agent = Some(agent.clone());+ }+ if let Some(model) = config.model.as_ref() {+ self.model = Some(model.clone());+ }+ merge_unique(&mut self.allowed_tools, &config.allowed_tools);+ merge_unique(&mut self.disallowed_tools, &config.disallowed_tools);+ if let Some(permission_mode) = config.permission_mode.as_ref() {+ self.permission_mode = Some(permission_mode.clone());+ }+ merge_unique(&mut self.add_dirs, &config.add_dirs);+ if let Some(max_budget_usd) = config.max_budget_usd {+ self.max_budget_usd = Some(max_budget_usd);+ }+ if let Some(token_budget) = config.token_budget {+ self.token_budget = Some(token_budget);+ }+ self.append_system_prompt = match (+ self.append_system_prompt.take(),+ config.append_system_prompt.as_ref(),+ ) {+ (Some(parent), Some(child)) => Some(format!("{parent}\n\n{child}")),+ (Some(parent), None) => Some(parent),+ (None, Some(child)) => Some(child.clone()),+ (None, None) => None,+ };+ }+}++fn merge_unique<T>(base: &mut Vec<T>, additions: &[T])+where+ T: Clone + PartialEq,+{+ for value in additions {+ if !base.contains(value) {+ base.push(value.clone());+ }+ }+}+impl BudgetAlertThresholds {pub fn sanitized(self) -> Self {let values = [self.advisory, self.warning, self.critical];@@ -461,6 +574,7 @@ mod tests {PaneLayout,};use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};+ use std::path::PathBuf;use uuid::Uuid;#[test]@@ -806,6 +920,65 @@ notify_lead = false);}+ #[test]+ fn agent_profiles_resolve_inheritance_and_defaults() {+ let config: Config = toml::from_str(+ r#"+default_agent_profile = "reviewer"++[agent_profiles.base]+model = "sonnet"+allowed_tools = ["Read"]+permission_mode = "plan"+add_dirs = ["docs"]+append_system_prompt = "Be careful."++[agent_profiles.reviewer]+inherits = "base"+allowed_tools = ["Edit"]+disallowed_tools = ["Bash"]+token_budget = 1200+append_system_prompt = "Review thoroughly."+"#,+ )+ .unwrap();++ let profile = config.resolve_agent_profile("reviewer").unwrap();+ assert_eq!(config.default_agent_profile.as_deref(), Some("reviewer"));+ assert_eq!(profile.profile_name, "reviewer");+ assert_eq!(profile.model.as_deref(), Some("sonnet"));+ assert_eq!(profile.allowed_tools, vec!["Read", "Edit"]);+ assert_eq!(profile.disallowed_tools, vec!["Bash"]);+ assert_eq!(profile.permission_mode.as_deref(), Some("plan"));+ assert_eq!(profile.add_dirs, vec![PathBuf::from("docs")]);+ assert_eq!(profile.token_budget, Some(1200));+ assert_eq!(+ profile.append_system_prompt.as_deref(),+ Some("Be careful.\n\nReview thoroughly.")+ );+ }++ #[test]+ fn agent_profile_resolution_rejects_inheritance_cycles() {+ let config: Config = toml::from_str(+ r#"+[agent_profiles.a]+inherits = "b"++[agent_profiles.b]+inherits = "a"+"#,+ )+ .unwrap();++ let error = config+ .resolve_agent_profile("a")+ .expect_err("profile inheritance cycles must fail");+ assert!(error+ .to_string()+ .contains("agent profile inheritance cycle"));+ }+#[test]fn completion_summary_notifications_deserialize_from_toml() {let config: Config = toml::from_str(diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex 756dadcbd..ee1fcb500 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -53,6 +53,9 @@ enum Commands {/// Agent type (claude, codex, custom)#[arg(short, long, default_value = "claude")]agent: String,+ /// Agent profile defined in ecc2.toml+ #[arg(long)]+ profile: Option<String>,#[command(flatten)]worktree: WorktreePolicyArgs,/// Source session to delegate from@@ -69,6 +72,9 @@ enum Commands {/// Agent type (claude, codex, custom)#[arg(short, long, default_value = "claude")]agent: String,+ /// Agent profile defined in ecc2.toml+ #[arg(long)]+ profile: Option<String>,#[command(flatten)]worktree: WorktreePolicyArgs,},@@ -82,6 +88,9 @@ enum Commands {/// Agent type (claude, codex, custom)#[arg(short, long, default_value = "claude")]agent: String,+ /// Agent profile defined in ecc2.toml+ #[arg(long)]+ profile: Option<String>,#[command(flatten)]worktree: WorktreePolicyArgs,},@@ -381,6 +390,7 @@ async fn main() -> Result<()> {Some(Commands::Start {task,agent,+ profile,worktree,from_session,}) => {@@ -394,18 +404,34 @@ async fn main() -> Result<()> {} else {None};- let session_id = session::manager::create_session_with_grouping(- &db,- &cfg,- &task,- &agent,- use_worktree,- session::SessionGrouping {- project: source.as_ref().map(|session| session.project.clone()),- task_group: source.as_ref().map(|session| session.task_group.clone()),- },- )- .await?;+ let grouping = session::SessionGrouping {+ project: source.as_ref().map(|session| session.project.clone()),+ task_group: source.as_ref().map(|session| session.task_group.clone()),+ };+ let session_id = if let Some(source) = source.as_ref() {+ session::manager::create_session_from_source_with_profile_and_grouping(+ &db,+ &cfg,+ &task,+ &agent,+ use_worktree,+ profile.as_deref(),+ &source.id,+ grouping,+ )+ .await?+ } else {+ session::manager::create_session_with_profile_and_grouping(+ &db,+ &cfg,+ &task,+ &agent,+ use_worktree,+ profile.as_deref(),+ grouping,+ )+ .await?+ };if let Some(source) = source {let from_id = source.id;send_handoff_message(&db, &from_id, &session_id)?;@@ -416,6 +442,7 @@ async fn main() -> Result<()> {from_session,task,agent,+ profile,worktree,}) => {let use_worktree = worktree.resolve(&cfg);@@ -431,12 +458,14 @@ async fn main() -> Result<()> {)});- let session_id = session::manager::create_session_with_grouping(+ let session_id = session::manager::create_session_from_source_with_profile_and_grouping(&db,&cfg,&task,&agent,use_worktree,+ profile.as_deref(),+ &source.id,session::SessionGrouping {project: Some(source.project.clone()),task_group: Some(source.task_group.clone()),@@ -454,13 +483,22 @@ async fn main() -> Result<()> {from_session,task,agent,+ profile,worktree,}) => {let use_worktree = worktree.resolve(&cfg);let lead_id = resolve_session_id(&db, &from_session)?;- let outcome =- session::manager::assign_session(&db, &cfg, &lead_id, &task, &agent, use_worktree)- .await?;+ let outcome = session::manager::assign_session_with_profile_and_grouping(+ &db,+ &cfg,+ &lead_id,+ &task,+ &agent,+ use_worktree,+ profile.as_deref(),+ session::SessionGrouping::default(),+ )+ .await?;if session::manager::assignment_action_routes_work(outcome.action) {println!("Assignment routed: {} -> {} ({})",diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 8311a4f27..28669e9df 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -11,7 +11,7 @@ use super::runtime::capture_command_output;use super::store::StateStore;use super::{default_project_label, default_task_group_label, normalize_group_label, Session,- SessionGrouping, SessionMetrics, SessionState,+ SessionAgentProfile, SessionGrouping, SessionMetrics, SessionState,};use crate::comms::{self, MessageType};use crate::config::Config;@@ -25,12 +25,13 @@ pub async fn create_session(agent_type: &str,use_worktree: bool,) -> Result<String> {- create_session_with_grouping(+ create_session_with_profile_and_grouping(db,cfg,task,agent_type,use_worktree,+ None,SessionGrouping::default(),).await@@ -43,6 +44,27 @@ pub async fn create_session_with_grouping(agent_type: &str,use_worktree: bool,grouping: SessionGrouping,+) -> Result<String> {+ create_session_with_profile_and_grouping(+ db,+ cfg,+ task,+ agent_type,+ use_worktree,+ None,+ grouping,+ )+ .await+}++pub async fn create_session_with_profile_and_grouping(+ db: &StateStore,+ cfg: &Config,+ task: &str,+ agent_type: &str,+ use_worktree: bool,+ profile_name: Option<&str>,+ grouping: SessionGrouping,) -> Result<String> {let repo_root =std::env::current_dir().context("Failed to resolve current working directory")?;@@ -53,6 +75,34 @@ pub async fn create_session_with_grouping(agent_type,use_worktree,&repo_root,+ profile_name,+ None,+ grouping,+ )+ .await+}++pub async fn create_session_from_source_with_profile_and_grouping(+ db: &StateStore,+ cfg: &Config,+ task: &str,+ agent_type: &str,+ use_worktree: bool,+ profile_name: Option<&str>,+ source_session_id: &str,+ grouping: SessionGrouping,+) -> Result<String> {+ let repo_root =+ std::env::current_dir().context("Failed to resolve current working directory")?;+ queue_session_in_dir(+ db,+ cfg,+ task,+ agent_type,+ use_worktree,+ &repo_root,+ profile_name,+ Some(source_session_id),grouping,).await@@ -66,6 +116,7 @@ pub fn get_status(db: &StateStore, id: &str) -> Result<SessionStatus> {let session = resolve_session(db, id)?;let session_id = session.id.clone();Ok(SessionStatus {+ profile: db.get_session_profile(&session_id)?,session,parent_session: db.latest_task_handoff_source(&session_id)?,delegated_children: db.delegated_children(&session_id, 5)?,@@ -159,13 +210,14 @@ pub async fn assign_session(agent_type: &str,use_worktree: bool,) -> Result<AssignmentOutcome> {- assign_session_with_grouping(+ assign_session_with_profile_and_grouping(db,cfg,lead_id,task,agent_type,use_worktree,+ None,SessionGrouping::default(),).await@@ -179,6 +231,29 @@ pub async fn assign_session_with_grouping(agent_type: &str,use_worktree: bool,grouping: SessionGrouping,+) -> Result<AssignmentOutcome> {+ assign_session_with_profile_and_grouping(+ db,+ cfg,+ lead_id,+ task,+ agent_type,+ use_worktree,+ None,+ grouping,+ )+ .await+}++pub async fn assign_session_with_profile_and_grouping(+ db: &StateStore,+ cfg: &Config,+ lead_id: &str,+ task: &str,+ agent_type: &str,+ use_worktree: bool,+ profile_name: Option<&str>,+ grouping: SessionGrouping,) -> Result<AssignmentOutcome> {let repo_root =std::env::current_dir().context("Failed to resolve current working directory")?;@@ -191,6 +266,7 @@ pub async fn assign_session_with_grouping(use_worktree,&repo_root,&std::env::current_exe().context("Failed to resolve ECC executable path")?,+ profile_name,grouping,).await@@ -228,6 +304,7 @@ pub async fn drain_inbox(use_worktree,&repo_root,&runner_program,+ None,SessionGrouping::default(),).await?;@@ -434,6 +511,7 @@ pub async fn rebalance_team_backlog(use_worktree,&repo_root,&runner_program,+ None,SessionGrouping::default(),).await?;@@ -464,12 +542,15 @@ pub async fn stop_session(db: &StateStore, id: &str) -> Result<()> {pub struct BudgetEnforcementOutcome {pub token_budget_exceeded: bool,pub cost_budget_exceeded: bool,+ pub profile_token_budget_exceeded: bool,pub paused_sessions: Vec<String>,}impl BudgetEnforcementOutcome {pub fn hard_limit_exceeded(&self) -> bool {- self.token_budget_exceeded || self.cost_budget_exceeded+ self.token_budget_exceeded+ || self.cost_budget_exceeded+ || self.profile_token_budget_exceeded}}@@ -490,18 +571,51 @@ pub fn enforce_budget_hard_limits(let mut outcome = BudgetEnforcementOutcome {token_budget_exceeded: cfg.token_budget > 0 && total_tokens >= cfg.token_budget,cost_budget_exceeded: cfg.cost_budget_usd > 0.0 && total_cost >= cfg.cost_budget_usd,+ profile_token_budget_exceeded: false,paused_sessions: Vec::new(),};- if !outcome.hard_limit_exceeded() {- return Ok(outcome);+ let mut sessions_to_pause = HashSet::new();++ if outcome.token_budget_exceeded || outcome.cost_budget_exceeded {+ for session in sessions.iter().filter(|session| {+ matches!(+ session.state,+ SessionState::Pending | SessionState::Running | SessionState::Idle+ )+ }) {+ sessions_to_pause.insert(session.id.clone());+ }}- for session in sessions.into_iter().filter(|session| {+ for session in sessions.iter().filter(|session| {matches!(session.state,SessionState::Pending | SessionState::Running | SessionState::Idle)+ }) {+ let Some(profile) = db.get_session_profile(&session.id)? else {+ continue;+ };+ let Some(token_budget) = profile.token_budget else {+ continue;+ };+ if token_budget > 0 && session.metrics.tokens_used >= token_budget {+ outcome.profile_token_budget_exceeded = true;+ sessions_to_pause.insert(session.id.clone());+ }+ }++ if !outcome.hard_limit_exceeded() {+ return Ok(outcome);+ }++ for session in sessions.into_iter().filter(|session| {+ sessions_to_pause.contains(&session.id)+ && matches!(+ session.state,+ SessionState::Pending | SessionState::Running | SessionState::Idle+ )}) {stop_session_recorded(db, &session, false)?;outcome.paused_sessions.push(session.id);@@ -820,6 +934,7 @@ async fn assign_session_in_dir_with_runner_program(use_worktree: bool,repo_root: &Path,runner_program: &Path,+ profile_name: Option<&str>,grouping: SessionGrouping,) -> Result<AssignmentOutcome> {let lead = resolve_session(db, lead_id)?;@@ -868,6 +983,8 @@ async fn assign_session_in_dir_with_runner_program(use_worktree,repo_root,runner_program,+ profile_name,+ Some(&lead.id),inherited_grouping.clone(),).await?;@@ -943,6 +1060,8 @@ async fn assign_session_in_dir_with_runner_program(use_worktree,repo_root,runner_program,+ profile_name,+ Some(&lead.id),inherited_grouping,).await?;@@ -1623,7 +1742,8 @@ pub async fn run_session(}let agent_program = agent_program(agent_type)?;- let command = build_agent_command(&agent_program, task, session_id, working_dir);+ let profile = db.get_session_profile(session_id)?;+ let command = build_agent_command(&agent_program, task, session_id, working_dir, profile.as_ref());capture_command_output(cfg.db_path.clone(),session_id.to_string(),@@ -1750,6 +1870,8 @@ async fn queue_session_in_dir(agent_type: &str,use_worktree: bool,repo_root: &Path,+ profile_name: Option<&str>,+ inherited_profile_session_id: Option<&str>,grouping: SessionGrouping,) -> Result<String> {queue_session_in_dir_with_runner_program(@@ -1760,6 +1882,8 @@ async fn queue_session_in_dir(use_worktree,repo_root,&std::env::current_exe().context("Failed to resolve ECC executable path")?,+ profile_name,+ inherited_profile_session_id,grouping,).await@@ -1773,11 +1897,29 @@ async fn queue_session_in_dir_with_runner_program(use_worktree: bool,repo_root: &Path,runner_program: &Path,+ profile_name: Option<&str>,+ inherited_profile_session_id: Option<&str>,grouping: SessionGrouping,) -> Result<String> {- let session =- build_session_record(db, task, agent_type, use_worktree, cfg, repo_root, grouping)?;+ let profile =+ resolve_launch_profile(db, cfg, profile_name, inherited_profile_session_id)?;+ let effective_agent_type = profile+ .as_ref()+ .and_then(|profile| profile.agent.as_deref())+ .unwrap_or(agent_type);+ let session = build_session_record(+ db,+ task,+ effective_agent_type,+ use_worktree,+ cfg,+ repo_root,+ grouping,+ )?;db.insert_session(&session)?;+ if let Some(profile) = profile.as_ref() {+ db.upsert_session_profile(&session.id, profile)?;+ }if use_worktree && session.worktree.is_none() {db.enqueue_pending_worktree(&session.id, repo_root)?;@@ -1793,7 +1935,7 @@ async fn queue_session_in_dir_with_runner_program(match spawn_session_runner_for_program(task,&session.id,- agent_type,+ &session.agent_type,working_dir,runner_program,)@@ -1911,6 +2053,27 @@ async fn create_session_in_dir(}}+fn resolve_launch_profile(+ db: &StateStore,+ cfg: &Config,+ explicit_profile_name: Option<&str>,+ inherited_profile_session_id: Option<&str>,+) -> Result<Option<SessionAgentProfile>> {+ let inherited_profile_name = match inherited_profile_session_id {+ Some(session_id) => db.get_session_profile(session_id)?.map(|profile| profile.profile_name),+ None => None,+ };+ let profile_name = explicit_profile_name+ .map(ToOwned::to_owned)+ .or(inherited_profile_name)+ .or_else(|| cfg.default_agent_profile.clone());++ profile_name+ .as_deref()+ .map(|name| cfg.resolve_agent_profile(name))+ .transpose()+}+fn attached_worktree_count(db: &StateStore) -> Result<usize> {Ok(db.list_sessions()?@@ -2075,16 +2238,44 @@ fn build_agent_command(task: &str,session_id: &str,working_dir: &Path,+ profile: Option<&SessionAgentProfile>,) -> Command {let mut command = Command::new(agent_program);+ command.env("ECC_SESSION_ID", session_id);command- .env("ECC_SESSION_ID", session_id).arg("--print").arg("--name")- .arg(format!("ecc-{session_id}"))- .arg(task)- .current_dir(working_dir)- .stdin(Stdio::null());+ .arg(format!("ecc-{session_id}"));+ if let Some(profile) = profile {+ if let Some(model) = profile.model.as_ref() {+ command.arg("--model").arg(model);+ }+ if !profile.allowed_tools.is_empty() {+ command+ .arg("--allowed-tools")+ .arg(profile.allowed_tools.join(","));+ }+ if !profile.disallowed_tools.is_empty() {+ command+ .arg("--disallowed-tools")+ .arg(profile.disallowed_tools.join(","));+ }+ if let Some(permission_mode) = profile.permission_mode.as_ref() {+ command.arg("--permission-mode").arg(permission_mode);+ }+ for dir in &profile.add_dirs {+ command.arg("--add-dir").arg(dir);+ }+ if let Some(max_budget_usd) = profile.max_budget_usd {+ command+ .arg("--max-budget-usd")+ .arg(max_budget_usd.to_string());+ }+ if let Some(prompt) = profile.append_system_prompt.as_ref() {+ command.arg("--append-system-prompt").arg(prompt);+ }+ }+ command.arg(task).current_dir(working_dir).stdin(Stdio::null());command}@@ -2094,7 +2285,7 @@ async fn spawn_claude_code(session_id: &str,working_dir: &Path,) -> Result<u32> {- let mut command = build_agent_command(agent_program, task, session_id, working_dir);+ let mut command = build_agent_command(agent_program, task, session_id, working_dir, None);let child = command.stdout(Stdio::null()).stderr(Stdio::null())@@ -2194,6 +2385,7 @@ async fn kill_process(pid: u32) -> Result<()> {}pub struct SessionStatus {+ profile: Option<SessionAgentProfile>,session: Session,parent_session: Option<String>,delegated_children: Vec<String>,@@ -2363,6 +2555,21 @@ impl fmt::Display for SessionStatus {writeln!(f, "Task: {}", s.task)?;writeln!(f, "Agent: {}", s.agent_type)?;writeln!(f, "State: {}", s.state)?;+ if let Some(profile) = self.profile.as_ref() {+ writeln!(f, "Profile: {}", profile.profile_name)?;+ if let Some(model) = profile.model.as_ref() {+ writeln!(f, "Model: {}", model)?;+ }+ if let Some(permission_mode) = profile.permission_mode.as_ref() {+ writeln!(f, "Perms: {}", permission_mode)?;+ }+ if let Some(token_budget) = profile.token_budget {+ writeln!(f, "Profile tokens: {}", token_budget)?;+ }+ if let Some(max_budget_usd) = profile.max_budget_usd {+ writeln!(f, "Profile cost: ${max_budget_usd:.4}")?;+ }+ }if let Some(parent) = self.parent_session.as_ref() {writeln!(f, "Parent: {}", parent)?;}@@ -2590,7 +2797,7 @@ fn session_state_label(state: &SessionState) -> &'static str {mod tests {use super::*;use crate::config::{Config, PaneLayout, Theme};- use crate::session::{Session, SessionMetrics, SessionState};+ use crate::session::{Session, SessionAgentProfile, SessionMetrics, SessionState};use anyhow::{Context, Result};use chrono::{Duration, Utc};use std::fs;@@ -2635,6 +2842,8 @@ mod tests {heartbeat_interval_secs: 5,auto_terminate_stale_sessions: false,default_agent: "claude".to_string(),+ default_agent_profile: None,+ agent_profiles: Default::default(),auto_dispatch_unread_handoffs: false,auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,@@ -2674,6 +2883,61 @@ mod tests {}}+ #[test]+ fn build_agent_command_applies_profile_runner_flags() {+ let profile = SessionAgentProfile {+ profile_name: "reviewer".to_string(),+ agent: None,+ model: Some("sonnet".to_string()),+ allowed_tools: vec!["Read".to_string(), "Edit".to_string()],+ disallowed_tools: vec!["Bash".to_string()],+ permission_mode: Some("plan".to_string()),+ add_dirs: vec![PathBuf::from("docs"), PathBuf::from("specs")],+ max_budget_usd: Some(1.25),+ token_budget: Some(750),+ append_system_prompt: Some("Review thoroughly.".to_string()),+ };++ let command = build_agent_command(+ Path::new("claude"),+ "review this change",+ "sess-1234",+ Path::new("/tmp/repo"),+ Some(&profile),+ );+ let args = command+ .as_std()+ .get_args()+ .map(|value| value.to_string_lossy().to_string())+ .collect::<Vec<_>>();++ assert_eq!(+ args,+ vec![+ "--print",+ "--name",+ "ecc-sess-1234",+ "--model",+ "sonnet",+ "--allowed-tools",+ "Read,Edit",+ "--disallowed-tools",+ "Bash",+ "--permission-mode",+ "plan",+ "--add-dir",+ "docs",+ "--add-dir",+ "specs",+ "--max-budget-usd",+ "1.25",+ "--append-system-prompt",+ "Review thoroughly.",+ "review this change",+ ]+ );+ }+#[test]fn enforce_session_heartbeats_marks_overdue_running_sessions_stale() -> Result<()> {let tempdir = TestDir::new("manager-heartbeat-stale")?;@@ -3099,6 +3363,62 @@ mod tests {Ok(())}+ #[tokio::test(flavor = "current_thread")]+ async fn create_session_uses_default_agent_profile_and_persists_launch_settings() -> Result<()> {+ let tempdir = TestDir::new("manager-default-agent-profile")?;+ let repo_root = tempdir.path().join("repo");+ init_git_repo(&repo_root)?;++ let mut cfg = build_config(tempdir.path());+ cfg.default_agent_profile = Some("reviewer".to_string());+ cfg.agent_profiles.insert(+ "reviewer".to_string(),+ crate::config::AgentProfileConfig {+ model: Some("sonnet".to_string()),+ allowed_tools: vec!["Read".to_string(), "Edit".to_string()],+ disallowed_tools: vec!["Bash".to_string()],+ permission_mode: Some("plan".to_string()),+ add_dirs: vec![PathBuf::from("docs")],+ token_budget: Some(800),+ append_system_prompt: Some("Review thoroughly.".to_string()),+ ..Default::default()+ },+ );+ let db = StateStore::open(&cfg.db_path)?;+ let (fake_runner, _) = write_fake_claude(tempdir.path())?;++ let session_id = queue_session_in_dir_with_runner_program(+ &db,+ &cfg,+ "review work",+ "claude",+ false,+ &repo_root,+ &fake_runner,+ None,+ None,+ SessionGrouping::default(),+ )+ .await?;++ let profile = db+ .get_session_profile(&session_id)?+ .context("session profile should be persisted")?;+ assert_eq!(profile.profile_name, "reviewer");+ assert_eq!(profile.model.as_deref(), Some("sonnet"));+ assert_eq!(profile.allowed_tools, vec!["Read", "Edit"]);+ assert_eq!(profile.disallowed_tools, vec!["Bash"]);+ assert_eq!(profile.permission_mode.as_deref(), Some("plan"));+ assert_eq!(profile.add_dirs, vec![PathBuf::from("docs")]);+ assert_eq!(profile.token_budget, Some(800));+ assert_eq!(+ profile.append_system_prompt.as_deref(),+ Some("Review thoroughly.")+ );++ Ok(())+ }+#[test]fn enforce_budget_hard_limits_stops_active_sessions_without_cleaning_worktrees() -> Result<()> {let tempdir = TestDir::new("manager-budget-pause")?;@@ -3214,6 +3534,73 @@ mod tests {Ok(())}+ #[test]+ fn enforce_budget_hard_limits_pauses_sessions_over_profile_token_budget() -> Result<()> {+ let tempdir = TestDir::new("manager-profile-token-budget")?;+ let cfg = build_config(tempdir.path());+ let db = StateStore::open(&cfg.db_path)?;+ let now = Utc::now();++ db.insert_session(&Session {+ id: "profile-over-budget".to_string(),+ task: "review work".to_string(),+ project: "workspace".to_string(),+ task_group: "general".to_string(),+ agent_type: "claude".to_string(),+ working_dir: tempdir.path().to_path_buf(),+ state: SessionState::Running,+ pid: Some(999_998),+ worktree: None,+ created_at: now - Duration::minutes(1),+ updated_at: now,+ last_heartbeat_at: now,+ metrics: SessionMetrics::default(),+ })?;+ db.upsert_session_profile(+ "profile-over-budget",+ &SessionAgentProfile {+ profile_name: "reviewer".to_string(),+ agent: None,+ model: Some("sonnet".to_string()),+ allowed_tools: vec!["Read".to_string()],+ disallowed_tools: Vec::new(),+ permission_mode: Some("plan".to_string()),+ add_dirs: Vec::new(),+ max_budget_usd: None,+ token_budget: Some(75),+ append_system_prompt: None,+ },+ )?;+ db.update_metrics(+ "profile-over-budget",+ &SessionMetrics {+ input_tokens: 60,+ output_tokens: 30,+ tokens_used: 90,+ tool_calls: 0,+ files_changed: 0,+ duration_secs: 60,+ cost_usd: 0.0,+ },+ )?;++ let outcome = enforce_budget_hard_limits(&db, &cfg)?;+ assert!(!outcome.token_budget_exceeded);+ assert!(!outcome.cost_budget_exceeded);+ assert!(outcome.profile_token_budget_exceeded);+ assert_eq!(+ outcome.paused_sessions,+ vec!["profile-over-budget".to_string()]+ );++ let session = db+ .get_session("profile-over-budget")?+ .context("session should still exist")?;+ assert_eq!(session.state, SessionState::Stopped);++ Ok(())+ }+#[tokio::test(flavor = "current_thread")]async fn resume_session_requeues_failed_session() -> Result<()> {let tempdir = TestDir::new("manager-resume-session")?;@@ -4108,6 +4495,7 @@ mod tests {true,&repo_root,&fake_runner,+ None,SessionGrouping::default(),).await?;@@ -4181,6 +4569,7 @@ mod tests {true,&repo_root,&fake_runner,+ None,SessionGrouping::default(),).await?;@@ -4266,6 +4655,7 @@ mod tests {true,&repo_root,&fake_runner,+ None,SessionGrouping::default(),).await?;@@ -4338,6 +4728,7 @@ mod tests {true,&repo_root,&fake_runner,+ None,SessionGrouping::default(),).await?;@@ -4394,6 +4785,7 @@ mod tests {true,&repo_root,&fake_runner,+ None,SessionGrouping::default(),).await?;@@ -4467,6 +4859,7 @@ mod tests {true,&repo_root,&fake_runner,+ None,SessionGrouping::default(),).await?;diff --git a/ecc2/src/session/mod.rs b/ecc2/src/session/mod.rsindex b66f6ee0f..301f3384d 100644--- a/ecc2/src/session/mod.rs+++ b/ecc2/src/session/mod.rs@@ -10,6 +10,8 @@ use std::fmt;use std::path::Path;use std::path::PathBuf;+pub type SessionAgentProfile = crate::config::ResolvedAgentProfile;+#[derive(Debug, Clone, Serialize, Deserialize)]pub struct Session {pub id: String,diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rsindex b7029b577..d0b826865 100644--- a/ecc2/src/session/store.rs+++ b/ecc2/src/session/store.rs@@ -14,8 +14,8 @@ use crate::observability::{ToolCallEvent, ToolLogEntry, ToolLogPage};use super::output::{OutputLine, OutputStream, OUTPUT_BUFFER_LIMIT};use super::{default_project_label, default_task_group_label, normalize_group_label, DecisionLogEntry,- FileActivityAction, FileActivityEntry, Session, SessionMessage, SessionMetrics, SessionState,- WorktreeInfo,+ FileActivityAction, FileActivityEntry, Session, SessionAgentProfile, SessionMessage,+ SessionMetrics, SessionState, WorktreeInfo,};pub struct StateStore {@@ -194,6 +194,19 @@ impl StateStore {file_events_json TEXT NOT NULL DEFAULT '[]');+ CREATE TABLE IF NOT EXISTS session_profiles (+ session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,+ profile_name TEXT NOT NULL,+ model TEXT,+ allowed_tools_json TEXT NOT NULL DEFAULT '[]',+ disallowed_tools_json TEXT NOT NULL DEFAULT '[]',+ permission_mode TEXT,+ add_dirs_json TEXT NOT NULL DEFAULT '[]',+ max_budget_usd REAL,+ token_budget INTEGER,+ append_system_prompt TEXT+ );+CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY AUTOINCREMENT,from_session TEXT NOT NULL,@@ -569,6 +582,98 @@ impl StateStore {Ok(())}+ pub fn upsert_session_profile(+ &self,+ session_id: &str,+ profile: &SessionAgentProfile,+ ) -> Result<()> {+ let allowed_tools_json = serde_json::to_string(&profile.allowed_tools)+ .context("serialize allowed agent profile tools")?;+ let disallowed_tools_json = serde_json::to_string(&profile.disallowed_tools)+ .context("serialize disallowed agent profile tools")?;+ let add_dirs_json = serde_json::to_string(&profile.add_dirs)+ .context("serialize agent profile add_dirs")?;++ self.conn.execute(+ "INSERT INTO session_profiles (+ session_id,+ profile_name,+ model,+ allowed_tools_json,+ disallowed_tools_json,+ permission_mode,+ add_dirs_json,+ max_budget_usd,+ token_budget,+ append_system_prompt+ )+ VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)+ ON CONFLICT(session_id) DO UPDATE SET+ profile_name = excluded.profile_name,+ model = excluded.model,+ allowed_tools_json = excluded.allowed_tools_json,+ disallowed_tools_json = excluded.disallowed_tools_json,+ permission_mode = excluded.permission_mode,+ add_dirs_json = excluded.add_dirs_json,+ max_budget_usd = excluded.max_budget_usd,+ token_budget = excluded.token_budget,+ append_system_prompt = excluded.append_system_prompt",+ rusqlite::params![+ session_id,+ profile.profile_name,+ profile.model,+ allowed_tools_json,+ disallowed_tools_json,+ profile.permission_mode,+ add_dirs_json,+ profile.max_budget_usd,+ profile.token_budget,+ profile.append_system_prompt,+ ],+ )?;+ Ok(())+ }++ pub fn get_session_profile(&self, session_id: &str) -> Result<Option<SessionAgentProfile>> {+ self.conn+ .query_row(+ "SELECT+ profile_name,+ model,+ allowed_tools_json,+ disallowed_tools_json,+ permission_mode,+ add_dirs_json,+ max_budget_usd,+ token_budget,+ append_system_prompt+ FROM session_profiles+ WHERE session_id = ?1",+ [session_id],+ |row| {+ let allowed_tools_json: String = row.get(2)?;+ let disallowed_tools_json: String = row.get(3)?;+ let add_dirs_json: String = row.get(5)?;+ Ok(SessionAgentProfile {+ profile_name: row.get(0)?,+ model: row.get(1)?,+ allowed_tools: serde_json::from_str(&allowed_tools_json)+ .unwrap_or_default(),+ disallowed_tools: serde_json::from_str(&disallowed_tools_json)+ .unwrap_or_default(),+ permission_mode: row.get(4)?,+ add_dirs: serde_json::from_str(&add_dirs_json).unwrap_or_default(),+ max_budget_usd: row.get(6)?,+ token_budget: row.get(7)?,+ append_system_prompt: row.get(8)?,+ agent: None,+ })+ },+ )+ .optional()+ .map_err(Into::into)+ }+pub fn update_state_and_pid(&self,session_id: &str,@@ -2532,6 +2637,63 @@ mod tests {Ok(())}+ #[test]+ fn session_profile_round_trips_with_launch_settings() -> Result<()> {+ let tempdir = TestDir::new("store-session-profile")?;+ let db = StateStore::open(&tempdir.path().join("state.db"))?;+ let now = Utc::now();++ db.insert_session(&Session {+ id: "session-1".to_string(),+ task: "review work".to_string(),+ project: "workspace".to_string(),+ task_group: "general".to_string(),+ agent_type: "claude".to_string(),+ working_dir: PathBuf::from("/tmp"),+ state: SessionState::Pending,+ pid: None,+ worktree: None,+ created_at: now,+ updated_at: now,+ last_heartbeat_at: now,+ metrics: SessionMetrics::default(),+ })?;++ db.upsert_session_profile(+ "session-1",+ &crate::session::SessionAgentProfile {+ agent: None,+ profile_name: "reviewer".to_string(),+ model: Some("sonnet".to_string()),+ allowed_tools: vec!["Read".to_string(), "Edit".to_string()],+ disallowed_tools: vec!["Bash".to_string()],+ permission_mode: Some("plan".to_string()),+ add_dirs: vec![PathBuf::from("docs"), PathBuf::from("specs")],+ max_budget_usd: Some(1.5),+ token_budget: Some(1200),+ append_system_prompt: Some("Review thoroughly.".to_string()),+ },+ )?;++ let profile = db+ .get_session_profile("session-1")?+ .expect("profile should be stored");+ assert_eq!(profile.profile_name, "reviewer");+ assert_eq!(profile.model.as_deref(), Some("sonnet"));+ assert_eq!(profile.allowed_tools, vec!["Read", "Edit"]);+ assert_eq!(profile.disallowed_tools, vec!["Bash"]);+ assert_eq!(profile.permission_mode.as_deref(), Some("plan"));+ assert_eq!(profile.add_dirs, vec![PathBuf::from("docs"), PathBuf::from("specs")]);+ assert_eq!(profile.max_budget_usd, Some(1.5));+ assert_eq!(profile.token_budget, Some(1200));+ assert_eq!(+ profile.append_system_prompt.as_deref(),+ Some("Review thoroughly.")+ );++ Ok(())+ }+#[test]fn sync_cost_tracker_metrics_aggregates_usage_into_sessions() -> Result<()> {let tempdir = TestDir::new("store-cost-metrics")?;diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex 68603fb92..a471d637f 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -5392,6 +5392,11 @@ impl Dashboard {fn selected_session_metrics_text(&self) -> String {if let Some(session) = self.sessions.get(self.selected_session) {let metrics = &session.metrics;+ let selected_profile = self+ .db+ .get_session_profile(&session.id)+ .ok()+ .flatten();let group_peers = self.sessions.iter()@@ -5413,6 +5418,57 @@ impl Dashboard {),];+ if let Some(profile) = selected_profile.as_ref() {+ let model = profile.model.as_deref().unwrap_or("default");+ let permission_mode = profile.permission_mode.as_deref().unwrap_or("default");+ lines.push(format!(+ "Profile {} | Model {} | Permissions {}",+ profile.profile_name, model, permission_mode+ ));+ let mut profile_details = Vec::new();+ if let Some(token_budget) = profile.token_budget {+ profile_details.push(format!(+ "Profile tokens {}",+ format_token_count(token_budget)+ ));+ }+ if let Some(max_budget_usd) = profile.max_budget_usd {+ profile_details.push(format!(+ "Profile cost {}",+ format_currency(max_budget_usd)+ ));+ }+ if !profile.allowed_tools.is_empty() {+ profile_details.push(format!(+ "Allow {}",+ truncate_for_dashboard(&profile.allowed_tools.join(", "), 36)+ ));+ }+ if !profile.disallowed_tools.is_empty() {+ profile_details.push(format!(+ "Deny {}",+ truncate_for_dashboard(&profile.disallowed_tools.join(", "), 36)+ ));+ }+ if !profile.add_dirs.is_empty() {+ profile_details.push(format!(+ "Dirs {}",+ truncate_for_dashboard(+ &profile+ .add_dirs+ .iter()+ .map(|path| path.display().to_string())+ .collect::<Vec<_>>()+ .join(", "),+ 36+ )+ ));+ }+ if !profile_details.is_empty() {+ lines.push(profile_details.join(" | "));+ }+ }+if let Some(parent) = self.selected_parent_session.as_ref() {lines.push(format!("Delegated from {}", format_session_id(parent)));}@@ -7878,11 +7934,16 @@ fn heartbeat_enforcement_note(outcome: &manager::HeartbeatEnforcementOutcome) ->}fn budget_auto_pause_note(outcome: &manager::BudgetEnforcementOutcome) -> String {- let cause = match (outcome.token_budget_exceeded, outcome.cost_budget_exceeded) {- (true, true) => "token and cost budgets exceeded",- (true, false) => "token budget exceeded",- (false, true) => "cost budget exceeded",- (false, false) => "budget exceeded",+ let cause = match (+ outcome.token_budget_exceeded,+ outcome.cost_budget_exceeded,+ outcome.profile_token_budget_exceeded,+ ) {+ (true, true, _) => "token and cost budgets exceeded",+ (true, false, _) => "token budget exceeded",+ (false, true, _) => "cost budget exceeded",+ (false, false, true) => "profile token budget exceeded",+ (false, false, false) => "budget exceeded",};format!(@@ -13011,6 +13072,8 @@ diff --git a/src/lib.rs b/src/lib.rsheartbeat_interval_secs: 5,auto_terminate_stale_sessions: false,default_agent: "claude".to_string(),+ default_agent_profile: None,+ agent_profiles: Default::default(),auto_dispatch_unread_handoffs: false,auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,