chore: collapse the ifs the 1.98 clippy flags

The pinned toolchain's clippy grew opinions the older lint let stand:
nested if/if-let pairs it wants as let-chains, and a modulo test it
wants as is_multiple_of. Machine-applied collapses, fmt-settled, no
behavior change — the gauntlet runs clean again.

crates/rhema-claw/src/accounts_tools.rs

@@ -132,8 +132,7 @@ pub fn save_account(
         forge_known: forge.is_some(),
         watch_added: false,
     };
-    if watch {
-        if let Some(kind) = forge {
+    if watch && let Some(kind) = forge {
         let host = saved.account.url.as_deref().filter(|url| !url.is_empty());
         saved.watch_added = watches
             .add_account_watch(kind.name(), host, &saved.account.id)
@@ -141,7 +140,6 @@ pub fn save_account(
     }
     // Asked to watch a service the daemon cannot watch: the save
     // stands, the watch verdict says why not.
-    }
     Ok(saved)
 }
 

crates/rhema-claw/src/backends.rs

@@ -669,12 +669,12 @@ pub fn discover(
 /// The config file's model seeds llama's fallback, as discovery always
 /// has: it names the deployment's local model when it names one at all.
 fn seed_llama_model(backend: &mut Backend, config: &crate::config::ClawConfig) {
-    if backend.kind == "llama-cpp" {
-        if let Some(model) = &config.model {
+    if backend.kind == "llama-cpp"
+        && let Some(model) = &config.model
+    {
         backend.default_model = model.clone();
     }
 }
-}
 
 #[cfg(test)]
 mod tests {

crates/rhema-claw/src/config.rs

@@ -320,21 +320,21 @@ impl ClawConfig {
         // The agent token's safety is that it is scoped; making it the
         // human token silently unscopes everything the model's shell
         // holds. Boot refuses the configuration instead.
-        if let (Some(token), Some(agent_token)) = (&self.token, &self.agent_token) {
-            if !token.is_empty() && token == agent_token {
+        if let (Some(token), Some(agent_token)) = (&self.token, &self.agent_token)
+            && !token.is_empty()
+            && token == agent_token
+        {
             return Err(ConfigError::SameAgentToken);
         }
-        }
         // The ingest credential's safety is that it is write-only and
         // one route deep; a value shared with a wider class silently
         // widens it, so boot refuses the collision with either token.
-        if let Some(ingest_token) = self.ingest_token.as_deref().filter(|t| !t.is_empty()) {
-            if Some(ingest_token) == self.token.as_deref()
-                || Some(ingest_token) == self.agent_token.as_deref()
+        if let Some(ingest_token) = self.ingest_token.as_deref().filter(|t| !t.is_empty())
+            && (Some(ingest_token) == self.token.as_deref()
+                || Some(ingest_token) == self.agent_token.as_deref())
         {
             return Err(ConfigError::IngestTokenCollision);
         }
-        }
         Ok(())
     }
 }

crates/rhema-claw/src/consents.rs

@@ -349,15 +349,15 @@ pub async fn wait_for_resolution(
 ) -> WaitOutcome {
     let deadline = tokio::time::Instant::now() + budget;
     loop {
-        if let Ok(Some(consent)) = store.get(id) {
-            if let Some(granted) = consent.granted {
+        if let Ok(Some(consent)) = store.get(id)
+            && let Some(granted) = consent.granted
+        {
             return if granted {
                 WaitOutcome::Granted(consent.account_id)
             } else {
                 WaitOutcome::Denied
             };
         }
-        }
         let waiter = bridge.waiter(id);
         let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
         match tokio::time::timeout(remaining, waiter.notified()).await {

crates/rhema-claw/src/http.rs

@@ -1433,8 +1433,9 @@ async fn ingest(State(state): State<ClawState>, Json(body): Json<IngestBody>) ->
     // `phone status` read cannot. A bare `phone:<device>` key is a
     // message on the device's resident key and dispatches like any
     // resident key's. A store failure is logged, never fatal.
-    if source == crate::phone::SOURCE {
-        if let Some((device, topic)) = crate::phone::phone_key_parts(key) {
+    if source == crate::phone::SOURCE
+        && let Some((device, topic)) = crate::phone::phone_key_parts(key)
+    {
         if let Err(err) = state.phone.observe(device, topic, &body.payload) {
             eprintln!("[claw] warning: phone state for {key} not stored: {err}");
         }
@@ -1444,7 +1445,6 @@ async fn ingest(State(state): State<ClawState>, Json(body): Json<IngestBody>) ->
         )
             .into_response();
     }
-    }
     match state.ingest_external(source, key, body.payload) {
         Ok(result) => (
             StatusCode::ACCEPTED,
@@ -1761,14 +1761,14 @@ async fn providers_set_credentials(
     }
     let kind = match state.backends().get(id) {
         Some(existing) => {
-            if let Some(kind) = body["kind"].as_str() {
-                if kind != existing.kind {
+            if let Some(kind) = body["kind"].as_str()
+                && kind != existing.kind
+            {
                 return Err(bad_request(format!(
                     "provider {id:?} is a {} backend, not {kind:?}",
                     existing.kind
                 )));
             }
-            }
             existing.kind.clone()
         }
         None => match body["kind"].as_str() {

crates/rhema-claw/src/identity.rs

@@ -142,13 +142,13 @@ impl IdentityStore {
         ];
         for (field, value, cap) in fields {
             let cleaned = value.as_deref().map(str::trim).filter(|v| !v.is_empty());
-            if let Some(value) = cleaned {
-                if value.chars().count() > cap {
+            if let Some(value) = cleaned
+                && value.chars().count() > cap
+            {
                 return Err(IdentityError::Backend(format!(
                     "{field} is over {cap} characters"
                 )));
             }
-            }
             self.settings
                 .set(
                     &text_key(field),

crates/rhema-claw/src/phone.rs

@@ -462,14 +462,14 @@ pub async fn wait_for_command_result(
 ) -> CommandOutcome {
     let deadline = tokio::time::Instant::now() + budget;
     loop {
-        if let Ok(Some(command)) = store.command_by_id(id) {
-            if let Some(ok) = command.result_ok {
+        if let Ok(Some(command)) = store.command_by_id(id)
+            && let Some(ok) = command.result_ok
+        {
             return CommandOutcome::Confirmed {
                 ok,
                 detail: command.result_detail,
             };
         }
-        }
         let waiter = bridge.waiter(id);
         let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
         match tokio::time::timeout(remaining, waiter.notified()).await {

crates/rhema-claw/src/task_tools.rs

@@ -149,14 +149,14 @@ impl ToolOp for ScheduleTask {
             .as_deref()
             .map(str::trim)
             .filter(|session| !session.is_empty());
-        if let Some(session) = deliver_to {
-            if !is_resident_key(session) {
+        if let Some(session) = deliver_to
+            && !is_resident_key(session)
+        {
             return Err(format!(
                 "session must be a resident key (interactive:, task:, or phone:), got {session:?}"
             )
             .into());
         }
-        }
         let record = match (args.at, args.every_secs) {
             (Some(at), None) => {
                 let at_millis = parse_at_millis(at)?;

integrations/rhema-calendar-integration/src/ics.rs

@@ -234,22 +234,22 @@ fn vevent_blocks(raw: &str) -> Vec<Vec<ContentLine>> {
             }
             "END" => {
                 let component = line.value.trim().to_ascii_uppercase();
-                if component == "VEVENT" {
-                    if let Some(block) = current.take() {
+                if component == "VEVENT"
+                    && let Some(block) = current.take()
+                {
                     blocks.push(block);
                 }
-                }
                 stack.pop();
             }
             _ => {
-                if stack.last().map(String::as_str) == Some("VEVENT") {
-                    if let Some(block) = current.as_mut() {
+                if stack.last().map(String::as_str) == Some("VEVENT")
+                    && let Some(block) = current.as_mut()
+                {
                     block.push(line);
                 }
             }
         }
     }
-    }
     blocks
 }
 
@@ -755,11 +755,11 @@ fn expand_rule(
         if walked > MAX_CANDIDATES {
             return false;
         }
-        if let Some(until) = rule.until {
-            if start > until {
+        if let Some(until) = rule.until
+            && start > until
+        {
             return false;
         }
-        }
         if start > window.to {
             return false;
         }

integrations/rhema-forge-integration/src/gitea.rs

@@ -398,11 +398,11 @@ fn review_event(
         Some(timestamp) => timestamp,
         None => return Ok(None),
     };
-    if let Some(since) = since {
-        if timestamp < *since {
+    if let Some(since) = since
+        && timestamp < *since
+    {
         return Ok(None);
     }
-    }
     let id = required(row.id, "review id")?;
     Ok(Some(ForgeEvent {
         id: format!("gitea:review:{id}"),
@@ -577,11 +577,11 @@ impl Forge for GiteaForge {
         ];
         for row in self.paged::<WirePull>(&pulls_path, &query).await? {
             let updated = required(row.updated_at.clone(), "pull updated_at")?;
-            if let Some(since) = since {
-                if updated < *since {
+            if let Some(since) = since
+                && updated < *since
+            {
                 continue;
             }
-            }
             let number = required(row.number, "pull number")?;
             if let Some(event) = pull_event(&row, repo)? {
                 events.push(event);

integrations/rhema-forge-integration/src/github.rs

@@ -400,11 +400,11 @@ fn review_event(
     }
     // A review without a submission time was never submitted.
     let timestamp = required(row.submitted_at.clone(), "review submitted_at")?;
-    if let Some(since) = since {
-        if timestamp < *since {
+    if let Some(since) = since
+        && timestamp < *since
+    {
         return Ok(None);
     }
-    }
     let id = required(row.id, "review id")?;
     Ok(Some(ForgeEvent {
         id: format!("github:review:{id}"),

integrations/rhema-forge-integration/src/gitlab.rs

@@ -382,11 +382,11 @@ fn note_event(
         return Ok(None);
     }
     let timestamp = required(row.created_at.clone(), "note created_at")?;
-    if let Some(since) = since {
-        if timestamp < *since {
+    if let Some(since) = since
+        && timestamp < *since
+    {
         return Ok(None);
     }
-    }
     let id = required(row.id, "note id")?;
     Ok(Some(ForgeEvent {
         id: format!("gitlab:note:{id}"),