kward 0.81.0 → 0.83.0

data/lib/kward/cli/rendering.rb

@@ -12,7 +12,12 @@ module Kward
 
       def redraw_interactive_prompt
         tab = active_tab if respond_to?(:active_tab, true)
-        if tab && (tab.running? || tab.shell)
+        clear_active_tab_transient_shell_output if tab && respond_to?(:clear_active_tab_transient_shell_output, true)
+        if tab&.shell
+          render_tab(tab, restore_composer: false)
+          return
+        end
+        if tab&.running?
           @prompt.redraw if @prompt.respond_to?(:redraw)
           return
         end
@@ -25,6 +30,7 @@ module Kward
 
         restore_prompt_transcript do
           tab ? render_transcript_messages(tab.driver.messages) : render_conversation_transcript(conversation)
+          render_tab_transient_shell_entries(tab) if tab && respond_to?(:render_tab_transient_shell_entries, true)
         end
       end
 
@@ -283,8 +289,14 @@ module Kward
       # Writes the pasted images output for the terminal CLI flow.
       def print_pasted_images(input, image_parts: nil)
         parts = image_parts || Kward::ImageAttachments.image_parts_from_text(input)
+        protocol = @prompt.inline_image_protocol if @prompt.respond_to?(:inline_image_protocol)
         parts.each do |part|
-          sequence = Kward::ImageAttachments.terminal_image_sequence(part)
+          next if @prompt.respond_to?(:inline_image_protocol) && protocol.nil?
+
+          part = Kward::ImageAttachments.terminal_image_part(part, protocol) if protocol
+          next if protocol && part.nil?
+
+          sequence = Kward::ImageAttachments.terminal_image_sequence(part, protocol: protocol)
           next unless sequence
 
           if @prompt.respond_to?(:say_visual)

data/lib/kward/cli/runtime_helpers.rb

@@ -6,7 +6,6 @@ module Kward
     module RuntimeHelpers
       MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES = 1_048_576
       UNSAFE_TRANSCRIPT_CONTROL_PATTERN = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.freeze
-      FROZEN_COMPOSER_COMMANDS = /\Agit\s+(?:fetch|ls-remote|push|remote|status)(?:\s|\z)/.freeze
 
       private
 
@@ -101,6 +100,7 @@ module Kward
         shell = bang_shell(agent)
         editor_result = shell.editor_command_result(command)
         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
           return true
@@ -192,13 +192,86 @@ module Kward
         entering = tab.nil? || tab.shell.nil?
         shell = tab&.shell || build_ekwsh(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))
+        run_ekwsh_loop(shell, tab: tab, history: build_ekwsh_history(agent), shell_agent: shell_agent)
+      end
+
+      def shell_prompt_agent_for(agent, tab: nil)
+        return tab.shell_agent if tab&.shell_agent
+        return nil unless agent.respond_to?(:conversation) && agent.respond_to?(:tool_registry)
+
+        shell_agent = build_shell_prompt_agent(agent)
+        tab.shell_agent = shell_agent if tab
+        shell_agent
+      end
+
+      def build_shell_prompt_agent(active_agent)
+        active_conversation = active_agent.conversation
+        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
+        )
+        Agent.new(
+          client: @client,
+          tool_registry: active_agent.tool_registry,
+          conversation: conversation,
+          warning_sink: ConfigFiles.warning_sink
+        )
+      end
+
+      def run_shell_prompt_turn(input, shell, shell_agent)
+        tab = active_tab if respond_to?(:active_tab, true)
+        transcript_before = prompt_transcript_text
+        instruction = input.to_s.sub(/\A\?\s*/, "").strip
+        if instruction.empty?
+          runtime_output("Shell prompt instruction required after ?")
+          return []
+        end
+        unless shell_agent.respond_to?(:tool_registry)
+          runtime_output("Shell agent is unavailable in this prompt.")
+          return []
+        end
+
+        session = ShellPromptSession.new(shell)
+        registry = shell_agent.tool_registry.for_shell_prompt(session)
+        on_complete = lambda do |successful:, **|
+          next unless successful
+          next unless session.prepared_command
+
+          if @prompt.respond_to?(:prefill_input)
+            @prompt.prefill_input(session.prepared_command)
+          else
+            runtime_output("Prepared shell command:\n#{session.prepared_command}")
+          end
+        end
+        pending_inputs = run_interactive_turn(
+          shell_agent,
+          ShellPrompt.input(instruction, session.context),
+          display_input: "? #{instruction}",
+          tool_registry: registry,
+          busy_label: shell.prompt_label,
+          on_complete: on_complete
+        )
+        @prompt.update_prompt_label(shell.prompt_label) if @prompt.respond_to?(:update_prompt_label)
+        pending_inputs
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        []
+      ensure
+        record_shell_prompt_transcript(tab, transcript_before)
+      end
+
+      def shell_prompt_input?(input)
+        input.to_s.start_with?("?")
       end
 
       def build_ekwsh(agent)
         config = ConfigFiles.read_ekwsh_config
-        Ekwsh.new(
+        PersistentShellSession.new(
           cwd: interactive_workspace_root(agent),
           configured_env: config[:env],
           aliases: config[:aliases],
@@ -235,65 +308,109 @@ module Kward
 
       def run_user_interactive_pty_command(command, shell:, env:, cwd:, intro: nil)
         intro_message = intro || "$ #{command}\n"
+        record_tab_transient_shell_output(intro_message, render: false)
         if @prompt.respond_to?(:write_transcript)
           @prompt.write_transcript(intro_message)
         elsif @prompt.respond_to?(:say)
           @prompt.say(intro_message)
         end
-        output = +"".b
-        output_truncated = false
-        handoff_options = {}
-        handoff_options[:preserve_composer] = true if frozen_composer_command?(command)
-        result = run_interactive_pty_with_terminal_handoff(shell, command, env: env, cwd: cwd, **handoff_options) do |chunk|
-          remaining = MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES - output.bytesize
-          if chunk.bytesize > remaining
-            output << chunk.byteslice(0, remaining) if remaining.positive?
-            output_truncated = true
-          else
-            output << chunk
-          end
-        end
-        @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
-        transcript_output = terminal_transcript_output(output, result, truncated: output_truncated)
-        if transcript_output && @prompt.respond_to?(:record_transient_terminal_output)
-          @prompt.record_transient_terminal_output(transcript_output)
+        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)
+          yield(transcript_output, completed_result) if block_given?
         end
+        refresh_composer_status
         result
       rescue Errno::ENOENT => e
         runtime_output("Error: #{e.message}")
         nil
       end
 
-      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, preserve_composer: false, &block)
+      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:, &on_complete)
         runner = InteractivePtyRunner.new
-        if @prompt.respond_to?(:with_terminal_handoff)
-          if preserve_composer
-            @prompt.with_terminal_handoff(preserve_composer: true) do |input, output|
-              runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output, &block)
-            end
+        with_interactive_terminal_handoff do |input, sink|
+          result = if shell.respond_to?(:run_interactive)
+            shell.run_interactive(command, input: input, sink: sink)
           else
-            @prompt.with_terminal_handoff do |input, output|
-              runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output, &block)
-            end
+            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, sink: sink)
+          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|
+            sink = AdaptivePtyOutputSink.new(
+              output: output,
+              on_exclusive: transition,
+              max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+            )
+            yield(input, sink)
+          end
+        elsif @prompt.respond_to?(:with_terminal_handoff)
+          @prompt.with_terminal_handoff do |input, output|
+            sink = PassthroughPtyOutputSink.new(
+              output: output,
+              max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+            )
+            yield(input, sink)
           end
         else
-          runner.run(shell, "-c", command, env: env, cwd: cwd, &block)
+          sink = PassthroughPtyOutputSink.new(
+            output: $stdout,
+            max_capture_bytes: MAX_TRANSIENT_TERMINAL_OUTPUT_BYTES
+          )
+          yield($stdin, sink)
         end
       end
 
-      def frozen_composer_command?(command)
-        FROZEN_COMPOSER_COMMANDS.match?(command.to_s.strip)
+      def record_completed_pty_output(sink, result)
+        classified_output = sink.respond_to?(:transcript_safe?)
+        return if classified_output && !sink.transcript_safe?
+
+        output = sink&.captured_output || +"".b
+        allow_input = classified_output &&
+          sink.respond_to?(:pre_input_capture_only?) &&
+          sink.pre_input_capture_only?
+        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(output, result, truncated:)
-        return if truncated || result.input_forwarded
+      def terminal_transcript_output(
+        output,
+        result,
+        truncated:,
+        allow_input: false,
+        normalize_line_controls: false
+      )
+        return if truncated || (result.input_forwarded && !allow_input)
 
         text = ANSI.normalize_transcript_encoding(output).gsub("\r\n", "\n")
-        return if text.empty? || text.include?("\r")
+        return if text.empty?
+
+        if normalize_line_controls
+          sanitized = PtyTranscriptNormalizer.normalize(text)
+        else
+          return if text.include?("\r")
 
-        sanitized = ANSI.sanitize_transcript(text)
-        return unless sanitized == text
-        return if ANSI.strip_control_sequences(text).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
+          sanitized = ANSI.sanitize_transcript(text)
+          return unless sanitized == text
+        end
+        return if sanitized.empty?
+        return if ANSI.strip_control_sequences(sanitized).match?(UNSAFE_TRANSCRIPT_CONTROL_PATTERN)
 
         sanitized
       end
@@ -305,13 +422,15 @@ module Kward
         end
       end
 
-      def run_ekwsh_loop(shell, tab: nil, history: nil)
+      def run_ekwsh_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)
+          run_ekwsh_loop_with_history(shell, tab: tab, shell_agent: shell_agent)
         end
       end
 
-      def run_ekwsh_loop_with_history(shell, tab: nil)
+      def run_ekwsh_loop_with_history(shell, tab: nil, shell_agent: nil)
+        pending_shell_inputs = []
         loop do
           if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
             editor_result = @prompt.run_editor
@@ -321,16 +440,26 @@ module Kward
             end
           end
 
-          input = ask_ekwsh(shell)
+          input = pending_shell_inputs.shift || ask_ekwsh(shell)
           if input.is_a?(Hash) && input[:tab_action]
             (@pending_inputs ||= []).unshift(input)
             return :tab_action
           end
           break if input.nil?
 
+          if shell_prompt_input?(input)
+            pending_shell_inputs.concat(run_shell_prompt_turn(input, shell, shell_agent))
+            next
+          end
+
           result = run_ekwsh_command(shell, input)
-          @prompt.clear_transcript if result.clear && @prompt.respond_to?(:clear_transcript)
-          @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          if result.clear
+            clear_active_tab_transient_shell_output
+            @prompt.clear_transcript if @prompt.respond_to?(:clear_transcript)
+          else
+            record_tab_transient_shell_output(result.output, render: false) unless result.interactive_command
+            @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          end
           return :tab_action if pending_tab_action?
 
           if result.open_editor_path
@@ -344,16 +473,26 @@ module Kward
             next
           end
           if result.exit_shell
+            close_ekwsh_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)
         tab.shell = nil if tab
+        tab.shell_agent = nil if tab
         runtime_output("Shell exited.")
         :exited
       end
 
+      def close_ekwsh_session(shell)
+        shell.close if shell.respond_to?(:close)
+      rescue StandardError
+        nil
+      end
+
       def with_ekwsh_history(history)
         if history && @prompt.respond_to?(:with_prompt_history)
           @prompt.with_prompt_history(history) { yield }
@@ -387,13 +526,19 @@ module Kward
       end
 
       def run_ekwsh_interactive_pty_command(shell, result)
+        shell_target = shell.respond_to?(:run_interactive) ? shell : shell.command_shell
         run_user_interactive_pty_command(
           result.interactive_command,
-          shell: shell.command_shell,
+          shell: shell_target,
           env: shell.child_env(interactive: true),
           cwd: shell.cwd,
           intro: result.output
-        )
+        ) do |transcript_output, completed_result|
+          shell.record_interactive_result(
+            output: transcript_output,
+            exit_status: completed_result.exit_status
+          )
+        end
       end
 
       def run_ekwsh_command(shell, input)
@@ -443,6 +588,59 @@ module Kward
         result
       end
 
+      def record_tab_transient_shell_output(text, render: true)
+        value = text.to_s
+        return if value.empty?
+
+        tab = active_tab if respond_to?(:active_tab, true)
+        tab&.append_transient_shell_entry(value)
+        if render && @prompt.respond_to?(:record_transient_terminal_output)
+          @prompt.record_transient_terminal_output(value)
+        end
+      end
+
+      def clear_active_tab_transient_shell_output
+        clear_active_tab_transient_shell_entries if respond_to?(:clear_active_tab_transient_shell_entries, true)
+      end
+
+      def prompt_transcript_text
+        return nil unless @prompt.respond_to?(:tab_view_snapshot)
+
+        snapshot = @prompt.tab_view_snapshot
+        transcript = snapshot[:transcript_buffer] || snapshot["transcript_buffer"] || snapshot[:transcript] || snapshot["transcript"]
+        transcript = transcript.map(&:to_s).join if transcript.is_a?(Array)
+        transcript.to_s
+      rescue StandardError
+        nil
+      end
+
+      def record_shell_prompt_transcript(tab, transcript_before)
+        return unless tab && !transcript_before.nil?
+
+        transcript_after = prompt_transcript_text
+        return if transcript_after.nil?
+
+        delta = shell_prompt_transcript_delta(transcript_before, transcript_after)
+        tab.append_transient_shell_entry(delta) unless delta.empty?
+      rescue StandardError
+        nil
+      end
+
+      def shell_prompt_transcript_delta(before, after)
+        return "" if before == after
+        return after[before.length..].to_s if after.start_with?(before)
+
+        # The prompt transcript is bounded and may trim while a large agent
+        # response is rendered. Preserve only the part not already retained.
+        overlap = [before.length, after.length].min
+        while overlap.positive?
+          return after[overlap..].to_s if before.end_with?(after[0, overlap])
+
+          overlap -= 1
+        end
+        after
+      end
+
       def drain_ekwsh_chunks(chunks)
         loop do
           @prompt.write_transcript_delta(chunks.pop(true))
@@ -559,6 +757,14 @@ module Kward
         @client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : ModelInfo::DEFAULT_REASONING_EFFORT
       end
 
+      def refresh_composer_status
+        if @prompt.respond_to?(:refresh_composer_status)
+          @prompt.refresh_composer_status
+        elsif @prompt.respond_to?(:redraw)
+          @prompt.redraw
+        end
+      end
+
       def reload_client_config
         @client.reload_config if @client.respond_to?(:reload_config)
       end

data/lib/kward/cli/settings.rb

@@ -115,7 +115,7 @@ module Kward
         ConfigFiles.update_config("provider" => ModelInfo.config_provider_for_provider(provider))
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       def provider_choices
@@ -166,7 +166,7 @@ module Kward
         ConfigFiles.update_config("local_backend" => backend, "local_base_url" => url)
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       def configure_account_settings
@@ -920,7 +920,7 @@ module Kward
         ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
         reload_client_config
         refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        refresh_composer_status
       end
 
       REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5
@@ -953,18 +953,10 @@ module Kward
         queue_reasoning_config(effort, provider: provider, conversation: conversation) if queue_config
         if queue_config
           update_conversation_reasoning_effort(conversation, effort)
-          refresh_reasoning_status
+          refresh_composer_status
         else
           refresh_conversation_runtime(conversation, reasoning_effort: effort)
-          refresh_reasoning_status
-        end
-      end
-
-      def refresh_reasoning_status
-        if @prompt.respond_to?(:refresh_composer_status)
-          @prompt.refresh_composer_status
-        else
-          @prompt.redraw if @prompt.respond_to?(:redraw)
+          refresh_composer_status
         end
       end
 

data/lib/kward/cli/slash_commands.rb

@@ -54,13 +54,17 @@ module Kward
           run_captured_shell_command(argument, agent)
           [true, nil]
         when "scratchpad"
-          open_scratchpad_command(argument)
+          result = open_scratchpad_command(argument)
+          queue_editor_prompt_action(result)
           [true, nil]
         when "pty"
           run_interactive_pty_command(argument, agent)
           [true, nil]
         when "tab"
           [true, handle_tab_command(argument, session_store)]
+        when "worktree"
+          handle_worktree_command(argument)
+          [true, active_tab&.agent]
         when "settings"
           configure_settings(agent.conversation)
           [true, nil]
@@ -307,6 +311,13 @@ module Kward
         end
       end
 
+      def queue_editor_prompt_action(result)
+        return unless result.is_a?(Hash) && result[:editor_prompt]
+
+        @pending_inputs ||= []
+        @pending_inputs.unshift(result)
+      end
+
       def scratchpad_language_argument(argument)
         value = argument.to_s.strip.downcase
         return :text if value.empty? || value == "text"

data/lib/kward/cli/tabs.rb

@@ -35,10 +35,14 @@ module Kward
         :unread,
         :pending_question,
         :shell,
+        :shell_agent,
+        :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
         keyword_init: true
       ) do
+        TRANSIENT_SHELL_OUTPUT_LIMIT = 200_000
+
         def running?
           %w[queued running waiting_for_question].include?(status.to_s)
         end
@@ -54,6 +58,41 @@ module Kward
         def record_event(event)
           event_history << event
         end
+
+        def append_transient_shell_entry(text)
+          value = text.to_s
+          return if value.empty?
+
+          self.transient_shell_entries ||= []
+          transient_shell_entries << value
+          trim_transient_shell_entries
+        end
+
+        def clear_transient_shell_entries
+          self.transient_shell_entries = []
+        end
+
+        private
+
+        def trim_transient_shell_entries
+          combined = transient_shell_entries.join
+          return if combined.length <= TRANSIENT_SHELL_OUTPUT_LIMIT
+
+          target = (TRANSIENT_SHELL_OUTPUT_LIMIT * 0.9).floor
+          cutoff = combined.length - target
+          newline = combined.index("\n", cutoff)
+          cutoff = newline + 1 if newline
+          cutoff = transient_shell_escape_boundary(combined, cutoff)
+          self.transient_shell_entries = [combined[cutoff..].to_s]
+        end
+
+        def transient_shell_escape_boundary(text, cutoff)
+          escape_start = text.rindex("\e", cutoff)
+          return cutoff unless escape_start
+
+          escape = ANSI.escape_sequence_at(text, escape_start)
+          escape && escape_start + escape.length > cutoff ? escape_start + escape.length : cutoff
+        end
       end
 
       class TabQuestionPrompt
@@ -279,6 +318,8 @@ module Kward
           unread: false,
           pending_question: nil,
           shell: nil,
+          shell_agent: nil,
+          transient_shell_entries: [],
           error_reported: false,
           local_busy_activity: nil
         ).tap { |tab| assign_tab_question_prompt(agent, tab) }
@@ -379,12 +420,14 @@ module Kward
         end
 
         if @tabs.length <= 1
+          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
           @tabs.clear
           persist_tabs
           return PromptInterface::EXIT_INPUT
         end
 
         stop_tab_live_view
+        close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
         tab.session&.delete_if_unused if tab&.session.respond_to?(:delete_if_unused)
         tab.driver.close if tab.driver.respond_to?(:close)
         @tabs.delete_at(@active_tab_index)
@@ -423,7 +466,10 @@ module Kward
         tab.seen_events = 0
         tab.queued_inputs.clear
         tab.steering = nil
+        close_ekwsh_session(tab.shell) if tab.shell && respond_to?(:close_ekwsh_session, true)
         tab.shell = nil
+        tab.shell_agent = nil
+        tab.clear_transient_shell_entries
         tab.stream_state = new_tab_stream_state(tab.driver)
         tab.markdown_chunks.clear
         update_prompt_workspace_root(current_workspace_root)
@@ -451,7 +497,7 @@ module Kward
         end
         return snapshot_method.call unless supports_transcript_option
 
-        snapshot_method.call(include_transcript: tab.running? || !tab.shell.nil?)
+        snapshot_method.call(include_transcript: tab.running?)
       end
 
       def activate_tab(index, render: true)
@@ -484,8 +530,8 @@ module Kward
         tab.agent
       end
 
-      def render_tab(tab)
-        if tab.snapshot && @prompt.respond_to?(:restore_tab_view_snapshot) && (tab.running? || tab.shell)
+      def render_tab(tab, restore_composer: true)
+        if restore_composer && tab.snapshot && @prompt.respond_to?(:restore_tab_view_snapshot) && tab.running?
           @prompt.restore_tab_view_snapshot(tab.snapshot)
           return
         end
@@ -497,8 +543,23 @@ module Kward
             render_transcript_messages(tab.driver.messages)
           end
           report_tab_runtime_error(tab) if %w[failed cancelled].include?(tab.status.to_s)
+          render_tab_transient_shell_entries(tab)
+        end
+        restore_tab_composer_snapshot(tab.snapshot) if restore_composer
+      end
+
+      def render_tab_transient_shell_entries(tab)
+        Array(tab.transient_shell_entries).each do |entry|
+          if @prompt.respond_to?(:say)
+            @prompt.say(entry)
+          elsif @prompt.respond_to?(:write_transcript)
+            @prompt.write_transcript(entry)
+          end
         end
-        restore_tab_composer_snapshot(tab.snapshot)
+      end
+
+      def clear_active_tab_transient_shell_entries
+        active_tab&.clear_transient_shell_entries
       end
 
       def restore_tab_composer_snapshot(snapshot)
@@ -904,11 +965,12 @@ module Kward
       def stop_tabs
         stop_tab_live_view
         Array(@tabs).each do |tab|
-          next unless tab&.running?
-
-          tab.cancellation&.cancel!
-          tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
-          tab.thread&.join(0.2)
+          if tab&.running?
+            tab.cancellation&.cancel!
+            tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
+            tab.thread&.join(0.2)
+          end
+          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
         rescue StandardError
           nil
         end