openclacky 1.5.9 → 1.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 565adf42059330fb821c57cb3b1200035fb866a1f2190ca87e093bc34de9edc0
-  data.tar.gz: 89db4dd987f39d4b77acd52121aa31bef54858f81d614557ac7b9984a1066ba0
+  metadata.gz: '038138bc72f3f740ed3ccee6da3f6464f80fd0cf1d0466788879a4472ac127b1'
+  data.tar.gz: dfb75e0b2e832e923c34a1f5e61b4a005bd29435f3724763128b0fadc0b6ec1b
 SHA512:
-  metadata.gz: e3bbb8988d833e3c6e6ce4cd13da64111e2ee15b400c2eb34b78bca9f51ae80525336baf923ba18cdbf85b5320d542f8050567792e7d5a437b28e2d09d29729d
-  data.tar.gz: ae508f3bdb44a35b8edd0c89ebcc53a64d3f7340214ded6c8dd47d0c757c66f5f99700f466c86278e8ee0a38ab838b8509c80ba8af2f253653f967b91f52a814
+  metadata.gz: c72531566a2b744a279e54907f750ff67e518963c9d42216dde3cb05048e4c86688dbb2ebfe908b31b7f7df8d2332df0ab0b11e0977ab5c486ca5c83b565eafc
+  data.tar.gz: 584975067a26ebfc123e9f9a7f168ef45aab93f783e91da576510f416554c0ba4598e88064db7f71c0f6a30dfda949a4f36cc35d69aa35973489be800422a6b2

data/.clackyrules

@@ -70,6 +70,7 @@ the CI matrix - a green local `bundle exec rspec` on Ruby 3.x proves nothing abo
 - **IMPORTANT**: When developing new features, write RSpec tests as needed and ensure they pass
 - **DO NOT** write custom test scripts unless explicitly requested by the user
 - **DO NOT** create markdown documentation unless explicitly requested by the user
+- **DO NOT** run RuboCop for verification. `bundle exec rspec` is the only required check; the codebase has many pre-existing offenses, so RuboCop output is noise. Only run it when the user explicitly asks
 - **IMPORTANT**: When testing clacky commands or debugging, always use `bundle exec ruby bin/clacky` instead of the global `clacky` command. The global command loads the system-installed gem version (e.g., `openclacky-0.7.0`), not your local development code
 
 ### Tool Development

data/CHANGELOG.md

@@ -4,6 +4,40 @@ 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.10] - 2026-08-19
+
+### Added
+- Import extensions from a local zip file
+- Per-model API format override (#484 - @kylezhang)
+- Project pinning (pin to top)
+- Copy Session ID action in session menu
+- Price ratio on model switcher panel
+- Model search filter and provider filter dropdown in settings
+- Remark field for model configs
+- Custom vision model config
+- GPT-5.6 Sol/Terra/Luna presets and pricing
+- GLM-5.3 model support
+- Global IM status-messages toggle (default off)
+- Extension-defined tools support; extensions can disable skills
+- Server restart state and HTTP restart flag
+- Actionable web search provider errors
+- Localized display names for broadcast skill commands
+
+### Improved
+- Skill autocomplete dropdown UI with localized source labels
+- Skill auto-creation and evolution reporting refinements
+
+### Fixed
+- MCP: preserve CRLF pairs split across SSE chunk boundaries (#489 - @MohammedAlkindi)
+- Feishu: auto-refresh token and retry when revoked (99991663) (#483 - @chengoak)
+- Preserve head+tail for oversized terminal output (#455 - @shipinliang)
+- openclacky start failed when no TTY
+- Capture master/worker crash logs under LaunchAgent
+- ReferenceError in model modal _syncRemarkField
+- Remark field always visible in model modal
+- api_format field only shown for custom providers and validated before mutating model config
+- Media gen output dir handling
+
 ## [1.5.9] - 2026-08-14
 
 ### Added

data/lib/clacky/agent/memory_updater.rb

@@ -74,7 +74,7 @@ module Clacky
       private def with_memory_update_phase
         return yield unless @ui.respond_to?(:with_phase)
 
-        pid = @ui.phase_start(kind: "memory_update", label: "Updating long-term memory")
+        pid = @ui.phase_start(kind: "memory_update", label: Clacky::I18n.t("phase.memory_update"))
         summary = nil
         begin
           summary = yield
@@ -127,11 +127,6 @@ module Clacky
         # still reflects ONLY the user's task, not the memory update.
         subagent_cost = absorb_subagent_cost(result)
 
-        # A summary is only worth showing if the subagent actually wrote
-        # something. The common "No memory updates needed." path returns nil
-        # so the phase leaves no trace at all.
-        return unless subagent_wrote_memory?(subagent)
-
         "#{result[:iterations]} steps · $#{subagent_cost.round(4)}"
       end
 
@@ -142,43 +137,6 @@ module Clacky
         @config.memory_update_enabled != false
       end
 
-      # Inspect the subagent's history for a successful write/edit tool
-      # call targeting a memory file. Used to decide whether to surface a
-      # "Memory updated" info line (option C — silent when nothing changed).
-      # @param subagent [Clacky::Agent]
-      # @return [Boolean]
-      private def subagent_wrote_memory?(subagent)
-        return false unless subagent.respond_to?(:history) && subagent.history
-
-        subagent.history.to_a.any? do |msg|
-          next false unless msg.is_a?(Hash)
-
-          # Match OpenAI-style tool_calls on assistant messages …
-          tool_calls = msg[:tool_calls] || msg["tool_calls"]
-          if tool_calls.is_a?(Array) && tool_calls.any?
-            next true if tool_calls.any? do |tc|
-              name = tc.dig(:function, :name) || tc.dig("function", "name") || tc[:name] || tc["name"]
-              %w[write edit].include?(name.to_s)
-            end
-          end
-
-          # … and Anthropic-style content blocks with type=tool_use.
-          content = msg[:content] || msg["content"]
-          if content.is_a?(Array)
-            next true if content.any? do |block|
-              block.is_a?(Hash) &&
-                (block[:type] == "tool_use" || block["type"] == "tool_use") &&
-                %w[write edit].include?((block[:name] || block["name"]).to_s)
-            end
-          end
-
-          false
-        end
-      rescue StandardError
-        # Defensive: never let introspection errors break memory update.
-        false
-      end
-
       # Build the memory update prompt for the forked subagent.
       #
       # Architecture:

data/lib/clacky/agent/session_serializer.rb

@@ -392,7 +392,9 @@ module Clacky
           }
           all_files = image_files + disk_files
           ui.show_user_message(raw_text, created_at: msg[:created_at], files: all_files,
-                               editable: round[:editable] != false)
+                               editable: round[:editable] != false,
+                               skill_command: msg[:skill_command],
+                               skill_command_display: msg[:skill_command_display])
           replay_ext_events(msg, ui)
 
           round[:events].each do |ev|

data/lib/clacky/agent/skill_auto_creator.rb

@@ -22,8 +22,10 @@ module Clacky
 
         # Fork an isolated subagent to evaluate + create — does NOT touch main history
         subagent = fork_subagent
-        subagent.run(build_skill_creation_prompt)
-        nil
+        result = subagent.run(build_skill_creation_prompt)
+        cost = absorb_subagent_cost(result)
+
+        "$#{cost.round(4)}"
       end
 
       # Determine if this task is a candidate for skill auto-creation
@@ -84,19 +86,20 @@ module Clacky
           ## Action
 
           If **ALL** criteria are met:
-            → Call invoke_skill with:
+            → Call invoke_skill with EXACTLY these two parameters:
                - skill_name: "skill-creator"
-               - task: A clear description of what to automate and how (be specific)
-               - mode: "quick" (enables fast auto-creation without user interviews)
-               - suggested_name: A descriptive identifier (lowercase, hyphens OK)
+               - task: A clear description of what to automate and how (be specific).
+                 Start it with "Quick mode:" and state the suggested skill name
+                 (lowercase, hyphens OK) inside this text.
+
+          invoke_skill accepts ONLY skill_name and task. Passing any other
+          parameter raises an ArgumentError and the creation fails.
 
           Example invocation:
           ```
           invoke_skill(
             skill_name: "skill-creator",
-            task: "Create a skill to extract and summarize content from URLs. The skill should: 1) fetch the URL content, 2) parse the main text, 3) generate a concise summary. Expected input: URL. Expected output: markdown summary.",
-            mode: "quick",
-            suggested_name: "url-summarizer"
+            task: "Quick mode: create a skill named 'url-summarizer' (no user interviews). It should extract and summarize content from URLs: 1) fetch the URL content, 2) parse the main text, 3) generate a concise summary. Expected input: URL. Expected output: markdown summary."
           )
           ```
 

data/lib/clacky/agent/skill_evolution.rb

@@ -26,11 +26,12 @@ module Clacky
       def run_skill_evolution_hooks
         return unless skill_evolution_enabled?
         return if @is_subagent
+        # Preconditions unmet (short task, default skill, ...): the evolution
+        # never ran, so there is nothing to report — stay completely silent.
+        return unless skill_evolution_has_work?
 
         with_skill_evolution_phase do
-          if !skill_evolution_has_work?
-            Clacky::I18n.t("phase.skipped")
-          elsif @skill_execution_context
+          if @skill_execution_context
             maybe_reflect_on_skill
           else
             maybe_create_skill_from_task

data/lib/clacky/agent/skill_manager.rb

@@ -82,7 +82,7 @@ module Clacky
           return { matched: true, found: false, skill_name: skill_name, reason: :not_user_invocable, skill: skill }
         end
 
-        if @agent_profile && !skill.allowed_for_agent?(@agent_profile.name)
+        if @agent_profile && !@agent_profile.skill_allowed?(skill)
           return { matched: true, found: false, skill_name: skill_name, reason: :agent_not_allowed, skill: skill }
         end
 
@@ -266,22 +266,20 @@ module Clacky
       # is injected instructing the LLM to inform the user in their own language and
       # suggest similar skills — no error is raised, the LLM handles the reply.
       #
-      # @param user_input [String] Raw user input
+      # @param skill_command [Hash] Result of parse_skill_command for the user input
       # @param task_id [Integer] Current task ID (for message tagging)
       # @return [void]
-      def inject_skill_command_as_assistant_message(user_input, task_id)
-        result = parse_skill_command(user_input)
-
+      def inject_skill_command_as_assistant_message(skill_command, task_id)
         # Not a slash command at all — nothing to do
-        return unless result[:matched]
+        return unless skill_command[:matched]
 
-        skill_name = result[:skill_name]
+        skill_name = skill_command[:skill_name]
 
         # Slash command recognised but skill could not be dispatched — inject an
         # LLM-facing notice so the model explains the situation to the user in
         # their own language instead of silently ignoring the command.
-        unless result[:found]
-          notice = case result[:reason]
+        unless skill_command[:found]
+          notice = case skill_command[:reason]
           when :not_found
             suggestions = suggest_similar_skills(skill_name)
             msg = "[SYSTEM] The user entered the slash command /#{skill_name} but no matching skill was found. " \
@@ -302,8 +300,8 @@ module Clacky
           return
         end
 
-        skill     = result[:skill]
-        arguments = result[:arguments]
+        skill     = skill_command[:skill]
+        arguments = skill_command[:arguments]
 
         # fork_agent skills run in an isolated subagent
         if skill.fork_agent?
@@ -443,7 +441,7 @@ module Clacky
       def filter_skills_by_profile(skills)
         return skills unless @agent_profile
 
-        skills.select { |skill| skill.allowed_for_agent?(@agent_profile.name) }
+        skills.select { |skill| @agent_profile.skill_allowed?(skill) }
       end
 
       # Build template context for skill content expansion.

data/lib/clacky/agent/skill_reflector.rb

@@ -26,11 +26,11 @@ module Clacky
         subagent = fork_subagent
         result = subagent.run(build_skill_reflection_prompt(skill_name))
 
-        cost = absorb_subagent_cost(result) if result
+        cost = absorb_subagent_cost(result)
 
         @skill_execution_context = nil
 
-        "#{skill_name} · $#{cost.round(4)}" if cost
+        "#{skill_name} · $#{cost.round(4)}"
       end
 
       private def should_reflect_on_skill?

data/lib/clacky/agent.rb

@@ -149,6 +149,11 @@ module Clacky
       # Register built-in tools
       register_builtin_tools
 
+      # Register tools contributed by ext.yml containers (contributes.tools).
+      # Each tool file must define at least one Clacky::Tools::Base subclass —
+      # every subclass defined in that file is instantiated and registered.
+      register_extension_tools
+
       # Load declarative shell hooks from ~/.clacky/hooks.yml. Entries with
       # `type: rewrite` use the rich JSON protocol (updatedInput rewrite);
       # entries without `type` use the simple exit-code protocol.
@@ -217,11 +222,15 @@ 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.effective_base_url,
         model: @config.model_name,
-        anthropic_format: @config.anthropic_format?
+        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)
@@ -257,6 +266,7 @@ module Clacky
         model: model["model"],
         base_url: model["base_url"],
         provider_id: model["provider_id"],
+        remark: model["remark"],
         card_model: base_entry&.dig("model"),
         sub_model: sub_model
       }
@@ -587,9 +597,22 @@ module Clacky
           preview_path: f[:preview_path] || f["preview_path"] }
       end
 
+      # Resolved once here (not after append) so the user message can carry the
+      # confirmed skill name: only a skill that actually dispatches gets marked,
+      # so the UI never highlights a typo'd or unavailable command. The display
+      # name is resolved against the client's language (Thread.current[:lang],
+      # seeded from the WS message / X-Lang header) so the Web UI and third-party
+      # clients can render a localized label without re-resolving the skill.
+      skill_command = parse_skill_command(user_input)
+      skill_command_display = if skill_command[:found] && skill_command[:skill]
+                                skill_command[:skill].display_name(Thread.current[:lang])
+                              end
+
       created_at ||= Time.now.to_f
       @history.append({ role: "user", content: user_content, task_id: task_id, created_at: created_at,
                         display_text: display_text,
+                        skill_command: skill_command[:found] ? skill_command[:skill_name] : nil,
+                        skill_command_display: skill_command_display,
                         display_files: display_files.empty? ? nil : display_files })
       @total_tasks += 1
 
@@ -659,7 +682,7 @@ module Clacky
       # If the user typed a slash command targeting a skill with disable-model-invocation: true,
       # inject the skill content as a synthetic assistant message so the LLM can act on it.
       # Skills already in the system prompt (model_invocation_allowed?) are skipped.
-      inject_skill_command_as_assistant_message(user_input, task_id)
+      inject_skill_command_as_assistant_message(skill_command, task_id)
 
       @hooks.trigger(:on_start, user_input)
 
@@ -1374,9 +1397,17 @@ module Clacky
       # the new task's @current_task_id, orphaned from its assistant.
       check_stale!
 
+      # Build a tool_call_id → tool_name lookup so truncate_oversized_tool_content
+      # can apply tool-specific truncation strategies (e.g. terminal head+tail).
+      tool_name_by_id = {}
+      response[:tool_calls]&.each do |tc|
+        tool_name_by_id[tc[:id]] = tc[:name]
+      end
+
       formatted_messages = @client.format_tool_results(response, tool_results, model: current_model)
       formatted_messages.each do |msg|
-        truncated = truncate_oversized_tool_content(msg)
+        tool_name = tool_name_by_id[msg[:tool_call_id]]
+        truncated = truncate_oversized_tool_content(msg, tool_name: tool_name)
         @history.append(truncated.merge(task_id: @current_task_id))
       end
 
@@ -1453,16 +1484,37 @@ module Clacky
     # are handled by the image_inject path above.
     MAX_TOOL_RESULT_CHARS = 80_000
 
-    private def truncate_oversized_tool_content(msg)
+    # For terminal output, keep both head and tail because build/test logs
+    # put the most actionable information (error summaries, exit codes) at
+    # the end. Splitting the budget evenly preserves both the command echo
+    # and the final error summary.
+    TERMINAL_HEAD_CHARS = 40_000
+    TERMINAL_TAIL_CHARS = 40_000
+
+    private def truncate_oversized_tool_content(msg, tool_name: nil)
       content = msg[:content]
       return msg unless content.is_a?(String) && content.length > MAX_TOOL_RESULT_CHARS
 
       original_len = content.length
-      head = content[0, MAX_TOOL_RESULT_CHARS]
-      truncated = head + "\n\n[Tool result truncated: #{original_len} chars total, " \
-        "showing first #{MAX_TOOL_RESULT_CHARS}. Use a more specific query/limit, " \
-        "or read the raw output via file_reader/grep on the underlying source.]"
-      msg.merge(content: truncated)
+
+      if tool_name == "terminal"
+        head = content[0, TERMINAL_HEAD_CHARS]
+        tail_start = content.length - TERMINAL_TAIL_CHARS
+        tail = content[tail_start, TERMINAL_TAIL_CHARS]
+        omitted = original_len - TERMINAL_HEAD_CHARS - TERMINAL_TAIL_CHARS
+        truncated = head + "\n\n" \
+          "[... #{omitted} chars omitted — terminal output truncated: " \
+          "#{original_len} chars total, showing first #{TERMINAL_HEAD_CHARS} + " \
+          "last #{TERMINAL_TAIL_CHARS}. Use a more specific command or redirect " \
+          "to a file and read the relevant section. ...]\n\n" + tail
+        msg.merge(content: truncated)
+      else
+        head = content[0, MAX_TOOL_RESULT_CHARS]
+        truncated = head + "\n\n[Tool result truncated: #{original_len} chars total, " \
+          "showing first #{MAX_TOOL_RESULT_CHARS}. Use a more specific query/limit, " \
+          "or read the raw output via file_reader/grep on the underlying source.]"
+        msg.merge(content: truncated)
+      end
     end
 
     # Enqueue an inline skill injection to be flushed after observe().
@@ -1593,6 +1645,37 @@ module Clacky
       @tool_registry.register(Tools::Browser.new)
     end
 
+    # Register tools the agent declared via `tools:` — each id maps to
+    # <container>/tools/<id>.rb, and the file name maps to the class name
+    # (Clacky::Tools::<Camelized id>), so an id alone gives the path and the
+    # class. A failing file is logged and skipped so one broken tool never
+    # blocks agent startup.
+    private def register_extension_tools
+      dir = @agent_profile.container_dir
+      return unless dir
+      @agent_profile.tools.each do |id|
+        require File.join(dir, "tools", "#{id}.rb")
+        klass = extension_tool_class_for(id)
+        next unless klass
+
+        tool = klass.new
+        tool.agent = self if tool.respond_to?(:agent=)
+        @tool_registry.register(tool)
+      rescue StandardError, ScriptError => e
+        Clacky::Logger.warn("agent.register_extension_tool",
+          error: e.message, tool: id)
+      end
+    end
+
+    # tools/<id>.rb must define Clacky::Tools::<Camelized id> — the file name
+    # IS the class-name mapping (web-search → Clacky::Tools::WebSearch).
+    private def extension_tool_class_for(id)
+      const_name = id.split(/[_-]/).map(&:capitalize).join
+      Clacky::Tools.const_get(const_name)
+    rescue NameError
+      nil
+    end
+
     # Run a one-off task on a forked subagent and return its final reply text,
     # WITHOUT mutating this (parent) agent's history. Used by extensions that
     # need a side analysis (e.g. meeting annotate) which must reuse the parent's
@@ -1615,61 +1698,51 @@ module Clacky
       # to the parent's session_id) would broadcast the subagent's raw output
       # into the parent chat transcript. Swap in a no-op UI so nothing leaks.
       subagent.instance_variable_set(:@ui, NullUIController.new)
-      parent_count = subagent.instance_variable_get(:@parent_message_count) || 0
       result = subagent.run(task)
 
       # A detached run stays invisible, so its cost is merged silently — the
       # sessionbar refresh would be the one thing that gives it away.
       absorb_subagent_cost(result, notify_ui: false)
 
-      final_assistant_text(subagent, parent_count)
+      final_reply(subagent)
     end
 
-    # Run several independent tasks on forked subagents at the same time.
+    # Run labeled jobs in parallel, each inside its own concurrent UI phase.
     #
-    # Each subagent is forked on the calling thread (forking deep-copies parent
-    # config + history, which must not race) and only the blocking run is moved
-    # onto the pool. Results keep the order of `tasks`; a task that raises or
-    # overruns the budget yields a failed slot instead of aborting its siblings.
+    # Exposed for extension tools that build their own subagents (e.g. one per
+    # skill) but still need the UI wiring to be correct: the web UI folds each
+    # phase into its own live card, and the CLI collapses concurrent phases into
+    # a single progress line. Getting that right by hand is easy to botch, so
+    # the orchestration lives here while job construction stays with the caller.
     #
-    # Subagents run silently by default: they share the parent's session, so a
-    # live UI would interleave several raw transcripts into one chat.
+    # Callers must build their subagents on the calling thread before handing
+    # the jobs over — forking deep-copies parent config + history, which must
+    # not race. Only the blocking run belongs in the lambda.
     #
-    # @param tasks [Array<String>] one prompt per subagent
-    # @param model [String, nil] model for every subagent (nil = current)
-    # @param forbidden_tools [Array<String>] tool names blocked at runtime
-    # @param max_concurrency [Integer] subagents allowed to run at once
+    # @param jobs [Array<Hash>] each { label: String, run: #call }
+    # @param max_concurrency [Integer] jobs allowed to run at once
     # @param timeout [Numeric, nil] wall-clock budget for the whole batch
-    # @return [Array<Fanout::Result>] value is the subagent's final reply text
-    def fan_out_subagents(tasks, model: nil, forbidden_tools: [], max_concurrency: Fanout::DEFAULT_MAX_CONCURRENCY,
-                          timeout: nil)
-      return [] if tasks.empty?
-
-      jobs = tasks.each_with_index.map do |task, index|
-        subagent = fork_subagent(
-          model: model,
-          forbidden_tools: forbidden_tools,
-          system_prompt_suffix: "You are one of several subagents running in parallel on independent tasks. " \
-                                "Do your task and return only the requested output. Do not ask follow-up questions."
-        )
-        parent_count = subagent.instance_variable_get(:@parent_message_count) || 0
-        label = "Subagent #{index + 1}/#{tasks.size}"
-        # Fanout workers are fresh threads, so the epoch that lets the web
-        # broadcaster drop events from superseded tasks has to be carried over
-        # by hand — otherwise interrupted subagents keep writing to the new task.
-        epoch = Thread.current[:task_epoch]
+    # @return [Array<Fanout::Result>] aligned to the input order
+    def fan_out_labeled(jobs, max_concurrency: Fanout::DEFAULT_MAX_CONCURRENCY, timeout: nil)
+      return [] if jobs.empty?
+
+      # Fanout workers are fresh threads, so the epoch that lets the web
+      # broadcaster drop events from superseded tasks has to be carried over
+      # by hand — otherwise interrupted subagents keep writing to the new task.
+      epoch = Thread.current[:task_epoch]
+
+      wrapped = jobs.each_with_index.map do |job, index|
+        label = job[:label] || job["label"] || "Subagent #{index + 1}/#{jobs.size}"
+        run = job[:run] || job["run"]
+        raise ArgumentError, "job #{index} must provide a callable :run" unless run.respond_to?(:call)
 
         lambda do
           Thread.current[:task_epoch] = epoch
-          within_phase(label, kind: "fanout_subagent", concurrent: true) do
-            result = subagent.run(task)
-            absorb_subagent_cost(result, notify_ui: false)
-            final_assistant_text(subagent, parent_count)
-          end
+          within_phase(label, kind: "fanout_subagent", concurrent: true) { run.call }
         end
       end
 
-      Fanout.new(max_concurrency: max_concurrency, timeout: timeout).run(jobs)
+      Fanout.new(max_concurrency: max_concurrency, timeout: timeout).run(wrapped)
     end
 
     private def within_phase(label, kind:, concurrent:, &block)
@@ -1678,7 +1751,21 @@ module Clacky
       @ui.with_phase(kind: kind, label: label, concurrent: concurrent, &block)
     end
 
-    private def final_assistant_text(subagent, parent_count)
+    # The subagent's last non-empty assistant message — its actual answer.
+    #
+    # A subagent's `run` result carries cost and iteration counts but no reply
+    # text, and its trailing history entries are usually tool results, so the
+    # answer has to be found by scanning backwards from the end. Only messages
+    # appended after the fork are considered; earlier ones are the inherited
+    # parent conversation.
+    #
+    # Use this when the caller wants the raw answer to pass on programmatically.
+    # For a human-facing digest use {#generate_subagent_summary} instead.
+    #
+    # @param subagent [Agent] a subagent produced by {#fork_subagent}
+    # @return [String] the reply, or "" when the subagent never answered
+    def final_reply(subagent)
+      parent_count = subagent.instance_variable_get(:@parent_message_count) || 0
       new_messages = subagent.history.to_a[parent_count..] || []
       new_messages
         .reverse
@@ -1742,11 +1829,15 @@ module Clacky
       end
 
       # Create new client for subagent
+      subagent_entry = subagent_config.current_model
       subagent_client = Clacky::Client.new(
         subagent_config.api_key,
         base_url: subagent_config.base_url,
         model: subagent_config.model_name,
-        anthropic_format: subagent_config.anthropic_format?
+        anthropic_format: subagent_config.anthropic_format?,
+        api_format: subagent_config.api_format,
+        provider_id: subagent_config.provider_id_for(subagent_entry),
+        capabilities: subagent_entry && subagent_entry["capabilities"]
       )
 
       # Create subagent (reuses all tools from parent, inherits agent profile from parent)