legionio 1.6.36 → 1.6.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd73445976635c61163ac93a058fd3253bb164956fff00d8b791817b1dd16ddb
-  data.tar.gz: 218c4b3975aa59cb4c0eec3735c2cdbe185cf23f85429b4268d4335a8cb7fdf9
+  metadata.gz: 3a187a818bb06029a4b03e5eb47c75af63e2fe85f997d157ce7f36dad924307b
+  data.tar.gz: 77005d16734961543c5cf5bd81d615f7387686e731725f510e2f56c72a49613a
 SHA512:
-  metadata.gz: 247d06dcfb4d405c1a156bac4c9a4a0aaa00eedd0cf2f3bfef74da95f9027acb39f303bc9afda3dbf50d2f14dee2a41eafd10d5522dbf074017548489f69ebd0
-  data.tar.gz: 840d3c68d9e48e11e3c92a40cf2a0d849079d5ab68aa39629368f88a75615d1dca151b952987de9a882517c84569bcc7aff9c93becbd9d8277b98152a5fdc942
+  metadata.gz: 856b38fdb0200c467538ed0c7b79863be85d0a14ea44d0ae52f0e13a6f655089cfb4e905b94f42a89b893809c183b81366789bf531a1f1023b9ba0c44523920d
+  data.tar.gz: a23b1bc63408859994b6c315aa38f7dba5a43e5a64bfdd7d0e8f51dc9a3ce4eac96d12d0bf98a2241e9bd7c507953d9733bb4e6b857186f8e3789f2a99db3206

data/.rubocop.yml

@@ -29,7 +29,7 @@ Metrics/ModuleLength:
     - 'lib/legion/api/openapi.rb'
 
 Metrics/BlockLength:
-  Max: 40
+  Max: 52
   Exclude:
     - 'spec/**/*'
     - 'integration/**/*'

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [1.6.37] - 2026-03-30
+
+### Added
+- TBI Patterns API: `POST /api/tbi/patterns/export`, `GET /api/tbi/patterns`, `GET /api/tbi/patterns/:id`, `PATCH /api/tbi/patterns/:id/score`, `GET /api/tbi/patterns/discover` (501 stub)
+- TBI Pattern model and local migration (`create_tbi_patterns`)
+- OpenInference telemetry integration (`Legion::Telemetry::OpenInference`)
+
+### Fixed
+- Governance lifecycle integration specs expanded and hardened
+
 ## [1.6.36] - 2026-03-29
 
 ### Added

data/lib/legion/api/catalog.rb

@@ -26,7 +26,7 @@ module Legion
       end
     end
 
-    helpers do # rubocop:disable Metrics/BlockLength
+    helpers do
       def build_catalog_manifest(name, entry)
         {
           name:          name,

data/lib/legion/api/openapi.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/json'
+require 'legion/api/events'
 
 module Legion
   class API < Sinatra::Base
@@ -922,7 +923,7 @@ module Legion
               summary:     'Get recent events from ring buffer',
               operationId: 'getRecentEvents',
               parameters:  [
-                { name: 'count', in: 'query', description: "Number of events (max #{Routes::Events::BUFFER_SIZE})",
+                { name: 'count', in: 'query', description: "Number of events (max #{Legion::API::Routes::Events::BUFFER_SIZE})",
                   required: false, schema: { type: 'integer', default: 25 } }
               ],
               responses:   {

data/lib/legion/api/tbi_patterns.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module TbiPatterns
+        MAX_DESCRIPTION_BYTES = 1024
+        MAX_PAYLOAD_SHAPE_BYTES = 65_536
+        VALID_TIERS = %w[tier1 tier2 tier3 tier4 tier5].freeze
+
+        def self.registered(app)
+          register_export(app)
+          register_discover(app)
+          register_all(app)
+          register_score(app)
+          register_fetch(app)
+        end
+
+        # POST /api/tbi/patterns/export — anonymously export a learned behavioral pattern
+        def self.register_export(app) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          app.post '/api/tbi/patterns/export' do
+            require_data!
+            body = parse_request_body
+
+            if body[:pattern_type].to_s.strip.empty?
+              Legion::Logging.warn 'API POST /api/tbi/patterns/export returned 422: pattern_type is required' if defined?(Legion::Logging)
+              halt 422, json_error('missing_field', 'pattern_type is required', status_code: 422)
+            end
+            if body[:description].to_s.strip.empty?
+              Legion::Logging.warn 'API POST /api/tbi/patterns/export returned 422: description is required' if defined?(Legion::Logging)
+              halt 422, json_error('missing_field', 'description is required', status_code: 422)
+            end
+            if body[:pattern_data].to_s.strip.empty?
+              Legion::Logging.warn 'API POST /api/tbi/patterns/export returned 422: pattern_data is required' if defined?(Legion::Logging)
+              halt 422, json_error('missing_field', 'pattern_data is required', status_code: 422)
+            end
+            if body[:tier].to_s.strip.empty?
+              Legion::Logging.warn 'API POST /api/tbi/patterns/export returned 422: tier is required' if defined?(Legion::Logging)
+              halt 422, json_error('missing_field', 'tier is required', status_code: 422)
+            end
+
+            if body[:description].to_s.bytesize > MAX_DESCRIPTION_BYTES
+              halt 422, json_error('field_too_large', "description exceeds #{MAX_DESCRIPTION_BYTES} bytes", status_code: 422)
+            end
+
+            pattern_data_str = Routes::TbiPatterns.serialize_pattern_data(body[:pattern_data])
+            if pattern_data_str.bytesize > MAX_PAYLOAD_SHAPE_BYTES
+              halt 422, json_error('field_too_large', "pattern_data exceeds #{MAX_PAYLOAD_SHAPE_BYTES} bytes", status_code: 422)
+            end
+
+            unless VALID_TIERS.include?(body[:tier].to_s)
+              halt 422, json_error('invalid_field', "tier must be one of: #{VALID_TIERS.join(', ')}", status_code: 422)
+            end
+
+            # Anonymize: strip any identifying keys before persisting
+            anonymous_data = Routes::TbiPatterns.anonymize(body)
+
+            invocation_count = Routes::TbiPatterns.parse_integer(body[:invocation_count], 0)
+            success_rate     = Routes::TbiPatterns.parse_float(body[:success_rate], 0.0)
+            quality_score    = Routes::TbiPatterns.compute_quality(
+              invocation_count: invocation_count,
+              success_rate:     success_rate,
+              tier:             body[:tier].to_s
+            )
+
+            record = Legion::Data::Model::TbiPattern.create(
+              pattern_type:     body[:pattern_type].to_s,
+              description:      body[:description].to_s,
+              tier:             body[:tier].to_s,
+              pattern_data:     pattern_data_str,
+              quality_score:    quality_score,
+              invocation_count: invocation_count,
+              success_rate:     success_rate,
+              source_hash:      anonymous_data[:source_hash]
+            )
+            Legion::Logging.info "API: exported TBI pattern id=#{record.id} tier=#{record.tier}" if defined?(Legion::Logging)
+            json_response(record.values, status_code: 201)
+          rescue StandardError => e
+            Legion::Logging.error "API POST /api/tbi/patterns/export: #{e.class} — #{e.message}" if defined?(Legion::Logging)
+            json_error('export_error', e.message, status_code: 500)
+          end
+        end
+
+        # GET /api/tbi/patterns/:id — fetch a single pattern by integer ID
+        def self.register_fetch(app)
+          app.get '/api/tbi/patterns/:id' do
+            require_data!
+            id_val = params[:id].to_i
+            halt 422, json_error('invalid_id', 'id must be a positive integer', status_code: 422) if id_val <= 0
+
+            record = Legion::Data::Model::TbiPattern.first(id: id_val)
+            halt 404, json_error('not_found', "TBI pattern #{params[:id]} not found", status_code: 404) unless record
+
+            json_response(record.values)
+          rescue StandardError => e
+            Legion::Logging.error "API GET /api/tbi/patterns/#{params[:id]}: #{e.class} — #{e.message}" if defined?(Legion::Logging)
+            json_error('fetch_error', e.message, status_code: 500)
+          end
+        end
+
+        # GET /api/tbi/patterns — list patterns with optional tier/type filter
+        def self.register_all(app)
+          app.get '/api/tbi/patterns' do
+            require_data!
+            dataset = Legion::Data::Model::TbiPattern.order(Sequel.desc(:quality_score))
+            dataset = dataset.where(tier: params[:tier]) if params[:tier]
+            dataset = dataset.where(pattern_type: params[:type]) if params[:type]
+            json_collection(dataset)
+          rescue StandardError => e
+            Legion::Logging.error "API GET /api/tbi/patterns: #{e.class} — #{e.message}" if defined?(Legion::Logging)
+            json_error('list_error', e.message, status_code: 500)
+          end
+        end
+
+        # PATCH /api/tbi/patterns/:id/score — update quality score with new usage metadata
+        def self.register_score(app)
+          app.patch '/api/tbi/patterns/:id/score' do
+            require_data!
+            id_val = params[:id].to_i
+            halt 422, json_error('invalid_id', 'id must be a positive integer', status_code: 422) if id_val <= 0
+
+            record = Legion::Data::Model::TbiPattern.first(id: id_val)
+            halt 404, json_error('not_found', "TBI pattern #{params[:id]} not found", status_code: 404) unless record
+
+            body = parse_request_body
+            invocation_count = Routes::TbiPatterns.parse_integer(body[:invocation_count], record.invocation_count)
+            success_rate     = Routes::TbiPatterns.parse_float(body[:success_rate], record.success_rate)
+            quality_score    = Routes::TbiPatterns.compute_quality(
+              invocation_count: invocation_count,
+              success_rate:     success_rate,
+              tier:             record.tier
+            )
+
+            record.update(
+              invocation_count: invocation_count,
+              success_rate:     success_rate,
+              quality_score:    quality_score
+            )
+            Legion::Logging.info "API: rescored TBI pattern id=#{record.id} quality=#{quality_score}" if defined?(Legion::Logging)
+            json_response(record.values)
+          rescue StandardError => e
+            Legion::Logging.error "API PATCH /api/tbi/patterns/#{params[:id]}/score: #{e.class} — #{e.message}" if defined?(Legion::Logging)
+            json_error('score_error', e.message, status_code: 500)
+          end
+        end
+
+        # GET /api/tbi/patterns/discover — cross-instance pattern discovery (P3/TBI Phase 6)
+        # TODO: implement cross-instance discovery
+        def self.register_discover(app)
+          app.get '/api/tbi/patterns/discover' do
+            halt 501, json_error('not_implemented', 'cross-instance pattern discovery is not yet available', status_code: 501)
+          end
+        end
+
+        # --- helpers ---
+
+        # Anonymize pattern export: remove instance-identifying fields, compute a
+        # one-way hash for deduplication without fingerprinting.
+        def self.anonymize(body)
+          identifying_keys = %i[node_id instance_id hostname ip_address worker_id]
+          sanitized = body.reject { |k, _v| identifying_keys.include?(k.to_sym) }
+          # Remove both string and symbol variants
+          sanitized = sanitized.reject { |k, _v| identifying_keys.map(&:to_s).include?(k.to_s) }
+
+          salt_source = "#{body[:pattern_type]}:#{body[:tier]}:#{body[:description]}"
+          source_hash = Digest::SHA256.hexdigest(salt_source)[0, 16]
+
+          sanitized.merge(source_hash: source_hash)
+        end
+
+        def self.serialize_pattern_data(pattern_data)
+          return pattern_data.to_s if pattern_data.is_a?(String)
+
+          Legion::JSON.dump(pattern_data)
+        rescue StandardError
+          Legion::JSON.dump(pattern_data.to_s)
+        end
+
+        def self.compute_quality(invocation_count:, success_rate:, tier:)
+          # tier weight: higher tiers (closer to tier5) earn a modest bonus
+          tier_num    = tier.to_s.gsub(/[^0-9]/, '').to_i.clamp(1, 5)
+          tier_weight = tier_num / 5.0
+
+          count_score   = [invocation_count.to_f / 100.0, 1.0].min
+          success_score = success_rate.to_f.clamp(0.0, 1.0)
+
+          ((count_score * 0.4) + (success_score * 0.5) + (tier_weight * 0.1)).round(4)
+        end
+
+        # Parse an integer from user input; return default if blank or invalid.
+        def self.parse_integer(value, default)
+          return default if value.nil?
+          return default if value.to_s.strip.empty?
+          raise ArgumentError, 'not numeric' unless value.to_s =~ /\A-?\d+\z/
+
+          [value.to_i, 0].max
+        rescue ArgumentError
+          default
+        end
+
+        # Parse a float from user input; return default if blank or invalid.
+        def self.parse_float(value, default)
+          return default if value.nil?
+          return default if value.to_s.strip.empty?
+          raise ArgumentError, 'not numeric' unless value.to_s =~ /\A-?\d+(\.\d+)?\z/
+
+          value.to_f.clamp(0.0, 1.0)
+        rescue ArgumentError
+          default
+        end
+
+        private_class_method :register_export, :register_fetch, :register_all,
+                             :register_score, :register_discover
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -52,6 +52,7 @@ require_relative 'api/router'
 require_relative 'api/library_routes'
 require_relative 'api/sync_dispatch'
 require_relative 'api/lex_dispatch'
+require_relative 'api/tbi_patterns'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -176,6 +177,7 @@ module Legion
     register Routes::Absorbers
     register Routes::Codegen
     register Routes::Logs
+    register Routes::TbiPatterns
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger

data/lib/legion/data/local_migrations/20250601000001_create_tbi_patterns.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table?(:tbi_patterns) do
+      primary_key :id
+      String      :pattern_type,     null: false
+      String      :description,      null: false
+      String      :tier,             null: false
+      # TEXT column holds JSON-encoded behavioral pattern data (up to 64KB)
+      String      :pattern_data,     text: true, null: false
+      Float       :quality_score,    null: false, default: 0.0
+      Integer     :invocation_count, null: false, default: 0
+      Float       :success_rate,     null: false, default: 0.0
+      # one-way SHA-256 prefix derived from pattern_type+tier+description; not reversible to the submitting instance
+      String      :source_hash
+      Time        :created_at,       null: false
+      Time        :updated_at,       null: false
+    end
+  end
+end

data/lib/legion/data/models/tbi_pattern.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+if defined?(Sequel)
+  module Legion
+    module Data
+      module Model
+        class TbiPattern < Sequel::Model(:tbi_patterns)
+          plugin :timestamps, update_on_create: true
+
+          def validate
+            super
+            errors.add(:pattern_type, 'is required') if !pattern_type || pattern_type.to_s.strip.empty?
+            errors.add(:description,  'is required') if !description  || description.to_s.strip.empty?
+            errors.add(:pattern_data, 'is required') if !pattern_data || pattern_data.to_s.strip.empty?
+            errors.add(:tier,         'is required') if !tier         || tier.to_s.strip.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/telemetry/open_inference.rb

@@ -141,6 +141,51 @@ module Legion
         Legion::Telemetry.with_span("agent.#{name}", kind: :internal, attributes: attrs, &)
       end
 
+      def retriever_span(name:, query: nil, top_k: nil, &)
+        unless open_inference_enabled?
+          return yield(nil) if block_given?
+
+          return
+        end
+
+        attrs = base_attrs('RETRIEVER').merge('retriever.name' => name)
+        attrs['retriever.top_k'] = top_k if top_k
+        attrs['input.value'] = truncate_value(query.to_s) if query && include_io?
+
+        Legion::Telemetry.with_span("retriever.#{name}", kind: :client, attributes: attrs, &)
+      end
+
+      def reranker_span(model:, query: nil, top_k: nil, &)
+        unless open_inference_enabled?
+          return yield(nil) if block_given?
+
+          return
+        end
+
+        attrs = base_attrs('RERANKER').merge('reranker.model_name' => model)
+        attrs['reranker.top_k'] = top_k if top_k
+        attrs['input.value'] = truncate_value(query.to_s) if query && include_io?
+
+        Legion::Telemetry.with_span("reranker.#{model}", kind: :internal, attributes: attrs, &)
+      end
+
+      def guardrail_span(name:, input: nil)
+        unless open_inference_enabled?
+          return yield(nil) if block_given?
+
+          return
+        end
+
+        attrs = base_attrs('GUARDRAIL').merge('guardrail.name' => name)
+        attrs['input.value'] = truncate_value(input.to_s) if input && include_io?
+
+        Legion::Telemetry.with_span("guardrail.#{name}", kind: :internal, attributes: attrs) do |span|
+          result = yield(span)
+          annotate_guardrail_result(span, result) if span && result.is_a?(Hash)
+          result
+        end
+      end
+
       def truncate_value(str, max: nil)
         limit = max || truncate_limit
         str.length > limit ? str[0...limit] : str
@@ -181,6 +226,17 @@ module Legion
         Legion::Logging.debug "OpenInference#annotate_eval_result failed: #{e.message}" if defined?(Legion::Logging)
         nil
       end
+
+      def annotate_guardrail_result(span, result)
+        return unless span.respond_to?(:set_attribute)
+
+        span.set_attribute('guardrail.passed', result[:passed]) unless result[:passed].nil?
+        span.set_attribute('guardrail.score', result[:score]) unless result[:score].nil?
+        span.set_attribute('output.value', truncate_value(result[:explanation].to_s)) if include_io? && result[:explanation]
+      rescue StandardError => e
+        Legion::Logging.debug "OpenInference#annotate_guardrail_result failed: #{e.message}" if defined?(Legion::Logging)
+        nil
+      end
     end
   end
 end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.6.36'
+  VERSION = '1.6.37'
 end

data/workflows/autofix-pipeline.yml

@@ -0,0 +1,58 @@
+name: autofix-pipeline
+version: 0.1.0
+description: >
+  Log event triage → GitHub issue → LLM fix → PR creation.
+  Triggered by batched exception log events.
+
+requires:
+  - lex-autofix
+  - lex-github
+
+relationships:
+  - name: triage-to-diagnose
+    trigger:
+      extension: autofix
+      runner: triage
+      function: batch_triage
+    action:
+      extension: autofix
+      runner: diagnose
+      function: check_github
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true
+
+  - name: diagnose-to-fix
+    trigger:
+      extension: autofix
+      runner: diagnose
+      function: check_github
+    action:
+      extension: autofix
+      runner: fix
+      function: attempt_fix
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true
+        - fact: action
+          operator: not_equal
+          value: skipped
+
+  - name: fix-to-ship
+    trigger:
+      extension: autofix
+      runner: fix
+      function: attempt_fix
+    action:
+      extension: autofix
+      runner: ship
+      function: ship
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true

data/workflows/factory-develop-codegen.yml

@@ -0,0 +1,25 @@
+name: factory-develop-codegen
+version: 0.1.0
+description: >
+  Factory develop stage delegates code generation to lex-codegen.
+  Each spec requirement becomes a codegen task.
+
+requires:
+  - lex-factory
+  - lex-codegen
+
+relationships:
+  - name: develop-to-codegen
+    trigger:
+      extension: factory
+      runner: factory
+      function: run_pipeline
+    action:
+      extension: codegen
+      runner: from_gap
+      function: generate
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true

data/workflows/mind-growth-build.yml

@@ -0,0 +1,88 @@
+name: mind-growth-build
+version: 0.1.0
+description: >
+  Extension build pipeline: scaffold → implement → test → validate → register.
+  Runs locally on the build node. Task relationships provide observability
+  and conditional retry on test failure.
+
+requires:
+  - lex-mind-growth
+  - lex-codegen
+  - lex-eval
+  - lex-exec
+
+relationships:
+  - name: scaffold-to-implement
+    trigger:
+      extension: mind_growth
+      runner: builder
+      function: scaffold_stage
+    action:
+      extension: mind_growth
+      runner: builder
+      function: implement_stage
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true
+
+  - name: implement-to-test
+    trigger:
+      extension: mind_growth
+      runner: builder
+      function: implement_stage
+    action:
+      extension: mind_growth
+      runner: builder
+      function: test_stage
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true
+
+  - name: test-pass-to-validate
+    trigger:
+      extension: mind_growth
+      runner: builder
+      function: test_stage
+    action:
+      extension: mind_growth
+      runner: builder
+      function: validate_stage
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true
+
+  - name: test-fail-to-implement-retry
+    trigger:
+      extension: mind_growth
+      runner: builder
+      function: test_stage
+    action:
+      extension: mind_growth
+      runner: builder
+      function: implement_stage
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: false
+
+  - name: validate-to-register
+    trigger:
+      extension: mind_growth
+      runner: builder
+      function: validate_stage
+    action:
+      extension: mind_growth
+      runner: builder
+      function: register_stage
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true

data/workflows/mind-growth-swarm-parallel-build.yml

@@ -0,0 +1,42 @@
+name: mind-growth-swarm-parallel-build
+version: 0.1.0
+description: >
+  Swarm-orchestrated parallel build: create swarm → build proposals → complete.
+
+requires:
+  - lex-mind-growth
+  - lex-swarm
+
+relationships:
+  - name: create-to-build
+    trigger:
+      extension: mind_growth
+      runner: swarm_builder
+      function: create_build_swarm
+    action:
+      extension: mind_growth
+      runner: swarm_builder
+      function: execute_parallel_build
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true
+        - fact: charter_type
+          operator: equal
+          value: parallel_build
+
+  - name: build-to-complete
+    trigger:
+      extension: mind_growth
+      runner: swarm_builder
+      function: execute_parallel_build
+    action:
+      extension: swarm
+      runner: swarm
+      function: complete_swarm
+    conditions:
+      all:
+        - fact: success
+          operator: equal
+          value: true

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.6.36
+  version: 1.6.37
 platform: ruby
 authors:
 - Esity
@@ -513,6 +513,7 @@ files:
 - lib/legion/api/stats.rb
 - lib/legion/api/sync_dispatch.rb
 - lib/legion/api/tasks.rb
+- lib/legion/api/tbi_patterns.rb
 - lib/legion/api/tenants.rb
 - lib/legion/api/token.rb
 - lib/legion/api/traces.rb
@@ -759,8 +760,10 @@ files:
 - lib/legion/compliance/phi_erasure.rb
 - lib/legion/compliance/phi_tag.rb
 - lib/legion/context.rb
+- lib/legion/data/local_migrations/20250601000001_create_tbi_patterns.rb
 - lib/legion/data/local_migrations/20260319000001_create_extension_catalog.rb
 - lib/legion/data/local_migrations/20260319000002_create_extension_permissions.rb
+- lib/legion/data/models/tbi_pattern.rb
 - lib/legion/digital_worker.rb
 - lib/legion/digital_worker/airb.rb
 - lib/legion/digital_worker/lifecycle.rb
@@ -872,7 +875,11 @@ files:
 - public/workflow/index.html
 - scripts/rollout-ci-workflow.sh
 - scripts/sync-github-labels-topics.sh
+- workflows/autofix-pipeline.yml
 - workflows/autonomous-github-lifecycle.yml
+- workflows/factory-develop-codegen.yml
+- workflows/mind-growth-build.yml
+- workflows/mind-growth-swarm-parallel-build.yml
 homepage: https://github.com/LegionIO/LegionIO
 licenses:
 - Apache-2.0