kward 0.84.0 → 0.85.0

data/lib/kward/cli/slash_commands.rb

@@ -1,4 +1,4 @@
-require_relative "../scratchpad_languages"
+require_relative "../prompt_interface/editor/scratchpad_languages"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -64,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]
@@ -81,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) }]
@@ -113,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:")
@@ -122,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
@@ -133,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

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,
@@ -41,6 +44,7 @@ module Kward
         :transient_shell_entries,
         :error_reported,
         :local_busy_activity,
+        :pending_runtime_outputs,
         keyword_init: true
       ) do
         TRANSIENT_SHELL_OUTPUT_LIMIT = 200_000
@@ -53,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
@@ -205,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)
@@ -225,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
@@ -254,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
@@ -301,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",
@@ -329,7 +365,8 @@ module Kward
           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
 
@@ -429,6 +466,7 @@ module Kward
 
         if @tabs.length <= 1
           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
@@ -437,7 +475,7 @@ module Kward
         stop_tab_live_view
         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)
@@ -555,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)
@@ -569,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
@@ -614,10 +678,15 @@ module Kward
         index ? index + 1 : active_tab_number
       end
 
-      def register_background_tab_run(tab, run, &completion)
+      def register_background_tab_run(tab, run, output_kind: nil, &completion)
         return unless tab && run
 
-        tab.background_run = { run: run, completion: completion }
+        tab.background_run = {
+          run: run,
+          completion: completion,
+          output_kind: output_kind,
+          rendered_output: +""
+        }
         tab.local_busy_activity = "running"
         tab.attention = nil
         update_prompt_tabs
@@ -628,11 +697,19 @@ module Kward
 
         @tabs.each do |tab|
           state = tab.background_run
-          next unless state&.fetch(:run)&.complete?
+          next unless state
 
-          result = state[:run].result
+          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
-          state[:completion]&.call(state[:run].sink, result) if result.is_a?(Struct)
           finish_local_busy_command_for_tab(tab)
           if tab != active_tab
             tab.unread = true
@@ -654,20 +731,39 @@ module Kward
 
       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
@@ -779,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
@@ -812,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?
@@ -922,7 +1026,7 @@ module Kward
         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 :activity if tab.unread
+        return :success if tab.unread
 
         nil
       end
@@ -972,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)
@@ -1042,16 +1146,52 @@ module Kward
           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

data/lib/kward/{cli_transcript_formatter.rb → cli/transcript_formatter.rb}

@@ -1,7 +1,7 @@
 require "base64"
-require_relative "image_attachments"
-require_relative "message_access"
-require_relative "message_text"
+require_relative "../image_attachments"
+require_relative "../message_access"
+require_relative "../message_text"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward

data/lib/kward/cli/worktrees.rb

@@ -101,10 +101,14 @@ module Kward
           remove_active_worktree
         when "merge"
           merge_active_worktree
+        when "merge resolve"
+          resolve_active_worktree_merge
+        when "merge continue"
+          continue_active_worktree_merge
         when "merge abort"
           abort_active_worktree_merge
         else
-          runtime_output("Usage: /tab worktree [activate|detach|status|merge|merge abort|remove]")
+          runtime_output("Usage: /tab worktree [activate|detach|status|merge [resolve|continue|abort]|remove]")
         end
       end
 
@@ -222,6 +226,11 @@ module Kward
           raise GitWorktreeManager::Error, "Worktree branch changed: expected #{binding.branch}, found #{info.branch || "detached HEAD"}" unless info.branch == binding.branch
           status = git_worktree_manager.status(binding.path)
           lines << "Changes: #{status.clean? ? "clean" : "#{status.entries.length} local change(s)"}"
+          if git_worktree_manager.merge_in_progress?(binding.origin_root)
+            conflicts = git_worktree_manager.merge_conflict_marker_paths(binding.origin_root, cached: false)
+            lines << "Merge: in progress in origin#{conflicts.empty? ? "; ready to continue" : "; #{conflicts.length} unresolved conflict(s)"}"
+            lines << "Conflicts: #{conflicts.join(", ")}" unless conflicts.empty?
+          end
         rescue GitWorktreeManager::Error => e
           lines << "State: unavailable (#{e.message})"
         end
@@ -236,6 +245,10 @@ module Kward
         return runtime_output("Activate the worktree before merging it.") unless binding.active?
 
         validate_worktree_binding!(binding)
+        if git_worktree_manager.merge_in_progress?(binding.origin_root)
+          return runtime_output("A merge is already in progress in #{binding.origin_root}. Resolve it with /worktree merge resolve, continue it with /worktree merge continue, or abort it with /worktree merge abort.")
+        end
+
         source_status = git_worktree_manager.status(binding.path)
         return runtime_output("Worktree has local changes; commit or clean it before merging.") if source_status.dirty?
 
@@ -270,12 +283,62 @@ module Kward
         if result.merged?
           runtime_output("Merged #{binding.branch} into #{target_branch}.")
         else
-          runtime_output("Merge conflicts in #{result.conflicts.join(", ")}. Resolve them in #{binding.origin_root} or run /tab worktree merge abort.")
+          runtime_output(<<~MESSAGE.strip)
+            Merge conflicts in #{result.conflicts.join(", ")}.
+            Merge paused in #{binding.origin_root}; this tab remains on #{binding.branch}.
+            Run /worktree merge resolve to let the agent inspect and fix the conflicts here, or /worktree merge abort to cancel.
+          MESSAGE
         end
       rescue GitWorktreeManager::Error => e
         runtime_output("Worktree error: #{e.message}")
       end
 
+      def resolve_active_worktree_merge
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot resolve its worktree merge yet.") if tab.running? || tab.local_busy? || tab.shell
+        return runtime_output("Activate the worktree before resolving its merge.") unless binding.active?
+        return runtime_output("No merge is in progress in the original workspace.") unless git_worktree_manager.merge_in_progress?(binding.origin_root)
+
+        validate_worktree_binding!(binding)
+        conflicts = git_worktree_manager.unmerged_paths(binding.origin_root)
+        return runtime_output("No unresolved conflicts remain in #{binding.origin_root}; run /worktree merge continue to finish the merge.") if conflicts.empty?
+
+        submit_tab_input(
+          tab,
+          <<~PROMPT.strip,
+            Resolve the in-progress Git merge in the verified origin workspace. Use target: "origin" for every workspace inspection, edit, and test operation. Read the applicable AGENTS.md files first, inspect the unmerged paths, resolve the conflicts, and run the relevant tests. Do not commit the merge; leave it ready for /worktree merge continue after all conflicts are resolved.
+
+            Unmerged paths: #{conflicts.join(", ")}
+          PROMPT
+          display_input: "Resolve merge conflicts in origin"
+        )
+      rescue GitWorktreeManager::Error => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
+      def continue_active_worktree_merge
+        tab = active_tab
+        binding = worktree_binding_for(tab)
+        return runtime_output("Tab #{active_tab_number} has no worktree binding.") unless binding
+        return runtime_output("Tab #{active_tab_number} is running and cannot continue its worktree merge yet.") if tab.running? || tab.local_busy? || tab.shell
+        return runtime_output("Activate the worktree before continuing its merge.") unless binding.active?
+        return runtime_output("No merge is in progress in the original workspace.") unless git_worktree_manager.merge_in_progress?(binding.origin_root)
+
+        validate_worktree_binding!(binding)
+        markers = git_worktree_manager.merge_conflict_marker_paths(binding.origin_root, cached: false)
+        return runtime_output("Merge still contains conflict markers: #{markers.join(", ")}.") unless markers.empty?
+        target_branch = git_worktree_manager.current_branch(binding.origin_root)
+        return runtime_output("Original workspace is in detached HEAD state; resolve that before continuing the merge.") if target_branch.empty?
+        return unless confirm_worktree_action("Complete the merge of #{binding.branch} into #{target_branch} in #{binding.origin_root}?")
+
+        git_worktree_manager.continue_merge(binding.origin_root)
+        runtime_output("Completed the merge of #{binding.branch} into #{target_branch}.")
+      rescue GitWorktreeManager::Error => e
+        runtime_output("Worktree error: #{e.message}")
+      end
+
       def abort_active_worktree_merge
         tab = active_tab
         binding = worktree_binding_for(tab)