kward 0.83.0 → 0.85.0

data/lib/kward/cli/slash_commands.rb

@@ -1,3 +1,5 @@
+require_relative "../prompt_interface/editor/scratchpad_languages"
+
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line frontend that coordinates terminal interaction, sessions, tools, and model turns.
@@ -48,7 +50,7 @@ module Kward
           open_project_files_browser
           [true, nil]
         when "shell"
-          run_ekwsh(agent)
+          run_kwsh(agent)
           [true, nil]
         when "capture"
           run_captured_shell_command(argument, agent)
@@ -62,6 +64,9 @@ module Kward
           [true, nil]
         when "tab"
           [true, handle_tab_command(argument, session_store)]
+        when "name"
+          rename_active_session_and_tab(argument)
+          [true, nil]
         when "worktree"
           handle_worktree_command(argument)
           [true, active_tab&.agent]
@@ -79,7 +84,9 @@ module Kward
           configure_reasoning(agent.conversation)
           [true, nil]
         when "reload"
-          run_busy_local_command_and_requeue { reload_plugins(agent.conversation) }
+          strict_worktree = active_tab&.driver&.respond_to?(:worktree) && active_tab.driver.worktree&.active?
+          registry = strict_worktree ? nil : agent.tool_registry
+          run_busy_local_command_and_requeue { reload_plugins(agent.conversation, tool_registry: registry) }
           [true, nil]
         when "new"
           [true, run_busy_local_command_and_requeue { start_new_session(session_store) }]
@@ -111,7 +118,11 @@ module Kward
           run_busy_local_command_and_requeue { export_session(agent.conversation, argument) }
           [true, nil]
         when "compact"
-          run_busy_local_command_and_requeue(activity: "compacting") { compact_context(agent, argument) }
+          origin_tab = active_tab
+          result = run_busy_local_command_and_requeue(activity: "compacting") do |cancellation|
+            compact_context(agent, argument, cancellation: cancellation)
+          end
+          render_compaction_summary(result) if !origin_tab || origin_tab == active_tab
           [true, nil]
         else
           if name.to_s.start_with?("skill:")
@@ -120,7 +131,7 @@ module Kward
           elsif interactive_command_for(name) && prompt_interface? && @prompt.respond_to?(:start_interactive)
             run_interactive_command(name, argument, agent)
           elsif plugin_command_for(name)
-            run_busy_local_command_and_requeue(activity: "running") { run_plugin_command(name, argument, agent) }
+            run_plugin_command_and_turn(name, argument, agent)
           else
             [false, nil]
           end
@@ -131,6 +142,38 @@ module Kward
         PromptCommands.parse(command) || [nil, ""]
       end
 
+      def rename_active_session_and_tab(argument)
+        name = argument.to_s.strip
+        return runtime_output("Usage: /name <name>") if name.empty?
+
+        tab = active_tab
+        unless @active_session && (!tab || tab.session.equal?(@active_session))
+          return runtime_output("The /name command is only available in a session tab.")
+        end
+
+        errors = []
+        begin
+          rename_session(name, require_name: true, announce: false)
+        rescue StandardError => error
+          errors << "session: #{error.message}"
+        end
+
+        if tab
+          begin
+            rename_active_tab(name)
+          rescue StandardError => error
+            errors << "tab: #{error.message}"
+          end
+        end
+
+        if errors.empty?
+          label = tab ? "Named session and tab: #{name}" : "Named session: #{name}"
+          runtime_output(label)
+        else
+          runtime_output("Name update incomplete (#{errors.join("; ")}).")
+        end
+      end
+
       def handle_sandbox_command(argument, workspace_root)
         action, value = argument.to_s.strip.split(/\s+/, 2)
         case action
@@ -304,11 +347,16 @@ module Kward
       end
 
       def open_scratchpad_command(argument)
-        if @prompt.respond_to?(:scratchpad)
-          @prompt.scratchpad(scratchpad_language_argument(argument))
-        else
-          runtime_output("The scratchpad is only available in the interactive prompt.")
+        unless @prompt.respond_to?(:scratchpad)
+          return runtime_output("The scratchpad is only available in the interactive prompt.")
         end
+
+        value = argument.to_s.strip
+        return runtime_output(ScratchpadLanguages.help_text) if value.casecmp("help").zero?
+
+        @prompt.scratchpad(ScratchpadLanguages.normalize(value))
+      rescue ArgumentError => e
+        runtime_output(e.message)
       end
 
       def queue_editor_prompt_action(result)
@@ -318,15 +366,6 @@ module Kward
         @pending_inputs.unshift(result)
       end
 
-      def scratchpad_language_argument(argument)
-        value = argument.to_s.strip.downcase
-        return :text if value.empty? || value == "text"
-        return :markdown if ["markdown", "md"].include?(value)
-        return :ruby if ["ruby", "rb"].include?(value)
-
-        :text
-      end
-
       def open_project_files_browser
         if @prompt.respond_to?(:open_project_browser)
           @prompt.open_project_browser

data/lib/kward/cli/tabs.rb

@@ -1,4 +1,5 @@
 require "json"
+require "securerandom"
 require "thread"
 require_relative "../cancellation"
 
@@ -10,14 +11,16 @@ module Kward
     module Tabs
       WORKTREE_AGENT_CONTEXT = <<~PROMPT.strip.freeze
         This is an active Git worktree tab. The workspace is sandboxed separately from the host repository metadata.
-        When the user explicitly asks you to commit, use the advertised `git_commit` tool. Do not use `run_shell_command` for `git add` or `git commit`, because shared Git metadata is intentionally protected there.
-        `git_commit` requires a commit message and accepts optional workspace-relative paths; omit paths to include all current changes in this worktree. Do not create a commit unless the user requested one.
+        Workspace tools default to the active worktree. When they advertise `target`, use `target: "origin"` to inspect the verified host repository worktree without leaving this tab. Read the origin's applicable `AGENTS.md` before changing it.
+        When the user explicitly asks you to commit, use the advertised `git_commit` tool. Set `target: "origin"` only when the user asks to commit there. Do not use `run_shell_command` for `git add` or `git commit`, because shared Git metadata is intentionally protected.
+        `git_commit` requires a commit message and accepts optional target-relative paths; omit paths to include all current changes in the selected worktree. Do not create a commit unless the user requested one.
       PROMPT
 
       TabRuntime = Struct.new(
         :session,
         :agent,
         :driver,
+        :plugin_host,
         :diff,
         :snapshot,
         :status,
@@ -33,12 +36,15 @@ module Kward
         :markdown_chunks,
         :label,
         :unread,
+        :attention,
         :pending_question,
         :shell,
         :shell_agent,
+        :background_run,
         :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
+        :pending_runtime_outputs,
         keyword_init: true
       ) do
         TRANSIENT_SHELL_OUTPUT_LIMIT = 200_000
@@ -51,6 +57,11 @@ module Kward
           !local_busy_activity.to_s.empty?
         end
 
+        def append_pending_runtime_output(text)
+          self.pending_runtime_outputs ||= []
+          pending_runtime_outputs << text.to_s
+        end
+
         def idle?
           !running? && !local_busy?
         end
@@ -106,6 +117,10 @@ module Kward
           @cli.send(:ask_tab_user_question, @tab, questions, cancellation: cancellation)
         end
 
+        def edit_file(path, base_dir:, allow_new:)
+          @cli.send(:open_editor_for_agent, path, base_dir: base_dir, allow_new: allow_new)
+        end
+
         def ask_tool_approval(tool_name:, args:, reason: nil)
           answers = ask_user_question([
             {
@@ -199,14 +214,23 @@ module Kward
         end
 
         tab_type = plugin_registry.tab_type_for_id(descriptor["plugin_tab_type"])
+        host = nil
         driver = if tab_type&.local
-          host = PluginTabHost.new(client: @client, workspace_root: session_store.cwd)
-          tab_type.handler.call(host, descriptor)
+          descriptor["scope_key"] ||= plugin_tab_scope_key(tab_type)
+          host = build_plugin_tab_host(tab_type, workspace_root: session_store.cwd, scope_key: descriptor["scope_key"])
+          begin
+            created_driver = tab_type.handler.call(host, descriptor)
+            raise "Plugin tab #{descriptor["plugin_tab_type"].inspect} did not return a tab driver." unless created_driver
+
+            tab_type.capabilities.validate_driver!(created_driver)
+          rescue StandardError
+            host.shutdown
+            raise
+          end
         else
           UnavailableTabDriver.new(descriptor: descriptor, message: "Plugin tab #{descriptor["plugin_tab_type"].inspect} is unavailable.")
         end
-        raise "Plugin tab #{descriptor["plugin_tab_type"].inspect} did not return a tab driver." unless driver
-        build_tab(nil, nil, driver: driver, label: label || descriptor["label"] || tab_type&.title)
+        build_tab(nil, nil, driver: driver, plugin_host: host, label: label || descriptor["label"] || tab_type&.title)
       end
 
       def open_plugin_tab(name, session_store)
@@ -219,12 +243,20 @@ module Kward
 
         save_active_tab_state
         stop_tab_live_view
-        descriptor = { "kind" => "plugin", "plugin_tab_type" => tab_type.id, "label" => tab_type.title }
-        host = PluginTabHost.new(client: @client, workspace_root: session_store.cwd)
-        driver = tab_type.handler.call(host, descriptor)
-        raise "Plugin tab #{name.inspect} did not return a tab driver." unless driver
+        scope_key = plugin_tab_scope_key(tab_type)
+        descriptor = { "kind" => "plugin", "plugin_tab_type" => tab_type.id, "label" => tab_type.title, "scope_key" => scope_key }
+        host = build_plugin_tab_host(tab_type, workspace_root: session_store.cwd, scope_key: scope_key)
+        begin
+          driver = tab_type.handler.call(host, descriptor)
+          raise "Plugin tab #{name.inspect} did not return a tab driver." unless driver
+
+          tab_type.capabilities.validate_driver!(driver)
+        rescue StandardError
+          host.shutdown
+          raise
+        end
 
-        @tabs << build_tab(nil, nil, driver: driver, label: tab_type.title)
+        @tabs << build_tab(nil, nil, driver: driver, plugin_host: host, label: tab_type.title)
         @active_tab_index = @tabs.length - 1
         activate_tab(@active_tab_index)
       rescue StandardError => e
@@ -248,21 +280,30 @@ module Kward
         strict = worktree&.active? == true
         update_worktree_agent_context(conversation, strict)
         workspace = configured_workspace(root: conversation.workspace_root, strict: strict)
+        workspace_targets = if strict
+                              origin_workspace = configured_workspace(root: worktree.origin_root, strict: true)
+                              Tools::WorkspaceTargets.new(active: workspace, targets: { origin: origin_workspace })
+                            end
         prompt = TabQuestionPrompt.new(self)
         hook_manager = strict ? nil : lifecycle_hook_manager(conversation)
         hook_context = strict ? nil : lifecycle_hook_context(conversation)
         git_committer = if strict
-                          ->(message:, paths:) { git_commit_for_agent(workspace.root.to_s, message: message, paths: paths) }
+                          lambda do |message:, paths:, target: Tools::WorkspaceTargets::ACTIVE|
+                            commit_workspace = target == "origin" ? worktree.origin_root : workspace.root.to_s
+                            git_commit_for_agent(commit_workspace, message: message, paths: paths)
+                          end
                         end
         project_skill_paths = project_skill_paths_for(conversation.workspace_root) || []
         tool_registry = ToolRegistry.new(
           workspace: workspace,
+          workspace_targets: workspace_targets,
           prompt: prompt,
           skills: ConfigFiles.skills(workspace_root: conversation.workspace_root, project_skill_paths: project_skill_paths),
           tool_approval: tab_tool_approval_callback(prompt),
           hook_manager: hook_manager,
           hook_context: hook_context,
           mcp_clients: strict ? [] : nil,
+          plugin_tools: strict ? [] : plugin_registry.tools,
           git_committer: git_committer
         )
         @footer_conversation = conversation
@@ -295,12 +336,13 @@ module Kward
         end
       end
 
-      def build_tab(session, agent, driver: nil, label: nil)
+      def build_tab(session, agent, driver: nil, plugin_host: nil, label: nil)
         driver ||= SessionTabDriver.new(session: session, agent: agent)
         TabRuntime.new(
           session: session,
           agent: agent,
           driver: driver,
+          plugin_host: plugin_host,
           diff: session&.path ? SessionDiff.from_session_file(session.path) : SessionDiff.new,
           snapshot: nil,
           status: "idle",
@@ -316,12 +358,15 @@ module Kward
           markdown_chunks: [],
           label: label,
           unread: false,
+          attention: nil,
           pending_question: nil,
           shell: nil,
           shell_agent: nil,
+          background_run: nil,
           transient_shell_entries: [],
           error_reported: false,
-          local_busy_activity: nil
+          local_busy_activity: nil,
+          pending_runtime_outputs: []
         ).tap { |tab| assign_tab_question_prompt(agent, tab) }
       end
 
@@ -420,16 +465,17 @@ module Kward
         end
 
         if @tabs.length <= 1
-          close_ekwsh_session(tab.shell) if tab&.shell && respond_to?(:close_ekwsh_session, true)
+          close_kwsh_session(tab.shell) if tab&.shell && respond_to?(:close_kwsh_session, true)
+          close_plugin_tab(tab)
           @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)
+        close_kwsh_session(tab.shell) if tab&.shell && respond_to?(:close_kwsh_session, true)
         tab.session&.delete_if_unused if tab&.session.respond_to?(:delete_if_unused)
-        tab.driver.close if tab.driver.respond_to?(:close)
+        close_plugin_tab(tab)
         @tabs.delete_at(@active_tab_index)
         @active_tab_index = [@active_tab_index, @tabs.length - 1].min
         activate_tab(@active_tab_index)
@@ -461,12 +507,13 @@ module Kward
         tab.error = nil
         tab.answer = nil
         tab.unread = false
+        tab.attention = nil
         tab.error_reported = false
         tab.event_history.clear
         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)
+        close_kwsh_session(tab.shell) if tab.shell && respond_to?(:close_kwsh_session, true)
         tab.shell = nil
         tab.shell_agent = nil
         tab.clear_transient_shell_entries
@@ -501,6 +548,7 @@ module Kward
       end
 
       def activate_tab(index, render: true)
+        service_background_tab_runs
         tab = @tabs[index]
         return nil unless tab
 
@@ -517,6 +565,7 @@ module Kward
           @prompt.update_assistant_label(assistant_prompt_name) if @prompt.respond_to?(:update_assistant_label)
         end
         tab.unread = false
+        tab.attention = nil
         restore_tab_composer_snapshot(tab.snapshot)
         update_prompt_workspace_root(current_workspace_root)
         @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
@@ -544,8 +593,23 @@ module Kward
           end
           report_tab_runtime_error(tab) if %w[failed cancelled].include?(tab.status.to_s)
           render_tab_transient_shell_entries(tab)
+          render_background_tab_output(tab)
         end
         restore_tab_composer_snapshot(tab.snapshot) if restore_composer
+        render_pending_tab_runtime_outputs(tab)
+      end
+
+      def render_pending_tab_runtime_outputs(tab)
+        outputs = Array(tab.pending_runtime_outputs)
+        tab.pending_runtime_outputs = []
+        outputs.each { |output| runtime_output(output) }
+      end
+
+      def flush_pending_runtime_outputs(tab)
+        return false unless tab && tab == active_tab
+
+        render_pending_tab_runtime_outputs(tab)
+        true
       end
 
       def render_tab_transient_shell_entries(tab)
@@ -558,6 +622,17 @@ module Kward
         end
       end
 
+      def render_background_tab_output(tab)
+        output = tab.background_run&.fetch(:rendered_output, "").to_s
+        return if output.empty?
+
+        if @prompt.respond_to?(:say)
+          @prompt.say(output)
+        elsif @prompt.respond_to?(:write_transcript)
+          @prompt.write_transcript(output)
+        end
+      end
+
       def clear_active_tab_transient_shell_entries
         active_tab&.clear_transient_shell_entries
       end
@@ -603,21 +678,92 @@ module Kward
         index ? index + 1 : active_tab_number
       end
 
+      def register_background_tab_run(tab, run, output_kind: nil, &completion)
+        return unless tab && run
+
+        tab.background_run = {
+          run: run,
+          completion: completion,
+          output_kind: output_kind,
+          rendered_output: +""
+        }
+        tab.local_busy_activity = "running"
+        tab.attention = nil
+        update_prompt_tabs
+      end
+
+      def service_background_tab_runs
+        return unless @tabs
+
+        @tabs.each do |tab|
+          state = tab.background_run
+          next unless state
+
+          complete = state[:run].complete?
+          result = state[:run].result if complete
+          if state[:output_kind] && respond_to?(:flush_background_tab_output, true)
+            flush_background_tab_output(tab, state, result: result)
+          end
+          next unless complete
+
+          state[:completion]&.call(state[:run].sink, result, state) if result.is_a?(Struct)
+          rendered_output = state[:rendered_output].to_s
+          tab.append_transient_shell_entry(rendered_output) unless rendered_output.empty?
+          tab.background_run = nil
+          finish_local_busy_command_for_tab(tab)
+          if tab != active_tab
+            tab.unread = true
+            tab.attention = :success
+          end
+        rescue StandardError => e
+          tab.background_run = nil
+          tab.error = e.message
+          finish_local_busy_command_for_tab(tab)
+          tab.attention = :failure if tab != active_tab
+        end
+        update_prompt_tabs
+      end
+
+      def finish_local_busy_command_for_tab(tab)
+        tab.local_busy_activity = nil
+        @prompt.finish_busy_input if prompt_interface? && tab == active_tab && @prompt.respond_to?(:finish_busy_input)
+      end
+
       def submit_tab_input(tab, input, display_input: nil)
         return if input.to_s.strip.empty?
+        return unless plugin_tab_attachments_allowed?(tab, input)
 
         save_active_tab_state
         start_tab_turn(tab, input, display_input: display_input)
         start_tab_live_view(tab) if tab == active_tab
       end
 
+      def plugin_tab_attachments_allowed?(tab, input)
+        capabilities = tab.plugin_host&.capabilities
+        return true unless capabilities&.declared?
+        return true if capabilities.allows_attachment?(:image)
+
+        attached = ImageAttachments.references_from_text(input.to_s).any? { |reference| reference[:status] == :attached }
+        return true unless attached
+
+        runtime_output("This plugin chat does not allow image attachments.")
+        false
+      end
+
       def start_tab_turn(tab, input, display_input: nil)
         prepare_memory_context(tab.agent.conversation, input) if tab.agent.respond_to?(:conversation)
-        print_user_transcript(input, display_input: display_input) if prompt_interface?
+        print_user_transcript(input, display_input: display_input) if prompt_interface? && tab == active_tab
         tab.status = "queued"
         tab.unread = false
+        tab.attention = nil
         tab.cancellation = Cancellation.new
-        tab.steering = tab.driver.supports_steering? && steering_supported? ? Steering.new : nil
+        steering_capability = tab.plugin_host&.capabilities
+        driver_supports_steering = if steering_capability&.declared?
+          steering_capability.steering?
+        else
+          tab.driver.supports_steering?
+        end
+        tab.steering = driver_supports_steering && steering_supported? ? Steering.new : nil
         tab.error = nil
         tab.answer = nil
         tab.error_reported = false
@@ -639,14 +785,17 @@ module Kward
         end
         tab.status = "ready"
         tab.unread = tab != active_tab
+        tab.attention = :output if tab != active_tab
       rescue Cancellation::CancelledError
         tab.status = "cancelled"
         tab.unread = false
+        tab.attention = :failure if tab != active_tab
         report_tab_runtime_error(tab)
       rescue StandardError => e
         tab.error = e.message
         tab.status = "failed"
         tab.unread = false
+        tab.attention = :failure if tab != active_tab
         report_tab_runtime_error(tab)
       ensure
         finish_tab_turn(tab)
@@ -662,8 +811,9 @@ module Kward
       end
 
       def poll_active_tab_input
+        service_background_tab_runs
         tab = active_tab
-        unless tab&.running?
+        unless tab&.running? || tab&.local_busy?
           input = @prompt.ask("You>")
           return { tab_action: :close } if input.nil? && tab && @tabs.length > 1
 
@@ -672,6 +822,7 @@ module Kward
 
         @prompt.begin_busy_input("You>") if @prompt.respond_to?(:begin_busy_input)
         loop do
+          service_background_tab_runs
           refresh_active_tab
           if service_active_tab_question
             return next_tab_queued_input(tab) if tab.idle? && !tab.queued_inputs.empty?
@@ -679,6 +830,10 @@ module Kward
 
             next
           end
+          if @prompt.respond_to?(:modal_active?) && @prompt.modal_active?
+            sleep 0.01
+            next
+          end
           poll_result = @prompt.poll_input
           case poll_result
           when Hash
@@ -687,8 +842,12 @@ module Kward
               return poll_result
             end
           when PromptInterface::CANCEL_INPUT
-            tab.cancellation&.cancel!
-            tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
+            if tab.background_run
+              tab.background_run[:run].cancel!
+            else
+              tab.cancellation&.cancel!
+              tab.thread&.raise(Cancellation::CancelledError, "cancelled") if tab.thread&.alive?
+            end
           when PromptInterface::EXIT_INPUT
             tab.queued_inputs << "/exit"
             @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
@@ -716,8 +875,12 @@ module Kward
           tab.queued_inputs << input
           @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
           return
-        elsif busy_tab_command?(input)
-          handle_tab_command(input.to_s.strip.sub(%r{\A/tab(?:\s+|\z)}, ""), @session_store)
+        elsif busy_tab_command?(input) || busy_name_command?(input)
+          if busy_tab_command?(input)
+            handle_tab_command(input.to_s.strip.sub(%r{\A/tab(?:\s+|\z)}, ""), @session_store)
+          else
+            handle_local_slash_command(input, tab.agent, @session_store)
+          end
           unless active_tab.equal?(tab)
             @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
             return :active_tab_changed
@@ -749,6 +912,10 @@ module Kward
         input.to_s.strip.match?(%r{\A/tab(?:\s|\z)})
       end
 
+      def busy_name_command?(input)
+        input.to_s.strip.match?(%r{\A/name(?:\s|\z)})
+      end
+
       def refresh_active_tab
         tab = active_tab
         return unless tab&.thread && !tab.thread.alive? && tab.running?
@@ -830,15 +997,17 @@ module Kward
         return if tab.stream_state[:streamed]
         return if tab.answer.to_s.empty?
 
-        @prompt.say("\n#{colored(assistant_output_prompt, :green, :bold)} #{render_markdown_transcript(tab.answer)}\n")
+        @prompt.say("\n#{colored(transcript_marker("Assistant"), :activity, :bold)} #{render_markdown_transcript(tab.answer)}\n")
       end
 
       def new_tab_stream_state(driver)
         {
           streamed: false,
+          assistant_arrived: false,
           last_flush: monotonic_now,
           stream_block_open: false,
           markdown_streams: {},
+          tool_elapsed_ms: {},
           defer_assistant_streaming: driver.respond_to?(:conversation) && defer_assistant_streaming?(driver.agent)
         }
       end
@@ -853,10 +1022,11 @@ module Kward
       end
 
       def tab_label_color(tab)
-        return :green if tab.status.to_s == "waiting_for_question"
-        return :yellow if tab.running? || tab.local_busy?
-        return :red if %w[failed cancelled].include?(tab.status.to_s)
-        return :green if tab.unread
+        return :success if tab.status.to_s == "waiting_for_question"
+        return :caution if tab.running? || tab.local_busy?
+        return :failure if %w[failed cancelled].include?(tab.status.to_s) || tab.attention == :failure
+        return :success if tab.attention == :success
+        return :success if tab.unread
 
         nil
       end
@@ -906,7 +1076,7 @@ module Kward
       end
 
       def tab_usage
-        "/tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label> | /tab worktree [activate|detach|status|merge|merge abort|remove]"
+        "/tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label> | /tab worktree [activate|detach|status|merge [resolve|continue|abort]|remove]"
       end
 
       def switch_tab_number(number)
@@ -970,17 +1140,58 @@ module Kward
             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)
+          if (background_run = tab.background_run&.fetch(:run))
+            background_run.cancel!
+            background_run.join(0.5)
+          end
+          tab.background_run = nil
+          close_kwsh_session(tab.shell) if tab&.shell && respond_to?(:close_kwsh_session, true)
+          close_plugin_tab(tab)
         rescue StandardError
           nil
         end
       end
 
+      def build_plugin_tab_host(tab_type, workspace_root:, scope_key:)
+        PluginTabHost.new(
+          client: @client,
+          workspace_root: workspace_root,
+          plugin_host: tab_type.plugin_id && plugin_registry.plugin_for(tab_type.plugin_id),
+          type_id: tab_type.id,
+          surface: :local,
+          scope_key: scope_key,
+          capabilities: tab_type.capabilities
+        )
+      end
+
+      def plugin_tab_scope_key(tab_type)
+        tab_type.singleton == :global ? "global" : SecureRandom.uuid
+      end
+
+      def close_plugin_tab(tab)
+        return unless tab&.plugin_host
+
+        if tab.driver.respond_to?(:close)
+          tab.driver.close
+        elsif tab.driver.respond_to?(:shutdown)
+          tab.driver.shutdown
+        end
+      rescue StandardError => e
+        runtime_output("Plugin tab cleanup error: #{e.message}")
+      ensure
+        tab&.plugin_host&.shutdown
+        tab.plugin_host = nil if tab
+      end
+
       def persist_tabs
         return unless @tab_store
 
         @tab_store.save(
-          tabs: @tabs.map { |tab| tab.driver.descriptor.merge("label" => tab.label.to_s) },
+          tabs: @tabs.map do |tab|
+            descriptor = tab.driver.descriptor.merge("label" => tab.label.to_s)
+            descriptor["scope_key"] ||= tab.plugin_host.scope_key if tab.plugin_host
+            descriptor
+          end,
           active_index: @active_tab_index
         )
       end