openclaw-agent-dashboard 1.0.43 → 1.0.45

package/dashboard/api/performance.py

@@ -3,9 +3,12 @@
 支持按分钟查看调用详情，便于分析调用瓶颈
 """
 from fastapi import APIRouter
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Tuple
+import copy
 import json
 import re
+import asyncio
+import time
 from pathlib import Path
 from datetime import datetime, timedelta, timezone
 from zoneinfo import ZoneInfo
@@ -19,6 +22,31 @@ TZ_DISPLAY = ZoneInfo('Asia/Shanghai')
 
 router = APIRouter()
 
+# 聚合统计多次并发请求（WS + 轮询 + 多标签）共用；TTL 短以保证大致实时
+_perf_stats_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+_PERF_STATS_CACHE_TTL_SEC = 12.0
+
+# 柱体钻取：多次点击 / 并发标签共用短缓存
+_perf_details_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+_PERF_DETAILS_CACHE_TTL_SEC = 12.0
+
+# 轻量解析 envelope ISO 时间，便于跳过明显早于查询窗口的行（避免 json.loads + schema）
+_QUICK_ENV_TS_RE = re.compile(r'"timestamp"\s*:\s*"([^"]+)"')
+
+
+def _quick_envelope_timestamp_utc(line: str) -> Optional[datetime]:
+    m = _QUICK_ENV_TS_RE.search(line)
+    if not m:
+        return None
+    try:
+        return datetime.fromisoformat(m.group(1).replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def _perf_cache_key(range_minutes: int, range_hours: int, granularity: str) -> str:
+    return f"{range_minutes}:{range_hours}:{granularity}"
+
 
 def _extract_trigger_text(msg: Dict) -> str:
     """从消息中提取触发内容（完整展示）"""
@@ -177,11 +205,25 @@ def parse_session_file(session_path: Path, range_hours: int = 1) -> List[Dict]:
         range_hours: 时间范围（小时），0 表示不限制
     """
     messages = []
+    now = datetime.now(timezone.utc)
+    time_ago = now - timedelta(hours=range_hours) if range_hours > 0 else None
+
+    # 启发式：窗口内若有 assistant usage，文件通常在窗口内有过写入；过久未修改则可跳过整文件
+    if time_ago is not None:
+        try:
+            if session_path.stat().st_mtime < time_ago.timestamp():
+                return []
+        except OSError:
+            return []
 
     try:
         with open(session_path, 'r', encoding='utf-8') as f:
             for line in f:
                 try:
+                    if time_ago is not None:
+                        qt = _quick_envelope_timestamp_utc(line)
+                        if qt is not None and qt < time_ago:
+                            continue
                     envelope, msg = parse_session_jsonl_line(line)
                     if (
                         not envelope
@@ -200,11 +242,8 @@ def parse_session_file(session_path: Path, range_hours: int = 1) -> List[Dict]:
                             str(envelope['timestamp']).replace('Z', '+00:00')
                         )
 
-                        if range_hours > 0:
-                            now = datetime.now(timezone.utc)
-                            time_ago = now - timedelta(hours=range_hours)
-                            if timestamp < time_ago:
-                                continue
+                        if time_ago is not None and timestamp < time_ago:
+                            continue
 
                         messages.append({
                             'timestamp': timestamp,
@@ -240,14 +279,8 @@ async def get_performance_stats(range: str = "20m"):
     return stats
 
 
-async def get_real_stats(range_minutes: int = 20, range_hours: int = 1, granularity: str = "minute") -> Dict:
-    """获取真实的 TPM/RPM 统计
-
-    Args:
-        range_minutes: 时间范围（分钟）
-        range_hours: 用于解析 session 的时间范围（小时）
-        granularity: 聚合粒度 (minute, hour)
-    """
+def _compute_real_stats_sync(range_minutes: int = 20, range_hours: int = 1, granularity: str = "minute") -> Dict:
+    """同步聚合 TPM/RPM（在线程池中运行，避免阻塞事件循环）。"""
     stats = {
         'current': {
             'tpm': 0,
@@ -381,24 +414,38 @@ async def get_real_stats(range_minutes: int = 20, range_hours: int = 1, granular
     return stats
 
 
-async def get_minute_details(
+async def get_real_stats(range_minutes: int = 20, range_hours: int = 1, granularity: str = "minute") -> Dict:
+    """获取真实的 TPM/RPM 统计（线程池计算 + 短时缓存，减轻重复扫盘）。"""
+    key = _perf_cache_key(range_minutes, range_hours, granularity)
+    now = time.monotonic()
+    hit = _perf_stats_cache.get(key)
+    if hit is not None and (now - hit[0]) < _PERF_STATS_CACHE_TTL_SEC:
+        return hit[1]
+    data = await asyncio.to_thread(_compute_real_stats_sync, range_minutes, range_hours, granularity)
+    _perf_stats_cache[key] = (now, data)
+    return data
+
+
+def _perf_details_cache_key(
+    timestamp_ms: int,
+    granularity: str,
+    agent: str,
+    search: str,
+    sort: str,
+    limit: int,
+) -> str:
+    return f"{timestamp_ms}:{granularity}:{agent}:{search}:{sort}:{limit}"
+
+
+def _compute_minute_details_sync(
     timestamp_ms: int,
     granularity: str = "minute",
     agent: Optional[str] = None,
     search: Optional[str] = None,
     sort: str = "tokens_desc",
-    limit: int = 50
+    limit: int = 50,
 ) -> Dict[str, Any]:
-    """获取指定时间窗口的调用详情，用于柱体点击钻取。时间展示使用 Asia/Shanghai 时区
-
-    Args:
-        timestamp_ms: Unix 毫秒时间戳
-        granularity: 粒度 (minute, hour)
-        agent: 筛选指定 Agent
-        search: 搜索触发内容
-        sort: 排序方式 (tokens_desc, tokens_asc, time_asc, time_desc)
-        limit: 返回数量限制
-    """
+    """同步聚合柱体钻取数据（线程池 + 短 TTL 缓存）。"""
     try:
         ts = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
         ts_local = ts.astimezone(TZ_DISPLAY)
@@ -419,6 +466,7 @@ async def get_minute_details(
 
         all_calls = []
         agent_set = set()
+        window_start_ts = time_start.timestamp()
 
         for agent_dir in agents_path.iterdir():
             if not agent_dir.is_dir():
@@ -437,6 +485,12 @@ async def get_minute_details(
             for session_file in sessions_path.glob('*.jsonl'):
                 if 'lock' in session_file.name or 'deleted' in session_file.name:
                     continue
+                try:
+                    # 与 parse_session_file 相同启发式：窗口开始后未修改的文件不可能含该窗内的 assistant 记录
+                    if session_file.stat().st_mtime < window_start_ts:
+                        continue
+                except OSError:
+                    continue
                 records = parse_session_file_with_details(session_file, agent_id)
                 for r in records:
                     if time_start <= r['timestamp'] < time_end:
@@ -503,6 +557,44 @@ async def get_minute_details(
         return {'timeWindow': '', 'calls': [], 'totalCalls': 0, 'totalTokens': 0, 'summary': {'avgTokens': 0}, 'agents': [], 'pagination': {'total': 0, 'limit': limit, 'hasMore': False}}
 
 
+async def get_minute_details(
+    timestamp_ms: int,
+    granularity: str = "minute",
+    agent: Optional[str] = None,
+    search: Optional[str] = None,
+    sort: str = "tokens_desc",
+    limit: int = 50
+) -> Dict[str, Any]:
+    """获取指定时间窗口的调用详情，用于柱体点击钻取。时间展示使用 Asia/Shanghai 时区
+
+    Args:
+        timestamp_ms: Unix 毫秒时间戳
+        granularity: 粒度 (minute, hour)
+        agent: 筛选指定 Agent
+        search: 搜索触发内容
+        sort: 排序方式 (tokens_desc, tokens_asc, time_asc, time_desc)
+        limit: 返回数量限制
+    """
+    ag = agent or ""
+    sr = search or ""
+    key = _perf_details_cache_key(timestamp_ms, granularity, ag, sr, sort, limit)
+    now = time.monotonic()
+    hit = _perf_details_cache.get(key)
+    if hit is not None and (now - hit[0]) < _PERF_DETAILS_CACHE_TTL_SEC:
+        return copy.deepcopy(hit[1])
+    data = await asyncio.to_thread(
+        _compute_minute_details_sync,
+        timestamp_ms,
+        granularity,
+        agent,
+        search,
+        sort,
+        limit,
+    )
+    _perf_details_cache[key] = (now, copy.deepcopy(data))
+    return data
+
+
 @router.get("/performance/details")
 async def get_performance_details(
     timestamp: int,

package/dashboard/api/timeline.py

@@ -1,11 +1,13 @@
 """
 Timeline API 路由 - 实时执行时序图
 """
+import asyncio
+import copy
 import logging
 import time
 from fastapi import APIRouter, Query, HTTPException
 from pydantic import BaseModel
-from typing import Optional, List, Dict, Any
+from typing import Optional, List, Dict, Any, Tuple
 import sys
 from pathlib import Path
 
@@ -20,6 +22,14 @@ from data.config_reader import get_agent_config
 
 router = APIRouter()
 
+# 切换 agent / 轮询重复命中时减轻重复读盘解析（短时 stale 可接受）
+_timeline_cache: Dict[str, Tuple[float, Dict[str, Any]]] = {}
+_TIMELINE_CACHE_TTL_SEC = 5.0
+
+
+def _timeline_cache_key(agent_id: str, session_key: Optional[str], limit: int) -> str:
+    return f"{agent_id}\x00{session_key or ''}\x00{limit}"
+
 
 class TimelineStats(BaseModel):
     totalDuration: int
@@ -80,11 +90,18 @@ async def get_timeline(
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
     t0 = time.perf_counter()
-    try:
-        result = get_timeline_steps(agent_id, session_key, limit)
-    except Exception as e:
-        record_error("unknown", str(e), "api:timeline:get", exc=e)
-        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
+    cache_key = _timeline_cache_key(agent_id, session_key, limit)
+    now_mono = time.monotonic()
+    hit = _timeline_cache.get(cache_key)
+    if hit is not None and (now_mono - hit[0]) < _TIMELINE_CACHE_TTL_SEC:
+        result = copy.deepcopy(hit[1])
+    else:
+        try:
+            result = await asyncio.to_thread(get_timeline_steps, agent_id, session_key, limit)
+        except Exception as e:
+            record_error("unknown", str(e), "api:timeline:get", exc=e)
+            raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
+        _timeline_cache[cache_key] = (now_mono, copy.deepcopy(result))
     elapsed_ms = (time.perf_counter() - t0) * 1000
     steps_count = len(result.get("steps", []))
     if elapsed_ms >= 100.0:
@@ -127,7 +144,7 @@ async def get_timeline_steps_only(
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
     try:
-        result = get_timeline_steps(agent_id, session_key, limit)
+        result = await asyncio.to_thread(get_timeline_steps, agent_id, session_key, limit)
     except Exception as e:
         record_error("unknown", str(e), "api:timeline:steps", exc=e)
         raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
@@ -153,7 +170,7 @@ async def get_timeline_summary(agent_id: str, session_key: Optional[str] = Query
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
     try:
-        result = get_timeline_steps(agent_id, session_key, limit=10)  # 只需基本信息
+        result = await asyncio.to_thread(get_timeline_steps, agent_id, session_key, 10)  # 只需基本信息
     except Exception as e:
         record_error("unknown", str(e), "api:timeline:summary", exc=e)
         raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e

package/dashboard/api/websocket.py

@@ -7,6 +7,7 @@ from typing import Set, List, Dict, Any
 import json
 import asyncio
 import sys
+import time
 from pathlib import Path
 
 sys.path.append(str(Path(__file__).parent.parent))
@@ -18,30 +19,46 @@ router = APIRouter()
 # 活跃的 WebSocket 连接
 active_connections: Set[WebSocket] = set()
 
-# 周期性推送间隔（秒）- 优化：从 3 秒缩短到 1 秒
-BROADCAST_INTERVAL_SEC = 1
+# 周期性增量检查基准间隔（秒）；空闲时会自动退避拉长（见 _periodic_broadcast_loop）
+BROADCAST_INTERVAL_SEC = 5
 _broadcast_task: asyncio.Task | None = None
+_broadcast_sleep_sec: float = float(BROADCAST_INTERVAL_SEC)
+_broadcast_idle_streak: int = 0
+
+# 文件监听等高频触发下合并 full_state，降低前端解析与重绘压力
+FULL_STATE_MIN_INTERVAL_SEC = 2.0
+_last_full_state_monotonic: float = 0.0
 
 
 async def _periodic_broadcast_loop():
-    """周期性广播状态更新（增量），确保无文件变更时也有更新"""
+    """周期性广播状态更新（增量）；连续无变更则拉长睡眠间隔，上限 30s。"""
+    global _broadcast_sleep_sec, _broadcast_idle_streak
     while True:
-        await asyncio.sleep(BROADCAST_INTERVAL_SEC)
+        await asyncio.sleep(_broadcast_sleep_sec)
         if active_connections:
-            # 只推送状态变化的 Agent
             try:
                 from status.status_calculator import get_changed_agents
                 changed_agents = await get_changed_agents()
                 if changed_agents:
+                    _broadcast_idle_streak = 0
+                    _broadcast_sleep_sec = float(BROADCAST_INTERVAL_SEC)
                     await broadcast_state_update(changed_agents)
+                else:
+                    _broadcast_idle_streak += 1
+                    if _broadcast_idle_streak >= 3:
+                        _broadcast_sleep_sec = min(_broadcast_sleep_sec * 2.0, 30.0)
+            except asyncio.CancelledError:
+                raise
             except Exception as e:
                 record_error("unknown", str(e), "websocket:periodic_broadcast", exc=e)
 
 
 def _ensure_broadcast_task():
     """有连接时启动周期性推送"""
-    global _broadcast_task
+    global _broadcast_task, _broadcast_sleep_sec, _broadcast_idle_streak
     if active_connections and (_broadcast_task is None or _broadcast_task.done()):
+        _broadcast_sleep_sec = float(BROADCAST_INTERVAL_SEC)
+        _broadcast_idle_streak = 0
         _broadcast_task = asyncio.create_task(_periodic_broadcast_loop())
 
 
@@ -210,9 +227,15 @@ async def broadcast_full_state():
     优化点：
     1. 使用 get_collaboration_dynamic() 代替 get_collaboration()
     2. 只推送动态数据，减少数据量
+    3. 短时间重复调用节流，避免监听线程连震时频繁全量推送
     """
+    global _last_full_state_monotonic
     if not active_connections:
         return
+    now = time.monotonic()
+    if now - _last_full_state_monotonic < FULL_STATE_MIN_INTERVAL_SEC:
+        return
+    _last_full_state_monotonic = now
     try:
         from .agents import get_agents as get_agents_list
         from .subagents import get_subagents

package/dashboard/core/schemas/base.py

@@ -25,19 +25,20 @@ class SchemaValidator:
         self.schema = schema
         self.strict = strict
         self._validator = Draft202012Validator(schema)
-        self._last_errors: List[str] = []
 
     def validate(self, data: Any) -> ValidationResult:
-        self._last_errors = []
+        """线程安全：校验结果仅通过返回值给出，实例上不保留最后一次错误（避免并发覆盖）。"""
+        errors: List[str] = []
         if not isinstance(data, (dict, list)) and self.schema.get("type") == "object":
-            self._last_errors.append("expected object")
-            return ValidationResult(False, list(self._last_errors))
+            errors.append("expected object")
+            return ValidationResult(False, errors)
         try:
             self._validator.validate(data)
             return ValidationResult(True, [])
         except jsonschema.ValidationError as e:
-            self._last_errors.append(e.message)
-            return ValidationResult(False, list(self._last_errors))
+            errors.append(e.message)
+            return ValidationResult(False, errors)
 
     def get_error_details(self) -> Dict[str, Any]:
-        return {"errors": list(self._last_errors)}
+        """兼容旧接口；共享校验器实例时不代表「最后一次校验」。请使用 validate() 的返回值。"""
+        return {"errors": []}

package/dashboard/data/config_reader.py

@@ -152,22 +152,32 @@ def get_models_configured_by_agents() -> List[str]:
     """
     从配置中收集「各 Agent 实际配置使用」的模型 ID（仅 primary + fallbacks）。
     用于协作流程右侧模型面板：只显示有 Agent 配置的模型，不含白名单中未使用的。
+
+    策略：仅包含作为 primary 使用、或被某 agent 配置过的模型。
+    不包含 defaults.model.fallbacks 中没有任何 agent 当 primary 使用的模型。
     """
     agents = get_agents_list()
-    model_ids = set()
-    defaults = get_default_config()
-    default_model = defaults.get('model', {})
-    if default_model.get('primary'):
-        model_ids.add(default_model['primary'])
-    for fb in default_model.get('fallbacks') or []:
-        model_ids.add(fb)
+    # Step 1: 收集所有 primary 模型（用于判断 fallback 是否被实际使用）
+    primaries: List[str] = []
     for agent in agents:
         cfg = get_agent_models(agent.get('id', ''))
         if cfg.get('primary'):
-            model_ids.add(cfg['primary'])
+            primaries.append(cfg['primary'])
+    primary_set = set(primaries)
+
+    # Step 2: 收集所有 primary
+    model_ids: List[str] = list(dict.fromkeys(primaries))  # 保持顺序去重
+
+    # Step 3: 只添加被某 agent 实际配置过的 fallback（不被 primary_set 包含的不添加）
+    seen = set(primary_set)
+    for agent in agents:
+        cfg = get_agent_models(agent.get('id', ''))
         for fb in cfg.get('fallbacks', []):
-            model_ids.add(fb)
-    return sorted(model_ids)
+            if fb and fb not in seen:
+                model_ids.append(fb)
+                seen.add(fb)
+
+    return model_ids
 
 
 def get_all_models_from_agents() -> List[str]:
@@ -187,6 +197,23 @@ def get_all_models_from_agents() -> List[str]:
     return sorted(model_ids)
 
 
+def get_default_models_from_defaults() -> List[str]:
+    """
+    仅返回 agents.defaults.model.primary + fallbacks 中的模型。
+    用于协作流程右侧模型面板：当没有任何 Agent 实际配置某模型时，
+    不应因白名单而显示该模型（避免「配置未使用但显示在右侧」）。
+    """
+    defaults = get_default_config()
+    default_model = defaults.get('model', {})
+    result = []
+    if default_model.get('primary'):
+        result.append(default_model['primary'])
+    for fb in default_model.get('fallbacks') or []:
+        if fb not in result:
+            result.append(fb)
+    return result
+
+
 def get_model_display_name(model_id: str) -> str:
     """获取模型显示名。展示策略：使用 id 不用别名（与 OpenClaw 白名单逻辑一致）"""
     if not model_id:

package/dashboard/data/session_reader.py

@@ -269,9 +269,12 @@ def has_recent_errors(agent_id: str, minutes: int = 5) -> bool:
 
 
 def get_last_error(agent_id: str) -> Optional[Dict[str, Any]]:
-    """获取最近的错误信息"""
+    """
+    获取最近的错误信息，优先从 session stopReason=error 获取，
+    若无则从 runs.json 中最近结束的 error run 兜底。
+    """
     messages = get_recent_messages(agent_id, limit=100)
-    
+
     for msg in reversed(messages):
         if msg.get('stopReason') == 'error':
             return {
@@ -279,7 +282,39 @@ def get_last_error(agent_id: str) -> Optional[Dict[str, Any]]:
                 'message': msg.get('errorMessage', ''),
                 'timestamp': msg.get('timestamp', 0)
             }
-    
+
+    # 兜底：检查 runs.json 中最近结束的 error run
+    run_error = _get_last_run_error(agent_id)
+    if run_error:
+        return run_error
+
+    return None
+
+
+def _get_last_run_error(agent_id: str) -> Optional[Dict[str, Any]]:
+    """
+    从 runs.json 获取最近结束的 error run 的错误信息。
+    用于补充 session 中未落 stopReason=error 的 Gateway 中断等场景。
+    """
+    import time
+    from data.subagent_reader import get_agent_runs
+
+    runs = get_agent_runs(agent_id, limit=20)
+    cutoff = int(time.time() * 1000) - 5 * 60 * 1000
+    for run in runs:
+        ended = run.get('endedAt')
+        if not ended or ended < cutoff:
+            continue
+        outcome = run.get('outcome')
+        if not isinstance(outcome, dict) or outcome.get('status') != 'error':
+            continue
+        error_msg = outcome.get('error', '') or ''
+        return {
+            'type': detect_error_type(error_msg),
+            'message': error_msg,
+            'timestamp': ended,
+            'source': 'run'  # 标记来源，便于调试
+        }
     return None
 
 

package/dashboard/data/timeline_reader.py

@@ -666,22 +666,9 @@ def resolve_agent_session_jsonl(
         if isinstance(index_map.get(k), dict) and str(k).startswith(prefix)
     ]
 
-    # 1) 与当前子任务最一致：runs.json 中该 agent 最近一次 run 的 childSessionKey
-    runs = get_subagent_runs().get(state_id, [])
-    if runs:
-        runs.sort(key=lambda x: x.get('startedAt', 0), reverse=True)
-        preferred_key = runs[0].get('childSessionKey')
-        if preferred_key and preferred_key in index_map:
-            ent = index_map[preferred_key]
-            if isinstance(ent, dict):
-                p = resolve_session_jsonl_path(sessions_path, ent)
-                if p and p.is_file():
-                    sid = ent.get('sessionId') or preferred_key
-                    return p, sid, preferred_key
-
-    # 2) 按 sessions.json 的 updatedAt/lastMessageAt 选最近会话（在 glob mtime 之前）
-    #    OpenClaw 在任务结束后可能从 runs.json 移除 run，此处仍可定位「最近活跃」子会话 jsonl。
-    #    多文件时比仅凭 *.jsonl 的 mtime 更稳，且与 4/24 当晚最晚更新 session 一致。
+    # 直接按 sessions.json 的 updatedAt 选最新会话。
+    # runs.json 中的 run 即使已结束也仍保留在列表中，用它优先会错误选中旧 session；
+    # 而 updatedAt 由 OpenClaw 维护，能准确反映会话的实际最后活跃时间。
     if agent_keys:
         agent_keys.sort(
             key=lambda k: (index_map[k].get('updatedAt') or index_map[k].get('lastMessageAt') or 0),

package/dashboard/status/status_calculator.py

@@ -30,6 +30,28 @@ MAIN_AGENT_SOLO_STREAM_GRACE_SEC = 20
 
 AgentStatus = Literal['idle', 'working', 'down']
 
+# 最近多久内的 error run 应视为 down 状态（分钟）
+_RECENT_ERROR_RUN_WINDOW_MINUTES = 5
+
+
+def _has_recent_error_run(agent_id: str, minutes: int = _RECENT_ERROR_RUN_WINDOW_MINUTES) -> bool:
+    """
+    检查 runs.json 中是否有最近结束且 outcome.status == 'error' 的 run。
+    用于补充 session stopReason=error：Gateway 重启等原因导致的 run 中断
+    会写入 runs.json 但不一定会话落 stopReason=error。
+    """
+    import time
+    runs = get_agent_runs(agent_id, limit=20)
+    cutoff = int(time.time() * 1000) - minutes * 60 * 1000
+    for run in runs:
+        ended = run.get('endedAt')
+        if not ended or ended < cutoff:
+            continue
+        outcome = run.get('outcome')
+        if isinstance(outcome, dict) and outcome.get('status') == 'error':
+            return True
+    return False
+
 
 def _main_agent_solo_processing(agent_id: str) -> bool:
     """
@@ -58,16 +80,16 @@ def _main_agent_solo_processing(agent_id: str) -> bool:
 def calculate_agent_status(agent_id: str, use_cache: bool = True) -> AgentStatus:
     """
     计算 Agent 状态（基于 runs.json + sessions.json）
-    
+
     优先级:
-    1. 异常 (down) - 最近5分钟有 stopReason=error
+    1. 异常 (down) - 最近5分钟有 stopReason=error，或有最近结束的 error run
     2. 工作中 (working) - 有活跃 subagent run；或主 Agent 且无 run 时 thinking / 未完成工具 / 短窗内会话写入
     3. 空闲 (idle) - 其余情况（子 Agent 无 run 即空闲，与协作图 activePath 一致）
-    
+
     Args:
         agent_id: Agent ID
         use_cache: 是否使用缓存（默认 True）
-    
+
     Returns:
         Agent 状态
     """
@@ -82,6 +104,8 @@ def calculate_agent_status(agent_id: str, use_cache: bool = True) -> AgentStatus
         # 重新计算
         if has_recent_errors(agent_id, minutes=5):
             status = 'down'
+        elif _has_recent_error_run(agent_id, minutes=5):
+            status = 'down'
         elif is_agent_working(agent_id):
             status = 'working'
         elif _main_agent_solo_processing(agent_id):
@@ -124,7 +148,8 @@ def get_agents_with_status() -> list:
         try:
             status = calculate_agent_status(agent_id)
             current_task = get_current_task(agent_id)
-            if status == 'idle':
+            # idle 且无已结束 run 任务时才清空 currentTask
+            if status == 'idle' and not current_task:
                 current_task = ''
             last_active = get_last_active_time(agent_id)
             last_error = get_last_error(agent_id) if status == 'down' else None
@@ -155,16 +180,32 @@ def get_agents_with_status() -> list:
 def get_current_task(agent_id: str) -> str:
     """
     获取 Agent 当前任务描述。
-    仅从未结束的 run（endedAt 为空）读取；已结束的 run 只代表历史，不应在空闲时仍当「当前任务」展示。
+
+    优先级：
+    1. 活跃 run（endedAt 为空）—— 代表正在执行的任务
+    2. 最近结束的 run——即使已结束也要展示（run 失败中断后仍需可见）
     """
     runs = get_agent_runs(agent_id, limit=40)
+
+    # 优先级1：未结束的 run
+    for run in runs:
+        if run.get('endedAt') is None:
+            task = run.get('task', '') or ''
+            if len(task) > 60:
+                task = task[:57] + '...'
+            return task
+
+    # 优先级2：最近的已结束 run（确保失败中断的任务也能在 Dashboard 上看到）
     for run in runs:
         if run.get('endedAt') is not None:
-            continue
-        task = run.get('task', '') or ''
-        if len(task) > 60:
-            task = task[:57] + '...'
-        return task
+            task = run.get('task', '') or ''
+            if task:
+                outcome = run.get('outcome', {})
+                status = outcome.get('status') if isinstance(outcome, dict) else None
+                prefix = '[失败] ' if status == 'error' else '[已结束] '
+                if len(task) > 57:
+                    task = task[:57] + '...'
+                return prefix + task
 
     return ''