kward 0.76.0 → 0.78.0

data/lib/kward/rpc/session_manager.rb

@@ -62,10 +62,11 @@ module Kward
       RPC_IMAGE_MIME_TYPES = AttachmentNormalizer::IMAGE_MIME_TYPES
       STREAMING_BEHAVIORS = ["newTurn", "followUp", "steer"].freeze
       FOOTER_REFRESH_INTERVAL = 1.0
+      WORKER_STOP_TIMEOUT = 2.0
       WORKER_STOP = Object.new.freeze
 
       RpcSession = Struct.new(:id, :workspace_root, :store, :session, :conversation, :agent, :tool_registry, :prompt, :plugin_output, :queue, :worker, :running_turn_id, :footer_worker, :last_footer_text, keyword_init: true)
-      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, :options, :tool_registry, keyword_init: true)
+      Turn = Struct.new(:id, :session_id, :input, :display_input, :status, :cancel_requested, :cancellation, :created_at, :started_at, :finished_at, :events, :next_sequence, :error, :streaming_behavior, :plugin_command_name, :plugin_arguments, :steering, :options, :tool_registry, :mutex, keyword_init: true)
 
       # Creates an object for RPC session lifecycle and turn coordination.
       def initialize(
@@ -74,7 +75,8 @@ module Kward
         config_dir: ConfigFiles.config_dir,
         config_manager: ConfigManager.new(config_path: File.join(config_dir, "config.json")),
         context_usage: ContextUsage.new,
-        session_trash: SessionTrash.new
+        session_trash: SessionTrash.new,
+        worker_stop_timeout: WORKER_STOP_TIMEOUT
       )
         @server = server
         @client = client
@@ -83,6 +85,7 @@ module Kward
         @context_usage = context_usage
         @session_metrics = SessionMetrics.new(context_usage: context_usage)
         @session_trash = session_trash
+        @worker_stop_timeout = worker_stop_timeout
         @sessions = {}
         @turns = {}
         @mutex = Mutex.new
@@ -140,7 +143,11 @@ module Kward
         store = SessionStore.new(config_dir: @config_dir, cwd: root)
         requested_limit = limit.to_i if limit
         requested_limit = nil unless requested_limit&.positive?
-        store.recent(limit: requested_limit, keep_empty_path: current_session_path)
+        live_paths = @mutex.synchronize do
+          @sessions.values.filter_map { |rpc_session| rpc_session.session.path if rpc_session.workspace_root == root }
+        end
+        live_paths << current_session_path unless current_session_path.to_s.empty?
+        store.recent(limit: requested_limit, keep_empty_path: live_paths)
              .map { |info| session_info_payload(info, workspace_root: root) }
       end
 
@@ -325,7 +332,7 @@ module Kward
       # 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) }
+        rpc_sessions.reverse_each { |rpc_session| close_rpc_session(rpc_session) }
         { closed: true }
       end
 
@@ -368,7 +375,8 @@ module Kward
           plugin_command_name: plugin_command&.name,
           plugin_arguments: plugin_arguments,
           options: normalized_options,
-          tool_registry: scoped_tool_registry(rpc_session, normalized_options)
+          tool_registry: scoped_tool_registry(rpc_session, normalized_options),
+          mutex: Mutex.new
         )
         @mutex.synchronize { @turns[turn.id] = turn }
         rpc_session.queue << turn.id
@@ -379,12 +387,13 @@ module Kward
 
       def cancel_turn(turn_id:)
         turn = fetch_turn(turn_id)
-        turn.cancel_requested = true
-        turn.cancellation&.cancel!
-        emit_turn_event(turn, "turnCancelRequested", {})
-        if turn.status == "queued"
-          finish_turn(turn, "canceled")
+        queued, event = turn.mutex.synchronize do
+          turn.cancel_requested = true
+          [turn.status == "queued", append_turn_event_locked(turn, "turnCancelRequested", {})]
         end
+        @server.notify("turn/event", event)
+        turn.cancellation&.cancel!
+        finish_turn(turn, "canceled") if queued
         turn_payload(turn)
       end
 
@@ -395,10 +404,12 @@ module Kward
       def turn_events(turn_id:, after_sequence: 0)
         turn = fetch_turn(turn_id)
         after_sequence = after_sequence.to_i
-        {
-          turn: turn_payload(turn),
-          events: turn.events.select { |event| event[:sequence].to_i > after_sequence }
-        }
+        turn.mutex.synchronize do
+          {
+            turn: turn_payload_unlocked(turn),
+            events: turn.events.select { |event| event[:sequence].to_i > after_sequence }
+          }
+        end
       end
 
       def list_turns(session_id: nil, active: false)
@@ -957,6 +968,7 @@ module Kward
           prompt: prompt,
           allowed_tool_names: allowed_tool_names,
           tool_approval: tool_approval,
+          approval_for_allowed_tools: !tool_approval.nil?,
           hook_manager: hook_manager,
           hook_context: hook_context
         )
@@ -1043,6 +1055,8 @@ module Kward
       end
 
       def close_rpc_session(rpc_session, delete_unused: true)
+        turns = cancel_session_turns(rpc_session)
+        turns.each { |turn| finish_turn(turn, "canceled") } if stop_worker(rpc_session, wait: true)
         remove_live_session(rpc_session)
         rpc_session.session.delete_if_unused if delete_unused && rpc_session.session.respond_to?(:delete_if_unused)
       end
@@ -1066,12 +1080,28 @@ module Kward
         stop_footer_worker(rpc_session)
       end
 
-      def stop_worker(rpc_session)
+      def stop_worker(rpc_session, wait: false)
         worker = rpc_session.worker
-        return unless worker&.alive?
-        return if worker == Thread.current
+        return false unless worker&.alive?
+        return false if worker == Thread.current
 
         rpc_session.queue << WORKER_STOP
+        return false unless wait
+
+        worker.join(@worker_stop_timeout)
+        return false unless worker.alive?
+
+        worker.kill
+        worker.join
+        true
+      end
+
+      def cancel_session_turns(rpc_session)
+        turns = @mutex.synchronize do
+          @turns.values.select { |turn| turn.session_id == rpc_session.id && ["queued", "running"].include?(turn.status) }
+        end
+        turns.each { |turn| cancel_turn(turn_id: turn.id) }
+        turns
       end
 
       def start_footer_worker(rpc_session)
@@ -1128,11 +1158,18 @@ module Kward
       def run_turn(rpc_session, turn)
         previous_turn_id = Thread.current[:kward_rpc_turn_id]
         Thread.current[:kward_rpc_turn_id] = turn.id
+        started, event = turn.mutex.synchronize do
+          next [false, nil] if turn.status == "canceled"
+
+          turn.status = "running"
+          turn.started_at = now
+          [true, append_turn_event_locked(turn, "turnStarted", { status: "running" })]
+        end
+        return unless started
+
+        @server.notify("turn/event", event)
         rpc_session.running_turn_id = turn.id
         turn.steering = build_steering(turn) if supports_in_flight_steer? && !turn.plugin_command_name
-        turn.status = "running"
-        turn.started_at = now
-        emit_turn_event(turn, "turnStarted", { status: "running" })
 
         if turn.cancel_requested
           finish_turn(turn, "canceled")
@@ -1292,11 +1329,16 @@ module Kward
       end
 
       def finish_turn(turn, status)
-        return if ["completed", "failed", "canceled"].include?(turn.status)
+        event = turn.mutex.synchronize do
+          next nil if ["completed", "failed", "canceled"].include?(turn.status)
+
+          turn.status = status
+          turn.finished_at = now
+          append_turn_event_locked(turn, "turnFinished", { status: status, error: turn.error })
+        end
+        return unless event
 
-        turn.status = status
-        turn.finished_at = now
-        emit_turn_event(turn, "turnFinished", { status: status, error: turn.error })
+        @server.notify("turn/event", event)
         rpc_session = @mutex.synchronize { @sessions[turn.session_id] }
         emit_footer_update(rpc_session) if rpc_session
       end
@@ -1326,6 +1368,12 @@ module Kward
       end
 
       def emit_turn_event(turn, type, payload)
+        event = turn.mutex.synchronize { append_turn_event_locked(turn, type, payload) }
+        @server.notify("turn/event", event)
+        event
+      end
+
+      def append_turn_event_locked(turn, type, payload)
         event = {
           sequence: turn.next_sequence,
           timestamp: now,
@@ -1337,7 +1385,6 @@ module Kward
         turn.next_sequence += 1
         turn.events << event
         turn.events.shift while turn.events.length > RECENT_EVENT_LIMIT
-        @server.notify("turn/event", event)
         event
       end
 
@@ -1351,6 +1398,10 @@ module Kward
       end
 
       def turn_payload(turn)
+        turn.mutex.synchronize { turn_payload_unlocked(turn) }
+      end
+
+      def turn_payload_unlocked(turn)
         {
           id: turn.id,
           sessionId: turn.session_id,

data/lib/kward/rpc/tool_event_normalizer.rb

@@ -65,6 +65,8 @@ module Kward
           if mutation_tool?
             diff = ToolMetadata.extract_unified_diff(text)
             result[:diff] = diff if diff
+            first_changed_line = ToolMetadata.first_changed_line(diff)
+            result[:firstChangedLine] = first_changed_line if first_changed_line
           end
 
           files = changed_files

data/lib/kward/rpc/tool_metadata.rb

@@ -75,6 +75,29 @@ module Kward
         index ? text.to_s[index..] : nil
       end
 
+      # Returns the first changed line in the post-edit file from a unified diff.
+      # A deletion-only hunk uses the next surviving new-file line as its anchor.
+      def first_changed_line(diff)
+        new_line = nil
+
+        diff.to_s.each_line do |line|
+          if (match = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/))
+            new_line = match[1].to_i
+          elsif new_line
+            case line
+            when /^\+[^+]/
+              return new_line
+            when /^-[^-]/
+              return new_line
+            when /^ /
+              new_line += 1
+            end
+          end
+        end
+
+        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

data/lib/kward/rpc/transcript_normalizer.rb

@@ -54,10 +54,13 @@ module Kward
       end
 
       def normalize_user_message(message)
-        {
-          role: "user",
-          content: normalize_content(MessageAccess.content(message))
-        }
+        with_timestamp(
+          {
+            role: "user",
+            content: normalize_content(MessageAccess.content(message))
+          },
+          message
+        )
       end
 
       def normalize_assistant_message(message)
@@ -76,7 +79,7 @@ module Kward
         result = { role: "assistant", content: content }
         error_message = ToolCall.value(message, :errorMessage) || ToolCall.value(message, :error_message)
         result[:errorMessage] = error_message unless error_message.to_s.empty?
-        result
+        with_timestamp(result, message)
       end
 
       def normalize_tool_result_message(message)
@@ -96,6 +99,12 @@ module Kward
 
         details = tool_result_details(message, matching_call, content)
         result[:details] = details unless details.empty?
+        with_timestamp(result, message)
+      end
+
+      def with_timestamp(result, message)
+        timestamp = ToolCall.value(message, :timestamp)
+        result[:timestamp] = timestamp if timestamp
         result
       end
 
@@ -246,6 +255,8 @@ module Kward
 
         diff = details[:diff] || details["diff"] || ToolMetadata.extract_unified_diff(text)
         details[:diff] = diff if diff
+        first_changed_line = details[:firstChangedLine] || details["firstChangedLine"] || ToolMetadata.first_changed_line(diff)
+        details[:firstChangedLine] = first_changed_line if first_changed_line
 
         changed_files = details[:changedFiles] || details["changedFiles"] || ToolMetadata.changed_files_from_result(text, matching_call)
         details[:changedFiles] = changed_files if changed_files && !changed_files.empty?
@@ -257,6 +268,8 @@ module Kward
         allowed = {}
         diff = ToolCall.value(details, :diff)
         allowed[:diff] = diff if diff
+        first_changed_line = ToolCall.value(details, :firstChangedLine) || ToolCall.value(details, :first_changed_line)
+        allowed[:firstChangedLine] = first_changed_line if first_changed_line.is_a?(Integer) && first_changed_line.positive?
         changed_files = ToolCall.value(details, :changedFiles) || ToolCall.value(details, :changed_files)
         allowed[:changedFiles] = changed_files if changed_files.is_a?(Array)
         allowed

data/lib/kward/session_store.rb

@@ -309,11 +309,10 @@ module Kward
     # Lists recent non-empty sessions for this workspace.
     #
     # @param limit [Integer, nil] maximum number of sessions, or nil for all
-    # @param keep_empty_path [String, nil] empty session path to keep visible
+    # @param keep_empty_path [String, Array<String>, nil] live empty session path(s) to preserve while omitting them from results
     # @return [Array<SessionInfo>] newest sessions first
     def recent(limit: 20, keep_empty_path: nil)
-      sessions = recent_sessions(keep_empty_path: keep_empty_path)
-      limit ? sessions.first(limit) : sessions
+      recent_sessions(limit: limit, keep_empty_path: keep_empty_path)
     end
 
     # Persists the last active session pointer for workspace auto-resume.
@@ -344,9 +343,7 @@ module Kward
     #
     # @return [Array<SessionInfo>] recent sessions with tree depth fields
     def recent_tree(limit: 20, keep_empty_path: nil)
-      sessions = recent_sessions(keep_empty_path: keep_empty_path)
-      sessions = sessions.first(limit) if limit
-      decorate_tree(sessions)
+      decorate_tree(recent_sessions(limit: limit, keep_empty_path: keep_empty_path))
     end
 
     # Deletes an empty unnamed session file.
@@ -770,20 +767,30 @@ module Kward
       nil
     end
 
-    def recent_sessions(keep_empty_path: nil)
-      keep_empty_path = File.expand_path(keep_empty_path) unless keep_empty_path.to_s.empty?
-      Dir.glob(File.join(session_dir, "*.jsonl")).filter_map do |path|
-        info = session_info(path)
-        next unless info
-        next if delete_empty_unnamed_session_info(info, keep_empty_path: keep_empty_path)
+    def recent_sessions(limit: nil, keep_empty_path: nil)
+      keep_empty_paths = Array(keep_empty_path).filter_map do |path|
+        File.expand_path(path) unless path.to_s.empty?
+      end
+      paths = Dir.glob(File.join(session_dir, "*.jsonl")).sort_by { |path| session_file_mtime(path) }.reverse
+      sessions = []
+
+      paths.each do |path|
+        if limit.nil? || sessions.length < limit
+          info = session_info(path)
+          next unless info
+          next if delete_empty_unnamed_session_info(info, keep_empty_paths: keep_empty_paths)
 
-        info
-      end.sort_by { |info| info.modified_at || Time.at(0) }.reverse
+          sessions << info
+        else
+          delete_empty_unnamed_session_path(path, keep_empty_paths: keep_empty_paths)
+        end
+      end
+      sessions
     end
 
-    def delete_empty_unnamed_session_info(info, keep_empty_path: nil)
+    def delete_empty_unnamed_session_info(info, keep_empty_paths: [])
       return false unless info.name.to_s.strip.empty? && info.message_count.to_i.zero?
-      return true if keep_empty_path && File.expand_path(info.path) == keep_empty_path
+      return true if keep_empty_paths.include?(File.expand_path(info.path))
 
       File.delete(info.path)
       true
@@ -791,6 +798,38 @@ module Kward
       false
     end
 
+    def session_file_mtime(path)
+      File.mtime(path)
+    rescue StandardError
+      Time.at(0)
+    end
+
+    def delete_empty_unnamed_session_path(path, keep_empty_paths: [])
+      return false unless empty_unnamed_session_path?(path)
+      return true if keep_empty_paths.include?(File.expand_path(path))
+
+      File.delete(path)
+      true
+    rescue StandardError
+      false
+    end
+
+    def empty_unnamed_session_path?(path)
+      header = false
+      name = nil
+      File.foreach(path) do |line|
+        record = JSON.parse(line)
+        header = true if record["type"] == "session" && !record["id"].to_s.empty?
+        name = record["name"] if record["type"] == "session_info" && record.key?("name")
+        next unless record["type"] == "message"
+
+        return false if ["user", "assistant", "tool"].include?(message_role(record["message"] || {}))
+      end
+      header && name.to_s.strip.empty?
+    rescue JSON::ParserError
+      false
+    end
+
     def decorate_tree(sessions)
       by_parent = Hash.new { |hash, key| hash[key] = [] }
       ids = sessions.map(&:id).to_h { |id| [id, true] }

data/lib/kward/skills/registry.rb

@@ -4,7 +4,13 @@ require "pathname"
 module Kward
   # Skill discovery and metadata parsing from configured skill folders.
   module Skills
-    # Parsed skill metadata and instruction path.
+    # Discovers Agent Skills and reads their bounded instruction resources.
+    #
+    # Project sources are included only when the caller marks them trusted. If
+    # duplicate skill names exist, the first source in documented precedence
+    # order wins.
+    #
+    # @api public
     class Registry
       SkillSource = Struct.new(:root, :label, :scope, :precedence, keyword_init: true)
 
@@ -18,6 +24,10 @@ module Kward
         @inside_directory = inside_directory
       end
 
+      # Returns discovered, validated skills in precedence order.
+      #
+      # @return [Array<ConfigFiles::Skill>]
+      # @api public
       def skills
         seen = {}
         skill_sources.flat_map do |source|
@@ -39,6 +49,16 @@ module Kward
         []
       end
 
+      # Reads a skill's main instructions or a bounded relative resource.
+      #
+      # Absolute paths, paths escaping the skill folder, missing files, and files
+      # above the configured size limit return user-facing error strings.
+      #
+      # @param name [String, #to_s] discovered skill name
+      # @param relative_path [String, nil] file relative to the skill directory;
+      #   defaults to `SKILL.md`
+      # @return [String] skill content or an error message
+      # @api public
       def read_skill_file(name, relative_path = nil)
         skill = skills.find { |candidate| candidate.name == name.to_s }
         return "Error: unknown skill: #{name}" unless skill

data/lib/kward/starter_pack_installer.rb

@@ -6,6 +6,7 @@ require "tmpdir"
 require "uri"
 require "zlib"
 require_relative "config_files"
+require_relative "http"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -56,8 +57,9 @@ module Kward
 
     def download(url)
       uri = URI(url)
+      request = Http.apply_user_agent(Net::HTTP::Get.new(uri))
       response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https", open_timeout: 10, read_timeout: 30) do |http|
-        http.get(uri.request_uri)
+        http.request(request)
       end
       raise "Starter pack download failed with HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
 

data/lib/kward/tab_driver.rb

@@ -0,0 +1,87 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Adapts a session-backed agent to the tab runtime interface. Plugin tab
+  # drivers implement the same small surface without becoming Kward sessions.
+  class SessionTabDriver
+    attr_reader :session, :agent
+
+    def initialize(session:, agent:)
+      @session = session
+      @agent = agent
+    end
+
+    def messages
+      agent.conversation.messages
+    end
+
+    def conversation
+      agent.conversation
+    end
+
+    def submit(input, display_input:, cancellation:, steering: nil, &block)
+      options = { cancellation: cancellation }
+      options[:display_input] = display_input unless display_input.nil?
+      options[:steering] = steering if steering
+      agent.ask(input, **options, &block)
+    end
+
+    def descriptor
+      { "kind" => "session", "session_path" => session.path }
+    end
+
+    def session?
+      true
+    end
+
+    def supports_steering?
+      true
+    end
+
+    def assistant_label
+      nil
+    end
+  end
+
+  # Represents a persisted plugin tab whose provider plugin is unavailable.
+  # Its descriptor is retained so reinstalling the plugin restores the tab.
+  class UnavailableTabDriver
+    attr_reader :descriptor
+
+    def initialize(descriptor:, message:)
+      @descriptor = descriptor
+      @message = message
+    end
+
+    def messages
+      [{ role: "assistant", content: @message }]
+    end
+
+    def submit(*)
+      raise @message
+    end
+
+    def session?
+      false
+    end
+
+    def supports_steering?
+      false
+    end
+
+    def assistant_label
+      "Plugin"
+    end
+  end
+
+  # Dependencies made available to a plugin tab factory. The host deliberately
+  # exposes provider transport and frontend-neutral facts, not CLI internals or
+  # workspace session state.
+  class PluginTabHost
+    attr_reader :client, :workspace_root
+
+    def initialize(client:, workspace_root:)
+      @client = client
+      @workspace_root = workspace_root
+    end
+  end
+end

data/lib/kward/tab_store.rb

@@ -5,32 +5,45 @@ require_relative "private_file"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
-  # Persists the terminal UI's open session tabs per workspace.
+  # Persists the terminal UI's open tabs per workspace.
   class TabStore
+    VERSION = 2
+
     def initialize(config_dir: ConfigFiles.config_dir, cwd: Dir.pwd)
       @config_dir = config_dir
       @cwd = File.expand_path(cwd)
     end
 
     def load
-      return { "session_paths" => [], "active_index" => 0 } unless File.file?(path)
+      return empty_state unless File.file?(path)
 
       data = JSON.parse(File.read(path))
-      paths = Array(data["session_paths"]).map(&:to_s).reject(&:empty?)
-      labels = Array(data["labels"]).map(&:to_s)
-      active_index = data["active_index"].to_i
-      { "session_paths" => paths, "labels" => labels, "active_index" => active_index }
+      return typed_state(data) if data["tabs"].is_a?(Array)
+
+      legacy_state(data)
     rescue JSON::ParserError
-      { "session_paths" => [], "active_index" => 0 }
+      empty_state
     end
 
-    def save(session_paths:, active_index:, labels: [])
-      paths = Array(session_paths).map(&:to_s).reject(&:empty?)
+    # `session_paths` remains supported for callers and layouts written before
+    # typed tab descriptors were introduced.
+    def save(session_paths: nil, tabs: nil, active_index:, labels: [])
+      tabs ||= Array(session_paths).filter_map.with_index do |session_path, index|
+        path = session_path.to_s
+        next if path.empty?
+
+        {
+          "kind" => "session",
+          "session_path" => path,
+          "label" => Array(labels)[index].to_s
+        }
+      end
+      tabs = normalize_tabs(tabs)
       PrivateFile.write_json(path, {
+        "version" => VERSION,
         "cwd" => @cwd,
-        "session_paths" => paths,
-        "labels" => Array(labels).map(&:to_s),
-        "active_index" => [[active_index.to_i, 0].max, [paths.length - 1, 0].max].min
+        "tabs" => tabs,
+        "active_index" => [[active_index.to_i, 0].max, [tabs.length - 1, 0].max].min
       })
     end
 
@@ -40,6 +53,55 @@ module Kward
 
     private
 
+    def empty_state
+      { "tabs" => [], "session_paths" => [], "labels" => [], "active_index" => 0 }
+    end
+
+    def typed_state(data)
+      tabs = normalize_tabs(data["tabs"])
+      state_for(tabs, data["active_index"])
+    end
+
+    def legacy_state(data)
+      paths = Array(data["session_paths"]).map(&:to_s).reject(&:empty?)
+      labels = Array(data["labels"]).map(&:to_s)
+      tabs = paths.each_with_index.map do |session_path, index|
+        { "kind" => "session", "session_path" => session_path, "label" => labels[index].to_s }
+      end
+      state_for(tabs, data["active_index"])
+    end
+
+    def state_for(tabs, active_index)
+      {
+        "tabs" => tabs,
+        "session_paths" => tabs.filter_map { |tab| tab["session_path"] if tab["kind"] == "session" },
+        "labels" => tabs.map { |tab| tab["label"].to_s },
+        "active_index" => [[active_index.to_i, 0].max, [tabs.length - 1, 0].max].min
+      }
+    end
+
+    def normalize_tabs(tabs)
+      session_paths = {}
+
+      Array(tabs).filter_map do |tab|
+        next unless tab.is_a?(Hash)
+
+        normalized = tab.transform_keys(&:to_s)
+        kind = normalized["kind"].to_s
+        next if kind.empty?
+        next if kind == "session" && normalized["session_path"].to_s.empty?
+
+        if kind == "session"
+          session_path = File.expand_path(normalized["session_path"].to_s, @cwd)
+          next if session_paths[session_path]
+
+          session_paths[session_path] = true
+        end
+
+        normalized
+      end
+    end
+
     def workspace_key
       Digest::SHA256.hexdigest(@cwd)[0, 24]
     end