Fix App Control shell hijacking chat CLI terminal routing (#371)

* Fix App Control shell hijacking chat CLI terminal routing

App Control launches a shell PTY with the parent chatSessionId for sidebar
nesting, but that overwrote activeTerminalByChatSession and caused
activeForChat/reattachChatCli to target the Electron dev shell instead of
the agent CLI — sending resume commands and signals to the wrong process.

Partition routing: chat-CLI sessions own the active map; auxiliary shells
are resolved separately for read/write/list vs activeForChat/reattach.

Co-authored-by: Arul Sharma <arul28@users.noreply.github.com>

* fix: preserve chat terminal routing

* ship: iteration 1 - address review feedback

* ship: align action audit with main

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: Arul Sharma <arul28@users.noreply.github.com>
Co-authored-by: Arul Sharma <31745423+arul28@users.noreply.github.com>

Author: 3 people

apps/desktop/src/main/services/pty/ptyService.test.ts

@@ -4557,6 +4557,87 @@ describe("ptyService", () => {
         expect(result.ptyId).toBe(created.ptyId);
       });
 
+      it("prefers chat CLI over a newer App Control shell with the same chatSessionId", async () => {
+        const { service } = createChatHarness();
+        const chatCli = await service.create({
+          sessionId: "chat-app-control",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-app-control",
+          tracked: true,
+          toolType: "claude-chat",
+          startupCommand: "claude --resume target",
+        });
+        const appControlShell = await service.create({
+          laneId: "lane-1",
+          title: "App Control",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-app-control",
+          tracked: true,
+          toolType: "shell",
+          startupCommand: "npm run dev",
+        });
+
+        const active = service.activeForChat({ chatSessionId: "chat-app-control" });
+        expect(active?.terminalId).toBe(chatCli.sessionId);
+        expect(active?.terminalId).not.toBe(appControlShell.sessionId);
+
+        const reattached = await service.reattachChatCli({ chatSessionId: "chat-app-control" });
+        expect(reattached.relaunched).toBe(false);
+        expect(reattached.terminalId).toBe(chatCli.sessionId);
+        expect(reattached.ptyId).toBe(chatCli.ptyId);
+      });
+
+      it("routes terminal operations to the App Control shell without making it the active chat CLI", async () => {
+        const { service, loadPty, sessionService } = createChatHarness();
+        const chatPty = createMockPty();
+        const appControlPty = createMockPty();
+        const spawn = vi.fn()
+          .mockReturnValueOnce(chatPty)
+          .mockReturnValueOnce(appControlPty);
+        loadPty.mockReturnValue({ spawn });
+
+        const chatCli = await service.create({
+          sessionId: "chat-app-control-routing",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-app-control-routing",
+          tracked: true,
+          toolType: "claude-chat",
+          startupCommand: "claude --resume target",
+        });
+        const appControlShell = await service.create({
+          laneId: "lane-1",
+          title: "App Control",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-app-control-routing",
+          tracked: true,
+          toolType: "shell",
+          startupCommand: "npm run dev",
+        });
+        (chatPty.write as ReturnType<typeof vi.fn>).mockClear();
+        (appControlPty.write as ReturnType<typeof vi.fn>).mockClear();
+        sessionService.readTranscriptTail.mockResolvedValueOnce("app control output");
+
+        const read = await service.readTerminal({ chatSessionId: "chat-app-control-routing" });
+        await service.writeTerminal({ chatSessionId: "chat-app-control-routing", data: "q\n" });
+        service.signalTerminal({ chatSessionId: "chat-app-control-routing", signal: "SIGINT" });
+
+        expect(read.terminalId).toBe(appControlShell.sessionId);
+        expect(appControlPty.write).toHaveBeenNthCalledWith(1, "q\n");
+        expect(appControlPty.write).toHaveBeenNthCalledWith(2, "\x03");
+        expect(chatPty.write).not.toHaveBeenCalled();
+        expect(service.activeForChat({ chatSessionId: "chat-app-control-routing" })?.terminalId).toBe(chatCli.sessionId);
+      });
+
       it("relaunches a new PTY for a disposed chat-CLI session", async () => {
         const { service, loadPty, sessionStore } = createChatHarness();
         const created = await service.create({

apps/desktop/src/main/services/pty/ptyService.ts

@@ -929,6 +929,7 @@ export function createPtyService({
   const exitListeners = new Set<PtyExitListener>();
   const terminalChatSessions = new Map<string, string>();
   const activeTerminalByChatSession = new Map<string, string>();
+  const activeAuxiliaryTerminalByChatSession = new Map<string, string>();
   const missingResumeTargetBackfillFailures = new Map<string, { toolType: TerminalToolType | null; checkedAtMs: number }>();
   const claudeTitleCaptureKeys = new Set<string>();
   const resumeRuntimeFlights = new Map<string, Promise<PtyCreateResult>>();
@@ -2438,20 +2439,30 @@ export function createPtyService({
     const finalRuntimeState = runtimeFromStatus(status);
     setRuntimeState(entry.sessionId, finalRuntimeState, { touch: false });
     runtimeStates.delete(entry.sessionId);
-    if (entry.chatSessionId && activeTerminalByChatSession.get(entry.chatSessionId) === entry.sessionId) {
-      const replacement = Array.from(ptys.values())
-        .filter((candidate) => (
-          candidate.sessionId !== entry.sessionId
-          && !candidate.disposed
-          && candidate.chatSessionId === entry.chatSessionId
-        ))
-        .sort((a, b) => b.createdAt - a.createdAt)[0] ?? null;
+    if (
+      entry.chatSessionId
+      && isChatCliRoutingEntry(entry)
+      && activeTerminalByChatSession.get(entry.chatSessionId) === entry.sessionId
+    ) {
+      const replacement = liveChatCliEntriesFor(entry.chatSessionId)[0] ?? null;
       if (replacement) {
         activeTerminalByChatSession.set(entry.chatSessionId, replacement.sessionId);
       } else {
         activeTerminalByChatSession.delete(entry.chatSessionId);
       }
     }
+    if (
+      entry.chatSessionId
+      && isAuxiliaryRoutingEntry(entry)
+      && activeAuxiliaryTerminalByChatSession.get(entry.chatSessionId) === entry.sessionId
+    ) {
+      const replacement = liveAuxiliaryEntriesFor(entry.chatSessionId)[0] ?? null;
+      if (replacement) {
+        activeAuxiliaryTerminalByChatSession.set(entry.chatSessionId, replacement.sessionId);
+      } else {
+        activeAuxiliaryTerminalByChatSession.delete(entry.chatSessionId);
+      }
+    }
     try {
       onSessionRuntimeSignal?.({
         laneId: entry.laneId,
@@ -2692,6 +2703,89 @@ export function createPtyService({
     Array.from(ptys.entries()).find(([, entry]) => entry.sessionId === sessionId && !entry.disposed) ?? null
   );
 
+  const isChatCliRoutingEntry = (entry: PtyEntry): boolean =>
+    isPersistedChatToolType(entry.toolTypeHint);
+
+  const isAuxiliaryRoutingEntry = (entry: PtyEntry): boolean =>
+    !isChatCliRoutingEntry(entry);
+
+  const liveChatCliEntriesFor = (chatSessionId: string): PtyEntry[] =>
+    Array.from(ptys.values())
+      .filter((entry) => (
+        entry.chatSessionId === chatSessionId
+        && !entry.disposed
+        && isChatCliRoutingEntry(entry)
+      ))
+      .sort((a, b) => b.createdAt - a.createdAt);
+
+  const liveAuxiliaryEntriesFor = (chatSessionId: string): PtyEntry[] =>
+    Array.from(ptys.values())
+      .filter((entry) => (
+        entry.chatSessionId === chatSessionId
+        && !entry.disposed
+        && isAuxiliaryRoutingEntry(entry)
+      ))
+      .sort((a, b) => b.createdAt - a.createdAt);
+
+  const activeEntryFromMap = (
+    map: Map<string, string>,
+    chatSessionId: string,
+    predicate: (entry: PtyEntry) => boolean,
+  ): PtyEntry | null => {
+    const sessionId = map.get(chatSessionId) ?? null;
+    if (!sessionId) return null;
+    const live = liveEntryBySessionId(sessionId);
+    if (live && live[1].chatSessionId === chatSessionId && predicate(live[1])) return live[1];
+    map.delete(chatSessionId);
+    return null;
+  };
+
+  const activeChatCliEntryFor = (chatSessionId: string): PtyEntry | null => {
+    const active = activeEntryFromMap(activeTerminalByChatSession, chatSessionId, isChatCliRoutingEntry);
+    if (active) return active;
+    const replacement = liveChatCliEntriesFor(chatSessionId)[0] ?? null;
+    if (replacement) activeTerminalByChatSession.set(chatSessionId, replacement.sessionId);
+    return replacement;
+  };
+
+  const activeAuxiliaryEntryFor = (chatSessionId: string): PtyEntry | null => {
+    const active = activeEntryFromMap(activeAuxiliaryTerminalByChatSession, chatSessionId, isAuxiliaryRoutingEntry);
+    if (active) return active;
+    const replacement = liveAuxiliaryEntriesFor(chatSessionId)[0] ?? null;
+    if (replacement) activeAuxiliaryTerminalByChatSession.set(chatSessionId, replacement.sessionId);
+    return replacement;
+  };
+
+  const promoteActiveChatCliTerminal = (
+    chatSessionId: string,
+    sessionId: string,
+    toolType: TerminalToolType | null,
+  ): void => {
+    if (!isPersistedChatToolType(toolType)) return;
+    activeTerminalByChatSession.set(chatSessionId, sessionId);
+  };
+
+  const promoteActiveAuxiliaryTerminal = (
+    chatSessionId: string,
+    sessionId: string,
+    toolType: TerminalToolType | null,
+  ): void => {
+    if (isPersistedChatToolType(toolType)) return;
+    activeAuxiliaryTerminalByChatSession.set(chatSessionId, sessionId);
+  };
+
+  const promoteActiveChatTerminal = (
+    chatSessionId: string,
+    sessionId: string,
+    toolType: TerminalToolType | null,
+  ): void => {
+    if (isPersistedChatToolType(toolType)) {
+      promoteActiveChatCliTerminal(chatSessionId, sessionId, toolType);
+    } else {
+      promoteActiveAuxiliaryTerminal(chatSessionId, sessionId, toolType);
+    }
+  };
+
   const codexReadyRegion = (text: string): string => {
     const lastPrompt = text.lastIndexOf("›");
     if (lastPrompt < 0) return text;
@@ -2858,8 +2952,15 @@ export function createPtyService({
       ?? live?.[1].chatSessionId
       ?? summary.chatSessionId
       ?? null;
-    const activeTerminalId = chatSessionId ? activeTerminalByChatSession.get(chatSessionId) ?? null : null;
     const fallbackStatus = live ? "running" : summary.status;
+    let active = false;
+    if (chatSessionId) {
+      if (isPersistedChatToolType(summary.toolType)) {
+        active = activeChatCliEntryFor(chatSessionId)?.sessionId === summary.id;
+      } else {
+        active = activeAuxiliaryEntryFor(chatSessionId)?.sessionId === summary.id;
+      }
+    }
     return {
       terminalId: summary.id,
       ptyId: live?.[0] ?? summary.ptyId ?? null,
@@ -2871,7 +2972,7 @@ export function createPtyService({
       goal: summary.goal,
       status: fallbackStatus,
       runtimeState: computeRuntimeState(summary.id, fallbackStatus),
-      active: Boolean(activeTerminalId && activeTerminalId === summary.id),
+      active,
       startedAt: summary.startedAt,
       endedAt: live ? null : summary.endedAt,
       exitCode: live ? null : summary.exitCode,
@@ -2891,17 +2992,8 @@ export function createPtyService({
     if (terminalId) return terminalId;
     const chatSessionId = cleanOptionalId(args.chatSessionId);
     if (!chatSessionId) return null;
-    const activeTerminalId = activeTerminalByChatSession.get(chatSessionId) ?? null;
-    if (activeTerminalId && liveEntryBySessionId(activeTerminalId)) return activeTerminalId;
-    const replacement = Array.from(ptys.values())
-      .filter((entry) => entry.chatSessionId === chatSessionId && !entry.disposed)
-      .sort((a, b) => b.createdAt - a.createdAt)[0] ?? null;
-    if (replacement) {
-      activeTerminalByChatSession.set(chatSessionId, replacement.sessionId);
-      return replacement.sessionId;
-    }
-    activeTerminalByChatSession.delete(chatSessionId);
-    return null;
+    // Auxiliary terminals (shell, App Control, etc.) — never route chat-CLI rows.
+    return activeAuxiliaryEntryFor(chatSessionId)?.sessionId ?? null;
   };
 
   const service = {
@@ -2963,7 +3055,7 @@ export function createPtyService({
         if (chatSessionId) {
           attachedEntry.chatSessionId = chatSessionId;
           terminalChatSessions.set(existingSession.id, chatSessionId);
-          activeTerminalByChatSession.set(chatSessionId, existingSession.id);
+          promoteActiveChatTerminal(chatSessionId, existingSession.id, attachedEntry.toolTypeHint);
           if (existingSession.chatSessionId !== chatSessionId) {
             try { sessionService.setChatSessionId(existingSession.id, chatSessionId); } catch {}
           }
@@ -3262,7 +3354,7 @@ export function createPtyService({
       ptys.set(ptyId, entry);
       if (chatSessionId) {
         terminalChatSessions.set(sessionId, chatSessionId);
-        activeTerminalByChatSession.set(chatSessionId, sessionId);
+        promoteActiveChatTerminal(chatSessionId, sessionId, toolTypeHint);
         if (existingSession && existingSession.chatSessionId !== chatSessionId) {
           try { sessionService.setChatSessionId(sessionId, chatSessionId); } catch {}
         }
@@ -3804,20 +3896,17 @@ export function createPtyService({
     activeForChat(args: ChatTerminalActiveForChatArgs): ChatTerminalSession | null {
       const chatSessionId = cleanOptionalId(args.chatSessionId);
       if (!chatSessionId) return null;
-      const terminalId = activeTerminalByChatSession.get(chatSessionId) ?? null;
-      if (terminalId && liveEntryBySessionId(terminalId)) {
-        const session = sessionService.get(terminalId);
-        return session ? terminalSessionFromSummary(session) : null;
-      }
-      const replacement = Array.from(ptys.values())
-        .filter((entry) => entry.chatSessionId === chatSessionId && !entry.disposed)
-        .sort((a, b) => b.createdAt - a.createdAt)[0] ?? null;
-      if (!replacement) {
-        activeTerminalByChatSession.delete(chatSessionId);
-        return null;
+      const chatCli = activeChatCliEntryFor(chatSessionId);
+      if (chatCli) {
+        const session = sessionService.get(chatCli.sessionId);
+        if (session) {
+          promoteActiveChatCliTerminal(chatSessionId, chatCli.sessionId, session.toolType);
+          return terminalSessionFromSummary(session);
+        }
       }
-      activeTerminalByChatSession.set(chatSessionId, replacement.sessionId);
-      const session = sessionService.get(replacement.sessionId);
+      const auxiliary = activeAuxiliaryEntryFor(chatSessionId);
+      if (!auxiliary) return null;
+      const session = sessionService.get(auxiliary.sessionId);
       return session ? terminalSessionFromSummary(session) : null;
     },
 
@@ -3827,12 +3916,13 @@ export function createPtyService({
 
       // Fast path: an existing live PTY is already bound. Skip the dedup map to
       // keep the no-op cost low.
-      const activeTerminalId = activeTerminalByChatSession.get(chatSessionId) ?? null;
-      if (activeTerminalId) {
-        const liveActive = liveEntryBySessionId(activeTerminalId);
+      const liveChatCli = activeChatCliEntryFor(chatSessionId);
+      if (liveChatCli) {
+        const liveActive = liveEntryBySessionId(liveChatCli.sessionId);
         if (liveActive) {
+          promoteActiveChatCliTerminal(chatSessionId, liveChatCli.sessionId, liveChatCli.toolTypeHint);
           return {
-            terminalId: activeTerminalId,
+            terminalId: liveChatCli.sessionId,
             ptyId: liveActive[0],
             pid: liveActive[1].pty.pid ?? null,
             relaunched: false,

docs/features/terminals-and-sessions/pty-and-processes.md

@@ -316,6 +316,14 @@ user wants to send a message". It only accepts tracked chat-typed
 sessions (`isPersistedChatToolType(toolType)`) — non-chat sessions and
 untracked rows are rejected with a clear error.
 
+Chat-scoped PTYs are partitioned by tool type. Persisted chat tool
+types (`claude-chat`, `codex-chat`, `cursor`, `opencode-chat`,
+`droid-chat`) are the only sessions allowed to own the chat-CLI active
+route used by `activeForChat` and `reattachChatCli`. Auxiliary PTYs
+such as App Control or plain shells may carry the same `chatSessionId`
+so they nest under the parent chat, but they are tracked in a separate
+auxiliary active route for `terminal.read` / `write` / `signal`.
+
 Behaviour:
 
 - Fast path: if a live PTY is already bound to the chat session, the