kward 0.79.0 → 0.80.1

data/lib/kward/cli/worktrees.rb

@@ -0,0 +1,360 @@
+require "securerandom"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Coordinates Git worktree bindings with session-backed tab runtimes.
+  class CLI
+    module Worktrees
+      private
+
+      def git_worktree_manager
+        @git_worktree_manager ||= GitWorktreeManager.new
+      end
+
+      def worktree_binding_for(tab)
+        driver = tab&.driver
+        driver.worktree if driver&.respond_to?(:worktree)
+      end
+
+      def worktree_root_for(binding, fallback: current_workspace_root)
+        return fallback unless binding
+
+        binding.active? ? binding.path : binding.origin_root
+      end
+
+      def reconcile_worktree_binding(tab, conversation)
+        binding = worktree_binding_for(tab)
+        return nil unless binding
+        return binding unless binding.active?
+
+        binding.active = false unless File.realpath(conversation.workspace_root) == File.realpath(binding.path)
+        binding
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        binding.active = false
+        binding
+      end
+
+      def validate_worktree_binding!(binding)
+        return unless binding
+
+        unless File.directory?(binding.origin_root)
+          raise GitWorktreeManager::Error, "Original workspace is unavailable: #{binding.origin_root}"
+        end
+
+        return unless binding.active?
+
+        info = git_worktree_manager.inspect(repository_root: binding.repository_root, path: binding.path)
+        return if info.branch == binding.branch
+
+        raise GitWorktreeManager::Error, "Worktree branch changed: expected #{binding.branch}, found #{info.branch || "detached HEAD"}"
+      end
+
+      def rebind_session_tab(tab, root:, worktree:)
+        raise GitWorktreeManager::Error, "A session tab is required." unless tab&.session
+        raise GitWorktreeManager::Error, "The session store is unavailable." unless @session_store
+
+        session, conversation = @session_store.load(
+          tab.session.path,
+          workspace: configured_workspace(root: root, strict: worktree&.active? == true),
+          provider: current_model_provider,
+          model: current_model_id,
+          reasoning_effort: current_reasoning_effort
+        )
+        agent = build_tab_agent(conversation, session, worktree: worktree)
+        tab.session = track_session(session)
+        tab.agent = agent
+        tab.driver = SessionTabDriver.new(session: tab.session, agent: agent, worktree: worktree)
+        tab.diff = SessionDiff.from_session_file(tab.session.path)
+        tab.status = "idle"
+        tab.thread = nil
+        tab.cancellation = nil
+        tab.steering = nil
+        tab.error = nil
+        tab.answer = nil
+        tab.pending_question = nil
+        tab.unread = false
+        tab.error_reported = false
+        tab.event_history.clear
+        tab.seen_events = 0
+        tab.queued_inputs.clear
+        tab.shell = nil
+        tab.stream_state = new_tab_stream_state(tab.driver)
+        tab.markdown_chunks.clear
+        assign_tab_question_prompt(tab.agent, tab)
+        if tab == active_tab
+          @active_session = tab.session
+          @session_diff = tab.diff
+          update_assistant_prompt(tab.agent.conversation)
+        end
+        tab
+      end
+
+      def handle_worktree_command(argument)
+        case argument.to_s.strip
+        when "", "activate"
+          activate_active_tab_worktree
+        when "detach"
+          detach_current_worktree
+        when "status"
+          print_active_worktree_status
+        when "remove"
+          remove_active_worktree
+        when "merge"
+          merge_active_worktree
+        when "merge abort"
+          abort_active_worktree_merge
+        else
+          runtime_output("Usage: /tab worktree [activate|detach|status|merge|merge abort|remove]")
+        end
+      end
+
+      def activate_active_tab_worktree
+        tab = active_tab
+        return runtime_output("There is no active tab.") unless tab
+        return runtime_output("Worktrees are available only for normal session tabs.") if plugin_tab?(tab)
+        return runtime_output("Tab #{active_tab_number} is running and cannot change workspaces yet.") if tab&.running? || tab&.local_busy? || tab&.shell
+
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} is already using #{binding.branch} at #{binding.path}.") if binding&.active?
+        return activate_existing_worktree(tab, binding) if binding
+
+        attach_new_worktree(tab)
+      rescue GitWorktreeManager::Error, Sandbox::UnavailableError => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def detach_current_worktree
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is not using its linked worktree.") unless binding.active?
+        return runtime_output("Tab #{active_tab_number} is running and cannot change workspaces yet.") if tab.running? || tab.local_busy? || tab.shell
+
+        detach_active_worktree(tab, binding)
+      rescue GitWorktreeManager::Error, Sandbox::UnavailableError => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def attach_new_worktree(tab)
+        origin_root = tab.agent.conversation.workspace_root
+        repository_root = git_worktree_manager.repository_root(origin_root)
+        status = git_worktree_manager.status(origin_root)
+        if status.dirty? && !confirm_worktree_action(<<~MESSAGE)
+          #{origin_root} has #{status.entries.length} local change(s).
+
+          The new worktree will be created from HEAD. Existing changes will remain in the original workspace and will not be copied.
+
+          Create the worktree anyway?
+        MESSAGE
+          return
+        end
+
+        branch = generated_worktree_branch(tab)
+        path = default_worktree_path(repository_root, branch)
+        binding = git_worktree_manager.create(
+          repository_root: repository_root,
+          origin_root: origin_root,
+          path: path,
+          branch: branch
+        )
+        begin
+          rebind_active_tab(tab, root: binding.path, worktree: binding)
+        rescue StandardError
+          git_worktree_manager.remove(repository_root: binding.repository_root, path: binding.path)
+          raise
+        end
+        runtime_output("Tab #{active_tab_number} is now using #{binding.branch} at #{binding.path}.")
+      end
+
+      def activate_existing_worktree(tab, binding)
+        binding.active = true
+        validate_worktree_binding!(binding)
+        rebind_active_tab(tab, root: binding.path, worktree: binding)
+        runtime_output("Tab #{active_tab_number} is now using #{binding.branch} at #{binding.path}.")
+      rescue StandardError
+        binding.active = false
+        raise
+      end
+
+      def detach_active_worktree(tab, binding)
+        validate_worktree_binding!(binding)
+        status = git_worktree_manager.status(binding.path)
+        if status.dirty? && !confirm_worktree_action(<<~MESSAGE)
+          #{binding.path} has #{status.entries.length} local change(s).
+
+          They will remain in the worktree after this tab switches back to #{binding.origin_root}.
+
+          Detach and keep the worktree?
+        MESSAGE
+          return
+        end
+
+        binding.active = false
+        rebind_active_tab(tab, root: binding.origin_root, worktree: binding)
+        runtime_output("Tab #{active_tab_number} returned to #{binding.origin_root}; worktree kept at #{binding.path}.")
+      rescue StandardError
+        binding.active = true
+        raise
+      end
+
+      def rebind_active_tab(tab, root:, worktree:)
+        save_active_tab_state
+        stop_tab_live_view
+        rebind_session_tab(tab, root: root, worktree: worktree)
+        activate_tab(@active_tab_index)
+        persist_tabs
+      end
+
+      def print_active_worktree_status
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+
+        lines = [
+          "Worktree: #{binding.active? ? "active" : "detached"}",
+          "Origin: #{binding.origin_root}",
+          "Path: #{binding.path}",
+          "Branch: #{binding.branch}",
+          "Base: #{binding.base_revision}"
+        ]
+        begin
+          info = git_worktree_manager.inspect(repository_root: binding.repository_root, path: binding.path)
+          raise GitWorktreeManager::Error, "Worktree branch changed: expected #{binding.branch}, found #{info.branch || "detached HEAD"}" unless info.branch == binding.branch
+          status = git_worktree_manager.status(binding.path)
+          lines << "Changes: #{status.clean? ? "clean" : "#{status.entries.length} local change(s)"}"
+        rescue GitWorktreeManager::Error => e
+          lines << "State: unavailable (#{e.message})"
+        end
+        runtime_output(lines.join("\n"))
+      end
+
+      def merge_active_worktree
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot merge its worktree yet.") if tab.running? || tab.local_busy? || tab.shell
+        return runtime_output("Activate the worktree before merging it.") unless binding.active?
+
+        validate_worktree_binding!(binding)
+        source_status = git_worktree_manager.status(binding.path)
+        return runtime_output("Worktree has local changes; commit or clean it before merging.") if source_status.dirty?
+
+        target_status = git_worktree_manager.status(binding.origin_root)
+        return runtime_output("Original workspace has local changes; clean it before merging.") if target_status.dirty?
+
+        target_branch = git_worktree_manager.current_branch(binding.origin_root)
+        return runtime_output("Original workspace is in detached HEAD state; select a target branch before merging.") if target_branch.empty?
+        return runtime_output("Worktree already uses the target branch #{target_branch}.") if target_branch == binding.branch
+
+        target_revision = git_worktree_manager.current_revision(binding.origin_root)
+        source_revision = git_worktree_manager.current_revision(binding.path)
+        return unless confirm_worktree_action(<<~MESSAGE)
+          Merge #{binding.branch} into #{target_branch}?
+
+          Source: #{binding.branch} (#{source_revision})
+          Target: #{target_branch} (#{target_revision})
+          Original workspace: #{binding.origin_root}
+
+          The merge runs directly in the original workspace.
+        MESSAGE
+
+        unless git_worktree_manager.current_revision(binding.origin_root) == target_revision && git_worktree_manager.status(binding.origin_root).clean?
+          return runtime_output("Original workspace changed before the merge could begin; review it and try again.")
+        end
+
+        result = git_worktree_manager.merge(
+          repository_root: binding.repository_root,
+          target_path: binding.origin_root,
+          source_branch: binding.branch
+        )
+        if result.merged?
+          runtime_output("Merged #{binding.branch} into #{target_branch}.")
+        else
+          runtime_output("Merge conflicts in #{result.conflicts.join(", ")}. Resolve them in #{binding.origin_root} or run /tab worktree merge abort.")
+        end
+      rescue GitWorktreeManager::Error => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def abort_active_worktree_merge
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot abort its merge yet.") if tab.running? || tab.local_busy? || tab.shell
+        return runtime_output("No merge is in progress in the original workspace.") unless git_worktree_manager.merge_in_progress?(binding.origin_root)
+        return unless confirm_worktree_action("Abort the merge in #{binding.origin_root}?")
+
+        git_worktree_manager.abort_merge(binding.origin_root)
+        runtime_output("Aborted the merge in #{binding.origin_root}.")
+      rescue GitWorktreeManager::Error => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def remove_active_worktree
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot remove its worktree yet.") if tab.running? || tab.local_busy? || tab.shell
+
+        git_worktree_manager.inspect(repository_root: binding.repository_root, path: binding.path)
+        status = git_worktree_manager.status(binding.path)
+        return runtime_output("Worktree has local changes; detach it or clean it before removing it.") if status.dirty?
+
+        was_active = binding.active?
+        detached = false
+        if was_active
+          binding.active = false
+          rebind_active_tab(tab, root: binding.origin_root, worktree: binding)
+          detached = true
+        end
+        git_worktree_manager.remove(repository_root: binding.repository_root, path: binding.path)
+        tab.driver = SessionTabDriver.new(session: tab.session, agent: tab.agent)
+        tab.stream_state = new_tab_stream_state(tab.driver)
+        persist_tabs
+        runtime_output("Removed worktree #{binding.path}. Branch #{binding.branch} was kept.")
+      rescue GitWorktreeManager::Error => e
+        binding.active = true if was_active && !detached
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def confirm_worktree_action(message)
+        prompt = message.to_s.strip
+        if @prompt.respond_to?(:ask_user_question)
+          answer = @prompt.ask_user_question([{
+            header: "Confirm worktree action",
+            question: prompt,
+            options: [
+              { label: "Continue", description: "Proceed with this Git operation." },
+              { label: "Cancel", description: "Leave the workspace unchanged." }
+            ]
+          }])
+          return answer&.first&.fetch(:answer, nil) == "Continue"
+        end
+
+        return false unless @prompt.respond_to?(:yes?)
+
+        runtime_output(prompt) if prompt.include?("\n")
+        @prompt.yes?(prompt.include?("\n") ? "Continue?" : prompt, default: false)
+      end
+
+      def generated_worktree_branch(tab)
+        label = tab.label.to_s.downcase.gsub(/[^a-z0-9]+/, "-").sub(/\A-+|-+\z/, "")
+        label = "tab-#{active_tab_number}" if label.empty?
+        "kward/#{label}-#{SecureRandom.hex(3)}"
+      end
+
+      def default_worktree_path(repository_root, branch)
+        slug = branch.to_s.delete_prefix("kward/").gsub(/[^a-zA-Z0-9._-]+/, "-")
+        File.join(File.dirname(repository_root), ".kward-worktrees", File.basename(repository_root), slug)
+      end
+
+      def unavailable_worktree_tab(descriptor, error, label: nil)
+        driver = UnavailableTabDriver.new(
+          descriptor: descriptor,
+          message: "Worktree unavailable: #{error.message}"
+        )
+        build_tab(nil, nil, driver: driver, label: label || descriptor["label"] || "Worktree")
+      end
+    end
+  end
+end

data/lib/kward/cli.rb

@@ -17,6 +17,7 @@ require_relative "export_path"
 require_relative "ekwsh"
 require_relative "interactive_pty_runner"
 require_relative "auth/anthropic_oauth"
+require_relative "auth/api_key_store"
 require_relative "auth/github_oauth"
 require_relative "auth/openrouter_api_key"
 require_relative "image_attachments"
@@ -25,12 +26,16 @@ require_relative "memory/turn_context"
 require_relative "transcript_export"
 require_relative "message_access"
 require_relative "model/model_info"
+require_relative "model/azure_openai_config"
+require_relative "model/provider_catalog"
+require_relative "model/catalog"
 require_relative "auth/openai_oauth"
 require_relative "pan/server"
 require_relative "plugin_registry"
 require_relative "prompts/commands"
 require_relative "model/retry_message"
 require_relative "rpc/server"
+require_relative "transport/runtime"
 require_relative "session_diff"
 require_relative "session_store"
 require_relative "session_naming"
@@ -46,6 +51,7 @@ require_relative "tools/tool_call"
 require_relative "tools/registry"
 require_relative "telemetry/stats"
 require_relative "workspace_factory"
+require_relative "git_worktree_manager"
 require_relative "cli/commands"
 require_relative "cli/auth_commands"
 require_relative "cli/doctor"
@@ -59,6 +65,7 @@ require_relative "cli/hook_commands"
 require_relative "cli/settings"
 require_relative "cli/sessions"
 require_relative "cli/tabs"
+require_relative "cli/worktrees"
 require_relative "cli/compaction"
 require_relative "cli/rendering"
 require_relative "cli/prompt_interface"
@@ -66,6 +73,7 @@ require_relative "cli/plugins"
 require_relative "cli/git"
 require_relative "cli/interactive_turn"
 require_relative "cli/tool_summaries"
+require_relative "cli/transports"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -92,6 +100,7 @@ module Kward
     include CLI::Settings
     include CLI::Sessions
     include CLI::Tabs
+    include CLI::Worktrees
     include CLI::CompactionCommands
     include CLI::Rendering
     include CLI::PromptInterfaceSupport
@@ -99,6 +108,7 @@ module Kward
     include CLI::GitCommands
     include CLI::InteractiveTurn
     include CLI::ToolSummaries
+    include CLI::Transports
 
     def initialize(argv: ARGV, stdin: STDIN, prompt: TTY::Prompt.new, client: nil, session_store: nil, context_usage: ContextUsage.new)
       @argv = argv
@@ -244,6 +254,16 @@ module Kward
         return
       end
 
+      if @argv.first == "transport"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("transport")
+          return
+        end
+
+        handle_transport_command(@argv[1..] || [])
+        return
+      end
+
       if @argv.first == "rpc"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("rpc")
@@ -313,6 +333,7 @@ module Kward
       @prompt.edit_file(path, base_dir: Dir.pwd, allow_new: true)
     ensure
       @prompt.close if @prompt.respond_to?(:close) && prompt_interface?
+      clear_interactive_warning_sink if respond_to?(:clear_interactive_warning_sink, true)
     end
 
     def run_prompt_or_interactive
@@ -526,6 +547,7 @@ module Kward
         stop_tabs if respond_to?(:stop_tabs, true)
         @prompt.close if prompt_interface?
       ensure
+        clear_interactive_warning_sink if respond_to?(:clear_interactive_warning_sink, true)
         cleanup_unused_sessions
         remember_active_session(session_store)
       end

data/lib/kward/compactor.rb

@@ -734,9 +734,10 @@ module Kward
     AUTO_COMPACTION_EXTRA_GUARD_FLOOR = 12_000
 
     # Creates an object for conversation compaction.
-    def initialize(conversation:, client:, tool_result_summarizer: nil, settings: nil, summarizer: nil)
+    def initialize(conversation:, client:, tool_result_summarizer: nil, settings: nil, summarizer: nil, warning_sink: nil)
       @conversation = conversation
       @client = client
+      @warning_sink = warning_sink
       @settings = settings || Compaction::Settings.from_config
       @prompt_builder = Compaction::PromptBuilder.new(
         serializer: Compaction::ConversationSerializer.new(tool_result_summarizer: tool_result_summarizer)
@@ -791,7 +792,7 @@ module Kward
     rescue Compaction::NothingToCompact, Compaction::AlreadyCompacted
       nil
     rescue StandardError => e
-      warn "Auto-compaction failed: #{e.message}"
+      emit_warning "Auto-compaction failed: #{e.message}"
       nil
     end
 
@@ -814,6 +815,10 @@ module Kward
 
     private
 
+    def emit_warning(message)
+      @warning_sink ? @warning_sink.call(message) : warn(message)
+    end
+
     def prepare
       @conversation.refresh_system_message_if_workspace_agents_changed!
       Compaction::Preparation.new(conversation: @conversation, settings: @settings).call

data/lib/kward/config_files.rb

@@ -3,6 +3,7 @@ require "fileutils"
 require "json"
 require "yaml"
 require_relative "frontmatter"
+require_relative "deep_copy"
 require_relative "private_file"
 require_relative "path_guard"
 require_relative "permissions/policy"
@@ -65,6 +66,7 @@ module Kward
     end
 
     @skip_config = false
+    @warning_sink = nil
 
     module_function
 
@@ -72,6 +74,14 @@ module Kward
       @skip_config = value
     end
 
+    def warning_sink=(sink)
+      @warning_sink = sink
+    end
+
+    def warning_sink
+      @warning_sink
+    end
+
     def skip_config?
       @skip_config == true
     end
@@ -156,6 +166,7 @@ module Kward
           "include_principles" => true
         },
         "mcpServers" => {},
+        "transports" => {},
         "tools" => {
           "workspace_guardrails" => true
         },
@@ -190,6 +201,13 @@ module Kward
       File.join(cache_dir, "openrouter_models.json")
     end
 
+    def model_catalog_cache_path(provider_id)
+      provider = provider_id.to_s.gsub(/[^a-z0-9_-]/i, "_")
+      raise ArgumentError, "Provider id must be a non-empty string" if provider.empty?
+
+      File.join(cache_dir, "models", "#{provider}.json")
+    end
+
     def update_check_cache_path
       File.join(cache_dir, "update_check.json")
     end
@@ -236,7 +254,10 @@ module Kward
       return {} if skip_config? && path == config_path
       return {} unless File.exist?(path)
 
-      JSON.parse(File.read(path))
+      config = JSON.parse(File.read(path))
+      return config if config.is_a?(Hash)
+
+      raise ConfigError.new(path: path, format: "JSON", detail: "top-level value must be an object")
     rescue JSON::ParserError => e
       raise ConfigError.new(path: path, format: "JSON", detail: e.message)
     end
@@ -544,6 +565,15 @@ module Kward
       value.is_a?(Hash) ? value : {}
     end
 
+    # Returns the private configuration namespace for one transport.
+    def transport_config(transport_id, config = read_config)
+      transports = config["transports"]
+      return {} unless transports.is_a?(Hash)
+
+      values = transports[transport_id.to_s]
+      values.is_a?(Hash) ? DeepCopy.dup(values) : {}
+    end
+
     # Returns configured MCP stdio servers, or an empty config when absent.
     def mcp_servers(config = read_config)
       value = config["mcpServers"] || config.dig("mcp", "servers")
@@ -770,13 +800,13 @@ module Kward
 
       size = File.size(path)
       if size > MAX_PROMPT_FILE_BYTES
-        warn "Warning: skipping #{label} #{path}: file too large (#{size} bytes; limit is #{MAX_PROMPT_FILE_BYTES} bytes)"
+        emit_warning "Warning: skipping #{label} #{path}: file too large (#{size} bytes; limit is #{MAX_PROMPT_FILE_BYTES} bytes)"
         return nil
       end
 
       File.read(path)
     rescue StandardError => e
-      warn "Warning: skipping #{label} #{path}: #{e.message}"
+      emit_warning "Warning: skipping #{label} #{path}: #{e.message}"
       nil
     end
 
@@ -887,8 +917,8 @@ module Kward
     # Lists configured skills discovered under the config directory.
     #
     # @return [Array<Skill>] skill metadata available to the model
-    def skills(workspace_root: Dir.pwd)
-      skills_registry(workspace_root: workspace_root).skills
+    def skills(workspace_root: Dir.pwd, warning_sink: nil)
+      skills_registry(workspace_root: workspace_root, warning_sink: warning_sink).skills
     end
 
     # @return [String] trusted user plugin directory
@@ -896,19 +926,21 @@ module Kward
       File.expand_path("~/.kward/plugins")
     end
 
-    # Finds trusted top-level plugin files.
+    # Finds trusted plugin files and package entrypoints.
     #
     # Plugins are intentionally loaded only from `~/.kward/plugins`, not from a
     # workspace or custom `KWARD_CONFIG_PATH` directory.
     #
     # @return [Array<String>] sorted plugin file paths
-    def plugin_paths
+    def plugin_paths(warning_sink: nil)
       plugins_root = plugin_dir
       return [] unless Dir.exist?(plugins_root)
 
-      Dir.glob(File.join(plugins_root, "*.rb")).sort
+      paths = Dir.glob(File.join(plugins_root, "*.rb"))
+      paths.concat(Dir.glob(File.join(plugins_root, "*", "plugin.rb")))
+      paths.sort
     rescue StandardError => e
-      warn "Warning: skipping Kward plugins in #{plugins_root}: #{e.message}"
+      emit_warning("Warning: skipping Kward plugins in #{plugins_root}: #{e.message}", warning_sink: warning_sink)
       []
     end
 
@@ -929,7 +961,7 @@ module Kward
       skills_registry(workspace_root: workspace_root).read_skill_file(name, relative_path)
     end
 
-    def skills_registry(workspace_root: Dir.pwd)
+    def skills_registry(workspace_root: Dir.pwd, warning_sink: nil)
       Skills::Registry.new(
         config_dir: config_dir,
         workspace_root: workspace_root,
@@ -937,7 +969,8 @@ module Kward
         skill_class: Skill,
         max_file_bytes: MAX_SKILL_FILE_BYTES,
         markdown_parser: ->(path) { Frontmatter.markdown_parts(path, lenient: true) },
-        inside_directory: method(:inside_directory?)
+        inside_directory: method(:inside_directory?),
+        warning_sink: warning_sink || @warning_sink
       )
     end
 
@@ -945,10 +978,16 @@ module Kward
       Prompts::Templates.new(
         config_dir: config_dir,
         template_class: PromptTemplate,
-        markdown_parser: ->(path) { Frontmatter.markdown_parts(path) }
+        markdown_parser: ->(path) { Frontmatter.markdown_parts(path) },
+        warning_sink: @warning_sink
       )
     end
 
+    def emit_warning(message, warning_sink: nil)
+      sink = warning_sink || @warning_sink
+      sink ? sink.call(message) : warn(message)
+    end
+
     def inside_directory?(path, base)
       PathGuard.inside?(path, base)
     end