legion-tty 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df932fba0f861bcb1473808566486e7ebc769ab735d53b4464f2d1c77a78f7a0
-  data.tar.gz: a13036205e7d36cee04d0dbdea574041b358f62cf7d533b87a564a86a39a4ddd
+  metadata.gz: 4e5ec362f89174ce0ccc182a50343da7a6ce2846f3c01ad51ad14afe8a7f80f8
+  data.tar.gz: 763d695f1c7a2e8c13e3a518b36d2e90ae25713954a2127f5ed71869eaa31908
 SHA512:
-  metadata.gz: f9d27f13872938348b97a31cb8949cb93d158c3b288dc9972ad48de25b9e47abdd298a5fa0688c3b9497648ce864280308d1ec82653502192a57ea00535ed80a
-  data.tar.gz: aad5dfe5fa9b5960acde7a58d086ac87ccd49c2503d6bed0e3a0220d2a5caae4d121b38e2d53f78cfa940c43dc665d252c5ffc5ddbdb32ce4bd5f791b8837149
+  metadata.gz: 4cde6c72b3a66dd7b5daffce9c3407c0d82275a41bb1ed564579ccd013d31bd2f42f4e0366426446adf19f382d5f4911de6cc04622c86fd2e7090663ba1b7177
+  data.tar.gz: e4350ae0a6145f62758118c141f809de74d90ba5db873cbae1bd499c0c6b958325fa2196f91edd3df7aa3ddeb933f0fc818e3b7a372fab9ff8feb157f68ac680

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## [0.4.1] - 2026-03-19
+
+### Added
+- Progress panel component wrapping tty-progressbar for long operations
+- Tab completion for slash commands (type `/` + Tab to cycle through matches)
+- InputBar now accepts `completions:` parameter for configurable auto-complete
+
+### Changed
+- README.md updated to reflect 0.4.x features, hotkeys, architecture
+- CLAUDE.md updated to reflect current version, components, LLM integration notes
+
+## [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/README.md

@@ -2,19 +2,26 @@
 
 Rich terminal UI for the LegionIO async cognition engine.
 
-**Version**: 0.2.9
+**Version**: 0.4.1
 
-Think Claude Code meets Codex CLI, but for LegionIO: onboarding wizard with identity detection, streaming AI chat shell, operational dashboard, and session persistence - all rendered with the [tty-ruby](https://ttytoolkit.org/) gem ecosystem.
+Think Claude Code meets Codex CLI, but for LegionIO: onboarding wizard with identity detection, streaming AI chat shell, operational dashboard, extensions browser, config editor, and session persistence - all rendered with the [tty-ruby](https://ttytoolkit.org/) gem ecosystem.
 
 ## Features
 
 - **Onboarding wizard** - First-run setup with Kerberos identity detection, GitHub profile probing, environment scanning, and LLM provider selection
 - **Digital rain intro** - Matrix-style rain using discovered LEX extension names
-- **AI chat shell** - Streaming LLM chat with slash commands, tool panels, and markdown rendering
+- **AI chat shell** - Streaming LLM chat with 19 slash commands, tab completion, markdown rendering, and tool panels
 - **Operational dashboard** - Service status, extension inventory, system info, recent activity (Ctrl+D or `/dashboard`)
-- **Session persistence** - Auto-save on quit, `/save`, `/load`, `/sessions` to manage history across runs
-- **Token tracking** - Real-time input/output token counts and estimated cost via `/cost`
-- **Hotkey navigation** - Ctrl+D (dashboard), Ctrl+L (refresh), ? (help overlay)
+- **Extensions browser** - Browse installed LEX gems by category (core, agentic, service, AI, other) with detail view
+- **Config viewer/editor** - View and edit `~/.legionio/settings/*.json` with vault:// masking
+- **Command palette** - Fuzzy-search overlay for all commands, screens, and sessions (Ctrl+K or `/palette`)
+- **Model picker** - Switch LLM providers interactively
+- **Session management** - Auto-save on quit, `/save`, `/load`, `/sessions`, session picker (Ctrl+S)
+- **Token tracking** - Per-model pricing for 9 models across 8 providers via `/cost`
+- **Plan mode** - Bookmark messages without sending to LLM (`/plan`)
+- **Hotkey navigation** - Ctrl+D (dashboard), Ctrl+K (palette), Ctrl+S (sessions), Escape (back)
+- **Tab completion** - Type `/` and Tab to auto-complete slash commands
+- **Progress panel** - Visual progress bars for long operations (extension scanning, gem ops)
 - **Second-run flow** - Skips onboarding, re-scans environment, drops into chat
 
 ## Installation
@@ -35,6 +42,7 @@ brew install legion
 
 ```bash
 legion-tty
+legion-tty --skip-rain    # skip digital rain animation
 ```
 
 ### Via LegionIO CLI
@@ -56,7 +64,7 @@ legion chat prompt "explain async cognition"
 
 | Command | Description |
 |---------|-------------|
-| `/help` | Show all commands |
+| `/help` | Show all commands and hotkeys |
 | `/quit` | Exit (auto-saves session) |
 | `/clear` | Clear message history |
 | `/model <name>` | Switch LLM model at runtime |
@@ -69,6 +77,23 @@ legion chat prompt "explain async cognition"
 | `/save [name]` | Save current session |
 | `/load <name>` | Load a saved session |
 | `/sessions` | List all saved sessions |
+| `/system <prompt>` | Set or override system prompt |
+| `/delete <session>` | Delete a saved session |
+| `/plan` | Toggle read-only bookmark mode |
+| `/palette` | Open command palette (fuzzy search) |
+| `/extensions` | Browse installed LEX extensions |
+| `/config` | View and edit settings files |
+
+## Hotkeys
+
+| Key | Action |
+|-----|--------|
+| Ctrl+D | Toggle dashboard |
+| Ctrl+K | Open command palette |
+| Ctrl+S | Open session picker |
+| Ctrl+L | Refresh screen |
+| Escape | Go back / dismiss overlay |
+| Tab | Auto-complete slash commands |
 
 ## Architecture
 
@@ -84,16 +109,23 @@ legion-tty
     Onboarding           # First-run wizard (rain -> intro -> wizard -> reveal)
     Chat                 # AI chat REPL with streaming + slash commands
     Dashboard            # Operational status panels
+    Extensions           # LEX gem browser by category
+    Config               # Settings file viewer/editor
 
   Components/
     DigitalRain          # Matrix-style falling characters
-    InputBar             # Prompt line with thinking indicator
-    MessageStream        # Scrollable message history
-    StatusBar            # Model, tokens, cost, session display
+    InputBar             # Prompt line with tab completion + thinking indicator
+    MessageStream        # Scrollable message history with markdown rendering
+    StatusBar            # Model, plan mode, thinking, tokens, cost, session
     ToolPanel            # Expandable tool use panels
     MarkdownView         # TTY::Markdown rendering
     WizardPrompt         # TTY::Prompt wrappers
-    TokenTracker         # Token counting and cost estimation
+    TokenTracker         # Per-model token counting and cost estimation
+    CommandPalette       # Fuzzy-search command/screen/session overlay
+    ModelPicker          # LLM provider/model selection
+    SessionPicker        # Session list and selection
+    TableView            # TTY::Table wrapper
+    ProgressPanel        # TTY::ProgressBar wrapper
 
   Background/
     Scanner              # Service port probing, git repo discovery, shell history
@@ -101,20 +133,11 @@ legion-tty
     KerberosProbe        # klist + LDAP profile resolution
 ```
 
-## Comparison
-
-| Feature | legion-tty | Claude Code | Codex CLI |
-|---------|-----------|-------------|-----------|
-| Onboarding wizard | Yes (identity detection) | No (API key only) | No |
-| Streaming chat | Yes | Yes | Yes |
-| Tool use panels | Yes | Yes | Yes |
-| Dashboard | Yes (services, extensions) | No | No |
-| Session persistence | Yes | Yes (conversations) | No |
-| Environment scanning | Yes (services, repos, history) | Yes (git context) | Yes (git context) |
-| Extension ecosystem | Yes (LEX gems) | Yes (MCP servers) | Yes (tools) |
-| Identity probing | Yes (Kerberos, GitHub, LDAP) | No | No |
-| Token/cost tracking | Yes | Yes | Yes |
-| Hotkey navigation | Yes | Yes | No |
+## LLM Integration
+
+legion-tty uses **Legion::LLM exclusively** for all LLM operations. No direct RubyLLM calls. If Legion::LLM is not available or not started, the chat shell runs without LLM (commands still work, messages show "LLM not configured").
+
+The boot sequence mirrors `Legion::Service`: logging -> settings -> crypt -> resolve_secrets -> LLM merge -> start.
 
 ## Configuration
 
@@ -131,8 +154,8 @@ Boot logs go to `~/.legionio/logs/tty-boot.log`.
 
 ```bash
 bundle install
-bundle exec rspec
-bundle exec rubocop
+bundle exec rspec       # 598 examples, 0 failures
+bundle exec rubocop     # 68 files, 0 offenses
 ```
 
 ## License

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/input_bar.rb

@@ -6,8 +6,11 @@ module Legion
   module TTY
     module Components
       class InputBar
-        def initialize(name: 'User', reader: nil)
+        attr_reader :completions
+
+        def initialize(name: 'User', reader: nil, completions: [])
           @name = name
+          @completions = completions
           @reader = reader || build_default_reader
           @thinking = false
         end
@@ -32,14 +35,47 @@ module Legion
           @thinking
         end
 
+        def complete(partial)
+          return [] if partial.nil? || partial.empty?
+
+          @completions.select { |c| c.start_with?(partial) }.sort
+        end
+
         private
 
         def build_default_reader
           require 'tty-reader'
-          ::TTY::Reader.new
+          reader = ::TTY::Reader.new
+          register_tab_completion(reader)
+          reader
         rescue LoadError
           nil
         end
+
+        def register_tab_completion(reader)
+          return if @completions.empty?
+
+          @tab_matches = []
+          @tab_index = 0
+
+          reader.on(:keypress) do |event|
+            handle_tab(event) if event.value == "\t"
+          end
+        end
+
+        def handle_tab(event)
+          line = event.line.text.to_s
+          matches = complete(line)
+          return if matches.empty?
+
+          if matches.size == 1
+            event.line.replace(matches.first)
+          else
+            @tab_matches = matches unless @tab_matches == matches
+            event.line.replace(@tab_matches[@tab_index % @tab_matches.size])
+            @tab_index += 1
+          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/progress_panel.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../theme'
+
+module Legion
+  module TTY
+    module Components
+      class ProgressPanel
+        attr_reader :title, :total, :current
+
+        def initialize(title:, total:, output: $stdout)
+          @title = title
+          @total = total
+          @current = 0
+          @output = output
+          @bar = build_bar
+        end
+
+        def advance(step = 1)
+          @current = [@current + step, @total].min
+          @bar&.advance(step)
+        end
+
+        def finish
+          remaining = @total - @current
+          @bar&.advance(remaining) if remaining.positive?
+          @current = @total
+        end
+
+        def finished?
+          @current >= @total
+        end
+
+        def percent
+          return 0 if @total.zero?
+
+          ((@current.to_f / @total) * 100).round(1)
+        end
+
+        def render(width: 80)
+          pct = percent
+          label = Theme.c(:accent, @title)
+          bar = build_render_bar(width, pct)
+          "#{label} [#{bar}] #{Theme.c(:secondary, "#{pct}%")}"
+        end
+
+        private
+
+        def build_render_bar(width, pct)
+          bar_width = [width - @title.length - 12, 10].max
+          filled = (bar_width * pct / 100.0).round
+          empty = bar_width - filled
+          Theme.c(:primary, '#' * filled) + Theme.c(:muted, '-' * empty)
+        end
+
+        def build_bar
+          require 'tty-progressbar'
+          ::TTY::ProgressBar.new(
+            "#{@title} [:bar] :percent",
+            total: @total,
+            output: @output,
+            width: 40
+          )
+        rescue LoadError
+          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