kward 0.74.0 → 0.76.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
@@ -598,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
@@ -209,6 +213,16 @@ module Kward
         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")
@@ -328,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

@@ -10,25 +10,31 @@ module Kward
     module_function
 
     def reasoning(message)
-      direct = MessageAccess.value(message, :reasoning_summary)
-      return direct.to_s unless direct.to_s.empty?
+      reasoning_blocks(message).join("\n")
+    end
+
+    def reasoning_blocks(message)
+      response_blocks = response_items(message).flat_map do |item|
+        next [] unless MessageAccess.value(item, :type) == "reasoning"
+
+        summary = response_item_text_parts(MessageAccess.value(item, :summary))
+        summary.empty? ? response_item_text_parts(MessageAccess.value(item, :content)) : summary
+      end
+      return response_blocks unless response_blocks.empty?
 
       content = MessageAccess.content(message)
       if content.is_a?(Array)
-        text = content.filter_map do |part|
+        blocks = content.filter_map do |part|
           type = MessageAccess.value(part, :type)
           next unless ["thinking", "reasoning"].include?(type)
 
           MessageAccess.value(part, :thinking) || MessageAccess.value(part, :reasoning) || MessageAccess.value(part, :text)
-        end.join("\n")
-        return text unless text.empty?
+        end.map(&:to_s).reject(&:empty?)
+        return blocks unless blocks.empty?
       end
 
-      response_items(message).filter_map do |item|
-        next unless MessageAccess.value(item, :type) == "reasoning"
-
-        response_item_text(MessageAccess.value(item, :summary)).empty? ? response_item_text(MessageAccess.value(item, :content)) : response_item_text(MessageAccess.value(item, :summary))
-      end.join("\n")
+      direct = MessageAccess.value(message, :reasoning_summary).to_s
+      direct.empty? ? [] : [direct]
     end
 
     def content_text(content)
@@ -52,13 +58,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?
@@ -120,11 +119,15 @@ module Kward
     end
 
     def response_item_text(parts)
+      response_item_text_parts(parts).join
+    end
+
+    def response_item_text_parts(parts)
       Array(parts).filter_map do |part|
         next unless part.is_a?(Hash)
 
         MessageAccess.value(part, :text) || MessageAccess.value(part, :refusal)
-      end.join
+      end.map(&:to_s).reject(&:empty?)
     end
 
     def image_part_reference(part)

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