kward 0.83.0 → 0.85.0

data/lib/kward/rpc/session_manager.rb

@@ -9,24 +9,24 @@ require_relative "../config_files"
 require_relative "../model/context_usage"
 require_relative "../conversation"
 require_relative "../events"
-require_relative "../export_path"
+require_relative "../transcripts/export_path"
 require_relative "../memory/manager"
 require_relative "../memory/turn_context"
 require_relative "../message_access"
 require_relative "../message_text"
-require_relative "../session_tree_tool_display"
+require_relative "../sessions/tree_tool_display"
 require_relative "../skills/capture"
 require_relative "../model/model_info"
-require_relative "../plugin_registry"
+require_relative "../plugins/registry"
 require_relative "../prompts/commands"
-require_relative "../session_store"
-require_relative "../session_naming"
-require_relative "../session_trash"
+require_relative "../sessions/store"
+require_relative "../sessions/naming"
+require_relative "../sessions/trash"
 require_relative "../steering"
 require_relative "../tools/tool_call"
 require_relative "../tools/registry"
-require_relative "../transcript_export"
-require_relative "../workspace_factory"
+require_relative "../transcripts/transcript_export"
+require_relative "../workspace/factory"
 require_relative "attachment_normalizer"
 require_relative "config_manager"
 require_relative "memory_methods"
@@ -66,7 +66,7 @@ module Kward
       WORKER_STOP_TIMEOUT = 2.0
       WORKER_STOP = Object.new.freeze
 
-      RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :execution_profile, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, keyword_init: true)
+      RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :execution_profile, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, :last_footer_segments, keyword_init: true)
       Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, :options, :tool_registry, :execution_profile, :mutex, keyword_init: true)
 
       # Creates an object for RPC session lifecycle and turn coordination.
@@ -215,7 +215,7 @@ module Kward
 
       # Returns the plugin registry shared by RPC sessions and plugin chats.
       def plugin_registry
-        @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_plugin_command_names)
+        @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_plugin_command_names).tap(&:start!)
       end
 
       # Renames the persisted session attached to an RPC session id.
@@ -392,6 +392,11 @@ module Kward
         { closed: true }
       end
 
+      def shutdown_plugins
+        @plugin_registry&.shutdown!
+        { closed: true }
+      end
+
       # Returns the normalized transcript for the active RPC session.
       def transcript(session_id:)
         rpc_session = fetch_session(session_id)
@@ -490,6 +495,12 @@ module Kward
         { ok: true }
       end
 
+      def answer_plugin_ui(session_id:, request_id:, value:)
+        rpc_session = fetch_session(session_id)
+        rpc_session.prompt.answer_plugin_ui(request_id, value)
+        { ok: true }
+      end
+
       def answer_tool_approval(session_id:, approval_request_id:, approved:)
         rpc_session = fetch_session(session_id)
         rpc_session.prompt.answer_tool_approval(approval_request_id, approved: approved)
@@ -525,18 +536,39 @@ module Kward
 
       def run_plugin_command(session_id:, command:, arguments: "")
         rpc_session = fetch_session(session_id)
+        raise ArgumentError, "Plugin commands are disabled for this session" if rpc_session.execution_profile && !rpc_session.execution_profile.plugin_commands
+
         command = plugin_registry.command_for(command.to_s.delete_prefix("/")) || raise(ArgumentError, "Unknown plugin command: #{command}")
+        arguments = command.parse_arguments(arguments)
         output = []
-        context = plugin_context(rpc_session, args: arguments.to_s, say_callback: lambda { |message| output << message.to_s })
-        result = command.handler.call(arguments.to_s, context)
+        context = plugin_context(rpc_session, args: arguments, say_callback: lambda { |message| output << message.to_s })
+        result = command.normalize_result(command.handler.call(arguments, context))
         output = rpc_session.plugin_output.shift(rpc_session.plugin_output.length) + output
-        { command: command.name, output: output, result: result.nil? ? nil : result.to_s }
+        serialized_result = command.typed? ? result.to_h : (result.nil? ? nil : result.to_s)
+        { command: command.name, output: output, result: serialized_result }
       end
 
       def plugin_commands
         plugin_registry.commands
       end
 
+      def plugin_actions
+        plugin_registry.actions
+      end
+
+      def run_plugin_action(session_id:, id:, arguments: {})
+        rpc_session = fetch_session(session_id)
+        raise ArgumentError, "Plugin actions are disabled for this session" if rpc_session.execution_profile && !rpc_session.execution_profile.plugin_commands
+
+        action = plugin_registry.action_for(id) || raise(ArgumentError, "Unknown plugin action: #{id}")
+        arguments = action.parse_arguments(arguments)
+        output = []
+        context = plugin_context(rpc_session, args: arguments, say_callback: lambda { |message| output << message.to_s })
+        result = action.normalize_result(action.handler.call(arguments, context))
+        output = rpc_session.plugin_output.shift(rpc_session.plugin_output.length) + output
+        { action: action.id, output: output, result: result.to_h }
+      end
+
       def available_models
         models = @client.respond_to?(:available_models) ? Array(@client.available_models) : []
         normalized = models.map { |model| normalize_model(model) }
@@ -628,6 +660,8 @@ module Kward
 
       def reload_plugins
         registry = PluginRegistry.load(reserved_commands: reserved_plugin_command_names)
+        @plugin_registry&.reload!
+        registry.start!
         sessions = @mutex.synchronize do
           @plugin_registry = registry
           @sessions.values
@@ -636,7 +670,7 @@ module Kward
           rpc_session.conversation.plugin_registry = registry if rpc_session.conversation.respond_to?(:plugin_registry=)
           rpc_session.conversation.refresh_system_message! if rpc_session.conversation.respond_to?(:refresh_system_message!)
           rebuild_session_tools(rpc_session)
-          if registry.footer_renderer
+          if registry.status?
             start_footer_worker(rpc_session)
             emit_footer_update(rpc_session)
           else
@@ -714,7 +748,9 @@ module Kward
         hook_context = lifecycle_hook_context(
           conversation: rpc_session.conversation,
           session: rpc_session.session,
-          workspace_root: rpc_session.workspace_root
+          workspace_root: rpc_session.workspace_root,
+          prompt: rpc_session.prompt,
+          session_id: rpc_session.id
         )
         hook_manager = lifecycle_hook_manager(rpc_session.workspace_root)
         tool_registry = build_tool_registry(
@@ -1042,7 +1078,13 @@ module Kward
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         id = SecureRandom.uuid
         prompt = PromptBridge.new(notify: method(:notify), session_id: id)
-        hook_context = lifecycle_hook_context(conversation: conversation, session: session, workspace_root: workspace_root)
+        hook_context = lifecycle_hook_context(
+          conversation: conversation,
+          session: session,
+          workspace_root: workspace_root,
+          prompt: prompt,
+          session_id: id
+        )
         hook_manager = lifecycle_hook_manager(workspace_root)
         tool_registry = build_tool_registry(workspace_root, prompt, hook_manager: hook_manager, hook_context: hook_context)
         agent = Agent.new(
@@ -1074,6 +1116,7 @@ module Kward
           workspace: configured_workspace(workspace_root),
           prompt: prompt,
           allowed_tool_names: allowed_tool_names,
+          plugin_tools: plugin_registry.tools,
           tool_approval: tool_approval,
           approval_for_allowed_tools: !tool_approval.nil?,
           hook_manager: hook_manager,
@@ -1115,13 +1158,16 @@ module Kward
         })
       end
 
-      def lifecycle_hook_context(conversation:, session:, workspace_root:)
+      def lifecycle_hook_context(conversation:, session:, workspace_root:, prompt: nil, session_id: nil)
+        say_callback = lambda { |message| notify("hook/message", { message: message.to_s }) }
         PluginRegistry::Context.new(
           conversation: conversation,
           args: "",
           session: session,
           workspace_root: workspace_root,
-          say_callback: lambda { |message| notify("hook/message", { message: message.to_s }) }
+          say_callback: say_callback,
+          ui: rpc_plugin_ui(prompt: prompt, session_id: session_id, say_callback: say_callback, requests: false),
+          tool_ui: rpc_plugin_ui(prompt: prompt, session_id: session_id, say_callback: say_callback, requests: !prompt.nil?)
         )
       end
 
@@ -1212,7 +1258,7 @@ module Kward
       end
 
       def start_footer_worker(rpc_session)
-        return unless plugin_registry.footer_renderer
+        return unless plugin_registry.status?
         return if rpc_session.footer_worker&.alive?
 
         rpc_session.footer_worker = Thread.new do
@@ -1290,18 +1336,7 @@ module Kward
         if turn.plugin_command_name
           run_plugin_turn(rpc_session, turn)
         else
-          auto_name_session(rpc_session, turn.display_input || turn.input)
-          prepare_memory_context(rpc_session.conversation, turn.input) unless memory_disabled?(turn)
-          rpc_session.agent.ask(turn.input, display_input: turn_display_input(turn), cancellation: turn.cancellation, steering: turn.steering, options: turn.options || {}, tool_registry: turn.tool_registry) do |event|
-            next if turn.cancel_requested
-
-            notify_plugin_transcript_event(rpc_session, event)
-            handle_agent_event(turn, event)
-          end
-          unless memory_disabled?(turn)
-            persist_memory_state(rpc_session)
-            auto_summarize_memory(rpc_session) unless turn.cancel_requested
-          end
+          run_session_model_turn(rpc_session, turn, input: turn.input, display_input: turn_display_input(turn))
           finish_turn(turn, turn.cancel_requested ? "canceled" : "completed")
         end
       rescue Cancellation::CancelledError
@@ -1316,6 +1351,22 @@ module Kward
         rpc_session.running_turn_id = nil
       end
 
+      def run_session_model_turn(rpc_session, turn, input:, display_input: nil)
+        auto_name_session(rpc_session, display_input || turn.display_input || input)
+        memory_input = input.is_a?(PluginTurnRequest) ? input.to_s : input
+        prepare_memory_context(rpc_session.conversation, memory_input) unless memory_disabled?(turn)
+        rpc_session.agent.ask(input, display_input: display_input, cancellation: turn.cancellation, steering: turn.steering, options: turn.options || {}, tool_registry: turn.tool_registry) do |event|
+          next if turn.cancel_requested
+
+          notify_plugin_transcript_event(rpc_session, event)
+          handle_agent_event(turn, event)
+        end
+        unless memory_disabled?(turn)
+          persist_memory_state(rpc_session)
+          auto_summarize_memory(rpc_session) unless turn.cancel_requested
+        end
+      end
+
       def build_steering(_turn)
         Steering.new
       end
@@ -1371,12 +1422,44 @@ module Kward
         turn_payload(turn)
       end
 
-      def plugin_context(rpc_session, args: nil, say_callback:)
+      def plugin_context(rpc_session, args: nil, say_callback:, requests: false, cancellation: nil, turn_command: nil)
         PluginRegistry::Context.new(
           conversation: rpc_session.conversation,
           args: args,
           session: rpc_session.session,
           workspace_root: rpc_session.workspace_root,
+          say_callback: say_callback,
+          cancellation: cancellation,
+          turn_command: turn_command,
+          ui: rpc_plugin_ui(
+            prompt: rpc_session.prompt,
+            session_id: rpc_session.id,
+            say_callback: say_callback,
+            requests: requests
+          )
+        )
+      end
+
+      def rpc_plugin_ui(prompt:, session_id:, say_callback:, requests:)
+        capabilities = { progress: true, notify: true }
+        requester = nil
+        if requests && prompt
+          capabilities.merge!(question: true, select: true, confirm: true, input: true)
+          requester = lambda do |kind, payload, cancellation: nil|
+            if kind == :question
+              prompt.ask_user_question(payload.fetch(:questions), cancellation: cancellation)
+            else
+              prompt.request_plugin_ui(kind, payload, cancellation: cancellation)
+            end
+          end
+        end
+        emitter = lambda do |kind, payload|
+          method = kind == :progress ? "ui/progress" : "ui/notification"
+          payload = payload.merge(level: payload[:level].to_s) if payload[:level]
+          notify(method, { sessionId: session_id }.merge(payload))
+        end
+        PluginUI.new(
+          backend: PluginUI::Backend.new(capabilities: capabilities, requester: requester, emitter: emitter),
           say_callback: say_callback
         )
       end
@@ -1384,13 +1467,30 @@ module Kward
       def run_plugin_turn(rpc_session, turn)
         turn.cancellation&.raise_if_cancelled!
         command = plugin_registry.command_for(turn.plugin_command_name) || raise(ArgumentError, "Unknown plugin command: #{turn.plugin_command_name}")
+        arguments = command.parse_arguments(turn.plugin_arguments)
         output = []
-        context = plugin_context(rpc_session, args: turn.plugin_arguments.to_s, say_callback: lambda { |message| output << message.to_s })
-        result = command.handler.call(turn.plugin_arguments.to_s, context)
+        context = plugin_context(
+          rpc_session,
+          args: arguments,
+          say_callback: lambda { |message| output << message.to_s },
+          requests: true,
+          cancellation: turn.cancellation,
+          turn_command: command
+        )
+        result = command.normalize_result(command.handler.call(arguments, context))
+        turn.cancellation&.raise_if_cancelled!
+        if command.typed?
+          emit_turn_event(turn, "pluginCommandResult", { command: command.name, result: result.to_h })
+          result = result.message
+        end
         answer = (output + [result]).compact.map(&:to_s).reject(&:empty?).join("\n")
         unless answer.empty?
           emit_turn_event(turn, "assistantDelta", { delta: answer })
-          emit_turn_event(turn, "answer", { content: answer })
+          emit_turn_event(turn, "answer", { content: answer }) unless context.requested_turn
+        end
+        if context.requested_turn
+          turn.steering = build_steering(turn) if supports_in_flight_steer?
+          run_session_model_turn(rpc_session, turn, input: context.requested_turn, display_input: context.requested_turn.to_s)
         end
         finish_turn(turn, turn.cancel_requested ? "canceled" : "completed")
       end
@@ -1457,27 +1557,30 @@ module Kward
       end
 
       def emit_footer_update(rpc_session)
-        renderer = plugin_registry.footer_renderer
-        return clear_footer_update(rpc_session) unless renderer
+        return clear_footer_update(rpc_session) unless plugin_registry.status?
 
-        text = begin
+        segments = begin
           context = plugin_context(rpc_session, say_callback: lambda { |message| rpc_session.plugin_output << message.to_s })
-          renderer.call(context).to_s.gsub(/\s+/, " ").strip
+          plugin_registry.status_segments(context)
         rescue StandardError => e
           warn "Warning: Kward plugin footer error: #{e.message}"
-          ""
+          []
         end
-        return if rpc_session.last_footer_text == text
+        segment_payloads = segments.map(&:to_h)
+        text = plugin_registry.compose_status(segments)
+        return if rpc_session.last_footer_text == text && rpc_session.last_footer_segments == segment_payloads
 
         rpc_session.last_footer_text = text
-        notify("ui/footer", { sessionId: rpc_session.id, text: text })
+        rpc_session.last_footer_segments = segment_payloads
+        notify("ui/footer", { sessionId: rpc_session.id, text: text, segments: segment_payloads })
       end
 
       def clear_footer_update(rpc_session)
-        return if rpc_session.last_footer_text.to_s.empty?
+        return if rpc_session.last_footer_text.to_s.empty? && Array(rpc_session.last_footer_segments).empty?
 
         rpc_session.last_footer_text = ""
-        notify("ui/footer", { sessionId: rpc_session.id, text: "" })
+        rpc_session.last_footer_segments = []
+        notify("ui/footer", { sessionId: rpc_session.id, text: "", segments: [] })
       end
 
       def emit_turn_event(turn, type, payload)

data/lib/kward/rpc/session_tree_rows.rb

@@ -1,7 +1,7 @@
 require_relative "../message_access"
 require_relative "../message_text"
-require_relative "../session_tree_nodes"
-require_relative "../session_tree_tool_display"
+require_relative "../sessions/tree_nodes"
+require_relative "../sessions/tree_tool_display"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/rpc/tool_metadata.rb

@@ -1,5 +1,5 @@
 require_relative "../tools/tool_call"
-require_relative "../workspace"
+require_relative "../workspace/workspace"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/rpc/transcript_normalizer.rb

@@ -173,10 +173,14 @@ module Kward
           when "reasoning"
             reasoning_item_blocks(item).map { |thinking| { type: "thinking", thinking: thinking } }
           when "message"
-            next [] if ToolCall.value(item, :phase).to_s == "commentary"
-
             text = response_message_item_text(item)
-            text.empty? ? [] : [{ type: "text", text: text }]
+            next [] if text.empty?
+
+            if ToolCall.value(item, :phase).to_s == "commentary"
+              [{ type: "thinking", thinking: text }]
+            else
+              [{ type: "text", text: text }]
+            end
           else
             []
           end

data/lib/kward/sandbox/command_runner.rb

@@ -1,4 +1,4 @@
-require_relative "../local_command_runner"
+require_relative "../pty/local_command_runner"
 
 # Namespace for operating-system command sandboxing.
 module Kward

data/lib/kward/{session_catalog.rb → sessions/catalog.rb}

@@ -1,5 +1,5 @@
 require "json"
-require_relative "private_file"
+require_relative "../private_file"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/{session_store.rb → sessions/store.rb}

@@ -3,15 +3,15 @@ require "digest"
 require "json"
 require "securerandom"
 require "time"
-require_relative "config_files"
-require_relative "conversation"
-require_relative "message_access"
-require_relative "message_text"
-require_relative "private_file"
-require_relative "rpc/tool_event_normalizer"
-require_relative "session_catalog"
-require_relative "tools/tool_call"
-require_relative "workspace"
+require_relative "../config_files"
+require_relative "../conversation"
+require_relative "../message_access"
+require_relative "../message_text"
+require_relative "../private_file"
+require_relative "../rpc/tool_event_normalizer"
+require_relative "catalog"
+require_relative "../tools/tool_call"
+require_relative "../workspace/workspace"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/{session_tree_nodes.rb → sessions/tree_nodes.rb}

@@ -1,6 +1,6 @@
-require_relative "message_access"
-require_relative "message_text"
-require_relative "tools/tool_call"
+require_relative "../message_access"
+require_relative "../message_text"
+require_relative "../tools/tool_call"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/{session_tree_renderer.rb → sessions/tree_renderer.rb}

@@ -1,7 +1,7 @@
-require_relative "message_access"
-require_relative "message_text"
-require_relative "session_tree_nodes"
-require_relative "session_tree_tool_display"
+require_relative "../message_access"
+require_relative "../message_text"
+require_relative "tree_nodes"
+require_relative "tree_tool_display"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/{session_tree_tool_display.rb → sessions/tree_tool_display.rb}

@@ -1,5 +1,5 @@
 require "json"
-require_relative "tools/tool_call"
+require_relative "../tools/tool_call"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/{ekwsh.rb → shell/kwsh.rb}

@@ -1,8 +1,8 @@
 require "shellwords"
-require_relative "ansi"
-require_relative "local_command_runner"
+require_relative "../terminal/ansi"
+require_relative "../pty/local_command_runner"
 begin
-  require_relative "local_pty_command_runner"
+  require_relative "../pty/local_pty_runner"
 rescue LoadError
   nil
 end
@@ -10,10 +10,10 @@ end
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Kward-native embedded shell command runner.
-  class Ekwsh
+  class Kwsh
     Result = Struct.new(:output, :exit_status, :exit_shell, :clear, :open_editor_path, :interactive_command, :streamed, keyword_init: true)
     Completion = Struct.new(:range, :replacement, :candidates, keyword_init: true)
-    BUILTINS = %w[alias capture cd pwd export unset unalias clear exit logout pty].freeze
+    BUILTINS = %w[alias capture cd pwd export source unset unalias clear exit logout pty].freeze
     DEFAULT_SHELL = "/bin/sh"
     DEFAULT_TIMEOUT_SECONDS = 300
     DEFAULT_MAX_OUTPUT_BYTES = 1_048_576
@@ -60,7 +60,7 @@ module Kward
     end
 
     # Runs a command for the shell assistant without handing it the terminal.
-    # Built-ins still execute in this Ekwsh instance so their state persists.
+    # Built-ins still execute in this Kwsh instance so their state persists.
     def run_for_agent(input, timeout_seconds: nil, cancellation: nil)
       command = input.to_s.strip
       return run(command, cancellation: cancellation) if command.empty?
@@ -322,12 +322,12 @@ module Kward
       return nil unless %w[exit logout].include?(words.first)
 
       if words.length > 2 || (words[1] && !words[1].match?(/\A\d+\z/))
-        return Result.new(output: "#{command_echo(display_command)}ekwsh: #{words.first}: numeric status expected\n", exit_status: 2)
+        return Result.new(output: "#{command_echo(display_command)}kwsh: #{words.first}: numeric status expected\n", exit_status: 2)
       end
 
       Result.new(output: command_echo(display_command), exit_status: words[1].to_i, exit_shell: true)
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 2)
     end
 
     def builtin_result(command, display_command: command, cancellation: nil, &block)
@@ -347,6 +347,8 @@ module Kward
         print_working_directory(display_command, words)
       when "export"
         export_variables(display_command, words)
+      when "source", "."
+        source_file(display_command, words)
       when "unset"
         unset_variables(display_command, words)
       when "clear"
@@ -359,7 +361,7 @@ module Kward
         nil
       end
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 2)
     end
 
     def captured_command_result(command, display_command:, cancellation: nil, &block)
@@ -399,7 +401,7 @@ module Kward
           invalid << name
         end
       end
-      return Result.new(output: "#{command_echo(command)}ekwsh: alias: invalid name: #{invalid.join(" ")}\n", exit_status: 2) unless invalid.empty?
+      return Result.new(output: "#{command_echo(command)}kwsh: alias: invalid name: #{invalid.join(" ")}\n", exit_status: 2) unless invalid.empty?
 
       names = @aliases.keys.sort if names.empty? && assignments.empty?
       lines = names.filter_map { |name| @aliases[name] ? "alias #{name}=#{Shellwords.escape(@aliases.fetch(name))}" : nil }
@@ -417,7 +419,7 @@ module Kward
       end
 
       missing = words.drop(1).reject { |name| @aliases.delete(name) }
-      return Result.new(output: "#{command_echo(command)}ekwsh: unalias: not found: #{missing.join(" ")}\n", exit_status: 1) unless missing.empty?
+      return Result.new(output: "#{command_echo(command)}kwsh: unalias: not found: #{missing.join(" ")}\n", exit_status: 1) unless missing.empty?
 
       Result.new(output: command_echo(command), exit_status: 0)
     end
@@ -455,7 +457,7 @@ module Kward
       path = File.expand_path(words[2], @cwd)
       Result.new(output: command_echo(display_command), exit_status: 0, open_editor_path: path)
     rescue ArgumentError => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 2)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 2)
     end
 
     def kward_edit_command?(words)
@@ -489,7 +491,7 @@ module Kward
 
     def change_directory(command, words)
       if words.length > 2
-        return Result.new(output: "#{command_echo(command)}ekwsh: cd: too many arguments\n", exit_status: 2)
+        return Result.new(output: "#{command_echo(command)}kwsh: cd: too many arguments\n", exit_status: 2)
       end
 
       target = words[1]
@@ -497,7 +499,7 @@ module Kward
       target = @previous_cwd || @cwd if target == "-"
       path = File.expand_path(target, @cwd)
       unless File.directory?(path)
-        return Result.new(output: "#{command_echo(command)}ekwsh: cd: no such directory: #{target}\n", exit_status: 1)
+        return Result.new(output: "#{command_echo(command)}kwsh: cd: no such directory: #{target}\n", exit_status: 1)
       end
 
       @previous_cwd = @cwd
@@ -528,10 +530,27 @@ module Kward
       if invalid.empty?
         Result.new(output: command_echo(command), exit_status: 0)
       else
-        Result.new(output: "#{command_echo(command)}ekwsh: export: invalid assignment: #{invalid.join(" ")}\n", exit_status: 2)
+        Result.new(output: "#{command_echo(command)}kwsh: export: invalid assignment: #{invalid.join(" ")}\n", exit_status: 2)
       end
     end
 
+    def source_file(command, words)
+      unless words.length == 2
+        return Result.new(output: "#{command_echo(command)}Usage: source <file>\n", exit_status: 2)
+      end
+
+      require_relative "kwshrc"
+      path = Kwshrc.resolve_path(words[1], cwd: @cwd, env: @env)
+      config = Kwshrc.read_file(path, env: @env)
+      path_changed = config[:env].key?("PATH")
+      @env.merge!(config[:env])
+      @aliases.merge!(config[:aliases])
+      invalidate_path_executables_cache if path_changed
+      Result.new(output: command_echo(command), exit_status: 0)
+    rescue Kwshrc::ParseError => e
+      Result.new(output: "#{command_echo(command)}kwsh: source: #{e.message}\n", exit_status: 1)
+    end
+
     def unset_variables(command, words)
       names = words.drop(1)
       names.shift if names.first == "--"
@@ -541,7 +560,7 @@ module Kward
       if invalid.empty?
         Result.new(output: command_echo(command), exit_status: 0)
       else
-        Result.new(output: "#{command_echo(command)}ekwsh: unset: invalid name: #{invalid.join(" ")}\n", exit_status: 2)
+        Result.new(output: "#{command_echo(command)}kwsh: unset: invalid name: #{invalid.join(" ")}\n", exit_status: 2)
       end
     end
 
@@ -575,8 +594,8 @@ module Kward
       end
       append_output_newline(output) { |text| yield text if streamed }
       exit_status = result.timed_out || result.truncated ? 1 : (result.exit_status || 1)
-      append_streamed(output, "ekwsh: command timed out after #{timeout} seconds\n", streamed) { |text| yield text } if result.timed_out
-      append_streamed(output, "ekwsh: output exceeded #{@max_output_bytes} bytes; command terminated\n", streamed) { |text| yield text } if result.truncated
+      append_streamed(output, "kwsh: command timed out after #{timeout} seconds\n", streamed) { |text| yield text } if result.timed_out
+      append_streamed(output, "kwsh: output exceeded #{@max_output_bytes} bytes; command terminated\n", streamed) { |text| yield text } if result.truncated
       append_streamed(output, "Exit status: #{exit_status}\n", streamed) { |text| yield text } unless exit_status.zero?
       Result.new(output: output, exit_status: exit_status, streamed: streamed)
     rescue Cancellation::CancelledError
@@ -584,7 +603,7 @@ module Kward
       append_streamed(output, "^C\nExit status: 130\n", streamed) { |text| yield text }
       Result.new(output: output, exit_status: 130, streamed: streamed)
     rescue Errno::ENOENT => e
-      Result.new(output: "#{command_echo(display_command)}ekwsh: #{e.message}\n", exit_status: 127)
+      Result.new(output: "#{command_echo(display_command)}kwsh: #{e.message}\n", exit_status: 127)
     end
 
     def effective_timeout(timeout_seconds)