rubik 0.1.0

data/lib/rubik/orchestrator/budget_manager.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../prompt"
+require_relative "provider_recovery"
+require_relative "goal_ledger"
+
+module Rubik
+  module Orchestrator
+    # Step-budget warnings, token accounting and context-compaction decisions
+    # (Plan 54 D-6). Stateless collaborator over Loop-held state: counters are
+    # read through accessors at call time (tests may poke them between calls)
+    # and the total_tokens hash is mutated in place so Loop's reader keeps its
+    # object identity.
+    class BudgetManager
+      # Plan 87 E-1: state is reached through the ShellDeps façade. Accepts a
+      # bare loop for compatibility with existing test doubles (wrapped).
+      def initialize(loop_or_deps)
+        @deps = ShellDeps.wrap(loop_or_deps)
+      end
+
+      def evaluate_step_budget_warning!(warned)
+        # Threshold computed at call time: a live `!steps <n>` extension raises
+        # max_steps mid-run, and the next evaluation must use the new budget's
+        # 75% point instead of a stale pre-extension threshold.
+        warn_step = (@deps.max_steps * @deps.warn_at_ratio).ceil
+        return warned if warned || @deps.step_count < warn_step || @deps.step_count >= @deps.max_steps
+
+        remaining = @deps.max_steps - @deps.step_count
+        # Plan 61 D-14: send as its own user message — concatenating onto
+        # @history.last can weld the XML onto a tool result or a
+        # content-less assistant message, which provider formatters mangle.
+        warning_xml = "<step_budget current=\"#{@deps.step_count}\" max=\"#{@deps.max_steps}\" remaining=\"#{remaining}\" " \
+                      "alert=\"Step budget nearing limit (#{remaining} steps left). Please begin concluding your work, " \
+                      "verify with tests/diagnostics, and call finish. If the task genuinely needs more room, you may " \
+                      "raise the live step budget with exec_repl_command('!steps <n>') where n is the new total.\" />"
+        @deps.history << { role: "user", content: warning_xml }
+        @deps.on_step&.call(type: :step_warning, current: @deps.step_count, max: @deps.max_steps, remaining: remaining)
+        true
+      end
+
+      def evaluate_context_compaction!
+        return unless @deps.context_limit
+
+        context_cfg = ProviderRecovery.compaction_config(@deps.config)
+        needs = Rubik::Prompt::ContextCompactor.needs_compaction?(
+          @deps.history, context_limit: @deps.context_limit,
+                         max_output_tokens: @deps.max_output_tokens, config: context_cfg
+        )
+        return unless needs
+
+        # compact_history is pure and returns a new array, so the history
+        # reference itself must be rebound on Loop. absorb (plan D): the
+        # directive is nil unless goal-mode + knobs + coeffect + rev ≥ 1
+        # all hold — otherwise compaction stays byte-identical.
+        @deps.replace_history!(Rubik::Prompt::ContextCompactor.compact_history(
+                                 @deps.history, context_limit: @deps.context_limit,
+                                                max_output_tokens: @deps.max_output_tokens, config: context_cfg,
+                                                absorb: GoalLedger::ObservationProjection.directive_for(deps: @deps)
+                               ))
+      end
+
+      def track_token_usage!(res)
+        return unless res.respond_to?(:usage) && res.usage
+
+        in_tokens = res.usage[:input_tokens] || res.usage["input_tokens"] || 0
+        @deps.total_tokens[:input] += in_tokens
+        @deps.total_tokens[:output] += res.usage[:output_tokens] || res.usage["output_tokens"] || 0
+        warn_context_truncation!(in_tokens)
+      end
+
+      # Plan 61 D-1: usage input_tokens is the server's ground truth. When
+      # it approaches the configured window the provider (not the compactor)
+      # is clipping the prompt head — surface it once so silent context loss
+      # becomes visible instead of reading as "the model forgot everything".
+      def warn_context_truncation!(in_tokens)
+        return if @deps.context_limit.nil? || in_tokens.to_i <= 0
+        return if in_tokens.to_i < (@deps.context_limit * 0.9)
+        return if @deps.context_warning_emitted
+
+        @deps.flag_context_warning!
+        @deps.on_step&.call(
+          type: :context_truncation_warning,
+          input_tokens: in_tokens.to_i,
+          context_limit: @deps.context_limit,
+          step: @deps.step_count,
+          max_steps: @deps.max_steps
+        )
+      end
+
+      def estimate_tokens_from_history
+        # Use the same estimator as the compaction math (Plan 61 D-1): the
+        # usage fallback must agree with the window the request was sized for.
+        Rubik::Prompt::TokenEstimator.estimate_history(@deps.history)
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/continuation_manager.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    # Manages auto-continuation when an LLM response is truncated due to
+    # reaching max_output_tokens (finish_reason == "length" or "max_tokens").
+    #
+    # Responsible for:
+    # 1. Distinguishing between reasoning/thinking exhaustion (empty text)
+    #    and content truncation (mid-sentence cut-off).
+    # 2. Buffering and stitching partial text across continuation turns.
+    # 3. Generating targeted, non-repetitive continuation prompts.
+    # 4. Enforcing the max_auto_continues safety ceiling to prevent runaways.
+    class ContinuationManager
+      TRUNCATION_REASONS = ["length", "max_tokens"].freeze
+
+      attr_reader :auto_continue_count, :continuation_buffer, :max_auto_continues
+
+      def initialize(config: nil, max_auto_continues: nil)
+        @config = config
+        @max_auto_continues = (max_auto_continues || safe_config("llm.max_auto_continues", 3)).to_i
+        @auto_continue_count = 0
+        @continuation_buffer = +""
+      end
+
+      def enabled?
+        return true if @config.nil?
+
+        safe_config("llm.auto_continue_on_length", true) == true
+      end
+
+      def truncation?(finish_reason)
+        TRUNCATION_REASONS.include?(finish_reason.to_s.downcase)
+      end
+
+      def ceiling_reached?
+        @auto_continue_count >= @max_auto_continues
+      end
+
+      # Classifies the truncation scenario:
+      # - :thinking_exhausted when text and tools are empty (budget spent on thought)
+      # - :text_truncated when partial text was produced
+      # - :tool_truncated when partial tool call was being assembled
+      def classify_truncation(text_resp, tool_calls, _res = nil)
+        if tool_calls.empty?
+          if text_resp.to_s.strip.empty?
+            :thinking_exhausted
+          else
+            :text_truncated
+          end
+        else
+          # Tool call was partially assembled or arguments broken due to cut-off
+          :tool_truncated
+        end
+      end
+
+      # Handles a truncation event.
+      # Returns a Hash:
+      #   { continue: true, nudge: "...", step_event: {...} }
+      # or
+      #   { continue: false, error: "..." } if ceiling reached or disabled.
+      def handle_truncation(finish_reason:, text_resp:, tool_calls:, res: nil, max_tokens: 4096)
+        return { continue: false } unless truncation?(finish_reason)
+
+        unless enabled?
+          rec = (max_tokens.to_i * 2).positive? ? max_tokens.to_i * 2 : 8192
+          diag = "⚠️ Model çıktısı maksimum token sınırına (max_output_tokens: #{max_tokens}) ulaştığı için tamamlanamadan kesildi.\n" \
+                 "Çözüm: Çıktı token bütçesini artırmak için şu komutu çalıştırabilirsiniz:\n  !config set llm.default_max_output_tokens #{rec}"
+          return { continue: false, error: diag }
+        end
+
+        if ceiling_reached?
+          rec = (max_tokens.to_i * 2).positive? ? max_tokens.to_i * 2 : 8192
+          diag = "⚠️ Model çıktısı maksimum token sınırına (max_output_tokens: #{max_tokens}) ulaştığı için " \
+                 "ve #{@max_auto_continues} otomatik devam denemesi tükendiği için durduruldu.\n" \
+                 "Çözüm: Çıktı token bütçesini artırmak için şu komutu çalıştırabilirsiniz:\n  !config set llm.default_max_output_tokens #{rec}"
+          return { continue: false, error: diag }
+        end
+
+        scenario = classify_truncation(text_resp, tool_calls, res)
+        @auto_continue_count += 1
+
+        case scenario
+        when :thinking_exhausted
+          {
+            continue: true,
+            scenario: :thinking_exhausted,
+            nudge: "Your thinking process reached the output token limit before producing a response or tool call. " \
+                   "Do not repeat your reasoning; immediately provide your final response or invoke the necessary tool call concisely.",
+            thought: res.respond_to?(:thought) ? res.thought : nil,
+            step_event: { type: :auto_continue, reason: :thinking_exhausted, count: @auto_continue_count, max: @max_auto_continues }
+          }
+        when :text_truncated
+          @continuation_buffer << text_resp.to_s
+          {
+            continue: true,
+            scenario: :text_truncated,
+            partial_text: text_resp.to_s,
+            nudge: "Your previous response was cut off because it reached the output token limit. " \
+                   "Continue directly and seamlessly from the exact character/code line where you stopped. " \
+                   "Do not repeat previous text or restart.",
+            step_event: { type: :auto_continue, reason: :text_truncated, count: @auto_continue_count, max: @max_auto_continues }
+          }
+        when :tool_truncated
+          {
+            continue: true,
+            scenario: :tool_truncated,
+            nudge: "Your tool call was cut off due to the output token limit. Please re-invoke the tool call directly with concise arguments.",
+            step_event: { type: :auto_continue, reason: :tool_truncated, count: @auto_continue_count, max: @max_auto_continues }
+          }
+        end
+      end
+
+      # Stitches any accumulated continuation buffer with the final response
+      # text and resets the continuation state.
+      def stitch_and_reset(final_text)
+        stitched = if @continuation_buffer.empty?
+                     final_text.to_s
+                   else
+                     @continuation_buffer + final_text.to_s
+                   end
+        reset!
+        stitched
+      end
+
+      def reset!
+        @auto_continue_count = 0
+        @continuation_buffer = +""
+      end
+
+      private
+
+      def safe_config(key, default)
+        return default unless @config
+
+        if @config.respond_to?(:fetch)
+          begin
+            val = @config.fetch(key)
+            return val unless val.nil?
+          rescue KeyError, ArgumentError
+            nil
+          end
+        end
+
+        if key.include?(".") && @config.respond_to?(:dig)
+          val = @config.dig(*key.split("."))
+          return val unless val.nil?
+        end
+
+        if @config.respond_to?(:[])
+          val = @config[key]
+          return val unless val.nil?
+        end
+
+        default
+      rescue KeyError, TypeError, NoMethodError
+        default
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/finish_message_selector.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    # Selects the final message shown to the user when the agent finishes.
+    # Extracted from StepExecutor#handle_finish_tool (review Finding 5): the
+    # heuristic was inline, undocumented, and its magic substring
+    # `!clean_text_resp.include?("tool")` had no explanation of intent.
+    #
+    # Inputs (both already normalized by the caller):
+    #   narration — the turn's free text with JSON tool-call blocks stripped
+    #               (StepExecutor#clean_llm_text), stripped and possibly empty.
+    #   tool_msg  — the finish tool's `message` argument, stripped.
+    #
+    # Selection (behavior preserved exactly from the inline version):
+    #   1. tool_msg non-empty and NOT a generic filler ("completed", "done",
+    #      "finished", "ok", "task_completed"):
+    #        - narration and message don't subsume each other -> both, joined.
+    #        - otherwise keep the richer (longer) one, unless the narration is
+    #          mere tool-usage narration (see NARRATION_TOOL_HINT below).
+    #   2. tool_msg empty or generic filler: prefer the narration if present.
+    #   3. Neither has content: fallback constant.
+    #
+    # The narration-skip heuristic: a narration that merely mentions "tool"
+    # ("I'll use the run_tests tool next...") is process talk, not an answer;
+    # the finish tool's message is the better user-facing summary, so the
+    # message wins even when the narration is longer.
+    module FinishMessageSelector
+      GENERIC_FILLERS = ["completed", "done", "finished", "ok", "task_completed"].freeze
+      NARRATION_TOOL_HINT = "tool"
+      DEFAULT_MESSAGE = "Completed"
+
+      module_function
+
+      def select(narration, tool_msg)
+        narration = narration.to_s
+        tool_msg = tool_msg.to_s
+
+        if !tool_msg.empty? && !GENERIC_FILLERS.include?(tool_msg.downcase)
+          if !narration.empty? && !narration.include?(tool_msg) && !tool_msg.include?(narration)
+            "#{narration}\n\n#{tool_msg}"
+          elsif narration.length > tool_msg.length && !narration.include?(NARRATION_TOOL_HINT)
+            narration
+          else
+            tool_msg
+          end
+        elsif !narration.empty?
+          narration
+        else
+          tool_msg.empty? ? DEFAULT_MESSAGE : tool_msg
+        end
+      end
+    end
+  end
+end

data/lib/rubik/orchestrator/goal_ledger/drift.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rubik
+  module Orchestrator
+    module GoalLedger
+      # Drift işleme (goal-ledger planı B): failed-doğrulamaların iç mutasyona
+      # eşlenmesi (flip + last_check annotation), sessiz :ledger_drift
+      # emission'u ve reinjection taşıyıcısı DriftNote.
+      #
+      # Sessizlik sözleşmesi: :ledger_drift WAKE_KINDS DIŞINDADIR —
+      # notice/wake üretmez, vakanüvis abone değildir (yalnız kronik
+      # bus'da kaybolur); GoalState#notify_finish mold'ü: post fire-and-
+      # forget, rescue → Log.warn. Bus yoksa tamamen sessiz atlanır.
+      module Drift
+        EVENT = :ledger_drift
+        MAX_NOTE_ENTRIES = 8
+        MAX_NOTE_CHARS = 300
+
+        module_function
+
+        def emit(trigger:, ledger:, flips:, unknowns:, rev:)
+          bus = ledger.event_bus
+          unless bus.respond_to?(:post)
+            # Dürüst degradasyon (review 2026-10-10): bus yokken drift kaydı
+            # tamamen kaybolmasın — Log'a tek satır düşer.
+            Rubik::Log.warn(:orchestrator, "event bus unavailable — ledger drift dropped " \
+                                           "(#{flips.size} flip(s), #{unknowns.size} unknown(s), rev #{rev})")
+            return
+          end
+
+          bus.post(EVENT,
+                   { trigger: trigger.to_s, rev: rev, flipped: flips.size,
+                     unknowns: unknowns.map { |u| "unknown #{u[:collection]}[#{u[:index]}] #{u[:id]}: #{u[:reason]}" },
+                     entries: flips.map { |f| "#{f[:collection]}[#{f[:index]}] #{f[:id]}: #{f[:reason]}" } },
+                   subsystem: :orchestrator, level: :warn)
+        rescue StandardError => e
+          Rubik::Log.warn(:orchestrator, "ledger drift event post failed: #{e.class}: #{e.message}")
+        end
+      end
+
+      # Reinjection taşıyıcısı: son doğrulamada FAILED olan (o an stale)
+      # girdilerden en yeni MAX_NOTE_ENTRIES tanesi, girdi başına
+      # MAX_NOTE_CHARS. Boşsa HİÇ render edilmez (OFF/drift'siz koşu
+      # byte-özdeş). Tüm metin xml_escape'ten geçer.
+      module DriftNote
+        module_function
+
+        def render(snap:)
+          entries = []
+          Array(snap["tasks"]).each do |task|
+            check = task.is_a?(Hash) && task["verify"].is_a?(Hash) ? task["verify"]["last_check"] : nil
+            next unless check.is_a?(Hash) && check["state"] == "failed"
+
+            entries << "task #{task['id']} (was #{check['from']}) -> stale: #{check['reason']} at #{check['at']}"
+          end
+          Array(snap["environment_notes"]).each do |note|
+            check = note.is_a?(Hash) && note["verify"].is_a?(Hash) ? note["verify"]["last_check"] : nil
+            next unless check.is_a?(Hash) && check["state"] == "failed"
+
+            entries << "environment_note #{note['id']} -> verify failed: #{check['reason']} at #{check['at']}"
+          end
+          return nil if entries.empty?
+
+          esc = Rubik::Platform.method(:xml_escape)
+          body = entries.last(Drift::MAX_NOTE_ENTRIES).map { |line| esc.call(line.to_s.slice(0, Drift::MAX_NOTE_CHARS)) }
+          %(<ledger_drift rev="#{snap['rev']}" entries="#{body.size}">\n  #{body.join("\n  ")}\n</ledger_drift>)
+        end
+      end
+    end
+  end
+end