kward 0.79.0 → 0.80.0

data/lib/kward/cli/commands.rb

@@ -59,6 +59,7 @@ module Kward
             #{command.call("kward openrouter refresh")}           Refresh cached OpenRouter models
             #{command.call("kward pan")}                          Start Pan mode web UI
             #{command.call("kward rpc")}                          Start the JSON-RPC backend
+            #{command.call("kward transport")}                    Manage transport plugins
 
           #{heading.call("Commands")}
             #{command.call("help")}                               Show this help
@@ -74,6 +75,7 @@ module Kward
             #{command.call("openrouter refresh|list")}             Refresh or list cached OpenRouter models
             #{command.call("pan")}                                Start Pan mode web UI
             #{command.call("rpc")}                                Run the JSON-RPC backend for UI clients
+            #{command.call("transport list|status|run")}            Manage transport plugins
 
           #{heading.call("Options")}
             #{option.call("--working-directory=PATH")}             Run Kward from PATH
@@ -163,6 +165,11 @@ module Kward
             usage: "kward rpc",
             description: "Start the JSON-RPC backend for trusted local UI clients.",
             examples: ["kward rpc", "kward --working-directory ~/code/project rpc"]
+          },
+          "transport" => {
+            usage: "kward transport list|status [NAME]|run NAME [WORKSPACE]",
+            description: "Inspect or run trusted external transport plugins.",
+            examples: ["kward transport list", "kward transport status", "kward transport run telegram", "kward transport run telegram ~/code/project"]
           }
         }
       end

data/lib/kward/cli/git.rb

@@ -1,4 +1,5 @@
 require "open3"
+require "pathname"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -131,20 +132,40 @@ module Kward
         { path: path, staged: status[0] != " " && status[0] != "?", untracked: status == "??" }
       end
 
-      def git_commit(root, message)
-        before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
-        return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+      def git_commit_for_agent(root, message:, paths: nil)
+        git_commit(root, message, paths: paths, stage_all: true, run_hooks: false)
+      end
+
+      def git_commit(root, message, paths: nil, stage_all: false, run_hooks: true)
+        if run_hooks
+          before = git_lifecycle_hook("git_commit_before", root: root, payload: { message: message.to_s })
+          return { success: false, output: "Declined: #{before.decision.message || "git commit denied"}" } if before.denied? || before.approval_required?
+        end
 
-        return git_commit_staged(root, message) if git_staged_changes?(root)
+        return git_commit_staged(root, message, run_hooks: run_hooks) if !stage_all && paths.nil? && git_staged_changes?(root)
 
-        add_output, add_status = Open3.capture2e("git", "add", "--all", chdir: root.to_s)
+        add_arguments = ["git", "add", "--all"]
+        add_arguments.concat(["--", *validated_git_commit_paths(root, paths)]) if paths
+        add_output, add_status = Open3.capture2e(*add_arguments, chdir: root.to_s)
         return { success: false, output: add_output } unless add_status.success?
 
-        git_commit_staged(root, message)
+        git_commit_staged(root, message, run_hooks: run_hooks)
       rescue StandardError => e
         { success: false, output: e.message }
       end
 
+      def validated_git_commit_paths(root, paths)
+        Array(paths).map do |path|
+          value = path.to_s
+          expanded = File.expand_path(value, root.to_s)
+          unless !value.empty? && !Pathname.new(value).absolute? && (expanded == root.to_s || expanded.start_with?("#{root}/"))
+            raise ArgumentError, "Git commit path must be workspace-relative: #{value}"
+          end
+
+          value
+        end
+      end
+
       def git_staged_changes?(root)
         _output, status = Open3.capture2e("git", "diff", "--cached", "--quiet", chdir: root.to_s)
         !status.success?
@@ -152,10 +173,12 @@ module Kward
         false
       end
 
-      def git_commit_staged(root, message)
+      def git_commit_staged(root, message, run_hooks: true)
         commit_output, commit_status = Open3.capture2e("git", "commit", "-m", message.to_s, chdir: root.to_s)
         result = { success: commit_status.success?, output: commit_output }
-        git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        if run_hooks
+          git_lifecycle_hook("git_commit_after", root: root, payload: { message: message.to_s, success: result[:success], output: result[:output] })
+        end
         result
       rescue StandardError => e
         { success: false, output: e.message }

data/lib/kward/cli/plugins.rb

@@ -31,6 +31,7 @@ module Kward
       end
 
       def reload_plugins(conversation)
+        @prompt_templates = nil
         @plugin_registry = PluginRegistry.load(reserved_commands: reserved_slash_command_names)
         @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=)

data/lib/kward/cli/prompt_interface.rb

@@ -27,6 +27,7 @@ module Kward
           banner_message: Kward::PromptInterface::BANNER_MESSAGE,
           tab_keybindings: ConfigFiles.composer_tab_keybindings,
           prompt_history: PromptHistory.new(cwd: current_workspace_root),
+          workspace_root: current_workspace_root,
           editor_mode: ConfigFiles.editor_mode,
           editor_mode_source: -> { ConfigFiles.editor_mode },
           editor_auto_indent: ConfigFiles.editor_auto_indent?,
@@ -67,6 +68,12 @@ module Kward
         @prompt.respond_to?(:start_stream_block) && @prompt.respond_to?(:write_delta)
       end
 
+      def update_prompt_workspace_root(root)
+        return unless @prompt.respond_to?(:update_workspace_root)
+
+        @prompt.update_workspace_root(root, prompt_history: PromptHistory.new(cwd: root))
+      end
+
       # Writes the startup info screen output for the terminal CLI flow.
       def print_visual_banner
         return unless @prompt.respond_to?(:print_visual_banner)

data/lib/kward/cli/rendering.rb

@@ -272,8 +272,12 @@ module Kward
       # Writes the block delta output for the terminal CLI flow.
       def print_block_delta(label, delta)
         if prompt_interface?
-          @prompt.start_stream_block(label)
-          @prompt.write_delta(delta)
+          if @prompt.respond_to?(:write_stream_block)
+            @prompt.write_stream_block(label, delta, finish: false)
+          else
+            @prompt.start_stream_block(label)
+            @prompt.write_delta(delta)
+          end
         else
           start_stream_block(label)
           print delta

data/lib/kward/cli/runtime_helpers.rb

@@ -317,8 +317,8 @@ module Kward
         @pending_inputs&.first.is_a?(Hash) && @pending_inputs.first[:tab_action]
       end
 
-      def configured_workspace(root: current_workspace_root)
-        WorkspaceFactory.build(root: root, guardrails: workspace_guardrails_enabled?, config: safely_read_config.to_h)
+      def configured_workspace(root: current_workspace_root, strict: false)
+        WorkspaceFactory.build(root: root, guardrails: workspace_guardrails_enabled?, config: safely_read_config.to_h, strict: strict)
       end
 
       def workspace_guardrails_enabled?
@@ -401,6 +401,8 @@ module Kward
       end
 
       def current_workspace_root
+        conversation = active_tab&.agent&.conversation if respond_to?(:active_tab, true)
+        return conversation.workspace_root if conversation&.respond_to?(:workspace_root)
         return @active_session.cwd.to_s unless @active_session&.cwd.to_s.empty?
         return @working_directory if @working_directory
 

data/lib/kward/cli/sessions.rb

@@ -103,7 +103,7 @@ module Kward
         @active_session = track_session(session_store.create)
         reset_session_diff
         cleanup_replaced_session(previous_session)
-        conversation = new_conversation(workspace_root: session_store.cwd)
+        conversation = new_conversation(workspace_root: current_workspace_root)
         @active_session.attach(conversation)
         run_lifecycle_hook("session_create", conversation: conversation, payload: { action: "create" })
         update_assistant_prompt(conversation)

data/lib/kward/cli/settings.rb

@@ -120,7 +120,10 @@ module Kward
 
       def provider_choices
         current = current_model_provider
-        ["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"].map do |provider|
+        configured_api_key_providers = ProviderCatalog.api_key_providers.filter_map do |provider|
+          provider.name if api_key_store.configured?(provider.id)
+        end
+        (["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"] + configured_api_key_providers).uniq.map do |provider|
           label = provider.dup
           label += " (current)" if provider == current
           label
@@ -135,7 +138,7 @@ module Kward
         return "Copilot" if text.start_with?("copilot")
         return "Local" if text.start_with?("local")
 
-        nil
+        ProviderCatalog.find_by_name(selected)&.name
       end
 
       def configure_local_server_preset(conversation)
@@ -721,12 +724,15 @@ module Kward
           return
         end
 
-        selected = @prompt.select("OAuth provider", login_provider_choices, title: "Login")
+        method = selected_login_method(@prompt.select("How would you like to connect?", login_method_choices, title: "Login"))
+        return unless method
+
+        selected = @prompt.select(login_provider_prompt(method), login_provider_choices(method), title: "Login")
         provider = selected_login_provider(selected)
         return unless provider
 
         run_busy_local_command_and_requeue(activity: "running") do
-          login(provider: provider)
+          login(provider: provider, auth_method: method)
           reload_client_config
         end
       rescue StandardError => e
@@ -740,17 +746,40 @@ module Kward
         end
 
         models ||= normalized_available_models(conversation)
-        choices = model_choices(models, conversation)
-        selected = @prompt.select("Default model", choices, title: "Models", custom: true)
-        return unless selected
-
-        provider, model = selected_model(selected, models)
-        raise "Model must be a non-empty string" if model.to_s.strip.empty?
-
-        ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
-        reload_client_config
-        refresh_conversation_runtime(conversation)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
+        provider_filter = nil
+        show_all = false
+        loop do
+          visible_models = provider_filter ? models.select { |model| model[:provider] == provider_filter } : models
+          visible_models = visible_models.select { |model| default_selectable_model?(model) } unless show_all
+          actions = ["Refresh model list", "Enter model ID manually", "Show all models", "Change provider"]
+          selected = @prompt.select("Default model", model_choices(visible_models, conversation) + actions, title: "Models", custom: true)
+          return unless selected
+
+          case selected.to_s
+          when "Refresh model list"
+            refreshed = @client.refresh_available_models(provider: provider_filter) if @client.respond_to?(:refresh_available_models)
+            models = normalized_available_models(conversation, models: refreshed)
+          when "Enter model ID manually"
+            provider = provider_filter || conversation&.provider || current_model_provider
+            model = @prompt.select("Model ID for #{provider}", [], title: "Models", custom: true)
+            return unless model
+            persist_model_selection(provider, model, conversation)
+            return
+          when "Show all models"
+            provider_filter = nil
+            show_all = true
+          when "Change provider"
+            selected_provider_name = selected_provider(@prompt.select("Provider", provider_choices, title: "Models"))
+            if selected_provider_name
+              provider_filter = selected_provider_name
+              show_all = false
+            end
+          else
+            provider, model = selected_model(selected, models)
+            persist_model_selection(provider, model, conversation)
+            return
+          end
+        end
       rescue StandardError => e
         runtime_output("Model error: #{e.message}")
       end
@@ -784,23 +813,38 @@ module Kward
         @prompt.respond_to?(:select)
       end
 
-      def login_provider_choices
-        ["OpenAI", "Anthropic", "OpenRouter", "GitHub"]
+      def login_method_choices
+        ["API key", "Subscription / OAuth"]
       end
 
-      def selected_login_provider(selected)
+      def selected_login_method(selected)
         case selected.to_s.downcase
-        when /\Aopenai\b/
-          "openai"
-        when /\Aanthropic\b/, /\Aclaude\b/
-          "anthropic"
-        when /\Aopenrouter\b/
-          "openrouter"
-        when /\Agithub\b/
-          "github"
+        when /\Aapi key\z/ then :api_key
+        when /\Asubscription \/ oauth\z/ then :oauth
+        end
+      end
+
+      def login_provider_prompt(method)
+        method == :api_key ? "Add an API key" : "Sign in with a subscription"
+      end
+
+      def login_provider_choices(method)
+        if method == :api_key
+          ProviderCatalog.api_key_providers.map(&:name)
+        else
+          ["Anthropic Claude", "ChatGPT", "GitHub Copilot"]
         end
       end
 
+      def selected_login_provider(selected)
+        value = selected.to_s.downcase
+        return "openai" if value == "openai" || value == "chatgpt"
+        return "anthropic" if value == "anthropic" || value == "anthropic claude"
+        return "copilot" if value == "github copilot"
+
+        ProviderCatalog.find_by_name(selected)&.id
+      end
+
       def model_overlay_available?
         @prompt.respond_to?(:select)
       end
@@ -822,11 +866,11 @@ module Kward
         values.find { |value| choice.to_s.downcase.start_with?(value) }
       end
 
-      def normalized_available_models(conversation = current_footer_conversation)
+      def normalized_available_models(conversation = current_footer_conversation, models: nil)
         current_provider = conversation.provider || (@client.respond_to?(:current_provider) ? @client.current_provider : "Codex")
         current_model = conversation.model || (@client.respond_to?(:current_model) ? @client.current_model : nil)
         current_reasoning = conversation.reasoning_effort || (@client.respond_to?(:current_reasoning_effort) ? @client.current_reasoning_effort : nil)
-        models = @client.respond_to?(:available_models) ? @client.available_models : []
+        models ||= @client.respond_to?(:available_models) ? @client.available_models : []
         ModelInfo.normalize_available(
           models,
           current_provider: current_provider,
@@ -846,17 +890,37 @@ module Kward
         choices.empty? ? ["#{current_provider} #{current_model} (current)"] : choices.uniq
       end
 
+      def default_selectable_model?(model)
+        return true if model[:current]
+
+        capabilities = Array(model[:supportedParameters]).map { |value| value.to_s.downcase }
+        return true if capabilities.empty?
+
+        capabilities.any? do |capability|
+          ["tools", "toolchoice", "functioncalling", "generatecontent", "streamgeneratecontent"].include?(capability.delete("_-"))
+        end
+      end
+
       def selected_model(selected, models)
         text = selected.to_s.sub(/ \(current\)\z/, "").strip
         known = models.find { |model| "#{model[:provider]} #{model[:id]}" == text }
         return [known[:provider], known[:id]] if known
 
         provider, model = text.split(/\s+/, 2)
-        if ["Codex", "Anthropic", "OpenRouter", "Copilot"].include?(provider) && !model.to_s.strip.empty?
-          [provider, model.strip]
-        else
-          [current_model_provider, text]
-        end
+        known_provider = ["Codex", "Anthropic", "OpenRouter", "Copilot", "Local"].include?(provider) || ProviderCatalog.find_by_name(provider)
+        return [provider, model.strip] if known_provider && !model.to_s.strip.empty?
+
+        [current_model_provider, text]
+      end
+
+      def persist_model_selection(provider, model, conversation)
+        model = model.to_s.strip
+        raise "Model must be a non-empty string" if model.empty?
+
+        ConfigFiles.update_config(ModelInfo.config_values_for_selection(provider, model))
+        reload_client_config
+        refresh_conversation_runtime(conversation)
+        @prompt.redraw if @prompt.respond_to?(:redraw)
       end
 
       REASONING_CONFIG_DEBOUNCE_SECONDS = 0.5

data/lib/kward/cli/tabs.rb

@@ -8,6 +8,12 @@ module Kward
   class CLI
     # TUI session tab coordination and asynchronous turn execution.
     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.
+      PROMPT
+
       TabRuntime = Struct.new(
         :session,
         :agent,
@@ -91,6 +97,7 @@ module Kward
         @active_tab_index = 0
         @tab_store = session_store ? TabStore.new(config_dir: session_store.config_dir, cwd: session_store.cwd) : nil
         @tab_live_view = nil
+        @tab_live_view_token = nil
         @restored_tabs = false
         restored = restore_tabs(session_store) if session_store && agent.nil?
         return restored if restored
@@ -120,11 +127,14 @@ module Kward
         descriptors = Array(data["tabs"])
         return nil if descriptors.empty?
 
-        descriptors.each_with_index do |_descriptor, index|
-          tab = build_tab_from_descriptor(data.fetch("tabs")[index], session_store, label: restored_tab_label(data, index))
+        descriptors.each_with_index do |descriptor, index|
+          tab = build_tab_from_descriptor(descriptor, session_store, label: restored_tab_label(data, index))
           @tabs << tab if tab
-        rescue StandardError
-          next
+        rescue StandardError => e
+          descriptor = descriptor.transform_keys(&:to_s) if descriptor.respond_to?(:transform_keys)
+          if descriptor.is_a?(Hash) && descriptor.key?("worktree")
+            @tabs << unavailable_worktree_tab(descriptor, e, label: restored_tab_label(data, index))
+          end
         end
         return nil if @tabs.empty?
 
@@ -136,13 +146,21 @@ module Kward
       def build_tab_from_descriptor(descriptor, session_store, label: nil)
         descriptor = descriptor.transform_keys(&:to_s)
         if descriptor["kind"] == "session"
-          session, conversation = restore_tab_session(session_store, descriptor.fetch("session_path"))
-          agent = build_tab_agent(conversation, session)
-          return build_tab(session, agent, driver: SessionTabDriver.new(session: session, agent: agent), label: label)
+          worktree = if descriptor.key?("worktree")
+            binding = GitWorktreeBinding.from_descriptor(descriptor["worktree"])
+            raise GitWorktreeManager::Error, "Invalid worktree binding." unless binding
+
+            binding
+          end
+          validate_worktree_binding!(worktree)
+          root = worktree_root_for(worktree, fallback: session_store.cwd)
+          session, conversation = restore_tab_session(session_store, descriptor.fetch("session_path"), workspace_root: root, strict: worktree&.active? == true)
+          agent = build_tab_agent(conversation, session, worktree: worktree)
+          return build_tab(session, agent, driver: SessionTabDriver.new(session: session, agent: agent, worktree: worktree), label: label)
         end
 
         tab_type = plugin_registry.tab_type_for_id(descriptor["plugin_tab_type"])
-        driver = if tab_type
+        driver = if tab_type&.local
           host = PluginTabHost.new(client: @client, workspace_root: session_store.cwd)
           tab_type.handler.call(host, descriptor)
         else
@@ -154,7 +172,7 @@ module Kward
 
       def open_plugin_tab(name, session_store)
         tab_type = plugin_registry.tab_type_for(name)
-        return runtime_output("Plugin tab #{name.inspect} is not available.") unless tab_type
+        return runtime_output("Plugin tab #{name.inspect} is not available.") unless tab_type&.local
 
         if tab_type.singleton == :global && (existing = @tabs.find { |tab| tab.driver.descriptor["plugin_tab_type"] == tab_type.id })
           return switch_tab(@tabs.index(existing))
@@ -174,30 +192,37 @@ module Kward
         runtime_output("Could not open plugin tab #{name.inspect}: #{e.message}")
       end
 
-      def restore_tab_session(session_store, path)
+      def restore_tab_session(session_store, path, workspace_root: session_store.cwd, strict: false)
         if File.file?(path)
-          session, conversation = session_store.load(path, workspace: configured_workspace(root: session_store.cwd), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
+          session, conversation = session_store.load(path, workspace: configured_workspace(root: workspace_root, strict: strict), provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort)
           return [track_session(session), conversation]
         end
 
         session = track_session(session_store.create(provider: current_model_provider, model: current_model_id, reasoning_effort: current_reasoning_effort))
-        conversation = new_conversation(workspace_root: session_store.cwd)
+        conversation = new_conversation(workspace_root: workspace_root)
         session.attach(conversation)
         [session, conversation]
       end
 
-      def build_tab_agent(conversation, _session)
+      def build_tab_agent(conversation, _session, worktree: nil)
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
-        workspace = configured_workspace(root: conversation.workspace_root)
+        strict = worktree&.active? == true
+        update_worktree_agent_context(conversation, strict)
+        workspace = configured_workspace(root: conversation.workspace_root, strict: strict)
         prompt = TabQuestionPrompt.new(self)
-        hook_manager = lifecycle_hook_manager(conversation)
-        hook_context = lifecycle_hook_context(conversation)
+        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) }
+                        end
         tool_registry = ToolRegistry.new(
           workspace: workspace,
           prompt: prompt,
           tool_approval: tab_tool_approval_callback(prompt),
           hook_manager: hook_manager,
-          hook_context: hook_context
+          hook_context: hook_context,
+          mcp_clients: strict ? [] : nil,
+          git_committer: git_committer
         )
         @footer_conversation = conversation
         @footer_tool_registry = tool_registry
@@ -212,6 +237,14 @@ module Kward
         agent
       end
 
+      def update_worktree_agent_context(conversation, strict)
+        desired = strict ? WORKTREE_AGENT_CONTEXT : nil
+        return if conversation.execution_profile_context == desired
+        return unless strict || conversation.execution_profile_context == WORKTREE_AGENT_CONTEXT
+
+        conversation.update_execution_profile_context!(desired)
+      end
+
       def tab_tool_approval_callback(prompt)
         return nil unless ConfigFiles.permission_policy(safely_read_config.to_h).enabled?
 
@@ -372,8 +405,9 @@ module Kward
         return agent unless tab
 
         tab.session = @active_session
-        tab.agent = build_tab_agent(agent.conversation, tab.session)
-        tab.driver = SessionTabDriver.new(session: tab.session, agent: tab.agent)
+        worktree = reconcile_worktree_binding(tab, agent.conversation)
+        tab.agent = build_tab_agent(agent.conversation, tab.session, worktree: worktree)
+        tab.driver = SessionTabDriver.new(session: tab.session, agent: tab.agent, worktree: worktree)
         assign_tab_question_prompt(tab.agent, tab)
         tab.diff = @session_diff || (tab.session&.path ? SessionDiff.from_session_file(tab.session.path) : SessionDiff.new)
         tab.snapshot = nil
@@ -389,6 +423,7 @@ module Kward
         tab.shell = nil
         tab.stream_state = new_tab_stream_state(tab.driver)
         tab.markdown_chunks.clear
+        update_prompt_workspace_root(current_workspace_root)
         update_prompt_tabs
         persist_tabs
         tab.agent
@@ -399,13 +434,23 @@ module Kward
         return unless tab
 
         if @prompt.respond_to?(:tab_view_snapshot)
-          tab.snapshot = @prompt.tab_view_snapshot
+          tab.snapshot = tab_view_snapshot_for(tab)
         elsif @prompt.respond_to?(:composer_snapshot)
           tab.snapshot = @prompt.composer_snapshot
         end
         tab.diff = @session_diff
       end
 
+      def tab_view_snapshot_for(tab)
+        snapshot_method = @prompt.method(:tab_view_snapshot)
+        supports_transcript_option = snapshot_method.parameters.any? do |type, name|
+          type == :keyrest || ([:key, :keyreq].include?(type) && name == :include_transcript)
+        end
+        return snapshot_method.call unless supports_transcript_option
+
+        snapshot_method.call(include_transcript: tab.running? || !tab.shell.nil?)
+      end
+
       def activate_tab(index, render: true)
         tab = @tabs[index]
         return nil unless tab
@@ -424,6 +469,8 @@ module Kward
         end
         tab.unread = false
         restore_tab_composer_snapshot(tab.snapshot)
+        update_prompt_workspace_root(current_workspace_root)
+        @prompt.refresh_composer_status if @prompt.respond_to?(:refresh_composer_status)
         update_plugin_tab_slash_commands(tab)
         update_prompt_tabs
         render_tab(tab) if render
@@ -640,12 +687,12 @@ module Kward
 
       def refresh_active_tab
         tab = active_tab
-        return unless tab
+        return unless tab&.thread && !tab.thread.alive? && tab.running?
 
-        if tab.thread && !tab.thread.alive? && tab.running?
-          tab.thread.join
-          tab.status = "ready" if tab.status == "running"
-        end
+        tab.thread.join
+        return unless tab.status == "running"
+
+        tab.status = "ready"
         update_prompt_tabs
       end
 
@@ -653,23 +700,31 @@ module Kward
         return unless prompt_interface?
 
         stop_tab_live_view
-        @tab_live_view_stop = false
-        @tab_live_view = Thread.new { run_tab_live_view(tab) }
+        token = Object.new
+        @tab_live_view_token = token
+        @tab_live_view = Thread.new { run_tab_live_view(tab, token) }
         @tab_live_view.report_on_exception = false
       end
 
       def stop_tab_live_view
-        @tab_live_view_stop = true
-        @tab_live_view&.join(0.2)
-        @tab_live_view = nil
+        thread = @tab_live_view
+        @tab_live_view_token = nil
+        thread&.join(0.2)
+        @tab_live_view = nil if @tab_live_view.equal?(thread)
       end
 
-      def run_tab_live_view(tab)
+      def run_tab_live_view(tab, token)
         renderer = tab_live_renderer(tab)
-        until @tab_live_view_stop
+        while @tab_live_view_token.equal?(token)
           events = tab.event_history[tab.seen_events..] || []
-          events.each { |event| renderer.call(event, tab.driver) }
-          tab.seen_events += events.length
+          events.each do |event|
+            break unless @tab_live_view_token.equal?(token)
+
+            renderer.call(event, tab.driver)
+            tab.seen_events += 1
+          end
+          break unless @tab_live_view_token.equal?(token)
+
           if tab.idle?
             renderer.call(:flush, tab.driver)
             break
@@ -677,7 +732,8 @@ module Kward
           sleep 0.05
         end
       ensure
-        @tab_live_view_stop = false if @tab_live_view == Thread.current
+        @tab_live_view_token = nil if @tab_live_view_token.equal?(token)
+        @tab_live_view = nil if @tab_live_view == Thread.current
       end
 
       def tab_live_renderer(tab)
@@ -726,6 +782,8 @@ module Kward
       def tab_labels
         @tabs.each_with_index.map do |tab, index|
           label = tab.label.to_s.empty? ? default_tab_label(index) : tab.label.to_s
+          binding = worktree_binding_for(tab)
+          label = "#{label} · #{binding.branch}" if binding&.active?
           { name: label, color: tab_label_color(tab) }
         end
       end
@@ -752,7 +810,7 @@ module Kward
         action, value = argument.to_s.strip.split(/\s+/, 2)
         case action
         when nil, ""
-          runtime_output("Usage: /tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label>")
+          runtime_output(tab_usage)
           nil
         when /^\d+$/
           switch_tab_number(action)
@@ -774,12 +832,19 @@ module Kward
         when "name", "rename"
           rename_active_tab(value)
           active_tab&.agent
+        when "worktree"
+          handle_worktree_command(value)
+          active_tab&.agent
         else
-          runtime_output("Usage: /tab 1-n | /tab move 1-n|left|right | /tab close | /tab new | /tab open <plugin-tab> | /tab name <label>")
+          runtime_output(tab_usage)
           nil
         end
       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]"
+      end
+
       def switch_tab_number(number)
         index = number.to_i - 1
         return switch_tab(index) if @tabs && index.between?(0, @tabs.length - 1)