openclacky 1.5.13 → 1.5.14

data/lib/clacky/tools/browser.rb

@@ -34,7 +34,9 @@ module Clacky
         Actions: open | navigate | snapshot | act | screenshot | tabs | focus | close | status
         Workflow: open → snapshot(interactive:true) → act(ref=...). New tab from `open` is auto-selected; only use `focus` to switch back to a previously-opened tab.
         snapshot: returns hierarchical a11y tree truncated to ~8KB. Use query="text" to seek, or offset=N to page.
-        act kinds: click | dblclick | type | fill | press | hover | scroll | drag | select | wait | evaluate | click_at
+        act kinds: click | dblclick | type | fill | fill_form | press | hover | scroll | drag | select | wait | evaluate | click_at
+        act auto-waits for network/DOM to settle and returns the post-action page state, so do NOT follow an act with a snapshot — read the result instead. Pass include_snapshot:false to skip it on trivial acts.
+        fill_form: ALWAYS prefer this over several individual fill/click calls on a form — one call, fewer turns. fill/type accept submit_key:"Enter" to submit in the same call.
         evaluate: `js` is a JS expression, e.g. "document.title". For multi-line / async logic use an IIFE: "(async () => { const r = await fetch(...); return r.status })()". Result is JSON-encoded.
         screenshot: expensive — pass `ref` to capture one element instead of the whole page.
       DESC
@@ -48,11 +50,24 @@ module Clacky
           },
           kind: {
             type: "string",
-            enum: %w[click dblclick type fill press hover drag select scroll wait evaluate click_at],
+            enum: %w[click dblclick type fill fill_form press hover drag select scroll wait evaluate click_at],
             description: "act: interaction kind"
           },
           ref:         { type: "string",  description: "element ref from snapshot (e.g. 'e1')" },
           text:        { type: "string",  description: "act type/fill text" },
+          submit_key:  { type: "string",  description: "act fill/type: key to press after filling (e.g. 'Enter')" },
+          elements: {
+            type: "array",
+            description: "act fill_form: [{ref, value}, ...] — fill a whole form in one call",
+            items: {
+              type: "object",
+              properties: {
+                ref:   { type: "string", description: "element ref from snapshot" },
+                value: { type: "string", description: "value; 'true'/'false' for checkboxes and toggles" }
+              },
+              required: ["ref", "value"]
+            }
+          },
           key:         { type: "string",  description: "act press key (e.g. 'Enter')" },
           direction:   { type: "string",  enum: %w[up down left right], description: "act scroll" },
           amount:      { type: "integer", description: "act scroll pixels (default 300)" },
@@ -70,7 +85,11 @@ module Clacky
           depth:       { type: "integer", description: "snapshot: max tree depth" },
           query:       { type: "string",  description: "snapshot: return window around first match" },
           offset:      { type: "integer", description: "snapshot: skip N lines (paging)" },
-          full_page:   { type: "boolean", description: "screenshot: full page" }
+          full_page:   { type: "boolean", description: "screenshot: full page" },
+          include_snapshot: {
+            type: "boolean",
+            description: "act: return the post-action page snapshot (default true). Set false for trivial acts."
+          }
         },
         required: ["action"]
       }
@@ -90,6 +109,14 @@ module Clacky
         "Target closed",
         "page is detached"
       ].freeze
+      # chrome-devtools-mcp resolves refs against the last snapshot it took for a
+      # page, so a page that has never been snapshotted rejects every ref call.
+      MISSING_SNAPSHOT_ERROR = "No snapshot found for page"
+      # Raised when a ref exists in no/older snapshot — the AI needs fresh refs.
+      STALE_REF_ERRORS = [
+        "not found on page",
+        "no longer exists on the page"
+      ].freeze
 
       def execute(action:, profile: nil, working_dir: nil, **opts)
         bypass = action.to_s == "status" ||
@@ -103,6 +130,23 @@ module Clacky
         { error: classify_browser_error(e) }
       end
 
+      # Hidden once the user turns the browser off, so the model never sees an
+      # action it would only get rejected for. An unconfigured browser stays
+      # visible — that path guides the user into browser-setup.
+      #
+      # Checked once at registration: the tools array carries the prompt-cache
+      # breakpoint, so it must stay byte-identical for the whole process.
+      # Toggling the browser takes effect on the next restart.
+      def self.available?
+        return true unless File.exist?(BROWSER_CONFIG_PATH)
+
+        config = YAMLCompat.safe_load(File.read(BROWSER_CONFIG_PATH),
+                                      permitted_classes: [Date, Time, Symbol])
+        config.is_a?(Hash) && config["enabled"] == true
+      rescue StandardError
+        true
+      end
+
       def format_call(args)
         action = args[:action] || args["action"] || "browser"
         "browser(#{action})"
@@ -142,13 +186,14 @@ module Clacky
         end
 
         output = result[:output].to_s
-        output = compress_snapshot(output) if action == "snapshot"
-        max_chars = action == "snapshot" ? MAX_SNAPSHOT_CHARS : MAX_LLM_OUTPUT_CHARS
+        has_snapshot = action == "snapshot" || result[:snapshot_included]
+        output = compress_snapshot(output) if has_snapshot
+        max_chars = has_snapshot ? MAX_SNAPSHOT_CHARS : MAX_LLM_OUTPUT_CHARS
 
         {
           action:  action,
           success: result[:success],
-          stdout:  truncate_output(output, max_chars),
+          stdout:  truncate_output(output, max_chars, paged: action == "snapshot"),
           profile: result[:profile]
         }.compact
       end
@@ -302,6 +347,7 @@ module Clacky
       private def do_user_act(opts)
         kind = (opts[:kind] || opts["kind"] || "click").to_s
         ref  = opts[:ref]   || opts["ref"]
+        snap = include_snapshot?(opts)
 
         # Page-scoped MCP calls all benefit from an explicit pageId. We pass it
         # transparently via with_page so the AI never has to think about it.
@@ -311,31 +357,48 @@ module Clacky
           return uid if uid.is_a?(Hash)
           args = { uid: uid }
           args[:dblClick] = true if kind == "dblclick"
-          mcp_call("click", with_page(args))
+          return act_result(kind, mcp_call("click", with_page(with_snapshot(args, snap))), opts, snap)
 
         when "fill", "type"
           uid = require_ref(ref)
           return uid if uid.is_a?(Hash)
-          mcp_call("fill", with_page({ uid: uid, value: opts[:text] || opts["text"] || "" }))
+          submit = opts[:submit_key] || opts["submit_key"]
+          fill_args = { uid: uid, value: (opts[:text] || opts["text"] || "").to_s }
+          if submit && !submit.to_s.empty?
+            mcp_call("fill", with_page(fill_args))
+            result = mcp_call("press_key", with_page(with_snapshot({ key: submit.to_s }, snap)))
+          else
+            result = mcp_call("fill", with_page(with_snapshot(fill_args, snap)))
+          end
+          return act_result(kind, result, opts, snap)
+
+        when "fill_form"
+          elements = normalize_form_elements(opts[:elements] || opts["elements"])
+          return elements if elements.is_a?(Hash)
+          result = mcp_call("fill_form", with_page(with_snapshot({ elements: elements }, snap)))
+          return act_result(kind, result, opts, snap)
 
         when "press"
-          mcp_call("press_key", with_page({ key: opts[:key] || opts["key"] || "Enter" }))
+          args = { key: (opts[:key] || opts["key"] || "Enter").to_s }
+          return act_result(kind, mcp_call("press_key", with_page(with_snapshot(args, snap))), opts, snap)
 
         when "hover"
           uid = require_ref(ref)
           return uid if uid.is_a?(Hash)
-          mcp_call("hover", with_page({ uid: uid }))
+          return act_result(kind, mcp_call("hover", with_page(with_snapshot({ uid: uid }, snap))), opts, snap)
 
         when "drag"
           uid = require_ref(ref)
           return uid if uid.is_a?(Hash)
-          mcp_call("drag", with_page({ from_uid: uid, to_uid: opts[:target_ref] || opts["target_ref"] || "" }))
+          args = { from_uid: uid, to_uid: (opts[:target_ref] || opts["target_ref"] || "").to_s }
+          return act_result(kind, mcp_call("drag", with_page(with_snapshot(args, snap))), opts, snap)
 
         when "select"
           uid = require_ref(ref)
           return uid if uid.is_a?(Hash)
           values = Array(opts[:values] || opts["values"] || [])
-          mcp_call("fill", with_page({ uid: uid, value: values.first.to_s }))
+          args = { uid: uid, value: values.first.to_s }
+          return act_result(kind, mcp_call("fill", with_page(with_snapshot(args, snap))), opts, snap)
 
         when "scroll"
           direction = opts[:direction] || opts["direction"] || "down"
@@ -352,7 +415,8 @@ module Clacky
             sleep(ms.to_i / 1000.0)
             return { action: "act", success: true, profile: "user", output: "Waited #{ms}ms" }
           elsif sel
-            mcp_call("wait_for", with_page({ text: [sel] }))
+            # wait_for always attaches a snapshot server-side.
+            return act_result(kind, mcp_call("wait_for", with_page({ text: [sel] })), opts, true)
           else
             sleep(1)
           end
@@ -367,8 +431,8 @@ module Clacky
           x = opts[:x] || opts["x"]
           y = opts[:y] || opts["y"]
           return { error: "click_at requires x and y coordinates" } unless x && y
-          result = mcp_call("click_at", with_page({ x: x.to_f, y: y.to_f }))
-          return { action: "act", success: true, profile: "user", output: extract_message(result).to_s }
+          args = { x: x.to_f, y: y.to_f }
+          return act_result(kind, mcp_call("click_at", with_page(with_snapshot(args, snap))), opts, snap)
 
         else
           return { error: "Unknown act kind: #{kind}" }
@@ -377,6 +441,72 @@ module Clacky
         { action: "act", success: true, profile: "user", output: "#{kind} completed." }
       end
 
+      # act defaults to returning the post-action snapshot: chrome-devtools-mcp
+      # renders it in the same response, so a follow-up snapshot call is waste.
+      private def include_snapshot?(opts)
+        val = opts.key?(:include_snapshot) ? opts[:include_snapshot] : opts["include_snapshot"]
+        return true if val.nil?
+        !(val == false || val.to_s == "false")
+      end
+
+      private def with_snapshot(args, enabled)
+        enabled ? args.merge(includeSnapshot: true) : args
+      end
+
+      private def normalize_form_elements(raw)
+        list = Array(raw)
+        return { error: "fill_form requires a non-empty `elements` array of {ref, value}" } if list.empty?
+
+        normalized = list.map do |entry|
+          next nil unless entry.is_a?(Hash)
+          uid   = entry[:ref]   || entry["ref"]   || entry[:uid]   || entry["uid"]
+          value = entry[:value] || entry["value"] || entry[:text]  || entry["text"]
+          next nil if uid.nil? || uid.to_s.empty?
+          { uid: uid.to_s, value: value.to_s }
+        end.compact
+
+        return { error: "fill_form `elements` entries must each have a `ref`" } if normalized.empty?
+        normalized
+      end
+
+      # Render an act response: the MCP status line plus the post-action
+      # snapshot when one was attached.
+      private def act_result(kind, result, opts, snapshot_requested)
+        message = extract_act_message(result).strip
+        message = "#{kind} completed." if message.empty?
+
+        parts = [message]
+        included = false
+
+        if snapshot_requested
+          node = extract_snapshot(result)
+          if node.is_a?(Hash) && !node.empty?
+            text = build_ai_snapshot(node,
+                                     interactive: opts[:interactive] || opts["interactive"],
+                                     compact:     opts[:compact]     || opts["compact"],
+                                     max_depth:   opts[:depth]       || opts["depth"])
+            unless text.empty?
+              parts << "## Page snapshot after #{kind}\n#{text}"
+              included = true
+            end
+          end
+        end
+
+        { action: "act", success: true, profile: "user",
+          output: parts.join("\n\n"), snapshot_included: included }
+      end
+
+      # Like extract_message, but drops the MCP-rendered snapshot block from the
+      # text fallback so it is not duplicated alongside our own rendering.
+      private def extract_act_message(result)
+        return "" unless result.is_a?(Hash)
+
+        structured = result["structuredContent"]
+        return structured["message"].to_s if structured.is_a?(Hash) && structured["message"]
+
+        extract_text_content(result).split("## Latest page snapshot").first.to_s
+      end
+
       # Merge pageId into MCP args when we know the current page. Safe no-op
       # if the cache is empty — the MCP server then falls back to its own
       # selected-page state, matching the old behaviour.
@@ -460,11 +590,19 @@ module Clacky
       # -----------------------------------------------------------------------
 
       # Delegate to BrowserManager. Auto-retries once on transient page-context errors
-      # (closed/detached selected page, or "no active page" right after open).
+      # (closed/detached selected page, or "no active page" right after open) and on
+      # a missing page snapshot (fresh tab that ref-based calls cannot resolve yet).
       private def mcp_call(tool_name, arguments = {})
         Clacky::BrowserManager.instance.mcp_call(tool_name, arguments)
       rescue RuntimeError => e
         msg = e.message.to_s
+
+        if msg.include?(MISSING_SNAPSHOT_ERROR)
+          # Prime the page snapshot the MCP server resolves refs against, then retry once.
+          return Clacky::BrowserManager.instance.mcp_call(tool_name, arguments) if prime_page_snapshot
+          raise RuntimeError, "The page has no snapshot yet. Use action=snapshot first, then retry."
+        end
+
         if RETRYABLE_PAGE_ERRORS.any? { |frag| msg.include?(frag) }
           # Try to recover by re-selecting the most recent page, then retry once.
           recovered = recover_selected_page
@@ -474,9 +612,23 @@ module Clacky
           end
           raise RuntimeError, "The browser tab is no longer available. Use action=open to open a new tab, then retry."
         end
+
+        if STALE_REF_ERRORS.any? { |frag| msg.include?(frag) }
+          raise RuntimeError, "#{msg} The page changed — use action=snapshot to get fresh refs, then retry."
+        end
+
         raise
       end
 
+      # Take a snapshot purely so the MCP server has refs to resolve against.
+      # Returns true when the page now has one.
+      private def prime_page_snapshot
+        Clacky::BrowserManager.instance.mcp_call("take_snapshot", with_page({}))
+        true
+      rescue StandardError
+        false
+      end
+
       # Pick the currently selected page, or fall back to the most recent one,
       # and re-issue select_page so subsequent calls have a valid context.
       # Returns the chosen pageId, or nil if there are no pages at all.
@@ -762,7 +914,7 @@ module Clacky
         collapsed.join
       end
 
-      private def truncate_output(output, max_chars)
+      private def truncate_output(output, max_chars, paged: true)
         return output if output.length <= max_chars
 
         lines      = output.lines
@@ -774,8 +926,13 @@ module Clacky
           first_part << line
           acc += line.length
         end
-        hint = "\n... [truncated: #{first_part.size}/#{lines.size} lines shown — " \
-               "rerun with query=\"keyword\" or offset=#{first_part.size} to see more] ...\n"
+        hint = if paged
+                 "\n... [truncated: #{first_part.size}/#{lines.size} lines shown — " \
+                 "rerun with query=\"keyword\" or offset=#{first_part.size} to see more] ...\n"
+               else
+                 "\n... [truncated: #{first_part.size}/#{lines.size} lines shown — " \
+                 "use action=snapshot with query=\"keyword\" if you need the rest] ...\n"
+               end
         first_part.join + hint
       end
     end

data/lib/clacky/tools/web_search.rb

@@ -30,10 +30,14 @@ module Clacky
       }
 
       # Ordered list of search providers to try in sequence.
-      # cn.bing.com is accessible in mainland China without VPN.
-      PROVIDERS = %i[duckduckgo bing].freeze
+      # Parallel is the primary no-key provider; the HTML scrapers remain as
+      # fallbacks, with cn.bing.com accessible in mainland China without VPN.
+      PROVIDERS = %i[parallel duckduckgo bing].freeze
 
       SEARCHER_TIMEOUT = 30
+      PARALLEL_ENDPOINT = "https://search.parallel.ai/mcp"
+      PARALLEL_SNIPPET_MAX_CHARS = 400
+      PROVIDER_COOLDOWN_SECONDS = 600
 
       def execute(query:, max_results: 10, working_dir: nil)
         if query.nil? || query.strip.empty?
@@ -57,8 +61,13 @@ module Clacky
               error: nil
             }
           rescue StandardError => e
-            # DuckDuckGo failed — suppress it for 10 minutes
-            @ddg_unavailable_until = Time.now + 600 if provider == :duckduckgo
+            # Avoid paying the same network/handshake failure on every search.
+            if provider == :parallel
+              reset_parallel_client
+              @parallel_unavailable_until = Time.now + PROVIDER_COOLDOWN_SECONDS
+            elsif provider == :duckduckgo
+              @ddg_unavailable_until = Time.now + PROVIDER_COOLDOWN_SECONDS
+            end
             last_error = e
             next
           end
@@ -93,13 +102,75 @@ module Clacky
         # broken key or script look like a low-quality result set.
         return [:custom] if Clacky::SearchConfig.script_path
 
-        if @ddg_unavailable_until && Time.now < @ddg_unavailable_until
-          PROVIDERS.drop(1)
-        else
-          PROVIDERS
+        PROVIDERS.reject do |provider|
+          unavailable_until = case provider
+                              when :parallel then @parallel_unavailable_until
+                              when :duckduckgo then @ddg_unavailable_until
+                              end
+          unavailable_until && Time.now < unavailable_until
         end
       end
 
+      # ── Parallel Free MCP ──────────────────────────────────────────────────
+
+      private def search_parallel(query, max_results)
+        result = parallel_client.call_tool(
+          "web_search",
+          {
+            "objective" => query[0, 5000],
+            "search_queries" => [query[0, 200]],
+            "session_id" => parallel_logical_session_id
+          }
+        )
+
+        if result["isError"]
+          message = extract_parallel_content_text(result)
+          raise(message.empty? ? "Parallel search failed" : message)
+        end
+
+        payload = result["structuredContent"]
+        payload ||= JSON.parse(extract_parallel_content_text(result))
+        raise "Parallel returned malformed search results" unless payload.is_a?(Hash) && payload["results"].is_a?(Array)
+
+        payload["results"].filter_map do |item|
+          next unless item.is_a?(Hash)
+
+          url = item["url"].to_s
+          next if url.empty?
+
+          snippet = Array(item["excerpts"]).join(" ").gsub(/\s+/, " ").strip
+          {
+            title: item["title"].to_s,
+            url: url,
+            snippet: snippet[0, PARALLEL_SNIPPET_MAX_CHARS]
+          }
+        end.first(max_results)
+      rescue JSON::ParserError
+        raise "Parallel returned malformed JSON"
+      end
+
+      private def parallel_client
+        @parallel_client ||= Clacky::Mcp::Client.from_spec(
+          "parallel-free",
+          { "type" => "http", "url" => PARALLEL_ENDPOINT }
+        ).tap(&:start)
+      end
+
+      private def reset_parallel_client
+        @parallel_client&.stop
+        @parallel_client = nil
+      end
+
+      private def parallel_logical_session_id
+        @parallel_logical_session_id ||= SecureRandom.uuid
+      end
+
+      private def extract_parallel_content_text(result)
+        Array(result["content"]).filter_map do |item|
+          item["text"] if item.is_a?(Hash) && item["type"] == "text"
+        end.join("\n")
+      end
+
       # ── Configured searcher (~/.clacky/searchers/<provider>.rb) ────────────
 
       private def search_custom(query, max_results)

data/lib/clacky/ui2/components/command_suggestions.rb

@@ -16,7 +16,8 @@ module Clacky
           { command: "/clear", description: "Clear chat history and restart session" },
           { command: "/config", description: "Open configuration (models, API keys, settings)" },
           { command: "/model", description: "Quickly switch the current model" },
-          { command: "/goal", description: "Set a standing goal for autonomous multi-turn work" },
+          { command: "/think", description: "Set the thinking (reasoning) effort level" },
+          { command: "/goal", description: "Set a standing goal for autonomous multi-turn work", argument_hint: "<goal text>" },
           { command: "/undo", description: "Undo the last task and restore previous state" },
           { command: "/help", description: "Show help information" },
           { command: "/exit", description: "Exit the chat session" },

data/lib/clacky/ui2/components/input_area.rb

@@ -62,6 +62,7 @@ module Clacky
             working_dir: nil,
             mode: nil,
             model: nil,
+            reasoning_effort: nil,  # nil = provider default; appended to model name when set
             tasks: 0,
             cost: 0.0,
             cost_source: nil,  # nil / :api / :price / :default — :default means pricing unknown, show N/A
@@ -145,15 +146,18 @@ module Clacky
         # @param working_dir [String] Working directory
         # @param mode [String] Permission mode
         # @param model [String] AI model name
+        # @param reasoning_effort [String, nil] Thinking level; nil (explicit) appends nothing,
+        #   :_unset (default) leaves the previous value untouched
         # @param tasks [Integer] Number of completed tasks
         # @param cost [Float] Total cost
         # @param cost_source [Symbol, nil] :api / :price / :default — :default renders as N/A
         # @param status [String] Workspace status ('idle' or 'working')
-        def update_sessionbar(session_id: nil, working_dir: nil, mode: nil, model: nil, tasks: nil, cost: nil, cost_source: nil, status: nil)
+        def update_sessionbar(session_id: nil, working_dir: nil, mode: nil, model: nil, reasoning_effort: :_unset, tasks: nil, cost: nil, cost_source: nil, status: nil)
           @sessionbar_info[:session_id] = session_id if session_id
           @sessionbar_info[:working_dir] = working_dir if working_dir
           @sessionbar_info[:mode] = mode if mode
           @sessionbar_info[:model] = model if model
+          @sessionbar_info[:reasoning_effort] = reasoning_effort unless reasoning_effort == :_unset
           @sessionbar_info[:tasks] = tasks if tasks
           @sessionbar_info[:cost] = cost if cost
           @sessionbar_info[:cost_source] = cost_source if cost_source
@@ -184,10 +188,23 @@ module Clacky
               @command_suggestions.select_next
               return { action: nil }
             when :enter
-              # Accept selected command and submit immediately
+              # Accept selected command; submit immediately — unless the
+              # command takes arguments (argument_hint), in which case only
+              # complete the name so the user can type the arguments first
+              # (same behavior as Tab).
               if @command_suggestions.has_suggestions?
                 selected = @command_suggestions.selected_command_text
                 if selected
+                  hint = @command_suggestions.selected_argument_hint
+                  if hint && !hint.empty?
+                    completed = "#{selected} "
+                    @lines = [completed]
+                    @line_index = 0
+                    @cursor_position = completed.length
+                    @command_suggestions.hide
+                    set_tips("Usage: #{selected} #{hint}", type: :info)
+                    return { action: nil }
+                  end
                   # Replace current input with selected command
                   @lines = [selected]
                   @line_index = 0
@@ -1187,6 +1204,9 @@ module Clacky
             parts << theme.format_text(@sessionbar_info[:model], :statusbar_secondary)
           end
 
+          # Thinking level (nil renders as off = provider default)
+          parts << theme.format_text((@sessionbar_info[:reasoning_effort] || 'off').to_s, :statusbar_secondary)
+
           # Tasks count
           parts << theme.format_text("#{@sessionbar_info[:tasks]} tasks", :statusbar_secondary)
 

data/lib/clacky/ui2/components/modal_component.rb

@@ -59,8 +59,18 @@ module Clacky
 
           # Adjust height based on mode
           if @mode == :menu
-            visible_items = [@choices.length, 15].min
-            @height = visible_items + 4  # +4 for title, borders, and instructions
+            # Choices marked sticky: true (e.g. /config action buttons) are
+            # always rendered below the scrollable area, so they never scroll
+            # out of view no matter how many models precede them.
+            @scroll_count = @choices.count { |c| !c[:sticky] }
+            @sticky_count = @choices.length - @scroll_count
+            @visible_items = [@scroll_count, 15].min
+            @height = @visible_items + @sticky_count + 4  # +4 for title, borders, and instructions
+            # Scroll window: draw_menu_choices only renders this slice, so a
+            # menu with more choices than fit (e.g. /config with many models)
+            # scrolls instead of painting over the bottom border.
+            @window_start = 0
+            clamp_scroll_window
           else
             # Form mode - adjust height based on number of fields
             # Each field takes 2 rows (label + input)
@@ -369,11 +379,17 @@ module Clacky
           end
         end
 
-        # Draw menu choices
+        # Draw menu choices (only the visible scroll window, then sticky tail)
         private def draw_menu_choices(start_row, start_col)
-          @choices.each_with_index do |choice, index|
-            row = start_row + index
-            draw_menu_choice(choice, index, row, start_col)
+          window_end = [@window_start + @visible_items, @scroll_count].min
+          (@window_start...window_end).each do |index|
+            draw_menu_choice(@choices[index], index, start_row + index - @window_start, start_col)
+          end
+
+          sticky_row = start_row + (window_end - @window_start)
+          (@scroll_count...@choices.length).each do |index|
+            draw_menu_choice(@choices[index], index, sticky_row, start_col)
+            sticky_row += 1
           end
         end
 
@@ -438,6 +454,19 @@ module Clacky
             # Skip disabled choices
             break unless @choices[@selected_index][:disabled]
           end
+          clamp_scroll_window
+        end
+
+        # Keep the cursor inside the visible window, scrolling when needed.
+        # Sticky choices are always on screen, so they never move the window.
+        private def clamp_scroll_window
+          return if @selected_index >= @scroll_count
+
+          if @selected_index < @window_start
+            @window_start = @selected_index
+          elsif @selected_index >= @window_start + @visible_items
+            @window_start = @selected_index - @visible_items + 1
+          end
         end
       end
     end