Stop stale branches from polluting workspace test signals

Workspace-wide verification now preflights the current branch against main so stale or diverged branches surface missing commits before broad cargo tests run. The lane failure taxonomy is also collapsed to the blocker classes the roadmap lane needs so automation can branch on a smaller, stable set of categories.

Constraint: Broad workspace tests should not run when main is ahead and would produce stale-branch noise
Rejected: Run workspace tests unconditionally | makes stale-branch failures indistinguishable from real regressions
Confidence: medium
Scope-risk: moderate
Reversibility: clean
Directive: Keep workspace-test preflight scoped to broad test commands until command classification grows more precise
Tested: cargo test -p runtime stale_branch -- --nocapture; cargo test -p tools lane_failure_taxonomy_normalizes_common_blockers -- --nocapture; cargo test -p tools bash_workspace_tests_are_blocked_when_branch_is_behind_main -- --nocapture; cargo test -p tools bash_targeted_tests_skip_branch_preflight -- --nocapture
Not-tested: clean worktree cargo test --workspace still fails on pre-existing rusty-claude-cli tests default_permission_mode_uses_project_config_when_env_is_unset and single_word_slash_command_names_return_guidance_instead_of_hitting_prompt_mode

rust/crates/runtime/src/stale_branch.rs

@@ -11,6 +11,7 @@ pub enum BranchFreshness {
     Diverged {
         ahead: usize,
         behind: usize,
+        missing_fixes: Vec<String>,
     },
 }
 
@@ -77,15 +78,21 @@ pub fn apply_policy(freshness: &BranchFreshness, policy: StaleBranchPolicy) -> S
             StaleBranchPolicy::AutoRebase => StaleBranchAction::Rebase,
             StaleBranchPolicy::AutoMergeForward => StaleBranchAction::MergeForward,
         },
-        BranchFreshness::Diverged { ahead, behind } => match policy {
+        BranchFreshness::Diverged {
+            ahead,
+            behind,
+            missing_fixes,
+        } => match policy {
             StaleBranchPolicy::WarnOnly => StaleBranchAction::Warn {
                 message: format!(
-                    "Branch has diverged: {ahead} commit(s) ahead, {behind} commit(s) behind main."
+                    "Branch has diverged: {ahead} commit(s) ahead, {behind} commit(s) behind main. Missing fixes: {}",
+                    format_missing_fixes(missing_fixes)
                 ),
             },
             StaleBranchPolicy::Block => StaleBranchAction::Block {
                 message: format!(
-                    "Branch has diverged ({ahead} ahead, {behind} behind) and must be reconciled before proceeding."
+                    "Branch has diverged ({ahead} ahead, {behind} behind) and must be reconciled before proceeding. Missing fixes: {}",
+                    format_missing_fixes(missing_fixes)
                 ),
             },
             StaleBranchPolicy::AutoRebase => StaleBranchAction::Rebase,
@@ -107,7 +114,11 @@ pub(crate) fn check_freshness_in(
     }
 
     if ahead > 0 {
-        return BranchFreshness::Diverged { ahead, behind };
+        return BranchFreshness::Diverged {
+            ahead,
+            behind,
+            missing_fixes: missing_fix_subjects(main_ref, branch, repo_path),
+        };
     }
 
     let missing_fixes = missing_fix_subjects(main_ref, branch, repo_path);
@@ -117,6 +128,14 @@ pub(crate) fn check_freshness_in(
     }
 }
 
+fn format_missing_fixes(missing_fixes: &[String]) -> String {
+    if missing_fixes.is_empty() {
+        "(none)".to_string()
+    } else {
+        missing_fixes.join("; ")
+    }
+}
+
 fn rev_list_count(a: &str, b: &str, repo_path: &Path) -> usize {
     let output = Command::new("git")
         .args(["rev-list", "--count", &format!("{b}..{a}")])
@@ -271,9 +290,14 @@ mod tests {
 
         // then
         match freshness {
-            BranchFreshness::Diverged { ahead, behind } => {
+            BranchFreshness::Diverged {
+                ahead,
+                behind,
+                missing_fixes,
+            } => {
                 assert_eq!(ahead, 1);
                 assert_eq!(behind, 1);
+                assert_eq!(missing_fixes, vec!["main fix".to_string()]);
             }
             other => panic!("expected Diverged, got {other:?}"),
         }
@@ -356,6 +380,7 @@ mod tests {
         let freshness = BranchFreshness::Diverged {
             ahead: 5,
             behind: 2,
+            missing_fixes: vec!["fix: merge main".into()],
         };
 
         // when
@@ -371,6 +396,7 @@ mod tests {
         let freshness = BranchFreshness::Diverged {
             ahead: 3,
             behind: 1,
+            missing_fixes: vec!["main hotfix".into()],
         };
 
         // when
@@ -382,6 +408,7 @@ mod tests {
                 assert!(message.contains("diverged"));
                 assert!(message.contains("3 commit(s) ahead"));
                 assert!(message.contains("1 commit(s) behind"));
+                assert!(message.contains("main hotfix"));
             }
             other => panic!("expected Warn, got {other:?}"),
         }