legion-tty 0.4.35 → 0.4.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31b8e7a6dcba6b0327573f361400407394b176b79a115a9e3547c6e38c6523eb
-  data.tar.gz: 3f5bf51a8520ca9ab668067a03033467f344020f851b6b6545273b739889135c
+  metadata.gz: f6aab5b9e38570a9072b676e7573506c5051693e503ff3861c1f7c042e836267
+  data.tar.gz: 412cd703adfd6117e87fb0a57820d8d01c60d2701dea9b2b0c6c30c5f0a44f06
 SHA512:
-  metadata.gz: 6b4606e9588d44d94142722851e0b16d2d31e39c3c3ce3054eca965eeac432cf36c79b9ffb2d50e6abf005a37076df1890548f29586a44656f4ce290faf7ef90
-  data.tar.gz: 8ac2d9587039192b05262e4ab285b7e1791d41f95c9d58990f04cadcc98113e576019a886fe1130e5ce2ef515f6e85d541c948ac2011f5eacc91ef55e5fd8343
+  metadata.gz: e6164b922a3e05f202cc8ae224ce0a8ebc84cba655ee333bfc74dfaf66f3ab62aeff4dfde49e624d7d40f26e0cb377a3ba36a20b0f03e0806f55f08e9efd43da
+  data.tar.gz: 37b23570482bc80906620439d165594bd436d56c87da0f13612729e8e5d06f26ebf786881c88b708236efb9af3d55f71c407e46051680479bd1f6c95940f1d68

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## [0.4.37] - 2026-03-26
+
+### Fixed
+- Token tracking uses `model_id` from RubyLLM::Message response (was incorrectly checking non-existent `model` method)
+- Initialize TokenTracker with actual model from LLM chat session when available
+- Guard against blank `model_id` in `track_response_tokens` — a nil `model_id` no longer overwrites the previously-set model with an empty string
+
+### Added
+- Daemon path token tracking via `track_daemon_tokens` (reads `meta[:tokens_in]`/`meta[:tokens_out]` from daemon response)
+- Extracted `update_status_bar_tokens` helper to DRY up status bar updates after tracking
+
+## [0.4.36] - 2026-03-26
+
+### Changed
+- Rebuild rendering engine with raw-mode event loop replacing synchronous readline blocking
+- App#run_loop uses character-by-character input via IO.select + $stdin.raw with manual escape sequence parsing
+- Differential rendering compares frame buffers line-by-line to eliminate screen flicker
+- Overlay compositing renders TTY::Box frames centered over screen content, persists until Escape
+- Key normalization maps raw escape sequences and control chars to symbols for dispatch
+- InputBar rewritten with handle_key line buffer for non-blocking single-key processing
+- Chat screen uses render/handle_input contract with page_up/page_down scroll
+- Streaming flag enables 50ms refresh during LLM streaming for responsive re-rendering
+- Hotkeys now use normalized symbol keys (:ctrl_d, :ctrl_l, :ctrl_k, :ctrl_s)
+- Screens (Dashboard, Extensions, Config) driven by App event loop instead of standalone blocking loops
+
 ## [0.4.35] - 2026-03-25
 
 ### Changed

data/README.md

@@ -2,7 +2,7 @@
 
 Rich terminal UI for the LegionIO async cognition engine.
 
-**Version**: 0.4.29
+**Version**: 0.4.35
 
 Think Claude Code meets Codex CLI, but for LegionIO: onboarding wizard with identity detection, streaming AI chat shell with 115 slash commands, operational dashboard, extensions browser, config editor, and session persistence - all rendered with the [tty-ruby](https://ttytoolkit.org/) gem ecosystem.
 

data/lib/legion/tty/app.rb

@@ -13,7 +13,21 @@ module Legion
     class App
       CONFIG_DIR = File.expand_path('~/.legionio/settings')
 
-      attr_reader :config, :credentials, :screen_manager, :hotkeys, :llm_chat
+      # Key normalization: raw escape sequences and control chars to symbols
+      KEY_MAP = {
+        "\e[A" => :up, "\e[B" => :down, "\e[C" => :right, "\e[D" => :left,
+        "\r" => :enter, "\n" => :enter, "\e" => :escape,
+        "\e[5~" => :page_up, "\e[6~" => :page_down,
+        "\e[H" => :home, "\eOH" => :home, "\e[F" => :end, "\eOF" => :end,
+        "\e[1~" => :home, "\e[4~" => :end,
+        "\x7f" => :backspace, "\b" => :backspace, "\t" => :tab,
+        "\x03" => :ctrl_c, "\x04" => :ctrl_d,
+        "\x01" => :ctrl_a, "\x05" => :ctrl_e,
+        "\x0B" => :ctrl_k, "\x0C" => :ctrl_l, "\x13" => :ctrl_s,
+        "\x15" => :ctrl_u
+      }.freeze
+
+      attr_reader :config, :credentials, :screen_manager, :hotkeys, :llm_chat, :input_bar
 
       def self.run(argv = [])
         opts = parse_argv(argv)
@@ -42,23 +56,59 @@ module Legion
         @screen_manager = ScreenManager.new
         @hotkeys = Hotkeys.new
         @llm_chat = nil
+        @input_bar = nil
+        @running = false
+        @prev_frame = []
+        @raw_mode = false
       end
 
       def start
         setup_hotkeys
-        if self.class.first_run?(config_dir: @config_dir)
-          run_onboarding
-        else
-          run_chat
+        run_onboarding if self.class.first_run?(config_dir: @config_dir)
+        setup_for_chat
+        run_loop
+      end
+
+      # Public: called by screens (e.g., Chat during LLM streaming) to force a re-render
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def render_frame
+        width = terminal_width
+        height = terminal_height
+        active = @screen_manager.active_screen
+        return unless active
+
+        has_input = active.respond_to?(:needs_input_bar?) && active.needs_input_bar?
+        screen_height = has_input ? height - 1 : height
+
+        lines = active.render(width, screen_height)
+        lines << @input_bar.render_line(width: width) if has_input && @input_bar
+
+        lines = lines[0, height] if lines.size > height
+        lines += Array.new(height - lines.size, '') if lines.size < height
+
+        lines = composite_overlay(lines, width, height) if @screen_manager.overlay
+
+        write_differential(lines, width)
+
+        if has_input && @input_bar
+          col = [@input_bar.cursor_column, width - 1].min
+          $stdout.print cursor.move_to(col, height - 1)
         end
+
+        $stdout.flush
+      rescue StandardError => e
+        Legion::Logging.warn("render_frame failed: #{e.message}") if defined?(Legion::Logging)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def setup_hotkeys
-        @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 }
+      # Temporarily exit raw mode for blocking prompts (TTY::Prompt, etc.)
+      def with_cooked_mode(&)
+        return yield unless @raw_mode
+
+        $stdout.print cursor.show
+        $stdin.cooked(&)
+        $stdout.print cursor.hide
+        @prev_frame = []
       end
 
       def toggle_dashboard
@@ -72,23 +122,273 @@ module Legion
         end
       end
 
+      def shutdown
+        @running = false
+        @screen_manager.teardown_all
+      end
+
+      private
+
+      # --- Boot ---
+
+      def setup_for_chat
+        rescan_environment
+        setup_llm
+        cfg = safe_config
+        name = cfg[:name] || 'User'
+        @input_bar = Components::InputBar.new(name: name, completions: Screens::Chat::SLASH_COMMANDS)
+        chat = Screens::Chat.new(self)
+        @screen_manager.push(chat)
+      end
+
+      # --- Event Loop ---
+
+      # rubocop:disable Metrics/AbcSize
+      def run_loop
+        require 'io/console'
+
+        @running = true
+        @raw_mode = true
+        $stdout.print cursor.hide
+        $stdout.print cursor.clear_screen
+
+        $stdin.raw do |raw_in|
+          while @running
+            render_frame
+            timeout = needs_refresh? ? 0.05 : nil
+            raw_key = read_raw_key(raw_in, timeout: timeout)
+            next unless raw_key
+
+            key = normalize_key(raw_key)
+            dispatch_key(key)
+          end
+        end
+      rescue Interrupt
+        nil
+      ensure
+        @raw_mode = false
+        $stdout.print cursor.show
+        $stdout.print cursor.move_to(0, terminal_height - 1)
+        $stdout.puts
+        shutdown
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def needs_refresh?
+        active = @screen_manager.active_screen
+        active.respond_to?(:streaming?) && active.streaming?
+      end
+
+      def normalize_key(raw)
+        KEY_MAP[raw] || raw
+      end
+
+      # --- Key Dispatch ---
+
+      def dispatch_key(key)
+        if key == :ctrl_c
+          @running = false
+          return
+        end
+
+        if key == :escape && @screen_manager.overlay
+          @screen_manager.dismiss_overlay
+          return
+        end
+
+        result = @hotkeys.handle(key)
+        if result
+          handle_hotkey_result(result)
+          return
+        end
+
+        active = @screen_manager.active_screen
+        return unless active
+
+        if active.respond_to?(:needs_input_bar?) && active.needs_input_bar? && @input_bar
+          dispatch_to_input_screen(active, key)
+        else
+          dispatch_to_screen(active, key)
+        end
+      end
+
+      def dispatch_to_input_screen(screen, key)
+        result = @input_bar.handle_key(key)
+        if result.is_a?(Array) && result[0] == :submit
+          screen_result = screen.handle_line(result[1])
+          handle_screen_result(screen_result)
+        elsif result == :pass
+          screen_result = screen.handle_input(key)
+          handle_screen_result(screen_result)
+        end
+      end
+
+      def dispatch_to_screen(screen, key)
+        result = screen.handle_input(key)
+        handle_screen_result(result)
+      end
+
+      def handle_screen_result(result)
+        case result
+        when :pop_screen then @screen_manager.pop
+        when :quit then @running = false
+        end
+      end
+
+      def handle_hotkey_result(result)
+        case result
+        when :command_palette
+          active = @screen_manager.active_screen
+          active.send(:handle_palette) if active.respond_to?(:handle_palette, true)
+        when :session_picker
+          active = @screen_manager.active_screen
+          active.send(:handle_sessions_picker) if active.respond_to?(:handle_sessions_picker, true)
+        end
+      end
+
+      # --- Raw Key Reading ---
+
+      def read_raw_key(io, timeout: nil)
+        return nil unless io.wait_readable(timeout)
+
+        c = io.getc
+        return nil unless c
+
+        return c unless c == "\e"
+
+        read_escape_sequence(io)
+      end
+
+      def read_escape_sequence(io)
+        return "\e" unless io.wait_readable(0.05)
+
+        c2 = io.getc
+        return "\e" unless c2
+
+        if c2 == '['
+          read_csi_sequence(io)
+        elsif c2 == 'O'
+          c3 = io.wait_readable(0.05) ? io.getc : nil
+          c3 ? "\eO#{c3}" : "\eO"
+        else
+          "\e#{c2}"
+        end
+      end
+
+      def read_csi_sequence(io)
+        seq = +"\e["
+        loop do
+          break unless io.wait_readable(0.05)
+
+          c = io.getc
+          break unless c
+
+          seq << c
+          break if c.ord.between?(0x40, 0x7E)
+        end
+        seq
+      end
+
+      # --- Rendering ---
+
+      # rubocop:disable Metrics/AbcSize
+      def composite_overlay(lines, width, height)
+        require 'tty-box'
+        text = @screen_manager.overlay.to_s
+        box_width = (width - 4).clamp(40, width)
+        box = ::TTY::Box.frame(
+          width: box_width,
+          padding: 1,
+          title: { top_left: ' Help ' },
+          border: :round
+        ) { text }
+
+        overlay_lines = box.split("\n")
+        start_row = [(height - overlay_lines.size) / 2, 0].max
+        left_pad = [(width - box_width) / 2, 0].max
+
+        result = lines.dup
+        overlay_lines.each_with_index do |ol, i|
+          row = start_row + i
+          next if row >= height
+
+          result[row] = (' ' * left_pad) + ol
+        end
+        result
+      rescue StandardError => e
+        Legion::Logging.warn("composite_overlay failed: #{e.message}") if defined?(Legion::Logging)
+        lines
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def write_differential(lines, width)
+        lines.each_with_index do |line, row|
+          next if @prev_frame[row] == line
+
+          $stdout.print cursor.move_to(0, row)
+          $stdout.print line
+          plain_len = strip_ansi(line).length
+          $stdout.print(' ' * (width - plain_len)) if plain_len < width
+        end
+        @prev_frame = lines.dup
+      end
+
+      def strip_ansi(str)
+        str.to_s.gsub(/\e\[[0-9;]*m/, '')
+      end
+
+      def cursor
+        require 'tty-cursor'
+        ::TTY::Cursor
+      end
+
+      def terminal_width
+        require 'tty-screen'
+        ::TTY::Screen.width
+      rescue StandardError
+        80
+      end
+
+      def terminal_height
+        require 'tty-screen'
+        ::TTY::Screen.height
+      rescue StandardError
+        24
+      end
+
+      # --- Hotkeys ---
+
+      def setup_hotkeys
+        @hotkeys.register(:ctrl_d, 'Toggle dashboard (Ctrl+D)') do
+          toggle_dashboard
+          :handled
+        end
+        @hotkeys.register(:ctrl_l, 'Refresh screen (Ctrl+L)') do
+          @prev_frame = []
+          :handled
+        end
+        @hotkeys.register(:ctrl_k, 'Command palette (Ctrl+K)') { :command_palette }
+        @hotkeys.register(:ctrl_s, 'Session picker (Ctrl+S)') { :session_picker }
+      end
+
+      # --- Onboarding ---
+
       def run_onboarding
         onboarding = Screens::Onboarding.new(self, skip_rain: @skip_rain)
         data = onboarding.activate
         save_config(data)
         @config = load_config
         @credentials = load_credentials
-        run_chat
       end
 
-      def run_chat
-        rescan_environment
-        setup_llm
-        chat = Screens::Chat.new(self)
-        @screen_manager.push(chat)
-        chat.run
+      def save_config(data)
+        FileUtils.mkdir_p(@config_dir)
+        save_identity(data)
+        save_credentials(data)
       end
 
+      # --- LLM Setup ---
+
       def setup_llm
         boot_legion_subsystems
         @llm_chat = try_settings_llm
@@ -120,25 +420,10 @@ module Legion
           nil
         end
       end
-
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      def save_config(data)
-        FileUtils.mkdir_p(@config_dir)
-        save_identity(data)
-        save_credentials(data)
-      end
-
-      def shutdown
-        @screen_manager.teardown_all
-      end
-
-      private
-
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
       def boot_legion_subsystems
-        # Follow the same init order as Legion::Service:
-        # 1. logging  2. settings  3. crypt  4. resolve secrets  5. LLM merge
         require 'legion/logging'
         Legion::Logging.setup(log_level: 'error', level: 'error', trace: false)
 
@@ -197,6 +482,13 @@ module Legion
         nil
       end
 
+      # --- Config & Credentials ---
+
+      def safe_config
+        cfg = @config
+        cfg.is_a?(Hash) ? cfg : {}
+      end
+
       # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def save_identity(data)
         identity = {
@@ -205,7 +497,6 @@ module Legion
           created_at: Time.now.iso8601
         }
 
-        # Kerberos identity
         if data[:identity].is_a?(Hash)
           id = data[:identity]
           identity[:kerberos] = {
@@ -226,7 +517,6 @@ module Legion
           }.compact
         end
 
-        # GitHub profile
         if data[:github].is_a?(Hash) && data[:github][:username]
           gh = data[:github]
           identity[:github] = {
@@ -237,7 +527,6 @@ module Legion
           }.compact
         end
 
-        # Environment scan
         if data[:scan].is_a?(Hash)
           scan = data[:scan]
           services = scan[:services]&.values&.select { |s| s[:running] }&.map { |s| s[:name] } || []

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

@@ -5,13 +5,20 @@ require_relative '../theme'
 module Legion
   module TTY
     module Components
-      class InputBar
-        attr_reader :completions
+      class InputBar # rubocop:disable Metrics/ClassLength
+        attr_reader :completions, :buffer
 
         def initialize(name: 'User', reader: nil, completions: [])
           @name = name
           @completions = completions
-          @reader = reader || build_default_reader
+          @buffer = +''
+          @cursor_pos = 0
+          @history_entries = []
+          @history_index = nil
+          @saved_buffer = nil
+          @tab_matches = []
+          @tab_index = 0
+          @legacy_reader = reader
           @thinking = false
         end
 
@@ -19,20 +26,80 @@ module Legion
           "#{Theme.c(:accent, @name)} #{Theme.c(:primary, '>')} "
         end
 
-        def read_line
-          @reader.read_line(prompt_string)
+        def prompt_plain_length
+          @name.length + 3
         end
 
-        def show_thinking
-          @thinking = true
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+        def handle_key(key)
+          case key
+          when :enter
+            submit_line
+          when :backspace
+            handle_backspace
+          when :tab
+            handle_tab_key
+          when :up
+            history_prev
+          when :down
+            history_next
+          when :right
+            @cursor_pos = [@cursor_pos + 1, @buffer.length].min
+            :handled
+          when :left
+            @cursor_pos = [@cursor_pos - 1, 0].max
+            :handled
+          when :home, :ctrl_a
+            @cursor_pos = 0
+            :handled
+          when :end, :ctrl_e
+            @cursor_pos = @buffer.length
+            :handled
+          when :ctrl_u
+            @buffer = +''
+            @cursor_pos = 0
+            :handled
+          when String
+            insert_char(key)
+          else
+            :pass
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+
+        def render_line(width:)
+          avail = [width - prompt_plain_length, 1].max
+          display = if @buffer.length > avail
+                      @buffer[(@buffer.length - avail)..]
+                    else
+                      @buffer
+                    end
+          "#{prompt_string}#{display}"
         end
 
-        def clear_thinking
-          @thinking = false
+        def cursor_column
+          prompt_plain_length + @cursor_pos
         end
 
-        def thinking?
-          @thinking
+        def current_line
+          @buffer.dup
+        end
+
+        def clear_buffer
+          @buffer = +''
+          @cursor_pos = 0
+        end
+
+        def history
+          @history_entries.dup
+        end
+
+        # Backward-compatible blocking read for onboarding/tests
+        def read_line
+          reader = @legacy_reader || build_legacy_reader
+          reader&.read_line(prompt_string)
+        rescue Interrupt
+          nil
         end
 
         def complete(partial)
@@ -41,47 +108,104 @@ module Legion
           @completions.select { |c| c.start_with?(partial) }.sort
         end
 
-        def history
-          return [] unless @reader.respond_to?(:history)
-
-          @reader.history.to_a
+        def show_thinking
+          @thinking = true
         end
 
-        private
+        def clear_thinking
+          @thinking = false
+        end
 
-        def build_default_reader
-          require 'tty-reader'
-          reader = ::TTY::Reader.new(history_cycle: true)
-          register_tab_completion(reader)
-          reader
-        rescue LoadError => e
-          Legion::Logging.debug("tty-reader not available: #{e.message}") if defined?(Legion::Logging)
-          nil
+        def thinking?
+          @thinking
         end
 
-        def register_tab_completion(reader)
-          return if @completions.empty?
+        private
 
+        def submit_line
+          line = @buffer.dup
+          @history_entries << line unless line.strip.empty? || line == @history_entries.last
+          @buffer = +''
+          @cursor_pos = 0
+          @history_index = nil
+          @saved_buffer = nil
           @tab_matches = []
           @tab_index = 0
+          [:submit, line]
+        end
 
-          reader.on(:keypress) do |event|
-            handle_tab(event) if event.value == "\t"
-          end
+        def handle_backspace
+          return :handled if @cursor_pos.zero?
+
+          @buffer.slice!(@cursor_pos - 1)
+          @cursor_pos -= 1
+          @tab_matches = []
+          :handled
         end
 
-        def handle_tab(event)
-          line = event.line.text.to_s
-          matches = complete(line)
-          return if matches.empty?
+        def handle_tab_key
+          return :handled if @buffer.empty?
+
+          matches = complete(@buffer)
+          return :handled if matches.empty?
 
           if matches.size == 1
-            event.line.replace(matches.first)
+            @buffer = "#{matches.first} "
+            @cursor_pos = @buffer.length
           else
             @tab_matches = matches unless @tab_matches == matches
-            event.line.replace(@tab_matches[@tab_index % @tab_matches.size])
+            @buffer = +@tab_matches[@tab_index % @tab_matches.size].to_s
+            @cursor_pos = @buffer.length
             @tab_index += 1
           end
+          :handled
+        end
+
+        def history_prev
+          return :handled if @history_entries.empty?
+
+          if @history_index.nil?
+            @saved_buffer = @buffer.dup
+            @history_index = @history_entries.size - 1
+          elsif @history_index.positive?
+            @history_index -= 1
+          else
+            return :handled
+          end
+          @buffer = +@history_entries[@history_index].to_s
+          @cursor_pos = @buffer.length
+          :handled
+        end
+
+        def history_next
+          return :handled if @history_index.nil?
+
+          if @history_index < @history_entries.size - 1
+            @history_index += 1
+            @buffer = +@history_entries[@history_index].to_s
+          else
+            @history_index = nil
+            @buffer = +(@saved_buffer || '')
+            @saved_buffer = nil
+          end
+          @cursor_pos = @buffer.length
+          :handled
+        end
+
+        def insert_char(key)
+          return :pass unless key.is_a?(String) && key.length == 1 && key.ord >= 32
+
+          @buffer.insert(@cursor_pos, key)
+          @cursor_pos += 1
+          @tab_matches = []
+          :handled
+        end
+
+        def build_legacy_reader
+          require 'tty-reader'
+          ::TTY::Reader.new(history_cycle: true)
+        rescue LoadError
+          nil
         end
       end
     end

data/lib/legion/tty/hotkeys.rb

@@ -11,15 +11,12 @@ module Legion
         @bindings[key] = { description: description, action: block }
       end
 
-      # rubocop:disable Naming/PredicateMethod
       def handle(key)
         binding_entry = @bindings[key]
-        return false unless binding_entry
+        return nil unless binding_entry
 
         binding_entry[:action].call
-        true
       end
-      # rubocop:enable Naming/PredicateMethod
 
       def list
         @bindings.map { |key, b| { key: key, description: b[:description] } }

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

@@ -21,6 +21,10 @@ module Legion
           :pass
         end
 
+        def needs_input_bar?
+          false
+        end
+
         def teardown; end
       end
     end

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

@@ -65,7 +65,10 @@ module Legion
               current_provider: safe_config[:provider],
               current_model: @llm_chat.respond_to?(:model) ? @llm_chat.model.to_s : nil
             )
-            selection = picker.select_with_prompt(output: @output)
+            selection = nil
+            @app.with_cooked_mode do
+              selection = picker.select_with_prompt(output: @output)
+            end
             return unless selection
 
             switch_model(selection[:provider])

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

@@ -122,7 +122,10 @@ module Legion
           def handle_palette
             require_relative '../components/command_palette'
             palette = Components::CommandPalette.new(session_store: @session_store)
-            selection = palette.select_with_prompt(output: @output)
+            selection = nil
+            @app.with_cooked_mode do
+              selection = palette.select_with_prompt(output: @output)
+            end
             return :handled unless selection
 
             if selection.start_with?('/')
@@ -176,7 +179,7 @@ module Legion
           end
 
           def handle_history
-            entries = @input_bar.history
+            entries = @app.respond_to?(:input_bar) && @app.input_bar ? @app.input_bar.history : []
             if entries.empty?
               @message_stream.add_message(role: :system, content: 'No input history.')
             else

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

@@ -68,15 +68,16 @@ module Legion
         attr_reader :message_stream, :status_bar
 
         # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        def initialize(app, output: $stdout, input_bar: nil)
+        def initialize(app, output: $stdout, input_bar: nil) # rubocop:disable Lint/UnusedMethodArgument
           super(app)
           @output = output
           @message_stream = Components::MessageStream.new
           @status_bar = Components::StatusBar.new
-          @running = false
-          @input_bar = input_bar || build_default_input_bar
           @llm_chat = app.respond_to?(:llm_chat) ? app.llm_chat : nil
-          @token_tracker = Components::TokenTracker.new(provider: detect_provider)
+          @token_tracker = Components::TokenTracker.new(
+            provider: detect_provider,
+            model: @llm_chat.respond_to?(:model) ? @llm_chat.model.to_s : nil
+          )
           @session_store = SessionStore.new
           @session_name = 'default'
           @plan_mode = false
@@ -105,12 +106,12 @@ module Legion
           @timer_thread = nil
           @message_prefix = nil
           @message_suffix = nil
+          @streaming = false
         end
 
         # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def activate
-          @running = true
           cfg = safe_config
           @status_bar.update(model: cfg[:provider], session: 'default')
           setup_system_prompt
@@ -121,34 +122,25 @@ module Legion
           @status_bar.update(message_count: @message_stream.messages.size)
         end
 
-        def running?
-          @running
+        def needs_input_bar?
+          true
         end
 
-        # rubocop:disable Metrics/AbcSize
-        def run
-          activate
-          while @running
-            render_screen
-            input = read_input
-            break if input.nil?
-
-            if @app.respond_to?(:screen_manager) && @app.screen_manager.overlay
-              @app.screen_manager.dismiss_overlay
-              next
-            end
+        def streaming?
+          @streaming
+        end
 
-            result = handle_slash_command(input)
-            if result == :quit
-              auto_save_session
-              @running = false
-              break
-            elsif result.nil?
-              handle_user_message(input) unless input.strip.empty?
-            end
+        def handle_line(line)
+          return :handled if line.strip.empty?
+
+          result = handle_slash_command(line)
+          if result == :quit
+            auto_save_session
+            return :quit
           end
+          handle_user_message(line) if result.nil?
+          :handled
         end
-        # rubocop:enable Metrics/AbcSize
 
         def handle_slash_command(input)
           return nil unless input.start_with?('/')
@@ -179,7 +171,6 @@ module Legion
           end
           @status_bar.update(message_count: @message_stream.messages.size)
           check_autosave
-          render_screen
         end
 
         def send_to_llm(message)
@@ -207,11 +198,11 @@ module Legion
 
         def handle_input(key)
           case key
-          when :up
-            @message_stream.scroll_up
+          when :page_up
+            @message_stream.scroll_up(10)
             :handled
-          when :down
-            @message_stream.scroll_down
+          when :page_down
+            @message_stream.scroll_down(10)
             :handled
           else
             :pass
@@ -263,6 +254,7 @@ module Legion
             parser = build_tool_call_parser
             parser.feed(result[:response])
             parser.flush
+            track_daemon_tokens(result)
           when :error
             err = result.dig(:error, :message) || 'Unknown error'
             @message_stream.append_streaming("\n[Daemon error: #{err}]")
@@ -279,7 +271,8 @@ module Legion
           return unless @llm_chat
 
           @status_bar.update(thinking: true)
-          render_screen
+          @streaming = true
+          @app.render_frame if @app.respond_to?(:render_frame)
           start_time = Time.now
           response_text = +''
           parser = build_tool_call_parser
@@ -289,13 +282,15 @@ module Legion
               response_text << chunk.content
               parser.feed(chunk.content)
             end
-            render_screen
+            @app.render_frame if @app.respond_to?(:render_frame)
           end
           parser.flush
           record_response_time(Time.now - start_time)
           @status_bar.update(thinking: false)
           track_response_tokens(response)
           speak_response(response_text) if @speak_mode
+        ensure
+          @streaming = false
         end
         # rubocop:enable Metrics/AbcSize
 
@@ -360,63 +355,6 @@ module Legion
           cfg.is_a?(Hash) ? cfg : {}
         end
 
-        def render_screen
-          require 'tty-cursor'
-          lines = render(terminal_width, terminal_height - 1)
-          @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 => e
-          Legion::Logging.warn("render_overlay failed: #{e.message}") if defined?(Legion::Logging)
-          nil
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        def read_input
-          return nil unless @input_bar.respond_to?(:read_line)
-          return read_multiline_input if @multiline_mode
-
-          @input_bar.read_line
-        rescue Interrupt => e
-          Legion::Logging.debug("read_input interrupted: #{e.message}") if defined?(Legion::Logging)
-          nil
-        end
-
-        def read_multiline_input
-          lines = []
-          loop do
-            line = @input_bar.read_line
-            return nil if line.nil? && lines.empty?
-            break if line.nil? || line.empty?
-
-            lines << line
-          end
-          lines.empty? ? nil : lines.join("\n")
-        rescue Interrupt => e
-          Legion::Logging.debug("read_multiline_input interrupted: #{e.message}") if defined?(Legion::Logging)
-          nil
-        end
-
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def dispatch_slash(cmd, input)
           case cmd
@@ -641,12 +579,6 @@ module Legion
           )
         end
 
-        def build_default_input_bar
-          cfg = safe_config
-          name = cfg[:name] || 'User'
-          Components::InputBar.new(name: name, completions: SLASH_COMMANDS)
-        end
-
         def terminal_width
           require 'tty-screen'
           ::TTY::Screen.width
@@ -674,12 +606,31 @@ 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
+          raw_model = response.respond_to?(:model_id) ? response.model_id.to_s : nil
+          model_id = raw_model && !raw_model.empty? ? raw_model : nil
+          input_tokens = response.input_tokens.to_i
+          output_tokens = response.respond_to?(:output_tokens) ? response.output_tokens.to_i : 0
           @token_tracker.track(
-            input_tokens: response.input_tokens.to_i,
-            output_tokens: response.output_tokens.to_i,
+            input_tokens: input_tokens,
+            output_tokens: output_tokens,
             model: model_id
           )
+          update_status_bar_tokens
+        end
+
+        def track_daemon_tokens(result)
+          meta = result[:meta]
+          return unless meta.is_a?(Hash) && (meta[:tokens_in] || meta[:tokens_out])
+
+          @token_tracker.track(
+            input_tokens: meta[:tokens_in].to_i,
+            output_tokens: meta[:tokens_out].to_i,
+            model: meta[:model]&.to_s
+          )
+          update_status_bar_tokens
+        end
+
+        def update_status_bar_tokens
           @status_bar.update(
             tokens: @token_tracker.total_input_tokens + @token_tracker.total_output_tokens,
             cost: @token_tracker.total_cost

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.35'
+    VERSION = '0.4.37'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.4.35
+  version: 0.4.37
 platform: ruby
 authors:
 - Esity