diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65b97bb..071057f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,4 @@
+- Added support for long choice dialogs (e.g. /model with more than 9 items): all items are listed with a scrollbar when the list is taller than the new "Choice menu max height" setting (Tools → Options → Claude Code → General, default 320 px), items 10 and above can be selected, and the model list at startup and the model combo include every model
 - Fixed the choice dialog (e.g. /model) endlessly flickering and resizing when not all menu items fit on screen
 # 1.3.20 (2026-10-04)
 
diff --git a/claude-launch-tests/test_long_choice_menu.py b/claude-launch-tests/test_long_choice_menu.py
new file mode 100644
index 0000000..536900f
--- /dev/null
+++ b/claude-launch-tests/test_long_choice_menu.py
@@ -0,0 +1,98 @@
+"""
+Hypotheses for long (scrolling) choice menus, using /model in a small terminal:
+  A. Down/Up arrows move the cursor and scroll the window.
+  B. Down on the last item wraps to the first one (cyclic navigation).
+  C. (observed manually) a digit key selects its item immediately -> two-digit numbers cannot be typed.
+  D. Arrow navigation + Enter selects the intended item (checked via cursor number only, Esc to cancel).
+
+Screens are rendered with pexpect's ANSI emulator and dumped.
+"""
+import os
+import re
+import sys
+import time
+
+import pexpect
+import pyte
+
+CLAUDE = os.environ.get('CLAUDE_BIN', '/usr/local/bin/claude')
+ROWS, COLS = 16, 120
+DOWN, UP, ESC = '\x1b[B', '\x1b[A', '\x1b'
+CURSOR = re.compile(r'❯\s*(\d+)\.')
+
+
+class Term:
+    def __init__(self):
+        self.screen = pyte.Screen(COLS, ROWS)
+        self.stream = pyte.Stream(self.screen)
+
+
+def pump(child, term, secs=0.6):
+    end = time.time() + secs
+    while time.time() < end:
+        try:
+            term.stream.feed(child.read_nonblocking(65536, timeout=0.1))
+        except pexpect.TIMEOUT:
+            pass
+
+
+def lines(term):
+    return [l.rstrip() for l in term.screen.display]
+
+
+def cursor_num(screen):
+    for l in lines(screen):
+        m = CURSOR.search(l)
+        if m:
+            return int(m.group(1))
+    return None
+
+
+def dump(title, screen):
+    print(f'--- {title} ---')
+    for l in lines(screen):
+        if l.strip():
+            print(l)
+
+
+def main():
+    child = pexpect.spawn(CLAUDE, cwd='/tmp', dimensions=(ROWS, COLS), encoding='utf-8', codec_errors='replace',
+                          env=dict(os.environ, TERM='xterm-256color'))
+    screen = Term()
+    pump(child, screen, 12)
+    time.sleep(1.5)
+    child.send('/model'); pump(child, screen, 0.3)
+    child.send(ESC); pump(child, screen, 0.3)
+    child.send('\r'); pump(child, screen, 1.5)
+    dump('menu opened', screen)
+    start = cursor_num(screen)
+    ok = True
+
+    # A: scrolling downward
+    seen = [start]
+    for _ in range(14):
+        child.send(DOWN); pump(child, screen, 0.25)
+        seen.append(cursor_num(screen))
+    dump('after 14 Down', screen)
+    print('cursor sequence on Down:', seen)
+
+    # B: wrap-around is visible in the sequence (max -> 1)
+    nums = [n for n in seen if n]
+    wrapped = any(b < a for a, b in zip(nums, nums[1:]))
+    print('B wrap-around on Down:', wrapped)
+
+    # D: Up navigation
+    child.send(UP); pump(child, screen, 0.3)
+    print('cursor after one Up:', cursor_num(screen))
+
+    # C (not automated): a digit selects immediately and SAVES the model as default,
+    # so '10' cannot be typed - observed manually: '1' applied item 1 at once.
+
+    child.send(ESC); pump(child, screen, 0.5)
+    child.close(force=True)
+    print('RESULT: scrolling=%s wrap=%s' % (len(set(nums)) > 1, wrapped))
+    return 0 if len(set(nums)) > 1 else 1
+
+
+if __name__ == '__main__':
+    sys.exit(main())
diff --git a/docs/screenshots/settings-general.png b/docs/screenshots/settings-general.png
index 3e47a68..a298f87 100644
Binary files a/docs/screenshots/settings-general.png and b/docs/screenshots/settings-general.png differ
diff --git a/docs/user-manual.md b/docs/user-manual.md
index 292dcb3..330ba37 100644
--- a/docs/user-manual.md
+++ b/docs/user-manual.md
@@ -272,6 +272,8 @@ Claude Code sometimes presents interactive prompts (Yes/No or multiple choice).
 
 **Other options** appear as radio buttons. Some options may include a text field for additional input. Click the desired option (and optionally fill in the text field), then press **Enter** or click **Send** to submit. Press **Escape** to cancel.
 
+**Long menus.** When Claude shows only part of a long list (e.g. `/model` with more than a handful of models), the plugin scrolls through the whole list once to collect every item, then shows them all. If the list is taller than **Choice menu max height** (see [Settings](#11-settings)), the option list gets a scrollbar. Items numbered 10 and above are selected by moving Claude's cursor with the arrow keys, so every item can be chosen.
+
 After submitting or cancelling, the input area is restored automatically.
 
 **Note:** If the choice panel does not appear when Claude asks a question, or appears unexpectedly without a question — click into the terminal area and interact with Claude directly. The panel will disappear automatically once Claude's state changes.
@@ -383,6 +385,7 @@ Open **Tools → Options → Claude Code** in NetBeans.
 | Automatically open Plan Preview tab when Claude writes a plan | On | When enabled, a live Markdown Preview tab opens automatically as soon as the user clicks Allow in a diff panel for a file in a `plans/` directory. |
 | Markdown preview dock position | Right side | Where the Markdown Preview tab is docked when first opened. Choices: Editor area, Right side, Left side top, Left side bottom, Bottom dock. |
 | Choice menu focus | Grab focus | Controls whether the choice menu panel grabs keyboard focus when it appears. Choices: Grab focus, Show without grabbing focus, Hide menu. |
+| Choice menu max height (px) | 320 | Maximum height of the option list in the choice menu panel (100–2000). Longer lists (e.g. `/model` with many models) get a scrollbar; the scrollbar also appears or disappears by itself when you resize the panel by dragging the divider. |
 | Terminal font | Auto | Font used in the embedded terminal. Click **Choose…** to open the font picker. The label shows the resolved font name (e.g. `Adwaita Mono, 14 (Auto)` when auto-detection is active, or `Monospaced, 14` when set explicitly). |
 
 #### Terminal font picker
diff --git a/pom.xml b/pom.xml
index 63d2ccb..887e825 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>io.github.nbplugins</groupId>
     <artifactId>netbeans-plugin-claude-code-gui</artifactId>
-    <version>1.3.39-SNAPSHOT</version>
+    <version>1.3.42-SNAPSHOT</version>
     <packaging>nbm</packaging>
     <name>Netbeans Plugin Claude Code GUI</name>
     <description>NetBeans plugin that provides a GUI for Claude Code CLI — run claude code sessions directly inside the IDE.</description>
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/controller/ClaudeSessionController.java b/src/main/java/io/github/nbplugins/claudecodegui/controller/ClaudeSessionController.java
index ae40e52..ce072f9 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/controller/ClaudeSessionController.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/controller/ClaudeSessionController.java
@@ -11,6 +11,7 @@
 import io.github.nbplugins.claudecodegui.model.SessionMode;
 import io.github.nbplugins.claudecodegui.process.ClaudeProcess;
 import io.github.nbplugins.claudecodegui.process.ClaudeSessionStore;
+import io.github.nbplugins.claudecodegui.process.MenuEnumerator;
 import io.github.nbplugins.claudecodegui.process.ModelMenuParser;
 import io.github.nbplugins.claudecodegui.process.PtyTtyConnector;
 import io.github.nbplugins.claudecodegui.process.ScreenContentDetector;
@@ -61,6 +62,10 @@ public class ClaudeSessionController {
 
     /** DEL character (0x7F) — acts as BackSpace in xterm-256color terminals. */
     private static final byte[] PTY_BACKSPACE = {0x7f};
+    private static final byte[] PTY_ARROW_UP = {0x1b, '[', 'A'};
+    private static final byte[] PTY_ARROW_DOWN = {0x1b, '[', 'B'};
+    /** Pause after an arrow key before the screen is read while enumerating a scrolling menu. */
+    private static final long MENU_ENUMERATION_SETTLE_MS = 120;
 
     private static final int MAX_MODEL_DISCOVERY_ATTEMPTS = 1;
 
@@ -124,6 +129,8 @@ public class ClaudeSessionController {
 
     /** {@code true} while the model-discovery or model-switch background thread is running. */
     private volatile boolean modelDiscoveryInProgress = false;
+    /** True while {@link MenuEnumerator} walks the cursor through a scrolling menu. */
+    private volatile boolean menuEnumerationInProgress = false;
 
     /** Number of model-discovery attempts made since the last session start. */
     private int modelDiscoveryAttempts = 0;
@@ -645,6 +652,13 @@ public void writePtyAnswer(String answer) {
                         t.setDaemon(true);
                         t.start();
                     }
+                } else if (answer.matches("[0-9]{2,}") && menuCursorNumber(current) > 0) {
+                    // Items 10+ cannot be typed (a digit selects immediately): move the PTY
+                    // cursor onto the item with arrow keys, then Enter.
+                    int delta = Integer.parseInt(answer) - menuCursorNumber(current);
+                    LOG.fine("[PTY write] ARROW-number answer=" + answer + " delta=" + delta);
+                    clearActiveChoiceMenu();
+                    sendArrowsThenEnter(delta, "pty-arrow-number");
                 } else {
                     boolean isMenuDigit = answer.matches("[0-9]");
                     String toWrite = isMenuDigit ? answer : answer + "\r";
@@ -658,6 +672,33 @@ public void writePtyAnswer(String answer) {
         }
     }
 
+    /** Menu number under the PTY cursor according to {@code menu}, or 0 if unknown. */
+    private int menuCursorNumber(ChoiceMenuModel menu) {
+        if (menu != null && menu.cursorNumber() > 0) return menu.cursorNumber();
+        ChoiceMenuModel active = model.getActiveChoiceMenu();
+        return active != null ? active.cursorNumber() : 0;
+    }
+
+    /** Presses Down (delta &gt; 0) or Up (delta &lt; 0) {@code |delta|} times, then Enter, on a daemon thread. */
+    private void sendArrowsThenEnter(int delta, String threadName) {
+        Thread t = new Thread(() -> {
+            try {
+                byte[] arrow = delta < 0 ? PTY_ARROW_UP : PTY_ARROW_DOWN;
+                for (int i = 0; i < Math.abs(delta); i++) {
+                    connector.write(arrow);
+                    Thread.sleep(80);
+                }
+                connector.write("\r");
+            } catch (IOException ex) {
+                LOG.warning(threadName + " write failed: " + ex.getMessage());
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }, threadName);
+        t.setDaemon(true);
+        t.start();
+    }
+
     /**
      * Computes which checkbox option responses must be toggled in the PTY to reach
      * {@code desired} from the current states in {@code currentOptions}.
@@ -910,7 +951,24 @@ public void switchModel(int index) {
             Thread t = new Thread(() -> {
                 try {
                     openModelMenu();
-                    connector.write(String.valueOf(index + 1));
+                    if (index < 9) {
+                        connector.write(String.valueOf(index + 1));
+                    } else {
+                        // Items 10+ cannot be typed: move the cursor onto the item, then Enter.
+                        int cursor = waitForModelMenuCursor();
+                        if (cursor > 0) {
+                            int delta = index + 1 - cursor;
+                            byte[] arrow = delta < 0 ? PTY_ARROW_UP : PTY_ARROW_DOWN;
+                            for (int i = 0; i < Math.abs(delta); i++) {
+                                connector.write(arrow);
+                                Thread.sleep(80);
+                            }
+                            connector.write("\r");
+                        } else {
+                            LOG.warning("model switch: /model menu not visible, cannot select item " + (index + 1));
+                            connector.write(PTY_ESC);
+                        }
+                    }
                     Thread.sleep(500);
                 } catch (IOException | InterruptedException ex) {
                     LOG.warning("model switch failed: " + ex.getMessage());
@@ -928,6 +986,16 @@ public void switchModel(int index) {
     // Model discovery
     // -------------------------------------------------------------------------
 
+    /** Waits (up to ~3 s) for the {@code /model} menu and returns the number under the cursor, or 0. */
+    private int waitForModelMenuCursor() throws InterruptedException {
+        for (int i = 0; i < 20; i++) {
+            Optional<ChoiceMenuModel> m = screenContentDetector.detectChoiceMenu(screenLines.get());
+            if (m.isPresent() && m.get().cursorNumber() > 0) return m.get().cursorNumber();
+            Thread.sleep(150);
+        }
+        return 0;
+    }
+
     /**
      * Opens the {@code /model} selection menu, parses the screen, and populates
      * the model list in {@link ClaudeSessionModel}.
@@ -987,6 +1055,14 @@ void discoverModels() {
                     }
                 }
 
+                // A long menu shows only a window of the models: walk the cursor through the
+                // whole list (and back) so the combo gets every model, not just the visible ones.
+                if (menuOpt.isPresent() && menuOpt.get().scrollable()) {
+                    ChoiceMenuModel full = newMenuEnumerator().enumerate(menuOpt.get());
+                    menuOpt = Optional.of(full);
+                    lines = MenuEnumerator.toScreenLines(full);
+                }
+
                 // Scan the rolling PTY line buffer for the /model hint line, which is
                 // shorter and never truncated (e.g. "/model  … (currently anthropic/claude-sonnet-4.6)").
                 String hintCurrentModel = null;
@@ -1134,7 +1210,7 @@ void pollScreenState() {
         // (e.g. thinking spinner keeps PTY active and prevents the 400 ms silence).
         // Also clear stale menu when it disappears from screen — flushPendingPrompt
         // may never fire if the spinner continuously restarts promptFlushTimer.
-        if (!modelDiscoveryInProgress) {
+        if (!modelDiscoveryInProgress && !menuEnumerationInProgress) {
             Optional<ChoiceMenuModel> menuOpt = screenContentDetector.detectChoiceMenu(lines);
             if (menuOpt.isPresent()) {
                 applyDetectedChoiceMenu(menuOpt.get(), "[pollScreenState] ");
@@ -1274,7 +1350,7 @@ private void detectAndApplyInitialEditMode(List<String> lines) {
      */
     void flushPendingPrompt() {
         LOG.fine("[flushPendingPrompt] enter, modelDiscoveryInProgress=" + modelDiscoveryInProgress);
-        if (modelDiscoveryInProgress) return;
+        if (modelDiscoveryInProgress || menuEnumerationInProgress) return;
 
         Optional<ChoiceMenuModel> req = Optional.empty();
         List<String> lines = screenLines.get();
@@ -1335,7 +1411,7 @@ void flushPendingPrompt() {
 
         req.ifPresent(r -> {
             LOG.fine("[screen prompt flush] setting choice menu: \"" + r.text() + "\" | options=" + r.options());
-            model.setActiveChoiceMenu(r);
+            showChoiceMenu(r);
         });
     }
 
@@ -1430,12 +1506,51 @@ private void applyDetectedEditMode(Optional<EditMode> detected) {
         }
     }
 
+    /**
+     * Shows {@code menu} in the choice panel. A scrolling menu (only a window of a longer
+     * list is on screen) is first completed on a daemon thread by {@link MenuEnumerator},
+     * which walks the PTY cursor through the whole list and back; the poll timers are
+     * suppressed meanwhile, and the panel is shown only once the full list is known.
+     */
+    private void showChoiceMenu(ChoiceMenuModel menu) {
+        if (!menu.scrollable() || connector == null || menuEnumerationInProgress) {
+            model.setActiveChoiceMenu(menu);
+            return;
+        }
+        menuEnumerationInProgress = true;
+        Thread t = new Thread(() -> {
+            ChoiceMenuModel full = menu;
+            try {
+                full = newMenuEnumerator().enumerate(menu);
+            } catch (IOException ex) {
+                LOG.warning("menu enumeration failed: " + ex.getMessage());
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            } finally {
+                final ChoiceMenuModel result = full;
+                SwingUtilities.invokeLater(() -> {
+                    menuEnumerationInProgress = false;
+                    if (model.getActiveChoiceMenu() == null) model.setActiveChoiceMenu(result);
+                });
+            }
+        }, "claude-menu-enumeration");
+        t.setDaemon(true);
+        t.start();
+    }
+
+    private MenuEnumerator newMenuEnumerator() {
+        return new MenuEnumerator(screenContentDetector, screenLines, new MenuEnumerator.Keys() {
+            @Override public void down() throws IOException { connector.write(PTY_ARROW_DOWN); }
+            @Override public void up() throws IOException { connector.write(PTY_ARROW_UP); }
+        }, Thread::sleep, MENU_ENUMERATION_SETTLE_MS);
+    }
+
     private void applyDetectedChoiceMenu(ChoiceMenuModel newMenu, String logTag) {
         ChoiceMenuModel current = model.getActiveChoiceMenu();
         if (current == null) {
             pendingChoiceMenuCandidate = null;
             LOG.fine(logTag + "setting choice menu: \"" + newMenu.text() + "\"");
-            model.setActiveChoiceMenu(newMenu);
+            showChoiceMenu(newMenu);
             return;
         }
         if (sameMenu(newMenu, current) || isShrunkViewOf(newMenu, current)) {
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/model/ChoiceMenuModel.java b/src/main/java/io/github/nbplugins/claudecodegui/model/ChoiceMenuModel.java
index 9351f5c..1ec544c 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/model/ChoiceMenuModel.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/model/ChoiceMenuModel.java
@@ -102,6 +102,12 @@ public Option(String display, String response, String description, boolean check
     private final List<Option> options;
     @JsonProperty("defaultOptionIndex")
     private final int defaultOptionIndex;
+    @JsonInclude(JsonInclude.Include.NON_DEFAULT)
+    @JsonProperty("scrollable")
+    private final boolean scrollable;
+    @JsonInclude(JsonInclude.Include.NON_DEFAULT)
+    @JsonProperty("cursorNumber")
+    private final int cursorNumber;
 
     /**
      * Creates a choice-menu model.
@@ -110,16 +116,48 @@ public Option(String display, String response, String description, boolean check
      * @param options            list of selectable options
      * @param defaultOptionIndex index of the pre-selected option
      */
+    public ChoiceMenuModel(String text, List<Option> options, int defaultOptionIndex) {
+        this(text, options, defaultOptionIndex, false, 0);
+    }
+
+    /**
+     * Creates a choice-menu model.
+     *
+     * @param text               prompt text displayed above the options
+     * @param options            list of selectable options
+     * @param defaultOptionIndex index of the pre-selected option
+     * @param scrollable         whether Claude shows only a window of a longer list
+     *                           (scroll indicators {@code ↑}/{@code ↓}/{@code … +N})
+     * @param cursorNumber       menu number of the item under Claude's cursor, or 0 if unknown
+     */
     @JsonCreator
     public ChoiceMenuModel(
             @JsonProperty("text") String text,
             @JsonProperty("options") List<Option> options,
-            @JsonProperty("defaultOptionIndex") int defaultOptionIndex) {
+            @JsonProperty("defaultOptionIndex") int defaultOptionIndex,
+            @JsonProperty("scrollable") boolean scrollable,
+            @JsonProperty("cursorNumber") int cursorNumber) {
         this.text = text;
         this.options = options;
         this.defaultOptionIndex = defaultOptionIndex;
+        this.scrollable = scrollable;
+        this.cursorNumber = cursorNumber;
     }
 
+    /**
+     * Returns whether Claude shows only a window of a longer list.
+     *
+     * @return {@code true} if the menu scrolls
+     */
+    public boolean scrollable() { return scrollable; }
+
+    /**
+     * Returns the menu number of the item under Claude's cursor.
+     *
+     * @return the number, or 0 if unknown
+     */
+    public int cursorNumber() { return cursorNumber; }
+
     /**
      * Returns the prompt text.
      *
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/process/MenuEnumerator.java b/src/main/java/io/github/nbplugins/claudecodegui/process/MenuEnumerator.java
new file mode 100644
index 0000000..9e4ccb5
--- /dev/null
+++ b/src/main/java/io/github/nbplugins/claudecodegui/process/MenuEnumerator.java
@@ -0,0 +1,169 @@
+package io.github.nbplugins.claudecodegui.process;
+
+import io.github.nbplugins.claudecodegui.model.ChoiceMenuModel;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.TreeMap;
+import java.util.function.Supplier;
+import java.util.logging.Logger;
+
+/**
+ * Collects the full item list of a scrolling numbered menu (e.g. {@code /model}) by moving
+ * Claude's cursor with the arrow keys and merging every window it shows.
+ *
+ * <p>Claude draws only as many items as fit the terminal. The cursor is moved down one item
+ * at a time (Claude's menus wrap from the last item to the first), each window is merged by
+ * item number, and the walk stops when the cursor is back on the item it started on — so the
+ * menu is left exactly as it was found. If the menu does not wrap, the cursor is walked to
+ * both ends and back instead.
+ */
+public final class MenuEnumerator {
+
+    private static final Logger LOG = Logger.getLogger(MenuEnumerator.class.getName());
+
+    /** Upper bound on key presses, so a misbehaving menu can never loop forever. */
+    static final int MAX_STEPS = 300;
+    private static final int READ_RETRIES = 6;
+
+    /** Sends cursor-movement keys to Claude. */
+    public interface Keys {
+        void down() throws IOException, InterruptedException;
+        void up() throws IOException, InterruptedException;
+    }
+
+    /** Pause between a key press and reading the screen. */
+    public interface Pause {
+        void sleep(long millis) throws InterruptedException;
+    }
+
+    private final ScreenContentDetector detector;
+    private final Supplier<List<String>> screen;
+    private final Keys keys;
+    private final Pause pause;
+    private final long settleMs;
+
+    /**
+     * Creates an enumerator.
+     *
+     * @param detector detector used to parse each window
+     * @param screen   supplies the current screen lines
+     * @param keys     sends arrow keys
+     * @param pause    sleeps for the given time (injectable for tests)
+     * @param settleMs time to wait after a key press before reading the screen
+     */
+    public MenuEnumerator(ScreenContentDetector detector, Supplier<List<String>> screen,
+                          Keys keys, Pause pause, long settleMs) {
+        this.detector = detector;
+        this.screen = screen;
+        this.keys = keys;
+        this.pause = pause;
+        this.settleMs = settleMs;
+    }
+
+    /**
+     * Returns the complete menu for a scrollable {@code initial} window, with the cursor left on
+     * the item it was on. A menu that is not scrollable, or whose cursor cannot be tracked, is
+     * returned unchanged.
+     *
+     * @param initial the window currently shown on screen
+     * @return the merged menu
+     * @throws IOException          if a key cannot be written
+     * @throws InterruptedException if the thread is interrupted
+     */
+    public ChoiceMenuModel enumerate(ChoiceMenuModel initial) throws IOException, InterruptedException {
+        int start = initial.cursorNumber();
+        if (!initial.scrollable() || start <= 0) return initial;
+
+        TreeMap<Integer, ChoiceMenuModel.Option> byNumber = new TreeMap<>();
+        merge(byNumber, initial);
+
+        int steps = 0;
+        int prev = start;
+        boolean wraps = true;
+        while (steps++ < MAX_STEPS) {
+            keys.down();
+            ChoiceMenuModel w = readWindow();
+            if (w == null) return finish(initial, byNumber, start);
+            merge(byNumber, w);
+            int cur = w.cursorNumber();
+            if (cur == start) return finish(initial, byNumber, start);
+            if (cur == prev) {
+                wraps = false;
+                break;
+            }
+            prev = cur;
+        }
+        if (!wraps) {
+            // No wrap-around: walk to the top, merging, then back down to the start item.
+            prev = -1;
+            while (steps++ < MAX_STEPS) {
+                keys.up();
+                ChoiceMenuModel w = readWindow();
+                if (w == null) return finish(initial, byNumber, start);
+                merge(byNumber, w);
+                if (w.cursorNumber() == prev) break;
+                prev = w.cursorNumber();
+            }
+            while (steps++ < MAX_STEPS) {
+                ChoiceMenuModel w = readWindow();
+                if (w == null || w.cursorNumber() == start) break;
+                if (w.cursorNumber() > start) {
+                    keys.up();
+                } else {
+                    keys.down();
+                }
+            }
+        }
+        return finish(initial, byNumber, start);
+    }
+
+    /** Reads the window after a key press; {@code null} if no menu with a cursor is visible. */
+    private ChoiceMenuModel readWindow() throws InterruptedException {
+        for (int i = 0; i < READ_RETRIES; i++) {
+            pause.sleep(settleMs);
+            Optional<ChoiceMenuModel> m = detector.detectChoiceMenu(screen.get());
+            if (m.isPresent() && m.get().cursorNumber() > 0) return m.get();
+        }
+        LOG.fine("[MenuEnumerator] menu not readable, giving up");
+        return null;
+    }
+
+    private static void merge(TreeMap<Integer, ChoiceMenuModel.Option> byNumber, ChoiceMenuModel window) {
+        for (ChoiceMenuModel.Option o : window.options()) {
+            try {
+                byNumber.put(Integer.parseInt(o.response()), o);
+            } catch (NumberFormatException ignored) {
+                // not a numbered item
+            }
+        }
+    }
+
+    private static ChoiceMenuModel finish(ChoiceMenuModel initial,
+                                          TreeMap<Integer, ChoiceMenuModel.Option> byNumber, int start) {
+        List<ChoiceMenuModel.Option> options = new ArrayList<>(byNumber.values());
+        int idx = 0;
+        for (int i = 0; i < options.size(); i++) {
+            if (options.get(i).response().equals(String.valueOf(start))) idx = i;
+        }
+        LOG.fine("[MenuEnumerator] enumerated " + options.size() + " items, cursor=" + start);
+        return new ChoiceMenuModel(initial.text(), options, idx, true, start);
+    }
+
+    /**
+     * Renders a numbered menu as screen lines ({@code ❯ 3.  Sonnet 5.5 …}), so line-based
+     * parsers such as {@link ModelMenuParser} can read the merged list.
+     *
+     * @param menu the menu
+     * @return one line per option
+     */
+    public static List<String> toScreenLines(ChoiceMenuModel menu) {
+        List<String> lines = new ArrayList<>();
+        for (ChoiceMenuModel.Option o : menu.options()) {
+            boolean cursor = o.response().equals(String.valueOf(menu.cursorNumber()));
+            lines.add((cursor ? "❯ " : "  ") + o.response() + ".  " + o.display());
+        }
+        return lines;
+    }
+}
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/process/ModelMenuParser.java b/src/main/java/io/github/nbplugins/claudecodegui/process/ModelMenuParser.java
index 2eee8cd..5b4204d 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/process/ModelMenuParser.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/process/ModelMenuParser.java
@@ -66,9 +66,9 @@ public ModelDiscovery parse(List<String> lines) {
         int currentIndex = -1;
 
         for (String line : lines) {
-            boolean hasCursor = line.trim().matches("^[❯▶>].*");
+            boolean hasCursor = line.trim().matches("^[❯▶>↑↓].*");
             boolean hasCheck  = line.contains("\u2714");
-            String trimmed = line.trim().replaceFirst("^[❯▶>]\\s*", "").trim();
+            String trimmed = line.trim().replaceFirst("^[❯▶>↑↓]\\s*", "").trim();
 
             // Numbered format: "N. ..."
             if (trimmed.matches("^\\d+\\..*")) {
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetector.java b/src/main/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetector.java
index 0b078d9..1c95966 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetector.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetector.java
@@ -48,7 +48,14 @@ public void setSessionTag(String tag) {
      * Leading whitespace is allowed (produced by ESC[1C cursor-forward expansion).
      */
     private static final Pattern OPTION_LINE =
-            Pattern.compile("^\\s*(\u276F|\u25B6|>)?\\s*\\d+\\.\\s*.+");
+            Pattern.compile("^\\s*(\u276F|\u25B6|>|\u2191|\u2193)?\\s*\\d+\\.\\s*.+");
+
+    /**
+     * Matches the "hidden items" line of a scrolling menu, e.g. {@code … +7 models}
+     * (also {@code ... +7 models}).
+     */
+    private static final Pattern HIDDEN_ITEMS_LINE =
+            Pattern.compile("^(\u2026|\\.\\.\\.)\\s*\\+\\d+\\s+\\S.*");
 
     /** Matches an option line that carries the Ink cursor glyph (selected item). */
     private static final Pattern CURSOR_LINE =
@@ -186,6 +193,7 @@ public Optional<ChoiceMenuModel> detectChoiceMenu(List<String> screenLines) {
                 String line = raw.trim();
                 if (line.isBlank()) break;
                 if (OPTION_LINE.matcher(line).matches()) break;
+                if (HIDDEN_ITEMS_LINE.matcher(line).matches()) break;
                 // Skip keyboard-hint lines; "shift+tab to approve" also marks the option
                 // as requiring free-text input (hasTextInput=true).
                 if (isHintLine(line)) {
@@ -246,9 +254,11 @@ public Optional<ChoiceMenuModel> detectChoiceMenu(List<String> screenLines) {
         // currently-selected option. Numbered lists in Claude's own output never have
         // a cursor, so requiring one eliminates false positives entirely.
         boolean hasCursor = false;
+        int cursorNumber = 0;
         for (int i = firstOptionRow; i <= lastOptionRow; i++) {
             if (CURSOR_LINE.matcher(screenLines.get(i).trim()).matches()) {
                 hasCursor = true;
+                cursorNumber = parseOptionNumber(screenLines.get(i).trim());
                 break;
             }
         }
@@ -281,7 +291,23 @@ public Optional<ChoiceMenuModel> detectChoiceMenu(List<String> screenLines) {
         }
 
         LOG.fine(tag + "[ScreenContentDetector] detected prompt: \"" + question + "\" options=" + options);
-        return Optional.of(new ChoiceMenuModel(question, options, 0));
+        // Scrolling menu: Claude marks hidden items with a leading ↑ / ↓ on the edge option
+        // and/or a "… +N models" line below the list.
+        boolean scrollable = screenLines.get(firstOptionRow).trim().startsWith("\u2191")
+                || screenLines.get(lastOptionRow).trim().startsWith("\u2193");
+        for (int i = lastOptionRow + 1; !scrollable && i < Math.min(lastOptionRow + 4, screenLines.size()); i++) {
+            if (HIDDEN_ITEMS_LINE.matcher(screenLines.get(i).trim()).matches()) scrollable = true;
+        }
+        return Optional.of(new ChoiceMenuModel(question, options, 0, scrollable, cursorNumber));
+    }
+
+    /** Returns the menu number of a trimmed option line, or 0 if it cannot be parsed. */
+    static int parseOptionNumber(String trimmedOptionLine) {
+        try {
+            return Integer.parseInt(extractOption(trimmedOptionLine, 0).response());
+        } catch (NumberFormatException e) {
+            return 0;
+        }
     }
 
     // -------------------------------------------------------------------------
@@ -750,7 +776,7 @@ static List<String> bottomNonBlankLines(List<String> lines, int n) {
     static ChoiceMenuModel.Option extractOption(String line, int index) {
         // Skip cursor glyph if present
         String working = line;
-        if (!working.isEmpty() && "\u276F\u25B6>".indexOf(working.charAt(0)) >= 0) {
+        if (!working.isEmpty() && "\u276F\u25B6>\u2191\u2193".indexOf(working.charAt(0)) >= 0) {
             working = working.substring(1).stripLeading();
         }
         int dotPos = working.indexOf('.');
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodeOptionsPanel.java b/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodeOptionsPanel.java
index 17f123e..02b57a6 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodeOptionsPanel.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodeOptionsPanel.java
@@ -85,6 +85,7 @@ public final class ClaudeCodeOptionsPanel extends JPanel {
     private javax.swing.JCheckBox startNewSessionCheck;
     /** Spinner for the maximum number of sessions shown in the session list. */
     private JSpinner sessionListLimitSpinner;
+    private JSpinner choiceMenuMaxHeightSpinner;
     /** Dropdown for the dock position of the Claude Code session tab. */
     private javax.swing.JComboBox<String> dockModeCombo;
     /** Dropdown for the dock position of the Markdown Preview tab. */
@@ -275,6 +276,15 @@ public java.awt.Component getListCellRendererComponent(
         form.add(choiceMenuFocusCombo, gbc(1, row, false));
         row++;
 
+        // --- choice menu max height ---
+        form.add(new JLabel("Choice menu max height (px):"), gbc(0, row, false));
+        choiceMenuMaxHeightSpinner = new JSpinner(new SpinnerNumberModel(
+                ClaudeCodePreferences.DEFAULT_CHOICE_MENU_MAX_HEIGHT, 100, 2000, 20));
+        choiceMenuMaxHeightSpinner.setToolTipText(
+                "Option lists of a choice dialog (e.g. /model) taller than this get a scrollbar");
+        form.add(choiceMenuMaxHeightSpinner, gbc(1, row, false));
+        row++;
+
         // --- terminal font ---
         form.add(new JLabel("Terminal font:"), gbc(0, row, false));
         terminalFontLabel = new JLabel();
@@ -480,6 +490,7 @@ void load() {
                 ClaudeCodePreferences.getContextMenuSessionMode()
                         == io.github.nbplugins.claudecodegui.model.SessionMode.NEW);
         sessionListLimitSpinner.setValue(ClaudeCodePreferences.getSessionListLimit());
+        choiceMenuMaxHeightSpinner.setValue(ClaudeCodePreferences.getChoiceMenuMaxHeight());
         dockModeCombo.setSelectedIndex(ClaudeCodePreferences.getSessionDockMode().ordinal());
         mdPreviewDockModeCombo.setSelectedIndex(
                 ClaudeCodePreferences.getMarkdownPreviewDockMode().ordinal());
@@ -528,6 +539,7 @@ void store() {
                         ? io.github.nbplugins.claudecodegui.model.SessionMode.NEW
                         : io.github.nbplugins.claudecodegui.model.SessionMode.CONTINUE_LAST);
         ClaudeCodePreferences.setSessionListLimit((Integer) sessionListLimitSpinner.getValue());
+        ClaudeCodePreferences.setChoiceMenuMaxHeight((Integer) choiceMenuMaxHeightSpinner.getValue());
         ClaudeCodePreferences.setSessionDockMode(dockModeFromCombo(dockModeCombo));
         ClaudeCodePreferences.setMarkdownPreviewDockMode(dockModeFromCombo(mdPreviewDockModeCombo));
         ClaudeCodePreferences.setFileDiffDockMode(dockModeFromCombo(fileDiffDockModeCombo));
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodePreferences.java b/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodePreferences.java
index 5ec2004..6736f6b 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodePreferences.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/settings/ClaudeCodePreferences.java
@@ -544,6 +544,35 @@ public static void setSessionListLimit(int v) {
                 .putInt(KEY_SESSION_LIST_LIMIT, Math.max(1, Math.min(500, v)));
     }
 
+    // -------------------------------------------------------------------------
+    // choiceMenuMaxHeight
+    // -------------------------------------------------------------------------
+
+    /** Preference key: maximum height (pixels) of the choice-menu option list before it scrolls. */
+    public static final String KEY_CHOICE_MENU_MAX_HEIGHT = "choiceMenuMaxHeight";
+    /** Default: 320 pixels. */
+    public static final int DEFAULT_CHOICE_MENU_MAX_HEIGHT = 320;
+
+    /**
+     * Returns the maximum height of the choice-menu option list; a longer list gets a scrollbar.
+     *
+     * @return height in pixels (100–2000)
+     */
+    public static int getChoiceMenuMaxHeight() {
+        return NbPreferences.forModule(ClaudeCodePreferences.class)
+                .getInt(KEY_CHOICE_MENU_MAX_HEIGHT, DEFAULT_CHOICE_MENU_MAX_HEIGHT);
+    }
+
+    /**
+     * Persists the maximum height of the choice-menu option list.
+     *
+     * @param v height in pixels; clamped to [100, 2000]
+     */
+    public static void setChoiceMenuMaxHeight(int v) {
+        NbPreferences.forModule(ClaudeCodePreferences.class)
+                .putInt(KEY_CHOICE_MENU_MAX_HEIGHT, Math.max(100, Math.min(2000, v)));
+    }
+
     // -------------------------------------------------------------------------
     // hangTimeoutSeconds
     // -------------------------------------------------------------------------
diff --git a/src/main/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanel.java b/src/main/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanel.java
index 1f6af41..2b28eea 100644
--- a/src/main/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanel.java
+++ b/src/main/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanel.java
@@ -1,10 +1,12 @@
 package io.github.nbplugins.claudecodegui.ui;
 
 import io.github.nbplugins.claudecodegui.model.ChoiceMenuModel;
+import io.github.nbplugins.claudecodegui.settings.ClaudeCodePreferences;
 import io.github.nbplugins.claudecodegui.ui.common.DecoratedTextField;
 import io.github.nbplugins.claudecodegui.ui.common.UiUtils;
 import java.awt.Color;
 import java.awt.Component;
+import java.awt.Dimension;
 import java.awt.event.KeyEvent;
 import java.util.List;
 import java.util.function.Consumer;
@@ -21,8 +23,11 @@
 import javax.swing.JLabel;
 import javax.swing.JPanel;
 import javax.swing.JRadioButton;
+import javax.swing.JScrollPane;
 import javax.swing.JTextField;
 import javax.swing.KeyStroke;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.SwingUtilities;
 
 /**
  * A panel that appears when claude asks an interactive question.
@@ -400,12 +405,28 @@ public void keyPressed(java.awt.event.KeyEvent e) {
         JPanel mainRow = new JPanel();
         mainRow.setLayout(new BoxLayout(mainRow, BoxLayout.X_AXIS));
         mainRow.setAlignmentX(Component.LEFT_ALIGNMENT);
-        mainRow.add(leftCol);
-        mainRow.add(Box.createHorizontalGlue());
+        mainRow.add(new OptionScrollPane(leftCol, maxOptionsHeight()));
         mainRow.add(rightCol);
 
         add(mainRow);
 
+        // Long option lists scroll: keep the selected / focused option in view.
+        final JComponent initiallySelected = defaultRadioBtn;
+        if (initiallySelected != null) {
+            SwingUtilities.invokeLater(() -> leftCol.scrollRectToVisible(initiallySelected.getBounds()));
+        }
+        java.awt.event.FocusAdapter keepVisible = new java.awt.event.FocusAdapter() {
+            @Override public void focusGained(java.awt.event.FocusEvent e) {
+                leftCol.scrollRectToVisible(((Component) e.getSource()).getBounds());
+            }
+        };
+        for (JRadioButton rb : radioButtons) {
+            if (rb != null) rb.addFocusListener(keepVisible);
+        }
+        for (JCheckBox cb : checkBoxes) {
+            if (cb != null) cb.addFocusListener(keepVisible);
+        }
+
         // ESC → cancel from anywhere in the panel
         getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
                 .put(KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0), "cancel");
@@ -822,6 +843,52 @@ public void dismiss() {
 
     // -------------------------------------------------------------------------
 
+    /** Maximum height of the option list before it scrolls (Tools → Options → General). */
+    private static int maxOptionsHeight() {
+        try {
+            return ClaudeCodePreferences.getChoiceMenuMaxHeight();
+        } catch (RuntimeException | LinkageError e) {
+            return ClaudeCodePreferences.DEFAULT_CHOICE_MENU_MAX_HEIGHT;
+        }
+    }
+
+    /**
+     * Scroll pane whose preferred height is the content height capped at {@code maxHeight}.
+     * The scrollbar is shown only while the pane is actually shorter than its content, so it
+     * appears and disappears by itself when the user resizes the panel.
+     */
+    private static final class OptionScrollPane extends JScrollPane {
+        private final int maxHeight;
+
+        OptionScrollPane(JComponent view, int maxHeight) {
+            super(view, ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED,
+                    ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+            this.maxHeight = maxHeight;
+            setBorder(null);
+            setAlignmentY(Component.TOP_ALIGNMENT);
+            getVerticalScrollBar().setUnitIncrement(16);
+        }
+
+        @Override
+        public Dimension getPreferredSize() {
+            Dimension v = getViewport().getView().getPreferredSize();
+            boolean capped = v.height > maxHeight;
+            int width = v.width + (capped ? getVerticalScrollBar().getPreferredSize().width : 0);
+            return new Dimension(width, Math.min(v.height, maxHeight));
+        }
+
+        /** Stretches horizontally up to the buttons on the right, so the scrollbar sits next to them. */
+        @Override
+        public Dimension getMaximumSize() {
+            return new Dimension(Integer.MAX_VALUE, getPreferredSize().height);
+        }
+
+        @Override
+        public Dimension getMinimumSize() {
+            return new Dimension(getPreferredSize().width, Math.min(getPreferredSize().height, 48));
+        }
+    }
+
     private void submitAnswer(String answer) {
         Consumer<String> cb = callback;
         LOG.info("[ChoiceMenuPanel] submitAnswer: \"" + answer + "\", cb=" + cb);
diff --git a/src/test/java/io/github/nbplugins/claudecodegui/process/MenuEnumeratorTest.java b/src/test/java/io/github/nbplugins/claudecodegui/process/MenuEnumeratorTest.java
new file mode 100644
index 0000000..3de9f3d
--- /dev/null
+++ b/src/test/java/io/github/nbplugins/claudecodegui/process/MenuEnumeratorTest.java
@@ -0,0 +1,126 @@
+package io.github.nbplugins.claudecodegui.process;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.github.nbplugins.claudecodegui.model.ChoiceMenuModel;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Test;
+
+class MenuEnumeratorTest {
+
+    /** Simulates Claude's scrolling /model menu. */
+    static final class FakeMenu {
+        final int n;
+        final int window;
+        final boolean wraps;
+        int cursor;
+        int top = 1;
+
+        FakeMenu(int n, int window, boolean wraps, int cursor) {
+            this.n = n;
+            this.window = window;
+            this.wraps = wraps;
+            this.cursor = cursor;
+            scroll();
+        }
+
+        void down() {
+            if (cursor < n) cursor++;
+            else if (wraps) cursor = 1;
+            scroll();
+        }
+
+        void up() {
+            if (cursor > 1) cursor--;
+            else if (wraps) cursor = n;
+            scroll();
+        }
+
+        private void scroll() {
+            if (cursor < top) top = cursor;
+            if (cursor > top + window - 1) top = cursor - window + 1;
+        }
+
+        List<String> screen() {
+            List<String> l = new ArrayList<>();
+            l.add("─".repeat(60));
+            l.add("  Select model");
+            l.add("  Switch between Claude models.");
+            l.add("");
+            int bottom = Math.min(n, top + window - 1);
+            for (int i = top; i <= bottom; i++) {
+                String glyph = i == cursor ? "❯" : (i == top && top > 1 ? "↑" : (i == bottom && bottom < n ? "↓" : " "));
+                l.add("  " + glyph + " " + i + ".  Model " + i + "          Description " + i);
+            }
+            if (bottom < n) l.add("     … +" + (n - bottom) + " models");
+            l.add("");
+            l.add("  Enter to set as default · s to use this session only · Esc to cancel");
+            return l;
+        }
+    }
+
+    private static ChoiceMenuModel enumerate(FakeMenu m, int[] keyCount) throws Exception {
+        ScreenContentDetector det = new ScreenContentDetector();
+        ChoiceMenuModel initial = det.detectChoiceMenu(m.screen()).orElseThrow();
+        MenuEnumerator e = new MenuEnumerator(det, m::screen, new MenuEnumerator.Keys() {
+            public void down() { m.down(); keyCount[0]++; }
+            public void up() { m.up(); keyCount[0]++; }
+        }, ms -> { }, 0);
+        return e.enumerate(initial);
+    }
+
+    @Test
+    void wrappingMenuIsEnumeratedAndCursorRestored() throws Exception {
+        FakeMenu m = new FakeMenu(12, 3, true, 5);
+        int[] keys = {0};
+        ChoiceMenuModel full = enumerate(m, keys);
+        assertEquals(12, full.options().size());
+        assertEquals("1", full.options().get(0).response());
+        assertEquals("12", full.options().get(11).response());
+        assertEquals(5, m.cursor, "cursor must be back on the starting item");
+        assertEquals(12, keys[0], "one full cycle");
+        assertEquals(5, full.cursorNumber());
+        assertEquals(4, full.defaultOptionIndex());
+        assertTrue(full.scrollable());
+    }
+
+    @Test
+    void nonWrappingMenuIsEnumeratedAndCursorRestored() throws Exception {
+        FakeMenu m = new FakeMenu(12, 3, false, 6);
+        ChoiceMenuModel full = enumerate(m, new int[]{0});
+        assertEquals(12, full.options().size());
+        assertEquals(6, m.cursor);
+    }
+
+    @Test
+    void cursorAtLastItemWraps() throws Exception {
+        FakeMenu m = new FakeMenu(12, 4, true, 12);
+        ChoiceMenuModel full = enumerate(m, new int[]{0});
+        assertEquals(12, full.options().size());
+        assertEquals(12, m.cursor);
+    }
+
+    @Test
+    void shortMenuIsReturnedUnchanged() throws Exception {
+        FakeMenu m = new FakeMenu(3, 5, true, 2);
+        ScreenContentDetector det = new ScreenContentDetector();
+        ChoiceMenuModel initial = det.detectChoiceMenu(m.screen()).orElseThrow();
+        assertFalse(initial.scrollable());
+        int[] keys = {0};
+        assertEquals(initial.options(), enumerate(m, keys).options());
+        assertEquals(0, keys[0]);
+    }
+
+    @Test
+    void screenLinesAreParsedByModelMenuParser() {
+        ChoiceMenuModel menu = new ChoiceMenuModel("t", List.of(
+                new ChoiceMenuModel.Option("Opus 5.5                 For complex work", "9"),
+                new ChoiceMenuModel.Option("Fable 5.1                For toughest", "10")), 1, true, 10);
+        List<String> lines = MenuEnumerator.toScreenLines(menu);
+        assertEquals("❯ 10.  Fable 5.1                For toughest", lines.get(1));
+        assertEquals(List.of("Opus 5.5", "Fable 5.1"), new ModelMenuParser().parse(lines).models());
+    }
+}
diff --git a/src/test/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetectorTest.java b/src/test/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetectorTest.java
index d637ef3..b0e816c 100644
--- a/src/test/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetectorTest.java
+++ b/src/test/java/io/github/nbplugins/claudecodegui/process/ScreenContentDetectorTest.java
@@ -74,6 +74,12 @@ void detectChoiceMenu(String caseName, Path srcFile, Path expectedFile) throws E
                     "text mismatch for case '" + caseName + "'");
             assertEquals(expected.options(), result.get().options(),
                     "options mismatch for case '" + caseName + "'");
+            assertEquals(expected.scrollable(), result.get().scrollable(),
+                    "scrollable mismatch for case '" + caseName + "'");
+            if (expected.cursorNumber() != 0) {
+                assertEquals(expected.cursorNumber(), result.get().cursorNumber(),
+                        "cursorNumber mismatch for case '" + caseName + "'");
+            }
         }
     }
 
diff --git a/src/test/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanelTest.java b/src/test/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanelTest.java
index b6cd911..3124162 100644
--- a/src/test/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanelTest.java
+++ b/src/test/java/io/github/nbplugins/claudecodegui/ui/ChoiceMenuPanelTest.java
@@ -1,6 +1,7 @@
 package io.github.nbplugins.claudecodegui.ui;
 
 import io.github.nbplugins.claudecodegui.model.ChoiceMenuModel;
+import io.github.nbplugins.claudecodegui.settings.ClaudeCodePreferences;
 import io.github.nbplugins.claudecodegui.model.ChoiceMenuModel.Option;
 import io.github.nbplugins.claudecodegui.ui.common.UiUtils;
 import java.awt.BorderLayout;
@@ -1034,10 +1035,52 @@ void testTextFieldsHaveUpDownBindings() throws Exception {
         });
     }
 
+    // -------------------------------------------------------------------------
+    // long menus
+    // -------------------------------------------------------------------------
+
+    @Test
+    void testLongOptionListIsCappedAndScrollable() throws Exception {
+        SwingUtilities.invokeAndWait(() -> {
+            ChoiceMenuPanel panel = new ChoiceMenuPanel(() -> null);
+            List<Option> opts = new ArrayList<>();
+            for (int i = 1; i <= 40; i++) opts.add(new Option("Model " + i, String.valueOf(i)));
+            panel.show(new ChoiceMenuModel("Select model", opts, 0, true, 3), a -> {}, false);
+
+            javax.swing.JScrollPane sp = findScrollPane(panel);
+            assertNotNull(sp, "option list must be inside a scroll pane");
+            assertEquals(ClaudeCodePreferences.DEFAULT_CHOICE_MENU_MAX_HEIGHT, sp.getPreferredSize().height,
+                    "tall list is capped at the configured max height");
+        });
+    }
+
+    @Test
+    void testShortOptionListIsNotCapped() throws Exception {
+        SwingUtilities.invokeAndWait(() -> {
+            ChoiceMenuPanel panel = new ChoiceMenuPanel(() -> null);
+            panel.show(new ChoiceMenuModel("Q?",
+                    List.of(new Option("A", "1"), new Option("B", "2"), new Option("C", "3")), 0), a -> {}, false);
+            javax.swing.JScrollPane sp = findScrollPane(panel);
+            assertNotNull(sp);
+            assertTrue(sp.getPreferredSize().height < ClaudeCodePreferences.DEFAULT_CHOICE_MENU_MAX_HEIGHT);
+        });
+    }
+
     // -------------------------------------------------------------------------
     // helpers
     // -------------------------------------------------------------------------
 
+    private static javax.swing.JScrollPane findScrollPane(java.awt.Container container) {
+        for (Component c : container.getComponents()) {
+            if (c instanceof javax.swing.JScrollPane sp) return sp;
+            if (c instanceof java.awt.Container sub) {
+                javax.swing.JScrollPane found = findScrollPane(sub);
+                if (found != null) return found;
+            }
+        }
+        return null;
+    }
+
     private static List<String> collectButtonLabels(java.awt.Container container) {
         List<String> labels = new ArrayList<>();
         for (Component c : container.getComponents()) {
@@ -1136,6 +1179,8 @@ private static List<JButton> collectYesNoButtons(java.awt.Container container) {
             if (c instanceof JButton btn) {
                 String t = btn.getText();
                 if (!"Send".equals(t) && !"Submit".equals(t) && !"Cancel".equals(t)) result.add(btn);
+            } else if (c instanceof javax.swing.JScrollBar) {
+                // scrollbar arrow buttons are not choice buttons
             } else if (c instanceof java.awt.Container sub) {
                 result.addAll(collectYesNoButtons(sub));
             }
diff --git a/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-bottom.expectedRes.json b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-bottom.expectedRes.json
new file mode 100644
index 0000000..d65bfbe
--- /dev/null
+++ b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-bottom.expectedRes.json
@@ -0,0 +1,28 @@
+{
+  "text": "Switch between Claude models. Your pick becomes the default for new sessions. For other/previous model names, specify with --model.",
+  "options": [
+    {
+      "display": "Fable 5                  Most capable for your hardest and longest-running tasks",
+      "response": "8"
+    },
+    {
+      "display": "Opus 4.8                 Best for everyday, complex tasks",
+      "response": "9"
+    },
+    {
+      "display": "Opus 4.7                 Best for everyday, complex tasks",
+      "response": "10"
+    },
+    {
+      "display": "Opus 4.6                 Best for everyday, complex tasks",
+      "response": "11"
+    },
+    {
+      "display": "Sonnet 4.6               Efficient for routine tasks",
+      "response": "12"
+    }
+  ],
+  "defaultOptionIndex": 0,
+  "scrollable": true,
+  "cursorNumber": 12
+}
diff --git a/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-bottom.src.txt b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-bottom.src.txt
new file mode 100644
index 0000000..8ef6821
--- /dev/null
+++ b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-bottom.src.txt
@@ -0,0 +1,15 @@
+─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  Select model
+  Switch between Claude models. Your pick becomes the default for new sessions. For other/previous model names, specify with --model.
+
+  ↑ 8.  Fable 5                  Most capable for your hardest and longest-running tasks
+    9.  Opus 4.8                 Best for everyday, complex tasks
+    10. Opus 4.7                 Best for everyday, complex tasks
+    11. Opus 4.6                 Best for everyday, complex tasks
+  ❯ 12. Sonnet 4.6               Efficient for routine tasks
+
+
+  ◐ Medium effort ←/→ to adjust
+
+  Enter to set as default · s to use this session only · Esc to cancel
+
diff --git a/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-middle.expectedRes.json b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-middle.expectedRes.json
new file mode 100644
index 0000000..2bf79d3
--- /dev/null
+++ b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-middle.expectedRes.json
@@ -0,0 +1,28 @@
+{
+  "text": "Switch between Claude models. Your pick becomes the default for new sessions. For other/previous model names, specify with --model.",
+  "options": [
+    {
+      "display": "Fable 5.1                For your toughest challenges",
+      "response": "4"
+    },
+    {
+      "display": "Haiku 4.5                Fastest for quick answers",
+      "response": "5"
+    },
+    {
+      "display": "Sonnet 5                 Efficient for routine tasks",
+      "response": "6"
+    },
+    {
+      "display": "Opus 5                   Best for everyday, complex tasks",
+      "response": "7"
+    },
+    {
+      "display": "Fable 5                  Most capable for your hardest and longest-running tasks",
+      "response": "8"
+    }
+  ],
+  "defaultOptionIndex": 0,
+  "scrollable": true,
+  "cursorNumber": 8
+}
diff --git a/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-middle.src.txt b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-middle.src.txt
new file mode 100644
index 0000000..f83092b
--- /dev/null
+++ b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-middle.src.txt
@@ -0,0 +1,16 @@
+─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  Select model
+  Switch between Claude models. Your pick becomes the default for new sessions. For other/previous model names, specify with --model.
+
+  ↑ 4.  Fable 5.1                For your toughest challenges
+    5.  Haiku 4.5                Fastest for quick answers
+    6.  Sonnet 5                 Efficient for routine tasks
+    7.  Opus 5                   Best for everyday, complex tasks
+  ❯ 8.  Fable 5                  Most capable for your hardest and longest-running tasks
+     … +4 models
+
+  ● High effort (default) ←/→ to adjust
+
+  Enter to set as default · s to use this session only · Esc to cancel
+
+
diff --git a/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-top.expectedRes.json b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-top.expectedRes.json
new file mode 100644
index 0000000..d9ea0fb
--- /dev/null
+++ b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-top.expectedRes.json
@@ -0,0 +1,28 @@
+{
+  "text": "Switch between Claude models. Your pick becomes the default for new sessions. For other/previous model names, specify with --model.",
+  "options": [
+    {
+      "display": "Default (recommended) ✔  Sonnet 5.5 · Efficient for routine tasks",
+      "response": "1"
+    },
+    {
+      "display": "Opus 5.5                 For complex work and everyday tasks",
+      "response": "2"
+    },
+    {
+      "display": "Sonnet 5.5               Most efficient for simpler tasks",
+      "response": "3"
+    },
+    {
+      "display": "Fable 5.1                For your toughest challenges",
+      "response": "4"
+    },
+    {
+      "display": "Haiku 4.5                Fastest for quick answers",
+      "response": "5"
+    }
+  ],
+  "defaultOptionIndex": 0,
+  "scrollable": true,
+  "cursorNumber": 3
+}
diff --git a/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-top.src.txt b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-top.src.txt
new file mode 100644
index 0000000..c35720c
--- /dev/null
+++ b/src/test/resources/io/github/nbplugins/claudecodegui/process/screen-content-detector/detect-choice-menu/model-scrolled-top.src.txt
@@ -0,0 +1,16 @@
+─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
+  Select model
+  Switch between Claude models. Your pick becomes the default for new sessions. For other/previous model names, specify with --model.
+
+    1.  Default (recommended) ✔  Sonnet 5.5 · Efficient for routine tasks
+    2.  Opus 5.5                 For complex work and everyday tasks
+  ❯ 3.  Sonnet 5.5               Most efficient for simpler tasks
+    4.  Fable 5.1                For your toughest challenges
+  ↓ 5.  Haiku 4.5                Fastest for quick answers
+     … +7 models
+
+  ◐ Medium effort (default) ←/→ to adjust
+
+  Enter to set as default · s to use this session only · Esc to cancel
+
+