kward 0.80.1 → 0.82.0

data/lib/kward/conversation.rb

@@ -63,13 +63,16 @@ module Kward
     attr_reader :tool_output_artifacts
     # @return [ContextBudgetMeter] runtime context savings for this conversation
     attr_reader :context_budget_meter
+    # @return [Array<String>, nil] explicitly permitted project skill paths
+    attr_reader :project_skill_paths
 
-    def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil, execution_profile_context: nil)
+    def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil, execution_profile_context: nil, project_skill_paths: nil)
       @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
       @provider = provider
       @model = model
       @reasoning_effort = reasoning_effort
       @plugin_registry = plugin_registry
+      @project_skill_paths = project_skill_paths
       @execution_profile_context = execution_profile_context.to_s.empty? ? nil : execution_profile_context.to_s.freeze
       @messages = []
       restored_system_message, transcript_messages = split_system_message(messages)
@@ -78,13 +81,13 @@ module Kward
           system_message = restored_system_message
         else
           @last_plugin_prompt_context = plugin_prompt_context
-          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context)
+          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths)
         end
       end
       @system_message = system_message
       @system_message_enabled = !@system_message.nil?
       if compaction_system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
-        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context) : nil
+        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths) : nil
       end
       @compaction_system_message = compaction_system_message
       @workspace_agents_mtime = workspace_agents_mtime
@@ -188,10 +191,10 @@ module Kward
       return nil unless @system_message_enabled
 
       @last_plugin_prompt_context = plugin_prompt_context
-      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context)
+      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths)
       @system_message = replacement
       @on_system_message_change&.call(replacement)
-      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context)
+      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context, project_skill_paths: @project_skill_paths)
       @workspace_agents_mtime = workspace_agents_mtime
       @system_prompt_sources_fingerprint = ConfigFiles.system_prompt_sources_fingerprint
       replacement

data/lib/kward/ekwsh.rb

@@ -13,7 +13,7 @@ module Kward
   class Ekwsh
     Result = Struct.new(:output, :exit_status, :exit_shell, :clear, :open_editor_path, :interactive_command, :streamed, keyword_init: true)
     Completion = Struct.new(:range, :replacement, :candidates, keyword_init: true)
-    BUILTINS = %w[alias cd pwd export unset unalias clear exit logout pty].freeze
+    BUILTINS = %w[alias capture cd pwd export unset unalias clear exit logout pty].freeze
     DEFAULT_SHELL = "/bin/sh"
     DEFAULT_TIMEOUT_SECONDS = 300
     DEFAULT_MAX_OUTPUT_BYTES = 1_048_576
@@ -72,6 +72,23 @@ module Kward
       Completion.new(range: token[:range], replacement: replacement, candidates: candidates)
     end
 
+    def expand_alias(command, interactive: false)
+      words = shell_words(command)
+      return command if words.empty? || BUILTINS.include?(words.first)
+      return command unless @aliases[words.first]
+
+      rest = command.sub(/\A\s*#{Regexp.escape(words.first)}\b\s*/, "")
+      expanded = [@aliases.fetch(words.first), rest].reject(&:empty?).join(" ")
+      interactive ? expanded.sub(/\A\s*(?:capture|pty)(?:\s+|\z)/, "") : expanded
+    rescue ArgumentError
+      command
+    end
+
+    def editor_command_result(command, display_command: command)
+      expanded_command = expand_alias(command, interactive: true)
+      kward_command_result(expanded_command, display_command: display_command)
+    end
+
     private
 
     def configure_rbenv_environment
@@ -276,7 +293,7 @@ module Kward
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
     end
 
-    def builtin_result(command, display_command: command)
+    def builtin_result(command, display_command: command, cancellation: nil, &block)
       words = shell_words(command)
       return nil if words.empty?
       assignment_result = persist_assignments(display_command, words)
@@ -297,6 +314,8 @@ module Kward
         unset_variables(display_command, words)
       when "clear"
         Result.new(output: "", exit_status: 0, clear: true)
+      when "capture"
+        captured_command_result(command, display_command: display_command, cancellation: cancellation, &block)
       when "pty"
         interactive_pty_result(command, display_command: display_command)
       else
@@ -306,13 +325,26 @@ module Kward
       Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
     end
 
+    def captured_command_result(command, display_command:, cancellation: nil, &block)
+      captured_command = command.sub(/\A\s*capture(?:\s+|\z)/, "")
+      if captured_command.empty?
+        return Result.new(output: "#{command_echo(display_command)}Usage: capture <command>\n", exit_status: 2)
+      end
+
+      execute(captured_command, display_command: display_command, cancellation: cancellation, &block)
+    end
+
     def interactive_pty_result(command, display_command: command)
       interactive_command = command.sub(/\A\s*pty(?:\s+|\z)/, "")
       if interactive_command.empty?
         return Result.new(output: "#{command_echo(display_command)}Usage: pty <command>\n", exit_status: 2)
       end
 
-      Result.new(output: "#{command_echo(display_command)}[interactive PTY session started]\n", exit_status: 0, interactive_command: interactive_command)
+      interactive_command_result(interactive_command, display_command: display_command)
+    end
+
+    def interactive_command_result(command, display_command: command)
+      Result.new(output: command_echo(display_command), exit_status: 0, interactive_command: command)
     end
 
     def shell_words(command)
@@ -361,29 +393,18 @@ module Kward
       name.to_s.match?(/\A[A-Za-z_][A-Za-z0-9_-]*\z/) && !BUILTINS.include?(name.to_s)
     end
 
-    def expand_alias(command)
-      words = shell_words(command)
-      return command if words.empty? || BUILTINS.include?(words.first)
-      return command unless @aliases[words.first]
-
-      rest = command.sub(/\A\s*#{Regexp.escape(words.first)}\b\s*/, "")
-      [@aliases.fetch(words.first), rest].reject(&:empty?).join(" ")
-    rescue ArgumentError
-      command
-    end
-
     def run_expanded_command(command, cancellation: nil, &block)
       expanded_command = expand_alias(command)
       exit_result = exit_result(expanded_command, display_command: command)
       return exit_result if exit_result
 
-      builtin_result = builtin_result(expanded_command, display_command: command)
+      builtin_result = builtin_result(expanded_command, display_command: command, cancellation: cancellation, &block)
       return builtin_result if builtin_result
 
       kward_result = kward_command_result(expanded_command, display_command: command)
       return kward_result if kward_result
 
-      execute(expanded_command, display_command: command, cancellation: cancellation, &block)
+      interactive_command_result(expanded_command, display_command: command)
     end
 
     def kward_command_result(command, display_command: command)

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,14 +2,15 @@ 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
-    Result = Struct.new(:exit_status, keyword_init: true)
+    Result = Struct.new(:exit_status, :input_forwarded, keyword_init: true)
 
     READ_SIZE = 4096
 
@@ -18,34 +19,29 @@ module Kward
       @window_size = nil
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, output: $stdout)
+    def run(*command, env: {}, cwd: Dir.pwd, input: $stdin, sink:)
       pid = nil
       status = nil
+      writer = nil
+      input_forwarded = false
 
-      PTY.spawn(env.to_h, *command, chdir: cwd.to_s) do |reader, writer, child_pid|
+      PTY.spawn(env.to_h, *command, chdir: cwd.to_s) do |reader, child_writer, child_pid|
         pid = child_pid
+        writer = child_writer
         update_window_size(reader, pid)
         with_raw_input(input) do
-          drain_initial_input(input, writer)
-          loop do
-            update_window_size(reader, pid)
-            readable = IO.select([reader, input], nil, nil, 0.02)&.first || []
-            forward_pty_output(reader, output) if readable.include?(reader)
-            forward_input(input, writer) if readable.include?(input)
-            if (finished_status = finished_status(pid))
-              status = finished_status
-              break
-            end
-          rescue Errno::EIO, IOError
-            break
-          end
+          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)
-      ensure
-        writer&.close unless writer&.closed?
       end
 
-      Result.new(exit_status: exit_status(status))
+      Result.new(exit_status: exit_status(status), input_forwarded: input_forwarded)
+    ensure
+      writer&.close unless writer&.closed?
+      terminate_and_reap(pid) if pid && status.nil?
     end
 
     private
@@ -53,39 +49,93 @@ module Kward
     def with_raw_input(input)
       return yield unless input.respond_to?(:raw)
 
-      input.raw { yield }
+      yielded = false
+      input.raw do
+        yielded = true
+        yield
+      end
     rescue Errno::ENOTTY
+      raise if yielded
+
       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_pty_output(reader, output)
+    def forward_io(reader, writer, pid, input, sink)
+      input_open = true
+      input_forwarded = false
+      loop do
+        update_window_size(reader, pid)
+        readers = [reader]
+        readers << input if input_open
+        readable = IO.select(readers, nil, nil, 0.02)&.first || []
+        forward_pty_output(reader, sink) if readable.include?(reader)
+        if input_open && readable.include?(input)
+          input_open, forwarded = forward_input(input, writer, sink)
+          input_forwarded ||= forwarded
+        end
+
+        status = finished_status(pid)
+        next unless status
+
+        return [finish_stopped_process(pid), input_forwarded] if status.stopped?
+
+        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, 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)
+      sink.write(chunk)
+      sink.flush if sink.respond_to?(:flush)
+    end
+
+    def drain_pty_output(reader, sink)
+      loop do
+        readable, = IO.select([reader], nil, nil, 0.02)
+        break unless readable
+
+        chunk = reader.read_nonblock(READ_SIZE, exception: false)
+        break if chunk.nil? || chunk == :wait_readable
+
+        sink.write(chunk)
+      end
+      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 if chunk.nil? || chunk == :wait_readable
+      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]
     rescue Errno::EIO, Errno::EPIPE, IOError
-      nil
+      [false, false]
     end
 
     def update_window_size(reader, pid)
@@ -111,12 +161,18 @@ module Kward
     def finished_status(pid)
       return unless pid
 
-      finished_pid, status = Process.wait2(pid, Process::WNOHANG)
+      finished_pid, status = Process.wait2(pid, Process::WNOHANG | Process::WUNTRACED)
       status if finished_pid
     rescue Errno::ECHILD
       nil
     end
 
+    def finish_stopped_process(pid)
+      signal_process("CONT", -pid) || signal_process("CONT", pid)
+      terminate_process_group(pid)
+      wait_for_status(pid)
+    end
+
     def wait_for_status(pid)
       return unless pid
 
@@ -134,6 +190,22 @@ module Kward
       1
     end
 
+    def terminate_and_reap(pid)
+      terminate_process_group(pid)
+      wait_for_status(pid)
+    end
+
+    def terminate_process_group(pid)
+      signal_process("TERM", -pid) || signal_process("TERM", pid)
+      deadline = Time.now + 0.2
+      while Time.now < deadline
+        return unless process_running?(pid)
+
+        sleep 0.02
+      end
+      signal_process("KILL", -pid) || signal_process("KILL", pid)
+    end
+
     def process_running?(pid)
       Process.kill(0, pid)
       true

data/lib/kward/prompt_interface/composer_controller.rb

@@ -256,11 +256,23 @@ module Kward
       def submit_input
         value = submitted_input
         add_history(composer_input)
-        clear_finished_input_locked(reset_history: true)
-        @output_io.flush
+        if !@busy && value.strip.empty?
+          flush_output_locked
+          return value
+        end
+
+        clear_submitted_input_locked
+        flush_output_locked
         value
       end
 
+      def clear_submitted_input_locked
+        self.composer_input = ""
+        self.composer_cursor = 0
+        @composer.clear_attachments
+        reset_history_search
+      end
+
       def clear_finished_input_locked(reset_history: false)
         if @busy
           clear_prompt_for_output_locked
@@ -294,7 +306,7 @@ module Kward
 
       def exit_input
         clear_finished_input_locked
-        @output_io.flush
+        flush_output_locked
         EXIT_INPUT
       end
 

data/lib/kward/prompt_interface/composer_renderer.rb

@@ -265,6 +265,33 @@ module Kward
         @composer.cursor_logical_position
       end
 
+      def image_viewer_preview_rows(height, width: screen_width)
+        available_rows = max_project_browser_rows(height, width: width)
+        desired_rows = [(IMAGE_VIEWER_MAX_ROWS * image_viewer_zoom).round, 1].max
+        [available_rows, desired_rows].min
+      end
+
+      def image_viewer_rows(width, height: screen_height)
+        content_width = [width - 4, 1].max
+        preview_rows = image_viewer_preview_rows(height, width: width)
+        title = visible_truncate(" Image: #{@image_viewer_state[:display_path]} ", content_width)
+        rows = [
+          colored("╭", :primary_green) + title + colored("─" * [width - ANSI.strip(title).length - 2, 0].max, :primary_green) + colored("╮", :primary_green),
+          image_viewer_graphic_row(width, image_viewer_sequence(width, height))
+        ]
+        rows.concat(Array.new(preview_rows - 1) { box_content_row("", content_width) })
+        zoom = (image_viewer_zoom * 100).round
+        rows << footer_row(content_width, "Read-only image preview · #{zoom}% · +/- zoom · Esc/Q close")
+        rows << bottom_border(width)
+        rows
+      end
+
+      def image_viewer_graphic_row(width, sequence)
+        left_border = "#{colored("│", :primary_green)} "
+        right_border = "#{TerminalSequences.move_to_column(width)}#{colored("│", :primary_green)}"
+        "#{TTY::Cursor.clear_line}#{left_border}#{sequence}#{right_border}"
+      end
+
     end
   end
 end

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

@@ -827,6 +827,10 @@ module Kward
         modifier = sequence[:modifier]
         queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
 
+        if ctrl_modifier?(modifier) && ctrl_code(code) == 113
+          return close_editor
+        end
+
         if ctrl_modifier?(modifier) && ctrl_code(code) == 102
           return editor_search_active? ? editor_search_append(key) : editor_search_begin
         end
@@ -988,8 +992,8 @@ module Kward
         return false if text.empty?
 
         @editor_state.push_kill(text)
-        @output_io.print(TerminalSequences.osc52(text))
-        @output_io.flush if @output_io.respond_to?(:flush)
+        print_output_locked(TerminalSequences.osc52(text))
+        flush_output_locked if @output_io.respond_to?(:flush)
         @editor_state.clear_selection
         @editor_state.status = "Copied selection"
         true
@@ -1099,16 +1103,16 @@ module Kward
       def enable_editor_mouse_reporting
         return if @editor_mouse_reporting_enabled
 
-        @output_io.print(TerminalSequences::MOUSE_REPORTING_ENABLE)
-        @output_io.flush if @output_io.respond_to?(:flush)
+        print_output_locked(TerminalSequences::MOUSE_REPORTING_ENABLE)
+        flush_output_locked if @output_io.respond_to?(:flush)
         @editor_mouse_reporting_enabled = true
       end
 
       def disable_editor_mouse_reporting(force: false)
         return unless force || @editor_mouse_reporting_enabled
 
-        @output_io.print(TerminalSequences::MOUSE_REPORTING_DISABLE)
-        @output_io.flush if @output_io.respond_to?(:flush)
+        print_output_locked(TerminalSequences::MOUSE_REPORTING_DISABLE)
+        flush_output_locked if @output_io.respond_to?(:flush)
         @editor_mouse_reporting_enabled = false
       end
 

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

@@ -240,8 +240,8 @@ module Kward
         end
 
         @editor_state.copy_for_kill_ring(range[0], range[1])
-        @output_io.print(TerminalSequences.osc52(@editor_state.kill_buffer))
-        @output_io.flush if @output_io.respond_to?(:flush)
+        print_output_locked(TerminalSequences.osc52(@editor_state.kill_buffer))
+        flush_output_locked if @output_io.respond_to?(:flush)
         @editor_state.clear_selection
         @editor_state.status = "Copied region"
         true

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

@@ -2239,8 +2239,8 @@ module Kward
       def vibe_copy_range(start_index, end_index, status, linewise: false)
         @editor_state.copy_range(start_index, end_index)
         @editor_state.vibe_kill_linewise = linewise
-        @output_io.print(TerminalSequences.osc52(@editor_state.kill_buffer))
-        @output_io.flush if @output_io.respond_to?(:flush)
+        print_output_locked(TerminalSequences.osc52(@editor_state.kill_buffer))
+        flush_output_locked if @output_io.respond_to?(:flush)
         @editor_state.status = status
       end
 

data/lib/kward/prompt_interface/git_prompt.rb

@@ -262,7 +262,7 @@ module Kward
           self.composer_cursor = 0
           @asking = true
           render_prompt_locked
-          @output_io.flush
+          flush_output_locked
         end
       end