diff --git a/packages/tracker/meshnet_tracker/dashboard.html b/packages/tracker/meshnet_tracker/dashboard.html
index f9793d7..e50dbd0 100644
--- a/packages/tracker/meshnet_tracker/dashboard.html
+++ b/packages/tracker/meshnet_tracker/dashboard.html
@@ -41,21 +41,21 @@
   .error-msg { color:var(--bad); font-size:12px; min-height:16px; }
   .keybox { word-break:break-all; background:var(--bg); border:1px solid var(--border);
           border-radius:6px; padding:4px 8px; margin:4px 0; font-size:11px; }
-  .tabs { display:flex; gap:10px; margin-bottom:8px; }
-  .tabs a { color:var(--dim); cursor:pointer; }
-  .tabs a.active { color:var(--accent); border-bottom:1px solid var(--accent); }
-  .wide { grid-column:1 / -1; }
-  .console {
-    background:var(--bg); border:1px solid var(--border); border-radius:6px;
-    min-height:160px; max-height:280px; overflow:auto; padding:7px 9px;
-    white-space:pre-wrap; word-break:break-word; font-size:11px;
-  }
-  .console-line { padding:1px 0; border-bottom:1px solid #161b22; }
-  .console-time { color:var(--dim); }
-  .console-level-info { color:var(--accent); }
-  .console-level-warn { color:var(--warn); }
-  .console-level-error { color:var(--bad); }
-</style>
+  .tabs { display:flex; gap:10px; margin-bottom:8px; }
+  .tabs a { color:var(--dim); cursor:pointer; }
+  .tabs a.active { color:var(--accent); border-bottom:1px solid var(--accent); }
+  .wide { grid-column:1 / -1; }
+  .console {
+    background:var(--bg); border:1px solid var(--border); border-radius:6px;
+    min-height:160px; max-height:280px; overflow:auto; padding:7px 9px;
+    white-space:pre-wrap; word-break:break-word; font-size:11px;
+  }
+  .console-line { padding:1px 0; border-bottom:1px solid #161b22; }
+  .console-time { color:var(--dim); }
+  .console-level-info { color:var(--accent); }
+  .console-level-warn { color:var(--warn); }
+  .console-level-error { color:var(--bad); }
+</style>
 </head>
 <body>
 <header>
@@ -72,11 +72,11 @@
   <section><h2>Node pending payouts</h2><div id="pending" class="empty">loading…</div></section>
   <section><h2>Settlement history</h2><div id="settlements" class="empty">loading…</div></section>
   <section><h2>Strikes / bans / forfeitures</h2><div id="fraud" class="empty">loading…</div></section>
-  <section><h2>Model usage (RPM)</h2><div id="stats" class="empty">loading…</div></section>
-  <section><h2>Node throughput</h2><div id="throughput" class="empty">loading…</div></section>
-  <section class="wide"><h2>Console output</h2><div id="console" class="console empty">loading…</div></section>
-  <section class="wide"><h2>Inference history</h2><div id="inference-history" class="empty">loading...</div></section>
-</main>
+  <section><h2>Model usage (RPM)</h2><div id="stats" class="empty">loading…</div></section>
+  <section><h2>Node throughput</h2><div id="throughput" class="empty">loading…</div></section>
+  <section class="wide"><h2>Console output</h2><div id="console" class="console empty">loading…</div></section>
+  <section class="wide"><h2>Inference history</h2><div id="inference-history" class="empty">loading...</div></section>
+</main>
 <script>
 "use strict";
 const $ = id => document.getElementById(id);
@@ -84,6 +84,7 @@ const esc = s => String(s).replace(/[&<>"]/g,
   c => ({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;"}[c]));
 const usdt = v => (Math.round(v * 1e6) / 1e6).toFixed(6);
 const tps = v => (v === null || v === undefined) ? "?" : (Math.round(v * 10) / 10).toFixed(1);
+const copies = v => (v === null || v === undefined) ? "?" : Number(v).toFixed(2);
 const short = (s, n=14) => { s = String(s); return s.length > n ? s.slice(0, 6) + "…" + s.slice(-5) : s; };
 
 async function fetchJson(path) {
@@ -129,16 +130,17 @@ function renderNodes(map) {
   }
   let html = "";
   for (const [model, group] of Object.entries(byModel)) {
-    html += `<div><b>${esc(model)}</b> <span class="dim">(${group.length} node${group.length===1?"":"s"})</span></div>`;
-    html += table(["node", "shard", "tps (1h)", "queue", "health"], group.map(n => {
+    const supply = group.find(n => n.model_supply && n.model_supply.served_model_copies !== undefined);
+    const served = supply && supply.model_supply && supply.model_supply.served_model_copies;
+    html += `<div><b>${esc(model)}</b> <span class="dim">(${group.length} node${group.length===1?"":"s"} · ${esc(copies(served))} served)</span></div>`;
+    html += table(["node", "shard", "tps (1h)", "queue", "served"], group.map(n => {
       const modelStats = (n.throughput && (n.throughput[n.hf_repo] || n.throughput[n.model])) || {};
       return [
       esc(short(n.node_id || "?")),
       esc(`${n.shard_start ?? "?"}-${n.shard_end ?? "?"}`),
       `<span class="num">${esc(tps(modelStats.tokens_per_sec_last_hour))}</span>`,
       esc(String((n.stats && n.stats.queue_depth) ?? 0)),
-      (n.stats && (n.stats.alive === false || n.stats.healthy === false))
-        ? '<span class="bad">down</span>' : '<span class="ok">up</span>',
+      `<span class="num">${esc(copies(n.model_supply && n.model_supply.served_model_copies))}</span>`,
     ]; }));
   }
   $("nodes").innerHTML = html;
@@ -209,10 +211,10 @@ function renderStats(stats) {
   $("stats").innerHTML = table(["model", "rpm (1h)", "rpm (24h)", "rpm (30d)"], rows);
 }
 
-function renderThroughput(stats) {
-  const nodes = (stats && stats.nodes) || {};
-  const rows = [];
-  for (const [nodeId, nodeStats] of Object.entries(nodes)) {
+function renderThroughput(stats) {
+  const nodes = (stats && stats.nodes) || {};
+  const rows = [];
+  for (const [nodeId, nodeStats] of Object.entries(nodes)) {
     for (const [model, s] of Object.entries((nodeStats && nodeStats.models) || {})) {
       rows.push([
         esc(short(nodeId)),
@@ -221,66 +223,66 @@ function renderThroughput(stats) {
         `<span class="num">${esc(String(s.sample_count_last_hour ?? 0))}</span>`,
       ]);
     }
-  }
-  $("throughput").innerHTML = table(["node", "model", "tps (1h)", "samples"], rows);
-}
-
-function renderInferenceHistory(data) {
-  const events = (data && data.events) || [];
-  const started = new Map();
-  const completed = [];
-  for (const e of events) {
-    const f = e.fields || {};
-    const id = f.request_id;
-    if (!id) continue;
-    if (e.message === "proxy route selected") {
-      started.set(id, e);
-    } else if (e.message === "proxy complete" || e.message === "proxy failed" || e.message === "direct proxy failed after relay") {
-      completed.push(e);
-      started.delete(id);
-    }
-  }
-  const activeByModel = {};
-  for (const e of started.values()) {
-    const f = e.fields || {};
-    const model = f.model || f.route_model || "?";
-    activeByModel[model] = (activeByModel[model] || 0) + 1;
-  }
-  const active = Object.entries(activeByModel)
-    .map(([model, count]) => `${esc(model)}: <span class="num">${count}</span> active`)
-    .join(" &middot; ");
-  const rows = completed.slice(-20).reverse().map(e => {
-    const f = e.fields || {};
-    return [
-      new Date((e.ts || 0) * 1000).toLocaleTimeString(),
-      esc(short(f.model || f.route_model || "?", 28)),
-      esc(short(f.request_id || "?", 18)),
-      `<span class="num">${esc(tps(f.tokens_per_sec))}</span>`,
-      `<span class="num">${esc(String(f.tokens ?? "?"))}</span>`,
-      `<span class="num">${esc(String(f.elapsed_seconds ?? "?"))}</span>`,
-      f.stream ? "stream" : "json",
-    ];
-  });
-  $("inference-history").innerHTML =
-    `<div class="dim" style="margin-bottom:6px">${active || "no active requests"}</div>` +
-    (rows.length ? table(["time", "model", "request", "tps", "tokens", "sec", "mode"], rows)
-                 : '<div class="empty">no completed inference requests</div>');
-}
-
-function renderConsole(data) {
-  const events = (data && data.events) || [];
-  if (!events.length) {
-    $("console").innerHTML = '<div class="empty">no console events</div>';
-    return;
-  }
-  $("console").innerHTML = events.slice(-120).map(e => {
-    const level = String(e.level || "info");
-    const cls = level === "error" ? "console-level-error" : level === "warn" ? "console-level-warn" : "console-level-info";
-    const fields = e.fields && Object.keys(e.fields).length ? " " + JSON.stringify(e.fields) : "";
-    return `<div class="console-line"><span class="console-time">${new Date((e.ts || 0) * 1000).toLocaleTimeString()}</span> ` +
-      `<span class="${cls}">${esc(level.toUpperCase())}</span> ${esc(e.message || "")}${esc(fields)}</div>`;
-  }).join("");
-}
+  }
+  $("throughput").innerHTML = table(["node", "model", "tps (1h)", "samples"], rows);
+}
+
+function renderInferenceHistory(data) {
+  const events = (data && data.events) || [];
+  const started = new Map();
+  const completed = [];
+  for (const e of events) {
+    const f = e.fields || {};
+    const id = f.request_id;
+    if (!id) continue;
+    if (e.message === "proxy route selected") {
+      started.set(id, e);
+    } else if (e.message === "proxy complete" || e.message === "proxy failed" || e.message === "direct proxy failed after relay") {
+      completed.push(e);
+      started.delete(id);
+    }
+  }
+  const activeByModel = {};
+  for (const e of started.values()) {
+    const f = e.fields || {};
+    const model = f.model || f.route_model || "?";
+    activeByModel[model] = (activeByModel[model] || 0) + 1;
+  }
+  const active = Object.entries(activeByModel)
+    .map(([model, count]) => `${esc(model)}: <span class="num">${count}</span> active`)
+    .join(" &middot; ");
+  const rows = completed.slice(-20).reverse().map(e => {
+    const f = e.fields || {};
+    return [
+      new Date((e.ts || 0) * 1000).toLocaleTimeString(),
+      esc(short(f.model || f.route_model || "?", 28)),
+      esc(short(f.request_id || "?", 18)),
+      `<span class="num">${esc(tps(f.tokens_per_sec))}</span>`,
+      `<span class="num">${esc(String(f.tokens ?? "?"))}</span>`,
+      `<span class="num">${esc(String(f.elapsed_seconds ?? "?"))}</span>`,
+      f.stream ? "stream" : "json",
+    ];
+  });
+  $("inference-history").innerHTML =
+    `<div class="dim" style="margin-bottom:6px">${active || "no active requests"}</div>` +
+    (rows.length ? table(["time", "model", "request", "tps", "tokens", "sec", "mode"], rows)
+                 : '<div class="empty">no completed inference requests</div>');
+}
+
+function renderConsole(data) {
+  const events = (data && data.events) || [];
+  if (!events.length) {
+    $("console").innerHTML = '<div class="empty">no console events</div>';
+    return;
+  }
+  $("console").innerHTML = events.slice(-120).map(e => {
+    const level = String(e.level || "info");
+    const cls = level === "error" ? "console-level-error" : level === "warn" ? "console-level-warn" : "console-level-info";
+    const fields = e.fields && Object.keys(e.fields).length ? " " + JSON.stringify(e.fields) : "";
+    return `<div class="console-line"><span class="console-time">${new Date((e.ts || 0) * 1000).toLocaleTimeString()}</span> ` +
+      `<span class="${cls}">${esc(level.toUpperCase())}</span> ${esc(e.message || "")}${esc(fields)}</div>`;
+  }).join("");
+}
 
 // ---- account panel (registration / login / balance / usage / API keys) ----
 
@@ -436,24 +438,24 @@ async function renderAdminPanel() {
 
 async function refresh() {
   $("self-url").textContent = location.host;
-  const [raft, map, summary, settlements, wallets, stats, consoleData] = await Promise.all([
-    fetchJson("/v1/raft/status"),
-    fetchJson("/v1/network/map"),
-    fetchJson("/v1/billing/summary"),
-    fetchJson("/v1/billing/settlements"),
-    fetchJson("/v1/registry/wallets"),
-    fetchJson("/v1/stats"),
-    fetchJson("/v1/console"),
-  ]);
+  const [raft, map, summary, settlements, wallets, stats, consoleData] = await Promise.all([
+    fetchJson("/v1/raft/status"),
+    fetchJson("/v1/network/map"),
+    fetchJson("/v1/billing/summary"),
+    fetchJson("/v1/billing/settlements"),
+    fetchJson("/v1/registry/wallets"),
+    fetchJson("/v1/stats"),
+    fetchJson("/v1/console"),
+  ]);
   renderHive(raft);
   renderNodes(map);
   renderBilling(summary);
   renderSettlements(settlements);
-  renderFraud(wallets, summary);
-  renderStats(stats);
-  renderThroughput(stats);
-  renderInferenceHistory(consoleData);
-  renderConsole(consoleData);
+  renderFraud(wallets, summary);
+  renderStats(stats);
+  renderThroughput(stats);
+  renderInferenceHistory(consoleData);
+  renderConsole(consoleData);
   $("refreshed").textContent = "refreshed " + new Date().toLocaleTimeString();
 }
 refresh();
diff --git a/packages/tracker/meshnet_tracker/server.py b/packages/tracker/meshnet_tracker/server.py
index 8f8e28d..d5863dd 100644
--- a/packages/tracker/meshnet_tracker/server.py
+++ b/packages/tracker/meshnet_tracker/server.py
@@ -32,10 +32,10 @@ import tarfile
 import threading
 import time
 import urllib.parse
-import urllib.request
-import uuid
-from collections import deque
-from importlib.resources import files
+import urllib.request
+import uuid
+from collections import deque
+from importlib.resources import files
 from pathlib import Path
 from typing import Any
 
@@ -47,10 +47,10 @@ from .calibration import DEFAULT_CALIBRATION_DB_PATH, ToplocCalibrationStore
 from .hf_pricing import DEFAULT_HF_PRICING_LOG_DB_PATH, HfPricingLog, refresh_preset_price
 from .gossip import NodeGossip
 from .model_files import files_for_layer_range, snapshot_dir_for_repo
-from .raft import RaftNode
-
-
-_CONSOLE_LIMIT = 300
+from .raft import RaftNode
+
+
+_CONSOLE_LIMIT = 300
 
 
 def _preset_price_keys(name: str, preset: dict) -> set[str]:
@@ -533,7 +533,7 @@ class _StatsCollector:
 class _NodeEntry:
     __slots__ = (
         "node_id", "endpoint", "shard_start", "shard_end",
-        "model", "hf_repo", "num_layers", "model_metadata", "shard_checksum", "downloaded_models", "hardware_profile", "wallet_address",
+        "model", "hf_repo", "num_layers", "model_metadata", "shard_checksum", "downloaded_models", "hardware_profile", "wallet_address",
         "score", "vram_bytes", "ram_bytes", "quantizations", "max_loaded_shards",
         "benchmark_tokens_per_sec", "quantization", "managed_assignment",
         "model_tokens_per_sec",
@@ -566,11 +566,11 @@ class _NodeEntry:
         quantization: str | None = None,
         managed_assignment: bool = False,
         tracker_mode: bool = False,
-        hf_repo: str | None = None,
-        num_layers: int | None = None,
-        model_metadata: dict | None = None,
-        downloaded_models: list[dict] | None = None,
-        relay_addr: str | None = None,
+        hf_repo: str | None = None,
+        num_layers: int | None = None,
+        model_metadata: dict | None = None,
+        downloaded_models: list[dict] | None = None,
+        relay_addr: str | None = None,
         cert_fingerprint: str | None = None,
         peer_id: str | None = None,
     ) -> None:
@@ -593,10 +593,10 @@ class _NodeEntry:
         self.model_tokens_per_sec: dict[str, float] = {}
         self.tracker_mode = tracker_mode
         self.hf_repo = hf_repo
-        self.num_layers = num_layers
-        self.model_metadata = dict(model_metadata or {})
-        self.downloaded_models = [dict(item) for item in (downloaded_models or []) if isinstance(item, dict)]
-        self.relay_addr = relay_addr
+        self.num_layers = num_layers
+        self.model_metadata = dict(model_metadata or {})
+        self.downloaded_models = [dict(item) for item in (downloaded_models or []) if isinstance(item, dict)]
+        self.relay_addr = relay_addr
         self.cert_fingerprint = cert_fingerprint
         self.peer_id = peer_id
         self.pending_directives: list[dict] = []
@@ -636,7 +636,7 @@ def _reputation_multiplier(node: "_NodeEntry", contracts: Any | None) -> float:
     return 0.5 + 0.5 * reputation
 
 
-def _select_route(
+def _select_route(
     nodes: list[_NodeEntry],
     required_start: int,
     required_end: int,
@@ -678,25 +678,25 @@ def _select_route(
         covered_up_to = best.shard_end
         candidates = [n for n in candidates if n is not best]
 
-    return route, ""
-
-
-def _node_route_summary(nodes: list["_NodeEntry"]) -> list[dict]:
-    return [
-        {
-            "node_id": node.node_id,
-            "model": node.model,
-            "hf_repo": node.hf_repo,
-            "endpoint": node.endpoint,
-            "shard": f"{node.shard_start}-{node.shard_end}",
-            "num_layers": node.num_layers,
-            "queue_depth": node.queue_depth,
-        }
-        for node in nodes
-    ]
-
-
-def _coverage_percentage(
+    return route, ""
+
+
+def _node_route_summary(nodes: list["_NodeEntry"]) -> list[dict]:
+    return [
+        {
+            "node_id": node.node_id,
+            "model": node.model,
+            "hf_repo": node.hf_repo,
+            "endpoint": node.endpoint,
+            "shard": f"{node.shard_start}-{node.shard_end}",
+            "num_layers": node.num_layers,
+            "queue_depth": node.queue_depth,
+        }
+        for node in nodes
+    ]
+
+
+def _coverage_percentage(
     nodes: list[_NodeEntry],
     required_start: int,
     required_end: int,
@@ -728,6 +728,33 @@ def _coverage_percentage(
     return round((covered / required_layers) * 100, 2)
 
 
+def _served_model_copies(
+    nodes: list[_NodeEntry],
+    required_start: int,
+    required_end: int,
+) -> float:
+    required_layers = required_end - required_start + 1
+    if required_layers <= 0:
+        return 0.0
+
+    layer_counts = []
+    for layer in range(required_start, required_end + 1):
+        count = 0
+        for node in nodes:
+            if node.shard_start is None or node.shard_end is None:
+                continue
+            if node.shard_start <= layer <= node.shard_end:
+                count += 1
+        layer_counts.append(count)
+
+    if not layer_counts:
+        return 0.0
+
+    complete_copies = min(layer_counts)
+    residual_layers = sum(1 for count in layer_counts if count > complete_copies)
+    return round(complete_copies + (residual_layers / required_layers), 2)
+
+
 def _preset_layer_bounds(preset: dict) -> tuple[int, int]:
     start = int(preset.get("layers_start", 0))
     if "layers_end" in preset:
@@ -761,14 +788,14 @@ def _node_memory_budget_bytes(node: _NodeEntry) -> tuple[int, str]:
     return DEFAULT_RAM_BYTES, "ram-default"
 
 
-def _node_layer_capacity(node: _NodeEntry, preset: dict) -> int:
-    bytes_per_layer = _preset_bytes_per_layer(preset)
-    quantization = _node_quantization(node, preset)
-    layer_bytes = bytes_per_layer[quantization]
-    if layer_bytes <= 0:
-        return 0
-    memory_budget_bytes, _ = _node_memory_budget_bytes(node)
-    return int((memory_budget_bytes * 0.8) // layer_bytes)
+def _node_layer_capacity(node: _NodeEntry, preset: dict) -> int:
+    bytes_per_layer = _preset_bytes_per_layer(preset)
+    quantization = _node_quantization(node, preset)
+    layer_bytes = bytes_per_layer[quantization]
+    if layer_bytes <= 0:
+        return 0
+    memory_budget_bytes, _ = _node_memory_budget_bytes(node)
+    return int((memory_budget_bytes * 0.8) // layer_bytes)
 
 
 def _node_capacity_summary(node: _NodeEntry, preset: dict | None = None) -> dict:
@@ -832,17 +859,17 @@ def _deployment_summary(nodes: list[_NodeEntry], preset: dict | None) -> dict:
     }
 
 
-def _max_layers_for_memory(memory_mb: int, total_layers: int, preset: dict | None = None) -> int:
-    if total_layers <= 0:
-        return 0
-    if memory_mb <= 0:
-        return max(1, total_layers // 2)
-    memory_bytes = memory_mb * 1024 * 1024
-    bytes_per_layer = next(iter(_preset_bytes_per_layer(preset).values())) if preset is not None else 30 * 1024 * 1024
-    return min(
-        total_layers,
-        max(1, int((memory_bytes * 0.8) // bytes_per_layer)),
-    )
+def _max_layers_for_memory(memory_mb: int, total_layers: int, preset: dict | None = None) -> int:
+    if total_layers <= 0:
+        return 0
+    if memory_mb <= 0:
+        return max(1, total_layers // 2)
+    memory_bytes = memory_mb * 1024 * 1024
+    bytes_per_layer = next(iter(_preset_bytes_per_layer(preset).values())) if preset is not None else 30 * 1024 * 1024
+    return min(
+        total_layers,
+        max(1, int((memory_bytes * 0.8) // bytes_per_layer)),
+    )
 
 
 def _model_metadata_from_nodes(nodes: list[_NodeEntry]) -> dict:
@@ -1267,18 +1294,18 @@ def _purge_expired_nodes_locked(server: "_TrackerHTTPServer") -> list[str]:
         node_id for node_id, entry in server.registry.items()
         if (now - entry.last_heartbeat) > server.heartbeat_timeout
     ]
-    for node_id in expired_ids:
-        entry = server.registry.pop(node_id)
-        _tracker_log(
-            server,
-            "warn",
-            "node expired",
-            node_id=node_id,
-            endpoint=entry.endpoint,
-            model=entry.model,
-            shard=f"{entry.shard_start}-{entry.shard_end}",
-            heartbeat_timeout_seconds=server.heartbeat_timeout,
-        )
+    for node_id in expired_ids:
+        entry = server.registry.pop(node_id)
+        _tracker_log(
+            server,
+            "warn",
+            "node expired",
+            node_id=node_id,
+            endpoint=entry.endpoint,
+            model=entry.model,
+            shard=f"{entry.shard_start}-{entry.shard_end}",
+            heartbeat_timeout_seconds=server.heartbeat_timeout,
+        )
     if expired_ids:
         _rebalance_all_locked(server)
     return expired_ids
@@ -1636,33 +1663,33 @@ def _billable_stream_tokens(observed_tokens: int, reported_tokens: int | None) -
     return min(observed, max(0, reported_tokens))
 
 
-def _registration_ban_error(contracts: Any | None, wallet_address: str | None) -> str | None:
+def _registration_ban_error(contracts: Any | None, wallet_address: str | None) -> str | None:
     if contracts is None or not wallet_address:
         return None
     if contracts.registry.get_wallet(wallet_address).banned:
         return "wallet is banned"
-    return None
-
-
-def _tracker_log(server: "_TrackerHTTPServer", level: str, message: str, **fields: Any) -> None:
-    event = {
-        "ts": time.time(),
-        "level": level,
-        "message": message,
-        "fields": {
-            key: value
-            for key, value in fields.items()
-            if value is not None
-        },
-    }
-    with server.console_lock:
-        server.console_events.append(event)
-    extras = " ".join(f"{key}={value}" for key, value in event["fields"].items())
-    suffix = f"  {extras}" if extras else ""
-    print(f"[tracker] {level}: {message}{suffix}", flush=True)
-
-
-def _node_id_for_registration(
+    return None
+
+
+def _tracker_log(server: "_TrackerHTTPServer", level: str, message: str, **fields: Any) -> None:
+    event = {
+        "ts": time.time(),
+        "level": level,
+        "message": message,
+        "fields": {
+            key: value
+            for key, value in fields.items()
+            if value is not None
+        },
+    }
+    with server.console_lock:
+        server.console_events.append(event)
+    extras = " ".join(f"{key}={value}" for key, value in event["fields"].items())
+    suffix = f"  {extras}" if extras else ""
+    print(f"[tracker] {level}: {message}{suffix}", flush=True)
+
+
+def _node_id_for_registration(
     endpoint: str,
     model: str,
     wallet_address: str | None,
@@ -1743,10 +1770,10 @@ class _TrackerHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
         )
         self.toploc_calibration_gate_min_hardware_profiles = toploc_calibration_gate_min_hardware_profiles
         self.toploc_backend = toploc_backend
-        self.hf_pricing_log: HfPricingLog | None = hf_pricing_log
-        self.models_dir = models_dir
-        self.console_events = deque(maxlen=_CONSOLE_LIMIT)
-        self.console_lock = threading.Lock()
+        self.hf_pricing_log: HfPricingLog | None = hf_pricing_log
+        self.models_dir = models_dir
+        self.console_events = deque(maxlen=_CONSOLE_LIMIT)
+        self.console_lock = threading.Lock()
 
 
 class _TrackerHandler(http.server.BaseHTTPRequestHandler):
@@ -1932,12 +1959,12 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             self._handle_tracker_nodes(model)
         elif parsed.path == "/v1/raft/status":
             self._handle_raft_status()
-        elif parsed.path == "/v1/stats":
-            self._handle_stats()
-        elif parsed.path == "/v1/console":
-            self._handle_console()
-        elif parsed.path == "/v1/billing/summary":
-            self._handle_billing_summary()
+        elif parsed.path == "/v1/stats":
+            self._handle_stats()
+        elif parsed.path == "/v1/console":
+            self._handle_console()
+        elif parsed.path == "/v1/billing/summary":
+            self._handle_billing_summary()
         elif parsed.path == "/v1/billing/settlements":
             self._handle_billing_settlements()
         elif parsed.path == "/v1/account":
@@ -2143,6 +2170,40 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                 result[model] = server.stats.get_node_model_stats(node.node_id, model)
             return result
 
+        def model_supply_for(node: _NodeEntry) -> dict:
+            model = node.model or node.hf_repo
+            if not model:
+                return {}
+            resolved_name, preset = _resolve_model_preset(server.model_presets, model)
+            if preset is not None:
+                required_start, required_end = _preset_layer_bounds(preset)
+                model_nodes = [
+                    n for n in nodes
+                    if _node_matches_preset(n, resolved_name, preset)  # type: ignore[arg-type]
+                ]
+            else:
+                model_nodes = [
+                    n for n in nodes
+                    if _node_matches_model(n, model)
+                    and n.shard_start is not None
+                    and n.shard_end is not None
+                    and n.num_layers is not None
+                ]
+                if not model_nodes:
+                    return {}
+                required_start = 0
+                required_end = max(n.num_layers for n in model_nodes if n.num_layers is not None) - 1
+            return {
+                "model": resolved_name or model,
+                "required_start": required_start,
+                "required_end": required_end,
+                "served_model_copies": _served_model_copies(
+                    model_nodes,
+                    required_start,
+                    required_end,
+                ),
+            }
+
         self._send_json(200, {
             "relay_url": server.relay_url,
             "pool": _pool_summary(nodes),
@@ -2165,14 +2226,15 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                     "peer_id": node.peer_id,
                     "model": node.model,
                     "hf_repo": node.hf_repo,
-                    "num_layers": node.num_layers,
-                    "model_metadata": dict(node.model_metadata),
-                    "downloaded_models": [dict(item) for item in node.downloaded_models],
-                    "shard_start": node.shard_start,
+                    "num_layers": node.num_layers,
+                    "model_metadata": dict(node.model_metadata),
+                    "downloaded_models": [dict(item) for item in node.downloaded_models],
+                    "shard_start": node.shard_start,
                     "shard_end": node.shard_end,
                     "tracker_mode": node.tracker_mode,
                     "last_heartbeat": node.last_heartbeat,
                     "capacity": capacity_for(node),
+                    "model_supply": model_supply_for(node),
                     "throughput": throughput_for(node),
                     "stats": _node_health(node, server.heartbeat_timeout),
                 }
@@ -2313,27 +2375,27 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                         if n.shard_start == 0 and _node_matches_model(n, model)
                     ]
 
-            if not candidates:
-                with server.lock:
-                    registered = [
-                        {
-                            "node_id": n.node_id,
-                            "model": n.model,
-                            "hf_repo": n.hf_repo,
-                            "shard": f"{n.shard_start}-{n.shard_end}",
-                            "tracker_mode": n.tracker_mode,
-                        }
-                        for n in server.registry.values()
-                    ]
-                _tracker_log(
-                    server,
-                    "warn",
-                    "no nodes available for model",
-                    model=model,
-                    registered_nodes=registered,
-                )
-                self._send_json(503, {"error": {
-                    "message": f"no nodes available for model {model!r}",
+            if not candidates:
+                with server.lock:
+                    registered = [
+                        {
+                            "node_id": n.node_id,
+                            "model": n.model,
+                            "hf_repo": n.hf_repo,
+                            "shard": f"{n.shard_start}-{n.shard_end}",
+                            "tracker_mode": n.tracker_mode,
+                        }
+                        for n in server.registry.values()
+                    ]
+                _tracker_log(
+                    server,
+                    "warn",
+                    "no nodes available for model",
+                    model=model,
+                    registered_nodes=registered,
+                )
+                self._send_json(503, {"error": {
+                    "message": f"no nodes available for model {model!r}",
                     "type": "service_unavailable",
                     "code": "model_not_available",
                 }})
@@ -2346,42 +2408,42 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         # Pre-resolve the downstream route so the first-shard node skips its own
         # tracker query.  We already hold the full registry picture — no need for
         # a second round-trip.
-        route_model = node.hf_repo or node.model or model
-        with server.lock:
-            resolved_route_model, route_preset = _resolve_model_preset(server.model_presets, route_model)
-            if route_preset is not None:
-                route_model = resolved_route_model or route_model
-                preset = route_preset
-                rs, re = _preset_layer_bounds(preset)
-                all_nodes: list = [
-                    n for n in server.registry.values()
-                    if _node_matches_preset(n, route_model, preset)
-                    and n.shard_start is not None
-                    and n.shard_end is not None
-                ]
-            else:
-                all_nodes = [
-                    n for n in server.registry.values()
-                    if _node_matches_model(n, route_model)
-                    and n.shard_start is not None and n.num_layers is not None
+        route_model = node.hf_repo or node.model or model
+        with server.lock:
+            resolved_route_model, route_preset = _resolve_model_preset(server.model_presets, route_model)
+            if route_preset is not None:
+                route_model = resolved_route_model or route_model
+                preset = route_preset
+                rs, re = _preset_layer_bounds(preset)
+                all_nodes: list = [
+                    n for n in server.registry.values()
+                    if _node_matches_preset(n, route_model, preset)
+                    and n.shard_start is not None
+                    and n.shard_end is not None
+                ]
+            else:
+                all_nodes = [
+                    n for n in server.registry.values()
+                    if _node_matches_model(n, route_model)
+                    and n.shard_start is not None and n.num_layers is not None
                 ]
                 rs, re = 0, (max((n.num_layers for n in all_nodes), default=1) - 1)
         if pinned_nodes is not None:
             route_nodes = pinned_nodes
         else:
-            route_nodes, route_error = _select_route(all_nodes, rs, re, model=route_model, contracts=server.contracts)
-            if route_error:
-                _tracker_log(
-                    server,
-                    "warn",
-                    "route unavailable",
-                    model=model,
-                    route_model=route_model,
-                    error=route_error,
-                    candidate_count=len(all_nodes),
-                    candidates=_node_route_summary(all_nodes),
-                )
-                self._send_json(503, {"error": {
+            route_nodes, route_error = _select_route(all_nodes, rs, re, model=route_model, contracts=server.contracts)
+            if route_error:
+                _tracker_log(
+                    server,
+                    "warn",
+                    "route unavailable",
+                    model=model,
+                    route_model=route_model,
+                    error=route_error,
+                    candidate_count=len(all_nodes),
+                    candidates=_node_route_summary(all_nodes),
+                )
+                self._send_json(503, {"error": {
                     "message": route_error,
                     "type": "service_unavailable",
                     "code": "route_not_available",
@@ -2407,18 +2469,18 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             f"{n.node_id}@{n.endpoint}[{n.shard_start}-{n.shard_end}]"
             for n in route_nodes
         )
-        _tracker_log(
-            server,
-            "info",
-            "proxy route selected",
-            request_id=request_id,
-            model=model,
-            head_node_id=node.node_id,
-            head_endpoint=node.endpoint,
-            downstream=downstream_urls,
-            route=route_debug or "<empty>",
-            nodes=_node_route_summary(route_nodes),
-        )
+        _tracker_log(
+            server,
+            "info",
+            "proxy route selected",
+            request_id=request_id,
+            model=model,
+            head_node_id=node.node_id,
+            head_endpoint=node.endpoint,
+            downstream=downstream_urls,
+            route=route_debug or "<empty>",
+            nodes=_node_route_summary(route_nodes),
+        )
 
         req = urllib.request.Request(
             target_url,
@@ -2441,14 +2503,14 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         }
 
         if node.relay_addr:
-            _tracker_log(
-                server,
-                "info",
-                "proxy via relay",
-                request_id=request_id,
-                relay_addr=node.relay_addr,
-                direct_endpoint=target_url,
-            )
+            _tracker_log(
+                server,
+                "info",
+                "proxy via relay",
+                request_id=request_id,
+                relay_addr=node.relay_addr,
+                direct_endpoint=target_url,
+            )
             started = time.monotonic()
             frames = _relay_http_request_frames(
                 node.relay_addr,
@@ -2475,39 +2537,39 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                         in_tokens, out_tokens = _billable_non_stream_split(json.loads(body_text), body)
                     except (json.JSONDecodeError, TypeError):
                         in_tokens, out_tokens = 0, 0
-                    tokens = in_tokens + out_tokens
-                    self._record_observed_throughput(model, route_model, tokens, elapsed, route_nodes)
-                    _tracker_log(
-                        server,
-                        "info",
-                        "proxy complete",
-                        request_id=request_id,
-                        model=model,
-                        route_model=route_model,
-                        status=int(first.get("status", 503)),
-                        tokens=tokens,
-                        elapsed_seconds=round(elapsed, 4),
-                        tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
-                        route=_node_route_summary(route_nodes),
-                    )
-                    self._bill_completed(
-                        api_key, model, tokens, node_work,
-                        input_tokens=in_tokens, output_tokens=out_tokens,
-                    )
+                    tokens = in_tokens + out_tokens
+                    self._record_observed_throughput(model, route_model, tokens, elapsed, route_nodes)
+                    _tracker_log(
+                        server,
+                        "info",
+                        "proxy complete",
+                        request_id=request_id,
+                        model=model,
+                        route_model=route_model,
+                        status=int(first.get("status", 503)),
+                        tokens=tokens,
+                        elapsed_seconds=round(elapsed, 4),
+                        tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
+                        route=_node_route_summary(route_nodes),
+                    )
+                    self._bill_completed(
+                        api_key, model, tokens, node_work,
+                        input_tokens=in_tokens, output_tokens=out_tokens,
+                    )
                 return
-            _tracker_log(
-                server,
-                "warn",
-                "relay proxy failed, trying direct",
-                request_id=request_id,
-                relay_addr=node.relay_addr,
-                direct_endpoint=target_url,
-            )
+            _tracker_log(
+                server,
+                "warn",
+                "relay proxy failed, trying direct",
+                request_id=request_id,
+                relay_addr=node.relay_addr,
+                direct_endpoint=target_url,
+            )
 
         try:
-            started = time.monotonic()
-            upstream = urllib.request.urlopen(req, timeout=300.0)
-            _tracker_log(server, "info", "proxy connected", request_id=request_id, target_url=target_url)
+            started = time.monotonic()
+            upstream = urllib.request.urlopen(req, timeout=300.0)
+            _tracker_log(server, "info", "proxy connected", request_id=request_id, target_url=target_url)
         except urllib.error.HTTPError as exc:
             # Relay error status + body from node
             err_body = exc.read()
@@ -2521,25 +2583,25 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                 pass
             return
         except Exception as exc:
-            if node.relay_addr:
-                _tracker_log(
-                    server,
-                    "error",
-                    "direct proxy failed after relay",
-                    request_id=request_id,
-                    target_url=target_url,
-                    relay_addr=node.relay_addr,
-                    error=repr(exc),
-                )
-            else:
-                _tracker_log(
-                    server,
-                    "error",
-                    "proxy failed",
-                    request_id=request_id,
-                    target_url=target_url,
-                    error=repr(exc),
-                )
+            if node.relay_addr:
+                _tracker_log(
+                    server,
+                    "error",
+                    "direct proxy failed after relay",
+                    request_id=request_id,
+                    target_url=target_url,
+                    relay_addr=node.relay_addr,
+                    error=repr(exc),
+                )
+            else:
+                _tracker_log(
+                    server,
+                    "error",
+                    "proxy failed",
+                    request_id=request_id,
+                    target_url=target_url,
+                    error=repr(exc),
+                )
             self._send_json(503, {"error": {
                 "message": f"upstream node unreachable: {exc}",
                 "type": "service_unavailable",
@@ -2577,57 +2639,57 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                 in_tokens, out_tokens = _stream_billable_split(
                     observed_stream_tokens, stream_usage, body
                 )
-                self._record_observed_throughput(
-                    model, route_model, in_tokens + out_tokens, elapsed, route_nodes
-                )
-                tokens = in_tokens + out_tokens
-                _tracker_log(
-                    server,
-                    "info",
-                    "proxy complete",
-                    request_id=request_id,
-                    model=model,
-                    route_model=route_model,
-                    status=200,
-                    stream=True,
-                    tokens=tokens,
-                    elapsed_seconds=round(elapsed, 4),
-                    tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
-                    route=_node_route_summary(route_nodes),
-                )
-                self._bill_completed(
-                    api_key, model, tokens, node_work,
-                    input_tokens=in_tokens, output_tokens=out_tokens,
-                )
-            else:
-                # Non-streaming: buffer and relay
-                resp_body = upstream.read()
-                elapsed = time.monotonic() - started
-                observed_output = ""
-                try:
-                    response_payload = json.loads(resp_body)
-                    in_tokens, out_tokens = _billable_non_stream_split(response_payload, body)
-                    observed_output = _observed_output_from_non_stream_payload(response_payload)
-                except json.JSONDecodeError:
-                    in_tokens, out_tokens = 0, 0
-                tokens = in_tokens + out_tokens
-                self._record_observed_throughput(model, route_model, tokens, elapsed, route_nodes)
-                _tracker_log(
-                    server,
-                    "info",
-                    "proxy complete",
-                    request_id=request_id,
-                    model=model,
-                    route_model=route_model,
-                    target_url=target_url,
-                    status=200,
-                    bytes=len(resp_body),
-                    tokens=tokens,
-                    elapsed_seconds=round(elapsed, 4),
-                    tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
-                    route=_node_route_summary(route_nodes),
-                )
-                self._record_validation_event(request_id, model, body, observed_output, route_nodes)
+                self._record_observed_throughput(
+                    model, route_model, in_tokens + out_tokens, elapsed, route_nodes
+                )
+                tokens = in_tokens + out_tokens
+                _tracker_log(
+                    server,
+                    "info",
+                    "proxy complete",
+                    request_id=request_id,
+                    model=model,
+                    route_model=route_model,
+                    status=200,
+                    stream=True,
+                    tokens=tokens,
+                    elapsed_seconds=round(elapsed, 4),
+                    tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
+                    route=_node_route_summary(route_nodes),
+                )
+                self._bill_completed(
+                    api_key, model, tokens, node_work,
+                    input_tokens=in_tokens, output_tokens=out_tokens,
+                )
+            else:
+                # Non-streaming: buffer and relay
+                resp_body = upstream.read()
+                elapsed = time.monotonic() - started
+                observed_output = ""
+                try:
+                    response_payload = json.loads(resp_body)
+                    in_tokens, out_tokens = _billable_non_stream_split(response_payload, body)
+                    observed_output = _observed_output_from_non_stream_payload(response_payload)
+                except json.JSONDecodeError:
+                    in_tokens, out_tokens = 0, 0
+                tokens = in_tokens + out_tokens
+                self._record_observed_throughput(model, route_model, tokens, elapsed, route_nodes)
+                _tracker_log(
+                    server,
+                    "info",
+                    "proxy complete",
+                    request_id=request_id,
+                    model=model,
+                    route_model=route_model,
+                    target_url=target_url,
+                    status=200,
+                    bytes=len(resp_body),
+                    tokens=tokens,
+                    elapsed_seconds=round(elapsed, 4),
+                    tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
+                    route=_node_route_summary(route_nodes),
+                )
+                self._record_validation_event(request_id, model, body, observed_output, route_nodes)
                 self._bill_completed(
                     api_key, model, tokens, node_work,
                     input_tokens=in_tokens, output_tokens=out_tokens,
@@ -2800,30 +2862,30 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         in_tokens, out_tokens = _stream_billable_split(
             observed_stream_tokens, stream_usage, request_body
         )
-        self._record_observed_throughput(
-            model, route_model, in_tokens + out_tokens, elapsed, route_nodes
-        )
-        tokens = in_tokens + out_tokens
-        server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
-        _tracker_log(
-            server,
-            "info",
-            "proxy complete",
-            request_id=session_id,
-            model=model,
-            route_model=route_model,
-            status=200,
-            stream=True,
-            relay=True,
-            tokens=tokens,
-            elapsed_seconds=round(elapsed, 4),
-            tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
-            route=_node_route_summary(route_nodes),
-        )
-        self._bill_completed(
-            api_key, model, tokens, node_work,
-            input_tokens=in_tokens, output_tokens=out_tokens,
-        )
+        self._record_observed_throughput(
+            model, route_model, in_tokens + out_tokens, elapsed, route_nodes
+        )
+        tokens = in_tokens + out_tokens
+        server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
+        _tracker_log(
+            server,
+            "info",
+            "proxy complete",
+            request_id=session_id,
+            model=model,
+            route_model=route_model,
+            status=200,
+            stream=True,
+            relay=True,
+            tokens=tokens,
+            elapsed_seconds=round(elapsed, 4),
+            tokens_per_sec=round(tokens / elapsed, 4) if elapsed > 0 else 0.0,
+            route=_node_route_summary(route_nodes),
+        )
+        self._bill_completed(
+            api_key, model, tokens, node_work,
+            input_tokens=in_tokens, output_tokens=out_tokens,
+        )
 
     def _send_relayed_response(self, response: dict) -> None:
         status = int(response.get("status", 503))
@@ -2973,19 +3035,19 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         model_metadata = body.get("model_metadata", {})
         if model_metadata is None:
             model_metadata = {}
-        if not isinstance(model_metadata, dict):
-            self._send_json(400, {"error": "model_metadata must be an object"})
-            return
-        downloaded_models = body.get("downloaded_models", [])
-        if downloaded_models is None:
-            downloaded_models = []
-        if not (
-            isinstance(downloaded_models, list)
-            and all(isinstance(item, dict) for item in downloaded_models)
-        ):
-            self._send_json(400, {"error": "downloaded_models must be an array of objects"})
-            return
-        relay_addr = body.get("relay_addr") or None
+        if not isinstance(model_metadata, dict):
+            self._send_json(400, {"error": "model_metadata must be an object"})
+            return
+        downloaded_models = body.get("downloaded_models", [])
+        if downloaded_models is None:
+            downloaded_models = []
+        if not (
+            isinstance(downloaded_models, list)
+            and all(isinstance(item, dict) for item in downloaded_models)
+        ):
+            self._send_json(400, {"error": "downloaded_models must be an array of objects"})
+            return
+        relay_addr = body.get("relay_addr") or None
         cert_fingerprint = body.get("cert_fingerprint") or None
         peer_id = body.get("peer_id") or None
 
@@ -3015,11 +3077,11 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             quantization=quantization,
             managed_assignment=managed_assignment or not explicit_shard,
             tracker_mode=tracker_mode,
-            hf_repo=hf_repo,
-            num_layers=num_layers,
-            model_metadata=model_metadata,
-            downloaded_models=downloaded_models,
-            relay_addr=relay_addr,
+            hf_repo=hf_repo,
+            num_layers=num_layers,
+            model_metadata=model_metadata,
+            downloaded_models=downloaded_models,
+            relay_addr=relay_addr,
             cert_fingerprint=cert_fingerprint,
             peer_id=peer_id,
         )
@@ -3030,37 +3092,37 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                 eid for eid, e in server.registry.items()
                 if e.endpoint == entry.endpoint.rstrip("/")
             ]
-            for eid in stale_ids:
-                old = server.registry.pop(eid)
-                _tracker_log(
-                    server,
-                    "info",
-                    "node re-registered",
-                    old_node_id=eid,
-                    node_id=node_id,
-                    endpoint=old.endpoint,
-                )
-            server.registry[node_id] = entry
+            for eid in stale_ids:
+                old = server.registry.pop(eid)
+                _tracker_log(
+                    server,
+                    "info",
+                    "node re-registered",
+                    old_node_id=eid,
+                    node_id=node_id,
+                    endpoint=old.endpoint,
+                )
+            server.registry[node_id] = entry
             if entry.managed_assignment:
                 if entry.hf_repo:
                     _rebalance_hf_model_locked(server, entry.hf_repo)
                 else:
                     _rebalance_model_locked(server, model)
             assignment_directive = entry.pending_directives[-1] if entry.pending_directives else None
-            if assignment_directive is not None:
-                entry.pending_directives.clear()
-
-            _tracker_log(
-                server,
-                "info",
-                "node registered",
-                node_id=node_id,
-                endpoint=entry.endpoint,
-                model=entry.model,
-                hf_repo=entry.hf_repo,
-                shard=f"{entry.shard_start}-{entry.shard_end}",
-                tracker_mode=entry.tracker_mode,
-            )
+            if assignment_directive is not None:
+                entry.pending_directives.clear()
+
+            _tracker_log(
+                server,
+                "info",
+                "node registered",
+                node_id=node_id,
+                endpoint=entry.endpoint,
+                model=entry.model,
+                hf_repo=entry.hf_repo,
+                shard=f"{entry.shard_start}-{entry.shard_end}",
+                tracker_mode=entry.tracker_mode,
+            )
 
         shard_info = f"layers {shard_start}-{shard_end}" if shard_start is not None else "unsharded"
         repo_info = f" [{hf_repo}]" if hf_repo else ""
@@ -3099,12 +3161,12 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             except Exception:
                 pass
         with server.lock:
-            self._purge_expired_nodes()
-            entry = server.registry.get(node_id)
-            if entry is None:
-                _tracker_log(server, "warn", "heartbeat for unknown node", node_id=node_id)
-                self._send_json(404, {"error": "node not found"})
-                return
+            self._purge_expired_nodes()
+            entry = server.registry.get(node_id)
+            if entry is None:
+                _tracker_log(server, "warn", "heartbeat for unknown node", node_id=node_id)
+                self._send_json(404, {"error": "node not found"})
+                return
             entry.last_heartbeat = time.monotonic()
             entry.heartbeats_received += 1
             # P2P metadata
@@ -3213,7 +3275,7 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             return
         self._send_json(200, server.billing.snapshot())
 
-    def _handle_dashboard(self):
+    def _handle_dashboard(self):
         """Serve the read-only web dashboard (US-035). Any tracker in the
         mesh — leader or follower — serves it from its replicated state."""
         try:
@@ -3228,16 +3290,16 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
         self.end_headers()
         try:
             self.wfile.write(body)
-        except BrokenPipeError:
-            pass
-
-    def _handle_console(self):
-        server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
-        with server.console_lock:
-            events = [dict(event) for event in server.console_events]
-        self._send_json(200, {"events": events})
-
-    def _handle_registry_wallets(self):
+        except BrokenPipeError:
+            pass
+
+    def _handle_console(self):
+        server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
+        with server.console_lock:
+            events = [dict(event) for event in server.console_events]
+        self._send_json(200, {"events": events})
+
+    def _handle_registry_wallets(self):
         server: _TrackerHTTPServer = self.server  # type: ignore[assignment]
         if not self._require_role("admin"):
             return
@@ -4217,12 +4279,12 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                     "shard_end": shard_end,
                     "num_layers": total_l,
                     "gap_found": True,
-                    "price_per_token": 0.0,
-                    "bytes_per_layer": _preset_bytes_per_layer(preset),
-                    "deployment": _deployment_summary(pool_with_caller, preset),
-                    "model_sources": self._model_sources(
-                        str(resolved_name),
-                        preset,
+                    "price_per_token": 0.0,
+                    "bytes_per_layer": _preset_bytes_per_layer(preset),
+                    "deployment": _deployment_summary(pool_with_caller, preset),
+                    "model_sources": self._model_sources(
+                        str(resolved_name),
+                        preset,
                         shard_start,
                         shard_end,
                     ),
@@ -4314,13 +4376,13 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
             "shard_start": shard_start,
             "shard_end": shard_end,
             "num_layers": total_l,
-            "gap_found": gap_found,
-            "price_per_token": 0.0,
-            "bytes_per_layer": _preset_bytes_per_layer(best_preset) if best_preset is not None else None,
-            "model_sources": self._model_sources(
-                str(resolved_name or best_repo),
-                best_preset or {"hf_repo": best_repo},
-                shard_start,
+            "gap_found": gap_found,
+            "price_per_token": 0.0,
+            "bytes_per_layer": _preset_bytes_per_layer(best_preset) if best_preset is not None else None,
+            "model_sources": self._model_sources(
+                str(resolved_name or best_repo),
+                best_preset or {"hf_repo": best_repo},
+                shard_start,
                 shard_end,
             ),
         })
@@ -4366,20 +4428,20 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                 if not node.wallet_address or not server.contracts.registry.get_wallet(node.wallet_address).banned
             ]
 
-        route, error = _select_route(alive, required_start, required_end, contracts=server.contracts)
-        if error:
-            _tracker_log(
-                server,
-                "warn",
-                "route unavailable",
-                model=model,
-                route_model=resolved_name or model,
-                error=error,
-                candidate_count=len(alive),
-                candidates=_node_route_summary(alive),
-            )
-            self._send_json(503, {"error": error})
-            return
+        route, error = _select_route(alive, required_start, required_end, contracts=server.contracts)
+        if error:
+            _tracker_log(
+                server,
+                "warn",
+                "route unavailable",
+                model=model,
+                route_model=resolved_name or model,
+                error=error,
+                candidate_count=len(alive),
+                candidates=_node_route_summary(alive),
+            )
+            self._send_json(503, {"error": error})
+            return
 
         covered_up_to = required_start - 1
         route_with_start: list[tuple] = []
@@ -4402,9 +4464,9 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                     "model": e.model,
                     "hf_repo": e.hf_repo,
                     "num_layers": e.num_layers,
-                    "model_metadata": dict(e.model_metadata),
-                    "downloaded_models": [dict(item) for item in e.downloaded_models],
-                    "shard_checksum": e.shard_checksum,
+                    "model_metadata": dict(e.model_metadata),
+                    "downloaded_models": [dict(item) for item in e.downloaded_models],
+                    "shard_checksum": e.shard_checksum,
                     "score": e.score,
                 }
                 for e, start in route_with_start
@@ -4468,9 +4530,9 @@ class _TrackerHandler(http.server.BaseHTTPRequestHandler):
                         "wallet_address": e.wallet_address,
                         "shard_start": e.shard_start,
                         "shard_end": e.shard_end,
-                        "model": e.model,
-                        "downloaded_models": [dict(item) for item in e.downloaded_models],
-                        "shard_checksum": e.shard_checksum,
+                        "model": e.model,
+                        "downloaded_models": [dict(item) for item in e.downloaded_models],
+                        "shard_checksum": e.shard_checksum,
                         "score": e.score,
                     }
                     for e in route
@@ -4888,15 +4950,15 @@ class TrackerServer:
             wallet_address=payload.get("wallet_address"),
             score=float(payload.get("score", 1.0)),
             tracker_mode=bool(payload.get("tracker_mode", False)),
-            hf_repo=payload.get("hf_repo"),
-            num_layers=int(payload["num_layers"]) if payload.get("num_layers") is not None else None,
-            model_metadata=payload.get("model_metadata") if isinstance(payload.get("model_metadata"), dict) else None,
-            downloaded_models=(
-                payload.get("downloaded_models")
-                if isinstance(payload.get("downloaded_models"), list)
-                else None
-            ),
-        )
+            hf_repo=payload.get("hf_repo"),
+            num_layers=int(payload["num_layers"]) if payload.get("num_layers") is not None else None,
+            model_metadata=payload.get("model_metadata") if isinstance(payload.get("model_metadata"), dict) else None,
+            downloaded_models=(
+                payload.get("downloaded_models")
+                if isinstance(payload.get("downloaded_models"), list)
+                else None
+            ),
+        )
         with self._lock:
             self._registry[node_id] = entry
 
diff --git a/tests/test_tracker_routing.py b/tests/test_tracker_routing.py
index 0715ec7..43e26dc 100644
--- a/tests/test_tracker_routing.py
+++ b/tests/test_tracker_routing.py
@@ -162,6 +162,59 @@ def test_network_map_exposes_pool_size_and_speed_summary():
     assert pool["total_effective_throughput"] == 10.0
 
 
+def test_network_map_exposes_served_model_copy_count():
+    tracker = TrackerServer()
+    port = tracker.start()
+    url = f"http://127.0.0.1:{port}"
+    try:
+        _post_json(
+            f"{url}/v1/nodes/register",
+            {
+                "endpoint": "http://127.0.0.1:7201",
+                "model": "copy-count-test",
+                "hf_repo": "example/copy-count-test",
+                "num_layers": 37,
+                "shard_start": 0,
+                "shard_end": 21,
+                "hardware_profile": {},
+            },
+        )
+        network_map = _get_json(f"{url}/v1/network/map")
+        assert network_map["nodes"][0]["model_supply"]["served_model_copies"] == 0.59
+
+        _post_json(
+            f"{url}/v1/nodes/register",
+            {
+                "endpoint": "http://127.0.0.1:7202",
+                "model": "copy-count-test",
+                "hf_repo": "example/copy-count-test",
+                "num_layers": 37,
+                "shard_start": 22,
+                "shard_end": 36,
+                "hardware_profile": {},
+            },
+        )
+        network_map = _get_json(f"{url}/v1/network/map")
+        assert network_map["nodes"][0]["model_supply"]["served_model_copies"] == 1.0
+
+        _post_json(
+            f"{url}/v1/nodes/register",
+            {
+                "endpoint": "http://127.0.0.1:7203",
+                "model": "copy-count-test",
+                "hf_repo": "example/copy-count-test",
+                "num_layers": 37,
+                "shard_start": 0,
+                "shard_end": 36,
+                "hardware_profile": {},
+            },
+        )
+        network_map = _get_json(f"{url}/v1/network/map")
+        assert network_map["nodes"][0]["model_supply"]["served_model_copies"] == 2.0
+    finally:
+        tracker.stop()
+
+
 def test_recommended_kimi_becomes_deployable_when_pool_is_large_enough():
     tracker = TrackerServer()
     port = tracker.start()
