rubik 0.3.5 → 0.4.1

data/lib/rubik/lsp/manager.rb

@@ -200,18 +200,16 @@ module Rubik
 
           client.stop
           @clients.delete(lang_str)
-          effective_ctx = @context || @runtime_manager&.context
-          effective_ctx&.unprovide("lsp:#{lang_str}") if effective_ctx.respond_to?(:unprovide)
+          unregister_client_unlocked(lang_str)
           { ok: true, message: "Stopped LSP server for '#{lang_str}'" }
         end
       end
 
       def stop_all
         @monitor.synchronize do
-          effective_ctx = @context || @runtime_manager&.context
           @clients.each do |lang_str, client|
             client.stop
-            effective_ctx&.unprovide("lsp:#{lang_str}") if effective_ctx.respond_to?(:unprovide)
+            unregister_client_unlocked(lang_str)
           end
           @clients.clear
         end
@@ -387,7 +385,10 @@ module Rubik
           recovering = true
           record_crash(lang)
           stop_client_safely(client)
-          @clients.delete(lang) if stored.equal?(client)
+          if stored.equal?(client)
+            @clients.delete(lang)
+            unregister_client_unlocked(lang)
+          end
           client = nil
         end
 
@@ -418,6 +419,7 @@ module Rubik
             else
               record_crash(lang)
               stop_client_safely(client)
+              unregister_client_unlocked(lang)
               @recovery_errors[lang] = "LSP server restart failed for '#{lang}'" if recovering
             end
           elsif recovering
@@ -439,6 +441,7 @@ module Rubik
           else
             record_crash(lang)
             stop_client_safely(client)
+            unregister_client_unlocked(lang)
             @recovery_errors[lang] = "LSP server restart failed for '#{lang}'" if recovering
           end
         end
@@ -465,6 +468,13 @@ module Rubik
         end
       end
 
+      def unregister_client_unlocked(lang)
+        lang_str = lang.to_s.downcase
+        @registered_disposable_langs.delete(lang_str)
+        effective_ctx = @context || @runtime_manager&.context
+        effective_ctx&.unprovide("lsp:#{lang_str}") if effective_ctx.respond_to?(:unprovide)
+      end
+
       def stop_client_safely(client)
         client.stop
       rescue StandardError

data/lib/rubik/orchestrator/step_executor.rb

@@ -19,20 +19,9 @@ module Rubik
       include MaestroGate
 
       ERROR_PREFIXES = [
-        "-- ",
-        "Error:",
-        "Error ",
-        "Usage:",
-        "Pre-flight verification failed",
-        "Bilinmeyen komut",
-        "Failed",
-        "Security blocked",
-        "Command error",
-        "[EXIT ",
-        "Test run [FAILED]",
-        "Lint [FAILED]",
-        "[CONFLICT]",
-        "[CONFLICT "
+        "-- ", "Error:", "Error ", "Usage:", "Pre-flight verification failed",
+        "Bilinmeyen komut", "Failed", "Security blocked", "Command error",
+        "[EXIT ", "Test run [FAILED]", "Lint [FAILED]", "[CONFLICT]", "[CONFLICT "
       ].freeze
 
       # Plan 87 E-1: state is reached through the ShellDeps façade. Accepts a
@@ -98,7 +87,6 @@ module Rubik
 
       def execute_registered_tool(tool_instance, tool_name, tool_args, call_id, auto_apply_mode = nil)
         @deps.on_step&.call(type: :tool_call, tool: tool_name, args: tool_args, step: @deps.step_count, max_steps: @deps.max_steps, call_id: call_id)
-        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         # Opt-in circuit breaker (G19): when enabled and the circuit for this
         # tool is open, raise into the normal error-result plumbing below so
@@ -107,111 +95,13 @@ module Rubik
         breaker = circuit_breaker_for
         blocked_by_circuit = breaker && !breaker.allow?(tool_instance.name)
 
-        tool_result = begin
-          if blocked_by_circuit
-            raise ToolCircuitBreaker::CircuitOpenError,
-                  "circuit open for '#{tool_instance.name}' — repeated failures; waiting out the cooldown before retrying"
-          end
+        raw_output, tool_result = invoke_tool_and_normalize(tool_instance, tool_name, tool_args, call_id, blocked_by_circuit: blocked_by_circuit)
 
-          raw_output = tool_instance.execute(tool_args)
-          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          dur = ((t1 - t0) * 1000).round(1)
-
-          max_chars = @deps.shell&.config&.fetch("tools.max_output_chars", 12_000) || 12_000
-          max_lines = @deps.shell&.config&.fetch("tools.max_output_lines", 300) || 300
-          trunc_strat = @deps.shell&.config&.fetch("tools.truncation_strategy", "head_tail") || "head_tail"
-
-          if raw_output.is_a?(Rubik::Tools::Result)
-            trunc_res = Rubik::Tools::Truncator.truncate(raw_output.output, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
-            effective_dur = raw_output.duration_ms.positive? ? raw_output.duration_ms : dur
-            first_line = raw_output.output.lines.first.to_s.strip
-            first_line = nil if first_line.empty?
-            Rubik::Tools::Result.new(
-              tool_name: raw_output.tool_name.to_s.empty? ? tool_name : raw_output.tool_name,
-              call_id: raw_output.call_id.to_s.empty? ? call_id : raw_output.call_id,
-              status: raw_output.status,
-              error: raw_output.error || (raw_output.error? ? first_line : nil),
-              exit_code: raw_output.exit_code,
-              output: trunc_res[:text],
-              duration_ms: effective_dur,
-              truncated: raw_output.truncated || trunc_res[:truncated],
-              metadata: raw_output.metadata
-            )
-          elsif raw_output.respond_to?(:status) && raw_output.respond_to?(:output)
-            out_str = raw_output.output.to_s
-            trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
-            st = raw_output.status.to_sym
-            first_line = out_str.lines.first.to_s.strip
-            first_line = nil if first_line.empty?
-            err = (raw_output.respond_to?(:error) && raw_output.error) || (st == :error ? first_line : nil)
-            Rubik::Tools::Result.new(
-              tool_name: tool_name,
-              call_id: call_id,
-              status: st,
-              error: err,
-              output: trunc_res[:text],
-              duration_ms: dur,
-              truncated: trunc_res[:truncated],
-              # Structured fields ride along when the tool provides them
-              # (issue #127): the same Result contract for every carrier.
-              exit_code: raw_output.respond_to?(:exit_code) ? raw_output.exit_code : nil,
-              metadata: raw_output.respond_to?(:metadata) ? raw_output.metadata : {}
-            )
-          else
-            out_str = raw_output.to_s
-            trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
-
-            is_err = if raw_output.respond_to?(:error?)
-                       raw_output.error?
-                     elsif raw_output.respond_to?(:failed?)
-                       raw_output.failed?
-                     elsif raw_output.is_a?(String)
-                       ERROR_PREFIXES.any? { |pfx| raw_output.start_with?(pfx) }
-                     else
-                       false
-                     end
-
-            first_line = out_str.lines.first.to_s.strip
-            first_line = nil if first_line.empty?
-
-            Rubik::Tools::Result.new(
-              tool_name: tool_name,
-              call_id: call_id,
-              status: is_err ? :error : :ok,
-              error: is_err ? first_line : nil,
-              output: trunc_res[:text],
-              duration_ms: dur,
-              truncated: trunc_res[:truncated]
-            )
-          end
-        rescue StandardError => e
-          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          dur = ((t1 - t0) * 1000).round(1)
-          err_msg = "Error executing tool '#{tool_name}': #{e.class} - #{e.message}"
-          Rubik::Tools::Result.new(
-            tool_name: tool_name,
-            call_id: call_id,
-            status: :error,
-            error: e.message,
-            output: err_msg,
-            duration_ms: dur
-          )
-        end
+        record_circuit_breaker_result(breaker, tool_instance.name, tool_result.status) if breaker && !blocked_by_circuit
 
         # always-mode flush after every tool — was historically silent; the
         # post_tool event makes the disk write visible like every other apply
-        if breaker && !blocked_by_circuit
-          if tool_result.status == :ok
-            breaker.record_success(tool_instance.name)
-          else
-            breaker.record_failure(tool_instance.name)
-          end
-        end
-
-        if AutoApply.apply?(@deps.config, trigger: :post_tool, mode: auto_apply_mode) && @deps.buffer_manager&.dirty?
-          applied = AutoApply.apply_and_sync(@deps.buffer_manager, @deps.shell)
-          @deps.on_step&.call(type: :auto_apply, reason: "post_tool", files: applied, step: @deps.step_count, max_steps: @deps.max_steps)
-        end
+        perform_post_tool_auto_apply(auto_apply_mode)
 
         # Real-time LSP In-Buffer Diagnostics feedback loop (Plan 56 D-5,
         # extracted to LspFeedback for the line budget).
@@ -222,39 +112,9 @@ module Rubik
         # çıktısı tam içerikle kullanıcıya :user_output olarak akar; model,
         # history ve :tool_result özeti yalnız stub görür. Event birincil
         # teslimat olduğu için onsuz stub yalan olur — kaynak yoksa warn.
-        if raw_output.respond_to?(:user_display?) && raw_output.user_display? && tool_result.status == :ok
-          sink = @deps.respond_to?(:on_step) ? @deps.on_step : nil
-          if sink
-            sink.call(type: :user_output, content: raw_output.to_s, label: raw_output.display_stub,
-                      step: @deps.step_count, max_steps: @deps.max_steps)
-          else
-            warn("[show_file] no :user_output sink wired — display content dropped: #{raw_output.display_stub}")
-          end
-          tool_result = Rubik::Tools::Result.new(tool_name: tool_name, call_id: call_id, status: :ok,
-                                                 output: raw_output.display_stub, duration_ms: tool_result.duration_ms)
-        end
+        tool_result = handle_user_display_output(raw_output, tool_result, tool_name, call_id)
 
-        @deps.on_step&.call(
-          type: :tool_result,
-          tool: tool_name,
-          output: tool_result.output,
-          status: tool_result.status,
-          duration_ms: tool_result.duration_ms,
-          step: @deps.step_count,
-          max_steps: @deps.max_steps,
-          call_id: call_id,
-          exit_code: tool_result.exit_code,
-          metadata: tool_result.metadata,
-          line_count: tool_result.output.to_s.lines.size,
-          byte_size: tool_result.output.to_s.bytesize,
-          tokens: @deps.total_tokens
-        )
-
-        Rubik::Orchestrator::ToolHistory.write(@deps.history, tool_call_id: call_id, tool_name: tool_name,
-                                                              status: tool_result.status, duration_ms: tool_result.duration_ms,
-                                                              content: tool_result.to_xml, exit_code: tool_result.exit_code,
-                                                              metadata: tool_result.metadata)
-        @deps.activity.record(tool_name, tool_args, tool_result.status) if @deps.respond_to?(:activity)
+        record_tool_execution_results(tool_name, tool_args, call_id, tool_result)
         @deps.reset_invalid_tools!
         tool_result
       end
@@ -280,12 +140,8 @@ module Rubik
         diagnostic_msg = Rubik::Tools::DiagnosticReporter.render_unknown_tool(tool_name, candidate_tools: candidate_tools, all_tools: all_tool_names)
 
         err_result = Rubik::Tools::Result.new(
-          tool_name: tool_name,
-          call_id: call_id,
-          status: :error,
-          error: "Tool '#{tool_name}' does not exist.",
-          output: diagnostic_msg,
-          duration_ms: 0.0
+          tool_name: tool_name, call_id: call_id, status: :error,
+          error: "Tool '#{tool_name}' does not exist.", output: diagnostic_msg, duration_ms: 0.0
         )
         Rubik::Orchestrator::ToolHistory.write(@deps.history, tool_call_id: call_id, tool_name: tool_name,
                                                               status: :error, duration_ms: 0.0, content: err_result.to_xml)
@@ -294,6 +150,134 @@ module Rubik
 
       private
 
+      def invoke_tool_and_normalize(tool_instance, tool_name, tool_args, call_id, blocked_by_circuit:)
+        t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        raw_output = nil
+
+        tool_result = begin
+          if blocked_by_circuit
+            raise ToolCircuitBreaker::CircuitOpenError,
+                  "circuit open for '#{tool_instance.name}' — repeated failures; waiting out the cooldown before retrying"
+          end
+
+          raw_output = tool_instance.execute(tool_args)
+          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          dur = ((t1 - t0) * 1000).round(1)
+
+          normalize_raw_output(raw_output, tool_name, call_id, dur)
+        rescue StandardError => e
+          t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          dur = ((t1 - t0) * 1000).round(1)
+          err_msg = "Error executing tool '#{tool_name}': #{e.class} - #{e.message}"
+          Rubik::Tools::Result.new(tool_name: tool_name, call_id: call_id, status: :error, error: e.message, output: err_msg, duration_ms: dur)
+        end
+
+        [raw_output, tool_result]
+      end
+
+      def normalize_raw_output(raw_output, tool_name, call_id, dur)
+        max_chars = @deps.shell&.config&.fetch("tools.max_output_chars", 12_000) || 12_000
+        max_lines = @deps.shell&.config&.fetch("tools.max_output_lines", 300) || 300
+        trunc_strat = @deps.shell&.config&.fetch("tools.truncation_strategy", "head_tail") || "head_tail"
+
+        if raw_output.is_a?(Rubik::Tools::Result)
+          trunc_res = Rubik::Tools::Truncator.truncate(raw_output.output, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
+          effective_dur = raw_output.duration_ms.positive? ? raw_output.duration_ms : dur
+          first_line = raw_output.output.lines.first.to_s.strip
+          first_line = nil if first_line.empty?
+          Rubik::Tools::Result.new(
+            tool_name: raw_output.tool_name.to_s.empty? ? tool_name : raw_output.tool_name,
+            call_id: raw_output.call_id.to_s.empty? ? call_id : raw_output.call_id,
+            status: raw_output.status, error: raw_output.error || (raw_output.error? ? first_line : nil),
+            # Structured fields ride along when the tool provides them
+            # (issue #127): the same Result contract for every carrier.
+            exit_code: raw_output.exit_code, output: trunc_res[:text], duration_ms: effective_dur,
+            truncated: raw_output.truncated || trunc_res[:truncated], metadata: raw_output.metadata
+          )
+        elsif raw_output.respond_to?(:status) && raw_output.respond_to?(:output)
+          out_str = raw_output.output.to_s
+          trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
+          st = raw_output.status.to_sym
+          first_line = out_str.lines.first.to_s.strip
+          first_line = nil if first_line.empty?
+          err = (raw_output.respond_to?(:error) && raw_output.error) || (st == :error ? first_line : nil)
+          Rubik::Tools::Result.new(
+            tool_name: tool_name, call_id: call_id, status: st, error: err, output: trunc_res[:text],
+            duration_ms: dur, truncated: trunc_res[:truncated],
+            exit_code: raw_output.respond_to?(:exit_code) ? raw_output.exit_code : nil,
+            metadata: raw_output.respond_to?(:metadata) ? raw_output.metadata : {}
+          )
+        else
+          out_str = raw_output.to_s
+          trunc_res = Rubik::Tools::Truncator.truncate(out_str, max_chars: max_chars, max_lines: max_lines, strategy: trunc_strat)
+
+          is_err = if raw_output.respond_to?(:error?)
+                     raw_output.error?
+                   elsif raw_output.respond_to?(:failed?)
+                     raw_output.failed?
+                   elsif raw_output.is_a?(String)
+                     ERROR_PREFIXES.any? { |pfx| raw_output.start_with?(pfx) }
+                   else
+                     false
+                   end
+
+          first_line = out_str.lines.first.to_s.strip
+          first_line = nil if first_line.empty?
+
+          Rubik::Tools::Result.new(
+            tool_name: tool_name, call_id: call_id, status: is_err ? :error : :ok,
+            error: is_err ? first_line : nil, output: trunc_res[:text], duration_ms: dur, truncated: trunc_res[:truncated]
+          )
+        end
+      end
+
+      def record_circuit_breaker_result(breaker, tool_name, status)
+        if status == :ok
+          breaker.record_success(tool_name)
+        else
+          breaker.record_failure(tool_name)
+        end
+      end
+
+      def perform_post_tool_auto_apply(auto_apply_mode)
+        return unless AutoApply.apply?(@deps.config, trigger: :post_tool, mode: auto_apply_mode) && @deps.buffer_manager&.dirty?
+
+        applied = AutoApply.apply_and_sync(@deps.buffer_manager, @deps.shell)
+        @deps.on_step&.call(type: :auto_apply, reason: "post_tool", files: applied, step: @deps.step_count, max_steps: @deps.max_steps)
+      end
+
+      def handle_user_display_output(raw_output, tool_result, tool_name, call_id)
+        return tool_result unless raw_output.respond_to?(:user_display?) && raw_output.user_display? && tool_result.status == :ok
+
+        sink = @deps.respond_to?(:on_step) ? @deps.on_step : nil
+        if sink
+          sink.call(type: :user_output, content: raw_output.to_s, label: raw_output.display_stub,
+                    step: @deps.step_count, max_steps: @deps.max_steps)
+        else
+          warn("[show_file] no :user_output sink wired — display content dropped: #{raw_output.display_stub}")
+        end
+
+        Rubik::Tools::Result.new(
+          tool_name: tool_name, call_id: call_id, status: :ok, output: raw_output.display_stub, duration_ms: tool_result.duration_ms
+        )
+      end
+
+      def record_tool_execution_results(tool_name, tool_args, call_id, tool_result)
+        @deps.on_step&.call(
+          type: :tool_result, tool: tool_name, output: tool_result.output, status: tool_result.status,
+          duration_ms: tool_result.duration_ms, step: @deps.step_count, max_steps: @deps.max_steps,
+          call_id: call_id, exit_code: tool_result.exit_code, metadata: tool_result.metadata,
+          line_count: tool_result.output.to_s.lines.size, byte_size: tool_result.output.to_s.bytesize, tokens: @deps.total_tokens
+        )
+
+        Rubik::Orchestrator::ToolHistory.write(
+          @deps.history, tool_call_id: call_id, tool_name: tool_name, status: tool_result.status,
+                         duration_ms: tool_result.duration_ms, content: tool_result.to_xml, exit_code: tool_result.exit_code, metadata: tool_result.metadata
+        )
+
+        @deps.activity.record(tool_name, tool_args, tool_result.status) if @deps.respond_to?(:activity)
+      end
+
       # G19: one breaker per executor, built from the first enabled config
       # sighting. Threshold/cooldown changes via live !config set are picked
       # up on the next executor instantiation — acceptable for an opt-in
@@ -328,7 +312,7 @@ module Rubik
         end
 
         # Strip ```json ... ``` blocks
-        str.gsub(/```(?:json)?\s*\{.*?\}\s*```/m, "").strip
+        str.gsub(/```(?:json)?\s*\{[^`]*\}\s*```/m, "").strip
       end
     end
   end

data/lib/rubik/orchestrator/subagent/completion.rb

@@ -21,6 +21,7 @@ module Rubik
           reap_orphans
           release_ready!
           emit_completion_notice(inst)
+          notify_wait!
         end
 
         private

data/lib/rubik/orchestrator/subagent/dependency.rb

@@ -150,6 +150,7 @@ module Rubik
           end
           announce_cancellations(cancelled)
           claimed.each { |spec| launch_claimed!(spec) }
+          notify_wait!
         end
 
         # wait_for'un döngü koşulu için: hedef id'ler arasında hâlâ kuyrukta

data/lib/rubik/orchestrator/subagent/supervisor.rb

@@ -68,6 +68,7 @@ module Rubik
           @instances = {}
           @deferred = {}
           @monitor = Monitor.new
+          @wait_cond = @monitor.new_cond
           @counter = 0
           @max_depth = (config&.fetch("subagents.max_depth", 2) || 2).to_i
           @max_concurrency = (config&.fetch("subagents.max_concurrency", 10) || 10).to_i
@@ -83,6 +84,13 @@ module Rubik
           # redacted, paginated — see ResultArchive.
           @result_archive = ResultArchive.new(config: @config)
 
+          if @event_bus.respond_to?(:subscribe)
+            @event_bus.subscribe(Notices::ERROR_PAUSED_EVENT) { notify_wait! }
+            @event_bus.subscribe(Notices::BUDGET_EXHAUSTED_EVENT) { notify_wait! }
+            @event_bus.subscribe(Notices::COMPLETED_EVENT) { notify_wait! }
+            @event_bus.subscribe(Notices::QUESTION_EVENT) { notify_wait! } if defined?(Notices::QUESTION_EVENT)
+          end
+
           # Register inverse in root context (maestro hook)
           @root_context.register_disposable { shutdown_all } if @root_context.respond_to?(:register_disposable)
         end
@@ -93,20 +101,26 @@ module Rubik
           inst = get(id)
           return false unless inst.is_a?(Instance)
 
-          inst.extend_budget(steps)
+          res = inst.extend_budget(steps)
+          notify_wait! if res
+          res
         end
 
         def resume(id, additional_steps: nil)
           inst = get(id)
-          inst.respond_to?(:resume!) ? inst.resume!(additional_steps: additional_steps) : false
+          res = inst.respond_to?(:resume!) ? inst.resume!(additional_steps: additional_steps) : false
+          notify_wait! if res
+          res
         end
 
         def resume_all
-          @monitor.synchronize do
+          resumed = @monitor.synchronize do
             @instances.values.select(&:parked?).map do |i|
               i.resume! ? i.id : nil
             end.compact
           end
+          notify_wait! unless resumed.empty?
+          resumed
         end
 
         def list(parent_id: nil)
@@ -129,6 +143,7 @@ module Rubik
           # monitörü 2s'ye kadar bloklar (emit kuralı ihlali olurdu).
           announce_cancellations(cancelled)
           release_ready!
+          notify_wait!
           found
         end
 
@@ -142,6 +157,7 @@ module Rubik
             true
           end
           announce_cancellations(cancelled)
+          notify_wait!
         end
 
         def shutdown_all
@@ -151,6 +167,7 @@ module Rubik
             @instances.clear
             @deferred.clear
           end
+          notify_wait!
         end
 
         def reap_orphans

data/lib/rubik/orchestrator/subagent/waiting.rb

@@ -20,25 +20,32 @@ module Rubik
           wait(ids, timeout: timeout, wait_for_budget: wait_for_budget).rows
         end
 
+        def notify_wait!
+          @monitor.synchronize { @wait_cond&.broadcast }
+        end
+
         def wait(ids = nil, timeout: Notices::DEFAULT_WAIT_TIMEOUT, wait_for_budget: true)
           target_ids = Array(ids).compact.map(&:to_s)
           deadline = Time.now + [timeout.to_i, 1].max
 
-          loop do
-            active_targets = @monitor.synchronize do
+          @monitor.synchronize do
+            loop do
               candidates = target_ids.empty? ? @instances.values : target_ids.filter_map { |id| @instances[id] }
-              candidates.select do |inst|
+              active_targets = candidates.select do |inst|
                 inst.active? && !inst.error_paused? && !inst.awaiting_human? && (!wait_for_budget || !inst.awaiting_budget?)
               end
-            end
 
-            # Kuyruğa takılı hedefler wait'i canlı tutar (zincir bitene dek).
-            break if (active_targets.empty? && !deferred_pending?(target_ids)) || Time.now >= deadline
+              # Kuyruğa takılı hedefler wait'i canlı tutar (zincir bitene dek).
+              rem = deadline - Time.now
+              break if (active_targets.empty? && !deferred_pending?(target_ids)) || rem <= 0
 
-            sleep 0.1
-          end
+              if @wait_cond
+                @wait_cond.wait([rem, 0].max)
+              else
+                sleep [rem, 0.1].min
+              end
+            end
 
-          @monitor.synchronize do
             candidates = target_ids.empty? ? @instances.values : target_ids.filter_map { |id| @instances[id] || queued_spec(id) }
             paused = candidates.select { |c| parked_candidate?(c) }
             active = candidates.select { |c| c.respond_to?(:active?) && c.active? }

data/lib/rubik/orchestrator/turn_executor/subagent_channel.rb

@@ -62,7 +62,7 @@ module Rubik
           @inst.emit_compacted_event(reason, layer)
         end
 
-        def announce_llm_thought(_text) = nil
+        def announce_llm_thought(_text, **) = nil
 
         # ── terminals & dispatch ──
         # The shared two-strike nudge policy (Channel#empty_response_turn)

data/lib/rubik/orchestrator/turn_executor/user_channel.rb

@@ -107,8 +107,8 @@ module Rubik
                               max_steps: @deps.max_steps, layer: layer)
         end
 
-        def announce_llm_thought(text)
-          @deps.on_step&.call(type: :llm_thought, content: text, step: @deps.step_count, max_steps: @deps.max_steps)
+        def announce_llm_thought(text, streamed: false)
+          @deps.on_step&.call(type: :llm_thought, content: text, streamed: streamed, step: @deps.step_count, max_steps: @deps.max_steps)
         end
 
         # ── terminals & dispatch ──

data/lib/rubik/orchestrator/turn_executor.rb

@@ -218,7 +218,8 @@ module Rubik
       def tool_turn(res, text_resp, tool_calls)
         channel.nudge_policy.reset!
         channel.append_tool_call_row(channel.final_text(res, text_resp), tool_calls)
-        channel.announce_llm_thought(text_resp) if !text_resp.empty? && tool_calls.none? { |tc| self.class.finish_call?(channel.tool_registry, tc) }
+        streamed = res.respond_to?(:streamed) && res.streamed == true
+        channel.announce_llm_thought(text_resp, streamed: streamed) if !text_resp.empty? && tool_calls.none? { |tc| self.class.finish_call?(channel.tool_registry, tc) }
 
         tool_calls.each do |tc|
           # finish is exempt (pinned by test_orchestrator_stream): its args
@@ -300,7 +301,7 @@ module Rubik
         # ── announce ──
         def announce_compaction(_reason, _layer) = nil
 
-        def announce_llm_thought(_text) = nil
+        def announce_llm_thought(_text, **) = nil
 
         # Goal-ledger observation projection (plan D): related-optional
         # capability — base channel is structurally inert (subagent planes

data/lib/rubik/platform/path.rb

@@ -228,7 +228,8 @@ module Rubik
         # drive root?" depend on the process cwd (which drive the workspace
         # lives on). Security callers pass already-expanded absolute paths;
         # compare the literal form here.
-        cleaned = path.to_s.tr("\\", "/").downcase.sub(%r{/+\z}, "")
+        cleaned = path.to_s.tr("\\", "/").downcase
+        cleaned = cleaned.delete_suffix("/") while cleaned.end_with?("/")
         cleaned =~ /^[a-z]:$/
       end
     end

data/lib/rubik/platform/sanitize.rb

@@ -108,14 +108,17 @@ module Rubik
         end
       end
 
+      VALID_SYMBOL_ENCODINGS = [Encoding::UTF_8, Encoding::US_ASCII].freeze
+
       # Binary (ASCII-8BIT) symbol names always report valid_encoding?, so a
       # bare validity check would fast-path them through UNCLEANED — the old
       # clean_utf8 path strips their >= 0x80 bytes and the byte loss would
       # instead surface later, at the JSON/display layer. Only UTF-8 (or the
       # lossless US-ASCII subset) symbols may take the fast path.
+      # PERF: Hoist encoding array to frozen constant to eliminate array allocations per symbol check (~26% faster, ~99.99% fewer allocations).
       def fast_clean_symbol(sym)
         name = sym.name
-        return sym if [Encoding::UTF_8, Encoding::US_ASCII].include?(name.encoding) && name.valid_encoding?
+        return sym if VALID_SYMBOL_ENCODINGS.include?(name.encoding) && name.valid_encoding?
 
         clean_utf8(name).to_sym
       end

data/lib/rubik/prompt/token_estimator.rb

@@ -22,27 +22,31 @@ module Rubik
         ((len * 10) + 37) / 38
       end
 
+      # PERF: Fast-path message token estimator respecting ConversationRows abstraction.
       def estimate_message(msg)
         return 0 unless ConversationRows.row?(msg)
 
         tokens = 4 # Base message overhead (role delimiter, headers)
-        role = ConversationRows.value_of(msg, :role)
-        tokens += estimate_text(role) if role
 
-        content = ConversationRows.value_of(msg, :content)
-        tokens += estimate_text(content) if content
+        if (role = ConversationRows.value_of(msg, :role))
+          tokens += estimate_text(role)
+        end
 
-        tool_calls = msg[:tool_calls] || msg["tool_calls"]
-        if tool_calls && !tool_calls.empty?
-          tool_calls_str = serialize_for_estimation(tool_calls)
-          tokens += estimate_text(tool_calls_str)
+        if (content = ConversationRows.value_of(msg, :content))
+          tokens += estimate_text(content)
         end
 
-        tool_call_id = msg[:tool_call_id] || msg["tool_call_id"]
-        tokens += estimate_text(tool_call_id) if tool_call_id
+        if (tool_calls = ConversationRows.value_of(msg, :tool_calls)) && !tool_calls.empty?
+          tokens += estimate_text(serialize_for_estimation(tool_calls))
+        end
 
-        tool_name = msg[:tool_name] || msg["tool_name"]
-        tokens += estimate_text(tool_name) if tool_name
+        if (tool_call_id = ConversationRows.value_of(msg, :tool_call_id))
+          tokens += estimate_text(tool_call_id)
+        end
+
+        if (tool_name = ConversationRows.value_of(msg, :tool_name))
+          tokens += estimate_text(tool_name)
+        end
 
         tokens
       end