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 worktree conflict protocol
Affaan Mustafad8c8178f92f4
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex e70ee2226..6a5b3cd65 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -203,6 +203,20 @@ enum Commands {#[arg(long)]check: bool,},+ /// Show conflict-resolution protocol for a worktree+ WorktreeResolution {+ /// Session ID or alias+ session_id: Option<String>,+ /// Show conflict protocol for all conflicted worktrees+ #[arg(long)]+ all: bool,+ /// Emit machine-readable JSON instead of the human summary+ #[arg(long)]+ json: bool,+ /// Return a non-zero exit code when conflicted worktrees are present+ #[arg(long)]+ check: bool,+ },/// Merge a session worktree branch into its base branchMergeWorktree {/// Session ID or alias@@ -704,6 +718,46 @@ async fn main() -> Result<()> {std::process::exit(worktree_status_reports_exit_code(&reports));}}+ Some(Commands::WorktreeResolution {+ session_id,+ all,+ json,+ check,+ }) => {+ if all && session_id.is_some() {+ return Err(anyhow::anyhow!(+ "worktree-resolution does not accept a session ID when --all is set"+ ));+ }+ let reports = if all {+ session::manager::list_sessions(&db)?+ .into_iter()+ .map(|session| build_worktree_resolution_report(&session))+ .collect::<Result<Vec<_>>>()?+ .into_iter()+ .filter(|report| report.conflicted)+ .collect::<Vec<_>>()+ } else {+ let id = session_id.unwrap_or_else(|| "latest".to_string());+ let resolved_id = resolve_session_id(&db, &id)?;+ let session = db+ .get_session(&resolved_id)?+ .ok_or_else(|| anyhow::anyhow!("Session not found: {resolved_id}"))?;+ vec![build_worktree_resolution_report(&session)?]+ };+ if json {+ if all {+ println!("{}", serde_json::to_string_pretty(&reports)?);+ } else {+ println!("{}", serde_json::to_string_pretty(&reports[0])?);+ }+ } else {+ println!("{}", format_worktree_resolution_reports_human(&reports));+ }+ if check {+ std::process::exit(worktree_resolution_reports_exit_code(&reports));+ }+ }Some(Commands::MergeWorktree {session_id,all,@@ -987,6 +1041,22 @@ struct WorktreeStatusReport {merge_readiness: Option<WorktreeMergeReadinessReport>,}+#[derive(Debug, Clone, Serialize)]+struct WorktreeResolutionReport {+ session_id: String,+ task: String,+ session_state: String,+ attached: bool,+ conflicted: bool,+ check_exit_code: i32,+ path: Option<String>,+ branch: Option<String>,+ base_branch: Option<String>,+ summary: String,+ conflicts: Vec<String>,+ resolution_steps: Vec<String>,+}+fn build_worktree_status_report(session: &session::Session, include_patch: bool) -> Result<WorktreeStatusReport> {let Some(worktree) = session.worktree.as_ref() else {return Ok(WorktreeStatusReport {@@ -1047,6 +1117,55 @@ fn build_worktree_status_report(session: &session::Session, include_patch: bool)})}+fn build_worktree_resolution_report(session: &session::Session) -> Result<WorktreeResolutionReport> {+ let Some(worktree) = session.worktree.as_ref() else {+ return Ok(WorktreeResolutionReport {+ session_id: session.id.clone(),+ task: session.task.clone(),+ session_state: session.state.to_string(),+ attached: false,+ conflicted: false,+ check_exit_code: 0,+ path: None,+ branch: None,+ base_branch: None,+ summary: "No worktree attached".to_string(),+ conflicts: Vec::new(),+ resolution_steps: Vec::new(),+ });+ };++ let merge_readiness = worktree::merge_readiness(worktree)?;+ let conflicted = merge_readiness.status == worktree::MergeReadinessStatus::Conflicted;+ let resolution_steps = if conflicted {+ vec![+ format!("Inspect current patch: ecc worktree-status {} --patch", session.id),+ format!("Open worktree: cd {}", worktree.path.display()),+ "Resolve conflicts and stage files: git add <paths>".to_string(),+ format!("Commit the resolution on {}: git commit", worktree.branch),+ format!("Re-check readiness: ecc worktree-status {} --check", session.id),+ format!("Merge when clear: ecc merge-worktree {}", session.id),+ ]+ } else {+ Vec::new()+ };++ Ok(WorktreeResolutionReport {+ session_id: session.id.clone(),+ task: session.task.clone(),+ session_state: session.state.to_string(),+ attached: true,+ conflicted,+ check_exit_code: if conflicted { 2 } else { 0 },+ path: Some(worktree.path.display().to_string()),+ branch: Some(worktree.branch.clone()),+ base_branch: Some(worktree.base_branch.clone()),+ summary: merge_readiness.summary,+ conflicts: merge_readiness.conflicts,+ resolution_steps,+ })+}+fn format_worktree_status_human(report: &WorktreeStatusReport) -> String {let mut lines = vec![format!("Worktree status for {} [{}]",@@ -1102,6 +1221,58 @@ fn format_worktree_status_reports_human(reports: &[WorktreeStatusReport]) -> Str.join("\n\n")}+fn format_worktree_resolution_human(report: &WorktreeResolutionReport) -> String {+ let mut lines = vec![format!(+ "Worktree resolution for {} [{}]",+ short_session(&report.session_id),+ report.session_state+ )];+ lines.push(format!("Task {}", report.task));++ if !report.attached {+ lines.push(report.summary.clone());+ return lines.join("\n");+ }++ if let Some(path) = report.path.as_ref() {+ lines.push(format!("Path {path}"));+ }+ if let (Some(branch), Some(base_branch)) = (report.branch.as_ref(), report.base_branch.as_ref()) {+ lines.push(format!("Branch {branch} (base {base_branch})"));+ }+ lines.push(report.summary.clone());++ if !report.conflicts.is_empty() {+ lines.push("Conflicts".to_string());+ for conflict in &report.conflicts {+ lines.push(format!("- {conflict}"));+ }+ }++ if report.resolution_steps.is_empty() {+ lines.push("No conflict-resolution steps required".to_string());+ } else {+ lines.push("Resolution steps".to_string());+ for (index, step) in report.resolution_steps.iter().enumerate() {+ lines.push(format!("{}. {step}", index + 1));+ }+ }++ lines.join("\n")+}++fn format_worktree_resolution_reports_human(reports: &[WorktreeResolutionReport]) -> String {+ if reports.is_empty() {+ return "No conflicted worktrees found".to_string();+ }++ reports+ .iter()+ .map(format_worktree_resolution_human)+ .collect::<Vec<_>>()+ .join("\n\n")+}+fn format_worktree_merge_human(outcome: &session::manager::WorktreeMergeOutcome) -> String {let mut lines = vec![format!("Merged worktree for {}",@@ -1192,6 +1363,14 @@ fn worktree_status_reports_exit_code(reports: &[WorktreeStatusReport]) -> i32 {.unwrap_or(0)}+fn worktree_resolution_reports_exit_code(reports: &[WorktreeResolutionReport]) -> i32 {+ reports+ .iter()+ .map(|report| report.check_exit_code)+ .max()+ .unwrap_or(0)+}+fn format_prune_worktrees_human(outcome: &session::manager::WorktreePruneOutcome) -> String {let mut lines = Vec::new();@@ -1626,6 +1805,48 @@ mod tests {}}+ #[test]+ fn cli_parses_worktree_resolution_flags() {+ let cli = Cli::try_parse_from(["ecc", "worktree-resolution", "planner", "--json", "--check"])+ .expect("worktree-resolution flags should parse");++ match cli.command {+ Some(Commands::WorktreeResolution {+ session_id,+ all,+ json,+ check,+ }) => {+ assert_eq!(session_id.as_deref(), Some("planner"));+ assert!(!all);+ assert!(json);+ assert!(check);+ }+ _ => panic!("expected worktree-resolution subcommand"),+ }+ }++ #[test]+ fn cli_parses_worktree_resolution_all_flag() {+ let cli = Cli::try_parse_from(["ecc", "worktree-resolution", "--all"])+ .expect("worktree-resolution --all should parse");++ match cli.command {+ Some(Commands::WorktreeResolution {+ session_id,+ all,+ json,+ check,+ }) => {+ assert!(session_id.is_none());+ assert!(all);+ assert!(!json);+ assert!(!check);+ }+ _ => panic!("expected worktree-resolution subcommand"),+ }+ }+#[test]fn cli_parses_prune_worktrees_json_flag() {let cli = Cli::try_parse_from(["ecc", "prune-worktrees", "--json"])@@ -1721,6 +1942,71 @@ mod tests {assert!(text.contains("--- Branch diff vs main ---"));}+ #[test]+ fn format_worktree_resolution_human_includes_protocol_steps() {+ let report = WorktreeResolutionReport {+ session_id: "deadbeefcafefeed".to_string(),+ task: "Resolve merge conflict".to_string(),+ session_state: "stopped".to_string(),+ attached: true,+ conflicted: true,+ check_exit_code: 2,+ path: Some("/tmp/ecc/wt-1".to_string()),+ branch: Some("ecc/deadbeefcafefeed".to_string()),+ base_branch: Some("main".to_string()),+ summary: "Merge blocked by 1 conflict(s): README.md".to_string(),+ conflicts: vec!["README.md".to_string()],+ resolution_steps: vec![+ "Inspect current patch: ecc worktree-status deadbeefcafefeed --patch".to_string(),+ "Open worktree: cd /tmp/ecc/wt-1".to_string(),+ "Resolve conflicts and stage files: git add <paths>".to_string(),+ ],+ };++ let text = format_worktree_resolution_human(&report);+ assert!(text.contains("Worktree resolution for deadbeef [stopped]"));+ assert!(text.contains("Merge blocked by 1 conflict(s): README.md"));+ assert!(text.contains("Conflicts"));+ assert!(text.contains("- README.md"));+ assert!(text.contains("Resolution steps"));+ assert!(text.contains("1. Inspect current patch"));+ }++ #[test]+ fn worktree_resolution_reports_exit_code_tracks_conflicts() {+ let clear = WorktreeResolutionReport {+ session_id: "clear".to_string(),+ task: "ok".to_string(),+ session_state: "stopped".to_string(),+ attached: false,+ conflicted: false,+ check_exit_code: 0,+ path: None,+ branch: None,+ base_branch: None,+ summary: "No worktree attached".to_string(),+ conflicts: Vec::new(),+ resolution_steps: Vec::new(),+ };+ let conflicted = WorktreeResolutionReport {+ session_id: "conflicted".to_string(),+ task: "resolve".to_string(),+ session_state: "failed".to_string(),+ attached: true,+ conflicted: true,+ check_exit_code: 2,+ path: Some("/tmp/ecc/wt-2".to_string()),+ branch: Some("ecc/conflicted".to_string()),+ base_branch: Some("main".to_string()),+ summary: "Merge blocked by 1 conflict(s): src/lib.rs".to_string(),+ conflicts: vec!["src/lib.rs".to_string()],+ resolution_steps: vec!["Inspect current patch".to_string()],+ };++ assert_eq!(worktree_resolution_reports_exit_code(&[clear]), 0);+ assert_eq!(worktree_resolution_reports_exit_code(&[conflicted]), 2);+ }+#[test]fn format_prune_worktrees_human_reports_cleaned_and_active_sessions() {let text = format_prune_worktrees_human(&session::manager::WorktreePruneOutcome {diff --git a/ecc2/src/tui/app.rs b/ecc2/src/tui/app.rsindex 34f3bc17e..8b8e7cacf 100644--- a/ecc2/src/tui/app.rs+++ b/ecc2/src/tui/app.rs@@ -46,6 +46,7 @@ pub async fn run(db: StateStore, cfg: Config) -> Result<()> {(_, KeyCode::Char('g')) => dashboard.auto_dispatch_backlog().await,(_, KeyCode::Char('G')) => dashboard.coordinate_backlog().await,(_, KeyCode::Char('v')) => dashboard.toggle_output_mode(),+ (_, KeyCode::Char('c')) => dashboard.toggle_conflict_protocol_mode(),(_, KeyCode::Char('m')) => dashboard.merge_selected_worktree().await,(_, KeyCode::Char('M')) => dashboard.merge_ready_worktrees().await,(_, KeyCode::Char('p')) => dashboard.toggle_auto_dispatch_policy(),diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex 58aa2d29c..1282fb0a3 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -54,6 +54,7 @@ pub struct Dashboard {selected_diff_summary: Option<String>,selected_diff_preview: Vec<String>,selected_diff_patch: Option<String>,+ selected_conflict_protocol: Option<String>,selected_merge_readiness: Option<worktree::MergeReadiness>,output_mode: OutputMode,selected_pane: Pane,@@ -94,6 +95,7 @@ enum Pane {enum OutputMode {SessionOutput,WorktreeDiff,+ ConflictProtocol,}#[derive(Debug, Clone, Copy)]@@ -173,6 +175,7 @@ impl Dashboard {selected_diff_summary: None,selected_diff_preview: Vec::new(),selected_diff_patch: None,+ selected_conflict_protocol: None,selected_merge_readiness: None,output_mode: OutputMode::SessionOutput,selected_pane: Pane::Sessions,@@ -365,6 +368,16 @@ impl Dashboard {});(" Diff ", content)}+ OutputMode::ConflictProtocol => {+ let content = self+ .selected_conflict_protocol+ .clone()+ .unwrap_or_else(|| {+ "No conflicted worktree available for the selected session."+ .to_string()+ });+ (" Conflict Protocol ", content)+ }}} else {(" Output ", "No sessions. Press 'n' to start one.".to_string())@@ -462,7 +475,7 @@ impl Dashboard {fn render_status_bar(&self, frame: &mut Frame, area: Rect) {let text = format!(- " [n]ew session [a]ssign re[b]alance global re[B]alance dra[i]n inbox [g]lobal dispatch coordinate [G]lobal [v]iew diff [m]erge merge ready [M] auto-merge [w] toggle [p]olicy [,/.] dispatch limit [s]top [u]resume [x]cleanup prune inactive [X] [d]elete [r]efresh [Tab] switch pane [j/k] scroll [+/-] resize [{}] layout [?] help [q]uit ",+ " [n]ew session [a]ssign re[b]alance global re[B]alance dra[i]n inbox [g]lobal dispatch coordinate [G]lobal [v]iew diff conflict proto[c]ol [m]erge merge ready [M] auto-merge [w] toggle [p]olicy [,/.] dispatch limit [s]top [u]resume [x]cleanup prune inactive [X] [d]elete [r]efresh [Tab] switch pane [j/k] scroll [+/-] resize [{}] layout [?] help [q]uit ",self.layout_label());let text = if let Some(note) = self.operator_note.as_ref() {@@ -514,6 +527,7 @@ impl Dashboard {" g Auto-dispatch unread handoffs across lead sessions"," G Dispatch then rebalance backlog across lead teams"," v Toggle selected worktree diff in output pane",+ " c Show conflict-resolution protocol for selected conflicted worktree"," m Merge selected ready worktree into base and clean it up"," M Merge all ready inactive worktrees and clean them up"," p Toggle daemon auto-dispatch policy and persist config",@@ -727,6 +741,34 @@ impl Dashboard {self.reset_output_view();self.set_operator_note("showing session output".to_string());}+ OutputMode::ConflictProtocol => {+ self.output_mode = OutputMode::SessionOutput;+ self.reset_output_view();+ self.set_operator_note("showing session output".to_string());+ }+ }+ }++ pub fn toggle_conflict_protocol_mode(&mut self) {+ match self.output_mode {+ OutputMode::ConflictProtocol => {+ self.output_mode = OutputMode::SessionOutput;+ self.reset_output_view();+ self.set_operator_note("showing session output".to_string());+ }+ _ => {+ if self.selected_conflict_protocol.is_some() {+ self.output_mode = OutputMode::ConflictProtocol;+ self.selected_pane = Pane::Output;+ self.output_follow = false;+ self.output_scroll_offset = 0;+ self.set_operator_note("showing worktree conflict protocol".to_string());+ } else {+ self.set_operator_note(+ "no conflicted worktree for selected session".to_string(),+ );+ }+ }}}@@ -1473,10 +1515,8 @@ impl Dashboard {}fn sync_selected_diff(&mut self) {- let worktree = self- .sessions- .get(self.selected_session)- .and_then(|session| session.worktree.as_ref());+ let session = self.sessions.get(self.selected_session);+ let worktree = session.and_then(|session| session.worktree.as_ref());self.selected_diff_summary =worktree.and_then(|worktree| worktree::diff_summary(worktree).ok().flatten());@@ -1487,9 +1527,20 @@ impl Dashboard {.and_then(|worktree| worktree::diff_patch_preview(worktree, MAX_DIFF_PATCH_LINES).ok().flatten());self.selected_merge_readiness = worktree.and_then(|worktree| worktree::merge_readiness(worktree).ok());+ self.selected_conflict_protocol = session+ .zip(worktree)+ .zip(self.selected_merge_readiness.as_ref())+ .and_then(|((session, worktree), merge_readiness)| {+ build_conflict_protocol(&session.id, worktree, merge_readiness)+ });if self.output_mode == OutputMode::WorktreeDiff && self.selected_diff_patch.is_none() {self.output_mode = OutputMode::SessionOutput;}+ if self.output_mode == OutputMode::ConflictProtocol+ && self.selected_conflict_protocol.is_none()+ {+ self.output_mode = OutputMode::SessionOutput;+ }}fn sync_selected_messages(&mut self) {@@ -2410,6 +2461,44 @@ fn format_session_id(id: &str) -> String {id.chars().take(8).collect()}+fn build_conflict_protocol(+ session_id: &str,+ worktree: &crate::session::WorktreeInfo,+ merge_readiness: &worktree::MergeReadiness,+) -> Option<String> {+ if merge_readiness.status != worktree::MergeReadinessStatus::Conflicted {+ return None;+ }++ let mut lines = vec![+ format!("Conflict protocol for {}", format_session_id(session_id)),+ format!("Worktree {}", worktree.path.display()),+ format!("Branch {} (base {})", worktree.branch, worktree.base_branch),+ merge_readiness.summary.clone(),+ ];++ if !merge_readiness.conflicts.is_empty() {+ lines.push("Conflicts".to_string());+ for conflict in &merge_readiness.conflicts {+ lines.push(format!("- {conflict}"));+ }+ }++ lines.push("Resolution steps".to_string());+ lines.push(format!(+ "1. Inspect current patch: ecc worktree-status {session_id} --patch"+ ));+ lines.push(format!("2. Open worktree: cd {}", worktree.path.display()));+ lines.push("3. Resolve conflicts and stage files: git add <paths>".to_string());+ lines.push(format!("4. Commit the resolution on {}: git commit", worktree.branch));+ lines.push(format!(+ "5. Re-check readiness: ecc worktree-status {session_id} --check"+ ));+ lines.push(format!("6. Merge when clear: ecc merge-worktree {session_id}"));++ Some(lines.join("\n"))+}+fn assignment_action_label(action: manager::AssignmentAction) -> &'static str {match action {manager::AssignmentAction::Spawned => "spawned",@@ -2566,6 +2655,41 @@ mod tests {assert!(rendered.contains("diff --git a/src/lib.rs b/src/lib.rs"));}+ #[test]+ fn toggle_conflict_protocol_mode_switches_to_protocol_view() {+ let mut dashboard = test_dashboard(+ vec![sample_session(+ "focus-12345678",+ "planner",+ SessionState::Running,+ Some("ecc/focus"),+ 512,+ 42,+ )],+ 0,+ );+ dashboard.selected_merge_readiness = Some(worktree::MergeReadiness {+ status: worktree::MergeReadinessStatus::Conflicted,+ summary: "Merge blocked by 1 conflict(s): src/main.rs".to_string(),+ conflicts: vec!["src/main.rs".to_string()],+ });+ dashboard.selected_conflict_protocol = Some(+ "Conflict protocol for focus-12\nResolution steps\n1. Inspect current patch: ecc worktree-status focus-12345678 --patch"+ .to_string(),+ );++ dashboard.toggle_conflict_protocol_mode();++ assert_eq!(dashboard.output_mode, OutputMode::ConflictProtocol);+ assert_eq!(+ dashboard.operator_note.as_deref(),+ Some("showing worktree conflict protocol")+ );+ let rendered = dashboard.rendered_output_text(180, 30);+ assert!(rendered.contains("Conflict Protocol"));+ assert!(rendered.contains("Resolution steps"));+ }+#[test]fn selected_session_metrics_text_includes_team_capacity_summary() {let mut dashboard = test_dashboard(@@ -3762,6 +3886,7 @@ mod tests {selected_diff_summary: None,selected_diff_preview: Vec::new(),selected_diff_patch: None,+ selected_conflict_protocol: None,selected_merge_readiness: None,output_mode: OutputMode::SessionOutput,selected_pane: Pane::Sessions,