fix(scip): ruby encoding fallback + surface swallowed nightly failures

- ruby was missing from effective_encoding's spec-convention fallback
  table added by D4 (7672f52): every scip-ruby occurrence had no byte
  span, so ingest_occurrences_with_proof_context's
  identity_version >= 2 gate never matched a row and
  ruby_overlay_upgrades_ambiguous_case_when_calls_on_the_multi_lang_fixture
  failed 6 nightly runs straight (2026-08-01 through 08-07). Verified
  against scip-ruby's real source (SCIPIndexer.cc sets
  text_document_encoding=UTF8 but never calls set_position_encoding
  anywhere in the repo) and end-to-end against the real pinned
  scip-ruby-v0.4.7 binary -- the ignored test now passes for real, not
  just at the unit level.

- cargo test's lib harness never installed a tracing subscriber, so
  run_overlay_for_with_catalog's tracing::warn! on a real indexer
  subprocess failure -- already carrying a real stderr tail from
  runner.rs's run_indexer -- was a complete no-op. Nightly
  python/js/etc. failures showed only the generic "expected at least
  one edge upgraded to formal" with zero diagnostic value, which is
  why the python/js regression (unrelated to the ruby one, still
  under investigation) went unnoticed for weeks. Added
  init_test_tracing() (with_test_writer, so output only surfaces on a
  failing test like println! does) to all 11 real-indexer nightly
  tests plus the calm-cli CLI-level mirror test. Verified by forcing a
  real 1ms timeout locally: the real subprocess-failure reason now
  prints even without --nocapture, matching exactly how the nightly
  workflow invokes cargo test.

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

Author: Your Name

Cargo.lock

@@ -68,8 +68,12 @@ fn calm_index_cli_upgrades_a_real_edge_on_the_fixture() {
         )
         .unwrap();
     assert_eq!(
-        conf, "formal",
+        conf,
+        "formal",
         "expected the CLI's one-shot `calm index` to run the SCIP overlay \
-         and upgrade this edge to formal, same as the background indexer does"
+         and upgrade this edge to formal, same as the background indexer does \
+         -- child stdout={}\nchild stderr={}",
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
     );
 }

crates/calm-cli/tests/scip_overlay_cli.rs

@@ -104,6 +104,14 @@ tokio = { workspace = true, optional = true }
 [dev-dependencies]
 tempfile = "3"
 proptest = "1"
+# Only for the nightly real-indexer `#[ignore]`d tests in scip/mod.rs --
+# without a subscriber installed, cargo test's lib harness leaves every
+# `tracing::warn!`/`info!` in the whole crate a silent no-op, which is
+# exactly how run_overlay_for_with_catalog's real subprocess-failure reason
+# (already captured with a real stderr tail by runner.rs's `run_indexer`)
+# was vanishing from nightly CI logs instead of explaining why e.g.
+# scip-python/scip-js failed. See `init_test_tracing` in scip/mod.rs.
+tracing-subscriber = { workspace = true }
 
 [features]
 # Semantic embeddings: pure-Rust static code embeddings (model2vec-rs).

crates/calm-core/Cargo.toml

@@ -979,6 +979,32 @@ pub struct OverlayStatus {
 mod tests {
     use super::*;
 
+    /// Call at the top of every nightly real-indexer `#[ignore]`d test below.
+    /// `cargo test`'s lib harness installs no `tracing` subscriber by
+    /// default (only `calm-cli`'s/`calm-server`'s real `main()` does), so
+    /// every `tracing::warn!`/`info!` in the whole crate is normally a
+    /// silent no-op during tests -- including `run_overlay_for_with_catalog`'s
+    /// `tracing::warn!("SCIP overlay ({}) run failed, keeping syntactic
+    /// graph: {e}", ...)`, whose `{e}` already carries a real stderr tail
+    /// from the failed subprocess (`runner.rs`'s `run_indexer`). Without this,
+    /// that real reason vanishes and a nightly CI failure shows only the
+    /// generic `assert!(stats.upgraded > 0)` message with zero diagnostic
+    /// value -- root-caused 2026-08-07 chasing scip-python/scip-js nightly
+    /// failures that reproduced on a live GitHub Actions re-run but not
+    /// locally, with no way to see why. `with_test_writer()` routes output
+    /// through cargo test's own per-test capture (shown only on failure,
+    /// like `println!`); `try_init().ok()` makes repeat calls from multiple
+    /// tests in the same process safe (first one wins, rest are no-ops).
+    fn init_test_tracing() {
+        let _ = tracing_subscriber::fmt()
+            .with_test_writer()
+            .with_env_filter(
+                tracing_subscriber::EnvFilter::try_from_default_env()
+                    .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("warn")),
+            )
+            .try_init();
+    }
+
     #[test]
     fn provider_cache_key_tracks_shared_typescript_context_without_cross_language_churn() {
         let root = tempfile::tempdir().unwrap();
@@ -1365,6 +1391,7 @@ mod tests {
     #[test]
     #[ignore]
     fn overlay_upgrades_a_real_edge_on_the_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/rust_workspace");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1409,6 +1436,7 @@ mod tests {
     #[test]
     #[ignore]
     fn go_overlay_upgrades_a_real_edge_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/go");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1557,6 +1585,7 @@ mod tests {
     #[test]
     #[ignore]
     fn go_workspace_overlay_upgrades_edges_in_both_member_modules() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/go_workspace");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1606,6 +1635,7 @@ mod tests {
     #[test]
     #[ignore]
     fn python_overlay_upgrades_a_real_edge_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/python");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1647,6 +1677,7 @@ mod tests {
     #[test]
     #[ignore]
     fn js_overlay_upgrades_a_real_edge_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/js");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1692,6 +1723,7 @@ mod tests {
     #[test]
     #[ignore]
     fn java_overlay_upgrades_a_real_edge_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/java");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1753,6 +1785,7 @@ mod tests {
     #[test]
     #[ignore]
     fn kotlin_overlay_upgrades_ambiguous_smart_cast_calls_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/kotlin");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1876,6 +1909,7 @@ mod tests {
     #[test]
     #[ignore]
     fn ruby_overlay_upgrades_ambiguous_case_when_calls_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/ruby");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -1979,6 +2013,7 @@ mod tests {
     #[test]
     #[ignore]
     fn csharp_overlay_upgrades_a_real_edge_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/csharp");
         let mut conn = Connection::open_in_memory().unwrap();
@@ -2047,6 +2082,7 @@ mod tests {
     #[test]
     #[ignore]
     fn php_overlay_upgrades_a_real_edge_on_the_multi_lang_fixture() {
+        init_test_tracing();
         let fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/php");
         // Composer-managed `vendor/` is gitignored and not committed (see
@@ -2132,6 +2168,7 @@ mod tests {
     #[test]
     #[ignore]
     fn clang_overlay_upgrades_a_real_edge_on_the_c_fixture() {
+        init_test_tracing();
         let src_fixture = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/fixtures/multi_lang_workspace/c");
         let tmp = tempfile::tempdir().unwrap();

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

@@ -11,27 +11,51 @@ pub enum EncodingProvenance {
     /// The SCIP document declared a non-`Unspecified` encoding — the
     /// producing indexer followed the protocol.
     Declared,
-    /// The document left `position_encoding` unset; this provider is one of
-    /// the languages SCIP's own spec (`scip.proto`'s
-    /// `Document.position_encoding` doc comment) documents a convention for,
-    /// so that convention was applied as a fallback instead of failing
-    /// closed. See `effective_encoding`.
+    /// The document left `position_encoding` unset; this provider is one
+    /// CALM has real evidence for (either SCIP's own documented spec
+    /// convention, or a specific indexer's real source verified by hand),
+    /// so a guessed encoding was applied as a fallback instead of failing
+    /// closed. See `effective_encoding` for exactly which providers and
+    /// which kind of evidence backs each.
     Fallback,
     /// The document left `position_encoding` unset and no fallback applies
     /// (unknown/generic provider) — `start_byte`/`end_byte` stay `None`.
     Unresolved,
 }
 
-/// SCIP's own documented convention for indexers that omit
-/// `Document.position_encoding` (`scip-0.9.0/src/generated/scip.rs`'s doc
-/// comment on that field, itself a transcription of `scip.proto`): JVM/.NET/
-/// JS/TS indexers should emit UTF-16, Python UTF-32, Go/Rust/C++ UTF-8. This
-/// is an evidence CONTRACT scoped to exactly those verified languages, never
-/// a global fallback — a provider outside this table keeps failing closed,
-/// including any future/unknown provider. A `declared` encoding (anything
-/// other than `Unspecified`) always wins outright: the indexer's own
-/// self-report has protocol precedence over a guess derived from its
-/// implementation language.
+/// Fallback position-encoding table for indexers that omit
+/// `Document.position_encoding`. This is an evidence CONTRACT — a provider
+/// outside this table keeps failing closed, including any future/unknown
+/// provider — but it's backed by two distinct kinds of evidence, both
+/// treated identically at runtime (guessed, not declared; see
+/// `EncodingProvenance::Fallback` and its defense-in-depth cross-check in
+/// `parse_index`'s `guessed_alt_byte_range`):
+///
+/// - `python` / `javascript`+`java`+`csharp` / `rust`+`go`+`c`: SCIP's own
+///   documented convention (`scip-0.9.0/src/generated/scip.rs`'s doc
+///   comment on `Document.position_encoding`, itself a transcription of
+///   `scip.proto`): Python -> UTF-32, JVM/.NET/JS/TS -> UTF-16,
+///   Go/Rust/C++ -> UTF-8.
+/// - `ruby`: NOT part of that spec table (see
+///   `effective_encoding_unknown_or_unverified_provider_stays_fail_closed`
+///   for what still fails closed), but independently verified against
+///   `scip-ruby`'s real source (github.com/sourcegraph/scip-ruby,
+///   `scip_indexer/SCIPIndexer.cc`): it sets
+///   `Metadata.text_document_encoding` to UTF-8 but never calls
+///   `set_position_encoding` anywhere in the codebase (0 hits repo-wide,
+///   verified via GitHub code search 2026-08-07) — Sorbet's underlying
+///   `core::Loc`/`Range` machinery is byte-oriented like the C/C++-family
+///   indexers above, so UTF-8 is a verified guess, not a spec-table one.
+///   Root-caused from the nightly regression in
+///   `ruby_overlay_upgrades_ambiguous_case_when_calls_on_the_multi_lang_
+///   fixture` that started at D4 (7672f52, 2026-08-01): before this entry,
+///   every scip-ruby occurrence had no byte span at all (`Unresolved`), so
+///   `IngestStats::upgraded` stayed 0.
+///
+/// A `declared` encoding (anything other than `Unspecified`) always wins
+/// outright regardless of the above: the indexer's own self-report has
+/// protocol precedence over any guess derived from its implementation
+/// language.
 fn effective_encoding(
     declared: scip::types::PositionEncoding,
     provider_lang: &str,
@@ -45,7 +69,11 @@ fn effective_encoding(
         "javascript" | "java" | "csharp" => {
             Some(PositionEncoding::UTF16CodeUnitOffsetFromLineStart)
         }
+        // scip.proto's own documented convention (see doc comment above).
         "rust" | "go" | "c" => Some(PositionEncoding::UTF8CodeUnitOffsetFromLineStart),
+        // Not spec-documented -- verified against scip-ruby's real source
+        // instead (see doc comment above).
+        "ruby" => Some(PositionEncoding::UTF8CodeUnitOffsetFromLineStart),
         _ => None,
     };
     match fallback {
@@ -469,14 +497,37 @@ mod tests {
         }
     }
 
+    #[test]
+    fn effective_encoding_ruby_fallback_is_utf8_verified_from_scip_ruby_source() {
+        use scip::types::PositionEncoding::*;
+        // Ruby isn't in scip.proto's documented convention table (see the
+        // test above), so this fallback rests on different evidence:
+        // scip-ruby's real source (sourcegraph/scip-ruby, scip_indexer/
+        // SCIPIndexer.cc) declares `text_document_encoding = UTF8` but never
+        // calls `set_position_encoding` anywhere in the repo (0 hits via
+        // GitHub code search, verified 2026-08-07) -- so its ranges are
+        // left Unspecified and byte-oriented like the C/C++-family
+        // indexers, matching the same UTF-8 guess used for rust/go/c above.
+        // Root-caused from the `ruby_overlay_upgrades_ambiguous_case_when_
+        // calls_on_the_multi_lang_fixture` nightly regression that started
+        // at D4 (7672f52, 2026-08-01): before this fallback existed, every
+        // scip-ruby occurrence had no byte span at all, so
+        // `IngestStats::upgraded` stayed 0.
+        let (encoding, provenance) = effective_encoding(UnspecifiedPositionEncoding, "ruby");
+        assert_eq!(encoding, UTF8CodeUnitOffsetFromLineStart);
+        assert_eq!(provenance, EncodingProvenance::Fallback);
+    }
+
     #[test]
     fn effective_encoding_unknown_or_unverified_provider_stays_fail_closed() {
         use scip::types::PositionEncoding::*;
-        // PHP/Ruby are real providers but NOT in SCIP's documented
-        // encoding-convention table — this is an evidence CONTRACT scoped to
-        // spec-verified languages, not a global fallback, so they (and any
-        // future/unknown provider) must keep failing closed.
-        for lang in ["php", "ruby", "some-future-language", ""] {
+        // PHP is a real provider but has no verified encoding evidence
+        // (neither in SCIP's documented spec table nor independently
+        // confirmed against its real indexer source the way ruby was — see
+        // `effective_encoding`'s doc comment) — this is an evidence
+        // CONTRACT, not a global fallback, so it (and any future/unknown
+        // provider) must keep failing closed.
+        for lang in ["php", "some-future-language", ""] {
             let (encoding, provenance) = effective_encoding(UnspecifiedPositionEncoding, lang);
             assert_eq!(encoding, UnspecifiedPositionEncoding, "lang={lang}");
             assert_eq!(provenance, EncodingProvenance::Unresolved, "lang={lang}");