kward 0.72.0 → 0.73.0

data/lib/kward/cli/runtime_helpers.rb

@@ -125,15 +125,72 @@ module Kward
         shell = tab&.shell || build_ekwsh(agent)
         tab.shell = shell if tab
         runtime_output("Entering ekwsh. Type exit or press Ctrl+D on an empty prompt to return.") if entering
-        run_ekwsh_loop(shell, tab: tab)
+        run_ekwsh_loop(shell, tab: tab, history: build_ekwsh_history(agent))
       end
 
       def build_ekwsh(agent)
         config = ConfigFiles.read_ekwsh_config
-        Ekwsh.new(cwd: interactive_workspace_root(agent), configured_env: config[:env], aliases: config[:aliases])
+        Ekwsh.new(
+          cwd: interactive_workspace_root(agent),
+          configured_env: config[:env],
+          aliases: config[:aliases],
+          shell: config[:shell],
+          timeout_seconds: config[:timeout_seconds],
+          max_output_bytes: config[:max_output_bytes]
+        )
+      end
+
+      def build_ekwsh_history(agent)
+        config = ConfigFiles.read_ekwsh_config
+        PromptHistory.new(
+          cwd: interactive_workspace_root(agent),
+          limit: config[:history_limit],
+          kind: "shell"
+        )
+      end
+
+      def run_interactive_pty_command(command, agent)
+        command = command.to_s.strip
+        if command.empty?
+          runtime_output("Usage: /pty <command>")
+          return
+        end
+
+        config = ConfigFiles.read_ekwsh_config
+        env = interactive_pty_environment(config[:env])
+        cwd = interactive_workspace_root(agent)
+        @prompt.say("$ #{command}\n[interactive PTY session started]\n") if @prompt.respond_to?(:say)
+        result = run_interactive_pty_with_terminal_handoff(config[:shell], command, env: env, cwd: cwd)
+        @prompt.say("[interactive PTY session exited with status #{result.exit_status}]\n") if @prompt.respond_to?(:say)
+      rescue Errno::ENOENT => e
+        runtime_output("Error: #{e.message}")
+      end
+
+      def run_interactive_pty_with_terminal_handoff(shell, command, env:, cwd:)
+        runner = InteractivePtyRunner.new
+        if @prompt.respond_to?(:with_terminal_handoff)
+          @prompt.with_terminal_handoff do |input, output|
+            runner.run(shell, "-c", command, env: env, cwd: cwd, input: input, output: output)
+          end
+        else
+          runner.run(shell, "-c", command, env: env, cwd: cwd)
+        end
       end
 
-      def run_ekwsh_loop(shell, tab: nil)
+      def interactive_pty_environment(configured_env)
+        ENV.to_h.merge(configured_env.to_h.transform_keys(&:to_s).transform_values(&:to_s)).tap do |env|
+          env.delete("GIT_PAGER") if env["GIT_PAGER"] == "cat"
+          env["TERM"] = "xterm-256color" if env["TERM"].to_s.empty? || env["TERM"] == "dumb"
+        end
+      end
+
+      def run_ekwsh_loop(shell, tab: nil, history: nil)
+        with_ekwsh_history(history) do
+          run_ekwsh_loop_with_history(shell, tab: tab)
+        end
+      end
+
+      def run_ekwsh_loop_with_history(shell, tab: nil)
         loop do
           if @prompt.respond_to?(:editing_file?) && @prompt.editing_file?
             editor_result = @prompt.run_editor
@@ -152,13 +209,19 @@ module Kward
 
           result = run_ekwsh_command(shell, input)
           @prompt.clear_transcript if result.clear && @prompt.respond_to?(:clear_transcript)
-          @prompt.say(result.output) unless result.output.to_s.empty?
+          @prompt.say(result.output) unless result.streamed || result.interactive_command || result.output.to_s.empty?
+          return :tab_action if pending_tab_action?
+
           if result.open_editor_path
             editor_result = open_ekwsh_editor(result.open_editor_path, shell)
             return :tab_action if editor_result == :tab_action
 
             next
           end
+          if result.interactive_command
+            run_ekwsh_interactive_pty_command(shell, result)
+            next
+          end
           if result.exit_shell
             tab.shell = nil if tab
             runtime_output("Shell exited.")
@@ -170,6 +233,14 @@ module Kward
         :exited
       end
 
+      def with_ekwsh_history(history)
+        if history && @prompt.respond_to?(:with_prompt_history)
+          @prompt.with_prompt_history(history) { yield }
+        else
+          yield
+        end
+      end
+
       def open_ekwsh_editor(path, shell)
         unless @prompt.respond_to?(:edit_file)
           runtime_output("Integrated editor is unavailable in this prompt.")
@@ -188,21 +259,82 @@ module Kward
       def ask_ekwsh(shell)
         provider = ->(input, cursor) { shell.complete(input, cursor) }
         if @prompt.respond_to?(:with_completion_provider)
-          @prompt.with_completion_provider(provider) { @prompt.ask(shell.prompt_label) }
+          @prompt.with_completion_provider(provider, slash_overlay: false) { @prompt.ask(shell.prompt_label) }
         else
           @prompt.ask(shell.prompt_label)
         end
       end
 
+      def run_ekwsh_interactive_pty_command(shell, result)
+        @prompt.say(result.output) unless result.output.to_s.empty?
+        pty_result = run_interactive_pty_with_terminal_handoff(
+          shell.command_shell,
+          result.interactive_command,
+          env: shell.child_env(interactive: true),
+          cwd: shell.cwd
+        )
+        @prompt.say("[interactive PTY session exited with status #{pty_result.exit_status}]\n") if @prompt.respond_to?(:say)
+      end
+
       def run_ekwsh_command(shell, input)
         if @prompt.respond_to?(:begin_busy_input)
           @prompt.begin_busy_input(shell.prompt_label, activity: "running")
         end
-        shell.run(input)
+        if @prompt.respond_to?(:write_transcript_delta) && @prompt.respond_to?(:poll_input)
+          run_streaming_ekwsh_command(shell, input)
+        elsif @prompt.respond_to?(:write_transcript_delta)
+          shell.run(input) { |chunk| @prompt.write_transcript_delta(chunk) }
+        else
+          shell.run(input)
+        end
       ensure
         @prompt.finish_busy_input if @prompt.respond_to?(:finish_busy_input)
       end
 
+      def run_streaming_ekwsh_command(shell, input)
+        cancellation = Cancellation.new
+        chunks = Queue.new
+        queued_inputs = []
+        result = nil
+        error = nil
+        worker = Thread.new do
+          result = shell.run(input, cancellation: cancellation) { |chunk| chunks << chunk }
+        rescue StandardError => e
+          error = e
+        end
+        worker.report_on_exception = false
+
+        while worker.alive?
+          drain_ekwsh_chunks(chunks)
+          poll_result = collect_queued_input(queued_inputs)
+          if poll_result == PromptInterface::CANCEL_INPUT
+            cancellation.cancel!
+          elsif poll_result.is_a?(Hash) && poll_result[:tab_action]
+            (@pending_inputs ||= []).unshift(poll_result)
+            cancellation.cancel!
+          end
+          sleep 0.01
+        end
+        worker.join
+        drain_ekwsh_chunks(chunks)
+        raise error if error
+
+        queued_inputs.reverse_each { |pending_input| (@pending_inputs ||= []).unshift(pending_input) }
+        result
+      end
+
+      def drain_ekwsh_chunks(chunks)
+        loop do
+          @prompt.write_transcript_delta(chunks.pop(true))
+        rescue ThreadError
+          break
+        end
+      end
+
+      def pending_tab_action?
+        @pending_inputs&.first.is_a?(Hash) && @pending_inputs.first[:tab_action]
+      end
+
       def configured_workspace(root: current_workspace_root)
         Workspace.new(root: root, guardrails: workspace_guardrails_enabled?)
       end
@@ -279,7 +411,9 @@ module Kward
       def refresh_conversation_runtime(conversation, reasoning_effort: current_reasoning_effort, refresh_system_message: true)
         return unless conversation&.respond_to?(:update_runtime_context!)
 
+        runtime_changed = [conversation.provider, conversation.model, conversation.reasoning_effort] != [current_model_provider, current_model_id, reasoning_effort]
         conversation.update_runtime_context!(provider: current_model_provider, model: current_model_id, reasoning_effort: reasoning_effort, refresh: refresh_system_message)
+        conversation.persist_runtime_context! if runtime_changed && conversation.respond_to?(:persist_runtime_context!)
         update_assistant_prompt(conversation)
       end
 
@@ -292,7 +426,7 @@ module Kward
       end
 
       def default_session_name(input)
-        input.to_s.gsub(/\s+/, " ").strip.slice(0, 120).to_s
+        SessionNaming.default_name(input)
       end
 
     end

data/lib/kward/cli/settings.rb

@@ -734,7 +734,6 @@ module Kward
           refresh_reasoning_status
         else
           refresh_conversation_runtime(conversation, reasoning_effort: effort)
-          conversation.persist_runtime_context! if conversation&.respond_to?(:persist_runtime_context!)
           @prompt.redraw if @prompt.respond_to?(:redraw)
         end
       end

data/lib/kward/cli/slash_commands.rb

@@ -25,12 +25,21 @@ module Kward
         when "git"
           handle_git_command(agent)
           [true, nil]
+        when "diff"
+          open_session_diff
+          [true, nil]
         when "files"
           open_project_files_browser
           [true, nil]
         when "shell"
           run_ekwsh(agent)
           [true, nil]
+        when "scratchpad"
+          open_scratchpad_command(argument)
+          [true, nil]
+        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.")
@@ -38,6 +47,13 @@ module Kward
           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"
@@ -125,6 +141,44 @@ module Kward
         PromptCommands.parse(command) || [nil, ""]
       end
 
+      def open_session_diff
+        unless @active_session&.path
+          runtime_output("No active persisted session.")
+          return
+        end
+
+        content = SessionDiff.content_from_session_file(@active_session.path)
+        if content.empty?
+          runtime_output("No file changes recorded in this session.")
+          return
+        end
+
+        if @prompt.respond_to?(:open_modal_diff_viewer)
+          @prompt.open_modal_diff_viewer("Session diff", content)
+        elsif @prompt.respond_to?(:open_diff_viewer)
+          @prompt.open_diff_viewer("Session diff", content)
+        else
+          runtime_output(content)
+        end
+      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.")
+        end
+      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
@@ -164,6 +218,165 @@ 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

data/lib/kward/cli/tabs.rb

@@ -27,6 +27,7 @@ module Kward
         :unread,
         :pending_question,
         :shell,
+        :error_reported,
         keyword_init: true
       ) do
         def running?
@@ -148,7 +149,8 @@ module Kward
           label: label,
           unread: false,
           pending_question: nil,
-          shell: nil
+          shell: nil,
+          error_reported: false
         ).tap { |tab| assign_tab_question_prompt(agent, tab) }
       end
 
@@ -271,6 +273,7 @@ module Kward
         tab.error = nil
         tab.answer = nil
         tab.unread = false
+        tab.error_reported = false
         tab.event_history.clear
         tab.seen_events = 0
         tab.queued_inputs.clear
@@ -326,7 +329,7 @@ module Kward
           else
             render_conversation_transcript(tab.agent.conversation)
           end
-          render_tab_error(tab) if tab.status == "failed"
+          report_tab_runtime_error(tab) if %w[failed cancelled].include?(tab.status.to_s)
         end
         restore_tab_composer_snapshot(tab.snapshot)
       end
@@ -344,8 +347,32 @@ module Kward
         end
       end
 
-      def render_tab_error(tab)
-        runtime_output("Tab #{active_tab_number} error: #{tab.error}") unless tab.error.to_s.empty?
+      def report_tab_runtime_error(tab)
+        return if tab.error_reported
+
+        message = tab_runtime_error_message(tab)
+        return if message.empty?
+
+        tab.error_reported = true
+        runtime_output(message)
+      end
+
+      def tab_runtime_error_message(tab)
+        number = tab_number(tab)
+        case tab.status.to_s
+        when "failed"
+          error = tab.error.to_s.strip
+          error.empty? ? "Tab #{number} error." : "Tab #{number} error: #{error}"
+        when "cancelled"
+          "Tab #{number} cancelled."
+        else
+          ""
+        end
+      end
+
+      def tab_number(tab)
+        index = @tabs&.index(tab)
+        index ? index + 1 : active_tab_number
       end
 
       def submit_tab_input(tab, input, display_input: nil)
@@ -366,6 +393,7 @@ module Kward
         tab.steering = steering_supported? ? Steering.new : nil
         tab.error = nil
         tab.answer = nil
+        tab.error_reported = false
         tab.event_history.clear
         tab.seen_events = 0
         tab.markdown_chunks.clear
@@ -390,10 +418,12 @@ module Kward
       rescue Cancellation::CancelledError
         tab.status = "cancelled"
         tab.unread = false
+        report_tab_runtime_error(tab)
       rescue StandardError => e
         tab.error = e.message
         tab.status = "failed"
         tab.unread = false
+        report_tab_runtime_error(tab)
       ensure
         finish_tab_turn(tab)
       end

data/lib/kward/cli/tool_summaries.rb

@@ -21,6 +21,8 @@ module Kward
           shell_command_summary(args, text)
         when "web_search"
           web_search_summary(args, text)
+        when "read_skill"
+          read_skill_summary(text)
         else
           generic_tool_summary(name, text)
         end
@@ -76,6 +78,10 @@ module Kward
         lines.join("\n")
       end
 
+      def read_skill_summary(content)
+        "read_skill:\n#{content}"
+      end
+
       def error_tool_summary(name, args, content)
         path = args["path"] || args[:path]
         command = args["command"] || args[:command]

data/lib/kward/cli.rb

@@ -9,11 +9,13 @@ require_relative "model/client"
 require_relative "compactor"
 require_relative "config_files"
 require_relative "clipboard"
+require_relative "cancellation"
 require_relative "cli_transcript_formatter"
 require_relative "model/context_usage"
 require_relative "events"
 require_relative "export_path"
 require_relative "ekwsh"
+require_relative "interactive_pty_runner"
 require_relative "auth/anthropic_oauth"
 require_relative "auth/github_oauth"
 require_relative "auth/openrouter_api_key"
@@ -30,6 +32,7 @@ require_relative "model/retry_message"
 require_relative "rpc/server"
 require_relative "session_diff"
 require_relative "session_store"
+require_relative "session_naming"
 require_relative "tab_store"
 require_relative "session_trash"
 require_relative "session_tree_renderer"
@@ -185,17 +188,6 @@ module Kward
         return
       end
 
-      if @argv.first == "count-tests"
-        if help_option_arguments?(@argv[1..] || [])
-          print_command_help("count-tests")
-          return
-        end
-        raise ArgumentError, command_usage("count-tests") unless @argv.length == 1
-
-        print_test_count
-        return
-      end
-
       if @argv.first == "sysprompt"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("sysprompt")
@@ -383,7 +375,7 @@ module Kward
 
       loop do
         if @pending_inputs.empty? && active_tab&.shell
-          run_ekwsh_loop(active_tab.shell, tab: active_tab)
+          run_ekwsh_loop(active_tab.shell, tab: active_tab, history: build_ekwsh_history(active_tab.agent))
         end
         input = @pending_inputs.shift || (active_tab ? poll_active_tab_input : @prompt.ask("You>"))
         if input.is_a?(Hash) && input[:tab_action]

data/lib/kward/clipboard.rb

@@ -1,5 +1,5 @@
-require "base64"
 require "open3"
+require_relative "terminal_sequences"
 require "rbconfig"
 
 # Namespace for the Kward CLI agent runtime.
@@ -39,8 +39,7 @@ module Kward
     end
 
     def write_osc52(content)
-      encoded = Base64.strict_encode64(content)
-      @output.print("\e]52;c;#{encoded}\a")
+      @output.print(TerminalSequences.osc52(content))
       @output.flush if @output.respond_to?(:flush)
     end