Fix all clippy::uninlined_format_args errors across 11 source files

- Inline all format arguments in format!() calls to use {var} syntax
  instead of passing variables as arguments
- Fixes clippy::uninlined_format_args (denied via -D warnings) detected
  by Rust 1.88 clippy on CI

Author: developerworks

src/config/state.rs

@@ -327,7 +327,7 @@ impl ConfigState {
         use std::hash::{Hash, Hasher};
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
         json.hash(&mut hasher);
-        format!("v{:x}", hasher.finish())
+        format!("v{hash:x}", hash = hasher.finish())
     }
 
     /// Recovers pending transactions after a restart.

src/dashboard/error.rs

@@ -68,7 +68,7 @@ impl DashboardError {
             "unsupported_method",
             "protocol_parse",
             None,
-            format!("unsupported dashboard IPC method {}", method.as_ref()),
+            format!("unsupported dashboard IPC method {m}", m = method.as_ref()),
             false,
         )
     }
@@ -182,7 +182,7 @@ impl DashboardError {
             "authz_denied",
             "authorization",
             None,
-            format!("command {} is not authorized", method.into()),
+            format!("command {m} is not authorized", m = method.into()),
             false,
         )
     }
@@ -204,7 +204,7 @@ impl DashboardError {
             "replay_detected",
             "replay_protection",
             None,
-            format!("replay detected for request_id {}", request_id.into()),
+            format!("replay detected for request_id {r}", r = request_id.into()),
             false,
         )
     }
@@ -253,7 +253,7 @@ impl DashboardError {
             "allowlist_denied",
             "allowlist",
             None,
-            format!("external command not in allowlist: {}", path.into()),
+            format!("external command not in allowlist: {p}", p = path.into()),
             false,
         )
     }

src/dashboard/ipc_server.rs

@@ -839,7 +839,10 @@ pub fn validate_command(command: &ControlCommandRequest) -> Result<(), Dashboard
         return Err(DashboardError::validation(
             "command_validate",
             Some(command.target_id.clone()),
-            format!("command_id is not a valid UUID: {}", command.command_id),
+            format!(
+                "command_id is not a valid UUID: {id}",
+                id = command.command_id
+            ),
         ));
     }
     // AddChild requires a non-empty manifest.

src/dashboard/registration.rs

@@ -178,7 +178,7 @@ pub async fn send_registration_upsert(
             "registration_ack_read_timeout",
             "registration_send",
             Some(config.target_id.clone()),
-            format!("timed out reading registration ack after {}s", io_timeout,),
+            format!("timed out reading registration ack after {io_timeout}s"),
             true,
         )
     })?

src/dashboard/runtime.rs

@@ -316,7 +316,7 @@ impl BoundedFrameReader {
                             "frame_too_large",
                             "ipc_read",
                             None,
-                            format!("frame exceeded maximum size of {} bytes", self.max_bytes),
+                            format!("frame exceeded maximum size of {max} bytes", max = self.max_bytes),
                             false,
                         ));
                     }

src/dashboard/state.rs

@@ -57,7 +57,12 @@ pub fn build_dashboard_state(
     );
     let recent_logs = recent_events
         .iter()
-        .map(|event| log_record_for_event(event, format!("event {}", event.event_type)))
+        .map(|event| {
+            log_record_for_event(
+                event,
+                format!("event {event_type}", event_type = event.event_type),
+            )
+        })
         .collect::<Vec<_>>();
     DashboardState {
         target: TargetProcessIdentity {
@@ -160,8 +165,8 @@ pub fn runtime_state_rows(state: &SupervisorState) -> Vec<RuntimeState> {
         .map(|child| RuntimeState {
             child_path: child.path.to_string(),
             lifecycle_state: child.state.as_label().to_owned(),
-            health: format!("{:?}", child.health).to_lowercase(),
-            readiness: format!("{:?}", child.readiness).to_lowercase(),
+            health: format!("{health:?}", health = child.health).to_lowercase(),
+            readiness: format!("{readiness:?}", readiness = child.readiness).to_lowercase(),
             generation: child.generation.value,
             child_start_count: child.child_start_count.value,
             restart_count: child.restart_count,
@@ -173,7 +178,7 @@ pub fn runtime_state_rows(state: &SupervisorState) -> Vec<RuntimeState> {
                 .last_policy_decision
                 .as_ref()
                 .map(|decision| decision.decision.clone()),
-            shutdown_state: format!("{:?}", state.shutdown_state).to_lowercase(),
+            shutdown_state: format!("{s:?}", s = state.shutdown_state).to_lowercase(),
         })
         .collect()
 }

src/ipc/security/mod.rs

@@ -296,7 +296,11 @@ impl IpcSecurityPipeline {
         if !self.audit_config.enabled {
             return Ok(());
         }
-        let hash = format!("uid:{}:pid:{}", peer_identity.uid, peer_identity.pid);
+        let hash = format!(
+            "uid:{uid}:pid:{pid}",
+            uid = peer_identity.uid,
+            pid = peer_identity.pid
+        );
         let now = std::time::SystemTime::now()
             .duration_since(std::time::UNIX_EPOCH)
             .unwrap_or_default()

src/observe/pipeline.rs

@@ -472,7 +472,7 @@ fn make_backpressure_alert(
 ) -> SupervisorEvent {
     let mut ev = event.clone();
     ev.what = What::BackpressureAlert {
-        subscriber: format!("subscriber_{}", subscriber_index),
+        subscriber: format!("subscriber_{subscriber_index}"),
         buffer_pct: occupancy_pct,
         threshold_pct,
     };
@@ -493,7 +493,7 @@ fn make_backpressure_degradation(
         BackpressureStrategy::SampleAndAudit => "sample_and_audit",
     };
     ev.what = What::BackpressureDegradation {
-        subscriber: format!("subscriber_{}", subscriber_index),
+        subscriber: format!("subscriber_{subscriber_index}"),
         strategy: strategy_name.to_owned(),
         sample_ratio: FiniteF64::new(0.5),
         buffer_peak_pct: occupancy_pct,
@@ -1200,7 +1200,7 @@ fn merge_generation_fence_child_control_audit_fields(
     if let Some(fence) = &outcome.generation_fence {
         context.insert(
             "generation_fence_decision".to_owned(),
-            format!("{:?}", fence.decision),
+            format!("{decision:?}", decision = fence.decision),
         );
         context.insert(
             "generation_fence_abort_requested".to_owned(),
@@ -1283,19 +1283,19 @@ fn audit_child_control(input: ChildControlAuditInput<'_>) -> AuditRecord {
     context.insert("status".to_owned(), optional_debug(input.outcome.status));
     context.insert(
         "operation_before".to_owned(),
-        format!("{:?}", input.outcome.operation_before),
+        format!("{ob:?}", ob = input.outcome.operation_before),
     );
     context.insert(
         "operation_after".to_owned(),
-        format!("{:?}", input.outcome.operation_after),
+        format!("{oa:?}", oa = input.outcome.operation_after),
     );
     context.insert(
         "cancel_delivered".to_owned(),
         input.outcome.cancel_delivered.to_string(),
     );
     context.insert(
         "stop_state".to_owned(),
-        format!("{:?}", input.outcome.stop_state),
+        format!("{ss:?}", ss = input.outcome.stop_state),
     );
     context.insert(
         "restart_limit_remaining".to_owned(),

src/runtime/control_loop.rs

@@ -700,7 +700,7 @@ impl RuntimeControlState {
         // Execute six-stage supervision pipeline for failure processing.
         let sequence = self.event_sequences.next().value;
         // T037: Generate a real CorrelationId to link budget→meltdown→escalation events.
-        let correlation_id_str = format!("{}", uuid::Uuid::new_v4());
+        let correlation_id_str = uuid::Uuid::new_v4().to_string();
         let supervisor_path = self
             .slots
             .get(&child_id)
@@ -748,7 +748,7 @@ impl RuntimeControlState {
             )
             && let Some(ref group_id) = pipeline_result.group_id
         {
-            let _ignored = event_sender.send(format!("group_fuse_active:{group_id}:{}", child_id));
+            let _ignored = event_sender.send(format!("group_fuse_active:{group_id}:{child_id}"));
             // Mark all children in the affected group as non-restartable.
             for (_cid, slot) in self.slots.iter_mut() {
                 if slot.group.as_deref() == Some(group_id.as_str()) {
@@ -1045,7 +1045,7 @@ impl RuntimeControlState {
                 &mut self.orphan_count,
             ) {
                 let _ =
-                    event_sender.send(format!("child_orphaned:{}:shutdown_phase=reconcile", diag,));
+                    event_sender.send(format!("child_orphaned:{diag}:shutdown_phase=reconcile"));
             }
         }
         let reconcile = ShutdownReconcileReport::core_runtime_completed();
@@ -1069,7 +1069,10 @@ impl RuntimeControlState {
             reconcile,
             idempotent: false,
         };
-        let _ignored = event_sender.send(format!("shutdown_completed:{}", report.outcomes.len()));
+        let _ignored = event_sender.send(format!(
+            "shutdown_completed:{len}",
+            len = report.outcomes.len()
+        ));
         self.shutdown_pipeline.cache_report(report.clone());
 
         // Step 4: active orphan degradation detection.
@@ -3034,7 +3037,10 @@ impl RuntimeControlState {
             idempotent: false,
         };
         self.shutdown_pipeline.cache_report(report.clone());
-        let _ignored = event_sender.send(format!("shutdown_completed:{}", report.outcomes.len()));
+        let _ignored = event_sender.send(format!(
+            "shutdown_completed:{len}",
+            len = report.outcomes.len()
+        ));
 
         // Step 4: active orphan degradation detection.
         let threshold = self.shutdown.policy.effective_max_orphan_threshold() as u64;
@@ -3480,7 +3486,10 @@ pub async fn run_control_loop(
                     Ok(()) => {
                         let report = RuntimeExitReport::completed(
                             "shutdown",
-                            format!("runtime control plane shutdown requested: {}", meta.reason),
+                            format!(
+                                "runtime control plane shutdown requested: {reason}",
+                                reason = meta.reason
+                            ),
                         );
                         let _ignored = reply_sender.send(Ok(report.clone()));
                         return report;

src/runtime/pipeline.rs

@@ -747,9 +747,9 @@ impl SupervisionPipeline {
                     let fuse_outcome_str = ctx
                         .budget_evaluation
                         .as_ref()
-                        .map(|be| format!("{:?}", be.meltdown_outcome));
+                        .map(|be| format!("{mo:?}", mo = be.meltdown_outcome));
                     return What::EscalationBifurcated {
-                        severity: format!("{:?}", policy.severity),
+                        severity: format!("{s:?}", s = policy.severity),
                         budget_verdict: budget_verdict_str,
                         fuse_outcome: fuse_outcome_str,
                         tie_break_reason: None,