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

backend/routes/mobile_bridge_routes.py

@@ -224,20 +224,34 @@ async def command(request: Request) -> dict[str, Any]:
     #
     # Falls through to record-only when no PC is listening, which is the honest
     # answer when the machine is off rather than a failure.
+    #
+    # We wait for the PC's actual answer rather than reporting success on
+    # hand-off. The desktop can refuse a command outright — an un-activated
+    # session hard-blocks every one of them — and reporting "Sent to your PC."
+    # in that case tells the user their command ran when it did not.
     try:
         from backend.ws.agent_ws import ws_manager as _ws_manager
-        delivered = await _ws_manager.send_to_pcs({
-            "event": "system:execute",
-            "payload": {"cmd": cmd, "source": "guardian", "device_name": device_name},
-        })
+        outcome = await _ws_manager.execute_on_pcs(cmd, device_name=device_name)
     except Exception as exc:
         log.warning("PC relay unavailable: %s", exc)
-        delivered = 0
+        outcome = {"delivered": 0, "ok": False, "spoken": [], "timed_out": False}
 
+    delivered = int(outcome.get("delivered") or 0)
     if delivered:
+        if outcome.get("timed_out"):
+            return {
+                "ok": False,
+                "spoken": ["Your PC received the command but did not report back."],
+                "status": "no_response",
+                "action": "pc_relay",
+                "pc_count": delivered,
+            }
+        spoken = outcome.get("spoken") or []
         return {
-            "ok": True,
-            "spoken": [f"Sent to your PC."],
+            # The PC's own words when it has any — that is where "This PC is
+            # locked…" reaches the phone — and a plain confirmation otherwise.
+            "ok": bool(outcome.get("ok")),
+            "spoken": spoken or ["Done on your PC."],
             "status": "relayed",
             "action": "pc_relay",
             "pc_count": delivered,

backend/ws/agent_ws.py

@@ -56,6 +56,12 @@ class ConnectionManager:
         # idea which socket it was. That is why phone -> cloud -> PC control did
         # not work: not a missing channel, an unread introduction.
         self.pc_connections: list[WebSocket] = []
+        # In-flight command_id -> Future, resolved when a PC reports the outcome.
+        # Without this the cloud answered the phone the instant it had *handed
+        # off* the command, so "Sent to your PC." was printed for commands the
+        # desktop then refused outright (locked session) or failed to run. The
+        # phone showed success for work that never happened.
+        self.pending_results: dict[str, asyncio.Future] = {}
         from backend.agent.react_agent import Tool
         self.tools = []
         for name, func in TOOL_REGISTRY.items():
@@ -102,6 +108,49 @@ class ConnectionManager:
                     self.pc_connections.remove(connection)
         return delivered
 
+    async def execute_on_pcs(self, cmd: str, device_name: str = "",
+                             timeout: float = 20.0) -> dict:
+        """Send a command to the PCs and wait for the first real outcome.
+
+        Returns {delivered, ok, spoken, timed_out}. `delivered == 0` means no
+        desktop was listening; `timed_out` means one was, but it never answered
+        (old relay build, or the command stack hung) — three states the caller
+        must be able to tell apart, because only one of them is success.
+        """
+        command_id = str(uuid.uuid4())
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future = loop.create_future()
+        self.pending_results[command_id] = future
+        try:
+            delivered = await self.send_to_pcs({
+                "event": "system:execute",
+                "payload": {
+                    "cmd": cmd,
+                    "source": "guardian",
+                    "device_name": device_name,
+                    "command_id": command_id,
+                },
+            })
+            if not delivered:
+                return {"delivered": 0, "ok": False, "spoken": [], "timed_out": False}
+            try:
+                result = await asyncio.wait_for(future, timeout=timeout)
+            except asyncio.TimeoutError:
+                logging.warning("PC relay did not report a result for %r", cmd)
+                return {"delivered": delivered, "ok": False, "spoken": [],
+                        "timed_out": True}
+            spoken = result.get("spoken") or []
+            if isinstance(spoken, str):
+                spoken = [spoken]
+            return {
+                "delivered": delivered,
+                "ok": bool(result.get("ok")),
+                "spoken": [str(s) for s in spoken],
+                "timed_out": False,
+            }
+        finally:
+            self.pending_results.pop(command_id, None)
+
     async def broadcast(self, message: dict):
         for connection in self.active_connections:
             try:
@@ -134,6 +183,27 @@ class ConnectionManager:
                 except Exception:
                     pass
             return
+
+        # ── WHAT HAPPENED? ──────────────────────────────────────────────────────
+        # The PC reports back the outcome of a system:execute it was given, keyed
+        # 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.
+        if data.get("event") == "relay:result":
+            payload = data.get("payload") or {}
+            command_id = str(payload.get("command_id") or "")
+            future = self.pending_results.get(command_id)
+            if future is not None and not future.done():
+                future.set_result({
+                    "ok": bool(payload.get("ok")),
+                    "spoken": payload.get("spoken") or [],
+                })
+            else:
+                # Late or duplicate answer — the waiter already gave up, or a
+                # second PC answered after the first. Never an error.
+                logging.debug("relay:result for unknown command_id %r", command_id)
+            return
+
         # ── WAKE WORD → PERSONA SWITCH (Cloud + Local path) ──────────────────────
         # Mobile app / local PC sends: {"event": "voice:wake_word", "payload": {"agent": "hey jarvis"}}
         # The server auto-switches the active persona and broadcasts UI + TTS confirmation.