Skip to content

armgit / ECC

Public Imported from GitHub
0

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 orchestration templates

Affaan Mustafa194bf605c216
diff --git a/ecc2/src/config/mod.rs b/ecc2/src/config/mod.rs
index 938903a11..4e00bc9b6 100644
--- a/ecc2/src/config/mod.rs
+++ b/ecc2/src/config/mod.rs
@@ -1,5 +1,6 @@
use anyhow::{Context, Result};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+use regex::Regex;
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::path::PathBuf;
@@ -78,6 +79,50 @@ pub struct ResolvedAgentProfile {
pub append_system_prompt: Option<String>,
}
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct OrchestrationTemplateConfig {
+ pub description: Option<String>,
+ pub project: Option<String>,
+ pub task_group: Option<String>,
+ pub agent: Option<String>,
+ pub profile: Option<String>,
+ pub worktree: Option<bool>,
+ pub steps: Vec<OrchestrationTemplateStepConfig>,
+}
+
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct OrchestrationTemplateStepConfig {
+ pub name: Option<String>,
+ pub task: String,
+ pub agent: Option<String>,
+ pub profile: Option<String>,
+ pub worktree: Option<bool>,
+ pub project: Option<String>,
+ pub task_group: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ResolvedOrchestrationTemplate {
+ pub template_name: String,
+ pub description: Option<String>,
+ pub project: Option<String>,
+ pub task_group: Option<String>,
+ pub steps: Vec<ResolvedOrchestrationTemplateStep>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ResolvedOrchestrationTemplateStep {
+ pub name: String,
+ pub task: String,
+ pub agent: Option<String>,
+ pub profile: Option<String>,
+ pub worktree: bool,
+ pub project: Option<String>,
+ pub task_group: Option<String>,
+}
+
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct Config {
@@ -93,6 +138,7 @@ pub struct Config {
pub default_agent: String,
pub default_agent_profile: Option<String>,
pub agent_profiles: BTreeMap<String, AgentProfileConfig>,
+ pub orchestration_templates: BTreeMap<String, OrchestrationTemplateConfig>,
pub auto_dispatch_unread_handoffs: bool,
pub auto_dispatch_limit_per_session: usize,
pub auto_create_worktrees: bool,
@@ -156,6 +202,7 @@ impl Default for Config {
default_agent: "claude".to_string(),
default_agent_profile: None,
agent_profiles: BTreeMap::new(),
+ orchestration_templates: BTreeMap::new(),
auto_dispatch_unread_handoffs: false,
auto_dispatch_limit_per_session: 5,
auto_create_worktrees: true,
@@ -219,6 +266,80 @@ impl Config {
self.resolve_agent_profile_inner(name, &mut chain)
}
+ pub fn resolve_orchestration_template(
+ &self,
+ name: &str,
+ vars: &BTreeMap<String, String>,
+ ) -> Result<ResolvedOrchestrationTemplate> {
+ let template = self
+ .orchestration_templates
+ .get(name)
+ .ok_or_else(|| anyhow::anyhow!("Unknown orchestration template: {name}"))?;
+
+ if template.steps.is_empty() {
+ anyhow::bail!("orchestration template {name} has no steps");
+ }
+
+ let description = interpolate_optional_string(template.description.as_deref(), vars)?;
+ let project = interpolate_optional_string(template.project.as_deref(), vars)?;
+ let task_group = interpolate_optional_string(template.task_group.as_deref(), vars)?;
+ let default_agent = interpolate_optional_string(template.agent.as_deref(), vars)?;
+ let default_profile = interpolate_optional_string(template.profile.as_deref(), vars)?;
+ if let Some(profile_name) = default_profile.as_deref() {
+ self.resolve_agent_profile(profile_name)?;
+ }
+
+ let mut steps = Vec::with_capacity(template.steps.len());
+ for (index, step) in template.steps.iter().enumerate() {
+ let task = interpolate_required_string(&step.task, vars).with_context(|| {
+ format!(
+ "resolve task for orchestration template {name} step {}",
+ index + 1
+ )
+ })?;
+ let step_name = interpolate_optional_string(step.name.as_deref(), vars)?
+ .unwrap_or_else(|| format!("step {}", index + 1));
+ let agent = interpolate_optional_string(
+ step.agent.as_deref().or(default_agent.as_deref()),
+ vars,
+ )?;
+ let profile = interpolate_optional_string(
+ step.profile.as_deref().or(default_profile.as_deref()),
+ vars,
+ )?;
+ if let Some(profile_name) = profile.as_deref() {
+ self.resolve_agent_profile(profile_name)?;
+ }
+
+ steps.push(ResolvedOrchestrationTemplateStep {
+ name: step_name,
+ task,
+ agent,
+ profile,
+ worktree: step
+ .worktree
+ .or(template.worktree)
+ .unwrap_or(self.auto_create_worktrees),
+ project: interpolate_optional_string(
+ step.project.as_deref().or(project.as_deref()),
+ vars,
+ )?,
+ task_group: interpolate_optional_string(
+ step.task_group.as_deref().or(task_group.as_deref()),
+ vars,
+ )?,
+ });
+ }
+
+ Ok(ResolvedOrchestrationTemplate {
+ template_name: name.to_string(),
+ description,
+ project,
+ task_group,
+ steps,
+ })
+ }
+
fn resolve_agent_profile_inner(
&self,
name: &str,
@@ -226,10 +347,7 @@ impl Config {
) -> Result<ResolvedAgentProfile> {
if chain.iter().any(|existing| existing == name) {
chain.push(name.to_string());
- anyhow::bail!(
- "agent profile inheritance cycle: {}",
- chain.join(" -> ")
- );
+ anyhow::bail!("agent profile inheritance cycle: {}", chain.join(" -> "));
}
let profile = self
@@ -550,6 +668,55 @@ where
}
}
+fn interpolate_optional_string(
+ value: Option<&str>,
+ vars: &BTreeMap<String, String>,
+) -> Result<Option<String>> {
+ value
+ .map(|value| interpolate_required_string(value, vars))
+ .transpose()
+ .map(|value| {
+ value.and_then(|value| {
+ let trimmed = value.trim();
+ if trimmed.is_empty() {
+ None
+ } else {
+ Some(trimmed.to_string())
+ }
+ })
+ })
+}
+
+fn interpolate_required_string(value: &str, vars: &BTreeMap<String, String>) -> Result<String> {
+ let placeholder = Regex::new(r"\{\{\s*([A-Za-z0-9_-]+)\s*\}\}")
+ .expect("orchestration template placeholder regex");
+ let mut missing = Vec::new();
+ let rendered = placeholder.replace_all(value, |captures: &regex::Captures<'_>| {
+ let key = captures
+ .get(1)
+ .map(|capture| capture.as_str())
+ .unwrap_or_default();
+ match vars.get(key) {
+ Some(value) => value.to_string(),
+ None => {
+ missing.push(key.to_string());
+ String::new()
+ }
+ }
+ });
+
+ if !missing.is_empty() {
+ missing.sort();
+ missing.dedup();
+ anyhow::bail!(
+ "missing orchestration template variable(s): {}",
+ missing.join(", ")
+ );
+ }
+
+ Ok(rendered.into_owned())
+}
+
impl BudgetAlertThresholds {
pub fn sanitized(self) -> Self {
let values = [self.advisory, self.warning, self.critical];
@@ -574,6 +741,7 @@ mod tests {
PaneLayout,
};
use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+ use std::collections::BTreeMap;
use std::path::PathBuf;
use uuid::Uuid;
@@ -979,6 +1147,90 @@ inherits = "a"
.contains("agent profile inheritance cycle"));
}
+ #[test]
+ fn orchestration_templates_resolve_steps_and_interpolate_variables() {
+ let config: Config = toml::from_str(
+ r#"
+default_agent = "claude"
+default_agent_profile = "reviewer"
+
+[agent_profiles.reviewer]
+model = "sonnet"
+
+[orchestration_templates.feature_development]
+description = "Ship {{task}}"
+project = "{{project}}"
+task_group = "{{task_group}}"
+profile = "reviewer"
+worktree = true
+
+[[orchestration_templates.feature_development.steps]]
+name = "planner"
+task = "Plan {{task}}"
+agent = "claude"
+
+[[orchestration_templates.feature_development.steps]]
+name = "reviewer"
+task = "Review {{task}} in {{component}}"
+profile = "reviewer"
+worktree = false
+"#,
+ )
+ .unwrap();
+
+ let vars = BTreeMap::from([
+ ("task".to_string(), "stabilize auth callback".to_string()),
+ ("project".to_string(), "ecc-core".to_string()),
+ ("task_group".to_string(), "auth callback".to_string()),
+ ("component".to_string(), "billing".to_string()),
+ ]);
+ let template = config
+ .resolve_orchestration_template("feature_development", &vars)
+ .unwrap();
+
+ assert_eq!(template.template_name, "feature_development");
+ assert_eq!(
+ template.description.as_deref(),
+ Some("Ship stabilize auth callback")
+ );
+ assert_eq!(template.project.as_deref(), Some("ecc-core"));
+ assert_eq!(template.task_group.as_deref(), Some("auth callback"));
+ assert_eq!(template.steps.len(), 2);
+ assert_eq!(template.steps[0].name, "planner");
+ assert_eq!(template.steps[0].task, "Plan stabilize auth callback");
+ assert_eq!(template.steps[0].agent.as_deref(), Some("claude"));
+ assert_eq!(template.steps[0].profile.as_deref(), Some("reviewer"));
+ assert!(template.steps[0].worktree);
+ assert_eq!(
+ template.steps[1].task,
+ "Review stabilize auth callback in billing"
+ );
+ assert!(!template.steps[1].worktree);
+ }
+
+ #[test]
+ fn orchestration_templates_fail_when_required_variables_are_missing() {
+ let config: Config = toml::from_str(
+ r#"
+[orchestration_templates.feature_development]
+[[orchestration_templates.feature_development.steps]]
+task = "Plan {{task}} for {{component}}"
+"#,
+ )
+ .unwrap();
+
+ let error = config
+ .resolve_orchestration_template(
+ "feature_development",
+ &BTreeMap::from([("task".to_string(), "fix retry".to_string())]),
+ )
+ .expect_err("missing template variables must fail");
+ let error_text = format!("{error:#}");
+ assert!(error_text
+ .contains("resolve task for orchestration template feature_development step 1"));
+ assert!(error_text.contains("missing orchestration template variable(s): component"));
+ }
+
#[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.rs
index ee1fcb500..d7b88de73 100644
--- a/ecc2/src/main.rs
+++ b/ecc2/src/main.rs
@@ -9,6 +9,7 @@ mod worktree;
use anyhow::Result;
use clap::Parser;
use serde::Serialize;
+use std::collections::BTreeMap;
use std::path::PathBuf;
use tracing_subscriber::EnvFilter;
@@ -78,6 +79,20 @@ enum Commands {
#[command(flatten)]
worktree: WorktreePolicyArgs,
},
+ /// Launch a named orchestration template
+ Template {
+ /// Template name defined in ecc2.toml
+ name: String,
+ /// Optional task injected into the template context
+ #[arg(short, long)]
+ task: Option<String>,
+ /// Source session to delegate the template from
+ #[arg(long)]
+ from_session: Option<String>,
+ /// Template variables in key=value form
+ #[arg(long = "var")]
+ vars: Vec<String>,
+ },
/// Route work to an existing delegate when possible, otherwise spawn a new one
Assign {
/// Lead session ID or alias
@@ -458,20 +473,21 @@ async fn main() -> Result<()> {
)
});
- 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()),
- },
- )
- .await?;
+ 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()),
+ },
+ )
+ .await?;
send_handoff_message(&db, &source.id, &session_id)?;
println!(
"Delegated session started: {} <- {}",
@@ -479,6 +495,43 @@ async fn main() -> Result<()> {
short_session(&source.id)
);
}
+ Some(Commands::Template {
+ name,
+ task,
+ from_session,
+ vars,
+ }) => {
+ let source_session_id = from_session
+ .as_deref()
+ .map(|session_id| resolve_session_id(&db, session_id))
+ .transpose()?;
+ let outcome = session::manager::launch_orchestration_template(
+ &db,
+ &cfg,
+ &name,
+ source_session_id.as_deref(),
+ task.as_deref(),
+ parse_template_vars(&vars)?,
+ )
+ .await?;
+ println!(
+ "Template launched: {} ({} step{})",
+ outcome.template_name,
+ outcome.created.len(),
+ if outcome.created.len() == 1 { "" } else { "s" }
+ );
+ if let Some(anchor_session_id) = outcome.anchor_session_id.as_deref() {
+ println!("Anchor session: {}", short_session(anchor_session_id));
+ }
+ for step in outcome.created {
+ println!(
+ "- {} -> {} | {}",
+ step.step_name,
+ short_session(&step.session_id),
+ step.task
+ );
+ }
+ }
Some(Commands::Assign {
from_session,
task,
@@ -2174,6 +2227,22 @@ fn send_handoff_message(db: &session::store::StateStore, from_id: &str, to_id: &
)
}
+fn parse_template_vars(values: &[String]) -> Result<BTreeMap<String, String>> {
+ let mut vars = BTreeMap::new();
+ for value in values {
+ let (key, raw_value) = value
+ .split_once('=')
+ .ok_or_else(|| anyhow::anyhow!("template vars must use key=value form: {value}"))?;
+ let key = key.trim();
+ let raw_value = raw_value.trim();
+ if key.is_empty() || raw_value.is_empty() {
+ anyhow::bail!("template vars must use non-empty key=value form: {value}");
+ }
+ vars.insert(key.to_string(), raw_value.to_string());
+ }
+ Ok(vars)
+}
+
#[cfg(test)]
mod tests {
use super::*;
@@ -2424,6 +2493,70 @@ mod tests {
}
}
+ #[test]
+ fn cli_parses_template_command() {
+ let cli = Cli::try_parse_from([
+ "ecc",
+ "template",
+ "feature_development",
+ "--task",
+ "stabilize auth callback",
+ "--from-session",
+ "lead",
+ "--var",
+ "component=billing",
+ "--var",
+ "area=oauth",
+ ])
+ .expect("template should parse");
+
+ match cli.command {
+ Some(Commands::Template {
+ name,
+ task,
+ from_session,
+ vars,
+ }) => {
+ assert_eq!(name, "feature_development");
+ assert_eq!(task.as_deref(), Some("stabilize auth callback"));
+ assert_eq!(from_session.as_deref(), Some("lead"));
+ assert_eq!(
+ vars,
+ vec!["component=billing".to_string(), "area=oauth".to_string(),]
+ );
+ }
+ _ => panic!("expected template subcommand"),
+ }
+ }
+
+ #[test]
+ fn parse_template_vars_builds_map() {
+ let vars =
+ parse_template_vars(&["component=billing".to_string(), "area=oauth".to_string()])
+ .expect("template vars");
+
+ assert_eq!(
+ vars,
+ BTreeMap::from([
+ ("area".to_string(), "oauth".to_string()),
+ ("component".to_string(), "billing".to_string()),
+ ])
+ );
+ }
+
+ #[test]
+ fn parse_template_vars_rejects_invalid_entries() {
+ let error = parse_template_vars(&["missing-delimiter".to_string()])
+ .expect_err("invalid template var should fail");
+
+ assert!(
+ error
+ .to_string()
+ .contains("template vars must use key=value form"),
+ "unexpected error: {error}"
+ );
+ }
+
#[test]
fn cli_parses_team_command() {
let cli = Cli::try_parse_from(["ecc", "team", "planner", "--depth", "3"])
diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rs
index 28669e9df..3f5f2c2c8 100644
--- a/ecc2/src/session/manager.rs
+++ b/ecc2/src/session/manager.rs
@@ -150,6 +150,197 @@ pub fn get_team_status(db: &StateStore, id: &str, depth: usize) -> Result<TeamSt
})
}
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+pub struct TemplateLaunchStepOutcome {
+ pub step_name: String,
+ pub session_id: String,
+ pub task: String,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+pub struct TemplateLaunchOutcome {
+ pub template_name: String,
+ pub step_count: usize,
+ pub anchor_session_id: Option<String>,
+ pub created: Vec<TemplateLaunchStepOutcome>,
+}
+
+pub async fn launch_orchestration_template(
+ db: &StateStore,
+ cfg: &Config,
+ template_name: &str,
+ source_session_id: Option<&str>,
+ task: Option<&str>,
+ variables: BTreeMap<String, String>,
+) -> Result<TemplateLaunchOutcome> {
+ let repo_root =
+ std::env::current_dir().context("Failed to resolve current working directory")?;
+ let runner_program =
+ std::env::current_exe().context("Failed to resolve ECC executable path")?;
+ let source_session = source_session_id
+ .map(|id| resolve_session(db, id))
+ .transpose()?;
+ let vars = build_template_variables(&repo_root, source_session.as_ref(), task, variables);
+ let template = cfg.resolve_orchestration_template(template_name, &vars)?;
+ let live_sessions = db
+ .list_sessions()?
+ .into_iter()
+ .filter(|session| {
+ matches!(
+ session.state,
+ SessionState::Pending
+ | SessionState::Running
+ | SessionState::Idle
+ | SessionState::Stale
+ )
+ })
+ .count();
+ let available_slots = cfg.max_parallel_sessions.saturating_sub(live_sessions);
+ if template.steps.len() > available_slots {
+ anyhow::bail!(
+ "template {template_name} requires {} session slots but only {available_slots} available",
+ template.steps.len()
+ );
+ }
+
+ let default_profile = cfg
+ .default_agent_profile
+ .as_deref()
+ .map(|name| cfg.resolve_agent_profile(name))
+ .transpose()?;
+ let base_grouping = SessionGrouping {
+ project: Some(
+ source_session
+ .as_ref()
+ .map(|session| session.project.clone())
+ .unwrap_or_else(|| default_project_label(&repo_root)),
+ ),
+ task_group: Some(
+ source_session
+ .as_ref()
+ .map(|session| session.task_group.clone())
+ .or_else(|| task.map(default_task_group_label))
+ .unwrap_or_else(|| template_name.replace(['_', '-'], " ")),
+ ),
+ };
+
+ let mut created = Vec::with_capacity(template.steps.len());
+ let mut anchor_session_id = source_session.as_ref().map(|session| session.id.clone());
+ let mut created_anchor_id: Option<String> = None;
+
+ for step in template.steps {
+ let profile = match step.profile.as_deref() {
+ Some(name) => Some(cfg.resolve_agent_profile(name)?),
+ None if step.agent.is_some() => None,
+ None => default_profile.clone(),
+ };
+ let agent = step
+ .agent
+ .as_deref()
+ .unwrap_or(&cfg.default_agent)
+ .to_string();
+ let grouping = SessionGrouping {
+ project: step
+ .project
+ .clone()
+ .or_else(|| base_grouping.project.clone()),
+ task_group: step
+ .task_group
+ .clone()
+ .or_else(|| base_grouping.task_group.clone()),
+ };
+ let session_id = queue_session_with_resolved_profile_and_runner_program(
+ db,
+ cfg,
+ &step.task,
+ &agent,
+ step.worktree,
+ &repo_root,
+ &runner_program,
+ profile,
+ grouping,
+ )
+ .await?;
+
+ if let Some(parent_id) = anchor_session_id.as_deref() {
+ let parent = resolve_session(db, parent_id)?;
+ send_task_handoff(
+ db,
+ &parent,
+ &session_id,
+ &step.task,
+ &format!("template {} | {}", template_name, step.name),
+ )?;
+ } else {
+ created_anchor_id = Some(session_id.clone());
+ anchor_session_id = Some(session_id.clone());
+ }
+
+ if created_anchor_id.is_none() {
+ created_anchor_id = Some(session_id.clone());
+ }
+
+ created.push(TemplateLaunchStepOutcome {
+ step_name: step.name,
+ session_id,
+ task: step.task,
+ });
+ }
+
+ Ok(TemplateLaunchOutcome {
+ template_name: template_name.to_string(),
+ step_count: created.len(),
+ anchor_session_id: source_session
+ .as_ref()
+ .map(|session| session.id.clone())
+ .or(created_anchor_id),
+ created,
+ })
+}
+
+pub(crate) fn build_template_variables(
+ repo_root: &Path,
+ source_session: Option<&Session>,
+ task: Option<&str>,
+ mut variables: BTreeMap<String, String>,
+) -> BTreeMap<String, String> {
+ if let Some(source) = source_session {
+ variables
+ .entry("source_task".to_string())
+ .or_insert_with(|| source.task.clone());
+ variables
+ .entry("source_project".to_string())
+ .or_insert_with(|| source.project.clone());
+ variables
+ .entry("source_task_group".to_string())
+ .or_insert_with(|| source.task_group.clone());
+ variables
+ .entry("source_agent".to_string())
+ .or_insert_with(|| source.agent_type.clone());
+ }
+
+ let effective_task = task
+ .map(ToOwned::to_owned)
+ .or_else(|| source_session.map(|session| session.task.clone()));
+ if let Some(task) = effective_task {
+ variables.entry("task".to_string()).or_insert(task.clone());
+ variables
+ .entry("task_group".to_string())
+ .or_insert_with(|| default_task_group_label(&task));
+ }
+
+ variables.entry("project".to_string()).or_insert_with(|| {
+ source_session
+ .map(|session| session.project.clone())
+ .unwrap_or_else(|| default_project_label(repo_root))
+ });
+ variables
+ .entry("cwd".to_string())
+ .or_insert_with(|| repo_root.display().to_string());
+
+ variables
+}
+
#[derive(Debug, Clone, Default, Serialize)]
pub struct HeartbeatEnforcementOutcome {
pub stale_sessions: Vec<String>,
@@ -1743,7 +1934,13 @@ pub async fn run_session(
let agent_program = agent_program(agent_type)?;
let profile = db.get_session_profile(session_id)?;
- let command = build_agent_command(&agent_program, task, session_id, working_dir, profile.as_ref());
+ 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(),
@@ -1901,8 +2098,32 @@ async fn queue_session_in_dir_with_runner_program(
inherited_profile_session_id: Option<&str>,
grouping: SessionGrouping,
) -> Result<String> {
- let profile =
- resolve_launch_profile(db, cfg, profile_name, inherited_profile_session_id)?;
+ let profile = resolve_launch_profile(db, cfg, profile_name, inherited_profile_session_id)?;
+ queue_session_with_resolved_profile_and_runner_program(
+ db,
+ cfg,
+ task,
+ agent_type,
+ use_worktree,
+ repo_root,
+ runner_program,
+ profile,
+ grouping,
+ )
+ .await
+}
+
+async fn queue_session_with_resolved_profile_and_runner_program(
+ db: &StateStore,
+ cfg: &Config,
+ task: &str,
+ agent_type: &str,
+ use_worktree: bool,
+ repo_root: &Path,
+ runner_program: &Path,
+ profile: Option<SessionAgentProfile>,
+ grouping: SessionGrouping,
+) -> Result<String> {
let effective_agent_type = profile
.as_ref()
.and_then(|profile| profile.agent.as_deref())
@@ -2060,7 +2281,9 @@ fn resolve_launch_profile(
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),
+ Some(session_id) => db
+ .get_session_profile(session_id)?
+ .map(|profile| profile.profile_name),
None => None,
};
let profile_name = explicit_profile_name
@@ -2275,7 +2498,10 @@ fn build_agent_command(
command.arg("--append-system-prompt").arg(prompt);
}
}
- command.arg(task).current_dir(working_dir).stdin(Stdio::null());
+ command
+ .arg(task)
+ .current_dir(working_dir)
+ .stdin(Stdio::null());
command
}
@@ -2844,6 +3070,7 @@ mod tests {
default_agent: "claude".to_string(),
default_agent_profile: None,
agent_profiles: Default::default(),
+ orchestration_templates: Default::default(),
auto_dispatch_unread_handoffs: false,
auto_dispatch_limit_per_session: 5,
auto_create_worktrees: true,
@@ -3364,7 +3591,8 @@ mod tests {
}
#[tokio::test(flavor = "current_thread")]
- async fn create_session_uses_default_agent_profile_and_persists_launch_settings() -> Result<()> {
+ 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)?;
diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rs
index d0b826865..8d028e761 100644
--- a/ecc2/src/session/store.rs
+++ b/ecc2/src/session/store.rs
@@ -591,8 +591,8 @@ impl StateStore {
.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")?;
+ let add_dirs_json =
+ serde_json::to_string(&profile.add_dirs).context("serialize agent profile add_dirs")?;
self.conn.execute(
"INSERT INTO session_profiles (
@@ -2683,7 +2683,10 @@ mod tests {
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.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!(
diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rs
index a471d637f..e137653cf 100644
--- a/ecc2/src/tui/dashboard.rs
+++ b/ecc2/src/tui/dashboard.rs
@@ -8,7 +8,7 @@ use ratatui::{
},
};
use regex::Regex;
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
use std::time::UNIX_EPOCH;
use tokio::sync::broadcast;
@@ -273,16 +273,31 @@ struct TimelineEvent {
}
#[derive(Debug, Clone, PartialEq, Eq)]
-struct SpawnRequest {
- requested_count: usize,
- task: String,
+enum SpawnRequest {
+ AdHoc {
+ requested_count: usize,
+ task: String,
+ },
+ Template {
+ name: String,
+ task: Option<String>,
+ variables: BTreeMap<String, String>,
+ },
}
#[derive(Debug, Clone, PartialEq, Eq)]
-struct SpawnPlan {
- requested_count: usize,
- spawn_count: usize,
- task: String,
+enum SpawnPlan {
+ AdHoc {
+ requested_count: usize,
+ spawn_count: usize,
+ task: String,
+ },
+ Template {
+ name: String,
+ task: Option<String>,
+ variables: BTreeMap<String, String>,
+ step_count: usize,
+ },
}
#[derive(Debug, Clone, Copy)]
@@ -1357,7 +1372,7 @@ impl Dashboard {
"Keyboard Shortcuts:".to_string(),
"".to_string(),
" n New session".to_string(),
- " N Natural-language multi-agent spawn prompt".to_string(),
+ " N Natural-language multi-agent or template spawn prompt".to_string(),
" a Assign follow-up work from selected session".to_string(),
" b Rebalance backed-up delegate handoff backlog for selected lead".to_string(),
" B Rebalance backed-up delegate handoff backlog across lead teams".to_string(),
@@ -3062,7 +3077,7 @@ impl Dashboard {
self.spawn_input = Some(self.spawn_prompt_seed());
self.set_operator_note(
- "spawn mode | try: give me 3 agents working on fix flaky tests".to_string(),
+ "spawn mode | try: give me 3 agents working on fix flaky tests | or: template feature_development for fix flaky tests".to_string(),
);
}
@@ -3419,64 +3434,96 @@ impl Dashboard {
let agent = self.cfg.default_agent.clone();
let mut created_ids = Vec::new();
- for task in expand_spawn_tasks(&plan.task, plan.spawn_count) {
- let session_id = match manager::create_session_with_grouping(
+ match &plan {
+ SpawnPlan::AdHoc {
+ requested_count: _,
+ spawn_count,
+ task,
+ } => {
+ for task in expand_spawn_tasks(task, *spawn_count) {
+ let session_id = match manager::create_session_with_grouping(
+ &self.db,
+ &self.cfg,
+ &task,
+ &agent,
+ self.cfg.auto_create_worktrees,
+ source_grouping.clone(),
+ )
+ .await
+ {
+ Ok(session_id) => session_id,
+ Err(error) => {
+ let preferred_selection =
+ post_spawn_selection_id(source_session_id.as_deref(), &created_ids);
+ self.refresh_after_spawn(preferred_selection.as_deref());
+ let mut summary = if created_ids.is_empty() {
+ format!("spawn failed: {error}")
+ } else {
+ format!(
+ "spawn partially completed: {} of {} queued before failure: {error}",
+ created_ids.len(),
+ spawn_count
+ )
+ };
+ if let Some(layout_note) =
+ self.auto_split_layout_after_spawn(created_ids.len())
+ {
+ summary.push_str(" | ");
+ summary.push_str(&layout_note);
+ }
+ self.set_operator_note(summary);
+ return;
+ }
+ };
+
+ if let (Some(source_id), Some(task), Some(context)) = (
+ source_session_id.as_ref(),
+ source_task.as_ref(),
+ handoff_context.as_ref(),
+ ) {
+ if let Err(error) = comms::send(
+ &self.db,
+ source_id,
+ &session_id,
+ &comms::MessageType::TaskHandoff {
+ task: task.clone(),
+ context: context.clone(),
+ },
+ ) {
+ tracing::warn!(
+ "Failed to send handoff from session {} to {}: {error}",
+ source_id,
+ session_id
+ );
+ }
+ }
+
+ created_ids.push(session_id);
+ }
+ }
+ SpawnPlan::Template {
+ name,
+ task,
+ variables,
+ ..
+ } => match manager::launch_orchestration_template(
&self.db,
&self.cfg,
- &task,
- &agent,
- self.cfg.auto_create_worktrees,
- source_grouping.clone(),
+ name,
+ source_session_id.as_deref(),
+ task.as_deref(),
+ variables.clone(),
)
.await
{
- Ok(session_id) => session_id,
+ Ok(outcome) => {
+ created_ids.extend(outcome.created.into_iter().map(|step| step.session_id));
+ }
Err(error) => {
- let preferred_selection =
- post_spawn_selection_id(source_session_id.as_deref(), &created_ids);
- self.refresh_after_spawn(preferred_selection.as_deref());
- let mut summary = if created_ids.is_empty() {
- format!("spawn failed: {error}")
- } else {
- format!(
- "spawn partially completed: {} of {} queued before failure: {error}",
- created_ids.len(),
- plan.spawn_count
- )
- };
- if let Some(layout_note) = self.auto_split_layout_after_spawn(created_ids.len())
- {
- summary.push_str(" | ");
- summary.push_str(&layout_note);
- }
- self.set_operator_note(summary);
+ self.set_operator_note(format!("template launch failed: {error}"));
return;
}
- };
-
- if let (Some(source_id), Some(task), Some(context)) = (
- source_session_id.as_ref(),
- source_task.as_ref(),
- handoff_context.as_ref(),
- ) {
- if let Err(error) = comms::send(
- &self.db,
- source_id,
- &session_id,
- &comms::MessageType::TaskHandoff {
- task: task.clone(),
- context: context.clone(),
- },
- ) {
- tracing::warn!(
- "Failed to send handoff from session {} to {}: {error}",
- source_id,
- session_id
- );
- }
- }
-
- created_ids.push(session_id);
+ },
}
let preferred_selection =
@@ -5392,11 +5439,7 @@ 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 selected_profile = self.db.get_session_profile(&session.id).ok().flatten();
let group_peers = self
.sessions
.iter()
@@ -5433,10 +5476,8 @@ impl Dashboard {
));
}
if let Some(max_budget_usd) = profile.max_budget_usd {
- profile_details.push(format!(
- "Profile cost {}",
- format_currency(max_budget_usd)
- ));
+ profile_details
+ .push(format!("Profile cost {}", format_currency(max_budget_usd)));
}
if !profile.allowed_tools.is_empty() {
profile_details.push(format!(
@@ -5958,18 +5999,58 @@ impl Dashboard {
.max_parallel_sessions
.saturating_sub(self.active_session_count());
- if available_slots == 0 {
- return Err(format!(
- "cannot queue sessions: active session limit reached ({})",
- self.cfg.max_parallel_sessions
- ));
- }
+ match request {
+ SpawnRequest::AdHoc {
+ requested_count,
+ task,
+ } => {
+ if available_slots == 0 {
+ return Err(format!(
+ "cannot queue sessions: active session limit reached ({})",
+ self.cfg.max_parallel_sessions
+ ));
+ }
- Ok(SpawnPlan {
- requested_count: request.requested_count,
- spawn_count: request.requested_count.min(available_slots),
- task: request.task,
- })
+ Ok(SpawnPlan::AdHoc {
+ requested_count,
+ spawn_count: requested_count.min(available_slots),
+ task,
+ })
+ }
+ SpawnRequest::Template {
+ name,
+ task,
+ variables,
+ } => {
+ let repo_root = std::env::current_dir().map_err(|error| {
+ format!("failed to resolve cwd for template preview: {error}")
+ })?;
+ let source_session = self.sessions.get(self.selected_session);
+ let preview_vars = manager::build_template_variables(
+ &repo_root,
+ source_session,
+ task.as_deref(),
+ variables.clone(),
+ );
+ let template = self
+ .cfg
+ .resolve_orchestration_template(&name, &preview_vars)
+ .map_err(|error| error.to_string())?;
+ if available_slots < template.steps.len() {
+ return Err(format!(
+ "template {name} requires {} session slots but only {available_slots} available",
+ template.steps.len()
+ ));
+ }
+
+ Ok(SpawnPlan::Template {
+ name,
+ task,
+ variables,
+ step_count: template.steps.len(),
+ })
+ }
+ }
}
fn pane_areas(&self, area: Rect) -> PaneAreas {
@@ -6289,6 +6370,10 @@ fn parse_spawn_request(input: &str) -> Result<SpawnRequest, String> {
return Err("spawn request cannot be empty".to_string());
}
+ if let Some(template_request) = parse_template_spawn_request(trimmed)? {
+ return Ok(template_request);
+ }
+
let count = Regex::new(r"\b([1-9]\d*)\b")
.expect("spawn count regex")
.captures(trimmed)
@@ -6301,12 +6386,66 @@ fn parse_spawn_request(input: &str) -> Result<SpawnRequest, String> {
return Err("spawn request must include a task description".to_string());
}
- Ok(SpawnRequest {
+ Ok(SpawnRequest::AdHoc {
requested_count: count,
task,
})
}
+fn parse_template_spawn_request(input: &str) -> Result<Option<SpawnRequest>, String> {
+ let captures = Regex::new(
+ r"(?is)^\s*template\s+(?P<name>[A-Za-z0-9_-]+)(?:\s+for\s+(?P<task>.*?))?(?:\s+with\s+(?P<vars>.+))?\s*$",
+ )
+ .expect("template spawn regex")
+ .captures(input);
+
+ let Some(captures) = captures else {
+ return Ok(None);
+ };
+
+ let name = captures
+ .name("name")
+ .map(|value| value.as_str().trim().to_string())
+ .ok_or_else(|| "template request must include a template name".to_string())?;
+ let task = captures
+ .name("task")
+ .map(|value| value.as_str().trim().to_string())
+ .filter(|value| !value.is_empty());
+ let variables = captures
+ .name("vars")
+ .map(|value| parse_template_request_variables(value.as_str()))
+ .transpose()?
+ .unwrap_or_default();
+
+ Ok(Some(SpawnRequest::Template {
+ name,
+ task,
+ variables,
+ }))
+}
+
+fn parse_template_request_variables(input: &str) -> Result<BTreeMap<String, String>, String> {
+ let mut variables = BTreeMap::new();
+ for entry in input
+ .split(',')
+ .map(str::trim)
+ .filter(|entry| !entry.is_empty())
+ {
+ let (key, value) = entry
+ .split_once('=')
+ .ok_or_else(|| format!("template vars must use key=value form: {entry}"))?;
+ let key = key.trim();
+ let value = value.trim();
+ if key.is_empty() || value.is_empty() {
+ return Err(format!(
+ "template vars must use non-empty key=value form: {entry}"
+ ));
+ }
+ variables.insert(key.to_string(), value.to_string());
+ }
+ Ok(variables)
+}
+
fn extract_spawn_task(input: &str) -> String {
let trimmed = input.trim();
let lower = trimmed.to_ascii_lowercase();
@@ -6344,14 +6483,33 @@ fn expand_spawn_tasks(task: &str, count: usize) -> Vec<String> {
}
fn build_spawn_note(plan: &SpawnPlan, created_count: usize, queued_count: usize) -> String {
- let task = truncate_for_dashboard(&plan.task, 72);
- let mut note = if plan.spawn_count < plan.requested_count {
- format!(
- "spawned {created_count} session(s) for {task} (requested {}, capped at {})",
- plan.requested_count, plan.spawn_count
- )
- } else {
- format!("spawned {created_count} session(s) for {task}")
+ let mut note = match plan {
+ SpawnPlan::AdHoc {
+ requested_count,
+ spawn_count,
+ task,
+ } => {
+ let task = truncate_for_dashboard(task, 72);
+ if spawn_count < requested_count {
+ format!(
+ "spawned {created_count} session(s) for {task} (requested {requested_count}, capped at {spawn_count})"
+ )
+ } else {
+ format!("spawned {created_count} session(s) for {task}")
+ }
+ }
+ SpawnPlan::Template {
+ name,
+ task,
+ step_count,
+ ..
+ } => {
+ let scope = task
+ .as_ref()
+ .map(|task| format!(" for {}", truncate_for_dashboard(task, 72)))
+ .unwrap_or_default();
+ format!("launched template {name} ({created_count}/{step_count} step(s)){scope}")
+ }
};
if queued_count > 0 {
@@ -11053,7 +11211,7 @@ diff --git a/src/lib.rs b/src/lib.rs
assert_eq!(
request,
- SpawnRequest {
+ SpawnRequest::AdHoc {
requested_count: 10,
task: "stabilize the queue".to_string(),
}
@@ -11066,13 +11224,33 @@ diff --git a/src/lib.rs b/src/lib.rs
assert_eq!(
request,
- SpawnRequest {
+ SpawnRequest::AdHoc {
requested_count: 1,
task: "stabilize the queue".to_string(),
}
);
}
+ #[test]
+ fn parse_spawn_request_extracts_template_request() {
+ let request = parse_spawn_request(
+ "template feature_development for stabilize auth callback with component=billing, area=oauth",
+ )
+ .expect("template request should parse");
+
+ assert_eq!(
+ request,
+ SpawnRequest::Template {
+ name: "feature_development".to_string(),
+ task: Some("stabilize auth callback".to_string()),
+ variables: BTreeMap::from([
+ ("area".to_string(), "oauth".to_string()),
+ ("component".to_string(), "billing".to_string()),
+ ]),
+ }
+ );
+ }
+
#[test]
fn build_spawn_plan_caps_requested_count_to_available_slots() {
let dashboard = test_dashboard(
@@ -11090,7 +11268,7 @@ diff --git a/src/lib.rs b/src/lib.rs
assert_eq!(
plan,
- SpawnPlan {
+ SpawnPlan::AdHoc {
requested_count: 9,
spawn_count: 5,
task: "ship release notes".to_string(),
@@ -11098,6 +11276,145 @@ diff --git a/src/lib.rs b/src/lib.rs
);
}
+ #[test]
+ fn build_spawn_plan_resolves_template_steps() {
+ let mut dashboard = test_dashboard(Vec::new(), 0);
+ dashboard.cfg.orchestration_templates = BTreeMap::from([(
+ "feature_development".to_string(),
+ crate::config::OrchestrationTemplateConfig {
+ description: None,
+ project: None,
+ task_group: None,
+ agent: Some("claude".to_string()),
+ profile: None,
+ worktree: Some(true),
+ steps: vec![
+ crate::config::OrchestrationTemplateStepConfig {
+ name: Some("planner".to_string()),
+ task: "Plan {{task}}".to_string(),
+ project: None,
+ task_group: None,
+ agent: None,
+ profile: None,
+ worktree: None,
+ },
+ crate::config::OrchestrationTemplateStepConfig {
+ name: Some("builder".to_string()),
+ task: "Build {{task}} in {{component}}".to_string(),
+ project: None,
+ task_group: None,
+ agent: None,
+ profile: None,
+ worktree: None,
+ },
+ ],
+ },
+ )]);
+
+ let plan = dashboard
+ .build_spawn_plan(
+ "template feature_development for stabilize auth callback with component=billing",
+ )
+ .expect("template spawn plan");
+
+ assert_eq!(
+ plan,
+ SpawnPlan::Template {
+ name: "feature_development".to_string(),
+ task: Some("stabilize auth callback".to_string()),
+ variables: BTreeMap::from([("component".to_string(), "billing".to_string(),)]),
+ step_count: 2,
+ }
+ );
+ }
+
+ #[tokio::test(flavor = "current_thread")]
+ async fn submit_spawn_prompt_launches_orchestration_template() -> Result<()> {
+ let tempdir = std::env::temp_dir().join(format!("dashboard-template-{}", Uuid::new_v4()));
+ let repo_root = tempdir.join("repo");
+ init_git_repo(&repo_root)?;
+
+ let original_dir = std::env::current_dir()?;
+ std::env::set_current_dir(&repo_root)?;
+
+ let mut cfg = build_config(&tempdir);
+ cfg.orchestration_templates = BTreeMap::from([(
+ "feature_development".to_string(),
+ crate::config::OrchestrationTemplateConfig {
+ description: None,
+ project: Some("ecc2-smoke".to_string()),
+ task_group: Some("{{task}}".to_string()),
+ agent: Some("claude".to_string()),
+ profile: None,
+ worktree: Some(false),
+ steps: vec![
+ crate::config::OrchestrationTemplateStepConfig {
+ name: Some("planner".to_string()),
+ task: "Plan {{task}}".to_string(),
+ project: None,
+ task_group: None,
+ agent: None,
+ profile: None,
+ worktree: None,
+ },
+ crate::config::OrchestrationTemplateStepConfig {
+ name: Some("builder".to_string()),
+ task: "Build {{task}} in {{component}}".to_string(),
+ project: None,
+ task_group: None,
+ agent: None,
+ profile: None,
+ worktree: None,
+ },
+ ],
+ },
+ )]);
+
+ let db = StateStore::open(&cfg.db_path)?;
+ let mut dashboard = Dashboard::new(db, cfg);
+ dashboard.spawn_input = Some(
+ "template feature_development for stabilize auth callback with component=billing"
+ .to_string(),
+ );
+
+ dashboard.submit_spawn_prompt().await;
+
+ let operator_note = dashboard
+ .operator_note
+ .clone()
+ .expect("template launch should set an operator note");
+ assert!(
+ operator_note
+ .contains("launched template feature_development (2/2 step(s)) for stabilize auth callback"),
+ "unexpected operator note: {operator_note}"
+ );
+ assert_eq!(dashboard.sessions.len(), 2);
+ assert!(dashboard
+ .sessions
+ .iter()
+ .all(|session| session.project == "ecc2-smoke"));
+ assert!(dashboard
+ .sessions
+ .iter()
+ .all(|session| session.task_group == "stabilize auth callback"));
+ let tasks = dashboard
+ .sessions
+ .iter()
+ .map(|session| session.task.as_str())
+ .collect::<std::collections::BTreeSet<_>>();
+ assert_eq!(
+ tasks,
+ std::collections::BTreeSet::from([
+ "Build stabilize auth callback in billing",
+ "Plan stabilize auth callback",
+ ])
+ );
+
+ std::env::set_current_dir(original_dir)?;
+ let _ = std::fs::remove_dir_all(&tempdir);
+ Ok(())
+ }
+
#[test]
fn expand_spawn_tasks_suffixes_multi_session_requests() {
assert_eq!(
@@ -13074,6 +13391,7 @@ diff --git a/src/lib.rs b/src/lib.rs
default_agent: "claude".to_string(),
default_agent_profile: None,
agent_profiles: Default::default(),
+ orchestration_templates: Default::default(),
auto_dispatch_unread_handoffs: false,
auto_dispatch_limit_per_session: 5,
auto_create_worktrees: true,