diff --git a/.changeset/trace-select-copy.md b/.changeset/trace-select-copy.md
new file mode 100644
index 000000000..6deef5910
--- /dev/null
+++ b/.changeset/trace-select-copy.md
@@ -0,0 +1,5 @@
+---
+"eve": patch
+---
+
+The `/traces` viewer supports drag-to-select: dragging with the mouse highlights text and releasing copies it to the clipboard (OSC 52 with tmux passthrough, plus the platform clipboard command) with a confirmation toast. Clicks now act on release so drags never toggle cards, and Esc cancels an in-flight selection.
diff --git a/docs/guides/dev-tui.md b/docs/guides/dev-tui.md
index 5e6fd100b..d67684543 100644
--- a/docs/guides/dev-tui.md
+++ b/docs/guides/dev-tui.md
@@ -123,7 +123,7 @@ The viewer opens on your current session's trace (or the most recent one). It re
 | `Esc`     | Close the panel (or unfocus it), otherwise close the viewer.             |
 | `q`       | Close the viewer.                                                        |
 
-`←`/`→` or a mouse click expands a card to its full contents (the system prompt, long payloads) and collapses it back; cards that already fit have nothing to expand. The attributes panel opens on the right and stays metadata-only — status, timing, ids, and the span's non-payload OTLP attributes — since the cards already carry the payloads. Model spans capture the system prompt, the prompt messages (rendered as a chat transcript), and the response (text, tool calls, finish reason); tool-call spans capture the call arguments and result, pretty-printed — each capped at 32 KB, with provider transport metadata stripped. When a conversation's messages exceed the cap, the oldest messages are dropped and the transcript notes how many were omitted. Set `EVE_TRACES_CONTENT=off` to stop capturing payload content. With no spans yet, the viewer shows an empty state and keeps watching; if tracing is disabled (`EVE_TRACES=off`) it says so instead.
+`←`/`→` or a mouse click expands a card to its full contents (the system prompt, long payloads) and collapses it back; cards that already fit have nothing to expand. The scroll wheel scrolls the conversation. Dragging with the mouse selects text — the selection highlights as you drag, and releasing copies it to your clipboard (a `✓ Copied to clipboard` toast confirms in the header); `Esc` cancels an in-flight selection. The attributes panel opens on the right and stays metadata-only — status, timing, ids, and the span's non-payload OTLP attributes — since the cards already carry the payloads. Model spans capture the system prompt, the prompt messages (rendered as a chat transcript), and the response (text, tool calls, finish reason); tool-call spans capture the call arguments and result, pretty-printed — each capped at 32 KB, with provider transport metadata stripped. When a conversation's messages exceed the cap, the oldest messages are dropped and the transcript notes how many were omitted. Set `EVE_TRACES_CONTENT=off` to stop capturing payload content. With no spans yet, the viewer shows an empty state and keeps watching; if tracing is disabled (`EVE_TRACES=off`) it says so instead.
 
 ## Display flags
 
diff --git a/packages/eve/src/cli/dev/tui/clipboard.test.ts b/packages/eve/src/cli/dev/tui/clipboard.test.ts
new file mode 100644
index 000000000..6254ee4ec
--- /dev/null
+++ b/packages/eve/src/cli/dev/tui/clipboard.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import { clipboardCommand, clipboardSequence } from "#cli/dev/tui/clipboard.js";
+
+describe("clipboardSequence", () => {
+  it("encodes the text as base64 in an OSC 52 write", () => {
+    expect(clipboardSequence("hello", {})).toBe(
+      `\x1b]52;c;${Buffer.from("hello").toString("base64")}\x07`,
+    );
+  });
+
+  it("wraps the sequence for tmux and screen passthrough", () => {
+    const inner = clipboardSequence("hi", {});
+    expect(clipboardSequence("hi", { TMUX: "/tmp/tmux-1000/default" })).toBe(
+      `\x1bPtmux;\x1b${inner}\x1b\\`,
+    );
+    expect(clipboardSequence("hi", { STY: "1234.pts-0" })).toBe(`\x1bPtmux;\x1b${inner}\x1b\\`);
+  });
+});
+
+describe("clipboardCommand", () => {
+  it("picks the platform clipboard tool", () => {
+    expect(clipboardCommand("darwin", {})).toEqual(["pbcopy"]);
+    expect(clipboardCommand("linux", {})).toEqual(["xclip", "-selection", "clipboard"]);
+    expect(clipboardCommand("linux", { WAYLAND_DISPLAY: "wayland-0" })).toEqual(["wl-copy"]);
+    expect(clipboardCommand("win32", {})).toEqual(["clip"]);
+    expect(clipboardCommand("freebsd", {})).toBeUndefined();
+  });
+});
diff --git a/packages/eve/src/cli/dev/tui/clipboard.ts b/packages/eve/src/cli/dev/tui/clipboard.ts
new file mode 100644
index 000000000..8644985f1
--- /dev/null
+++ b/packages/eve/src/cli/dev/tui/clipboard.ts
@@ -0,0 +1,54 @@
+/**
+ * Best-effort clipboard writes for the dev TUI: an OSC 52 escape sequence
+ * (which reaches the user's terminal even over SSH, with tmux/screen
+ * passthrough) plus the platform's native clipboard command as a fallback
+ * for terminals that reject OSC 52. Both paths fail silently — copying is
+ * a convenience, never a hard dependency.
+ */
+
+import { spawn } from "node:child_process";
+
+/** The OSC 52 sequence for `text`, wrapped for tmux/screen when present. */
+export function clipboardSequence(
+  text: string,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): string {
+  const sequence = `\x1b]52;c;${Buffer.from(text).toString("base64")}\x07`;
+  const multiplexed = env.TMUX !== undefined || env.STY !== undefined;
+  return multiplexed ? `\x1bPtmux;\x1b${sequence}\x1b\\` : sequence;
+}
+
+/** The native clipboard command for a platform, or `undefined` when unknown. */
+export function clipboardCommand(
+  platform: NodeJS.Platform,
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): readonly string[] | undefined {
+  if (platform === "darwin") return ["pbcopy"];
+  if (platform === "linux") {
+    return env.WAYLAND_DISPLAY !== undefined ? ["wl-copy"] : ["xclip", "-selection", "clipboard"];
+  }
+  if (platform === "win32") return ["clip"];
+  return undefined;
+}
+
+/**
+ * Copies `text` to the clipboard: emits OSC 52 through `writeTerminal`
+ * (the same raw write the alt screen paints with) and pipes the text into
+ * the platform clipboard command in the background.
+ */
+export function copyTextToClipboard(text: string, writeTerminal: (chunk: string) => void): void {
+  writeTerminal(clipboardSequence(text));
+  const command = clipboardCommand(process.platform);
+  if (command === undefined) return;
+  try {
+    const child = spawn(command[0]!, command.slice(1), {
+      stdio: ["pipe", "ignore", "ignore"],
+      detached: false,
+    });
+    child.on("error", () => {});
+    child.stdin?.on("error", () => {});
+    child.stdin?.end(text);
+  } catch {
+    // Native clipboard is a fallback; OSC 52 already went out.
+  }
+}
diff --git a/packages/eve/src/cli/dev/tui/terminal-renderer.ts b/packages/eve/src/cli/dev/tui/terminal-renderer.ts
index 905a4ad0a..32624c49b 100644
--- a/packages/eve/src/cli/dev/tui/terminal-renderer.ts
+++ b/packages/eve/src/cli/dev/tui/terminal-renderer.ts
@@ -113,6 +113,7 @@ import {
 } from "./line-editor.js";
 import { LiveRegion } from "#cli/ui/live-region.js";
 import { AltScreen } from "#cli/ui/alt-screen.js";
+import { copyTextToClipboard } from "./clipboard.js";
 import type { TraceViewerOpenOptions, TraceViewerRenderer } from "./traces/trace-viewer-session.js";
 import { TraceViewerSession } from "./traces/trace-viewer-session.js";
 import { buildStatusLine } from "./status-line.js";
@@ -2669,6 +2670,7 @@ export class TerminalRenderer implements AgentTUIRenderer {
       dimensions: () => ({ width: this.#width(), height: this.#height() }),
       paint: (rows) => this.#altScreen.paint(rows, this.#height()),
       tracingDisabled: process.env.EVE_TRACES === "off",
+      copyText: (text) => copyTextToClipboard(text, (chunk) => this.#altScreen.writeRaw(chunk)),
     });
     this.#traceView = session;
     this.#altScreen.enter();
diff --git a/packages/eve/src/cli/dev/tui/traces/trace-view.test.ts b/packages/eve/src/cli/dev/tui/traces/trace-view.test.ts
index 6bda56b15..2ca62ccb9 100644
--- a/packages/eve/src/cli/dev/tui/traces/trace-view.test.ts
+++ b/packages/eve/src/cli/dev/tui/traces/trace-view.test.ts
@@ -4,7 +4,12 @@ import { stripAnsi, visibleLength } from "#cli/ui/terminal-text.js";
 import type { LocalTrace, LocalTraceSpan } from "#harness/local-trace-reader.js";
 
 import { createTheme } from "../theme.js";
-import { renderSpanDetail, renderTraceViewer } from "./trace-view.js";
+import {
+  conversationSelectionText,
+  panelSelectionText,
+  renderSpanDetail,
+  renderTraceViewer,
+} from "./trace-view.js";
 import type { TraceViewerState } from "./trace-viewer-state.js";
 import { applyLoadedTrace, applyTraceList, createTraceViewerState } from "./trace-viewer-state.js";
 
@@ -108,6 +113,87 @@ describe("renderTraceViewer", () => {
     expect(selectedRows.length).toBeGreaterThan(0);
   });
 
+  it("shows the copy toast in the header's top-right corner", () => {
+    const state = viewerState(conversationSpans());
+    const frame = renderTraceViewer(state, {
+      width: 100,
+      height: 30,
+      theme: THEME,
+      toast: "Copied to clipboard",
+    });
+    expect(stripAnsi(frame.rows[0]!)).toContain("✓ Copied to clipboard");
+  });
+
+  it("paints an active drag selection in reverse video", () => {
+    const state = viewerState(conversationSpans(), {
+      textSelection: {
+        anchor: { line: 1, column: 2 },
+        head: { line: 2, column: 10 },
+        dragging: true,
+        region: "conversation" as const,
+      },
+    });
+    const frame = render(state);
+    const highlighted = frame.rows.filter((row) => row.includes("\x1b[7m"));
+    expect(highlighted.length).toBe(2);
+  });
+
+  it("extracts the dragged text from the rendered conversation", () => {
+    const state = viewerState(conversationSpans());
+    // The system card's title row is line 1 ("  ▸ system" once rendered).
+    const selection = {
+      anchor: { line: 1, column: 0 },
+      head: { line: 1, column: 40 },
+      dragging: true,
+      region: "conversation" as const,
+    };
+    const text = conversationSelectionText(state, 100, THEME, selection);
+    expect(text).toContain("system");
+    expect(text).not.toContain("\x1b");
+    // A multi-line drag keeps line structure.
+    const multi = conversationSelectionText(state, 100, THEME, {
+      anchor: { line: 1, column: 0 },
+      head: { line: 5, column: 99 },
+      dragging: true,
+      region: "conversation" as const,
+    });
+    expect(multi.split("\n").length).toBe(5);
+  });
+
+  it("paints a drawer drag selection on the panel, not the cards", () => {
+    const state = viewerState(conversationSpans(), {
+      panelOpen: true,
+      textSelection: {
+        anchor: { line: 1, column: 0 },
+        head: { line: 3, column: 10 },
+        dragging: true,
+        region: "panel" as const,
+      },
+    });
+    const frame = render(state);
+    const highlighted = frame.rows.filter((row) => row.includes("\x1b[7m"));
+    expect(highlighted.length).toBe(3);
+    // The highlight sits in the drawer area (right of the conversation).
+    for (const row of highlighted) {
+      const before = row.slice(0, row.indexOf("\x1b[7m"));
+      expect(visibleLength(before)).toBeGreaterThanOrEqual(frame.contentWidth);
+    }
+  });
+
+  it("extracts the dragged text from the details drawer", () => {
+    const state = viewerState(conversationSpans(), { panelOpen: true });
+    // Detail line 1 is the selected span's name (line 0 is top padding).
+    const text = panelSelectionText(state, 100, THEME, {
+      anchor: { line: 1, column: 0 },
+      head: { line: 2, column: 40 },
+      dragging: true,
+      region: "panel" as const,
+    });
+    expect(text).toContain("ai.streamText.doStream");
+    expect(text).not.toContain("\x1b");
+    expect(text.split("\n").length).toBe(2);
+  });
+
   it("marks error cards and shows the error status in the detail panel", () => {
     const turn = span("a".repeat(16), "agent.turn", 0, 0);
     const step = span("b".repeat(16), "agent.step", 10, 300, turn.spanId, {});
diff --git a/packages/eve/src/cli/dev/tui/traces/trace-view.ts b/packages/eve/src/cli/dev/tui/traces/trace-view.ts
index eb2c98038..25b38d44a 100644
--- a/packages/eve/src/cli/dev/tui/traces/trace-view.ts
+++ b/packages/eve/src/cli/dev/tui/traces/trace-view.ts
@@ -9,6 +9,8 @@
 import { formatElapsed } from "#cli/format-elapsed.js";
 import {
   clipVisible,
+  sliceVisible,
+  stripAnsi,
   stripTerminalControls,
   visibleLength,
   wrapVisibleLine,
@@ -19,8 +21,8 @@ import { describeLocalTraceSpan } from "#harness/local-trace-reader.js";
 import type { Theme } from "../theme.js";
 import { formatAttributeContent } from "./trace-content.js";
 import { renderConversationItem } from "./trace-conversation.js";
-import type { TraceViewerState } from "./trace-viewer-state.js";
-import { selectedTraceViewerSpan } from "./trace-viewer-state.js";
+import type { TextSelectionRange, TraceViewerState } from "./trace-viewer-state.js";
+import { orderedTextSelection, selectedTraceViewerSpan } from "./trace-viewer-state.js";
 
 const HEADER_ROWS = 1;
 const FOOTER_ROWS = 2;
@@ -49,6 +51,8 @@ export interface RenderTraceViewerOptions {
   readonly activeWindowEndNs?: bigint;
   /** Tracing is disabled via `EVE_TRACES=off` (empty-state copy). */
   readonly tracingDisabled?: boolean;
+  /** Transient confirmation shown in the header's top-right corner. */
+  readonly toast?: string;
 }
 
 export function renderTraceViewer(
@@ -60,19 +64,7 @@ export function renderTraceViewer(
   const panelWidth = state.panelOpen ? panelWidthFor(width) : 0;
   const timelineWidth = Math.max(20, width - (panelWidth === 0 ? 0 : panelWidth + 1));
 
-  const selected = selectedTraceViewerSpan(state);
-  // A panel that doesn't fit (very narrow terminal) isn't modeled as open —
-  // otherwise key handling would scroll content nobody can see. The drawer
-  // gets one row of top padding and one column of side padding.
-  const detailLines =
-    state.panelOpen && panelWidth > 0 && selected !== undefined
-      ? [
-          "",
-          ...renderSpanDetail(selected, Math.max(16, panelWidth - 3), theme, {
-            excludeKeys: CONVERSATION_CONTENT_KEYS,
-          }).map((line) => ` ${line}`),
-        ]
-      : [];
+  const detailLines = panelDetailLines(state, panelWidth, theme);
   const panelViewportRows = bodyRows;
 
   const rows: string[] = [];
@@ -91,7 +83,15 @@ export function renderTraceViewer(
       }
       // No divider: the base canvas separates the cards and drawer by itself.
       const separator = " ";
-      const panelLine = detailLines[state.panelScroll + index] ?? "";
+      let panelLine = detailLines[state.panelScroll + index] ?? "";
+      if (state.textSelection !== undefined && state.textSelection.region === "panel") {
+        panelLine = highlightSelection(
+          panelLine,
+          state.panelScroll + index,
+          state.textSelection,
+          panelWidth,
+        );
+      }
       rows.push(joinPanels(left, timelineWidth, separator, panelLine, width));
     }
   }
@@ -219,7 +219,11 @@ function renderHeader(state: TraceViewerState, options: RenderTraceViewerOptions
   const position =
     state.traces.length === 0 ? "" : colors.dim(`[${state.traceIndex + 1}/${state.traces.length}]`);
   const live = options.activeWindowEndNs !== undefined ? colors.green("● live") : "";
-  const right = [live, position].filter((part) => part.length > 0).join(" ");
+  const toast =
+    options.toast === undefined
+      ? ""
+      : colors.green(`${theme.unicode ? "✓ " : ""}${stripTerminalControls(options.toast)}`);
+  const right = [toast, live, position].filter((part) => part.length > 0).join(" ");
   // The badge keeps its room: the title (full session id and all) clips first.
   const header = joinRight(
     clipVisible(title, Math.max(0, width - visibleLength(right) - 1)),
@@ -246,6 +250,17 @@ function renderConversation(
   }
   // Render all cards, then apply the line-level scroll offset so expanded
   // cards taller than the viewport can be scrolled through to the end.
+  const allLines = conversationLines(state, width, theme);
+  const visible = allLines.slice(state.scrollRow, state.scrollRow + bodyRows);
+  if (state.textSelection === undefined || state.textSelection.region !== "conversation") {
+    return visible;
+  }
+  return visible.map((line, index) =>
+    highlightSelection(line, state.scrollRow + index, state.textSelection!, width),
+  );
+}
+
+function conversationLines(state: TraceViewerState, width: number, theme: Theme): string[] {
   const allLines: string[] = [];
   for (let index = 0; index < state.conversationItems.length; index += 1) {
     allLines.push(
@@ -259,7 +274,98 @@ function renderConversation(
       "",
     );
   }
-  return allLines.slice(state.scrollRow, state.scrollRow + bodyRows);
+  return allLines;
+}
+
+/**
+ * The drawer's display lines for the selected span: one row of top padding
+ * and one column of side padding around the span detail. A panel that
+ * doesn't fit (very narrow terminal) isn't modeled as open — otherwise key
+ * handling would scroll content nobody can see.
+ */
+function panelDetailLines(state: TraceViewerState, panelWidth: number, theme: Theme): string[] {
+  const selected = selectedTraceViewerSpan(state);
+  if (!state.panelOpen || panelWidth <= 0 || selected === undefined) return [];
+  return [
+    "",
+    ...renderSpanDetail(selected, Math.max(16, panelWidth - 3), theme, {
+      excludeKeys: CONVERSATION_CONTENT_KEYS,
+    }).map((line) => ` ${line}`),
+  ];
+}
+
+/**
+ * Plain text covered by a drag selection over the conversation, extracted
+ * from the same rendered lines the user saw.
+ */
+export function conversationSelectionText(
+  state: TraceViewerState,
+  width: number,
+  theme: Theme,
+  selection: TextSelectionRange,
+): string {
+  return selectionText(conversationLines(state, width, theme), selection);
+}
+
+/**
+ * Plain text covered by a drag selection over the details drawer, extracted
+ * from the same detail lines the frame painted. `totalWidth` is the full
+ * terminal width — the drawer's width derives from it exactly as rendering
+ * does, so columns map to the same cells the user selected.
+ */
+export function panelSelectionText(
+  state: TraceViewerState,
+  totalWidth: number,
+  theme: Theme,
+  selection: TextSelectionRange,
+): string {
+  const panelWidth = state.panelOpen ? panelWidthFor(totalWidth) : 0;
+  return selectionText(panelDetailLines(state, panelWidth, theme), selection);
+}
+
+/**
+ * Slices the selected cells out of rendered lines: partial first/last lines
+ * honor the columns, middle lines contribute in full, and each line loses
+ * its trailing padding.
+ */
+function selectionText(lines: readonly string[], selection: TextSelectionRange): string {
+  const { start, end } = orderedTextSelection(selection);
+  const parts: string[] = [];
+  for (let line = Math.max(0, start.line); line <= end.line && line < lines.length; line += 1) {
+    const text = stripAnsi(lines[line]!);
+    const from = line === start.line ? start.column : 0;
+    const to = line === end.line ? end.column + 1 : Number.POSITIVE_INFINITY;
+    const head = to === Number.POSITIVE_INFINITY ? text : sliceVisible(text, to);
+    const prefixLength = sliceVisible(text, from).length;
+    parts.push(head.slice(prefixLength).trimEnd());
+  }
+  return parts.join("\n");
+}
+
+/** Paints the selected cells of one visible row in reverse video. */
+function highlightSelection(
+  row: string,
+  line: number,
+  selection: TextSelectionRange,
+  width: number,
+): string {
+  const { start, end } = orderedTextSelection(selection);
+  if (line < start.line || line > end.line) return row;
+  const from = line === start.line ? start.column : 0;
+  const to = line === end.line ? end.column + 1 : width;
+  // Selection can extend past a row's painted cells; pad so the highlight
+  // shows the full extent the copy will cover.
+  const rowWidth = visibleLength(row);
+  const padded = rowWidth < to ? row + " ".repeat(to - rowWidth) : row;
+  const prefix = sliceVisible(padded, from);
+  const withSelection = sliceVisible(padded, to);
+  const middle = withSelection.slice(prefix.length);
+  const suffix = padded.slice(withSelection.length);
+  if (middle.length === 0) return row;
+  // Re-assert reverse video after any embedded reset so a card's internal
+  // style changes cannot end the highlight early.
+  const inverted = middle.replaceAll("\x1b[0m", "\x1b[0m\x1b[7m");
+  return `${prefix}\x1b[7m${inverted}\x1b[27m${suffix}`;
 }
 
 function renderFooter(state: TraceViewerState, width: number, theme: Theme): string[] {
diff --git a/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.test.ts b/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.test.ts
index c711f0b80..83c4a03cd 100644
--- a/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.test.ts
+++ b/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.test.ts
@@ -75,6 +75,64 @@ async function openViewer(store: TraceStore, sessionId?: string) {
   return frames[frames.length - 1]!.join("\n");
 }
 
+describe("TraceViewerSession drag copy", () => {
+  it("copies the dragged text and shows a toast", async () => {
+    const turn = span("a".repeat(16), "session-mine");
+    const model: LocalTraceSpan = {
+      ...span("b".repeat(16), "session-mine"),
+      name: "ai.streamText.doStream",
+      parentSpanId: turn.spanId,
+      attributes: {
+        "ai.prompt.messages": JSON.stringify([{ role: "user", content: "copy me please" }]),
+        "ai.response.text": "reply",
+      },
+    };
+    const store = stubStore([
+      {
+        endTimeNs: 1_000_000n,
+        sessionId: "session-mine",
+        sessionIds: ["session-mine"],
+        spans: [turn, model],
+        startTimeNs: 1_000_000n,
+        traceId: "c".repeat(32),
+      },
+    ]);
+    const frames: string[][] = [];
+    const copied: string[] = [];
+    const session = new TraceViewerSession({
+      appRoot: "/nowhere",
+      copyText: (text) => copied.push(text),
+      dimensions: () => ({ width: 80, height: 24 }),
+      paint: (rows) => frames.push([...rows]),
+      store,
+      theme: THEME,
+    });
+    session.start();
+    await vi.waitFor(() => {
+      const last = frames[frames.length - 1]?.join("\n") ?? "";
+      if (!last.includes("copy me please")) throw new Error("no conversation frame yet");
+    });
+    // Drag across the user card's text row: press, motion, release.
+    session.handleKey({ type: "mouse", action: "press", button: 0, x: 1, y: 6 });
+    session.handleKey({ type: "mouse", action: "press", button: 32, x: 40, y: 6 });
+    session.handleKey({ type: "mouse", action: "release", button: 0, x: 40, y: 6 });
+    expect(copied).toHaveLength(1);
+    expect(copied[0]).toContain("copy me please");
+    expect(frames[frames.length - 1]!.join("\n")).toContain("Copied to clipboard");
+
+    // A drag over the open drawer copies drawer text: at width 80 the
+    // drawer starts right of the conversation's 46 columns, and detail
+    // line 1 carries the selected span's name.
+    session.handleKey({ type: "enter" });
+    session.handleKey({ type: "mouse", action: "press", button: 0, x: 49, y: 3 });
+    session.handleKey({ type: "mouse", action: "press", button: 32, x: 75, y: 3 });
+    session.handleKey({ type: "mouse", action: "release", button: 0, x: 75, y: 3 });
+    expect(copied).toHaveLength(2);
+    expect(copied[1]).toContain("agent.turn");
+    session.dispose();
+  });
+});
+
 describe("TraceViewerSession session preference", () => {
   it("opens on the trace containing the current session, not the newest", async () => {
     // Trace ids are provider-generated, so the session's trace is found by
diff --git a/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.ts b/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.ts
index 5ed933c47..506fef434 100644
--- a/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.ts
+++ b/packages/eve/src/cli/dev/tui/traces/trace-viewer-session.ts
@@ -10,8 +10,8 @@ import type { Theme } from "../theme.js";
 import type { TraceStore, TraceStoreEntry } from "./trace-store.js";
 import { createTraceStore } from "./trace-store.js";
 import { conversationItemLineCount } from "./trace-conversation.js";
-import { renderTraceViewer } from "./trace-view.js";
-import type { TraceViewerState } from "./trace-viewer-state.js";
+import { conversationSelectionText, panelSelectionText, renderTraceViewer } from "./trace-view.js";
+import type { TextSelectionRange, TraceViewerState } from "./trace-viewer-state.js";
 import {
   applyLoadedTrace,
   applyTraceList,
@@ -22,6 +22,8 @@ import {
 const POLL_INTERVAL_MS = 1_000;
 /** A trace whose last span landed this recently renders its window up to "now". */
 const LIVE_WINDOW_MS = 3_000;
+/** How long the copy confirmation stays in the header. */
+const TOAST_MS = 2_000;
 
 export interface TraceViewerOpenOptions {
   readonly appRoot: string;
@@ -42,6 +44,8 @@ export interface TraceViewerSessionOptions extends TraceViewerOpenOptions {
   readonly dimensions: () => { readonly width: number; readonly height: number };
   readonly tracingDisabled?: boolean;
   readonly store?: TraceStore;
+  /** Receives drag-selected text (wired to the clipboard by the renderer). */
+  readonly copyText?: (text: string) => void;
 }
 
 export class TraceViewerSession {
@@ -59,6 +63,8 @@ export class TraceViewerSession {
    */
   #preferSessionId?: string;
   #pollTimer?: ReturnType<typeof setInterval>;
+  #toast?: string;
+  #toastTimer?: ReturnType<typeof setTimeout>;
   #disposed = false;
   #refreshing = false;
   #refreshAgain = false;
@@ -101,9 +107,10 @@ export class TraceViewerSession {
       this.#preferSessionId = undefined;
     }
     const hadTrace = this.#state.trace !== undefined;
-    const { state, effect } = reduceTraceViewerKey(this.#state, key, this.#metrics);
+    const { state, effect, copySelection } = reduceTraceViewerKey(this.#state, key, this.#metrics);
     this.#state = state;
     if (effect === "close") return "close";
+    if (copySelection !== undefined) this.#copySelection(copySelection);
     this.repaint();
     // A trace switch cleared the timeline — fetch the newly selected trace
     // immediately instead of leaving a Loading frame up for a full poll.
@@ -120,6 +127,7 @@ export class TraceViewerSession {
       theme: this.#options.theme,
       tracingDisabled: this.#options.tracingDisabled,
       activeWindowEndNs: this.#activeWindowEndNs(),
+      toast: this.#toast,
     });
     this.#metrics = {
       timelineViewportRows: frame.timelineViewportRows,
@@ -144,6 +152,38 @@ export class TraceViewerSession {
       clearInterval(this.#pollTimer);
       this.#pollTimer = undefined;
     }
+    if (this.#toastTimer !== undefined) {
+      clearTimeout(this.#toastTimer);
+      this.#toastTimer = undefined;
+    }
+  }
+
+  /** Extracts the dragged text, hands it to the clipboard, and confirms with a toast. */
+  #copySelection(selection: TextSelectionRange): void {
+    const text =
+      selection.region === "panel"
+        ? panelSelectionText(
+            this.#state,
+            this.#options.dimensions().width,
+            this.#options.theme,
+            selection,
+          )
+        : conversationSelectionText(
+            this.#state,
+            this.#metrics.contentWidth,
+            this.#options.theme,
+            selection,
+          );
+    if (text.trim().length === 0) return;
+    this.#options.copyText?.(text);
+    this.#toast = "Copied to clipboard";
+    if (this.#toastTimer !== undefined) clearTimeout(this.#toastTimer);
+    this.#toastTimer = setTimeout(() => {
+      this.#toastTimer = undefined;
+      this.#toast = undefined;
+      this.repaint();
+    }, TOAST_MS);
+    this.#toastTimer.unref?.();
   }
 
   async #refresh(): Promise<void> {
diff --git a/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.test.ts b/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.test.ts
index b086a3a15..9a5c87887 100644
--- a/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.test.ts
+++ b/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.test.ts
@@ -172,7 +172,7 @@ describe("reduceTraceViewerKey", () => {
     expect(state.expandedItems.has(assistantIndex)).toBe(false);
   });
 
-  it("expands and collapses cards on mouse clicks", () => {
+  it("expands and collapses cards on mouse clicks (press + release in place)", () => {
     let state = applyLoadedTrace(createTraceViewerState(), conversationTrace({ longReply: true }));
     const env = {
       ...ENV,
@@ -183,29 +183,143 @@ describe("reduceTraceViewerKey", () => {
     // assistantIndex*7. Click one row into it (y=2 is first body row, so
     // bodyRow = clickY-2 maps to absolute line scrollRow+bodyRow).
     const clickY = 2 + assistantIndex * 7 + 1;
+    const click = (): void => {
+      state = reduceTraceViewerKey(
+        state,
+        { type: "mouse", action: "press", button: 0, x: 10, y: clickY },
+        env,
+      ).state;
+      state = reduceTraceViewerKey(
+        state,
+        { type: "mouse", action: "release", button: 0, x: 10, y: clickY },
+        env,
+      ).state;
+    };
 
+    click();
+    expect(state.selectedRow).toBe(assistantIndex);
+    expect(state.expandedItems.has(assistantIndex)).toBe(true);
+
+    click();
+    expect(state.expandedItems.has(assistantIndex)).toBe(false);
+
+    // A press alone (a drag may follow) is not a click.
     state = reduceTraceViewerKey(
       state,
       { type: "mouse", action: "press", button: 0, x: 10, y: clickY },
       env,
     ).state;
-    expect(state.selectedRow).toBe(assistantIndex);
-    expect(state.expandedItems.has(assistantIndex)).toBe(true);
+    expect(state.expandedItems.has(assistantIndex)).toBe(false);
+  });
 
+  it("selects and copies from the details drawer when the drag starts there", () => {
+    let state = applyLoadedTrace(createTraceViewerState(), conversationTrace());
+    const env = { ...ENV, conversationLineCounts: state.conversationItems.map(() => 6) };
+    state = reduceTraceViewerKey(state, key("enter"), env).state;
+    expect(state.panelOpen).toBe(true);
+    // Press right of the cards (contentWidth 80 + separator): drawer cell
+    // columns are relative to the drawer's content area.
     state = reduceTraceViewerKey(
       state,
-      { type: "mouse", action: "press", button: 0, x: 10, y: clickY },
+      { type: "mouse", action: "press", button: 0, x: 85, y: 3 },
       env,
     ).state;
-    expect(state.expandedItems.has(assistantIndex)).toBe(false);
+    expect(state.textSelection).toEqual({
+      anchor: { line: 1, column: 3 },
+      head: { line: 1, column: 3 },
+      dragging: false,
+      region: "panel",
+    });
+    state = reduceTraceViewerKey(
+      state,
+      { type: "mouse", action: "press", button: 32, x: 90, y: 5 },
+      env,
+    ).state;
+    const result = reduceTraceViewerKey(
+      state,
+      { type: "mouse", action: "release", button: 0, x: 90, y: 5 },
+      env,
+    );
+    expect(result.copySelection).toEqual({
+      anchor: { line: 1, column: 3 },
+      head: { line: 3, column: 8 },
+      dragging: true,
+      region: "panel",
+    });
+    expect(result.state.textSelection).toBeUndefined();
+  });
 
-    // A release is not a click.
+  it("does not anchor a selection right of the cards when the drawer is closed", () => {
+    let state = applyLoadedTrace(createTraceViewerState(), conversationTrace());
+    const env = { ...ENV, conversationLineCounts: state.conversationItems.map(() => 6) };
     state = reduceTraceViewerKey(
       state,
-      { type: "mouse", action: "release", button: 0, x: 10, y: clickY },
+      { type: "mouse", action: "press", button: 0, x: 85, y: 3 },
       env,
     ).state;
-    expect(state.expandedItems.has(assistantIndex)).toBe(false);
+    expect(state.textSelection).toBeUndefined();
+  });
+
+  it("copies a drag selection on release instead of clicking", () => {
+    let state = applyLoadedTrace(createTraceViewerState(), conversationTrace({ longReply: true }));
+    const env = {
+      ...ENV,
+      conversationLineCounts: state.conversationItems.map(() => 6),
+    };
+
+    state = reduceTraceViewerKey(
+      state,
+      { type: "mouse", action: "press", button: 0, x: 5, y: 3 },
+      env,
+    ).state;
+    expect(state.textSelection).toEqual({
+      anchor: { line: 1, column: 4 },
+      head: { line: 1, column: 4 },
+      dragging: false,
+      region: "conversation",
+    });
+
+    // Motion with the left button held (SGR button 32) extends the selection.
+    state = reduceTraceViewerKey(
+      state,
+      { type: "mouse", action: "press", button: 32, x: 20, y: 5 },
+      env,
+    ).state;
+    expect(state.textSelection).toEqual({
+      anchor: { line: 1, column: 4 },
+      head: { line: 3, column: 19 },
+      dragging: true,
+      region: "conversation",
+    });
+
+    const result = reduceTraceViewerKey(
+      state,
+      { type: "mouse", action: "release", button: 0, x: 20, y: 5 },
+      env,
+    );
+    expect(result.copySelection).toEqual({
+      anchor: { line: 1, column: 4 },
+      head: { line: 3, column: 19 },
+      dragging: true,
+      region: "conversation",
+    });
+    expect(result.state.textSelection).toBeUndefined();
+    // The drag did not toggle any card.
+    expect(result.state.expandedItems.size).toBe(0);
+  });
+
+  it("escape clears an in-flight selection without closing the viewer", () => {
+    let state = applyLoadedTrace(createTraceViewerState(), conversationTrace());
+    const env = { ...ENV, conversationLineCounts: state.conversationItems.map(() => 6) };
+    state = reduceTraceViewerKey(
+      state,
+      { type: "mouse", action: "press", button: 0, x: 5, y: 3 },
+      env,
+    ).state;
+    expect(state.textSelection).toBeDefined();
+    const result = reduceTraceViewerKey(state, key("escape"), env);
+    expect(result.effect).toBeUndefined();
+    expect(result.state.textSelection).toBeUndefined();
   });
 
   it("scrolls the viewport on mouse wheel events", () => {
diff --git a/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.ts b/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.ts
index 31ec86972..a5ca85ada 100644
--- a/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.ts
+++ b/packages/eve/src/cli/dev/tui/traces/trace-viewer-state.ts
@@ -38,6 +38,39 @@ export interface TraceViewerState {
   readonly panelScroll: number;
   /** One-line status for edge cases (trace pruned, tracing disabled, …). */
   readonly notice?: string;
+  /** Mouse drag selection over the conversation or drawer, in line/column cells. */
+  readonly textSelection?: TextSelectionRange;
+}
+
+/**
+ * One end of a text selection: line index + 0-based column, both relative
+ * to the selection's region — absolute conversation lines for the cards,
+ * absolute detail lines (and panel-content columns) for the drawer.
+ */
+export interface TextSelectionPoint {
+  readonly line: number;
+  readonly column: number;
+}
+
+/** A drag selection from anchor (press) to head (latest drag position). */
+export interface TextSelectionRange {
+  readonly anchor: TextSelectionPoint;
+  readonly head: TextSelectionPoint;
+  /** The pointer moved off the anchor cell — release copies instead of clicking. */
+  readonly dragging: boolean;
+  /** Where the drag started; the selection stays in that region. */
+  readonly region: "conversation" | "panel";
+}
+
+/** Selection endpoints ordered top-to-bottom for rendering and extraction. */
+export function orderedTextSelection(selection: TextSelectionRange): {
+  start: TextSelectionPoint;
+  end: TextSelectionPoint;
+} {
+  const { anchor, head } = selection;
+  const anchorFirst =
+    anchor.line < head.line || (anchor.line === head.line && anchor.column <= head.column);
+  return anchorFirst ? { start: anchor, end: head } : { start: head, end: anchor };
 }
 
 /** Viewport metrics the controller measures so scrolling math stays pure. */
@@ -61,6 +94,8 @@ export interface TraceViewerKeyEnvironment {
 export interface TraceViewerKeyResult {
   readonly state: TraceViewerState;
   readonly effect?: "close";
+  /** A completed drag selection to copy — the controller extracts and copies the text. */
+  readonly copySelection?: TextSelectionRange;
 }
 
 export function createTraceViewerState(): TraceViewerState {
@@ -131,6 +166,7 @@ export function applyTraceList(
     panelOpen: false,
     panelFocus: false,
     panelScroll: 0,
+    textSelection: undefined,
   };
 }
 
@@ -193,6 +229,9 @@ export function reduceTraceViewerKey(
 
   switch (key.type) {
     case "escape": {
+      if (base.textSelection !== undefined) {
+        return { state: { ...base, textSelection: undefined } };
+      }
       if (base.panelFocus) return { state: { ...base, panelFocus: false } };
       if (base.panelOpen) return { state: { ...base, panelOpen: false, panelScroll: 0 } };
       return { state: base, effect: "close" };
@@ -201,20 +240,60 @@ export function reduceTraceViewerKey(
       return { state: base, effect: "close" };
     }
     case "mouse": {
-      if (key.action !== "press") return { state: base };
       // Scroll wheel (SGR button 64/65): scroll the conversation viewport.
-      if (key.button === 64 || key.button === 65) {
+      if (key.action === "press" && (key.button === 64 || key.button === 65)) {
         const delta = key.button === 64 ? -3 : 3;
         return { state: scrollConversation(base, delta, environment) };
       }
-      if (key.button !== 0) return { state: base };
+      // Left press anchors a possible drag selection in whichever region the
+      // pointer sits over — the cards or the open drawer; the click action
+      // (and any copy) waits for release so dragging never toggles cards.
+      if (key.action === "press" && key.button === 0) {
+        const anchored = selectionCellAt(base, environment, key.x, key.y);
+        if (anchored === undefined) return { state: { ...base, textSelection: undefined } };
+        return {
+          state: {
+            ...base,
+            textSelection: {
+              anchor: anchored.point,
+              head: anchored.point,
+              dragging: false,
+              region: anchored.region,
+            },
+          },
+        };
+      }
+      // Motion with the left button held (SGR button 32) extends the
+      // selection within the region the drag started in.
+      if (key.action === "press" && key.button === 32) {
+        if (base.textSelection === undefined) return { state: base };
+        const point =
+          base.textSelection.region === "panel"
+            ? panelCellAt(base, environment, key.x, key.y)
+            : conversationCellAt(base, environment, key.x, key.y);
+        if (point === undefined) return { state: base };
+        const dragging =
+          base.textSelection.dragging ||
+          point.line !== base.textSelection.anchor.line ||
+          point.column !== base.textSelection.anchor.column;
+        return {
+          state: { ...base, textSelection: { ...base.textSelection, head: point, dragging } },
+        };
+      }
+      if (key.action !== "release" || key.button !== 0) return { state: base };
+      const selection = base.textSelection;
+      const released: TraceViewerState = { ...base, textSelection: undefined };
+      // A drag that moved copies the selection; a stationary click acts.
+      if (selection !== undefined && selection.dragging) {
+        return { state: released, copySelection: selection };
+      }
       // Left click selects and expands/collapses cards.
       const bodyIndex = key.y - 2; // one header row, 1-based coordinates
-      if (bodyIndex < 0) return { state: base };
-      const itemIndex = conversationItemAtBodyRow(base, environment, bodyIndex);
-      if (itemIndex === undefined) return { state: base };
-      const item = base.conversationItems[itemIndex];
-      const expandedItems = new Set(base.expandedItems);
+      if (bodyIndex < 0) return { state: released };
+      const itemIndex = conversationItemAtBodyRow(released, environment, bodyIndex);
+      if (itemIndex === undefined) return { state: released };
+      const item = released.conversationItems[itemIndex];
+      const expandedItems = new Set(released.expandedItems);
       if (
         item !== undefined &&
         !expandedItems.has(itemIndex) &&
@@ -224,7 +303,7 @@ export function reduceTraceViewerKey(
       } else {
         expandedItems.delete(itemIndex);
       }
-      return { state: { ...base, selectedRow: itemIndex, expandedItems } };
+      return { state: { ...released, selectedRow: itemIndex, expandedItems } };
     }
     case "enter": {
       if (traceViewerItemCount(base) === 0) return { state: base };
@@ -310,6 +389,7 @@ function switchTrace(state: TraceViewerState, delta: number): TraceViewerState {
     panelOpen: false,
     panelFocus: false,
     panelScroll: 0,
+    textSelection: undefined,
   };
 }
 
@@ -354,6 +434,68 @@ function conversationScrollRow(
   return Math.max(0, cardEnd - viewportRows);
 }
 
+/**
+ * Maps 1-based terminal coordinates to a conversation cell: absolute line
+ * (scroll offset applied) and 0-based column. Cells above the body, past
+ * the conversation's last line, or right of the cards (the details drawer)
+ * do not select.
+ */
+function conversationCellAt(
+  state: TraceViewerState,
+  environment: TraceViewerKeyEnvironment,
+  x: number,
+  y: number,
+): TextSelectionPoint | undefined {
+  const counts = environment.conversationLineCounts;
+  if (counts === undefined || state.conversationItems.length === 0) return undefined;
+  const bodyIndex = y - 2; // one header row, 1-based coordinates
+  if (bodyIndex < 0 || bodyIndex >= environment.timelineViewportRows) return undefined;
+  const column = x - 1;
+  if (column < 0 || column >= environment.contentWidth) return undefined;
+  let totalLines = 0;
+  for (const count of counts) totalLines += count + 1;
+  const line = state.scrollRow + bodyIndex;
+  if (line >= totalLines) return undefined;
+  return { column, line };
+}
+
+/**
+ * Maps 1-based terminal coordinates to a detail-drawer cell: absolute
+ * detail-line index (drawer scroll applied) and a column relative to the
+ * drawer's content (the area right of the conversation and its separator).
+ */
+function panelCellAt(
+  state: TraceViewerState,
+  environment: TraceViewerKeyEnvironment,
+  x: number,
+  y: number,
+): TextSelectionPoint | undefined {
+  if (!state.panelOpen || environment.panelTotalRows === 0) return undefined;
+  const bodyIndex = y - 2; // one header row, 1-based coordinates
+  if (bodyIndex < 0 || bodyIndex >= environment.panelViewportRows) return undefined;
+  const column = x - 1 - (environment.contentWidth + 1);
+  if (column < 0) return undefined;
+  const line = state.panelScroll + bodyIndex;
+  if (line >= environment.panelTotalRows) return undefined;
+  return { column, line };
+}
+
+/** Resolves a press to the region under the pointer: cards first, then drawer. */
+function selectionCellAt(
+  state: TraceViewerState,
+  environment: TraceViewerKeyEnvironment,
+  x: number,
+  y: number,
+):
+  | { readonly point: TextSelectionPoint; readonly region: TextSelectionRange["region"] }
+  | undefined {
+  const conversation = conversationCellAt(state, environment, x, y);
+  if (conversation !== undefined) return { point: conversation, region: "conversation" };
+  const panel = panelCellAt(state, environment, x, y);
+  if (panel !== undefined) return { point: panel, region: "panel" };
+  return undefined;
+}
+
 /** Maps a click's body row to a card index, walking card heights + separators. */
 function conversationItemAtBodyRow(
   state: TraceViewerState,
diff --git a/packages/eve/src/cli/ui/alt-screen.test.ts b/packages/eve/src/cli/ui/alt-screen.test.ts
index 32d26474b..fa731a158 100644
--- a/packages/eve/src/cli/ui/alt-screen.test.ts
+++ b/packages/eve/src/cli/ui/alt-screen.test.ts
@@ -21,12 +21,12 @@ describe("AltScreen", () => {
     const screen = new AltScreen(output);
     screen.enter();
     screen.enter();
-    expect(writes.join("")).toBe("\x1b[?1049h\x1b[?25l\x1b[?1000h\x1b[?1006h");
+    expect(writes.join("")).toBe("\x1b[?1049h\x1b[?25l\x1b[?1002h\x1b[?1006h");
     expect(screen.active).toBe(true);
     screen.exit();
     screen.exit();
     expect(writes.join("")).toBe(
-      "\x1b[?1049h\x1b[?25l\x1b[?1000h\x1b[?1006h\x1b[?1006l\x1b[?1000l\x1b[?25h\x1b[?1049l",
+      "\x1b[?1049h\x1b[?25l\x1b[?1002h\x1b[?1006h\x1b[?1006l\x1b[?1002l\x1b[?25h\x1b[?1049l",
     );
     expect(screen.active).toBe(false);
   });
diff --git a/packages/eve/src/cli/ui/alt-screen.ts b/packages/eve/src/cli/ui/alt-screen.ts
index 94962120a..ca7ee5ff6 100644
--- a/packages/eve/src/cli/ui/alt-screen.ts
+++ b/packages/eve/src/cli/ui/alt-screen.ts
@@ -14,8 +14,10 @@
 const ESC = "\x1b";
 const ALT_SCREEN_ON = `${ESC}[?1049h`;
 const ALT_SCREEN_OFF = `${ESC}[?1049l`;
-const MOUSE_ON = `${ESC}[?1000h${ESC}[?1006h`;
-const MOUSE_OFF = `${ESC}[?1006l${ESC}[?1000l`;
+// 1002 (button-event tracking) reports motion while a button is held, which
+// drag-to-select needs; 1006 upgrades coordinates to the SGR encoding.
+const MOUSE_ON = `${ESC}[?1002h${ESC}[?1006h`;
+const MOUSE_OFF = `${ESC}[?1006l${ESC}[?1002l`;
 const HIDE_CURSOR = `${ESC}[?25l`;
 const SHOW_CURSOR = `${ESC}[?25h`;
 const CLEAR_TO_END = `${ESC}[0J`;
@@ -65,6 +67,15 @@ export class AltScreen {
     this.#write(`${SYNC_START}${CURSOR_HOME}${CLEAR_TO_END}${body}${SYNC_END}`);
   }
 
+  /**
+   * Writes an out-of-band sequence (e.g. an OSC 52 clipboard write) through
+   * the same captured write the paints use, bypassing foreign-output capture.
+   */
+  writeRaw(chunk: string): void {
+    if (!this.#active) return;
+    this.#write(chunk);
+  }
+
   /** Restores the main screen, cursor, and mouse reporting. */
   exit(): void {
     if (!this.#active) return;
diff --git a/packages/eve/test/tui-client/tui-traces.ts b/packages/eve/test/tui-client/tui-traces.ts
index f49baafe7..c93073c09 100644
--- a/packages/eve/test/tui-client/tui-traces.ts
+++ b/packages/eve/test/tui-client/tui-traces.ts
@@ -208,14 +208,24 @@ void (async () => {
     }
     console.log(theme.muted("[tui-traces] arrow keys expand and collapse cards"));
 
-    // A mouse click toggles a card open too: an SGR press at row 3 lands
-    // inside the first card (one header row, 1-based coordinates).
+    // A mouse click toggles a card open too: an SGR press+release at row 3
+    // lands inside the first card (one header row, 1-based coordinates).
+    // The click acts on release so drag selections never toggle cards.
     input.send("\x1b[<0;10;3M");
+    input.send("\x1b[<0;10;3m");
     await screen.waitForText(SYSTEM_PROMPT_TAIL, 5_000);
     console.log(theme.muted("[tui-traces] mouse click expands a card"));
     input.left();
     await screen.waitForText("Click to expand", 5_000);
 
+    // Dragging (press, SGR button-32 motion, release) selects text and
+    // copies it, confirmed by the header toast.
+    input.send("\x1b[<0;3;3M");
+    input.send("\x1b[<32;30;3M");
+    input.send("\x1b[<0;30;3m");
+    await screen.waitForText("Copied to clipboard", 5_000);
+    console.log(theme.muted("[tui-traces] drag selection copies to the clipboard"));
+
     // The details drawer stays metadata-only: the tool card carries the call
     // payload inline ("city" in its Input section), while the drawer lists
     // facts and metadata attributes — never the content keys.