rubik 0.1.0

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

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../runtime"
+require_relative "../../sandbox"
+require_relative "../../orchestrator/auto_apply"
+
+module Rubik
+  module REPL
+    module Commands
+      module AgentExecution
+        extend Base
+
+        # Whole-command synopses: shared by the spine registration (usage:)
+        # and the empty-args branches that print them, so the two cannot drift.
+        USAGE_PLAN = "Kullanım: !plan <görev açıklaması>"
+        USAGE_GOAL = "Kullanım: !goal <hedef açıklaması>"
+
+        def self.register(shell)
+          register_plan_command(shell)
+          register_goal_command(shell)
+          register_test_command(shell)
+          register_lint_command(shell)
+          register_format_command(shell)
+          register_sh_command(shell)
+          register_sandbox_command(shell)
+        end
+
+        private_class_method def self.register_plan_command(shell)
+          shell.register_command("plan", description: "Formulate step-by-step plan for a task and ask for confirmation",
+                                         usage: USAGE_PLAN) do |args, ctx|
+            task = args.join(" ").strip
+            if task.empty?
+              ctx.out.puts USAGE_PLAN
+              next
+            end
+
+            plan_steps = ctx.config.fetch("agent.plan_max_steps", 15).to_i
+            routed = ctx.router.route(task_type: :plan, prompt: task)
+            ctx.runtime_manager.provide(:llm_client, routed[:provider]) if routed[:provider]
+            orchestrator = ctx.orchestrator_loop(
+              provider: routed[:provider],
+              model: routed[:model],
+              max_steps: plan_steps,
+              context_limit: routed[:context_limit],
+              max_output_tokens: routed[:max_output_tokens],
+              on_step: ->(step_info) { ctx.render_step_event(step_info) }
+            )
+
+            ctx.out.puts "[Rubik::Plan] Generating plan using #{routed[:role]} model (#{routed[:model]})..."
+            res = orchestrator.run(task, plan_only: true)
+
+            if res[:ok]
+              ctx.out.puts "\n=== Proposed Plan ==="
+              ctx.out.puts res[:output]
+              ctx.out.puts "=====================\n"
+              ans = ctx.ask_yes_no("[Rubik::Plan] Plan uygulansın mı?", default: "y")
+              if ["y", "yes", "evet"].include?(ans)
+                ctx.out.puts "[Rubik::Act] Executing approved plan..."
+                ctx.execute_free_text("Execute the following approved plan step by step:\n#{res[:output]}")
+              else
+                ctx.out.puts "[Rubik] Plan iptal edildi."
+              end
+            else
+              ctx.out.puts "Plan üretilemedi: #{res[:error]}"
+            end
+          end
+        end
+
+        private_class_method def self.register_goal_command(shell)
+          shell.register_command("goal", description: "Run long-running autonomous goal loop (the maestro supervises a subagent pipeline) until all tests pass",
+                                         usage: USAGE_GOAL) do |args, ctx|
+            goal_text = args.join(" ").strip
+            if goal_text.empty?
+              ctx.out.puts USAGE_GOAL
+              next
+            end
+
+            ctx.recorder&.record_user_turn("!goal #{goal_text}")
+            goal_steps = ctx.config.fetch("agent.goal_max_steps", 100).to_i
+            warn_ratio = ctx.config.fetch("agent.warn_at_ratio", 0.75).to_f
+            routed = ctx.router.route(task_type: :goal, prompt: goal_text)
+            ctx.runtime_manager.provide(:llm_client, routed[:provider]) if routed[:provider]
+
+            # Canlı hedef durumu: maestro ve alt ajanlar read_file
+            # rubik://goal/state ile aynı anlık görüntüyü okur. Provide swap
+            # semantiğine sahiptir — tekrarlanan !goal koşuları Ω'ya inverse
+            # yığmaz; session dispose'u tek delete-inverse ile temizler.
+            # event_bus: bitiş olayı (GoalState::FINISH_EVENT) Vakanüvis
+            # kronikçisinin goal kancasına akar (K3) — notice/wake yok.
+            goal_state = Rubik::Orchestrator::GoalState.new(event_bus: ctx.event_bus)
+            goal_state.start!(goal_text, goal_steps)
+            ctx.runtime_manager.provide(Rubik::Coeffects::GOAL_STATE, goal_state)
+
+            # Yapılandırılmış Σ defteri (goal-ledger planı A): knob ON iken
+            # koşuyla doğar, terminal dallarda finalize olur, provide swap
+            # semantiğiyle tekrarlanan !goal koşuları Ω'ya inverse yığmaz.
+            # OFF iken hiçbir yüz kurulmaz (araç/URI/prompt bayt-özdeş).
+            goal_ledger = nil
+            if Rubik::Orchestrator::GoalLedger::Ledger.enabled?(ctx.config)
+              store = Rubik::Coeffects.get(ctx.runtime_manager&.context, Rubik::Coeffects::STORAGE_STORE)
+              dmesg = Rubik::Coeffects.get(ctx.runtime_manager&.context, Rubik::Coeffects::DMESG)
+              goal_ledger = Rubik::Orchestrator::GoalLedger::Ledger.create!(
+                goal_text: goal_text, config: ctx.config, store: store, dmesg: dmesg,
+                event_bus: ctx.event_bus
+              )
+              ctx.runtime_manager.provide(Rubik::Coeffects::GOAL_LEDGER, goal_ledger)
+            end
+            finalize_ledger = lambda do |status|
+              next unless goal_ledger
+
+              goal_ledger.finalize!(status)
+              goal_state.ledger_id = goal_ledger.snapshot[:storage_id]
+            end
+
+            ctx.out.puts "[Rubik::Goal] Starting autonomous goal loop (Budget: #{goal_steps} steps) with #{routed[:role]} model (#{routed[:model]})..."
+            ctx.out.puts "[Rubik::Goal] Target: #{goal_text}\n"
+
+            orchestrator = ctx.orchestrator_loop(
+              provider: routed[:provider],
+              model: routed[:model],
+              max_steps: goal_steps,
+              warn_at_ratio: warn_ratio,
+              context_limit: routed[:context_limit],
+              max_output_tokens: routed[:max_output_tokens],
+              on_step: lambda { |step_info|
+                # Adım sayacı rubik://goal/state'e aksın: olaylar bir adım
+                # içinde tekrarlanabilir, GoalState monotoniktir (zararsız).
+                goal_state.update_steps(step_info[:step], step_info[:max_steps]) if step_info[:step].is_a?(Integer)
+                ctx.render_step_event(step_info)
+              }
+            )
+
+            # Plan 53 D-8 yardımcısı: nötr çift + kayıtçı eşlemesi tek yerde.
+            # Session restore kayıtçı OLAYLARINDAN hidrate eder — eşlenmiş
+            # restore için conversation_history VE record_assistant_response
+            # birlikte yazılmalı (başarısızlıkta da).
+            record_goal_pair = lambda do |assistant_content, streamed: nil, tokens: nil|
+              ctx.conversation_history << { role: "user", content: "Goal: #{goal_text}" }
+              ctx.conversation_history << { role: "assistant", content: assistant_content }
+              ctx.recorder&.record_assistant_response(assistant_content, tokens: tokens, streamed: streamed)
+              ctx.trim_conversation_window!
+            end
+
+            # Pruner apply seam: hedef döngüsü de aynı sınırda tohumlanır —
+            # aşamalı plan varsa goal promptundan ÖNCE uygulanır.
+            ctx.apply_staged_prune_plan!
+            ctx.active_loop = orchestrator
+            begin
+              res = orchestrator.run(goal_text, goal_mode: true, conversation_history: ctx.conversation_history)
+
+              # 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.
+              while !res[:ok] && res[:error]&.include?("Max steps budget exceeded") && 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
+            rescue Interrupt
+              # ^C hedefi 'running' bırakmasın; eşlenmiş kayıt otursun. Interrupt
+              # yeniden yükselir — kullanıcı mesajını execute_command basar.
+              goal_state.stop!("Interrupted by user (^C)")
+              finalize_ledger.call(:stopped)
+              record_goal_pair.call("[Goal attempt interrupted after #{goal_state.step_count} steps]")
+              raise
+            ensure
+              ctx.active_loop = nil
+            end
+            if res[:ok]
+              active = goal_active_subagent_count(ctx)
+              if active.positive?
+                # Defense behind the loop-level goal guard (GoalWait): a
+                # success terminal escaping with live subagents means the
+                # pipeline is mid-flight — an honest stop beats a false
+                # "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)
+                ctx.out.puts "\n⚠️ [Rubik::Goal] #{reason}."
+                record_goal_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)
+                ctx.out.puts "\n🎉 Goal Achieved in #{res[:steps]} steps!"
+                ctx.out.puts res[:output]
+                # Keep the bang syntax out of the LLM context (Plan 53 D-8): the
+                # session recorder already stores the literal "!goal ..." for replay.
+                record_goal_pair.call(res[:output].to_s, streamed: res[:streamed] == true, tokens: res[:tokens])
+
+                ctx.out.puts "\nTip: Use `!diff` to review changes and `!apply` to commit to disk." if ctx.buffer_manager.dirty?
+              end
+            else
+              # Başarısızlık eşlemesi: kayıtçı '!goal ...' user_turn'unu komut
+              # girişinde çoktan yazdı — assistant_response olmadan session
+              # restore EŞLEŞMEMİŞ bir 'Goal: ...' turu hidrate ederdi.
+              # Adım sayısı: loop'un truncation hatası :steps'siz döner —
+              # GoalState monotonik sayacı otoriter yedek.
+              sanitized = Rubik::Platform.safe_utf8(res[:error].to_s)
+              steps_used = res[:steps] || goal_state.step_count
+              goal_state.fail!(sanitized, tokens: res[:tokens])
+              finalize_ledger.call(:failed)
+              ctx.out.puts "\n❌ Goal could not be completed: #{sanitized}"
+              record_goal_pair.call("[Goal attempt ended after #{steps_used} steps: #{sanitized}]", tokens: res[:tokens])
+            end
+          end
+        end
+
+        # Defense-in-depth behind the loop-level goal guard: if a success
+        # terminal escapes GoalWait with live subagent units, the goal must
+        # stop honestly instead of celebrating a false completion. Fails
+        # CONSERVATIVE: coeffect absence is nil-safe (Coeffects.get never
+        # raises for a missing subsystem), so a raise here is real breakage
+        # — reporting zero would launder it into exactly the false
+        # "Goal Achieved" this backstop exists to refuse.
+        private_class_method def self.goal_active_subagent_count(ctx)
+          supervisor = Rubik::Coeffects.get(ctx.runtime_manager&.context, Rubik::Coeffects::SUBAGENT_SUPERVISOR)
+          supervisor&.active_count.to_i
+        rescue StandardError => e
+          Rubik::Log.warn(:orchestrator, "goal completion defense could not inspect subagents " \
+                                         "(#{e.class}: #{e.message}); refusing completion")
+          1
+        end
+
+        private_class_method def self.register_test_command(shell)
+          shell.register_command("test", description: "Run test suite via active language adapter") do |args, ctx|
+            if ctx.buffer_manager&.dirty?
+              if Rubik::Orchestrator::AutoApply.apply?(ctx.config, trigger: :pre_execution)
+                applied = Rubik::Orchestrator::AutoApply.apply_and_sync(ctx.buffer_manager, ctx)
+                ctx.out.puts Rubik::Orchestrator::AutoApply.applied_line(applied.size, "test run")
+              else
+                ctx.out.puts Rubik::Orchestrator::AutoApply.unapplied_warning("Tests")
+              end
+            end
+            lang = args.first || Rubik::Runtime::Discovery.detect_primary_language(Dir.pwd) || "ruby"
+            adapter = ctx.adapter_registry.get(lang) || ctx.adapter_registry.get("ruby")
+            res = adapter.run_tests(Dir.pwd)
+            ctx.out.puts res[:output]
+            if !res[:ok] && res[:diagnostic]
+              ctx.out.puts "\n🔍 [Diagnostic] #{res[:diagnostic].category.to_s.upcase}: #{res[:diagnostic].suggestion}"
+              ctx.out.puts "Tip: Use `repair_runtime_service` (or `fix_service`) to adapt test runners dynamically."
+            end
+          end
+        end
+
+        private_class_method def self.register_lint_command(shell)
+          shell.register_command("lint", description: "Run linter/syntax check", audience: :both) do |args, ctx|
+            target = args.first || "lib/rubik.rb"
+            lang = Rubik::Runtime::Discovery.detect_primary_language(Dir.pwd) || "ruby"
+            adapter = ctx.adapter_registry.get(lang) || ctx.adapter_registry.get("ruby")
+            res = adapter.check_syntax(target)
+            ctx.out.puts res[:output]
+            ctx.out.puts "\n🔍 [Diagnostic] #{res[:diagnostic].category.to_s.upcase}: #{res[:diagnostic].suggestion}" if !res[:ok] && res[:diagnostic]
+          end
+        end
+
+        private_class_method def self.register_format_command(shell)
+          shell.register_command("format", description: "Format target file", audience: :both) do |args, ctx|
+            target = args.first
+            if target
+              lang = Rubik::Runtime::Discovery.detect_primary_language(Dir.pwd) || "ruby"
+              adapter = ctx.adapter_registry.get(lang) || ctx.adapter_registry.get("ruby")
+              res = adapter.format_code(target)
+              ctx.out.puts res[:output]
+              ctx.out.puts "\n🔍 [Diagnostic] #{res[:diagnostic].category.to_s.upcase}: #{res[:diagnostic].suggestion}" if !res[:ok] && res[:diagnostic]
+            end
+          end
+        end
+
+        private_class_method def self.register_sh_command(shell)
+          shell.register_command("sh", description: "Execute shell command via sandbox runner") do |args, ctx|
+            if ctx.buffer_manager&.dirty?
+              if Rubik::Orchestrator::AutoApply.apply?(ctx.config, trigger: :pre_execution)
+                applied = Rubik::Orchestrator::AutoApply.apply_and_sync(ctx.buffer_manager, ctx)
+                ctx.out.puts Rubik::Orchestrator::AutoApply.applied_line(applied.size, "command execution")
+              else
+                ctx.out.puts Rubik::Orchestrator::AutoApply.unapplied_warning("Commands")
+              end
+            end
+
+            cmd = args.join(" ")
+            ctx.guard.verify_command_safety!(cmd)
+            runner = ctx.sandbox_runner || Rubik::Sandbox::Runner.new(root_dir: Dir.pwd, config: ctx.config, guard: ctx.guard)
+            res = runner.run(cmd)
+            ctx.out.puts res[:output]
+          end
+        end
+
+        private_class_method def self.register_sandbox_command(shell)
+          shell.register_command("sandbox", description: "Inspect or configure sandbox isolation (bwrap/docker/podman)") do |args, ctx|
+            scope, clean_args = Base.parse_scope(args)
+            subcmd = clean_args.first.to_s.downcase
+
+            registered_map = Rubik::Sandbox::Driver.registered_drivers
+            registered_keys = registered_map.keys.uniq
+
+            if clean_args.empty? || subcmd == "status"
+              enabled = ctx.config.fetch("sandbox.enabled", false)
+              state_str = enabled ? "Açık (enabled)" : "Kapalı (disabled - direct safe execution)"
+              driver_name = ctx.sandbox_runner&.driver&.name || ctx.config.fetch("sandbox.driver", "bwrap")
+              net_str = ctx.config.fetch("sandbox.allow_network", false) ? "allowed" : "blocked"
+
+              ctx.out.puts "=== Sandbox Durumu ==="
+              ctx.out.puts "Durum:       #{state_str}"
+              ctx.out.puts "Aktif Motor: #{driver_name}"
+              ctx.out.puts "Ağ:          #{net_str}"
+              ctx.out.puts "Kayıtlı:     #{registered_keys.join(', ')}"
+            elsif subcmd == "on"
+              res = ctx.config.set("sandbox.enabled", true, persist: scope)
+              driver_res = ctx.config.set("sandbox.driver", "bwrap", persist: scope) if Rubik::Platform.linux?
+              next if Base.report_persist_failure(ctx, res, scope)
+              next if Base.report_persist_failure(ctx, driver_res, scope)
+
+              ctx.out.puts "[Sandbox] Enabled (#{ctx.sandbox_runner&.driver&.name || 'default'})."
+            elsif subcmd == "off"
+              res = ctx.config.set("sandbox.enabled", false, persist: scope)
+              next if Base.report_persist_failure(ctx, res, scope)
+
+              ctx.out.puts "[Sandbox] Disabled (direct safe execution active)."
+            elsif registered_map.key?(subcmd)
+              ctx.out.puts "⚠️ [Sandbox] 'bwrap' yalnızca Linux üzerinde desteklenir." if ["bwrap", "bubblewrap"].include?(subcmd) && !Rubik::Platform.linux?
+              res = ctx.config.set("sandbox.enabled", true, persist: scope)
+              driver_res = ctx.config.set("sandbox.driver", subcmd, persist: scope)
+              next if Base.report_persist_failure(ctx, res, scope)
+              next if Base.report_persist_failure(ctx, driver_res, scope)
+
+              ctx.out.puts "[Sandbox] Driver set to '#{subcmd}' (enabled)."
+            else
+              ctx.out.puts "[Sandbox] Bilinmeyen alt komut veya sürücü: '#{subcmd}'. Kayıtlı sürücüler: #{registered_keys.join(', ')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../../llm"
+
+module Rubik
+  module REPL
+    module Commands
+      module AgentModels
+        extend Base
+
+        def self.parse_model_target(target, ctx)
+          return ["ollama", ""] if target.nil? || target.empty?
+
+          raw_target = target.strip
+
+          # Extract registered providers from registry and config
+          registered_providers = []
+          registered_providers += ctx.llm_registry.list if ctx.llm_registry
+          registered_providers += ctx.config.fetch("providers", {}).keys if ctx.config
+          registered_providers = registered_providers.map { |p| p.to_s.downcase }.uniq
+
+          # 1. Explicit provider prefix with colon: e.g. "openrouter:anthropic/claude-3.5-sonnet"
+          if raw_target.include?(":")
+            parts = raw_target.split(":", 2)
+            first_part = parts.first.downcase
+
+            if registered_providers.include?(first_part)
+              prov = first_part
+              mod = parts[1]
+              return [prov, mod]
+            end
+          end
+
+          # 2. Explicit provider prefix with slash: e.g. "ollama/qwen2.5-coder:7b" or "openrouter/cline-pass/deepseek-v4-flash"
+          if raw_target.include?("/")
+            parts = raw_target.split("/")
+            first_part = parts.first.downcase
+
+            if registered_providers.include?(first_part)
+              prov = first_part
+              mod = parts[1..].join("/")
+              return [prov, mod]
+            end
+
+            # Check if this exact target is registered in any provider's model catalog
+            if ctx.llm_registry&.models_catalog
+              catalog_match = ctx.llm_registry.models_catalog.find { |_k, v| v[:name] == raw_target }
+              return [catalog_match[1][:provider], raw_target] if catalog_match
+            end
+
+            # First part is not a known provider; treat entire string as model under default provider
+            current_default_prov = ctx.config.model_spec(:default)&.dig("provider") || "ollama"
+            return [current_default_prov, raw_target]
+          end
+
+          # 3. No slash, exactly registered provider name alone
+          if registered_providers.include?(raw_target.downcase)
+            default_mod = ctx.llm_registry.get(raw_target.downcase).respond_to?(:model) ? ctx.llm_registry.get(raw_target.downcase).model : raw_target
+            return [raw_target.downcase, default_mod]
+          end
+
+          # 4. Fallback: model name under default provider (e.g. "qwen2.5-coder:7b", "llama3")
+          current_default_prov = ctx.config.model_spec(:default)&.dig("provider") || "ollama"
+          [current_default_prov, raw_target]
+        end
+
+        def self.parse_model_args(clean_args, ctx)
+          return ["ollama", ""] if clean_args.nil? || clean_args.empty?
+
+          clean_array = clean_args.is_a?(Array) ? clean_args : clean_args.to_s.strip.split(/\s+/)
+          return ["ollama", ""] if clean_array.empty?
+
+          registered_providers = []
+          registered_providers += ctx.llm_registry.list if ctx.llm_registry
+          registered_providers += ctx.config.fetch("providers", {}).keys if ctx.config
+          registered_providers = registered_providers.map { |p| p.to_s.downcase }.uniq
+
+          # 1. If 2 or more space-separated arguments: e.g. ["openrouter", "deepseek/deepseek-v4-flash"]
+          if clean_array.length >= 2
+            first_candidate = clean_array.first.to_s.strip.downcase
+            if registered_providers.include?(first_candidate)
+              prov = first_candidate
+              mod = clean_array[1..].join(" ").strip
+              return [prov, mod]
+            end
+          end
+
+          # 2. Otherwise join and parse as single target
+          target = clean_array.join(" ").strip
+          parse_model_target(target, ctx)
+        end
+
+        def self.register(shell)
+          register_model_command(shell)
+        end
+
+        # Shared tail of the three !model context forms: apply the limit
+        # through the Config verb, refresh the runtime, report — or refuse
+        # honestly (unknown provider vs a disk write that failed).
+        private_class_method def self.update_context_limit(ctx, scope, provider, model, limit_val, label)
+          res = ctx.config.upsert_provider_model(provider, model, context_limit: limit_val, persist: scope)
+          ctx.refresh_llm_registry!
+          if res[:ok]
+            ctx.out.puts "Updated context limit for #{label} to #{limit_val} tokens [#{Base.scope_label(scope)}]."
+          elsif res[:reason] == :unknown_provider
+            ctx.out.puts "Provider '#{provider}' not found."
+          else
+            Base.report_persist_failure(ctx, res, scope)
+          end
+        end
+
+        private_class_method def self.register_model_command(shell)
+          shell.register_command("model",
+                                 audience: :both,
+                                 description: "Switch or view LLM provider/model roles (default, fast, advanced) with auto-persistence") do |args, ctx|
+            scope, clean_args = Base.parse_scope(args)
+
+            if clean_args.empty? || clean_args.first.downcase == "list"
+              mode = ctx.config.fetch("router.mode", "auto")
+              def_spec = ctx.config.model_spec(:default)
+              fast_spec = ctx.config.model_spec(:fast)
+              adv_spec = ctx.config.model_spec(:advanced)
+
+              def_limit = ctx.llm_registry.context_limit_for(def_spec["provider"], def_spec["name"])
+              fast_limit = ctx.llm_registry.context_limit_for(fast_spec["provider"], fast_spec["name"])
+              adv_limit = ctx.llm_registry.context_limit_for(adv_spec["provider"], adv_spec["name"])
+
+              def_ep = def_spec["endpoint"] || def_spec["host"] || "cloud"
+              fast_ep = fast_spec["endpoint"] || fast_spec["host"] || "cloud"
+              adv_ep = adv_spec["endpoint"] || adv_spec["host"] || "cloud"
+
+              ctx.out.puts "Model Router Configuration (Mode: #{mode}):"
+              ctx.out.puts "  • default  : #{def_spec['provider']}/#{def_spec['name']} [Context: #{def_limit} tokens] (#{def_ep})"
+              ctx.out.puts "  • fast     : #{fast_spec['provider']}/#{fast_spec['name']} [Context: #{fast_limit} tokens] (#{fast_ep})"
+              ctx.out.puts "  • advanced : #{adv_spec['provider']}/#{adv_spec['name']} [Context: #{adv_limit} tokens] (#{adv_ep})"
+              ctx.out.puts "Global Config  : #{ctx.config.global_config_path}"
+              ctx.out.puts "Project Config : #{ctx.config.project_config_path}"
+            elsif clean_args.first.downcase == "route"
+              mode = clean_args[1].to_s.downcase
+              if ["auto", "manual"].include?(mode)
+                res = ctx.config.set("router.mode", mode, persist: scope)
+                next if Base.report_persist_failure(ctx, res, scope)
+
+                ctx.out.puts "Router mode set to #{mode} [#{Base.scope_label(scope)}]."
+              else
+                ctx.out.puts "Usage: !model route <auto|manual>"
+              end
+            elsif clean_args.first.downcase == "add"
+              p_name = clean_args[1]&.downcase
+              m_name = clean_args[2]
+              if p_name.nil? || p_name.empty? || m_name.nil? || m_name.empty?
+                ctx.out.puts "Usage: !model add <provider_name> <model_name> [--context=LIMIT] [--project|--global]"
+              else
+                context_arg = clean_args.find { |a| a.start_with?("--context=") }
+                c_limit = context_arg ? context_arg.split("=", 2).last.to_i : 32_768
+                res = ctx.config.upsert_provider_model(p_name, m_name, context_limit: c_limit, persist: scope)
+                ctx.refresh_llm_registry!
+                if res[:ok]
+                  ctx.out.puts "Added model '#{m_name}' (#{c_limit} tokens) to provider '#{p_name}' [#{Base.scope_label(scope)}]."
+                elsif res[:reason] == :unknown_provider
+                  ctx.out.puts "Provider '#{p_name}' not found. Add provider first via !provider add."
+                else
+                  Base.report_persist_failure(ctx, res, scope)
+                end
+              end
+            elsif ["context", "limit"].include?(clean_args.first.downcase)
+              if clean_args.size == 2 && clean_args[1] =~ /^\d+$/
+                def_spec = ctx.config.model_spec(:default)
+                update_context_limit(ctx, scope, def_spec["provider"], def_spec["name"],
+                                     clean_args[1].to_i, "default model #{def_spec['provider']}/#{def_spec['name']}")
+              elsif clean_args.size == 3 && ["default", "fast", "advanced"].include?(clean_args[1].downcase) && clean_args[2] =~ /^\d+$/
+                role = clean_args[1].downcase.to_sym
+                spec = ctx.config.model_spec(role)
+                update_context_limit(ctx, scope, spec["provider"], spec["name"],
+                                     clean_args[2].to_i, "#{role} model #{spec['provider']}/#{spec['name']}")
+              elsif clean_args.size == 4 && clean_args[3] =~ /^\d+$/
+                update_context_limit(ctx, scope, clean_args[1].downcase, clean_args[2],
+                                     clean_args[3].to_i, "#{clean_args[1].downcase}/#{clean_args[2]}")
+              else
+                ctx.out.puts "Usage: !model context <limit> | !model context <default|fast|advanced> <limit> | " \
+                             "!model context <provider> <model> <limit> [--project|--global]"
+              end
+            elsif clean_args.first.downcase == "set"
+              role = clean_args[1].to_s.downcase
+              model_args = clean_args[2..]
+              if model_args.nil? || model_args.empty?
+                ctx.out.puts "Usage: !model set <default|fast|advanced> [<provider>] <model_name> [--project|--global]"
+              else
+                prov, mod = parse_model_args(model_args, ctx)
+                res = ctx.config.set_model_spec(role, provider: prov, name: mod, persist: scope)
+                ctx.resync_llm_route!
+                next if Base.report_persist_failure(ctx, res, scope)
+
+                limit = ctx.llm_registry.context_limit_for(prov, mod)
+                ctx.out.puts "Set model role '#{role}' to #{prov}/#{mod} [Context: #{limit} tokens] [#{Base.scope_label(scope)}]."
+              end
+            else
+              prov, mod = parse_model_args(clean_args, ctx)
+              res = ctx.config.set_model_spec(:default, provider: prov, name: mod, persist: scope)
+              ctx.resync_llm_route!
+              next if Base.report_persist_failure(ctx, res, scope)
+
+              limit = ctx.llm_registry.context_limit_for(prov, mod)
+              ctx.out.puts "Switched default model to #{prov}/#{mod} [Context: #{limit} tokens] [#{Base.scope_label(scope)}]."
+            end
+          end
+        end
+      end
+    end
+  end
+end