Fix black tiles on connect; 64px tiles, byte-based delta choice

app.py

@@ -51,7 +51,12 @@ FB = int(os.environ.get("NEURALOS_FB", "1024"))            # framebuffer edge
 TASKBAR_H = 40
 TITLEBAR_H = 26
 CHROME_BORDER = 3
-TILE = 128                                                  # dirty-tile granularity
+TILE = 64                                                   # dirty-tile granularity (16x16 grid)
+# Full-vs-patch decision constants (measured, quality 82): every patch pays a
+# fresh WebP header, so many small tiles can cost more than one full frame. We
+# therefore compare estimated shipped BYTES, not tile count.
+PATCH_OVERHEAD = 700        # bytes of per-image WebP overhead
+PX_RATE = 0.019            # encoded bytes per pixel for UI content
 
 # auto | mock | cpu | cuda
 ENGINE_MODE = os.environ.get("NEURALOS_ENGINE", "auto").lower()
@@ -1058,10 +1063,12 @@ class Compositor:
             self.metrics["idle"] += 1
             self.metrics["tiles"] = 0
             return ("none", None, None)
-        # Per-image WebP overhead means lots of small tiles can cost MORE bytes
-        # than one full frame, so choose on dirty AREA, not tile count.
-        area = sum(w * h for (_, _, w, h) in rects)
-        full = self.last is None or area > 0.08 * FB * FB or len(rects) > 24
+        # A full frame is one image; a patch set is N images, each with its own
+        # WebP header. Ship whichever is estimated to cost fewer bytes.
+        dirty_px = sum(w * h for (_, _, w, h) in rects)
+        est_patch = PATCH_OVERHEAD * len(rects) + PX_RATE * dirty_px
+        est_full = PATCH_OVERHEAD + PX_RATE * FB * FB
+        full = self.last is None or est_patch >= 0.9 * est_full
         if full:
             frame = self.stack.composite()
             payload = self._encode(frame)
@@ -1153,18 +1160,51 @@ def refinement_worker():
             print("[refine]", e)
 
 
+def _frame_stats():
+    """Metrics + kernel state shipped in every frame header.
+
+    Deliberately does NOT call get_engine(): during a cold boot that blocks on
+    model load, and the first frame must not wait behind it."""
+    stats = dict(COMPOSITOR.metrics)
+    stats["cache"] = {"hits": STORE.hits, "misses": STORE.misses}
+    stats["engine"] = ENGINE.stats() if ENGINE is not None else \
+        {"engine": "loading", "device": "-", "lcm": False}
+    stats["windows"] = len(KERNEL.windows)
+    stats["menu"] = KERNEL.menu_open
+    stats["buffer"] = KERNEL.text_buffer
+    return stats
+
+
+def send_full_to(ws):
+    """Push a complete frame to ONE just-connected client.
+
+    The compositor streams a single delta stream shared by every client, so a
+    client that joins after the first frame would otherwise only ever receive
+    the tiles the cursor/caret happens to dirty -- most of its canvas stays
+    blank ("black tiles until mouseover"). Each new socket therefore starts
+    from a full snapshot. Chrome is procedural, so this is cheap and never
+    touches the model."""
+    with STATE_LOCK:
+        COMPOSITOR.build()                    # layers must exist before compositing
+        COMPOSITOR.stack.take_dirty_rects()   # we are shipping the whole state
+        frame = COMPOSITOR.stack.composite()
+        blob = COMPOSITOR._encode(frame)
+        COMPOSITOR.last = frame
+        COMPOSITOR.metrics["full"] += 1
+        COMPOSITOR.metrics["bytes"] = len(blob)
+        COMPOSITOR.metrics["px"] = FB * FB
+        COMPOSITOR.metrics["tiles"] = 0
+        stats = _frame_stats()
+    ws.send(pack(T_FULL, {"w": FB, "h": FB, **stats}, blob))
+
+
 def broadcast_dirty(clients):
     with STATE_LOCK:
         for (text, ttl) in list(KERNEL.overlays):
             if ttl < time.time():
                 KERNEL.overlays.remove((text, ttl))
         result = COMPOSITOR.render()
-        stats = dict(COMPOSITOR.metrics)
-        stats["cache"] = {"hits": STORE.hits, "misses": STORE.misses}
-        stats["engine"] = get_engine().stats()
-        stats["windows"] = len(KERNEL.windows)
-        stats["menu"] = KERNEL.menu_open
-        stats["buffer"] = KERNEL.text_buffer
+        stats = _frame_stats()
     kind, payload, blob = result
     if kind == "none":
         return result
@@ -1327,9 +1367,12 @@ try:
     def kernel_ws(ws):
         CLIENTS.add(ws)
         try:
-            get_engine()
             send_log(ws, "Kernel attached")
-            broadcast_dirty(CLIENTS)          # push the initial full frame now
+            # Paint the whole desktop for this client FIRST: chrome is
+            # procedural, so the first frame need not wait behind engine load.
+            send_full_to(ws)
+            get_engine()
+            broadcast_dirty(CLIENTS)          # then stream deltas as usual
             while True:
                 data = ws.receive()
                 if not data: