relay-codex 0.5.0 → 0.5.2

package/docs/commands.md

@@ -97,6 +97,8 @@ The watch view waits for local file changes and redraws only when useful status
 changes. Heartbeats do not repeatedly print the table. Watching uses no model
 allowance and does not fetch account allowance. `refresh` explicitly checks it.
 The menu uses one local status stream, a template icon, and native session actions.
+Opening it reads a fresh local snapshot, and visible rows update in place.
+Short-window and weekly allowance are labeled separately.
 It opens at Mac login after `relay menubar`; disable that in its menu or with
 `relay menubar --no-startup --configure-only`.
 
@@ -122,6 +124,10 @@ A workspace saves the same supervised session IDs, rather than starting fresh
 conversations. Restore restarts stopped jobs and prints reconnect commands; live
 jobs are retained. Save specific sessions by appending their IDs to `workspace save`.
 
+Foreground jobs close after their launcher disappears and current activity is
+idle. Explicit background tasks and takeovers remain running. An interrupted action
+is retained for review rather than being silently retried.
+
 The normal command remains available after reboot. Background task recovery at
 login is a separate opt-in setting; enabling the menu does not enable task startup.
 Uncertain work still pauses for review after recovery.

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

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "relay-codex",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Keep your Codex sessions moving between your own accounts.",
   "license": "MIT",
   "author": "blackspider-ops",
   "repository": {
     "type": "git",
-    "url": "https://github.com/blackspider-ops/relay.git"
+    "url": "git+https://github.com/blackspider-ops/relay.git"
   },
   "homepage": "https://github.com/blackspider-ops/relay#readme",
   "bugs": {

package/python/Menu.swift

@@ -8,6 +8,7 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
     var message: String?
     var reconnect: DispatchWorkItem?
     var stopping = false
+    var snapshotInFlight = false
     let command = Bundle.main.object(forInfoDictionaryKey: "RelayCommand") as? String ?? "/usr/bin/false"
     let state = Bundle.main.object(forInfoDictionaryKey: "RelayState") as? String ?? ""
 
@@ -61,10 +62,56 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         while let newline = buffer.firstIndex(of: 10) {
             let line = buffer.prefix(upTo: newline); buffer.removeSubrange(...newline)
             if let value = (try? JSONSerialization.jsonObject(with: line)) as? [String: Any] {
-                current = value; message = nil; render()
+                if (value["at"] as? Double ?? 0) >= (current["at"] as? Double ?? 0) { current = value; message = nil; render() }
             }
         }
     }
+    func refreshSnapshot() {
+        guard !snapshotInFlight, !stopping else { return }
+        snapshotInFlight = true
+        let proc = process(["status", "--json"])
+        let pipe = Pipe(); proc.standardOutput = pipe; proc.standardError = FileHandle.nullDevice
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            var snapshot: [String: Any]?
+            do {
+                try proc.run()
+                let timeout = DispatchWorkItem { if proc.isRunning { proc.terminate() } }
+                DispatchQueue.global(qos: .utility).asyncAfter(deadline: .now() + 8, execute: timeout)
+                let bytes = pipe.fileHandleForReading.readDataToEndOfFile(); proc.waitUntilExit(); timeout.cancel()
+                if proc.terminationStatus == 0 { snapshot = (try? JSONSerialization.jsonObject(with: bytes)) as? [String: Any] }
+            } catch { }
+            let result = snapshot
+            DispatchQueue.main.async {
+                guard let self = self else { return }
+                self.snapshotInFlight = false
+                if let value = result {
+                    let at = value["at"] as? Double ?? 0
+                    if at >= (self.current["at"] as? Double ?? 0) { self.current = value; self.render() }
+                }
+            }
+        }
+    }
+    static func synchronise(_ live: NSMenu, with desired: NSMenu) {
+        let incoming = desired.items
+        while live.items.count > incoming.count { live.removeItem(at: live.items.count - 1) }
+        for (index, fresh) in incoming.enumerated() {
+            if index >= live.items.count {
+                desired.removeItem(fresh); live.addItem(fresh); continue
+            }
+            let existing = live.items[index]
+            if existing.isSeparatorItem != fresh.isSeparatorItem || existing.identifier != fresh.identifier {
+                live.removeItem(at: index); desired.removeItem(fresh); live.insertItem(fresh, at: index); continue
+            }
+            existing.title = fresh.title; existing.state = fresh.state
+            existing.target = fresh.target; existing.action = fresh.action
+            existing.keyEquivalent = fresh.keyEquivalent; existing.isEnabled = fresh.isEnabled
+            existing.representedObject = fresh.representedObject; existing.toolTip = fresh.toolTip
+            if let child = fresh.submenu {
+                if let previous = existing.submenu { synchronise(previous, with: child) }
+                else { fresh.submenu = nil; existing.submenu = child }
+            } else { existing.submenu = nil }
+        }
+    }
     func updateIcon(attention: Bool) {
         let symbol = attention ? "exclamationmark.circle.fill" : "arrow.triangle.branch"
         let image = NSImage(systemSymbolName: symbol, accessibilityDescription: attention ? "Relay needs attention" : "Relay")
@@ -72,11 +119,13 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         item.button?.image = image
     }
     func text(_ title: String, into menu: NSMenu) {
-        menu.addItem(NSMenuItem(title: title, action: nil, keyEquivalent: ""))
+        let entry = NSMenuItem(title: title, action: nil, keyEquivalent: "")
+        entry.isEnabled = false; menu.addItem(entry)
     }
     func action(_ title: String, args: [String], into menu: NSMenu) {
         let entry = NSMenuItem(title: title, action: #selector(runAction(_:)), keyEquivalent: "")
-        entry.target = self; entry.representedObject = args; menu.addItem(entry)
+        entry.target = self; entry.representedObject = args
+        entry.identifier = NSUserInterfaceItemIdentifier("action:" + args.joined(separator: "|")); menu.addItem(entry)
     }
     func date(_ value: Any?) -> String {
         guard let seconds = value as? Double else { return "unknown" }
@@ -110,23 +159,28 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         for account in accounts {
             let name = account["name"] as? String ?? "Account"
             let primary = account["primary"] as? [String: Any]
-            let remaining = (primary?["usedPercent"] as? NSNumber).map { "\(max(0, 100 - $0.intValue))% left" } ?? "allowance unknown"
-            let label = (account["enabled"] as? Bool ?? true) ? remaining : "disabled"
+            let short = account["short_remaining"] as? String ?? (primary?["usedPercent"] as? NSNumber).map { "\(max(0, 100 - $0.intValue))%" } ?? "?"
+            let remaining = short == "?" ? "allowance unknown" : short + " left"
+            let secondary = account["secondary"] as? [String: Any]
+            let weekly = account["weekly_remaining"] as? String ?? (secondary?["usedPercent"] as? NSNumber).map { "\(max(0, 100 - $0.intValue))%" } ?? "?"
+            let label = (account["enabled"] as? Bool ?? true) ? "Short \(short) · Week \(weekly)" : "disabled"
             let submenu = NSMenu()
             if let email = account["email"] as? String { text(email, into: submenu) }
             text("Short window: \(remaining)", into: submenu)
-            if let secondary = account["secondary"] as? [String: Any], let used = secondary["usedPercent"] as? NSNumber { text("Weekly window: \(max(0, 100 - used.intValue))% left", into: submenu) }
+            if weekly != "?" { text("Weekly window: \(weekly) left", into: submenu) }
             if let reset = account["next_check"] { countdown("Next check", value: reset, into: submenu) }
             text("Last checked: \(date(account["usage_checked_at"]))", into: submenu)
-            let entry = NSMenuItem(title: "\(name) · \(label)", action: nil, keyEquivalent: ""); entry.submenu = submenu; menu.addItem(entry)
+            let entry = NSMenuItem(title: "\(name) · \(label)", action: nil, keyEquivalent: "")
+            entry.identifier = NSUserInterfaceItemIdentifier("account:" + (account["id"] as? String ?? name))
+            entry.submenu = submenu; menu.addItem(entry)
         }
-        menu.addItem(.separator())
+        if !sessions.isEmpty { menu.addItem(.separator()) }
         for session in sessions {
             let id = session["id"] as? String ?? ""
             let name = session["name"] as? String ?? String(id.prefix(10))
             let status = (session["state"] as? String ?? "unknown").replacingOccurrences(of: "_", with: " ")
             let submenu = NSMenu()
-            text("Account: \(session["account"] as? String ?? "unknown")", into: submenu)
+            text("Account: \(session["account_name"] as? String ?? session["account"] as? String ?? "unknown")", into: submenu)
             text("Model: \(session["model"] as? String ?? "unknown")", into: submenu)
             if let next = session["next_wake"] { countdown("Next action", value: next, into: submenu) }
             if let reason = session["reason"] as? String { text(reason.replacingOccurrences(of: "_", with: " "), into: submenu) }
@@ -134,7 +188,9 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
             action("Pause recovery", args: ["pause", id, "--wait"], into: submenu)
             action("Resume recovery", args: ["unpause", id, "--wait"], into: submenu)
             action("Review and retry…", args: ["confirm-retry", id], into: submenu)
-            let entry = NSMenuItem(title: "\(name) · \(status)", action: nil, keyEquivalent: ""); entry.submenu = submenu; menu.addItem(entry)
+            let entry = NSMenuItem(title: "\(name) · \(status)", action: nil, keyEquivalent: "")
+            entry.identifier = NSUserInterfaceItemIdentifier("session:" + id)
+            entry.submenu = submenu; menu.addItem(entry)
         }
         menu.addItem(.separator())
         action("Copy dashboard command", args: ["copy", "relay status --watch"], into: menu)
@@ -143,9 +199,11 @@ final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
         login.state = FileManager.default.fileExists(atPath: NSHomeDirectory() + "/Library/LaunchAgents/local.relay.menu.plist") ? .on : .off
         menu.addItem(login)
         let quit = NSMenuItem(title: "Quit Relay menu", action: #selector(quitMenu), keyEquivalent: "q"); quit.target = self; menu.addItem(quit)
-        item.menu = menu
+        if let visible = item.menu { MenuController.synchronise(visible, with: menu) }
+        else { item.menu = menu }
     }
     func menuWillOpen(_ menu: NSMenu) {
+        refreshSnapshot()
         updateTimes(menu)
         for entry in menu.items where entry.title == "Open at login" {
             entry.state = FileManager.default.fileExists(atPath: NSHomeDirectory() + "/Library/LaunchAgents/local.relay.menu.plist") ? .on : .off
@@ -181,7 +239,19 @@ if CommandLine.arguments.contains("--self-check") {
     let normal = NSImage(systemSymbolName: "arrow.triangle.branch", accessibilityDescription: "Relay")
     let attention = NSImage(systemSymbolName: "exclamationmark.circle.fill", accessibilityDescription: "Relay needs attention")
     print("Relay menu symbols available: \(normal != nil && attention != nil)")
-    exit(normal != nil && attention != nil ? 0 : 1)
+    let visible = NSMenu(); visible.addItem(NSMenuItem(title: "Short 83%", action: nil, keyEquivalent: ""))
+    let existing = visible.items[0]
+    let updated = NSMenu(); updated.addItem(NSMenuItem(title: "Short 30%", action: nil, keyEquivalent: ""))
+    MenuController.synchronise(visible, with: updated)
+    let liveUpdate = visible.items[0] === existing && existing.title == "Short 30%"
+    print("Visible menu update preserved: \(liveUpdate)")
+    existing.identifier = NSUserInterfaceItemIdentifier("session:old")
+    let replacement = NSMenu(); let newItem = NSMenuItem(title: "New task", action: nil, keyEquivalent: "")
+    newItem.identifier = NSUserInterfaceItemIdentifier("session:new"); replacement.addItem(newItem)
+    MenuController.synchronise(visible, with: replacement)
+    let safeIdentity = visible.items[0] !== existing && visible.items[0].identifier == newItem.identifier
+    print("Session action identity preserved: \(safeIdentity)")
+    exit(normal != nil && attention != nil && liveUpdate && safeIdentity ? 0 : 1)
 } else {
     let app = NSApplication.shared
     let delegate = MenuController(); app.delegate = delegate; app.run()

package/python/commands.py

@@ -68,6 +68,13 @@ def resolve_label(state, value):
     raise RouterError("Unknown or ambiguous account name")
 
 
+def remaining_percent(window):
+    if not window or not isinstance(window.get("usedPercent"), (int, float)):
+        return "?"
+    value = max(0, min(100, 100 - window["usedPercent"]))
+    return f"{value:.1f}".rstrip("0").rstrip(".") + "%"
+
+
 def snapshot(state, include_inactive=False):
     from router import labels, VERSION
 
@@ -99,6 +106,8 @@ def snapshot(state, include_inactive=False):
                     "sessions": sum(s["account"] == label for s in sessions),
                     "primary": windows.get("primary"),
                     "secondary": windows.get("secondary"),
+                    "short_remaining": remaining_percent(windows.get("primary")),
+                    "weekly_remaining": remaining_percent(windows.get("secondary")),
                     "usage_known": usage is not None,
                     "usage_checked_at": pool.checked_at(label),
                     "maintenance": options.get("maintenance", False),
@@ -110,6 +119,13 @@ def snapshot(state, include_inactive=False):
             )
         with pool.db() as db:
             for session in sessions:
+                account = next(
+                    (a for a in accounts if a["id"] == session.get("account")), {}
+                )
+                session["account_name"] = account.get(
+                    "name", session.get("account", "")
+                )
+                session["account_email"] = account.get("email")
                 saved_intent = db.execute(
                     "SELECT details FROM intents WHERE owner=? AND thread=?",
                     (session["id"], session.get("thread", "")),
@@ -165,10 +181,6 @@ def snapshot(state, include_inactive=False):
 
 
 def render(value):
-    def percent(window):
-        return (
-            "?" if not window else str(max(0, 100 - window.get("usedPercent", 0))) + "%"
-        )
 
     lines = [
         f"Relay · {len(value['sessions'])} sessions · {len(value['accounts'])} accounts",
@@ -193,16 +205,16 @@ def render(value):
             else "—"
         )
         lines.append(
-            f"{label:<39}{state:<13}{percent(account['primary']):<13}{percent(account['secondary']):<13}{account['sessions']:<10}{next_at}"
+            f"{label:<39}{state:<13}{account.get('short_remaining', remaining_percent(account['primary'])):<13}{account.get('weekly_remaining', remaining_percent(account['secondary'])):<13}{account['sessions']:<10}{next_at}"
         )
     if value["sessions"]:
         lines += [
             "",
-            f"{'SESSION':<12}{'ACCOUNT':<14}{'STATE':<23}{'MODEL':<23}PROJECT / NAME",
+            f"{'SESSION':<12}{'ACCOUNT':<32}{'STATE':<23}{'MODEL':<23}PROJECT / NAME",
         ]
         for row in value["sessions"]:
             lines.append(
-                f"{row['id'][:10]:<12}{row.get('account', ''):<14}{str(row.get('state', 'unknown'))[:22]:<23}{str(row.get('model') or '?')[:22]:<23}{row.get('cwd') or row.get('name') or ''}"
+                f"{row['id'][:10]:<12}{str(row.get('account_name') or row.get('account', '')):<32}{str(row.get('state', 'unknown'))[:22]:<23}{str(row.get('model') or '?')[:22]:<23}{row.get('cwd') or row.get('name') or ''}"
             )
             if row.get("next_wake"):
                 lines.append(

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.5.0"
+VERSION = "0.5.2"
 _support = Path.home() / "Library/Application Support"
 _legacy = _support / "Codex Accounts"
 _default_state = _legacy if (_legacy / "accounts").exists() else _support / "Relay"
@@ -427,6 +427,8 @@ class Controller:
         self.stopping = asyncio.Event()
         self.extra_accounts = None
         self.starting = False
+        self.lifecycle_check = None
+        self.exit_state = "stopped"
         self.on_thread = None
         self.on_detach = None
         self.project = os.getcwd()
@@ -435,6 +437,17 @@ class Controller:
         self.awake_process = None
         self.fallback_tried = {}
 
+    def account_name(self):
+        if self.pool:
+            from commands import account_identity
+
+            return (
+                account_identity(self.pool.state, self.account.label).get("email")
+                or self.pool.options(self.account.label).get("name")
+                or self.account.label
+            )
+        return self.account.label
+
     def attached(self):
         return bool(self.client) or self.background or self.starting
 
@@ -457,7 +470,7 @@ class Controller:
         if self.preferences.get("notifications"):
             from notifications import notify
 
-            notify(kind, self.account.label)
+            notify(kind, self.account_name())
 
     def merge_settings(self, thread, params):
         allowed = {
@@ -514,6 +527,8 @@ class Controller:
 
     def clear_review(self, thread):
         self.paused_uncertain.discard(thread)
+        if not self.paused_uncertain:
+            self.exit_state = "stopped"
         self.persist(thread, review_required=False, review_reason=None)
 
     def can_continue(self, thread, generation):
@@ -670,6 +685,10 @@ class Controller:
                     except Exception:
                         self.pool.ack(command, "failed")
                         self.note("control_failed", operation=op)
+            if self.lifecycle_check:
+                await self.lifecycle_check()
+                if self.stopping.is_set():
+                    break
             if self.preferences.get("keep_awake") and self.active_threads:
                 if (
                     self.awake_process is None
@@ -727,6 +746,7 @@ class Controller:
             self.wake.set()
             self.note("resumed")
         elif op == "stop":
+            self.exit_state = "stopped"
             self.stopping.set()
         elif op == "detach":
             if self.pool:
@@ -792,6 +812,8 @@ class Controller:
             self.note("switched", to=label)
         elif op == "retry":
             self.paused = False
+            if thread:
+                self.clear_review(thread)
             self.wake.set()
             if self.recovery and not self.recovery.done():
                 self.force_retry.set()
@@ -803,7 +825,6 @@ class Controller:
                 )
                 self.pool.invalidate(self.account.label)
             if thread and (not self.recovery or self.recovery.done()):
-                self.clear_review(thread)
                 self.recovery = asyncio.create_task(
                     self.continue_thread(thread, self.user_generation)
                 )
@@ -1173,7 +1194,7 @@ class Controller:
             raise
         except (RouterError, asyncio.TimeoutError):
             return await self.uncertain(thread, generation, baseline)
-        self.report(f"Continued the saved thread with {self.account.label}.")
+        self.report(f"Continued the saved thread with {self.account_name()}.")
 
     async def restore_recovery(self, thread, persisted):
         """Honor an accepted retry's original deadline after a process restart."""
@@ -1383,7 +1404,7 @@ class Controller:
                     episode["attempt"] += 1
                     target = episode["start"] + episode["attempt"] * self.retry_interval
                     self.report(
-                        f"Service/authentication failure on {self.account.label}. Retry {episode['attempt']}/{self.retry_attempts} at {time.strftime('%H:%M:%S', time.localtime(target))}."
+                        f"Service/authentication failure on {self.account_name()}. Retry {episode['attempt']}/{self.retry_attempts} at {time.strftime('%H:%M:%S', time.localtime(target))}."
                     )
                     self.note(
                         "retry_scheduled",
@@ -1416,7 +1437,7 @@ class Controller:
                 )
             self.episodes.pop(thread, None)
             self.report(
-                f"Selecting another account after {kind} failure on {self.account.label}."
+                f"Selecting another account after {kind} failure on {self.account_name()}."
             )
             self.note("selecting_account", thread=thread, reason=kind)
             await self.mark(self.index, model, kind)

package/python/service.py

@@ -51,6 +51,10 @@ def start(
         "interactive": interactive,
         "binary": binary,
         "relay_runtime": str(Path(__file__).parent.resolve()),
+        "foreground_owner": {"pid": os.getpid(), "birth": process_birth(os.getpid())}
+        if interactive
+        else None,
+        "background_launch": not interactive,
     }
     if not Path(spec["cwd"]).is_dir():
         raise ValueError("Working directory does not exist")
@@ -155,6 +159,21 @@ async def attach(
     spec_path = root / (ident + ".job.json")
     spec = json.loads(spec_path.read_text())
     binary = spec.get("binary") or binary
+    owner = spec.get("foreground_owner")
+    if (
+        spec.get("interactive")
+        and not spec.get("background_launch")
+        and owner
+        and not (
+            Pool.alive(owner["pid"])
+            and process_birth(owner["pid"]) == owner.get("birth")
+        )
+    ):
+        spec["foreground_owner"] = {
+            "pid": os.getpid(),
+            "birth": process_birth(os.getpid()),
+        }
+        atomic_json(spec_path, spec)
     meta = root / (ident + ".connection.json")
     invocation_cwd = cwd
     reconnect = False
@@ -353,7 +372,7 @@ def restart(state, prefix):
     spec = json.loads(path.read_text())
     if not Path(spec["cwd"]).is_dir():
         raise RouterError("The project folder no longer exists")
-    spec.update(state="starting")
+    spec.update(state="starting", background_launch=True, foreground_owner=None)
     spec.pop("last_error", None)
     atomic_json(path, spec)
     process = spawn(
@@ -378,6 +397,54 @@ def restart(state, prefix):
     return ident
 
 
+def foreground_owner_gone(spec, preferences, controller, *, now=None):
+    """Foreground jobs must not outlive a vanished launcher unless explicitly detached."""
+    if (
+        not spec.get("interactive")
+        or spec.get("background_launch")
+        or spec.get("takeover")
+        or preferences.get("background_on_disconnect")
+        or controller.client
+    ):
+        return False
+    owner = spec.get("foreground_owner")
+    if owner:
+        return not (
+            Pool.alive(owner["pid"])
+            and process_birth(owner["pid"]) == owner.get("birth")
+        )
+    # Earlier jobs did not record a launcher. Only retire a definitely empty,
+    # unattached picker; retain older conversations whose ownership is uncertain.
+    return (
+        not spec.get("resume")
+        and not controller.last_turn
+        and (time.time() if now is None else now) - spec.get("created", time.time())
+        > 60
+    )
+
+
+async def close_orphaned_foreground(controller, spec_path):
+    spec = json.loads(spec_path.read_text())
+    if not foreground_owner_gone(spec, controller.preferences, controller):
+        return
+    if (
+        controller.active_threads
+        or controller.active_items
+        or controller.server_requests
+    ):
+        for thread in controller.last_turn:
+            controller.hold_for_review(thread, "terminal_closed_during_action")
+        controller.exit_state = "needs_attention"
+        if not getattr(controller, "orphan_reported", False):
+            controller.note("needs_attention", reason="terminal_closed_during_action")
+            controller.orphan_reported = True
+        return
+    controller.note("foreground_closed", reason="launcher_exited")
+    spec["state"] = controller.exit_state
+    atomic_json(spec_path, spec)
+    controller.stopping.set()
+
+
 async def _serve(state, ident, binary):
     from websockets.asyncio.server import serve as ws_serve
     from router import (
@@ -456,6 +523,9 @@ async def _serve(state, ident, binary):
         return new or old
 
     controller.extra_accounts = reload_accounts
+    controller.lifecycle_check = lambda: close_orphaned_foreground(
+        controller, spec_path
+    )
     controller.preferences = settings.load(state, cwd, spec.get("profile"))
     controller.retry_interval = controller.preferences["retry_interval"]
     controller.retry_attempts = controller.preferences["retry_attempts"]
@@ -513,6 +583,9 @@ async def _serve(state, ident, binary):
                 pool.touch(state="waiting_for_reset", next_wake=deadline)
                 await controller.wait_until(deadline, controller.user_generation)
         if controller.stopping.is_set():
+            latest = json.loads(spec_path.read_text())
+            latest["state"] = controller.exit_state
+            atomic_json(spec_path, latest)
             return 0
         controller.backend_factory = factory
         thread_id = old_thread or spec.get("resume")
@@ -688,7 +761,7 @@ async def _serve(state, ident, binary):
             # have been reconciled. A frontend must not race recovery setup.
             atomic_json(connection, meta)
             await controller.stopping.wait()
-        spec["state"] = "stopped"
+        spec["state"] = controller.exit_state
         atomic_json(spec_path, spec)
         return 0
     finally:

package/tests/test_audit.py

@@ -45,6 +45,31 @@ class RecoveryRegressions(unittest.IsolatedAsyncioTestCase):
             self.assertTrue(any(method == "turn/start" for method, _ in backend.calls))
             pool.close()
 
+    async def test_explicit_retry_clears_a_review_hold_during_an_existing_timer(self):
+        with tempfile.TemporaryDirectory() as folder:
+            pool = Pool(Path(folder))
+            backend = FakeBackend()
+            c = Controller(
+                [FakeAccount("one")], backend, pool=pool, report=lambda _: None
+            )
+            c.client = FakeClient()
+            c.last_turn["thread-1"] = {"threadId": "thread-1"}
+            c.recovery = asyncio.create_task(c.recover("thread-1", 0, "capacity"))
+            try:
+                while not c.episodes:
+                    await asyncio.sleep(0)
+                c.hold_for_review("thread-1")
+                await c.control("retry", {"thread": "thread-1"})
+                await asyncio.wait_for(c.recovery, 1)
+                self.assertFalse(pool.intent("thread-1")["review_required"])
+                self.assertEqual(
+                    sum(method == "turn/start" for method, _ in backend.calls), 1
+                )
+            finally:
+                c.recovery.cancel()
+                await asyncio.gather(c.recovery, return_exceptions=True)
+                pool.close()
+
     async def test_picker_permission_control_applies_before_thread_selection(self):
         c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
         c.launch_overrides = {
@@ -318,3 +343,89 @@ class AttachmentRegressions(unittest.IsolatedAsyncioTestCase):
         self.assertFalse(
             parse_arguments(["attach", "task", "--", "--takeover"]).takeover
         )
+
+
+class ForegroundLifecycleTests(unittest.IsolatedAsyncioTestCase):
+    async def test_closed_launcher_retires_an_empty_idle_foreground_job(self):
+        with tempfile.TemporaryDirectory() as folder:
+            path = Path(folder) / "job.json"
+            job = {
+                "interactive": True,
+                "foreground_owner": {"pid": 99999999, "birth": "gone"},
+                "state": "starting",
+            }
+            atomic_json(path, job)
+            c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
+            await service.close_orphaned_foreground(c, path)
+            self.assertTrue(c.stopping.is_set())
+            self.assertEqual(json.loads(path.read_text())["state"], "stopped")
+
+    async def test_real_launcher_background_preference_and_takeover_are_preserved(self):
+        c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
+        job = {
+            "interactive": True,
+            "foreground_owner": {
+                "pid": os.getpid(),
+                "birth": process_birth(os.getpid()),
+            },
+        }
+        self.assertFalse(service.foreground_owner_gone(job, c.preferences, c))
+        dead = {**job, "foreground_owner": {"pid": 99999999, "birth": "gone"}}
+        for field in ("background_launch", "takeover"):
+            self.assertFalse(
+                service.foreground_owner_gone({**dead, field: True}, c.preferences, c)
+            )
+        self.assertFalse(
+            service.foreground_owner_gone(
+                dead, {**c.preferences, "background_on_disconnect": True}, c
+            )
+        )
+        c.client = FakeClient()
+        self.assertFalse(service.foreground_owner_gone(dead, c.preferences, c))
+
+    async def test_orphaned_active_action_requires_review_and_is_not_killed(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            path = state / "job.json"
+            pool = Pool(state)
+            atomic_json(
+                path,
+                {
+                    "interactive": True,
+                    "foreground_owner": {"pid": 99999999, "birth": "gone"},
+                },
+            )
+            c = Controller(
+                [FakeAccount("one")], FakeBackend(), pool=pool, report=lambda _: None
+            )
+            c.last_turn["thread"] = {"threadId": "thread"}
+            c.active_items.add("command")
+            await service.close_orphaned_foreground(c, path)
+            self.assertFalse(c.stopping.is_set())
+            self.assertTrue(pool.intent("thread")["review_required"])
+            c.active_items.clear()
+            await service.close_orphaned_foreground(c, path)
+            self.assertTrue(c.stopping.is_set())
+            self.assertEqual(json.loads(path.read_text())["state"], "needs_attention")
+            pool.close()
+
+    async def test_explicit_review_or_stop_clears_orphan_exit_status(self):
+        c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
+        c.hold_for_review("thread")
+        c.exit_state = "needs_attention"
+        c.clear_review("thread")
+        self.assertEqual(c.exit_state, "stopped")
+        c.exit_state = "needs_attention"
+        await c.control("stop", {})
+        self.assertEqual(c.exit_state, "stopped")
+
+    def test_legacy_empty_picker_expires_but_saved_conversation_is_retained(self):
+        c = Controller([FakeAccount("one")], FakeBackend(), report=lambda _: None)
+        job = {"interactive": True, "created": 1000}
+        self.assertFalse(service.foreground_owner_gone(job, c.preferences, c, now=1005))
+        self.assertTrue(service.foreground_owner_gone(job, c.preferences, c, now=1100))
+        self.assertFalse(
+            service.foreground_owner_gone(
+                {**job, "resume": "saved"}, c.preferences, c, now=1100
+            )
+        )

package/tests/test_features.py

@@ -85,6 +85,31 @@ class ManagementTests(unittest.TestCase):
             with self.assertRaises(ValueError):
                 prepare_worktree(["resume", "--worktree"], state, str(repo))
 
+    def test_both_displays_receive_the_same_fractional_allowance(self):
+        with tempfile.TemporaryDirectory() as folder:
+            state = Path(folder)
+            home = state / "accounts" / "one"
+            home.mkdir(parents=True)
+            (home / "enrolled").write_text("{}")
+            pool = Pool(state)
+            pool.save(
+                "one",
+                {
+                    "rateLimits": {
+                        "primary": {"usedPercent": 70.2},
+                        "secondary": {"usedPercent": 41.5},
+                    }
+                },
+            )
+            value = commands.snapshot(state)
+            account = value["accounts"][0]
+            self.assertEqual(account["short_remaining"], "29.8%")
+            self.assertEqual(account["weekly_remaining"], "58.5%")
+            text = commands.render(value)
+            self.assertIn(account["short_remaining"], text)
+            self.assertIn(account["weekly_remaining"], text)
+            pool.close()
+
     def test_account_emails_are_displayed_and_resolve_without_reading_tokens(self):
         with tempfile.TemporaryDirectory() as folder:
             state = Path(folder)