models on tracker

packages/node/meshnet_node/cli.py

@@ -106,6 +106,11 @@ def _resolve_model_flags(
     explicit = model_id or model
     if not explicit:
         return None, None
+    from .model_catalog import resolve_model_alias
+
+    preset = resolve_model_alias(explicit)
+    if preset is not None:
+        return preset.name, preset.hf_repo
     if "/" in explicit:
         return explicit.split("/")[-1], explicit
     return explicit, None

packages/node/meshnet_node/model_catalog.py

@@ -19,6 +19,7 @@ class ModelPreset:
     vram_bf16: float
     description: str
     metadata: dict | None = None
+    aliases: tuple[str, ...] = ()
 
     def vram_for_quant(self, quant: str) -> float:
         """Return VRAM requirement in GB for the given quantization."""
@@ -167,9 +168,29 @@ CURATED_MODELS: list[ModelPreset] = [
         description="Large coding-focused MoE model",
         metadata=_MODEL_METADATA.get("unsloth/Kimi-K2.7-Code"),
     ),
+    ModelPreset(
+        name="Qwen3.6-27B",
+        hf_repo="Qwen/Qwen3.6-27B",
+        num_layers=64,
+        vram_nf4=13.0,
+        vram_int8=26.0,
+        vram_bf16=52.0,
+        description="Qwen 27B hybrid linear-attention model",
+        aliases=("qwen3.6-27b",),
+    ),
 ]
 
 
+def resolve_model_alias(value: str) -> ModelPreset | None:
+    """Resolve a curated name, repository, or alias case-insensitively."""
+    normalized = value.strip().casefold()
+    for model in CURATED_MODELS:
+        candidates = (model.name, model.hf_repo, *model.aliases)
+        if normalized in {candidate.casefold() for candidate in candidates}:
+            return model
+    return None
+
+
 def layers_from_config(cfg) -> int | None:
     """Extract the transformer layer count from a HuggingFace config object.
 

packages/node/meshnet_node/startup.py

@@ -631,6 +631,21 @@ def _registration_display_fields(node_name: str | None) -> dict[str, str]:
     return {"friendly_name": name}
 
 
+def _tracker_http_error_message(exc: urllib.error.HTTPError) -> str:
+    """Describe an HTTP rejection from the tracker, including its JSON error."""
+    detail = exc.reason or "request rejected"
+    try:
+        payload = json.loads(exc.read().decode("utf-8", errors="replace"))
+        error = payload.get("error") if isinstance(payload, dict) else None
+        if isinstance(error, dict):
+            detail = error.get("message") or error.get("code") or detail
+        elif error:
+            detail = error
+    except Exception:
+        pass
+    return f"Tracker rejected shard assignment (HTTP {exc.code}): {detail}"
+
+
 def run_startup(
     tracker_url: str,
     port: int = 0,
@@ -1108,6 +1123,8 @@ def run_startup(
     })
     try:
         assignment = _get_json(f"{tracker_url}/v1/nodes/assign?{assign_qs}")
+    except urllib.error.HTTPError as exc:
+        raise RuntimeError(_tracker_http_error_message(exc)) from exc
     except urllib.error.URLError as exc:
         print(f"  ERROR: Cannot reach tracker at {tracker_url}: {exc}", file=sys.stderr, flush=True)
         raise

packages/tracker/meshnet_tracker/server.py

@@ -33,6 +33,7 @@ import random
 import select
 import socketserver
 import sqlite3
+import sys
 import tarfile
 import threading
 import time
@@ -6738,19 +6739,32 @@ class TrackerServer:
                 delivered_all = False
         return delivered_all
 
+    def _save_stats_once(self) -> None:
+        """Persist each store independently so one DB failure cannot kill the loop."""
+        registry_log = getattr(self._contracts, "registry_log", None)
+        stores = (
+            ("request stats", self._stats),
+            ("route stats", self._route_stats),
+            ("billing", self._billing),
+            ("accounts", self._accounts),
+            ("registry", registry_log),
+        )
+        for label, store in stores:
+            if store is None:
+                continue
+            try:
+                store.save_to_db()
+            except Exception as exc:
+                print(
+                    f"[tracker] warn: {label} persistence failed: {exc}",
+                    file=sys.stderr,
+                    flush=True,
+                )
+
     def _stats_loop(self) -> None:
         """Periodically save stats/billing to DB and push local slices to cluster peers."""
         while not self._stats_stop.wait(_StatsCollector.SAVE_INTERVAL):
-            if self._stats is not None:
-                self._stats.save_to_db()
-            self._route_stats.save_to_db()
-            if self._billing is not None:
-                self._billing.save_to_db()
-            if self._accounts is not None:
-                self._accounts.save_to_db()
-            registry_log = getattr(self._contracts, "registry_log", None)
-            if registry_log is not None:
-                registry_log.save_to_db()
+            self._save_stats_once()
             if self._cluster_peers and not self._hive_secret:
                 print(
                     "[tracker] WARNING: cluster peers configured without --hive-secret — "