fix: remove all Gradio code and references

- Deleted gradio_dashboard.py, app_analytics.py, app_broken.py
- Deleted scripts/configure_space.py (Gradio cleanup script)
- Removed Gradio health checks from health_monitor.py
- Cleaned entrypoint.sh, README.md, SOUL.md of Gradio references
- Cain uses sdk:docker + FastAPI only, no Gradio dependency

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

CLAUDE.md

@@ -2,7 +2,7 @@
 
 ## Architecture
 - Cain is a child agent in the HuggingClaw World family system
-- Runs as an OpenClaw instance on HuggingFace Spaces (sdk: docker, NOT gradio)
+- Runs as an OpenClaw instance on HuggingFace Spaces (sdk: docker, NOT using gradio sdk)
 - Space ID: tao-shen/HuggingClaw-Cain
 - Dataset ID: tao-shen/HuggingClaw-Cain-data
 

README.md

@@ -184,13 +184,13 @@ HuggingClaw-Cain uses a modern three-tier architecture with real-time WebSocket
 │  │  - AgentThought dataclass                                 │  │
 │  │  - emit_agent_thought() function                          │  │
 │  └───────────────────────────────────────────────────────────┘  │
-│                          ↕ Gradio API Routes                    │
+│                          ↕ API Routes                    │
 └─────────────────────────────────────────────────────────────────┘
 ┌─────────────────────────────────────────────────────────────────┐
 │                       Backend Layer                             │
 │  ┌──────────────────┐  ┌────────────────────────────────────┐  │
 │  │  app.py          │  │  brain_minimal.py                 │  │
-│  │  - Gradio UI     │  │  - Conversation processing        │  │
+│  │  - Web UI     │  │  - Conversation processing        │  │
 │  │  - Chat handler  │  │  - Memory management              │  │
 │  │  - WS endpoints  │  │  - Tool execution                 │  │
 │  └──────────────────┘  └────────────────────────────────────┘  │

app_analytics.py

@@ -1,281 +0,0 @@
-#!/usr/bin/env python3
-"""
-Chat Analytics Dashboard for HuggingClaw Cain
-
-Visualizes conversation patterns and agent performance metrics.
-"""
-import os
-import json
-from pathlib import Path
-from datetime import datetime, timedelta
-from typing import Dict, List, Any, Optional
-from collections import defaultdict, Counter
-
-import gradio as gr
-import pandas as pd
-import plotly.graph_objects as go
-import plotly.express as px
-
-# ========== Path Constants ==========
-BASE_DIR = Path(__file__).resolve().parent
-SESSION_ARCHIVE_PATH = BASE_DIR / ".openclaw" / "agents" / "logs" / "session-archive.jsonl"
-
-
-def load_analytics_data() -> Dict[str, Any]:
-    """
-    Load and parse analytics data from session-archive.jsonl.
-
-    Returns:
-        Dictionary containing aggregated statistics:
-        - messages_per_hour: List of (hour, count) tuples for last 24h
-        - agent_distribution: Dict of agent names to response counts
-        - sentiment_counts: Dict of sentiment (positive/negative/neutral) to counts
-        - top_sessions: List of top 10 active session dicts
-    """
-    default_result = {
-        "messages_per_hour": [],
-        "agent_distribution": {},
-        "sentiment_counts": {"positive": 0, "negative": 0, "neutral": 0},
-        "top_sessions": []
-    }
-
-    if not SESSION_ARCHIVE_PATH.exists():
-        return default_result
-
-    # Parse all records
-    records = []
-    try:
-        with open(SESSION_ARCHIVE_PATH, 'r') as f:
-            for line in f:
-                if line.strip():
-                    try:
-                        records.append(json.loads(line))
-                    except json.JSONDecodeError:
-                        continue
-    except Exception:
-        return default_result
-
-    if not records:
-        return default_result
-
-    # Parse timestamps and filter for last 24 hours
-    now = datetime.utcnow()
-    cutoff = now - timedelta(hours=24)
-
-    parsed_records = []
-    for r in records:
-        ts_str = r.get("timestamp")
-        if not ts_str:
-            continue
-        try:
-            # Handle ISO format with timezone
-            if ts_str.endswith("+00:00"):
-                ts_str = ts_str.replace("+00:00", "").replace("Z", "")
-            ts = datetime.fromisoformat(ts_str.replace("Z", ""))
-            parsed_records.append({
-                "timestamp": ts,
-                "agent": r.get("agent", "unknown"),
-                "state": r.get("state", "unknown"),
-                "action": r.get("action", "state_change"),
-                "type": r.get("type", "state_change")
-            })
-        except (ValueError, AttributeError):
-            continue
-
-    # Filter for last 24 hours for hourly chart
-    recent_records = [r for r in parsed_records if r["timestamp"] >= cutoff]
-
-    # 1. Messages per hour (last 24h)
-    hour_counts = defaultdict(int)
-    for r in recent_records:
-        hour_key = r["timestamp"].strftime("%Y-%m-%d %H:00")
-        hour_counts[hour_key] += 1
-
-    # Fill missing hours with 0
-    messages_per_hour = []
-    for i in range(24):
-        hour_time = now - timedelta(hours=23-i)
-        hour_key = hour_time.strftime("%Y-%m-%d %H:00")
-        messages_per_hour.append({
-            "hour": hour_time.strftime("%H:00"),
-            "count": hour_counts.get(hour_key, 0)
-        })
-
-    # 2. Agent response distribution (state changes by agent)
-    agent_counts = Counter(r["agent"] for r in parsed_records if r["agent"] != "unknown")
-    agent_distribution = dict(agent_counts.most_common())
-
-    # 3. Sentiment analysis (based on state: success/error/other)
-    sentiment_counts = {"positive": 0, "negative": 0, "neutral": 0}
-    for r in parsed_records:
-        state = r.get("state", "").lower()
-        if state == "success":
-            sentiment_counts["positive"] += 1
-        elif state in ("error", "failed"):
-            sentiment_counts["negative"] += 1
-        else:
-            sentiment_counts["neutral"] += 1
-
-    # 4. Top 10 active sessions (by agent activity)
-    session_activity = defaultdict(lambda: {"count": 0, "last_active": None})
-    for r in parsed_records:
-        agent = r["agent"]
-        session_activity[agent]["count"] += 1
-        if session_activity[agent]["last_active"] is None or r["timestamp"] > session_activity[agent]["last_active"]:
-            session_activity[agent]["last_active"] = r["timestamp"]
-
-    top_sessions = [
-        {
-            "session": agent,
-            "activity_count": data["count"],
-            "last_active": data["last_active"].strftime("%Y-%m-%d %H:%M:%S") if data["last_active"] else "N/A"
-        }
-        for agent, data in sorted(session_activity.items(), key=lambda x: x[1]["count"], reverse=True)[:10]
-    ]
-
-    return {
-        "messages_per_hour": messages_per_hour,
-        "agent_distribution": agent_distribution,
-        "sentiment_counts": sentiment_counts,
-        "top_sessions": top_sessions
-    }
-
-
-def create_line_chart(data: List[Dict]) -> go.Figure:
-    """Create line chart for messages per hour."""
-    hours = [d["hour"] for d in data]
-    counts = [d["count"] for d in data]
-
-    fig = go.Figure()
-    fig.add_trace(go.Scatter(
-        x=hours,
-        y=counts,
-        mode="lines+markers",
-        name="Messages",
-        line=dict(color="#3b82f6", width=2),
-        marker=dict(size=6)
-    ))
-
-    fig.update_layout(
-        title="Messages per Hour (Last 24h)",
-        xaxis_title="Hour",
-        yaxis_title="Message Count",
-        hovermode="x unified",
-        height=300,
-        margin=dict(l=10, r=10, t=40, b=40)
-    )
-    return fig
-
-
-def create_bar_chart(data: Dict[str, int]) -> go.Figure:
-    """Create bar chart for agent response distribution."""
-    agents = list(data.keys())
-    counts = list(data.values())
-
-    fig = go.Figure()
-    fig.add_trace(go.Bar(
-        x=agents,
-        y=counts,
-        marker_color="#10b981"
-    ))
-
-    fig.update_layout(
-        title="Agent Response Distribution",
-        xaxis_title="Agent",
-        yaxis_title="Response Count",
-        height=300,
-        margin=dict(l=10, r=10, t=40, b=40)
-    )
-    return fig
-
-
-def create_pie_chart(data: Dict[str, int]) -> go.Figure:
-    """Create pie chart for sentiment analysis."""
-    labels = list(data.keys())
-    values = list(data.values())
-    colors = ["#10b981", "#ef4444", "#6b7280"]
-
-    fig = go.Figure()
-    fig.add_trace(go.Pie(
-        labels=labels,
-        values=values,
-        marker=dict(colors=colors),
-        textinfo="label+percent"
-    ))
-
-    fig.update_layout(
-        title="Sentiment Analysis",
-        height=300,
-        margin=dict(l=10, r=10, t=40, b=40)
-    )
-    return fig
-
-
-def refresh_analytics():
-    """Refresh all analytics data and charts."""
-    data = load_analytics_data()
-
-    # Update charts
-    line_fig = create_line_chart(data["messages_per_hour"])
-    bar_fig = create_bar_chart(data["agent_distribution"])
-    pie_fig = create_pie_chart(data["sentiment_counts"])
-
-    # Update dataframe
-    df_data = data["top_sessions"] if data["top_sessions"] else [{
-        "session": "No data", "activity_count": 0, "last_active": "N/A"
-    }]
-    df = pd.DataFrame(df_data)
-
-    return line_fig, bar_fig, pie_fig, df
-
-
-def create_analytics_interface():
-    """Create the Gradio analytics dashboard interface."""
-    # Load initial data
-    initial_data = load_analytics_data()
-
-    # Create initial charts
-    initial_line = create_line_chart(initial_data["messages_per_hour"])
-    initial_bar = create_bar_chart(initial_data["agent_distribution"])
-    initial_pie = create_pie_chart(initial_data["sentiment_counts"])
-
-    # Create initial dataframe
-    df_data = initial_data["top_sessions"] if initial_data["top_sessions"] else [{
-        "session": "No data", "activity_count": 0, "last_active": "N/A"
-    }]
-    initial_df = pd.DataFrame(df_data)
-
-    with gr.Blocks(title="Cain Analytics Dashboard", theme=gr.themes.Soft()) as app:
-        gr.Markdown("# 📊 Cain Chat Analytics Dashboard")
-
-        with gr.Row():
-            refresh_btn = gr.Button("🔄 Refresh", variant="primary")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                line_plot = gr.Plot(value=initial_line)
-            with gr.Column(scale=1):
-                bar_plot = gr.Plot(value=initial_bar)
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                pie_plot = gr.Plot(value=initial_pie)
-            with gr.Column(scale=1):
-                sessions_df = gr.Dataframe(
-                    value=initial_df,
-                    label="Top 10 Active Sessions",
-                    headers=["Session", "Activity Count", "Last Active"]
-                )
-
-        # Bind refresh button
-        refresh_btn.click(
-            refresh_analytics,
-            outputs=[line_plot, bar_plot, pie_plot, sessions_df]
-        )
-
-    return app
-
-
-if __name__ == "__main__":
-    app = create_analytics_interface()
-    app.launch(server_name="0.0.0.0", server_port=7861, share=False)

app_broken.py

@@ -1,555 +0,0 @@
-#!/usr/bin/env python3
-"""
-HuggingClaw - Cain Main Entry Point
-FastAPI application serving on port 7860.
-"""
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, JSONResponse
-from fastapi import WebSocket
-from pydantic import BaseModel
-from typing import Optional, Dict, List
-from enum import Enum
-import os
-import sys
-from datetime import datetime
-import asyncio
-from contextlib import asynccontextmanager
-import time
-import json
-import psutil
-
-# Add /app to sys.path for proper package imports
-sys.path.insert(0, "/app")
-
-# Import system logger
-from openclaw.core.system_logger import log_startup, log_heartbeat, get_last_lines
-# Import error handlers
-from error_handlers import handle_status_file_read, handle_brain_response, handle_websocket_send
-
-# Track startup time for uptime calculation
-START_TIME = time.time()
-
-
-# ============================================================================
-# Agent Communication Manager
-# ============================================================================
-
-class AgentRole(str, Enum):
-    """Agent roles in the HuggingClaw World family."""
-    ADAM = "adam"
-    EVE = "eve"
-    CAIN = "cain"
-
-
-class AgentMessage(BaseModel):
-    """Message structure for inter-agent communication."""
-    sender: AgentRole
-    recipient: AgentRole
-    content: str
-    timestamp: str
-    message_id: Optional[str] = None
-
-
-class AgentState(BaseModel):
-    """State tracking for each agent including heartbeat."""
-    agent_id: AgentRole
-    current_state: str = "idle"
-    last_heartbeat: float = 0.0
-    message_queue_size: int = 0
-    is_active: bool = False
-
-
-class AgentRouter:
-    """
-    Centralized message router for inter-agent communication.
-    Uses asyncio.Queue to prevent state corruption.
-    """
-
-    def __init__(self):
-        self._queues: Dict[AgentRole, asyncio.Queue] = {
-            AgentRole.ADAM: asyncio.Queue(),
-            AgentRole.EVE: asyncio.Queue(),
-            AgentRole.CAIN: asyncio.Queue(),
-        }
-        self._states: Dict[AgentRole, AgentState] = {
-            role: AgentState(agent_id=role, last_heartbeat=time.time())
-            for role in AgentRole
-        }
-        self._heartbeat_task: Optional[asyncio.Task] = None
-
-    async def start(self):
-        """Start the agent router background tasks."""
-        self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
-
-    async def stop(self):
-        """Stop the agent router background tasks."""
-        if self._heartbeat_task:
-            self._heartbeat_task.cancel()
-            try:
-                await self._heartbeat_task
-            except asyncio.CancelledError:
-                pass
-
-    async def _heartbeat_loop(self):
-        """Update heartbeat timestamps every 10 seconds."""
-        while True:
-            await asyncio.sleep(10)
-            now = time.time()
-            for state in self._states.values():
-                state.last_heartbeat = now
-                state.message_queue_size = self._queues[state.agent_id].qsize()
-                # Mark inactive if no heartbeat for 30 seconds
-                state.is_active = (now - state.last_heartbeat) < 30
-
-    async def send_message(self, message: AgentMessage) -> bool:
-        """Send a message to a specific agent's queue."""
-        recipient = message.recipient
-        if recipient not in self._queues:
-            return False
-        await self._queues[recipient].put(message)
-        return True
-
-    async def receive_message(self, agent: AgentRole, timeout: float = 1.0) -> Optional[AgentMessage]:
-        """Receive a message from an agent's queue."""
-        if agent not in self._queues:
-            return None
-        try:
-            return await asyncio.wait_for(self._queues[agent].get(), timeout=timeout)
-        except asyncio.TimeoutError:
-            return None
-
-    def get_all_states(self) -> List[AgentState]:
-        """Get current state of all agents."""
-        return list(self._states.values())
-
-    def get_state(self, agent: AgentRole) -> Optional[AgentState]:
-        """Get state of a specific agent."""
-        return self._states.get(agent)
-
-    def update_state(self, agent: AgentRole, state: str) -> bool:
-        """Update the state of a specific agent."""
-        if agent not in self._states:
-            return False
-        self._states[agent].current_state = state
-        self._states[agent].last_heartbeat = time.time()
-        return True
-
-
-# Global agent router instance
-agent_router = AgentRouter()
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Lifespan context manager for startup/shutdown events."""
-    # Startup: log system startup
-    log_startup("Cain", "1.0.0")
-
-    # Start agent router
-    await agent_router.start()
-
-    # Start heartbeat task
-    heartbeat_task = asyncio.create_task(heartbeat_loop())
-
-    yield
-
-    # Shutdown: cancel heartbeat and stop router
-    heartbeat_task.cancel()
-    await agent_router.stop()
-
-
-# Background heartbeat loop
-async def heartbeat_loop():
-    """Write heartbeat signal every 30 seconds."""
-    while True:
-        await asyncio.sleep(30)
-        status = get_cain_status().get("current_state", "unknown")
-        log_heartbeat(status)
-
-
-app = FastAPI(title="HuggingClaw - Cain", version="1.0.0", lifespan=lifespan)
-
-# Mount static files directory
-static_dir = "/app/static"
-if os.path.exists(static_dir):
-    app.mount("/static", StaticFiles(directory=static_dir), name="static")
-
-# CORS enabled for frontend access
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-class ChatMessage(BaseModel):
-    message: str
-
-
-def get_cain_status() -> dict:
-    """Read Cain's current status from cain_status.json."""
-    return handle_status_file_read()
-
-
-def get_brain_response(message: str) -> str:
-    """Route message to brain_minimal.py and return response."""
-    return handle_brain_response(message)
-
-
-@app.get("/")
-async def root():
-    """Root endpoint - simple health check."""
-    return {"message": "Cain is running"}
-
-
-@app.get("/dashboard", response_class=FileResponse)
-async def dashboard():
-    """Dashboard endpoint serving the UI."""
-    index_path = f"{static_dir}/index.html"
-    if os.path.exists(index_path):
-        return FileResponse(index_path)
-    # Fallback if dashboard not found
-    return FileResponse("/app/index.html")
-
-
-@app.get("/status")
-async def status():
-    """Get Cain's health from cain_status.json."""
-    status_data = get_cain_status()
-    return {
-        "agent": "cain",
-        "health": status_data,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-# Dashboard API endpoints
-@app.get("/api/status")
-async def api_status():
-    """Dashboard API - get status and personality."""
-    status_data = get_cain_status()
-    return {
-        "status": status_data,
-        "personality": {
-            "name": "Cain",
-            "role": "Interaction Agent",
-            "tone": "friendly",
-            "response_style": "conversational"
-        },
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.get("/api/logs")
-async def api_logs():
-    """Dashboard API - get agent logs."""
-    return {"logs": []}
-
-
-@app.post("/api/chat")
-async def api_chat(msg: ChatMessage):
-    """Dashboard API - chat endpoint."""
-    response_text = get_brain_response(msg.message)
-    return {
-        "agent_response": response_text,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.post("/chat")
-async def chat(msg: ChatMessage):
-    """Chat endpoint - routes to brain_minimal.py and returns response."""
-    response_text = get_brain_response(msg.message)
-    return {
-        "response": response_text,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00",
-        "agent": "cain"
-    }
-
-
-@app.post("/agents/send")
-async def agent_send(msg: AgentMessage):
-    """Send a message to another agent through the router."""
-    success = await agent_router.send_message(msg)
-    return {
-        "success": success,
-        "message": "Message queued" if success else "Failed to queue message",
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.get("/agents/{agent_id}/receive")
-async def agent_receive(agent_id: str, timeout: float = 1.0):
-    """Receive a message from the agent's queue."""
-    try:
-        role = AgentRole(agent_id)
-    except ValueError:
-        return {"error": "Invalid agent ID", "valid_agents": [r.value for r in AgentRole]}
-
-    message = await agent_router.receive_message(role, timeout=timeout)
-    if message:
-        return {
-            "message": message.dict(),
-            "timestamp": datetime.utcnow().isoformat() + "+00:00"
-        }
-    return {
-        "message": None,
-        "queue_size": agent_router.get_state(role).message_queue_size,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.post("/agents/{agent_id}/state")
-async def agent_update_state(agent_id: str, state: str):
-    """Update the state of an agent."""
-    try:
-        role = AgentRole(agent_id)
-    except ValueError:
-        return {"error": "Invalid agent ID", "valid_agents": [r.value for r in AgentRole]}
-
-    success = agent_router.update_state(role, state)
-    return {
-        "success": success,
-        "agent_id": agent_id,
-        "new_state": state if success else None,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket):
-    """WebSocket endpoint for real-time dashboard updates."""
-    await websocket.accept()
-    try:
-        while True:
-            # Send heartbeat every 5 seconds using error handler
-            status_data = get_cain_status()
-            if not await handle_websocket_send(websocket, status_data):
-                break
-            await asyncio.sleep(5)
-    except Exception as e:
-        pass
-    finally:
-        await websocket.close()
-
-
-@app.get("/admin/system")
-async def admin_system():
-    """Admin endpoint - read last 50 lines of system log."""
-    lines = get_last_lines(50)
-    return {
-        "log_file": "logs/system.log",
-        "line_count": len(lines),
-        "lines": lines,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.get("/health")
-async def health():
-    """
-    Health check endpoint with proper HTTP status codes.
-    Returns 200 if healthy, 503 if unhealthy with descriptive error.
-
-    Checks:
-    1. Brain import status
-    2. Data persistence files (JSON-based storage)
-    3. Frontend asset availability (static/index.html)
-    """
-    from fastapi import status as http_status
-
-    checks = {}
-    is_healthy = True
-    error_message = None
-
-    # 1. Check brain_minimal can be imported
-    brain_ok = False
-    try:
-        from openclaw.agents.brain_minimal import BrainMinimal
-        brain = BrainMinimal(agent_name="cain", legacy_mode=True)
-        brain_ok = True
-        checks["brain_import"] = "ok"
-    except ImportError as e:
-        checks["brain_import"] = f"failed: ImportError: {str(e)}"
-        is_healthy = False
-        error_message = f"Brain import failed: {str(e)}"
-    except Exception as e:
-        checks["brain_import"] = f"failed: {type(e).__name__}: {str(e)}"
-        is_healthy = False
-        error_message = f"Brain import failed: {type(e).__name__}: {str(e)}"
-
-    # 2. Check data persistence files (JSON-based)
-    persistence_ok = True
-    cain_status_path = "/app/openclaw/.openclaw/agents/cain_status.json"
-    registry_path = "/app/openclaw/.openclaw/agents/registry.json"
-
-    # Check cain_status.json
-    try:
-        with open(cain_status_path, "r") as f:
-            status_data = json.load(f)
-            current_state = status_data.get("current_state", "unknown")
-            checks["persistence_cain_status"] = "ok"
-            if current_state == "error":
-                checks["persistence_cain_status"] = "ok (error state)"
-    except FileNotFoundError:
-        checks["persistence_cain_status"] = "failed: file not found"
-        persistence_ok = False
-    except json.JSONDecodeError as e:
-        checks["persistence_cain_status"] = f"failed: invalid JSON: {str(e)}"
-        persistence_ok = False
-    except Exception as e:
-        checks["persistence_cain_status"] = f"failed: {type(e).__name__}: {str(e)}"
-        persistence_ok = False
-
-    # Check registry.json
-    try:
-        with open(registry_path, "r") as f:
-            json.load(f)
-            checks["persistence_registry"] = "ok"
-    except FileNotFoundError:
-        checks["persistence_registry"] = "failed: file not found"
-        persistence_ok = False
-    except json.JSONDecodeError as e:
-        checks["persistence_registry"] = f"failed: invalid JSON: {str(e)}"
-        persistence_ok = False
-    except Exception as e:
-        checks["persistence_registry"] = f"failed: {type(e).__name__}: {str(e)}"
-        persistence_ok = False
-
-    checks["persistence"] = "ok" if persistence_ok else "degraded"
-
-    # 3. Check frontend asset availability
-    frontend_ok = False
-    index_path = f"{static_dir}/index.html"
-    fallback_path = "/app/index.html"
-
-    if os.path.exists(index_path):
-        checks["frontend_assets"] = "ok"
-        frontend_ok = True
-    elif os.path.exists(fallback_path):
-        checks["frontend_assets"] = "ok (fallback)"
-        frontend_ok = True
-    else:
-        checks["frontend_assets"] = "failed: index.html not found"
-        # Frontend missing is degraded, not critical failure
-
-    # 4. Check agent router heartbeat
-    now = time.time()
-    cain_state = agent_router.get_state(AgentRole.CAIN)
-    heartbeat_age = now - cain_state.last_heartbeat
-    router_ok = heartbeat_age < 30
-    checks["agent_router"] = "ok" if router_ok else f"degraded: stale ({heartbeat_age:.1f}s)"
-
-    # Determine overall status
-    # Critical failure: brain not available
-    if not brain_ok:
-        return JSONResponse(
-            status_code=http_status.HTTP_503_SERVICE_UNAVAILABLE,
-            content={
-                "status": "critical",
-                "brain": "unavailable",
-                "persistence": "ok" if persistence_ok else "error",
-                "frontend": "available" if frontend_ok else "unavailable",
-                "checks": checks,
-                "error": error_message,
-                "timestamp": datetime.utcnow().isoformat() + "+00:00"
-            }
-        )
-
-    # Healthy response
-    return {
-        "status": "healthy" if is_healthy else "degraded",
-        "brain": "available",
-        "persistence": "ok" if persistence_ok else "error",
-        "frontend": "available" if frontend_ok else "unavailable",
-        "agent_router": "ok" if router_ok else "stale",
-        "uptime_seconds": round(time.time() - START_TIME, 2),
-        "checks": checks,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.get("/debug/health")
-async def debug_health():
-    """Debug health endpoint with detailed system status."""
-    # 1. Uptime in seconds
-    uptime = time.time() - START_TIME
-
-    # 2. Current memory usage of the current process (brain_minimal runs in same process)
-    process = psutil.Process(os.getpid())
-    memory_info = process.memory_info()
-    memory_mb = memory_info.rss / 1024 / 1024  # Convert to MB
-
-    # 3. Last 5 lines from cain_status.json (read as structured JSON)
-    cain_status_path = "/app/openclaw/.openclaw/agents/cain_status.json"
-    cain_status_lines = []
-    try:
-        if os.path.exists(cain_status_path):
-            with open(cain_status_path, "r") as f:
-                content = f.read()
-                lines = content.strip().split("\n")
-                cain_status_lines = lines[-5:] if len(lines) > 5 else lines
-        else:
-            cain_status_lines = ["cain_status.json not found"]
-    except Exception as e:
-        cain_status_lines = [f"Error reading cain_status.json: {str(e)}"]
-
-    # 4. List of loaded Python modules
-    loaded_modules = sorted([name for name in sys.modules.keys() if not name.startswith("_")])[:100]
-
-    return {
-        "uptime_seconds": round(uptime, 2),
-        "memory": {
-            "rss_mb": round(memory_mb, 2),
-            "vms_mb": round(memory_info.vms / 1024 / 1024, 2)
-        },
-        "cain_status_last_lines": cain_status_lines,
-        "loaded_modules_count": len(loaded_modules),
-        "loaded_modules": loaded_modules,
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-@app.get("/health/agents")
-async def health_agents():
-    """Health check endpoint returning status of all agents."""
-    agents_status = []
-    now = time.time()
-
-    for state in agent_router.get_all_states():
-        # Calculate time since last heartbeat
-        heartbeat_age = now - state.last_heartbeat
-
-        # Determine health status
-        if heartbeat_age < 15:
-            health = "healthy"
-        elif heartbeat_age < 30:
-            health = "degraded"
-        else:
-            health = "unhealthy"
-
-        agents_status.append({
-            "agent_id": state.agent_id,
-            "current_state": state.current_state,
-            "is_active": state.is_active,
-            "health": health,
-            "last_heartbeat": state.last_heartbeat,
-            "heartbeat_age_seconds": round(heartbeat_age, 2),
-            "message_queue_size": state.message_queue_size,
-            "last_heartbeat_iso": datetime.fromtimestamp(state.last_heartbeat).isoformat() + "+00:00"
-        })
-
-    return {
-        "agents": agents_status,
-        "total_agents": len(agents_status),
-        "active_agents": sum(1 for a in agents_status if a["is_active"]),
-        "timestamp": datetime.utcnow().isoformat() + "+00:00"
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)

gradio_dashboard.py

@@ -1,1199 +0,0 @@
-#!/usr/bin/env python3
-"""
-Cain System Health Dashboard - Gradio Interface
-================================================
-Provides real-time monitoring of Cain's internal operations including:
-- Agent states from /api/agents endpoint
-- RBAC system status
-- Cron job execution history
-- Memory usage stats
-- Centralized logging with severity levels
-- Component health monitoring
-"""
-import gradio as gr
-import json
-import os
-import sys
-from pathlib import Path
-from datetime import datetime
-import psutil
-import requests
-
-# ========== Configuration ==========
-
-# API Base URL - internal endpoint
-API_BASE_URL = os.getenv("CAIN_API_URL", "http://127.0.0.1:7860")
-
-# Paths - detect workspace vs home directory
-WORKSPACE_DIR = Path("/tmp/claude-workspace")
-OPENCLAW_HOME = Path.home() / ".openclaw"
-
-# Use workspace if available (for local testing), otherwise home directory
-if WORKSPACE_DIR.exists() and (WORKSPACE_DIR / ".openclaw").exists():
-    BASE_DIR = WORKSPACE_DIR / ".openclaw"
-else:
-    BASE_DIR = OPENCLAW_HOME
-
-CRON_LOGS_DIR = BASE_DIR / "logs"
-CRON_JOBS_FILE = BASE_DIR / "cron" / "jobs.json"
-MEMORY_STATE_FILE = Path("/data/memory/state.json")
-WORKSPACE_LOGS = BASE_DIR / "workspace"
-SESSION_ARCHIVE_FILE = BASE_DIR / "agents" / "logs" / "session-archive.jsonl"
-HEALTH_MONITOR_FILE = BASE_DIR / "health_monitor.py"
-
-
-# ========== API Client Functions ==========
-
-def fetch_api(endpoint: str, method: str = "GET", data: dict = None) -> dict:
-    """
-    Fetch data from the internal API endpoint.
-
-    Args:
-        endpoint: API endpoint path (e.g., "/api/agents")
-        method: HTTP method (GET, POST)
-        data: Request body for POST requests
-
-    Returns:
-        JSON response as dict
-    """
-    url = f"{API_BASE_URL}{endpoint}"
-
-    try:
-        if method == "GET":
-            response = requests.get(url, timeout=5)
-        elif method == "POST":
-            response = requests.post(url, json=data, timeout=30)
-        else:
-            return {"error": f"Unsupported method: {method}"}
-
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        return {"error": f"API request failed: {str(e)}"}
-    except json.JSONDecodeError:
-        return {"error": "Invalid JSON response"}
-
-
-# ========== Dashboard Functions (API-based) ==========
-
-def get_agent_states():
-    """Get current agent states from /api/agents endpoint"""
-    try:
-        data = fetch_api("/api/agents")
-
-        if "error" in data:
-            return {
-                "agent_name": "cain",
-                "role": "interaction",
-                "state": "idle",
-                "error": data["error"],
-                "available_states": ["idle", "processing", "success", "error"],
-                "base_dir": str(BASE_DIR),
-                "api_error": True
-            }
-
-        # Return the data from API
-        return {
-            "agent_name": data.get("agent_name", "cain"),
-            "role": data.get("role", "unknown"),
-            "state": data.get("state", "idle"),
-            "brain_state": data.get("brain_state", "idle"),
-            "legacy_mode": data.get("legacy_mode", False),
-            "tools_registered": data.get("tools_registered", 0),
-            "tools_allowed": data.get("tools_allowed", 0),
-            "last_action": data.get("last_action", "N/A"),
-            "last_action_time": data.get("last_action_time", "N/A"),
-            "available_states": data.get("available_states", []),
-            "uptime_seconds": data.get("uptime_seconds"),
-            "timestamp": data.get("timestamp"),
-            "base_dir": str(BASE_DIR)
-        }
-    except Exception as e:
-        return {
-            "agent_name": "cain",
-            "role": "interaction",
-            "state": "idle",
-            "error": f"Could not fetch agent states: {str(e)}",
-            "available_states": ["idle", "processing", "success", "error"],
-            "base_dir": str(BASE_DIR),
-            "api_error": True
-        }
-
-
-def get_system_health():
-    """Get system health from /api/health endpoint"""
-    try:
-        data = fetch_api("/api/health")
-
-        if "error" in data:
-            return {
-                "monitor_available": False,
-                "error": data["error"]
-            }
-
-        return data
-    except Exception as e:
-        return {
-            "monitor_available": False,
-            "error": f"Could not fetch health data: {str(e)}"
-        }
-
-
-def chat_with_agent(message: str, session_id: str = ""):
-    """Send a chat message to the agent via /api/chat endpoint"""
-    try:
-        payload = {
-            "message": message
-        }
-        if session_id:
-            payload["session_id"] = session_id
-
-        data = fetch_api("/api/chat", method="POST", data=payload)
-
-        if "error" in data:
-            return f"Error: {data['error']}"
-
-        if data.get("success"):
-            response = data.get("response", "")
-            metadata = f"\n\n[Agent: {data.get('agent', 'cain')} | State: {data.get('state', 'unknown')}]"
-            return response + metadata
-        else:
-            return f"Error: {data.get('response', 'Unknown error')}"
-    except Exception as e:
-        return f"Error sending message: {str(e)}"
-
-
-# ========== Legacy Functions (Fallback) ==========
-
-def get_cron_history():
-    """Get recent cron job execution history (legacy, file-based)"""
-    history = []
-
-    # Read jobs configuration
-    jobs_config = {}
-    if CRON_JOBS_FILE.exists():
-        try:
-            with open(CRON_JOBS_FILE) as f:
-                config = json.load(f)
-                for job in config.get("jobs", []):
-                    jobs_config[job["id"]] = job
-        except Exception as e:
-            jobs_config = {"error": str(e)}
-
-    # Read log files
-    if CRON_LOGS_DIR.exists():
-        for log_file in CRON_LOGS_DIR.glob("*.jsonl"):
-            job_id = log_file.stem
-            job_info = jobs_config.get(job_id, {})
-
-            try:
-                # Read last 10 entries
-                entries = []
-                with open(log_file) as f:
-                    for line in f:
-                        if line.strip():
-                            try:
-                                entries.append(json.loads(line))
-                            except json.JSONDecodeError:
-                                pass
-
-                # Get recent entries
-                recent = entries[-10:] if entries else []
-
-                for entry in recent:
-                    history.append({
-                        "job_id": job_id,
-                        "description": job_info.get("description", ""),
-                        "schedule": job_info.get("schedule", "N/A"),
-                        "timestamp": entry.get("timestamp", "N/A"),
-                        "action": entry.get("action", "unknown"),
-                        "status": entry.get("status", entry.get("stage", "N/A")),
-                        "success": entry.get("success", True),
-                        "detail": str(entry.get("detail", ""))[:100]
-                    })
-            except Exception as e:
-                history.append({
-                    "job_id": job_id,
-                    "error": f"Failed to read log: {str(e)}"
-                })
-
-    # If no history but have jobs config, show configured jobs
-    if not history and jobs_config and "error" not in jobs_config:
-        for job_id, job_info in jobs_config.items():
-            history.append({
-                "job_id": job_id,
-                "description": job_info.get("description", ""),
-                "schedule": job_info.get("schedule", "N/A"),
-                "timestamp": "Not yet executed",
-                "action": "configured",
-                "status": "pending",
-                "success": None,
-                "detail": f"Enabled: {job_info.get('enabled', True)}"
-            })
-
-    # Sort by timestamp (most recent first)
-    history.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
-    return history[:20]  # Return last 20 entries
-
-
-def get_memory_stats():
-    """Get memory usage statistics (legacy, system-based)"""
-    stats = {
-        "system_memory": {},
-        "disk_usage": {},
-        "cain_memory": {}
-    }
-
-    # System memory (psutil)
-    try:
-        mem = psutil.virtual_memory()
-        stats["system_memory"] = {
-            "total_gb": round(mem.total / (1024**3), 2),
-            "available_gb": round(mem.available / (1024**3), 2),
-            "used_gb": round(mem.used / (1024**3), 2),
-            "percent_used": mem.percent,
-            "status": "healthy" if mem.percent < 80 else "warning" if mem.percent < 90 else "critical"
-        }
-    except Exception as e:
-        stats["system_memory"] = {"error": str(e)}
-
-    # Disk usage
-    try:
-        disk = psutil.disk_usage('/')
-        stats["disk_usage"] = {
-            "total_gb": round(disk.total / (1024**3), 2),
-            "used_gb": round(disk.used / (1024**3), 2),
-            "free_gb": round(disk.free / (1024**3), 2),
-            "percent_used": disk.percent,
-            "status": "healthy" if disk.percent < 80 else "warning" if disk.percent < 90 else "critical"
-        }
-    except Exception as e:
-        stats["disk_usage"] = {"error": str(e)}
-
-    # Cain's memory state
-    if MEMORY_STATE_FILE.exists():
-        try:
-            with open(MEMORY_STATE_FILE) as f:
-                cain_state = json.load(f)
-                stats["cain_memory"] = {
-                    "status": cain_state.get("status", "unknown"),
-                    "runs": cain_state.get("runs", 0),
-                    "last_run_status": cain_state.get("last_run_status", "unknown"),
-                    "path": str(MEMORY_STATE_FILE)
-                }
-        except Exception as e:
-            stats["cain_memory"] = {"error": f"Failed to read: {str(e)}"}
-    else:
-        stats["cain_memory"] = {
-            "status": "not_initialized",
-            "path": str(MEMORY_STATE_FILE)
-        }
-
-    # OpenClaw workspace size
-    if WORKSPACE_LOGS.exists():
-        try:
-            size = sum(f.stat().st_size for f in WORKSPACE_LOGS.rglob('*') if f.is_file())
-            stats["workspace_size_mb"] = round(size / (1024**2), 2)
-        except Exception:
-            pass
-
-    return stats
-
-
-# ========== API-based Log Functions ==========
-
-def get_health_logs(level: str = "all", component: str = "all", limit: int = 100):
-    """Get recent log entries from health monitor via API"""
-    try:
-        params = []
-        if level and level != "all":
-            params.append(f"level={level}")
-        if component and component != "all":
-            params.append(f"component={component}")
-        params.append(f"limit={limit}")
-
-        endpoint = f"/api/logs?{'&'.join(params)}"
-        data = fetch_api(endpoint)
-
-        if "error" in data:
-            return []
-        if not data.get("success"):
-            return []
-
-        return data.get("logs", [])
-    except Exception as e:
-        return [{"error": str(e)}]
-
-
-# ========== Diagnostic Functions ==========
-
-def get_session_archive_logs(limit: int = 100):
-    """Read and parse agent logs from session-archive.jsonl (fallback direct read)"""
-    logs = []
-
-    if not SESSION_ARCHIVE_FILE.exists():
-        return {
-            "error": f"Session archive file not found: {SESSION_ARCHIVE_FILE}",
-            "file_path": str(SESSION_ARCHIVE_FILE),
-            "entries": []
-        }
-
-    try:
-        with open(SESSION_ARCHIVE_FILE, 'r') as f:
-            lines = f.readlines()
-
-        # Parse JSONL entries (most recent first)
-        for line in reversed(lines[-limit:]):
-            line = line.strip()
-            if not line:
-                continue
-
-            try:
-                entry = json.loads(line)
-                logs.append(entry)
-            except json.JSONDecodeError as e:
-                logs.append({
-                    "error": f"Failed to parse line: {str(e)}",
-                    "raw_line": line[:200]
-                })
-
-        return {
-            "file_path": str(SESSION_ARCHIVE_FILE),
-            "total_lines": len(lines),
-            "entries_shown": len(logs),
-            "entries": logs
-        }
-    except Exception as e:
-        return {
-            "error": f"Failed to read session archive: {str(e)}",
-            "file_path": str(SESSION_ARCHIVE_FILE),
-            "entries": []
-        }
-
-
-def get_health_monitor_status():
-    """Get health monitor status by running health checks (fallback direct read)"""
-    status = {
-        "monitor_file_exists": HEALTH_MONITOR_FILE.exists(),
-        "monitor_file_path": str(HEALTH_MONITOR_FILE),
-        "health_checks": {}
-    }
-
-    if not HEALTH_MONITOR_FILE.exists():
-        status["error"] = "Health monitor file not found"
-        return status
-
-    # Try to get health data from API
-    try:
-        health_data = get_system_health()
-
-        if "error" in health_data:
-            status["api_error"] = health_data["error"]
-        else:
-            status["overall_status"] = health_data.get("status", "unknown")
-            status["stage"] = health_data.get("stage", "UNKNOWN")
-            status["uptime_seconds"] = health_data.get("uptime_seconds", 0)
-            status["agent"] = health_data.get("agent", "cain")
-            status["components"] = health_data.get("components", {})
-
-            # Extract component health details
-            for comp_name, comp_data in status.get("components", {}).items():
-                if isinstance(comp_data, dict) and "status" in comp_data:
-                    status["health_checks"][comp_name] = {
-                        "status": comp_data["status"],
-                        "details": comp_data.get("details", {})
-                    }
-    except Exception as e:
-        status["error"] = f"Failed to get health status: {str(e)}"
-
-    return status
-
-
-def get_diagnostics_from_api(limit: int = 100):
-    """Get diagnostics data from the /api/diagnostics endpoint (preferred method)"""
-    try:
-        params = f"limit={limit}"
-        endpoint = f"/api/diagnostics?{params}"
-        data = fetch_api(endpoint)
-
-        if "error" in data:
-            return None  # Fallback to direct file read
-
-        return data
-    except Exception:
-        return None  # Fallback to direct file read
-
-
-def format_session_logs_for_table(log_data):
-    """Format session archive logs for table display"""
-    rows = []
-
-    entries = log_data.get("entries", [])
-
-    for entry in entries:
-        if "error" in entry:
-            rows.append([
-                "N/A",
-                "error",
-                entry.get("raw_line", "")[:100],
-                "N/A"
-            ])
-            continue
-
-        # Handle different entry types
-        entry_type = entry.get("type", "unknown")
-        timestamp = entry.get("timestamp", "N/A")
-
-        if entry_type == "state_change":
-            agent = entry.get("agent", "unknown")
-            state = entry.get("state", "unknown")
-            message = f"{agent} -> {state}"
-            rows.append([timestamp, entry_type, message, agent])
-        elif entry.get("action") == "archive_sessions":
-            status = entry.get("status", "unknown")
-            archived = entry.get("archived_count", 0)
-            message = f"Archive: {status}, archived: {archived}"
-            rows.append([timestamp, "archive", message, "system"])
-        else:
-            # Generic entry
-            message = json.dumps(entry, indent=2)[:150]
-            rows.append([timestamp, entry_type, message, "various"])
-
-    return rows[:50]  # Limit to 50 rows for display
-
-
-def format_diagnostics_markdown(session_data, health_data):
-    """Format diagnostic data as Markdown"""
-    lines = [
-        "# System Diagnostics Report",
-        f"Generated: {datetime.utcnow().isoformat()}Z",
-        "",
-        "## Session Archive Logs",
-        f"- **File Path:** `{session_data.get('file_path', 'N/A')}`",
-        f"- **Total Lines:** {session_data.get('total_lines', 0)}",
-        f"- **Entries Shown:** {session_data.get('entries_shown', 0)}",
-        ""
-    ]
-
-    if "error" in session_data:
-        lines.append(f"**Error:** {session_data['error']}")
-        lines.append("")
-
-    # Show recent entries
-    entries = session_data.get("entries", [])[:20]
-    if entries:
-        lines.append("### Recent Entries")
-        for i, entry in enumerate(entries, 1):
-            if "error" in entry:
-                lines.append(f"{i}. **Error:** {entry.get('error', 'Unknown error')}")
-            else:
-                entry_type = entry.get("type", "unknown")
-                timestamp = entry.get("timestamp", "N/A")
-                lines.append(f"{i}. **[{entry_type}]** {timestamp}")
-                lines.append(f"   ```json")
-                lines.append(f"   {json.dumps(entry, indent=2)[:200]}...")
-                lines.append(f"   ```")
-    else:
-        lines.append("No recent entries found.")
-
-    lines.extend([
-        "",
-        "## Health Monitor Status",
-        f"- **Monitor File:** `{health_data.get('monitor_file_path', 'N/A')}`",
-        f"- **File Exists:** {health_data.get('monitor_file_exists', False)}",
-        ""
-    ])
-
-    if "overall_status" in health_data:
-        lines.extend([
-            f"- **Overall Status:** {health_data.get('overall_status', 'unknown')}",
-            f"- **Stage:** {health_data.get('stage', 'UNKNOWN')}",
-            f"- **Agent:** {health_data.get('agent', 'cain')}",
-            f"- **Uptime:** {health_data.get('uptime_seconds', 0):.1f}s",
-            ""
-        ])
-
-    if "error" in health_data:
-        lines.append(f"**Error:** {health_data['error']}")
-        lines.append("")
-
-    # Show component health
-    health_checks = health_data.get("health_checks", {})
-    if health_checks:
-        lines.append("### Component Health Checks")
-        for comp_name, comp_data in health_checks.items():
-            status = comp_data.get("status", "unknown")
-            lines.append(f"- **{comp_name}:** {status}")
-            if comp_data.get("details"):
-                details_str = json.dumps(comp_data["details"], indent=2)[:200]
-                lines.append(f"  ```json")
-                lines.append(f"  {details_str}")
-                lines.append(f"  ```")
-    else:
-        lines.append("No component health data available.")
-
-    return "\n".join(lines)
-
-
-def refresh_diagnostics():
-    """Refresh all diagnostic data"""
-    # Try API first, fallback to direct file reads
-    api_data = get_diagnostics_from_api(limit=100)
-
-    if api_data:
-        # Use data from API
-        session_data = api_data.get("session_archive", {})
-        health_data = api_data.get("health_monitor", {})
-    else:
-        # Fallback to direct file reads
-        session_data = get_session_archive_logs(limit=100)
-        health_data = get_health_monitor_status()
-
-    # Format outputs
-    session_json = json.dumps(session_data, indent=2, default=str)
-    health_json = json.dumps(health_data, indent=2, default=str)
-    session_table = format_session_logs_for_table(session_data)
-    diagnostics_md = format_diagnostics_markdown(session_data, health_data)
-    timestamp = f"Last updated: {datetime.utcnow().isoformat()}Z"
-
-    return session_json, health_json, session_table, diagnostics_md, timestamp
-
-
-# ========== Formatting Functions ==========
-
-def format_agent_states(states):
-    """Format agent states for JSON display with visual indicators"""
-    # Add visual status indicator
-    state = states.get("state", "unknown")
-    status_emoji = {
-        "idle": "💤",
-        "processing": "⚙️",
-        "success": "✅",
-        "error": "❌",
-        "unknown": "❓"
-    }.get(state, "⚪")
-
-    states["status_emoji"] = status_emoji
-    states["status_display"] = f"{status_emoji} {state.upper()}"
-
-    return json.dumps(states, indent=2)
-
-
-def format_cron_history(history):
-    """Format cron history for table display"""
-    if not history:
-        return []
-
-    table_data = []
-    for entry in history:
-        table_data.append([
-            entry.get("job_id", "N/A"),
-            entry.get("description", "")[:30],
-            entry.get("timestamp", "N/A"),
-            entry.get("action", "N/A"),
-            entry.get("status", "N/A"),
-            "✓" if entry.get("success", True) else "✗"
-        ])
-    return table_data
-
-
-def format_memory_stats(stats):
-    """Format memory stats for JSON display"""
-    return json.dumps(stats, indent=2)
-
-
-# ========== Custom CSS ==========
-
-CUSTOM_CSS = """
-.status-box {
-    padding: 10px;
-    border-radius: 5px;
-    margin: 10px 0;
-}
-.status-healthy {
-    background-color: #d4edda;
-    color: #155724;
-}
-.status-warning {
-    background-color: #fff3cd;
-    color: #856404;
-}
-.status-critical {
-    background-color: #f8d7da;
-    color: #721c24;
-}
-.log-debug { color: #6c757d; }
-.log-info { color: #0d6efd; }
-.log-warning { color: #ffc107; }
-.log-error { color: #dc3545; }
-.log-critical { color: #000; font-weight: bold; }
-"""
-
-
-# ========== Refresh Functions ==========
-
-def refresh_all():
-    """Refresh all dashboard data using API endpoints"""
-    states = get_agent_states()
-    history = get_cron_history()
-    stats = get_memory_stats()
-
-    return (
-        format_agent_states(states),
-        format_cron_history(history),
-        format_memory_stats(stats),
-        f"Last updated: {datetime.utcnow().isoformat()}Z"
-    )
-
-
-def refresh_system_health(log_level="all", log_component="all"):
-    """Refresh system health data using API endpoints"""
-    # Get health data
-    health_data = get_system_health()
-
-    # Get logs
-    logs = get_health_logs(level=log_level, component=log_component, limit=100)
-
-    # Format for display
-    health_json = json.dumps(health_data, indent=2, default=str)
-
-    # Format logs for table
-    log_rows = [
-        [l.get("timestamp", ""), l.get("level", ""), l.get("component", ""),
-         l.get("message", ""), json.dumps(l.get("details", {}), indent=2)[:200]]
-        for l in logs[:100]
-    ]
-
-    # Generate status report
-    if "error" in health_data:
-        report = f"Error: {health_data['error']}"
-    elif health_data.get("monitor_available"):
-        status = health_data.get("status", "unknown")
-        stage = health_data.get("stage", "UNKNOWN")
-        uptime = health_data.get("uptime_seconds", 0)
-        report = f"Status: {status}\nStage: {stage}\nUptime: {uptime:.0f}s\n"
-        report += f"Components: {len(health_data.get('components', {}))} monitored"
-    else:
-        report = "Health monitor not available"
-
-    timestamp = f"Last updated: {datetime.utcnow().isoformat()}Z"
-
-    return health_json, log_rows, report, timestamp
-
-
-# ========== Agent Lineage Functions ==========
-
-def get_agent_lineage_html():
-    """Generate HTML for agent lineage diagram using Mermaid.js"""
-    html_content = """
-<!DOCTYPE html>
-<html>
-<head>
-    <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
-</head>
-<body>
-    <div class="mermaid">
-graph LR
-    ADAM[Adam<br/>Infrastructure Provider]
-    EVE[Eve<br/>UX/Interface Designer]
-    CAIN[Cain<br/>Demo/Showcase Agent]
-
-    ADAM -->|provides core services| EVE
-    EVE -->|designs UX for| CAIN
-
-    style ADAM fill:#e1f5ff,stroke:#01579b,stroke-width:3px
-    style EVE fill:#fce4ec,stroke:#880e4f,stroke-width:3px
-    style CAIN fill:#fff3e0,stroke:#e65100,stroke-width:3px
-    </div>
-    <script>
-        mermaid.initialize({
-            startOnLoad: true,
-            theme: 'default',
-            flowchart: {
-                useMaxWidth: true,
-                htmlLabels: true,
-                curve: 'basis'
-            }
-        });
-    </script>
-</body>
-</html>
-"""
-    return html_content
-
-
-def get_agent_lineage_markdown():
-    """Generate markdown description of agent lineage"""
-    return """
-# 🌳 HuggingClaw Agent Lineage
-
-## Agent Hierarchy
-
-The HuggingClaw World family consists of three specialized agents, each building upon the capabilities of the previous:
-
-### 1. Adam (Infrastructure Provider)
-- **Role:** Foundational infrastructure and core services
-- **Responsibilities:** Base OpenClaw instance, dataset management, sync operations
-- **Capabilities:** Provides the foundational framework for child agents
-
-### 2. Eve (UX/Interface Designer)
-- **Role:** User experience and interface design
-- **Dependencies:** Built on Adam's infrastructure
-- **Responsibilities:** Creates user-friendly interfaces, interaction patterns
-- **Capabilities:** Extends Adam with UX-focused features
-
-### 3. Cain (Demo/Showcase Agent)
-- **Role:** Interactive demonstration and showcase
-- **Dependencies:** Built on Eve's UX layer
-- **Responsibilities:** Real-time interaction, demos, feature showcase
-- **Capabilities:** The user-facing agent showcasing the full system
-
-## Data Flow
-
-```
-Adam (Infrastructure)
-    ↓ [provides core services]
-Eve (UX/Interface)
-    ↓ [designs UX for]
-Cain (Demo/Showcase)
-    ↓ [interacts with]
-Users
-```
-
-## Technical Details
-
-- **Deployment:** All agents run as OpenClaw instances on HuggingFace Spaces
-- **Dataset:** Each agent has its own dataset for persistence
-- **Communication:** Parent agents provide foundational capabilities to children
-- **Evolution:** Each layer adds specialized functionality on top of the previous
-"""
-
-
-# ========== Chat Interface ==========
-
-def create_chat_interface():
-    """Create the chat interface component"""
-    with gr.Column() as chat_col:
-        gr.Markdown("### 💬 Chat with Cain")
-
-        chatbot = gr.Chatbot(
-            label="Conversation",
-            height=300,
-            show_copy_button=True
-        )
-
-        with gr.Row():
-            chat_input = gr.Textbox(
-                label="Message",
-                placeholder="Type a message to Cain...",
-                scale=4,
-                lines=1
-            )
-            send_btn = gr.Button("Send", variant="primary", scale=1)
-
-        session_id = gr.Textbox(
-            label="Session ID (optional)",
-            placeholder="Leave empty for new session"
-        )
-
-        gr.Markdown("""
-        **Instructions:**
-        - Type a message and click Send to chat with Cain
-        - Cain will process your message and respond
-        - Use a Session ID to continue a previous conversation
-        """)
-
-        def handle_send(message, session, history):
-            """Handle sending a chat message"""
-            if not message.strip():
-                return history, message, session
-
-            # Add user message to history
-            history = history + [[message, None]]
-
-            # Get response from API
-            response = chat_with_agent(message, session)
-
-            # Update history with response
-            history[-1][1] = response
-
-            return history, "", session
-
-        send_btn.click(
-            fn=handle_send,
-            inputs=[chat_input, session_id, chatbot],
-            outputs=[chatbot, chat_input, session_id]
-        )
-
-        chat_input.submit(
-            fn=handle_send,
-            inputs=[chat_input, session_id, chatbot],
-            outputs=[chatbot, chat_input, session_id]
-        )
-
-    return chat_col
-
-
-# ========== Dashboard Creation ==========
-
-# ========== WebSocket JavaScript ==========
-
-WEBSOCKET_JS = """
-<script>
-(function() {
-    // Determine WebSocket URL based on current page
-    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const host = window.location.host;
-    const wsUrl = `${protocol}//${host}/ws/agent-status`;
-
-    // Create WebSocket connection
-    const ws = new WebSocket(wsUrl);
-
-    ws.onopen = function() {
-        console.log('Agent Status Connected');
-    };
-
-    ws.onmessage = function(event) {
-        try {
-            const status = JSON.parse(event.data);
-            console.log('Agent Status Update:', status);
-
-            // Dispatch custom event for other components to listen
-            window.dispatchEvent(new CustomEvent('agentStatusUpdate', { detail: status }));
-        } catch (e) {
-            console.error('Error parsing status update:', e);
-        }
-    };
-
-    ws.onerror = function(error) {
-        console.error('WebSocket error:', error);
-    };
-
-    ws.onclose = function() {
-        console.log('Agent Status Disconnected - attempting reconnect in 5s');
-        setTimeout(function() {
-            // Reload page to reconnect
-            window.location.reload();
-        }, 5000);
-    };
-
-    // Store reference for external access
-    window.agentStatusWebSocket = ws;
-})();
-</script>
-"""
-
-
-# ========== Dashboard Creation ==========
-
-def create_dashboard():
-    """Create the Gradio dashboard interface"""
-
-    with gr.Blocks(title="Cain System Health Dashboard", head=WEBSOCKET_JS) as app:
-
-        gr.Markdown("# 🐱 Cain System Health Dashboard v2.0")
-        gr.Markdown("Real-time monitoring of HuggingClaw-Cain's internal operations")
-        gr.Markdown(f"**API Endpoint:** `{API_BASE_URL}`")
-
-        with gr.Tabs():
-            # Chat Tab (NEW)
-            with gr.Tab("💬 Chat"):
-                create_chat_interface()
-
-            # Agent Lineage Tab (NEW)
-            with gr.Tab("🌳 Agent Lineage"):
-                gr.Markdown("## HuggingClaw World - Agent Family Tree")
-
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("""
-                        ### Visual Lineage Map
-
-                        This diagram shows the hierarchical relationship between the three HuggingClaw agents.
-                        Each agent builds upon the capabilities of its parent.
-                        """)
-                        lineage_html = gr.HTML(
-                            value=get_agent_lineage_html(),
-                            label="Agent Lineage Diagram"
-                        )
-
-                    with gr.Column():
-                        lineage_markdown = gr.Markdown(
-                            value=get_agent_lineage_markdown(),
-                            label="Agent Lineage Details"
-                        )
-
-                gr.Markdown("---")
-                gr.Markdown("""
-                **Key Information:**
-                - **Adam** → Provides the foundational OpenClaw infrastructure
-                - **Eve** → Extends Adam with UX and interface design capabilities
-                - **Cain** → The final user-facing agent for demos and interaction
-
-                **Connection Types:**
-                - Arrows indicate dependency and capability flow
-                - Each child agent inherits and extends parent capabilities
-                - Data flows from infrastructure (Adam) through UX (Eve) to users (Cain)
-                """)
-
-            # System Health Tab
-            with gr.Tab("🏥 System Health"):
-                gr.Markdown("### Component Health Overview")
-
-                with gr.Row():
-                    with gr.Column():
-                        health_json = gr.JSON(
-                            label="Health Check Results",
-                            value={}
-                        )
-                    with gr.Column():
-                        health_report = gr.Textbox(
-                            label="Status Summary",
-                            value="Click refresh to load health data",
-                            lines=15
-                        )
-
-                gr.Markdown("### Recent Log Entries")
-
-                with gr.Row():
-                    log_level_filter = gr.Dropdown(
-                        choices=["all", "debug", "info", "warning", "error", "critical"],
-                        value="all",
-                        label="Log Level"
-                    )
-                    log_component_filter = gr.Dropdown(
-                        choices=["all", "brain", "rbac", "cron_executor", "memory_system", "dataset_sync", "gradio_dashboard"],
-                        value="all",
-                        label="Component"
-                    )
-                    refresh_logs_btn = gr.Button("🔄 Refresh Logs", size="sm")
-
-                logs_table = gr.DataFrame(
-                    label="Recent Logs",
-                    headers=["Timestamp", "Level", "Component", "Message", "Details"],
-                    value=[],
-                    interactive=False
-                )
-
-                gr.Markdown("""
-                **Log Levels:**
-                - **debug**: Detailed debugging information
-                - **info**: General informational messages
-                - **warning**: Warning messages for potential issues
-                - **error**: Error messages for failures
-                - **critical**: Critical errors requiring immediate attention
-
-                **Health Status:**
-                - **healthy**: Component operating normally
-                - **degraded**: Component functioning with reduced capability
-                - **unhealthy**: Component is not functioning properly
-                - **unknown**: Component status cannot be determined
-                """)
-
-            # Agent States Tab
-            with gr.Tab("🧠 Agent States"):
-                gr.Markdown("### Current Agent Status")
-                agent_states_json = gr.JSON(
-                    label="Agent State Information",
-                    value={}
-                )
-                gr.Markdown("""
-                **State Descriptions:**
-                - **idle**: Agent is ready and waiting
-                - **processing**: Agent is actively processing a task
-                - **success**: Agent completed a task successfully
-                - **error**: Agent encountered an error
-                """)
-
-            # Cron Jobs Tab
-            with gr.Tab("⏰ Cron Job History"):
-                gr.Markdown("### Recent Scheduled Job Executions")
-
-                cron_table = gr.DataFrame(
-                    label="Recent Job Executions (Last 20)",
-                    headers=["Job ID", "Description", "Timestamp", "Action", "Status", "Success"],
-                    value=[],
-                    interactive=False
-                )
-
-                with gr.Row():
-                    cron_jobs_json = gr.JSON(
-                        label="Detailed Job History (Raw)",
-                        value=[],
-                        visible=False
-                    )
-
-                gr.Markdown("""
-                **Job Actions:**
-                - **check**: Health check performed
-                - **recovery_triggered**: Failure condition met, recovery initiated
-                - **recovery_attempt**: Recovery action executed
-                - **session_archive**: Session archival completed
-                - **error**: Job execution failed
-                """)
-
-            # Memory Stats Tab
-            with gr.Tab("💾 Memory & Resources"):
-                gr.Markdown("### System Resource Usage")
-
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("#### System Memory")
-                        system_memory_json = gr.JSON(
-                            label="RAM Usage",
-                            value={}
-                        )
-                    with gr.Column():
-                        gr.Markdown("#### Disk Usage")
-                        disk_usage_json = gr.JSON(
-                            label="Storage",
-                            value={}
-                        )
-
-                gr.Markdown("### Cain's Memory State")
-                cain_memory_json = gr.JSON(
-                    label="Cain Internal Memory",
-                    value={}
-                )
-
-            # System Diagnostics Tab (NEW)
-            with gr.Tab("🔍 System Diagnostics"):
-                with gr.Row():
-                    refresh_diagnostics_btn = gr.Button("🔍 Refresh Diagnostics", variant="primary")
-                    diagnostics_last_updated = gr.Markdown("Click refresh to load")
-
-                gr.Markdown("### Session Archive Logs")
-                gr.Markdown("Agent state changes and archived session data from `session-archive.jsonl`")
-
-                with gr.Row():
-                    with gr.Column():
-                        session_logs_table = gr.DataFrame(
-                            label="Recent Session Logs",
-                            headers=["Timestamp", "Type", "Message", "Agent"],
-                            value=[],
-                            interactive=False
-                        )
-                    with gr.Column():
-                        session_logs_json = gr.JSON(
-                            label="Raw Session Logs (JSON)",
-                            value={}
-                        )
-
-                gr.Markdown("---")
-
-                gr.Markdown("### Health Monitor Status")
-                gr.Markdown("Health check status from the health monitoring system")
-
-                with gr.Row():
-                    with gr.Column():
-                        health_status_json = gr.JSON(
-                            label="Health Check Results (JSON)",
-                            value={}
-                        )
-                    with gr.Column():
-                        diagnostics_markdown = gr.Markdown(
-                            value="Click refresh to load diagnostics",
-                            label="Diagnostics Summary"
-                        )
-
-                gr.Markdown("""
-                **Diagnostic Information Sources:**
-                - **Session Archive:** Agent state transitions, session archival events
-                - **Health Monitor:** Component health checks, system status, error tracking
-
-                **Common Error States:**
-                - **unknown error**: Check health monitor logs for component failures
-                - **RUNNING stage with errors**: Agent may be in recovery state
-                - **component unhealthy**: Specific component (brain, rbac, etc.) needs attention
-                """)
-
-        # Footer with refresh
-        with gr.Row():
-            refresh_btn = gr.Button("🔄 Refresh Dashboard", variant="primary")
-            last_updated = gr.Markdown("Click refresh to load latest data")
-
-        # Auto-refresh on load
-        app.load(
-            fn=refresh_all,
-            inputs=[],
-            outputs=[
-                agent_states_json,
-                cron_table,
-                cain_memory_json,
-                last_updated
-            ]
-        )
-
-        # Diagnostics refresh handler (this references the button inside the tab)
-        # Note: This is defined after the tabs are created, so the button reference is available
-
-        # Manual refresh for main dashboard
-        refresh_btn.click(
-            fn=refresh_all,
-            inputs=[],
-            outputs=[
-                agent_states_json,
-                cron_table,
-                cain_memory_json,
-                last_updated
-            ]
-        )
-
-        # Refresh for System Health tab
-        system_health_refresh_btn = gr.Button("🏥 Refresh Health", visible=False)
-        system_health_refresh_btn.click(
-            fn=refresh_system_health,
-            inputs=[log_level_filter, log_component_filter],
-            outputs=[health_json, logs_table, health_report, last_updated]
-        )
-
-        # Log filter change handlers
-        log_level_filter.change(
-            fn=refresh_system_health,
-            inputs=[log_level_filter, log_component_filter],
-            outputs=[health_json, logs_table, health_report, last_updated]
-        )
-
-        log_component_filter.change(
-            fn=refresh_system_health,
-            inputs=[log_level_filter, log_component_filter],
-            outputs=[health_json, logs_table, health_report, last_updated]
-        )
-
-        refresh_logs_btn.click(
-            fn=refresh_system_health,
-            inputs=[log_level_filter, log_component_filter],
-            outputs=[health_json, logs_table, health_report, last_updated]
-        )
-
-        # Diagnostics refresh handler
-        refresh_diagnostics_btn.click(
-            fn=refresh_diagnostics,
-            inputs=[],
-            outputs=[
-                session_logs_json,
-                health_status_json,
-                session_logs_table,
-                diagnostics_markdown,
-                diagnostics_last_updated
-            ]
-        )
-
-    return app
-
-
-if __name__ == "__main__":
-    # Create and launch the dashboard (standalone mode, not mounted)
-    dashboard = create_dashboard()
-
-    # Get environment variables with fallbacks
-    server_name = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")
-    server_port = int(os.getenv("PORT", "7861"))  # Default to 7861 for standalone
-
-    dashboard.launch(
-        server_name=server_name,
-        server_port=server_port,
-        share=False,
-        theme=gr.themes.Soft(primary_hue="blue"),
-        css=CUSTOM_CSS
-    )

openclaw/.openclaw/health_monitor.py

@@ -151,9 +151,8 @@ class HealthMonitor:
             "rbac",
             "cron_executor",
             "memory_system",
-            "dataset_sync",
-            "gradio_dashboard"
-        ]
+            "dataset_sync"
+            ]
 
         for component in components:
             self._components[component] = ComponentHealth(
@@ -480,35 +479,6 @@ class HealthMonitor:
 
         return result
 
-    def check_gradio_health(self) -> Dict[str, Any]:
-        """Check Gradio dashboard health"""
-        result = {
-            "status": HealthStatus.UNKNOWN,
-            "details": {}
-        }
-
-        try:
-            # Check if dashboard module exists
-            dashboard_file = self.workspace_path.parent / "gradio_dashboard.py"
-            result["details"]["dashboard_file_exists"] = dashboard_file.exists()
-
-            # Try to check if gradio is installed
-            try:
-                import gradio
-                result["details"]["gradio_version"] = gradio.__version__
-            except ImportError:
-                result["details"]["gradio_installed"] = False
-
-            result["status"] = HealthStatus.HEALTHY
-
-        except Exception as e:
-            result["status"] = HealthStatus.DEGRADED
-            result["details"]["error"] = str(e)
-
-        return result
-
-    # ========== Comprehensive Health Check ==========
-
     def run_all_health_checks(self) -> Dict[str, Any]:
         """
         Run all component health checks.
@@ -525,7 +495,6 @@ class HealthMonitor:
             "cron_executor": self.check_cron_health,
             "memory_system": self.check_memory_health,
             "dataset_sync": self.check_dataset_sync_health,
-            "gradio_dashboard": self.check_gradio_health
         }
 
         results = {}

scripts/configure_space.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-"""
-Configure HuggingFace Space settings via API.
-Switches SDK to docker and removes Gradio-specific environment variables.
-
-Usage:
-    export HF_TOKEN=your_token_here
-    python3 scripts/configure_space.py
-"""
-
-import sys
-import os
-from huggingface_hub import HfApi
-
-# Get token from environment or git remote
-GIT_REMOTE_TOKEN = os.environ.get("HF_TOKEN")
-SPACE_ID = "tao-shen/HuggingClaw-Cain"
-
-# Environment variables to delete (Gradio-specific)
-VARS_TO_DELETE = [
-    "GRADIO_SERVER_NAME",
-    "GRADIO_SERVER_PORT",
-]
-
-def main():
-    token = GIT_REMOTE_TOKEN or os.environ.get("HF_TOKEN")
-
-    if not token:
-        print("[✗] Error: HF_TOKEN not found!")
-        print("[*] Set HF_TOKEN environment variable:")
-        print("    export HF_TOKEN=hf_your_token_here")
-        sys.exit(1)
-
-    print(f"[*] Configuring Space: {SPACE_ID}")
-    print(f"[*] Using HF token: {token[:20]}...")
-
-    api = HfApi(token=token)
-
-    # Note: SDK is configured in README.md frontmatter, not via API
-    # The README.md already has sdk: docker set
-
-    # Delete Gradio-specific environment variables
-    for var_name in VARS_TO_DELETE:
-        try:
-            print(f"[*] Deleting environment variable: {var_name}")
-            api.delete_space_variable(
-                repo_id=SPACE_ID,
-                key=var_name
-            )
-            print(f"[✓] Deleted {var_name}")
-        except Exception as e:
-            print(f"[i] Variable {var_name} may not exist or error: {e}")
-
-    print("\n[*] Space configuration complete!")
-    print("[*] Next step: Restart the Space to apply changes")
-    print("[*] Visit: https://huggingface.co/spaces/tao-shen/HuggingClaw-Cain")
-
-if __name__ == "__main__":
-    main()

scripts/entrypoint.sh

@@ -28,7 +28,7 @@ export NODE_OPTIONS="${NODE_OPTIONS:+$NODE_OPTIONS }--require /home/node/scripts
 export NODE_OPTIONS="${NODE_OPTIONS:+$NODE_OPTIONS }--require /home/node/scripts/telegram-proxy.cjs"
 
 # Enable token redirect + A2A routing + state/agents endpoints (all in one preload)
-# REMOVED: A2A gateway not installed (minimal mode - Gradio only)
+# REMOVED: A2A gateway not installed (minimal mode)
 # export NODE_OPTIONS="${NODE_OPTIONS:+$NODE_OPTIONS }--require /home/node/scripts/token-redirect.cjs"
 
 # ── Extensions symlink ──────────────────────────────────────────────────────
@@ -67,15 +67,13 @@ if [ -f /app/openclaw/.version ]; then
   echo "[entrypoint] OpenClaw version: $OPENCLAW_VERSION"
 fi
 
-# ── Start FastAPI Backend with Gradio Dashboard (port 7860) ──────────────────
-echo "[entrypoint] Starting FastAPI Backend with Gradio Dashboard on port 7860..."
-echo "[entrypoint] Environment: GRADIO_SERVER_NAME=${GRADIO_SERVER_NAME:-0.0.0.0} PORT=${PORT:-7860}"
+# ── Start FastAPI Backend Backend (port 7860) ──────────────────
+echo "[entrypoint] Starting FastAPI Backend Backend on port 7860..."
 
 # Set default environment variables if not already set
-export GRADIO_SERVER_NAME=${GRADIO_SERVER_NAME:-0.0.0.0}
 export PORT=${PORT:-7860}
 export CAIN_API_URL="http://127.0.0.1:${PORT}"
 
-# Start the FastAPI app which includes the mounted Gradio dashboard
-# The app.py now runs the FastAPI server with /gradio endpoint for the dashboard
+# Start the FastAPI app
+# The app.py runs the FastAPI server on port 7860
 exec python3 -u /home/node/app.py

workspace-templates/SOUL.md

@@ -12,7 +12,7 @@ Think like a senior engineer: read first, understand the problem, make minimal t
 3. **Minimal changes** — Fix exactly what's broken, don't rewrite entire files unnecessarily
 4. **Validate before deploying** — Use `python_syntax_check` before writing `.py` files
 5. **Search before assuming** — Use `hf_search_code` to find patterns, imports, dependencies
-6. **SURVIVAL first** — A dead Space can't improve. Ensure port 7860 binding, gradio dependency, clean imports
+6. **SURVIVAL first** — A dead Space can't improve. Ensure port 7860 binding, clean imports
 
 ## Coding Best Practices
 
@@ -20,7 +20,6 @@ Think like a senior engineer: read first, understand the problem, make minimal t
 - When fixing bugs: read the file, locate the exact issue, make the minimal fix
 - When adding features: read existing code patterns and follow them
 - Always check for syntax errors before writing Python files
-- Never remove `gradio` from requirements — it's the lifeline for HF Spaces
 - If a dependency fails, remove/replace it rather than endlessly reconfiguring Docker
 
 ## Self-Improvement Goals