rubik 0.3.4 → 0.4.0

data/lib/rubik/repl/commands/agent_context.rb

@@ -31,121 +31,143 @@ module Rubik
             sub = args.first&.downcase
             case sub
             when "scan"
-              begin
-                ctx.context_index.full_scan
-                ctx.warm_ast_graph(async: false)
-                ctx.out.puts "Context index and AST symbol graph updated."
-              rescue Errno::EACCES => e
-                root_path = begin
-                  ctx.buffer_manager.root_dir
-                rescue
-                  Dir.pwd
-                end
-                ctx.out.puts Rubik::Tools::DiagnosticReporter.render_permission_denied(root_path, operation: "scan", reason: e.message)
-              rescue StandardError => e
-                ctx.out.puts "Context scan failed: #{e.message}"
-              end
+              handle_context_scan(ctx)
             when "add"
-              file = args[1]
-              if file
-                ctx.context_index.update_file(file)
-                full_path = File.join(ctx.buffer_manager.root_dir, file)
-                ctx.ast_graph.index_file(full_path) if File.exist?(full_path)
-              end
-              ctx.out.puts "Added #{file} to context index and AST graph."
+              handle_context_add(args, ctx)
             when "drop"
-              file = args[1]
-              if file
-                ctx.context_index.files.delete(file)
-                ctx.out.puts "Removed #{file} from context index."
-              else
-                ctx.out.puts "Usage: !context drop <relative_file_path>"
-              end
+              handle_context_drop(args, ctx)
             when "compact"
-              before_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
-              spec = ctx.current_model_spec
-              context_limit = ctx.llm_registry.context_limit_for(spec["provider"], spec["name"])
-              max_output = ctx.llm_registry.max_output_tokens_for(spec["provider"], spec["name"])
-              context_cfg = ctx.config.fetch("context", {})
-
-              ctx.conversation_history = Rubik::Prompt::ContextCompactor.compact_history(
-                ctx.conversation_history,
-                context_limit: context_limit,
-                max_output_tokens: max_output,
-                config: context_cfg,
-                force: true
-              )
-              after_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
-              delta = before_tokens - after_tokens
-              ctx.out.puts "Context compaction completed: #{before_tokens} -> #{after_tokens} tokens (reduced #{delta} tokens)."
+              handle_context_compact(ctx)
             when "stats"
-              spec = ctx.current_model_spec
-              p_name = spec["provider"]
-              m_name = spec["name"]
-              context_limit = ctx.llm_registry.context_limit_for(p_name, m_name)
-              max_output = ctx.llm_registry.max_output_tokens_for(p_name, m_name)
-              ceiling = ctx.llm_registry.effective_input_limit_for(p_name, m_name)
-              est_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
-              pct = ceiling.positive? ? ((est_tokens.to_f / ceiling) * 100).clamp(0.0, 100.0).round(1) : 0.0
-              summary = ctx.context_index.status_summary
-              ast_symbols_count = ctx.ast_graph ? ctx.ast_graph.symbols.size : 0
-
-              ctx.out.puts "=== Context & Token Statistics ==="
-              ctx.out.puts "  • Model            : #{m_name} (#{p_name})"
-              ctx.out.puts "  • Context Limit    : #{context_limit} tokens"
-              ctx.out.puts "  • Usable Capacity  : #{ceiling} tokens (Max Output: #{max_output} tokens)"
-              ctx.out.puts "  • Consumed Tokens  : #{est_tokens} tokens (#{pct}% of usable capacity)"
-              ctx.out.puts "  • Active Turns     : #{ctx.conversation_history.size} turn(s)"
-              ctx.out.puts "  • Indexed Files    : #{summary[:file_count]} files"
-              ctx.out.puts "  • AST Symbol Count : #{ast_symbols_count} symbols"
-              ctx.out.puts "=================================="
-              guidance = Rubik::Tools::DiagnosticReporter.render_context_status_guidance(
-                { model: "#{p_name}/#{m_name}", consumed_tokens: est_tokens, context_limit: ceiling },
-                token_breakdown: { "Conversation Turns" => est_tokens }
-              )
-              ctx.out.puts "\n#{guidance}"
+              handle_context_stats(ctx)
             when "status", nil
-              spec = ctx.current_model_spec
-              p_name = spec["provider"]
-              m_name = spec["name"]
-              context_limit = ctx.llm_registry.context_limit_for(p_name, m_name)
-              max_output = ctx.llm_registry.max_output_tokens_for(p_name, m_name)
-              ceiling = ctx.llm_registry.effective_input_limit_for(p_name, m_name)
-              context_cfg = ctx.config.fetch("context", {})
-              strategy = context_cfg["compaction_strategy"] || "hybrid"
-
-              est_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
-              pct = ceiling.positive? ? ((est_tokens.to_f / ceiling) * 100).clamp(0.0, 100.0).round(1) : 0.0
-              bar_width = 12
-              filled = ((pct / 100.0) * bar_width).round
-              empty = bar_width - filled
-              bar_str = "[#{'█' * filled}#{'░' * empty}] #{pct}%"
-
-              summary = ctx.context_index.status_summary
-              ast_symbols_count = ctx.ast_graph ? ctx.ast_graph.symbols.size : 0
-
-              ctx.out.puts "=== LLM Context Window & In-Memory Status ==="
-              ctx.out.puts "Active Model: #{m_name} (#{p_name})"
-              ctx.out.puts "Context Window Limit: #{context_limit} tokens"
-              ctx.out.puts "Max Output Tokens: #{max_output} tokens"
-              ctx.out.puts "Usable Input Ceiling: #{ceiling} tokens"
-              ctx.out.puts "Estimated Prompt Tokens: #{est_tokens} / #{ceiling} tokens #{bar_str}"
-              ctx.out.puts "Compaction Strategy: #{strategy}"
-              ctx.out.puts "Indexed Files: #{summary[:file_count]}, AST Symbols: #{ast_symbols_count}"
-              ctx.out.puts "============================================="
-              if (args && (args.include?("--guidance") || args.include?("-g"))) || est_tokens > (ceiling * 0.8)
-                guidance = Rubik::Tools::DiagnosticReporter.render_context_status_guidance(
-                  { model: "#{p_name}/#{m_name}", consumed_tokens: est_tokens, context_limit: ceiling },
-                  token_breakdown: { "Conversation History" => est_tokens }
-                )
-                ctx.out.puts "\n#{guidance}"
-              end
+              handle_context_status(args, ctx)
             else
               ctx.out.puts USAGE_CONTEXT
             end
           end
         end
 
+        private_class_method def self.handle_context_scan(ctx)
+          ctx.context_index.full_scan
+          ctx.warm_ast_graph(async: false)
+          ctx.out.puts "Context index and AST symbol graph updated."
+        rescue Errno::EACCES => e
+          root_path = begin
+            ctx.buffer_manager.root_dir
+          rescue
+            Dir.pwd
+          end
+          ctx.out.puts Rubik::Tools::DiagnosticReporter.render_permission_denied(root_path, operation: "scan", reason: e.message)
+        rescue StandardError => e
+          ctx.out.puts "Context scan failed: #{e.message}"
+        end
+
+        private_class_method def self.handle_context_add(args, ctx)
+          file = args[1]
+          if file
+            ctx.context_index.update_file(file)
+            full_path = File.join(ctx.buffer_manager.root_dir, file)
+            ctx.ast_graph.index_file(full_path) if File.exist?(full_path)
+          end
+          ctx.out.puts "Added #{file} to context index and AST graph."
+        end
+
+        private_class_method def self.handle_context_drop(args, ctx)
+          file = args[1]
+          if file
+            ctx.context_index.files.delete(file)
+            ctx.out.puts "Removed #{file} from context index."
+          else
+            ctx.out.puts "Usage: !context drop <relative_file_path>"
+          end
+        end
+
+        private_class_method def self.handle_context_compact(ctx)
+          before_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
+          spec = ctx.current_model_spec
+          context_limit = ctx.llm_registry.context_limit_for(spec["provider"], spec["name"])
+          max_output = ctx.llm_registry.max_output_tokens_for(spec["provider"], spec["name"])
+          context_cfg = ctx.config.fetch("context", {})
+
+          ctx.conversation_history = Rubik::Prompt::ContextCompactor.compact_history(
+            ctx.conversation_history,
+            context_limit: context_limit,
+            max_output_tokens: max_output,
+            config: context_cfg,
+            force: true
+          )
+          after_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
+          delta = before_tokens - after_tokens
+          ctx.out.puts "Context compaction completed: #{before_tokens} -> #{after_tokens} tokens (reduced #{delta} tokens)."
+        end
+
+        private_class_method def self.handle_context_stats(ctx)
+          spec = ctx.current_model_spec
+          p_name = spec["provider"]
+          m_name = spec["name"]
+          context_limit = ctx.llm_registry.context_limit_for(p_name, m_name)
+          max_output = ctx.llm_registry.max_output_tokens_for(p_name, m_name)
+          ceiling = ctx.llm_registry.effective_input_limit_for(p_name, m_name)
+          est_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
+          pct = ceiling.positive? ? ((est_tokens.to_f / ceiling) * 100).clamp(0.0, 100.0).round(1) : 0.0
+          summary = ctx.context_index.status_summary
+          ast_symbols_count = ctx.ast_graph ? ctx.ast_graph.symbols.size : 0
+
+          ctx.out.puts "=== Context & Token Statistics ==="
+          ctx.out.puts "  • Model            : #{m_name} (#{p_name})"
+          ctx.out.puts "  • Context Limit    : #{context_limit} tokens"
+          ctx.out.puts "  • Usable Capacity  : #{ceiling} tokens (Max Output: #{max_output} tokens)"
+          ctx.out.puts "  • Consumed Tokens  : #{est_tokens} tokens (#{pct}% of usable capacity)"
+          ctx.out.puts "  • Active Turns     : #{ctx.conversation_history.size} turn(s)"
+          ctx.out.puts "  • Indexed Files    : #{summary[:file_count]} files"
+          ctx.out.puts "  • AST Symbol Count : #{ast_symbols_count} symbols"
+          ctx.out.puts "=================================="
+          guidance = Rubik::Tools::DiagnosticReporter.render_context_status_guidance(
+            { model: "#{p_name}/#{m_name}", consumed_tokens: est_tokens, context_limit: ceiling },
+            token_breakdown: { "Conversation Turns" => est_tokens }
+          )
+          ctx.out.puts "\n#{guidance}"
+        end
+
+        private_class_method def self.handle_context_status(args, ctx)
+          spec = ctx.current_model_spec
+          p_name = spec["provider"]
+          m_name = spec["name"]
+          context_limit = ctx.llm_registry.context_limit_for(p_name, m_name)
+          max_output = ctx.llm_registry.max_output_tokens_for(p_name, m_name)
+          ceiling = ctx.llm_registry.effective_input_limit_for(p_name, m_name)
+          context_cfg = ctx.config.fetch("context", {})
+          strategy = context_cfg["compaction_strategy"] || "hybrid"
+
+          est_tokens = Rubik::Prompt::TokenEstimator.estimate_history(ctx.conversation_history)
+          pct = ceiling.positive? ? ((est_tokens.to_f / ceiling) * 100).clamp(0.0, 100.0).round(1) : 0.0
+          bar_width = 12
+          filled = ((pct / 100.0) * bar_width).round
+          empty = bar_width - filled
+          bar_str = "[#{'█' * filled}#{'░' * empty}] #{pct}%"
+
+          summary = ctx.context_index.status_summary
+          ast_symbols_count = ctx.ast_graph ? ctx.ast_graph.symbols.size : 0
+
+          ctx.out.puts "=== LLM Context Window & In-Memory Status ==="
+          ctx.out.puts "Active Model: #{m_name} (#{p_name})"
+          ctx.out.puts "Context Window Limit: #{context_limit} tokens"
+          ctx.out.puts "Max Output Tokens: #{max_output} tokens"
+          ctx.out.puts "Usable Input Ceiling: #{ceiling} tokens"
+          ctx.out.puts "Estimated Prompt Tokens: #{est_tokens} / #{ceiling} tokens #{bar_str}"
+          ctx.out.puts "Compaction Strategy: #{strategy}"
+          ctx.out.puts "Indexed Files: #{summary[:file_count]}, AST Symbols: #{ast_symbols_count}"
+          ctx.out.puts "============================================="
+          return unless (args && (args.include?("--guidance") || args.include?("-g"))) || est_tokens > (ceiling * 0.8)
+
+          guidance = Rubik::Tools::DiagnosticReporter.render_context_status_guidance(
+            { model: "#{p_name}/#{m_name}", consumed_tokens: est_tokens, context_limit: ceiling },
+            token_breakdown: { "Conversation History" => est_tokens }
+          )
+          ctx.out.puts "\n#{guidance}"
+        end
+
         private_class_method def self.register_steps_command(shell)
           shell.register_command("steps", description: "Manage or view agentic step budget (default|goal|plan|<n>|status)",
                                           usage: USAGE_STEPS, audience: :both) do |args, ctx|

data/lib/rubik/repl/commands/agent_execution.rb

@@ -208,75 +208,16 @@ module Rubik
         # çıktısını bayt-baytına korur.
         private_class_method def self.drive_goal_turn(ctx, orchestrator:, goal_state:, goal_ledger:,
                                                       goal_text:, goal_id:, record_pair:, start:)
-          finalize_ledger = lambda do |status|
-            next unless goal_ledger
-
-            goal_ledger.finalize!(status)
-            goal_state.ledger_id = goal_ledger.snapshot[:storage_id]
-          end
-
-          fail_goal = lambda do |reason, tokens: nil, steps: nil|
-            sanitized = Rubik::Platform.safe_utf8(reason.to_s)
-            steps_used = steps || goal_state.step_count
-            goal_state.fail!(sanitized, tokens: tokens)
-            finalize_ledger.call(:failed)
-            forget_suspended_goal(ctx, goal_id)
-            ctx.out.puts "\n❌ Goal could not be completed: #{sanitized}"
-            record_pair.call("[Goal attempt ended after #{steps_used} steps: #{sanitized}]", tokens: tokens)
-          end
-
-          suspend_goal = lambda do |reason, tokens: nil|
-            attempt = suspended_attempt(ctx, goal_id) + 1
-            goal_state.suspend!(reason, tokens: tokens)
-            goal_ledger&.suspend!(suspend_stamp_meta(goal_state, goal_id, reason, attempt))
-            registry = goal_registry_for(ctx)
-            registry.register(Rubik::Orchestrator::GoalRegistry::Entry.new(
-                                goal_id: goal_id, goal_text: goal_text, loop: orchestrator,
-                                goal_state: goal_state, ledger: goal_ledger, reason: reason.to_s,
-                                suspended_at: Time.now, attempt: attempt
-                              ))
-            ctx.out.puts "\n⏸️ [Rubik::Goal] Suspended after #{goal_state.step_count} steps (transient provider error): #{reason}"
-            ctx.out.puts "   Loop, counters and Σ ledger are preserved — resume with `!goal resume`."
-            record_pair.call("[Goal suspended after #{goal_state.step_count} steps: #{reason}]", tokens: tokens)
-          end
-
           ctx.active_loop = orchestrator
           begin
             res = start.call(orchestrator)
-
-            # Bütçe tükenince sor (execute_free_text simetrisi; aynı knob,
-            # aynı +20). continue_loop boyunca active_loop DOLU kalmalı:
-            # notice yönlendirmesi aktif döngüye bakar (lifecycle.rb
-            # route_subagent_notice) — soruya beklerken gelen subagent
-            # olayları loop inbox'a girer ve devam adımında boşaltılır.
-            auto_extensions = 0
-            max_auto = ctx.config.fetch("agent.goal_auto_continue_limit", 0).to_i
-            while !res[:ok] && res[:error]&.include?("Max steps budget exceeded")
-              if auto_extensions < max_auto
-                auto_extensions += 1
-                ctx.out.puts "\n🤖 [Rubik::Goal] Adım bütçesi doldu (#{res[:error]}). " \
-                             "Otonom devam hakkı (#{auto_extensions}/#{max_auto}) kullanılarak +20 adım ekleniyor..."
-                goal_state.extend!(goal_state.max_steps + 20)
-                res = orchestrator.continue_loop(20, auto: true)
-                next
-              end
-
-              break unless ctx.config.fetch("agent.ask_continue_on_limit", true)
-
-              ctx.out.puts "\n⚠️ [Rubik::Goal] #{res[:error]}"
-              ans = ctx.ask_yes_no(" [Rubik::Goal] +20 adım ile devam edilsin mi?", default: "n")
-              break unless ["y", "yes", "evet"].include?(ans)
-
-              ctx.out.puts " [Rubik::Goal] Adım bütçesi +20 artırılıyor ve hedef sürdürülüyor..."
-              goal_state.extend!(goal_state.max_steps + 20)
-              res = orchestrator.continue_loop(20)
-            end
+            res = handle_goal_budget_extensions(ctx, orchestrator: orchestrator, goal_state: goal_state, res: res)
           rescue Interrupt
             # ^C hedefi 'running' bırakmasın; eşlenmiş kayıt otursun. Interrupt
             # yeniden yükselir — kullanıcı mesajını execute_command basar.
             # Resume üstüne ^C = askıyı terk (terminal :stopped damgası).
             goal_state.stop!("Interrupted by user (^C)")
-            finalize_ledger.call(:stopped)
+            finalize_goal_ledger(goal_ledger, goal_state, :stopped)
             forget_suspended_goal(ctx, goal_id)
             record_pair.call("[Goal attempt interrupted after #{goal_state.step_count} steps]")
             raise
@@ -289,18 +230,92 @@ module Rubik
             # next yerine return: rescue sonrası res'siz terminal
             # eşlemesine düşülmesin.
             if e.respond_to?(:transient?) && e.transient?
-              suspend_goal.call(e.message)
+              suspend_goal_turn(ctx, orchestrator: orchestrator, goal_state: goal_state, goal_ledger: goal_ledger,
+                                     goal_text: goal_text, goal_id: goal_id, record_pair: record_pair, reason: e.message)
             else
-              fail_goal.call(e.message)
+              fail_goal_turn(ctx, goal_state: goal_state, goal_ledger: goal_ledger, goal_id: goal_id,
+                                  record_pair: record_pair, reason: e.message)
             end
             return
           rescue StandardError => e
-            fail_goal.call("#{e.class}: #{e.message}")
+            fail_goal_turn(ctx, goal_state: goal_state, goal_ledger: goal_ledger, goal_id: goal_id,
+                                record_pair: record_pair, reason: "#{e.class}: #{e.message}")
             return
           ensure
             ctx.active_loop = nil
           end
 
+          handle_goal_completion(ctx, res: res, goal_state: goal_state, goal_ledger: goal_ledger,
+                                      goal_id: goal_id, record_pair: record_pair)
+        end
+
+        private_class_method def self.finalize_goal_ledger(goal_ledger, goal_state, status)
+          return unless goal_ledger
+
+          goal_ledger.finalize!(status)
+          goal_state.ledger_id = goal_ledger.snapshot[:storage_id]
+        end
+
+        private_class_method def self.fail_goal_turn(ctx, goal_state:, goal_ledger:, goal_id:, record_pair:,
+                                                     reason:, tokens: nil, steps: nil)
+          sanitized = Rubik::Platform.safe_utf8(reason.to_s)
+          steps_used = steps || goal_state.step_count
+          goal_state.fail!(sanitized, tokens: tokens)
+          finalize_goal_ledger(goal_ledger, goal_state, :failed)
+          forget_suspended_goal(ctx, goal_id)
+          ctx.out.puts "\n❌ Goal could not be completed: #{sanitized}"
+          record_pair.call("[Goal attempt ended after #{steps_used} steps: #{sanitized}]", tokens: tokens)
+        end
+
+        private_class_method def self.suspend_goal_turn(ctx, orchestrator:, goal_state:, goal_ledger:,
+                                                        goal_text:, goal_id:, record_pair:, reason:, tokens: nil)
+          attempt = suspended_attempt(ctx, goal_id) + 1
+          goal_state.suspend!(reason, tokens: tokens)
+          goal_ledger&.suspend!(suspend_stamp_meta(goal_state, goal_id, reason, attempt))
+          registry = goal_registry_for(ctx)
+          registry.register(Rubik::Orchestrator::GoalRegistry::Entry.new(
+                              goal_id: goal_id, goal_text: goal_text, loop: orchestrator,
+                              goal_state: goal_state, ledger: goal_ledger, reason: reason.to_s,
+                              suspended_at: Time.now, attempt: attempt
+                            ))
+          ctx.out.puts "\n⏸️ [Rubik::Goal] Suspended after #{goal_state.step_count} steps (transient provider error): #{reason}"
+          ctx.out.puts "   Loop, counters and Σ ledger are preserved — resume with `!goal resume`."
+          record_pair.call("[Goal suspended after #{goal_state.step_count} steps: #{reason}]", tokens: tokens)
+        end
+
+        private_class_method def self.handle_goal_budget_extensions(ctx, orchestrator:, goal_state:, res:)
+          # Bütçe tükenince sor (execute_free_text simetrisi; aynı knob,
+          # aynı +20). continue_loop boyunca active_loop DOLU kalmalı:
+          # notice yönlendirmesi aktif döngüye bakar (lifecycle.rb
+          # route_subagent_notice) — soruya beklerken gelen subagent
+          # olayları loop inbox'a girer ve devam adımında boşaltılır.
+          auto_extensions = 0
+          max_auto = ctx.config.fetch("agent.goal_auto_continue_limit", 0).to_i
+          while !res[:ok] && res[:error]&.include?("Max steps budget exceeded")
+            if auto_extensions < max_auto
+              auto_extensions += 1
+              ctx.out.puts "\n🤖 [Rubik::Goal] Adım bütçesi doldu (#{res[:error]}). " \
+                           "Otonom devam hakkı (#{auto_extensions}/#{max_auto}) kullanılarak +20 adım ekleniyor..."
+              goal_state.extend!(goal_state.max_steps + 20)
+              res = orchestrator.continue_loop(20, auto: true)
+              next
+            end
+
+            break unless ctx.config.fetch("agent.ask_continue_on_limit", true)
+
+            ctx.out.puts "\n⚠️ [Rubik::Goal] #{res[:error]}"
+            ans = ctx.ask_yes_no(" [Rubik::Goal] +20 adım ile devam edilsin mi?", default: "n")
+            break unless ["y", "yes", "evet"].include?(ans)
+
+            ctx.out.puts " [Rubik::Goal] Adım bütçesi +20 artırılıyor ve hedef sürdürülüyor..."
+            goal_state.extend!(goal_state.max_steps + 20)
+            res = orchestrator.continue_loop(20)
+          end
+          res
+        end
+
+        private_class_method def self.handle_goal_completion(ctx, res:, goal_state:, goal_ledger:,
+                                                             goal_id:, record_pair:)
           if res[:ok]
             active = goal_active_subagent_count(ctx)
             if active.positive?
@@ -310,12 +325,12 @@ module Rubik
               # "Goal Achieved" (field incident 2026-10-05).
               reason = "Goal loop concluded with #{active} active subagent(s) still running — not marked complete"
               goal_state.stop!(reason)
-              finalize_ledger.call(:stopped)
+              finalize_goal_ledger(goal_ledger, goal_state, :stopped)
               ctx.out.puts "\n⚠️ [Rubik::Goal] #{reason}."
               record_pair.call("[Goal attempt ended after #{goal_state.step_count} steps: #{reason}]", tokens: res[:tokens])
             else
               goal_state.complete!(res[:output].to_s, tokens: res[:tokens])
-              finalize_ledger.call(:completed)
+              finalize_goal_ledger(goal_ledger, goal_state, :completed)
               forget_suspended_goal(ctx, goal_id)
               ctx.out.puts "\n🎉 Goal Achieved in #{res[:steps]} steps!"
               ctx.out.puts res[:output]
@@ -329,10 +344,10 @@ module Rubik
             # Başarısızlık eşlemesi yukarıdaki tek hata kanalından akar:
             # GoalState → ledger finalize → kayıtçı çifti, istisna yoluyla
             # aynı sırayla.
-            fail_goal.call(res[:error], tokens: res[:tokens], steps: res[:steps])
+            fail_goal_turn(ctx, goal_state: goal_state, goal_ledger: goal_ledger, goal_id: goal_id,
+                                record_pair: record_pair, reason: res[:error], tokens: res[:tokens], steps: res[:steps])
           end
         end
-
         # ------------------------------------------------------------------
         # !goal resume (issue #106). İki yol, dönüşüm sırasına göre:
         #   1) Oturum kaydında canlı girdi varsa süreç-içi resume — hayatta