kward 0.71.0 → 0.72.0

data/lib/kward/rpc/session_manager.rb

@@ -295,12 +295,21 @@ module Kward
         rpc_sessions = @mutex.synchronize { @sessions.values.dup }
         rpc_sessions.reverse_each do |rpc_session|
           next unless session_idle?(rpc_session)
+          next unless rpc_session.session.respond_to?(:delete_if_unused)
+          next unless rpc_session.session.delete_if_unused
 
-          close_rpc_session(rpc_session)
+          remove_live_session(rpc_session)
         end
         { closed: true }
       end
 
+      # Stops all live RPC session workers during server shutdown.
+      def shutdown_sessions
+        rpc_sessions = @mutex.synchronize { @sessions.values.dup }
+        rpc_sessions.reverse_each { |rpc_session| close_rpc_session(rpc_session) if session_idle?(rpc_session) }
+        { closed: true }
+      end
+
       # Returns the normalized transcript for the active RPC session.
       def transcript(session_id:)
         rpc_session = fetch_session(session_id)
@@ -321,10 +330,7 @@ module Kward
         content = plugin_command ? input.to_s : user_turn_content(expand_prompt_input(input), normalized_attachments)
         streaming_behavior = validate_streaming_behavior(default_streaming_behavior(rpc_session, streaming_behavior), rpc_session: rpc_session)
         if streaming_behavior == "steer"
-          steered_turn = steer_running_turn(rpc_session, content)
-          return steered_turn if steered_turn
-
-          streaming_behavior = "followUp"
+          return steer_running_turn(rpc_session, content)
         end
         turn = Turn.new(
           id: SecureRandom.uuid,
@@ -461,13 +467,7 @@ module Kward
         rpc_session = fetch_session(session_id)
         command = plugin_registry.command_for(command.to_s.delete_prefix("/")) || raise(ArgumentError, "Unknown plugin command: #{command}")
         output = []
-        context = PluginRegistry::Context.new(
-          conversation: rpc_session.conversation,
-          args: arguments.to_s,
-          session: rpc_session.session,
-          workspace_root: rpc_session.workspace_root,
-          say_callback: lambda { |message| output << message.to_s }
-        )
+        context = plugin_context(rpc_session, args: arguments.to_s, say_callback: lambda { |message| output << message.to_s })
         result = command.handler.call(arguments.to_s, context)
         output = rpc_session.plugin_output.shift(rpc_session.plugin_output.length) + output
         { command: command.name, output: output, result: result.nil? ? nil : result.to_s }
@@ -709,10 +709,6 @@ module Kward
         pending_turn_count(rpc_session.id).zero?
       end
 
-      def active_session_count(workspace_root)
-        @mutex.synchronize { @sessions.values.count { |rpc_session| rpc_session.workspace_root == workspace_root } }
-      end
-
       def tool_calls(message)
         MessageAccess.tool_calls(message)
       end
@@ -721,10 +717,6 @@ module Kward
         MessageAccess.role(message)
       end
 
-      def message_content(message)
-        MessageAccess.content(message)
-      end
-
       def session_tree_helper(rpc_session)
         SessionTree.new(rpc_session)
       end
@@ -913,9 +905,7 @@ module Kward
       end
 
       def close_rpc_session(rpc_session, delete_unused: true)
-        @mutex.synchronize { @sessions.delete(rpc_session.id) }
-        stop_worker(rpc_session)
-        stop_footer_worker(rpc_session)
+        remove_live_session(rpc_session)
         rpc_session.session.delete_if_unused if delete_unused && rpc_session.session.respond_to?(:delete_if_unused)
       end
 
@@ -928,12 +918,16 @@ module Kward
           next unless rpc_session.session.respond_to?(:delete_if_unused)
           next unless rpc_session.session.delete_if_unused
 
-          @mutex.synchronize { @sessions.delete(rpc_session.id) }
-          stop_worker(rpc_session)
-          stop_footer_worker(rpc_session)
+          remove_live_session(rpc_session)
         end
       end
 
+      def remove_live_session(rpc_session)
+        @mutex.synchronize { @sessions.delete(rpc_session.id) }
+        stop_worker(rpc_session)
+        stop_footer_worker(rpc_session)
+      end
+
       def stop_worker(rpc_session)
         worker = rpc_session.worker
         return unless worker&.alive?
@@ -1076,21 +1070,23 @@ module Kward
 
         turn.steering.submit(input)
         turn_payload(turn)
-      rescue StandardError
-        nil
       end
 
-      def run_plugin_turn(rpc_session, turn)
-        turn.cancellation&.raise_if_cancelled!
-        command = plugin_registry.command_for(turn.plugin_command_name) || raise(ArgumentError, "Unknown plugin command: #{turn.plugin_command_name}")
-        output = []
-        context = PluginRegistry::Context.new(
+      def plugin_context(rpc_session, args: nil, say_callback:)
+        PluginRegistry::Context.new(
           conversation: rpc_session.conversation,
-          args: turn.plugin_arguments.to_s,
+          args: args,
           session: rpc_session.session,
           workspace_root: rpc_session.workspace_root,
-          say_callback: lambda { |message| output << message.to_s }
+          say_callback: say_callback
         )
+      end
+
+      def run_plugin_turn(rpc_session, turn)
+        turn.cancellation&.raise_if_cancelled!
+        command = plugin_registry.command_for(turn.plugin_command_name) || raise(ArgumentError, "Unknown plugin command: #{turn.plugin_command_name}")
+        output = []
+        context = plugin_context(rpc_session, args: turn.plugin_arguments.to_s, say_callback: lambda { |message| output << message.to_s })
         result = command.handler.call(turn.plugin_arguments.to_s, context)
         answer = (output + [result]).compact.map(&:to_s).reject(&:empty?).join("\n")
         unless answer.empty?
@@ -1103,12 +1099,7 @@ module Kward
       def notify_plugin_transcript_event(rpc_session, event)
         return if plugin_registry.transcript_event_handlers.empty?
 
-        context = PluginRegistry::Context.new(
-          conversation: rpc_session.conversation,
-          session: rpc_session.session,
-          workspace_root: rpc_session.workspace_root,
-          say_callback: lambda { |message| rpc_session.plugin_output << message.to_s }
-        )
+        context = plugin_context(rpc_session, say_callback: lambda { |message| rpc_session.plugin_output << message.to_s })
         plugin_registry.notify_transcript_event(event, context)
       end
 
@@ -1124,6 +1115,8 @@ module Kward
           emit_turn_event(turn, "modelRetry", retry_event_payload(event))
         when Events::Steering
           emit_turn_event(turn, "turnSteered", { input: event.input, createdAt: event.created_at })
+        when Events::SteeringApplied
+          emit_turn_event(turn, "steeringApplied", { count: event.count })
         when Events::ToolCall
           emit_turn_event(turn, "toolCall", normalized_tool_event_payload(event.tool_call))
         when Events::ToolResult
@@ -1160,12 +1153,7 @@ module Kward
         return clear_footer_update(rpc_session) unless renderer
 
         text = begin
-          context = PluginRegistry::Context.new(
-            conversation: rpc_session.conversation,
-            session: rpc_session.session,
-            workspace_root: rpc_session.workspace_root,
-            say_callback: lambda { |message| rpc_session.plugin_output << message.to_s }
-          )
+          context = plugin_context(rpc_session, say_callback: lambda { |message| rpc_session.plugin_output << message.to_s })
           renderer.call(context).to_s.gsub(/\s+/, " ").strip
         rescue StandardError => e
           warn "Warning: Kward plugin footer error: #{e.message}"

data/lib/kward/rpc/session_tree_rows.rb

@@ -1,7 +1,7 @@
 require_relative "../message_access"
 require_relative "../message_text"
+require_relative "../session_tree_nodes"
 require_relative "../session_tree_tool_display"
-require_relative "../tools/tool_call"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -28,13 +28,14 @@ module Kward
       #
       # @return [Array<Hash>] rows for the `session/tree` RPC method
       def rows
-        active_path = tree_active_path(@roots, @current_leaf)
-        tool_calls_by_id = tree_tool_calls(@roots)
-        visible_roots = @roots.flat_map { |root| visible_tree_nodes(root) }
+        tree_nodes = SessionTreeNodes.new(roots: @roots, current_leaf: @current_leaf)
+        active_path = tree_nodes.active_path
+        tool_calls_by_id = tree_nodes.tool_calls
+        visible_roots = tree_nodes.visible_roots
         multiple_roots = visible_roots.length > 1
         result = []
 
-        stack = visible_roots.sort_by { |root| tree_contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
+        stack = visible_roots.sort_by { |root| tree_nodes.contains_active_path?(root, active_path) ? 0 : 1 }.each_with_index.map do |root, index|
           [root, multiple_roots ? 1 : 0, multiple_roots, multiple_roots, index == visible_roots.length - 1, [], multiple_roots]
         end.reverse
 
@@ -60,7 +61,7 @@ module Kward
             prefix: tree_prefix(display_indent, gutters, show_connector && !virtual_root_child, is_last, !node[:children].empty?)
           }.compact
 
-          children = node[:children].sort_by { |child| tree_contains_active_path?(child, active_path) ? 0 : 1 }
+          children = node[:children].sort_by { |child| tree_nodes.contains_active_path?(child, active_path) ? 0 : 1 }
           multiple_children = children.length > 1
           child_indent = if multiple_children
                            indent + 1
@@ -80,112 +81,6 @@ module Kward
 
       private
 
-      def tree_active_path(roots, leaf_id)
-        by_id = tree_entries_by_id(roots)
-        ids = []
-        current = by_id[leaf_id.to_s]
-        seen = {}
-        while current && !seen[current["id"].to_s]
-          seen[current["id"].to_s] = true
-          ids << current["id"].to_s
-          current = by_id[current["parentId"].to_s]
-        end
-        ids
-      end
-
-      def tree_entries_by_id(roots)
-        roots.each_with_object({}) do |root, map|
-          stack = [root]
-          seen = {}
-          until stack.empty?
-            node = stack.pop
-            next if seen[node.object_id]
-
-            seen[node.object_id] = true
-            entry = node["entry"] || {}
-            map[entry["id"].to_s] = entry unless entry["id"].to_s.empty?
-            stack.concat(Array(node["children"]))
-          end
-        end
-      end
-
-      def visible_tree_nodes(node)
-        results = {}
-        stack = [[node, false, {}]]
-
-        until stack.empty?
-          current, visited, seen = stack.pop
-          node_key = current.object_id
-          next if seen[node_key]
-
-          if visited
-            children = Array(current["children"]).flat_map { |child| results[child.object_id] || [] }
-            results[node_key] = if hidden_tree_entry?(current["entry"] || {})
-                                  children
-                                else
-                                  [{ source: current, children: children }]
-                                end
-          else
-            branch_seen = seen.merge(node_key => true)
-            stack << [current, true, seen]
-            Array(current["children"]).reverse_each { |child| stack << [child, false, branch_seen] unless branch_seen[child.object_id] }
-          end
-        end
-
-        results[node.object_id] || []
-      end
-
-      def hidden_tree_entry?(entry)
-        return false if @current_leaf && entry["id"].to_s == @current_leaf.to_s
-        return false unless entry["type"] == "message"
-
-        message = entry["message"]
-        return false unless message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
-
-        content = MessageAccess.content(message)
-        content_tool_calls = content.is_a?(Array) && content.any? { |part| ToolCall.value(part, :type) == "toolCall" }
-        (content_tool_calls && !tree_text_content?(content)) || (!MessageAccess.tool_calls(message).empty? && MessageText.full_text(message).empty?)
-      end
-
-      def tree_text_content?(content)
-        Array(content).any? { |part| ToolCall.value(part, :type) == "text" && ToolCall.value(part, :text).to_s.strip != "" }
-      end
-
-      def tree_contains_active_path?(node, active_path)
-        stack = [node]
-        seen = {}
-        until stack.empty?
-          current = stack.pop
-          next if seen[current.object_id]
-
-          seen[current.object_id] = true
-          entry_id = (current[:source]["entry"] || {})["id"].to_s
-          return true if active_path.include?(entry_id)
-
-          stack.concat(current[:children])
-        end
-        false
-      end
-
-      def tree_tool_calls(roots)
-        roots.each_with_object({}) do |root, tool_calls_by_id|
-          stack = [root]
-          seen = {}
-          until stack.empty?
-            node = stack.pop
-            next if seen[node.object_id]
-
-            seen[node.object_id] = true
-            entry = node["entry"] || {}
-            message = entry["message"]
-            if entry["type"] == "message" && message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
-              MessageAccess.tool_calls(message).each { |tool_call| tool_calls_by_id[ToolCall.id(tool_call).to_s] = tool_call }
-            end
-            stack.concat(Array(node["children"]))
-          end
-        end
-      end
-
       def tree_entry_display(entry, tool_calls_by_id = {})
         case entry["type"]
         when "message"
@@ -237,12 +132,11 @@ module Kward
       end
 
       def display_message_text(message)
-        truncate_tree_text(MessageText.full_text(message))
+        SessionTreeNodes.truncate_text(MessageText.full_text(message))
       end
 
       def truncate_tree_text(text)
-        normalized = text.to_s.gsub(/\s+/, " ").strip
-        normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+        SessionTreeNodes.truncate_text(text)
       end
     end
   end

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -67,7 +67,7 @@ module Kward
       end
 
       def mutation_tool?
-        ["edit", "write"].include?(@fields[:toolName])
+        ToolCall.file_change_tool?(@fields[:toolName])
       end
     end
   end

data/lib/kward/session_store.rb

@@ -178,6 +178,9 @@ module Kward
     # @return [String] workspace directory this store lists and creates sessions for
     attr_reader :cwd
 
+    # @return [String] configuration directory containing session and tab files
+    attr_reader :config_dir
+
     # Creates a new empty session file for the store's workspace directory.
     #
     # Parent fields record clone/fork ancestry; they do not imply live coupling
@@ -285,6 +288,7 @@ module Kward
         session_memories: memory_state["sessionMemories"],
         last_memory_retrieval: memory_state["lastRetrieval"]
       )
+      restore_tool_output_artifacts(records, conversation)
       conversation.mark_last_entry_compaction! if latest_record_type(records) == "compaction"
       session = Session.new(
         store: self,
@@ -561,6 +565,46 @@ module Kward
       records.reverse.find { |record| record["type"] == "memory_state" } || { "sessionMemories" => [], "lastRetrieval" => nil }
     end
 
+    def restore_tool_output_artifacts(records, conversation)
+      tool_names = tool_message_names_by_id(records)
+      records.each do |record|
+        next unless record["type"] == "tool_execution_end"
+
+        content = record.dig("result", "content")
+        next if content.nil?
+
+        tool_name = tool_names[record["toolCallId"].to_s] || raw_tool_name(record["toolName"])
+        next if tool_name.to_s.empty?
+
+        conversation.restore_tool_output_artifact(
+          tool_name: tool_name,
+          content: content,
+          created_at: parse_time(record["timestamp"])
+        )
+      end
+    end
+
+    def tool_message_names_by_id(records)
+      records.each_with_object({}) do |record, names|
+        next unless record["type"] == "message"
+
+        message = record["message"]
+        next unless message.is_a?(Hash) && message_role(message) == "tool"
+
+        tool_call_id = message_tool_call_id(message).to_s
+        names[tool_call_id] = message_name(message) unless tool_call_id.empty? || message_name(message).to_s.empty?
+      end
+    end
+
+    def raw_tool_name(name)
+      {
+        "bash" => "run_shell_command",
+        "edit" => "edit_file",
+        "read" => "read_file",
+        "write" => "write_file"
+      }.fetch(name.to_s, name.to_s)
+    end
+
     def session_runtime(records, header)
       result = {
         "provider" => header["provider"],

data/lib/kward/session_tree_nodes.rb

@@ -0,0 +1,136 @@
+require_relative "message_access"
+require_relative "message_text"
+require_relative "tools/tool_call"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared traversal helpers for persisted session trees.
+  #
+  # Frontends own their final labels or payloads. This class owns only the
+  # frontend-neutral mechanics needed by both terminal and RPC tree views:
+  # active-path lookup, hidden tool-call-only assistant nodes, visible-node
+  # flattening, and assistant tool-call lookup by id.
+  class SessionTreeNodes
+    def initialize(roots:, current_leaf: nil)
+      @roots = roots
+      @current_leaf = current_leaf
+    end
+
+    def active_path
+      by_id = entries_by_id
+      ids = []
+      entry = by_id[@current_leaf.to_s]
+      seen = {}
+      while entry && !seen[entry["id"].to_s]
+        seen[entry["id"].to_s] = true
+        ids << entry["id"].to_s
+        entry = by_id[entry["parentId"].to_s]
+      end
+      ids
+    end
+
+    def visible_roots
+      @roots.flat_map { |root| visible_nodes(root) }
+    end
+
+    def contains_active_path?(node, active_path)
+      stack = [node]
+      seen = {}
+      until stack.empty?
+        current = stack.pop
+        next if seen[current.object_id]
+
+        seen[current.object_id] = true
+        entry_id = (current[:source]["entry"] || {})["id"].to_s
+        return true if active_path.include?(entry_id)
+
+        stack.concat(current[:children])
+      end
+      false
+    end
+
+    def tool_calls
+      @roots.each_with_object({}) do |root, calls|
+        stack = [root]
+        seen = {}
+        until stack.empty?
+          node = stack.pop
+          next if seen[node.object_id]
+
+          seen[node.object_id] = true
+          entry = node["entry"] || {}
+          message = entry["message"]
+          if entry["type"] == "message" && message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
+            MessageAccess.tool_calls(message).each { |tool_call| calls[ToolCall.id(tool_call).to_s] = tool_call }
+          end
+          stack.concat(Array(node["children"]))
+        end
+      end
+    end
+
+    def self.truncate_text(text)
+      normalized = text.to_s.gsub(/\s+/, " ").strip
+      normalized.length > 120 ? "#{normalized.slice(0, 117)}..." : normalized
+    end
+
+    private
+
+    def visible_nodes(node)
+      results = {}
+      stack = [[node, false, {}]]
+
+      until stack.empty?
+        current, visited, seen = stack.pop
+        node_key = current.object_id
+        next if seen[node_key]
+
+        if visited
+          children = Array(current["children"]).flat_map { |child| results[child.object_id] || [] }
+          results[node_key] = if hidden_entry?(current["entry"] || {})
+                                children
+                              else
+                                [{ source: current, children: children }]
+                              end
+        else
+          branch_seen = seen.merge(node_key => true)
+          stack << [current, true, seen]
+          Array(current["children"]).reverse_each { |child| stack << [child, false, branch_seen] unless branch_seen[child.object_id] }
+        end
+      end
+
+      results[node.object_id] || []
+    end
+
+    def hidden_entry?(entry)
+      return false if @current_leaf && entry["id"].to_s == @current_leaf.to_s
+      return false unless entry["type"] == "message"
+
+      message = entry["message"]
+      return false unless message.is_a?(Hash) && MessageAccess.role(message) == "assistant"
+
+      content = MessageAccess.content(message)
+      content_tool_calls = content.is_a?(Array) && content.any? { |part| MessageAccess.value(part, :type) == "toolCall" }
+      (content_tool_calls && !text_content?(content)) || (!MessageAccess.tool_calls(message).empty? && MessageText.full_text(message).empty?)
+    end
+
+    def text_content?(content)
+      Array(content).any? { |part| MessageAccess.value(part, :type) == "text" && MessageAccess.value(part, :text).to_s.strip != "" }
+    end
+
+    def entries_by_id
+      @roots.each_with_object({}) do |root, map|
+        stack = [root]
+        seen = {}
+        until stack.empty?
+          node = stack.pop
+          next if seen[node.object_id]
+
+          seen[node.object_id] = true
+          entry = node["entry"] || {}
+          map[entry["id"].to_s] = entry unless entry["id"].to_s.empty?
+          stack.concat(Array(node["children"]))
+        end
+      end
+    end
+  end
+end