style: cargo fmt

2026-04-07 00:24:50 +08:00 · 2026-04-05 16:56:48 +00:00
parent eb4d3b11ee
commit 31163be347
14 changed files with 114 additions and 96 deletions
--- a/rust/crates/tools/src/lane_completion.rs
+++ b/rust/crates/tools/src/lane_completion.rs
@@ -16,7 +16,7 @@ use runtime::{
 use crate::AgentOutput;

 /// Detects if a lane should be automatically marked as completed.
-/// 
+///
 /// Returns `Some(LaneContext)` with `completed = true` if all conditions met,
 /// `None` if lane should remain active.
 #[allow(dead_code)]
@@ -29,29 +29,29 @@ pub(crate) fn detect_lane_completion(
    if output.error.is_some() {
        return None;
    }
-    
+
    // Must have finished status
    if !output.status.eq_ignore_ascii_case("completed")
        && !output.status.eq_ignore_ascii_case("finished")
    {
        return None;
    }
-    
+
    // Must have no current blocker
    if output.current_blocker.is_some() {
        return None;
    }
-    
+
    // Must have green tests
    if !test_green {
        return None;
    }
-    
+
    // Must have pushed code
    if !has_pushed {
        return None;
    }
-    
+
    // All conditions met — create completed context
    Some(LaneContext {
        lane_id: output.agent_id.clone(),
@@ -67,9 +67,7 @@ pub(crate) fn detect_lane_completion(

 /// Evaluates policy actions for a completed lane.
 #[allow(dead_code)]
-pub(crate) fn evaluate_completed_lane(
-    context: &LaneContext,
-) -> Vec<PolicyAction> {
+pub(crate) fn evaluate_completed_lane(context: &LaneContext) -> Vec<PolicyAction> {
    let engine = PolicyEngine::new(vec![
        PolicyRule::new(
            "closeout-completed-lane",
@@ -87,7 +85,7 @@ pub(crate) fn evaluate_completed_lane(
            5,
        ),
    ]);
-    
+
    evaluate(&engine, context)
 }

@@ -114,53 +112,53 @@ mod tests {
            error: None,
        }
    }
-    
+
    #[test]
    fn detects_completion_when_all_conditions_met() {
        let output = test_output();
        let result = detect_lane_completion(&output, true, true);
-        
+
        assert!(result.is_some());
        let context = result.unwrap();
        assert!(context.completed);
        assert_eq!(context.green_level, 3);
        assert_eq!(context.blocker, LaneBlocker::None);
    }
-    
+
    #[test]
    fn no_completion_when_error_present() {
        let mut output = test_output();
        output.error = Some("Build failed".to_string());
-        
+
        let result = detect_lane_completion(&output, true, true);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn no_completion_when_not_finished() {
        let mut output = test_output();
        output.status = "Running".to_string();
-        
+
        let result = detect_lane_completion(&output, true, true);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn no_completion_when_tests_not_green() {
        let output = test_output();
-        
+
        let result = detect_lane_completion(&output, false, true);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn no_completion_when_not_pushed() {
        let output = test_output();
-        
+
        let result = detect_lane_completion(&output, true, false);
        assert!(result.is_none());
    }
-    
+
    #[test]
    fn evaluate_triggers_closeout_for_completed_lane() {
        let context = LaneContext {
@@ -173,9 +171,9 @@ mod tests {
            completed: true,
            reconciled: false,
        };
-        
+
        let actions = evaluate_completed_lane(&context);
-        
+
        assert!(actions.contains(&PolicyAction::CloseoutLane));
        assert!(actions.contains(&PolicyAction::CleanupSession));
    }
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -17,7 +17,6 @@ use runtime::{
    permission_enforcer::{EnforcementResult, PermissionEnforcer},
    read_file,
    summary_compression::compress_summary_text,
-    TaskPacket,
    task_registry::TaskRegistry,
    team_cron_registry::{CronRegistry, TeamRegistry},
    worker_boot::{WorkerReadySnapshot, WorkerRegistry},
@@ -25,7 +24,7 @@ use runtime::{
    BranchFreshness, ContentBlock, ConversationMessage, ConversationRuntime, GrepSearchInput,
    LaneEvent, LaneEventBlocker, LaneEventName, LaneEventStatus, LaneFailureClass,
    McpDegradedReport, MessageRole, PermissionMode, PermissionPolicy, PromptCacheEvent,
-    RuntimeError, Session, ToolError, ToolExecutor,
+    RuntimeError, Session, TaskPacket, ToolError, ToolExecutor,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
@@ -1878,27 +1877,25 @@ fn branch_divergence_output(
        dangerously_disable_sandbox: None,
        return_code_interpretation: Some("preflight_blocked:branch_divergence".to_string()),
        no_output_expected: Some(false),
-        structured_content: Some(vec![
-            serde_json::to_value(
-                LaneEvent::new(
-                    LaneEventName::BranchStaleAgainstMain,
-                    LaneEventStatus::Blocked,
-                    iso8601_now(),
-                )
-                    .with_failure_class(LaneFailureClass::BranchDivergence)
-                    .with_detail(stderr.clone())
-                    .with_data(json!({
-                        "branch": branch,
-                        "mainRef": main_ref,
-                        "commitsBehind": commits_behind,
-                        "commitsAhead": commits_ahead,
-                        "missingCommits": missing_fixes,
-                        "blockedCommand": command,
-                        "recommendedAction": format!("merge or rebase {main_ref} before workspace tests")
-                    })),
+        structured_content: Some(vec![serde_json::to_value(
+            LaneEvent::new(
+                LaneEventName::BranchStaleAgainstMain,
+                LaneEventStatus::Blocked,
+                iso8601_now(),
            )
-            .expect("lane event should serialize"),
-        ]),
+            .with_failure_class(LaneFailureClass::BranchDivergence)
+            .with_detail(stderr.clone())
+            .with_data(json!({
+                "branch": branch,
+                "mainRef": main_ref,
+                "commitsBehind": commits_behind,
+                "commitsAhead": commits_ahead,
+                "missingCommits": missing_fixes,
+                "blockedCommand": command,
+                "recommendedAction": format!("merge or rebase {main_ref} before workspace tests")
+            })),
+        )
+        .expect("lane event should serialize")]),
        persisted_output_path: None,
        persisted_output_size: None,
        sandbox_status: None,
@@ -3297,12 +3294,12 @@ fn persist_agent_terminal_state(
    next_manifest.current_blocker = blocker.clone();
    next_manifest.error = error;
    if let Some(blocker) = blocker {
-        next_manifest.lane_events.push(
-            LaneEvent::blocked(iso8601_now(), &blocker),
-        );
-        next_manifest.lane_events.push(
-            LaneEvent::failed(iso8601_now(), &blocker),
-        );
+        next_manifest
+            .lane_events
+            .push(LaneEvent::blocked(iso8601_now(), &blocker));
+        next_manifest
+            .lane_events
+            .push(LaneEvent::failed(iso8601_now(), &blocker));
    } else {
        next_manifest.current_blocker = None;
        let compressed_detail = result
@@ -4952,8 +4949,8 @@ mod tests {
        agent_permission_policy, allowed_tools_for_subagent, classify_lane_failure,
        execute_agent_with_spawn, execute_tool, final_assistant_text, mvp_tool_specs,
        permission_mode_from_plugin, persist_agent_terminal_state, push_output_block,
-        run_task_packet, AgentInput, AgentJob, GlobalToolRegistry, LaneEventName,
-        LaneFailureClass, SubagentToolExecutor,
+        run_task_packet, AgentInput, AgentJob, GlobalToolRegistry, LaneEventName, LaneFailureClass,
+        SubagentToolExecutor,
    };
    use api::OutputContentBlock;
    use runtime::{
@@ -5977,7 +5974,10 @@ mod tests {
                "gateway routing rejected the request",
                LaneFailureClass::GatewayRouting,
            ),
-            ("tool failed: denied tool execution from hook", LaneFailureClass::ToolRuntime),
+            (
+                "tool failed: denied tool execution from hook",
+                LaneFailureClass::ToolRuntime,
+            ),
            ("thread creation failed", LaneFailureClass::Infra),
        ];

@@ -6000,11 +6000,17 @@ mod tests {
            (LaneEventName::MergeReady, "lane.merge.ready"),
            (LaneEventName::Finished, "lane.finished"),
            (LaneEventName::Failed, "lane.failed"),
-            (LaneEventName::BranchStaleAgainstMain, "branch.stale_against_main"),
+            (
+                LaneEventName::BranchStaleAgainstMain,
+                "branch.stale_against_main",
+            ),
        ];

        for (event, expected) in cases {
-            assert_eq!(serde_json::to_value(event).expect("serialize lane event"), json!(expected));
+            assert_eq!(
+                serde_json::to_value(event).expect("serialize lane event"),
+                json!(expected)
+            );
        }
    }