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 configurable harness runners

Affaan Mustafabcd869d520ac
diff --git a/ecc2/src/config/mod.rs b/ecc2/src/config/mod.rs
index 2f2309d0e..159d78f04 100644
--- a/ecc2/src/config/mod.rs
+++ b/ecc2/src/config/mod.rs
@@ -79,6 +79,26 @@ pub struct ResolvedAgentProfile {
pub append_system_prompt: Option<String>,
}
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct HarnessRunnerConfig {
+ pub program: String,
+ pub base_args: Vec<String>,
+ pub cwd_flag: Option<String>,
+ pub session_name_flag: Option<String>,
+ pub task_flag: Option<String>,
+ pub model_flag: Option<String>,
+ pub add_dir_flag: Option<String>,
+ pub include_directories_flag: Option<String>,
+ pub allowed_tools_flag: Option<String>,
+ pub disallowed_tools_flag: Option<String>,
+ pub permission_mode_flag: Option<String>,
+ pub max_budget_usd_flag: Option<String>,
+ pub append_system_prompt_flag: Option<String>,
+ pub inline_system_prompt_for_task: bool,
+ pub env: BTreeMap<String, String>,
+}
+
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
#[serde(default)]
pub struct OrchestrationTemplateConfig {
@@ -198,6 +218,7 @@ pub struct Config {
pub auto_terminate_stale_sessions: bool,
pub default_agent: String,
pub default_agent_profile: Option<String>,
+ pub harness_runners: BTreeMap<String, HarnessRunnerConfig>,
pub agent_profiles: BTreeMap<String, AgentProfileConfig>,
pub orchestration_templates: BTreeMap<String, OrchestrationTemplateConfig>,
pub memory_connectors: BTreeMap<String, MemoryConnectorConfig>,
@@ -263,6 +284,7 @@ impl Default for Config {
auto_terminate_stale_sessions: false,
default_agent: "claude".to_string(),
default_agent_profile: None,
+ harness_runners: BTreeMap::new(),
agent_profiles: BTreeMap::new(),
orchestration_templates: BTreeMap::new(),
memory_connectors: BTreeMap::new(),
@@ -329,6 +351,11 @@ impl Config {
self.resolve_agent_profile_inner(name, &mut chain)
}
+ pub fn harness_runner(&self, harness: &str) -> Option<&HarnessRunnerConfig> {
+ let key = harness.trim().to_ascii_lowercase();
+ self.harness_runners.get(&key)
+ }
+
pub fn resolve_orchestration_template(
&self,
name: &str,
@@ -720,6 +747,28 @@ impl ResolvedAgentProfile {
}
}
+impl Default for HarnessRunnerConfig {
+ fn default() -> Self {
+ Self {
+ program: String::new(),
+ base_args: Vec::new(),
+ cwd_flag: None,
+ session_name_flag: None,
+ task_flag: None,
+ model_flag: None,
+ add_dir_flag: None,
+ include_directories_flag: None,
+ allowed_tools_flag: None,
+ disallowed_tools_flag: None,
+ permission_mode_flag: None,
+ max_budget_usd_flag: None,
+ append_system_prompt_flag: None,
+ inline_system_prompt_for_task: true,
+ env: BTreeMap::new(),
+ }
+ }
+}
+
fn merge_unique<T>(base: &mut Vec<T>, additions: &[T])
where
T: Clone + PartialEq,
@@ -1210,6 +1259,44 @@ inherits = "a"
.contains("agent profile inheritance cycle"));
}
+ #[test]
+ fn harness_runners_deserialize_from_toml() {
+ let config: Config = toml::from_str(
+ r#"
+[harness_runners.cursor]
+program = "cursor-agent"
+base_args = ["run"]
+cwd_flag = "--cwd"
+session_name_flag = "--name"
+task_flag = "--task"
+model_flag = "--model"
+permission_mode_flag = "--permission-mode"
+inline_system_prompt_for_task = true
+
+[harness_runners.cursor.env]
+ECC_HARNESS = "cursor"
+"#,
+ )
+ .unwrap();
+
+ let runner = config.harness_runner("cursor").expect("cursor runner");
+ assert_eq!(runner.program, "cursor-agent");
+ assert_eq!(runner.base_args, vec!["run"]);
+ assert_eq!(runner.cwd_flag.as_deref(), Some("--cwd"));
+ assert_eq!(runner.session_name_flag.as_deref(), Some("--name"));
+ assert_eq!(runner.task_flag.as_deref(), Some("--task"));
+ assert_eq!(runner.model_flag.as_deref(), Some("--model"));
+ assert_eq!(
+ runner.permission_mode_flag.as_deref(),
+ Some("--permission-mode")
+ );
+ assert!(runner.inline_system_prompt_for_task);
+ assert_eq!(
+ runner.env.get("ECC_HARNESS").map(String::as_str),
+ Some("cursor")
+ );
+ }
+
#[test]
fn orchestration_templates_resolve_steps_and_interpolate_variables() {
let config: Config = toml::from_str(
diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rs
index 150b4ef05..a8ed0f915 100644
--- a/ecc2/src/session/manager.rs
+++ b/ecc2/src/session/manager.rs
@@ -2002,8 +2002,17 @@ pub async fn delete_session(db: &StateStore, id: &str) -> Result<()> {
Ok(())
}
-fn agent_program(agent_type: &str) -> Result<PathBuf> {
- match HarnessKind::from_agent_type(agent_type) {
+fn agent_program(cfg: &Config, agent_type: &str) -> Result<PathBuf> {
+ let harness = HarnessKind::from_agent_type(agent_type);
+ if let Some(runner) = cfg.harness_runner(harness.as_str()) {
+ let program = runner.program.trim();
+ if program.is_empty() {
+ anyhow::bail!("Configured harness runner for {harness} is missing a program");
+ }
+ return Ok(PathBuf::from(program));
+ }
+
+ match harness {
HarnessKind::Claude => Ok(PathBuf::from("claude")),
HarnessKind::Codex => Ok(PathBuf::from("codex")),
HarnessKind::OpenCode => Ok(PathBuf::from("opencode")),
@@ -2067,9 +2076,10 @@ pub async fn run_session(
return Ok(());
}
- let agent_program = agent_program(agent_type)?;
+ let agent_program = agent_program(cfg, agent_type)?;
let profile = db.get_session_profile(session_id)?;
let command = build_agent_command(
+ cfg,
agent_type,
&agent_program,
task,
@@ -2666,6 +2676,7 @@ async fn spawn_session_runner_for_program(
}
fn build_agent_command(
+ cfg: &Config,
agent_type: &str,
agent_program: &Path,
task: &str,
@@ -2674,6 +2685,17 @@ fn build_agent_command(
profile: Option<&SessionAgentProfile>,
) -> Command {
let harness = HarnessKind::from_agent_type(agent_type);
+ if let Some(runner) = cfg.harness_runner(harness.as_str()) {
+ return build_configured_harness_command(
+ runner,
+ agent_program,
+ task,
+ session_id,
+ working_dir,
+ profile,
+ );
+ }
+
let task = normalize_task_for_harness(harness, task, profile);
let mut command = Command::new(agent_program);
command.env("ECC_SESSION_ID", session_id);
@@ -2771,33 +2793,139 @@ fn build_agent_command(
command
}
+fn build_configured_harness_command(
+ runner: &crate::config::HarnessRunnerConfig,
+ agent_program: &Path,
+ 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);
+ for (key, value) in &runner.env {
+ if !value.trim().is_empty() {
+ command.env(key, value);
+ }
+ }
+ for arg in &runner.base_args {
+ if !arg.trim().is_empty() {
+ command.arg(arg);
+ }
+ }
+ if let Some(flag) = runner.cwd_flag.as_deref() {
+ command.arg(flag).arg(working_dir);
+ }
+ if let Some(flag) = runner.session_name_flag.as_deref() {
+ command.arg(flag).arg(format!("ecc-{session_id}"));
+ }
+ if let Some(profile) = profile {
+ if let (Some(flag), Some(model)) = (runner.model_flag.as_deref(), profile.model.as_ref()) {
+ command.arg(flag).arg(model);
+ }
+ if let Some(flag) = runner.add_dir_flag.as_deref() {
+ for dir in &profile.add_dirs {
+ command.arg(flag).arg(dir);
+ }
+ }
+ if let Some(flag) = runner.include_directories_flag.as_deref() {
+ if !profile.add_dirs.is_empty() {
+ let include_dirs = profile
+ .add_dirs
+ .iter()
+ .map(|dir| dir.to_string_lossy().to_string())
+ .collect::<Vec<_>>()
+ .join(",");
+ command.arg(flag).arg(include_dirs);
+ }
+ }
+ if let Some(flag) = runner.allowed_tools_flag.as_deref() {
+ if !profile.allowed_tools.is_empty() {
+ command.arg(flag).arg(profile.allowed_tools.join(","));
+ }
+ }
+ if let Some(flag) = runner.disallowed_tools_flag.as_deref() {
+ if !profile.disallowed_tools.is_empty() {
+ command.arg(flag).arg(profile.disallowed_tools.join(","));
+ }
+ }
+ if let (Some(flag), Some(permission_mode)) = (
+ runner.permission_mode_flag.as_deref(),
+ profile.permission_mode.as_ref(),
+ ) {
+ command.arg(flag).arg(permission_mode);
+ }
+ if let (Some(flag), Some(max_budget_usd)) = (
+ runner.max_budget_usd_flag.as_deref(),
+ profile.max_budget_usd,
+ ) {
+ command.arg(flag).arg(max_budget_usd.to_string());
+ }
+ if let (Some(flag), Some(prompt)) = (
+ runner.append_system_prompt_flag.as_deref(),
+ profile.append_system_prompt.as_ref(),
+ ) {
+ command.arg(flag).arg(prompt);
+ }
+ }
+
+ let task = if runner.inline_system_prompt_for_task && runner.append_system_prompt_flag.is_none()
+ {
+ normalize_task_with_inline_system_prompt(task, profile)
+ } else {
+ task.to_string()
+ };
+
+ if let Some(flag) = runner.task_flag.as_deref() {
+ command.arg(flag);
+ }
+ command
+ .arg(task)
+ .current_dir(working_dir)
+ .stdin(Stdio::null());
+ command
+}
+
fn normalize_task_for_harness(
harness: HarnessKind,
task: &str,
profile: Option<&SessionAgentProfile>,
) -> String {
- let Some(system_prompt) = profile.and_then(|profile| profile.append_system_prompt.as_ref())
- else {
- return task.to_string();
- };
+ let rendered = normalize_task_with_inline_system_prompt(task, profile);
match harness {
HarnessKind::Claude => task.to_string(),
- HarnessKind::Codex | HarnessKind::OpenCode | HarnessKind::Gemini => {
- format!("System instructions:\n{system_prompt}\n\nTask:\n{task}")
- }
+ HarnessKind::Codex | HarnessKind::OpenCode | HarnessKind::Gemini => rendered,
_ => task.to_string(),
}
}
+fn normalize_task_with_inline_system_prompt(
+ task: &str,
+ profile: Option<&SessionAgentProfile>,
+) -> String {
+ let Some(system_prompt) = profile.and_then(|profile| profile.append_system_prompt.as_ref())
+ else {
+ return task.to_string();
+ };
+ format!("System instructions:\n{system_prompt}\n\nTask:\n{task}")
+}
+
async fn spawn_claude_code(
agent_program: &Path,
task: &str,
session_id: &str,
working_dir: &Path,
) -> Result<u32> {
- let mut command =
- build_agent_command("claude", agent_program, task, session_id, working_dir, None);
+ let mut command = build_agent_command(
+ &Config::default(),
+ "claude",
+ agent_program,
+ task,
+ session_id,
+ working_dir,
+ None,
+ );
let child = command
.stdout(Stdio::null())
.stderr(Stdio::null())
@@ -3490,6 +3618,7 @@ mod tests {
auto_terminate_stale_sessions: false,
default_agent: "claude".to_string(),
default_agent_profile: None,
+ harness_runners: Default::default(),
agent_profiles: Default::default(),
orchestration_templates: Default::default(),
memory_connectors: Default::default(),
@@ -3534,6 +3663,7 @@ mod tests {
#[test]
fn build_agent_command_applies_profile_runner_flags_for_claude() {
+ let cfg = Config::default();
let profile = SessionAgentProfile {
profile_name: "reviewer".to_string(),
agent: None,
@@ -3548,6 +3678,7 @@ mod tests {
};
let command = build_agent_command(
+ &cfg,
"claude",
Path::new("claude"),
"review this change",
@@ -3590,6 +3721,7 @@ mod tests {
#[test]
fn build_agent_command_normalizes_runner_flags_for_codex() {
+ let cfg = Config::default();
let profile = SessionAgentProfile {
profile_name: "reviewer".to_string(),
agent: None,
@@ -3604,6 +3736,7 @@ mod tests {
};
let command = build_agent_command(
+ &cfg,
"codex",
Path::new("codex"),
"review this change",
@@ -3641,6 +3774,7 @@ mod tests {
#[test]
fn build_agent_command_normalizes_runner_flags_for_opencode() {
+ let cfg = Config::default();
let profile = SessionAgentProfile {
profile_name: "builder".to_string(),
agent: None,
@@ -3655,6 +3789,7 @@ mod tests {
};
let command = build_agent_command(
+ &cfg,
"opencode",
Path::new("opencode"),
"stabilize callback flow",
@@ -3685,6 +3820,7 @@ mod tests {
#[test]
fn build_agent_command_normalizes_runner_flags_for_gemini() {
+ let cfg = Config::default();
let profile = SessionAgentProfile {
profile_name: "investigator".to_string(),
agent: None,
@@ -3699,6 +3835,7 @@ mod tests {
};
let command = build_agent_command(
+ &cfg,
"gemini",
Path::new("gemini"),
"investigate auth regression",
@@ -3725,6 +3862,111 @@ mod tests {
);
}
+ #[test]
+ fn agent_program_uses_configured_runner_for_cursor() -> Result<()> {
+ let mut cfg = Config::default();
+ cfg.harness_runners.insert(
+ "cursor".to_string(),
+ crate::config::HarnessRunnerConfig {
+ program: "cursor-agent".to_string(),
+ ..Default::default()
+ },
+ );
+
+ assert_eq!(
+ agent_program(&cfg, "cursor")?,
+ PathBuf::from("cursor-agent")
+ );
+ Ok(())
+ }
+
+ #[test]
+ fn build_agent_command_uses_configured_runner_for_cursor() {
+ let mut cfg = Config::default();
+ cfg.harness_runners.insert(
+ "cursor".to_string(),
+ crate::config::HarnessRunnerConfig {
+ program: "cursor-agent".to_string(),
+ base_args: vec!["run".to_string()],
+ cwd_flag: Some("--cwd".to_string()),
+ session_name_flag: Some("--name".to_string()),
+ task_flag: Some("--task".to_string()),
+ model_flag: Some("--model".to_string()),
+ permission_mode_flag: Some("--permission-mode".to_string()),
+ add_dir_flag: Some("--context-dir".to_string()),
+ inline_system_prompt_for_task: true,
+ env: BTreeMap::from([("ECC_HARNESS".to_string(), "cursor".to_string())]),
+ ..Default::default()
+ },
+ );
+ let profile = SessionAgentProfile {
+ profile_name: "worker".to_string(),
+ agent: None,
+ model: Some("gpt-5.4".to_string()),
+ allowed_tools: Vec::new(),
+ disallowed_tools: Vec::new(),
+ permission_mode: Some("plan".to_string()),
+ add_dirs: vec![PathBuf::from("docs"), PathBuf::from("specs")],
+ max_budget_usd: None,
+ token_budget: None,
+ append_system_prompt: Some("Use repo context carefully.".to_string()),
+ };
+
+ let command = build_agent_command(
+ &cfg,
+ "cursor",
+ Path::new("cursor-agent"),
+ "fix callback regression",
+ "sess-cur1",
+ 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![
+ "run",
+ "--cwd",
+ "/tmp/repo",
+ "--name",
+ "ecc-sess-cur1",
+ "--model",
+ "gpt-5.4",
+ "--context-dir",
+ "docs",
+ "--context-dir",
+ "specs",
+ "--permission-mode",
+ "plan",
+ "--task",
+ "System instructions:\nUse repo context carefully.\n\nTask:\nfix callback regression",
+ ]
+ );
+ let mut envs = command
+ .as_std()
+ .get_envs()
+ .map(|(key, value)| {
+ (
+ key.to_string_lossy().to_string(),
+ value.map(|value| value.to_string_lossy().to_string()),
+ )
+ })
+ .collect::<Vec<_>>();
+ envs.sort();
+ assert_eq!(
+ envs,
+ vec![
+ ("ECC_HARNESS".to_string(), Some("cursor".to_string())),
+ ("ECC_SESSION_ID".to_string(), Some("sess-cur1".to_string())),
+ ]
+ );
+ }
+
#[test]
fn build_session_record_canonicalizes_known_agent_aliases() -> Result<()> {
let tempdir = TestDir::new("manager-canonical-agent-type")?;
diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rs
index dab25e72a..6345872e5 100644
--- a/ecc2/src/tui/dashboard.rs
+++ b/ecc2/src/tui/dashboard.rs
@@ -14590,6 +14590,7 @@ diff --git a/src/lib.rs b/src/lib.rs
auto_terminate_stale_sessions: false,
default_agent: "claude".to_string(),
default_agent_profile: None,
+ harness_runners: Default::default(),
agent_profiles: Default::default(),
orchestration_templates: Default::default(),
memory_connectors: Default::default(),