legionio 1.6.47 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6fdb142083ba9c7189a2c1d067d010b1ab0f39f22caa6c138d14fc1ebacd1589
-  data.tar.gz: 3f462e8d42971068e296464fd1911cd326fcce814cf37c41b4f0cd21c278247e
+  metadata.gz: ba1e9bda23249eed2b5999c61cfe654516482285e9a7c485b34535107e591a52
+  data.tar.gz: 041a860cec2ee554696c8006006afa5b23ce69e789c7b76e97acc47023577ecd
 SHA512:
-  metadata.gz: 5a0d8a882c72675d9b6b4aa9d31f5e7f51c2e7feea21f8bc71080b4f4ebabe95c20e3f51ef1c6bf77c9e87df41ba6dc46809d2081d1b70a7a468728aefa71943
-  data.tar.gz: be6c28ddffac2b02d22dd98b6133481bd724b26586853d58b8df0035cf1716e27dfedcdbfb53ffd1a9016fe7deff3bceb3755ac013b332f93552a606ca210d2c
+  metadata.gz: 2c3a39c3aca59a10712c212d36dfced8d432376622c30469219afe69c95c73c86875388e8c178ddfd74d697f78f3d6abf3056d6763c4509686d486310f463edc
+  data.tar.gz: c51e8d1e950a2010a65839db4c823ea1be94d9156efbe2cb01ffceedcea989dea33482b8d9a3dbb09c1f2605467f9c73e715d1e032653d94a87b5f6cdcb7b6d2

data/.rubocop.yml

@@ -60,6 +60,7 @@ Metrics/BlockLength:
     - 'lib/legion/cli/trace_command.rb'
     - 'lib/legion/cli/features_command.rb'
     - 'lib/legion/cli/absorb_command.rb'
+    - 'lib/legion/cli/mode_command.rb'
 
 Metrics/AbcSize:
   Max: 60

data/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [1.7.0] - 2026-03-31
+
+### Added
+- `Legion::Provider` base class with DAG-ordered registry for boot lifecycle (#71)
+- `TaskOutcomeObserver` wires task completion to reflection and learning persistence (#70)
+- GenAI semantic convention attributes (`gen_ai.*`) on OpenInference spans (#69)
+- `legionio doctor` scored audit report with weighted health score and letter grades (#77)
+- Local skill drop-in directory with `.rb` and `.md` support and execution (#76)
+- Dynamic gem sources for extension installs via `extensions.sources` setting (#52)
+- `legionio mode` CLI command for profile and process role switching (#72)
+- Cross-project session resume with CWD context and `--resume-latest` flag (#105)
+- Away summary recap via LLM when user returns after idle period (#100)
+- Wire `LexCliManifest.write_manifest` into extension autobuild pipeline (#97)
+- Inbound webhook normalizer and HTTP-to-AMQP event bridge (`Legion::Trigger`) (#74)
+- Interrupt detection and session recovery for chat resume (#98)
+- Configurable output styles for LLM responses via `.legionio/output-styles/` (#103)
+- Route RunCommand through lex-exec sandbox when `chat.sandboxed_commands.enabled` is true (#96)
+- Cross-session memory consolidation with 3-gate trigger system (#99)
+- Per-model `/cost` breakdown with token counts, cache hits, and `CostEstimator` pricing (#102)
+- Team memory sync via Apollo knowledge store with repo-scoped tags (#104)
+
+### Fixed
+- Puma no longer steals SIGINT/SIGTERM traps, preventing graceful shutdown (#91)
+
 ## [1.6.47] - 2026-03-31
 
 ### Added

data/Gemfile

@@ -29,6 +29,7 @@ group :test do
   gem 'rake'
   gem 'rspec'
   gem 'rubocop'
+  gem 'rubocop-legion'
   gem 'rubocop-rspec'
   gem 'ruby_llm'
   gem 'simplecov'

data/lib/legion/api/inbound_webhooks.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module InboundWebhooks
+        def self.registered(app)
+          app.post '/api/webhooks/:source' do
+            require 'legion/trigger'
+
+            source_name = params[:source]
+            body_raw = request.body.read
+            body = begin
+              Legion::JSON.load(body_raw)
+            rescue StandardError
+              halt 400, json_error('invalid_body', 'request body must be valid JSON', status_code: 400)
+            end
+
+            headers = request.env.select { |k, _| k.start_with?('HTTP_') }
+
+            result = Legion::Trigger.process(
+              source_name: source_name,
+              headers:     headers,
+              body_raw:    body_raw,
+              body:        body
+            )
+
+            if result[:success]
+              json_response(result, status_code: 202)
+            elsif result[:reason] == :duplicate
+              json_response(result, status_code: 200)
+            elsif result[:reason] == :unknown_source
+              halt 404, json_error('unknown_source', result[:error], status_code: 404)
+            else
+              halt 500, json_error('trigger_error', result[:error] || 'processing failed', status_code: 500)
+            end
+          end
+
+          app.get '/api/webhooks/sources' do
+            require 'legion/trigger'
+            json_response({ sources: Legion::Trigger.registered_sources })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -54,6 +54,7 @@ require_relative 'api/library_routes'
 require_relative 'api/sync_dispatch'
 require_relative 'api/lex_dispatch'
 require_relative 'api/tbi_patterns'
+require_relative 'api/inbound_webhooks'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -180,6 +181,7 @@ module Legion
     register Routes::Knowledge
     register Routes::Logs
     register Routes::TbiPatterns
+    register Routes::InboundWebhooks
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger

data/lib/legion/chat/skills.rb

@@ -13,7 +13,9 @@ module Legion
             expanded = File.expand_path(dir)
             next [] unless Dir.exist?(expanded)
 
-            Dir.glob(File.join(expanded, '*.md')).filter_map { |f| parse(f) }
+            md_skills = Dir.glob(File.join(expanded, '*.md')).filter_map { |f| parse(f) }
+            rb_skills = Dir.glob(File.join(expanded, '*.rb')).filter_map { |f| parse_rb(f) }
+            md_skills + rb_skills
           end
         end
 
@@ -34,6 +36,7 @@ module Legion
           {
             name:        frontmatter['name'] || File.basename(path, '.md'),
             description: frontmatter['description'] || '',
+            type:        :prompt,
             model:       frontmatter['model'],
             tools:       Array(frontmatter['tools']),
             prompt:      body,
@@ -43,6 +46,79 @@ module Legion
           Legion::Logging.warn "Skill parse error #{path}: #{e.message}" if defined?(Legion::Logging)
           nil
         end
+
+        def parse_rb(path)
+          content = File.read(path)
+
+          name = File.basename(path, '.rb')
+          description = content.match(/^\s*#\s*description:\s*(.+)$/i)&.captures&.first || ''
+          model = content.match(/^\s*#\s*model:\s*(.+)$/i)&.captures&.first
+
+          {
+            name:        name,
+            description: description.strip,
+            type:        :ruby,
+            model:       model&.strip,
+            tools:       [],
+            prompt:      nil,
+            path:        path
+          }
+        rescue StandardError => e
+          Legion::Logging.warn "Skill parse_rb error #{path}: #{e.message}" if defined?(Legion::Logging)
+          nil
+        end
+
+        def execute(skill, input: nil)
+          case skill[:type]
+          when :ruby
+            execute_rb(skill, input: input)
+          when :prompt
+            execute_prompt(skill, input: input)
+          else
+            { success: false, error: "unknown skill type: #{skill[:type]}" }
+          end
+        end
+
+        private
+
+        def execute_prompt(skill, input: nil)
+          return { success: false, error: 'Legion::LLM not available' } unless defined?(Legion::LLM) && Legion::LLM.respond_to?(:chat_direct)
+
+          prompt = skill[:prompt]
+          prompt = "#{prompt}\n\nUser input: #{input}" if input
+
+          session = Legion::LLM.chat_direct(model: skill[:model], provider: nil)
+          response = session.ask(prompt)
+          content = response.respond_to?(:content) ? response.content : response.to_s
+
+          { success: true, output: content }
+        rescue StandardError => e
+          { success: false, error: e.message }
+        end
+
+        def execute_rb(skill, input: nil)
+          begin
+            real_path = File.realpath(skill[:path])
+          rescue Errno::ENOENT
+            return { success: false, error: "skill file not found: #{skill[:path]}" }
+          end
+          allowed = SKILL_DIRS.filter_map do |dir|
+            expanded = File.expand_path(dir)
+            File.realpath(expanded) if Dir.exist?(expanded)
+          end
+          unless allowed.any? { |dir| real_path.start_with?("#{dir}/") }
+            return { success: false, error: "skill path outside allowed directories: #{real_path}" }
+          end
+
+          mod = Module.new
+          mod.module_eval(File.read(real_path), real_path)
+          return { success: false, error: "#{skill[:name]}.rb must define a module-level `self.call` method" } unless mod.respond_to?(:call)
+
+          result = mod.call(input: input)
+          { success: true, output: result }
+        rescue StandardError => e
+          { success: false, error: e.message }
+        end
       end
     end
   end

data/lib/legion/cli/chat/memory_store.rb

@@ -54,6 +54,8 @@ module Legion
             header = scope == :global ? "# Global Memory\n" : "# Project Memory\n"
             File.write(path, "#{header}#{entry}", encoding: 'utf-8')
           end
+
+          sync_to_team(text)
           path
         end
 
@@ -102,6 +104,14 @@ module Legion
           FileUtils.mkdir_p(File.dirname(path))
         end
         private_class_method :ensure_dir
+
+        def sync_to_team(text)
+          require 'legion/cli/chat/team_memory'
+          Chat::TeamMemory.sync_add(text)
+        rescue StandardError => e
+          Legion::Logging.debug("MemoryStore#sync_to_team failed: #{e.message}") if defined?(Legion::Logging)
+        end
+        private_class_method :sync_to_team
       end
     end
   end

data/lib/legion/cli/chat/output_styles.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Legion
+  module CLI
+    class Chat
+      module OutputStyles
+        STYLE_DIRS = ['.legionio/output-styles', '~/.legionio/output-styles'].freeze
+
+        class << self
+          def discover
+            STYLE_DIRS.flat_map do |dir|
+              expanded = File.expand_path(dir)
+              next [] unless Dir.exist?(expanded)
+
+              Dir.glob(File.join(expanded, '*.md')).filter_map { |f| parse(f) }
+            end
+          end
+
+          def active_styles
+            discover.select { |s| s[:active] }
+          end
+
+          def find(name)
+            discover.find { |s| s[:name] == name.to_s }
+          end
+
+          def activate(name)
+            style = find(name)
+            return nil unless style
+
+            path = style[:path]
+            content = File.read(path)
+            content.sub!(/^---\s*$/, "---\nactive: true") unless content.match?(/^active:\s/)
+            content.gsub!(/^active:\s+\w+/, 'active: true')
+            File.write(path, content)
+            style[:name]
+          end
+
+          def system_prompt_injection
+            active = active_styles
+            return nil if active.empty?
+
+            active.map { |s| s[:content] }.join("\n\n")
+          end
+
+          def parse(path)
+            raw = File.read(path)
+            return nil unless raw.start_with?('---')
+
+            parts = raw.split(/^---\s*$/, 3)
+            return nil if parts.size < 3
+
+            frontmatter = YAML.safe_load(parts[1], permitted_classes: [Symbol])
+            body = parts[2]&.strip
+
+            {
+              name:        frontmatter['name'] || File.basename(path, '.md'),
+              description: frontmatter['description'] || '',
+              active:      frontmatter['active'] == true,
+              content:     body,
+              path:        path
+            }
+          rescue StandardError => e
+            Legion::Logging.warn "OutputStyles parse error #{path}: #{e.message}" if defined?(Legion::Logging)
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat/session.rb

@@ -13,7 +13,7 @@ module Legion
         INPUT_RATE  = 0.003 / 1000.0  # $3 per million input tokens
         OUTPUT_RATE = 0.015 / 1000.0  # $15 per million output tokens
 
-        attr_reader :chat, :stats
+        attr_reader :chat, :stats, :cache_hits_tokens
         attr_accessor :budget_usd
 
         def initialize(chat:, system_prompt: nil, budget_usd: nil)
@@ -25,6 +25,8 @@ module Legion
             messages_received: 0,
             started_at:        Time.now
           }
+          @model_usage = Hash.new { |h, k| h[k] = { input_tokens: 0, output_tokens: 0, requests: 0 } }
+          @cache_hits_tokens = 0
           @callbacks = Hash.new { |h, k| h[k] = [] }
           @turn = 0
         end
@@ -65,8 +67,18 @@ module Legion
           @stats[:messages_received] += 1
 
           if response.respond_to?(:input_tokens)
-            @stats[:input_tokens]  = (@stats[:input_tokens] || 0) + (response.input_tokens || 0)
-            @stats[:output_tokens] = (@stats[:output_tokens] || 0) + (response.output_tokens || 0)
+            in_tok  = response.input_tokens || 0
+            out_tok = response.output_tokens || 0
+            @stats[:input_tokens]  = (@stats[:input_tokens] || 0) + in_tok
+            @stats[:output_tokens] = (@stats[:output_tokens] || 0) + out_tok
+
+            resp_model = response.respond_to?(:model_id) ? response.model_id : model_id
+            entry = @model_usage[resp_model.to_s]
+            entry[:input_tokens]  += in_tok
+            entry[:output_tokens] += out_tok
+            entry[:requests]      += 1
+
+            @cache_hits_tokens += response.cache_read_input_tokens.to_i if response.respond_to?(:cache_read_input_tokens) && response.cache_read_input_tokens
           end
 
           emit(:llm_complete, { turn: current_turn, user_message: message })
@@ -75,9 +87,35 @@ module Legion
         end
 
         def estimated_cost
-          input  = (@stats[:input_tokens] || 0) * INPUT_RATE
-          output = (@stats[:output_tokens] || 0) * OUTPUT_RATE
-          input + output
+          if cost_estimator_available? && @model_usage.any?
+            @model_usage.sum do |model, usage|
+              Legion::LLM::CostEstimator.estimate(
+                model_id: model, input_tokens: usage[:input_tokens], output_tokens: usage[:output_tokens]
+              )
+            end
+          else
+            input  = (@stats[:input_tokens] || 0) * INPUT_RATE
+            output = (@stats[:output_tokens] || 0) * OUTPUT_RATE
+            input + output
+          end
+        end
+
+        def model_usage
+          @model_usage.transform_values(&:dup)
+        end
+
+        def cost_breakdown
+          @model_usage.map do |model, usage|
+            cost = if cost_estimator_available?
+                     Legion::LLM::CostEstimator.estimate(
+                       model_id: model, input_tokens: usage[:input_tokens], output_tokens: usage[:output_tokens]
+                     )
+                   else
+                     (usage[:input_tokens] * INPUT_RATE) + (usage[:output_tokens] * OUTPUT_RATE)
+                   end
+            { model: model, input_tokens: usage[:input_tokens], output_tokens: usage[:output_tokens],
+              requests: usage[:requests], cost: cost }
+          end
         end
 
         def model_id
@@ -93,6 +131,10 @@ module Legion
 
         private
 
+        def cost_estimator_available?
+          defined?(Legion::LLM::CostEstimator)
+        end
+
         def check_budget!
           return unless @budget_usd
 

data/lib/legion/cli/chat/session_recovery.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'legion/cli/chat_command'
+
+module Legion
+  module CLI
+    class Chat
+      module SessionRecovery
+        STATES = %i[none interrupted_prompt interrupted_turn].freeze
+
+        class << self
+          def classify(messages)
+            cleaned = filter_artifacts(messages)
+            return :none if cleaned.empty?
+
+            last = cleaned.last
+            role = msg_role(last)
+
+            case role
+            when 'user' then :interrupted_prompt
+            when 'tool_result', 'tool' then :interrupted_turn
+            when 'assistant'
+              tool_calls = last.is_a?(Hash) ? (last[:tool_calls] || last['tool_calls']) : nil
+              tool_calls.is_a?(Array) && tool_calls.any? ? :interrupted_turn : :none
+            else :none
+            end
+          end
+
+          def recover(messages)
+            cleaned = filter_artifacts(messages)
+            state = classify(cleaned)
+
+            case state
+            when :none
+              { state: :none, messages: cleaned, recovery_message: nil }
+            when :interrupted_prompt
+              msg = 'Continue from where you left off. The previous session was interrupted.'
+              { state: :interrupted_prompt, messages: cleaned, recovery_message: msg }
+            when :interrupted_turn
+              tool_name = detect_interrupted_tool(cleaned)
+              msg = 'Continue from where you left off. The previous session was interrupted'
+              msg += " during tool execution (#{tool_name})" if tool_name
+              msg += '.'
+              repaired = repair_orphaned_tool_use(cleaned)
+              { state: :interrupted_turn, messages: repaired, recovery_message: msg }
+            end
+          end
+
+          private
+
+          def filter_artifacts(messages)
+            messages.reject do |msg|
+              role = msg_role(msg)
+              content = msg_content(msg)
+
+              next true if role == 'assistant' && thinking_only?(msg)
+              next true if role == 'assistant' && whitespace_only?(content)
+
+              false
+            end
+          end
+
+          def thinking_only?(msg)
+            content = msg_content(msg)
+            return false unless content.nil? || content.to_s.strip.empty?
+
+            tool_calls = msg.is_a?(Hash) ? (msg[:tool_calls] || msg['tool_calls']) : nil
+            tool_calls.nil? || (tool_calls.is_a?(Array) && tool_calls.empty?)
+          end
+
+          def whitespace_only?(content)
+            return true if content.nil?
+
+            content.to_s.strip.empty?
+          end
+
+          def msg_role(msg)
+            if msg.is_a?(Hash)
+              (msg[:role] || msg['role']).to_s
+            elsif msg.respond_to?(:role)
+              msg.role.to_s
+            else
+              ''
+            end
+          end
+
+          def msg_content(msg)
+            if msg.is_a?(Hash)
+              msg[:content] || msg['content']
+            elsif msg.respond_to?(:content)
+              msg.content
+            end
+          end
+
+          def detect_interrupted_tool(messages)
+            reversed = messages.reverse
+            reversed.each do |msg|
+              role = msg_role(msg)
+              next unless role == 'assistant'
+
+              tool_calls = msg.is_a?(Hash) ? (msg[:tool_calls] || msg['tool_calls']) : nil
+              next unless tool_calls.is_a?(Array) && tool_calls.any?
+
+              first_tool = tool_calls.first
+              return first_tool[:name] || first_tool['name'] if first_tool.is_a?(Hash)
+            end
+            nil
+          end
+
+          def repair_orphaned_tool_use(messages)
+            return messages if messages.empty?
+
+            last = messages.last
+            role = msg_role(last)
+
+            return messages[0...-1] if %w[tool_result tool].include?(role)
+
+            if role == 'assistant'
+              tool_calls = last.is_a?(Hash) ? (last[:tool_calls] || last['tool_calls']) : nil
+              return messages[0...-1] if tool_calls.is_a?(Array) && tool_calls.any?
+            end
+
+            messages
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat/session_store.rb

@@ -15,13 +15,16 @@ module Legion
 
             messages = session.chat.messages.map(&:to_h)
             data = {
-              name:          name,
-              model:         session.model_id,
-              stats:         session.stats,
-              saved_at:      Time.now.iso8601,
-              message_count: messages.size,
-              summary:       generate_summary(messages),
-              messages:      messages
+              name:              name,
+              model:             session.model_id,
+              stats:             session.stats,
+              saved_at:          Time.now.iso8601,
+              cwd:               Dir.pwd,
+              message_count:     messages.size,
+              summary:           generate_summary(messages),
+              model_usage:       session.respond_to?(:model_usage) ? session.model_usage : {},
+              cache_hits_tokens: session.respond_to?(:cache_hits_tokens) ? session.cache_hits_tokens : 0,
+              messages:          messages
             }
 
             path = session_path(name)
@@ -37,10 +40,16 @@ module Legion
           end
 
           def restore(session, data)
+            require 'legion/cli/chat/session_recovery'
+
+            recovery = Chat::SessionRecovery.recover(data[:messages] || [])
             session.chat.reset_messages!
-            data[:messages].each do |msg|
+            recovery[:messages].each do |msg|
               session.chat.add_message(msg)
             end
+
+            data[:recovery_state]   = recovery[:state]
+            data[:recovery_message] = recovery[:recovery_message]
             data
           end
 
@@ -57,7 +66,8 @@ module Legion
                 modified:      stat.mtime,
                 message_count: meta[:message_count],
                 summary:       meta[:summary],
-                model:         meta[:model]
+                model:         meta[:model],
+                cwd:           meta[:cwd]
               }
             end
             sessions.sort_by { |s| s[:modified] }.reverse
@@ -101,11 +111,12 @@ module Legion
             {
               message_count: data[:message_count] || data[:messages]&.size,
               summary:       data[:summary],
-              model:         data[:model]
+              model:         data[:model],
+              cwd:           data[:cwd]
             }
           rescue StandardError => e
             Legion::Logging.debug("SessionStore#read_session_meta failed: #{e.message}") if defined?(Legion::Logging)
-            { message_count: nil, summary: nil, model: nil }
+            { message_count: nil, summary: nil, model: nil, cwd: nil }
           end
         end
       end