kward 0.71.0 → 0.73.0

data/lib/kward/rpc/session_manager.rb

@@ -18,6 +18,7 @@ require_relative "../model/model_info"
 require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../session_store"
+require_relative "../session_naming"
 require_relative "../session_trash"
 require_relative "../steering"
 require_relative "../tools/tool_call"
@@ -26,6 +27,7 @@ require_relative "../transcript_export"
 require_relative "../workspace"
 require_relative "attachment_normalizer"
 require_relative "config_manager"
+require_relative "memory_methods"
 require_relative "prompt_bridge"
 require_relative "runtime_payloads"
 require_relative "session_metrics"
@@ -51,6 +53,8 @@ module Kward
     # `ToolRegistry`. This class should coordinate those pieces rather than own
     # their low-level mechanics.
     class SessionManager
+      include MemoryMethods
+
       RECENT_EVENT_LIMIT = 1_000
       RPC_ATTACHMENT_MAX_BYTES = AttachmentNormalizer::MAX_BYTES
       RPC_IMAGE_MIME_TYPES = AttachmentNormalizer::IMAGE_MIME_TYPES
@@ -295,12 +299,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 +334,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,
@@ -385,89 +395,11 @@ module Kward
         run_plugin_command(session_id: session_id, command: name, arguments: arguments)
       end
 
-      def memory_manager
-        Memory::Manager.for_config_dir(@config_dir)
-      end
-
-      def memory_status
-        manager = memory_manager
-        { enabled: manager.enabled?, autoSummary: manager.auto_summary_enabled?, paths: manager.paths }
-      end
-
-      def memory_enable
-        memory_manager.enable
-        { enabled: true }
-      end
-
-      def memory_disable
-        memory_manager.disable
-        { enabled: false }
-      end
-
-      def memory_auto_summary_enable
-        memory_manager.auto_summary_enable
-        { autoSummary: true }
-      end
-
-      def memory_auto_summary_disable
-        memory_manager.auto_summary_disable
-        { autoSummary: false }
-      end
-
-      def memory_list(include_inactive: false, workspace_root: Dir.pwd)
-        memory_manager.hierarchy(include_inactive: include_inactive, workspace_root: workspace_root)
-      end
-
-      def memory_add(text:, scope: nil, tags: [])
-        { memory: memory_manager.add_soft(text, scope: scope || "global", tags: tags) }
-      end
-
-      def memory_add_core(text:, scope: nil, tags: [])
-        { memory: memory_manager.add_core(text, scope: scope || "global", tags: tags) }
-      end
-
-      def memory_forget(id:)
-        { forgotten: memory_manager.forget_memory(id) }
-      end
-
-      def memory_promote(id:)
-        { memory: memory_manager.promote_memory(id) }
-      end
-
-      def memory_relax(id:, workspace_root: Dir.pwd)
-        { memory: memory_manager.relax_core(id, workspace_root: workspace_root) }
-      end
-
-      def memory_inspect
-        memory_manager.inspect_memory
-      end
-
-      def memory_why(session_id: nil)
-        if session_id
-          rpc_session = fetch_session(session_id)
-          return rpc_session.conversation.last_memory_retrieval || memory_manager.explain_retrieval
-        end
-        memory_manager.explain_retrieval
-      end
-
-      def memory_summarize(session_id:)
-        rpc_session = fetch_session(session_id)
-        records = memory_manager.summarize_conversation(rpc_session.conversation, client: @client)
-        persist_memory_state(rpc_session)
-        { memories: records }
-      end
-
       def run_plugin_command(session_id:, command:, arguments: "")
         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 }
@@ -613,11 +545,15 @@ module Kward
       end
 
       def refresh_session_runtime_contexts
+        provider = current_model[:provider]
         model = current_model_id
         reasoning_effort = current_reasoning_effort
         sessions = @mutex.synchronize { @sessions.values }
         sessions.each do |rpc_session|
-          rpc_session.conversation.update_runtime_context!(provider: current_model[:provider], model: model, reasoning_effort: reasoning_effort)
+          conversation = rpc_session.conversation
+          runtime_changed = [conversation.provider, conversation.model, conversation.reasoning_effort] != [provider, model, reasoning_effort]
+          conversation.update_runtime_context!(provider: provider, model: model, reasoning_effort: reasoning_effort)
+          conversation.persist_runtime_context! if runtime_changed
         end
       end
 
@@ -709,10 +645,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 +653,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 +841,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 +854,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?
@@ -1042,7 +972,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
 
       def turn_display_input(turn)
@@ -1076,21 +1006,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 +1035,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 +1051,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 +1089,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/rpc/tool_metadata.rb

@@ -75,6 +75,17 @@ module Kward
         index ? text.to_s[index..] : nil
       end
 
+      def changed_files_from_result(text, matching_call = nil)
+        path = matching_call&.dig(:arguments, :path) || matching_call&.dig(:arguments, "path")
+        return [path] if path
+
+        if (match = text.to_s.match(/\A(?:Wrote \d+ bytes to|Edited)\s+([^:\n]+)/))
+          [match[1].strip]
+        else
+          []
+        end
+      end
+
       def error_result?(text)
         text.to_s.start_with?("Error:", "Declined:", "Cancelled.")
       end

data/lib/kward/rpc/transcript_normalizer.rb

@@ -106,7 +106,7 @@ module Kward
           type: "toolCall",
           id: ToolCall.id(tool_call),
           name: normalize_tool_name(raw_name) || raw_name,
-          arguments: normalize_tool_arguments(raw_name, ToolCall.raw_arguments(tool_call))
+          arguments: ToolMetadata.normalize_tool_args(raw_name, ToolCall.parse_arguments(ToolCall.raw_arguments(tool_call)))
         }.compact
       end
 
@@ -235,7 +235,7 @@ module Kward
           type: "toolCall",
           id: ToolCall.value(part, :id),
           name: normalize_tool_name(raw_name) || raw_name,
-          arguments: normalize_tool_arguments(raw_name, arguments)
+          arguments: ToolMetadata.normalize_tool_args(raw_name, ToolCall.parse_arguments(arguments))
         }.compact
       end
 
@@ -244,10 +244,10 @@ module Kward
         details = explicit_details.is_a?(Hash) ? safe_details(explicit_details) : {}
         text = content_text(content)
 
-        diff = details[:diff] || details["diff"] || extract_unified_diff(text)
+        diff = details[:diff] || details["diff"] || ToolMetadata.extract_unified_diff(text)
         details[:diff] = diff if diff
 
-        changed_files = details[:changedFiles] || details["changedFiles"] || changed_files_from_result(text, matching_call)
+        changed_files = details[:changedFiles] || details["changedFiles"] || ToolMetadata.changed_files_from_result(text, matching_call)
         details[:changedFiles] = changed_files if changed_files && !changed_files.empty?
 
         details
@@ -262,21 +262,6 @@ module Kward
         allowed
       end
 
-      def extract_unified_diff(text)
-        ToolMetadata.extract_unified_diff(text)
-      end
-
-      def changed_files_from_result(text, matching_call)
-        path = matching_call&.dig(:arguments, :path) || matching_call&.dig(:arguments, "path")
-        return [path] if path
-
-        if (match = text.match(/\A(?:Wrote \d+ bytes to|Edited)\s+([^:\n]+)/))
-          [match[1].strip]
-        else
-          []
-        end
-      end
-
       def error_tool_result?(message, content)
         return ToolCall.value(message, :isError) if has_key?(message, :isError)
         return ToolCall.value(message, :is_error) if has_key?(message, :is_error)
@@ -299,26 +284,6 @@ module Kward
         ToolMetadata.normalize_tool_name(name)
       end
 
-      def normalize_tool_arguments(name, arguments)
-        args = ToolCall.parse_arguments(arguments)
-        case name.to_s
-        when "edit_file", "edit"
-          ToolMetadata.normalize_tool_args(name, args)
-        when "run_shell_command", "bash"
-          normalize_bash_args(args)
-        else
-          ToolCall.camelize_args(args)
-        end
-      end
-
-      def normalize_bash_args(args)
-        normalized = ToolCall.camelize_args(args)
-        timeout = ToolCall.value(args, :timeoutSeconds) || ToolCall.value(args, :timeout_seconds)
-        normalized[:timeoutSeconds] = timeout if timeout
-        normalized.delete(:timeout_seconds)
-        normalized
-      end
-
       def normalize_mime_type(mime_type)
         mime_type.to_s.downcase.sub("image/jpg", "image/jpeg")
       end

data/lib/kward/scratchpad_runner.rb

@@ -0,0 +1,56 @@
+require "open3"
+require "rbconfig"
+require "tempfile"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Executes scratchpad buffers and returns transformed buffer content.
+  module ScratchpadRunner
+    RUBY_END_MARKER_PATTERN = /^__END__\n?/.freeze
+
+    Result = Struct.new(:buffer, :exit_status, keyword_init: true)
+
+    module_function
+
+    def run(language, content)
+      case language&.to_sym
+      when :ruby
+        run_ruby(content)
+      else
+        raise ArgumentError, "Scratchpad language #{language.inspect} is not runnable"
+      end
+    end
+
+    def run_ruby(content)
+      content = content.to_s
+      output, status = capture_ruby_output(content)
+      Result.new(buffer: ruby_buffer_with_output(content, output, status.exitstatus), exit_status: status.exitstatus)
+    end
+
+    def capture_ruby_output(content)
+      Tempfile.create(["kward-scratchpad", ".rb"]) do |file|
+        file.write(content)
+        file.flush
+        Open3.capture2e(RbConfig.ruby, file.path)
+      end
+    end
+
+    def ruby_buffer_with_output(content, output, exit_status)
+      output = output.to_s
+      output += "\n" unless output.empty? || output.end_with?("\n")
+      output += "[exit status: #{exit_status}]\n" unless exit_status.to_i.zero?
+
+      if (match = content.match(RUBY_END_MARKER_PATTERN))
+        "#{content[0...match.begin(0)]}__END__\n#{output}"
+      else
+        "#{content}#{ruby_end_separator(content)}__END__\n#{output}"
+      end
+    end
+
+    def ruby_end_separator(content)
+      return "" if content.empty?
+
+      content.end_with?("\n") ? "\n" : "\n\n"
+    end
+  end
+end

data/lib/kward/session_diff.rb

@@ -25,20 +25,37 @@ module Kward
       new
     end
 
+    def self.content_from_session_file(path)
+      records = File.readlines(path, chomp: true).filter_map { |line| parse_record(line) }
+      content_from_records(records)
+    rescue Errno::ENOENT, Errno::EACCES
+      ""
+    end
+
     def self.from_records(records)
       execution_records = records.select { |record| record["type"] == "tool_execution_end" }
       source_records = execution_records.empty? ? records : execution_records
       source_records.each_with_object(new) do |record, diff|
         if record["type"] == "tool_execution_end"
-          next if record["isError"] || record.dig("result", "isError")
-
-          diff.add_diff(record.dig("result", "diff"))
+          diff.add_diff(record_diff(record))
         elsif record["type"] == "message" && (record.dig("message", "role") == "tool" || record.dig("message", :role) == "tool")
           diff.add_tool_result(record.dig("message", "content") || record.dig("message", :content))
         end
       end
     end
 
+    def self.content_from_records(records)
+      records.filter_map { |record| record_diff(record) }.join("\n")
+    end
+
+    def self.record_diff(record)
+      return nil unless record["type"] == "tool_execution_end"
+      return nil if record["isError"] || record.dig("result", "isError")
+
+      diff = record.dig("result", "diff").to_s
+      diff.empty? ? nil : diff
+    end
+
     def self.count(diff)
       if (stats = truncated_diff_stats(diff))
         return stats

data/lib/kward/session_naming.rb

@@ -0,0 +1,11 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared session-name formatting for CLI and RPC session auto-naming.
+  module SessionNaming
+    module_function
+
+    def default_name(input)
+      input.to_s.gsub(/\s+/, " ").strip.slice(0, 120).to_s
+    end
+  end
+end