rubik 0.3.1 → 0.3.3

data/lib/rubik/lsp/manager.rb

@@ -42,6 +42,8 @@ module Rubik
         @context = context || runtime_manager&.context
         @clients = {}
         @crash_stats = {}
+        @recovery_errors = {}
+        @registered_disposable_langs = {}
         @monitor = Monitor.new
       end
 
@@ -93,82 +95,20 @@ module Rubik
       def ensure_healthy!(language_or_client)
         return nil unless enabled?
 
-        client = language_or_client.is_a?(Client) ? language_or_client : client_for(language_or_client)
-        return nil unless client
+        lang = language_for(language_or_client)
+        return nil unless lang
 
-        if client.running && client.respond_to?(:alive?) && !client.alive?
-          lang = client.language
-          record_crash(lang)
-          @monitor.synchronize do
-            begin
-              client.stop
-            rescue
-              nil
-            end
-            @clients.delete(lang)
-          end
-          start_client(lang) unless circuit_open?(lang)
-          client = @clients[lang]
-        elsif !client.running && @config.fetch("lsp.auto_start", true) && client.available? && !circuit_open?(client.language)
-          start_client(client.language)
-          client = @clients[client.language]
+        @monitor.synchronize do
+          preferred = language_or_client if language_or_client.is_a?(Client)
+          client_for_unlocked(lang, preferred)
         end
-
-        client
       end
 
       def client_for(language_or_file)
-        lang = if language_or_file.to_s.include?(".")
-                 detect_language(language_or_file)
-               else
-                 language_or_file.to_s.downcase
-               end
-
+        lang = language_for(language_or_file)
         return nil unless lang
 
-        @monitor.synchronize do
-          if @clients.key?(lang)
-            client = @clients[lang]
-            if client.running && client.respond_to?(:alive?) && !client.alive?
-              record_crash(lang)
-              begin
-                client.stop
-              rescue
-                nil
-              end
-              @clients.delete(lang)
-              nil # Will trigger recreate / start below
-            else
-              client
-            end
-          elsif enabled?
-            configured_cmd = @config.fetch("lsp.servers.#{lang}") || Client::SERVERS[lang]
-            client = Client.new(lang, root_dir: @root_dir, server_cmd: configured_cmd)
-            unless client.available?
-              probed_cmd = Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir, custom_cmd: configured_cmd)
-              client = Client.new(lang, root_dir: @root_dir, server_cmd: probed_cmd) if probed_cmd
-            end
-
-            if client.available? && @config.fetch("lsp.auto_start", true) && !circuit_open?(lang)
-              if client.start
-                reset_circuit!(lang)
-                effective_ctx = @context || @runtime_manager&.context
-                if effective_ctx
-                  effective_ctx.provide("lsp:#{lang}", client)
-                  effective_ctx.register_disposable { client.stop if client.running }
-                end
-              else
-                record_crash(lang)
-                begin
-                  client.stop
-                rescue StandardError
-                  nil
-                end
-              end
-            end
-            @clients[lang] = client
-          end
-        end
+        @monitor.synchronize { client_for_unlocked(lang) }
       end
 
       def start_client(lang)
@@ -204,19 +144,12 @@ module Rubik
             @clients[lang_str] = client
             if res
               reset_circuit!(lang_str)
-              effective_ctx = @context || @runtime_manager&.context
-              if effective_ctx
-                effective_ctx.provide("lsp:#{lang_str}", client)
-                effective_ctx.register_disposable { client.stop if client.running }
-              end
+              @recovery_errors.delete(lang_str)
+              register_client_unlocked(lang_str, client)
               { ok: true, message: "Started LSP server for '#{lang_str}' (#{client.server_cmd})" }
             else
               record_crash(lang_str)
-              begin
-                client.stop
-              rescue StandardError
-                nil
-              end
+              stop_client_safely(client)
               failure = Runtime::DiagnosticEngine.diagnose(
                 cmd: client.server_cmd,
                 exit_code: 1,
@@ -241,13 +174,19 @@ 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)
           { ok: true, message: "Stopped LSP server for '#{lang_str}'" }
         end
       end
 
       def stop_all
         @monitor.synchronize do
-          @clients.each_value(&:stop)
+          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)
+          end
           @clients.clear
         end
       end
@@ -317,21 +256,21 @@ module Rubik
 
       def hover(file_path, line, character)
         client = client_for(file_path)
-        return { ok: false, error: "LSP not active for '#{file_path}'" } unless client&.running
+        return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
 
         client.hover(file_path, line, character)
       end
 
       def definition(file_path, line, character)
         client = client_for(file_path)
-        return { ok: false, error: "LSP not active for '#{file_path}'" } unless client&.running
+        return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
 
         client.definition(file_path, line, character)
       end
 
       def references(file_path, line, character)
         client = client_for(file_path)
-        return { ok: false, error: "LSP not active for '#{file_path}'" } unless client&.running
+        return { ok: false, error: inactive_client_error(file_path, client) } unless client&.running
 
         client.references(file_path, line, character)
       end
@@ -361,6 +300,120 @@ module Rubik
           servers: client_statuses
         }
       end
+
+      private
+
+      def language_for(language_or_file)
+        if language_or_file.is_a?(Client)
+          language_or_file.language.to_s.downcase
+        elsif language_or_file.to_s.include?(".")
+          detect_language(language_or_file)
+        else
+          language_or_file.to_s.downcase
+        end
+      end
+
+      # Caller MUST hold @monitor. Dead-client removal and replacement startup
+      # happen in one critical section so concurrent requests share one client.
+      def client_for_unlocked(lang, preferred = nil)
+        stored = @clients[lang]
+        client = stored || preferred
+        recovering = false
+
+        if client && client_dead?(client)
+          recovering = true
+          record_crash(lang)
+          stop_client_safely(client)
+          @clients.delete(lang) if stored.equal?(client)
+          client = nil
+        end
+
+        if recovering && circuit_open?(lang)
+          @recovery_errors[lang] = "LSP server restart for '#{lang}' is blocked by the circuit breaker"
+          return nil
+        end
+        if recovering && !@config.fetch("lsp.auto_start", true)
+          @recovery_errors[lang] = "LSP server restart for '#{lang}' is disabled"
+          return nil
+        end
+
+        return nil unless client || enabled?
+
+        if client.nil?
+          configured_cmd = @config.fetch("lsp.servers.#{lang}") || Client::SERVERS[lang]
+          client = Client.new(lang, root_dir: @root_dir, server_cmd: configured_cmd)
+          unless client.available?
+            probed_cmd = Runtime::Discovery.probe_lsp(lang, root_dir: @root_dir, custom_cmd: configured_cmd)
+            client = Client.new(lang, root_dir: @root_dir, server_cmd: probed_cmd) if probed_cmd
+          end
+
+          if client.available? && @config.fetch("lsp.auto_start", true) && !circuit_open?(lang)
+            if client.start
+              reset_circuit!(lang)
+              @recovery_errors.delete(lang)
+              register_client_unlocked(lang, client)
+            else
+              record_crash(lang)
+              stop_client_safely(client)
+              @recovery_errors[lang] = "LSP server restart failed for '#{lang}'" if recovering
+            end
+          elsif recovering
+            @recovery_errors[lang] = if circuit_open?(lang)
+                                       "LSP server restart for '#{lang}' is blocked by the circuit breaker"
+                                     elsif !@config.fetch("lsp.auto_start", true)
+                                       "LSP server restart for '#{lang}' is disabled"
+                                     else
+                                       "LSP server restart failed for '#{lang}': server unavailable"
+                                     end
+          end
+          @clients[lang] = client
+        elsif !client.running && @config.fetch("lsp.auto_start", true) &&
+              client.available? && !circuit_open?(lang)
+          if client.start
+            reset_circuit!(lang)
+            @recovery_errors.delete(lang)
+            register_client_unlocked(lang, client)
+          else
+            record_crash(lang)
+            stop_client_safely(client)
+            @recovery_errors[lang] = "LSP server restart failed for '#{lang}'" if recovering
+          end
+        end
+
+        client
+      end
+
+      def client_dead?(client)
+        (client.running && client.respond_to?(:alive?) && !client.alive?) ||
+          (client.respond_to?(:crashed?) && client.crashed?)
+      end
+
+      def register_client_unlocked(lang, client)
+        effective_ctx = @context || @runtime_manager&.context
+        return unless effective_ctx
+
+        effective_ctx.provide("lsp:#{lang}", client)
+        return if @registered_disposable_langs[lang] == effective_ctx.object_id
+
+        @registered_disposable_langs[lang] = effective_ctx.object_id
+        effective_ctx.register_disposable do
+          current = @clients[lang]
+          current.stop if current&.running
+        end
+      end
+
+      def stop_client_safely(client)
+        client.stop
+      rescue StandardError
+        nil
+      end
+
+      def inactive_client_error(file_path, client)
+        lang = client&.language || detect_language(file_path)
+        @monitor.synchronize do
+          @recovery_errors[lang] || "LSP not active for '#{file_path}'"
+        end
+      end
     end
   end
 end

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

@@ -28,9 +28,11 @@ module Rubik
       class Budget
         DEFAULT_MAX_STEPS = 88
         DEFAULT_GRANT_STEPS = 20
+        DEFAULT_MAX_TOTAL_STEPS = 256
 
-        def initialize(max_steps: nil)
-          @max_steps = (max_steps || DEFAULT_MAX_STEPS).to_i
+        def initialize(max_steps: nil, max_total_steps: DEFAULT_MAX_TOTAL_STEPS)
+          @max_total_steps = [(max_total_steps || DEFAULT_MAX_TOTAL_STEPS).to_i, 1].max
+          @max_steps = [(max_steps || DEFAULT_MAX_STEPS).to_i, @max_total_steps].min
           @current_step = 0
           @monitor = Monitor.new
         end
@@ -39,6 +41,10 @@ module Rubik
           @monitor.synchronize { @max_steps }
         end
 
+        def max_total_steps
+          @monitor.synchronize { @max_total_steps }
+        end
+
         def current_step
           @monitor.synchronize { @current_step }
         end
@@ -62,14 +68,16 @@ module Rubik
           @monitor.synchronize { "[Step #{@current_step}/#{@max_steps}]" }
         end
 
-        # Normalize -> floor -> +=, atomically. Returns the
-        # [extra, total] pair Instance's note lambda needs. Terminal-state
+        # Normalize -> floor -> cap, atomically. Returns the [extra, total]
+        # pair Instance's note lambda needs. Repeated grants can never push a
+        # run past its configured lifetime ceiling. Terminal-state
         # refusal, the :running transition, the history note, and the condvar
         # broadcast stay on Instance — lifecycle facts, not budget facts.
         # Called with the Instance monitor held (lock order: instance -> budget).
         def grant!(steps)
           @monitor.synchronize do
-            extra = Budget.normalize_grant(steps)
+            available = [@max_total_steps - @max_steps, 0].max
+            extra = [Budget.normalize_grant(steps), available].min
             @max_steps += extra
             [extra, @max_steps]
           end
@@ -80,11 +88,10 @@ module Rubik
           @monitor.synchronize { { current_step: @current_step, max_steps: @max_steps } }
         end
 
-        # Pure half of the grant invariant, shared by grant! (mutation edge)
-        # and the reporting edges (manage_subagents steps arg, REPL
-        # !subagents extend arg): nil/non-positive -> DEFAULT_GRANT_STEPS, so
-        # the number a caller echoes can never disagree with the number
-        # grant! applies. Idempotent.
+        # Pure normalization half shared by grant! and the reporting edges
+        # (manage_subagents steps arg, REPL !subagents extend arg). A grant
+        # may be smaller than this normalized request when the lifetime
+        # ceiling has less room remaining. Idempotent.
         def self.normalize_grant(steps)
           extra = (steps || DEFAULT_GRANT_STEPS).to_i
           extra = DEFAULT_GRANT_STEPS if extra <= 0

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

@@ -52,6 +52,7 @@ module Rubik
         # Budget delegation: step counters live in Subagent::Budget (reader contract preserved).
         def current_step = @budget.current_step
         def max_steps = @budget.max_steps
+        def max_total_steps = @budget.max_total_steps
 
         def initialize(id:, parent_id:, role:, type_name:, prompt:, context:, tool_registry:,
                        system_prompt: nil, workspace: "inherit", model: "inherit",
@@ -72,7 +73,15 @@ module Rubik
           @tool_registry = tool_registry
           @provider = provider
           @buffer_manager = buffer_manager
-          @budget = Budget.new(max_steps: max_steps)
+          max_total_steps = if config.is_a?(Hash)
+                              config["subagents.max_total_steps"] || config.dig("subagents", "max_total_steps") ||
+                                Budget::DEFAULT_MAX_TOTAL_STEPS
+                            elsif config.respond_to?(:fetch)
+                              config.fetch("subagents.max_total_steps", Budget::DEFAULT_MAX_TOTAL_STEPS)
+                            else
+                              Budget::DEFAULT_MAX_TOTAL_STEPS
+                            end
+          @budget = Budget.new(max_steps: max_steps, max_total_steps: max_total_steps)
           @root_dir = root_dir
           @config = config
           @event_bus = event_bus
@@ -189,7 +198,8 @@ module Rubik
         def to_h
           @monitor.synchronize do
             { id: @id, parent_id: @parent_id, role: @role, type: @type_name, state: @state.to_s,
-              **@budget.to_h, grants_received: @grants_received, run: @run_seq,
+              **@budget.to_h, max_total_steps: @budget.max_total_steps,
+              grants_received: @grants_received, run: @run_seq,
               result_ref: result_ref, owner: @owner_task&.id, detached: @owner_task.nil?, uptime_seconds: uptime.round(2),
               operation: operations.current, timings: operations.timings,
               last_progress_seconds_ago: operations.last_progress_seconds_ago,
@@ -230,6 +240,8 @@ module Rubik
             return false if terminal?
 
             extra, total = @budget.grant!(steps)
+            return false if extra <= 0
+
             transition!(:running)
             @grants_received += 1
             @pause_facts = nil # the wake retires the wait fact with the pause (B3's clearer, now fact-only)

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

@@ -22,9 +22,9 @@ module Rubik
       #
       # Retention is bounded independently of the model context: at most
       # `subagents.journal.max_bytes` per execution file. Once the cap is
-      # reached a final `journal_truncated` record marks the boundary and
-      # further events are not persisted (a cancellation outcome is recorded
-      # when the handler can still write one). Tool payloads are previewed
+      # reached a `journal_truncated` record marks the boundary; detail events
+      # stop, while reserved space preserves the terminal run/cancellation
+      # outcome. Tool payloads are previewed
       # (PREVIEW_CHARS) with explicit `output_chars` / `output_truncated`
       # metadata plus an `artifact_ref` to the conversation snapshot, so replay
       # can distinguish originals from summaries from clipped output.
@@ -37,10 +37,12 @@ module Rubik
       # in Instance#to_h), never raised into the run.
       class Journal
         FILENAME = "journal.jsonl"
-        DEFAULT_MAX_BYTES = 2_097_152
+        DEFAULT_MAX_BYTES = 8_388_608
         # Headroom kept free for the final truncation marker: accepted records
         # never consume the last bytes, so the marker always fits inside the cap.
         MARKER_RESERVE = 512
+        TERMINAL_RESERVE = 16_384
+        TERMINAL_EVENTS = ["run_finished", "cancelled"].freeze
         MIN_MAX_BYTES = 1024
         PREVIEW_CHARS = 4000
         ARGS_CHARS = 2000
@@ -54,9 +56,12 @@ module Rubik
           @path = path.to_s
           @monitor = Monitor.new
           @max_bytes = [config_get(config, "subagents.journal.max_bytes", DEFAULT_MAX_BYTES).to_i, MIN_MAX_BYTES].max
-          @seq = self.class.read(@path).records.length
+          existing_records = self.class.read(@path).records
+          @seq = existing_records.map { |record| record["seq"].to_i }.max || 0
           @bytes = File.exist?(@path) ? File.size(@path) : 0
-          @closed = false
+          @marker_reserve = [MARKER_RESERVE, @max_bytes / 4].min
+          @terminal_reserve = [TERMINAL_RESERVE, @max_bytes / 3].min
+          @closed = existing_records.any? { |record| record["event"] == "journal_truncated" }
           @last_error = nil
           @run_metrics = {}
         end
@@ -65,16 +70,24 @@ module Rubik
         # record envelope; the payload is masked HERE (single redaction gate).
         def append(event, run: 1, data: {}, call_id: nil)
           @monitor.synchronize do
-            return nil if @closed
+            event_name = event.to_s
+            terminal = TERMINAL_EVENTS.include?(event_name)
+            return nil if @closed && !terminal
 
             @last_run = run.to_i
             row = { "seq" => @seq + 1, "run" => @last_run, "ts" => Time.now.utc.iso8601(3),
-                    "event" => event.to_s, "data" => Rubik::Security::Redactor.mask_value(data) }
+                    "event" => event_name, "data" => Rubik::Security::Redactor.mask_value(data) }
             row["call_id"] = call_id.to_s if call_id
-            line = "#{Rubik::Platform.safe_json_generate(row)}\n"
-            if @bytes + line.bytesize + MARKER_RESERVE > @max_bytes
+
+            return append_terminal!(row) if @closed
+
+            line = serialize(row)
+            if @bytes + line.bytesize + @marker_reserve + @terminal_reserve > @max_bytes
               mark_truncated
-              return nil
+              return nil unless terminal
+
+              row["seq"] = @seq + 1
+              return append_terminal!(row)
             end
             return nil unless write!(line)
 
@@ -199,6 +212,35 @@ module Rubik
 
         private
 
+        def serialize(row) = "#{Rubik::Platform.safe_json_generate(row)}\n"
+
+        def append_terminal!(row)
+          line = serialize(row)
+          if @bytes + line.bytesize > @max_bytes
+            row["data"] = compact_terminal_data(row["data"])
+            line = serialize(row)
+          end
+          return nil if @bytes + line.bytesize > @max_bytes || !write!(line)
+
+          @seq += 1
+          @bytes += line.bytesize
+          row
+        end
+
+        def compact_terminal_data(data)
+          return {} unless data.is_a?(Hash)
+
+          summary = data.slice("state", "outcome", "duration_ms", "step_count")
+          ["state", "outcome"].each do |key|
+            summary[key] = summary[key].to_s.slice(0, 64) if summary.key?(key)
+          end
+          summary["reason"] = data["reason"].to_s.slice(0, 256) if data["reason"]
+          result_ref = data["result_ref"]
+          summary["result_ref"] = result_ref.to_s.slice(0, 128) if result_ref
+          summary["terminal_summary_truncated"] = true
+          summary
+        end
+
         def empty_run_metrics
           { tool_usage: {}, model_responses: 0, input_tokens: 0, output_tokens: 0,
             input_token_responses: 0, output_token_responses: 0 }
@@ -240,8 +282,9 @@ module Rubik
           @closed = true
           marker = { "seq" => @seq + 1, "run" => (@last_run || 1).to_i, "ts" => Time.now.utc.iso8601(3),
                      "event" => "journal_truncated",
-                     "data" => { "max_bytes" => @max_bytes, "reason" => "retention cap reached; further events are not journaled" } }
-          line = "#{Rubik::Platform.safe_json_generate(marker)}\n"
+                     "data" => { "max_bytes" => @max_bytes,
+                                 "reason" => "retention cap reached; detail events stop, terminal outcomes use reserved space" } }
+          line = serialize(marker)
           return nil if @bytes + line.bytesize > @max_bytes || !write!(line)
 
           @seq += 1

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

@@ -59,7 +59,7 @@ module Rubik
             drain_inbox_into_history
             @history << { role: "user", content: "[New task from maestro]: #{prompt}" }
             @prompt = prompt.to_s
-            @budget = Budget.new(max_steps: max_steps.to_i)
+            @budget = Budget.new(max_steps: max_steps.to_i, max_total_steps: @budget.max_total_steps)
             # @result reset is the ONE sanctioned clearer (terminal-only
             # contract): a new lineage begins. @pause_facts rides along —
             # the old run's wait fact must not narrate the new one.

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

@@ -69,11 +69,14 @@ module Rubik
         def build_effective_system_prompt
           base = "You are a specialized subagent operating under autonomous supervision.\n\n" \
                  "Subagent ID: #{@id} | Role: #{@role} | Type: #{@type_name}\n" \
-                 "Allocated Step Budget: #{@budget.max_steps} steps.\n\n" \
-                 "A [Step X/Y] status line precedes each of your steps (X = current step, Y = total budget). Pace yourself: " \
-                 "when remaining steps (Y - X) run low, conclude the task or prepare a progress summary for the maestro " \
-                 "supervisor — it may extend your budget or steer you. If a requirement is genuinely ambiguous, ask the maestro directly with the " \
-                 "ask_question tool — it blocks until the maestro answers or times out; ask only when the answer truly changes your work.\n\n" \
+                 "Allocated Step Budget: #{@budget.max_steps} steps; lifetime ceiling: " \
+                 "#{@budget.max_total_steps} steps across all grants.\n\n" \
+                 "A [Step X/Y] status line precedes each of your steps (X = current step, Y = total budget). " \
+                 "Pace yourself: when remaining steps (Y - X) run low, conclude the task or prepare a progress " \
+                 "summary for the maestro supervisor — it may extend your budget up to the lifetime ceiling or " \
+                 "steer you. If a requirement is genuinely ambiguous, ask the maestro directly with the " \
+                 "ask_question tool — it blocks until the maestro answers or times out; ask only when the answer " \
+                 "truly changes your work.\n\n" \
                  "Perform your assigned task with high precision and provide a structured synthesis report."
           @system_prompt && !@system_prompt.strip.empty? ? "#{base}\n\nCustom Instructions:\n#{@system_prompt}" : base
         end

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

@@ -38,6 +38,7 @@ module Rubik
       class Supervisor
         attr_accessor :tool_registry, :router, :init
         attr_reader :root_context, :type_registry, :instances, :max_depth, :max_concurrency, :default_max_steps,
+                    :max_total_steps,
                     :provider_gate, :result_archive
 
         include RedeploySupervisor
@@ -70,7 +71,12 @@ module Rubik
           @counter = 0
           @max_depth = (config&.fetch("subagents.max_depth", 2) || 2).to_i
           @max_concurrency = (config&.fetch("subagents.max_concurrency", 10) || 10).to_i
-          @default_max_steps = (config&.fetch("subagents.default_max_steps", Budget::DEFAULT_MAX_STEPS) || Budget::DEFAULT_MAX_STEPS).to_i
+          configured_max_total_steps = config&.fetch("subagents.max_total_steps", Budget::DEFAULT_MAX_TOTAL_STEPS) ||
+                                       Budget::DEFAULT_MAX_TOTAL_STEPS
+          @max_total_steps = [configured_max_total_steps.to_i, 1].max
+          configured_default_steps = config&.fetch("subagents.default_max_steps", Budget::DEFAULT_MAX_STEPS) ||
+                                     Budget::DEFAULT_MAX_STEPS
+          @default_max_steps = [configured_default_steps.to_i, @max_total_steps].min
           @provider_concurrency = (config&.fetch("subagents.provider_concurrency", 2) || 2).to_i
           @provider_gate = ConcurrencyGate.new(@provider_concurrency)
           # Retained completed-run results (issue #122): session-scoped,

data/lib/rubik/orchestrator/tool_circuit_breaker.rb

@@ -35,15 +35,25 @@ module Rubik
           when :open
             return false unless cooldown_elapsed?(circuit)
 
-            # one probe through the half-open gate
+            # Cooldown elapsed: enter half-open state and grant single probe
             circuit[:state] = :half_open
             circuit[:probing] = true
+            circuit[:opened_at] = now
             true
           when :half_open
             if circuit[:probing]
-              true
+              # Probe is currently in flight. If probe wedged past cooldown,
+              # allow a new probe to prevent permanent deadlock.
+              if cooldown_elapsed?(circuit)
+                circuit[:opened_at] = now
+                true
+              else
+                false
+              end
             else
-              cooldown_elapsed?
+              circuit[:probing] = true
+              circuit[:opened_at] = now
+              true
             end
           else
             true
@@ -53,7 +63,7 @@ module Rubik
 
       def record_success(tool_name)
         @monitor.synchronize do
-          @tools.delete(tool_name)
+          @tools.delete(tool_name.to_s)
         end
       end
 
@@ -76,7 +86,7 @@ module Rubik
       private
 
       def circuit(tool_name)
-        @tools[tool_name] ||= { failures: 0, opened_at: nil, probing: false, state: :closed }
+        @tools[tool_name.to_s] ||= { failures: 0, opened_at: nil, probing: false, state: :closed }
       end
 
       def cooldown_elapsed?(circuit)

data/lib/rubik/platform/process.rb

@@ -92,7 +92,7 @@ module Rubik
             # Plan 55 D-1 ile tutarlı dizi-form çağrı: cmd.exe ara katmanı ve kabuk
             # yönlendirmesi ("> NUL 2>&1") yerine out:/err: seçenekleri kullanılır.
             system("taskkill", "/F", "/T", "/PID", pid.to_s, out: File::NULL, err: File::NULL)
-          rescue
+          rescue StandardError
             nil
           end
         else

data/lib/rubik/platform/sanitize.rb

@@ -39,7 +39,7 @@ module Rubik
         debug_warn("clean_utf8 scrub fallback: #{e.class}: #{e.message}")
         begin
           str.to_s.scrub("")
-        rescue
+        rescue StandardError
           ""
         end
       end
@@ -108,7 +108,7 @@ module Rubik
         fallback = sanitize_for_json_fallback(obj)
         begin
           JSON.generate(fallback, *)
-        rescue
+        rescue StandardError
           "{}"
         end
       end
@@ -122,7 +122,7 @@ module Rubik
         fallback = sanitize_for_json_fallback(obj)
         begin
           JSON.dump(fallback, *)
-        rescue
+        rescue StandardError
           "{}"
         end
       end
@@ -148,7 +148,7 @@ module Rubik
         debug_warn("sanitize_for_json_fallback rescue: #{e.class}: #{e.message}")
         begin
           obj.to_s.scrub("")
-        rescue
+        rescue StandardError
           ""
         end
       end