refactor: Use idiomatic let...else and remove redundant closures

crates/pu-core/src/agent_def.rs

@@ -96,9 +96,8 @@ pub fn delete_agent_def(dir: &Path, name: &str) -> Result<bool, std::io::Error>
 
 fn scan_dir(dir: &Path, scope: &str) -> Vec<AgentDef> {
     let mut defs = Vec::new();
-    let entries = match std::fs::read_dir(dir) {
-        Ok(e) => e,
-        Err(_) => return defs,
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return defs;
     };
     for entry in entries.flatten() {
         let path = entry.path();

crates/pu-core/src/manifest.rs

@@ -28,7 +28,9 @@ pub fn write_manifest(project_root: &Path, manifest: &Manifest) -> Result<(), Pu
     let file = std::fs::File::create(&tmp_path)?;
     let mut writer = std::io::BufWriter::new(file);
     writer.write_all(content.as_bytes())?;
-    let file = writer.into_inner().map_err(|e| e.into_error())?;
+    let file = writer
+        .into_inner()
+        .map_err(std::io::IntoInnerError::into_error)?;
     file.sync_all()?;
     std::fs::rename(&tmp_path, &path)?;
     Ok(())

crates/pu-core/src/schedule_def.rs

@@ -82,7 +82,7 @@ impl ScheduleDef {
                     "agent_name must not be set when root is true",
                 ));
             }
-        } else if self.agent_name.as_ref().is_none_or(|n| n.is_empty()) {
+        } else if self.agent_name.as_ref().is_none_or(String::is_empty) {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
                 "agent_name is required when root is false",
@@ -277,9 +277,8 @@ pub fn next_occurrence(
 
 fn scan_dir(dir: &Path, scope: &str) -> Vec<ScheduleDef> {
     let mut defs = Vec::new();
-    let entries = match std::fs::read_dir(dir) {
-        Ok(e) => e,
-        Err(_) => return defs,
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return defs;
     };
     for entry in entries.flatten() {
         let path = entry.path();

crates/pu-core/src/swarm_def.rs

@@ -101,9 +101,8 @@ pub fn delete_swarm_def(dir: &Path, name: &str) -> Result<bool, std::io::Error>
 
 fn scan_dir(dir: &Path, scope: &str) -> Vec<SwarmDef> {
     let mut defs = Vec::new();
-    let entries = match std::fs::read_dir(dir) {
-        Ok(e) => e,
-        Err(_) => return defs,
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return defs;
     };
     for entry in entries.flatten() {
         let path = entry.path();

crates/pu-core/src/template.rs

@@ -222,9 +222,8 @@ pub fn delete_template(dir: &Path, name: &str) -> Result<bool, std::io::Error> {
 
 fn scan_dir(dir: &Path, source: &str) -> Vec<Template> {
     let mut templates = Vec::new();
-    let entries = match std::fs::read_dir(dir) {
-        Ok(e) => e,
-        Err(_) => return templates,
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return templates;
     };
     for entry in entries.flatten() {
         let path = entry.path();

crates/pu-engine/src/engine.rs

@@ -646,14 +646,11 @@ impl Engine {
         let creating_new_worktree = !root && worktree.is_none();
         let agent_name = if creating_new_worktree {
             // Worktree spawns require a user-provided name (becomes the branch slug)
-            let raw = match name {
-                Some(n) => n,
-                None => {
-                    return Response::Error {
-                        code: "INVALID_ARGUMENT".into(),
-                        message: "worktree spawn requires a name".into(),
-                    };
-                }
+            let Some(raw) = name else {
+                return Response::Error {
+                    code: "INVALID_ARGUMENT".into(),
+                    message: "worktree spawn requires a name".into(),
+                };
             };
             let normalized = pu_core::id::normalize_worktree_name(&raw);
             if normalized.is_empty() {
@@ -700,7 +697,7 @@ impl Engine {
                 } else {
                     (
                         parts[0].to_string(),
-                        parts[1..].iter().map(|s| s.to_string()).collect(),
+                        parts[1..].iter().map(ToString::to_string).collect(),
                     )
                 }
             };
@@ -995,14 +992,11 @@ impl Engine {
         };
 
         // Resolve name
-        let raw = match name {
-            Some(n) => n,
-            None => {
-                return Response::Error {
-                    code: "INVALID_ARGUMENT".into(),
-                    message: "worktree creation requires a name".into(),
-                };
-            }
+        let Some(raw) = name else {
+            return Response::Error {
+                code: "INVALID_ARGUMENT".into(),
+                message: "worktree creation requires a name".into(),
+            };
         };
         let worktree_name = pu_core::id::normalize_worktree_name(&raw);
         if worktree_name.is_empty() {
@@ -1833,9 +1827,8 @@ impl Engine {
     /// Called synchronously inside handle_init so state is correct before the first status read.
     fn reconcile_agents_on_init(project_root: &str) {
         let root = Path::new(project_root);
-        let m = match manifest::read_manifest(root) {
-            Ok(m) => m,
-            Err(_) => return,
+        let Ok(m) = manifest::read_manifest(root) else {
+            return;
         };
         let is_stale = |a: &AgentEntry| {
             !a.suspended && matches!(a.status, AgentStatus::Streaming | AgentStatus::Waiting)
@@ -1880,9 +1873,8 @@ impl Engine {
     /// Note: Suspended agents are intentionally unaffected — they have no PID and are paused.
     fn reap_stale_agents(project_root: &str) {
         let root = Path::new(project_root);
-        let m = match manifest::read_manifest(root) {
-            Ok(m) => m,
-            Err(_) => return,
+        let Ok(m) = manifest::read_manifest(root) else {
+            return;
         };
         let needs_reap = |a: &AgentEntry| {
             !a.suspended