@selesai/code 0.1.0

package/dist/extensions/pi-powerline-footer/tests/fixed-editor.test.ts

@@ -0,0 +1,1416 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { TUI, visibleWidth } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, renderFixedEditorCluster } from "../fixed-editor/cluster.ts";
+import {
+  buildFixedClusterPaint,
+  emergencyTerminalModeReset,
+  endSynchronizedOutput,
+  beginSynchronizedOutput,
+  moveCursor,
+  resetScrollRegion,
+  setScrollRegion,
+  TerminalSplitCompositor,
+} from "../fixed-editor/terminal-split.ts";
+
+class FakeTerminal {
+  columns = 40;
+  private rowCount = 12;
+  writes: string[] = [];
+
+  get rows(): number {
+    return this.rowCount;
+  }
+
+  setRows(rows: number): void {
+    this.rowCount = rows;
+  }
+
+  write(data: string): void {
+    this.writes.push(data);
+  }
+
+  hideCursor(): void {}
+
+  showCursor(): void {}
+}
+
+test("fixed cluster keeps the editor visible before optional rows", () => {
+  const rendered = renderFixedEditorCluster({
+    width: 80,
+    terminalRows: 6,
+    statusLines: ["status"],
+    topLines: ["top"],
+    editorLines: ["edit-a", `edit-b ${CURSOR_MARKER}`, "edit-c"],
+    secondaryLines: ["secondary"],
+    transcriptLines: ["old-1", "old-2"],
+    lastPromptLines: ["last"],
+  });
+
+  assert.deepEqual(rendered.lines, ["top", "edit-a", "edit-b ", "edit-c", "secondary"]);
+  assert.deepEqual(rendered.cursor, { row: 2, col: 7 });
+});
+
+test("fixed cluster caps oversized editor around the cursor", () => {
+  const rendered = renderFixedEditorCluster({
+    width: 80,
+    terminalRows: 4,
+    statusLines: ["status"],
+    editorLines: ["edit-a", "edit-b", `edit-c ${CURSOR_MARKER}`, "edit-d", "edit-e"],
+    transcriptLines: ["old"],
+  });
+
+  assert.deepEqual(rendered.lines, ["edit-a", "edit-b", "edit-c "]);
+  assert.deepEqual(rendered.cursor, { row: 2, col: 7 });
+});
+
+test("fixed cluster caps selector-style editor replacements around the selected row", () => {
+  const rendered = renderFixedEditorCluster({
+    width: 80,
+    terminalRows: 4,
+    editorLines: [
+      "title",
+      "  option-a",
+      "  option-b",
+      "\x1b[38;5;39m→ \x1b[0m\x1b[38;5;39moption-c\x1b[0m",
+      "  option-d",
+      "hint",
+    ],
+  });
+
+  assert.deepEqual(rendered.lines, ["  option-b", "\x1b[38;5;39m→ \x1b[0m\x1b[38;5;39moption-c\x1b[0m", "  option-d"]);
+});
+
+test("fixed cluster keeps tail status lines when compact", () => {
+  const rendered = renderFixedEditorCluster({
+    width: 80,
+    terminalRows: 3,
+    statusLines: ["above-widget", "powerline-status", "⠏ Shaolin Switchblade Sync..."],
+    editorLines: ["edit"],
+  });
+
+  assert.deepEqual(rendered.lines, ["⠏ Shaolin Switchblade Sync...", "edit"]);
+});
+
+test("terminal split can render a hidden status container in the fixed cluster", () => {
+  const terminal = new FakeTerminal();
+  const status = {
+    text: "⠏ Shaolin Switchblade Sync...",
+    render() {
+      return ["", this.text];
+    },
+  };
+  const editor = {
+    render() {
+      return ["editor"];
+    },
+  };
+  const tui = {
+    terminal,
+    render() {
+      return ["chat"];
+    },
+    doRender() {
+      this.terminal.write("body");
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    getShowHardwareCursor: () => false,
+    renderCluster: (width) => ({
+      lines: [
+        ...compositor.renderHidden(status, width).filter((line) => visibleWidth(line) > 0),
+        ...compositor.renderHidden(editor, width),
+      ],
+      cursor: null,
+    }),
+  });
+
+  compositor.hideRenderable(status);
+  compositor.hideRenderable(editor);
+  compositor.install();
+
+  assert.deepEqual(status.render(), []);
+  tui.doRender();
+  assert.ok(terminal.writes.at(-1)?.includes("⠏ Shaolin Switchblade Sync..."));
+
+  status.text = "⠙ Shaolin Switchblade Sync...";
+  compositor.requestRepaint();
+  assert.ok(terminal.writes.at(-1)?.includes("⠙ Shaolin Switchblade Sync..."));
+
+  compositor.dispose();
+  assert.deepEqual(status.render(), ["", "⠙ Shaolin Switchblade Sync..."]);
+});
+
+test("terminal split escape helpers generate DEC scroll region controls", () => {
+  assert.equal(beginSynchronizedOutput(), "\x1b[?2026h");
+  assert.equal(endSynchronizedOutput(), "\x1b[?2026l");
+  assert.equal(setScrollRegion(1, 18), "\x1b[1;18r");
+  assert.equal(resetScrollRegion(), "\x1b[r");
+  assert.equal(moveCursor(20, 3), "\x1b[20;3H");
+});
+
+test("fixed cluster paint clears bottom rows and positions hardware cursor", () => {
+  const paint = buildFixedClusterPaint(
+    { lines: ["top", "edit"], cursor: { row: 1, col: 2 } },
+    10,
+    20,
+    true,
+  );
+
+  assert.match(paint, /^\x1b\[r/);
+  assert.ok(paint.includes("\x1b[9;1H\x1b[2Ktop"));
+  assert.ok(paint.includes("\x1b[10;1H\x1b[2Kedit"));
+  assert.ok(paint.endsWith("\x1b[10;3H\x1b[?25h"));
+});
+
+test("terminal split reserves rows, hides root renderables, repaints, and cleans up", () => {
+  const terminal = new FakeTerminal();
+  const hidden = {
+    render(width: number) {
+      return [`hidden:${width}`];
+    },
+  };
+  const tui = {
+    terminal,
+    hardwareCursorRow: 2,
+    cursorRow: 2,
+    previousViewportTop: 0,
+    rendered: 0,
+    doRender() {
+      this.rendered += 1;
+      this.terminal.write("body");
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    getShowHardwareCursor: () => false,
+    renderCluster: (width) => ({
+      lines: [`cluster:${width}`, ...compositor.renderHidden(hidden, width)],
+      cursor: null,
+    }),
+  });
+
+  compositor.hideRenderable(hidden);
+  compositor.install();
+
+  assert.deepEqual(hidden.render(40), []);
+  assert.equal(terminal.rows, 10);
+
+  tui.doRender();
+
+  assert.equal(tui.rendered, 1);
+  assert.equal(terminal.writes.length, 3);
+  assert.ok(terminal.writes[0]?.includes("\x1b[?1049h"));
+  assert.ok(terminal.writes[0]?.includes("\x1b[?1007l"));
+  assert.ok(terminal.writes[0]?.includes("\x1b[?1002h"));
+  assert.ok(terminal.writes[0]?.includes("\x1b[?1006h"));
+  assert.ok(terminal.writes[1]?.includes("\x1b[1;10r\x1b[3;1Hbody"));
+  assert.ok(terminal.writes[1]?.includes("cluster:40"));
+  assert.ok(terminal.writes[1]?.includes("hidden:40"));
+  assert.ok(terminal.writes[2]?.includes("cluster:40"));
+
+  compositor.dispose();
+
+  assert.deepEqual(hidden.render(8), ["hidden:8"]);
+  assert.equal(terminal.rows, 12);
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[r"));
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1006l"));
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1002l"));
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1000l"));
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1007h"));
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1049l"));
+  assert.ok(!terminal.writes.at(-1)?.includes("\x1b[<u"));
+  assert.ok(!terminal.writes.at(-1)?.includes("\x1b[>4;0m"));
+});
+
+test("terminal split re-enables Kitty keyboard protocol in alternate screen", () => {
+  const terminal = new FakeTerminal();
+  Object.defineProperty(terminal, "kittyProtocolActive", { value: true });
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+
+  const setup = terminal.writes[0] ?? "";
+  assert.ok(setup.includes("\x1b[?1049h"));
+  assert.ok(setup.includes("\x1b[>7u"));
+  assert.ok(setup.indexOf("\x1b[?1049h") < setup.indexOf("\x1b[>7u"));
+
+  compositor.dispose();
+
+  const cleanup = terminal.writes.at(-1) ?? "";
+  assert.ok(cleanup.includes("\x1b[<u"));
+  assert.ok(cleanup.indexOf("\x1b[<u") < cleanup.indexOf("\x1b[?1049l"));
+  assert.ok(!cleanup.includes("\x1b[<999u"));
+});
+
+test("terminal split re-enables modifyOtherKeys in alternate screen", () => {
+  const terminal = new FakeTerminal();
+  Reflect.set(terminal, "_modifyOtherKeysActive", true);
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+
+  const setup = terminal.writes[0] ?? "";
+  assert.ok(setup.includes("\x1b[?1049h"));
+  assert.ok(setup.includes("\x1b[>4;2m"));
+  assert.ok(setup.indexOf("\x1b[?1049h") < setup.indexOf("\x1b[>4;2m"));
+
+  compositor.dispose();
+
+  const cleanup = terminal.writes.at(-1) ?? "";
+  assert.ok(cleanup.includes("\x1b[>4;0m"));
+  assert.ok(cleanup.indexOf("\x1b[>4;0m") < cleanup.indexOf("\x1b[?1049l"));
+  assert.ok(!cleanup.includes("\x1b[<999u"));
+});
+
+test("terminal split restores main screen mode when Kitty activates after install", () => {
+  const terminal = new FakeTerminal();
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  terminal.kittyProtocolActive = true;
+  compositor.dispose();
+
+  const cleanup = terminal.writes.at(-1) ?? "";
+  assert.ok(cleanup.includes("\x1b[<u"));
+  assert.ok(cleanup.includes("\x1b[>7u"));
+  assert.ok(cleanup.indexOf("\x1b[<u") < cleanup.indexOf("\x1b[?1049l"));
+  assert.ok(cleanup.indexOf("\x1b[?1049l") < cleanup.indexOf("\x1b[>7u"));
+});
+
+test("terminal split restores main screen mode when modifyOtherKeys activates after install", () => {
+  const terminal = new FakeTerminal();
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  Reflect.set(terminal, "_modifyOtherKeysActive", true);
+  compositor.dispose();
+
+  const cleanup = terminal.writes.at(-1) ?? "";
+  assert.ok(cleanup.includes("\x1b[>4;0m"));
+  assert.ok(cleanup.includes("\x1b[>4;2m"));
+  assert.ok(cleanup.indexOf("\x1b[>4;0m") < cleanup.indexOf("\x1b[?1049l"));
+  assert.ok(cleanup.indexOf("\x1b[?1049l") < cleanup.indexOf("\x1b[>4;2m"));
+});
+
+test("terminal split shutdown cleanup resets extended keyboard modes", () => {
+  const terminal = new FakeTerminal();
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  compositor.dispose({ resetExtendedKeyboardModes: true });
+
+  const cleanup = terminal.writes.at(-1) ?? "";
+  assert.ok(cleanup.includes("\x1b[<999u"));
+  assert.ok(cleanup.includes("\x1b[>4;0m"));
+  assert.ok(cleanup.indexOf("\x1b[?1049l") < cleanup.indexOf("\x1b[<999u"));
+});
+
+test("terminal row reservation does not recurse when hidden editor render reads terminal rows", () => {
+  const terminal = new FakeTerminal();
+  const tui = { terminal };
+  const hidden = {
+    render() {
+      return [`rows:${terminal.rows}`];
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: (width) => ({
+      lines: compositor.renderHidden(hidden, width),
+      cursor: null,
+    }),
+  });
+
+  compositor.hideRenderable(hidden);
+  compositor.install();
+
+  assert.equal(terminal.rows, 11);
+  compositor.requestRepaint();
+  assert.ok(terminal.writes.at(-1)?.includes("rows:12"));
+
+  compositor.dispose();
+});
+
+test("terminal split anchors diff writes to the visible viewport row", () => {
+  const terminal = new FakeTerminal();
+  const tui = {
+    terminal,
+    hardwareCursorRow: 100,
+    cursorRow: 100,
+    previousViewportTop: 95,
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  terminal.write("diff");
+
+  assert.ok(terminal.writes[1]?.includes("\x1b[1;10r\x1b[6;1Hdiff"));
+
+  compositor.dispose();
+});
+
+test("terminal split does not repaint the fixed cluster over visible overlays", () => {
+  const terminal = new FakeTerminal();
+  const tui = {
+    terminal,
+    overlayStack: [{}],
+    rendered: 0,
+    doRender() {
+      this.rendered += 1;
+      this.terminal.write("overlay-frame");
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.doRender();
+  compositor.requestRepaint();
+
+  assert.deepEqual(terminal.writes, [
+    "\x1b[?2026h\x1b[?1049h\x1b[?1007l\x1b[?1002h\x1b[?1006h\x1b[?2026l",
+    "overlay-frame",
+  ]);
+
+  compositor.dispose();
+});
+
+test("terminal split strips OSC markers from root lines while overlays are visible", () => {
+  const terminal = new FakeTerminal();
+  terminal.columns = 20;
+  const tui = {
+    terminal,
+    overlayStack: [{}],
+    render() {
+      return ["\x1b]133;B\x07" + "x".repeat(20) + "\x1b]133;C\x07"];
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  const rendered = tui.render(20);
+
+  assert.equal(rendered.length, 1);
+  assert.equal(visibleWidth(rendered[0] ?? ""), 20);
+  assert.doesNotMatch(rendered[0] ?? "", /\]133/);
+
+  compositor.dispose();
+});
+
+test("terminal split keeps tabbed overlay composition within terminal width", () => {
+  const terminal = new FakeTerminal();
+  terminal.columns = 250;
+  terminal.setRows(40);
+  const tui = new TUI(terminal, false);
+  const overlay = "\x1b[38;2;119;125;136m[grep]: render.ts-706- \treturn [...lines.slice(0, visibleLines), truncLine(theme.fg(\"dim\", hint), width)];\x1b[39m";
+
+  const before = tui.compositeLineAt("Validation before " + " ".repeat(232), overlay, 20, 210, 250);
+  assert.ok(visibleWidth(before) > 250);
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  const after = tui.compositeLineAt("Validation before " + " ".repeat(232), overlay, 20, 210, 250);
+
+  assert.ok(visibleWidth(after) <= 250);
+  assert.doesNotMatch(after, /\t/);
+
+  compositor.dispose();
+});
+
+test("terminal split renders chat through an app-owned scroll viewport", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const renderRequests: Array<boolean | undefined> = [];
+  let rootLines = Array.from({ length: 15 }, (_, index) => `line-${index}`);
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return rootLines;
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+
+  assert.equal(terminal.rows, 10);
+  assert.deepEqual(tui.render(40), [
+    "line-5", "line-6", "line-7", "line-8", "line-9",
+    "line-10", "line-11", "line-12", "line-13", "line-14",
+  ]);
+
+  assert.deepEqual(inputListener?.("\x1b[<2;1;1M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1bOA"), undefined);
+  assert.deepEqual(inputListener?.("\x1bOB"), undefined);
+  assert.deepEqual(inputListener?.("\x1b[A"), undefined);
+  assert.deepEqual(renderRequests, []);
+  assert.deepEqual(inputListener?.("\x1b[<64;1;1M"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-2", "line-3", "line-4", "line-5", "line-6",
+    "line-7", "line-8", "line-9", "line-10", "line-11",
+  ]);
+
+  rootLines = [...rootLines, "line-15"];
+  assert.deepEqual(tui.render(40), [
+    "line-2", "line-3", "line-4", "line-5", "line-6",
+    "line-7", "line-8", "line-9", "line-10", "line-11",
+  ]);
+
+  assert.deepEqual(inputListener?.("\x1b[<65;1;1M"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined, undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-5", "line-6", "line-7", "line-8", "line-9",
+    "line-10", "line-11", "line-12", "line-13", "line-14",
+  ]);
+
+  assert.deepEqual(inputListener?.("\x1b[5~"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined, undefined, undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-0", "line-1", "line-2", "line-3", "line-4",
+    "line-5", "line-6", "line-7", "line-8", "line-9",
+  ]);
+
+  compositor.dispose();
+  assert.equal(inputListener, null);
+});
+
+test("terminal split refreshes scroll bounds after fixed status rows appear", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const renderRequests: Array<boolean | undefined> = [];
+  const rootLines = Array.from({ length: 11 }, (_, index) => `line-${index}`);
+  let statusVisible = false;
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return rootLines;
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({
+      lines: statusVisible ? ["⠏ fixed status", "editor"] : ["editor"],
+      cursor: null,
+    }),
+  });
+
+  compositor.install();
+
+  assert.deepEqual(tui.render(40), rootLines);
+
+  statusVisible = true;
+  compositor.requestRepaint();
+
+  assert.deepEqual(inputListener?.("\x1b[<64;1;1M"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined]);
+  assert.match(terminal.writes.at(-1) ?? "", /line-0/);
+  assert.match(terminal.writes.at(-1) ?? "", /⠏ fixed status/);
+  assert.deepEqual(tui.render(40), [
+    "line-0", "line-1", "line-2", "line-3", "line-4",
+    "line-5", "line-6", "line-7", "line-8", "line-9",
+  ]);
+
+  compositor.dispose();
+});
+
+test("terminal split handles modified SGR wheel packets", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const renderRequests: Array<boolean | undefined> = [];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return Array.from({ length: 15 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render(40);
+
+  assert.deepEqual(inputListener?.("\x1b[<68;1;1M"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-2", "line-3", "line-4", "line-5", "line-6",
+    "line-7", "line-8", "line-9", "line-10", "line-11",
+  ]);
+
+  assert.deepEqual(inputListener?.("\x1b[<68;1;1M\x1b[<68;1;1M"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined, undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-0", "line-1", "line-2", "line-3", "line-4",
+    "line-5", "line-6", "line-7", "line-8", "line-9",
+  ]);
+
+  assert.deepEqual(inputListener?.("\x1b[<69;1;1M"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined, undefined, undefined]);
+
+  compositor.dispose();
+});
+
+test("terminal split pauses mouse reporting on right click for the terminal context menu", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const renderRequests: Array<boolean | undefined> = [];
+  const copied: string[] = [];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return Array.from({ length: 20 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => copied.push(text),
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render(40);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;5;5M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;5;5m"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<2;5;5M"), { consume: true });
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1006l\x1b[?1002l\x1b[?1000l"));
+  assert.deepEqual(inputListener?.("\x1b[<0;5;5M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;5;5m"), { consume: true });
+  assert.deepEqual(copied, []);
+  assert.deepEqual(renderRequests, [undefined, undefined, undefined, undefined]);
+
+  compositor.dispose();
+});
+
+test("terminal split selects visible chat text and copies it on drag release", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const renderRequests: Array<boolean | undefined> = [];
+  const copied: string[] = [];
+  const rootLines = [
+    "old-0", "old-1", "old-2", "old-3", "old-4",
+    "alpha one", "bravo two", "charlie three", "delta four", "echo five",
+    "foxtrot six", "golf seven", "hotel eight", "india nine", "juliet ten",
+  ];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return rootLines;
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => copied.push(text),
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  assert.deepEqual(tui.render(40), [
+    "alpha one", "bravo two", "charlie three", "delta four", "echo five",
+    "foxtrot six", "golf seven", "hotel eight", "india nine", "juliet ten",
+  ]);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;2;2M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<32;7;4M"), { consume: true });
+  assert.deepEqual(tui.render(40).slice(1, 4), [
+    "b\x1b[7mravo two\x1b[27m",
+    "\x1b[7mcharlie three\x1b[27m",
+    "\x1b[7mdelta \x1b[27mfour",
+  ]);
+  assert.deepEqual(inputListener?.("\x1b[<0;7;4m"), { consume: true });
+
+  assert.deepEqual(copied, ["ravo two\ncharlie three\ndelta"]);
+  assert.ok(!terminal.writes.at(-1)?.includes("\x1b[?1006l\x1b[?1002l\x1b[?1000l"));
+  assert.deepEqual(renderRequests, [undefined, undefined, undefined]);
+
+  compositor.dispose();
+});
+
+test("terminal split restores app-owned selection after context menu copy", (t) => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  let clipboard = "";
+  const rootLines = [
+    "old-0", "old-1", "old-2", "old-3", "old-4",
+    "alpha one", "bravo two", "charlie three", "delta four", "echo five",
+    "foxtrot six", "golf seven", "hotel eight", "india nine", "juliet ten",
+  ];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render(_width?: number) {
+      return rootLines;
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => {
+      clipboard = text;
+    },
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render(40);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;2;2M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<32;7;4M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;7;4m"), { consume: true });
+  assert.equal(clipboard, "ravo two\ncharlie three\ndelta");
+
+  clipboard = "clicked-word";
+  assert.deepEqual(inputListener?.("\x1b[<2;4;3M"), { consume: true });
+  assert.equal(clipboard, "ravo two\ncharlie three\ndelta");
+  assert.ok(tui.render(40)[1]?.includes("b\x1b[7mravo two\x1b[27m"));
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1006l\x1b[?1002l\x1b[?1000l"));
+
+  clipboard = "terminal-clicked-word-copy";
+  t.mock.timers.tick(1200);
+  assert.equal(clipboard, "ravo two\ncharlie three\ndelta");
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[?1002h\x1b[?1006h"));
+
+  clipboard = "late-terminal-clicked-word-copy";
+  t.mock.timers.tick(100);
+  assert.equal(clipboard, "ravo two\ncharlie three\ndelta");
+
+  clipboard = "other-copy";
+  assert.deepEqual(inputListener?.("\x1b[<2;5;5M"), { consume: true });
+  assert.equal(clipboard, "other-copy");
+  t.mock.timers.tick(1200);
+  assert.equal(clipboard, "other-copy");
+  assert.ok(!tui.render(40)[1]?.includes("\x1b[7mravo two\x1b[27m"));
+
+  compositor.dispose();
+});
+
+test("terminal split selection does not expose OSC control sequences as text", () => {
+  const terminal = new FakeTerminal();
+  terminal.columns = 20;
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const rootLines = [
+    "old-0", "old-1", "old-2", "old-3", "old-4",
+    "alpha", "bravo", "charlie", "delta", "echo",
+    "foxtrot", "golf", "hotel", "india", "\x1b]133;B\x07\x1b]133;C\x07juliet",
+  ];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return rootLines;
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render(20);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;1;10M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<32;6;10M"), { consume: true });
+  const selectedLine = tui.render(20).at(-1) ?? "";
+
+  assert.ok(visibleWidth(selectedLine) <= 20);
+  assert.ok(!selectedLine.includes("]133"));
+  assert.ok(selectedLine.includes("\x1b[7mjulie\x1b[27mt"));
+
+  compositor.dispose();
+});
+
+test("terminal split selection highlighting does not duplicate wide glyphs", () => {
+  for (const glyph of ["🪃", "👨‍👩‍👧‍👦"]) {
+    const terminal = new FakeTerminal();
+    terminal.columns = 30;
+    let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+    const prefix = "Done shows ";
+    const line = `${prefix}${glyph} auto${" ".repeat(30 - visibleWidth(`${prefix}${glyph} auto`))}`;
+    const tui = {
+      terminal,
+      addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+        inputListener = listener;
+        return () => {
+          inputListener = null;
+        };
+      },
+      requestRender() {},
+      render() {
+        return ["old-0", "old-1", "old-2", "old-3", "old-4", "old-5", "old-6", "old-7", "old-8", line];
+      },
+    };
+
+    const compositor = new TerminalSplitCompositor({
+      tui,
+      terminal,
+      renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+    });
+
+    compositor.install();
+    tui.render(30);
+
+    const glyphCol = visibleWidth(prefix);
+    assert.deepEqual(inputListener?.(`\x1b[<0;${glyphCol + 1};10M`), { consume: true });
+    assert.deepEqual(inputListener?.(`\x1b[<32;${glyphCol + 2};10M`), { consume: true });
+    const selectedLine = tui.render(30).at(-1) ?? "";
+
+    assert.ok(visibleWidth(selectedLine) <= 30);
+    assert.equal(selectedLine.includes(glyph), true);
+    assert.ok(selectedLine.includes(`\x1b[7m${glyph}\x1b[27m`));
+
+    compositor.dispose();
+  }
+});
+
+test("terminal split copies chat and fixed cluster selections", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const copied: string[] = [];
+  const rootLines = [
+    "old-0", "old-1", "old-2", "old-3", "old-4",
+    "alpha one", "bravo two", "charlie three", "delta four", "echo five",
+    "foxtrot six", "golf seven", "hotel eight", "india nine", "juliet ten",
+  ];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return rootLines;
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => copied.push(text),
+    renderCluster: () => ({ lines: ["cluster-a", "  > hello world"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render(40);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;1;9M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;5;11m"), { consume: true });
+  assert.deepEqual(copied, ["india nine\njuli"]);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;5;12M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<32;10;12M"), { consume: true });
+  compositor.requestRepaint();
+  assert.ok(terminal.writes.at(-1)?.includes("  > \x1b[7mhello\x1b[27m world"));
+  assert.deepEqual(inputListener?.("\x1b[<0;10;12m"), { consume: true });
+  assert.deepEqual(copied, ["india nine\njuli", "hello"]);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;8;12M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;8;12m"), { consume: true });
+  assert.deepEqual(copied, ["india nine\njuli", "hello"]);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;4;3M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;4;3m"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;5;3M"), { consume: true });
+  assert.ok(tui.render(40)[2]?.includes("\x1b[7mcharlie three\x1b[27m"));
+  assert.deepEqual(inputListener?.("\x1b[<0;5;3m"), { consume: true });
+  assert.deepEqual(copied, ["india nine\njuli", "hello", "charlie three"]);
+
+  assert.deepEqual(inputListener?.("\x1b[<0;8;12M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;8;12m"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<0;9;12M"), { consume: true });
+  compositor.requestRepaint();
+  assert.ok(terminal.writes.at(-1)?.includes("\x1b[7m  > hello world\x1b[27m"));
+  assert.deepEqual(inputListener?.("\x1b[<0;9;12m"), { consume: true });
+  assert.deepEqual(copied, ["india nine\njuli", "hello", "charlie three", "  > hello world"]);
+
+  compositor.dispose();
+});
+
+test("terminal split selection scrolls when dragged to viewport edges", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const copied: string[] = [];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => copied.push(text),
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render();
+  inputListener?.("\x1b[5~");
+  assert.equal(tui.render()[0], "line-10");
+
+  assert.deepEqual(inputListener?.("\x1b[<0;1;9M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<32;5;12M"), { consume: true });
+  assert.equal(tui.render()[0], "line-11");
+  assert.ok(tui.render()[9]?.includes("\x1b[7mline\x1b[27m-20"));
+  assert.deepEqual(inputListener?.("\x1b[<0;5;12m"), { consume: true });
+  assert.deepEqual(copied, ["line-18\nline-19\nline"]);
+
+  compositor.jumpToRootBottom();
+  assert.equal(tui.render()[0], "line-20");
+  assert.deepEqual(inputListener?.("\x1b[<0;1;2M"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[<32;5;1M"), { consume: true });
+  assert.equal(tui.render()[0]?.replace(/\x1b\[[0-9;]*m/g, ""), "line-19");
+  assert.ok(tui.render()[0]?.includes("line\x1b[7m-19\x1b[27m"));
+  assert.deepEqual(inputListener?.("\x1b[<0;5;1m"), { consume: true });
+  assert.deepEqual(copied, ["line-18\nline-19\nline", "-19\nline-20"]);
+
+  compositor.dispose();
+});
+
+test("terminal split copies edge-scrolled selections without waiting for render", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const copied: string[] = [];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => copied.push(text),
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render();
+  inputListener?.("\x1b[5~");
+  tui.render();
+
+  inputListener?.("\x1b[<0;1;9M");
+  inputListener?.("\x1b[<32;5;12M");
+  inputListener?.("\x1b[<0;5;12m");
+  assert.deepEqual(copied, ["line-18\nline-19\nline"]);
+
+  inputListener?.("\x1b[<0;1;9M");
+  for (let i = 0; i < 9; i++) {
+    inputListener?.("\x1b[<32;5;12M");
+  }
+  inputListener?.("\x1b[<0;5;12m");
+  assert.deepEqual(copied.at(-1), [
+    "line-19", "line-20", "line-21", "line-22", "line-23",
+    "line-24", "line-25", "line-26", "line-27", "line-28", "line",
+  ].join("\n"));
+
+  compositor.dispose();
+});
+
+test("terminal split maps post-edge-scroll drags against the updated viewport", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const copied: string[] = [];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    onCopySelection: (text) => copied.push(text),
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render();
+  inputListener?.("\x1b[5~");
+  tui.render();
+
+  inputListener?.("\x1b[<0;1;9M");
+  inputListener?.("\x1b[<32;1;12M");
+  inputListener?.("\x1b[<32;1;3M");
+  inputListener?.("\x1b[<0;5;4m");
+  assert.deepEqual(copied, ["-14\nline-15\nline-16\nline-17"]);
+
+  compositor.dispose();
+});
+
+test("terminal split keyboard scroll supports Pi page aliases and preserves app shortcuts", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render();
+
+  assert.deepEqual(inputListener?.("\x1b[5~"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[5;9~"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57421;9u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[1;9A"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57419;9u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[1;9H"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57423;9u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[7;9~"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[1;6A"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57419;6u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[6;9~"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57422;9u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[1;9B"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57420;9u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[1;9F"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57424;9u"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[8;9~"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[1;6B"), { consume: true });
+  assert.deepEqual(inputListener?.("\x1b[57420;6u"), { consume: true });
+  assert.equal(inputListener?.("\x1b[1;10A"), undefined);
+  assert.equal(inputListener?.("\x1b[57419;10u"), undefined);
+  assert.equal(inputListener?.("\x1b[1;10B"), undefined);
+  assert.equal(inputListener?.("\x1b[57420;10u"), undefined);
+  assert.equal(inputListener?.("\x1b[1;10:3A"), undefined);
+  assert.equal(inputListener?.("\x1b[57419;10:3u"), undefined);
+  assert.equal(inputListener?.("\x1bp"), undefined);
+  assert.equal(inputListener?.("\x1bn"), undefined);
+
+  compositor.dispose();
+});
+
+test("terminal split keyboard scroll accepts configured shortcuts", () => {
+  const terminal = new FakeTerminal();
+  const renderRequests: Array<boolean | undefined> = [];
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    keyboardScrollShortcuts: { up: "ctrl+shift+u", down: "ctrl+shift+d" },
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render();
+
+  assert.equal(inputListener?.("\x1b[1;9A"), undefined);
+  assert.deepEqual(inputListener?.("\x1b[117;6u"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined]);
+  assert.deepEqual(inputListener?.("\x1b[100;6u"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined, undefined]);
+
+  compositor.dispose();
+});
+
+test("terminal split jumps to previous root target lines", () => {
+  const terminal = new FakeTerminal();
+  const renderRequests: Array<boolean | undefined> = [];
+  const tui = {
+    terminal,
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  assert.deepEqual(tui.render(40), [
+    "line-20", "line-21", "line-22", "line-23", "line-24",
+    "line-25", "line-26", "line-27", "line-28", "line-29",
+  ]);
+
+  assert.equal(compositor.jumpToPreviousRootTarget([6, 14, 24]), true);
+  assert.deepEqual(renderRequests, [undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-14", "line-15", "line-16", "line-17", "line-18",
+    "line-19", "line-20", "line-21", "line-22", "line-23",
+  ]);
+
+  assert.equal(compositor.jumpToPreviousRootTarget([6, 14, 24]), true);
+  assert.deepEqual(renderRequests, [undefined, undefined]);
+  assert.deepEqual(tui.render(40), [
+    "line-6", "line-7", "line-8", "line-9", "line-10",
+    "line-11", "line-12", "line-13", "line-14", "line-15",
+  ]);
+
+  assert.equal(compositor.jumpToPreviousRootTarget([6, 14, 24]), false);
+
+  assert.equal(compositor.jumpToNextRootTarget([6, 14, 24]), true);
+  assert.deepEqual(tui.render(40), [
+    "line-14", "line-15", "line-16", "line-17", "line-18",
+    "line-19", "line-20", "line-21", "line-22", "line-23",
+  ]);
+
+  assert.equal(compositor.jumpToNextRootTarget([6, 14, 24]), true);
+  assert.deepEqual(tui.render(40), [
+    "line-20", "line-21", "line-22", "line-23", "line-24",
+    "line-25", "line-26", "line-27", "line-28", "line-29",
+  ]);
+
+  assert.equal(compositor.jumpToNextRootTarget([6, 14, 24]), false);
+
+  assert.equal(compositor.jumpToPreviousRootTarget([6, 14, 24]), true);
+  assert.deepEqual(tui.render(40), [
+    "line-14", "line-15", "line-16", "line-17", "line-18",
+    "line-19", "line-20", "line-21", "line-22", "line-23",
+  ]);
+  assert.equal(compositor.jumpToRootBottom(), true);
+  assert.deepEqual(tui.render(40), [
+    "line-20", "line-21", "line-22", "line-23", "line-24",
+    "line-25", "line-26", "line-27", "line-28", "line-29",
+  ]);
+  assert.equal(compositor.jumpToRootBottom(), false);
+  compositor.dispose();
+});
+
+test("terminal split previous root target only moves to older targets", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender() {},
+    render() {
+      return Array.from({ length: 30 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  assert.deepEqual(tui.render(), [
+    "line-20", "line-21", "line-22", "line-23", "line-24",
+    "line-25", "line-26", "line-27", "line-28", "line-29",
+  ]);
+  assert.deepEqual(inputListener?.("\x1b[5~"), { consume: true });
+  assert.deepEqual(tui.render(), [
+    "line-10", "line-11", "line-12", "line-13", "line-14",
+    "line-15", "line-16", "line-17", "line-18", "line-19",
+  ]);
+
+  assert.equal(compositor.jumpToPreviousRootTarget([6, 14, 24]), true);
+  assert.deepEqual(tui.render(), [
+    "line-6", "line-7", "line-8", "line-9", "line-10",
+    "line-11", "line-12", "line-13", "line-14", "line-15",
+  ]);
+
+  compositor.dispose();
+});
+
+test("terminal split can disable mouse reporting for normal selection", () => {
+  const terminal = new FakeTerminal();
+  let inputListener: ((data: string) => { consume?: boolean; data?: string } | undefined) | null = null;
+  const renderRequests: Array<boolean | undefined> = [];
+  const tui = {
+    terminal,
+    addInputListener(listener: (data: string) => { consume?: boolean; data?: string } | undefined) {
+      inputListener = listener;
+      return () => {
+        inputListener = null;
+      };
+    },
+    requestRender(force?: boolean) {
+      renderRequests.push(force);
+    },
+    render() {
+      return Array.from({ length: 15 }, (_, index) => `line-${index}`);
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    mouseScroll: false,
+    renderCluster: () => ({ lines: ["cluster-a", "cluster-b"], cursor: null }),
+  });
+
+  compositor.install();
+  tui.render(40);
+
+  assert.ok(!terminal.writes[0]?.includes("\x1b[?1002h"));
+  assert.ok(!terminal.writes[0]?.includes("\x1b[?1006h"));
+  assert.deepEqual(inputListener?.("\x1b[<64;1;1M"), undefined);
+  assert.deepEqual(inputListener?.("\x1b[A"), undefined);
+  assert.deepEqual(inputListener?.("\x1b[5~"), { consume: true });
+  assert.deepEqual(renderRequests, [undefined]);
+
+  compositor.dispose();
+  assert.ok(!terminal.writes.at(-1)?.includes("\x1b[?1006l"));
+  assert.ok(!terminal.writes.at(-1)?.includes("\x1b[?1002l"));
+});
+
+test("terminal split reuses the fixed cluster during one render pass", () => {
+  const terminal = new FakeTerminal();
+  let renderClusterCount = 0;
+  const tui = {
+    terminal,
+    hardwareCursorRow: 0,
+    cursorRow: 0,
+    previousViewportTop: 0,
+    render() {
+      return ["root-a", "root-b"];
+    },
+    doRender() {
+      void this.terminal.rows;
+      this.render(this.terminal.columns);
+      this.terminal.write("body");
+    },
+  };
+
+  const compositor = new TerminalSplitCompositor({
+    tui,
+    terminal,
+    renderCluster: () => {
+      renderClusterCount += 1;
+      return { lines: ["cluster-a", "cluster-b"], cursor: null };
+    },
+  });
+
+  compositor.install();
+  tui.doRender();
+
+  assert.equal(renderClusterCount, 1);
+
+  compositor.dispose();
+});
+
+test("emergency terminal reset exits alternate screen before clearing keyboard modes", () => {
+  const cleanup = emergencyTerminalModeReset();
+  assert.ok(cleanup.includes("\x1b[?1049l"));
+  assert.ok(cleanup.includes("\x1b[<999u"));
+  assert.ok(cleanup.includes("\x1b[>4;0m"));
+  assert.ok(cleanup.indexOf("\x1b[?1049l") < cleanup.indexOf("\x1b[<999u"));
+});
+
+test("terminal split emergency exit cleanup resets extended keyboard modes", () => {
+  const terminal = new FakeTerminal();
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  process.emit("exit", 0);
+
+  const cleanup = terminal.writes.at(-1) ?? "";
+  assert.ok(cleanup.includes("\x1b[<999u"));
+  assert.ok(cleanup.includes("\x1b[>4;0m"));
+  assert.ok(cleanup.indexOf("\x1b[?1049l") < cleanup.indexOf("\x1b[<999u"));
+
+  compositor.dispose();
+});
+
+test("terminal split unregisters emergency exit cleanup on dispose", () => {
+  const terminal = new FakeTerminal();
+  const before = process.listenerCount("exit");
+  const compositor = new TerminalSplitCompositor({
+    tui: { terminal },
+    terminal,
+    renderCluster: () => ({ lines: ["cluster"], cursor: null }),
+  });
+
+  compositor.install();
+  assert.equal(process.listenerCount("exit"), before + 1);
+
+  compositor.dispose();
+  assert.equal(process.listenerCount("exit"), before);
+});