legionio 1.4.82 → 1.4.85

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be7718191541e7f3c7d122c0df0f74145ef0ed5aa8e4b8a67396932155e4cccf
-  data.tar.gz: 5b4f4e5453fe9667b6424433d8d0ec9cfe524b6f9c35be64f7e4b0edeae1c3f3
+  metadata.gz: 512139af5d950a28790627a762f8dc5f52e37cd093ed2829a9a42aa833ededec
+  data.tar.gz: f80a9bfa077caa791bf68058c91eb1061b9cf3851c1766ef5aedd49e9ecda95e
 SHA512:
-  metadata.gz: dd10e410a69d1cae47dadbaf02f287857410b44e8f8d305c1cd8b555a44a32d2a6b0a63950a3ee2e54d815ef28a25ee7dc08fd7e78a584ec39698b03385bcac0
-  data.tar.gz: ce22d223fd1b67df63878d1e1f4d54273437c01a4359f384dc0658ecf06e1e83481285d2b78afd511ee17fabe75a5cb8342826e5cab6ee63cc49a33ccb3c38e4
+  metadata.gz: ecd74de131841cb6a00d1fe66ccfa51fe0a0eafe649e0cdf26e90c8602127f0d29d7f55b4cfeda0f13908b0eebe9828d61dc380a7518268e29bda49bd780855d
+  data.tar.gz: 9d27ac10782d1e6319e96b517c6da5a819e7b599f15a2e9ae27a5d1f3e33f13d70838bd64390218931ded9be7ec45c3cc28e1e65dc2cedebcbd5faf17fa1ba6a

data/.github/workflows/ci-cd.yml

@@ -1,7 +1,5 @@
 name: CI/CD
 on:
-  push:
-    branches: [main]
   pull_request:
     branches: [main]
 
@@ -33,31 +31,6 @@ jobs:
       - run: bundle install && bundle exec rspec
       - run: bundle exec rubocop
 
-  build:
-    name: Build Image
-    needs: test
-    if: github.ref == 'refs/heads/main'
-    runs-on: ubuntu-latest
-    permissions:
-      packages: write
-    steps:
-      - uses: actions/checkout@v4
-      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          tags: |
-            ghcr.io/legionio/legion:${{ github.sha }}
-            ghcr.io/legionio/legion:latest
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-
   helm-lint:
     name: Helm Lint
     runs-on: ubuntu-latest

data/.github/workflows/ci.yml

@@ -27,3 +27,28 @@ jobs:
           gh api repos/LegionIO/homebrew-tap/dispatches \
             -f event_type=build-daemon \
             -f "client_payload[legionio_version]=${{ needs.release.outputs.version }}"
+
+  docker-build:
+    name: Build Docker Image
+    needs: release
+    if: needs.release.outputs.changed == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: |
+            ghcr.io/legionio/legion:${{ needs.release.outputs.version }}
+            ghcr.io/legionio/legion:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Legion Changelog
 
+## [1.4.85] - 2026-03-20
+
+### Added
+- `legion lex fixes` CLI command to list pending auto-fix patches (filterable by status)
+- `legion lex approve-fix FIX_ID` CLI command to approve LLM-generated fixes
+- `legion lex reject-fix FIX_ID` CLI command to reject LLM-generated fixes
+- `with_data` helper to `legion lex` subcommand class for data-required operations
+
+## [1.4.84] - 2026-03-20
+
+### Added
+- `Legion::Extensions.load_yaml_agents` — loads YAML/JSON agent definitions from `~/.legionio/agents/` or configured directory
+- `generate_yaml_runner` — dynamically generates a runner Module for each agent with `llm`, `script`, and `http` function types
+- YAML agent loading integrated into `hook_extensions` boot sequence
+- Governance API routes under `/api/governance/approvals` (list, show, submit, approve, reject)
+- HTML governance dashboard at `/governance/` with approve/reject buttons, 30s auto-poll, and reviewer dialog
+- Static file serving enabled for `public/` directory in Sinatra
+
+## [1.4.83] - 2026-03-20
+
+### Added
+- `Helpers::Context` for filesystem-based inter-agent context sharing
+- Org chart API endpoint (`GET /api/org-chart`) with dashboard panel
+- Workflow relationship graph API (`GET /api/relationships/graph`)
+- Workflow visualizer web page (`public/workflow/`) with Cytoscape.js
+- `--worktree` flag for `legion chat` with auto-checkpointing
+- `.legion-context/` and `.legion-worktrees/` in generated `.gitignore`
+
 ## [1.4.82] - 2026-03-20
 
 ### Added

data/Dockerfile

@@ -4,8 +4,9 @@ WORKDIR /app
 RUN apt-get update && \
     apt-get install -y --no-install-recommends build-essential libpq-dev git && \
     rm -rf /var/lib/apt/lists/*
-COPY Gemfile Gemfile.lock ./
-RUN bundle config set --local deployment true && \
+COPY Gemfile legionio.gemspec ./
+COPY lib/legion/version.rb lib/legion/
+RUN bundle lock && \
     bundle config set --local without 'development test' && \
     bundle install --jobs 4 --retry 3
 COPY . .

data/lib/legion/api/governance.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Governance
+        def self.registered(app)
+          app.helpers GovernanceHelpers
+          register_approvals(app)
+        end
+
+        module GovernanceHelpers
+          def run_governance_runner(method, **)
+            require 'legion/extensions/audit/runners/approval_queue'
+            runner = Object.new.extend(Legion::Extensions::Audit::Runners::ApprovalQueue)
+            runner.send(method, **)
+          rescue LoadError
+            halt 503, json_error('service_unavailable', 'lex-audit not available', status_code: 503)
+          end
+        end
+
+        def self.register_approvals(app)
+          app.get '/api/governance/approvals' do
+            require_data!
+            result = run_governance_runner(:list_pending,
+                                           tenant_id: params[:tenant_id],
+                                           limit:     (params[:limit] || 50).to_i)
+            json_response(result)
+          end
+
+          app.get '/api/governance/approvals/:id' do
+            require_data!
+            result = run_governance_runner(:show_approval, id: params[:id].to_i)
+            if result[:success]
+              json_response(result)
+            else
+              halt 404, json_error('not_found', 'Approval not found', status_code: 404)
+            end
+          end
+
+          app.post '/api/governance/approvals' do
+            require_data!
+            body = parse_request_body
+            halt 422, json_error('missing_field', 'approval_type is required', status_code: 422) unless body[:approval_type]
+            halt 422, json_error('missing_field', 'requester_id is required', status_code: 422) unless body[:requester_id]
+
+            result = run_governance_runner(:submit,
+                                           approval_type: body[:approval_type],
+                                           payload:       body[:payload] || {},
+                                           requester_id:  body[:requester_id],
+                                           tenant_id:     body[:tenant_id])
+            json_response(result, status_code: 201)
+          end
+
+          app.put '/api/governance/approvals/:id/approve' do
+            require_data!
+            body = parse_request_body
+            halt 422, json_error('missing_field', 'reviewer_id is required', status_code: 422) unless body[:reviewer_id]
+
+            result = run_governance_runner(:approve,
+                                           id:          params[:id].to_i,
+                                           reviewer_id: body[:reviewer_id])
+            json_response(result)
+          end
+
+          app.put '/api/governance/approvals/:id/reject' do
+            require_data!
+            body = parse_request_body
+            halt 422, json_error('missing_field', 'reviewer_id is required', status_code: 422) unless body[:reviewer_id]
+
+            result = run_governance_runner(:reject,
+                                           id:          params[:id].to_i,
+                                           reviewer_id: body[:reviewer_id])
+            json_response(result)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api/org_chart.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module OrgChart
+        def self.registered(app)
+          app.helpers OrgChartHelpers
+          app.get '/api/org-chart' do
+            require_data!
+            departments = build_org_chart
+            json_response({ departments: departments })
+          end
+        end
+
+        module OrgChartHelpers
+          def build_org_chart
+            extensions = Legion::Data::Model::Extension.all
+            workers = Legion::Data::Model::DigitalWorker.all
+
+            extensions.map do |ext|
+              functions = Legion::Data::Model::Function.where(extension_id: ext.id).all
+              {
+                name:  ext.name,
+                roles: functions.map do |func|
+                  ext_workers = workers.select { |w| w.extension_name == ext.name }
+                  {
+                    name:    func.name,
+                    workers: ext_workers.map { |w| { id: w.id, name: w.name, status: w.lifecycle_state } }
+                  }
+                end
+              }
+            end
+          rescue StandardError
+            []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api/workflow.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  class API < Sinatra::Base
+    module Routes
+      module Workflow
+        def self.registered(app)
+          app.helpers WorkflowHelpers
+          app.get '/api/relationships/graph' do
+            require_data!
+            graph = build_relationship_graph(
+              chain_id:  params[:chain_id]&.to_i,
+              extension: params[:extension]
+            )
+            json_response(graph)
+          end
+        end
+
+        module WorkflowHelpers
+          def build_relationship_graph(chain_id: nil, extension: nil)
+            raw = Legion::Graph::Builder.build(chain_id: chain_id)
+
+            nodes = raw[:nodes].map do |id, meta|
+              ext = id.to_s.split('.').first
+              { id: id, label: meta[:label], type: meta[:type], extension: ext }
+            end
+
+            edges = raw[:edges].map do |edge|
+              { source: edge[:from], target: edge[:to], label: edge[:label] }
+            end
+
+            if extension
+              node_ids = nodes.select { |n| n[:extension] == extension }.map { |n| n[:id] }
+              nodes = nodes.select { |n| node_ids.include?(n[:id]) }
+              edges = edges.select { |e| node_ids.include?(e[:source]) || node_ids.include?(e[:target]) }
+            end
+
+            { nodes: nodes, edges: edges }
+          rescue StandardError
+            { nodes: [], edges: [] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/api.rb

@@ -34,6 +34,9 @@ require_relative 'api/audit'
 require_relative 'api/metrics'
 require_relative 'api/llm'
 require_relative 'api/catalog'
+require_relative 'api/org_chart'
+require_relative 'api/workflow'
+require_relative 'api/governance'
 
 module Legion
   class API < Sinatra::Base
@@ -42,6 +45,8 @@ module Legion
 
     set :show_exceptions, false
     set :raise_errors, false
+    set :public_folder, File.expand_path('../../public', __dir__)
+    set :static, true
 
     configure do
       set :logging, nil
@@ -91,6 +96,7 @@ module Legion
     register Routes::Extensions
     register Routes::Nodes
     register Routes::Schedules
+    register Routes::Workflow
     register Routes::Relationships
     register Routes::Chains
     register Routes::Settings
@@ -110,6 +116,8 @@ module Legion
     register Routes::Metrics
     register Routes::Llm
     register Routes::ExtensionCatalog
+    register Routes::OrgChart
+    register Routes::Governance
 
     use Legion::Rbac::Middleware if defined?(Legion::Rbac::Middleware)
 

data/lib/legion/cli/acp_command.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Legion
+  module CLI
+    class Acp < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      desc 'stdio', 'Start ACP agent with stdio transport (default)'
+      def stdio
+        require 'legion/extensions/acp'
+
+        transport = Legion::Extensions::Acp::Transport::Stdio.new
+        agent     = Legion::Extensions::Acp::Runners::Agent.new(transport: transport)
+
+        transport.log('LegionIO ACP agent started (stdio)')
+
+        setup_llm if llm_available?
+
+        transport.run { |msg| agent.dispatch(msg) }
+      end
+
+      default_command :stdio
+
+      no_commands do
+        private
+
+        def llm_available?
+          require 'legion/llm'
+          true
+        rescue LoadError
+          false
+        end
+
+        def setup_llm
+          require 'legion/cli/connection'
+          Connection.ensure_settings
+          Connection.ensure_llm
+        rescue StandardError => e
+          warn("[lex-acp] LLM setup failed: #{e.message} — running without prompt support")
+        end
+      end
+    end
+  end
+end

data/lib/legion/cli/chat_command.rb

@@ -30,6 +30,7 @@ module Legion
       class_option :fork,     type: :string, desc: 'Fork a saved session (load but save as new)'
       class_option :add_dir,  type: :array, default: [], desc: 'Additional directories to include in context'
       class_option :personality, type: :string, desc: 'Communication style (concise, verbose, educational)'
+      class_option :worktree, type: :boolean, default: false, desc: 'Run in isolated git worktree'
 
       autoload :Session, 'legion/cli/chat/session'
       autoload :StatusIndicator, 'legion/cli/chat/status_indicator'
@@ -54,6 +55,7 @@ module Legion
         load_custom_agents
 
         setup_notification_bridge
+        setup_worktree(out) if options[:worktree]
 
         chat_log.info "session started model=#{@session.model_id} incognito=#{incognito?}"
         out.banner(version: Legion::VERSION)
@@ -311,6 +313,7 @@ module Legion
                   index: tool_index, total: tool_total
                               })
                 puts out.dim("  [result] #{result_preview}")
+                worktree_auto_checkpoint
               }
             ) do |chunk|
               buffer << chunk.content if chunk.content
@@ -409,6 +412,7 @@ module Legion
           when '/quit', '/exit', '/q'
             show_session_stats(out)
             auto_save_session(out)
+            cleanup_worktree(out) if @worktree_path
             raise SystemExit, 0
           when '/help', '/h'
             show_help(out)
@@ -774,6 +778,11 @@ module Legion
         end
 
         def handle_rewind(arg, out)
+          if @worktree_path
+            handle_worktree_rewind(arg, out)
+            return
+          end
+
           require 'legion/cli/chat/checkpoint'
           if Chat::Checkpoint.entries.none?
             out.warn('No checkpoints available to rewind.')
@@ -1149,6 +1158,82 @@ module Legion
         def api_port_for_chat
           4567
         end
+
+        def setup_worktree(out)
+          require 'legion/extensions/exec/helpers/worktree'
+          @worktree_task_id = "chat-#{SecureRandom.hex(4)}"
+          @checkpoint_count = 0
+          wt = Legion::Extensions::Exec::Helpers::Worktree.create(task_id: @worktree_task_id)
+          if wt[:success]
+            @worktree_path = wt[:path]
+            Dir.chdir(@worktree_path)
+            out.success("Worktree created: #{@worktree_path} (branch: #{wt[:branch]})")
+            chat_log.info "worktree created path=#{@worktree_path} branch=#{wt[:branch]}"
+          else
+            out.warn("Worktree creation failed: #{wt[:reason]}. Continuing without worktree.")
+            chat_log.warn "worktree creation failed: #{wt.inspect}"
+          end
+        rescue LoadError
+          out.warn('lex-exec not available. --worktree requires lex-exec. Continuing without worktree.')
+        end
+
+        def worktree_auto_checkpoint
+          return unless @worktree_path
+
+          require 'legion/extensions/exec/helpers/checkpoint'
+          @checkpoint_count += 1
+          Legion::Extensions::Exec::Helpers::Checkpoint.save(
+            worktree_path: @worktree_path,
+            label:         "step-#{@checkpoint_count}",
+            task_id:       @worktree_task_id
+          )
+        rescue StandardError => e
+          chat_log.debug "worktree checkpoint failed: #{e.message}"
+        end
+
+        def handle_worktree_rewind(arg, out)
+          require 'legion/extensions/exec/helpers/checkpoint'
+          list = Legion::Extensions::Exec::Helpers::Checkpoint.list_checkpoints(task_id: @worktree_task_id)
+          if list[:checkpoints].empty?
+            out.warn('No worktree checkpoints available.')
+            return
+          end
+
+          label = if arg.nil? || arg.strip.empty?
+                    list[:checkpoints].last[:label]
+                  elsif arg.strip.match?(/\A\d+\z/)
+                    target = [list[:checkpoints].size - arg.strip.to_i, 0].max
+                    list[:checkpoints][target][:label]
+                  else
+                    arg.strip
+                  end
+
+          result = Legion::Extensions::Exec::Helpers::Checkpoint.restore(
+            worktree_path: @worktree_path, label: label, task_id: @worktree_task_id
+          )
+          if result[:success]
+            chat_log.info "worktree rewind to #{label}"
+            out.success("Restored to checkpoint: #{label}")
+          else
+            out.warn("Rewind failed: #{result[:message]}")
+          end
+        end
+
+        def cleanup_worktree(out)
+          require 'legion/extensions/exec/helpers/worktree'
+          require 'legion/extensions/exec/helpers/checkpoint'
+
+          checkpoints = Legion::Extensions::Exec::Helpers::Checkpoint.list_checkpoints(task_id: @worktree_task_id)
+          if checkpoints[:checkpoints].any?
+            out.info("Worktree has #{checkpoints[:checkpoints].size} checkpoint(s). Branch: legion/#{@worktree_task_id}")
+            out.info('Worktree preserved. Merge manually or run: git worktree remove <path>')
+          else
+            Legion::Extensions::Exec::Helpers::Worktree.remove(task_id: @worktree_task_id)
+            out.info('Worktree removed (no checkpoints).')
+          end
+        rescue StandardError => e
+          chat_log.warn "worktree cleanup error: #{e.message}"
+        end
       end
     end
   end

data/lib/legion/cli/dashboard/renderer.rb

@@ -17,6 +17,8 @@ module Legion
           lines << events_section(data[:events] || [])
           lines << separator
           lines << health_section(data[:health] || {})
+          lines << separator
+          lines << org_chart_section(data[:departments] || [])
           lines << footer_line(data[:fetched_at])
           lines.flatten.join("\n")
         end
@@ -63,6 +65,24 @@ module Legion
           "Health: #{components.empty? ? 'unknown' : components}"
         end
 
+        def org_chart_section(departments)
+          lines = ['Org Chart:']
+          if departments.empty?
+            lines << '  (no departments)'
+          else
+            departments.each do |dept|
+              lines << "  #{dept[:name]}"
+              (dept[:roles] || []).each do |role|
+                lines << "    +-- #{role[:name]}"
+                (role[:workers] || []).each do |w|
+                  lines << "    |   +-- #{w[:name]} (#{w[:status]})"
+                end
+              end
+            end
+          end
+          lines
+        end
+
         def footer_line(fetched_at)
           "Last updated: #{fetched_at&.strftime('%H:%M:%S') || 'never'} | Press q to quit, r to refresh"
         end

data/lib/legion/cli/init/config_generator.rb

@@ -39,11 +39,33 @@ module Legion
             settings_path = File.join(workspace_dir, 'settings.json')
             File.write(settings_path, "{}\n") unless File.exist?(settings_path)
 
+            ensure_gitignore_entries(dir)
+
             workspace_dir
           end
 
+          GITIGNORE_ENTRIES = %w[
+            .legion-context/
+            .legion-worktrees/
+          ].freeze
+
           private
 
+          def ensure_gitignore_entries(dir)
+            gitignore_path = File.join(dir, '.gitignore')
+            existing = File.exist?(gitignore_path) ? File.read(gitignore_path) : ''
+            existing_lines = existing.lines.map(&:chomp)
+
+            additions = GITIGNORE_ENTRIES.reject { |entry| existing_lines.include?(entry) }
+            return if additions.empty?
+
+            content = existing
+            content += "\n" unless content.empty? || content.end_with?("\n")
+            content += "# Legion workspace\n" unless existing_lines.any? { |l| l.include?('Legion') }
+            content += "#{additions.join("\n")}\n"
+            File.write(gitignore_path, content)
+          end
+
           def render_template(path, options)
             template = File.read(path)
             ERB.new(template, trim_mode: '-').result_with_hash(options: options)

data/lib/legion/cli/lex_cli_manifest.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Legion
+  module CLI
+    class LexCliManifest
+      attr_reader :cache_dir
+
+      def initialize(cache_dir: File.expand_path('~/.legionio/cache/cli'))
+        @cache_dir = cache_dir
+        FileUtils.mkdir_p(@cache_dir)
+      end
+
+      def write_manifest(gem_name:, gem_version:, alias_name:, commands:)
+        data = { 'gem' => gem_name, 'version' => gem_version, 'alias' => alias_name,
+                 'commands' => serialize_commands(commands) }
+        File.write(manifest_path(gem_name), ::JSON.pretty_generate(data))
+      end
+
+      def read_manifest(gem_name)
+        path = manifest_path(gem_name)
+        return nil unless File.exist?(path)
+
+        ::JSON.parse(File.read(path))
+      end
+
+      def resolve_alias(name)
+        all_manifests.each do |m|
+          return m['gem'] if m['alias'] == name
+        end
+        nil
+      end
+
+      def all_manifests
+        Dir.glob(File.join(@cache_dir, 'lex-*.json')).map do |path|
+          ::JSON.parse(File.read(path))
+        rescue StandardError
+          nil
+        end.compact
+      end
+
+      def stale?(gem_name, current_version)
+        m = read_manifest(gem_name)
+        return true unless m
+
+        m['version'] != current_version
+      end
+
+      private
+
+      def manifest_path(gem_name)
+        File.join(@cache_dir, "#{gem_name}.json")
+      end
+
+      def serialize_commands(commands)
+        commands.transform_values do |cmd|
+          {
+            'class'   => cmd[:class_name],
+            'methods' => cmd[:methods].transform_values { |m| { 'desc' => m[:desc], 'args' => m[:args] } }
+          }
+        end
+      end
+    end
+  end
+end