relay-codex 0.7.1 → 0.7.3

package/docs/commands.md

@@ -140,7 +140,9 @@ Each session menu can switch to another enabled account after work and approvals
 finish. The worker checks allowance and session capacity before switching, then
 checks again that the session is idle before changing its login. Rejected actions
 show their reason. Pending menu actions cannot be submitted twice, and results
-remain visible until dismissed or another action starts. Stopped workers offer
+disappear 30 seconds after first being viewed in the menu. Unseen results wait
+until the menu is opened; action progress remains until the action finishes.
+Starting another action replaces its previous result. Stopped workers offer
 Restart; restarting retains any review hold.
 
 Account menus can disable or enable future routing. Disabling an account does not

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.1
-npx --yes github:blackspider-ops/relay#v0.7.1 --version
+npm install -g github:blackspider-ops/relay#v0.7.3
+npx --yes github:blackspider-ops/relay#v0.7.3 --version
 ```
 
 `npx` runs packages; it is not a separate publishing service. Publishing

package/docs/troubleshooting.md

@@ -49,6 +49,15 @@ 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.3. A missed tool-completion
+notification could leave a finished tool marked as active. Relay now checks full
+native history for the matching tool before continuing account recovery. It 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.
+
 **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.1",
+  "version": "0.7.3",
   "description": "Keep your Codex sessions moving between your own accounts.",
   "license": "MIT",
   "author": "blackspider-ops",

package/python/Menu.swift

@@ -6,7 +6,11 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
     var buffer = Data()
     var current: [String: Any] = [:]
     var message: String?
-    var actionNotice: String?
+    var actionNotice: String? {
+        didSet { noticeVersion += 1; noticeExpiry?.cancel(); noticeExpiry = nil }
+    }
+    var noticeVersion = 0
+    var noticeExpiry: DispatchWorkItem?
     var actionFailed = false
     var actionRunning = false
     var reconnect: DispatchWorkItem?
@@ -194,6 +198,7 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         if let visible = item.menu { MenuController.synchronise(visible, with: menu) }
         else { item.menu = menu }
         if menuOpen { scheduleResetExpiry() }
+        scheduleNoticeExpiry()
     }
     func makeMenu() -> NSMenu {
         let sessions = current["sessions"] as? [[String: Any]] ?? []
@@ -205,7 +210,6 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         if let message = message { text(message, into: menu) }
         if let notice = actionNotice {
             text(notice, into: menu)
-            if !actionRunning { action("Dismiss message", args: ["dismiss"], into: menu) }
         }
         if accounts.isEmpty { text("Add an account with relay setup in Terminal.", into: menu) }
         if liveSessions.isEmpty && !accounts.isEmpty { text("No Relay sessions running. Start with relay run.", into: menu) }
@@ -335,6 +339,21 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         }
     }
     func menuDidClose(_ menu: NSMenu) { menuOpen = false; resetExpiry?.cancel(); resetExpiry = nil }
+    func scheduleNoticeExpiry() {
+        guard menuOpen, !actionRunning, actionNotice != nil, noticeExpiry == nil else { return }
+        let version = noticeVersion
+        let expiry = DispatchWorkItem { [weak self] in
+            guard let self = self, self.expireNotice(version: version) else { return }
+            self.render()
+        }
+        noticeExpiry = expiry
+        DispatchQueue.main.asyncAfter(deadline: .now() + 30, execute: expiry)
+    }
+    func expireNotice(version: Int) -> Bool {
+        guard !stopping, !actionRunning, actionNotice != nil, noticeVersion == version else { return false }
+        actionNotice = nil; actionFailed = false
+        return true
+    }
     func resetAllowed(_ id: String) -> Bool {
         let accounts = current["accounts"] as? [[String: Any]] ?? []
         guard let account = accounts.first(where: { $0["id"] as? String == id }) else {
@@ -346,7 +365,6 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
     @objc func runAction(_ sender: NSMenuItem) {
         guard var args = sender.representedObject as? [String], !args.isEmpty else { return }
         if args[0] == "copy" { NSPasteboard.general.clearContents(); NSPasteboard.general.setString(args[1], forType: .string); return }
-        if args[0] == "dismiss" { actionNotice = nil; actionFailed = false; render(); return }
         guard !actionRunning else { return }
         if args[0] == "confirm-retry" {
             let alert = NSAlert(); alert.messageText = "Continue this task?"; alert.informativeText = "Review any interrupted command or external action in the conversation before continuing."
@@ -404,7 +422,7 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         runAction(sender)
     }
     @objc func quitMenu() { stopping = true; reconnect?.cancel(); stream?.terminate(); NSApp.terminate(nil) }
-    func applicationWillTerminate(_ notification: Notification) { stopping = true; stream?.terminate() }
+    func applicationWillTerminate(_ notification: Notification) { stopping = true; noticeExpiry?.cancel(); resetExpiry?.cancel(); stream?.terminate() }
 }
 if CommandLine.arguments.contains("--self-check") {
     let normal = NSImage(systemSymbolName: "arrow.triangle.branch", accessibilityDescription: "Relay")
@@ -473,12 +491,26 @@ if CommandLine.arguments.contains("--self-check") {
     controller.actionRunning = false; controller.actionNotice = "Task is busy."
     controller.current["at"] = 2000000001.0
     let retainedResult = controller.makeMenu().items.contains { $0.title == "Task is busy." }
+    let noDismissButton = findAction(["dismiss"], in: controller.makeMenu()) == nil
+    controller.menuOpen = false; controller.actionFailed = true; controller.actionNotice = "Unseen result"
+    controller.scheduleNoticeExpiry()
+    let unseenRetained = controller.noticeExpiry == nil && controller.actionNotice == "Unseen result"
+    controller.menuOpen = true; controller.scheduleNoticeExpiry()
+    let startsOnView = controller.noticeExpiry != nil
+    let previousNotice = controller.noticeVersion
+    controller.actionNotice = "Newer result"
+    let newerProtected = !controller.expireNotice(version: previousNotice) && controller.actionNotice == "Newer result"
+    controller.actionRunning = true; controller.scheduleNoticeExpiry()
+    let progressRetained = controller.noticeExpiry == nil && !controller.expireNotice(version: controller.noticeVersion)
+    controller.actionRunning = false
+    let expiresAfterView = controller.expireNotice(version: controller.noticeVersion) && controller.actionNotice == nil && !controller.actionFailed
     print("Account choices and stopped controls correct: \(correctChoices && stoppedControls)")
     print("Pending action protected and result retained: \(correctPending && retainedResult)")
     print("In-use accounts and current choice marked: \(correctMarker && correctMultiple && correctEmpty)")
     print("Available and pending reset actions protected: \(correctResets && resetLocked)")
     print("Weekly zero and more-than-48-hour guard enforced: \(correctPolicy && pendingLocked)")
-    exit(normal != nil && attention != nil && liveUpdate && safeIdentity && correctTiming && correctChoices && stoppedControls && correctPending && retainedResult && correctMarker && correctMultiple && correctEmpty && correctResets && resetLocked && correctPolicy && pendingLocked ? 0 : 1)
+    print("Viewed notices expire without hiding unseen or newer results: \(noDismissButton && unseenRetained && startsOnView && newerProtected && progressRetained && expiresAfterView)")
+    exit(normal != nil && attention != nil && liveUpdate && safeIdentity && correctTiming && correctChoices && stoppedControls && correctPending && retainedResult && correctMarker && correctMultiple && correctEmpty && correctResets && resetLocked && correctPolicy && pendingLocked && noDismissButton && unseenRetained && startsOnView && newerProtected && progressRetained && expiresAfterView ? 0 : 1)
 } else {
     let app = NSApplication.shared
     let delegate = MenuController(); app.delegate = delegate; app.run()

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/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.1"
+VERSION = "0.7.3"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"
@@ -434,6 +434,8 @@ class Controller:
         self.recovery_jobs = {}
         self.pending_intents = {}
         self.active_items = set()
+        self.active_item_threads = {}
+        self.item_revision = 0
         self.backend_factory = None
         self.restart_lock = asyncio.Lock()
         self.restart_task = None
@@ -786,7 +788,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"):
@@ -877,8 +882,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
@@ -1034,11 +1041,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 +1187,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(
@@ -1194,6 +1216,69 @@ class Controller:
                     pass
         return generation == self.user_generation and self.attached()
 
+    async def reconcile_active_items(self):
+        """Retire missed completion events only from matching, full native history."""
+        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
+            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)
+
     async def continue_thread(self, thread, generation):
         if not self.can_continue(thread, generation):
             return

package/python/service.py

@@ -246,6 +246,9 @@ async def attach(
             await send_control(state, ident, "detach")
             value = json.loads(meta.read_text())
             env["RELAY_TRANSPORT_TOKEN"] = value["token"]
+        from terminal import TerminalState
+
+        terminal_state = TerminalState()
         proc = await asyncio.create_subprocess_exec(
             binary,
             "--remote",
@@ -295,6 +298,7 @@ async def attach(
                     proc.kill()
                     await proc.wait()
             await asyncio.gather(waiter, return_exceptions=True)
+            terminal_state.restore()
         if replacement:
             print("Reconnecting to the recovered task…", flush=True)
             value = await connection(previous=value)
@@ -590,7 +594,7 @@ async def _serve(state, ident, binary):
         controller.backend_factory = factory
         thread_id = old_thread or spec.get("resume")
         if thread_id:
-            params = {"threadId": thread_id, **overrides}
+            params = {"threadId": thread_id, "excludeTurns": True, **overrides}
             if old:
                 controller.merge_settings(thread_id, persisted.get("settings", {}))
                 params.update(

package/python/terminal.py

@@ -0,0 +1,28 @@
+"""Restore terminal modes even when the native frontend cannot clean up."""
+
+import contextlib
+import os
+import sys
+import termios
+
+RESET_MODES = b"\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1015l\x1b[?2004l\x1b[?25h\x1b[0m"
+
+
+class TerminalState:
+    def __init__(self):
+        self.input_fd = None
+        self.output_fd = None
+        self.attributes = None
+        with contextlib.suppress(OSError, ValueError, AttributeError, termios.error):
+            if sys.stdin.isatty() and sys.stdout.isatty():
+                self.input_fd = sys.stdin.fileno()
+                self.output_fd = sys.stdout.fileno()
+                self.attributes = termios.tcgetattr(self.input_fd)
+
+    def restore(self):
+        if self.attributes is None:
+            return
+        with contextlib.suppress(OSError, termios.error):
+            os.write(self.output_fd, RESET_MODES)
+            termios.tcsetattr(self.input_fd, termios.TCSANOW, self.attributes)
+        self.attributes = None

package/tests/fake_native.py

@@ -55,6 +55,9 @@ def finish(thread, turn, text, mode):
         value = data["threads"][thread]
         value["status"] = {"type": "idle"}
         value["turns"][-1].update(status=status, error=error)
+        for item in value["turns"][-1]["items"]:
+            if item.get("id", "").startswith("lost-completion-"):
+                item["status"] = "completed"
         return value["turns"][-1].copy()
 
     value = change(apply)
@@ -208,6 +211,8 @@ for raw in sys.stdin:
                     ]
                 )
             }
+            for value in result["data"]:
+                value["itemsView"] = params.get("itemsView", "summary")
         elif method == "thread/loaded/list":
             result = {"data": change(lambda d: list(d["threads"]))}
         elif method in {"turn/start", "review/start"}:
@@ -243,6 +248,21 @@ for raw in sys.stdin:
                     "params": {"threadId": thread, "turn": value},
                 }
             )
+            if count <= fault.get("lost_completion_turns", 0):
+                tool = {
+                    "id": "lost-completion-" + turn,
+                    "type": "commandExecution",
+                    "status": "inProgress",
+                }
+                change(
+                    lambda d: d["threads"][thread]["turns"][-1]["items"].append(tool)
+                )
+                send(
+                    {
+                        "method": "item/started",
+                        "params": {"threadId": thread, "item": tool},
+                    }
+                )
             if fault.get("external"):
                 send(
                     {

package/tests/test_activity.py

@@ -0,0 +1,318 @@
+"""A lost item completion must not strand recovery or clear unknown work."""
+
+import asyncio
+import json
+import os
+from pathlib import Path
+import pty
+import termios
+import tempfile
+import tty
+import unittest
+from unittest.mock import patch
+
+from router import Controller, RPC, RouterError
+from test_router import FakeAccount, FakeBackend, FakeClient, completed
+
+
+class ActivityTests(unittest.IsolatedAsyncioTestCase):
+    def test_forced_frontend_exit_restores_terminal_and_disables_mouse_reporting(self):
+        from terminal import TerminalState, RESET_MODES
+
+        master, slave = pty.openpty()
+
+        class Stream:
+            def isatty(self):
+                return True
+
+            def fileno(self):
+                return slave
+
+        try:
+            original = termios.tcgetattr(slave)
+            with patch("sys.stdin", Stream()), patch("sys.stdout", Stream()):
+                state = TerminalState()
+                tty.setraw(slave)
+                state.restore()
+                state.restore()
+            restored = termios.tcgetattr(slave)
+            # macOS may set the transient PENDIN flag when canonical mode returns.
+            restored[3] &= ~getattr(termios, "PENDIN", 0)
+            original[3] &= ~getattr(termios, "PENDIN", 0)
+            self.assertEqual(restored, original)
+            self.assertEqual(os.read(master, 4096), RESET_MODES)
+        finally:
+            os.close(master)
+            os.close(slave)
+
+    def test_noninteractive_output_receives_no_terminal_escape_codes(self):
+        import io
+        from terminal import TerminalState
+
+        output = io.StringIO()
+        with patch("sys.stdin", io.StringIO()), patch("sys.stdout", output):
+            TerminalState().restore()
+        self.assertEqual(output.getvalue(), "")
+
+    async def test_restart_dispatch_uses_the_shared_file_lock(self):
+        import commands
+        from router import parse_arguments
+
+        with tempfile.TemporaryDirectory() as folder:
+            with patch("service.restart", return_value="saved-session") as restart:
+                result = await commands.dispatch(
+                    parse_arguments(["restart", "saved-session"]), Path(folder), None
+                )
+                self.assertEqual(result, 0)
+                restart.assert_called_once()
+
+    async def test_lost_completion_over_real_jsonl_recovers_without_backend_restart(
+        self,
+    ):
+        from test_services import fake_executable, wait_for
+        from settings import atomic_json
+
+        with tempfile.TemporaryDirectory() as folder:
+            root = Path(folder)
+            atomic_json(
+                root / "fault.json", {"quota_turns": 1, "lost_completion_turns": 1}
+            )
+            rpc = await RPC.start(fake_executable(root), root)
+            c = Controller(
+                [FakeAccount("one"), FakeAccount("two")], rpc, report=lambda _: None
+            )
+            c.client = FakeClient()
+            rpc.handler = c.event
+            try:
+                initial_pid = rpc.proc.pid
+                await rpc.initialize()
+                await c.forward(
+                    {"id": "thread", "method": "thread/start", "params": {}}, {}
+                )
+                thread = next(iter(c.last_turn))
+                await c.forward(
+                    {
+                        "id": "turn",
+                        "method": "turn/start",
+                        "params": {
+                            "threadId": thread,
+                            "input": [
+                                {
+                                    "type": "text",
+                                    "text": "fake work",
+                                    "text_elements": [],
+                                }
+                            ],
+                        },
+                    },
+                    {},
+                )
+                history = root / "fake-history.json"
+
+                def recovered():
+                    turns = json.loads(history.read_text())["threads"][thread]["turns"]
+                    return len(turns) == 2 and turns[-1]["status"] == "completed"
+
+                await wait_for(recovered)
+                self.assertEqual(c.account.label, "two")
+                self.assertFalse(c.active_items)
+                self.assertEqual(rpc.proc.pid, initial_pid)
+                self.assertIsNone(rpc.proc.returncode)
+            finally:
+                if c.recovery:
+                    await asyncio.gather(c.recovery, return_exceptions=True)
+                await rpc.close()
+
+    def controller(self):
+        c = Controller(
+            [FakeAccount("one"), FakeAccount("two")],
+            FakeBackend(),
+            report=lambda _: None,
+        )
+        c.client = FakeClient()
+        c.last_turn["thread-1"] = {"threadId": "thread-1"}
+        c.preferences["watchdog_interval"] = 0.01
+        return c
+
+    async def started(self, c, ident="tool", thread="thread-1"):
+        await c.event(
+            {
+                "method": "item/started",
+                "params": {
+                    "threadId": thread,
+                    "item": {
+                        "id": ident,
+                        "type": "commandExecution",
+                        "status": "inProgress",
+                    },
+                },
+            }
+        )
+
+    def history(self, c, status="completed", view="full", ident="tool"):
+        original = c.backend.call
+
+        async def call(method, params=None, **kw):
+            if method == "thread/turns/list" and params.get("itemsView") == "full":
+                return {
+                    "data": [
+                        {
+                            "itemsView": view,
+                            "items": [
+                                {
+                                    "id": ident,
+                                    "type": "commandExecution",
+                                    "status": status,
+                                }
+                            ],
+                        }
+                    ]
+                }
+            return await original(method, params, **kw)
+
+        c.backend.call = call
+
+    async def test_quota_after_lost_completion_switches_and_continues_same_thread(self):
+        c = self.controller()
+        await self.started(c)
+        self.history(c)
+        await c.event(completed())
+        await asyncio.wait_for(c.recovery, 1)
+        self.assertFalse(c.active_items)
+        self.assertEqual(c.account.label, "two")
+        turns = [p for m, p in c.backend.calls if m == "turn/start"]
+        self.assertEqual(len(turns), 1)
+        self.assertEqual(turns[0]["threadId"], "thread-1")
+
+    async def test_running_missing_and_summary_items_remain_blocking(self):
+        for status, view, ident in (
+            ("inProgress", "full", "tool"),
+            ("completed", "summary", "tool"),
+            ("completed", "full", "different"),
+            (None, "full", "tool"),
+        ):
+            c = self.controller()
+            await self.started(c)
+            self.history(c, status, view, ident)
+            await c.reconcile_active_items()
+            self.assertEqual(c.active_items, {"tool"})
+
+    async def test_finished_tool_does_not_clear_pending_approval_or_child_thread(self):
+        c = self.controller()
+        await self.started(c)
+        c.server_requests.add(7)
+        c.active_threads.add("child")
+        self.history(c)
+        await c.reconcile_active_items()
+        self.assertFalse(c.active_items)
+        self.assertEqual(c.server_requests, {7})
+        self.assertEqual(c.active_threads, {"child"})
+        self.assertFalse(any(m == "account/login/start" for m, _ in c.backend.calls))
+
+    async def test_new_start_during_history_read_invalidates_the_read(self):
+        c = self.controller()
+        await self.started(c)
+
+        async def call(method, params=None, **kw):
+            await self.started(c, "new")
+            return {
+                "data": [
+                    {
+                        "itemsView": "full",
+                        "items": [
+                            {
+                                "id": "tool",
+                                "type": "commandExecution",
+                                "status": "completed",
+                            }
+                        ],
+                    }
+                ]
+            }
+
+        c.backend.call = call
+        await c.reconcile_active_items()
+        self.assertEqual(c.active_items, {"tool", "new"})
+
+    async def test_full_history_pages_until_matching_item_and_stops_on_repeated_cursor(
+        self,
+    ):
+        c = self.controller()
+        await self.started(c)
+        calls = []
+
+        async def call(method, params=None, **kw):
+            calls.append(params)
+            if not params.get("cursor"):
+                return {"data": [], "nextCursor": "older"}
+            return {
+                "data": [
+                    {
+                        "itemsView": "full",
+                        "items": [
+                            {
+                                "id": "tool",
+                                "type": "commandExecution",
+                                "status": "failed",
+                            }
+                        ],
+                    }
+                ]
+            }
+
+        c.backend.call = call
+        await c.reconcile_active_items()
+        self.assertFalse(c.active_items)
+        self.assertEqual(len(calls), 2)
+        await self.started(c)
+        calls.clear()
+
+        async def repeated(method, params=None, **kw):
+            calls.append(params)
+            return {"data": [], "nextCursor": "same"}
+
+        c.backend.call = repeated
+        await c.reconcile_active_items()
+        self.assertEqual(len(calls), 2)
+        self.assertEqual(c.active_items, {"tool"})
+
+    async def test_failed_read_and_unowned_item_never_clear_activity(self):
+        c = self.controller()
+        await self.started(c)
+        c.active_items.add("unknown-owner")
+
+        async def failed(*args, **kwargs):
+            raise RouterError("unavailable")
+
+        c.backend.call = failed
+        await c.reconcile_active_items()
+        self.assertEqual(c.active_items, {"tool", "unknown-owner"})
+
+    async def test_completion_and_terminal_start_do_not_leave_stale_ownership(self):
+        c = self.controller()
+        await self.started(c)
+        await c.event(
+            {
+                "method": "item/completed",
+                "params": {"threadId": "thread-1", "item": {"id": "tool"}},
+            }
+        )
+        self.assertFalse(c.active_item_threads)
+        await c.event(
+            {
+                "method": "item/started",
+                "params": {
+                    "threadId": "thread-1",
+                    "item": {
+                        "id": "already-done",
+                        "type": "commandExecution",
+                        "status": "completed",
+                    },
+                },
+            }
+        )
+        self.assertFalse(c.active_items)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_audit.py

@@ -246,6 +246,7 @@ class WorkerRegressions(unittest.IsolatedAsyncioTestCase):
             c.task = asyncio.create_task(service.serve(c.state, c.ident, c.binary))
             await wait_for(c.meta.exists)
         self.assertEqual(observed[0]["approvalsReviewer"], "auto_review")
+        self.assertTrue(observed[0]["excludeTurns"])
         self.assertIn("/private/tmp/audit-extra", observed[0]["runtimeWorkspaceRoots"])
         pool.close()