kward 0.84.0 → 0.85.0

data/lib/kward/cli/plugins.rb

@@ -11,7 +11,7 @@ module Kward
       end
 
       def plugin_registry
-        @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_slash_command_names)
+        @plugin_registry ||= PluginRegistry.load(reserved_commands: reserved_slash_command_names).tap(&:start!)
       end
 
       def plugin_commands
@@ -30,15 +30,22 @@ module Kward
         plugin_registry.interactive_command_for(command)
       end
 
-      def reload_plugins(conversation)
+      def reload_plugins(conversation, tool_registry: nil)
         @prompt_templates = nil
-        @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
+        registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
+        @plugin_registry&.reload!
+        @plugin_registry = registry.tap(&:start!)
         @prompt.update_slash_commands(slash_command_entries) if @prompt.respond_to?(:update_slash_commands)
         conversation.plugin_registry = @plugin_registry if conversation.respond_to?(:plugin_registry=)
         conversation.refresh_system_message! if conversation.respond_to?(:refresh_system_message!)
+        tool_registry&.replace_plugin_tools!(@plugin_registry.tools)
         runtime_output("Plugins reloaded.")
       end
 
+      def shutdown_plugins
+        @plugin_registry&.shutdown!
+      end
+
       def lifecycle_hook_manager(conversation)
         manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(conversation.workspace_root)).manager
         plugin_registry.hook_handlers.each do |hook|
@@ -50,7 +57,7 @@ module Kward
       end
 
       def lifecycle_hook_context(conversation)
-        plugin_context(conversation, "")
+        plugin_context(conversation, "", requests: false, tool_requests: true)
       end
 
       def run_lifecycle_hook(name, conversation:, payload: {}, session: @active_session)
@@ -81,7 +88,7 @@ module Kward
         return [false, nil] unless command
         return [false, nil] unless prompt_interface? && @prompt.respond_to?(:start_interactive)
 
-        context = plugin_context(agent.conversation, argument)
+        context = plugin_context(agent.conversation, argument, requests: false)
         controller = @prompt.start_interactive(title: "/#{name}", rows: command.rows, fps: command.fps)
         command.handler.call(controller, context)
         run_interactive_loop
@@ -150,26 +157,88 @@ module Kward
         PromptCommands.expand(input, templates: prompt_templates, reserved_commands: builtin_slash_command_names)
       end
 
-      def run_plugin_command(name, argument, agent)
+      def run_plugin_command_and_turn(name, argument, agent)
+        origin_tab = active_tab
+        _handled, request = run_busy_local_command_and_requeue(activity: "running") do |cancellation|
+          run_plugin_command(name, argument, agent, cancellation: cancellation)
+        end
+        return [true, nil] unless request
+        return [true, nil] if origin_tab && (!@tabs.include?(origin_tab) || !origin_tab.agent.equal?(agent))
+
+        flush_pending_reasoning_config(conversation: agent.conversation)
+        if origin_tab
+          session = origin_tab.session
+          session.rename(default_session_name(request.to_s)) if session && session.name.to_s.empty?
+          submit_tab_input(origin_tab, request, display_input: request.to_s)
+        else
+          auto_name_active_session(request.to_s)
+          pending = run_interactive_turn(agent, request, display_input: request.to_s)
+          pending.reverse_each { |input| @pending_inputs.unshift(input) }
+        end
+        [true, nil]
+      rescue Cancellation::CancelledError
+        [true, nil]
+      rescue StandardError => e
+        runtime_output("Error: #{e.message}")
+        [true, nil]
+      end
+
+      def run_plugin_command(name, argument, agent, cancellation: nil)
         command = plugin_command_for(name)
         return [false, nil] unless command
 
+        cancellation&.raise_if_cancelled!
         agent.conversation.plugin_registry ||= plugin_registry if agent.conversation.respond_to?(:plugin_registry)
-        context = plugin_context(agent.conversation, argument)
-        command.handler.call(argument, context)
-        [true, nil]
+        arguments = command.parse_arguments(argument)
+        context = plugin_context(agent.conversation, arguments, cancellation: cancellation, turn_command: command)
+        result = command.normalize_result(command.handler.call(arguments, context))
+        cancellation&.raise_if_cancelled!
+        runtime_output(result.message) if command.typed? && !result.message.to_s.empty?
+        [true, context.requested_turn]
+      rescue Cancellation::CancelledError
+        raise
       rescue StandardError => e
         runtime_output("Plugin command /#{name} error: #{e.message}")
         [true, nil]
       end
 
-      def plugin_context(conversation, args)
+      def plugin_context(conversation, args, requests: true, tool_requests: nil, cancellation: nil, turn_command: nil)
+        say_callback = lambda { |message| runtime_output(message) }
+        tool_requests = requests if tool_requests.nil?
         PluginRegistry::Context.new(
           conversation: conversation,
           args: args,
           session: @active_session,
           workspace_root: conversation.workspace_root,
-          say_callback: lambda { |message| runtime_output(message) }
+          say_callback: say_callback,
+          cancellation: cancellation,
+          ui: plugin_ui(say_callback, requests: requests),
+          tool_ui: plugin_ui(say_callback, requests: tool_requests),
+          turn_command: turn_command
+        )
+      end
+
+      def plugin_ui(say_callback, requests:)
+        capabilities = { progress: true, notify: true }
+        requester = nil
+        if requests && @prompt.respond_to?(:request_plugin_ui)
+          capabilities.merge!(question: true, select: true, confirm: true, input: true)
+          requester = lambda do |kind, payload, cancellation: nil|
+            @prompt.request_plugin_ui(kind, payload, cancellation: cancellation)
+          end
+        end
+        emitter = lambda do |kind, payload|
+          case kind
+          when :notify
+            runtime_output(payload[:message])
+          when :progress
+            text = payload[:percent] ? "#{payload[:message]} (#{payload[:percent]}%)" : payload[:message]
+            runtime_output(text)
+          end
+        end
+        PluginUI.new(
+          backend: PluginUI::Backend.new(capabilities: capabilities, requester: requester, emitter: emitter),
+          say_callback: say_callback
         )
       end
 
@@ -201,7 +270,7 @@ module Kward
         return unless conversation
         return if plugin_registry.transcript_event_handlers.empty?
 
-        plugin_registry.notify_transcript_event(event, plugin_context(conversation, ""))
+        plugin_registry.notify_transcript_event(event, plugin_context(conversation, "", requests: false))
       end
 
       def notify_plugin_tab_transcript_event(event, driver)

data/lib/kward/cli/prompt_interface.rb

@@ -247,14 +247,16 @@ module Kward
       end
 
       def prompt_footer_renderer
-        return nil unless plugin_registry.footer_renderer
+        return nil unless plugin_registry.status?
 
-        lambda do
-          renderer = plugin_registry.footer_renderer
-          next "" unless renderer
+        lambda do |max_width = nil|
+          next "" unless plugin_registry.status?
 
           context = plugin_context(current_footer_conversation, "")
-          renderer.call(context).to_s
+          segments = plugin_registry.status_segments(context)
+          plugin_registry.compose_status(segments, max_width: max_width) do |text|
+            TerminalText.width(ANSI.strip(text.to_s))
+          end
         rescue StandardError => e
           emit_warning "Warning: Kward plugin footer error: #{e.message}"
           ""
@@ -271,6 +273,8 @@ module Kward
         parts = []
         git = composer_git_branch_text
         parts << git if git
+        merge = composer_worktree_merge_text
+        parts << merge if merge
         diff = composer_session_diff_text
         parts << diff if diff
         usage = composer_context_usage(provider, model)
@@ -279,6 +283,22 @@ module Kward
         parts.join(" · ")
       end
 
+      def composer_worktree_merge_text
+        return nil unless respond_to?(:active_tab, true) && respond_to?(:worktree_binding_for, true)
+
+        binding = worktree_binding_for(active_tab)
+        return nil unless binding&.active?
+        return nil unless git_worktree_manager.merge_in_progress?(binding.origin_root)
+
+        conflicts = git_worktree_manager.merge_conflict_marker_paths(binding.origin_root, cached: false)
+        target = git_worktree_manager.current_branch(binding.origin_root)
+        count = conflicts.length
+        detail = count.zero? ? "ready" : "#{count} conflict#{count == 1 ? "" : "s"}"
+        ANSI.colorize("merge→#{target.empty? ? "detached" : target} (#{detail})", :red, enabled: @color_enabled)
+      rescue GitWorktreeManager::Error
+        nil
+      end
+
       def composer_session_diff_text
         return nil if @session_diff.nil? || @session_diff.empty?
 

data/lib/kward/cli/rendering.rb

@@ -224,6 +224,9 @@ module Kward
       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")
+        # 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

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
@@ -320,8 +326,13 @@ module Kward
           @prompt.say(intro_message)
         end
         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|
-          transcript_output = record_completed_pty_output(sink, completed_result, tab: origin_tab)
+        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
@@ -337,7 +348,13 @@ module Kward
         with_interactive_terminal_handoff do |input, sink|
           tab_action_handler = terminal_handoff_tab_action_handler
           on_detach = if origin_tab
-            -> { BufferedPtyOutputSink.new(max_capture_bytes: Kward::CLI::Tabs::TRANSIENT_SHELL_OUTPUT_LIMIT) }
+            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, tab_action_handler: tab_action_handler, on_detach: on_detach)
@@ -345,7 +362,7 @@ module Kward
             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, &on_complete)
+            register_background_tab_run(origin_tab, result.background, output_kind: :pty, &on_complete)
           else
             on_complete.call(sink, result) if on_complete
           end
@@ -404,7 +421,76 @@ module Kward
         end
       end
 
-      def record_completed_pty_output(sink, result, tab: nil)
+      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?
 
@@ -412,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, tab: tab)
-        if @prompt.respond_to?(:record_transient_terminal_output) && (!tab || tab == active_tab)
-          @prompt.record_transient_terminal_output(transcript_output, render: false)
-        end
-        transcript_output
       end
 
       def terminal_transcript_output(
@@ -602,6 +681,7 @@ module Kward
         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
@@ -610,6 +690,7 @@ module Kward
             if detached_sink
               detached_sink.write(chunk)
             else
+              streamed_output.write(chunk)
               chunks << chunk
             end
           end
@@ -626,17 +707,18 @@ module Kward
           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)
+              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) do |_sink, completed_result|
-                record_tab_transient_shell_output(completed_result.output, render: false, tab: origin_tab)
-                @prompt.say(completed_result.output) if origin_tab == active_tab && completed_result.output.to_s != ""
-              end
+              register_background_tab_run(origin_tab, background, output_kind: :streamed)
               return Kwsh::Result.new(output: "", exit_status: 0, streamed: true)
             end
             cancellation.cancel!
@@ -737,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)

data/lib/kward/cli/sessions.rb

@@ -392,13 +392,15 @@ module Kward
       end
 
       def reload_active_session(session_store)
+        workspace_root = current_workspace_root
+        worktree = worktree_binding_for(active_tab)
         @active_session, conversation = session_store.load(
           @active_session.path,
-          workspace: configured_workspace(root: session_store.cwd),
+          workspace: configured_workspace(root: workspace_root, strict: worktree&.active? == true),
           provider: current_model_provider,
           model: current_model_id,
           reasoning_effort: current_reasoning_effort,
-          project_skill_paths: project_skill_paths_for(session_store.cwd) || []
+          project_skill_paths: project_skill_paths_for(workspace_root) || []
         )
         reset_session_diff(@active_session.path)
         track_session(@active_session)
@@ -415,7 +417,7 @@ module Kward
         SessionTreeRenderer.new(roots: roots, current_leaf_id: current_leaf_id).items
       end
 
-      def rename_session(argument, require_name: false)
+      def rename_session(argument, require_name: false, announce: true)
         unless @active_session
           runtime_output("No active persisted session.")
           return
@@ -430,8 +432,10 @@ module Kward
         old_name = @active_session.name
         @active_session.rename(name)
         run_lifecycle_hook("session_rename", conversation: new_conversation(workspace_root: current_workspace_root), session: @active_session, payload: { old_name: old_name, new_name: @active_session.name })
-        label = @active_session.name ? "Named session: #{@active_session.name}" : "Cleared session name."
-        runtime_output(label)
+        if announce
+          label = @active_session.name ? "Named session: #{@active_session.name}" : "Cleared session name."
+          runtime_output(label)
+        end
       end
 
       def clone_session(session_store, agent)