ci: enforce workspace clippy and clear lint debt

Author: rexleimo

.github/workflows/ci.yml

@@ -196,8 +196,8 @@ jobs:
       - name: Check (workspace, locked)
         run: cargo check --workspace --locked
 
-  clippy-core-fast:
-    name: clippy core crates (fast)
+  clippy-workspace:
+    name: clippy workspace (all targets)
     runs-on: ubuntu-latest
 
     steps:
@@ -210,8 +210,8 @@ jobs:
       - name: Rust cache
         uses: Swatinem/rust-cache@v2
 
-      - name: Clippy (core crates, all targets)
-        run: cargo clippy -p rexos-tools -p rexos-llm -p rexos-kernel --all-targets --locked -- -D warnings
+      - name: Clippy (workspace, all targets)
+        run: cargo clippy --workspace --all-targets --locked -- -D warnings
 
   docs:
     name: docs build

crates/loopforge-cli/src/dispatch/mcp.rs

@@ -1,5 +1,5 @@
 use std::collections::BTreeMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::{anyhow, Context};
 use serde_json::Value;
@@ -135,7 +135,7 @@ async fn diagnose(
 }
 
 fn build_mcp_diagnose_json(
-    workspace: &PathBuf,
+    workspace: &Path,
     session_id: &str,
     sanitized_config: Value,
     servers_json: Value,

crates/loopforge-cli/src/dispatch/session.rs

@@ -174,10 +174,11 @@ mod tests {
 
     #[test]
     fn build_session_policy_json_includes_expected_keys() {
-        let mut skill_policy = rexos::agent::SessionSkillPolicy::default();
-        skill_policy.allowlist = vec!["alpha".to_string()];
-        skill_policy.require_approval = true;
-        skill_policy.auto_approve_readonly = false;
+        let skill_policy = rexos::agent::SessionSkillPolicy {
+            allowlist: vec!["alpha".to_string()],
+            require_approval: true,
+            auto_approve_readonly: false,
+        };
 
         let mcp_config_json =
             r#"{"servers":{"s1":{"command":"python","env":{"API_KEY":"secret"}}}}"#;

crates/rexos-runtime/src/agents_hands/agents/lifecycle.rs

@@ -63,7 +63,7 @@ impl AgentRuntime {
                 out.push(record);
             }
         }
-        Ok(serde_json::to_string(&out).context("serialize agent list")?)
+        serde_json::to_string(&out).context("serialize agent list")
     }
 
     pub(crate) fn agent_find(&self, query: &str) -> anyhow::Result<String> {
@@ -85,7 +85,7 @@ impl AgentRuntime {
             }
         }
 
-        Ok(serde_json::to_string(&out).context("serialize agent find")?)
+        serde_json::to_string(&out).context("serialize agent find")
     }
 
     pub(crate) fn agent_kill(&self, agent_id: &str) -> anyhow::Result<String> {

crates/rexos-runtime/src/agents_hands/hands/lifecycle.rs

@@ -38,7 +38,7 @@ impl AgentRuntime {
             })
             .collect();
 
-        Ok(serde_json::to_string(&out).context("serialize hand_list")?)
+        serde_json::to_string(&out).context("serialize hand_list")
     }
 
     pub(crate) fn hand_activate(&self, args: HandActivateToolArgs) -> anyhow::Result<String> {
@@ -131,7 +131,7 @@ impl AgentRuntime {
             .to_string());
         };
 
-        Ok(serde_json::to_string(&active).context("serialize hand_status")?)
+        serde_json::to_string(&active).context("serialize hand_status")
     }
 
     pub(crate) fn hand_deactivate(&self, instance_id: &str) -> anyhow::Result<String> {

crates/rexos-runtime/src/scheduling/cron.rs

@@ -41,7 +41,7 @@ impl AgentRuntime {
 
     pub(crate) fn cron_list(&self) -> anyhow::Result<String> {
         let jobs = self.cron_jobs_get()?;
-        Ok(serde_json::to_string(&jobs).context("serialize cron_list")?)
+        serde_json::to_string(&jobs).context("serialize cron_list")
     }
 
     pub(crate) fn cron_cancel(&self, job_id: &str) -> anyhow::Result<String> {

crates/rexos-runtime/src/scheduling/runner.rs

@@ -121,7 +121,7 @@ fn truncate_status(s: String) -> String {
         }
         out.push(ch);
     }
-    out.push_str("…");
+    out.push('…');
     out
 }
 
@@ -165,7 +165,7 @@ impl AgentRuntime {
             if let Ok(schedule) = parse_schedule(&job.schedule) {
                 let next = compute_initial_next_run_at(&schedule, now);
                 let job_id = job.job_id.clone();
-                let _ = self.cron_jobs_update(|jobs| {
+                self.cron_jobs_update(|jobs| {
                     if let Some(existing) = jobs.iter_mut().find(|j| j.job_id == job_id) {
                         if existing.next_run_at.is_none() && existing.enabled {
                             existing.next_run_at = Some(next);
@@ -357,10 +357,10 @@ impl AgentRuntime {
                     existing.last_status = Some(truncate_status(status.clone()));
                     existing.consecutive_errors = 0;
 
-                    let disable_after_success = match parse_schedule(&existing.schedule) {
-                        Ok(CronSchedule::At { .. }) => true,
-                        _ => false,
-                    };
+                    let disable_after_success = matches!(
+                        parse_schedule(&existing.schedule),
+                        Ok(CronSchedule::At { .. })
+                    );
                     if existing.one_shot || disable_after_success {
                         existing.enabled = false;
                         existing.next_run_at = None;

crates/rexos-runtime/src/scheduling/schedules.rs

@@ -29,7 +29,7 @@ impl AgentRuntime {
 
     pub(crate) fn schedule_list(&self) -> anyhow::Result<String> {
         let schedules = self.schedules_get()?;
-        Ok(serde_json::to_string(&schedules).context("serialize schedule_list")?)
+        serde_json::to_string(&schedules).context("serialize schedule_list")
     }
 
     pub(crate) fn schedule_delete(&self, id: &str) -> anyhow::Result<String> {

crates/rexos-runtime/src/session_runner/tool_dispatch.rs

@@ -4,7 +4,7 @@ mod parsing;
 mod tasks_scheduling;
 mod workflow_knowledge;
 
-use std::path::PathBuf;
+use std::path::Path;
 
 use anyhow::Context;
 use rexos_kernel::router::TaskKind;
@@ -15,7 +15,7 @@ use crate::AgentRuntime;
 impl AgentRuntime {
     pub(super) async fn dispatch_runtime_tool_call(
         &self,
-        workspace_root: &PathBuf,
+        workspace_root: &Path,
         session_id: &str,
         kind: TaskKind,
         tools: &Toolset,

crates/rexos-runtime/src/session_runner/tool_dispatch/agents_hands.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::Path;
 
 use rexos_kernel::router::TaskKind;
 
@@ -11,7 +11,7 @@ use crate::AgentRuntime;
 
 pub(super) async fn dispatch_agent_hand_tool(
     runtime: &AgentRuntime,
-    workspace_root: &PathBuf,
+    workspace_root: &Path,
     kind: TaskKind,
     tool_name: &str,
     args_json: &str,
@@ -50,7 +50,7 @@ pub(super) async fn dispatch_agent_hand_tool(
             let args: AgentSendToolArgs = parse_args(args_json, tool_name)?;
             Some(
                 runtime
-                    .agent_send(workspace_root.clone(), kind, args)
+                    .agent_send(workspace_root.to_path_buf(), kind, args)
                     .await
                     .map_err(|err| err.context("agent_send"))?,
             )