kward 0.70.0 → 0.72.0

data/lib/kward/cli/sessions.rb

@@ -12,7 +12,7 @@ module Kward
         return @session_store if @session_store
         return nil if agent
 
-        SessionStore.new
+        @session_store = SessionStore.new
       end
 
       def resume_last_session(session_store)
@@ -69,7 +69,7 @@ module Kward
       end
 
       def mutation_tool_call?(tool_call)
-        ["edit_file", "write_file", "edit", "write"].include?(ToolCall.name(tool_call).to_s)
+        ToolCall.file_change_tool?(ToolCall.name(tool_call))
       end
 
       def cleanup_unused_sessions
@@ -108,6 +108,13 @@ module Kward
         path = select_session_path(session_store) if path.empty?
         return nil if path.to_s.empty?
 
+        load_session(session_store, path, message: "Resumed session")
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        nil
+      end
+
+      def load_session(session_store, path, message: nil)
         previous_session = @active_session
         @active_session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
         reset_session_diff(@active_session.path)
@@ -115,15 +122,12 @@ module Kward
         cleanup_replaced_session(previous_session)
         update_assistant_prompt(conversation)
         restore_prompt_transcript do
-          runtime_output("Resumed session: #{@active_session.path}")
+          runtime_output("#{message}: #{@active_session.path}") if message
           render_conversation_transcript(conversation)
         end
         agent = build_interactive_agent(conversation)
         @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
         agent
-      rescue StandardError => e
-        runtime_output("Error: #{e.message}")
-        nil
       end
 
       def navigate_session_tree(session_store)
@@ -295,7 +299,7 @@ module Kward
       end
 
       def relative_rewind_time(timestamp)
-        time = Time.iso8601(timestamp.to_s).utc
+        time = timestamp.is_a?(Time) ? timestamp.utc : Time.iso8601(timestamp.to_s).utc
         seconds = [(Time.now.utc - time).to_i, 0].max
         case seconds
         when 0...60
@@ -397,13 +401,19 @@ module Kward
         SessionTreeRenderer.new(roots: roots, current_leaf_id: current_leaf_id).items
       end
 
-      def rename_session(argument)
+      def rename_session(argument, require_name: false)
         unless @active_session
           runtime_output("No active persisted session.")
           return
         end
 
-        @active_session.rename(argument)
+        name = argument.to_s.strip
+        if require_name && name.empty?
+          runtime_output("Usage: /rename <name>")
+          return
+        end
+
+        @active_session.rename(name)
         label = @active_session.name ? "Named session: #{@active_session.name}" : "Cleared session name."
         runtime_output(label)
       end
@@ -420,6 +430,198 @@ module Kward
         agent
       end
 
+      def fork_session(session_store)
+        return say_sessions_unavailable unless session_store
+        unless @active_session
+          runtime_output("No active persisted session.")
+          return nil
+        end
+
+        points = fork_points(session_store)
+        if points.empty?
+          runtime_output("No prompts to fork from.")
+          return nil
+        end
+
+        point = select_fork_point_from_points(points)
+        return nil unless point
+
+        run_busy_local_command_and_requeue(activity: "forking") do
+          fork_session_from_point(session_store, point)
+        end
+      rescue StandardError => e
+        runtime_output("Fork error: #{e.message}")
+        nil
+      end
+
+      def fork_points(session_store)
+        fork_points_for_session(session_store, @active_session)
+      end
+
+      def fork_points_for_session(session_store, session)
+        entries = session_store.session_entries(session.path)
+        current_leaf_id = session.leaf_id || session_store.current_leaf(session.path)
+        active_path = active_session_tree_entry_ids(entries, current_leaf_id)
+        entries.each_with_index.filter_map do |entry, index|
+          next unless rewind_entry?(entry)
+          next unless active_path.include?(entry["id"].to_s)
+
+          {
+            entry: entry,
+            entry_index: index,
+            label: fork_point_label(entry),
+            timestamp: entry["timestamp"]
+          }
+        end.reverse.then { |points| align_rewind_point_timestamps(points, picker_choice_width) }
+      end
+
+      def fork_point_label(entry)
+        "Fork from: #{truncate_rewind_text(full_message_text(entry["message"] || {}))}"
+      end
+
+      def select_fork_point(labels)
+        if @prompt.respond_to?(:select)
+          return @prompt.select("Fork>", labels, title: "Fork")
+        end
+
+        numbered_labels = labels.each_with_index.map { |label, index| "#{index + 1}. #{label}" }
+        runtime_output((["Fork from:"] + numbered_labels).join("\n"))
+        answer = @prompt.ask("Fork point number>").to_s.strip
+        answer.match?(/\A\d+\z/) ? labels[answer.to_i - 1] : nil
+      end
+
+      def fork_session_from_point(session_store, point)
+        previous_session = @active_session
+        forked_session, conversation, selected_text = create_fork_from_point(session_store, previous_session, point)
+        @active_session = track_session(forked_session)
+        reset_session_diff(@active_session.path)
+        cleanup_replaced_session(previous_session)
+        update_assistant_prompt(conversation)
+        restore_prompt_transcript do
+          runtime_output("Forked session: #{@active_session.path}")
+          render_conversation_transcript(conversation)
+        end
+        prefill_selected_fork_text(selected_text)
+        agent = build_interactive_agent(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw) && !@prompt.respond_to?(:restore_transcript)
+        agent
+      end
+
+      def create_fork_from_point(session_store, source_session, point)
+        entries = session_store.session_entries(source_session.path)
+        messages = entries[0...point[:entry_index]].filter_map { |entry| entry["message"] }
+        forked_session, conversation = session_store.create_independent_from_messages(
+          messages,
+          provider: current_model_provider,
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort,
+          parent_session: source_session
+        )
+        [forked_session, conversation, full_message_text(point[:entry]["message"] || {})]
+      end
+
+      def prefill_selected_fork_text(selected_text)
+        return if selected_text.to_s.empty?
+
+        if @prompt.respond_to?(:prefill_input)
+          @prompt.prefill_input(selected_text)
+        else
+          runtime_output("Selected prompt for editing:\n#{selected_text}")
+        end
+      end
+
+      def clone_session_from_path(session_store, path)
+        clone_path = clone_session_file_from_path(session_store, path)
+        load_session(session_store, clone_path, message: "Cloned session")
+      end
+
+      def fork_session_from_picker(session_store, source_path)
+        source_session, = session_store.load(source_path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        point = select_fork_point_for_session(session_store, source_session)
+        return nil unless point
+
+        forked_session, = create_fork_from_point(session_store, source_session, point)
+        forked_session.path
+      end
+
+      def select_fork_point_for_session(session_store, session)
+        points = fork_points_for_session(session_store, session)
+        if points.empty?
+          runtime_output("No prompts to fork from.")
+          return nil
+        end
+
+        select_fork_point_from_points(points)
+      end
+
+      def select_fork_point_from_points(points)
+        labels = points.map { |point| point[:label] }
+        choice = select_fork_point(labels)
+        return nil unless choice
+
+        points[labels.index(choice)]
+      end
+
+      def clone_session_file_from_path(session_store, path)
+        source_session, source_conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+        clone, = session_store.create_independent_from_conversation(source_conversation, parent_session: source_session)
+        clone.path
+      end
+
+      def clone_session_selection(session_store, sessions, labels, label)
+        copy_session_selection(session_store, sessions, labels, label) do |source|
+          clone_session_file_from_path(session_store, source.path)
+        end
+      end
+
+      def copy_session_selection(session_store, sessions, labels, label)
+        source = sessions[labels.index(label)]
+        return nil unless source
+
+        copy_path = yield source
+        insert_session_copy(session_store, sessions, labels, source, copy_path)
+      end
+
+      def insert_session_copy(session_store, sessions, labels, source, copy_path)
+        copy_info = session_store.recent_tree(limit: nil).find { |session| File.expand_path(session.path) == File.expand_path(copy_path) }
+        copy_info ||= session_store.recent(limit: nil).find { |session| File.expand_path(session.path) == File.expand_path(copy_path) }
+        return nil unless copy_info
+
+        source_index = sessions.index(source) || 0
+        copy_index = source_index + 1
+        sessions.insert(copy_index, copy_info)
+        labels.replace(session_picker_labels(sessions))
+        continue_session_selection(labels, copy_index)
+      end
+
+      def delete_session_selection(_session_store, sessions, labels, label)
+        source = sessions[labels.index(label)]
+        return nil unless source
+
+        SessionTrash.new.delete(source.path)
+        index = sessions.index(source) || labels.index(label) || 0
+        sessions.delete_at(index)
+        labels.replace(session_picker_labels(sessions))
+        next_index = [index, labels.length - 1].min
+        continue_session_selection(labels, next_index)
+      end
+
+      def rename_session_selection(session_store, sessions, labels, label, name)
+        source = sessions[labels.index(label)]
+        return nil unless source
+
+        session_store.load(source.path).first.rename(name)
+        updated = session_store.recent_tree(limit: nil)
+        sessions.replace(updated)
+        labels.replace(session_picker_labels(sessions))
+        index = sessions.index { |session| File.expand_path(session.path) == File.expand_path(source.path) } || 0
+        continue_session_selection(labels, index)
+      end
+
+      def continue_session_selection(labels, selection_index)
+        { select_continue: true, choices: labels, selection_index: selection_index }
+      end
+
       def copy_session_text(conversation, argument)
         target = copy_target(argument)
         unless target
@@ -501,19 +703,46 @@ module Kward
       end
 
       def select_session_path(session_store)
-        select_session_path_from_sessions(session_store.recent_tree(limit: nil))
+        select_session_path_from_sessions(session_store.recent_tree(limit: nil), session_store: session_store)
       end
 
-      def select_session_path_from_sessions(sessions)
+      def reopen_sessions_after_fork(session_store, source_path, source_label)
+        fork_path = run_busy_local_command_and_requeue(activity: "forking") do
+          fork_session_from_picker(session_store, source_path)
+        end
+
+        sessions = session_store.recent_tree(limit: nil)
+        labels = session_picker_labels(sessions)
+        initial_index = if fork_path
+                          sessions.index { |session| File.expand_path(session.path) == File.expand_path(fork_path) }
+                        else
+                          labels.index(source_label)
+                        end
+        select_session_path_from_sessions(sessions, session_store: session_store, initial_index: initial_index || 0)
+      end
+
+      def select_session_path_from_sessions(sessions, session_store: @session_store, initial_index: 0)
         if sessions.empty?
           runtime_output("No saved sessions found.")
           return nil
         end
 
-        labels = sessions.map { |session| session_label(session) }
+        labels = session_picker_labels(sessions)
         if @prompt.respond_to?(:select)
-          choice = @prompt.select("Session>", labels)
+          choice = @prompt.select(
+            "Session>",
+            labels,
+            initial_index: initial_index,
+            action_keys: { "c" => { action: :clone, activity: "cloning" }, "f" => { action: :fork, defer_finish_render: true }, "r" => { action: :rename, input_prompt: "Name>" }, "d" => { action: :delete, confirm: "Press d again to delete, Esc to cancel.", confirm_title: "Delete session?" } },
+            action_handlers: {
+              clone: ->(label) { clone_session_selection(session_store, sessions, labels, label) },
+              delete: ->(label) { delete_session_selection(session_store, sessions, labels, label) },
+              rename: ->(label, name) { rename_session_selection(session_store, sessions, labels, label, name) }
+            }
+          )
           return nil unless choice
+          return choice if choice.respond_to?(:conversation)
+          return choice[:path] ? choice : session_selection_action(choice, sessions, labels, defer_finish_render: choice[:defer_finish_render]) if choice.is_a?(Hash)
 
           selected = sessions[labels.index(choice)]
           return selected&.path
@@ -529,6 +758,26 @@ module Kward
         end
       end
 
+      def session_selection_action(choice, sessions, labels, defer_finish_render: false)
+        selected = sessions[labels.index(choice[:choice])]
+        return nil unless selected
+
+        { action: choice[:action], path: selected.path, choice_label: choice[:choice] }.tap do |action|
+          action[:defer_finish_render] = true if defer_finish_render
+        end
+      end
+
+      def session_picker_labels(sessions)
+        labels = sessions.map { |session| session_label(session) }
+        label_width = labels.map(&:length).max.to_i
+        sessions.zip(labels).map do |session, label|
+          timestamp = relative_rewind_time(session.modified_at)
+          next label if timestamp.empty?
+
+          right_aligned_picker_metadata(label, timestamp, width: picker_choice_width, minimum_label_width: label_width)
+        end
+      end
+
       def session_label(session)
         title = session.name.to_s.strip
         title = session.first_message.to_s.strip if title.empty?

data/lib/kward/cli/settings.rb

@@ -222,9 +222,21 @@ module Kward
         when /\Ashow busy help/, /\Ahide busy help/
           set_composer_busy_help(!composer_busy_help?)
           runtime_output("Busy help #{composer_busy_help? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.")
-        when /\Ashow startup banner/, /\Ahide startup banner/
-          set_banner_enabled(!banner_enabled?)
-          runtime_output("Startup banner #{banner_enabled? ? "enabled" : "disabled"}. Restart the TUI to apply this setting.")
+        when /\Atab keybindings/
+          configure_tab_keybindings
+        when /\Aeditor mode/
+          configure_editor_mode
+        when /\Aeditor line numbers/
+          configure_editor_line_numbers
+        when /\Aenable auto-close pairs/, /\Adisable auto-close pairs/
+          set_editor_auto_close_pairs_enabled(!editor_auto_close_pairs_enabled?)
+          runtime_output("Editor auto-close pairs #{editor_auto_close_pairs_enabled? ? "enabled" : "disabled"}.")
+        when /\Aenable soft-wrap/, /\Adisable soft-wrap/
+          set_editor_soft_wrap_enabled(!editor_soft_wrap_enabled?)
+          runtime_output("Editor soft-wrap #{editor_soft_wrap_enabled? ? "enabled" : "disabled"}.")
+        when /\Aenable bar cursor/, /\Adisable bar cursor/
+          set_editor_bar_cursor_enabled(!editor_bar_cursor_enabled?)
+          runtime_output("Editor bar cursor #{editor_bar_cursor_enabled? ? "enabled" : "disabled"}.")
         when /\Aenable session auto-resume/, /\Adisable session auto-resume/
           set_session_auto_resume_enabled(!session_auto_resume_enabled?)
           runtime_output("Session auto-resume #{session_auto_resume_enabled? ? "enabled" : "disabled"}.")
@@ -237,7 +249,12 @@ module Kward
           "Overlay alignment (#{settings["alignment"]})",
           "Overlay width (#{settings["width"]})",
           "#{composer_busy_help? ? "Hide" : "Show"} busy help (currently #{on_off(composer_busy_help?)})",
-          "#{banner_enabled? ? "Hide" : "Show"} startup banner (currently #{on_off(banner_enabled?)})",
+          "Tab keybindings (#{composer_tab_keybindings})",
+          "Editor mode (#{editor_mode})",
+          "Editor line numbers (#{editor_line_numbers})",
+          "#{editor_auto_close_pairs_enabled? ? "Disable" : "Enable"} auto-close pairs (currently #{on_off(editor_auto_close_pairs_enabled?)})",
+          "#{editor_soft_wrap_enabled? ? "Disable" : "Enable"} soft-wrap (currently #{on_off(editor_soft_wrap_enabled?)})",
+          "#{editor_bar_cursor_enabled? ? "Disable" : "Enable"} bar cursor (currently #{on_off(editor_bar_cursor_enabled?)})",
           "#{session_auto_resume_enabled? ? "Disable" : "Enable"} session auto-resume (currently #{on_off(session_auto_resume_enabled?)})",
           "Back"
         ]
@@ -247,8 +264,82 @@ module Kward
         ConfigFiles.composer_busy_help?(safely_read_config.to_h)
       end
 
-      def banner_enabled?
-        ConfigFiles.banner_enabled?(safely_read_config.to_h)
+      def composer_tab_keybindings
+        ConfigFiles.composer_tab_keybindings(safely_read_config.to_h)
+      end
+
+      def configure_tab_keybindings
+        selected = @prompt.select("Tab keybindings", tab_keybinding_choices, title: "Settings")
+        value = selected.to_s.split.first.to_s.downcase
+        return unless %w[auto ctrl alt].include?(value)
+
+        update_nested_config("composer", "tab_keybindings" => value)
+        runtime_output("Tab keybindings set to #{value}. Restart the TUI to apply this setting.")
+      end
+
+      def tab_keybinding_choices
+        current = composer_tab_keybindings
+        %w[auto ctrl alt].map { |value| value == current ? "#{value} (current)" : value }
+      end
+
+      def editor_mode
+        ConfigFiles.editor_mode(safely_read_config.to_h)
+      end
+
+      def configure_editor_mode
+        selected = @prompt.select("Editor mode", editor_mode_choices, title: "Settings")
+        value = selected.to_s.split.first.to_s.downcase
+        return unless %w[modern emacs vibe].include?(value)
+
+        update_nested_config("editor", "mode" => value)
+        runtime_output("Editor mode set to #{value}. New editor buffers will use this mode.")
+      end
+
+      def editor_mode_choices
+        current = editor_mode
+        %w[modern emacs vibe].map { |value| value == current ? "#{value} (current)" : value }
+      end
+
+      def editor_line_numbers
+        ConfigFiles.editor_line_numbers(safely_read_config.to_h)
+      end
+
+      def configure_editor_line_numbers
+        selected = @prompt.select("Editor line numbers", editor_line_number_choices, title: "Settings")
+        value = selected.to_s.split.first.to_s.downcase
+        return unless %w[absolute relative].include?(value)
+
+        update_nested_config("editor", "line_numbers" => value)
+        runtime_output("Editor line numbers set to #{value}.")
+      end
+
+      def editor_line_number_choices
+        current = editor_line_numbers
+        %w[absolute relative].map { |value| value == current ? "#{value} (current)" : value }
+      end
+
+      def editor_auto_close_pairs_enabled?
+        ConfigFiles.editor_auto_close_pairs?(safely_read_config.to_h)
+      end
+
+      def set_editor_auto_close_pairs_enabled(enabled)
+        update_nested_config("editor", "auto_close_pairs" => enabled)
+      end
+
+      def editor_soft_wrap_enabled?
+        ConfigFiles.editor_soft_wrap?(safely_read_config.to_h)
+      end
+
+      def set_editor_soft_wrap_enabled(enabled)
+        update_nested_config("editor", "soft_wrap" => enabled)
+      end
+
+      def editor_bar_cursor_enabled?
+        ConfigFiles.editor_bar_cursor?(safely_read_config.to_h)
+      end
+
+      def set_editor_bar_cursor_enabled(enabled)
+        update_nested_config("editor", "bar_cursor" => enabled)
       end
 
       def session_auto_resume_enabled?
@@ -259,10 +350,6 @@ module Kward
         update_nested_config("composer", "busy_help" => enabled)
       end
 
-      def set_banner_enabled(enabled)
-        update_nested_config("banner", "enabled" => enabled)
-      end
-
       def set_session_auto_resume_enabled(enabled)
         update_nested_config("sessions", "auto_resume" => enabled)
       end
@@ -467,11 +554,7 @@ module Kward
       end
 
       def update_nested_config(section, values)
-        config = ConfigFiles.read_config
-        current = config[section].is_a?(Hash) ? config[section].dup : {}
-        config[section] = current.merge(values)
-        ConfigFiles.write_config(config)
-        config
+        ConfigFiles.update_nested_config(section, values)
       end
 
       def on_off(value)
@@ -518,24 +601,6 @@ module Kward
         runtime_output("Model error: #{e.message}")
       end
 
-      # Writes the openrouter catalog output for the terminal CLI flow.
-      def print_openrouter_catalog
-        unless @client.respond_to?(:openrouter_catalog)
-          runtime_output("OpenRouter catalog is unavailable for this client.")
-          return
-        end
-
-        models = Array(@client.openrouter_catalog)
-        if models.empty?
-          runtime_output("No OpenRouter catalog models available.")
-        else
-          ids = models.map { |model| model[:id] || model["id"] || model }.map(&:to_s).reject(&:empty?)
-          runtime_output((["OpenRouter catalog:"] + ids).join("\n"))
-        end
-      rescue StandardError => e
-        runtime_output("OpenRouter catalog error: #{e.message}")
-      end
-
       def configure_reasoning(conversation = nil)
         unless model_overlay_available?
           runtime_output("Reasoning overlay is unavailable in this prompt.")
@@ -556,10 +621,7 @@ module Kward
         effort, = choices.find { |_value, label| selected.to_s.downcase.start_with?(label.downcase) }
         raise "Reasoning effort must be one of: #{choices.map(&:first).join(", ")}" unless effort
 
-        ConfigFiles.update_config(ModelInfo.reasoning_config_key_for_provider(current_model_provider) => effort)
-        reload_client_config
-        refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        set_reasoning_effort(effort, conversation, provider: provider)
       rescue StandardError => e
         runtime_output("Reasoning error: #{e.message}")
       end
@@ -639,6 +701,123 @@ module Kward
         end
       end
 
+      REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5
+
+      def cycle_reasoning(conversation = current_footer_conversation, direction: :next, persist: :immediate)
+        provider = conversation&.provider || current_model_provider
+        model = conversation&.model || current_model_id
+        choices = ModelInfo.reasoning_effort_choices(provider, model)
+        return false if choices.empty?
+
+        current = (pending_reasoning_effort(provider) || conversation&.reasoning_effort || current_reasoning_effort).to_s
+        current_index = choices.index { |effort, _label| effort == current }
+        current_index ||= direction == :previous ? 0 : -1
+        offset = direction == :previous ? -1 : 1
+        effort = choices[(current_index + offset) % choices.length].first
+        persist == :debounced ? apply_reasoning_effort(effort, conversation, provider: provider) : set_reasoning_effort(effort, conversation, provider: provider)
+        true
+      rescue StandardError => e
+        runtime_output("Reasoning error: #{e.message}")
+        false
+      end
+
+      def set_reasoning_effort(effort, conversation = nil, provider: nil)
+        @pending_reasoning_config_mutex.synchronize { @pending_reasoning_config = nil }
+        persist_reasoning_config(effort, provider: provider)
+        apply_reasoning_effort(effort, conversation, provider: provider, queue_config: false)
+      end
+
+      def apply_reasoning_effort(effort, conversation = nil, provider: nil, queue_config: true)
+        queue_reasoning_config(effort, provider: provider, conversation: conversation) if queue_config
+        if queue_config
+          update_conversation_reasoning_effort(conversation, effort)
+          refresh_reasoning_status
+        else
+          refresh_conversation_runtime(conversation, reasoning_effort: effort)
+          conversation.persist_runtime_context! if conversation&.respond_to?(:persist_runtime_context!)
+          @prompt.redraw if @prompt.respond_to?(:redraw)
+        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)
+        end
+      end
+
+      def update_conversation_reasoning_effort(conversation, effort)
+        return unless conversation&.respond_to?(:update_runtime_context!)
+
+        conversation.update_runtime_context!(
+          provider: conversation.provider || current_model_provider,
+          model: conversation.model || current_model_id,
+          reasoning_effort: effort,
+          refresh: false
+        )
+      end
+
+      def pending_reasoning_effort(provider)
+        @pending_reasoning_config_mutex.synchronize do
+          pending = @pending_reasoning_config
+          return nil unless pending
+          return nil unless pending[:provider].to_s.downcase == provider.to_s.downcase
+
+          pending[:effort]
+        end
+      end
+
+      def queue_reasoning_config(effort, provider: nil, conversation: nil)
+        pending = {
+          effort: effort,
+          provider: provider || current_model_provider,
+          conversation: conversation,
+          deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + REASONING_CONFIG_DEBOUNCE_SECONDS
+        }
+        @pending_reasoning_config_mutex.synchronize { @pending_reasoning_config = pending }
+        schedule_reasoning_config_flush
+      end
+
+      def schedule_reasoning_config_flush
+        return if @pending_reasoning_config_thread&.alive?
+
+        @pending_reasoning_config_thread = Thread.new do
+          loop do
+            sleep REASONING_CONFIG_DEBOUNCE_SECONDS
+            break if flush_pending_reasoning_config(force: false)
+            break unless @pending_reasoning_config_mutex.synchronize { @pending_reasoning_config }
+          end
+        rescue StandardError => e
+          runtime_output("Reasoning error: #{e.message}")
+        end
+      end
+
+      def flush_pending_reasoning_config(force: true, conversation: nil)
+        pending = nil
+        @pending_reasoning_config_mutex.synchronize do
+          pending = @pending_reasoning_config
+          return false unless pending
+
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          return false if !force && now < pending[:deadline].to_f
+
+          @pending_reasoning_config = nil
+        end
+        persist_reasoning_config(pending[:effort], provider: pending[:provider])
+        conversation ||= pending[:conversation]
+        if conversation&.reasoning_effort.to_s == pending[:effort].to_s
+          refresh_conversation_runtime(conversation, reasoning_effort: pending[:effort])
+          conversation.persist_runtime_context! if conversation.respond_to?(:persist_runtime_context!)
+        end
+        true
+      end
+
+      def persist_reasoning_config(effort, provider: nil)
+        ConfigFiles.update_config(ModelInfo.reasoning_config_key_for_provider(provider || current_model_provider) => effort)
+        reload_client_config
+      end
+
       def reasoning_choices(choices, conversation = current_footer_conversation)
         current = (conversation.reasoning_effort || (@client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT)).to_s
         choices.map do |effort, label|