kward 0.70.0 → 0.72.0

data/lib/kward/cli/interactive_turn.rb

@@ -7,6 +7,7 @@ module Kward
       private
 
       def run_interactive_turn(agent, input, display_input: nil)
+        stop_live_worker_view if respond_to?(:stop_live_worker_view, true)
         prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
         print_user_transcript(input, display_input: display_input) if prompt_interface?
         return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
@@ -42,7 +43,7 @@ module Kward
 
         while worker.alive?
           begin
-            poll_result = collect_busy_input(queued_inputs, steering)
+            poll_result = collect_busy_input(queued_inputs, steering, agent)
             sleep 0.01
           rescue Interrupt
             poll_result = PromptInterface::CANCEL_INPUT
@@ -52,7 +53,11 @@ module Kward
             cancellation.cancel!
             worker.raise(Cancellation::CancelledError, "cancelled") if worker.alive?
           end
-          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+          if busy_replacement_agent?
+            discard_interactive_events(event_queue, markdown_chunks, stream_state)
+          else
+            drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+          end
         end
         begin
           worker.join
@@ -60,10 +65,14 @@ module Kward
           error ||= e
         end
         drain_busy_input(queued_inputs, nil) unless cancelled
-        drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
-        raise error if error && !error.is_a?(Cancellation::CancelledError)
+        if busy_replacement_agent?
+          discard_interactive_events(event_queue, markdown_chunks, stream_state, force: true)
+        else
+          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+        end
+        raise error if error && !error.is_a?(Cancellation::CancelledError) && !busy_replacement_agent?
 
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless cancelled || stream_state[:streamed] || answer.to_s.empty?
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
         persist_memory_state(agent.conversation) if agent.respond_to?(:conversation)
         auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && queued_inputs.empty? && !cancelled
         queued_inputs
@@ -87,6 +96,21 @@ module Kward
         flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: force)
       end
 
+      def discard_interactive_events(event_queue, markdown_chunks, stream_state, force: false)
+        drained = 0
+        loop do
+          break if !force && drained >= INTERACTIVE_EVENT_DRAIN_LIMIT
+
+          event_queue.pop(true)
+          drained += 1
+        rescue ThreadError
+          break
+        end
+        markdown_chunks.clear
+        finish_stream_block if stream_state[:stream_block_open]
+        stream_state[:stream_block_open] = false
+      end
+
       def handle_interactive_event(event, markdown_chunks, stream_state)
         case event
         when Events::ReasoningDelta
@@ -154,13 +178,18 @@ module Kward
         collect_busy_input(queued_inputs, nil)
       end
 
-      def collect_busy_input(queued_inputs, steering)
+      def collect_busy_input(queued_inputs, steering, agent = nil)
         return nil if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
 
         poll_result = @prompt.poll_input
         case poll_result
         when String
-          if steering && !poll_result.strip.empty?
+          return poll_result if handle_busy_worker_input(poll_result, agent, queued_inputs)
+
+          if slash_command_input?(poll_result)
+            queued_inputs << poll_result
+            @prompt.set_queued_count(queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
+          elsif steering && !poll_result.strip.empty?
             begin
               steering.submit(poll_result)
               @prompt.set_steered_count(1) if @prompt.respond_to?(:set_steered_count)
@@ -183,16 +212,51 @@ module Kward
         drain_busy_input(queued_inputs, nil)
       end
 
-      def drain_busy_input(queued_inputs, steering)
+      def drain_busy_input(queued_inputs, steering, agent = nil)
         deadline = Time.now + 0.15
         loop do
-          poll_result = collect_busy_input(queued_inputs, steering)
+          poll_result = collect_busy_input(queued_inputs, steering, agent)
           break if Time.now > deadline && poll_result.nil?
 
           sleep 0.01
         end
       end
 
+      def slash_command_input?(input)
+        input.to_s.strip.start_with?("/")
+      end
+
+      def handle_busy_worker_input(input, agent, queued_inputs)
+        return false unless agent
+
+        command = input.to_s.strip
+        return false unless command == "/workers" || command.start_with?("/workers ")
+
+        _handled, replacement_agent = handle_local_slash_command(command, agent, @session_store)
+        @busy_replacement_agent = replacement_agent if replacement_agent?(replacement_agent)
+        restore_busy_input_prompt
+        true
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        restore_busy_input_prompt
+        true
+      end
+
+      def replacement_agent?(object)
+        object.respond_to?(:conversation) && object.respond_to?(:ask)
+      end
+
+      def busy_replacement_agent?
+        replacement_agent?(@busy_replacement_agent)
+      end
+
+      def restore_busy_input_prompt
+        return unless @prompt.respond_to?(:begin_busy_input)
+        return if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
+
+        @prompt.begin_busy_input("You>")
+      end
+
       def steering_supported?
         @client.respond_to?(:supports_in_flight_steer?) && @client.supports_in_flight_steer?
       end

data/lib/kward/cli/openrouter_commands.rb

@@ -0,0 +1,55 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
+  class CLI
+    # OpenRouter cache management commands for the terminal CLI flow.
+    module OpenRouterCommands
+      private
+
+      def handle_openrouter_command(arguments)
+        case arguments
+        when ["refresh"], ["--refresh"]
+          refresh_openrouter_models
+        when ["list"], ["--list"]
+          list_openrouter_models
+        else
+          raise ArgumentError, command_usage("openrouter")
+        end
+      end
+
+      def refresh_openrouter_models
+        cache = OpenRouterModelCache.new(api_key: configured_openrouter_api_key, path: openrouter_models_cache_path)
+        data = cache.refresh
+        count = Array(data["models"]).length
+        @client.reload_config if @client.respond_to?(:reload_config)
+        @prompt.say("Refreshed #{count} OpenRouter text model#{count == 1 ? "" : "s"} for this key.")
+        @prompt.say("Cached at: #{cache.path}")
+      rescue StandardError => e
+        warn e.message
+        exit 1
+      end
+
+      def list_openrouter_models
+        cache = OpenRouterModelCache.new(api_key: configured_openrouter_api_key, path: openrouter_models_cache_path)
+        data = cache.read
+        unless data
+          @prompt.say("No OpenRouter model cache found. Run `kward openrouter refresh` first.")
+          return
+        end
+
+        models = Array(data["models"])
+        lines = ["OpenRouter models cached at #{data["refreshed_at"]}:"]
+        lines.concat(models.map { |model| model["id"].to_s }.reject(&:empty?))
+        @prompt.say(lines.join("\n"))
+      end
+
+      def configured_openrouter_api_key
+        ENV["OPENROUTER_API_KEY"].to_s.empty? ? ConfigFiles.config_value(ConfigFiles.read_config, "openrouter_api_key").to_s : ENV["OPENROUTER_API_KEY"].to_s
+      end
+
+      def openrouter_models_cache_path
+        File.join(File.dirname(ConfigFiles.config_path), "cache", "openrouter_models.json")
+      end
+    end
+  end
+end

data/lib/kward/cli/plugins.rb

@@ -7,7 +7,7 @@ module Kward
       private
 
       def prompt_templates
-        @prompt_templates ||= ConfigFiles.prompt_templates(reserved_commands: BUILTIN_SLASH_COMMAND_NAMES)
+        @prompt_templates ||= ConfigFiles.prompt_templates(reserved_commands: builtin_slash_command_names)
       end
 
       def plugin_registry
@@ -22,6 +22,14 @@ module Kward
         plugin_registry.command_for(command)
       end
 
+      def interactive_commands
+        plugin_registry.interactive_commands
+      end
+
+      def interactive_command_for(command)
+        plugin_registry.interactive_command_for(command)
+      end
+
       def reload_plugins(conversation)
         @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
         conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)
@@ -30,7 +38,34 @@ module Kward
       end
 
       def reserved_slash_command_names
-        BUILTIN_SLASH_COMMAND_NAMES + prompt_templates.map(&:command)
+        builtin_slash_command_names + prompt_templates.map(&:command)
+      end
+
+      def run_interactive_command(name, argument, agent)
+        command = interactive_command_for(name)
+        return [false, nil] unless command
+        return [false, nil] unless prompt_interface? && @prompt.respond_to?(:start_interactive)
+
+        context = plugin_context(agent.conversation, argument)
+        controller = @prompt.start_interactive(title: "/#{name}", rows: command.rows, fps: command.fps)
+        command.handler.call(controller, context)
+        run_interactive_loop
+        [true, nil]
+      rescue StandardError => e
+        @prompt.finish_interactive if @prompt.respond_to?(:finish_interactive)
+        runtime_output("Interactive command /#{name} error: #{e.message}")
+        [true, nil]
+      end
+
+      def run_interactive_loop
+        loop do
+          result = @prompt.poll_input
+          if result == :interactive_exited || @prompt.interactive_exited?
+            @prompt.finish_interactive
+            break
+          end
+          sleep 0.01
+        end
       end
 
       def slash_command_entries
@@ -42,15 +77,30 @@ module Kward
           }
         end
         plugin_entries = plugin_commands.map(&:entry)
-        BUILTIN_SLASH_COMMANDS + prompt_entries + plugin_entries
+        interactive_entries = interactive_commands.map(&:entry)
+        builtin_slash_commands + prompt_entries + plugin_entries + interactive_entries
       end
 
       def prompt_template_for(command)
         prompt_templates.find { |template| template.command == command }
       end
 
+      def builtin_slash_commands
+        return BUILTIN_SLASH_COMMANDS if experimental_workers_enabled?
+
+        BUILTIN_SLASH_COMMANDS.reject { |command| command[:name] == "workers" }
+      end
+
+      def builtin_slash_command_names
+        builtin_slash_commands.map { |command| command[:name] }
+      end
+
+      def experimental_workers_enabled?
+        @experimental_workers == true
+      end
+
       def expand_prompt_template(input)
-        PromptCommands.expand(input, templates: prompt_templates, reserved_commands: BUILTIN_SLASH_COMMAND_NAMES)
+        PromptCommands.expand(input, templates: prompt_templates, reserved_commands: builtin_slash_command_names)
       end
 
       def run_plugin_command(name, argument, agent)

data/lib/kward/cli/prompt_interface.rb

@@ -1,3 +1,5 @@
+require "open3"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
@@ -13,7 +15,6 @@ module Kward
         prompt_interface = load_prompt_interface
         return unless prompt_interface
 
-        banner_enabled = ConfigFiles.banner_enabled?
         @prompt = prompt_interface.new(
           slash_commands: slash_command_entries,
           overlay_settings: ConfigFiles.overlay_settings,
@@ -22,8 +23,21 @@ module Kward
           busy_help: ConfigFiles.composer_busy_help?,
           attachment_badges: method(:composer_attachment_badges),
           attachment_parser: method(:composer_attachment_parser),
-          banner_pixels: banner_enabled ? Kward::PromptInterface::BANNER_LOGO_PIXELS : nil,
-          banner_message: banner_enabled ? Kward::PromptInterface::BANNER_MESSAGE : nil
+          banner_message: Kward::PromptInterface::BANNER_MESSAGE,
+          tab_keybindings: ConfigFiles.composer_tab_keybindings,
+          prompt_history: PromptHistory.new(cwd: current_workspace_root),
+          editor_mode: ConfigFiles.editor_mode,
+          editor_mode_source: -> { ConfigFiles.editor_mode },
+          editor_auto_indent: ConfigFiles.editor_auto_indent?,
+          editor_auto_indent_source: -> { ConfigFiles.editor_auto_indent? },
+          editor_auto_close_pairs: ConfigFiles.editor_auto_close_pairs?,
+          editor_auto_close_pairs_source: -> { ConfigFiles.editor_auto_close_pairs? },
+          editor_soft_wrap: ConfigFiles.editor_soft_wrap?,
+          editor_soft_wrap_source: -> { ConfigFiles.editor_soft_wrap? },
+          editor_bar_cursor: ConfigFiles.editor_bar_cursor?,
+          editor_bar_cursor_source: -> { ConfigFiles.editor_bar_cursor? },
+          editor_line_numbers: ConfigFiles.editor_line_numbers,
+          editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers }
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
           @prompt.start(render: false)
@@ -50,9 +64,80 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
-      # Writes the visual banner output for the terminal CLI flow.
+      # Writes the startup info screen output for the terminal CLI flow.
       def print_visual_banner
-        @prompt.print_visual_banner if @prompt.respond_to?(:print_visual_banner)
+        return unless @prompt.respond_to?(:print_visual_banner)
+
+        @prompt.print_visual_banner(startup_info_screen)
+      end
+
+      def startup_info_screen
+        [
+          startup_status_line,
+          "",
+          startup_info_line("Workspace", startup_workspace_label),
+          startup_info_line("Branch", startup_branch_value),
+          startup_info_line("Plugins", startup_plugins_value),
+          "",
+          startup_brand_line
+        ].join("\n")
+      end
+
+      def startup_workspace_label
+        root = File.expand_path(current_workspace_root)
+        home = begin
+          Dir.home
+        rescue StandardError
+          nil
+        end
+        if home && (root == home || root.start_with?("#{home}/"))
+          relative = root.delete_prefix(home).sub(%r{\A/}, "")
+          return "~" if relative.empty?
+          return "~/#{relative}" unless relative.include?("/")
+        end
+
+        parent = File.basename(File.dirname(root))
+        name = File.basename(root)
+        parent.empty? || parent == "." ? name : "#{parent}/#{name}"
+      end
+
+      def startup_branch_value
+        git_root = startup_git_root(current_workspace_root)
+        return "not a repository" if git_root.to_s.empty?
+
+        branch = startup_git_output(%w[git branch --show-current], root: git_root)
+        branch = startup_git_output(%w[git rev-parse --short HEAD], root: git_root) if branch.empty?
+        branch.empty? ? "unknown" : branch
+      end
+
+      def startup_plugins_value
+        filenames = plugin_registry.paths.map { |path| File.basename(path) }
+        filenames.empty? ? "none" : filenames.join(", ")
+      end
+
+      def startup_status_line
+        "#{ANSI.colorize("●", :green, enabled: @color_enabled)} Kward v#{Kward::VERSION} is online."
+      end
+
+      def startup_info_line(label, value)
+        "#{ANSI.colorize(label.ljust(12), :gray, enabled: @color_enabled)}#{ANSI.colorize(value, :cyan, enabled: @color_enabled)}"
+      end
+
+      def startup_brand_line
+        ANSI.colorize(Kward::PromptInterface::BANNER_MESSAGE, :bold, enabled: @color_enabled)
+      end
+
+      def startup_git_root(root)
+        startup_git_output(%w[git rev-parse --show-toplevel], root: root)
+      end
+
+      def startup_git_output(command, root:)
+        output, status = Open3.capture2e(*command, chdir: root.to_s)
+        return "" unless status.success?
+
+        output.lines.first.to_s.strip
+      rescue StandardError
+        ""
       end
 
       def prompt_footer_renderer
@@ -78,6 +163,8 @@ module Kward
         reasoning = "n/a" unless ModelInfo.reasoning_supported?(provider, model) && !reasoning.to_s.empty?
         text = "#{provider} #{model} · #{reasoning}"
         parts = []
+        git = composer_git_branch_text
+        parts << git if git
         diff = composer_session_diff_text
         parts << diff if diff
         usage = composer_context_usage(provider, model)
@@ -94,6 +181,21 @@ module Kward
         "#{additions}|#{deletions}"
       end
 
+      def composer_git_branch_text
+        git_root = startup_git_root(current_workspace_root)
+        return nil if git_root.to_s.empty?
+
+        branch = startup_git_output(%w[git branch --show-current], root: git_root)
+        branch = startup_git_output(%w[git rev-parse --short HEAD], root: git_root) if branch.empty?
+        branch = "unknown" if branch.empty?
+        color = composer_git_dirty?(git_root) ? :yellow : nil
+        ANSI.colorize(branch, color, enabled: @color_enabled)
+      end
+
+      def composer_git_dirty?(git_root)
+        !startup_git_output(%w[git status --porcelain --untracked-files=normal], root: git_root).empty?
+      end
+
       def composer_context_percent_text(percent)
         value = percent.round
         color = if value >= 85
@@ -107,7 +209,10 @@ module Kward
       def composer_context_window(provider = nil, model = nil)
         provider ||= current_footer_conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
         model ||= current_footer_conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : ModelInfo::DEFAULT_OPENAI_MODEL)
-        ModelInfo.context_window(ModelInfo.provider_label(provider), model)
+        provider = ModelInfo.provider_label(provider)
+        return @client.context_window(provider, model) if @client.respond_to?(:context_window) && @client.method(:context_window).arity != 0
+
+        ModelInfo.context_window(provider, model)
       end
 
       def composer_context_usage(provider, model)

data/lib/kward/cli/rendering.rb

@@ -59,7 +59,7 @@ module Kward
         if prompt_interface?
           print_tool_result(tool_call, content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
         else
-          @prompt.say("\n#{colored("Tool>", *tool_label_styles(content))}\n#{summary}\n")
+          @prompt.say("\n#{colored("Tool>", *tool_label_styles(content))} #{tool_summary_display_text(summary)}\n")
         end
       end
 
@@ -71,7 +71,7 @@ module Kward
           print_block_delta(label, rendered)
           finish_stream_block
         else
-          @prompt.say("\n#{colored("#{transcript_label(label)}>", *label_styles(label))}\n#{rendered}\n")
+          @prompt.say("\n#{colored("#{transcript_label(label)}>", *label_styles(label))} #{rendered}\n")
         end
       end
 
@@ -298,8 +298,9 @@ module Kward
       def print_tool_result(tool_call, content, line_limit: nil)
         summary = tool_result_summary(tool_call, content)
         summary = limit_tool_output_lines(summary, line_limit) if line_limit
+        display_summary = tool_summary_display_text(summary)
         if prompt_interface?
-          summary = summary.end_with?("\n") ? summary : "#{summary}\n"
+          summary = display_summary.end_with?("\n") ? display_summary : "#{display_summary}\n"
           if @prompt.respond_to?(:write_stream_block)
             @prompt.write_stream_block("Tool", summary, finish: true)
           else
@@ -309,18 +310,22 @@ module Kward
           end
         else
           start_stream_block(tool_stream_label(content))
-          print summary
-          puts unless summary.end_with?("\n")
+          print display_summary
+          puts unless display_summary.end_with?("\n")
           $stdout.flush
           @stream_block = nil
         end
       end
 
+      def tool_summary_display_text(summary)
+        summary.to_s.sub("\n", "\n\n")
+      end
+
       def start_stream_block(label)
         return if @stream_block == label
 
         puts if @stream_block
-        puts "\n#{colored("#{transcript_label(label)}>", *label_styles(label))}"
+        print "\n#{colored("#{transcript_label(label)}>", *label_styles(label))} "
         @stream_block = label
       end
 

data/lib/kward/cli/runtime_helpers.rb

@@ -43,9 +43,22 @@ module Kward
       end
 
       def build_interactive_agent(conversation)
+        @active_worker_role = "implementation"
+        set_visible_worker("implementation", status: "active")
+        build_worker_agent(conversation, role: "implementation")
+      end
+
+      def build_worker_agent(conversation, role: "implementation")
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         workspace = configured_workspace(root: conversation.workspace_root)
-        tool_registry = ToolRegistry.new(workspace: workspace, prompt: @prompt)
+        writer_id = worker_writer_id(role)
+        tool_registry = ToolRegistry.new(
+          workspace: workspace,
+          prompt: @prompt,
+          allowed_tool_names: Workers::ToolPolicy.allowed_tool_names(role),
+          write_lock: @worker_write_lock,
+          writer_id: writer_id
+        )
         @footer_conversation = conversation
         @footer_tool_registry = tool_registry
         Agent.new(
@@ -55,6 +68,34 @@ module Kward
         )
       end
 
+      def set_visible_worker(id, status: nil, worker: nil)
+        @visible_worker_id = id.to_s
+        @visible_worker_status = status
+        @visible_worker = worker
+      end
+
+      def worker_writer_id(role)
+        return nil unless Workers::ToolPolicy.write_capable?(role)
+
+        @worker_write_lock ||= Workers::WriteLock.new
+        owner_id = role.to_s.empty? ? "implementation" : role.to_s
+        return owner_id if @worker_write_lock.acquire(owner_id)
+
+        nil
+      end
+
+      def refresh_implementation_writer(agent)
+        return agent unless @active_worker_role == "implementation"
+        return agent unless agent&.respond_to?(:tool_registry)
+        return agent if agent.tool_registry.writer_id && @worker_write_lock&.owned_by?(agent.tool_registry.writer_id)
+
+        build_interactive_agent(agent.conversation)
+      end
+
+      def release_implementation_writer
+        @worker_write_lock&.release("implementation")
+      end
+
       def handle_interactive_shell_command(input, agent)
         command = input.to_s.sub(/\A!\s*/, "")
         if command.strip.empty?
@@ -73,6 +114,95 @@ module Kward
         input.to_s.start_with?("!")
       end
 
+      def run_ekwsh(agent)
+        unless @prompt.respond_to?(:ask)
+          runtime_output("The embedded shell is only available in interactive mode.")
+          return
+        end
+
+        tab = active_tab if respond_to?(:active_tab, true)
+        entering = tab.nil? || tab.shell.nil?
+        shell = tab&.shell || build_ekwsh(agent)
+        tab.shell = shell if tab
+        runtime_output("Entering ekwsh. Type exit or press Ctrl+D on an empty prompt to return.") if entering
+        run_ekwsh_loop(shell, tab: tab)
+      end
+
+      def build_ekwsh(agent)
+        config = ConfigFiles.read_ekwsh_config
+        Ekwsh.new(cwd: interactive_workspace_root(agent), configured_env: config[:env], aliases: config[:aliases])
+      end
+
+      def run_ekwsh_loop(shell, tab: nil)
+        loop do
+          if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
+            editor_result = @prompt.run_editor
+            if editor_result.is_a?(Hash) && editor_result[:tab_action]
+              (@pending_inputs ||= []).unshift(editor_result)
+              return :tab_action
+            end
+          end
+
+          input = ask_ekwsh(shell)
+          if input.is_a?(Hash) && input[:tab_action]
+            (@pending_inputs ||= []).unshift(input)
+            return :tab_action
+          end
+          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.output.to_s.empty?
+          if result.open_editor_path
+            editor_result = open_ekwsh_editor(result.open_editor_path, shell)
+            return :tab_action if editor_result == :tab_action
+
+            next
+          end
+          if result.exit_shell
+            tab.shell = nil if tab
+            runtime_output("Shell exited.")
+            return :exited
+          end
+        end
+        tab.shell = nil if tab
+        runtime_output("Shell exited.")
+        :exited
+      end
+
+      def open_ekwsh_editor(path, shell)
+        unless @prompt.respond_to?(:edit_file)
+          runtime_output("Integrated editor is unavailable in this prompt.")
+          return false
+        end
+
+        result = @prompt.edit_file(path, base_dir: shell.cwd, allow_new: true)
+        if result.is_a?(Hash) && result[:tab_action]
+          (@pending_inputs ||= []).unshift(result)
+          return :tab_action
+        end
+
+        result
+      end
+
+      def ask_ekwsh(shell)
+        provider = ->(input, cursor) { shell.complete(input, cursor) }
+        if @prompt.respond_to?(:with_completion_provider)
+          @prompt.with_completion_provider(provider) { @prompt.ask(shell.prompt_label) }
+        else
+          @prompt.ask(shell.prompt_label)
+        end
+      end
+
+      def run_ekwsh_command(shell, input)
+        if @prompt.respond_to?(:begin_busy_input)
+          @prompt.begin_busy_input(shell.prompt_label, activity: "running")
+        end
+        shell.run(input)
+      ensure
+        @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+      end
+
       def configured_workspace(root: current_workspace_root)
         Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
       end
@@ -146,10 +276,10 @@ module Kward
         @client.reload_config if @client.respond_to?(:reload_config)
       end
 
-      def refresh_conversation_runtime(conversation)
+      def refresh_conversation_runtime(conversation, reasoning_effort: current_reasoning_effort, refresh_system_message: true)
         return unless conversation&.respond_to?(:update_runtime_context!)
 
-        conversation.update_runtime_context!(provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        conversation.update_runtime_context!(provider: current_model_provider, model: current_model_id, reasoning_effort: reasoning_effort, refresh: refresh_system_message)
         update_assistant_prompt(conversation)
       end