kward 0.73.1 → 0.75.0

data/lib/kward/cli/slash_commands.rb

@@ -19,6 +19,12 @@ module Kward
           activity = memory_summarize_command?(argument) ? "summarizing" : "loading"
           run_busy_local_command_and_requeue(activity: activity) { handle_memory_command(argument, agent) }
           [true, nil]
+        when "hooks"
+          run_busy_local_command_and_requeue { handle_hooks_command(argument) }
+          [true, nil]
+        when "skill"
+          run_busy_local_command_and_requeue { activate_skill_command(argument, agent) }
+          [true, nil]
         when "redraw"
           run_busy_local_command_and_requeue { @prompt.redraw if @prompt.respond_to?(:redraw) }
           [true, nil]
@@ -74,38 +80,16 @@ module Kward
           [true, nil]
         when "new"
           [true, run_busy_local_command_and_requeue { start_new_session(session_store) }]
-        when "sessions", "resume"
-          unless session_store
-            say_sessions_unavailable
-            return [true, nil]
-          end
-
-          path = argument.to_s.strip
-          if path.empty?
-            sessions = run_busy_local_command_and_requeue { session_store.recent_tree(limit: nil) }
-            path = select_session_path_from_sessions(sessions, session_store: session_store)
-          end
-          replacement_agent = nil
-          selection = path
-          loop do
-            replacement_agent = if selection.respond_to?(:conversation)
-                                  selection
-                                elsif selection.is_a?(Hash) && selection[:action] == :clone
-                                  run_busy_local_command_and_requeue(activity: "cloning") { clone_session_from_path(session_store, selection[:path]) }
-                                elsif selection.is_a?(Hash) && selection[:action] == :fork
-                                  selection = reopen_sessions_after_fork(session_store, selection[:path], selection[:choice_label])
-                                  next
-                                elsif selection.to_s.empty?
-                                  nil
-                                else
-                                  run_busy_local_command_and_requeue { resume_session(session_store, selection) }
-                                end
-            break
+        when "session"
+          session_command, session_argument = argument.to_s.split(/\s+/, 2)
+          if session_command == "name"
+            rename_session(session_argument)
+            [true, nil]
+          else
+            [true, open_or_resume_session(session_store, argument)]
           end
-          [true, replacement_agent]
-        when "name"
-          rename_session(argument)
-          [true, nil]
+        when "resume"
+          [true, open_or_resume_session(session_store, argument)]
         when "rename"
           rename_session(argument, require_name: true)
           [true, nil]
@@ -127,7 +111,10 @@ module Kward
           run_busy_local_command_and_requeue(activity: "compacting") { compact_context(agent, argument) }
           [true, nil]
         else
-          if interactive_command_for(name) && prompt_interface? && @prompt.respond_to?(:start_interactive)
+          if name.to_s.start_with?("skill:")
+            run_busy_local_command_and_requeue { activate_skill_command(name.to_s.delete_prefix("skill:"), agent) }
+            [true, nil]
+          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) }
@@ -141,6 +128,56 @@ module Kward
         PromptCommands.parse(command) || [nil, ""]
       end
 
+      def open_or_resume_session(session_store, argument)
+        unless session_store
+          say_sessions_unavailable
+          return nil
+        end
+
+        path = argument.to_s.strip
+        if path.empty?
+          sessions = run_busy_local_command_and_requeue { session_store.recent_tree(limit: nil) }
+          path = select_session_path_from_sessions(sessions, session_store: session_store)
+        end
+
+        selection = path
+        loop do
+          replacement_agent = if selection.respond_to?(:conversation)
+                                selection
+                              elsif selection.is_a?(Hash) && selection[:action] == :clone
+                                run_busy_local_command_and_requeue(activity: "cloning") { clone_session_from_path(session_store, selection[:path]) }
+                              elsif selection.is_a?(Hash) && selection[:action] == :fork
+                                selection = reopen_sessions_after_fork(session_store, selection[:path], selection[:choice_label])
+                                next
+                              elsif selection.to_s.empty?
+                                nil
+                              else
+                                run_busy_local_command_and_requeue { resume_session(session_store, selection) }
+                              end
+          return replacement_agent
+        end
+      end
+
+      def activate_skill_command(name, agent)
+        skill_name = name.to_s.strip
+        if skill_name.empty?
+          runtime_output("Usage: /skill <name>")
+          return
+        end
+
+        tool_call = {
+          "id" => "skill_#{skill_name.gsub(/[^a-zA-Z0-9_-]/, "_")}",
+          "type" => "function",
+          "function" => {
+            "name" => "read_skill",
+            "arguments" => JSON.dump({ name: skill_name })
+          }
+        }
+        agent.conversation.append_assistant("role" => "assistant", "content" => nil, "tool_calls" => [tool_call])
+        result = agent.tool_registry.dispatch(tool_call, agent.conversation)
+        runtime_output(result.start_with?("Error:") ? result : "Activated skill: #{skill_name}")
+      end
+
       def open_session_diff
         unless @active_session&.path
           runtime_output("No active persisted session.")
@@ -413,7 +450,9 @@ module Kward
           reasoning_effort: current_reasoning_effort,
           write_lock: (@worker_write_lock ||= Workers::WriteLock.new),
           worker_store: worker_store,
-          write_lane_available: -> { !@foreground_turn_active }
+          write_lane_available: -> { !@foreground_turn_active },
+          hook_manager: lifecycle_hook_manager(agent.conversation),
+          hook_context: lifecycle_hook_context(agent.conversation)
         )
       end
 
@@ -452,7 +491,7 @@ module Kward
       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(agent)
+        jobs = worker_jobs
         if jobs.empty?
           runtime_output(empty_message)
           return
@@ -466,15 +505,15 @@ module Kward
         open_worker_actions(selected, agent, session_store) if selected
       end
 
-      def worker_jobs(agent)
+      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(agent)].compact + persisted_workers + live_workers
+        [implementation_worker_job].compact + persisted_workers + live_workers
       end
 
-      def implementation_worker_job(agent)
-        remember_implementation_worker(agent) if implementation_agent?(agent)
+      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?
 
@@ -482,18 +521,18 @@ module Kward
           "id" => "implementation",
           "title" => @implementation_worker_title || @active_session&.name || "Implementation",
           "role" => "implementation",
-          "status" => implementation_agent?(agent) ? "active" : "idle",
+          "status" => implementation_agent? ? "active" : "idle",
           "session_path" => path
         }
       end
 
-      def implementation_agent?(agent)
+      def implementation_agent?
         @active_worker_role.to_s.empty? || @active_worker_role == "implementation"
       end
 
-      def remember_implementation_worker(agent)
+      def remember_implementation_worker
         return unless @active_session&.path
-        return unless implementation_agent?(agent)
+        return unless implementation_agent?
 
         @implementation_worker_session_path = @active_session.path
         @implementation_worker_title = @active_session.name || "Implementation"

data/lib/kward/cli/tabs.rb

@@ -28,14 +28,19 @@ module Kward
         :pending_question,
         :shell,
         :error_reported,
+        :local_busy_activity,
         keyword_init: true
       ) do
         def running?
           %w[queued running waiting_for_question].include?(status.to_s)
         end
 
+        def local_busy?
+          !local_busy_activity.to_s.empty?
+        end
+
         def idle?
-          !running?
+          !running? && !local_busy?
         end
 
         def record_event(event)
@@ -121,10 +126,23 @@ module Kward
         conversation.plugin_registry ||= plugin_registry if conversation.respond_to?(:plugin_registry)
         workspace = configured_workspace(root: conversation.workspace_root)
         prompt = TabQuestionPrompt.new(self)
-        tool_registry = ToolRegistry.new(workspace: workspace, prompt: prompt)
+        hook_manager = lifecycle_hook_manager(conversation)
+        hook_context = lifecycle_hook_context(conversation)
+        tool_registry = ToolRegistry.new(
+          workspace: workspace,
+          prompt: prompt,
+          hook_manager: hook_manager,
+          hook_context: hook_context
+        )
         @footer_conversation = conversation
         @footer_tool_registry = tool_registry
-        agent = Agent.new(client: @client, tool_registry: tool_registry, conversation: conversation)
+        agent = Agent.new(
+          client: @client,
+          tool_registry: tool_registry,
+          conversation: conversation,
+          hook_manager: hook_manager,
+          hook_context: hook_context
+        )
         agent.instance_variable_set(:@tab_question_prompt, prompt)
         agent
       end
@@ -150,7 +168,8 @@ module Kward
           unread: false,
           pending_question: nil,
           shell: nil,
-          error_reported: false
+          error_reported: false,
+          local_busy_activity: nil
         ).tap { |tab| assign_tab_question_prompt(agent, tab) }
       end
 
@@ -231,7 +250,7 @@ module Kward
 
       def close_active_tab
         tab = active_tab
-        if tab&.running?
+        if tab&.running? || tab&.local_busy?
           runtime_output("Tab #{active_tab_number} is running and cannot be closed yet.")
           return nil
         end
@@ -312,6 +331,7 @@ module Kward
         update_prompt_tabs
         render_tab(tab) if render
         start_tab_live_view(tab) if tab.running?
+        @prompt.begin_busy_input("You>", activity: tab.local_busy_activity) if tab.local_busy? && @prompt.respond_to?(:begin_busy_input)
         persist_tabs
         service_active_tab_question
         tab.agent
@@ -488,18 +508,15 @@ module Kward
       end
 
       def handle_tab_busy_input(tab, input)
-        command = input.to_s.strip
-        if command == "/workers" || command.start_with?("/workers ") || command == "/tab" || command.start_with?("/tab ")
-          _handled, replacement_agent = handle_local_slash_command(command, tab.agent, @session_store)
-          tab.agent = replacement_agent if replacement_agent?(replacement_agent)
-          restore_busy_input_prompt
-          return
-        end
-
-        if slash_command_input?(input)
+        if busy_queued_command?(input)
           tab.queued_inputs << input
           @prompt.set_queued_count(tab.queued_inputs.length) if @prompt.respond_to?(:set_queued_count)
           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
+          # may have changed by the time the active turn finishes.
+          return
         end
 
         if tab.steering && !input.to_s.strip.empty?
@@ -601,7 +618,7 @@ module Kward
 
       def tab_label_color(tab)
         return :green if tab.status.to_s == "waiting_for_question"
-        return :yellow if tab.running?
+        return :yellow if tab.running? || tab.local_busy?
         return :red if %w[failed cancelled].include?(tab.status.to_s)
         return :green if tab.unread
 

data/lib/kward/cli.rb

@@ -21,6 +21,7 @@ require_relative "auth/github_oauth"
 require_relative "auth/openrouter_api_key"
 require_relative "image_attachments"
 require_relative "memory/manager"
+require_relative "memory/turn_context"
 require_relative "transcript_export"
 require_relative "message_access"
 require_relative "model/model_info"
@@ -38,6 +39,7 @@ require_relative "session_trash"
 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"
@@ -52,6 +54,7 @@ require_relative "cli/openrouter_commands"
 require_relative "cli/runtime_helpers"
 require_relative "cli/slash_commands"
 require_relative "cli/memory_commands"
+require_relative "cli/hook_commands"
 require_relative "cli/settings"
 require_relative "cli/sessions"
 require_relative "cli/tabs"
@@ -66,7 +69,7 @@ require_relative "cli/tool_summaries"
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # Command-line interface for interactive chat, one-shot prompts, login,
-  # telemetry export, Pan server mode, and the experimental JSON-RPC backend.
+  # telemetry export, Pan server mode, and the JSON-RPC backend.
   class CLI
     RESTORED_TOOL_OUTPUT_LIMIT = 2_000
     INTERACTIVE_TOOL_OUTPUT_LINE_LIMIT = 10
@@ -84,6 +87,7 @@ module Kward
     include CLI::RuntimeHelpers
     include CLI::SlashCommands
     include CLI::MemoryCommands
+    include CLI::HookCommands
     include CLI::Settings
     include CLI::Sessions
     include CLI::Tabs
@@ -95,7 +99,7 @@ module Kward
     include CLI::InteractiveTurn
     include CLI::ToolSummaries
 
-    def initialize(argv: ARGV, stdin: STDIN, prompt: TTY::Prompt.new, client: Client.new, session_store: nil, context_usage: ContextUsage.new)
+    def initialize(argv: ARGV, stdin: STDIN, prompt: TTY::Prompt.new, client: nil, session_store: nil, context_usage: ContextUsage.new)
       @argv = argv
       @stdin = stdin
       @prompt = prompt
@@ -109,6 +113,7 @@ module Kward
       @working_directory = nil
       @prompt_delimited = false
       @requested_mode = "auto"
+      @skip_config = false
       @experimental_workers = false
       @foreground_turn_active = false
       @pending_reasoning_config = nil
@@ -122,11 +127,41 @@ module Kward
     # @return [void]
     def run
       @argv = extract_global_options(@argv)
+      ConfigFiles.skip_config = @skip_config
       with_working_directory { dispatch }
+    rescue ConfigFiles::ConfigError => e
+      warn config_error_message(e)
+      exit 1
     rescue ArgumentError => e
       warn e.message
       warn "Run `kward help` for available commands."
       exit 1
+    ensure
+      ConfigFiles.skip_config = false
+    end
+
+    def ensure_client!
+      @client ||= Client.new
+    end
+
+    def config_error_message(error)
+      <<~MESSAGE.rstrip
+        Invalid Kward config #{error.format}.
+
+        File:
+          #{error.path}
+
+        Parser error:
+          #{error.detail}
+
+        Kward cannot safely continue with this config.
+
+        Repair it with:
+          kward edit #{error.path}
+
+        Emergency fallback:
+          kward --skip-config doctor
+      MESSAGE
     end
 
     def dispatch
@@ -173,10 +208,21 @@ module Kward
         end
         raise ArgumentError, command_usage("doctor") unless @argv.length == 1
 
+        ensure_client!
         print_doctor
         return
       end
 
+      if @argv.first == "hooks"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("hooks")
+          return
+        end
+
+        handle_hooks_command((@argv[1..] || []).join(" "))
+        return
+      end
+
       if @argv.first == "edit"
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("edit")
@@ -194,6 +240,7 @@ module Kward
           return
         end
 
+        ensure_client!
         print_sysprompt(@argv[1..] || [])
         return
       end
@@ -205,6 +252,7 @@ module Kward
         end
         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
         return
       end
@@ -226,6 +274,7 @@ module Kward
           return
         end
 
+        ensure_client!
         handle_openrouter_command(@argv[1..] || [])
         return
       end
@@ -237,6 +286,7 @@ module Kward
         end
         raise ArgumentError, command_usage("pan") unless @argv.length == 1
 
+        ensure_client!
         PanServer.new(client: @client, working_directory: current_workspace_root).run
         return
       end
@@ -267,6 +317,7 @@ module Kward
     end
 
     def run_prompt_or_interactive
+      ensure_client!
       stdin_input = read_stdin_input
       first_prompt = one_shot_prompt_argument
 
@@ -291,10 +342,19 @@ module Kward
       markdown_chunks = []
       conversation = new_conversation
       apply_filter_system_prompt(conversation) if filter
+      hook_manager = lifecycle_hook_manager(conversation)
+      hook_context = lifecycle_hook_context(conversation)
       agent = Agent.new(
         client: @client,
-        tool_registry: ToolRegistry.new(workspace: configured_workspace, prompt: @prompt),
-        conversation: conversation
+        tool_registry: ToolRegistry.new(
+          workspace: configured_workspace,
+          prompt: @prompt,
+          hook_manager: hook_manager,
+          hook_context: hook_context
+        ),
+        conversation: conversation,
+        hook_manager: hook_manager,
+        hook_context: hook_context
       )
       answer = if filter
         agent.ask(input)

data/lib/kward/cli_transcript_formatter.rb

@@ -52,13 +52,6 @@ module Kward
       end.join
     end
 
-    def display_text(message)
-      display_content = MessageAccess.display_content(message)
-      return display_content.to_s unless display_content.nil?
-
-      content_text(MessageAccess.content(message))
-    end
-
     def user_display_text(message)
       display_content = MessageAccess.display_content(message)
       return display_content.to_s unless display_content.nil?

data/lib/kward/compaction/token_estimator.rb

@@ -0,0 +1,112 @@
+require "json"
+require_relative "../message_access"
+require_relative "../tools/tool_call"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Conversation compaction settings, planning, and summary generation.
+  module Compaction
+    # Estimates transcript token usage from messages and provider usage metadata.
+    class TokenEstimator
+      def estimate_tokens(text)
+        (text.to_s.length / 4.0).ceil
+      end
+
+      def messages_tokens(messages)
+        Array(messages).sum { |message| message_tokens(message) }
+      end
+
+      def context_tokens(messages)
+        messages = Array(messages)
+        usage_info = last_assistant_usage_info(messages)
+        return messages_tokens(messages) unless usage_info
+
+        usage_tokens = usage_tokens(usage_info[:usage])
+        trailing_tokens = messages[(usage_info[:index] + 1)..].to_a.sum { |message| message_tokens(message) }
+        usage_tokens + trailing_tokens
+      end
+
+      def message_tokens(message)
+        role = value(message, :role)
+        parts = [role]
+        if role.to_s == "compactionSummary"
+          parts << value(message, :summary)
+        else
+          parts << content_text(value(message, :content))
+        end
+        parts << value(message, :reasoning_summary)
+        tool_calls(message).each do |tool_call|
+          parts << tool_call_name(tool_call)
+          parts << tool_call_arguments(tool_call)
+        end
+        parts << value(message, :tool_call_id)
+        parts << value(message, :name)
+        estimate_tokens(parts.compact.join("\n"))
+      end
+
+      private
+
+      def content_text(content)
+        return content.to_s unless content.is_a?(Array)
+
+        content.filter_map do |part|
+          type = value(part, :type)
+          if type == "text"
+            value(part, :text)
+          elsif type == "image"
+            path = value(part, :path)
+            media_type = value(part, :media_type) || value(part, :mimeType) || "image"
+            "[#{media_type}#{path ? ": #{path}" : ""}]"
+          end
+        end.join("\n")
+      end
+
+      def tool_calls(message)
+        MessageAccess.tool_calls(message)
+      end
+
+      def tool_call_name(tool_call)
+        ToolCall.name(tool_call)
+      end
+
+      def tool_call_arguments(tool_call)
+        arguments = ToolCall.raw_arguments(tool_call)
+        arguments.is_a?(Hash) ? JSON.dump(arguments) : arguments.to_s
+      end
+
+      def last_assistant_usage_info(messages)
+        messages.each_with_index.reverse_each do |message, index|
+          next unless value(message, :role).to_s == "assistant"
+
+          usage = value(message, :usage)
+          tokens = usage_tokens(usage)
+          return { usage: usage, index: index } if tokens.positive?
+        end
+        nil
+      end
+
+      def usage_tokens(usage)
+        return 0 unless usage.respond_to?(:key?)
+
+        total = usage_value(usage, :total_tokens, "totalTokens")
+        return total if total.positive?
+
+        usage_value(usage, :input_tokens, "input", "prompt_tokens") +
+          usage_value(usage, :output_tokens, "output", "completion_tokens") +
+          usage_value(usage, :cache_read_tokens, "cacheRead", "cacheReadTokens", "cache_read", "cached_tokens") +
+          usage_value(usage, :cache_write_tokens, "cacheWrite", "cacheWriteTokens", "cache_write")
+      end
+
+      def usage_value(usage, *keys)
+        key = keys.find { |candidate| usage.key?(candidate) || usage.key?(candidate.to_s) }
+        return 0 unless key
+
+        (usage[key] || usage[key.to_s]).to_i
+      end
+
+      def value(object, key)
+        ToolCall.value(object, key)
+      end
+    end
+  end
+end