Claude Code: Target:

Implement a simple state ma

.openclaw/agents/brain_minimal.py

@@ -14,6 +14,13 @@ from typing import Dict, List, Optional, Any, Callable
 from pathlib import Path
 from datetime import datetime
 from enum import Enum
+import threading
+
+
+# OpenClaw agents directory
+OPENCLAW_AGENTS_DIR = Path(__file__).parent
+LOGS_DIR = OPENCLAW_AGENTS_DIR / "logs"
+STATUS_FILE = OPENCLAW_AGENTS_DIR / "cain_status.json"
 
 
 # Import RBAC system
@@ -43,6 +50,149 @@ except ImportError:
         print("[Brain] Warning: RBAC system not available, running in legacy mode")
 
 
+# State Machine for Agent State Management
+class AgentState(Enum):
+    """Agent operational states"""
+    IDLE = "idle"
+    PROCESSING = "processing"
+    SUCCESS = "success"
+    ERROR = "error"
+
+
+class AgentStateMachine:
+    """
+    Simple state machine for tracking agent states with persistence and logging.
+
+    States:
+    - IDLE: Agent is idle, waiting for tasks
+    - PROCESSING: Agent is actively processing a task
+    - SUCCESS: Agent completed a task successfully
+    - ERROR: Agent encountered an error
+
+    Every state transition is:
+    - Written to cain_status.json (current_state, last_updated)
+    - Logged to session-archive.jsonl
+    """
+
+    def __init__(self, agent_name: str = "cain"):
+        """
+        Initialize the state machine.
+
+        Args:
+            agent_name: Name of the agent for logging purposes
+        """
+        self._state = AgentState.IDLE
+        self._agent_name = agent_name
+        self._lock = threading.Lock()
+        self._status_file = STATUS_FILE
+
+        # Initialize log file and status file
+        self._ensure_log_file_exists()
+        self._update_status_file()
+
+    def _ensure_log_file_exists(self):
+        """Ensure the log file exists."""
+        LOGS_DIR.mkdir(parents=True, exist_ok=True)
+
+    def _log_state_change(self, new_state: AgentState):
+        """
+        Log state change to session-archive.jsonl.
+
+        Args:
+            new_state: The new state being transitioned to
+        """
+        log_entry = {
+            "type": "state_change",
+            "state": new_state.value,
+            "timestamp": datetime.utcnow().isoformat() + "+00:00",
+            "agent": self._agent_name
+        }
+
+        log_file = LOGS_DIR / "session-archive.jsonl"
+        try:
+            with open(log_file, "a") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except Exception as e:
+            print(f"[AgentStateMachine] Failed to write log: {e}")
+
+    def _update_status_file(self):
+        """Update cain_status.json with current state and timestamp."""
+        status_data = {
+            "current_state": self._state.value,
+            "last_updated": datetime.utcnow().isoformat() + "+00:00",
+            "agent": self._agent_name
+        }
+
+        try:
+            with open(self._status_file, "w") as f:
+                json.dump(status_data, f, indent=2)
+        except Exception as e:
+            print(f"[AgentStateMachine] Failed to update status file: {e}")
+
+    def transition_to(self, new_state: AgentState) -> bool:
+        """
+        Transition to a new state.
+
+        Args:
+            new_state: The state to transition to
+
+        Returns:
+            True if transition was successful, False otherwise
+        """
+        with self._lock:
+            if new_state == self._state:
+                return True  # Already in this state
+
+            old_state = self._state
+            self._state = new_state
+
+            # Log the state change
+            self._log_state_change(new_state)
+
+            # Update status file
+            self._update_status_file()
+
+            return True
+
+    def get_state(self) -> str:
+        """
+        Get the current state as a string.
+
+        Returns:
+            Current state value as a string
+        """
+        return self._state.value
+
+    def get_state_enum(self) -> AgentState:
+        """
+        Get the current state as an enum.
+
+        Returns:
+            Current AgentState enum
+        """
+        return self._state
+
+    def is_idle(self) -> bool:
+        """Check if agent is in IDLE state."""
+        return self._state == AgentState.IDLE
+
+    def is_processing(self) -> bool:
+        """Check if agent is in PROCESSING state."""
+        return self._state == AgentState.PROCESSING
+
+    def is_success(self) -> bool:
+        """Check if agent is in SUCCESS state."""
+        return self._state == AgentState.SUCCESS
+
+    def is_error(self) -> bool:
+        """Check if agent is in ERROR state."""
+        return self._state == AgentState.ERROR
+
+    def reset(self) -> None:
+        """Reset state to IDLE."""
+        self.transition_to(AgentState.IDLE)
+
+
 class ToolCategory(Enum):
     """Categories of tools for organization"""
     INFRASTRUCTURE = "infrastructure"
@@ -125,8 +275,9 @@ class BrainMinimal:
             self.current_role = None
             self.legacy_mode = True
 
-        # Brain state
-        self.state = BrainState.IDLE
+        # Brain state - use AgentStateMachine for state management
+        self.brain_state = BrainState.IDLE  # Legacy brain state
+        self.state_machine = AgentStateMachine(agent_name or "cain")  # New state machine
         self.tools: Dict[str, Tool] = {}
         self.memory: Dict[str, Any] = {}
         self.last_action = None
@@ -379,19 +530,36 @@ class BrainMinimal:
             }
 
         try:
-            self.state = BrainState.EXECUTING
+            # Transition to PROCESSING state
+            self.state_machine.transition_to(AgentState.PROCESSING)
+            self.brain_state = BrainState.EXECUTING
+
             result = self.tools[tool_name].execute(*args, **kwargs)
             self.last_action = tool_name
             self.last_action_time = datetime.utcnow().isoformat()
-            self.state = BrainState.IDLE
+
+            # Transition to SUCCESS state
+            self.state_machine.transition_to(AgentState.SUCCESS)
+
+            # Return to IDLE after successful completion
+            self.state_machine.transition_to(AgentState.IDLE)
+            self.brain_state = BrainState.IDLE
+
             return result
         except Exception as e:
-            self.state = BrainState.ERROR
+            # Transition to ERROR state
+            self.state_machine.transition_to(AgentState.ERROR)
+            self.brain_state = BrainState.ERROR
             return {
                 "success": False,
                 "error": str(e),
                 "tool": tool_name
             }
+        finally:
+            # Ensure we return to IDLE after any operation
+            if self.state_machine.get_state_enum() not in (AgentState.ERROR,):
+                self.state_machine.transition_to(AgentState.IDLE)
+                self.brain_state = BrainState.IDLE
 
     # ========== Default Tool Implementations ==========
 
@@ -498,7 +666,7 @@ class BrainMinimal:
         return {
             "success": True,
             "status": "healthy",
-            "state": self.state.value,
+            "state": self.brain_state.value,
             "agent": self.agent_name,
             "role": self.current_role.value if self.current_role else "unknown",
             "tools_count": len(self.get_allowed_tools())
@@ -510,7 +678,8 @@ class BrainMinimal:
             "success": True,
             "agent": self.agent_name,
             "role": self.current_role.value if self.current_role else "unknown",
-            "state": self.state.value,
+            "brain_state": self.brain_state.value,
+            "agent_state": self.state_machine.get_state(),
             "last_action": self.last_action,
             "last_action_time": self.last_action_time,
             "legacy_mode": self.legacy_mode
@@ -538,7 +707,7 @@ class BrainMinimal:
         Returns:
             Name of the tool to execute
         """
-        self.state = BrainState.THINKING
+        self.brain_state = BrainState.THINKING
 
         # Simple decision logic
         action = context.get("action", "")
@@ -557,7 +726,7 @@ class BrainMinimal:
         else:
             tool = "get_status"
 
-        self.state = BrainState.IDLE
+        self.brain_state = BrainState.IDLE
         return tool
 
     def execute_decision(self, context: Dict[str, Any]) -> Any:
@@ -573,6 +742,38 @@ class BrainMinimal:
         tool_name = self.think(context)
         return self.execute_tool(tool_name, **context)
 
+    # ========== State Machine Methods ==========
+
+    def get_state(self) -> str:
+        """
+        Get the current agent state as a string.
+
+        Returns:
+            Current state value (idle, processing, success, error)
+        """
+        return self.state_machine.get_state()
+
+    def get_state_enum(self) -> AgentState:
+        """
+        Get the current agent state as an enum.
+
+        Returns:
+            Current AgentState enum
+        """
+        return self.state_machine.get_state_enum()
+
+    def transition_to(self, state: AgentState) -> bool:
+        """
+        Manually transition to a specific state.
+
+        Args:
+            state: The AgentState to transition to
+
+        Returns:
+            True if transition was successful
+        """
+        return self.state_machine.transition_to(state)
+
     # ========== Utility Methods ==========
 
     def get_info(self) -> Dict[str, Any]:
@@ -580,7 +781,8 @@ class BrainMinimal:
         return {
             "agent": self.agent_name,
             "role": self.current_role.value if self.current_role else "unknown",
-            "state": self.state.value,
+            "brain_state": self.brain_state.value,
+            "agent_state": self.state_machine.get_state(),
             "legacy_mode": self.legacy_mode,
             "tools_registered": len(self.tools),
             "tools_allowed": len(self.get_allowed_tools()),

.openclaw/agents/cain_status.json

@@ -0,0 +1,5 @@
+{
+  "current_state": "idle",
+  "last_updated": "2026-03-14T16:15:44.947651+00:00",
+  "agent": "cain"
+}

.openclaw/agents/logs/session-archive.jsonl

@@ -1,2 +1,15 @@
 {"timestamp": "2026-03-14T04:45:10.399081+00:00", "threshold_days": 7, "dry_run": true, "action": "archive_sessions", "total_files": 0, "archived_count": 0, "skipped_count": 0, "error_count": 0, "status": "no_sessions_found"}
 {"timestamp": "2026-03-14T04:45:28.188361+00:00", "threshold_days": 7, "dry_run": true, "action": "archive_sessions", "total_files": 0, "archived_count": 0, "skipped_count": 0, "error_count": 0, "status": "no_sessions_found"}
+{"type": "state_change", "state": "processing", "timestamp": "2026-03-14T16:15:25.366226+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "success", "timestamp": "2026-03-14T16:15:25.366381+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "error", "timestamp": "2026-03-14T16:15:25.367350+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "idle", "timestamp": "2026-03-14T16:15:25.368319+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "processing", "timestamp": "2026-03-14T16:15:25.370340+00:00", "agent": "cain"}
+{"type": "state_change", "state": "error", "timestamp": "2026-03-14T16:15:25.371351+00:00", "agent": "cain"}
+{"type": "state_change", "state": "processing", "timestamp": "2026-03-14T16:15:44.940447+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "success", "timestamp": "2026-03-14T16:15:44.941499+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "error", "timestamp": "2026-03-14T16:15:44.942554+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "idle", "timestamp": "2026-03-14T16:15:44.943556+00:00", "agent": "test_agent"}
+{"type": "state_change", "state": "processing", "timestamp": "2026-03-14T16:15:44.945500+00:00", "agent": "cain"}
+{"type": "state_change", "state": "success", "timestamp": "2026-03-14T16:15:44.946525+00:00", "agent": "cain"}
+{"type": "state_change", "state": "idle", "timestamp": "2026-03-14T16:15:44.947587+00:00", "agent": "cain"}