kward 0.83.0 → 0.85.0

data/lib/kward/tools/write_file.rb

@@ -7,15 +7,15 @@ module Kward
     # Tool wrapper for guarded full-file writes.
     class WriteFile < Base
       # Builds the tool schema and stores the execution dependency.
-      def initialize(workspace:)
-        @workspace = workspace
+      def initialize(workspace:, workspace_targets: nil)
+        configure_workspace_targets(workspace, workspace_targets)
         super(
           "write_file",
           "Write a workspace file. Existing files must be read first.",
-          properties: {
+          properties: targeted_properties(
             path: { type: "string", description: "Workspace-relative path." },
             content: { type: "string", description: "Complete file content." }
-          },
+          ),
           required: ["path", "content"]
         )
       end
@@ -25,8 +25,11 @@ module Kward
         path = argument(args, :path, "")
         content = argument(args, :content, "")
 
-        result = @workspace.write_file(path, content, read_paths: conversation.read_paths)
-        conversation.refresh_system_message! if agents_file_changed?(@workspace, path, result)
+        workspace = workspace_for(args)
+        result = workspace.write_file(path, content, read_paths: conversation.read_paths)
+        if workspace.equal?(@workspace) && agents_file_changed?(workspace, path, result)
+          conversation.refresh_system_message!
+        end
         result
       end
     end

data/lib/kward/{export_path.rb → transcripts/export_path.rb}

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

data/lib/kward/{markdown_transcript.rb → transcripts/markdown_transcript.rb}

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

data/lib/kward/transport/contracts.rb

@@ -0,0 +1,200 @@
+# Frontend-neutral external transport contracts.
+require "logger"
+require_relative "../deep_copy"
+
+# Namespace for frontend-neutral external transport contracts.
+module Kward
+  module Transport
+    STREAMING_MODES = %i[native edit aggregate none].freeze
+
+    Actor = Data.define(:id, :display_name, :metadata)
+    Attachment = Data.define(:name, :mime_type, :data, :url, :metadata)
+    ConversationKey = Data.define(:transport_id, :external_id)
+    InboundMessage = Data.define(
+      :conversation,
+      :message_id,
+      :actor,
+      :text,
+      :attachments,
+      :reply_context,
+      :idempotency_key,
+      :metadata
+    )
+    TurnEvent = Data.define(:type, :session_id, :turn_id, :sequence, :payload)
+    InteractionRequest = Data.define(
+      :id,
+      :session_id,
+      :turn_id,
+      :kind,
+      :prompt,
+      :choices,
+      :expires_at,
+      :metadata
+    )
+    Capabilities = Data.define(:inbound, :outbound, :streaming, :limits)
+    ExecutionProfile = Data.define(
+      :id,
+      :tool_mode,
+      :allowed_tools,
+      :disabled_tools,
+      :plugin_commands,
+      :approval_mode,
+      :memory,
+      :attachments,
+      :workspace_mode,
+      :prompt_context
+    )
+
+    TOOL_MODES = %i[all none allowlist].freeze
+    APPROVAL_MODES = %i[default ask deny].freeze
+    MEMORY_MODES = %i[default none].freeze
+    WORKSPACE_MODES = %i[session fixed].freeze
+
+    module_function
+
+    def actor(id:, display_name: nil, metadata: {})
+      Actor.new(
+        id: required_string(id, "actor id"),
+        display_name: optional_string(display_name),
+        metadata: frozen_copy(metadata)
+      )
+    end
+
+    def attachment(name: nil, mime_type:, data: nil, url: nil, metadata: {})
+      raise ArgumentError, "attachment requires data or url" if data.nil? && url.nil?
+      raise ArgumentError, "attachment cannot contain both data and url" unless data.nil? || url.nil?
+
+      Attachment.new(
+        name: optional_string(name),
+        mime_type: required_string(mime_type, "attachment MIME type"),
+        data: data&.dup&.freeze,
+        url: url && required_string(url, "attachment URL"),
+        metadata: frozen_copy(metadata)
+      )
+    end
+
+    def conversation_key(transport_id:, external_id:)
+      ConversationKey.new(
+        transport_id: required_string(transport_id, "transport id"),
+        external_id: required_string(external_id, "external conversation id")
+      )
+    end
+
+    def inbound_message(conversation:, message_id:, actor:, text: "", attachments: [], reply_context: {}, idempotency_key:, metadata: {})
+      unless conversation.is_a?(ConversationKey)
+        raise ArgumentError, "conversation must be a Transport::ConversationKey"
+      end
+      unless actor.is_a?(Actor)
+        raise ArgumentError, "actor must be a Transport::Actor"
+      end
+
+      InboundMessage.new(
+        conversation: conversation,
+        message_id: required_string(message_id, "message id"),
+        actor: actor,
+        text: text.to_s.freeze,
+        attachments: frozen_copy(Array(attachments)),
+        reply_context: frozen_copy(reply_context),
+        idempotency_key: required_string(idempotency_key, "idempotency key"),
+        metadata: frozen_copy(metadata)
+      )
+    end
+
+    def turn_event(type:, session_id:, turn_id:, sequence:, payload: {})
+      TurnEvent.new(
+        type: required_string(type, "turn event type"),
+        session_id: required_string(session_id, "session id"),
+        turn_id: required_string(turn_id, "turn id"),
+        sequence: Integer(sequence),
+        payload: frozen_copy(payload)
+      )
+    end
+
+    def interaction_request(id:, session_id:, turn_id:, kind:, prompt:, choices: [], expires_at: nil, metadata: {})
+      InteractionRequest.new(
+        id: required_string(id, "interaction id"),
+        session_id: required_string(session_id, "session id"),
+        turn_id: required_string(turn_id, "turn id"),
+        kind: required_string(kind, "interaction kind"),
+        prompt: required_string(prompt, "interaction prompt"),
+        choices: frozen_copy(Array(choices)),
+        expires_at: expires_at,
+        metadata: frozen_copy(metadata)
+      )
+    end
+
+    def execution_profile(
+      id:,
+      tool_mode: :all,
+      allowed_tools: nil,
+      disabled_tools: nil,
+      plugin_commands: true,
+      approval_mode: :default,
+      memory: :default,
+      attachments: true,
+      workspace_mode: :session,
+      prompt_context: nil
+    )
+      id = required_string(id, "execution profile id")
+      tool_mode = tool_mode.to_sym
+      approval_mode = approval_mode.to_sym
+      memory = memory.to_sym
+      workspace_mode = workspace_mode.to_sym
+      raise ArgumentError, "unsupported tool mode: #{tool_mode}" unless TOOL_MODES.include?(tool_mode)
+      raise ArgumentError, "unsupported approval mode: #{approval_mode}" unless APPROVAL_MODES.include?(approval_mode)
+      raise ArgumentError, "unsupported memory mode: #{memory}" unless MEMORY_MODES.include?(memory)
+      raise ArgumentError, "unsupported workspace mode: #{workspace_mode}" unless WORKSPACE_MODES.include?(workspace_mode)
+      raise ArgumentError, "allowlist tool mode requires allowed_tools" if tool_mode == :allowlist && Array(allowed_tools).empty?
+      raise ArgumentError, "none tool mode cannot define allowed_tools" if tool_mode == :none && allowed_tools
+      raise ArgumentError, "allowed_tools and disabled_tools cannot both be set" if allowed_tools && disabled_tools
+
+      ExecutionProfile.new(
+        id: id,
+        tool_mode: tool_mode,
+        allowed_tools: frozen_symbols(allowed_tools),
+        disabled_tools: frozen_symbols(disabled_tools),
+        plugin_commands: !!plugin_commands,
+        approval_mode: approval_mode,
+        memory: memory,
+        attachments: !!attachments,
+        workspace_mode: workspace_mode,
+        prompt_context: prompt_context.nil? ? nil : prompt_context.to_s.freeze
+      )
+    end
+
+    def capabilities(inbound: [], outbound: [], streaming: :none, limits: {})
+      streaming = streaming.to_sym
+      raise ArgumentError, "unsupported streaming mode: #{streaming}" unless STREAMING_MODES.include?(streaming)
+
+      Capabilities.new(
+        inbound: frozen_symbols(inbound),
+        outbound: frozen_symbols(outbound),
+        streaming: streaming,
+        limits: frozen_copy(limits)
+      )
+    end
+
+    def required_string(value, name)
+      value = value.to_s
+      raise ArgumentError, "#{name} is required" if value.empty?
+
+      value.freeze
+    end
+    private_class_method :required_string
+
+    def optional_string(value)
+      value.nil? ? nil : value.to_s.freeze
+    end
+    private_class_method :optional_string
+
+    def frozen_symbols(values)
+      Array(values).map { |value| value.to_sym }.uniq.freeze
+    end
+    private_class_method :frozen_symbols
+
+    def frozen_copy(value)
+      DeepCopy.freeze(DeepCopy.dup(value))
+    end
+    private_class_method :frozen_copy
+  end
+end

data/lib/kward/transport/gateway.rb

@@ -13,6 +13,7 @@ module Kward
     # without changing transport plugins.
     class Gateway
       POLL_INTERVAL = 0.05
+      INTERACTION_ROUTE_LIMIT = 1_000
       TERMINAL_STATUSES = %w[completed canceled failed].freeze
 
       def initialize(session_manager:, transport_id:, storage: nil, poll_interval: POLL_INTERVAL)
@@ -22,6 +23,7 @@ module Kward
         @poll_interval = poll_interval
         @subscriptions = []
         @interaction_subscribers = []
+        @interaction_routes = {}
         @mutex = Mutex.new
         @session_manager.subscribe_events { |method, payload| handle_runtime_event(method, payload) } if @session_manager.respond_to?(:subscribe_events)
       end
@@ -73,19 +75,16 @@ module Kward
       end
 
       def answer_transport_interaction(session_id:, request_id:, answer:)
-        if answer == true || answer == false
-          @session_manager.answer_tool_approval(
-            session_id: session_id,
-            approval_request_id: request_id,
-            approved: answer
-          )
+        route = @mutex.synchronize { @interaction_routes.delete(request_id.to_s) }
+        case route
+        when :plugin_ui
+          @session_manager.answer_plugin_ui(session_id: session_id, request_id: request_id, value: answer)
+        when :tool_approval
+          @session_manager.answer_tool_approval(session_id: session_id, approval_request_id: request_id, approved: answer == true)
+        when :question
+          answer_transport_question(session_id, request_id, answer)
         else
-          answers = answer.is_a?(Array) ? answer : [{ question: request_id, answer: answer.to_s }]
-          @session_manager.answer_question(
-            session_id: session_id,
-            question_request_id: request_id,
-            answers: answers
-          )
+          answer == true || answer == false ? answer_transport_approval(session_id, request_id, answer) : answer_transport_question(session_id, request_id, answer)
         end
       end
 
@@ -122,6 +121,7 @@ module Kward
           current = @subscriptions
           @subscriptions = []
           @interaction_subscribers = []
+          @interaction_routes = {}
           current
         end
         subscriptions.each(&:kill)
@@ -168,31 +168,17 @@ module Kward
       end
 
       def handle_runtime_event(method, payload)
-        request = case method
-                  when "ui/question"
-                    questions = Array(payload[:questions] || payload["questions"])
-                    Transport.interaction_request(
-                      id: payload[:questionRequestId] || payload["questionRequestId"],
-                      session_id: payload[:sessionId] || payload["sessionId"],
-                      turn_id: payload[:turnId] || payload["turnId"] || "unknown",
-                      kind: :question,
-                      prompt: questions.map { |question| question[:question] || question["question"] }.join("\\n"),
-                      choices: questions
-                    )
-                  when "tool/approvalRequested"
-                    Transport.interaction_request(
-                      id: payload[:approvalRequestId] || payload["approvalRequestId"],
-                      session_id: payload[:sessionId] || payload["sessionId"],
-                      turn_id: payload[:turnId] || payload["turnId"] || "unknown",
-                      kind: :tool_approval,
-                      prompt: "Allow #{payload[:toolName] || payload["toolName"]}?",
-                      choices: [{ id: "approve", label: "Approve" }, { id: "deny", label: "Deny" }],
-                      metadata: { tool_call_id: payload[:toolCallId] || payload["toolCallId"], args: payload[:args] || payload["args"] }
-                    )
-                  end
+        request, route = interaction_for_runtime_event(method, payload)
         return unless request
 
-        subscribers = @mutex.synchronize { @interaction_subscribers.dup }
+        subscribers = @mutex.synchronize do
+          current = @interaction_subscribers.dup
+          if route && !current.empty?
+            @interaction_routes[request.id.to_s] = route
+            @interaction_routes.shift while @interaction_routes.length > INTERACTION_ROUTE_LIMIT
+          end
+          current
+        end
         subscribers.each do |subscriber|
           begin
             subscriber.call(request)
@@ -202,6 +188,64 @@ module Kward
         end
       end
 
+      def interaction_for_runtime_event(method, payload)
+        session_id = payload[:sessionId] || payload["sessionId"]
+        turn_id = payload[:turnId] || payload["turnId"] || "unknown"
+        case method
+        when "ui/question"
+          questions = Array(payload[:questions] || payload["questions"])
+          [Transport.interaction_request(
+            id: payload[:questionRequestId] || payload["questionRequestId"],
+            session_id: session_id,
+            turn_id: turn_id,
+            kind: :question,
+            prompt: questions.map { |question| question[:question] || question["question"] }.join("\\n"),
+            choices: questions
+          ), :question]
+        when "ui/request"
+          plugin_ui_interaction(payload, session_id, turn_id)
+        when "tool/approvalRequested"
+          [Transport.interaction_request(
+            id: payload[:approvalRequestId] || payload["approvalRequestId"],
+            session_id: session_id,
+            turn_id: turn_id,
+            kind: :tool_approval,
+            prompt: "Allow #{payload[:toolName] || payload["toolName"]}?",
+            choices: [{ id: "approve", label: "Approve" }, { id: "deny", label: "Deny" }],
+            metadata: { tool_call_id: payload[:toolCallId] || payload["toolCallId"], args: payload[:args] || payload["args"] }
+          ), :tool_approval]
+        end
+      end
+
+      def plugin_ui_interaction(payload, session_id, turn_id)
+        kind = (payload[:kind] || payload["kind"]).to_s
+        details = payload[:payload] || payload["payload"] || {}
+        prompt = details[:message] || details["message"] || details[:title] || details["title"]
+        choices = details[:options] || details["options"] || []
+        if kind == "confirm"
+          choices = [{ label: "Yes", value: true }, { label: "No", value: false }]
+        end
+        default = details.key?(:default) ? details[:default] : details["default"]
+        [Transport.interaction_request(
+          id: payload[:requestId] || payload["requestId"],
+          session_id: session_id,
+          turn_id: turn_id,
+          kind: kind,
+          prompt: prompt,
+          choices: choices,
+          metadata: { title: details[:title] || details["title"], placeholder: details[:placeholder] || details["placeholder"], default: default }.compact
+        ), :plugin_ui]
+      end
+
+      def answer_transport_approval(session_id, request_id, answer)
+        @session_manager.answer_tool_approval(session_id: session_id, approval_request_id: request_id, approved: answer)
+      end
+
+      def answer_transport_question(session_id, request_id, answer)
+        answers = answer.is_a?(Array) ? answer : [{ question: request_id, answer: answer.to_s }]
+        @session_manager.answer_question(session_id: session_id, question_request_id: request_id, answers: answers)
+      end
+
       def profile_options(options, profile)
         return options unless profile
 

data/lib/kward/transport/plugin_chat_gateway.rb

@@ -1,6 +1,6 @@
 require "base64"
 require "thread"
-require_relative "../plugin_chat_runtime"
+require_relative "../plugins/chat_runtime"
 
 module Kward
   module Transport
@@ -45,9 +45,10 @@ module Kward
           raise ArgumentError, "plugin chat turns do not support #{streaming_behavior} streaming"
         end
 
+        chat = fetch_chat(chat_id)
         turn = @runtime.start_turn(
           chat_id: chat_id,
-          input: @runtime.input_with_attachments(input, normalize_attachments(attachments)),
+          input: @runtime.input_with_attachments(input, normalize_attachments(attachments), capabilities: chat.type.capabilities),
           display_input: input.to_s,
           context: { actor: actor }
         )

data/lib/kward/transport.rb

@@ -1,203 +1,4 @@
-require "logger"
-require_relative "deep_copy"
-
-# Namespace for frontend-neutral external transport contracts.
-module Kward
-  module Transport
-    STREAMING_MODES = %i[native edit aggregate none].freeze
-
-    Actor = Data.define(:id, :display_name, :metadata)
-    Attachment = Data.define(:name, :mime_type, :data, :url, :metadata)
-    ConversationKey = Data.define(:transport_id, :external_id)
-    InboundMessage = Data.define(
-      :conversation,
-      :message_id,
-      :actor,
-      :text,
-      :attachments,
-      :reply_context,
-      :idempotency_key,
-      :metadata
-    )
-    TurnEvent = Data.define(:type, :session_id, :turn_id, :sequence, :payload)
-    InteractionRequest = Data.define(
-      :id,
-      :session_id,
-      :turn_id,
-      :kind,
-      :prompt,
-      :choices,
-      :expires_at,
-      :metadata
-    )
-    Capabilities = Data.define(:inbound, :outbound, :streaming, :limits)
-    ExecutionProfile = Data.define(
-      :id,
-      :tool_mode,
-      :allowed_tools,
-      :disabled_tools,
-      :plugin_commands,
-      :approval_mode,
-      :memory,
-      :attachments,
-      :workspace_mode,
-      :prompt_context
-    )
-
-    TOOL_MODES = %i[all none allowlist].freeze
-    APPROVAL_MODES = %i[default ask deny].freeze
-    MEMORY_MODES = %i[default none].freeze
-    WORKSPACE_MODES = %i[session fixed].freeze
-
-    module_function
-
-    def actor(id:, display_name: nil, metadata: {})
-      Actor.new(
-        id: required_string(id, "actor id"),
-        display_name: optional_string(display_name),
-        metadata: frozen_copy(metadata)
-      )
-    end
-
-    def attachment(name: nil, mime_type:, data: nil, url: nil, metadata: {})
-      raise ArgumentError, "attachment requires data or url" if data.nil? && url.nil?
-      raise ArgumentError, "attachment cannot contain both data and url" unless data.nil? || url.nil?
-
-      Attachment.new(
-        name: optional_string(name),
-        mime_type: required_string(mime_type, "attachment MIME type"),
-        data: data&.dup&.freeze,
-        url: url && required_string(url, "attachment URL"),
-        metadata: frozen_copy(metadata)
-      )
-    end
-
-    def conversation_key(transport_id:, external_id:)
-      ConversationKey.new(
-        transport_id: required_string(transport_id, "transport id"),
-        external_id: required_string(external_id, "external conversation id")
-      )
-    end
-
-    def inbound_message(conversation:, message_id:, actor:, text: "", attachments: [], reply_context: {}, idempotency_key:, metadata: {})
-      unless conversation.is_a?(ConversationKey)
-        raise ArgumentError, "conversation must be a Transport::ConversationKey"
-      end
-      unless actor.is_a?(Actor)
-        raise ArgumentError, "actor must be a Transport::Actor"
-      end
-
-      InboundMessage.new(
-        conversation: conversation,
-        message_id: required_string(message_id, "message id"),
-        actor: actor,
-        text: text.to_s.freeze,
-        attachments: frozen_copy(Array(attachments)),
-        reply_context: frozen_copy(reply_context),
-        idempotency_key: required_string(idempotency_key, "idempotency key"),
-        metadata: frozen_copy(metadata)
-      )
-    end
-
-    def turn_event(type:, session_id:, turn_id:, sequence:, payload: {})
-      TurnEvent.new(
-        type: required_string(type, "turn event type"),
-        session_id: required_string(session_id, "session id"),
-        turn_id: required_string(turn_id, "turn id"),
-        sequence: Integer(sequence),
-        payload: frozen_copy(payload)
-      )
-    end
-
-    def interaction_request(id:, session_id:, turn_id:, kind:, prompt:, choices: [], expires_at: nil, metadata: {})
-      InteractionRequest.new(
-        id: required_string(id, "interaction id"),
-        session_id: required_string(session_id, "session id"),
-        turn_id: required_string(turn_id, "turn id"),
-        kind: required_string(kind, "interaction kind"),
-        prompt: required_string(prompt, "interaction prompt"),
-        choices: frozen_copy(Array(choices)),
-        expires_at: expires_at,
-        metadata: frozen_copy(metadata)
-      )
-    end
-
-    def execution_profile(
-      id:,
-      tool_mode: :all,
-      allowed_tools: nil,
-      disabled_tools: nil,
-      plugin_commands: true,
-      approval_mode: :default,
-      memory: :default,
-      attachments: true,
-      workspace_mode: :session,
-      prompt_context: nil
-    )
-      id = required_string(id, "execution profile id")
-      tool_mode = tool_mode.to_sym
-      approval_mode = approval_mode.to_sym
-      memory = memory.to_sym
-      workspace_mode = workspace_mode.to_sym
-      raise ArgumentError, "unsupported tool mode: #{tool_mode}" unless TOOL_MODES.include?(tool_mode)
-      raise ArgumentError, "unsupported approval mode: #{approval_mode}" unless APPROVAL_MODES.include?(approval_mode)
-      raise ArgumentError, "unsupported memory mode: #{memory}" unless MEMORY_MODES.include?(memory)
-      raise ArgumentError, "unsupported workspace mode: #{workspace_mode}" unless WORKSPACE_MODES.include?(workspace_mode)
-      raise ArgumentError, "allowlist tool mode requires allowed_tools" if tool_mode == :allowlist && Array(allowed_tools).empty?
-      raise ArgumentError, "none tool mode cannot define allowed_tools" if tool_mode == :none && allowed_tools
-      raise ArgumentError, "allowed_tools and disabled_tools cannot both be set" if allowed_tools && disabled_tools
-
-      ExecutionProfile.new(
-        id: id,
-        tool_mode: tool_mode,
-        allowed_tools: frozen_symbols(allowed_tools),
-        disabled_tools: frozen_symbols(disabled_tools),
-        plugin_commands: !!plugin_commands,
-        approval_mode: approval_mode,
-        memory: memory,
-        attachments: !!attachments,
-        workspace_mode: workspace_mode,
-        prompt_context: prompt_context.nil? ? nil : prompt_context.to_s.freeze
-      )
-    end
-
-    def capabilities(inbound: [], outbound: [], streaming: :none, limits: {})
-      streaming = streaming.to_sym
-      raise ArgumentError, "unsupported streaming mode: #{streaming}" unless STREAMING_MODES.include?(streaming)
-
-      Capabilities.new(
-        inbound: frozen_symbols(inbound),
-        outbound: frozen_symbols(outbound),
-        streaming: streaming,
-        limits: frozen_copy(limits)
-      )
-    end
-
-    def required_string(value, name)
-      value = value.to_s
-      raise ArgumentError, "#{name} is required" if value.empty?
-
-      value.freeze
-    end
-    private_class_method :required_string
-
-    def optional_string(value)
-      value.nil? ? nil : value.to_s.freeze
-    end
-    private_class_method :optional_string
-
-    def frozen_symbols(values)
-      Array(values).map { |value| value.to_sym }.uniq.freeze
-    end
-    private_class_method :frozen_symbols
-
-    def frozen_copy(value)
-      DeepCopy.freeze(DeepCopy.dup(value))
-    end
-    private_class_method :frozen_copy
-  end
-end
-
+require_relative "transport/contracts"
 require_relative "transport/store"
 require_relative "transport/host"
 require_relative "transport/manager"

data/lib/kward/version.rb

@@ -1,5 +1,5 @@
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Current gem version.
-  VERSION = "0.83.0"
+  VERSION = "0.85.0"
 end

data/lib/kward/{workspace_factory.rb → workspace/factory.rb}

@@ -1,5 +1,5 @@
-require_relative "config_files"
-require_relative "sandbox"
+require_relative "../config_files"
+require_relative "../sandbox"
 require_relative "workspace"
 
 # Namespace for the Kward CLI agent runtime.

data/lib/kward/{project_files.rb → workspace/files.rb}

@@ -15,13 +15,13 @@ module Kward
     end
 
     def git_paths(root, include_ignored: false)
-      output, status = Open3.capture2("git", "ls-files", "--cached", "--others", "--exclude-standard", chdir: root)
+      output, status = Open3.capture2e("git", "ls-files", "--cached", "--others", "--exclude-standard", chdir: root)
       return [] unless status.success?
 
       paths = output.lines.map(&:chomp).reject(&:empty?)
       return paths unless include_ignored
 
-      ignored_output, ignored_status = Open3.capture2("git", "ls-files", "--others", "--ignored", "--exclude-standard", chdir: root)
+      ignored_output, ignored_status = Open3.capture2e("git", "ls-files", "--others", "--ignored", "--exclude-standard", chdir: root)
       return paths unless ignored_status.success?
 
       paths + ignored_output.lines.map(&:chomp).reject(&:empty?)