fix(core,server): resolve D4 post-push CI failures (fitness-check crash + clippy + fmt)

Root-caused and fixed everything CI flagged red after D4 (7672f52) landed:

- indexer/parser.rs: walk_calls fed an immediately-invoked closure's whole
  multi-line body to split_receiver_callee/selected_callee_byte_span as if it
  were a simple dotted callee expression. The naive last-`.`/`::` scan latched
  onto an unrelated nested call and derived a byte span that collided with
  that call's own correctly-walked RawCall, tripping D4's new UNIQUE
  call_sites identity index and crashing fitness-check on a real repo. Now
  guarded to only run that logic on single-line fn_node text.
- scip/ingest.rs, scip/parse.rs, lsp/overlay.rs, lsp/provider.rs,
  tools/recover.rs: clippy fixes (type_complexity via a CallEdgeRow alias,
  needless_borrow, needless_update, map_flatten, too_many_arguments,
  assertions_on_constants, collapsible_if) across every feature-combo CI
  actually lints with, including one only visible under lsp-overlay/
  all-languages and one masked by the fmt-check step short-circuiting first.
- embedding.rs: pre-existing (non-D4) cargo fmt violations.

Verified: all 6 CI clippy invocations + fmt --check clean locally, fresh
index of a real repo no longer hits the UNIQUE constraint, and two clean
full `cargo test --workspace --all-features` runs both pass (937 tests, 0
failed) with no competing background processes -- including
watcher_reindexes_add_and_delete and
coordinator_refuses_phase_three_commit_after_a_newer_baseline_is_queued,
each of which flaked once earlier under this session's own resource
contention (stacked calm serve daemons + concurrent builds) but passed
cleanly in isolation and in the final clean run.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: Your Name

crates/calm-core/src/embedding.rs

@@ -360,9 +360,13 @@ mod imp {
             }
             let model = model
                 .into_optimized()
-                .map_err(|e| anyhow::anyhow!("optimize onnx model at {}: {e}", onnx_path.display()))?
+                .map_err(|e| {
+                    anyhow::anyhow!("optimize onnx model at {}: {e}", onnx_path.display())
+                })?
                 .into_runnable()
-                .map_err(|e| anyhow::anyhow!("compile onnx model at {}: {e}", onnx_path.display()))?;
+                .map_err(|e| {
+                    anyhow::anyhow!("compile onnx model at {}: {e}", onnx_path.display())
+                })?;
 
             let mut this = Self {
                 model,
@@ -397,8 +401,11 @@ mod imp {
                 .encode(text, true)
                 .map_err(|e| anyhow::anyhow!("tokenize: {e}"))?;
             let mut ids: Vec<i64> = encoding.get_ids().iter().map(|&x| x as i64).collect();
-            let mut mask: Vec<i64> =
-                encoding.get_attention_mask().iter().map(|&x| x as i64).collect();
+            let mut mask: Vec<i64> = encoding
+                .get_attention_mask()
+                .iter()
+                .map(|&x| x as i64)
+                .collect();
             ids.truncate(ONNX_MAX_SEQ_LEN);
             mask.truncate(ONNX_MAX_SEQ_LEN);
             while ids.len() < ONNX_MAX_SEQ_LEN {

crates/calm-core/src/indexer/parser.rs

@@ -1726,6 +1726,18 @@ fn walk_calls(
                     None
                 }
             })
+        // A legitimate callee expression (`a.b.method`, `Type::method`) is
+        // always single-line/single-expression text in every currently
+        // supported grammar. Reject a multi-line `fn_node` here -- e.g. an
+        // immediately-invoked closure `(|| { ...multi-statement body... })()`
+        // resolves its "function" field to the WHOLE closure body, and
+        // `split_receiver_callee`'s naive last-`.`/`::` scan then silently
+        // latches onto some unrelated call buried inside that body (found
+        // via a real UNIQUE-constraint collision on a real repo: an
+        // IIFE-shaped `(|| {...})()` produced a phantom RawCall whose
+        // `rfind`-derived byte span landed on the SAME bytes as the real,
+        // separately-walked call a few lines later).
+        && !source[fn_node.byte_range()].contains('\n')
         && let Some((mut receiver, callee, mut receiver_is_type_path)) =
             split_receiver_callee(&source[fn_node.byte_range()])
         && let Some((callee_start_byte, callee_end_byte)) =

crates/calm-core/src/lsp/overlay.rs

@@ -497,6 +497,7 @@ enum PhaseThreeOutcome {
 /// Leader-only portion of an LSP refresh. The coordinator guarantees that no
 /// same-baseline peer starts another server, and its cancellation token fences
 /// a superseded generation before it can write evidence in phase 3.
+#[allow(clippy::too_many_arguments)]
 fn run_lsp_overlay_prepared(
     conn: &Connection,
     root: &Path,

crates/calm-core/src/lsp/provider.rs

@@ -355,7 +355,7 @@ mod tests {
             (CLANGD.client_profile.language_id)(Path::new("x.cpp")),
             "cpp"
         );
-        assert!(RUST_ANALYZER.client_profile.include_workspace_folder);
+        const { assert!(RUST_ANALYZER.client_profile.include_workspace_folder) };
     }
 
     #[test]

crates/calm-core/src/scip/ingest.rs

@@ -11,6 +11,20 @@ use super::parse::ScipOccurrence;
 
 type ExactCallSiteKey = (String, i64, i64, String);
 type DefinitionSite = (String, i64);
+/// One joined `call_edges`/`call_sites`/`file_index`/`symbols` row used by
+/// both the upgrade pass and `exact_sibling_rule_out_ids`: (edge id,
+/// call_site id, exact CallSite key, target def path, target def line,
+/// edge_confidence, formal_source, ruled_out_by_scip).
+type CallEdgeRow = (
+    i64,
+    i64,
+    ExactCallSiteKey,
+    String,
+    i64,
+    String,
+    Option<String>,
+    bool,
+);
 
 /// Outcome of one `ingest_occurrences` pass.
 ///
@@ -185,16 +199,7 @@ pub fn ingest_occurrences_with_proof_context(
         }
     }
 
-    let rows: Vec<(
-        i64,
-        i64,
-        ExactCallSiteKey,
-        String,
-        i64,
-        String,
-        Option<String>,
-        bool,
-    )> = {
+    let rows: Vec<CallEdgeRow> = {
         let mut stmt = conn.prepare(
             "SELECT ce.id, ce.call_site_id, cs.from_path, cs.callee_start_byte,
                     cs.callee_end_byte, fi.hash, s.path, s.line_start, ce.edge_confidence,
@@ -227,7 +232,7 @@ pub fn ingest_occurrences_with_proof_context(
     let mut newly_upgraded = 0;
     let mut satisfied = HashSet::new();
     for (edge_id, _, key, def_path, def_line, confidence, formal_source, _) in &rows {
-        let agrees = ref_targets.get(&key).is_some_and(|targets| {
+        let agrees = ref_targets.get(key).is_some_and(|targets| {
             targets
                 .iter()
                 .any(|(path, line)| path == def_path && *line == *def_line)
@@ -290,21 +295,11 @@ pub fn ingest_occurrences_with_proof_context(
         } else {
             satisfied.len() as f64 / ref_targets.len() as f64
         },
-        ..IngestStats::default()
     })
 }
 
 fn exact_sibling_rule_out_ids(
-    rows: &[(
-        i64,
-        i64,
-        ExactCallSiteKey,
-        String,
-        i64,
-        String,
-        Option<String>,
-        bool,
-    )],
+    rows: &[CallEdgeRow],
     ref_targets: &HashMap<ExactCallSiteKey, Vec<DefinitionSite>>,
 ) -> Vec<i64> {
     let mut groups: HashMap<i64, Vec<_>> = HashMap::new();

crates/calm-core/src/scip/parse.rs

@@ -63,7 +63,7 @@ pub fn parse_index(
                 line: (start_line as usize) + 1,
                 start_byte: byte_range.map(|(start, _)| start),
                 end_byte: byte_range.map(|(_, end)| end),
-                source_file_hash: byte_range.as_ref().map(|_| source_hash.clone()).flatten(),
+                source_file_hash: byte_range.as_ref().and_then(|_| source_hash.clone()),
                 symbol: occ.symbol.clone(),
                 is_def,
                 is_local: occ.symbol.starts_with("local "),

crates/calm-server/src/tools/recover.rs

@@ -47,19 +47,17 @@ impl CalmServer {
             let mut external_proofs = ExternalProofStatusOutput::default();
             if let Ok(mut stmt) = conn.prepare(
                 "SELECT status, COUNT(*) FROM external_proofs GROUP BY status",
-            ) {
-                if let Ok(rows) = stmt.query_map([], |row| {
-                    Ok((row.get::<_, String>(0)?, row.get::<_, u64>(1)?))
-                }) {
-                    for row in rows.flatten() {
-                        match row.0.as_str() {
-                            "fresh" => external_proofs.fresh = row.1,
-                            "stale" => external_proofs.stale = row.1,
-                            "legacy" => external_proofs.legacy = row.1,
-                            "unverified" => external_proofs.unverified = row.1,
-                            "rejected" => external_proofs.rejected = row.1,
-                            _ => {}
-                        }
+            ) && let Ok(rows) = stmt.query_map([], |row| {
+                Ok((row.get::<_, String>(0)?, row.get::<_, u64>(1)?))
+            }) {
+                for row in rows.flatten() {
+                    match row.0.as_str() {
+                        "fresh" => external_proofs.fresh = row.1,
+                        "stale" => external_proofs.stale = row.1,
+                        "legacy" => external_proofs.legacy = row.1,
+                        "unverified" => external_proofs.unverified = row.1,
+                        "rejected" => external_proofs.rejected = row.1,
+                        _ => {}
                     }
                 }
             }