kward 0.81.0 → 0.82.0

data/lib/kward/cli/runtime_helpers.rb

@@ -6,7 +6,6 @@ module Kward
     module RuntimeHelpers
       MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES = 1_048_576
       UNSAFE_TRANSCRIPT_CONTROL_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.freeze
-      FROZEN_COMPOSER_COMMANDS = /\Agit\s+(?:fetch|ls-remote|push|remote|status)(?:\s|\z)/.freeze
 
       private
 
@@ -101,6 +100,7 @@ module Kward
         shell = bang_shell(agent)
         editor_result = shell.editor_command_result(command)
         if editor_result
+          record_tab_transient_shell_output(editor_result.output, render: false)
           @prompt.say(editor_result.output) unless editor_result.output.to_s.empty?
           open_ekwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
           return true
@@ -235,65 +235,101 @@ module Kward
 
       def run_user_interactive_pty_command(command, shell:, env:, cwd:, intro: nil)
         intro_message = intro || "$ #{command}\n"
+        record_tab_transient_shell_output(intro_message, render: false)
         if @prompt.respond_to?(:write_transcript)
           @prompt.write_transcript(intro_message)
         elsif @prompt.respond_to?(:say)
           @prompt.say(intro_message)
         end
-        output = +"".b
-        output_truncated = false
-        handoff_options = {}
-        handoff_options[:preserve_composer] = true if frozen_composer_command?(command)
-        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd, **handoff_options) do |chunk|
-          remaining = MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES - output.bytesize
-          if chunk.bytesize > remaining
-            output << chunk.byteslice(0, remaining) if remaining.positive?
-            output_truncated = true
-          else
-            output << chunk
-          end
-        end
-        @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
-        transcript_output = terminal_transcript_output(output, result, truncated: output_truncated)
-        if transcript_output && @prompt.respond_to?(:record_transient_terminal_output)
-          @prompt.record_transient_terminal_output(transcript_output)
+        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd) do |sink, completed_result|
+          record_completed_pty_output(sink, completed_result)
         end
+        refresh_composer_status
         result
       rescue Errno::ENOENT => e
         runtime_output("Error: #{e.message}")
         nil
       end
 
-      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, preserve_composer: false, &block)
+      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
-        if @prompt.respond_to?(:with_terminal_handoff)
-          if preserve_composer
-            @prompt.with_terminal_handoff(preserve_composer: true) do |input, output|
-              runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output, &block)
-            end
-          else
-            @prompt.with_terminal_handoff do |input, output|
-              runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output, &block)
-            end
+        run_with_sink = lambda do |input, sink|
+          result = runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+          on_complete.call(sink, result) if on_complete
+          result
+        end
+
+        if @prompt.respond_to?(:with_inline_terminal_handoff)
+          @prompt.with_inline_terminal_handoff do |input, output, transition|
+            sink = AdaptivePtyOutputSink.new(
+              output: output,
+              on_exclusive: transition,
+              max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+            )
+            run_with_sink.call(input, sink)
+          end
+        elsif @prompt.respond_to?(:with_terminal_handoff)
+          @prompt.with_terminal_handoff do |input, output|
+            sink = PassthroughPtyOutputSink.new(
+              output: output,
+              max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+            )
+            run_with_sink.call(input, sink)
           end
         else
-          runner.run(shell, "-c", command, env: env, cwd: cwd, &block)
+          sink = PassthroughPtyOutputSink.new(
+            output: $stdout,
+            max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+          )
+          run_with_sink.call($stdin, sink)
         end
       end
 
-      def frozen_composer_command?(command)
-        FROZEN_COMPOSER_COMMANDS.match?(command.to_s.strip)
+      def record_completed_pty_output(sink, result)
+        classified_output = sink.respond_to?(:transcript_safe?)
+        return if classified_output && !sink.transcript_safe?
+
+        output = sink&.captured_output || +"".b
+        allow_input = classified_output &&
+          sink.respond_to?(:pre_input_capture_only?) &&
+          sink.pre_input_capture_only?
+        transcript_output = terminal_transcript_output(
+          output,
+          result,
+          truncated: sink&.truncated? || false,
+          allow_input: allow_input,
+          normalize_line_controls: classified_output
+        )
+        return unless transcript_output
+
+        record_tab_transient_shell_output(transcript_output, render: false)
+        if @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(transcript_output, render: false)
+        end
       end
 
-      def terminal_transcript_output(output, result, truncated:)
-        return if truncated || result.input_forwarded
+      def terminal_transcript_output(
+        output,
+        result,
+        truncated:,
+        allow_input: false,
+        normalize_line_controls: false
+      )
+        return if truncated || (result.input_forwarded && !allow_input)
 
         text = ANSI.normalize_transcript_encoding(output).gsub("\r\n", "\n")
-        return if text.empty? || text.include?("\r")
+        return if text.empty?
+
+        if normalize_line_controls
+          sanitized = PtyTranscriptNormalizer.normalize(text)
+        else
+          return if text.include?("\r")
 
-        sanitized = ANSI.sanitize_transcript(text)
-        return unless sanitized == text
-        return if ANSI.strip_control_sequences(text).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
+          sanitized = ANSI.sanitize_transcript(text)
+          return unless sanitized == text
+        end
+        return if sanitized.empty?
+        return if ANSI.strip_control_sequences(sanitized).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
 
         sanitized
       end
@@ -329,8 +365,13 @@ module Kward
           break if input.nil?
 
           result = run_ekwsh_command(shell, input)
-          @prompt.clear_transcript if result.clear && @prompt.respond_to?(:clear_transcript)
-          @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          if result.clear
+            clear_active_tab_transient_shell_output
+            @prompt.clear_transcript if @prompt.respond_to?(:clear_transcript)
+          else
+            record_tab_transient_shell_output(result.output, render: false) unless result.interactive_command
+            @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          end
           return :tab_action if pending_tab_action?
 
           if result.open_editor_path
@@ -443,6 +484,21 @@ module Kward
         result
       end
 
+      def record_tab_transient_shell_output(text, render: true)
+        value = text.to_s
+        return if value.empty?
+
+        tab = active_tab if respond_to?(:active_tab, true)
+        tab&.append_transient_shell_entry(value)
+        if render && @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(value)
+        end
+      end
+
+      def clear_active_tab_transient_shell_output
+        clear_active_tab_transient_shell_entries if respond_to?(:clear_active_tab_transient_shell_entries, true)
+      end
+
       def drain_ekwsh_chunks(chunks)
         loop do
           @prompt.write_transcript_delta(chunks.pop(true))
@@ -559,6 +615,14 @@ module Kward
         @client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT
       end
 
+      def refresh_composer_status
+        if @prompt.respond_to?(:refresh_composer_status)
+          @prompt.refresh_composer_status
+        elsif @prompt.respond_to?(:redraw)
+          @prompt.redraw
+        end
+      end
+
       def reload_client_config
         @client.reload_config if @client.respond_to?(:reload_config)
       end

data/lib/kward/cli/settings.rb

@@ -115,7 +115,7 @@ module Kward
         ConfigFiles.update_config("provider" => ModelInfo.config_provider_for_provider(provider))
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       def provider_choices
@@ -166,7 +166,7 @@ module Kward
         ConfigFiles.update_config("local_backend" => backend, "local_base_url" => url)
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       def configure_account_settings
@@ -920,7 +920,7 @@ module Kward
         ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5
@@ -953,18 +953,10 @@ module Kward
         queue_reasoning_config(effort, provider: provider, conversation: conversation) if queue_config
         if queue_config
           update_conversation_reasoning_effort(conversation, effort)
-          refresh_reasoning_status
+          refresh_composer_status
         else
           refresh_conversation_runtime(conversation, reasoning_effort: effort)
-          refresh_reasoning_status
-        end
-      end
-
-      def refresh_reasoning_status
-        if @prompt.respond_to?(:refresh_composer_status)
-          @prompt.refresh_composer_status
-        else
-          @prompt.redraw if @prompt.respond_to?(:redraw)
+          refresh_composer_status
         end
       end
 

data/lib/kward/cli/tabs.rb

@@ -35,10 +35,13 @@ module Kward
         :unread,
         :pending_question,
         :shell,
+        :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
         keyword_init: true
       ) do
+        TRANSIENT_SHELL_OUTPUT_LIMIT = 200_000
+
         def running?
           %w[queued running waiting_for_question].include?(status.to_s)
         end
@@ -54,6 +57,41 @@ module Kward
         def record_event(event)
           event_history << event
         end
+
+        def append_transient_shell_entry(text)
+          value = text.to_s
+          return if value.empty?
+
+          self.transient_shell_entries ||= []
+          transient_shell_entries << value
+          trim_transient_shell_entries
+        end
+
+        def clear_transient_shell_entries
+          self.transient_shell_entries = []
+        end
+
+        private
+
+        def trim_transient_shell_entries
+          combined = transient_shell_entries.join
+          return if combined.length <= TRANSIENT_SHELL_OUTPUT_LIMIT
+
+          target = (TRANSIENT_SHELL_OUTPUT_LIMIT * 0.9).floor
+          cutoff = combined.length - target
+          newline = combined.index("\n", cutoff)
+          cutoff = newline + 1 if newline
+          cutoff = transient_shell_escape_boundary(combined, cutoff)
+          self.transient_shell_entries = [combined[cutoff..].to_s]
+        end
+
+        def transient_shell_escape_boundary(text, cutoff)
+          escape_start = text.rindex("\e", cutoff)
+          return cutoff unless escape_start
+
+          escape = ANSI.escape_sequence_at(text, escape_start)
+          escape && escape_start + escape.length > cutoff ? escape_start + escape.length : cutoff
+        end
       end
 
       class TabQuestionPrompt
@@ -279,6 +317,7 @@ module Kward
           unread: false,
           pending_question: nil,
           shell: nil,
+          transient_shell_entries: [],
           error_reported: false,
           local_busy_activity: nil
         ).tap { |tab| assign_tab_question_prompt(agent, tab) }
@@ -424,6 +463,7 @@ module Kward
         tab.queued_inputs.clear
         tab.steering = nil
         tab.shell = nil
+        tab.clear_transient_shell_entries
         tab.stream_state = new_tab_stream_state(tab.driver)
         tab.markdown_chunks.clear
         update_prompt_workspace_root(current_workspace_root)
@@ -451,7 +491,7 @@ module Kward
         end
         return snapshot_method.call unless supports_transcript_option
 
-        snapshot_method.call(include_transcript: tab.running? || !tab.shell.nil?)
+        snapshot_method.call(include_transcript: tab.running?)
       end
 
       def activate_tab(index, render: true)
@@ -484,8 +524,8 @@ module Kward
         tab.agent
       end
 
-      def render_tab(tab)
-        if tab.snapshot && @prompt.respond_to?(:restore_tab_view_snapshot) && (tab.running? || tab.shell)
+      def render_tab(tab, restore_composer: true)
+        if restore_composer && tab.snapshot && @prompt.respond_to?(:restore_tab_view_snapshot) && tab.running?
           @prompt.restore_tab_view_snapshot(tab.snapshot)
           return
         end
@@ -497,8 +537,23 @@ module Kward
             render_transcript_messages(tab.driver.messages)
           end
           report_tab_runtime_error(tab) if %w[failed cancelled].include?(tab.status.to_s)
+          render_tab_transient_shell_entries(tab)
         end
-        restore_tab_composer_snapshot(tab.snapshot)
+        restore_tab_composer_snapshot(tab.snapshot) if restore_composer
+      end
+
+      def render_tab_transient_shell_entries(tab)
+        Array(tab.transient_shell_entries).each do |entry|
+          if @prompt.respond_to?(:say)
+            @prompt.say(entry)
+          elsif @prompt.respond_to?(:write_transcript)
+            @prompt.write_transcript(entry)
+          end
+        end
+      end
+
+      def clear_active_tab_transient_shell_entries
+        active_tab&.clear_transient_shell_entries
       end
 
       def restore_tab_composer_snapshot(snapshot)

data/lib/kward/cli.rb

@@ -16,6 +16,8 @@ require_relative "events"
 require_relative "export_path"
 require_relative "ekwsh"
 require_relative "interactive_pty_runner"
+require_relative "adaptive_pty_output_sink"
+require_relative "pty_transcript_normalizer"
 require_relative "auth/anthropic_oauth"
 require_relative "auth/api_key_store"
 require_relative "auth/github_oauth"

data/lib/kward/image_attachments.rb

@@ -1,8 +1,10 @@
 require "base64"
 require "cgi/escape"
+require "open3"
 require "shellwords"
 require "tmpdir"
 require "uri"
+require_relative "terminal_image_support"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -291,6 +293,71 @@ module Kward
       MIME_TYPES.key?(File.extname(path.to_s).downcase)
     end
 
+    def image_part_from_path(path)
+      expanded_path = File.expand_path(path.to_s)
+      return nil unless File.file?(expanded_path)
+
+      media_type = mime_type(expanded_path)
+      return nil unless media_type
+
+      size = File.size(expanded_path)
+      return nil if size > MAX_IMAGE_BYTES
+
+      {
+        type: "image",
+        media_type: media_type,
+        data: Base64.strict_encode64(File.binread(expanded_path)),
+        path: expanded_path,
+        size_bytes: size
+      }
+    rescue SystemCallError
+      nil
+    end
+
+    def terminal_image_part(part, protocol)
+      return part unless protocol == :kitty
+      return part if image_media_type(part) == "image/png"
+
+      convert_image_part_to_png(part)
+    end
+
+    def png_dimensions(part)
+      encoded = part[:data] || part["data"]
+      header = Base64.strict_decode64(encoded.to_s[0, 32])
+      return nil unless header.start_with?("\x89PNG\r\n\x1A\n".b)
+      return nil unless header.byteslice(12, 4) == "IHDR"
+
+      width, height = header.byteslice(16, 8).unpack("NN")
+      return nil unless width.positive? && height.positive?
+
+      [width, height]
+    rescue ArgumentError, NoMethodError
+      nil
+    end
+
+    def convert_image_part_to_png(part)
+      path = part[:path] || part["path"]
+      return nil unless path && File.file?(path)
+
+      stdout, _stderr, status = Open3.capture3(
+        "magick",
+        "-limit", "memory", "128MiB",
+        "-limit", "map", "256MiB",
+        "#{path}[0]",
+        "png:-"
+      )
+      return nil unless status.success?
+      return nil if stdout.empty? || stdout.bytesize > MAX_IMAGE_BYTES
+
+      part.merge(
+        media_type: "image/png",
+        data: Base64.strict_encode64(stdout),
+        size_bytes: stdout.bytesize
+      )
+    rescue SystemCallError
+      nil
+    end
+
     def mime_type(path)
       MIME_TYPES[File.extname(path.to_s).downcase]
     end
@@ -300,36 +367,52 @@ module Kward
       "data:#{media_type};base64,#{part[:data] || part["data"]}"
     end
 
-    def terminal_image_sequence(part, width: DEFAULT_TERMINAL_IMAGE_WIDTH, env: ENV)
+    def terminal_image_sequence(part, width: DEFAULT_TERMINAL_IMAGE_WIDTH, height: nil, protocol: nil, image_id: nil, move_cursor: true, env: ENV)
       data = part[:data] || part["data"]
       return nil if data.to_s.empty?
 
+      protocol ||= terminal_image_protocol(env)
       name = part[:path] || part["path"]
-      if iterm_image_protocol?(env)
-        iterm_image_sequence(data, name, width)
-      elsif kitty_image_protocol?(env)
-        kitty_image_sequence(data, name, width)
+      case protocol
+      when :iterm2
+        iterm_image_sequence(data, name, width, height, env: env)
+      when :kitty
+        return nil unless image_media_type(part) == "image/png"
+
+        kitty_image_sequence(data, name, width, height, image_id, move_cursor: move_cursor, env: env)
       end
     end
 
+    def terminal_image_protocol(env)
+      TerminalImageSupport.static_protocol(env)
+    end
+
     def iterm_image_protocol?(env)
-      env["TERM_PROGRAM"] == "iTerm.app"
+      TerminalImageSupport.iterm2_hint?(env)
     end
 
     def kitty_image_protocol?(env)
-      env["KITTY_WINDOW_ID"].to_s != "" || env["TERM"].to_s.include?("kitty") || env["TERM_PROGRAM"] == "WezTerm"
+      TerminalImageSupport.kitty_hint?(env)
+    end
+
+    def iterm_image_sequence(data, name, width, height = nil, env: ENV)
+      sequence = TerminalSequences.iterm2_image(data, name: name, width: width, height: height)
+      env["TMUX"].to_s.empty? ? sequence : TerminalSequences.tmux_passthrough(sequence)
     end
 
-    def iterm_image_sequence(data, name, width)
-      params = ["inline=1", "preserveAspectRatio=1", "width=#{width}"]
-      params << "name=#{Base64.strict_encode64(File.basename(name))}" if name
-      "\e]1337;File=#{params.join(";")}:#{data}\a"
+    def kitty_image_sequence(data, _name, width, height = nil, image_id = nil, move_cursor: true, env: ENV)
+      sequence = TerminalSequences.kitty_graphics(
+        data,
+        image_id: image_id,
+        columns: width,
+        rows: height,
+        move_cursor: move_cursor
+      )
+      env["TMUX"].to_s.empty? ? sequence : TerminalSequences.tmux_passthrough(sequence)
     end
 
-    def kitty_image_sequence(data, name, width)
-      params = ["inline=1", "preserveAspectRatio=1", "width=#{width}"]
-      params << "name=#{Base64.strict_encode64(File.basename(name))}" if name
-      "\e_G#{params.join(";")}:#{data}\e\\"
+    def image_media_type(part)
+      part[:media_type] || part["media_type"] || part[:mimeType] || part["mimeType"]
     end
   end
 end

data/lib/kward/interactive_pty_runner.rb

@@ -2,10 +2,11 @@ require "io/console"
 require "pty"
 require "timeout"
 require_relative "local_pty_command_runner"
+require_relative "pty_output_sink"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Runs a command in a PTY while forwarding caller-owned input and output IOs.
+  # Runs a command in a PTY while forwarding caller-owned input and output sink.
   # This is intentionally low level: UI orchestration decides when terminal
   # ownership is handed to the child process and how the result is presented.
   class InteractivePtyRunner
@@ -18,7 +19,7 @@ module Kward
       @window_size = nil
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, output: $stdout, &block)
+    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:)
       pid = nil
       status = nil
       writer = nil
@@ -29,9 +30,11 @@ module Kward
         writer = child_writer
         update_window_size(reader, pid)
         with_raw_input(input) do
-          drain_initial_input(input, writer)
-          status, input_forwarded = forward_io(reader, writer, pid, input, output, &block)
+          input_forwarded = drain_initial_input(input, writer, sink)
+          status, forwarded = forward_io(reader, writer, pid, input, sink)
+          input_forwarded ||= forwarded
         end
+        sink.finish if sink.respond_to?(:finish)
         status ||= wait_for_status(pid)
       end
 
@@ -57,19 +60,23 @@ module Kward
       yield
     end
 
-    def drain_initial_input(input, writer)
+    def drain_initial_input(input, writer, sink)
+      forwarded = false
       loop do
         chunk = input.read_nonblock(READ_SIZE, exception: false)
         break if chunk.nil? || chunk == :wait_readable
 
+        sink.input_forwarded if sink.respond_to?(:input_forwarded)
         writer.write(chunk)
+        forwarded = true
       end
       writer.flush
+      forwarded
     rescue Errno::EIO, Errno::EPIPE, IOError
-      nil
+      forwarded
     end
 
-    def forward_io(reader, writer, pid, input, output, &block)
+    def forward_io(reader, writer, pid, input, sink)
       input_open = true
       input_forwarded = false
       loop do
@@ -77,9 +84,9 @@ module Kward
         readers = [reader]
         readers << input if input_open
         readable = IO.select(readers, nil, nil, 0.02)&.first || []
-        forward_pty_output(reader, output, &block) if readable.include?(reader)
+        forward_pty_output(reader, sink) if readable.include?(reader)
         if input_open && readable.include?(input)
-          input_open, forwarded = forward_input(input, writer)
+          input_open, forwarded = forward_input(input, writer, sink)
           input_forwarded ||= forwarded
         end
 
@@ -88,23 +95,22 @@ module Kward
 
         return [finish_stopped_process(pid), input_forwarded] if status.stopped?
 
-        drain_pty_output(reader, output, &block)
+        drain_pty_output(reader, sink)
         return [status, input_forwarded]
       rescue Errno::EIO
         return [wait_for_status(pid), input_forwarded]
       end
     end
 
-    def forward_pty_output(reader, output)
+    def forward_pty_output(reader, sink)
       chunk = reader.read_nonblock(READ_SIZE, exception: false)
       return if chunk.nil? || chunk == :wait_readable
 
-      output.write(chunk)
-      output.flush if output.respond_to?(:flush)
-      yield chunk if block_given?
+      sink.write(chunk)
+      sink.flush if sink.respond_to?(:flush)
     end
 
-    def drain_pty_output(reader, output)
+    def drain_pty_output(reader, sink)
       loop do
         readable, = IO.select([reader], nil, nil, 0.02)
         break unless readable
@@ -112,19 +118,19 @@ module Kward
         chunk = reader.read_nonblock(READ_SIZE, exception: false)
         break if chunk.nil? || chunk == :wait_readable
 
-        output.write(chunk)
-        yield chunk if block_given?
+        sink.write(chunk)
       end
-      output.flush if output.respond_to?(:flush)
+      sink.flush if sink.respond_to?(:flush)
     rescue Errno::EIO
       nil
     end
 
-    def forward_input(input, writer)
+    def forward_input(input, writer, sink)
       chunk = input.read_nonblock(READ_SIZE, exception: false)
       return [false, false] if chunk.nil?
       return [true, false] if chunk == :wait_readable
 
+      sink.input_forwarded if sink.respond_to?(:input_forwarded)
       writer.write(chunk)
       writer.flush
       [true, true]

data/lib/kward/prompt_interface/composer_controller.rb

@@ -257,12 +257,12 @@ module Kward
         value = submitted_input
         add_history(composer_input)
         if !@busy && value.strip.empty?
-          @output_io.flush
+          flush_output_locked
           return value
         end
 
         clear_submitted_input_locked
-        @output_io.flush
+        flush_output_locked
         value
       end
 
@@ -306,7 +306,7 @@ module Kward
 
       def exit_input
         clear_finished_input_locked
-        @output_io.flush
+        flush_output_locked
         EXIT_INPUT
       end