CI: remove k8s stages, fix the Docker-level pipeline green

Survey + fixes so the pipeline passes at the Docker level (no k8s).

- Remove k8s: drop the `sandbox-k8s` job (kind/Calico/--features k8s-tests) and the
  "Helm chart lints" gate step. release.yml was already k8s-clean.
- Rust job:
  - `cargo fmt --all` — fix pre-existing formatting drift (fmt --check was failing).
  - clippy -D warnings: fix 3 lib warnings (cm-brain sort_by_key→Reverse, cm-api
    fleet.rs doc list indentation, node_rules map_or→is_none_or).
  - Regenerate the .sqlx offline cache (was missing the cm-runtime run_loop test
    query → offline compile failed). DB-backed tests use testcontainers at runtime.
  - Set SQLX_OFFLINE=true on the rust + e2e jobs so query! macros compile against
    the committed cache deterministically (no DB needed at compile time).
- Frontend job:
  - Fix the 1 ESLint error (useAgentTelemetry: no setState-synchronously-in-effect;
    tag the slice with agentId + derive null on mismatch).
  - Fix 2 stale panel-params tests (`terminal` is a valid app id now; assert the
    current APP_IDS + use a genuinely-unknown id for the reject case).

Verified locally: fmt clean, clippy --all-targets -D warnings clean (offline),
frontend lint 0 errors, tsc clean, 86/86 frontend tests pass, build OK.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>

crates/cm-api/src/routes/world.rs

@@ -74,33 +74,60 @@ fn summarize_input(input: &Value) -> String {
 /// Normalize one durable `run_events` row into taxonomy events — the Rust twin of
 /// the handoff bridge's normalize(). The runner already journals these, so the
 /// live view shows REAL reasoning, tool-convergence and doors with no runner edit.
-fn normalize_run_event(agent_id: &str, event_type: &str, payload: &Value) -> Vec<(&'static str, Value)> {
+fn normalize_run_event(
+    agent_id: &str,
+    event_type: &str,
+    payload: &Value,
+) -> Vec<(&'static str, Value)> {
     let mut out = Vec::new();
     match event_type {
         "text_delta" => {
             if let Some(delta) = payload.get("delta").and_then(|v| v.as_str()) {
-                out.push(("agent.reasoning.delta", json!({ "agentId": agent_id, "text": delta })));
+                out.push((
+                    "agent.reasoning.delta",
+                    json!({ "agentId": agent_id, "text": delta }),
+                ));
             }
         }
         "step_started" => {
-            let tool = payload.get("tool").and_then(|v| v.as_str()).unwrap_or("tool");
+            let tool = payload
+                .get("tool")
+                .and_then(|v| v.as_str())
+                .unwrap_or("tool");
             let node_id = format!("tool:{tool}");
-            let target = payload.get("input").map(summarize_input).unwrap_or_default();
+            let target = payload
+                .get("input")
+                .map(summarize_input)
+                .unwrap_or_default();
             // File/project I/O gets an explosive burst (high touch weight).
             let lower = tool.to_lowercase();
-            let file_op = ["file", "read", "write", "drive", "vault", "obsidian", "edit", "fs", "save"]
-                .iter()
-                .any(|k| lower.contains(k));
+            let file_op = [
+                "file", "read", "write", "drive", "vault", "obsidian", "edit", "fs", "save",
+            ]
+            .iter()
+            .any(|k| lower.contains(k));
             let weight = if file_op { 1.0 } else { 0.4 };
-            out.push(("agent.tool.call", json!({ "agentId": agent_id, "tool": tool, "target": target })));
+            out.push((
+                "agent.tool.call",
+                json!({ "agentId": agent_id, "tool": tool, "target": target }),
+            ));
             out.push(("node.activity", json!({ "nodeId": node_id, "label": tool, "kind": "service", "heat": if file_op { 1.0 } else { 0.9 } })));
             // the agent converges on the tool it's using (the Gource beam)
             out.push(("world.touch", json!({ "agentId": agent_id, "nodeId": node_id, "kind": "service", "weight": weight })));
         }
         "approval_required" => {
-            let action = payload.get("action_type").and_then(|v| v.as_str()).unwrap_or("action");
-            let category = payload.get("category").and_then(|v| v.as_str()).unwrap_or("");
-            let door_id = payload.get("approval_id").and_then(|v| v.as_str()).unwrap_or("");
+            let action = payload
+                .get("action_type")
+                .and_then(|v| v.as_str())
+                .unwrap_or("action");
+            let category = payload
+                .get("category")
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            let door_id = payload
+                .get("approval_id")
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
             out.push((
                 "door.request",
                 json!({ "doorId": door_id, "agentId": agent_id, "action": action, "target": category, "summary": action }),
@@ -134,7 +161,10 @@ struct AgentTele {
 /// Per-agent telemetry for every agent in the workspace, in 4 grouped queries
 /// (not N×4): tokens over the last minute, credits over the last hour, active
 /// routines, and pending approvals — all keyed by agent id.
-async fn agent_telemetry(pool: &PgPool, ws: WorkspaceId) -> std::collections::HashMap<String, AgentTele> {
+async fn agent_telemetry(
+    pool: &PgPool,
+    ws: WorkspaceId,
+) -> std::collections::HashMap<String, AgentTele> {
     let mut m: std::collections::HashMap<String, AgentTele> = std::collections::HashMap::new();
     let id_of = |r: &sqlx::postgres::PgRow| r.get::<uuid::Uuid, _>("agent_id").to_string();
 
@@ -347,7 +377,9 @@ pub async fn world_replay(
         events.push(json!({ "t": started, "type": "node.activity", "data": { "nodeId": node_id, "label": "run", "kind": "event", "heat": 0.85 }}));
         events.push(json!({ "t": started, "type": "world.touch", "data": { "agentId": agent_id, "nodeId": node_id, "kind": "event" }}));
     }
-    Ok(Json(json!({ "events": events, "hours": hours, "count": rows.len() })))
+    Ok(Json(
+        json!({ "events": events, "hours": hours, "count": rows.len() }),
+    ))
 }
 
 // THE NORMALIZE SEAM (future) -------------------------------------------------