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 computer use remote dispatch
Affaan Mustafa30913b2cc4a0
diff --git a/ecc2/src/config/mod.rs b/ecc2/src/config/mod.rsindex 0f083e39d..d48bd9a67 100644--- a/ecc2/src/config/mod.rs+++ b/ecc2/src/config/mod.rs@@ -50,6 +50,16 @@ pub struct ConflictResolutionConfig {pub notify_lead: bool,}+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]+#[serde(default)]+pub struct ComputerUseDispatchConfig {+ pub agent: Option<String>,+ pub profile: Option<String>,+ pub use_worktree: bool,+ pub project: Option<String>,+ pub task_group: Option<String>,+}+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]#[serde(default)]pub struct AgentProfileConfig {@@ -223,6 +233,7 @@ pub struct Config {pub agent_profiles: BTreeMap<String, AgentProfileConfig>,pub orchestration_templates: BTreeMap<String, OrchestrationTemplateConfig>,pub memory_connectors: BTreeMap<String, MemoryConnectorConfig>,+ pub computer_use_dispatch: ComputerUseDispatchConfig,pub auto_dispatch_unread_handoffs: bool,pub auto_dispatch_limit_per_session: usize,pub auto_create_worktrees: bool,@@ -289,6 +300,7 @@ impl Default for Config {agent_profiles: BTreeMap::new(),orchestration_templates: BTreeMap::new(),memory_connectors: BTreeMap::new(),+ computer_use_dispatch: ComputerUseDispatchConfig::default(),auto_dispatch_unread_handoffs: false,auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,@@ -347,6 +359,26 @@ impl Config {self.budget_alert_thresholds.sanitized()}+ pub fn computer_use_dispatch_defaults(&self) -> ResolvedComputerUseDispatchConfig {+ let agent = self+ .computer_use_dispatch+ .agent+ .clone()+ .unwrap_or_else(|| self.default_agent.clone());+ let profile = self+ .computer_use_dispatch+ .profile+ .clone()+ .or_else(|| self.default_agent_profile.clone());+ ResolvedComputerUseDispatchConfig {+ agent,+ profile,+ use_worktree: self.computer_use_dispatch.use_worktree,+ project: self.computer_use_dispatch.project.clone(),+ task_group: self.computer_use_dispatch.task_group.clone(),+ }+ }+pub fn resolve_agent_profile(&self, name: &str) -> Result<ResolvedAgentProfile> {let mut chain = Vec::new();self.resolve_agent_profile_inner(name, &mut chain)@@ -771,6 +803,27 @@ impl Default for HarnessRunnerConfig {}}+impl Default for ComputerUseDispatchConfig {+ fn default() -> Self {+ Self {+ agent: None,+ profile: None,+ use_worktree: false,+ project: None,+ task_group: None,+ }+ }+}++#[derive(Debug, Clone, Default, PartialEq, Eq)]+pub struct ResolvedComputerUseDispatchConfig {+ pub agent: String,+ pub profile: Option<String>,+ pub use_worktree: bool,+ pub project: Option<String>,+ pub task_group: Option<String>,+}+fn merge_unique<T>(base: &mut Vec<T>, additions: &[T])whereT: Clone + PartialEq,@@ -851,8 +904,8 @@ impl BudgetAlertThresholds {#[cfg(test)]mod tests {use super::{- BudgetAlertThresholds, Config, ConflictResolutionConfig, ConflictResolutionStrategy,- PaneLayout,+ BudgetAlertThresholds, ComputerUseDispatchConfig, Config, ConflictResolutionConfig,+ ConflictResolutionStrategy, PaneLayout, ResolvedComputerUseDispatchConfig,};use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};use std::collections::BTreeMap;@@ -1202,6 +1255,42 @@ notify_lead = false);}+ #[test]+ fn computer_use_dispatch_deserializes_from_toml() {+ let config: Config = toml::from_str(+ r#"+[computer_use_dispatch]+agent = "codex"+profile = "browser"+use_worktree = true+project = "ops"+task_group = "remote browser"+"#,+ )+ .unwrap();++ assert_eq!(+ config.computer_use_dispatch,+ ComputerUseDispatchConfig {+ agent: Some("codex".to_string()),+ profile: Some("browser".to_string()),+ use_worktree: true,+ project: Some("ops".to_string()),+ task_group: Some("remote browser".to_string()),+ }+ );+ assert_eq!(+ config.computer_use_dispatch_defaults(),+ ResolvedComputerUseDispatchConfig {+ agent: "codex".to_string(),+ profile: Some("browser".to_string()),+ use_worktree: true,+ project: Some("ops".to_string()),+ task_group: Some("remote browser".to_string()),+ }+ );+ }+#[test]fn agent_profiles_resolve_inheritance_and_defaults() {let config: Config = toml::from_str(diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex 335802456..78e4bf464 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -45,6 +45,28 @@ impl WorktreePolicyArgs {}}+#[derive(clap::Args, Debug, Clone, Default)]+struct OptionalWorktreePolicyArgs {+ /// Create a dedicated worktree+ #[arg(short = 'w', long = "worktree", action = clap::ArgAction::SetTrue, overrides_with = "no_worktree")]+ worktree: bool,+ /// Skip dedicated worktree creation+ #[arg(long = "no-worktree", action = clap::ArgAction::SetTrue, overrides_with = "worktree")]+ no_worktree: bool,+}++impl OptionalWorktreePolicyArgs {+ fn resolve(&self, default_value: bool) -> bool {+ if self.worktree {+ true+ } else if self.no_worktree {+ false+ } else {+ default_value+ }+ }+}+#[derive(clap::Subcommand, Debug)]enum Commands {/// Launch the TUI dashboard@@ -479,6 +501,41 @@ enum RemoteCommands {#[arg(long)]json: bool,},+ /// Queue a remote computer-use task request+ ComputerUse {+ /// Goal to complete with computer-use/browser tools+ #[arg(long)]+ goal: String,+ /// Optional target URL to open first+ #[arg(long)]+ target_url: Option<String>,+ /// Extra context for the operator+ #[arg(long)]+ context: Option<String>,+ /// Optional lead session ID or alias to route through+ #[arg(long)]+ to_session: Option<String>,+ /// Task priority+ #[arg(long, value_enum, default_value_t = TaskPriorityArg::Normal)]+ priority: TaskPriorityArg,+ /// Agent type override (defaults to [computer_use_dispatch] or ECC default agent)+ #[arg(short, long)]+ agent: Option<String>,+ /// Agent profile override (defaults to [computer_use_dispatch] or ECC default profile)+ #[arg(long)]+ profile: Option<String>,+ #[command(flatten)]+ worktree: OptionalWorktreePolicyArgs,+ /// Optional project grouping override+ #[arg(long)]+ project: Option<String>,+ /// Optional task-group grouping override+ #[arg(long)]+ task_group: Option<String>,+ /// Emit machine-readable JSON instead of the human summary+ #[arg(long)]+ json: bool,+ },/// List queued remote task requestsList {/// Include already dispatched or failed requests@@ -816,6 +873,20 @@ struct RemoteDispatchHttpRequest {task_group: Option<String>,}+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+struct RemoteComputerUseHttpRequest {+ goal: String,+ target_url: Option<String>,+ context: Option<String>,+ to_session: Option<String>,+ priority: Option<TaskPriorityArg>,+ agent: Option<String>,+ profile: Option<String>,+ use_worktree: Option<bool>,+ project: Option<String>,+ task_group: Option<String>,+}+#[derive(Debug, Clone, Default, Deserialize)]#[serde(default)]struct JsonlMemoryConnectorRecord {@@ -1996,6 +2067,57 @@ async fn main() -> Result<()> {}}}+ RemoteCommands::ComputerUse {+ goal,+ target_url,+ context,+ to_session,+ priority,+ agent,+ profile,+ worktree,+ project,+ task_group,+ json,+ } => {+ let target_session_id = to_session+ .as_deref()+ .map(|value| resolve_session_id(&db, value))+ .transpose()?;+ let defaults = cfg.computer_use_dispatch_defaults();+ let request = session::manager::create_computer_use_remote_dispatch_request(+ &db,+ &cfg,+ &goal,+ target_url.as_deref(),+ context.as_deref(),+ target_session_id.as_deref(),+ priority.into(),+ agent.as_deref(),+ profile.as_deref(),+ Some(worktree.resolve(defaults.use_worktree)),+ session::SessionGrouping {+ project,+ task_group,+ },+ "cli_computer_use",+ None,+ )?;+ if json {+ println!("{}", serde_json::to_string_pretty(&request)?);+ } else {+ println!(+ "Queued remote {} request #{} [{}] {}",+ request.request_kind, request.id, request.priority, goal+ );+ if let Some(target_url) = request.target_url.as_deref() {+ println!("- target url {target_url}");+ }+ if let Some(target_session_id) = request.target_session_id.as_deref() {+ println!("- target {}", short_session(target_session_id));+ }+ }+ }RemoteCommands::List { all, limit, json } => {let requests = session::manager::list_remote_dispatch_requests(&db, all, limit)?;if json {@@ -2010,9 +2132,15 @@ async fn main() -> Result<()> {.as_deref().map(short_session).unwrap_or_else(|| "new-session".to_string());+ let label = format_remote_dispatch_kind(request.request_kind);println!(- "#{} [{}] {} -> {} | {}",- request.id, request.priority, request.status, target, request.task+ "#{} [{}] {} {} -> {} | {}",+ request.id,+ request.priority,+ label,+ request.status,+ target,+ request.task.lines().next().unwrap_or(&request.task));}}@@ -3096,6 +3224,13 @@ fn format_remote_dispatch_action(action: &session::manager::RemoteDispatchAction}}+fn format_remote_dispatch_kind(kind: session::RemoteDispatchKind) -> &'static str {+ match kind {+ session::RemoteDispatchKind::Standard => "standard",+ session::RemoteDispatchKind::ComputerUse => "computer_use",+ }+}+fn short_session(session_id: &str) -> String {session_id.chars().take(8).collect()}@@ -3225,6 +3360,86 @@ fn handle_remote_dispatch_connection(&serde_json::to_string(&request)?,)}+ ("POST", "/computer-use") => {+ let auth = headers+ .get("authorization")+ .map(String::as_str)+ .unwrap_or_default();+ let expected = format!("Bearer {bearer_token}");+ if auth != expected {+ return write_http_response(+ stream,+ 401,+ "application/json",+ &serde_json::json!({"error": "unauthorized"}).to_string(),+ );+ }++ let payload: RemoteComputerUseHttpRequest =+ serde_json::from_slice(&body).context("Invalid remote computer-use JSON body")?;+ if payload.goal.trim().is_empty() {+ return write_http_response(+ stream,+ 400,+ "application/json",+ &serde_json::json!({"error": "goal is required"}).to_string(),+ );+ }++ let target_session_id = match payload+ .to_session+ .as_deref()+ .map(|value| resolve_session_id(db, value))+ .transpose()+ {+ Ok(value) => value,+ Err(error) => {+ return write_http_response(+ stream,+ 400,+ "application/json",+ &serde_json::json!({"error": error.to_string()}).to_string(),+ );+ }+ };+ let requester = stream.peer_addr().ok().map(|addr| addr.ip().to_string());+ let defaults = cfg.computer_use_dispatch_defaults();+ let request = match session::manager::create_computer_use_remote_dispatch_request(+ db,+ cfg,+ &payload.goal,+ payload.target_url.as_deref(),+ payload.context.as_deref(),+ target_session_id.as_deref(),+ payload.priority.unwrap_or(TaskPriorityArg::Normal).into(),+ payload.agent.as_deref(),+ payload.profile.as_deref(),+ Some(payload.use_worktree.unwrap_or(defaults.use_worktree)),+ session::SessionGrouping {+ project: payload.project,+ task_group: payload.task_group,+ },+ "http_computer_use",+ requester.as_deref(),+ ) {+ Ok(request) => request,+ Err(error) => {+ return write_http_response(+ stream,+ 400,+ "application/json",+ &serde_json::json!({"error": error.to_string()}).to_string(),+ );+ }+ };++ write_http_response(+ stream,+ 202,+ "application/json",+ &serde_json::to_string(&request)?,+ )+ }_ => write_http_response(stream,404,@@ -4995,6 +5210,55 @@ mod tests {}}+ #[test]+ fn cli_parses_remote_computer_use_command() {+ let cli = Cli::try_parse_from([+ "ecc",+ "remote",+ "computer-use",+ "--goal",+ "Confirm the recovery banner",+ "--target-url",+ "https://ecc.tools/account",+ "--context",+ "Use the production flow",+ "--priority",+ "critical",+ "--agent",+ "codex",+ "--profile",+ "browser",+ "--no-worktree",+ ])+ .expect("remote computer-use should parse");++ match cli.command {+ Some(Commands::Remote {+ command:+ RemoteCommands::ComputerUse {+ goal,+ target_url,+ context,+ priority,+ agent,+ profile,+ worktree,+ ..+ },+ }) => {+ assert_eq!(goal, "Confirm the recovery banner");+ assert_eq!(target_url.as_deref(), Some("https://ecc.tools/account"));+ assert_eq!(context.as_deref(), Some("Use the production flow"));+ assert_eq!(priority, TaskPriorityArg::Critical);+ assert_eq!(agent.as_deref(), Some("codex"));+ assert_eq!(profile.as_deref(), Some("browser"));+ assert!(worktree.no_worktree);+ assert!(!worktree.worktree);+ }+ _ => panic!("expected remote computer-use subcommand"),+ }+ }+#[test]fn cli_parses_start_with_handoff_source() {let cli = Cli::try_parse_from([diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex e2dccfe57..5c6d4e30f 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -14,8 +14,8 @@ use super::runtime::capture_command_output;use super::store::StateStore;use super::{default_project_label, default_task_group_label, normalize_group_label, HarnessKind,- ScheduledTask, Session, SessionAgentProfile, SessionGrouping, SessionHarnessInfo,- SessionMetrics, SessionState,+ RemoteDispatchKind, ScheduledTask, Session, SessionAgentProfile, SessionGrouping,+ SessionHarnessInfo, SessionMetrics, SessionState,};use crate::comms::{self, MessageType, TaskPriority};use crate::config::Config;@@ -268,6 +268,125 @@ pub fn create_remote_dispatch_request() -> Result<super::RemoteDispatchRequest> {let working_dir =std::env::current_dir().context("Failed to resolve current working directory")?;+ create_remote_dispatch_request_inner(+ db,+ cfg,+ RemoteDispatchKind::Standard,+ &working_dir,+ task,+ None,+ target_session_id,+ priority,+ agent_type,+ profile_name,+ use_worktree,+ grouping,+ source,+ requester,+ )+}++#[allow(clippy::too_many_arguments)]+pub fn create_computer_use_remote_dispatch_request(+ db: &StateStore,+ cfg: &Config,+ goal: &str,+ target_url: Option<&str>,+ context: Option<&str>,+ target_session_id: Option<&str>,+ priority: TaskPriority,+ agent_type_override: Option<&str>,+ profile_name_override: Option<&str>,+ use_worktree_override: Option<bool>,+ grouping: SessionGrouping,+ source: &str,+ requester: Option<&str>,+) -> Result<super::RemoteDispatchRequest> {+ let working_dir =+ std::env::current_dir().context("Failed to resolve current working directory")?;+ create_computer_use_remote_dispatch_request_in_dir(+ db,+ cfg,+ &working_dir,+ goal,+ target_url,+ context,+ target_session_id,+ priority,+ agent_type_override,+ profile_name_override,+ use_worktree_override,+ grouping,+ source,+ requester,+ )+}++#[allow(clippy::too_many_arguments)]+fn create_computer_use_remote_dispatch_request_in_dir(+ db: &StateStore,+ cfg: &Config,+ working_dir: &Path,+ goal: &str,+ target_url: Option<&str>,+ context: Option<&str>,+ target_session_id: Option<&str>,+ priority: TaskPriority,+ agent_type_override: Option<&str>,+ profile_name_override: Option<&str>,+ use_worktree_override: Option<bool>,+ grouping: SessionGrouping,+ source: &str,+ requester: Option<&str>,+) -> Result<super::RemoteDispatchRequest> {+ let defaults = cfg.computer_use_dispatch_defaults();+ let task = render_computer_use_task(goal, target_url, context);+ let agent_type = agent_type_override.unwrap_or(&defaults.agent);+ let profile_name = profile_name_override.or(defaults.profile.as_deref());+ let use_worktree = use_worktree_override.unwrap_or(defaults.use_worktree);+ let grouping = SessionGrouping {+ project: grouping.project.or(defaults.project),+ task_group: grouping+ .task_group+ .or(defaults.task_group)+ .or_else(|| Some(default_task_group_label(goal))),+ };++ create_remote_dispatch_request_inner(+ db,+ cfg,+ RemoteDispatchKind::ComputerUse,+ working_dir,+ &task,+ target_url,+ target_session_id,+ priority,+ agent_type,+ profile_name,+ use_worktree,+ grouping,+ source,+ requester,+ )+}++#[allow(clippy::too_many_arguments)]+fn create_remote_dispatch_request_inner(+ db: &StateStore,+ cfg: &Config,+ request_kind: RemoteDispatchKind,+ working_dir: &Path,+ task: &str,+ target_url: Option<&str>,+ target_session_id: Option<&str>,+ priority: TaskPriority,+ agent_type: &str,+ profile_name: Option<&str>,+ use_worktree: bool,+ grouping: SessionGrouping,+ source: &str,+ requester: Option<&str>,+) -> Result<super::RemoteDispatchRequest> {let project = grouping.project.as_deref()@@ -288,8 +407,10 @@ pub fn create_remote_dispatch_request(}db.insert_remote_dispatch_request(+ request_kind,target_session_id,task,+ target_url,priority,&agent_type,profile_name,@@ -302,6 +423,24 @@ pub fn create_remote_dispatch_request()}+fn render_computer_use_task(goal: &str, target_url: Option<&str>, context: Option<&str>) -> String {+ let mut lines = vec![+ "Computer-use task.".to_string(),+ format!("Goal: {}", goal.trim()),+ ];+ if let Some(target_url) = target_url.map(str::trim).filter(|value| !value.is_empty()) {+ lines.push(format!("Target URL: {target_url}"));+ }+ if let Some(context) = context.map(str::trim).filter(|value| !value.is_empty()) {+ lines.push(format!("Context: {context}"));+ }+ lines.push(+ "Use browser or computer-use tools directly when available, and report blockers clearly if auth, approvals, or local-device access prevent completion."+ .to_string(),+ );+ lines.join("\n")+}+pub fn list_remote_dispatch_requests(db: &StateStore,include_processed: bool,@@ -3840,6 +3979,7 @@ mod tests {agent_profiles: Default::default(),orchestration_templates: Default::default(),memory_connectors: Default::default(),+ computer_use_dispatch: crate::config::ComputerUseDispatchConfig::default(),auto_dispatch_unread_handoffs: false,auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,@@ -4656,8 +4796,10 @@ mod tests {let (fake_runner, _log_path) = write_fake_claude(tempdir.path())?;let request = db.insert_remote_dispatch_request(+ RemoteDispatchKind::Standard,None,"Remote phone triage",+ None,TaskPriority::High,"claude",None,@@ -4703,6 +4845,59 @@ mod tests {Ok(())}+ #[test]+ fn create_computer_use_remote_dispatch_request_uses_config_defaults() -> Result<()> {+ let tempdir = TestDir::new("manager-create-computer-use-remote-defaults")?;+ let repo_root = tempdir.path().join("repo");+ init_git_repo(&repo_root)?;++ let mut cfg = build_config(tempdir.path());+ cfg.computer_use_dispatch = crate::config::ComputerUseDispatchConfig {+ agent: Some("codex".to_string()),+ profile: None,+ use_worktree: false,+ project: Some("ops".to_string()),+ task_group: Some("remote browser".to_string()),+ };+ let db = StateStore::open(&cfg.db_path)?;++ let request = create_computer_use_remote_dispatch_request_in_dir(+ &db,+ &cfg,+ &repo_root,+ "Open the billing portal and confirm the refund banner",+ Some("https://ecc.tools/account"),+ Some("Use the production account flow"),+ None,+ TaskPriority::Critical,+ None,+ None,+ None,+ SessionGrouping::default(),+ "http_computer_use",+ Some("127.0.0.1"),+ )?;++ assert_eq!(request.request_kind, RemoteDispatchKind::ComputerUse);+ assert_eq!(+ request.target_url.as_deref(),+ Some("https://ecc.tools/account")+ );+ assert_eq!(request.agent_type, "codex");+ assert_eq!(request.project, "ops");+ assert_eq!(request.task_group, "remote browser");+ assert!(!request.use_worktree);+ assert!(request.task.contains("Computer-use task."));+ assert!(request.task.contains("Goal: Open the billing portal"));+ assert!(request+ .task+ .contains("Target URL: https://ecc.tools/account"));+ assert!(request+ .task+ .contains("Context: Use the production account flow"));+ Ok(())+ }+#[tokio::test(flavor = "current_thread")]async fn stop_session_kills_process_and_optionally_cleans_worktree() -> Result<()> {let tempdir = TestDir::new("manager-stop-session")?;diff --git a/ecc2/src/session/mod.rs b/ecc2/src/session/mod.rsindex 5175d9d92..1f53a6fb4 100644--- a/ecc2/src/session/mod.rs+++ b/ecc2/src/session/mod.rs@@ -398,8 +398,10 @@ pub struct ScheduledTask {#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]pub struct RemoteDispatchRequest {pub id: i64,+ pub request_kind: RemoteDispatchKind,pub target_session_id: Option<String>,pub task: String,+ pub target_url: Option<String>,pub priority: crate::comms::TaskPriority,pub agent_type: String,pub profile_name: Option<String>,@@ -418,6 +420,31 @@ pub struct RemoteDispatchRequest {pub dispatched_at: Option<DateTime<Utc>>,}+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum RemoteDispatchKind {+ Standard,+ ComputerUse,+}++impl fmt::Display for RemoteDispatchKind {+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {+ match self {+ Self::Standard => write!(f, "standard"),+ Self::ComputerUse => write!(f, "computer_use"),+ }+ }+}++impl RemoteDispatchKind {+ pub fn from_db_value(value: &str) -> Self {+ match value {+ "computer_use" => Self::ComputerUse,+ _ => Self::Standard,+ }+ }+}+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]#[serde(rename_all = "snake_case")]pub enum RemoteDispatchStatus {diff --git a/ecc2/src/session/store.rs b/ecc2/src/session/store.rsindex d23187c9e..6d8087846 100644--- a/ecc2/src/session/store.rs+++ b/ecc2/src/session/store.rs@@ -18,8 +18,8 @@ use super::{ContextGraphCompactionStats, ContextGraphEntity, ContextGraphEntityDetail,ContextGraphObservation, ContextGraphRecallEntry, ContextGraphRelation, ContextGraphSyncStats,ContextObservationPriority, DecisionLogEntry, FileActivityAction, FileActivityEntry,- HarnessKind, RemoteDispatchRequest, RemoteDispatchStatus, ScheduledTask, Session,- SessionAgentProfile, SessionHarnessInfo, SessionMessage, SessionMetrics, SessionState,+ HarnessKind, RemoteDispatchKind, RemoteDispatchRequest, RemoteDispatchStatus, ScheduledTask,+ Session, SessionAgentProfile, SessionHarnessInfo, SessionMessage, SessionMetrics, SessionState,WorktreeInfo,};@@ -318,8 +318,10 @@ impl StateStore {CREATE TABLE IF NOT EXISTS remote_dispatch_requests (id INTEGER PRIMARY KEY AUTOINCREMENT,+ request_kind TEXT NOT NULL DEFAULT 'standard',target_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,task TEXT NOT NULL,+ target_url TEXT,priority INTEGER NOT NULL DEFAULT 1,agent_type TEXT NOT NULL,profile_name TEXT,@@ -681,6 +683,24 @@ impl StateStore {.context("Failed to add last_auto_prune_active_skipped column to daemon_activity table")?;}+ if !self.has_column("remote_dispatch_requests", "request_kind")? {+ self.conn+ .execute(+ "ALTER TABLE remote_dispatch_requests ADD COLUMN request_kind TEXT NOT NULL DEFAULT 'standard'",+ [],+ )+ .context("Failed to add request_kind column to remote_dispatch_requests table")?;+ }++ if !self.has_column("remote_dispatch_requests", "target_url")? {+ self.conn+ .execute(+ "ALTER TABLE remote_dispatch_requests ADD COLUMN target_url TEXT",+ [],+ )+ .context("Failed to add target_url column to remote_dispatch_requests table")?;+ }+self.conn.execute_batch("CREATE UNIQUE INDEX IF NOT EXISTS idx_tool_log_hook_eventON tool_log(hook_event_id)@@ -1192,8 +1212,10 @@ impl StateStore {#[allow(clippy::too_many_arguments)]pub fn insert_remote_dispatch_request(&self,+ request_kind: RemoteDispatchKind,target_session_id: Option<&str>,task: &str,+ target_url: Option<&str>,priority: crate::comms::TaskPriority,agent_type: &str,profile_name: Option<&str>,@@ -1207,8 +1229,10 @@ impl StateStore {let now = chrono::Utc::now();self.conn.execute("INSERT INTO remote_dispatch_requests (+ request_kind,target_session_id,task,+ target_url,priority,agent_type,profile_name,@@ -1221,10 +1245,12 @@ impl StateStore {status,created_at,updated_at- ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, 'pending', ?12, ?13)",+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, 'pending', ?14, ?15)",rusqlite::params![+ request_kind.to_string(),target_session_id,task,+ target_url,task_priority_db_value(priority),agent_type,profile_name,@@ -1250,7 +1276,7 @@ impl StateStore {limit: usize,) -> Result<Vec<RemoteDispatchRequest>> {let sql = if include_processed {- "SELECT id, target_session_id, task, priority, agent_type, profile_name, working_dir,+ "SELECT id, request_kind, target_session_id, task, target_url, priority, agent_type, profile_name, working_dir,project, task_group, use_worktree, source, requester, status,result_session_id, result_action, error, created_at, updated_at, dispatched_atFROM remote_dispatch_requests@@ -1258,7 +1284,7 @@ impl StateStore {priority DESC, created_at ASC, id ASCLIMIT ?1"} else {- "SELECT id, target_session_id, task, priority, agent_type, profile_name, working_dir,+ "SELECT id, request_kind, target_session_id, task, target_url, priority, agent_type, profile_name, working_dir,project, task_group, use_worktree, source, requester, status,result_session_id, result_action, error, created_at, updated_at, dispatched_atFROM remote_dispatch_requests@@ -1285,7 +1311,7 @@ impl StateStore {) -> Result<Option<RemoteDispatchRequest>> {self.conn.query_row(- "SELECT id, target_session_id, task, priority, agent_type, profile_name, working_dir,+ "SELECT id, request_kind, target_session_id, task, target_url, priority, agent_type, profile_name, working_dir,project, task_group, use_worktree, source, requester, status,result_session_id, result_action, error, created_at, updated_at, dispatched_atFROM remote_dispatch_requests@@ -3900,29 +3926,31 @@ fn map_scheduled_task(row: &rusqlite::Row<'_>) -> rusqlite::Result<ScheduledTask}fn map_remote_dispatch_request(row: &rusqlite::Row<'_>) -> rusqlite::Result<RemoteDispatchRequest> {- let created_at = parse_store_timestamp(row.get::<_, String>(16)?, 16)?;- let updated_at = parse_store_timestamp(row.get::<_, String>(17)?, 17)?;+ let created_at = parse_store_timestamp(row.get::<_, String>(18)?, 18)?;+ let updated_at = parse_store_timestamp(row.get::<_, String>(19)?, 19)?;let dispatched_at = row- .get::<_, Option<String>>(18)?- .map(|value| parse_store_timestamp(value, 18))+ .get::<_, Option<String>>(20)?+ .map(|value| parse_store_timestamp(value, 20)).transpose()?;Ok(RemoteDispatchRequest {id: row.get(0)?,- target_session_id: normalize_optional_string(row.get(1)?),- task: row.get(2)?,- priority: task_priority_from_db_value(row.get::<_, i64>(3)?),- agent_type: row.get(4)?,- profile_name: normalize_optional_string(row.get(5)?),- working_dir: PathBuf::from(row.get::<_, String>(6)?),- project: row.get(7)?,- task_group: row.get(8)?,- use_worktree: row.get::<_, i64>(9)? != 0,- source: row.get(10)?,- requester: normalize_optional_string(row.get(11)?),- status: RemoteDispatchStatus::from_db_value(&row.get::<_, String>(12)?),- result_session_id: normalize_optional_string(row.get(13)?),- result_action: normalize_optional_string(row.get(14)?),- error: normalize_optional_string(row.get(15)?),+ request_kind: RemoteDispatchKind::from_db_value(&row.get::<_, String>(1)?),+ target_session_id: normalize_optional_string(row.get(2)?),+ task: row.get(3)?,+ target_url: normalize_optional_string(row.get(4)?),+ priority: task_priority_from_db_value(row.get::<_, i64>(5)?),+ agent_type: row.get(6)?,+ profile_name: normalize_optional_string(row.get(7)?),+ working_dir: PathBuf::from(row.get::<_, String>(8)?),+ project: row.get(9)?,+ task_group: row.get(10)?,+ use_worktree: row.get::<_, i64>(11)? != 0,+ source: row.get(12)?,+ requester: normalize_optional_string(row.get(13)?),+ status: RemoteDispatchStatus::from_db_value(&row.get::<_, String>(14)?),+ result_session_id: normalize_optional_string(row.get(15)?),+ result_action: normalize_optional_string(row.get(16)?),+ error: normalize_optional_string(row.get(17)?),created_at,updated_at,dispatched_at,diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex c2f940565..ebdf2e538 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -14612,6 +14612,7 @@ diff --git a/src/lib.rs b/src/lib.rsagent_profiles: Default::default(),orchestration_templates: Default::default(),memory_connectors: Default::default(),+ computer_use_dispatch: crate::config::ComputerUseDispatchConfig::default(),auto_dispatch_unread_handoffs: false,auto_dispatch_limit_per_session: 5,auto_create_worktrees: true,