feat: Windows-CUDA serving node — build fixes + compacted-19b chat candidate

core/continuum-core/src/airc/discovery.rs

@@ -148,17 +148,55 @@ async fn airc_on_path() -> bool {
         .unwrap_or(false)
 }
 
+/// Probe attempts before declaring the substrate unresponsive. A single 5s shot
+/// is a coin flip on a loaded box: Windows process spawn alone can transiently
+/// eat seconds when the machine is compiling/converting/downloading (observed
+/// 2026-07-28 BigMama — the updated airc answered instantly when idle, yet the
+/// one-shot probe timed out mid-build and the core refused full-citizen boot).
+/// Retries stay BOUNDED (3 × deadline ≈ 15s worst case) — resilient to transient
+/// load, still fail-loud when airc is genuinely dead.
+const DISCOVERY_PROBE_ATTEMPTS: u32 = 3;
+
+/// How an `airc <subcommand>` probe failed — timeout (every attempt) vs spawn error.
+enum ProbeError {
+    TimedOut,
+    Io(String),
+}
+
+/// Run `airc <arg>` with the discovery deadline and bounded retries (see
+/// [`DISCOVERY_PROBE_ATTEMPTS`]). ONE probe implementation for every discovery
+/// subcommand — the retry-on-transient-stall policy lives here, not copy-pasted
+/// per call site.
+async fn probe_airc(arg: &str) -> Result<std::process::Output, ProbeError> {
+    for attempt in 1..=DISCOVERY_PROBE_ATTEMPTS {
+        let call = TokioCommand::new("airc").arg(arg).output();
+        match timeout(DISCOVERY_SUBPROCESS_DEADLINE, call).await {
+            Ok(res) => return res.map_err(|e| ProbeError::Io(e.to_string())),
+            Err(_) if attempt < DISCOVERY_PROBE_ATTEMPTS => {
+                warn!(
+                    attempt,
+                    "`airc {arg}` did not exit within {DISCOVERY_SUBPROCESS_DEADLINE:?} \
+                     — retrying (transient spawn stall under load)"
+                );
+            }
+            Err(_) => {}
+        }
+    }
+    Err(ProbeError::TimedOut)
+}
+
+fn probe_timeout_msg(arg: &str) -> String {
+    format!(
+        "`airc {arg}` did not exit within {DISCOVERY_SUBPROCESS_DEADLINE:?} \
+         × {DISCOVERY_PROBE_ATTEMPTS} attempts — substrate is unresponsive, refusing to wait",
+    )
+}
+
 async fn query_airc_endpoint() -> Result<PathBuf, DiscoveryError> {
-    let call = TokioCommand::new("airc").arg("ipc-endpoint").output();
-    let out = timeout(DISCOVERY_SUBPROCESS_DEADLINE, call)
-        .await
-        .map_err(|_| {
-            DiscoveryError::EndpointCommandFailed(format!(
-                "`airc ipc-endpoint` did not exit within {DISCOVERY_SUBPROCESS_DEADLINE:?} \
-                 — substrate is unresponsive, refusing to wait",
-            ))
-        })?
-        .map_err(|e| DiscoveryError::EndpointCommandFailed(e.to_string()))?;
+    let out = probe_airc("ipc-endpoint").await.map_err(|e| match e {
+        ProbeError::TimedOut => DiscoveryError::EndpointCommandFailed(probe_timeout_msg("ipc-endpoint")),
+        ProbeError::Io(msg) => DiscoveryError::EndpointCommandFailed(msg),
+    })?;
     if !out.status.success() {
         return Err(DiscoveryError::EndpointCommandFailed(format!(
             "exit {}: {}",
@@ -200,16 +238,10 @@ pub async fn discover_default_channel() -> Result<uuid::Uuid, DiscoveryError> {
             ))
         });
     }
-    let call = TokioCommand::new("airc").arg("room").output();
-    let out = timeout(DISCOVERY_SUBPROCESS_DEADLINE, call)
-        .await
-        .map_err(|_| {
-            DiscoveryError::RoomCommandFailed(format!(
-                "`airc room` did not exit within {DISCOVERY_SUBPROCESS_DEADLINE:?} \
-                 — substrate is unresponsive, refusing to wait",
-            ))
-        })?
-        .map_err(|e| DiscoveryError::RoomCommandFailed(e.to_string()))?;
+    let out = probe_airc("room").await.map_err(|e| match e {
+        ProbeError::TimedOut => DiscoveryError::RoomCommandFailed(probe_timeout_msg("room")),
+        ProbeError::Io(msg) => DiscoveryError::RoomCommandFailed(msg),
+    })?;
     if !out.status.success() {
         return Err(DiscoveryError::RoomCommandFailed(format!(
             "exit {}: {}",
@@ -241,16 +273,10 @@ pub async fn discover_default_room_name() -> Result<String, DiscoveryError> {
             return Ok(raw);
         }
     }
-    let call = TokioCommand::new("airc").arg("room").output();
-    let out = timeout(DISCOVERY_SUBPROCESS_DEADLINE, call)
-        .await
-        .map_err(|_| {
-            DiscoveryError::RoomCommandFailed(format!(
-                "`airc room` did not exit within {DISCOVERY_SUBPROCESS_DEADLINE:?} \
-                 — substrate is unresponsive, refusing to wait",
-            ))
-        })?
-        .map_err(|e| DiscoveryError::RoomCommandFailed(e.to_string()))?;
+    let out = probe_airc("room").await.map_err(|e| match e {
+        ProbeError::TimedOut => DiscoveryError::RoomCommandFailed(probe_timeout_msg("room")),
+        ProbeError::Io(msg) => DiscoveryError::RoomCommandFailed(msg),
+    })?;
     if !out.status.success() {
         return Err(DiscoveryError::RoomCommandFailed(format!(
             "exit {}: {}",

core/continuum-core/src/airc/inbound_attach.rs

@@ -212,6 +212,31 @@ pub async fn publish_transcript_event(
                 "first capacity offer heard from a grid peer",
             );
         }
+    } else if let Some(beacon) = residency_beacon_from_envelope(&envelope) {
+        // Residency beacon (grid-overflow eligibility): fold the heard beacon into the
+        // process-global residency ledger, keyed on the WIRE's peer id — the orthogonal
+        // sibling of the capacity fold above. Our own echo lands here too (the loopback
+        // proof that publish→hear works before a second node exists).
+        let now_ms = std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map(|d| d.as_millis() as u64)
+            .unwrap_or(0);
+        let model_count = beacon.resident_models.len();
+        let is_new = crate::capacity::model_residency::global_residency_ledger().hear(
+            event.peer_id.as_uuid(),
+            beacon,
+            now_ms,
+        );
+        if is_new {
+            crate::probe!(
+                class = "grid.residency.heard",
+                from_peer = %event.peer_id.as_uuid(),
+                model_count = model_count,
+                heard_peers =
+                    crate::capacity::model_residency::global_residency_ledger().heard_count(),
+                "first residency beacon heard from a grid peer",
+            );
+        }
     } else if let Some((name, payload)) = chat_posted_from_envelope(&envelope, event) {
         crate::probe!(
             class = "airc.chat.projected",
@@ -284,6 +309,22 @@ fn capacity_offer_from_envelope(
     serde_json::from_value(payload.inline.clone()?).ok()
 }
 
+/// Decode a `grid_residency` envelope's inline payload into a [`ResidencyBeacon`].
+/// Returns `None` for any other envelope — the residency sibling of
+/// [`capacity_offer_from_envelope`], same honest schema gate.
+fn residency_beacon_from_envelope(
+    envelope: &AircRealtimeEnvelope,
+) -> Option<crate::capacity::model_residency::ResidencyBeacon> {
+    let crate::airc::realtime::AircRealtimePayload::ExistingSchema { payload } = &envelope.payload
+    else {
+        return None;
+    };
+    if payload.schema != crate::airc::realtime::AircRealtimeSchema::GridResidency {
+        return None;
+    }
+    serde_json::from_value(payload.inline.clone()?).ok()
+}
+
 /// Project a plain airc chat message into the THIN `chat:posted` bus
 /// payload the positron chat projection consumes (`AircChatPosted` in
 /// `ipc/positron_source.rs`). Returns `None` for any non-message event

core/continuum-core/src/airc/realtime.rs

@@ -53,6 +53,13 @@ pub enum AircRealtimeSchema {
     /// presence-of-compute. EphemeralCoalesced: latest wins, never replayed
     /// (a stale capacity reading is a lie).
     GridCapacity,
+    /// A node's residency beacon (`capacity::model_residency::ResidencyBeacon`) —
+    /// which models it holds resident, the grid-overflow ELIGIBILITY signal (a peer
+    /// is only a fast overflow target for a model it already holds). Orthogonal to
+    /// GridCapacity (concurrency): the governor composes the two. EphemeralCoalesced
+    /// like capacity, but published on a slower cadence — residency changes on model
+    /// page-in/out (minute-scale), not the 10s capacity beat.
+    GridResidency,
 }
 
 /// Handle to a payload already defined by a Continuum schema.
@@ -458,7 +465,9 @@ impl AircRealtimePayload {
                 | AircRealtimeSchema::LiveKitBridgeEvent => AircRealtimeDelivery::Control,
                 // Capacity offers are presence-of-compute: latest wins, never
                 // replayed — a stale reading must not outlive its freshness.
-                AircRealtimeSchema::GridCapacity => AircRealtimeDelivery::EphemeralCoalesced,
+                AircRealtimeSchema::GridCapacity | AircRealtimeSchema::GridResidency => {
+                    AircRealtimeDelivery::EphemeralCoalesced
+                }
                 _ => AircRealtimeDelivery::Durable,
             },
             Self::Presence { event } => event.delivery(),