legion-tty 0.4.39 → 0.4.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a46889a85e5da8000964e9ac91d0c8e8fba67591fc12ca4bc8a4057339ed09b
-  data.tar.gz: d769157e7b76054bc01148650474b0e621a22173428628ce2edf41e2c58aafc8
+  metadata.gz: 2e5ecb9de86922a5a3d4dd3b3eca6b4f7864103c89399a8a945bbae95e749814
+  data.tar.gz: 0d25f75d79303fd7a42a9fbf125768503c48f16e5c749b799cd2013d68bae99a
 SHA512:
-  metadata.gz: cfb3a079a43835daf8cb922627ccb2f19e36c9fcfd0577f9cfa9a468f38d0ff1f658eaaeeda82ff202b6213013442e798cca11e9b61ca544ce171173ada7ce8e
-  data.tar.gz: 4bc9d5d5e2b7173740d4d1a72193e31d77c7bd22bfa745cd39861704804d2f78489dafc915c5a35b916252a554b80df685b4e0bb6136f0cc1bef356b24e57a0f
+  metadata.gz: 804bc560650b61a6987a8f9d4d02cd7a315caeaccd1823f1b11a4e1b1fe024fc0eb37a35c59bafe654c0738f2e201af9b04d7274bd9c7d8df02b563c6551336b
+  data.tar.gz: 15ab28737a1677ae28285400d1e9ae6b794f1ea021e4cc7c194e949e59a97df56c054419d21fd351c70ea97636608d09a8a6737ca7a690e17b398e87531e6c1c

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.4.41] - 2026-03-31
+
+### Added
+- `KeybindingManager`: context-aware keybinding system with named contexts (`global`, `chat`, `dashboard`, `extensions`, `config`, `command_palette`, `session_picker`, `history`), chord sequence support (`@pending_chord` state machine), `resolve(key, active_contexts:)` method, and user-customizable overrides via `~/.legionio/keybindings.json` (closes #10)
+- `Legion::TTY::Notify`: OS-level terminal notification module with auto-detection of iTerm2 (OSC 9), Kitty (`kitten notify`), Ghostty (OSC 99), Linux (`notify-send`), macOS (`osascript`), and bell fallback; settings integration via `notifications.terminal.enabled` / `notifications.terminal.backend` (closes #11)
+
+### Changed
+- `SessionStore#load` now normalizes both TTY v1 format and CLI legacy format (RubyLLM `model`+`stats`+`summary` fields) into a canonical `{ role: :symbol, content:, tool_panels: [] }` shape; fills in default `version`, `metadata`, `name`, and `saved_at` when absent (closes #9)
+- `SessionStore::SESSION_DIR` confirmed as `~/.legionio/sessions/` (no legacy `~/.legion/` references)
+
+## [0.4.40] - 2026-03-28
+
+### Changed
+- All LLM calls in the chat screen now route exclusively through the LegionIO daemon API (`POST /api/llm/inference`) via `Legion::TTY::DaemonClient.inference`
+- Removed soft fallback to raw RubyLLM (`send_via_direct` / `@llm_chat.ask`) — if the daemon is not running, a clear error is displayed: "LegionIO daemon is not running. Start it with: legionio start"
+- Fixed `send_via_daemon`: was calling `Legion::LLM.ask` (which never returns `{status: :done}`) and falling through to direct on every call; now calls `DaemonClient.inference` with the full conversation history
+- Fixed `daemon_available?`: was checking `Legion::LLM::DaemonClient` (an unrelated module); now calls `Legion::TTY::DaemonClient.available?` directly
+- `try_settings_llm` in `App` no longer creates a raw `Legion::LLM.chat` session; daemon availability is logged instead
+- System prompt is now injected per-request as part of the messages array sent to `/api/llm/inference`, not pre-set on a session object
+- Added `DaemonClient.inference` method: `POST /api/llm/inference` with messages array, tools, model, provider; returns `{status: :ok/:error/:unavailable, data:}`
+- Added `build_inference_messages`: assembles system + conversation history + current message for the inference call
+- Added `track_inference_tokens`: tracks input/output tokens from the `data` hash returned by `/api/llm/inference`
+
 ## [0.4.39] - 2026-03-28
 
 ### Fixed

data/lib/legion/tty/app.rb

@@ -468,15 +468,16 @@ module Legion
       end
 
       def try_settings_llm
-        return nil unless defined?(Legion::LLM)
-
-        Legion::LLM.start unless Legion::LLM.started?
-        return nil unless Legion::LLM.started?
-
-        provider = Legion::LLM.settings[:default_provider]
-        return nil unless provider
-
-        Legion::LLM.chat(provider: provider, caller: { source: 'tty', screen: 'chat' })
+        # All LLM calls route through the LegionIO daemon API.
+        # No raw RubyLLM session is created here — nil signals "use daemon path".
+        if Legion::TTY::DaemonClient.available?
+          Legion::Logging.debug('TTY: daemon available, LLM routed through daemon') if defined?(Legion::Logging)
+        elsif defined?(Legion::Logging)
+          if defined?(Legion::Logging)
+            Legion::Logging.warn('TTY: daemon not running; LLM unavailable until daemon starts')
+          end
+        end
+        nil
       rescue StandardError => e
         Legion::Logging.warn("try_settings_llm failed: #{e.message}") if defined?(Legion::Logging)
         nil

data/lib/legion/tty/daemon_client.rb

@@ -10,6 +10,7 @@ module Legion
     module DaemonClient
       SUCCESS_CODES = [200, 201, 202].freeze
 
+      # rubocop:disable Metrics/ClassLength
       class << self
         def configure(daemon_url: 'http://127.0.0.1:4567', cache_file: nil, timeout: 5)
           @daemon_url = daemon_url
@@ -89,6 +90,19 @@ module Legion
           nil
         end
 
+        def inference(messages:, tools: [], model: nil, provider: nil, timeout: 120)
+          response = post_inference(messages: messages, tools: tools, model: model,
+                                    provider: provider, timeout: timeout)
+          return inference_error_result(response) unless SUCCESS_CODES.include?(response.code.to_i)
+
+          body = Legion::JSON.load(response.body)
+          data = body[:data] || body
+          { status: :ok, data: data }
+        rescue StandardError => e
+          Legion::Logging.warn("inference failed: #{e.message}") if defined?(Legion::Logging)
+          { status: :unavailable, error: { message: e.message } }
+        end
+
         def reset!
           @daemon_url = nil
           @cache_file = nil
@@ -98,6 +112,29 @@ module Legion
 
         private
 
+        def post_inference(messages:, tools:, model:, provider:, timeout:)
+          uri = URI("#{daemon_url}/api/llm/inference")
+          payload = Legion::JSON.dump({ messages: messages, tools: tools,
+                                        model: model, provider: provider }.compact)
+          http_timeout = [timeout, @timeout || 5].max
+          req = Net::HTTP::Post.new(uri)
+          req['Content-Type'] = 'application/json'
+          req.body = payload
+          Net::HTTP.start(uri.hostname, uri.port,
+                          open_timeout: @timeout || 5,
+                          read_timeout: http_timeout) { |h| h.request(req) }
+        end
+
+        def inference_error_result(response)
+          body = begin
+            Legion::JSON.load(response.body)
+          rescue StandardError
+            {}
+          end
+          err = body.dig(:error, :message) || body.dig(:data, :error, :message) || "HTTP #{response.code}"
+          { status: :error, error: { message: err } }
+        end
+
         def daemon_url
           @daemon_url || 'http://127.0.0.1:4567'
         end
@@ -119,6 +156,7 @@ module Legion
           nil
         end
       end
+      # rubocop:enable Metrics/ClassLength
     end
   end
 end

data/lib/legion/tty/keybinding_manager.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'legion/json'
+require 'fileutils'
+
+module Legion
+  module TTY
+    # KeybindingManager — context-aware keybinding system with chord support and user customization.
+    #
+    # Named contexts:
+    #   :global, :chat, :dashboard, :extensions, :config, :command_palette, :session_picker, :history
+    #
+    # Chord sequences: two-key combos stored as "key1+key2" strings. Set @pending_chord between
+    # key presses; the second key resolves the chord action.
+    #
+    # User overrides loaded from ~/.legionio/keybindings.json at boot.
+    class KeybindingManager
+      CONTEXTS = %i[global chat dashboard extensions config command_palette session_picker history].freeze
+
+      OVERRIDES_PATH = File.expand_path('~/.legionio/keybindings.json')
+
+      DEFAULT_BINDINGS = {
+        ctrl_d: { contexts: %i[global chat], action: :toggle_dashboard, description: 'Toggle dashboard (Ctrl+D)' },
+        ctrl_k: { contexts: %i[global chat], action: :command_palette, description: 'Open command palette (Ctrl+K)' },
+        ctrl_s: { contexts: %i[global chat], action: :session_picker, description: 'Open session picker (Ctrl+S)' },
+        ctrl_l: { contexts: %i[global chat dashboard], action: :refresh, description: 'Refresh screen (Ctrl+L)' },
+        escape: { contexts: CONTEXTS, action: :back, description: 'Go back / dismiss overlay (Escape)' },
+        tab: { contexts: %i[chat], action: :autocomplete, description: 'Auto-complete (Tab)' },
+        ctrl_c: { contexts: CONTEXTS, action: :interrupt, description: 'Interrupt / quit (Ctrl+C)' }
+      }.freeze
+
+      def initialize(overrides_path: OVERRIDES_PATH)
+        @overrides_path = overrides_path
+        @bindings = {}
+        @pending_chord = nil
+        load_defaults
+        load_user_overrides
+      end
+
+      # Resolve a key press given the currently active contexts.
+      #
+      # @param key [Symbol, String] normalized key (e.g. :ctrl_d, :escape)
+      # @param active_contexts [Array<Symbol>] contexts currently in scope (most specific last)
+      # @return [Symbol, nil] action name, or nil if no binding matches
+      def resolve(key, active_contexts: [:global])
+        key_sym = key.to_s.to_sym
+
+        # Chord resolution: if a chord is pending, try to complete it
+        if @pending_chord
+          chord = :"#{@pending_chord}+#{key_sym}"
+          @pending_chord = nil
+          return action_for(chord, active_contexts)
+        end
+
+        # Check if this key starts a chord
+        if chord_starter?(key_sym)
+          @pending_chord = key_sym
+          return :chord_pending
+        end
+
+        action_for(key_sym, active_contexts)
+      end
+
+      # Cancel any in-progress chord sequence.
+      def cancel_chord
+        @pending_chord = nil
+      end
+
+      # Whether a chord is currently waiting for its second key.
+      def chord_pending?
+        !@pending_chord.nil?
+      end
+
+      # Register or override a single binding.
+      # @param key [Symbol, String] normalized key
+      # @param action [Symbol] action name
+      # @param contexts [Array<Symbol>] applicable contexts (:global means all)
+      # @param description [String]
+      def bind(key, action:, contexts: [:global], description: '')
+        @bindings[key.to_s.to_sym] = { contexts: contexts, action: action, description: description }
+      end
+
+      # Remove a binding.
+      def unbind(key)
+        @bindings.delete(key.to_s.to_sym)
+      end
+
+      # All registered bindings as an array of hashes.
+      def list
+        @bindings.map do |key, b|
+          { key: key, action: b[:action], contexts: b[:contexts], description: b[:description] }
+        end
+      end
+
+      # Reload default bindings (resets user overrides).
+      def load_defaults
+        @bindings = {}
+        DEFAULT_BINDINGS.each do |key, binding|
+          @bindings[key] = binding.dup
+        end
+      end
+
+      # Load user overrides from ~/.legionio/keybindings.json.
+      # File format: { "ctrl_d": { "action": "toggle_dashboard", "contexts": ["global"], "description": "..." } }
+      def load_user_overrides
+        return unless File.exist?(@overrides_path)
+
+        raw = Legion::JSON.parse(File.read(@overrides_path), symbolize_names: true)
+        raw.each { |key, cfg| apply_override(key, cfg) }
+      rescue Legion::JSON::ParseError => e
+        Legion::Logging.warn("keybindings load failed: #{e.message}") if defined?(Legion::Logging)
+      end
+
+      private
+
+      def action_for(key_sym, active_contexts)
+        binding_entry = @bindings[key_sym]
+        return nil unless binding_entry
+
+        binding_contexts = binding_entry[:contexts]
+        return binding_entry[:action] if binding_contexts.include?(:global)
+        return binding_entry[:action] if binding_contexts.intersect?(active_contexts)
+
+        nil
+      end
+
+      def apply_override(key, cfg)
+        return unless cfg.is_a?(Hash) && cfg[:action]
+
+        contexts = Array(cfg[:contexts] || [:global]).map(&:to_sym)
+        @bindings[key.to_s.to_sym] = {
+          contexts: contexts,
+          action: cfg[:action].to_sym,
+          description: cfg[:description].to_s
+        }
+      end
+
+      def chord_starter?(key_sym)
+        @bindings.keys.any? { |k| k.to_s.start_with?("#{key_sym}+") }
+      end
+    end
+  end
+end

data/lib/legion/tty/notify.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Legion
+  module TTY
+    # Notify — OS-level terminal notification dispatcher with auto-detection.
+    #
+    # Auto-detects the terminal environment via TERM_PROGRAM and TERM env vars, then
+    # dispatches notifications using the most appropriate backend:
+    #   - iTerm2:   OSC 9 escape sequence
+    #   - kitty:    kitten notify subprocess
+    #   - Ghostty:  OSC 99 escape sequence
+    #   - Linux:    notify-send subprocess
+    #   - macOS:    osascript subprocess
+    #   - fallback: terminal bell (\a)
+    #
+    # Settings integration (read from Legion::Settings when available):
+    #   notifications.terminal.enabled  (default: true)
+    #   notifications.terminal.backend  (default: 'auto')
+    module Notify
+      BACKENDS = %w[iterm2 kitty ghostty notify_send osascript bell].freeze
+
+      class << self
+        # Send a notification.
+        # @param message [String] notification body
+        # @param title [String] notification title
+        def send(message, title: 'LegionIO')
+          return unless enabled?
+
+          backend = configured_backend
+          dispatch(backend, message: message, title: title)
+        end
+
+        # Detect the current terminal program from environment variables.
+        # @return [String] one of: 'iterm2', 'kitty', 'ghostty', 'linux', 'macos', 'unknown'
+        def detect_terminal
+          term_prog = ::ENV.fetch('TERM_PROGRAM', '').downcase
+          term = ::ENV.fetch('TERM', '').downcase
+
+          return 'iterm2'  if term_prog == 'iterm.app'
+          return 'kitty'   if term_prog == 'kitty' || term == 'xterm-kitty'
+          return 'ghostty' if term_prog == 'ghostty'
+          return 'linux'   if linux?
+          return 'macos'   if macos?
+
+          'unknown'
+        end
+
+        private
+
+        def enabled?
+          return true unless defined?(Legion::Settings)
+
+          setting = settings_dig(:notifications, :terminal, :enabled)
+          setting.nil? || setting
+        end
+
+        def configured_backend
+          backend_setting = settings_dig(:notifications, :terminal, :backend)
+          return resolve_auto_backend if backend_setting.nil? || backend_setting.to_s == 'auto'
+
+          backend_setting.to_s
+        end
+
+        def resolve_auto_backend
+          case detect_terminal
+          when 'iterm2'  then 'iterm2'
+          when 'kitty'   then 'kitty'
+          when 'ghostty' then 'ghostty'
+          when 'linux'   then 'notify_send'
+          when 'macos'   then 'osascript'
+          else 'bell'
+          end
+        end
+
+        def dispatch(backend, message:, title:)
+          case backend.to_s
+          when 'iterm2'      then notify_iterm2(message: message)
+          when 'kitty'       then notify_kitty(message: message, title: title)
+          when 'ghostty'     then notify_ghostty(message: message, title: title)
+          when 'notify_send' then notify_send(message: message, title: title)
+          when 'osascript'   then notify_osascript(message: message, title: title)
+          else notify_bell
+          end
+        rescue StandardError => e
+          Legion::Logging.warn("Notify dispatch failed: #{e.message}") if defined?(Legion::Logging)
+          notify_bell
+        end
+
+        # iTerm2: OSC 9 — "Application-specific notification"
+        def notify_iterm2(message:)
+          $stdout.print("\e]9;#{message}\a")
+          $stdout.flush
+        end
+
+        # Kitty: kitten notify subprocess
+        def notify_kitty(message:, title:)
+          ::Kernel.system('kitten', 'notify', '--title', title, message)
+        end
+
+        # Ghostty: OSC 99 (freedesktop desktop notifications via escape sequence)
+        def notify_ghostty(message:, title:)
+          payload = "i=1:p=body;#{message}\e\\\\#{title}"
+          $stdout.print("\e]99;#{payload}\a")
+          $stdout.flush
+        end
+
+        # Linux: notify-send
+        def notify_send(message:, title:)
+          ::Kernel.system('notify-send', title, message)
+        end
+
+        # macOS: osascript display notification
+        def notify_osascript(message:, title:)
+          script = "display notification #{message.inspect} with title #{title.inspect}"
+          ::Kernel.system('osascript', '-e', script)
+        end
+
+        def notify_bell
+          $stdout.print("\a")
+          $stdout.flush
+        end
+
+        def linux?
+          !macos? && (::ENV.key?('DISPLAY') || ::ENV.key?('WAYLAND_DISPLAY') || RUBY_PLATFORM.include?('linux'))
+        end
+
+        def macos?
+          RUBY_PLATFORM.include?('darwin')
+        end
+
+        def settings_dig(*keys)
+          return nil unless defined?(Legion::Settings)
+
+          first, *rest = keys
+          obj = Legion::Settings[first]
+          rest.reduce(obj) do |acc, key|
+            break nil unless acc.is_a?(Hash)
+
+            acc[key]
+          end
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -18,33 +18,18 @@ module Legion
           end
 
           def switch_model(name)
-            unless @llm_chat
-              @message_stream.add_message(role: :system, content: 'No active LLM session.')
-              return
-            end
-
-            apply_model_switch(name)
+            @preferred_model = name
+            @status_bar.update(model: name)
+            @token_tracker.update_model(name)
+            @message_stream.add_message(role: :system,
+                                        content: "Model preference set to: #{name} (applied on next daemon request)")
           rescue StandardError => e
             Legion::Logging.warn("switch_model failed: #{e.message}") if defined?(Legion::Logging)
             @message_stream.add_message(role: :system, content: "Failed to switch model: #{e.message}")
           end
 
           def apply_model_switch(name)
-            new_chat = try_provider_switch(name)
-            if new_chat
-              @llm_chat = new_chat
-              @status_bar.update(model: name)
-              @token_tracker.update_model(name)
-              @message_stream.add_message(role: :system, content: "Switched to provider: #{name}")
-            elsif @llm_chat.respond_to?(:with_model)
-              @llm_chat.with_model(name)
-              @status_bar.update(model: name)
-              @token_tracker.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
+            switch_model(name)
           end
 
           def try_provider_switch(name)
@@ -75,9 +60,8 @@ module Legion
           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
+            info = @preferred_model ? "#{@preferred_model} (#{provider})" : provider
             @message_stream.add_message(role: :system, content: "Current model: #{info}")
           end
 

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

@@ -73,10 +73,10 @@ module Legion
           @output = output
           @message_stream = Components::MessageStream.new
           @status_bar = Components::StatusBar.new
-          @llm_chat = app.respond_to?(:llm_chat) ? app.llm_chat : nil
+          @llm_chat = nil
           @token_tracker = Components::TokenTracker.new(
             provider: detect_provider,
-            model: @llm_chat.respond_to?(:model) ? @llm_chat.model.to_s : nil
+            model: nil
           )
           @session_store = SessionStore.new
           @session_name = 'default'
@@ -174,16 +174,14 @@ module Legion
         end
 
         def send_to_llm(message)
-          unless @llm_chat || daemon_available?
-            @message_stream.append_streaming('LLM not configured. Use /help for commands.')
+          unless daemon_available?
+            @message_stream.append_streaming(
+              'LegionIO daemon is not running. Start it with: legionio start'
+            )
             return
           end
 
-          if daemon_available?
-            send_via_daemon(message)
-          else
-            send_via_direct(message)
-          end
+          send_via_daemon(message)
         rescue StandardError => e
           Legion::Logging.error("send_to_llm failed: #{e.message}") if defined?(Legion::Logging)
           @status_bar.update(thinking: false)
@@ -239,60 +237,47 @@ module Legion
         end
 
         def setup_system_prompt
-          cfg = safe_config
-          return unless @llm_chat && cfg.is_a?(Hash) && !cfg.empty?
-
-          prompt = build_system_prompt(cfg)
-          @llm_chat.with_instructions(prompt) if @llm_chat.respond_to?(:with_instructions)
+          # System prompt is injected per-request in build_inference_messages.
+          # Nothing to do at activation time.
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         def send_via_daemon(message)
-          result = Legion::LLM.ask(message: message)
+          @status_bar.update(thinking: true)
+          @streaming = true
+          @app.render_frame if @app.respond_to?(:render_frame)
+
+          start_time = Time.now
+          messages = build_inference_messages(message)
+          result = Legion::TTY::DaemonClient.inference(
+            messages: messages,
+            model: @preferred_model
+          )
 
-          case result&.dig(:status)
-          when :done
+          case result[:status]
+          when :ok
+            data = result[:data] || {}
+            content = data[:content].to_s
             parser = build_tool_call_parser
-            parser.feed(result[:response])
+            parser.feed(content)
             parser.flush
-            track_daemon_tokens(result)
+            record_response_time(Time.now - start_time)
+            track_inference_tokens(data)
+            speak_response(content) if @speak_mode
           when :error
             err = result.dig(:error, :message) || 'Unknown error'
             @message_stream.append_streaming("\n[Daemon error: #{err}]")
-          else
-            send_via_direct(message)
+          when :unavailable
+            err = result.dig(:error, :message) || 'Daemon unavailable'
+            @message_stream.append_streaming(
+              "\nLegionIO daemon is not running. Start it with: legionio start\n[#{err}]"
+            )
           end
-        rescue StandardError => e
-          Legion::Logging.warn("send_via_daemon failed: #{e.message}") if defined?(Legion::Logging)
-          send_via_direct(message)
-        end
-
-        # rubocop:disable Metrics/AbcSize
-        def send_via_direct(message)
-          return unless @llm_chat
-
-          @status_bar.update(thinking: true)
-          @streaming = true
-          @app.render_frame if @app.respond_to?(:render_frame)
-          start_time = Time.now
-          response_text = +''
-          parser = build_tool_call_parser
-          response = @llm_chat.ask(message) do |chunk|
-            @status_bar.update(thinking: false)
-            if chunk.content
-              response_text << chunk.content
-              parser.feed(chunk.content)
-            end
-            @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
+          @status_bar.update(thinking: false)
           @streaming = false
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         def speak_response(text)
           return unless RUBY_PLATFORM =~ /darwin/
@@ -310,7 +295,47 @@ module Legion
         end
 
         def daemon_available?
-          !!(defined?(Legion::LLM::DaemonClient) && Legion::LLM::DaemonClient.available?)
+          Legion::TTY::DaemonClient.available?
+        rescue StandardError => e
+          Legion::Logging.debug("daemon_available? check failed: #{e.message}") if defined?(Legion::Logging)
+          false
+        end
+
+        def build_inference_messages(current_message)
+          msgs = []
+          inject_system_message(msgs)
+          inject_history_messages(msgs)
+          msgs.pop if msgs.last&.dig(:role) == 'user'
+          msgs << { role: 'user', content: current_message }
+          msgs
+        end
+
+        def inject_system_message(msgs)
+          prompt = build_system_prompt(safe_config)
+          msgs << { role: 'system', content: prompt } if prompt && !prompt.strip.empty?
+        end
+
+        def inject_history_messages(msgs)
+          @message_stream.messages.each do |m|
+            next if m[:tool_panel]
+            next unless %i[user assistant].include?(m[:role])
+
+            content = m[:content].to_s
+            next if content.strip.empty?
+
+            msgs << { role: m[:role].to_s, content: content }
+          end
+        end
+
+        def track_inference_tokens(data)
+          return unless data.is_a?(Hash) && (data[:input_tokens] || data[:output_tokens])
+
+          @token_tracker.track(
+            input_tokens: data[:input_tokens].to_i,
+            output_tokens: data[:output_tokens].to_i,
+            model: data[:model]&.to_s
+          )
+          update_status_bar_tokens
         end
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
@@ -638,18 +663,6 @@ module Legion
           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,

data/lib/legion/tty/session_store.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'json'
+require 'legion/json'
 require 'fileutils'
 
 module Legion
@@ -21,17 +21,16 @@ module Legion
           saved_at: Time.now.iso8601,
           version: 1
         }
-        File.write(session_path(name), ::JSON.generate(data))
+        File.write(session_path(name), Legion::JSON.generate(data))
       end
 
       def load(name)
         path = session_path(name)
         return nil unless File.exist?(path)
 
-        data = ::JSON.parse(File.read(path), symbolize_names: true)
-        data[:messages] = data[:messages].map { |m| deserialize_message(m) }
-        data
-      rescue ::JSON::ParserError => e
+        data = Legion::JSON.parse(File.read(path), symbolize_names: true)
+        normalize_session(data)
+      rescue Legion::JSON::ParseError => e
         Legion::Logging.warn("session load failed: #{e.message}") if defined?(Legion::Logging)
         nil
       end
@@ -39,7 +38,7 @@ module Legion
       def list
         entries = Dir.glob(File.join(@dir, '*.json')).map do |path|
           name = File.basename(path, '.json')
-          data = ::JSON.parse(File.read(path), symbolize_names: true)
+          data = Legion::JSON.parse(File.read(path), symbolize_names: true)
           { name: name, saved_at: data[:saved_at], message_count: data[:messages]&.size || 0 }
         rescue StandardError => e
           Legion::Logging.warn("session list entry failed: #{e.message}") if defined?(Legion::Logging)
@@ -77,6 +76,25 @@ module Legion
       def deserialize_message(msg)
         { role: msg[:role].to_sym, content: msg[:content], tool_panels: [] }
       end
+
+      # Normalize a loaded session to the canonical TTY format.
+      # Handles two shapes:
+      #   - TTY format (v1): { version: 1, name:, messages: [{role:, content:}], metadata:, saved_at: }
+      #   - CLI format (legacy): { messages: [{role:, content:, model:, stats:, summary:}] }
+      def normalize_session(data)
+        data[:messages] = (data[:messages] || []).map { |m| normalize_message(m) }
+        data[:version] ||= 1
+        data[:metadata] ||= {}
+        data[:name] ||= 'imported'
+        data[:saved_at] ||= Time.now.iso8601
+        data
+      end
+
+      def normalize_message(msg)
+        role = msg[:role].to_s.to_sym
+        content = msg[:content].to_s
+        { role: role, content: content, tool_panels: [] }
+      end
     end
   end
 end

data/lib/legion/tty/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module TTY
-    VERSION = '0.4.39'
+    VERSION = '0.4.41'
   end
 end

data/lib/legion/tty.rb

@@ -4,6 +4,8 @@ require_relative 'tty/version'
 require_relative 'tty/boot_logger'
 require_relative 'tty/theme'
 require_relative 'tty/hotkeys'
+require_relative 'tty/keybinding_manager'
+require_relative 'tty/notify'
 require_relative 'tty/screen_manager'
 require_relative 'tty/screens/base'
 require_relative 'tty/components/digital_rain'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-tty
 version: !ruby/object:Gem::Version
-  version: 0.4.39
+  version: 0.4.41
 platform: ruby
 authors:
 - Esity
@@ -246,6 +246,8 @@ files:
 - lib/legion/tty/components/wizard_prompt.rb
 - lib/legion/tty/daemon_client.rb
 - lib/legion/tty/hotkeys.rb
+- lib/legion/tty/keybinding_manager.rb
+- lib/legion/tty/notify.rb
 - lib/legion/tty/screen_manager.rb
 - lib/legion/tty/screens/base.rb
 - lib/legion/tty/screens/chat.rb