kward 0.82.0 → 0.83.0

data/lib/kward/cli/interactive_turn.rb

@@ -6,9 +6,68 @@ module Kward
     module InteractiveTurn
       private
 
-      def run_interactive_turn(agent, input, display_input: nil)
-        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation)
-        return run_blocking_interactive_turn(agent, input, display_input: display_input) unless prompt_interface?
+      def run_editor_prompt_turn(action, agent)
+        unless agent.respond_to?(:tool_registry) && agent.tool_registry.respond_to?(:for_editor_prompt)
+          runtime_output("Editor prompts are unavailable in this tab.")
+          return []
+        end
+        unless @prompt.respond_to?(:editor_prompt_context)
+          runtime_output("Editor prompts are unavailable in this prompt.")
+          return []
+        end
+
+        context = @prompt.editor_prompt_context
+        unless context
+          runtime_output("Open a Modern or Vibe editor buffer before prompting the agent.")
+          return []
+        end
+
+        unless @prompt.suspend_editor_for_agent
+          runtime_output("The editor is busy.")
+          return []
+        end
+
+        session = EditorPromptSession.new(context)
+        registry = agent.tool_registry.for_editor_prompt(session)
+        editor_agent = build_editor_prompt_agent(agent, context, registry)
+        instruction = action[:instruction] || action["instruction"]
+        run_interactive_turn(
+          editor_agent,
+          EditorPrompt.input(instruction, context),
+          tool_registry: registry,
+          editor_prompt_session: session,
+          suppress_transcript: true
+        )
+      rescue StandardError => e
+        @prompt.resume_editor_for_agent(status: "Agent request failed") if @prompt.respond_to?(:resume_editor_for_agent)
+        runtime_output("Error: #{e.message}")
+        []
+      end
+
+      def build_editor_prompt_agent(active_agent, context, registry)
+        active_conversation = active_agent.conversation
+        config = safely_read_config.to_h
+        provider = active_conversation.provider || current_model_provider
+        model = ConfigFiles.editor_agent_model(config) || active_conversation.model || current_model_id
+        reasoning = ConfigFiles.editor_agent_reasoning_effort(config) || active_conversation.reasoning_effort || current_reasoning_effort
+        conversation = Conversation.new(
+          system_message: EditorPrompt.system_message,
+          workspace_root: context[:workspace_root] || active_conversation.workspace_root,
+          provider: provider,
+          model: model,
+          reasoning_effort: reasoning
+        )
+        Agent.new(
+          client: @client,
+          tool_registry: registry,
+          conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink
+        )
+      end
+
+      def run_interactive_turn(agent, input, display_input: nil, tool_registry: nil, editor_prompt_session: nil, suppress_transcript: false, busy_label: "You>", on_complete: nil)
+        prepare_memory_context(agent.conversation, input) if agent.respond_to?(:conversation) && !suppress_transcript
+        return run_blocking_interactive_turn(agent, input, display_input: display_input, tool_registry: tool_registry, suppress_transcript: suppress_transcript, on_complete: on_complete) unless prompt_interface?
 
         queued_inputs = []
         cancellation = Cancellation.new
@@ -25,11 +84,11 @@ module Kward
         markdown_chunks = []
         answer = nil
         error = nil
-        @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
-        print_user_transcript(input, display_input: display_input)
+        @prompt.begin_busy_input(busy_label) if @prompt.respond_to?(:begin_busy_input)
+        print_user_transcript(input, display_input: display_input) unless suppress_transcript
 
         worker = Thread.new do
-          options = agent_display_options(display_input)
+          options = agent_display_options(display_input, tool_registry: tool_registry)
           options[:cancellation] = cancellation
           options[:steering] = steering if steering
           answer = agent.ask(input, **options) do |event|
@@ -52,7 +111,7 @@ module Kward
             cancellation.cancel!
             worker.raise(Cancellation::CancelledError, "cancelled") if worker.alive?
           end
-          if busy_replacement_agent?
+          if busy_replacement_agent? || suppress_transcript
             discard_interactive_events(event_queue, markdown_chunks, stream_state)
           else
             drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
@@ -64,19 +123,39 @@ module Kward
           error ||= e
         end
         drain_busy_input(queued_inputs, nil) unless cancelled
-        if busy_replacement_agent?
+        if busy_replacement_agent? || suppress_transcript
           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
+        completed = !cancelled && !busy_replacement_agent? && !error
+        on_complete&.call(successful: completed, cancelled: cancelled, error: error, answer: answer)
         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 || 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
+        @prompt.commit_editor_prompt(editor_prompt_session) if editor_prompt_session && completed
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript && queued_inputs.empty? && !cancelled
         queued_inputs
       ensure
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+        if editor_prompt_session && @prompt.respond_to?(:resume_editor_for_agent)
+          status = if cancelled
+            "Agent request cancelled"
+          elsif error
+            "Agent request failed"
+          elsif editor_prompt_session && !editor_prompt_session.changed? && !answer.to_s.strip.empty?
+            editor_prompt_answer_status(answer)
+          end
+          @prompt.resume_editor_for_agent(status: status)
+        end
+      end
+
+      def editor_prompt_answer_status(answer)
+        text = answer.to_s.gsub(/\s+/, " ").strip
+        text = text[0, 120].to_s
+        text += "…" if answer.to_s.gsub(/\s+/, " ").strip.length > text.length
+        "Agent: #{text}"
       end
 
       def drain_interactive_events(event_queue, markdown_chunks, stream_state, agent = nil, force: false)
@@ -261,21 +340,24 @@ module Kward
         ModelInfo.reasoning_supported?(current_model_provider, model)
       end
 
-      def run_blocking_interactive_turn(agent, input, display_input: nil)
+      def run_blocking_interactive_turn(agent, input, display_input: nil, tool_registry: nil, suppress_transcript: false, on_complete: nil)
         streamed = false
         markdown_chunks = []
-        answer = agent.ask(input, **agent_display_options(display_input)) do |event|
-          streamed = true if render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+        answer = agent.ask(input, **agent_display_options(display_input, tool_registry: tool_registry)) do |event|
+          streamed = true if !suppress_transcript && render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
         end
         flush_markdown_deltas(markdown_chunks) if streamed
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless 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)
+        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || streamed || answer.to_s.empty?
+        persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
+        on_complete&.call(successful: true, cancelled: false, error: nil, answer: answer)
         []
       end
 
-      def agent_display_options(display_input)
-        display_input.nil? ? {} : { display_input: display_input }
+      def agent_display_options(display_input, tool_registry: nil)
+        options = display_input.nil? ? {} : { display_input: display_input }
+        options[:tool_registry] = tool_registry if tool_registry
+        options
       end
 
     end

data/lib/kward/cli/runtime_helpers.rb

@@ -192,13 +192,86 @@ module Kward
         entering = tab.nil? || tab.shell.nil?
         shell = tab&.shell || build_ekwsh(agent)
         tab.shell = shell if tab
+        shell_agent = shell_prompt_agent_for(agent, tab: 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, history: build_ekwsh_history(agent))
+        run_ekwsh_loop(shell, tab: tab, history: build_ekwsh_history(agent), shell_agent: shell_agent)
+      end
+
+      def shell_prompt_agent_for(agent, tab: nil)
+        return tab.shell_agent if tab&.shell_agent
+        return nil unless agent.respond_to?(:conversation) && agent.respond_to?(:tool_registry)
+
+        shell_agent = build_shell_prompt_agent(agent)
+        tab.shell_agent = shell_agent if tab
+        shell_agent
+      end
+
+      def build_shell_prompt_agent(active_agent)
+        active_conversation = active_agent.conversation
+        conversation = Conversation.new(
+          system_message: ShellPrompt.system_message,
+          workspace_root: active_conversation.workspace_root,
+          provider: active_conversation.provider || current_model_provider,
+          model: active_conversation.model || current_model_id,
+          reasoning_effort: active_conversation.reasoning_effort || current_reasoning_effort
+        )
+        Agent.new(
+          client: @client,
+          tool_registry: active_agent.tool_registry,
+          conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink
+        )
+      end
+
+      def run_shell_prompt_turn(input, shell, shell_agent)
+        tab = active_tab if respond_to?(:active_tab, true)
+        transcript_before = prompt_transcript_text
+        instruction = input.to_s.sub(/\A\?\s*/, "").strip
+        if instruction.empty?
+          runtime_output("Shell prompt instruction required after ?")
+          return []
+        end
+        unless shell_agent.respond_to?(:tool_registry)
+          runtime_output("Shell agent is unavailable in this prompt.")
+          return []
+        end
+
+        session = ShellPromptSession.new(shell)
+        registry = shell_agent.tool_registry.for_shell_prompt(session)
+        on_complete = lambda do |successful:, **|
+          next unless successful
+          next unless session.prepared_command
+
+          if @prompt.respond_to?(:prefill_input)
+            @prompt.prefill_input(session.prepared_command)
+          else
+            runtime_output("Prepared shell command:\n#{session.prepared_command}")
+          end
+        end
+        pending_inputs = run_interactive_turn(
+          shell_agent,
+          ShellPrompt.input(instruction, session.context),
+          display_input: "? #{instruction}",
+          tool_registry: registry,
+          busy_label: shell.prompt_label,
+          on_complete: on_complete
+        )
+        @prompt.update_prompt_label(shell.prompt_label) if @prompt.respond_to?(:update_prompt_label)
+        pending_inputs
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        []
+      ensure
+        record_shell_prompt_transcript(tab, transcript_before)
+      end
+
+      def shell_prompt_input?(input)
+        input.to_s.start_with?("?")
       end
 
       def build_ekwsh(agent)
         config = ConfigFiles.read_ekwsh_config
-        Ekwsh.new(
+        PersistentShellSession.new(
           cwd: interactive_workspace_root(agent),
           configured_env: config[:env],
           aliases: config[:aliases],
@@ -242,7 +315,8 @@ module Kward
           @prompt.say(intro_message)
         end
         result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd) do |sink, completed_result|
-          record_completed_pty_output(sink, completed_result)
+          transcript_output = record_completed_pty_output(sink, completed_result)
+          yield(transcript_output, completed_result) if block_given?
         end
         refresh_composer_status
         result
@@ -253,12 +327,18 @@ module Kward
 
       def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
-        run_with_sink = lambda do |input, sink|
-          result = runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+        with_interactive_terminal_handoff do |input, sink|
+          result = if shell.respond_to?(:run_interactive)
+            shell.run_interactive(command, input: input, sink: sink)
+          else
+            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+          end
           on_complete.call(sink, result) if on_complete
           result
         end
+      end
 
+      def with_interactive_terminal_handoff
         if @prompt.respond_to?(:with_inline_terminal_handoff)
           @prompt.with_inline_terminal_handoff do |input, output, transition|
             sink = AdaptivePtyOutputSink.new(
@@ -266,7 +346,7 @@ module Kward
               on_exclusive: transition,
               max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
             )
-            run_with_sink.call(input, sink)
+            yield(input, sink)
           end
         elsif @prompt.respond_to?(:with_terminal_handoff)
           @prompt.with_terminal_handoff do |input, output|
@@ -274,14 +354,14 @@ module Kward
               output: output,
               max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
             )
-            run_with_sink.call(input, sink)
+            yield(input, sink)
           end
         else
           sink = PassthroughPtyOutputSink.new(
             output: $stdout,
             max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
           )
-          run_with_sink.call($stdin, sink)
+          yield($stdin, sink)
         end
       end
 
@@ -306,6 +386,7 @@ module Kward
         if @prompt.respond_to?(:record_transient_terminal_output)
           @prompt.record_transient_terminal_output(transcript_output, render: false)
         end
+        transcript_output
       end
 
       def terminal_transcript_output(
@@ -341,13 +422,15 @@ module Kward
         end
       end
 
-      def run_ekwsh_loop(shell, tab: nil, history: nil)
+      def run_ekwsh_loop(shell, tab: nil, history: nil, shell_agent: nil)
+        shell_agent ||= shell_prompt_agent_for(tab.agent, tab: tab) if tab&.agent
         with_ekwsh_history(history) do
-          run_ekwsh_loop_with_history(shell, tab: tab)
+          run_ekwsh_loop_with_history(shell, tab: tab, shell_agent: shell_agent)
         end
       end
 
-      def run_ekwsh_loop_with_history(shell, tab: nil)
+      def run_ekwsh_loop_with_history(shell, tab: nil, shell_agent: nil)
+        pending_shell_inputs = []
         loop do
           if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
             editor_result = @prompt.run_editor
@@ -357,13 +440,18 @@ module Kward
             end
           end
 
-          input = ask_ekwsh(shell)
+          input = pending_shell_inputs.shift || ask_ekwsh(shell)
           if input.is_a?(Hash) && input[:tab_action]
             (@pending_inputs ||= []).unshift(input)
             return :tab_action
           end
           break if input.nil?
 
+          if shell_prompt_input?(input)
+            pending_shell_inputs.concat(run_shell_prompt_turn(input, shell, shell_agent))
+            next
+          end
+
           result = run_ekwsh_command(shell, input)
           if result.clear
             clear_active_tab_transient_shell_output
@@ -385,16 +473,26 @@ module Kward
             next
           end
           if result.exit_shell
+            close_ekwsh_session(shell)
             tab.shell = nil if tab
+            tab.shell_agent = nil if tab
             runtime_output("Shell exited.")
             return :exited
           end
         end
+        close_ekwsh_session(shell)
         tab.shell = nil if tab
+        tab.shell_agent = nil if tab
         runtime_output("Shell exited.")
         :exited
       end
 
+      def close_ekwsh_session(shell)
+        shell.close if shell.respond_to?(:close)
+      rescue StandardError
+        nil
+      end
+
       def with_ekwsh_history(history)
         if history && @prompt.respond_to?(:with_prompt_history)
           @prompt.with_prompt_history(history) { yield }
@@ -428,13 +526,19 @@ module Kward
       end
 
       def run_ekwsh_interactive_pty_command(shell, result)
+        shell_target = shell.respond_to?(:run_interactive) ? shell : shell.command_shell
         run_user_interactive_pty_command(
           result.interactive_command,
-          shell: shell.command_shell,
+          shell: shell_target,
           env: shell.child_env(interactive: true),
           cwd: shell.cwd,
           intro: result.output
-        )
+        ) do |transcript_output, completed_result|
+          shell.record_interactive_result(
+            output: transcript_output,
+            exit_status: completed_result.exit_status
+          )
+        end
       end
 
       def run_ekwsh_command(shell, input)
@@ -499,6 +603,44 @@ module Kward
         clear_active_tab_transient_shell_entries if respond_to?(:clear_active_tab_transient_shell_entries, true)
       end
 
+      def prompt_transcript_text
+        return nil unless @prompt.respond_to?(:tab_view_snapshot)
+
+        snapshot = @prompt.tab_view_snapshot
+        transcript = snapshot[:transcript_buffer] || snapshot["transcript_buffer"] || snapshot[:transcript] || snapshot["transcript"]
+        transcript = transcript.map(&:to_s).join if transcript.is_a?(Array)
+        transcript.to_s
+      rescue StandardError
+        nil
+      end
+
+      def record_shell_prompt_transcript(tab, transcript_before)
+        return unless tab && !transcript_before.nil?
+
+        transcript_after = prompt_transcript_text
+        return if transcript_after.nil?
+
+        delta = shell_prompt_transcript_delta(transcript_before, transcript_after)
+        tab.append_transient_shell_entry(delta) unless delta.empty?
+      rescue StandardError
+        nil
+      end
+
+      def shell_prompt_transcript_delta(before, after)
+        return "" if before == after
+        return after[before.length..].to_s if after.start_with?(before)
+
+        # The prompt transcript is bounded and may trim while a large agent
+        # response is rendered. Preserve only the part not already retained.
+        overlap = [before.length, after.length].min
+        while overlap.positive?
+          return after[overlap..].to_s if before.end_with?(after[0, overlap])
+
+          overlap -= 1
+        end
+        after
+      end
+
       def drain_ekwsh_chunks(chunks)
         loop do
           @prompt.write_transcript_delta(chunks.pop(true))

data/lib/kward/cli/slash_commands.rb

@@ -54,13 +54,17 @@ module Kward
           run_captured_shell_command(argument, agent)
           [true, nil]
         when "scratchpad"
-          open_scratchpad_command(argument)
+          result = open_scratchpad_command(argument)
+          queue_editor_prompt_action(result)
           [true, nil]
         when "pty"
           run_interactive_pty_command(argument, agent)
           [true, nil]
         when "tab"
           [true, handle_tab_command(argument, session_store)]
+        when "worktree"
+          handle_worktree_command(argument)
+          [true, active_tab&.agent]
         when "settings"
           configure_settings(agent.conversation)
           [true, nil]
@@ -307,6 +311,13 @@ module Kward
         end
       end
 
+      def queue_editor_prompt_action(result)
+        return unless result.is_a?(Hash) && result[:editor_prompt]
+
+        @pending_inputs ||= []
+        @pending_inputs.unshift(result)
+      end
+
       def scratchpad_language_argument(argument)
         value = argument.to_s.strip.downcase
         return :text if value.empty? || value == "text"

data/lib/kward/cli/tabs.rb

@@ -35,6 +35,7 @@ module Kward
         :unread,
         :pending_question,
         :shell,
+        :shell_agent,
         :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
@@ -317,6 +318,7 @@ module Kward
           unread: false,
           pending_question: nil,
           shell: nil,
+          shell_agent: nil,
           transient_shell_entries: [],
           error_reported: false,
           local_busy_activity: nil
@@ -418,12 +420,14 @@ module Kward
         end
 
         if @tabs.length <= 1
+          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
           @tabs.clear
           persist_tabs
           return PromptInterface::EXIT_INPUT
         end
 
         stop_tab_live_view
+        close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
         tab.session&.delete_if_unused if tab&.session.respond_to?(:delete_if_unused)
         tab.driver.close if tab.driver.respond_to?(:close)
         @tabs.delete_at(@active_tab_index)
@@ -462,7 +466,9 @@ module Kward
         tab.seen_events = 0
         tab.queued_inputs.clear
         tab.steering = nil
+        close_ekwsh_session(tab.shell) if tab.shell && respond_to?(:close_ekwsh_session, true)
         tab.shell = nil
+        tab.shell_agent = nil
         tab.clear_transient_shell_entries
         tab.stream_state = new_tab_stream_state(tab.driver)
         tab.markdown_chunks.clear
@@ -959,11 +965,12 @@ module Kward
       def stop_tabs
         stop_tab_live_view
         Array(@tabs).each do |tab|
-          next unless tab&.running?
-
-          tab.cancellation&.cancel!
-          tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
-          tab.thread&.join(0.2)
+          if tab&.running?
+            tab.cancellation&.cancel!
+            tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
+            tab.thread&.join(0.2)
+          end
+          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
         rescue StandardError
           nil
         end

data/lib/kward/cli.rb

@@ -10,11 +10,16 @@ require_relative "compactor"
 require_relative "config_files"
 require_relative "clipboard"
 require_relative "cancellation"
+require_relative "editor_prompt"
+require_relative "editor_prompt_session"
+require_relative "shell_prompt"
+require_relative "shell_prompt_session"
 require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
 require_relative "ekwsh"
+require_relative "persistent_shell_session"
 require_relative "interactive_pty_runner"
 require_relative "adaptive_pty_output_sink"
 require_relative "pty_transcript_normalizer"
@@ -477,6 +482,11 @@ module Kward
           run_ekwsh_loop(active_tab.shell, tab: active_tab, history: build_ekwsh_history(active_tab.agent))
         end
         input = @pending_inputs.shift || (active_tab ? poll_active_tab_input : @prompt.ask("You>"))
+        if input.is_a?(Hash) && input[:editor_prompt]
+          pending_inputs = run_editor_prompt_turn(input[:editor_prompt], active_tab&.agent || agent)
+          pending_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
+          next
+        end
         if input.is_a?(Hash) && input[:tab_action]
           tab_result = handle_tab_action(input, session_store)
           break if tab_result == PromptInterface::EXIT_INPUT

data/lib/kward/compaction/token_estimator.rb

@@ -31,13 +31,15 @@ module Kward
         parts = [role]
         if role.to_s == "compactionSummary"
           parts << value(message, :summary)
-        else
+        elsif response_items(message).empty?
           parts << content_text(value(message, :content))
-        end
-        parts << value(message, :reasoning_summary)
-        tool_calls(message).each do |tool_call|
-          parts << tool_call_name(tool_call)
-          parts << tool_call_arguments(tool_call)
+          parts << value(message, :reasoning_summary)
+          tool_calls(message).each do |tool_call|
+            parts << tool_call_name(tool_call)
+            parts << tool_call_arguments(tool_call)
+          end
+        else
+          parts << JSON.generate(response_items(message))
         end
         parts << value(message, :tool_call_id)
         parts << value(message, :name)
@@ -65,6 +67,10 @@ module Kward
         MessageAccess.tool_calls(message)
       end
 
+      def response_items(message)
+        MessageAccess.response_items(message)
+      end
+
       def tool_call_name(tool_call)
         ToolCall.name(tool_call)
       end

data/lib/kward/config_files.rb

@@ -136,6 +136,7 @@ module Kward
         },
         "editor" => {
           "mode" => "modern",
+          "agent" => {},
           "auto_indent" => true,
           "auto_close_pairs" => true,
           "soft_wrap" => true,
@@ -482,6 +483,22 @@ module Kward
       EditorMode.normalize(editor["mode"])
     end
 
+    # Returns the optional model override for editor-agent turns.
+    def editor_agent_model(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      agent = editor["agent"].is_a?(Hash) ? editor["agent"] : {}
+      value = agent["model"].to_s.strip
+      value.empty? ? nil : value
+    end
+
+    # Returns the optional reasoning-effort override for editor-agent turns.
+    def editor_agent_reasoning_effort(config = read_config)
+      editor = config["editor"].is_a?(Hash) ? config["editor"] : {}
+      agent = editor["agent"].is_a?(Hash) ? editor["agent"] : {}
+      value = agent["reasoning_effort"].to_s.strip
+      value.empty? ? nil : value
+    end
+
     # Returns whether the built-in TUI editor should auto-indent new lines.
     def editor_auto_indent?(config = read_config)
       editor = config["editor"].is_a?(Hash) ? config["editor"] : {}