diff --git a/.env b/.env
new file mode 100644
index 0000000..95d0ab1
--- /dev/null
+++ b/.env
@@ -0,0 +1 @@
+AGENTAPI_ALLOWED_HOSTS="dev.otherstuff.studio dev.otherstuff.ai localhost"
diff --git a/AGENTS.md b/AGENTS.md
index d0397a3..44cb280 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -21,6 +21,7 @@ This file provides guidance to AI agents working with code in this repository.
 - `agentapi server -- goose` - Start server with Goose agent
 - `agentapi server --type=codex -- codex` - Start server with Codex (requires explicit type)
 - `agentapi server --type=gemini -- gemini` - Start server with Gemini (requires explicit type)
+- `agentapi server --tmux-session=my-app -- claude` - Override the tmux session name (defaults to `wingman-agents`)
 - `agentapi attach --url localhost:3284` - Attach to running agent terminal
 - Server runs on port 3284 by default
 - Chat UI available at http://localhost:3284/chat
diff --git a/chat/src/components/message-input.tsx b/chat/src/components/message-input.tsx
index 0748dee..edd9705 100644
--- a/chat/src/components/message-input.tsx
+++ b/chat/src/components/message-input.tsx
@@ -7,6 +7,7 @@ import {
   ArrowLeftIcon,
   ArrowRightIcon,
   ArrowUpIcon,
+  Command as CommandIcon,
   CornerDownLeftIcon,
   DeleteIcon,
   SendIcon,
@@ -14,6 +15,12 @@ import {
   Square,
 } from "lucide-react";
 import {Tabs, TabsList, TabsTrigger} from "./ui/tabs";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "./ui/dropdown-menu";
 import type {ServerStatus} from "./chat-provider";
 import TextareaAutosize from "react-textarea-autosize";
 import {useChat} from "./chat-provider";
@@ -50,6 +57,32 @@ const specialKeys: Record<string, string> = {
   Backspace: "\b", // Backspace key
 };
 
+const SHIFT_TAB_SEQUENCE = "\x1b[Z";
+const CLEAR_SCREEN_SEQUENCE = "\x0C";
+
+interface ControlAction {
+  id: string;
+  label: string;
+  display: string;
+  sequence: string;
+}
+
+const CONTROL_ACTIONS: ControlAction[] = [
+  {id: "escape", label: "Esc", display: "Esc", sequence: specialKeys.Escape},
+  {id: "enter", label: "Enter", display: "⏎", sequence: "\r"},
+  {id: "tab", label: "Tab", display: "Tab", sequence: specialKeys.Tab},
+  {id: "shift-tab", label: "Shift+Tab", display: "Shift+Tab", sequence: SHIFT_TAB_SEQUENCE},
+  {id: "one-enter", label: "1 + Enter", display: "1⏎", sequence: "1\r"},
+  {id: "two-enter", label: "2 + Enter", display: "2⏎", sequence: "2\r"},
+  {id: "three-enter", label: "3 + Enter", display: "3⏎", sequence: "3\r"},
+  {id: "ctrl-c", label: "Ctrl+C", display: "Ctrl+C", sequence: "\x03"},
+  {id: "arrow-up", label: "Up", display: "ArrowUp", sequence: specialKeys.ArrowUp},
+  {id: "arrow-down", label: "Down", display: "ArrowDown", sequence: specialKeys.ArrowDown},
+  {id: "arrow-left", label: "Left", display: "ArrowLeft", sequence: specialKeys.ArrowLeft},
+  {id: "arrow-right", label: "Right", display: "ArrowRight", sequence: specialKeys.ArrowRight},
+  {id: "clear", label: "Clear", display: "Clear", sequence: CLEAR_SCREEN_SEQUENCE},
+];
+
 export default function MessageInput({
   onSendMessage,
   disabled = false,
@@ -121,9 +154,25 @@ export default function MessageInput({
     setSentChars((prev) => [...prev, newChar]);
   };
 
+  const handleControlAction = (action: ControlAction) => {
+    if (disabled || inputMode !== "control") {
+      return;
+    }
+    addSentChar(action.display);
+    onSendMessage(action.sequence, "raw");
+    textareaRef.current?.focus();
+  };
+
   const handleKeyDown = (e: KeyboardEvent<HTMLTextAreaElement>) => {
     // In control mode, send special keys as raw messages
     if (inputMode === "control" && !disabled) {
+      if (e.key === "Tab" && e.shiftKey) {
+        e.preventDefault();
+        addSentChar("Shift+Tab");
+        onSendMessage(SHIFT_TAB_SEQUENCE, "raw");
+        return;
+      }
+
       // Check if the pressed key is in our special keys map
       if (specialKeys[e.key]) {
         e.preventDefault();
@@ -241,26 +290,54 @@ export default function MessageInput({
               </div>
 
               <div className="flex items-center justify-between p-4">
-                <TabsList className="bg-transparent">
-                  <TabsTrigger
-                    value="text"
-                    onClick={() => {
-                      textareaRef.current?.focus();
-                    }}
-                  >
-                    Text
-                  </TabsTrigger>
-                  <TabsTrigger
-                    value="control"
-                    onClick={() => {
-                      textareaRef.current?.focus();
-                    }}
-                  >
-                    Control
-                  </TabsTrigger>
-                </TabsList>
+                <div className="flex items-center gap-2">
+                  <TabsList className="bg-transparent">
+                    <TabsTrigger
+                      value="text"
+                      onClick={() => {
+                        textareaRef.current?.focus();
+                      }}
+                    >
+                      Text
+                    </TabsTrigger>
+                    <TabsTrigger
+                      value="control"
+                      onClick={() => {
+                        textareaRef.current?.focus();
+                      }}
+                    >
+                      Control
+                    </TabsTrigger>
+                  </TabsList>
+
+                  {inputMode === "control" && !disabled && (
+                    <DropdownMenu>
+                      <DropdownMenuTrigger asChild>
+                        <Button
+                          type="button"
+                          variant="outline"
+                          size="sm"
+                          className="gap-1"
+                        >
+                          <CommandIcon className="h-4 w-4"/>
+                          Cmd Menu
+                        </Button>
+                      </DropdownMenuTrigger>
+                      <DropdownMenuContent align="start" className="w-44">
+                        {CONTROL_ACTIONS.map((action) => (
+                          <DropdownMenuItem
+                            key={action.id}
+                            onSelect={() => handleControlAction(action)}
+                          >
+                            {action.label}
+                          </DropdownMenuItem>
+                        ))}
+                      </DropdownMenuContent>
+                    </DropdownMenu>
+                  )}
+                </div>
 
-                <div className={"flex flex-row gap-3"}>
+                <div className="flex flex-row items-center gap-3">
                   <Button
                     type="submit"
                     size="icon"
diff --git a/cmd/server/server.go b/cmd/server/server.go
index 3afe050..69728f9 100644
--- a/cmd/server/server.go
+++ b/cmd/server/server.go
@@ -7,8 +7,13 @@ import (
 	"log/slog"
 	"net/http"
 	"os"
+	"os/signal"
 	"sort"
 	"strings"
+	"sync"
+	"syscall"
+	"time"
+	"unicode"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
@@ -80,6 +85,7 @@ func runServer(ctx context.Context, logger *slog.Logger, argsToPass []string) er
 
 	termWidth := viper.GetUint16(FlagTermWidth)
 	termHeight := viper.GetUint16(FlagTermHeight)
+	tmuxSession := viper.GetString(FlagTmuxSession)
 
 	if termWidth < 10 {
 		return xerrors.Errorf("term width must be at least 10")
@@ -99,18 +105,25 @@ func runServer(ctx context.Context, logger *slog.Logger, argsToPass []string) er
 			TerminalWidth:  termWidth,
 			TerminalHeight: termHeight,
 			AgentType:      agentType,
+			SessionName:    tmuxSession,
 		})
 		if err != nil {
 			return xerrors.Errorf("failed to setup process: %w", err)
 		}
 	}
+	allowedHosts := viper.GetStringSlice(FlagAllowedHosts)
+	if envHosts := parseEnvList(os.Getenv("ALLOW_HOSTS")); len(envHosts) > 0 {
+		logger.Info("Using allowed hosts from ALLOW_HOSTS env", "hosts", strings.Join(envHosts, ", "))
+		allowedHosts = envHosts
+	}
+
 	port := viper.GetInt(FlagPort)
 	srv, err := httpapi.NewServer(ctx, httpapi.ServerConfig{
 		AgentType:      agentType,
 		Process:        process,
 		Port:           port,
 		ChatBasePath:   viper.GetString(FlagChatBasePath),
-		AllowedHosts:   viper.GetStringSlice(FlagAllowedHosts),
+		AllowedHosts:   allowedHosts,
 		AllowedOrigins: viper.GetStringSlice(FlagAllowedOrigins),
 		InitialPrompt:  viper.GetString(FlagInitialPrompt),
 	})
@@ -123,6 +136,22 @@ func runServer(ctx context.Context, logger *slog.Logger, argsToPass []string) er
 	}
 	srv.StartSnapshotLoop(ctx)
 	logger.Info("Starting server on port", "port", port)
+	stopOnce := &sync.Once{}
+	stopServer := func(reason string) {
+		stopOnce.Do(func() {
+			logger.Info("Stopping server", "reason", reason)
+			stopCtx, stopCancel := context.WithTimeout(context.Background(), 10*time.Second)
+			defer stopCancel()
+			if err := srv.Stop(stopCtx); err != nil && err != context.Canceled && err != http.ErrServerClosed {
+				logger.Error("Failed to stop server", "error", err)
+			}
+		})
+	}
+
+	signalCh := make(chan os.Signal, 1)
+	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
+	defer signal.Stop(signalCh)
+
 	processExitCh := make(chan error, 1)
 	go func() {
 		defer close(processExitCh)
@@ -133,19 +162,79 @@ func runServer(ctx context.Context, logger *slog.Logger, argsToPass []string) er
 				processExitCh <- xerrors.Errorf("failed to wait for process: %w", err)
 			}
 		}
-		if err := srv.Stop(ctx); err != nil {
-			logger.Error("Failed to stop server", "error", err)
-		}
 	}()
-	if err := srv.Start(); err != nil && err != context.Canceled && err != http.ErrServerClosed {
-		return xerrors.Errorf("failed to start server: %w", err)
+
+	serverErrCh := make(chan error, 1)
+	go func() {
+		err := srv.Start()
+		serverErrCh <- err
+		close(serverErrCh)
+	}()
+
+	var (
+		processErr     error
+		processDone    bool
+		receivedSignal bool
+	)
+
+	for {
+		select {
+		case sig := <-signalCh:
+			if receivedSignal {
+				logger.Warn("Second signal received, forcing exit", "signal", sig)
+				os.Exit(1)
+			}
+			receivedSignal = true
+			logger.Info("Signal received, shutting down", "signal", sig)
+			if err := process.Close(logger, 5*time.Second); err != nil {
+				logger.Error("Error closing process", "error", err)
+			}
+			stopServer("signal")
+		case err, ok := <-processExitCh:
+			if !ok {
+				processExitCh = nil
+				continue
+			}
+			processDone = true
+			processErr = err
+			stopServer("process exited")
+			processExitCh = nil
+		case err, ok := <-serverErrCh:
+			if !ok {
+				serverErrCh = nil
+				continue
+			}
+			if err != nil && err != http.ErrServerClosed && err != context.Canceled {
+				stopServer("server error")
+				return xerrors.Errorf("failed to start server: %w", err)
+			}
+			serverErrCh = nil
+		}
+
+		if serverErrCh == nil && processExitCh == nil {
+			if processDone && processErr != nil {
+				return xerrors.Errorf("agent exited with error: %w", processErr)
+			}
+			return nil
+		}
 	}
-	select {
-	case err := <-processExitCh:
-		return xerrors.Errorf("agent exited with error: %w", err)
-	default:
+}
+
+func parseEnvList(raw string) []string {
+	if strings.TrimSpace(raw) == "" {
+		return nil
+	}
+	fields := strings.FieldsFunc(raw, func(r rune) bool {
+		return r == ',' || unicode.IsSpace(r)
+	})
+	out := make([]string, 0, len(fields))
+	for _, item := range fields {
+		trimmed := strings.TrimSpace(item)
+		if trimmed != "" {
+			out = append(out, trimmed)
+		}
 	}
-	return nil
+	return out
 }
 
 var agentNames = (func() []string {
@@ -172,6 +261,7 @@ const (
 	FlagChatBasePath   = "chat-base-path"
 	FlagTermWidth      = "term-width"
 	FlagTermHeight     = "term-height"
+	FlagTmuxSession    = "tmux-session"
 	FlagAllowedHosts   = "allowed-hosts"
 	FlagAllowedOrigins = "allowed-origins"
 	FlagExit           = "exit"
@@ -209,6 +299,7 @@ func CreateServerCmd() *cobra.Command {
 		{FlagChatBasePath, "c", "/chat", "Base path for assets and routes used in the static files of the chat interface", "string"},
 		{FlagTermWidth, "W", uint16(80), "Width of the emulated terminal", "uint16"},
 		{FlagTermHeight, "H", uint16(1000), "Height of the emulated terminal", "uint16"},
+		{FlagTmuxSession, "", termexec.DefaultTmuxSessionName, "Name of the tmux session used to host agent processes", "string"},
 		// localhost is the default host for the server. Port is ignored during matching.
 		{FlagAllowedHosts, "a", []string{"localhost", "127.0.0.1", "[::1]"}, "HTTP allowed hosts (hostnames only, no ports). Use '*' for all, comma-separated list via flag, space-separated list via AGENTAPI_ALLOWED_HOSTS env var", "stringSlice"},
 		// localhost:3284 is the default origin when you open the chat interface in your browser. localhost:3000 and 3001 are used during development.
diff --git a/cmd/server/server_test.go b/cmd/server/server_test.go
index bd07fc6..4254b8d 100644
--- a/cmd/server/server_test.go
+++ b/cmd/server/server_test.go
@@ -10,6 +10,8 @@ import (
 	"github.com/spf13/viper"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+
+	"github.com/coder/agentapi/lib/termexec"
 )
 
 type nullWriter struct{}
@@ -230,6 +232,7 @@ func TestServerCmd_AllArgs_Defaults(t *testing.T) {
 		{"chat-base-path default", FlagChatBasePath, "/chat", func() any { return viper.GetString(FlagChatBasePath) }},
 		{"term-width default", FlagTermWidth, uint16(80), func() any { return viper.GetUint16(FlagTermWidth) }},
 		{"term-height default", FlagTermHeight, uint16(1000), func() any { return viper.GetUint16(FlagTermHeight) }},
+		{"tmux-session default", FlagTmuxSession, termexec.DefaultTmuxSessionName, func() any { return viper.GetString(FlagTmuxSession) }},
 		{"allowed-hosts default", FlagAllowedHosts, []string{"localhost", "127.0.0.1", "[::1]"}, func() any { return viper.GetStringSlice(FlagAllowedHosts) }},
 		{"allowed-origins default", FlagAllowedOrigins, []string{"http://localhost:3284", "http://localhost:3000", "http://localhost:3001"}, func() any { return viper.GetStringSlice(FlagAllowedOrigins) }},
 	}
@@ -264,6 +267,7 @@ func TestServerCmd_AllEnvVars(t *testing.T) {
 		{"AGENTAPI_CHAT_BASE_PATH", "AGENTAPI_CHAT_BASE_PATH", "/api", "/api", func() any { return viper.GetString(FlagChatBasePath) }},
 		{"AGENTAPI_TERM_WIDTH", "AGENTAPI_TERM_WIDTH", "120", uint16(120), func() any { return viper.GetUint16(FlagTermWidth) }},
 		{"AGENTAPI_TERM_HEIGHT", "AGENTAPI_TERM_HEIGHT", "500", uint16(500), func() any { return viper.GetUint16(FlagTermHeight) }},
+		{"AGENTAPI_TMUX_SESSION", "AGENTAPI_TMUX_SESSION", "custom-session", "custom-session", func() any { return viper.GetString(FlagTmuxSession) }},
 		{"AGENTAPI_ALLOWED_HOSTS", "AGENTAPI_ALLOWED_HOSTS", "localhost example.com", []string{"localhost", "example.com"}, func() any { return viper.GetStringSlice(FlagAllowedHosts) }},
 		{"AGENTAPI_ALLOWED_ORIGINS", "AGENTAPI_ALLOWED_ORIGINS", "https://example.com http://localhost:3000", []string{"https://example.com", "http://localhost:3000"}, func() any { return viper.GetStringSlice(FlagAllowedOrigins) }},
 	}
@@ -336,6 +340,13 @@ func TestServerCmd_ArgsPrecedenceOverEnv(t *testing.T) {
 			uint16(600),
 			func() any { return viper.GetUint16(FlagTermHeight) },
 		},
+		{
+			"tmux-session: CLI overrides env",
+			"AGENTAPI_TMUX_SESSION", "session-env",
+			[]string{"--tmux-session", "session-cli"},
+			"session-cli",
+			func() any { return viper.GetString(FlagTmuxSession) },
+		},
 		{
 			"allowed-origins: CLI overrides env",
 			"AGENTAPI_ALLOWED_ORIGINS", "https://env-example.com http://localhost:3000",
diff --git a/e2e/echo_test.go b/e2e/echo_test.go
index 5784027..23dc9e7 100644
--- a/e2e/echo_test.go
+++ b/e2e/echo_test.go
@@ -100,14 +100,11 @@ func setup(ctx context.Context, t testing.TB) ([]ScriptEntry, *agentapisdk.Clien
 		cwd, err := os.Getwd()
 		require.NoError(t, err, "Failed to get current working directory")
 		binaryPath = filepath.Join(cwd, "..", "out", "agentapi")
-		_, err = os.Stat(binaryPath)
-		if err != nil {
-			t.Logf("Building binary at %s", binaryPath)
-			buildCmd := exec.CommandContext(ctx, "go", "build", "-o", binaryPath, ".")
-			buildCmd.Dir = filepath.Join(cwd, "..")
-			t.Logf("run: %s", buildCmd.String())
-			require.NoError(t, buildCmd.Run(), "Failed to build binary")
-		}
+		t.Logf("Building binary at %s", binaryPath)
+		buildCmd := exec.CommandContext(ctx, "go", "build", "-o", binaryPath, ".")
+		buildCmd.Dir = filepath.Join(cwd, "..")
+		t.Logf("run: %s", buildCmd.String())
+		require.NoError(t, buildCmd.Run(), "Failed to build binary")
 	}
 
 	serverPort, err := getFreePort()
@@ -116,8 +113,13 @@ func setup(ctx context.Context, t testing.TB) ([]ScriptEntry, *agentapisdk.Clien
 	cwd, err := os.Getwd()
 	require.NoError(t, err, "Failed to get current working directory")
 
+	sessionName := fmt.Sprintf("agentapi-%d-%d-%s", os.Getpid(), serverPort, strings.ToLower(t.Name()))
+	sessionName = strings.ReplaceAll(sessionName, string(os.PathSeparator), "-")
+	sessionName = strings.ReplaceAll(sessionName, "/", "-")
+
 	cmd := exec.CommandContext(ctx, binaryPath, "server",
 		fmt.Sprintf("--port=%d", serverPort),
+		fmt.Sprintf("--tmux-session=%s", sessionName),
 		"--",
 		"go", "run", filepath.Join(cwd, "echo.go"), scriptFilePath)
 
@@ -152,6 +154,7 @@ func setup(ctx context.Context, t testing.TB) ([]ScriptEntry, *agentapisdk.Clien
 			_ = cmd.Process.Kill()
 			_ = cmd.Wait()
 		}
+		_ = exec.Command("tmux", "kill-session", "-t", sessionName).Run()
 		wg.Wait()
 	})
 
diff --git a/lib/httpapi/setup.go b/lib/httpapi/setup.go
index 1620304..72f3ed9 100644
--- a/lib/httpapi/setup.go
+++ b/lib/httpapi/setup.go
@@ -4,10 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"os/signal"
 	"strings"
-	"syscall"
-	"time"
 
 	"github.com/coder/agentapi/lib/logctx"
 	mf "github.com/coder/agentapi/lib/msgfmt"
@@ -20,6 +17,7 @@ type SetupProcessConfig struct {
 	TerminalWidth  uint16
 	TerminalHeight uint16
 	AgentType      mf.AgentType
+	SessionName    string
 }
 
 func SetupProcess(ctx context.Context, config SetupProcessConfig) (*termexec.Process, error) {
@@ -32,6 +30,7 @@ func SetupProcess(ctx context.Context, config SetupProcessConfig) (*termexec.Pro
 		Args:           config.ProgramArgs,
 		TerminalWidth:  config.TerminalWidth,
 		TerminalHeight: config.TerminalHeight,
+		SessionName:    config.SessionName,
 	})
 	if err != nil {
 		logger.Error(fmt.Sprintf("Error starting process: %v", err))
@@ -46,15 +45,5 @@ func SetupProcess(ctx context.Context, config SetupProcessConfig) (*termexec.Pro
 		}
 	}
 
-	// Handle SIGINT (Ctrl+C) and send it to the process
-	signalCh := make(chan os.Signal, 1)
-	signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-signalCh
-		if err := process.Close(logger, 5*time.Second); err != nil {
-			logger.Error("Error closing process", "error", err)
-		}
-	}()
-
 	return process, nil
 }
diff --git a/lib/msgfmt/msgfmt.go b/lib/msgfmt/msgfmt.go
index 0cf1ca8..fc43f52 100644
--- a/lib/msgfmt/msgfmt.go
+++ b/lib/msgfmt/msgfmt.go
@@ -250,6 +250,7 @@ const (
 func formatGenericMessage(message string, userInput string, agentType AgentType) string {
 	message = RemoveUserInput(message, userInput, agentType)
 	message = removeMessageBox(message)
+	message = removeTrailingPrompts(message)
 	message = trimEmptyLines(message)
 	return message
 }
@@ -257,6 +258,7 @@ func formatGenericMessage(message string, userInput string, agentType AgentType)
 func formatCodexMessage(message string, userInput string) string {
 	message = RemoveUserInput(message, userInput, AgentTypeCodex)
 	message = removeCodexInputBox(message)
+	message = removeTrailingPrompts(message)
 	message = trimEmptyLines(message)
 	return message
 }
@@ -264,10 +266,38 @@ func formatCodexMessage(message string, userInput string) string {
 func formatOpencodeMessage(message string, userInput string) string {
 	message = RemoveUserInput(message, userInput, AgentTypeOpencode)
 	message = removeOpencodeMessageBox(message)
+	message = removeTrailingPrompts(message)
 	message = trimEmptyLines(message)
 	return message
 }
 
+func removeTrailingPrompts(message string) string {
+	lines := strings.Split(message, "\n")
+	startIdx := 0
+	for ; startIdx < len(lines); startIdx++ {
+		trimmed := strings.TrimSpace(lines[startIdx])
+		if trimmed == "" || trimmed == ">" {
+			continue
+		}
+		break
+	}
+	if startIdx >= len(lines) {
+		return ""
+	}
+	lines = lines[startIdx:]
+	lastIdx := len(lines) - 1
+	for ; lastIdx >= 0; lastIdx-- {
+		trimmed := strings.TrimSpace(lines[lastIdx])
+		if trimmed == "" {
+			continue
+		}
+		if trimmed != ">" {
+			break
+		}
+	}
+	return strings.Join(lines[:lastIdx+1], "\n")
+}
+
 func FormatAgentMessage(agentType AgentType, message string, userInput string) string {
 	switch agentType {
 	case AgentTypeClaude:
diff --git a/lib/msgfmt/msgfmt_test.go b/lib/msgfmt/msgfmt_test.go
index 780a395..1aba2db 100644
--- a/lib/msgfmt/msgfmt_test.go
+++ b/lib/msgfmt/msgfmt_test.go
@@ -216,6 +216,51 @@ func TestTrimEmptyLines(t *testing.T) {
 	}
 }
 
+func TestRemoveTrailingPrompts(t *testing.T) {
+	cases := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "removes single prompt",
+			input:    "Hello!\n> ",
+			expected: "Hello!",
+		},
+		{
+			name:     "removes prompt with spaces",
+			input:    "Hello!\n   >   ",
+			expected: "Hello!",
+		},
+		{
+			name:     "removes leading prompt",
+			input:    "> \nHello!",
+			expected: "Hello!",
+		},
+		{
+			name:     "only prompts",
+			input:    "> \n> ",
+			expected: "",
+		},
+		{
+			name:     "keeps prompt in middle",
+			input:    "Hello!\n> Something\nDone",
+			expected: "Hello!\n> Something\nDone",
+		},
+		{
+			name:     "keeps message without prompt",
+			input:    "Hello!",
+			expected: "Hello!",
+		},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			assert.Equal(t, c.expected, removeTrailingPrompts(c.input))
+		})
+	}
+}
+
 func TestFormatAgentMessage(t *testing.T) {
 	dir := "testdata/format"
 	agentTypes := []AgentType{AgentTypeClaude, AgentTypeGoose, AgentTypeAider, AgentTypeGemini, AgentTypeCopilot, AgentTypeAmp, AgentTypeCodex, AgentTypeCursor, AgentTypeAuggie, AgentTypeAmazonQ, AgentTypeOpencode, AgentTypeCustom}
diff --git a/lib/screentracker/conversation.go b/lib/screentracker/conversation.go
index 4617e8e..6b7dc89 100644
--- a/lib/screentracker/conversation.go
+++ b/lib/screentracker/conversation.go
@@ -291,6 +291,7 @@ func (c *Conversation) writeMessageWithConfirmation(ctx context.Context, message
 		return xerrors.Errorf("failed to write message: %w", err)
 	}
 	// wait for the screen to stabilize after the message is written
+	noEchoDeadline := time.Now().Add(300 * time.Millisecond)
 	if err := util.WaitFor(ctx, util.WaitTimeout{
 		Timeout:     15 * time.Second,
 		MinInterval: 50 * time.Millisecond,
@@ -302,6 +303,9 @@ func (c *Conversation) writeMessageWithConfirmation(ctx context.Context, message
 			newScreen := c.cfg.AgentIO.ReadScreen()
 			return newScreen == screen, nil
 		}
+		if time.Now().After(noEchoDeadline) {
+			return true, nil
+		}
 		return false, nil
 	}); err != nil {
 		return xerrors.Errorf("failed to wait for screen to stabilize: %w", err)
diff --git a/lib/termexec/termexec.go b/lib/termexec/termexec.go
index fd2c04b..e1666c5 100644
--- a/lib/termexec/termexec.go
+++ b/lib/termexec/termexec.go
@@ -1,27 +1,32 @@
 package termexec
 
 import (
+	"bytes"
 	"context"
 	"errors"
-	"io"
+	"fmt"
 	"log/slog"
 	"os"
 	"os/exec"
+	"strconv"
+	"strings"
 	"sync"
-	"syscall"
 	"time"
 
-	"github.com/ActiveState/termtest/xpty"
 	"github.com/coder/agentapi/lib/logctx"
-	"github.com/coder/agentapi/lib/util"
 	"golang.org/x/xerrors"
 )
 
+const DefaultTmuxSessionName = "wingman-agents"
+
 type Process struct {
-	xp               *xpty.Xpty
-	execCmd          *exec.Cmd
-	screenUpdateLock sync.RWMutex
-	lastScreenUpdate time.Time
+	sessionName string
+	paneID      string
+	windowID    string
+	bufferName  string
+	width       uint16
+	height      uint16
+	writeLock   sync.Mutex
 }
 
 type StartProcessConfig struct {
@@ -29,153 +34,393 @@ type StartProcessConfig struct {
 	Args           []string
 	TerminalWidth  uint16
 	TerminalHeight uint16
+	SessionName    string
 }
 
 func StartProcess(ctx context.Context, args StartProcessConfig) (*Process, error) {
 	logger := logctx.From(ctx)
-	xp, err := xpty.New(args.TerminalWidth, args.TerminalHeight, false)
-	if err != nil {
-		return nil, err
+	sessionName := args.SessionName
+	if sessionName == "" {
+		sessionName = DefaultTmuxSessionName
+	}
+	width := args.TerminalWidth
+	height := args.TerminalHeight
+	if width == 0 {
+		width = 80
 	}
-	execCmd := exec.Command(args.Program, args.Args...)
-	// vt100 is the terminal type that the vt10x library emulates.
-	// Setting this signals to the process that it should only use compatible
-	// escape sequences.
-	execCmd.Env = append(os.Environ(), "TERM=vt100")
-	if err := xp.StartProcessInTerminal(execCmd); err != nil {
+	if height == 0 {
+		height = 24
+	}
+
+	sessionExists, err := tmuxSessionExists(ctx, sessionName)
+	if err != nil {
 		return nil, err
 	}
 
-	process := &Process{xp: xp, execCmd: execCmd}
-
-	go func() {
-		// HACK: Working around xpty concurrency limitations
-		//
-		// Problem:
-		// 1. We need to track when the terminal screen was last updated (for ReadScreen)
-		// 2. xpty only updates terminal state through xp.ReadRune()
-		// 3. xp.ReadRune() has a bug - it panics when SetReadDeadline is used
-		// 4. Without deadlines, ReadRune blocks until the process outputs data
-		//
-		// Why this matters:
-		// If we wrapped ReadRune + lastScreenUpdate in a mutex, this goroutine would
-		// hold the lock while waiting for process output. Since ReadRune blocks indefinitely,
-		// ReadScreen callers would be locked out until new output arrives. Even worse,
-		// after output arrives, this goroutine could immediately reacquire the lock
-		// for the next ReadRune call, potentially starving ReadScreen callers indefinitely.
-		//
-		// Solution:
-		// Instead of using xp.ReadRune(), we directly use its internal components:
-		// - pp.ReadRune() - handles the blocking read from the process
-		// - xp.Term.WriteRune() - updates the terminal state
-		//
-		// This lets us apply the mutex only around the terminal update and timestamp,
-		// keeping reads non-blocking while maintaining thread safety.
-		//
-		// Warning: This depends on xpty internals and may break if xpty changes.
-		// A proper fix would require forking xpty or getting upstream changes.
-		pp := util.GetUnexportedField(xp, "pp").(*xpty.PassthroughPipe)
-		for {
-			r, _, err := pp.ReadRune()
-			if err != nil {
-				if err != io.EOF {
-					logger.Error("Error reading from pseudo terminal", "error", err)
-				}
-				// TODO: handle this error better. if this happens, the terminal
-				// state will never be updated anymore and the process will appear
-				// unresponsive.
-				return
+	var paneID string
+	var windowID string
+
+	if !sessionExists {
+		tmuxArgs := []string{"new-session", "-d", "-s", sessionName, "-x", strconv.Itoa(int(width)), "-y", strconv.Itoa(int(height)), "-P", "-F", "#{pane_id},#{window_id}", "--", "env", "TERM=vt100", args.Program}
+		if len(args.Args) > 0 {
+			tmuxArgs = append(tmuxArgs, args.Args...)
+		}
+		cmd := exec.CommandContext(ctx, "tmux", tmuxArgs...)
+		output, startErr := cmd.CombinedOutput()
+		if startErr != nil {
+			return nil, xerrors.Errorf("failed to start tmux session: %w: %s", startErr, output)
+		}
+		paneID, windowID, err = parsePaneWindowIDs(output)
+		if err != nil {
+			return nil, err
+		}
+		logger.Info("tmux session created", "session", sessionName)
+		if err := configureSessionForClients(sessionName); err != nil {
+			logger.Warn("failed to configure tmux session options", "session", sessionName, "error", err)
+		}
+		logger.Info("tmux window created", "session", sessionName, "window", windowID, "pane", paneID)
+	} else {
+		tmuxArgs := []string{"new-window", "-d", "-t", sessionName, "-P", "-F", "#{pane_id},#{window_id}", "--", "env", "TERM=vt100", args.Program}
+		if len(args.Args) > 0 {
+			tmuxArgs = append(tmuxArgs, args.Args...)
+		}
+		cmd := exec.CommandContext(ctx, "tmux", tmuxArgs...)
+		output, startErr := cmd.CombinedOutput()
+		if startErr != nil {
+			return nil, xerrors.Errorf("failed to create tmux window: %w: %s", startErr, output)
+		}
+		paneID, windowID, err = parsePaneWindowIDs(output)
+		if err != nil {
+			return nil, err
+		}
+		if err := configureSessionForClients(sessionName); err != nil {
+			logger.Warn("failed to configure tmux session options", "session", sessionName, "error", err)
+		}
+		resizeWidth := width
+		resizeHeight := height
+		if clientWidth, clientHeight, clientErr := clientSize(sessionName); clientErr == nil {
+			if clientWidth > 0 {
+				resizeWidth = clientWidth
+			}
+			if clientHeight > 0 {
+				resizeHeight = clientHeight
+			}
+		} else if !errors.Is(clientErr, errPaneNotFound) {
+			logger.Warn("failed to look up tmux client size", "session", sessionName, "error", clientErr)
+		}
+		if sessionWidth, sessionHeight, sizeErr := sessionSize(sessionName); sizeErr == nil {
+			if sessionWidth > 0 {
+				resizeWidth = sessionWidth
 			}
-			process.screenUpdateLock.Lock()
-			// writing to the terminal updates its state. without it,
-			// xp.State will always return an empty string
-			xp.Term.WriteRune(r)
-			process.lastScreenUpdate = time.Now()
-			process.screenUpdateLock.Unlock()
+			if sessionHeight > 0 {
+				resizeHeight = sessionHeight
+			}
+		} else {
+			logger.Warn("failed to look up tmux session size", "session", sessionName, "error", sizeErr)
+		}
+		if resizeErr := resizeWindow(windowID, resizeWidth, resizeHeight); resizeErr != nil && !errors.Is(resizeErr, errPaneNotFound) {
+			return nil, resizeErr
 		}
-	}()
+		logger.Info("tmux window created", "session", sessionName, "window", windowID, "pane", paneID)
+	}
 
+	process := &Process{
+		sessionName: sessionName,
+		paneID:      paneID,
+		windowID:    windowID,
+		bufferName:  fmt.Sprintf("%s_buffer_%s", sessionName, strings.TrimPrefix(paneID, "%")),
+		width:       width,
+		height:      height,
+	}
 	return process, nil
 }
 
 func (p *Process) Signal(sig os.Signal) error {
-	return p.execCmd.Process.Signal(sig)
-}
-
-// ReadScreen returns the contents of the terminal window.
-// It waits for the terminal to be stable for 16ms before
-// returning, or 48 ms since it's called, whichever is sooner.
-//
-// This logic acts as a kind of vsync. Agents regularly redraw
-// parts of the screen. If we naively snapshotted the screen,
-// we'd often capture it while it's being updated. This would
-// result in a malformed agent message being returned to the
-// user.
+	// Sending signals is not supported directly when running inside tmux.
+	return xerrors.Errorf("sending signals is not supported for tmux-managed processes")
+}
+
 func (p *Process) ReadScreen() string {
-	for range 3 {
-		p.screenUpdateLock.RLock()
-		if time.Since(p.lastScreenUpdate) >= 16*time.Millisecond {
-			state := p.xp.State.String()
-			p.screenUpdateLock.RUnlock()
-			return state
-		}
-		p.screenUpdateLock.RUnlock()
-		time.Sleep(16 * time.Millisecond)
+	height := p.height
+	if height == 0 {
+		height = 24
 	}
-	return p.xp.State.String()
+	start := fmt.Sprintf("-%d", height)
+	cmd := exec.Command("tmux", "capture-pane", "-t", p.paneID, "-p", "-S", start)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return ""
+	}
+	return string(output)
 }
 
-// Write sends input to the process via the pseudo terminal.
 func (p *Process) Write(data []byte) (int, error) {
-	return p.xp.TerminalInPipe().Write(data)
+	if len(data) == 0 {
+		return 0, nil
+	}
+	p.writeLock.Lock()
+	defer p.writeLock.Unlock()
+
+	loadCmd := exec.Command("tmux", "load-buffer", "-b", p.bufferName, "-")
+	loadCmd.Stdin = bytes.NewReader(data)
+	if output, err := loadCmd.CombinedOutput(); err != nil {
+		return 0, xerrors.Errorf("tmux load-buffer failed: %w: %s", err, output)
+	}
+
+	pasteCmd := exec.Command("tmux", "paste-buffer", "-t", p.paneID, "-b", p.bufferName, "-d")
+	if output, err := pasteCmd.CombinedOutput(); err != nil {
+		return 0, xerrors.Errorf("tmux paste-buffer failed: %w: %s", err, output)
+	}
+	return len(data), nil
 }
 
-// Close closes the process using a SIGINT signal or forcefully killing it if the process
-// does not exit after the timeout. It then closes the pseudo terminal.
 func (p *Process) Close(logger *slog.Logger, timeout time.Duration) error {
 	logger.Info("Closing process")
-	if err := p.execCmd.Process.Signal(os.Interrupt); err != nil {
-		return xerrors.Errorf("failed to send SIGINT to process: %w", err)
+	if err := p.sendKeys("C-c"); err != nil {
+		logger.Warn("failed to send interrupt to tmux session", "error", err)
 	}
-
-	exited := make(chan error, 1)
-	go func() {
-		_, err := p.execCmd.Process.Wait()
-		exited <- err
-		close(exited)
-	}()
-
-	var exitErr error
-	select {
-	case <-time.After(timeout):
-		if err := p.execCmd.Process.Kill(); err != nil {
-			exitErr = xerrors.Errorf("failed to forcefully kill the process: %w", err)
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		dead, _, err := p.paneStatus()
+		if err != nil && !errors.Is(err, errPaneNotFound) {
+			return err
 		}
-		// don't wait for the process to exit to avoid hanging indefinitely
-		// if the process never exits
-	case err := <-exited:
-		var pathErr *os.SyscallError
-		// ECHILD is expected if the process has already exited
-		if err != nil && !(errors.As(err, &pathErr) && pathErr.Err == syscall.ECHILD) {
-			exitErr = xerrors.Errorf("process exited with error: %w", err)
+		if dead || errors.Is(err, errPaneNotFound) {
+			if err := p.killWindow(); err != nil && !errors.Is(err, errPaneNotFound) {
+				return err
+			}
+			return nil
 		}
+		time.Sleep(200 * time.Millisecond)
 	}
-	if err := p.xp.Close(); err != nil {
-		return xerrors.Errorf("failed to close pseudo terminal: %w, exitErr: %w", err, exitErr)
+	if err := p.killWindow(); err != nil && !errors.Is(err, errPaneNotFound) {
+		return err
 	}
-	return exitErr
+	return nil
 }
 
 var ErrNonZeroExitCode = xerrors.New("non-zero exit code")
 
-// Wait waits for the process to exit.
 func (p *Process) Wait() error {
-	state, err := p.execCmd.Process.Wait()
+	for {
+		dead, status, err := p.paneStatus()
+		if err != nil {
+			if errors.Is(err, errPaneNotFound) {
+				return nil
+			}
+			return err
+		}
+		if dead {
+			if status != 0 {
+				return ErrNonZeroExitCode
+			}
+			return nil
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+}
+
+var errPaneNotFound = errors.New("tmux pane not found")
+
+func (p *Process) paneStatus() (bool, int, error) {
+	cmd := exec.Command("tmux", "display-message", "-p", "-t", p.paneID, "#{pane_dead}")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return true, 0, errPaneNotFound
+		}
+		return false, 0, xerrors.Errorf("tmux display-message failed: %w: %s", err, output)
+	}
+	dead := strings.TrimSpace(string(output)) == "1"
+	if !dead {
+		return false, 0, nil
+	}
+	cmd = exec.Command("tmux", "display-message", "-p", "-t", p.paneID, "#{pane_dead_status}")
+	output, err = cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return true, 0, errPaneNotFound
+		}
+		return true, 0, xerrors.Errorf("tmux display-message failed: %w: %s", err, output)
+	}
+	statusStr := strings.TrimSpace(string(output))
+	if statusStr == "" {
+		return true, 0, nil
+	}
+	status, err := strconv.Atoi(statusStr)
+	if err != nil {
+		return true, 0, xerrors.Errorf("failed to parse pane dead status: %w", err)
+	}
+	return true, status, nil
+}
+
+func (p *Process) killWindow() error {
+	if p.windowID == "" {
+		return nil
+	}
+	cmd := exec.Command("tmux", "kill-window", "-t", p.windowID)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return errPaneNotFound
+		}
+		return xerrors.Errorf("tmux kill-window failed: %w: %s", err, output)
+	}
+	return nil
+}
+
+func (p *Process) sendKeys(keys string) error {
+	cmd := exec.Command("tmux", "send-keys", "-t", p.paneID, keys)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return errPaneNotFound
+		}
+		return xerrors.Errorf("tmux send-keys failed: %w: %s", err, output)
+	}
+	return nil
+}
+
+func isTmuxTargetMissing(err error, output []byte) bool {
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 {
+		out := strings.ToLower(string(output))
+		if strings.Contains(out, "can't find") || strings.Contains(out, "no such") || strings.Contains(out, "not found") {
+			return true
+		}
+	}
+	return false
+}
+
+func tmuxSessionExists(ctx context.Context, sessionName string) (bool, error) {
+	cmd := exec.CommandContext(ctx, "tmux", "has-session", "-t", sessionName)
+	if err := cmd.Run(); err != nil {
+		var exitErr *exec.ExitError
+		if errors.As(err, &exitErr) && exitErr.ExitCode() == 1 {
+			return false, nil
+		}
+		return false, xerrors.Errorf("failed to check tmux session: %w", err)
+	}
+	return true, nil
+}
+
+func parsePaneWindowIDs(output []byte) (string, string, error) {
+	parts := strings.Split(strings.TrimSpace(string(output)), ",")
+	if len(parts) != 2 {
+		return "", "", xerrors.Errorf("unexpected tmux output: %q", string(output))
+	}
+	return parts[0], parts[1], nil
+}
+
+func sessionSize(sessionName string) (uint16, uint16, error) {
+	cmd := exec.Command("tmux", "display-message", "-p", "-t", sessionName, "#{session_width},#{session_height}")
+	output, err := cmd.CombinedOutput()
 	if err != nil {
-		return xerrors.Errorf("process exited with error: %w", err)
+		if isTmuxTargetMissing(err, output) {
+			return 0, 0, errPaneNotFound
+		}
+		return 0, 0, xerrors.Errorf("tmux display-message failed: %w: %s", err, output)
 	}
-	if state.ExitCode() != 0 {
-		return ErrNonZeroExitCode
+	parts := strings.Split(strings.TrimSpace(string(output)), ",")
+	if len(parts) != 2 {
+		return 0, 0, xerrors.Errorf("unexpected tmux output: %q", string(output))
+	}
+	width, err := strconv.Atoi(parts[0])
+	if err != nil {
+		return 0, 0, xerrors.Errorf("failed to parse session width %q: %w", parts[0], err)
+	}
+	height, err := strconv.Atoi(parts[1])
+	if err != nil {
+		return 0, 0, xerrors.Errorf("failed to parse session height %q: %w", parts[1], err)
+	}
+	return uint16(width), uint16(height), nil
+}
+
+func clientSize(sessionName string) (uint16, uint16, error) {
+	cmd := exec.Command("tmux", "list-clients", "-t", sessionName, "-F", "#{client_width},#{client_height}")
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return 0, 0, errPaneNotFound
+		}
+		// When no clients are attached tmux exits with status 1 and the message "no clients".
+		// Treat this as "no size available" rather than an error.
+		out := strings.TrimSpace(string(output))
+		if strings.Contains(out, "no clients") {
+			return 0, 0, nil
+		}
+		return 0, 0, xerrors.Errorf("tmux list-clients failed: %w: %s", err, output)
+	}
+	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+		parts := strings.Split(line, ",")
+		if len(parts) != 2 {
+			continue
+		}
+		width, err := strconv.Atoi(strings.TrimSpace(parts[0]))
+		if err != nil {
+			return 0, 0, xerrors.Errorf("failed to parse client width %q: %w", parts[0], err)
+		}
+		height, err := strconv.Atoi(strings.TrimSpace(parts[1]))
+		if err != nil {
+			return 0, 0, xerrors.Errorf("failed to parse client height %q: %w", parts[1], err)
+		}
+		return uint16(width), uint16(height), nil
+	}
+	return 0, 0, nil
+}
+
+func configureSessionForClients(sessionName string) error {
+	var errs []error
+	if err := setTmuxOption(sessionName, "window-size", "latest"); err != nil {
+		errs = append(errs, err)
+	}
+	if err := setTmuxOption(sessionName, "aggressive-resize", "on"); err != nil {
+		errs = append(errs, err)
+	}
+	if len(errs) > 0 {
+		return errors.Join(errs...)
+	}
+	return nil
+}
+
+func setTmuxOption(sessionName, option, value string) error {
+	cmd := exec.Command("tmux", "set-option", "-t", sessionName, option, value)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return errPaneNotFound
+		}
+		return xerrors.Errorf("tmux set-option failed: %w: %s", err, output)
+	}
+	return nil
+}
+
+func resizeWindow(windowID string, width, height uint16) error {
+	if windowID == "" {
+		return nil
+	}
+	args := []string{"resize-window", "-t", windowID}
+	if width > 0 {
+		args = append(args, "-x", strconv.Itoa(int(width)))
+	}
+	if height > 0 {
+		args = append(args, "-y", strconv.Itoa(int(height)))
+	}
+	if len(args) <= 3 {
+		return nil
+	}
+	cmd := exec.Command("tmux", args...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		if isTmuxTargetMissing(err, output) {
+			return errPaneNotFound
+		}
+		return xerrors.Errorf("tmux resize-window failed: %w: %s", err, output)
 	}
 	return nil
 }