fix(telemetry): detect cold start inside ZeroGPU worker body

ZeroGPU executes @spaces.GPU bodies in a worker process; get_model sets
_llm/_loaded_file there and the globals never reach the web process, so
the outer residency pre-check always saw no model and the -1.0 sentinel
leaked into records (summary filtered it to 0.0). Residency is now
evaluated inside the worker and returned with the result, which does
propagate back. Regression test pins the worker-side semantics.

app.py

@@ -404,34 +404,35 @@ def gpu_tracked_call(kind: str, fn, *args, model: str = "", **kwargs):
     """
     t_submit = time.time()
     call_id = GPU_USAGE.lease_start(kind)
-    # Cold-start detection: the model was not resident before this lease, so
-    # this lease includes the full load cost (first lease after boot or after
-    # a model switch freed it).
-    was_resident = _llm is not None and _loaded_file == model
-    cold_start_s = 0.0 if was_resident else -1.0  # -1 => resolved after body
 
     @spaces.GPU(duration=120)
     def _tracked_inner():
+        # Residency must be evaluated INSIDE the ZeroGPU worker: module
+        # globals set there (_llm/_loaded_file via get_model) never propagate
+        # back to the web process, so cold-start state is invisible outside.
+        resident_before = _llm is not None and _loaded_file == model
         t_body_start = time.time()
         try:
             result = fn(*args, **kwargs)
             error = ""
         except Exception as exc:
             result, error = None, str(exc)
-        return result, error, t_body_start
+        if not resident_before and _llm is not None and _loaded_file == model:
+            # The body loaded the model inside this lease. The load share is
+            # not directly observable, so the whole post-body span is the
+            # cold-start upper bound.
+            cold_start_s = max(0.0, time.time() - t_body_start)
+        else:
+            cold_start_s = 0.0
+        return result, error, t_body_start, cold_start_s
 
     try:
-        result, error, t_body_start = _tracked_inner()
+        result, error, t_body_start, cold_start_s = _tracked_inner()
     except Exception as exc:
         # Lease-level failure (e.g. 429 quota exhaustion): body never ran.
         GPU_USAGE.lease_end(call_id, model=model, kind=kind, error=str(exc))
         raise
     queue_wait = max(0.0, t_body_start - t_submit)
-    if cold_start_s < 0 and _llm is not None and _loaded_file == model:
-        # Body loaded the model inside this lease. The load share is not
-        # directly observable, so record the whole post-body span as the
-        # cold-start upper bound.
-        cold_start_s = max(0.0, time.time() - t_body_start)
     GPU_USAGE.lease_end(
         call_id, model=model, kind=kind,
         queue_wait_s=queue_wait, cold_start_s=cold_start_s, error=error,

tests/unit/test_gpu_usage_tracker.py

@@ -145,6 +145,36 @@ def test_gpu_tracked_call_records_usage(fresh_usage):
     assert snap["profile"]["total_calls"] == 1
 
 
+def test_gpu_tracked_call_cold_start_worker_side(fresh_usage):
+    """ZeroGPU runs @spaces.GPU bodies in a worker process: get_model sets
+    _llm/_loaded_file there and those globals never reach the web process.
+    Cold-start detection must therefore run inside the body (returns DO
+    propagate back). Regression for the live finding where cold_start was
+    always 0.0 (the -1.0 sentinel was silently dropped by summary())."""
+    app = fresh_usage
+    app._llm = None
+    app._loaded_file = None
+
+    def loader(msgs, model_file, *a, **k):
+        # mimic get_model side effect inside the worker
+        app._llm = object()
+        app._loaded_file = model_file
+        return {"choices": [{"message": {"content": "ok"}}]}
+
+    model = "Qwen3.8-9B-Q8_0.gguf"
+    app.gpu_tracked_call("chat", loader, [], model, 0.7, 30, model=model)
+    cold_rec = app.GPU_USAGE._calls[-1]
+    assert cold_rec["cold_start_seconds"] >= 0.0
+    assert cold_rec["lease_seconds"] >= cold_rec["cold_start_seconds"]
+
+    def warm(msgs, model_file, *a, **k):
+        return {"choices": [{"message": {"content": "ok"}}]}
+
+    app.gpu_tracked_call("chat", warm, [], model, 0.7, 30, model=model)
+    warm_rec = app.GPU_USAGE._calls[-1]
+    assert warm_rec["cold_start_seconds"] == 0.0
+
+
 def test_gpu_tracked_call_records_error_path(fresh_usage):
     app = fresh_usage
     with pytest.raises(RuntimeError):