tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/tui/mirror/menu-model.ts

@@ -16,7 +16,7 @@
 /** The surfaces a right-click can target. Each maps to a fixed item list; the
  *  concrete payload (session name, file path, pane id) rides in the app's menu
  *  state, not here. */
-export type MenuRegion = "session" | "file" | "difffile" | "pane" | "window";
+export type MenuRegion = "session" | "agent" | "file" | "difffile" | "pane" | "window";
 
 /** One menu entry. `id` is what the app dispatches on; `danger` items rearm to
  *  a "confirm: y" state instead of firing immediately; `input` items open an
@@ -36,9 +36,21 @@ export interface MenuItem {
 export const MENU_ITEMS: Record<MenuRegion, MenuItem[]> = {
   session: [
     { id: "attach", label: "Attach" },
+    { id: "new-agent", label: "New agent…" },
     { id: "rename", label: "Rename", input: "rename to" },
     { id: "kill", label: "Kill session", danger: true },
   ],
+  // Sidebar AGENT rows (M23.1): a left-click jumps; the context menu carries
+  // the lifecycle verbs. "Stop agent" only interrupts (the pane survives);
+  // "Close pane" is the destructive twin that also kills the pane. restart/
+  // stop confirm via DialogConfirm in the app (plain-language body), so only
+  // close — where there is no dialog — uses the inline confirm rearm.
+  agent: [
+    { id: "jump", label: "Go to agent" },
+    { id: "restart", label: "Restart agent" },
+    { id: "stop", label: "Stop agent" },
+    { id: "close", label: "Close pane", danger: true },
+  ],
   file: [
     { id: "open", label: "Open" },
     { id: "newfile", label: "New file", input: "new file" },
@@ -81,13 +93,24 @@ export const MENU_ITEMS: Record<MenuRegion, MenuItem[]> = {
  *  panes (the app turned mouse reporting on — presses are forwarded, so a drag
  *  can't start a selection) get a leading "Select text…" verb that pauses
  *  forwarding for that pane; while its select mode is active the entry flips to
- *  the exit verb. Ordinary panes keep the fixed list untouched. */
-export function paneMenuItems(appMouse: boolean, selectModeOn: boolean): MenuItem[] {
+ *  the exit verb. They also get the drag-default toggle (M24.2): the label is
+ *  always the OTHER default (`dragDefault` is the pane's current one, override
+ *  and config applied), so picking it flips the pane for the session. Ordinary
+ *  panes keep the fixed list untouched. */
+export function paneMenuItems(
+  appMouse: boolean,
+  selectModeOn: boolean,
+  dragDefault: "select" | "forward",
+): MenuItem[] {
   if (!appMouse) return MENU_ITEMS.pane;
   const entry: MenuItem = selectModeOn
     ? { id: "select-text-off", label: "Stop selecting" }
     : { id: "select-text", label: "Select text…" };
-  return [entry, ...MENU_ITEMS.pane];
+  const dragToggle: MenuItem =
+    dragDefault === "select"
+      ? { id: "drag-forward", label: "Forward mouse drags" }
+      : { id: "drag-select", label: "Select on drag" };
+  return [entry, dragToggle, ...MENU_ITEMS.pane];
 }
 
 /** The overlay's border (1) + horizontal padding (1 each side). The header row

package/packages/daemon/src/tui/mirror/palette.ts

@@ -12,7 +12,7 @@
  * to the top when the query looks like a path.
  */
 import { fuzzyFilter } from "../team/fuzzy.ts";
-import type { Tab } from "./app-state.ts";
+import type { PaletteUsageEntry, Tab } from "./app-state.ts";
 import type { AgentRowInput } from "./agent-rows.ts";
 import { SETTINGS_PALETTE_COMMANDS, type SettingsCommandId } from "./settings-model.ts";
 
@@ -23,10 +23,26 @@ export type PaletteAction =
   | { kind: "open-folder"; label: string }
   | { kind: "attach"; session: string; label: string }
   | { kind: "jump-agent"; paneId: string; session: string; windowIndex: number; label: string }
+  // The lifecycle verbs (M23.1) — `agentKind` (not `kind`, taken by the action
+  // discriminant) is the manifest id the restart flow resolves a launch
+  // command from. Each fleet agent gets one restart + one stop row; "New
+  // agent…" opens the spawn flow (kind → placement → run) on the dialog stack.
+  | { kind: "new-agent"; label: string }
+  // Repeat the current context's remembered spawn directly — no dialog (M24.1).
+  | { kind: "new-agent-again"; label: string }
+  // The one-surface team console (M24.1): jump/restart/stop + "+ new agent".
+  | { kind: "manage-team"; label: string }
+  | { kind: "restart-agent"; paneId: string; agentKind: string; session: string; label: string }
+  | { kind: "stop-agent"; paneId: string; agentKind: string; session: string; label: string }
   | { kind: "open-file"; path: string; label: string }
+  // "Go to file:" (M24.6) — one row per fuzzy-matched REPO file (workspace-
+  // relative, ignore-respecting, fed by the app via ctx.repoFiles), unlike
+  // open-file whose path is whatever the user typed.
+  | { kind: "go-file"; path: string; label: string }
   | { kind: "save"; label: string }
   | { kind: "refresh-diff"; label: string }
   | { kind: "paste-buffer"; label: string }
+  | { kind: "search-scrollback"; label: string }
   | { kind: "new-window"; label: string }
   | { kind: "rename-window"; name: string; label: string }
   | { kind: "kill-window"; label: string }
@@ -69,6 +85,27 @@ export interface PaletteContext {
    *  "Select text in pane" offered (ordinary panes drag-select directly, so the
    *  action would be a no-op that clutters the list). */
   appMousePane?: boolean;
+  /** What the current context's remembered spawn is called (`claude`, a custom
+   *  argv, …) — when set, a direct "New agent: <name> (again)" action is PINNED
+   *  FIRST, so a repeat spawn is F5 → Enter (M24.1's ≤2-Enters bar). */
+  againName?: string | null;
+  /** Palette usage history (M24.4) keyed by {@link paletteActionKey}: drives
+   *  the empty-query "recent" group and the frequency/recency tie-break on a
+   *  typed query. Persisted in app-state. */
+  usage?: Readonly<Record<string, PaletteUsageEntry>>;
+  /** The active surface tab (M24.4) — steers the empty-query "suggested"
+   *  group (Terminal → window/pane verbs + the again spawn; Files → save +
+   *  open-folder). `terminal` above stays THE gate for the window/pane verbs
+   *  so existing callers/tests are untouched. */
+  surface?: Tab;
+  /** Action key → keycap ({@link ../mirror/settings-model.ts}'s
+   *  PALETTE_KEYCAPS) — rows whose action has one right-align it (M24.4).
+   *  app.tsx drops `quit` in HOSTED mode, where ^q detaches instead. */
+  keycaps?: Readonly<Record<string, string>>;
+  /** The workspace's file list (M24.6) — repo-relative paths, gitignore-
+   *  respecting, capped by the caller. A non-empty query offers fuzzy-matched
+   *  "Go to file: <path>" rows via {@link goToFileActions}. */
+  repoFiles?: readonly string[];
 }
 
 const TAB_LABELS: { tab: Tab; label: string }[] = [
@@ -85,14 +122,24 @@ export function staticPaletteActions(
   sessions: string[],
   ctx: PaletteContext = {},
 ): PaletteAction[] {
-  const actions: PaletteAction[] = TAB_LABELS.map((t) => ({
-    kind: "tab" as const,
-    tab: t.tab,
-    label: t.label,
-  }));
+  const actions: PaletteAction[] = [];
+  // The repeat spawn (M24.1) — FIRST, above everything: with memory for the
+  // current context, an empty-query Enter repeats the last spawn, making
+  // F5 → Enter the whole gesture (the card's ≤2-Enters acceptance bar).
+  if (ctx.againName) {
+    actions.push({ kind: "new-agent-again", label: `New agent: ${ctx.againName} (again)` });
+  }
+  for (const t of TAB_LABELS) actions.push({ kind: "tab", tab: t.tab, label: t.label });
   // The non-technicals' front door (M22.5): a filesystem picker → create-or-
   // attach a session in the chosen folder. Offered on every surface.
   actions.push({ kind: "open-folder", label: "Open folder…" });
+  // Spawn an agent (M23.1/M24.1) — offered on every surface; ONE dialog whose
+  // default placement is contextual (split beside a focused pane, else a new
+  // window in the session, else a fresh session).
+  actions.push({ kind: "new-agent", label: "New agent…" });
+  // The team console (M24.1): every fleet agent in one dialog — jump, restart,
+  // stop, spawn. The sidebar agents-header click's keyboard twin.
+  actions.push({ kind: "manage-team", label: "Manage team…" });
   for (const s of sessions) {
     actions.push({ kind: "attach", session: s, label: `Attach session: ${s}` });
   }
@@ -108,6 +155,25 @@ export function staticPaletteActions(
       label: `Agent: ${a.kind} · ${a.session} (${a.state})`,
     });
   }
+  // The per-agent lifecycle verbs (M23.1), grouped after the jumps so an empty
+  // query reads jump-first; the fuzzy filter finds "restart"/"stop" directly.
+  for (const a of ctx.agents ?? []) {
+    const who = `${a.kind} · ${a.session}`;
+    actions.push({
+      kind: "restart-agent",
+      paneId: a.paneId,
+      agentKind: a.kind,
+      session: a.session,
+      label: `Restart agent: ${who}`,
+    });
+    actions.push({
+      kind: "stop-agent",
+      paneId: a.paneId,
+      agentKind: a.kind,
+      session: a.session,
+      label: `Stop agent: ${who}`,
+    });
+  }
   actions.push({ kind: "save", label: "Save file" });
   actions.push({ kind: "refresh-diff", label: "Refresh diff" });
   // Paste target is the focused surface (a pane, or the editor buffer), so this
@@ -120,6 +186,10 @@ export function staticPaletteActions(
     actions.push({ kind: "settings", id: c.id, label: c.label });
   }
   if (ctx.terminal) {
+    // `/` only opens search while scrolled into history (at the live prompt it
+    // belongs to the pane — agents' slash commands); this is the always-there
+    // entry.
+    actions.push({ kind: "search-scrollback", label: "Search scrollback" });
     actions.push({ kind: "new-window", label: "New window" });
     actions.push({ kind: "kill-window", label: "Kill window" });
     actions.push({ kind: "zoom-pane", label: "Zoom pane" });
@@ -246,9 +316,76 @@ function looksLikePath(q: string): boolean {
   return /[/.~]/.test(q);
 }
 
+/** Cap on "Go to file:" rows so a big repo never floods the palette. */
+export const GO_FILE_CAP = 8;
+
+/**
+ * PURE (M24.6) — the dynamic "Go to file:" rows for `query`: the repo's
+ * (ignore-respecting) file list fuzzy-filtered against the query, one open
+ * action per match, capped at `cap`. An empty query offers none — the static
+ * list stays uncluttered. Strictly ADDITIVE to the palette: this only CALLS
+ * the shared fuzzy filter, and its rows are appended after the existing
+ * results (see {@link filterPaletteActions}).
+ */
+export function goToFileActions(
+  query: string,
+  repoFiles: readonly string[],
+  cap: number = GO_FILE_CAP,
+): PaletteAction[] {
+  const q = query.trim();
+  if (q.length === 0 || repoFiles.length === 0) return [];
+  return fuzzyFilter(q, [...repoFiles], (p) => p)
+    .slice(0, cap)
+    .map((m) => ({ kind: "go-file" as const, path: m.item, label: `Go to file: ${m.item}` }));
+}
+
+/**
+ * PURE — the STABLE identity of an action for usage history (M24.4): the kind
+ * plus the payload fields that survive restarts (session/layout/settings id/
+ * path — NOT the label, so relabeling never orphans history, and NOT pane ids,
+ * which tmux renumbers). Kinds without a stable payload are keyed by kind
+ * alone (rename-window's typed name is query-dependent, not identity).
+ */
+export function paletteActionKey(a: PaletteAction): string {
+  switch (a.kind) {
+    case "tab":
+      return `tab:${a.tab}`;
+    case "attach":
+      return `attach:${a.session}`;
+    case "jump-agent":
+      return `jump-agent:${a.session}`;
+    case "restart-agent":
+      return `restart-agent:${a.session}:${a.agentKind}`;
+    case "stop-agent":
+      return `stop-agent:${a.session}:${a.agentKind}`;
+    case "select-layout":
+      return `select-layout:${a.layout}`;
+    case "settings":
+      return `settings:${a.id}`;
+    case "open-file":
+      return `open-file:${a.path}`;
+    default:
+      return a.kind;
+  }
+}
+
+/** PURE — the usage comparator (frequency first, then recency): negative when
+ *  `a` should rank before `b`. Unused actions rank last, mutually tied. */
+function compareUsage(
+  a: PaletteAction,
+  b: PaletteAction,
+  usage: Readonly<Record<string, PaletteUsageEntry>> | undefined,
+): number {
+  const ua = usage?.[paletteActionKey(a)];
+  const ub = usage?.[paletteActionKey(b)];
+  return (ub?.count ?? 0) - (ua?.count ?? 0) || (ub?.lastUsed ?? 0) - (ua?.lastUsed ?? 0);
+}
+
 /**
  * PURE — the palette result list for `query`: the static actions fuzzy-filtered
- * and score-sorted, plus (when the query is non-empty) a dynamic
+ * and score-sorted (exact/prefix matches outrank mid-word via the scorer's
+ * label-start weighting; score TIES break by usage — frequency then recency —
+ * M24.4), plus (when the query is non-empty) a dynamic
  * "Open file: <query>" action. That open-file entry is pinned FIRST when the
  * query looks like a path, otherwise appended LAST so it never buries a real
  * match. An empty query returns every static action in natural order.
@@ -261,7 +398,11 @@ export function filterPaletteActions(
   const statics = staticPaletteActions(sessions, ctx);
   const q = query.trim();
   const matched =
-    q.length === 0 ? statics : fuzzyFilter(query, statics, (a) => a.label).map((m) => m.item);
+    q.length === 0
+      ? statics
+      : fuzzyFilter(query, statics, (a) => a.label)
+          .sort((x, y) => y.score - x.score || compareUsage(x.item, y.item, ctx.usage))
+          .map((m) => m.item);
   if (q.length === 0) return matched;
   const dynamic: PaletteAction[] = [{ kind: "open-file", path: q, label: `Open file: ${q}` }];
   // On the Terminal surface a non-empty query also offers a rename-to-<query>
@@ -270,5 +411,154 @@ export function filterPaletteActions(
   if (ctx.terminal) {
     dynamic.push({ kind: "rename-window", name: q, label: `Rename window: ${q}` });
   }
-  return looksLikePath(q) ? [...dynamic, ...matched] : [...matched, ...dynamic];
+  // "Go to file:" rows (M24.6) are APPENDED after everything so this addition
+  // cannot disturb the existing result ranking.
+  const goFiles = goToFileActions(q, ctx.repoFiles ?? []);
+  return looksLikePath(q)
+    ? [...dynamic, ...matched, ...goFiles]
+    : [...matched, ...dynamic, ...goFiles];
+}
+
+// ── Grouped rows (M24.4 — the palette's list model) ─────────────────────────
+// The overlay renders ROWS, not bare actions: on an EMPTY query the list opens
+// with a "recent" group (top used actions), a contextual "suggested" group,
+// then everything else under "commands"; a typed query is one flat ranked list
+// (no headers). Headers are real rows — they occupy a screen line, scroll with
+// the list, and are NOT selectable/clickable — so the selection helpers below
+// are what the keyboard/router use to move between action rows.
+
+/** One rendered palette line: a group header, or an action with its optional
+ *  right-aligned keycap (from ctx.keycaps). */
+export type PaletteRow =
+  | { type: "header"; label: string }
+  | { type: "action"; action: PaletteAction; shortcut: string | null };
+
+/** How many actions the empty-query "recent" group shows at most. */
+export const PALETTE_RECENT_LIMIT = 5;
+
+/** The Terminal surface's suggested window/pane verbs, in offer order. */
+const TERMINAL_SUGGESTED_KINDS: ReadonlyArray<PaletteAction["kind"]> = [
+  "new-window",
+  "kill-window",
+  "zoom-pane",
+  "swap-pane",
+  "break-pane",
+  "rotate-window",
+];
+
+/**
+ * PURE — the palette rows for `query` (M24.4). A non-empty query is the flat
+ * {@link filterPaletteActions} ranking. An empty query groups:
+ *   1. "recent" — up to {@link PALETTE_RECENT_LIMIT} previously-run actions
+ *      still offerable now (usage keys matched against the current statics),
+ *      most-frequently-used first, recency breaking ties;
+ *   2. "suggested" — BLOCKED agents' jump actions first (ctx.agents arrives
+ *      attention-sorted, so their relative order is the sidebar's), then the
+ *      surface's verbs: Terminal → the again-spawn + window/pane verbs, Files
+ *      → save + open-folder;
+ *   3. "commands" — every remaining action in today's natural order.
+ * With nothing to group (no usage, no suggestions) the list is exactly the
+ * ungrouped statics — no headers, same as before this card.
+ */
+export function paletteRows(
+  query: string,
+  sessions: string[],
+  ctx: PaletteContext = {},
+): PaletteRow[] {
+  const row = (action: PaletteAction): PaletteRow => ({
+    type: "action",
+    action,
+    shortcut: ctx.keycaps?.[paletteActionKey(action)] ?? null,
+  });
+  if (query.trim().length > 0) return filterPaletteActions(query, sessions, ctx).map(row);
+
+  const statics = staticPaletteActions(sessions, ctx);
+  // First static per key — recents resolve through this so a persisted key
+  // finds the action's CURRENT incarnation (relabels don't orphan history).
+  const byKey = new Map<string, PaletteAction>();
+  for (const a of statics) {
+    const k = paletteActionKey(a);
+    if (!byKey.has(k)) byKey.set(k, a);
+  }
+  const taken = new Set<PaletteAction>();
+
+  const recent: PaletteAction[] = [];
+  const usedKeys = Object.entries(ctx.usage ?? {})
+    .sort(([, a], [, b]) => b.count - a.count || b.lastUsed - a.lastUsed)
+    .map(([k]) => k);
+  for (const k of usedKeys) {
+    if (recent.length >= PALETTE_RECENT_LIMIT) break;
+    const a = byKey.get(k);
+    if (a && !taken.has(a)) {
+      recent.push(a);
+      taken.add(a);
+    }
+  }
+
+  const suggested: PaletteAction[] = [];
+  const suggest = (pred: (a: PaletteAction) => boolean): void => {
+    for (const a of statics) {
+      if (!taken.has(a) && pred(a)) {
+        suggested.push(a);
+        taken.add(a);
+      }
+    }
+  };
+  // Blocked agents outrank every other suggestion — they are why the user is
+  // opening the palette (the sidebar's attention-first law, applied here).
+  const blockedPanes = new Set(
+    (ctx.agents ?? []).filter((x) => x.state === "blocked").map((x) => x.paneId),
+  );
+  suggest((a) => a.kind === "jump-agent" && blockedPanes.has(a.paneId));
+  if (ctx.surface === "terminal") {
+    suggest((a) => a.kind === "new-agent-again");
+    suggest((a) => TERMINAL_SUGGESTED_KINDS.includes(a.kind));
+  } else if (ctx.surface === "files") {
+    suggest((a) => a.kind === "save" || a.kind === "open-folder");
+  }
+
+  if (recent.length === 0 && suggested.length === 0) return statics.map(row);
+  const rows: PaletteRow[] = [];
+  if (recent.length > 0) {
+    rows.push({ type: "header", label: "recent" });
+    for (const a of recent) rows.push(row(a));
+  }
+  if (suggested.length > 0) {
+    rows.push({ type: "header", label: "suggested" });
+    for (const a of suggested) rows.push(row(a));
+  }
+  rows.push({ type: "header", label: "commands" });
+  for (const a of statics) if (!taken.has(a)) rows.push(row(a));
+  return rows;
+}
+
+/** PURE — the first selectable (action) row index, or -1 when none. Where the
+ *  selection starts on open/query edits (headers are never selected). */
+export function firstPaletteAction(rows: readonly PaletteRow[]): number {
+  return rows.findIndex((r) => r.type === "action");
+}
+
+/** PURE — the next action row from `cur` in `dir` (±1), skipping headers;
+ *  stays put at the list's ends. The keyboard's up/down. */
+export function stepPaletteRow(rows: readonly PaletteRow[], cur: number, dir: 1 | -1): number {
+  for (let i = cur + dir; i >= 0 && i < rows.length; i += dir) {
+    if (rows[i]!.type === "action") return i;
+  }
+  return cur;
+}
+
+/**
+ * PURE — one action row's text after the selection prefix: the label, then —
+ * when the row has a keycap — right-aligned padding + the keycap inside
+ * `width` cells. The label truncates with an ellipsis so the keycap ALWAYS
+ * fits (min one space between); without a keycap the label just truncates.
+ */
+export function paletteRowText(label: string, shortcut: string | null, width: number): string {
+  if (width <= 0) return "";
+  if (!shortcut || shortcut.length + 2 > width) {
+    return label.length <= width ? label : label.slice(0, Math.max(0, width - 1)) + "…";
+  }
+  const labelMax = width - shortcut.length - 1;
+  const shown = label.length <= labelMax ? label : label.slice(0, Math.max(0, labelMax - 1)) + "…";
+  return shown + " ".repeat(width - shown.length - shortcut.length) + shortcut;
 }

package/packages/daemon/src/tui/mirror/pane-mirror.ts

@@ -40,6 +40,7 @@ import {
   type GraphemeOverride,
 } from "./blit.ts";
 import { AckWriter } from "./ack-writer.ts";
+import { extractSelection, type Cell } from "./selection.ts";
 
 /** OpenTUI TextAttributes bit values (kept literal to avoid the dep here). */
 const ATTR_BOLD = 1;
@@ -163,6 +164,18 @@ export class PaneMirror {
    *  fast path. Counted from xterm's onScroll (which fires once per scrolled
    *  line and keeps firing at the scrollback cap, unlike the saturating payload). */
   private _pendingScroll = 0;
+  // ── Absolute-line stability (M25.6) ────────────────────────────────────────
+  /** Lines TRIMMED off the top of the scrollback (monotonic): once viewportY
+   *  saturates at the scrollback cap, each further scroll rotates one line out
+   *  and every retained line's absolute index drops by one. An absolute-space
+   *  consumer (the drag selection) records `lineTrim()` when it anchors and
+   *  subtracts the delta later, so its anchor keeps naming the same content.
+   *  Detected as "onScroll fired but viewportY did not grow". A scrollback
+   *  clear (`clear-history` / ED3) collapses viewportY instead — that index
+   *  shift is NOT counted; stale absolute cells then clamp into the buffer
+   *  (the selection was over content that no longer exists anyway). */
+  private _trimmed = 0;
+  private _lastViewportY = 0;
   /** The alt/normal buffer swapped (`?1049h/l`) — the whole grid is new. */
   private _bufferSwapped = false;
   /** Shadow of the last-blitted rows' raw xterm cell data (`_line._data`,
@@ -175,12 +188,19 @@ export class PaneMirror {
    *  incremental. */
   private _incremental = true;
 
-  constructor(cols: number, rows: number) {
+  constructor(cols: number, rows: number, scrollback = 5000) {
     this.cols = cols;
     this.rows = rows;
-    this.term = new Terminal({ cols, rows, allowProposedApi: true, scrollback: 5000 });
+    this.term = new Terminal({ cols, rows, allowProposedApi: true, scrollback });
     this.term.onWriteParsed(() => this._version++);
-    this.term.onScroll(() => this._pendingScroll++);
+    this.term.onScroll(() => {
+      this._pendingScroll++;
+      // Trim detection (M25.6): below the cap each scroll grows viewportY by
+      // one; at the cap it stays put and the oldest line rotated out.
+      const vy = this.term.buffer.active.viewportY;
+      if (vy === this._lastViewportY) this._trimmed++;
+      else this._lastViewportY = vy;
+    });
     this.term.buffer.onBufferChange(() => {
       this._bufferSwapped = true;
       this._version++;
@@ -234,9 +254,20 @@ export class PaneMirror {
     this._shadow = null;
     this._pendingScroll = 0;
     this._bufferSwapped = false;
+    // Reflow moved viewportY without scrolls — re-baseline the trim detector so
+    // the first post-resize scroll isn't miscounted as a cap rotation. (Reflow
+    // also re-indexes wrapped lines; a mid-resize drag selection is approximate
+    // by nature and clamps safely.)
+    this._lastViewportY = this.term.buffer.active.viewportY;
     this._version++;
   }
 
+  /** Monotonic count of lines trimmed off the scrollback top (M25.6) — the
+   *  absolute-line drift an anchored consumer must subtract. See {@link _trimmed}. */
+  lineTrim(): number {
+    return this._trimmed;
+  }
+
   /** Lines available above the live viewport (how far back scroll can go). */
   scrollbackDepth(): number {
     return this.term.buffer.active.viewportY;
@@ -420,7 +451,12 @@ export class PaneMirror {
     const forceRows = opts.forceRows && opts.forceRows.length ? opts.forceRows : null;
 
     for (let y = 0; y < height; y++) {
-      const data = this._incremental ? this.rowData(baseY, y) : null;
+      const raw = this._incremental ? this.rowData(baseY, y) : null;
+      // Bounds guard (M23.5, D5): after a shrink xterm's reflow can leave a
+      // line's `_data` at a length ≠ cols×3; comparing or `set`ting it against
+      // the rowLen-strided shadow would read garbage / throw RangeError. Treat
+      // such a row as shadow-less: always repaint it, never write the shadow.
+      const data = raw !== null && raw.length === rowLen ? raw : null;
       let dirty = full || y >= bottomDirtyFrom || data === null; // no shadow info for this row → always repaint
       if (!dirty && this._shadow) dirty = !shadowMatches(this._shadow, y * rowLen, data!);
       if (!dirty && forceRows) {
@@ -555,6 +591,48 @@ export class PaneMirror {
     return out;
   }
 
+  /**
+   * Extract the text of an ORDERED absolute-line range (M25.6) — the release
+   * path of a selection that may span far beyond the viewport. Each buffer
+   * line reads via `translateToString(true)` — the SAME trim/collapse as
+   * {@link visibleRowTexts} (wide-glyph spacers collapse, trailing blanks trim)
+   * — and the columns/joining go through {@link extractSelection}, so a
+   * selection that happens to fit one screen extracts byte-identically to the
+   * old visible-rows path. Wrapped lines stay separate visual rows joined with
+   * "\n", exactly as the on-screen copy always has.
+   *
+   * `maxBytes` bounds the string BUILT here: accumulation stops once the raw
+   * line total strictly exceeds it, so a runaway span never materializes tens
+   * of MB — the caller's clipboard cap (which refuses anything over the limit)
+   * still sees an over-limit byte count and refuses honestly.
+   */
+  extractAbsoluteText(start: Cell, end: Cell, maxBytes: number): string {
+    const buf = this.term.buffer.active;
+    const last = buf.length - 1;
+    if (last < 0 || end.row < 0 || start.row > last) return "";
+    const lo = Math.max(0, Math.min(start.row, last));
+    const hi = Math.max(0, Math.min(end.row, last));
+    const rowTexts: string[] = [];
+    let bytes = 0;
+    for (let y = lo; y <= hi; y++) {
+      const line = buf.getLine(y);
+      const text = line ? line.translateToString(true) : "";
+      rowTexts.push(text);
+      bytes += Buffer.byteLength(text, "utf8") + 1; // +1 for the joining "\n"
+      if (bytes > maxBytes) break;
+    }
+    // Shift the range to the accumulated slice. A clamped start selects from
+    // column 0 (its true start line is gone/off-buffer); a clamped or
+    // byte-truncated end extends to its last line's end (Infinity clamps to
+    // the row length inside rowSelectionRange).
+    const lastRowAbs = lo + rowTexts.length - 1;
+    return extractSelection(
+      rowTexts,
+      { row: 0, col: start.row === lo ? start.col : 0 },
+      { row: rowTexts.length - 1, col: lastRowAbs === end.row ? end.col : Infinity },
+    );
+  }
+
   dispose(): void {
     this.term.dispose();
   }

package/packages/daemon/src/tui/mirror/pane-surface.tsx

@@ -31,7 +31,7 @@ import { appendFileSync } from "node:fs";
 import type { SessionMirror } from "./session-mirror.ts";
 import type { CursorState } from "./pane-mirror.ts";
 import { swapCells, paintBg, type GraphemeOverride } from "./blit.ts";
-import { rowSelectionRange, type Cell } from "./selection.ts";
+import { rowSelectionRange, visibleSelRows, type Cell } from "./selection.ts";
 import type { SearchMatch } from "./search-model.ts";
 
 /** The scrollback-search highlight payload for one pane: matches keyed by
@@ -60,7 +60,10 @@ export interface PaneSurfaceOptions extends RenderableOptions<FrameBufferRendera
   paneFocused?: boolean;
   /** Bumps (coalesced, once per state tick) when this pane's content changed. */
   contentVersion?: number;
-  /** The drag selection on THIS pane (already surface/pane-filtered), or null. */
+  /** The drag selection on THIS pane (already surface/pane-filtered and
+   *  ordered), or null. ABSOLUTE buffer lines (M25.6): the walk maps them to
+   *  visible rows per-frame against the pane's live baseY (depth − offset), so
+   *  the highlight stays glued to its content while the view scrolls. */
   selRange?: { start: Cell; end: Cell } | null;
   search?: PaneSearchHighlight | null;
 }
@@ -234,7 +237,14 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
     this._lastScroll = this._scrollOffset;
     this._lastFocused = this._focusedPane;
 
-    const newSelRows = this.selRows(h);
+    // The view's absolute→visible mapping (M25.6), re-read every walk: both the
+    // selection (absolute cells) and the search matches (absolute lines) resolve
+    // to visible rows against the CURRENT baseY, so a scroll — or new content
+    // pushing the depth — moves the highlights with their text. Same clamping as
+    // the blit's own offset math (depth here == viewportY there).
+    const depth = this._mirror.scrollbackDepth(this._paneId);
+    const baseY = depth - Math.min(Math.max(0, this._scrollOffset), depth);
+    const newSelRows = this.selRows(h, baseY);
     const newSearchRows = this.searchRows(h);
     // The live cursor (M21.6): the focused pane drives the hardware cursor; an
     // unfocused pane paints a quiet marker on its cursor cell. Read once.
@@ -309,7 +319,7 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
     if (sel) {
       for (let i = 0; i < newSelRows.length; i++) {
         const y = newSelRows[i]!;
-        const r = rowSelectionRange(y, w, sel.start, sel.end);
+        const r = rowSelectionRange(baseY + y, w, sel.start, sel.end);
         if (r) swapCells(buffers, w, y, r.from, r.to);
       }
     }
@@ -370,15 +380,12 @@ class PaneSurfaceRenderable extends FrameBufferRenderable {
   }
 
   /** Visible rows covered by the current drag selection (clamped), or []. The
-   *  range arrives ordered (app.tsx passes `orderCells`). */
-  private selRows(height: number): number[] {
+   *  range arrives ordered (app.tsx passes `orderCells`) in ABSOLUTE buffer
+   *  lines; `baseY` is the view's current absolute top (M25.6). */
+  private selRows(height: number, baseY: number): number[] {
     const sel = this._sel;
     if (!sel) return [];
-    const lo = Math.max(0, sel.start.row);
-    const hi = Math.min(height - 1, sel.end.row);
-    const out: number[] = [];
-    for (let y = lo; y <= hi; y++) out.push(y);
-    return out;
+    return visibleSelRows(sel.start, sel.end, baseY, height);
   }
 
   /** Distinct visible rows carrying a search match (clamped), or []. */