sneakoscope 7.3.0 → 7.6.0

package/dist/native/sks-menubar/Sources/RemoteTelegramViewController.swift

@@ -1,74 +1,276 @@
 import Cocoa
 
 final class RemoteTelegramViewController: NSViewController, ControlCenterPage {
-    private let processClient: ProcessClient
+    let processClient: ProcessClient
+    private let hubSupervisor: TelegramHubSupervisor
     private let operations: OperationCoordinator
-    private let readinessStatus = NativeView.detail("Remote readiness has not been checked.")
-    private let setupStatus = NativeView.detail("Telegram setup has not been checked.")
-    private let hubStatus = NativeView.detail("Telegram Hub status has not been checked.")
-    private var generation = 0
-    private var busy = false
-    private var setupReady = false
-    private var hubRunning = false
-    private var checkButton: NSButton!
-    private var connectButton: NSButton!
+
+    let readinessStatus = NativeView.detail("Project readiness has not been checked.")
+    let setupBadge = ControlKit.badge("Telegram setup not checked", tone: .neutral)
+    let setupStatus = NativeView.detail("Create the bot, send /start in its private chat, then connect the token.")
+    let connectionBadge = ControlKit.badge("Telegram connection not checked", tone: .neutral)
+    let connectionStatus = NativeView.detail("Connection details are loading…")
+    let hubBadge = ControlKit.badge("Telegram Hub not checked", tone: .neutral)
+    let hubStatus = NativeView.detail("Complete setup to use the local Hub.")
+    let liveSourceBadge = ControlKit.badge("Codex thread not loaded", tone: .neutral)
+    let snapshotStatus = NativeView.detail("Conversation and public work activity have not been loaded.")
+    let sessionPicker = NSPopUpButton()
+    let conversationView = RemoteTelegramViewController.readOnlyTextView(
+        label: "Telegram Codex conversation history"
+    )
+    let activityView = RemoteTelegramViewController.readOnlyTextView(
+        label: "Telegram Codex live public activity"
+    )
+
+    var setupCard: NSView!
+    var connectedCard: NSView!
+    var workspaceCard: NSView!
+    var generation = 0
+    var snapshotGeneration = 0
+    var liveGeneration = 0
+    var busy = false
+    var statusInFlight = false
+    var snapshotInFlight = false
+    var liveInFlight = false
+    var setupReady = false
+    var hubRunning = false
+    var deadLetterIngressCount = 0
+    var selectedSessionId: String?
+    var registeredSessionCount = 0
+    var conversationCursor: String?
+    var conversationSortDirection = "desc"
+    var isViewingLatestConversationPage = true
+    var olderConversationCursor: String?
+    var olderConversationSortDirection = "desc"
+    var newerConversationCursor: String?
+    var newerConversationSortDirection = "asc"
+    var loadedSessionId: String?
+    var loadedConversationRevision: String?
+    var loadedLiveActivityDigest: String?
+    var liveTriggeredConversationRevision: String?
+    var loadedTranscriptRows: [[String: Any]] = []
+    var loadedHistoryActivityRows: [[String: Any]] = []
+    var loadedLiveActivityRows: [[String: Any]] = []
+    var loadedThreadId: String?
+    var loadedThreadStatus = "unknown"
+    var loadedConversationPageTurnCount = 0
+    var loadedSnapshotTruncated = false
+    var loadedLiveActivityState = "pending"
+    var loadedLiveActivityError: String?
+    var renderedTranscriptSignature: String?
+    var renderedActivitySignature: String?
+    var liveSourceFileSignature: String?
+    var liveCatchUpInProgress = false
+    var liveTimer: Timer?
+
+    var checkButton: NSButton!
+    private var snapshotRefreshButton: NSButton!
+    private var olderConversationButton: NSButton!
+    private var newerConversationButton: NSButton!
+    private var latestConversationButton: NSButton!
+    private var setupBotFatherButton: NSButton!
+    private var setupConnectButton: NSButton!
+    private var connectedBotFatherButton: NSButton!
+    private var reconnectButton: NSButton!
     private var startButton: NSButton!
     private var stopButton: NSButton!
     private var restartButton: NSButton!
+    private var acknowledgeDeadLettersButton: NSButton!
 
-    init(processClient: ProcessClient, operations: OperationCoordinator) {
+    init(
+        processClient: ProcessClient,
+        hubSupervisor: TelegramHubSupervisor,
+        operations: OperationCoordinator
+    ) {
         self.processClient = processClient
+        self.hubSupervisor = hubSupervisor
         self.operations = operations
         super.init(nibName: nil, bundle: nil)
     }
     required init?(coder: NSCoder) { nil }
 
+    deinit {
+        liveTimer?.invalidate()
+    }
+
     override func loadView() {
-        connectButton = NativeView.button("Connect Bot & Register Coding Session…", target: self, action: #selector(connectBot))
+        for label in [setupStatus, connectionStatus, hubStatus, snapshotStatus, readinessStatus] {
+            label.textColor = .labelColor
+            label.alignment = .left
+        }
+
+        checkButton = NativeView.button("Refresh All", target: self, action: #selector(check))
+        snapshotRefreshButton = NativeView.button("Refresh Conversation", target: self, action: #selector(refreshSnapshotManually))
+        olderConversationButton = NativeView.button("Older", target: self, action: #selector(showOlderConversationPage))
+        newerConversationButton = NativeView.button("Newer", target: self, action: #selector(showNewerConversationPage))
+        latestConversationButton = NativeView.button("Latest", target: self, action: #selector(showLatestConversationPage))
+        setupBotFatherButton = ControlKit.primaryButton("Open @BotFather", target: self, action: #selector(openBotFather))
+        setupConnectButton = NativeView.button("Connect This Project…", target: self, action: #selector(connectBot))
+        connectedBotFatherButton = NativeView.button("Open @BotFather", target: self, action: #selector(openBotFather))
+        reconnectButton = NativeView.button("Reconnect / Rotate Token…", target: self, action: #selector(connectBot))
         startButton = NativeView.button("Start Hub", target: self, action: #selector(startHub))
         stopButton = NativeView.button("Stop Hub", target: self, action: #selector(stopHub))
         restartButton = NativeView.button("Restart Hub", target: self, action: #selector(restartHub))
-        checkButton = NativeView.button("Refresh Status", target: self, action: #selector(check))
+        acknowledgeDeadLettersButton = NativeView.button(
+            "Acknowledge Failed Ingress…",
+            target: self,
+            action: #selector(acknowledgeDeadLetters)
+        )
 
-        let setupCard = NativeView.card(
-            title: "1. Connect your private Telegram bot",
-            subtitle: "Create a bot with BotFather, open that bot in Telegram, send /start, then paste the bot token here. SKS verifies the bot, detects only that private chat/user, saves the token in macOS Keychain, and registers one dedicated coding session for this project.",
-            views: [setupStatus, NativeView.row([connectButton])]
+        setupBotFatherButton.setAccessibilityHelp("Open Telegram BotFather to create or manage the private bot.")
+        setupConnectButton.setAccessibilityHelp("Paste the BotFather token securely and register this project.")
+        reconnectButton.setAccessibilityHelp("Stop the Hub first, then reconnect the bot or rotate its token.")
+        acknowledgeDeadLettersButton.setAccessibilityHelp(
+            "After the Hub is stopped, retire failed ingress metadata so the request can be resent from Telegram."
         )
-        let hubCard = NativeView.card(
-            title: "2. Keep remote coding available",
-            subtitle: "The LaunchAgent keeps the Hub running and prevents idle system sleep while this Mac user is logged in. Closing the lid or logging out can still stop access. It uses a local in-process worker on this Mac; SSH remains available only for explicitly configured remote machines.",
-            views: [hubStatus, NativeView.row([startButton, stopButton, restartButton])]
+        olderConversationButton.setAccessibilityHelp("Load the next older page from the complete stored Codex conversation.")
+        newerConversationButton.setAccessibilityHelp("Load the next newer page from the complete stored Codex conversation.")
+        latestConversationButton.setAccessibilityHelp("Return to the live latest page and resume automatic refresh.")
+        sessionPicker.target = self
+        sessionPicker.action = #selector(sessionChanged)
+        sessionPicker.setAccessibilityLabel("Registered Telegram coding session")
+        sessionPicker.widthAnchor.constraint(greaterThanOrEqualToConstant: 260).isActive = true
+
+        let setupSteps = NSStackView(views: [
+            guideStep("1", title: "Create the bot", detail: "Open @BotFather, send /newbot, and copy the HTTP API token."),
+            guideStep("2", title: "Pair your account", detail: "Open the new bot in a private chat and send /start."),
+            guideStep("3", title: "Connect this project", detail: "Paste the token here. SKS verifies one private chat/user and stores the token only in macOS Keychain.")
+        ])
+        setupSteps.orientation = .vertical; setupSteps.alignment = .leading; setupSteps.spacing = 9
+        for step in setupSteps.arrangedSubviews { step.widthAnchor.constraint(equalTo: setupSteps.widthAnchor).isActive = true }
+        setupCard = NativeView.card(
+            title: "Connect Telegram in 3 steps",
+            subtitle: "This creates one private, project-scoped Telegram coding session. SKS never puts the bot token in arguments, project config, or logs.",
+            views: [
+                setupBadge,
+                setupStatus,
+                setupSteps,
+                ControlKit.actionRow([setupBotFatherButton, setupConnectButton])
+            ],
+            fullWidthLeadingContent: true
+        )
+
+        let sessionLabel = NSTextField(labelWithString: "Coding session")
+        sessionLabel.font = NSFont.systemFont(ofSize: 12, weight: .medium)
+        sessionLabel.textColor = .secondaryLabelColor
+        sessionLabel.setContentHuggingPriority(.required, for: .horizontal)
+        let sessionRow = ControlKit.actionRow([sessionLabel, sessionPicker])
+        connectedCard = NativeView.card(
+            title: "Telegram connected",
+            subtitle: "Plain text from the paired private chat continues this project's dedicated Codex thread.",
+            views: [
+                connectionBadge,
+                connectionStatus,
+                sessionRow,
+                hubBadge,
+                hubStatus,
+                ControlKit.actionRow([startButton, stopButton, restartButton]),
+                ControlKit.actionRow([acknowledgeDeadLettersButton]),
+                ControlKit.actionRow([connectedBotFatherButton, reconnectButton])
+            ],
+            fullWidthLeadingContent: true
+        )
+
+        let conversationScroll = textArea(conversationView, height: 210)
+        let activityScroll = textArea(activityView, height: 150)
+        let conversationTitle = NativeView.sectionTitle("Conversation history")
+        let conversationPageRow = ControlKit.actionRow(
+            [conversationTitle],
+            trailing: [olderConversationButton, newerConversationButton, latestConversationButton]
+        )
+        let activityTitle = NativeView.sectionTitle("Live public activity")
+        workspaceCard = NativeView.card(
+            title: "Connected Codex thread",
+            subtitle: "Browse the real Telegram-bound Codex conversation and bounded public activity. Latest checks local journal files every 2.5 seconds and refreshes only after a change; reasoning, raw tool output, and credentials stay private.",
+            views: [
+                ControlKit.actionRow([liveSourceBadge], trailing: [snapshotRefreshButton]),
+                snapshotStatus,
+                conversationPageRow,
+                conversationScroll,
+                activityTitle,
+                activityScroll
+            ],
+            fullWidthLeadingContent: true
         )
+
+        let usageSteps = NSStackView(views: [
+            guideStep(
+                "1",
+                title: "Send a coding request",
+                detail: "Type ordinary text in the paired private chat. It starts or resumes only this project's dedicated Codex thread."
+            ),
+            guideStep(
+                "2",
+                title: "Follow the real Codex work",
+                detail: "Conversation history shows stored user and assistant messages. Latest also follows bounded public tool, file, search, subagent, and turn activity."
+            ),
+            guideStep(
+                "3",
+                title: "Receive and control the result",
+                detail: "SKS waits for the turn and sends Codex's final response back to Telegram. Use the commands below for status and guarded actions."
+            )
+        ])
+        usageSteps.orientation = .vertical; usageSteps.alignment = .leading; usageSteps.spacing = 9
+        for step in usageSteps.arrangedSubviews { step.widthAnchor.constraint(equalTo: usageSteps.widthAnchor).isActive = true }
+        let readCommandGuide = NativeView.detail("/status  /tail  /diff  /gates  /trust  /proof  /artifacts")
+        readCommandGuide.font = NSFont.monospacedSystemFont(ofSize: 11, weight: .regular); readCommandGuide.setAccessibilityLabel("Read-only Telegram commands")
+        let actionCommandGuide = NativeView.detail("/input <text>  /verify  /cancel  /refresh  /open")
+        actionCommandGuide.font = NSFont.monospacedSystemFont(ofSize: 11, weight: .regular)
+        actionCommandGuide.setAccessibilityLabel("Telegram action commands")
         let usageCard = NativeView.card(
-            title: "3. Code from Telegram",
-            subtitle: "Send ordinary text in the paired private chat. The first message creates and persists the Codex thread with its first turn; later messages resume that exact thread, wait for completion, and return Codex’s final answer. /status, /diff, /proof, and /verify remain available. Arbitrary remote shell and unpaired chats stay blocked.",
-            views: []
+            title: "How to use it",
+            subtitle: "Send ordinary text to continue the linked Codex conversation; no special command is required for everyday coding requests.",
+            views: [
+                usageSteps,
+                NativeView.sectionTitle("Useful bot commands"),
+                readCommandGuide,
+                actionCommandGuide,
+                NativeView.detail("Read commands inspect the linked project without starting arbitrary shell access. /cancel remains owner-proof guarded; unpaired chats stay blocked.")
+            ],
+            fullWidthLeadingContent: true
         )
         let readinessCard = NativeView.card(
             title: "Project readiness",
-            subtitle: "Codex app, CLI, and Git state for this project — checked together with every status refresh.",
-            views: [readinessStatus]
+            subtitle: "Codex App, CLI, and Git state for this project.",
+            views: [readinessStatus],
+            fullWidthLeadingContent: true
         )
-        view = NativeView.page([
-            ControlKit.header("Remote & Telegram", "Telegram remote coding is isolated to this project, uses workspace-write with network disabled, and never exposes the bot token in config, arguments, or logs."),
-            NativeView.row([checkButton]),
-            setupCard, hubCard, usageCard, readinessCard
+
+        let page = NativeView.page([
+            ControlKit.header("Remote & Telegram", "Code through a private BotFather bot and inspect the exact linked Codex conversation in SKS Center."),
+            ControlKit.actionRow([], trailing: [checkButton]),
+            connectedCard,
+            setupCard,
+            workspaceCard,
+            usageCard,
+            readinessCard
         ])
+        view = page
+        renderVisibility()
+        renderConversationPlaceholder("Connect Telegram to load a Codex conversation.")
+        renderActivityPlaceholder("Public work activity will appear after a linked Codex turn starts.")
         updateButtons()
-        check()
     }
 
-    func refreshOnAppear() { check() }
+    func refreshOnAppear() {
+        startLivePolling()
+        checkStatus(refreshConversation: loadedSessionId == nil)
+    }
+
+    @objc private func openBotFather() {
+        guard let url = URL(string: "https://t.me/BotFather") else { return }
+        NSWorkspace.shared.open(url)
+    }
 
     @objc private func connectBot() {
         guard let window = view.window else { return }
         AlertFactory.textSheet(
             window: window,
             title: "Telegram Bot Token",
-            message: "First send /start to your bot from the private Telegram account you want to pair. Paste the BotFather token below. It is sent through stdin, stored in macOS Keychain, and never logged.",
+            message: "First send /start to your bot from the private Telegram account you want to pair. Paste the current BotFather token below. It is sent through stdin, verified, stored in macOS Keychain, and never logged.",
             secure: true,
-            placeholder: "123456789:ABC…"
+            placeholder: "123456789:ABC…",
+            actionTitle: "Connect"
         ) { [weak self] token in
             guard let self = self, let token = token else { return }
             self.runMutation(
@@ -81,58 +283,115 @@ final class RemoteTelegramViewController: NSViewController, ControlCenterPage {
     }
 
     @objc private func startHub() {
-        runMutation(
-            args: ["telegram", "hub", "start", "--project-root", AppRuntime.projectRoot, "--json"],
+        runHubMutation(
             kind: "telegram-hub-start",
-            summary: "Start Telegram Hub"
+            summary: "Start Telegram Hub",
+            action: hubSupervisor.start
         )
     }
 
     @objc private func stopHub() {
-        runMutation(
-            args: ["telegram", "hub", "stop", "--project-root", AppRuntime.projectRoot, "--json"],
+        runHubMutation(
             kind: "telegram-hub-stop",
-            summary: "Stop Telegram Hub"
+            summary: "Stop Telegram Hub",
+            action: hubSupervisor.stop
         )
     }
 
     @objc private func restartHub() {
-        runMutation(
-            args: ["telegram", "hub", "restart", "--project-root", AppRuntime.projectRoot, "--json"],
+        runHubMutation(
             kind: "telegram-hub-restart",
-            summary: "Restart Telegram Hub"
+            summary: "Restart Telegram Hub",
+            action: hubSupervisor.restart
         )
     }
 
-    @objc private func check() {
-        guard !busy else { return }
-        generation += 1
-        let requestGeneration = generation
-        checkButton?.isEnabled = false
-        readinessStatus.stringValue = "Checking project readiness…"
-        setupStatus.stringValue = "Checking Keychain, pairing, and dedicated Codex session…"
-        hubStatus.stringValue = "Checking LaunchAgent state…"
-        var remote: [String: Any]?
-        var telegram: [String: Any]?
-        let group = DispatchGroup()
-        group.enter()
-        processClient.run(["remote", "readiness", "--project-root", AppRuntime.projectRoot, "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
-            remote = self?.json(result.output)
-            group.leave()
+    private func runHubMutation(
+        kind: String,
+        summary: String,
+        action: (@escaping (Bool) -> Void) -> Void
+    ) {
+        guard !busy else {
+            hubStatus.stringValue = "Another Telegram operation is already running."
+            return
         }
-        group.enter()
-        processClient.run(["telegram", "status", "--project-root", AppRuntime.projectRoot, "--json"], timeout: NativeView.statusTimeout) { [weak self] result in
-            telegram = self?.json(result.output)
-            group.leave()
+        guard let operation = operations.begin(kind: kind, mutationGroup: "telegram", summary: summary) else {
+            hubStatus.stringValue = "Another guarded mutation is already running. Wait or open Diagnostics."
+            return
         }
-        group.notify(queue: .main) { [weak self] in
-            guard let self = self, self.generation == requestGeneration else { return }
-            self.render(remote: remote, telegram: telegram)
-            self.updateButtons()
+        setBusy(true)
+        _ = operations.update(operation, state: .running, stage: "running", progress: nil, summary: summary)
+        ControlKit.setBadge(hubBadge, text: "\(summary)…", tone: .busy)
+        hubStatus.stringValue = "\(summary)…"
+        action { [weak self] ok in
+            guard let self = self else { return }
+            _ = self.operations.update(
+                operation,
+                state: ok ? .succeeded : .failed,
+                stage: "complete",
+                progress: 1,
+                summary: ok ? "\(summary) completed" : "\(summary) failed"
+            )
+            self.setBusy(false)
+            if !ok {
+                ControlKit.setBadge(self.hubBadge, text: "Telegram Hub action failed", tone: .error)
+                self.hubStatus.stringValue = "\(summary) failed. Open Diagnostics and retry."
+            }
+            self.checkStatus(refreshConversation: false)
+            if ok {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 3) { [weak self] in
+                    self?.checkStatus(refreshConversation: false)
+                }
+            }
         }
     }
 
-    private func runMutation(args: [String], stdin: String? = nil, kind: String, summary: String) {
+    @objc private func check() {
+        checkStatus(refreshConversation: true)
+    }
+
+    @objc private func refreshSnapshotManually() {
+        refreshSnapshot(force: true)
+    }
+
+    @objc private func sessionChanged() {
+        guard let item = sessionPicker.selectedItem,
+              let sessionId = item.representedObject as? String,
+              !sessionId.isEmpty else { return }
+        guard sessionId != selectedSessionId || loadedSessionId != sessionId else { return }
+        selectedSessionId = sessionId
+        invalidateCenterRequests()
+        clearLoadedCenterState()
+        resetConversationPagination()
+        ControlKit.setBadge(liveSourceBadge, text: "Loading selected Codex thread…", tone: .busy)
+        snapshotStatus.stringValue = "Reading the selected session’s conversation and bounded public activity…"
+        renderConversationPlaceholder("Loading the selected Codex conversation…")
+        renderActivityPlaceholder("Loading the selected session’s public activity…")
+        refreshSnapshot(force: true)
+    }
+
+    @objc private func showOlderConversationPage() {
+        guard let cursor = olderConversationCursor else { return }
+        conversationCursor = cursor
+        conversationSortDirection = olderConversationSortDirection
+        isViewingLatestConversationPage = false
+        refreshSnapshot(force: true)
+    }
+
+    @objc private func showNewerConversationPage() {
+        guard let cursor = newerConversationCursor else { return }
+        conversationCursor = cursor
+        conversationSortDirection = newerConversationSortDirection
+        isViewingLatestConversationPage = false
+        refreshSnapshot(force: true)
+    }
+
+    @objc private func showLatestConversationPage() {
+        resetConversationPagination()
+        refreshSnapshot(force: true)
+    }
+
+    func runMutation(args: [String], stdin: String? = nil, kind: String, summary: String) {
         guard !busy else {
             hubStatus.stringValue = "Another Telegram operation is already running."
             return
@@ -143,7 +402,14 @@ final class RemoteTelegramViewController: NSViewController, ControlCenterPage {
         }
         setBusy(true)
         _ = operations.update(operation, state: .running, stage: "running", progress: nil, summary: summary)
-        hubStatus.stringValue = "\(summary)…"
+        if kind == "telegram-setup" {
+            ControlKit.setBadge(setupReady ? connectionBadge : setupBadge, text: "Connecting Telegram…", tone: .busy)
+            if setupReady { connectionStatus.stringValue = "\(summary)…" }
+            else { setupStatus.stringValue = "\(summary)…" }
+        } else {
+            ControlKit.setBadge(hubBadge, text: "\(summary)…", tone: .busy)
+            hubStatus.stringValue = "\(summary)…"
+        }
         processClient.run(args, stdin: stdin, timeout: NativeView.mutationTimeout) { [weak self] result in
             guard let self = self else { return }
             let ok = result.code == 0
@@ -156,15 +422,17 @@ final class RemoteTelegramViewController: NSViewController, ControlCenterPage {
             )
             self.setBusy(false)
             if !ok {
-                // Route setup failures to the setup card so the guidance sits
-                // next to the Connect button instead of the Hub status line.
                 if kind == "telegram-setup" {
-                    self.setupStatus.stringValue = "Setup failed. Confirm you sent /start to this bot, then retry. The token was not written to logs."
+                    ControlKit.setBadge(self.setupReady ? self.connectionBadge : self.setupBadge, text: "Telegram setup needs attention", tone: .error)
+                    let message = self.setupFailureMessage(result.output)
+                    if self.setupReady { self.connectionStatus.stringValue = message }
+                    else { self.setupStatus.stringValue = message }
                 } else {
+                    ControlKit.setBadge(self.hubBadge, text: "Telegram Hub action failed", tone: .error)
                     self.hubStatus.stringValue = "\(summary) failed · \(NativeView.redactPreview(result.output))"
                 }
             }
-            self.check()
+            if ok { self.checkStatus(refreshConversation: kind == "telegram-setup") }
         }
     }
 
@@ -173,49 +441,30 @@ final class RemoteTelegramViewController: NSViewController, ControlCenterPage {
         updateButtons()
     }
 
-    private func updateButtons() {
-        connectButton?.isEnabled = !busy
-        startButton?.isEnabled = !busy && setupReady && !hubRunning
-        stopButton?.isEnabled = !busy && hubRunning
-        restartButton?.isEnabled = !busy && setupReady && hubRunning
-        checkButton?.isEnabled = !busy
+    func updateButtons() {
+        let controlsBusy = busy || statusInFlight
+        setupBotFatherButton?.isEnabled = !busy
+        connectedBotFatherButton?.isEnabled = !busy
+        setupConnectButton?.isEnabled = !busy && !hubRunning
+        reconnectButton?.isEnabled = !busy && !hubRunning
+        startButton?.isEnabled = !controlsBusy && setupReady && !hubRunning
+        stopButton?.isEnabled = !controlsBusy && hubRunning
+        restartButton?.isEnabled = !controlsBusy && setupReady && hubRunning
+        acknowledgeDeadLettersButton?.isEnabled = !controlsBusy
+            && setupReady
+            && !hubRunning
+            && deadLetterIngressCount > 0
+        checkButton?.isEnabled = !controlsBusy
+        snapshotRefreshButton?.isEnabled = !busy && setupReady && !snapshotInFlight
+        olderConversationButton?.isEnabled = !busy && setupReady && !snapshotInFlight && olderConversationCursor != nil
+        newerConversationButton?.isEnabled = !busy && setupReady && !snapshotInFlight && newerConversationCursor != nil
+        latestConversationButton?.isEnabled = !busy && setupReady && !snapshotInFlight && !isViewingLatestConversationPage
+        sessionPicker.isEnabled = !busy && setupReady && !snapshotInFlight && registeredSessionCount > 0
+        startButton?.isHidden = !setupReady || hubRunning
+        stopButton?.isHidden = !hubRunning
+        restartButton?.isHidden = !hubRunning
+        acknowledgeDeadLettersButton?.isHidden = deadLetterIngressCount == 0
+        reconnectButton?.isHidden = hubRunning
     }
 
-    private func render(remote: [String: Any]?, telegram: [String: Any]?) {
-        if let remote = remote {
-            let host = remote["host"] as? [String: Any]
-            let project = remote["project"] as? [String: Any]
-            let blockers = remote["blockers"] as? [String] ?? []
-            readinessStatus.stringValue = "Project readiness: \(remote["ok"] as? Bool == true ? "Ready" : "Needs attention") · Codex app \(host?["codex_app_found"] as? Bool == true ? "found" : "missing") · CLI \(host?["codex_cli_found"] as? Bool == true ? "found" : "missing") · Git \(project?["git_repo"] as? Bool == true ? "ready" : "missing")" + (blockers.isEmpty ? "" : " · \(blockers.prefix(2).joined(separator: "; "))")
-        } else {
-            readinessStatus.stringValue = "Project readiness is unavailable. Open Diagnostics for the redacted log."
-        }
-
-        guard let telegram = telegram else {
-            setupReady = false
-            hubRunning = false
-            setupStatus.stringValue = "Telegram setup status is unavailable."
-            hubStatus.stringValue = "Telegram Hub status is unavailable."
-            return
-        }
-        let token = telegram["token_configured"] as? Bool == true
-        let pairing = telegram["pairing_valid"] as? Bool == true
-        let sessions = telegram["registered_session_count"] as? Int ?? 0
-        setupReady = token && pairing && sessions > 0
-        hubRunning = telegram["hub_running"] as? Bool == true
-        setupStatus.stringValue = "Keychain token \(token ? "ready" : "missing") · private pairing \(pairing ? "ready" : "missing") · dedicated Codex sessions \(sessions)" + (setupReady ? " · ready to start" : " · connect the bot to continue")
-        let service = telegram["service"] as? [String: Any]
-        let installed = service?["installed"] as? Bool == true
-        let state = service?["state"] as? String
-        hubStatus.stringValue = "Hub \(hubRunning ? "Running" : installed ? "Stopped" : "Not installed")" + (state.map { " · launchd \($0)" } ?? "") + (hubRunning ? " · send a Telegram message to code" : setupReady ? " · click Start Hub" : "")
-    }
-
-    private func json(_ text: String) -> [String: Any]? {
-        guard let data = text.data(using: .utf8) else { return nil }
-        if let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any] { return object }
-        guard let start = text.range(of: "{", options: [.backwards])?.lowerBound else { return nil }
-        let slice = String(text[start...])
-        guard let sliced = slice.data(using: .utf8) else { return nil }
-        return try? JSONSerialization.jsonObject(with: sliced) as? [String: Any]
-    }
 }