pi-better-btw-plus 1.3.0 → 1.4.0

package/config.json

@@ -18,6 +18,7 @@
   "features": {
     "rightClickCopyPaste": true,
     "modelSwitch": true,
-    "retry": true
+    "retry": true,
+    "editorSelection": true
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-btw-plus",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "pi extension: /btw side-chat overlay — maintained fork of @yceachan/pi-better-btw (+ right-click copy/paste, fork model switch, turn-level retry)",
   "type": "module",
   "keywords": [

package/srcs/config.ts

@@ -42,6 +42,8 @@ export interface SideChatFeatures {
   modelSwitch: boolean;
   /** Turn-level auto-retry of transient provider errors. Default: true. */
   retry: boolean;
+  /** Left-drag selection on the input editor (spec #24). Default: true. */
+  editorSelection: boolean;
 }
 
 export interface SideChatConfig {
@@ -204,6 +206,7 @@ function parseConfigLayer(raw: unknown, dir: string): ConfigLayer {
           rightClickCopyPaste: parseBoolean(featureRec.rightClickCopyPaste),
           modelSwitch: parseBoolean(featureRec.modelSwitch),
           retry: parseBoolean(featureRec.retry),
+          editorSelection: parseBoolean(featureRec.editorSelection),
         }
       : undefined,
   };
@@ -287,12 +290,14 @@ const FEATURE_KEYS = [
   "rightClickCopyPaste",
   "modelSwitch",
   "retry",
+  "editorSelection",
 ] as const;
 function mergeFeatures(layers: ConfigLayer[]): SideChatFeatures {
   const features: SideChatFeatures = {
     rightClickCopyPaste: true,
     modelSwitch: true,
     retry: true,
+    editorSelection: true,
   };
   for (const layer of layers) {
     const layerFeatures = layer.features;

package/srcs/editor-selection.ts

@@ -0,0 +1,366 @@
+/**
+ * Editor selection: a zero-TUI, visual-space selection model for the side chat's
+ * input editor (pi-tui `Editor`), spec #24 / T1 (#25).
+ *
+ * The `Editor` widget exposes no selection or highlight API and keeps its
+ * word-wrap map and scroll offset private, so selection lives in *visual/screen
+ * space*: an anchor/focus pair of `{line, col}` positions relative to the
+ * editor's content band — the lines of `Editor.render(width)` between the top
+ * and bottom border rows (top border excluded, so band line 0 is `rendered[1]`).
+ * Columns are cell columns (visible width), grapheme-aligned so a wide/CJK
+ * grapheme is never split, and every range is clipped so it never includes a
+ * paste-marker literal (`[paste #N …]`).
+ *
+ * Everything here is pure and unit-testable; the overlay (T3/T4) wires the
+ * `EditorSelectionState` holder and `decorateEditorSelection` into `render()`.
+ */
+import {
+  findWordBackward,
+  findWordForward,
+} from "@earendil-works/pi-tui/dist/word-navigation.js";
+import {
+  sliceByColumn,
+  stripTerminalSequences,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+
+/** A position in editor visual space. */
+export interface EditorPos {
+  /** Visual line index within the editor content band (0-based, top border excluded). */
+  line: number;
+  /** Cell column (visible width, 0-based), grapheme-aligned. */
+  col: number;
+}
+
+/** A visual-space selection over the editor content band. */
+export interface EditorSelection {
+  anchor: EditorPos;
+  focus: EditorPos;
+}
+
+/** One visual line's inverse-video highlight range (content-band coordinates). */
+export interface EditorHighlightRange {
+  /** Content-band line index. */
+  line: number;
+  /** Start cell column (inclusive). */
+  start: number;
+  /** End cell column (exclusive). */
+  end: number;
+}
+
+// Paste markers the editor inserts for large pastes (mirrors the editor's own
+// `PASTE_MARKER_REGEX`). Selection must never include their literal text.
+const PASTE_MARKER_GLOBAL = /\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]/g;
+const PASTE_MARKER_SINGLE = /^\[paste #(\d+)( (\+\d+ lines|\d+ chars))?\]$/;
+
+const SELECTION_ON = "\x1b[7m";
+const SELECTION_OFF = "\x1b[27m";
+
+const graphemeSegmenter = new Intl.Segmenter(undefined, {
+  granularity: "grapheme",
+});
+const wordSegmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+
+function isPasteMarkerText(segment: string): boolean {
+  return segment.length >= 10 && PASTE_MARKER_SINGLE.test(segment);
+}
+
+/** Cell-column spans of every paste-marker literal in a plain line. */
+function pasteMarkerSpans(
+  plain: string,
+): Array<{ start: number; end: number }> {
+  const spans: Array<{ start: number; end: number }> = [];
+  for (const m of plain.matchAll(PASTE_MARKER_GLOBAL)) {
+    const start = m.index ?? 0;
+    const end = start + m[0].length;
+    spans.push({
+      start: visibleWidth(plain.slice(0, start)),
+      end: visibleWidth(plain.slice(0, end)),
+    });
+  }
+  return spans;
+}
+
+/** Map a cell column to the code-unit index of the grapheme containing it. */
+function colToCharIndex(plain: string, col: number): number {
+  let width = 0;
+  for (const seg of graphemeSegmenter.segment(plain)) {
+    const w = visibleWidth(seg.segment);
+    if (width + w > col) return seg.index;
+    width += w;
+  }
+  return plain.length;
+}
+
+/** Snap a cell column to a grapheme boundary ("start" floors, "end" ceils). */
+function snapCol(plain: string, col: number, which: "start" | "end"): number {
+  let width = 0;
+  for (const { segment } of graphemeSegmenter.segment(plain)) {
+    const w = visibleWidth(segment);
+    const gStart = width;
+    const gEnd = width + w;
+    if (col > gStart && col < gEnd) return which === "start" ? gStart : gEnd;
+    width = gEnd;
+  }
+  return col;
+}
+
+/** Clamp a cell column into [0, lineWidth]. */
+function clampCol(col: number, width: number): number {
+  return Math.max(0, Math.min(col, width));
+}
+
+/** Clip a cell range so it never includes a paste-marker literal. */
+function clipRangeToMarkers(
+  start: number,
+  end: number,
+  plain: string,
+): { start: number; end: number } {
+  let s = start;
+  let e = end;
+  for (const span of pasteMarkerSpans(plain)) {
+    if (span.end <= s) continue; // marker entirely before the range
+    if (span.start >= e) break; // markers are sorted; the rest are after
+    if (span.start <= s && span.end >= e) return { start: s, end: s }; // fully inside
+    if (span.start <= s) s = span.end; // marker covers the start
+    else if (span.end >= e) e = span.start; // marker covers the end
+    else e = span.start; // marker strictly inside → keep the left part
+    if (s >= e) return { start: s, end: s };
+  }
+  return { start: s, end: e };
+}
+
+/** Topmost/leftmost endpoint of a selection. */
+export function orderedStart(sel: EditorSelection): EditorPos {
+  const { anchor, focus } = sel;
+  if (
+    anchor.line < focus.line ||
+    (anchor.line === focus.line && anchor.col <= focus.col)
+  ) {
+    return anchor;
+  }
+  return focus;
+}
+
+/** Bottommost/rightmost endpoint of a selection. */
+export function orderedEnd(sel: EditorSelection): EditorPos {
+  const { anchor, focus } = sel;
+  if (
+    anchor.line > focus.line ||
+    (anchor.line === focus.line && anchor.col > focus.col)
+  ) {
+    return anchor;
+  }
+  return focus;
+}
+
+/**
+ * The editor content band: `Editor.render()` output with the top/bottom border
+ * rows dropped, ANSI stripped, and trailing padding trimmed. Assumes the
+ * overlay's editor config (`paddingX: 0`), so padding is trailing only.
+ */
+export function contentBandPlainLines(rendered: string[]): string[] {
+  return rendered.slice(1, -1).map((l) => stripTerminalSequences(l).trimEnd());
+}
+
+/**
+ * Per-visual-line inverse-video highlight ranges for a selection. Columns are
+ * clamped to each line's visible width, snapped to grapheme boundaries, and
+ * clipped so the range never crosses a paste marker.
+ */
+export function highlightRanges(
+  plainLines: string[],
+  sel: EditorSelection,
+): EditorHighlightRange[] {
+  const n = plainLines.length;
+  if (n === 0) return [];
+  const start = orderedStart(sel);
+  const end = orderedEnd(sel);
+  const first = Math.max(0, Math.min(start.line, n - 1));
+  const last = Math.max(0, Math.min(end.line, n - 1));
+  const ranges: EditorHighlightRange[] = [];
+  for (let line = first; line <= last; line++) {
+    const text = plainLines[line] ?? "";
+    const width = visibleWidth(text);
+    let s = line === start.line ? clampCol(start.col, width) : 0;
+    let e = line === end.line ? clampCol(end.col, width) : width;
+    if (s >= e) continue;
+    s = snapCol(text, s, "start");
+    e = snapCol(text, e, "end");
+    const clipped = clipRangeToMarkers(s, e, text);
+    if (clipped.end > clipped.start) {
+      ranges.push({ line, start: clipped.start, end: clipped.end });
+    }
+  }
+  return ranges;
+}
+
+/**
+ * Copy text for a selection: each selected line is stripped to plain text and
+ * sliced by cell column, then lines are joined with `\n` in top-to-bottom
+ * reading order (soft wraps become hard newlines — accepted v1 behavior).
+ */
+export function selectedText(plainLines: string[], sel: EditorSelection): string {
+  return highlightRanges(plainLines, sel)
+    .map((r) => sliceByColumn(plainLines[r.line] ?? "", r.start, r.end - r.start))
+    .join("\n");
+}
+
+// Word navigation mirroring the editor's own word-jump semantics: paste markers
+// are merged into atomic segments (the editor's `segmentWithMarkers`), so
+// findWordBackward/Forward treat a marker as a single unit and never land
+// mid-marker.
+function wordSegments(text: string): Intl.SegmentData[] {
+  if (!text.includes("[paste #")) return [...wordSegmenter.segment(text)];
+  const markers: Array<{ start: number; end: number }> = [];
+  for (const m of text.matchAll(PASTE_MARKER_GLOBAL)) {
+    const start = m.index ?? 0;
+    markers.push({ start, end: start + m[0].length });
+  }
+  if (markers.length === 0) return [...wordSegmenter.segment(text)];
+  const merged: Intl.SegmentData[] = [];
+  let markerIdx = 0;
+  for (const seg of wordSegmenter.segment(text)) {
+    while (markerIdx < markers.length && markers[markerIdx].end <= seg.index) {
+      markerIdx++;
+    }
+    const marker = markerIdx < markers.length ? markers[markerIdx] : null;
+    if (marker && seg.index >= marker.start && seg.index < marker.end) {
+      if (seg.index === marker.start) {
+        merged.push({
+          segment: text.slice(marker.start, marker.end),
+          index: marker.start,
+          input: text,
+        });
+      }
+    } else {
+      merged.push(seg);
+    }
+  }
+  return merged;
+}
+
+const WORD_NAV_OPTIONS = {
+  segment: (text: string) => wordSegments(text),
+  isAtomicSegment: isPasteMarkerText,
+};
+
+/**
+ * Double-click word selection around `(line, col)`: resolve the word bounds with
+ * the editor's own `findWordBackward`/`findWordForward` on that visual line's
+ * visible text, then clip the result at paste markers (so a double-click on a
+ * marker selects nothing).
+ */
+export function wordSelection(
+  plainLines: string[],
+  line: number,
+  col: number,
+): EditorSelection {
+  const text = plainLines[line] ?? "";
+  const c = clampCol(col, visibleWidth(text));
+  const idx = colToCharIndex(text, c);
+  const back = findWordBackward(text, idx, WORD_NAV_OPTIONS);
+  const fwd = findWordForward(text, idx, WORD_NAV_OPTIONS);
+  const clipped = clipRangeToMarkers(
+    visibleWidth(text.slice(0, back)),
+    visibleWidth(text.slice(0, fwd)),
+    text,
+  );
+  return {
+    anchor: { line, col: clipped.start },
+    focus: { line, col: clipped.end },
+  };
+}
+
+/**
+ * Triple-click visual-line selection: the whole line, from column 0 to the
+ * line's visible width (paste-marker clipping still applies downstream).
+ */
+export function lineSelection(
+  plainLines: string[],
+  line: number,
+): EditorSelection {
+  const text = plainLines[line] ?? "";
+  return {
+    anchor: { line, col: 0 },
+    focus: { line, col: visibleWidth(text) },
+  };
+}
+
+/**
+ * Post-process `Editor.render()` output with inverse-video highlight for a
+ * selection. Only the content-band lines in the selection are rebuilt (from
+ * their plain text, dropping the cursor's own ANSI highlight); border rows and
+ * unselected lines pass through untouched. Rebuilt lines are re-padded to the
+ * original content width. Assumes no autocomplete rows are present (the overlay
+ * gates selection off while the popup is open — ADR 0006).
+ */
+export function decorateEditorSelection(
+  rendered: string[],
+  sel: EditorSelection,
+): string[] {
+  const plain = contentBandPlainLines(rendered);
+  const ranges = highlightRanges(plain, sel);
+  if (ranges.length === 0) return rendered;
+  const out = rendered.slice();
+  for (const r of ranges) {
+    const text = plain[r.line];
+    if (text === undefined) continue;
+    const raw = out[r.line + 1];
+    if (raw === undefined) continue;
+    const contentWidth = visibleWidth(raw);
+    const s = colToCharIndex(text, r.start);
+    const e = colToCharIndex(text, r.end);
+    const rebuilt =
+      text.slice(0, s) + SELECTION_ON + text.slice(s, e) + SELECTION_OFF +
+      text.slice(e);
+    out[r.line + 1] =
+      rebuilt + " ".repeat(Math.max(0, contentWidth - visibleWidth(rebuilt)));
+  }
+  return out;
+}
+
+/**
+ * Stateful holder for the overlay (T3): stores the anchor/focus pair and
+ * delegates all computation to the pure functions above. No window-shift
+ * translation is needed (the editor does not grow mid-drag like the message
+ * area does), and the lifecycle is transient — the overlay clears it on any
+ * non-drag editor input or a plain click.
+ */
+export class EditorSelectionState {
+  private selection: EditorSelection | null = null;
+
+  setSelection(anchor: EditorPos, focus: EditorPos): void {
+    this.selection = { anchor, focus };
+  }
+
+  clear(): void {
+    this.selection = null;
+  }
+
+  get(): EditorSelection | null {
+    return this.selection;
+  }
+
+  hasSelection(): boolean {
+    const s = this.selection;
+    if (!s) return false;
+    return s.anchor.line !== s.focus.line || s.anchor.col !== s.focus.col;
+  }
+
+  getAnchor(): EditorPos | null {
+    return this.selection?.anchor ?? null;
+  }
+
+  highlightRanges(plainLines: string[]): EditorHighlightRange[] {
+    return this.selection ? highlightRanges(plainLines, this.selection) : [];
+  }
+
+  selectedText(plainLines: string[]): string {
+    return this.selection ? selectedText(plainLines, this.selection) : "";
+  }
+
+  decorate(rendered: string[]): string[] {
+    return this.selection ? decorateEditorSelection(rendered, this.selection) : rendered;
+  }
+}

package/srcs/pointer-gesture.ts

@@ -1,12 +1,15 @@
 /**
- * Pointer gesture state machine for the side chat overlay (spec #12/#13):
- * consumes raw SGR mouse events, produces `GestureAction[]` action objects.
+ * Pointer gesture state machine for the side chat overlay (spec #12/#13,
+ * #24/#26): consumes raw SGR mouse events, produces `GestureAction[]` action
+ * objects over two surfaces — the chat area and the input editor.
  *
  * The module is deliberately ignorant of the TUI, clipboard and editor: it
- * only classifies press/drag/double-click/wheel/right-click sequences and
- * reports WHAT happened; the overlay owns the "action → render" translation.
- * All coordinates handed to the injected hit queries are 0-based screen
- * coordinates (the SGR 1-based → 0-based conversion happens here).
+ * only classifies press/drag/double-/triple-click/wheel/right-click sequences
+ * and reports WHAT happened and on WHICH surface; the overlay owns the
+ * "action → render" translation. All coordinates handed to the injected hit
+ * queries are 0-based screen coordinates (the SGR 1-based → 0-based
+ * conversion happens here); positions the queries return live in each
+ * surface's own coordinate space (chat cells or editor visual cells).
  */
 import {
   isLeftDrag,
@@ -19,15 +22,19 @@ import {
   type SgrMouseEvent,
 } from "./side-chat-mouse.ts";
 import type { CellPos } from "./side-chat-messages.ts";
+import type { EditorPos } from "./editor-selection.ts";
 
-/** Two quick presses within this window (same line) count as a double-click → select line. */
+/**
+ * Two (or three) quick presses within this window count as a multi-click
+ * (double-click → word/line, triple-click → line), same surface only.
+ */
 export const DOUBLE_CLICK_INTERVAL_MS = 500;
 
 /**
  * True when a drag release ended within the double-click tolerance (same
  * line, within a couple of cells). Real terminals report motion even for
- * 1-cell hand shake during a double-click, so a selection this small is a
- * click, not a drag — it must not suppress the next press's double-click
+ * 1-cell hand shake during a multi-click, so a selection this small is a
+ * click, not a drag — it must not suppress the next press's multi-click
  * classification. Only the same line counts: a real cross-line drag of a
  * couple of cells stays a drag, never a click.
  */
@@ -44,14 +51,24 @@ export function selectionWithinClickTolerance(a: CellPos, b: CellPos): boolean {
  */
 export const DRAG_RENDER_INTERVAL_MS = 32;
 
+/**
+ * The two selection surfaces the gesture module classifies over (spec #24).
+ * Positions on each surface live in that surface's own coordinate space:
+ * chat cells for "chat", editor visual cells for "editor".
+ */
+export type Surface = "chat" | "editor";
+
 /**
  * One output of the gesture state machine. At most one action per event;
  * no-op situations (release outside the press area, right-click without a
- * selection, header/border hits) produce an empty array.
+ * selection, header/border hits) produce an empty array. Selection actions
+ * carry the surface they act on; the overlay resolves surface-local geometry
+ * (column bounds, word bounds) from its own state.
  */
 export type GestureAction =
   | {
       kind: "select";
+      surface: Surface;
       anchor: CellPos;
       focus: CellPos;
       /** False on throttled drag updates: the selection changed but the frame need not repaint. */
@@ -59,11 +76,19 @@ export type GestureAction =
     }
   | {
       kind: "selectLine";
+      surface: Surface;
       /** Rendered line to select; column bounds are filled in by the overlay from its own geometry. */
       line: number;
     }
+  | {
+      kind: "selectWord";
+      surface: Surface;
+      /** Visual cell under the double-click; word bounds are resolved by the overlay (editor surface only). */
+      line: number;
+      col: number;
+    }
   | { kind: "scroll"; lines: number }
-  | { kind: "copy" }
+  | { kind: "copy"; surface: Surface }
   | { kind: "paste" };
 
 /**
@@ -80,19 +105,29 @@ export interface PointerHit {
   clampToChat(row: number, col: number): CellPos;
   /** True when a screen row falls inside the input editor widget band. */
   overEditor(row: number, col: number): boolean;
-  /** True when a non-empty selection is active (right-click copy precondition). */
+  /** Map a screen position to an editor visual cell, or null off the editor content band. */
+  editorAt(row: number, col: number): EditorPos | null;
+  /** Like editorAt but clamps into the editor content band (drag overshoot). */
+  clampToEditor(row: number, col: number): EditorPos;
+  /** True when a non-empty chat selection is active (right-click copy precondition). */
   hasSelection(): boolean;
-  /** The current selection anchor (window coordinates), or null when no selection. */
+  /** The current chat selection anchor (window coordinates), or null when no selection. */
   getSelectionAnchor(): CellPos | null;
+  /** True when a non-empty editor selection is active. */
+  hasEditorSelection(): boolean;
+  /** The current editor selection anchor, or null when no selection. */
+  getEditorSelectionAnchor(): EditorPos | null;
 }
 
 export interface PointerGestureOptions {
   hit: PointerHit;
   /** D11 gate: when false, right presses are not recorded and releases produce no actions. */
   rightClickEnabled?: boolean;
+  /** Editor-selection gate (spec #24): when false, left presses never classify onto the editor surface. */
+  editorSelectionEnabled?: boolean;
   /** Wheel scroll step in lines (default 3, matching the previous mouse handler). */
   wheelScrollLines?: number;
-  /** Clock for the double-click window and drag throttle (test seam; defaults to Date.now). */
+  /** Clock for the click-count window and drag throttle (test seam; defaults to Date.now). */
   now?: () => number;
 }
 
@@ -102,10 +137,12 @@ export interface PointerGestureOptions {
  * lives in the overlay, the module knows nothing about the modal).
  */
 export class PointerGesture {
-  /** Options with defaults already merged in (rightClickEnabled / wheelScrollLines / now). */
+  /** Options with defaults already merged in (rightClickEnabled / editorSelectionEnabled / wheelScrollLines / now). */
   private readonly options: Required<PointerGestureOptions>;
   /** Set while a left-button selection drag is in progress. */
   private dragging = false;
+  /** The surface the in-flight left drag is on (null when not dragging). */
+  private surface: Surface | null = null;
   /** Right-press landed in the chat area; the copy action fires on release there. */
   private rightPressInChat = false;
   /** Right-press landed in the input editor; the paste action fires on release there. */
@@ -113,8 +150,11 @@ export class PointerGesture {
   private mouseAnchor: CellPos = { line: 0, col: 0 };
   private lastPressTime = 0;
   private lastPressPos: CellPos | null = null;
-  private pendingDoubleClick = false;
-  /** The last release ended a drag; a quick follow-up click must not count as a double-click. */
+  /** The surface of the last press (a surface change resets the click count). */
+  private lastPressSurface: Surface | null = null;
+  /** Consecutive-click count of the current series (1–3), resolved at press time. */
+  private clickCount = 1;
+  /** The last release ended a drag; a quick follow-up click must not count as a multi-click. */
   private lastReleaseWasDrag = false;
   /** Timestamp of the last paint-triggering drag motion (coalescing). */
   private lastDragRenderAt = 0;
@@ -122,15 +162,51 @@ export class PointerGesture {
   constructor(options: PointerGestureOptions) {
     this.options = {
       rightClickEnabled: true,
+      editorSelectionEnabled: true,
       wheelScrollLines: 3,
       now: () => Date.now(),
       ...options,
     };
   }
 
+  /** Clamp a screen position into the active surface's coordinate space. */
+  private clampTo(surface: Surface, row: number, col: number): CellPos {
+    const { hit } = this.options;
+    return surface === "chat"
+      ? hit.clampToChat(row, col)
+      : hit.clampToEditor(row, col);
+  }
+
+  /**
+   * Read the selection anchor back from the active surface's store. The
+   * authoritative copy of the chat anchor lives in SideChatMessages
+   * (window-shift translation moves it mid-drag), so the module reads it back
+   * instead of hoarding a private copy; the editor anchor needs no shift.
+   */
+  private selectionAnchor(surface: Surface): CellPos {
+    const { hit } = this.options;
+    const anchor =
+      surface === "chat"
+        ? hit.getSelectionAnchor()
+        : hit.getEditorSelectionAnchor();
+    return anchor ?? this.mouseAnchor;
+  }
+
+  /** True when the active surface holds a non-empty selection. */
+  private hasSelection(surface: Surface): boolean {
+    return surface === "chat"
+      ? this.options.hit.hasSelection()
+      : this.options.hit.hasEditorSelection();
+  }
+
   /** Classify one SGR mouse event and return the actions it produces. */
   onEvent(event: SgrMouseEvent): GestureAction[] {
-    const { hit, rightClickEnabled, wheelScrollLines } = this.options;
+    const {
+      hit,
+      rightClickEnabled,
+      editorSelectionEnabled,
+      wheelScrollLines,
+    } = this.options;
 
     if (isWheelEvent(event)) {
       return [
@@ -139,67 +215,103 @@ export class PointerGesture {
     }
 
     if (isLeftPress(event)) {
-      const pos = hit.chatAt(event.row - 1, event.col - 1);
-      if (!pos) return [];
+      const row = event.row - 1;
+      const col = event.col - 1;
+      const chatPos = hit.chatAt(row, col);
+      let surface: Surface;
+      let pos: CellPos;
+      if (chatPos) {
+        surface = "chat";
+        pos = chatPos;
+      } else if (editorSelectionEnabled) {
+        const editorPos = hit.editorAt(row, col);
+        if (!editorPos) return [];
+        surface = "editor";
+        pos = editorPos;
+      } else {
+        return [];
+      }
       const now = this.options.now();
-      const doubleClick =
+      // Consecutive-click classification (spec #24/#26): the click count
+      // advances only when this press lands on the same surface, within the
+      // double-click window and tolerance, and the previous release was not a
+      // drag. Any of those failing resets the count to a fresh single click.
+      const isMultiClick =
         this.lastPressPos !== null &&
+        this.lastPressSurface === surface &&
         !this.lastReleaseWasDrag &&
         now - this.lastPressTime <= DOUBLE_CLICK_INTERVAL_MS &&
         Math.abs(pos.line - this.lastPressPos.line) <= 1 &&
         Math.abs(pos.col - this.lastPressPos.col) <= 2;
+      this.clickCount = isMultiClick ? Math.min(this.clickCount + 1, 3) : 1;
       this.dragging = true;
+      this.surface = surface;
       this.mouseAnchor = pos;
       this.lastPressPos = pos;
+      this.lastPressSurface = surface;
       this.lastPressTime = now;
-      this.pendingDoubleClick = doubleClick;
       // Seed the selection with the anchor (empty range): the window-shift
       // translation in SideChatMessages.render then keeps the anchor aligned
       // with the same content when status/stream lines are appended mid-drag.
-      return [{ kind: "select", anchor: pos, focus: pos, paint: true }];
+      return [{ kind: "select", surface, anchor: pos, focus: pos, paint: true }];
     }
 
     if (isLeftDrag(event)) {
       if (!this.dragging) return [];
-      const pos = hit.clampToChat(event.row - 1, event.col - 1);
-      const anchor = hit.getSelectionAnchor() ?? this.mouseAnchor;
+      const surface = this.surface ?? "chat";
+      const pos = this.clampTo(surface, event.row - 1, event.col - 1);
+      const anchor = this.selectionAnchor(surface);
       // Coalesce drag paints: the selection state is always current (the next
       // render picks it up), only the number of full-frame redraws is capped.
       const now = this.options.now();
       const paint = now - this.lastDragRenderAt >= DRAG_RENDER_INTERVAL_MS;
       if (paint) this.lastDragRenderAt = now;
-      return [{ kind: "select", anchor, focus: pos, paint }];
+      return [{ kind: "select", surface, anchor, focus: pos, paint }];
     }
 
     if (isLeftRelease(event)) {
       if (!this.dragging) return [];
       this.dragging = false;
-      if (this.pendingDoubleClick) {
-        // Double-click: select the whole rendered line (no auto-copy; the
-        // hotkey copies it).
-        this.pendingDoubleClick = false;
+      const surface = this.surface ?? "chat";
+      const clickCount = this.clickCount;
+      const pos = this.clampTo(surface, event.row - 1, event.col - 1);
+
+      if (clickCount === 2) {
+        // Double-click (no auto-copy; the hotkey copies it): chat selects the
+        // whole rendered line, the editor selects the word under the click
+        // (word bounds resolved by the overlay from its own geometry).
         this.lastReleaseWasDrag = false;
-        const pos = hit.clampToChat(event.row - 1, event.col - 1);
-        return [{ kind: "selectLine", line: pos.line }];
+        if (surface === "editor") {
+          return [
+            { kind: "selectWord", surface, line: pos.line, col: pos.col },
+          ];
+        }
+        return [{ kind: "selectLine", surface, line: pos.line }];
       }
-      this.pendingDoubleClick = false;
-      const pos = hit.clampToChat(event.row - 1, event.col - 1);
-      if (hit.hasSelection()) {
+
+      if (clickCount === 3) {
+        // Triple-click: select the whole rendered/visual line on both surfaces.
+        this.lastReleaseWasDrag = false;
+        return [{ kind: "selectLine", surface, line: pos.line }];
+      }
+
+      // clickCount === 1: a single press — either finalize a drag or end a click.
+      if (this.hasSelection(surface)) {
         // Drag-release: finalize the selection (the anchor may have been
         // window-shifted by appended status/stream lines mid-drag). The
         // selection stays highlighted so Ctrl+C copies it (hotkey-only copy).
-        const anchor = hit.getSelectionAnchor() ?? this.mouseAnchor;
+        const anchor = this.selectionAnchor(surface);
         // A selection that ends within the double-click tolerance is a click
         // with hand shake, not a drag: real terminals report motion (button 32)
         // even for 1-cell moves, so without this the tiniest movement while
-        // double-clicking marks the release as a drag and the second press is
-        // never classified as a double-click (bug: line-select never fires).
+        // multi-clicking marks the release as a drag and the next press is
+        // never classified as a multi-click (bug: line/word-select never fires).
         this.lastReleaseWasDrag = !selectionWithinClickTolerance(anchor, pos);
-        return [{ kind: "select", anchor, focus: pos, paint: true }];
+        return [{ kind: "select", surface, anchor, focus: pos, paint: true }];
       }
       // Plain click without drag: the press-seeded empty selection (anchor === focus)
-      // is inert (hasSelection() === false, no highlight rendered), so no explicit
-      // clear action is needed; left to be overwritten on the next press/scroll.
+      // is inert (no highlight rendered), so no explicit clear action is needed;
+      // left to be overwritten on the next press/scroll.
       this.lastReleaseWasDrag = false;
       return [];
     }
@@ -230,7 +342,7 @@ export class PointerGesture {
       if (pressInChat) {
         if (hit.chatAt(event.row - 1, event.col - 1) === null) return [];
         if (!hit.hasSelection()) return [];
-        return [{ kind: "copy" }];
+        return [{ kind: "copy", surface: "chat" }];
       }
       if (pressInEditor) {
         if (!hit.overEditor(event.row - 1, event.col - 1)) return [];
@@ -254,8 +366,12 @@ export class PointerGesture {
    */
   cancel(): void {
     this.dragging = false;
+    this.surface = null;
     this.rightPressInChat = false;
     this.rightPressInEditor = false;
-    this.pendingDoubleClick = false;
+    // The next press after an aborted drag is a fresh single click, never a
+    // continuation of a multi-click series.
+    this.clickCount = 1;
+    this.lastReleaseWasDrag = true;
   }
 }

package/srcs/shortcuts.ts

@@ -6,6 +6,17 @@ export const SIDE_CHAT_SHORTCUT: KeyId = "alt+w";
 interface Keybinding {
   readonly keys: readonly KeyId[];
   readonly hint: string;
+  /**
+   * Raw terminal encodings that also trigger this action, besides the
+   * parser-recognizable `keys`. Needed because pi-tui's parser cannot express
+   * alt+shift+letter: its legacy branch only maps ESC+lowercase to alt+letter,
+   * and its modifyOtherKeys parse drops the shift bit. Terminals without the
+   * kitty keyboard protocol (Windows Terminal < 1.25) deliver Alt+Shift+C as
+   * the legacy ESC+'C' form (shift folded into case), which parseKey returns
+   * undefined for — so the binding must match the raw bytes too. Only
+   * copyInput needs this today.
+   */
+  readonly raw?: readonly string[];
 }
 
 /**
@@ -37,7 +48,7 @@ export const KEYBINDINGS = {
   /** Copy the last side-chat assistant message (pi `app.message.copy` parity). */
   copyLastMessage: { keys: ["ctrl+x"], hint: "C+x last" },
   /** Copy all input editor text (expanded paste markers — submit semantics). */
-  copyInput: { keys: ["alt+shift+c"], hint: "A+⇧C all" },
+  copyInput: { keys: ["alt+shift+c"], raw: ["\x1bC", "\x1b[27;3;99~"], hint: "A+⇧C all" },
   /** Paste clipboard text (pi `app.clipboard.pasteImage` parity). */
   paste: { keys: ["ctrl+v", "alt+v"], hint: "C+v paste" },
 } as const satisfies Record<string, Keybinding>;
@@ -46,3 +57,9 @@ export const KEYBINDINGS = {
 export function matchesAnyKey(data: string, keys: readonly KeyId[]): boolean {
   return keys.some((key) => matchesKey(data, key));
 }
+
+/** True when `data` matches a binding's keys or one of its raw encodings. */
+export function matchesKeybinding(data: string, kb: Keybinding): boolean {
+  if (kb.raw?.includes(data)) return true;
+  return matchesAnyKey(data, kb.keys);
+}

package/srcs/side-chat-overlay.ts

@@ -44,6 +44,13 @@ import {
 } from "./clipboard-read.ts";
 import { exportChatHistoryToFile } from "./side-chat-export.ts";
 import { type SgrMouseEvent } from "./side-chat-mouse.ts";
+import {
+  contentBandPlainLines,
+  EditorSelectionState,
+  lineSelection,
+  wordSelection,
+  type EditorPos,
+} from "./editor-selection.ts";
 import {
   PointerGesture,
   type GestureAction,
@@ -62,7 +69,7 @@ import {
   modelKey,
   type ModelChoice,
 } from "./model-switch.ts";
-import { KEYBINDINGS, matchesAnyKey } from "./shortcuts.ts";
+import { KEYBINDINGS, matchesAnyKey, matchesKeybinding } from "./shortcuts.ts";
 import { wrapToolsWithOverlapDetection } from "./tool-wrapper.ts";
 import type { SideChatFeatures } from "./config.ts";
 import type { RetryPolicy } from "./retry.ts";
@@ -171,6 +178,10 @@ export class SideChatOverlay implements Component, Focusable {
   private geometry: ChatGeometry | null = null;
   /** Pointer gesture state machine (spec #13): press/drag/double-click/right-click classification. */
   private gesture: PointerGesture;
+  /** Visual-space selection over the input editor (spec #24, T3). */
+  private editorSelection = new EditorSelectionState();
+  /** Plain (ANSI-stripped) lines of the last editor render's content band. */
+  private editorPlainLines: string[] = [];
   /** Leading messages injected from the main lane at fork time (context cite). */
   private forkedMessageCount: number;
   /** Tool names allowed in the read-only lane (builtins + allowlist + peek_main). */
@@ -217,6 +228,7 @@ export class SideChatOverlay implements Component, Focusable {
   cancelMouseDrag(): void {
     this.gesture.cancel();
     this.messages.clearSelection();
+    this.editorSelection.clear();
   }
 
   /**
@@ -243,16 +255,36 @@ export class SideChatOverlay implements Component, Focusable {
   private applyGestureAction(action: GestureAction): void {
     switch (action.kind) {
       case "select":
-        this.messages.setSelection(action.anchor, action.focus);
+        // Cross-surface exclusion (spec #24): starting a selection on one
+        // surface clears the other, so only one highlight is ever on screen.
+        if (action.surface === "editor") {
+          this.setEditorSelection(action.anchor, action.focus);
+        } else {
+          this.setChatSelection(action.anchor, action.focus);
+        }
         if (action.paint) this.options.tui.requestRender();
         break;
       case "selectLine":
-        // Column bounds come from the overlay's own geometry; the module
-        // only knows the rendered line.
-        this.messages.setSelection(
-          { line: action.line, col: 0 },
-          { line: action.line, col: this.geometry?.innerWidth ?? 0 },
-        );
+        if (action.surface === "editor") {
+          // Column bounds come from the editor's own content band; the module
+          // only knows the rendered line (spec #24/#26).
+          const sel = lineSelection(this.editorPlainLines, action.line);
+          this.setEditorSelection(sel.anchor, sel.focus);
+        } else {
+          // Column bounds come from the overlay's own geometry; the module
+          // only knows the rendered line.
+          this.setChatSelection(
+            { line: action.line, col: 0 },
+            { line: action.line, col: this.geometry?.innerWidth ?? 0 },
+          );
+        }
+        this.options.tui.requestRender();
+        break;
+      case "selectWord":
+        // Editor double-click: word bounds resolved by the overlay from the
+        // editor's own content band (findWordBackward/Forward semantics).
+        const word = wordSelection(this.editorPlainLines, action.line, action.col);
+        this.setEditorSelection(word.anchor, word.focus);
         this.options.tui.requestRender();
         break;
       case "scroll":
@@ -267,6 +299,18 @@ export class SideChatOverlay implements Component, Focusable {
     }
   }
 
+  /** Set the chat selection, clearing the editor selection (cross-surface). */
+  private setChatSelection(anchor: CellPos, focus: CellPos): void {
+    this.messages.setSelection(anchor, focus);
+    this.editorSelection.clear();
+  }
+
+  /** Set the editor selection, clearing the chat selection (cross-surface). */
+  private setEditorSelection(anchor: EditorPos, focus: EditorPos): void {
+    this.editorSelection.setSelection(anchor, focus);
+    this.messages.clearSelection();
+  }
+
   /**
    * Copy the current mouse selection to the clipboard (native → wl-copy /
    * xclip → OSC 52 cascade via {@link copyToClipboard}, matching the main
@@ -287,6 +331,23 @@ export class SideChatOverlay implements Component, Focusable {
     return ok;
   }
 
+  /**
+   * Copy the current editor selection (spec #24, hotkey-only): selected text
+   * from the editor content band, consumed on success so Ctrl+C then falls
+   * back to the clear-input lane; a failed (or empty) copy keeps it for retry.
+   */
+  async copyEditorSelectionToClipboard(): Promise<boolean> {
+    if (!this.editorSelection.hasSelection()) return false;
+    const text = this.editorSelection.selectedText(this.editorPlainLines);
+    if (!text) return false;
+    const ok = await this.copyTextWithFeedback(text);
+    if (ok) {
+      this.editorSelection.clear();
+      this.options.tui.requestRender();
+    }
+    return ok;
+  }
+
   /**
    * Copy text to the system clipboard and surface the outcome: a success
    * flash on the status line (labelled by `hint`) or an error line on
@@ -348,6 +409,7 @@ export class SideChatOverlay implements Component, Focusable {
     }
     // Bracketed paste is the only paste entry the Editor exposes (handlePaste
     // is private); the same sequences a native terminal paste produces.
+    this.editorSelection.clear();
     this.editor.handleInput(`\x1b[200~${outcome.text}\x1b[201~`);
     this.options.tui.requestRender();
   }
@@ -380,6 +442,32 @@ export class SideChatOverlay implements Component, Focusable {
     return { line, col: c };
   }
 
+  /**
+   * Map 0-based screen coords to an editor visual cell, or null off the
+   * editor content band (the `Editor.render()` lines between the top and
+   * bottom borders). The top border row is `editorTopRow`, so content-band
+   * line 0 is the next screen row down.
+   */
+  private screenToEditor(row: number, col: number): EditorPos | null {
+    const g = this.geometry;
+    if (!g) return null;
+    const line = row - (g.editorTopRow + 1);
+    const c = col - g.contentCol;
+    if (line < 0 || line >= g.editorHeight - 2 || c < 0 || c >= g.innerWidth)
+      return null;
+    return { line, col: c };
+  }
+
+  /** Like {@link screenToEditor} but clamps into the editor content band (drag overshoot). */
+  private clampScreenToEditor(row: number, col: number): EditorPos {
+    const g = this.geometry;
+    if (!g) return { line: 0, col: 0 };
+    const maxLine = Math.max(0, g.editorHeight - 3);
+    const line = Math.max(0, Math.min(row - (g.editorTopRow + 1), maxLine));
+    const c = Math.max(0, Math.min(col - g.contentCol, Math.max(0, g.innerWidth - 1)));
+    return { line, col: c };
+  }
+
   get focused() {
     return this._focused;
   }
@@ -464,11 +552,25 @@ export class SideChatOverlay implements Component, Focusable {
         chatAt: (row, col) => this.screenToChat(row, col),
         clampToChat: (row, col) => this.clampScreenToChat(row, col),
         overEditor: (row, _col) => this.isOverEditor(row),
+        // Editor surface (spec #24/#26): real hit-testing / selection store.
+        // While the autocomplete popup is open the editor-drag branch is
+        // disabled (row-index drift — ADR 0006), so editorAt reports null and
+        // left presses fall through to a no-op.
+        editorAt: (row, col) =>
+          this.editor.isShowingAutocomplete()
+            ? null
+            : this.screenToEditor(row, col),
+        clampToEditor: (row, col) => this.clampScreenToEditor(row, col),
+        hasEditorSelection: () => this.editorSelection.hasSelection(),
+        getEditorSelectionAnchor: () => this.editorSelection.getAnchor(),
         hasSelection: () => this.messages.hasSelection(),
         getSelectionAnchor: () => this.messages.getSelectionAnchor(),
       },
       // D11: the feature switch gates right-click copy/paste at the module.
       rightClickEnabled: this.options.features.rightClickCopyPaste,
+      // Editor-selection gate (spec #24): off → left-drag never classifies
+      // onto the editor surface; right-click paste is unaffected.
+      editorSelectionEnabled: this.options.features.editorSelection,
     });
 
     // The runner (fork-turn.ts, issue #9) owns the fork agent and the whole
@@ -678,6 +780,7 @@ export class SideChatOverlay implements Component, Focusable {
     this.refreshFramingModel();
 
     this.editor.setText("");
+    this.editorSelection.clear();
     this.streamingContent = "";
     // A new user message resumes bottom-following even if the view was frozen.
     this.messages.resumeFollowing();
@@ -848,6 +951,13 @@ export class SideChatOverlay implements Component, Focusable {
     for (let i = msgLines.length; i < maxLines; i++) msgLines.push("");
 
     const editorLines = this.editor.render(innerWidth);
+    // Editor selection (spec #24): hit-testing / copy resolve against the
+    // content band (top/bottom borders dropped, ANSI stripped), and the
+    // highlight is injected by post-processing the rendered lines. The plain
+    // lines are cached here so mouse actions between renders see the same
+    // band the frame was drawn from.
+    this.editorPlainLines = contentBandPlainLines(editorLines);
+    const decoratedEditorLines = this.editorSelection.decorate(editorLines);
     const lines = renderSideChatFrame({
       width,
       theme,
@@ -855,7 +965,7 @@ export class SideChatOverlay implements Component, Focusable {
       headerLeft: left,
       headerRight: status,
       msgLines,
-      editorLines,
+      editorLines: decoratedEditorLines,
       hints: hintLines,
     });
     this.lastRenderHeight = lines.length;
@@ -863,7 +973,7 @@ export class SideChatOverlay implements Component, Focusable {
       this.options.tui.terminal.columns,
       this.options.tui.terminal.rows,
       msgLines.length,
-      editorLines.length,
+      decoratedEditorLines.length,
     );
     return lines;
   }
@@ -910,11 +1020,13 @@ export class SideChatOverlay implements Component, Focusable {
       this.openModelPicker();
       return;
     }
-    if (matchesAnyKey(data, KEYBINDINGS.copyInput.keys)) {
+    if (matchesKeybinding(data, KEYBINDINGS.copyInput)) {
       // Copy the whole input editor text (issue #23): expanded paste
       // markers — exactly what a submit would send. Read-only, unlike
       // Ctrl+C's clear lane it never touches the draft; an empty input
-      // flashes a hint instead of copying.
+      // flashes a hint instead of copying. `matchesKeybinding` also accepts
+      // the raw legacy ESC+C form that terminals without the kitty protocol
+      // (Windows Terminal < 1.25) deliver for Alt+Shift+C.
       const text = this.editor.getExpandedText();
       if (!text) {
         this.status.flash(INPUT_EMPTY_STATUS, COPIED_STATUS_CLEAR_MS);
@@ -924,15 +1036,23 @@ export class SideChatOverlay implements Component, Focusable {
       return;
     }
     if (matchesAnyKey(data, KEYBINDINGS.copySelection.keys)) {
-      // Hotkey copy: with an active mouse selection, Ctrl+C / Ctrl+Shift+C
-      // copies it. Without one, Ctrl+C clears the input box (pi `app.clear`
-      // parity, spec #22); Ctrl+Shift+C falls through — pi binds no such
-      // key, so it stays a forced copy (terminal habit).
+      // Hotkey copy (spec #24): three-tier routing — chat selection first,
+      // then editor selection, then the legacy clear-input lane. Copying the
+      // editor selection consumes it so Ctrl+C then returns to clearing the
+      // input; a failed copy keeps it for retry. Bare Ctrl+C with no
+      // selection clears the input box (pi `app.clear` parity, spec #22);
+      // Ctrl+Shift+C falls through — pi binds no such key, so it stays a
+      // forced copy (terminal habit).
       if (this.messages.hasSelection()) {
         void this.copySelectionToClipboard();
         return;
       }
+      if (this.editorSelection.hasSelection()) {
+        void this.copyEditorSelectionToClipboard();
+        return;
+      }
       if (matchesKey(data, KEYBINDINGS.copySelection.keys[0])) {
+        this.editorSelection.clear();
         this.editor.setText("");
         this.options.tui.requestRender();
         return;
@@ -975,6 +1095,11 @@ export class SideChatOverlay implements Component, Focusable {
       this.options.tui.requestRender();
       return;
     }
+    // Any non-drag editor input (typing, cursor movement) clears the editor
+    // selection — transient by design (spec #24). The clear happens before
+    // the editor consumes the input so the next render never shows a stale
+    // highlight next to the moved cursor.
+    this.editorSelection.clear();
     this.editor.handleInput(data);
     this.options.tui.requestRender();
   }
@@ -989,6 +1114,11 @@ export class SideChatOverlay implements Component, Focusable {
     if (this.modelPicker) return;
     // Feature switch (D11): Ctrl+L is inert when model switching is off.
     if (!this.options.features.modelSwitch) return;
+    // Editor selection is transient: opening the picker clears it and aborts
+    // any in-flight editor drag, so the modal's mouse surface starts clean
+    // (spec #24).
+    this.gesture.cancel();
+    this.editorSelection.clear();
     if (this.runner.isRunning) {
       this.status.setSteady("feedback", {
         text: () => "Model switch unavailable while streaming",
@@ -1124,6 +1254,7 @@ export class SideChatOverlay implements Component, Focusable {
     // phase would do it, but handlePhase is a no-op once disposed).
     this.status.reset();
     this.runner.cancel();
+    this.editorSelection.clear();
     const messages = [...this.runner.agent.state.messages];
     this.options.onClose(action, messages);
   }