diff --git a/docs/design/statusline-text-selection.md b/docs/design/statusline-text-selection.md
new file mode 100644
index 00000000000..4a0b1e9e05c
--- /dev/null
+++ b/docs/design/statusline-text-selection.md
@@ -0,0 +1,31 @@
+# Statusline text selection
+
+## Problem
+
+Virtualized History enables terminal-wide mouse tracking, so the terminal cannot
+provide native text selection. Qwen Code's application-level selection currently
+accepts presses only inside the history viewport, leaving the footer/statusline
+unselectable.
+
+## Design
+
+Keep one selection controller and give it an ordered list of selectable frame
+rectangles. The history viewport remains the primary rectangle. The default
+layout passes a ref for the rendered footer through `Composer`, and
+`MainContent` supplies its measured rectangle as the second target.
+
+The controller records which rectangle owns a selection when the press starts.
+Drag coordinates remain clamped to that rectangle, and frame/layout changes are
+compared only within it. Input, dialogs, scrollbars, and other controls remain
+outside the selectable targets, so their existing mouse behavior is unchanged.
+
+This applies only to the existing Virtualized History path. Normal-buffer mode
+continues to use terminal-native selection.
+
+## Verification
+
+- Dragging within history still highlights and copies history text.
+- Dragging within a multi-line footer highlights and copies footer text.
+- Presses in the gap between the history and footer do not start a selection.
+- Footer selection is cleared when its content or layout changes.
+- A live Virtualized History session can copy visible statusline text.
diff --git a/docs/design/vp-mouse-selection/design.md b/docs/design/vp-mouse-selection/design.md
index b02ceefa873..4f7beafe189 100644
--- a/docs/design/vp-mouse-selection/design.md
+++ b/docs/design/vp-mouse-selection/design.md
@@ -136,6 +136,8 @@ virtualRow  = scrollTop + viewportRow
 
 Before starting a selection, hit-test that `(col, layoutRow)` lies inside the history viewport content region and not in the scrollbar column, composer, or footer; presses elsewhere fall through to the existing scrollbar-drag / click-to-focus handlers. This arbitration is the contract between the new selection subscriber and the existing mouse subscribers.
 
+The issue #8131 follow-up keeps that history-region arbitration but registers the footer as a separate selectable rectangle. A drag remains clamped to the rectangle where it started, so the composer and other controls stay excluded.
+
 Anchors are stored in **virtual-row space** so a selection stays pinned to content, but in PR 1 any non-selection scroll/resize/streaming clears the selection (off-screen content is not cached), so virtual-row anchoring here is just consistent bookkeeping, not cross-screen persistence.
 
 ### Copy
diff --git a/packages/cli/src/ui/components/Composer.tsx b/packages/cli/src/ui/components/Composer.tsx
index 1c104a73f85..1e297a45dec 100644
--- a/packages/cli/src/ui/components/Composer.tsx
+++ b/packages/cli/src/ui/components/Composer.tsx
@@ -4,8 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Box, Text, useIsScreenReaderEnabled } from 'ink';
-import { useCallback, useRef, useState } from 'react';
+import { Box, Text, useIsScreenReaderEnabled, type DOMElement } from 'ink';
+import { useCallback, useRef, useState, type RefObject } from 'react';
 import { LoadingIndicator } from './LoadingIndicator.js';
 import { InputPrompt } from './InputPrompt.js';
 import { Footer } from './Footer.js';
@@ -20,7 +20,11 @@ import { StreamingState } from '../types.js';
 import { FeedbackDialog } from '../FeedbackDialog.js';
 import { t } from '../../i18n/index.js';
 
-export const Composer = () => {
+interface ComposerProps {
+  footerRef?: RefObject<DOMElement | null>;
+}
+
+export const Composer = ({ footerRef }: ComposerProps) => {
   const config = useConfig();
   const isScreenReaderEnabled = useIsScreenReaderEnabled();
   const uiState = useUIState();
@@ -152,7 +156,7 @@ export const Composer = () => {
         (showShortcuts ? (
           <KeyboardShortcuts />
         ) : (
-          !isScreenReaderEnabled && <Footer />
+          !isScreenReaderEnabled && <Footer containerRef={footerRef} />
         ))}
     </Box>
   );
diff --git a/packages/cli/src/ui/components/Footer.test.tsx b/packages/cli/src/ui/components/Footer.test.tsx
index 8ab0730aaf4..9c2d5113eb7 100644
--- a/packages/cli/src/ui/components/Footer.test.tsx
+++ b/packages/cli/src/ui/components/Footer.test.tsx
@@ -6,8 +6,10 @@
 
 import { render } from 'ink-testing-library';
 import { render as inkRender } from 'ink';
+import type { DOMElement } from 'ink';
 import stripAnsi from 'strip-ansi';
 import { EventEmitter } from 'node:events';
+import { createRef, type RefObject } from 'react';
 import { act } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Footer } from './Footer.js';
@@ -200,6 +202,7 @@ const renderAtLayoutWidth = (
   columns: number,
   uiState: UIState,
   backgroundEntries: readonly DialogEntry[] = [],
+  containerRef?: RefObject<DOMElement | null>,
 ) => {
   useTerminalSizeMock.mockReturnValue({ columns, rows: 24 });
   let lastFrame = '';
@@ -231,10 +234,10 @@ const renderAtLayoutWidth = (
       <BackgroundTaskViewStateContext.Provider
         value={createBackgroundTaskState(backgroundEntries)}
       >
-        <Footer />
+        <Footer containerRef={containerRef} />
       </BackgroundTaskViewStateContext.Provider>
     ) : (
-      <Footer />
+      <Footer containerRef={containerRef} />
     );
   const instance = inkRender(
     <SettingsContext.Provider value={mockSettings}>
@@ -280,6 +283,19 @@ describe('<Footer />', () => {
     });
   });
 
+  it('attaches the selectable-region ref to its outer box', () => {
+    const containerRef = createRef<DOMElement>();
+    const { unmount } = renderAtLayoutWidth(
+      80,
+      createMockUIState(),
+      [],
+      containerRef,
+    );
+
+    expect(containerRef.current).not.toBeNull();
+    unmount();
+  });
+
   it('passes the left-column width after a right pill reserves space', async () => {
     const originalSandbox = process.env['SANDBOX'];
     process.env['SANDBOX'] = 'qwen-code-docker';
diff --git a/packages/cli/src/ui/components/Footer.tsx b/packages/cli/src/ui/components/Footer.tsx
index f8875b77c82..8724a987ee3 100644
--- a/packages/cli/src/ui/components/Footer.tsx
+++ b/packages/cli/src/ui/components/Footer.tsx
@@ -5,7 +5,7 @@
  */
 
 import type React from 'react';
-import { useRef } from 'react';
+import { type RefObject, useRef } from 'react';
 import { type DOMElement, Box, Text, useBoxMetrics } from 'ink';
 import { theme } from '../semantic-colors.js';
 import { ContextUsageDisplay } from './ContextUsageDisplay.js';
@@ -49,7 +49,11 @@ const PasteProgressBar: React.FC<{ progress: PasteProgress }> = ({
   );
 };
 
-export const Footer: React.FC = () => {
+interface FooterProps {
+  containerRef?: RefObject<DOMElement | null>;
+}
+
+export const Footer: React.FC<FooterProps> = ({ containerRef }) => {
   const uiState = useUIState();
   const config = useConfig();
   const settings = useSettings();
@@ -209,6 +213,7 @@ export const Footer: React.FC = () => {
   // (bottom), right section has indicators. Status line and hints coexist.
   return (
     <Box
+      ref={containerRef}
       flexDirection={isNarrow ? 'column' : 'row'}
       justifyContent={isNarrow ? 'flex-start' : 'space-between'}
       width="100%"
diff --git a/packages/cli/src/ui/components/MainContent.tsx b/packages/cli/src/ui/components/MainContent.tsx
index ab2115921da..6b0199b2f0c 100644
--- a/packages/cli/src/ui/components/MainContent.tsx
+++ b/packages/cli/src/ui/components/MainContent.tsx
@@ -4,8 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { Box, Static } from 'ink';
-import { memo, useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Static, type DOMElement } from 'ink';
+import {
+  memo,
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type RefObject,
+} from 'react';
 import type { HistoryItem, HistoryItemWithoutId } from '../types.js';
 import {
   isHistoryItemVisibleAfterRestore,
@@ -32,6 +40,7 @@ import {
   type ScrollableListRef,
 } from './shared/ScrollableList.js';
 import { TextSelectionController } from '../selection/use-text-selection.js';
+import { measureElementPosition } from '../utils/measure-element-position.js';
 
 // Limit Gemini messages to a very high number of lines to mitigate performance
 // issues in the worst case if we somehow get an enormous response from Gemini.
@@ -114,7 +123,11 @@ const virtualKeyExtractor = (item: VpItem) =>
 const virtualIsStaticItem = (item: VpItem) =>
   item.type === 'vp-banner' || item.id > 0;
 
-export const MainContent = () => {
+interface MainContentProps {
+  footerRef?: RefObject<DOMElement | null>;
+}
+
+export const MainContent = ({ footerRef }: MainContentProps) => {
   const { version } = useAppContext();
   const uiState = useUIState();
   const { allExpanded: fullDetail } = useThoughtExpanded();
@@ -460,6 +473,11 @@ export const MainContent = () => {
         <TextSelectionController
           isActive={!uiState.dialogsVisible}
           getViewportRect={() => scrollRef.current?.getViewportRect() ?? null}
+          getAdditionalSelectableRects={() =>
+            footerRef?.current
+              ? [measureElementPosition(footerRef.current)]
+              : []
+          }
           getScrollState={() =>
             scrollRef.current?.getScrollState() ?? {
               scrollTop: 0,
diff --git a/packages/cli/src/ui/layouts/DefaultAppLayout.tsx b/packages/cli/src/ui/layouts/DefaultAppLayout.tsx
index 242c3238af4..d321a13165c 100644
--- a/packages/cli/src/ui/layouts/DefaultAppLayout.tsx
+++ b/packages/cli/src/ui/layouts/DefaultAppLayout.tsx
@@ -6,7 +6,7 @@
 
 import type React from 'react';
 import { useEffect, useRef } from 'react';
-import { Box } from 'ink';
+import { Box, type DOMElement } from 'ink';
 import { MainContent } from '../components/MainContent.js';
 import { UpdateNotification } from '../components/UpdateNotification.js';
 import { DialogManager } from '../components/DialogManager.js';
@@ -29,6 +29,7 @@ import { getDialogMaxHeight } from '../utils/layoutUtils.js';
 
 export const DefaultAppLayout: React.FC = () => {
   const uiState = useUIState();
+  const footerRef = useRef<DOMElement>(null);
   const { refreshStatic } = useUIActions();
   const { activeView, agents } = useAgentViewState();
   const { columns: terminalWidth } = useTerminalSize();
@@ -79,7 +80,7 @@ export const DefaultAppLayout: React.FC = () => {
       ) : (
         <>
           {/* Main view: conversation history + main composer / dialogs */}
-          <MainContent />
+          <MainContent footerRef={footerRef} />
           <Box flexDirection="column" ref={uiState.mainControlsRef}>
             {!uiState.dialogsVisible && uiState.updateInfo && (
               <UpdateNotification message={uiState.updateInfo.message} />
@@ -114,7 +115,7 @@ export const DefaultAppLayout: React.FC = () => {
                     />
                   </Box>
                 )}
-                <Composer />
+                <Composer footerRef={footerRef} />
               </>
             )}
             <ExitWarning />
diff --git a/packages/cli/src/ui/selection/selection-span.test.ts b/packages/cli/src/ui/selection/selection-span.test.ts
index 2603f23d3e7..c1ac201c8ab 100644
--- a/packages/cli/src/ui/selection/selection-span.test.ts
+++ b/packages/cli/src/ui/selection/selection-span.test.ts
@@ -67,11 +67,73 @@ describe('wordSpanAt', () => {
 describe('lineSpanAt', () => {
   it('spans from column 0 to the last non-space cell', () => {
     const frame = frameFromLines(['  hi there   ']);
-    expect(lineSpanAt(frame, 0)).toEqual({ sx: 0, sy: 0, ex: 9, ey: 0 });
+    expect(lineSpanAt(frame, 4, 0)).toEqual({ sx: 0, sy: 0, ex: 9, ey: 0 });
   });
 
   it('returns null for a blank line', () => {
     const frame = frameFromLines(['     ']);
-    expect(lineSpanAt(frame, 0)).toBeNull();
+    expect(lineSpanAt(frame, 2, 0)).toBeNull();
+  });
+
+  it('stops at a non-selectable layout gap', () => {
+    const frame = frameFromLines(['status    42%']);
+    for (let x = 6; x < 10; x++) {
+      (frame.cells[0][x] as FrameCell).selectable = false;
+    }
+
+    expect(lineSpanAt(frame, 2, 0)).toEqual({
+      sx: 0,
+      sy: 0,
+      ex: 5,
+      ey: 0,
+    });
+    expect(lineSpanAt(frame, 7, 0)).toEqual({
+      sx: 0,
+      sy: 0,
+      ex: 5,
+      ey: 0,
+    });
+    expect(lineSpanAt(frame, 9, 0)).toEqual({
+      sx: 10,
+      sy: 0,
+      ex: 12,
+      ey: 0,
+    });
+  });
+
+  it('snaps non-selectable history padding and gutters to visible content', () => {
+    const padded = frameFromLines(['history   ']);
+    for (let x = 7; x < padded.cells[0].length; x++) {
+      (padded.cells[0][x] as FrameCell).selectable = false;
+    }
+    expect(lineSpanAt(padded, 9, 0)).toEqual({
+      sx: 0,
+      sy: 0,
+      ex: 6,
+      ey: 0,
+    });
+
+    const gutter = frameFromLines(['  1 code']);
+    for (let x = 0; x < 4; x++) {
+      (gutter.cells[0][x] as FrameCell).selectable = false;
+    }
+    expect(lineSpanAt(gutter, 1, 0)).toEqual({
+      sx: 4,
+      sy: 0,
+      ex: 7,
+      ey: 0,
+    });
+  });
+
+  it('snaps a non-selectable wide-character spacer to its glyph', () => {
+    const frame = frameFromLines(['中']);
+    (frame.cells[0][1] as FrameCell).selectable = false;
+
+    expect(lineSpanAt(frame, 1, 0)).toEqual({
+      sx: 0,
+      sy: 0,
+      ex: 0,
+      ey: 0,
+    });
   });
 });
diff --git a/packages/cli/src/ui/selection/selection-span.ts b/packages/cli/src/ui/selection/selection-span.ts
index 2f797c11c71..aaf22ab8030 100644
--- a/packages/cli/src/ui/selection/selection-span.ts
+++ b/packages/cli/src/ui/selection/selection-span.ts
@@ -16,9 +16,13 @@ function isWordCell(value: string): boolean {
   return value !== '' && value !== ' ' && !/^\s$/u.test(value);
 }
 
-/** Trailing column of the last non-space cell on a row, or -1 if blank. */
-function lastContentColumn(row: ReadonlyFrame['cells'][number]): number {
-  for (let x = row.length - 1; x >= 0; x--) {
+/** Trailing column of the last non-space cell in a row range, or -1 if blank. */
+function lastContentColumn(
+  row: ReadonlyFrame['cells'][number],
+  start: number,
+  end: number,
+): number {
+  for (let x = end; x >= start; x--) {
     if (row[x].value !== '' && row[x].value !== ' ') {
       return x;
     }
@@ -61,20 +65,52 @@ export function wordSpanAt(
   return { sx, sy: y, ex, ey: y };
 }
 
-/** Whole visual line span (first column to last non-space), or null if blank. */
+function selectableLineSpan(
+  row: ReadonlyFrame['cells'][number],
+  x: number,
+  y: number,
+): NormalizedSelection {
+  let start = x;
+  while (start > 0 && row[start - 1].selectable) {
+    start--;
+  }
+  let runEnd = x;
+  while (runEnd < row.length - 1 && row[runEnd + 1].selectable) {
+    runEnd++;
+  }
+  const contentEnd = lastContentColumn(row, start, runEnd);
+  return { sx: start, sy: y, ex: contentEnd, ey: y };
+}
+
+function isSelectableContent(
+  cell: ReadonlyFrame['cells'][number][number],
+): boolean {
+  return cell.selectable && cell.value !== '' && cell.value !== ' ';
+}
+
+/** Nearest contiguous selectable line span around a click, or null if blank. */
 export function lineSpanAt(
   frame: ReadonlyFrame | null,
+  x: number,
   y: number,
 ): NormalizedSelection | null {
   const row = frame?.cells[y];
-  if (!row) {
+  if (!row || row.length === 0) {
     return null;
   }
-  const end = lastContentColumn(row);
-  if (end < 0) {
-    return null;
+
+  const origin = Math.max(0, Math.min(x, row.length - 1));
+  for (let distance = 0; distance < row.length; distance++) {
+    const left = origin - distance;
+    if (left >= 0 && isSelectableContent(row[left])) {
+      return selectableLineSpan(row, left, y);
+    }
+    const right = origin + distance;
+    if (distance > 0 && right < row.length && isSelectableContent(row[right])) {
+      return selectableLineSpan(row, right, y);
+    }
   }
-  return { sx: 0, sy: y, ex: end, ey: y };
+  return null;
 }
 
 /** Resolve the span at a point for a word/line selection mode. */
@@ -85,5 +121,5 @@ export function spanAtForMode(
 ): NormalizedSelection | null {
   return mode === 'word'
     ? wordSpanAt(frame, point.x, point.y)
-    : lineSpanAt(frame, point.y);
+    : lineSpanAt(frame, point.x, point.y);
 }
diff --git a/packages/cli/src/ui/selection/selection-text.test.ts b/packages/cli/src/ui/selection/selection-text.test.ts
index cb7b8fffed6..33090d11c06 100644
--- a/packages/cli/src/ui/selection/selection-text.test.ts
+++ b/packages/cli/src/ui/selection/selection-text.test.ts
@@ -126,6 +126,17 @@ describe('getSelectedText', () => {
     expect(getSelectedText(frame, { sx: 0, sy: 0, ex: 4, ey: 0 })).toBe('hi');
   });
 
+  it('separates selectable runs split by a layout gap', () => {
+    const frame = frameFromLines(['status    42%']);
+    for (let x = 6; x < 10; x++) {
+      (frame.cells[0][x] as FrameCell).selectable = false;
+    }
+
+    expect(getSelectedText(frame, { sx: 0, sy: 0, ex: 12, ey: 0 })).toBe(
+      'status 42%',
+    );
+  });
+
   it('replaces a soft visual break with its source joiner', () => {
     const frame = frameFromLines(['hello', 'world']);
     setBoundary(frame, 0, 'soft', ' ');
diff --git a/packages/cli/src/ui/selection/selection-text.ts b/packages/cli/src/ui/selection/selection-text.ts
index f5263fdf79a..ab2fb2b1127 100644
--- a/packages/cli/src/ui/selection/selection-text.ts
+++ b/packages/cli/src/ui/selection/selection-text.ts
@@ -34,11 +34,27 @@ export function getSelectedText(
     }
     const startX = y === sy ? sx : 0;
     const endX = y === ey ? ex : row.length - 1;
+    let rowText = '';
+    let skippedLayoutGap = false;
     for (let x = Math.max(0, startX); x <= endX && x < row.length; x++) {
-      if (row[x].selectable) {
-        text += row[x].value;
+      const cell = row[x];
+      if (cell.selectable) {
+        if (
+          skippedLayoutGap &&
+          rowText.length > 0 &&
+          cell.value !== '' &&
+          !/\s$/u.test(rowText) &&
+          !/^\s/u.test(cell.value)
+        ) {
+          rowText += ' ';
+        }
+        rowText += cell.value;
+        skippedLayoutGap = false;
+      } else if (rowText.length > 0) {
+        skippedLayoutGap = true;
       }
     }
+    text += rowText;
     if (y < ey) {
       text += boundaryJoiner(frame, selection, y);
     }
diff --git a/packages/cli/src/ui/selection/use-text-selection-render.test.tsx b/packages/cli/src/ui/selection/use-text-selection-render.test.tsx
new file mode 100644
index 00000000000..56d632f100d
--- /dev/null
+++ b/packages/cli/src/ui/selection/use-text-selection-render.test.tsx
@@ -0,0 +1,132 @@
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { act, useState } from 'react';
+import { Box, render, Text, type Instance } from 'ink';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { MouseEvent } from '../utils/mouse.js';
+import { TextSelectionController } from './use-text-selection.js';
+
+const mocks = vi.hoisted(() => ({
+  mouseHandler: undefined as ((event: MouseEvent) => void) | undefined,
+}));
+
+vi.mock('../hooks/useMouseEvents.js', () => ({
+  useMouseEvents: (handler: (event: MouseEvent) => void) => {
+    mocks.mouseHandler = handler;
+  },
+}));
+
+vi.mock('../utils/commandUtils.js', () => ({
+  copyToClipboard: vi.fn().mockResolvedValue(undefined),
+}));
+
+const SELECTION_BG = '\u001B[48;5;240m';
+let current: Instance | undefined;
+
+afterEach(async () => {
+  if (current) {
+    await act(async () => current!.unmount());
+    current = undefined;
+  }
+  mocks.mouseHandler = undefined;
+});
+
+const mouseEvent = (
+  name: MouseEvent['name'],
+  col: number,
+  row: number,
+): MouseEvent => ({
+  name,
+  col,
+  row,
+  shift: false,
+  meta: false,
+  ctrl: false,
+  button: 'left',
+});
+
+describe('TextSelectionController render invalidation', () => {
+  it('publishes a repaint without stale highlight after footer content changes', async () => {
+    const writes: string[] = [];
+    const stdout = Object.create(process.stdout, {
+      columns: { value: 80 },
+      rows: { value: 24 },
+      isTTY: { value: true },
+      write: {
+        value(
+          chunk: string | Uint8Array,
+          encodingOrCallback?: BufferEncoding | (() => void),
+          callback?: () => void,
+        ) {
+          writes.push(String(chunk));
+          const done =
+            typeof encodingOrCallback === 'function'
+              ? encodingOrCallback
+              : callback;
+          done?.();
+          return true;
+        },
+      },
+    }) as NodeJS.WriteStream;
+    let updateFooter!: () => void;
+
+    function Harness() {
+      const [footer, setFooter] = useState('status');
+      updateFooter = () => setFooter('footer');
+      return (
+        <Box flexDirection="column">
+          <Text>hello</Text>
+          <Text>{footer}</Text>
+          <TextSelectionController
+            isActive
+            getViewportRect={() => ({ x: 0, y: 0, width: 5, height: 1 })}
+            getAdditionalSelectableRects={() => [
+              { x: 0, y: 1, width: 6, height: 1 },
+            ]}
+            getScrollState={() => ({
+              scrollTop: 0,
+              scrollHeight: 1,
+              innerHeight: 1,
+            })}
+            hitTestScrollbar={() => false}
+          />
+        </Box>
+      );
+    }
+
+    let app!: Instance;
+    await act(async () => {
+      app = render(<Harness />, {
+        stdout,
+        interactive: true,
+        incrementalRendering: false,
+        maxFps: 30,
+        patchConsole: false,
+      });
+      current = app;
+    });
+    await app.waitUntilRenderFlush();
+
+    await act(async () => {
+      mocks.mouseHandler!(mouseEvent('left-press', 1, 2));
+      mocks.mouseHandler!(mouseEvent('left-release', 6, 2));
+    });
+    await app.waitUntilRenderFlush();
+    expect(writes.some((write) => write.includes(SELECTION_BG))).toBe(true);
+    writes.length = 0;
+
+    await act(async () => {
+      updateFooter();
+      await new Promise((resolve) => setTimeout(resolve, 120));
+    });
+    await app.waitUntilRenderFlush();
+
+    const footerWrites = writes.filter((write) => write.includes('footer'));
+    expect(footerWrites.length).toBeGreaterThan(0);
+    expect(footerWrites.at(-1)).not.toContain(SELECTION_BG);
+  });
+});
diff --git a/packages/cli/src/ui/selection/use-text-selection.test.tsx b/packages/cli/src/ui/selection/use-text-selection.test.tsx
index 86c5ff2fa0d..1de24912867 100644
--- a/packages/cli/src/ui/selection/use-text-selection.test.tsx
+++ b/packages/cli/src/ui/selection/use-text-selection.test.tsx
@@ -121,6 +121,8 @@ const makeEvent = (
   button: 'left',
 });
 
+const flushMicrotasks = (): Promise<void> => Promise.resolve();
+
 describe('TextSelectionController', () => {
   let frame: ReadonlyFrame;
   let setSelection: ReturnType<typeof vi.fn>;
@@ -131,6 +133,12 @@ describe('TextSelectionController', () => {
     innerHeight: number;
   };
   let viewportRect: { x: number; y: number; width: number; height: number };
+  let additionalSelectableRects: Array<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  }>;
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -139,6 +147,7 @@ describe('TextSelectionController', () => {
     listener = undefined;
     scrollState = { scrollTop: 0, scrollHeight: 1, innerHeight: 1 };
     viewportRect = { x: 0, y: 0, width: frame.width, height: 1 };
+    additionalSelectableRects = [];
     vi.mocked(copyToClipboard).mockResolvedValue(undefined);
     vi.mocked(getScreenBuffer).mockReturnValue({
       get frame() {
@@ -162,6 +171,7 @@ describe('TextSelectionController', () => {
       <TextSelectionController
         isActive
         getViewportRect={() => viewportRect}
+        getAdditionalSelectableRects={() => additionalSelectableRects}
         getScrollState={() => scrollState}
         hitTestScrollbar={() => false}
       />,
@@ -202,6 +212,56 @@ describe('TextSelectionController', () => {
     expect(copyToClipboard).toHaveBeenCalledWith('hello');
   });
 
+  it('turns a footer drag into a highlight and clipboard payload', () => {
+    frame = makeTwoLineFrame('hello', 'status');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    additionalSelectableRects = [{ x: 0, y: 1, width: 6, height: 1 }];
+    const handler = mount();
+
+    handler(makeEvent('left-press', 1, 2));
+    handler(makeEvent('move', 6, 2));
+    handler(makeEvent('left-release', 6, 2));
+
+    expect(setSelection).toHaveBeenLastCalledWith({
+      sx: 0,
+      sy: 1,
+      ex: 5,
+      ey: 1,
+    });
+    expect(copyToClipboard).toHaveBeenCalledWith('status');
+  });
+
+  it('clamps a footer drag to the footer when it enters history', () => {
+    frame = makeTwoLineFrame('hello', 'status');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    additionalSelectableRects = [{ x: 0, y: 1, width: 6, height: 1 }];
+    const handler = mount();
+
+    handler(makeEvent('left-press', 1, 2));
+    handler(makeEvent('move', 3, 1));
+    handler(makeEvent('left-release', 3, 1));
+
+    expect(setSelection).toHaveBeenLastCalledWith({
+      sx: 0,
+      sy: 1,
+      ex: 2,
+      ey: 1,
+    });
+    expect(copyToClipboard).toHaveBeenCalledWith('sta');
+  });
+
+  it('does not select frame content outside registered regions', () => {
+    frame = makeTwoLineFrame('hello', 'input');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    const handler = mount();
+
+    handler(makeEvent('left-press', 1, 2));
+    handler(makeEvent('left-release', 5, 2));
+
+    expect(setSelection).not.toHaveBeenCalled();
+    expect(copyToClipboard).not.toHaveBeenCalled();
+  });
+
   it('does not treat a click after a drag as a double-click', () => {
     vi.spyOn(Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(1100);
     const handler = mount();
@@ -363,6 +423,85 @@ describe('TextSelectionController', () => {
     expect(copyToClipboard).toHaveBeenLastCalledWith('x');
   });
 
+  it('triple-clicks history text from non-selectable trailing padding', () => {
+    const content = makeFrame('history').cells[0];
+    const padding = Array.from({ length: 3 }, () => ({
+      type: 'char' as const,
+      value: ' ',
+      fullWidth: false,
+      styles: [],
+      selectable: false,
+      flowId: null,
+    }));
+    frame = {
+      width: 10,
+      height: 1,
+      cells: [[...content, ...padding]],
+      boundaries: [Array.from({ length: 10 }, () => null)],
+    };
+    viewportRect = { x: 0, y: 0, width: 10, height: 1 };
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1000);
+    const handler = mount();
+
+    for (let click = 0; click < 3; click++) {
+      handler(makeEvent('left-press', 10));
+      handler(makeEvent('left-release', 10));
+    }
+    nowSpy.mockRestore();
+
+    expect(setSelection).toHaveBeenLastCalledWith({
+      sx: 0,
+      sy: 0,
+      ex: 6,
+      ey: 0,
+    });
+    expect(copyToClipboard).toHaveBeenLastCalledWith('history');
+  });
+
+  it('keeps a line drag aligned when it moves into trailing padding', () => {
+    const first = makeFrame('hello').cells[0];
+    const second = makeFrame('world').cells[0];
+    const padding = Array.from({ length: 3 }, () => ({
+      type: 'char' as const,
+      value: ' ',
+      fullWidth: false,
+      styles: [],
+      selectable: false,
+      flowId: null,
+    }));
+    frame = {
+      width: 8,
+      height: 2,
+      cells: [
+        [...first, ...padding],
+        [...second, ...padding],
+      ],
+      boundaries: [
+        Array.from({ length: 8 }, () => null),
+        Array.from({ length: 8 }, () => null),
+      ],
+    };
+    viewportRect = { x: 0, y: 0, width: 8, height: 2 };
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1000);
+    const handler = mount();
+    handler(makeEvent('left-press', 2, 1));
+    handler(makeEvent('left-release', 2, 1));
+    handler(makeEvent('left-press', 2, 1));
+    handler(makeEvent('left-release', 2, 1));
+    handler(makeEvent('left-press', 2, 1));
+    handler(makeEvent('move', 8, 2));
+    handler(makeEvent('left-release', 8, 2));
+    nowSpy.mockRestore();
+
+    expect(setSelection).toHaveBeenLastCalledWith({
+      sx: 0,
+      sy: 0,
+      ex: 4,
+      ey: 1,
+    });
+    expect(copyToClipboard).toHaveBeenLastCalledWith('hello\nworld');
+  });
+
   it('extends a word drag to the release cell when no move event is emitted', () => {
     frame = makeFrame('foo bar baz');
     viewportRect = { x: 0, y: 0, width: 11, height: 1 };
@@ -521,23 +660,25 @@ describe('TextSelectionController', () => {
     );
   });
 
-  it('clears a completed selection when scrollTop changes', () => {
+  it('clears a completed selection when scrollTop changes', async () => {
     const handler = mount();
     selectHello(handler);
     setSelection.mockClear();
 
     scrollState = { ...scrollState, scrollTop: 1 };
     listener!(frame);
+    await flushMicrotasks();
 
     expect(setSelection).toHaveBeenCalledWith(null);
   });
 
-  it('clears a completed selection when same-size frame content changes', () => {
+  it('clears a completed selection when same-size frame content changes', async () => {
     const handler = mount();
     selectHello(handler);
     setSelection.mockClear();
 
     listener!(makeFrame('hullo'));
+    await flushMicrotasks();
 
     expect(setSelection).toHaveBeenCalledWith(null);
   });
@@ -563,4 +704,98 @@ describe('TextSelectionController', () => {
 
     expect(setSelection).not.toHaveBeenCalled();
   });
+
+  it('clears a footer selection when footer content changes', async () => {
+    frame = makeTwoLineFrame('hello', 'status');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    additionalSelectableRects = [{ x: 0, y: 1, width: 6, height: 1 }];
+    const handler = mount();
+    handler(makeEvent('left-press', 1, 2));
+    handler(makeEvent('left-release', 6, 2));
+    setSelection.mockClear();
+
+    listener!(makeTwoLineFrame('hullo', 'status'));
+    expect(setSelection).not.toHaveBeenCalled();
+
+    listener!(makeTwoLineFrame('hello', 'footer'));
+    await flushMicrotasks();
+
+    expect(setSelection).toHaveBeenCalledWith(null);
+  });
+
+  it('clears a footer selection when its layout changes', async () => {
+    frame = makeTwoLineFrame('hello', 'status');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    additionalSelectableRects = [{ x: 0, y: 1, width: 6, height: 1 }];
+    const handler = mount();
+    handler(makeEvent('left-press', 1, 2));
+    handler(makeEvent('left-release', 6, 2));
+    setSelection.mockClear();
+
+    additionalSelectableRects = [{ x: 0, y: 2, width: 6, height: 1 }];
+    listener!(frame);
+    await flushMicrotasks();
+
+    expect(setSelection).toHaveBeenCalledWith(null);
+  });
+
+  it('keeps a footer selection while history scrolls', async () => {
+    frame = makeTwoLineFrame('hello', 'status');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    additionalSelectableRects = [{ x: 0, y: 1, width: 6, height: 1 }];
+    const handler = mount();
+    handler(makeEvent('left-press', 1, 2));
+    handler(makeEvent('left-release', 6, 2));
+    setSelection.mockClear();
+
+    scrollState = { ...scrollState, scrollTop: 1, scrollHeight: 2 };
+    listener!(frame);
+    await flushMicrotasks();
+
+    expect(setSelection).not.toHaveBeenCalled();
+  });
+
+  it('keeps a footer drag active while history scrolls', () => {
+    frame = makeTwoLineFrame('hello', 'status');
+    viewportRect = { x: 0, y: 0, width: 5, height: 1 };
+    additionalSelectableRects = [{ x: 0, y: 1, width: 6, height: 1 }];
+    const handler = mount();
+    handler(makeEvent('left-press', 1, 2));
+    setSelection.mockClear();
+
+    scrollState = { ...scrollState, scrollTop: 1 };
+    handler(makeEvent('move', 5, 2));
+
+    expect(setSelection).toHaveBeenLastCalledWith({
+      sx: 0,
+      sy: 1,
+      ex: 4,
+      ey: 1,
+    });
+  });
+
+  it('does not let stale invalidation clear a newer selection', () => {
+    const handler = mount();
+    selectHello(handler);
+    setSelection.mockClear();
+
+    const queued: Array<() => void> = [];
+    const queueSpy = vi
+      .spyOn(globalThis, 'queueMicrotask')
+      .mockImplementation((callback) => queued.push(callback));
+    frame = makeFrame('hullo');
+    listener!(frame);
+
+    handler(makeEvent('left-press', 1));
+    handler(makeEvent('left-release', 5));
+    queued[0]();
+    queueSpy.mockRestore();
+
+    expect(setSelection).toHaveBeenLastCalledWith({
+      sx: 0,
+      sy: 0,
+      ex: 4,
+      ey: 0,
+    });
+  });
 });
diff --git a/packages/cli/src/ui/selection/use-text-selection.tsx b/packages/cli/src/ui/selection/use-text-selection.tsx
index 586f60b9bb7..29b87f9112c 100644
--- a/packages/cli/src/ui/selection/use-text-selection.tsx
+++ b/packages/cli/src/ui/selection/use-text-selection.tsx
@@ -70,6 +70,8 @@ export interface TextSelectionControllerProps {
   isActive: boolean;
   /** Reads from the history viewport; called at event time (may be null early). */
   getViewportRect: () => ViewportRect | null;
+  /** Additional selectable regions outside the history viewport. */
+  getAdditionalSelectableRects?: () => readonly ViewportRect[];
   getScrollState: () => ScrollState;
   hitTestScrollbar: (location: { col: number; row: number }) => boolean;
 }
@@ -86,12 +88,13 @@ interface ClickRecord {
 }
 
 /**
- * Headless controller that turns mouse press/drag/release in the VP history
- * viewport into a text selection: it maps terminal coordinates to the
+ * Headless controller that turns mouse press/drag/release in selectable VP
+ * regions into a text selection: it maps terminal coordinates to the
  * composited frame, drives the {@link SelectionState}, highlights the range
  * through the frame controller, and copies on release. Double/triple click
- * select a word/line. B1 scope: visible-region only, cleared on any scroll,
- * resize, or streaming content change.
+ * select a word/line. B1 scope: visible-region only; history selections clear
+ * on scroll, while every selection clears when its owning content or layout
+ * changes.
  */
 export function TextSelectionController(
   props: TextSelectionControllerProps,
@@ -102,7 +105,12 @@ export function TextSelectionController(
   const baselineScrollTopRef = useRef<number>(0);
   const baselineScrollHeightRef = useRef<number>(0);
   const baselineFrameRef = useRef<ReadonlyFrame | null>(null);
-  const baselineViewportRectRef = useRef<ViewportRect | null>(null);
+  const baselineRectRef = useRef<ViewportRect | null>(null);
+  const activeRectIndexRef = useRef<number | null>(null);
+  const selectionGenerationRef = useRef(0);
+  // Generation of a queued frame-invalidation that has not run yet; a release
+  // in the same generation must not copy content the repaint already replaced.
+  const pendingInvalidationGenRef = useRef<number | null>(null);
   const lastClickRef = useRef<ClickRecord | null>(null);
   // Anchor span and mode of an active word/line drag; null for char drags.
   const anchorSpanRef = useRef<{
@@ -121,6 +129,8 @@ export function TextSelectionController(
   }, [stdout]);
 
   const clearSelection = useCallback(() => {
+    selectionGenerationRef.current += 1;
+    activeRectIndexRef.current = null;
     const selection = selectionRef.current;
     anchorSpanRef.current = null;
     if (selection.isEmpty) {
@@ -138,13 +148,31 @@ export function TextSelectionController(
     );
   }, [getBuffer]);
 
-  const recordBaseline = useCallback(() => {
-    const scrollState = propsRef.current.getScrollState();
-    baselineScrollTopRef.current = scrollState.scrollTop;
-    baselineScrollHeightRef.current = scrollState.scrollHeight;
-    baselineFrameRef.current = getBuffer()?.frame ?? null;
-    baselineViewportRectRef.current = propsRef.current.getViewportRect();
-  }, [getBuffer]);
+  const getSelectableRects = useCallback((): readonly ViewportRect[] => {
+    const viewportRect = propsRef.current.getViewportRect();
+    if (!viewportRect) {
+      return [];
+    }
+    const additionalRects =
+      propsRef.current.getAdditionalSelectableRects?.() ?? [];
+    return [viewportRect, ...additionalRects];
+  }, []);
+
+  const getActiveRect = useCallback((): ViewportRect | null => {
+    const index = activeRectIndexRef.current;
+    return index === null ? null : (getSelectableRects()[index] ?? null);
+  }, [getSelectableRects]);
+
+  const recordBaseline = useCallback(
+    (rect: ViewportRect) => {
+      const scrollState = propsRef.current.getScrollState();
+      baselineScrollTopRef.current = scrollState.scrollTop;
+      baselineScrollHeightRef.current = scrollState.scrollHeight;
+      baselineFrameRef.current = getBuffer()?.frame ?? null;
+      baselineRectRef.current = rect;
+    },
+    [getBuffer],
+  );
 
   const copySelection = useCallback(() => {
     const normalized = selectionRef.current.normalized();
@@ -159,15 +187,9 @@ export function TextSelectionController(
   }, [getBuffer]);
 
   const mapEvent = useCallback(
-    (
-      event: MouseEvent,
-    ): {
-      point: ReturnType<typeof terminalToGrid>;
-      rect: ViewportRect;
-    } | null => {
+    (event: MouseEvent): ReturnType<typeof terminalToGrid> | null => {
       const buffer = getBuffer();
-      const rect = propsRef.current.getViewportRect();
-      if (!buffer || !rect) {
+      if (!buffer) {
         return null;
       }
       const frameHeight = buffer.dimensions.height;
@@ -186,7 +208,7 @@ export function TextSelectionController(
         row[point.x - 1]?.fullWidth
           ? { ...point, x: point.x - 1 }
           : point;
-      return { point: snappedPoint, rect };
+      return snappedPoint;
     },
     [getBuffer, stdout],
   );
@@ -234,25 +256,34 @@ export function TextSelectionController(
     (event: MouseEvent) => {
       const selection = selectionRef.current;
 
-      // Any scroll drops the selection (B1: visible-region only).
+      // History scrolls invalidate history-owned selection coordinates. Footer
+      // selections live outside the scrollable viewport and remain valid.
       if (event.name.startsWith('scroll-')) {
-        clearSelection();
+        if (activeRectIndexRef.current === 0) {
+          clearSelection();
+        }
         return;
       }
 
       if (event.name === 'left-press') {
+        selectionGenerationRef.current += 1;
         if (
           propsRef.current.hitTestScrollbar({ col: event.col, row: event.row })
         ) {
           clearSelection();
           return;
         }
-        const mapped = mapEvent(event);
-        if (!mapped || !pointInViewport(mapped.point, mapped.rect)) {
+        const point = mapEvent(event);
+        const rects = getSelectableRects();
+        const rectIndex = point
+          ? rects.findIndex((rect) => pointInViewport(point, rect))
+          : -1;
+        if (!point || rectIndex < 0) {
           clearSelection();
           return;
         }
-        const { point } = mapped;
+        const rect = rects[rectIndex];
+        activeRectIndexRef.current = rectIndex;
 
         // Multi-click detection (double = word, triple = line).
         const now = Date.now();
@@ -280,7 +311,7 @@ export function TextSelectionController(
             anchorSpanRef.current = { span, mode };
             dragScrollTopRef.current =
               propsRef.current.getScrollState().scrollTop;
-            recordBaseline();
+            recordBaseline(rect);
             applyHighlight();
             copySelection();
             return;
@@ -290,7 +321,7 @@ export function TextSelectionController(
         anchorSpanRef.current = null;
         selection.start(point);
         dragScrollTopRef.current = propsRef.current.getScrollState().scrollTop;
-        recordBaseline();
+        recordBaseline(rect);
         applyHighlight();
         return;
       }
@@ -304,19 +335,22 @@ export function TextSelectionController(
         if (!anchorSpanRef.current) {
           lastClickRef.current = null;
         }
-        // A scroll under the drag invalidates coordinates in B1.
+        // A scroll under a history drag invalidates its viewport coordinates.
         if (
+          activeRectIndexRef.current === 0 &&
           propsRef.current.getScrollState().scrollTop !==
-          dragScrollTopRef.current
+            dragScrollTopRef.current
         ) {
           clearSelection();
           return;
         }
-        const mapped = mapEvent(event);
-        if (!mapped) {
+        const point = mapEvent(event);
+        const rect = getActiveRect();
+        if (!point || !rect) {
+          clearSelection();
           return;
         }
-        extendActiveDrag(clampToViewport(mapped.point, mapped.rect));
+        extendActiveDrag(clampToViewport(point, rect));
         applyHighlight();
         return;
       }
@@ -325,9 +359,18 @@ export function TextSelectionController(
         if (!selection.dragging) {
           return;
         }
-        const mapped = mapEvent(event);
-        if (mapped) {
-          extendActiveDrag(clampToViewport(mapped.point, mapped.rect));
+        // A repaint invalidated this selection but the deferred clear has not
+        // run yet; drop it without extending or copying the stale content.
+        if (
+          pendingInvalidationGenRef.current === selectionGenerationRef.current
+        ) {
+          clearSelection();
+          return;
+        }
+        const point = mapEvent(event);
+        const rect = getActiveRect();
+        if (point && rect) {
+          extendActiveDrag(clampToViewport(point, rect));
         }
         // Clear the span drag only after extending, so the release cell still
         // applies to a word/line drag when no move covered it.
@@ -349,6 +392,8 @@ export function TextSelectionController(
       recordBaseline,
       mapEvent,
       getBuffer,
+      getSelectableRects,
+      getActiveRect,
       extendActiveDrag,
     ],
   );
@@ -375,17 +420,26 @@ export function TextSelectionController(
         return;
       }
       const { scrollTop, scrollHeight } = propsRef.current.getScrollState();
-      const viewportRect = propsRef.current.getViewportRect();
+      const activeRect = getActiveRect();
+      const isViewportSelection = activeRectIndexRef.current === 0;
       if (
-        scrollTop !== baselineScrollTopRef.current ||
-        scrollHeight !== baselineScrollHeightRef.current ||
-        !sameViewportRect(baselineViewportRectRef.current, viewportRect) ||
-        !sameViewportContent(baselineFrameRef.current, frame, viewportRect)
+        (isViewportSelection &&
+          (scrollTop !== baselineScrollTopRef.current ||
+            scrollHeight !== baselineScrollHeightRef.current)) ||
+        !sameViewportRect(baselineRectRef.current, activeRect) ||
+        !sameViewportContent(baselineFrameRef.current, frame, activeRect)
       ) {
-        clearSelection();
+        const invalidatedGeneration = selectionGenerationRef.current;
+        pendingInvalidationGenRef.current = invalidatedGeneration;
+        queueMicrotask(() => {
+          pendingInvalidationGenRef.current = null;
+          if (selectionGenerationRef.current === invalidatedGeneration) {
+            clearSelection();
+          }
+        });
       }
     });
-  }, [getBuffer, clearSelection]);
+  }, [getBuffer, getActiveRect, clearSelection]);
 
   useEffect(() => {
     if (!props.isActive) {