Add a chat view for the terminal's agent session (Claude Code, Codex)

Packages/macOS/CmuxControlSocket/Sources/CmuxControlSocket/Coordinator/MobileHost/ControlCommandCoordinator+MobileHost.swift

@@ -40,6 +40,10 @@ extension ControlCommandCoordinator {
             return await context?.controlMobileTaskModelsList(
                 params: request.params
             )
+        case "mobile.chat.send":
+            return await context?.controlMobileChatSend(params: request.params)
+        case "mobile.chat.interrupt":
+            return await context?.controlMobileChatInterrupt(params: request.params)
         default:
             return nil
         }

Packages/macOS/CmuxControlSocket/Sources/CmuxControlSocket/Coordinator/MobileHost/ControlMobileHostContext.swift

@@ -136,6 +136,23 @@ public protocol ControlMobileHostContext: AnyObject {
         params: [String: JSONValue]
     ) async -> ControlCallResult
 
+    /// `mobile.chat.send` — types a prompt into an agent session's terminal,
+    /// the same delivery the iOS chat uses.
+    ///
+    /// - Parameter params: The decoded request params (`session_id`, `text`).
+    /// - Returns: The fully-built command result.
+    nonisolated func controlMobileChatSend(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult
+
+    /// `mobile.chat.interrupt` — interrupts an agent session's running turn.
+    ///
+    /// - Parameter params: The decoded request params (`session_id`, `hard`).
+    /// - Returns: The fully-built command result.
+    nonisolated func controlMobileChatInterrupt(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult
+
     /// `chat.sessions.dump` (local debug socket) — the full chat-session registry
     /// dump, for diagnosing inconsistent phone-side chat state.
     ///
@@ -154,4 +171,18 @@ public extension ControlMobileHostContext {
             data: nil
         )
     }
+
+    /// Default for test and partial contexts without agent chat delivery.
+    nonisolated func controlMobileChatSend(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult {
+        .err(code: "method_not_found", message: "Agent chat is unavailable", data: nil)
+    }
+
+    /// Default for test and partial contexts without agent chat delivery.
+    nonisolated func controlMobileChatInterrupt(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult {
+        .err(code: "method_not_found", message: "Agent chat is unavailable", data: nil)
+    }
 }

Packages/macOS/CmuxControlSocket/Sources/CmuxControlSocket/Wire/ControlCommandExecutionPolicy.swift

@@ -107,9 +107,9 @@ public enum ControlCommandExecutionPolicy: Sendable, Equatable {
         "browser.profiles.delete",
         "browser.import.cookies",
         "mobile.attach_ticket.create",
-        // Provider discovery may read configuration or run `opencode models`;
-        // it must never hold the main actor while waiting for process I/O.
-        "mobile.task.models.list",
+        // Provider discovery reads config or runs `opencode models`; chat
+        // send/interrupt await terminal input. Neither may hold the main actor.
+        "mobile.task.models.list", "mobile.chat.send", "mobile.chat.interrupt",
         // `mobile.terminal.set_font` only validates params and emits a push
         // event via thread-safe MobileHostService statics, so it runs on the worker
         // like the other mobile data-plane verbs. Without this entry the policy

Packages/macOS/CmuxControlSocket/Tests/CmuxControlSocketTests/ControlCommandCoordinatorMobileHostTests.swift

@@ -69,6 +69,18 @@ private final class FakeMobileHostControlCommandContext: ControlCommandContext {
         }
     }
 
+    nonisolated func controlMobileChatSend(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult {
+        await MainActor.run { record("chat.send", params) }
+    }
+
+    nonisolated func controlMobileChatInterrupt(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult {
+        await MainActor.run { record("chat.interrupt", params) }
+    }
+
     func controlMobileChatSessionsDump() -> ControlCallResult {
         record("chat.sessions.dump", [:])
     }
@@ -127,6 +139,18 @@ struct ControlCommandCoordinatorMobileHostTests {
         )
     }
 
+    @Test func workerSurfaceRoutesChatSendAndInterruptThroughAsyncSeam() async {
+        let (coordinator, context) = makeCoordinator()
+        let params: [String: JSONValue] = ["session_id": .string("abc"), "text": .string("hi")]
+        #expect(await coordinator.handleMobileHostAsync(request("mobile.chat.send", params), context: context) != nil)
+        #expect(context.lastMarker == "chat.send")
+        #expect(context.lastParams == params)
+        #expect(await coordinator.handleMobileHostAsync(request("mobile.chat.interrupt"), context: context) != nil)
+        #expect(context.lastMarker == "chat.interrupt")
+        #expect(ControlCommandExecutionPolicy(forMethod: "mobile.chat.send") == .socketWorker(mainThreadCallable: false))
+        #expect(ControlCommandExecutionPolicy(forMethod: "mobile.chat.interrupt") == .socketWorker(mainThreadCallable: false))
+    }
+
     @Test func v2SurfaceUsesPrivateHostStatusVariant() {
         let (coordinator, context) = makeCoordinator()
         #expect(coordinator.handle(request("mobile.host.status")) != nil)

Resources/Localizable.xcstrings

@@ -143921,6 +143921,65 @@
         }
       }
     },
+    "command.openTerminalChatView.title": {
+      "extractionState": "manual",
+      "localizations": {
+        "en": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Open terminal as chat"
+          }
+        },
+        "ja": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "ターミナルをチャットで表示"
+          }
+        },
+        "zh-Hans": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "以对话形式查看终端"
+          }
+        },
+        "de": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Terminal als Chat öffnen"
+          }
+        },
+        "fr": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Ouvrir le terminal en discussion"
+          }
+        },
+        "ar": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "فتح الطرفية كدردشة"
+          }
+        },
+        "es": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "Abrir la terminal como chat"
+          }
+        },
+        "zh-Hant": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "以對話形式檢視終端機"
+          }
+        },
+        "ko": {
+          "stringUnit": {
+            "state": "translated",
+            "value": "터미널을 채팅으로 열기"
+          }
+        }
+      }
+    },
     "command.openDiffViewer.title": {
       "extractionState": "manual",
       "localizations": {

Sources/AppDelegate+AgentChat.swift

@@ -1,5 +1,6 @@
 import AppKit
 import CMUXAgentLaunch
+import CmuxSettings
 import Foundation
 import os
 import Security
@@ -164,6 +165,25 @@ extension AppDelegate {
         return true
     }
 
+    /// Starts or reuses the agent-chat sidecar and returns its page base URL,
+    /// or nil when Agent Chat is off or the sidecar is unreachable.
+    func agentChatBrowserBaseURL(tabManager: TabManager, preferredWindow: NSWindow?) async -> URL? {
+        guard CmuxFeatureFlags.shared.isAgentChatUIEnabled,
+              BrowserAvailabilitySettings.isEnabled(),
+              AgentChatActionInFlightGate.begin() else { return nil }
+        defer { AgentChatActionInFlightGate.end() }
+        let store = mainWindowContext(for: tabManager)?.cmuxConfigStore
+        let agentChat = store?.agentChat ?? .default
+        AgentChatThemeSync.start()
+        let availability = await ensureAgentChatServerAvailable(
+            agentChat,
+            globalConfigPath: store?.globalConfigPath,
+            preferredWindow: preferredWindow
+        )
+        AgentChatThemeSync.syncNow(agentChat: agentChat)
+        return availability.isReachable ? availability.browserURL : nil
+    }
+
     @discardableResult
     private func openAgentChatWorkspace(
         tabManager: TabManager,
@@ -320,6 +340,9 @@ extension AppDelegate {
                 "CMUX_AGENT_CHAT_PORT": "0",
                 "CMUX_AGENT_CHAT_STATE_FILE": stateFileURL.path,
                 "CMUX_AGENT_CHAT_LAUNCH_ID": launchId,
+                // Terminal chat views deliver prompts over this app's socket.
+                "CMUX_SOCKET_PATH": TerminalController.shared.activeSocketPath(preferredPath: SocketControlSettings.socketPath()),
+                "CMUX_BUNDLED_CLI_PATH": CLIForwardingLaunchRouter.bundledCLIURL()?.path ?? "",
             ]
         ) else {
             return AgentChatServerAvailability(isReachable: false, browserURL: agentChat.url)

Sources/ContentView+AgentChatCommandPalette.swift

@@ -33,6 +33,15 @@ extension ContentView {
             subtitle: { _ in String(localized: "command.newAgentChat.subtitle", defaultValue: "Agent Chat") },
             keywords: ["create", "new", "agent", "chat", "browser", "codex", "claude"],
             when: { !$0.bool(CommandPaletteContextKeys.browserDisabled) }
+        ), CommandPaletteCommandContribution(
+            commandId: "palette.openTerminalChatView",
+            title: { _ in String(localized: "command.openTerminalChatView.title", defaultValue: "Open terminal as chat") },
+            subtitle: { _ in String(localized: "command.newAgentChat.subtitle", defaultValue: "Agent Chat") },
+            keywords: ["terminal", "chat", "view", "transcript", "gui", "agent", "claude", "codex"],
+            when: {
+                $0.bool(CommandPaletteContextKeys.panelIsTerminal)
+                    && !$0.bool(CommandPaletteContextKeys.browserDisabled)
+            }
         )]
     }
 
@@ -55,6 +64,21 @@ extension ContentView {
                 NSSound.beep()
             }
         }
+        registerTerminalChatViewCommandPaletteHandler(&registry)
+    }
+
+    /// Registers the read-only chat view for the focused terminal's agent.
+    func registerTerminalChatViewCommandPaletteHandler(_ registry: inout CommandPaletteHandlerRegistry) {
+        registry.register(commandId: "palette.openTerminalChatView") {
+            guard let context = focusedPanelContext, context.panel.panelType == .terminal else {
+                NSSound.beep()
+                return
+            }
+            context.workspace.openTerminalChatView(
+                terminalPanelId: context.panelId,
+                presentingWindow: AppDelegate.shared?.mainWindow(for: windowId)
+            )
+        }
     }
 
     /// Palette context key indicating that the selected workspace is remotely managed.

Sources/TerminalController+Capabilities.swift

@@ -57,6 +57,8 @@ extension TerminalController {
             "mobile.compatible_tags.set",
             "mobile.task.attachment.upload",
             "mobile.task.models.list",
+            "mobile.chat.send",
+            "mobile.chat.interrupt",
             // Socket-reachable panel artifact reads (worker lane); fetch stays
             // behind the authenticated mobile execution context.
             "mobile.panel.artifact.stat",

Sources/TerminalController+ControlMobileHostContext.swift

@@ -77,6 +77,20 @@ extension TerminalController: ControlMobileHostContext {
         )
     }
 
+    nonisolated func controlMobileChatSend(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult {
+        let params = foundationParams(params)
+        return bridgeMobileResult(await v2MobileChatSend(params: params))
+    }
+
+    nonisolated func controlMobileChatInterrupt(
+        params: [String: JSONValue]
+    ) async -> ControlCallResult {
+        let params = foundationParams(params)
+        return bridgeMobileResult(await v2MobileChatInterrupt(params: params))
+    }
+
     func controlMobileChatSessionsDump() -> ControlCallResult {
         bridgeMobileResult(v2ChatSessionsDump())
     }

Sources/TerminalController.swift

@@ -1308,7 +1308,7 @@ class TerminalController {
                     await self.v2SurfaceReadSelection(params: parsedRequest.params)
                 }
             }
-            if request.method == "mobile.task.models.list" {
+            if ["mobile.task.models.list", "mobile.chat.send", "mobile.chat.interrupt"].contains(request.method) {
                 return v2AsyncResultCall(
                     id: request.id,
                     timeoutSeconds: 7

Sources/Workspace+AgentChat.swift

@@ -9,4 +9,43 @@ extension Workspace {
             preferredWindow: presentingWindow
         )
     }
+
+    /// Opens a read-only chat view of the agent running in a terminal panel.
+    /// The agent-chat sidecar renders the agent's own transcript, so the
+    /// terminal process stays the only agent.
+    func openTerminalChatView(terminalPanelId: UUID, presentingWindow: NSWindow?) {
+        guard let owningTabManager, let appDelegate = AppDelegate.shared else {
+            NSSound.beep()
+            return
+        }
+        Task { @MainActor [weak self, weak owningTabManager] in
+            guard let owningTabManager,
+                  let base = await appDelegate.agentChatBrowserBaseURL(
+                      tabManager: owningTabManager,
+                      preferredWindow: presentingWindow
+                  ),
+                  let self,
+                  let url = Self.terminalChatViewURL(base: base, terminalPanelId: terminalPanelId),
+                  self.newBrowserSplit(
+                      from: terminalPanelId,
+                      orientation: .horizontal,
+                      url: url,
+                      transparentBackground: true
+                  ) != nil else {
+                NSSound.beep()
+                return
+            }
+        }
+    }
+
+    /// `<sidecar>/terminal/<panel id>?transparent=1`; the sidecar maps the
+    /// panel to its agent session through the hook session stores.
+    static func terminalChatViewURL(base: URL, terminalPanelId: UUID) -> URL? {
+        let path = base
+            .appendingPathComponent("terminal", isDirectory: true)
+            .appendingPathComponent(terminalPanelId.uuidString)
+        var components = URLComponents(url: path, resolvingAgainstBaseURL: false)
+        components?.queryItems = [URLQueryItem(name: "transparent", value: "1")]
+        return components?.url
+    }
 }

agent-chat/README.md

@@ -12,6 +12,12 @@ Three entrypoints, all landing on the same server:
 
 One page = one session: `/` is the composer, `/s/<id>` a chat. When `CMUX_AGENT_CHAT_TOKEN` or `--token` is configured, every HTTP route, static asset, API route, and WebSocket upgrade except `/healthz` must be under `/<token>/...`; missing or wrong tokens return 404. There is deliberately no in-page session list or header; each chat is its own cmux workspace tab (page title = first prompt), so cmux's sidebar is the session list.
 
+## Terminal chat view
+
+`/terminal/<surface-id>` shows a Claude Code or Codex session that is already running in a cmux terminal as a chat, without starting another agent. The sidecar looks the surface up in the hook session stores (`~/.cmuxterm/claude-hook-sessions.json`, `~/.cmuxterm/codex-hook-sessions.json`), tails the agent's own transcript (Claude `projects/<slug>/<session>.jsonl`, Codex `sessions/YYYY/MM/DD/rollout-*-<session>.jsonl`), and normalizes it into `AgentEvent`s with `adapters/transcript.ts`, so the regular chat renderer draws it. The page lives at `/s/t-<agent session id>`, which re-resolves after a sidecar restart; a view with no open page stops tailing after five minutes.
+
+The terminal stays the source of truth. The composer types the prompt into the terminal's agent with `mobile.chat.send` (bracketed paste and submit, the delivery the iOS chat uses), and Stop or Esc sends `mobile.chat.interrupt`; both go over the cmux control socket through `cmux rpc` (`cmux-rpc.ts`, using the `CMUX_BUNDLED_CLI_PATH` and `CMUX_SOCKET_PATH` the app passes to the sidecar). The prompt shows immediately and is replaced by the transcript's own copy when it lands. Permission prompts, questions, and pickers stay in the terminal: when the hook store says the agent needs input, the view shows the request with an "Answer in terminal" button that focuses the terminal pane. Open the view with "Open terminal as chat" in the command palette (Agent Chat UI flag) or `cmux-chat --terminal --surface <surface-id>` from a shell.
+
 ## Model catalog
 
 The sidecar fetches the model catalog from `https://cmux.dev/api/agent-models` (`CMUX_AGENT_MODELS_URL` overrides it for development), revalidates it with ETags after a one-hour TTL, and caches the last-good response at `~/.cache/cmux-agent-chat/models.json` for offline startup. Refreshes happen in the background; changed catalogs are pushed to open pages so model pickers update without reloading.