kairos-chain 3.7.0 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cef8ee3fd2052bb3d553e0c7ee0569d50f88fcfadea13dec6722122e2e71adb7
-  data.tar.gz: de6425c1fa691e86ad4e3597f36733b9ca592cb017ad58b69d54aecb64b63dd6
+  metadata.gz: b7d045865d5f35b2ceba8abf858cc33219f88690feaf5591183b20154cda36e4
+  data.tar.gz: f333e43070e2268da45be99949d3c85217bfcf2a5d7d691e707fbe26f5b96796
 SHA512:
-  metadata.gz: bc9dec7fd29edf94dce3de1a18fc90eb006695cb22475195aeb4422f6aa843a0efc1b2fa2e5796891768934c7307fc0687d0420f2883a099b700a80077ae4b7a
-  data.tar.gz: db1e322c0b191ab12d949c403b6b04a5c6d99fccd9dd2e6528754a066a4bf3db26e4fb3e0cba4898826da13887d52f91c3018377a47aa5dd1ee25316f850f7df
+  metadata.gz: 4951cb6216a2f85212c12882c02337fc86e2a8abd906bcfd1322ca7d23760226692608a92626ea807c7a67b44c3f94b6eadd96ef88a6125a551dcca30a951954
+  data.tar.gz: ccf714bf15d9b54219373f9a83560943fcff476cb700a459cf5d62b5c02c02ce87c0986bf81d8b5b3d7c9708b1eb58c94c5e1ecb96c5c5909ec9bf6f562c1d78

data/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [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/version.rb

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

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

@@ -45,5 +45,12 @@ 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
+
 # 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)

data/templates/skillsets/agent/tools/agent_start.rb

@@ -52,6 +52,12 @@ module KairosMcp
                 risk_budget: {
                   type: 'string',
                   description: 'Maximum risk level: "low" or "medium" (default: "low")'
+                },
+                autonomous: {
+                  type: 'boolean',
+                  description: 'Enable autonomous mode (default: false). ' \
+                    'Session starts at [observed] regardless. ' \
+                    'Autonomous loop begins on first agent_step(approve).'
                 }
               },
               required: ['goal_name']
@@ -63,10 +69,14 @@ module KairosMcp
             max_cycles = arguments['max_cycles'] || 3
             checkpoint_every = arguments['checkpoint_every'] || 1
             risk_budget = arguments['risk_budget'] || 'low'
+            autonomous = arguments['autonomous'] == true
+
+            # Pre-resolve goal content for content-based drift detection hash
+            pre_obs = run_observe(goal_name)
+            goal_content_for_hash = pre_obs['goal_content'] || goal_name
+            goal_hash = Digest::SHA256.hexdigest(goal_content_for_hash)[0..15]
 
-            # Create mandate via Autonomos
-            goal_hash = Digest::SHA256.hexdigest(goal_name)[0..15]
-            mandate = Autonomos::Mandate.create(
+            mandate = ::Autonomos::Mandate.create(
               goal_name: goal_name,
               goal_hash: goal_hash,
               max_cycles: max_cycles,
@@ -85,11 +95,12 @@ module KairosMcp
               mandate_id: mandate[:mandate_id],
               goal_name: goal_name,
               invocation_context: ctx,
-              config: config
+              config: config,
+              autonomous: autonomous
             )
 
-            # OBSERVE (no LLM — direct Ruby)
-            observation = run_observe(goal_name)
+            # OBSERVE: reuse pre-resolved observation (avoids duplicate L2/L1 lookups)
+            observation = pre_obs
 
             session.save_observation(observation)
             session.update_state('observed')
@@ -100,6 +111,7 @@ module KairosMcp
               'session_id' => session_id,
               'mandate_id' => mandate[:mandate_id],
               'state' => 'observed',
+              'autonomous' => autonomous,
               'observation' => observation
             }
 
@@ -151,10 +163,10 @@ module KairosMcp
             # Gather observation data without LLM
             observation = { 'goal_name' => goal_name, 'timestamp' => Time.now.iso8601 }
 
-            # Try to load goal from L2/L1
-            if defined?(Autonomos::Ooda)
+            # Load environment data via Autonomos::Ooda
+            if defined?(::Autonomos::Ooda)
               begin
-                helper = Class.new { include Autonomos::Ooda }.new
+                helper = Class.new { include ::Autonomos::Ooda }.new
                 ooda_obs = helper.observe(goal_name)
                 observation.merge!(ooda_obs.transform_keys(&:to_s)) if ooda_obs.is_a?(Hash)
               rescue StandardError => e
@@ -162,8 +174,47 @@ module KairosMcp
               end
             end
 
+            # Load goal content from L2/L1 so Orient has context to analyze
+            begin
+              if defined?(::Autonomos::Ooda)
+                helper = Class.new { include ::Autonomos::Ooda }.new
+                goal = helper.load_goal(goal_name)
+              else
+                goal = load_goal_fallback(goal_name)
+              end
+              if goal && goal[:found]
+                observation['goal_content'] = goal[:content]
+                observation['goal_source'] = goal[:source].to_s
+              end
+            rescue StandardError => e
+              observation['goal_load_error'] = e.message
+            end
+
             observation
           end
+
+          def load_goal_fallback(goal_name)
+            # Direct L2/L1 lookup when Autonomos::Ooda is unavailable
+            if defined?(KairosMcp::ContextManager)
+              ctx_mgr = KairosMcp::ContextManager.new
+              ctx_mgr.list_sessions.each do |session|
+                entry = ctx_mgr.get_context(session[:session_id], goal_name)
+                if entry && entry.respond_to?(:content) && entry.content && !entry.content.strip.empty?
+                  return { content: entry.content, found: true, source: :l2 }
+                end
+              end
+            end
+            if defined?(KairosMcp::KnowledgeProvider)
+              provider = KairosMcp::KnowledgeProvider.new(nil)
+              result = provider.get(goal_name)
+              if result && result[:content] && !result[:content].strip.empty?
+                return { content: result[:content], found: true, source: :l1 }
+              end
+            end
+            { content: nil, found: false }
+          rescue StandardError
+            { content: nil, found: false }
+          end
         end
       end
     end

data/templates/skillsets/agent/tools/agent_step.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require 'digest'
 require_relative '../lib/agent'
 
 module KairosMcp
@@ -96,12 +97,16 @@ module KairosMcp
 
           def handle_approve(session)
             case session.state
-            when 'observed'
-              run_orient_decide(session)
+            when 'observed', 'autonomous_cycling'
+              session.autonomous? ? run_autonomous_loop(session) : run_orient_decide(session)
             when 'proposed'
               run_act_reflect(session)
             when 'checkpoint'
-              run_next_cycle(session)
+              session.autonomous? ? run_autonomous_loop(session) : run_next_cycle(session)
+            when 'paused_risk'
+              handle_resume_from_risk(session)
+            when 'paused_error'
+              handle_resume_from_error(session)
             else
               error_result("Cannot approve in state: #{session.state}")
             end
@@ -113,11 +118,15 @@ module KairosMcp
           end
 
           def handle_skip(session)
-            return error_result("skip only valid at [proposed]") unless session.state == 'proposed'
+            return error_result("skip not valid in state: #{session.state}") unless %w[proposed paused_error].include?(session.state)
+            return handle_resume_from_error(session) if session.state == 'paused_error'
             # Skip ACT, go directly to REFLECT with "skipped"
             session.update_state('reflecting')
             act_result = { 'skipped' => true, 'summary' => 'skipped' }
-            reflect_result = run_reflect(session, act_result)
+            reflect_loop = CognitiveLoop.new(self, session)
+            messages = [{ 'role' => 'user', 'content' => build_reflect_prompt(session, act_result) }]
+            reflect_raw = reflect_loop.run_phase('reflect', reflect_system_prompt, messages, [])
+            reflect_result = reflect_raw['content'] ? parse_reflect_json(reflect_raw['content']) : { 'confidence' => 0.0 }
 
             # Chain recording + progress (same as run_act_reflect)
             decision_payload = session.load_decision || {}
@@ -138,98 +147,411 @@ module KairosMcp
 
           # ---- ORIENT + DECIDE ----
 
-          def run_orient_decide(session)
+          # Internal version: returns Hash, never calls text_content.
+          # Used by both manual wrapper and autonomous loop.
+          # mandate_override: pass in-memory mandate from autonomous loop to avoid stale reads.
+          def run_orient_decide_internal(session, mandate_override: nil)
             loop_inst = CognitiveLoop.new(self, session)
 
-            # Load observation (Fix #6: pass to ORIENT)
             observation = session.load_observation
             observation_text = observation ? JSON.generate(observation) : '(no observation data)'
 
-            # ORIENT
             session.update_state('orienting')
             orient_prompt = build_orient_prompt(session, observation_text)
             messages = [{ 'role' => 'user', 'content' => orient_prompt }]
 
             orient_result = loop_inst.run_phase('orient', orient_system_prompt, messages, orient_tools(session))
-            return error_with_state(session, 'observed', orient_result) if orient_result['error']
+            if orient_result['error']
+              session.update_state('observed')
+              session.save
+              return { error: orient_result['error'], llm_calls: loop_inst.total_calls }
+            end
 
-            # DECIDE (single-stage; see design v0.4 sec 3.3 for future extension)
             session.update_state('deciding')
             decide_messages = [{ 'role' => 'user', 'content' => build_decide_prompt(session, orient_result) }]
 
             decide_result = loop_inst.run_decide(decide_system_prompt, decide_messages)
-            return error_with_state(session, 'observed', decide_result) if decide_result['error']
+            if decide_result['error']
+              session.update_state('observed')
+              session.save
+              return { error: decide_result['error'], llm_calls: loop_inst.total_calls }
+            end
 
-            # M4: Loop detection (after DECIDE, before presenting to user)
             decision_payload = decide_result['decision_payload']
-            loop_term = check_loop_detection(session, orient_result, decision_payload)
+            loop_term = check_loop_detection(session, orient_result, decision_payload,
+                                             mandate_override: mandate_override)
             if loop_term
+              return { loop_detected: true, llm_calls: loop_inst.total_calls }
+            end
+
+            session.save_decision(decision_payload)
+            { orient: orient_result, decision_payload: decision_payload,
+              loop_detected: false, error: nil, llm_calls: loop_inst.total_calls }
+          end
+
+          # Manual mode wrapper: pure format converter
+          def run_orient_decide(session)
+            result = run_orient_decide_internal(session)
+            if result[:error]
+              return error_with_state(session, 'observed', { 'error' => result[:error] })
+            end
+            if result[:loop_detected]
               return text_content(JSON.generate({
                 'status' => 'terminated', 'reason' => 'loop_detected',
                 'session_id' => session.session_id
               }))
             end
 
-            # Fix #1: persist decision for proposed→ACT transition
-            session.save_decision(decision_payload)
             session.update_state('proposed')
             session.save
-
             text_content(JSON.generate({
               'status' => 'ok', 'session_id' => session.session_id,
               'state' => 'proposed',
-              'orient' => summarize_orient(orient_result),
-              'decision_payload' => decide_result['decision_payload']
+              'orient' => summarize_orient(result[:orient]),
+              'decision_payload' => result[:decision_payload]
             }))
           end
 
           # ---- ACT + REFLECT ----
 
-          def run_act_reflect(session)
-            decision_payload = load_last_decision(session)
-            return error_result("No decision payload found") unless decision_payload
-
-            # Check risk before ACT
-            proposal = MandateAdapter.to_mandate_proposal(decision_payload)
-            mandate = Autonomos::Mandate.load(session.mandate_id)
-            if Autonomos::Mandate.risk_exceeds_budget?(proposal, mandate[:risk_budget])
-              Autonomos::Mandate.update_status(session.mandate_id, 'paused_risk_exceeded')
-              session.update_state('terminated')
-              session.save
-              return text_content(JSON.generate({
-                'status' => 'paused', 'reason' => 'risk_exceeded',
-                'session_id' => session.session_id, 'state' => 'terminated'
-              }))
-            end
+          # Internal version: returns Hash, never calls text_content.
+          # Increments cycle and saves session. Does NOT set final state.
+          def run_act_reflect_internal(session)
+            decision_payload = session.load_decision
+            return { act_error: 'No decision payload found', llm_calls: 0 } unless decision_payload
 
-            # ACT via autoexec with derived context
             session.update_state('acting')
             act_result = run_act(session, decision_payload)
 
-            # REFLECT
             session.update_state('reflecting')
-            reflect_result = run_reflect(session, act_result)
+            reflect_loop = CognitiveLoop.new(self, session)
+            messages = [{ 'role' => 'user', 'content' => build_reflect_prompt(session, act_result) }]
+            reflect_raw = reflect_loop.run_phase('reflect', reflect_system_prompt, messages, [])
+            reflect_result = if reflect_raw['content']
+                               parse_reflect_json(reflect_raw['content'])
+                             else
+                               { 'confidence' => 0.0, 'error' => reflect_raw['error'] || 'no content' }
+                             end
 
-            # Record cycle
             record_agent_cycle(session, decision_payload, act_result, reflect_result)
 
-            # M5: Save cumulative progress after REFLECT (1-based cycle numbering)
             act_summary = act_result['summary'] || act_result['error'] || 'completed'
             decision_summary = decision_payload['summary'] || ''
             session.save_progress(reflect_result, session.cycle_number + 1, act_summary, decision_summary)
 
             session.increment_cycle
-            session.update_state('checkpoint')
             session.save
 
+            act_succeeded = !act_result['error'] && act_result['summary'] != 'failed'
+
+            { act: act_result, reflect: reflect_result, cycle: session.cycle_number,
+              act_error: act_result['error'], act_succeeded: act_succeeded,
+              llm_calls: reflect_loop.total_calls }
+          end
+
+          # Manual mode wrapper: pure format converter
+          def run_act_reflect(session)
+            decision_payload = load_last_decision(session)
+            return error_result("No decision payload found") unless decision_payload
+
+            proposal = MandateAdapter.to_mandate_proposal(decision_payload)
+            mandate = ::Autonomos::Mandate.load(session.mandate_id)
+            if ::Autonomos::Mandate.risk_exceeds_budget?(proposal, mandate[:risk_budget])
+              ::Autonomos::Mandate.update_status(session.mandate_id, 'paused_risk_exceeded')
+              session.update_state('paused_risk')
+              session.save
+              return text_content(JSON.generate({
+                'status' => 'paused', 'reason' => 'risk_exceeded',
+                'session_id' => session.session_id, 'state' => 'paused_risk'
+              }))
+            end
+
+            result = run_act_reflect_internal(session)
+            session.update_state('checkpoint')
+            session.save
             text_content(JSON.generate({
               'status' => 'ok', 'session_id' => session.session_id,
               'state' => 'checkpoint',
-              'act_summary' => act_result['summary'] || 'completed',
-              'reflect' => reflect_result
+              'act_summary' => result.dig(:act, 'summary') || 'completed',
+              'reflect' => result[:reflect]
             }))
           end
 
+          # ---- AUTONOMOUS LOOP ----
+
+          def run_autonomous_loop(session)
+            auto_cfg = session.config['autonomous'] || {}
+            max_total_llm = auto_cfg['max_total_llm_calls'] || 60
+            max_duration = auto_cfg['max_duration_seconds'] || 300
+            min_exit_cycles = auto_cfg['min_cycles_before_exit'] || 2
+            confidence_threshold = auto_cfg['confidence_exit_threshold'] || 0.9
+
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            total_llm_calls = 0
+            results = []
+
+            ::Autonomos::Mandate.with_lock(session.mandate_id) do |mandate|
+              while session.cycle_number < (mandate[:max_cycles] || 3)
+                session.update_state('autonomous_cycling')
+                session.save
+
+                # Gate 1: Mandate termination
+                term_reason = ::Autonomos::Mandate.check_termination(mandate)
+                if term_reason
+                  mandate[:status] = 'terminated'
+                  ::Autonomos::Mandate.save(session.mandate_id, mandate)
+                  session.update_state('terminated')
+                  return finalize_autonomous(session, results, terminated: term_reason)
+                end
+
+                # Gate 2: Goal drift
+                if goal_drifted?(session, mandate)
+                  mandate[:status] = 'paused_goal_drift'
+                  ::Autonomos::Mandate.save(session.mandate_id, mandate)
+                  session.update_state('checkpoint')
+                  session.save
+                  return finalize_autonomous(session, results, checkpoint: true,
+                                             warning: 'goal_content_changed')
+                end
+
+                # Gate 3: Wall-clock timeout
+                elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+                if elapsed > max_duration
+                  session.update_state('checkpoint')
+                  session.save
+                  return finalize_autonomous(session, results, checkpoint: true,
+                                             paused: 'timeout')
+                end
+
+                # Gate 4: Aggregate LLM budget
+                if total_llm_calls >= max_total_llm
+                  session.update_state('checkpoint')
+                  session.save
+                  return finalize_autonomous(session, results, checkpoint: true,
+                                             paused: 'llm_budget_exceeded')
+                end
+
+                # OBSERVE (cycle 2+; cycle 1 already observed by agent_start)
+                if session.cycle_number > 0
+                  observation = run_observe_for_next_cycle(session)
+                  session.save_observation(observation)
+                end
+
+                # ORIENT + DECIDE (pass in-memory mandate to avoid stale reads)
+                od_result = run_orient_decide_internal(session, mandate_override: mandate)
+                total_llm_calls += od_result[:llm_calls] || 0
+                if od_result[:error]
+                  session.update_state('paused_error')
+                  session.save
+                  return finalize_autonomous(session, results, error: od_result[:error])
+                end
+                if od_result[:loop_detected]
+                  session.update_state('terminated')
+                  return finalize_autonomous(session, results, terminated: 'loop_detected')
+                end
+
+                # Gate 5: Risk budget (after loop detection, existing order)
+                decision_payload = session.load_decision
+                proposal = MandateAdapter.to_mandate_proposal(decision_payload)
+                if ::Autonomos::Mandate.risk_exceeds_budget?(proposal, mandate[:risk_budget])
+                  mandate[:status] = 'paused_risk_exceeded'
+                  ::Autonomos::Mandate.save(session.mandate_id, mandate)
+                  session.update_state('paused_risk')
+                  session.save
+                  return finalize_autonomous(session, results, paused: 'risk_exceeded')
+                end
+
+                # ACT + REFLECT
+                ar_result = run_act_reflect_internal(session)
+                total_llm_calls += ar_result[:llm_calls] || 0
+                results << ar_result
+                if ar_result[:act_error]
+                  session.update_state('paused_error')
+                  session.save
+                  return finalize_autonomous(session, results, paused: 'act_failed',
+                                             error: ar_result[:act_error])
+                end
+
+                # Gate 6: Post-ACT termination (record_cycle may have incremented errors)
+                mandate = ::Autonomos::Mandate.reload(session.mandate_id)
+                term_reason = ::Autonomos::Mandate.check_termination(mandate)
+                if term_reason
+                  session.update_state('terminated')
+                  return finalize_autonomous(session, results, terminated: term_reason)
+                end
+
+                # Gate 7: Confidence-based early exit
+                if session.cycle_number >= min_exit_cycles
+                  confidence = clamp_confidence(ar_result.dig(:reflect, 'confidence'))
+                  remaining = ar_result.dig(:reflect, 'remaining')
+                  if confidence >= confidence_threshold &&
+                     remaining.is_a?(Array) && remaining.empty? &&
+                     ar_result[:act_succeeded]
+                    session.update_state('terminated')
+                    return finalize_autonomous(session, results, terminated: 'goal_achieved')
+                  end
+                end
+
+                # Gate 8: Checkpoint pause
+                checkpoint_every = mandate[:checkpoint_every] || 1
+                if session.cycle_number > 0 &&
+                   (session.cycle_number % checkpoint_every).zero?
+                  mandate[:status] = 'paused_at_checkpoint'
+                  ::Autonomos::Mandate.save(session.mandate_id, mandate)
+                  session.update_state('checkpoint')
+                  session.save
+                  return finalize_autonomous(session, results, checkpoint: true)
+                end
+              end
+
+              # All cycles exhausted (inside lock)
+              session.update_state('terminated')
+              session.save
+              finalize_autonomous(session, results, terminated: 'max_cycles_reached')
+            end
+          rescue ::Autonomos::Mandate::LockError => e
+            error_result("Session locked: #{e.message}")
+          end
+
+          def finalize_autonomous(session, cycle_results, terminated: nil, paused: nil,
+                                  checkpoint: nil, error: nil, warning: nil)
+            session.save
+
+            status = if checkpoint then 'checkpoint'
+                     elsif paused then 'paused'
+                     elsif error then 'error'
+                     else 'completed'
+                     end
+
+            text_content(JSON.generate({
+              'status' => status,
+              'session_id' => session.session_id,
+              'state' => session.state,
+              'cycles_completed' => session.cycle_number,
+              'terminated_reason' => terminated,
+              'paused_reason' => paused,
+              'error' => error,
+              'warning' => warning,
+              'cycle_results' => cycle_results.map { |r|
+                { 'cycle' => r[:cycle],
+                  'act_summary' => r.dig(:act, 'summary') || 'completed',
+                  'confidence' => clamp_confidence(r.dig(:reflect, 'confidence')),
+                  'remaining_count' => Array(r.dig(:reflect, 'remaining')).size }
+              }
+            }))
+          end
+
+          def clamp_confidence(raw)
+            val = raw.to_f
+            [[val, 0.0].max, 1.0].min
+          end
+
+          def goal_drifted?(session, mandate)
+            current_goal = load_goal_content(session.goal_name)
+            current_hash = Digest::SHA256.hexdigest(current_goal || session.goal_name)[0..15]
+            current_hash != mandate[:goal_hash].to_s
+          rescue StandardError
+            false
+          end
+
+          def load_goal_content(goal_name)
+            # Use Ooda (same path as agent_start's run_observe)
+            if defined?(::Autonomos::Ooda)
+              helper = Class.new { include ::Autonomos::Ooda }.new
+              goal = helper.load_goal(goal_name)
+              return goal[:content] if goal && goal[:found]
+            end
+            # Fallback: direct L1 lookup (matches agent_start's load_goal_fallback)
+            if defined?(KairosMcp::KnowledgeProvider)
+              provider = KairosMcp::KnowledgeProvider.new(nil)
+              result = provider.get(goal_name)
+              return result[:content] if result && result[:content] && !result[:content].strip.empty?
+            end
+            nil
+          rescue StandardError
+            nil
+          end
+
+          # ---- RESUME HANDLERS ----
+
+          def handle_resume_from_risk(session)
+            mandate = ::Autonomos::Mandate.load(session.mandate_id)
+            decision_payload = session.load_decision
+            return error_result("No decision to re-check") unless decision_payload
+
+            proposal = MandateAdapter.to_mandate_proposal(decision_payload)
+            if ::Autonomos::Mandate.risk_exceeds_budget?(proposal, mandate[:risk_budget])
+              return text_content(JSON.generate({
+                'status' => 'still_paused', 'reason' => 'risk_still_exceeded',
+                'session_id' => session.session_id,
+                'hint' => 'Update mandate risk_budget or call stop'
+              }))
+            end
+
+            # Resume: risk now within budget. Execute the paused proposal (ACT+REFLECT),
+            # not a new ORIENT+DECIDE cycle. decision_payload is already saved.
+            mandate[:status] = 'active'
+            ::Autonomos::Mandate.save(session.mandate_id, mandate)
+
+            if session.autonomous?
+              # In autonomous mode, run ACT+REFLECT for the paused proposal,
+              # then continue the autonomous loop from next cycle.
+              ar_result = run_act_reflect_internal(session)
+              if ar_result[:act_error]
+                session.update_state('paused_error')
+                session.save
+                return finalize_autonomous(session, [ar_result], paused: 'act_failed',
+                                           error: ar_result[:act_error])
+              end
+              # Continue to next cycle in autonomous loop
+              session.update_state('observed')
+              session.save
+              run_autonomous_loop(session)
+            else
+              # Manual mode: resume at ACT+REFLECT for the existing proposal
+              result = run_act_reflect_internal(session)
+              session.update_state('checkpoint')
+              session.save
+              text_content(JSON.generate({
+                'status' => 'ok', 'session_id' => session.session_id,
+                'state' => 'checkpoint',
+                'act_summary' => result.dig(:act, 'summary') || 'completed',
+                'reflect' => result[:reflect]
+              }))
+            end
+          end
+
+          def handle_resume_from_error(session)
+            # Record skipped cycle in mandate before advancing
+            begin
+              ::Autonomos::Mandate.record_cycle(
+                session.mandate_id,
+                cycle_id: "#{session.session_id}_cycle#{session.cycle_number}_skipped",
+                evaluation: 'failed'
+              )
+            rescue StandardError => e
+              warn "[agent] Failed to record skipped cycle: #{e.message}"
+            end
+
+            # Do NOT increment session.cycle_number here — the next
+            # run_act_reflect_internal will do it after a successful cycle.
+            # We only record the skip in mandate.
+            observation = run_observe_for_next_cycle(session)
+            session.save_observation(observation)
+            session.update_state('observed')
+            session.save
+
+            if session.autonomous?
+              run_autonomous_loop(session)
+            else
+              text_content(JSON.generate({
+                'status' => 'ok', 'session_id' => session.session_id,
+                'state' => 'observed', 'cycle' => session.cycle_number + 1,
+                'observation' => observation
+              }))
+            end
+          end
+
           def run_act(session, decision_payload)
             act_ctx = session.invocation_context.derive(
               blacklist_remove: %w[autoexec_plan autoexec_run]
@@ -265,20 +587,21 @@ module KairosMcp
             { 'error' => "ACT failed: #{e.message}" }
           end
 
-          def run_reflect(session, act_result)
-            loop = CognitiveLoop.new(self, session)
-            messages = [{ 'role' => 'user', 'content' => build_reflect_prompt(session, act_result) }]
-            result = loop.run_phase('reflect', reflect_system_prompt, messages, [])
-
-            if result['content']
+          # Parse REFLECT response, handling code fences and nested JSON
+          def parse_reflect_json(content)
+            # Try direct parse first
+            JSON.parse(content)
+          rescue JSON::ParserError
+            # Try extracting from code fences
+            if content =~ /```(?:json)?\s*\n?(.*?)\n?\s*```/m
               begin
-                JSON.parse(result['content'])
+                return JSON.parse($1)
               rescue JSON::ParserError
-                { 'confidence' => 0.0, 'raw' => result['content'] }
+                # fall through
               end
-            else
-              { 'confidence' => 0.0, 'error' => result['error'] || 'no content' }
             end
+            # Last resort: confidence 0.0 with raw content preserved
+            { 'confidence' => 0.0, 'raw' => content }
           end
 
           # ---- NEXT CYCLE ----
@@ -287,12 +610,12 @@ module KairosMcp
           # checkpoint_due? is checked BEFORE reaching [checkpoint] (in run_act_reflect).
           # When the user approves at [checkpoint], we always proceed to the next cycle.
           def run_next_cycle(session)
-            mandate = Autonomos::Mandate.load(session.mandate_id)
+            mandate = ::Autonomos::Mandate.load(session.mandate_id)
 
             # Check termination conditions
-            term_reason = Autonomos::Mandate.check_termination(mandate)
+            term_reason = ::Autonomos::Mandate.check_termination(mandate)
             if term_reason
-              Autonomos::Mandate.update_status(session.mandate_id, 'terminated')
+              ::Autonomos::Mandate.update_status(session.mandate_id, 'terminated')
               session.update_state('terminated')
               session.save
               return text_content(JSON.generate({
@@ -355,31 +678,29 @@ module KairosMcp
 
           # M4: Loop detection using decision_payload['summary'] as canonical gap
           # description (matches autonomos_loop's approach).
-          # Single-session-per-mandate assumed (no concurrent mandate writes).
-          def check_loop_detection(session, _orient_result, decision_payload)
-            mandate = Autonomos::Mandate.load(session.mandate_id)
+          # Accepts optional in-memory mandate to avoid stale reads in autonomous mode.
+          def check_loop_detection(session, _orient_result, decision_payload, mandate_override: nil)
+            mandate = mandate_override || ::Autonomos::Mandate.load(session.mandate_id)
             return nil unless mandate
 
-            # Use decision summary as gap description (same source as proposal)
             gap_desc = decision_payload['summary'] || 'unknown'
             recent_gaps = Array(mandate[:recent_gap_descriptions])
             recent_gaps_updated = (recent_gaps + [gap_desc]).last(3)
 
             proposal = MandateAdapter.to_mandate_proposal(decision_payload)
 
-            if Autonomos::Mandate.loop_detected?(proposal, recent_gaps)
-              # Single save: update both status and gap history atomically
+            if ::Autonomos::Mandate.loop_detected?(proposal, recent_gaps)
               mandate[:status] = 'terminated'
               mandate[:recent_gap_descriptions] = recent_gaps_updated
-              Autonomos::Mandate.save(session.mandate_id, mandate)
+              ::Autonomos::Mandate.save(session.mandate_id, mandate)
               session.update_state('terminated')
               session.save
               return true
             end
 
-            # Update gap history even if no loop detected
+            # Update gap history in-memory and on disk
             mandate[:recent_gap_descriptions] = recent_gaps_updated
-            Autonomos::Mandate.save(session.mandate_id, mandate)
+            ::Autonomos::Mandate.save(session.mandate_id, mandate)
             nil
           rescue StandardError => e
             warn "[agent] Loop detection failed: #{e.message}"
@@ -390,7 +711,7 @@ module KairosMcp
 
           def record_agent_cycle(session, decision_payload, act_result, reflect_result)
             evaluation = MandateAdapter.reflect_to_evaluation(reflect_result)
-            Autonomos::Mandate.record_cycle(
+            ::Autonomos::Mandate.record_cycle(
               session.mandate_id,
               cycle_id: "#{session.session_id}_cycle#{session.cycle_number}",
               evaluation: evaluation
@@ -472,6 +793,7 @@ module KairosMcp
           # Build a filtered tool catalog for DECIDE prompt.
           # Uses session's InvocationContext.allowed? for blacklist/whitelist
           # consistency with the ACT phase execution policy.
+          # Includes parameter schemas so DECIDE LLM generates correct tool_arguments.
           def build_tool_catalog(session)
             return "(no registry available)" unless @registry
 
@@ -480,12 +802,40 @@ module KairosMcp
             tools = tools.reject { |t| ctx && !ctx.allowed?(t[:name]) } if ctx
 
             tools.map { |t|
-              required = extract_required_params(t[:inputSchema])
-              params_str = required.empty? ? '' : " (params: #{required.join(', ')})"
-              "- **#{t[:name]}**#{params_str}: #{t[:description]}"
+              format_tool_entry(t)
             }.join("\n")
           end
 
+          # Format a single tool entry with parameter details for DECIDE.
+          def format_tool_entry(tool)
+            schema = tool[:inputSchema] || {}
+            required_names = extract_required_params(schema)
+            properties = schema[:properties] || schema['properties'] || {}
+
+            lines = ["- **#{tool[:name]}**: #{tool[:description]}"]
+
+            unless properties.empty?
+              req_parts = []
+              opt_parts = []
+              properties.each do |param_name, param_def|
+                pname = param_name.to_s
+                ptype = param_def['type'] || param_def[:type] || '?'
+                pdesc = param_def['description'] || param_def[:description]
+                short_desc = pdesc ? pdesc.to_s[0..60] : nil
+                entry = short_desc ? "#{pname} (#{ptype}: #{short_desc})" : "#{pname} (#{ptype})"
+                if required_names.include?(pname)
+                  req_parts << entry
+                else
+                  opt_parts << entry
+                end
+              end
+              lines << "  Required: #{req_parts.join(', ')}" unless req_parts.empty?
+              lines << "  Optional: #{opt_parts.join(', ')}" unless opt_parts.empty?
+            end
+
+            lines.join("\n")
+          end
+
           # Extract required parameter names from an inputSchema hash.
           def extract_required_params(schema)
             return [] unless schema.is_a?(Hash)

data/templates/skillsets/agent/tools/agent_stop.rb

@@ -53,7 +53,7 @@ module KairosMcp
 
             # Update mandate status
             begin
-              Autonomos::Mandate.update_status(session.mandate_id, 'interrupted')
+              ::Autonomos::Mandate.update_status(session.mandate_id, 'interrupted')
             rescue StandardError
               # Non-fatal
             end

data/templates/skillsets/autonomos/lib/autonomos/mandate.rb

@@ -19,6 +19,8 @@ module Autonomos
 
     RISK_BUDGETS = %w[low medium].freeze
 
+    class LockError < StandardError; end
+
     class << self
       def create(goal_name:, goal_hash:, max_cycles:, checkpoint_every:, risk_budget:)
         validate_params!(max_cycles, checkpoint_every, risk_budget)
@@ -48,21 +50,43 @@ module Autonomos
 
       def load(mandate_id)
         validate_id!(mandate_id)
-        mandates_dir = Autonomos.storage_path('mandates')
-        path = File.join(mandates_dir, "#{mandate_id}.json")
+        path = mandate_path(mandate_id)
         return nil unless File.exist?(path)
 
         JSON.parse(File.read(path), symbolize_names: true)
       end
 
+      # Alias for clarity when reloading inside with_lock
+      def reload(mandate_id)
+        load(mandate_id)
+      end
+
       def save(mandate_id, mandate)
         validate_id!(mandate_id)
-        mandates_dir = Autonomos.storage_path('mandates')
+        path = mandate_path(mandate_id)
         mandate[:updated_at] = Time.now.iso8601
-        File.write(
-          File.join(mandates_dir, "#{mandate_id}.json"),
-          JSON.pretty_generate(mandate)
-        )
+        # Atomic write via tmp+rename
+        tmp = "#{path}.tmp.#{$$}.#{Thread.current.object_id}"
+        File.write(tmp, JSON.pretty_generate(mandate))
+        File.rename(tmp, path)
+      end
+
+      # Single-writer lock for autonomous batch execution.
+      # Yields the loaded mandate; caller must use reload() to refresh after internal saves.
+      def with_lock(mandate_id)
+        validate_id!(mandate_id)
+        lock_path = mandate_path(mandate_id) + '.lock'
+        File.open(lock_path, File::CREAT | File::RDWR) do |f|
+          unless f.flock(File::LOCK_EX | File::LOCK_NB)
+            raise LockError, "Mandate #{mandate_id} is locked by another process"
+          end
+          begin
+            mandate = load(mandate_id)
+            yield mandate
+          ensure
+            f.flock(File::LOCK_UN)
+          end
+        end
       end
 
       def update_status(mandate_id, new_status)
@@ -179,6 +203,11 @@ module Autonomos
         "mnd_#{Time.now.strftime('%Y%m%d_%H%M%S')}_#{SecureRandom.hex(3)}"
       end
 
+      def mandate_path(mandate_id)
+        mandates_dir = Autonomos.storage_path('mandates')
+        File.join(mandates_dir, "#{mandate_id}.json")
+      end
+
       def validate_id!(mandate_id)
         unless mandate_id.to_s.match?(/\A[\w\-]+\z/)
           raise ArgumentError, 'Invalid mandate_id: must contain only word characters and hyphens'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kairos-chain
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.8.0
 platform: ruby
 authors:
 - Masaomi Hatakeyama
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-29 00:00:00.000000000 Z
+date: 2026-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -450,7 +450,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: KairosChain - Self-referential MCP server for auditable skill self-management