rubik 0.1.5 → 0.2.0

data/lib/rubik/concurrency/event_loop.rb

@@ -20,7 +20,8 @@ module Rubik
     #     the loop thread wakes immediately.
     #   * Wake staleness is handled by park generations: every registration
     #     stamps @gen[fiber]; timer fires and io dispatch only push when the
-    #     generation still matches, so a fiber that timed out and re-parked
+    #     generation still matches at dispatch, including queued wakeups,
+    #     so a fiber that timed out and re-parked
     #     elsewhere can never be resumed by a stale source.
     #
     # Drain model (waiters, not liveness — Fiber#alive? does not exist on
@@ -48,8 +49,8 @@ module Rubik
 
       def initialize
         @mutex = ::Mutex.new
-        @runnable = []       # [[fiber, resume_value]] — guarded by @mutex
-        @parked = {}         # fiber => true (block-hook parks) — guarded
+        @runnable = []       # [[fiber, resume_value, park_generation]] — guarded by @mutex
+        @parked = {}         # fiber => generation (block-hook parks) — guarded
         @waiter_threads = [] # process-wait threads — guarded
         # Stale timers (fiber re-parked or resumed since registration) must
         # not gate draining — @gen is bumped on every resume, so any of this
@@ -77,11 +78,11 @@ module Rubik
 
       # Queues a fiber to be resumed with value. Safe from foreign threads:
       # pushes write a self-pipe byte so the loop's IO.select wakes at once.
-      def push(fiber, value: true)
+      def push(fiber, value: true, generation: nil)
         @mutex.synchronize do
           return if @closed
 
-          @runnable << [fiber, value]
+          @runnable << [fiber, value, generation]
         end
         kick unless ::Thread.current.equal?(@loop_thread)
       end
@@ -95,8 +96,8 @@ module Rubik
         @mutex.synchronize do
           return if @closed
 
-          @parked.delete(fiber)
-          @runnable << [fiber, value]
+          generation = @parked.delete(fiber)
+          @runnable << [fiber, value, generation]
         end
         kick unless ::Thread.current.equal?(@loop_thread)
       end
@@ -149,8 +150,8 @@ module Rubik
       # timeout of 0 still registers a timer (fires immediately) — truthiness
       # guards would park join(0)/wait(0) polls forever.
       def park(_blocker, timeout = nil)
-        @mutex.synchronize { @parked[::Fiber.current] = true }
         value = park_fiber do |fiber, gen|
+          @mutex.synchronize { @parked[fiber] = gen }
           @timers.add(monotonic + timeout, fiber, :timeout, gen) unless timeout.nil?
         end
         value == :timeout ? false : value
@@ -172,49 +173,52 @@ module Rubik
         value
       end
 
-      # io_read body (one nonblocking attempt per call — the VM re-invokes
-      # the hook in a loop, mirroring IO::Buffer#read's one-syscall shape).
-      # Fills the caller's buffer and returns bytes read (0 = EOF).
-      #
-      # Two 4.0.6 facts shape this (verified by probe): the integer hook
-      # args are protocol noise (3.3 passes length; 4.0 passes 0,0 — both
-      # size the buffer to the requested read, hence buffer.size), and
-      # EVERY blocking-family read primitive — read_nonblock included — is
-      # itself routed back through scheduler.io_read once the hook exists.
-      # The Fiber.blocking wrap is the VM-sanctioned escape (ruby's own test
-      # scheduler wraps its primitives the same way): it runs the primitive
-      # immediately, bypassing interception, and read_nonblock(exception:
-      # false) never blocks the OS thread.
-      def read_io(io, buffer)
-        length = buffer.size
-        return 0 if length.zero?
+      # A zero minimum means one nonblocking attempt: return -errno to
+      # the VM instead of parking here, so read_nonblock preserves the
+      # caller's subsequent IO#wait_readable deadline (e.g. Net::HTTP).
+      # Fiber.blocking prevents the primitive from re-entering this hook.
+      def read_io(io, buffer, minimum = 0, offset = 0)
+        transferred = 0
+        capacity = buffer.size - offset
+        return 0 if capacity.zero?
 
         loop do
-          chunk = ::Fiber.blocking { io.read_nonblock(length, exception: false) }
+          chunk = ::Fiber.blocking { io.read_nonblock(capacity - transferred, exception: false) }
           case chunk
-          when :wait_readable then wait_io(io, READABLE, nil)
-          when :wait_writable then wait_io(io, WRITABLE, nil)
-          when nil then return 0
+          when :wait_readable, :wait_writable
+            return transferred.positive? ? transferred : -Errno::EAGAIN::Errno if transferred >= minimum
+
+            wait_io(io, chunk == :wait_readable ? READABLE : WRITABLE, nil)
+          when nil then return transferred
           else
-            buffer.copy(::IO::Buffer.for(chunk), 0)
-            return chunk.bytesize
+            buffer.set_string(chunk, offset + transferred)
+            transferred += chunk.bytesize
+            return transferred if transferred >= minimum || transferred == capacity
           end
         end
+      rescue SystemCallError => e
+        -e.errno
       end
 
-      # io_write body: writes the whole caller-supplied buffer with one
-      # nonblocking attempt per call, parking on WRITABLE between attempts.
-      # (4.0.6 passes (0,0) as integers and expects the full buffer out.)
-      def write_io(io, buffer)
-        data = buffer.get_string(0, buffer.size)
-        return 0 if data.empty?
+      def write_io(io, buffer, minimum = 0, offset = 0)
+        transferred = 0
+        capacity = buffer.size - offset
+        return 0 if capacity.zero?
 
         loop do
+          data = buffer.get_string(offset + transferred, capacity - transferred)
           written = ::Fiber.blocking { io.write_nonblock(data, exception: false) }
-          return written if written.is_a?(::Integer)
+          if written.is_a?(::Integer)
+            transferred += written
+            return transferred if transferred >= minimum || transferred == capacity
+          else
+            return transferred.positive? ? transferred : -Errno::EAGAIN::Errno if transferred >= minimum
 
-          wait_io(io, WRITABLE, nil)
+            wait_io(io, written == :wait_readable ? READABLE : WRITABLE, nil)
+          end
         end
+      rescue SystemCallError => e
+        -e.errno
       end
 
       # DNS resolution parks the fiber; the DnsPool worker delivers the list
@@ -345,7 +349,9 @@ module Rubik
 
       def run_batch
         while (item = @mutex.synchronize { @runnable.shift })
-          fiber, value = item
+          fiber, value, generation = item
+          next if generation && @gen[fiber] != generation
+
           # A resumed fiber is definitionally no longer parked; dropping the
           # registration here keeps interrupt-style wakes from leaking parks.
           # Bumping the park generation invalidates every OTHER outstanding
@@ -369,7 +375,9 @@ module Rubik
       end
 
       def select_or_wait
-        read_set = @io_waiters.keys
+        read_set = @io_waiters.each_with_object([]) do |(io, slot), acc|
+          acc << io unless slot[:read].empty?
+        end
         write_set = @io_waiters.each_with_object([]) do |(io, slot), acc|
           acc << io unless slot[:write].empty?
         end
@@ -407,7 +415,7 @@ module Rubik
           next if gen != STICKY && @gen[fiber] != gen # stale: fiber moved on after registering
 
           drop_io_interest(fiber)
-          push(fiber, value: value)
+          push(fiber, value: value, generation: gen == STICKY ? nil : gen)
         end
       end
 
@@ -420,7 +428,9 @@ module Rubik
         slot = @io_waiters[io]
         return unless slot
 
-        waiters = slot[:read].merge(slot[:write])
+        waiters = {}
+        waiters.merge!(slot[:read]) if events.anybits?(READABLE)
+        waiters.merge!(slot[:write]) if events.anybits?(WRITABLE)
         waiters.each do |fiber, gen|
           if @gen[fiber] != gen
             # Stale interest (the fiber timed out or moved on): remove it so
@@ -434,7 +444,7 @@ module Rubik
           # it re-registers with a fresh generation.
           slot[:read].delete(fiber)
           slot[:write].delete(fiber)
-          push(fiber, value: events)
+          push(fiber, value: events, generation: gen)
         end
         @io_waiters.delete(io) if slot[:read].empty? && slot[:write].empty?
       end
@@ -460,7 +470,9 @@ module Rubik
           slot = @io_waiters.delete(io)
           next unless slot
 
-          (slot[:read].keys + slot[:write].keys).each { |fiber| push(fiber, value: 0) }
+          slot[:read].merge(slot[:write]).each do |fiber, gen|
+            push(fiber, value: 0, generation: gen)
+          end
           pruned += 1
         end
         pruned

data/lib/rubik/concurrency/scheduler.rb

@@ -5,23 +5,9 @@ require_relative "process_waiter"
 
 module Rubik
   module Concurrency
-    # Adapter for the VM's Fiber::Scheduler hook protocol — stateless; all
-    # state lives on the EventLoop. Ruby 3.3 ↔ 4.0 protocol drift is
-    # concentrated here (probes against 4.0.6, plan §2):
-    #
-    #   fiber    4.0: fiber(&blk) — scheduler creates and returns the fiber.
-    #            3.3: fiber(fiber, block) — VM pre-created it.
-    #   io_read  integer args differ (3.3 passes length; 4.0 passes 0, 0)
-    #   io_write but the buffer is always sized to the operation, so both
-    #            hooks drive off buffer.size — see EventLoop#read_io.
-    #
-    # io_read/io_write are required on 4.0: without them a plain IO#read
-    # inside a scheduled fiber falls back to a whole-thread BLOCKING read
-    # (measured: 20 × 0.2 s child pipes serialized into 13 s). The buffer is
-    # filled/drained with read_nonblock/write_nonblock + IO::Buffer views —
-    # IO#nonblock= and IO::Buffer#read(io,...) are NOT usable on Windows
-    # builds (NoMethodError / constant-zero reads, verified), while the
-    # nonblock(…, exception: false) family works for pipes and sockets alike.
+    # Adapter for the VM's Fiber::Scheduler hooks. IO hooks receive a
+    # minimum transfer length and a buffer offset. A zero minimum requests
+    # one nonblocking attempt; the VM owns subsequent waits and deadlines.
     class Scheduler
       attr_reader :loop
 
@@ -42,15 +28,12 @@ module Rubik
         @loop.wait_io(io, events, timeout)
       end
 
-      # The integer args differ per protocol (3.3: length; 4.0. offset/length
-      # both zero) but the buffer is always sized to the operation, so the
-      # EventLoop drives both hooks off buffer.size — see read_io/write_io.
-      def io_read(io, buffer, *_protocol_args)
-        @loop.read_io(io, buffer)
+      def io_read(io, buffer, length, offset = 0)
+        @loop.read_io(io, buffer, length, offset)
       end
 
-      def io_write(io, buffer, *_protocol_args)
-        @loop.write_io(io, buffer)
+      def io_write(io, buffer, length, offset = 0)
+        @loop.write_io(io, buffer, length, offset)
       end
 
       def kernel_sleep(duration = nil)

data/lib/rubik/config/defaults.rb

@@ -118,6 +118,7 @@ module Rubik
           "statusline_template" => "{model} · ctx {ctx} · {dirty} · sandbox {sandbox}",
           "input_box" => false,
           "paste_join_window_ms" => 120, # Plan 91: lines arriving within this gap join into one paste turn
+          "prompt_grace_window_ms" => 1000,
           "quiet_notices" => false # Plan 105: buffer background notices to inbox until prompt/enter
         },
         "workspace" => {
@@ -148,13 +149,15 @@ module Rubik
           "network_backoff_base" => 0.5,
           "error_wait_timeout" => 300,
           "question_timeout" => 300,
-          # Bitmiş subagent bu grace (sn) sonrasında reap edilir (0 = kapalı);
-          # tombstone_limit sorgulanabilir mezar taşı sayısını sınırlar:
+          # reap_finished_after: grace (sn, 0 = kapalı); tombstone_limit: sorgulanabilir mezar taşı sınırı.
           "reap_finished_after" => 300,
           "tombstone_limit" => 25,
-          # Maestro kapısı: maestro write_file/replace_file_content/run_command/
-          # run_tests araçlarını doğrudan ÇALIŞTIRAMAZ — subagent'a devir zorunlu
-          # (false = doktrin yalnız prompt düzeyinde, kapı kapalı):
+          "cancel_timeout" => 2, # foreground ^C: owned descendants' grace period (s) before force-kill
+          # Sonuç arşivi (issue #122): tamamlanan koşular oturum-içi saklanır; redeploy öncekini EZMEZ.
+          "result_archive" => { "ttl_seconds" => 3600, "max_runs_per_instance" => 8, "page_chars" => 4000 },
+          # Append-only execution journal (issue #124): per-execution JSONL, capped per file.
+          "journal" => { "max_bytes" => 2_097_152 },
+          # Maestro kapısı: maestro write_file/replace_file_content/run_command/run_tests'ı ÇALIŞTIRAMAZ:
           "maestro_gate" => true,
           "auto_pause_on_network_error" => true,
           "reactive_wakeup" => true,
@@ -217,6 +220,7 @@ module Rubik
 
         config.each do |key, val|
           current_key = prefix.empty? ? key.to_s : "#{prefix}.#{key}"
+          validate_prompt_grace_value!(current_key, val)
           if schema.is_a?(Hash) && !schema.key?(key.to_s)
             candidate_keys = schema.keys
             candidates = if defined?(Rubik::Tools::FuzzyMatcher)
@@ -235,7 +239,6 @@ module Rubik
             raise ArgumentError, suggestion_msg if strict
 
             @warnings << suggestion_msg
-
           elsif val.is_a?(Hash) && schema.is_a?(Hash) && schema[key.to_s].is_a?(Hash) && !schema[key.to_s].empty?
             validate_schema(val, schema[key.to_s], current_key, strict: strict)
           end

data/lib/rubik/config.rb

@@ -68,6 +68,8 @@ module Rubik
     def set(key, value, persist: nil)
       old_val = fetch(key)
       typed_val = parse_scalar_value(value)
+      validate_prompt_grace_value!(key.to_s, typed_val)
+      validate_schema(typed_val, DEFAULT_CONFIG["ui"], "ui") if key.to_s == "ui" && typed_val.is_a?(Hash)
       keys = key.to_s.split(".")
       last_key = keys.pop
       target = keys.reduce(@data) do |acc, k|
@@ -161,6 +163,12 @@ module Rubik
 
     private
 
+    def validate_prompt_grace_value!(key, value)
+      return unless key == "ui.prompt_grace_window_ms" && !(value.is_a?(Integer) && value >= 0)
+
+      raise ArgumentError, "ui.prompt_grace_window_ms must be a non-negative integer (milliseconds)"
+    end
+
     # save! returns itself for no-write scopes; persist outcomes are hashes.
     def persist_result(res)
       res.is_a?(Hash) ? res : { ok: true }

data/lib/rubik/context/git_lister.rb

@@ -21,7 +21,12 @@ module Rubik
         )
         return nil unless status.success?
 
-        out.split("\x00", -1).reject(&:empty?).map { |p| p.tr("\\", "/") }.uniq
+        # PERF: NUL-split with conditional in-place backslash translation and
+        # in-place deduplication avoids intermediate array and string allocations.
+        res = out.split("\x00", -1).reject(&:empty?)
+        res.map! { |p| p.tr("\\", "/") } if out.include?("\\")
+        res.uniq!
+        res
       rescue StandardError
         nil
       end

data/lib/rubik/context/scanner.rb

@@ -196,8 +196,9 @@ module Rubik
         }
       end
 
+      # PERF: integer math avoids Rational allocation from Time#to_r (~5x faster, zero allocation)
       def mtime_micros(stat)
-        (stat.mtime.to_r * 1_000_000).to_i
+        (stat.mtime.tv_sec * 1_000_000) + stat.mtime.tv_usec
       end
 
       def walk_dir(base_dir, rel_prefix, key_prefix, ignore_patterns, previous, needles)
@@ -325,6 +326,15 @@ module Rubik
         # depth. subtree_ignored? is a pure function of (dir, needles), so
         # the memo is exact.
         dir_verdicts = Hash.new { |h, dir| h[dir] = subtree_ignored?(dir, needles) }
+
+        # PERF: filter ignore_patterns to exclude prunable subtree patterns that
+        # dir_verdicts already checked on ancestor directory segments.
+        file_patterns = ignore_patterns.reject do |pat|
+          m = PRUNABLE_PATTERN.match(pat)
+          m && !m[1].include?("*") && !m[1].include?("?") && !m[1].include?("[")
+        end
+        file_rules = compile_ignore_regexes(file_patterns)
+
         order_like_walker(rel_paths).each do |rel|
           # PERF: zero-allocation ancestor check using string slicing instead of Array#split and Array#join
           ignored_dir = false
@@ -337,7 +347,8 @@ module Rubik
             idx += 1
           end
           next if ignored_dir
-          next if ignored?(rel, ignore_patterns)
+          next if rel == ".rubik" || rel.start_with?(".rubik/") || rel == ".git" || rel.start_with?(".git/")
+          next if file_rules.any? { |r| pattern_match?(r, rel) }
           next unless included?(rel, @custom_includes)
 
           full = "#{base_dir}/#{rel}"
@@ -370,8 +381,9 @@ module Rubik
       # PERF: replacing "/" with NUL byte ("\x00") is equivalent to array component
       # comparison because NUL (0x00) is strictly less than any valid path byte,
       # avoiding intermediate Array allocations per path (~8.4x faster, ~62.5% fewer allocations).
+      # PERF: in-place sort_by! avoids array re-allocation
       def order_like_walker(paths)
-        paths.sort_by { |p| p.tr("/", "\x00") }
+        paths.sort_by! { |p| p.tr("/", "\x00") }
       end
 
       def parse_gitignore(dir = @root_dir)

data/lib/rubik/mcp/transport/stdio.rb

@@ -29,6 +29,7 @@ module Rubik
           @mutex = Mutex.new
           @cv = ConditionVariable.new
           @responses = {}
+          @closed = false
         end
 
         def open
@@ -78,6 +79,7 @@ module Rubik
           end
 
           @running = true
+          @closed = false
           @req_id = 0
           @responses.clear
 
@@ -118,8 +120,9 @@ module Rubik
         end
 
         def close
-          return unless @running || @wait_thr&.alive?
+          return if @closed
 
+          @closed = true
           @running = false
 
           begin
@@ -128,6 +131,16 @@ module Rubik
             nil
           end
 
+          if @wait_thr&.alive?
+            Rubik::Platform.kill_tree(@wait_thr.pid)
+            begin
+              @wait_thr.join(0.5)
+            rescue StandardError
+              nil
+            end
+          end
+          @wait_thr = nil
+
           [@stdin, @stdout, @stderr].each do |io|
             io&.close unless io&.closed?
           rescue StandardError
@@ -142,16 +155,6 @@ module Rubik
             @reader_thr = nil
           end
 
-          if @wait_thr&.alive?
-            Rubik::Platform.kill_tree(@wait_thr.pid)
-            begin
-              @wait_thr.join(0.5)
-            rescue StandardError
-              nil
-            end
-          end
-          @wait_thr = nil
-
           @mutex.synchronize do
             @responses.clear
             @cv.broadcast

data/lib/rubik/orchestrator/step_executor.rb

@@ -151,7 +151,11 @@ module Rubik
               error: err,
               output: trunc_res[:text],
               duration_ms: dur,
-              truncated: trunc_res[:truncated]
+              truncated: trunc_res[:truncated],
+              # Structured fields ride along when the tool provides them
+              # (issue #127): the same Result contract for every carrier.
+              exit_code: raw_output.respond_to?(:exit_code) ? raw_output.exit_code : nil,
+              metadata: raw_output.respond_to?(:metadata) ? raw_output.metadata : {}
             )
           else
             out_str = raw_output.to_s
@@ -239,6 +243,8 @@ module Rubik
           step: @deps.step_count,
           max_steps: @deps.max_steps,
           call_id: call_id,
+          exit_code: tool_result.exit_code,
+          metadata: tool_result.metadata,
           line_count: tool_result.output.to_s.lines.size,
           byte_size: tool_result.output.to_s.bytesize,
           tokens: @deps.total_tokens
@@ -246,7 +252,8 @@ module Rubik
 
         Rubik::Orchestrator::ToolHistory.write(@deps.history, tool_call_id: call_id, tool_name: tool_name,
                                                               status: tool_result.status, duration_ms: tool_result.duration_ms,
-                                                              content: tool_result.to_xml)
+                                                              content: tool_result.to_xml, exit_code: tool_result.exit_code,
+                                                              metadata: tool_result.metadata)
         @deps.activity.record(tool_name, tool_args, tool_result.status) if @deps.respond_to?(:activity)
         @deps.reset_invalid_tools!
         tool_result

data/lib/rubik/orchestrator/subagent/activation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../task_cancellation"
+
 module Rubik
   module Orchestrator
     module Subagent
@@ -23,13 +25,18 @@ module Rubik
         # happens at execute time, but a start_async completion must never
         # race an unprovided asker), unit registration second (pre-start, so
         # the kernel board sees a live unit), start_async last.
-        def activate_instance!(inst, child_ctx:)
+        def activate_instance!(inst, child_ctx:, owner_token: nil)
           # ask_question'ın subagent düzlemi: instance kendi child ctx'ine
           # asker olarak publish edilir.
           child_ctx&.provide(Rubik::Coeffects::SUBAGENT_QUESTION_ASKER, inst)
           # send_message atfı: subagent→maestro mesajları gerçek gönderen
           # id'siyle taşır (coeffect yoksa root default'u yanlış atfı yapar).
           child_ctx&.provide(Rubik::Coeffects::SUBAGENT_SENDER_ID, inst.id)
+          # Task ownership (issue #125): the spawned execution (and, through
+          # inheritance, its own nested spawns) carries the owner's token; a
+          # detached spawn gets a never-cancelled token so its whole subtree
+          # survives a foreground ^C.
+          child_ctx&.provide(Rubik::Coeffects::TASK_CANCELLATION, owner_token || TaskCancellation.detached)
           eff_init = @init || (@root_context.respond_to?(:get) && Rubik::Coeffects.get(@root_context, Rubik::Coeffects::INIT))
           eff_init&.register(Kernel::SubagentUnit.new(inst, context: child_ctx, birth_state: unit_birth_state(inst)))
           inst.start_async { |completed_inst| handle_subagent_completion(completed_inst) }

data/lib/rubik/orchestrator/subagent/completion.rb

@@ -16,18 +16,45 @@ module Rubik
         def handle_subagent_completion(inst)
           merge_branch_buffer(inst) if inst.workspace == "branch" && inst.completed?
           auto_apply_subagent_buffer(inst) if inst.completed?
+          retain_result(inst)
           Rubik::Storage::TranscriptIndexer.index(storage_store, inst)
           reap_orphans
           release_ready!
-          # Result is deliberately absent: notices announce, the model retrieves
-          # via manage_subagents wait — the wait protocol stays authoritative.
+          emit_completion_notice(inst)
+        end
+
+        private
+
+        # One terminal outcome per execution (issue #125): an operator kill
+        # already announced the cancellation from the kill path — the settle
+        # notice would be a duplicate. Natural settles announce here, with the
+        # canonical result reference so a truncated preview keeps a working
+        # continuation (result_ref, issue #122).
+        def emit_completion_notice(inst)
+          return if inst.respond_to?(:cancelled_by_operator?) && inst.cancelled_by_operator?
+
           # max_steps rides along so the budget-exhausted guidance can count.
           # storage_id: Vakanüvis kronikçisinin annal/transcript ref anahtarı
           # (plan 2026-10-04) — mevcut aboneler bu anahtarı yok sayar.
-          Notices.emit(@event_bus, Notices::COMPLETED_EVENT, { id: inst.id, role: inst.role, state: inst.state, max_steps: inst.max_steps, storage_id: inst.storage_id })
+          Notices.emit(@event_bus, Notices::COMPLETED_EVENT,
+                       { id: inst.id, role: inst.role, state: inst.state, max_steps: inst.max_steps,
+                         storage_id: inst.storage_id, result_ref: (inst.result_ref if inst.settled?),
+                         transcript_ref: inst.transcript_ref })
         end
 
-        private
+        # The result archive's single write site (issue #122): a settled run
+        # retains its redacted result under its execution-specific reference
+        # (storage id + run sequence) so retrieval never needs a redeploy.
+        # A retention failure degrades to a warning — the durable transcript
+        # remains the fallback, and completion choreography must not stall.
+        def retain_result(inst)
+          return unless inst.settled? && @result_archive
+
+          @result_archive.retain(storage_id: inst.storage_id, id: inst.id, run: inst.run_seq,
+                                 state: inst.state, body: inst.result)
+        rescue StandardError => e
+          Rubik::Log.warn(:orchestrator, "result archive retain failed for #{inst.id}: #{e.class}: #{e.message}")
+        end
 
         # Completion-time spelling of the shared auto-apply policy: the
         # subagents flag OR the buffer.auto_apply mode decides (previously

data/lib/rubik/orchestrator/subagent/context_compaction.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "notices"
+require_relative "../provider_recovery"
+
+module Rubik
+  module Orchestrator
+    module Subagent
+      # The subagent's context-recovery plane, extracted from StepRunner
+      # (module hygiene): routine compaction evaluation, the emergency
+      # compaction actuator, and the bus announcement. One vertical slice —
+      # history pruning and its observable event.
+      module ContextCompaction
+        def evaluate_subagent_context_compaction!
+          return unless @context_limit&.positive?
+
+          context_cfg = ProviderRecovery.compaction_config(@config)
+          needs = Rubik::Prompt::ContextCompactor.needs_compaction?(
+            @history, context_limit: @context_limit, max_output_tokens: @max_output_tokens, config: context_cfg
+          )
+          return unless needs
+
+          compacted = Rubik::Prompt::ContextCompactor.compact_history(
+            @history, context_limit: @context_limit, max_output_tokens: @max_output_tokens, config: context_cfg
+          )
+          before = @history.size
+          @history.replace(compacted)
+          # Journaled BEFORE the next step can prune further (issue #124): the
+          # pre-compaction event sequence stays reconstructible.
+          @journal&.record_compaction(run: @run_seq, layer: "context_compactor", before: before, after: @history.size)
+        end
+
+        # Compaction actuator for the subagent path (mirrors Loop's seam): the
+        # body lives in TurnExecutor#emergency_compact! (one home for both
+        # channels); this delegates and the channel announces on the bus. Never
+        # call it while holding @monitor (the emit stays lock-free).
+        def emergency_compact_and_notify!(reason)
+          turn_executor.emergency_compact!(reason)
+        end
+
+        # The object that owns the fact emits it — outside the monitor, so
+        # subscribers never run under the instance lock.
+        def emit_compacted_event(reason, layer)
+          @journal&.record_compaction(run: @run_seq, layer: layer, reason: reason)
+          Notices.emit(@event_bus, Notices::COMPACTED_EVENT, { id: @id, role: @role, state: @state, reason: reason.to_s, layer: layer })
+        end
+      end
+    end
+  end
+end