kward 0.79.0 → 0.80.0

data/lib/kward/cli/transports.rb

@@ -0,0 +1,67 @@
+require_relative "../transport/runtime"
+
+module Kward
+  class CLI
+    # Foreground transport lifecycle commands.
+    module Transports
+      private
+
+      def handle_transport_command(arguments)
+        command = arguments.first.to_s
+        case command
+        when "list"
+          raise ArgumentError, command_usage("transport") unless arguments.length == 1
+
+          with_transport_runtime { |runtime| print_transport_entries(runtime.manager.list) }
+        when "status"
+          raise ArgumentError, command_usage("transport") unless arguments.length <= 2
+
+          with_transport_runtime do |runtime|
+            entries = arguments.length == 2 ? [runtime.manager.status(arguments[1])] : runtime.manager.status
+            print_transport_entries(entries)
+          end
+        when "run"
+          raise ArgumentError, command_usage("transport") unless (2..3).cover?(arguments.length)
+
+          workspace_root = arguments[2] ? expanded_working_directory(arguments[2]) : @working_directory
+          run_transport(arguments[1], workspace_root: workspace_root)
+        else
+          raise ArgumentError, command_usage("transport")
+        end
+      end
+
+      def print_transport_entries(entries)
+        entries.each do |entry|
+          @prompt.say("#{entry[:id]}\t#{entry[:state] || "stopped"}")
+        end
+      end
+
+      def run_transport(name, workspace_root: nil)
+        runtime = Transport::Runtime.new(client: ensure_client!)
+        runtime.manager.start(name, workspace_root: workspace_root)
+        @prompt.say("Transport #{name} is running. Press Ctrl-C to stop.")
+        wait_for_transport_shutdown
+      ensure
+        runtime&.shutdown
+      end
+
+      def with_transport_runtime
+        runtime = Transport::Runtime.new(client: ensure_client!)
+        yield runtime
+      ensure
+        runtime&.shutdown
+      end
+
+      def wait_for_transport_shutdown
+        stopped = false
+        previous_handlers = {}
+        %w[INT TERM].each do |signal|
+          previous_handlers[signal] = Signal.trap(signal) { stopped = true }
+        end
+        sleep 0.1 until stopped
+      ensure
+        previous_handlers&.each { |signal, handler| Signal.trap(signal, handler) }
+      end
+    end
+  end
+end

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")

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"
@@ -156,6 +157,7 @@ module Kward
           "include_principles" => true
         },
         "mcpServers" => {},
+        "transports" => {},
         "tools" => {
           "workspace_guardrails" => true
         },
@@ -190,6 +192,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 +245,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 +556,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")
@@ -896,7 +917,7 @@ 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.
@@ -906,7 +927,9 @@ module Kward
       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}"
       []

data/lib/kward/conversation.rb

@@ -58,32 +58,33 @@ module Kward
     # @return [PluginRegistry, nil] registry used to collect plugin prompt context
     attr_accessor :plugin_registry
     # @return [String, nil] plugin prompt context used in the current system prompt
-    attr_reader :last_plugin_prompt_context
+    attr_reader :last_plugin_prompt_context, :execution_profile_context
     # @return [Hash] original large tool outputs retained outside model context
     attr_reader :tool_output_artifacts
     # @return [ContextBudgetMeter] runtime context savings for this conversation
     attr_reader :context_budget_meter
 
-    def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil)
+    def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil, execution_profile_context: nil)
       @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
       @provider = provider
       @model = model
       @reasoning_effort = reasoning_effort
       @plugin_registry = plugin_registry
+      @execution_profile_context = execution_profile_context.to_s.empty? ? nil : execution_profile_context.to_s.freeze
       @messages = []
       restored_system_message, transcript_messages = split_system_message(messages)
       if system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
-        if restored_system_message
+        if restored_system_message && @execution_profile_context.to_s.empty?
           system_message = restored_system_message
         else
           @last_plugin_prompt_context = plugin_prompt_context
-          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context)
+          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context)
         end
       end
       @system_message = system_message
       @system_message_enabled = !@system_message.nil?
       if compaction_system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
-        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time) : nil
+        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context) : nil
       end
       @compaction_system_message = compaction_system_message
       @workspace_agents_mtime = workspace_agents_mtime
@@ -187,15 +188,20 @@ module Kward
       return nil unless @system_message_enabled
 
       @last_plugin_prompt_context = plugin_prompt_context
-      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context)
+      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context, execution_profile_context: @execution_profile_context)
       @system_message = replacement
       @on_system_message_change&.call(replacement)
-      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time)
+      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, execution_profile_context: @execution_profile_context)
       @workspace_agents_mtime = workspace_agents_mtime
       @system_prompt_sources_fingerprint = ConfigFiles.system_prompt_sources_fingerprint
       replacement
     end
 
+    def update_execution_profile_context!(context)
+      @execution_profile_context = context.to_s.empty? ? nil : context.to_s.freeze
+      refresh_system_message!
+    end
+
     def update_runtime_context!(provider: nil, model:, reasoning_effort:, refresh: true)
       @provider = provider unless provider.to_s.empty?
       @model = model