Fix rustfmt formatting violations to unblock CI on release/v0.0.11 (#99)

Run cargo fmt --all to fix formatting across 8 files that failed the
rustfmt check in CI (runs/23273074858 and runs/23273086485).

Author: Shooksie

crates/llm-cli-wrapper/src/session/mod.rs

@@ -17,9 +17,7 @@ pub mod subprocess_session_backend;
 pub(crate) async fn kill_and_reap_child(child: &mut tokio::process::Child) {
     #[cfg(unix)]
     if let Some(pid) = child.id() {
-        let _ = std::process::Command::new("kill")
-            .args(["-9", &format!("-{}", pid)])
-            .output();
+        let _ = std::process::Command::new("kill").args(["-9", &format!("-{}", pid)]).output();
     }
     #[cfg(not(unix))]
     let _ = child.kill().await;

crates/oai-runner/src/config.rs

@@ -36,10 +36,7 @@ pub fn resolve_config(model: &str, api_base: Option<String>, api_key: Option<Str
 }
 
 fn infer_structured_output_support(normalized_model: &str) -> StructuredOutputSupport {
-    if normalized_model.starts_with("zai")
-        || normalized_model.starts_with("glm")
-        || normalized_model.contains("glm")
-    {
+    if normalized_model.starts_with("zai") || normalized_model.starts_with("glm") || normalized_model.contains("glm") {
         return StructuredOutputSupport::JsonObjectOnly;
     }
     if normalized_model.starts_with("minimax/") || normalized_model.contains("minimax") {

crates/oai-runner/src/main.rs

@@ -156,11 +156,7 @@ async fn main() -> Result<()> {
                 cancel_for_signal.cancel();
             });
 
-            let structured_output = if no_response_format {
-                None
-            } else {
-                Some(resolved_config.structured_output)
-            };
+            let structured_output = if no_response_format { None } else { Some(resolved_config.structured_output) };
 
             let result = runner::agent_loop::run_agent_loop(
                 &client,

crates/oai-runner/src/runner/agent_loop.rs

@@ -52,19 +52,12 @@ fn build_json_schema_format(schema: &Value) -> ResponseFormat {
     }
     ResponseFormat {
         type_: "json_schema".to_string(),
-        json_schema: Some(JsonSchemaSpec {
-            name: "phase_output".to_string(),
-            strict: true,
-            schema: strict_schema,
-        }),
+        json_schema: Some(JsonSchemaSpec { name: "phase_output".to_string(), strict: true, schema: strict_schema }),
     }
 }
 
 fn build_json_object_format() -> ResponseFormat {
-    ResponseFormat {
-        type_: "json_object".to_string(),
-        json_schema: None,
-    }
+    ResponseFormat { type_: "json_object".to_string(), json_schema: None }
 }
 
 fn build_schema_injection(schema: &Value) -> String {
@@ -117,8 +110,8 @@ pub async fn run_agent_loop(
         }
     }
 
-    let needs_schema_in_prompt = structured_output == Some(StructuredOutputSupport::JsonObjectOnly)
-        && response_schema.is_some();
+    let needs_schema_in_prompt =
+        structured_output == Some(StructuredOutputSupport::JsonObjectOnly) && response_schema.is_some();
 
     if messages.is_empty() {
         let mut sys = system_prompt.to_string();
@@ -195,10 +188,22 @@ pub async fn run_agent_loop(
             if let Some(schema) = response_schema {
                 if let Err(errors) = validate_output_against_schema(content, schema) {
                     let system_msg = messages.iter().find(|m| m.role == "system").cloned();
-                    let corrected =
-                        retry_schema_validation(client, model, system_msg.as_ref(), &mut messages, schema, &errors, output, structured_output).await;
+                    let corrected = retry_schema_validation(
+                        client,
+                        model,
+                        system_msg.as_ref(),
+                        &mut messages,
+                        schema,
+                        &errors,
+                        output,
+                        structured_output,
+                    )
+                    .await;
                     if !corrected {
-                        eprintln!("Warning: schema validation failed after {} retries, synthesizing fallback result", SCHEMA_RETRY_LIMIT);
+                        eprintln!(
+                            "Warning: schema validation failed after {} retries, synthesizing fallback result",
+                            SCHEMA_RETRY_LIMIT
+                        );
                         schema_ok = false;
                     }
                 }
@@ -302,12 +307,8 @@ async fn retry_schema_validation(
 ) -> bool {
     let mut last_errors = initial_errors.to_string();
 
-    let last_assistant_content = messages
-        .iter()
-        .rev()
-        .find(|m| m.role == "assistant")
-        .and_then(|m| m.content.clone())
-        .unwrap_or_default();
+    let last_assistant_content =
+        messages.iter().rev().find(|m| m.role == "assistant").and_then(|m| m.content.clone()).unwrap_or_default();
 
     for attempt in 1..=SCHEMA_RETRY_LIMIT {
         eprintln!("Schema validation failed (attempt {}/{}): {}", attempt, SCHEMA_RETRY_LIMIT, last_errors);
@@ -389,14 +390,17 @@ fn validate_output_against_schema(content: &str, schema: &Value) -> std::result:
 
     let validator = jsonschema::validator_for(schema).map_err(|e| format!("Invalid schema: {}", e))?;
 
-    let errors: Vec<String> = validator.iter_errors(&parsed).map(|e| {
-        let path = e.instance_path().to_string();
-        if path.is_empty() {
-            format!("{}", e)
-        } else {
-            format!("at '{}': {}", path, e)
-        }
-    }).collect();
+    let errors: Vec<String> = validator
+        .iter_errors(&parsed)
+        .map(|e| {
+            let path = e.instance_path().to_string();
+            if path.is_empty() {
+                format!("{}", e)
+            } else {
+                format!("at '{}': {}", path, e)
+            }
+        })
+        .collect();
 
     if errors.is_empty() {
         Ok(())

crates/orchestrator-cli/src/services/operations/ops_mcp/runner_tools.rs

@@ -44,12 +44,11 @@ impl AoMcpServer {
         description = "Clean up orphaned runner processes. Purpose: Remove runner processes that are no longer managed by the daemon. Prerequisites: Use ao.runner.orphans-detect first to identify orphaned run IDs. Example: {\"run_id\": [\"abc123\"]}. Sequencing: Use after ao.runner.orphans-detect to find orphan IDs, then ao.runner.health to verify cleanup.",
         input_schema = ao_schema_for_type::<RunnerOrphansCleanupInput>()
     )]
-    async fn ao_runner_orphans_cleanup(&self, params: Parameters<RunnerOrphansCleanupInput>) -> Result<CallToolResult, McpError> {
-        let mut args = vec![
-            "runner".to_string(),
-            "orphans".to_string(),
-            "cleanup".to_string(),
-        ];
+    async fn ao_runner_orphans_cleanup(
+        &self,
+        params: Parameters<RunnerOrphansCleanupInput>,
+    ) -> Result<CallToolResult, McpError> {
+        let mut args = vec!["runner".to_string(), "orphans".to_string(), "cleanup".to_string()];
         for id in &params.0.run_id {
             args.push("--run-id".to_string());
             args.push(id.clone());

crates/orchestrator-cli/src/services/operations/ops_workflow/mod.rs

@@ -73,11 +73,22 @@ async fn resolve_workflow_run_dispatch_from_input(
     project_root: &str,
     input: WorkflowRunInput,
 ) -> Result<protocol::SubjectDispatch> {
-    let WorkflowRunInput { subject, workflow_ref, input, vars, task_id: flat_task_id, requirement_id: flat_requirement_id, .. } = input;
-    let effective_task_id = subject.task_id().filter(|id| !id.is_empty()).map(|s| s.to_string())
+    let WorkflowRunInput {
+        subject,
+        workflow_ref,
+        input,
+        vars,
+        task_id: flat_task_id,
+        requirement_id: flat_requirement_id,
+        ..
+    } = input;
+    let effective_task_id = subject
+        .task_id()
+        .filter(|id| !id.is_empty())
+        .map(|s| s.to_string())
         .or_else(|| (!flat_task_id.is_empty()).then_some(flat_task_id));
-    let effective_requirement_id = subject.requirement_id().filter(|id| !id.is_empty()).map(|s| s.to_string())
-        .or(flat_requirement_id);
+    let effective_requirement_id =
+        subject.requirement_id().filter(|id| !id.is_empty()).map(|s| s.to_string()).or(flat_requirement_id);
     if let Some(id) = effective_task_id {
         let task = hub.tasks().get(&id).await?;
         Ok(protocol::SubjectDispatch::for_task_with_metadata(

crates/orchestrator-cli/src/services/runtime/runtime_daemon/daemon_reconciliation.rs

@@ -173,18 +173,11 @@ fn workflow_is_waiting_on_manual_phase(project_root: &str, workflow: &orchestrat
         .unwrap_or(false)
 }
 
-pub async fn reconcile_runner_blocked_tasks(
-    hub: Arc<dyn ServiceHub>,
-    _project_root: &str,
-) -> Result<usize> {
+pub async fn reconcile_runner_blocked_tasks(hub: Arc<dyn ServiceHub>, _project_root: &str) -> Result<usize> {
     let tasks = match hub.tasks().list().await {
         Ok(tasks) => tasks,
         Err(error) => {
-            eprintln!(
-                "{}: failed to list tasks for runner-blocked reconciliation: {}",
-                protocol::ACTOR_DAEMON,
-                error
-            );
+            eprintln!("{}: failed to list tasks for runner-blocked reconciliation: {}", protocol::ACTOR_DAEMON, error);
             return Ok(0);
         }
     };
@@ -202,12 +195,7 @@ pub async fn reconcile_runner_blocked_tasks(
                 // Escalated to human review — task left blocked
             }
             Err(error) => {
-                eprintln!(
-                    "{}: failed to reconcile runner-blocked task {}: {}",
-                    protocol::ACTOR_DAEMON,
-                    task.id,
-                    error
-                );
+                eprintln!("{}: failed to reconcile runner-blocked task {}: {}", protocol::ACTOR_DAEMON, task.id, error);
             }
         }
     }

crates/orchestrator-core/src/execution_projection.rs

@@ -44,10 +44,7 @@ pub fn is_workflow_runner_blocked(task: &OrchestratorTask) -> bool {
 /// been reset.  Once the count reaches `MAX_RUNNER_FAILURE_RESETS` the task is
 /// left blocked and an error message is logged, signalling that human
 /// intervention is needed.
-pub async fn reconcile_runner_blocked_task(
-    hub: Arc<dyn ServiceHub>,
-    task: &OrchestratorTask,
-) -> anyhow::Result<bool> {
+pub async fn reconcile_runner_blocked_task(hub: Arc<dyn ServiceHub>, task: &OrchestratorTask) -> anyhow::Result<bool> {
     let count = task.consecutive_dispatch_failures.unwrap_or(0).saturating_add(1);
 
     if count > MAX_RUNNER_FAILURE_RESETS {
@@ -243,7 +240,10 @@ mod tests {
     use chrono::Utc;
     use protocol::{SubjectExecutionFact, SUBJECT_KIND_TASK};
 
-    use super::{execution_fact_subject_kind, is_workflow_runner_blocked, project_execution_fact, reconcile_runner_blocked_task, MAX_RUNNER_FAILURE_RESETS};
+    use super::{
+        execution_fact_subject_kind, is_workflow_runner_blocked, project_execution_fact, reconcile_runner_blocked_task,
+        MAX_RUNNER_FAILURE_RESETS,
+    };
     use crate::{
         services::ServiceHub, InMemoryServiceHub, OrchestratorTask, Priority, ResourceRequirements, Scope,
         TaskMetadata, TaskStatus, TaskType, WorkflowMetadata,
@@ -450,7 +450,8 @@ mod tests {
             status: TaskStatus::Blocked,
             paused: true,
             blocked_reason: Some(
-                "workflow runner exited without workflow status: workflow runner exited with status Some(1)".to_string(),
+                "workflow runner exited without workflow status: workflow runner exited with status Some(1)"
+                    .to_string(),
             ),
             ..base_test_task("TASK-1")
         };