rubik 0.1.0

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

@@ -0,0 +1,399 @@
+# frozen_string_literal: true
+
+require "time"
+require "json"
+require_relative "../../prompt/context_compactor"
+require_relative "../../prompt/conversation_rows"
+require_relative "../../uris"
+
+module Rubik
+  module Orchestrator
+    module GoalLedger
+      # !goal döngüsünün yapılandırılmış ΔΣ defteri (Σ) — SKILL.state
+      # uyarlamasının durumlu yarısı. C kütüphanesi (Patch/Schema/Validator)
+      # SAFTI; burada yaşam döngüsü durumu yaşar: Monitor korumalı doküman,
+      # ardışık-ret bütçesi, storage revizyon zinciri (her kabul YENİ satır;
+      # `goal-ledger` ref'i daima son revizyonu gösterir) ve dmesg telemetrisi.
+      #
+      # Thread modeli (plan A kuralı): yazmalar YALNIZ turn thread'indedir
+      # (araç execute, step-top refresh, finalize); tüm okumalar Monitor
+      # altındadır — rubik://goal/ledger read_file her an güvenlidir
+      # (GoalState mold'u). Arkaplan thread'i yoktur.
+      #
+      # Degradasyon sözleşmesi: Store yoksa/başarısızsa satır YAZILMAZ, tek
+      # dmesg warn düşer ve Σ bellekte yaşamaya devam eder — özellik asla
+      # storage hatasıyla çökmez ("prompt'tan atmak ≠ kayıttan atmak":
+      # transcripts/ToolHistory bu sınıfa hiç girmez).
+      class Ledger
+        Result = Struct.new(:status, :reasons, :rev, :uri, keyword_init: true)
+
+        # A planı üretim şemasını SAHİPLENİR: goal skeleton örnek örneği
+        # üretim yüzeyi olur (frozen; verify alanları optional+allow_null —
+        # re-verification planı doldurur).
+        PRODUCTION_SCHEMA = Schema.goal_skeleton
+
+        # rev = Σ sürüm SSOT'u (doc["rev"]) — ObservationProjection ve
+        # kullanıcılar Monitor altında okur (@rev ivarı YOKTUR; atanmaz).
+        def rev
+          @monitor.synchronize { @doc["rev"] }
+        end
+
+        attr_reader :event_bus
+
+        def initialize(goal_text:, max_retries: DEFAULT_MAX_RETRIES, store: nil, dmesg: nil, event_bus: nil)
+          @monitor = Monitor.new
+          @max_retries = max_retries.to_i
+          @store = store
+          @dmesg = dmesg
+          @event_bus = event_bus
+          @rejections = 0
+          @storage_id = nil
+          @last_links = {}
+          @finalized = false
+          @updated_at = nil
+          @last_drift_note = nil
+          @doc = seed_doc(goal_text)
+        end
+
+        # ------------------------------------------------------------------
+        # Sınıf yüzü: çift-diyalekt knob okuması (pruner Service mold'u —
+        # Rubik::Config dotted-path böler, düz Hash tek anahtar sayar) ve
+        # oluşturma fabrikası. Konum: Ledger üzerinde, çünkü GoalLedger
+        # modülü C sabitlerinin evi olmayı sürdürür (shim < 90 hygiene pin).
+        class << self
+          def enabled?(config = nil)
+            config_get(config, "goal.ledger.enabled", true)
+          end
+
+          # B'nin knob'u (re-verification): enabled kapalıyken İNERTTİR
+          # (coeffect hiç provide edilmez → verifier girişi no-op).
+          def verify_enabled?(config = nil)
+            config_get(config, "goal.ledger.verify", true)
+          end
+
+          def max_patch_retries(config = nil)
+            config_get(config, "goal.ledger.max_patch_retries", DEFAULT_MAX_RETRIES).to_i
+          end
+
+          def create!(goal_text:, config: nil, store: nil, dmesg: nil, event_bus: nil)
+            ledger = new(goal_text: goal_text.to_s, max_retries: max_patch_retries(config),
+                         store: store, dmesg: dmesg, event_bus: event_bus)
+            ledger.persist_seed!
+            ledger
+          end
+
+          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
+
+        def persist_seed!
+          row = put_row(title: row_title, body: canonical_json, tags: ["goal-ledger"], links: {}, ref: "goal-ledger")
+          @storage_id = row["id"] if row
+          degrade_storage_once unless row
+        rescue StandardError => e
+          degrade("seed revision row", e)
+        end
+
+        # Tek giriş: patch metni (ya da Patch VO) → sınıflandırılmış sonuç.
+        # Ret sayacı ardışıktır; başarı sıfırlar; bütçe aşımında :exhausted
+        # döner ve ESKİ Σ korunur (goal loop asla brick olmaz).
+        def update(patch_or_text)
+          verdict = Validator.validate(patch_or_text, schema: PRODUCTION_SCHEMA, current_doc: @doc)
+          @monitor.synchronize do
+            if verdict[0] == :ok
+              apply!(verdict[1])
+            elsif @rejections >= @max_retries
+              # C sözleşmesi: ardışık ret bütçesi dolu — ESKİ Σ korunur ve
+              # dürüst tükenme döner; geçerli bir patch geldiğinde kabul
+              # yolu yeniden açılır (goal loop asla brick olmaz).
+              exhausted_result
+            else
+              @rejections += 1
+              log(:patch_rejected, "patch rejected (#{@rejections}/#{@max_retries} budget): " \
+                                   "#{verdict[1].first[:class]} — #{verdict[1].first[:message]}")
+              Result.new(status: :rejected, reasons: verdict[1], rev: @doc["rev"], uri: ledger_uri)
+            end
+          end
+        end
+
+        # Adım başı yenileme: mevcut Σ satırlarını düşürüp TEK güncel satırı
+        # <user_task> hedef satırının peşine yerleştirir (tek-Σ-satırı
+        # invaryantı — pinli satırlar compaction'ı baypas ederek şişemez).
+        # Ledger satırı role "user" zorunludur: EmergencyCompactor hard
+        # tier'ı user satırlarına dokunmaz (emergency_compactor.rb:59-77).
+        def refresh_in_history!(history)
+          return if history.nil? || !history.respond_to?(:reject!)
+
+          @monitor.synchronize do
+            history.reject! { |msg| ledger_row?(msg) || drift_row?(msg) }
+            anchor = history.rindex { |msg| Prompt::ContextCompactor.goal_message?(msg) }
+            if anchor
+              history.insert(anchor + 1, { role: "user", content: render_xml })
+              history.insert(anchor + 2, { role: "user", content: @last_drift_note }) if @last_drift_note
+            else
+              history << { role: "user", content: render_xml }
+              history << { role: "user", content: @last_drift_note } if @last_drift_note
+            end
+          end
+        end
+
+        # Terminal damga (complete!/fail!/stop! sonrası): son revizyon
+        # satırına status yazılır (id korunur — version++), idempotenttir.
+        def finalize!(status)
+          @monitor.synchronize do
+            return final_result if @finalized
+
+            @finalized = true
+            if @store && @storage_id
+              links = @last_links.merge("finish_status" => status.to_s)
+              row = @store.put(type: "goal", id: @storage_id, title: row_title, body: canonical_json,
+                               tags: ["goal-ledger", "final"], links: links, status: status.to_s)
+              @storage_id = row["id"]
+            else
+              degrade_storage_once
+            end
+            log(:finalized, "goal ledger finalized at rev #{@doc['rev']} (status: #{status})")
+            final_result
+          end
+        rescue StandardError => e
+          degrade("final status stamp", e)
+          @monitor.synchronize { final_result }
+        end
+
+        # B (re-verification): iç mutasyon girişi — drift flip'leri MODEL
+        # ΔΣ validasyonunu ATLAR (bu bir model patch'i değildir) ama rev
+        # BUMP EDİLİR: :conflict, drift sinyalinin ta kendisidir (model
+        # bayat rev ile patch gönderir → conflict → yeniden okur → stale
+        # bayraklarını GÖRÜR — paper'ın zero-recovery mekanizması). Tek
+        # yazar disiplini: persistence A'nın kendi put yolundan geçer.
+        def apply_internal_drift!(flips)
+          @monitor.synchronize do
+            flips.each do |flip|
+              item = @doc[flip[:collection]]&.[](flip[:index])
+              next unless item.is_a?(Hash)
+
+              item["status"] = "stale" if flip[:collection] == "tasks"
+              verify_h = item["verify"].is_a?(Hash) ? item["verify"].dup : {}
+              verify_h["last_check"] = { "state" => "failed", "from" => flip[:from].to_s,
+                                         "reason" => flip[:reason].to_s, "at" => flip[:at].to_s }
+              item["verify"] = verify_h
+            end
+            return nil if flips.empty?
+
+            @doc["rev"] += 1
+            @updated_at = Time.now.utc
+            if @store && @storage_id
+              @store.put(type: "goal", id: @storage_id, title: row_title, body: canonical_json,
+                         tags: ["goal-ledger"], links: @last_links, status: "active")
+            end
+            @last_drift_note = DriftNote.render(snap: deep_dup(@doc))
+            log(:ledger_drift, "internal drift applied: #{flips.size} flip(s), rev #{@doc['rev']}")
+            { rev: @doc["rev"], flipped: flips.size }
+          end
+        rescue StandardError => e
+          degrade("drift persistence", e)
+          nil
+        end
+
+        # Verifier girişi: Monitor'lu FROZEN kopya — FS IO kilit dışı
+        # değerlendirilir (verifier.rb disiplini).
+        def snapshot_doc
+          @monitor.synchronize { deep_freeze(deep_dup(@doc)) }
+        end
+
+        # Test/seam gözlemcisi: güncel drift notu (yoksa nil).
+        def render_drift_note
+          @monitor.synchronize { DriftNote.render(snap: deep_dup(@doc)) }
+        end
+
+        def to_xml
+          @monitor.synchronize { render_xml }
+        end
+
+        # §4.1 render: GoalState#to_xml mold'u — tüm metin xml_escape'ten
+        # geçer; boş koleksiyonların etiketi HİÇ basılmaz ("yokluk, boşluk
+        # değil" kuralı); optional attribute'lar (storage_id, verify) yalnız
+        # set iken basılır.
+        def render_xml
+          esc = Rubik::Platform.method(:xml_escape)
+          attrs = %(rev="#{@doc['rev']}")
+          attrs += %( storage_id="#{esc.call(@storage_id)}") if @storage_id
+          attrs += %( updated_at="#{@updated_at.utc.iso8601}") if @updated_at
+          body = []
+          body << %(  <objective>#{esc.call(@doc['objective'].to_s)}</objective>)
+          tasks = @doc["tasks"].map do |task|
+            text = task["title"].to_s
+            text += " — notes: #{task['notes']}" if task["notes"]
+            attrs_t = %(id="#{esc.call(task['id'].to_s)}" status="#{esc.call(task['status'].to_s)}")
+            attrs_t += %( verify="#{esc.call(task['verify'].to_s)}") if task["verify"]
+            task["title"] || task["notes"] ? %(  <task #{attrs_t}>#{esc.call(text)}</task>) : %(  <task #{attrs_t} />)
+          end
+          body << "<tasks>\n#{tasks.join("\n")}\n  </tasks>" unless tasks.empty?
+          findings = @doc["findings"].map do |f|
+            %(  <finding id="#{esc.call(f['id'].to_s)}" source_step="#{f['source_step']}">#{esc.call(f['text'].to_s)}</finding>)
+          end
+          body << "<findings>\n#{findings.join("\n")}\n  </findings>" unless findings.empty?
+          decisions = @doc["decisions"].map do |dec|
+            attrs_d = %(id="#{esc.call(dec['id'].to_s)}")
+            attrs_d += %( rationale="#{esc.call(dec['rationale'].to_s)}") if dec["rationale"]
+            %(  <decision #{attrs_d}>#{esc.call(dec['text'].to_s)}</decision>)
+          end
+          body << "<decisions>\n#{decisions.join("\n")}\n  </decisions>" unless decisions.empty?
+          questions = @doc["open_questions"].map { |q| %(  <question>#{esc.call(q.to_s)}</question>) }
+          body << "<open_questions>\n#{questions.join("\n")}\n  </open_questions>" unless questions.empty?
+          notes = @doc["environment_notes"].map do |note|
+            attrs_n = %(id="#{esc.call(note['id'].to_s)}")
+            attrs_n += %( verify="#{esc.call(note['verify'].to_s)}") if note["verify"]
+            %(  <note #{attrs_n}>#{esc.call(note['text'].to_s)}</note>)
+          end
+          body << "<environment_notes>\n#{notes.join("\n")}\n  </environment_notes>" unless notes.empty?
+          <<~XML.strip
+            <goal_ledger #{attrs}>
+            #{body.join("\n")}
+            </goal_ledger>
+          XML
+        end
+
+        def snapshot
+          @monitor.synchronize do
+            { rev: @doc["rev"], objective: @doc["objective"], storage_id: @storage_id,
+              updated_at: @updated_at, finalized: @finalized, tasks: @doc["tasks"].size,
+              findings: @doc["findings"].size, decisions: @doc["decisions"].size,
+              open_questions: @doc["open_questions"].size, environment_notes: @doc["environment_notes"].size }
+          end
+        end
+
+        private
+
+        def seed_doc(goal_text)
+          { "rev" => 0, "objective" => Rubik::Platform.safe_utf8(goal_text.to_s.slice(0, 400)),
+            "tasks" => [], "findings" => [], "decisions" => [],
+            "open_questions" => [], "environment_notes" => [] }
+        end
+
+        def apply!(new_doc)
+          # Validator deep-frozen çıkarır (VO sözleşmesi); durum sahibi
+          # ledger'ın ÇALIŞMA kopyası mutable kalmalıdır (apply_internal_drift!
+          # ve render_xml iç mutasyonu).
+          @doc = deep_dup(new_doc)
+          @rejections = 0
+          @updated_at = Time.now.utc
+          @last_drift_note = nil # model yeniden planladı — drift notu tek seferliktir
+          links = @storage_id ? { "ledger_prev" => @storage_id } : {}
+          row = put_row(title: row_title, body: canonical_json, tags: ["goal-ledger"], links: links, ref: "goal-ledger")
+          if row
+            @storage_id = row["id"]
+            @last_links = links
+          end
+          log(:patch_accepted, "goal ledger rev #{@doc['rev']} applied (#{row ? "stored #{@storage_id}" : 'memory-only'})")
+          Result.new(status: :applied, rev: @doc["rev"], uri: ledger_uri)
+        rescue StandardError => e
+          # Storage yazım başarısızlığı araç yolunu BOGMAMALI: Σ zaten
+          # uygulandı (atomik validate-then-apply), yalnız kalıcılık düştü.
+          degrade("revision row", e)
+          Result.new(status: :applied, rev: @doc["rev"], uri: ledger_uri)
+        end
+
+        def exhausted_result
+          log(:patch_exhausted, "patch budget exhausted after #{@rejections} consecutive rejections; " \
+                                "ledger unchanged at rev #{@doc['rev']}")
+          Result.new(status: :exhausted, rev: @doc["rev"], uri: ledger_uri)
+        end
+
+        def final_result
+          { id: @storage_id, rev: @doc["rev"], uri: ledger_uri }
+        end
+
+        def put_row(title:, body:, tags:, links:, ref: nil)
+          return nil unless @store
+
+          @store.put(type: "goal", title: title, body: body, tags: tags, links: links, ref: ref)
+        end
+
+        def canonical_json
+          Rubik::Platform.safe_json_generate(@doc)
+        end
+
+        def row_title
+          "ledger r#{@doc['rev']}: #{Rubik::Platform.safe_utf8(@doc['objective'].to_s.slice(0, 60))}"
+        end
+
+        def ledger_uri
+          @storage_id ? Rubik::Uris.storage_entity(project: @store.project, type: "goal", id: @storage_id) : nil
+        end
+
+        def ledger_row?(msg)
+          return false unless Prompt::ConversationRows.row?(msg)
+
+          content = Prompt::ConversationRows.content_of(msg).to_s
+          Prompt::ConversationRows.role_of(msg) == "user" && content.start_with?("<goal_ledger ") && content.include?("</goal_ledger>")
+        end
+
+        def drift_row?(msg)
+          return false unless Prompt::ConversationRows.row?(msg)
+
+          content = Prompt::ConversationRows.content_of(msg).to_s
+          Prompt::ConversationRows.role_of(msg) == "user" && content.start_with?("<ledger_drift ") && content.include?("</ledger_drift>")
+        end
+
+        def deep_dup(value)
+          case value
+          when Hash then value.to_a.to_h { |key, val| [key.dup, deep_dup(val)] }
+          when Array then value.map { |val| deep_dup(val) }
+          else value
+          end
+        end
+
+        def deep_freeze(value)
+          case value
+          when Hash then value.each do |key, val|
+            deep_freeze(key)
+            deep_freeze(val)
+          end.freeze
+          when Array then value.each { |val| deep_freeze(val) }.freeze
+          when String then value.dup.freeze
+          else value
+          end
+        end
+
+        def log(event, message)
+          unless @dmesg.respond_to?(:log)
+            # Dürüst degradasyon (review 2026-10-10): dmesg yokken telemetri
+            # sessizliğe gömülmesin — bir kez Log'a düş, sonra sessiz.
+            unless @dmesg_degraded
+              @dmesg_degraded = true
+              Rubik::Log.warn(:goal_ledger, "dmesg unavailable — goal ledger telemetry degraded to Log only")
+            end
+            return
+          end
+
+          @dmesg.log(:goal_ledger, :info, "[#{event}] #{message}")
+        rescue StandardError
+          Rubik::Log.warn(:goal_ledger, "[#{event}] #{message}")
+        end
+
+        def degrade(what, error)
+          Rubik::Log.warn(:goal_ledger, "goal ledger #{what} unavailable (#{error.class}: #{error.message}); " \
+                                        "Σ continues in memory")
+        end
+
+        # Depo yokluğu bilinçli degradasyondur ama SESSIZ olamaz (sözleşme:
+        # tek dürüst warn) — memoize'lı tek atış.
+        def degrade_storage_once
+          return if @storage_degraded
+
+          @storage_degraded = true
+          Rubik::Log.warn(:goal_ledger, "storage unavailable — goal ledger revisions stay memory-only (no audit rows)")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require_relative "../../prompt/conversation_rows"
+
+module Rubik
+  module Orchestrator
+    module GoalLedger
+      # Gözlem projeksiyonu (goal-ledger planı D): goal-loop observation'larının
+      # Σ üzerinden erken yapısal projeksiyonu — compaction'ın TIER 0'ı.
+      #
+      # Sözleşmeler: (1) yalnız goal-mode user kanalı (directive_for önkoşul
+      # matrisi: goal_mode? → knob'lar → coeffect → rev ≥ 1; herhangi biri
+      # yoksa nil → compaction byte-özdeş); (2) satır DÜŞÜRME YOK — yalnız
+      # content tombstone'u (tool_call_id pairing'i korunur, orphan-id 400
+      # riski yapısal olarak imkânsız); (3) kayıt katmanı dokunulmaz —
+      # tombstone yalnız compact_history'nin dup kopyasına yazılır
+      # ("prompt'tan atmak ≠ kayıttan atmak"); (4) worker thread yok —
+      # directive çözümü + uygulama yalnız turn thread'indedir.
+      module ObservationProjection
+        MODULE_NAME = "update_goal_ledger" # ledger tool adının SSOT'u (Declaration name ile aynı değer)
+        SKILL_TOOL_NAME = "skill"          # progressive disclosure payload muafiyeti
+
+        module_function
+
+        # Önkoşul matrisi -> Directive | nil. Misconfiguration dürüstlüğü:
+        # observe_projection ON ama enabled OFF iken tek dmesg warn (çağrı
+        # yeri compaction'tır — doğal oran-limitli).
+        def directive_for(deps:)
+          config = deps.config
+          # goal_mode? yüklü olmayan test double'ları (ShellDeps method_missing
+          # raise eder) yapısal olarak dışla — non-goal muamelesi görsünler.
+          return nil unless deps.respond_to?(:goal_mode?) && deps.goal_mode?
+
+          enabled = Ledger.enabled?(config)
+          unless enabled
+            if config_get(config, "goal.ledger.observe_projection", true) && deps.respond_to?(:runtime_manager)
+              dmesg = Rubik::Coeffects.get(deps.runtime_manager&.context, Rubik::Coeffects::DMESG)
+              if dmesg.respond_to?(:log)
+                dmesg.log(:orchestrator, :warn,
+                          "goal.ledger.observe_projection is ON but goal.ledger.enabled is OFF — observation projection inert")
+              end
+            end
+            return nil
+          end
+          return nil unless config_get(config, "goal.ledger.observe_projection", true)
+
+          ledger = Rubik::Coeffects.get(deps.runtime_manager&.context, Rubik::Coeffects::GOAL_LEDGER)
+          return nil unless ledger.respond_to?(:rev)
+          return nil unless ledger.rev.is_a?(Integer) && ledger.rev >= 1
+
+          window = config_get(config, "goal.ledger.observe_window", 5).to_i
+          Directive.new(ledger: ledger, window: [window, 1].max, deps: deps)
+        end
+
+        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
+
+      # Kural: anchor = en yeni KABUL edilmiş update_goal_ledger tool satırını
+      # içeren atomic unit (model o çağrıyı yaparken önceki tüm observation'ları
+      # görmüştü). Anchor'dan önceki birimler = banked; son K assistant-taşıyan
+      # birim + anchor + sonrası daima raw. Banked bölgedeki tool satırlarının
+      # content'i tombstone ile değişir; diğer anahtarlar bit-bit korunur.
+      class ObservationProjection::Directive
+        def initialize(ledger:, window:, deps:)
+          @ledger = ledger
+          @window = window
+          @deps = deps
+        end
+
+        attr_reader :rev
+
+        # -> {count:, rev:, reclaimed_tokens:} (rows KOPYASI üzerinde çalışır)
+        def apply!(rows)
+          before = Prompt::TokenEstimator.estimate_history(rows)
+          units = Prompt::ContextCompactor.group_atomic_units(rows)
+          anchor_idx = anchor_unit_index(units)
+          count = 0
+          rev_now = @ledger.rev
+          units.each_with_index do |unit, idx|
+            next unless banked?(idx, anchor_idx, units)
+            next if Prompt::ContextCompactor.unit_pins_goal?(unit) # <user_task> taşıyan birim asla emilmez
+
+            unit.each do |row|
+              count += 1 if tombstone!(row, rev_now)
+            end
+          end
+          return { count: 0, rev: rev_now, reclaimed_tokens: 0 } if count.zero?
+
+          reclaimed = before - Prompt::TokenEstimator.estimate_history(rows)
+          observe(count, rev_now, reclaimed)
+          { count: count, rev: rev_now, reclaimed_tokens: reclaimed }
+        end
+
+        private
+
+        # En yeni accepted anchor biriminin index'i; hiç yoksa nil → no-op
+        # (anchor'sız banked bölge tanımsızdır — dürüst iç çekim yapmayız).
+        def anchor_unit_index(units)
+          units.rindex { |unit| unit.any? { |row| anchor_row?(row) } }
+        end
+
+        def anchor_row?(row)
+          return false unless Prompt::ConversationRows.row?(row)
+
+          Prompt::ConversationRows.role_of(row) == "tool" &&
+            tool_name_of(row) == ObservationProjection::MODULE_NAME &&
+            row[:status].to_s != "error" && row["status"].to_s != "error"
+        end
+
+        # Recency: son K assistant-taşıyan birimin İLKİnden itibaren her şey
+        # (ve anchor'u ve sonrası) raw kalır; banked = idx < anchor VE
+        # idx < recency_start.
+        def banked?(idx, anchor_idx, units)
+          return false if anchor_idx.nil? || idx >= anchor_idx
+
+          assistant_units = units.each_index.select { |i| units[i].any? { |r| assistant_row?(r) } }
+          recency_start = assistant_units[[assistant_units.size - @window, 0].max] || units.size
+          idx < recency_start
+        end
+
+        def assistant_row?(row)
+          Prompt::ConversationRows.row?(row) && Prompt::ConversationRows.role_of(row) == "assistant"
+        end
+
+        # Muafiyetler: ledger tool satırları (Σ denetim izi), skill gövdeleri,
+        # goal-pinned birimler, user/assistant/system satırları (kural gereği
+        # zaten aday değil), hâlihazırda tombstone taşıyanlar (idempotence).
+        def tombstone!(row, rev_now)
+          return false unless Prompt::ConversationRows.row?(row)
+
+          role = Prompt::ConversationRows.role_of(row)
+          return false unless ["tool", "tool_result"].include?(role)
+
+          name = tool_name_of(row)
+          return false if name == ObservationProjection::MODULE_NAME
+          return false if name == ObservationProjection::SKILL_TOOL_NAME
+          return false if row[:status].to_s == "error" || row["status"].to_s == "error"
+
+          key = Prompt::ConversationRows.content_key_of(row)
+          content = row[key].to_s
+          return false if content.start_with?("<absorbed_into_ledger")
+
+          row[key] = %(<absorbed_into_ledger rev="#{rev_now}" tool="#{Rubik::Platform.xml_escape(name.to_s)}" />)
+          true
+        end
+
+        def tool_name_of(row)
+          (row[:tool_name] || row["tool_name"]).to_s
+        end
+
+        # Sessizlik sözleşmesi: tek gözlemlenebilirlik on_step
+        # (:ledger_absorb_drop — StepFormatter bilinmeyen tipte nil döner →
+        # UI sessiz) + dmesg ring kaydı. Notice/event_bus/wake YOK.
+        def observe(count, rev_now, reclaimed)
+          @deps.on_step&.call(type: :ledger_absorb_drop, count: count, rev: rev_now,
+                              reclaimed_tokens: reclaimed,
+                              step: @deps.respond_to?(:step_count) ? @deps.step_count : nil,
+                              max_steps: @deps.respond_to?(:max_steps) ? @deps.max_steps : nil)
+          dmesg = Rubik::Coeffects.get(@deps.runtime_manager&.context, Rubik::Coeffects::DMESG)
+          if dmesg.respond_to?(:log)
+            dmesg.log(:orchestrator, :info,
+                      "goal ledger absorbed #{count} observation row(s) (rev=#{rev_now}, ~#{reclaimed} tokens reclaimed)")
+          end
+        rescue StandardError => e
+          Rubik::Log.warn(:orchestrator, "observation projection observability failed (#{e.class}: #{e.message})")
+        end
+      end
+    end
+  end
+end