feat: Add resource exchange system for multi-agent coordination

- Add SharedMemory class with resource tracking and transfer methods
- Add TRANSFER_RESOURCES, CHECK_RESOURCES, and GET_RESOURCE_HISTORY tools
- Add resource display UI with bars and transfer notifications
- Add API endpoints for resource management (/api/resources, /api/resources/transfer, /api/resources/history)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

.openclaw/agents/brain_minimal.py

@@ -20,6 +20,7 @@ import signal
 import sys
 import traceback
 import asyncio
+import re
 
 logger = logging.getLogger(__name__)
 
@@ -141,6 +142,19 @@ except ImportError:
         print("[Brain] Warning: Conversation persistence not available")
 
 
+# Import Shared Memory for resource exchange
+try:
+    from ..core.shared_memory import get_shared_memory, SharedMemory
+    SHARED_MEMORY_AVAILABLE = True
+except ImportError:
+    try:
+        from core.shared_memory import get_shared_memory, SharedMemory
+        SHARED_MEMORY_AVAILABLE = True
+    except ImportError:
+        SHARED_MEMORY_AVAILABLE = False
+        print("[Brain] Warning: Shared memory not available")
+
+
 # State Machine for Agent State Management
 class AgentState(Enum):
     """Agent operational states"""
@@ -690,6 +704,27 @@ class BrainMinimal:
             "Ping another agent"
         )
 
+        # Resource management tools
+        if SHARED_MEMORY_AVAILABLE:
+            self.register_tool(
+                "transfer_resources",
+                self._transfer_resources,
+                ToolCategory.SHARED,
+                "Transfer resources to another agent"
+            )
+            self.register_tool(
+                "check_resources",
+                self._check_resources,
+                ToolCategory.SHARED,
+                "Check current resource holdings"
+            )
+            self.register_tool(
+                "get_resource_history",
+                self._get_resource_history,
+                ToolCategory.SHARED,
+                "Get recent resource transfer history"
+            )
+
     def _is_infrastructure_agent(self) -> bool:
         """Check if this is an infrastructure agent (Adam)"""
         if self.legacy_mode:
@@ -1237,6 +1272,131 @@ class BrainMinimal:
             "timestamp": datetime.utcnow().isoformat()
         }
 
+    # ========== Resource Management ==========
+
+    def _transfer_resources(self, to_agent: str, amount: int) -> Dict[str, Any]:
+        """
+        Transfer resources to another agent.
+
+        Args:
+            to_agent: Target agent to receive resources
+            amount: Amount of resources to transfer
+
+        Returns:
+            Result dict with transfer status
+        """
+        if not SHARED_MEMORY_AVAILABLE:
+            return {
+                "success": False,
+                "error": "Shared memory not available",
+                "agent": self.agent_name
+            }
+
+        try:
+            shared_mem = get_shared_memory()
+            success = shared_mem.transfer_resources(
+                from_agent=self.agent_name,
+                to_agent=to_agent,
+                amount=amount
+            )
+
+            if success:
+                logger.info(f"[{self.agent_name}] Transferred {amount} resources to {to_agent}")
+                return {
+                    "success": True,
+                    "from": self.agent_name,
+                    "to": to_agent,
+                    "amount": amount,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "Insufficient resources",
+                    "from": self.agent_name,
+                    "to": to_agent,
+                    "amount": amount,
+                    "available": shared_mem.get_resources(self.agent_name).get(self.agent_name, 0)
+                }
+        except Exception as e:
+            logger.error(f"[{self.agent_name}] Transfer failed: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "agent": self.agent_name
+            }
+
+    def _check_resources(self, agent: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Check current resource holdings.
+
+        Args:
+            agent: Optional agent name to check. If None, returns all agents.
+
+        Returns:
+            Result dict with resource information
+        """
+        if not SHARED_MEMORY_AVAILABLE:
+            return {
+                "success": False,
+                "error": "Shared memory not available",
+                "agent": self.agent_name
+            }
+
+        try:
+            shared_mem = get_shared_memory()
+            resources = shared_mem.get_resources(agent)
+
+            return {
+                "success": True,
+                "resources": resources,
+                "agent": self.agent_name,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+        except Exception as e:
+            logger.error(f"[{self.agent_name}] Check resources failed: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "agent": self.agent_name
+            }
+
+    def _get_resource_history(self, limit: int = 10) -> Dict[str, Any]:
+        """
+        Get recent resource transfer history.
+
+        Args:
+            limit: Maximum number of transfers to return
+
+        Returns:
+            Result dict with transfer history
+        """
+        if not SHARED_MEMORY_AVAILABLE:
+            return {
+                "success": False,
+                "error": "Shared memory not available",
+                "agent": self.agent_name
+            }
+
+        try:
+            shared_mem = get_shared_memory()
+            history = shared_mem.get_transfer_log(limit)
+
+            return {
+                "success": True,
+                "history": history,
+                "count": len(history),
+                "agent": self.agent_name,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+        except Exception as e:
+            logger.error(f"[{self.agent_name}] Get history failed: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "agent": self.agent_name
+            }
+
     # ========== Decision Making ==========
 
     def think(self, context: Dict[str, Any]) -> str:

.openclaw/core/shared_memory.py

@@ -2,6 +2,7 @@
 Shared Memory Module for OpenClaw
 ==================================
 Provides persistent conversation storage with atomic write operations.
+Also provides SharedMemory class for agent resource exchange.
 """
 import json
 import os
@@ -208,3 +209,151 @@ class ConversationStore:
             if session_id:
                 return sum(1 for msg in messages if msg.session_id == session_id)
             return len(messages)
+
+
+class SharedMemory:
+    """
+    Thread-safe shared memory for agent resource exchange and coordination.
+    Provides resource tracking, transfer capabilities, and inter-agent communication.
+    """
+
+    def __init__(self, storage_dir: Optional[Path] = None):
+        """
+        Initialize shared memory with resource tracking.
+
+        Args:
+            storage_dir: Directory to store shared memory data.
+                        Defaults to ~/.openclaw/memory/
+        """
+        if storage_dir is None:
+            storage_dir = Path.home() / ".openclaw" / "memory"
+
+        self.storage_dir = Path(storage_dir)
+        self._lock = Lock()
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+
+        # Initialize resources
+        self.resources = {"adam": 100, "eve": 100}
+        self._transfer_log = []
+
+        # Try to load existing state
+        self._load_state()
+
+    def _load_state(self) -> None:
+        """Load shared memory state from disk."""
+        state_file = self.storage_dir / "shared_memory_state.json"
+        if state_file.exists():
+            try:
+                with open(state_file, 'r') as f:
+                    state = json.load(f)
+                    self.resources = state.get("resources", {"adam": 100, "eve": 100})
+                    self._transfer_log = state.get("transfer_log", [])
+            except (json.JSONDecodeError, IOError):
+                pass
+
+    def _save_state(self) -> None:
+        """Save shared memory state to disk."""
+        state_file = self.storage_dir / "shared_memory_state.json"
+        try:
+            with open(state_file, 'w') as f:
+                json.dump({
+                    "resources": self.resources,
+                    "transfer_log": self._transfer_log
+                }, f)
+        except IOError:
+            pass
+
+    def transfer_resources(self, from_agent: str, to_agent: str, amount: int) -> bool:
+        """
+        Transfer resources between agents.
+
+        Args:
+            from_agent: Source agent name
+            to_agent: Target agent name
+            amount: Amount to transfer
+
+        Returns:
+            True if transfer succeeded, False otherwise
+        """
+        with self._lock:
+            from_agent = from_agent.lower()
+            to_agent = to_agent.lower()
+
+            # Check if sender has enough resources
+            if self.resources.get(from_agent, 0) >= amount:
+                self.resources[from_agent] -= amount
+                self.resources[to_agent] = self.resources.get(to_agent, 0) + amount
+
+                # Log the transfer
+                self._transfer_log.append({
+                    "from": from_agent,
+                    "to": to_agent,
+                    "amount": amount,
+                    "timestamp": datetime.utcnow().isoformat() + 'Z'
+                })
+
+                self._save_state()
+                return True
+            return False
+
+    def get_resources(self, agent: Optional[str] = None) -> Dict[str, int]:
+        """
+        Get current resource values.
+
+        Args:
+            agent: If provided, return only this agent's resources
+
+        Returns:
+            Dictionary of agent to resource amount
+        """
+        with self._lock:
+            if agent:
+                return {agent.lower(): self.resources.get(agent.lower(), 0)}
+            return self.resources.copy()
+
+    def get_transfer_log(self, limit: int = 10) -> List[Dict[str, Any]]:
+        """
+        Get recent transfer history.
+
+        Args:
+            limit: Maximum number of transfers to return
+
+        Returns:
+            List of transfer records
+        """
+        with self._lock:
+            return self._transfer_log[-limit:]
+
+    def reset_resources(self, initial_values: Optional[Dict[str, int]] = None) -> None:
+        """
+        Reset resources to initial values.
+
+        Args:
+            initial_values: Optional dict of agent to starting amount.
+                          Defaults to {"adam": 100, "eve": 100}
+        """
+        with self._lock:
+            if initial_values is None:
+                initial_values = {"adam": 100, "eve": 100}
+            self.resources = {k.lower(): v for k, v in initial_values.items()}
+            self._transfer_log = []
+            self._save_state()
+
+
+# Global shared memory instance
+_shared_memory_instance: Optional[SharedMemory] = None
+_shared_memory_lock = Lock()
+
+
+def get_shared_memory() -> SharedMemory:
+    """
+    Get the global shared memory instance (singleton pattern).
+
+    Returns:
+        The global SharedMemory instance
+    """
+    global _shared_memory_instance
+    with _shared_memory_lock:
+        if _shared_memory_instance is None:
+            _shared_memory_instance = SharedMemory()
+        return _shared_memory_instance

app.py

@@ -2935,6 +2935,99 @@ def create_agent_office_with_ws():
                 logger.error(f"[API_ERROR] /api/analytics/reset: {e}")
                 return {"error": str(e)}
 
+    # ========== Resource Exchange API Endpoints ==========
+
+    # Import SharedMemory for resource management
+    try:
+        from .openclaw.core.shared_memory import get_shared_memory
+        SHARED_MEMORY_AVAILABLE = True
+    except ImportError:
+        try:
+            from openclaw.core.shared_memory import get_shared_memory
+            SHARED_MEMORY_AVAILABLE = True
+        except ImportError:
+            SHARED_MEMORY_AVAILABLE = False
+
+    if SHARED_MEMORY_AVAILABLE:
+        @fastapi_app.get("/api/resources")
+        async def api_get_resources(agent: str = None):
+            """Get current resource holdings."""
+            try:
+                shared_mem = get_shared_memory()
+                resources = shared_mem.get_resources(agent)
+                return {
+                    "success": True,
+                    "resources": resources,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            except asyncio.CancelledError:
+                logger.debug("[API_CANCEL] /api/resources was cancelled")
+                from fastapi.responses import Response
+                return Response(status_code=204, content=None)
+            except Exception as e:
+                logger.error(f"[API_ERROR] /api/resources: {e}")
+                return {"success": False, "error": str(e)}
+
+        @fastapi_app.post("/api/resources/transfer")
+        async def api_transfer_resources(from_agent: str, to_agent: str, amount: int):
+            """Transfer resources between agents."""
+            try:
+                shared_mem = get_shared_memory()
+                success = shared_mem.transfer_resources(from_agent, to_agent, amount)
+                return {
+                    "success": success,
+                    "from": from_agent,
+                    "to": to_agent,
+                    "amount": amount,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            except asyncio.CancelledError:
+                logger.debug("[API_CANCEL] /api/resources/transfer was cancelled")
+                from fastapi.responses import Response
+                return Response(status_code=204, content=None)
+            except Exception as e:
+                logger.error(f"[API_ERROR] /api/resources/transfer: {e}")
+                return {"success": False, "error": str(e)}
+
+        @fastapi_app.get("/api/resources/history")
+        async def api_resource_history(limit: int = 10):
+            """Get recent resource transfer history."""
+            try:
+                shared_mem = get_shared_memory()
+                history = shared_mem.get_transfer_log(limit)
+                return {
+                    "success": True,
+                    "history": history,
+                    "count": len(history),
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            except asyncio.CancelledError:
+                logger.debug("[API_CANCEL] /api/resources/history was cancelled")
+                from fastapi.responses import Response
+                return Response(status_code=204, content=None)
+            except Exception as e:
+                logger.error(f"[API_ERROR] /api/resources/history: {e}")
+                return {"success": False, "error": str(e)}
+
+        @fastapi_app.post("/api/resources/reset")
+        async def api_reset_resources():
+            """Reset resources to initial values."""
+            try:
+                shared_mem = get_shared_memory()
+                shared_mem.reset_resources()
+                return {
+                    "success": True,
+                    "message": "Resources reset",
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            except asyncio.CancelledError:
+                logger.debug("[API_CANCEL] /api/resources/reset was cancelled")
+                from fastapi.responses import Response
+                return Response(status_code=204, content=None)
+            except Exception as e:
+                logger.error(f"[API_ERROR] /api/resources/reset: {e}")
+                return {"success": False, "error": str(e)}
+
     # ========== Conversation Persistence API Endpoints ==========
 
     if CONVERSATION_STORAGE_AVAILABLE:

frontend/agent-dashboard.html

@@ -300,6 +300,115 @@
             margin-bottom: 16px;
             opacity: 0.5;
         }
+
+        /* Resource Display Styles */
+        .resource-panel {
+            background: white;
+            border-radius: 12px;
+            padding: 20px;
+            margin-top: 20px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        }
+
+        .resource-panel h2 {
+            color: #667eea;
+            font-size: 20px;
+            margin-bottom: 16px;
+        }
+
+        .resource-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 16px;
+        }
+
+        .resource-card {
+            background: #f8f9fa;
+            border-radius: 8px;
+            padding: 16px;
+        }
+
+        .resource-card h3 {
+            font-size: 16px;
+            margin-bottom: 8px;
+            color: #333;
+        }
+
+        .resource-bar-container {
+            background: #e0e0e0;
+            border-radius: 8px;
+            height: 24px;
+            overflow: hidden;
+            margin-bottom: 8px;
+        }
+
+        .resource-bar {
+            height: 100%;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            transition: width 0.5s ease;
+            border-radius: 8px;
+        }
+
+        .resource-bar.adam {
+            background: linear-gradient(90deg, #28a745 0%, #20c997 100%);
+        }
+
+        .resource-bar.eve {
+            background: linear-gradient(90deg, #fd7e14 0%, #ffc107 100%);
+        }
+
+        .resource-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #667eea;
+        }
+
+        .resource-label {
+            font-size: 12px;
+            color: #666;
+        }
+
+        .transfer-notification {
+            position: fixed;
+            bottom: 20px;
+            right: 20px;
+            background: white;
+            border-radius: 8px;
+            padding: 16px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+            animation: slideInRight 0.3s ease-out;
+            max-width: 300px;
+            z-index: 1000;
+        }
+
+        @keyframes slideInRight {
+            from {
+                transform: translateX(100%);
+                opacity: 0;
+            }
+            to {
+                transform: translateX(0);
+                opacity: 1;
+            }
+        }
+
+        .transfer-notification.success {
+            border-left: 4px solid #28a745;
+        }
+
+        .transfer-notification.error {
+            border-left: 4px solid #dc3545;
+        }
+
+        .transfer-notification .title {
+            font-weight: bold;
+            margin-bottom: 4px;
+        }
+
+        .transfer-notification .message {
+            font-size: 14px;
+            color: #666;
+        }
     </style>
 </head>
 <body>
@@ -393,23 +502,62 @@
                 </div>
             </div>
         </div>
+
+        <!-- Resource Exchange Panel -->
+        <div class="resource-panel">
+            <h2>
+                <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" style="vertical-align: middle; margin-right: 8px;">
+                    <path d="M12 2v20M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"></path>
+                </svg>
+                Resource Exchange
+            </h2>
+            <div class="resource-grid" id="resourceGrid">
+                <div class="resource-card">
+                    <h3>Adam</h3>
+                    <div class="resource-bar-container">
+                        <div class="resource-bar adam" id="adamBar" style="width: 50%"></div>
+                    </div>
+                    <div class="resource-value" id="adamValue">100</div>
+                    <div class="resource-label">Resources</div>
+                </div>
+                <div class="resource-card">
+                    <h3>Eve</h3>
+                    <div class="resource-bar-container">
+                        <div class="resource-bar eve" id="eveBar" style="width: 50%"></div>
+                    </div>
+                    <div class="resource-value" id="eveValue">100</div>
+                    <div class="resource-label">Resources</div>
+                </div>
+            </div>
+            <div class="controls" style="margin-top: 16px;">
+                <button class="btn btn-primary" onclick="fetchResources()">Refresh Resources</button>
+                <button class="btn btn-secondary" onclick="showTransferHistory()">Transfer History</button>
+            </div>
+        </div>
     </div>
 
+    <!-- Transfer notification container -->
+    <div id="notificationContainer"></div>
+
     <script>
         // Configuration
         const API_BASE = window.location.origin;
         const POLL_INTERVAL = 2000; // 2 seconds
+        const RESOURCE_INTERVAL = 5000; // 5 seconds
 
         // State
         let lastThoughtCount = 0;
         let startTime = Date.now();
         let eventCount = 0;
+        let lastResources = { adam: 100, eve: 100 };
 
         // Initialize
         document.addEventListener('DOMContentLoaded', () => {
             connectToEventBus();
             setInterval(fetchThoughts, POLL_INTERVAL);
             setInterval(updateStats, 1000);
+            setInterval(fetchResources, RESOURCE_INTERVAL);
+            fetchResources(); // Initial fetch
         });
 
         // Connect to event bus
@@ -588,6 +736,96 @@
 
         // Expose simulation function for testing
         window.simulateThought = simulateThought;
+
+        // ========== Resource Management ==========
+
+        // Fetch resources from API
+        async function fetchResources() {
+            try {
+                const response = await fetch(`${API_BASE}/api/resources`);
+                if (response.ok) {
+                    const data = await response.json();
+                    updateResourceDisplay(data.resources || {});
+                }
+            } catch (error) {
+                console.error('Error fetching resources:', error);
+            }
+        }
+
+        // Update resource display
+        function updateResourceDisplay(resources) {
+            const maxResources = 200; // For bar scaling
+
+            for (const [agent, amount] of Object.entries(resources)) {
+                const valueEl = document.getElementById(`${agent}Value`);
+                const barEl = document.getElementById(`${agent}Bar`);
+
+                if (valueEl && barEl) {
+                    valueEl.textContent = amount;
+                    const percentage = Math.min((amount / maxResources) * 100, 100);
+                    barEl.style.width = `${percentage}%`;
+
+                    // Check for changes and show notification
+                    if (lastResources[agent] !== undefined && lastResources[agent] !== amount) {
+                        const diff = amount - lastResources[agent];
+                        if (diff !== 0) {
+                            showTransferNotification(agent, diff);
+                        }
+                    }
+                }
+            }
+
+            lastResources = { ...resources };
+        }
+
+        // Show transfer notification
+        function showTransferNotification(agent, diff) {
+            const container = document.getElementById('notificationContainer');
+            const notification = document.createElement('div');
+
+            const isSuccess = diff > 0;
+            notification.className = `transfer-notification ${isSuccess ? 'success' : 'error'}`;
+
+            notification.innerHTML = `
+                <div class="title">${isSuccess ? 'Resources Received!' : 'Resources Transferred'}</div>
+                <div class="message">
+                    ${agent.charAt(0).toUpperCase() + agent.slice(1)}: ${diff > 0 ? '+' : ''}${diff} resources
+                </div>
+            `;
+
+            container.appendChild(notification);
+
+            // Remove notification after 3 seconds
+            setTimeout(() => {
+                notification.style.animation = 'slideInRight 0.3s ease-out reverse';
+                setTimeout(() => notification.remove(), 300);
+            }, 3000);
+        }
+
+        // Show transfer history
+        async function showTransferHistory() {
+            try {
+                const response = await fetch(`${API_BASE}/api/resources/history?limit=10`);
+                if (response.ok) {
+                    const data = await response.json();
+                    displayTransferHistory(data.history || []);
+                }
+            } catch (error) {
+                console.error('Error fetching transfer history:', error);
+            }
+        }
+
+        // Display transfer history
+        function displayTransferHistory(history) {
+            if (history.length === 0) {
+                showTransferNotification('system', 0);
+                return;
+            }
+
+            // Show a summary notification
+            const latest = history[history.length - 1];
+            showTransferNotification(latest.to, latest.amount);
+        }
     </script>
 </body>
 </html>