init microgrid dispatch agent

.env

@@ -0,0 +1,3 @@
+SILICONFLOW_API_KEY=your_key_here
+SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1
+SILICONFLOW_MODEL=deepseek-ai/DeepSeek-V3

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+instance/
+.env
+.DS_Store

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN mkdir -p instance
+RUN chmod 777 instance
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+EXPOSE 7860
+
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app"]

README.md

@@ -0,0 +1,43 @@
+---
+short_description: 微电网调度闭环智能体
+---
+
+# 微电网调度闭环智能体
+
+面向新能源微电网的闭环调度系统，包含推理/决策、工具行动、状态记忆、校验/验收、迭代与回放。适用于园区、工厂、冷链与分布式能源场景，支持移动端浏览。
+
+## 功能亮点
+- 多智能体协同：规划、风险、优化三段式决策
+- 工具行动：负荷预测、电价/碳价、并网约束模拟
+- 状态记忆：持久化最近调度策略与KPI
+- 校验与迭代：自动检查供需/并网/SOC并迭代修正
+- 回放机制：完整日志追溯
+- Markdown 展示：前端内置解析器
+
+## 快速启动
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+浏览器访问：http://localhost:7860
+
+## 环境变量
+
+支持硅基流模型服务（可选）：
+
+```bash
+SILICONFLOW_API_KEY=你的key
+SILICONFLOW_BASE_URL=https://api.siliconflow.cn/v1
+SILICONFLOW_MODEL=deepseek-ai/DeepSeek-V3
+```
+
+未配置时自动进入离线模拟模式。
+
+## Docker 运行
+
+```bash
+docker build -t microgrid-dispatch-agent .
+docker run -p 7860:7860 microgrid-dispatch-agent
+```

app.py

@@ -0,0 +1,740 @@
+import os
+import json
+import uuid
+import math
+import random
+import sqlite3
+import datetime
+import hashlib
+import requests
+from flask import Flask, render_template, request, jsonify, g, send_file
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+INSTANCE_DIR = os.path.join(BASE_DIR, "instance")
+os.makedirs(INSTANCE_DIR, exist_ok=True)
+
+app = Flask(__name__)
+app.config["DATABASE"] = os.path.join(INSTANCE_DIR, "microgrid.db")
+app.config["SILICONFLOW_API_KEY"] = os.getenv("SILICONFLOW_API_KEY", "").strip()
+app.config["SILICONFLOW_BASE_URL"] = os.getenv("SILICONFLOW_BASE_URL", "https://api.siliconflow.cn/v1").strip()
+app.config["SILICONFLOW_MODEL"] = os.getenv("SILICONFLOW_MODEL", "deepseek-ai/DeepSeek-V3").strip()
+
+
+def get_db():
+    db = getattr(g, "_database", None)
+    if db is None:
+        db = g._database = sqlite3.connect(app.config["DATABASE"])
+        db.row_factory = sqlite3.Row
+    return db
+
+
+@app.teardown_appcontext
+def close_connection(exception):
+    db = getattr(g, "_database", None)
+    if db is not None:
+        db.close()
+
+
+def now_ts():
+    return datetime.datetime.now().isoformat()
+
+
+def init_db():
+    db = sqlite3.connect(app.config["DATABASE"])
+    cursor = db.cursor()
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS cycles (
+            id TEXT PRIMARY KEY,
+            title TEXT,
+            scenario TEXT,
+            result TEXT,
+            status TEXT,
+            created_at TEXT
+        )
+        """
+    )
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS logs (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            cycle_id TEXT,
+            role TEXT,
+            content TEXT,
+            created_at TEXT
+        )
+        """
+    )
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS memories (
+            key TEXT PRIMARY KEY,
+            value TEXT,
+            updated_at TEXT
+        )
+        """
+    )
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS validations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            cycle_id TEXT,
+            passed INTEGER,
+            issues TEXT,
+            created_at TEXT
+        )
+        """
+    )
+    cursor.execute(
+        """
+        CREATE TABLE IF NOT EXISTS files (
+            id TEXT PRIMARY KEY,
+            filename TEXT,
+            size_bytes INTEGER,
+            sha256 TEXT,
+            content_type TEXT,
+            is_binary INTEGER,
+            storage_path TEXT,
+            created_at TEXT
+        )
+        """
+    )
+    db.commit()
+    cursor.execute("SELECT COUNT(1) FROM cycles")
+    count = cursor.fetchone()[0]
+    if count == 0:
+        sample_id = str(uuid.uuid4())
+        scenario = {
+            "title": "示例：园区A峰值调度",
+            "demand_mw": 120,
+            "solar_mw": 42,
+            "wind_mw": 28,
+            "storage_mwh": 80,
+            "storage_soc": 0.45,
+            "priority": "成本优先",
+            "notes": "示例备注：保障冷链负荷，允许需求响应10%。",
+        }
+        db.execute(
+            "INSERT INTO cycles (id, title, scenario, result, status, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+            (
+                sample_id,
+                scenario["title"],
+                json.dumps(scenario, ensure_ascii=False),
+                json.dumps(
+                    {
+                        "scenario": scenario,
+                        "decision": {
+                            "dispatch": {
+                                "solar_mw": 42,
+                                "wind_mw": 28,
+                                "storage_discharge_mw": 18,
+                                "storage_charge_mw": 0,
+                                "grid_import_mw": 32,
+                                "grid_export_mw": 0,
+                                "demand_response_mw": 0,
+                                "storage_soc_next": 0.22,
+                            },
+                            "kpi": {"cost": 27.5, "carbon": 16.8, "reliability": 0.99},
+                            "notes": "示例调度已完成",
+                        },
+                        "validation": {"passed": True, "issues": ["校验通过"]},
+                        "memory": {
+                            "last_priority": "成本优先",
+                            "last_cost": 27.5,
+                            "last_carbon": 16.8,
+                            "last_reliability": 0.99,
+                            "iterations": 0,
+                        },
+                        "iterations": 0,
+                    },
+                    ensure_ascii=False,
+                ),
+                "completed",
+                now_ts(),
+            ),
+        )
+    db.commit()
+    db.close()
+
+
+init_db()
+
+
+def log_event(cycle_id, role, content):
+    db = get_db()
+    db.execute(
+        "INSERT INTO logs (cycle_id, role, content, created_at) VALUES (?, ?, ?, ?)",
+        (cycle_id, role, content, now_ts()),
+    )
+    db.commit()
+
+
+def set_memory(key, value):
+    db = get_db()
+    row = db.execute("SELECT key FROM memories WHERE key = ?", (key,)).fetchone()
+    payload = json.dumps(value, ensure_ascii=False)
+    if row:
+        db.execute("UPDATE memories SET value = ?, updated_at = ? WHERE key = ?", (payload, now_ts(), key))
+    else:
+        db.execute("INSERT INTO memories (key, value, updated_at) VALUES (?, ?, ?)", (key, payload, now_ts()))
+    db.commit()
+
+
+def get_memory(key, default=None):
+    db = get_db()
+    row = db.execute("SELECT value FROM memories WHERE key = ?", (key,)).fetchone()
+    if not row:
+        return default
+    try:
+        return json.loads(row["value"])
+    except json.JSONDecodeError:
+        return default
+
+
+def call_llm_json(system_prompt, user_prompt):
+    api_key = app.config["SILICONFLOW_API_KEY"]
+    if not api_key:
+        return None
+    url = f"{app.config['SILICONFLOW_BASE_URL']}/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    payload = {
+        "model": app.config["SILICONFLOW_MODEL"],
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+        "temperature": 0.2,
+        "max_tokens": 900,
+        "response_format": {"type": "json_object"},
+    }
+    try:
+        response = requests.post(url, headers=headers, json=payload, timeout=25)
+        response.raise_for_status()
+        data = response.json()
+        content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+        return json.loads(content)
+    except Exception:
+        return None
+
+
+def tool_forecast(scenario):
+    demand = scenario["demand_mw"]
+    solar = scenario["solar_mw"]
+    wind = scenario["wind_mw"]
+    forecast = []
+    for hour in range(6):
+        factor = 0.92 + random.random() * 0.16
+        forecast.append(
+            {
+                "hour": hour + 1,
+                "demand_mw": round(demand * factor, 2),
+                "solar_mw": round(solar * (0.7 + random.random() * 0.4), 2),
+                "wind_mw": round(wind * (0.6 + random.random() * 0.5), 2),
+            }
+        )
+    return forecast
+
+
+def tool_price():
+    schedule = []
+    base = 0.52 + random.random() * 0.12
+    for hour in range(6):
+        peak = 1.25 if hour in (2, 3, 4) else 1.0
+        schedule.append(round(base * peak + random.random() * 0.08, 3))
+    return {
+        "energy_price": round(base, 3),
+        "carbon_price": round(0.08 + random.random() * 0.05, 3),
+        "schedule": schedule,
+    }
+
+
+def tool_grid_constraints():
+    return {"max_import_mw": 80.0, "max_export_mw": 40.0}
+
+
+def tool_demand_response():
+    return {"max_response_mw": 12.0, "response_cost": 0.15}
+
+
+def planner_agent(scenario, tools):
+    system_prompt = "你是微电网调度规划智能体，输出JSON，包含目标、优先级、步骤。"
+    user_prompt = f"场景: {json.dumps(scenario, ensure_ascii=False)}\n工具: {json.dumps(tools, ensure_ascii=False)}"
+    result = call_llm_json(system_prompt, user_prompt)
+    if result:
+        return result
+    priority = scenario.get("priority", "成本优先")
+    return {
+        "目标": "在满足负荷的前提下优化成本与碳排",
+        "优先级": priority,
+        "步骤": [
+            "读取需求与可再生出力",
+            "评估储能SOC与可调度能力",
+            "结合电价与碳价决定充放电与并网",
+            "生成调度方案并进入校验",
+        ],
+    }
+
+
+def risk_agent(scenario, tools, plan):
+    system_prompt = "你是电力系统风险评估智能体，输出JSON，包含风险列表与缓释建议。"
+    user_prompt = f"计划: {json.dumps(plan, ensure_ascii=False)}\n场景: {json.dumps(scenario, ensure_ascii=False)}"
+    result = call_llm_json(system_prompt, user_prompt)
+    if result:
+        return result
+    risks = []
+    if scenario["storage_soc"] < 0.2:
+        risks.append("储能SOC偏低，抗波动能力下降")
+    if scenario["demand_mw"] > 120:
+        risks.append("负荷偏高，可能逼近并网上限")
+    return {
+        "风险": risks or ["暂无明显风险"],
+        "缓释": "必要时启用需求响应与负荷切分策略",
+    }
+
+
+def optimizer_agent(scenario, tools, plan, risk):
+    demand = scenario["demand_mw"]
+    solar = scenario["solar_mw"]
+    wind = scenario["wind_mw"]
+    storage_mwh = scenario["storage_mwh"]
+    storage_soc = scenario["storage_soc"]
+    grid_limit = tools["grid"]["max_import_mw"]
+    export_limit = tools["grid"]["max_export_mw"]
+    response_limit = tools["response"]["max_response_mw"]
+
+    max_rate = storage_mwh * 0.5
+    available_discharge = storage_mwh * storage_soc
+    forecast = tools["forecast"]
+    schedule_price = tools["price"]["schedule"]
+    carbon_price = tools["price"]["carbon_price"]
+    grid_carbon = 0.72
+    priority = scenario.get("priority", "成本优先")
+    weight_cost = 0.5
+    weight_carbon = 0.3
+    weight_reliability = 0.2
+    if priority == "碳优先":
+        weight_cost, weight_carbon, weight_reliability = 0.2, 0.6, 0.2
+    elif priority == "可靠性优先":
+        weight_cost, weight_carbon, weight_reliability = 0.2, 0.2, 0.6
+
+    hourly = []
+    total_cost = 0.0
+    total_carbon = 0.0
+    total_demand = 0.0
+    total_unserved = 0.0
+    soc = storage_soc
+
+    for idx, point in enumerate(forecast):
+        hour_price = schedule_price[idx]
+        demand_h = point["demand_mw"]
+        solar_h = point["solar_mw"]
+        wind_h = point["wind_mw"]
+        total_demand += demand_h
+
+        max_rate_h = storage_mwh * 0.5
+        available_discharge_h = storage_mwh * soc
+        net = demand_h - solar_h - wind_h
+
+        if priority == "碳优先":
+            discharge = min(max_rate_h, available_discharge_h, max(0.0, net * 0.8))
+        elif priority == "成本优先" and hour_price < 0.6:
+            discharge = min(max_rate_h * 0.4, available_discharge_h, max(0.0, net))
+        else:
+            discharge = min(max_rate_h, available_discharge_h, max(0.0, net))
+
+        remaining = net - discharge
+        grid_import = min(max(0.0, remaining), grid_limit)
+        demand_response = min(response_limit, max(0.0, remaining - grid_import))
+        unserved = max(0.0, remaining - grid_import - demand_response)
+
+        surplus = max(0.0, solar_h + wind_h + discharge - demand_h)
+        charge = min(max_rate_h, storage_mwh * (1 - soc), surplus)
+        export = max(0.0, min(export_limit, surplus - charge))
+
+        soc = soc + (charge - discharge) / storage_mwh if storage_mwh > 0 else soc
+        soc = max(0.0, min(1.0, soc))
+
+        cost = grid_import * hour_price + demand_response * tools["response"]["response_cost"]
+        carbon = grid_import * grid_carbon - (solar_h + wind_h) * 0.18
+        total_cost += cost
+        total_carbon += carbon
+        total_unserved += unserved
+
+        hourly.append(
+            {
+                "hour": point["hour"],
+                "demand_mw": round(demand_h, 2),
+                "solar_mw": round(solar_h, 2),
+                "wind_mw": round(wind_h, 2),
+                "storage_discharge_mw": round(discharge, 2),
+                "storage_charge_mw": round(charge, 2),
+                "grid_import_mw": round(grid_import, 2),
+                "grid_export_mw": round(export, 2),
+                "demand_response_mw": round(demand_response, 2),
+                "unserved_mw": round(unserved, 2),
+                "soc": round(soc, 3),
+                "price": hour_price,
+            }
+        )
+
+    reliability = round(1 - (total_unserved / total_demand if total_demand > 0 else 0), 3)
+    cost = round(total_cost, 3)
+    carbon = round(total_carbon, 3)
+    score = round((100 - cost) * weight_cost + (100 - abs(carbon)) * weight_carbon + reliability * 100 * weight_reliability, 2)
+
+    return {
+        "dispatch": {
+            "solar_mw": round(solar, 2),
+            "wind_mw": round(wind, 2),
+            "storage_soc_next": round(soc, 3),
+            "hourly": hourly,
+        },
+        "kpi": {"cost": cost, "carbon": carbon, "reliability": reliability, "score": score},
+        "notes": "已综合考虑电价、碳价、需求响应与并网约束",
+        "plan": plan,
+        "risk": risk,
+    }
+
+
+def validate_dispatch(scenario, decision, tools):
+    issues = []
+    hourly = decision["dispatch"].get("hourly", [])
+    grid_limit = tools["grid"]["max_import_mw"]
+    for point in hourly:
+        supplied = (
+            point["solar_mw"]
+            + point["wind_mw"]
+            + point["storage_discharge_mw"]
+            + point["grid_import_mw"]
+            - point["storage_charge_mw"]
+            - point["grid_export_mw"]
+        )
+        if supplied + 0.01 < point["demand_mw"]:
+            issues.append(f"小时{point['hour']}供给不足")
+        if point["grid_import_mw"] > grid_limit + 0.01:
+            issues.append(f"小时{point['hour']}并网功率超限")
+        if not (0 <= point["soc"] <= 1):
+            issues.append(f"小时{point['hour']}储能SOC越界")
+    passed = len(issues) == 0
+    return {"passed": passed, "issues": issues or ["校验通过"]}
+
+
+def iterate_adjustment(scenario, decision, tools):
+    dispatch = decision["dispatch"].copy()
+    hourly = []
+    grid_limit = tools["grid"]["max_import_mw"]
+    for point in dispatch.get("hourly", []):
+        if point["unserved_mw"] > 0:
+            extra = min(point["unserved_mw"], grid_limit - point["grid_import_mw"])
+            point["grid_import_mw"] = round(point["grid_import_mw"] + extra, 2)
+            point["unserved_mw"] = round(max(0.0, point["unserved_mw"] - extra), 2)
+        hourly.append(point)
+    dispatch["hourly"] = hourly
+    decision["dispatch"] = dispatch
+    return decision
+
+
+def run_cycle(payload):
+    cycle_id = str(uuid.uuid4())
+    title = payload.get("title", "未命名调度")
+    scenario = {
+        "title": title,
+        "demand_mw": float(payload.get("demand_mw", 120)),
+        "solar_mw": float(payload.get("solar_mw", 40)),
+        "wind_mw": float(payload.get("wind_mw", 30)),
+        "storage_mwh": float(payload.get("storage_mwh", 80)),
+        "storage_soc": float(payload.get("storage_soc", 0.45)),
+        "priority": payload.get("priority", "成本优先"),
+        "notes": payload.get("notes", ""),
+    }
+
+    tools = {
+        "forecast": tool_forecast(scenario),
+        "price": tool_price(),
+        "grid": tool_grid_constraints(),
+        "response": tool_demand_response(),
+    }
+
+    db = get_db()
+    db.execute(
+        "INSERT INTO cycles (id, title, scenario, result, status, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+        (cycle_id, title, json.dumps(scenario, ensure_ascii=False), "{}", "running", now_ts()),
+    )
+    db.commit()
+
+    log_event(cycle_id, "system", "进入闭环：推理/决策/工具行动/状态记忆/校验/迭代")
+    log_event(cycle_id, "tool_action", f"工具预测: {json.dumps(tools, ensure_ascii=False)}")
+
+    plan = planner_agent(scenario, tools)
+    log_event(cycle_id, "reasoning", json.dumps(plan, ensure_ascii=False))
+
+    risk = risk_agent(scenario, tools, plan)
+    log_event(cycle_id, "reasoning", json.dumps(risk, ensure_ascii=False))
+
+    decision = optimizer_agent(scenario, tools, plan, risk)
+    log_event(cycle_id, "decision", json.dumps(decision, ensure_ascii=False))
+
+    validation = validate_dispatch(scenario, decision, tools)
+    log_event(cycle_id, "validation", json.dumps(validation, ensure_ascii=False))
+
+    iteration_count = 0
+    while not validation["passed"] and iteration_count < 2:
+        iteration_count += 1
+        decision = iterate_adjustment(scenario, decision, tools)
+        log_event(cycle_id, "iteration", f"第{iteration_count}次迭代调整")
+        validation = validate_dispatch(scenario, decision, tools)
+        log_event(cycle_id, "validation", json.dumps(validation, ensure_ascii=False))
+
+    memory_snapshot = {
+        "last_priority": scenario["priority"],
+        "last_cost": decision["kpi"]["cost"],
+        "last_carbon": decision["kpi"]["carbon"],
+        "last_reliability": decision["kpi"]["reliability"],
+        "iterations": iteration_count,
+        "last_score": decision["kpi"]["score"],
+    }
+    set_memory("microgrid_state", memory_snapshot)
+    log_event(cycle_id, "memory", json.dumps(memory_snapshot, ensure_ascii=False))
+
+    db.execute(
+        "INSERT INTO validations (cycle_id, passed, issues, created_at) VALUES (?, ?, ?, ?)",
+        (cycle_id, 1 if validation["passed"] else 0, json.dumps(validation["issues"], ensure_ascii=False), now_ts()),
+    )
+    db.execute(
+        "UPDATE cycles SET result = ?, status = ? WHERE id = ?",
+        (
+            json.dumps(
+                {
+                    "scenario": scenario,
+                    "decision": decision,
+                    "validation": validation,
+                    "memory": memory_snapshot,
+                    "iterations": iteration_count,
+                },
+                ensure_ascii=False,
+            ),
+            "completed" if validation["passed"] else "needs_review",
+            cycle_id,
+        ),
+    )
+    db.commit()
+
+    return {
+        "id": cycle_id,
+        "status": "completed" if validation["passed"] else "needs_review",
+        "scenario": scenario,
+        "decision": decision,
+        "validation": validation,
+        "memory": memory_snapshot,
+        "iterations": iteration_count,
+    }
+
+
+@app.route("/")
+def index():
+    return render_template("index.html")
+
+
+@app.route("/api/run_cycle", methods=["POST"])
+def api_run_cycle():
+    payload = request.json or {}
+    result = run_cycle(payload)
+    return jsonify(result)
+
+
+@app.route("/api/cycles", methods=["GET"])
+def api_cycles():
+    db = get_db()
+    rows = db.execute(
+        "SELECT id, title, status, created_at FROM cycles ORDER BY created_at DESC LIMIT 30"
+    ).fetchall()
+    return jsonify(
+        [
+            {
+                "id": row["id"],
+                "title": row["title"],
+                "status": row["status"],
+                "created_at": row["created_at"],
+            }
+            for row in rows
+        ]
+    )
+
+
+@app.route("/api/cycles/<cycle_id>", methods=["GET"])
+def api_cycle_detail(cycle_id):
+    db = get_db()
+    row = db.execute("SELECT * FROM cycles WHERE id = ?", (cycle_id,)).fetchone()
+    if not row:
+        return jsonify({"error": "未找到任务"}), 404
+    result = json.loads(row["result"] or "{}")
+    return jsonify(result)
+
+
+@app.route("/api/replay/<cycle_id>", methods=["GET"])
+def api_replay(cycle_id):
+    db = get_db()
+    logs = db.execute(
+        "SELECT role, content, created_at FROM logs WHERE cycle_id = ? ORDER BY id ASC", (cycle_id,)
+    ).fetchall()
+    return jsonify(
+        [
+            {"role": row["role"], "content": row["content"], "created_at": row["created_at"]}
+            for row in logs
+        ]
+    )
+
+
+@app.route("/api/memory", methods=["GET"])
+def api_memory():
+    snapshot = get_memory("microgrid_state", {})
+    return jsonify(snapshot)
+
+
+@app.route("/api/stats", methods=["GET"])
+def api_stats():
+    db = get_db()
+    rows = db.execute("SELECT result, status, created_at FROM cycles").fetchall()
+    total = len(rows)
+    completed = sum(1 for r in rows if r["status"] == "completed")
+    costs = []
+    carbons = []
+    for row in rows:
+        try:
+            result = json.loads(row["result"] or "{}")
+            kpi = result.get("decision", {}).get("kpi", {})
+            if "cost" in kpi:
+                costs.append(kpi["cost"])
+            if "carbon" in kpi:
+                carbons.append(kpi["carbon"])
+        except Exception:
+            continue
+    return jsonify(
+        {
+            "total": total,
+            "completed": completed,
+            "avg_cost": round(sum(costs) / len(costs), 3) if costs else 0,
+            "avg_carbon": round(sum(carbons) / len(carbons), 3) if carbons else 0,
+            "last_run": rows[0]["created_at"] if rows else "暂无",
+        }
+    )
+
+
+@app.route("/api/scenario_suggest", methods=["GET"])
+def api_scenario_suggest():
+    last = get_memory("microgrid_state", {})
+    return jsonify(
+        {
+            "title": "智能建议场景",
+            "demand_mw": 110 + random.randint(-10, 12),
+            "solar_mw": 45 + random.randint(-8, 6),
+            "wind_mw": 30 + random.randint(-6, 6),
+            "storage_mwh": 90 + random.randint(-15, 15),
+            "storage_soc": round(0.35 + random.random() * 0.45, 2),
+            "priority": last.get("last_priority", "成本优先"),
+            "notes": "建议场景：参考历史记忆与负荷波动生成。",
+        }
+    )
+
+
+def detect_binary(file_path):
+    with open(file_path, "rb") as f:
+        chunk = f.read(1024)
+    return b"\0" in chunk
+
+
+def finalize_file(file_id, filename, storage_path, content_type):
+    size = os.path.getsize(storage_path)
+    sha256_hash = hashlib.sha256()
+    with open(storage_path, "rb") as f:
+        for block in iter(lambda: f.read(4096), b""):
+            sha256_hash.update(block)
+    is_binary = 1 if detect_binary(storage_path) else 0
+    db = get_db()
+    db.execute(
+        "INSERT INTO files (id, filename, size_bytes, sha256, content_type, is_binary, storage_path, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+        (file_id, filename, size, sha256_hash.hexdigest(), content_type or "", is_binary, storage_path, now_ts()),
+    )
+    db.commit()
+    return {
+        "id": file_id,
+        "filename": filename,
+        "size_bytes": size,
+        "sha256": sha256_hash.hexdigest(),
+        "is_binary": bool(is_binary),
+    }
+
+
+@app.route("/api/upload", methods=["POST"])
+def api_upload():
+    if "file" not in request.files:
+        return jsonify({"error": "未检测到文件"}), 400
+    file = request.files["file"]
+    if not file.filename:
+        return jsonify({"error": "文件名为空"}), 400
+    filename = os.path.basename(file.filename)
+    file_id = str(uuid.uuid4())
+    storage_path = os.path.join(INSTANCE_DIR, f"{file_id}_{filename}")
+    file.save(storage_path)
+    payload = finalize_file(file_id, filename, storage_path, file.content_type)
+    return jsonify({"status": "ok", "file": payload})
+
+
+@app.route("/api/upload_chunk", methods=["POST"])
+def api_upload_chunk():
+    file_id = request.headers.get("X-File-Id")
+    filename = request.headers.get("X-File-Name")
+    total = int(request.headers.get("X-Chunk-Total", "1"))
+    index = int(request.headers.get("X-Chunk-Index", "0"))
+    if not file_id or not filename:
+        return jsonify({"error": "缺少文件标识"}), 400
+    chunk = request.data
+    if not chunk:
+        return jsonify({"error": "分片内容为空"}), 400
+    temp_path = os.path.join(INSTANCE_DIR, f"{file_id}.part")
+    with open(temp_path, "ab") as f:
+        f.write(chunk)
+    if index + 1 == total:
+        final_name = os.path.basename(filename)
+        final_path = os.path.join(INSTANCE_DIR, f"{file_id}_{final_name}")
+        os.replace(temp_path, final_path)
+        payload = finalize_file(file_id, final_name, final_path, request.headers.get("X-Content-Type"))
+        return jsonify({"status": "completed", "file": payload})
+    return jsonify({"status": "chunk_received", "index": index})
+
+
+@app.route("/api/files", methods=["GET"])
+def api_files():
+    db = get_db()
+    rows = db.execute(
+        "SELECT id, filename, size_bytes, sha256, is_binary, created_at FROM files ORDER BY created_at DESC LIMIT 50"
+    ).fetchall()
+    return jsonify(
+        [
+            {
+                "id": row["id"],
+                "filename": row["filename"],
+                "size_bytes": row["size_bytes"],
+                "sha256": row["sha256"],
+                "is_binary": bool(row["is_binary"]),
+                "created_at": row["created_at"],
+            }
+            for row in rows
+        ]
+    )
+
+
+@app.route("/api/files/<file_id>", methods=["GET"])
+def api_download(file_id):
+    db = get_db()
+    row = db.execute("SELECT storage_path, filename FROM files WHERE id = ?", (file_id,)).fetchone()
+    if not row:
+        return jsonify({"error": "未找到文件"}), 404
+    return send_file(row["storage_path"], as_attachment=True, download_name=row["filename"])
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=True)

requirements.txt

@@ -0,0 +1,4 @@
+flask==3.0.3
+requests==2.32.3
+python-dotenv==1.0.1
+gunicorn==22.0.0

templates/index.html

@@ -0,0 +1,547 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1" />
+    <title>微电网调度闭环智能体</title>
+    <link rel="preconnect" href="https://cdn.jsdelivr.net" />
+    <script src="https://cdn.jsdelivr.net/npm/markdown-it@14.1.0/dist/markdown-it.min.js"></script>
+    <style>
+      :root {
+        color-scheme: dark;
+        --bg: #070c1f;
+        --surface: rgba(18, 29, 58, 0.75);
+        --stroke: rgba(120, 145, 208, 0.2);
+        --text: #e6eeff;
+        --muted: #9fb2da;
+        --accent: #7dd3fc;
+        --accent-strong: #38bdf8;
+        --warn: #fda4af;
+      }
+      * {
+        box-sizing: border-box;
+      }
+      body {
+        margin: 0;
+        font-family: "PingFang SC", "Microsoft YaHei", system-ui, -apple-system, sans-serif;
+        background: radial-gradient(circle at top, #1a2a6c 0%, #070c1f 60%);
+        color: var(--text);
+      }
+      header {
+        padding: 28px 20px 12px;
+        text-align: center;
+      }
+      header h1 {
+        margin: 0 0 6px;
+        font-size: 26px;
+      }
+      header p {
+        margin: 0;
+        color: var(--muted);
+        font-size: 14px;
+      }
+      main {
+        max-width: 1100px;
+        margin: 0 auto;
+        padding: 16px 16px 40px;
+        display: grid;
+        gap: 16px;
+      }
+      .grid {
+        display: grid;
+        gap: 16px;
+      }
+      .grid.two {
+        grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+      }
+      .card {
+        background: var(--surface);
+        border: 1px solid var(--stroke);
+        border-radius: 16px;
+        padding: 16px;
+        backdrop-filter: blur(14px);
+      }
+      .card h3 {
+        margin-top: 0;
+        font-size: 18px;
+      }
+      label {
+        display: block;
+        margin-bottom: 12px;
+        color: var(--muted);
+        font-size: 13px;
+      }
+      input,
+      select,
+      textarea {
+        width: 100%;
+        margin-top: 6px;
+        padding: 10px 12px;
+        border-radius: 12px;
+        border: 1px solid transparent;
+        background: rgba(8, 16, 38, 0.7);
+        color: var(--text);
+        font-size: 14px;
+      }
+      textarea {
+        min-height: 88px;
+        resize: vertical;
+      }
+      button {
+        padding: 10px 16px;
+        background: linear-gradient(120deg, #0ea5e9, #6366f1);
+        border: none;
+        border-radius: 999px;
+        color: #fff;
+        font-weight: 600;
+        cursor: pointer;
+        width: 100%;
+      }
+      button:disabled {
+        opacity: 0.6;
+        cursor: not-allowed;
+      }
+      .pill {
+        display: inline-block;
+        padding: 4px 10px;
+        border-radius: 999px;
+        background: rgba(125, 211, 252, 0.15);
+        color: var(--accent);
+        font-size: 12px;
+      }
+      .kpi {
+        display: grid;
+        gap: 8px;
+      }
+      .kpi span {
+        color: var(--muted);
+        font-size: 13px;
+      }
+      .kpi strong {
+        font-size: 16px;
+      }
+      .log {
+        background: rgba(10, 18, 40, 0.6);
+        border: 1px solid var(--stroke);
+        border-radius: 12px;
+        padding: 10px 12px;
+        margin-bottom: 8px;
+      }
+      .log header {
+        padding: 0;
+        text-align: left;
+        font-size: 12px;
+        color: var(--muted);
+        margin-bottom: 6px;
+      }
+      .warn {
+        color: var(--warn);
+      }
+      .cycle-list button {
+        width: 100%;
+        margin-bottom: 8px;
+        background: rgba(56, 189, 248, 0.16);
+        color: var(--text);
+      }
+      .toolbar {
+        display: grid;
+        gap: 10px;
+        grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+      }
+      .stat-grid {
+        display: grid;
+        gap: 10px;
+        grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+      }
+      .stat-card {
+        padding: 10px 12px;
+        border-radius: 12px;
+        border: 1px solid var(--stroke);
+        background: rgba(10, 16, 36, 0.55);
+      }
+      .stat-card span {
+        display: block;
+        font-size: 12px;
+        color: var(--muted);
+      }
+      .stat-card strong {
+        font-size: 18px;
+      }
+      @media (max-width: 720px) {
+        header h1 {
+          font-size: 22px;
+        }
+        main {
+          padding: 12px;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>微电网调度闭环智能体</h1>
+      <p>面向新能源微电网的推理/决策/行动/校验/迭代与回放系统</p>
+    </header>
+    <main>
+      <section class="grid two">
+        <article class="card">
+          <h3>新建调度任务</h3>
+          <form id="cycleForm">
+            <label>
+              任务标题
+              <input name="title" placeholder="例如：园区A峰值调度" required />
+            </label>
+            <label>
+              需求负荷（MW��
+              <input name="demand_mw" type="number" step="0.1" value="120" required />
+            </label>
+            <label>
+              光伏出力（MW）
+              <input name="solar_mw" type="number" step="0.1" value="40" required />
+            </label>
+            <label>
+              风电出力（MW）
+              <input name="wind_mw" type="number" step="0.1" value="30" required />
+            </label>
+            <label>
+              储能容量（MWh）
+              <input name="storage_mwh" type="number" step="0.1" value="80" required />
+            </label>
+            <label>
+              储能SOC（0-1）
+              <input name="storage_soc" type="number" step="0.01" value="0.45" required />
+            </label>
+            <label>
+              优先级策略
+              <select name="priority">
+                <option value="成本优先">成本优先</option>
+                <option value="碳优先">碳优先</option>
+                <option value="可靠性优先">可靠性优先</option>
+              </select>
+            </label>
+            <label>
+              业务备注（支持Markdown）
+              <textarea name="notes" placeholder="例如：需要保障冷链仓储负荷、可接受需求响应10%"></textarea>
+            </label>
+            <button type="submit" id="runBtn">生成闭环调度</button>
+          </form>
+          <div style="margin-top: 14px" class="toolbar">
+            <button type="button" id="suggestBtn">生成建议场景</button>
+            <button type="button" id="demoBtn">一键演示</button>
+          </div>
+        </article>
+        <article class="card">
+          <h3>闭环结果概览</h3>
+          <div id="overview">
+            <span class="pill">等待调度</span>
+            <div class="kpi" style="margin-top: 12px">
+              <span>成本</span>
+              <strong id="kpiCost">-</strong>
+              <span>碳排影响</span>
+              <strong id="kpiCarbon">-</strong>
+              <span>可靠性</span>
+              <strong id="kpiReliability">-</strong>
+            </div>
+          </div>
+          <div style="margin-top: 14px">
+            <h4>记忆快照</h4>
+            <div id="memoryBox" class="log"></div>
+          </div>
+        </article>
+      </section>
+
+      <section class="grid two">
+        <article class="card">
+          <h3>调度方案与校验</h3>
+          <div id="planBox" class="log"></div>
+          <div id="riskBox" class="log"></div>
+          <div id="dispatchBox" class="log"></div>
+          <div id="validationBox" class="log"></div>
+        </article>
+        <article class="card">
+          <h3>闭环日志回放</h3>
+          <div id="logList"></div>
+        </article>
+      </section>
+
+      <section class="grid two">
+        <article class="card">
+          <h3>历史调度</h3>
+          <div id="cycleList" class="cycle-list"></div>
+        </article>
+        <article class="card">
+          <h3>Markdown 预览</h3>
+          <div id="markdownPreview" class="log"></div>
+        </article>
+      </section>
+
+      <section class="grid two">
+        <article class="card">
+          <h3>运行统计</h3>
+          <div id="statGrid" class="stat-grid"></div>
+          <button type="button" id="refreshStatsBtn" style="margin-top: 10px">刷新统计</button>
+        </article>
+        <article class="card">
+          <h3>文件与数据集</h3>
+          <div class="toolbar">
+            <input type="file" id="fileInput" />
+            <button type="button" id="uploadBtn">上传文件</button>
+          </div>
+          <progress id="uploadProgress" value="0" max="100" style="width: 100%; margin-top: 10px"></progress>
+          <div id="fileList" style="margin-top: 12px"></div>
+        </article>
+      </section>
+    </main>
+
+    <script>
+      const md = window.markdownit({ html: false, breaks: true, linkify: true });
+      const form = document.getElementById("cycleForm");
+      const runBtn = document.getElementById("runBtn");
+      const suggestBtn = document.getElementById("suggestBtn");
+      const demoBtn = document.getElementById("demoBtn");
+      const kpiCost = document.getElementById("kpiCost");
+      const kpiCarbon = document.getElementById("kpiCarbon");
+      const kpiReliability = document.getElementById("kpiReliability");
+      const dispatchBox = document.getElementById("dispatchBox");
+      const validationBox = document.getElementById("validationBox");
+      const planBox = document.getElementById("planBox");
+      const riskBox = document.getElementById("riskBox");
+      const logList = document.getElementById("logList");
+      const cycleList = document.getElementById("cycleList");
+      const memoryBox = document.getElementById("memoryBox");
+      const markdownPreview = document.getElementById("markdownPreview");
+      const statGrid = document.getElementById("statGrid");
+      const refreshStatsBtn = document.getElementById("refreshStatsBtn");
+      const fileInput = document.getElementById("fileInput");
+      const uploadBtn = document.getElementById("uploadBtn");
+      const uploadProgress = document.getElementById("uploadProgress");
+      const fileList = document.getElementById("fileList");
+
+      function uuid() {
+        if (window.crypto && window.crypto.randomUUID) {
+          return window.crypto.randomUUID();
+        }
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+          const r = (Math.random() * 16) | 0;
+          const v = c === "x" ? r : (r & 0x3) | 0x8;
+          return v.toString(16);
+        });
+      }
+
+      function renderMarkdown(target, content) {
+        target.innerHTML = md.render(content || "暂无内容");
+      }
+
+      function renderDecision(result) {
+        const kpi = result.decision?.kpi || {};
+        kpiCost.textContent = kpi.cost ?? "-";
+        kpiCarbon.textContent = kpi.carbon ?? "-";
+        kpiReliability.textContent = kpi.reliability ?? "-";
+        const plan = result.decision?.plan || result.plan || {};
+        const risk = result.decision?.risk || result.risk || {};
+        renderMarkdown(planBox, "#### 推理规划\n\n```json\n" + JSON.stringify(plan, null, 2) + "\n```");
+        renderMarkdown(riskBox, "#### 风险评估\n\n```json\n" + JSON.stringify(risk, null, 2) + "\n```");
+        const hourly = result.decision?.dispatch?.hourly || [];
+        if (hourly.length > 0) {
+          const head = "|小时|负荷|光伏|风电|储能放电|储能充电|并网|需求响应|SOC|电价|\n|---|---|---|---|---|---|---|---|---|---|";
+          const rows = hourly
+            .map(
+              (h) =>
+                `|${h.hour}|${h.demand_mw}|${h.solar_mw}|${h.wind_mw}|${h.storage_discharge_mw}|${h.storage_charge_mw}|${h.grid_import_mw}|${h.demand_response_mw}|${h.soc}|${h.price}|`
+            )
+            .join("\n");
+          renderMarkdown(dispatchBox, "#### 小时级调度表\n\n" + head + "\n" + rows);
+        } else {
+          renderMarkdown(dispatchBox, "暂无小时级调度结果");
+        }
+        const validation = result.validation || {};
+        const message = validation.passed ? "校验通过" : "校验未通过";
+        const issues = (validation.issues || []).join("、");
+        renderMarkdown(validationBox, `**${message}**\n\n${issues}`);
+        renderMarkdown(memoryBox, "```json\n" + JSON.stringify(result.memory || {}, null, 2) + "\n```");
+        const notes = result.scenario?.notes || "";
+        renderMarkdown(markdownPreview, notes || "暂无备注");
+      }
+
+      function renderLogs(logs) {
+        logList.innerHTML = "";
+        logs.forEach((item) => {
+          const wrap = document.createElement("div");
+          wrap.className = "log";
+          const header = document.createElement("header");
+          header.textContent = `${item.role} · ${item.created_at}`;
+          const body = document.createElement("div");
+          body.innerHTML = md.render(item.content || "");
+          wrap.appendChild(header);
+          wrap.appendChild(body);
+          logList.appendChild(wrap);
+        });
+      }
+
+      async function loadCycles() {
+        const res = await fetch("/api/cycles");
+        const data = await res.json();
+        cycleList.innerHTML = "";
+        data.forEach((cycle) => {
+          const btn = document.createElement("button");
+          btn.type = "button";
+          btn.textContent = `${cycle.title} · ${cycle.status}`;
+          btn.addEventListener("click", async () => {
+            const detailRes = await fetch(`/api/cycles/${cycle.id}`);
+            const detail = await detailRes.json();
+            renderDecision(detail);
+            const replayRes = await fetch(`/api/replay/${cycle.id}`);
+            const replay = await replayRes.json();
+            renderLogs(replay);
+          });
+          cycleList.appendChild(btn);
+        });
+      }
+
+      async function loadMemory() {
+        const res = await fetch("/api/memory");
+        const data = await res.json();
+        renderMarkdown(memoryBox, "```json\n" + JSON.stringify(data || {}, null, 2) + "\n```");
+      }
+
+      async function loadStats() {
+        const res = await fetch("/api/stats");
+        const data = await res.json();
+        statGrid.innerHTML = "";
+        const items = [
+          { label: "任务总数", value: data.total },
+          { label: "完成任务", value: data.completed },
+          { label: "平均成本", value: data.avg_cost },
+          { label: "平均碳排", value: data.avg_carbon },
+          { label: "最近运行", value: data.last_run },
+        ];
+        items.forEach((item) => {
+          const card = document.createElement("div");
+          card.className = "stat-card";
+          const span = document.createElement("span");
+          span.textContent = item.label;
+          const strong = document.createElement("strong");
+          strong.textContent = item.value;
+          card.appendChild(span);
+          card.appendChild(strong);
+          statGrid.appendChild(card);
+        });
+      }
+
+      async function loadFiles() {
+        const res = await fetch("/api/files");
+        const data = await res.json();
+        fileList.innerHTML = "";
+        data.forEach((file) => {
+          const row = document.createElement("div");
+          row.className = "log";
+          row.innerHTML = `<strong>${file.filename}</strong><br/>大小: ${Math.round(
+            file.size_bytes / 1024
+          )} KB · 二进制: ${file.is_binary ? "是" : "否"}<br/>SHA256: ${file.sha256}`;
+          fileList.appendChild(row);
+        });
+      }
+
+      async function fillSuggestedScenario() {
+        const res = await fetch("/api/scenario_suggest");
+        const data = await res.json();
+        Object.keys(data).forEach((key) => {
+          const field = form.querySelector(`[name="${key}"]`);
+          if (field) field.value = data[key];
+        });
+      }
+
+      async function runDemo() {
+        const payload = {
+          title: "一键演示调度",
+          demand_mw: 125,
+          solar_mw: 38,
+          wind_mw: 26,
+          storage_mwh: 78,
+          storage_soc: 0.4,
+          priority: "可靠性优先",
+          notes: "演示场景：保障核心负荷、允许有限需求响应。",
+        };
+        const res = await fetch("/api/run_cycle", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        });
+        const data = await res.json();
+        renderDecision(data);
+        const replayRes = await fetch(`/api/replay/${data.id}`);
+        renderLogs(await replayRes.json());
+        await loadCycles();
+        await loadMemory();
+        await loadStats();
+      }
+
+      async function uploadFile(file) {
+        if (!file) return;
+        uploadProgress.value = 0;
+        const chunkSize = 4 * 1024 * 1024;
+        const totalChunks = Math.ceil(file.size / chunkSize);
+        if (file.size <= chunkSize) {
+          const formData = new FormData();
+          formData.append("file", file);
+          const res = await fetch("/api/upload", { method: "POST", body: formData });
+          await res.json();
+          uploadProgress.value = 100;
+          await loadFiles();
+          return;
+        }
+        const fileId = uuid();
+        for (let i = 0; i < totalChunks; i++) {
+          const start = i * chunkSize;
+          const end = Math.min(file.size, start + chunkSize);
+          const chunk = file.slice(start, end);
+          await fetch("/api/upload_chunk", {
+            method: "POST",
+            headers: {
+              "X-File-Id": fileId,
+              "X-File-Name": file.name,
+              "X-Chunk-Index": i,
+              "X-Chunk-Total": totalChunks,
+              "X-Content-Type": file.type,
+            },
+            body: chunk,
+          });
+          uploadProgress.value = Math.round(((i + 1) / totalChunks) * 100);
+        }
+        await loadFiles();
+      }
+
+      form.addEventListener("submit", async (event) => {
+        event.preventDefault();
+        runBtn.disabled = true;
+        const payload = Object.fromEntries(new FormData(form).entries());
+        const res = await fetch("/api/run_cycle", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+        });
+        const data = await res.json();
+        renderDecision(data);
+        const replayRes = await fetch(`/api/replay/${data.id}`);
+        renderLogs(await replayRes.json());
+        await loadCycles();
+        await loadMemory();
+        runBtn.disabled = false;
+      });
+
+      suggestBtn.addEventListener("click", fillSuggestedScenario);
+      demoBtn.addEventListener("click", runDemo);
+      refreshStatsBtn.addEventListener("click", loadStats);
+      uploadBtn.addEventListener("click", () => uploadFile(fileInput.files[0]));
+
+      loadCycles();
+      loadMemory();
+      loadStats();
+      loadFiles();
+      renderMarkdown(dispatchBox, "等待调度结果");
+      renderMarkdown(validationBox, "等待校验结果");
+      renderMarkdown(planBox, "等待推理规划");
+      renderMarkdown(riskBox, "等待风险评估");
+    </script>
+  </body>
+</html>