fix(symphony): clippy + fmt fixes for convergence crates

Apply cargo fmt to terraphim_tracker, terraphim_workspace, and
terraphim_orchestrator. Fix clippy::match_result_ok in pagerank.rs.
All crates pass tests, clean clippy -D warnings, and clean fmt.

Co-Authored-By: Terraphim AI <noreply@terraphim.io>

Author: Terraphim CI

Cargo.lock

@@ -98,16 +98,12 @@ impl ConcurrencyController {
     }
 
     /// Try to acquire a slot for a time-driven agent.
-    pub async fn acquire_time_driven(
-        &self,
-    ) -> Option<AgentPermit> {
+    pub async fn acquire_time_driven(&self) -> Option<AgentPermit> {
         self.acquire(AgentMode::TimeDriven).await
     }
 
     /// Try to acquire a slot for an issue-driven agent.
-    pub async fn acquire_issue_driven(
-        &self,
-    ) -> Option<AgentPermit> {
+    pub async fn acquire_issue_driven(&self) -> Option<AgentPermit> {
         self.acquire(AgentMode::IssueDriven).await
     }
 

crates/terraphim_orchestrator/src/concurrency.rs

@@ -117,17 +117,20 @@ impl DualModeOrchestrator {
             ConcurrencyController::new(
                 workflow.concurrency.global_max,
                 ModeQuotas {
-                    time_max: workflow.concurrency.global_max.saturating_sub(workflow.concurrency.issue_max),
+                    time_max: workflow
+                        .concurrency
+                        .global_max
+                        .saturating_sub(workflow.concurrency.issue_max),
                     issue_max: workflow.concurrency.issue_max,
                 },
-                workflow.concurrency.fairness.parse().unwrap_or(FairnessPolicy::RoundRobin),
+                workflow
+                    .concurrency
+                    .fairness
+                    .parse()
+                    .unwrap_or(FairnessPolicy::RoundRobin),
             )
         } else {
-            ConcurrencyController::new(
-                10,
-                ModeQuotas::default(),
-                FairnessPolicy::RoundRobin,
-            )
+            ConcurrencyController::new(10, ModeQuotas::default(), FairnessPolicy::RoundRobin)
         };
 
         // Create shared state
@@ -143,9 +146,13 @@ impl DualModeOrchestrator {
 
         // Setup time mode
         let time_mode = {
-            let scheduler = TimeScheduler::new(&config.agents, Some(&config.compound_review.schedule))?;
+            let scheduler =
+                TimeScheduler::new(&config.agents, Some(&config.compound_review.schedule))?;
             let shutdown_rx = state.shutdown_tx.subscribe();
-            Some(TimeModeComponents { scheduler, shutdown_rx })
+            Some(TimeModeComponents {
+                scheduler,
+                shutdown_rx,
+            })
         };
 
         // Setup issue mode if configured
@@ -154,7 +161,11 @@ impl DualModeOrchestrator {
                 match create_tracker(workflow) {
                     Ok(tracker) => {
                         let shutdown_rx = state.shutdown_tx.subscribe();
-                        Some(IssueModeComponents { tracker, workflow: workflow.clone(), shutdown_rx })
+                        Some(IssueModeComponents {
+                            tracker,
+                            workflow: workflow.clone(),
+                            shutdown_rx,
+                        })
                     }
                     Err(e) => {
                         warn!("failed to create issue tracker: {}", e);
@@ -245,14 +256,14 @@ impl DualModeOrchestrator {
     /// Shutdown gracefully.
     async fn shutdown(&mut self) {
         info!("initiating graceful shutdown");
-        
+
         // Stop accepting new tasks
         self.request_shutdown();
 
         // Wait for active agents to complete
         let timeout = Duration::from_secs(30);
         let start = std::time::Instant::now();
-        
+
         loop {
             let active_count = {
                 let agents = self.active_agents.lock().await;
@@ -265,7 +276,10 @@ impl DualModeOrchestrator {
             }
 
             if start.elapsed() > timeout {
-                warn!("shutdown timeout reached with {} agents still active", active_count);
+                warn!(
+                    "shutdown timeout reached with {} agents still active",
+                    active_count
+                );
                 break;
             }
 
@@ -274,7 +288,7 @@ impl DualModeOrchestrator {
 
         // Shutdown base orchestrator
         self.base.shutdown();
-        
+
         info!("shutdown complete");
     }
 
@@ -291,12 +305,19 @@ impl DualModeOrchestrator {
     }
 
     /// Trigger compound review.
-    pub async fn trigger_compound_review(&mut self) -> Result<CompoundReviewResult, crate::OrchestratorError> {
+    pub async fn trigger_compound_review(
+        &mut self,
+    ) -> Result<CompoundReviewResult, crate::OrchestratorError> {
         self.base.trigger_compound_review().await
     }
 
     /// Handoff task between agents.
-    pub async fn handoff(&mut self, from_agent: &str, to_agent: &str, ctx: HandoffContext) -> Result<(), crate::OrchestratorError> {
+    pub async fn handoff(
+        &mut self,
+        from_agent: &str,
+        to_agent: &str,
+        ctx: HandoffContext,
+    ) -> Result<(), crate::OrchestratorError> {
         self.base.handoff(from_agent, to_agent, ctx).await
     }
 }
@@ -305,7 +326,10 @@ impl DualModeOrchestrator {
 async fn run_time_mode(components: TimeModeComponents, state: SharedState) {
     info!("starting time mode task");
 
-    let TimeModeComponents { mut scheduler, mut shutdown_rx } = components;
+    let TimeModeComponents {
+        mut scheduler,
+        mut shutdown_rx,
+    } = components;
 
     // Get immediate agents (Safety layer)
     let immediate = scheduler.immediate_agents();
@@ -353,7 +377,11 @@ async fn run_time_mode(components: TimeModeComponents, state: SharedState) {
 async fn run_issue_mode(components: IssueModeComponents, state: SharedState) {
     info!("starting issue mode task");
 
-    let IssueModeComponents { tracker, workflow, mut shutdown_rx } = components;
+    let IssueModeComponents {
+        tracker,
+        workflow,
+        mut shutdown_rx,
+    } = components;
 
     let poll_interval = Duration::from_secs(workflow.poll_interval_secs);
 
@@ -363,7 +391,7 @@ async fn run_issue_mode(components: IssueModeComponents, state: SharedState) {
                 match tracker.fetch_candidate_issues().await {
                     Ok(issues) => {
                         info!(count = issues.len(), "fetched candidate issues");
-                        
+
                         for issue in issues {
                             // Skip blocked issues
                             if !issue.all_blockers_terminal(&workflow.tracker.states.terminal) {
@@ -416,11 +444,15 @@ fn create_tracker(workflow: &WorkflowConfig) -> Result<Box<dyn IssueTracker>, St
                 active_states: workflow.tracker.states.active.clone(),
                 terminal_states: workflow.tracker.states.terminal.clone(),
                 use_robot_api: workflow.tracker.use_robot_api,
-            }).map_err(|e| format!("failed to create Gitea tracker: {}", e))?;
-            
+            })
+            .map_err(|e| format!("failed to create Gitea tracker: {}", e))?;
+
             Ok(Box::new(tracker))
         }
-        _ => Err(format!("unsupported tracker kind: {}", workflow.tracker.kind)),
+        _ => Err(format!(
+            "unsupported tracker kind: {}",
+            workflow.tracker.kind
+        )),
     }
 }
 

crates/terraphim_orchestrator/src/dual_mode.rs

@@ -10,15 +10,15 @@ pub mod nightwatch;
 pub mod scheduler;
 
 pub use compound::{CompoundReviewResult, CompoundReviewWorkflow};
+pub use concurrency::{ConcurrencyController, FairnessPolicy, ModeQuotas};
 pub use config::{
     AgentDefinition, AgentLayer, CompoundReviewConfig, ConcurrencyConfig, NightwatchConfig,
     OrchestratorConfig, TrackerConfig, TrackerStates, WorkflowConfig,
 };
-pub use error::OrchestratorError;
-pub use handoff::HandoffContext;
-pub use concurrency::{ConcurrencyController, FairnessPolicy, ModeQuotas};
 pub use dispatcher::{DispatchTask, Dispatcher, DispatcherStats};
 pub use dual_mode::DualModeOrchestrator;
+pub use error::OrchestratorError;
+pub use handoff::HandoffContext;
 pub use mode::{IssueMode, TimeMode};
 pub use nightwatch::{
     CorrectionAction, CorrectionLevel, DriftAlert, DriftMetrics, DriftScore, NightwatchMonitor,

crates/terraphim_orchestrator/src/lib.rs

@@ -2,9 +2,7 @@
 //!
 //! Polls Gitea/Linear for issues and dispatches agents to work on them.
 
-use crate::{
-    ConcurrencyController, DispatchTask, Dispatcher, WorkflowConfig,
-};
+use crate::{ConcurrencyController, DispatchTask, Dispatcher, WorkflowConfig};
 use std::collections::HashMap;
 use std::time::Duration;
 use terraphim_tracker::{Issue, IssueTracker, PagerankClient};
@@ -79,18 +77,18 @@ impl IssueMode {
     }
 
     /// Poll for issues and dispatch agents.
-    async fn poll_and_dispatch(&mut self,
-    ) -> Result<(), Box<dyn std::error::Error>> {
+    async fn poll_and_dispatch(&mut self) -> Result<(), Box<dyn std::error::Error>> {
         // Fetch candidate issues
         let mut issues = self.tracker.fetch_candidate_issues().await?;
 
         // Fetch PageRank scores if enabled
         if let Some(ref pagerank) = self.pagerank {
-            match pagerank.fetch_ready(&self.config.tracker.owner,&self.config.tracker.repo,
-            ).await {
+            match pagerank
+                .fetch_ready(&self.config.tracker.owner, &self.config.tracker.repo)
+                .await
+            {
                 Ok(ready) => {
-                    PagerankClient::merge_scores(&mut issues,&ready.ready_issues,
-                    );
+                    PagerankClient::merge_scores(&mut issues, &ready.ready_issues);
                 }
                 Err(e) => {
                     warn!("failed to fetch PageRank scores: {}", e);
@@ -140,7 +138,10 @@ impl IssueMode {
             }
 
             // Check if issue state is active
-            if !active_states.iter().any(|s| s.eq_ignore_ascii_case(&issue.state)) {
+            if !active_states
+                .iter()
+                .any(|s| s.eq_ignore_ascii_case(&issue.state))
+            {
                 continue;
             }
 
@@ -191,7 +192,10 @@ fn compute_sort_score(issue: &Issue) -> i64 {
     let base = issue.priority.map(|p| p as i64 * 100).unwrap_or(500);
 
     // PageRank bonus (higher = more important = lower score)
-    let pagerank_bonus = issue.pagerank_score.map(|pr| -(pr * 100.0) as i64).unwrap_or(0);
+    let pagerank_bonus = issue
+        .pagerank_score
+        .map(|pr| -(pr * 100.0) as i64)
+        .unwrap_or(0);
 
     base + pagerank_bonus
 }
@@ -207,8 +211,7 @@ mod tests {
 
     #[async_trait]
     impl IssueTracker for MockTracker {
-        async fn fetch_candidate_issues(&self,
-        ) -> terraphim_tracker::Result<Vec<Issue>> {
+        async fn fetch_candidate_issues(&self) -> terraphim_tracker::Result<Vec<Issue>> {
             Ok(self.issues.clone())
         }