Fix: keep slow Text2OS/LASM/wallpaper generation off STATE_LOCK; deterministic keyword fast path before the LLM

app.py

@@ -874,7 +874,11 @@ def keyword_intents(text):
 
 
 def parse_intents(text):
-    """Text2OS: try the LLM, fall back to deterministic keywords."""
+    """Text2OS: deterministic keywords first (instant), LLM only for the
+    ambiguous remainder. Keeps common commands off the model entirely."""
+    kw = keyword_intents(text)
+    if not any(o.get("op") == "none" for o in kw):
+        return kw
     eng = get_engine()
     try:
         raw = eng.text2text(
@@ -886,7 +890,7 @@ def parse_intents(text):
                 return data["ops"]
     except Exception:
         pass
-    return keyword_intents(text)
+    return kw
 
 
 # --------------------------------------------------------------------------- #
@@ -902,7 +906,7 @@ class Compositor:
         self.last = None
         self._memo = {}          # signature -> raster, avoids per-frame realloc
         self.metrics = {"frames": 0, "full": 0, "patch": 0, "idle": 0,
-                        "composite_ms": 0.0, "encode_ms": 0.0, "tiles": 0}
+                        "build_ms": 0.0, "frame_ms": 0.0, "tiles": 0, "bytes": 0}
 
     def _cached(self, sig, maker):
         """Return a stable raster for a content signature, so unchanged UI
@@ -1235,32 +1239,58 @@ def handle_client_message(msg, clients):
         elif t == "key":
             key = msg.get("key", "")
             if key == "Enter":
+                # The intent parse may call the LLM for tens of seconds on CPU.
+                # Never do that under STATE_LOCK: hand it to a worker thread so
+                # the render loop and the heartbeat keep flowing.
                 text = KERNEL.text_buffer
                 KERNEL.text_buffer = ""
-                ops = parse_intents(text)
-                for op in ops:
-                    if op.get("op") == "open" and op.get("app") in DEFAULT_SIZE:
-                        KERNEL.open(op["app"])
-                    elif op.get("op") == "close_all":
-                        for pid in list(KERNEL.windows):
-                            KERNEL.close(pid)
                 KERNEL.log(f"Text2OS: {text[:40]}", ttl=6)
+                _spawn(apply_text2os, text)
             elif key == "Backspace":
                 KERNEL.text_buffer = KERNEL.text_buffer[:-1]
             elif len(key) == 1:
                 KERNEL.text_buffer = (KERNEL.text_buffer + key)[-120:]
         elif t == "lasm":
-            from types import SimpleNamespace
-            vm = LatentVM(COMPOSITOR.stack, SPRITES)
-            logs = vm.run(msg.get("program", []))
-            for l in logs:
-                KERNEL.log(l, ttl=5)
+            _spawn(apply_lasm, msg.get("program", []))
         elif t == "wallpaper":
-            STORE.put("chrome.wallpaper.v3", get_engine().text2img(
-                msg.get("prompt", "abstract"), (FB, FB), seed=int(time.time()), steps=2))
+            _spawn(apply_wallpaper, msg.get("prompt", "abstract"))
     broadcast_dirty(clients)
 
 
+def _spawn(fn, *args):
+    """Run slow, generation-bound work off the input/render critical path."""
+    threading.Thread(target=fn, args=args, daemon=True).start()
+
+
+def apply_text2os(text):
+    ops = parse_intents(text)          # slow (LLM) -> done without the lock
+    with STATE_LOCK:
+        for op in ops:
+            if op.get("op") == "open" and op.get("app") in DEFAULT_SIZE:
+                KERNEL.open(op["app"])
+            elif op.get("op") == "close_all":
+                for pid in list(KERNEL.windows):
+                    KERNEL.close(pid)
+    broadcast_dirty(CLIENTS)
+
+
+def apply_lasm(program):
+    vm = LatentVM(COMPOSITOR.stack, SPRITES)
+    logs = vm.run(program)             # may run the model per opcode
+    with STATE_LOCK:
+        for l in logs:
+            KERNEL.log(l, ttl=5)
+    broadcast_dirty(CLIENTS)
+
+
+def apply_wallpaper(prompt):
+    img = get_engine().text2img(prompt, (FB, FB), seed=int(time.time()), steps=2)
+    STORE.put("chrome.wallpaper.v3", img)
+    with STATE_LOCK:
+        KERNEL.log("wallpaper regenerated", ttl=5)
+    broadcast_dirty(CLIENTS)
+
+
 def heartbeat(clients):
     """Cursor/clock tick: small dirty rect, proves patch path."""
     while True: