style: Replace disallowed methods with idiomatic alternatives

Replace map_or/map_or_else with map().unwrap_or()/map().unwrap_or_else()
per clippy disallowed_methods configuration.

Replace for_each with for loops for side-effectful iteration.

Files changed:
- claude.rs: map_or -> map().unwrap_or()
- filter.rs: map_or_else -> map().unwrap_or_else()
- results.rs: for_each -> for loop
- manager.rs: map_or -> if let Some
- output_formatter.rs: map_or -> map().unwrap_or()
- progress.rs: for_each -> for loops
- composer.rs: for_each -> for loop, map_or -> if let Some
- git_operations_tests.rs: for_each with panic -> collect + assert
- error_handling_test.rs: map_or -> map().unwrap_or()

Author: iepathos

src/cook/execution/claude.rs

@@ -78,7 +78,7 @@ impl<R: CommandRunner + 'static> ClaudeExecutor for ClaudeExecutorImpl<R> {
         env_vars: HashMap<String, String>,
     ) -> Result<ExecutionResult> {
         // Handle test mode
-        let test_mode = self.test_config.as_ref().map_or(false, |c| c.test_mode);
+        let test_mode = self.test_config.as_ref().map(|c| c.test_mode).unwrap_or(false);
         if test_mode {
             return self.handle_test_mode_execution(command).await;
         }
@@ -110,7 +110,7 @@ impl<R: CommandRunner + 'static> ClaudeExecutor for ClaudeExecutorImpl<R> {
 
     async fn check_claude_cli(&self) -> Result<bool> {
         // Always return true in test mode
-        let test_mode = self.test_config.as_ref().map_or(false, |c| c.test_mode);
+        let test_mode = self.test_config.as_ref().map(|c| c.test_mode).unwrap_or(false);
         if test_mode {
             return Ok(true);
         }

src/cook/execution/data_pipeline/filter.rs

@@ -610,13 +610,12 @@ impl FilterExpression {
     /// Pure function: Compare string against regex pattern
     pub(crate) fn compare_regex(actual: Option<&Value>, expected: &Value) -> bool {
         match (actual, expected) {
-            (Some(Value::String(a)), Value::String(pattern)) => Regex::new(pattern).map_or_else(
-                |e| {
+            (Some(Value::String(a)), Value::String(pattern)) => Regex::new(pattern)
+                .map(|re| re.is_match(a))
+                .unwrap_or_else(|e| {
                     warn!("Invalid regex pattern '{}': {}", pattern, e);
                     false
-                },
-                |re| re.is_match(a),
-            ),
+                }),
             _ => false,
         }
     }
@@ -728,13 +727,12 @@ impl FilterExpression {
 
     /// Pure function: Check if string matches regex pattern
     pub(crate) fn regex_matches(text: &str, pattern: &str) -> bool {
-        Regex::new(pattern).map_or_else(
-            |e| {
+        Regex::new(pattern)
+            .map(|re| re.is_match(text))
+            .unwrap_or_else(|e| {
                 warn!("Invalid regex pattern '{}': {}", pattern, e);
                 false
-            },
-            |re| re.is_match(text),
-        )
+            })
     }
 }
 

src/cook/execution/mapreduce/agent/results.rs

@@ -174,28 +174,24 @@ impl AgentResultAggregator for DefaultResultAggregator {
             context.set("map.results", results_value);
         }
 
-        // Add individual successful results using iterator
-        results
-            .successful
-            .iter()
-            .enumerate()
-            .for_each(|(i, result)| {
-                context.set(
-                    format!("map.successful.{}.item_id", i),
-                    json!(result.item_id),
-                );
-                if let Some(output) = &result.output {
-                    context.set(format!("map.successful.{}.output", i), json!(output));
-                }
-            });
+        // Add individual successful results
+        for (i, result) in results.successful.iter().enumerate() {
+            context.set(
+                format!("map.successful.{}.item_id", i),
+                json!(result.item_id),
+            );
+            if let Some(output) = &result.output {
+                context.set(format!("map.successful.{}.output", i), json!(output));
+            }
+        }
 
-        // Add individual failed results using iterator
-        results.failed.iter().enumerate().for_each(|(i, result)| {
+        // Add individual failed results
+        for (i, result) in results.failed.iter().enumerate() {
             context.set(format!("map.failed.{}.item_id", i), json!(result.item_id));
             if let Some(error) = &result.error {
                 context.set(format!("map.failed.{}.error", i), json!(error));
             }
-        });
+        }
 
         context
     }

src/cook/execution/mapreduce/checkpoint/manager.rs

@@ -157,18 +157,19 @@ impl CheckpointManager {
             );
         }
 
-        // Validate agent state consistency using functional find
-        checkpoint
+        // Validate agent state consistency
+        if let Some(agent_id) = checkpoint
             .agent_state
             .agent_assignments
             .keys()
             .find(|agent_id| !checkpoint.agent_state.active_agents.contains_key(*agent_id))
-            .map_or(Ok(()), |agent_id| {
-                Err(anyhow!(
-                    "Agent {} has assignments but is not active",
-                    agent_id
-                ))
-            })
+        {
+            return Err(anyhow!(
+                "Agent {} has assignments but is not active",
+                agent_id
+            ));
+        }
+        Ok(())
     }
 
     /// Validate checkpoint integrity

src/cook/execution/mapreduce/dry_run/output_formatter.rs

@@ -216,7 +216,7 @@ impl OutputFormatter {
         // Show available variables
         let total_vars = preview.setup_variables.len()
             + preview.reduce_variables.len()
-            + preview.item_variables.first().map_or(0, |v| v.len());
+            + preview.item_variables.first().map(|v| v.len()).unwrap_or(0);
 
         writeln!(output, "  Available variables: {}", total_vars).unwrap();
     }

src/cook/execution/mapreduce/resources/git_operations_tests.rs

@@ -539,11 +539,13 @@ mod tests {
             ),
         ];
 
-        // Apply all validations using functional approach
-        validations
+        // Apply all validations
+        let failures: Vec<_> = validations
             .iter()
             .filter(|(condition, _)| !condition)
-            .for_each(|(_, msg)| panic!("{}", msg));
+            .map(|(_, msg)| *msg)
+            .collect();
+        assert!(failures.is_empty(), "Validation failures: {:?}", failures);
 
         // Modified files check - we created 2 files across 2 commits
         // The exact count depends on deduplication logic

src/cook/execution/progress.rs

@@ -744,10 +744,10 @@ impl ProgressWebServer {
             let connections = self.connections.read().await;
             let message = serde_json::to_string(&update).unwrap_or_default();
 
-            // Broadcast to all connections using functional iteration
-            connections.values().for_each(|sender| {
+            // Broadcast to all connections
+            for sender in connections.values() {
                 let _ = sender.send(message.clone());
-            });
+            }
         }
     }
 
@@ -893,13 +893,13 @@ impl ProgressWebServer {
         output.push_str("# HELP mapreduce_agent_states Count of agents by state\n");
         output.push_str("# TYPE mapreduce_agent_states gauge\n");
 
-        // Build state metrics using functional iteration
-        state_counts.iter().for_each(|(state, count)| {
+        // Build state metrics
+        for (state, count) in &state_counts {
             output.push_str(&format!(
                 "mapreduce_agent_states{{job_id=\"{}\",state=\"{}\"}} {}\n",
                 server.tracker.job_id, state, count
             ));
-        });
+        }
 
         // Job duration
         let duration = server.tracker.start_time.elapsed().as_secs();

src/cook/workflow/composition/composer.rs

@@ -243,15 +243,15 @@ impl WorkflowComposer {
 
         // Apply parameter defaults if defined
         if let Some(params) = &mut workflow.parameters {
-            params
+            for param in params
                 .optional
                 .iter_mut()
                 .filter(|param| param.default.is_none())
-                .for_each(|param| {
-                    if let Some(default_value) = defaults.get(&param.name) {
-                        param.default = Some(default_value.clone());
-                    }
-                });
+            {
+                if let Some(default_value) = defaults.get(&param.name) {
+                    param.default = Some(default_value.clone());
+                }
+            }
         }
 
         Ok(())
@@ -628,17 +628,15 @@ impl WorkflowComposer {
         &self,
         sub_workflows: &HashMap<String, super::SubWorkflow>,
     ) -> Result<()> {
-        // Check for missing sources using functional approach
-        sub_workflows
-            .iter()
-            .find(|(_, sub)| !sub.source.exists())
-            .map_or(Ok(()), |(name, sub)| {
-                anyhow::bail!(
-                    "Sub-workflow '{}' source does not exist: {:?}",
-                    name,
-                    sub.source
-                )
-            })
+        // Check for missing sources
+        if let Some((name, sub)) = sub_workflows.iter().find(|(_, sub)| !sub.source.exists()) {
+            anyhow::bail!(
+                "Sub-workflow '{}' source does not exist: {:?}",
+                name,
+                sub.source
+            )
+        }
+        Ok(())
     }
 }
 

tests/error_handling_test.rs

@@ -29,9 +29,9 @@ fn test_option_handling_without_unwrap() -> Result<()> {
     assert_eq!(some_value.unwrap_or(0), 42);
     assert_eq!(none_value.unwrap_or(0), 0);
 
-    // Using map_or for transformations
-    assert_eq!(some_value.map_or(0, |v| v * 2), 84);
-    assert_eq!(none_value.map_or(0, |v| v * 2), 0);
+    // Using map + unwrap_or for transformations
+    assert_eq!(some_value.map(|v| v * 2).unwrap_or(0), 84);
+    assert_eq!(none_value.map(|v| v * 2).unwrap_or(0), 0);
 
     Ok(())
 }
@@ -56,9 +56,9 @@ fn test_result_handling_without_unwrap() -> Result<()> {
     assert_eq!(ok_result.as_ref().unwrap_or(&0), &42);
     assert_eq!(err_result.as_ref().unwrap_or(&0), &0);
 
-    // Using map_or for transformations
-    assert_eq!(ok_result.as_ref().map_or(0, |v| v * 2), 84);
-    assert_eq!(err_result.map_or(0, |v| v * 2), 0);
+    // Using map + unwrap_or for transformations
+    assert_eq!(ok_result.as_ref().map(|v| v * 2).unwrap_or(0), 84);
+    assert_eq!(err_result.map(|v| v * 2).unwrap_or(0), 0);
 
     Ok(())
 }