node registration fixes

packages/node/meshnet_node/startup.py

@@ -12,7 +12,7 @@ import urllib.error
 import urllib.parse
 import urllib.request
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from .admission import (
     AdmissionRequirement,
@@ -419,6 +419,7 @@ def _start_heartbeat(
     interval: float = _HEARTBEAT_INTERVAL_IDLE,
     node_ref: Any | None = None,
     start_time: float | None = None,
+    refresh_capability: Callable[[dict], dict | None] | None = None,
 ) -> threading.Thread:
     """Daemon thread: sends heartbeats and re-registers automatically after tracker restarts.
 
@@ -461,9 +462,26 @@ def _start_heartbeat(
             return _HEARTBEAT_INTERVAL_BUSY
         return interval
 
+    def _refresh_proof(payload: dict) -> None:
+        """Re-prove the current shard so a re-registration never presents an aged proof.
+
+        The tracker refuses proofs older than its freshness budget: re-sending the
+        startup-time report after an outage would re-register the node unroutable.
+        """
+        if refresh_capability is None or "capability_report" not in payload:
+            return
+        try:
+            fresh = refresh_capability(payload)
+        except Exception as exc:
+            print(f"  [node] WARNING: capability re-validation failed: {exc}", flush=True)
+            return
+        if fresh:
+            payload["capability_report"] = fresh
+
     def _reregister() -> bool:
         nonlocal node_id
         try:
+            _refresh_proof(register_payload)
             resp = _post_json(f"{tracker_url}/v1/nodes/register", register_payload)
             node_id = resp.get("node_id", node_id)
             if node_ref is not None:
@@ -485,6 +503,7 @@ def _start_heartbeat(
             "managed_assignment": True,
         }
         try:
+            _refresh_proof(extra_payload)
             reg_resp = _post_json(f"{tracker_url}/v1/nodes/register", extra_payload)
             print(
                 f"  [node] registered additional model — node ID: {reg_resp.get('node_id')}",
@@ -579,6 +598,7 @@ def _register_with_tracker(
     reg_payload: dict,
     node: Any,
     start_time: float,
+    refresh_capability: Callable[[dict], dict | None] | None = None,
 ) -> str | None:
     """Register with the tracker, or start background retries when it is unreachable."""
     try:
@@ -586,7 +606,14 @@ def _register_with_tracker(
         tracker_node_id = str(reg_resp.get("node_id") or "?")
         setattr(node, "tracker_node_id", tracker_node_id)
         print(f"  Registered with tracker — node ID: {tracker_node_id}", flush=True)
-        _start_heartbeat(tracker_url, tracker_node_id, reg_payload, node_ref=node, start_time=start_time)
+        _start_heartbeat(
+            tracker_url,
+            tracker_node_id,
+            reg_payload,
+            node_ref=node,
+            start_time=start_time,
+            refresh_capability=refresh_capability,
+        )
         return tracker_node_id
     except Exception as exc:
         setattr(node, "tracker_node_id", None)
@@ -598,6 +625,7 @@ def _register_with_tracker(
             reg_payload,
             node_ref=node,
             start_time=start_time,
+            refresh_capability=refresh_capability,
         )
         return None
 
@@ -718,6 +746,54 @@ def _admit_capability(
     return report
 
 
+def _capability_refresher(
+    node: Any,
+    *,
+    manifest: RecipeManifest,
+    recipe: Recipe,
+    detected_device: str,
+    cache_dir: Path | None,
+    force_cpu: bool,
+    validator: CapabilityValidator | None = None,
+) -> Callable[[dict], dict | None]:
+    """A fresh proof for what the node serves *now*, run at re-registration time.
+
+    The startup proof ages past the tracker's freshness budget, and directives
+    can move the node to a shard the startup proof never covered — so every
+    re-registration re-proves against the currently loaded backend rather than
+    replaying the report captured at boot.
+    """
+    def refresh(payload: dict) -> dict | None:
+        target_model = payload.get("hf_repo") or payload.get("model")
+        backend = None
+        accessor = getattr(node, "backend_for", None)
+        if callable(accessor) and target_model:
+            backend = accessor(str(target_model))
+        if backend is None:
+            backend = getattr(node, "backend", None)
+        if backend is None:
+            return None
+        context = CapabilityContext(
+            backend=backend,
+            selection=DoctorSelection(
+                model_id=str(getattr(backend, "model_id", target_model)),
+                shard_start=int(getattr(backend, "shard_start", 0) or 0),
+                shard_end=int(getattr(backend, "shard_end", 0) or 0),
+                quantization=str(getattr(backend, "quantization", None) or "auto"),
+                cache_dir=cache_dir,
+                force_cpu=force_cpu,
+            ),
+            recipe=recipe,
+            manifest=manifest,
+            device=_capability_device(backend, detected_device),
+        )
+        report = (validator or probe_capability)(context)
+        setattr(node, "capability_report", report)
+        return report.to_dict()
+
+    return refresh
+
+
 def run_startup(
     tracker_url: str,
     port: int = 0,
@@ -1026,6 +1102,15 @@ def run_startup(
         }
         tracker_node_id = _register_with_tracker(
             tracker_url, reg_payload, node, _node_start_time,
+            refresh_capability=_capability_refresher(
+                node,
+                manifest=manifest,
+                recipe=recipe,
+                detected_device=device,
+                cache_dir=cache_dir,
+                force_cpu=force_cpu,
+                validator=capability_validator,
+            ),
         )
 
         print(
@@ -1197,6 +1282,15 @@ def run_startup(
         }
         tracker_node_id = _register_with_tracker(
             tracker_url, auto_reg_payload, node, _node_start_time,
+            refresh_capability=_capability_refresher(
+                node,
+                manifest=manifest,
+                recipe=recipe,
+                detected_device=device,
+                cache_dir=cache_dir,
+                force_cpu=force_cpu,
+                validator=capability_validator,
+            ),
         )
         shard_label = _format_shard_label(
             assigned_shard_start,
@@ -1389,6 +1483,15 @@ def run_startup(
         }
         tracker_node_id = _register_with_tracker(
             tracker_url, reg_payload, node, _node_start_time,
+            refresh_capability=_capability_refresher(
+                node,
+                manifest=manifest,
+                recipe=recipe,
+                detected_device=device,
+                cache_dir=cache_dir,
+                force_cpu=force_cpu,
+                validator=capability_validator,
+            ),
         )
         print(
             f"\n{'=' * 32}\n"
@@ -1474,7 +1577,22 @@ def run_startup(
         )
         node_id = str(reg_resp["node_id"])
         setattr(node, "tracker_node_id", node_id)
-        _start_heartbeat(tracker_url, node_id, reg_payload, node_ref=node, start_time=_node_start_time)
+        _start_heartbeat(
+            tracker_url,
+            node_id,
+            reg_payload,
+            node_ref=node,
+            start_time=_node_start_time,
+            refresh_capability=_capability_refresher(
+                node,
+                manifest=manifest,
+                recipe=recipe,
+                detected_device=device,
+                cache_dir=shard_path,
+                force_cpu=force_cpu,
+                validator=capability_validator,
+            ),
+        )
     except Exception:
         node.stop()
         raise

packages/node/meshnet_node/torch_server.py

@@ -1543,6 +1543,17 @@ class TorchNodeServer:
     def loaded_model_ids(self) -> list[str]:
         return list(self._backends.keys())
 
+    def backend_for(self, model_id: str) -> TorchModelShard | None:
+        """The loaded backend serving `model_id` — full repo id or short name."""
+        backend = self._backends.get(model_id)
+        if backend is not None:
+            return backend
+        short = model_id.split("/")[-1].lower()
+        for key, candidate in self._backends.items():
+            if key.split("/")[-1].lower() == short:
+                return candidate
+        return None
+
     def apply_tracker_directives(self, directives: list[dict]) -> dict | None:
         """Apply tracker shard directives (LOAD_SHARD replace, ADD_SHARD load-more)."""
         drop_directive = next(

packages/tracker/meshnet_tracker/server.py

@@ -1101,12 +1101,15 @@ def _registration_quantization(body: dict, quantizations: list[str]) -> str | No
 
     An absent field predates the protocol adding it: it means "unknown", not
     "unsupported", so the node keeps the best precision it advertises and stays
-    routable. Anything the node states explicitly is taken at its word -- a null,
-    a non-string, or an unsupported name leaves it with no usable precision and
-    routing excludes it.
+    routable. An explicit "auto" means the same thing — the node's CLI default
+    delegates the choice, it does not refuse one. Anything else the node states
+    explicitly is taken at its word -- a null, a non-string, or an unsupported
+    name leaves it with no usable precision and routing excludes it.
     """
-    if "quantization" in body:
-        return _normalize_quantization(body["quantization"])
+    declared = body.get("quantization")
+    declared_auto = isinstance(declared, str) and declared.strip().lower() == "auto"
+    if "quantization" in body and not declared_auto:
+        return _normalize_quantization(declared)
     supported = [
         normalized for value in quantizations
         if (normalized := _normalize_quantization(value)) is not None