kward 0.76.0 → 0.77.0

data/lib/kward/prompt_interface/layout.rb

@@ -10,10 +10,6 @@ module Kward
         @banner.rows(width, message: message)
       end
 
-      def banner_logo_rows
-        @banner.logo_rows(screen_width)
-      end
-
       def transcript_redraw_row_count(height = screen_height)
         [[@transcript_viewport_rows, transcript_bottom_row(height)].max, height].min
       end

data/lib/kward/prompt_interface/project_browser.rb

@@ -12,6 +12,28 @@ module Kward
       PROJECT_BROWSER_ROOT = "".freeze
       PROJECT_BROWSER_RESULT_LIMIT = 200
       PROJECT_BROWSER_STATE_VERSION = 1
+      PROJECT_BROWSER_FILENAME_ICONS = {
+        ".gitignore" => "",
+        "Gemfile" => "",
+        "Rakefile" => "",
+        "README" => "",
+        "README.md" => "",
+        "package.json" => ""
+      }.freeze
+      PROJECT_BROWSER_EXTENSION_ICONS = {
+        "css" => "",
+        "html" => "",
+        "js" => "",
+        "json" => "",
+        "md" => "",
+        "rb" => "",
+        "sh" => "",
+        "ts" => "",
+        "yaml" => "",
+        "yml" => ""
+      }.freeze
+      PROJECT_BROWSER_DIRECTORY_ICON = ""
+      PROJECT_BROWSER_FILE_ICON = ""
 
       def open_project_browser
         @mutex.synchronize do
@@ -399,8 +421,25 @@ module Kward
                  else
                    "  "
                  end
+        icon = project_browser_icon(row)
         suffix = row[:directory] ? "/" : ""
-        "#{indent}#{marker}#{row[:name]}#{suffix}"
+        "#{indent}#{marker}#{icon}#{row[:name]}#{suffix}"
+      end
+
+      def project_browser_icon(row)
+        return "" unless @project_browser_icon_theme == "nerd-font"
+
+        icon = if row[:directory]
+                 PROJECT_BROWSER_DIRECTORY_ICON
+               else
+                 project_browser_file_icon(row[:path])
+               end
+        "#{icon} "
+      end
+
+      def project_browser_file_icon(path)
+        name = File.basename(path.to_s)
+        PROJECT_BROWSER_FILENAME_ICONS[name] || PROJECT_BROWSER_EXTENSION_ICONS[File.extname(name).delete_prefix(".").downcase] || PROJECT_BROWSER_FILE_ICON
       end
 
       def saved_project_browser_state

data/lib/kward/prompt_interface/runtime_state.rb

@@ -74,6 +74,10 @@ module Kward
         ANSI.colorize(text, *styles, enabled: @color_enabled)
       end
 
+      def normalize_project_browser_icon_theme(value)
+        value.to_s == "nerd-font" ? "nerd-font" : "off"
+      end
+
       def normalize_tab_keybindings(value)
         text = value.to_s.downcase
         return "ctrl" if text == "ctrl"

data/lib/kward/prompt_interface/selection_prompt.rb

@@ -68,7 +68,6 @@ module Kward
         return false unless sequence
 
         code = sequence[:code]
-        modifiers = sequence[:modifiers]
         modifier = sequence[:modifier]
         queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
 

data/lib/kward/prompt_interface/transcript_renderer.rb

@@ -40,10 +40,6 @@ module Kward
         @transcript_buffer.append(text.to_s)
       end
 
-      def invalidate_transcript_display_rows_cache
-        @transcript_buffer.invalidate_display_rows_cache
-      end
-
       def ensure_transcript_block_separator_locked
         return if @transcript_buffer.empty? || @transcript_buffer.end_with?("\n\n")
 
@@ -65,10 +61,6 @@ module Kward
         @output_io.print(terminal_newlines(rows.join("\n")))
       end
 
-      def transcript_viewport_text(row_count, width)
-        transcript_viewport_rows(row_count, width).join("\n")
-      end
-
       def transcript_viewport_rows(row_count, width)
         return [] unless row_count.positive?
 
@@ -89,10 +81,6 @@ module Kward
         @transcript_buffer.display_rows(width)
       end
 
-      def transcript_text_display_rows(width)
-        @transcript_buffer.text_display_rows(width)
-      end
-
       def reset_stream_position_from_transcript_locked(width = screen_width)
         @stream_state.reset_position_from_rows(transcript_display_rows(width), width)
       end

data/lib/kward/prompt_interface.rb

@@ -126,7 +126,7 @@ module Kward
       end
     end
 
-    def initialize(input: $stdin, output: $stdout, slash_commands: [], overlay_settings: nil, footer: nil, composer_status: nil, busy_help: true, attachment_badges: nil, attachment_parser: nil, banner_message: nil, tab_keybindings: nil, prompt_history: nil, editor_mode: nil, editor_mode_source: nil, editor_auto_indent: true, editor_auto_indent_source: nil, editor_auto_close_pairs: true, editor_auto_close_pairs_source: nil, editor_soft_wrap: true, editor_soft_wrap_source: nil, editor_bar_cursor: true, editor_bar_cursor_source: nil, editor_line_numbers: "absolute", editor_line_numbers_source: nil, diff_view: "auto", diff_view_source: nil)
+    def initialize(input: $stdin, output: $stdout, slash_commands: [], overlay_settings: nil, project_browser_icon_theme: "off", footer: nil, composer_status: nil, busy_help: true, attachment_badges: nil, attachment_parser: nil, banner_message: nil, tab_keybindings: nil, prompt_history: nil, editor_mode: nil, editor_mode_source: nil, editor_auto_indent: true, editor_auto_indent_source: nil, editor_auto_close_pairs: true, editor_auto_close_pairs_source: nil, editor_soft_wrap: true, editor_soft_wrap_source: nil, editor_bar_cursor: true, editor_bar_cursor_source: nil, editor_line_numbers: "absolute", editor_line_numbers_source: nil, diff_view: "auto", diff_view_source: nil)
       @input_io = input
       @output_io = output
       @reader = TTY::Reader.new(input: input, output: output, interrupt: :error)
@@ -186,6 +186,7 @@ module Kward
       @editor_bar_cursor_active = false
       @synchronized_output_depth = 0
       @overlay_settings = normalize_overlay_settings(overlay_settings)
+      @project_browser_icon_theme = normalize_project_browser_icon_theme(project_browser_icon_theme)
       @footer = footer
       @composer_status = composer_status
       @busy_help = busy_help
@@ -211,6 +212,15 @@ module Kward
       @diff_view_source = diff_view_source
     end
 
+    def update_slash_commands(commands)
+      @mutex.synchronize do
+        @slash_commands = normalize_slash_commands(commands)
+        reset_slash_selection
+        @slash_overlay_dismissed_input = nil
+        render_prompt_locked if @started
+      end
+    end
+
     def start(render: true)
       @mutex.synchronize do
         return if @started
@@ -661,6 +671,13 @@ module Kward
       end
     end
 
+    def update_project_browser_icon_theme(theme)
+      @mutex.synchronize do
+        @project_browser_icon_theme = normalize_project_browser_icon_theme(theme)
+        render_prompt_locked if @started && @asking && project_browser_visible?
+      end
+    end
+
     def begin_busy_input(message = "You>", activity: "streaming")
       start
       @mutex.synchronize do

data/lib/kward/prompts/commands.rb

@@ -19,13 +19,11 @@ module Kward
       { name: "export", description: "Export the current session as Markdown.", argument_hint: "[path]" },
       { name: "compact", description: "Compact the current conversation context.", argument_hint: "[instructions]" },
       { name: "redraw", description: "Refresh the visible terminal.", argument_hint: "" },
-      { name: "settings", description: "Configure prompt overlays.", argument_hint: "" },
+      { name: "settings", description: "Configure Kward interactively.", argument_hint: "" },
       { name: "login", description: "Log in with an OAuth provider.", argument_hint: "" },
       { name: "model", description: "Select the default model.", argument_hint: "" },
       { name: "reasoning", description: "Select reasoning effort.", argument_hint: "" },
       { name: "reload", description: "Reload installed plugins.", argument_hint: "" },
-      { name: "workers", description: "Open the worker pipeline.", argument_hint: "[new|do <task>]" },
-      { name: "queue", description: "Manage the tab-backed worker queue.", argument_hint: "[add|list|open|run|suspend|resume]" },
       { name: "git", description: "Review uncommitted changes and commit them.", argument_hint: "" },
       { name: "diff", description: "Open the file changes recorded in this session.", argument_hint: "" },
       { name: "files", description: "Browse project files.", argument_hint: "" },

data/lib/kward/prompts.rb

@@ -3,9 +3,25 @@ require_relative "config_files"
 # Namespace for the Kward CLI agent runtime.
 module Kward
   # System prompt assembly from config, workspace instructions, memory, and plugins.
+  #
+  # Call {system_message} for the provider-ready message or {prompt_sections}
+  # when a frontend needs to inspect the labeled sources separately.
+  #
+  # @api public
   module Prompts
     module_function
 
+    # Builds the system message sent to a model provider.
+    #
+    # @param workspace_root [String] active workspace root
+    # @param include_workspace_personality [Boolean] include persona and plugin context
+    # @param model [String, nil] model used for persona matching
+    # @param reasoning_effort [String, nil] reasoning effort used for persona matching
+    # @param now [Time] time used for persona modifiers
+    # @param memory_context [String, nil] retrieved memory text
+    # @param plugin_context [String, nil] trusted plugin-provided instructions
+    # @return [Hash] role/content system message
+    # @api public
     def system_message(workspace_root: Dir.pwd, include_workspace_personality: true, model: nil, reasoning_effort: nil, now: Time.now, memory_context: nil, plugin_context: nil)
       {
         role: "system",
@@ -17,6 +33,10 @@ module Kward
       prompt_sections(workspace_root: workspace_root, include_workspace_personality: include_workspace_personality, model: model, reasoning_effort: reasoning_effort, now: now, memory_context: memory_context, plugin_context: plugin_context).map { |section| section[:content] }
     end
 
+    # Returns labeled prompt sections for inspection by CLI and RPC frontends.
+    #
+    # @return [Array<Hash>] section hashes with label, content, and optional source
+    # @api public
     def prompt_sections(workspace_root: Dir.pwd, include_workspace_personality: true, model: nil, reasoning_effort: nil, now: Time.now, memory_context: nil, plugin_context: nil)
       sections = [prompt_section("Built-in system prompt", base_prompt)]
       sections << prompt_section(config_agents_prompt_label, config_agents_prompt, source: config_agents_prompt_source)

data/lib/kward/rpc/server.rb

@@ -5,7 +5,6 @@ require_relative "../memory/manager"
 require_relative "../plugin_registry"
 require_relative "../prompts/commands"
 require_relative "../tools/registry"
-require_relative "../workers"
 require_relative "../workspace"
 require_relative "../telemetry/logger"
 require_relative "../telemetry/stats"
@@ -33,6 +32,7 @@ module Kward
     # `SessionManager`, `AuthManager`, and `ConfigManager`. When adding an RPC
     # feature, update dispatch, capabilities, docs, and tests together so clients
     # can trust `initialize` as the source of supported behavior.
+    # @api public
     class Server
       PROTOCOL_VERSION = 1
       JSONRPC_VERSION = "2.0"
@@ -70,7 +70,6 @@ module Kward
         "memory/forget", "memory/promote", "memory/relax", "memory/inspect",
         "memory/why", "memory/summarize"
       ].freeze
-      WORKER_METHODS = ["workers/list", "workers/show"].freeze
       COMMAND_METHODS = ["commands/list", "commands/run"].freeze
       STARTUP_RESOURCE_METHODS = ["resources/startup"].freeze
       CONFIG_METHODS = ["config/read", "config/update"].freeze
@@ -98,7 +97,6 @@ module Kward
         runtime_settings: RUNTIME_SETTING_METHODS,
         auth: AUTH_METHODS,
         memory: MEMORY_METHODS,
-        workers: WORKER_METHODS,
         commands: COMMAND_METHODS,
         startup_resources: STARTUP_RESOURCE_METHODS,
         config: CONFIG_METHODS,
@@ -110,15 +108,18 @@ module Kward
       RPC_METHODS = METHOD_GROUPS.values.flatten.freeze
 
       # Creates the RPC server and its stateful managers.
-      def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new, experimental_workers: false)
+      #
+      # @param input [IO] framed JSON-RPC input stream
+      # @param output [IO] framed JSON-RPC output stream
+      # @param error_output [IO, nil] redacted diagnostic stream
+      # @param client [Client] model-provider client shared by sessions
+      def initialize(input: $stdin, output: $stdout, error_output: $stderr, client: Client.new)
         @transport = Transport.new(input: input, output: output)
         @error_output = error_output
         @client = client
         @config_manager = ConfigManager.new
         @session_manager = SessionManager.new(server: self, client: client, config_manager: @config_manager)
         @auth_manager = AuthManager.new(server: self, config_manager: @config_manager)
-        @worker_store = Workers::Store.new
-        @experimental_workers = experimental_workers
         @shutdown = false
       end
 
@@ -162,6 +163,10 @@ module Kward
         })
       end
 
+      # Writes a redacted server diagnostic without exposing error payload data.
+      #
+      # @param error [Exception]
+      # @return [void]
       def log_error(error)
         @error_output.puts("Kward RPC error: #{Redactor.redact_string(error.message)}") if @error_output
       end
@@ -277,12 +282,6 @@ module Kward
           @session_manager.memory_why(session_id: params["sessionId"])
         when MEMORY_METHODS[13]
           @session_manager.memory_summarize(session_id: params.fetch("sessionId"))
-        when WORKER_METHODS[0]
-          require_experimental_workers!
-          workers_list(params)
-        when WORKER_METHODS[1]
-          require_experimental_workers!
-          workers_show(params)
         when AUTH_METHODS[0]
           @auth_manager.status
         when AUTH_METHODS[1]
@@ -429,7 +428,7 @@ module Kward
             reasoning: { start: false, delta: true, boundary: true, end: false },
             modelRetry: { supported: true, event: "modelRetry" },
             steering: { supported: @session_manager.in_flight_steer_supported?, event: "turnSteered", mode: @session_manager.in_flight_steer_supported? ? "native" : "unsupported" },
-            tools: { call: true, update: true, result: true, normalizedMetadata: true, diffs: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
+            tools: { call: true, update: true, result: true, normalizedMetadata: true, diffs: true, firstChangedLine: true, changedFiles: true, workspaceGuardrails: workspace_guardrails_enabled?, focusedContext: true, contextBudgetStats: true },
             errors: true,
             sessionUpdates: false
           },
@@ -484,8 +483,7 @@ module Kward
             logout: true
           },
           memory: { supported: true, optIn: true, defaultEnabled: false, autoSummaryDefaultEnabled: false, promptInjection: "interactive", storage: { core: "json", soft: "jsonl", events: "jsonl" }, methods: MEMORY_METHODS },
-          workers: workers_capability,
-          stability: { protocol: "stable", compatibility: "additive-fields-unless-protocol-version-changes", experimentalCapabilities: ["workers"] },
+          stability: { protocol: "stable", compatibility: "additive-fields-unless-protocol-version-changes", experimentalCapabilities: [] },
           commands: { supported: true, methods: COMMAND_METHODS, method: COMMAND_METHODS[0], runMethod: COMMAND_METHODS[1], sources: ["builtin", "prompt", "skill", "plugin"], executableSources: ["builtin", "plugin"] },
           mcp: {
             supported: true,
@@ -543,18 +541,6 @@ module Kward
         }
       end
 
-      def workers_capability
-        return { supported: false, reason: "experimentalWorkersFlagRequired", flag: "--experimental-workers" } unless @experimental_workers
-
-        { supported: true, methods: WORKER_METHODS, roles: ["implementation", "request"], statuses: Workers::Worker::STATUSES, transcriptStorage: "sessions", metadataStorage: "json" }
-      end
-
-      def require_experimental_workers!
-        return if @experimental_workers
-
-        raise NoMethodError, "workers require --experimental-workers"
-      end
-
       def workspace_info(root)
         root = @session_manager.validate_workspace_root(root)
         { root: root, basename: File.basename(root), writable: File.writable?(root) }
@@ -715,20 +701,6 @@ module Kward
         { sections: sections }
       end
 
-      def workers_list(params)
-        include_archived = params["includeArchived"] == true
-        workers = @worker_store.list(include_archived: include_archived)
-        { workers: workers }
-      end
-
-      def workers_show(params)
-        id = params.fetch("id").to_s.delete_prefix("#")
-        worker = @worker_store.find(id)
-        return { worker: worker } if worker
-
-        raise ArgumentError, "Unknown worker: #{id}"
-      end
-
       def auth_login_with_api_key(params)
         result = @auth_manager.login_with_api_key(provider_id: params.fetch("providerId"), api_key: params.fetch("apiKey"))
         @session_manager.refresh_client_config

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)
@@ -1043,6 +1054,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 +1079,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 +1157,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 +1328,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 +1367,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 +1384,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 +1397,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

@@ -246,6 +246,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 +259,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