relay-codex 0.7.2 → 0.7.4

package/docs/publishing.md

@@ -8,8 +8,8 @@ Friends can run `npx relay-codex` or install it with `npm install -g relay-codex
 The GitHub repository is enough for friends to install or try Relay:
 
 ```sh
-npm install -g github:blackspider-ops/relay#v0.7.2
-npx --yes github:blackspider-ops/relay#v0.7.2 --version
+npm install -g github:blackspider-ops/relay#v0.7.4
+npx --yes github:blackspider-ops/relay#v0.7.4 --version
 ```
 
 `npx` runs packages; it is not a separate publishing service. Publishing

package/docs/troubleshooting.md

@@ -49,6 +49,24 @@ Relay rechecks this after checking the target account, so work starting during
 that check also prevents switching. A rejected menu action keeps its explanation
 visible. Use Restart for a stopped worker rather than sending it live controls.
 
+**A usage-limit panel remains open and Relay says “waiting for activity.”**
+
+Update Relay if you are using a version older than 0.7.4. Background terminals
+and missed tool notifications could leave a finished turn marked as active.
+Relay checks native history and the current backend's status. Commands explicitly
+listed by Codex as background terminals can keep running while accounts change
+after the model turn ends. The usage panel does not need to be clicked. Relay keeps
+waiting when work is still running or completion cannot be verified; approvals
+and paused recovery still need attention. Existing workers retain the code they
+started with, so an update takes effect after that worker is relaunched.
+
+**Codex says “auth refresh request failed: code=-32000.”**
+
+Relay retries authentication on its normal retry schedule, then tries another
+available account. If Codex reports that a refresh token was revoked, sign in
+again with `relay account reauth LABEL`. Switch any sessions using that account
+first. A revoked login cannot be repaired by retrying the same token.
+
 **Tab completion is missing.**
 
 Load `source <(relay completion zsh)` after `compinit`, or use

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relay-codex",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Keep your Codex sessions moving between your own accounts.",
   "license": "MIT",
   "author": "blackspider-ops",

package/python/broker.py

@@ -225,6 +225,11 @@ async def serve(state, binary):
                                     ):
                                         value = candidate
                                 if value is None:
+                                    if request.get("refresh"):
+                                        # A retained native manager can hold a refresh
+                                        # grant rotated by another process. Reload the
+                                        # Keychain under this account's shared lock.
+                                        await account.close()
                                     await account.start()
                                     result = await account.rpc.call(
                                         "account/read",

package/python/commands.py

@@ -773,8 +773,6 @@ async def dispatch(args, state, binary):
         elif args.command == "clean":
             if args.days < 1:
                 raise ValueError("Retention must be at least one day")
-            from pool import file_lock
-
             async with file_lock(state / "cleanup.lock"):
                 if args.apply:
                     try:

package/python/execution.py

@@ -350,7 +350,7 @@ async def _run(args, state, binary):
         controller.launch_overrides = overrides
         controller.client = output
         output.controller = controller
-        backend.handler = controller.event
+        backend.handler = lambda message: controller.event(message, origin=backend)
         init = await backend.initialize()
         heartbeat = asyncio.create_task(controller.maintain())
         model = values.get("--model")

package/python/pool.py

@@ -545,6 +545,13 @@ CAPACITY_MESSAGE = "Selected model is at capacity. Please try a different model.
 
 
 def failure_kind(info, message=None):
+    if (
+        info in (None, "other", "unauthorized")
+        and isinstance(message, str)
+        and message.strip().removeprefix("■").strip().lower()
+        == "auth refresh request failed: code=-32000"
+    ):
+        return "auth"
     if info == "policyCapacityUnavailable":
         return "capacity"
     # Older/generic error envelopes can omit the enum. Match only the known

package/python/router.py

@@ -24,7 +24,7 @@ from pool import Pool, blocked, reset_time, failure_kind, file_lock
 from launch import translate, RESUME_FIELDS
 import settings
 
-VERSION = "0.7.2"
+VERSION = "0.7.4"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"
@@ -95,6 +95,17 @@ def clean_env(home: Path) -> dict:
     return env
 
 
+def rejected_failure_kind(payload):
+    if payload.get("code") == -32001:
+        return "transient"
+    if (
+        payload.get("code") in {-32000, -32603}
+        and failure_kind("other", payload.get("message")) == "auth"
+    ):
+        return "auth"
+    return None
+
+
 def codex_path() -> str:
     path = shutil.which("codex")
     if not path:
@@ -193,6 +204,9 @@ class RPC:
         self.reader = asyncio.create_task(self.read_loop())
         self.startup_guard = None
 
+    def disconnected(self):
+        return self.proc.returncode is not None or self.reader.done()
+
     @classmethod
     async def start(
         cls, binary: str, home: Path, *, helper=False, handler=None, extra_args=None
@@ -330,7 +344,7 @@ class Account:
         self.lock = asyncio.Lock()
 
     async def start(self):
-        if self.rpc and self.rpc.proc.returncode is not None:
+        if self.rpc and self.rpc.disconnected():
             await self.rpc.close()
             self.rpc = None
         if not self.rpc:
@@ -384,6 +398,7 @@ class Account:
     async def close(self):
         if self.rpc:
             await self.rpc.close()
+            self.rpc = None
 
 
 class Controller:
@@ -433,7 +448,11 @@ class Controller:
         self.turn_ids = {}
         self.recovery_jobs = {}
         self.pending_intents = {}
+        self.rejected_turns = {}
         self.active_items = set()
+        self.active_item_threads = {}
+        self.item_revision = 0
+        self.auth_account = None
         self.backend_factory = None
         self.restart_lock = asyncio.Lock()
         self.restart_task = None
@@ -673,6 +692,7 @@ class Controller:
                         model=next((self.model_for(t) for t in self.last_turn), None),
                         paused=self.paused,
                         background=self.background,
+                        activity=self.activity_snapshot(),
                     )
                     last_heartbeat = now
                 new_revision = self.pool.revision()
@@ -741,7 +761,7 @@ class Controller:
                     pass
             if now - last_watch >= self.preferences["watchdog_interval"]:
                 last_watch = now
-                if self.backend.proc.returncode is not None and self.backend_factory:
+                if self.backend_disconnected() and self.backend_factory:
                     if not self.restart_task or self.restart_task.done():
                         self.restart_task = asyncio.create_task(self.restart_backend())
                 elif self.active_threads:
@@ -786,7 +806,10 @@ class Controller:
             if self.active_threads or self.active_items:
                 raise RouterError("Session is busy")
             if thread:
-                await self.backend.call("thread/resume", {"threadId": thread, **params})
+                await self.backend.call(
+                    "thread/resume",
+                    {"threadId": thread, "excludeTurns": True, **params},
+                )
                 self.merge_settings(thread, params)
             self.launch_overrides = {**self.launch_overrides, **params}
             if params.get("permissions"):
@@ -800,6 +823,7 @@ class Controller:
             )
             if index is None:
                 raise ControlRejected("unknown_account")
+            await self.reconcile_active_items()
             if self.active_threads or self.active_items or self.server_requests:
                 raise ControlRejected("busy")
             options = self.pool.options(label) if self.pool else {}
@@ -854,20 +878,24 @@ class Controller:
 
     async def restart_backend(self):
         async with self.restart_lock:
-            if self.backend.proc.returncode is None:
+            if not self.backend_disconnected():
                 return
             self.note("restarting")
             in_flight = bool(self.active_items or self.server_requests)
             old = self.backend
+            old_auth_account = self.auth_account
             candidate = None
             try:
                 candidate = await self.backend_factory()
-                candidate.handler = self.event
+                candidate.handler = lambda message: self.event(
+                    message, origin=candidate
+                )
                 await candidate.initialize()
                 self.backend = candidate
                 await self.login(self.index)
             except Exception:
                 self.backend = old
+                self.auth_account = old_auth_account
                 if candidate:
                     await candidate.close()
                 self.note("backend_restart_failed", reason="startup_or_login_failed")
@@ -877,8 +905,10 @@ class Controller:
             self.pending_server_requests.clear()
             self.replayed_requests.clear()
             self.active_items.clear()
+            self.active_item_threads.clear()
+            self.item_revision += 1
             for thread in list(self.last_turn):
-                params = {"threadId": thread}
+                params = {"threadId": thread, "excludeTurns": True}
                 params.update(
                     {
                         k: v
@@ -959,9 +989,17 @@ class Controller:
                     )
                 ):
                     raise ControlRejected("account_unavailable")
-            await self.backend.call(
-                "account/login/start", {"type": "chatgptAuthTokens", **credentials}
-            )
+            # Native refresh callbacks can arrive before the login response.
+            # Bind them to the credentials being installed, not the old index.
+            previous_binding = self.auth_account
+            self.auth_account = self.accounts[index]
+            try:
+                await self.backend.call(
+                    "account/login/start", {"type": "chatgptAuthTokens", **credentials}
+                )
+            except RemoteError:
+                self.auth_account = previous_binding
+                raise
             self.index = index
             # Acceptance of token syntax alone isn't a verified, usable login.
             result = await self.backend.call("account/read", {"refreshToken": False})
@@ -977,25 +1015,34 @@ class Controller:
             except Exception:
                 pass
 
-    async def event(self, message):
+    async def event(self, message, *, origin=None):
+        if origin is not None and origin is not self.backend:
+            return
         method, params = message.get("method"), message.get("params", {})
         if method == "account/chatgptAuthTokens/refresh":
+            account = self.auth_account or self.account
+            transport = self.backend
             try:
                 # Never return another identity in response to a refresh request.
-                credentials = await self.account.credentials(refresh=True)
+                credentials = await account.credentials(refresh=True)
                 previous = params.get("previousAccountId")
                 if previous and previous != credentials["chatgptAccountId"]:
                     raise RouterError(
                         "Refresh account mismatch; re-enroll the account."
                     )
-                await self.backend.send({"id": message["id"], "result": credentials})
+                if transport is not self.backend:
+                    return
+                await transport.send({"id": message["id"], "result": credentials})
             except (RouterError, asyncio.TimeoutError):
-                await self.backend.send(
+                if transport is not self.backend:
+                    return
+                self.note("auth_refresh_failed", account=account.label)
+                await transport.send(
                     {
                         "id": message["id"],
                         "error": {
                             "code": -32000,
-                            "message": "Account requires sign-in.",
+                            "message": "Account credentials could not be refreshed. Relay will retry after this turn ends.",
                         },
                     }
                 )
@@ -1017,6 +1064,7 @@ class Controller:
             if self.pool and thread.get("id"):
                 self.pool.claim(thread["id"])
         if method == "turn/started":
+            self.rejected_turns.pop(params["threadId"], None)
             self.active_threads.add(params["threadId"])
             self.turn_ids[params["threadId"]] = params.get("turn", {}).get("id")
             if params["threadId"] in self.pending_intents:
@@ -1027,6 +1075,7 @@ class Controller:
                 accepted=True,
                 turn=params.get("turn", {}).get("id"),
                 state="working",
+                rejected=False,
             )
         elif method == "item/started" and params.get("item", {}).get("type") in {
             "commandExecution",
@@ -1034,11 +1083,18 @@ class Controller:
             "fileChange",
             "dynamicToolCall",
         }:
-            self.active_items.add(params["item"]["id"])
-            if params.get("threadId"):
-                self.persist(params["threadId"], active_items=True)
+            item = params["item"]
+            if item.get("status") not in {"completed", "failed", "declined"}:
+                self.active_items.add(item["id"])
+                self.item_revision += 1
+                if params.get("threadId"):
+                    self.active_item_threads[item["id"]] = params["threadId"]
+                    self.persist(params["threadId"], active_items=True)
         elif method == "item/completed":
-            self.active_items.discard(params.get("item", {}).get("id"))
+            item = params.get("item", {}).get("id")
+            self.active_items.discard(item)
+            self.active_item_threads.pop(item, None)
+            self.item_revision += 1
             if params.get("threadId"):
                 self.persist(params["threadId"], active_items=bool(self.active_items))
         elif method == "model/rerouted":
@@ -1173,6 +1229,14 @@ class Controller:
         ):
             if generation != self.user_generation or not self.attached():
                 return False
+            await self.reconcile_active_items()
+            if not (
+                self.active_threads
+                or self.active_items
+                or self.server_requests
+                or self.paused
+            ):
+                break
             self.status_changed.clear()
             try:
                 await asyncio.wait_for(
@@ -1184,7 +1248,9 @@ class Controller:
                         await self.reconcile(thread)
                 if time.monotonic() - began > self.preferences["idle_warning_after"]:
                     self.note(
-                        "waiting_for_activity", reason="actions_or_approvals_not_idle"
+                        "waiting_for_activity",
+                        reason="actions_or_approvals_not_idle",
+                        activity=self.activity_snapshot(),
                     )
             if self.paused:
                 self.wake.clear()
@@ -1194,6 +1260,170 @@ class Controller:
                     pass
         return generation == self.user_generation and self.attached()
 
+    async def reconcile_active_items(self):
+        """Reconcile finished actions and native background jobs at idle boundaries."""
+        owners = dict(self.active_item_threads)
+        revision = self.item_revision
+        for thread in set(owners.values()):
+            pending = {
+                item
+                for item, owner in owners.items()
+                if owner == thread and item in self.active_items
+            }
+            if not pending:
+                continue
+            await self.reconcile_background_activity(thread, pending, revision)
+            pending &= self.active_items
+            if not pending:
+                continue
+            cursor = None
+            visited = set()
+            for _ in range(8):
+                params = {
+                    "threadId": thread,
+                    "limit": 1,
+                    "sortDirection": "desc",
+                    "itemsView": "full",
+                }
+                if cursor:
+                    params["cursor"] = cursor
+                try:
+                    result = await self.backend.call(
+                        "thread/turns/list", params, timeout=15
+                    )
+                except (RouterError, asyncio.TimeoutError):
+                    break
+                # A concurrent start invalidates this history read. Never clear
+                # a newly started action using a snapshot taken before it began.
+                if revision != self.item_revision:
+                    return
+                confirmed = {
+                    item.get("id")
+                    for turn in result.get("data", [])
+                    if turn.get("itemsView") == "full"
+                    for item in turn.get("items", [])
+                    if item.get("type")
+                    in {
+                        "commandExecution",
+                        "mcpToolCall",
+                        "fileChange",
+                        "dynamicToolCall",
+                    }
+                    and item.get("status") in {"completed", "failed", "declined"}
+                }
+                cleared = pending & confirmed
+                for item in cleared:
+                    if self.active_item_threads.get(item) == thread:
+                        self.active_items.discard(item)
+                        self.active_item_threads.pop(item, None)
+                if cleared:
+                    pending -= cleared
+                    self.persist(thread, active_items=bool(self.active_items))
+                    if self.pool:
+                        self.pool.record("tool_activity_reconciled", count=len(cleared))
+                    self.status_changed.set()
+                cursor = result.get("nextCursor")
+                if not pending or not cursor or cursor in visited:
+                    break
+                visited.add(cursor)
+
+    def backend_disconnected(self):
+        check = getattr(self.backend, "disconnected", None)
+        return (
+            check()
+            if check
+            else getattr(getattr(self.backend, "proc", None), "returncode", None)
+            is not None
+        )
+
+    def activity_snapshot(self):
+        """Private diagnostic metadata; never tool arguments or credentials."""
+        return {
+            "threads": sorted(self.active_threads),
+            "items": sorted(self.active_items),
+            "owners": dict(self.active_item_threads),
+            "requests": sorted(
+                {
+                    m.get("method", "unknown")
+                    for m in self.pending_server_requests.values()
+                }
+            ),
+            "request_count": len(self.server_requests),
+            "paused": self.paused,
+            "disconnected": self.backend_disconnected(),
+        }
+
+    async def reconcile_background_activity(self, thread, pending, revision):
+        """After a turn ends, known background terminals need not block login.
+
+        These jobs remain alive in the same backend. Unknown tools and pending
+        approvals still block recovery; a terminal turn alone cannot clear them.
+        """
+        turn_id = self.turn_ids.get(thread)
+        generation = self.user_generation
+        if not turn_id or self.server_requests:
+            return
+        try:
+            turn = await self.latest(thread) or {}
+            if turn.get("id") != turn_id or turn.get("status") not in {
+                "completed",
+                "failed",
+                "interrupted",
+            }:
+                return
+            background = set()
+            cursor = None
+            visited = set()
+            for _ in range(8):
+                params = {"threadId": thread, "limit": 100}
+                if cursor:
+                    params["cursor"] = cursor
+                result = await self.backend.call(
+                    "thread/backgroundTerminals/list", params, timeout=15
+                )
+                background.update(item.get("itemId") for item in result.get("data", []))
+                cursor = result.get("nextCursor")
+                if not cursor or cursor in visited or pending <= background:
+                    break
+                visited.add(cursor)
+            if not pending & background:
+                return
+            info = await self.backend.call(
+                "thread/read", {"threadId": thread}, timeout=15
+            )
+        except (RouterError, asyncio.TimeoutError):
+            return
+        if (
+            revision != self.item_revision
+            or generation != self.user_generation
+            or self.turn_ids.get(thread) != turn_id
+            or self.server_requests
+            or info.get("thread", {}).get("status", {}).get("type")
+            not in {"idle", "systemError"}
+            or info.get("thread", {}).get("canAcceptDirectInput") is False
+        ):
+            return
+        cleared = {
+            item
+            for item in pending & background
+            if self.active_item_threads.get(item) == thread
+            and item in self.active_items
+        }
+        for item in cleared:
+            self.active_items.discard(item)
+            self.active_item_threads.pop(item, None)
+        if cleared:
+            self.active_threads.discard(thread)
+            self.persist(thread, active_items=bool(self.active_items))
+            if self.pool:
+                self.pool.record(
+                    "background_activity_reconciled",
+                    count=len(cleared),
+                    thread=thread,
+                    turn=turn_id,
+                )
+            self.status_changed.set()
+
     async def continue_thread(self, thread, generation):
         if not self.can_continue(thread, generation):
             return
@@ -1210,6 +1440,19 @@ class Controller:
                 params[key] = self.thread_settings[thread][key]
         params["clientUserMessageId"] = str(uuid.uuid4())
         baseline = self.turn_ids.get(thread) or "__unknown_before_submission__"
+        rejected = self.rejected_turns.get(thread)
+        if rejected:
+            baseline = rejected["baseline"]
+            try:
+                latest = await self.latest(thread)
+            except (RouterError, asyncio.TimeoutError):
+                self.hold_for_review(thread, "rejected_request_history_unavailable")
+                return
+            observed = (latest or {}).get("id") or "__unknown_before_submission__"
+            if observed != baseline:
+                self.hold_for_review(thread, "rejected_request_history_changed")
+                return
+            params = dict(rejected["params"])
         try:
             while True:
                 async with self.login_lock:
@@ -1227,6 +1470,7 @@ class Controller:
                             accepted=False,
                             state="submitting",
                             baseline=baseline,
+                            rejected=bool(rejected),
                         )
                         result = await self.backend.call("turn/start", params)
                         break
@@ -1234,6 +1478,7 @@ class Controller:
                     return
             turn = result.get("turn", {})
             if turn.get("id"):
+                self.rejected_turns.pop(thread, None)
                 self.turn_ids[thread] = turn["id"]
                 self.pending_intents[thread]["accepted"] = True
                 self.persist(
@@ -1241,18 +1486,35 @@ class Controller:
                     accepted=True,
                     turn=turn["id"],
                     state=turn.get("status", "working"),
+                    rejected=False,
                 )
         except RemoteError as error:
-            if error.payload.get("code") == -32001:
-                return await self.recover(thread, generation, "transient")
+            kind = rejected_failure_kind(error.payload)
+            if kind:
+                if self.pending_intents.get(thread, {}).get("accepted"):
+                    return await self.uncertain(thread, generation, baseline)
+                self.remember_rejected(thread, params, baseline)
+                return await self.recover(thread, generation, kind)
             raise
         except (RouterError, asyncio.TimeoutError):
             return await self.uncertain(thread, generation, baseline)
         self.report(f"Continued the saved thread with {self.account_name()}.")
 
+    def remember_rejected(self, thread, params, baseline):
+        # Only explicit pre-acceptance rejections qualify. Keep the original
+        # input in memory; a worker restart requires resubmission, not a guess.
+        self.rejected_turns[thread] = {
+            "params": dict(params),
+            "baseline": baseline or "__unknown_before_submission__",
+        }
+        self.persist(thread, rejected=True)
+
     async def restore_recovery(self, thread, persisted):
         """Honor an accepted retry's original deadline after a process restart."""
         generation = self.user_generation
+        if persisted.get("rejected"):
+            self.hold_for_review(thread, "rejected_request_requires_resubmission")
+            return
         if persisted.get("review_required"):
             self.hold_for_review(
                 thread, persisted.get("review_reason") or "review_required"
@@ -1618,6 +1880,7 @@ class Controller:
                 self.fallback_tried.pop(message["params"]["threadId"], None)
             self.status_changed.set()
             if method == "turn/start":
+                self.rejected_turns.pop(message["params"]["threadId"], None)
                 self.clear_review(message["params"]["threadId"])
                 self.last_turn[message["params"]["threadId"]] = message["params"]
                 self.merge_settings(message["params"]["threadId"], message["params"])
@@ -1683,6 +1946,7 @@ class Controller:
                         accepted=False,
                         baseline=self.turn_ids.get(thread),
                         state="submitting",
+                        rejected=False,
                     )
                 async with guard:
                     result = await self.backend.call(
@@ -1749,13 +2013,22 @@ class Controller:
             await self.emit({"id": request_id, "error": error.payload})
             # Ingress overload rejects a turn before a turn/completed event
             # exists. Its documented code is explicit, not message matching.
-            if method == "turn/start" and error.payload.get("code") == -32001:
+            kind = rejected_failure_kind(error.payload)
+            if method == "turn/start" and kind:
                 if self.recovery and not self.recovery.done():
                     self.recovery.cancel()
                 thread = message["params"]["threadId"]
-                self.recovery = asyncio.create_task(
-                    self.recover(thread, self.user_generation, "transient")
-                )
+                intent = self.pending_intents.get(thread, {})
+                baseline = intent.get("baseline", "__unknown_before_submission__")
+                if intent.get("accepted"):
+                    self.recovery = asyncio.create_task(
+                        self.uncertain(thread, self.user_generation, baseline)
+                    )
+                else:
+                    self.remember_rejected(thread, message["params"], baseline)
+                    self.recovery = asyncio.create_task(
+                        self.recover(thread, self.user_generation, kind)
+                    )
         except (RouterError, asyncio.TimeoutError):
             await self.emit(
                 {