legionio 1.5.22 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc118d8800708d94fc279455bd379cda4f159cc535b6af290997aacf311765bb
-  data.tar.gz: b144e6d8fa85659d6a929f427c611ddd5e5288bfce404eeb11b41bfe1f85d82f
+  metadata.gz: 6413e545fabb634ddda16a99e884701751aa1cdd8245b649799f4836ae0c7360
+  data.tar.gz: 4239fd5af0278ba21cf33bbd320e62e67b103d93d36f3f5266eb5269019b7859
 SHA512:
-  metadata.gz: ba5b7bfc06588c0a8f3e6e5d123e481a847e72614e76bb312b3dbf78bec3f55d56c539fd501db189a6827ab81a36716377084c8419a11548c5a1463fa4fe5dc8
-  data.tar.gz: 35580f0a9895e93c225fe596a02379f57a21669e67b2485805beb37ec9082c4098302b6dfb465ec5f21f06d9265e0bc103dd882ec68377e8f4e4ce2d891c3d59
+  metadata.gz: 2dee1932ef724c587ff8d26c496913cb7b90b1385f7793b3d13c7e3e703440c0b6ad4f7b431215c395ee742cd920afebcda784e29feca058d67a6afb73cb0abb
+  data.tar.gz: fd476599db94cf729ed3e5b66f82f1f090b44215222c24e6a8cf8e6d67c9837fd204561c6054f83505b0fc194a3766aef365eadaa46712babb5750dde82383c3

data/CHANGELOG.md

@@ -1,7 +1,24 @@
 # Legion Changelog
 
+## [1.6.0] - 2026-03-26
+
+### Added
+- `legion knowledge monitor add/list/remove/status` — multi-directory corpus monitor management
+- `legion knowledge capture commit` — capture git commit as knowledge (hook-compatible)
+- `legion knowledge capture session` — capture session summary as knowledge (hook-compatible)
+- `legion setup claude-code` now installs write-back hooks for automatic knowledge capture
+- `resolve_corpus_path` falls back to first registered monitor when no explicit path given
+
+## [1.5.23] - 2026-03-26
+
+### Changed
+- Remove all lex-memory references from service.rb, API coldstart, and OpenAPI docs; use lex-agentic-memory namespace everywhere
+
 ## [1.5.22] - 2026-03-26
 
+### Fixed
+- `coldstart ingest` no longer crashes when lex-memory is absent; uses lex-agentic-memory trace store instead
+
 ### Changed
 - Consolidate 48 root CLI commands into 7 groups + 19 root commands
 - New groups: `ai`, `git`, `pipeline`, `ops`, `serve`, `admin`, `dev`

data/CLAUDE.md

@@ -9,7 +9,7 @@ The primary gem for the LegionIO framework. An extensible async job engine for s
 
 **GitHub**: https://github.com/LegionIO/LegionIO
 **Gem**: `legionio`
-**Version**: 1.4.197
+**Version**: 1.6.0
 **License**: Apache-2.0
 **Docker**: `legionio/legion`
 **Ruby**: >= 3.4
@@ -47,12 +47,13 @@ Legion.start
       ├── 6.  setup_data         (legion-data, MySQL/SQLite + migrations, optional)
       ├── 7.  setup_rbac         (legion-rbac, optional)
       ├── 8.  setup_llm          (legion-llm, AI provider setup + routing, optional)
-      ├── 9.  setup_gaia         (legion-gaia, cognitive coordination layer, optional)
-      ├── 10. setup_telemetry    (OpenTelemetry, optional)
-      ├── 11. setup_supervision  (process supervision)
-      ├── 12. load_extensions    (parallel require+autobuild on 4-thread pool, then hook_all_actors)
-      ├── 13. Legion::Crypt.cs   (distribute cluster secret)
-      └── 14. setup_api          (start Sinatra/Puma on port 4567)
+      ├── 9.  setup_apollo       (legion-apollo, shared + local knowledge store, optional)
+      ├── 10. setup_gaia         (legion-gaia, cognitive coordination layer, optional)
+      ├── 11. setup_telemetry    (OpenTelemetry, optional)
+      ├── 12. setup_supervision  (process supervision)
+      ├── 13. load_extensions    (two-phase parallel: require+autobuild on FixedThreadPool, then hook_all_actors)
+      ├── 14. Legion::Crypt.cs   (distribute cluster secret)
+      └── 15. setup_api          (start Sinatra/Puma on port 4567)
 ```
 
 Each phase calls `Legion::Readiness.mark_ready(:component)`. All phases are individually toggleable via `Service.new(transport: false, ...)`.
@@ -150,7 +151,7 @@ Legion (lib/legion.rb)
 │                      # Populated by Builders::Routes during autobuild
 │
 ├── MCP (legion-mcp gem)  # Extracted to standalone gem — see legion-mcp/CLAUDE.md
-│   └── (41 tools, 2 resources, TierRouter, PatternStore, ContextGuard, Observer, EmbeddingIndex)
+│   └── (58 tools, 2 resources, TierRouter, PatternStore, ContextGuard, Observer, EmbeddingIndex)
 │
 ├── DigitalWorker      # Digital worker platform (AI-as-labor governance)
 │   ├── Lifecycle      # Worker state machine (active/paused/retired/terminated)
@@ -194,7 +195,7 @@ Legion (lib/legion.rb)
     │   ├── Session        # Multi-turn chat session with streaming
     │   ├── SessionStore   # Persistent session save/load/list/resume/fork
     │   ├── Permissions    # Tool permission model (interactive/auto_approve/read_only)
-    │   ├── ToolRegistry   # Chat tool discovery and registration (40 built-in + extension tools)
+    │   ├── ToolRegistry   # Chat tool discovery and registration (40 built-in tools + extension tools)
     │   ├── ExtensionTool    # permission_tier DSL module for LEX chat tools (:read/:write/:shell)
     │   ├── ExtensionToolLoader # Lazy discovery of tools/ directories from loaded extensions
     │   ├── Context        # Project awareness (git, language, instructions, extra dirs)
@@ -480,7 +481,7 @@ legion
 
 ### MCP Design
 
-Extracted to the `legion-mcp` gem (v0.5.5). See `legion-mcp/CLAUDE.md` for full architecture.
+Extracted to the `legion-mcp` gem (v0.5.9). See `legion-mcp/CLAUDE.md` for full architecture.
 
 - `Legion::MCP.server` is memoized singleton — call `Legion::MCP.reset!` in tests
 - Tool naming: `legion.snake_case_name` (dot namespace, not slash)
@@ -768,7 +769,7 @@ rack-test, rake, rspec, rubocop, rubocop-rspec, simplecov
 
 ```bash
 bundle install
-bundle exec rspec       # 3194 examples, 0 failures
+bundle exec rspec       # ~3500+ examples, 0 failures
 bundle exec rubocop     # 0 offenses
 ```
 

data/README.md

@@ -8,13 +8,13 @@ Schedule tasks, chain services into dependency graphs, run them concurrently via
          ╭──────────────────────────────────────╮
          │           L E G I O N I O            │
          │                                      │
-         │   280+ extensions  ·  41 MCP tools   │
+         │   280+ extensions  ·  58 MCP tools   │
          │   AI chat CLI  ·  REST API  ·  HA    │
          │   cognitive architecture  ·  Vault    │
          ╰──────────────────────────────────────╯
 ```
 
-**Ruby >= 3.4** | **v1.4.197** | **Apache-2.0** | [@Esity](https://github.com/Esity)
+**Ruby >= 3.4** | **v1.5.20** | **Apache-2.0** | [@Esity](https://github.com/Esity)
 
 ---
 
@@ -33,7 +33,7 @@ When A completes, B runs. B triggers C, D, and E in parallel. Conditions gate ex
 But that's just the foundation. LegionIO is also:
 
 - **An AI coding assistant** — interactive chat with tools, code review, commit messages, PR generation, and multi-agent workflows
-- **An MCP server** — 35 tools that let any AI agent run tasks, manage extensions, and query your infrastructure
+- **An MCP server** — 58 tools that let any AI agent run tasks, manage extensions, and query your infrastructure
 - **A cognitive computing platform** — 242 brain-modeled extensions across 18 cognitive domains
 - **A digital worker platform** — AI-as-labor with governance, risk tiers, and cost tracking
 
@@ -49,7 +49,7 @@ For the AI features:
 
 ```bash
 legion                    # launch the interactive TTY shell
-legion chat               # interactive AI REPL with 10 built-in tools
+legion chat               # interactive AI REPL with 40 built-in tools
 legion commit             # AI-generated commit message from staged changes
 legion review             # AI code review of your code
 ```
@@ -162,7 +162,7 @@ legion chat prompt "explain main.rb"    # single-prompt mode
 echo "fix the bug" | legion chat prompt - # pipe from stdin
 ```
 
-**10 built-in tools**: read_file, write_file, edit_file, search_files, search_content, run_command, save_memory, search_memory, web_search, spawn_agent
+**40 built-in tools**: read_file, write_file, edit_file, search_files, search_content, run_command, save_memory, search_memory, web_search, spawn_agent, search_traces, query_knowledge, ingest_knowledge, consolidate_memory, relate_knowledge, knowledge_maintenance, knowledge_stats, summarize_traces, list_extensions, manage_tasks, system_status, view_events, cost_summary, reflect, manage_schedules, worker_status, detect_anomalies, view_trends, trigger_dream, generate_insights, budget_status, provider_health, model_comparison, shadow_eval_status, entity_extract, arbitrage_status, escalation_status, graph_explore, scheduling_status, memory_status
 
 **Slash commands**: `/help` `/quit` `/cost` `/status` `/clear` `/new` `/save` `/load` `/sessions` `/compact` `/fetch URL` `/search QUERY` `/diff` `/copy` `/rewind` `/memory` `/agent` `/agents` `/plan` `/swarm` `/review` `/permissions` `/personality` `/model` `/edit` `/commit` `/workers` `/dream`
 
@@ -200,6 +200,39 @@ legion memory search "testing"
 legion memory forget 3
 ```
 
+### Knowledge
+
+Query and manage the Apollo shared knowledge store and local knowledge index:
+
+```bash
+legion knowledge query "how does transport routing work?"
+legion knowledge retrieve "embedding cosine similarity" --scope global
+legion knowledge ingest /path/to/docs/
+legion knowledge status             # index stats, embedding coverage
+legion knowledge health             # detect orphans, quality metrics
+legion knowledge maintain           # cleanup orphans, reindex
+legion knowledge quality            # quality report
+```
+
+### Mind Growth
+
+Autonomous cognitive architecture expansion system. Analyzes gaps, proposes new cognitive extensions, and builds them via a staged pipeline:
+
+```bash
+legion mind-growth status           # current growth cycle state
+legion mind-growth analyze          # gap analysis against 5 reference models
+legion mind-growth propose          # propose a new concept
+legion mind-growth evaluate <id>    # evaluate a proposal
+legion mind-growth build <id>       # run staged build pipeline
+legion mind-growth list             # list proposals
+legion mind-growth approve <id>     # manually approve
+legion mind-growth reject <id>      # manually reject
+legion mind-growth profile          # cognitive profile across all models
+legion mind-growth health           # extension fitness validation
+```
+
+Requires `lex-mind-growth`. Also exposes 6 MCP tools in the `legion.mind_growth_*` namespace.
+
 ### Digital Workers
 
 AI-as-labor with governance, risk tiers, and cost tracking:
@@ -326,7 +359,7 @@ legion mcp http           # streamable HTTP on localhost:9393
 legion mcp http --port 8080 --host 0.0.0.0
 ```
 
-**41 tools** in the `legion.*` namespace:
+**58 tools** in the `legion.*` namespace:
 
 | Category | Tools |
 |----------|-------|
@@ -340,6 +373,8 @@ legion mcp http --port 8080 --host 0.0.0.0
 | **Workers** | `list_workers`, `show_worker`, `worker_lifecycle`, `worker_costs`, `team_summary` |
 | **RBAC** | `rbac_assignments`, `rbac_check`, `rbac_grants` |
 | **Analytics** | `routing_stats` |
+| **Knowledge** | `query_knowledge`, `knowledge_health` |
+| **Mind Growth** | `mind_growth_status`, `mind_growth_analyze`, `mind_growth_propose`, `mind_growth_evaluate`, `mind_growth_build`, `mind_growth_profile` |
 
 **Resources**: `legion://runners` (full runner catalog), `legion://extensions/{name}` (extension detail)
 
@@ -475,19 +510,21 @@ Before any Legion code loads, the executable applies three performance optimizat
 ```
 legion start
   └── Legion::Service
-      ├── 1. Logging          (legion-logging)
-      ├── 2. Settings         (legion-settings — /etc/legionio, ~/legionio, ./settings)
-      ├── 3. Crypt            (legion-crypt — Vault connection)
-      ├── 4. Transport        (legion-transport — RabbitMQ)
-      ├── 5. Cache            (legion-cache — Redis/Memcached)
-      ├── 6. Data             (legion-data — database + migrations)
-      ├── 7. RBAC             (legion-rbac — optional role-based access control)
-      ├── 8. LLM              (legion-llm — AI provider setup + routing)
-      ├── 9. GAIA             (legion-gaia — cognitive coordination layer)
-      ├── 10. Supervision     (process supervision)
-      ├── 11. Extensions      (discover + load 280+ LEX gems, filtered by role profile)
-      ├── 12. Cluster Secret  (distribute via Vault or memory)
-      └── 13. API             (Sinatra/Puma on port 4567)
+      ├── 1.  Logging          (legion-logging)
+      ├── 2.  Settings         (legion-settings — /etc/legionio, ~/legionio, ./settings)
+      ├── 3.  Crypt            (legion-crypt — Vault connection)
+      ├── 4.  Transport        (legion-transport — RabbitMQ)
+      ├── 5.  Cache            (legion-cache — Redis/Memcached)
+      ├── 6.  Data             (legion-data — database + migrations)
+      ├── 7.  RBAC             (legion-rbac — optional role-based access control)
+      ├── 8.  LLM              (legion-llm — AI provider setup + routing)
+      ├── 9.  Apollo           (legion-apollo — shared/local knowledge store)
+      ├── 10. GAIA             (legion-gaia — cognitive coordination layer)
+      ├── 11. Telemetry        (OpenTelemetry — optional)
+      ├── 12. Supervision      (process supervision)
+      ├── 13. Extensions       (two-phase parallel load: require+autobuild, then hook_all_actors)
+      ├── 14. Cluster Secret   (distribute via Vault or memory)
+      └── 15. API              (Sinatra/Puma on port 4567)
 ```
 
 Each phase registers with `Legion::Readiness`. All phases are individually toggleable.

data/lib/legion/api/coldstart.rb

@@ -19,12 +19,13 @@ module Legion
               halt 503, json_error('coldstart_unavailable', 'lex-coldstart is not loaded', status_code: 503)
             end
 
-            unless defined?(Legion::Extensions::Memory)
-              Legion::Logging.warn 'API POST /api/coldstart/ingest returned 503: lex-memory is not loaded'
-              halt 503, json_error('memory_unavailable', 'lex-memory is not loaded', status_code: 503)
+            unless defined?(Legion::Extensions::Agentic::Memory::Trace)
+              Legion::Logging.warn 'API POST /api/coldstart/ingest returned 503: lex-agentic-memory is not loaded'
+              halt 503, json_error('memory_unavailable', 'lex-agentic-memory is not loaded', status_code: 503)
             end
 
             runner = Object.new.extend(Legion::Extensions::Coldstart::Runners::Ingest)
+            runner.define_singleton_method(:log) { Legion::Logging } unless runner.respond_to?(:log)
 
             result = if File.file?(path)
                        runner.ingest_file(file_path: File.expand_path(path))

data/lib/legion/api/openapi.rb

@@ -128,7 +128,7 @@ module Legion
           { name: 'Lex',           description: 'Auto-registered LEX runner routes' },
           { name: 'Workers',       description: 'Digital worker lifecycle management' },
           { name: 'Teams',         description: 'Team-level worker and cost views' },
-          { name: 'Coldstart',     description: 'Cold-start memory ingestion (requires lex-coldstart + lex-memory)' },
+          { name: 'Coldstart',     description: 'Cold-start memory ingestion (requires lex-coldstart + lex-agentic-memory)' },
           { name: 'Gaia',          description: 'Gaia cognitive layer status' },
           { name: 'Apollo',        description: 'Apollo knowledge graph (requires lex-apollo + legion-data)' },
           { name: 'OpenAPI',       description: 'OpenAPI spec endpoint' }
@@ -1384,8 +1384,8 @@ module Legion
           '/api/coldstart/ingest' => {
             post: {
               tags:        ['Coldstart'],
-              summary:     'Ingest a file or directory into lex-memory',
-              description: 'Requires lex-coldstart and lex-memory to be loaded.',
+              summary:     'Ingest a file or directory into agentic memory',
+              description: 'Requires lex-coldstart and lex-agentic-memory to be loaded.',
               operationId: 'coldstartIngest',
               requestBody: {
                 required: true,
@@ -1404,7 +1404,7 @@ module Legion
                 '401' => UNAUTH_RESPONSE,
                 '404' => NOT_FOUND_RESPONSE,
                 '422' => UNPROCESSABLE_RESPONSE,
-                '503' => { description: 'lex-coldstart or lex-memory not loaded' }
+                '503' => { description: 'lex-coldstart or lex-agentic-memory not loaded' }
               }
             }
           }

data/lib/legion/cli/coldstart_command.rb

@@ -11,10 +11,10 @@ module Legion
       class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
       class_option :verbose,  type: :boolean, default: false, aliases: ['-V'], desc: 'Verbose logging'
 
-      desc 'ingest [PATH...]', 'Ingest Claude memory/CLAUDE.md files into lex-memory traces'
+      desc 'ingest [PATH...]', 'Ingest Claude memory/CLAUDE.md files into agentic memory traces'
       long_desc <<~DESC
         Parse Claude Code MEMORY.md or CLAUDE.md files and convert them into
-        lex-memory traces for cold start bootstrapping.
+        agentic memory traces for cold start bootstrapping.
 
         Accepts any number of file or directory paths. When given a directory,
         all CLAUDE.md and MEMORY.md files are discovered recursively.
@@ -59,7 +59,7 @@ module Legion
         require_coldstart!
         paths = [Dir.pwd] if paths.empty?
 
-        runner = Object.new.extend(Legion::Extensions::Coldstart::Runners::Ingest)
+        runner = build_runner(Legion::Extensions::Coldstart::Runners::Ingest)
 
         paths.each do |path|
           if File.file?(path)
@@ -83,7 +83,7 @@ module Legion
         out = formatter
         require_coldstart!
 
-        runner = Object.new.extend(Legion::Extensions::Coldstart::Runners::Coldstart)
+        runner = build_runner(Legion::Extensions::Coldstart::Runners::Coldstart)
         progress = runner.coldstart_progress
 
         if options[:json]
@@ -111,7 +111,7 @@ module Legion
         end
 
         def run_local_ingest(out, path, dry_run:)
-          runner = Object.new.extend(Legion::Extensions::Coldstart::Runners::Ingest)
+          runner = build_runner(Legion::Extensions::Coldstart::Runners::Ingest)
 
           if File.file?(path)
             result = dry_run ? runner.preview_ingest(file_path: File.expand_path(path)) : runner.ingest_file(file_path: File.expand_path(path))
@@ -152,10 +152,23 @@ module Legion
           4567
         end
 
+        def build_runner(mod)
+          obj = Object.new
+          obj.extend(mod)
+          obj.define_singleton_method(:log) { Legion::Logging } unless obj.respond_to?(:log)
+          obj
+        end
+
         def require_coldstart!
           require 'legion/logging'
           Legion::Logging.setup(level: options[:verbose] ? 'debug' : 'warn') unless Legion::Logging.instance_variable_get(:@log)
-          require 'legion/extensions/memory'
+
+          begin
+            require 'legion/extensions/agentic/memory/trace'
+          rescue LoadError
+            Legion::Logging.debug('lex-agentic-memory not available, traces will be parsed but not stored') if defined?(Legion::Logging)
+          end
+
           require 'legion/extensions/coldstart'
         rescue LoadError => e
           formatter.error("lex-coldstart not available: #{e.message}")

data/lib/legion/cli/knowledge_command.rb

@@ -2,6 +2,184 @@
 
 module Legion
   module CLI
+    class MonitorCommand < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,     type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+
+      desc 'add PATH', 'Add a directory to corpus monitors'
+      option :extensions, type: :string,  desc: 'Comma-separated file extensions to watch (e.g. md,rb)'
+      option :label,      type: :string,  desc: 'Human-readable label for this monitor'
+      def add(path)
+        require_monitor!
+        exts = options[:extensions]&.split(',')&.map(&:strip)
+        result = Legion::Extensions::Knowledge::Runners::Monitor.add_monitor(
+          path:       path,
+          extensions: exts,
+          label:      options[:label]
+        )
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Monitor added: #{path}")
+        else
+          out.warn("Failed to add monitor: #{result[:error]}")
+        end
+      end
+
+      desc 'list', 'List registered corpus monitors'
+      def list
+        require_monitor!
+        monitors = Legion::Extensions::Knowledge::Runners::Monitor.list_monitors
+        out = formatter
+        if options[:json]
+          out.json(monitors)
+        elsif monitors.nil? || monitors.empty?
+          out.warn('No monitors registered')
+        else
+          out.header('Knowledge Monitors')
+          monitors.each do |m|
+            label = m[:label] ? " [#{m[:label]}]" : ''
+            exts  = m[:extensions]&.join(', ')
+            puts "  #{m[:path]}#{label}"
+            puts "    Extensions: #{exts}" if exts && !exts.empty?
+          end
+        end
+      end
+      default_task :list
+
+      desc 'remove IDENTIFIER', 'Remove a corpus monitor by path or label'
+      def remove(identifier)
+        require_monitor!
+        result = Legion::Extensions::Knowledge::Runners::Monitor.remove_monitor(identifier:)
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Monitor removed: #{identifier}")
+        else
+          out.warn("Failed to remove monitor: #{result[:error]}")
+        end
+      end
+
+      desc 'status', 'Show monitor status (counts)'
+      def status
+        require_monitor!
+        result = Legion::Extensions::Knowledge::Runners::Monitor.monitor_status
+        out = formatter
+        if options[:json]
+          out.json(result)
+        else
+          out.header('Monitor Status')
+          out.detail({
+                       'Total monitors' => result[:total_monitors].to_s,
+                       'Total files'    => result[:total_files].to_s
+                     })
+        end
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
+        end
+
+        def require_monitor!
+          return if defined?(Legion::Extensions::Knowledge::Runners::Monitor)
+
+          raise CLI::Error, 'lex-knowledge extension is not loaded. Install and enable it first.'
+        end
+      end
+    end
+
+    class CaptureCommand < Thor
+      def self.exit_on_failure?
+        true
+      end
+
+      class_option :json,     type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color, type: :boolean, default: false, desc: 'Disable color output'
+
+      desc 'commit', 'Capture the last git commit as knowledge'
+      def commit
+        log_line = `git log -1 --format='%H %s' 2>/dev/null`.strip
+        diff_stat = `git diff HEAD~1 --stat 2>/dev/null`.strip
+
+        if log_line.empty?
+          formatter.warn('No git commit found')
+          return
+        end
+
+        sha, *subject_parts = log_line.split
+        subject = subject_parts.join(' ')
+        content = "Git commit: #{sha}\nSubject: #{subject}\n\nDiff stat:\n#{diff_stat}"
+        tags    = %w[git commit knowledge-capture]
+
+        result = if defined?(Legion::Extensions::Knowledge::Runners::Ingest)
+                   Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
+                     content: content,
+                     tags:    tags,
+                     source:  "git:#{sha}"
+                   )
+                 else
+                   { success: false, error: 'lex-knowledge not loaded' }
+                 end
+
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success("Captured commit #{sha[0, 8]}: #{subject}")
+        else
+          out.warn("Capture failed: #{result[:error]}")
+        end
+      end
+
+      desc 'session', 'Capture a session note from stdin'
+      def session
+        input = $stdin.gets(nil) if $stdin.ready? rescue nil # rubocop:disable Style/RescueModifier
+        input = input.to_s.strip
+
+        if input.empty?
+          formatter.warn('No session input provided (pipe text to stdin)')
+          return
+        end
+
+        repo = `git rev-parse --show-toplevel 2>/dev/null`.strip.split('/').last
+        content = "Session note (#{::Time.now.strftime('%Y-%m-%d')}):\n\n#{input}"
+        tags    = ['session', 'knowledge-capture', ::Time.now.strftime('%Y-%m-%d')]
+        tags   << "repo:#{repo}" unless repo.empty?
+
+        result = if defined?(Legion::Extensions::Knowledge::Runners::Ingest)
+                   Legion::Extensions::Knowledge::Runners::Ingest.ingest_file(
+                     content: content,
+                     tags:    tags,
+                     source:  "session:#{::Time.now.iso8601}"
+                   )
+                 else
+                   { success: false, error: 'lex-knowledge not loaded' }
+                 end
+
+        out = formatter
+        if options[:json]
+          out.json(result)
+        elsif result[:success]
+          out.success('Session captured')
+        else
+          out.warn("Capture failed: #{result[:error]}")
+        end
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
+        end
+      end
+    end
+
     class Knowledge < Thor
       def self.exit_on_failure?
         true
@@ -161,6 +339,12 @@ module Legion
         end
       end
 
+      desc 'monitor SUBCOMMAND', 'Manage knowledge corpus monitors'
+      subcommand 'monitor', MonitorCommand
+
+      desc 'capture SUBCOMMAND', 'Capture knowledge from git commits or sessions'
+      subcommand 'capture', CaptureCommand
+
       no_commands do # rubocop:disable Metrics/BlockLength
         def formatter
           @formatter ||= Output::Formatter.new(json: options[:json], color: !options[:no_color])
@@ -199,6 +383,9 @@ module Legion
         def resolve_corpus_path
           if options[:corpus_path]
             options[:corpus_path]
+          elsif defined?(Legion::Extensions::Knowledge::Runners::Monitor)
+            monitors = Legion::Extensions::Knowledge::Runners::Monitor.resolve_monitors
+            monitors.first&.dig(:path) || legacy_corpus_path || ::Dir.pwd
           elsif defined?(Legion::Settings)
             Legion::Settings.dig(:knowledge, :corpus_path) || ::Dir.pwd
           else
@@ -206,6 +393,12 @@ module Legion
           end
         end
 
+        def legacy_corpus_path
+          return unless defined?(Legion::Settings)
+
+          Legion::Settings.dig(:knowledge, :corpus_path)
+        end
+
         def print_sources(sources, out, verbose:)
           return out.warn('No sources found') if sources.empty?
 

data/lib/legion/cli/setup_command.rb

@@ -78,6 +78,7 @@ module Legion
 
         install_claude_mcp(installed)
         install_claude_skill(installed)
+        install_claude_hooks(installed)
 
         if options[:json]
           out.json(platform: 'claude-code', installed: installed)
@@ -343,6 +344,43 @@ module Legion
           puts "  Wrote slash command skill to #{skill_path}" unless options[:json]
         end
 
+        def install_claude_hooks(installed)
+          settings_path = File.expand_path('~/.claude/settings.json')
+          existing = load_json_file(settings_path)
+
+          hooks = existing['hooks'] || {}
+
+          has_commit  = Array(hooks['PostToolUse']).any? { |h| h['command']&.include?('knowledge capture commit') }
+          has_session = Array(hooks['Stop']).any? { |h| h['command']&.include?('knowledge capture session') }
+          if has_commit && has_session && !options[:force]
+            puts '  Write-back hooks already present (use --force to overwrite)' unless options[:json]
+            return
+          end
+
+          hooks['PostToolUse'] ||= []
+          hooks['Stop'] ||= []
+
+          unless has_commit
+            hooks['PostToolUse'] << {
+              'matcher' => 'Bash',
+              'command' => 'legionio knowledge capture commit',
+              'timeout' => 10_000
+            }
+          end
+
+          unless has_session
+            hooks['Stop'] << {
+              'command' => 'legionio knowledge capture session',
+              'timeout' => 15_000
+            }
+          end
+
+          existing['hooks'] = hooks
+          write_json_file(settings_path, existing)
+          installed << 'hooks'
+          puts '  Installed write-back hooks for knowledge capture' unless options[:json]
+        end
+
         def write_mcp_servers_json(_out, path, installed)
           existing = load_json_file(path)
           servers  = existing['mcpServers'] || {}

data/lib/legion/service.rb

@@ -130,7 +130,7 @@ module Legion
 
       Legion::Gaia.registry&.rediscover if gaia && defined?(Legion::Gaia) && Legion::Gaia.started?
 
-      Legion::Extensions::Memory::Helpers::ErrorTracer.setup if defined?(Legion::Extensions::Memory::Helpers::ErrorTracer)
+      Legion::Extensions::Agentic::Memory::Trace::Helpers::ErrorTracer.setup if defined?(Legion::Extensions::Agentic::Memory::Trace::Helpers::ErrorTracer)
 
       Legion::Crypt.cs if crypt
 

data/lib/legion/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.5.22
+  version: 1.6.0
 platform: ruby
 authors:
 - Esity