kward 0.83.0 → 0.85.0

data/lib/kward/cli/rendering.rb

@@ -223,7 +223,10 @@ module Kward
       # Writes the user transcript output for the terminal CLI flow.
       def print_user_transcript(input, display_input: nil, attachment_references: nil, image_parts: nil)
         visible_input = display_input.nil? ? input : display_input
-        write_prompt_transcript("\n#{colored("You>", :blue, :bold)} #{visible_input}\n")
+        write_prompt_transcript("\n#{colored("❯ You>", :blue, :bold)} #{visible_input}\n")
+        # System-turn instructions are plain text, never image attachments.
+        return if input.is_a?(PluginTurnRequest)
+
         print_attachment_badges(input, references: attachment_references)
         print_pasted_images(input, image_parts: image_parts)
       end
@@ -347,8 +350,9 @@ module Kward
       end
 
       # Writes the tool result output for the terminal CLI flow.
-      def print_tool_result(tool_call, content, line_limit: nil)
+      def print_tool_result(tool_call, content, line_limit: nil, elapsed_ms: nil)
         summary = tool_result_summary(tool_call, content)
+        summary = tool_summary_with_duration(summary, elapsed_ms)
         summary = limit_tool_output_lines(summary, line_limit) if line_limit
         display_summary = tool_summary_display_text(summary)
         if prompt_interface?
@@ -380,7 +384,7 @@ module Kward
         return if @stream_block == label
 
         puts if @stream_block
-        print "\n#{colored("#{transcript_label(label)}>", *label_styles(label))} "
+        print "\n#{colored(transcript_marker(label), *label_styles(label))} "
         @stream_block = label
       end
 
@@ -408,20 +412,25 @@ module Kward
         end
       end
 
+      def transcript_marker(label)
+        marker = "#{transcript_label(label)}>"
+        label == "Assistant" ? "✦ #{marker}" : marker
+      end
+
       def label_styles(label)
         case label
         when "Reasoning", "Compaction summary"
-          [:gray, :bold]
+          [:metadata, :bold]
         when "Assistant", "Kward"
-          [:green, :bold]
+          [:activity, :bold]
         when "Tool", "Tool output"
-          [:cyan, :bold]
+          [:tool, :bold]
         when "Tool failed"
-          [:red, :bold]
+          [:failure, :bold]
         when "Retry"
-          [:yellow, :bold]
+          [:caution, :bold]
         else
-          [:gray, :bold]
+          [:metadata, :bold]
         end
       end
 

data/lib/kward/cli/runtime_helpers.rb

@@ -47,6 +47,11 @@ module Kward
 
       def runtime_output(text)
         content = text.to_s.chomp
+        if (tab = Thread.current[:kward_local_busy_tab]) && !content.empty?
+          tab.append_pending_runtime_output(content)
+          return
+        end
+
         label = colored(runtime_output_prompt, :gray, :bold)
         separator = content.include?("\n") ? "\n" : " "
         @prompt.say("\n#{label}#{separator}#{content}\n")
@@ -61,6 +66,7 @@ module Kward
           workspace: workspace,
           prompt: @prompt,
           skills: ConfigFiles.skills(workspace_root: conversation.workspace_root, project_skill_paths: project_skill_paths_for(conversation.workspace_root)),
+          plugin_tools: plugin_registry.tools,
           tool_approval: interactive_tool_approval_callback,
           hook_manager: hook_manager,
           hook_context: hook_context
@@ -102,19 +108,19 @@ module Kward
         if editor_result
           record_tab_transient_shell_output(editor_result.output, render: false)
           @prompt.say(editor_result.output) unless editor_result.output.to_s.empty?
-          open_ekwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
+          open_kwsh_editor(editor_result.open_editor_path, shell) if editor_result.open_editor_path
           return true
         end
 
         expanded_command = shell.expand_alias(command, interactive: true)
-        run_user_interactive_pty_command(
+        result = run_user_interactive_pty_command(
           expanded_command,
-          shell: Ekwsh::DEFAULT_SHELL,
-          env: interactive_pty_environment({}, preserve_git_pager: true),
+          shell: Kwsh::DEFAULT_SHELL,
+          env: interactive_pty_environment(shell.child_env, preserve_git_pager: true),
           cwd: interactive_workspace_root(agent),
           intro: "$ #{command}\n"
         )
-        true
+        result&.tab_action ? :tab_action : true
       end
 
       def run_captured_shell_command(command, agent)
@@ -142,7 +148,7 @@ module Kward
         completion = bang_shell(agent).complete(value[1..], cursor.to_i - 1)
         return nil unless completion
 
-        Ekwsh::Completion.new(
+        Kwsh::Completion.new(
           range: (completion.range.begin + 1)...(completion.range.end + 1),
           replacement: completion.replacement,
           candidates: completion.candidates
@@ -151,12 +157,14 @@ module Kward
 
       def bang_shell(agent)
         root = File.expand_path(interactive_workspace_root(agent).to_s)
-        aliases = ConfigFiles.read_ekwsh_config[:aliases]
-        cache_key = [root, ENV.fetch("PATH", ""), aliases.sort]
+        config = ConfigFiles.read_kwsh_config
+        aliases = config[:aliases]
+        configured_env = config[:env]
+        cache_key = [root, ENV.fetch("PATH", ""), aliases.sort, configured_env.sort]
         return @bang_shell if @bang_shell_key == cache_key
 
         @bang_shell_key = cache_key
-        @bang_shell = Ekwsh.new(cwd: root, env: ENV.to_h, aliases: aliases)
+        @bang_shell = Kwsh.new(cwd: root, env: ENV.to_h, configured_env: configured_env, aliases: aliases)
       end
 
       def install_bang_completion_provider(agent)
@@ -182,7 +190,7 @@ module Kward
         @bang_completion_provider_installed = false
       end
 
-      def run_ekwsh(agent)
+      def run_kwsh(agent)
         unless @prompt.respond_to?(:ask)
           runtime_output("The embedded shell is only available in interactive mode.")
           return
@@ -190,11 +198,11 @@ module Kward
 
         tab = active_tab if respond_to?(:active_tab, true)
         entering = tab.nil? || tab.shell.nil?
-        shell = tab&.shell || build_ekwsh(agent)
+        shell = tab&.shell || build_kwsh(agent)
         tab.shell = shell if tab
         shell_agent = shell_prompt_agent_for(agent, tab: tab)
-        runtime_output("Entering ekwsh. Type exit or press Ctrl+D on an empty prompt to return.") if entering
-        run_ekwsh_loop(shell, tab: tab, history: build_ekwsh_history(agent), shell_agent: shell_agent)
+        runtime_output("Entering kwsh. Type exit or press Ctrl+D on an empty prompt to return.") if entering
+        run_kwsh_loop(shell, tab: tab, history: build_kwsh_history(agent), shell_agent: shell_agent)
       end
 
       def shell_prompt_agent_for(agent, tab: nil)
@@ -208,17 +216,20 @@ module Kward
 
       def build_shell_prompt_agent(active_agent)
         active_conversation = active_agent.conversation
+        config = ConfigFiles.read_config
+        configured_provider = ConfigFiles.shell_agent_provider(config)
         conversation = Conversation.new(
           system_message: ShellPrompt.system_message,
           workspace_root: active_conversation.workspace_root,
-          provider: active_conversation.provider || current_model_provider,
-          model: active_conversation.model || current_model_id,
-          reasoning_effort: active_conversation.reasoning_effort || current_reasoning_effort
+          provider: configured_provider || active_conversation.provider || current_model_provider,
+          model: ConfigFiles.shell_agent_model(config) || (configured_provider ? nil : active_conversation.model || current_model_id),
+          reasoning_effort: ConfigFiles.shell_agent_reasoning_effort(config) || (configured_provider ? nil : active_conversation.reasoning_effort || current_reasoning_effort)
         )
         Agent.new(
           client: @client,
           tool_registry: active_agent.tool_registry,
           conversation: conversation,
+          strict_provider: !configured_provider.nil?,
           warning_sink: ConfigFiles.warning_sink
         )
       end
@@ -269,8 +280,8 @@ module Kward
         input.to_s.start_with?("?")
       end
 
-      def build_ekwsh(agent)
-        config = ConfigFiles.read_ekwsh_config
+      def build_kwsh(agent)
+        config = ConfigFiles.read_kwsh_config
         PersistentShellSession.new(
           cwd: interactive_workspace_root(agent),
           configured_env: config[:env],
@@ -281,8 +292,8 @@ module Kward
         )
       end
 
-      def build_ekwsh_history(agent)
-        config = ConfigFiles.read_ekwsh_config
+      def build_kwsh_history(agent)
+        config = ConfigFiles.read_kwsh_config
         PromptHistory.new(
           cwd: interactive_workspace_root(agent),
           limit: config[:history_limit],
@@ -297,7 +308,7 @@ module Kward
           return
         end
 
-        config = ConfigFiles.read_ekwsh_config
+        config = ConfigFiles.read_kwsh_config
         run_user_interactive_pty_command(
           command,
           shell: config[:shell],
@@ -314,8 +325,14 @@ module Kward
         elsif @prompt.respond_to?(:say)
           @prompt.say(intro_message)
         end
-        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd) do |sink, completed_result|
-          transcript_output = record_completed_pty_output(sink, completed_result)
+        origin_tab = active_tab if respond_to?(:active_tab, true)
+        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd) do |sink, completed_result, background_state|
+          transcript_output = record_completed_pty_output(
+            sink,
+            completed_result,
+            tab: origin_tab,
+            background_state: background_state
+          )
           yield(transcript_output, completed_result) if block_given?
         end
         refresh_composer_status
@@ -327,20 +344,35 @@ module Kward
 
       def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
+        origin_tab = active_tab if respond_to?(:active_tab, true)
         with_interactive_terminal_handoff do |input, sink|
+          tab_action_handler = terminal_handoff_tab_action_handler
+          on_detach = if origin_tab
+            lambda do
+              BufferedPtyOutputSink.new(
+                max_capture_bytes: Kward::CLI::Tabs::TRANSIENT_SHELL_OUTPUT_LIMIT,
+                initial_output: sink.captured_output,
+                initial_truncated: sink.truncated?
+              )
+            end
+          end
           result = if shell.respond_to?(:run_interactive)
-            shell.run_interactive(command, input: input, sink: sink)
+            shell.run_interactive(command, input: input, sink: sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
+          else
+            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink, tab_action_handler: tab_action_handler, on_detach: on_detach)
+          end
+          if result&.background
+            register_background_tab_run(origin_tab, result.background, output_kind: :pty, &on_complete)
           else
-            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+            on_complete.call(sink, result) if on_complete
           end
-          on_complete.call(sink, result) if on_complete
           result
         end
       end
 
       def with_interactive_terminal_handoff
         if @prompt.respond_to?(:with_inline_terminal_handoff)
-          @prompt.with_inline_terminal_handoff do |input, output, transition|
+          with_tab_keybinding_handoff(:with_inline_terminal_handoff) do |input, output, transition|
             sink = AdaptivePtyOutputSink.new(
               output: output,
               on_exclusive: transition,
@@ -349,7 +381,7 @@ module Kward
             yield(input, sink)
           end
         elsif @prompt.respond_to?(:with_terminal_handoff)
-          @prompt.with_terminal_handoff do |input, output|
+          with_tab_keybinding_handoff(:with_terminal_handoff) do |input, output|
             sink = PassthroughPtyOutputSink.new(
               output: output,
               max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
@@ -365,7 +397,100 @@ module Kward
         end
       end
 
-      def record_completed_pty_output(sink, result)
+      def with_tab_keybinding_handoff(method_name)
+        method = @prompt.method(method_name)
+        supports_option = method.parameters.any? do |type, name|
+          type == :keyrest || (type == :key || type == :keyreq) && name == :preserve_tab_keybindings
+        end
+        if supports_option
+          @prompt.public_send(method_name, preserve_tab_keybindings: true) { |*args| yield(*args) }
+        else
+          @prompt.public_send(method_name) { |*args| yield(*args) }
+        end
+      end
+
+      def terminal_handoff_tab_action_handler
+        return unless @prompt.respond_to?(:filter_terminal_handoff_input)
+        return unless respond_to?(:handle_tab_action, true)
+
+        lambda do |chunk|
+          filtered = @prompt.filter_terminal_handoff_input(chunk)
+          action = filtered[:tab_action]
+          handle_tab_action(action, @session_store) if action
+          filtered
+        end
+      end
+
+      def record_completed_pty_output(sink, result, tab: nil, background_state: nil)
+        transcript_output = background_shell_transcript_output(sink, result)
+        return unless transcript_output
+
+        rendered_output = background_state&.fetch(:rendered_output, "").to_s
+        delta = if transcript_output.start_with?(rendered_output)
+          transcript_output[rendered_output.length..].to_s
+        else
+          transcript_output
+        end
+        if background_state
+          background_state[:rendered_output] = transcript_output
+          render_background_tab_delta(tab, delta) unless delta.empty?
+        else
+          record_tab_transient_shell_output(transcript_output, render: false, tab: tab)
+          if @prompt.respond_to?(:record_transient_terminal_output) && (!tab || tab == active_tab)
+            @prompt.record_transient_terminal_output(transcript_output, render: false)
+          end
+        end
+        transcript_output
+      end
+
+      def flush_background_tab_output(tab, state, result: nil)
+        sink = state[:run].sink
+        output = sink&.captured_output.to_s
+        return if output.empty?
+
+        transcript_output = if state[:output_kind] == :streamed
+          background_stream_transcript_output(sink)
+        else
+          transcript_result = result || InteractivePtyRunner::Result.new(exit_status: 0, input_forwarded: false)
+          background_shell_transcript_output(sink, transcript_result)
+        end
+        return unless transcript_output
+
+        rendered_output = state[:rendered_output].to_s
+        if transcript_output.start_with?(rendered_output)
+          delta = transcript_output[rendered_output.length..].to_s
+          return if delta.empty?
+
+          state[:rendered_output] = transcript_output
+          render_background_tab_delta(tab, delta)
+        else
+          state[:rendered_output] = transcript_output
+          render_tab(tab, restore_composer: false) if tab == active_tab
+        end
+      end
+
+      def render_background_tab_delta(tab, delta)
+        return unless tab == active_tab
+
+        if @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(delta)
+        elsif @prompt.respond_to?(:say)
+          @prompt.say(delta)
+        end
+      end
+
+      def background_stream_transcript_output(sink)
+        return if sink&.truncated?
+
+        text = ANSI.normalize_transcript_encoding(sink&.captured_output.to_s).gsub("\r\n", "\n")
+        sanitized = PtyTranscriptNormalizer.normalize(text)
+        return if sanitized.empty?
+        return if ANSI.strip_control_sequences(sanitized).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
+
+        sanitized
+      end
+
+      def background_shell_transcript_output(sink, result)
         classified_output = sink.respond_to?(:transcript_safe?)
         return if classified_output && !sink.transcript_safe?
 
@@ -373,20 +498,13 @@ module Kward
         allow_input = classified_output &&
           sink.respond_to?(:pre_input_capture_only?) &&
           sink.pre_input_capture_only?
-        transcript_output = terminal_transcript_output(
+        terminal_transcript_output(
           output,
           result,
           truncated: sink&.truncated? || false,
           allow_input: allow_input,
           normalize_line_controls: classified_output
         )
-        return unless transcript_output
-
-        record_tab_transient_shell_output(transcript_output, render: false)
-        if @prompt.respond_to?(:record_transient_terminal_output)
-          @prompt.record_transient_terminal_output(transcript_output, render: false)
-        end
-        transcript_output
       end
 
       def terminal_transcript_output(
@@ -422,14 +540,14 @@ module Kward
         end
       end
 
-      def run_ekwsh_loop(shell, tab: nil, history: nil, shell_agent: nil)
+      def run_kwsh_loop(shell, tab: nil, history: nil, shell_agent: nil)
         shell_agent ||= shell_prompt_agent_for(tab.agent, tab: tab) if tab&.agent
-        with_ekwsh_history(history) do
-          run_ekwsh_loop_with_history(shell, tab: tab, shell_agent: shell_agent)
+        with_kwsh_history(history) do
+          run_kwsh_loop_with_history(shell, tab: tab, shell_agent: shell_agent)
         end
       end
 
-      def run_ekwsh_loop_with_history(shell, tab: nil, shell_agent: nil)
+      def run_kwsh_loop_with_history(shell, tab: nil, shell_agent: nil)
         pending_shell_inputs = []
         loop do
           if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
@@ -440,7 +558,7 @@ module Kward
             end
           end
 
-          input = pending_shell_inputs.shift || ask_ekwsh(shell)
+          input = pending_shell_inputs.shift || ask_kwsh(shell)
           if input.is_a?(Hash) && input[:tab_action]
             (@pending_inputs ||= []).unshift(input)
             return :tab_action
@@ -452,7 +570,7 @@ module Kward
             next
           end
 
-          result = run_ekwsh_command(shell, input)
+          result = run_kwsh_command(shell, input)
           if result.clear
             clear_active_tab_transient_shell_output
             @prompt.clear_transcript if @prompt.respond_to?(:clear_transcript)
@@ -463,37 +581,39 @@ module Kward
           return :tab_action if pending_tab_action?
 
           if result.open_editor_path
-            editor_result = open_ekwsh_editor(result.open_editor_path, shell)
+            editor_result = open_kwsh_editor(result.open_editor_path, shell)
             return :tab_action if editor_result == :tab_action
 
             next
           end
           if result.interactive_command
-            run_ekwsh_interactive_pty_command(shell, result)
+            pty_result = run_kwsh_interactive_pty_command(shell, result)
+            return :tab_action if pty_result&.tab_action
+
             next
           end
           if result.exit_shell
-            close_ekwsh_session(shell)
+            close_kwsh_session(shell)
             tab.shell = nil if tab
             tab.shell_agent = nil if tab
             runtime_output("Shell exited.")
             return :exited
           end
         end
-        close_ekwsh_session(shell)
+        close_kwsh_session(shell)
         tab.shell = nil if tab
         tab.shell_agent = nil if tab
         runtime_output("Shell exited.")
         :exited
       end
 
-      def close_ekwsh_session(shell)
+      def close_kwsh_session(shell)
         shell.close if shell.respond_to?(:close)
       rescue StandardError
         nil
       end
 
-      def with_ekwsh_history(history)
+      def with_kwsh_history(history)
         if history && @prompt.respond_to?(:with_prompt_history)
           @prompt.with_prompt_history(history) { yield }
         else
@@ -501,7 +621,7 @@ module Kward
         end
       end
 
-      def open_ekwsh_editor(path, shell)
+      def open_kwsh_editor(path, shell)
         unless @prompt.respond_to?(:edit_file)
           runtime_output("Integrated editor is unavailable in this prompt.")
           return false
@@ -516,7 +636,7 @@ module Kward
         result
       end
 
-      def ask_ekwsh(shell)
+      def ask_kwsh(shell)
         provider = ->(input, cursor) { shell.complete(input, cursor) }
         if @prompt.respond_to?(:with_completion_provider)
           @prompt.with_completion_provider(provider, slash_overlay: false) { @prompt.ask(shell.prompt_label) }
@@ -525,7 +645,7 @@ module Kward
         end
       end
 
-      def run_ekwsh_interactive_pty_command(shell, result)
+      def run_kwsh_interactive_pty_command(shell, result)
         shell_target = shell.respond_to?(:run_interactive) ? shell : shell.command_shell
         run_user_interactive_pty_command(
           result.interactive_command,
@@ -541,12 +661,12 @@ module Kward
         end
       end
 
-      def run_ekwsh_command(shell, input)
+      def run_kwsh_command(shell, input)
         if @prompt.respond_to?(:begin_busy_input)
           @prompt.begin_busy_input(shell.prompt_label, activity: "running")
         end
         if @prompt.respond_to?(:write_transcript_delta) && @prompt.respond_to?(:poll_input)
-          run_streaming_ekwsh_command(shell, input)
+          run_streaming_kwsh_command(shell, input)
         elsif @prompt.respond_to?(:write_transcript_delta)
           shell.run(input) { |chunk| @prompt.write_transcript_delta(chunk) }
         else
@@ -556,45 +676,70 @@ module Kward
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
       end
 
-      def run_streaming_ekwsh_command(shell, input)
+      def run_streaming_kwsh_command(shell, input)
         cancellation = Cancellation.new
         chunks = Queue.new
         queued_inputs = []
+        origin_tab = active_tab if respond_to?(:active_tab, true)
+        streamed_output = BufferedPtyOutputSink.new(max_capture_bytes: Kward::CLI::Tabs::TRANSIENT_SHELL_OUTPUT_LIMIT)
+        detached_sink = nil
         result = nil
         error = nil
         worker = Thread.new do
-          result = shell.run(input, cancellation: cancellation) { |chunk| chunks << chunk }
+          result = shell.run(input, cancellation: cancellation) do |chunk|
+            if detached_sink
+              detached_sink.write(chunk)
+            else
+              streamed_output.write(chunk)
+              chunks << chunk
+            end
+          end
         rescue StandardError => e
           error = e
         end
         worker.report_on_exception = false
 
         while worker.alive?
-          drain_ekwsh_chunks(chunks)
+          drain_kwsh_chunks(chunks)
           poll_result = collect_queued_input(queued_inputs)
           if poll_result == PromptInterface::CANCEL_INPUT
             cancellation.cancel!
           elsif poll_result.is_a?(Hash) && poll_result[:tab_action]
             (@pending_inputs ||= []).unshift(poll_result)
+            if origin_tab
+              detached_sink = BufferedPtyOutputSink.new(
+                max_capture_bytes: Kward::CLI::Tabs::TRANSIENT_SHELL_OUTPUT_LIMIT,
+                initial_output: streamed_output.captured_output,
+                initial_truncated: streamed_output.truncated?
+              )
+              background = DetachedRun.new(sink: detached_sink, canceler: -> { cancellation.cancel! }) do
+                worker.join
+                raise error if error
+
+                result
+              end
+              register_background_tab_run(origin_tab, background, output_kind: :streamed)
+              return Kwsh::Result.new(output: "", exit_status: 0, streamed: true)
+            end
             cancellation.cancel!
           end
           sleep 0.01
         end
         worker.join
-        drain_ekwsh_chunks(chunks)
+        drain_kwsh_chunks(chunks)
         raise error if error
 
         queued_inputs.reverse_each { |pending_input| (@pending_inputs ||= []).unshift(pending_input) }
         result
       end
 
-      def record_tab_transient_shell_output(text, render: true)
+      def record_tab_transient_shell_output(text, render: true, tab: nil)
         value = text.to_s
         return if value.empty?
 
-        tab = active_tab if respond_to?(:active_tab, true)
+        tab ||= active_tab if respond_to?(:active_tab, true)
         tab&.append_transient_shell_entry(value)
-        if render && @prompt.respond_to?(:record_transient_terminal_output)
+        if render && @prompt.respond_to?(:record_transient_terminal_output) && tab == active_tab
           @prompt.record_transient_terminal_output(value)
         end
       end
@@ -641,7 +786,7 @@ module Kward
         after
       end
 
-      def drain_ekwsh_chunks(chunks)
+      def drain_kwsh_chunks(chunks)
         loop do
           @prompt.write_transcript_delta(chunks.pop(true))
         rescue ThreadError
@@ -674,44 +819,56 @@ module Kward
         queued_inputs = []
         result = nil
         error = nil
-        begin_local_busy_command(activity)
+        cancelled = false
+        origin_tab = active_tab
+        cancellation = Cancellation.new
+        begin_local_busy_command(activity, tab: origin_tab)
 
         worker = Thread.new do
-          result = yield
+          Thread.current[:kward_local_busy_tab] = origin_tab
+          result = yield(cancellation)
         rescue StandardError => e
           error = e
+        ensure
+          Thread.current[:kward_local_busy_tab] = nil
         end
 
         while worker.alive?
           poll_result = collect_queued_input(queued_inputs)
+          if poll_result == PromptInterface::CANCEL_INPUT && !cancelled
+            cancelled = true
+            cancellation.cancel!
+          end
           handle_busy_local_tab_action(poll_result, activity: activity) if busy_local_tab_action?(poll_result)
           sleep 0.02
         end
         worker.join
         drain_queued_input(queued_inputs)
-        raise error if error
+        flushed = flush_pending_runtime_outputs(origin_tab)
+        origin_tab.unread = true if origin_tab && !flushed && origin_tab.pending_runtime_outputs.any?
+        raise error if error && !error.is_a?(Cancellation::CancelledError)
 
         [result, queued_inputs]
       ensure
-        finish_local_busy_command(activity)
+        finish_local_busy_command(activity, tab: origin_tab)
       end
 
       def run_busy_local_command_and_requeue(activity: "loading")
         return yield unless prompt_interface?
 
-        result, queued_inputs = run_busy_local_command(activity: activity) { yield }
+        result, queued_inputs = run_busy_local_command(activity: activity) { |cancellation| yield(cancellation) }
         queued_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
         result
       end
 
-      def begin_local_busy_command(activity)
-        active_tab.local_busy_activity = activity if active_tab
+      def begin_local_busy_command(activity, tab: active_tab)
+        tab.local_busy_activity = activity if tab
         @prompt.begin_busy_input("You>", activity: activity) if @prompt.respond_to?(:begin_busy_input)
         update_prompt_tabs if respond_to?(:update_prompt_tabs, true)
       end
 
-      def finish_local_busy_command(activity)
-        tab = local_busy_tab(activity)
+      def finish_local_busy_command(activity, tab: nil)
+        tab ||= local_busy_tab(activity)
         tab.local_busy_activity = nil if tab
         update_prompt_tabs if respond_to?(:update_prompt_tabs, true)
         @prompt.finish_busy_input if prompt_interface? && @prompt.respond_to?(:finish_busy_input) && (!active_tab || active_tab == tab)