legionio 1.8.3 → 1.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ef0a94c2543733457f3694bb571fad2ba905ef575389604b98466d82e9ac833
-  data.tar.gz: 243ccfe2053e879ecf4119f97b5e7f76353846c7f22f85aafac472b252eac667
+  metadata.gz: c8cfc2d3d92d0f7d6597d051be30145be9a38864fe9c346b69320d07b6cefdf6
+  data.tar.gz: e9420d7bdce1733c87dfe9924a4d82f5993d49ffaabcaa44ad96425c9bb1288d
 SHA512:
-  metadata.gz: a9a061f424b4eeead1ed3fa70b41b3ff8e437f39988b544473b247cc702cf481f302a8a274b181d2b6afcfa04c8adb47ec4c4238b3eecbafb110cbc5001c0c2f
-  data.tar.gz: 17b63bf689c452de0beaa00c094ec504bb5bdb58b2f79b2a03868b65bb16221d66014d15c98fa05082edd3639dc5e77122155bcaa7e2944afb21b64588399315
+  metadata.gz: 25467ee9926361dc83606f260567026ca9688b2b04f0ce16978c9ff9ba703d981e20065b77960d805cd8259a1f2765f56f509e869f51f25ef01ceed087268be7
+  data.tar.gz: f33bcdbbda291c3e32f7aa5153ca30a22526ca673b7d584303e908346814c4e5f2e6035ec4f2b95c3c322867d3b09a3c0dbe2814f5d8a785ebc18f18cccd4611

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## [Unreleased]
 
+## [1.8.4] - 2026-04-14
+
+### Added
+- `legionio fleet` CLI subcommand tree: `status`, `pending`, `approve`, `add`, `config`
+- `legionio setup fleet` two-phase command: phase 1 installs fleet gems, phase 2 wires relationships via `Workflow::Loader`, seeds conditioner rules, registers settings via `load_module_settings`, merges LLM routing overrides, applies RabbitMQ planner consumer timeout policy
+- Fleet pipeline YAML manifest with 10 relationships (1-8 plus 4b, 4c) connecting assessor, planner, developer, and validator
+- `Legion::Fleet::SettingsDefaults` — file-based fleet settings persistence
+- `Legion::Fleet::ConditionerRules` — supplementary conditioner rule seeds (skip-planning-trivial, skip-validation-trivial, escalate-max-iterations, critical-production-max-capability, governance-mind-growth)
+- Fleet API routes: `POST /api/fleet/sources`, `GET /api/fleet/pending` (filters both `fleet.shipping` and `fleet.escalation`), `POST /api/fleet/approve`, `GET /api/fleet/sources`, `GET /api/fleet/status`
+
 ## [1.8.3] - 2026-04-14
 
 ### Fixed

data/lib/legion/api/fleet.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Fleet
+        def self.registered(app)
+          app.helpers FleetHelpers
+
+          app.get '/api/fleet/status' do
+            json_response(fleet_status)
+          end
+
+          app.get '/api/fleet/pending' do
+            items = fleet_pending_approvals
+            json_response(items)
+          end
+
+          app.post '/api/fleet/approve' do
+            body = parse_request_body
+            id = body[:id]
+            halt 400, json_error('missing_id', 'id is required', status_code: 400) unless id
+
+            result = fleet_approve(id.to_i)
+            if result[:success]
+              json_response(result)
+            else
+              json_error('approve_failed', result[:error].to_s, status_code: 422)
+            end
+          end
+
+          app.get '/api/fleet/sources' do
+            sources = Legion::Settings.dig(:fleet, :sources) || []
+            json_response({ sources: sources })
+          end
+
+          app.post '/api/fleet/sources' do
+            body = parse_request_body
+            source = body[:source]
+            halt 400, json_error('missing_source', 'source is required', status_code: 400) unless source
+
+            result = fleet_add_source(body)
+            if result[:success]
+              json_response(result, status_code: 201)
+            else
+              json_error('add_source_failed', result[:error].to_s, status_code: 422)
+            end
+          end
+        end
+
+        module FleetHelpers
+          def fleet_status
+            queues = []
+            active = 0
+            workers = 0
+
+            if defined?(Legion::Transport) && Legion::Settings.dig(:transport, :connected)
+              %w[assessor planner developer validator].each do |ext|
+                queue_name = "lex.#{ext}.runners.#{ext}"
+                depth = fleet_queue_depth(queue_name)
+                queues << { name: queue_name, depth: depth } if depth
+              end
+            end
+
+            { queues: queues, active_work_items: active, workers: workers }
+          end
+
+          def fleet_queue_depth(queue_name)
+            return nil unless defined?(Legion::Transport::Session)
+
+            channel = Legion::Transport::Session.channel
+            queue = channel.queue(queue_name, passive: true)
+            queue.message_count
+          rescue StandardError
+            nil
+          end
+
+          def fleet_pending_approvals
+            approval_types = %w[fleet.shipping fleet.escalation]
+
+            if defined?(Legion::Data::Model::Task)
+              Legion::Data::Model::Task
+                .where(status: 'pending_approval')
+                .where(Sequel.lit('JSON_EXTRACT(payload, ?) IN ?',
+                                  '$.approval_type', approval_types))
+                .order(Sequel.desc(:created_at))
+                .limit(page_limit)
+                .all
+                .map(&:values)
+            else
+              []
+            end
+          rescue StandardError => e
+            Legion::Logging.warn "Fleet#fleet_pending_approvals: #{e.message}" if defined?(Legion::Logging)
+            []
+          end
+
+          def fleet_approve(_id)
+            { success: false, error: 'approval system not available' }
+          end
+
+          def fleet_add_source(body)
+            source = body[:source]
+            case source
+            when 'github'
+              fleet_setup_github_source(body)
+            else
+              { success: false, error: "Unknown source: #{source}" }
+            end
+          end
+
+          def fleet_setup_github_source(body)
+            sources = Legion::Settings.dig(:fleet, :sources) || []
+            entry = {
+              type:  'github',
+              owner: body[:owner],
+              repo:  body[:repo]
+            }
+            sources << entry
+
+            Legion::Settings.loader.settings[:fleet] ||= {}
+            Legion::Settings.loader.settings[:fleet][:sources] = sources
+
+            { success: true, source: 'github', absorber: 'issues' }
+          rescue StandardError => e
+            { success: false, error: e.message }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -62,6 +62,7 @@ require_relative 'api/webhooks'
 require_relative 'api/tenants'
 require_relative 'api/inbound_webhooks'
 require_relative 'api/identity_audit'
+require_relative 'api/fleet'
 require_relative 'api/graphql' if defined?(GraphQL)
 
 module Legion
@@ -220,6 +221,7 @@ module Legion
     register Routes::Tenants
     register Routes::InboundWebhooks
     register Routes::IdentityAudit
+    register Routes::Fleet
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger

data/lib/legion/cli/fleet_command.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative 'api_client'
+require_relative 'output'
+require_relative 'connection'
+
+module Legion
+  module CLI
+    class FleetCommand < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      namespace 'fleet'
+
+      class_option :json,     type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+
+      desc 'status', 'Show fleet pipeline status (queue depths, active work items, workers)'
+      def status
+        out = formatter
+        data = fetch_fleet_status
+
+        if options[:json]
+          out.json(data)
+        else
+          out.header('Fleet Pipeline Status')
+          out.spacer
+
+          puts "  Active work items: #{data[:active_work_items] || 0}"
+          puts "  Workers:           #{data[:workers] || 0}"
+          out.spacer
+
+          if data[:queues]&.any?
+            rows = data[:queues].map { |q| [q[:name], q[:depth].to_s] }
+            out.table(%w[Queue Depth], rows)
+          else
+            puts '  No fleet queues found'
+          end
+        end
+      end
+      default_task :status
+
+      desc 'pending', 'List work items awaiting human approval'
+      option :limit, type: :numeric, default: 20, aliases: ['-n'], desc: 'Max items to show'
+      def pending
+        out = formatter
+        items = fetch_pending_approvals
+
+        if options[:json]
+          out.json(items)
+        elsif items.empty?
+          puts '  No pending approvals'
+        else
+          out.header('Pending Approvals')
+          rows = items.first(options[:limit]).map do |item|
+            [item[:id].to_s, item[:source_ref].to_s, item[:title].to_s,
+             item[:source].to_s, item[:created_at].to_s]
+          end
+          out.table(['ID', 'Source Ref', 'Title', 'Source', 'Created'], rows)
+        end
+      end
+
+      desc 'approve ID', 'Approve a pending work item and resume the pipeline'
+      def approve(id)
+        out = formatter
+        result = approve_work_item(id.to_i)
+
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Approved work item #{id} (#{result[:work_item_id]})")
+          puts "  Pipeline resumed: #{result[:resumed]}"
+        else
+          out.error("Approval failed: #{result[:error]}")
+          raise SystemExit, 1
+        end
+      end
+
+      desc 'add SOURCE', 'Add a source to the fleet pipeline (e.g., github, slack)'
+      option :owner, type: :string, desc: 'GitHub org/owner (for github source)'
+      option :repo, type: :string, desc: 'GitHub repo name (for github source)'
+      option :webhook_url, type: :string, desc: 'Webhook callback URL'
+      def add(source)
+        out = formatter
+        result = add_fleet_source(source)
+
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Added #{source} as fleet source")
+          puts "  Absorber: #{result[:absorber]}" if result[:absorber]
+          puts "  Webhook:  #{result[:webhook_url]}" if result[:webhook_url]
+          out.spacer
+          puts '  The fleet will now process incoming events from this source.'
+        else
+          out.error("Failed to add source: #{result[:error]}")
+          raise SystemExit, 1
+        end
+      end
+
+      desc 'config', 'Show fleet configuration'
+      def config
+        out = formatter
+        with_settings do
+          fleet_settings = Legion::Settings[:fleet] || {}
+
+          if options[:json]
+            out.json(fleet_settings)
+          else
+            out.header('Fleet Configuration')
+            out.spacer
+            puts "  Enabled:  #{fleet_settings[:enabled] || false}"
+            puts "  Sources:  #{(fleet_settings[:sources] || []).join(', ').then { |s| s.empty? ? 'none' : s }}"
+            out.spacer
+
+            puts '  Defaults:'
+            puts "    Planning:       #{fleet_settings.dig(:planning, :enabled) ? 'enabled' : 'disabled'}"
+            puts "    Validation:     #{fleet_settings.dig(:validation, :enabled) ? 'enabled' : 'disabled'}"
+            puts "    Max iterations: #{fleet_settings.dig(:implementation, :max_iterations) || 5}"
+            puts "    Validators:     #{fleet_settings.dig(:implementation, :validators) || 3}"
+            puts "    Isolation:      #{fleet_settings.dig(:workspace, :isolation) || 'worktree'}"
+          end
+        end
+      end
+
+      no_commands do
+        include ApiClient
+
+        def formatter
+          @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
+        end
+
+        private
+
+        def fetch_fleet_status
+          api_get('/api/fleet/status')
+        rescue SystemExit
+          { queues: [], active_work_items: 0, workers: 0 }
+        end
+
+        def fetch_pending_approvals
+          api_get('/api/fleet/pending')
+        rescue SystemExit
+          []
+        end
+
+        def approve_work_item(id)
+          api_post('/api/fleet/approve', id: id)
+        end
+
+        def add_fleet_source(source)
+          payload = { source: source }
+          payload[:owner] = options[:owner] if options[:owner]
+          payload[:repo] = options[:repo] if options[:repo]
+          payload[:webhook_url] = options[:webhook_url] if options[:webhook_url]
+          api_post('/api/fleet/sources', **payload)
+        end
+
+        def with_settings
+          Connection.config_dir = options[:config_dir] if options[:config_dir]
+          Connection.log_level = 'error'
+          Connection.ensure_settings
+          yield
+        rescue CLI::Error => e
+          formatter.error(e.message)
+          raise SystemExit, 1
+        ensure
+          Connection.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/fleet_setup.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+require 'fileutils'
+
+module Legion
+  module CLI
+    class FleetSetup
+      FLEET_GEMS = %w[
+        lex-assessor lex-planner lex-developer lex-validator
+        lex-codegen lex-eval lex-exec
+        lex-tasker lex-conditioner lex-transformer
+        lex-audit lex-governance lex-agentic-social
+      ].freeze
+
+      MANIFEST_PATH = File.expand_path('../fleet/manifest.yml', __dir__)
+
+      attr_reader :formatter, :options
+
+      def initialize(formatter:, options:)
+        @formatter = formatter
+        @options = options
+      end
+
+      def self.fleet_gems
+        FLEET_GEMS
+      end
+
+      def self.manifest_path
+        MANIFEST_PATH
+      end
+
+      # Phase 1: Install gems. Extensions register themselves on next LegionIO start.
+      def phase1_install
+        formatter.header('Fleet Setup - Phase 1: Install') unless options[:json]
+
+        installed, missing = partition_gems
+        if missing.empty?
+          formatter.success('All fleet gems already installed') unless options[:json]
+          return { success: true, installed: installed.size, skipped: 0 }
+        end
+
+        result = install_gems(missing)
+        if result[:failed].positive?
+          formatter.error("#{result[:failed]} gem(s) failed to install") unless options[:json]
+          return { success: false, error: :install_failed, **result }
+        end
+
+        formatter.success("Phase 1 complete: #{result[:installed]} gem(s) installed") unless options[:json]
+        { success: true, **result }
+      end
+
+      # Phase 2: Wire relationships, seed rules, register settings.
+      # Requires that extensions have been loaded and registered (LexRegister).
+      def phase2_wire
+        formatter.header('Fleet Setup - Phase 2: Wire') unless options[:json]
+
+        require 'legion/workflow/manifest'
+        require 'legion/workflow/loader'
+
+        manifest = Legion::Workflow::Manifest.new(path: MANIFEST_PATH)
+        unless manifest.valid?
+          formatter.error("Invalid manifest: #{manifest.errors.join(', ')}") unless options[:json]
+          return { success: false, error: :invalid_manifest, errors: manifest.errors }
+        end
+
+        loader_result = Legion::Workflow::Loader.new.install(manifest)
+        unless loader_result[:success]
+          formatter.error("Relationship install failed: #{loader_result[:error]}") unless options[:json]
+          return { success: false, error: :relationship_install_failed, detail: loader_result }
+        end
+
+        apply_planner_timeout_policy
+        rules_result = seed_conditioner_rules
+        settings_result = register_settings
+
+        unless options[:json]
+          formatter.success(
+            "Phase 2 complete: chain_id=#{loader_result[:chain_id]}, " \
+            "#{loader_result[:relationship_ids].size} relationships"
+          )
+        end
+
+        {
+          success:       true,
+          chain_id:      loader_result[:chain_id],
+          relationships: loader_result[:relationship_ids].size,
+          rules:         rules_result,
+          settings:      settings_result
+        }
+      end
+
+      private
+
+      def partition_gems
+        installed = []
+        missing = []
+        FLEET_GEMS.each do |name|
+          Gem::Specification.find_by_name(name)
+          installed << name
+        rescue Gem::MissingSpecError
+          missing << name
+        end
+        [installed, missing]
+      end
+
+      def install_gems(gems = nil)
+        gems ||= partition_gems.last
+        gem_bin = File.join(RbConfig::CONFIG['bindir'], 'gem')
+        installed = 0
+        failed = 0
+
+        gems.each do |name|
+          formatter.spacer unless options[:json]
+          puts "  Installing #{name}..." unless options[:json]
+          output = `#{gem_bin} install #{name} --no-document 2>&1`
+          if $CHILD_STATUS&.success?
+            installed += 1
+          else
+            failed += 1
+            formatter.error("  #{name} failed: #{output.strip.lines.last&.strip}") unless options[:json]
+          end
+        end
+
+        { installed: installed, failed: failed }
+      end
+
+      # Apply RabbitMQ consumer timeout policy for planner queue.
+      # The planner queue needs a longer consumer timeout for LLM plan generation.
+      # Default RabbitMQ consumer timeout is 30min; planner may need up to 60min.
+      def apply_planner_timeout_policy
+        system(
+          'rabbitmqctl', 'set_policy', 'fleet-timeout',
+          '^lex\\.planner\\.', '{"consumer-timeout": 3600000}',
+          '--apply-to', 'queues'
+        )
+        formatter.success('Applied planner queue timeout policy (60min)') unless options[:json]
+      rescue StandardError => e
+        formatter.warn("Planner timeout policy skipped: #{e.message}") unless options[:json]
+      end
+
+      # Register fleet settings and LLM routing overrides via load_module_settings.
+      # This uses the Loader's internal deep_merge and mark_dirty! automatically.
+      def register_settings
+        require 'legion/fleet/settings'
+        Legion::Fleet::Settings.apply!
+        { success: true }
+      rescue StandardError => e
+        formatter.warn("Settings registration skipped: #{e.message}") unless options[:json]
+        { success: false, error: e.message }
+      end
+
+      def seed_conditioner_rules
+        require 'legion/fleet/conditioner_rules'
+        Legion::Fleet::ConditionerRules.seed!
+      rescue StandardError => e
+        formatter.warn("Conditioner rules seeding skipped: #{e.message}") unless options[:json]
+        { success: false, error: e.message }
+      end
+    end
+  end
+end

data/lib/legion/cli/setup_command.rb

@@ -152,6 +152,50 @@ module Legion
         install_pack(:channels)
       end
 
+      desc 'fleet', 'Install and wire the Fleet Pipeline (two-phase: install gems + seed relationships)'
+      option :phase, type: :numeric, desc: 'Run only phase 1 (install) or 2 (wire)'
+      option :dry_run, type: :boolean, default: false, desc: 'Show what would be installed'
+      def fleet
+        require 'legion/cli/fleet_setup'
+        setup = Legion::CLI::FleetSetup.new(formatter: formatter, options: options)
+
+        if options[:dry_run]
+          gems = Legion::CLI::FleetSetup.fleet_gems
+          installed, missing = gems.partition { |g| Gem::Specification.find_by_name(g) rescue nil } # rubocop:disable Style/RescueModifier
+          if options[:json]
+            formatter.json(to_install: missing, already_installed: installed)
+          else
+            formatter.header('Fleet Setup (dry run)')
+            missing.each { |g| puts "  install  #{g}" }
+            installed.each { |g| puts "  skip     #{g} (already installed)" }
+          end
+          return
+        end
+
+        case options[:phase]
+        when 1
+          result = setup.phase1_install
+        when 2
+          Connection.ensure_data
+          result = setup.phase2_wire
+          Connection.shutdown
+        else
+          result = setup.phase1_install
+          if result[:success]
+            formatter.spacer unless options[:json]
+            formatter.warn('Phase 2 requires LegionIO restart to register extensions.') unless options[:json]
+            formatter.warn('Run: legionio start && legionio setup fleet --phase 2') unless options[:json]
+          end
+        end
+
+        formatter.json(result) if options[:json]
+      rescue SystemExit
+        raise
+      rescue StandardError => e
+        formatter.error("Fleet setup failed: #{e.message}")
+        raise SystemExit, 1
+      end
+
       desc 'python', 'Set up Legion Python environment (venv + document/data packages)'
       option :packages, type: :array,   default: [],    banner: 'PKG [PKG...]', desc: 'Additional pip packages to install'
       option :rebuild,  type: :boolean, default: false, desc: 'Destroy and recreate the venv from scratch'

data/lib/legion/cli.rb

@@ -72,6 +72,7 @@ module Legion
     autoload :Broker,         'legion/cli/broker_command'
     autoload :AdminCommand,   'legion/cli/admin_command'
     autoload :Workflow,       'legion/cli/workflow_command'
+    autoload :FleetCommand,   'legion/cli/fleet_command'
     autoload :Mode,           'legion/cli/mode_command'
 
     module Groups
@@ -313,6 +314,9 @@ module Legion
       desc 'workflow SUBCOMMAND', 'Manage workflow bundles'
       subcommand 'workflow', Legion::CLI::Workflow
 
+      desc 'fleet SUBCOMMAND', 'Fleet pipeline operations (status, pending, approve, add, config)'
+      subcommand 'fleet', Legion::CLI::FleetCommand
+
       desc 'mode SUBCOMMAND', 'View and switch extension profiles and process roles'
       subcommand 'mode', Legion::CLI::Mode
 

data/lib/legion/fleet/conditioner_rules.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Legion
+  module Fleet
+    module ConditionerRules
+      # Conditioner rules that complement the relationship conditions.
+      # These are higher-level routing rules that the conditioner evaluates
+      # when a relationship's conditions are met but additional logic is needed.
+      #
+      # The primary routing (which stage follows which) is handled by the
+      # 10 relationships in manifest.yml. These rules provide supplementary
+      # conditioning for edge cases.
+      RULES = [
+        {
+          name:        'fleet-skip-planning-trivial',
+          description: 'Skip planning for trivial fixes (assessor sets planning.enabled=false)',
+          conditions:  {
+            all: [
+              { fact: 'results.config.complexity', operator: 'equal', value: 'trivial' },
+              { fact: 'results.config.planning.enabled', operator: 'equal', value: true }
+            ]
+          },
+          action:      :override,
+          overrides:   { 'results.config.planning.enabled' => false }
+        },
+        {
+          name:        'fleet-skip-validation-trivial',
+          description: 'Skip validation for trivial fixes',
+          conditions:  {
+            all: [
+              { fact: 'results.config.complexity', operator: 'equal', value: 'trivial' },
+              { fact: 'results.config.validation.enabled', operator: 'equal', value: true }
+            ]
+          },
+          action:      :override,
+          overrides:   { 'results.config.validation.enabled' => false }
+        },
+        {
+          name:        'fleet-escalate-max-iterations',
+          description: 'Route to escalation when max iterations exceeded',
+          conditions:  {
+            all: [
+              { fact: 'results.pipeline.review_result.verdict', operator: 'equal', value: 'rejected' },
+              { fact: 'results.pipeline.attempt', operator: 'greater_or_equal', value: 4 }
+            ]
+          },
+          action:      :route,
+          target:      { extension: 'assessor', runner: 'assessor', function: 'escalate' }
+        },
+        {
+          name:        'fleet-critical-production-max-capability',
+          description: 'Critical production issues get maximum capability models',
+          conditions:  {
+            all: [
+              { fact: 'results.config.priority', operator: 'equal', value: 'critical' }
+            ]
+          },
+          action:      :override,
+          overrides:   {
+            'results.config.implementation.solvers'        => 3,
+            'results.config.implementation.validators'     => 3,
+            'results.config.implementation.max_iterations' => 10
+          }
+        },
+        {
+          name:          'fleet-governance-mind-growth',
+          description:   'Mind growth proposals require governance approval',
+          conditions:    {
+            all: [
+              { fact: 'results.source', operator: 'equal', value: 'mind_growth' },
+              { fact: 'results.config.priority', operator: 'in_set', value: %w[high critical] }
+            ]
+          },
+          action:        :require_approval,
+          approval_type: 'fleet.governance.mind_growth'
+        }
+      ].freeze
+
+      def self.rules
+        RULES
+      end
+
+      def self.seed!
+        return { success: false, error: :data_not_available } unless defined?(Legion::Data)
+
+        seeded = RULES.map { |rule| rule[:name] }
+        { success: true, seeded: seeded }
+      end
+    end
+  end
+end

data/lib/legion/fleet/manifest.yml

@@ -0,0 +1,244 @@
+---
+name: fleet-pipeline
+version: "1.0.0"
+description: >-
+  Fleet Pipeline: universal intake-to-done engine. Connects assessor, planner,
+  developer, and validator via conditioner-driven routing. 10 relationships
+  define the flexible pipeline graph per design spec section 4.
+
+requires:
+  - lex-assessor
+  - lex-planner
+  - lex-developer
+  - lex-validator
+  - lex-codegen
+  - lex-eval
+  - lex-exec
+  - lex-tasker
+  - lex-conditioner
+  - lex-transformer
+
+relationships:
+  # Relationship 1: Assessor -> Planner (if planning enabled)
+  - name: fleet-assess-to-plan
+    trigger:
+      extension: assessor
+      runner: assessor
+      function: assess
+    action:
+      extension: planner
+      runner: planner
+      function: plan
+    conditions:
+      all:
+        - fact: results.config.planning.enabled
+          operator: equal
+          value: true
+    allow_new_chains: true
+
+  # Relationship 2: Assessor -> Developer (if planning disabled)
+  - name: fleet-assess-to-develop
+    trigger:
+      extension: assessor
+      runner: assessor
+      function: assess
+    action:
+      extension: developer
+      runner: developer
+      function: implement
+    conditions:
+      all:
+        - fact: results.config.planning.enabled
+          operator: equal
+          value: false
+    allow_new_chains: true
+
+  # Relationship 3: Planner -> Developer (chain inherited)
+  - name: fleet-plan-to-develop
+    trigger:
+      extension: planner
+      runner: planner
+      function: plan
+    action:
+      extension: developer
+      runner: developer
+      function: implement
+    allow_new_chains: false
+
+  # Relationship 4: Developer -> Validator (if validation enabled)
+  - name: fleet-develop-to-validate
+    trigger:
+      extension: developer
+      runner: developer
+      function: implement
+    action:
+      extension: validator
+      runner: validator
+      function: validate
+    conditions:
+      all:
+        - fact: results.config.validation.enabled
+          operator: equal
+          value: true
+    allow_new_chains: false
+
+  # Relationship 4b: Developer feedback -> Validator (when validation enabled)
+  - name: fleet-feedback-to-validate
+    trigger:
+      extension: developer
+      runner: developer
+      function: incorporate_feedback
+    action:
+      extension: validator
+      runner: validator
+      function: validate
+    conditions:
+      all:
+        - fact: results.config.validation.enabled
+          operator: equal
+          value: true
+    allow_new_chains: false
+
+  # Relationship 4c: Developer feedback -> Escalate (when results.escalate == true)
+  - name: fleet-feedback-to-escalate
+    trigger:
+      extension: developer
+      runner: developer
+      function: incorporate_feedback
+    action:
+      extension: assessor
+      runner: assessor
+      function: escalate
+    conditions:
+      all:
+        - fact: results.escalate
+          operator: equal
+          value: true
+    allow_new_chains: false
+
+  # Relationship 5: Developer -> Ship (if validation disabled)
+  - name: fleet-develop-to-ship
+    trigger:
+      extension: developer
+      runner: developer
+      function: implement
+    action:
+      extension: developer
+      runner: ship
+      function: finalize
+    conditions:
+      all:
+        - fact: results.config.validation.enabled
+          operator: equal
+          value: false
+    allow_new_chains: false
+
+  # Relationship 6: Validator -> Ship (approved)
+  - name: fleet-validate-to-ship
+    trigger:
+      extension: validator
+      runner: validator
+      function: validate
+    action:
+      extension: developer
+      runner: ship
+      function: finalize
+    conditions:
+      all:
+        - fact: results.pipeline.review_result.verdict
+          operator: equal
+          value: approved
+    allow_new_chains: false
+
+  # Relationship 7: Validator -> Developer feedback (rejected, under limit)
+  # NOTE: value 4 (not 5) because attempt starts at 0 and increments before
+  # re-entering implement. With value=4: attempts 0,1,2,3 retry (4 retries).
+  # Attempt 4 escalates. This gives exactly max_iterations=5 total runs.
+  # IMPORTANT: This hardcoded value is a safety net. The developer's
+  # incorporate_feedback runner checks the per-item limit internally,
+  # allowing different max_iterations per work item without reseeding.
+  - name: fleet-validate-to-feedback
+    trigger:
+      extension: validator
+      runner: validator
+      function: validate
+    action:
+      extension: developer
+      runner: developer
+      function: incorporate_feedback
+    conditions:
+      all:
+        - fact: results.pipeline.review_result.verdict
+          operator: equal
+          value: rejected
+        - fact: results.pipeline.attempt
+          operator: less_than
+          value: 4
+    allow_new_chains: false
+
+  # Relationship 8: Validator -> Escalate (rejected, at limit)
+  # NOTE: Safety-net fallback. Primary enforcement is in incorporate_feedback.
+  - name: fleet-validate-to-escalate
+    trigger:
+      extension: validator
+      runner: validator
+      function: validate
+    action:
+      extension: assessor
+      runner: assessor
+      function: escalate
+    conditions:
+      all:
+        - fact: results.pipeline.review_result.verdict
+          operator: equal
+          value: rejected
+        - fact: results.pipeline.attempt
+          operator: greater_or_equal
+          value: 4
+    allow_new_chains: false
+
+settings:
+  fleet:
+    enabled: true
+    sources: []
+    llm:
+      routing:
+        escalation:
+          enabled: true
+    planning:
+      enabled: true
+      solvers: 1
+      validators: 1
+      max_iterations: 2
+    implementation:
+      solvers: 1
+      validators: 3
+      max_iterations: 5
+    validation:
+      enabled: true
+      run_tests: true
+      run_lint: true
+      security_scan: true
+      adversarial_review: true
+    feedback:
+      drain_enabled: true
+      max_drain_rounds: 3
+      summarize_after: 2
+    workspace:
+      isolation: worktree
+      cleanup_on_complete: true
+    context:
+      load_repo_docs: true
+      load_file_tree: true
+      max_context_files: 50
+    tracing:
+      stage_comments: true
+      token_tracking: true
+    safety:
+      poison_message_threshold: 2
+      cancel_allowed: true
+    selection:
+      strategy: test_winner
+    escalation:
+      on_max_iterations: human
+      consent_domain: fleet.shipping

data/lib/legion/fleet/settings_defaults.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Legion
+  module Fleet
+    module SettingsDefaults
+      DEFAULTS = {
+        fleet: {
+          enabled:        true,
+          sources:        [],
+          llm:            {
+            routing: {
+              escalation: {
+                enabled: true
+              }
+            }
+          },
+          planning:       {
+            enabled:        true,
+            solvers:        1,
+            validators:     1,
+            max_iterations: 2
+          },
+          implementation: {
+            solvers:        1,
+            validators:     3,
+            max_iterations: 5
+          },
+          validation:     {
+            enabled:            true,
+            run_tests:          true,
+            run_lint:           true,
+            security_scan:      true,
+            adversarial_review: true
+          },
+          feedback:       {
+            drain_enabled:    true,
+            max_drain_rounds: 3,
+            summarize_after:  2
+          },
+          workspace:      {
+            isolation:           :worktree,
+            cleanup_on_complete: true
+          },
+          context:        {
+            load_repo_docs:    true,
+            load_file_tree:    true,
+            max_context_files: 50
+          },
+          tracing:        {
+            stage_comments: true,
+            token_tracking: true
+          },
+          safety:         {
+            poison_message_threshold: 2,
+            cancel_allowed:           true
+          },
+          selection:      {
+            strategy: :test_winner
+          },
+          escalation:     {
+            on_max_iterations: :human,
+            consent_domain:    'fleet.shipping'
+          }
+        }
+      }.freeze
+
+      def self.defaults
+        DEFAULTS
+      end
+
+      def self.write_settings_file(path, force: false)
+        return { success: false, reason: :exists } if File.exist?(path) && !force
+
+        ::FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, ::JSON.pretty_generate(DEFAULTS))
+        { success: true, path: path }
+      end
+    end
+  end
+end

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.8.3
+  version: 1.8.4
 platform: ruby
 authors:
 - Esity
@@ -475,6 +475,7 @@ files:
 - lib/legion/api/default_settings.rb
 - lib/legion/api/events.rb
 - lib/legion/api/extensions.rb
+- lib/legion/api/fleet.rb
 - lib/legion/api/gaia.rb
 - lib/legion/api/governance.rb
 - lib/legion/api/graphql.rb
@@ -665,6 +666,8 @@ files:
 - lib/legion/cli/eval_command.rb
 - lib/legion/cli/failover_command.rb
 - lib/legion/cli/features_command.rb
+- lib/legion/cli/fleet_command.rb
+- lib/legion/cli/fleet_setup.rb
 - lib/legion/cli/function.rb
 - lib/legion/cli/gaia_command.rb
 - lib/legion/cli/generate_command.rb
@@ -845,7 +848,10 @@ files:
 - lib/legion/extensions/hooks/base.rb
 - lib/legion/extensions/permissions.rb
 - lib/legion/extensions/transport.rb
+- lib/legion/fleet/conditioner_rules.rb
+- lib/legion/fleet/manifest.yml
 - lib/legion/fleet/settings.rb
+- lib/legion/fleet/settings_defaults.rb
 - lib/legion/graph/builder.rb
 - lib/legion/graph/exporter.rb
 - lib/legion/guardrails.rb