ethagent 3.3.4 → 4.0.0

package/src/chat/transcript/TranscriptView.tsx

@@ -1,184 +0,0 @@
-import React, { useEffect, useMemo, useState } from 'react'
-import { Box, Text, useStdout } from 'ink'
-import { useAppInput } from '../../app/input/AppInputProvider.js'
-import { MessageList, type MessageRow } from '../MessageList.js'
-import { theme } from '../../ui/theme.js'
-import {
-  anchorForScrollTop,
-  buildLineOffsets,
-  clampLine,
-  estimateMessageRowHeight,
-  resolveScrollTopFromAnchor,
-  scrollTopForPageDown,
-  scrollTopForPageUp,
-  selectRowsForScrollTop,
-  type TranscriptViewportState,
-} from './transcriptViewport.js'
-
-type TranscriptViewProps = {
-  rows: MessageRow[]
-  active?: boolean
-  bottomVariant?: 'prompt' | 'overlay'
-  onVisibleReasoningIdsChange?: (ids: string[]) => void
-  onScrollabilityChange?: (canScroll: boolean) => void
-}
-
-const PROMPT_RESERVED_LINES = 12
-const OVERLAY_RESERVED_LINES = 16
-const MIN_TRANSCRIPT_LINES = 6
-const MAX_TRANSCRIPT_LINES = 240
-
-export const TranscriptView: React.FC<TranscriptViewProps> = ({
-  rows,
-  active = true,
-  bottomVariant = 'prompt',
-  onVisibleReasoningIdsChange,
-  onScrollabilityChange,
-}) => {
-  const { stdout } = useStdout()
-  const columns = stdout.columns ?? process.stdout.columns ?? 80
-  const terminalRows = stdout.rows ?? process.stdout.rows ?? 24
-  const reservedLines = bottomVariant === 'overlay' ? OVERLAY_RESERVED_LINES : PROMPT_RESERVED_LINES
-  const maxLines = Math.min(
-    MAX_TRANSCRIPT_LINES,
-    Math.max(MIN_TRANSCRIPT_LINES, terminalRows - reservedLines),
-  )
-  const [viewportState, setViewportState] = useState<TranscriptViewportState>({
-    scrollTopLine: 0,
-    followTail: true,
-    anchor: null,
-  })
-  const metrics = useMemo(() => {
-    const heights = rows.map(row => Math.max(1, estimateMessageRowHeight(row, columns)))
-    const offsets = buildLineOffsets(heights)
-    const totalLines = offsets[offsets.length - 1] ?? 0
-    return {
-      rowIds: rows.map(row => row.id),
-      offsets,
-      maxScrollTop: Math.max(0, totalLines - maxLines),
-    }
-  }, [columns, maxLines, rows])
-  const resolvedViewportState = useMemo(
-    () => resolveViewportState(viewportState, metrics.rowIds, metrics.offsets, metrics.maxScrollTop),
-    [metrics, viewportState],
-  )
-  const selection = useMemo(
-    () => selectRowsForScrollTop(
-      rows,
-      maxLines,
-      resolvedViewportState.scrollTopLine,
-      row => estimateMessageRowHeight(row, columns),
-    ),
-    [columns, maxLines, resolvedViewportState, rows],
-  )
-  const visibleReasoningIds = useMemo(
-    () => selection.rows
-      .filter((slice): slice is { row: Extract<MessageRow, { role: 'thinking' }>; clipStart: number; clipEnd: number; rowHeight: number } =>
-        slice.row.role === 'thinking',
-      )
-      .map(slice => slice.row.id),
-    [selection.rows],
-  )
-
-  useEffect(() => {
-    setViewportState(prev => sameViewportState(prev, resolvedViewportState) ? prev : resolvedViewportState)
-  }, [resolvedViewportState])
-
-  useEffect(() => {
-    onVisibleReasoningIdsChange?.(visibleReasoningIds)
-  }, [onVisibleReasoningIdsChange, visibleReasoningIds])
-
-  useEffect(() => {
-    onScrollabilityChange?.(metrics.maxScrollTop > 0)
-  }, [metrics.maxScrollTop, onScrollabilityChange])
-
-  useAppInput((_input, key) => {
-    if (key.pageUp) {
-      const target = scrollTopForPageUp(
-        resolvedViewportState.scrollTopLine,
-        metrics.maxScrollTop,
-        maxLines,
-      )
-      setViewportState(viewportForScrollTop(
-        target,
-        metrics.rowIds,
-        metrics.offsets,
-        metrics.maxScrollTop,
-      ))
-    } else if (key.pageDown) {
-      const target = scrollTopForPageDown(
-        resolvedViewportState.scrollTopLine,
-        metrics.maxScrollTop,
-        maxLines,
-      )
-      setViewportState(viewportForScrollTop(
-        target,
-        metrics.rowIds,
-        metrics.offsets,
-        metrics.maxScrollTop,
-      ))
-    }
-  }, { isActive: active })
-
-  return (
-    <Box flexDirection="column">
-      {selection.hiddenBefore > 0 ? (
-        <Text color={theme.dim}>
-          {`  ${selection.hiddenBefore} earlier message${selection.hiddenBefore === 1 ? '' : 's'} above · `}
-          <Text color={theme.accentPeriwinkle}>pgup</Text>
-          {` to scroll · `}
-          <Text color={theme.accentPeriwinkle}>/export</Text>
-          {` saves the full transcript`}
-        </Text>
-      ) : null}
-      <MessageList slices={selection.rows} />
-      {selection.hiddenAfter > 0 ? (
-        <Text color={theme.dim}>
-          {`  ${selection.hiddenAfter} later message${selection.hiddenAfter === 1 ? '' : 's'} below · `}
-          <Text color={theme.accentPeriwinkle}>pgdn</Text>
-          {` to return`}
-        </Text>
-      ) : null}
-    </Box>
-  )
-}
-
-function resolveViewportState(
-  state: TranscriptViewportState,
-  rowIds: string[],
-  offsets: number[],
-  maxScrollTop: number,
-): TranscriptViewportState {
-  if (rowIds.length === 0) {
-    return { scrollTopLine: 0, followTail: true, anchor: null }
-  }
-
-  const scrollTopLine = state.followTail
-    ? maxScrollTop
-    : resolveScrollTopFromAnchor(rowIds, offsets, state.anchor, maxScrollTop)
-      ?? clampLine(state.scrollTopLine, maxScrollTop)
-
-  return viewportForScrollTop(scrollTopLine, rowIds, offsets, maxScrollTop)
-}
-
-function viewportForScrollTop(
-  scrollTopLine: number,
-  rowIds: string[],
-  offsets: number[],
-  maxScrollTop: number,
-): TranscriptViewportState {
-  const clamped = clampLine(scrollTopLine, maxScrollTop)
-  const followTail = clamped >= maxScrollTop
-  return {
-    scrollTopLine: clamped,
-    followTail,
-    anchor: followTail ? null : anchorForScrollTop(rowIds, offsets, clamped),
-  }
-}
-
-function sameViewportState(left: TranscriptViewportState, right: TranscriptViewportState): boolean {
-  return left.scrollTopLine === right.scrollTopLine
-    && left.followTail === right.followTail
-    && left.anchor?.rowId === right.anchor?.rowId
-    && left.anchor?.offset === right.anchor?.offset
-}

package/src/chat/transcript/transcriptViewport.ts

@@ -1,295 +0,0 @@
-import type { MessageRow } from '../MessageList.js'
-import { flattenAssistantBody } from '../MessageList.js'
-
-export type TranscriptAnchor = {
-  rowId: string
-  offset: number
-}
-
-export type TranscriptViewportState = {
-  scrollTopLine: number
-  followTail: boolean
-  anchor: TranscriptAnchor | null
-}
-
-export type RowSlice<T> = {
-  row: T
-  clipStart: number
-  clipEnd: number
-  rowHeight: number
-}
-
-export function buildLineOffsets(rowHeights: number[]): number[] {
-  const out = new Array<number>(rowHeights.length + 1).fill(0)
-  for (let i = 0; i < rowHeights.length; i += 1) {
-    out[i + 1] = out[i]! + (rowHeights[i] ?? 1)
-  }
-  return out
-}
-
-export function findRowIndexAtLine(offsets: number[], line: number): number {
-  let low = 0
-  let high = offsets.length - 1
-  while (low < high) {
-    const mid = Math.floor((low + high + 1) / 2)
-    if ((offsets[mid] ?? 0) <= line) low = mid
-    else high = mid - 1
-  }
-  return low
-}
-
-export function anchorForScrollTop(
-  rowIds: string[],
-  offsets: number[],
-  scrollTopLine: number,
-): TranscriptAnchor | null {
-  if (rowIds.length === 0) return null
-  const rowIndex = Math.min(rowIds.length - 1, findRowIndexAtLine(offsets, scrollTopLine))
-  const rowId = rowIds[rowIndex]
-  if (!rowId) return null
-  return {
-    rowId,
-    offset: Math.max(0, scrollTopLine - (offsets[rowIndex] ?? 0)),
-  }
-}
-
-export function resolveScrollTopFromAnchor(
-  rowIds: string[],
-  offsets: number[],
-  anchor: TranscriptAnchor | null,
-  maxScrollTop: number,
-): number | null {
-  if (!anchor) return null
-  const rowIndex = rowIds.indexOf(anchor.rowId)
-  if (rowIndex === -1) return null
-  return clampLine((offsets[rowIndex] ?? 0) + anchor.offset, maxScrollTop)
-}
-
-export function clampLine(line: number, maxScrollTop: number): number {
-  return Math.max(0, Math.min(maxScrollTop, Math.floor(line)))
-}
-
-export type TranscriptTailSelection<T> = {
-  rows: Array<RowSlice<T>>
-  hiddenCount: number
-}
-
-export type TranscriptWindowSelection<T> = {
-  rows: Array<RowSlice<T>>
-  hiddenBefore: number
-  hiddenAfter: number
-  totalLines: number
-  maxScrollOffset: number
-}
-
-export function selectTailRowsForViewport<T>(
-  rows: T[],
-  maxLines: number,
-  estimateHeight: (row: T) => number,
-): TranscriptTailSelection<T> {
-  if (rows.length === 0) return { rows: [], hiddenCount: 0 }
-
-  const budget = Math.max(1, Math.floor(maxLines))
-  let used = 0
-  let start = rows.length - 1
-
-  for (; start >= 0; start -= 1) {
-    const row = rows[start]
-    if (!row) break
-    const height = Math.max(1, estimateHeight(row))
-    if (used > 0 && used + height > budget) break
-    used += height
-  }
-
-  const firstVisible = Math.max(0, start + 1)
-  const slice = rows.slice(firstVisible).map(row => {
-    const height = Math.max(1, estimateHeight(row))
-    return { row, clipStart: 0, clipEnd: height, rowHeight: height }
-  })
-  return {
-    rows: slice,
-    hiddenCount: firstVisible,
-  }
-}
-
-export function selectRowsForScrollOffset<T>(
-  rows: T[],
-  maxLines: number,
-  scrollOffsetFromTail: number,
-  estimateHeight: (row: T) => number,
-): TranscriptWindowSelection<T> {
-  if (rows.length === 0) {
-    return { rows: [], hiddenBefore: 0, hiddenAfter: 0, totalLines: 0, maxScrollOffset: 0 }
-  }
-
-  const budget = Math.max(1, Math.floor(maxLines))
-  const heights = rows.map(row => Math.max(1, estimateHeight(row)))
-  const offsets = buildLineOffsets(heights)
-  const totalLines = offsets[offsets.length - 1] ?? 0
-  const maxScrollOffset = Math.max(0, totalLines - budget)
-  const scrollOffset = clampLine(scrollOffsetFromTail, maxScrollOffset)
-  const startLine = Math.max(0, totalLines - budget - scrollOffset)
-
-  return selectRowsForLineWindow(rows, heights, offsets, budget, startLine, totalLines, maxScrollOffset)
-}
-
-export function selectRowsForScrollTop<T>(
-  rows: T[],
-  maxLines: number,
-  scrollTopLine: number,
-  estimateHeight: (row: T) => number,
-): TranscriptWindowSelection<T> {
-  if (rows.length === 0) {
-    return { rows: [], hiddenBefore: 0, hiddenAfter: 0, totalLines: 0, maxScrollOffset: 0 }
-  }
-
-  const budget = Math.max(1, Math.floor(maxLines))
-  const heights = rows.map(row => Math.max(1, estimateHeight(row)))
-  const offsets = buildLineOffsets(heights)
-  const totalLines = offsets[offsets.length - 1] ?? 0
-  const maxScrollOffset = Math.max(0, totalLines - budget)
-  const startLine = clampLine(scrollTopLine, maxScrollOffset)
-
-  return selectRowsForLineWindow(rows, heights, offsets, budget, startLine, totalLines, maxScrollOffset)
-}
-
-export function scrollTopForPageUp(
-  scrollTopLine: number,
-  maxScrollTop: number,
-  viewportLines: number,
-): number {
-  return clampLine(scrollTopLine - pageScrollDistance(viewportLines), maxScrollTop)
-}
-
-export function scrollTopForPageDown(
-  scrollTopLine: number,
-  maxScrollTop: number,
-  viewportLines: number,
-): number {
-  return clampLine(scrollTopLine + pageScrollDistance(viewportLines), maxScrollTop)
-}
-
-function pageScrollDistance(viewportLines: number): number {
-  const viewport = Math.max(1, Math.floor(viewportLines))
-  return Math.max(1, viewport - 2)
-}
-
-function selectRowsForLineWindow<T>(
-  rows: T[],
-  heights: number[],
-  offsets: number[],
-  budget: number,
-  startLine: number,
-  totalLines: number,
-  maxScrollOffset: number,
-): TranscriptWindowSelection<T> {
-  const endLine = Math.min(totalLines, startLine + budget)
-
-  const startIndex = Math.min(rows.length - 1, findRowIndexAtLine(offsets, startLine))
-  const lastVisibleLine = Math.max(startLine, endLine - 1)
-  const endIndex = endLine >= totalLines
-    ? rows.length
-    : Math.min(rows.length, findRowIndexAtLine(offsets, lastVisibleLine) + 1)
-
-  const slices: Array<RowSlice<T>> = []
-  for (let i = startIndex; i < endIndex; i += 1) {
-    const row = rows[i]
-    if (!row) continue
-    const rowTop = offsets[i] ?? 0
-    const height = heights[i] ?? 1
-    const clipStart = Math.max(0, startLine - rowTop)
-    const clipEnd = Math.min(height, endLine - rowTop)
-    if (clipEnd <= clipStart) continue
-    slices.push({ row, clipStart, clipEnd, rowHeight: height })
-  }
-
-  return {
-    rows: slices,
-    hiddenBefore: startIndex,
-    hiddenAfter: rows.length - endIndex,
-    totalLines,
-    maxScrollOffset,
-  }
-}
-
-export function estimateMessageRowHeight(row: MessageRow, columns = 80): number {
-  const contentWidth = Math.max(20, columns - 8)
-  switch (row.role) {
-    case 'user':
-      return userRowLineCount(row.content, contentWidth)
-    case 'assistant':
-      return assistantRowLineCount(row.content, row.liveTail ?? '', contentWidth, Boolean(row.streaming))
-    case 'thinking':
-      return thinkingRowLineCount(row, contentWidth)
-    case 'tool_call':
-      return 1
-    case 'note':
-      return 1 + wrappedLineCount(row.content, contentWidth)
-    case 'progress':
-      return 4
-    case 'splash':
-      return 28
-  }
-}
-
-export function userRowLineCount(content: string, contentWidth: number): number {
-  const lines = splitLines(content)
-  return 1 + lines.reduce((sum, line) => sum + Math.max(1, Math.ceil(line.length / contentWidth)), 0)
-}
-
-export function assistantRowLineCount(content: string, liveTail: string, _contentWidth: number, streaming = false): number {
-  const fullText = liveTail ? content + liveTail : content
-  return 1 + flattenAssistantBody(fullText, streaming).length
-}
-
-export function thinkingRowLineCount(
-  row: Extract<MessageRow, { role: 'thinking' }>,
-  _contentWidth: number,
-): number {
-  const omitted = thinkingDisplayOmittedChars(row)
-  const overhead = 1 + (omitted > 0 ? 1 : 0) + 1
-  if (!row.expanded) return overhead
-  const body = thinkingDisplayBody(row)
-  const lines = splitLines(body)
-  return overhead + lines.length
-}
-
-export function thinkingDisplayBody(row: Extract<MessageRow, { role: 'thinking' }>): string {
-  const text = row.liveTail ? row.content + row.liveTail : row.content
-  return clipReasoningForDisplayText(text)
-}
-
-export function thinkingDisplayOmittedChars(row: Extract<MessageRow, { role: 'thinking' }>): number {
-  const text = row.liveTail ? row.content + row.liveTail : row.content
-  return clipReasoningForDisplayOmitted(text)
-}
-
-const MAX_RENDERED_REASONING_CHARS = 10_000
-
-function clipReasoningForDisplayText(text: string): string {
-  if (text.length <= MAX_RENDERED_REASONING_CHARS) return text
-  const rawStart = Math.max(0, text.length - MAX_RENDERED_REASONING_CHARS)
-  const newline = text.indexOf('\n', rawStart)
-  const start = newline >= 0 && newline - rawStart <= 240 ? newline + 1 : rawStart
-  return text.slice(start)
-}
-
-function clipReasoningForDisplayOmitted(text: string): number {
-  if (text.length <= MAX_RENDERED_REASONING_CHARS) return 0
-  const rawStart = Math.max(0, text.length - MAX_RENDERED_REASONING_CHARS)
-  const newline = text.indexOf('\n', rawStart)
-  return newline >= 0 && newline - rawStart <= 240 ? newline + 1 : rawStart
-}
-
-export function splitLines(text: string): string[] {
-  if (!text) return ['']
-  const normalized = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n')
-  return normalized.split('\n')
-}
-
-function wrappedLineCount(text: string, width: number): number {
-  if (!text) return 1
-  return text
-    .split(/\r?\n/)
-    .reduce((total, line) => total + Math.max(1, Math.ceil(line.length / width)), 0)
-}

package/src/chat/views/ContextLimitView.tsx

@@ -1,95 +0,0 @@
-import React, { useState } from 'react'
-import { Box, Text } from 'ink'
-import type { ContextUsage } from '../../runtime/compaction.js'
-import { useAppInput } from '../../app/input/AppInputProvider.js'
-import { theme } from '../../ui/theme.js'
-
-export type ContextLimitAction = 'compact' | 'switchModel' | 'send' | 'cancel'
-
-type ContextLimitViewProps = {
-  usage: ContextUsage
-  promptPreview: string
-  onSelect: (action: ContextLimitAction) => void | Promise<void>
-  onCancel: () => void
-}
-
-export const CONTEXT_LIMIT_OPTIONS: Array<{ action: ContextLimitAction; label: string; detail: string }> = [
-  {
-    action: 'compact',
-    label: 'Summarize and move to new conversation',
-    detail: 'Summarize this transcript into a new conversation, then send the pending message.',
-  },
-  {
-    action: 'switchModel',
-    label: 'Switch to larger-context model',
-    detail: 'Pick a model that can fit this conversation, then send the pending message.',
-  },
-  {
-    action: 'send',
-    label: 'Ignore warning and send',
-    detail: 'May hit rate/context limits faster or degrade local/cloud model behavior.',
-  },
-  {
-    action: 'cancel',
-    label: 'Cancel',
-    detail: 'Return to the prompt without sending the pending message.',
-  },
-]
-
-export const ContextLimitView: React.FC<ContextLimitViewProps> = ({
-  usage,
-  promptPreview,
-  onSelect,
-  onCancel,
-}) => {
-  const [selected, setSelected] = useState(0)
-
-  useAppInput((_input, key) => {
-    if (key.escape) {
-      onCancel()
-      return
-    }
-    if (key.upArrow) {
-      setSelected(i => Math.max(0, i - 1))
-      return
-    }
-    if (key.downArrow) {
-      setSelected(i => Math.min(CONTEXT_LIMIT_OPTIONS.length - 1, i + 1))
-      return
-    }
-    if (key.return) {
-      const picked = CONTEXT_LIMIT_OPTIONS[selected]
-      if (picked) void onSelect(picked.action)
-    }
-  })
-
-  return (
-    <Box flexDirection="column" borderStyle="round" borderColor={theme.accentPeriwinkle} paddingX={1}>
-      <Text color={theme.accentPeriwinkle} bold>context limit</Text>
-      <Text color={theme.dim}>
-        {`Context ${usage.percent}% · ~${formatTokens(usage.usedTokens)} / ${formatTokens(usage.windowTokens)} tokens (${usage.source}).`}
-      </Text>
-      {usage.percent >= 100 ? (
-        <Text color={theme.accentPeriwinkle}>
-          This transcript is over the selected model's estimated window. You can still send, but summarizing first is safer.
-        </Text>
-      ) : null}
-      <Text color={theme.textSubtle}>{`Pending: ${promptPreview || '(empty)'}`}</Text>
-      <Box flexDirection="column" marginTop={1}>
-        {CONTEXT_LIMIT_OPTIONS.map((option, index) => (
-          <Text key={option.action} color={index === selected ? theme.accentPeriwinkle : theme.text}>
-            {index === selected ? '> ' : '  '}
-            {option.label}
-            <Text color={theme.dim}>{` · ${option.detail}`}</Text>
-          </Text>
-        ))}
-      </Box>
-    </Box>
-  )
-}
-
-function formatTokens(count: number): string {
-  if (count < 1000) return String(count)
-  if (count < 10_000) return `${(count / 1000).toFixed(1)}k`
-  return `${Math.round(count / 1000)}k`
-}

package/src/chat/views/ContinuityEditReviewView.tsx

@@ -1,50 +0,0 @@
-import React from 'react'
-import { Box, Text } from 'ink'
-import { Surface } from '../../ui/Surface.js'
-import { Select } from '../../ui/Select.js'
-import { theme } from '../../ui/theme.js'
-import { DiffView } from '../display/DiffView.js'
-
-export type ContinuityEditReviewState = {
-  file: 'SOUL.md' | 'MEMORY.md'
-  filePath: string
-  summary: string
-  diff?: string
-  editorOpened?: boolean
-}
-
-export type ContinuityEditReviewAction = 'open' | 'save-publish' | 'later'
-
-export const ContinuityEditReviewView: React.FC<{
-  review: ContinuityEditReviewState
-  onSelect: (action: ContinuityEditReviewAction) => void | Promise<void>
-  onCancel: () => void
-}> = ({ review, onSelect, onCancel }) => (
-  <Surface
-    title={`${review.file} Updated`}
-    footer="enter select · esc dismiss"
-  >
-    <Text color={theme.accentPeriwinkle}>{displayContinuityReviewText(review.summary)}</Text>
-    {review.diff ? (
-      <Box flexDirection="column" marginTop={1}>
-        <Text color={theme.accentPeriwinkle}>diff</Text>
-        <DiffView diff={review.diff} />
-      </Box>
-    ) : null}
-    <Box marginTop={1}>
-      <Select<ContinuityEditReviewAction>
-        options={[
-          { value: 'open', label: `Open ${review.file}`, hint: 'Review in editor' },
-          { value: 'save-publish', label: 'Save Snapshot', hint: 'Wallet signature' },
-          { value: 'later', label: 'Dismiss', hint: 'Save later from Identity Hub' },
-        ]}
-        onSubmit={onSelect}
-        onCancel={onCancel}
-      />
-    </Box>
-  </Surface>
-)
-
-function displayContinuityReviewText(value: string): string {
-  return value ? value[0]!.toUpperCase() + value.slice(1) : value
-}

package/src/chat/views/CopyPicker.tsx

@@ -1,50 +0,0 @@
-import React from 'react'
-import { Surface } from '../../ui/Surface.js'
-import { Select } from '../../ui/Select.js'
-import { parseSegments, type Segment } from '../../utils/markdownSegments.js'
-import { copyToClipboard, type CopyResult } from '../../utils/clipboard.js'
-
-type CopyPickerProps = {
-  turnText: string
-  turnLabel: string
-  onDone: (result: CopyResult, label: string) => void
-  onCancel: () => void
-}
-
-type Choice = { index: number; segment: Segment | null; label: string }
-
-export const CopyPicker: React.FC<CopyPickerProps> = ({ turnText, turnLabel, onDone, onCancel }) => {
-  const segments = parseSegments(turnText)
-  const choices: Choice[] = [
-    { index: -1, segment: null, label: `all (${turnText.length} chars)` },
-    ...segments.map((segment, i) => ({ index: i, segment, label: segment.preview })),
-  ]
-
-  const options = choices.map(c => ({
-    value: c.index,
-    label: c.label,
-    hint: c.segment ? (c.segment.kind === 'code' ? 'code block' : undefined) : 'full reply',
-  }))
-
-  const handleSubmit = (index: number) => {
-    const chosen = choices.find(c => c.index === index)
-    const payload = chosen?.segment ? chosen.segment.content : turnText
-    const label = chosen?.label ?? 'copy'
-    void copyToClipboard(payload).then(result => onDone(result, label))
-  }
-
-  return (
-    <Surface
-      title={`Copy From ${turnLabel}`}
-      subtitle="Choose the full reply or an extracted segment."
-      footer="enter copies · esc closes"
-    >
-      <Select<number>
-        options={options}
-        initialIndex={0}
-        onSubmit={handleSubmit}
-        onCancel={onCancel}
-      />
-    </Surface>
-  )
-}