rubik 0.1.0

data/lib/rubik/orchestrator/loop.rb

@@ -0,0 +1,388 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../prompt"
+require_relative "../prompt/conversation_rows"
+require_relative "activity_log"
+require_relative "shell_deps"
+require_relative "step_executor"
+require_relative "budget_manager"
+require_relative "stream_manager"
+require_relative "provider_resolver"
+require_relative "provider_recovery"
+require_relative "continuation_manager"
+require_relative "goal_wait"
+require_relative "subagent_notice_inbox"
+require_relative "turn_executor"
+require_relative "turn_executor/user_channel"
+require_relative "tool_call_id"
+require_relative "subagent/notices"
+
+module Rubik
+  module Orchestrator
+    class Loop
+      attr_accessor :history, :invalid_tool_count, :last_turn_streamed, :context_warning_emitted
+      attr_reader :max_steps, :step_count, :model, :total_tokens, :warn_at_ratio, :runtime_manager, :loop_context, :context_limit, :max_output_tokens, :config
+      # Collaborator-facing state (Plan 54 D-5): loop state physically stays on Loop;
+      # extracted collaborators reach it through these accessors.
+      attr_reader :provider, :on_step, :tool_registry, :shell, :buffer_manager, :lsp_manager, :step_executor,
+                  :budget_manager, :stream_manager, :activity
+
+      # Channel-owned counter (TurnExecutor::NudgePolicy); the public reader
+      # name is load-bearing (tests, REPL surfaces).
+      def empty_response_count = turn_executor.nudge_policy.count
+
+      def initialize(provider:, tool_registry:, max_steps: 40, warn_at_ratio: 0.75, model: nil, on_step: nil, shell: nil, context_limit: nil,
+                     max_output_tokens: nil)
+        @provider = provider
+        @tool_registry = tool_registry
+        @max_steps = (max_steps || 40).to_i
+        @warn_at_ratio = (warn_at_ratio || 0.75).to_f
+        @model = model
+        @on_step = on_step
+        # The shell must be STABLE from construction through run(): the
+        # ivars below snapshot its services at initialize (execution uses
+        # these), while the system prompt re-reads the public readers at
+        # run() start (Prompt::Services.from_shell) — a service swapped
+        # in between would make prompt and execution disagree.
+        @shell = shell
+        @buffer_manager = shell&.buffer_manager
+        @snapshot_store = shell&.snapshot_store
+        @context_index = shell&.context_index
+        @lsp_manager = shell&.lsp_manager
+        @config = shell&.config
+        @root_dir = File.expand_path(shell&.buffer_manager&.root_dir || Dir.pwd)
+        @runtime_manager = shell&.runtime_manager
+        @context_limit = context_limit || 32_768
+        @max_output_tokens = (max_output_tokens || (@config.respond_to?(:fetch) ? @config.fetch("llm.default_max_output_tokens", 4_096) : 4_096)).to_i
+        @loop_context = nil
+        @step_count = 0
+        @history = []
+        @total_tokens = { input: 0, output: 0 }
+        @invalid_tool_count = 0
+        @last_turn_streamed = false
+        @context_warning_emitted = false
+        # Plan 61 D-15: per-run activity ledger feeding the turn summary.
+        @activity = ActivityLog.new
+        # Plan 87 E-1: collaborators reach loop state only through the
+        # ShellDeps façade, not through raw @loop reach-through.
+        # Review Öneri 3: provider-config resolution follows the same
+        # collaborator-extraction pattern (ProviderResolver, built lazily
+        # on first use — see #provider_resolver).
+        @shell_deps = ShellDeps.new(self)
+        @step_executor = StepExecutor.new(@shell_deps)
+        @budget_manager = BudgetManager.new(@shell_deps)
+        @stream_manager = StreamManager.new(@shell_deps)
+        @continuation_manager = ContinuationManager.new(config: @config)
+        @subagent_notice_inbox = SubagentNoticeInbox.new
+        @goal_mode = false
+        @goal_wait = nil
+      end
+
+      # §7.2 item 3 (ContinuationManager mold): the notice queue lives in
+      # SubagentNoticeInbox; Loop keeps the original public names as
+      # delegation shims — repl/lifecycle.rb routes by respond_to?(
+      # :enqueue_subagent_notice), so that name is load-bearing.
+      def enqueue_subagent_notice(notice) = subagent_notice_inbox.enqueue(notice)
+
+      def drain_subagent_notices_into_history!
+        notices = subagent_notice_inbox.drain_all
+        return notices if notices.empty?
+
+        merge_notice_block_into_history!(Rubik::Orchestrator::Subagent::Notices.history_block(notices))
+        notices
+      end
+
+      # The merge policy lives in Prompt::ConversationRows (the row-dialect
+      # single home, shared with the REPL injector and the compaction layer).
+      def merge_notice_block_into_history!(xml_payload)
+        Prompt::ConversationRows.append_notice!(@history, xml_payload)
+      end
+
+      def subagent_notice_inbox = (@subagent_notice_inbox ||= SubagentNoticeInbox.new)
+
+      # Goal-mode flag (run/continue_loop lifecycle above) and the
+      # premature-completion guard collaborator. Lazy so Class#allocate
+      # test doubles — which skip initialize — answer goal_mode? false and
+      # never build the collaborator off a nil @shell_deps.
+      def goal_mode? = @goal_mode == true
+
+      def goal_wait
+        @goal_wait ||= GoalWait.new(@shell_deps)
+      end
+
+      def continuation_manager
+        @continuation_manager ||= ContinuationManager.new(config: @config)
+      end
+
+      # Agent-turn-executor plan: response processing is shared with the
+      # subagent channel through TurnExecutor; Loop supplies the
+      # user-channel adapter. Built lazily on first use, NOT in
+      # initialize: several test doubles construct loops via
+      # Class#allocate + instance_variable_set (build_knob_loop), which
+      # skips initialize.
+      def turn_executor
+        @turn_executor ||= TurnExecutor.new(channel: TurnExecutor::UserChannel.new(self))
+      end
+
+      def extend_budget(extra_steps) = (@max_steps += extra_steps.to_i)
+
+      def run(task_prompt, model: nil, plan_only: false, goal_mode: false, initial_context: nil, conversation_history: [])
+        @step_count = 0
+        @history = []
+        # Goal-mode marker for the premature-completion guard (GoalWait):
+        # set per run so a reused Loop instance cannot inherit the flag;
+        # continue_loop deliberately keeps it (same run resumed).
+        @goal_mode = goal_mode
+        # Fresh inbox per run, aligned with the history reset; continue_loop
+        # deliberately keeps the queue (SubagentNoticeInbox contract docs).
+        subagent_notice_inbox.reset_for_new_run!
+        @total_tokens = { input: 0, output: 0 }
+        @invalid_tool_count = 0
+        turn_executor.reset!
+        @context_warning_emitted = false
+        @activity&.reset!
+        continuation_manager&.reset!
+        @loop_context = @runtime_manager&.context&.extend
+
+        begin
+          target_model = model || @model
+          opts = target_model ? { model: target_model } : {}
+          opts[:tools] = @tool_registry.schemas unless plan_only
+
+          mode = if plan_only
+                   :plan
+                 else
+                   goal_mode ? :goal : :default
+                 end
+
+          # Prompt view built once at the composition boundary: the
+          # orchestrator resolves coeffects (skills index, type registry)
+          # and the prompt layer only renders (candidate 2, Phase 2).
+          services = Rubik::Prompt::Services.from_shell(@shell,
+                                                        skills_index: Rubik::Coeffects.get(@runtime_manager&.context, Rubik::Coeffects::SKILL_MANAGER)&.prompt_index,
+                                                        type_registry: resolve_type_registry,
+                                                        context_limit: @context_limit,
+                                                        max_output_tokens: @max_output_tokens,
+                                                        root_dir: @root_dir,
+                                                        extra_context: initial_context)
+          system_prompt = Rubik::Prompt::ContextBuilder.build_system_prompt(
+            mode: mode,
+            tool_schemas: plan_only ? [] : @tool_registry.schemas,
+            native_tools: !plan_only,
+            services: services
+          )
+
+          formatted_task = Rubik::Prompt::ContextBuilder.format_user_task(task_prompt)
+
+          @history << { role: "system", content: system_prompt }
+
+          # Inject prior dialogue turns if provided
+          if conversation_history && !conversation_history.empty?
+            conversation_history.each do |turn|
+              r = turn[:role] || turn["role"]
+              c = turn[:content] || turn["content"]
+              next if r.nil? || c.nil? || c.to_s.strip.empty?
+
+              @history << { role: r.to_s, content: c.to_s }
+            end
+          end
+
+          @history << { role: "user", content: formatted_task }
+
+          execute_steps(opts: opts, plan_only: plan_only)
+        ensure
+          @loop_context&.dispose
+        end
+      end
+
+      def continue_loop(extra_steps = 20, plan_only: false)
+        # Retention seam — see SubagentNoticeInbox#keep_for_continuation.
+        subagent_notice_inbox.keep_for_continuation
+        extend_budget(extra_steps)
+        target_model = @model
+        opts = target_model ? { model: target_model } : {}
+        opts[:tools] = @tool_registry.schemas
+
+        # Plan 61 D-14: notifications travel as their own user message —
+        # appending to @history.last may target a tool result or a
+        # content-less assistant message, which provider formatters then
+        # mangle.
+        continuation_msg = "<step_budget_extended extra=\"#{extra_steps}\" new_max=\"#{@max_steps}\" " \
+                           "current=\"#{@step_count}\" " \
+                           "message=\"User approved extending step budget by #{extra_steps} steps. " \
+                           "Continue working toward completion.\" />"
+        @history << { role: "user", content: continuation_msg }
+        execute_steps(opts: opts, plan_only: plan_only)
+      end
+
+      # Shared by both request paths (batch + streaming, Plan 63 Faz A):
+      # compact the history in place and emit the :emergency_compact event
+      # carrying the layer that produced the final history. Public because
+      # StreamManager's compact callable drives it through the ShellDeps
+      # façade. The compaction body lives in TurnExecutor#emergency_compact!
+      # — one home for both channels; the announce is channel-parameterized.
+      def emergency_compact_and_notify!(reason)
+        turn_executor.emergency_compact!(reason)
+      end
+
+      def safe_config(key, default)
+        return default unless @config.respond_to?(:fetch)
+
+        @config.fetch(key, default) || default
+      rescue KeyError, TypeError, NoMethodError
+        default
+      end
+
+      # Turn-result contract (public: the TurnExecutor user-channel adapter
+      # builds every terminal through it, and the shell drives
+      # continue_loop off the carried loop_instance).
+      def turn_result(success:, error: nil, output: nil)
+        r = { ok: success, steps: @step_count, tokens: @total_tokens, streamed: @last_turn_streamed == true, loop_instance: self }
+        r[:output] = output if output
+        r[:error] = error if error
+        r
+      end
+
+      private
+
+      # Registry-key + llm.* override resolution lives in ProviderResolver
+      # (review Öneri 3). Loop keeps thin private delegates with the
+      # original names/signatures so call sites and send()-based tests are
+      # untouched.
+      def provider_registry_key
+        provider_resolver.registry_key
+      end
+
+      def provider_llm_config(key, default)
+        provider_resolver.llm_config(key, default)
+      end
+
+      # Built lazily on first use, NOT in initialize: several test doubles
+      # construct loops via Class#allocate + instance_variable_set
+      # (build_knob_loop), which skips initialize. Reading @provider/
+      # @config at first use keeps that pattern working. Memoization is
+      # safe: the provider reference is immutable for the loop's lifetime
+      # and the config object is held by reference (values re-read per
+      # fetch — config reactivity preserved).
+      def provider_resolver
+        @provider_resolver ||= ProviderResolver.new(provider: @provider, config: @config)
+      end
+
+      def resolve_type_registry
+        if @runtime_manager&.context.respond_to?(:get)
+          sup = Rubik::Coeffects.get(@runtime_manager.context, Rubik::Coeffects::SUBAGENT_SUPERVISOR)
+          return sup.type_registry if sup&.type_registry
+        end
+
+        Rubik::Orchestrator::Subagent::TypeRegistry.new if @tool_registry&.get("invoke_subagent") && defined?(Rubik::Orchestrator::Subagent::TypeRegistry)
+      rescue StandardError => e
+        Rubik::Platform.debug_warn("type registry resolution failed (#{e.class}: #{e.message}); subagent typing degraded")
+        nil
+      end
+
+      def execute_steps(opts:, plan_only: false)
+        @invalid_tool_count = 0
+        turn_executor.reset!
+        warned = false
+
+        while @step_count < @max_steps
+          # Late-notice asymmetry is intentional: notices arriving after the
+          # final step drain nowhere — the user channel (turn-end flush) and
+          # manage_subagents wait remain their delivery path.
+          drain_subagent_notices_into_history!
+          @step_count += 1
+
+          warned = @budget_manager.evaluate_step_budget_warning!(warned)
+          verify_goal_ledger! if goal_mode?
+          @budget_manager.evaluate_context_compaction!
+          refresh_goal_ledger_row!
+
+          opts[:tools] = @tool_registry.schemas unless plan_only
+
+          prov_name = provider_registry_key || "custom"
+
+          @on_step&.call(
+            type: :thinking,
+            step: @step_count,
+            max_steps: @max_steps,
+            model: opts[:model] || @model,
+            provider: prov_name
+          )
+
+          res = send_llm_request_with_recovery(opts)
+          result = turn_executor.call(res, plan_only: plan_only)
+          return result if result
+        end
+
+        { ok: false, error: "Max steps budget exceeded (#{@max_steps})", steps: @step_count, tokens: @total_tokens, loop_instance: self }
+      end
+
+      # Goal-ledger adım-baı yenilemesi (goal-ledger planı A): compaction
+      # SONRADA, request ÖNCE — refresh her zaman güncel history referansını
+      # görür (BudgetManager history'yi yeni diziye bağlar) ve güncel Σ
+      # satırı her adımda garanti edilir. GOAL_LEDGER coeffect'i yoksa
+      # (knob OFF ya da !goal dışı) tek satırda no-op — davranış değişmez.
+      # Goal-ledger yeniden-doğrulama (plan B): :turn_finished goal
+      # çalışırken HİÇ fire etmez (senkron bloklamalı !goal) — turn sınırı
+      # execute_steps iterasyonudur, bu yüzden doğrudan hook. Hata
+      # izolasyonu: doğrulama asla akışı bozmaz.
+      def verify_goal_ledger!
+        Rubik::Orchestrator::GoalLedger::Verifier.at_step_boundary!(self)
+      rescue StandardError => e
+        # Dürüst kanal (Log.warn): debug_warn ENV-gated no-op'tur — doğrulama
+        # çöktüğünde drift tespiti sessizce duramaz (sessiz-yutma yasağı).
+        Rubik::Log.warn(:orchestrator, "goal ledger verification failed (#{e.class}: #{e.message}); step continues unverified")
+      end
+
+      def refresh_goal_ledger_row!
+        ledger = Rubik::Coeffects.get(@runtime_manager&.context, Rubik::Coeffects::GOAL_LEDGER)
+        ledger&.refresh_in_history!(@history)
+      rescue StandardError => e
+        Rubik::Log.warn(:orchestrator, "goal ledger refresh failed (#{e.class}: #{e.message}); step continues")
+      end
+
+      def send_llm_request_with_recovery(opts)
+        streaming_enabled = if opts.key?(:stream)
+                              opts[:stream] == true
+                            else
+                              provider_llm_config("stream", true) != false
+                            end
+
+        # Plan 61 D-1/D-3: the wire request must share the compaction math's
+        # assumptions. Ollama needs context_limit (sent as num_ctx) or its
+        # server silently clips the prompt head to the model default; strict
+        # providers need max_tokens or output falls back to tiny defaults
+        # (e.g. Anthropic's 1024).
+        effective_opts = opts.key?(:on_retry) ? opts.dup : opts.merge(on_retry: @stream_manager.llm_retry_notifier)
+        effective_opts[:context_limit] = @context_limit if @context_limit
+        effective_opts[:max_tokens] = @max_output_tokens if @max_output_tokens&.positive?
+        effective_opts[:stream_timeout] ||= provider_llm_config("stream_timeout", ProviderRecovery::STREAM_REQUEST_TIMEOUT)
+        effective_opts[:open_timeout] ||= provider_llm_config("open_timeout", ProviderRecovery::DEFAULT_OPEN_TIMEOUT)
+        effective_opts[:timeout] ||= effective_opts[:stream_timeout]
+        # Plan 90 completion: the llm.thinking_budget_ratio / llm.reasoning_effort
+        # knobs reach the adapters only through this bridge. Both default to nil
+        # (never sent); the key must stay ABSENT when unset — openai_compatible's
+        # reasoning_model? tests opts.key?(:reasoning_effort), so even a nil
+        # value would flip every model onto the reasoning payload branch.
+        ratio = provider_llm_config("thinking_budget_ratio", nil)
+        effective_opts[:thinking_budget_ratio] ||= ratio if ratio
+        effort = provider_llm_config("reasoning_effort", nil)
+        effective_opts[:reasoning_effort] ||= effort if effort
+
+        if streaming_enabled && @provider.respond_to?(:stream_chat)
+          @stream_manager.execute_streaming_request(effective_opts)
+        else
+          execute_batch_request(effective_opts)
+        end
+      end
+
+      def execute_batch_request(opts)
+        @last_turn_streamed = false
+        ProviderRecovery.with_recovery(config: @config, compact: method(:emergency_compact_and_notify!)) do
+          @provider.complete(@history, opts)
+        end
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/lsp_feedback.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    # Gerçek zamanlı LSP tampon-tanı geri beslemesi (Plan 56 D-5) —
+    # StepExecutor'dan dürüst çıkarım (satır bütçesi; storage-show-surface
+    # planı A'nın :user_output kancası yerine yer açar). Yazma araçlarının
+    # ardından tampon LSP'ye senkronize edilir; severity-1 tanılar varsa
+    # sonuç çıktısına düzeltme yönlendirmesi eklenir.
+    module LspFeedback
+      module_function
+
+      WRITER_TOOLS = ["write_file", "replace_file_content"].freeze
+
+      def refresh(deps:, tool_instance:, tool_args:, tool_result:)
+        return tool_result unless tool_result.status == :ok
+        return tool_result unless WRITER_TOOLS.include?(tool_instance&.name)
+        return tool_result unless deps.lsp_manager&.enabled?
+
+        written_file = tool_args["path"] || tool_args[:path]
+        return tool_result unless written_file && deps.buffer_manager
+
+        content = deps.buffer_manager.read(written_file)
+        synced = deps.lsp_manager.sync_buffer_file(written_file, content)
+        return tool_result unless synced && deps.lsp_manager.auto_diagnostics?
+
+        append_diagnostics(deps, written_file, tool_result)
+      rescue StandardError => e
+        # Loop exposes no logger; the old @loop.logger&.debug raised
+        # NoMethodError from inside this rescue itself (fresh-eye
+        # review, Plan 87). warn keeps the failure visible on stderr;
+        # ANSI stripping keeps LSP-server-controlled messages from
+        # injecting terminal escape sequences (red-team E1).
+        warn("LSP sync skipped: #{e.message.gsub(/\e\[[0-9;]*[A-Za-z]/, '')}")
+        tool_result
+      end
+
+      def append_diagnostics(deps, written_file, tool_result)
+        sleep 0.05
+        diags = deps.lsp_manager.diagnostics_for(written_file)
+        errors = diags.select { |d| d["severity"] == 1 }
+        return tool_result if errors.empty?
+
+        err_lines = errors.map { |e| "  • Line #{(e.dig('range', 'start', 'line') || 0) + 1}: #{e['message']}" }.join("\n")
+        lsp_msg = "\n\n⚠️ [LSP Real-Time Compiler Diagnostics - #{errors.size} error(s)]:\n#{err_lines}\n" \
+                  "Please fix these compilation/type errors before proceeding."
+        Rubik::Tools::Result.new(
+          tool_name: tool_result.tool_name, call_id: tool_result.call_id, status: tool_result.status,
+          output: "#{tool_result.output}#{lsp_msg}", duration_ms: tool_result.duration_ms,
+          truncated: tool_result.truncated
+        )
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/maestro_gate.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "../tools/catalog"
+require_relative "tool_history"
+
+module Rubik
+  module Orchestrator
+    # Maestro kapısı (kullanıcı kararı 2026-10-01, opencode-personal
+    # bulgusu): maestro HER modda saf orkestratördür — kök ajanın doğrudan
+    # yürütme araç çağrıları ÇALIŞTIRILMADAN reddedilir ve subagent'a
+    # yönlendirilir. Yalnız StepExecutor (Loop'un kök yolu) bu modülü
+    # içerir: subagent'lar StepRunner'ın kendi dispatch'inden gider, buraya
+    # asla uğramaz. Config subagents.maestro_gate ile aç/kapa (default
+    # açık); kapı canlı okur ama ajan config'i değiştiremez (workspace.rb
+    # Paket D: subagents.* operatör-only) — self-unlock yolu kapalı.
+    module MaestroGate
+      # Kapı sınıfı Tools::Catalog'un maestro_blocked projeksiyonundan türetil
+      # (tek kaynak: her aracın DECLARATION'ı); her :write/:execute araç beyanı
+      # açıkça vermek zorundadır — yeni bir mutasyon aracı sessizce kapıdan
+      # kaçamaz (no-silent-escape invariant'i,
+      # test_tool_declaration_catalog.rb). Yalnız YÜRÜTME araçları kapılı:
+      # salt-okunur keşif, storage, ask_question ve finish serbest.
+      # manage_task action-bazlıdır: start = run_command eşdeğeri arka plan
+      # shell'i; list/status/logs/send_input/kill orkestrasyon komşusu olarak
+      # serbest kalır.
+      def maestro_gate_blocks?(canonical_name, tool_args = {})
+        return false unless Rubik::Tools::Catalog.maestro_blocked?(canonical_name)
+        return false if canonical_name == "manage_task" &&
+                        !["start"].include?((tool_args["action"] || tool_args[:action]).to_s.downcase.strip)
+
+        # Kapıyı çalışma anında config'den oku (!config set ile operatör
+        # aç/kapa mümkün). Gerçek Config dotted fetch'i çözer
+        # ("subagents.maestro_gate"); düz Hash (test doubles) nested tutar —
+        # dig fallback'i iki şekli de kapsar (dotted-key config gotchası).
+        cfg = @deps.shell&.config
+        return true unless cfg.respond_to?(:fetch)
+
+        raw = cfg.fetch("subagents.maestro_gate", nil)
+        raw = cfg.dig("subagents", "maestro_gate") if raw.nil? && cfg.respond_to?(:dig)
+        raw != false
+      end
+
+      # Red = yönlendirme: mesaj ne olduğunu, neden ve NASIL düzgün
+      # yapılacağını söyler (empathetic error, AGENTS.md §5). invalid-tool
+      # sayacına dokunmaz — bu çağrı geçersiz değil, devredilmiş bir istek.
+      def maestro_refusal(canonical_name, tool_name, call_id)
+        result = Rubik::Tools::Result.new(
+          tool_name: tool_name,
+          call_id: call_id,
+          status: :error,
+          error: "Maestro gate: '#{canonical_name}' is delegated to subagents.",
+          output: "Maestro doctrine: the maestro is a pure orchestrator and never executes '#{canonical_name}' itself — " \
+                  "execution work belongs to subagents in every mode. This call was NOT executed. Dispatch a subagent instead: " \
+                  "invoke_subagent with type_name 'coder' (file edits, tests, commands, background processes) or 'research' " \
+                  "(read-only exploration), then collect results via manage_subagents (action: 'wait' or 'transcript') and " \
+                  "steer with send_message, or hand follow-ups to a finished subagent with manage_subagents (action: 'redeploy').",
+          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: result.to_xml)
+        @deps.activity.record(canonical_name, {}, :error) if @deps.respond_to?(:activity) && @deps.activity
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/provider_recovery.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    # Deep module (Candidate 03): the ONE home for provider-call recovery
+    # policy. Three call sites carried private copies of the same
+    # rescue/retry/compact control flow and drifted (a streaming retry that
+    # re-used the failed attempt's chunks, a silent subagent compaction,
+    # three config-gate spellings). This module owns everything the policy
+    # needs and nothing it does not.
+    #
+    #   owns   : overflow classification, auto-recover gate, retry-once
+    #            control flow, compaction-config resolution, request-timeout
+    #            defaults
+    #   leaves : the provider call itself (the block); which history is
+    #            compacted and what observability fires (the compact
+    #            callable — each site's emergency_compact_and_notify!)
+    #
+    # Idiom (load-bearing): keep ALL per-attempt state inside the block.
+    # `retry` re-executes the begin, which re-yields, which re-runs the
+    # block with fresh block-locals — the structural fix for the streaming
+    # chunk-pollution bug. Interrupt is not a StandardError and escapes.
+    module ProviderRecovery
+      # Provider errors matching this are context-window overflows (OpenAI
+      # context_length_exceeded, Anthropic "prompt is too long", generic
+      # token-limit wording). Collapsed from the three former inline regexes.
+      #
+      # NOTE: a bare /context/ alternative is deliberately absent. Go-based
+      # provider proxies surface transport failures as "context deadline
+      # exceeded" / "context canceled" — those must fail (or retry at the
+      # transport layer), never trigger the emergency compaction this gate
+      # unwinds into, which is destructive and irreversible.
+      OVERFLOW_PATTERN = /context_length|context window|maximum context|prompt is too long|token limit|too many tokens/i
+
+      # Config gate for the automatic compaction+retry (default: on).
+      AUTO_RECOVER_KEY = "context.auto_recover_on_overflow"
+
+      # Config section every compaction call site resolves.
+      COMPACTION_CONFIG_KEY = "context"
+
+      # Named request-timeout defaults. Per-site values preserved on
+      # purpose: a subagent step is a short focused call; the shell's
+      # streaming turn may legitimately think longer.
+      DEFAULT_OPEN_TIMEOUT = 15
+      SUBAGENT_REQUEST_TIMEOUT = 90
+      STREAM_REQUEST_TIMEOUT = 120
+
+      module_function
+
+      # Executes the provider call with context-overflow recovery. On the
+      # first overflow-classified StandardError: run the site's compact
+      # callable (reason = the provider's error message), then retry the
+      # block exactly once. Everything else re-raises untouched, including
+      # Interrupt (not a StandardError) and errors raised by compact itself
+      # (fail loud — half-recovered state must surface, never be swallowed).
+      def with_recovery(config:, compact:)
+        retry_attempted = false
+        begin
+          yield
+        rescue StandardError => e
+          raise e unless !retry_attempted && auto_recover?(config) && overflow_error?(e)
+
+          retry_attempted = true
+          compact.call(e.message)
+          retry
+        end
+      end
+
+      # Defensive resolution of the "context" config section shared by every
+      # compaction call site: nil config, fetch-less objects, and null YAML
+      # sections all collapse to {}. One spelling replaces five.
+      def compaction_config(config)
+        cfg = config.respond_to?(:fetch) ? config.fetch(COMPACTION_CONFIG_KEY, {}) : {}
+        cfg.is_a?(Hash) ? cfg : {}
+      end
+
+      # ── implementation details (not interface) ────────────────────────
+
+      def auto_recover?(config)
+        config.respond_to?(:fetch) ? config.fetch(AUTO_RECOVER_KEY, true) : true
+      end
+
+      def overflow_error?(err)
+        err.message.to_s.match?(OVERFLOW_PATTERN)
+      end
+
+      private_class_method :auto_recover?, :overflow_error?
+    end
+  end
+end

data/lib/rubik/orchestrator/provider_resolver.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    # Provider-scoped configuration resolution for the orchestrator loop
+    # (review Öneri 3; extracted from Loop's provider-config section).
+    #
+    # Owns two lookups:
+    # - registry_key: registry-style key of the active provider — the
+    #   explicit provider name (downcased, the way the registry stores
+    #   them) when it carries one, else the class name derived the way
+    #   builtin providers are registered (Rubik::LLM::OllamaProvider ->
+    #   "ollama"). An empty name counts as unnamed, so instances built
+    #   outside the registry keep falling back.
+    # - llm_config: per-provider llm.* override — providers.<key>.<field>
+    #   beats the global llm.<field>, so a provider-specific quirk (e.g. a
+    #   broken SSE stack) can be tuned without flipping the knob for every
+    #   provider. A scoped nil counts as unset — also the only way to
+    #   clear an override back to the global value.
+    #
+    # The config object is held by reference and values are re-read on
+    # every fetch, so !config set / !provider set still apply from the
+    # very next turn (config reactivity, Plan 75).
+    class ProviderResolver
+      def initialize(provider:, config:)
+        @provider = provider
+        @config = config
+      end
+
+      # Registry-style key for the active provider: the explicit provider name
+      # when it carries one (downcased, the way the registry stores them),
+      # else the class name derived the way builtin providers are registered
+      # (Rubik::LLM::OllamaProvider -> "ollama"). An empty name counts as
+      # unnamed, so instances built outside the registry keep falling back.
+      def registry_key
+        explicit = @provider.respond_to?(:name) ? @provider.name.to_s.downcase : ""
+        return explicit unless explicit.empty?
+
+        klass_name = @provider.class.name
+        base = klass_name&.split("::")&.last
+        base&.delete_suffix("Provider")&.downcase
+      end
+
+      # Per-provider llm.* override: providers.<key>.<field> beats the global
+      # llm.<field>, so a provider-specific quirk (e.g. a broken SSE stack)
+      # can be tuned without flipping the knob for every provider. Re-read on
+      # each request: !config set / !provider set apply from the very next
+      # turn. A scoped nil counts as unset — also the only way to clear an
+      # override back to the global value.
+      def llm_config(key, default)
+        prov_key = registry_key
+        if prov_key.is_a?(String) && !prov_key.empty? && @config.respond_to?(:fetch)
+          val = @config.fetch("providers.#{prov_key}.#{key}", nil)
+          return val unless val.nil?
+        end
+
+        # Two-arg fetch, not safe_config: safe_config's `fetch(...) || default`
+        # would coerce an explicit false (llm.stream=false) into the truthy
+        # default, and a one-arg fetch on a plain-Hash config (tests) raises
+        # KeyError instead of falling through.
+        return default unless @config.respond_to?(:fetch)
+
+        @config.fetch("llm.#{key}", default)
+      rescue StandardError
+        default
+      end
+    end
+  end
+end