kward 0.83.0 → 0.84.0

data/lib/kward/prompt_interface/editor/modes/vibe.rb

@@ -17,6 +17,9 @@ module Kward
       VIBE_RUBY_BLOCK_OPENERS = %w[if unless case while until for def module class do begin].freeze
       VIBE_RUBY_PATHS = %w[Gemfile Rakefile Guardfile Capfile Vagrantfile].freeze
       VIBE_RUBY_EXTENSIONS = %w[.rb .rake .gemspec].freeze
+      VIBE_VISUAL_LINE_MOVE_CONTROLS = {
+        TerminalKeys::CTRL_H => "h", TerminalKeys::CTRL_J => "j", TerminalKeys::CTRL_K => "k", TerminalKeys::CTRL_L => "l"
+      }.freeze
 
       VibeOperatorTarget = Struct.new(:type, :start_index, :end_index, :replacement_text, :replacement_cursor_offset, keyword_init: true) do
         def characterwise?
@@ -38,6 +41,9 @@ module Kward
         csi_result = handle_vibe_csi_u_key(key)
         return csi_result unless csi_result == false
 
+        multi_cursor_result = handle_vibe_multi_cursor_key(key)
+        return multi_cursor_result unless multi_cursor_result == false
+
         return handle_vibe_command_key(key) if @editor_state.vibe_mode == "command"
 
         tab_result = handle_tab_key_binding(key)
@@ -84,6 +90,7 @@ module Kward
 
         @editor_state.vibe_command = ""
         @editor_state.vibe_pending = ""
+        @editor_state.vibe_command_range = nil
         @editor_state.clear_selection
         vibe_return_to_normal
       end
@@ -123,6 +130,35 @@ module Kward
         nil
       end
 
+      def handle_vibe_multi_cursor_key(key)
+        return false unless key == TerminalKeys::CTRL_D
+        return false if editor_search_active?
+
+        visual_selection = @editor_state.vibe_mode == "visual"
+        return false unless visual_selection || %w[normal insert replace].include?(@editor_state.vibe_mode)
+
+        original_selection = vibe_prepare_visual_selection_for_multi_cursor if visual_selection
+        added = @editor_state.add_next_occurrence_selection
+        if added
+          vibe_enter_insert_mode(TerminalKeys::CTRL_D) unless @editor_state.vibe_mode == "insert"
+        elsif original_selection
+          @editor_state.vibe_mode = "visual"
+          @editor_state.set_selections([original_selection])
+        end
+        true
+      end
+
+      def vibe_prepare_visual_selection_for_multi_cursor
+        range = @editor_state.selection_range
+        return unless range
+
+        original_selection = { anchor: @editor_state.selection_anchor, cursor: @editor_state.cursor }
+        vibe_remember_visual_selection
+        @editor_state.vibe_mode = "normal"
+        @editor_state.set_selections([{ anchor: range[0], cursor: range[1] }])
+        original_selection
+      end
+
       def handle_vibe_search_key(key)
         case key
         when "\n", "\r"
@@ -159,7 +195,7 @@ module Kward
           named_result = handle_vibe_insert_named_key(key_name) if key_name
           return named_result unless named_result == false || named_result.nil?
 
-          vibe_record_undo { editor_insert_printable(key) } if printable_key?(key)
+          vibe_record_undo { vibe_insert_printable(key) } if printable_key?(key)
         end
       end
 
@@ -186,9 +222,15 @@ module Kward
         end
       end
 
+      def vibe_insert_printable(text)
+        return editor_insert_printable(text) unless @editor_state.multi_cursor?
+
+        @editor_state.replace_selections(text)
+      end
+
       def vibe_replace_character(key)
         @editor_state.delete_at_cursor
-        editor_insert_printable(key)
+        vibe_insert_printable(key)
       end
 
       def handle_vibe_command_key(key)
@@ -196,6 +238,7 @@ module Kward
         case key
         when "\e", TerminalKeys::CTRL_C, :escape
           @editor_state.vibe_command = ""
+          @editor_state.vibe_command_range = nil
           vibe_return_to_normal
         when "\b", "\x7F"
           @editor_state.vibe_command = @editor_state.vibe_command[0...-1].to_s
@@ -215,6 +258,10 @@ module Kward
 
       def execute_vibe_command(command)
         command = command.to_s.strip
+        command_range = @editor_state.vibe_command_range
+        command_range ||= vibe_visual_line_bounds if vibe_visual_mode?
+        command_range, command = vibe_extract_command_range(command, command_range)
+        @editor_state.vibe_command_range = nil
         @editor_state.vibe_mode = "normal"
         @editor_state.vibe_command = ""
         action = nil
@@ -225,8 +272,15 @@ module Kward
           save_editor(Regexp.last_match(1))
         when /\Ae(!?)\s+(.+)\z/
           vibe_edit_file(Regexp.last_match(2), force: Regexp.last_match(1) == "!")
+        when "run all"
+          run_vibe_all_markdown_code_blocks
         when "run"
-          vibe_record_undo { run_editor_buffer }
+          block = vibe_markdown_code_block_for_run(command_range)
+          if block
+            run_vibe_markdown_code_block(block)
+          else
+            vibe_record_undo { run_editor_buffer(source: vibe_command_source(command_range)) }
+          end
         when /\Aprompt\s+(.+)\z/
           action = editor_prompt_action(Regexp.last_match(1))
         when "prompt"
@@ -243,7 +297,7 @@ module Kward
           save_editor if @editor_state&.dirty?
           close_editor if @editor_state
         when /\A(?:(%|\d+,\d+))?s\/([^\/]*)\/([^\/]*)\/(g?)\z/
-          vibe_substitute_command(Regexp.last_match(1), Regexp.last_match(2), Regexp.last_match(3), global: Regexp.last_match(4) == "g")
+          vibe_substitute_command(command_range || Regexp.last_match(1), Regexp.last_match(2), Regexp.last_match(3), global: Regexp.last_match(4) == "g")
         when /\A\d+\z/
           @editor_state.set_cursor_line_and_column(command.to_i - 1, 0)
           @editor_state.status = "Line #{command}"
@@ -253,6 +307,134 @@ module Kward
         action || true
       end
 
+      def vibe_extract_command_range(command, visual_range)
+        if command.start_with?("'<,'>")
+          [visual_range, command[5..].to_s.strip]
+        elsif (match = command.match(/\A(%|\d+,\d+)(?=[a-z])/))
+          [match[1], command[match[1].length..].to_s]
+        else
+          [visual_range, command]
+        end
+      end
+
+      def vibe_command_source(range)
+        return @editor_state.buffer.dup unless range
+
+        first_line, last_line = vibe_command_line_bounds(range)
+        start_index = @editor_state.line_range(first_line)[0]
+        end_index = @editor_state.line_range(last_line)[1]
+        @editor_state.buffer[start_index...end_index].to_s
+      end
+
+      def vibe_command_line_bounds(range)
+        return range if range.is_a?(Array)
+        return [0, @editor_state.lines.length - 1] if range.to_s == "%"
+
+        first_line, last_line = range.to_s.split(",", 2).map { |value| value.to_i - 1 }
+        [first_line, last_line]
+      end
+
+      def vibe_markdown_code_block_for_run(command_range)
+        if command_range.is_a?(Array)
+          MarkdownCodeBlock.for_selection(@editor_state.buffer, *command_range)
+        else
+          line, = @editor_state.cursor_line_and_column
+          MarkdownCodeBlock.for_cursor(@editor_state.buffer, line)
+        end
+      end
+
+      def run_vibe_markdown_code_block(block)
+        document = block.source.dup
+        language = normalize_vibe_code_block_language(block.language)
+        unless language
+          @editor_state.status = "Selected code block has no runnable language"
+          return false
+        end
+
+        start_vibe_markdown_code_block_run(block, language) do |result, error|
+          if @editor_state.buffer != document
+            @editor_state.status = "Output not inserted: buffer changed"
+            next
+          end
+
+          output = error ? "Run failed: #{error.message}" : result.output
+          @editor_state.replace_buffer(block.with_output(output))
+          @editor_state.status = error ? "Output updated · Run failed" : vibe_code_block_result_status(result)
+        end
+      end
+
+      def run_vibe_all_markdown_code_blocks
+        document = @editor_state.buffer.dup
+        runs = MarkdownCodeBlock.parse(document).filter_map do |block|
+          language = normalize_vibe_code_block_language(block.language)
+          [block, language] if language
+        end
+        if runs.empty?
+          @editor_state.status = "No runnable code blocks"
+          return false
+        end
+
+        results = []
+        run_next = nil
+        run_next = lambda do
+          block, language = runs.shift
+          start_vibe_markdown_code_block_run(block, language) do |result, error|
+            output = error ? "Run failed: #{error.message}" : result.output
+            results << [block, output, result, error]
+            if runs.empty?
+              finish_vibe_all_markdown_code_blocks(document, results)
+            else
+              run_next.call
+            end
+          end
+        end
+        run_next.call
+      end
+
+      def start_vibe_markdown_code_block_run(block, language, &completion)
+        run_editor_buffer(
+          source: block.code,
+          language: language,
+          source_path: ScratchpadLanguages.display_path(language),
+          output_visible: false,
+          completion: completion
+        )
+      end
+
+      def finish_vibe_all_markdown_code_blocks(document, results)
+        if @editor_state.buffer != document
+          @editor_state.status = "Output not inserted: buffer changed"
+          return false
+        end
+
+        content = document.dup
+        results.reverse_each do |block, output, _result, _error|
+          start_index, end_index, replacement = block.output_edit(output)
+          content[start_index...end_index] = replacement
+        end
+        @editor_state.replace_buffer(content)
+        failures = results.count { |_block, _output, result, error| error || result.exit_status != 0 }
+        status = "Ran #{results.length} code blocks"
+        status += " · #{failures} failed" if failures.positive?
+        @editor_state.status = status
+        true
+      end
+
+      def vibe_code_block_result_status(result)
+        return "Output updated · Canceled" if result.cancelled
+
+        "Output updated · Exit #{result.exit_status} · #{format_runner_duration(result.duration)}"
+      end
+
+      def normalize_vibe_code_block_language(language)
+        return nil if language.to_s.strip.empty?
+
+        normalized = ScratchpadLanguages.normalize(language)
+        ScratchpadLanguages.runnable?(normalized) ? normalized : nil
+      rescue ArgumentError
+        nil
+      end
+
       def vibe_edit_file(path, force: false)
         if @editor_state.dirty? && !force
           @editor_state.status = "No write since last change (:e! overrides)"
@@ -264,6 +446,8 @@ module Kward
 
       def vibe_complete_command_path
         command = @editor_state.vibe_command.to_s
+        range_prefix = command.start_with?("'<,'>") ? command[0, 5] : ""
+        command = command[5..].to_s if range_prefix != ""
         match = command.match(/\A(e!?)\s+(.*)\z/)
         return false unless match
 
@@ -276,7 +460,7 @@ module Kward
 
         replacement = candidates.length == 1 ? candidates.first : vibe_common_prefix(candidates)
         if replacement.length > prefix.length
-          @editor_state.vibe_command = "#{match[1]} #{replacement}"
+          @editor_state.vibe_command = "#{range_prefix}#{match[1]} #{replacement}"
           @editor_state.status = ":#{@editor_state.vibe_command}"
         elsif candidates.length > 1
           @editor_state.status = vibe_path_completion_status(candidates)
@@ -336,7 +520,9 @@ module Kward
 
         start_line = 0
         end_line = @editor_state.lines.length - 1
-        if range&.include?(",")
+        if range.is_a?(Array)
+          start_line, end_line = range
+        elsif range&.include?(",")
           start_line, end_line = range.split(",", 2).map { |value| value.to_i - 1 }
         end
         start_line = [[start_line, 0].max, @editor_state.lines.length - 1].min
@@ -406,8 +592,6 @@ module Kward
           @editor_state.page_up(editor_page_rows)
         when :ctrl_f
           @editor_state.page_down(editor_page_rows)
-        when :ctrl_d
-          @editor_state.page_down(vibe_half_page_rows)
         when :ctrl_u
           @editor_state.page_up(vibe_half_page_rows)
         when :ctrl_e
@@ -422,7 +606,7 @@ module Kward
       end
 
       def vibe_normal_control_key?(key)
-        ["\n", "\r", "\b", "\x7F", TerminalKeys::CTRL_B, TerminalKeys::CTRL_D, TerminalKeys::CTRL_E, TerminalKeys::CTRL_F, "\x0F", TerminalKeys::CTRL_R, TerminalKeys::CTRL_U, TerminalKeys::CTRL_Y].include?(key)
+        ["\n", "\r", "\b", "\x7F", TerminalKeys::CTRL_B, TerminalKeys::CTRL_E, TerminalKeys::CTRL_F, "\x0F", TerminalKeys::CTRL_R, TerminalKeys::CTRL_U, TerminalKeys::CTRL_Y].include?(key)
       end
 
       def vibe_visual_mode?
@@ -430,7 +614,7 @@ module Kward
       end
 
       def vibe_return_to_normal
-        vibe_apply_visual_block_insert if @editor_state.vibe_visual_block_insert
+        @editor_state.collapse_to_primary_selection if @editor_state.multi_cursor?
         @editor_state.vibe_mode = "normal"
         @editor_state.status = "NORMAL · i insert · :prompt ask agent · :w save · :q quit"
         true
@@ -551,8 +735,6 @@ module Kward
           @editor_state.page_down(editor_page_rows)
         when TerminalKeys::CTRL_B
           @editor_state.page_up(editor_page_rows)
-        when TerminalKeys::CTRL_D
-          @editor_state.page_down(vibe_half_page_rows)
         when TerminalKeys::CTRL_U
           @editor_state.page_up(vibe_half_page_rows)
         when TerminalKeys::CTRL_E
@@ -653,6 +835,7 @@ module Kward
         when "u"
           @editor_state.undo
         when ":"
+          @editor_state.vibe_command_range = nil
           @editor_state.vibe_mode = "command"
           @editor_state.vibe_command = ""
           @editor_state.status = ":"
@@ -674,6 +857,13 @@ module Kward
       end
 
       def handle_vibe_visual_key(key)
+        if (direction = VIBE_VISUAL_LINE_MOVE_CONTROLS[key])
+          count, = vibe_count_and_body(@editor_state.vibe_pending.to_s + direction)
+          count = 1 if count.zero?
+          @editor_state.vibe_pending = ""
+          return vibe_move_selected_lines(direction, count)
+        end
+
         key_name = key_name_for(key)
         return handle_vibe_visual_named_key(key_name) if key_name
         if key == "\e" || key == TerminalKeys::CTRL_C
@@ -708,9 +898,9 @@ module Kward
         when "p"
           vibe_paste_visual_selection
         when "I"
-          vibe_begin_visual_block_insert(:before)
+          vibe_begin_visual_multi_cursor_insert(:before)
         when "A"
-          vibe_begin_visual_block_insert(:after)
+          vibe_begin_visual_multi_cursor_insert(:after)
         when ">"
           vibe_indent_visual_selection(:right)
         when "<"
@@ -735,6 +925,8 @@ module Kward
           editor_search_repeat(vibe_opposite_search_direction)
         when "o"
           vibe_switch_visual_selection_end
+        when ":"
+          vibe_begin_visual_command
         when "G"
           vibe_visual_goto_line(command.match?(/\A\d+G\z/) ? count : nil)
         when "gg"
@@ -785,6 +977,14 @@ module Kward
         true
       end
 
+      def vibe_begin_visual_command
+        @editor_state.vibe_command_range = vibe_visual_line_bounds
+        @editor_state.vibe_mode = "command"
+        @editor_state.vibe_command = "'<,'>"
+        @editor_state.status = ":'<,'>"
+        true
+      end
+
       def vibe_jump_ruby_method(direction)
         unless vibe_ruby_file?
           @editor_state.status = "Ruby navigation requires Ruby file"
@@ -958,6 +1158,71 @@ module Kward
         vibe_apply_cursor_motion(motion, count)
       end
 
+      def vibe_move_selected_lines(direction, count)
+        @editor_state.status = case @editor_state.vibe_mode
+                               when "visual_line" then "VISUAL LINE"
+                               when "visual_block" then "VISUAL BLOCK"
+                               else "VISUAL"
+                               end
+        start_line, end_line = vibe_visual_line_bounds
+        original_lines = @editor_state.lines.dup
+        lines = original_lines.dup
+        endpoint_positions = [@editor_state.selection_anchor, @editor_state.cursor].map do |offset|
+          @editor_state.cursor_line_and_column_for(offset)
+        end
+        line_shift = 0
+
+        case direction
+        when "h", "l"
+          moved_lines = lines[start_line..end_line].map(&:dup)
+          count.times do
+            moved_lines = moved_lines.map do |line|
+              if direction == "l"
+                "  #{line}"
+              else
+                line.sub(/\A(?:  |\t| )/, "")
+              end
+            end
+          end
+          lines[start_line..end_line] = moved_lines
+        when "k"
+          line_shift = -[count, start_line].min
+          return true if line_shift.zero?
+
+          selected_lines = lines.slice!(start_line..end_line)
+          lines.insert(start_line + line_shift, *selected_lines)
+        when "j"
+          line_shift = [count, lines.length - end_line - 1].min
+          return true if line_shift.zero?
+
+          selected_lines = lines.slice!(start_line..end_line)
+          lines.insert(start_line + line_shift, *selected_lines)
+        end
+
+        return false if lines == @editor_state.lines
+
+        @editor_state.replace_buffer(lines.join("\n"))
+        selection_offsets = endpoint_positions.map do |line, column|
+          new_line = line + line_shift
+          new_column = if direction == "l"
+                         column + (lines[line].length - original_lines[line].length)
+                       elsif direction == "h"
+                         [column - (original_lines[line].length - lines[line].length), 0].max
+                       else
+                         column
+                       end
+          @editor_state.offset_for_line_and_column(new_line, new_column)
+        end
+        @editor_state.set_selections([{ anchor: selection_offsets[0], cursor: selection_offsets[1] }])
+        true
+      end
+
+      def vibe_visual_line_bounds
+        anchor_line, = @editor_state.cursor_line_and_column_for(@editor_state.selection_anchor)
+        cursor_line, = @editor_state.cursor_line_and_column
+        [anchor_line, cursor_line].minmax
+      end
+
       def vibe_visual_range
         @editor_state.selection_range
       end
@@ -1013,39 +1278,19 @@ module Kward
         vibe_cancel_visual_mode
       end
 
-      def vibe_begin_visual_block_insert(position)
-        return vibe_move_visual_selection(position == :before ? "I" : "A") unless @editor_state.vibe_mode == "visual_block"
-
-        anchor_line, anchor_column = @editor_state.cursor_line_and_column_for(@editor_state.selection_anchor)
-        cursor_line, cursor_column = @editor_state.cursor_line_and_column
-        start_line, end_line = [anchor_line, cursor_line].minmax
-        start_column, end_column = [anchor_column, cursor_column].minmax
-        column = position == :before ? start_column : end_column + 1
-        @editor_state.vibe_visual_block_insert = { start_line: start_line, end_line: end_line, column: column }
-        @editor_state.clear_selection
-        @editor_state.set_cursor_line_and_column(start_line, column)
-        @editor_state.vibe_visual_block_insert[:start_index] = @editor_state.cursor
-        @editor_state.vibe_mode = "insert"
-        @editor_state.status = "INSERT · Esc normal"
+      def vibe_begin_visual_multi_cursor_insert(position)
+        vibe_remember_visual_selection
+        start_line, end_line = vibe_visual_line_bounds
+        selections = (start_line..end_line).map do |line_index|
+          column = position == :before ? 0 : @editor_state.lines[line_index].to_s.length
+          offset = @editor_state.offset_for_line_and_column(line_index, column)
+          { anchor: offset, cursor: offset }
+        end
+        @editor_state.set_selections(selections)
+        vibe_enter_insert_mode(position == :before ? "I" : "A")
         true
       end
 
-      def vibe_apply_visual_block_insert
-        block = @editor_state.vibe_visual_block_insert
-        @editor_state.vibe_visual_block_insert = nil
-        return unless block
-
-        inserted_text = @editor_state.buffer[block[:start_index]...@editor_state.cursor].to_s
-        return if inserted_text.empty?
-
-        block[:end_line].downto(block[:start_line] + 1) do |line_index|
-          line_start = @editor_state.line_start_offset(line_index)
-          line_length = @editor_state.lines[line_index].to_s.length
-          @editor_state.cursor = line_start + [block[:column], line_length].min
-          @editor_state.insert(inserted_text)
-        end
-      end
-
       def vibe_transform_visual_selection(transform)
         range = vibe_visual_range
         return false unless range

data/lib/kward/prompt_interface/editor/renderer.rb

@@ -7,6 +7,8 @@ module Kward
       private
 
       def editor_layout(width, height = screen_height)
+        return editor_split_layout(width, height) if editor_runner_output_visible?
+
         content_width = [width - 4, 1].max
         visible_count = editor_visible_line_count(height: height, width: width)
         line_index, column = @editor_state.cursor_line_and_column
@@ -21,7 +23,107 @@ module Kward
         end
       end
 
-      def editor_unwrapped_layout(width, content_width, visible_count, line_index, column, text_width)
+      def editor_split_layout(width, height)
+        content_width = [width - 4, 1].max
+        source_count, output_count = editor_split_visible_counts(height: height, width: width)
+        line_index, column = @editor_state.cursor_line_and_column
+        gutter_width = editor_line_number_gutter_width
+        text_width = editor_text_width(content_width, gutter_width)
+        sync_editor_wrap_state(text_width)
+        source_rows, cursor_row, cursor_col = if current_editor_soft_wrap?
+                                                editor_wrapped_layout(width, content_width, source_count, line_index, column, text_width, include_bottom: false)
+                                              else
+                                                editor_unwrapped_layout(width, content_width, source_count, line_index, column, text_width, include_bottom: false)
+                                              end
+        rows = source_rows + editor_runner_output_rows(width, content_width, output_count)
+        rows.concat(editor_bottom_rows(width))
+        [rows, cursor_row, cursor_col]
+      end
+
+      def editor_split_visible_counts(height:, width:)
+        # Keep one row available above the composer, matching the normal editor layout.
+        available = height - editor_bottom_rows(width).length - 5
+        available = 2 if available < 2
+        source_count = (available + 1) / 2
+        [source_count, available - source_count]
+      end
+
+      def editor_runner_output_rows(width, content_width, visible_count, include_bottom: false)
+        lines = editor_runner_output_lines(content_width)
+        maximum_scroll = [lines.length - visible_count, 0].max
+        @editor_runner_state.set_scroll_row(@editor_runner_state.scroll_row, maximum: maximum_scroll)
+        visible_lines = lines[@editor_runner_state.scroll_row, visible_count] || []
+        visible_lines << "" while visible_lines.length < visible_count
+        rows = [editor_runner_output_top_border(width)]
+        rows.concat(visible_lines.each_with_index.map do |line, index|
+          line_index = @editor_runner_state.scroll_row + index
+          selection = editor_runner_selection_range_for(line_index, ANSI.strip(line).length)
+          line = editor_overlay_selection(line, [selection], force: true) if selection
+          box_content_row(line, content_width)
+        end)
+        rows << footer_row(content_width, editor_runner_output_status)
+        rows.concat(editor_bottom_rows(width)) if include_bottom
+        rows
+      end
+
+      def editor_runner_output_visible_count(height: screen_height, width: screen_width)
+        editor_split_visible_counts(height: height, width: width).last
+      end
+
+      def editor_runner_output_scroll_max
+        width = [screen_width - 4, 1].max
+        lines = editor_runner_output_lines(width)
+        [lines.length - editor_runner_output_visible_count, 0].max
+      end
+
+      def editor_runner_output_lines(width)
+        text = ANSI.sanitize_transcript(@editor_runner_state.output_text)
+        text = ANSI.strip(text) unless @color_enabled
+        text = text.chomp
+        return ["(no output)"] if text.empty?
+
+        text.split("\n", -1).flat_map do |line|
+          wrapped = ANSI.wrap_visible(line, width)
+          wrapped.empty? ? [""] : wrapped
+        end
+      end
+
+      def editor_runner_output_top_border(width)
+        title = visible_truncate("Output #{editor_display_path}", [width - 4, 1].max)
+        plain_title = ANSI.strip(title)
+        "#{colored("╭", :primary_green)} #{title} #{colored("─" * [width - plain_title.length - 4, 0].max, :primary_green)}#{colored("╮", :primary_green)}"
+      end
+
+      def editor_runner_output_status
+        state = @editor_runner_state
+        if state.running?
+          return "Canceling #{state.language} · please wait" if state.cancel_requested?
+
+          return "Running #{state.language} · Ctrl+C cancel · Esc close"
+        end
+
+        if (error = state.error)
+          return "Run failed: #{error.message} · Esc close"
+        end
+
+        result = state.result
+        status = if result.cancelled
+                   "Canceled"
+                 else
+                   "Exit #{result.exit_status}"
+                 end
+        status += " · #{format_runner_duration(result.duration)}"
+        status += " · output truncated" if result.truncated
+        status += " · source changed" if editor_runner_output_stale?
+        "#{status} · Ctrl+R rerun · Esc close"
+      end
+
+      def editor_runner_output_stale?
+        digest = Digest::SHA256.hexdigest(@editor_state.buffer.to_s)
+        digest != @editor_runner_state.source_digest
+      end
+
+      def editor_unwrapped_layout(width, content_width, visible_count, line_index, column, text_width, include_bottom: true)
         @editor_state.viewport_row = [[@editor_state.viewport_row, line_index - visible_count + 1].max, line_index].min
         @editor_state.viewport_row = [@editor_state.viewport_row, 0].max
         @editor_state.viewport_column = [[@editor_state.viewport_column.to_i, column - text_width + 1].max, column].min
@@ -43,13 +145,13 @@ module Kward
           box_content_row(row, content_width)
         end)
         rows << footer_row(content_width, editor_status_text)
-        rows.concat(editor_bottom_rows(width))
+        rows.concat(editor_bottom_rows(width)) if include_bottom
         cursor_row = 1 + line_index - @editor_state.viewport_row
         cursor_col = 2 + gutter_width + [[column - @editor_state.viewport_column, 0].max, text_width - 1].min
         [rows, cursor_row, cursor_col]
       end
 
-      def editor_wrapped_layout(width, content_width, visible_count, line_index, column, text_width)
+      def editor_wrapped_layout(width, content_width, visible_count, line_index, column, text_width, include_bottom: true)
         visual_rows = editor_visual_rows(text_width)
         cursor_visual_row = editor_visual_row_for(line_index, column, text_width)
         @editor_state.viewport_row = [[@editor_state.viewport_row, cursor_visual_row - visible_count + 1].max, cursor_visual_row].min
@@ -67,7 +169,7 @@ module Kward
           end
         end)
         rows << footer_row(content_width, editor_status_text)
-        rows.concat(editor_bottom_rows(width))
+        rows.concat(editor_bottom_rows(width)) if include_bottom
         line_start = editor_visual_row_start_column(line_index, column, text_width)
         cursor_row = 1 + cursor_visual_row - @editor_state.viewport_row
         cursor_col = 2 + editor_line_number_gutter_width + [[column - line_start, 0].max, text_width - 1].min
@@ -138,8 +240,8 @@ module Kward
         editor_overlay_selection(rendered, cursor_columns.map { |column| [column, column + 1] })
       end
 
-      def editor_overlay_selection(rendered, selection_ranges)
-        return rendered unless @color_enabled
+      def editor_overlay_selection(rendered, selection_ranges, force: false)
+        return rendered unless @color_enabled || force
 
         output = +""
         selected = false