rubik 0.1.0

data/lib/rubik/orchestrator/goal_state.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "monitor"
+require "time"
+require_relative "../platform"
+
+module Rubik
+  module Orchestrator
+    # !goal döngüsünün canlı durum anlık görüntüsü. maestro VE alt ajanlar
+    # rubik://goal/state üzerinden aynı nesneyi okur; yazma yalnızca REPL
+    # thread'indedir (on_step + komut sonuç dalı) ama Monitor ile kilitlenir
+    # — okuma (read_file) her an güvenli olmalıdır.
+    class GoalState
+      # Bitiş olayının bus adı (Vakanüvis kronikçisinin goal kancası — K3;
+      # REPL bu olaya abone değildir, notice/wake üretilmez).
+      FINISH_EVENT = :goal_finished
+
+      def initialize(event_bus: nil)
+        @monitor = Monitor.new
+        @event_bus = event_bus
+        @status = :idle
+        @goal = ""
+        @step_count = 0
+        @max_steps = 0
+        @extensions = 0
+        @last_error = nil
+        @output_summary = nil
+        @started_at = nil
+        @finished_at = nil
+        @tokens = { input: 0, output: 0 }
+      end
+
+      attr_reader :status, :goal, :step_count, :max_steps, :extensions,
+                  :last_error, :output_summary, :started_at, :finished_at, :tokens
+
+      # Goal-ledger planı A: son Σ revizyon satırının storage id'si — yalnız
+      # goal.ledger.enabled iken !goal komutu set eder; OFF yolunda hiç set
+      # edilmez (snapshot/payload/to_xml render'ları bayt-özdeş kalır).
+      attr_accessor :ledger_id
+
+      def running? = @monitor.synchronize { @status == :running }
+
+      # Yeni bir koşu: tekrarlanan !goal çağrılarında sıfırlar (provide swap
+      # semantiğiyle eşleşir — Context#provide inverse yığmaz).
+      def start!(text, max_steps)
+        @monitor.synchronize do
+          @goal = text.to_s
+          @max_steps = max_steps.to_i
+          @step_count = 0
+          @extensions = 0
+          @last_error = nil
+          @output_summary = nil
+          @tokens = { input: 0, output: 0 }
+          @started_at = Time.now
+          @finished_at = nil
+          @status = :running
+        end
+        self
+      end
+
+      # Monotonik sayaç: on_step olayları bir adım içinde tekrarlanır
+      # (:thinking, :llm_thought, :tool_*); geriye gitmek bir hata değil
+      # sıralama gürültüsüdür — görmezden gelinir. Yükselen max (canlı
+      # !steps uzatması) kabul edilir.
+      def update_steps(current, max)
+        @monitor.synchronize do
+          @step_count = current.to_i if current.to_i >= @step_count
+          @max_steps = max.to_i if max.to_i >= @max_steps
+        end
+      end
+
+      def extend!(new_max)
+        @monitor.synchronize do
+          return self unless @status == :running
+
+          @extensions += 1
+          @max_steps = new_max.to_i if new_max.to_i > @max_steps
+        end
+        self
+      end
+
+      def record_tokens!(usage)
+        @monitor.synchronize do
+          u = usage.to_h
+          @tokens[:input] += u[:input].to_i
+          @tokens[:output] += u[:output].to_i
+        end
+        self
+      end
+
+      def complete!(output_summary = nil, tokens: nil)
+        @monitor.synchronize do
+          return self unless @status == :running
+
+          @output_summary = output_summary.to_s.split("\n").first.to_s.slice(0, 200)
+          finish_unlocked!(:completed, tokens)
+        end
+        notify_finish
+        self
+      end
+
+      def fail!(error, tokens: nil)
+        @monitor.synchronize do
+          return self unless @status == :running
+
+          @last_error = Rubik::Platform.safe_utf8(error.to_s).slice(0, 300)
+          finish_unlocked!(:failed, tokens)
+        end
+        notify_finish
+        self
+      end
+
+      def stop!(reason)
+        @monitor.synchronize do
+          return self unless @status == :running
+
+          @last_error = Rubik::Platform.safe_utf8(reason.to_s).slice(0, 300)
+          finish_unlocked!(:stopped, nil)
+        end
+        notify_finish
+        self
+      end
+
+      def snapshot
+        @monitor.synchronize do
+          snap = { status: @status, goal: @goal, steps: @step_count, max_steps: @max_steps,
+                   extensions: @extensions, last_error: @last_error, output_summary: @output_summary,
+                   started_at: @started_at, finished_at: @finished_at, tokens: @tokens.dup }
+          snap[:ledger_id] = @ledger_id if @ledger_id
+          snap
+        end
+      end
+
+      # rubik://goal/state gövdesi (read_file çıktısı). Nitelikler yoksa
+      # boş basılmaz — tüketici (LLM) boşlukla değil yoklukla muhatap olur.
+      def to_xml
+        s = snapshot
+        esc = Rubik::Platform.method(:xml_escape)
+        attrs = %(status="#{s[:status]}" steps="#{s[:steps]}" max_steps="#{s[:max_steps]}" ) +
+                %(extensions="#{s[:extensions]}" started_at="#{iso(s[:started_at])}")
+        attrs += %( finished_at="#{iso(s[:finished_at])}") if s[:finished_at]
+        attrs += %( last_error="#{esc.call(s[:last_error])}") if s[:last_error]
+        attrs += %( ledger_id="#{esc.call(s[:ledger_id])}") if s[:ledger_id]
+        <<~XML.strip
+          <goal_state #{attrs}>
+            <goal>#{esc.call(s[:goal])}</goal>
+            <tokens input="#{s[:tokens][:input]}" output="#{s[:tokens][:output]}" />
+          </goal_state>
+        XML
+      end
+
+      private
+
+      # Vakanüvis goal kancası (K3): bitiş anlık görüntüsünü bus'a GÖNDERİR
+      # (post — senkron drain yok, monitor kapanışından SONRA çağrılır).
+      # REPL bu olaya abone değildir: notice/wake üretilmez, yalnızca
+      # kronikçi (varsa) ve dmesg görür. Bus yoksa (bağımsız kullanım)
+      # sessizce atlanır.
+      def notify_finish
+        return unless @event_bus.respond_to?(:post)
+
+        s = snapshot
+        payload = { status: s[:status].to_s, goal: s[:goal].to_s, steps: s[:steps],
+                    max_steps: s[:max_steps], output_summary: s[:output_summary].to_s,
+                    last_error: s[:last_error].to_s }
+        payload[:ledger_id] = s[:ledger_id] if s[:ledger_id]
+        @event_bus.post(FINISH_EVENT, payload, subsystem: :orchestrator, level: :info)
+      rescue StandardError => e
+        Rubik::Log.warn(:orchestrator, "goal finish event post failed: #{e.class}: #{e.message}")
+      end
+
+      # @monitor altında çağrılır — çift finish (Interrupt yarışı) no-op'tır.
+      def finish_unlocked!(status, tokens)
+        @status = status
+        @finished_at = Time.now
+        t = tokens.to_h
+        @tokens[:input] += t[:input].to_i
+        @tokens[:output] += t[:output].to_i
+      end
+
+      def iso(time) = time ? time.utc.iso8601 : ""
+    end
+  end
+end

data/lib/rubik/orchestrator/goal_wait.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../log"
+
+module Rubik
+  module Orchestrator
+    # Premature goal-completion guard (maestro lifecycle round 4; field
+    # incident 2026-10-05): in goal mode a text-only conclusion or a
+    # `finish` call used to end the run with success while dispatched
+    # subagents were still running — "Goal Achieved" over a live pipeline.
+    # GoalWait owns the implicit yield-and-wait that replaces that
+    # terminal: block on the supervisor (bounded, burns no step), deliver
+    # pending notices into history, and hand the turn back so the maestro
+    # reacts and re-attempts completion only once nothing dispatched
+    # remains. Interactive mode never reaches this object — the user
+    # channel guards on Loop#goal_mode?.
+    class GoalWait
+      DEFAULT_TIMEOUT = 300
+
+      def initialize(deps)
+        @deps = deps
+      end
+
+      # Live dispatched work: any active unit (running, paused on error or
+      # budget, or blocked on an ask_question answer) counts — none of them
+      # may be abandoned by a completion. A nil supervisor (no subagent
+      # system, bare test loops) means nothing is pending.
+      def pending?
+        active_count.positive?
+      end
+
+      def active_count
+        supervisor&.active_count.to_i
+      end
+
+      # Called by the user channel INSTEAD of building the success
+      # terminal. Always returns nil — the step loop continues and the
+      # model re-attempts completion once the injected messages say the
+      # pipeline has settled. Never returns a terminal itself: the guard
+      # must not become a second completion path.
+      def premature_yield!(via:)
+        inbox = @deps.loop_instance.subagent_notice_inbox
+        return inject_notices! unless inbox.empty?
+
+        timeout = wait_timeout
+        @deps.on_step&.call(type: :goal_wait, via: via, active: active_count, timeout: timeout,
+                            step: @deps.step_count, max_steps: @deps.max_steps)
+        # Notices arriving while the model was concluding sit in the inbox;
+        # wait_for blocks until the whole dispatched set settles (budget-
+        # and error-paused units emit their notice and are excluded here,
+        # so the inbox check below re-prompts the maestro to steer them).
+        supervisor&.wait_for(nil, timeout: timeout) if timeout.positive?
+
+        return inject_notices! unless inbox.empty?
+        return timeout_nudge! if pending?
+
+        settled_nudge!
+      end
+
+      private
+
+      def supervisor
+        @supervisor ||= Rubik::Coeffects.get(@deps.runtime_manager&.context, Rubik::Coeffects::SUBAGENT_SUPERVISOR)
+      rescue StandardError => e
+        # Absence never raises (Coeffects.get is nil-safe), so this branch
+        # is real breakage and the guard goes INERT for the rest of the
+        # run — warn unconditionally; the REPL completion defense
+        # (agent_execution.rb) still refuses a false "Goal Achieved" in
+        # that world by failing conservative.
+        Rubik::Log.warn(:orchestrator, "goal wait: supervisor resolution failed (#{e.class}: #{e.message}); " \
+                                       "premature-completion guard inert for this run")
+        nil
+      end
+
+      def wait_timeout
+        raw = @deps.safe_config("agent.goal_wait_timeout", DEFAULT_TIMEOUT)
+        return raw.to_i if raw.is_a?(Numeric)
+        # "0"/"300" honor the user; garbage ("5min") must not degrade to a
+        # zero wait — fall back to the default bound.
+        return raw.to_i if raw.to_s.match?(/\A\s*-?\d+\s*\z/)
+
+        DEFAULT_TIMEOUT
+      rescue KeyError, TypeError, NoMethodError
+        DEFAULT_TIMEOUT
+      end
+
+      # Drains the inbox into history through the loop's own merge seam and
+      # continues the loop — the model evaluates the notice digest on its
+      # next turn, exactly like the interactive reactive wake.
+      def inject_notices!
+        @deps.loop_instance.drain_subagent_notices_into_history!
+        nil
+      end
+
+      # Deadline hit with live units: one step is spent telling the model
+      # the wait is still open. Concluding again re-arms the implicit wait,
+      # so a model that has nothing to add cycles cheaply instead of
+      # falsely completing.
+      def timeout_nudge!
+        append_user_message!(
+          "<goal_wait_timeout active=\"#{active_count}\" timeout=\"#{wait_timeout}\">#{active_count} dispatched " \
+          "subagent(s) are still running. The goal is NOT complete while they run. Conclude your turn again to " \
+          "keep waiting, or inspect and steer them (`manage_subagents` action 'status' | 'wait' | 'kill'). " \
+          "Call finish only once every dispatched subagent has settled.</goal_wait_timeout>"
+        )
+        nil
+      end
+
+      # Everything settled during the wait without a single notice — only
+      # reachable when notice routing is absent (test doubles). The model,
+      # not the guard, draws the completion conclusion.
+      def settled_nudge!
+        append_user_message!(
+          "<goal_wait_settled>All dispatched subagents have settled with no pending notices. " \
+          "Verify their outcomes and conclude the goal (finish) if the objective is met.</goal_wait_settled>"
+        )
+        nil
+      end
+
+      def append_user_message!(xml)
+        @deps.history << { role: "user", content: xml }
+      end
+    end
+  end
+end