kward 0.83.0 → 0.85.0

data/lib/kward/cli/doctor.rb

@@ -8,11 +8,32 @@ module Kward
 
       # Writes the doctor output for the terminal CLI flow.
       def print_doctor
-        lines = ["#{colored("Kward Doctor", :green, :bold)}", ""]
-        doctor_checks.each do |check|
-          lines << "#{doctor_mark(check.fetch(:status))} #{check.fetch(:label)}: #{check.fetch(:message)}"
+        checks = doctor_checks
+        core_checks, optional_checks = checks.partition { |check| !check[:optional] }
+        lines = [colored("Kward Doctor", :green, :bold), "", colored("Core checks", :blue, :bold)]
+        lines.concat(doctor_check_lines(core_checks))
+        if optional_checks.any?
+          lines << ""
+          lines << colored("Optional", :blue, :bold)
+          lines.concat(doctor_check_lines(optional_checks))
         end
+        lines << ""
+        lines << doctor_summary(checks)
         @prompt.say lines.join("\n")
+        checks.none? { |check| check.fetch(:status) == :error && !check[:optional] }
+      end
+
+      def doctor_check_lines(checks)
+        checks.map { |check| "#{doctor_mark(check.fetch(:status))} #{check.fetch(:label)}: #{check.fetch(:message)}" }
+      end
+
+      def doctor_summary(checks)
+        errors = checks.count { |check| check.fetch(:status) == :error && !check[:optional] }
+        warnings = checks.count { |check| check.fetch(:status) == :warning && !check[:optional] }
+        return "Kward needs attention: #{errors} core check#{errors == 1 ? "" : "s"} failed." if errors.positive?
+        return "Kward is ready with #{warnings} warning#{warnings == 1 ? "" : "s"}." if warnings.positive?
+
+        "Kward is ready."
       end
 
       def doctor_checks
@@ -108,29 +129,28 @@ module Kward
         { status: :error, label: "Local endpoint", message: "invalid URL: #{url}" }
       end
 
-      def doctor_auth_check(config)
-        openai_auth = OpenAIOAuth.default_auth_path
-        github_auth = GithubOAuth.default_auth_path
-        has_openrouter = !config.to_h["openrouter_api_key"].to_s.empty? || !ENV["OPENROUTER_API_KEY"].to_s.empty?
+      def doctor_auth_check(_config)
         local_provider = @client.respond_to?(:current_provider) && @client.current_provider == "Local"
-        paths = []
-        paths << "OpenAI OAuth" if File.exist?(openai_auth)
-        paths << "GitHub OAuth" if File.exist?(github_auth)
-        paths << "OpenRouter API key" if has_openrouter
-        paths << "Local endpoint (no authentication required)" if local_provider
-        return { status: :ok, label: "Auth", message: paths.join(", ") } if paths.any?
+        configured = auth_credentials.select { |credential| credential.fetch(:configured) }.map { |credential| credential.fetch(:label) }
+        configured << "Local endpoint (no authentication required)" if local_provider
+        return { status: :ok, label: "Auth", message: configured.join(", ") } if configured.any?
 
         { status: :warning, label: "Auth", message: "no saved credentials found; run `kward login`" }
+      rescue ConfigFiles::ConfigError
+        { status: :warning, label: "Auth", message: "skipped because config is invalid" }
       end
 
       def doctor_pan_check(config_result)
-        return { status: :warning, label: "Pan mode", message: "skipped because config is invalid" } if config_result.is_a?(ConfigFiles::ConfigError)
+        return { status: :optional, label: "Pan mode", message: "skipped because config is invalid", optional: true } if config_result.is_a?(ConfigFiles::ConfigError)
 
         pan = config_result.to_h["pan_mode"] || {}
-        if !pan["username"].to_s.empty? && !pan["password"].to_s.empty?
-          { status: :ok, label: "Pan mode", message: "credentials configured" }
+        environment_password = ENV["KWARD_PAN_PASSWORD"].to_s
+        password = environment_password.empty? ? pan["password"].to_s : environment_password
+        if !pan["username"].to_s.empty? && !password.empty?
+          source = environment_password.empty? ? "config" : "environment"
+          { status: :ok, label: "Pan mode", message: "credentials configured (password from #{source})", optional: true }
         else
-          { status: :warning, label: "Pan mode", message: "username/password not configured" }
+          { status: :optional, label: "Pan mode", message: "not configured", optional: true }
         end
       end
 
@@ -140,6 +160,8 @@ module Kward
           colored("✓", :green, :bold)
         when :warning
           colored("!", :yellow, :bold)
+        when :optional
+          colored("•", :gray, :bold)
         else
           colored("✗", :red, :bold)
         end

data/lib/kward/cli/hook_commands.rb

@@ -9,7 +9,9 @@ module Kward
     module HookCommands
       private
 
-      def handle_hooks_command(argument)
+      def handle_hooks_command(argument, command_line: false)
+        previous_output_mode = @hook_command_line_output
+        @hook_command_line_output = command_line
         subcommand, rest = argument.to_s.strip.split(/\s+/, 2)
         subcommand = "list" if subcommand.to_s.empty?
 
@@ -27,8 +29,16 @@ module Kward
         when "untrust"
           untrust_workspace_hooks
         else
-          runtime_output("Usage: /hooks [list|events|logs|doctor|trust|untrust]")
+          raise ArgumentError, command_usage("hooks") if command_line
+
+          hook_command_output("Usage: /hooks [list|events|logs|doctor|trust|untrust]")
         end
+      ensure
+        @hook_command_line_output = previous_output_mode
+      end
+
+      def hook_command_output(text)
+        @hook_command_line_output ? @prompt.say(text) : runtime_output(text)
       end
 
       def print_hooks_list
@@ -46,7 +56,7 @@ module Kward
             lines << "- #{details.join(' ')}"
           end
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def print_hooks_events
@@ -57,7 +67,7 @@ module Kward
           suffix = fields.empty? ? "" : " modifies=#{fields.join(',')}"
           lines << "- #{event_name} failure_policy=#{Hooks::Catalog.failure_policy(event_name)}#{suffix}"
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def print_hooks_logs(argument)
@@ -65,7 +75,7 @@ module Kward
         count = 20 unless count.positive?
         path = hooks_log_path
         unless File.file?(path)
-          runtime_output("No lifecycle hook audit log found at #{path}.")
+          hook_command_output("No lifecycle hook audit log found at #{path}.")
           return
         end
 
@@ -75,7 +85,7 @@ module Kward
           nil
         end
         if records.empty?
-          runtime_output("No readable lifecycle hook audit records found at #{path}.")
+          hook_command_output("No readable lifecycle hook audit records found at #{path}.")
           return
         end
 
@@ -83,7 +93,7 @@ module Kward
         records.each do |record|
           lines << format_hook_log_record(record)
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def print_hooks_doctor
@@ -105,7 +115,7 @@ module Kward
         rescue StandardError => e
           lines << "Error: #{e.message}"
         end
-        runtime_output(lines.join("\n"))
+        hook_command_output(lines.join("\n"))
       end
 
       def configured_hook_entries
@@ -226,16 +236,16 @@ module Kward
 
       def trust_workspace_hooks
         ConfigFiles.trust_workspace_hooks!(current_workspace_root)
-        runtime_output("Trusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
+        hook_command_output("Trusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
       rescue StandardError => e
-        runtime_output("Workspace hook trust error: #{e.message}")
+        hook_command_output("Workspace hook trust error: #{e.message}")
       end
 
       def untrust_workspace_hooks
         ConfigFiles.untrust_workspace_hooks!(current_workspace_root)
-        runtime_output("Untrusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
+        hook_command_output("Untrusted workspace hooks: #{ConfigFiles.workspace_hooks_path(current_workspace_root)}")
       rescue StandardError => e
-        runtime_output("Workspace hook trust error: #{e.message}")
+        hook_command_output("Workspace hook trust error: #{e.message}")
       end
 
       def hooks_log_path

data/lib/kward/cli/interactive_turn.rb

@@ -47,9 +47,10 @@ module Kward
       def build_editor_prompt_agent(active_agent, context, registry)
         active_conversation = active_agent.conversation
         config = safely_read_config.to_h
-        provider = active_conversation.provider || current_model_provider
-        model = ConfigFiles.editor_agent_model(config) || active_conversation.model || current_model_id
-        reasoning = ConfigFiles.editor_agent_reasoning_effort(config) || active_conversation.reasoning_effort || current_reasoning_effort
+        configured_provider = ConfigFiles.editor_agent_provider(config)
+        provider = configured_provider || active_conversation.provider || current_model_provider
+        model = ConfigFiles.editor_agent_model(config) || (configured_provider ? nil : active_conversation.model || current_model_id)
+        reasoning = ConfigFiles.editor_agent_reasoning_effort(config) || (configured_provider ? nil : active_conversation.reasoning_effort || current_reasoning_effort)
         conversation = Conversation.new(
           system_message: EditorPrompt.system_message,
           workspace_root: context[:workspace_root] || active_conversation.workspace_root,
@@ -61,6 +62,7 @@ module Kward
           client: @client,
           tool_registry: registry,
           conversation: conversation,
+          strict_provider: !configured_provider.nil?,
           warning_sink: ConfigFiles.warning_sink
         )
       end
@@ -76,9 +78,11 @@ module Kward
         event_queue = Queue.new
         stream_state = {
           streamed: false,
+          assistant_arrived: false,
           last_flush: monotonic_now,
           stream_block_open: false,
           markdown_streams: {},
+          tool_elapsed_ms: {},
           defer_assistant_streaming: defer_assistant_streaming?(agent)
         }
         markdown_chunks = []
@@ -126,19 +130,29 @@ module Kward
         if busy_replacement_agent? || suppress_transcript
           discard_interactive_events(event_queue, markdown_chunks, stream_state, force: true)
         else
-          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+          drain_remaining_interactive_events(event_queue, markdown_chunks, stream_state, agent)
         end
         completed = !cancelled && !busy_replacement_agent? && !error
         on_complete&.call(successful: completed, cancelled: cancelled, error: error, answer: answer)
         raise error if error && !error.is_a?(Cancellation::CancelledError) && !busy_replacement_agent?
 
         @prompt.commit_editor_prompt(editor_prompt_session) if editor_prompt_session && completed
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
+        @prompt.say("\n#{colored(transcript_marker("Assistant"), :activity, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || cancelled || busy_replacement_agent? || stream_state[:streamed] || answer.to_s.empty?
         persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
         auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript && queued_inputs.empty? && !cancelled
         queued_inputs
       ensure
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+        if @prompt.respond_to?(:show_completion) && !busy_replacement_agent?
+          completion = if cancelled
+            :cancelled
+          elsif error
+            :failed
+          elsif completed
+            :success
+          end
+          @prompt.show_completion(completion) if completion
+        end
         if editor_prompt_session && @prompt.respond_to?(:resume_editor_for_agent)
           status = if cancelled
             "Agent request cancelled"
@@ -174,6 +188,14 @@ module Kward
         flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: force)
       end
 
+      def drain_remaining_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+        until event_queue.empty?
+          drain_interactive_events(event_queue, markdown_chunks, stream_state, agent)
+          sleep STREAM_RENDER_INTERVAL unless event_queue.empty?
+        end
+        drain_interactive_events(event_queue, markdown_chunks, stream_state, agent, force: true)
+      end
+
       def discard_interactive_events(event_queue, markdown_chunks, stream_state, force: false)
         drained = 0
         loop do
@@ -193,12 +215,19 @@ module Kward
         case event
         when Events::ReasoningDelta
           stream_state[:streamed] = true
+          update_busy_activity("reasoning")
           append_markdown_delta(markdown_chunks, "Reasoning", event.delta)
         when Events::ReasoningBoundary
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_busy_activity("thinking")
         when Events::AssistantDelta
           stream_state[:streamed] = true
+          unless stream_state[:assistant_arrived]
+            @prompt.show_response_arrival if @prompt.respond_to?(:show_response_arrival)
+            stream_state[:assistant_arrived] = true
+          end
+          update_busy_activity("responding")
           append_markdown_delta(markdown_chunks, "Assistant", event.delta)
         when Events::Steering
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
@@ -208,18 +237,30 @@ module Kward
         when Events::Retry
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_busy_activity("retrying")
           print_retry(event)
         when Events::ToolCall
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
+          update_busy_activity(tool_activity(event.tool_call))
+        when Events::ToolUpdate
+          key = tool_call_id(event.tool_call) || event.tool_call.object_id
+          stream_state[:tool_elapsed_ms][key] = event.elapsed_ms
         when Events::ToolResult
           stream_state[:streamed] = true
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
           update_session_diff(event.content, tool_call: event.tool_call)
-          print_tool_result(event.tool_call, event.content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
+          key = tool_call_id(event.tool_call) || event.tool_call.object_id
+          elapsed_ms = stream_state[:tool_elapsed_ms].delete(key)
+          print_tool_result(event.tool_call, event.content, line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT, elapsed_ms: elapsed_ms)
+          update_busy_activity("thinking")
         end
       end
 
+      def update_busy_activity(activity)
+        @prompt.update_busy_activity(activity) if @prompt.respond_to?(:update_busy_activity)
+      end
+
       def flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: false)
         if force
           finish_interactive_markdown_deltas(markdown_chunks, stream_state)
@@ -347,7 +388,7 @@ module Kward
           streamed = true if !suppress_transcript && render_blocking_turn_event(event, markdown_chunks, tool_line_limit: INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT)
         end
         flush_markdown_deltas(markdown_chunks) if streamed
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || streamed || answer.to_s.empty?
+        @prompt.say("\n#{colored(transcript_marker("Assistant"), :activity, :bold)} #{render_markdown_transcript(answer)}\n") unless suppress_transcript || streamed || answer.to_s.empty?
         persist_memory_state(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
         auto_summarize_memory(agent.conversation) if agent.respond_to?(:conversation) && !suppress_transcript
         on_complete&.call(successful: true, cancelled: false, error: nil, answer: answer)

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/project_skills_commands.rb

@@ -7,20 +7,20 @@ module Kward
         argument = Array(arguments).join(" ").strip.downcase
         _workspace_root, candidates, coordinator = project_skill_trust_coordinator
         if candidates.empty? && argument != "untrust"
-          @prompt.say("No project skills found in the current workspace.")
+          project_skills_cli_output("No project skills found in the current workspace.")
           return
         end
 
         case argument
         when "", "status"
           lines = candidates.empty? ? ["No project skills found in the current workspace."] : candidates.map { |candidate| "#{relative_workspace_path(candidate.path)}: #{coordinator.decision(candidate) || "needs review"}" }
-          @prompt.say(lines.join("\n"))
+          project_skills_cli_output(lines.join("\n"))
         when "trust"
           coordinator.record!(candidates, "allow")
-          @prompt.say("Project skills trusted for the current skill snapshots.")
+          project_skills_cli_output("Project skills trusted for the current skill snapshots.")
         when "untrust"
           coordinator.remove_workspace!
-          @prompt.say("Project skill trust removed for this workspace.")
+          project_skills_cli_output("Project skill trust removed for this workspace.")
         when "review"
           review_project_skills(candidates)
         else
@@ -43,6 +43,10 @@ module Kward
 
       private
 
+      def project_skills_cli_output(message)
+        @prompt.say("#{colored("Project skills", :green, :bold)}\n\n#{message}")
+      end
+
       def project_skill_trust_coordinator
         workspace_root = current_workspace_root
         candidates = ConfigFiles.project_skill_candidates(workspace_root: workspace_root)

data/lib/kward/cli/prompt_interface.rb

@@ -45,6 +45,7 @@ module Kward
           editor_line_numbers_source: -> { ConfigFiles.editor_line_numbers },
           diff_view: ConfigFiles.diff_view,
           diff_view_source: -> { ConfigFiles.diff_view },
+          editor_runners_source: -> { ConfigFiles.editor_runners },
           redraw_handler: method(:redraw_interactive_prompt)
         )
         if @prompt.method(:start).parameters.any? { |kind, name| [:key, :keyreq].include?(kind) && name == :render }
@@ -99,6 +100,13 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
+      def open_editor_for_agent(path, base_dir:, allow_new:)
+        return false unless prompt_interface?
+        return false unless @prompt.respond_to?(:edit_file)
+
+        @prompt.edit_file(path, base_dir: base_dir, allow_new: allow_new)
+      end
+
       def emit_warning(message)
         sink = ConfigFiles.warning_sink
         sink ? sink.call(message) : warn(message)
@@ -129,6 +137,7 @@ module Kward
         [
           startup_status_line(refresh_update_check: refresh_update_check),
           *startup_update_notice_lines,
+          *startup_authentication_notice_lines,
           "",
           startup_info_line("Workspace", startup_workspace_label),
           startup_info_line("Branch", startup_branch_value),
@@ -198,6 +207,24 @@ module Kward
         @startup_update_notice = @startup_update_check.notice(refresh: refresh)
       end
 
+      def startup_authentication_notice_lines
+        return [] unless startup_authentication_required?
+
+        [
+          ANSI.colorize("  No model provider is connected.", :yellow, enabled: @color_enabled),
+          "  Run /login to sign in, or /model to configure a local server."
+        ]
+      end
+
+      def startup_authentication_required?
+        return false unless @client.is_a?(Client)
+        return false if @client.current_provider == "Local"
+
+        auth_credentials.none? { |credential| credential.fetch(:configured) }
+      rescue StandardError
+        false
+      end
+
       def startup_info_line(label, value)
         "#{ANSI.colorize(label.ljust(12), :gray, enabled: @color_enabled)}#{ANSI.colorize(value, :cyan, enabled: @color_enabled)}"
       end
@@ -220,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}"
           ""
@@ -244,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)
@@ -252,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?