openclacky 1.5.20 → 1.5.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a87f3bff7a9f13d77ae6ae11ccc67a67a6429d596d922309e3f3847469b240f4
-  data.tar.gz: 6f7043a63e27dfb922bac4e586ec19c6d0659efb75ba9ef7e1b522b1a16b9410
+  metadata.gz: a120f8d1189892876508f1c49309b7e4a21652c9293499211444b6e42770f649
+  data.tar.gz: 2c02a199d26ae835426fa5ce8fb65665ac3c342aa7b717337c3e72470fd868f7
 SHA512:
-  metadata.gz: 23cc0c1d6902579a09f2cb3c9b9f692c61dcb485daca62ff226ea6fa1c165afa141fbee8ee51de24e97ec4d7060bc872988c6f8b785575180f821a52e68acc26
-  data.tar.gz: d198a4ed2d6887094fe8f90fc1d13a429cd06008f47859acb7b334804d5d8dfc727f31dba6486ae02d11613bfd0dbe2f0004c83090a8e7f457d31891b4e29fae
+  metadata.gz: aed2dcb3fb47de8a9fc9b20cccbae1f45e70338b37a44e5edbea6ec54c8c3065a27976a2ea5cb2b34ac209cbc3d53c8b6866598deb1a78ff5194ecbef6c0d66e
+  data.tar.gz: 948e67f2dc8f003e55daea5f8e4d790e5368ef58eec63489d317e8be4336e2e04a9db498bdb1e362005a66b502f930a1dd5c88e9da6607863d9dfc4b06986feb

data/CHANGELOG.md

@@ -4,6 +4,55 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
+## [1.5.21] - 2026-10-22
+
+### Added
+- Switch the current session between Manual and Auto approval from the composer, even while a task is running
+- Wait 20 seconds on `ask_user` in auto mode before the agent decides, with the delay configurable through `ask_user_timeout_seconds`
+- Add DeepSeek hosted web search and page fetch
+- Archive every session in a project at once
+- Add MiniMax M3.1 Flash
+- Support multiline terminal commands (#641 - @YeEmrick)
+- Fall back to a dependency-free PNG256 encoder when no image tool is available (#668 - @YeEmrick)
+- Configure where the server writes its PID file (#663)
+- Explain an unreachable license server where the license is entered
+- Point extension publishers at the contributor page
+- Prepare and persist shared feedback requests (#649)
+
+### Improved
+- Downscale oversized browser screenshots so they cost fewer tokens
+- Raise the file reader per-line limit to 8000 characters (#645 - @YeEmrick)
+- Spell out the billing basis in price tooltips
+- Tidy the session search palette and its content-match snippets
+
+### Fixed
+- Refresh data management lists after archiving or deleting from the sidebar (#673)
+- Make bulk delete in the recycle bin and archive respect the active filters (#672)
+- Keep routing channel messages to a session after it is archived (#671)
+- Stop long terminal commands from echoing a duplicated wrapped tail (#670)
+- Page session lists by a server-issued cursor so long lists no longer skip sessions (#669)
+- Refresh the header title when the active session is renamed (#666)
+- Match chat navigator rounds by task id so compression no longer misaligns them (#664)
+- Stop dropping replayed chunks that continue an earlier turn (#662)
+- Apply model card edits to a running session immediately (#661)
+- Keep the attachment strip inside the new-session composer card (#659)
+- Keep the /#new draft name out of sessions created by a quick action (#658)
+- Keep the Default reasoning choice intact after reopening settings
+- Suggest switching models when retries are exhausted
+- Correct MiniMax-M3 rates with its 512K tier
+- Complete MiniMax Flash effort handling and retire the legacy Ollama choices (#655 - @octo-patch)
+- Drop tool results with a blank call id before sending
+- Preserve response headers when handling Anthropic stream errors (#642)
+- Stop compressing oversized recent messages over and over (#643)
+- Localize device-login errors and stop showing the user code
+- Localize the QR lightbox caption and stop clipping its close button
+- Keep web search on the free engine chain unless DeepSeek is chosen
+- Stop extension reloads from serving a stale cached bundle when the manifest path changes
+
+### More
+- Retire the slow GPT-6 and Grok 4.7 aliases from the model picker; their lanes stay routable for existing sessions
+- Bill the Bedrock GPT lane at a 20% markup
+
 ## [1.5.20] - 2026-10-15
 
 ### Added

data/README.md

@@ -207,6 +207,24 @@ Set your **API Key**, **Model**, and **Base URL** (any OpenAI-compatible provide
 
 Supported out of the box: **Claude (Anthropic) · GPT (OpenAI) · DeepSeek · Kimi (Moonshot) · MiniMax · OpenRouter** — or any custom endpoint.
 
+In Web, use the permission selector above the message box to switch the current
+session between **Manual** and **Auto**, including while running. The choice
+is saved for that session. Running tools finish normally; subsequent actions use
+the new mode. Switching to Manual stops an active question countdown. Auto
+approve runs tools without approval.
+
+In auto-approve mode, CLI and Web wait 20 seconds after `ask_user` before the
+agent decides how to continue. Typing or selecting an answer cancels the timer
+and waits for submission. Configure the duration in `~/.clacky/config.yml`:
+
+```yaml
+settings:
+  ask_user_timeout_seconds: 20
+```
+
+Use a non-negative integer (seconds); `0` continues immediately. Missing or
+invalid values use 20 seconds. Other permission modes wait for an answer.
+
 ## Coding use case
 
 OpenClacky works as a general AI coding assistant — scaffold full-stack apps, add features, or explore unfamiliar codebases:

data/lib/clacky/agent/chunk_index.rb

@@ -40,6 +40,7 @@ module Clacky
         rounds = []
         nested = []
         section_count = 0
+        continuation_start = nil
         user_start = nil
         user_task_id = nil
         archived_at = nil
@@ -60,6 +61,7 @@ module Clacky
             header = chunk_section_header(text, directory)
             if header
               section_count += 1
+              continuation_start ||= start
               nested << header[:nested_chunk] if header[:nested_chunk]
               user_start = header[:role] == "user" ? start : nil
               user_task_id = header[:role] == "user" ? header[:task_id] : nil
@@ -78,7 +80,12 @@ module Clacky
           end
           rounds.last[:length] = position - rounds.last[:start] if rounds.any?
         end
-        { rounds: rounds, nested: nested, section_count: section_count,
+        # Compression can cut mid-turn: sections before the first user turn continue the previous turn.
+        continuation_end = rounds.any? ? rounds.first[:start] : position
+        if continuation_start && continuation_end > continuation_start
+          continuation_range = { start: continuation_start, length: continuation_end - continuation_start }
+        end
+        { rounds: rounds, nested: nested, section_count: section_count, continuation_range: continuation_range,
           base_time: (archived_at || File.mtime(path)).to_f }
       end
     end

data/lib/clacky/agent/feedback.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Clacky
+  class Agent
+    module Feedback
+      # Extensions prepare a single immutable snapshot before the UI or its
+      # countdown sees it. The same snapshot becomes the model's tool result.
+      private def prepare_feedback_request(call, result, assistant_message:)
+        args = call[:arguments].is_a?(String) ? JSON.parse(call[:arguments]) : call[:arguments]
+        request = {
+          request_id: call[:id].to_s,
+          questions: Tools::AskUser.normalize_questions(args),
+          context: Tools::AskUser.fetch_key(args, :context).to_s
+        }
+        @hooks.trigger(:prepare_feedback, request)
+        check_stale!
+        request[:request_id] = call[:id].to_s
+        request[:questions] = Tools::AskUser.normalize_questions(request)
+        raise ArgumentError, "Feedback preparation removed all questions" if request[:questions].empty?
+
+        request[:context] = request[:context].to_s
+        request[:answer_context] = request[:answer_context].to_s
+        @history.attach_feedback_request(message: assistant_message, tool_call_id: call[:id], request: request)
+        result[:message] = [Tools::AskUser.render_text(request[:questions], request[:context]),
+                            request[:answer_context]].reject(&:empty?).join("\n\n")
+        request.reject { |key, _| key == :answer_context }
+      end
+    end
+  end
+end

data/lib/clacky/agent/history_navigation.rb

@@ -11,7 +11,7 @@ module Clacky
         sources = navigation_sources
         manifest = sources.map do |source|
           entry = { key: source[:key], version: source[:version], count: navigation_source_count(source),
-                    volatile: !!source[:rounds] || source[:continuation].to_a.any? }
+                    volatile: !!source[:rounds] || source[:continuation].to_a.any? || source[:continuation_ranges].to_a.any? }
           if source[:rounds]
             entry[:identities] = source[:rounds].map { |round| round[:user_msg].values_at(:created_at, :task_id) }
           else
@@ -144,6 +144,13 @@ module Clacky
         end
         chunks.uniq.each { |path| append_source.call(path) }
         @chunk_index_mutex&.synchronize { @chunk_indexes&.delete_if { |path, _| !visited.include?(path) } }
+        owner = nil
+        sources.each do |source|
+          if owner && source[:index][:continuation_range]
+            (owner[:continuation_ranges] ||= []) << { path: source[:path], index: source[:index] }
+          end
+          owner = source if navigation_source_count(source).positive?
+        end
         last_archive = sources.reverse_each.find { |source| navigation_source_count(source).positive? }
         last_archive[:continuation] = leading if last_archive
         version = rounds.map { |round| round[:user_msg].values_at(:created_at, :task_id) }.hash.to_s
@@ -201,8 +208,15 @@ module Clacky
           end
           result
         end
-        if rounds.any? && offset + length == count && source[:continuation]
-          rounds.last[:events].concat(source[:continuation])
+        if rounds.any? && offset + length == count
+          Array(source[:continuation_ranges]).each do |entry|
+            events = parse_chunk_md_events(entry[:path], excluded_paths: siblings,
+              byte_range: entry[:index][:continuation_range], index: entry[:index])
+            raise ArgumentError, "History changed while reading" unless chunk_file_version(entry[:path]) == entry[:index][:version]
+
+            rounds.last[:events].concat(events)
+          end
+          rounds.last[:events].concat(source[:continuation]) if source[:continuation]
         end
         rounds.each { |round| round[:events].reject! { |event| event[:compressed_summary] } }
         rounds.each_with_index do |round, position|

data/lib/clacky/agent/hook_manager.rb

@@ -5,6 +5,7 @@ module Clacky
     HOOK_EVENTS = [
       :before_tool_use,
       :after_tool_use,
+      :prepare_feedback,
       :on_tool_error,
       :on_start,
       :on_complete,
@@ -34,6 +35,10 @@ module Clacky
     # call `agent.emit_event(...)`. Blocks are procs — those declaring fewer
     # params (`|call|`, `|call, result|`) silently ignore extra arguments.
     # Start/complete append context after the agent. Completion is observation-only.
+    # prepare_feedback receives (request, agent) after tool tracking, before UI
+    # display/countdown. It may extend questions, display context and model-only
+    # answer_context in place; answer_context is never sent to UI subscribers.
+    # return values are ignored. Keep work bounded; no separate UI events.
     def trigger(event, *args)
       validate_event!(event)
       # Keep payload hashes positional: Ruby 2.6 otherwise promotes their keys
@@ -46,7 +51,7 @@ module Clacky
           callback_args = [*args, @agent]
           callback_args << context.dup if context
           hook_result = hook.call(*callback_args)
-          next if event == :on_complete
+          next if [:on_complete, :prepare_feedback].include?(event)
           next unless hook_result.is_a?(Hash)
           # First deny wins and stops the chain: a weaker later verdict must
           # never clobber a stronger earlier one, and the first deny's reason

data/lib/clacky/agent/llm_caller.rb

@@ -48,6 +48,7 @@ module Clacky
       private def call_llm(agent_upstream_fails: nil, agent_upgrade_fails: nil)
         # Transition :fallback_active → :probing if cooling-off has expired.
         @config.maybe_start_probing
+        refresh_client_if_card_changed!
 
         tools_to_send = @tool_registry.all_definitions
 

data/lib/clacky/agent/message_compressor_helper.rb

@@ -246,6 +246,25 @@ module Clacky
         # Note: we need to remove the compression instruction message we just added
         original_messages = @history.to_a[0..-2]  # All except the last (compression instruction)
 
+        # Keep the usual recent messages unless they would immediately trigger
+        # compression again. The summary covers all original_messages, so any
+        # dropped recent messages can safely join the archive below.
+        [nil, 10, 0].each do |count|
+          if count
+            compression_context[:recent_messages] = get_recent_messages_with_tool_pairs(compression_context[:recent_messages], count)
+          end
+          candidate = @message_compressor.rebuild_with_compression(
+            compressed_content,
+            original_messages: original_messages,
+            recent_messages: compression_context[:recent_messages],
+            pulled_back_messages: compression_context[:pulled_back_messages] || []
+          )
+          break if MessageHistory.new(candidate).estimate_tokens < @config.compression_threshold &&
+                   candidate.size < @config.message_count_threshold
+
+          raise "History still exceeds compression thresholds after summarization" if count == 0
+        end
+
         # Archive compressed messages to a chunk MD file before discarding them.
         #
         # IMPORTANT: chunk_index and previous_chunks MUST come from disk, not from
@@ -309,7 +328,7 @@ module Clacky
           { basename: c[:basename], path: c[:path], topics: c[:topics] }
         end
 
-        @history.replace_all(@message_compressor.rebuild_with_compression(
+        rebuilt_messages = @message_compressor.rebuild_with_compression(
           compressed_content,
           original_messages: original_messages,
           recent_messages: compression_context[:recent_messages],
@@ -317,7 +336,14 @@ module Clacky
           topics: topics,
           previous_chunks: previous_chunks,
           pulled_back_messages: compression_context[:pulled_back_messages] || []
-        ))
+        )
+        # Archive references also consume context; never re-enter compression
+        # indefinitely if even the final rebuilt history cannot fit.
+        if MessageHistory.new(rebuilt_messages).estimate_tokens >= @config.compression_threshold ||
+           rebuilt_messages.size >= @config.message_count_threshold
+          raise "History still exceeds compression thresholds after summarization"
+        end
+        @history.replace_all(rebuilt_messages)
 
         # Reset to the estimated size of the rebuilt (small) history.
         # The compression call_llm reported the OLD large token count, so

data/lib/clacky/agent/session_serializer.rb

@@ -43,6 +43,9 @@ module Clacky
         # Restore project association (nil = no project)
         @project_id = session_data[:project_id]
 
+        mode_override = session_data.dig(:config, :permission_mode_override)
+        self.permission_mode = mode_override if %w[confirm_all auto_approve].include?(mode_override)
+
         # Restore standing goal state (nil = no goal). The judge client/model
         # are rebound lazily via #goal_manager when first accessed after
         # restore — but the persisted state must be reattached here so a
@@ -283,6 +286,7 @@ module Clacky
             # model_name is saved so the session can restore its original model on restart
             # (falling back to the current default if the model no longer exists).
             permission_mode: @config.permission_mode.to_s,
+            permission_mode_override: @permission_mode_override,
             enable_compression: @config.enable_compression,
             enable_idle_compression: @config.enable_idle_compression,
             enable_prompt_caching: @config.enable_prompt_caching,
@@ -430,7 +434,7 @@ module Clacky
       # @param chunk_path [String] Path to the chunk md file
       # @return [Array<Hash>] rounds array (may be empty if file missing/unreadable)
       private def parse_chunk_md_to_rounds(chunk_path, visited: Set.new, excluded_paths: Set.new,
-                                          byte_range: nil, index: nil, round_offset: 0)
+                                          byte_range: nil, index: nil, round_offset: 0, continue_round: nil)
         return [] unless chunk_path
 
         # 1. Try the stored absolute path first (same machine, normal case).
@@ -506,7 +510,7 @@ module Clacky
 
         # Group into rounds: each user section starts a new round
         rounds        = []
-        current_round = nil
+        current_round = continue_round
         round_index   = 0
 
         sections.each do |sec|
@@ -606,6 +610,14 @@ module Clacky
         []
       end
 
+      # Parse a chunk byte range holding only the tail of a turn that began in an earlier chunk.
+      private def parse_chunk_md_events(chunk_path, byte_range:, index:, excluded_paths: Set.new)
+        round = { events: [] }
+        parse_chunk_md_to_rounds(chunk_path, excluded_paths: excluded_paths, byte_range: byte_range,
+          index: index, continue_round: round)
+        round[:events]
+      end
+
 
       # Pull lightweight attachment badge metadata out of a chunk section.
       # The marker is internal archive data and must not appear in replayed text.
@@ -779,6 +791,12 @@ module Clacky
             # Special handling: the ask_user question is shown as an assistant
             # message (matching real-time behavior), not as a tool call.
             if Clacky::Tools::AskUser.feedback_tool?(name)
+              prepared = msg[:feedback_requests] || {}
+              request = prepared[tc[:id].to_s] || prepared[tc[:id].to_s.to_sym]
+              if request
+                ui.show_tool_call(name, request.reject { |key, _| key.to_s == "answer_context" })
+                next
+              end
               questions = Clacky::Tools::AskUser.normalize_questions(args)
               context   = Clacky::Tools::AskUser.fetch_key(args, :context).to_s
               first     = questions.first

data/lib/clacky/agent.rb

@@ -24,6 +24,7 @@ require_relative "agent/skill_evolution"
 require_relative "agent/skill_reflector"
 require_relative "agent/skill_auto_creator"
 require_relative "agent/fake_tool_call_detector"
+require_relative "agent/feedback"
 require_relative "agent/goal_state"
 require_relative "agent/goal_manager"
 
@@ -31,6 +32,7 @@ module Clacky
   class Agent
     # Include all functionality modules
     include MessageCompressorHelper
+    include Feedback
     include ToolExecutor
     include CostTracker
     include SessionSerializer
@@ -57,6 +59,13 @@ module Clacky
     attr_accessor :archived_at
 
     REASONING_EFFORTS = %w[low medium high xhigh max].freeze
+    # Sessionbar/config values meaning "no explicit level". They stay a string
+    # instead of collapsing to nil so format adapters can tell an explicit
+    # "default" apart from "user never chose": for models whose provider
+    # default is the deepest level (MiniMax M3.1-Flash, GLM-5.3) the adapters
+    # map this value to their lightest effort.
+    REASONING_DEFAULT = "off"
+    REASONING_DEFAULT_ALIASES = %w[off none disabled nothink].freeze
     MAX_VIDEO_UNDERSTANDING_BYTES = Utils::FileProcessor::MAX_FILE_BYTES
     MAX_VIDEO_BASE64_BYTES = 45 * 1024 * 1024
     MAX_VIDEO_DESCRIPTION_CHARS = 500
@@ -71,6 +80,16 @@ module Clacky
       @config&.permission_mode&.to_s || ""
     end
 
+    # Persist an explicit session choice separately from temporary goal mode.
+    def permission_mode=(value)
+      mode = value.to_s
+      raise ArgumentError, "Invalid permission mode" unless %w[confirm_all auto_approve].include?(mode)
+      @permission_mode_override = mode
+      @config.permission_mode = mode.to_sym
+      @pre_goal_permission_mode = nil
+      notify_permission_mode_change(mode.to_sym)
+    end
+
     def reasoning_effort=(value)
       @reasoning_effort = normalize_reasoning_effort(value)
     end
@@ -78,7 +97,8 @@ module Clacky
     private def normalize_reasoning_effort(value)
       return nil if value.nil?
       str = value.to_s.strip.downcase
-      return nil if str.empty? || str == "off" || str == "none"
+      return nil if str.empty?
+      return REASONING_DEFAULT if REASONING_DEFAULT_ALIASES.include?(str)
       return str if REASONING_EFFORTS.include?(str)
       nil
     end
@@ -88,6 +108,7 @@ module Clacky
     def initialize(client, config, working_dir:, ui:, profile:, session_id:, source:)
       @client = client  # Client for current model
       @config = config.is_a?(AgentConfig) ? config : AgentConfig.new(config)
+      @client_options = @config.client_options
       @agent_profile = AgentProfile.load(profile)
       @source = source.to_sym  # :manual | :cron | :channel
       @channel_info = nil  # { platform:, user_id:, user_name:, chat_id: } set by ChannelManager
@@ -117,7 +138,7 @@ module Clacky
       @task_cost_source = :estimated  # Track cost source for current task
       @previous_total_tokens = 0  # Track tokens from previous iteration for delta calculation
       @latest_latency = nil  # Most recent LLM call's latency metrics (see Client#send_messages_with_tools)
-      @reasoning_effort = nil  # Per-session reasoning effort override; nil = provider default
+      @reasoning_effort = REASONING_DEFAULT  # Sessionbar shows "Default" for a fresh session; adapters resolve it per model
       @ui = ui  # UIController for direct UI interaction
       @debug_logs = []  # Debug logs for troubleshooting
       @input_mutex = Mutex.new
@@ -239,23 +260,25 @@ module Clacky
     # Rebuild the underlying Client (and dependent components) to pick up
     # credentials/model name from the currently-selected model in @config.
     private def rebuild_client_for_current_model!
-      entry = @config.current_model
-      @client = Clacky::Client.new(
-        @config.api_key,
-        base_url: @config.base_url,
-        model: @config.model_name,
-        anthropic_format: @config.anthropic_format?,
-        api_format: @config.api_format,
-        provider_id: @config.provider_id_for(entry),
-        capabilities: entry && entry["capabilities"]
-      )
-      # Update message compressor with new client and model
-      @message_compressor = MessageCompressor.new(@client, model: current_model)
+      build_client!
 
       # Inject a new session context to notify the AI of the model switch
       inject_session_context
     end
 
+    private def build_client!
+      @client_options = @config.client_options
+      opts = @client_options.dup
+      @client = Clacky::Client.new(opts.delete(:api_key), **opts)
+      # Update message compressor with new client and model
+      @message_compressor = MessageCompressor.new(@client, model: current_model)
+    end
+
+    # The shared model card can be edited (Settings, config reload) under a live session.
+    private def refresh_client_if_card_changed!
+      build_client! unless @config.client_options == @client_options
+    end
+
     # Change the working directory for this session
     # Injects a new session context to notify the AI of the directory change
     def change_working_dir(new_dir)
@@ -497,7 +520,7 @@ module Clacky
       @name = new_name.to_s.strip
     end
 
-    def run(user_input, files: nil, reference_contexts: nil, display_text: nil, created_at: nil, references_display: nil, feedback: nil)
+    def run(user_input, files: nil, reference_contexts: nil, display_text: nil, created_at: nil, references_display: nil)
       # Initialized here (not mid-body) because run's rescue/ensure are
       # method-level and must be able to reference them on any exit path.
       result = nil
@@ -534,7 +557,6 @@ module Clacky
 
       # Start new task for Time Machine
       task_id = start_new_task(title: display_text.to_s.empty? ? user_input.to_s : display_text.to_s)
-      @feedback = feedback
       run_context = { session_id: @session_id, run_id: task_id.to_s,
                       source: @source.to_s, input_created_at: created_at,
                       observed_at: Time.now.utc.iso8601(6), status: "running" }
@@ -770,7 +792,7 @@ module Clacky
         @ui&.show_token_usage(response[:token_usage]) if response[:token_usage]
 
         # Act: Execute tool calls
-        action_result = act(response[:tool_calls])
+        action_result = act(response[:tool_calls], assistant_message: response.delete(:history_message))
 
         # Check if ask_user was called
         if action_result[:awaiting_feedback]
@@ -1330,7 +1352,6 @@ module Clacky
       end
       entries.each do |entry|
         options = entry[:options].dup
-        options.delete(:feedback)
         source = options.delete(:source) || :web
         history_size = @history.size
         begin
@@ -1537,7 +1558,7 @@ module Clacky
       # "reasoning_content must be passed back" contract.
       msg[:reasoning_content] = response[:reasoning_content] if response[:reasoning_content]
       check_stale!
-      @history.append(msg)
+      @history.append(msg) { |stored_message| response[:history_message] = stored_message }
 
       # Close the thinking spinner before returning. The caller (run loop)
       # is about to render the assistant message and/or tool invocations,
@@ -1561,7 +1582,7 @@ module Clacky
       raise Clacky::AgentInterrupted, "Task superseded by a newer task on another thread"
     end
 
-    private def act(tool_calls)
+    private def act(tool_calls, assistant_message: nil)
       return { denied: false, feedback: nil, tool_results: [], awaiting_feedback: false } unless tool_calls
 
       denied = false
@@ -1742,31 +1763,21 @@ module Clacky
           # result path so the model sees the error and can retry.
           if Tools::AskUser.feedback_tool?(call[:name]) &&
               result.is_a?(Hash) && result[:awaiting_feedback]
-            # Pass the raw call arguments to show_tool_call so the WebUI controller
-            # can extract the questions and emit a "request_feedback" event
-            # (renders as a clickable card in the browser).
-            # Fallback UIs (terminal, IM channels) receive the formatted text message.
-            if @feedback && @ui.respond_to?(:wait_for_feedback)
-              questions = Tools::AskUser.normalize_questions(args)
-              question = questions.first
-              label = if questions.one? && !question[:multi] && question[:recommended]
-                question[:options][question[:recommended]]
-              end
-              answer, feedback_options = @ui.wait_for_feedback(timeout_seconds: @feedback[:timeout_seconds], question: question[:question], recommended_label: label) do
-                @ui.show_tool_call(call[:name], call[:arguments])
-              end
-              check_stale!
-              result[:awaiting_feedback] = awaiting_feedback = !answer
-              enqueue_input("Answer: #{answer}", delivery: :steer, created_at: Time.now.to_f, **(feedback_options || {})) if answer
-            elsif @config.permission_mode == :auto_approve
-              @ui&.show_tool_call(call[:name], call[:arguments])
+            # Prepare and persist the complete request before displaying it or
+            # starting the wait. Extensions and native questions share one result.
+            request = prepare_feedback_request(call, result, assistant_message: assistant_message)
+            @ui&.show_tool_call(call[:name], request)
+
+            if @config.permission_mode == :auto_approve
               # auto_approve means the agent runs unattended by default, but a
               # human MAY be watching the terminal. Show a short interactive
               # countdown: if the user steps in, hand control over and wait for
               # their answer; otherwise auto-decide and keep going.
-              countdown = @ui&.request_feedback_with_countdown(seconds: 10)
+              countdown = @ui&.request_feedback_with_countdown(seconds: @config.ask_user_timeout_seconds)
 
-              if @ui.nil? || countdown == :timeout
+              if countdown == :timeout && @config.permission_mode != :auto_approve
+                awaiting_feedback = true
+              elsif @ui.nil? || countdown == :timeout
                 result = result.merge(
                   auto_reply: "No user is available. Please make a reasonable decision based on the context and continue."
                 )
@@ -1782,7 +1793,6 @@ module Clacky
               end
             else
               # confirm_all / confirm_safes — a human is present, truly wait for user input.
-              @ui&.show_tool_call(call[:name], call[:arguments])
               awaiting_feedback = true
             end
           else
@@ -2105,8 +2115,11 @@ module Clacky
       @tool_registry.register(Tools::Edit.new)
       @tool_registry.register(Tools::Glob.new)
       @tool_registry.register(Tools::Grep.new)
-      @tool_registry.register(Tools::WebSearch.new)
-      @tool_registry.register(Tools::WebFetch.new)
+      [Tools::WebSearch, Tools::WebFetch].each do |klass|
+        tool = klass.new
+        tool.agent = self
+        @tool_registry.register(tool)
+      end
       @tool_registry.register(Tools::TodoManager.new)
       @tool_registry.register(Tools::AskUser.new)
       @tool_registry.register(Tools::InvokeSkill.new)