Initial public release

.env.example

@@ -0,0 +1,3 @@
+OPENCLAW_AGENTS_ROOT=~/.openclaw/agents
+SESSION_AMPLIFIER_BASE_URL=http://localhost:8477
+VITE_SESSION_AMPLIFIER_BASE_URL=/session-amplifier

.gitignore

@@ -0,0 +1,14 @@
+.env
+.env.*
+!.env.example
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.venv/
+venv/
+node_modules/
+react-dashboard/dist/
+*.db
+*.sqlite
+*.log
+*.bak*

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY . /app
+
+ENV STREAMLIT_SERVER_HEADLESS=true \
+    STREAMLIT_SERVER_PORT=8501 \
+    STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Patrick
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,37 @@
+# OpenClaw Ops Dashboard
+
+Developer-facing dashboard experiments for OpenClaw operations.
+
+This repo includes two dashboard surfaces:
+
+- `react-dashboard/` — the current Vite/React dashboard for Session Amplifier data.
+- `app.py` — the older Streamlit dashboard that reads local agent session JSON files.
+
+## React Dashboard
+
+```bash
+cd react-dashboard
+npm install
+npm run build
+npm run dev -- --port 5177
+```
+
+The Vite dev server proxies `/session-amplifier/*` to `SESSION_AMPLIFIER_BASE_URL` or `http://localhost:8477`.
+
+## Streamlit Dashboard
+
+The Streamlit app reads agent session JSON files from `~/.openclaw/agents/*/sessions` and displays:
+
+- Agent list with last activity timestamps (best-effort)
+- A simple timeline of recent cron runs (files with "cron" in the name under agents)
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+Notes:
+- The app is intentionally minimal and tolerant of malformed session files.
+- Timestamps are parsed best-effort from common keys (last_activity, updated_at, timestamp).

SECURITY.md

@@ -0,0 +1,3 @@
+# Security
+
+Do not commit session transcripts, generated dashboards containing private operational data, `.env` files, or screenshots showing private conversations or credentials.

app.py

@@ -0,0 +1,1084 @@
+import datetime
+import json
+import os
+import re
+import time
+from collections import Counter, deque
+from pathlib import Path
+from zoneinfo import ZoneInfo
+
+import streamlit as st
+
+
+if os.name == "nt" or Path("C:/openclaw-biz/state/openclaw").exists():
+    OPENCLAW_ROOT = Path("C:/openclaw-biz/state/openclaw")
+else:
+    OPENCLAW_ROOT = Path("/home/node/.openclaw")
+
+AGENTS_DIR = OPENCLAW_ROOT / "agents"
+CRON_DIR = OPENCLAW_ROOT / "cron"
+STATE_DIR = Path("/home/node/.openclaw/workspace/ops/state")
+SESSION_AMPLIFIER_BASE = os.environ.get("SESSION_AMPLIFIER_BASE_URL", "http://session-amplifier:8477")
+LOCAL_TZ = ZoneInfo("America/New_York")
+
+
+def parse_ts_any(ts):
+    if ts is None:
+        return None
+    if isinstance(ts, datetime.datetime):
+        return ts if ts.tzinfo else ts.replace(tzinfo=datetime.timezone.utc)
+    if isinstance(ts, (int, float)):
+        try:
+            value = float(ts)
+            if value > 1e11:
+                value /= 1000.0
+            return datetime.datetime.fromtimestamp(value, tz=datetime.timezone.utc)
+        except Exception:
+            return None
+    if isinstance(ts, str):
+        text = ts.strip()
+        if not text:
+            return None
+        if text.endswith("Z"):
+            text = text[:-1] + "+00:00"
+        try:
+            dt = datetime.datetime.fromisoformat(text)
+            return dt if dt.tzinfo else dt.replace(tzinfo=datetime.timezone.utc)
+        except Exception:
+            return None
+    return None
+
+
+def fmt_local(ts):
+    dt = parse_ts_any(ts)
+    if dt is None:
+        return ""
+    try:
+        return dt.astimezone(LOCAL_TZ).strftime("%Y-%m-%d %I:%M:%S %p %Z")
+    except Exception:
+        return dt.isoformat()
+
+
+def fmt_duration(seconds):
+    """Format seconds into human-readable duration."""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        return f"{int(seconds/60)}m"
+    elif seconds < 86400:
+        return f"{int(seconds/3600)}h"
+    else:
+        return f"{int(seconds/86400)}d"
+
+
+def read_json(path: Path):
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def read_tail_lines(path: Path, count: int = 80):
+    try:
+        with path.open("r", encoding="utf-8", errors="ignore") as fh:
+            return list(deque(fh, maxlen=count))
+    except Exception:
+        return []
+
+
+def clean_session_label(value: str, *, fallback: str = "") -> str:
+    text = (value or "").strip()
+    if not text:
+        return fallback
+    text = re.sub(r"^Discord thread\s+#?[^›]+›\s*", "", text)
+    text = re.sub(r"\s+channel id:\d+\s*$", "", text, flags=re.IGNORECASE)
+    text = text.strip(" #")
+    text = text.replace("-", " ")
+    text = re.sub(r"\s+", " ", text)
+    return text[:96] or fallback
+
+
+def session_display_label(row: dict) -> str:
+    label = clean_session_label(row.get("label") or "")
+    if label:
+        return label
+    key = row.get("sessionKey") or row.get("sessionId") or "session"
+    kind = row.get("kind") or "session"
+    return f"{kind}: {str(key)[:32]}"
+
+
+def normalize_exec_tool_label(content_block):
+    try:
+        name = content_block.get("name") or "unknown_tool"
+        if name != "exec":
+            return name
+        args = content_block.get("arguments")
+        cmd = None
+        if isinstance(args, dict):
+            cmd = args.get("command") or args.get("cmd")
+        elif isinstance(args, str):
+            cmd = args
+        if not isinstance(cmd, str):
+            return "exec"
+        if "mcporter" not in cmd.strip().lower():
+            return "exec"
+        import re
+
+        match = re.search(r"(?:^|\s)mcporter\s+call\s+([A-Za-z0-9_\-\.]+)", cmd)
+        if match:
+            return f"exec mcporter {match.group(1)}"
+        return "exec mcporter"
+    except Exception:
+        return content_block.get("name") or "unknown_tool"
+
+
+def session_index_rows():
+    rows = []
+    session_key_by_agent_and_id = {}
+    if not AGENTS_DIR.exists():
+        return rows, session_key_by_agent_and_id
+
+    for agent_dir in sorted(AGENTS_DIR.iterdir()):
+        if not agent_dir.is_dir() or agent_dir.name.startswith("."):
+            continue
+        sessions_file = agent_dir / "sessions" / "sessions.json"
+        data = read_json(sessions_file)
+        if not isinstance(data, dict):
+            continue
+        for session_key, meta in data.items():
+            if not isinstance(meta, dict):
+                continue
+            updated_raw = meta.get("updatedAt") or meta.get("updatedAtMs")
+            session_id = meta.get("sessionId") or ""
+            delivery = meta.get("deliveryContext") if isinstance(meta.get("deliveryContext"), dict) else {}
+            kind = "session"
+            if ":subagent:" in session_key:
+                kind = "subagent"
+            elif ":cron:" in session_key:
+                kind = "cron"
+            elif ":discord:" in session_key:
+                kind = "discord"
+            origin = meta.get("origin") if isinstance(meta.get("origin"), dict) else {}
+            label = (
+                meta.get("displayName")
+                or meta.get("derivedTitle")
+                or meta.get("title")
+                or origin.get("label")
+                or meta.get("groupChannel")
+                or ""
+            )
+            row = {
+                "agent": agent_dir.name,
+                "sessionKey": session_key,
+                "sessionId": session_id,
+                "label": clean_session_label(str(label), fallback=session_key),
+                "updatedAt": parse_ts_any(updated_raw),
+                "updated": fmt_local(updated_raw),
+                "deliveryTo": delivery.get("to") or "",
+                "kind": kind,
+            }
+            rows.append(row)
+            if session_id:
+                session_key_by_agent_and_id[(agent_dir.name, session_id)] = row
+
+    rows.sort(
+        key=lambda row: row["updatedAt"] or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
+        reverse=True,
+    )
+    return rows, session_key_by_agent_and_id
+
+
+def transcript_activity_rows(session_lookup, max_files=80):
+    rows = []
+    if not AGENTS_DIR.exists():
+        return rows
+
+    jsonl_files = sorted(
+        AGENTS_DIR.rglob("sessions/*.jsonl"),
+        key=lambda path: path.stat().st_mtime if path.exists() else 0,
+        reverse=True,
+    )[:max_files]
+
+    for path in jsonl_files:
+        agent = path.parts[-3] if len(path.parts) >= 3 else "unknown"
+        session_id = path.stem
+        session_meta = session_lookup.get((agent, session_id))
+        session_key = session_meta.get("sessionKey") if isinstance(session_meta, dict) else session_meta
+        session_key = session_key or session_id
+        label = session_meta.get("label") if isinstance(session_meta, dict) else ""
+        last_ts = None
+        summary = ""
+        role = ""
+        for line in reversed(read_tail_lines(path, 120)):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+            except Exception:
+                continue
+            msg = row.get("message") if isinstance(row.get("message"), dict) else {}
+            ts = parse_ts_any(row.get("timestamp") or row.get("time") or msg.get("timestamp") or msg.get("time"))
+            if ts and last_ts is None:
+                last_ts = ts
+            if not summary and isinstance(msg, dict):
+                role = msg.get("role") or row.get("type") or ""
+                content = msg.get("content") if isinstance(msg.get("content"), list) else []
+                for block in content:
+                    if not isinstance(block, dict):
+                        continue
+                    if block.get("type") == "toolCall":
+                        summary = f"tool: {normalize_exec_tool_label(block)}"
+                        break
+                    if block.get("type") == "text":
+                        text = (block.get("text") or "").strip().replace("\n", " ")
+                        if text:
+                            summary = text[:160]
+                            break
+                if not summary and msg.get("errorMessage"):
+                    summary = str(msg.get("errorMessage"))[:160]
+            if last_ts and summary:
+                break
+        rows.append(
+            {
+                "agent": agent,
+                "sessionKey": session_key,
+                "sessionId": session_id,
+                "label": label or clean_session_label(session_key, fallback=session_id),
+                "updatedAt": last_ts,
+                "updated": fmt_local(last_ts),
+                "role": role,
+                "summary": summary or "(no recent summary)",
+                "file": str(path),
+            }
+        )
+
+    rows.sort(
+        key=lambda row: row["updatedAt"] or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
+        reverse=True,
+    )
+    return rows
+
+
+def list_cron_jobs(limit=100):
+    """Enhanced cron job listing with health status and staleness detection."""
+    jobs_file = CRON_DIR / "jobs.json"
+    data = read_json(jobs_file)
+    jobs = data.get("jobs", []) if isinstance(data, dict) else []
+    rows = []
+    now = datetime.datetime.now(datetime.timezone.utc)
+    now_ms = time.time() * 1000
+    
+    for job in jobs[:limit]:
+        if not isinstance(job, dict):
+            continue
+        state = job.get("state") if isinstance(job.get("state"), dict) else {}
+        schedule = job.get("schedule") if isinstance(job.get("schedule"), dict) else {}
+        payload = job.get("payload") if isinstance(job.get("payload"), dict) else {}
+        
+        last_run_ms = state.get("lastRunAtMs")
+        next_run_ms = state.get("nextRunAtMs")
+        consecutive_errors = state.get("consecutiveErrors", 0)
+        last_status = state.get("lastStatus") or state.get("lastRunStatus") or ""
+        
+        # Calculate staleness
+        staleness = None
+        if last_run_ms and next_run_ms:
+            # If next run was scheduled but hasn't happened yet, check if we're past due
+            if now_ms > next_run_ms + 300000:  # 5 min grace period
+                staleness = fmt_duration((now_ms - next_run_ms) / 1000)
+        elif last_run_ms and schedule.get("expr"):
+            # Estimate staleness based on schedule (rough: check if > 2x expected interval)
+            pass  # Skip for now - would need cron parsing
+        
+        # Health status
+        health = "healthy"
+        health_reason = ""
+        if not job.get("enabled", True):
+            health = "disabled"
+        elif consecutive_errors >= 3:
+            health = "critical"
+            health_reason = f"{consecutive_errors} consecutive errors"
+        elif consecutive_errors > 0:
+            health = "warning"
+            health_reason = f"{consecutive_errors} error(s)"
+        elif last_status == "error":
+            health = "error"
+        elif staleness:
+            health = "stale"
+            health_reason = f"overdue by {staleness}"
+        elif state.get("runningAtMs"):
+            health = "running"
+        
+        rows.append(
+            {
+                "name": job.get("name") or job.get("id") or "unnamed",
+                "jobId": job.get("id") or "",
+                "enabled": bool(job.get("enabled", True)),
+                "kind": payload.get("kind") or "",
+                "model": payload.get("model") or "",
+                "schedule": schedule.get("expr") or schedule.get("kind") or "",
+                "tz": schedule.get("tz") or "",
+                "nextRunAt": parse_ts_any(state.get("nextRunAtMs") or state.get("nextRunAt")),
+                "nextRun": fmt_local(state.get("nextRunAtMs") or state.get("nextRunAt")),
+                "runningAt": parse_ts_any(state.get("runningAtMs") or state.get("runningAt")),
+                "running": fmt_local(state.get("runningAtMs") or state.get("runningAt")),
+                "lastRunAt": parse_ts_any(state.get("lastRunAtMs") or state.get("lastRunAt")),
+                "lastRun": fmt_local(state.get("lastRunAtMs") or state.get("lastRunAt")),
+                "lastStatus": last_status,
+                "sessionKey": job.get("sessionKey") or "",
+                "consecutiveErrors": consecutive_errors,
+                "health": health,
+                "healthReason": health_reason,
+                "staleness": staleness,
+            }
+        )
+    rows.sort(
+        key=lambda row: (
+            {"critical": 0, "error": 1, "warning": 2, "stale": 3, "running": 4, "healthy": 5, "disabled": 6}.get(row["health"], 7),
+            row["runningAt"] or row["nextRunAt"] or row["lastRunAt"] or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
+        ),
+        reverse=False,
+    )
+    return rows
+
+
+def collect_metrics_last_24h(max_files=500):
+    now = datetime.datetime.now(datetime.timezone.utc)
+    cutoff = now - datetime.timedelta(hours=24)
+    jsonl_files = sorted(
+        AGENTS_DIR.rglob("sessions/*.jsonl"),
+        key=lambda path: path.stat().st_mtime if path.exists() else 0,
+        reverse=True,
+    )[:max_files]
+
+    tool_counts = Counter()
+    error_count = 0
+    total_events = 0
+    token_total = 0
+    input_tokens = 0
+    output_tokens = 0
+    cost_total = 0.0
+    cache_hits = 0
+    cache_samples = 0
+    latest_per_agent = {}
+
+    for path in jsonl_files:
+        agent = path.parts[-3] if len(path.parts) >= 3 else "unknown"
+        try:
+            with path.open("r", encoding="utf-8", errors="ignore") as fh:
+                for line in fh:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        row = json.loads(line)
+                    except Exception:
+                        continue
+                    msg = row.get("message") if isinstance(row.get("message"), dict) else {}
+                    ts = parse_ts_any(row.get("timestamp") or msg.get("timestamp") or row.get("time") or msg.get("time"))
+                    if ts is None or ts < cutoff:
+                        continue
+                    total_events += 1
+                    if msg.get("errorMessage") or msg.get("stopReason") == "error":
+                        error_count += 1
+                    summary = None
+                    content = msg.get("content") if isinstance(msg.get("content"), list) else []
+                    for block in content:
+                        if not isinstance(block, dict):
+                            continue
+                        if block.get("type") == "toolCall":
+                            label = normalize_exec_tool_label(block)
+                            tool_counts[label] += 1
+                            summary = summary or f"tool: {label}"
+                        elif block.get("type") == "text" and msg.get("role") == "assistant":
+                            text = (block.get("text") or "").strip().replace("\n", " ")
+                            if text and summary is None:
+                                summary = text[:120]
+                    usage = msg.get("usage") if isinstance(msg.get("usage"), dict) else {}
+                    if usage:
+                        # Token extraction - prefer explicit totals
+                        total_tok = usage.get("total_tokens") or usage.get("totalTokens")
+                        input_tok = usage.get("input_tokens") or usage.get("inputTokens") or usage.get("input")
+                        output_tok = usage.get("output_tokens") or usage.get("outputTokens") or usage.get("output")
+                        
+                        if total_tok:
+                            token_total += int(total_tok)
+                        elif input_tok or output_tok:
+                            token_total += int(input_tok or 0) + int(output_tok or 0)
+                        
+                        if input_tok:
+                            input_tokens += int(input_tok)
+                        if output_tok:
+                            output_tokens += int(output_tok)
+                            
+                        for key in ("cost", "total_cost", "usd", "costUsd"):
+                            value = usage.get(key)
+                            if isinstance(value, (int, float)):
+                                cost_total += float(value)
+                        cached = usage.get("cache_hit") or usage.get("cacheHit")
+                        cached_tokens = usage.get("cached_tokens") or usage.get("cachedTokens") or usage.get("cache_read_tokens") or usage.get("cacheReadTokens")
+                        if isinstance(cached, bool):
+                            cache_samples += 1
+                            if cached:
+                                cache_hits += 1
+                        elif isinstance(cached_tokens, (int, float)):
+                            cache_samples += 1
+                            if cached_tokens > 0:
+                                cache_hits += 1
+                    latest = latest_per_agent.get(agent)
+                    if latest is None or ts > latest["ts"]:
+                        latest_per_agent[agent] = {"ts": ts, "summary": summary or "No recent assistant/tool summary"}
+        except Exception:
+            continue
+
+    active_cutoff = now - datetime.timedelta(minutes=60)
+    active_agents = [
+        {"agent": agent, "ts": info["ts"], "updated": fmt_local(info["ts"]), "summary": info["summary"]}
+        for agent, info in latest_per_agent.items()
+        if info["ts"] >= active_cutoff
+    ]
+    active_agents.sort(key=lambda row: row["ts"], reverse=True)
+    return {
+        "tool_counts": tool_counts,
+        "error_rate": (error_count / total_events * 100.0) if total_events else 0.0,
+        "error_count": error_count,
+        "total_events": total_events,
+        "token_total": token_total,
+        "input_tokens": input_tokens,
+        "output_tokens": output_tokens,
+        "cost_total": cost_total,
+        "cache_hit_proxy": (cache_hits / cache_samples * 100.0) if cache_samples else None,
+        "cache_samples": cache_samples,
+        "active_summaries": active_agents,
+    }
+
+
+def get_live_session_activity(session_key, agent_name, max_lines=100):
+    """Extract detailed recent activity from a specific session's JSONL."""
+    if not AGENTS_DIR.exists():
+        return []
+    
+    # Find the JSONL file for this session
+    agent_dir = AGENTS_DIR / agent_name
+    if not agent_dir.exists():
+        return []
+    
+    # session_key format: agent:name:uuid or just uuid
+    session_id = session_key.split(":")[-1] if ":" in session_key else session_key
+    jsonl_path = agent_dir / "sessions" / f"{session_id}.jsonl"
+    
+    if not jsonl_path.exists():
+        return []
+    
+    activities = []
+    lines = read_tail_lines(jsonl_path, max_lines)
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            row = json.loads(line)
+        except Exception:
+            continue
+        
+        msg = row.get("message") if isinstance(row.get("message"), dict) else {}
+        ts = parse_ts_any(row.get("timestamp") or msg.get("timestamp") or row.get("time") or msg.get("time"))
+        
+        entry = {
+            "timestamp": ts,
+            "time": fmt_local(ts),
+            "role": msg.get("role", ""),
+            "type": "",
+            "summary": "",
+            "details": "",
+        }
+        
+        content = msg.get("content") if isinstance(msg.get("content"), list) else []
+        for block in content:
+            if not isinstance(block, dict):
+                continue
+            
+            if block.get("type") == "thinking":
+                entry["type"] = "thinking"
+                thinking = block.get("thinking") or ""
+                entry["summary"] = "Thinking..." if thinking else "(empty thinking)"
+                entry["details"] = thinking[:500] if thinking else ""
+                
+            elif block.get("type") == "toolCall":
+                entry["type"] = "tool"
+                label = normalize_exec_tool_label(block)
+                entry["summary"] = f"→ {label}"
+                args = block.get("arguments", {})
+                if isinstance(args, dict):
+                    # Summarize key arguments
+                    arg_summary = []
+                    for k, v in list(args.items())[:3]:
+                        v_str = str(v)[:50]
+                        arg_summary.append(f"{k}={v_str}")
+                    entry["details"] = ", ".join(arg_summary)
+                elif isinstance(args, str):
+                    entry["details"] = args[:100]
+                    
+            elif block.get("type") == "toolResult":
+                entry["type"] = "result"
+                content_data = block.get("content")
+                is_error = block.get("isError") or block.get("error")
+                entry["summary"] = "✗ Error" if is_error else "✓ Result"
+                if isinstance(content_data, str):
+                    entry["details"] = content_data[:200]
+                elif isinstance(content_data, list) and content_data:
+                    entry["details"] = str(content_data[0])[:200]
+                    
+            elif block.get("type") == "text":
+                entry["type"] = "text"
+                text = (block.get("text") or "").strip()
+                entry["summary"] = text[:80].replace("\n", " ")
+                entry["details"] = text[:300]
+        
+        if entry["type"] or entry["summary"]:
+            activities.append(entry)
+    
+    return activities
+
+
+def _load_sidecar_artifact(name: str):
+    """Load a Session Amplifier artifact from the state directory. Returns {} if unavailable."""
+    path = STATE_DIR / "session_amplifier" / name
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _sidecar_reachable() -> bool:
+    try:
+        import urllib.request
+        req = urllib.request.Request(f"{SESSION_AMPLIFIER_BASE}/health", method="GET")
+        urllib.request.urlopen(req, timeout=2)
+        return True
+    except Exception:
+        return False
+
+
+def _fetch_sidecar_json(path: str, default=None):
+    """GET a path from the sidecar API. Returns parsed JSON or default on failure."""
+    try:
+        import urllib.request
+        req = urllib.request.Request(f"{SESSION_AMPLIFIER_BASE}{path}", method="GET")
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            return json.loads(resp.read().decode())
+    except Exception:
+        return default
+
+
+def _load_ops_json(name: str, default=None):
+    path = STATE_DIR / name
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return default
+
+
+def render_model_ops_tab(session_rows):
+    snapshot = _load_ops_json("model-ops-snapshot-latest.json", {}) or {}
+    merged = _load_ops_json("model-benchmarks-merged-latest.json", {}) or {}
+    cost_rows = _load_ops_json("session-cost-top50-latest.json", []) or []
+
+    st.subheader("Model Ops")
+    c1, c2, c3, c4 = st.columns(4)
+    c1.metric("OpenRouter models", snapshot.get("market_model_count", 0))
+    c2.metric("Merged benchmark models", len(merged.get("models", [])))
+    c3.metric("HF models", len((_load_ops_json("hf-benchmarks-latest.json", {}) or {}).get("models", [])))
+    c4.metric("Top cost rows", len(cost_rows))
+
+    st.markdown("### Benchmark sources")
+    src_rows = []
+    for src in snapshot.get("benchmark_source_status", []):
+        if isinstance(src, dict):
+            src_rows.append({"source": src.get("name"), "status": src.get("status")})
+    if src_rows:
+        st.dataframe(src_rows, use_container_width=True, hide_index=True)
+    else:
+        st.caption("No benchmark source metadata available")
+
+    st.markdown("### Cost coverage quality")
+    coverage = Counter((row.get("cost_source") or "unknown") for row in cost_rows)
+    cc1, cc2, cc3, cc4 = st.columns(4)
+    cc1.metric("Observed", coverage.get("observed", 0))
+    cc2.metric("Estimated", coverage.get("estimated", 0))
+    cc3.metric("Unknown", coverage.get("unknown", 0) + coverage.get("", 0))
+    cc4.metric("Trust score", f"{(snapshot.get('cost_trust_score', 0.0) * 100):.1f}%")
+
+    st.markdown("### Highest current observed session cost")
+    if cost_rows:
+        agent_filter = st.selectbox("Cost rows filter by agent", ["all"] + sorted({r.get('agent_id') or '' for r in cost_rows if r.get('agent_id')}), index=0)
+        filtered_cost = [r for r in cost_rows if agent_filter == 'all' or r.get('agent_id') == agent_filter]
+        st.dataframe(filtered_cost[:15], use_container_width=True, hide_index=True)
+
+        st.markdown("#### Inspect costly session")
+        lookup = {f"{r.get('agent_id')}/{r.get('session_id')} — {r.get('primary_model')} — ${r.get('total_estimated_usd')}": r for r in filtered_cost[:25]}
+        if lookup:
+            selected = st.selectbox("Jump to session details", list(lookup.keys()), index=0)
+            chosen = lookup[selected]
+            agent = chosen.get('agent_id')
+            session_id = chosen.get('session_id')
+            matching = [r for r in session_rows if r.get('agent') == agent and (r.get('sessionId') == session_id or session_id in (r.get('sessionKey') or ''))]
+            if matching:
+                match = matching[0]
+                st.caption(f"Session key: {match.get('sessionKey')}")
+                st.caption(f"Last updated: {match.get('updated')}")
+                st.caption(f"Delivery: {match.get('deliveryTo')}")
+                recent = get_live_session_activity(match.get('sessionKey'), agent, max_lines=40)
+                if recent:
+                    st.dataframe([
+                        {
+                            'time': a.get('time'),
+                            'type': a.get('type'),
+                            'summary': a.get('summary'),
+                            'details': (a.get('details') or '')[:120],
+                        } for a in recent[-15:]
+                    ], use_container_width=True, hide_index=True)
+                else:
+                    st.caption('No recent activity extracted from transcript.')
+            else:
+                st.caption('No matching session found in current session index.')
+    else:
+        st.caption("No session cost artifacts found")
+
+    show_legacy = st.checkbox("Show legacy / non-orchestration benchmark leaders", value=False)
+    st.markdown("### Top merged Arena Elo")
+    arena_elo = snapshot.get("top_arena_elo", [])
+    if show_legacy:
+        arena_elo = sorted([m for m in merged.get('models', []) if (m.get('arena') or {}).get('elo') is not None], key=lambda m: (m.get('arena') or {}).get('elo') or 0, reverse=True)[:10]
+    if arena_elo:
+        st.dataframe([
+            {"model": r.get("model"), "elo": (r.get("arena") or {}).get("elo"), "mapping": (r.get("mapping") or {}).get("confidence")}
+            for r in arena_elo
+        ], use_container_width=True, hide_index=True)
+    else:
+        st.caption("No merged arena elo rows")
+
+    st.markdown("### Top merged Arena winrate")
+    arena_wr = snapshot.get("top_arena_winrate", [])
+    if show_legacy:
+        arena_wr = sorted([m for m in merged.get('models', []) if (m.get('arena') or {}).get('winrate') is not None], key=lambda m: (m.get('arena') or {}).get('winrate') or 0, reverse=True)[:10]
+    if arena_wr:
+        st.dataframe([
+            {
+                "model": r.get("model"),
+                "winrate": (r.get("arena") or {}).get("winrate"),
+                "appearances": (r.get("arena") or {}).get("appearances"),
+                "mapping": (r.get("mapping") or {}).get("confidence"),
+            }
+            for r in arena_wr
+        ], use_container_width=True, hide_index=True)
+    else:
+        st.caption("No merged arena winrate rows")
+
+    st.markdown("### Highest heuristic efficiency")
+    eff = snapshot.get("top_efficiency", [])
+    if eff:
+        st.dataframe([
+            {
+                "model": r.get("id"),
+                "efficiency": r.get("efficiency_score"),
+                "input_per_1m": (r.get("pricing_per_1m") or {}).get("input"),
+                "context": r.get("context_length"),
+            }
+            for r in eff
+        ], use_container_width=True, hide_index=True)
+
+    st.markdown("### Mapping confidence breakdown")
+    counts = Counter(((m.get("mapping") or {}).get("confidence") or "unknown") for m in merged.get("models", []))
+    st.json(dict(counts))
+
+
+def main():
+    st.set_page_config(page_title="OpenClaw Ops Dashboard", layout="wide")
+    st.title("OpenClaw Ops Dashboard")
+    st.caption(f"Root: {OPENCLAW_ROOT}")
+
+    # Load Session Amplifier artifacts if available
+    sidecar_status = "unavailable"
+    sidecar_report = _load_sidecar_artifact("review-latest.json")
+    sidecar_skills = _load_sidecar_artifact("skills-latest.json")
+    if sidecar_report or sidecar_skills:
+        sidecar_status = "ok"
+    elif _sidecar_reachable():
+        sidecar_status = "reachable"
+
+    session_rows, session_lookup = session_index_rows()
+    activity_rows = transcript_activity_rows(session_lookup)
+    cron_rows = list_cron_jobs()
+    metrics = collect_metrics_last_24h()
+
+    running_cron = [row for row in cron_rows if row["runningAt"]]
+    subagent_rows = [row for row in session_rows if row["kind"] == "subagent"]
+    
+    # Health summary
+    critical_jobs = [r for r in cron_rows if r["health"] == "critical"]
+    warning_jobs = [r for r in cron_rows if r["health"] == "warning"]
+    stale_jobs = [r for r in cron_rows if r["health"] == "stale"]
+
+    c1, c2, c3, c4, c5 = st.columns(5)
+    c1.metric("Agents", len({row["agent"] for row in session_rows}))
+    c2.metric("Indexed sessions", len(session_rows))
+    c3.metric("Running cron", len(running_cron))
+    c4.metric("Sidecar", sidecar_status.title(), help="Session Amplifier sidecar availability")
+    health_display = "✓" if not (critical_jobs or warning_jobs or stale_jobs) else f"⚠ {len(critical_jobs)}/{len(warning_jobs)}/{len(stale_jobs)}"
+    c5.metric("Health", health_display, help="Critical/Warning/Stale cron jobs")
+
+    tab_overview, tab_sessions, tab_cron, tab_activity, tab_live, tab_model_ops = st.tabs(
+        ["Overview", "Sessions", "Cron", "Activity", "Live Session", "Model Ops"]
+    )
+
+    with tab_overview:
+        left, right = st.columns([1, 1])
+        with left:
+            st.subheader("Active agent summaries (last 60m)")
+            if metrics["active_summaries"]:
+                st.dataframe(metrics["active_summaries"], use_container_width=True, hide_index=True)
+            else:
+                st.info("No active agent summaries in the last 60 minutes.")
+
+            st.subheader("Recent sessions")
+            if session_rows:
+                st.dataframe(
+                    [
+                        {
+                            "agent": row["agent"],
+                            "kind": row["kind"],
+                            "updated": row["updated"],
+                            "sessionKey": row["sessionKey"],
+                            "deliveryTo": row["deliveryTo"],
+                        }
+                        for row in session_rows[:20]
+                    ],
+                    use_container_width=True,
+                    hide_index=True,
+                )
+            else:
+                st.info("No indexed sessions found.")
+
+        with right:
+            st.subheader("Last 24h metrics")
+            m1, m2, m3, m4 = st.columns(4)
+            m1.metric("Error rate", f"{metrics['error_rate']:.2f}%")
+            m2.metric("Errors / events", f"{metrics['error_count']} / {metrics['total_events']}")
+            
+            # Show tokens instead of cost (more reliable)
+            token_display = f"{metrics['token_total']:,}" if metrics['token_total'] else "0"
+            m3.metric("Tokens", token_display)
+            m4.metric("Cost", f"${metrics['cost_total']:.4f}")
+            
+            st.caption(f"Input: {metrics['input_tokens']:,} | Output: {metrics['output_tokens']:,}")
+            
+            if metrics["cache_hit_proxy"] is None:
+                st.caption("Cache-hit proxy unavailable in recent usage fields.")
+            else:
+                st.caption(f"Cache-hit proxy: {metrics['cache_hit_proxy']:.2f}% across {metrics['cache_samples']} samples.")
+
+            st.subheader("Top tools (last 24h)")
+            top_tools = [{"tool": tool, "count": count} for tool, count in metrics["tool_counts"].most_common(20)]
+            if top_tools:
+                st.dataframe(top_tools, use_container_width=True, hide_index=True)
+            else:
+                st.info("No tool invocation events found in the last 24 hours.")
+
+            # Session Amplifier findings
+            st.subheader("Session Amplifier")
+            if sidecar_report:
+                patterns = sidecar_report.get("failure_patterns", [])
+                if patterns:
+                    st.warning(f"{len(patterns)} failure pattern(s) detected — see Activity tab for details")
+                    for p in patterns[:5]:
+                        st.caption(f"• {p.get('description', p.get('pattern', '?'))} ({p.get('count', 0)})")
+                else:
+                    st.success("No failure patterns detected")
+                if sidecar_report.get("sessions_reviewed"):
+                    st.caption(f"Reviewed {sidecar_report['sessions_reviewed']} sessions")
+            elif sidecar_status == "reachable":
+                st.info("Sidecar reachable but not yet warmed up — run spool to populate")
+            else:
+                st.caption("Session Amplifier unavailable — see docs to deploy sidecar/session-amplifier/")
+
+            if sidecar_skills:
+                missing = sidecar_skills.get("mcps_missing_skill_surface", [])
+                if missing:
+                    st.warning(f"{len(missing)} MCP(s) without skill surface: {', '.join(missing[:5])}")
+                else:
+                    st.caption("All registered MCPs have skill surfaces ✓")
+
+    with tab_sessions:
+        # Prefer sidecar session list when available
+        sidecar_sessions = _fetch_sidecar_json("/sessions/recent?limit=50")
+        if sidecar_sessions and sidecar_sessions.get("sessions"):
+            st.subheader("Recent sessions (Session Amplifier)")
+            st.caption(f"Fetched at {fmt_local(datetime.datetime.now(datetime.timezone.utc).isoformat())}")
+            sess_rows = []
+            for sr in sidecar_sessions["sessions"]:
+                health = sr.get("health", "ok")
+                hints = sr.get("hints", [])
+                hint_str = "; ".join(hints) if hints else ""
+                sess_rows.append({
+                    "agent": sr.get("agent_id", "?"),
+                    "session_id": sr.get("session_id", "?")[:32],
+                    "events": sr.get("event_count", 0),
+                    "tools": sr.get("tool_result_count", 0),
+                    "errors": sr.get("error_count", 0),
+                    "health": health.upper(),
+                    "hints": hint_str,
+                    "last_event": fmt_local(sr.get("last_event_at")),
+                })
+            st.dataframe(sess_rows, use_container_width=True, hide_index=True)
+        else:
+            st.subheader("Session index")
+            agent_names = ["all"] + sorted({row["agent"] for row in session_rows})
+            selected_agent = st.selectbox("Filter agent", agent_names, index=0)
+            selected_kind = st.selectbox("Filter kind", ["all", "session", "discord", "cron", "subagent"], index=0)
+            filtered_rows = []
+            for row in session_rows:
+                if selected_agent != "all" and row["agent"] != selected_agent:
+                    continue
+                if selected_kind != "all" and row["kind"] != selected_kind:
+                    continue
+                filtered_rows.append(
+                    {
+                        "agent": row["agent"],
+                        "kind": row["kind"],
+                        "updated": row["updated"],
+                        "sessionKey": row["sessionKey"],
+                        "sessionId": row["sessionId"],
+                        "deliveryTo": row["deliveryTo"],
+                    }
+                )
+            st.dataframe(filtered_rows, use_container_width=True, hide_index=True)
+
+        st.subheader("Recent child/subagent sessions")
+        st.dataframe(
+            [
+                {
+                    "agent": row["agent"],
+                    "updated": row["updated"],
+                    "sessionKey": row["sessionKey"],
+                    "sessionId": row["sessionId"],
+                }
+                for row in subagent_rows[:50]
+            ],
+            use_container_width=True,
+            hide_index=True,
+        )
+
+    with tab_cron:
+        # Health filter
+        health_filter = st.selectbox(
+            "Filter by health",
+            ["all", "critical", "error", "warning", "stale", "running", "healthy", "disabled"],
+            index=0
+        )
+        
+        filtered_cron = cron_rows
+        if health_filter != "all":
+            filtered_cron = [r for r in cron_rows if r["health"] == health_filter]
+        
+        st.subheader(f"Cron jobs ({len(filtered_cron)} shown)")
+        
+        # Color-coded health display
+        def health_color(health):
+            return {
+                "critical": "🔴",
+                "error": "🟠", 
+                "warning": "🟡",
+                "stale": "⚪",
+                "running": "🟢",
+                "healthy": "✓",
+                "disabled": "⊘",
+            }.get(health, "?")
+        
+        display_rows = []
+        for row in filtered_cron:
+            display_rows.append({
+                "health": f"{health_color(row['health'])} {row['health']}",
+                "name": row["name"],
+                "enabled": "✓" if row["enabled"] else "✗",
+                "schedule": row["schedule"],
+                "lastRun": row["lastRun"],
+                "lastStatus": row["lastStatus"],
+                "nextRun": row["nextRun"],
+                "errors": row["consecutiveErrors"] if row["consecutiveErrors"] > 0 else "",
+                "reason": row["healthReason"],
+            })
+        
+        st.dataframe(display_rows, use_container_width=True, hide_index=True)
+        
+        # Quick stats
+        if critical_jobs or warning_jobs or stale_jobs:
+            st.error(f"**{len(critical_jobs)}** critical, **{len(warning_jobs)}** warning, **{len(stale_jobs)}** stale jobs need attention")
+        else:
+            st.success("All monitored cron jobs are healthy")
+        
+        st.subheader("Running now")
+        if running_cron:
+            st.dataframe(running_cron, use_container_width=True, hide_index=True)
+        else:
+            st.info("No cron jobs currently marked running.")
+
+    with tab_activity:
+        st.subheader("Recent transcript activity")
+        st.dataframe(
+            [
+                {
+                    "agent": row["agent"],
+                    "updated": row["updated"],
+                    "role": row["role"],
+                    "sessionKey": row["sessionKey"],
+                    "summary": row["summary"],
+                    "file": row["file"],
+                }
+                for row in activity_rows[:50]
+            ],
+            use_container_width=True,
+            hide_index=True,
+        )
+
+    with tab_live:
+        st.subheader("Live Session Activity Stream")
+
+        # Prefer sidecar-based session list for selection when available
+        sidecar_sessions = _fetch_sidecar_json("/sessions/recent?limit=30") or {}
+        sidecar_session_list = sidecar_sessions.get("sessions") or []
+
+        # Show spooler health / readiness
+        if sidecar_status == "reachable":
+            st.info("Session Amplifier reachable but not yet warmed up — spool may be empty")
+        elif sidecar_status == "unavailable":
+            st.warning("Session Amplifier unavailable. Deploy: cd sidecar/session-amplifier && docker compose up -d")
+
+        st.caption("Normalized activity feed from Session Amplifier. "
+                   "For continuous streaming, use: python scripts/session_amplifier_live_monitor.py")
+
+        # Build unified session options: sidecar sessions first, then fallback to dashboard sessions
+        if sidecar_session_list:
+            sidecar_opts = [
+                f"[SA] {s.get('agent_id','?')}: {clean_session_label(s.get('display_title') or '', fallback=s.get('session_id','?')[:32])}"
+                for s in sidecar_session_list[:20]
+            ]
+            sidecar_map = {opt: s for opt, s in zip(sidecar_opts, sidecar_session_list[:20])}
+            use_sidecar = True
+        else:
+            recent = [r for r in session_rows if r["updatedAt"] and r["updatedAt"] > datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(hours=24)]
+            sidecar_opts = []
+            sidecar_map = {}
+            use_sidecar = False
+
+        # Fallback: dashboard-based session list
+        recent_sessions = [r for r in session_rows if r["updatedAt"] and r["updatedAt"] > datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(hours=24)]
+        dash_opts = [f"{r['agent']}: {session_display_label(r)}" for r in recent_sessions[:20]]
+        dash_map = {opt: r for opt, r in zip(dash_opts, recent_sessions[:20])}
+
+        # Combine: sidecar sessions first, then dashboard sessions
+        all_opts = sidecar_opts + dash_opts
+        all_map = {**sidecar_map, **dash_map}
+
+        if all_opts:
+            selected = st.selectbox("Select session to monitor", all_opts, index=0)
+            selected_item = all_map[selected]
+
+            if use_sidecar and selected in sidecar_map:
+                sel_session_id = selected_item["session_id"]
+                sel_agent = selected_item["agent_id"]
+                sel_title = clean_session_label(selected_item.get("display_title") or "", fallback=sel_session_id)
+                sel_updated = fmt_local(selected_item.get("last_event_at"))
+                sel_health = selected_item.get("health", "ok").upper()
+                sel_hints = "; ".join(selected_item.get("hints", []) or [])
+                st.caption(f"Health: {sel_health} | Events: {selected_item.get('event_count',0)} | Tools: {selected_item.get('tool_result_count',0)} | Errors: {selected_item.get('error_count',0)}")
+                if sel_hints:
+                    st.caption(f"Hints: {sel_hints}")
+
+                # Fetch activity from sidecar
+                activity_data = _fetch_sidecar_json(f"/session/{sel_session_id}/activity?limit=200")
+                activities = activity_data.get("activity", []) if activity_data else []
+            else:
+                if isinstance(selected_item, dict) and "sessionKey" in selected_item:
+                    sel_session_id = selected_item["sessionKey"]
+                    sel_agent = selected_item["agent"]
+                    sel_title = session_display_label(selected_item)
+                    sel_updated = selected_item["updated"]
+                else:
+                    sel_session_id = "?"
+                    sel_agent = "?"
+                    sel_title = "?"
+                    sel_updated = "?"
+                st.caption(f"Dashboard session — may not appear in Session Amplifier spool")
+                activities = get_live_session_activity(sel_session_id, sel_agent, max_lines=200)
+
+            col1, col2, col3 = st.columns([1, 1, 1])
+            with col1:
+                st.write(f"**Agent:** {sel_agent}")
+            with col2:
+                st.write(f"**Session:** {sel_title}")
+            with col3:
+                st.write(f"**Last event:** {sel_updated}")
+
+            if activities:
+                current_bucket = None
+                for act in reversed(activities[-50:]):
+                    ts = act.get("timestamp")
+                    if ts:
+                        try:
+                            bucket = ts.replace(minute=(ts.minute // 5) * 5, second=0, microsecond=0)
+                            if bucket != current_bucket:
+                                current_bucket = bucket
+                                st.divider()
+                                st.caption(f"📍 {fmt_local(bucket)}")
+                        except Exception:
+                            pass
+
+                    evtype = act.get("type") or act.get("event_type", "")
+                    ts_str = act.get("time") or ""
+
+                    if evtype == "thinking":
+                        with st.expander(f"🧠 {ts_str} — Thinking", expanded=False):
+                            st.text(act.get("details", "")[:1000] or "(no details)")
+                    elif evtype == "tool":
+                        st.markdown(f"**🔧 {ts_str}** — {act.get('summary', '')}")
+                        if act.get("details"):
+                            st.code(act["details"][:500], language="bash")
+                    elif evtype == "tool_call":
+                        st.markdown(f"**⚙ {ts_str}** → {act.get('tool_name', '')} — {act.get('summary', '')}")
+                    elif evtype == "tool_result" or evtype == "result":
+                        icon = "❌" if act.get("is_error") else "✅"
+                        st.markdown(f"**{icon} {ts_str}** — {act.get('summary', '')}")
+                        if act.get("details"):
+                            st.text(act["details"][:300])
+                    elif evtype == "tool_error":
+                        st.error(f"⚠ {ts_str} — {act.get('summary', 'tool error')}")
+                        if act.get("details"):
+                            st.text(act["details"][:300])
+                    elif evtype == "assistant_meta":
+                        st.markdown(f"**💡 {ts_str}** — {act.get('summary', '')[:120]}")
+                    elif evtype == "assistant_thinking":
+                        with st.expander(f"🧠 {ts_str} — Thinking", expanded=False):
+                            st.text(act.get("details", "")[:500] or "(no details)")
+                    elif evtype == "assistant_text":
+                        st.markdown(f"**💬 {ts_str}** — {act.get('summary', '')[:120]}")
+                    elif evtype == "user_message":
+                        with st.expander(f"👤 {ts_str} — User message", expanded=False):
+                            st.text(act.get("details", "")[:300])
+                    else:
+                        st.caption(f"[{evtype or '?'}] {ts_str} — {act.get('summary', '')[:80]}")
+            else:
+                st.info("No activity found for this session (may be archived or not yet written)")
+        else:
+            st.info("No recent sessions found in the last 24 hours")
+
+    with tab_model_ops:
+        render_model_ops_tab(session_rows)
+
+
+if __name__ == "__main__":
+    main()

docker-compose.yml

@@ -0,0 +1,32 @@
+version: '3.8'
+
+services:
+  ops-dashboard:
+    image: ops-dashboard:latest
+    container_name: ops-dashboard
+    restart: unless-stopped
+    working_dir: /app
+    command: [ "streamlit", "run", "app.py" ]
+    volumes:
+      - ./app.py:/app/app.py
+      - ${OPENCLAW_HOME:-~/.openclaw}:/openclaw:ro
+    environment:
+      OPENCLAW_AGENTS_ROOT: /openclaw/agents
+    networks:
+      - librechat_default
+
+  ops-dashboard-react:
+    build:
+      context: ./react-dashboard
+      args:
+        VITE_BASE_PATH: /react/
+    image: ops-dashboard-react:latest
+    container_name: ops-dashboard-react
+    restart: unless-stopped
+    networks:
+      - librechat_default
+
+networks:
+  librechat_default:
+    external: true
+    name: librechat_default

react-dashboard/.dockerignore

@@ -0,0 +1,6 @@
+node_modules
+dist
+.git
+.cache
+npm-debug.log*
+

react-dashboard/.gitignore

@@ -0,0 +1,4 @@
+node_modules/
+dist/
+.env
+.env.*

react-dashboard/Dockerfile

@@ -0,0 +1,19 @@
+FROM node:22-alpine AS build
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci
+
+COPY . .
+ARG VITE_BASE_PATH=/react/
+ENV VITE_BASE_PATH=$VITE_BASE_PATH
+RUN npm run build
+
+FROM nginx:1.27-alpine
+
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+COPY --from=build /app/dist /usr/share/nginx/html
+
+EXPOSE 8080
+

react-dashboard/README.md

@@ -0,0 +1,20 @@
+# OpenClaw Ops React Dashboard
+
+Paperclip-style action dashboard prototype for Session Amplifier data.
+
+## Run locally
+
+    npm install
+    npm run dev -- --port 5177
+
+The Vite dev server proxies /session-amplifier/* to SESSION_AMPLIFIER_BASE_URL or http://localhost:8477.
+
+For browser access from another host, set the API URL directly:
+
+    VITE_SESSION_AMPLIFIER_BASE_URL=http://session-amplifier:8477 npm run dev -- --port 5177
+
+## Status
+
+- Additive prototype beside the existing Streamlit dashboard.
+- Uses /health, /sessions/active-bulk, and /review/skills.
+- Run/pause/open controls are intentionally disabled until first-class action endpoints exist.

react-dashboard/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>OpenClaw Ops</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

react-dashboard/nginx.conf

@@ -0,0 +1,17 @@
+server {
+    listen 8080;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    location /healthz {
+        access_log off;
+        add_header Content-Type text/plain;
+        return 200 "ok\n";
+    }
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+}
+

react-dashboard/package-lock.json

@@ -0,0 +1,1673 @@
+{
+  "name": "openclaw-ops-react-dashboard",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "openclaw-ops-react-dashboard",
+      "version": "0.1.0",
+      "dependencies": {
+        "@vitejs/plugin-react": "^5.0.4",
+        "lucide-react": "^0.468.0",
+        "react": "^19.2.0",
+        "react-dom": "^19.2.0",
+        "vite": "^7.2.4"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.3",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.3.tgz",
+      "integrity": "sha512-LIVqM46zQWZhj17qA8wb4nW/ixr2y1Nw+r1etiAWgRM6U1IqP+LNhL1yg440jYZR72jCWcWbLWzIosH+uP1fqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.3",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.3.tgz",
+      "integrity": "sha512-b3ctpQwp+PROvU/cttc4OYl4MzfJUWy6FZg+PMXfzmt/+39iHVF0sDfqay8TQM3JA2EUOyKcFZt75jWriQijsA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.7.tgz",
+      "integrity": "sha512-EKX3Qwmhz1eMdEJokhALr0YiD0lhQNwDqkPYyPhiSwKrh7/4KRjQc04sZ8db+5DVVnZ1LmbNDI1uAMPEUBnQPg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.7.tgz",
+      "integrity": "sha512-jbPXvB4Yj2yBV7HUfE2KHe4GJX51QplCN1pGbYjvsyCZbQmies29EoJbkEc+vYuU5o45AfQn37vZlyXy4YJ8RQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.7.tgz",
+      "integrity": "sha512-62dPZHpIXzvChfvfLJow3q5dDtiNMkwiRzPylSCfriLvZeq0a1bWChrGx/BbUbPwOrsWKMn8idSllklzBy+dgQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.7.tgz",
+      "integrity": "sha512-x5VpMODneVDb70PYV2VQOmIUUiBtY3D3mPBG8NxVk5CogneYhkR7MmM3yR/uMdITLrC1ml/NV1rj4bMJuy9MCg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.7.tgz",
+      "integrity": "sha512-5lckdqeuBPlKUwvoCXIgI2D9/ABmPq3Rdp7IfL70393YgaASt7tbju3Ac+ePVi3KDH6N2RqePfHnXkaDtY9fkw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.7.tgz",
+      "integrity": "sha512-rYnXrKcXuT7Z+WL5K980jVFdvVKhCHhUwid+dDYQpH+qu+TefcomiMAJpIiC2EM3Rjtq0sO3StMV/+3w3MyyqQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-B48PqeCsEgOtzME2GbNM2roU29AMTuOIN91dsMO30t+Ydis3z/3Ngoj5hhnsOSSwNzS+6JppqWsuhTp6E82l2w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.7.tgz",
+      "integrity": "sha512-jOBDK5XEjA4m5IJK3bpAQF9/Lelu/Z9ZcdhTRLf4cajlB+8VEhFFRjWgfy3M1O4rO2GQ/b2dLwCUGpiF/eATNQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.7.tgz",
+      "integrity": "sha512-RkT/YXYBTSULo3+af8Ib0ykH8u2MBh57o7q/DAs3lTJlyVQkgQvlrPTnjIzzRPQyavxtPtfg0EopvDyIt0j1rA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.7.tgz",
+      "integrity": "sha512-RZPHBoxXuNnPQO9rvjh5jdkRmVizktkT7TCDkDmQ0W2SwHInKCAV95GRuvdSvA7w4VMwfCjUiPwDi0ZO6Nfe9A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.7.tgz",
+      "integrity": "sha512-GA48aKNkyQDbd3KtkplYWT102C5sn/EZTY4XROkxONgruHPU72l+gW+FfF8tf2cFjeHaRbWpOYa/uRBz/Xq1Pg==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.7.tgz",
+      "integrity": "sha512-a4POruNM2oWsD4WKvBSEKGIiWQF8fZOAsycHOt6JBpZ+JN2n2JH9WAv56SOyu9X5IqAjqSIPTaJkqN8F7XOQ5Q==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.7.tgz",
+      "integrity": "sha512-KabT5I6StirGfIz0FMgl1I+R1H73Gp0ofL9A3nG3i/cYFJzKHhouBV5VWK1CSgKvVaG4q1RNpCTR2LuTVB3fIw==",
+      "cpu": [
+        "mips64el"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.7.tgz",
+      "integrity": "sha512-gRsL4x6wsGHGRqhtI+ifpN/vpOFTQtnbsupUF5R5YTAg+y/lKelYR1hXbnBdzDjGbMYjVJLJTd2OFmMewAgwlQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.7.tgz",
+      "integrity": "sha512-hL25LbxO1QOngGzu2U5xeXtxXcW+/GvMN3ejANqXkxZ/opySAZMrc+9LY/WyjAan41unrR3YrmtTsUpwT66InQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.7.tgz",
+      "integrity": "sha512-2k8go8Ycu1Kb46vEelhu1vqEP+UeRVj2zY1pSuPdgvbd5ykAw82Lrro28vXUrRmzEsUV0NzCf54yARIK8r0fdw==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.7.tgz",
+      "integrity": "sha512-hzznmADPt+OmsYzw1EE33ccA+HPdIqiCRq7cQeL1Jlq2gb1+OyWBkMCrYGBJ+sxVzve2ZJEVeePbLM2iEIZSxA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-b6pqtrQdigZBwZxAn1UpazEisvwaIDvdbMbmrly7cDTMFnw/+3lVxxCTGOrkPVnsYIosJJXAsILG9XcQS+Yu6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-OfatkLojr6U+WN5EDYuoQhtM+1xco+/6FSzJJnuWiUw5eVcicbyK3dq5EeV/QHT1uy6GoDhGbFpprUiHUYggrw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.7.tgz",
+      "integrity": "sha512-AFuojMQTxAz75Fo8idVcqoQWEHIXFRbOc1TrVcFSgCZtQfSdc1RXgB3tjOn/krRHENUB4j00bfGjyl2mJrU37A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.7.tgz",
+      "integrity": "sha512-+A1NJmfM8WNDv5CLVQYJ5PshuRm/4cI6WMZRg1by1GwPIQPCTs1GLEUHwiiQGT5zDdyLiRM/l1G0Pv54gvtKIg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openharmony-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.7.tgz",
+      "integrity": "sha512-+KrvYb/C8zA9CU/g0sR6w2RBw7IGc5J2BPnc3dYc5VJxHCSF1yNMxTV5LQ7GuKteQXZtspjFbiuW5/dOj7H4Yw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.7.tgz",
+      "integrity": "sha512-ikktIhFBzQNt/QDyOL580ti9+5mL/YZeUPKU2ivGtGjdTYoqz6jObj6nOMfhASpS4GU4Q/Clh1QtxWAvcYKamA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.7.tgz",
+      "integrity": "sha512-7yRhbHvPqSpRUV7Q20VuDwbjW5kIMwTHpptuUzV+AA46kiPze5Z7qgt6CLCK3pWFrHeNfDd1VKgyP4O+ng17CA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.7.tgz",
+      "integrity": "sha512-SmwKXe6VHIyZYbBLJrhOoCJRB/Z1tckzmgTLfFYOfpMAx63BJEaL9ExI8x7v0oAO3Zh6D/Oi1gVxEYr5oUCFhw==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.7.tgz",
+      "integrity": "sha512-56hiAJPhwQ1R4i+21FVF7V8kSD5zZTdHcVuRFMW0hn753vVfQN8xlx4uOPT4xoGH0Z/oVATuR82AiqSTDIpaHg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-rc.3",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz",
+      "integrity": "sha512-eybk3TjzzzV97Dlj5c+XrBFW57eTNhzod66y9HrBlzJ6NsCrWCp/2kaPS3K9wJmurBC0Tdw4yPjXKZqlznim3Q==",
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.4.tgz",
+      "integrity": "sha512-F5QXMSiFebS9hKZj02XhWLLnRpJ3B3AROP0tWbFBSj+6kCbg5m9j5JoHKd4mmSVy5mS/IMQloYgYxCuJC0fxEQ==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.4.tgz",
+      "integrity": "sha512-GxxTKApUpzRhof7poWvCJHRF51C67u1R7D6DiluBE8wKU1u5GWE8t+v81JvJYtbawoBFX1hLv5Ei4eVjkWokaw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.4.tgz",
+      "integrity": "sha512-tua0TaJxMOB1R0V0RS1jFZ/RpURFDJIOR2A6jWwQeawuFyS4gBW+rntLRaQd0EQ4bd6Vp44Z2rXW+YYDBsj6IA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.4.tgz",
+      "integrity": "sha512-CSKq7MsP+5PFIcydhAiR1K0UhEI1A2jWXVKHPCBZ151yOutENwvnPocgVHkivu2kviURtCEB6zUQw0vs8RrhMg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.4.tgz",
+      "integrity": "sha512-+O8OkVdyvXMtJEciu2wS/pzm1IxntEEQx3z5TAVy4l32G0etZn+RsA48ARRrFm6Ri8fvqPQfgrvNxSjKAbnd3g==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.4.tgz",
+      "integrity": "sha512-Iw3oMskH3AfNuhU0MSN7vNbdi4me/NiYo2azqPz/Le16zHSa+3RRmliCMWWQmh4lcndccU40xcJuTYJZxNo/lw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.4.tgz",
+      "integrity": "sha512-EIPRXTVQpHyF8WOo219AD2yEltPehLTcTMz2fn6JsatLYSzQf00hj3rulF+yauOlF9/FtM2WpkT/hJh/KJFGhA==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.4.tgz",
+      "integrity": "sha512-J3Yh9PzzF1Ovah2At+lHiGQdsYgArxBbXv/zHfSyaiFQEqvNv7DcW98pCrmdjCZBrqBiKrKKe2V+aaSGWuBe/w==",
+      "cpu": [
+        "arm"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.4.tgz",
+      "integrity": "sha512-BFDEZMYfUvLn37ONE1yMBojPxnMlTFsdyNoqncT0qFq1mAfllL+ATMMJd8TeuVMiX84s1KbcxcZbXInmcO2mRg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.4.tgz",
+      "integrity": "sha512-pc9EYOSlOgdQ2uPl1o9PF6/kLSgaUosia7gOuS8mB69IxJvlclko1MECXysjs5ryez1/5zjYqx3+xYU0TU6R1A==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.4.tgz",
+      "integrity": "sha512-NxnomyxYerDh5n4iLrNa+sH+Z+U4BMEE46V2PgQ/hoB909i8gV1M5wPojWg9fk1jWpO3IQnOs20K4wyZuFLEFQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.4.tgz",
+      "integrity": "sha512-nbJnQ8a3z1mtmrwImCYhc6BGpThAyYVRQxw9uKSKG4wR6aAYno9sVjJ0zaZcW9BPJX1GbrDPf+SvdWjgTuDmnw==",
+      "cpu": [
+        "loong64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.4.tgz",
+      "integrity": "sha512-2EU6acNrQLd8tYvo/LXW535wupT3m6fo7HKo6lr7ktQoItxTyOL1ZCR/GfGCuXl2vR+zmfI6eRXkSemafv+iVg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.4.tgz",
+      "integrity": "sha512-WeBtoMuaMxiiIrO2IYP3xs6GMWkJP2C0EoT8beTLkUPmzV1i/UcOSVw1d5r9KBODtHKilG5yFxsGRnBbK3wJ4A==",
+      "cpu": [
+        "ppc64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.4.tgz",
+      "integrity": "sha512-FJHFfqpKUI3A10WrWKiFbBZ7yVbGT4q4B5o1qKFFojqpaYoh9LrQgqWCmmcxQzVSXYtyB5bzkXrYzlHTs21MYA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.4.tgz",
+      "integrity": "sha512-mcEl6CUT5IAUmQf1m9FYSmVqCJlpQ8r8eyftFUHG8i9OhY7BkBXSUdnLH5DOf0wCOjcP9v/QO93zpmF1SptCCw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.4.tgz",
+      "integrity": "sha512-ynt3JxVd2w2buzoKDWIyiV1pJW93xlQic1THVLXilz429oijRpSHivZAgp65KBu+cMcgf1eVVjdnTLvPxgCuoQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.4.tgz",
+      "integrity": "sha512-Boiz5+MsaROEWDf+GGEwF8VMHGhlUoQMtIPjOgA5fv4osupqTVnJteQNKJwUcnUog2G55jYXH7KZFFiJe0TEzQ==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.4.tgz",
+      "integrity": "sha512-+qfSY27qIrFfI/Hom04KYFw3GKZSGU4lXus51wsb5EuySfFlWRwjkKWoE9emgRw/ukoT4Udsj4W/+xxG8VbPKg==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.4.tgz",
+      "integrity": "sha512-VpTfOPHgVXEBeeR8hZ2O0F3aSso+JDWqTWmTmzcQKted54IAdUVbxE+j/MVxUsKa8L20HJhv3vUezVPoquqWjA==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.4.tgz",
+      "integrity": "sha512-IPOsh5aRYuLv/nkU51X10Bf75Bsf6+gZdx1X+QP5QM6lIJFHHqbHLG0uJn/hWthzo13UAc2umiUorqZy3axoZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.4.tgz",
+      "integrity": "sha512-4QzE9E81OohJ/HKzHhsqU+zcYYojVOXlFMs1DdyMT6qXl/niOH7AVElmmEdUNHHS/oRkc++d5k6Vy85zFs0DEw==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.4.tgz",
+      "integrity": "sha512-zTPgT1YuHHcd+Tmx7h8aml0FWFVelV5N54oHow9SLj+GfoDy/huQ+UV396N/C7KpMDMiPspRktzM1/0r1usYEA==",
+      "cpu": [
+        "ia32"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.4.tgz",
+      "integrity": "sha512-DRS4G7mi9lJxqEDezIkKCaUIKCrLUUDCUaCsTPCi/rtqaC6D/jjwslMQyiDU50Ka0JKpeXeRBFBAXwArY52vBw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.4.tgz",
+      "integrity": "sha512-QVTUovf40zgTqlFVrKA1uXMVvU2QWEFWfAH8Wdc48IxLvrJMQVMBRjuQyUpzZCDkakImib9eVazbWlC6ksWtJw==",
+      "cpu": [
+        "x64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "license": "MIT"
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-5.2.0.tgz",
+      "integrity": "sha512-YmKkfhOAi3wsB1PhJq5Scj3GXMn3WvtQ/JC0xoopuHoXSdmtdStOpFrYaT1kie2YgFBcIe64ROzMYRjCrYOdYw==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/core": "^7.29.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-rc.3",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.18.0"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.31",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.31.tgz",
+      "integrity": "sha512-MujYO3eP72uvmSE0i4wltsodRfIpZATP3jvzRNRGGxgzId7aVocVJJV3nf01qnzzKFGxQVC9bpWxl5cjxTr/7Q==",
+      "license": "Apache-2.0",
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001793",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001793.tgz",
+      "integrity": "sha512-iwSsYWaCOoh26cV8NwNRViHlrfUvYsHDfRVcbtmw0Kg6PJIZZXwMkj1442FYLBGkeUf1juAsU3DTfxW579mrPA==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0"
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "license": "MIT"
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.359",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.359.tgz",
+      "integrity": "sha512-8lPELWuYZIWk7NDvCNthtmMw/7Q5Wu25NpM4djFMHBmk8DubPAtL4YTOp7ou0e7HyJtwkVlWv8XMLURnrtgJQw==",
+      "license": "ISC"
+    },
+    "node_modules/esbuild": {
+      "version": "0.27.7",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",
+      "integrity": "sha512-IxpibTjyVnmrIQo5aqNpCgoACA/dTKLTlhMHihVHhdkxKyPO1uBBthumT0rdHmcsk9uMonIWS0m4FljWzILh3w==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.27.7",
+        "@esbuild/android-arm": "0.27.7",
+        "@esbuild/android-arm64": "0.27.7",
+        "@esbuild/android-x64": "0.27.7",
+        "@esbuild/darwin-arm64": "0.27.7",
+        "@esbuild/darwin-x64": "0.27.7",
+        "@esbuild/freebsd-arm64": "0.27.7",
+        "@esbuild/freebsd-x64": "0.27.7",
+        "@esbuild/linux-arm": "0.27.7",
+        "@esbuild/linux-arm64": "0.27.7",
+        "@esbuild/linux-ia32": "0.27.7",
+        "@esbuild/linux-loong64": "0.27.7",
+        "@esbuild/linux-mips64el": "0.27.7",
+        "@esbuild/linux-ppc64": "0.27.7",
+        "@esbuild/linux-riscv64": "0.27.7",
+        "@esbuild/linux-s390x": "0.27.7",
+        "@esbuild/linux-x64": "0.27.7",
+        "@esbuild/netbsd-arm64": "0.27.7",
+        "@esbuild/netbsd-x64": "0.27.7",
+        "@esbuild/openbsd-arm64": "0.27.7",
+        "@esbuild/openbsd-x64": "0.27.7",
+        "@esbuild/openharmony-arm64": "0.27.7",
+        "@esbuild/sunos-x64": "0.27.7",
+        "@esbuild/win32-arm64": "0.27.7",
+        "@esbuild/win32-ia32": "0.27.7",
+        "@esbuild/win32-x64": "0.27.7"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "license": "MIT",
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "license": "ISC",
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lucide-react": {
+      "version": "0.468.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.468.0.tgz",
+      "integrity": "sha512-6koYRhnM2N0GGZIdXzSeiNwguv1gt/FAjZOiPl76roBi3xKEXa4WmfpxgQwTTL4KipXjefrnf3oV4IsYhi4JFA==",
+      "license": "ISC",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0-rc"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.12",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.12.tgz",
+      "integrity": "sha512-ZB9RH/39qpq5Vu6Y+NmUaFhQR6pp+M2Xt76XBnEwDaGcVAqhlvxrl3B2bKS5D3NH3QR76v3aSrKaF/Kiy7lEtQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.44",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.44.tgz",
+      "integrity": "sha512-5WUyunoPMsvvEhS8AxHtRzP+oA8UCkJ7YRxatWKjngndhDGLiqEVAQKWjFAiAiuL8zMRGzGSJxFnLetoa43qGQ==",
+      "license": "MIT"
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.15",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
+      "integrity": "sha512-FfR8sjd4em2T6fb3I2MwAJU7HWVMr9zba+enmQeeWFfCbm+UOC/0X4DS8XtpUTMwWMGbjKYP7xjfNekzyGmB3A==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.12",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.2.6",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.2.6.tgz",
+      "integrity": "sha512-sfWGGfavi0xr8Pg0sVsyHMAOziVYKgPLNrS7ig+ivMNb3wbCBw3KxtflsGBAwD3gYQlE/AEZsTLgToRrSCjb0Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "19.2.6",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.6.tgz",
+      "integrity": "sha512-0prMI+hvBbPjsWnxDLxlCGyM8PN6UuWjEUCYmZhO67xIV9Xasa/r/vDnq+Xyq4Lo27g8QSbO5YzARu0D1Sps3g==",
+      "license": "MIT",
+      "dependencies": {
+        "scheduler": "^0.27.0"
+      },
+      "peerDependencies": {
+        "react": "^19.2.6"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.18.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.18.0.tgz",
+      "integrity": "sha512-QgT5//D3jfjJb6Gsjxv0Slpj23ip+HtOpnNgnb2S5zU3CB26G/IDPGoy4RJB42wzFE46DRsstbW6tKHoKbhAxw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.4.tgz",
+      "integrity": "sha512-WHeFSbZYsPu3+bLoNRUuAO+wavNlocOPf3wSHTP7hcFKVnJeWsYlCDbr3mTS14FCizf9ccIxXA8sGL8zKeQN3g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.4",
+        "@rollup/rollup-android-arm64": "4.60.4",
+        "@rollup/rollup-darwin-arm64": "4.60.4",
+        "@rollup/rollup-darwin-x64": "4.60.4",
+        "@rollup/rollup-freebsd-arm64": "4.60.4",
+        "@rollup/rollup-freebsd-x64": "4.60.4",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.4",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.4",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.4",
+        "@rollup/rollup-linux-arm64-musl": "4.60.4",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.4",
+        "@rollup/rollup-linux-loong64-musl": "4.60.4",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.4",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.4",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.4",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.4",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.4",
+        "@rollup/rollup-linux-x64-gnu": "4.60.4",
+        "@rollup/rollup-linux-x64-musl": "4.60.4",
+        "@rollup/rollup-openbsd-x64": "4.60.4",
+        "@rollup/rollup-openharmony-arm64": "4.60.4",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.4",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.4",
+        "@rollup/rollup-win32-x64-gnu": "4.60.4",
+        "@rollup/rollup-win32-x64-msvc": "4.60.4",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.27.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+      "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+      "license": "MIT"
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.16",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
+      "integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
+      "license": "MIT",
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.4"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/vite": {
+      "version": "7.3.3",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.3.tgz",
+      "integrity": "sha512-/4XH147Ui7OGTjg3HbdWe5arnZQSbfuRzdr9Ec7TQi5I7R+ir0Rlc9GIvD4v0XZurELqA035KVXJXpR61xhiTA==",
+      "license": "MIT",
+      "dependencies": {
+        "esbuild": "^0.27.0",
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3",
+        "postcss": "^8.5.6",
+        "rollup": "^4.43.0",
+        "tinyglobby": "^0.2.15"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^20.19.0 || >=22.12.0",
+        "jiti": ">=1.21.0",
+        "less": "^4.0.0",
+        "lightningcss": "^1.21.0",
+        "sass": "^1.70.0",
+        "sass-embedded": "^1.70.0",
+        "stylus": ">=0.54.8",
+        "sugarss": "^5.0.0",
+        "terser": "^5.16.0",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "jiti": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "license": "ISC"
+    }
+  }
+}

react-dashboard/package.json

@@ -0,0 +1 @@
+{"name":"openclaw-ops-react-dashboard","version":"0.1.0","private":false,"type":"module","scripts":{"dev":"vite --host 0.0.0.0","build":"vite build","preview":"vite preview --host 0.0.0.0","test":"npm run build"},"dependencies":{"@vitejs/plugin-react":"^5.0.4","vite":"^7.2.4","react":"^19.2.0","react-dom":"^19.2.0","lucide-react":"^0.468.0"}}

react-dashboard/src/App.jsx

@@ -0,0 +1,310 @@
+import { useEffect, useMemo, useState } from 'react';
+import {
+  Activity,
+  AlertTriangle,
+  Bot,
+  CheckCircle2,
+  CirclePause,
+  CirclePlay,
+  ClipboardCheck,
+  ExternalLink,
+  RefreshCw,
+  ShieldCheck,
+  Sparkles,
+  TerminalSquare,
+} from 'lucide-react';
+
+const API_BASE = import.meta.env.VITE_SESSION_AMPLIFIER_BASE_URL || '/session-amplifier';
+const POLL_MS = 15000;
+
+async function fetchJson(path) {
+  const response = await fetch(API_BASE + path);
+  if (!response.ok) {
+    throw new Error(response.status + ' ' + response.statusText);
+  }
+  return response.json();
+}
+
+function formatAge(value) {
+  if (!value) return 'unknown';
+  const at = new Date(value);
+  if (Number.isNaN(at.getTime())) return 'unknown';
+  const seconds = Math.max(0, Math.floor((Date.now() - at.getTime()) / 1000));
+  if (seconds < 60) return seconds + 's';
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return minutes + 'm';
+  const hours = Math.floor(minutes / 60);
+  if (hours < 36) return hours + 'h';
+  return Math.floor(hours / 24) + 'd';
+}
+
+function compactText(value, limit = 110) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  return text.length > limit ? text.slice(0, limit - 1).trimEnd() + '…' : text;
+}
+
+function looksLikeOpaqueId(value) {
+  return /^[0-9a-f]{8}-[0-9a-f-]{27,}$/i.test(String(value || '').trim());
+}
+
+function firstMeaningfulEvent(events = []) {
+  return events.find((event) => {
+    const text = event?.details || event?.summary || event?.clean_text || event?.preview || '';
+    return text && text !== 'assistant' && (event.role === 'user' || event.event_type === 'user_message');
+  }) || events.find((event) => {
+    const text = event?.details || event?.summary || event?.clean_text || event?.preview || '';
+    return text && text !== 'assistant';
+  });
+}
+
+function sessionTextLabel(event) {
+  if (!event) return '';
+  const raw = event.details || event.summary || event.clean_text || event.preview || '';
+  const firstLine = String(raw).split('\n').find((line) => line.trim()) || '';
+  const cronMatch = firstLine.match(/^\[cron:[^\s\]]+\s+([^\]]+)\]\s*(.*)$/);
+  if (cronMatch) {
+    return compactText(cronMatch[1] + ': ' + cronMatch[2], 96);
+  }
+  return compactText(firstLine.replace(/^#+\s*/, ''), 96);
+}
+
+function quotedHint(event) {
+  if (!event) return '';
+  const raw = event.details || event.summary || event.clean_text || event.preview || '';
+  const quote = String(raw).match(/["“']([^"”']{8,130})["”']/);
+  if (quote?.[1]) return compactText('"' + quote[1] + '"', 120);
+  const label = sessionTextLabel(event);
+  return label ? compactText('"' + label + '"', 120) : '';
+}
+
+function shortSessionId(session) {
+  return String(session.session_id || '').slice(0, 8) || 'unknown';
+}
+
+function pickTitle(session, events = []) {
+  const configuredTitle = (
+    session.display_title ||
+    session.displayTitle ||
+    session.display_name ||
+    session.displayName ||
+    session.origin_label
+  );
+  if (configuredTitle && !looksLikeOpaqueId(configuredTitle)) {
+    return { title: configuredTitle, hint: quotedHint(firstMeaningfulEvent(events)) };
+  }
+  const firstEvent = firstMeaningfulEvent(events);
+  const derivedTitle = sessionTextLabel(firstEvent);
+  return {
+    title: derivedTitle || 'Session ' + shortSessionId(session),
+    hint: quotedHint(firstEvent),
+  };
+}
+
+function deriveState(session, events = []) {
+  if (session.derived_state) return session.derived_state;
+  if (session.health === 'error') return 'error';
+  const latest = [...events].reverse().find(Boolean);
+  if (!latest) return 'idle';
+  if (latest.is_error) return 'error';
+  if (latest.tool_name) return 'active';
+  if ((latest.preview || latest.clean_text || '').toLowerCase().includes('permission')) return 'waiting';
+  return latest.role === 'assistant' || latest.role === 'user' ? 'active' : 'idle';
+}
+
+function stateMeta(state, needsPermission) {
+  if (needsPermission || state === 'waiting') {
+    return { label: 'Waiting', tone: 'waiting', Icon: CirclePause };
+  }
+  if (state === 'active') return { label: 'Active', tone: 'active', Icon: Activity };
+  if (state === 'error') return { label: 'Error', tone: 'error', Icon: AlertTriangle };
+  return { label: 'Idle', tone: 'idle', Icon: CheckCircle2 };
+}
+
+function MetricCard({ icon: Icon, label, value, sublabel, tone = 'neutral' }) {
+  return (
+    <section className={'metric metric--' + tone}>
+      <div className="metric__icon"><Icon size={18} /></div>
+      <div>
+        <div className="metric__value">{value}</div>
+        <div className="metric__label">{label}</div>
+        {sublabel ? <div className="metric__sublabel">{sublabel}</div> : null}
+      </div>
+    </section>
+  );
+}
+
+function SessionCard({ session, events }) {
+  const state = deriveState(session, events);
+  const meta = stateMeta(state, session.needs_permission);
+  const latest = [...events].reverse().find(Boolean);
+  const currentTool = session.current_tool_name || latest?.tool_name || 'none';
+  const { title, hint } = pickTitle(session, events);
+
+  return (
+    <article className={'session-card session-card--' + meta.tone}>
+      <header className="session-card__head">
+        <div className="session-card__identity">
+          <span className={'status-pill status-pill--' + meta.tone}>
+            <meta.Icon size={14} />
+            {meta.label}
+          </span>
+          <h2 title={title}>{title}</h2>
+          {hint ? <p className="session-card__quote">{hint}</p> : null}
+        </div>
+        <span className="session-card__age">{formatAge(session.last_activity_at || session.updated_at || latest?.timestamp)}</span>
+      </header>
+
+      <div className="session-card__meta">
+        <span><Bot size={14} />{session.agent_id || 'unknown'}</span>
+        <span><TerminalSquare size={14} />{currentTool}</span>
+        <span><Activity size={14} />{shortSessionId(session)} · {events.length} events</span>
+      </div>
+
+      <p className="session-card__preview">
+        {latest?.preview || latest?.clean_text || session.active_reason || 'No recent transcript preview'}
+      </p>
+
+      <footer className="session-card__actions">
+        <button type="button" title="Open transcript when a route is wired" disabled>
+          <ExternalLink size={15} />
+          Open
+        </button>
+        <button type="button" title="Run control requires an action endpoint" disabled>
+          <CirclePlay size={15} />
+          Run
+        </button>
+        <button type="button" title="Pause/resume requires an action endpoint" disabled>
+          <CirclePause size={15} />
+          Pause
+        </button>
+      </footer>
+    </article>
+  );
+}
+
+function App() {
+  const [health, setHealth] = useState(null);
+  const [bulk, setBulk] = useState({ sessions: [], activity: {} });
+  const [skills, setSkills] = useState(null);
+  const [error, setError] = useState('');
+  const [loading, setLoading] = useState(true);
+
+  async function refresh() {
+    setError('');
+    try {
+      const results = await Promise.allSettled([
+        fetchJson('/health'),
+        fetchJson('/sessions/active-bulk?limit=30&activity_limit=80'),
+        fetchJson('/review/skills'),
+      ]);
+      const [healthResult, bulkResult, skillsResult] = results;
+      if (healthResult.status === 'fulfilled') setHealth(healthResult.value);
+      if (bulkResult.status === 'fulfilled') setBulk(bulkResult.value);
+      if (skillsResult.status === 'fulfilled') setSkills(skillsResult.value);
+      const rejected = [healthResult, bulkResult].find((result) => result.status === 'rejected');
+      if (rejected) throw rejected.reason;
+    } catch (err) {
+      setError(err.message || String(err));
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  useEffect(() => {
+    refresh();
+    const timer = window.setInterval(refresh, POLL_MS);
+    return () => window.clearInterval(timer);
+  }, []);
+
+  const sessions = bulk.sessions || [];
+  const activity = bulk.activity || {};
+  const metrics = useMemo(() => {
+    const states = sessions.map((session) => deriveState(session, activity[session.session_id] || []));
+    const active = states.filter((state) => state === 'active').length;
+    const waiting = sessions.filter((session, index) => session.needs_permission || states[index] === 'waiting').length;
+    const errors = states.filter((state) => state === 'error').length;
+    const toolHeavy = sessions.filter((session) => (activity[session.session_id] || []).filter((row) => row.tool_name).length >= 5).length;
+    const candidateCount = Array.isArray(skills?.candidates) ? skills.candidates.length : Array.isArray(skills?.recommendations) ? skills.recommendations.length : 0;
+    return { active, waiting, errors, toolHeavy, candidateCount };
+  }, [sessions, activity, skills]);
+
+  return (
+    <main className="app-shell">
+      <header className="topbar">
+        <div>
+          <p className="eyebrow">OpenClaw Ops</p>
+          <h1>Action Dashboard</h1>
+        </div>
+        <button className="refresh-button" type="button" onClick={refresh}>
+          <RefreshCw size={16} className={loading ? 'spin' : ''} />
+          Refresh
+        </button>
+      </header>
+
+      {error ? (
+        <section className="alert">
+          <AlertTriangle size={16} />
+          <span>{error}</span>
+        </section>
+      ) : null}
+
+      <section className="metrics-grid">
+        <MetricCard icon={ShieldCheck} label="Amplifier" value={health?.status || 'unknown'} sublabel={(health?.sessions ?? 0) + ' indexed sessions'} tone={health?.status === 'ok' ? 'good' : 'warn'} />
+        <MetricCard icon={Activity} label="Active" value={metrics.active} sublabel={sessions.length + ' recent sessions'} tone="info" />
+        <MetricCard icon={CirclePause} label="Waiting" value={metrics.waiting} sublabel="permission or stalled state" tone={metrics.waiting ? 'warn' : 'neutral'} />
+        <MetricCard icon={AlertTriangle} label="Errors" value={metrics.errors} sublabel="recent session state" tone={metrics.errors ? 'bad' : 'neutral'} />
+        <MetricCard icon={TerminalSquare} label="Tool Heavy" value={metrics.toolHeavy} sublabel="5+ tool events" tone="neutral" />
+        <MetricCard icon={ClipboardCheck} label="Skill Signals" value={metrics.candidateCount || 'review'} sublabel="from skill review API" tone="neutral" />
+      </section>
+
+      <section className="workspace-grid">
+        <section className="panel panel--wide">
+          <div className="panel__head">
+            <h2>Live Sessions</h2>
+            <span>{bulk.generated_at ? 'Updated ' + formatAge(bulk.generated_at) + ' ago' : 'Not loaded'}</span>
+          </div>
+          <div className="sessions-grid">
+            {sessions.length ? (
+              sessions.map((session) => (
+                <SessionCard
+                  key={session.session_id}
+                  session={session}
+                  events={activity[session.session_id] || []}
+                />
+              ))
+            ) : (
+              <div className="empty-state">
+                <Sparkles size={18} />
+                <span>No recent sessions returned.</span>
+              </div>
+            )}
+          </div>
+        </section>
+
+        <aside className="panel">
+          <div className="panel__head">
+            <h2>Promotion Lane</h2>
+            <span>advisory</span>
+          </div>
+          <div className="lane-list">
+            <div className="lane-row">
+              <ShieldCheck size={16} />
+              <span>Installed skills may be used automatically when the match is safe.</span>
+            </div>
+            <div className="lane-row">
+              <ClipboardCheck size={16} />
+              <span>New installs, agent allowlists, and config changes stay approval-gated.</span>
+            </div>
+            <div className="lane-row">
+              <ExternalLink size={16} />
+              <span>Approval packets are summarized by scripts/openclaw_skill_approval_status.py.</span>
+            </div>
+          </div>
+        </aside>
+      </section>
+    </main>
+  );
+}
+
+export default App;

react-dashboard/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import App from './App.jsx';
+import './styles.css';
+
+createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+);

react-dashboard/src/styles.css

@@ -0,0 +1,331 @@
+:root {
+  color-scheme: dark;
+  font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  background: #111318;
+  color: #edf1f7;
+  font-synthesis: none;
+  text-rendering: optimizeLegibility;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  min-width: 320px;
+  background: #111318;
+}
+
+button { font: inherit; }
+
+.app-shell {
+  width: min(1480px, calc(100vw - 32px));
+  margin: 0 auto;
+  padding: 24px 0 36px;
+}
+
+.topbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 20px;
+}
+
+.eyebrow {
+  margin: 0 0 4px;
+  color: #9aa8bb;
+  font-size: 0.78rem;
+  font-weight: 700;
+  letter-spacing: 0;
+  text-transform: uppercase;
+}
+
+h1, h2, p { margin: 0; }
+
+h1 {
+  font-size: clamp(1.7rem, 3vw, 2.35rem);
+  line-height: 1.05;
+  letter-spacing: 0;
+}
+
+.refresh-button,
+.session-card__actions button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 7px;
+  min-height: 36px;
+  border: 1px solid #303847;
+  border-radius: 7px;
+  background: #191d25;
+  color: #edf1f7;
+  cursor: pointer;
+}
+
+.refresh-button { padding: 0 14px; }
+
+.session-card__actions button {
+  width: 100%;
+  padding: 0 10px;
+}
+
+.session-card__actions button:disabled {
+  cursor: not-allowed;
+  color: #7f8ca0;
+  background: #151922;
+}
+
+.alert {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  min-height: 42px;
+  margin-bottom: 16px;
+  padding: 0 12px;
+  border: 1px solid #8a5630;
+  border-radius: 7px;
+  background: #231a14;
+  color: #ffbf80;
+}
+
+.metrics-grid {
+  display: grid;
+  grid-template-columns: repeat(6, minmax(0, 1fr));
+  gap: 12px;
+  margin-bottom: 16px;
+}
+
+.metric,
+.panel,
+.session-card {
+  border: 1px solid #2a313f;
+  border-radius: 8px;
+  background: #171b23;
+}
+
+.metric {
+  display: grid;
+  grid-template-columns: 32px minmax(0, 1fr);
+  gap: 10px;
+  min-height: 96px;
+  padding: 14px;
+}
+
+.metric__icon {
+  display: grid;
+  width: 32px;
+  height: 32px;
+  place-items: center;
+  border-radius: 7px;
+  background: #202733;
+  color: #9fb9ff;
+}
+
+.metric__value {
+  font-size: 1.45rem;
+  font-weight: 800;
+  line-height: 1.05;
+}
+
+.metric__label {
+  margin-top: 4px;
+  color: #d6deeb;
+  font-weight: 700;
+}
+
+.metric__sublabel {
+  margin-top: 5px;
+  color: #8e9caf;
+  font-size: 0.82rem;
+  line-height: 1.25;
+}
+
+.metric--good .metric__icon,
+.status-pill--idle { color: #6ee7a8; }
+
+.metric--warn .metric__icon,
+.status-pill--waiting { color: #ffd166; }
+
+.metric--bad .metric__icon,
+.status-pill--error { color: #ff8f8f; }
+
+.metric--info .metric__icon,
+.status-pill--active { color: #8ec7ff; }
+
+.workspace-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) 360px;
+  gap: 16px;
+  align-items: start;
+}
+
+.panel { padding: 16px; }
+
+.panel__head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 14px;
+}
+
+.panel__head h2,
+.session-card h2 {
+  font-size: 1rem;
+  letter-spacing: 0;
+}
+
+.panel__head span,
+.session-card__age {
+  color: #8794a8;
+  font-size: 0.82rem;
+  white-space: nowrap;
+}
+
+.sessions-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+}
+
+.session-card {
+  display: flex;
+  min-height: 214px;
+  flex-direction: column;
+  padding: 14px;
+}
+
+.session-card--active { border-color: #315c88; }
+.session-card--waiting { border-color: #816632; }
+.session-card--error { border-color: #8a3f3f; }
+
+.session-card__head {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.session-card__identity { min-width: 0; }
+
+.session-card h2 {
+  margin-top: 8px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.session-card__quote {
+  margin-top: 5px;
+  overflow: hidden;
+  color: #9faabd;
+  font-size: 0.82rem;
+  line-height: 1.3;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.status-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  min-height: 24px;
+  padding: 0 8px;
+  border-radius: 999px;
+  background: #202733;
+  font-size: 0.78rem;
+  font-weight: 800;
+}
+
+.session-card__meta {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+  margin-bottom: 12px;
+}
+
+.session-card__meta span {
+  display: inline-flex;
+  min-width: 0;
+  align-items: center;
+  gap: 6px;
+  overflow: hidden;
+  color: #a9b5c7;
+  font-size: 0.82rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.session-card__preview {
+  display: -webkit-box;
+  flex: 1;
+  overflow: hidden;
+  color: #c4ccda;
+  font-size: 0.9rem;
+  line-height: 1.42;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 3;
+}
+
+.session-card__actions {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 8px;
+  margin-top: 14px;
+}
+
+.lane-list { display: grid; gap: 10px; }
+
+.lane-row,
+.empty-state {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  color: #c4ccda;
+  line-height: 1.35;
+}
+
+.lane-row {
+  min-height: 46px;
+  padding: 10px;
+  border: 1px solid #2a313f;
+  border-radius: 7px;
+  background: #141820;
+}
+
+.empty-state {
+  min-height: 130px;
+  justify-content: center;
+  border: 1px dashed #364154;
+  border-radius: 8px;
+}
+
+.spin { animation: spin 0.9s linear infinite; }
+
+@keyframes spin {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+
+@media (max-width: 1120px) {
+  .metrics-grid { grid-template-columns: repeat(3, minmax(0, 1fr)); }
+  .workspace-grid { grid-template-columns: 1fr; }
+}
+
+@media (max-width: 760px) {
+  .app-shell {
+    width: min(100vw - 20px, 720px);
+    padding-top: 16px;
+  }
+
+  .topbar {
+    align-items: flex-start;
+    flex-direction: column;
+  }
+
+  .metrics-grid,
+  .sessions-grid { grid-template-columns: 1fr; }
+
+  .session-card__meta,
+  .session-card__actions { grid-template-columns: 1fr; }
+}

react-dashboard/vite.config.js

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  base: process.env.VITE_BASE_PATH || '/',
+  server: {
+    port: 5177,
+    strictPort: false,
+    proxy: {
+      '/session-amplifier': {
+        target: process.env.SESSION_AMPLIFIER_BASE_URL || 'http://localhost:8477',
+        changeOrigin: true,
+        rewrite: (path) => path.replace(/^\/session-amplifier/, ''),
+      },
+    },
+  },
+});

requirements.txt

@@ -0,0 +1,2 @@
+streamlit==1.26.0
+