The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
feat: auto-rebase blocked merge queue worktrees
Affaan Mustafa599a9d1e7bd4
diff --git a/ecc2/src/main.rs b/ecc2/src/main.rsindex 8095cfcad..ce00a2e62 100644--- a/ecc2/src/main.rs+++ b/ecc2/src/main.rs@@ -250,6 +250,9 @@ enum Commands {/// Emit machine-readable JSON instead of the human summary#[arg(long)]json: bool,+ /// Process the queue, auto-rebasing clean blocked worktrees and merging what becomes ready+ #[arg(long)]+ apply: bool,},/// Prune worktrees for inactive sessions and report any active sessions still holding onePruneWorktrees {@@ -844,12 +847,21 @@ async fn main() -> Result<()> {}}}- Some(Commands::MergeQueue { json }) => {- let report = session::manager::build_merge_queue(&db)?;- if json {- println!("{}", serde_json::to_string_pretty(&report)?);+ Some(Commands::MergeQueue { json, apply }) => {+ if apply {+ let outcome = session::manager::process_merge_queue(&db).await?;+ if json {+ println!("{}", serde_json::to_string_pretty(&outcome)?);+ } else {+ println!("{}", format_bulk_worktree_merge_human(&outcome));+ }} else {- println!("{}", format_merge_queue_human(&report));+ let report = session::manager::build_merge_queue(&db)?;+ if json {+ println!("{}", serde_json::to_string_pretty(&report)?);+ } else {+ println!("{}", format_merge_queue_human(&report));+ }}}Some(Commands::PruneWorktrees { json }) => {@@ -1506,6 +1518,26 @@ fn format_bulk_worktree_merge_human());}+ if !outcome.rebased.is_empty() {+ lines.push(format!(+ "Rebased {} blocked worktree(s) onto their base branch",+ outcome.rebased.len()+ ));+ for rebased in &outcome.rebased {+ lines.push(format!(+ "- rebased {} onto {} for {}{}",+ rebased.branch,+ rebased.base_branch,+ short_session(&rebased.session_id),+ if rebased.already_up_to_date {+ " (already up to date)"+ } else {+ ""+ }+ ));+ }+ }+if !outcome.active_with_worktree_ids.is_empty() {lines.push(format!("Skipped {} active worktree session(s)",@@ -1524,6 +1556,12 @@ fn format_bulk_worktree_merge_human(outcome.dirty_worktree_ids.len()));}+ if !outcome.blocked_by_queue_session_ids.is_empty() {+ lines.push(format!(+ "Blocked {} worktree(s) on remaining queue conflicts",+ outcome.blocked_by_queue_session_ids.len()+ ));+ }if !outcome.failures.is_empty() {lines.push(format!("Encountered {} merge failure(s)",@@ -2613,7 +2651,24 @@ mod tests {.expect("merge-queue --json should parse");match cli.command {- Some(Commands::MergeQueue { json }) => assert!(json),+ Some(Commands::MergeQueue { json, apply }) => {+ assert!(json);+ assert!(!apply);+ }+ _ => panic!("expected merge-queue subcommand"),+ }+ }++ #[test]+ fn cli_parses_merge_queue_apply_flag() {+ let cli = Cli::try_parse_from(["ecc", "merge-queue", "--apply", "--json"])+ .expect("merge-queue --apply --json should parse");++ match cli.command {+ Some(Commands::MergeQueue { json, apply }) => {+ assert!(json);+ assert!(apply);+ }_ => panic!("expected merge-queue subcommand"),}}@@ -2813,9 +2868,16 @@ mod tests {already_up_to_date: false,cleaned_worktree: true,}],+ rebased: vec![session::manager::WorktreeRebaseOutcome {+ session_id: "rebased12345678".to_string(),+ branch: "ecc/rebased12345678".to_string(),+ base_branch: "main".to_string(),+ already_up_to_date: false,+ }],active_with_worktree_ids: vec!["running12345678".to_string()],conflicted_session_ids: vec!["conflict123456".to_string()],dirty_worktree_ids: vec!["dirty123456789".to_string()],+ blocked_by_queue_session_ids: vec!["queue123456789".to_string()],failures: vec![session::manager::WorktreeMergeFailure {session_id: "fail1234567890".to_string(),reason: "base branch not checked out".to_string(),@@ -2824,9 +2886,12 @@ mod tests {assert!(text.contains("Merged 1 ready worktree(s)"));assert!(text.contains("- merged ecc/deadbeefcafefeed -> main for deadbeef"));+ assert!(text.contains("Rebased 1 blocked worktree(s) onto their base branch"));+ assert!(text.contains("- rebased ecc/rebased12345678 onto main for rebased1"));assert!(text.contains("Skipped 1 active worktree session(s)"));assert!(text.contains("Skipped 1 conflicted worktree(s)"));assert!(text.contains("Skipped 1 dirty worktree(s)"));+ assert!(text.contains("Blocked 1 worktree(s) on remaining queue conflicts"));assert!(text.contains("Encountered 1 merge failure(s)"));assert!(text.contains("- failed fail1234: base branch not checked out"));}diff --git a/ecc2/src/session/daemon.rs b/ecc2/src/session/daemon.rsindex 47f141b85..2f5096fb5 100644--- a/ecc2/src/session/daemon.rs+++ b/ecc2/src/session/daemon.rs@@ -1202,9 +1202,11 @@ mod tests {invoked_flag.store(true, std::sync::atomic::Ordering::SeqCst);Ok(manager::WorktreeBulkMergeOutcome {merged: Vec::new(),+ rebased: Vec::new(),active_with_worktree_ids: Vec::new(),conflicted_session_ids: Vec::new(),dirty_worktree_ids: Vec::new(),+ blocked_by_queue_session_ids: Vec::new(),failures: Vec::new(),})}@@ -1239,9 +1241,16 @@ mod tests {cleaned_worktree: true,},],+ rebased: vec![manager::WorktreeRebaseOutcome {+ session_id: "worker-r".to_string(),+ branch: "ecc/worker-r".to_string(),+ base_branch: "main".to_string(),+ already_up_to_date: false,+ }],active_with_worktree_ids: vec!["worker-c".to_string()],conflicted_session_ids: vec!["worker-d".to_string()],dirty_worktree_ids: vec!["worker-e".to_string()],+ blocked_by_queue_session_ids: vec!["worker-f".to_string()],failures: Vec::new(),})})diff --git a/ecc2/src/session/manager.rs b/ecc2/src/session/manager.rsindex 64a55e9bc..ef96d26bd 100644--- a/ecc2/src/session/manager.rs+++ b/ecc2/src/session/manager.rs@@ -803,6 +803,14 @@ pub struct WorktreeMergeOutcome {pub cleaned_worktree: bool,}+#[derive(Debug, Clone, Serialize)]+pub struct WorktreeRebaseOutcome {+ pub session_id: String,+ pub branch: String,+ pub base_branch: String,+ pub already_up_to_date: bool,+}+pub async fn merge_session_worktree(db: &StateStore,id: &str,@@ -841,6 +849,34 @@ pub async fn merge_session_worktree(})}+pub async fn rebase_session_worktree(db: &StateStore, id: &str) -> Result<WorktreeRebaseOutcome> {+ let session = resolve_session(db, id)?;++ if matches!(+ session.state,+ SessionState::Pending | SessionState::Running | SessionState::Idle | SessionState::Stale+ ) {+ anyhow::bail!(+ "Cannot rebase active session {} while it is {}",+ session.id,+ session.state+ );+ }++ let worktree = session+ .worktree+ .clone()+ .ok_or_else(|| anyhow::anyhow!("Session {} has no attached worktree", session.id))?;+ let outcome = crate::worktree::rebase_onto_base(&worktree)?;++ Ok(WorktreeRebaseOutcome {+ session_id: session.id,+ branch: outcome.branch,+ base_branch: outcome.base_branch,+ already_up_to_date: outcome.already_up_to_date,+ })+}+#[derive(Debug, Clone, Serialize)]pub struct WorktreeMergeFailure {pub session_id: String,@@ -850,15 +886,110 @@ pub struct WorktreeMergeFailure {#[derive(Debug, Clone, Serialize)]pub struct WorktreeBulkMergeOutcome {pub merged: Vec<WorktreeMergeOutcome>,+ pub rebased: Vec<WorktreeRebaseOutcome>,pub active_with_worktree_ids: Vec<String>,pub conflicted_session_ids: Vec<String>,pub dirty_worktree_ids: Vec<String>,+ pub blocked_by_queue_session_ids: Vec<String>,pub failures: Vec<WorktreeMergeFailure>,}pub async fn merge_ready_worktrees(db: &StateStore,cleanup_worktree: bool,+) -> Result<WorktreeBulkMergeOutcome> {+ if cleanup_worktree {+ return process_merge_queue(db).await;+ }++ merge_ready_worktrees_one_pass(db, cleanup_worktree).await+}++pub async fn process_merge_queue(db: &StateStore) -> Result<WorktreeBulkMergeOutcome> {+ let mut merged = Vec::new();+ let mut rebased = Vec::new();+ let mut failures = Vec::new();+ let mut attempted_rebase_heads = BTreeMap::<String, String>::new();++ loop {+ let report = build_merge_queue(db)?;+ let mut merged_any = false;++ for entry in &report.ready_entries {+ match merge_session_worktree(db, &entry.session_id, true).await {+ Ok(outcome) => {+ merged.push(outcome);+ merged_any = true;+ }+ Err(error) => failures.push(WorktreeMergeFailure {+ session_id: entry.session_id.clone(),+ reason: error.to_string(),+ }),+ }+ }++ if merged_any {+ continue;+ }++ let mut rebased_any = false;+ for entry in &report.blocked_entries {+ if !can_auto_rebase_merge_queue_entry(entry) {+ continue;+ }++ let session = resolve_session(db, &entry.session_id)?;+ let Some(worktree) = session.worktree.clone() else {+ continue;+ };+ let base_head = crate::worktree::branch_head_oid(&worktree, &worktree.base_branch)?;+ if attempted_rebase_heads+ .get(&entry.session_id)+ .is_some_and(|last_head| last_head == &base_head)+ {+ continue;+ }+ attempted_rebase_heads.insert(entry.session_id.clone(), base_head);++ match rebase_session_worktree(db, &entry.session_id).await {+ Ok(outcome) => {+ rebased.push(outcome);+ rebased_any = true;+ break;+ }+ Err(error) => failures.push(WorktreeMergeFailure {+ session_id: entry.session_id.clone(),+ reason: error.to_string(),+ }),+ }+ }++ if rebased_any {+ continue;+ }++ let (+ active_with_worktree_ids,+ conflicted_session_ids,+ dirty_worktree_ids,+ blocked_by_queue_session_ids,+ ) = classify_merge_queue_report(&report);++ return Ok(WorktreeBulkMergeOutcome {+ merged,+ rebased,+ active_with_worktree_ids,+ conflicted_session_ids,+ dirty_worktree_ids,+ blocked_by_queue_session_ids,+ failures,+ });+ }+}++async fn merge_ready_worktrees_one_pass(+ db: &StateStore,+ cleanup_worktree: bool,) -> Result<WorktreeBulkMergeOutcome> {let sessions = db.list_sessions()?;let mut merged = Vec::new();@@ -926,9 +1057,11 @@ pub async fn merge_ready_worktrees(Ok(WorktreeBulkMergeOutcome {merged,+ rebased: Vec::new(),active_with_worktree_ids,conflicted_session_ids,dirty_worktree_ids,+ blocked_by_queue_session_ids: Vec::new(),failures,})}@@ -1170,6 +1303,49 @@ pub fn build_merge_queue(db: &StateStore) -> Result<MergeQueueReport> {})}+fn can_auto_rebase_merge_queue_entry(entry: &MergeQueueEntry) -> bool {+ !entry.ready_to_merge+ && !entry.dirty+ && entry.worktree_health == worktree::WorktreeHealth::Conflicted+ && !entry.blocked_by.is_empty()+ && entry+ .blocked_by+ .iter()+ .all(|blocker| blocker.session_id == entry.session_id)+}++fn classify_merge_queue_report(+ report: &MergeQueueReport,+) -> (Vec<String>, Vec<String>, Vec<String>, Vec<String>) {+ let mut active = Vec::new();+ let mut conflicted = Vec::new();+ let mut dirty = Vec::new();+ let mut queue_blocked = Vec::new();++ for entry in &report.blocked_entries {+ if entry.blocked_by.iter().any(|blocker| {+ blocker.session_id == entry.session_id+ && matches!(+ blocker.state,+ SessionState::Pending+ | SessionState::Running+ | SessionState::Idle+ | SessionState::Stale+ )+ }) {+ active.push(entry.session_id.clone());+ } else if entry.dirty {+ dirty.push(entry.session_id.clone());+ } else if entry.worktree_health == worktree::WorktreeHealth::Conflicted {+ conflicted.push(entry.session_id.clone());+ } else {+ queue_blocked.push(entry.session_id.clone());+ }+ }++ (active, conflicted, dirty, queue_blocked)+}+pub async fn delete_session(db: &StateStore, id: &str) -> Result<()> {let session = resolve_session(db, id)?;@@ -3235,6 +3411,174 @@ mod tests {Ok(())}+ #[tokio::test(flavor = "current_thread")]+ async fn process_merge_queue_rebases_blocked_session_and_merges_it() -> Result<()> {+ let tempdir = TestDir::new("manager-process-merge-queue-success")?;+ let repo_root = tempdir.path().join("repo");+ init_git_repo(&repo_root)?;++ let cfg = build_config(tempdir.path());+ let db = StateStore::open(&cfg.db_path)?;+ let now = Utc::now();++ let alpha_worktree = worktree::create_for_session_in_repo("alpha", &cfg, &repo_root)?;+ fs::write(alpha_worktree.path.join("README.md"), "hello\nalpha\n")?;+ run_git(&alpha_worktree.path, ["commit", "-am", "alpha change"])?;++ let beta_worktree = worktree::create_for_session_in_repo("beta", &cfg, &repo_root)?;+ fs::write(beta_worktree.path.join("README.md"), "hello\nalpha\n")?;+ run_git(&beta_worktree.path, ["commit", "-am", "beta shared change"])?;+ fs::write(beta_worktree.path.join("README.md"), "hello\nalpha\nbeta\n")?;+ run_git(&beta_worktree.path, ["commit", "-am", "beta follow-up"])?;++ db.insert_session(&Session {+ id: "alpha".to_string(),+ task: "alpha merge".to_string(),+ project: "ecc".to_string(),+ task_group: "merge".to_string(),+ agent_type: "claude".to_string(),+ working_dir: alpha_worktree.path.clone(),+ state: SessionState::Completed,+ pid: None,+ worktree: Some(alpha_worktree.clone()),+ created_at: now - Duration::minutes(2),+ updated_at: now - Duration::minutes(2),+ last_heartbeat_at: now - Duration::minutes(2),+ metrics: SessionMetrics::default(),+ })?;+ db.insert_session(&Session {+ id: "beta".to_string(),+ task: "beta merge".to_string(),+ project: "ecc".to_string(),+ task_group: "merge".to_string(),+ agent_type: "claude".to_string(),+ working_dir: beta_worktree.path.clone(),+ state: SessionState::Completed,+ pid: None,+ worktree: Some(beta_worktree.clone()),+ created_at: now - Duration::minutes(1),+ updated_at: now - Duration::minutes(1),+ last_heartbeat_at: now - Duration::minutes(1),+ metrics: SessionMetrics::default(),+ })?;++ let queue_before = build_merge_queue(&db)?;+ assert_eq!(queue_before.ready_entries.len(), 1);+ assert_eq!(queue_before.ready_entries[0].session_id, "alpha");+ assert_eq!(queue_before.blocked_entries.len(), 1);+ assert_eq!(queue_before.blocked_entries[0].session_id, "beta");++ let outcome = process_merge_queue(&db).await?;++ assert_eq!(+ outcome+ .merged+ .iter()+ .map(|entry| entry.session_id.as_str())+ .collect::<Vec<_>>(),+ vec!["alpha", "beta"]+ );+ assert_eq!(outcome.rebased.len(), 1);+ assert_eq!(outcome.rebased[0].session_id, "beta");+ assert!(outcome.active_with_worktree_ids.is_empty());+ assert!(outcome.conflicted_session_ids.is_empty());+ assert!(outcome.dirty_worktree_ids.is_empty());+ assert!(outcome.blocked_by_queue_session_ids.is_empty());+ assert!(outcome.failures.is_empty());+ assert_eq!(+ fs::read_to_string(repo_root.join("README.md"))?,+ "hello\nalpha\nbeta\n"+ );+ assert!(db+ .get_session("alpha")?+ .context("alpha should still exist")?+ .worktree+ .is_none());+ assert!(db+ .get_session("beta")?+ .context("beta should still exist")?+ .worktree+ .is_none());++ Ok(())+ }++ #[tokio::test(flavor = "current_thread")]+ async fn process_merge_queue_records_failed_rebase_and_leaves_blocked_session() -> Result<()> {+ let tempdir = TestDir::new("manager-process-merge-queue-fail")?;+ let repo_root = tempdir.path().join("repo");+ init_git_repo(&repo_root)?;++ let cfg = build_config(tempdir.path());+ let db = StateStore::open(&cfg.db_path)?;+ let now = Utc::now();++ let alpha_worktree = worktree::create_for_session_in_repo("alpha", &cfg, &repo_root)?;+ fs::write(alpha_worktree.path.join("README.md"), "hello\nalpha\n")?;+ run_git(&alpha_worktree.path, ["commit", "-am", "alpha change"])?;++ let beta_worktree = worktree::create_for_session_in_repo("beta", &cfg, &repo_root)?;+ fs::write(beta_worktree.path.join("README.md"), "hello\nbeta\n")?;+ run_git(&beta_worktree.path, ["commit", "-am", "beta change"])?;++ db.insert_session(&Session {+ id: "alpha".to_string(),+ task: "alpha merge".to_string(),+ project: "ecc".to_string(),+ task_group: "merge".to_string(),+ agent_type: "claude".to_string(),+ working_dir: alpha_worktree.path.clone(),+ state: SessionState::Completed,+ pid: None,+ worktree: Some(alpha_worktree.clone()),+ created_at: now - Duration::minutes(2),+ updated_at: now - Duration::minutes(2),+ last_heartbeat_at: now - Duration::minutes(2),+ metrics: SessionMetrics::default(),+ })?;+ db.insert_session(&Session {+ id: "beta".to_string(),+ task: "beta merge".to_string(),+ project: "ecc".to_string(),+ task_group: "merge".to_string(),+ agent_type: "claude".to_string(),+ working_dir: beta_worktree.path.clone(),+ state: SessionState::Completed,+ pid: None,+ worktree: Some(beta_worktree.clone()),+ created_at: now - Duration::minutes(1),+ updated_at: now - Duration::minutes(1),+ last_heartbeat_at: now - Duration::minutes(1),+ metrics: SessionMetrics::default(),+ })?;++ let outcome = process_merge_queue(&db).await?;++ assert_eq!(+ outcome+ .merged+ .iter()+ .map(|entry| entry.session_id.as_str())+ .collect::<Vec<_>>(),+ vec!["alpha"]+ );+ assert!(outcome.rebased.is_empty());+ assert_eq!(outcome.conflicted_session_ids, vec!["beta".to_string()]);+ assert!(outcome.active_with_worktree_ids.is_empty());+ assert!(outcome.dirty_worktree_ids.is_empty());+ assert!(outcome.blocked_by_queue_session_ids.is_empty());+ assert_eq!(outcome.failures.len(), 1);+ assert_eq!(outcome.failures[0].session_id, "beta");+ assert!(outcome.failures[0].reason.contains("git rebase failed"));+ assert!(db+ .get_session("beta")?+ .context("beta should still exist")?+ .worktree+ .is_some());++ Ok(())+ }+#[tokio::test(flavor = "current_thread")]async fn build_merge_queue_orders_ready_sessions_and_blocks_conflicts() -> Result<()> {let tempdir = TestDir::new("manager-merge-queue")?;diff --git a/ecc2/src/tui/dashboard.rs b/ecc2/src/tui/dashboard.rsindex ae1aa796e..16b6fc2c8 100644--- a/ecc2/src/tui/dashboard.rs+++ b/ecc2/src/tui/dashboard.rs@@ -2734,9 +2734,11 @@ impl Dashboard {Ok(outcome) => {self.refresh();if outcome.merged.is_empty()+ && outcome.rebased.is_empty()&& outcome.active_with_worktree_ids.is_empty()&& outcome.conflicted_session_ids.is_empty()&& outcome.dirty_worktree_ids.is_empty()+ && outcome.blocked_by_queue_session_ids.is_empty()&& outcome.failures.is_empty(){self.set_operator_note("no ready worktrees to merge".to_string());@@ -2744,6 +2746,9 @@ impl Dashboard {}let mut parts = vec![format!("merged {} ready worktree(s)", outcome.merged.len())];+ if !outcome.rebased.is_empty() {+ parts.push(format!("rebased {}", outcome.rebased.len()));+ }if !outcome.active_with_worktree_ids.is_empty() {parts.push(format!("skipped {} active",@@ -2762,6 +2767,12 @@ impl Dashboard {outcome.dirty_worktree_ids.len()));}+ if !outcome.blocked_by_queue_session_ids.is_empty() {+ parts.push(format!(+ "blocked {} in queue",+ outcome.blocked_by_queue_session_ids.len()+ ));+ }if !outcome.failures.is_empty() {parts.push(format!("{} failed", outcome.failures.len()));}diff --git a/ecc2/src/worktree/mod.rs b/ecc2/src/worktree/mod.rsindex 3173662fc..6165a5598 100644--- a/ecc2/src/worktree/mod.rs+++ b/ecc2/src/worktree/mod.rs@@ -35,6 +35,13 @@ pub struct MergeOutcome {pub already_up_to_date: bool,}+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]+pub struct RebaseOutcome {+ pub branch: String,+ pub base_branch: String,+ pub already_up_to_date: bool,+}+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]pub struct BranchConflictPreview {pub left_branch: String,@@ -741,6 +748,65 @@ pub fn merge_into_base(worktree: &WorktreeInfo) -> Result<MergeOutcome> {})}+pub fn rebase_onto_base(worktree: &WorktreeInfo) -> Result<RebaseOutcome> {+ if has_uncommitted_changes(worktree)? {+ anyhow::bail!(+ "Worktree {} has uncommitted changes; commit or discard them before rebasing",+ worktree.branch+ );+ }++ let repo_root = base_checkout_path(worktree)?;+ let before_head = branch_head_oid_in_repo(&repo_root, &worktree.branch)?;+ let output = Command::new("git")+ .arg("-C")+ .arg(&worktree.path)+ .args(["rebase", &worktree.base_branch])+ .output()+ .context("Failed to rebase worktree branch onto base")?;++ if !output.status.success() {+ let abort_output = Command::new("git")+ .arg("-C")+ .arg(&worktree.path)+ .args(["rebase", "--abort"])+ .output()+ .context("Failed to abort unsuccessful rebase")?;+ let abort_warning = if abort_output.status.success() {+ String::new()+ } else {+ format!(+ " (rebase abort warning: {})",+ String::from_utf8_lossy(&abort_output.stderr).trim()+ )+ };+ let stderr = format!(+ "{}\n{}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );+ anyhow::bail!("git rebase failed: {}{}", stderr.trim(), abort_warning);+ }++ let after_head = branch_head_oid_in_repo(&repo_root, &worktree.branch)?;+ let rebase_output = format!(+ "{}\n{}",+ String::from_utf8_lossy(&output.stdout),+ String::from_utf8_lossy(&output.stderr)+ );++ Ok(RebaseOutcome {+ branch: worktree.branch.clone(),+ base_branch: worktree.base_branch.clone(),+ already_up_to_date: before_head == after_head || rebase_output.contains("up to date"),+ })+}++pub fn branch_head_oid(worktree: &WorktreeInfo, branch: &str) -> Result<String> {+ let repo_root = base_checkout_path(worktree)?;+ branch_head_oid_in_repo(&repo_root, branch)+}+fn git_diff_shortstat(worktree_path: &Path, extra_args: &[&str]) -> Result<Option<String>> {let mut command = Command::new("git");command@@ -1113,6 +1179,22 @@ fn git_status_short(worktree_path: &Path) -> Result<Vec<String>> {Ok(parse_nonempty_lines(&output.stdout))}+fn branch_head_oid_in_repo(repo_root: &Path, branch: &str) -> Result<String> {+ let output = Command::new("git")+ .arg("-C")+ .arg(repo_root)+ .args(["rev-parse", branch])+ .output()+ .context("Failed to resolve branch head")?;++ if !output.status.success() {+ let stderr = String::from_utf8_lossy(&output.stderr);+ anyhow::bail!("git rev-parse failed: {stderr}");+ }++ Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())+}+fn validate_branch_name(repo_root: &Path, branch: &str) -> Result<()> {let output = Command::new("git").arg("-C")@@ -1567,6 +1649,130 @@ mod tests {Ok(())}+ #[test]+ fn rebase_onto_base_replays_simple_branch_after_base_advances() -> Result<()> {+ let root =+ std::env::temp_dir().join(format!("ecc2-worktree-rebase-success-{}", Uuid::new_v4()));+ let repo = init_repo(&root)?;++ let alpha_dir = root.join("wt-alpha");+ run_git(+ &repo,+ &[+ "worktree",+ "add",+ "-b",+ "ecc/alpha",+ alpha_dir.to_str().expect("utf8 path"),+ "HEAD",+ ],+ )?;+ fs::write(alpha_dir.join("README.md"), "hello\nalpha\n")?;+ run_git(&alpha_dir, &["commit", "-am", "alpha change"])?;++ let beta_dir = root.join("wt-beta");+ run_git(+ &repo,+ &[+ "worktree",+ "add",+ "-b",+ "ecc/beta",+ beta_dir.to_str().expect("utf8 path"),+ "HEAD",+ ],+ )?;+ fs::write(beta_dir.join("README.md"), "hello\nalpha\n")?;+ run_git(&beta_dir, &["commit", "-am", "beta shared change"])?;+ fs::write(beta_dir.join("README.md"), "hello\nalpha\nbeta\n")?;+ run_git(&beta_dir, &["commit", "-am", "beta follow-up"])?;++ run_git(&repo, &["merge", "--no-edit", "ecc/alpha"])?;++ let beta = WorktreeInfo {+ path: beta_dir.clone(),+ branch: "ecc/beta".to_string(),+ base_branch: "main".to_string(),+ };+ let readiness_before = merge_readiness(&beta)?;+ assert_eq!(readiness_before.status, MergeReadinessStatus::Conflicted);++ let outcome = rebase_onto_base(&beta)?;+ assert_eq!(outcome.branch, "ecc/beta");+ assert_eq!(outcome.base_branch, "main");+ assert!(!outcome.already_up_to_date);++ let readiness_after = merge_readiness(&beta)?;+ assert_eq!(readiness_after.status, MergeReadinessStatus::Ready);+ assert_eq!(+ fs::read_to_string(beta_dir.join("README.md"))?,+ "hello\nalpha\nbeta\n"+ );++ let _ = Command::new("git")+ .arg("-C")+ .arg(&repo)+ .args(["worktree", "remove", "--force"])+ .arg(&alpha_dir)+ .output();+ let _ = Command::new("git")+ .arg("-C")+ .arg(&repo)+ .args(["worktree", "remove", "--force"])+ .arg(&beta_dir)+ .output();+ let _ = fs::remove_dir_all(root);+ Ok(())+ }++ #[test]+ fn rebase_onto_base_aborts_failed_rebase() -> Result<()> {+ let root =+ std::env::temp_dir().join(format!("ecc2-worktree-rebase-fail-{}", Uuid::new_v4()));+ let repo = init_repo(&root)?;++ let worktree_dir = root.join("wt-conflict");+ run_git(+ &repo,+ &[+ "worktree",+ "add",+ "-b",+ "ecc/conflict",+ worktree_dir.to_str().expect("utf8 path"),+ "HEAD",+ ],+ )?;++ fs::write(worktree_dir.join("README.md"), "hello\nbranch\n")?;+ run_git(&worktree_dir, &["commit", "-am", "branch change"])?;+ fs::write(repo.join("README.md"), "hello\nmain\n")?;+ run_git(&repo, &["commit", "-am", "main change"])?;++ let info = WorktreeInfo {+ path: worktree_dir.clone(),+ branch: "ecc/conflict".to_string(),+ base_branch: "main".to_string(),+ };++ let error = rebase_onto_base(&info).expect_err("rebase should fail");+ assert!(error.to_string().contains("git rebase failed"));+ assert!(git_status_short(&worktree_dir)?.is_empty());+ assert_eq!(+ merge_readiness(&info)?.status,+ MergeReadinessStatus::Conflicted+ );++ let _ = Command::new("git")+ .arg("-C")+ .arg(&repo)+ .args(["worktree", "remove", "--force"])+ .arg(&worktree_dir)+ .output();+ let _ = fs::remove_dir_all(root);+ Ok(())+ }+#[test]fn branch_conflict_preview_reports_conflicting_branches() -> Result<()> {let root = std::env::temp_dir().join(format!(