fix(browser): the pursuit was cancelled at 181s, then blamed the website

Measured live: 3,183-token decision prompts with 2,471 tokens re-prefilled
every round, roughly a minute a round, and the turn's own budget killing
the generation mid-pursuit. What the person then read was "the page did
not respond to any action" — a confident claim about a website, made
because a model call had been cancelled. The page had been responding
fine.

Two things, both general.

The observation was unbounded. A live questionnaire renders 83 controls
and most are site furniture — nav, language, login, footer — emitted
first in document order, so truncating the raw list would have cut the
answers and kept the chrome. The controls are ranked by what they DO, and
the ones that can advance a goal are offered first. Page text is halved.
The loop resolves indices against the same ranked list she was shown,
because rendering a subset and resolving against the raw one means index
3 names one control on screen and a different one in the click — the
precise way these loops end up pressing whatever moved into slot four.

And an empty error is not evidence about a page. A cancelled generation
returns {"status": "failed", "error": ""}, which was being rendered as a
finding about the site. It now says what is actually known: the status it
ended in, or that it ended before it could act.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: codex

core/skills/desktop_task.py

@@ -5863,7 +5863,24 @@ async def _delegate_page_objective(
             if step.get("error"):
                 failure = str(step["error"])
         if not failure and not report.get("ok"):
-            failure = str(report.get("error") or "the page did not respond to any action")
+            # Say what actually happened, not a guess about the page.
+            #
+            # A cancelled generation comes back `{"status": "failed",
+            # "error": ""}`, and an empty error was being rendered as "the page
+            # did not respond to any action" — a confident claim about a
+            # website, made because a model call was killed mid-round. The turn
+            # ran 181s and was cancelled by its own budget; the page had been
+            # responding fine.
+            reported = str(report.get("error") or "").strip()
+            status = str(report.get("status") or "").strip()
+            if reported:
+                failure = reported
+            elif status and status != "completed":
+                failure = f"the browser task ended as {status} without saying why"
+            elif report.get("rounds") in (None, 0):
+                failure = "the browser task ended before it could act"
+            else:
+                failure = "the page did not respond to any action"
         # The lane's own result shape, not a parallel vocabulary.
         #
         # Third time in this integration: `final_url` where the effect verifier

core/skills/sovereign_browser.py

@@ -881,7 +881,7 @@ async def _handle_interact(
     #: How many of the page's own words travel with the element list. The
     #: controls say what can be done; this says what is being asked, and a
     #: questionnaire is unanswerable without it.
-    PURSUE_TEXT_BUDGET = 1800
+    PURSUE_TEXT_BUDGET = 900
     #: Consecutive rounds that change neither the URL nor the set of controls
     #: before the loop concedes. Two is enough to distinguish a slow page from
     #: a wall: the first repeat may be a re-render, the second is a loop.
@@ -897,10 +897,44 @@ def _observation_signature(observation: Mapping[str, Any]) -> str:
         )
         return f"{observation.get('url')}#{marks}"
 
+    #: Controls offered to one decision. A live questionnaire renders 83, most
+    #: of them site furniture — nav, language, login, footer — and every one of
+    #: them is prefill on every round. Measured: 3,183-token prompts with 2,471
+    #: re-prefilled each time, ~60s a round, and the turn cancelled at 181s
+    #: mid-pursuit.
+    PURSUE_CONTROL_BUDGET = 40
+
+    #: Roles that DO something, offered before the ones that merely navigate.
+    _ACTIONABLE_ROLES = (
+        "radio", "checkbox", "switch", "option", "select", "textarea",
+        "text", "email", "password", "search", "number", "button", "submit",
+    )
+
+    @classmethod
+    def _controls_worth_offering(cls, elements: list[Any]) -> list[Any]:
+        """The controls that can advance a goal, before the ones that decorate.
+
+        Truncating the raw list would cut the answers and keep the navigation,
+        because site furniture is emitted first in document order. Ranking by
+        what a control DOES keeps the form and drops the chrome.
+        """
+        ranked = sorted(
+            enumerate(elements),
+            key=lambda pair: (
+                cls._ACTIONABLE_ROLES.index(str(pair[1].get("role") or "").lower())
+                if str(pair[1].get("role") or "").lower() in cls._ACTIONABLE_ROLES
+                else len(cls._ACTIONABLE_ROLES),
+                pair[0],
+            ),
+        )
+        return [element for _index, element in ranked[: cls.PURSUE_CONTROL_BUDGET]]
+
     @staticmethod
     def _render_observation(observation: Mapping[str, Any]) -> str:
         """The page as the decision sees it: what it says, and what it offers."""
-        elements = observation.get("elements") or []
+        elements = SovereignBrowserSkill._controls_worth_offering(
+            list(observation.get("elements") or [])
+        )
         lines = [
             f"URL: {observation.get('url')}",
             f"Title: {observation.get('title')}",
@@ -1539,7 +1573,12 @@ async def _handle_pursue(
                 steps.append({"why": str(decision.get("why") or ""), "done": True})
                 break
 
-            elements = observation.get("elements") or []
+            # The same list she was shown, in the same order. Rendering a
+            # ranked subset and resolving against the raw list would mean
+            # index 3 named one control on screen and a different one in the
+            # click — the precise way these loops end up pressing whatever
+            # moved into slot four.
+            elements = self._controls_worth_offering(list(observation.get("elements") or []))
             planned: list[BrowserAction] = []
             for item in decision.get("actions") or []:
                 if not isinstance(item, dict):

tests/test_browser_pursue_is_a_closed_loop.py

@@ -482,3 +482,43 @@ async def test_done_after_work_is_accepted(self):
             3,
         )
         assert result["completed"] is True
+
+
+class TestTheDecisionPromptStaysAffordable:
+    """3,183-token prompts, 2,471 re-prefilled per round, cancelled at 181s.
+
+    A live questionnaire renders 83 controls and most are site furniture — nav,
+    language, login, footer — emitted first in document order. Truncating the
+    raw list would therefore cut the answers and keep the chrome, so the ranking
+    is by what a control DOES.
+    """
+
+    def _crowded_page(self):
+        return {
+            "url": "https://example.com/q",
+            "title": "t",
+            "text": "Question 1 of 60",
+            "elements": [{"role": "link", "name": f"nav{i}", "selector": f"#n{i}"} for i in range(30)]
+            + [{"role": "radio", "name": f"answer{i}", "selector": f"#a{i}"} for i in range(14)]
+            + [{"role": "button", "name": "Next", "selector": "#next"}],
+        }
+
+    def test_the_form_survives_and_the_chrome_does_not(self):
+        offered = SovereignBrowserSkill._controls_worth_offering(self._crowded_page()["elements"])
+        assert len(offered) <= SovereignBrowserSkill.PURSUE_CONTROL_BUDGET
+        assert sum(1 for e in offered if e["role"] == "radio") == 14
+        assert any(e["name"] == "Next" for e in offered)
+
+    def test_what_she_is_shown_is_what_the_indices_mean(self):
+        """Rendering a subset and resolving against the raw list clicks the wrong thing."""
+        page = self._crowded_page()
+        rendered = SovereignBrowserSkill._render_observation(page)
+        offered = SovereignBrowserSkill._controls_worth_offering(page["elements"])
+        assert f"[0] {offered[0]['role']}" in rendered
+        assert offered[0]["name"] in rendered
+
+    def test_the_ranking_is_stable(self):
+        page = self._crowded_page()
+        assert [e["selector"] for e in SovereignBrowserSkill._controls_worth_offering(page["elements"])] == [
+            e["selector"] for e in SovereignBrowserSkill._controls_worth_offering(page["elements"])
+        ]