relay-codex 0.4.1 → 0.5.1

package/python/Menu.swift

@@ -1,70 +1,188 @@
 import AppKit
 
-final class MenuController: NSObject, NSApplicationDelegate {
+final class MenuController: NSObject, NSApplicationDelegate, NSMenuDelegate {
     var item: NSStatusItem!
-    var timer: Timer?
-    var busy = false
-    let command = CommandLine.arguments.count > 1 ? CommandLine.arguments[1] : (Bundle.main.object(forInfoDictionaryKey: "RelayCommand") as? String ?? "/usr/bin/false")
+    var stream: Process?
+    var buffer = Data()
+    var current: [String: Any] = [:]
+    var message: String?
+    var reconnect: DispatchWorkItem?
+    var stopping = false
+    let command = Bundle.main.object(forInfoDictionaryKey: "RelayCommand") as? String ?? "/usr/bin/false"
+    let state = Bundle.main.object(forInfoDictionaryKey: "RelayState") as? String ?? ""
+
     func applicationDidFinishLaunching(_ notification: Notification) {
+        let others = NSRunningApplication.runningApplications(withBundleIdentifier: "local.relay.menu")
+        if others.contains(where: { $0.processIdentifier != ProcessInfo.processInfo.processIdentifier }) { NSApp.terminate(nil); return }
         NSApp.setActivationPolicy(.accessory)
-        item = NSStatusBar.system.statusItem(withLength: NSStatusItem.variableLength)
-        item.button?.title = "Relay"
-        refresh()
-        timer = Timer.scheduledTimer(withTimeInterval: 30, repeats: true) { [weak self] _ in self?.refresh() }
+        item = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
+        item.button?.title = ""
+        item.button?.setAccessibilityLabel("Relay account and session status")
+        updateIcon(attention: false)
+        render()
+        startStream()
     }
-    @objc func refresh() {
-        if busy { return }; busy = true
-        DispatchQueue.global(qos: .utility).async { [weak self] in
-            guard let self = self else { return }
-            let process = Process(); process.executableURL = URL(fileURLWithPath: self.command)
-            process.arguments = ["status", "--json"]
-            let pipe = Pipe(); process.standardOutput = pipe; process.standardError = FileHandle.nullDevice
-            var value: [String: Any] = [:]
-            do {
-                try process.run()
-                let bytes = pipe.fileHandleForReading.readDataToEndOfFile(); process.waitUntilExit()
-                value = (try? JSONSerialization.jsonObject(with: bytes)) as? [String: Any] ?? [:]
-            } catch { }
-            let result = value
-            DispatchQueue.main.async { self.busy = false; self.render(result) }
+    func process(_ args: [String]) -> Process {
+        let proc = Process()
+        proc.executableURL = URL(fileURLWithPath: command)
+        proc.arguments = args
+        var env = ProcessInfo.processInfo.environment
+        let node = Bundle.main.object(forInfoDictionaryKey: "RelayNodeDirectory") as? String ?? "/opt/homebrew/bin"
+        env["PATH"] = node + ":/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:" + (env["PATH"] ?? "")
+        env["RELAY_STATE"] = state
+        proc.environment = env
+        return proc
+    }
+    func startStream() {
+        guard !stopping else { return }
+        let proc = process(["status", "--watch", "--json"])
+        let pipe = Pipe()
+        proc.standardOutput = pipe; proc.standardError = FileHandle.nullDevice
+        pipe.fileHandleForReading.readabilityHandler = { [weak self] handle in
+            let bytes = handle.availableData
+            guard !bytes.isEmpty else { handle.readabilityHandler = nil; return }
+            DispatchQueue.main.async { self?.receive(bytes) }
+        }
+        proc.terminationHandler = { [weak self] _ in
+            DispatchQueue.main.async {
+                guard let self = self, !self.stopping else { return }
+                self.message = "Status connection interrupted. Retrying in 30 seconds."
+                self.render()
+                let retry = DispatchWorkItem { [weak self] in self?.startStream() }
+                self.reconnect = retry
+                DispatchQueue.main.asyncAfter(deadline: .now() + 30, execute: retry)
+            }
+        }
+        do { buffer.removeAll(); try proc.run(); stream = proc }
+        catch { message = "Relay could not start. Open Terminal and run relay doctor."; render() }
+    }
+    func receive(_ bytes: Data) {
+        buffer.append(bytes)
+        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()
+            }
+        }
+    }
+    func updateIcon(attention: Bool) {
+        let symbol = attention ? "exclamationmark.circle.fill" : "arrow.triangle.branch"
+        let image = NSImage(systemSymbolName: symbol, accessibilityDescription: attention ? "Relay needs attention" : "Relay")
+        image?.isTemplate = true
+        item.button?.image = image
+    }
+    func text(_ title: String, into menu: NSMenu) {
+        menu.addItem(NSMenuItem(title: title, action: nil, keyEquivalent: ""))
+    }
+    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)
+    }
+    func date(_ value: Any?) -> String {
+        guard let seconds = value as? Double else { return "unknown" }
+        return Date(timeIntervalSince1970: seconds).formatted(date: .abbreviated, time: .shortened)
+    }
+    func countdown(_ title: String, value: Any, into menu: NSMenu) {
+        let entry = NSMenuItem(title: title + ": " + date(value), action: nil, keyEquivalent: "")
+        entry.representedObject = ["label": title, "at": value]
+        menu.addItem(entry)
+    }
+    func updateTimes(_ menu: NSMenu) {
+        for entry in menu.items {
+            if let data = entry.representedObject as? [String: Any], let at = data["at"] as? Double, let label = data["label"] as? String {
+                let seconds = max(0, Int(at - Date().timeIntervalSince1970))
+                let remaining = seconds < 60 ? "under a minute" : seconds < 3600 ? "\(seconds / 60)m" : "\(seconds / 3600)h \((seconds % 3600) / 60)m"
+                entry.title = label + ": " + (seconds == 0 ? "due now" : "in " + remaining) + " · " + date(at)
+            }
+            if let child = entry.submenu { updateTimes(child) }
         }
     }
-    func render(_ value: [String: Any]) {
-        let sessions = value["sessions"] as? [[String: Any]] ?? []
-        let accounts = value["accounts"] as? [[String: Any]] ?? []
-        item.button?.title = "Relay \(sessions.count)"
-        let menu = NSMenu()
-        let heading = NSMenuItem(title: "\(sessions.count) sessions · \(accounts.count) accounts", action: nil, keyEquivalent: "")
-        menu.addItem(heading); menu.addItem(.separator())
+    func render() {
+        let sessions = current["sessions"] as? [[String: Any]] ?? []
+        let accounts = current["accounts"] as? [[String: Any]] ?? []
+        let attention = message != nil || sessions.contains { ($0["state"] as? String) == "needs_attention" }
+        updateIcon(attention: attention)
+        item.button?.toolTip = "Relay · \(sessions.count) sessions · \(accounts.count) accounts"
+        let menu = NSMenu(); menu.delegate = self
+        text("Relay · \(sessions.count) sessions", into: menu)
+        if let message = message { text(message, into: menu) }
+        if accounts.isEmpty { text("Add an account with relay setup in Terminal.", into: menu) }
         for account in accounts {
             let name = account["name"] as? String ?? "Account"
             let primary = account["primary"] as? [String: Any]
-            let used = (primary?["usedPercent"] as? NSNumber)?.intValue
-            let remaining = used.map { "\(max(0,100-$0))% left" } ?? "usage unknown"
-            let enabled = account["enabled"] as? Bool ?? true
-            menu.addItem(NSMenuItem(title: "\(name): \(enabled ? remaining : "disabled")", action: nil, keyEquivalent: ""))
+            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 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 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)
         }
+        menu.addItem(.separator())
         for session in sessions {
-            let name = session["name"] as? String ?? String((session["id"] as? String ?? "").prefix(10))
-            let state = session["state"] as? String ?? "unknown"
-            menu.addItem(NSMenuItem(title: "\(name) — \(state)", action: nil, keyEquivalent: ""))
+            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_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) }
+            action("Copy reconnect command", args: ["copy", "relay attach " + id], into: submenu)
+            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)
         }
         menu.addItem(.separator())
-        let copy = NSMenuItem(title: "Copy dashboard command", action: #selector(copyDashboard), keyEquivalent: ""); copy.target=self; menu.addItem(copy)
-        let update = NSMenuItem(title: "Refresh allowance", action: #selector(refreshAllowance), keyEquivalent: ""); update.target=self; menu.addItem(update)
-        let reload = NSMenuItem(title: "Refresh menu", action: #selector(refresh), keyEquivalent: ""); reload.target=self; menu.addItem(reload)
-        let quit = NSMenuItem(title: "Quit menu", action: #selector(quitMenu), keyEquivalent: "q"); quit.target=self; menu.addItem(quit)
-        item.menu=menu
+        action("Copy dashboard command", args: ["copy", "relay status --watch"], into: menu)
+        action("Check allowance now", args: ["refresh"], into: menu)
+        let login = NSMenuItem(title: "Open at login", action: #selector(toggleLogin), keyEquivalent: ""); login.target = self
+        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
     }
-    @objc func copyDashboard() {
-        NSPasteboard.general.clearContents(); NSPasteboard.general.setString("relay status --watch", forType: .string)
+    func menuWillOpen(_ menu: NSMenu) {
+        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
+        }
     }
-    @objc func refreshAllowance() {
-        let process=Process(); process.executableURL=URL(fileURLWithPath:command);process.arguments=["refresh"]
-        process.standardOutput=FileHandle.nullDevice;process.standardError=FileHandle.nullDevice
-        try? process.run()
+    @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] == "confirm-retry" {
+            let alert = NSAlert(); alert.messageText = "Continue this task?"; alert.informativeText = "Review any interrupted command or external action in the conversation before continuing."
+            alert.addButton(withTitle: "Continue task"); alert.addButton(withTitle: "Cancel")
+            NSApp.activate(ignoringOtherApps: true)
+            guard alert.runModal() == .alertFirstButtonReturn else { return }
+            args = ["retry", args[1], "--wait"]
+        }
+        let proc = process(args); let pipe = Pipe(); proc.standardOutput = FileHandle.nullDevice; proc.standardError = pipe
+        DispatchQueue.global(qos: .utility).async { [weak self] in
+            do {
+                try proc.run(); let bytes = pipe.fileHandleForReading.readDataToEndOfFile(); proc.waitUntilExit()
+                if proc.terminationStatus != 0 { DispatchQueue.main.async { self?.message = String(data: bytes, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? "Action failed. Check relay events."; self?.render() } }
+            } catch { DispatchQueue.main.async { self?.message = "Could not run that action."; self?.render() } }
+        }
     }
-    @objc func quitMenu() { NSApp.terminate(nil) }
+    @objc func toggleLogin() {
+        let enabled = FileManager.default.fileExists(atPath: NSHomeDirectory() + "/Library/LaunchAgents/local.relay.menu.plist")
+        runCommand(enabled ? ["menubar", "--no-startup", "--configure-only"] : ["menubar", "--configure-only"])
+    }
+    func runCommand(_ args: [String]) { let proc = process(args); proc.standardOutput = FileHandle.nullDevice; proc.standardError = FileHandle.nullDevice; try? proc.run() }
+    @objc func quitMenu() { stopping = true; reconnect?.cancel(); stream?.terminate(); NSApp.terminate(nil) }
+    func applicationWillTerminate(_ notification: Notification) { stopping = true; stream?.terminate() }
+}
+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)
+} else {
+    let app = NSApplication.shared
+    let delegate = MenuController(); app.delegate = delegate; app.run()
 }
-let app=NSApplication.shared
-let delegate=MenuController(); app.delegate=delegate; app.run()

package/python/commands.py

@@ -13,6 +13,41 @@ from pool import Pool, file_lock
 import settings
 
 
+def account_identity(state, label):
+    from router import account_home
+
+    home = account_home(state, label)
+    for name in ("identity.json", "enrolled"):
+        path = home / name
+        try:
+            value = json.loads(path.read_text())
+            if value.get("email"):
+                return {"email": value["email"]}
+        except (OSError, ValueError):
+            pass
+    return {}
+
+
+def identify_accounts(state):
+    from router import labels, account_home, read_keychain, RouterError
+
+    updated = 0
+    for label in labels(state):
+        if account_identity(state, label).get("email"):
+            continue
+        try:
+            identity = read_keychain(account_home(state, label), include_identity=True)
+        except RouterError:
+            continue
+        if identity.get("email"):
+            settings.atomic_json(
+                account_home(state, label) / "identity.json",
+                {"email": identity["email"]},
+            )
+            updated += 1
+    return updated
+
+
 def resolve_label(state, value):
     from router import labels, RouterError
 
@@ -21,7 +56,10 @@ def resolve_label(state, value):
     pool = Pool(state)
     try:
         matching = [
-            label for label in labels(state) if pool.options(label).get("name") == value
+            label
+            for label in labels(state)
+            if pool.options(label).get("name") == value
+            or account_identity(state, label).get("email") == value
         ]
         if len(matching) == 1:
             return matching[0]
@@ -47,12 +85,14 @@ def snapshot(state, include_inactive=False):
             ]
         for label in labels(state):
             options = pool.options(label)
+            identity = account_identity(state, label)
             usage = pool.cached(label, 86400)
             windows = (usage or {}).get("rateLimits", {})
             accounts.append(
                 {
                     "id": label,
-                    "name": options.get("name", label),
+                    "name": options.get("name") or identity.get("email") or label,
+                    "email": identity.get("email"),
                     "enabled": options.get("enabled", True),
                     "priority": options.get("priority", 0),
                     "max_sessions": options.get("max_sessions", 0),
@@ -60,13 +100,34 @@ def snapshot(state, include_inactive=False):
                     "primary": windows.get("primary"),
                     "secondary": windows.get("secondary"),
                     "usage_known": usage is not None,
+                    "usage_checked_at": pool.checked_at(label),
                     "maintenance": options.get("maintenance", False),
-                    "next_check": max(
+                    "next_check": min(
                         (b["next_check"] for b in blocks if b["account"] == label),
                         default=None,
                     ),
                 }
             )
+        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", "")),
+                ).fetchone()
+                intent = json.loads(saved_intent[0]) if saved_intent else {}
+                session["reason"] = intent.get("review_reason") or intent.get("kind")
+                session["attempt"] = (intent.get("episode") or {}).get("attempt")
+                session["review_required"] = intent.get("review_required", False)
+                if session["review_required"]:
+                    session["state"] = "needs_attention"
+                session.setdefault("recovery_enabled", True)
         active = {s["id"] for s in sessions}
         with pool.db() as db:
             saved = {
@@ -119,13 +180,13 @@ def render(value):
     lines = [
         f"Relay · {len(value['sessions'])} sessions · {len(value['accounts'])} accounts",
         "",
-        f"{'ACCOUNT':<23}{'STATE':<13}{'SHORT LEFT':<13}{'WEEK LEFT':<13}{'SESSIONS':<10}NEXT CHECK",
+        f"{'ACCOUNT':<39}{'STATE':<13}{'SHORT LEFT':<13}{'WEEK LEFT':<13}{'SESSIONS':<10}NEXT CHECK",
     ]
     for account in value["accounts"]:
         label = (
             account["name"]
             + (" [" + account["id"] + "]" if account["name"] != account["id"] else "")
-        )[:22]
+        )[:38]
         state = (
             "maintenance"
             if account["maintenance"]
@@ -139,16 +200,16 @@ def render(value):
             else "—"
         )
         lines.append(
-            f"{label:<23}{state:<13}{percent(account['primary']):<13}{percent(account['secondary']):<13}{account['sessions']:<10}{next_at}"
+            f"{label:<39}{state:<13}{percent(account['primary']):<13}{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(
@@ -163,17 +224,30 @@ def render(value):
 
 
 async def status(args, state):
-    while True:
-        value = snapshot(state, getattr(args, "all", False))
-        if args.json:
-            print(json.dumps(value, indent=None if args.watch else 2), flush=True)
-        else:
-            if args.watch and sys.stdout.isatty():
-                print("\033[2J\033[H", end="")
-            print(render(value), flush=True)
-        if not args.watch:
-            return 0
-        await asyncio.sleep(args.interval)
+    from watch import LocalChanges, fingerprint
+
+    previous = None
+    watcher = LocalChanges(state) if args.watch else None
+    try:
+        while True:
+            value = snapshot(state, getattr(args, "all", False))
+            current = fingerprint(value)
+            if current != previous:
+                if args.json:
+                    print(
+                        json.dumps(value, indent=None if args.watch else 2), flush=True
+                    )
+                else:
+                    if args.watch and sys.stdout.isatty():
+                        print("\033[2J\033[H", end="")
+                    print(render(value), flush=True)
+                previous = current
+            if not args.watch:
+                return 0
+            await watcher.changed(max(1, args.interval))
+    finally:
+        if watcher:
+            watcher.close()
 
 
 async def control(args, state):
@@ -204,7 +278,13 @@ async def control(args, state):
         for session in matching:
             op = "resume" if args.command == "unpause" else args.command
             ident = pool.command(session["id"], op, params)
-            print(f"Queued {op} for {session['id'][:10]} (command {ident}).")
+            if getattr(args, "wait", False):
+                from service import wait_control
+
+                await wait_control(pool, ident, timeout=args.timeout)
+                print(f"{op.capitalize()} applied to {session['id'][:10]}.")
+            else:
+                print(f"Queued {op} for {session['id'][:10]} (command {ident}).")
         return 0
     finally:
         pool.close()
@@ -473,6 +553,37 @@ async def group(args, state, binary):
 
 
 def add_parsers(sub):
+    preview = sub.add_parser(
+        "explain", help="Preview a native Codex launch without starting a task"
+    )
+    preview.add_argument("codex_args", nargs="...")
+    diagnostics = sub.add_parser(
+        "diagnostics",
+        help="Export redacted operational facts without credentials, prompts, or project paths",
+    )
+    diagnostics.add_argument("output")
+    clean = sub.add_parser(
+        "clean", help="Preview safe cleanup of unreferenced old runtime files"
+    )
+    clean.add_argument("--apply", action="store_true")
+    clean.add_argument("--older-than", type=int, default=30, dest="days")
+    clean.add_argument(
+        "--jobs",
+        action="store_true",
+        help="Also remove old stopped jobs; saved workspace references are retained",
+    )
+    workspaces = sub.add_parser(
+        "workspace",
+        help="Save and restore the same conversations across several terminals",
+    )
+    ws = workspaces.add_subparsers(dest="action", required=True)
+    ws.add_parser("list")
+    save_ws = ws.add_parser("save")
+    save_ws.add_argument("name")
+    save_ws.add_argument("sessions", nargs="*")
+    for action in ("restore", "remove"):
+        child = ws.add_parser(action)
+        child.add_argument("name")
     status = sub.add_parser(
         "status", help="Account and session dashboard without live network requests"
     )
@@ -487,15 +598,28 @@ def add_parsers(sub):
         "restart", help="Restart a stopped session from saved history"
     )
     restart.add_argument("session")
-    status.add_argument("--interval", type=float, default=2)
+    restart.add_argument("--if-stopped", action="store_true")
+    status.add_argument(
+        "--interval",
+        type=float,
+        default=30,
+        help="Maximum local filesystem wait; output changes only when data changes",
+    )
     for command in ["pause", "unpause", "retry", "wake", "stop", "switch"]:
         p = sub.add_parser(command, help=command + " one live session or all")
         p.add_argument("target", nargs="?")
         p.add_argument("--thread")
+        p.add_argument(
+            "--wait",
+            action="store_true",
+            help="Wait for the worker to confirm the action",
+        )
+        p.add_argument("--timeout", type=float, default=15)
         if command == "switch":
             p.add_argument("--account", required=True)
     account = sub.add_parser("account", help="Manage any number of enrolled accounts")
     child = account.add_subparsers(dest="action", required=True)
+    child.add_parser("identify", help="Fill in account emails from saved local logins")
     for action in [
         "add",
         "reauth",
@@ -544,10 +668,21 @@ def add_parsers(sub):
     )
     runtime.add_argument("action", choices=["list", "cache", "use", "preflight"])
     runtime.add_argument("value", nargs="?")
+    startup = sub.add_parser(
+        "startup", help="Choose background sessions to recover at Mac login"
+    )
+    startup.add_argument("action", choices=["list", "enable", "disable"])
+    startup.add_argument("session", nargs="?")
     menu = sub.add_parser(
         "menubar", help="Build or launch the optional native menu app"
     )
     menu.add_argument("--build-only", action="store_true")
+    menu.add_argument(
+        "--no-startup", action="store_true", help="Disable menu login startup"
+    )
+    menu.add_argument(
+        "--configure-only", action="store_true", help="Only update the login setting"
+    )
     start = sub.add_parser(
         "start", help="Start a supervised background task; attach later"
     )
@@ -585,9 +720,65 @@ def add_parsers(sub):
 async def dispatch(args, state, binary):
     from router import RouterError
 
+    if args.command in {"explain", "diagnostics", "clean", "workspace"}:
+        import tools
+
+        if args.command == "explain":
+            result = tools.explain(args.codex_args, os.getcwd(), binary)
+        elif args.command == "diagnostics":
+            result = {"written": tools.diagnostics(state, args.output)}
+        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:
+                        async with asyncio.timeout(2):
+                            async with file_lock(state / "metadata.lock"):
+                                result = tools.cleanup(
+                                    state, apply=True, days=args.days, jobs=args.jobs
+                                )
+                    except asyncio.TimeoutError:
+                        raise RouterError(
+                            "Stop supervised sessions before applying cleanup. The dry run works while sessions are active."
+                        ) from None
+                else:
+                    result = tools.cleanup(
+                        state, apply=args.apply, days=args.days, jobs=args.jobs
+                    )
+        else:
+            result = tools.workspace(
+                state,
+                args.action,
+                getattr(args, "name", None),
+                getattr(args, "sessions", None),
+                binary,
+            )
+        print(json.dumps(result, indent=2))
+        return 0
+    if args.command == "startup":
+        import desktop
+
+        if args.action != "list" and not args.session:
+            raise ValueError("Choose a saved session ID")
+        print(
+            json.dumps(desktop.job_startup(state, args.action, args.session), indent=2)
+        )
+        return 0
     if args.command == "restart":
         import service
 
+        if args.if_stopped:
+            pool = Pool(state)
+            try:
+                ident = service.resolve(state, args.session)
+                if any(s["id"] == ident for s in pool.detail()):
+                    return 0
+            finally:
+                pool.close()
+
         async with file_lock(state / "restart.lock"):
             ident = service.restart(state, args.session)
         print("Restarted " + ident)
@@ -599,6 +790,11 @@ async def dispatch(args, state, binary):
     if args.command in {"pause", "unpause", "retry", "wake", "stop", "switch"}:
         return await control(args, state)
     if args.command == "account":
+        if args.action == "identify":
+            print(
+                f"Identified {await asyncio.to_thread(identify_accounts, state)} saved accounts."
+            )
+            return 0
         return await manage(args, state, binary)
     if args.command == "config":
         if args.key:
@@ -670,7 +866,17 @@ async def dispatch(args, state, binary):
     if args.command == "menubar":
         import desktop
 
-        app = await asyncio.to_thread(desktop.menubar, state, None, args.build_only)
+        if args.no_startup or args.configure_only:
+            desktop.login_item(state, enabled=not args.no_startup)
+            if args.configure_only:
+                print(
+                    "Menu login startup "
+                    + ("disabled" if args.no_startup else "enabled")
+                )
+                return 0
+        app = await asyncio.to_thread(
+            desktop.menubar, state, None, args.build_only, not args.no_startup
+        )
         print(str(app))
         return 0
     if args.command == "group":

package/python/compatibility.py

@@ -7,7 +7,7 @@ import subprocess
 import tempfile
 import sys
 
-ADAPTER = 4
+ADAPTER = 5
 
 
 def executable(path):
@@ -130,6 +130,8 @@ def validate_schema(root):
                     "threadId": ident,
                     "sandbox": "danger-full-access",
                     "approvalPolicy": "never",
+                    "approvalsReviewer": "user",
+                    "runtimeWorkspaceRoots": ["/tmp/relay-probe"],
                 },
             },
             {