rubik 0.1.0

data/lib/rubik/repl/pruner/harness.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module Rubik
+  module REPL
+    module Pruner
+      # Düzlem 1 çekirdeği (Vakanüvis::Harness yapısı): tek worker thread
+      # + sınırlı FIFO. ANLIK GÖRÜNTÜ her zaman ÇAĞIRAN thread'de alınır
+      # (:turn_finished abonelik bloğu turn thread'inde koşar; araç/komut
+      # çağrısı da turn thread'indedir) — worker shell durumuna ASLA
+      # dokunmaz; o yalnız brif kurar, doğurur, hasat eder ve planı
+      # aşamalar. Sessizlik sözleşmesi: "Context Pruner" SILENT_ROLES'tadır
+      # — notice yok, wake yok, yalnız dmesg. Uygulama (pencere takası)
+      # yalnız turn thread'inde, apply_staged_prune_plan! üzerinden.
+      class Harness
+        STOP = :__pruner_stop__
+        MAX_QUEUE = 16
+        TURN_EVENT = :turn_finished # TurnRecorder::TURN_EVENT_TARGET ile eş pinli
+        COMPLETED_EVENT = :subagent_completed
+        TYPE_NAME = "pruner"
+        PRUNER_ROLE = "Context Pruner"
+
+        attr_reader :shell, :supervisor, :dmesg, :gate
+
+        def initialize(shell:, config: nil, event_bus: nil, supervisor: nil, dmesg: nil, context: nil)
+          @shell = shell
+          @config = config
+          @event_bus = event_bus
+          @supervisor = supervisor
+          @dmesg = dmesg
+          @context = context
+          @queue = Thread::Queue.new
+          @monitor = Monitor.new
+          @busy = 0
+          @stopped = false
+          @worker = nil
+          @gate = Gate.new(shell: shell, config: config, supervisor: supervisor, dmesg: dmesg,
+                           event_bus: event_bus, ceiling_resolver: method(:resolve_ceiling))
+        end
+
+        # ---- yaşam döngüsü ---------------------------------------------------
+
+        def start!
+          subscribe_events
+          @worker = Thread.new { run_worker }
+          @worker.name = "rubik-pruner" if @worker.respond_to?(:name=)
+          self
+        end
+
+        def stopped? = @monitor.synchronize { @stopped }
+
+        # Dispose sözleşmesi (vakanüvis): FIFO drain olur (STOP dahil önceki
+        # olaylar işlenir), thread 2 saniyede durmazsa kill + dürüst dmesg.
+        def shutdown
+          @monitor.synchronize { @stopped = true }
+          @monitor.synchronize { @busy += 1 }
+          @queue.push(STOP)
+          @worker&.join(2)
+          if @worker&.alive?
+            Pruner.log_via(@dmesg, :warn, "worker did not stop in 2s — killing with #{queue_size} event(s) unprocessed")
+            @worker.kill
+          end
+          @worker = nil
+        end
+
+        def wait_idle(timeout: 2.0)
+          deadline = Time.now + timeout
+          sleep 0.01 while busy? && Time.now < deadline
+          !busy?
+        end
+
+        def busy? = @monitor.synchronize { @busy.positive? }
+
+        def queue_size = @queue.size
+
+        # ---- talep düzlemi (prune_context aracı / !prune komutu) ----------
+
+        # Zorunlu budama isteği: LLM asla bekletilmez — deterministik makbuz
+        # döner. Kuyruk reddi (kapanış yarışı) yer tutucuyu temizler ve dürüst
+        # ret makbuzu döner (makbuz asla kuyruğa girmeyen işe söz vermez).
+        def prune(reason: "manual")
+          envelope, skip = @gate.stage_job(@shell.conversation_history, reason: reason, forced: true)
+          return decline_receipt(skip) unless envelope
+
+          if !stopped? && enqueue_job(envelope)
+            "Prune queued (async): the pruner will propose a keep/drop/summarize plan for the ROOT window; " \
+              "it is validated deterministically and applied at the next turn boundary. " \
+              "This call did NOT wait for the LLM. Reason: #{reason}."
+          else
+            @gate.drop_job(envelope, why: "harness stopped")
+            decline_receipt(:stopped)
+          end
+        end
+
+        # ---- turn sınırı uygulama kapısı (TurnRecorder çağırır) -----------
+
+        # Aşamalı planı canlı pencereye uygular; dönüş [yeni_pencere,
+        # makbuz] veya nil (plan yok / canlı doğrulama düşürdü).
+        def take_applicable_plan!(live_window)
+          @gate.take_staged!(live_window, config: compaction_config)
+        end
+
+        def status_text
+          Rules.status_report(window: @shell.conversation_history, ceiling: resolve_ceiling,
+                              bits: @gate.status_bits)
+        end
+
+        private
+
+        def subscribe_events
+          return unless @event_bus.respond_to?(:subscribe)
+
+          # Anlık görüntü abonelik bloğunda alınır. DÜRÜST NOT: bus post'u
+          # fire-and-forget'tir — blok rubik-kworker thread'inde koşar, turn
+          # thread'i DEĞİLDİR; okuma bir sonraki turn'ün pencere mutasyonuyla
+          # yarışabilir. Güvenlik apply katmanından gelir: hash8 yeniden
+          # doğrulaması yarışan birimleri "bayat op" olarak atlar (sayılır),
+          # uygulama-sonu değişmezleri ve kopyala-doğrula-takas pencereyi
+          # bozulmadan korur — yarış en fazla bir planın düşmesine mal olur.
+          @event_bus.subscribe(TURN_EVENT, context: @context) do |_payload|
+            @gate.note_turn!
+            envelope, = @gate.stage_job(@shell.conversation_history, reason: "turn", forced: false)
+            @gate.drop_job(envelope, why: "harness stopped") if envelope && !enqueue_job(envelope)
+          end
+          @event_bus.subscribe(COMPLETED_EVENT, context: @context) { |p| enqueue_event(:completed, p) }
+        end
+
+        def enqueue_job(envelope)
+          enqueue_event(:job, { envelope: envelope })
+        end
+
+        def enqueue_event(kind, payload)
+          return false if stopped?
+
+          unless payload.is_a?(Hash)
+            Pruner.log_via(@dmesg, :warn, "discarded non-hash #{kind} event (#{payload.class})")
+            return false
+          end
+
+          drop_oldest! if @queue.size >= MAX_QUEUE
+          @monitor.synchronize { @busy += 1 }
+          @queue.push([kind, payload])
+          true
+        end
+
+        # Taşma düşürmesi asla STOP'u yutamaz (vakanüvis kuralı); düşen
+        # işin gate'teki izi uzlaştırılır — :job yer tutucusu temizlenir,
+        # :completed sicil girdisi silinir (kapı asla "uçuşta" takılı
+        # kalamaz) ve taşan tamamlanmanın id'si loglanır.
+        def drop_oldest!
+          item = @queue.pop(true)
+          if item == STOP
+            @queue.push(STOP)
+          else
+            @monitor.synchronize { @busy -= 1 }
+            if item[0] == :job
+              @gate.drop_job(item[1][:envelope], why: "queue overflow")
+            elsif item[0] == :completed
+              @gate.discard_completion(item[1])
+            end
+            Pruner.log_via(@dmesg, :warn, "event queue overflow — dropped oldest #{item[0]} event")
+          end
+        rescue ThreadError
+          nil
+        end
+
+        def run_worker
+          loop do
+            kind, payload = @queue.pop
+            break if kind == STOP
+
+            handle_event(kind, payload)
+          ensure
+            @monitor.synchronize { @busy -= 1 }
+          end
+        end
+
+        # Pruner'in kendi hatası REPL akışını asla bozmaz — uyarı düşer,
+        # sonraki olay işlenir (TranscriptIndexer disiplini).
+        def handle_event(kind, payload)
+          case kind
+          when :job then handle_job(payload[:envelope])
+          when :completed then @gate.completion_event(payload)
+          end
+        rescue StandardError => e
+          Pruner.log_via(@dmesg, :warn, "event handling failed (#{kind}): #{e.class}: #{e.message}")
+        end
+
+        def handle_job(envelope)
+          brief = Brief.build(units: envelope[:units], ceiling: envelope[:ceiling],
+                              target_tokens: envelope[:target_tokens], trigger_ratio: envelope[:trigger_ratio],
+                              max_chars: envelope[:brief_budget_chars])
+          return @gate.drop_job(envelope, why: "brief over the hard bound") unless brief
+
+          envelope[:brief] = brief
+          @gate.spawn_job(envelope)
+        end
+
+        def decline_receipt(skip)
+          case skip
+          when :busy then "A pruner run is already in flight — this request was not duplicated."
+          when :staged then "A validated prune plan is already staged and applies at the next turn boundary."
+          when :no_ceiling then "Prune declined: the effective input ceiling is unknown for the current model."
+          when :stopped then "Prune declined: the pruner harness is not running (session teardown)."
+          else "Prune declined (#{skip})."
+          end
+        end
+
+        # Koruma bantları context.* SSOT'sundan (preserve_first_n/last_n).
+        def compaction_config
+          {
+            "preserve_first_n" => fetch_cfg("context.preserve_first_n", 2),
+            "preserve_last_n" => fetch_cfg("context.preserve_last_n", 6)
+          }
+        end
+
+        # trim_conversation_window! ile aynı tavan çözümü (sticky damgalı
+        # model spec'i + llm_registry; hata → nil → kapı atlar).
+        def resolve_ceiling
+          spec = @shell.current_model_spec
+          return nil unless spec.is_a?(Hash) && @shell.respond_to?(:llm_registry) && @shell.llm_registry
+
+          @shell.llm_registry.effective_input_limit_for(spec["provider"], spec["name"])
+        rescue StandardError => e
+          Pruner.log_via(@dmesg, :warn, "input ceiling lookup failed (#{e.class}: #{e.message}); prune gate skipped")
+          nil
+        end
+
+        def fetch_cfg(key, default)
+          @config.respond_to?(:fetch) ? @config.fetch(key, default) : default
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/pruner/rules.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+require_relative "../../platform"
+require_relative "../../prompt/context_compactor"
+
+module Rubik
+  module REPL
+    module Pruner
+      # Düzlem 1 kuralları (durumsuz, saf): pencereyi atomik birimlere
+      # böler (koruma bantları + hedef sabitlemesi dahil), LLM planını
+      # katı şemayla doğrular ve DOĞRULANMIŞ planı canlı pencereye
+      # kopyala-doğrula-takas disipliniyle uygular. Mevcut sıkıştırma
+      # koduna dokunmaz — ContextCompactor/TokenEstimator/ConversationRows
+      # yalniz ÇAĞRILIR (subagent yolu bu dosyadan habersizdir).
+      module Rules
+        MAX_OPS = 64
+        SUMMARY_MIN_CHARS = 40
+        SUMMARY_MAX_CHARS = 2000
+        KEEP_PREVIEW_CHARS = 400
+        MIN_WINDOW_ENTRIES = 4 # trim_history_to_budget min_entries aynası
+        UNIT_ID = /\Au\d+:[0-9a-f]{8}\z/
+
+        module_function
+
+        # Pencereyi budanabilir birim anlık görüntüsüne çevirir. Birim =
+        # Prompt::ContextCompactor.group_atomic_units çıktısı (assistant+tool
+        # eşleşmesi yapısal olarak korunur). Korumalı birimler (KEEP):
+        # hedef sabitlemeli (<user_task> çifti), baş/bant (preserve_first_n
+        # mesajını kaplayan birimler), kuyruk bandı (preserve_last_n), system
+        # satırı taşıyanlar. id = "u<sıra>:<hash8>" — sıra benzersizlik,
+        # hash8 bayatlık işaretidir (apply sırasında içerik kimliği).
+        def build_units(window, config: {})
+          groups = Prompt::ContextCompactor.group_atomic_units(Array(window))
+          units = groups.map do |rows|
+            { rows: rows.map { |r| Prompt::ConversationRows.row?(r) ? r.dup : r } }
+          end
+          units.each { |u| u[:pinned_goal?] = Prompt::ContextCompactor.unit_pins_goal?(u[:rows]) }
+
+          protect_bands!(units, config)
+          units.each_with_index do |u, idx|
+            u[:id] = "u#{idx}:#{unit_digest(u[:rows])}"
+            u[:tokens] = Prompt::TokenEstimator.estimate_history(u[:rows])
+            u[:role] = role_label(u[:rows])
+          end
+          units.each(&:freeze)
+          units.freeze
+        end
+
+        def unit_digest(rows)
+          canonical = rows.map { |r| canonical_row(r) }
+          Digest::SHA256.hexdigest(Platform.safe_json_generate(canonical))[0, 8]
+        end
+
+        # İki satır diyalektini (symbol/string anahtar) tek kanonik şekle
+        # indirir — nil okumalar "" olur, anahtar sırası hash'i değiştirmez.
+        def canonical_row(row)
+          return { "row" => "" } unless Prompt::ConversationRows.row?(row)
+
+          {
+            "role" => Prompt::ConversationRows.role_of(row),
+            "content" => Prompt::ConversationRows.content_of(row).to_s,
+            "tool_call_id" => Prompt::ConversationRows.value_of(row, :tool_call_id).to_s,
+            "tool_name" => Prompt::ConversationRows.value_of(row, :tool_name).to_s,
+            "status" => Prompt::ConversationRows.value_of(row, :status).to_s,
+            "tool_calls" => tool_calls_json(row)
+          }
+        end
+
+        # LLM planını ANLIK GÖRÜNTÜYE karşı doğrular (canlı durum yok).
+        # Dönüş: [plan, nil] veya [nil, insan-okur ret sebebi]. Beyaz liste
+        # grameri: {"ops":[{"op":"drop","id":...},{"op":"summarize","id":...,
+        # "text":...}]} — model satır/rol/talimat ENJEKTE EDEMEZ, yalnız
+        # önceden doğrulanmış birimler arasından seçer ve ≤2000 karakterlik
+        # özet yazar.
+        def validate_plan(raw_finish_body, units)
+          return [nil, "final message is empty"] if raw_finish_body.to_s.strip.empty?
+
+          parsed = parse_json_object(raw_finish_body.to_s)
+          return [nil, parsed] if parsed.is_a?(String)
+
+          ops = parsed["ops"]
+          return [nil, "'ops' must be an array"] unless ops.is_a?(Array)
+          return [nil, "plan needs at least one op"] if ops.empty?
+          return [nil, "plan exceeds #{MAX_OPS} ops"] if ops.size > MAX_OPS
+
+          by_id = units.to_h { |u| [u[:id], u] }
+          seen = {}
+          normalized = []
+          ops.each do |op|
+            reason = normalize_op(op, by_id, seen, normalized)
+            return [nil, reason] if reason
+          end
+          [{ "ops" => normalized }, nil]
+        end
+
+        # Doğrulanmış planı CANLI pencereye uygular (yalnız turn thread'i
+        # çağırır). Her op'un hash'i yeniden doğrulanır: içerik değişen
+        # birimler tek tek atlanır (bayat op), genel değişmezlerden biri
+        # bozulursa TÜM plan düşer — giriş dizisi asla mutasyona uğramaz.
+        # Dönüş: [yeni_pencere, makbuz] veya [nil, sebep].
+        def apply_plan(window, plan, target_tokens:, config: {})
+          return [nil, "no plan"] unless plan.is_a?(Hash) && plan["ops"].is_a?(Array)
+
+          units = build_units(window, config: config)
+          outcome = resolve_ops(plan["ops"], units)
+          applied = outcome[:applied]
+          return [nil, "all ops went stale (window changed since the plan)"] if applied.empty?
+
+          candidate = assemble(units, applied)
+          reason = post_invariant_reason(window, candidate, target_tokens)
+          return [nil, reason] if reason
+
+          after_tokens = Prompt::TokenEstimator.estimate_history(candidate)
+          receipt = { dropped: applied.count { |_id, op| op[:kind] == :drop },
+                      summarized: applied.count { |_id, op| op[:kind] == :summarize },
+                      skipped_stale: outcome[:skipped_stale],
+                      before_tokens: Prompt::TokenEstimator.estimate_history(window),
+                      after_tokens: after_tokens }
+          [candidate, receipt]
+        end
+
+        def status_report(window:, ceiling:, bits: {})
+          est = Prompt::TokenEstimator.estimate_history(Array(window))
+          pct = ceiling&.positive? ? " (#{(est * 100.0 / ceiling).round}% of ceiling)" : ""
+          lines = ["Context pruner:",
+                   "  window: #{Array(window).size} entries, ~#{est} est. tokens#{pct}",
+                   "  ceiling: #{ceiling || 'unknown'}"]
+          if bits.empty?
+            lines << "  gate: idle"
+          else
+            lines << "  pruner in flight: #{bits[:in_flight] ? 'yes' : 'no'}"
+            lines << "  staged plan: #{bits[:staged] ? 'waiting for the next turn boundary' : 'none'}"
+            lines << "  last receipt: #{bits[:last_receipt] || 'none yet'}"
+          end
+          lines.join("\n")
+        end
+
+        # ---- iç kısım ---------------------------------------------------------
+
+        # Hash döner veya ret sebebi String'i — validate_plan'ın begin/rescue
+        # return dansını izole eder (Lint/NoReturnInBeginEndBlocks).
+        def parse_json_object(raw)
+          parsed = JSON.parse(raw)
+          return "plan must be a JSON object" unless parsed.is_a?(Hash)
+          return "plan must have exactly one 'ops' key" unless parsed.keys == ["ops"]
+
+          parsed
+        rescue JSON::ParserError
+          "final message is not valid JSON"
+        end
+
+        # Baş/kuyruk koruma bantları apply_sliding_window ile AYNI hesapla
+        # (context_compactor.rb:180-199): baş birimleri preserve_first_n
+        # mesajı, kuyruk birimleri preserve_last_n mesajı kaplayana kadar;
+        # system satırı ve sabitlenmiş hedef birimi her yerde korumalı.
+        def protect_bands!(units, config)
+          first_n = (config["preserve_first_n"] || config[:preserve_first_n] || 2).to_i
+          last_n = (config["preserve_last_n"] || config[:preserve_last_n] || 6).to_i
+
+          protected_idx = {}
+          head_count = 0
+          head_idx = 0
+          while head_idx < units.size && head_count < first_n
+            protected_idx[head_idx] = :head
+            head_count += units[head_idx][:rows].size
+            head_idx += 1
+          end
+          tail_count = 0
+          tail_idx = units.size - 1
+          while tail_idx >= head_idx && tail_count < last_n
+            protected_idx[tail_idx] = :tail
+            tail_count += units[tail_idx][:rows].size
+            tail_idx -= 1
+          end
+
+          units.each_with_index do |u, idx|
+            u[:protected?] = protected_idx.key?(idx) || u[:pinned_goal?] ||
+                             u[:rows].any? { |r| Prompt::ConversationRows.role_of(r) == "system" }
+          end
+        end
+
+        def role_label(rows)
+          first = Prompt::ConversationRows.role_of(rows.first)
+          rows.size > 1 ? "#{first}+tool" : first
+        end
+
+        def tool_calls_json(row)
+          calls = row[:tool_calls] || row["tool_calls"]
+          return "" unless calls && !calls.empty?
+
+          Platform.safe_json_generate(calls)
+        rescue StandardError
+          calls.to_s
+        end
+
+        # Tek op normalize eder; ret sebebi döndürür (nil = kabul).
+        def normalize_op(entry, by_id, seen, normalized)
+          return "each op must be a JSON object" unless entry.is_a?(Hash)
+
+          kind = entry["op"]
+          return "unknown op '#{kind}' (valid: drop, summarize)" unless ["drop", "summarize"].include?(kind)
+
+          expected = kind == "drop" ? ["id", "op"].freeze : ["id", "op", "text"].freeze
+          return "op keys must be exactly #{expected.join(', ')}" unless entry.keys.sort == expected
+
+          id = entry["id"]
+          return "malformed unit id '#{id}'" unless id.is_a?(String) && id.match?(UNIT_ID)
+          return "duplicate op for unit '#{id}'" if seen.key?(id)
+
+          unit = by_id[id]
+          return "unknown unit '#{id}'" unless unit
+          return "unit '#{id}' is protected (KEEP)" if unit[:protected?]
+
+          seen[id] = true
+          clean_op = { "op" => kind, "id" => id }
+          if kind == "summarize"
+            text = entry["text"]
+            return "summarize text must be a string" unless text.is_a?(String)
+
+            clean = Platform.safe_utf8(text)
+            return "summary must be #{SUMMARY_MIN_CHARS}-#{SUMMARY_MAX_CHARS} chars (got #{clean.length})" unless clean.length.between?(SUMMARY_MIN_CHARS, SUMMARY_MAX_CHARS)
+
+            # Enjeksiyon kapanışı (review 2026-10-09): özet metni <user_task>
+            # etiketi taşayla YENİ sabitlenmiş hedef satırı doğurabilir —
+            # deterministik yığın o satırı sonsuza dek korurdu. Etiketler
+            # özet içinde asla birebir yaşayamaz.
+            # <goal_ledger> kaçışı (goal-ledger planı A): sahte pinnenmiş Σ
+            # satırı doğması aynı enjeksiyon sınıfıdır — etiketler özet
+            # içinde asla birebir yaşayamaz.
+            clean = clean.gsub("<user_task>", "&lt;user_task&gt;").gsub("</user_task>", "&lt;/user_task&gt;")
+            clean = clean.gsub("<goal_ledger ", "&lt;goal_ledger ").gsub("</goal_ledger>", "&lt;/goal_ledger>")
+            clean_op["text"] = clean
+          end
+          normalized << clean_op
+          nil
+        end
+
+        # Op'ları canlı birimlere bağlar. Önce tam id eşleşmesi; olmazsa
+        # hash8 eşleşmesi (sıra kaydırdıysa içerik hâlâ aynı olabilir).
+        # Birden çok hash eşleşmesi belirsizdir → op bayat sayılır.
+        def resolve_ops(ops, units)
+          applied = {}
+          skipped = 0
+          units_by_id = units.to_h { |u| [u[:id], u] }
+          ops.each do |op|
+            hash8 = op["id"].split(":").last
+            unit = units_by_id[op["id"]]
+            unless unit && !unit[:protected?] && !applied.key?(unit[:id])
+              matches = units.select do |u|
+                !u[:protected?] && !applied.key?(u[:id]) && u[:id].end_with?(":#{hash8}")
+              end
+              unit = matches.size == 1 ? matches.first : nil
+            end
+            if unit.nil?
+              skipped += 1
+              next
+            end
+
+            applied[unit[:id]] = { kind: op["op"].to_sym, text: op["text"] }
+          end
+          { applied: applied, skipped_stale: skipped }
+        end
+
+        # Birimleri özgün sırasında birleştirir: düşürülenler çıkar,
+        # özetlenenler tek <pruned_summary> user satırına iner (role "user"
+        # — sıkı sağlayıcılar ortada system satırı reddeder; compactor
+        # summary_message geleneği).
+        def assemble(units, applied)
+          candidate = []
+          units.each do |u|
+            op = applied[u[:id]]
+            if op.nil?
+              candidate.concat(u[:rows])
+            elsif op[:kind] == :drop
+              next
+            else
+              candidate << {
+                role: "user",
+                content: "<pruned_summary unit=\"#{u[:id]}\" rows=\"#{u[:rows].size}\">#{op[:text]}</pruned_summary>"
+              }
+            end
+          end
+          candidate
+        end
+
+        # Uygulama-sonu değişmezleri — biri bozulursa plan bütünüyle düşer.
+        # nil = ihlal yok; String = insan-okur ihlal sebebi.
+        def post_invariant_reason(original, candidate, target_tokens)
+          return "pruned window would be empty" if candidate.empty?
+          return "pruned window must open with a user turn (strict providers)" unless Prompt::ConversationRows.role_of(candidate.first) == "user"
+          return "pruned window would be too small (< #{MIN_WINDOW_ENTRIES} entries)" if candidate.size < MIN_WINDOW_ENTRIES
+          if Prompt::TokenEstimator.estimate_history(candidate) > target_tokens
+            return "pruned window still over target (#{Prompt::TokenEstimator.estimate_history(candidate)} > #{target_tokens} tokens)"
+          end
+
+          # Hedef satır sayısı BİREBİR kalmalı (review 2026-10-09): yalnız
+          # eksilmesi değil ARTMASI da ret — özet metninden enjekte edilen
+          # sahte <user_task> satırı sonsuza dek sabitlenmiş hedef olurdu.
+          original_goals = original.count { |r| Prompt::ContextCompactor.goal_message?(r) }
+          candidate_goals = candidate.count { |r| Prompt::ContextCompactor.goal_message?(r) }
+          return "goal-pinned message count changed (#{original_goals} -> #{candidate_goals})" if candidate_goals != original_goals
+
+          # Σ satırı sayısı değişmezi (goal-ledger planı A): hedef satırıyla
+          # aynı savunma — eksilme de artma da ret.
+          original_ledger = original.count { |r| Prompt::ContextCompactor.ledger_message?(r) }
+          candidate_ledger = candidate.count { |r| Prompt::ContextCompactor.ledger_message?(r) }
+          return "goal-ledger message count changed (#{original_ledger} -> #{candidate_ledger})" if candidate_ledger != original_ledger
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/pruner/service.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Rubik
+  module REPL
+    module Pruner
+      # Kompozisyon kökü kancası (repl/lifecycle.rb Phase 4, Vakanüvis
+      # bind'inden hemen sonra — SHELL/SUPERVISOR/DMESG coeffect'leri Faz
+      # 2'den çözülebilir olmalı): budayıcı açıksa Harness kurulur, kendi
+      # child ctx'inde yaşar (abonelik geri alımları orada), PRUNER
+      # coeffect'i köke sağlanır (prune_context aracı buradan çözer;
+      # apply_staged_prune_plan! da). Kapalıysa
+      # (subagents.pruner.enabled=false — opt-out) nil döner: budayıcı
+      # yok, araç REQUIRES karşılanmaz ve model yüzünde görünmez, REPL
+      # komutu dürüstçe kapalı der.
+      module Service
+        module_function
+
+        # Test zırhı (vakanüvis emsali): RUBIK_TEST=1 ortamında budayıcı
+        # varsayılan KAPALI bağlanır — scripted shell testleri arka plan
+        # doğumlarıyla yarışmasın. RUBIK_PRUNER_FORCE=1 zırhı kaldırır
+        # (budayıcının kendi testleri). Knob varsayılanı ON'dur (2026-10-10);
+        # zırh yalnızca süit içi davranışı sabitler.
+        def enabled?(config = nil)
+          return false if ENV["RUBIK_TEST"] == "1" && ENV["RUBIK_PRUNER_FORCE"] != "1"
+
+          config_get(config, "subagents.pruner.enabled", true)
+        end
+
+        def bind(context_or_manager, config: nil, event_bus: nil)
+          return nil unless enabled?(config)
+
+          ctx = context_or_manager.respond_to?(:context) ? context_or_manager.context : context_or_manager
+          return nil unless ctx.respond_to?(:provide)
+
+          shell = Rubik::Coeffects.get(ctx, Rubik::Coeffects::SHELL)
+          unless shell
+            Rubik::Log.warn(:repl, "pruner not bound: SHELL coeffect unsatisfied (boot-order gap)")
+            return nil
+          end
+          supervisor = Rubik::Coeffects.get(ctx, Rubik::Coeffects::SUBAGENT_SUPERVISOR)
+          unless supervisor
+            Rubik::Log.warn(:repl, "pruner not bound: SUBAGENT_SUPERVISOR coeffect unsatisfied — no spawn path")
+            return nil
+          end
+          Rubik::Log.warn(:repl, "pruner bound without an event bus — the LLM half stays dormant (no harvest path)") unless event_bus.respond_to?(:subscribe)
+
+          child = ctx.respond_to?(:extend) ? ctx.extend : nil
+          unless child
+            Rubik::Log.warn(:repl, "pruner bound without a disposable child ctx — worker and " \
+                                   "subscriptions live for the process lifetime")
+          end
+
+          harness = Harness.new(
+            shell: shell, config: config, event_bus: event_bus,
+            supervisor: supervisor, dmesg: Rubik::Coeffects.get(ctx, Rubik::Coeffects::DMESG),
+            context: child
+          )
+          # Ömür (§2.7): child ctx'in cascade inverse'i worker'ı kapatır.
+          child&.on_dispose { harness.shutdown }
+          harness.start!
+          ctx.provide(Rubik::Coeffects::PRUNER, harness)
+          context_or_manager.reconcile_all if context_or_manager.respond_to?(:reconcile_all)
+          harness
+        end
+
+        # Noktalı anahtar okuması iki config şeklinde de aynı çalışsın
+        # (maestro_gate.rb:38-40 düzeni): Rubik::Config#fetch noktalı yolu
+        # böler, düz Hash hepsini tek anahtar sayar → dig'e düş.
+        def config_get(config, key, default)
+          return default if config.nil?
+
+          val = if config.is_a?(Hash)
+                  config.dig(*key.to_s.split("."))
+                elsif config.respond_to?(:fetch)
+                  config.fetch(key, nil)
+                end
+          val.nil? ? default : val
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/pruner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Rubik
+  module REPL
+    # Pruner — yarı deterministik KÖK konuşma penceresi budayıcısı
+    # (context-pruner planı 2026-10-09, vakanüvis iki-düzlem modeli):
+    #
+    #   Düzlem 1 (deterministik): tetik kapısı, brif kurulumu, plan
+    #   doğrulaması ve turn sınırındaki aşamalı uygulama (Rules/Brief/Gate).
+    #   Düzlem 2 (LLM): sessiz "Context Pruner" subagent'ı keep/drop/
+    #   summarize planını ÖNERİR — yazma yetkisi yoktur; öneri katı
+    #   doğrulamadan geçmezse pencere dokunulmadan kalır.
+    #
+    # Deterministik sıkıştırma yığını (trim_conversation_window! /
+    # ContextCompactor / EmergencyCompactor) DEĞİŞMEZ ve her zaman güvenlik
+    # ağıdır; subagent kanallarının budama mekanizmaları bu özellikten
+    # tamamen bağımsız, tam deterministik kalır. DEFAULT ON
+    # (subagents.pruner.enabled; opt-out: false — 2026-10-10).
+    module Pruner
+      SUBSYSTEM = :repl
+
+      module_function
+
+      # Vakanüvis.log_via emsali: dmesg yoksa Log'a, ikisi de patlarsa
+      # stderr'e — günlükleme asla akışı bozmaz.
+      def log_via(dmesg, level, message)
+        dmesg.respond_to?(:log) ? dmesg.log(SUBSYSTEM, level, message) : Rubik::Log.send(level, SUBSYSTEM, message)
+      rescue StandardError
+        Rubik::Log.warn(SUBSYSTEM, message)
+      end
+    end
+  end
+end
+
+require_relative "pruner/rules"
+require_relative "pruner/brief"
+require_relative "pruner/gate"
+require_relative "pruner/harness"
+require_relative "pruner/service"