kward 0.83.0 → 0.84.0

data/lib/kward/markdown_code_block.rb

@@ -0,0 +1,136 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Finds fenced Markdown code blocks and manages their adjacent output fields.
+  class MarkdownCodeBlock
+    Block = Struct.new(
+      :source, :open_line, :close_line, :language, :body_start, :body_end, :close_end, :next_fence_start,
+      keyword_init: true
+    ) do
+      def code
+        source[body_start...body_end].to_s
+      end
+
+      def output_match
+        limit = next_fence_start || source.length
+        match = source.match(/<output\b[^>]*>.*?<\/output>/mi, close_end)
+        match if match && match.begin(0) < limit && match.end(0) <= limit
+      end
+
+      def output_edit(output)
+        replacement = MarkdownCodeBlock.format_output(output, newline: newline)
+        match = output_match
+        if match
+          [match.begin(0), match.end(0), replacement]
+        else
+          insertion = if source[close_end - newline.length, newline.length] == newline
+                         "#{newline}#{replacement}#{newline}"
+                       else
+                         "#{newline}#{newline}#{replacement}#{newline}"
+                       end
+          [close_end, close_end, insertion]
+        end
+      end
+
+      def with_output(output)
+        start_index, end_index, replacement = output_edit(output)
+        source.dup.tap { |content| content[start_index...end_index] = replacement }
+      end
+
+      private
+
+      def newline
+        source[body_end...close_end].to_s.end_with?("\r\n") ? "\r\n" : "\n"
+      end
+    end
+
+    Fence = Struct.new(:line, :start, :finish, :marker, :length, :language, :close_line, :close_start, :close_end, keyword_init: true)
+
+    class << self
+      def for_selection(source, first_line, last_line)
+        blocks = parse(source)
+        candidates = blocks.select do |block|
+          full_fence = first_line == block.open_line && last_line == block.close_line
+          body_only = block.open_line < first_line && last_line < block.close_line
+          full_fence || body_only
+        end
+        candidates.min_by { |block| block.close_line - block.open_line }
+      end
+
+      def for_cursor(source, line)
+        parse(source).select do |block|
+          block.open_line <= line && line <= block.close_line
+        end.min_by { |block| block.close_line - block.open_line }
+      end
+
+      def parse(source)
+        source = source.to_s
+        lines = source.lines
+        fences = []
+        open_fences = []
+        offset = 0
+
+        lines.each_with_index do |line, line_number|
+          content = line.chomp
+          if (match = content.match(/\A\s*(`{3,}|~{3,})(.*)\z/))
+            marker = match[1][0]
+            length = match[1].length
+            rest = match[2]
+            closing = rest.match?(/\A\s*\z/)
+
+            if closing && open_fences.last&.marker == marker && length >= open_fences.last.length
+              opening = open_fences.pop
+              fences << Fence.new(
+                line: line_number,
+                start: offset,
+                finish: offset + line.length,
+                marker: marker,
+                length: length,
+                language: opening.language
+              )
+              opening.close_line = line_number
+              opening.close_start = offset
+              opening.close_end = offset + line.length
+              offset += line.length
+              next
+            end
+
+            next if closing
+
+            opening = Fence.new(
+              line: line_number,
+              start: offset,
+              finish: offset + line.length,
+              marker: marker,
+              length: length,
+              language: rest.strip.split(/\s+/, 2).first
+            )
+            open_fences << opening
+            fences << opening
+          end
+          offset += line.length
+        end
+
+        completed = fences.select { |fence| fence.close_line }
+        completed.map do |opening|
+          next_fence = fences.map(&:start).select { |start| start > opening.close_end }.min
+          Block.new(
+            source: source,
+            open_line: opening.line,
+            close_line: opening.close_line,
+            language: opening.language,
+            body_start: opening.finish,
+            body_end: opening.close_start,
+            close_end: opening.close_end,
+            next_fence_start: next_fence
+          )
+        end
+      end
+
+      def format_output(output, newline: "\n")
+        body = output.to_s.gsub(/\r\n?/, "\n").chomp
+        body = body.gsub("\n", newline)
+        body.empty? ? "<output>#{newline}</output>" : "<output>#{newline}#{body}#{newline}</output>"
+      end
+    end
+  end
+end

data/lib/kward/model/client.rb

@@ -37,12 +37,12 @@ module Kward
       "lm_studio" => "http://127.0.0.1:1234/v1",
       "llama_cpp" => "http://127.0.0.1:8080/v1"
     }.freeze
-    AUTH_ERROR = "No OpenAI OAuth login found. Run `ruby lib/main.rb login`, or set OPENAI_ACCESS_TOKEN/OPENROUTER_API_KEY."
-    OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Set OPENROUTER_API_KEY or sign in with an API key."
-    OPENAI_API_AUTH_ERROR = "No OpenAI API key found. Set OPENAI_API_KEY or sign in with an API key."
-    AZURE_OPENAI_AUTH_ERROR = "No Azure OpenAI API key found. Set AZURE_OPENAI_API_KEY or sign in with an API key."
-    COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `ruby lib/main.rb login github` or set COPILOT_GITHUB_TOKEN."
-    ANTHROPIC_AUTH_ERROR = "No Anthropic OAuth login found. Run `ruby lib/main.rb login anthropic`."
+    AUTH_ERROR = "No OpenAI OAuth login found. Run `kward login`, or set OPENAI_ACCESS_TOKEN or OPENROUTER_API_KEY."
+    OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Run `kward login openrouter`, or set OPENROUTER_API_KEY."
+    OPENAI_API_AUTH_ERROR = "No OpenAI API key found. Run `kward login`, or set OPENAI_API_KEY."
+    AZURE_OPENAI_AUTH_ERROR = "No Azure OpenAI API key found. Run `kward login`, or set AZURE_OPENAI_API_KEY."
+    COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `kward login github`, or set COPILOT_GITHUB_TOKEN."
+    ANTHROPIC_AUTH_ERROR = "No Anthropic OAuth login found. Run `kward login anthropic`."
     DEFAULT_OPENAI_MODEL = ModelInfo::DEFAULT_OPENAI_MODEL
     DEFAULT_REASONING_EFFORT = ModelInfo::DEFAULT_REASONING_EFFORT
     RETRY_DELAYS = [1, 2].freeze
@@ -61,6 +61,8 @@ module Kward
       /(?:exceeded|reached).*(?:usage|quota|credit|budget|balance)/i
     ].freeze
 
+    AuthenticationError = Class.new(RuntimeError)
+
     RequestError = Class.new(StandardError) do
       attr_reader :provider, :code, :body
 
@@ -108,11 +110,12 @@ module Kward
       @local_models = nil
     end
 
-    def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
+    def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil, provider_required: false)
       cancellation&.raise_if_cancelled!
       requested_provider = provider
+      validate_required_provider!(requested_provider) if provider_required
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
-      if token.to_s.empty? && authentication_required?(resolved_provider) && !requested_provider.to_s.empty? && resolved_provider != "OpenAI"
+      if token.to_s.empty? && authentication_required?(resolved_provider) && !provider_required && !requested_provider.to_s.empty? && resolved_provider != "OpenAI"
         url, token, resolved_provider, account_id = credentials
         model = nil
         reasoning = nil
@@ -593,20 +596,22 @@ module Kward
     end
 
     def auth_error_for(provider)
-      case provider
-      when "Azure OpenAI"
-        AZURE_OPENAI_AUTH_ERROR
-      when "OpenAI"
-        OPENAI_API_AUTH_ERROR
-      when "OpenRouter"
-        OPENROUTER_AUTH_ERROR
-      when "Copilot"
-        COPILOT_AUTH_ERROR
-      when "Anthropic"
-        ANTHROPIC_AUTH_ERROR
-      else
-        AUTH_ERROR
-      end
+      message =
+        case provider
+        when "Azure OpenAI"
+          AZURE_OPENAI_AUTH_ERROR
+        when "OpenAI"
+          OPENAI_API_AUTH_ERROR
+        when "OpenRouter"
+          OPENROUTER_AUTH_ERROR
+        when "Copilot"
+          COPILOT_AUTH_ERROR
+        when "Anthropic"
+          ANTHROPIC_AUTH_ERROR
+        else
+          AUTH_ERROR
+        end
+      AuthenticationError.new(message)
     end
 
     def with_retries(provider, model, request_bytes: nil, on_retry: nil, cancellation: nil)
@@ -1063,6 +1068,13 @@ module Kward
       ModelInfo.reasoning_effort(config: @config, provider: provider)
     end
 
+    def validate_required_provider!(provider)
+      provider_id = provider.to_s.strip.downcase
+      return if ProviderCatalog.configuration_ids.include?(provider_id)
+
+      raise ArgumentError, "Unknown provider: #{provider}"
+    end
+
     def authentication_required?(provider)
       provider != "Local"
     end

data/lib/kward/model/provider_catalog.rb

@@ -71,9 +71,14 @@ module Kward
       Definition.new(id: "xai", name: "xAI", api_key_env: ["XAI_API_KEY"], protocol: "openai_chat", oauth_name: "xAI Grok"),
       Definition.new(id: "copilot", name: "GitHub Copilot", api_key_env: [], protocol: "copilot", oauth_name: "GitHub Copilot")
     ].freeze
+    CONFIGURATION_IDS = (["codex", "openai_api", "local"] + DEFINITIONS.map(&:id).reject { |id| id == "openai" }).freeze
 
     module_function
 
+    def configuration_ids
+      CONFIGURATION_IDS
+    end
+
     def all
       DEFINITIONS
     end

data/lib/kward/model/stream_parser.rb

@@ -347,7 +347,7 @@ module Kward
       when "response.content_part.added"
         codex_content_part_added(state, event["part"])
       when "response.output_text.delta", "response.refusal.delta"
-        codex_output_text_delta(state, event["delta"], on_assistant_delta: on_assistant_delta)
+        codex_output_text_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta)
       when "response.reasoning_summary_part.added"
         codex_reasoning_summary_part_added(state, event["part"])
       when "response.reasoning_summary_text.delta"
@@ -417,7 +417,7 @@ module Kward
       state[:current_text_content_part] = item["content"].last
     end
 
-    def codex_output_text_delta(state, delta, on_assistant_delta: nil)
+    def codex_output_text_delta(state, delta, on_reasoning_delta: nil, on_assistant_delta: nil)
       text = delta.to_s
       return if text.empty?
 
@@ -432,6 +432,9 @@ module Kward
         if codex_streamable_message_item?(item)
           on_assistant_delta&.call(text)
           state[:emitted_message_keys] << codex_item_key(item)
+        elsif codex_commentary_message_item?(item)
+          on_reasoning_delta&.call(text)
+          state[:emitted_message_keys] << codex_item_key(item)
         end
       end
       state[:raw_content] << text
@@ -647,10 +650,19 @@ module Kward
       case item["type"]
       when "message"
         text = text_from_codex_items([item])
-        return if text.empty? || !codex_streamable_message_item?(item)
+        return if text.empty?
 
-        state[:content] << text
         key = codex_item_key(item)
+        if codex_commentary_message_item?(item)
+          unless state[:emitted_message_keys].include?(key)
+            on_reasoning_delta&.call(text)
+            state[:emitted_message_keys] << key
+          end
+          return
+        end
+        return unless codex_streamable_message_item?(item)
+
+        state[:content] << text
         unless state[:emitted_message_keys].include?(key)
           on_assistant_delta&.call(text)
           state[:emitted_message_keys] << key
@@ -774,6 +786,10 @@ module Kward
       phase.empty? || phase == "final_answer"
     end
 
+    def codex_commentary_message_item?(item)
+      codex_message_phase(item) == "commentary"
+    end
+
     def codex_message_phase(item)
       item["phase"].to_s
     end

data/lib/kward/pan/index.html.erb

@@ -162,7 +162,7 @@
         <button class="icon-button" id="open-sessions" type="button" aria-label="Open sessions">☰</button>
         <div class="title-block">
           <div class="title-row"><span class="live-dot"></span><h1 id="conversation-title">New session</h1></div>
-          <div class="top-meta" id="session-meta">Secure LAN workspace</div>
+          <div class="top-meta" id="session-meta">Authenticated HTTP workspace</div>
         </div>
         <button class="text-button" id="capture-skill" type="button">Capture skill</button>
         <button class="text-button" id="rename-session" type="button">Rename</button>
@@ -176,7 +176,7 @@
       <div class="composer-shell">
         <form id="prompt-form">
           <div class="composer">
-            <textarea id="prompt" name="prompt" rows="1" autocomplete="off" enterkeyhint="send" aria-label="Prompt" placeholder="Give <%= ERB::Util.html_escape(@assistant_label) %> an order…"></textarea>
+            <textarea id="prompt" name="prompt" rows="1" autocomplete="off" enterkeyhint="send" aria-label="Prompt" placeholder="Ask <%= ERB::Util.html_escape(@assistant_label) %> to inspect, explain, or change code…"></textarea>
             <button class="send" id="send" type="submit" aria-label="Send prompt">↑</button>
           </div>
           <div class="composer-meta"><span id="status">Connecting…</span><span>Return to send · Shift Return for a new line</span></div>
@@ -437,7 +437,7 @@
       if (!activeSession) return;
       titleEl.textContent = activeSession.title || activeSession.name || 'New session';
       const details = [activeSession.model, activeSession.messageCount != null ? `${activeSession.messageCount} messages` : null].filter(Boolean);
-      sessionMeta.textContent = details.join(' · ') || 'Secure LAN workspace';
+      sessionMeta.textContent = details.join(' · ') || 'Authenticated HTTP workspace';
     }
 
     async function changeSession(action, values = {}) {

data/lib/kward/pan/server.rb

@@ -1,5 +1,6 @@
 require "base64"
 require "erb"
+require "ipaddr"
 require "json"
 require "socket"
 require "thread"
@@ -24,7 +25,7 @@ require_relative "../workspace_factory"
 module Kward
   # Local HTTP server for the mobile-friendly Pan web UI.
   class PanServer
-    DEFAULT_HOST = "0.0.0.0"
+    DEFAULT_HOST = "127.0.0.1"
     DEFAULT_PORT = 8765
     MAX_REQUEST_BODY_BYTES = 64 * 1024
     ROUTING_PROBE_ADDRESS = "8.8.8.8"
@@ -44,8 +45,11 @@ module Kward
       @host = @config.fetch("host", DEFAULT_HOST).to_s
       @port = positive_port(@config.fetch("port", DEFAULT_PORT))
       @username = @config["username"].to_s
-      @password = @config["password"].to_s
-      raise "Pan mode requires pan_mode.username and pan_mode.password in #{ConfigFiles.config_path}" if @username.empty? || @password.empty?
+      environment_password = ENV["KWARD_PAN_PASSWORD"].to_s
+      @password = environment_password.empty? ? @config["password"].to_s : environment_password
+      if @username.empty? || @password.empty?
+        raise "Pan mode requires pan_mode.username and either pan_mode.password or KWARD_PAN_PASSWORD"
+      end
 
       @session_store = SessionStore.new(config_dir: config_dir, cwd: @workspace.root.to_s)
       @session = @session_store.create(
@@ -69,6 +73,7 @@ module Kward
     attr_reader :host, :port, :session, :workspace
 
     def run
+      warn_if_exposed
       start_worker
       @server = TCPServer.new(@host, @port)
       actual_port = @server.addr[1]
@@ -595,6 +600,21 @@ module Kward
       lan_address || "<lan-address>"
     end
 
+    def warn_if_exposed
+      return if loopback_host?
+
+      @output.puts "Warning: Pan is exposed over plain HTTP on #{@host}."
+      @output.puts "Use it only on a trusted network, or bind pan_mode.host to 127.0.0.1."
+    end
+
+    def loopback_host?
+      return true if @host.casecmp?("localhost")
+
+      IPAddr.new(@host).loopback?
+    rescue IPAddr::InvalidAddressError
+      false
+    end
+
     def lan_address
       socket = @udp_socket_class.new
       socket.connect(ROUTING_PROBE_ADDRESS, ROUTING_PROBE_PORT)

data/lib/kward/persistent_shell_session.rb

@@ -3,8 +3,10 @@ require "pty"
 require "securerandom"
 require "shellwords"
 require_relative "ansi"
-require_relative "ekwsh"
+require_relative "kwsh"
+require_relative "kwshrc"
 require_relative "local_pty_command_runner"
+require_relative "detached_run"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -13,8 +15,8 @@ module Kward
   # The process is kept alive between commands so shell variables, functions,
   # aliases, directory changes, and child-shell state belong to one session.
   class PersistentShellSession
-    Result = Ekwsh::Result
-    InteractiveResult = Struct.new(:exit_status, :input_forwarded, keyword_init: true)
+    Result = Kwsh::Result
+    InteractiveResult = Struct.new(:exit_status, :input_forwarded, :tab_action, :background, keyword_init: true)
 
     class CommandInterrupted < StandardError
       attr_reader :protocol
@@ -38,14 +40,14 @@ module Kward
 
     attr_reader :cwd, :last_command, :timeout_seconds
 
-    def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: Ekwsh::DEFAULT_SHELL, configured_env: {}, aliases: {}, timeout_seconds: Ekwsh::DEFAULT_TIMEOUT_SECONDS, max_output_bytes: Ekwsh::DEFAULT_MAX_OUTPUT_BYTES, window_size_provider: nil)
+    def initialize(cwd: Dir.pwd, env: ENV.to_h, shell: Kwsh::DEFAULT_SHELL, configured_env: {}, aliases: {}, timeout_seconds: Kwsh::DEFAULT_TIMEOUT_SECONDS, max_output_bytes: Kwsh::DEFAULT_MAX_OUTPUT_BYTES, window_size_provider: nil)
       @cwd = File.expand_path(cwd.to_s.empty? ? Dir.pwd : cwd.to_s)
       @base_env = env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
       @configured_env = configured_env.to_h.transform_keys(&:to_s).transform_values(&:to_s)
       @aliases = aliases.to_h.transform_keys(&:to_s).transform_values(&:to_s)
-      @shell = shell.to_s.empty? ? Ekwsh::DEFAULT_SHELL : shell.to_s
-      @timeout_seconds = timeout_seconds.to_i.positive? ? timeout_seconds.to_i : Ekwsh::DEFAULT_TIMEOUT_SECONDS
-      @max_output_bytes = max_output_bytes.to_i.positive? ? max_output_bytes.to_i : Ekwsh::DEFAULT_MAX_OUTPUT_BYTES
+      @shell = shell.to_s.empty? ? Kwsh::DEFAULT_SHELL : shell.to_s
+      @timeout_seconds = timeout_seconds.to_i.positive? ? timeout_seconds.to_i : Kwsh::DEFAULT_TIMEOUT_SECONDS
+      @max_output_bytes = max_output_bytes.to_i.positive? ? max_output_bytes.to_i : Kwsh::DEFAULT_MAX_OUTPUT_BYTES
       @window_size_provider = window_size_provider
       @last_command = nil
       @last_result = nil
@@ -93,6 +95,8 @@ module Kward
         capture_result(command, expanded_command, cancellation: cancellation, &block)
       elsif words.first == "pty"
         interactive_result(command, expanded_command)
+      elsif %w[source .].include?(words.first)
+        source_result(command, words)
       elsif (editor_result = editor_command_result(command))
         editor_result
       elsif stateful_command?(words)
@@ -103,7 +107,7 @@ module Kward
       remember_result(command, result)
       result
     rescue ArgumentError => e
-      result = Result.new(output: "#{command_echo(command)}ekwsh: #{e.message}\n", exit_status: 2)
+      result = Result.new(output: "#{command_echo(command)}kwsh: #{e.message}\n", exit_status: 2)
       remember_result(command, result)
       result
     end
@@ -129,14 +133,16 @@ module Kward
 
     # Runs an external command through the same persistent shell process while
     # the caller owns the terminal.
-    def run_interactive(command, input:, sink:)
+    def run_interactive(command, input:, sink:, tab_action_handler: nil, on_detach: nil)
       protocol = with_raw_input(input) do
-        execute_protocol(command, input: input, sink: sink)
+        execute_protocol(command, input: input, sink: sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
       end
-      update_cwd(protocol[:cwd])
+      update_cwd(protocol[:cwd]) unless protocol[:background]
       InteractiveResult.new(
         exit_status: protocol[:status] || 1,
-        input_forwarded: protocol[:input_forwarded]
+        input_forwarded: protocol[:input_forwarded],
+        tab_action: protocol[:tab_action],
+        background: protocol[:background]
       )
     ensure
       sink.finish if sink.respond_to?(:finish)
@@ -150,7 +156,7 @@ module Kward
     end
 
     # Returns bounded shell state for an explicit shell-agent prompt.
-    def context_snapshot(max_output_bytes: Ekwsh::CONTEXT_OUTPUT_BYTES)
+    def context_snapshot(max_output_bytes: Kwsh::CONTEXT_OUTPUT_BYTES)
       {
         cwd: @cwd,
         last_command: @last_command,
@@ -207,7 +213,7 @@ module Kward
     end
 
     def build_routing_shell
-      Ekwsh.new(
+      Kwsh.new(
         cwd: @cwd,
         env: @env || @base_env,
         shell: @shell,
@@ -253,7 +259,7 @@ module Kward
       update_cwd(protocol[:cwd])
     end
 
-    def execute_protocol(command, input: nil, sink: nil, timeout_seconds: nil, max_output_bytes: @max_output_bytes, cancellation: nil, suppress_git_pager: false)
+    def execute_protocol(command, input: nil, sink: nil, timeout_seconds: nil, max_output_bytes: @max_output_bytes, cancellation: nil, suppress_git_pager: false, tab_action_handler: nil, on_detach: nil)
       @command_mutex.synchronize do
         ensure_open
         cancellation&.raise_if_cancelled!
@@ -265,11 +271,13 @@ module Kward
           sink: sink,
           timeout_seconds: timeout_seconds,
           max_output_bytes: max_output_bytes,
-          cancellation: cancellation
+          cancellation: cancellation,
+          tab_action_handler: tab_action_handler,
+          on_detach: on_detach
         )
       end
     rescue CommandInterrupted => e
-      restart_process
+      restart_process unless e.protocol[:background]
       e.protocol
     rescue IOError
       close
@@ -320,8 +328,8 @@ module Kward
       [setup, restore]
     end
 
-    def read_until_marker(marker, input:, sink:, timeout_seconds:, max_output_bytes:, cancellation:)
-      buffer = +"".b
+    def read_until_marker(marker, input:, sink:, timeout_seconds:, max_output_bytes:, cancellation:, tab_action_handler: nil, on_detach: nil, initial_buffer: nil)
+      buffer = initial_buffer ? initial_buffer.dup : +"".b
       captured = +"".b
       captured_bytes = 0
       truncated = false
@@ -411,9 +419,45 @@ module Kward
           if input_chunk.nil?
             input = nil
           elsif input_chunk != :wait_readable
-            notify_input_forwarded(sink)
-            write_raw(input_chunk)
-            input_forwarded = true
+            filtered = tab_action_handler&.call(input_chunk)
+            input_chunk = filtered[:input].to_s if filtered
+            unless input_chunk.empty?
+              notify_input_forwarded(sink)
+              write_raw(input_chunk)
+              input_forwarded = true
+            end
+            if filtered && filtered[:tab_action]
+              if on_detach
+                detached_sink = on_detach.call
+                detached = detach_protocol(
+                  marker,
+                  sink: detached_sink,
+                  timeout_seconds: timeout_seconds,
+                  max_output_bytes: max_output_bytes,
+                  initial_buffer: buffer,
+                  input_forwarded: input_forwarded
+                )
+                raise CommandInterrupted.new(
+                  output: captured,
+                  status: 0,
+                  cwd: @cwd,
+                  input_forwarded: input_forwarded,
+                  tab_action: filtered[:tab_action],
+                  truncated: truncated,
+                  background: detached
+                )
+              end
+
+              interrupt_process
+              raise CommandInterrupted.new(
+                output: captured,
+                status: 130,
+                cwd: @cwd,
+                input_forwarded: input_forwarded,
+                tab_action: filtered[:tab_action],
+                truncated: truncated
+              )
+            end
           end
         end
         update_window_size
@@ -422,6 +466,30 @@ module Kward
       raise IOError, "The embedded shell exited before completing the command."
     end
 
+    def detach_protocol(marker, sink:, timeout_seconds:, max_output_bytes:, initial_buffer:, input_forwarded:)
+      DetachedRun.new(sink: sink, canceler: method(:interrupt_process)) do
+        begin
+          protocol = read_until_marker(
+            marker,
+            input: nil,
+            sink: sink,
+            timeout_seconds: timeout_seconds,
+            max_output_bytes: max_output_bytes,
+            cancellation: nil,
+            initial_buffer: initial_buffer
+          )
+          update_cwd(protocol[:cwd])
+          InteractiveResult.new(
+            exit_status: protocol[:status] || 1,
+            input_forwarded: input_forwarded || protocol[:input_forwarded],
+            background: nil
+          )
+        ensure
+          sink.finish if sink.respond_to?(:finish)
+        end
+      end
+    end
+
     def extract_marker(buffer, marker)
       match = buffer.match(/#{Regexp.escape(marker)}:(-?\d+):(.*?)\r?\n/m)
       return nil unless match
@@ -494,10 +562,10 @@ module Kward
       append_output_newline(output)
       status = protocol[:status] || 1
       if protocol[:timed_out]
-        output << "ekwsh: command timed out after #{effective_timeout(timeout_seconds)} seconds\n"
+        output << "kwsh: command timed out after #{effective_timeout(timeout_seconds)} seconds\n"
         status = 1
       elsif protocol[:truncated]
-        output << "ekwsh: output exceeded #{@max_output_bytes} bytes; output truncated\n"
+        output << "kwsh: output exceeded #{@max_output_bytes} bytes; output truncated\n"
         status = 1
       elsif cancellation&.cancelled?
         output << "^C\n" unless output.end_with?("^C\n")
@@ -509,6 +577,31 @@ module Kward
       Result.new(output: output, exit_status: status, streamed: block_given?)
     end
 
+    def source_result(command, words)
+      unless words.length == 2
+        return Result.new(output: "#{command_echo(command)}Usage: source <file>\n", exit_status: 2)
+      end
+
+      path = Kwshrc.resolve_path(words[1], cwd: @cwd, env: @env)
+      config = Kwshrc.read_file(path, env: @env)
+      exports = config[:env]
+      if exports.any?
+        assignments = exports.map { |key, value| "#{key}=#{Shellwords.escape(value)}" }
+        protocol = execute_protocol("export #{assignments.join(" ")}", timeout_seconds: STARTUP_TIMEOUT_SECONDS, max_output_bytes: nil)
+        unless protocol[:status].to_i.zero?
+          return Result.new(output: "#{command_echo(command)}kwsh: source: could not apply environment\n", exit_status: 1)
+        end
+      end
+
+      @env.merge!(exports)
+      @aliases.merge!(config[:aliases])
+      @routing_shell = build_routing_shell
+      @completion_shell = nil
+      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 capture_result(command, expanded_command, cancellation: nil, &block)
       captured_command = expanded_command.sub(/\A\s*capture(?:\s+|\z)/, "")
       if captured_command.empty?
@@ -535,7 +628,7 @@ module Kward
 
     def exit_result(command, words)
       if words.length > 2 || (words[1] && !words[1].match?(/\A\d+\z/))
-        return Result.new(output: "#{command_echo(command)}ekwsh: #{words.first}: numeric status expected\n", exit_status: 2)
+        return Result.new(output: "#{command_echo(command)}kwsh: #{words.first}: numeric status expected\n", exit_status: 2)
       end
 
       Result.new(output: command_echo(command), exit_status: words[1].to_i, exit_shell: true)
@@ -555,7 +648,7 @@ module Kward
         before = @aliases.dup
         words.drop(1).each do |assignment|
           name, value = assignment.split("=", 2)
-          @aliases[name] = value.to_s if value && Ekwsh.valid_alias_name?(name)
+          @aliases[name] = value.to_s if value && Kwsh.valid_alias_name?(name)
         end
         before != @aliases
       when "unalias"