deploy(S4): Blender headless pipeline + WebAR client + backend fixes

backend/routes/mobile_bridge_routes.py

@@ -162,6 +162,57 @@ async def caps() -> dict[str, Any]:
     return {"ok": True, "capabilities": labels}
 
 
+@router.get("/link_status")
+async def link_status() -> dict[str, Any]:
+    """The truth about the phone -> cloud -> PC path, in one call.
+
+    Guardian used to build its status cards from two unrelated signals: a /health
+    ping (proves the Space is up) and a stored boolean. Neither said anything
+    about whether a command could actually REACH the desktop, so the app happily
+    rendered "PC CONTROL: CLOUD online" next to "NO ACTIVE LINK" while the phone
+    could not send a single command. A status light that does not test the path
+    it claims to describe is worse than no light at all.
+
+    Reaching this endpoint at all proves the cloud leg. `pc_connected` is the
+    number of desktops holding a live, registered WebSocket — the exact list
+    send_to_pcs() delivers to — so it is the same fact the command path uses,
+    not a parallel guess. `pc_unlocked` comes from the PC's own periodic report.
+    """
+    pc_count = 0
+    status: dict[str, Any] = {}
+    age: float | None = None
+    queued = 0
+    try:
+        from backend.ws.agent_ws import ws_manager as _ws
+        pc_count = len(_ws.pc_connections)
+        status = dict(_ws.last_pc_status or {})
+        queued = len(_ws.pending_commands)
+        if _ws.last_pc_status_at:
+            age = round(time.time() - _ws.last_pc_status_at, 1)
+    except Exception as exc:
+        log.warning("link_status unavailable: %s", exc)
+
+    unlocked = bool(status.get("unlocked"))
+    if pc_count <= 0:
+        state, detail = "offline", "Your PC is not connected."
+    elif not unlocked:
+        state, detail = "locked", "Connected, but locked. Send: unlock pc <password>"
+    else:
+        state, detail = "ready", "Connected and ready for commands."
+
+    return {
+        "ok": True,
+        "cloud": True,            # answering at all proves this leg
+        "pc_connected": pc_count,
+        "pc_unlocked": unlocked,
+        "state": state,           # offline | locked | ready
+        "detail": detail,
+        "queued_commands": queued,
+        "pc_status_age_seconds": age,
+        "pc_status": status,
+    }
+
+
 @router.get("/link_info")
 async def link_info(request: Request) -> dict[str, Any]:
     base = _base_url(request)

backend/ws/agent_ws.py

@@ -69,6 +69,14 @@ class ConnectionManager:
         # simply dropped — the user had to remember it and send it again once the
         # PC woke up.
         self.pending_commands: list[dict] = []
+        # Last status the PC relay pushed, and when. The relay has always sent
+        # `relay:status` every 10 seconds and NOTHING read it — there was no
+        # branch for it in handle_client_event, so it fell through and was
+        # dropped. That is why the phone had no honest way to know anything about
+        # the desktop and fell back to showing cloud health in a card labelled
+        # "PC CONTROL".
+        self.last_pc_status: dict = {}
+        self.last_pc_status_at: float = 0.0
         from backend.agent.react_agent import Tool
         self.tools = []
         for name, func in TOOL_REGISTRY.items():
@@ -280,6 +288,18 @@ class ConnectionManager:
         # by the command_id the cloud minted. This closes the loop that used to
         # be open-ended: without it the phone was told "Sent to your PC." and
         # never learned that the desktop had refused the command.
+        # ── THE PC'S OWN REPORT ─────────────────────────────────────────────────
+        # Received every 10s from pc_relay_client.status_pusher and, until now,
+        # silently discarded. Storing it is what lets /api/link_status tell the
+        # phone something TRUE about the desktop instead of guessing from cloud
+        # health.
+        if data.get("event") == "relay:status":
+            payload = data.get("payload")
+            if isinstance(payload, dict):
+                self.last_pc_status = payload
+                self.last_pc_status_at = time.time()
+            return
+
         if data.get("event") == "relay:result":
             payload = data.get("payload") or {}
             command_id = str(payload.get("command_id") or "")

dist/app-release.apk

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9f6ff4329c1d9ab621312b87542baa2a90f5020db9131cb1601b5058ab50853d
+oid sha256:aea6e0ae1cd4ee73eae1ba552343ab583401abf760f44e5966a156af9e38d4ff
 size 116538395

modules/activation_state.py

@@ -12,9 +12,13 @@ UNLOCK_JSON = ROOT / "data" / "session_unlocked.json"
 # One wording for the refusal, shared by every caller that has to explain it —
 # core.commands (voice/GUI) and phone.command_runner (phone and cloud relay) —
 # so a remote user is never told something different from a local one.
+# Tells the user what to do from WHERE THEY ARE. The old wording sent them to
+# the desktop for an activation key, which is useless advice to someone holding
+# a phone in another country — and that is the only situation in which a relayed
+# command hits this message at all.
 LOCKED_MESSAGE = (
-    "This PC is locked. Activate JARVIS on the desktop with your "
-    "activation key, then send the command again."
+    "This PC is locked. Send: unlock pc <your password> — then this command "
+    "will run."
 )