legion-tty 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df932fba0f861bcb1473808566486e7ebc769ab735d53b4464f2d1c77a78f7a0
-  data.tar.gz: a13036205e7d36cee04d0dbdea574041b358f62cf7d533b87a564a86a39a4ddd
+  metadata.gz: d7b05c783669ce2e8482bd36b3654b75d626d3fc2b738e684a6b9fad407881e1
+  data.tar.gz: 34418c0af4571764d36096de930f126a92b192fe87ff22c2acbbcbb71f45a090
 SHA512:
-  metadata.gz: f9d27f13872938348b97a31cb8949cb93d158c3b288dc9972ad48de25b9e47abdd298a5fa0688c3b9497648ce864280308d1ec82653502192a57ea00535ed80a
-  data.tar.gz: aad5dfe5fa9b5960acde7a58d086ac87ccd49c2503d6bed0e3a0220d2a5caae4d121b38e2d53f78cfa940c43dc665d252c5ffc5ddbdb32ce4bd5f791b8837149
+  metadata.gz: 1f913c1e7ec15e45a7d27d24393e721852ffd28e7d61c1d3284996fe564bd30ee2dcd9910676eb40bf5239cfbf9068f5561c95f61bf55c0f1beb8ff95677925f
+  data.tar.gz: 995fc6176e39c16dae3b1570149ed8292c0c30174fa5eecd5effcafcfa5004eb8006a135b8c815199bf1003e46f26c227a65f1ecb3f00a35ebcc0b48d16f5fc6

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [0.4.0] - 2026-03-19
+
+### Fixed
+- /model crash: empty or invalid model name no longer crashes the shell
+- Removed all RubyLLM direct usage -- all LLM access goes through Legion::LLM exclusively
+- Kerberos username key mismatch in vault auth pre-fill (was :samaccountname, now :username)
+- Overlay rendering: help overlay now actually displays on screen
+- Thinking indicator: status bar shows "thinking..." during LLM requests
+- --skip-rain CLI option now forwarded to onboarding
+
+### Added
+- Per-model token pricing (Opus/Sonnet/Haiku, GPT-4o/4o-mini, Gemini Flash/Pro)
+- Markdown rendering for assistant messages via TTY::Markdown
+- /system command: set or override system prompt at runtime
+- /delete command: delete saved sessions
+- /plan command: toggle read-only bookmark mode with [PLAN] status indicator
+- /palette command: fuzzy-search command palette for all commands, screens, sessions
+- /extensions command: browse installed LEX gems by category
+- /config command: view and edit ~/.legionio/settings/*.json files
+- Command palette component with fuzzy search
+- Model picker component for switching LLM providers
+- Session picker component for quick session switching
+- Table view component wrapping tty-table
+- Extensions browser screen (grouped by core/agentic/service/AI/other)
+- Config viewer/editor screen with vault:// masking
+- Hotkeys: Ctrl+K (palette), Ctrl+S (sessions), Escape (back)
+- Plan mode: bookmark messages without sending to LLM
+
+### Changed
+- Token tracker now uses per-model rates with provider fallback
+- Hotkey ? removed (conflicted with typing questions)
+- Help text updated with all new commands and hotkey reference
+
+### Removed
+- RubyLLM direct fallback in app.rb (PROVIDER_MAP, try_credentials_llm, configure_llm_provider)
+
 ## [0.3.1] - 2026-03-19
 
 ### Fixed

data/lib/legion/tty/app.rb

@@ -16,19 +16,26 @@ module Legion
       attr_reader :config, :credentials, :screen_manager, :hotkeys, :llm_chat
 
       def self.run(argv = [])
-        _ = argv
-        app = new
+        opts = parse_argv(argv)
+        app = new(**opts)
         app.start
       rescue Interrupt
         app&.shutdown
       end
 
+      def self.parse_argv(argv)
+        opts = {}
+        opts[:skip_rain] = true if argv.include?('--skip-rain')
+        opts
+      end
+
       def self.first_run?(config_dir: CONFIG_DIR)
         !File.exist?(File.join(config_dir, 'identity.json'))
       end
 
-      def initialize(config_dir: CONFIG_DIR)
+      def initialize(config_dir: CONFIG_DIR, skip_rain: false)
         @config_dir = config_dir
+        @skip_rain = skip_rain
         @config = load_config
         @credentials = load_credentials
         @screen_manager = ScreenManager.new
@@ -46,15 +53,11 @@ module Legion
       end
 
       def setup_hotkeys
-        @hotkeys.register("\x04", 'Toggle dashboard (Ctrl+D)') do
-          toggle_dashboard
-        end
-        @hotkeys.register("\x0C", 'Refresh screen (Ctrl+L)') do
-          :refresh
-        end
-        @hotkeys.register('?', 'Show help overlay') do
-          show_help_overlay
-        end
+        @hotkeys.register("\x04", 'Toggle dashboard (Ctrl+D)') { toggle_dashboard }
+        @hotkeys.register("\x0C", 'Refresh screen (Ctrl+L)') { :refresh }
+        @hotkeys.register("\x0B", 'Command palette (Ctrl+K)') { :command_palette }
+        @hotkeys.register("\x13", 'Session picker (Ctrl+S)') { :session_picker }
+        @hotkeys.register("\e", 'Go back (Escape)') { :escape }
       end
 
       def toggle_dashboard
@@ -68,15 +71,8 @@ module Legion
         end
       end
 
-      def show_help_overlay
-        bindings = @hotkeys.list
-        lines = bindings.map { |b| "  #{b[:key].inspect} - #{b[:description]}" }
-        text = "Hotkeys:\n#{lines.join("\n")}"
-        @screen_manager.show_overlay(text)
-      end
-
       def run_onboarding
-        onboarding = Screens::Onboarding.new(self)
+        onboarding = Screens::Onboarding.new(self, skip_rain: @skip_rain)
         data = onboarding.activate
         save_config(data)
         @config = load_config
@@ -94,7 +90,7 @@ module Legion
 
       def setup_llm
         boot_legion_subsystems
-        @llm_chat = try_settings_llm || try_credentials_llm
+        @llm_chat = try_settings_llm
       rescue StandardError
         @llm_chat = nil
       end
@@ -134,11 +130,6 @@ module Legion
         @screen_manager.teardown_all
       end
 
-      PROVIDER_MAP = {
-        claude: :anthropic,
-        azure: :openai
-      }.freeze
-
       private
 
       def boot_legion_subsystems # rubocop:disable Metrics/MethodLength
@@ -194,17 +185,6 @@ module Legion
         nil
       end
 
-      def try_credentials_llm
-        return nil unless @credentials[:provider] && @credentials[:api_key]
-
-        provider = @credentials[:provider].to_sym
-        api_key = @credentials[:api_key]
-        configure_llm_provider(provider, api_key)
-        create_llm_chat(provider)
-      rescue StandardError
-        nil
-      end
-
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def save_identity(data)
         identity = {
@@ -270,43 +250,6 @@ module Legion
         {}
       end
 
-      def configure_llm_provider(provider, api_key)
-        llm_provider = PROVIDER_MAP[provider] || provider
-
-        # Try Legion::LLM first (full stack)
-        return if try_legion_llm(llm_provider, api_key)
-
-        # Fallback: configure ruby_llm directly
-        require 'ruby_llm'
-        RubyLLM.configure do |c|
-          case llm_provider
-          when :anthropic then c.anthropic_api_key = api_key
-          when :openai    then c.openai_api_key = api_key
-          when :gemini    then c.gemini_api_key = api_key
-          end
-        end
-      end
-
-      def try_legion_llm(llm_provider, api_key)
-        return false unless defined?(Legion::LLM) && defined?(Legion::Settings)
-
-        Legion::Settings[:llm][:providers][llm_provider][:enabled] = true
-        Legion::Settings[:llm][:providers][llm_provider][:api_key] = api_key
-        Legion::LLM.start unless Legion::LLM.started?
-        true
-      rescue StandardError
-        false
-      end
-
-      def create_llm_chat(provider)
-        llm_provider = PROVIDER_MAP[provider] || provider
-        if defined?(Legion::LLM) && Legion::LLM.started?
-          Legion::LLM.chat(provider: llm_provider)
-        else
-          RubyLLM.chat(provider: llm_provider)
-        end
-      end
-
       def save_credentials(data)
         credentials = { api_key: data[:api_key], provider: data[:provider] }
         creds_path = File.join(@config_dir, 'credentials.json')

data/lib/legion/tty/components/command_palette.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Components
+      class CommandPalette
+        COMMANDS = %w[/help /quit /clear /model /session /cost /export /tools
+                      /dashboard /hotkeys /save /load /sessions /system /delete /plan
+                      /palette /extensions /config].freeze
+
+        SCREENS = %w[chat dashboard extensions config].freeze
+
+        def initialize(session_store: nil)
+          @session_store = session_store
+        end
+
+        def entries
+          all = COMMANDS.map { |cmd| { label: cmd, category: 'Commands' } }
+          SCREENS.each { |s| all << { label: s, category: 'Screens' } }
+          @session_store&.list&.each do |s|
+            all << { label: "/load #{s[:name]}", category: 'Sessions' }
+          end
+          all
+        end
+
+        def search(query)
+          return entries if query.nil? || query.empty?
+
+          q = query.downcase
+          entries.select { |e| e[:label].downcase.include?(q) }
+        end
+
+        def select_with_prompt(output: $stdout)
+          require 'tty-prompt'
+          prompt = ::TTY::Prompt.new(output: output)
+          choices = entries.map { |e| { name: "#{e[:label]} (#{e[:category]})", value: e[:label] } }
+          prompt.select('Command:', choices, filter: true, per_page: 15)
+        rescue ::TTY::Reader::InputInterrupt, Interrupt
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/message_stream.rb

@@ -52,13 +52,13 @@ module Legion
         end
 
         def render_message(msg, width)
-          role_lines(msg) + panel_lines(msg, width)
+          role_lines(msg, width) + panel_lines(msg, width)
         end
 
-        def role_lines(msg)
+        def role_lines(msg, width)
           case msg[:role]
           when :user then user_lines(msg)
-          when :assistant then assistant_lines(msg)
+          when :assistant then assistant_lines(msg, width)
           when :system then system_lines(msg)
           else []
           end
@@ -69,8 +69,16 @@ module Legion
           ['', "#{prefix}: #{msg[:content]}"]
         end
 
-        def assistant_lines(msg)
-          ['', *msg[:content].split("\n")]
+        def assistant_lines(msg, width)
+          rendered = render_markdown(msg[:content], width)
+          ['', *rendered.split("\n")]
+        end
+
+        def render_markdown(text, width)
+          require_relative 'markdown_view'
+          MarkdownView.render(text, width: width)
+        rescue StandardError
+          text
         end
 
         def system_lines(msg)

data/lib/legion/tty/components/model_picker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Components
+      class ModelPicker
+        def initialize(current_provider: nil, current_model: nil)
+          @current_provider = current_provider
+          @current_model = current_model
+        end
+
+        def available_models # rubocop:disable Metrics/CyclomaticComplexity
+          return [] unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:settings)
+
+          providers = Legion::LLM.settings[:providers]
+          return [] unless providers.is_a?(Hash)
+
+          models = []
+          providers.each do |name, config|
+            next unless config.is_a?(Hash) && config[:enabled]
+
+            model = config[:default_model] || name.to_s
+            current = (name.to_s == @current_provider.to_s)
+            models << { provider: name.to_s, model: model, current: current }
+          end
+          models
+        end
+
+        def select_with_prompt(output: $stdout)
+          models = available_models
+          return nil if models.empty?
+
+          require 'tty-prompt'
+          prompt = ::TTY::Prompt.new(output: output)
+          choices = models.map do |m|
+            indicator = m[:current] ? ' (current)' : ''
+            { name: "#{m[:provider]} / #{m[:model]}#{indicator}", value: m }
+          end
+          prompt.select('Select model:', choices, per_page: 10)
+        rescue ::TTY::Reader::InputInterrupt, Interrupt
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/session_picker.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Components
+      class SessionPicker
+        def initialize(session_store:)
+          @session_store = session_store
+        end
+
+        def select_with_prompt(output: $stdout)
+          sessions = @session_store.list
+          return nil if sessions.empty?
+
+          require 'tty-prompt'
+          prompt = ::TTY::Prompt.new(output: output)
+          choices = sessions.map do |s|
+            { name: "#{s[:name]} (#{s[:message_count]} msgs, #{s[:saved_at]})", value: s[:name] }
+          end
+          choices << { name: '+ New session', value: :new }
+          prompt.select('Select session:', choices, per_page: 10)
+        rescue ::TTY::Reader::InputInterrupt, Interrupt
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/status_bar.rb

@@ -7,7 +7,7 @@ module Legion
     module Components
       class StatusBar
         def initialize
-          @state = { model: nil, tokens: 0, cost: 0.0, session: 'default' }
+          @state = { model: nil, tokens: 0, cost: 0.0, session: 'default', thinking: false, plan_mode: false }
         end
 
         def update(**fields)
@@ -31,6 +31,8 @@ module Legion
         def build_segments
           [
             model_segment,
+            plan_segment,
+            thinking_segment,
             tokens_segment,
             cost_segment,
             session_segment
@@ -41,6 +43,18 @@ module Legion
           Theme.c(:accent, @state[:model]) if @state[:model]
         end
 
+        def plan_segment
+          return nil unless @state[:plan_mode]
+
+          Theme.c(:warning, '[PLAN]')
+        end
+
+        def thinking_segment
+          return nil unless @state[:thinking]
+
+          Theme.c(:warning, 'thinking...')
+        end
+
         def tokens_segment
           Theme.c(:secondary, "#{format_number(@state[:tokens])} tokens") if @state[:tokens].to_i.positive?
         end

data/lib/legion/tty/components/table_view.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    module Components
+      module TableView
+        def self.render(headers:, rows:, width: 80)
+          require 'tty-table'
+          table = ::TTY::Table.new(header: headers, rows: rows)
+          table.render(:unicode, width: width, padding: [0, 1]) || ''
+        rescue StandardError => e
+          "Table render error: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/legion/tty/components/token_tracker.rb

@@ -4,28 +4,51 @@ module Legion
   module TTY
     module Components
       class TokenTracker
-        PRICING = {
+        # Rates per 1k tokens (input/output) — current as of 2026-03
+        MODEL_PRICING = {
+          'claude-opus-4-6' => { input: 0.015, output: 0.075 },
+          'claude-sonnet-4-6' => { input: 0.003, output: 0.015 },
+          'claude-haiku-4-5' => { input: 0.0008, output: 0.004 },
+          'gpt-4o' => { input: 0.0025, output: 0.010 },
+          'gpt-4o-mini' => { input: 0.00015, output: 0.0006 },
+          'gpt-4.1' => { input: 0.002, output: 0.008 },
+          'gemini-2.0-flash' => { input: 0.0001, output: 0.0004 },
+          'gemini-2.5-pro' => { input: 0.00125, output: 0.01 },
+          'local' => { input: 0.0, output: 0.0 }
+        }.freeze
+
+        PROVIDER_PRICING = {
+          'anthropic' => { input: 0.003, output: 0.015 },
           'claude' => { input: 0.003, output: 0.015 },
-          'openai' => { input: 0.005, output: 0.015 },
-          'gemini' => { input: 0.001, output: 0.002 },
-          'azure' => { input: 0.005, output: 0.015 },
+          'openai' => { input: 0.0025, output: 0.010 },
+          'gemini' => { input: 0.0001, output: 0.0004 },
+          'bedrock' => { input: 0.003, output: 0.015 },
+          'azure' => { input: 0.0025, output: 0.010 },
+          'ollama' => { input: 0.0, output: 0.0 },
           'local' => { input: 0.0, output: 0.0 }
         }.freeze
 
         attr_reader :total_input_tokens, :total_output_tokens, :total_cost
 
-        def initialize(provider: 'claude')
+        def initialize(provider: 'claude', model: nil)
           @provider = provider
+          @model = model
           @total_input_tokens = 0
           @total_output_tokens = 0
           @total_cost = 0.0
         end
 
-        def track(input_tokens:, output_tokens:)
+        def update_model(model)
+          @model = model
+        end
+
+        def track(input_tokens:, output_tokens:, model: nil)
+          @model = model if model
           @total_input_tokens += input_tokens.to_i
           @total_output_tokens += output_tokens.to_i
-          rates = PRICING[@provider] || PRICING['claude']
-          @total_cost += (input_tokens.to_i * rates[:input] / 1000.0) + (output_tokens.to_i * rates[:output] / 1000.0)
+          rates = rates_for(@model, @provider)
+          @total_cost += (input_tokens.to_i * rates[:input] / 1000.0) +
+                         (output_tokens.to_i * rates[:output] / 1000.0)
         end
 
         def summary
@@ -37,6 +60,16 @@ module Legion
 
         private
 
+        def rates_for(model, provider)
+          return MODEL_PRICING[model] if model && MODEL_PRICING.key?(model)
+
+          MODEL_PRICING.each do |key, rates|
+            return rates if model&.include?(key)
+          end
+
+          PROVIDER_PRICING[provider] || PROVIDER_PRICING['claude']
+        end
+
         def format_number(num)
           num.to_s.chars.reverse.each_slice(3).map(&:join).join(',').reverse
         end

data/lib/legion/tty/screens/chat.rb

@@ -13,7 +13,7 @@ module Legion
       # rubocop:disable Metrics/ClassLength
       class Chat < Base
         SLASH_COMMANDS = %w[/help /quit /clear /model /session /cost /export /tools /dashboard /hotkeys /save /load
-                            /sessions].freeze
+                            /sessions /system /delete /plan /palette /extensions /config].freeze
 
         attr_reader :message_stream, :status_bar
 
@@ -28,6 +28,7 @@ module Legion
           @token_tracker = Components::TokenTracker.new(provider: detect_provider)
           @session_store = SessionStore.new
           @session_name = 'default'
+          @plan_mode = false
         end
 
         def activate
@@ -45,6 +46,7 @@ module Legion
           @running
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def run
           activate
           while @running
@@ -52,6 +54,11 @@ module Legion
             input = read_input
             break if input.nil?
 
+            if @app.respond_to?(:screen_manager) && @app.screen_manager.overlay
+              @app.screen_manager.dismiss_overlay
+              next
+            end
+
             result = handle_slash_command(input)
             if result == :quit
               auto_save_session
@@ -62,6 +69,7 @@ module Legion
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def handle_slash_command(input)
           return nil unless input.start_with?('/')
@@ -74,25 +82,32 @@ module Legion
 
         def handle_user_message(input)
           @message_stream.add_message(role: :user, content: input)
-          @message_stream.add_message(role: :assistant, content: '')
-          send_to_llm(input)
+          if @plan_mode
+            @message_stream.add_message(role: :system, content: '(bookmarked)')
+          else
+            @message_stream.add_message(role: :assistant, content: '')
+            send_to_llm(input)
+          end
           render_screen
         end
 
         def send_to_llm(message)
           unless @llm_chat
-            @message_stream.append_streaming(
-              'LLM not configured. Use /help for commands.'
-            )
+            @message_stream.append_streaming('LLM not configured. Use /help for commands.')
             return
           end
 
+          @status_bar.update(thinking: true)
+          render_screen
           response = @llm_chat.ask(message) do |chunk|
+            @status_bar.update(thinking: false)
             @message_stream.append_streaming(chunk.content) if chunk.content
             render_screen
           end
+          @status_bar.update(thinking: false)
           track_response_tokens(response)
         rescue StandardError => e
+          @status_bar.update(thinking: false)
           @message_stream.append_streaming("\n[Error: #{e.message}]")
         end
 
@@ -175,7 +190,30 @@ module Legion
           @output.print ::TTY::Cursor.move_to(0, 0)
           @output.print ::TTY::Cursor.clear_screen_down
           lines.each { |line| @output.puts line }
+          render_overlay if @app.respond_to?(:screen_manager) && @app.screen_manager.overlay
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def render_overlay
+          require 'tty-box'
+          text = @app.screen_manager.overlay.to_s
+          width = (terminal_width - 4).clamp(40, terminal_width)
+          box = ::TTY::Box.frame(
+            width: width,
+            padding: 1,
+            title: { top_left: ' Help ' },
+            border: :round
+          ) { text }
+          overlay_lines = box.split("\n")
+          start_row = [(terminal_height - overlay_lines.size) / 2, 0].max
+          overlay_lines.each_with_index do |line, i|
+            @output.print ::TTY::Cursor.move_to(2, start_row + i)
+            @output.print line
+          end
+        rescue StandardError
+          nil
         end
+        # rubocop:enable Metrics/AbcSize
 
         def read_input
           return nil unless @input_bar.respond_to?(:read_line)
@@ -185,7 +223,7 @@ module Legion
           nil
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         def dispatch_slash(cmd, input)
           case cmd
           when '/quit' then :quit
@@ -201,16 +239,24 @@ module Legion
           when '/sessions' then handle_sessions
           when '/dashboard' then handle_dashboard
           when '/hotkeys' then handle_hotkeys
+          when '/system' then handle_system(input)
+          when '/delete' then handle_delete(input)
+          when '/plan' then handle_plan
+          when '/palette' then handle_palette
+          when '/extensions' then handle_extensions_screen
+          when '/config' then handle_config_screen
           else :handled
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
 
         def handle_help
           @message_stream.add_message(
             role: :system,
-            content: "Commands: /help /quit /clear /model <name> /session <name> /cost\n  " \
-                     '/export [md|json] /tools /dashboard /hotkeys /save /load /sessions'
+            content: "Commands:\n  /help /quit /clear /model <name> /session <name> /cost\n  " \
+                     "/export [md|json] /tools /dashboard /hotkeys /save /load /sessions\n  " \
+                     "/system <prompt> /delete <session> /plan /palette /extensions /config\n\n" \
+                     'Hotkeys: Ctrl+D=dashboard  Ctrl+K=palette  Ctrl+S=sessions  Esc=back'
           )
           :handled
         end
@@ -223,21 +269,38 @@ module Legion
         def handle_model(input)
           name = input.split(nil, 2)[1]
           if name
-            if @llm_chat.respond_to?(:with_model)
-              @llm_chat.with_model(name)
-              @status_bar.update(model: name)
-              @message_stream.add_message(role: :system, content: "Model switched to: #{name}")
-            else
-              @status_bar.update(model: name)
-              @message_stream.add_message(role: :system, content: "Model set to: #{name} (no active LLM session)")
-            end
+            switch_model(name)
           else
-            current = safe_config[:provider] || 'unknown'
-            @message_stream.add_message(role: :system, content: "Current model: #{current}")
+            show_current_model
           end
           :handled
         end
 
+        def switch_model(name)
+          unless @llm_chat
+            @message_stream.add_message(role: :system, content: 'No active LLM session.')
+            return
+          end
+
+          if @llm_chat.respond_to?(:with_model)
+            @llm_chat.with_model(name)
+            @status_bar.update(model: name)
+            @message_stream.add_message(role: :system, content: "Model switched to: #{name}")
+          else
+            @status_bar.update(model: name)
+            @message_stream.add_message(role: :system, content: "Model set to: #{name}")
+          end
+        rescue StandardError => e
+          @message_stream.add_message(role: :system, content: "Failed to switch model: #{e.message}")
+        end
+
+        def show_current_model
+          model = @llm_chat.respond_to?(:model) ? @llm_chat.model : nil
+          provider = safe_config[:provider] || 'unknown'
+          info = model ? "#{model} (#{provider})" : provider
+          @message_stream.add_message(role: :system, content: "Current model: #{info}")
+        end
+
         def handle_session(input)
           name = input.split(nil, 2)[1]
           if name
@@ -362,10 +425,91 @@ module Legion
           :handled
         end
 
+        def handle_system(input)
+          text = input.split(nil, 2)[1]
+          if text
+            if @llm_chat.respond_to?(:with_instructions)
+              @llm_chat.with_instructions(text)
+              @message_stream.add_message(role: :system, content: 'System prompt updated.')
+            else
+              @message_stream.add_message(role: :system, content: 'No active LLM session.')
+            end
+          else
+            @message_stream.add_message(role: :system, content: 'Usage: /system <prompt text>')
+          end
+          :handled
+        end
+
+        def handle_delete(input)
+          name = input.split(nil, 2)[1]
+          unless name
+            @message_stream.add_message(role: :system, content: 'Usage: /delete <session-name>')
+            return :handled
+          end
+          @session_store.delete(name)
+          @message_stream.add_message(role: :system, content: "Session '#{name}' deleted.")
+          :handled
+        end
+
+        def handle_plan
+          @plan_mode = !@plan_mode
+          if @plan_mode
+            @status_bar.update(plan_mode: true)
+            @message_stream.add_message(role: :system,
+                                        content: 'Plan mode ON -- messages are bookmarked, not sent to LLM.')
+          else
+            @status_bar.update(plan_mode: false)
+            @message_stream.add_message(role: :system, content: 'Plan mode OFF -- messages sent to LLM.')
+          end
+          :handled
+        end
+
+        def handle_palette
+          require_relative '../components/command_palette'
+          palette = Components::CommandPalette.new(session_store: @session_store)
+          selection = palette.select_with_prompt(output: @output)
+          return :handled unless selection
+
+          if selection.start_with?('/')
+            handle_slash_command(selection)
+          else
+            dispatch_screen_by_name(selection)
+          end
+          :handled
+        end
+
+        def dispatch_screen_by_name(name)
+          case name
+          when 'dashboard' then handle_dashboard
+          when 'extensions' then handle_extensions_screen
+          when 'config' then handle_config_screen
+          end
+        end
+
+        def handle_extensions_screen
+          require_relative '../screens/extensions'
+          screen = Screens::Extensions.new(@app, output: @output)
+          @app.screen_manager.push(screen)
+          :handled
+        rescue LoadError
+          @message_stream.add_message(role: :system, content: 'Extensions screen not available.')
+          :handled
+        end
+
+        def handle_config_screen
+          require_relative '../screens/config'
+          screen = Screens::Config.new(@app, output: @output)
+          @app.screen_manager.push(screen)
+          :handled
+        rescue LoadError
+          @message_stream.add_message(role: :system, content: 'Config screen not available.')
+          :handled
+        end
+
         def detect_provider
           cfg = safe_config
           provider = cfg[:provider].to_s.downcase
-          return provider if Components::TokenTracker::PRICING.key?(provider)
+          return provider if Components::TokenTracker::PROVIDER_PRICING.key?(provider)
 
           'claude'
         end
@@ -373,9 +517,11 @@ module Legion
         def track_response_tokens(response)
           return unless response.respond_to?(:input_tokens)
 
+          model_id = response.respond_to?(:model) ? response.model.to_s : nil
           @token_tracker.track(
             input_tokens: response.input_tokens.to_i,
-            output_tokens: response.output_tokens.to_i
+            output_tokens: response.output_tokens.to_i,
+            model: model_id
           )
           @status_bar.update(
             tokens: @token_tracker.total_input_tokens + @token_tracker.total_output_tokens,

data/lib/legion/tty/screens/config.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'base'
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Screens
+      # rubocop:disable Metrics/ClassLength
+      class Config < Base
+        MASKED_PATTERNS = %w[vault:// env://].freeze
+
+        def initialize(app, output: $stdout, config_dir: nil)
+          super(app)
+          @output = output
+          @config_dir = config_dir || File.expand_path('~/.legionio/settings')
+          @files = []
+          @selected_file = 0
+          @selected_key = 0
+          @viewing_file = false
+          @file_data = {}
+        end
+
+        def activate
+          @files = discover_config_files
+        end
+
+        def discover_config_files
+          return [] unless Dir.exist?(@config_dir)
+
+          Dir.glob(File.join(@config_dir, '*.json')).map do |path|
+            { name: File.basename(path), path: path }
+          end
+        end
+
+        def render(_width, height)
+          lines = [Theme.c(:accent, '  Settings'), '']
+          lines += if @viewing_file
+                     file_detail_lines(height - 4)
+                   else
+                     file_list_lines(height - 4)
+                   end
+          lines += ['', Theme.c(:muted, '  Enter=view  e=edit  q=back')]
+          pad_lines(lines, height)
+        end
+
+        def handle_input(key)
+          if @viewing_file
+            handle_file_view_input(key)
+          else
+            handle_file_list_input(key)
+          end
+        end
+
+        private
+
+        def handle_file_list_input(key)
+          case key
+          when :up then @selected_file = [(@selected_file - 1), 0].max
+                        :handled
+          when :down then @selected_file = [(@selected_file + 1), @files.size - 1].max
+                          :handled
+          when :enter then open_file
+                           :handled
+          when 'q', :escape then :pop_screen
+          else
+            :pass
+          end
+        end
+
+        def handle_file_view_input(key)
+          keys = @file_data.keys
+          max = [keys.size - 1, 0].max
+          case key
+          when :up then @selected_key = [(@selected_key - 1), 0].max
+                        :handled
+          when :down then @selected_key = [(@selected_key + 1), max].max
+                          :handled
+          when 'e', :enter then edit_selected_key
+                                :handled
+          when 'q', :escape
+            @viewing_file = false
+            @selected_key = 0
+            :handled
+          else
+            :pass
+          end
+        end
+
+        def open_file
+          return unless @files[@selected_file]
+
+          path = @files[@selected_file][:path]
+          @file_data = ::JSON.parse(File.read(path))
+          @viewing_file = true
+          @selected_key = 0
+        rescue ::JSON::ParserError, Errno::ENOENT
+          @file_data = { 'error' => 'Failed to parse file' }
+          @viewing_file = true
+        end
+
+        def edit_selected_key # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+          keys = @file_data.keys
+          return unless keys[@selected_key]
+
+          key = keys[@selected_key]
+          current = @file_data[key]
+          return if current.is_a?(Hash) || current.is_a?(Array)
+
+          require 'tty-prompt'
+          prompt = ::TTY::Prompt.new
+          display = masked?(current.to_s) ? '********' : current.to_s
+          new_val = prompt.ask("#{key}:", default: display)
+          return if new_val.nil? || new_val == '********'
+
+          @file_data[key] = new_val
+          save_current_file
+        rescue ::TTY::Reader::InputInterrupt, Interrupt
+          nil
+        end
+
+        def save_current_file
+          return unless @files[@selected_file]
+
+          path = @files[@selected_file][:path]
+          File.write(path, ::JSON.pretty_generate(@file_data))
+        end
+
+        def masked?(val)
+          MASKED_PATTERNS.any? { |p| val.to_s.start_with?(p) }
+        end
+
+        def file_list_lines(max_height)
+          @files.each_with_index.map do |f, i|
+            indicator = i == @selected_file ? Theme.c(:accent, '>') : ' '
+            "  #{indicator} #{f[:name]}"
+          end.first(max_height)
+        end
+
+        def file_detail_lines(max_height)
+          return ["  #{Theme.c(:muted, 'Empty file')}"] if @file_data.empty?
+
+          name = @files[@selected_file]&.dig(:name) || 'unknown'
+          lines = ["  #{Theme.c(:secondary, name)}", '']
+          @file_data.each_with_index do |(key, val), i|
+            indicator = i == @selected_key ? Theme.c(:accent, '>') : ' '
+            display_val = format_value(val)
+            lines << "  #{indicator} #{Theme.c(:accent, key)}: #{display_val}"
+          end
+          lines.first(max_height)
+        end
+
+        def format_value(val)
+          case val
+          when Hash then Theme.c(:muted, "{#{val.size} keys}")
+          when Array then Theme.c(:muted, "[#{val.size} items]")
+          else
+            masked?(val.to_s) ? Theme.c(:warning, '********') : val.to_s
+          end
+        end
+
+        def pad_lines(lines, height)
+          lines + Array.new([height - lines.size, 0].max, '')
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/legion/tty/screens/extensions.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Screens
+      # rubocop:disable Metrics/ClassLength
+      class Extensions < Base
+        CORE = %w[lex-node lex-tasker lex-scheduler lex-conditioner lex-transformer
+                  lex-synapse lex-health lex-log lex-ping lex-metering lex-llm-gateway
+                  lex-codegen lex-exec lex-lex lex-telemetry lex-audit lex-detect].freeze
+
+        AI = %w[lex-claude lex-openai lex-gemini].freeze
+
+        SERVICE = %w[lex-http lex-vault lex-github lex-consul lex-kerberos lex-tfe
+                     lex-redis lex-memcached lex-elasticsearch lex-s3].freeze
+
+        def initialize(app, output: $stdout)
+          super(app)
+          @output = output
+          @gems = []
+          @selected = 0
+          @detail = false
+        end
+
+        def activate
+          @gems = discover_extensions
+        end
+
+        def discover_extensions
+          Gem::Specification.select { |s| s.name.start_with?('lex-') }
+                            .sort_by(&:name)
+                            .map { |s| build_entry(s) }
+        end
+
+        def render(_width, height)
+          lines = [Theme.c(:accent, '  LEX Extensions'), '']
+          lines += if @detail && @gems[@selected]
+                     detail_lines(@gems[@selected])
+                   else
+                     list_lines(height - 4)
+                   end
+          lines += ['', Theme.c(:muted, '  Enter=detail  q=back')]
+          pad_lines(lines, height)
+        end
+
+        def handle_input(key)
+          case key
+          when :up
+            @selected = [(@selected - 1), 0].max
+            :handled
+          when :down
+            @selected = [(@selected + 1), @gems.size - 1].min
+            :handled
+          when :enter
+            @detail = !@detail
+            :handled
+          when 'q', :escape
+            if @detail
+              @detail = false
+              :handled
+            else
+              :pop_screen
+            end
+          else
+            :pass
+          end
+        end
+
+        private
+
+        def build_entry(spec)
+          loaded = $LOADED_FEATURES.any? { |f| f.include?(spec.name.tr('-', '/')) }
+          {
+            name: spec.name,
+            version: spec.version.to_s,
+            summary: spec.summary,
+            homepage: spec.homepage,
+            loaded: loaded,
+            category: categorize(spec.name),
+            deps: spec.runtime_dependencies.map { |d| "#{d.name} #{d.requirement}" }
+          }
+        end
+
+        def categorize(name)
+          return 'Core' if CORE.include?(name)
+          return 'AI' if AI.include?(name)
+          return 'Service' if SERVICE.include?(name)
+          return 'Agentic' if name.match?(/^lex-agentic-|^lex-theory-|^lex-mind-|^lex-planning|^lex-attention/)
+
+          'Other'
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def list_lines(max_height)
+          grouped = @gems.group_by { |g| g[:category] }
+          lines = []
+          idx = 0
+          grouped.each do |cat, gems|
+            lines << Theme.c(:secondary, "  #{cat} (#{gems.size})")
+            gems.each do |g|
+              indicator = idx == @selected ? Theme.c(:accent, '>') : ' '
+              status = g[:loaded] ? Theme.c(:success, 'loaded') : Theme.c(:muted, 'avail')
+              lines << "  #{indicator} #{g[:name]} #{Theme.c(:muted, g[:version])} [#{status}]"
+              idx += 1
+            end
+            lines << ''
+          end
+          lines.first(max_height)
+        end
+
+        # rubocop:enable Metrics/AbcSize
+
+        def detail_lines(gem_entry)
+          [
+            "  #{Theme.c(:accent, gem_entry[:name])} #{gem_entry[:version]}",
+            "  #{Theme.c(:muted, gem_entry[:category])}",
+            '',
+            "  #{gem_entry[:summary]}",
+            '',
+            "  #{Theme.c(:secondary, 'Dependencies:')}",
+            *gem_entry[:deps].map { |d| "    #{d}" },
+            '',
+            "  #{Theme.c(:muted, gem_entry[:homepage] || 'no homepage')}"
+          ]
+        end
+
+        def pad_lines(lines, height)
+          lines + Array.new([height - lines.size, 0].max, '')
+        end
+      end
+      # rubocop:enable Metrics/ClassLength
+    end
+  end
+end

data/lib/legion/tty/screens/onboarding.rb

@@ -387,8 +387,8 @@ module Legion
         end
 
         def default_vault_username
-          if @kerberos_identity&.dig(:samaccountname)
-            @kerberos_identity[:samaccountname]
+          if @kerberos_identity&.dig(:username)
+            @kerberos_identity[:username]
           else
             ENV.fetch('USER', 'unknown')
           end

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.3.1'
+    VERSION = '0.4.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Esity
@@ -201,11 +201,15 @@ files:
 - lib/legion/tty/background/llm_probe.rb
 - lib/legion/tty/background/scanner.rb
 - lib/legion/tty/boot_logger.rb
+- lib/legion/tty/components/command_palette.rb
 - lib/legion/tty/components/digital_rain.rb
 - lib/legion/tty/components/input_bar.rb
 - lib/legion/tty/components/markdown_view.rb
 - lib/legion/tty/components/message_stream.rb
+- lib/legion/tty/components/model_picker.rb
+- lib/legion/tty/components/session_picker.rb
 - lib/legion/tty/components/status_bar.rb
+- lib/legion/tty/components/table_view.rb
 - lib/legion/tty/components/token_tracker.rb
 - lib/legion/tty/components/tool_panel.rb
 - lib/legion/tty/components/wizard_prompt.rb
@@ -213,7 +217,9 @@ files:
 - lib/legion/tty/screen_manager.rb
 - lib/legion/tty/screens/base.rb
 - lib/legion/tty/screens/chat.rb
+- lib/legion/tty/screens/config.rb
 - lib/legion/tty/screens/dashboard.rb
+- lib/legion/tty/screens/extensions.rb
 - lib/legion/tty/screens/onboarding.rb
 - lib/legion/tty/session_store.rb
 - lib/legion/tty/theme.rb