pi-jar 0.1.7 → 0.1.9

package/src/democracy.ts

@@ -25,7 +25,8 @@ export interface DemocracyResult {
   shortlist: string[];
   winner?: string;
 }
-const live = (agent: SubagentReport) => ["queued", "working", "idle", "paused"].includes(agent.state);
+/** Retained voters hold pool slots whether or not their process is currently running. */
+const live = (agent: SubagentReport) => ["queued", "working", "idle", "paused", "hibernated"].includes(agent.state);
 /** One round never outlives this; late ballots count as failures, never as guesses. */
 export const BALLOT_TIMEOUT_MS = 10 * 60_000;
 /** Rationale and failure text returned to the moderator per voter. */
@@ -53,7 +54,8 @@ export function validateDemocracy(request: DemocracyRequest): void {
 }
 
 export function parseBallot(report: SubagentReport, nonce: string, options: readonly DecisionOption[]): Ballot {
-  if (report.error || report.state !== "idle") throw new Error(report.error ?? "Scout did not finish its ballot");
+  // A finished ballot turn is idle, or already hibernated if its process closed before the tally.
+  if (report.error || (report.state !== "idle" && report.state !== "hibernated")) throw new Error(report.error ?? "Scout did not finish its ballot");
   const lines = report.output.split(/\r?\n/).filter((line) => line.startsWith("JAR_BALLOT "));
   if (lines.length !== 1) throw new Error("Expected exactly one private JAR_BALLOT response");
   const raw = JSON.parse(lines[0]!.slice(11)) as { round?: unknown; option?: unknown; rationale?: unknown };
@@ -95,8 +97,8 @@ export async function conductDemocracy(controller: DelegateController, request:
   const fleet = controller.list();
   for (const id of agents) {
     const agent = fleet.find((item) => item.id === id);
-    if (!agent || agent.mode !== "scout" || !["idle", "paused"].includes(agent.state)) {
-      throw new Error("Only idle/paused fresh-context read-only scouts can be resumed for voting: " + id);
+    if (!agent || agent.mode !== "scout" || !["idle", "paused", "hibernated"].includes(agent.state)) {
+      throw new Error("Only idle/paused/hibernated fresh-context read-only scouts can be resumed for voting: " + id);
     }
   }
   const newScouts = voters - agents.length;

package/src/diff-inline.ts

@@ -0,0 +1,80 @@
+/** Word-level changes inside one replaced line, for intraline emphasis in /diff. */
+
+export type Span = readonly [start: number, end: number];
+
+/** Token LCS stays tiny: long or wholly rewritten lines are shown without intraline emphasis. */
+const MAX_INLINE_CELLS = 40_000;
+const TOKEN = /\w+|\s+|[^\w\s]/gu;
+
+const tokens = (text: string) => Array.from(text.matchAll(TOKEN), match => ({ text: match[0], at: match.index! }));
+
+/**
+ * Changed `[start, end)` code-unit spans of `before` and `after`. Undefined when the lines are equal,
+ * too long to compare cheaply, or share no non-whitespace token (emphasizing everything adds nothing).
+ */
+export function inlineChanges(before: string, after: string): { before: Span[]; after: Span[] } | undefined {
+  if (before === after) return undefined;
+  const a = tokens(before), b = tokens(after);
+  let start = 0;
+  while (start < a.length && start < b.length && a[start]!.text === b[start]!.text) start++;
+  let endA = a.length, endB = b.length;
+  while (endA > start && endB > start && a[endA - 1]!.text === b[endB - 1]!.text) { endA--; endB--; }
+  const n = endA - start, m = endB - start;
+  if (n * m > MAX_INLINE_CELLS) return undefined;
+  // lcs[i][j] = LCS length of a[start+i..endA) and b[start+j..endB), flattened.
+  const lcs = new Uint16Array((n + 1) * (m + 1));
+  for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
+    lcs[i * (m + 1) + j] = a[start + i]!.text === b[start + j]!.text ? lcs[(i + 1) * (m + 1) + j + 1]! + 1
+      : Math.max(lcs[(i + 1) * (m + 1) + j]!, lcs[i * (m + 1) + j + 1]!);
+  }
+  const changedA = new Uint8Array(n), changedB = new Uint8Array(m);
+  let common = /\S/.test(a.slice(0, start).map(token => token.text).join("") + a.slice(endA).map(token => token.text).join(""));
+  for (let i = 0, j = 0; i < n || j < m;) {
+    if (i < n && j < m && a[start + i]!.text === b[start + j]!.text) {
+      if (/\S/.test(a[start + i]!.text)) common = true;
+      i++; j++;
+    } else if (j < m && (i >= n || lcs[i * (m + 1) + j + 1]! >= lcs[(i + 1) * (m + 1) + j]!)) changedB[j++] = 1;
+    else changedA[i++] = 1;
+  }
+  if (!common) return undefined;
+  return { before: spans(a, start, changedA), after: spans(b, start, changedB) };
+}
+
+/** Merge consecutive changed tokens into spans; whitespace between two changes joins them. */
+function spans(list: readonly { text: string; at: number }[], offset: number, changed: Uint8Array): Span[] {
+  const result: [number, number][] = [];
+  let previous = -1;
+  for (let index = 0; index < changed.length; index++) {
+    if (!changed[index]) continue;
+    const token = list[offset + index]!;
+    let joined = previous >= 0;
+    for (let gap = previous + 1; joined && gap < index; gap++) if (/\S/.test(list[offset + gap]!.text)) joined = false;
+    if (joined) result.at(-1)![1] = token.at + token.text.length;
+    else result.push([token.at, token.at + token.text.length]);
+    previous = index;
+  }
+  return result;
+}
+
+const SGR = /\x1b\[[0-?]*[ -/]*[@-~]/y;
+const INVERSE_ON = "\x1b[7m";
+const INVERSE_OFF = "\x1b[27m";
+
+/**
+ * Insert inverse-video markers around `spans` of the visible text inside an SGR-styled string.
+ * Offsets count visible code units, so styling (syntax colours) never shifts the emphasis.
+ */
+export function emphasize(styled: string, spans: readonly Span[]): string {
+  if (!spans.length) return styled;
+  let out = "", visible = 0, span = 0, open = false;
+  for (let at = 0; at < styled.length;) {
+    SGR.lastIndex = at;
+    const escape = SGR.exec(styled);
+    if (escape) { out += escape[0]; at += escape[0].length; continue; }
+    while (span < spans.length && open && visible >= spans[span]![1]) { out += INVERSE_OFF; open = false; span++; }
+    if (span < spans.length && !open && visible >= spans[span]![0]) { out += INVERSE_ON; open = true; }
+    out += styled[at++];
+    visible++;
+  }
+  return open ? out + INVERSE_OFF : out;
+}

package/src/diff-view.ts

@@ -1,6 +1,8 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Key, matchesKey, truncateToWidth, visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
-import { coarseLineDiff, diffHunkOffsets, diffLineCount, diffRowCount, diffRowsWindow, lineDiff, MAX_REVIEW_DIFF_LINES, type ChangeTracker, type DiffOp, type DiffRow, type FileChange } from "./changes.ts";
+import { getLanguageFromPath, highlightCode, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { coarseLineDiff, diffHunkOffsets, diffLineCount, diffRowCount, diffRowsWindow, diffSplitHunkOffsets, diffSplitRowCount, diffSplitRowsWindow,
+  lineDiff, MAX_REVIEW_DIFF_LINES, type ChangeTracker, type DiffOp, type FileChange } from "./changes.ts";
+import { emphasize, inlineChanges } from "./diff-inline.ts";
 import { CHILD_BASELINE_ENV, writeChildBaseline } from "./child-baselines.ts";
 import { contentRows, optionList, sidebarWidth, splitFrame } from "./split-view.ts";
 
@@ -48,51 +50,118 @@ export function fullReviewSupported(change: FileChange): boolean {
 export const safeLine = (text: string) => text.slice(0, 4000).replace(/\t/g, "  ")
   .replace(/\x1b\][^\x07]*(?:\x07|\x1b\\)?|\x1b\[[0-?]*[ -/]*[@-~]|\x1b./g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "·");
 
+/** Optional styling hooks; tests and plain output omit them. */
+export interface DiffPaint {
+  /** Syntax colours (foreground SGR only) for one display line, or undefined to use diff colours. */
+  syntax?: (text: string) => string | undefined;
+  /** SGR background sequence that tints a changed line's text. */
+  tint?: (kind: "add" | "remove") => string;
+}
+
+/** Context sizes cycled by ←/→ (and [/]); Infinity shows whole files. */
+export const CONTEXT_STEPS = [0, 1, 3, 5, 10, 25, Infinity] as const;
+/** Split columns narrower than this fall back to unified rows. */
+export const MIN_SPLIT_WIDTH = 70;
+
+export interface DiffRenderOptions {
+  fullReview?: boolean; scroll?: number; rows?: number; unified?: boolean; ops?: readonly DiffOp[]; coarse?: boolean;
+  context?: number; wrap?: boolean; paint?: DiffPaint;
+}
+/** Rendered page plus how many logical rows it consumed (wrapping can show fewer than `rows`). */
+export interface DiffWindow { lines: string[]; shown: number; total: number }
+
+type Kind = "add" | "remove" | "context";
+const RESET = "\x1b[0m";
+const KIND_COLOR = { add: "success", remove: "error", context: "muted" } as const;
+const SIGN = { add: "+", remove: "-", context: " " } as const;
+
 /** Styled diff rows for one file, with a gutter of old/new line numbers. */
-export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string,
-  options: { fullReview?: boolean; scroll?: number; rows?: number; unified?: boolean; ops?: readonly DiffOp[]; coarse?: boolean } = {}): string[] {
+export function renderDiff(change: FileChange, width: number, fg: (color: string, text: string) => string, options: DiffRenderOptions = {}): string[] {
+  return renderDiffWindow(change, width, fg, options).lines;
+}
+
+export function renderDiffWindow(change: FileChange, width: number, fg: (color: string, text: string) => string, options: DiffRenderOptions = {}): DiffWindow {
   const large = fullReviewRequired(change);
-  if (large && (!options.fullReview || !fullReviewSupported(change))) return [
+  if (large && (!options.fullReview || !fullReviewSupported(change))) return { shown: 0, total: 0, lines: [
     fg("warning", `Summary preview · +${change.added} −${change.removed} · ${(Buffer.byteLength(change.before) + Buffer.byteLength(change.after)) / 1024 | 0} KiB`),
     fg("dim", fullReviewSupported(change) ? "Press v for a windowed full review, or keep this summary." : "Full review unavailable: preview is bounded to 100,000 combined lines."),
     fg("dim", "Older/binary/over-1 MiB files are not tracked for safe revert.")
-  ];
+  ] };
   const exact = options.ops ? change.diff : (change.diff === null ? undefined : (change.diff ?? lineDiff(change.before, change.after)));
   const ops = options.ops ?? exact ?? coarseLineDiff(change.before, change.after);
-  const rows = Math.min(options.rows ?? PREVIEW_WINDOW, PREVIEW_WINDOW);
+  const rows = Math.max(1, Math.min(options.rows ?? PREVIEW_WINDOW, PREVIEW_WINDOW));
   const scroll = Math.max(0, options.scroll ?? 0);
-  const visible = diffRowsWindow(ops, 3, scroll, rows);
-  if (!visible.length) return [fg("dim", scroll ? "End of diff." : "No textual changes.")];
+  const context = options.context ?? 3;
+  const unified = options.unified !== false;
+  const wrap = options.wrap === true;
+  const paint = options.paint ?? {};
+  const total = unified ? diffRowCount(ops, context) : diffSplitRowCount(ops, context);
+  const unifiedRows = unified ? diffRowsWindow(ops, context, scroll, rows) : [];
+  const splitRows = unified ? [] : diffSplitRowsWindow(ops, context, scroll, rows);
+  if (!unifiedRows.length && !splitRows.length) return { lines: [fg("dim", scroll ? "End of diff." : "No textual changes.")], shown: 0, total };
   const bounded = options.coarse ?? (change.diff === null || (!options.ops && exact === undefined));
-  const gutter = Math.max(3, String(Math.max(...visible.map((row) => Math.max(row.oldLine ?? 0, row.newLine ?? 0)))).length);
+  let widest = 0;
+  for (const row of unifiedRows) widest = Math.max(widest, row.oldLine ?? 0, row.newLine ?? 0);
+  for (const row of splitRows) if (row.kind === "pair") widest = Math.max(widest, row.left?.line ?? 0, row.right?.line ?? 0);
+  const gutter = Math.max(3, String(widest).length);
   const num = (value?: number) => (value ? String(value) : "").padStart(gutter);
-  if (options.unified === false) {
+
+  // Coarse replacement groups pair unrelated lines, so intraline emphasis would mislead there.
+  const style = (text: string, kind: Kind, pair: string | undefined) => {
+    const display = safeLine(text);
+    const styled = paint.syntax?.(display) ?? fg(KIND_COLOR[kind], display);
+    if (bounded || kind === "context" || pair === undefined) return styled;
+    const changes = kind === "remove" ? inlineChanges(display, safeLine(pair)) : inlineChanges(safeLine(pair), display);
+    return changes ? emphasize(styled, kind === "remove" ? changes.before : changes.after) : styled;
+  };
+  // Rail, numbers and sign, then text truncated or wrapped into the cell; continuation lines keep
+  // the rail only. Truncation emits full resets, so a tint is re-applied after each one.
+  const cell = (kind: Kind, lead: string, text: string, width: number, pair?: string): string[] => {
+    const leadWidth = visibleWidth(lead);
+    const textWidth = Math.max(1, width - leadWidth - 2);
+    const rail = kind === "context" ? " " : fg(KIND_COLOR[kind], "▌");
+    const tint = kind === "context" ? undefined : paint.tint?.(kind);
+    const styled = style(text, kind, pair);
+    return (wrap ? wrapTextWithAnsi(styled, textWidth) : [truncateToWidth(styled, textWidth, "…")]).map((body, index) => {
+      const prefix = index ? " ".repeat(leadWidth + 1) : fg("dim", lead) + fg(KIND_COLOR[kind], SIGN[kind]);
+      const content = body + " ".repeat(Math.max(0, textWidth - visibleWidth(body)));
+      return rail + prefix + (tint ? tint + content.replaceAll(RESET, RESET + tint) : content) + RESET;
+    });
+  };
+  const hunkLine = (text: string, hidden: number | undefined) => truncateToWidth(
+    (hidden ? fg("dim", `┄ ${hidden} unchanged line${hidden === 1 ? "" : "s"} ┄ `) : "") + fg("accent", text), width, "…");
+
+  const blocks: string[][] = unified
+    ? unifiedRows.map(row => row.kind === "hunk" ? [hunkLine(row.text, row.hidden)]
+      : cell(row.kind === "add" ? "add" : row.kind === "remove" ? "remove" : "context", `${num(row.oldLine)} ${num(row.newLine)} `, row.text, width, row.pair))
+    : splitRows.map(row => {
+      if (row.kind === "hunk") return [hunkLine(row.text, row.hidden)];
+      const column = Math.max(8, Math.floor((width - 3) / 2));
+      const replaced = row.left?.changed && row.right?.changed;
+      const left = row.left ? cell(row.left.changed ? "remove" : "context", num(row.left.line) + " ", row.left.text, column, replaced ? row.right!.text : undefined) : [];
+      const right = row.right ? cell(row.right.changed ? "add" : "context", num(row.right.line) + " ", row.right.text, column, replaced ? row.left!.text : undefined) : [];
+      return Array.from({ length: Math.max(left.length, right.length) }, (_, index) =>
+        (left[index] ?? " ".repeat(column)) + fg("dim", " │ ") + (right[index] ?? ""));
+    });
+  const lines: string[] = [];
+  if (bounded) lines.push(fg("warning", unified ? "Coarse preview: LCS budget exceeded; full review preserves file order but replacement groups are approximate."
+    : "Coarse preview: replacement groups are approximate."));
+  if (!unified) {
     const column = Math.max(8, Math.floor((width - 3) / 2));
-    return [
-      truncateToWidth(fg("accent", "Original"), column, "…", true) + fg("dim", " │ ") + fg("accent", "Updated"),
-      ...(bounded ? [fg("warning", "Coarse preview: replacement groups are approximate.")] : []),
-      ...visible.map(row => {
-        if (row.kind === "hunk") return fg("accent", row.text);
-        const oldText = row.kind === "add" ? "" : `${num(row.oldLine)} ${row.kind === "remove" ? "-" : " "}${safeLine(row.text)}`;
-        const newText = row.kind === "remove" ? "" : `${num(row.newLine)} ${row.kind === "add" ? "+" : " "}${safeLine(row.text)}`;
-        const left = truncateToWidth(oldText, column, "…", true);
-        const right = truncateToWidth(newText, column, "…", true);
-        return (row.kind === "remove" ? fg("error", left) : fg("muted", left)) + fg("dim", " │ ")
-          + (row.kind === "add" ? fg("success", right) : fg("muted", right));
-      })
-    ];
+    lines.push(truncateToWidth(fg("accent", "Original"), column, "…", true) + fg("dim", " │ ") + fg("accent", "Updated"));
   }
-  const rendered = visible.map((row) => {
-    if (row.kind === "hunk") return fg("accent", row.text);
-    const text = truncateToWidth(safeLine(row.text), Math.max(1, width - gutter * 2 - 4));
-    const prefix = fg("dim", `${num(row.oldLine)} ${num(row.newLine)} `);
-    if (row.kind === "add") return prefix + fg("success", "+" + text);
-    if (row.kind === "remove") return prefix + fg("error", "-" + text);
-    return prefix + fg("muted", " " + text);
-  });
-  if (bounded) rendered.unshift(fg("warning", "Coarse preview: LCS budget exceeded; full review preserves file order but replacement groups are approximate."));
-  if (change.added + change.removed > rows) rendered.push(fg("dim", `Windowed preview at row ${scroll + 1} · PgUp/PgDn or j/k`));
-  return rendered;
+  // Fill the viewport with whole logical rows; a first row taller than the viewport is clipped.
+  let used = 0, shown = 0;
+  for (const block of blocks) {
+    if (shown && used + block.length > rows) break;
+    const visible = block.slice(0, rows - used);
+    lines.push(...visible);
+    used += visible.length;
+    shown++;
+    if (used >= rows) break;
+  }
+  if (scroll > 0 || scroll + shown < total) lines.push(fg("dim", `Windowed preview · rows ${scroll + 1}–${scroll + shown} of ${total} · PgUp/PgDn`));
+  return { lines, shown, total };
 }
 
 /**
@@ -111,15 +180,54 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
     let searchMode = false;
     let fullReview = false;
     let unified = true;
+    let contextIndex = CONTEXT_STEPS.indexOf(3);
+    let wrap = false;
     let bodyRows = 0;
+    let bodyWidth = 80;
     let viewportRows = 1;
     let width = 80;
     let armed: "one" | "all" | undefined;
     let message = "";
     let layout = { top: 1, rows: 0, leftWidth: 0, bodyX: 2, footerTop: 0 };
-    let cache: { key: string; lines: string[] } | undefined;
-    let opCache: { key: string; ops: readonly DiffOp[]; hunks: number[]; rows: number; coarse: boolean } | undefined;
+    let cache: { key: string; lines: string[]; shown: number } | undefined;
+    let opCache: { key: string; ops: readonly DiffOp[]; coarse: boolean } | undefined;
+    let paintCache: { path: string; paint: DiffPaint } | undefined;
     const fg = (color: string, text: string) => theme.fg(color as never, text);
+    const context = () => CONTEXT_STEPS[contextIndex]!;
+    const contextLabel = () => Number.isFinite(context()) ? `${context()} line${context() === 1 ? "" : "s"}` : "whole file";
+    // Split columns need room; narrower panes keep the unified layout instead of unreadable halves.
+    const splitMode = () => !unified && bodyWidth >= MIN_SPLIT_WIDTH;
+    const rowLayout = () => {
+      if (!opCache) return { hunks: [] as number[], rows: 0 };
+      return splitMode()
+        ? { hunks: diffSplitHunkOffsets(opCache.ops, context()), rows: diffSplitRowCount(opCache.ops, context()) }
+        : { hunks: diffHunkOffsets(opCache.ops, context()), rows: diffRowCount(opCache.ops, context()) };
+    };
+    // Row offsets change with context and split mode; keep the hunk at the top of the viewport.
+    const relayout = (change: () => void) => {
+      const before = rowLayout().hunks;
+      let hunk = -1;
+      for (let index = 0; index < before.length && before[index]! <= scroll; index++) hunk = index;
+      change();
+      scroll = hunk >= 0 ? rowLayout().hunks[hunk] ?? 0 : 0;
+      cache = undefined;
+    };
+    const paintFor = (change: FileChange): DiffPaint => {
+      if (paintCache?.path !== change.path) {
+        const language = getLanguageFromPath(change.path);
+        const bg = (theme as { getBgAnsi?: (color: "toolSuccessBg" | "toolErrorBg") => string }).getBgAnsi?.bind(theme);
+        paintCache = { path: change.path, paint: {
+          // Per-line highlighting is bounded; very long lines, or a host without Pi's highlighter
+          // theme initialised, keep plain diff colours instead of failing the review.
+          ...(language ? { syntax: (text: string) => {
+            if (text.length > 1000) return undefined;
+            try { return highlightCode(text, language)[0]; } catch { return undefined; }
+          } } : {}),
+          ...(bg ? { tint: (kind: "add" | "remove") => bg(kind === "add" ? "toolSuccessBg" : "toolErrorBg") } : {})
+        } };
+      }
+      return paintCache.paint;
+    };
     const refresh = () => {
       changes = tracker.changes();
       cache = undefined;
@@ -136,10 +244,24 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
     const visibleChanges = () => filterChanges(changes, query).files;
     const currentChange = () => visibleChanges()[selected];
     const select = (index: number) => { selected = Math.max(0, Math.min(visibleChanges().length - 1, index)); scroll = 0; fullReview = false; cache = undefined; opCache = undefined; };
+    const windowAt = (change: FileChange, at: number) => renderDiffWindow(change, bodyWidth, fg, { fullReview, scroll: at, rows: viewportRows,
+      ops: opCache?.ops, coarse: opCache?.coarse, unified: !splitMode(), context: context(), wrap, paint: paintFor(change) });
+    // Wrapped rows vary in height: the last page starts at the first row whose tail fits the
+    // viewport. Measured only when scrolling past the cheap bound, at most one viewport of renders.
+    const lastScroll = () => {
+      const total = rowLayout().rows;
+      let at = Math.max(0, total - viewportRows);
+      const current = currentChange();
+      if (!wrap || !current) return at;
+      while (at < total - 1 && at + windowAt(current, at).shown < total) at++;
+      return at;
+    };
     const scrollBody = (delta: number) => {
-      const max = Math.max(0, (opCache?.rows ?? 0) - viewportRows);
-      scroll = Math.max(0, Math.min(max, scroll + delta)); cache = undefined;
+      const target = scroll + delta;
+      const cheap = Math.max(0, rowLayout().rows - viewportRows);
+      scroll = Math.max(0, target <= cheap ? target : Math.min(target, lastScroll())); cache = undefined;
     };
+    const page = () => Math.max(1, (wrap ? cache?.shown ?? 1 : viewportRows) - 1);
     const component = {
       invalidate() { cache = undefined; },
       handleInput(data: string) {
@@ -168,7 +290,17 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         if (data === "/") { searchMode = true; query = ""; }
         else if (data === "n" && query) select(selected + 1);
         else if (data === "N" && query) select(selected - 1);
-        else if (data === "t") { unified = !unified; cache = undefined; message = unified ? "Unified diff" : "Side-by-side diff"; }
+        else if (data === "t") {
+          relayout(() => { unified = !unified; });
+          message = unified ? "Unified diff" : bodyWidth >= MIN_SPLIT_WIDTH ? "Side-by-side diff" : `Side-by-side needs ${MIN_SPLIT_WIDTH} columns; showing unified`;
+        }
+        else if (matchesKey(data, Key.left) || data === "[") {
+          relayout(() => { contextIndex = Math.max(0, contextIndex - 1); }); message = `Context: ${contextLabel()}`;
+        }
+        else if (matchesKey(data, Key.right) || data === "]") {
+          relayout(() => { contextIndex = Math.min(CONTEXT_STEPS.length - 1, contextIndex + 1); }); message = `Context: ${contextLabel()}`;
+        }
+        else if (data === "w") { wrap = !wrap; cache = undefined; message = wrap ? "Wrapping long lines" : "Truncating long lines"; }
         else if (data === "v" && current && fullReviewRequired(current) && fullReviewSupported(current)) {
           fullReview = !fullReview; scroll = 0; cache = undefined; opCache = undefined; message = fullReview ? "Full windowed review · LCS budget may label a coarse replacement" : "Summary preview";
         }
@@ -178,16 +310,18 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         else if (data === "R" && current) { armed = "all"; message = `revert all ${changes.length} files? press R or y to confirm`; }
         else if (matchesKey(data, Key.up) || data === "k") select(selected - 1);
         else if (matchesKey(data, Key.down) || data === "j") select(selected + 1);
-        else if (matchesKey(data, Key.pageDown) || data === " ") scrollBody(Math.max(1, bodyRows - 2));
-        else if (matchesKey(data, Key.pageUp)) scrollBody(-Math.max(1, bodyRows - 2));
-        else if (data === "n" && !query && opCache?.hunks.length) {
-          scroll = opCache.hunks.find(offset => offset > scroll) ?? opCache.hunks[0]!; cache = undefined;
+        else if (matchesKey(data, Key.pageDown) || data === " ") scrollBody(page());
+        else if (matchesKey(data, Key.pageUp)) scrollBody(-page());
+        else if (data === "n" && !query && rowLayout().hunks.length) {
+          const hunks = rowLayout().hunks;
+          scroll = hunks.find(offset => offset > scroll) ?? hunks[0]!; cache = undefined;
         }
-        else if (data === "p" && opCache?.hunks.length) {
-          scroll = [...opCache.hunks].reverse().find(offset => offset < scroll) ?? opCache.hunks.at(-1)!; cache = undefined;
+        else if (data === "p" && rowLayout().hunks.length) {
+          const hunks = rowLayout().hunks;
+          scroll = [...hunks].reverse().find(offset => offset < scroll) ?? hunks.at(-1)!; cache = undefined;
         }
-        else if (data === "g") scrollBody(-Infinity);
-        else if (data === "G") scrollBody(Infinity);
+        else if (data === "g" || matchesKey(data, Key.home)) scrollBody(-Infinity);
+        else if (data === "G" || matchesKey(data, Key.end)) scrollBody(Infinity);
         tui.requestRender();
       },
       handleMouse(event: TuiMouseEvent) {
@@ -208,23 +342,24 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         width = Math.max(24, available);
         bodyRows = contentRows(7 + ACTIONS.length, 6);
         const listWidth = sidebarWidth(width, 20, 36);
-        const bodyWidth = listWidth ? width - listWidth - 6 : width - 4;
+        bodyWidth = listWidth ? width - listWidth - 6 : width - 4;
         const filtered = visibleChanges();
         const current = filtered[selected];
         if (!current) return [fg("dim", `No files match /${safeLine(query)}`), fg("dim", "Press / to edit the filter or Esc to clear it.")];
         const opKey = `${current.path}:${current.before.length}:${current.after.length}`;
         if (opCache?.key !== opKey && (!fullReviewRequired(current) || fullReview)) {
           const exact = current.diff === null ? undefined : (current.diff ?? lineDiff(current.before, current.after));
-          const coarse = exact === undefined;
-          const ops = exact ?? coarseLineDiff(current.before, current.after);
-          opCache = { key: opKey, ops, hunks: diffHunkOffsets(ops), rows: diffRowCount(ops), coarse };
+          opCache = { key: opKey, ops: exact ?? coarseLineDiff(current.before, current.after), coarse: exact === undefined };
         }
         const pathLines = wrapPath(current.path.replace(/[\x00-\x1f\x7f-\x9f]/g, char => `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`), bodyWidth);
         // Reserve wrapped path, metadata, split/coarse headers and the optional window footer.
-        viewportRows = Math.max(1, bodyRows - pathLines.length - 1 - (unified ? 0 : 1) - (opCache?.coarse ? 1 : 0) - 1);
-        scroll = Math.min(scroll, Math.max(0, (opCache?.rows ?? 0) - viewportRows));
-        const key = `${current.path}:${bodyWidth}:${bodyRows}:${viewportRows}:${unified}:${fullReview}:${scroll}`;
-        if (cache?.key !== key) cache = { key, lines: renderDiff(current, bodyWidth, fg, { fullReview, scroll, rows: viewportRows, ops: opCache?.ops, coarse: opCache?.coarse, unified }) };
+        viewportRows = Math.max(1, bodyRows - pathLines.length - 1 - (splitMode() ? 1 : 0) - (opCache?.coarse ? 1 : 0) - 1);
+        scroll = Math.min(scroll, Math.max(0, rowLayout().rows - (wrap ? 1 : viewportRows)));
+        const key = `${current.path}:${bodyWidth}:${bodyRows}:${viewportRows}:${splitMode()}:${fullReview}:${scroll}:${contextIndex}:${wrap}`;
+        if (cache?.key !== key) {
+          const page = windowAt(current, scroll);
+          cache = { key, lines: page.lines, shown: page.shown };
+        }
         // The absolute path is intentionally the first row of the right pane, even in split mode.
         const content = [...pathLines.map(path => fg("accent", path)),
           fg("dim", `${selected + 1}/${filtered.length} · ${current.status} · +${current.added} −${current.removed}`), ...cache.lines];
@@ -240,8 +375,10 @@ export async function openDiffView(ctx: ExtensionContext, tracker: ChangeTracker
         const title = `± CHANGES · ${filtered.length}/${changes.length} files · +${totals[0]} −${totals[1]}`;
         const footer = [
           ...optionList(theme, ACTIONS.map((item) => item.label), -1, ACTIONS.map((item) => item.key)),
-          fg(searchMode ? "accent" : "dim", searchMode ? `/${query} · Enter apply · Esc clear` : query ? `/${query} · n/N next match · / new search` : `${SEARCH_HINT} · n/p hunk · t split/unified · v full preview`),
-          message ? fg(armed ? "warning" : "dim", message) : fg("dim", "↑↓ file · PgUp/PgDn scroll · a accept · r revert · Esc close")
+          fg(searchMode ? "accent" : "dim", searchMode ? `/${query} · Enter apply · Esc clear`
+            : query ? `/${query} · n/N next match · / new search`
+            : `${SEARCH_HINT} · n/p hunk · t split · ←/→ context (${contextLabel()}) · w wrap${wrap ? " on" : ""} · v full`),
+          message ? fg(armed ? "warning" : "dim", message) : fg("dim", "↑↓ file · PgUp/PgDn/Home/End scroll · a accept · r revert · Esc close")
         ];
         const split = splitFrame(theme, width, title, list, content.slice(0, bodyRows), footer, bodyRows, listWidth);
         layout = split.layout;