kairos-chain 3.7.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cef8ee3fd2052bb3d553e0c7ee0569d50f88fcfadea13dec6722122e2e71adb7
-  data.tar.gz: de6425c1fa691e86ad4e3597f36733b9ca592cb017ad58b69d54aecb64b63dd6
+  metadata.gz: 4facdf3bcb070b304f05d2ba2edd1d115e2f743db24c47864d953280da4c80f0
+  data.tar.gz: debbc87b1676e18e7a3ff200132d956ac8531324aecbf957e625fc6e8cdab059
 SHA512:
-  metadata.gz: bc9dec7fd29edf94dce3de1a18fc90eb006695cb22475195aeb4422f6aa843a0efc1b2fa2e5796891768934c7307fc0687d0420f2883a099b700a80077ae4b7a
-  data.tar.gz: db1e322c0b191ab12d949c403b6b04a5c6d99fccd9dd2e6528754a066a4bf3db26e4fb3e0cba4898826da13887d52f91c3018377a47aa5dd1ee25316f850f7df
+  metadata.gz: af08ba6ddefba694090ca8f989b215ae80e2417e794ad3f3ece1bfb8b73e8aa428c1ea636e2ad9278a268b6f95435a180c043a96db15293e2f3351c2c2efc10b
+  data.tar.gz: c4d15cc38e425154e64cfd5aa52c80c939c3f00ce4ed8d0036c12e282816c0f320dae27bac46df968a8c74d1ac926037b0883244b7ed64827ff16dec18cc4c84

data/CHANGELOG.md

@@ -4,6 +4,74 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.9.0] - 2026-03-30
+
+### Added
+
+- **agent_execute** — Claude Code subprocess delegation for file operations
+  - Delegates Read/Edit/Write/Glob/Grep to a sandboxed `claude -p` subprocess
+  - `--permission-mode acceptEdits` for auto-approval of file edits
+  - `--output-format stream-json` for structured result parsing (files_modified, tool_calls)
+  - 8 security layers: Agent blacklist, tool restriction, Bash gating (requires
+    `Bash(pattern)` in allowed_tools), acceptEdits mode, env scrubbing
+    (unsetenv_others: true), project root lock, --max-budget-usd (clamped to
+    agent.yml max), external timeout (SIGTERM -> SIGKILL)
+  - Configurable via `agent.yml` `agent_execute:` section
+  - Design: 2 rounds x 2-3 LLMs. Implementation: 1 round x 3 LLMs.
+
+- **Agent ACT routing** — automatic delegation based on task plan
+  - `requires_file_operations?` detects Edit/Write/Read/Bash in task steps
+  - File operations route to `agent_execute`; MCP tools route to `autoexec_run`
+  - Context injection via `--append-system-prompt` (goal + progress)
+
+- **SkillSet discovery & install** via `system_upgrade`
+  - `system_upgrade command="skillsets"` lists all available SkillSets with status
+  - New SkillSets in gem templates auto-detected by `upgrade_check`
+  - `system_upgrade command="apply" names=["dream"]` installs specific SkillSets
+  - `available_skillsets` method on SkillSetManager
+
+### Fixed
+
+- `ClaudeCodeAdapter`: removed invalid `--max-turns 1` flag (not in claude CLI)
+- `agent_execute` blacklist: properly removes `agent_*` wildcard + re-adds other agent tools
+- `agent_execute` error propagation: subprocess failures now set `error` key for ACT gates
+
+## [3.8.0] - 2026-03-30
+
+### Added
+
+- **Agent Autonomous Mode** — Multi-cycle OODA loop execution
+  - `agent_start(autonomous: true)`: Enable autonomous mode. Session starts at
+    `[observed]` as before; autonomous loop begins on `agent_step(approve)`.
+  - 8 safety gates: mandate termination, goal drift detection, wall-clock timeout
+    (300s), aggregate LLM budget (60 calls), risk budget, post-ACT termination,
+    confidence-based early exit, checkpoint pause.
+  - New session states: `autonomous_cycling`, `paused_risk`, `paused_error`
+  - Resume handlers: `approve` at `paused_risk` re-checks risk and resumes ACT;
+    `approve`/`skip` at `paused_error` skips failed cycle and continues.
+  - `agent.yml` autonomous config: `max_total_llm_calls`, `max_duration_seconds`,
+    `min_cycles_before_exit`, `confidence_exit_threshold`.
+  - Design: 2 rounds x 3 LLMs. Implementation: 1 round x 3 LLMs. All HIGH fixed.
+
+- **Mandate locking** — `Mandate.with_lock` for single-writer batch execution
+  - File-based exclusive lock (`flock`), non-blocking with `LockError`
+  - Atomic save via tmp+rename pattern
+  - `Mandate.reload` helper for in-lock refresh
+
+- **CognitiveLoop call tracking** — `total_calls` attribute for aggregate
+  LLM budget enforcement across autonomous cycles
+
+- **Goal drift detection** — Content-based hash (not name-only) at mandate
+  creation; per-cycle drift check with fail-open semantics
+
+### Changed
+
+- `run_orient_decide` / `run_act_reflect` refactored into `_internal` (Hash return)
+  + wrapper (text_content) pattern. Manual mode behavior unchanged.
+- Manual risk pause now sets session to `paused_risk` (was `terminated`),
+  enabling resume via `agent_step(approve)`.
+- `MandateAdapter.to_mandate_proposal` uses `dig` for nil safety.
+
 ## [3.7.0] - 2026-03-29
 
 ### Added

data/lib/kairos_mcp/skillset_manager.rb

@@ -131,14 +131,18 @@ module KairosMcp
       { success: true, name: installed.name, version: installed.version, layer: installed.layer, path: dest }
     end
 
-    # Check for available SkillSet upgrades from gem templates
+    # Check for available SkillSet upgrades from gem templates.
+    # Also detects NEW SkillSets in templates that are not yet installed.
     #
-    # @return [Array<Hash>] List of upgradable skillsets with version info
+    # @return [Array<Hash>] List of upgradable/new skillsets with version info
     def upgrade_check
       results = []
       templates_dir = File.join(KairosMcp.gem_root, 'templates', 'skillsets')
       return results unless File.directory?(templates_dir)
 
+      installed_names = all_skillsets.map(&:name)
+
+      # Check existing installed SkillSets for upgrades
       all_skillsets.each do |installed|
         template_path = File.join(templates_dir, installed.name)
         next unless File.directory?(template_path)
@@ -157,17 +161,39 @@ module KairosMcp
             installed_version: installed.version,
             available_version: template_ss.version,
             version_bump: template_ver > installed_ver,
-            changed_files: changed_files
+            changed_files: changed_files,
+            new_skillset: false
           }
         end
       end
 
+      # Detect NEW SkillSets in templates not yet installed
+      Dir.children(templates_dir).sort.each do |name|
+        template_path = File.join(templates_dir, name)
+        next unless File.directory?(template_path)
+        next if installed_names.include?(name)
+
+        template_ss = Skillset.new(template_path)
+        next unless template_ss.valid?
+
+        results << {
+          name: name,
+          installed_version: nil,
+          available_version: template_ss.version,
+          description: template_ss.description,
+          version_bump: false,
+          changed_files: [],
+          new_skillset: true
+        }
+      end
+
       results
     end
 
-    # Apply SkillSet upgrades from gem templates
+    # Apply SkillSet upgrades from gem templates.
+    # Handles both upgrades (existing) and new installs.
     #
-    # @param names [Array<String>, nil] specific names to upgrade, or nil for all
+    # @param names [Array<String>, nil] specific names to upgrade/install, or nil for all
     # @return [Array<Hash>] results
     def upgrade_apply(names: nil)
       upgrades = upgrade_check
@@ -176,24 +202,61 @@ module KairosMcp
       results = []
       upgrades.each do |info|
         template_path = File.join(KairosMcp.gem_root, 'templates', 'skillsets', info[:name])
-        dest = File.join(@skillsets_dir, info[:name])
 
-        info[:changed_files].each do |rel_path|
-          src = File.join(template_path, rel_path)
-          dst = File.join(dest, rel_path)
-          FileUtils.mkdir_p(File.dirname(dst))
-          FileUtils.cp(src, dst) if File.exist?(src)
-        end
+        if info[:new_skillset]
+          # Install new SkillSet from template
+          result = install(template_path)
+          results << { name: info[:name], from: nil, to: info[:available_version],
+                       action: 'installed', files_updated: 0 }
+        else
+          # Upgrade existing: copy changed files
+          dest = File.join(@skillsets_dir, info[:name])
+          info[:changed_files].each do |rel_path|
+            src = File.join(template_path, rel_path)
+            dst = File.join(dest, rel_path)
+            FileUtils.mkdir_p(File.dirname(dst))
+            FileUtils.cp(src, dst) if File.exist?(src)
+          end
 
-        installed = Skillset.new(dest)
-        record_skillset_event(installed, 'upgrade')
-        results << { name: info[:name], from: info[:installed_version], to: info[:available_version],
-                     files_updated: info[:changed_files].size }
+          installed = Skillset.new(dest)
+          record_skillset_event(installed, 'upgrade')
+          results << { name: info[:name], from: info[:installed_version], to: info[:available_version],
+                       action: 'upgraded', files_updated: info[:changed_files].size }
+        end
       end
 
       results
     end
 
+    # List all available SkillSets from gem templates with install status.
+    #
+    # @return [Array<Hash>] list with name, version, description, installed status
+    def available_skillsets
+      templates_dir = File.join(KairosMcp.gem_root, 'templates', 'skillsets')
+      return [] unless File.directory?(templates_dir)
+
+      installed_map = all_skillsets.each_with_object({}) { |ss, h| h[ss.name] = ss }
+
+      Dir.children(templates_dir).sort.filter_map do |name|
+        template_path = File.join(templates_dir, name)
+        next unless File.directory?(template_path)
+
+        template_ss = Skillset.new(template_path)
+        next unless template_ss.valid?
+
+        installed = installed_map[name]
+        {
+          name: name,
+          available_version: template_ss.version,
+          description: template_ss.description,
+          installed: !installed.nil?,
+          installed_version: installed&.version,
+          enabled: installed ? enabled?(name) : false,
+          upgrade_available: installed ? Gem::Version.new(template_ss.version) > Gem::Version.new(installed.version) : false
+        }
+      end
+    end
+
     # Remove a SkillSet
     def remove(name)
       skillset = find_skillset(name)

data/lib/kairos_mcp/tools/system_upgrade.rb

@@ -57,12 +57,18 @@ module KairosMcp
           properties: {
             command: {
               type: 'string',
-              description: 'Command: "check", "preview", "apply", or "status"',
-              enum: %w[check preview apply status]
+              description: 'Command: "check", "preview", "apply", "status", or "skillsets". ' \
+                '"skillsets" lists all available SkillSets with install status.',
+              enum: %w[check preview apply status skillsets]
             },
             approved: {
               type: 'boolean',
               description: 'Set to true to approve and apply the upgrade (required for apply command)'
+            },
+            names: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Specific SkillSet names to install/upgrade (optional, for apply command)'
             }
           },
           required: ['command']
@@ -72,6 +78,7 @@ module KairosMcp
       def call(arguments)
         command = arguments['command']
         approved = arguments['approved'] || false
+        names = arguments['names']
 
         case command
         when 'check'
@@ -79,11 +86,13 @@ module KairosMcp
         when 'preview'
           handle_preview
         when 'apply'
-          handle_apply(approved)
+          handle_apply(approved, names: names)
         when 'status'
           handle_status
+        when 'skillsets'
+          handle_skillsets
         else
-          text_content("Unknown command: #{command}. Use check, preview, apply, or status.")
+          text_content("Unknown command: #{command}. Use check, preview, apply, status, or skillsets.")
         end
       end
 
@@ -122,6 +131,18 @@ module KairosMcp
           output += "No upgrade needed. Data directory is up to date.\n"
         end
 
+        # SkillSet status (always show, even if no L0/L1 upgrade needed)
+        ss_info = skillset_upgrade_summary
+        if ss_info[:new_count] > 0 || ss_info[:upgrade_count] > 0
+          output += "\n### SkillSets\n"
+          output += "  New available: #{ss_info[:new_count]}\n" if ss_info[:new_count] > 0
+          output += "  Upgrades available: #{ss_info[:upgrade_count]}\n" if ss_info[:upgrade_count] > 0
+          ss_info[:new_names].each { |n| output += "    + #{n[:name]} (#{n[:version]}) — #{n[:description]}\n" }
+          output += "\nRun `system_upgrade command=\"skillsets\"` for full list.\n"
+          output += "Run `system_upgrade command=\"apply\" approved=true` to install all.\n"
+          output += "Run `system_upgrade command=\"apply\" approved=true names=[\"dream\"]` to install specific.\n"
+        end
+
         text_content(output)
       end
 
@@ -207,7 +228,7 @@ module KairosMcp
       # =====================================================================
       # apply — Execute the upgrade
       # =====================================================================
-      def handle_apply(approved)
+      def handle_apply(approved, names: nil)
         unless approved
           return text_content(
             "Upgrade requires approval.\n\n" \
@@ -318,6 +339,27 @@ module KairosMcp
           end
         end
 
+        # Apply SkillSet upgrades/installs
+        begin
+          ss_mgr = KairosMcp::SkillSetManager.new
+          ss_results = ss_mgr.upgrade_apply(names: names)
+          if ss_results.any?
+            output += "\n## SkillSets\n\n"
+            ss_results.each do |r|
+              if r[:action] == 'installed'
+                actions[:skillsets_installed] = (actions[:skillsets_installed] || []) << r[:name]
+                output += "  [INSTALLED] #{r[:name]} v#{r[:to]}\n"
+              else
+                actions[:skillsets_upgraded] = (actions[:skillsets_upgraded] || []) << r[:name]
+                output += "  [UPGRADED] #{r[:name]} v#{r[:from]} → v#{r[:to]} (#{r[:files_updated]} files)\n"
+              end
+            end
+          end
+        rescue => e
+          output += "\n## SkillSets\n\n"
+          output += "  [ERROR] SkillSet upgrade failed: #{e.message}\n"
+        end
+
         # Update .kairos_meta.yml
         update_meta(analyzer.gem_version)
         output += "\n  [UPDATED] .kairos_meta.yml → v#{analyzer.gem_version}\n"
@@ -392,10 +434,63 @@ module KairosMcp
         text_content(output)
       end
 
+      # =====================================================================
+      # skillsets — List all available SkillSets with install status
+      # =====================================================================
+      def handle_skillsets
+        ss_mgr = KairosMcp::SkillSetManager.new
+        available = ss_mgr.available_skillsets
+
+        output = "# Available SkillSets\n\n"
+        output += "| Name | Available | Installed | Status |\n"
+        output += "|------|-----------|-----------|--------|\n"
+
+        available.each do |ss|
+          status = if !ss[:installed]
+                     'Not installed'
+                   elsif ss[:upgrade_available]
+                     "Upgrade: #{ss[:installed_version]} -> #{ss[:available_version]}"
+                   elsif ss[:enabled]
+                     'Installed, enabled'
+                   else
+                     'Installed, disabled'
+                   end
+          output += "| #{ss[:name]} | #{ss[:available_version]} | #{ss[:installed_version] || '-'} | #{status} |\n"
+        end
+
+        not_installed = available.select { |ss| !ss[:installed] }
+        if not_installed.any?
+          output += "\n## Not Installed\n\n"
+          not_installed.each do |ss|
+            output += "- **#{ss[:name]}** v#{ss[:available_version]}"
+            output += " — #{ss[:description]}" if ss[:description]
+            output += "\n"
+          end
+          output += "\nTo install: `system_upgrade command=\"apply\" approved=true names=[\"#{not_installed.first[:name]}\"]`\n"
+          output += "To install all: `system_upgrade command=\"apply\" approved=true`\n"
+        end
+
+        text_content(output)
+      end
+
       # =====================================================================
       # Helpers
       # =====================================================================
 
+      def skillset_upgrade_summary
+        ss_mgr = KairosMcp::SkillSetManager.new
+        checks = ss_mgr.upgrade_check
+        new_ss = checks.select { |c| c[:new_skillset] }
+        upgrades = checks.reject { |c| c[:new_skillset] }
+        {
+          new_count: new_ss.size,
+          upgrade_count: upgrades.size,
+          new_names: new_ss.map { |s| { name: s[:name], version: s[:available_version], description: s[:description] } }
+        }
+      rescue StandardError
+        { new_count: 0, upgrade_count: 0, new_names: [] }
+      end
+
       def pattern_icon(pattern)
         case pattern
         when :unchanged then 'OK'

data/lib/kairos_mcp/version.rb

@@ -1,4 +1,4 @@
 module KairosMcp
-  VERSION = "3.7.0"
+  VERSION = "3.9.0"
   CHANGELOG_URL = "https://github.com/masaomi/KairosChain_2026/blob/main/CHANGELOG.md"
 end

data/templates/skillsets/agent/config/agent.yml

@@ -35,6 +35,7 @@ tool_blacklist:
   - "challenge_*"
   - "autoexec_plan"
   - "autoexec_run"
+  - "agent_execute"
   # MCP client: user-only (requires token)
   - "mcp_connect"
   - "mcp_disconnect"
@@ -45,5 +46,21 @@ tool_blacklist:
 orient_tools_extra: []
   # - document_status   # uncomment to enable draft checking during ORIENT
 
+# Autonomous mode limits
+autonomous:
+  max_total_llm_calls: 60        # across all cycles in one batch
+  max_duration_seconds: 300      # wall-clock timeout per batch (5 min)
+  min_cycles_before_exit: 2      # confidence exit disabled for first N cycles
+  confidence_exit_threshold: 0.9 # minimum confidence for early exit
+
+# agent_execute: Claude Code subprocess delegation for file operations
+agent_execute:
+  default_tools: ["Read", "Edit", "Write", "Glob", "Grep"]
+  default_model: "sonnet"
+  default_timeout: 120
+  max_timeout: 600
+  default_budget_usd: 0.50
+  max_budget_usd: 2.00
+
 # Audit
 audit_level: summary

data/templates/skillsets/agent/lib/agent/cognitive_loop.rb

@@ -7,11 +7,17 @@ module KairosMcp
   module SkillSets
     module Agent
       class CognitiveLoop
+        FALLBACK_PROVIDERS = %w[claude_code].freeze
+
+        attr_reader :total_calls
+
         # @param caller_tool [BaseTool] the agent_step tool instance (has invoke_tool)
         # @param session [Session] current agent session
         def initialize(caller_tool, session)
           @caller = caller_tool
           @session = session
+          @fallback_attempted = false
+          @total_calls = 0
         end
 
         # Generic phase runner for ORIENT, REFLECT, and DECIDE_PREP.
@@ -29,14 +35,13 @@ module KairosMcp
                        'stop_reason' => 'budget' }
             end
 
-            llm_result = @caller.invoke_tool('llm_call', {
+            @total_calls += 1
+            parsed = call_llm_with_fallback(
               'messages' => messages,
               'system' => system_prompt,
               'tools' => available_tools,
               'invocation_context_json' => @session.invocation_context.to_json
-            }, context: @session.invocation_context)
-
-            parsed = JSON.parse(llm_result.map { |b| b[:text] || b['text'] }.compact.join)
+            )
             return { 'error' => parsed['error'] } if parsed['status'] == 'error'
 
             response = parsed['response']
@@ -79,14 +84,14 @@ module KairosMcp
               return { 'error' => 'Budget exceeded for DECIDE phase' }
             end
 
-            llm_result = @caller.invoke_tool('llm_call', {
+            @total_calls += 1
+
+            parsed = call_llm_with_fallback(
               'messages' => messages,
               'system' => system_prompt,
               'tools' => [],
               'invocation_context_json' => @session.invocation_context.to_json
-            }, context: @session.invocation_context)
-
-            parsed = JSON.parse(llm_result.map { |b| b[:text] || b['text'] }.compact.join)
+            )
             return { 'error' => parsed['error'] } if parsed['status'] == 'error'
 
             response = parsed['response']
@@ -110,7 +115,7 @@ module KairosMcp
             begin
               decision = JSON.parse(json_str)
               task_json_str = JSON.generate(decision['task_json'])
-              Autoexec::TaskDsl.from_json(task_json_str)
+              ::Autoexec::TaskDsl.from_json(task_json_str)
               return { 'decision_payload' => decision }
             rescue => e
               if attempts >= max_repair
@@ -127,6 +132,61 @@ module KairosMcp
 
         private
 
+        # Call llm_call with automatic provider fallback on auth errors.
+        # Tries the configured provider first. On auth_error, switches to
+        # fallback providers (claude_code) via llm_configure, then retries once.
+        def call_llm_with_fallback(arguments)
+          llm_result = @caller.invoke_tool('llm_call', arguments,
+                                            context: @session.invocation_context)
+          parsed = JSON.parse(llm_result.map { |b| b[:text] || b['text'] }.compact.join)
+
+          # If not an auth error, or already tried fallback, return as-is
+          error_info = parsed['error']
+          if !error_info || !error_info.is_a?(Hash) || error_info['type'] != 'auth_error' || @fallback_attempted
+            return parsed
+          end
+
+          # Attempt provider fallback
+          original_provider = error_info['provider'] || 'configured'
+          warn "[agent] Auth error from #{original_provider}, attempting provider fallback"
+
+          FALLBACK_PROVIDERS.each do |fallback|
+            @fallback_attempted = true
+            configure_result = try_configure_provider(fallback)
+            next unless configure_result
+
+            warn "[agent] Switched to provider: #{fallback}"
+            retry_result = @caller.invoke_tool('llm_call', arguments,
+                                                context: @session.invocation_context)
+            retry_parsed = JSON.parse(retry_result.map { |b| b[:text] || b['text'] }.compact.join)
+
+            # If this provider also fails with auth_error, try next
+            retry_error = retry_parsed['error']
+            if retry_error.is_a?(Hash) && retry_error['type'] == 'auth_error'
+              warn "[agent] Fallback provider #{fallback} also failed: #{retry_error['message']}"
+              next
+            end
+
+            return retry_parsed
+          end
+
+          # All fallbacks exhausted — return original error with fallback info
+          parsed['error']['fallback_attempted'] = true
+          parsed['error']['fallback_exhausted'] = true
+          parsed
+        end
+
+        def try_configure_provider(provider)
+          args = { 'provider' => provider }
+          result = @caller.invoke_tool('llm_configure', args,
+                                        context: @session.invocation_context)
+          parsed = JSON.parse(result.map { |b| b[:text] || b['text'] }.compact.join)
+          parsed['status'] == 'ok'
+        rescue StandardError => e
+          warn "[agent] Failed to configure provider #{provider}: #{e.message}"
+          false
+        end
+
         def extract_json(content)
           JSON.parse(content)
           content

data/templates/skillsets/agent/lib/agent/mandate_adapter.rb

@@ -11,7 +11,7 @@ module KairosMcp
         def self.to_mandate_proposal(decision_payload)
           {
             autoexec_task: {
-              steps: (decision_payload['task_json']['steps'] || []).map { |s|
+              steps: (decision_payload.dig('task_json', 'steps') || []).map { |s|
                 { risk: s['risk'] || 'low', tool_name: s['tool_name'] }
               }
             },

data/templates/skillsets/agent/lib/agent/session.rb

@@ -8,19 +8,25 @@ module KairosMcp
     module Agent
       class Session
         attr_reader :session_id, :mandate_id, :goal_name, :invocation_context,
-                    :state, :cycle_number, :config
+                    :state, :cycle_number, :config, :autonomous
 
-        def initialize(session_id:, mandate_id:, goal_name:, invocation_context:, config:)
+        def initialize(session_id:, mandate_id:, goal_name:, invocation_context:, config:,
+                       autonomous: false)
           @session_id = session_id
           @mandate_id = mandate_id
           @goal_name = goal_name
           @invocation_context = invocation_context
           @config = config
+          @autonomous = autonomous
           @state = 'created'
           @cycle_number = 0
           @snapshots = []
         end
 
+        def autonomous?
+          @autonomous == true
+        end
+
         # Per-phase budget configuration.
         # Returns defaults if the phase is not configured.
         def phase_config(phase_name)
@@ -109,7 +115,7 @@ module KairosMcp
           data = {
             session_id: @session_id, mandate_id: @mandate_id,
             goal_name: @goal_name, state: @state, cycle_number: @cycle_number,
-            config: @config,
+            config: @config, autonomous: @autonomous,
             invocation_context: @invocation_context.to_h
           }
           File.write(state_path, JSON.pretty_generate(data))
@@ -133,7 +139,8 @@ module KairosMcp
             mandate_id: data['mandate_id'],
             goal_name: data['goal_name'],
             invocation_context: ctx,
-            config: data['config']
+            config: data['config'],
+            autonomous: data['autonomous'] || false
           )
           session.instance_variable_set(:@state, data['state'])
           session.instance_variable_set(:@cycle_number, data['cycle_number'] || 0)