diff --git a/.changeset/current-line-cursor.md b/.changeset/current-line-cursor.md
new file mode 100644
index 000000000..7023fed7f
--- /dev/null
+++ b/.changeset/current-line-cursor.md
@@ -0,0 +1,5 @@
+---
+"hunkdiff": minor
+---
+
+Highlight the current line and move it with `j`/`k`, use `h`/`l` to select the old or new side in split mode, and press `c` to add a note exactly where the cursor sits. Set `cursor_line` to `number` for a quieter line-number marker, or `off` to restore plain row scrolling.
diff --git a/.changeset/sunny-ads-hang.md b/.changeset/sunny-ads-hang.md
new file mode 100644
index 000000000..8318991d7
--- /dev/null
+++ b/.changeset/sunny-ads-hang.md
@@ -0,0 +1,5 @@
+---
+"hunkdiff": minor
+---
+
+Add `sidebar = "auto" | "shown" | "hidden"` configuration and CLI flags to control the sidebar in non-pager mode.
diff --git a/README.md b/README.md
index ddaf6c024..c8ff7cc09 100644
--- a/README.md
+++ b/README.md
@@ -130,9 +130,10 @@ vcs = "git"          # git, jj, sl
 watch = false
 exclude_untracked = false
 line_numbers = true
-tab_width = 4       # tab stops, 1-16
+tab_width = 4        # tab stops, 1-16
 wrap_lines = false
 menu_bar = true
+sidebar = "auto"     # "auto", "shown", "hidden"
 agent_notes = false
 prompt_save_view_preferences = true
 transparent_background = false
diff --git a/docs/keybindings.md b/docs/keybindings.md
index dcf37d7af..56ce93ff2 100644
--- a/docs/keybindings.md
+++ b/docs/keybindings.md
@@ -67,10 +67,12 @@ The built-in commands and the keys they ship with:
 | `hunk.review.jumpToBottom`          | Jump to end                              | `G`, `end`                   |
 | `hunk.review.scrollCodeLeft`        | Scroll code left (shifted scrolls fast)  | `left`, `shift+left`         |
 | `hunk.review.scrollCodeRight`       | Scroll code right (shifted scrolls fast) | `right`, `shift+right`       |
+| `hunk.review.selectOldSide`         | Select old side of current line          | `h`                          |
+| `hunk.review.selectNewSide`         | Select new side of current line          | `l`                          |
 | `hunk.view.toggleSidebar`           | Toggle sidebar                           | `s`                          |
 | `hunk.view.toggleMenuBar`           | Toggle menu bar                          | `M`                          |
 | `hunk.view.toggleHunkHeaders`       | Toggle hunk headers                      | `m`                          |
-| `hunk.view.toggleLineNumbers`       | Toggle line numbers                      | `l`                          |
+| `hunk.view.toggleLineNumbers`       | Toggle line numbers                      | _(none)_                     |
 | `hunk.view.toggleLineWrap`          | Toggle line wrapping                     | `w`                          |
 | `hunk.view.toggleAgentNotes`        | Toggle agent notes                       | `a`                          |
 | `hunk.view.toggleCopyDecorations`   | Toggle copy decorations                  | _(none)_                     |
@@ -78,6 +80,9 @@ The built-in commands and the keys they ship with:
 | `hunk.view.layoutSplit`             | Split layout                             | `1`                          |
 | `hunk.view.layoutStack`             | Stack layout                             | `2`                          |
 | `hunk.view.layoutAuto`              | Auto layout                              | `0`                          |
+| `hunk.view.cursorLineRow`           | Highlight the current row                | _(none)_                     |
+| `hunk.view.cursorLineNumber`        | Mark the current line number             | _(none)_                     |
+| `hunk.view.cursorLineOff`           | Hide the current-line marker             | _(none)_                     |
 
 Commands marked _(none)_ ship without a key: they are menu items today, and
 binding one gives it a shortcut like any other.
diff --git a/src/core/cli.test.ts b/src/core/cli.test.ts
index 33cf1bc81..e42c43b10 100644
--- a/src/core/cli.test.ts
+++ b/src/core/cli.test.ts
@@ -151,6 +151,19 @@ describe("parseCli", () => {
     });
   });
 
+  test("parses the current-line style and rejects an unknown one", async () => {
+    const parsed = await parseCli(["bun", "hunk", "diff", "--cursor-line", "number"]);
+
+    expect(parsed).toMatchObject({
+      kind: "vcs",
+      options: { cursorLine: "number" },
+    });
+
+    await expect(parseCli(["bun", "hunk", "diff", "--cursor-line", "sparkles"])).rejects.toThrow(
+      "Invalid cursor line style: sparkles",
+    );
+  });
+
   test("accepts --experimental before the review command", async () => {
     const parsed = await parseCli(["bun", "hunk", "--experimental", "diff"]);
 
@@ -178,6 +191,16 @@ describe("parseCli", () => {
     });
   });
 
+  test("parses sidebar toggles", async () => {
+    const shown = await parseCli(["bun", "hunk", "diff", "--sidebar"]);
+    const hidden = await parseCli(["bun", "hunk", "diff", "--no-sidebar"]);
+    const unset = await parseCli(["bun", "hunk", "diff"]);
+
+    expect(shown).toMatchObject({ kind: "vcs", options: { sidebar: "shown" } });
+    expect(hidden).toMatchObject({ kind: "vcs", options: { sidebar: "hidden" } });
+    expect(unset.kind === "vcs" ? unset.options.sidebar : "unset").toBeUndefined();
+  });
+
   test("parses staged git-style diff aliases", async () => {
     const staged = await parseCli(["bun", "hunk", "diff", "--staged"]);
     const cached = await parseCli(["bun", "hunk", "diff", "--cached"]);
diff --git a/src/core/cli.ts b/src/core/cli.ts
index 38efebbb9..23e174f48 100644
--- a/src/core/cli.ts
+++ b/src/core/cli.ts
@@ -4,6 +4,7 @@ import { Command, Option } from "commander";
 import type {
   CliInput,
   CommonOptions,
+  CursorLine,
   HelpCommandInput,
   LayoutMode,
   PagerCommandInput,
@@ -38,7 +39,7 @@ import { resolveCliVersion } from "./version";
 export interface CliReferenceOption {
   readonly flag: string;
   readonly description: string;
-  readonly parse?: "layout" | "positiveInt" | "tabWidth" | "collect";
+  readonly parse?: "layout" | "cursorLine" | "positiveInt" | "tabWidth" | "collect";
   readonly defaultValue?: string;
   /** Default applied directly by Commander (as opposed to a config-resolved default). */
   readonly commanderDefault?: string;
@@ -59,6 +60,11 @@ export interface CliReferenceCommand {
 /** Review flags registered on every full-screen review command. */
 export const COMMON_REVIEW_OPTIONS = [
   { flag: "--mode <mode>", description: "layout mode: auto, split, stack", parse: "layout" },
+  {
+    flag: "--cursor-line <style>",
+    description: "current-line marker: row, number, off",
+    parse: "cursorLine",
+  },
   { flag: "--theme <theme>", description: "named theme override" },
   AUXILIARY_AGENT_OPTIONS.agentContext,
   { flag: "--pager", description: "use pager-style chrome" },
@@ -75,6 +81,8 @@ export const COMMON_REVIEW_OPTIONS = [
   { flag: "--no-wrap", description: "truncate long diff lines to one row" },
   { flag: "--hunk-headers", description: "show hunk metadata rows" },
   { flag: "--no-hunk-headers", description: "hide hunk metadata rows" },
+  { flag: "--sidebar", description: "show sidebar" },
+  { flag: "--no-sidebar", description: "hide sidebar" },
   { flag: "--agent-notes", description: "show agent notes by default" },
   { flag: "--no-agent-notes", description: "hide agent notes by default" },
   { flag: "--transparent-bg", description: "let terminal background show through Hunk surfaces" },
@@ -195,6 +203,15 @@ function parseLayoutMode(value: string): LayoutMode {
   throw new Error(`Invalid layout mode: ${value}`);
 }
 
+/** Validate one requested current-line style from CLI input. */
+function parseCursorLine(value: string): CursorLine {
+  if (value === "row" || value === "number" || value === "off") {
+    return value;
+  }
+
+  throw new Error(`Invalid cursor line style: ${value}`);
+}
+
 /** Parse one required positive integer CLI value. */
 function parsePositiveInt(value: string) {
   if (!/^[1-9]\d*$/.test(value)) {
@@ -236,6 +253,7 @@ function collectRepeatedValue(value: string, previous: string[] = []) {
 function buildCommonOptions(
   options: {
     mode?: LayoutMode;
+    cursorLine?: CursorLine;
     theme?: string;
     agentContext?: string;
     pager?: boolean;
@@ -247,8 +265,10 @@ function buildCommonOptions(
   },
   argv: string[],
 ): CommonOptions {
+  const sidebarFlag = resolveBooleanFlag(argv, "--sidebar", "--no-sidebar");
   return {
     mode: options.mode,
+    cursorLine: options.cursorLine,
     theme: options.theme,
     agentContext: options.agentContext,
     pager: options.pager ? true : undefined,
@@ -266,6 +286,7 @@ function buildCommonOptions(
     tabWidth: options.tabWidth,
     wrapLines: resolveBooleanFlag(argv, "--wrap", "--no-wrap"),
     hunkHeaders: resolveBooleanFlag(argv, "--hunk-headers", "--no-hunk-headers"),
+    sidebar: sidebarFlag === undefined ? undefined : sidebarFlag ? "shown" : "hidden",
     agentNotes: resolveBooleanFlag(argv, "--agent-notes", "--no-agent-notes"),
     transparentBackground: resolveBooleanFlag(argv, "--transparent-bg", "--no-transparent-bg"),
     // Read straight from argv so the absence of the flag stays undefined rather than
@@ -281,6 +302,8 @@ function applyReferenceOption(command: Command, option: CliReferenceOption) {
   const commanderOption = new Option(option.flag, option.description);
   if (option.parse === "layout") {
     commanderOption.argParser(parseLayoutMode);
+  } else if (option.parse === "cursorLine") {
+    commanderOption.argParser(parseCursorLine);
   } else if (option.parse === "positiveInt") {
     commanderOption.argParser(parsePositiveInt);
   } else if (option.parse === "tabWidth") {
@@ -375,6 +398,7 @@ function renderCliHelp() {
     "  -x, --tab-width <columns>                tab stop width: 1-16 (default: 4)",
     "  --wrap / --no-wrap                      wrap or truncate long diff lines",
     "  --hunk-headers / --no-hunk-headers      show or hide hunk metadata rows",
+    "  --sidebar / --no-sidebar                show or hide sidebar by default",
     "  --agent-notes / --no-agent-notes        show or hide agent notes by default",
     "  --transparent-bg / --no-transparent-bg  let terminal background show through Hunk surfaces",
     "  --theme <theme>                         named theme override",
diff --git a/src/core/config.test.ts b/src/core/config.test.ts
index 205783e12..28c746727 100644
--- a/src/core/config.test.ts
+++ b/src/core/config.test.ts
@@ -79,6 +79,7 @@ describe("config persistence", () => {
         showMenuBar: false,
         showAgentNotes: true,
         copyDecorations: true,
+        cursorLine: "row",
       },
       { env: { HOME: home } },
     );
@@ -95,6 +96,7 @@ describe("config persistence", () => {
         "menu_bar = false",
         "agent_notes = true",
         "copy_decorations = true",
+        'cursor_line = "row"',
         "",
         "[custom_theme]",
         'label = "Keep me"',
@@ -133,6 +135,7 @@ describe("config persistence", () => {
       showMenuBar: true,
       showAgentNotes: true,
       copyDecorations: false,
+      cursorLine: "row",
     } as const;
 
     expect(diffPersistedViewPreferences(initial, { ...initial })).toEqual([]);
@@ -219,6 +222,43 @@ describe("config resolution", () => {
     });
   });
 
+  test("reads the current-line style from config and lets CLI flags outrank it", () => {
+    const home = createTempDir("hunk-config-home-");
+    const repo = createTempDir("hunk-config-repo-");
+    createRepo(repo);
+
+    mkdirSync(join(home, ".config", "hunk"), { recursive: true });
+    writeFileSync(join(home, ".config", "hunk", "config.toml"), 'cursor_line = "number"');
+
+    const fromConfig = resolveConfiguredCliInput(createPatchPagerInput(), {
+      cwd: repo,
+      env: { HOME: home },
+    });
+    expect(fromConfig.input.options.cursorLine).toBe("number");
+
+    const fromFlag = resolveConfiguredCliInput(createPatchPagerInput({ cursorLine: "off" }), {
+      cwd: repo,
+      env: { HOME: home },
+    });
+    expect(fromFlag.input.options.cursorLine).toBe("off");
+  });
+
+  test("falls back to the built-in current-line style when config names an unknown one", () => {
+    const home = createTempDir("hunk-config-home-");
+    const repo = createTempDir("hunk-config-repo-");
+    createRepo(repo);
+
+    mkdirSync(join(home, ".config", "hunk"), { recursive: true });
+    writeFileSync(join(home, ".config", "hunk", "config.toml"), 'cursor_line = "sparkles"');
+
+    const resolved = resolveConfiguredCliInput(createPatchPagerInput(), {
+      cwd: repo,
+      env: { HOME: home },
+    });
+
+    expect(resolved.input.options.cursorLine).toBe("row");
+  });
+
   test("starts pager mode with the menu bar hidden unless a later layer asks for it", () => {
     const home = createTempDir("hunk-config-home-");
     const repo = createTempDir("hunk-config-repo-");
@@ -263,6 +303,33 @@ describe("config resolution", () => {
     }
   });
 
+  test("resolves the sidebar preference from config, CLI flags, and the auto default", () => {
+    const home = createTempDir("hunk-config-home-");
+    const repo = createTempDir("hunk-config-repo-");
+    createRepo(repo);
+
+    const resolveSidebar = (input: CliInput) =>
+      resolveConfiguredCliInput(input, { cwd: repo, env: { HOME: home } }).input.options.sidebar;
+
+    expect(resolveSidebar(createPatchPagerInput())).toBe("auto");
+
+    mkdirSync(join(home, ".config", "hunk"), { recursive: true });
+    writeFileSync(join(home, ".config", "hunk", "config.toml"), "sidebar = false\n");
+    expect(resolveSidebar(createPatchPagerInput())).toBe("hidden");
+    // `--sidebar` outranks the config layer.
+    expect(resolveSidebar(createPatchPagerInput({ sidebar: "shown" }))).toBe("shown");
+
+    writeFileSync(join(home, ".config", "hunk", "config.toml"), 'sidebar = "shown"\n');
+    expect(resolveSidebar(createPatchPagerInput())).toBe("shown");
+
+    writeFileSync(join(home, ".config", "hunk", "config.toml"), 'sidebar = "hidden"\n');
+    expect(resolveSidebar(createPatchPagerInput())).toBe("hidden");
+
+    // Values outside the named policies fall back to the built-in default.
+    writeFileSync(join(home, ".config", "hunk", "config.toml"), 'sidebar = "always"\n');
+    expect(resolveSidebar(createPatchPagerInput())).toBe("auto");
+  });
+
   test("merges custom theme overrides from global and repo config", () => {
     const home = createTempDir("hunk-config-home-");
     const repo = createTempDir("hunk-config-repo-");
@@ -959,6 +1026,7 @@ describe("config resolution", () => {
         "tab_width = 8",
         "wrap_lines = true",
         "menu_bar = false",
+        "sidebar = true",
         "hunk_headers = false",
         "agent_notes = true",
         "copy_decorations = false",
@@ -987,6 +1055,7 @@ describe("config resolution", () => {
     expect(bootstrap.initialTabWidth).toBe(8);
     expect(bootstrap.initialWrapLines).toBe(true);
     expect(bootstrap.initialShowMenuBar).toBe(false);
+    expect(bootstrap.initialSidebar).toBe("shown");
     expect(bootstrap.initialShowHunkHeaders).toBe(false);
     expect(bootstrap.initialShowAgentNotes).toBe(true);
     expect(bootstrap.initialCopyDecorations).toBe(false);
diff --git a/src/core/config.ts b/src/core/config.ts
index 63bfa0693..6fa549acf 100644
--- a/src/core/config.ts
+++ b/src/core/config.ts
@@ -20,12 +20,14 @@ import { detectVcs, findVcsRepoRootCandidate, getDefaultVcsAdapter } from "./vcs
 import type {
   CliInput,
   CommonOptions,
+  CursorLine,
   CustomSyntaxColorsConfig,
   CustomSyntaxScopesConfig,
   ExtensionsConfig,
   LayoutMode,
   NamedCustomThemeConfig,
   PersistedViewPreferences,
+  SidebarVisibility,
   UserKeyBinding,
   VcsMode,
 } from "./types";
@@ -42,6 +44,7 @@ const DEFAULT_VIEW_PREFERENCES: PersistedViewPreferences = {
   showMenuBar: true,
   showAgentNotes: false,
   copyDecorations: false,
+  cursorLine: "row",
 };
 
 const VIEW_PREFERENCES_PROMPT_CONFIG_KEY = "prompt_save_view_preferences";
@@ -57,6 +60,7 @@ const PERSISTED_VIEW_PREFERENCE_KEYS: Array<{
   { configKey: "menu_bar", value: (preferences) => preferences.showMenuBar },
   { configKey: "agent_notes", value: (preferences) => preferences.showAgentNotes },
   { configKey: "copy_decorations", value: (preferences) => preferences.copyDecorations },
+  { configKey: "cursor_line", value: (preferences) => preferences.cursorLine },
 ];
 
 interface ConfigResolutionOptions {
@@ -142,6 +146,11 @@ function normalizeLayoutMode(value: unknown): LayoutMode | undefined {
   return value === "auto" || value === "split" || value === "stack" ? value : undefined;
 }
 
+/** Accept only the current-line styles the review stream can draw. */
+function normalizeCursorLine(value: unknown): CursorLine | undefined {
+  return value === "row" || value === "number" || value === "off" ? value : undefined;
+}
+
 /**
  * Accept any backend id a config layer names, provisionally.
  *
@@ -159,6 +168,13 @@ function normalizeVcsMode(value: unknown): VcsMode | undefined {
   return typeof value === "string" && value.trim().length > 0 ? value : undefined;
 }
 
+/** Accept the named sidebar policy, with booleans retained as compatibility aliases. */
+function normalizeSidebarVisibility(value: unknown): SidebarVisibility | undefined {
+  if (value === true) return "shown";
+  if (value === false) return "hidden";
+  return value === "auto" || value === "shown" || value === "hidden" ? value : undefined;
+}
+
 /** Accept only plain booleans from config files. */
 function normalizeBoolean(value: unknown) {
   return typeof value === "boolean" ? value : undefined;
@@ -211,6 +227,15 @@ export const CONFIG_REFERENCE_OPTIONS: readonly ConfigReferenceOption[] = [
     runtimeDefault: DEFAULT_VIEW_PREFERENCES.mode,
     description: "Choose responsive, side-by-side, or stacked diff layout.",
   },
+  {
+    key: "cursor_line",
+    property: "cursorLine",
+    type: "string",
+    accepted: "`row`, `number`, or `off`",
+    runtimeDefault: DEFAULT_VIEW_PREFERENCES.cursorLine,
+    description:
+      "Mark the current line as a full-row highlight or on its line number. `off` restores plain `j`/`k` scrolling.",
+  },
   {
     key: "vcs",
     property: "vcs",
@@ -284,6 +309,15 @@ export const CONFIG_REFERENCE_OPTIONS: readonly ConfigReferenceOption[] = [
     runtimeDefault: DEFAULT_VIEW_PREFERENCES.showMenuBar,
     description: "Show the top application menu bar.",
   },
+  {
+    key: "sidebar",
+    property: "sidebar",
+    type: "string",
+    accepted: '`"auto"`, `"shown"`, or `"hidden"`',
+    runtimeDefault: "auto",
+    description:
+      "Always show the sidebar when it fits, keep it closed, or let the responsive layout decide. Pager sessions always open with the sidebar closed.",
+  },
   {
     key: "agent_notes",
     property: "agentNotes",
@@ -802,12 +836,16 @@ function normalizeConfigReferenceValue(property: keyof CommonOptions, value: unk
   switch (property) {
     case "mode":
       return normalizeLayoutMode(value);
+    case "cursorLine":
+      return normalizeCursorLine(value);
     case "vcs":
       return normalizeVcsMode(value);
     case "theme":
       return normalizeString(value);
     case "tabWidth":
       return normalizeTabWidth(value);
+    case "sidebar":
+      return normalizeSidebarVisibility(value);
     default:
       return normalizeBoolean(value);
   }
@@ -853,6 +891,7 @@ function mergeOptions(base: CommonOptions, overrides: CommonOptions): CommonOpti
   return {
     ...base,
     mode: overrides.mode ?? base.mode,
+    cursorLine: overrides.cursorLine ?? base.cursorLine,
     vcs: overrides.vcs ?? base.vcs,
     theme: overrides.theme ?? base.theme,
     agentContext: overrides.agentContext ?? base.agentContext,
@@ -865,6 +904,7 @@ function mergeOptions(base: CommonOptions, overrides: CommonOptions): CommonOpti
     wrapLines: overrides.wrapLines ?? base.wrapLines,
     hunkHeaders: overrides.hunkHeaders ?? base.hunkHeaders,
     menuBar: overrides.menuBar ?? base.menuBar,
+    sidebar: overrides.sidebar ?? base.sidebar,
     agentNotes: overrides.agentNotes ?? base.agentNotes,
     copyDecorations: overrides.copyDecorations ?? base.copyDecorations,
     promptSaveViewPreferences:
@@ -1081,6 +1121,7 @@ export function resolveConfiguredCliInput(
     wrapLines: resolvedOptions.wrapLines ?? DEFAULT_VIEW_PREFERENCES.wrapLines,
     hunkHeaders: resolvedOptions.hunkHeaders ?? DEFAULT_VIEW_PREFERENCES.showHunkHeaders,
     menuBar: resolvedOptions.menuBar ?? DEFAULT_VIEW_PREFERENCES.showMenuBar,
+    sidebar: resolvedOptions.sidebar ?? "auto",
     agentNotes: resolvedOptions.agentNotes ?? DEFAULT_VIEW_PREFERENCES.showAgentNotes,
     copyDecorations: resolvedOptions.copyDecorations ?? DEFAULT_VIEW_PREFERENCES.copyDecorations,
     promptSaveViewPreferences: resolvedOptions.promptSaveViewPreferences ?? true,
diff --git a/src/core/loaders.ts b/src/core/loaders.ts
index df1f3c3dd..f8106e3c8 100644
--- a/src/core/loaders.ts
+++ b/src/core/loaders.ts
@@ -504,7 +504,9 @@ export async function loadAppBootstrap(
     initialWrapLines: input.options.wrapLines ?? false,
     initialShowHunkHeaders: input.options.hunkHeaders ?? true,
     initialShowMenuBar: input.options.menuBar ?? true,
+    initialSidebar: input.options.sidebar ?? "auto",
     initialShowAgentNotes: input.options.agentNotes ?? false,
     initialCopyDecorations: input.options.copyDecorations ?? false,
+    initialCursorLine: input.options.cursorLine ?? "row",
   };
 }
diff --git a/src/core/types.ts b/src/core/types.ts
index fb9842418..992194b03 100644
--- a/src/core/types.ts
+++ b/src/core/types.ts
@@ -29,6 +29,8 @@ export type {
 } from "../extension-api/types";
 
 export type LayoutMode = "auto" | "split" | "stack";
+export type CursorLine = "row" | "number" | "off";
+export type SidebarVisibility = "auto" | "shown" | "hidden";
 export type VcsMode = string;
 export type TerminalThemeMode = "light" | "dark";
 
@@ -86,6 +88,7 @@ export interface Changeset {
 
 export interface CommonOptions {
   mode?: LayoutMode;
+  cursorLine?: CursorLine;
   vcs?: VcsMode;
   theme?: string;
   agentContext?: string;
@@ -99,6 +102,7 @@ export interface CommonOptions {
   wrapLines?: boolean;
   hunkHeaders?: boolean;
   menuBar?: boolean;
+  sidebar?: SidebarVisibility;
   agentNotes?: boolean;
   copyDecorations?: boolean;
   promptSaveViewPreferences?: boolean;
@@ -147,6 +151,7 @@ export interface PersistedViewPreferences {
   showMenuBar: boolean;
   showAgentNotes: boolean;
   copyDecorations: boolean;
+  cursorLine: CursorLine;
 }
 
 export interface HelpCommandInput {
@@ -388,8 +393,10 @@ export interface AppBootstrap {
   initialWrapLines?: boolean;
   initialShowHunkHeaders?: boolean;
   initialShowMenuBar?: boolean;
+  initialSidebar?: SidebarVisibility;
   initialShowAgentNotes?: boolean;
   initialCopyDecorations?: boolean;
+  initialCursorLine?: CursorLine;
   startupNotices?: readonly StartupNotice[];
   viewPreferencesConfigPath?: string;
   /** The user's `[keybindings]` table, resolved against command defaults in App. */
diff --git a/src/ui/App.tsx b/src/ui/App.tsx
index b737bf02b..39787511d 100644
--- a/src/ui/App.tsx
+++ b/src/ui/App.tsx
@@ -15,8 +15,10 @@ import { DEFAULT_TAB_WIDTH } from "../core/tabWidth";
 import type {
   AppBootstrap,
   CliInput,
+  CursorLine,
   LayoutMode,
   PersistedViewPreferences,
+  SidebarVisibility,
   UserNoteLineTarget,
 } from "../core/types";
 import { canReloadInput } from "../core/watch";
@@ -71,6 +73,7 @@ import {
 import { buildAppMenus } from "./lib/appMenus";
 import { buildExtensionAppCommands, extensionCommandKeyDefaults } from "./lib/extensionCommands";
 import { createGuardedReviewNavigation } from "./lib/extensionNavigation";
+import type { LineCursor } from "./lib/lineCursors";
 import { buildExtensionReviewSelection } from "./lib/extensionSelection";
 import { useFileViewLayouts } from "./fileViews/useFileViews";
 import type { FileViewRowFailure } from "./components/panes/FileView";
@@ -225,6 +228,7 @@ export function App({
   const [wrapLines, setWrapLines] = useState(bootstrap.initialWrapLines ?? false);
   const [copyDecorations, setCopyDecorations] = useState(bootstrap.initialCopyDecorations ?? false);
   const [codeHorizontalOffset, setCodeHorizontalOffset] = useState(0);
+  const [cursorLine, setCursorLine] = useState<CursorLine>(bootstrap.initialCursorLine ?? "row");
   const [showHunkHeaders, setShowHunkHeaders] = useState(bootstrap.initialShowHunkHeaders ?? true);
   const [showMenuBar, setShowMenuBar] = useState(bootstrap.initialShowMenuBar ?? true);
   const [themeSelectorState, setThemeSelectorState] = useState<ThemeSelectorState>({
@@ -232,8 +236,9 @@ export function App({
     selectedIndex: 0,
     previewThemeId: null,
   });
-  const [sidebarVisible, setSidebarVisible] = useState(() => !pagerMode);
-  const [forceSidebarOpen, setForceSidebarOpen] = useState(false);
+  const [sidebarState, setSidebarState] = useState<SidebarVisibility>(() =>
+    pagerMode ? "hidden" : (bootstrap.initialSidebar ?? "auto"),
+  );
   const [showHelp, setShowHelp] = useState(false);
   const [showAgentSkill, setShowAgentSkill] = useState(false);
   const [saveConfigPromptOpen, setSaveConfigPromptOpen] = useState(false);
@@ -296,9 +301,11 @@ export function App({
       showMenuBar,
       showAgentNotes,
       copyDecorations,
+      cursorLine,
     }),
     [
       copyDecorations,
+      cursorLine,
       layoutMode,
       showAgentNotes,
       showHunkHeaders,
@@ -335,8 +342,10 @@ export function App({
   // App computes layout geometry below this hook call, so the controller reads
   // the current values through a ref instead of a render-time parameter.
   const noteGeometryRef = useRef<AgentNoteGeometrySnapshot | null>(null);
+  const [lineCursors, setLineCursors] = useState<LineCursor[]>([]);
   const review = useReviewController({
     files: reviewFiles,
+    lineCursors,
     noteGeometry: noteGeometryRef,
     stmlEnabled,
   });
@@ -862,7 +871,11 @@ export function App({
   const responsiveLayout = resolveResponsiveLayout(layoutMode, terminal.width);
   const canForceShowSidebar = bodyWidth >= SIDEBAR_MIN_WIDTH + DIVIDER_WIDTH + DIFF_MIN_WIDTH;
   const sidebarAreaVisible =
-    sidebarVisible && (responsiveLayout.showSidebar || (forceSidebarOpen && canForceShowSidebar));
+    sidebarState === "auto"
+      ? responsiveLayout.showSidebar
+      : sidebarState === "shown" && canForceShowSidebar;
+  const openSidebarState: SidebarVisibility =
+    !responsiveLayout.showSidebar && canForceShowSidebar ? "shown" : "auto";
   const resolvedLayout = responsiveLayout.layout;
   const reportedLayoutRef = useRef<string | undefined>(undefined);
   useEffect(() => {
@@ -904,12 +917,10 @@ export function App({
   const renderSidebar = sidebarLayout.left.length + sidebarLayout.right.length > 0;
   const diffPaneWidth = Math.max(DIFF_MIN_WIDTH, bodyWidth - sidebarLayout.totalWidth);
   const diffContentWidth = Math.max(12, diffPaneWidth - 2);
-  // Mirrors toggleSidebar's reveal half: visible again, forced open when the
-  // responsive layout alone would keep it hidden and the terminal has room.
+  // Mirrors toggleSidebar's reveal half, for extensions opening a sidebar view.
   revealSidebarAreaRef.current = () => {
-    setSidebarVisible(true);
-    if (!responsiveLayout.showSidebar && canForceShowSidebar) {
-      setForceSidebarOpen(true);
+    if (!sidebarAreaVisible) {
+      setSidebarState(openSidebarState);
     }
   };
   // Publish the live note geometry for daemon-driven markup validation; the
@@ -1044,6 +1055,16 @@ export function App({
     diffScrollRef.current?.scrollBy(delta, unit);
   };
 
+  /** Step one line: move the current line, or scroll the viewport when there is no marker. */
+  const stepDiffLine = (delta: number) => {
+    if (cursorLine === "off" || !review.lineCursor) {
+      scrollDiff(delta, "step");
+      return;
+    }
+
+    review.moveLineCursor(delta);
+  };
+
   const maxCodeHorizontalOffset = useMemo(() => {
     // Wrapped rows never consume the horizontal offset. Avoid scanning every code line—especially
     // long Unicode lines—until nowrap mode actually needs a global horizontal extent.
@@ -1209,21 +1230,7 @@ export function App({
 
   /** Toggle the sidebar, forcing it open on narrower layouts when the app can still fit both panes. */
   const toggleSidebar = () => {
-    if (sidebarVisible && (responsiveLayout.showSidebar || forceSidebarOpen)) {
-      setSidebarVisible(false);
-      setForceSidebarOpen(false);
-      return;
-    }
-
-    if (sidebarVisible && !responsiveLayout.showSidebar) {
-      if (canForceShowSidebar) {
-        setForceSidebarOpen(true);
-      }
-      return;
-    }
-
-    setSidebarVisible(true);
-    setForceSidebarOpen(!responsiveLayout.showSidebar && canForceShowSidebar);
+    setSidebarState(sidebarAreaVisible ? "hidden" : openSidebarState);
   };
 
   /** Toggle visibility of hunk metadata rows without changing the actual diff lines. */
@@ -1547,17 +1554,20 @@ export function App({
   const startUserNote = useCallback(
     (fileId?: string, hunkIndex?: number, target?: UserNoteLineTarget) => {
       const hoverTarget = fileId === undefined ? activeAddNoteTarget : null;
+      const keyboardTarget =
+        hoverTarget ?? (fileId === undefined && cursorLine !== "off" ? review.lineCursor : null);
       const draft = review.startUserNote(
-        fileId ?? hoverTarget?.fileId,
-        hunkIndex ?? hoverTarget?.hunkIndex,
-        target ?? hoverTarget?.target,
+        fileId ?? keyboardTarget?.fileId,
+        hunkIndex ?? keyboardTarget?.hunkIndex,
+        target ?? keyboardTarget?.target,
+        { preserveViewport: fileId !== undefined || hoverTarget !== null },
       );
       if (draft) {
         setActiveAddNoteTarget(null);
         setFocusArea("note");
       }
     },
-    [activeAddNoteTarget, review.startUserNote],
+    [activeAddNoteTarget, cursorLine, review.lineCursor, review.startUserNote],
   );
 
   /** Mark the inline draft note textarea as the active keyboard input. */
@@ -1686,6 +1696,13 @@ export function App({
       resolvedKeys: resolvedCommandKeys,
       scrollCodeHorizontally,
       scrollDiff,
+      stepDiffLine,
+      selectCursorLine: setCursorLine,
+      selectLineCursorSide: (side) => {
+        if (resolvedLayout === "split" && cursorLine !== "off") {
+          review.selectLineCursorSide(side);
+        }
+      },
       selectLayoutMode,
       startUserNote: () => startUserNote(),
       toggleAgentNotes,
@@ -1753,6 +1770,7 @@ export function App({
   // hints and the checkbox state have to stay live.
   const menus = buildAppMenus({
     commands: appCommands,
+    cursorLine,
     extensionCommands: extensionAppCommands.commands,
     fileViewEntries: selectedFileViewEntries,
     fileViewApplyAllLabel: selectedFileViewBulkTarget
@@ -2034,6 +2052,9 @@ export function App({
           layoutToggleRequestId={layoutToggleRequestId}
           selectedFileTopAlignRequestId={review.selectedFileTopAlignRequestId}
           selectedHunkRevealRequestId={review.selectedHunkRevealRequestId}
+          cursorLine={cursorLine}
+          lineCursor={review.lineCursor}
+          lineCursorRevealRequestId={review.lineCursorRevealRequestId}
           theme={activeTheme}
           width={diffPaneWidth}
           onActiveAddNoteAffordanceChange={setActiveAddNoteTarget}
@@ -2054,6 +2075,8 @@ export function App({
           onViewportCenteredHunkChange={(fileId, hunkIndex) =>
             review.selectHunk(fileId, hunkIndex, { preserveViewport: true })
           }
+          onLineCursorsChange={setLineCursors}
+          onViewportLineCursorChange={review.anchorLineCursor}
         />
 
         {sidebarLayout.right.map((pane, index) => {
diff --git a/src/ui/AppHost.cursor-line.test.tsx b/src/ui/AppHost.cursor-line.test.tsx
new file mode 100644
index 000000000..dfbafabd0
--- /dev/null
+++ b/src/ui/AppHost.cursor-line.test.tsx
@@ -0,0 +1,217 @@
+import { describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import type { CursorLine } from "../core/types";
+import { createTestVcsAppBootstrap } from "../../test/helpers/app-bootstrap";
+import { createTestDiffFile, lines } from "../../test/helpers/diff-helpers";
+import { AppHost } from "./AppHost";
+
+const BEFORE = lines(
+  "const alpha = 1;",
+  "const beta = 2;",
+  "const gamma = 3;",
+  "const delta = 4;",
+  "const epsilon = 5;",
+);
+const AFTER = lines(
+  "const alpha = 1;",
+  "const beta = 22222;",
+  "const gamma = 3;",
+  "const delta = 4;",
+  "const epsilon = 5;",
+);
+
+async function flush(setup: Awaited<ReturnType<typeof testRender>>) {
+  await act(async () => {
+    await setup.renderOnce();
+    await Bun.sleep(0);
+    await setup.renderOnce();
+  });
+}
+
+function createCursorLineBootstrap(
+  cursorLine: CursorLine,
+  initialMode: "split" | "stack" = "stack",
+) {
+  return {
+    ...createTestVcsAppBootstrap({
+      files: [
+        createTestDiffFile({
+          id: "s",
+          path: "sample.ts",
+          before: BEFORE,
+          after: AFTER,
+          context: 3,
+        }),
+      ],
+      initialMode,
+    }),
+    initialCursorLine: cursorLine,
+  };
+}
+
+/** Read the background the review stream painted across one rendered code row. */
+function rowBackground(setup: Awaited<ReturnType<typeof testRender>>, needle: string) {
+  const frame = setup.captureSpans();
+  for (const line of frame.lines) {
+    const text = line.spans.map((span) => span.text).join("");
+    if (!text.includes(needle)) {
+      continue;
+    }
+
+    // The widest painted run is the code content, not the rail or the line-number gutter.
+    const widest = line.spans
+      .filter((span) => span.text.trim().length > 0)
+      .sort((left, right) => right.text.length - left.text.length)[0];
+    if (widest) {
+      return { r: widest.bg.r, g: widest.bg.g, b: widest.bg.b };
+    }
+  }
+
+  throw new Error(`No rendered row contained ${JSON.stringify(needle)}.`);
+}
+
+/** Read the background painted behind one rendered row's line-number gutter. */
+function gutterBackground(setup: Awaited<ReturnType<typeof testRender>>, needle: string) {
+  const frame = setup.captureSpans();
+  for (const line of frame.lines) {
+    const text = line.spans.map((span) => span.text).join("");
+    if (!text.includes(needle)) {
+      continue;
+    }
+
+    const gutter = line.spans.find((span) => /\d/.test(span.text));
+    if (gutter) {
+      return { r: gutter.bg.r, g: gutter.bg.g, b: gutter.bg.b };
+    }
+  }
+
+  throw new Error(`No rendered gutter for ${JSON.stringify(needle)}.`);
+}
+
+async function renderCursorLineApp(
+  cursorLine: CursorLine,
+  initialMode: "split" | "stack" = "stack",
+) {
+  const setup = await testRender(
+    <AppHost bootstrap={createCursorLineBootstrap(cursorLine, initialMode) as never} />,
+    { width: 200, height: 16 },
+  );
+  await flush(setup);
+  await act(async () => {
+    await Bun.sleep(60);
+    await setup.renderOnce();
+  });
+  return setup;
+}
+
+describe("current line highlight", () => {
+  test("marks the current row apart from the rows around it", async () => {
+    const setup = await renderCursorLineApp("row");
+
+    try {
+      expect(rowBackground(setup, "alpha = 1")).not.toEqual(rowBackground(setup, "gamma = 3"));
+      expect(rowBackground(setup, "gamma = 3")).toEqual(rowBackground(setup, "delta = 4"));
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("keeps added and removed lines telling themselves apart under the highlight", async () => {
+    const setup = await renderCursorLineApp("row");
+
+    try {
+      await act(async () => {
+        await setup.mockInput.typeText("j");
+      });
+      await flush(setup);
+      const removed = rowBackground(setup, "beta = 2;");
+      expect(removed.r).toBeGreaterThan(removed.g);
+
+      await act(async () => {
+        await setup.mockInput.typeText("j");
+      });
+      await flush(setup);
+      const added = rowBackground(setup, "beta = 22222");
+      expect(added.g).toBeGreaterThan(added.r);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("lifts added and removed rows as far as it lifts context rows", async () => {
+    const marked = await renderCursorLineApp("row");
+    const plain = await renderCursorLineApp("off");
+
+    /** Compare one row's marked and unmarked paint the way a reader perceives it. */
+    const lift = (needle: string) => {
+      const a = rowBackground(marked, needle);
+      const b = rowBackground(plain, needle);
+      return Math.abs(a.r + a.g + a.b - (b.r + b.g + b.b));
+    };
+
+    try {
+      for (let step = 0; step < 2; step += 1) {
+        await act(async () => {
+          await marked.mockInput.typeText("j");
+        });
+        await flush(marked);
+      }
+
+      const addedLift = lift("beta = 22222");
+      const contextLift = lift("alpha = 1");
+      expect(addedLift).toBeGreaterThan(0.1);
+      expect(addedLift).toBeGreaterThan(contextLift * 0.5);
+    } finally {
+      await act(async () => {
+        marked.renderer.destroy();
+        plain.renderer.destroy();
+      });
+    }
+  });
+
+  test("number style marks the gutter without repainting the code", async () => {
+    const setup = await renderCursorLineApp("number");
+    const plain = await renderCursorLineApp("off");
+
+    try {
+      expect(rowBackground(setup, "alpha = 1")).toEqual(rowBackground(plain, "alpha = 1"));
+      expect(gutterBackground(setup, "alpha = 1")).not.toEqual(
+        gutterBackground(plain, "alpha = 1"),
+      );
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+        plain.renderer.destroy();
+      });
+    }
+  });
+
+  test("marks both halves of a split context row", async () => {
+    const setup = await renderCursorLineApp("row", "split");
+
+    try {
+      expect(rowBackground(setup, "alpha = 1")).not.toEqual(rowBackground(setup, "gamma = 3"));
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("off style leaves every row painted the same", async () => {
+    const setup = await renderCursorLineApp("off");
+
+    try {
+      expect(rowBackground(setup, "alpha = 1")).toEqual(rowBackground(setup, "gamma = 3"));
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+});
diff --git a/src/ui/AppHost.file-views.test.tsx b/src/ui/AppHost.file-views.test.tsx
index a8e93672d..3f01ff73c 100644
--- a/src/ui/AppHost.file-views.test.tsx
+++ b/src/ui/AppHost.file-views.test.tsx
@@ -328,4 +328,48 @@ describe("AppHost file views", () => {
       });
     }
   });
+
+  test("steps the current line through the rows an alternate presentation renders", async () => {
+    const { extension, root } = copyJsxFileViewExtension();
+    const extensions = await loadStartupExtensions({
+      cliExtensionPaths: [extension],
+      cwd: root,
+      env: { XDG_CONFIG_HOME: root } as NodeJS.ProcessEnv,
+      extensions: { enabled: true, extensionConfigs: {}, paths: [], repoPaths: [] },
+    });
+    expect(extensions.issues).toEqual([]);
+
+    const bootstrap = createTestVcsAppBootstrap({
+      changesetId: "changeset:jsx-runtime-proof",
+      files: [createTwoHunkFile()],
+      initialMode: "stack",
+      inputMode: "stack",
+      vcsOptions: { extensionPaths: [extension] },
+    });
+    bootstrap.extensions = extensions;
+
+    const setup = await testRender(<AppHost bootstrap={bootstrap} onQuit={() => {}} />, {
+      width: 120,
+      height: 24,
+    });
+
+    try {
+      await waitForFrame(setup, (frame) => frame.includes("runtime-proof.ts"));
+      await act(async () => {
+        await setup.mockInput.pressKey("F8");
+      });
+      let frame = await waitForFrame(setup, (nextFrame) => nextFrame.includes("▶ Hunk 1"));
+      expect(frame).not.toContain("▶ Hunk 2");
+
+      await act(async () => {
+        await setup.mockInput.typeText("j");
+      });
+      frame = await waitForFrame(setup, (nextFrame) => nextFrame.includes("▶ Hunk 2"));
+      expect(frame).not.toContain("▶ Hunk 1");
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
 });
diff --git a/src/ui/AppHost.interactions.test.tsx b/src/ui/AppHost.interactions.test.tsx
index 43c780a8e..29e565dd3 100644
--- a/src/ui/AppHost.interactions.test.tsx
+++ b/src/ui/AppHost.interactions.test.tsx
@@ -680,7 +680,7 @@ describe("App interactions", () => {
     }
   }, 20_000);
 
-  test("keyboard shortcuts toggle notes, line numbers, and hunk metadata", async () => {
+  test("keyboard shortcuts toggle notes and hunk metadata", async () => {
     const setup = await testRender(<AppHost bootstrap={createSingleFileBootstrap()} />, {
       width: 240,
       height: 24,
@@ -706,15 +706,6 @@ describe("App interactions", () => {
       frame = setup.captureCharFrame();
       expect(frame).not.toContain("Annotation for alpha.ts");
 
-      await act(async () => {
-        await setup.mockInput.typeText("l");
-      });
-      await flush(setup);
-
-      frame = setup.captureCharFrame();
-      expect(frame).not.toContain("1 - export const alpha = 1;");
-      expect(frame).toContain("- export const alpha = 1;");
-
       await act(async () => {
         await setup.mockInput.typeText("m");
       });
@@ -722,7 +713,7 @@ describe("App interactions", () => {
 
       frame = setup.captureCharFrame();
       expect(frame).not.toContain("@@ -1,1 +1,2 @@");
-      expect(frame).toContain("- export const alpha = 1;");
+      expect(frame).toContain("1 - export const alpha = 1;");
     } finally {
       await act(async () => {
         setup.renderer.destroy();
@@ -1446,7 +1437,7 @@ describe("App interactions", () => {
       expect(frame).toContain("Why prefs.ts changed");
       expect(frame).not.toContain("@@ -1,1 +1,2 @@");
       expect(frame).not.toContain("1 - export const message");
-      expect(frame.indexOf("Agent note - prefs.ts R2")).toBeLessThan(
+      expect(frame.indexOf("Agent note - prefs.ts R2")).toBeGreaterThan(
         frame.indexOf("export const added = true;"),
       );
     } finally {
@@ -1902,7 +1893,7 @@ describe("App interactions", () => {
       expect(initialFrame).not.toContain("line08");
 
       let frame = initialFrame;
-      for (let index = 0; index < 24; index += 1) {
+      for (let index = 0; index < 48; index += 1) {
         await act(async () => {
           await setup.mockInput.pressArrow("down");
         });
@@ -1916,7 +1907,7 @@ describe("App interactions", () => {
       expect(frame).toContain("line08");
       expect(frame).not.toContain("line01");
 
-      for (let index = 0; index < 12; index += 1) {
+      for (let index = 0; index < 32; index += 1) {
         await act(async () => {
           await setup.mockInput.pressArrow("up");
         });
@@ -1936,10 +1927,13 @@ describe("App interactions", () => {
   });
 
   test("the first down-arrow step still advances content under the always-pinned file header above a collapsed gap", async () => {
-    const setup = await testRender(<AppHost bootstrap={createCollapsedTopBootstrap()} />, {
-      width: 220,
-      height: 10,
-    });
+    const setup = await testRender(
+      <AppHost bootstrap={{ ...createCollapsedTopBootstrap(), initialCursorLine: "off" }} />,
+      {
+        width: 220,
+        height: 10,
+      },
+    );
 
     try {
       await flush(setup);
@@ -2041,7 +2035,7 @@ describe("App interactions", () => {
       expect(initialFrame).not.toContain("line08");
 
       let frame = initialFrame;
-      for (let index = 0; index < 12; index += 1) {
+      for (let index = 0; index < 32; index += 1) {
         await act(async () => {
           await setup.mockInput.pressArrow("down");
         });
@@ -2055,7 +2049,7 @@ describe("App interactions", () => {
       expect(frame).toContain("line08");
       expect(frame).not.toContain("line01");
 
-      for (let index = 0; index < 12; index += 1) {
+      for (let index = 0; index < 32; index += 1) {
         await act(async () => {
           await setup.mockInput.pressArrow("up");
         });
diff --git a/src/ui/AppHost.sidebar-visibility.test.tsx b/src/ui/AppHost.sidebar-visibility.test.tsx
new file mode 100644
index 000000000..1a0dd4f14
--- /dev/null
+++ b/src/ui/AppHost.sidebar-visibility.test.tsx
@@ -0,0 +1,118 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { testRender } from "@opentui/react/test-utils";
+import { act } from "react";
+import type { AppBootstrap, SidebarVisibility } from "../core/types";
+import { createTestVcsAppBootstrap } from "../../test/helpers/app-bootstrap";
+import { createTestDiffFile as buildTestDiffFile, lines } from "../../test/helpers/diff-helpers";
+
+const { AppHost } = await import("./AppHost");
+
+/** Wide enough for the responsive layout to show the sidebar on its own. */
+const WIDE = { width: 240, height: 24 };
+/** Narrower than the full viewport, so `auto` hides the sidebar but both panes still fit. */
+const MEDIUM = { width: 180, height: 24 };
+// Default sidebar width (34) plus the body's 1-column left padding puts the divider at column 35.
+const SIDEBAR_DIVIDER_COLUMN = 35;
+// A stable mid-height row that always falls inside the sidebar/divider band.
+const PROBE_ROW = 10;
+
+function createSidebarBootstrap(initialSidebar?: SidebarVisibility): AppBootstrap {
+  return {
+    ...createTestVcsAppBootstrap({
+      changesetId: "changeset:sidebar-visibility",
+      initialMode: "split",
+      files: [
+        buildTestDiffFile({
+          after: lines("export const a = 10;"),
+          agent: false,
+          before: lines("export const a = 1;"),
+          context: 3,
+          id: "alpha",
+          path: "src/alpha.ts",
+        }),
+      ],
+    }),
+    initialSidebar,
+  };
+}
+
+/** Drive one or two render passes so pending state commits land before assertions. */
+async function flush(setup: Awaited<ReturnType<typeof testRender>>) {
+  await act(async () => {
+    await setup.renderOnce();
+    await Bun.sleep(0);
+    await setup.renderOnce();
+  });
+}
+
+/** Whether the sidebar/diff divider sits at its default column on the probe row. */
+function sidebarVisible(setup: Awaited<ReturnType<typeof testRender>>) {
+  const row = setup.captureCharFrame().split("\n")[PROBE_ROW] ?? "";
+  return row.indexOf("│") === SIDEBAR_DIVIDER_COLUMN;
+}
+
+let setup: Awaited<ReturnType<typeof testRender>> | null = null;
+
+beforeEach(() => {
+  setup = null;
+});
+
+afterEach(() => {
+  setup?.renderer.destroy();
+  setup = null;
+});
+
+describe("AppHost sidebar visibility preference", () => {
+  test("auto shows the sidebar on a full-width viewport", async () => {
+    setup = await testRender(<AppHost bootstrap={createSidebarBootstrap("auto")} />, WIDE);
+    await flush(setup);
+
+    expect(sidebarVisible(setup)).toBe(true);
+  });
+
+  test("auto hides the sidebar below the full-width viewport", async () => {
+    setup = await testRender(<AppHost bootstrap={createSidebarBootstrap("auto")} />, MEDIUM);
+    await flush(setup);
+
+    expect(sidebarVisible(setup)).toBe(false);
+  });
+
+  test("the toggle forces the sidebar open where auto hides it", async () => {
+    setup = await testRender(<AppHost bootstrap={createSidebarBootstrap("auto")} />, MEDIUM);
+    await flush(setup);
+    expect(sidebarVisible(setup)).toBe(false);
+
+    await act(async () => {
+      setup!.mockInput.pressKey("s");
+    });
+    await flush(setup);
+    expect(sidebarVisible(setup)).toBe(true);
+
+    // A second press closes it again rather than returning to the responsive default.
+    await act(async () => {
+      setup!.mockInput.pressKey("s");
+    });
+    await flush(setup);
+    expect(sidebarVisible(setup)).toBe(false);
+  });
+
+  test("shown displays the sidebar where auto would hide it", async () => {
+    setup = await testRender(<AppHost bootstrap={createSidebarBootstrap("shown")} />, MEDIUM);
+    await flush(setup);
+
+    expect(sidebarVisible(setup)).toBe(true);
+  });
+
+  test("hidden starts the sidebar closed but leaves the toggle working", async () => {
+    setup = await testRender(<AppHost bootstrap={createSidebarBootstrap("hidden")} />, WIDE);
+    await flush(setup);
+    expect(sidebarVisible(setup)).toBe(false);
+
+    await act(async () => {
+      setup!.mockInput.pressKey("s");
+    });
+    await flush(setup);
+
+    expect(sidebarVisible(setup)).toBe(true);
+  });
+});
diff --git a/src/ui/components/panes/DiffPane.tsx b/src/ui/components/panes/DiffPane.tsx
index 301d42043..37f51f278 100644
--- a/src/ui/components/panes/DiffPane.tsx
+++ b/src/ui/components/panes/DiffPane.tsx
@@ -16,12 +16,15 @@ import {
 import { DEFAULT_TAB_WIDTH } from "../../../core/tabWidth";
 import type {
   AgentAnnotation,
+  CursorLine,
   DiffFile,
   LayoutMode,
   UserNoteLineTarget,
 } from "../../../core/types";
+import type { LineCursor } from "../../lib/lineCursors";
 import type { FileSourceStatus } from "../../diff/expandCollapsedRows";
 import type { ActiveAddNoteAffordance } from "../../diff/PierreDiffView";
+import type { CursorHighlight } from "../../diff/renderRows";
 import type { DraftReviewNote } from "../../hooks/useReviewController";
 import {
   alwaysShowReviewNote,
@@ -32,7 +35,14 @@ import {
   computeRapidScrollOverscanRows,
   RAPID_SCROLL_OVERSCAN_IDLE_MS,
 } from "../../lib/adaptiveScrollOverscan";
-import { computeHunkRevealScrollTop } from "../../lib/hunkScroll";
+import { computeHunkRevealScrollTop, computeLineRevealScrollTop } from "../../lib/hunkScroll";
+import { inlineNoteStableKey } from "../../diff/reviewRenderPlan";
+import {
+  buildLineCursors,
+  clampLineCursorToViewport,
+  EMPTY_LINE_CURSORS,
+  type LineCursorBoundsLookup,
+} from "../../lib/lineCursors";
 import {
   measureDiffSectionGeometry,
   type DiffSectionGeometry,
@@ -195,6 +205,9 @@ export function DiffPane({
   scrollRef,
   selectedFileId,
   selectedHunkIndex,
+  cursorLine = "off",
+  lineCursor = null,
+  lineCursorRevealRequestId = 0,
   scrollToNote = false,
   draftNote = null,
   draftNoteFocused = false,
@@ -232,7 +245,9 @@ export function DiffPane({
   onScrollCodeHorizontally = () => {},
   onSelectFile,
   onToggleGap = NOOP_TOGGLE_GAP,
+  onLineCursorsChange,
   onViewportCenteredHunkChange,
+  onViewportLineCursorChange,
 }: {
   codeHorizontalOffset?: number;
   diffContentWidth: number;
@@ -246,6 +261,9 @@ export function DiffPane({
   scrollRef: RefObject<ScrollBoxRenderable | null>;
   selectedFileId?: string;
   selectedHunkIndex: number;
+  cursorLine?: CursorLine;
+  lineCursor?: LineCursor | null;
+  lineCursorRevealRequestId?: number;
   scrollToNote?: boolean;
   draftNote?: DraftReviewNote | null;
   draftNoteFocused?: boolean;
@@ -285,7 +303,9 @@ export function DiffPane({
   onScrollCodeHorizontally?: (delta: number) => void;
   onSelectFile: (fileId: string) => void;
   onToggleGap?: (fileId: string, gapKey: string) => void;
+  onLineCursorsChange?: (cursors: LineCursor[]) => void;
   onViewportCenteredHunkChange?: (fileId: string, hunkIndex: number) => void;
+  onViewportLineCursorChange?: (cursor: LineCursor) => void;
 }) {
   const renderTopChrome = showTopChrome ?? !pagerMode;
   const renderer = useRenderer();
@@ -535,7 +555,9 @@ export function DiffPane({
   const previousFilesRef = useRef<DiffFile[]>(files);
   const previousLayoutRef = useRef(layout);
   const previousWrapLinesRef = useRef(wrapLines);
-  const previousDraftNoteIdRef = useRef(draftNote?.id ?? null);
+  const draftNoteId = draftNote?.id ?? null;
+  const draftNoteFileId = draftNote?.fileId ?? null;
+  const previousDraftNoteIdRef = useRef(draftNoteId);
   const previousSelectedFileTopAlignRequestIdRef = useRef(selectedFileTopAlignRequestId);
   const previousLayoutToggleRequestIdRef = useRef(layoutToggleRequestId);
   const previousSelectedHunkRevealRequestIdRef = useRef(selectedHunkRevealRequestId);
@@ -801,6 +823,41 @@ export function DiffPane({
     [estimatedBodyHeights, files, sectionHeaderHeights],
   );
   const totalContentHeight = fileSectionLayouts[fileSectionLayouts.length - 1]?.sectionBottom ?? 0;
+  const fileSectionIndexById = useMemo(
+    () => buildFileSectionIndexById(fileSectionLayouts),
+    [fileSectionLayouts],
+  );
+
+  const lineCursors = useMemo(
+    // Nothing reads the stops while the marker is off, and enumerating them costs one object per
+    // rendered row of the whole changeset every time geometry is remeasured.
+    () => (cursorLine === "off" ? EMPTY_LINE_CURSORS : buildLineCursors(files, sectionGeometry)),
+    [cursorLine, files, sectionGeometry],
+  );
+  /** Locate one measured row in whole-stream rows, addressed by its file and plan anchor. */
+  const rowBoundsInStream = useCallback(
+    (fileId: string, stableKey: string) => {
+      const sectionIndex = fileSectionIndexById.get(fileId);
+      if (sectionIndex === undefined) {
+        return undefined;
+      }
+
+      const section = fileSectionLayouts[sectionIndex];
+      const bounds = sectionGeometry[sectionIndex]?.rowBoundsByStableKey.get(stableKey);
+      return section && bounds
+        ? { top: section.bodyTop + bounds.top, height: bounds.height }
+        : undefined;
+    },
+    [fileSectionIndexById, fileSectionLayouts, sectionGeometry],
+  );
+  const lineCursorBoundsOf = useCallback<LineCursorBoundsLookup>(
+    (cursor) => rowBoundsInStream(cursor.fileId, cursor.stableKey),
+    [rowBoundsInStream],
+  );
+
+  useEffect(() => {
+    onLineCursorsChange?.(lineCursors);
+  }, [lineCursors, onLineCursorsChange]);
 
   // Read the live scroll box position during render so pinned-header ownership flips
   // immediately after imperative scrolls instead of waiting for the polled viewport snapshot.
@@ -866,6 +923,20 @@ export function DiffPane({
     return resolveCopySelectionSide(copySelectionDrag.anchor.column, layout, diffContentWidth);
   }, [copySelectionDrag, diffContentWidth, layout]);
 
+  // One object per cursor move, so the section and row memos below only see a new reference when
+  // the current line actually moves.
+  const cursorHighlight = useMemo(
+    () =>
+      cursorLine === "off" || !lineCursor
+        ? undefined
+        : ({
+            stableKey: lineCursor.stableKey,
+            style: cursorLine,
+            side: lineCursor.target.side,
+          } satisfies CursorHighlight),
+    [cursorLine, lineCursor],
+  );
+
   const copySelectedRowKeysByFile = useMemo(
     () =>
       buildCopySelectedRowKeys({
@@ -1167,7 +1238,6 @@ export function DiffPane({
     if (
       previousViewportTop === null ||
       previousViewportTop === scrollViewport.top ||
-      !onViewportCenteredHunkChange ||
       suppressViewportSelectionSyncRef.current ||
       // A requested file-top align is still settling, so this viewport move is our own scroll
       // rather than the user's. The timed suppression above can expire before the align lands on
@@ -1180,6 +1250,20 @@ export function DiffPane({
       return;
     }
 
+    if (lineCursors.length > 0) {
+      const clampedCursor = clampLineCursorToViewport({
+        boundsOf: lineCursorBoundsOf,
+        current: lineCursor,
+        cursors: lineCursors,
+        scrollTop: scrollViewport.top,
+        viewportHeight: scrollViewport.height,
+      });
+      if (clampedCursor && clampedCursor !== lineCursor) {
+        onViewportLineCursorChange?.(clampedCursor);
+      }
+      return;
+    }
+
     const centeredTarget = findViewportCenteredHunkTarget({
       files,
       fileSectionLayouts,
@@ -1198,11 +1282,15 @@ export function DiffPane({
       return;
     }
 
-    onViewportCenteredHunkChange(centeredTarget.fileId, centeredTarget.hunkIndex);
+    onViewportCenteredHunkChange?.(centeredTarget.fileId, centeredTarget.hunkIndex);
   }, [
     fileSectionLayouts,
     files,
+    lineCursor,
+    lineCursorBoundsOf,
+    lineCursors,
     onViewportCenteredHunkChange,
+    onViewportLineCursorChange,
     scrollViewport.height,
     scrollViewport.top,
     sectionGeometry,
@@ -1219,10 +1307,6 @@ export function DiffPane({
       files.map((file, sectionIndex) => ({ kind: "file", fileId: file.id, sectionIndex })),
     [files],
   );
-  const fileSectionIndexById = useMemo(
-    () => buildFileSectionIndexById(fileSectionLayouts),
-    [fileSectionLayouts],
-  );
   const fileRenderWindow = useMemo(
     () =>
       windowingEnabled
@@ -1421,12 +1505,16 @@ export function DiffPane({
     const sectionRelativeHunkTop =
       selectedEstimatedHunkBounds.top - selectedEstimatedHunkBounds.sectionTop;
     const sectionRelativeHunkBottom = sectionRelativeHunkTop + selectedEstimatedHunkBounds.height;
-    const noteRow = geometry.rowBounds.find(
-      (row) =>
-        row.key.startsWith("inline-note:") &&
-        row.top >= sectionRelativeHunkTop &&
-        row.top < sectionRelativeHunkBottom,
-    );
+    const noteRow =
+      (draftNoteId
+        ? geometry.rowBoundsByStableKey.get(inlineNoteStableKey(draftNoteId))
+        : undefined) ??
+      geometry.rowBounds.find(
+        (row) =>
+          row.key.startsWith("inline-note:") &&
+          row.top >= sectionRelativeHunkTop &&
+          row.top < sectionRelativeHunkBottom,
+      );
 
     if (!noteRow) {
       return null;
@@ -1436,7 +1524,7 @@ export function DiffPane({
       top: selectedEstimatedHunkBounds.sectionTop + noteRow.top,
       height: noteRow.height,
     };
-  }, [scrollToNote, sectionGeometry, selectedEstimatedHunkBounds, selectedFileIndex]);
+  }, [draftNoteId, scrollToNote, sectionGeometry, selectedEstimatedHunkBounds, selectedFileIndex]);
   const selectedEstimatedHunkTop = selectedEstimatedHunkBounds?.top ?? null;
   const selectedEstimatedHunkHeight = selectedEstimatedHunkBounds?.height ?? null;
   const selectedEstimatedHunkStartRowId = selectedEstimatedHunkBounds?.startRowId ?? null;
@@ -1517,7 +1605,7 @@ export function DiffPane({
     const wrapChanged = previousWrapLinesRef.current !== wrapLines;
     const previousSectionMetrics = previousSectionGeometryRef.current;
     const previousFiles = previousFilesRef.current;
-    const currentDraftNoteId = draftNote?.id ?? null;
+    const currentDraftNoteId = draftNoteId;
     const draftChanged = previousDraftNoteIdRef.current !== currentDraftNoteId;
 
     if (draftChanged && previousSectionMetrics && previousFiles.length > 0) {
@@ -1531,12 +1619,24 @@ export function DiffPane({
           buildInStreamFileHeaderHeights(previousFiles),
         );
       if (anchor) {
-        const nextTop = resolveViewportRowAnchorTop(
+        const anchorTop = resolveViewportRowAnchorTop(
           files,
           sectionGeometry,
           anchor,
           sectionHeaderHeights,
         );
+        const draftBounds =
+          draftNoteId && draftNoteFileId
+            ? rowBoundsInStream(draftNoteFileId, inlineNoteStableKey(draftNoteId))
+            : undefined;
+        const nextTop = draftBounds
+          ? computeLineRevealScrollTop({
+              lineTop: draftBounds.top,
+              lineHeight: draftBounds.height,
+              scrollTop: anchorTop,
+              viewportHeight: scrollRef.current?.viewport.height || scrollViewport.height,
+            })
+          : anchorTop;
         const restoreViewportAnchor = () => {
           scrollRef.current?.scrollTo(nextTop);
         };
@@ -1616,12 +1716,15 @@ export function DiffPane({
     previousSectionGeometryRef.current = sectionGeometry;
     previousFilesRef.current = files;
   }, [
-    draftNote?.id,
+    draftNoteFileId,
+    draftNoteId,
     files,
     layout,
     layoutToggleRequestId,
     layoutToggleScrollTop,
+    rowBoundsInStream,
     scrollRef,
+    scrollViewport.height,
     scrollViewport.top,
     sectionGeometry,
     sectionHeaderHeights,
@@ -1863,6 +1966,47 @@ export function DiffPane({
     suppressViewportSelectionSync,
   ]);
 
+  const previousLineCursorRevealRequestIdRef = useRef(lineCursorRevealRequestId);
+
+  useLayoutEffect(() => {
+    if (previousLineCursorRevealRequestIdRef.current === lineCursorRevealRequestId) {
+      return;
+    }
+    previousLineCursorRevealRequestIdRef.current = lineCursorRevealRequestId;
+
+    const scrollBox = scrollRef.current;
+    if (!scrollBox || !lineCursor) {
+      return;
+    }
+
+    const bounds = lineCursorBoundsOf(lineCursor);
+    if (!bounds) {
+      return;
+    }
+
+    const viewportHeight = scrollBox.viewport.height || scrollViewport.height;
+    const revealScrollTop = computeLineRevealScrollTop({
+      lineTop: bounds.top,
+      lineHeight: bounds.height,
+      scrollTop: scrollBox.scrollTop,
+      viewportHeight,
+    });
+    if (revealScrollTop === scrollBox.scrollTop) {
+      return;
+    }
+
+    suppressViewportSelectionSync();
+    scrollBox.scrollTo(clampReviewScrollTop(revealScrollTop, viewportHeight));
+  }, [
+    clampReviewScrollTop,
+    lineCursor,
+    lineCursorBoundsOf,
+    lineCursorRevealRequestId,
+    scrollRef,
+    scrollViewport.height,
+    suppressViewportSelectionSync,
+  ]);
+
   // Keep keyboard step scrolling at exactly one row while wheel scrolling uses its own multiplier.
   useEffect(() => {
     const scrollBox = scrollRef.current;
@@ -1963,6 +2107,7 @@ export function DiffPane({
                       selectedHunkIndex={file.id === selectedFileId ? selectedHunkIndex : -1}
                       copySelectedRowRanges={copySelectedRowKeysByFile.get(file.id)}
                       copySelectedSide={copySelectionSide}
+                      cursorHighlight={file.id === lineCursor?.fileId ? cursorHighlight : undefined}
                       shouldLoadHighlight={
                         (!wrapLines || initialWrappedRenderWindowWarmed) &&
                         highlightPrefetchFileIds.has(file.id)
diff --git a/src/ui/components/panes/DiffSection.tsx b/src/ui/components/panes/DiffSection.tsx
index b3846d800..fe0bd4bfd 100644
--- a/src/ui/components/panes/DiffSection.tsx
+++ b/src/ui/components/panes/DiffSection.tsx
@@ -2,6 +2,7 @@ import { memo } from "react";
 import type { DiffFile, LayoutMode, UserNoteLineTarget } from "../../../core/types";
 import type { FileSourceStatus } from "../../diff/expandCollapsedRows";
 import { PierreDiffView, type ActiveAddNoteAffordance } from "../../diff/PierreDiffView";
+import type { CursorHighlight } from "../../diff/renderRows";
 import type { VisibleBodyBounds } from "../../diff/rowWindowing";
 import type { DiffSectionGeometry } from "../../diff/diffSectionGeometry";
 import type { VisibleAgentNote } from "../../lib/agentAnnotations";
@@ -24,6 +25,7 @@ interface DiffSectionProps {
   selectedHunkIndex: number;
   copySelectedRowRanges?: Map<string, CopySelectedRowRange>;
   copySelectedSide?: "left" | "right";
+  cursorHighlight?: CursorHighlight;
   shouldLoadHighlight: boolean;
   sectionGeometry?: DiffSectionGeometry;
   separatorWidth: number;
@@ -61,6 +63,7 @@ function DiffSectionComponent({
   selectedHunkIndex,
   copySelectedRowRanges,
   copySelectedSide,
+  cursorHighlight,
   shouldLoadHighlight,
   sectionGeometry,
   separatorWidth,
@@ -137,6 +140,7 @@ function DiffSectionComponent({
               rowBoundsByStableKey: new Map(),
             }
           }
+          cursorHighlight={cursorHighlight}
           selectedHunkIndex={selectedHunkIndex}
           theme={theme}
           visibleBodyBounds={visibleBodyBounds}
@@ -156,6 +160,7 @@ function DiffSectionComponent({
           codeHorizontalOffset={codeHorizontalOffset}
           copySelectedRowRanges={copySelectedRowRanges}
           copySelectedSide={copySelectedSide}
+          cursorHighlight={cursorHighlight}
           theme={theme}
           width={viewWidth}
           visibleAgentNotes={visibleAgentNotes}
@@ -193,6 +198,7 @@ export const DiffSection = memo(DiffSectionComponent, (previous, next) => {
     previous.selectedHunkIndex === next.selectedHunkIndex &&
     previous.copySelectedRowRanges === next.copySelectedRowRanges &&
     previous.copySelectedSide === next.copySelectedSide &&
+    previous.cursorHighlight === next.cursorHighlight &&
     previous.shouldLoadHighlight === next.shouldLoadHighlight &&
     previous.sectionGeometry === next.sectionGeometry &&
     previous.separatorWidth === next.separatorWidth &&
diff --git a/src/ui/components/panes/FileView.test.tsx b/src/ui/components/panes/FileView.test.tsx
index 245078abe..57de498e6 100644
--- a/src/ui/components/panes/FileView.test.tsx
+++ b/src/ui/components/panes/FileView.test.tsx
@@ -97,7 +97,7 @@ describe("FileView custom rows", () => {
     }
   });
 
-  test("renders a host-owned note immediately before its bound alternate row", async () => {
+  test("renders a host-owned note immediately after its bound alternate row", async () => {
     const file = createTestDiffFile({ id: "noted", path: "noted.ts" });
     const fileView = resolveTestLayout(
       {
@@ -140,7 +140,7 @@ describe("FileView custom rows", () => {
       const frame = setup.captureCharFrame();
       expect(frame).toContain("Review bound output");
       expect(frame).toContain("BOUND PRESENTATION");
-      expect(frame.indexOf("Review bound output")).toBeLessThan(
+      expect(frame.indexOf("Review bound output")).toBeGreaterThan(
         frame.indexOf("BOUND PRESENTATION"),
       );
       expect(
diff --git a/src/ui/components/panes/FileView.tsx b/src/ui/components/panes/FileView.tsx
index f2d6e6ff7..5770f25dc 100644
--- a/src/ui/components/panes/FileView.tsx
+++ b/src/ui/components/panes/FileView.tsx
@@ -9,9 +9,12 @@ import type {
 } from "../../../extension-api/types";
 import type { AppTheme } from "../../themes";
 import type { DiffSectionGeometry } from "../../diff/diffSectionGeometry";
+import { plannedRowMatchesCursor, type CursorHighlight } from "../../diff/renderRows";
+import { cursorLineHighlightBg } from "../../diff/rowStyle";
 import { resolveVisibleRowIndexWindow, type VisibleBodyBounds } from "../../diff/rowWindowing";
 import { reviewRowId } from "../../lib/ids";
 import { toExtensionPaintTheme } from "../../lib/extensionPaintTheme";
+import type { PlannedFileViewRow } from "../../fileViews/renderPlan";
 import type { ResolvedFileViewLayout } from "../../fileViews/useFileViews";
 import { AgentInlineNote } from "./AgentInlineNote";
 
@@ -113,6 +116,7 @@ function FileViewComponent({
   file,
   fileView,
   geometry,
+  cursorHighlight,
   selectedHunkIndex,
   theme,
   visibleBodyBounds,
@@ -122,6 +126,8 @@ function FileViewComponent({
   file: DiffFile;
   fileView: ResolvedFileViewLayout;
   geometry: DiffSectionGeometry;
+  /** The current line within this file, when the review-stream cursor rests in it. */
+  cursorHighlight?: CursorHighlight;
   selectedHunkIndex: number;
   theme: AppTheme;
   visibleBodyBounds?: VisibleBodyBounds;
@@ -130,7 +136,7 @@ function FileViewComponent({
 }) {
   const { layout } = fileView;
   const publicTheme = useMemo(() => toExtensionPaintTheme(theme), [theme]);
-  const plannedRows =
+  const plannedRows: readonly PlannedFileViewRow[] =
     geometry.fileViewRows ??
     layout.rows.map((row, rowIndex) => ({
       kind: "file-view-row" as const,
@@ -188,6 +194,8 @@ function FileViewComponent({
         const row = plannedRow.row;
         const index = plannedRow.rowIndex;
         const selected = isFileViewRowSelected(layout, index, selectedHunkIndex);
+        const onCursorRow = plannedRowMatchesCursor(plannedRow, cursorHighlight);
+        const rowBackground = selected ? theme.selectedHunk : theme.panel;
         const fixedHeight = row.component?.height;
         const View = row.component?.render as
           | ((props: ExtensionFileViewRowComponentProps) => ReactNode)
@@ -212,7 +220,10 @@ function FileViewComponent({
                     overflow: "hidden" as const,
                   }),
               flexDirection: "row",
-              backgroundColor: selected ? theme.selectedHunk : theme.panel,
+              // Presentation rows carry no line-number column, so both marker styles paint a band.
+              backgroundColor: onCursorRow
+                ? cursorLineHighlightBg(rowBackground, theme)
+                : rowBackground,
             }}
           >
             {View && fixedHeight !== undefined ? (
diff --git a/src/ui/components/ui-components.test.tsx b/src/ui/components/ui-components.test.tsx
index 9625d1034..73cbd2843 100644
--- a/src/ui/components/ui-components.test.tsx
+++ b/src/ui/components/ui-components.test.tsx
@@ -2413,7 +2413,7 @@ describe("UI components", () => {
     expect(frame).toContain("Agent note - alpha.ts R2");
     expect(frame).toContain("Annotation for alpha.ts");
     expect(frame).toContain("Why alpha.ts changed");
-    expect(frame.indexOf("Agent note - alpha.ts R2")).toBeLessThan(
+    expect(frame.indexOf("Agent note - alpha.ts R2")).toBeGreaterThan(
       frame.indexOf("2 + export const add = true;"),
     );
     expect(frame).toContain("Agent note - beta.ts R1");
@@ -2424,7 +2424,7 @@ describe("UI components", () => {
     expect(frame).not.toContain("confidence");
   });
 
-  test("DiffPane split inline notes hand off directly to the anchored row without shifting it", async () => {
+  test("DiffPane split inline notes hand off directly from the anchored row without shifting it", async () => {
     const bootstrap = createBootstrap();
     const theme = resolveTheme("github-dark-default", null);
     const frame = await captureFrame(
@@ -2452,10 +2452,10 @@ describe("UI components", () => {
     );
 
     const lines = frame.split("\n");
-    const noteBottomIndex = lines.findIndex((line) => line.includes("╰") && line.includes("╯"));
-    expect(noteBottomIndex).toBeGreaterThanOrEqual(0);
-    expect(lines[noteBottomIndex + 1]).toContain("export const add = true;");
-    expect(lines[noteBottomIndex + 1]?.trim()).not.toBe("│");
+    const noteTopIndex = lines.findIndex((line) => line.includes("╭") && line.includes("╮"));
+    expect(noteTopIndex).toBeGreaterThan(0);
+    expect(lines[noteTopIndex - 1]).toContain("export const add = true;");
+    expect(lines[noteTopIndex - 1]?.trim()).not.toBe("│");
 
     const changedLine = lines.find((line) => line.includes("export const alpha = 2;"));
     const annotatedLine = lines.find((line) => line.includes("export const add = true;"));
@@ -2667,13 +2667,13 @@ describe("UI components", () => {
     const frame = await captureFrame(
       <HelpDialog
         commands={builtinCommandMatchProbes()}
-        terminalHeight={39}
+        terminalHeight={40}
         terminalWidth={76}
         theme={theme}
         onClose={() => {}}
       />,
       76,
-      39,
+      40,
     );
 
     const expectedRows = [
@@ -2681,6 +2681,7 @@ describe("UI components", () => {
       "[Esc]",
       "Navigation",
       "Up / Down                move line-by-line",
+      "h / l                    select old / new side",
       "PageDown / Space / f     page down",
       "PageUp / b / Shift+Space page up",
       "d / u                    half page down / up",
@@ -2698,7 +2699,7 @@ describe("UI components", () => {
       "s / t                    sidebar / theme selector",
       "a                        toggle AI notes",
       "z                        toggle unchanged context",
-      "l / w / m / M            lines / wrap / metadata / menu",
+      "w / m / M                wrap / metadata / menu",
       "e                        open file in $EDITOR",
       "Review",
       "/                        focus file filter",
@@ -2734,13 +2735,13 @@ describe("UI components", () => {
     const frame = await captureFrame(
       <HelpDialog
         commands={builtinCommandMatchProbes(keys)}
-        terminalHeight={39}
+        terminalHeight={40}
         terminalWidth={76}
         theme={theme}
         onClose={() => {}}
       />,
       76,
-      39,
+      40,
     );
 
     expect(frame).toContain("Ctrl+X");
@@ -3020,7 +3021,7 @@ describe("UI components", () => {
     expect(frame).toContain("Ungrounded note");
     expect(frame).toContain("Falls back to the first visible");
     expect(frame).toContain("row.");
-    expect(frame.indexOf("Agent note - note-fallback.ts hunk")).toBeLessThan(
+    expect(frame.indexOf("Agent note - note-fallback.ts hunk")).toBeGreaterThan(
       frame.indexOf("1 - export const value = 1;"),
     );
   });
diff --git a/src/ui/diff/PierreDiffView.tsx b/src/ui/diff/PierreDiffView.tsx
index ec7df7d7c..8cf47cc9e 100644
--- a/src/ui/diff/PierreDiffView.tsx
+++ b/src/ui/diff/PierreDiffView.tsx
@@ -13,7 +13,13 @@ import { spansForHighlightedSourceLine, type DiffRow } from "./pierre";
 import { plannedReviewRowVisible } from "./plannedReviewRows";
 import { buildDiffSectionRowPlan } from "./diffSectionRowPlan";
 import { resolveVisiblePlannedRowWindow, type VisibleBodyBounds } from "./rowWindowing";
-import { diffMessage, DiffRowView, fitText } from "./renderRows";
+import {
+  diffMessage,
+  DiffRowView,
+  fitText,
+  plannedRowMatchesCursor,
+  type CursorHighlight,
+} from "./renderRows";
 import { useHighlightedDiff } from "./useHighlightedDiff";
 import { useHighlightedSource } from "./useHighlightedSource";
 
@@ -63,6 +69,7 @@ export function PierreDiffView({
   codeHorizontalOffset = 0,
   copySelectedRowRanges,
   copySelectedSide,
+  cursorHighlight,
   expandedGapKeys = EMPTY_EXPANDED_GAP_KEYS,
   file,
   layout,
@@ -89,6 +96,8 @@ export function PierreDiffView({
   codeHorizontalOffset?: number;
   copySelectedRowRanges?: Map<string, CopySelectedRowRange>;
   copySelectedSide?: "left" | "right";
+  /** The current line within this file, when the review-stream cursor rests in it. */
+  cursorHighlight?: CursorHighlight;
   expandedGapKeys?: ReadonlySet<string>;
   file: DiffFile | undefined;
   layout: Exclude<LayoutMode, "auto">;
@@ -371,6 +380,8 @@ export function PierreDiffView({
           );
         }
 
+        const isCursorRow = plannedRowMatchesCursor(plannedRow, cursorHighlight);
+
         return (
           <box key={plannedRow.key} id={rowId} style={{ width: "100%", flexDirection: "column" }}>
             <DiffRowView
@@ -385,6 +396,7 @@ export function PierreDiffView({
               selected={plannedRow.row.hunkIndex === selectedHunkIndex}
               copySelectedRowRange={copySelectedRowRanges?.get(plannedRow.key)}
               copySelectedSide={copySelectedSide}
+              cursorHighlight={isCursorRow ? cursorHighlight : undefined}
               anchorId={plannedRow.anchorId}
               noteGuideSide={plannedRow.noteGuideSide}
               showAddNoteBadge={
diff --git a/src/ui/diff/renderRows.tsx b/src/ui/diff/renderRows.tsx
index 3ef4debe6..12798999c 100644
--- a/src/ui/diff/renderRows.tsx
+++ b/src/ui/diff/renderRows.tsx
@@ -13,6 +13,7 @@ import {
   diffRailMarker,
   dimRailColor,
   neutralRailColor,
+  cursorLineHighlightBg,
   selectionHighlightBg,
   splitCellPalette,
   splitGutterText,
@@ -38,6 +39,35 @@ import {
   wrapSanitizedTextByWidth,
 } from "../lib/text";
 import type { CopySelectedRowRange } from "../components/panes/copySelection";
+import type { CursorLine } from "../../core/types";
+
+export interface CursorHighlight {
+  /** The render plan anchor of the row the cursor rests on, shared with reveal lookups. */
+  stableKey: string;
+  style: Exclude<CursorLine, "off">;
+  /** Which half of a split row the cursor sits on, and where a note would anchor. */
+  side: "old" | "new";
+}
+
+/** Report whether one planned row carries the anchor the cursor rests on. */
+export function plannedRowMatchesCursor(
+  row: { stableKey: string; stableAliasKeys?: readonly string[] },
+  cursor: CursorHighlight | undefined,
+) {
+  return (
+    cursor !== undefined &&
+    (row.stableKey === cursor.stableKey || row.stableAliasKeys?.includes(cursor.stableKey) === true)
+  );
+}
+
+interface RowHighlight {
+  bg: (baseBg: string) => string;
+  /** Global columns to blend; absent blends the gutter alone. */
+  colRange?: CopySelectedRowRange;
+}
+
+/** Column span covering a row's whole content column, in the global columns selection uses. */
+const FULL_ROW_COL_RANGE: CopySelectedRowRange = { startCol: 0, endCol: Number.MAX_SAFE_INTEGER };
 
 /** Clamp a label to one terminal row with an ellipsis. */
 export function fitText(text: string, width: number) {
@@ -327,7 +357,7 @@ function renderInlineSpans(
   fallbackBg: string,
   keyPrefix: string,
   horizontalOffset = 0,
-  selectionTheme?: AppTheme,
+  highlightBg?: (baseBg: string) => string,
   selectionColRange?: { start: number; end: number },
   spansAreSanitized = false,
 ) {
@@ -336,7 +366,7 @@ function renderInlineSpans(
     horizontalOffset,
     width,
   );
-  const needsBlending = selectionTheme && selectionColRange;
+  const needsBlending = highlightBg && selectionColRange;
   const paddingAmount = Math.max(0, width - usedWidth);
   let paddingMerged = false;
   const lastSpan = trimmed.at(-1);
@@ -430,7 +460,7 @@ function renderInlineSpans(
         <span
           key={`${keyPrefix}:${elementIndex++}`}
           fg={span.fg ?? fallbackColor}
-          bg={selectionHighlightBg(span.bg ?? fallbackBg, selectionTheme)}
+          bg={highlightBg(span.bg ?? fallbackBg)}
         >
           {selected}
         </span>,
@@ -473,11 +503,7 @@ function renderInlineSpans(
         }
         if (inSel > 0) {
           elements.push(
-            <span
-              key={`${keyPrefix}:pad-sel`}
-              fg={fallbackColor}
-              bg={selectionHighlightBg(fallbackBg, selectionTheme)}
-            >
+            <span key={`${keyPrefix}:pad-sel`} fg={fallbackColor} bg={highlightBg(fallbackBg)}>
               {" ".repeat(inSel)}
             </span>,
           );
@@ -1126,27 +1152,47 @@ function resolvePlainContentWidth(totalWidth: number, prefixWidth: number, gutte
 }
 
 /**
- * Apply the selection-highlight blend to a cell palette's gutter bg only.
+ * Apply a highlight blend to a cell palette's gutter bg only.
  *
  * The content bg is intentionally left untouched here so renderInlineSpans can apply the same
  * blend uniformly across every rendered span (including syntax-emphasis spans that supply their
  * own bg). Pre-blending contentBg would cause the fallback path to double-blend.
  */
-function applySelectionPalette<P extends { gutterBg: string; contentBg: string }>(
+function applyHighlightPalette<P extends { gutterBg: string; contentBg: string }>(
   palette: P,
-  theme: AppTheme,
+  highlightBg: (baseBg: string) => string,
 ): P {
   return {
     ...palette,
-    gutterBg: selectionHighlightBg(palette.gutterBg, theme),
+    gutterBg: highlightBg(palette.gutterBg),
   };
 }
 
-/** Apply the selection-highlight blend to a prefix descriptor. */
-function applySelectionPrefix<P extends { bg: string }>(prefix: P, theme: AppTheme): P {
+/**
+ * Choose which highlight paints one half of a row.
+ *
+ * An active drag outranks the resting cursor, so copy selection keeps its exact extent.
+ */
+function pickRowHighlight(
+  selection: RowHighlight,
+  cursor: RowHighlight | undefined,
+  hasSelection: boolean,
+  onCursor: boolean,
+) {
+  if (hasSelection) {
+    return selection;
+  }
+  return onCursor ? cursor : undefined;
+}
+
+/** Apply a highlight blend to a prefix descriptor. */
+function applyHighlightPrefix<P extends { bg: string }>(
+  prefix: P,
+  highlightBg: (baseBg: string) => string,
+): P {
   return {
     ...prefix,
-    bg: selectionHighlightBg(prefix.bg, theme),
+    bg: highlightBg(prefix.bg),
   };
 }
 
@@ -1164,13 +1210,12 @@ function renderSplitCell(
     fg: string;
     bg: string;
   },
-  selected = false,
-  selectionColRange?: CopySelectedRowRange,
+  highlight?: RowHighlight,
   paneOffset = 0,
 ) {
   const basePalette = splitCellPalette(cell.kind, theme, cell.moveKind);
-  const palette = selected ? applySelectionPalette(basePalette, theme) : basePalette;
-  const resolvedPrefix = selected && prefix ? applySelectionPrefix(prefix, theme) : prefix;
+  const palette = highlight ? applyHighlightPalette(basePalette, highlight.bg) : basePalette;
+  const resolvedPrefix = highlight && prefix ? applyHighlightPrefix(prefix, highlight.bg) : prefix;
   const prefixWidth = resolvedPrefix?.text.length ?? 0;
   const { gutterWidth, contentWidth } = resolveSplitCellGeometry(
     width,
@@ -1182,14 +1227,12 @@ function renderSplitCell(
 
   // Convert global selection column range to content-local range.
   const globalContentStart = paneOffset + prefixWidth + gutterWidth;
+  const colRange = highlight?.colRange;
   const localColRange =
-    selectionColRange && globalContentStart < selectionColRange.endCol
+    colRange && globalContentStart < colRange.endCol
       ? {
-          start: Math.max(0, selectionColRange.startCol - globalContentStart),
-          end: Math.min(
-            contentWidth,
-            Math.max(0, selectionColRange.endCol - globalContentStart + 1),
-          ),
+          start: Math.max(0, colRange.startCol - globalContentStart),
+          end: Math.min(contentWidth, Math.max(0, colRange.endCol - globalContentStart + 1)),
         }
       : undefined;
 
@@ -1210,7 +1253,7 @@ function renderSplitCell(
         palette.contentBg,
         `${keyPrefix}:content`,
         contentOffset,
-        selected ? theme : undefined,
+        highlight?.bg,
         localColRange,
       )}
     </>
@@ -1231,12 +1274,11 @@ function renderStackCell(
     fg: string;
     bg: string;
   },
-  selected = false,
-  selectionColRange?: CopySelectedRowRange,
+  highlight?: RowHighlight,
 ) {
   const basePalette = stackCellPalette(cell.kind, theme, cell.moveKind);
-  const palette = selected ? applySelectionPalette(basePalette, theme) : basePalette;
-  const resolvedPrefix = selected && prefix ? applySelectionPrefix(prefix, theme) : prefix;
+  const palette = highlight ? applyHighlightPalette(basePalette, highlight.bg) : basePalette;
+  const resolvedPrefix = highlight && prefix ? applyHighlightPrefix(prefix, highlight.bg) : prefix;
   const prefixWidth = resolvedPrefix?.text.length ?? 0;
   const { gutterWidth, contentWidth } = resolveStackCellGeometry(
     width,
@@ -1247,14 +1289,12 @@ function renderStackCell(
 
   // Convert global selection column range to content-local range.
   const globalContentStart = prefixWidth + gutterWidth;
+  const colRange = highlight?.colRange;
   const localColRange =
-    selectionColRange && globalContentStart < selectionColRange.endCol
+    colRange && globalContentStart < colRange.endCol
       ? {
-          start: Math.max(0, selectionColRange.startCol - globalContentStart),
-          end: Math.min(
-            contentWidth,
-            Math.max(0, selectionColRange.endCol - globalContentStart + 1),
-          ),
+          start: Math.max(0, colRange.startCol - globalContentStart),
+          end: Math.min(contentWidth, Math.max(0, colRange.endCol - globalContentStart + 1)),
         }
       : undefined;
 
@@ -1275,7 +1315,7 @@ function renderStackCell(
         palette.contentBg,
         `${keyPrefix}:content`,
         contentOffset,
-        selected ? theme : undefined,
+        highlight?.bg,
         localColRange,
       )}
     </>
@@ -1294,24 +1334,21 @@ function renderWrappedSplitCellLine(
     fg: string;
     bg: string;
   },
-  selected = false,
-  selectionColRange?: CopySelectedRowRange,
+  highlight?: RowHighlight,
   paneOffset = 0,
 ) {
-  const resolvedPalette = selected ? applySelectionPalette(palette, theme) : palette;
-  const resolvedPrefix = selected ? applySelectionPrefix(prefix, theme) : prefix;
+  const resolvedPalette = highlight ? applyHighlightPalette(palette, highlight.bg) : palette;
+  const resolvedPrefix = highlight ? applyHighlightPrefix(prefix, highlight.bg) : prefix;
 
   const prefixWidth = prefix.text.length;
   const gutterWidth = line.gutterText.length;
   const globalContentStart = paneOffset + prefixWidth + gutterWidth;
+  const colRange = highlight?.colRange;
   const localColRange =
-    selectionColRange && globalContentStart < selectionColRange.endCol
+    colRange && globalContentStart < colRange.endCol
       ? {
-          start: Math.max(0, selectionColRange.startCol - globalContentStart),
-          end: Math.min(
-            contentWidth,
-            Math.max(0, selectionColRange.endCol - globalContentStart + 1),
-          ),
+          start: Math.max(0, colRange.startCol - globalContentStart),
+          end: Math.min(contentWidth, Math.max(0, colRange.endCol - globalContentStart + 1)),
         }
       : undefined;
 
@@ -1334,7 +1371,7 @@ function renderWrappedSplitCellLine(
         resolvedPalette.contentBg,
         `${keyPrefix}:content`,
         0,
-        selected ? theme : undefined,
+        highlight?.bg,
         localColRange,
         true,
       )}
@@ -1354,23 +1391,20 @@ function renderWrappedStackCellLine(
     fg: string;
     bg: string;
   },
-  selected = false,
-  selectionColRange?: CopySelectedRowRange,
+  highlight?: RowHighlight,
 ) {
-  const resolvedPalette = selected ? applySelectionPalette(palette, theme) : palette;
-  const resolvedPrefix = selected ? applySelectionPrefix(prefix, theme) : prefix;
+  const resolvedPalette = highlight ? applyHighlightPalette(palette, highlight.bg) : palette;
+  const resolvedPrefix = highlight ? applyHighlightPrefix(prefix, highlight.bg) : prefix;
 
   const prefixWidth = prefix.text.length;
   const gutterWidth = line.gutterText.length;
   const globalContentStart = prefixWidth + gutterWidth;
+  const colRange = highlight?.colRange;
   const localColRange =
-    selectionColRange && globalContentStart < selectionColRange.endCol
+    colRange && globalContentStart < colRange.endCol
       ? {
-          start: Math.max(0, selectionColRange.startCol - globalContentStart),
-          end: Math.min(
-            contentWidth,
-            Math.max(0, selectionColRange.endCol - globalContentStart + 1),
-          ),
+          start: Math.max(0, colRange.startCol - globalContentStart),
+          end: Math.min(contentWidth, Math.max(0, colRange.endCol - globalContentStart + 1)),
         }
       : undefined;
 
@@ -1393,7 +1427,7 @@ function renderWrappedStackCellLine(
         resolvedPalette.contentBg,
         `${keyPrefix}:content`,
         0,
-        selected ? theme : undefined,
+        highlight?.bg,
         localColRange,
         true,
       )}
@@ -1667,6 +1701,7 @@ function renderRow(
   selected: boolean,
   copySelectedRowRange: CopySelectedRowRange | undefined,
   copySelectedSide: "left" | "right" | undefined,
+  cursorHighlight: CursorHighlight | undefined,
   anchorId?: string,
   noteGuideSide?: "old" | "new",
   showAddNoteBadge = false,
@@ -1682,6 +1717,40 @@ function renderRow(
   // selection represents.
   const hasLeftSelection = hasCopySelection && copySelectedSide !== "right";
   const hasRightSelection = hasCopySelection && copySelectedSide !== "left";
+
+  // A split context row shows the same source line on both halves, so marking one of them would
+  // read as half a row. Change rows keep the split, since the halves are different note targets.
+  const splitContextRow =
+    row.type === "split-line" && row.left.kind === "context" && row.right.kind === "context";
+  const onCursorRow = cursorHighlight !== undefined;
+  const selectionHighlight: RowHighlight = {
+    bg: (baseBg) => selectionHighlightBg(baseBg, theme),
+    colRange: copySelectedRowRange,
+  };
+  const cursorRowHighlight: RowHighlight | undefined = onCursorRow
+    ? {
+        bg: (baseBg) => cursorLineHighlightBg(baseBg, theme),
+        colRange: cursorHighlight.style === "row" ? FULL_ROW_COL_RANGE : undefined,
+      }
+    : undefined;
+  const leftHighlight = pickRowHighlight(
+    selectionHighlight,
+    cursorRowHighlight,
+    hasLeftSelection,
+    onCursorRow && (splitContextRow || cursorHighlight.side === "old"),
+  );
+  const rightHighlight = pickRowHighlight(
+    selectionHighlight,
+    cursorRowHighlight,
+    hasRightSelection,
+    onCursorRow && (splitContextRow || cursorHighlight.side === "new"),
+  );
+  const cellHighlight = pickRowHighlight(
+    selectionHighlight,
+    cursorRowHighlight,
+    hasCopySelection,
+    onCursorRow,
+  );
   let baseRow: ReactNode;
 
   if (row.type === "collapsed") {
@@ -1760,8 +1829,7 @@ function renderRow(
                 `${row.key}:left`,
                 codeHorizontalOffset,
                 leftPrefix,
-                hasLeftSelection,
-                hasLeftSelection ? copySelectedRowRange : undefined,
+                leftHighlight,
                 0,
               )}
               {renderSplitCell(
@@ -1773,8 +1841,7 @@ function renderRow(
                 `${row.key}:right`,
                 codeHorizontalOffset,
                 rightPrefix,
-                hasRightSelection,
-                hasRightSelection ? copySelectedRowRange : undefined,
+                rightHighlight,
                 leftWidth,
               )}
               {guideOnNewSide ? (
@@ -1836,7 +1903,7 @@ function renderRow(
 
             const showBadgeOnLine = showAddNoteBadge && index === 0;
             let styledRow: StyledText;
-            if (hasCopySelection) {
+            if (leftHighlight || rightHighlight) {
               styledRow = styledTextFromSpanNodes([
                 renderWrappedSplitCellLine(
                   leftLine,
@@ -1845,8 +1912,7 @@ function renderRow(
                   theme,
                   `${row.key}:left:${index}`,
                   leftPrefix,
-                  hasLeftSelection,
-                  copySelectedRowRange,
+                  leftHighlight,
                   0,
                 ),
                 renderWrappedSplitCellLine(
@@ -1856,8 +1922,7 @@ function renderRow(
                   theme,
                   `${row.key}:right:${index}`,
                   rightPrefix,
-                  hasRightSelection,
-                  copySelectedRowRange,
+                  rightHighlight,
                   leftWidth,
                 ),
                 guideOnNewSide ? (
@@ -1975,8 +2040,7 @@ function renderRow(
                 `${row.key}:stack`,
                 codeHorizontalOffset,
                 prefix,
-                hasCopySelection,
-                hasCopySelection ? copySelectedRowRange : undefined,
+                cellHighlight,
               )}
               {guideOnNewSide ? (
                 <span key={`${row.key}:note-guide`} fg={theme.noteBorder}>
@@ -2022,8 +2086,7 @@ function renderRow(
                 theme,
                 `${row.key}:stack:${index}`,
                 prefix,
-                hasCopySelection,
-                hasCopySelection ? copySelectedRowRange : undefined,
+                cellHighlight,
               ),
               guideOnNewSide ? (
                 <span key={`${row.key}:note-guide:${index}`} fg={theme.noteBorder}>
@@ -2088,6 +2151,7 @@ interface DiffRowViewProps {
   selected: boolean;
   copySelectedRowRange?: CopySelectedRowRange;
   copySelectedSide?: "left" | "right";
+  cursorHighlight?: CursorHighlight;
   anchorId?: string;
   noteGuideSide?: "old" | "new";
   showAddNoteBadge?: boolean;
@@ -2116,6 +2180,7 @@ export const DiffRowView = memo(
     selected,
     copySelectedRowRange,
     copySelectedSide,
+    cursorHighlight,
     anchorId,
     noteGuideSide,
     showAddNoteBadge,
@@ -2135,6 +2200,7 @@ export const DiffRowView = memo(
       selected,
       copySelectedRowRange,
       copySelectedSide,
+      cursorHighlight,
       anchorId,
       noteGuideSide,
       showAddNoteBadge,
@@ -2156,6 +2222,7 @@ export const DiffRowView = memo(
       previous.selected === next.selected &&
       previous.copySelectedRowRange === next.copySelectedRowRange &&
       previous.copySelectedSide === next.copySelectedSide &&
+      previous.cursorHighlight === next.cursorHighlight &&
       previous.anchorId === next.anchorId &&
       previous.noteGuideSide === next.noteGuideSide &&
       previous.showAddNoteBadge === next.showAddNoteBadge &&
diff --git a/src/ui/diff/reviewRenderPlan.test.ts b/src/ui/diff/reviewRenderPlan.test.ts
index 04dbac029..162fb9127 100644
--- a/src/ui/diff/reviewRenderPlan.test.ts
+++ b/src/ui/diff/reviewRenderPlan.test.ts
@@ -1,7 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import { parseDiffFromFile } from "@pierre/diffs";
 import type { DiffFile } from "../../core/types";
-import type { PlannedReviewRow } from "./reviewRenderPlan";
+import {
+  contextLineStableKeyTarget,
+  lineStableKey,
+  lineStableKeyTarget,
+  type PlannedReviewRow,
+} from "./reviewRenderPlan";
 import { resolveTheme } from "../themes";
 
 const { buildSplitRows, buildStackRows } = await import("./pierre");
@@ -55,7 +60,7 @@ function firstInlineNote(plannedRows: PlannedReviewRow[]) {
 
 function inlineNoteAnchorRow(plannedRows: PlannedReviewRow[]) {
   const noteIndex = plannedRows.findIndex((row) => row.kind === "inline-note");
-  return noteIndex >= 0 ? plannedRows[noteIndex + 1] : undefined;
+  return noteIndex > 0 ? plannedRows[noteIndex - 1] : undefined;
 }
 
 function guidedSplitLineNumbers(plannedRows: PlannedReviewRow[], side: "old" | "new") {
@@ -69,7 +74,7 @@ function guidedSplitLineNumbers(plannedRows: PlannedReviewRow[], side: "old" | "
 }
 
 describe("review render plan", () => {
-  test("inserts an inline note before the anchor row and starts the guide after the anchor", () => {
+  test("inserts an inline note after the anchor row and starts the guide below the note", () => {
     const theme = resolveTheme("github-dark-default", null);
     const file = createDiffFile(
       "alpha",
@@ -115,7 +120,7 @@ describe("review render plan", () => {
     expect(guidedSplitLineNumbers(plannedRows, "new")).toEqual([3]);
   });
 
-  test("anchors deletion-only notes to old-side rows without a dangling guide below the note", () => {
+  test("anchors deletion-only notes to old-side rows without a dangling guide above the note", () => {
     const theme = resolveTheme("github-dark-default", null);
     const file = createDiffFile(
       "deleted",
@@ -366,3 +371,38 @@ describe("review render plan", () => {
     expect(inlineNotes.every((row) => row.noteIndex === 0 && row.noteCount === 1)).toBe(true);
   });
 });
+
+describe("line stable key targets", () => {
+  test("reads a single-sided anchor back into a note target", () => {
+    expect(lineStableKeyTarget(lineStableKey(2, "old", 41))).toEqual({
+      hunkIndex: 2,
+      side: "old",
+      line: 41,
+    });
+    expect(lineStableKeyTarget(lineStableKey(0, "new", 7))).toEqual({
+      hunkIndex: 0,
+      side: "new",
+      line: 7,
+    });
+  });
+
+  test("reads a shared context anchor as its new-side line", () => {
+    expect(contextLineStableKeyTarget("line:3:context:12:14")).toEqual({
+      hunkIndex: 3,
+      side: "new",
+      line: 14,
+    });
+  });
+
+  test("keeps the two anchor shapes apart", () => {
+    expect(lineStableKeyTarget("line:3:context:12:14")).toBeNull();
+    expect(contextLineStableKeyTarget(lineStableKey(3, "new", 14))).toBeNull();
+  });
+
+  test("ignores anchors that do not name a source line", () => {
+    for (const stableKey of ["meta:hunk-header:1", "meta:collapsed:before:0", "inline-note:x"]) {
+      expect(lineStableKeyTarget(stableKey)).toBeNull();
+      expect(contextLineStableKeyTarget(stableKey)).toBeNull();
+    }
+  });
+});
diff --git a/src/ui/diff/reviewRenderPlan.ts b/src/ui/diff/reviewRenderPlan.ts
index f3bfc76d7..4a31df943 100644
--- a/src/ui/diff/reviewRenderPlan.ts
+++ b/src/ui/diff/reviewRenderPlan.ts
@@ -1,4 +1,4 @@
-import type { AgentAnnotation } from "../../core/types";
+import type { AgentAnnotation, UserNoteLineTarget } from "../../core/types";
 import { annotationAnchor, type VisibleAgentNote } from "../lib/agentAnnotations";
 import { diffHunkId } from "../lib/ids";
 import type { DiffRow } from "./pierre";
@@ -67,14 +67,24 @@ function uniqueStableKeys(keys: Array<string | undefined>) {
   return next;
 }
 
+/** Build the file-scoped stable anchor for one source line on either diff side. */
+export function lineStableKey(hunkIndex: number, side: "old" | "new", lineNumber: number) {
+  return `line:${hunkIndex}:${side}:${lineNumber}`;
+}
+
+/** Build the stable anchor for one inline note card. */
+export function inlineNoteStableKey(noteId: string) {
+  return `inline-note:${noteId}`;
+}
+
 /** Build the file-scoped stable anchor for one old-side source line. */
 function oldLineStableKey(hunkIndex: number, lineNumber?: number) {
-  return lineNumber === undefined ? undefined : `line:${hunkIndex}:old:${lineNumber}`;
+  return lineNumber === undefined ? undefined : lineStableKey(hunkIndex, "old", lineNumber);
 }
 
 /** Build the file-scoped stable anchor for one new-side source line. */
 function newLineStableKey(hunkIndex: number, lineNumber?: number) {
-  return lineNumber === undefined ? undefined : `line:${hunkIndex}:new:${lineNumber}`;
+  return lineNumber === undefined ? undefined : lineStableKey(hunkIndex, "new", lineNumber);
 }
 
 /** Build the file-scoped stable anchor for one context row shared by both sides. */
@@ -84,6 +94,54 @@ function contextLineStableKey(hunkIndex: number, oldLineNumber?: number, newLine
     : `line:${hunkIndex}:context:${oldLineNumber}:${newLineNumber}`;
 }
 
+const SIDED_LINE_STABLE_KEY = /^line:(\d+):(old|new):(\d+)$/;
+const CONTEXT_LINE_STABLE_KEY = /^line:(\d+):context:\d+:(\d+)$/;
+
+/** Recover the source line one single-sided stable anchor names. */
+export function lineStableKeyTarget(
+  stableKey: string,
+): (UserNoteLineTarget & { hunkIndex: number }) | null {
+  const match = SIDED_LINE_STABLE_KEY.exec(stableKey);
+  if (!match) {
+    return null;
+  }
+
+  return { hunkIndex: Number(match[1]), side: match[2] as "old" | "new", line: Number(match[3]) };
+}
+
+/**
+ * Recover the source line one shared context anchor names.
+ *
+ * Resolves to the new side, which is what the add-note affordance already anchors to.
+ */
+export function contextLineStableKeyTarget(
+  stableKey: string,
+): (UserNoteLineTarget & { hunkIndex: number }) | null {
+  const match = CONTEXT_LINE_STABLE_KEY.exec(stableKey);
+  if (!match) {
+    return null;
+  }
+
+  return { hunkIndex: Number(match[1]), side: "new", line: Number(match[2]) };
+}
+
+/** Resolve either side of a context row, whose stable key carries both line numbers. */
+export function contextLineStableKeyTargetForSide(
+  stableKey: string,
+  side: "old" | "new",
+): (UserNoteLineTarget & { hunkIndex: number }) | null {
+  const match = CONTEXT_LINE_STABLE_KEY.exec(stableKey);
+  if (!match) {
+    return null;
+  }
+
+  return {
+    hunkIndex: Number(match[1]),
+    side,
+    line: Number(side === "old" ? match[2] : match[3]),
+  };
+}
+
 /** Resolve the stable anchor keys for one rendered diff row across split and stack layouts. */
 function diffRowStableKeys(row: DiffRow) {
   if (row.type === "collapsed") {
@@ -184,9 +242,9 @@ function rowOverlapsAnnotation(row: DiffLineRow, annotation: AgentAnnotation) {
 }
 
 /**
- * Resolve the rendered diff row before which the inline note should appear.
+ * Resolve the rendered diff row after which the inline note should appear.
  * Range-less notes intentionally anchor beside the first code row in the file,
- * not above hunk header metadata.
+ * not against hunk header metadata.
  */
 function findInlineNoteAnchorRow(rows: DiffRow[], annotation: AgentAnnotation) {
   const fileLineRows = lineRows(rows);
@@ -209,8 +267,6 @@ function buildInlineVisibleNotePlacements(rows: DiffRow[], visibleAgentNotes: Vi
 
     const anchorSide = annotationAnchor(note.annotation)?.side;
     const coveredRows = fileLineRows.filter((row) => rowOverlapsAnnotation(row, note.annotation));
-    // The inline card already sits directly above its anchor; start any range guide after that row
-    // so the first code line below the note does not show a dangling right-gutter connector.
     const guideRows = coveredRows.filter((row) => row.key !== anchorRow.key);
     const anchorPlacements = placementsByAnchor.get(anchorRow.key) ?? [];
 
@@ -307,12 +363,24 @@ export function buildReviewRenderPlan({
       anchoredHunks.add(row.hunkIndex);
     }
 
+    plannedRows.push({
+      kind: "diff-row",
+      key: `diff-row:${row.key}`,
+      stableKey: diffStableKey,
+      stableAliasKeys: diffStableAliasKeys,
+      fileId: row.fileId,
+      hunkIndex: row.hunkIndex,
+      row,
+      anchorId,
+      noteGuideSide: noteGuideSideByRowKey.get(row.key),
+    });
+
     const anchoredNotes = placementsByAnchor.get(row.key) ?? [];
     anchoredNotes.forEach((placement) => {
       plannedRows.push({
         kind: "inline-note",
         key: `inline-note:${placement.note.id}:${row.key}:${placement.noteIndex}`,
-        stableKey: `inline-note:${placement.note.id}`,
+        stableKey: inlineNoteStableKey(placement.note.id),
         fileId,
         hunkIndex: placement.hunkIndex,
         annotationId: placement.note.id,
@@ -323,18 +391,6 @@ export function buildReviewRenderPlan({
         noteIndex: placement.noteIndex,
       });
     });
-
-    plannedRows.push({
-      kind: "diff-row",
-      key: `diff-row:${row.key}`,
-      stableKey: diffStableKey,
-      stableAliasKeys: diffStableAliasKeys,
-      fileId: row.fileId,
-      hunkIndex: row.hunkIndex,
-      row,
-      anchorId,
-      noteGuideSide: noteGuideSideByRowKey.get(row.key),
-    });
   }
 
   return plannedRows;
diff --git a/src/ui/diff/rowStyle.test.ts b/src/ui/diff/rowStyle.test.ts
new file mode 100644
index 000000000..0052bfb76
--- /dev/null
+++ b/src/ui/diff/rowStyle.test.ts
@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import { contrastRatio } from "../lib/color";
+import { THEMES, TRANSPARENT_BACKGROUND, withTransparentSurfaces } from "../themes";
+import { cursorLineHighlightBg, stackCellPalette } from "./rowStyle";
+
+const DARK = THEMES.find((theme) => theme.id === "github-dark-dimmed")!;
+const LIGHT = THEMES.find((theme) => theme.id === "github-light-default")!;
+
+describe("cursorLineHighlightBg", () => {
+  test("marks context rows on transparent surfaces", () => {
+    for (const base of [DARK, LIGHT]) {
+      const theme = withTransparentSurfaces(base);
+      const context = stackCellPalette("context", theme);
+
+      expect(context.contentBg).toBe(TRANSPARENT_BACKGROUND);
+      expect(cursorLineHighlightBg(context.contentBg, theme)).not.toBe(TRANSPARENT_BACKGROUND);
+    }
+  });
+
+  test("keeps the marked row readable on every built-in theme", () => {
+    for (const base of THEMES) {
+      for (const theme of [base, withTransparentSurfaces(base)]) {
+        for (const kind of ["context", "addition", "deletion"] as const) {
+          const marked = cursorLineHighlightBg(stackCellPalette(kind, theme).contentBg, theme);
+          expect(contrastRatio(theme.text, marked)).toBeGreaterThan(3);
+        }
+      }
+    }
+  });
+
+  test("moves added and removed rows as far as it moves context rows", () => {
+    const context = stackCellPalette("context", DARK).contentBg;
+    const added = stackCellPalette("addition", DARK).contentBg;
+
+    const shift = (from: string) => {
+      const to = cursorLineHighlightBg(from, DARK);
+      return contrastRatio(to, from);
+    };
+
+    expect(shift(added)).toBeGreaterThan(1.2);
+    expect(shift(context)).toBeGreaterThan(1.2);
+  });
+});
diff --git a/src/ui/diff/rowStyle.ts b/src/ui/diff/rowStyle.ts
index df5274b50..0d41368c9 100644
--- a/src/ui/diff/rowStyle.ts
+++ b/src/ui/diff/rowStyle.ts
@@ -1,10 +1,32 @@
-import type { AppTheme } from "../themes";
+import { TRANSPARENT_BACKGROUND, type AppTheme } from "../themes";
 import { blendHex } from "../lib/color";
 import type { SplitLineCell, StackLineCell } from "./pierre";
 
 const INACTIVE_RAIL_BLEND = 0.35;
 const SELECTION_BG_BLEND = 0.75;
+const CURSOR_LINE_BG_BLEND = 0.2;
 const selectionBackgroundCache = new WeakMap<AppTheme, Map<string, string>>();
+const cursorLineBackgroundCache = new WeakMap<AppTheme, Map<string, string>>();
+
+/** Memoize one derived row background per theme and base color. */
+function cachedRowBackground(
+  cache: WeakMap<AppTheme, Map<string, string>>,
+  theme: AppTheme,
+  baseBg: string,
+  blend: () => string,
+) {
+  let backgrounds = cache.get(theme);
+  if (!backgrounds) {
+    backgrounds = new Map();
+    cache.set(theme, backgrounds);
+  }
+  let background = backgrounds.get(baseBg);
+  if (background === undefined) {
+    background = blend();
+    backgrounds.set(baseBg, background);
+  }
+  return background;
+}
 
 /** The diff rail marker is always visible in Hunk stack and split rows. */
 export function diffRailMarker() {
@@ -19,17 +41,29 @@ export function diffRailMarker() {
  * harder toward the visible highlight color.
  */
 export function selectionHighlightBg(baseBg: string, theme: AppTheme) {
-  let backgrounds = selectionBackgroundCache.get(theme);
-  if (!backgrounds) {
-    backgrounds = new Map();
-    selectionBackgroundCache.set(theme, backgrounds);
-  }
-  let background = backgrounds.get(baseBg);
-  if (!background) {
-    background = blendHex(theme.selectedHunk, baseBg, SELECTION_BG_BLEND);
-    backgrounds.set(baseBg, background);
-  }
-  return background;
+  return cachedRowBackground(selectionBackgroundCache, theme, baseBg, () =>
+    blendHex(theme.selectedHunk, baseBg, SELECTION_BG_BLEND),
+  );
+}
+
+/**
+ * Lift a cell background toward the theme text color to mark the current line.
+ *
+ * Shifts luminance rather than hue: blending toward one fixed color barely moves a background
+ * already sharing that hue, which left the marker invisible on added rows.
+ */
+export function cursorLineHighlightBg(baseBg: string, theme: AppTheme) {
+  return cachedRowBackground(cursorLineBackgroundCache, theme, baseBg, () => {
+    // Reading the sentinel as a color yields black, so a transparent surface blends from the
+    // appearance's own extreme instead.
+    const source =
+      baseBg === TRANSPARENT_BACKGROUND
+        ? theme.appearance === "dark"
+          ? "#000000"
+          : "#ffffff"
+        : baseBg;
+    return blendHex(theme.text, source, CURSOR_LINE_BG_BLEND);
+  });
 }
 
 /** Return the neutral active-hunk rail color for the current theme. */
diff --git a/src/ui/fileViews/geometry.test.ts b/src/ui/fileViews/geometry.test.ts
index 92c41e044..ef5a3fbd8 100644
--- a/src/ui/fileViews/geometry.test.ts
+++ b/src/ui/fileViews/geometry.test.ts
@@ -121,9 +121,38 @@ describe("file-view geometry", () => {
     });
 
     expect(geometry.fileViewRows).toBe(plan.rows);
-    expect(geometry.rowBounds.map((row) => row.height)).toEqual([noteHeight, 2]);
+    expect(geometry.rowBounds.map((row) => row.height)).toEqual([2, noteHeight]);
     expect(geometry.bodyHeight).toBe(noteHeight + 2);
-    expect(geometry.hunkAnchorRows.get(0)).toBe(noteHeight);
+    expect(geometry.hunkAnchorRows.get(0)).toBe(0);
     expect(geometry.hunkBounds.get(0)).toMatchObject({ top: 0, height: noteHeight + 2 });
   });
+
+  test("indexes every navigable row under the source line the review stream reveals it by", () => {
+    const checked = validateFileViewLayout(
+      {
+        rows: [
+          {
+            id: "summary",
+            spans: [{ text: "hunk 1" }],
+            sourceRanges: [{ side: "new", range: [1, 1] }],
+          },
+          { id: "detail", spans: [{ text: "detail" }] },
+        ],
+        hunkRows: [{ startRow: 0, endRow: 1 }],
+      },
+      1,
+      80,
+    );
+    if (!checked.valid) throw new Error(checked.issue);
+
+    const plan = buildFileViewRenderPlan(checked.value.layout, []);
+    const geometry = measureFileViewGeometry({
+      resolved: checked.value,
+      plannedRows: plan.rows,
+      width: 80,
+    });
+
+    expect(geometry.rowBoundsByStableKey.get("line:0:new:1")).toMatchObject({ top: 0 });
+    expect(geometry.rowBoundsByStableKey.get("file-view:summary")).toMatchObject({ top: 0 });
+  });
 });
diff --git a/src/ui/fileViews/geometry.ts b/src/ui/fileViews/geometry.ts
index bc6ff815e..e458d7ebd 100644
--- a/src/ui/fileViews/geometry.ts
+++ b/src/ui/fileViews/geometry.ts
@@ -49,14 +49,19 @@ export function measureFileViewGeometry({
     const entry: DiffSectionRowBounds = {
       key: row.key,
       stableKey: row.stableKey,
-      stableKeys: [row.stableKey],
+      stableKeys:
+        row.kind === "file-view-row" && row.stableAliasKeys
+          ? [row.stableKey, ...row.stableAliasKeys]
+          : [row.stableKey],
       top: bodyHeight,
       height: plannedFileViewRowHeight(row, resolved, width),
     };
     rowBounds.push(entry);
     rowBoundsByKey.set(entry.key, entry);
-    if (!rowBoundsByStableKey.has(entry.stableKey)) {
-      rowBoundsByStableKey.set(entry.stableKey, entry);
+    for (const stableKey of entry.stableKeys) {
+      if (!rowBoundsByStableKey.has(stableKey)) {
+        rowBoundsByStableKey.set(stableKey, entry);
+      }
     }
     bodyHeight += entry.height;
   }
diff --git a/src/ui/fileViews/renderPlan.test.ts b/src/ui/fileViews/renderPlan.test.ts
index 63f70d552..6367aaf96 100644
--- a/src/ui/fileViews/renderPlan.test.ts
+++ b/src/ui/fileViews/renderPlan.test.ts
@@ -31,7 +31,7 @@ function note(
 }
 
 describe("file-view render plan", () => {
-  test("inserts notes before the uniquely bound preferred-side row", () => {
+  test("inserts notes after the uniquely bound preferred-side row", () => {
     const plan = buildFileViewRenderPlan(layout, [
       note("both", { oldRange: [3, 3], newRange: [6, 7] }),
     ]);
@@ -39,10 +39,10 @@ describe("file-view render plan", () => {
     expect(plan.unresolvedNoteIds).toEqual([]);
     expect(plan.rows.map((row) => `${row.kind}:${row.key}`)).toEqual([
       "file-view-row:file-view:old-summary",
-      "inline-note:inline-note:both:file-view:new-summary:0",
       "file-view-row:file-view:new-summary",
+      "inline-note:inline-note:both:file-view:new-summary:0",
     ]);
-    expect(plan.rows[1]).toMatchObject({
+    expect(plan.rows[2]).toMatchObject({
       kind: "inline-note",
       anchorRowIndex: 1,
       anchorSide: "new",
@@ -50,6 +50,44 @@ describe("file-view render plan", () => {
     });
   });
 
+  test("anchors each row on the source line the raw diff addresses", () => {
+    const plan = buildFileViewRenderPlan(layout, []);
+
+    expect(
+      plan.rows.map((row) => (row.kind === "file-view-row" ? row.stableAliasKeys : [])),
+    ).toEqual([["line:0:old:2"], ["line:0:new:5"]]);
+  });
+
+  test("gives one source line to the first row that presents it", () => {
+    const repeated: ExtensionFileViewLayout = {
+      rows: [
+        { id: "first", spans: [{ text: "a" }], sourceRanges: [{ side: "new", range: [5, 5] }] },
+        { id: "second", spans: [{ text: "b" }], sourceRanges: [{ side: "new", range: [5, 5] }] },
+      ],
+      hunkRows: [{ startRow: 0, endRow: 1 }],
+    };
+    const plan = buildFileViewRenderPlan(repeated, []);
+
+    expect(
+      plan.rows.map((row) => (row.kind === "file-view-row" ? row.stableAliasKeys : [])),
+    ).toEqual([["line:0:new:5"], undefined]);
+  });
+
+  test("leaves rows outside one hunk unaddressable by line navigation", () => {
+    const spanningHunks: ExtensionFileViewLayout = {
+      ...layout,
+      hunkRows: [
+        { startRow: 0, endRow: 1 },
+        { startRow: 0, endRow: 1 },
+      ],
+    };
+    const plan = buildFileViewRenderPlan(spanningHunks, []);
+
+    expect(plan.rows.every((row) => row.kind !== "file-view-row" || !row.stableAliasKeys)).toBe(
+      true,
+    );
+  });
+
   test("groups notes at one anchor in stable input order", () => {
     const plan = buildFileViewRenderPlan(layout, [
       note("first", { newRange: [5, 5] }),
diff --git a/src/ui/fileViews/renderPlan.ts b/src/ui/fileViews/renderPlan.ts
index b705063df..15bc06ee4 100644
--- a/src/ui/fileViews/renderPlan.ts
+++ b/src/ui/fileViews/renderPlan.ts
@@ -1,5 +1,6 @@
 import type { AgentAnnotation } from "../../core/types";
 import type { ExtensionFileViewLayout, ExtensionFileViewRow } from "../../extension-api/types";
+import { inlineNoteStableKey, lineStableKey } from "../diff/reviewRenderPlan";
 import { annotationAnchor, type VisibleAgentNote } from "../lib/agentAnnotations";
 
 /** One validated extension row or host-owned inline note in an alternate file presentation. */
@@ -8,6 +9,8 @@ export type PlannedFileViewRow =
       readonly kind: "file-view-row";
       readonly key: string;
       readonly stableKey: string;
+      /** The source line this row presents, so review-stream navigation can address it. */
+      readonly stableAliasKeys?: readonly string[];
       readonly row: ExtensionFileViewRow;
       readonly rowIndex: number;
     }
@@ -47,6 +50,14 @@ function hunkOwnersByRow(layout: ExtensionFileViewLayout) {
   });
 }
 
+/** Build the line anchor one presentation row shares with the raw diff, if it owns exactly one hunk. */
+function rowLineStableKey(row: ExtensionFileViewRow, hunkIndex: number) {
+  const sourceRange = row.sourceRanges?.[0];
+  return hunkIndex < 0 || !sourceRange
+    ? undefined
+    : lineStableKey(hunkIndex, sourceRange.side, sourceRange.range[0]);
+}
+
 /** Find the unique validated presentation row containing one note's preferred source anchor. */
 function boundRowIndex(layout: ExtensionFileViewLayout, annotation: AgentAnnotation) {
   const anchor = annotationAnchor(annotation);
@@ -93,13 +104,31 @@ export function buildFileViewRenderPlan(
   }
 
   const rows: PlannedFileViewRow[] = [];
+  const claimedLineKeys = new Set<string>();
   for (const [rowIndex, row] of layout.rows.entries()) {
+    const key = `file-view:${row.id}`;
+    const lineKey = rowLineStableKey(row, hunkOwnerByRow[rowIndex]!);
+    // Only the first row on a line claims it, matching how measured bounds resolve duplicates.
+    const claimsLine = lineKey !== undefined && !claimedLineKeys.has(lineKey);
+    if (claimsLine) {
+      claimedLineKeys.add(lineKey);
+    }
+
+    rows.push({
+      kind: "file-view-row",
+      key,
+      stableKey: key,
+      ...(claimsLine ? { stableAliasKeys: [lineKey] } : {}),
+      row,
+      rowIndex,
+    });
+
     const anchoredNotes = notesByRow.get(rowIndex) ?? [];
     for (const [noteIndex, placement] of anchoredNotes.entries()) {
       rows.push({
         kind: "inline-note",
         key: `inline-note:${placement.note.id}:file-view:${row.id}:${noteIndex}`,
-        stableKey: `inline-note:${placement.note.id}`,
+        stableKey: inlineNoteStableKey(placement.note.id),
         annotation: placement.note.annotation,
         anchorRowIndex: rowIndex,
         anchorSide: placement.anchorSide,
@@ -109,8 +138,6 @@ export function buildFileViewRenderPlan(
         noteIndex,
       });
     }
-    const key = `file-view:${row.id}`;
-    rows.push({ kind: "file-view-row", key, stableKey: key, row, rowIndex });
   }
 
   return {
diff --git a/src/ui/hooks/useReviewController.test.tsx b/src/ui/hooks/useReviewController.test.tsx
index 18d9d0079..70ae897aa 100644
--- a/src/ui/hooks/useReviewController.test.tsx
+++ b/src/ui/hooks/useReviewController.test.tsx
@@ -9,6 +9,9 @@ import {
   createTestSourceFetcher,
   lines,
 } from "../../../test/helpers/diff-helpers";
+import { measureDiffSectionGeometry } from "../diff/diffSectionGeometry";
+import { buildLineCursors, type LineCursor } from "../lib/lineCursors";
+import { resolveTheme } from "../themes";
 import { useReviewController, type ReviewController } from "./useReviewController";
 
 /** Build a DiffFile with real parsed hunks using the controller's preferred defaults. */
@@ -98,7 +101,25 @@ function ReviewControllerHarness({
   onSetFiles?: (setFiles: (nextFiles: DiffFile[]) => void) => void;
 }) {
   const [files, setFiles] = useState(initialFiles);
-  const controller = useReviewController({ files, noteGeometry, stmlEnabled });
+  const [lineCursors, setLineCursors] = useState<LineCursor[]>([]);
+  const controller = useReviewController({ files, lineCursors, noteGeometry, stmlEnabled });
+  const visibleFiles = controller.visibleFiles;
+
+  useEffect(() => {
+    setLineCursors(
+      buildLineCursors(
+        visibleFiles,
+        visibleFiles.map((file) =>
+          measureDiffSectionGeometry(
+            file,
+            "stack",
+            true,
+            resolveTheme("github-dark-default", null),
+          ),
+        ),
+      ),
+    );
+  }, [visibleFiles]);
 
   useEffect(() => {
     onController(controller);
@@ -1304,4 +1325,201 @@ describe("useReviewController", () => {
       });
     }
   });
+
+  test("seeds the current line at the selected hunk so the indicator is visible on launch", async () => {
+    const { controllerRef, setup } = await renderReviewController([createAlphaFile()]);
+
+    try {
+      await flush(setup);
+
+      const cursor = expectValue(expectValue(controllerRef.current).lineCursor);
+      expect(cursor.fileId).toBe("alpha");
+      expect(cursor.hunkIndex).toBe(0);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("moves the current line one row at a time and clamps at the top of the stream", async () => {
+    const { controllerRef, setup } = await renderReviewController([createTwoHunkFile()]);
+
+    try {
+      await flush(setup);
+      const first = expectValue(expectValue(controllerRef.current).lineCursor);
+
+      await act(async () => {
+        expectValue(controllerRef.current).moveLineCursor(1);
+      });
+      await flush(setup);
+      const second = expectValue(expectValue(controllerRef.current).lineCursor);
+      expect(second).not.toEqual(first);
+
+      await act(async () => {
+        expectValue(controllerRef.current).moveLineCursor(-1);
+      });
+      await flush(setup);
+      expect(expectValue(controllerRef.current).lineCursor).toEqual(first);
+
+      await act(async () => {
+        expectValue(controllerRef.current).moveLineCursor(-1);
+      });
+      await flush(setup);
+      expect(expectValue(controllerRef.current).lineCursor).toEqual(first);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("requests a reveal every time the current line moves", async () => {
+    const { controllerRef, setup } = await renderReviewController([createTwoHunkFile()]);
+
+    try {
+      await flush(setup);
+      const initialRequestId = expectValue(controllerRef.current).lineCursorRevealRequestId;
+
+      await act(async () => {
+        expectValue(controllerRef.current).moveLineCursor(1);
+      });
+      await flush(setup);
+
+      expect(expectValue(controllerRef.current).lineCursorRevealRequestId).toBe(
+        initialRequestId + 1,
+      );
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("carries hunk selection along as the current line crosses a hunk boundary", async () => {
+    const { controllerRef, setup } = await renderReviewController([createTwoHunkFile()]);
+
+    try {
+      await flush(setup);
+      expect(expectValue(controllerRef.current).selectedHunkIndex).toBe(0);
+
+      for (let step = 0; step < 40; step += 1) {
+        await act(async () => {
+          expectValue(controllerRef.current).moveLineCursor(1);
+        });
+      }
+      await flush(setup);
+
+      const cursor = expectValue(expectValue(controllerRef.current).lineCursor);
+      expect(cursor.hunkIndex).toBe(1);
+      expect(expectValue(controllerRef.current).selectedHunkIndex).toBe(1);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("moves the current line to the row a note is started on", async () => {
+    const { controllerRef, setup } = await renderReviewController([createTwoHunkFile()]);
+
+    try {
+      await flush(setup);
+
+      await act(async () => {
+        expectValue(controllerRef.current).startUserNote("alpha", 1, { side: "new", line: 12 });
+      });
+      await flush(setup);
+
+      expect(expectValue(controllerRef.current).lineCursor).toEqual({
+        fileId: "alpha",
+        hunkIndex: 1,
+        stableKey: "line:1:new:12",
+        target: { side: "new", line: 12 },
+      });
+      expect(expectValue(controllerRef.current).selectedHunkIndex).toBe(1);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("carries the current line along when hunk navigation moves the selection", async () => {
+    const { controllerRef, setup } = await renderReviewController([createTwoHunkFile()]);
+
+    try {
+      await flush(setup);
+      expect(expectValue(expectValue(controllerRef.current).lineCursor).hunkIndex).toBe(0);
+
+      await act(async () => {
+        expectValue(controllerRef.current).moveToHunk(1);
+      });
+      await flush(setup);
+
+      expect(expectValue(controllerRef.current).selectedHunkIndex).toBe(1);
+      expect(expectValue(expectValue(controllerRef.current).lineCursor).hunkIndex).toBe(1);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("recovers the current line when a reload retires the hunk it was on", async () => {
+    const { controllerRef, setFilesRef, setup } = await renderReviewController([
+      createTwoHunkFile(),
+    ]);
+
+    try {
+      await flush(setup);
+
+      await act(async () => {
+        expectValue(controllerRef.current).selectHunk("alpha", 1);
+      });
+      await flush(setup);
+      expect(expectValue(expectValue(controllerRef.current).lineCursor).hunkIndex).toBe(1);
+
+      await act(async () => {
+        expectValue(setFilesRef.current)([createSingleHunkFile()]);
+      });
+      await flush(setup);
+
+      const cursor = expectValue(expectValue(controllerRef.current).lineCursor);
+      expect(cursor.fileId).toBe("alpha");
+      expect(cursor.hunkIndex).toBe(0);
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
+
+  test("re-seeds the current line into the file a filter leaves visible", async () => {
+    const { controllerRef, setup } = await renderReviewController([
+      createDiffFile("alpha", "alpha.ts", "export const alpha = 1;\n", "export const alpha = 2;\n"),
+      createDiffFile(
+        "beta",
+        "beta.ts",
+        "export const beta = 1;\n",
+        "export const betaValue = 2;\n",
+      ),
+    ]);
+
+    try {
+      await flush(setup);
+      expect(expectValue(expectValue(controllerRef.current).lineCursor).fileId).toBe("alpha");
+
+      await act(async () => {
+        expectValue(controllerRef.current).setFilter("beta");
+      });
+      await flush(setup);
+
+      expect(expectValue(expectValue(controllerRef.current).lineCursor).fileId).toBe("beta");
+    } finally {
+      await act(async () => {
+        setup.renderer.destroy();
+      });
+    }
+  });
 });
diff --git a/src/ui/hooks/useReviewController.ts b/src/ui/hooks/useReviewController.ts
index 9f211807c..c6a6e036d 100644
--- a/src/ui/hooks/useReviewController.ts
+++ b/src/ui/hooks/useReviewController.ts
@@ -41,6 +41,16 @@ import type { FileSourceStatus } from "../diff/expandCollapsedRows";
 import { selectGapForKeyboardToggle } from "../diff/expandCollapsedRows";
 import { trailingCollapsedLines } from "../diff/pierre";
 import { findNextHunkCursor } from "../lib/hunks";
+import {
+  EMPTY_LINE_CURSORS,
+  findLineCursorOnSide,
+  findNextLineCursor,
+  firstLineCursorInHunk,
+  hasLineCursor,
+  lineCursorAt,
+  resolveLineCursor,
+  type LineCursor,
+} from "../lib/lineCursors";
 import { agentNoteMarkupWidth } from "../lib/agentNoteGeometry";
 import { reviewNoteSource } from "../lib/agentAnnotations";
 import { STML_REFERENCE_WIDTH, validateStmlMarkup } from "../lib/stml/layout";
@@ -51,6 +61,17 @@ import {
   resolveReviewNavigationTarget,
 } from "../lib/reviewState";
 
+/** Add or remove one gap key from a file's expansion set. */
+function toggledGaps(current: ReadonlySet<string> | undefined, gapKey: string, expanding: boolean) {
+  const next = new Set(current ?? []);
+  if (expanding) {
+    next.add(gapKey);
+  } else {
+    next.delete(gapKey);
+  }
+  return next;
+}
+
 /** Clamp one numeric index into an inclusive range. */
 function clamp(value: number, min: number, max: number) {
   return Math.min(Math.max(value, min), max);
@@ -138,6 +159,11 @@ export interface ReviewController {
   reviewNoteCount: number;
   reviewNoteSummaries: SessionReviewNoteSummary[];
   userNotesByFileId: Record<string, UserReviewNote[]>;
+  lineCursor: LineCursor | null;
+  lineCursorRevealRequestId: number;
+  anchorLineCursor: (cursor: LineCursor) => void;
+  moveLineCursor: (delta: number) => void;
+  selectLineCursorSide: (side: "old" | "new") => void;
   moveToAnnotatedFile: (delta: number) => void;
   moveToAnnotatedHunk: (delta: number) => void;
   moveToFile: (delta: number) => void;
@@ -179,6 +205,7 @@ export interface ReviewController {
     fileId?: string,
     hunkIndex?: number,
     target?: UserNoteLineTarget,
+    options?: { preserveViewport?: boolean },
   ) => DraftReviewNote | null;
   setFilter: (value: string) => void;
   updateDraftNote: (body: string) => void;
@@ -194,10 +221,16 @@ export interface AgentNoteGeometrySnapshot {
 
 export function useReviewController({
   files,
+  lineCursors = EMPTY_LINE_CURSORS,
   noteGeometry,
   stmlEnabled = false,
 }: {
   files: DiffFile[];
+  /**
+   * Navigable lines in rendered order, published by the pane that measures the review stream.
+   * Headless callers get none, which leaves `j` and `k` scrolling the viewport.
+   */
+  lineCursors?: LineCursor[];
   /** Allow STML bodies for live comments in this explicitly opted-in session. */
   stmlEnabled?: boolean;
   /**
@@ -212,6 +245,16 @@ export function useReviewController({
   const [selectedHunkIndex, setSelectedHunkIndex] = useState(0);
   const [selectedFileTopAlignRequestId, setSelectedFileTopAlignRequestId] = useState(0);
   const [selectedHunkRevealRequestId, setSelectedHunkRevealRequestId] = useState(0);
+  const [lineCursor, setLineCursor] = useState<LineCursor | null>(null);
+  // A held key drains as one stdin chunk, so every press in the burst would otherwise read the
+  // same pre-batch state and the cursor would advance a single row.
+  const lineCursorRef = useRef<LineCursor | null>(null);
+  const [lineCursorRevealRequestId, setLineCursorRevealRequestId] = useState(0);
+  const previousLineCursorsRef = useRef(lineCursors);
+  const pendingLineCursorRef = useRef<
+    { kind: "reveal"; fileId: string } | { kind: "restore"; cursor: LineCursor } | null
+  >(null);
+  const lineCursorBeforeExpandRef = useRef(new Map<string, LineCursor>());
   const [scrollToNote, setScrollToNote] = useState(false);
   const [liveCommentsByFileId, setLiveCommentsByFileId] = useState<Record<string, LiveComment[]>>(
     {},
@@ -233,6 +276,10 @@ export function useReviewController({
   // waiting for React's state updater to commit.
   const sourceStatusRef = useRef(sourceStatusByFileId);
   sourceStatusRef.current = sourceStatusByFileId;
+  // Mirror the expansion set for the same reason: toggleGap has to know which way it is toggling
+  // before its own updater commits.
+  const expandedGapsRef = useRef(expandedGapsByFileId);
+  expandedGapsRef.current = expandedGapsByFileId;
   const sourceLoadRequestsRef = useRef(new Map<string, SourceLoadRequest>());
   const nextSourceLoadRequestIdRef = useRef(1);
 
@@ -260,6 +307,11 @@ export function useReviewController({
     if (staleFileIds.size > 0) {
       for (const fileId of staleFileIds) {
         sourceLoadRequestsRef.current.delete(fileId);
+        for (const restorePointKey of lineCursorBeforeExpandRef.current.keys()) {
+          if (restorePointKey.startsWith(`${fileId}:`)) {
+            lineCursorBeforeExpandRef.current.delete(restorePointKey);
+          }
+        }
       }
       setSourceStatusByFileId((prev) => removeKeys(prev, staleFileIds));
       setExpandedGapsByFileId((prev) => removeKeys(prev, staleFileIds));
@@ -357,6 +409,110 @@ export function useReviewController({
     reconcileSelectedHunkIndex();
   }, [reconcileSelectedHunkIndex]);
 
+  /**
+   * Keep the current line on a row the review stream still renders.
+   *
+   * Seeding from the selected hunk makes the marker visible from launch, not just after the
+   * first keypress.
+   */
+  const applyLineCursor = useCallback((next: LineCursor | null) => {
+    lineCursorRef.current = next;
+    setLineCursor(next);
+  }, []);
+
+  /** Move the current line to a row the reviewer just asked to see, and scroll to it. */
+  const revealLineCursor = useCallback(
+    (cursor: LineCursor) => {
+      applyLineCursor(cursor);
+      setLineCursorRevealRequestId((current) => current + 1);
+      selectHunk(cursor.fileId, cursor.hunkIndex, { preserveViewport: true });
+    },
+    [applyLineCursor, selectHunk],
+  );
+
+  const reconcileLineCursor = useCallback(() => {
+    // Expansion remeasures before its source text loads, so a toggle records what it wants and
+    // this waits for the list that actually carries the revealed rows. Each request survives until
+    // it resolves or the next toggle replaces it.
+    const previousCursors = previousLineCursorsRef.current;
+    previousLineCursorsRef.current = lineCursors;
+
+    const pending = pendingLineCursorRef.current;
+    if (pending?.kind === "reveal") {
+      const alreadyStopped = new Set(
+        previousCursors
+          .filter((cursor) => cursor.fileId === pending.fileId)
+          .map((cursor) => cursor.stableKey),
+      );
+      const firstRevealed = lineCursors.find(
+        (cursor) => cursor.fileId === pending.fileId && !alreadyStopped.has(cursor.stableKey),
+      );
+      if (firstRevealed) {
+        pendingLineCursorRef.current = null;
+        revealLineCursor(firstRevealed);
+        return;
+      }
+    }
+
+    // Only take the restore point when the collapse actually retired the row the marker was on;
+    // the reviewer may have stepped well clear of the gap since expanding it.
+    if (pending?.kind === "restore" && !hasLineCursor(lineCursors, lineCursorRef.current)) {
+      const restored = resolveLineCursor(lineCursors, pending.cursor);
+      if (restored) {
+        pendingLineCursorRef.current = null;
+        revealLineCursor(restored);
+        return;
+      }
+    }
+
+    const resolved = resolveLineCursor(lineCursors, lineCursorRef.current);
+    if (resolved?.fileId === selectedFileId && resolved?.hunkIndex === selectedHunkIndex) {
+      applyLineCursor(resolved);
+      return;
+    }
+
+    applyLineCursor(firstLineCursorInHunk(lineCursors, selectedFileId, selectedHunkIndex));
+  }, [applyLineCursor, lineCursors, revealLineCursor, selectedFileId, selectedHunkIndex]);
+
+  useEffect(() => {
+    reconcileLineCursor();
+  }, [reconcileLineCursor]);
+
+  /** Adopt a current line the viewport already settled on, without scrolling back to it. */
+  const anchorLineCursor = useCallback(
+    (cursor: LineCursor) => {
+      applyLineCursor(cursor);
+      selectHunk(cursor.fileId, cursor.hunkIndex, { preserveViewport: true });
+    },
+    [applyLineCursor, selectHunk],
+  );
+
+  /** Move the current line one row through the visible review stream. */
+  const moveLineCursor = useCallback(
+    (delta: number) => {
+      const nextCursor = findNextLineCursor(lineCursors, lineCursorRef.current, delta);
+      if (!nextCursor) {
+        return;
+      }
+
+      revealLineCursor(nextCursor);
+    },
+    [lineCursors, revealLineCursor],
+  );
+
+  /** Move the current split row's target between its old and new sides. */
+  const selectLineCursorSide = useCallback(
+    (side: "old" | "new") => {
+      const nextCursor = findLineCursorOnSide(lineCursors, lineCursorRef.current, side);
+      if (!nextCursor || nextCursor === lineCursorRef.current) {
+        return;
+      }
+
+      revealLineCursor(nextCursor);
+    },
+    [lineCursors, revealLineCursor],
+  );
+
   /** Move through the full visible review stream one hunk at a time. */
   const moveToHunk = useCallback(
     (delta: number) => {
@@ -450,16 +606,29 @@ export function useReviewController({
         return;
       }
 
-      setExpandedGapsByFileId((prev) => {
-        const current = prev[fileId];
-        const next = new Set(current ?? []);
-        if (next.has(gapKey)) {
-          next.delete(gapKey);
-        } else {
-          next.add(gapKey);
+      const restorePointKey = `${fileId}:${gapKey}`;
+      const restorePoint = lineCursorBeforeExpandRef.current.get(restorePointKey) ?? null;
+      const expanding = !expandedGapsRef.current[fileId]?.has(gapKey);
+      if (expanding) {
+        if (lineCursorRef.current) {
+          lineCursorBeforeExpandRef.current.set(restorePointKey, lineCursorRef.current);
         }
-        return { ...prev, [fileId]: next };
-      });
+        pendingLineCursorRef.current = { kind: "reveal", fileId };
+      } else {
+        lineCursorBeforeExpandRef.current.delete(restorePointKey);
+        pendingLineCursorRef.current = restorePoint
+          ? { kind: "restore", cursor: restorePoint }
+          : null;
+      }
+
+      expandedGapsRef.current = {
+        ...expandedGapsRef.current,
+        [fileId]: toggledGaps(expandedGapsRef.current[fileId], gapKey, expanding),
+      };
+      setExpandedGapsByFileId((prev) => ({
+        ...prev,
+        [fileId]: toggledGaps(prev[fileId], gapKey, expanding),
+      }));
 
       // The fetcher caches its own resolved text; we mirror it into React state
       // as a tagged status so the UI can distinguish loading, loaded, and error
@@ -861,6 +1030,7 @@ export function useReviewController({
       fileId = selectedFile?.id,
       hunkIndex = selectedHunkIndex,
       requestedTarget?: UserNoteLineTarget,
+      options?: { preserveViewport?: boolean },
     ): DraftReviewNote | null => {
       const file = allFiles.find((candidate) => candidate.id === fileId);
       const hunk = file?.metadata.hunks[hunkIndex];
@@ -869,6 +1039,7 @@ export function useReviewController({
       }
 
       const target = requestedTarget ?? firstCommentTargetForHunk(hunk);
+      applyLineCursor(lineCursorAt(lineCursors, file.id, hunkIndex, target));
       const draft: DraftReviewNote = {
         id: `draft:${file.id}:${hunkIndex}:${Date.now()}`,
         fileId: file.id,
@@ -885,11 +1056,11 @@ export function useReviewController({
       selectHunk(
         file.id,
         hunkIndex,
-        requestedTarget ? { preserveViewport: true } : { scrollToNote: true },
+        options?.preserveViewport ? { preserveViewport: true } : { scrollToNote: true },
       );
       return draft;
     },
-    [allFiles, selectHunk, selectedFile?.id, selectedHunkIndex],
+    [allFiles, applyLineCursor, lineCursors, selectHunk, selectedFile?.id, selectedHunkIndex],
   );
 
   /** Update the body of the active draft note. */
@@ -1056,6 +1227,8 @@ export function useReviewController({
     liveCommentCount,
     liveCommentSummaries,
     liveCommentsByFileId,
+    lineCursor,
+    lineCursorRevealRequestId,
     reviewNoteCount,
     reviewNoteSummaries,
     userNotesByFileId,
@@ -1072,9 +1245,12 @@ export function useReviewController({
     visibleFiles,
     addLiveComment,
     addLiveCommentBatch,
+    anchorLineCursor,
     clearFilter,
     cancelDraftNote,
     clearLiveComments,
+    moveLineCursor,
+    selectLineCursorSide,
     moveToAnnotatedFile,
     moveToAnnotatedHunk,
     moveToFile,
diff --git a/src/ui/lib/appCommands.test.ts b/src/ui/lib/appCommands.test.ts
index 539849793..cea47b567 100644
--- a/src/ui/lib/appCommands.test.ts
+++ b/src/ui/lib/appCommands.test.ts
@@ -50,6 +50,9 @@ function createTestCommands(resolvedKeys?: ResolvedCommandKeys) {
     resolvedKeys,
     scrollCodeHorizontally: record("scrollCodeHorizontally"),
     scrollDiff: record("scrollDiff"),
+    selectCursorLine: record("selectCursorLine"),
+    selectLineCursorSide: record("selectLineCursorSide"),
+    stepDiffLine: record("stepDiffLine"),
     selectLayoutMode: record("selectLayoutMode"),
     startUserNote: record("startUserNote"),
     toggleAgentNotes: record("toggleAgentNotes"),
@@ -86,6 +89,8 @@ describe("built-in command chords", () => {
     expect(press({ name: "j", sequence: "j" })).toBe("hunk.review.stepDown");
     expect(press({ name: "up" })).toBe("hunk.review.stepUp");
     expect(press({ name: "k", sequence: "k" })).toBe("hunk.review.stepUp");
+    expect(press({ name: "h", sequence: "h" })).toBe("hunk.review.selectOldSide");
+    expect(press({ name: "l", sequence: "l" })).toBe("hunk.review.selectNewSide");
     expect(press({ name: "d", sequence: "d" })).toBe("hunk.review.halfPageDown");
     expect(press({ name: "u", sequence: "u" })).toBe("hunk.review.halfPageUp");
     expect(ran).toEqual([
@@ -95,10 +100,12 @@ describe("built-in command chords", () => {
       "scrollDiff:-1,viewport",
       "scrollDiff:-1,viewport",
       "scrollDiff:-1,viewport",
-      "scrollDiff:1,step",
-      "scrollDiff:1,step",
-      "scrollDiff:-1,step",
-      "scrollDiff:-1,step",
+      "stepDiffLine:1",
+      "stepDiffLine:1",
+      "stepDiffLine:-1",
+      "stepDiffLine:-1",
+      "selectLineCursorSide:old",
+      "selectLineCursorSide:new",
       "scrollDiff:1,half",
       "scrollDiff:-1,half",
     ]);
@@ -219,7 +226,11 @@ describe("builtinCommandKeyDefaults", () => {
       "hunk.review.nextAnnotatedFile",
       "hunk.review.previousAnnotatedFile",
       "hunk.view.applyFilePresentationToAllMatching",
+      "hunk.view.cursorLineNumber",
+      "hunk.view.cursorLineOff",
+      "hunk.view.cursorLineRow",
       "hunk.view.toggleCopyDecorations",
+      "hunk.view.toggleLineNumbers",
     ]);
   });
 });
diff --git a/src/ui/lib/appCommands.ts b/src/ui/lib/appCommands.ts
index 32e3c1688..f5afc70cf 100644
--- a/src/ui/lib/appCommands.ts
+++ b/src/ui/lib/appCommands.ts
@@ -1,5 +1,5 @@
 import type { KeyEvent } from "@opentui/core";
-import type { LayoutMode } from "../../core/types";
+import type { CursorLine, LayoutMode } from "../../core/types";
 import {
   matchesAnyKeyChord,
   parseKeyChordOrUndefined,
@@ -91,6 +91,9 @@ export interface BuildAppCommandsOptions {
   resolvedKeys?: ResolvedCommandKeys;
   scrollCodeHorizontally: (delta: number) => void;
   scrollDiff: (delta: number, unit: ScrollUnit) => void;
+  stepDiffLine: (delta: number) => void;
+  selectCursorLine: (style: CursorLine) => void;
+  selectLineCursorSide: (side: "old" | "new") => void;
   selectLayoutMode: (mode: LayoutMode) => void;
   startUserNote: () => void;
   toggleAgentNotes: () => void;
@@ -203,13 +206,13 @@ function builtinCommandSpecs(options: BuildAppCommandsOptions): BuiltinCommandSp
       id: "hunk.review.stepDown",
       title: "Scroll down one row",
       defaultKeys: ["down", "j"],
-      run: () => options.scrollDiff(1, "step"),
+      run: () => options.stepDiffLine(1),
     },
     {
       id: "hunk.review.stepUp",
       title: "Scroll up one row",
       defaultKeys: ["up", "k"],
-      run: () => options.scrollDiff(-1, "step"),
+      run: () => options.stepDiffLine(-1),
     },
     {
       id: "hunk.review.scrollCodeLeft",
@@ -227,6 +230,39 @@ function builtinCommandSpecs(options: BuildAppCommandsOptions): BuiltinCommandSp
       run: (key) =>
         options.scrollCodeHorizontally(key.shift ? FAST_CODE_HORIZONTAL_SCROLL_COLUMNS : 1),
     },
+    {
+      id: "hunk.review.selectOldSide",
+      title: "Select old side of current line",
+      defaultKeys: ["h"],
+      run: () => options.selectLineCursorSide("old"),
+    },
+    {
+      id: "hunk.review.selectNewSide",
+      title: "Select new side of current line",
+      defaultKeys: ["l"],
+      run: () => options.selectLineCursorSide("new"),
+    },
+    {
+      id: "hunk.view.cursorLineRow",
+      title: "Highlight the current row",
+      defaultKeys: [],
+      run: () => options.selectCursorLine("row"),
+      closesMenu: true,
+    },
+    {
+      id: "hunk.view.cursorLineNumber",
+      title: "Mark the current line number",
+      defaultKeys: [],
+      run: () => options.selectCursorLine("number"),
+      closesMenu: true,
+    },
+    {
+      id: "hunk.view.cursorLineOff",
+      title: "Hide the current-line marker",
+      defaultKeys: [],
+      run: () => options.selectCursorLine("off"),
+      closesMenu: true,
+    },
     {
       id: "hunk.view.layoutSplit",
       title: "Split layout",
@@ -288,7 +324,7 @@ function builtinCommandSpecs(options: BuildAppCommandsOptions): BuiltinCommandSp
     {
       id: "hunk.view.toggleLineNumbers",
       title: "Toggle line numbers",
-      defaultKeys: ["l"],
+      defaultKeys: [],
       run: () => options.toggleLineNumbers(),
       closesMenu: true,
     },
@@ -437,6 +473,9 @@ const NOOP_COMMAND_OPTIONS: BuildAppCommandsOptions = (() => {
     requestQuit: noop,
     scrollCodeHorizontally: noop,
     scrollDiff: noop,
+    stepDiffLine: noop,
+    selectCursorLine: noop,
+    selectLineCursorSide: noop,
     selectLayoutMode: noop,
     startUserNote: noop,
     toggleAgentNotes: noop,
diff --git a/src/ui/lib/appMenus.test.ts b/src/ui/lib/appMenus.test.ts
index 9fdf94213..369b1c87a 100644
--- a/src/ui/lib/appMenus.test.ts
+++ b/src/ui/lib/appMenus.test.ts
@@ -16,6 +16,7 @@ import { resolveCommandKeys } from "./keymap";
 /** The app-state half of the menu options, so tests only state what they exercise. */
 const MENU_STATE: Omit<BuildAppMenusOptions, "commands" | "extensionCommands"> = {
   copyDecorations: true,
+  cursorLine: "row" as const,
   layoutMode: "stack",
   renderSidebar: false,
   showAgentNotes: true,
@@ -49,6 +50,9 @@ function createTestCommands(overrides: Partial<BuildAppCommandsOptions> = {}) {
     requestQuit: record("requestQuit"),
     scrollCodeHorizontally: noop,
     scrollDiff: noop,
+    selectCursorLine: noop,
+    selectLineCursorSide: noop,
+    stepDiffLine: noop,
     selectLayoutMode: noop,
     startUserNote: noop,
     toggleAgentNotes: noop,
@@ -96,6 +100,19 @@ function registeredCommand(
 }
 
 describe("buildAppMenus", () => {
+  test("the current-line entries check the active style", () => {
+    const { commands } = createTestCommands();
+
+    const checkedFor = (cursorLine: BuildAppMenusOptions["cursorLine"]) =>
+      items(buildAppMenus({ commands, ...MENU_STATE, cursorLine }).view)
+        .filter((item) => item.checked && item.label.startsWith("Current line:"))
+        .map((item) => item.label);
+
+    expect(checkedFor("row")).toEqual(["Current line: full row"]);
+    expect(checkedFor("number")).toEqual(["Current line: line number"]);
+    expect(checkedFor("off")).toEqual(["Current line: off"]);
+  });
+
   test("labels, hints, and checked state come from the commands and app state", () => {
     const { commands } = createTestCommands();
     const menus = buildAppMenus({ commands, ...MENU_STATE });
@@ -123,6 +140,7 @@ describe("buildAppMenus", () => {
       "Line numbers",
       "Line wrapping",
       "Copy decorations",
+      "Current line: full row",
     ]);
     expect(items(menus.view).map((item) => item.label)).toContain("Themes…");
     expect(items(menus.agent).map((item) => item.label)).toEqual([
diff --git a/src/ui/lib/appMenus.ts b/src/ui/lib/appMenus.ts
index 8db426208..8af8998b7 100644
--- a/src/ui/lib/appMenus.ts
+++ b/src/ui/lib/appMenus.ts
@@ -1,4 +1,4 @@
-import type { LayoutMode } from "../../core/types";
+import type { CursorLine, LayoutMode } from "../../core/types";
 import type { AppMenus, MenuEntry, MenuId } from "../components/chrome/menu";
 import { executeAppCommand, isCommandEnabled, type AppCommand } from "./appCommands";
 
@@ -37,6 +37,7 @@ export interface BuildAppMenusOptions {
   /** Live label for the stable host command that applies the selected presentation changeset-wide. */
   fileViewApplyAllLabel?: string;
   copyDecorations: boolean;
+  cursorLine: CursorLine;
   layoutMode: LayoutMode;
   renderSidebar: boolean;
   showAgentNotes: boolean;
@@ -125,6 +126,7 @@ export function buildAppMenus({
   fileViewEntries = [],
   fileViewApplyAllLabel,
   copyDecorations,
+  cursorLine,
   layoutMode,
   renderSidebar,
   showAgentNotes,
@@ -170,6 +172,21 @@ export function buildAppMenus({
         label: "Copy decorations",
         checked: copyDecorations,
       },
+      {
+        commandId: "hunk.view.cursorLineRow",
+        label: "Current line: full row",
+        checked: cursorLine === "row",
+      },
+      {
+        commandId: "hunk.view.cursorLineNumber",
+        label: "Current line: line number",
+        checked: cursorLine === "number",
+      },
+      {
+        commandId: "hunk.view.cursorLineOff",
+        label: "Current line: off",
+        checked: cursorLine === "off",
+      },
     ],
     navigate: [
       { commandId: "hunk.review.previousHunk" },
diff --git a/src/ui/lib/helpContent.test.ts b/src/ui/lib/helpContent.test.ts
index 1666a41cc..cef2c035d 100644
--- a/src/ui/lib/helpContent.test.ts
+++ b/src/ui/lib/helpContent.test.ts
@@ -32,8 +32,9 @@ describe("buildHelpSections", () => {
     expect(keysFor(sections, "previous / next hunk")).toBe("[ / ]");
     expect(keysFor(sections, "half page down / up")).toBe("d / u");
     expect(keysFor(sections, "move line-by-line")).toBe("Up / Down");
+    expect(keysFor(sections, "select old / new side")).toBe("h / l");
     expect(keysFor(sections, "split / stack / auto")).toBe("1 / 2 / 0");
-    expect(keysFor(sections, "lines / wrap / metadata / menu")).toBe("l / w / m / M");
+    expect(keysFor(sections, "wrap / metadata / menu")).toBe("w / m / M");
   });
 
   test("a row about one command lists every chord it answers to", () => {
diff --git a/src/ui/lib/helpContent.ts b/src/ui/lib/helpContent.ts
index 45e1c69ac..85b4be5f7 100644
--- a/src/ui/lib/helpContent.ts
+++ b/src/ui/lib/helpContent.ts
@@ -44,6 +44,10 @@ const HELP_SECTIONS: readonly HelpSectionSpec[] = [
         commandIds: ["hunk.review.stepUp", "hunk.review.stepDown"],
         description: "move line-by-line",
       },
+      {
+        commandIds: ["hunk.review.selectOldSide", "hunk.review.selectNewSide"],
+        description: "select old / new side",
+      },
       { commandIds: ["hunk.review.pageDown"], description: "page down" },
       { commandIds: ["hunk.review.pageUp"], description: "page up" },
       {
@@ -97,7 +101,7 @@ const HELP_SECTIONS: readonly HelpSectionSpec[] = [
           "hunk.view.toggleHunkHeaders",
           "hunk.view.toggleMenuBar",
         ],
-        description: "lines / wrap / metadata / menu",
+        description: "wrap / metadata / menu",
       },
       { commandIds: ["hunk.review.editSelectedFile"], description: "open file in $EDITOR" },
     ],
diff --git a/src/ui/lib/hunkScroll.test.ts b/src/ui/lib/hunkScroll.test.ts
index 8f00bb5a0..aa641d16d 100644
--- a/src/ui/lib/hunkScroll.test.ts
+++ b/src/ui/lib/hunkScroll.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { computeHunkRevealScrollTop } from "./hunkScroll";
+import { computeHunkRevealScrollTop, computeLineRevealScrollTop } from "./hunkScroll";
 
 describe("computeHunkRevealScrollTop", () => {
   test("keeps a fitting hunk fully visible when the preferred padding would clip the end", () => {
@@ -57,3 +57,35 @@ describe("computeHunkRevealScrollTop", () => {
     ).toBe(19);
   });
 });
+
+describe("computeLineRevealScrollTop", () => {
+  test("leaves the viewport alone when the line is already visible", () => {
+    expect(
+      computeLineRevealScrollTop({ lineTop: 12, lineHeight: 1, scrollTop: 10, viewportHeight: 20 }),
+    ).toBe(10);
+  });
+
+  test("scrolls up just far enough to reach a line above the viewport", () => {
+    expect(
+      computeLineRevealScrollTop({ lineTop: 4, lineHeight: 1, scrollTop: 10, viewportHeight: 20 }),
+    ).toBe(4);
+  });
+
+  test("scrolls down just far enough to reach a line below the viewport", () => {
+    expect(
+      computeLineRevealScrollTop({ lineTop: 40, lineHeight: 1, scrollTop: 10, viewportHeight: 20 }),
+    ).toBe(21);
+  });
+
+  test("keeps a tall wrapped line's end on screen", () => {
+    expect(
+      computeLineRevealScrollTop({ lineTop: 28, lineHeight: 3, scrollTop: 10, viewportHeight: 20 }),
+    ).toBe(11);
+  });
+
+  test("never scrolls above the top of the stream", () => {
+    expect(
+      computeLineRevealScrollTop({ lineTop: 0, lineHeight: 40, scrollTop: 5, viewportHeight: 20 }),
+    ).toBe(0);
+  });
+});
diff --git a/src/ui/lib/hunkScroll.ts b/src/ui/lib/hunkScroll.ts
index 7057cd27f..9de6c9cd7 100644
--- a/src/ui/lib/hunkScroll.ts
+++ b/src/ui/lib/hunkScroll.ts
@@ -33,3 +33,37 @@ export function computeHunkRevealScrollTop({
 
   return desiredTop;
 }
+
+/**
+ * Pick a scroll target that brings the current line just into view.
+ *
+ * This runs on every step key, so it moves the minimum distance and stays put while the line is
+ * already on screen; hunk reveal's top bias would yank the viewport on each keystroke.
+ */
+export function computeLineRevealScrollTop({
+  lineTop,
+  lineHeight,
+  scrollTop,
+  viewportHeight,
+}: {
+  lineTop: number;
+  lineHeight: number;
+  scrollTop: number;
+  viewportHeight: number;
+}) {
+  const clampedTop = Math.max(0, lineTop);
+  const clampedHeight = Math.max(1, lineHeight);
+  const clampedViewportHeight = Math.max(0, viewportHeight);
+
+  if (clampedTop < scrollTop) {
+    return clampedTop;
+  }
+
+  const lineBottom = clampedTop + clampedHeight;
+  const viewportBottom = scrollTop + clampedViewportHeight;
+  if (lineBottom > viewportBottom) {
+    return Math.max(0, lineBottom - clampedViewportHeight);
+  }
+
+  return scrollTop;
+}
diff --git a/src/ui/lib/lineCursors.test.ts b/src/ui/lib/lineCursors.test.ts
new file mode 100644
index 000000000..278347fcd
--- /dev/null
+++ b/src/ui/lib/lineCursors.test.ts
@@ -0,0 +1,425 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createTestDiffFile,
+  createTestHeaderOnlyDiffFile,
+  lines,
+} from "../../../test/helpers/diff-helpers";
+import type { DiffFile, LayoutMode } from "../../core/types";
+import { gapKey } from "../diff/expandCollapsedRows";
+import { measureDiffSectionGeometry } from "../diff/diffSectionGeometry";
+import { resolveTheme } from "../themes";
+import {
+  buildLineCursors,
+  clampLineCursorToViewport,
+  findLineCursorOnSide,
+  findNextLineCursor,
+  firstLineCursorInHunk,
+  resolveLineCursor,
+  type LineCursor,
+} from "./lineCursors";
+
+const theme = resolveTheme("github-dark-default", null);
+
+/** Enumerate the stops the review stream renders for these files in one layout. */
+function cursorsFor(files: DiffFile[], layout: Exclude<LayoutMode, "auto">) {
+  return buildLineCursors(
+    files,
+    files.map((file) => measureDiffSectionGeometry(file, layout, true, theme)),
+  );
+}
+
+/** Build a file whose single hunk wraps one changed line in context. */
+function createContextWrappedFile(id: string, path: string) {
+  return createTestDiffFile({
+    id,
+    path,
+    before: lines("one", "two", "three", "four"),
+    after: lines("one", "TWO", "three", "four"),
+    context: 1,
+  });
+}
+
+/** Build a file with two separated single-line changes and no context. */
+function createTwoHunkFile(id: string, path: string) {
+  return createTestDiffFile({
+    id,
+    path,
+    before: lines("a", "b", "c", "d", "e", "f", "g", "h", "i", "j"),
+    after: lines("A", "b", "c", "d", "e", "f", "g", "h", "i", "J"),
+    context: 0,
+  });
+}
+
+/** Build a file whose only change sits below a collapsible gap. */
+function createCollapsedGapFile() {
+  const before = lines("one", "two", "three", "four", "five", "six");
+  return createTestDiffFile({
+    id: "alpha",
+    path: "alpha.ts",
+    before,
+    after: lines("one", "two", "three", "four", "five", "SIX"),
+    context: 1,
+  });
+}
+
+describe("buildLineCursors", () => {
+  test("walks context and changed lines in rendered order", () => {
+    const cursors = cursorsFor([createContextWrappedFile("alpha", "alpha.ts")], "stack");
+
+    expect(cursors).toEqual([
+      {
+        fileId: "alpha",
+        hunkIndex: 0,
+        stableKey: "line:0:context:1:1",
+        target: { side: "new", line: 1 },
+      },
+      {
+        fileId: "alpha",
+        hunkIndex: 0,
+        stableKey: "line:0:old:2",
+        target: { side: "old", line: 2 },
+      },
+      {
+        fileId: "alpha",
+        hunkIndex: 0,
+        stableKey: "line:0:new:2",
+        target: { side: "new", line: 2 },
+      },
+      {
+        fileId: "alpha",
+        hunkIndex: 0,
+        stableKey: "line:0:context:3:3",
+        target: { side: "new", line: 3 },
+      },
+    ]);
+  });
+
+  test("keeps old and new line numbering independent across hunks", () => {
+    const cursors = cursorsFor([createTwoHunkFile("alpha", "alpha.ts")], "stack");
+
+    expect(cursors.map((cursor) => ({ hunkIndex: cursor.hunkIndex, ...cursor.target }))).toEqual([
+      { hunkIndex: 0, side: "old", line: 1 },
+      { hunkIndex: 0, side: "new", line: 1 },
+      { hunkIndex: 1, side: "old", line: 10 },
+      { hunkIndex: 1, side: "new", line: 10 },
+    ]);
+  });
+
+  test("pairs a change block's two sides per row in split layout", () => {
+    const file = createTestDiffFile({
+      id: "alpha",
+      path: "alpha.ts",
+      before: lines("a", "b", "c"),
+      after: lines("A", "B", "C"),
+      context: 0,
+    });
+
+    expect(cursorsFor([file], "split").map((cursor) => cursor.target)).toEqual([
+      { side: "old", line: 1 },
+      { side: "new", line: 1 },
+      { side: "old", line: 2 },
+      { side: "new", line: 2 },
+      { side: "old", line: 3 },
+      { side: "new", line: 3 },
+    ]);
+  });
+
+  test("walks a change block one column at a time in stack layout", () => {
+    const file = createTestDiffFile({
+      id: "alpha",
+      path: "alpha.ts",
+      before: lines("a", "b", "c"),
+      after: lines("A", "B", "C"),
+      context: 0,
+    });
+
+    expect(cursorsFor([file], "stack").map((cursor) => cursor.target)).toEqual([
+      { side: "old", line: 1 },
+      { side: "old", line: 2 },
+      { side: "old", line: 3 },
+      { side: "new", line: 1 },
+      { side: "new", line: 2 },
+      { side: "new", line: 3 },
+    ]);
+  });
+
+  test("stops on the lines an expanded gap reveals", () => {
+    const file = createCollapsedGapFile();
+    const source = lines("one", "two", "three", "four", "five", "SIX");
+    const collapsed = measureDiffSectionGeometry(file, "stack", true, theme);
+    const expanded = measureDiffSectionGeometry(
+      file,
+      "stack",
+      true,
+      theme,
+      [],
+      120,
+      true,
+      false,
+      new Set([gapKey("before", 0)]),
+      { kind: "loaded", text: source },
+    );
+
+    const collapsedLines = buildLineCursors([file], [collapsed]).map(
+      (cursor) => cursor.target.line,
+    );
+    const expandedLines = buildLineCursors([file], [expanded]).map((cursor) => cursor.target.line);
+
+    expect(collapsedLines).not.toContain(1);
+    expect(expandedLines).toContain(1);
+    expect(expandedLines.length).toBeGreaterThan(collapsedLines.length);
+  });
+
+  test("flattens every visible file into one review stream", () => {
+    const cursors = cursorsFor(
+      [createTwoHunkFile("alpha", "alpha.ts"), createTwoHunkFile("beta", "beta.ts")],
+      "stack",
+    );
+
+    expect(cursors).toHaveLength(8);
+    expect(cursors.slice(0, 4).every((cursor) => cursor.fileId === "alpha")).toBe(true);
+    expect(cursors.slice(4).every((cursor) => cursor.fileId === "beta")).toBe(true);
+  });
+
+  test("gives no stops to a file the stream renders no source lines for", () => {
+    const empty = createTestHeaderOnlyDiffFile();
+    const cursors = cursorsFor([createTwoHunkFile("alpha", "alpha.ts"), empty], "stack");
+
+    expect(cursors.some((cursor) => cursor.fileId === "alpha")).toBe(true);
+    expect(cursors.some((cursor) => cursor.fileId === empty.id)).toBe(false);
+    expect(firstLineCursorInHunk(cursors, empty.id, 0)).toBeNull();
+  });
+
+  test("returns nothing when no files are visible", () => {
+    expect(buildLineCursors([], [])).toEqual([]);
+  });
+});
+
+describe("findLineCursorOnSide", () => {
+  test("switches between paired old and new targets in split layout", () => {
+    const file = createTestDiffFile({
+      id: "alpha",
+      path: "alpha.ts",
+      before: lines("a"),
+      after: lines("A"),
+      context: 0,
+    });
+    const cursors = cursorsFor([file], "split");
+
+    expect(findLineCursorOnSide(cursors, cursors[0]!, "new")).toEqual(cursors[1]!);
+    expect(findLineCursorOnSide(cursors, cursors[1]!, "old")).toEqual(cursors[0]!);
+  });
+
+  test("selects either side of a context row without adding another vertical stop", () => {
+    const cursors = cursorsFor([createContextWrappedFile("alpha", "alpha.ts")], "split");
+    const context = cursors[0]!;
+
+    expect(findLineCursorOnSide(cursors, context, "old")).toEqual({
+      ...context,
+      target: { side: "old", line: 1 },
+    });
+    expect(findLineCursorOnSide(cursors, context, "new")).toEqual(context);
+  });
+});
+
+describe("findNextLineCursor", () => {
+  const cursors = cursorsFor(
+    [createTwoHunkFile("alpha", "alpha.ts"), createTwoHunkFile("beta", "beta.ts")],
+    "stack",
+  );
+
+  test("steps forward and backward one line at a time", () => {
+    expect(findNextLineCursor(cursors, cursors[0]!, 1)).toEqual(cursors[1]!);
+    expect(findNextLineCursor(cursors, cursors[1]!, -1)).toEqual(cursors[0]!);
+  });
+
+  test("rolls across hunk and file boundaries", () => {
+    expect(findNextLineCursor(cursors, cursors[1]!, 1)).toEqual(cursors[2]!);
+    expect(findNextLineCursor(cursors, cursors[3]!, 1)).toEqual(cursors[4]!);
+    expect(findNextLineCursor(cursors, cursors[4]!, -1)).toEqual(cursors[3]!);
+  });
+
+  test("clamps at both ends instead of wrapping", () => {
+    expect(findNextLineCursor(cursors, cursors[0]!, -1)).toEqual(cursors[0]!);
+    expect(findNextLineCursor(cursors, cursors[cursors.length - 1]!, 1)).toEqual(
+      cursors[cursors.length - 1]!,
+    );
+  });
+
+  test("starts at the top of the stream when no cursor is set", () => {
+    expect(findNextLineCursor(cursors, null, 1)).toEqual(cursors[0]!);
+    expect(findNextLineCursor(cursors, null, -1)).toEqual(cursors[0]!);
+  });
+
+  test("recovers to the top when the current line left the stream", () => {
+    const retired: LineCursor = {
+      fileId: "gamma",
+      hunkIndex: 4,
+      stableKey: "line:4:new:99",
+      target: { side: "new", line: 99 },
+    };
+
+    expect(findNextLineCursor(cursors, retired, 1)).toEqual(cursors[0]!);
+  });
+
+  test("returns nothing when the stream is empty", () => {
+    expect(findNextLineCursor([], null, 1)).toBeNull();
+  });
+});
+
+describe("firstLineCursorInHunk", () => {
+  const cursors = cursorsFor(
+    [createTwoHunkFile("alpha", "alpha.ts"), createTwoHunkFile("beta", "beta.ts")],
+    "stack",
+  );
+
+  test("seeds at the first line of the requested hunk", () => {
+    expect(firstLineCursorInHunk(cursors, "beta", 1)).toEqual({
+      fileId: "beta",
+      hunkIndex: 1,
+      stableKey: "line:1:old:10",
+      target: { side: "old", line: 10 },
+    });
+  });
+
+  test("falls back within the file when the hunk is gone", () => {
+    expect(firstLineCursorInHunk(cursors, "beta", 7)?.fileId).toBe("beta");
+  });
+
+  test("falls back to the top of the stream without a selected file", () => {
+    expect(firstLineCursorInHunk(cursors, undefined, 0)).toEqual(cursors[0]!);
+  });
+
+  test("returns nothing when the selected file has no navigable lines", () => {
+    expect(firstLineCursorInHunk(cursors, "gamma", 0)).toBeNull();
+  });
+
+  test("returns nothing when the stream is empty", () => {
+    expect(firstLineCursorInHunk([], "alpha", 0)).toBeNull();
+  });
+});
+
+describe("resolveLineCursor", () => {
+  const cursors = cursorsFor([createTwoHunkFile("alpha", "alpha.ts")], "stack");
+
+  test("keeps a cursor that still points at a real line", () => {
+    expect(resolveLineCursor(cursors, cursors[2]!)).toEqual(cursors[2]!);
+  });
+
+  test("falls back to the same hunk when the line is gone", () => {
+    const movedLine: LineCursor = {
+      fileId: "alpha",
+      hunkIndex: 1,
+      stableKey: "line:1:new:42",
+      target: { side: "new", line: 42 },
+    };
+
+    expect(resolveLineCursor(cursors, movedLine)).toEqual({
+      fileId: "alpha",
+      hunkIndex: 1,
+      stableKey: "line:1:old:10",
+      target: { side: "old", line: 10 },
+    });
+  });
+
+  test("falls back to the same file when the hunk is gone", () => {
+    const retiredHunk: LineCursor = {
+      fileId: "alpha",
+      hunkIndex: 9,
+      stableKey: "line:9:new:1",
+      target: { side: "new", line: 1 },
+    };
+
+    expect(resolveLineCursor(cursors, retiredHunk)?.fileId).toBe("alpha");
+  });
+
+  test("gives up when the file left the review stream", () => {
+    const filteredOut: LineCursor = {
+      fileId: "gamma",
+      hunkIndex: 0,
+      stableKey: "line:0:new:1",
+      target: { side: "new", line: 1 },
+    };
+
+    expect(resolveLineCursor(cursors, filteredOut)).toBeNull();
+  });
+
+  test("gives up when there is no cursor to resolve", () => {
+    expect(resolveLineCursor(cursors, null)).toBeNull();
+  });
+});
+
+describe("clampLineCursorToViewport", () => {
+  const cursors = cursorsFor([createTwoHunkFile("alpha", "alpha.ts")], "stack");
+  const boundsOf = (cursor: LineCursor) => {
+    const index = cursors.findIndex((candidate) => candidate.stableKey === cursor.stableKey);
+    return index < 0 ? undefined : { top: index, height: 1 };
+  };
+
+  test("leaves a visible current line where it is", () => {
+    expect(
+      clampLineCursorToViewport({
+        boundsOf,
+        current: cursors[1]!,
+        cursors,
+        scrollTop: 0,
+        viewportHeight: 3,
+      }),
+    ).toEqual(cursors[1]!);
+  });
+
+  test("snaps down to the first visible line after scrolling past it", () => {
+    expect(
+      clampLineCursorToViewport({
+        boundsOf,
+        current: cursors[0]!,
+        cursors,
+        scrollTop: 2,
+        viewportHeight: 2,
+      }),
+    ).toEqual(cursors[2]!);
+  });
+
+  test("snaps up to the last visible line after scrolling back above it", () => {
+    expect(
+      clampLineCursorToViewport({
+        boundsOf,
+        current: cursors[3]!,
+        cursors,
+        scrollTop: 0,
+        viewportHeight: 2,
+      }),
+    ).toEqual(cursors[1]!);
+  });
+
+  test("adopts the first visible line when the current one left the stream", () => {
+    const retired: LineCursor = {
+      fileId: "alpha",
+      hunkIndex: 9,
+      stableKey: "line:9:new:1",
+      target: { side: "new", line: 1 },
+    };
+
+    expect(
+      clampLineCursorToViewport({
+        boundsOf,
+        current: retired,
+        cursors,
+        scrollTop: 1,
+        viewportHeight: 2,
+      }),
+    ).toEqual(cursors[1]!);
+  });
+
+  test("keeps the current line when there is nothing to clamp to", () => {
+    expect(
+      clampLineCursorToViewport({
+        boundsOf,
+        current: cursors[0]!,
+        cursors: [],
+        scrollTop: 40,
+        viewportHeight: 4,
+      }),
+    ).toEqual(cursors[0]!);
+  });
+});
diff --git a/src/ui/lib/lineCursors.ts b/src/ui/lib/lineCursors.ts
new file mode 100644
index 000000000..2363391a5
--- /dev/null
+++ b/src/ui/lib/lineCursors.ts
@@ -0,0 +1,279 @@
+/**
+ * Line-granular navigation targets for the review stream.
+ *
+ * Stops come from the measured render plan rather than the parsed diff, so they match the rows the
+ * active layout draws and carry the plan anchor rendering, reveal, and note placement already use.
+ */
+
+import type { DiffFile, UserNoteLineTarget } from "../../core/types";
+import type { DiffSectionGeometry, DiffSectionRowBounds } from "../diff/diffSectionGeometry";
+import {
+  contextLineStableKeyTarget,
+  contextLineStableKeyTargetForSide,
+  lineStableKey,
+  lineStableKeyTarget,
+} from "../diff/reviewRenderPlan";
+import type { VerticalBounds } from "./diffSpatial";
+
+export interface LineCursor {
+  fileId: string;
+  hunkIndex: number;
+  /** The render plan's anchor for this row, shared with reveal and highlight lookups. */
+  stableKey: string;
+  target: UserNoteLineTarget;
+}
+
+export const EMPTY_LINE_CURSORS: LineCursor[] = [];
+
+const cursorsBySectionGeometry = new WeakMap<DiffSectionGeometry, LineCursor[]>();
+const indexesByCursorList = new WeakMap<LineCursor[], Map<string, number>>();
+
+/** Index one cursor list by position, so stepping does not rescan the changeset per keypress. */
+function cursorIndexes(cursors: LineCursor[]) {
+  let indexes = indexesByCursorList.get(cursors);
+  if (!indexes) {
+    indexes = new Map(cursors.map((cursor, index) => [cursorId(cursor), index]));
+    indexesByCursorList.set(cursors, indexes);
+  }
+  return indexes;
+}
+
+/** Identify one navigable line across the whole review stream. */
+function cursorId(cursor: LineCursor) {
+  return `${cursor.fileId}\u0000${cursor.stableKey}`;
+}
+
+/** Enumerate the navigable stops one measured row renders, left to right. */
+function rowLineCursors(fileId: string, bounds: DiffSectionRowBounds): LineCursor[] {
+  // A context row shows one source line on both sides, so its sided anchors name the same position.
+  const context = contextLineStableKeyTarget(bounds.stableKey);
+  if (context) {
+    const { hunkIndex, ...target } = context;
+    return [{ fileId, hunkIndex, stableKey: bounds.stableKey, target }];
+  }
+
+  const cursors: LineCursor[] = [];
+  for (const stableKey of bounds.stableKeys) {
+    const anchor = lineStableKeyTarget(stableKey);
+    if (!anchor) {
+      continue;
+    }
+
+    const { hunkIndex, ...target } = anchor;
+    cursors.push({ fileId, hunkIndex, stableKey, target });
+  }
+
+  return cursors;
+}
+
+/** List one file's cursors, reusing the last result while its measured rows are unchanged. */
+function fileLineCursors(file: DiffFile, geometry: DiffSectionGeometry): LineCursor[] {
+  const cached = cursorsBySectionGeometry.get(geometry);
+  if (cached) {
+    return cached;
+  }
+
+  const cursors = geometry.rowBounds.flatMap((bounds) => rowLineCursors(file.id, bounds));
+  cursorsBySectionGeometry.set(geometry, cursors);
+  return cursors;
+}
+
+/** Flatten the measured review stream into one ordered line cursor list. */
+export function buildLineCursors(
+  files: DiffFile[],
+  sectionGeometry: DiffSectionGeometry[],
+): LineCursor[] {
+  return files.flatMap((file, index) => {
+    const geometry = sectionGeometry[index];
+    return geometry ? fileLineCursors(file, geometry) : [];
+  });
+}
+
+/** Find the first cursor in one hunk, then anywhere in its file. */
+function nearestCursorInFile(cursors: LineCursor[], fileId: string, hunkIndex: number) {
+  return (
+    cursors.find((cursor) => cursor.fileId === fileId && cursor.hunkIndex === hunkIndex) ??
+    cursors.find((cursor) => cursor.fileId === fileId)
+  );
+}
+
+/**
+ * Find the first navigable line inside one hunk.
+ *
+ * Stays inside the requested file: falling back to the top of the stream would move the marker,
+ * and with it the selection, off the file the reviewer just picked.
+ */
+export function firstLineCursorInHunk(
+  cursors: LineCursor[],
+  fileId: string | undefined,
+  hunkIndex: number,
+): LineCursor | null {
+  if (!fileId) {
+    return cursors[0] ?? null;
+  }
+
+  return nearestCursorInFile(cursors, fileId, hunkIndex) ?? null;
+}
+
+/** Move forward or backward through the review-stream line cursor list. */
+export function findNextLineCursor(
+  cursors: LineCursor[],
+  current: LineCursor | null,
+  delta: number,
+): LineCursor | null {
+  const currentIndex = current ? (cursorIndexes(cursors).get(cursorId(current)) ?? -1) : -1;
+  if (currentIndex < 0) {
+    return cursors[0] ?? null;
+  }
+
+  const nextIndex = Math.min(Math.max(currentIndex + delta, 0), cursors.length - 1);
+  return cursors[nextIndex] ?? null;
+}
+
+/** Select the old or new target rendered on the current split row. */
+export function findLineCursorOnSide(
+  cursors: LineCursor[],
+  current: LineCursor | null,
+  side: "old" | "new",
+): LineCursor | null {
+  if (!current || current.target.side === side) {
+    return current;
+  }
+
+  const context = contextLineStableKeyTargetForSide(current.stableKey, side);
+  if (context) {
+    const { hunkIndex, ...target } = context;
+    return { ...current, hunkIndex, target };
+  }
+
+  const currentIndex = cursorIndexes(cursors).get(cursorId(current));
+  if (currentIndex === undefined) {
+    return current;
+  }
+
+  const candidate = cursors[currentIndex + (side === "old" ? -1 : 1)];
+  return candidate?.fileId === current.fileId &&
+    candidate.hunkIndex === current.hunkIndex &&
+    candidate.target.side === side
+    ? candidate
+    : current;
+}
+
+/** Check whether one cursor still names a row the review stream renders. */
+export function hasLineCursor(cursors: LineCursor[], cursor: LineCursor | null) {
+  return cursor !== null && cursorIndexes(cursors).has(cursorId(cursor));
+}
+
+/** Keep a cursor pointing at a real line after filtering or a reload retires the one it was on. */
+export function resolveLineCursor(
+  cursors: LineCursor[],
+  current: LineCursor | null,
+): LineCursor | null {
+  if (!current) {
+    return null;
+  }
+
+  if (hasLineCursor(cursors, current)) {
+    return current;
+  }
+
+  return nearestCursorInFile(cursors, current.fileId, current.hunkIndex) ?? null;
+}
+
+/**
+ * Resolve the navigable line one note target sits on.
+ *
+ * Notes can address a side the stream does not stop on, so fall back to that line's own anchor,
+ * which reveal and rendering still resolve through aliases.
+ */
+export function lineCursorAt(
+  cursors: LineCursor[],
+  fileId: string,
+  hunkIndex: number,
+  target: UserNoteLineTarget,
+): LineCursor {
+  const stop = cursors.find(
+    (cursor) =>
+      cursor.fileId === fileId &&
+      cursor.hunkIndex === hunkIndex &&
+      cursor.target.side === target.side &&
+      cursor.target.line === target.line,
+  );
+  return (
+    stop ?? {
+      fileId,
+      hunkIndex,
+      stableKey: lineStableKey(hunkIndex, target.side, target.line),
+      target,
+    }
+  );
+}
+
+/** Read one cursor's measured extent in whole-stream rows. */
+export type LineCursorBoundsLookup = (cursor: LineCursor) => VerticalBounds | undefined;
+
+/**
+ * Find the first cursor whose row satisfies a monotonic viewport test.
+ *
+ * Cursor tops are non-decreasing, so both edges of the viewport resolve by binary search instead of
+ * a walk over every row in the changeset.
+ */
+function firstCursorIndexWhere(
+  cursors: LineCursor[],
+  boundsOf: LineCursorBoundsLookup,
+  reached: (bounds: VerticalBounds) => boolean,
+) {
+  let low = 0;
+  let high = cursors.length;
+
+  while (low < high) {
+    const middle = (low + high) >>> 1;
+    const bounds = boundsOf(cursors[middle]!);
+    if (bounds && reached(bounds)) {
+      high = middle;
+    } else {
+      low = middle + 1;
+    }
+  }
+
+  return low;
+}
+
+/** Keep the current line inside the viewport after the reviewer scrolls past it. */
+export function clampLineCursorToViewport({
+  boundsOf,
+  current,
+  cursors,
+  scrollTop,
+  viewportHeight,
+}: {
+  boundsOf: LineCursorBoundsLookup;
+  current: LineCursor | null;
+  cursors: LineCursor[];
+  scrollTop: number;
+  viewportHeight: number;
+}): LineCursor | null {
+  if (cursors.length === 0 || viewportHeight <= 0) {
+    return current;
+  }
+
+  const viewportBottom = scrollTop + viewportHeight;
+  const currentBounds = current ? boundsOf(current) : undefined;
+  if (
+    currentBounds &&
+    currentBounds.top >= scrollTop &&
+    currentBounds.top + currentBounds.height <= viewportBottom
+  ) {
+    return current;
+  }
+
+  const scrolledPastAbove = !currentBounds || currentBounds.top < scrollTop;
+  const index = scrolledPastAbove
+    ? firstCursorIndexWhere(cursors, boundsOf, (bounds) => bounds.top >= scrollTop)
+    : firstCursorIndexWhere(
+        cursors,
+        boundsOf,
+        (bounds) => bounds.top + bounds.height > viewportBottom,
+      ) - 1;
+  return cursors[Math.min(Math.max(index, 0), cursors.length - 1)] ?? null;
+}
diff --git a/test/pty/cursor-line.test.ts b/test/pty/cursor-line.test.ts
new file mode 100644
index 000000000..d5220f3f7
--- /dev/null
+++ b/test/pty/cursor-line.test.ts
@@ -0,0 +1,233 @@
+import { afterEach, describe, expect, setDefaultTimeout, test } from "bun:test";
+import { createPtyHarness, lineIndexOf, measureKeyScroll } from "./harness";
+
+const harness = createPtyHarness();
+
+/** Give PTY-backed startup and redraws enough headroom for slower CI machines. */
+setDefaultTimeout(20_000);
+
+afterEach(() => {
+  harness.cleanup();
+});
+
+describe("PTY current line", () => {
+  test("stepping moves the current line before it moves the viewport", async () => {
+    const fixture = harness.createPinnedHeaderRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["show", "HEAD", "--mode", "stack"],
+      cwd: fixture.dir,
+      cols: 120,
+      rows: 24,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.waitIdle({ timeout: 300 });
+
+      expect(await measureKeyScroll(session, "j", 12)).toBe(0);
+
+      let stepsBeforeScrolling = 1;
+      let firstScroll = 0;
+      for (let step = 0; step < 40 && firstScroll === 0; step += 1) {
+        firstScroll = await measureKeyScroll(session, "j", 12);
+        stepsBeforeScrolling += 1;
+      }
+
+      expect(stepsBeforeScrolling).toBeGreaterThan(5);
+      expect(firstScroll).toBeGreaterThan(0);
+
+      expect(await measureKeyScroll(session, "j", 12)).toBe(1);
+      expect(await measureKeyScroll(session, "j", 12)).toBe(1);
+      expect(await measureKeyScroll(session, "k", 12)).toBe(0);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("a held step key advances one line per press", async () => {
+    const fixture = harness.createPinnedHeaderRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["show", "HEAD", "--mode", "stack"],
+      cwd: fixture.dir,
+      cols: 120,
+      rows: 24,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.waitIdle({ timeout: 300 });
+
+      let scrolled = 0;
+      for (let step = 0; step < 40 && scrolled === 0; step += 1) {
+        scrolled = await measureKeyScroll(session, "j", 12);
+      }
+      expect(scrolled).toBeGreaterThan(0);
+
+      const before = (await session.text({ immediate: true })).split("\n");
+      const anchor = before[12]?.trim() ?? "";
+      expect(anchor.length).toBeGreaterThan(0);
+
+      // A held key arrives as one chunk and drains synchronously, so every press in the burst
+      // has to see the move the press before it made.
+      await session.writeRaw("jjjjj");
+      await session.waitIdle({ timeout: 800 });
+
+      const after = (await session.text({ immediate: true })).split("\n");
+      expect(12 - after.findIndex((line) => line.trim() === anchor)).toBe(5);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("stepping reaches the lines an expanded gap reveals", async () => {
+    const fixture = harness.createExpandableContextFilePair();
+    const session = await harness.launchHunk({
+      args: ["diff", fixture.before, fixture.after, "--mode", "stack"],
+      cols: 140,
+      rows: 16,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.press("z");
+      await harness.waitForSnapshot(session, (text) => text.includes("hiddenLine01"), 5_000);
+      // The revealed rows reach navigation one commit after they reach the screen.
+      await session.waitIdle({ timeout: 500 });
+
+      await session.press("k");
+      await session.waitIdle({ timeout: 200 });
+      await session.press("c");
+      const draft = await session.waitForText(/Draft note/, { timeout: 5_000 });
+
+      expect(lineIndexOf(draft, "Draft note")).toBe(lineIndexOf(draft, "hiddenLine01") + 1);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("expanding a gap moves the current line into it and collapsing puts it back", async () => {
+    const fixture = harness.createExpandableContextFilePair();
+    const session = await harness.launchHunk({
+      args: ["diff", fixture.before, fixture.after, "--mode", "stack"],
+      cols: 140,
+      rows: 16,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.waitIdle({ timeout: 300 });
+      await session.press("c");
+      const beforeExpand = await session.waitForText(/Draft note/, { timeout: 5_000 });
+      const startRow = /Draft note[^R]*R(\d+)/.exec(beforeExpand)?.[1];
+      expect(startRow).toBeDefined();
+      await session.press("escape");
+      await harness.waitForSnapshot(session, (text) => !text.includes("Draft note"), 5_000);
+
+      await session.press("z");
+      await harness.waitForSnapshot(session, (text) => text.includes("hiddenLine01"), 5_000);
+      await session.waitIdle({ timeout: 500 });
+      await session.press("c");
+      const expanded = await session.waitForText(/Draft note/, { timeout: 5_000 });
+
+      expect(expanded).toContain("R1 ");
+      expect(lineIndexOf(expanded, "Draft note")).toBe(lineIndexOf(expanded, "hiddenLine01") + 1);
+      await session.press("escape");
+      await harness.waitForSnapshot(session, (text) => !text.includes("Draft note"), 5_000);
+
+      await session.press("z");
+      await harness.waitForSnapshot(session, (text) => !text.includes("hiddenLine01"), 5_000);
+      await session.waitIdle({ timeout: 500 });
+      await session.press("c");
+      const collapsed = await session.waitForText(/Draft note/, { timeout: 5_000 });
+
+      expect(collapsed).toContain(`R${startRow} `);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("paging leaves the current line on screen", async () => {
+    const fixture = harness.createPinnedHeaderRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["show", "HEAD", "--mode", "stack"],
+      cwd: fixture.dir,
+      cols: 120,
+      rows: 24,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.waitIdle({ timeout: 300 });
+
+      await session.press("space");
+      await session.waitIdle({ timeout: 400 });
+
+      expect(await measureKeyScroll(session, "j", 12)).toBeLessThanOrEqual(1);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("a note after paging opens where the reviewer is looking", async () => {
+    const fixture = harness.createPinnedHeaderRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["show", "HEAD", "--mode", "stack"],
+      cwd: fixture.dir,
+      cols: 120,
+      rows: 24,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.waitIdle({ timeout: 300 });
+
+      await session.press("space");
+      await session.waitIdle({ timeout: 400 });
+      const paged = (await session.text({ immediate: true })).split("\n");
+      const anchor = paged[12]?.trim() ?? "";
+      expect(anchor.length).toBeGreaterThan(0);
+
+      await session.press("c");
+      const draft = await session.waitForText(/Draft note/, { timeout: 5_000 });
+
+      expect(draft).toContain(anchor);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("a note anchors at the current line instead of the top of the hunk", async () => {
+    const fixture = harness.createPinnedHeaderRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["show", "HEAD", "--mode", "stack"],
+      cwd: fixture.dir,
+      cols: 120,
+      rows: 24,
+    });
+
+    try {
+      await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, { timeout: 15_000 });
+      await session.waitIdle({ timeout: 300 });
+
+      await session.press("c");
+      const draftAtTop = await session.waitForText(/Draft note/, { timeout: 5_000 });
+      const draftRowAtTop = lineIndexOf(draftAtTop, "Draft note");
+      expect(draftRowAtTop).toBeGreaterThan(0);
+
+      await session.press("escape");
+      await harness.waitForSnapshot(session, (text) => !text.includes("Draft note"), 5_000);
+
+      for (let step = 0; step < 4; step += 1) {
+        await session.press("j");
+        await session.waitIdle({ timeout: 200 });
+      }
+
+      await session.press("c");
+      const draftAtCursor = await session.waitForText(/Draft note/, { timeout: 5_000 });
+
+      expect(lineIndexOf(draftAtCursor, "Draft note")).toBeGreaterThan(draftRowAtTop);
+    } finally {
+      session.close();
+    }
+  });
+});
diff --git a/test/pty/key-routing.test.ts b/test/pty/key-routing.test.ts
index e678c83dd..c72dc5f11 100644
--- a/test/pty/key-routing.test.ts
+++ b/test/pty/key-routing.test.ts
@@ -264,7 +264,7 @@ describe("PTY key routing", () => {
   test("step keys still scroll exactly one row while a menu is open", async () => {
     const fixture = harness.createPinnedHeaderRepoFixture();
     const session = await harness.launchHunk({
-      args: ["show", "HEAD"],
+      args: ["show", "HEAD", "--cursor-line", "off"],
       cwd: fixture.dir,
       cols: 120,
       rows: 24,
diff --git a/test/pty/layout.test.ts b/test/pty/layout.test.ts
index 561c2e319..b71cbe9f4 100644
--- a/test/pty/layout.test.ts
+++ b/test/pty/layout.test.ts
@@ -215,6 +215,55 @@ describe("PTY layout", () => {
     }
   });
 
+  test("--sidebar shows the sidebar below the viewport width that would reveal it", async () => {
+    const fixture = harness.createTwoFileRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["diff", "--mode", "split", "--sidebar"],
+      cwd: fixture.dir,
+      cols: 180,
+      rows: 18,
+    });
+
+    try {
+      const frame = await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, {
+        timeout: 15_000,
+      });
+
+      expect(harness.countMatches(frame, /alpha\.ts/g)).toBeGreaterThanOrEqual(2);
+    } finally {
+      session.close();
+    }
+  });
+
+  test("--no-sidebar opens the review with the sidebar closed", async () => {
+    const fixture = harness.createTwoFileRepoFixture();
+    const session = await harness.launchHunk({
+      args: ["diff", "--mode", "split", "--no-sidebar"],
+      cwd: fixture.dir,
+      cols: 220,
+      rows: 18,
+    });
+
+    try {
+      const frame = await session.waitForText(/View\s+Navigate\s+Agent\s+Help/, {
+        timeout: 15_000,
+      });
+
+      expect(harness.countMatches(frame, /alpha\.ts/g)).toBe(1);
+
+      await session.type("s");
+      const toggled = await harness.waitForSnapshot(
+        session,
+        (text) => harness.countMatches(text, /alpha\.ts/g) >= 2,
+        5_000,
+      );
+
+      expect(harness.countMatches(toggled, /alpha\.ts/g)).toBeGreaterThanOrEqual(2);
+    } finally {
+      session.close();
+    }
+  });
+
   test("dragging the sidebar divider resizes the review pane in a real PTY", async () => {
     const fixture = harness.createTwoFileRepoFixture();
     const session = await harness.launchHunk({
diff --git a/test/pty/nav.test.ts b/test/pty/nav.test.ts
index 1cdabae78..277484147 100644
--- a/test/pty/nav.test.ts
+++ b/test/pty/nav.test.ts
@@ -222,7 +222,7 @@ describe("PTY navigation", () => {
       expect(initial).toContain("first.ts");
       expect(initial).toContain("second.ts");
 
-      for (let index = 0; index < 8; index += 1) {
+      for (let index = 0; index < 16; index += 1) {
         await session.press("down");
       }
 
diff --git a/test/pty/pager.test.ts b/test/pty/pager.test.ts
index 95348daa6..553530dcb 100644
--- a/test/pty/pager.test.ts
+++ b/test/pty/pager.test.ts
@@ -396,6 +396,35 @@ describe("PTY pager", () => {
     }
   });
 
+  test("pager mode opens with the sidebar closed even when --sidebar asks for one", async () => {
+    const fixture = harness.createPagerPatchFixture();
+    const session = await harness.launchHunkWithFileBackedStdin({
+      stdinFile: fixture.patchFile,
+      args: ["pager", "--sidebar"],
+      cols: 120,
+      rows: 14,
+    });
+
+    try {
+      const initial = await session.waitForText(/scroll\.ts/, { timeout: 15_000 });
+
+      expect(harness.countMatches(initial, /scroll\.ts/g)).toBe(1);
+
+      await session.waitIdle({ timeout: 200 });
+      await session.press("s");
+      const sidebarRow = /\bM scroll\.ts\s+\+40 -40/;
+      const withSidebar = await harness.waitForSnapshot(
+        session,
+        (text) => sidebarRow.test(text),
+        5_000,
+      );
+
+      expect(withSidebar).toMatch(sidebarRow);
+    } finally {
+      session.close();
+    }
+  });
+
   test("explicit pager mode still supports mouse wheel scrolling on a TTY", async () => {
     const fixture = harness.createPagerPatchFixture(60);
     const session = await harness.launchHunk({
diff --git a/test/pty/scroll.test.ts b/test/pty/scroll.test.ts
index 1b5940cd4..1da31e5c0 100644
--- a/test/pty/scroll.test.ts
+++ b/test/pty/scroll.test.ts
@@ -14,7 +14,7 @@ describe("PTY scrolling", () => {
   test("a short last file does not trap upward scrolling at the bottom edge", async () => {
     const fixture = harness.createBottomClampedRepoFixture();
     const session = await harness.launchHunk({
-      args: ["diff", "--mode", "split"],
+      args: ["diff", "--mode", "split", "--cursor-line", "off"],
       cwd: fixture.dir,
       cols: 220,
       rows: 10,
@@ -55,7 +55,7 @@ describe("PTY scrolling", () => {
     const fixture = harness.createPagerPatchFixture(60);
     const session = await harness.launchHunkWithFileBackedStdin({
       stdinFile: fixture.patchFile,
-      args: ["pager"],
+      args: ["pager", "--cursor-line", "off"],
       cols: 140,
       rows: 24,
     });
@@ -75,7 +75,7 @@ describe("PTY scrolling", () => {
   test("step keys still move one row after a click in the review stream", async () => {
     const fixture = harness.createPinnedHeaderRepoFixture();
     const session = await harness.launchHunk({
-      args: ["show", "HEAD"],
+      args: ["show", "HEAD", "--cursor-line", "off"],
       cwd: fixture.dir,
       cols: 120,
       rows: 24,
diff --git a/website/src/content/docs/docs/configure/configuration.md b/website/src/content/docs/docs/configure/configuration.md
index 9fdd1bf78..2a64199a5 100644
--- a/website/src/content/docs/docs/configure/configuration.md
+++ b/website/src/content/docs/docs/configure/configuration.md
@@ -23,6 +23,7 @@ tab_width = 4
 wrap_lines = false
 hunk_headers = true
 menu_bar = true
+sidebar = "auto"
 agent_notes = false
 transparent_background = false
 ```
diff --git a/website/src/content/docs/docs/configure/layout-and-display.md b/website/src/content/docs/docs/configure/layout-and-display.md
index d13f251a8..dc7c4dc81 100644
--- a/website/src/content/docs/docs/configure/layout-and-display.md
+++ b/website/src/content/docs/docs/configure/layout-and-display.md
@@ -37,9 +37,13 @@ line_numbers = true
 wrap_lines = false
 hunk_headers = true
 menu_bar = true
+sidebar = "auto"
 agent_notes = false
 copy_decorations = false
 transparent_background = false
+cursor_line = "row"
 ```
 
 `transparent_background` lets the terminal paint Hunk surfaces; turn it off when exact theme surfaces matter more than matching terminal transparency.
+
+`cursor_line` chooses how the line you are on is marked: `row` highlights the whole row, `number` marks only its line number, and `off` removes the marker and returns `k` / `j` to scrolling the view one row at a time. Switch it mid-review from the View menu, or set `--cursor-line <style>` for a single run.
diff --git a/website/src/content/docs/docs/reference/cli.md b/website/src/content/docs/docs/reference/cli.md
index e8f0cb6b2..2ca680850 100644
--- a/website/src/content/docs/docs/reference/cli.md
+++ b/website/src/content/docs/docs/reference/cli.md
@@ -19,6 +19,7 @@ This reference is generated from the command metadata used by Hunk itself. Run `
 | Option                      | Description                                                     |
 | --------------------------- | --------------------------------------------------------------- |
 | `--mode <mode>`             | layout mode: auto, split, stack                                 |
+| `--cursor-line <style>`     | current-line marker: row, number, off                           |
 | `--theme <theme>`           | named theme override                                            |
 | `--agent-context <path>`    | JSON sidecar with agent rationale                               |
 | `--pager`                   | use pager-style chrome                                          |
@@ -30,6 +31,8 @@ This reference is generated from the command metadata used by Hunk itself. Run `
 | `--no-wrap`                 | truncate long diff lines to one row                             |
 | `--hunk-headers`            | show hunk metadata rows                                         |
 | `--no-hunk-headers`         | hide hunk metadata rows                                         |
+| `--sidebar`                 | show sidebar                                                    |
+| `--no-sidebar`              | hide sidebar                                                    |
 | `--agent-notes`             | show agent notes by default                                     |
 | `--no-agent-notes`          | hide agent notes by default                                     |
 | `--transparent-bg`          | let terminal background show through Hunk surfaces              |
diff --git a/website/src/content/docs/docs/reference/config.md b/website/src/content/docs/docs/reference/config.md
index a63850668..8c4194da1 100644
--- a/website/src/content/docs/docs/reference/config.md
+++ b/website/src/content/docs/docs/reference/config.md
@@ -30,6 +30,16 @@ Choose responsive, side-by-side, or stacked diff layout.
 
 ---
 
+**`cursor_line`**
+
+Mark the current line as a full-row highlight or on its line number. `off` restores plain `j`/`k` scrolling.
+
+- **Type:** string
+- **Accepted:** `row`, `number`, or `off`
+- **Built-in default:** `row`
+
+---
+
 **`vcs`**
 
 Select the version-control adapter explicitly. An explicit id outranks detection; an id no loaded backend owns falls back to detection with a startup notice.
@@ -120,6 +130,16 @@ Show the top application menu bar.
 
 ---
 
+**`sidebar`**
+
+Always show the sidebar when it fits, keep it closed, or let the responsive layout decide. Pager sessions always open with the sidebar closed.
+
+- **Type:** string
+- **Accepted:** `"auto"`, `"shown"`, or `"hidden"`
+- **Built-in default:** `auto`
+
+---
+
 **`agent_notes`**
 
 Show agent notes when a review opens.
diff --git a/website/src/content/docs/docs/start/keyboard-and-mouse.md b/website/src/content/docs/docs/start/keyboard-and-mouse.md
index 599b3842f..7c12bb8e1 100644
--- a/website/src/content/docs/docs/start/keyboard-and-mouse.md
+++ b/website/src/content/docs/docs/start/keyboard-and-mouse.md
@@ -21,6 +21,8 @@ Press `?` at any time for Hunk's in-app shortcut reference. Menus and primary re
 
 Hunk navigation stays review-wide: hunk and file shortcuts move through the same multi-file stream shown in the main pane.
 
+`↑` / `↓` and `k` / `j` move a highlighted current line, and the view scrolls only far enough to keep it visible. In split mode, `h` / `l` select the old or new side of that row. Paging or scrolling past it moves it to the nearest line still on screen, and `c` anchors a note on the selected side. Pick the marker from the View menu, or set [`cursor_line`](/docs/configure/layout-and-display/): `number` marks only the line number, and `off` turns the marker off and lets `↑` / `↓` and `k` / `j` scroll the view one row at a time instead.
+
 ## Change the view
 
 | Key             | Action                                           |
@@ -28,7 +30,7 @@ Hunk navigation stays review-wide: hunk and file shortcuts move through the same
 | `0` / `1` / `2` | Auto / split / stack layout                      |
 | `s`             | Toggle sidebar                                   |
 | `t`             | Choose a theme                                   |
-| `l`             | Toggle line numbers                              |
+| `h` / `l`       | Select old / new side of the current split row   |
 | `w`             | Toggle line wrapping                             |
 | `m`             | Toggle hunk metadata                             |
 | `M`             | Toggle menu bar                                  |