kward 0.76.0 → 0.77.0

data/lib/kward/cli/slash_commands.rb

@@ -46,20 +46,6 @@ module Kward
         when "pty"
           run_interactive_pty_command(argument, agent)
           [true, nil]
-        when "workers"
-          unless experimental_workers_enabled?
-            runtime_output("Workers are experimental. Start Kward with --experimental-workers to enable /workers.")
-            return [true, nil]
-          end
-
-          [true, handle_workers_command(argument, agent, session_store)]
-        when "queue"
-          unless experimental_workers_enabled?
-            runtime_output("Worker queues are experimental. Start Kward with --experimental-workers to enable /queue.")
-            return [true, nil]
-          end
-
-          [true, handle_worker_queue_command(argument, agent, session_store)]
         when "tab"
           [true, handle_tab_command(argument, session_store)]
         when "settings"
@@ -136,7 +122,7 @@ module Kward
 
         path = argument.to_s.strip
         if path.empty?
-          sessions = run_busy_local_command_and_requeue { session_store.recent_tree(limit: nil) }
+          sessions = run_busy_local_command_and_requeue { recent_sessions(session_store, tree: true) }
           path = select_session_path_from_sessions(sessions, session_store: session_store)
         end
 
@@ -255,552 +241,6 @@ module Kward
         nil
       end
 
-      def handle_worker_queue_command(argument, agent, session_store)
-        action, value = argument.to_s.strip.split(/\s+/, 2)
-        case action
-        when nil, "", "status", "list"
-          show_worker_queue
-        when "add", "enqueue"
-          enqueue_active_tab(value, agent)
-        when "open", "show"
-          open_worker_queue_job(session_store, value)
-        when "run", "start"
-          run_worker_queue(session_store)
-        when "resume"
-          value.to_s.strip.empty? ? run_worker_queue(session_store) : resume_worker_queue_job(session_store, value)
-        when "suspend", "pause"
-          suspend_worker_queue_job(session_store, value)
-        when "next"
-          run_next_worker_queue_job(session_store)
-        else
-          runtime_output("Usage: /queue [add|list|status|run|suspend <id>|resume <id>]")
-        end
-      end
-
-      def worker_queue_store
-        @worker_queue_store ||= Workers::QueueStore.new
-      end
-
-      def enqueue_active_tab(title, agent)
-        session = @active_session
-        unless session&.path
-          runtime_output("No active persisted session to queue.")
-          return
-        end
-
-        job = worker_queue_store.enqueue(
-          title: worker_queue_title(title, session, agent),
-          session_path: session.path,
-          workspace_root: session.cwd || current_workspace_root
-        )
-        runtime_output("Queued worker #{job.id}: #{job.title}")
-      end
-
-      def worker_queue_title(title, session, agent)
-        explicit = title.to_s.strip
-        return explicit unless explicit.empty?
-
-        session_name = session&.name.to_s.strip
-        return session_name unless session_name.empty?
-
-        last_user = if agent&.respond_to?(:conversation)
-                      agent.conversation.messages.reverse.find { |message| MessageAccess.role(message) == "user" }
-                    end
-        content = MessageAccess.content(last_user).to_s.strip.gsub(/\s+/, " ")
-        content.empty? ? "Queued worker" : content[0, 80]
-      end
-
-      def open_worker_queue_job(session_store, id)
-        unless session_store
-          runtime_output("Worker queue requires persisted sessions.")
-          return nil
-        end
-
-        id = id.to_s.strip
-        return runtime_output("Usage: /queue open <id>") if id.empty?
-
-        record = worker_queue_store.find(id)
-        return runtime_output("Unknown worker job: #{id}") unless record
-
-        load_session(session_store, record.fetch("session_path"), message: "Showing queued worker #{record.fetch('id')}")
-      end
-
-      def run_worker_queue(session_store)
-        unless session_store
-          runtime_output("Worker queue requires persisted sessions.")
-          return
-        end
-
-        results = worker_queue_runner(session_store).run_all
-        if results.empty?
-          runtime_output("Worker queue has no queued jobs.")
-          return
-        end
-
-        summary = results.map { |record| "#{record.fetch('id')} #{record.fetch('status')}" }.join(", ")
-        runtime_output("Worker queue run finished: #{summary}")
-      end
-
-      def run_next_worker_queue_job(session_store)
-        unless session_store
-          runtime_output("Worker queue requires persisted sessions.")
-          return
-        end
-
-        record = worker_queue_runner(session_store).run_next
-        if record
-          runtime_output("Worker #{record.fetch('id')} finished with status #{record.fetch('status')}.")
-        else
-          runtime_output("Worker queue has no queued jobs.")
-        end
-      end
-
-      def suspend_worker_queue_job(session_store, id)
-        unless session_store
-          runtime_output("Worker queue requires persisted sessions.")
-          return
-        end
-
-        id = id.to_s.strip
-        return runtime_output("Usage: /queue suspend <id>") if id.empty?
-
-        record = worker_queue_runner(session_store).suspend(id)
-        runtime_output("Worker #{record.fetch('id')} suspended.")
-      end
-
-      def resume_worker_queue_job(session_store, id)
-        unless session_store
-          runtime_output("Worker queue requires persisted sessions.")
-          return
-        end
-
-        id = id.to_s.strip
-        return runtime_output("Usage: /queue resume <id>") if id.empty?
-
-        record = worker_queue_runner(session_store).resume(id)
-        runtime_output("Worker #{record.fetch('id')} finished with status #{record.fetch('status')}.")
-      end
-
-      def worker_queue_runner(session_store)
-        Workers::QueueRunner.new(
-          queue_store: worker_queue_store,
-          session_store: session_store,
-          client_factory: -> { Client.new },
-          prompt: @prompt,
-          workspace_root: current_workspace_root,
-          provider: current_model_provider,
-          model: current_model_id,
-          reasoning_effort: current_reasoning_effort,
-          write_lock: (@worker_write_lock ||= Workers::WriteLock.new)
-        )
-      end
-
-      def show_worker_queue
-        jobs = worker_queue_store.list
-        if jobs.empty?
-          runtime_output("Worker queue is empty.")
-          return
-        end
-
-        lines = ["Worker queue:"]
-        jobs.each do |job|
-          details = [job.fetch("id"), "[#{job.fetch('status')}]"]
-          details << "##{job['position']}" if job["position"]
-          details << job.fetch("title")
-          details << "commit #{job['commit_sha']}" unless job["commit_sha"].to_s.empty?
-          details << "error: #{job['error']}" unless job["error"].to_s.empty?
-          lines << "- #{details.join(' ')}"
-        end
-        runtime_output(lines.join("\n"))
-      end
-
-      def handle_workers_command(argument, agent, session_store)
-        action, value = argument.to_s.strip.split(/\s+/, 2)
-        replacement_agent = case action
-                            when nil, ""
-                              open_worker_menu(agent, session_store)
-                            when "list"
-                              open_worker_list(agent, session_store)
-                            when "new", "do"
-                              prompt_for_worker_request(agent, value)
-                              nil
-                            else
-                              runtime_output("Usage: /workers | /workers new | /workers list")
-                              nil
-                            end
-        replacement_agent?(replacement_agent) ? replacement_agent : nil
-      end
-
-      def worker_store
-        @worker_store ||= Workers::Store.new
-      end
-
-      def worker_manager(agent)
-        workspace_root = interactive_workspace_root(agent)
-        return @worker_manager if @worker_manager && @worker_manager_workspace_root == workspace_root
-
-        @worker_manager_workspace_root = workspace_root
-        @worker_manager = Workers::Manager.new(
-          client_factory: -> { Client.new },
-          prompt: @prompt,
-          workspace_root: workspace_root,
-          session_store: interactive_session_store(agent),
-          provider: current_model_provider,
-          model: current_model_id,
-          reasoning_effort: current_reasoning_effort,
-          write_lock: (@worker_write_lock ||= Workers::WriteLock.new),
-          worker_store: worker_store,
-          write_lane_available: -> { !@foreground_turn_active },
-          hook_manager: lifecycle_hook_manager(agent.conversation),
-          hook_context: lifecycle_hook_context(agent.conversation)
-        )
-      end
-
-      def open_worker_menu(agent, session_store)
-        return runtime_output("Usage: /workers | /workers new | /workers list") unless @prompt.respond_to?(:select)
-
-        choice = @prompt.select(
-          "Workers",
-          ["New worker", "List workers"],
-          title: "Workers",
-          custom: false
-        )
-        case choice
-        when "New worker"
-          prompt_for_worker_request(agent)
-        when "List workers"
-          open_worker_list(agent, session_store)
-        end
-      end
-
-      def prompt_for_worker_request(agent, topic = nil)
-        topic = @prompt.ask("Worker task>") if topic.to_s.strip.empty? && @prompt.respond_to?(:ask)
-        send_worker_request(topic, agent) unless topic.to_s.strip.empty?
-      end
-
-      def send_worker_request(topic, agent)
-        if topic.to_s.strip.empty?
-          runtime_output("Usage: /workers new <task>")
-          return
-        end
-
-        worker = worker_manager(agent).start(role: "request", prompt: topic)
-        runtime_output("Worker #{worker.id} started: #{worker.title}")
-      end
-
-      def open_worker_list(agent, session_store, title: "Workers", empty_message: "No workers in the pipeline.")
-        return runtime_output(empty_message) unless @prompt.respond_to?(:select)
-
-        jobs = worker_jobs
-        if jobs.empty?
-          runtime_output(empty_message)
-          return
-        end
-
-        labels = jobs.map { |job| worker_choice_label(job) }
-        choice = @prompt.select("Select worker", labels, title: title, custom: false)
-        return unless choice
-
-        selected = jobs[labels.index(choice)]
-        open_worker_actions(selected, agent, session_store) if selected
-      end
-
-      def worker_jobs
-        runtime_worker_ids = @worker_manager ? @worker_manager.list.map(&:id) : []
-        persisted_workers = worker_store.list.reject { |job| runtime_worker_ids.include?(job["id"]) }
-        live_workers = @worker_manager ? @worker_manager.list.map(&:to_h) : []
-        [implementation_worker_job].compact + persisted_workers + live_workers
-      end
-
-      def implementation_worker_job
-        remember_implementation_worker if implementation_agent?
-        path = @implementation_worker_session_path || @active_session&.path
-        return nil if path.to_s.empty?
-
-        {
-          "id" => "implementation",
-          "title" => @implementation_worker_title || @active_session&.name || "Implementation",
-          "role" => "implementation",
-          "status" => implementation_agent? ? "active" : "idle",
-          "session_path" => path
-        }
-      end
-
-      def implementation_agent?
-        @active_worker_role.to_s.empty? || @active_worker_role == "implementation"
-      end
-
-      def remember_implementation_worker
-        return unless @active_session&.path
-        return unless implementation_agent?
-
-        @implementation_worker_session_path = @active_session.path
-        @implementation_worker_title = @active_session.name || "Implementation"
-      end
-
-      def open_worker_actions(job, _agent, session_store)
-        return open_implementation_actions(job, session_store) if job["id"] == "implementation"
-
-        open_background_worker_actions(job, session_store)
-      end
-
-      def open_implementation_actions(job, session_store)
-        actions = ["Show", "Back to list"]
-        choice = @prompt.select("#{job.fetch('id')} — #{job.fetch('title')}", actions, title: "Worker", custom: false)
-        case choice
-        when "Show"
-          load_implementation_session(session_store, job)
-        when "Back to list"
-          open_worker_list(nil, session_store)
-        end
-      end
-
-      def handle_request_worker_input(input, agent, session_store)
-        return [false, nil] unless @active_worker_role == "request"
-
-        worker = visible_request_worker(agent)
-        return [false, nil] unless worker
-
-        text = input.to_s.strip
-        return [true, nil] if text.empty?
-        return [true, proceed_request_worker(worker.to_h, agent, session_store)] if proceed_request_input?(text)
-
-        runtime_output("Worker #{worker.id} is a read-only request review. Reply yes/proceed to queue implementation, or use /workers to switch workers.")
-        [true, nil]
-      end
-
-      def visible_request_worker(agent)
-        worker = @visible_worker
-        return worker if worker&.role == "request" && worker.status == "ready"
-
-        id = @visible_worker_id.to_s
-        return nil if id.empty? || id == "implementation"
-
-        worker = @worker_manager&.find(id)
-        return worker if worker&.role == "request" && worker.status == "ready"
-
-        job = worker_store.find(id)
-        return nil unless job && job["role"] == "request" && job["status"] == "ready"
-        return nil if job["session_path"].to_s.empty? || !session_matches_agent?(job["session_path"], agent)
-
-        Workers::Worker.new(
-          id: job.fetch("id"),
-          title: job.fetch("title"),
-          role: job.fetch("role"),
-          workspace_root: job["workspace_root"] || current_workspace_root,
-          status: job.fetch("status"),
-          prompt: job["prompt"]
-        ).tap { |restored| restored.update_status("ready", report: job["report"], error: job["error"]) }
-      end
-
-      def session_matches_agent?(path, agent)
-        return true unless agent.respond_to?(:conversation)
-        return false unless @active_session&.path
-
-        File.expand_path(path) == File.expand_path(@active_session.path)
-      end
-
-      def proceed_request_input?(input)
-        input.downcase.strip.match?(/\A(?:y|yes|yeah|yep|sure|ok|okay|go ahead|proceed|continue|implement|do it|please do|make it so)\b/)
-      end
-
-      def proceed_request_worker(job, agent, session_store)
-        return runtime_output("Worker #{job.fetch('id')} is not ready to proceed.") unless request_ready?(job)
-
-        release_implementation_writer
-        manager = worker_manager(agent || build_session_agent_for_worker(job, session_store))
-        worker = manager.continue(
-          job.fetch("id"),
-          role: "implementation",
-          prompt: implementation_prompt_for_request(job),
-          title: "Implement #{job.fetch('title')}"
-        )
-        runtime_output("Worker #{worker.id} queued from request #{job.fetch('id')}: #{worker.title}")
-        wait_for_worker_session(worker)
-        load_worker_session(session_store, worker.session.path, worker.to_h, worker: worker) if worker.session&.path
-      rescue StandardError => e
-        runtime_output("Error: #{e.message}")
-        nil
-      end
-
-      def wait_for_worker_session(worker, timeout: 1.0)
-        deadline = Time.now + timeout
-        until worker.session&.path || Time.now >= deadline
-          sleep 0.02
-        end
-      end
-
-      def build_session_agent_for_worker(job, session_store)
-        conversation = Conversation.new(workspace_root: job["workspace_root"] || session_store&.cwd || current_workspace_root)
-        build_worker_agent(conversation, role: "request")
-      end
-
-      def request_ready?(job)
-        job["role"] == "request" && job["status"] == "ready"
-      end
-
-      def implementation_prompt_for_request(job)
-        <<~PROMPT
-          The user reviewed and approved this Kward request. Continue in the write-capable implementation lane.
-
-          Original request:
-          #{job["prompt"]}
-
-          Request review:
-          #{job["report"].to_s.empty? ? "No saved review text is available. Use the request session transcript for context if needed." : job["report"]}
-
-          Implement the approved next step. Make the smallest correct change, preserve existing style, and run focused verification when practical.
-          If you change files, commit the changes and report the commit hash. If no file changes are needed, explain why.
-        PROMPT
-      end
-
-      def open_background_worker_actions(job, session_store)
-        actions = ["Show"]
-        actions << "Proceed" if request_ready?(job)
-        actions << "Cancel" if %w[queued running].include?(job["status"])
-        actions << "Dismiss"
-        actions << "Back to list"
-        choice = @prompt.select("#{job.fetch('id')} — #{job.fetch('title')}", actions, title: "Worker", custom: false)
-        case choice
-        when "Show"
-          worker = @worker_manager&.find(job.fetch("id"))
-          path = job["session_path"] || worker&.session&.path
-          return runtime_output("Worker #{job.fetch('id')} session is not ready yet.") unless path
-
-          load_worker_session(session_store, path, job, worker: worker)
-        when "Proceed"
-          proceed_request_worker(job, nil, session_store)
-        when "Cancel"
-          @worker_manager&.cancel(job.fetch("id"))
-          runtime_output("Worker #{job.fetch('id')} cancelled.")
-        when "Dismiss"
-          dismiss_worker(job.fetch("id"))
-          runtime_output("Worker #{job.fetch('id')} dismissed.")
-        when "Back to list"
-          open_worker_list(nil, session_store)
-        end
-      end
-
-      def dismiss_worker(id)
-        @worker_manager&.archive(id)
-      rescue ArgumentError
-        nil
-      ensure
-        worker_store.archive(id)
-      end
-
-      def load_implementation_session(session_store, job)
-        return runtime_output("Implementation session unavailable.") unless session_store
-
-        stop_live_worker_view
-        @active_worker_role = "implementation"
-        set_visible_worker("implementation", status: "active")
-        load_session(session_store, job.fetch("session_path"), message: "Showing implementation worker")
-      rescue StandardError => e
-        runtime_output("Error: #{e.message}")
-        nil
-      end
-
-      def worker_choice_label(job)
-        error = job["status"] == "failed" && !job["error"].to_s.empty? ? " — #{job['error']}" : ""
-        "#{job.fetch('id')} [#{job.fetch('role')}/#{job.fetch('status')}] #{job.fetch('title')}#{error}"
-      end
-
-      def load_worker_session(session_store, path, job, worker: nil)
-        unless session_store
-          runtime_output(worker_report_text(job))
-          return nil
-        end
-
-        release_implementation_writer
-        agent = load_session(session_store, path, message: "Showing worker #{job.fetch('id')}")
-        release_implementation_writer
-        role = visible_session_role(job)
-        agent = build_worker_agent(agent.conversation, role: role)
-        @active_worker_role = role
-        set_visible_worker(job.fetch("id"), status: job["status"], worker: worker)
-        @prompt.redraw if @prompt.respond_to?(:redraw)
-        start_live_worker_view(worker, agent) if live_worker?(worker)
-        agent
-      rescue StandardError => e
-        runtime_output("Error: #{e.message}")
-        nil
-      end
-
-      def visible_session_role(job)
-        return "read_only" if job["id"] != "implementation" && job["role"] == "implementation"
-
-        job["role"] || "request"
-      end
-
-      def live_worker?(worker)
-        worker && %w[queued running].include?(worker.status)
-      end
-
-      def start_live_worker_view(worker, agent)
-        return unless prompt_interface?
-
-        stop_live_worker_view
-        renderer = live_worker_renderer(worker)
-        @live_worker_view = Workers::LiveView.new(worker: worker, agent: agent, renderer: renderer).start
-        @prompt.redraw if @prompt.respond_to?(:redraw)
-        runtime_output("Watching worker #{worker.id}; the view will update until it finishes.")
-      end
-
-      def stop_live_worker_view
-        @live_worker_view&.stop
-        @live_worker_view = nil
-      end
-
-      def live_worker_renderer(worker)
-        markdown_chunks = []
-        stream_state = {
-          streamed: false,
-          last_flush: monotonic_now,
-          stream_block_open: false,
-          markdown_streams: {},
-          defer_assistant_streaming: false
-        }
-        lambda do |event, agent|
-          if event == :flush
-            flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: worker_finished?(worker))
-            @prompt.redraw if @prompt.respond_to?(:redraw)
-            next
-          end
-
-          notify_plugin_transcript_event(event, agent.respond_to?(:conversation) ? agent.conversation : nil)
-          handle_live_worker_event(event, markdown_chunks, stream_state)
-          flush_interactive_markdown_deltas(markdown_chunks, stream_state, force: worker_finished?(worker))
-        rescue StandardError => e
-          runtime_output("Worker view error: #{e.message}")
-        end
-      end
-
-      def handle_live_worker_event(event, markdown_chunks, stream_state)
-        case event
-        when Events::AssistantMessage
-          return if stream_state[:streamed]
-
-          render_assistant_message(event.message)
-        else
-          handle_interactive_event(event, markdown_chunks, stream_state)
-        end
-      end
-
-      def worker_finished?(worker)
-        %w[ready failed cancelled archived].include?(worker.status)
-      end
-
-      def worker_report_text(job)
-        lines = ["Worker #{job.fetch('id')} [#{job.fetch('status')}] #{job.fetch('title')}", ""]
-        if job["report"].to_s.empty?
-          lines << (job["error"].to_s.empty? ? "No report yet." : "Error: #{job['error']}")
-        else
-          lines << job["report"]
-        end
-        lines.join("\n")
-      end
-
     end
   end
 end

data/lib/kward/cli/tabs.rb

@@ -404,7 +404,6 @@ module Kward
       end
 
       def start_tab_turn(tab, input, display_input: nil)
-        stop_live_worker_view if respond_to?(:stop_live_worker_view, true)
         prepare_memory_context(tab.agent.conversation, input) if tab.agent.respond_to?(:conversation)
         print_user_transcript(input, display_input: display_input) if prompt_interface?
         tab.status = "queued"
@@ -489,7 +488,7 @@ module Kward
             tab.queued_inputs << "/exit"
             @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
           when String
-            handle_tab_busy_input(tab, poll_result)
+            return { tab_action: :busy_command } if handle_tab_busy_input(tab, poll_result) == :active_tab_changed
           end
           return next_tab_queued_input(tab) if tab.idle? && !tab.queued_inputs.empty?
           return :tab_idle if tab.idle?
@@ -512,6 +511,15 @@ 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)
+          unless active_tab.equal?(tab)
+            @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
+            return :active_tab_changed
+          end
+
+          restore_busy_input_prompt
+          return
         elsif slash_command_input?(input)
           # Slash commands are local control actions. Running or queuing them
           # from the busy composer is surprising because the state they act on
@@ -532,6 +540,10 @@ module Kward
         @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
       end
 
+      def busy_tab_command?(input)
+        input.to_s.strip.match?(%r{\A/tab(?:\s|\z)})
+      end
+
       def refresh_active_tab
         tab = active_tab
         return unless tab

data/lib/kward/cli.rb

@@ -40,7 +40,6 @@ require_relative "session_tree_renderer"
 require_relative "starter_pack_installer"
 require_relative "steering"
 require_relative "update_check"
-require_relative "workers"
 require_relative "tools/tool_call"
 require_relative "tools/registry"
 require_relative "telemetry/stats"
@@ -114,8 +113,6 @@ module Kward
       @prompt_delimited = false
       @requested_mode = "auto"
       @skip_config = false
-      @experimental_workers = false
-      @foreground_turn_active = false
       @pending_reasoning_config = nil
       @pending_reasoning_config_mutex = Mutex.new
       @color_enabled = ANSI.enabled?($stdout)
@@ -253,7 +250,7 @@ module Kward
         raise ArgumentError, command_usage("rpc") unless @argv.length == 1
 
         ensure_client!
-        Kward::RPC::Server.new(input: @stdin, output: $stdout, client: @client, experimental_workers: @experimental_workers).run
+        Kward::RPC::Server.new(input: @stdin, output: $stdout, client: @client).run
         return
       end
 
@@ -473,25 +470,16 @@ module Kward
           end
         end
         next if handled
-        request_handled, request_replacement = handle_request_worker_input(command_input, agent, session_store)
-        if request_handled
-          if replacement_agent?(request_replacement)
-            agent = active_tab ? replace_active_tab_agent(request_replacement) : request_replacement
-          end
-          next
-        end
         next if shell_command_input?(command_input) && handle_interactive_shell_command(command_input, agent)
 
         flush_pending_reasoning_config(conversation: agent.conversation)
         expanded_input = expand_prompt_template(input)
         display_input = display_input || input if expanded_input
         input = expanded_input || input
-        agent = refresh_implementation_writer(agent)
         @footer_conversation = agent.conversation
         begin
           @rewind_return_leaf_id = nil
           auto_name_active_session(display_input || input)
-          @foreground_turn_active = true if @active_worker_role == "implementation"
           if active_tab
             submit_tab_input(active_tab, input, display_input: display_input)
             pending_inputs = []
@@ -503,9 +491,6 @@ module Kward
           pending_inputs.reverse_each { |pending_input| @pending_inputs.unshift(pending_input) }
         rescue StandardError => e
           runtime_output("Error: #{e.message}")
-        ensure
-          @foreground_turn_active = false if @active_worker_role == "implementation"
-          release_implementation_writer if @active_worker_role == "implementation"
         end
       end
 
@@ -518,7 +503,6 @@ module Kward
     ensure
       begin
         stop_tabs if respond_to?(:stop_tabs, true)
-        stop_live_worker_view if respond_to?(:stop_live_worker_view, true)
         @prompt.close if prompt_interface?
       ensure
         cleanup_unused_sessions