rubik 0.1.0

data/lib/rubik/repl/commands.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "commands/base"
+require_relative "commands/system"
+require_relative "commands/buffer"
+require_relative "commands/session"
+require_relative "commands/workspace"
+require_relative "commands/lsp"
+require_relative "commands/agent"
+require_relative "commands/plugins"
+require_relative "commands/mcp"
+require_relative "commands/skills"
+require_relative "commands/tasks"
+require_relative "commands/subagents"
+require_relative "commands/storage"
+require_relative "commands/pruner"
+require_relative "commands/dmesg"
+
+module Rubik
+  module REPL
+    module Commands
+      MODULES = [
+        System,
+        Buffer,
+        Session,
+        Workspace,
+        Lsp,
+        Agent,
+        Plugins,
+        Mcp,
+        Skills,
+        Tasks,
+        Subagents,
+        Storage,
+        Pruner,
+        Dmesg
+      ].freeze
+
+      def self.register_all(shell)
+        MODULES.each { |mod| mod.register(shell) }
+      end
+    end
+  end
+end

data/lib/rubik/repl/composition.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "service_catalog"
+
+module Rubik
+  module REPL
+    # Plan 63 Faz B: pure construction layer extracted from Shell#initialize.
+    # Candidate 05: WHAT gets built, in which order, and with which wiring
+    # facts lives in ServiceCatalog (the single declaration point); this
+    # module only resolves the effective root, seeds the override scope,
+    # folds the catalog and packs the Parts struct. Every part stays
+    # injectable for tests through the Shell's optional parts: kwarg (and
+    # through this module's config/event_bus/buffer_manager/snapshot_store
+    # override kwargs, which adopt their catalog entry verbatim).
+    module Composition
+      Parts = ServiceCatalog.parts_struct
+
+      def self.build(config:, root_dir: nil, event_bus: nil, buffer_manager: nil, snapshot_store: nil, dmesg: nil, dispatcher: nil, init: nil)
+        effective_root = File.expand_path(root_dir || buffer_manager&.root_dir || config&.root_dir || Dir.pwd)
+        scope = ServiceCatalog::Scope.new(
+          root_dir: effective_root,
+          overrides: {
+            config: config, event_bus: event_bus,
+            buffer_manager: buffer_manager, snapshot_store: snapshot_store,
+            dmesg: dmesg, dispatcher: dispatcher, init: init
+          }.compact
+        )
+        Parts.new(**ServiceCatalog.build(scope))
+      end
+    end
+  end
+end

data/lib/rubik/repl/config_wiring.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Rubik
+  module REPL
+    # Wires reactive configuration observers to Shell subsystems.
+    # Returns an array of cleanup procs (inverses) that can be unrolled on shutdown.
+    module ConfigWiring
+      class << self
+        def wire(shell)
+          config = shell.config
+          return [] unless config.respond_to?(:on_change)
+
+          cleanups = []
+
+          cleanups << config.on_change("workspace") do |key, val, _old|
+            wire_workspace_change(shell, key, val)
+          end
+
+          cleanups << config.on_change("context") do |key, val, _old|
+            wire_context_change(shell, key, val)
+          end
+
+          cleanups << config.on_change("lsp") do |key, val, _old|
+            wire_lsp_change(shell, key, val)
+          end
+
+          ["llm", "models", "model", "providers", "router"].each do |prefix|
+            cleanups << config.on_change(prefix) do |_key, _val, _old|
+              wire_llm_change(shell)
+            end
+          end
+
+          cleanups << config.on_change("ui") do |_key, _val, _old|
+            shell.refresh_ui! if shell.respond_to?(:refresh_ui!)
+          end
+
+          cleanups << config.on_change("skills") do |_key, _val, _old|
+            shell.skill_manager&.apply_config!(tool_registry: shell.tool_registry)
+          end
+
+          cleanups << config.on_change("security.command_allowlist") do |_key, val, _old|
+            wire_security_change(shell, val)
+          end
+
+          cleanups << config.on_change("security.allow_safe_probes") do |_key, val, _old|
+            next unless shell.guard.respond_to?(:allow_safe_probes=)
+
+            shell.guard.allow_safe_probes = ([true, "true"].include?(val))
+          end
+
+          # Audit destination is live-reconfigurable too (nil/blank disables,
+          # Guard#audit_log_path= normalizes) — otherwise a mid-session
+          # !config set security.audit_log_path would confirm silently while
+          # events kept flowing to the old path.
+          cleanups << config.on_change("security.audit_log_path") do |_key, val, _old|
+            shell.guard.audit_log_path = val if shell.guard.respond_to?(:audit_log_path=)
+          end
+
+          cleanups << config.on_change("network.allow") do |_key, val, _old|
+            config.set("sandbox.allow_network", val, persist: false) if config.fetch("sandbox.allow_network", nil) != val
+          end
+
+          cleanups << config.on_change("sandbox.allow_network") do |_key, val, _old|
+            config.set("network.allow", val, persist: false) if config.fetch("network.allow", nil) != val
+          end
+
+          cleanups
+        end
+
+        private
+
+        def wire_workspace_change(shell, key, typed_val)
+          case key
+          when "workspace.additional_roots"
+            return unless typed_val.is_a?(Array)
+
+            exp_roots = typed_val.map { |r| File.expand_path(r.to_s, shell.buffer_manager&.root_dir || Dir.pwd) }
+            current_roots = shell.buffer_manager&.additional_roots || []
+            new_roots = exp_roots - current_roots
+            removed_roots = current_roots - exp_roots
+
+            new_roots.each { |r| shell.buffer_manager&.add_root(r) }
+            removed_roots.each { |r| shell.buffer_manager&.remove_root(r) }
+
+            if (new_roots.any? || removed_roots.any?) &&
+               shell.config.fetch("workspace.auto_index_additional", true) && shell.context_index
+              shell.context_index.additional_roots = shell.buffer_manager&.additional_roots
+              shell.context_index.full_scan
+              shell.warm_ast_graph(async: false) if shell.respond_to?(:warm_ast_graph)
+            end
+          when "workspace.allowed_external_dirs"
+            return unless typed_val.is_a?(Array)
+
+            exp_dirs = typed_val.map { |d| File.expand_path(d.to_s, shell.buffer_manager&.root_dir || Dir.pwd) }
+            current_dirs = shell.buffer_manager&.allowed_external_dirs || []
+            new_dirs = exp_dirs - current_dirs
+            removed_dirs = current_dirs - exp_dirs
+
+            new_dirs.each do |d|
+              shell.buffer_manager.add_allowed_dir(d) if shell.buffer_manager.respond_to?(:add_allowed_dir)
+              shell.sandbox_runner&.add_allowed_dir(d)
+            end
+            removed_dirs.each do |d|
+              shell.buffer_manager.remove_allowed_dir(d) if shell.buffer_manager.respond_to?(:remove_allowed_dir)
+              shell.sandbox_runner&.remove_allowed_dir(d)
+            end
+          when "workspace.allow_external_writes"
+            shell.buffer_manager.allow_external_writes = typed_val if shell.buffer_manager.respond_to?(:allow_external_writes=)
+          end
+        end
+
+        def wire_context_change(shell, key, _typed_val)
+          return unless ["context.include", "context.exclude"].include?(key)
+          return unless shell.context_index.respond_to?(:update_file_filters)
+
+          inc = shell.config.fetch("context.include", [])
+          exc = shell.config.fetch("context.exclude", [])
+          shell.context_index.update_file_filters(includes: inc, excludes: exc)
+          shell.warm_ast_graph(async: false) if shell.respond_to?(:warm_ast_graph)
+        end
+
+        def wire_lsp_change(shell, key, typed_val)
+          shell.lsp_manager&.stop_all if key == "lsp.enabled" && typed_val == false
+        end
+
+        # Reactive command-allowlist wiring (Plan: komut-allowlist): config is
+        # the single source of truth; the live Guard is reconfigured in place —
+        # zero restart (Plan 75 pattern).
+        def wire_security_change(shell, typed_val)
+          return unless typed_val.is_a?(Array)
+          return unless shell.guard.respond_to?(:set_allowed_commands)
+
+          shell.guard.set_allowed_commands(typed_val)
+        end
+
+        def wire_llm_change(shell)
+          shell.refresh_llm_registry! if shell.respond_to?(:refresh_llm_registry!)
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/confirmations.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rubik
+  module REPL
+    # Interactive confirmation helpers mixed into Shell so every y/n prompt
+    # (max-steps continue, !plan approval) routes through Reline with one
+    # consistent notion of "interactive". Mixing raw #gets with Reline wedges
+    # the prompt on Windows, so all confirmations live here.
+    module Confirmations
+      # Asks a yes/no question. Non-interactive contexts (tests, piped IO,
+      # test-capture tees) short-circuit to the default answer WITHOUT
+      # reading input. Returns the downcased answer String ("y"/"n"/...) so
+      # call sites keep their %w[y yes evet] handling. Ctrl+C, EOF, or a bare
+      # Enter all select the default answer instead of unwinding the loop.
+      def ask_yes_no(prompt, default: "n")
+        default_answer = default.to_s.downcase
+        return default_answer unless interactive_input?
+
+        # Fast single-key approval on color-capable TTYs (UI::Approvals);
+        # plain terminals keep the classic Reline line prompt.
+        return Rubik::UI::Approvals.keypress_yes_no(self, prompt, default: default_answer, theme: @ui_theme) if @ui_theme&.color?
+
+        hint = default_answer.start_with?("y") ? "[Y/n]" : "[y/N]"
+        answer = @reline.readline("#{prompt} #{hint}: ", false)
+        answer = default_answer if answer.nil? # EOF (Ctrl+D/Ctrl+Z) -> default
+        answer = answer.to_s.strip.downcase
+        answer.empty? ? default_answer : answer
+      rescue Interrupt
+        Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+        @output.puts "^C"
+        default_answer
+      end
+
+      # True only when the Shell is attached to a live interactive console.
+      # A TeeIO wrapping REAL output (production command capture: its StringIO
+      # target makes test_capture? true) still counts as interactive; only
+      # tees whose every target is a StringIO (test harness) do not.
+      def interactive_input?
+        return false if ENV["RUBIK_TEST"] == "1"
+
+        out = @output
+        if out.is_a?(TeeIO)
+          real_targets = out.targets.compact.grep_v(StringIO)
+          return false if real_targets.empty?
+
+          out = real_targets.first
+        end
+        return false if out.is_a?(StringIO)
+        return false if out.respond_to?(:test_capture?) && out.test_capture?
+
+        input = @input || $stdin
+        input.respond_to?(:tty?) && input.tty?
+      end
+    end
+  end
+end

data/lib/rubik/repl/hooks.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Rubik
+  module REPL
+    class Hooks
+      KNOWN_EVENTS = [:file_changed, :test_failed, :before_command, :after_command].freeze
+
+      def initialize(logger: Logger.new($stderr))
+        @hooks = Hash.new { |h, k| h[k] = [] }
+        @logger = logger
+        @mutex = Mutex.new
+      end
+
+      def register(event_name, &block)
+        return unless block_given?
+
+        event_key = event_name.to_sym
+        @mutex.synchronize do
+          @hooks[event_key] << block
+        end
+        block
+      end
+
+      def unregister(event_name, token)
+        return unless token
+
+        event_key = event_name.to_sym
+        @mutex.synchronize do
+          @hooks[event_key].delete(token)
+        end
+        nil
+      end
+
+      def trigger(event_name, *)
+        event_key = event_name.to_sym
+        listeners = @mutex.synchronize { @hooks[event_key].dup }
+        listeners.each do |hook|
+          hook.call(*)
+        rescue StandardError => e
+          @logger.error("Hook error on event '#{event_name}': #{e.message}")
+        end
+      end
+    end
+  end
+end

data/lib/rubik/repl/input_execution.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "tee_io"
+
+module Rubik
+  module REPL
+    # Öneri 3 (Kademe 2): Shell'den ayrılan girdi yürütme ve çıktı yakalama
+    # sorumluluğu. with_output/capture_output I/O geçişini; execute_command
+    # bang-komut dispatch'ini (kayıt, truncation, konuşma geçmişi işleme);
+    # execute_free_text serbest metin turn'inin tam yaşam döngüsünü kodlar
+    # (route → loop kurulum → devam sorusu → araç-geçmişi birleştirme →
+    # kayıt → akış/render → hata/iptal temizliği).
+    # Durum Shell'de yaşar (@output, @recorder, @conversation_history,
+    # @active_loop, ...); bu modül yalnızca yürütme politikasını kodlar.
+    module InputExecution
+      def with_output(new_io)
+        orig = @output
+        @output = new_io
+        @terminal_guard.output = new_io if @terminal_guard
+        yield
+      ensure
+        @output = orig
+        @terminal_guard.output = orig if @terminal_guard
+      end
+
+      def capture_output(&)
+        StringIO.new.tap { |io| with_output(io, &) }.string
+      end
+
+      # Per-dispatch closed view handed to bang-command handlers (see
+      # CommandContext). Cheap by design — holds only the shell reference;
+      # the capture-aware IO is read live off the shell, so it reflects
+      # with_output's swap at call time.
+      def command_context
+        Rubik::REPL::CommandContext.new(self)
+      end
+
+      def execute_command(parsed)
+        # Plan 109 staleness rule: this turn's context already includes the
+        # idle-injected notices in @conversation_history — a surviving
+        # pending wake would turn the next stray Enter into a redundant
+        # notice turn.
+        clear_pending_wake_notices! if respond_to?(:clear_pending_wake_notices!)
+        cmd_name = @plugin_manager ? @plugin_manager.resolve_alias(parsed.command_name) : parsed.command_name.to_s.downcase.delete_prefix("!")
+        cmd_meta = @commands[cmd_name]
+
+        if cmd_meta
+          @hooks.trigger(:before_command, parsed.command_name, parsed.args)
+
+          # Lifecycle cmds + goal (which self-manages its own history turns)
+          untracked_commands = ["quit", "exit", "clear", "reset", "goal"]
+          if untracked_commands.include?(parsed.command_name.downcase)
+            begin
+              cmd_meta[:handler].call(parsed.args, command_context)
+            rescue Interrupt
+              Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+              @output.puts "\n⚠️ [Rubik] Komut kullanıcı tarafından iptal edildi (^C)."
+            end
+          else
+            captured = StringIO.new
+            cmd_interrupted = false
+            with_output(TeeIO.new(@output, captured)) do
+              # Built INSIDE the capture swap so ctx.out is the TeeIO — the
+              # handler's prints reach the recorder and LLM-history truncation.
+              cmd_meta[:handler].call(parsed.args, command_context)
+            rescue Interrupt
+              cmd_interrupted = true
+              Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+              @output.puts "\n⚠️ [Rubik] Komut kullanıcı tarafından iptal edildi (^C)."
+            ensure
+              # A command (!plan/!goal) may leave a live spinner if it died mid-wait.
+              @ui_renderer&.spinner&.kill
+            end
+            output_text = captured.string.strip
+            if !cmd_interrupted && !output_text.empty?
+              clean_raw = Rubik::Security::Redactor.redact(parsed.raw)
+              @recorder&.record_repl_command(clean_raw, output_text)
+              # Plan 61 D-8: bound what a bang command leaves in LLM memory; the recorder keeps the full text.
+              trunc = Rubik::Tools::Truncator.truncate(output_text, max_chars: @config.fetch("tools.max_output_chars", 12_000), strategy: :head_tail)
+              @conversation_history << { role: "user", content: clean_raw.delete_prefix("!") } # bangs stay out of LLM history; recorder keeps the literal
+              @conversation_history << { role: "assistant", content: trunc[:truncated] ? trunc[:text] : output_text }
+              trim_conversation_window!
+            end
+          end
+
+          @hooks.trigger(:after_command, parsed.command_name, parsed.args)
+          reap_dead_kernel_units! if respond_to?(:reap_dead_kernel_units!)
+        else
+          available = @commands.keys.sort.map { |c| "!#{c}" }.join(", ")
+          @output.puts "Bilinmeyen komut: !#{parsed.command_name}. Kullanılabilir komutlar: #{available} (!help'e bakın)."
+        end
+      end
+
+      # Plan 109 Faz B4: marker prefix makes the system-initiated origin
+      # visible in the recorder/session (user decision: honest provenance).
+      NOTICE_TURN_MARKER = "[reactive subagent wake-up]"
+
+      # Plan 109 Faz B4: the autonomous notice-evaluation turn. The queued
+      # notices ALREADY ride @conversation_history as
+      # <subagent_notifications> XML (idle-branch injection); the drained
+      # payload only builds a roster so the model can target ids
+      # immediately — the prompt never duplicates the XML. Reentrancy is
+      # excluded by construction: inside execute_free_text, @active_loop
+      # is set before orchestrator.run, so any event arriving mid-turn
+      # takes the ACTIVE path (loop inbox), never the idle path — no
+      # recursive wake. Wakeloop fix 2026-10-09: the residual idle-path
+      # windows (an event landing before @active_loop is set, or in the
+      # ensure tail after it is cleared) are closed by @autonomous_turn —
+      # route_subagent_notice's idle branch still injects and prints but
+      # does not arm the wake while this flag is up, so an autonomous turn
+      # can never chain into another one.
+      def execute_subagent_notice_turn!
+        notices = drain_pending_wake_notices!
+        return false if notices.empty?
+
+        roster = notices.map { |n| "#{n[:id]}:#{n[:kind]}" }.uniq.join(", ")
+        # Wakeloop fix 2026-10-09: an AUTONOMOUS turn must not spawn another
+        # one. Stranded notices this turn leaves behind still reach history
+        # (no loss), but they do not re-arm the wake — the prompt comes back
+        # and the backlog waits for the user's next Enter.
+        begin
+          @autonomous_turn = true
+          execute_free_text(
+            "#{NOTICE_TURN_MARKER} Background subagent activity arrived while the prompt was idle " \
+            "(#{roster}). Evaluate the <subagent_notifications> blocks in your conversation history: " \
+            "extend the budget of paused-but-promising subagents (manage_subagents action: 'extend_budget'), " \
+            "steer with send_message, retrieve finished results (manage_subagents action: 'wait'), " \
+            "wrap up or kill stale work, or report outcomes to the user. The user did not type this " \
+            "turn — it fired automatically. If nothing needs your attention, finish with a one-line status summary."
+          )
+        ensure
+          @autonomous_turn = false
+        end
+        true
+      end
+
+      def execute_free_text(text)
+        # Wakeloop fix 2026-10-09: ^C settles the wake debt instead of
+        # letting the interrupted turn's own ensure re-arm the cycle. Bound
+        # FIRST: every line between here and the rescue clauses can raise
+        # (recorder file IO, bus emit), and the ensure reads this local —
+        # an unbound read would mask the in-flight exception with a
+        # NameError, breaking the "cleanup must never mask" contract.
+        interrupted = false
+        # Plan 109 staleness rule (see execute_command): a real turn's
+        # context already includes the idle-injected notices. The notice
+        # turn itself drains first, so this clear is a no-op for it.
+        clear_pending_wake_notices! if respond_to?(:clear_pending_wake_notices!)
+        @recorder&.record_user_turn(text)
+        @event_bus.emit(:prompt_received, prompt: text)
+
+        renderer = md_stream = orchestrator = nil
+        routed = resolve_turn_route(text)
+        provider = routed[:provider]
+
+        if provider.nil?
+          spec_str = routed[:spec].is_a?(Hash) ? "#{routed[:spec]['provider']}/#{routed[:spec]['name']}" : routed[:spec].to_s
+          @output.puts "Hata: Model sağlayıcısı başlatılamadı (#{spec_str})."
+          record_failed_turn!(text, "failed", "no LLM provider available (#{spec_str})", nil)
+          return
+        end
+
+        @runtime_manager.provide(:llm_client, provider)
+
+        # Pruner apply seam (context-pruner 2026-10-09): budayıcı bir plan
+        # aşamaladıysa pencereyi turn tohumlanmadan ÖNCE takas et (knob
+        # kapalıysa no-op; !plan'ın execute_free_text devri ve otonom notice
+        # turn'leri buradan geçer).
+        apply_staged_prune_plan!
+
+        max_steps = @config.fetch("agent.max_steps", 40).to_i
+        warn_ratio = @config.fetch("agent.warn_at_ratio", 0.75).to_f
+        theme = self.theme
+        renderer = @ui_renderer || Rubik::UI::Renderer.new(config: @config, max_steps: max_steps, output: @output, theme: theme)
+        md_enabled = @config.fetch("ui.markdown", "live") != "off"
+        md_stream = Rubik::UI::MarkdownStream.new(theme, enabled: md_enabled)
+
+        orchestrator = orchestrator_loop(
+          provider: provider,
+          model: routed[:model],
+          max_steps: max_steps,
+          warn_at_ratio: warn_ratio,
+          context_limit: routed[:context_limit],
+          max_output_tokens: routed[:max_output_tokens],
+          on_step: lambda { |step_info|
+            case step_info[:type]&.to_sym
+            when :chunk
+              renderer.render(step_info) # stops spinner before raw output
+              md_stream.push(step_info[:delta]) { |seg| @output.print seg }
+              @output.flush if @output.respond_to?(:flush)
+            when :chunk_end
+              renderer.render(step_info)
+              md_stream.finish { |seg| @output.print seg }
+              @output.flush if @output.respond_to?(:flush)
+            when :tool_call
+              @recorder&.record_tool_call(step_info[:tool], step_info[:args], call_id: step_info[:call_id])
+              formatted = renderer.render(step_info)
+              @output.puts formatted if formatted && !formatted.empty?
+              @output.flush if @output.respond_to?(:flush)
+            when :tool_result
+              @recorder&.record_tool_result(step_info[:tool], step_info[:output], status: step_info[:status] || :ok, call_id: step_info[:call_id])
+              formatted = renderer.render(step_info)
+              @output.puts formatted if formatted && !formatted.empty?
+              @output.flush if @output.respond_to?(:flush)
+            else
+              formatted = renderer.render(step_info)
+              if formatted && !formatted.empty?
+                @output.puts formatted
+                @output.flush if @output.respond_to?(:flush)
+              end
+            end
+          }
+        )
+        @active_loop = orchestrator
+        res = orchestrator.run(text, conversation_history: @conversation_history)
+
+        while !res[:ok] && res[:error]&.include?("Max steps budget exceeded") && @config.fetch("agent.ask_continue_on_limit", true)
+          @output.puts "\n⚠️ [Rubik::Agent] #{res[:error]}"
+          ans = ask_yes_no(" [Rubik::Agent] +20 adım ile devam edilsin mi?", default: "n")
+          break unless ["y", "yes", "evet"].include?(ans)
+
+          @output.puts " [Rubik::Agent] Adım bütçesi +20 artırılıyor ve görev sürdürülüyor..."
+          res = orchestrator.continue_loop(20)
+
+        end
+
+        # Plan 85 D-7 (kök neden): turn içi @history'deki tool ara adımlarını
+        # conversation_history'ye kopyala — böylece continue'da model turn sırasındaki
+        # bağlamı görür ve "sıfırdan keşfe" başlamaz. res[:loop_instance].history,
+        # turn_result'ın döndürdüğü Loop örneğinin @history'sidir.
+        merge_turn_tool_history!(
+          res[:loop_instance]&.history,
+          max_entries: @config.fetch("context.merge_turn_tool_max_entries", 20).to_i
+        )
+
+        if res[:ok]
+          record_turn_outcome!(text, res[:output].to_s, tokens: res[:tokens], streamed: res[:streamed] == true)
+
+          # Only print the final answer when it was not already streamed
+          # live; batch answers get full markdown rendering on capable TTYs.
+          # res[:streamed] reflects the FINISHING turn (chunks streamed
+          # before a finish tool call count as printed).
+          if res[:streamed] != true && !res[:output].to_s.empty?
+            rendered = Rubik::UI::MarkdownStream.render_document(res[:output], theme, enabled: md_enabled)
+            @output.puts rendered
+          end
+
+          @output.puts "\n[Rubik] In-memory buffer updated. Type `!diff` to view, `!apply` to save." if @buffer_manager.dirty?
+
+          # Kök-turn kroniği (root-turn planı 2026-10-04): başarılı turn da
+          # vakanüvis'e düşer — subagent'siz geçen oturumlar kroniğe girsin.
+          # Bu dalın SON deyimi olmalı: sonrasındaki bir istisna (^C, render
+          # hatası) rescue merdivenine düşüp record_failed_turn! ile İKİNCİ
+          # bir :turn_finished üretmesin — tek turn, tek kronik satırı.
+          emit_turn_finished(kind: "success", prompt: text, outcome: res[:output].to_s,
+                             orchestrator: orchestrator, tokens: res[:tokens])
+        else
+          @output.puts "Görev tamamlanamadı: #{res[:error]}"
+          record_failed_turn!(text, "incomplete", res[:error], orchestrator)
+        end
+      rescue Interrupt
+        interrupted = true
+        # The user cancelled: queued wake debts settle here. Each queued
+        # notice already lives in @conversation_history (idle path injects
+        # at route time), so draining loses nothing the model needed.
+        clear_pending_wake_notices! if respond_to?(:clear_pending_wake_notices!)
+        Rubik::REPL::InterruptHandler.restore_console_after_interrupt
+        # Dedicated event type: restore_session must NOT hydrate this as a
+        # dialogue turn (the user_turn recorded at method entry already
+        # carries the question; a repl_command-style pair would duplicate it).
+        @recorder&.record("cancelled_turn",
+                          "question" => text.to_s.strip[0, 80],
+                          "reason" => "Interrupted by user (^C)")
+        @output.puts "\n⚠️ [Rubik::Agent] Görev kullanıcı tarafından iptal edildi (^C)."
+        record_failed_turn!(text, "cancelled", "Interrupted by user (^C)", orchestrator)
+      rescue Rubik::LLM::ClientError => e
+        # e.message may carry binary bytes (raw HTTP error bodies). Printing
+        # or recording those would raise INSIDE this rescue clause, bypassing
+        # every sibling handler and surfacing as a bare
+        # Encoding::CompatibilityError at the REPL prompt instead of the real
+        # LLM error. Sanitize before use.
+        message = Rubik::Platform.safe_utf8(e.message)
+        @output.puts "[Rubik::LLM Hatası] #{message}"
+        record_failed_turn!(text, "failed", message, orchestrator)
+      rescue StandardError => e
+        message = Rubik::Platform.safe_utf8(e.message)
+        @output.puts "[Hata] #{e.class}: #{message}"
+        record_failed_turn!(text, "failed", "#{e.class}: #{message}", orchestrator)
+      ensure
+        @active_loop = nil
+        # Flush a half-streamed markdown tail so an interrupt never eats the last
+        # line. Cleanup must never mask the in-flight exception (Interrupt, LLM
+        # error): each step reports its own failure to stderr instead of raising.
+        begin
+          md_stream&.finish { |seg| @output.print seg }
+        rescue StandardError => e
+          warn "[rubik] markdown tail flush failed: #{e.class}: #{e.message}"
+        end
+        begin
+          renderer&.spinner&.kill
+        rescue StandardError => e
+          warn "[rubik] spinner cleanup failed: #{e.class}: #{e.message}"
+        end
+        flush_subagent_notices! if respond_to?(:flush_subagent_notices!)
+        # Session review B3: notices stranded in the ended loop's inbox never
+        # reached the model channel and owed no wake — an idle maestro learned
+        # about a budget pause only at the next manual prompt (11 min in the
+        # reported session). Deliver them into history and arm the wake.
+        # Wakeloop fix 2026-10-09: NOT after an interrupt (the user cancelled;
+        # the cycle must not resume) and NOT from an autonomous notice turn
+        # (a synthetic turn must never spawn another — the prompt comes back).
+        if respond_to?(:deliver_stranded_loop_notices!)
+          deliver_stranded_loop_notices!(
+            orchestrator,
+            arm_wake: !interrupted && !@autonomous_turn
+          )
+        end
+        reap_dead_kernel_units! if respond_to?(:reap_dead_kernel_units!)
+      end
+    end
+  end
+end