kward 0.69.1 → 0.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ac5f4222e4587d469ce5cb838e4fb0404309083a85a144378f16e75fdfa76ba
-  data.tar.gz: 325995cade98eb049a465bbfa9d12f2c7ffc9ed1fec0b14be889d2810741fe93
+  metadata.gz: 12e9e888bceffd64f87f36ea3aa79e4108901e92a193db7c86e588abef789f04
+  data.tar.gz: 4b69dcc0fca28d026931ec809bba3f2b64ad12b37930df51454ad80003104ac0
 SHA512:
-  metadata.gz: 7fe3449248d4ae757422cd8e8113ad23b1bdb9dd6555015c64ea628911a8aa937a336b109945029b94f3f5e3fa4846b017af9455e839188ae3b2eb9ca1254cac
-  data.tar.gz: a92899f7e09d769220246923442450312b27852a801e64f273c3237594ab831b578ad72bde87f6fc6611c4b6fb5a02f4e6080bb7ecb2cd7cc3130e4804e76fc0
+  metadata.gz: d372a52d9eb15695e33f6723d060ea051a8cda166e3692c5b3f634a1d7ca5cd7b533dc8afc41f88f39228af095af049c8b767c3d9696e846fb99b58218fdae5f
+  data.tar.gz: 7ff32c27130676339ab62bccbbc2777c5a382c8adf66f4d1fec525d4c12ecea0aa8d563814c331f409f8c030f0236cc3dd727405955c4bedcb96705c94d42aec

data/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to Kward will be documented in this file.
 
 ## [Unreleased]
 
+## [0.70.0] - 2026-06-18
+
+### Added
+
+- Added `z-ai/glm-5.2` to the static OpenRouter model choices.
+- Added `/rewind` for revisiting earlier user prompts and continuing from there as a branch, while `/tree` remains the advanced full session tree navigator.
+
+### Changed
+
+- Changed TUI list navigation to keep long `/sessions` and `/tree` pickers centered while scrolling, and removed wrap-around at list edges.
+- Changed the saved session picker slash command to `/sessions`, with `/resume` kept as an alias.
+
+### Fixed
+
+- Fixed overlay open/close rendering so the interactive composer stays visible instead of briefly blinking away.
+- Fixed interactive session diff totals to show the net workspace diff instead of counting repeated edits to the same lines multiple times.
+- Fixed `/sessions` picker cancellation so Escape closes smoothly without a blink, while keeping the loading spinner visible as saved sessions are loaded.
+- Fixed root-prompt session tree navigation so it no longer persists an empty active branch that makes cloned sessions resume with a blank transcript.
+- Fixed `/resume` session picker entries to show cloned session ancestry as a tree.
+- Made `/tree` branch indentation more visible in the terminal session picker.
+- Fixed `Encoding::CompatibilityError` crash during compaction when tool results contained ASCII-8BIT (BINARY) strings from HTTP response bodies or shell output. Tool content is now normalized to UTF-8 on append.
+
 ## [0.69.1] - 2026-06-18
 
 ### Fixed

data/doc/configuration.md

@@ -188,7 +188,7 @@ Interactive CLI and RPC clients start fresh by default. To automatically resume
 }
 ```
 
-The `/resume` command and RPC `sessions/resume` work regardless of this automatic resume setting.
+The `/sessions` command, `/resume` alias, and RPC `sessions/resume` work regardless of this automatic resume setting.
 
 ## Memory
 

data/doc/getting-started.md

@@ -96,7 +96,9 @@ Inside interactive Kward:
 /login              sign in or save provider credentials
 /model              choose a model
 /status             show session and context status
-/resume             resume a previous session
+/sessions           open the saved sessions picker
+/resume             alias for /sessions
+/rewind             revisit an earlier prompt
 /export notes.md    export the transcript
 /compact            summarize older context when a chat gets long
 /exit               leave Kward

data/doc/usage.md

@@ -97,9 +97,12 @@ Use slash commands for local actions that should not go to the model:
 | `/reasoning` | choose reasoning effort. |
 | `/status` | see session, model, and context status. |
 | `/new` | start a fresh session. |
-| `/resume` | continue a previous session. |
+| `/sessions` | open the saved sessions picker or continue a previous session by path. |
+| `/resume` | alias for `/sessions`. |
 | `/name <name>` | name the current session. |
 | `/clone` | copy the current session into a new branch. |
+| `/rewind` | revisit an earlier prompt and try a different direction. |
+| `/tree` | inspect and navigate the full technical session tree. |
 | `/copy last` | copy the latest assistant answer. |
 | `/copy transcript` | copy the transcript as Markdown. |
 | `/export notes.md` | write the transcript to a Markdown file. |
@@ -132,9 +135,13 @@ Typical flow:
 Later:
 
 ```text
-/resume
+/sessions
 ```
 
+`/resume` remains available as an alias.
+
+Use `/rewind` when you want to go back to an earlier prompt and try a different direction. Kward shows user prompts from the current session, lets you edit a prior prompt, and continues from that point as a branch. Use `/tree` when you need the full technical session tree, including branches, assistant entries, tool calls, and tool results.
+
 Use `/compact` when a conversation gets long. Kward summarizes older context and keeps recent context active. After compaction, it may need to re-read files before editing them again.
 
 ## One-shot prompts

data/lib/kward/cli/prompt_interface.rb

@@ -25,7 +25,11 @@ module Kward
           banner_pixels: banner_enabled ? Kward::PromptInterface::BANNER_LOGO_PIXELS : nil,
           banner_message: banner_enabled ? Kward::PromptInterface::BANNER_MESSAGE : nil
         )
-        @prompt.start
+        if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
+          @prompt.start(render: false)
+        else
+          @prompt.start
+        end
       end
 
       def load_prompt_interface

data/lib/kward/cli/sessions.rb

@@ -1,3 +1,5 @@
+require "time"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
@@ -131,7 +133,7 @@ module Kward
           return nil
         end
 
-        tree_items = session_tree_items(session_store)
+        tree_items = run_busy_local_command_and_requeue { session_tree_items(session_store) }
         if tree_items.empty?
           runtime_output("No session tree entries found.")
           return nil
@@ -147,8 +149,12 @@ module Kward
         entry = tree_items.find { |item| item[:entry]["id"].to_s == entry_id }&.fetch(:entry)
         return nil unless entry
 
-        selected_text = apply_session_tree_entry(entry)
-        runtime_output("Moved session tree position to #{entry["id"]}.")
+        selected_text = nil
+        agent = run_busy_local_command_and_requeue do
+          selected_text = apply_session_tree_entry(entry)
+          runtime_output("Moved session tree position to #{entry["id"]}.")
+          reload_active_session(session_store)
+        end
         if selected_text && !selected_text.empty?
           if @prompt.respond_to?(:prefill_input)
             @prompt.prefill_input(selected_text)
@@ -156,8 +162,7 @@ module Kward
             runtime_output("Selected text for editing:\n#{selected_text}")
           end
         end
-        agent = reload_active_session(session_store)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
         agent
       rescue StandardError => e
         runtime_output("Session tree error: #{e.message}")
@@ -175,11 +180,193 @@ module Kward
         answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
       end
 
+      def rewind_session(session_store)
+        return say_sessions_unavailable unless session_store
+        unless @active_session
+          runtime_output("No active persisted session.")
+          return nil
+        end
+
+        points = rewind_points(session_store)
+        if points.empty?
+          runtime_output("No prompts to rewind to.")
+          return nil
+        end
+
+        labels = points.map { |point| point[:label] }
+        choice = select_rewind_point(labels)
+        return nil unless choice
+
+        point = points[labels.index(choice)]
+        return nil unless point
+
+        if point[:return_leaf_id]
+          @active_session.branch(point[:return_leaf_id])
+          @rewind_return_leaf_id = nil
+        else
+          @rewind_return_leaf_id = @active_session.leaf_id || session_store.current_leaf(@active_session.path)
+          selected_text = apply_session_tree_entry(point[:entry])
+          if selected_text && !selected_text.empty?
+            if @prompt.respond_to?(:prefill_input)
+              @prompt.prefill_input(selected_text)
+            else
+              runtime_output("Selected prompt for editing:\n#{selected_text}")
+            end
+          end
+        end
+        agent = reload_active_session(session_store)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
+        agent
+      rescue StandardError => e
+        runtime_output("Rewind error: #{e.message}")
+        nil
+      end
+
+      def select_rewind_point(labels)
+        if @prompt.respond_to?(:select)
+          return @prompt.select("Rewind>", labels, title: "Rewind")
+        end
+
+        numbered_labels = labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }
+        runtime_output((["Rewind to:"] + numbered_labels).join("\n"))
+        answer = @prompt.ask("Rewind point number>").to_s.strip
+        answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
+      end
+
+      def rewind_points(session_store)
+        entries = session_store.session_entries(@active_session.path)
+        current_leaf_id = @active_session.leaf_id || session_store.current_leaf(@active_session.path)
+        active_path = active_session_tree_entry_ids(entries, current_leaf_id)
+        user_entries = entries.select { |entry| rewind_entry?(entry) }
+        points = user_entries.reverse_each.with_index.map do |entry, index|
+          {
+            entry: entry,
+            label: rewind_point_label(entry, index, active_path.include?(entry["id"].to_s)),
+            timestamp: entry["timestamp"]
+          }
+        end
+        return_point = rewind_return_point(entries, current_leaf_id)
+        points = [return_point] + points if return_point
+        align_rewind_point_timestamps(points, picker_choice_width)
+      end
+
+      def rewind_return_point(entries, current_leaf_id)
+        return nil if @rewind_return_leaf_id.to_s.empty?
+        return nil if @rewind_return_leaf_id.to_s == current_leaf_id.to_s
+
+        entry = entries.find { |candidate| candidate["id"].to_s == @rewind_return_leaf_id.to_s }
+        return nil unless entry
+
+        {
+          return_leaf_id: @rewind_return_leaf_id,
+          label: "Return to where I was: #{truncate_rewind_text(rewind_return_text(entry))}",
+          timestamp: entry["timestamp"]
+        }
+      end
+
+      def align_rewind_point_timestamps(points, width)
+        labels = points.map { |point| point[:label].to_s }
+        label_width = labels.map(&:length).max.to_i
+        points.each do |point|
+          timestamp = relative_rewind_time(point[:timestamp])
+          next if timestamp.empty?
+
+          point[:label] = right_aligned_picker_metadata(point[:label], timestamp, width: width, minimum_label_width: label_width)
+        end
+      end
+
+      def right_aligned_picker_metadata(label, metadata, width:, minimum_label_width: 0)
+        label = label.to_s
+        metadata = metadata.to_s
+        fallback_width = minimum_label_width + metadata.length + 2
+        target_width = width.to_i.positive? ? width.to_i : fallback_width
+        label_width = [target_width - metadata.length - 2, 1].max
+        "#{truncate_picker_label(label, label_width).ljust(label_width)}  #{metadata}"
+      end
+
+      def truncate_picker_label(label, width)
+        return "" if width <= 0
+
+        text = label.to_s
+        return text if text.length <= width
+        return text.slice(0, width) if width <= 3
+
+        "#{text.slice(0, width - 3)}..."
+      end
+
+      def relative_rewind_time(timestamp)
+        time = Time.iso8601(timestamp.to_s).utc
+        seconds = [(Time.now.utc - time).to_i, 0].max
+        case seconds
+        when 0...60
+          "just now"
+        when 60...3600
+          minutes = seconds / 60
+          "#{minutes} min ago"
+        when 3600...86_400
+          hours = seconds / 3600
+          "#{hours} h ago"
+        else
+          days = seconds / 86_400
+          "#{days} d ago"
+        end
+      rescue ArgumentError
+        ""
+      end
+
+      def rewind_return_text(entry)
+        message = entry["message"]
+        text = full_message_text(message) if message.is_a?(Hash)
+        text.to_s.empty? ? entry["id"].to_s : text
+      end
+
+      def rewind_entry?(entry)
+        return false unless entry["type"] == "message"
+
+        message = entry["message"]
+        message.is_a?(Hash) && message_role(message) == "user" && !full_message_text(message).empty?
+      end
+
+      def rewind_point_label(entry, index, active)
+        marker = active ? "• " : ""
+        prefix = case index
+                 when 0 then "Last prompt"
+                 when 1 then "2 turns ago"
+                 else "#{index + 1} turns ago"
+                 end
+        "#{marker}#{prefix}: #{truncate_rewind_text(full_message_text(entry["message"] || {}))}"
+      end
+
+      def active_session_tree_entry_ids(entries, leaf_id)
+        by_id = entries.to_h { |entry| [entry["id"].to_s, entry] }
+        ids = []
+        seen = {}
+        current = by_id[leaf_id.to_s]
+        while current && !seen[current["id"].to_s]
+          seen[current["id"].to_s] = true
+          ids << current["id"].to_s
+          current = by_id[current["parentId"].to_s]
+        end
+        ids
+      end
+
+      def truncate_rewind_text(text)
+        text.to_s.gsub(/\s+/, " ").strip
+      end
+
+      def picker_choice_width
+        if @prompt.respond_to?(:picker_choice_width)
+          @prompt.picker_choice_width
+        else
+          96
+        end
+      end
+
       def apply_session_tree_entry(entry)
         message = entry["message"]
         if message.is_a?(Hash) && message_role(message) == "user"
           target_leaf = entry["parentId"]
-          target_leaf.to_s.empty? ? @active_session.reset_leaf : @active_session.branch(target_leaf)
+          @active_session.branch(target_leaf) unless target_leaf.to_s.empty?
           return full_message_text(message)
         end
 
@@ -314,7 +501,10 @@ module Kward
       end
 
       def select_session_path(session_store)
-        sessions = session_store.recent(limit: nil)
+        select_session_path_from_sessions(session_store.recent_tree(limit: nil))
+      end
+
+      def select_session_path_from_sessions(sessions)
         if sessions.empty?
           runtime_output("No saved sessions found.")
           return nil

data/lib/kward/cli/slash_commands.rb

@@ -43,19 +43,28 @@ module Kward
           [true, nil]
         when "new"
           [true, run_busy_local_command_and_requeue { start_new_session(session_store) }]
-        when "resume"
-          [true, run_busy_local_command_and_requeue do
-            path = argument.to_s.strip
-            path = select_session_path(session_store) if session_store && path.empty?
-            resume_session(session_store, path)
-          end]
+        when "sessions", "resume"
+          unless session_store
+            say_sessions_unavailable
+            return [true, nil]
+          end
+
+          path = argument.to_s.strip
+          if path.empty?
+            sessions = run_busy_local_command_and_requeue { session_store.recent_tree(limit: nil) }
+            path = select_session_path_from_sessions(sessions)
+          end
+          replacement_agent = path.to_s.empty? ? nil : run_busy_local_command_and_requeue { resume_session(session_store, path) }
+          [true, replacement_agent]
         when "name"
           run_busy_local_command_and_requeue { rename_session(argument) }
           [true, nil]
         when "clone"
           [true, run_busy_local_command_and_requeue { clone_session(session_store, agent) }]
+        when "rewind"
+          [true, run_busy_local_command_and_requeue { rewind_session(session_store) }]
         when "tree"
-          [true, run_busy_local_command_and_requeue { navigate_session_tree(session_store) }]
+          [true, navigate_session_tree(session_store)]
         when "copy"
           run_busy_local_command_and_requeue { copy_session_text(agent.conversation, argument) }
           [true, nil]

data/lib/kward/cli.rb

@@ -311,6 +311,7 @@ module Kward
         input = expanded_input || input
         @footer_conversation = agent.conversation
         begin
+          @rewind_return_leaf_id = nil
           auto_name_active_session(display_input || input)
           pending_inputs = run_interactive_turn(agent, input, display_input: display_input)
           pending_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }

data/lib/kward/conversation.rb

@@ -111,6 +111,7 @@ module Kward
     end
 
     def append_tool(tool_call_id:, name:, content:)
+      content = normalize_tool_content(content) if content.is_a?(String)
       append_message({
         role: "tool",
         tool_call_id: tool_call_id,
@@ -241,5 +242,19 @@ module Kward
       message
     end
 
+    # Tool results may arrive as ASCII-8BIT (BINARY) strings, e.g. from
+    # Net::HTTP response bodies or shell command output. When such a string
+    # is later concatenated with a UTF-8 string containing non-ASCII bytes
+    # (during compaction or JSON serialization), Ruby raises
+    # Encoding::CompatibilityError. Re-tag BINARY strings as UTF-8 when the
+    # bytes are valid UTF-8; otherwise scrub so the content is always
+    # serializable and concatenable.
+    def normalize_tool_content(string)
+      return string unless string.encoding == Encoding::ASCII_8BIT
+
+      probe = string.dup.force_encoding(Encoding::UTF_8)
+      probe.valid_encoding? ? probe : probe.scrub
+    end
+
   end
 end

data/lib/kward/model/model_info.rb

@@ -10,7 +10,10 @@ module Kward
     DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6"
     DEFAULT_REASONING_EFFORT = "medium"
     OPENAI_MODEL_CHOICES = %w[gpt-5.5 gpt-5.4 gpt-5.4-mini gpt-5.3-codex-spark].freeze
-    OPENROUTER_MODEL_CHOICES = OPENAI_MODEL_CHOICES.map { |model| "openai/#{model}" }.freeze
+    OPENROUTER_MODEL_CHOICES = [
+      *OPENAI_MODEL_CHOICES.map { |model| "openai/#{model}" },
+      "z-ai/glm-5.2"
+    ].freeze
     ANTHROPIC_MODEL_CHOICES = %w[
       claude-opus-4-8
       claude-sonnet-4-6
@@ -115,6 +118,9 @@ module Kward
     GEMINI_CONTEXT_WINDOWS = [
       [/\Agemini-(?:2\.5-pro|3(?:\.1)?-pro|3(?:\.5)?-flash)/, 1_048_576]
     ].freeze
+    OPENROUTER_CONTEXT_WINDOWS = [
+      [/\Az-ai\/glm-5\.2\z/, 1_048_576]
+    ].freeze
 
     module_function
 
@@ -252,7 +258,7 @@ module Kward
       return anthropic_context_window(text.delete_prefix("anthropic/")) if text.start_with?("anthropic/")
       return pattern_context_window(GEMINI_CONTEXT_WINDOWS, text.delete_prefix("google/")) if text.start_with?("google/")
 
-      nil
+      pattern_context_window(OPENROUTER_CONTEXT_WINDOWS, text)
     end
 
     def copilot_context_window(id)
@@ -298,6 +304,7 @@ module Kward
 
     def openai_reasoning_effort_choices(id)
       text = id.to_s.delete_prefix("openai/")
+      return REASONING_EFFORT_CHOICES if text == "z-ai/glm-5.2"
       return REASONING_EFFORT_CHOICES if text.match?(/\Agpt-5\.[23]-codex/)
 
       OPENAI_REASONING_EFFORT_CHOICES

data/lib/kward/prompt_interface/overlay_renderer.rb

@@ -73,6 +73,30 @@ module Kward
         (" " * left) + row + (" " * right)
       end
 
+      def next_list_selection_index(index, count)
+        return 0 if count <= 0
+
+        [index + 1, count - 1].min
+      end
+
+      def previous_list_selection_index(index, count)
+        return 0 if count <= 0
+
+        [index - 1, 0].max
+      end
+
+      def centered_list_window_start(index, count, max_rows)
+        return 0 if count <= max_rows
+
+        last_start = count - max_rows
+        middle_offset = max_rows / 2
+        [[index - middle_offset, 0].max, last_start].min
+      end
+
+      def max_overlay_list_rows(height)
+        [[height - 7, 1].max, 8].min
+      end
+
       def overlay_left_padding(width, row_width)
         padding = [width - row_width, 0].max
         case @overlay_settings["alignment"]

data/lib/kward/prompt_interface/prompt_renderer.rb

@@ -9,17 +9,19 @@ module Kward
       def render_prompt_locked
         return unless @started && @asking
 
-        handle_resize_locked
-        width, height = screen_size
-        rows, cursor_row, cursor_col = composer_layout(width, height)
-        ensure_scroll_region_locked(rows.length, width: width, height: height)
-        @rendered_rows = rows.length
-        render_composer_rows_locked(rows, height: height)
-        @cursor_rendered_row = cursor_row
-        @last_width = width
-        @last_height = height
-        move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
-        render_cursor_visibility_locked
+        with_synchronized_output_locked do
+          handle_resize_locked
+          width, height = screen_size
+          rows, cursor_row, cursor_col = composer_layout(width, height)
+          ensure_scroll_region_locked(rows.length, width: width, height: height)
+          @rendered_rows = rows.length
+          render_composer_rows_locked(rows, height: height)
+          @cursor_rendered_row = cursor_row
+          @last_width = width
+          @last_height = height
+          move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
+          render_cursor_visibility_locked
+        end
         @output_io.flush
       end
 

data/lib/kward/prompt_interface/screen.rb

@@ -75,10 +75,12 @@ module Kward
         return if @reserved_rows == new_reserved_rows && @last_height == height
 
         old_reserved_rows = @reserved_rows
-        rows_to_clear = [old_reserved_rows, new_reserved_rows].max
+        old_top = [height - old_reserved_rows + 1, 1].max
         @reserved_rows = new_reserved_rows
+        new_top = composer_top_row(height)
         @output_io.print("\e[1;#{transcript_bottom_row(height)}r")
-        clear_composer_region_locked(rows_to_clear, height: height)
+        clear_screen_rows_locked(old_top, new_top - 1) if new_top > old_top
+        @last_composer_rows = []
         redraw_transcript_locked(width: width, height: height) if redraw_transcript && new_reserved_rows < old_reserved_rows
       end
 
@@ -115,8 +117,11 @@ module Kward
           next if row == previous
 
           move_to_screen(top + index, 1)
-          @output_io.print(TTY::Cursor.clear_line)
-          @output_io.print(row) unless row.to_s.empty?
+          if row
+            @output_io.print(row)
+          else
+            @output_io.print(TTY::Cursor.clear_line)
+          end
         end
 
         rows.length.upto(rows.length + rows_to_clear - 1) do |index|

data/lib/kward/prompt_interface/selection_prompt.rb

@@ -78,7 +78,7 @@ module Kward
 
       def handle_select_escape_sequence
         sequence = read_pending_escape_sequence
-        return SELECT_CANCEL if sequence.empty?
+        return SELECT_CANCEL if sequence.empty? || sequence.start_with?("\e")
 
         key_name = @reader.console.keys["\e#{sequence}"]
         case key_name
@@ -134,14 +134,14 @@ module Kward
         matches = selection_matches
         return if matches.empty?
 
-        @select_state[:selection_index] = (selection_index - 1) % matches.length
+        @select_state[:selection_index] = previous_list_selection_index(selection_index, matches.length)
       end
 
       def select_next_choice
         matches = selection_matches
         return if matches.empty?
 
-        @select_state[:selection_index] = (selection_index + 1) % matches.length
+        @select_state[:selection_index] = next_list_selection_index(selection_index, matches.length)
       end
 
       def select_insert_key(key)
@@ -195,12 +195,10 @@ module Kward
       def finish_select_prompt
         @mutex.synchronize do
           @select_state = nil
-          clear_prompt_locked
           self.composer_input = ""
           self.composer_cursor = 0
-          @asking = false
-          @rendered_rows = 0
-          @cursor_rendered_row = 0
+          @asking = true
+          render_prompt_locked
           @output_io.flush
         end
       end
@@ -232,8 +230,8 @@ module Kward
       end
 
       def visible_selection_matches(matches, height: screen_height)
-        max_rows = [[height - 7, 1].max, 8].min
-        start = [[selection_index - max_rows + 1, 0].max, [matches.length - max_rows, 0].max].min
+        max_rows = max_overlay_list_rows(height)
+        start = centered_list_window_start(selection_index, matches.length, max_rows)
         { start: start, choices: matches[start, max_rows] || [] }
       end
 

data/lib/kward/prompt_interface/slash_overlay.rb

@@ -58,14 +58,14 @@ module Kward
         matches = slash_overlay_matches
         return if matches.empty?
 
-        @slash_selection_index = (@slash_selection_index - 1) % matches.length
+        @slash_selection_index = previous_list_selection_index(@slash_selection_index, matches.length)
       end
 
       def select_next_slash_command
         matches = slash_overlay_matches
         return if matches.empty?
 
-        @slash_selection_index = (@slash_selection_index + 1) % matches.length
+        @slash_selection_index = next_list_selection_index(@slash_selection_index, matches.length)
       end
 
       def complete_selected_slash_command
@@ -92,8 +92,8 @@ module Kward
       end
 
       def visible_slash_overlay_matches(matches, height: screen_height)
-        max_rows = [[height - 7, 1].max, 8].min
-        start = [[@slash_selection_index - max_rows + 1, 0].max, [matches.length - max_rows, 0].max].min
+        max_rows = max_overlay_list_rows(height)
+        start = centered_list_window_start(@slash_selection_index, matches.length, max_rows)
         { start: start, commands: matches[start, max_rows] || [] }
       end