diff --git a/backend/app/api/conversations.py b/backend/app/api/conversations.py
index 4e1b54cd..4111e813 100644
--- a/backend/app/api/conversations.py
+++ b/backend/app/api/conversations.py
@@ -13,15 +13,16 @@
 
 from __future__ import annotations
 
+from datetime import datetime, timedelta, timezone
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException
 from pydantic import BaseModel, Field
-from sqlalchemy import delete, func, select
+from sqlalchemy import and_, delete, func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.base import get_session, utcnow
-from app.db.models import Conversation, ConversationTurn
+from app.db.models import Approval, Conversation, ConversationTurn, Run
 
 router = APIRouter(prefix="/api/conversations", tags=["conversations"])
 
@@ -71,6 +72,8 @@ class TurnPatch(BaseModel):
     status: str | None = Field(default=None, pattern="^(running|done|error)$")
     error: str | None = None
     review: dict[str, Any] | None = None
+    #: 可信度元数据，前端整块写、整块读，后端不解读它的内容（列表状态除外，见 last_status）
+    meta: dict[str, Any] | None = None
 
 
 class TurnOut(BaseModel):
@@ -85,6 +88,8 @@ class TurnOut(BaseModel):
     error: str
     #: 复核结论。None = 这一轮没复核过，和「复核过、没发现问题」不是一回事
     review: dict[str, Any] | None = None
+    #: 可信度元数据。老轮次挂在 review.meta 下，读出来时统一放到这里
+    meta: dict[str, Any] | None = None
     created_at: Any = None
 
     model_config = {"from_attributes": True}
@@ -101,6 +106,11 @@ class ConversationOut(BaseModel):
     turn_count: int = 0
     #: 列表里给个副标题，让人一眼认出是哪次聊天
     last_question: str = ""
+    #: 最后一轮停在哪：running | waiting | error | cancelled | suspended | done，
+    #: 没有轮次时为 None。见 last_status()
+    last_status: str | None = None
+    #: 最后一轮的运行。建图阶段就断了的没有
+    last_run_id: str | None = None
 
     model_config = {"from_attributes": True}
 
@@ -114,14 +124,119 @@ class ConversationDetail(ConversationOut):
     model_config = {"from_attributes": False}
 
 
+def turn_meta(turn: Any) -> dict[str, Any] | None:
+    """这一轮的元数据：meta 列优先，老数据退回 review.meta。"""
+    if isinstance(turn.meta, dict):
+        return turn.meta
+    bridged = turn.review.get("meta") if isinstance(turn.review, dict) else None
+    return bridged if isinstance(bridged, dict) else None
+
+
+def _turn_out(turn: ConversationTurn) -> TurnOut:
+    out = TurnOut.model_validate(turn)
+    out.meta = turn_meta(turn)
+    return out
+
+
 def _detail(row: Conversation, turns: list[ConversationTurn]) -> ConversationDetail:
     base = ConversationOut.model_validate(row)
     return ConversationDetail(
         **base.model_dump(),
-        turns=[TurnOut.model_validate(t) for t in turns],
+        turns=[_turn_out(t) for t in turns],
     )
 
 
+#: 还没有运行的轮次停在 running 超过这么久，就当建图断了。建图跟着浏览器那条流走，
+#: 页面一关就停，轮次却一直是 running；最长的正常情况是模型超时再加两轮自查修正
+BUILD_STALE = timedelta(minutes=15)
+
+
+def last_status(
+    turn: Any, run_status: str | None, pending: bool, now: datetime | None = None,
+) -> str:
+    """一轮停在哪。轮次状态只有 running / done / error 三种，细分要看运行和元数据。
+
+    轮次状态是前端写的：页面关掉、服务重启时它停在 running，这时要以运行的状态为准；
+    运行也没有的，是断在了建图阶段。已经收尾的轮次以轮次自己为准——它写下的就是
+    用户看到的结局（取消、服务重启挂起在 error 里分开记）。
+    """
+    outcome = (turn_meta(turn) or {}).get("outcome")
+    if turn.status == "done":
+        return "done"
+    if turn.status == "error":
+        if outcome == "cancelled" or (turn.error or "").strip() == "已取消":
+            return "cancelled"
+        if outcome == "suspended":
+            # 挂起之后可能已经在别处接着跑了
+            live = _from_run(run_status, pending)
+            return live if live in ("running", "waiting") else "suspended"
+        return "error"
+    live = _from_run(run_status, pending)
+    if live:
+        return live
+    updated = turn.updated_at
+    if updated is not None and updated.tzinfo is None:
+        updated = updated.replace(tzinfo=timezone.utc)
+    stale = updated is not None and (now or utcnow()) - updated > BUILD_STALE
+    return "error" if stale else "running"
+
+
+def _from_run(run_status: str | None, pending: bool) -> str | None:
+    return {
+        "queued": "running", "running": "running",
+        "interrupted": "waiting" if pending else "suspended",
+        "succeeded": "done", "failed": "error", "cancelled": "cancelled",
+    }.get(run_status or "")
+
+
+async def _last_turns(
+    session: AsyncSession, ids: list[str]
+) -> dict[str, ConversationTurn]:
+    """每个会话 seq 最大的那一轮。一次查完，列表长了也只是一次往返。"""
+    latest = (
+        select(ConversationTurn.conversation_id, func.max(ConversationTurn.seq).label("seq"))
+        .where(ConversationTurn.conversation_id.in_(ids))
+        .group_by(ConversationTurn.conversation_id)
+        .subquery()
+    )
+    rows = (await session.execute(
+        select(ConversationTurn).join(latest, and_(
+            ConversationTurn.conversation_id == latest.c.conversation_id,
+            ConversationTurn.seq == latest.c.seq,
+        ))
+    )).scalars()
+    return {t.conversation_id: t for t in rows}
+
+
+async def _statuses(
+    session: AsyncSession, turns: dict[str, ConversationTurn]
+) -> dict[str, tuple[str, str | None]]:
+    """会话 id → (last_status, last_run_id)。运行状态和待审批各一次查询。"""
+    run_of = {
+        cid: t.run_id or (turn_meta(t) or {}).get("runId") or None for cid, t in turns.items()
+    }
+    run_ids = {r for r in run_of.values() if r}
+    runs: dict[str, str] = {}
+    waiting: set[str] = set()
+    if run_ids:
+        runs = dict((await session.execute(
+            select(Run.id, Run.status).where(Run.id.in_(run_ids))
+        )).all())
+        stopped = [r for r, st in runs.items() if st == "interrupted"]
+        if stopped:
+            waiting = set((await session.execute(
+                select(Approval.run_id).where(
+                    Approval.run_id.in_(stopped), Approval.status == "pending")
+            )).scalars())
+    now = utcnow()
+    out: dict[str, tuple[str, str | None]] = {}
+    for cid, turn in turns.items():
+        run_id = run_of[cid] if run_of[cid] in runs else None
+        out[cid] = (last_status(turn, runs.get(run_id or ""), run_id in waiting, now),
+                    run_id)
+    return out
+
+
 # --------------------------------------------------------------------------
 # 会话
 # --------------------------------------------------------------------------
@@ -152,34 +267,24 @@ async def list_conversations(
     if not rows:
         return []
 
-    # 轮数和最后一问一次查完。每条会话各查一次的话，列表长了就是几十次往返
+    # 轮数、最后一轮、它的运行状态一次查完。每条会话各查一次的话，列表长了就是
+    # 几十次往返。状态要带上：没打开过的会话也得标得出「在等审批」「失败了」
     ids = [r.id for r in rows]
     counts = dict((await session.execute(
         select(ConversationTurn.conversation_id, func.count(ConversationTurn.id))
         .where(ConversationTurn.conversation_id.in_(ids))
         .group_by(ConversationTurn.conversation_id)
     )).all())
-    last_seq = dict((await session.execute(
-        select(ConversationTurn.conversation_id, func.max(ConversationTurn.seq))
-        .where(ConversationTurn.conversation_id.in_(ids))
-        .group_by(ConversationTurn.conversation_id)
-    )).all())
-    last_questions: dict[str, str] = {}
-    if last_seq:
-        pairs = list(last_seq.items())
-        rows_q = list((await session.execute(
-            select(ConversationTurn.conversation_id, ConversationTurn.seq, ConversationTurn.question)
-            .where(ConversationTurn.conversation_id.in_([c for c, _ in pairs]))
-        )).all())
-        for conv_id, seq, question in rows_q:
-            if last_seq.get(conv_id) == seq:
-                last_questions[conv_id] = question or ""
+    last = await _last_turns(session, ids)
+    status = await _statuses(session, last)
 
     out: list[ConversationOut] = []
     for row in rows:
         item = ConversationOut.model_validate(row)
         item.turn_count = int(counts.get(row.id, 0))
-        item.last_question = last_questions.get(row.id, "")
+        if row.id in last:
+            item.last_question = last[row.id].question or ""
+            item.last_status, item.last_run_id = status[row.id]
         out.append(item)
     return out
 
@@ -212,6 +317,8 @@ async def get_conversation(
     out = _detail(row, turns)
     out.turn_count = len(turns)
     out.last_question = turns[-1].question if turns else ""
+    if turns:
+        out.last_status, out.last_run_id = (await _statuses(session, {row.id: turns[-1]}))[row.id]
     return out
 
 
@@ -275,7 +382,7 @@ async def create_turn(
 
     await session.commit()
     await session.refresh(turn)
-    return TurnOut.model_validate(turn)
+    return _turn_out(turn)
 
 
 @router.patch("/{conversation_id}/turns/{turn_id}", response_model=TurnOut)
@@ -290,7 +397,7 @@ async def patch_turn(
         raise HTTPException(404, "这一轮对话不存在，可能已经被删了")
 
     for field in (
-        "question", "answer", "explanation", "graph", "run_id", "status", "error", "review",
+        "question", "answer", "explanation", "graph", "run_id", "status", "error", "review", "meta",
     ):
         value = getattr(payload, field)
         if value is not None:
@@ -301,7 +408,7 @@ async def patch_turn(
         conversation.last_active_at = utcnow()
     await session.commit()
     await session.refresh(turn)
-    return TurnOut.model_validate(turn)
+    return _turn_out(turn)
 
 
 # --------------------------------------------------------------------------
diff --git a/backend/app/api/copilot.py b/backend/app/api/copilot.py
index 87540df1..52489510 100644
--- a/backend/app/api/copilot.py
+++ b/backend/app/api/copilot.py
@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import copy
 import json
+import re
 import time
 from typing import Any
 
@@ -11,11 +13,11 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 # 起别名：本文件底下有个叫 explain 的接口，generate 里又有个局部变量叫 raw，同名会互相盖掉
-from app.api.errors import explain as explain_error, graph_error, not_configured, raw as raw_error
+from app.core.errors import explain as explain_error, graph_error, not_configured, raw as raw_error
 from app.db.base import get_session
 from app.db.models import Workflow
 from app.engine.layout import CORRIDOR_MIN, MIN_ROW_GAP, NODE_W, _height, auto_layout
-from app.engine.schema import GraphSpec, NodeType, validate_graph
+from app.engine.schema import GraphSpec, NodeType, ValidationIssue, validate_graph
 from app.engine.state import message_text
 from app.providers.factory import ModelSpec, ProviderNotConfigured, get_chat_model
 from app.tools.registry import all_specs
@@ -23,7 +25,40 @@ from app.tools.registry import all_specs
 router = APIRouter(prefix="/api/copilot", tags=["copilot"])
 
 
-async def _tool_catalog(session: AsyncSession) -> str:
+async def _sources(session: AsyncSession, scope: list[str] | None) -> list[Any]:
+    """这一轮给助手看的数据源：启用着的，限定了范围就只留点名的（id、名字都认）。
+
+    点名的一个都不在（删了、停用了）就直接拒绝：悄悄退回「全部数据源」等于
+    无视用户的限定，而他正是因为想换一个库问才点的。
+    """
+    from app.db.models import DataSource
+
+    rows = list((
+        await session.execute(
+            select(DataSource).where(DataSource.enabled.is_(True)).order_by(DataSource.name)
+        )
+    ).scalars())
+    wanted = {s.strip() for s in scope or [] if isinstance(s, str) and s.strip()}
+    if not wanted:
+        return rows
+    picked = [r for r in rows if r.id in wanted or r.name in wanted]
+    if not picked:
+        raise HTTPException(
+            400, "限定的数据源都不在了：可能已经被删掉或停用。去掉限定再问，"
+                 "或者到「数据」页确认它还在、而且是启用的",
+        )
+    return picked
+
+
+def _scope_note(rows: list[Any], scoped: bool) -> str:
+    if not scoped:
+        return ""
+    names = "、".join(r.name for r in rows)
+    return (f"\n\n这一轮用户把数据源限定为：{names}。只查它们，只能用它们的 db_query__ / "
+            "db_schema__ 工具；前几轮用过别的库，这一轮也不要沿用")
+
+
+def _tool_catalog(rows: list[Any]) -> str:
     """给 Copilot 看的工具清单。
 
     all_specs() 只有静态注册的内置工具，数据源工具是运行时按库动态生成的
@@ -36,14 +71,8 @@ async def _tool_catalog(session: AsyncSession) -> str:
     ]
 
     from app.data import introspect as _introspect
-    from app.db.models import DataSource
     from app.tools.datasource import QUERY_PREFIX, SCHEMA_PREFIX
 
-    rows = list((
-        await session.execute(
-            select(DataSource).where(DataSource.enabled.is_(True)).order_by(DataSource.name)
-        )
-    ).scalars())
     for row in rows:
         tables = _introspect.table_names(row)
         listed = "、".join(tables[:12]) + (f" 等 {len(tables)} 个对象" if len(tables) > 12 else "")
@@ -68,16 +97,10 @@ _DATASOURCE_BUDGET_CHARS = 6000
 _DETAIL_TABLE_LIMIT = 40
 
 
-async def _datasource_section(session: AsyncSession) -> str:
+def _datasource_section(rows: list[Any]) -> str:
     """数据源与结构摘要。没有数据源时返回空串，不占 prompt。"""
     from app.data import introspect as _introspect
-    from app.db.models import DataSource
 
-    rows = list((
-        await session.execute(
-            select(DataSource).where(DataSource.enabled.is_(True)).order_by(DataSource.name)
-        )
-    ).scalars())
     if not rows:
         return ""
 
@@ -190,6 +213,8 @@ class GenerateIn(BaseModel):
     intent: str = Field(default="build")
     #: 属于哪次对话。带上它，这一轮才知道前面聊过什么
     conversation_id: str | None = None
+    #: 这一轮只查这几个数据源（id 或名字）。不传或空表示不限
+    datasource_ids: list[str] | None = None
 
 
 def _user_message(payload: GenerateIn, *, patch: bool) -> str:
@@ -395,6 +420,8 @@ class GenerateOut(BaseModel):
     explanation: str = ""
     issues: list[dict[str, Any]] = Field(default_factory=list)
     layout: dict[str, Any] = Field(default_factory=dict)
+    #: 改图前后都在、工具绑定却变了的节点和成员，见 tool_changes()
+    tool_changes: list[dict[str, Any]] = Field(default_factory=list)
 
 
 # --------------------------------------------------------------------------
@@ -545,8 +572,10 @@ async def generate(
     产物会经过和手工编排完全相同的校验与排版，所以生成完就是可运行、可读的，
     而不是一段还要人去修的 JSON。
     """
-    tool_list = await _tool_catalog(session)
-    datasources = await _datasource_section(session)
+    sources = await _sources(session, payload.datasource_ids)
+    scope = {r.name for r in sources} if payload.datasource_ids else None
+    tool_list = _tool_catalog(sources)
+    datasources = _datasource_section(sources) + _scope_note(sources, scope is not None)
 
     system = (
         "你是一个 agent 工作流编排专家。根据用户需求产出一张可执行的工作流图。\n\n"
@@ -620,11 +649,16 @@ async def generate(
 
     spec, layout = _layout_keeping(spec, _pinned_positions(payload.base_graph))
     report = validate_graph(spec)
+    out = spec.model_dump(mode="json")
+    changes = tool_changes((payload.base_graph or {}).get("nodes") or [], out["nodes"])
     return GenerateOut(
-        graph=spec.model_dump(mode="json"),
+        graph=out,
         explanation=str(raw.get("explanation", "")),
-        issues=[i.model_dump() for i in report.issues],
+        issues=[i.model_dump() for i in report.issues]
+        + _issue_dicts(scope_issues(out["nodes"], scope), "datasource_out_of_scope")
+        + dropped_tool_warnings(changes, payload.instruction),
         layout=layout,
+        tool_changes=changes,
     )
 
 
@@ -638,13 +672,16 @@ _STREAM_PROTOCOL = """\
 - 可用操作：
   {"op":"plan","summary":"一句话说明打算怎么搭"}          ← 第一行
   {"op":"add_node","node":{"id":"...","type":"...","label":"中文标签","config":{...}}}
-  {"op":"update_node","id":"...","label":"...","config":{...}}   ← 修改现有节点（config 整体替换）
+  {"op":"update_node","id":"...","label":"...","config":{...}}   ← 修改现有节点（config 只写要改的字段）
   {"op":"remove_node","id":"..."}
   {"op":"add_edge","edge":{"source":"...","target":"...","sourceHandle":"..."}}
   {"op":"remove_edge","source":"...","target":"...","sourceHandle":"..."}
   {"op":"done","explanation":"两三句话说明这张图怎么跑","run":true}    ← 最后一行
 - 按执行顺序添加节点（先入口后出口）；每加一个节点，立刻把连向它的边（两端都已存在的）输出出来，让图连贯地生长
 - 修改现有图时只输出改动，没提到的节点不要动
+- update_node 按字段合并：config 只写要改的字段，没写的（tools、assign_to…）原样保留；
+  要删掉某个字段就写成 null。supervisor 的 agents 按成员 name 合并：只写要改的成员和字段，
+  成员没写 tools 就沿用它原来的工具；新名字是新增成员；去掉成员写 {"name":"…","remove":true}
 - done 里的 run：这张图建完要不要立刻执行。默认 true；用户要的是**流程本身**
   （"设计一个每天跑的工作流"）时给 false —— 他要的是这张图，不是这一次的结果
 - 如果这句话根本不需要工作流（见下面的路径约定），**第一行也是最后一行**就输出：
@@ -669,6 +706,64 @@ def _parse_op_line(line: str) -> dict[str, Any] | None:
 
 _NODE_TYPES = frozenset(t.value for t in NodeType)
 
+#: 协作成员条目里写 "remove": true 就把这个成员拿掉。不复用 null：null 在合并里
+#: 的意思是「删这个字段」，成员本身不是一个字段
+_REMOVE_MEMBER = "remove"
+
+
+def _member_key(member: dict[str, Any], index: int) -> str:
+    # 和 engine/nodes/multi.py 的叫法一致：没起名字的成员按位置叫 agentN
+    return str(member.get("name") or f"agent{index}")
+
+
+def _merge_fields(old: dict[str, Any], patch: dict[str, Any]) -> dict[str, Any]:
+    """按字段合并：写了的覆盖，写 null 的删掉，没写的原样保留。返回新 dict。"""
+    out = dict(old)
+    for key, value in patch.items():
+        if value is None:
+            out.pop(key, None)
+        else:
+            out[key] = value
+    return out
+
+
+def _merge_members(old: list[Any], patch: list[Any]) -> list[Any]:
+    """协作成员按 name 合并。原有成员保持原来的次序，新名字接在后面。"""
+    merged: list[Any] = list(old)
+    where = {_member_key(m, i): i for i, m in enumerate(merged) if isinstance(m, dict)}
+    dropped: set[int] = set()
+    for i, entry in enumerate(patch):
+        if not isinstance(entry, dict):
+            continue
+        key = _member_key(entry, i)
+        if entry.get(_REMOVE_MEMBER) is True:
+            if key in where:
+                dropped.add(where[key])
+            continue
+        fields = {k: v for k, v in entry.items() if k != _REMOVE_MEMBER}
+        if key in where:
+            merged[where[key]] = _merge_fields(merged[where[key]], fields)
+        else:
+            where[key] = len(merged)
+            merged.append({k: v for k, v in fields.items() if v is not None})
+    return [m for i, m in enumerate(merged) if i not in dropped]
+
+
+def merge_node_config(
+    node_type: str, old: dict[str, Any], patch: dict[str, Any]
+) -> dict[str, Any]:
+    """update_node 的 config 怎么落到节点上。前端 store/studio.ts 必须是同一套规则。
+
+    以前是整体替换：模型只想改一句提示词，照协议也得把整份 config 抄一遍，
+    漏抄的字段就没了。真出过事——改写提示词时漏了 tools，三个要查库的 agent
+    全丢了工具，一次库都没查，最后把一堆工具调用的原始标记当答案交了出去。
+    改成按字段合并之后，漏写等于不改；真要删一个字段得显式写 null。
+    """
+    if node_type == NodeType.SUPERVISOR.value and isinstance(patch.get("agents"), list):
+        members = old.get("agents") if isinstance(old.get("agents"), list) else []
+        patch = {**patch, "agents": _merge_members(members, patch["agents"])}
+    return _merge_fields(old, patch)
+
 
 def _apply_op(nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], op: dict[str, Any]) -> bool:
     """把一个操作应用到服务端维护的图状态。返回是否真的改了图。"""
@@ -690,10 +785,12 @@ def _apply_op(nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], op:
         node = nodes.get(op.get("id") or "")
         if not node:
             return False
+        data = node.setdefault("data", {})
         if op.get("label") is not None:
-            node["data"]["label"] = op["label"]
-        if op.get("config") is not None:
-            node["data"]["config"] = op["config"]
+            data["label"] = op["label"]
+        if isinstance(op.get("config"), dict):
+            data["config"] = merge_node_config(
+                str(node.get("type") or ""), data.get("config") or {}, op["config"])
         return True
     if kind == "remove_node":
         node_id = op.get("id")
@@ -809,21 +906,250 @@ def _sse(obj: dict[str, Any]) -> str:
     return f"data: {json.dumps(obj, ensure_ascii=False)}\n\n"
 
 
-def _blocking_issues(nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]]) -> list[Any] | None:
-    """按运行时同一套校验，挑出会挡住运行的问题。图本身不成形时返回 None。"""
+def _blocking_issues(
+    nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], scope: set[str] | None = None,
+) -> list[dict[str, Any]] | None:
+    """按运行时同一套校验，挑出会挡住运行的问题。图本身不成形时返回 None。
+
+    限定了数据源时，用了范围外的库也算：用户点了「只查这个库」，拿别的库的数
+    回答他，比跑不起来更糟——答案看起来是对的。
+
+    每条是 ValidationIssue 的字典形状（node_id、field 都在），和 final.issues 一样：
+    界面靠 node_id 定位卡片、靠 field 落到具体的输入框，不用从一行字里抠节点 id。
+    """
     try:
         spec = GraphSpec.model_validate({"nodes": list(nodes.values()), "edges": edges})
     except Exception:  # noqa: BLE001 - 结构不合法留给收尾那一步报
         return None
-    return [i for i in validate_graph(spec).issues if i.level == "error"]
+    return ([i.model_dump() for i in validate_graph(spec).issues if i.level == "error"]
+            + _issue_dicts(scope_issues(list(nodes.values()), scope), "datasource_out_of_scope"))
 
 
-def _issue_line(issue: Any) -> str:
-    return f"「{issue.node_id}」{issue.message}" if issue.node_id else issue.message
+def _source_of(tool: str) -> str | None:
+    from app.tools.datasource import QUERY_PREFIX, SCHEMA_PREFIX
+
+    for prefix in (QUERY_PREFIX, SCHEMA_PREFIX):
+        if tool.startswith(prefix):
+            return tool[len(prefix):]
+    return None
+
+
+def scope_issues(nodes: list[dict[str, Any]], scope: set[str] | None) -> list[ValidationIssue]:
+    """用了限定范围之外的数据源的节点，一个节点一条。"""
+    if scope is None:
+        return []
+    out: list[ValidationIssue] = []
+    for node in nodes:
+        cfg = (node.get("data") or {}).get("config") or {}
+        names = _tool_names(cfg.get("tools")) + _tool_names([cfg.get("tool")])
+        for member in cfg.get("agents") or []:
+            if isinstance(member, dict):
+                names += _tool_names(member.get("tools"))
+        outside = sorted({src for src in map(_source_of, names) if src and src not in scope})
+        if outside:
+            out.append(ValidationIssue(
+                level="error", node_id=node.get("id"),
+                message=f"用了限定范围之外的数据源 {'、'.join(outside)}：这一轮只查 "
+                        f"{'、'.join(sorted(scope))}，改用它们的 db_query__ / db_schema__ 工具",
+            ))
+    return out
+
+
+def _issue_dicts(issues: list[ValidationIssue], code: str) -> list[dict[str, Any]]:
+    return [{**i.model_dump(), "code": code} for i in issues]
+
+
+def _issue_line(issue: dict[str, Any]) -> str:
+    """交回模型的修正请求里，一条问题一行，节点 id 在前。"""
+    return f"「{issue['node_id']}」{issue['message']}" if issue.get("node_id") else issue["message"]
+
+
+# --------------------------------------------------------------------------
+# 工具绑定变化：改图前后，每个 agent 和每个协作成员各绑了哪些工具
+# --------------------------------------------------------------------------
+
+
+def _tool_names(value: Any) -> list[str]:
+    return [t for t in value if isinstance(t, str) and t] if isinstance(value, list) else []
+
+
+def _tool_bindings(nodes: list[dict[str, Any]]) -> dict[tuple[str, str | None], dict[str, Any]]:
+    """(节点 id, 成员名) → {label, tools, field}。成员名为 None 的是 agent 节点本身。"""
+    out: dict[tuple[str, str | None], dict[str, Any]] = {}
+    for node in nodes:
+        data = node.get("data") or {}
+        cfg = data.get("config") or {}
+        label = data.get("label") or node.get("id")
+        if node.get("type") == NodeType.AGENT.value:
+            out[(node["id"], None)] = {"label": label, "field": "tools",
+                                       "tools": _tool_names(cfg.get("tools"))}
+        elif node.get("type") == NodeType.SUPERVISOR.value:
+            for i, member in enumerate(cfg.get("agents") or []):
+                if isinstance(member, dict):
+                    out[(node["id"], _member_key(member, i))] = {
+                        "label": label, "field": f"agents[{i}].tools",
+                        "tools": _tool_names(member.get("tools")),
+                    }
+    return out
+
+
+def tool_changes(
+    before: list[dict[str, Any]], after: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    """改图前后都在、而绑定的工具不一样了的节点和成员，按改后的图排序。
+
+    新加的、删掉的节点不算：那是结构变化，改图回执本来就会列出来。这里要抓的
+    是「节点还在、工具悄悄没了」——画布上看起来什么都没变，跑起来才发现查不了库。
+    """
+    old = _tool_bindings(before)
+    out: list[dict[str, Any]] = []
+    for (node_id, member), now in _tool_bindings(after).items():
+        was = old.get((node_id, member))
+        if was is None or set(was["tools"]) == set(now["tools"]):
+            continue
+        out.append({
+            "node_id": node_id, "label": now["label"], "member": member, "field": now["field"],
+            "before": was["tools"], "after": now["tools"],
+            "added": [t for t in now["tools"] if t not in was["tools"]],
+            "removed": [t for t in was["tools"] if t not in now["tools"]],
+        })
+    return out
+
+
+# 指令里有没有让删工具。只认「删除动词直接管着工具」：动词和「工具 / 工具名」
+# 挨着、在同一个分句里、中间没有夹别的动作。以前是整句里有「不要 / 不用 / 取消」、
+# 别处又有「工具」就算——「这次要真的用工具查库，不要编造数字」被当成让删工具，
+# 警告关掉，没工具的图照样自动运行。宁可在真让删时多提醒一句，也不能漏掉这种。
+
+#: 删除动词。「不要 / 不用 / 别」只在直接接着工具（或接「用 / 绑」再接工具）时才算
+_DROP_VERB = re.compile(
+    r"去掉|去除|删掉|删除|删了|删去|移除|拿掉|撤掉|撤下|解绑|解除绑定|禁用|停用|卸掉|剔除|砍掉|清空|取消"
+    r"|(?:不要|不用|不需要|无需|用不着|不再|别)再?(?:使用|调用|绑定|用|绑|挂)?"
+    r"|\b(?:remov(?:e|ing)|drop(?:ping)?|unbind|detach|disable|without|get rid of|no longer use)\b"
+    r"|\b(?:don't|do not|never|stop) us(?:e|ing)\b"
+)
+#: 工具在前、动词在后：「把查表的工具去掉」「db_schema__shop 不要了」
+_DROP_AFTER = re.compile(
+    r"去掉|去除|删掉|删除|删了|删去|移除|拿掉|撤掉|撤下|解绑|禁用|停用|卸掉|剔除|砍掉|清空"
+    r"|(?:不要|不用|不需要|用不着)再?(?:用|绑)?(?:了|$)|\b(?:removed|dropped)\b"
+)
+#: 「只保留 X」：别的可以删，但 X 本身不能跟着没了，更不能删光。「只用」只认点了名的——
+#: 「只用工具查库」说的是别编，不是让删哪个工具
+_KEEP_ONLY = re.compile(r"(只保留|只留下|只留|仅保留|\bkeep only\b|\bonly keep\b)"
+                        r"|(只用|仅用|\bonly use\b)")
+#: 动词和工具之间夹了这些，动词管的就不是工具了：「不用改工具」「别用假设的方式调用工具」
+_GAP_BREAK = re.compile(
+    r"改|动|换|变成|编|捏造|虚构|假设|假装|模拟|猜|然后|接着|并且|同时|但|而是|让|把|将|保留|留着|保持|只|必须|一定"
+    r"|make up|made up|making up|\b(?:then|but|instead|change|edit|modify|keep|fake|invent|pretend)\b"
+)
+#: 否定。中文只往前看几个字（「不要去掉工具」「别把工具删了」），英文的否定离动词远，看整个分句
+_NEGATED = re.compile(r"不要|不用|不能|不许|不准|不得|不可|不必|不想|不希望|不让|无需|没让|别|勿|千万")
+_NEGATED_EN = re.compile(r"\b(?:don't|dont|do not|never|no need|not|can't|cannot)\b")
+#: 工具后面紧跟着这些，说的是留着它：「工具保留」「工具不用改」
+_KEPT_AFTER = re.compile(r"\s*(?:都|也|就|还|先)?(?:保留|留着|不变|照旧|保持|别动|不动|不要动|不用动|"
+                         r"不要改|不用改|别改|别删|不要删|不能删)|\s*(?:stay|unchanged|as is)\b")
+_CLAUSE = re.compile(r"[，,。;；！!？?\n]|\.(?=\s|$)")
+_GENERIC = ("工具", "tool", "tools")
+_GAP, _GAP_AFTER, _LOOKBACK = 16, 8, 10
+
+
+def _tool_object(removed: list[str]) -> re.Pattern[str]:
+    """「工具」或一个工具名：这次删掉的、内置的，以及带 __ 的（db_query__x、MCP 工具）。
+
+    只认像工具的名字：表名、字段名也是下划线写法，「去掉 sales_daily 相关的工具」
+    里点名的不是工具。
+    """
+    names = sorted({t.lower() for t in [*removed, *all_specs()] if t}, key=len, reverse=True)
+    return re.compile("|".join([*map(re.escape, names), r"[a-z][a-z0-9_]*__[a-z0-9_-]+",
+                                "工具", r"\btools?\b"]))
+
+
+def _negated(clause: str, pos: int) -> bool:
+    return bool(_NEGATED.search(clause, max(0, pos - _LOOKBACK), pos)
+                or _NEGATED_EN.search(clause, 0, pos))
+
+
+def _drop_request(instruction: str, removed: list[str]) -> tuple[bool, set[str], set[str] | None]:
+    """指令里让删了哪些工具：(泛指「工具」, 点了名的, 「只保留」留下的——没说只保留是 None)。"""
+    target = _tool_object(removed)
+    dropped: set[str] = set()
+    kept: set[str] | None = None
+
+    def near(clause: str, start: int) -> re.Match[str] | None:
+        obj = target.search(clause, start)
+        return obj if obj and obj.start() - start <= _GAP else None
+
+    for clause in _CLAUSE.split((instruction or "").lower()):
+        for verb in _DROP_VERB.finditer(clause):
+            obj = near(clause, verb.end())
+            if not obj:
+                continue
+            gap = clause[verb.end():obj.start()]
+            if (_GAP_BREAK.search(gap) or _DROP_VERB.search(gap) or _negated(clause, verb.start())
+                    or _KEPT_AFTER.match(clause, obj.end())):
+                continue
+            dropped.add(obj.group())
+        for obj in target.finditer(clause):
+            verb = _DROP_AFTER.search(clause, obj.end())
+            if not verb or verb.start() - obj.end() > _GAP_AFTER:
+                continue
+            gap = clause[obj.end():verb.start()]
+            if _GAP_BREAK.search(gap) or _NEGATED.search(gap) or _negated(clause, obj.start()):
+                continue
+            dropped.add(obj.group())
+        for verb in _KEEP_ONLY.finditer(clause):
+            obj = near(clause, verb.end())
+            if obj and not (verb.group(2) and obj.group() in _GENERIC):
+                kept = (kept or set()) | {obj.group()}
+    return bool(dropped & set(_GENERIC)), dropped - set(_GENERIC), kept
+
+
+def _unasked_drops(instruction: str, change: dict[str, Any]) -> list[str]:
+    """这次少掉的工具里，哪些是指令没让删的。"""
+    generic, named, kept = _drop_request(instruction, change["removed"])
+    if generic:
+        return []
+
+    def asked(tool: str) -> bool:
+        if tool.lower() in named:
+            return True
+        # 「只保留 X」：X 以外的可以删；但一个都不剩就不是「保留」了
+        return kept is not None and bool(change["after"]) and tool.lower() not in kept
+
+    return [t for t in change["removed"] if not asked(t)]
+
+
+def dropped_tool_warnings(changes: list[dict[str, Any]], instruction: str) -> list[dict[str, Any]]:
+    """工具集合变小了、而这一轮没让删工具的，逐个报 warning。
+
+    只报变小的：把 db_query__a 换成 db_query__b 是正常的改图，数量没少不必大惊
+    小怪。也不打回去让模型重改——删工具有可能是对的，该让人看一眼，而不是再
+    赌一次模型。
+    """
+    out: list[dict[str, Any]] = []
+    for c in changes:
+        if not c["removed"] or len(set(c["after"])) >= len(set(c["before"])):
+            continue
+        unasked = _unasked_drops(instruction, c)
+        if not unasked:
+            continue
+        who = f"「{c['label']}」" + (f"的成员「{c['member']}」" if c["member"] else "")
+        now = f" {'、'.join(c['after'])}" if c["after"] else "空"
+        said = ("这一轮的要求里没有提到去掉工具" if len(unasked) == len(c["removed"])
+                else f"这一轮的要求里没有提到去掉 {'、'.join(unasked)}")
+        cost = ("没有绑定工具，它只能「假设」调用，查不了库" if not c["after"]
+                else f"{'、'.join(unasked)} 它就调不到了")
+        out.append({
+            "level": "warning", "node_id": c["node_id"], "edge_id": None,
+            "code": "tools_dropped", "field": c["field"],
+            "message": f"{who}的工具从 {'、'.join(c['before'])} 变成了{now}。"
+                       f"{said}，确认一下是不是改漏了：{cost}",
+        })
+    return out
 
 
 def _repair_request(
-    nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], errors: list[Any],
+    nodes: dict[str, dict[str, Any]], edges: list[dict[str, Any]], errors: list[dict[str, Any]],
 ) -> str:
     graph = {"nodes": list(nodes.values()), "edges": edges}
     return (
@@ -832,7 +1158,8 @@ def _repair_request(
         "上线前自查（和真正运行时同一套规则）发现下面这些问题，不改的话这张图跑不起来：\n"
         + "\n".join(f"- {_issue_line(i)}" for i in errors)
         + "\n\n只修这些问题，别的不要动。用操作流输出修正：改节点用 update_node"
-          "（config 整体替换，要带上这个节点完整的 config）；缺节点、缺边就补上。最后一行输出 done。"
+          "（config 只写要改的字段，没写的保持原样；要删掉一个字段写 null）；"
+          "缺节点、缺边就补上。最后一行输出 done。"
     )
 
 
@@ -845,8 +1172,10 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
     """
     from fastapi.responses import StreamingResponse
 
-    tool_list = await _tool_catalog(session)
-    datasources = await _datasource_section(session)
+    sources = await _sources(session, payload.datasource_ids)
+    scope = {r.name for r in sources} if payload.datasource_ids else None
+    tool_list = _tool_catalog(sources)
+    datasources = _datasource_section(sources) + _scope_note(sources, scope is not None)
     system = (
         "你是一个 agent 工作流编排专家。根据用户需求，以操作流的方式逐步搭出一张可执行的工作流图。\n\n"
         f"{NODE_REFERENCE}\n\n可用工具：\n{tool_list}{datasources}\n\n"
@@ -865,8 +1194,9 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
     # 用户摆好的坐标，收尾排版时原样留着
     pinned = _pinned_positions(payload.base_graph)
     if payload.base_graph and payload.base_graph.get("nodes"):
+        # 拷一份再改：改之前的样子还要留着比对工具绑定有没有被改掉
         for n in payload.base_graph["nodes"]:
-            nodes[n["id"]] = n
+            nodes[n["id"]] = copy.deepcopy(n)
         edges = [
             {k: v for k, v in e.items() if k in ("source", "target", "sourceHandle")}
             for e in payload.base_graph.get("edges") or []
@@ -889,6 +1219,9 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
                 ("human", _with_history(user, await _history_section(session, payload.conversation_id)))]
     # 兜底用：模型只发了改动操作时，把它们重放到这张图上
     prev_graph = await _previous_graph(session, payload.conversation_id)
+    # 比对工具绑定的基准：画布上是改之前的图；问数据页是上一轮的图（沿用它的节点 id）
+    baseline = copy.deepcopy(
+        (payload.base_graph or {}).get("nodes") or (prev_graph or {}).get("nodes") or [])
 
     async def event_stream():
         explanation = ""
@@ -939,7 +1272,7 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
         if not nodes and prev_graph and seen_ops:
             for n in prev_graph.get("nodes") or []:
                 if n.get("id"):
-                    nodes[n["id"]] = n
+                    nodes[n["id"]] = copy.deepcopy(n)
             # 原地改，不能重新绑定：给 edges 赋值会让它变成 event_stream 的局部
             # 变量，而它在上面 _apply_op 那一路已经被读过了 —— UnboundLocalError
             edges[:] = [
@@ -954,11 +1287,10 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
         # 循环 / 分支条件里套了 {{ }}），前面的步骤白跑，报错还停在半路
         repaired = 0
         for round_no in range(1, _SELF_CHECK_ROUNDS + 1):
-            errors = _blocking_issues(nodes, edges)
+            errors = _blocking_issues(nodes, edges, scope)
             if not errors:
                 break
-            yield _sse({"op": "check", "status": "repairing", "round": round_no,
-                        "issues": [_issue_line(i) for i in errors]})
+            yield _sse({"op": "check", "status": "repairing", "round": round_no, "issues": errors})
             fix = [("system", system), ("human", _repair_request(nodes, edges, errors))]
             try:
                 async for op in _with_heartbeat(_iter_ops(model, fix), phase="repairing"):
@@ -973,15 +1305,20 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
                             "message": f"自查修正没跑成：{explain_error(e)[0]}", "detail": raw_error(e)})
                 break
             repaired = round_no
-        remaining = _blocking_issues(nodes, edges)
+        remaining = _blocking_issues(nodes, edges, scope)
+        # 工具绑定变化不挡运行，但要在自查这一步就说出来：工具被改没了的图照样
+        # 能跑，只是跑出来的是模型「假设」查过库的答案
+        changes = tool_changes(baseline, list(nodes.values()))
+        warnings = dropped_tool_warnings(changes, payload.instruction)
         if remaining:
             # 改不好也照实交付、列出问题，但不自动运行：明知跑不起来的图，开跑只会
             # 在半路报一个用户看不懂的错
             autorun = False
-            yield _sse({"op": "check", "status": "failed",
-                        "issues": [_issue_line(i) for i in remaining]})
+            yield _sse({"op": "check", "status": "failed", "issues": remaining,
+                        "warnings": warnings})
         elif remaining is not None:
-            yield _sse({"op": "check", "status": "passed", "repaired": repaired})
+            yield _sse({"op": "check", "status": "passed", "repaired": repaired,
+                        "warnings": warnings})
 
         # 收尾：排版 + 校验，把最终图整体交付。改图时旧节点留在原处，只排新节点
         try:
@@ -989,6 +1326,8 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
                 GraphSpec.model_validate({"nodes": list(nodes.values()), "edges": edges}), pinned,
             )
             issues = [i.model_dump() for i in validate_graph(spec).issues]
+            issues += _issue_dicts(scope_issues(list(nodes.values()), scope),
+                                   "datasource_out_of_scope")
             # 跳过的节点要说出来，不能安静地少一步。code 给前端认：这一类要单独
             # 提示「少了一步」，不能和普通校验警告混在一起
             issues += [
@@ -1000,10 +1339,12 @@ async def generate_stream(payload: GenerateIn, session: AsyncSession = Depends(g
             final = {
                 "op": "final",
                 "graph": spec.model_dump(mode="json"),
-                "issues": issues,
+                "issues": issues + warnings,
                 "explanation": explanation,
                 "autorun": autorun,
                 "layout": layout,
+                # 改图回执：哪些节点、成员的工具变了。画布上看不出来，得明说
+                "tool_changes": changes,
             }
         except Exception as e:  # noqa: BLE001
             final = {"op": "error", "message": f"模型交回的工作流结构不对：{graph_error(e)}",
diff --git a/backend/app/api/datasources.py b/backend/app/api/datasources.py
index 4e5399d6..ff5c8c60 100644
--- a/backend/app/api/datasources.py
+++ b/backend/app/api/datasources.py
@@ -8,16 +8,20 @@ from __future__ import annotations
 from datetime import datetime, timezone
 from typing import Any
 
-from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, UploadFile
 from pydantic import BaseModel, Field
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.errors import explain, first_line, raw
+from app.api import health
+from app.core.errors import explain, first_line, raw
 from app.core.config import settings
 from app.core.crypto import encrypt, mask
 from app.data import introspect as introspect_mod
-from app.data.engine import SUPPORTED_KINDS, build_url, engine_args, engines
+from app.data.engine import (
+    MAX_QUERY_TIMEOUT_S, QUERY_TIMEOUT_OPTION, SUPPORTED_KINDS, build_url, engine_args, engines,
+    query_timeout_problem,
+)
 from app.db.base import get_session
 from app.db.models import DataSource
 from app.tools.datasource import tool_names
@@ -79,12 +83,27 @@ class DataSourceOut(BaseModel):
     #: 这台服务器上还有哪些库/schema 可选。探不到表时它就是下一步的线索
     available_schemas: list[str] = Field(default_factory=list)
     tools: list[str] = Field(default_factory=list)
+    #: 缓存是按哪个 schema 探的："" 是默认 schema，None 是没有缓存（或老缓存没记）。
+    #: 和 options.schema 对不上时，助手看到的结构不是配置里那个 schema 的
+    cached_schema: str | None = None
+    #: 最近一次测连接（见 app/api/health.py）。没测过、或者连接配置改过之后都是 None
+    last_checked_at: str | None = None
+    last_check_ok: bool | None = None
+    last_latency_ms: int | None = None
+    last_error: str | None = None
+
+
+def _cached_schema(cache: dict[str, Any]) -> str | None:
+    if not cache or "schema" not in cache:
+        return None
+    return str(cache.get("schema") or "")
 
 
 def _to_out(row: DataSource) -> DataSourceOut:
     cache = row.schema_cache or {}
     tables = cache.get("tables") or {}
     return DataSourceOut(
+        cached_schema=_cached_schema(cache),
         schema_error=str(cache.get("error") or "") if cache.get("failed") else "",
         available_schemas=list(cache.get("available_schemas") or []),
         id=row.id, name=row.name, kind=row.kind, host=row.host, port=row.port,
@@ -95,9 +114,27 @@ def _to_out(row: DataSource) -> DataSourceOut:
         table_count=len(tables),
         schema_synced_at=row.schema_synced_at.isoformat() if row.schema_synced_at else None,
         tools=tool_names(row),
+        **health.fields(row.last_check),
     )
 
 
+def _connection(source: Any) -> str | None:
+    """连接配置的指纹：驱动实际拿到的连接串和参数。配置拼不出连接串时为 None。
+
+    按连接串比而不是按字段比：Oracle 的服务名填在「数据库」还是 options 里，
+    连的是同一个库；探查用的 schema 不进连接串，改它也不影响连不连得上。
+    """
+    try:
+        url, extra = engine_args(source)
+    except Exception:  # noqa: BLE001 - 拼不出来就谈不上「测的是同一份」
+        return None
+    return health.fingerprint("datasource", url, extra)
+
+
+def _probe_record(result: dict[str, Any]) -> dict[str, Any]:
+    return health.record(result.get("ok"), result.get("elapsed_ms"), result.get("error"))
+
+
 async def _get_or_404(session: AsyncSession, source_id: str) -> DataSource:
     row = await session.get(DataSource, source_id)
     if not row:
@@ -111,6 +148,19 @@ async def list_sources(session: AsyncSession = Depends(get_session)) -> list[Dat
     return [_to_out(r) for r in rows]
 
 
+#: 每种库都有的「查询时限」。数据库按它自己停下语句，不只是后端不再等
+_TIMEOUT_FIELD = {
+    "key": QUERY_TIMEOUT_OPTION, "label": "查询时限（秒）", "placeholder": "30",
+    "help": f"一条查询最多跑多久，到点由数据库自己停下；留空是 30 秒，最多 {MAX_QUERY_TIMEOUT_S} 秒",
+}
+
+
+def _refuse_bad_options(options: dict[str, Any] | None) -> None:
+    problem = query_timeout_problem(options)
+    if problem:
+        raise HTTPException(422, problem)
+
+
 @router.get("/kinds")
 async def list_kinds() -> dict[str, Any]:
     """支持哪些数据库，以及各自需要填什么——前端表单据此渲染。
@@ -124,11 +174,12 @@ async def list_kinds() -> dict[str, Any]:
             {"value": "mysql", "label": "MySQL / MariaDB", "default_port": 3306,
              "needs": ["host", "database", "username", "password"],
              "hint": "字符集默认 utf8mb4，要换就在「高级连接参数」里加 charset",
-             "advanced": [{"key": "charset", "label": "字符集", "placeholder": "utf8mb4"}]},
+             "advanced": [{"key": "charset", "label": "字符集", "placeholder": "utf8mb4"},
+                          _TIMEOUT_FIELD]},
             {"value": "postgres", "label": "PostgreSQL", "default_port": 5432,
              "needs": ["host", "database", "username", "password"],
              "hint": "「schema」留空就用 public",
-             "advanced": []},
+             "advanced": [_TIMEOUT_FIELD]},
             {"value": "oracle", "label": "Oracle", "default_port": 1521,
              "needs": ["host", "username", "password"],
              "hint": "service_name 和 SID 二选一：一般填 service_name，老库只给了 SID 就切到 SID。"
@@ -139,10 +190,11 @@ async def list_kinds() -> dict[str, Any]:
                  {"key": "service_name", "label": "service_name", "placeholder": "ORCLPDB1",
                   "help": "和 SID 二选一"},
                  {"key": "sid", "label": "SID", "placeholder": "ORCL", "help": "和 service_name 二选一"},
+                 _TIMEOUT_FIELD,
              ]},
             {"value": "sqlite", "label": "SQLite（文件）", "default_port": None,
              "needs": ["database"], "hint": "「数据库文件路径」填 .db 文件的绝对路径",
-             "advanced": []},
+             "advanced": [_TIMEOUT_FIELD]},
         ],
         "supported": list(SUPPORTED_KINDS),
     }
@@ -189,12 +241,15 @@ async def create_source(
     )).scalar_one_or_none()
     if exists:
         raise HTTPException(409, f"已经有叫「{payload.name}」的数据源了，换个标识")
+    _refuse_bad_options(payload.options)
 
     row = DataSource(
         **payload.model_dump(exclude={"password"}),
         password=encrypt(payload.password),
     )
     _settle_oracle(row, None, None)
+    # 表单里刚测过这份配置：保存下来就带着那次结果，不必再测一遍
+    row.last_check = health.draft_result(_connection(row))
     session.add(row)
     await session.commit()
     await session.refresh(row)
@@ -207,13 +262,20 @@ async def update_source(
 ) -> DataSourceOut:
     row = await _get_or_404(session, source_id)
     data = payload.model_dump(exclude_unset=True)
+    if "options" in data:
+        _refuse_bad_options(data["options"])
     if "password" in data:
         # 空串表示清空，非空表示换新的
         data["password"] = encrypt(data["password"]) if data["password"] else None
     old_options, old_database = dict(row.options or {}), row.database
+    before = _connection(row)
     for key, value in data.items():
         setattr(row, key, value)
     _settle_oracle(row, old_options, old_database)
+    after = _connection(row)
+    if after != before:
+        # 连的已经不是测过的那个了：旧结果作废，表单里测过这一份的话换成那一次
+        row.last_check = health.draft_result(after)
     await session.commit()
     await session.refresh(row)
     # 连接参数可能变了，旧连接池不能再用——否则改完密码还在用旧连接，很难排查
@@ -386,27 +448,72 @@ async def test_draft(
         return {"ok": False, "error": f"不支持「{payload.kind}」这种数据库",
                 "hint": f"支持：{'、'.join(SUPPORTED_KINDS)}", "detail": "", "elapsed_ms": 0, "url": ""}
     saved = await session.get(DataSource, payload.id) if payload.id else None
-    return await _probe(_draft_source(payload, saved), cached=False)
+    draft = _draft_source(payload, saved)
+    result = await _probe(draft, cached=False)
+    last, key = _probe_record(result), _connection(draft)
+    health.remember_draft(key, last)
+    if saved is not None and key is not None and key == _connection(saved):
+        # 编辑框里没改连接、只是再测一次：测的就是已保存的那份
+        saved.last_check = last
+        await session.commit()
+    return result
 
 
 @router.post("/{source_id}/test")
 async def test_source(source_id: str, session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
     """测连接。失败时说清原因和怎么办，驱动的原始报错放在 detail——这类问题九成靠它定位。"""
     row = await _get_or_404(session, source_id)
-    return await _probe(row, cached=True)
+    result = await _probe(row, cached=True)
+    row.last_check = _probe_record(result)
+    await session.commit()
+    return result
 
 
-@router.post("/{source_id}/introspect", response_model=DataSourceOut)
+class IntrospectPreview(BaseModel):
+    """只看不存的探查结果。缓存、同步时间都没动。"""
+
+    dry_run: bool = True
+    #: 这次探的是哪个 schema，"" 是默认 schema
+    schema_: str = Field(default="", serialization_alias="schema")
+    table_count: int = 0
+    #: 带 schema 前缀的对象全名，最多 200 个（和真探查的上限一样）
+    tables: list[str] = Field(default_factory=list)
+    truncated: bool = False
+    total: int = 0
+    schema_error: str = ""
+    available_schemas: list[str] = Field(default_factory=list)
+
+
+@router.post("/{source_id}/introspect", response_model=DataSourceOut | IntrospectPreview)
 async def introspect_source(
-    source_id: str, schema: str | None = None, session: AsyncSession = Depends(get_session)
-) -> DataSourceOut:
-    """探查结构并缓存。显式动作，不做后台轮询——生产库不该被实验工具定时扫。"""
+    source_id: str,
+    schema: str | None = None,
+    dry_run: bool = Query(default=False, description="只返回探到的结构，不写缓存"),
+    session: AsyncSession = Depends(get_session),
+) -> DataSourceOut | IntrospectPreview:
+    """探查结构并缓存。显式动作，不做后台轮询——生产库不该被实验工具定时扫。
+
+    dry_run=true 只看不存：「换个 schema 看看」以前一探就把缓存换掉，用户随后
+    选了「不改」，助手此刻看到的也已经是另一套表了。
+    """
     row = await _get_or_404(session, source_id)
     try:
-        row.schema_cache = await introspect_mod.introspect(row, schema=schema)
+        cache = await introspect_mod.introspect(row, schema=schema)
     except Exception as e:  # noqa: BLE001
         reason, hint = _explain_connect(e, (row.kind or "").lower())
         raise HTTPException(400, f"探查表结构失败：{reason}" + (f"。{hint}" if hint else "")) from e
+    if dry_run:
+        tables = cache.get("tables") or {}
+        return IntrospectPreview(
+            schema_=str(cache.get("schema") or ""),
+            table_count=len(tables),
+            tables=[m.get("qualified", n) for n, m in tables.items()],
+            truncated=bool(cache.get("truncated")),
+            total=int(cache.get("total") or 0),
+            schema_error=str(cache.get("error") or "") if cache.get("failed") else "",
+            available_schemas=list(cache.get("available_schemas") or []),
+        )
+    row.schema_cache = cache
     # 失败也要把缓存存下来——里面的 available_schemas 正是下一步的线索——
     # 但**不能盖上"已同步"的戳**。以前盖了，于是界面显示同步过、工具却说
     # "还没探查过"，两边都不说真话（run 554a0f92）
@@ -422,7 +529,17 @@ async def get_schema(source_id: str, table: str | None = None,
                      session: AsyncSession = Depends(get_session)) -> dict[str, Any]:
     row = await _get_or_404(session, source_id)
     if table:
-        return {"table": table, "detail": introspect_mod.describe_table(row, table)}
+        meta = introspect_mod.find_table(row, table)
+        return {
+            "table": table,
+            # 给模型看的那段文本照旧；界面画表格用下面的结构化字段
+            "detail": introspect_mod.describe_table(row, table),
+            "found": meta is not None,
+            "qualified": meta.get("qualified", table) if meta else None,
+            "kind": ("view" if meta.get("is_view") else "table") if meta else None,
+            "comment": meta.get("comment") if meta else None,
+            "columns": introspect_mod.table_columns(meta) if meta else [],
+        }
     return {
         "tables": introspect_mod.table_names(row),
         "summary": introspect_mod.summary(row),
diff --git a/backend/app/api/errors.py b/backend/app/api/errors.py
deleted file mode 100644
index ea996e7b..00000000
--- a/backend/app/api/errors.py
+++ /dev/null
@@ -1,139 +0,0 @@
-"""面向用户的报错：说清发生了什么、为什么、怎么办，不把 Python 异常类名端上去。
-
-以前各处都是 f"{type(e).__name__}: {e}"，界面首行红字是
-「_make_query_tool.<locals>._run() got an unexpected keyword argument 'query'」
-——对业务用户是天书，也没有下一步。原始异常不丢：调用方把 raw(e) 放进响应的
-detail 字段或写进日志，排查时照样找得到。
-
-判断按类名走 MRO，不 import 各家 SDK：没装的驱动和 SDK 不该让报错这一层
-也跟着 ImportError。
-"""
-from __future__ import annotations
-
-import re
-from typing import Any
-
-_TIMEOUT = {"TimeoutError", "TimeoutException", "APITimeoutError", "ReadTimeout",
-            "ConnectTimeout", "PoolTimeout", "WriteTimeout"}
-_NETWORK = {"ConnectError", "ConnectionError", "APIConnectionError", "gaierror",
-            "ClientConnectorError", "RemoteProtocolError"}
-_AUTH = {"AuthenticationError", "PermissionDeniedError", "InvalidPasswordError",
-         "InvalidAuthorizationSpecificationError"}
-#: 这几类是程序自己的毛病，str(e) 里全是内部符号，原样端上去只会更糊涂
-_BUG = {"TypeError", "AttributeError", "KeyError", "NameError", "IndexError",
-        "UnboundLocalError", "AssertionError", "RecursionError"}
-
-#: SQLAlchemy 包过的驱动异常开头是「(sqlite3.OperationalError) 」
-_WRAPPED = re.compile(r"^\([\w.]+\)\s*")
-
-
-def raw(e: BaseException) -> str:
-    """原始报错，给「技术细节」折叠区和日志用。"""
-    return f"{type(e).__name__}: {e}"
-
-
-def _status(e: BaseException) -> int | None:
-    for obj in (e, getattr(e, "response", None)):
-        code = getattr(obj, "status_code", None)
-        if isinstance(code, int):
-            return code
-    return None
-
-
-def first_line(e: BaseException) -> str:
-    """异常自己的说明，去掉驱动包装的类名前缀和 SQLAlchemy 的文档链接。"""
-    text = str(e).strip()
-    line = text.splitlines()[0] if text else ""
-    return _WRAPPED.sub("", line)[:300]
-
-
-def explain(e: BaseException) -> tuple[str, str]:
-    """(原因, 怎么办)。原因是一句人话；说不出怎么办时第二项是空串。"""
-    names = {c.__name__ for c in type(e).__mro__}
-    low = str(e).lower()
-    status = _status(e)
-
-    if status in (401, 403) or names & _AUTH or "invalid api key" in low or "unauthorized" in low:
-        return "对方拒绝了这把密钥", "核对 API Key 有没有填错、过期，或者这个账号有没有权限"
-    if status == 404 or "NotFoundError" in names:
-        return "对方说找不到", "核对地址的路径（常见的是少了或多了 /v1）和模型名"
-    if status == 429 or "RateLimitError" in names:
-        return "请求被对方限流了", "等一会儿再试；频繁出现就检查账号额度"
-    if isinstance(status, int) and status >= 500:
-        return f"对方服务出错了（HTTP {status}）", "这是对方的问题，稍后再试"
-    if names & _TIMEOUT or "timed out" in low:
-        return "等了太久没有响应", "对方可能很忙或者网络不稳，稍后再试；一直超时就检查地址和网络"
-    if names & _NETWORK or any(s in low for s in (
-        "connection refused", "nodename nor servname", "name or service not known",
-        "all connection attempts failed", "network is unreachable",
-    )):
-        return "连不上对方的服务", "核对地址和端口，确认服务已经启动、这台机器访问得到它"
-    if "JSONDecodeError" in names:
-        return "对方返回的不是 JSON", "地址多半指到了网页而不是 API，核对 Base URL"
-    if "ValidationError" in names and callable(getattr(e, "errors", None)):
-        return f"参数不对：{_first_validation(e)}", ""
-    if names & _BUG:
-        return "后端内部出错了", "这不是你操作的问题；把技术细节发给维护者"
-    return first_line(e) or "出了一个没有说明的错误", ""
-
-
-def message(e: BaseException, lead: str = "") -> str:
-    """一整句：lead + 原因 + 怎么办。给只能放一个字符串的地方（HTTPException 的 detail）。"""
-    reason, hint = explain(e)
-    text = f"{lead}{reason}" if lead else reason
-    return f"{text}。{hint}" if hint else text
-
-
-def payload(e: BaseException, lead: str = "") -> dict[str, Any]:
-    """{ok: false, error, hint, detail}：测试连接这类「失败也是正常结果」的接口用。"""
-    reason, hint = explain(e)
-    return {"ok": False, "error": f"{lead}{reason}", "hint": hint, "detail": raw(e)}
-
-
-def not_configured(e: BaseException) -> str:
-    """模型接入没配好时的原话用的是内部叫法（provider 'x'、base_url），换成设置页上的说法。"""
-    text = re.sub(r"provider '([^']*)'", r"模型接入「\1」", str(e))
-    text = re.sub(r"模型 '([^']*)'", r"模型「\1」", text)
-    return text.replace("base_url", "Base URL").rstrip("。")
-
-
-def _has_cjk(text: str) -> bool:
-    return any("一" <= ch <= "鿿" for ch in text)
-
-
-def _first_validation(e: Any) -> str:
-    err = (e.errors() or [{}])[0]
-    loc = ".".join(str(p) for p in err.get("loc") or ())
-    msg = str(err.get("msg") or "").removeprefix("Value error, ")
-    if _has_cjk(msg):
-        return msg
-    return f"「{loc}」{'缺了' if err.get('type') == 'missing' else '格式不对'}" if loc else "格式不对"
-
-
-def graph_error(e: BaseException) -> str:
-    """工作流结构读不懂时，指到是哪个节点、哪一项。
-
-    pydantic 的原文是一大段英文，还列了全部十几种节点类型和一个文档链接，
-    用户从里面找不到自己错在哪。
-    """
-    errors = e.errors() if callable(getattr(e, "errors", None)) else None
-    if not errors:
-        return explain(e)[0]
-    err = errors[0]
-    loc = list(err.get("loc") or ())
-    msg = str(err.get("msg") or "").removeprefix("Value error, ")
-    more = f"（另有 {len(errors) - 1} 处）" if len(errors) > 1 else ""
-
-    if len(loc) >= 2 and loc[0] in ("nodes", "edges") and isinstance(loc[1], int):
-        where = f"第 {loc[1] + 1} 个{'节点' if loc[0] == 'nodes' else '连线'}"
-        field = str(loc[2]) if len(loc) > 2 else ""
-        if err.get("type") == "enum" and field == "type":
-            return f"{where}的类型「{err.get('input')}」不认识{more}"
-        if err.get("type") == "missing":
-            return f"{where}缺了「{field}」{more}"
-        if _has_cjk(msg):
-            return f"{where}：{msg}{more}"
-        return f"{where}的「{field or '内容'}」格式不对{more}"
-    if _has_cjk(msg):
-        return msg + more
-    return f"「{'.'.join(str(p) for p in loc) or '整体'}」格式不对{more}"
diff --git a/backend/app/api/health.py b/backend/app/api/health.py
new file mode 100644
index 00000000..8df5c0a2
--- /dev/null
+++ b/backend/app/api/health.py
@@ -0,0 +1,69 @@
+"""最近一次测连接的结果：数据源、模型接入、MCP 服务共用的一套记法。
+
+以前这份结果只在浏览器的 localStorage 里，换台电脑就全回到「未测试」。现在记在
+对象上（数据源、MCP 是 last_check 列，模型接入是 extra.last_check），列表接口
+平铺成 last_checked_at / last_check_ok / last_latency_ms / last_error 四个字段。
+
+表单里「先测再保存」的那一次也要算数：测的是草稿，保存时后端按连接配置的指纹
+认出「刚测过的就是这一份」，把结果带到新对象上。指纹只在进程里记一小会儿，
+用的是哈希，不留明文密码。
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from typing import Any
+
+from app.db.base import utcnow
+
+#: 草稿测完多久之内保存还算数。测完去倒杯水回来再点保存，也该认得出来
+_DRAFT_TTL = 15 * 60
+_DRAFT_MAX = 64
+_drafts: dict[str, tuple[float, dict[str, Any]]] = {}
+
+
+def record(ok: bool, latency_ms: int | None, error: str | None = None) -> dict[str, Any]:
+    return {
+        "at": utcnow().isoformat(),
+        "ok": bool(ok),
+        "latency_ms": None if latency_ms is None else int(latency_ms),
+        "error": None if ok else (error or "连不上"),
+    }
+
+
+def fields(last: dict[str, Any] | None) -> dict[str, Any]:
+    """对象上记的那份 → 列表接口的四个字段。没测过全是 None。"""
+    last = last if isinstance(last, dict) else {}
+    ok = last.get("ok")
+    return {
+        "last_checked_at": last.get("at"),
+        "last_check_ok": ok if isinstance(ok, bool) else None,
+        "last_latency_ms": last.get("latency_ms"),
+        "last_error": last.get("error"),
+    }
+
+
+def fingerprint(*parts: Any) -> str:
+    """连接配置的指纹。同一份配置得出同一个值；只拿来比对，不可逆。"""
+    blob = json.dumps(parts, sort_keys=True, ensure_ascii=False, default=str)
+    return hashlib.sha256(blob.encode()).hexdigest()
+
+
+def remember_draft(key: str | None, last: dict[str, Any]) -> None:
+    if not key:
+        return
+    now = time.monotonic()
+    for stale in [k for k, (at, _) in _drafts.items() if now - at > _DRAFT_TTL]:
+        _drafts.pop(stale, None)
+    if len(_drafts) >= _DRAFT_MAX:
+        _drafts.pop(min(_drafts, key=lambda k: _drafts[k][0]), None)
+    _drafts[key] = (now, last)
+
+
+def draft_result(key: str | None) -> dict[str, Any] | None:
+    """这份配置最近在表单里测过的结果，没有或太久了返回 None。"""
+    hit = _drafts.get(key or "")
+    if not hit or time.monotonic() - hit[0] > _DRAFT_TTL:
+        return None
+    return dict(hit[1])
diff --git a/backend/app/api/knowledge.py b/backend/app/api/knowledge.py
index 02e4a2c8..3a609877 100644
--- a/backend/app/api/knowledge.py
+++ b/backend/app/api/knowledge.py
@@ -10,7 +10,7 @@ from pydantic import BaseModel, Field
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.errors import explain, raw
+from app.core.errors import explain, raw
 from app.core.config import settings
 from app.db.base import get_session
 from app.db.models import Document, MemoryItem, Skill
@@ -433,20 +433,129 @@ async def probe_embedding(base_url: str) -> dict[str, Any]:
     return {"base_url": base_url, "models": models}
 
 
+class _ReindexJob:
+    """一次重建索引。进度按批更新：kb / store 每提交一批回调一次，不插值。"""
+
+    def __init__(self, collection: str | None, chunks: int, memories: int) -> None:
+        from app.db.base import new_id, utcnow
+
+        self.id = new_id()
+        self.collection = collection
+        self.state = "running"          # running | done | failed
+        # chunks → index（倒排重建，没有分批进度）→ memories → done
+        self.phase = "chunks"
+        self.chunks = {"total": chunks, "done": 0}
+        self.memories = {"total": memories, "done": 0}
+        self.started_at = utcnow()
+        self.finished_at: Any = None
+        self.error: str | None = None
+        self.hint: str | None = None
+        self.result: dict[str, Any] | None = None
+
+    def chunk_step(self, done: int, total: int) -> None:
+        self.chunks = {"total": total, "done": done}
+        if done >= total:
+            self.phase = "index"
+
+    def memory_step(self, done: int, total: int) -> None:
+        self.memories = {"total": total, "done": done}
+
+    def view(self) -> dict[str, Any]:
+        return {
+            "id": self.id, "state": self.state, "phase": self.phase,
+            "collection": self.collection,
+            "total": self.chunks["total"] + self.memories["total"],
+            "done": self.chunks["done"] + self.memories["done"],
+            "chunks": dict(self.chunks), "memories": dict(self.memories),
+            "started_at": self.started_at.isoformat(),
+            "finished_at": self.finished_at.isoformat() if self.finished_at else None,
+            "error": self.error, "hint": self.hint, "result": self.result,
+        }
+
+
+#: 最近一次重建。只在进程里记：重建是幂等的，服务重启丢了进度，再点一次就是
+_REINDEX: _ReindexJob | None = None
+#: 后台任务要有人拿着引用，否则跑到一半可能被回收
+_REINDEX_TASK: Any = None
+
+
+def reindex_job() -> _ReindexJob | None:
+    return _REINDEX
+
+
+async def _run_reindex(job: _ReindexJob) -> None:
+    from app.db.base import SessionLocal, utcnow
+
+    try:
+        async with SessionLocal() as session:
+            out = await kb.reindex(session, job.collection, on_progress=job.chunk_step)
+            job.phase = "memories"
+            # 记忆不按 collection 分，重建就是全量
+            out["memories_reindexed"] = await store.reindex(session, on_progress=job.memory_step)
+        job.result, job.state, job.phase = out, "done", "done"
+    except Exception as e:  # noqa: BLE001 - 失败要落到任务状态上，不能只进日志
+        logger.warning("重建索引失败：%s", raw(e))
+        reason, hint = explain(e)
+        job.state, job.error, job.hint = "failed", f"重建索引没做完：{reason}", hint or None
+    finally:
+        job.finished_at = utcnow()
+
+
 @kb_router.post("/reindex")
 async def reindex(
-    collection: str | None = None, session: AsyncSession = Depends(get_session)
-) -> dict[str, Any]:
+    collection: str | None = None,
+    background: bool = Query(default=False, description="后台跑，立刻返回任务；进度用 GET /kb/reindex 查"),
+    session: AsyncSession = Depends(get_session),
+):
     """用当前 embedder 重算向量。换了模型之后唯一的恢复手段。
 
     知识库和长期记忆一起重建：它们共用一个 embedder，换模型时一起失效。
     分成两个按钮的结果是点了一个、以为好了，另一个还在悄悄退回关键词——
     真踩过，记忆那边连个提示都没有。
+
+    几千段配远端 embedding 要好几分钟，压在请求里界面只能干转圈。background=true
+    时立刻返回 202 和任务，按批更新进度；不带它仍然等做完再返回，老调用方不受影响。
+    同一时间只跑一个：两次重建交错写同一批向量，谁最后写赢都说不清。
     """
-    out = await kb.reindex(session, collection)
-    # 记忆不按 collection 分，重建就是全量
-    out["memories_reindexed"] = await store.reindex(session)
-    return out
+    global _REINDEX, _REINDEX_TASK
+    import asyncio
+
+    from fastapi.responses import JSONResponse
+    from sqlalchemy import func
+
+    from app.db.models import Chunk
+
+    count = select(func.count(Chunk.id))
+    if collection:
+        count = count.where(Chunk.collection == collection)
+    chunks = int((await session.execute(count)).scalar_one() or 0)
+    memories = int((await session.execute(select(func.count(MemoryItem.id)))).scalar_one() or 0)
+    # 先数完再查「有没有在跑」，查和占位之间不能有 await：以前先查后数，两个同时
+    # 到的请求都在计数那里让出去，回来都以为没在跑，于是两个都起了
+    if _REINDEX is not None and _REINDEX.state == "running":
+        running = _REINDEX.view()
+        raise HTTPException(
+            409, f"已经在重建索引了（{_REINDEX.collection or '全部集合'}，"
+                 f"已完成 {running['done']}/{running['total']}），等它做完再点",
+        )
+    job = _REINDEX = _ReindexJob(collection, chunks, memories)
+    if background:
+        _REINDEX_TASK = asyncio.create_task(_run_reindex(job))
+        return JSONResponse(job.view(), status_code=202)
+
+    await _run_reindex(job)
+    if job.state == "failed":
+        raise HTTPException(502, job.error + (f"。{job.hint}" if job.hint else ""))
+    return job.result
+
+
+@kb_router.get("/reindex")
+async def reindex_status() -> dict[str, Any]:
+    """最近一次重建的进度：{state, phase, total, done, chunks, memories, result, error…}。
+
+    还没重建过返回 {state: "idle"}。
+    """
+    return _REINDEX.view() if _REINDEX is not None else {"state": "idle"}
 
 
 #: 单段返回多少字。切块本来就在千字量级，详情页是给人扫一眼"切得对不对"的，
diff --git a/backend/app/api/runs.py b/backend/app/api/runs.py
index 1e79b05d..a24c31c0 100644
--- a/backend/app/api/runs.py
+++ b/backend/app/api/runs.py
@@ -172,9 +172,14 @@ async def start_run(
     return run
 
 
+#: workflow_id 取这个值时只要没挂在任何工作流上的运行：画布上没保存就跑的临时图，
+#: 以及工作流被删掉之后留下来的运行（外键是 SET NULL）
+UNSAVED = "__none__"
+
+
 @router.get("", response_model=list[RunOut])
 async def list_runs(
-    workflow_id: str | None = None,
+    workflow_id: str | None = Query(default=None, description=f"{UNSAVED} 表示没保存的工作流"),
     status: str | None = Query(default=None, description="逗号分隔，如 failed,cancelled"),
     run_class: str | None = None,
     q: str | None = Query(default=None, description="按工作流名模糊匹配"),
@@ -188,7 +193,9 @@ async def list_runs(
     筛选都走服务端，翻页用 created_at 做游标（before 传上一页最后一条的 created_at）。
     """
     stmt = select(Run).order_by(Run.created_at.desc()).limit(limit)
-    if workflow_id:
+    if workflow_id == UNSAVED:
+        stmt = stmt.where(Run.workflow_id.is_(None))
+    elif workflow_id:
         stmt = stmt.where(Run.workflow_id == workflow_id)
     if statuses := _csv(status):
         stmt = stmt.where(Run.status.in_(statuses))
@@ -283,13 +290,25 @@ async def list_artifacts(
 
 
 @router.post("/{run_id}/cancel")
-async def cancel_run(run_id: str) -> dict[str, Any]:
-    stopped = await run_manager.cancel(run_id)
-    if not stopped:
-        raise HTTPException(
-            409, "这次运行已经不在执行中（可能刚结束，或者服务重启过），不需要再停止。刷新看看最新状态"
-        )
-    return {"ok": True}
+async def cancel_run(run_id: str, x_actor: str | None = Header(default=None)) -> dict[str, Any]:
+    """停止一次运行。status 是 stopping（正在执行的，取消已发出，稍后收到 run.cancelled）
+    或 cancelled（停在审批上、或服务重启挂起的，已经收成终态，待审批一并关闭）。"""
+    outcome = await run_manager.cancel(run_id, actor=actor_of(x_actor))
+    if outcome is None:
+        async with SessionLocal() as session:
+            run = await session.get(Run, run_id)
+        if run is None:
+            raise HTTPException(404, "运行记录不存在")
+        raise HTTPException(409, _cannot_cancel(run.status))
+    return {"ok": True, "status": outcome}
+
+
+def _cannot_cancel(status: str) -> str:
+    return {
+        "succeeded": "这次运行已完成，没有要停止的。",
+        "failed": "这次运行已经失败结束了，没有要停止的；要继续请用「接着跑」。",
+        "cancelled": "这次运行已经取消了。",
+    }.get(status, "这次运行已经不在执行中（可能刚结束，或者服务重启过），不需要再停止。刷新看看最新状态")
 
 
 class ResumeIn(BaseModel):
diff --git a/backend/app/api/settings.py b/backend/app/api/settings.py
index a921609d..121632cb 100644
--- a/backend/app/api/settings.py
+++ b/backend/app/api/settings.py
@@ -8,7 +8,8 @@ from pydantic import BaseModel, Field
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.errors import explain, not_configured, raw
+from app.api import health
+from app.core.errors import explain, not_configured, raw
 from app.core.config import settings as app_settings
 from app.core.crypto import encrypt, mask
 from app.db.base import get_session
@@ -57,9 +58,49 @@ class ProviderOut(BaseModel):
     # 只回掩码，明文 key 永远不出后端
     api_key_masked: str = ""
     has_key: bool = False
+    #: 最近一次测连接（见 app/api/health.py）。没测过、或者连接配置改过之后都是 None
+    last_checked_at: str | None = None
+    last_check_ok: bool | None = None
+    last_latency_ms: int | None = None
+    last_error: str | None = None
+
+
+#: extra 里这一项是后端记的最近一次测连接结果，不是用户填的配置：不回显、
+#: 不接受客户端写入，保存 extra 时原样留着
+LAST_CHECK = "last_check"
+
+
+def _user_extra(extra: dict[str, Any] | None) -> dict[str, Any]:
+    return {k: v for k, v in (extra or {}).items() if k != LAST_CHECK}
+
+
+def _with_saved_headers(extra: dict[str, Any], saved: dict[str, Any] | None) -> dict[str, Any]:
+    """请求头的值回显的是 ***：原样带回来的，换回存着的真值。
+
+    设置页保存时会把读到的 extra 整块带回来。以前照单全收，于是改个名字、
+    勾一下启用，自定义请求头就全变成了字面上的 ***，接口从此 401。
+    """
+    headers = extra.get("headers")
+    if not isinstance(headers, dict):
+        return extra
+    old = (saved or {}).get("headers") or {}
+    return {**extra, "headers": {k: (old.get(k, v) if v == "***" else v) for k, v in headers.items()}}
+
+
+def _connection(provider: Provider, model: str | None = None) -> str:
+    """连接配置的指纹：类型、地址、实际用的钥匙、请求头这些、测的哪个模型。"""
+    return health.fingerprint(
+        "provider", provider.kind, (provider.base_url or "").strip(), _resolve_key(provider) or "",
+        _user_extra(provider.extra), model or provider.default_model or "",
+    )
+
+
+def _set_last_check(row: Provider, last: dict[str, Any] | None) -> None:
+    row.extra = {**_user_extra(row.extra), **({LAST_CHECK: last} if last else {})}
 
 
 def _to_out(row: Provider) -> ProviderOut:
+    extra = _user_extra(row.extra)
     return ProviderOut(
         id=row.id,
         name=row.name,
@@ -68,13 +109,14 @@ def _to_out(row: Provider) -> ProviderOut:
         default_model=row.default_model,
         models=row.models or [],
         enabled=row.enabled,
-        extra={k: v for k, v in (row.extra or {}).items() if k != "headers"} | (
-            {"headers": {k: "***" for k in (row.extra or {}).get("headers", {})}}
-            if (row.extra or {}).get("headers")
+        extra={k: v for k, v in extra.items() if k != "headers"} | (
+            {"headers": {k: "***" for k in extra.get("headers", {})}}
+            if extra.get("headers")
             else {}
         ),
         api_key_masked=mask(row.api_key),
         has_key=bool(row.api_key),
+        **health.fields((row.extra or {}).get(LAST_CHECK)),
     )
 
 
@@ -120,8 +162,10 @@ async def create_provider(
         models=payload.models,
         default_model=payload.default_model,
         enabled=payload.enabled,
-        extra=payload.extra,
+        extra=_user_extra(payload.extra),
     )
+    # 表单里刚测过这份配置：保存下来就带着那次结果
+    _set_last_check(row, health.draft_result(_connection(row)))
     session.add(row)
     await session.commit()
     await session.refresh(row)
@@ -137,11 +181,21 @@ async def update_provider(
         raise HTTPException(404, "这个模型接入不存在，可能已经被删了")
 
     data = payload.model_dump(exclude_unset=True)
+    before, last = _connection(row), (row.extra or {}).get(LAST_CHECK)
     if "api_key" in data:
         row.api_key = encrypt(data.pop("api_key")) if data["api_key"] else None
         data.pop("api_key", None)
+    if data.get("extra") is not None:
+        data["extra"] = _with_saved_headers(_user_extra(data["extra"]), row.extra)
+    else:
+        data.pop("extra", None)
     for key, value in data.items():
         setattr(row, key, value)
+    after = _connection(row)
+    if after != before:
+        # 测过的已经不是这份配置了：旧结果作废，表单里测过这一份的话换成那一次
+        last = health.draft_result(after)
+    _set_last_check(row, last)
     await session.commit()
     await session.refresh(row)
     return _to_out(row)
@@ -224,7 +278,16 @@ async def test_provider(
     row = await session.get(Provider, provider_id)
     if not row:
         raise HTTPException(404, "这个模型接入不存在，可能已经被删了")
-    return await _try_model(row, payload.model, payload.prompt)
+    result = await _try_model(row, payload.model, payload.prompt)
+    # 只记默认模型的结果：拿别的模型测出 invalid_model，不等于这个接入连不上
+    if (payload.model or row.default_model) == row.default_model:
+        _set_last_check(row, _test_record(result))
+        await session.commit()
+    return result
+
+
+def _test_record(result: dict[str, Any]) -> dict[str, Any]:
+    return health.record(result.get("ok"), result.get("latency_ms"), result.get("error"))
 
 
 class ProviderDraftIn(BaseModel):
@@ -249,11 +312,9 @@ def _draft_provider(payload: ProviderDraftIn, saved: Provider | None) -> Provide
     编辑时 Key 框留空表示不改、请求头回显的是 ***——测试都得换回存着的真值，
     否则改个 Base URL 想测一下，只会得到一句"密钥不对"。
     """
-    extra = dict(payload.extra or {})
-    headers = extra.get("headers")
-    if saved and isinstance(headers, dict):
-        old = (saved.extra or {}).get("headers") or {}
-        extra["headers"] = {k: (old.get(k, v) if v == "***" else v) for k, v in headers.items()}
+    extra = _user_extra(payload.extra)
+    if saved:
+        extra = _with_saved_headers(extra, saved.extra)
     return Provider(
         name=payload.name or (saved.name if saved else "草稿"),
         kind=payload.kind,
@@ -284,7 +345,16 @@ async def test_provider_draft(
     problem = _config_problem(payload.kind, payload.base_url)
     if problem:
         return {"ok": False, "error": problem, "hint": "", "detail": ""}
-    return await _try_model(await _draft(payload, session), payload.model, payload.prompt)
+    saved = await session.get(Provider, payload.id) if payload.id else None
+    draft = _draft_provider(payload, saved)
+    result = await _try_model(draft, payload.model, payload.prompt)
+    last, key = _test_record(result), _connection(draft, payload.model)
+    health.remember_draft(key, last)
+    if saved is not None and key == _connection(saved):
+        # 编辑框里没改连接、只是再测一次：测的就是已保存的那份
+        _set_last_check(saved, last)
+        await session.commit()
+    return result
 
 
 @router.post("/providers/models")
diff --git a/backend/app/api/tools.py b/backend/app/api/tools.py
index 3f182424..21e9ffbc 100644
--- a/backend/app/api/tools.py
+++ b/backend/app/api/tools.py
@@ -7,13 +7,15 @@ from pydantic import BaseModel, Field
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.errors import explain, raw
+from app.api import health
+from app.core.errors import explain, raw
 from app.db.base import get_session
 from app.db.models import CustomTool, McpServer
-from app.tools.custom import run_custom_tool
+from app.tools.custom import ToolFailure, schema_problem, trial
 from app.tools.mcp_manager import mcp_manager
 from app.tools.registry import (
-    ToolArgsError, ToolContext, all_specs, build_tools, call_is_dangerous, call_tool, get_spec,
+    ToolArgsError, ToolBuildError, ToolContext, all_specs, build_tools, call_is_dangerous,
+    call_tool, get_spec,
 )
 
 router = APIRouter(prefix="/api/tools", tags=["tools"])
@@ -55,6 +57,8 @@ async def list_tools(session: AsyncSession = Depends(get_session)) -> list[dict[
                 # 在补上之前不能让标签说它会被审批
                 "runtime_approval": False,
                 "schema": row.parameters or {},
+                # 这道关卡之前存进库的坏参数定义：绑上它的节点会失败，列表上先标出来
+                "problem": schema_problem(row.parameters or {}),
             }
         )
 
@@ -146,12 +150,13 @@ async def run_tool(
     import time
 
     started = time.perf_counter()
+    notes: list[str] = []
     try:
-        result = await call_tool(tool_name, payload.args, ctx, session=session)
+        result = await call_tool(tool_name, payload.args, ctx, session=session, on_fix=notes.append)
     except KeyError as e:
         raise HTTPException(404, str(e.args[0] if e.args else e)) from e
-    except ToolArgsError as e:
-        # 参数对不上时报错里已经写清该填什么，原样给
+    except (ToolArgsError, ToolBuildError) as e:
+        # 参数对不上、工具自己的配置写坏了：报错里已经写清该改什么，原样给
         return {"ok": False, "error": str(e), "hint": "", "detail": raw(e),
                 "duration_ms": int((time.perf_counter() - started) * 1000)}
     except Exception as e:  # noqa: BLE001
@@ -167,6 +172,8 @@ async def run_tool(
         "ok": True,
         "result": result,
         "duration_ms": int((time.perf_counter() - started) * 1000),
+        # 参数名写错、被替换成唯一候选跑通了：运行时会报出来，这里也得说
+        **({"note": notes[0]} if notes else {}),
     }
 
 
@@ -181,49 +188,69 @@ class CustomToolIn(BaseModel):
     name: str = Field(min_length=1, max_length=100, pattern=r"^[a-zA-Z_][a-zA-Z0-9_]*$")
     description: str = ""
     kind: str = "http"  # http | python
-    parameters: dict[str, Any] = Field(default_factory=dict)
+    #: JSON Schema。不在这里限定成 dict：写成数组、字符串时要回一句人话（见 _refuse_bad_schema），
+    #: 而不是 pydantic 的英文错误列表
+    parameters: Any = Field(default_factory=dict)
     config: dict[str, Any] = Field(default_factory=dict)
     enabled: bool = True
 
 
 class CustomToolOut(CustomToolIn):
     id: str
+    parameters: dict[str, Any] = Field(default_factory=dict)
+    #: 参数定义哪里写坏了（保存时的关卡加上之前存进库的）。绑上它的节点会失败
+    problem: str | None = None
 
     model_config = {"from_attributes": True}
 
 
+def _custom_out(row: CustomTool) -> CustomToolOut:
+    out = CustomToolOut.model_validate(row)
+    out.problem = schema_problem(row.parameters or {})
+    return out
+
+
+def _refuse_bad_schema(parameters: Any) -> None:
+    """参数定义写坏了就不让存：存进去之后，绑了它的节点在运行时才炸。"""
+    problem = schema_problem(parameters)
+    if problem:
+        raise HTTPException(422, problem)
+
+
 @custom_router.get("", response_model=list[CustomToolOut])
-async def list_custom(session: AsyncSession = Depends(get_session)) -> list[CustomTool]:
-    return list((await session.execute(select(CustomTool))).scalars())
+async def list_custom(session: AsyncSession = Depends(get_session)) -> list[CustomToolOut]:
+    return [_custom_out(r) for r in (await session.execute(select(CustomTool))).scalars()]
 
 
 @custom_router.post("", response_model=CustomToolOut, status_code=201)
 async def create_custom(
     payload: CustomToolIn, session: AsyncSession = Depends(get_session)
-) -> CustomTool:
+) -> CustomToolOut:
     if (await session.execute(select(CustomTool).where(CustomTool.name == payload.name))).scalar_one_or_none():
         raise HTTPException(409, f"已经有叫「{payload.name}」的工具了，换个名字")
     if payload.name in all_specs():
         raise HTTPException(409, f"「{payload.name}」和内置工具重名了，换个名字")
+    _refuse_bad_schema(payload.parameters)
     row = CustomTool(**payload.model_dump())
     session.add(row)
     await session.commit()
     await session.refresh(row)
-    return row
+    return _custom_out(row)
 
 
 @custom_router.patch("/{tool_id}", response_model=CustomToolOut)
 async def update_custom(
     tool_id: str, payload: CustomToolIn, session: AsyncSession = Depends(get_session)
-) -> CustomTool:
+) -> CustomToolOut:
     row = await session.get(CustomTool, tool_id)
     if not row:
         raise HTTPException(404, "这个工具不存在，可能已经被删了")
+    _refuse_bad_schema(payload.parameters)
     for key, value in payload.model_dump().items():
         setattr(row, key, value)
     await session.commit()
     await session.refresh(row)
-    return row
+    return _custom_out(row)
 
 
 @custom_router.delete("/{tool_id}", status_code=204)
@@ -235,6 +262,84 @@ async def delete_custom(tool_id: str, session: AsyncSession = Depends(get_sessio
     await session.commit()
 
 
+async def _trial(row: CustomTool, args: dict[str, Any]) -> dict[str, Any]:
+    """试跑一次，返回和工具库「执行」同一种形状：{ok, result | error/hint/detail, duration_ms, note?}。"""
+    import json
+    import time
+
+    ctx = ToolContext(run_id="playground", node_id="test", sandbox_session="playground")
+    started = time.perf_counter()
+
+    def took() -> int:
+        return int((time.perf_counter() - started) * 1000)
+
+    problem = schema_problem(row.parameters or {})
+    if problem:
+        # 手写的参数定义写坏了：是配置的事，不是「后端内部出错」
+        return {"ok": False, "error": problem,
+                "hint": '参数定义是 JSON Schema，写成 {"type": "object", "properties": '
+                        '{"n": {"type": "integer", "description": "…"}}, "required": ["n"]}',
+                "detail": "", "duration_ms": 0}
+    try:
+        result, note = await trial(row, args, ctx)
+    except ToolArgsError as e:
+        # 参数对不上时报错里已经写清该填什么，原样给
+        return {"ok": False, "error": str(e), "hint": "", "detail": raw(e), "duration_ms": took()}
+    except Exception as e:  # noqa: BLE001
+        reason, hint = explain(e)
+        return {"ok": False, "error": f"工具执行失败：{reason}", "hint": hint, "detail": raw(e),
+                "duration_ms": took()}
+    # 参数名被纠正过：跑通了也要说，用户照着试跑的参数去配工作流
+    extra = {"note": note} if note else {}
+    if isinstance(result, ToolFailure):
+        detail = str(result.get("error") or "")
+        if "exit_code" in result:
+            error = f"代码运行出错（退出码 {result['exit_code']}）"
+            hint = "看下面的报错改代码；调用时传的参数在 args 变量里（一个 dict）"
+        else:
+            error = f"工具执行失败：{detail.splitlines()[0] if detail else '没有说明'}"
+            hint = "HTTP 工具只能访问公网地址，内网、回环地址会被拦截" if "拦截" in detail else ""
+        return {"ok": False, "error": error, "hint": hint,
+                "detail": json.dumps(dict(result), ensure_ascii=False), "duration_ms": took(),
+                **extra}
+    return {"ok": True, "result": result, "duration_ms": took(), **extra}
+
+
+class CustomToolDraftIn(BaseModel):
+    """还没保存（或改了还没保存）的一份工具配置，外加这次试跑的参数。"""
+
+    name: str = "draft_tool"
+    kind: str = "http"
+    parameters: Any = Field(default_factory=dict)
+    config: dict[str, Any] = Field(default_factory=dict)
+    args: dict[str, Any] = Field(default_factory=dict)
+
+
+def _draft_problem(kind: str, config: dict[str, Any]) -> str | None:
+    if kind not in ("http", "python"):
+        return f"不认识「{kind}」这种工具类型：只有 http 和 python 两种"
+    if kind == "http" and not str(config.get("url") or "").strip():
+        return "还没填接口地址"
+    if kind == "python" and not str(config.get("code") or "").strip():
+        return "还没写代码"
+    return None
+
+
+@custom_router.post("/test")
+async def test_custom_draft(payload: CustomToolDraftIn) -> dict[str, Any]:
+    """试跑一份没保存的配置，不落库。
+
+    以前只能试已保存的：新建要先保存才能试，改了代码也得先存——保存等于让节点
+    立刻用上一个还没试过的版本。
+    """
+    problem = _draft_problem(payload.kind, payload.config)
+    if problem:
+        return {"ok": False, "error": problem, "hint": "", "detail": "", "duration_ms": 0}
+    draft = CustomTool(name=payload.name or "draft_tool", kind=payload.kind,
+                       parameters=payload.parameters, config=payload.config)
+    return await _trial(draft, payload.args)
+
+
 @custom_router.post("/{tool_id}/test")
 async def test_custom(
     tool_id: str, payload: RunToolIn, session: AsyncSession = Depends(get_session)
@@ -242,13 +347,7 @@ async def test_custom(
     row = await session.get(CustomTool, tool_id)
     if not row:
         raise HTTPException(404, "这个工具不存在，可能已经被删了")
-    ctx = ToolContext(run_id="playground", node_id="test", sandbox_session="playground")
-    try:
-        result = await run_custom_tool(session, row.name, payload.args, ctx)
-    except Exception as e:  # noqa: BLE001
-        reason, hint = explain(e)
-        return {"ok": False, "error": f"工具执行失败：{reason}", "hint": hint, "detail": raw(e)}
-    return {"ok": True, "result": result}
+    return await _trial(row, payload.args)
 
 
 # --------------------------------------------------------------------------
@@ -273,40 +372,64 @@ class McpOut(McpIn):
     status: str
     last_error: str | None
     tools_cache: list[Any]
+    #: 最近一次连接的时刻和耗时（见 app/api/health.py）。status 只有结论，没有「何时」
+    last_checked_at: str | None = None
+    last_check_ok: bool | None = None
+    last_latency_ms: int | None = None
 
     model_config = {"from_attributes": True}
 
 
+def _mcp_out(row: McpServer) -> McpOut:
+    out = McpOut.model_validate(row)
+    checked = health.fields(row.last_check)
+    out.last_checked_at = checked["last_checked_at"]
+    out.last_check_ok = checked["last_check_ok"]
+    out.last_latency_ms = checked["last_latency_ms"]
+    return out
+
+
+def _mcp_connection(row: McpServer) -> tuple[Any, ...]:
+    return (row.transport, row.command, list(row.args or []), dict(row.env or {}), row.url)
+
+
 @mcp_router.get("/servers", response_model=list[McpOut])
-async def list_servers(session: AsyncSession = Depends(get_session)) -> list[McpServer]:
-    return list((await session.execute(select(McpServer))).scalars())
+async def list_servers(session: AsyncSession = Depends(get_session)) -> list[McpOut]:
+    return [_mcp_out(r) for r in (await session.execute(select(McpServer))).scalars()]
 
 
 @mcp_router.post("/servers", response_model=McpOut, status_code=201)
 async def create_server(
     payload: McpIn, session: AsyncSession = Depends(get_session)
-) -> McpServer:
+) -> McpOut:
     if (await session.execute(select(McpServer).where(McpServer.name == payload.name))).scalar_one_or_none():
         raise HTTPException(409, f"已经有叫「{payload.name}」的 MCP 服务了，换个名字")
     row = McpServer(**payload.model_dump())
     session.add(row)
     await session.commit()
     await session.refresh(row)
-    return row
+    return _mcp_out(row)
 
 
 @mcp_router.patch("/servers/{server_id}", response_model=McpOut)
 async def update_server(
     server_id: str, payload: McpIn, session: AsyncSession = Depends(get_session)
-) -> McpServer:
+) -> McpOut:
     row = await session.get(McpServer, server_id)
     if not row:
         raise HTTPException(404, "这个 MCP 服务不存在，可能已经被删了")
+    before, old_name, was_enabled = _mcp_connection(row), row.name, row.enabled
     for key, value in payload.model_dump().items():
         setattr(row, key, value)
+    if _mcp_connection(row) != before:
+        # 启动命令、地址换了，上次的「连得上」说的是另一个进程
+        row.status, row.last_error, row.last_check = "unknown", None, None
     await session.commit()
     await session.refresh(row)
-    return row
+    if (_mcp_connection(row), row.name, row.enabled) != (before, old_name, was_enabled):
+        # 按旧配置、旧名字建的工具作废，下次用到时按新的连
+        mcp_manager.invalidate(old_name, row.name)
+    return _mcp_out(row)
 
 
 @mcp_router.delete("/servers/{server_id}", status_code=204)
@@ -316,6 +439,7 @@ async def delete_server(server_id: str, session: AsyncSession = Depends(get_sess
         raise HTTPException(404, "这个 MCP 服务不存在，可能已经被删了")
     await session.delete(row)
     await session.commit()
+    mcp_manager.invalidate(row.name)
 
 
 @mcp_router.post("/servers/{server_id}/probe")
@@ -325,10 +449,15 @@ async def probe_server(
     row = await session.get(McpServer, server_id)
     if not row:
         raise HTTPException(404, "这个 MCP 服务不存在，可能已经被删了")
+    import time
+
+    started = time.perf_counter()
     result = await mcp_manager.probe(row)
+    result["elapsed_ms"] = int((time.perf_counter() - started) * 1000)
     row.status = "ok" if result.get("ok") else "error"
     row.last_error = result.get("error")
     row.tools_cache = [t["name"] for t in result.get("tools", [])]
+    row.last_check = health.record(result.get("ok"), result["elapsed_ms"], result.get("error"))
     await session.commit()
     return result
 
diff --git a/backend/app/api/workflows.py b/backend/app/api/workflows.py
index b800abc7..7d95bd36 100644
--- a/backend/app/api/workflows.py
+++ b/backend/app/api/workflows.py
@@ -7,7 +7,7 @@ from pydantic import BaseModel, Field
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.api.errors import graph_error
+from app.core.errors import graph_error
 from app.api.runs import actor_of
 from app.core.artifact_store import graph_hash
 from app.db.base import get_session
diff --git a/backend/app/core/errors.py b/backend/app/core/errors.py
new file mode 100644
index 00000000..2ed707e9
--- /dev/null
+++ b/backend/app/core/errors.py
@@ -0,0 +1,211 @@
+"""面向用户的报错：说清发生了什么、为什么、怎么办，不把 Python 异常类名端上去。
+
+以前各处都是 f"{type(e).__name__}: {e}"，界面首行红字是
+「_make_query_tool.<locals>._run() got an unexpected keyword argument 'query'」
+——对业务用户是天书，也没有下一步。原始异常不丢：调用方把 raw(e) 放进响应或
+事件的 detail 字段、写进日志，排查时照样找得到。
+
+这里曾经是两份：接口层一份（测连接这类回「原因 + 怎么办」），执行层一份（节点
+报错首行只要原因）。两份各认一套异常类名、各写一套说法，同一个 401 在设置页和
+运行记录里是两句话。现在认异常的规则只有下面这一张表，两个入口只在一件事上分叉：
+TypeError、KeyError 这类「程序自己的毛病」——
+
+- 接口里冒出来的，是后端的 bug，原文里全是内部符号，说「后端内部出错了」；
+- 节点里冒出来的，多半是工具被传错了参数、用户代码取错了字段，说清是哪个参数、
+  哪个字段，模型和人才知道该改什么。
+
+判断按类名走 MRO，不 import 各家 SDK：没装的驱动和 SDK 不该让报错这一层也跟着
+ImportError。
+"""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+_TIMEOUT = {"TimeoutError", "TimeoutException", "APITimeoutError", "ReadTimeout",
+            "ConnectTimeout", "PoolTimeout", "WriteTimeout"}
+_NETWORK = {"ConnectError", "ConnectionError", "APIConnectionError", "gaierror",
+            "ClientConnectorError", "RemoteProtocolError", "ReadError", "NetworkError"}
+_AUTH = {"AuthenticationError", "PermissionDeniedError", "InvalidPasswordError",
+         "InvalidAuthorizationSpecificationError"}
+#: 这几类是程序自己的毛病，str(e) 里全是内部符号，原样端上去只会更糊涂
+_BUG = {"TypeError", "AttributeError", "KeyError", "NameError", "IndexError",
+        "UnboundLocalError", "AssertionError", "RecursionError"}
+_UNREACHABLE = ("connection refused", "nodename nor servname", "name or service not known",
+                "all connection attempts failed", "network is unreachable")
+
+#: SQLAlchemy 包过的驱动异常开头是「(sqlite3.OperationalError) 」
+_WRAPPED = re.compile(r"^\([\w.]+\)\s*")
+# 内部符号：`a.b.<locals>._run()`、`<function f at 0x…>`、模块路径。对使用者没有意义
+_LOCALS = re.compile(r"[\w.]*<locals>\.?[\w.]*(\(\))?")
+_REPR = re.compile(r"<(?:function|bound method|coroutine|object) [^>]*>")
+# 包在消息里的异常类名（"连不上：ConnectError: All connection attempts failed"）
+_CLASS = re.compile(r"\b[A-Z]\w*(?:Error|Exception|Warning)\b:\s*")
+
+
+def raw(e: BaseException) -> str:
+    """原始报错，给「技术细节」折叠区、事件的 detail 字段和日志用。"""
+    text = str(e).strip()
+    return (f"{type(e).__name__}: {text}" if text else type(e).__name__)[:2000]
+
+
+def raw_detail(e: BaseException | None) -> str | None:
+    """同 raw，没有异常时是 None——事件里 detail 字段就不带。"""
+    return None if e is None else raw(e)
+
+
+def first_line(e: BaseException) -> str:
+    """异常自己的说明，去掉驱动包装的类名前缀和 SQLAlchemy 的文档链接。"""
+    text = str(e).strip()
+    line = text.splitlines()[0] if text else ""
+    return _WRAPPED.sub("", line)[:300]
+
+
+def _names(e: BaseException) -> set[str]:
+    return {c.__name__ for c in type(e).__mro__}
+
+
+def _status(e: BaseException) -> int | None:
+    for obj in (e, getattr(e, "response", None)):
+        code = getattr(obj, "status_code", None)
+        if isinstance(code, int):
+            return code
+    return None
+
+
+def _scrub(text: str) -> str:
+    text = _LOCALS.sub("内部函数", text)
+    text = _REPR.sub("内部对象", text)
+    text = _CLASS.sub("", text)
+    return " ".join(text.split())[:240]
+
+
+def _known(e: BaseException, *, sniff: bool) -> tuple[str, str] | None:
+    """两种场景说法一样的那些：鉴权、找不到、限流、对方故障、超时、网络、格式、文件。
+
+    sniff：类名认不出时要不要按原文字面猜。SDK 抛出来的裸异常要猜（原文就是
+    "Connection refused"）；执行层的异常常常是已经拼好的一句话、里头套着具体原因，
+    按字面猜会把那个原因换成笼统的一句。
+    """
+    names = _names(e)
+    low = str(e).lower() if sniff else ""
+    status = _status(e)
+
+    if status in (401, 403) or names & _AUTH or "invalid api key" in low or "unauthorized" in low:
+        code = f"（{status}）" if status else ""
+        return (f"鉴权没通过{code}：对方拒绝了这把密钥",
+                "核对 API Key 有没有填错、过期，或者这个账号有没有这个模型的权限")
+    if status == 404 or "NotFoundError" in names:
+        return "对方说找不到（404）", "核对地址的路径（常见的是少了或多了 /v1）和模型名"
+    if status == 429 or "RateLimitError" in names:
+        return "请求太频繁，或者额度用完了（429）", "等一会儿再试；频繁出现就检查账号额度"
+    if isinstance(status, int) and status >= 500:
+        return f"对方服务出错了（HTTP {status}）", "这是对方的问题，多半是暂时的，稍后再试"
+    if isinstance(e, TimeoutError) or names & _TIMEOUT or "timed out" in low:
+        return ("等待超时：对方没有在限定时间内响应",
+                "对方可能很忙或者网络不稳，稍后再试；一直超时就检查地址和网络")
+    if isinstance(e, ConnectionError) or names & _NETWORK or any(s in low for s in _UNREACHABLE):
+        return ("连不上对方的服务：网络不通，或者服务没有启动",
+                "核对地址和端口，确认服务已经启动、这台机器访问得到它")
+    if isinstance(e, json.JSONDecodeError):
+        return "返回的内容不是合法的 JSON", "地址多半指到了网页而不是 API，核对 Base URL"
+    if "ValidationError" in names and callable(getattr(e, "errors", None)):
+        return f"参数不对：{_first_validation(e)}", ""
+    if isinstance(e, PermissionError):
+        return "没有权限访问需要的文件或资源", ""
+    if isinstance(e, FileNotFoundError):
+        return f"找不到文件{'「' + str(e.filename) + '」' if e.filename else ''}", ""
+    if isinstance(e, (OverflowError, MemoryError)):
+        text = str(e).strip()
+        return f"数据超出了能处理的范围{'：' + _scrub(text) if text else ''}", ""
+    return None
+
+
+def explain(e: BaseException) -> tuple[str, str]:
+    """接口层：(原因, 怎么办)。原因是一句人话；说不出怎么办时第二项是空串。"""
+    known = _known(e, sniff=True)
+    if known:
+        return known
+    if _names(e) & _BUG:
+        return "后端内部出错了", "这不是你操作的问题；把技术细节发给维护者"
+    return first_line(e) or "出了一个没有说明的错误", ""
+
+
+def describe_exception(e: BaseException) -> str:
+    """执行层：原因，一句话。「发生了什么」和「怎么办」由节点按场景拼。"""
+    text = str(e).strip()
+    if isinstance(e, TypeError):
+        if m := re.search(r"unexpected keyword argument '(\w+)'", text):
+            return f"参数对不上：它不接受名为「{m.group(1)}」的参数"
+        if m := re.search(r"missing \d+ required (?:positional |keyword-only )?arguments?: (.+)$", text):
+            wanted = "、".join(re.findall(r"'(\w+)'", m.group(1))) or m.group(1)
+            return f"缺少必填参数「{wanted}」"
+    if isinstance(e, KeyError):
+        return f"缺少字段「{e.args[0] if e.args else '?'}」"
+    known = _known(e, sniff=False)
+    if known:
+        return known[0]
+    return _scrub(text) or "没有给出原因的内部错误"
+
+
+def message(e: BaseException, lead: str = "") -> str:
+    """一整句：lead + 原因 + 怎么办。给只能放一个字符串的地方（HTTPException 的 detail）。"""
+    reason, hint = explain(e)
+    text = f"{lead}{reason}" if lead else reason
+    return f"{text}。{hint}" if hint else text
+
+
+def payload(e: BaseException, lead: str = "") -> dict[str, Any]:
+    """{ok: false, error, hint, detail}：测试连接这类「失败也是正常结果」的接口用。"""
+    reason, hint = explain(e)
+    return {"ok": False, "error": f"{lead}{reason}", "hint": hint, "detail": raw(e)}
+
+
+def not_configured(e: BaseException) -> str:
+    """模型接入没配好时的原话用的是内部叫法（provider 'x'、base_url），换成设置页上的说法。"""
+    text = re.sub(r"provider '([^']*)'", r"模型接入「\1」", str(e))
+    text = re.sub(r"模型 '([^']*)'", r"模型「\1」", text)
+    return text.replace("base_url", "Base URL").rstrip("。")
+
+
+def _has_cjk(text: str) -> bool:
+    return any("一" <= ch <= "鿿" for ch in text)
+
+
+def _first_validation(e: Any) -> str:
+    err = (e.errors() or [{}])[0]
+    loc = ".".join(str(p) for p in err.get("loc") or ())
+    msg = str(err.get("msg") or "").removeprefix("Value error, ")
+    if _has_cjk(msg):
+        return msg
+    return f"「{loc}」{'缺了' if err.get('type') == 'missing' else '格式不对'}" if loc else "格式不对"
+
+
+def graph_error(e: BaseException) -> str:
+    """工作流结构读不懂时，指到是哪个节点、哪一项。
+
+    pydantic 的原文是一大段英文，还列了全部十几种节点类型和一个文档链接，
+    用户从里面找不到自己错在哪。
+    """
+    errors = e.errors() if callable(getattr(e, "errors", None)) else None
+    if not errors:
+        return explain(e)[0]
+    err = errors[0]
+    loc = list(err.get("loc") or ())
+    msg = str(err.get("msg") or "").removeprefix("Value error, ")
+    more = f"（另有 {len(errors) - 1} 处）" if len(errors) > 1 else ""
+
+    if len(loc) >= 2 and loc[0] in ("nodes", "edges") and isinstance(loc[1], int):
+        where = f"第 {loc[1] + 1} 个{'节点' if loc[0] == 'nodes' else '连线'}"
+        field = str(loc[2]) if len(loc) > 2 else ""
+        if err.get("type") == "enum" and field == "type":
+            return f"{where}的类型「{err.get('input')}」不认识{more}"
+        if err.get("type") == "missing":
+            return f"{where}缺了「{field}」{more}"
+        if _has_cjk(msg):
+            return f"{where}：{msg}{more}"
+        return f"{where}的「{field or '内容'}」格式不对{more}"
+    if _has_cjk(msg):
+        return msg + more
+    return f"「{'.'.join(str(p) for p in loc) or '整体'}」格式不对{more}"
diff --git a/backend/app/data/engine.py b/backend/app/data/engine.py
index ad004084..cb986582 100644
--- a/backend/app/data/engine.py
+++ b/backend/app/data/engine.py
@@ -7,15 +7,21 @@ from __future__ import annotations
 
 import asyncio
 import json
+import logging
+import time
+from contextlib import asynccontextmanager
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, AsyncIterator, Awaitable, Callable
 
-from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, create_async_engine
 from sqlalchemy import text
 
 from app.core.crypto import decrypt
+from app.data import guard
 from app.data.guard import QueryLimits, SqlRejected, check, is_write
 
+logger = logging.getLogger(__name__)
+
 # 各方言的 SQLAlchemy 驱动。都选 asyncio 原生驱动，没有一个需要装数据库客户端：
 # oracledb 走 thin 模式（纯 Python 协议实现），省掉了 Oracle Instant Client 这个
 # 历来最劝退的一步。
@@ -36,9 +42,16 @@ _DEFAULT_PORTS = {
 
 SUPPORTED_KINDS = tuple(sorted(set(_DRIVERS)))
 
+#: 数据源 options 里按源配置的查询时限（秒）。表单上叫「查询时限」
+QUERY_TIMEOUT_OPTION = "query_timeout_s"
+#: 按源配置时能填的范围。再长的查询不该让一个 agent 干等：该做成离线任务了
+MIN_QUERY_TIMEOUT_S = 1
+MAX_QUERY_TIMEOUT_S = 600
+
 # options 里这些 key 是 AgentLab 自己的配置，不是驱动参数，拼 URL 时要摘掉。
 # schema：探查哪个 schema（企业库里只读账号名下常常什么都没有，数据在别处）
-_NON_DRIVER_OPTIONS = frozenset({"schema"})
+# query_timeout_s：查询时限，由数据层按语句下发给数据库，见 _server_deadline
+_NON_DRIVER_OPTIONS = frozenset({"schema", QUERY_TIMEOUT_OPTION})
 
 
 @dataclass
@@ -137,6 +150,43 @@ def engine_args(source: Any) -> tuple[str, dict[str, Any]]:
     return url, {}
 
 
+def _timeout_value(value: Any) -> float | None:
+    """options 里的查询时限：表单存的是字符串，也认数字。填得不对返回 None。"""
+    if value is None or isinstance(value, bool):
+        return None
+    try:
+        seconds = float(str(value).strip())
+    except ValueError:
+        return None
+    if not MIN_QUERY_TIMEOUT_S <= seconds <= MAX_QUERY_TIMEOUT_S:
+        return None
+    return int(seconds) if seconds.is_integer() else seconds
+
+
+def query_timeout_problem(options: dict[str, Any] | None) -> str | None:
+    """保存数据源时查一下查询时限填得对不对；没填、或者填对了返回 None。"""
+    value = (options or {}).get(QUERY_TIMEOUT_OPTION)
+    if value is None or str(value).strip() == "":
+        return None
+    if _timeout_value(value) is None:
+        return (f"查询时限要填 {MIN_QUERY_TIMEOUT_S} 到 {MAX_QUERY_TIMEOUT_S} 之间的秒数，"
+                f"比如 60；现在填的是「{value}」")
+    return None
+
+
+def query_timeout(source: Any) -> float:
+    """这个数据源上一条查询最多跑多久（秒）。没配、或者库里存着的值不对，用缺省。
+
+    缺省按模块属性现取：只有 guard.QueryLimits 这一处定义。
+    """
+    value = _timeout_value((source.options or {}).get(QUERY_TIMEOUT_OPTION))
+    return value if value is not None else guard.QueryLimits().timeout_seconds
+
+
+def _seconds(value: float) -> str:
+    return str(int(value)) if float(value).is_integer() else f"{value:g}"
+
+
 class EngineCache:
     """按数据源 id 缓存 engine。连接池的建立不便宜，不该每次查询都重来一遍。
 
@@ -184,8 +234,6 @@ engines = EngineCache()
 
 async def test_connection(source: Any) -> dict[str, Any]:
     """测连接。失败时把驱动的原始错误带出来——这类问题九成靠错误信息定位。"""
-    import time
-
     started = time.perf_counter()
     try:
         engine = await engines.get(source)
@@ -206,6 +254,199 @@ async def test_connection(source: Any) -> dict[str, Any]:
         }
 
 
+#: 数据库按时限停下语句之后，数据层自己的兜底再多等多久。要比引擎的宽限
+#: （toolcalls.GRACE_S）短：数据库报上来的「超过 Ns 被中断」才是给人看的那句，
+#: 引擎那边只在数据层也卡住时才出面
+BACKSTOP_S = 0.5
+
+#: SQLite 每执行多少条虚拟机指令问一次进度回调。回调只比一次时间，几毫秒一问足够准
+_SQLITE_STEPS = 10_000
+
+#: 各家数据库按时限停下语句时的报错。认出来就说「超时」，而不是把驱动原文当成
+#: SQL 写错了交给模型——它会去改一条本来没错的 SQL。
+#:
+#: 先认错误码：服务器的报错文字会跟着它的语言设置走，中文环境的 PostgreSQL 报的是
+#: 「由于语句执行超时，正在取消查询命令」，按英文原文找一个也认不出来
+_PG_CANCELED = "57014"                    # PostgreSQL query_canceled（statement_timeout 到点）
+_MYSQL_TIMEOUT_CODES = frozenset({3024,   # MySQL：max_execution_time 到点
+                                  1969})  # MariaDB：max_statement_time 到点
+_TIMEOUT_MARKERS = (
+    "statement timeout",                   # PostgreSQL（英文环境）
+    "maximum statement execution time",    # MySQL 3024
+    "max_statement_time",                  # MariaDB 1969
+    "dpy-4024", "dpi-1067", "call timeout",  # python-oracledb：call timeout of N ms exceeded（驱动自己的话，不随服务器语言变）
+)
+
+
+def _causes(e: BaseException) -> list[BaseException]:
+    """异常连同它包着的原始驱动异常。SQLAlchemy 包一层（.orig），适配器再包一层（__cause__），
+    有的路径（服务端游标取行）又原样抛出驱动异常，所以几条链都走一遍。"""
+    out: list[BaseException] = []
+    todo: list[Any] = [e]
+    while todo and len(out) < 8:
+        err = todo.pop(0)
+        if isinstance(err, BaseException) and err not in out:
+            out.append(err)
+            todo += [getattr(err, "orig", None), err.__cause__, err.__context__]
+    return out
+
+
+class _Deadline:
+    """一条语句的时限。数据库那边按它停下；停下时报的错据此认成超时。"""
+
+    def __init__(self, seconds: float) -> None:
+        self.seconds = seconds
+        self.ends = time.monotonic() + seconds
+        #: SQLite 的进度回调真的掐过
+        self.fired = False
+        #: 语句已经结束。回调这时要是还挂在连接上（摘除没成功），也不能再掐别人的语句
+        self.over = False
+
+    @property
+    def ms(self) -> int:
+        return max(1, int(self.seconds * 1000))
+
+    def expired(self) -> bool:
+        return time.monotonic() >= self.ends
+
+    def sqlite_progress(self) -> int:
+        # 在 SQLite 执行语句的那个线程里被调用；返回非零，SQLite 就中止当前语句
+        if not self.over and time.monotonic() >= self.ends:
+            self.fired = True
+            return 1
+        return 0
+
+    def stopped(self, e: BaseException) -> bool:
+        """这个报错是不是数据库按时限停下语句造成的。"""
+        if self.fired:
+            return True
+        for err in _causes(e):
+            if _PG_CANCELED in (getattr(err, "sqlstate", None), getattr(err, "pgcode", None)):
+                return True
+            args = getattr(err, "args", None) or ()
+            if args and isinstance(args[0], int) and args[0] in _MYSQL_TIMEOUT_CODES:
+                return True
+            low = str(err).lower()
+            if any(marker in low for marker in _TIMEOUT_MARKERS):
+                return True
+            # 各家的措辞不一（interrupted / canceled，或者干脆只在类名里）；
+            # 过了时限才报出来的，就是时限掐的
+            if self.expired() and any(w in f"{type(err).__name__} {low}".lower()
+                                      for w in ("interrupt", "cancel")):
+                return True
+        return False
+
+
+async def _driver(conn: AsyncConnection) -> Any:
+    return (await conn.get_raw_connection()).driver_connection
+
+
+@asynccontextmanager
+async def _server_deadline(conn: AsyncConnection, kind: str, deadline: _Deadline) -> AsyncIterator[None]:
+    """让数据库自己在时限处停下这条语句。
+
+    只靠后端这边 wait_for 放弃等待是不够的：数据库那边的语句照样在跑，占着连接池
+    里的一个连接直到跑完（Oracle 实测多占了 60 秒）；aiosqlite 更糟，语句在线程里
+    跑，取消之后关连接要排在它后面，一条不收敛的查询能让调用永远回不来。
+
+    会话级的设置用完要恢复：连接会回到池子里，探查结构这类长操作也用它。
+    下发失败（老版本的 MySQL 没有这个变量）不挡查询，只剩后端这边的兜底。
+    """
+    if kind in ("postgres", "postgresql"):
+        # SET LOCAL 只管这一个事务：连接还回池子时回滚，设置随之作废
+        await conn.execute(text(f"SET LOCAL statement_timeout = {deadline.ms}"))
+        yield
+        return
+
+    if kind in ("mysql", "mariadb"):
+        # MySQL 的 max_execution_time 以毫秒计、只管 SELECT；MariaDB 没有它，
+        # 用 max_statement_time（秒）。按连上的服务器认，不按表单里选的类型
+        if getattr(conn.dialect, "is_mariadb", False):
+            var, value = "max_statement_time", _seconds(deadline.seconds)
+        else:
+            var, value = "max_execution_time", str(deadline.ms)
+        try:
+            await conn.execute(text(f"SET SESSION {var} = {value}"))
+        except Exception as e:  # noqa: BLE001
+            logger.warning("MySQL 语句时限没下发成功（%s），只剩后端兜底", e)
+            yield
+            return
+        cancelled = False
+        try:
+            yield
+        except asyncio.CancelledError:
+            # 连接还卡在那条语句上，这时再发一条只会排在它后面
+            cancelled = True
+            raise
+        finally:
+            if not cancelled:
+                try:
+                    await conn.execute(text(f"SET SESSION {var} = DEFAULT"))
+                except Exception:  # noqa: BLE001 - 连接已经坏了的话，连接池会把它作废
+                    pass
+        return
+
+    if kind == "oracle":
+        driver = await _driver(conn)
+        before = getattr(driver, "call_timeout", 0)
+        try:
+            driver.call_timeout = deadline.ms
+        except Exception as e:  # noqa: BLE001
+            logger.warning("Oracle call_timeout 没设上（%s），只剩后端兜底", e)
+            yield
+            return
+        try:
+            yield
+        finally:
+            try:
+                driver.call_timeout = before
+            except Exception:  # noqa: BLE001 - 超时后连接可能已经被驱动关掉
+                pass
+        return
+
+    if kind == "sqlite":
+        driver = await _driver(conn)
+        await driver.set_progress_handler(deadline.sqlite_progress, _SQLITE_STEPS)
+        try:
+            yield
+        finally:
+            deadline.over = True
+            try:
+                await driver.set_progress_handler(None, 0)
+            except Exception:  # noqa: BLE001 - over 已经让它不再掐人
+                pass
+        return
+
+    yield
+
+
+async def _bounded(
+    opener: Callable[[], Any], kind: str, limits: QueryLimits, over: str,
+    work: Callable[[AsyncConnection], Awaitable[Any]],
+) -> Any:
+    """在 opener() 开的连接上跑 work，时限交给数据库执行，后端这边再留一道兜底。
+
+    数据库按时限停下语句时报的错，翻成 over 这句话：「超过 Ns 被中断」。
+    """
+    deadline: _Deadline | None = None
+
+    async def _exec() -> Any:
+        nonlocal deadline
+        async with opener() as conn:
+            deadline = _Deadline(limits.timeout_seconds)
+            async with _server_deadline(conn, kind, deadline):
+                return await work(conn)
+
+    try:
+        return await asyncio.wait_for(_exec(), timeout=limits.timeout_seconds + BACKSTOP_S)
+    except asyncio.TimeoutError as e:
+        raise SqlRejected(over) from e
+    except Exception as e:
+        if deadline is not None and deadline.stopped(e):
+            raise SqlRejected(over) from e
+        raise
+
+
 async def run_query(
     source: Any, sql: str, *, limits: QueryLimits | None = None
 ) -> QueryResult:
@@ -213,44 +454,40 @@ async def run_query(
 
     注意执行的是 guard.check 的返回值而不是原始输入——守卫会把尾分号之类
     规范掉，执行原文等于绕过了守卫。
-    """
-    import time
 
-    limits = limits or QueryLimits()
+    时限没指定时按数据源自己的配置（query_timeout），由数据库执行（_server_deadline）。
+    """
+    limits = limits or QueryLimits(timeout_seconds=query_timeout(source))
     statement = check(sql, readonly=bool(source.readonly), source_name=source.name)
+    kind = (source.kind or "").lower()
 
     engine = await engines.get(source)
     started = time.perf_counter()
 
     if not source.readonly and is_write(statement):
-        return await _run_write(engine, statement, limits, started)
+        return await _run_write(engine, kind, statement, limits, started)
 
-    async def _exec() -> tuple[list[str], list[list[Any]], bool]:
-        async with engine.connect() as conn:
-            cursor = await conn.stream(text(statement))
-            columns = list(cursor.keys())
-            rows: list[list[Any]] = []
-            truncated = False
-            size = 0
-            async for row in cursor:
-                # 逐行累加，边收边判上限：一次性 fetchall 一个亿级表就晚了
-                values = [_jsonable(v) for v in row]
-                rows.append(values)
-                size += len(json.dumps(values, ensure_ascii=False, default=str))
-                if len(rows) >= limits.max_rows or size >= limits.max_bytes:
-                    truncated = True
-                    break
-            return columns, rows, truncated
-
-    try:
-        columns, rows, truncated = await asyncio.wait_for(
-            _exec(), timeout=limits.timeout_seconds
-        )
-    except asyncio.TimeoutError as e:
-        raise SqlRejected(
-            f"查询超过 {limits.timeout_seconds}s 被中断。加上 WHERE 条件或 LIMIT 缩小范围。"
-        ) from e
+    async def _read(conn: AsyncConnection) -> tuple[list[str], list[list[Any]], bool]:
+        cursor = await conn.stream(text(statement))
+        columns = list(cursor.keys())
+        rows: list[list[Any]] = []
+        truncated = False
+        size = 0
+        async for row in cursor:
+            # 逐行累加，边收边判上限：一次性 fetchall 一个亿级表就晚了
+            values = [_jsonable(v) for v in row]
+            rows.append(values)
+            size += len(json.dumps(values, ensure_ascii=False, default=str))
+            if len(rows) >= limits.max_rows or size >= limits.max_bytes:
+                truncated = True
+                break
+        return columns, rows, truncated
 
+    columns, rows, truncated = await _bounded(
+        engine.connect, kind, limits,
+        f"查询超过 {_seconds(limits.timeout_seconds)}s 被中断。加上 WHERE 条件或 LIMIT 缩小范围。",
+        _read,
+    )
     return QueryResult(
         columns=columns,
         rows=rows,
@@ -262,7 +499,7 @@ async def run_query(
 
 
 async def _run_write(
-    engine: AsyncEngine, statement: str, limits: QueryLimits, started: float
+    engine: AsyncEngine, kind: str, statement: str, limits: QueryLimits, started: float
 ) -> QueryResult:
     """可写源上的写操作：真的提交。
 
@@ -271,20 +508,19 @@ async def _run_write(
     能走到这里的写都已经过了审批（registry.call_is_dangerous → 各节点的审批关卡），
     只读源上的写在 check 里就被拒了。
     """
-    import time
 
-    async def _exec() -> tuple[list[str], list[list[Any]]]:
-        async with engine.begin() as conn:   # 正常退出提交，出错回滚
-            result = await conn.execute(text(statement))
-            if result.returns_rows:          # RETURNING、PG 的数据修改 CTE
-                return (list(result.keys()),
-                        [[_jsonable(v) for v in row] for row in result.fetchmany(limits.max_rows)])
-            return ["affected_rows"], [[result.rowcount]]
+    async def _write(conn: AsyncConnection) -> tuple[list[str], list[list[Any]]]:
+        result = await conn.execute(text(statement))
+        if result.returns_rows:          # RETURNING、PG 的数据修改 CTE
+            return (list(result.keys()),
+                    [[_jsonable(v) for v in row] for row in result.fetchmany(limits.max_rows)])
+        return ["affected_rows"], [[result.rowcount]]
 
-    try:
-        columns, rows = await asyncio.wait_for(_exec(), timeout=limits.timeout_seconds)
-    except asyncio.TimeoutError as e:
-        raise SqlRejected(f"写操作超过 {limits.timeout_seconds}s 被中断，已回滚。") from e
+    # engine.begin()：正常退出提交，出错（包括数据库按时限停下）回滚
+    columns, rows = await _bounded(
+        engine.begin, kind, limits,
+        f"写操作超过 {_seconds(limits.timeout_seconds)}s 被中断，已回滚。", _write,
+    )
     return QueryResult(
         columns=columns,
         rows=rows,
diff --git a/backend/app/data/guard.py b/backend/app/data/guard.py
index eda0e85c..f49f6616 100644
--- a/backend/app/data/guard.py
+++ b/backend/app/data/guard.py
@@ -83,7 +83,8 @@ class SqlRejected(ValueError):
 class QueryLimits:
     max_rows: int = 1000
     max_bytes: int = 1_000_000
-    timeout_seconds: int = 30
+    #: 数据源可以在 options.query_timeout_s 里自己定（见 data.engine.query_timeout），可以带小数
+    timeout_seconds: float = 30
 
 
 def strip_comments(sql: str) -> str:
diff --git a/backend/app/data/introspect.py b/backend/app/data/introspect.py
index 0d55d80c..8d1a9fbd 100644
--- a/backend/app/data/introspect.py
+++ b/backend/app/data/introspect.py
@@ -279,17 +279,43 @@ def _detailed_summary(source: Any, *, max_tables: int = 40) -> str:
     return "\n".join(lines)
 
 
-def describe_table(source: Any, table: str) -> str:
-    """单表的完整字段说明。agent 调 db_schema 工具时返回这个。"""
-    cache = source.schema_cache or {}
-    tables = cache.get("tables") or {}
-    # 模型可能传全名（ANALYTICS.V_TRIP_FACT），也可能只传表名，两种都认
+def find_table(source: Any, table: str) -> dict[str, Any] | None:
+    """在缓存里找一张表。全名、只有表名、大小写不一致都认——模型和人都可能这么写。"""
+    tables = (source.schema_cache or {}).get("tables") or {}
     meta = tables.get(table)
     if meta is None and "." in table:
         meta = tables.get(table.rsplit(".", 1)[-1])
     if meta is None:
         lowered = table.rsplit(".", 1)[-1].lower()
         meta = next((m for n, m in tables.items() if n.lower() == lowered), None)
+    return meta or None
+
+
+def table_columns(meta: dict[str, Any]) -> list[dict[str, Any]]:
+    """结构化的列：{name, type, pk, not_null, comment}。
+
+    界面要画表格，以前只能去解析 describe_table 那段给模型看的文本，文本格式
+    一改就全乱。两份出自同一份缓存，说法一致。
+    """
+    pk = set(meta.get("primary_key") or [])
+    return [
+        {
+            "name": col["name"],
+            "type": col.get("type") or "",
+            "pk": col["name"] in pk,
+            "not_null": not col.get("nullable", True),
+            "comment": col.get("comment") or None,
+        }
+        for col in meta.get("columns") or []
+    ]
+
+
+def describe_table(source: Any, table: str) -> str:
+    """单表的完整字段说明。agent 调 db_schema 工具时返回这个。"""
+    cache = source.schema_cache or {}
+    tables = cache.get("tables") or {}
+    # 模型可能传全名（ANALYTICS.V_TRIP_FACT），也可能只传表名，两种都认
+    meta = find_table(source, table)
     if not meta:
         if not tables:
             # 缓存是空的，说"里面没有这张表"就是在误导——真相是我们什么都不知道。
diff --git a/backend/app/db/base.py b/backend/app/db/base.py
index 3d4c1eae..44496088 100644
--- a/backend/app/db/base.py
+++ b/backend/app/db/base.py
@@ -161,6 +161,9 @@ _COLUMN_MIGRATIONS: list[tuple[str, str, str]] = [
     # 存量轮次没有复核结论。NULL 正好表示"这一轮没复核过"，和"复核过、没问题"
     # （存 verdict=ok）是两回事，前端要分得开
     ("conversation_turns", "review", "JSON"),
+    ("conversation_turns", "meta", "JSON"),
+    ("data_sources", "last_check", "JSON"),
+    ("mcp_servers", "last_check", "JSON"),
 ]
 
 
diff --git a/backend/app/db/models.py b/backend/app/db/models.py
index 30b3d0e4..be491db7 100644
--- a/backend/app/db/models.py
+++ b/backend/app/db/models.py
@@ -59,6 +59,8 @@ class DataSource(Base, TimestampMixin):
     schema_cache: Mapped[dict[str, Any]] = mapped_column(default=dict)
     schema_synced_at: Mapped[datetime | None] = mapped_column(default=None)
     enabled: Mapped[bool] = mapped_column(default=True)
+    # 最近一次测连接：{at, ok, latency_ms, error}。记在对象上，换台浏览器也看得到
+    last_check: Mapped[dict[str, Any] | None] = mapped_column(default=None)
 
 
 class Setting(Base, TimestampMixin):
@@ -85,6 +87,8 @@ class McpServer(Base, TimestampMixin):
     status: Mapped[str] = mapped_column(String(20), default="unknown")
     last_error: Mapped[str | None] = mapped_column(Text, default=None)
     tools_cache: Mapped[list[Any]] = mapped_column(default=list)
+    # 最近一次连接的时刻和耗时（status / last_error 只有结论，没有「何时、多快」）
+    last_check: Mapped[dict[str, Any] | None] = mapped_column(default=None)
 
 
 class CustomTool(Base, TimestampMixin):
@@ -435,5 +439,8 @@ class ConversationTurn(Base, TimestampMixin):
     # 命中的信号清单。落库是因为它是答案的一部分——刷新页面后只剩一个
     # 看起来很完整的答案、而"它哪里不可靠"没了，比不复核更糟
     review: Mapped[dict[str, Any] | None] = mapped_column(default=None)
+    # 这一轮的可信度元数据（出具档位、运行类别、未查库、结局、耗时、查库次数…），
+    # 前端写、前端读。单独一列：塞在 review 里的话，没复核过的轮次 review 也不为空
+    meta: Mapped[dict[str, Any] | None] = mapped_column(default=None)
 
     conversation: Mapped[Conversation] = relationship(back_populates="turns")
diff --git a/backend/app/engine/compiler.py b/backend/app/engine/compiler.py
index acdb11b1..e7de975f 100644
--- a/backend/app/engine/compiler.py
+++ b/backend/app/engine/compiler.py
@@ -8,9 +8,9 @@ from typing import Any, Awaitable, Callable
 from langgraph.errors import GraphBubbleUp
 from langgraph.graph import END, START, StateGraph
 
+from app.core.errors import describe_exception, raw_detail
 from app.core.events import EventType
 from app.engine.context import NodeContext, NodeError, RunContext
-from app.engine.errors import describe_exception, raw_detail
 from app.engine.nodes import control, human, io, knowledge, llm, metrics, multi, tools
 from app.engine.schema import GraphNode, GraphSpec, NodeType, back_edges, innermost_loops
 from app.engine.state import GraphState
diff --git a/backend/app/engine/errors.py b/backend/app/engine/errors.py
deleted file mode 100644
index 57d71f0d..00000000
--- a/backend/app/engine/errors.py
+++ /dev/null
@@ -1,81 +0,0 @@
-"""把异常翻成给人看的一句话。
-
-界面上出现过的原样报错：「工具 db_query__shop 执行失败：_make_query_tool.<locals>._run()
-got an unexpected keyword argument 'query'」「TypeError: Integer exceeds 64-bit range」。
-问数据的业务用户读不懂这些，也不知道下一步该做什么。
-
-这里只管"原因"那半句，不带异常类名和内部符号；"发生了什么"和"怎么办"由调用方
-按场景拼。原始异常另外放进事件的 detail 字段、写进日志，排查的人照样拿得到。
-"""
-from __future__ import annotations
-
-import json
-import re
-
-# 供应商 SDK / httpx 的网络类异常。按类名认而不 import：这些包不一定都装了，
-# 而这里只需要知道"是不是连不上"
-_NETWORK = {"ConnectError", "ConnectTimeout", "APIConnectionError", "RemoteProtocolError",
-            "ReadError", "NetworkError"}
-_TIMEOUT = {"ReadTimeout", "WriteTimeout", "PoolTimeout", "APITimeoutError", "TimeoutException"}
-
-# 内部符号：`a.b.<locals>._run()`、`<function f at 0x…>`、模块路径。对使用者没有意义
-_LOCALS = re.compile(r"[\w.]*<locals>\.?[\w.]*(\(\))?")
-_REPR = re.compile(r"<(?:function|bound method|coroutine|object) [^>]*>")
-# 包在消息里的异常类名（"连不上：ConnectError: All connection attempts failed"）
-_CLASS = re.compile(r"\b[A-Z]\w*(?:Error|Exception|Warning)\b:\s*")
-
-
-def _names(exc: BaseException) -> set[str]:
-    return {cls.__name__ for cls in type(exc).__mro__}
-
-
-def _scrub(text: str) -> str:
-    text = _LOCALS.sub("内部函数", text)
-    text = _REPR.sub("内部对象", text)
-    text = _CLASS.sub("", text)
-    return " ".join(text.split())[:240]
-
-
-def describe_exception(exc: BaseException) -> str:
-    """原因，一句话。常见的几类写成固定说法，其余的去掉内部符号后照实说。"""
-    names = _names(exc)
-    text = str(exc).strip()
-
-    status = getattr(exc, "status_code", None)
-    if isinstance(status, int):
-        if status in (401, 403):
-            return f"鉴权没通过（{status}）：key 无效、过期，或没有这个模型的权限"
-        if status == 429:
-            return "请求太频繁，或者额度用完了（429）"
-        if status >= 500:
-            return f"对方服务出错了（{status}），多半是暂时的"
-
-    if isinstance(exc, TypeError):
-        if m := re.search(r"unexpected keyword argument '(\w+)'", text):
-            return f"参数对不上：它不接受名为「{m.group(1)}」的参数"
-        if m := re.search(r"missing \d+ required (?:positional |keyword-only )?arguments?: (.+)$", text):
-            wanted = "、".join(re.findall(r"'(\w+)'", m.group(1))) or m.group(1)
-            return f"缺少必填参数「{wanted}」"
-    if isinstance(exc, TimeoutError) or names & _TIMEOUT:
-        return "等待超时：对方没有在限定时间内响应"
-    if isinstance(exc, ConnectionError) or names & _NETWORK:
-        return "连不上对方服务：网络不通，或者服务没有启动"
-    if isinstance(exc, PermissionError):
-        return "没有权限访问需要的文件或资源"
-    if isinstance(exc, FileNotFoundError):
-        return f"找不到文件{'「' + str(exc.filename) + '」' if exc.filename else ''}"
-    if isinstance(exc, json.JSONDecodeError):
-        return "返回的内容不是合法的 JSON"
-    if isinstance(exc, KeyError):
-        return f"缺少字段「{exc.args[0] if exc.args else '?'}」"
-    if isinstance(exc, (OverflowError, MemoryError)):
-        return f"数据超出了能处理的范围{'：' + _scrub(text) if text else ''}"
-    return _scrub(text) or "没有给出原因的内部错误"
-
-
-def raw_detail(exc: BaseException | None) -> str | None:
-    """原始异常，给排查的人看。只进事件的 detail 字段和日志，不进首行报错。"""
-    if exc is None:
-        return None
-    text = str(exc).strip()
-    return f"{type(exc).__name__}: {text}"[:2000] if text else type(exc).__name__
diff --git a/backend/app/engine/nodes/human.py b/backend/app/engine/nodes/human.py
index 0e9e0841..c628c8c4 100644
--- a/backend/app/engine/nodes/human.py
+++ b/backend/app/engine/nodes/human.py
@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 import json
+import re
+import time
 from typing import Any
 
-from langgraph.types import interrupt
-
 from app.core.events import EventType
 from app.db.base import SessionLocal
 from app.engine.approval import read_decision
 from app.engine.context import NodeContext, NodeError
-from app.engine.state import GraphState, message_text, template_context
+from app.engine.replay import ask, once
+from app.engine.state import GraphState, merge_usage, message_text, template_context
+from app.providers import catalog
 from app.providers.factory import ModelSpec, get_chat_model
 
 
@@ -32,10 +34,9 @@ async def run_human(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     if mode == "edit":
         payload["draft"] = ctx.render(ctx.cfg("draft", ""), state)
 
-    ctx.emit(EventType.HUMAN_REQUESTED, **payload)
-    response = interrupt(payload)
+    response = await ask(ctx, payload, **payload)
     # 谁批的跟着事件走：时间线要写得出"张工驳回了"，没署名就是 None，不再默认写"你"
-    ctx.emit(EventType.HUMAN_RESOLVED, response=response, actor=ctx.actor())
+    await once(ctx, EventType.HUMAN_RESOLVED, response=response, actor=ctx.actor())
     decision = read_decision(response)
 
     if mode == "approve":
@@ -79,6 +80,7 @@ async def run_validate(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     """按 JSON Schema 校验上游产出。
 
     校验失败时可以把错误原样喂回模型让它改 —— 这比在 prompt 里祈祷它输出正确格式可靠得多。
+    但修复只许改格式：修出来的值要能在原文里找到，找不到的就是模型编的（见 _invented）。
     """
     import jsonschema
 
@@ -87,24 +89,35 @@ async def run_validate(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         raise NodeError(ctx.node.id, "校验节点需要一个 JSON Schema")
 
     source_cfg = ctx.cfg("source", "{{ last_message }}")
-    raw = ctx.render(source_cfg, state) if not isinstance(source_cfg, str) else ctx.render_str(source_cfg, state)
+    original = ctx.render(source_cfg, state) if not isinstance(source_cfg, str) else ctx.render_str(source_cfg, state)
     max_retries = int(ctx.cfg("max_retries", 2) or 0)
     repair = bool(ctx.cfg("repair_with_llm", True))
 
     attempt = 0
     errors: list[str] = []
+    raw: Any = original
     value: Any = raw
+    usage: dict[str, Any] = {}
 
     while True:
         value, parse_error = _coerce_json(raw)
+        invented = [] if parse_error or raw is original else _invented(value, original, schema)
         if parse_error:
             errors = [parse_error]
+        elif invented:
+            # 修复编出了原文没有的值（真实运行里是凭空的 total_count: 0）。这次修复作废，
+            # 下一次仍从原文修，而不是在编出来的那份上接着改
+            errors = [f"修复时出现了原文没有的值：{'、'.join(invented[:5])}"]
+            ctx.emit(EventType.LOG, level="warn", code="repair_invented",
+                     message=f"第 {attempt} 次修复作废：{errors[0]}")
         else:
             try:
                 jsonschema.validate(value, schema)
                 ctx.emit(EventType.LOG, level="info", message=f"校验通过（第 {attempt + 1} 次尝试）")
                 result = {"valid": True, "data": value, "attempts": attempt + 1, "errors": []}
                 updates: dict[str, Any] = {"nodes": {ctx.node.id: result}}
+                if usage:
+                    updates["usage"] = usage
                 var_name = ctx.cfg("assign_to", "")
                 if var_name:
                     updates["vars"] = {var_name: value}
@@ -113,17 +126,19 @@ async def run_validate(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                 path = "/".join(str(p) for p in e.absolute_path) or "(根)"
                 errors = [f"{path}: {e.message}"]
 
-        ctx.emit(EventType.LOG, level="warn", message=f"第 {attempt + 1} 次校验失败：{errors[0]}",
-                 code="validate_retry")
+        if not invented:
+            ctx.emit(EventType.LOG, level="warn", message=f"第 {attempt + 1} 次校验失败：{errors[0]}",
+                     code="validate_retry")
         attempt += 1
         if attempt > max_retries or not repair:
             break
-        raw = await _repair(raw, schema, errors, ctx, state)
+        raw, spent = await _repair(original, schema, errors, ctx)
+        usage = merge_usage(usage, spent)
 
     result = {"valid": False, "data": value, "attempts": attempt, "errors": errors}
     if ctx.cfg("fail_fast", True):
         raise NodeError(ctx.node.id, f"结构化校验未通过：{'; '.join(errors)}")
-    return {"nodes": {ctx.node.id: result}}
+    return {"nodes": {ctx.node.id: result}, **({"usage": usage} if usage else {})}
 
 
 def _coerce_json(raw: Any) -> tuple[Any, str | None]:
@@ -150,18 +165,155 @@ def _coerce_json(raw: Any) -> tuple[Any, str | None]:
     return text, "输出不是合法 JSON"
 
 
-async def _repair(raw: Any, schema: dict[str, Any], errors: list[str], ctx: NodeContext,
-                  state: GraphState) -> str:
+async def _repair(raw: Any, schema: dict[str, Any], errors: list[str],
+                  ctx: NodeContext) -> tuple[str, dict[str, Any]]:
+    """让模型只改格式地重写一遍。返回 (重写的文本, 这次调用的用量)。"""
     async with SessionLocal() as session:
-        model, _ = await get_chat_model(
+        model, model_id = await get_chat_model(
             session,
             ModelSpec(provider=ctx.cfg("provider"), model=ctx.cfg("model"), max_tokens=4096),
         )
     prompt = (
-        "下面这段输出没有通过 JSON Schema 校验，请修正后重新输出。\n\n"
+        "下面这段输出没有通过 JSON Schema 校验，请只调整格式后重新输出。\n\n"
+        "规矩：你只能搬运原始输出里已经有的值，不许补数据。原始输出里没有的值一律填 null，"
+        "即使 Schema 要求它不能为空——不许用 0、空字符串或任何猜测的值凑数，不许编造。"
+        "值要从原文里原样抄过来。\n\n"
         f"Schema：\n{json.dumps(schema, ensure_ascii=False, indent=2)}\n\n"
         f"错误：\n- " + "\n- ".join(errors) + "\n\n"
-        f"原始输出：\n{str(raw)[:6000]}\n\n"
+        f"原始输出：\n{_as_text(raw)[:6000]}\n\n"
         "只输出修正后的 JSON，不要任何解释或代码围栏。"
     )
-    return message_text(await model.ainvoke(prompt))
+    started = time.perf_counter()
+    response = await model.ainvoke(prompt)
+    # 修复是一次真实的模型调用，以前不发 llm.end、不进 usage，钱花了账上看不见
+    meta = getattr(response, "usage_metadata", None) or {}
+    inp, out = int(meta.get("input_tokens") or 0), int(meta.get("output_tokens") or 0)
+    spent = {"input_tokens": inp, "output_tokens": out, "total_tokens": inp + out,
+             "cost_usd": round(catalog.estimate_cost(model_id, inp, out), 6), "calls": 1}
+    ctx.emit(EventType.LLM_END, model=model_id, purpose="repair",
+             duration_ms=int((time.perf_counter() - started) * 1000), **spent)
+    return message_text(response), spent
+
+
+def _as_text(raw: Any) -> str:
+    return raw if isinstance(raw, str) else json.dumps(raw, ensure_ascii=False, default=str)
+
+
+# 原文里的数字：可带千分位、小数、正负号
+_NUMBER = re.compile(r"-?\d[\d,]*(?:\.\d+)?")
+_PERCENT = re.compile(r"(-?\d[\d,]*(?:\.\d+)?)\s*[%％]")
+# 字符串值里要能在原文找到的片段：数字、拉丁词、连续的汉字
+_PIECE = re.compile(r"\d+(?:\.\d+)?|[A-Za-z]+|[\u4e00-\u9fff]+")
+
+# 数字的证据不从代码里取。「假设调用工具 + 一段 SQL」正是最常见的造假形状，而 SQL 里
+# 到处是数字：WHERE status > 0、deleted = 0、LIMIT 10。认它们的话，编出来的
+# total_count: 0 就有了「出处」。要去掉的是：代码围栏（sql / python / shell 之类）、
+# "sql": "…" 这类字符串值、以及正文里看起来像 SQL 的那一段（SELECT … FROM … 到句末，
+# 后面接着的 WHERE / LIMIT 之类的行一并算进去）
+_CODE_FENCE = re.compile(
+    r"```[ \t]*(?:sql|mysql|postgres(?:ql)?|sqlite|plsql|python|py|bash|sh|shell|zsh"
+    r"|javascript|js|typescript|ts)\b.*?(?:```|$)", re.I | re.S)
+_CODE_VALUE = re.compile(r'"(?:sql|query|statement|code|script|command)"\s*:\s*"(?:[^"\\]|\\.)*"',
+                         re.I)
+_SQL_RUN = re.compile(
+    r"\b(?:select\b|with\s+(?:recursive\s+)?\w+\s*(?:\([^)]*\))?\s+as\s*\()"
+    r"(?:(?!\.\s)[^；;。]){0,400}?\bfrom\b[^\n；;。，]*"
+    r"(?:\n[ \t]*(?:where|and|or|group|order|having|limit|offset|union|on|join|left|right|inner"
+    r"|outer|full|cross)\b[^\n；;。，]*)*", re.I)
+
+
+def _without_code(text: str) -> str:
+    for pattern in (_CODE_FENCE, _CODE_VALUE, _SQL_RUN):
+        text = pattern.sub(" ", text)
+    return text
+
+
+def _numbers_in(text: str) -> set[float]:
+    """原文里（代码之外）所有数字的值。中文写法（十二条、3.5万）按出具回指那套规则一并认；
+    带百分号的另认它的小数写法（12.5% → 0.125 是格式换算，不是编造）。"""
+    from app.engine.issuance import extract_numbers
+
+    text = _without_code(text)
+    out: set[float] = {token.value for token in extract_numbers(text)}
+    for token in _NUMBER.findall(text):
+        try:
+            out.add(float(token.replace(",", "")))
+        except ValueError:
+            continue
+    for token in _PERCENT.findall(text):
+        try:
+            out.add(float(token.replace(",", "")) / 100)
+        except ValueError:
+            continue
+    return out
+
+
+def _literals(schema: Any) -> set[str]:
+    """Schema 自己规定的取值（enum / const）：把「成功」映射成 "ok" 是格式，不是编造。"""
+    found: set[str] = set()
+    if isinstance(schema, dict):
+        for key in ("enum", "const"):
+            value = schema.get(key)
+            for item in value if isinstance(value, list) else [value]:
+                if item is not None:
+                    found.add(str(item))
+        for value in schema.values():
+            found |= _literals(value)
+    elif isinstance(schema, list):
+        for value in schema:
+            found |= _literals(value)
+    return found
+
+
+def _invented(value: Any, original: Any, schema: dict[str, Any]) -> list[str]:
+    """修复结果里原文没有的值，写成 "路径=值"。
+
+    数字按数值比（原文写 1,284，修出来 1284 算有）；非空字符串要么原样出现在原文里，
+    要么它的每个数字、拉丁词、汉字片段都能在原文里找到（2026年9月1日 → 2026-09-01
+    算搬运）。布尔、null 不查：null 正是「没有这个数据」的诚实写法。
+    """
+    text = _as_text(original)
+    lowered = text.lower()
+    numbers = _numbers_in(text)
+    allowed = _literals(schema)
+    found: list[str] = []
+
+    def known_number(n: float) -> bool:
+        return any(abs(n - m) <= 1e-9 for m in numbers)
+
+    def walk(node: Any, path: str) -> None:
+        if isinstance(node, dict):
+            for key, item in node.items():
+                walk(item, f"{path}.{key}" if path else str(key))
+        elif isinstance(node, list):
+            for i, item in enumerate(node):
+                walk(item, f"{path}[{i}]")
+        elif isinstance(node, bool) or node is None:
+            return
+        elif isinstance(node, (int, float)):
+            if not known_number(float(node)):
+                found.append(f"{path or '(根)'}={node}")
+        elif isinstance(node, str):
+            s = node.strip()
+            if not s:
+                if '""' not in text:
+                    found.append(f'{path or "(根)"}=""')
+                return
+            if s in allowed:
+                return
+            if _NUMBER.fullmatch(s):
+                # 写成字符串的数字照数字查："0" 不能因为 SQL 里有个 > 0 就算有出处
+                if not known_number(float(s.replace(",", ""))):
+                    found.append(f"{path or '(根)'}={s[:40]}")
+                return
+            if s.lower() in lowered:
+                return
+            pieces = _PIECE.findall(s)
+            ok = bool(pieces) and all(
+                known_number(float(p)) if p[0].isdigit() else p.lower() in lowered for p in pieces
+            )
+            if not ok:
+                found.append(f"{path or '(根)'}={s[:40]}")
+
+    walk(value, "")
+    return found
diff --git a/backend/app/engine/nodes/io.py b/backend/app/engine/nodes/io.py
index fecb7b96..7789d14d 100644
--- a/backend/app/engine/nodes/io.py
+++ b/backend/app/engine/nodes/io.py
@@ -78,6 +78,8 @@ def _apply_contract(
     # 没有它，一个写错的节点名会让所有列表都是空的，看起来和"全部通过"一模一样。
     gaps: list[str] = []
     unresolved: list[str] = []
+    #: 指标 id → 它来自哪张口径卡（「销售口径 @ v2」），逐个数字回指时标出处
+    caliber_of: dict[str, str] = {}
     for source in sources:
         payload = nodes.get(source)
         if isinstance(payload, dict) and payload.get("kind") == "metric_set":
@@ -89,6 +91,9 @@ def _apply_contract(
                     "version": payload.get("caliber_version", ""),
                 }
             )
+            label = " @ ".join(str(v) for v in (payload.get("caliber"), payload.get("caliber_version")) if v)
+            for m in payload.get("metrics") or []:
+                caliber_of.setdefault(str(m.get("id")), label)
         else:
             # 节点不存在、还没跑到、或者根本不是口径卡——指标集就是缺的，
             # 不能当作"这次没有指标要查"
@@ -121,6 +126,14 @@ def _apply_contract(
     if sources and not metrics:
         gaps.append("指标集为空，叙述里的数字无从回指")
 
+    # 上游有协作团队用完轮数、按降档交付的：叙述里的话不是调度者认可的结论，
+    # 数字全都对得上也不能盖「完整出具」
+    titles = {n.id: n.title for n in ctx.run.spec.nodes}
+    for node_id, payload in nodes.items():
+        if isinstance(payload, dict) and payload.get("exhausted"):
+            gaps.append(f"协作团队「{titles.get(node_id, node_id)}」用完 {payload.get('rounds', '?')} "
+                        "轮仍未完成，交来的是成员最后的原话")
+
     tier = decide_tier(
         missing_required=missing_required,
         missing_expected=missing_expected,
@@ -129,6 +142,11 @@ def _apply_contract(
         gaps=gaps,
     )
 
+    # 逐个数字的出处。以前只有一个计数，界面标不出「这个数来自哪个指标」
+    matched = [
+        {**hit, **({"caliber": caliber_of[hit["metric"]]} if caliber_of.get(hit.get("metric")) else {})}
+        for hit in (trace.matched if trace else [])
+    ][:50]
     issuance = {
         "tier": tier,
         "calibers": calibers,  # 口径版本照常印
@@ -137,6 +155,7 @@ def _apply_contract(
         "missing_expected": missing_expected,  # 缺数据声明照常印
         "unmatched_numbers": unmatched[:20],
         "matched_numbers": len(trace.matched) if trace else 0,
+        "matched": matched,
         # 校验没跑全的原因照实印出来——读的人要能分辨"查过都对"和"根本没查"
         "gaps": gaps,
         "declared_at": datetime.now(timezone.utc).isoformat(),
@@ -153,6 +172,7 @@ def _apply_contract(
         gaps=gaps,
         metrics_checked=len(metrics),
         matched_numbers=len(trace.matched) if trace else 0,
+        matched=matched,
     )
     return issuance
 
diff --git a/backend/app/engine/nodes/llm.py b/backend/app/engine/nodes/llm.py
index 88c002b9..fe676317 100644
--- a/backend/app/engine/nodes/llm.py
+++ b/backend/app/engine/nodes/llm.py
@@ -7,17 +7,27 @@ from typing import Any
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, SystemMessage, ToolMessage
 from langchain_core.tools import BaseTool
 from langgraph.func import task
-from langgraph.types import interrupt
 from sqlalchemy import select
 
 from app.core.config import settings
+from app.core.errors import describe_exception, raw_detail
 from app.core.events import EventType
 from app.db.base import SessionLocal
 from app.db.models import Skill
 from app.engine.approval import read_decision
 from app.engine.context import NodeContext, NodeError
-from app.engine.errors import describe_exception
+from app.engine.replay import ask, once
 from app.engine.state import GraphState, message_text, template_context, thinking_text
+from app.engine.toolcalls import (
+    TOOL_MARKUP_ERROR,
+    TOOL_MARKUP_NUDGE,
+    ToolTimeout,
+    leaked_markup,
+    limit_fields,
+    limit_of,
+    markup_warning,
+    run_bounded,
+)
 from app.providers import catalog
 from app.providers.factory import (
     ModelSpec,
@@ -27,6 +37,7 @@ from app.providers.factory import (
 )
 from app.tools.registry import (
     ToolArgsError,
+    ToolBuildError,
     ToolContext,
     args_model_of,
     build_tools,
@@ -124,6 +135,14 @@ def _usage_of(message: BaseMessage, model_id: str) -> dict[str, Any]:
     }
 
 
+def _report_call(ctx: NodeContext, response: BaseMessage, model_id: str, started: float) -> dict[str, Any]:
+    """一次模型调用一条 llm.end。返回这一次的用量。"""
+    usage = _usage_of(response, model_id)
+    ctx.emit(EventType.LLM_END, model=model_id,
+             duration_ms=int((time.perf_counter() - started) * 1000), **usage)
+    return usage
+
+
 def explain_model_error(exc: Exception, model_id: str) -> str:
     """把供应商的原始报错翻成能照着做的一句话。
 
@@ -218,6 +237,8 @@ async def run_llm(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     messages = await _build_messages(state, ctx)
     schema = ctx.cfg("output_schema")
     started = time.perf_counter()
+    #: 这个节点里每次模型调用的用量。正常只有一次；模型把工具调用写成文字时会多一次纠正
+    spent: list[dict[str, Any]] = []
 
     if schema:
         # 要结构化结果就走原生 structured output，这条路径拿不到 token 流
@@ -241,9 +262,23 @@ async def run_llm(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         payload = value if isinstance(value, (dict, list)) else getattr(value, "model_dump", lambda: value)()
         output = {"data": payload, "text": json.dumps(payload, ensure_ascii=False, indent=2)}
         response: BaseMessage = AIMessage(content=output["text"])
+        spent.append(_report_call(ctx, response, model_id, started))
     else:
         response = await _invoke_streaming(model, messages, ctx, model_id)
+        spent.append(_report_call(ctx, response, model_id, started))
         text = message_text(response)
+        if snippet := leaked_markup(text):
+            # 模型把工具调用当正文写了出来：这个节点压根没有工具，那段"调用"什么都没查到。
+            # 带一句纠正再问一次；还这样就判失败，别让一堆标记当答案往下游走
+            ctx.emit(EventType.LOG, level="warn", code="tool_markup_leak",
+                     message=f"{markup_warning(snippet)}，已提醒它重试一次")
+            retried = time.perf_counter()
+            response = await _invoke_streaming(
+                model, [*messages, response, HumanMessage(content=TOOL_MARKUP_NUDGE)], ctx, model_id)
+            spent.append(_report_call(ctx, response, model_id, retried))
+            text = message_text(response)
+            if leaked_markup(text):
+                raise NodeError(ctx.node.id, TOOL_MARKUP_ERROR)
         reasoning = thinking_text(response)
         if not text and reasoning:
             # 思考型模型把额度全花在推理上了，正文是空的 —— 说清楚而不是抛个空结果给下游
@@ -252,14 +287,9 @@ async def run_llm(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                      code="empty_completion")
         output = {"text": text, "thinking": reasoning}
 
-    usage = _usage_of(response, model_id)
     elapsed = int((time.perf_counter() - started) * 1000)
-    ctx.emit(
-        EventType.LLM_END,
-        model=model_id,
-        duration_ms=elapsed,
-        **usage,
-    )
+    usage = {key: sum(one[key] for one in spent) for key in spent[0]}
+    usage["cost_usd"] = round(usage["cost_usd"], 6)
 
     result = {**output, "model": model_id, "duration_ms": elapsed}
     updates: dict[str, Any] = {
@@ -289,7 +319,11 @@ async def _resolve_tools(ctx: NodeContext, state: GraphState) -> list[BaseTool]:
         collection=ctx.cfg("collection") or ctx.run.collection,
     )
     async with SessionLocal() as session:
-        return await build_tools(names, tool_ctx, session=session)
+        try:
+            return await build_tools(names, tool_ctx, session=session)
+        except ToolBuildError as e:
+            # 绑的工具自己坏了（参数定义写坏的自定义工具）：说清是哪个、去哪里改
+            raise NodeError(ctx.node.id, str(e)) from e
 
 
 SKIPPED_NOTE = (
@@ -333,6 +367,10 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
 
     这里没有用 prebuilt 的 create_react_agent，因为需要在循环内部做三件它不做的事：
     每步工具调用都往画布推事件、对危险工具逐个弹人工审批、以及步数护栏。
+
+    人工审批恢复时整个节点从头重放。模型调用和工具调用都包在 @task 里，重放时结果
+    取自 checkpoint，不重复计费、不重复执行；它们的事件也发在 task 里面，于是轨迹里
+    同一次调用只出现一回。写在 task 外面的事件一律经 replay.once 发，道理相同。
     """
     model_spec = _model_spec(ctx)
     async with SessionLocal() as session:
@@ -354,12 +392,17 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     transcript: list[dict[str, Any]] = []
 
     def _report(response: BaseMessage, started: float) -> None:
-        # 每次模型调用一条 llm.end：用量在节点跑的过程中就看得到。发在 task 里面，
-        # 节点因审批重放时 task 结果取自 checkpoint，这条不会重复
+        # 每次模型调用一条 llm.end：用量在节点跑的过程中就看得到
         ctx.emit(EventType.LLM_END, agent=ctx.node.title, model=model_id,
                  duration_ms=int((time.perf_counter() - started) * 1000),
                  **_usage_of(response, model_id))
 
+    def _count(response: BaseMessage) -> None:
+        usage = _usage_of(response, model_id)
+        for key in ("input_tokens", "output_tokens", "calls"):
+            total_usage[key] += usage[key]
+        total_usage["cost_usd"] = round(total_usage["cost_usd"] + usage["cost_usd"], 6)
+
     # @task 的返回值会进 checkpoint：人工审批导致节点重放时，
     # 之前已经完成的模型调用和工具执行不会重跑，也就不会重复计费。
     @task
@@ -379,23 +422,75 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         return response
 
     @task
-    async def tool_step(step: int, name: str, args: dict[str, Any]) -> str:
+    async def tool_step(step: int, name: str, args: dict[str, Any], call_id: str) -> dict[str, Any]:
+        # 失败也在这里收住、作为结果返回：失败的那次同样只执行一回，重放时不再重试
         tool = tool_map[name]
-        result = await tool.ainvoke(args)
-        return result if isinstance(result, str) else json.dumps(result, ensure_ascii=False, default=str)
+        limit = limit_of(tool, name, args)
+        ctx.emit(EventType.TOOL_START, tool=name, args=args, call_id=call_id, **limit_fields(limit))
+        started = time.perf_counter()
+        extra: dict[str, Any] = {}
+        try:
+            result = await run_bounded(tool.ainvoke(args), limit, name)
+            content = result if isinstance(result, str) else json.dumps(result, ensure_ascii=False, default=str)
+            ok = True
+        except ToolTimeout as e:
+            # 到点就收回控制权，驱动的收尾在后台做完。模型拿到的是"等了多久、为什么放弃"
+            content, ok = str(e), False
+            extra = {"error": str(e), "timed_out": True}
+        except Exception as e:  # noqa: BLE001 - 工具失败要喂回模型，让它自己纠错
+            content = f"工具执行失败：{describe_exception(e)}"
+            schema = args_model_of(tool)
+            if isinstance(e, TypeError) and schema is not None:
+                # 签名对不上还能走到这儿，说明 schema 和函数本身不一致（工具的 bug）。
+                # 模型改不了这个，但把参数表摊开至少让它别在同一个地方反复试
+                content += f"\n{describe_args(schema, args)}"
+            ok = False
+            extra = {"error": content.splitlines()[0][:300], "detail": raw_detail(e)}
+        elapsed = int((time.perf_counter() - started) * 1000)
+        snapshot_id: str | None = None
+        if ok:
+            from app.core.artifact_store import put_json
+
+            try:
+                snapshot_id = await put_json(
+                    {"tool": name, "args": args, "result": content},
+                    kind="tool_snapshot", run_id=ctx.run.run_id, node_id=ctx.node.id,
+                )
+            except Exception:  # noqa: BLE001
+                snapshot_id = None
+        ctx.emit(
+            EventType.TOOL_END if ok else EventType.TOOL_ERROR,
+            tool=name,
+            call_id=call_id,
+            duration_ms=elapsed,
+            preview=content[:2000],
+            artifact=snapshot_id,
+            **extra,
+        )
+        return {"content": content, "ok": ok, "duration_ms": elapsed}
 
     final_text = ""
+    #: 模型把工具调用写成了文字：纠正过一次了没有
+    nudged = False
     for step in range(max_steps):
         response = await llm_step(step, messages)
         messages.append(response)
-        usage = _usage_of(response, model_id)
-        for key in ("input_tokens", "output_tokens", "calls"):
-            total_usage[key] += usage[key]
-        total_usage["cost_usd"] = round(total_usage["cost_usd"] + usage["cost_usd"], 6)
+        _count(response)
 
         tool_calls = getattr(response, "tool_calls", None) or []
         if not tool_calls:
             final_text = message_text(response)
+            if snippet := leaked_markup(final_text):
+                # 没有真实的调用，正文里却是一段调用标记：这一步什么都没查到。
+                # 纠正一次；再来一次就是这个节点/模型根本调不了工具，判失败
+                if nudged:
+                    raise NodeError(ctx.node.id, TOOL_MARKUP_ERROR)
+                nudged = True
+                await once(ctx, EventType.LOG, level="warn", code="tool_markup_leak",
+                           message=f"{markup_warning(snippet)}，已提醒它重试一次")
+                messages.append(HumanMessage(content=TOOL_MARKUP_NUDGE))
+                final_text = ""
+                continue
             break
 
         run_calls, deferred = split_tool_calls(tool_calls, parallel=parallel_tools)
@@ -421,35 +516,25 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                     # 不执行，把"它接受什么"原样喂回去。模型下一步照着改就行，
                     # 这才是失败之后真正能自愈的重试——以前喂回去的是一句
                     # TypeError，里面既没有正确参数名也没有字段说明
-                    ctx.emit(EventType.TOOL_ERROR, tool=name, call_id=call_id, error=str(e))
+                    await once(ctx, EventType.TOOL_ERROR, tool=name, call_id=call_id, error=str(e))
                     messages.append(ToolMessage(content=str(e), tool_call_id=call_id))
                     transcript.append({"tool": name, "args": args, "ok": False, "result": str(e)})
                     continue
                 if fix_note:
-                    ctx.emit(EventType.LOG, level="warn",
-                             message=f"工具 {name}：{fix_note}", code="tool_args_fixed")
+                    await once(ctx, EventType.LOG, level="warn",
+                               message=f"工具 {name}：{fix_note}", code="tool_args_fixed")
 
             if _needs_approval(ctx, tool_map[name], args):
-                ctx.emit(
-                    EventType.HUMAN_REQUESTED,
-                    mode="approve",
-                    tool=name,
-                    args=args,
-                    title=f"Agent 想调用工具 {name}",
-                )
-                decision = interrupt(
-                    {
-                        "kind": "tool_approval",
-                        "node_id": ctx.node.id,
-                        "tool": name,
-                        "args": args,
-                        "title": f"是否允许调用 {name}？",
-                    }
+                decision = await ask(
+                    ctx,
+                    {"kind": "tool_approval", "node_id": ctx.node.id, "tool": name, "args": args,
+                     "title": f"是否允许调用 {name}？"},
+                    mode="approve", tool=name, args=args, title=f"Agent 想调用工具 {name}",
                 )
                 verdict = read_decision(decision)
                 note = verdict.note
-                ctx.emit(EventType.HUMAN_RESOLVED, tool=name, approved=verdict.approved, note=note,
-                         actor=ctx.actor())
+                await once(ctx, EventType.HUMAN_RESOLVED, tool=name, approved=verdict.approved,
+                           note=note, actor=ctx.actor())
                 if not verdict.approved:
                     messages.append(
                         ToolMessage(
@@ -462,41 +547,10 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                 if verdict.args:
                     args = verdict.args
 
-            ctx.emit(EventType.TOOL_START, tool=name, args=args, call_id=call_id)
-            started = time.perf_counter()
-            try:
-                content = await tool_step(step, name, args)
-                ok = True
-            except Exception as e:  # noqa: BLE001 - 工具失败要喂回模型，让它自己纠错
-                content = f"工具执行失败：{describe_exception(e)}"
-                if isinstance(e, TypeError) and schema is not None:
-                    # 签名对不上还能走到这儿，说明 schema 和函数本身不一致（工具的 bug）。
-                    # 模型改不了这个，但把参数表摊开至少让它别在同一个地方反复试
-                    content += f"\n{describe_args(schema, args)}"
-                ok = False
-            elapsed = int((time.perf_counter() - started) * 1000)
-            snapshot_id: str | None = None
-            if ok:
-                from app.core.artifact_store import put_json
-
-                try:
-                    snapshot_id = await put_json(
-                        {"tool": name, "args": args, "result": content},
-                        kind="tool_snapshot", run_id=ctx.run.run_id, node_id=ctx.node.id,
-                    )
-                except Exception:  # noqa: BLE001
-                    snapshot_id = None
-            ctx.emit(
-                EventType.TOOL_END if ok else EventType.TOOL_ERROR,
-                tool=name,
-                call_id=call_id,
-                duration_ms=elapsed,
-                preview=content[:2000],
-                artifact=snapshot_id,
-            )
-            transcript.append(
-                {"tool": name, "args": args, "ok": ok, "duration_ms": elapsed, "result": content[:4000]}
-            )
+            outcome = await tool_step(step, name, args, call_id)
+            content = outcome["content"]
+            transcript.append({"tool": name, "args": args, "ok": outcome["ok"],
+                               "duration_ms": outcome["duration_ms"], "result": content[:4000]})
             messages.append(ToolMessage(content=content, tool_call_id=call_id))
 
         # 没跑的那些排在执行过的后面，保持模型原本的调用顺序
@@ -506,7 +560,7 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                 {"tool": call.get("name", ""), "args": call.get("args", {}) or {}, "skipped": True}
             )
     else:
-        # 步数用完了。走到这儿一定意味着最后那步**要求了工具**（不要工具会 break），
+        # 步数用完了：最后那步要么要求了工具，要么是纠正之后还没来得及答。
         # 也就是说模型从来没拿到过"说结论"的那一轮——它只是被掐断在半路。
         #
         # 所以先补上那一轮：不给工具，让它基于已经查到的东西收口。这比把中间
@@ -520,14 +574,23 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         )))
         try:
             response = await settle_step(messages)
-            usage = _usage_of(response, model_id)
-            for key in ("input_tokens", "output_tokens", "calls"):
-                total_usage[key] += usage[key]
-            total_usage["cost_usd"] = round(total_usage["cost_usd"] + usage["cost_usd"], 6)
+            _count(response)
             settled = message_text(response).strip()
         except Exception as e:  # noqa: BLE001 - 收尾失败不能把已有成果一起赔进去
-            ctx.emit(EventType.LOG, level="warn",
-                     message=f"收尾轮没跑成：{describe_exception(e)}", code="settle_failed")
+            await once(ctx, EventType.LOG, level="warn",
+                       message=f"收尾轮没跑成：{describe_exception(e)}", code="settle_failed")
+
+        if snippet := leaked_markup(settled):
+            if not any(isinstance(m, AIMessage) and getattr(m, "tool_calls", None) for m in messages):
+                # 从头到尾一次真调用都没有，步数全耗在写标记上：还是那个「调不了工具」
+                raise NodeError(ctx.node.id, TOOL_MARKUP_ERROR)
+            # 收尾轮拿的是没绑工具的模型，它还是写了一段调用标记：想接着查、没能收口。
+            # 这不是「节点没绑工具」（前面的步数里工具是真调过的），不能套 TOOL_MARKUP_ERROR
+            # 判失败、把已经查到的一起丢掉——按收尾轮没说出话处理，取它之前说过的话
+            await once(ctx, EventType.LOG, level="warn", code="tool_markup_leak",
+                       message=f"{markup_warning(snippet)}：步数用完后的收尾轮仍想调用工具，"
+                               "没能给出结论")
+            settled = ""
 
         if settled:
             final_text = settled
@@ -546,7 +609,8 @@ async def run_agent(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
             # 管道文案冒充结论，比明说"没跑完"糟糕得多。
             final_text = next(
                 (text for m in reversed(messages)
-                 if isinstance(m, AIMessage) and (text := message_text(m).strip())),
+                 if isinstance(m, AIMessage) and (text := message_text(m).strip())
+                 and not leaked_markup(text)),
                 "",
             )
             hint = (
diff --git a/backend/app/engine/nodes/multi.py b/backend/app/engine/nodes/multi.py
index 56894acb..786df515 100644
--- a/backend/app/engine/nodes/multi.py
+++ b/backend/app/engine/nodes/multi.py
@@ -10,12 +10,21 @@ from langgraph.errors import GraphRecursionError
 from langgraph.func import task
 
 from app.core.config import settings
+from app.core.errors import describe_exception, raw_detail
 from app.core.events import EventType
 from app.db.base import SessionLocal
 from app.db.models import Workflow
 from app.engine.context import NodeContext, NodeError
-from app.engine.errors import describe_exception
 from app.engine.state import GraphState, message_text, template_context
+from app.engine.toolcalls import (
+    TOOL_MARKUP_NUDGE,
+    ToolTimeout,
+    leaked_markup,
+    limit_fields,
+    limit_of,
+    markup_warning,
+    run_bounded,
+)
 from app.providers import catalog
 from app.providers.factory import ModelSpec, bind_tools_safely, get_chat_model
 from app.tools.registry import (
@@ -32,6 +41,10 @@ _MAX_DEPTH = 3
 #: 调度者在 llm.end 里的 agent 名。成员用各自的名字
 COORDINATOR = "调度者"
 
+#: 成员把工具调用写成文字、纠正之后还是这样时，交给调度者的那句话
+MEMBER_MARKUP_FAILED = ("模型输出了工具调用的原始标记，但没有真正调用工具，这一步什么都没查到"
+                        "（常见原因：这个成员没有绑定工具，或者模型、服务不支持工具调用）")
+
 
 # --------------------------------------------------------------------------
 # Supervisor：一个调度者 + 若干专家
@@ -52,6 +65,9 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     names = [a.get("name") or f"agent{i}" for i, a in enumerate(agents)]
     agent_map = {n: a for n, a in zip(names, agents)}
     max_rounds = min(int(ctx.cfg("max_rounds", 6) or 6), settings.max_agent_steps)
+    #: 轮数用完、调度者始终没判定完成时怎么办。fail：判失败；degrade：照样交付但标明降档。
+    #: 缺省 fail——成员的原话不是结论，把它当成功交出去比失败更糟
+    on_exhausted = "degrade" if ctx.cfg("on_exhausted") == "degrade" else "fail"
 
     goal = ctx.render_str(ctx.cfg("goal", "{{ last_message }}"), state)
     if not goal.strip():
@@ -115,11 +131,12 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         return {"input_tokens": i, "output_tokens": o,
                 "cost_usd": round(catalog.estimate_cost(model_id, i, o), 6)}
 
-    def _accumulate(one: dict[str, Any]) -> None:
-        usage_total["input_tokens"] += one["input_tokens"]
-        usage_total["output_tokens"] += one["output_tokens"]
-        usage_total["calls"] += 1
-        usage_total["cost_usd"] = round(usage_total["cost_usd"] + one["cost_usd"], 6)
+    def _accumulate(one: dict[str, Any], into: dict[str, Any] | None = None) -> None:
+        into = usage_total if into is None else into
+        into["input_tokens"] += one["input_tokens"]
+        into["output_tokens"] += one["output_tokens"]
+        into["calls"] += one.get("calls", 1)
+        into["cost_usd"] = round(into["cost_usd"] + one["cost_usd"], 6)
 
     def _report(who: str, model_id: str, one: dict[str, Any], t0: float) -> None:
         # 每次模型调用各发一条 llm.end，界面上的用量才能实时涨，而且分得清是谁花的。
@@ -127,24 +144,8 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         ctx.emit(EventType.LLM_END, agent=who, model=model_id,
                  duration_ms=int((time.perf_counter() - t0) * 1000), **one)
 
-    @task
-    async def route(round_no: int, progress: str) -> dict[str, Any]:
-        prompt = (
-            f"你是团队调度者。目标：\n{goal}\n\n"
-            f"可用成员：\n{roster}\n\n"
-            f"当前进展：\n{progress or '(还没有任何进展)'}\n\n"
-            "决定这一轮把什么任务交给谁，每个任务给一句明确的指令。\n\n"
-            f"**互不依赖的任务可以放在同一轮**（最多 {max_parallel} 个），它们会同时执行，"
-            "总耗时按最慢的那个算。判断依据只有一条：**后一个任务需不需要看到前一个的结果**。\n"
-            "  可以同时派：「查 A 产品的资料」和「查 B 产品的资料」——两边互不相干\n"
-            "  不能同时派：「查资料」和「根据资料写报告」——后者要等前者\n"
-            "  不能同时派：「写初稿」和「校对初稿」——同上\n\n"
-            "同时派出去的成员看到的是**同一份进展快照**，谁也看不见谁这一轮干了什么。"
-            "拿不准是否独立时就分两轮派，代价只是慢一点；派错了则是两个人基于同样的"
-            "旧信息重复劳动，而这在结果里很难看出来。\n\n"
-            "目标已经达成时，done 填 true、assignments 给空数组。"
-        )
-        t0 = time.perf_counter()
+    async def _decide(prompt: str, *, closing: bool = False) -> tuple[dict[str, Any], dict[str, Any]]:
+        """问调度者一次。返回 (决定, 这次调用的用量)。"""
         spent = {"input_tokens": 0, "output_tokens": 0, "cost_usd": 0.0}
         try:
             # include_raw：结构化结果之外把原始消息也要回来，用量在那条消息上。
@@ -161,19 +162,139 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
             if not isinstance(value, dict):
                 value = json.loads(message_text(value))
         except Exception:  # noqa: BLE001
-            # 不支持结构化输出的模型退回文本：从回复里认出一个成员名，按单人派
+            # 不支持结构化输出的模型退回文本：从回复里认出一个成员名，按单人派。
+            # 收尾判定时同理：回复里还点着哪个成员，就是还没完
             reply = await supervisor_model.ainvoke(prompt)
             spent = _usage(reply, sup_model_id)
             raw = message_text(reply)
             picked = next((n for n in names if n in raw), None)
-            value = ({"assignments": [{"agent": picked, "instruction": raw[:500]}]}
-                     if picked else {"assignments": [], "done": True, "reason": raw[:200]})
-        # 在 task 里发：节点重放时 task 结果取自 checkpoint，这条不会重复
+            if closing:
+                value = {"assignments": [], "done": picked is None, "reason": raw[:200]}
+            else:
+                value = ({"assignments": [{"agent": picked, "instruction": raw[:500]}]}
+                         if picked else {"assignments": [], "done": True, "reason": raw[:200]})
+        return (value if isinstance(value, dict) else {}), spent
+
+    def _batch_of(decision: dict[str, Any]) -> list[tuple[str, str]]:
+        # 只留认得出的成员，并按上限截断。模型偶尔会重复派同一个人或者编一个
+        # 不存在的名字——这两种在并发里都是纯浪费
+        batch: list[tuple[str, str]] = []
+        seen: set[str] = set()
+        for item in decision.get("assignments") or []:
+            name = str((item or {}).get("agent") or "")
+            if name in agent_map and name not in seen:
+                seen.add(name)
+                batch.append((name, str(item.get("instruction") or goal)))
+            if len(batch) >= max_parallel:
+                break
+        return batch
+
+    def _finished(round_no: int, reason: str, **extra: Any) -> None:
+        # agents / done 是结构化字段，界面照着它渲染。以前只有一句中文
+        # 消息串，解码层得拿正则去拆「调度 → X（理由）」——文案一改就散架
+        ctx.emit(EventType.LOG, level="info", round=round_no, agents=[], done=True,
+                 message="调度 → 结束协作" + (f"（{reason}）" if reason else ""), **extra)
+
+    # 调度者决策前后各一条事件（它常常占掉团队节点大半的时间，以前是黑盒），和派活的
+    # 那条日志一起都在 task 里发：「接着跑」一个失败的团队节点时整个节点重放，前几轮
+    # 的决定取自 checkpoint，这些事件不该在时间线上再出现一遍
+    @task
+    async def route(round_no: int, progress: str) -> dict[str, Any]:
+        ctx.emit(EventType.AGENT_ROUTE_START, round=round_no)
+        prompt = (
+            f"你是团队调度者。目标：\n{goal}\n\n"
+            f"可用成员：\n{roster}\n\n"
+            f"当前进展：\n{progress or '(还没有任何进展)'}\n\n"
+            "决定这一轮把什么任务交给谁，每个任务给一句明确的指令。\n\n"
+            f"**互不依赖的任务可以放在同一轮**（最多 {max_parallel} 个），它们会同时执行，"
+            "总耗时按最慢的那个算。判断依据只有一条：**后一个任务需不需要看到前一个的结果**。\n"
+            "  可以同时派：「查 A 产品的资料」和「查 B 产品的资料」——两边互不相干\n"
+            "  不能同时派：「查资料」和「根据资料写报告」——后者要等前者\n"
+            "  不能同时派：「写初稿」和「校对初稿」——同上\n\n"
+            "同时派出去的成员看到的是**同一份进展快照**，谁也看不见谁这一轮干了什么。"
+            "拿不准是否独立时就分两轮派，代价只是慢一点；派错了则是两个人基于同样的"
+            "旧信息重复劳动，而这在结果里很难看出来。\n\n"
+            "目标已经达成时，done 填 true、assignments 给空数组。"
+        )
+        t0 = time.perf_counter()
+        value, spent = await _decide(prompt)
         _report(COORDINATOR, sup_model_id, spent, t0)
+
+        batch = _batch_of(value)
+        finishing = bool(value.get("done")) or not batch
+        reason = str(value.get("reason", ""))
+        ctx.emit(EventType.AGENT_ROUTE_END, round=round_no,
+                 duration_ms=int((time.perf_counter() - t0) * 1000),
+                 agents=[] if finishing else [n for n, _ in batch],
+                 parallel=0 if finishing else len(batch), done=finishing, reason=reason)
+        if finishing:
+            _finished(round_no, reason)
+        else:
+            who = "、".join(n for n, _ in batch)
+            ctx.emit(
+                EventType.LOG, level="info", round=round_no, parallel=len(batch),
+                agents=[n for n, _ in batch], done=False, reason=reason,
+                message=(f"调度 → {who}" + (f"（{reason}）" if reason else "")
+                         + (f" · {len(batch)} 人同时进行" if len(batch) > 1 else "")),
+            )
         return {"decision": value, "usage": spent}
 
+    # 最后一轮派出去的成员（常常就是定稿的那个）交回来之后，调度者还没看过它的产出。
+    # 以前轮数一到就算用完：步数恰好等于最多轮数的正常流水线（查数 → 撰稿，2 轮）也会
+    # 被判成没完成。补这一次只判定、不派活的决定，它说完成了才算完成
     @task
-    async def work(round_no: int, name: str, instruction: str, progress: str) -> dict[str, Any]:
+    async def verdict(round_no: int, progress: str) -> dict[str, Any]:
+        ctx.emit(EventType.AGENT_ROUTE_START, round=round_no, closing=True)
+        prompt = (
+            f"你是团队调度者。目标：\n{goal}\n\n"
+            f"当前进展：\n{progress or '(还没有任何进展)'}\n\n"
+            f"轮数已经用完（{max_rounds} 轮），不能再派任何任务。只判断一件事：按上面的进展，"
+            "目标是不是已经达成、能不能把最后一个成员的产出作为结论交出去。\n"
+            "达成了 done 填 true；没达成 done 填 false，并在 reason 里说清还缺什么。"
+            "assignments 给空数组。"
+        )
+        t0 = time.perf_counter()
+        value, spent = await _decide(prompt, closing=True)
+        _report(COORDINATOR, sup_model_id, spent, t0)
+        done = value.get("done") is True
+        reason = str(value.get("reason", ""))
+        ctx.emit(EventType.AGENT_ROUTE_END, round=round_no,
+                 duration_ms=int((time.perf_counter() - t0) * 1000),
+                 agents=[], parallel=0, done=done, reason=reason, closing=True)
+        if done:
+            _finished(round_no, reason, closing=True)
+        return {"done": done, "reason": reason, "usage": spent}
+
+    # 成员的开始、结束两条事件也在 task 里发，理由同 route。失败也在 task 里收住、作为
+    # 结果缓存：重放时这一步照旧是失败，不会换一个结果。用量随结果带出来再记账——在
+    # task 里直接记进 usage_total 的话，重放取了缓存，这一笔就没了
+    @task
+    async def work(round_no: int, name: str, instruction: str, progress: str,
+                   parallel: int = 1) -> dict[str, Any]:
+        ctx.emit(EventType.AGENT_STEP_START, agent=name, instruction=instruction[:300],
+                 round=round_no, parallel=parallel)
+        tally = {"input_tokens": 0, "output_tokens": 0, "cost_usd": 0.0, "calls": 0}
+        t0 = time.perf_counter()
+        try:
+            out: dict[str, Any] = await _member(name, instruction, progress, tally)
+        except asyncio.CancelledError:
+            raise
+        except BaseException as exc:  # noqa: BLE001 - 一个专家挂了不该拖垮整轮
+            # 把失败当成它的产出交回调度者，让它决定改派还是收工
+            why = describe_exception(exc)
+            text = f"（{name} 执行失败：{why}）"
+            out = {"text": text, "tool_calls": [], "failed": True, "error": why}
+            ctx.emit(EventType.LOG, level="warn", round=round_no,
+                     message=f"{name} 这一轮失败了：{text}")
+        each_ms = int((time.perf_counter() - t0) * 1000)
+        # failed / error 让矩阵把这一格画成失败，而不是一个"完成"的格子里写着失败原因
+        failure = {"failed": True, "error": out.get("error") or ""} if out.get("failed") else {}
+        ctx.emit(EventType.AGENT_STEP_END, agent=name, duration_ms=each_ms,
+                 round=round_no, parallel=parallel, preview=out["text"][:500], **failure)
+        return {**out, "duration_ms": each_ms, "usage": tally}
+
+    async def _member(name: str, instruction: str, progress: str,
+                      tally: dict[str, Any]) -> dict[str, Any]:
         cfg = agent_map[name]
         async with SessionLocal() as session:
             model, model_id = await get_chat_model(
@@ -202,20 +323,37 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         calls: list[dict[str, Any]] = []
         # 和 agent 节点同一个硬顶：成员上配多少步都过不去 max_agent_steps
         max_steps = min(int(cfg.get("max_steps") or 4), settings.max_agent_steps)
+        nudged = False
         for _ in range(max_steps):
             t0 = time.perf_counter()
             reply = await bound.ainvoke(messages)
             spent = _usage(reply, model_id)
-            _accumulate(spent)
+            _accumulate(spent, tally)
             _report(name, model_id, spent, t0)
             messages.append(reply)
             tool_calls = getattr(reply, "tool_calls", None) or []
             if not tool_calls:
-                return {"text": message_text(reply), "tool_calls": calls}
+                text = message_text(reply)
+                snippet = leaked_markup(text)
+                if not snippet:
+                    return {"text": text, "tool_calls": calls}
+                # 把工具调用写成了文字：这一步什么都没查到。纠正一次，还这样就记为失败，
+                # 原因交给调度者——以前这段标记会被当成这个成员的结论交上去
+                if nudged:
+                    return {"text": f"（{name} 这一步失败：{MEMBER_MARKUP_FAILED}）",
+                            "tool_calls": calls, "failed": True, "error": MEMBER_MARKUP_FAILED}
+                nudged = True
+                ctx.emit(EventType.LOG, level="warn", code="tool_markup_leak",
+                         message=f"{markup_warning(snippet, name)}，已提醒它重试一次")
+                messages.append(HumanMessage(content=TOOL_MARKUP_NUDGE))
+                continue
             for call in tool_calls:
                 tname = call.get("name", "")
                 targs = call.get("args", {}) or {}
                 cid = call.get("id") or f"{name}-{tname}"
+                limit = None
+                failure: dict[str, Any] = {}
+                started = time.perf_counter()
                 if tname not in tool_map:
                     ctx.emit(EventType.TOOL_START, tool=tname, args=targs, agent=name, call_id=cid)
                     content = f"错误：没有名为 {tname} 的工具"
@@ -229,7 +367,9 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                         except ToolArgsError as e:
                             args_error = str(e)
                     # 纠正后的参数才是真正要执行的那份，tool.start 要发它
-                    ctx.emit(EventType.TOOL_START, tool=tname, args=targs, agent=name, call_id=cid)
+                    limit = limit_of(tool_map[tname], tname, targs)
+                    ctx.emit(EventType.TOOL_START, tool=tname, args=targs, agent=name, call_id=cid,
+                             **limit_fields(limit))
                     if fix_note:
                         ctx.emit(EventType.LOG, level="warn",
                                  message=f"工具 {tname}：{fix_note}", code="tool_args_fixed")
@@ -250,11 +390,17 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
                                  message=f"{name} 想调用 {tname}，需要人工确认，协作节点里不执行")
                     else:
                         try:
-                            raw = await tool_map[tname].ainvoke(targs)
+                            raw = await run_bounded(tool_map[tname].ainvoke(targs), limit, tname)
                             content = raw if isinstance(raw, str) else json.dumps(raw, ensure_ascii=False, default=str)
+                        except ToolTimeout as e:
+                            content = str(e)
+                            failure = {"error": content, "timed_out": True}
                         except Exception as e:  # noqa: BLE001
                             content = f"工具失败：{describe_exception(e)}"
-                ctx.emit(EventType.TOOL_END, tool=tname, agent=name, call_id=cid, preview=content[:1500])
+                            failure = {"error": content, "detail": raw_detail(e)}
+                ctx.emit(EventType.TOOL_ERROR if failure else EventType.TOOL_END, tool=tname,
+                         agent=name, call_id=cid, preview=content[:1500],
+                         duration_ms=int((time.perf_counter() - started) * 1000), **failure)
                 calls.append({"tool": tname, "args": targs, "result": content[:2000]})
                 messages.append(ToolMessage(content=content, tool_call_id=cid))
 
@@ -270,14 +416,25 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
             t0 = time.perf_counter()
             settled = await model.ainvoke(messages)
             spent = _usage(settled, model_id)
-            _accumulate(spent)
+            _accumulate(spent, tally)
             _report(name, model_id, spent, t0)
             text = message_text(settled).strip()
         except Exception as e:  # noqa: BLE001 - 收尾失败不能把已有的过程一起赔进去
             ctx.emit(EventType.LOG, level="warn", code="settle_failed",
                      message=f"{name} 的收尾轮没跑成：{describe_exception(e)}")
             text = next((t for m in reversed(messages)
-                         if isinstance(m, AIMessage) and (t := message_text(m).strip())), "")
+                         if isinstance(m, AIMessage) and (t := message_text(m).strip())
+                         and not leaked_markup(t)), "")
+        if snippet := leaked_markup(text):
+            if not calls:
+                return {"text": f"（{name} 这一步失败：{MEMBER_MARKUP_FAILED}）",
+                        "tool_calls": calls, "failed": True, "error": MEMBER_MARKUP_FAILED}
+            # 真调过工具，只是收尾轮还想接着查：取它之前说过的话，和 agent 节点一样
+            ctx.emit(EventType.LOG, level="warn", code="tool_markup_leak",
+                     message=f"{markup_warning(snippet, name)}：步数用完后的收尾轮仍想调用工具")
+            text = next((t for m in reversed(messages)
+                         if isinstance(m, AIMessage) and (t := message_text(m).strip())
+                         and not leaked_markup(t)), "")
         ctx.emit(EventType.LOG, level="warn", code="step_limit_settled",
                  message=f"{name} 用满了 {max_steps} 步，结论基于已经查到的部分")
         return {"text": text or f"（{name} 用满了 {max_steps} 步，没有给出结论）", "tool_calls": calls}
@@ -285,54 +442,26 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     progress_lines: list[str] = []
     final_text = ""
     rounds_meta: list[dict[str, Any]] = []
+    #: 调度者最后一轮给的理由，以及派过活的成员。轮数用完时报错要说清卡在哪、谁从没上过场
+    last_reason = ""
+    dispatched: set[str] = set()
+    finished = False
     for round_no in range(max_rounds):
         progress = "\n\n".join(progress_lines)
-        # 调度者决策前后各一条事件。它常常占掉团队节点大半的时间，以前是黑盒
-        ctx.emit(EventType.AGENT_ROUTE_START, round=round_no)
-        route_t0 = time.perf_counter()
         routed = await route(round_no, progress)
-        route_ms = int((time.perf_counter() - route_t0) * 1000)
         decision = routed.get("decision", routed) if isinstance(routed, dict) else {}
+        decision = decision if isinstance(decision, dict) else {}
         _accumulate(routed.get("usage") or _usage(None, sup_model_id))
         reason = str(decision.get("reason", ""))
+        last_reason = reason or last_reason
 
-        # 只留认得出的成员，并按上限截断。模型偶尔会重复派同一个人或者编一个
-        # 不存在的名字——这两种在并发里都是纯浪费
-        batch: list[tuple[str, str]] = []
-        seen: set[str] = set()
-        for item in decision.get("assignments") or []:
-            name = str((item or {}).get("agent") or "")
-            if name in agent_map and name not in seen:
-                seen.add(name)
-                batch.append((name, str(item.get("instruction") or goal)))
-            if len(batch) >= max_parallel:
-                break
-
-        finishing = bool(decision.get("done")) or not batch
-        ctx.emit(EventType.AGENT_ROUTE_END, round=round_no, duration_ms=route_ms,
-                 agents=[] if finishing else [n for n, _ in batch],
-                 parallel=0 if finishing else len(batch), done=finishing, reason=reason)
-
-        if finishing:
-            # agents / done 是结构化字段，界面照着它渲染。以前只有一句中文
-            # 消息串，解码层得拿正则去拆「调度 → X（理由）」——文案一改就散架
-            ctx.emit(EventType.LOG, level="info", round=round_no,
-                     agents=[], done=True,
-                     message="调度 → 结束协作" + (f"（{reason}）" if reason else ""))
+        batch = _batch_of(decision)
+        if bool(decision.get("done")) or not batch:
             final_text = progress_lines[-1].split("】", 1)[-1] if progress_lines else ""
+            finished = True
             break
 
-        who = "、".join(n for n, _ in batch)
-        ctx.emit(
-            EventType.LOG, level="info", round=round_no, parallel=len(batch),
-            agents=[n for n, _ in batch], done=False, reason=reason,
-            message=(f"调度 → {who}" + (f"（{reason}）" if reason else "")
-                     + (f" · {len(batch)} 人同时进行" if len(batch) > 1 else "")),
-        )
-
-        for name, instruction in batch:
-            ctx.emit(EventType.AGENT_STEP_START, agent=name, instruction=instruction[:300],
-                     round=round_no, parallel=len(batch))
+        dispatched.update(n for n, _ in batch)
 
         # 并发执行。它们拿到的是**同一份** progress 快照——这正是"任务必须
         # 互不依赖"的技术含义，也是上面提示词里那几条反例的由来。
@@ -341,32 +470,23 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         # 时间"，那个数必须是量出来的。按 N×墙钟 推算等于假设每个人都跑满了
         # 最慢那条，而实际上快的那个可能只花了三分之一。
         #
-        # 结束事件也在这里一完成就发，不等整轮 gather：以前先做完的成员要一直
-        # 显示"进行中"，直到最慢的那个做完——矩阵答不了"谁还在跑"
-        async def _timed(name: str, instruction: str, parallel: int) -> tuple[str, Any, int]:
-            t0 = time.perf_counter()
-            try:
-                out: Any = await work(round_no, name, instruction, progress)
-            except asyncio.CancelledError:
-                raise
-            except BaseException as exc:  # noqa: BLE001 - 一个专家挂了不该拖垮整轮
-                # 把失败当成它的产出交回调度者，让它决定改派还是收工
-                text = f"（{name} 执行失败：{describe_exception(exc)}）"
-                out = {"text": text, "tool_calls": []}
-                ctx.emit(EventType.LOG, level="warn", round=round_no,
-                         message=f"{name} 这一轮失败了：{text}")
-            each_ms = int((time.perf_counter() - t0) * 1000)
-            ctx.emit(EventType.AGENT_STEP_END, agent=name, duration_ms=each_ms,
-                     round=round_no, parallel=parallel, preview=out["text"][:500])
-            return name, out, each_ms
+        # 结束事件也在各自的 task 里一完成就发，不等整轮 gather：以前先做完的成员要
+        # 一直显示"进行中"，直到最慢的那个做完——矩阵答不了"谁还在跑"
+        async def _one(name: str, instruction: str, parallel: int) -> dict[str, Any]:
+            return await work(round_no, name, instruction, progress, parallel)
 
         started = time.perf_counter()
-        results = await asyncio.gather(*(_timed(n, i, len(batch)) for n, i in batch))
+        results = await asyncio.gather(*(_one(n, i, len(batch)) for n, i in batch))
         wall_ms = int((time.perf_counter() - started) * 1000)
 
         # 进展仍按派活顺序拼：它是下一轮调度者读的输入，语义不随谁先回来而变
         sum_ms = 0
-        for (name, instruction), (_, outcome, each_ms) in zip(batch, results):
+        for (name, instruction), result in zip(batch, results):
+            outcome = dict(result)
+            spent = outcome.pop("usage", None)
+            if spent:
+                _accumulate(spent)
+            each_ms = int(outcome.pop("duration_ms", 0) or 0)
             sum_ms += each_ms
             progress_lines.append(f"【{name}】{outcome['text']}")
             transcript.append(
@@ -380,6 +500,32 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
             "parallel": len(batch), "wall_ms": wall_ms, "sum_ms": sum_ms,
         })
 
+    if not finished and progress_lines:
+        judged = await verdict(max_rounds, "\n\n".join(progress_lines))
+        _accumulate(judged.get("usage") or _usage(None, sup_model_id))
+        last_reason = str(judged.get("reason") or "") or last_reason
+        if judged.get("done"):
+            final_text = progress_lines[-1].split("】", 1)[-1]
+            finished = True
+
+    exhausted: dict[str, Any] = {}
+    if not finished:
+        # 轮数用完，调度者一次都没说「完成」。这时手上只有最后一个成员的原话——
+        # 以前它就被当作团队的结论交了出去：真实运行里是一段没执行的工具调用标记，
+        # 而负责定稿的成员一次都没被派到
+        never = [n for n in names if n not in dispatched]
+        summary = (f"协作团队用完 {max_rounds} 轮仍未完成："
+                   f"{last_reason or '调度者没有给出理由'}")
+        if never:
+            summary += f"。一次都没被派到的成员：{'、'.join(never)}"
+        if on_exhausted == "fail":
+            raise NodeError(ctx.node.id, f"{summary}。先看成员有没有绑定要用的工具，再调大「最多"
+                                         "轮数」；也可以把「用完轮数时」改成降档交付")
+        exhausted = {"exhausted": True, "exhausted_reason": last_reason,
+                     "never_dispatched": never}
+        ctx.emit(EventType.LOG, level="warn", code="team_exhausted",
+                 message=f"{summary}。按降档交付：成果是成员最后的原话，不是调度者认可的结论")
+
     usage_total["total_tokens"] = usage_total["input_tokens"] + usage_total["output_tokens"]
     # 并行省下的时间：各轮"串行本该花的"减去"实际花的"。只有并发过才有差值
     saved_ms = sum(r["sum_ms"] - r["wall_ms"] for r in rounds_meta)
@@ -391,6 +537,7 @@ async def run_supervisor(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         "agents": names,
         "schedule": rounds_meta,
         "parallel_saved_ms": saved_ms,
+        **exhausted,
     }
     updates: dict[str, Any] = {
         "nodes": {ctx.node.id: result},
diff --git a/backend/app/engine/nodes/tools.py b/backend/app/engine/nodes/tools.py
index 10690ead..2950aa04 100644
--- a/backend/app/engine/nodes/tools.py
+++ b/backend/app/engine/nodes/tools.py
@@ -4,18 +4,19 @@ import json
 import time
 from typing import Any
 
-from langgraph.types import interrupt
-
+from app.core.errors import describe_exception, raw_detail
 from app.core.events import EventType
 from app.db.base import SessionLocal
 from app.engine.approval import read_decision
 from app.engine.context import NodeContext, NodeError
-from app.engine.errors import describe_exception, raw_detail
+from app.engine.replay import ask, once
 from app.engine.state import GraphState
+from app.engine.toolcalls import ToolTimeout, limit_fields, limit_of, run_bounded
 from app.sandbox.base import SandboxLimits
 from app.sandbox.manager import sandbox_manager
 from app.tools.registry import (
     ToolArgsError,
+    ToolBuildError,
     ToolContext,
     build_tools,
     call_is_dangerous,
@@ -34,16 +35,20 @@ def _tool_ctx(ctx: NodeContext) -> ToolContext:
     )
 
 
-async def _is_dangerous(name: str, args: dict[str, Any], ctx: NodeContext) -> bool:
-    """内置工具看 ToolSpec；数据源这类动态工具得先建出来，才问得到这一次危不危险。
+async def _dynamic_tool(name: str, ctx: NodeContext) -> Any:
+    """数据源、MCP、自定义这类动态工具得先建出来，才问得到它危不危险、时限多长。
 
-    审批通过后节点会整个重放，这里会再算一遍——所以它必须只取决于 name 和 args。
+    内置工具的这两件事看 ToolSpec 和参数就够，不用建。
     """
     if get_spec(name) is not None:
-        return call_is_dangerous(None, name, args)
+        return None
     async with SessionLocal() as session:
-        tools = await build_tools([name], _tool_ctx(ctx), session=session)
-    return call_is_dangerous(tools[0] if tools else None, name, args)
+        try:
+            tools = await build_tools([name], _tool_ctx(ctx), session=session)
+        except ToolBuildError as e:
+            # 工具自己的配置写坏了：说清是哪个、去哪里改，不再往下走到 call_tool 里炸
+            raise NodeError(ctx.node.id, str(e)) from e
+    return tools[0] if tools else None
 
 
 async def run_tool(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
@@ -56,24 +61,27 @@ async def run_tool(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     if not isinstance(args, dict):
         raise NodeError(ctx.node.id, "工具参数必须是对象")
 
+    # 审批通过后节点会整个重放、再算一遍要不要问人，所以这里只能取决于 name 和 args。
     # 节点没配时取全局设置（「危险工具默认需要人工确认」），见 NodeContext.approval_mode
+    tool = await _dynamic_tool(name, ctx)
     approval = ctx.approval_mode()
-    if approval == "always" or (approval == "dangerous" and await _is_dangerous(name, args, ctx)):
-        ctx.emit(EventType.HUMAN_REQUESTED, mode="approve", tool=name, args=args,
-                 title=f"是否允许调用 {name}？")
-        decision = read_decision(interrupt(
+    if approval == "always" or (approval == "dangerous" and call_is_dangerous(tool, name, args)):
+        decision = read_decision(await ask(
+            ctx,
             {"kind": "tool_approval", "node_id": ctx.node.id, "tool": name, "args": args,
-             "title": f"是否允许调用 {name}？"}
+             "title": f"是否允许调用 {name}？"},
+            mode="approve", tool=name, args=args, title=f"是否允许调用 {name}？",
         ))
         if decision.args is not None:
             args = decision.args
-        ctx.emit(EventType.HUMAN_RESOLVED, tool=name, approved=decision.approved,
-                 note=decision.note, actor=ctx.actor())
+        await once(ctx, EventType.HUMAN_RESOLVED, tool=name, approved=decision.approved,
+                   note=decision.note, actor=ctx.actor())
         if not decision.approved:
             raise NodeError(ctx.node.id, f"用户拒绝执行工具 {name}"
                             + (f"：{decision.note}" if decision.note else ""))
 
-    ctx.emit(EventType.TOOL_START, tool=name, args=args)
+    limit = limit_of(tool, name, args)
+    ctx.emit(EventType.TOOL_START, tool=name, args=args, **limit_fields(limit))
     started = time.perf_counter()
 
     def _fixed(note: str) -> None:
@@ -82,9 +90,20 @@ async def run_tool(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
         ctx.emit(EventType.LOG, level="warn",
                  message=f"工具 {name}：{note}。请到节点里改正。", code="tool_args_fixed")
 
-    try:
+    async def _call() -> Any:
         async with SessionLocal() as session:
-            result = await call_tool(name, args, _tool_ctx(ctx), session=session, on_fix=_fixed)
+            return await call_tool(name, args, _tool_ctx(ctx), session=session, on_fix=_fixed)
+
+    try:
+        result = await run_bounded(_call(), limit, name)
+    except ToolTimeout as e:
+        # 到点就收回控制权，驱动的收尾在后台做完。报错里写的是实际等了多久
+        elapsed = int((time.perf_counter() - started) * 1000)
+        ctx.emit(EventType.TOOL_ERROR, tool=name, error=str(e), timed_out=True, duration_ms=elapsed)
+        if ctx.cfg("fail_fast", True):
+            raise NodeError(ctx.node.id, f"{e}。数据量大就在参数里缩小范围；对方偶尔卡住的话，"
+                                         "稍后「接着跑」即可") from e
+        result = {"error": str(e), "timed_out": True}
     except KeyError as e:
         # str(KeyError) 是带引号的 repr，直接拼会多出一对引号
         reason = e.args[0] if e.args else f"找不到工具 {name!r}"
@@ -144,16 +163,16 @@ async def run_code(state: GraphState, ctx: NodeContext) -> dict[str, Any]:
     )
 
     if ctx.cfg("approval", "never") == "always":
-        ctx.emit(EventType.HUMAN_REQUESTED, mode="approve", title="是否执行这段代码？",
-                 code=code[:4000], language=language)
-        decision = read_decision(interrupt(
+        decision = read_decision(await ask(
+            ctx,
             {"kind": "code_approval", "node_id": ctx.node.id, "code": code,
-             "language": language, "title": "是否执行这段代码？"}
+             "language": language, "title": "是否执行这段代码？"},
+            mode="approve", title="是否执行这段代码？", code=code[:4000], language=language,
         ))
         if decision.code:
             code = decision.code  # 允许人工改完再跑
-        ctx.emit(EventType.HUMAN_RESOLVED, approved=decision.approved, note=decision.note,
-                 actor=ctx.actor())
+        await once(ctx, EventType.HUMAN_RESOLVED, approved=decision.approved, note=decision.note,
+                   actor=ctx.actor())
         if not decision.approved:
             raise NodeError(ctx.node.id, "用户拒绝执行代码"
                             + (f"：{decision.note}" if decision.note else ""))
diff --git a/backend/app/engine/replay.py b/backend/app/engine/replay.py
new file mode 100644
index 00000000..46e0895c
--- /dev/null
+++ b/backend/app/engine/replay.py
@@ -0,0 +1,71 @@
+"""节点重放时，已经发生过的事不在轨迹里再发生一次。
+
+LangGraph 恢复一个停在 interrupt 上的节点，是把节点函数从头再跑一遍：前面几次
+interrupt() 按顺序直接返回已经给过的答复，@task 包住的调用直接取 checkpoint 里的
+结果。执行层面不会重复——agent 节点的模型调用、工具调用都在 task 里，副作用只发生
+一次。可写在 task 外面的 ctx.emit 每重放一次就再发一遍：运行 fac480ff 的轨迹里，
+同一个 call_id 的 python_exec 有两对 tool.start / tool.end，审批请求也问了两回，
+签批人还按最后一次恢复的人记。看轨迹的人只能照字面理解成「执行了两次」。
+「接着跑」一个失败的节点是同一回事。
+
+所以要落进轨迹、又写在 task 外面的事，经这里发：它本身就是一次 task，第一次真正
+走到这里时发出，重放时结果取自 checkpoint、不再发。
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from langgraph.config import get_config
+from langgraph.func import task
+from langgraph.types import interrupt
+
+from app.core.events import EventType
+from app.engine.context import NodeContext
+
+#: 重放协议的版本，记在每个 checkpoint 的 metadata 里。
+#:
+#: LangGraph 认 task 的缓存靠「函数名 + 节点里第几次调用」。这一版多了 once / ask 的
+#: 记录 task，agent 的 tool_step 也换了位置和返回值：升级前停下的断点照新代码重放，
+#: 节点里已经执行过的工具、模型调用对不上旧的位置，会再执行一次（副作用翻倍），缓存
+#: 下来的旧返回值还可能直接对不上形状。恢复前先看版本，对不上又有这种风险就拒绝
+#: （见 runner 的 _stale_replay）。以后再改节点里 task 的调用顺序，把它加一
+PROTOCOL = 2
+PROTOCOL_KEY = "agentlab_replay"
+
+
+def protocol_of(metadata: Any) -> int:
+    """checkpoint 是按哪一版重放协议写的。加这个标记之前的都算 1。"""
+    value = (metadata or {}).get(PROTOCOL_KEY) if isinstance(metadata, dict) else None
+    return int(value) if isinstance(value, int) else 1
+
+
+def _in_graph() -> bool:
+    try:
+        get_config()
+    except RuntimeError:        # 不在图执行上下文里（单独调用执行器的测试）
+        return False
+    return True
+
+
+async def once(ctx: NodeContext, event_type: EventType | str, **data: Any) -> None:
+    """发一条事件，节点重放时不再发。"""
+    if not _in_graph():
+        ctx.emit(event_type, **data)
+        return
+
+    @task
+    async def record(kind: str) -> bool:
+        ctx.emit(kind, **data)
+        return True
+
+    await record(str(event_type))
+
+
+async def ask(ctx: NodeContext, payload: dict[str, Any], **request: Any) -> Any:
+    """请人审批：human.requested 只在第一次走到这里时发，然后停下等答复。
+
+    返回答复。答复读完之后由调用方用 once() 发 human.resolved——那一条也只该在
+    答复真正到达的那次执行里出现。
+    """
+    await once(ctx, EventType.HUMAN_REQUESTED, **request)
+    return interrupt(payload)
diff --git a/backend/app/engine/review.py b/backend/app/engine/review.py
index 0d318bc1..dc6b5fb7 100644
--- a/backend/app/engine/review.py
+++ b/backend/app/engine/review.py
@@ -7,6 +7,7 @@ from typing import Any
 
 from app.core.events import EventType
 from app.engine.issuance import extract_numbers, trace_numbers
+from app.engine.toolcalls import leaked_markup
 
 # --------------------------------------------------------------------------
 # 跑完之后的复核层。
@@ -70,6 +71,13 @@ WARN_CODES: dict[str, tuple[str, str]] = {
     "validate_retry": ("validate_retry", DEGRADED),
     "sandbox_reset": ("sandbox_reset", DEGRADED),
     "retrieve_degraded": ("retrieve_degraded", DEGRADED),
+    # 模型把工具调用写成了文字。纠正一次好了的，答案是真查过的，只记缺口；
+    # 没好的那次节点已经判失败，node_failed 会按 BROKEN 算
+    "tool_markup_leak": ("tool_markup_leak", DEGRADED),
+    # 协作团队用完轮数、按降档交付：交来的是成员原话，不是调度者认可的结论
+    "team_exhausted": ("team_exhausted", BROKEN),
+    # 校验节点的修复编出了原文没有的值，这次修复被作废
+    "repair_invented": ("repair_invented", DEGRADED),
 }
 
 # 这些 kind 重跑一次大概率能好：原因说得清，且不是「问题本身没问明白」。
@@ -178,6 +186,9 @@ def scan(events: Iterable[Any], output: Mapping[str, Any] | None = None) -> list
         add("empty_output", "这次运行没有产出任何成果内容", BROKEN)
     elif any(mark in text for mark in _PLACEHOLDER_MARKS):
         add("placeholder_output", "交出来的是一句内部流程说明，不是对问题的回答", BROKEN)
+    elif leaked_markup(text):
+        # 老运行、或者绕过了节点检查的路径：成果本身就是一段没执行的工具调用标记
+        add("markup_output", "交出来的是一段没有执行的工具调用标记，不是对问题的回答", BROKEN)
 
     return signals
 
diff --git a/backend/app/engine/runner.py b/backend/app/engine/runner.py
index 1af49c1f..bb8487e4 100644
--- a/backend/app/engine/runner.py
+++ b/backend/app/engine/runner.py
@@ -5,6 +5,7 @@ import contextlib
 import json
 import logging
 import time
+from collections.abc import Callable
 from datetime import datetime, timezone
 from typing import Any
 
@@ -15,13 +16,14 @@ from sqlalchemy import select, update
 
 from app.core.bus import bus
 from app.core.config import settings
+from app.core.errors import describe_exception, raw_detail
 from app.core.events import EventType, RunEventModel
 from app.db.base import SessionLocal
 from app.db.models import Approval, Run, RunEvent, Workflow
 from app.engine.compiler import compile_graph, initial_state
 from app.engine.context import NodeError, RunContext
-from app.engine.errors import describe_exception, raw_detail
-from app.engine.schema import GraphSpec, loop_steps, topology_of, validate_graph
+from app.engine.replay import PROTOCOL, PROTOCOL_KEY, protocol_of
+from app.engine.schema import GraphSpec, NodeType, loop_steps, topology_of, validate_graph
 
 logger = logging.getLogger(__name__)
 
@@ -42,6 +44,8 @@ class RunManager:
         self._closing = False
         #: 已经跑完、正在落状态和封存的运行。关停不去打断它们
         self._finalizing: set[str] = set()
+        #: 谁停的：取消执行任务时记下，run.cancelled 和关掉的审批上写得出人
+        self._stopped_by: dict[str, str | None] = {}
 
     # ---------------- 生命周期 ----------------
 
@@ -111,16 +115,7 @@ class RunManager:
         persist: bool = True,
         ts: float | None = None,
     ) -> None:
-        event = RunEventModel(
-            run_id=run_id,
-            seq=bus.next_seq(run_id),
-            type=EventType(str(event_type)),
-            node_id=node_id,
-            data=data or {},
-            # 节点里发出的事件带着它发生的时刻。以前一律取转发时刻：并行的成员
-            # 先做完的那条也要排到整轮结束才被转发，时间线上的耗时就全错了
-            **({"ts": ts} if ts else {}),
-        )
+        event = self._event(run_id, event_type, node_id=node_id, data=data, ts=ts)
         # 先落库，再广播。顺序反过来会漏事件，而且是结构性的漏：
         #
         # 订阅者的完整性靠"读历史 + 接实时"两段拼起来。它先订阅、再读历史，
@@ -133,22 +128,30 @@ class RunManager:
         # 一半几率就这么没了——界面表现为某个节点永远在转圈。
         if persist and event.type not in _EPHEMERAL:
             async with SessionLocal() as session:
-                session.add(
-                    RunEvent(
-                        run_id=run_id,
-                        seq=event.seq,
-                        type=str(event.type),
-                        node_id=event.node_id,
-                        ts=event.ts,
-                        data=event.data,
-                    )
-                )
-                await session.execute(
-                    update(Run).where(Run.id == run_id).values(last_seq=event.seq)
-                )
+                await _stage(session, event)
                 await session.commit()
         await bus.publish(event)
 
+    @staticmethod
+    def _event(
+        run_id: str,
+        event_type: EventType | str,
+        *,
+        node_id: str | None = None,
+        data: dict[str, Any] | None = None,
+        ts: float | None = None,
+    ) -> RunEventModel:
+        return RunEventModel(
+            run_id=run_id,
+            seq=bus.next_seq(run_id),
+            type=EventType(str(event_type)),
+            node_id=node_id,
+            data=data or {},
+            # 节点里发出的事件带着它发生的时刻。以前一律取转发时刻：并行的成员
+            # 先做完的那条也要排到整轮结束才被转发，时间线上的耗时就全错了
+            **({"ts": ts} if ts else {}),
+        )
+
     async def note(
         self, run_id: str, event_type: EventType | str, *, node_id: str | None = None,
         **data: Any,
@@ -256,6 +259,11 @@ class RunManager:
                 "这次运行没有可恢复的断点（很可能重启前还没真正开始跑）。"
                 "请重新发起一次运行，而不是恢复——继续下去只会用默认值跑出一份假结果。"
             )
+        if stale := await _stale_replay(run_id, spec, snapshot):
+            raise ValueError(
+                f"这次运行是升级前停在「{stale}」上的，引擎记录断点的方式已经变了：现在恢复，"
+                f"「{stale}」里已经执行过的工具会再执行一次。请放弃这次运行，重新发起"
+            )
 
         answers: dict[str, Any] = {}
         async with SessionLocal() as session:
@@ -283,14 +291,21 @@ class RunManager:
 
             now = datetime.now(timezone.utc)
             if target is not None:
-                target.status = "answered"  # 已回复，但还没提交给引擎
                 # 存全文，不能用 _safe 截：多条审批并存时，交给引擎的就是这一份
                 # （见下面 answers）。截过的版本会把人工改过的长稿砍掉一截再送进节点
                 full = json.loads(json.dumps(response, ensure_ascii=False, default=str))
-                target.response = full if isinstance(full, dict) else {"value": full}
-                target.resolved_at = now
-                if actor:
-                    target.resolved_by = actor
+                # 条件更新：上面读到它还是 pending，到这里之间可能已经被放弃运行关掉
+                # （或者另一个人先批了）。无条件写回去，会把关掉的审批又改成已回复
+                marked = await session.execute(
+                    update(Approval)
+                    .where(Approval.id == target.id, Approval.status == "pending")
+                    .values(status="answered",  # 已回复，但还没提交给引擎
+                            response=full if isinstance(full, dict) else {"value": full},
+                            resolved_at=now, **({"resolved_by": actor} if actor else {}))
+                )
+                if marked.rowcount != 1:
+                    await session.rollback()
+                    raise ValueError("这条审批已经处理过了，或者这次运行已经放弃了。刷新看看最新状态")
                 await session.commit()
 
             # 凑齐没有？引擎还在等的每一个 interrupt 都得有答案
@@ -299,7 +314,7 @@ class RunManager:
                     select(Approval).where(
                         Approval.run_id == run_id,
                         Approval.status.in_(["answered", "pending"]),
-                    )
+                    ).execution_options(populate_existing=True)
                 )
             ).scalars())
             by_iid = {a.interrupt_id: a for a in answered if a.interrupt_id}
@@ -321,19 +336,26 @@ class RunManager:
                 # 还差人没回。保持 interrupted，把已回复的那条留在 answered 上等齐
                 await session.commit()
                 run = await session.get(Run, run_id)
+                if run.status != "interrupted":
+                    # 审批没了是因为运行在这期间被放弃了：不能回一个「已记下」
+                    raise ValueError(_cannot_resume(run.status))
                 return run
 
             # 齐了：正式落 resolved，然后驱动引擎。谁批的跟着交给节点，
             # human.resolved 里才写得出签批人
-            actors: dict[str, str | None] = {}
-            for rec in answered:
-                if rec.status == "answered":
-                    rec.status = "resolved"
-                    actors[rec.node_id] = rec.resolved_by
+            ready = [rec for rec in answered if rec.status == "answered"]
+            actors: dict[str, str | None] = {rec.node_id: rec.resolved_by for rec in ready}
+            # 回到 running 也用条件更新占住：从上面读状态到这里隔了好几次 await，
+            # 放弃运行可能正好在这中间把它收成了 cancelled（已经封存、发过 run.cancelled）。
+            # 无条件写 running，一次取消了的运行就又被拉起来跑了
+            await _claim(session, run_id, ("interrupted",), _cannot_resume)
+            await session.execute(
+                update(Approval)
+                .where(Approval.id.in_([rec.id for rec in ready]), Approval.status == "answered")
+                .values(status="resolved")
+            )
             run = await session.get(Run, run_id)
             bus.set_seq(run_id, run.last_seq)
-            run.status = "running"
-            run.error = None
             await session.commit()
             await session.refresh(run)
 
@@ -356,7 +378,7 @@ class RunManager:
         ))
         self._tasks[run_id] = asyncio.create_task(
             self._drive(run_id, spec, command, workflow_id=workflow_id, **carried,
-                        resumed=[str(n) for n in (getattr(snapshot, "next", None) or ())],
+                        resumed=sorted(_replayed(snapshot)),
                         actors=actors)
         )
         return run
@@ -389,6 +411,7 @@ class RunManager:
             )).first() is not None
             if not (run.status == "failed" or (run.status == "interrupted" and not has_pending)):
                 raise ValueError(_cannot_continue(run.status, has_pending))
+            observed = run.status
             spec = GraphSpec.model_validate(run.graph)
             workflow_id = run.workflow_id
             carried = _carried(run)
@@ -419,17 +442,22 @@ class RunManager:
                 "这次运行没有留下可以接着跑的断点（多半是还没跑到第一个节点就挂了）。"
                 "请重新发起一次运行——继续下去只会从头跑一遍，还看不出来。"
             )
+        if stale := await _stale_replay(run_id, spec, snapshot):
+            raise ValueError(
+                f"这次运行是升级前停在「{stale}」上的，引擎记录断点的方式已经变了：现在接着跑，"
+                f"「{stale}」里已经执行过的工具会再执行一次。请重新发起一次运行"
+            )
 
         done = [n for n in (snapshot.values or {}).get("nodes", {}) if n not in pending]
         async with SessionLocal() as session:
+            # 和 resume 一样用条件更新占住：读状态之后，放弃运行、或者另一次接着跑
+            # 可能已经先动了它
+            await _claim(session, run_id, (observed,),
+                              lambda status: _cannot_continue(status, False),
+                              **({"graph": spec.model_dump(mode="json")} if graph is not None else {}),
+                              **({"started_by": actor} if actor else {}))
             run = await session.get(Run, run_id)
             bus.set_seq(run_id, run.last_seq)
-            run.status = "running"
-            run.error = None
-            if graph is not None:
-                run.graph = spec.model_dump(mode="json")
-            if actor:
-                run.started_by = actor
             await session.commit()
             await session.refresh(run)
 
@@ -450,12 +478,65 @@ class RunManager:
         )
         return run
 
-    async def cancel(self, run_id: str) -> bool:
+    async def cancel(self, run_id: str, *, actor: str | None = None) -> str | None:
+        """停止一次运行。返回 "stopping"（执行任务已取消，终态由它自己收尾）、
+        "cancelled"（停在断点上的，这里直接收成终态），或者 None（已经是终态、或不存在）。
+
+        停在断点上的运行——等审批的、服务重启挂起的——手上没有执行任务。以前这里只会
+        去取消任务，于是它们一律「不在执行中」：待审批的那张卡只能批了它、让它跑完。
+        """
+        if run_id in self._finalizing:
+            # 执行任务已经跑完、正在落状态——刚发出 run.interrupted、还在写 interrupted
+            # 的那一刻，界面上已经给出了「放弃这次运行」。这时取消任务会把收尾从中间
+            # 打断：状态停在 running、审批还挂着、任务却没了，再点一次只剩 409。
+            # 等它落完，再按落下的状态处理
+            await self.wait_idle(run_id, timeout=30.0)
+            if run_id in self._finalizing:      # 收尾卡住了（库被锁着）：也不去打断它
+                return None
         task = self._tasks.get(run_id)
         if task and not task.done():
+            self._stopped_by[run_id] = actor
             task.cancel()
-            return True
-        return False
+            return "stopping"
+        return "cancelled" if await self._abandon(run_id, actor) else None
+
+    async def _abandon(self, run_id: str, actor: str | None) -> bool:
+        """把停在断点上的运行收成 cancelled：关掉待审批、发 run.cancelled、封存。"""
+        now = datetime.now(timezone.utc)
+        async with SessionLocal() as session:
+            # 条件更新占住这次收尾：同一时刻有人批了它（resume 把它改回 running），
+            # 或者另一个取消先到了，这里就什么都不做
+            claimed = await session.execute(
+                update(Run).where(Run.id == run_id, Run.status == "interrupted")
+                .values(status="cancelled", finished_at=now)
+            )
+            if claimed.rowcount != 1:
+                await session.rollback()
+                return False
+            closed = await _close_approvals(session, run_id, actor, now)
+            run = await session.get(Run, run_id)
+            timing = await _timing(session, run, 0, now)
+            run.usage = {**(run.usage or {}), "duration_ms": timing["active_ms"], **timing}
+            run.error = "用户取消：在等审批时放弃了这次运行" if closed else "用户取消：挂起期间放弃了这次运行"
+            bus.set_seq(run_id, run.last_seq or 0)
+            # 和状态同一个事务提交，理由同 _finalize
+            event = self._event(run_id, EventType.RUN_CANCELLED, data={
+                "timing": timing, "actor": actor,
+                "message": f"放弃了这次运行，{closed} 条待审批一并关闭" if closed
+                           else "放弃了这次挂起的运行",
+            })
+            await _stage(session, event, run)
+            await session.commit()
+
+        await bus.publish(event)
+        await self._seal(run_id)
+        # 等审批时在线的连接没有关（它还在等恢复），这里让它收到终态再结束
+        await bus.close(run_id)
+        with contextlib.suppress(Exception):
+            from app.sandbox.manager import sandbox_manager
+
+            await sandbox_manager.cleanup(run_id)
+        return True
 
     def is_active(self, run_id: str) -> bool:
         task = self._tasks.get(run_id)
@@ -512,7 +593,9 @@ class RunManager:
                           # 实际生效的运行参数进事件流，也就进了封存清单：
                           # 正式运行查的是哪个库、审批默认是什么，事后可复核
                           "memory_scope": memory_scope, "collection": collection,
-                          "approval_default": approval_default},
+                          "approval_default": approval_default,
+                          # 这一段是按哪一版重放协议跑的，恢复时据此认出升级前做下的工作
+                          "replay_protocol": PROTOCOL},
                 )
 
                 run_ctx = RunContext(
@@ -531,6 +614,8 @@ class RunManager:
                 config = {
                     "configurable": {"thread_id": run_id},
                     "recursion_limit": settings.max_graph_steps + extra_steps,
+                    # 进每个 checkpoint 的 metadata：恢复时据此认出旧版引擎停下的断点
+                    "metadata": {PROTOCOL_KEY: PROTOCOL},
                 }
 
                 interrupted = False
@@ -569,7 +654,7 @@ class RunManager:
                 else:
                     status = "cancelled"
                     error = "用户取消"
-                    terminal = (EventType.RUN_CANCELLED, {})
+                    terminal = (EventType.RUN_CANCELLED, {"actor": self._stopped_by.pop(run_id, None)})
                 raise
             except TimeoutError as e:
                 status = "failed"
@@ -611,6 +696,7 @@ class RunManager:
                     # gather 在别的事件循环里炸开
                     self._finalizing.discard(run_id)
                     self._tasks.pop(run_id, None)
+                    self._stopped_by.pop(run_id, None)
                 # 运行到终态就把沙箱会话收掉。thread_id 每个 run 都是新的，
                 # 不收的话每跑一次带代码节点的图就多一台常驻 microVM（几百 MB），
                 # 而且没有任何自动回收路径会碰它——闲置回收只在"下次有人执行
@@ -692,13 +778,41 @@ class RunManager:
         now = datetime.now(timezone.utc)
         timing = {"wall_ms": elapsed_ms, "active_ms": elapsed_ms, "wait_ms": 0}
 
+        # 终态事件和运行记录在同一个事务里提交，提交之后再广播。两边都有人在读：
+        # 读到 failed 的一方马上去翻事件，要翻得到 run.failed（报错原因和定位都在
+        # 那条事件里）；收到 run.finished 的一方马上 GET 这次运行取完整成果（事件里
+        # 的 output 是截断的），要读得到 succeeded 和 output。分两次提交，总有一边
+        # 会读到半截——以前先提交状态，前一种偶尔翻不到；反过来先落事件，后一种
+        # 每次都读到 running 和空的 output
+        event: RunEventModel | None = None
         async with SessionLocal() as session:
             run = await session.get(Run, run_id)
             if run:
                 timing = await _timing(session, run, elapsed_ms, now)
+                if status != "succeeded":
+                    # 状态里的用量只算跑完了的节点。失败、取消、停在审批上的那个节点已经
+                    # 花出去的调用（校验修复、agent 的前几步）只在 llm.end 里——以前这部分
+                    # 在运行记录上凭空消失，失败的运行看着像没花钱
+                    usage = _spent(usage, await _usage_of_events(session, run_id))
                 # duration_ms 是各段执行时长之和（= active_ms）。以前用这一段的耗时
                 # 覆盖它：87 秒、中间等过一次审批的运行，列表上写着 22ms
                 usage.update(duration_ms=timing["active_ms"], **timing)
+
+            if status == "succeeded":
+                # 事件里的 output 仍然截断（事件体积要控制），但截了就要说：消费方据此
+                # 回源 GET /api/runs/{id} 取全文。以前截得悄无声息，问数据页把 2000 字处
+                # 切断的半截答案当成完整结论落了库
+                clipped, truncated = _clip(output)
+                data: dict[str, Any] = {"output": clipped, "usage": usage,
+                                        "duration_ms": timing["active_ms"], "timing": timing}
+                if truncated:
+                    data["output_truncated"] = True
+                event = self._event(run_id, EventType.RUN_FINISHED, data=data)
+            elif terminal is not None:
+                kind, data = terminal
+                event = self._event(run_id, kind, data={**data, "timing": timing})
+
+            if run:
                 run.status = status
                 run.error = error
                 run.output = output
@@ -706,21 +820,17 @@ class RunManager:
                 run.error_node_id = error_node
                 if status != "interrupted":
                     run.finished_at = now
+                if status in ("failed", "cancelled"):
+                    # 并行支路上已经停下来等人的那张审批卡，运行结束了它也就没有意义了；
+                    # 留着的话它一直挂在全局待办里，批了也只会被告知运行不在断点上
+                    actor = terminal[1].get("actor") if terminal else None
+                    await _close_approvals(session, run_id, actor, now)
+                if event is not None:
+                    await _stage(session, event, run)
                 await session.commit()
+        if event is not None:
+            await bus.publish(event)
 
-        if status == "succeeded":
-            # 事件里的 output 仍然截断（事件体积要控制），但截了就要说：消费方据此
-            # 回源 GET /api/runs/{id} 取全文。以前截得悄无声息，问数据页把 2000 字处
-            # 切断的半截答案当成完整结论落了库
-            clipped, truncated = _clip(output)
-            data: dict[str, Any] = {"output": clipped, "usage": usage,
-                                    "duration_ms": timing["active_ms"], "timing": timing}
-            if truncated:
-                data["output_truncated"] = True
-            await self._emit(run_id, EventType.RUN_FINISHED, data=data)
-        elif terminal is not None:
-            kind, data = terminal
-            await self._emit(run_id, kind, data={**data, "timing": timing})
         if status != "interrupted":
             # 终态事件落库之后再封存。以前在 run.finished 之前算，清单里恰恰少了
             # 那条宣布"跑完了、成果是什么"的事件——改它的成果，清单照样对得上。
@@ -900,6 +1010,128 @@ async def _approval_default(*, run_class: str) -> str:
         return tool_approval_default(await run_defaults(session))
 
 
+def _replayed(snapshot: Any) -> set[str]:
+    """从断点驱动时要（重新）执行的节点：还没跑的（next），加上停在 interrupt 上、或者
+    失败了的。恢复过一次的节点手里已经有答复的写入，不在 next 里，只能从 tasks 上认。"""
+    again = {str(x) for x in getattr(snapshot, "next", None) or ()}
+    again.update(str(t.name) for t in getattr(snapshot, "tasks", None) or ()
+                 if getattr(t, "interrupts", None) or getattr(t, "error", None))
+    return again
+
+
+async def _stale_replay(run_id: str, spec: GraphSpec, snapshot: Any) -> str | None:
+    """旧版重放协议写下的断点，按现在的代码重放会不会把做过的工具再做一遍。会的话返回节点名。
+
+    有风险的是：断点之后，旧版代码在这个节点里已经执行过工具、或者已经批过一次。它们
+    的 task 缓存排在旧的位置上，新代码多插了记录 task，位置全错开了。停在第一次审批上、
+    之前什么都没做的，重放只会多发一条 human.requested，照常放行；人工审批节点同理。
+
+    「断点之后」按 checkpoint 的写入时刻算：同一个 superstep 里恢复不会写新的 checkpoint，
+    所以升级后恢复过一次的运行，断点仍是旧版写的，而那之后的工作是新版做的——
+    哪一段是哪一版，看那一段 run.started 里记的 replay_protocol。
+    """
+    if protocol_of(getattr(snapshot, "metadata", None)) >= PROTOCOL:
+        return None
+    nodes = spec.node_map()
+    suspects = [n for n in _replayed(snapshot) if n in nodes and nodes[n].type != NodeType.HUMAN]
+    if not suspects:
+        return None
+    try:
+        since = datetime.fromisoformat(str(snapshot.created_at)).timestamp()
+    except (AttributeError, TypeError, ValueError):
+        since = 0.0
+    async with SessionLocal() as session:
+        rows = (await session.execute(
+            select(RunEvent.type, RunEvent.node_id, RunEvent.ts, RunEvent.data)
+            .where(RunEvent.run_id == run_id,
+                   RunEvent.type.in_([EventType.RUN_STARTED, EventType.TOOL_START,
+                                      EventType.HUMAN_RESOLVED]))
+            .order_by(RunEvent.seq)
+        )).all()
+    protocol = 1
+    for kind, owner, ts, data in rows:
+        if kind == EventType.RUN_STARTED:
+            protocol = protocol_of({PROTOCOL_KEY: (data or {}).get("replay_protocol")})
+            continue
+        if protocol >= PROTOCOL or (ts or 0) < since:
+            continue
+        for node_id in suspects:
+            if owner == node_id or (owner or "").startswith(f"{node_id}/"):
+                return nodes[node_id].title or node_id
+    return None
+
+
+async def _claim(
+    session: Any, run_id: str, expected: tuple[str, ...], refusal: Callable[[str], str],
+    **values: Any,
+) -> None:
+    """只在状态仍是 expected 时把运行改成 running；已经被别人改过就回滚、说明原因。"""
+    claimed = await session.execute(
+        update(Run).where(Run.id == run_id, Run.status.in_(expected))
+        .values(status="running", error=None, **values)
+    )
+    if claimed.rowcount != 1:
+        await session.rollback()
+        status = await session.scalar(select(Run.status).where(Run.id == run_id))
+        raise ValueError(refusal(status or ""))
+
+
+async def _stage(session: Any, event: RunEventModel, run: Run | None = None) -> None:
+    """把一条事件写进这个 session，随它一起提交。run 已经在 session 里时直接改它的 last_seq。"""
+    session.add(RunEvent(run_id=event.run_id, seq=event.seq, type=str(event.type),
+                         node_id=event.node_id, ts=event.ts, data=event.data))
+    if run is not None:
+        run.last_seq = event.seq
+    else:
+        await session.execute(
+            update(Run).where(Run.id == event.run_id).values(last_seq=event.seq)
+        )
+
+
+async def _close_approvals(session: Any, run_id: str, actor: str | None, now: datetime) -> int:
+    """运行已经结束，它还没处理完的审批一并关掉。返回关掉了几条。"""
+    rows = list((await session.execute(
+        select(Approval).where(Approval.run_id == run_id,
+                               Approval.status.in_(["pending", "answered"]))
+    )).scalars())
+    for approval in rows:
+        approval.status = "cancelled"
+        approval.resolved_at = now
+        approval.resolved_by = actor
+    return len(rows)
+
+
+_USAGE_KEYS = ("input_tokens", "output_tokens", "cost_usd", "calls")
+
+
+async def _usage_of_events(session: Any, run_id: str) -> dict[str, Any]:
+    """按 llm.end 事件逐次加总的用量：每次模型调用都有一条，不管节点最后成没成。"""
+    rows = await session.execute(
+        select(RunEvent.data).where(RunEvent.run_id == run_id, RunEvent.type == EventType.LLM_END)
+    )
+    total: dict[str, Any] = dict.fromkeys(_USAGE_KEYS, 0)
+    for (data,) in rows:
+        for key in _USAGE_KEYS:
+            value = (data or {}).get(key, 1 if key == "calls" else 0)
+            if isinstance(value, (int, float)) and not isinstance(value, bool):
+                total[key] += value
+    total["cost_usd"] = round(total["cost_usd"], 6)
+    return total
+
+
+def _spent(state_usage: dict[str, Any], events_usage: dict[str, Any]) -> dict[str, Any]:
+    """两本账取大的那本。新引擎每次调用都发 llm.end，事件那本不会更少；
+    加这条事件之前的老运行（agent 节点不发 llm.end）状态那本更全。"""
+    out = dict(state_usage)
+    for key in _USAGE_KEYS:
+        mine, theirs = out.get(key) or 0, events_usage.get(key) or 0
+        if isinstance(mine, (int, float)) and theirs > mine:
+            out[key] = theirs
+    if "input_tokens" in out or "output_tokens" in out:
+        out["total_tokens"] = int(out.get("input_tokens") or 0) + int(out.get("output_tokens") or 0)
+    return out
+
+
 async def _timing(session: Any, run: Run, elapsed_ms: int, now: datetime) -> dict[str, int]:
     """wall：从第一次开始到现在的墙钟；active：各段执行时长之和；wait：等人审批的总时长。
 
diff --git a/backend/app/engine/schema.py b/backend/app/engine/schema.py
index 686ced9a..70693d51 100644
--- a/backend/app/engine/schema.py
+++ b/backend/app/engine/schema.py
@@ -150,6 +150,9 @@ class ValidationIssue(BaseModel):
     node_id: str | None = None
     edge_id: str | None = None
     message: str
+    #: 节点配置里出问题的那个字段：prompt、cases[1].condition、agents[0].system。
+    #: 检查器靠它把问题落到具体的输入框下面；说不清是哪个字段的（连线、图级）为空
+    field: str | None = None
 
 
 class ValidationResult(BaseModel):
@@ -157,9 +160,10 @@ class ValidationResult(BaseModel):
     issues: list[ValidationIssue] = Field(default_factory=list)
 
     def add(self, message: str, *, level: str = "error", node_id: str | None = None,
-            edge_id: str | None = None) -> None:
+            edge_id: str | None = None, field: str | None = None) -> None:
         self.issues.append(
-            ValidationIssue(level=level, message=message, node_id=node_id, edge_id=edge_id)  # type: ignore[arg-type]
+            ValidationIssue(level=level, message=message, node_id=node_id,  # type: ignore[arg-type]
+                            edge_id=edge_id, field=field)
         )
         if level == "error":
             self.ok = False
@@ -294,32 +298,33 @@ def innermost_loops(spec: GraphSpec) -> dict[str, str]:
     return out
 
 
-def expression_fields(node: GraphNode) -> list[tuple[str, str]]:
-    """这个节点上按表达式求值的字段：(给人看的名字, 原文)。
+def expression_fields(node: GraphNode) -> list[tuple[str, str, str]]:
+    """这个节点上按表达式求值的字段：(给人看的名字, 原文, 字段路径)。
 
     跟着模式走：foreach 循环的 condition、模板模式整形的 expression 不参与求值，
     拿它们报错就是误报。
     """
     cfg = node.config
-    out: list[tuple[str, str]] = []
+    out: list[tuple[str, str, str]] = []
 
-    def add(label: str, value: Any) -> None:
+    def add(label: str, value: Any, field: str) -> None:
         if isinstance(value, str) and value.strip():
-            out.append((label, value))
+            out.append((label, value, field))
 
-    add("跳过条件", cfg.get("skip_if"))
+    add("跳过条件", cfg.get("skip_if"), "skip_if")
     if node.type == NodeType.BRANCH and cfg.get("mode", "expression") == "expression":
-        for case in cfg.get("cases") or []:
+        for i, case in enumerate(cfg.get("cases") or []):
             case = case or {}
-            add(f"分支「{case.get('label') or case.get('key') or '?'}」的条件", case.get("condition"))
+            add(f"分支「{case.get('label') or case.get('key') or '?'}」的条件", case.get("condition"),
+                f"cases[{i}].condition")
     elif node.type == NodeType.LOOP and cfg.get("mode", "foreach") == "while":
-        add("循环条件", cfg.get("condition"))
+        add("循环条件", cfg.get("condition"), "condition")
     elif node.type == NodeType.TRANSFORM and cfg.get("mode", "expression") == "expression":
-        add("整形表达式", cfg.get("expression"))
+        add("整形表达式", cfg.get("expression"), "expression")
     elif node.type == NodeType.METRICS:
-        for d in cfg.get("metrics") or []:
+        for i, d in enumerate(cfg.get("metrics") or []):
             d = d or {}
-            add(f"指标「{d.get('id') or '?'}」的表达式", d.get("expression"))
+            add(f"指标「{d.get('id') or '?'}」的表达式", d.get("expression"), f"metrics[{i}].expression")
     return out
 
 
@@ -345,19 +350,20 @@ def _check_case_keys(node: GraphNode, cases: list[Any], result: ValidationResult
         case = case or {}
         key = str(case.get("key") or "").strip()
         name = case.get("label") or key or f"第 {i} 个"
+        field = f"cases[{i - 1}].key"
         if not key:
             result.add(f"「条件分支」的分支「{name}」没有标识（key），连不出边、也走不到它",
-                       node_id=node.id)
+                       node_id=node.id, field=field)
             continue
         if key == "default":
             result.add(
                 f"分支「{name}」的标识用了 default：这是「其他」兜底出口的保留名，两者会合并成"
                 "同一个出口，跑完分不清走的是哪条。换一个标识，比如 team",
-                level="warning", node_id=node.id,
+                level="warning", node_id=node.id, field=field,
             )
         elif key in seen:
             result.add(f"「条件分支」里有两个分支的标识都是 {key!r}：路由只认标识，"
-                       "后一个永远轮不到。给它换一个不重复的标识", node_id=node.id)
+                       "后一个永远轮不到。给它换一个不重复的标识", node_id=node.id, field=field)
         seen.add(key)
 
 
@@ -386,43 +392,46 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
         if node.type == NodeType.BRANCH:
             cases = cfg.get("cases") or []
             if not cases:
-                result.add("「条件分支」至少要配一个分支条件", node_id=node.id)
+                result.add("「条件分支」至少要配一个分支条件", node_id=node.id, field="cases")
             handles = {e.sourceHandle for e in spec.outgoing(node.id)}
             _check_case_keys(node, cases, result)
-            for case in cases:
+            for i, case in enumerate(cases):
                 key = str((case or {}).get("key") or "").strip()
                 if key and key != "default" and key not in handles:
                     result.add(
-                        f"分支 {key!r} 没有连出去的边", level="warning", node_id=node.id
+                        f"分支 {key!r} 没有连出去的边", level="warning", node_id=node.id,
+                        field=f"cases[{i}].key",
                     )
             if "default" not in handles:
                 result.add(
                     "建议给「条件分支」的「其他」出口连一条边，兜住所有条件都不满足的情况",
                     level="warning",
                     node_id=node.id,
+                    field="cases",
                 )
         elif node.type == NodeType.TOOL:
             if not cfg.get("tool"):
-                result.add("「调用工具」节点还没选工具", node_id=node.id)
+                result.add("「调用工具」节点还没选工具", node_id=node.id, field="tool")
         elif node.type == NodeType.SUBGRAPH:
             if not cfg.get("workflow_id"):
-                result.add("「子工作流」节点还没选要嵌套的工作流", node_id=node.id)
+                result.add("「子工作流」节点还没选要嵌套的工作流", node_id=node.id,
+                           field="workflow_id")
         elif node.type == NodeType.VALIDATE:
             if not cfg.get("schema"):
-                result.add("「结构校验」节点需要一个 JSON Schema", node_id=node.id)
+                result.add("「结构校验」节点需要一个 JSON Schema", node_id=node.id, field="schema")
         elif node.type == NodeType.METRICS:
             defs = cfg.get("metrics") or []
             if not defs:
-                result.add("口径卡还没有定义指标", node_id=node.id)
-            for d in defs:
+                result.add("口径卡还没有定义指标", node_id=node.id, field="metrics")
+            for i, d in enumerate(defs):
                 if not d.get("id") or not d.get("expression"):
                     result.add(f"指标定义缺 id 或 expression：{d.get('id') or '(空)'}",
-                               node_id=node.id)
+                               node_id=node.id, field=f"metrics[{i}]")
         elif node.type == NodeType.OUTPUT:
             contract = cfg.get("contract")
             if contract and not contract.get("metrics_from"):
                 result.add("出具契约缺 metrics_from（指标来自哪个「口径卡」节点）",
-                           node_id=node.id)
+                           node_id=node.id, field="contract.metrics_from")
         elif node.type == NodeType.LOOP:
             if not spec.outgoing(node.id):
                 result.add("「循环」节点没有循环体", node_id=node.id)
@@ -433,6 +442,7 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
                     "没有指定模型，将回退到默认 provider",
                     level="warning",
                     node_id=node.id,
+                    field="model",
                 )
 
     # 表达式：用运行时同一个 parse_expression 先解析一遍。以前写错了只有跑到那一步
@@ -441,30 +451,32 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
     from app.engine.expressions import ExpressionError, parse_expression
 
     for node in spec.nodes:
-        for label, text in expression_fields(node):
+        for label, text, field in expression_fields(node):
             try:
                 _, unwrapped, unknown = parse_expression(text)
             except ExpressionError as e:
-                result.add(f"{label}写错了：{e}（原文：{text}）", node_id=node.id)
+                result.add(f"{label}写错了：{e}（原文：{text}）", node_id=node.id, field=field)
                 continue
             if unwrapped:
                 result.add(
                     f"{label}里的 {{{{ }}}} 是多余的——这里是表达式、不是模板，"
                     f"已按 {'、'.join(unwrapped)} 理解", level="warning", node_id=node.id,
+                    field=field,
                 )
             if unknown:
                 result.add(
                     f"{label}里的 {'、'.join(unknown)} 不是能用的名字，运行时会取到空值"
                     "（变量要写全：vars.x、input.x、nodes.某节点.text）",
-                    level="warning", node_id=node.id,
+                    level="warning", node_id=node.id, field=field,
                 )
         cfg = node.config
         if node.type == NodeType.LOOP and cfg.get("mode", "foreach") == "while" \
                 and not str(cfg.get("condition") or "").strip():
-            result.add("while 循环没有写条件，循环体一次都不会跑", level="warning", node_id=node.id)
+            result.add("while 循环没有写条件，循环体一次都不会跑", level="warning", node_id=node.id,
+                       field="condition")
         if node.type == NodeType.TRANSFORM and cfg.get("mode", "expression") == "expression" \
                 and not str(cfg.get("expression") or "").strip():
-            result.add("整形节点没有填表达式", node_id=node.id)
+            result.add("整形节点没有填表达式", node_id=node.id, field="expression")
         # assign_to 拿到的是 stdout。脚本最后一行写个裸表达式不会输出（那是 notebook
         # 的行为）——变量是空的，下游的循环条件一上来就不成立、成果也是空的，而整次
         # 运行照样"成功"。开发库里的「测试 1」就是这样：修好条件之后跑通了，结果为空
@@ -478,9 +490,11 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
                 result.add(
                     f"代码把输出交给 vars.{var}，可代码里没有 print：Python 脚本最后一行的表达式"
                     f"不会自动输出，vars.{var} 会是空的。把结果 print 出来；要交给下游一个对象，"
-                    "就 print(json.dumps(结果))", node_id=node.id,
+                    "就 print(json.dumps(结果))", node_id=node.id, field="code",
                 )
 
+    _check_named_tools(spec, result)
+
     # 孤儿节点
     for node in spec.nodes:
         if node.type in (NodeType.INPUT, NodeType.OUTPUT):
@@ -497,6 +511,204 @@ def validate_graph(spec: GraphSpec) -> ValidationResult:
         # info 级是"产出没人用"这类提示，不进校验（它不影响能不能跑）
         if issue.level == "info":
             continue
-        result.add(issue.message, level=issue.level, node_id=issue.node_id)
+        result.add(issue.message, level=issue.level, node_id=issue.node_id,
+                   field=issue.field or None)
 
     return result
+
+
+# --------------------------------------------------------------------------
+# 提示词点名的工具，节点得真的绑了它
+#
+# 一次真实运行：助手改图时把三个查库 agent 的 tools 丢了，提示词里还写着「用
+# db_query__… 查」。模型拿不到工具，只能写一句「假设调用工具」，再往下编；校验节点
+# 的修复又替它编了个 0。这张图在跑之前就能认出来。Copilot 的自查读的是同一份
+# error，搭图时就会交回模型去修。
+#
+# 这条是 error，会挡住运行，还会作为 Copilot 自查的阻断项交回模型（模型可能反过来
+# 把提示词里禁用的工具绑上去），所以宁可漏判不可误判：
+#   - 认得出的工具名才算点名：内置工具、db_query__ / db_schema__ / mcp: 这几种形状，
+#     以及这张图里别的节点绑过的名字；
+#   - 「不要用 X」「Never call X」「X 的结果」不是在要求用它；
+#   - calculator 这种本身就是个普通词的工具名，只有写在反引号里、或者紧跟在「用 /
+#     调用 / use / call」后面才算点名；「可以用」「如有需要」「if needed」这类非强制的
+#     说法也一样。这两种只报 warning。
+# --------------------------------------------------------------------------
+
+_DYNAMIC_TOOL = r"db_(?:query|schema)__[A-Za-z0-9_\-]+|mcp:[\w\-]+/[\w\-.]+"
+# 工具名紧挨着汉字是常态（「用python_exec核对」），所以边界只排 ASCII 标识符字符
+_EDGE_BEFORE, _EDGE_AFTER = r"(?<![A-Za-z0-9_:/\-])", r"(?![A-Za-z0-9_\-])"
+_TEMPLATE_SPAN = re.compile(r"\{\{.*?\}\}", re.S)
+_NEGATED = re.compile(
+    r"(?:(?:不要|不用|不必|无需|无须|毋须|不需要|不再|别再|别|禁止|停止|不能|不得|不应|不可|避免|切勿|勿|严禁)"
+    r"\s*(?:再|去)?(?:使用|调用|用|执行|运行|跑)?"
+    r"|(?<![A-Za-z])(?:don['’]?t|do\s+not|never|avoid|without|must\s+not|mustn['’]?t|should\s+not"
+    r"|shouldn['’]?t|cannot|can['’]t|no\s+need\s+to|not|no)\s+(?:(?:use|call|invoke|run|execute|using|calling"
+    r"|invoking|running|rely\s+on|touch)\s+)?(?:the\s+|any\s+)?)"
+    r"\s*[「“\"'`]?\s*$", re.I)
+_REFERENCED = re.compile(r"^\s*[」”\"'`]?\s*(的|返回|给出|查到|产出|输出|结果"
+                         r"|(?:'s\b)|(?:results?|outputs?|returned|returns)\b)", re.I)
+# 普通词形的工具名（calculator）要有明确的「用」字眼紧挨着才算点名
+_PLAIN_WORD = re.compile(r"[A-Za-z][a-z]*(?:-[a-z]+)*")
+_USE_VERB = re.compile(r"(?:使用|调用|用|(?<![A-Za-z])(?:use|call|invoke|run))\s*$", re.I)
+# 非强制的说法：同一句里出现就只算提到，不算要求
+_OPTIONAL = re.compile(r"可以|可选|如有需要|如需|若需|必要时|需要时|有需要|酌情"
+                       r"|(?<![A-Za-z])(?:may|might|can|could|optionally|if\s+(?:needed|necessary|required)"
+                       r"|when\s+needed|feel\s+free)(?![A-Za-z])", re.I)
+_CLAUSE_END = re.compile(r"[。；;！!？?\n]|\.(?:\s|$)")
+# 笼统地要求用工具、却没点名
+_VAGUE = re.compile(r"(调用|使用|用|借助|通过)\s*(相关|对应|可用|数据库|查询)?\s*工具"
+                    r"|查询?数据库|查库|执行\s*SQL|跑\s*SQL", re.I)
+
+
+def _bound_tools(cfg: dict[str, Any]) -> set[str]:
+    return {t for t in cfg.get("tools") or [] if isinstance(t, str)}
+
+
+def _covers(bound: set[str], tool: str) -> bool:
+    """tool 在不在 bound 里。mcp:<server>/*（或只写 mcp:<server>）绑的是这个 server 的全部工具。"""
+    if tool in bound:
+        return True
+    if not tool.startswith("mcp:"):
+        return False
+    server = tool[4:].partition("/")[0]
+    return any(b in (f"mcp:{server}", f"mcp:{server}/", f"mcp:{server}/*") for b in bound)
+
+
+def _named_tool_pattern(spec: GraphSpec) -> re.Pattern[str]:
+    from app.tools.registry import all_specs
+
+    bound: set[str] = set()
+    for node in spec.nodes:
+        cfg = node.config
+        bound.update(_bound_tools(cfg))
+        if isinstance(cfg.get("tool"), str):
+            bound.add(cfg["tool"])
+        for member in cfg.get("agents") or []:
+            if isinstance(member, dict):
+                bound.update(_bound_tools(member))
+    names = sorted({*all_specs(), *bound}, key=len, reverse=True)
+    literal = "|".join(re.escape(n) for n in names if n)
+    body = f"{_DYNAMIC_TOOL}|{literal}" if literal else _DYNAMIC_TOOL
+    return re.compile(f"{_EDGE_BEFORE}(?:{body}){_EDGE_AFTER}")
+
+
+# 列举里的分隔：「严禁调用 web_search、web_fetch、http_request 等」「never call a, b or c」
+_LIST_TAIL = re.compile(r"(?:[\s、，,/和或及与跟以「」“”\"'`]|(?<![A-Za-z])(?:or|and|nor)(?![A-Za-z]))+$",
+                        re.I)
+
+
+def _negated(plain: str, start: int, pattern: re.Pattern[str]) -> bool:
+    """这个工具名前面是不是一句「不要用」。列举里排在后面的也算：往回跳过前面的工具名和顿号。"""
+    head = plain[max(0, start - 120):start]
+    while True:
+        trimmed = _LIST_TAIL.sub("", head)
+        last = None
+        for last in pattern.finditer(trimmed):
+            pass
+        if last is not None and last.end() == len(trimmed):
+            trimmed = trimmed[:last.start()]
+        if trimmed == head:
+            break
+        head = trimmed
+    return bool(_NEGATED.search(head[-40:] + " "))
+
+
+def _clause(plain: str, start: int, end: int) -> str:
+    """工具名所在的那一句。"""
+    before = [m.end() for m in _CLAUSE_END.finditer(plain, 0, start)]
+    after = _CLAUSE_END.search(plain, end)
+    return plain[before[-1] if before else 0:after.start() if after else len(plain)]
+
+
+def _asked_tools(text: str, pattern: re.Pattern[str]) -> dict[str, bool]:
+    """文本里被要求使用的工具名，按出现顺序。值是「是不是明确要求」：否的只算提到了。"""
+    # {{ }} 里的是模板引用，不是在点名工具；换成等长空白，位置不变
+    plain = _TEMPLATE_SPAN.sub(lambda m: " " * len(m.group(0)), text)
+    found: dict[str, bool] = {}
+    for m in pattern.finditer(plain):
+        if _negated(plain, m.start(), pattern) or _REFERENCED.match(plain[m.end():m.end() + 12]):
+            continue
+        name = m.group(0)
+        explicit = not _OPTIONAL.search(_clause(plain, m.start(), m.end()))
+        if explicit and _PLAIN_WORD.fullmatch(name):
+            quoted = plain[m.start() - 1:m.start()] == "`" and plain[m.end():m.end() + 1] == "`"
+            explicit = quoted or bool(_USE_VERB.search(plain[max(0, m.start() - 12):m.start()]))
+        found[name] = found.get(name, False) or explicit
+    return found
+
+
+def _asks_vaguely(text: str) -> bool:
+    plain = _TEMPLATE_SPAN.sub(" ", text)
+    return any(not _NEGATED.search(plain[max(0, m.start() - 12):m.start()])
+               for m in _VAGUE.finditer(plain))
+
+
+def _check_named_tools(spec: GraphSpec, result: ValidationResult) -> None:
+    agents = [n for n in spec.nodes if n.type in (NodeType.AGENT, NodeType.SUPERVISOR)]
+    if not agents:
+        return
+    pattern = _named_tool_pattern(spec)
+
+    def check(node: GraphNode, texts: list[tuple[str, Any]], tools: Any, who: str = "") -> None:
+        bound = {t for t in tools or [] if isinstance(t, str)}
+        vague_at: str | None = None
+        reported: set[str] = set()
+        asked: dict[str, tuple[bool, str]] = {}
+        for field, text in texts:
+            if not isinstance(text, str) or not text.strip():
+                continue
+            for tool, explicit in _asked_tools(text, pattern).items():
+                # system 和 prompt 里都点了同一个工具，报一次就够：指到先出现的那处，
+                # 哪一处是明确要求就按要求算
+                seen = asked.get(tool)
+                asked[tool] = (explicit or bool(seen and seen[0]), seen[1] if seen else field)
+            if not bound and vague_at is None and _asks_vaguely(text):
+                vague_at = field
+        for tool, (explicit, field) in asked.items():
+            if _covers(bound, tool):
+                continue
+            reported.add(tool)
+            if explicit:
+                message = (f"{who}的提示词要求用「{tool}」，但没有给这个成员绑定它" if who
+                           else f"提示词要求用「{tool}」，但节点没有绑定它")
+                result.add(f"{message}：运行时模型拿不到这个工具，只能编一个结果出来。"
+                           "把它加进工具里，或者改掉提示词里的要求",
+                           node_id=node.id, field=field)
+            else:
+                result.add(f"{who + '的' if who else ''}提示词提到了「{tool}」，但{'这个成员' if who else '节点'}没有"
+                           "绑定它：如果是要模型调用它，运行时拿不到。需要就把它加进工具里",
+                           level="warning", node_id=node.id, field=field)
+        # 已经点名报过了，那句笼统的就不再重复
+        if vague_at is not None and not reported:
+            result.add(f"{who or '提示词'}要求调用工具，但{'这个成员' if who else '这个节点'}没有绑定任何"
+                       "工具：模型拿不到工具，只能假设一个结果。绑定要用的工具，或者改掉这句要求",
+                       level="warning", node_id=node.id, field=vague_at)
+
+    for node in agents:
+        cfg = node.config
+        if node.type == NodeType.AGENT:
+            check(node, [("system", cfg.get("system")), ("prompt", cfg.get("prompt"))],
+                  cfg.get("tools"))
+            continue
+        members = [m for m in cfg.get("agents") or [] if isinstance(m, dict)]
+        team_tools: set[str] = set()
+        for i, member in enumerate(members):
+            name = member.get("name") or f"agent{i}"
+            team_tools.update(_bound_tools(member))
+            check(node, [(f"agents[{i}].system", member.get("system"))], member.get("tools"),
+                  who=f"成员「{name}」")
+        # 协作目标是给调度者看的：点了名的工具，至少得有一个成员拿得到
+        goal = cfg.get("goal")
+        if isinstance(goal, str):
+            for tool, explicit in _asked_tools(goal, pattern).items():
+                if _covers(team_tools, tool):
+                    continue
+                if explicit:
+                    result.add(f"协作目标要求用「{tool}」，但没有哪个成员绑定了它：调度者派出去的人"
+                               "谁都调不了它。给负责的成员加上这个工具，或者改掉目标里的要求",
+                               node_id=node.id, field="goal")
+                else:
+                    result.add(f"协作目标提到了「{tool}」，但没有哪个成员绑定了它：如果是要成员"
+                               "调用它，谁都拿不到。需要就给负责的成员加上",
+                               level="warning", node_id=node.id, field="goal")
diff --git a/backend/app/engine/toolcalls.py b/backend/app/engine/toolcalls.py
new file mode 100644
index 00000000..52c096c5
--- /dev/null
+++ b/backend/app/engine/toolcalls.py
@@ -0,0 +1,175 @@
+"""节点里调工具的公共部分：时限，以及「模型把工具调用写成了文字」的识别。
+
+agent 节点、协作成员、工具节点三处都在调工具。以前时限只有数据层自己那一道
+wait_for，而 wait_for 取消之后要等被取消的那一方收完尾：驱动关连接、回滚要排在
+数据库那条语句后面。真实运行里一次「查询超过 30s 被中断」实际等了 90 秒——时限
+到了、取消也发了，控制权却迟迟回不来，报错写的还是 30。
+"""
+from __future__ import annotations
+
+import asyncio
+import re
+from dataclasses import dataclass
+from typing import Any, Awaitable
+
+QUERY_PREFIX = "db_query__"
+
+#: 到了工具自己的时限之后再宽限多久才放弃。工具自己的超时报错（「查询超过 30s
+#: 被中断，加上 WHERE…」）比这里的说法更具体，先让它到；收尾卡住了才由这里兜底
+GRACE_S = 1.0
+
+#: 沙箱代码工具的时限来自参数（缺省 30 秒），由沙箱自己执行
+_SANDBOX_TOOLS = {"python_exec", "shell_exec", "run_code"}
+_HTTP_TOOLS = {"http_request", "web_fetch"}
+
+
+@dataclass(frozen=True)
+class Limit:
+    """一次工具调用的时限。seconds 随 tool.start 发给界面，界面据此说「已超出 30s 上限」。"""
+
+    seconds: float
+    #: 到点由引擎收回控制权。只对「时限到了、收尾却可能卡住」的类型开：沙箱的时限
+    #: 里还含着起虚拟机、装依赖，按它掐会误杀冷启动；HTTP 客户端自己掐得准
+    enforce: bool
+    #: query | declared | sandbox | http
+    kind: str
+
+    @property
+    def self_timed(self) -> bool:
+        """工具自己也按这个时限掐、并且自己收尾（数据层的查询）。引擎放弃它时只撒手、
+        不再取消：它那时多半正在收尾，再取消一次会把关连接那一步打断，连接就再也回不到池里。"""
+        return self.kind == "query"
+
+
+def limit_of(tool: Any, name: str, args: dict[str, Any]) -> Limit | None:
+    """这次调用的时限。说不出来就是 None——界面上不写上限，引擎也不掐。
+
+    工具自己在 metadata["timeout_s"] 里声明的优先（数字，或者按参数算的函数）。
+    """
+    meta = (getattr(tool, "metadata", None) or {}) if tool is not None else {}
+    declared = meta.get("timeout_s")
+    if callable(declared):
+        declared = declared(args)
+    if not (isinstance(declared, (int, float)) and not isinstance(declared, bool) and declared > 0):
+        declared = None
+    if name.startswith(QUERY_PREFIX):
+        # 数据层自己按这个时限掐、自己收尾。数据源声明了自己的时限就用它，
+        # 否则按模块属性现取数据层的缺省——那个数只有这一处定义
+        from app.data import guard
+
+        return Limit(float(declared or guard.QueryLimits().timeout_seconds), True, "query")
+    if declared:
+        return Limit(float(declared), True, "declared")
+    if name in _SANDBOX_TOOLS:
+        try:
+            seconds = float(args.get("timeout") or 30)
+        except (TypeError, ValueError):
+            seconds = 30.0
+        return Limit(seconds, False, "sandbox")
+    if name in _HTTP_TOOLS:
+        from app.core.config import settings
+
+        return Limit(float(settings.http_tool_timeout), False, "http")
+    return None
+
+
+def limit_fields(limit: Limit | None) -> dict[str, Any]:
+    """tool.start 上附带的时限字段。没有时限就什么都不带，老客户端照旧。"""
+    if limit is None:
+        return {}
+    return {"timeout_s": int(limit.seconds) if limit.seconds.is_integer() else limit.seconds}
+
+
+def _seconds(value: float) -> str:
+    return str(int(value)) if float(value).is_integer() else f"{value:g}"
+
+
+class ToolTimeout(TimeoutError):
+    """引擎等到时限就放弃了。消息直接给模型和人看：等了多久、为什么放弃、怎么办。"""
+
+    def __init__(self, name: str, limit: Limit) -> None:
+        self.name = name
+        self.limit = limit
+        seconds = _seconds(limit.seconds)
+        if limit.kind == "query":
+            text = (f"查询超过 {seconds}s 没有返回，已放弃等待（数据库那边可能还在跑，连接会在后台"
+                    "收回）。加上 WHERE 条件或 LIMIT 缩小范围再查")
+        else:
+            text = f"工具 {name} 超过 {seconds}s 没有返回，已放弃等待"
+        super().__init__(text)
+
+
+async def run_bounded(call: Awaitable[Any], limit: Limit | None, name: str) -> Any:
+    """跑一次工具调用；到了时限（加一点宽限）就收回控制权，不等它收尾。
+
+    被放弃的那次调用照样被取消，只是它的收尾（关连接、回滚）挪到后台去做完。
+    """
+    if limit is None or not limit.enforce:
+        return await call
+    job = asyncio.ensure_future(call)
+    try:
+        done, _ = await asyncio.wait({job}, timeout=limit.seconds + GRACE_S)
+    except asyncio.CancelledError:
+        # 整次运行被取消（用户停止、服务关停）：底下那次调用也不该接着跑
+        _abandon(job)
+        raise
+    if job in done:
+        return job.result()
+    _abandon(job, cancel=not limit.self_timed)
+    raise ToolTimeout(name, limit)
+
+
+def _abandon(job: asyncio.Future[Any], *, cancel: bool = True) -> None:
+    if cancel:
+        job.cancel()
+    # 结果没人要了；把异常取走，免得事件循环报 "exception was never retrieved"
+    job.add_done_callback(lambda f: f.cancelled() or f.exception())
+
+
+# --------------------------------------------------------------------------
+# 模型把工具调用写成了文字
+#
+# 有的模型（或它前面那层网关）不认工具调用接口、或者节点根本没绑工具，模型就把自己
+# 训练时那套调用格式当正文吐出来。这一步没有任何真实调用，数据一次都没查到，而文字
+# 看上去像是「在查」。认出来之后先纠正一次，仍然如此就判失败。
+# --------------------------------------------------------------------------
+
+_MARKUP = re.compile(
+    r"<[｜|]{1,2}\s*DSML\s*[｜|]{1,2}"                      # DeepSeek 的 DSML
+    r"|<[｜|]\s*tool[▁_ ]calls?[▁_ ]begin\s*[｜|]>"          # DeepSeek 的特殊 token
+    r"|<\s*(?:tool_call|function_call)\s*>"
+    r"|<\s*invoke\s+name\s*=",
+    re.IGNORECASE,
+)
+# 只有一段 {"tool": …, "sql": …} 不算：正文里引用一段 JSON 很正常。
+# 得同时自称是「假设」调的，才是在编
+_TOOL_JSON = re.compile(r'\{\s*"tool"\s*:')
+_SQL_KEY = re.compile(r'"sql"\s*:')
+_PRETEND = re.compile(r"假设(?:调用|使用|执行)了?(?:工具|查询)|假装调用|模拟调用(?:了)?工具")
+
+TOOL_MARKUP_ERROR = (
+    "模型输出了工具调用的原始标记，但没有真正调用工具，这一步一次都没查到数据。"
+    "常见原因：节点没有绑定工具，或者模型、服务不支持工具调用。"
+    "到画布里给这个节点绑定要用的工具；绑定了还这样，就换一个支持工具调用的模型"
+)
+
+TOOL_MARKUP_NUDGE = (
+    "你上一条回复把工具调用写成了文字，系统没有执行它，也就没有拿到任何数据。"
+    "要用工具，请通过工具调用接口发起，不要把调用格式写进正文；手上没有能用的工具，"
+    "就直接说明查不到、缺什么，不要假设调用的结果。"
+)
+
+
+def leaked_markup(text: str | None) -> str | None:
+    """正文里露出来的工具调用标记（截一小段，给警告用）。没有就是 None。"""
+    if not text:
+        return None
+    if m := _MARKUP.search(text):
+        return m.group(0)
+    if _TOOL_JSON.search(text) and _SQL_KEY.search(text) and (m := _PRETEND.search(text)):
+        return m.group(0)
+    return None
+
+
+def markup_warning(snippet: str, who: str = "模型") -> str:
+    return f"{who}把工具调用写成了文字（{snippet[:40]}…），没有真正调用工具"
diff --git a/backend/app/engine/variables.py b/backend/app/engine/variables.py
index 7a7d6469..76e2881f 100644
--- a/backend/app/engine/variables.py
+++ b/backend/app/engine/variables.py
@@ -68,6 +68,8 @@ class VarIssue(BaseModel):
     message: str
     node_id: str | None = None
     path: str = ""
+    #: 引用写在节点配置的哪个字段里（prompt、cases[0].condition）。产出侧的问题为空
+    field: str = ""
 
 
 class VariableReport(BaseModel):
@@ -350,7 +352,7 @@ def analyze(spec: GraphSpec) -> VariableReport:
                     if target.kind == "loop" and target.produced_by:
                         if node.id not in bodies.get(target.produced_by, set()):
                             report.issues.append(VarIssue(
-                                level="warning", node_id=node.id, path=path,
+                                level="warning", node_id=node.id, path=path, field=field,
                                 message=f"{{{{ {path} }}}} 是「{target.produced_by_label}」"
                                         f"每轮的循环变量，只在循环体内部有值；"
                                         f"这一步不在循环体里，取到的会是空值",
@@ -364,7 +366,7 @@ def analyze(spec: GraphSpec) -> VariableReport:
                         and target.order > order
                     ):
                         report.issues.append(VarIssue(
-                            level="warning", node_id=node.id, path=path,
+                            level="warning", node_id=node.id, path=path, field=field,
                             message=f"{{{{ {path} }}}} 由「{target.produced_by_label}」产出，"
                                     f"但那一步在这之后才跑，这里取到的会是空值",
                         ))
@@ -383,7 +385,7 @@ def analyze(spec: GraphSpec) -> VariableReport:
                 hint = _did_you_mean(path, index)
                 report.issues.append(VarIssue(
                     level="error" if known_root else "warning",
-                    node_id=node.id, path=path,
+                    node_id=node.id, path=path, field=field,
                     message=(
                         f"{{{{ {path} }}}} 没有任何节点产出，"
                         f"是不是想写 {{{{ {hint} }}}}？取不到值会渲染成空字符串，不报错"
diff --git a/backend/app/memory/embeddings.py b/backend/app/memory/embeddings.py
index b2728d53..35988208 100644
--- a/backend/app/memory/embeddings.py
+++ b/backend/app/memory/embeddings.py
@@ -4,7 +4,7 @@ import hashlib
 import math
 import os
 import re
-from typing import Any, Sequence
+from typing import Any, NamedTuple, Sequence
 
 import numpy as np
 
@@ -182,7 +182,7 @@ def has_semantics() -> bool:
 
 
 def _why(e: BaseException) -> str:
-    from app.api.errors import explain
+    from app.core.errors import explain
 
     return explain(e)[0]
 
@@ -293,7 +293,18 @@ class BM25:
         return scores
 
 
-def hybrid_rank(
+class Ranked(NamedTuple):
+    """一条混合排序的结果。contrib 两项之和就是 score。"""
+
+    index: int
+    score: float
+    #: 两路的原始分：余弦、BM25
+    signals: dict[str, float]
+    #: 两路各自对总分的贡献：归一化之后乘上 α / 1-α
+    contrib: dict[str, float]
+
+
+def hybrid_contrib(
     query: str,
     texts: Sequence[str],
     vectors: Sequence[np.ndarray | None],
@@ -301,8 +312,8 @@ def hybrid_rank(
     *,
     alpha: float = 0.5,
     keyword_scores: Sequence[float] | None = None,
-) -> list[tuple[int, float, dict[str, float]]]:
-    """向量相似度和 BM25 各归一化后加权合并。
+) -> list[Ranked]:
+    """向量相似度和 BM25 各归一化后加权合并，并交出每一路的贡献。
 
     纯向量会漏掉精确的专有名词，纯 BM25 又抓不住同义表达，
     混合排序在本地小知识库上稳定优于任何一个单独使用。
@@ -311,6 +322,9 @@ def hybrid_rank(
     统计（N、avg_len、df）算好了分，而这里只拿到候选子集——在子集上重算，
     df 和平均长度全是另一套数，排出来的名次和全表扫不一样。真踩过，
     test_the_index_ranks_the_same_as_a_full_scan 就是为此写的。
+
+    贡献要在这里算：归一化是在整个候选集上做的，调用方只拿得到前几条，
+    复现不了。
     """
     if not texts:
         return []
@@ -328,10 +342,24 @@ def hybrid_rank(
         return [(x - lo) / (hi - lo) for x in xs]
 
     kw_n, vec_n = _norm(kw_scores), _norm(vec_scores)
-    ranked = [
-        (i, alpha * vec_n[i] + (1 - alpha) * kw_n[i],
-         {"vector": vec_scores[i], "keyword": kw_scores[i]})
-        for i in range(len(texts))
-    ]
-    ranked.sort(key=lambda t: t[1], reverse=True)
+    ranked: list[Ranked] = []
+    for i in range(len(texts)):
+        by_vec, by_kw = alpha * vec_n[i], (1 - alpha) * kw_n[i]
+        ranked.append(Ranked(i, by_vec + by_kw, {"vector": vec_scores[i], "keyword": kw_scores[i]},
+                             {"vector": by_vec, "keyword": by_kw}))
+    ranked.sort(key=lambda r: r.score, reverse=True)
     return ranked
+
+
+def hybrid_rank(
+    query: str,
+    texts: Sequence[str],
+    vectors: Sequence[np.ndarray | None],
+    query_vec: np.ndarray,
+    *,
+    alpha: float = 0.5,
+    keyword_scores: Sequence[float] | None = None,
+) -> list[tuple[int, float, dict[str, float]]]:
+    """同 hybrid_contrib，只要 (下标, 总分, 原始分)。"""
+    return [(r.index, r.score, r.signals) for r in hybrid_contrib(
+        query, texts, vectors, query_vec, alpha=alpha, keyword_scores=keyword_scores)]
diff --git a/backend/app/memory/kb.py b/backend/app/memory/kb.py
index 77d4d5e5..36855b18 100644
--- a/backend/app/memory/kb.py
+++ b/backend/app/memory/kb.py
@@ -10,7 +10,7 @@ from app.db.models import Chunk, Document
 from app.memory import inverted
 from app.memory.embeddings import (
     default_alpha, embed_text, embed_texts, embedder_dim, embedder_id, from_blob,
-    hybrid_rank, to_blob, usable,
+    hybrid_contrib, to_blob, usable,
 )
 
 _TARGET = 800
@@ -301,7 +301,7 @@ async def search(
         query_vec = await embed_text(query)
         vectors = [from_blob(r.embedding, embedder_dim()) for r in rows]
 
-    ranked = hybrid_rank(
+    ranked = hybrid_contrib(
         query,
         [r.content for r in rows],
         vectors,
@@ -310,8 +310,11 @@ async def search(
         keyword_scores=kw_scores,
     )
     out: list[dict[str, Any]] = []
-    for idx, score, parts in ranked[:limit]:
-        row = rows[idx]
+    for hit in ranked[:limit]:
+        row = rows[hit.index]
+        score = round(hit.score, 4)
+        # 关键词那份用减法得出：各自四舍五入之后再相加，会和总分差出一个末位
+        by_vec = min(round(hit.contrib["vector"], 4), score)
         out.append(
             {
                 "chunk_id": row.id,
@@ -319,18 +322,23 @@ async def search(
                 "title": (row.meta or {}).get("title", ""),
                 "ordinal": row.ordinal,
                 "content": row.content,
-                "score": round(score, 4),
-                "signals": {k: round(v, 4) for k, v in parts.items()},
+                "score": score,
+                "signals": {k: round(v, 4) for k, v in hit.signals.items()},
+                # 两路各贡献了多少分，两者之和等于 score。调试台据此画贡献条
+                "contrib": {"vector": by_vec, "keyword": round(score - by_vec, 4)},
             }
         )
     return out
 
 
-async def reindex(session: AsyncSession, collection: str | None = None) -> dict[str, Any]:
+async def reindex(
+    session: AsyncSession, collection: str | None = None, *, on_progress: Any = None,
+) -> dict[str, Any]:
     """用当前 embedder 重算向量。
 
     换了 embedding 模型之后唯一的恢复手段。按批做：一次几千条 chunk 全塞给
     远端 embedding 接口，要么超时要么被限流，而中途失败又没有断点。
+    on_progress(已完成, 总数) 每批提交之后回调一次。
     """
     stmt = select(Chunk)
     if collection:
@@ -349,6 +357,8 @@ async def reindex(session: AsyncSession, collection: str | None = None) -> dict[
             row.embed_model = model_id
             row.embed_dim = dim
         await session.commit()
+        if on_progress:
+            on_progress(min(i + batch, len(rows)), len(rows))
     # 倒排一起重建：两者都是"存量数据升级"的恢复手段，分成两个按钮只会漏点一个
     await inverted.rebuild(session, collection)
     return {"collection": collection, "reindexed": len(rows), "embedder": model_id}
diff --git a/backend/app/memory/rerank.py b/backend/app/memory/rerank.py
index 0f531d6d..ea06252e 100644
--- a/backend/app/memory/rerank.py
+++ b/backend/app/memory/rerank.py
@@ -96,7 +96,7 @@ async def rerank(
         return hits[:top_n]
     except Exception as e:  # noqa: BLE001
         if on_note:
-            from app.api.errors import explain
+            from app.core.errors import explain
 
             on_note(f"重排失败，按初筛顺序返回：{explain(e)[0]}")
         return hits[:top_n]
diff --git a/backend/app/memory/store.py b/backend/app/memory/store.py
index e731739f..5d150666 100644
--- a/backend/app/memory/store.py
+++ b/backend/app/memory/store.py
@@ -232,11 +232,14 @@ async def stale_count(session: AsyncSession, scope: str | None = None) -> int:
     return int((await session.execute(stmt)).scalar_one() or 0)
 
 
-async def reindex(session: AsyncSession, scope: str | None = None) -> int:
+async def reindex(
+    session: AsyncSession, scope: str | None = None, *, on_progress: Any = None,
+) -> int:
     """用当前 embedder 重算记忆的向量，返回重算了多少条。
 
     换 embedding 模型之后记忆和知识库一起失效，但在此之前只有知识库有重建
     路径——记忆这边悄悄退回关键词，而且没有任何恢复手段。
+    on_progress(已完成, 总数) 每批提交之后回调一次。
     """
     stmt = select(MemoryItem)
     if scope:
@@ -246,9 +249,9 @@ async def reindex(session: AsyncSession, scope: str | None = None) -> int:
         return 0
 
     model_id, dim = embedder_id(), embedder_dim()
-    from app.memory.kb import _EMBED_BATCH
+    from app.memory import kb
 
-    batch = _EMBED_BATCH   # 和 kb 那边统一：一次几千条全发给远端接口必被限流
+    batch = kb._EMBED_BATCH   # 和 kb 那边统一：一次几千条全发给远端接口必被限流
     for i in range(0, len(rows), batch):
         part = rows[i:i + batch]
         vectors = await embed_texts([r.content for r in part])
@@ -257,6 +260,8 @@ async def reindex(session: AsyncSession, scope: str | None = None) -> int:
             row.embed_model = model_id
             row.embed_dim = dim
         await session.commit()
+        if on_progress:
+            on_progress(min(i + batch, len(rows)), len(rows))
     return len(rows)
 
 
diff --git a/backend/app/tools/builtin/web.py b/backend/app/tools/builtin/web.py
index 50119e7d..6f9d4aec 100644
--- a/backend/app/tools/builtin/web.py
+++ b/backend/app/tools/builtin/web.py
@@ -175,7 +175,7 @@ async def web_search(ctx: ToolContext, **kwargs: Any) -> dict[str, Any]:
             results = await _duckduckgo(args.query, args.max_results)
             engine = "duckduckgo"
     except Exception as e:  # noqa: BLE001 - 搜索失败不该让整个 run 挂掉
-        from app.api.errors import explain
+        from app.core.errors import explain
 
         return {"error": f"搜索失败：{explain(e)[0]}", "results": []}
     return {"engine": engine, "query": args.query, "results": results}
diff --git a/backend/app/tools/custom.py b/backend/app/tools/custom.py
index 8cbc2795..69e0bcbf 100644
--- a/backend/app/tools/custom.py
+++ b/backend/app/tools/custom.py
@@ -13,7 +13,7 @@ from app.engine.expressions import render_deep, render_template
 from app.sandbox.base import SandboxLimits
 from app.sandbox.manager import sandbox_manager
 from app.tools.net import UnsafeUrlError, safe_request
-from app.tools.registry import ToolContext
+from app.tools.registry import ToolBuildError, ToolContext, prepare_args
 
 _TYPES = {
     "string": str,
@@ -24,6 +24,22 @@ _TYPES = {
     "object": dict,
 }
 
+#: 手写参数定义时常见的类型写法（Python 的、其他语言的、缩写）。只用来在报错里
+#: 猜「是不是想写 X」，不自动放行：悄悄按猜的类型建出来，试跑和运行对不上还没人知道
+_TYPE_ALIASES = {
+    "int": "integer", "long": "integer", "float": "number", "double": "number",
+    "decimal": "number", "str": "string", "text": "string", "bool": "boolean",
+    "list": "array", "dict": "object", "map": "object", "json": "object",
+}
+
+
+def _type_guess(value: Any) -> str | None:
+    """value 像是哪个合法类型；认不出来返回 None。"""
+    if not isinstance(value, str):
+        return None
+    low = value.strip().lower()
+    return low if low in _TYPES else _TYPE_ALIASES.get(low)
+
 
 def schema_to_model(name: str, schema: dict[str, Any]) -> type[BaseModel]:
     """把 JSON Schema 转成 pydantic 模型，好让它能绑成 LangChain 工具。"""
@@ -42,6 +58,72 @@ def schema_to_model(name: str, schema: dict[str, Any]) -> type[BaseModel]:
     return create_model(f"{name}_Args", **fields)  # type: ignore[call-overload]
 
 
+def schema_problem(schema: Any) -> str | None:
+    """参数定义哪里写得不对；没问题返回 None。
+
+    参数定义是用户在编辑器里手写的 JSON。schema_to_model 只认 {"type": "integer"}
+    这样的写法，写成 "int" 或 {"type": "int"} 时要么炸在 .get 上、要么悄悄当成
+    字符串——前者会被说成「后端内部出错了」，后者试跑通过、到了模型那边类型不对。
+    """
+    if not isinstance(schema, dict):
+        return "参数定义要是一个 JSON 对象"
+    props = schema.get("properties")
+    if props is not None and not isinstance(props, dict):
+        return '参数定义格式不对：properties 要是一个对象，每个参数一项，比如 {"n": {"type": "integer"}}'
+    for key, spec in (props or {}).items():
+        if not str(key).strip():
+            return "参数定义格式不对：有一个参数名是空的，给它起个名字"
+        if str(key).startswith("_"):
+            return (f"参数定义格式不对：参数名 {key} 不能以下划线开头，"
+                    f"换成 {str(key).lstrip('_') or 'value'} 这样的名字")
+        if str(key).startswith("model_") and hasattr(BaseModel, str(key)):
+            return f"参数定义格式不对：参数名 {key} 和内部保留的名字冲突，换一个名字"
+        if not isinstance(spec, dict):
+            # 示例照着他写的那个类型给，照抄就能改好：写了 "string" 却让人改成 integer 只会添乱
+            shown = json.dumps(spec, ensure_ascii=False)
+            meant = _type_guess(spec) or "string"
+            return (f'参数定义格式不对：参数 {key} 要写成 {{"type": "{meant}"}} 这样的对象，'
+                    f"不能直接写 {shown}")
+        kind = spec.get("type", "string")
+        if not isinstance(kind, str) or kind not in _TYPES:
+            shown = kind if isinstance(kind, str) else json.dumps(kind, ensure_ascii=False)
+            meant = _type_guess(kind)
+            guess = f"，是不是想写 {meant}" if meant else ""
+            return (f"参数定义格式不对：参数 {key} 的类型「{shown}」认不出来{guess}；"
+                    f"只能是 {'、'.join(_TYPES)} 里的一个")
+        if not isinstance(spec.get("description", ""), str):
+            return f"参数定义格式不对：参数 {key} 的 description 要是一段文字"
+    required = schema.get("required")
+    if required is not None and (
+        not isinstance(required, list) or not all(isinstance(k, str) for k in required)
+    ):
+        return '参数定义格式不对：required 要是参数名的列表，比如 ["n"]'
+    # 上面没认出来的写法，最后按运行时同一个转换真建一次：放行的一定建得出来
+    import warnings
+
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")   # 和 BaseModel 同名的参数（json、copy）只是警告，照样能用
+            schema_to_model("probe", schema)
+    except Exception:  # noqa: BLE001
+        return "参数定义格式不对：按它建不出工具的参数表，检查参数名和每个参数的 type"
+    return None
+
+
+def broken_tool_message(name: str, problem: str) -> str:
+    """库里存着的坏工具被节点绑上时的报错：哪个工具、坏在哪、去哪里改。"""
+    return f"自定义工具「{name}」的{problem}。到「工具」页把它的参数定义改好再运行"
+
+
+class ToolFailure(dict):
+    """工具自己报的失败：沙箱里代码出错、地址被拦、请求体不是 JSON。
+
+    运行时照旧当成 {"error": …} 交给模型——它看了会换个参数再试；但试跑时要
+    认得出这是失败，不能在界面上标「成功」再贴一段报错。所以是个 dict 的子类：
+    序列化出来和原来一模一样，只多了一个能 isinstance 的身份。
+    """
+
+
 async def _run_http(row: CustomTool, args: dict[str, Any]) -> Any:
     """HTTP 模板工具：url / headers / body 里可以用 {{ 参数名 }} 插值。"""
     config = row.config or {}
@@ -62,9 +144,9 @@ async def _run_http(row: CustomTool, args: dict[str, Any]) -> Any:
             timeout=config.get("timeout"),
         )
     except UnsafeUrlError as e:
-        return {"error": str(e)}
+        return ToolFailure(error=str(e))
     except json.JSONDecodeError as e:
-        return {"error": f"请求体不是合法 JSON：{e}"}
+        return ToolFailure(error=f"请求体不是合法 JSON：{e}")
 
     text = str(result.get("body", ""))
     if config.get("parse_json"):
@@ -90,7 +172,7 @@ async def _run_python(row: CustomTool, args: dict[str, Any], ctx: ToolContext) -
         session_id=ctx.sandbox_session,
     )
     if not result.ok:
-        return {"error": result.error or result.stderr or "执行失败", "exit_code": result.exit_code}
+        return ToolFailure(error=result.error or result.stderr or "执行失败", exit_code=result.exit_code)
     out = result.stdout.strip()
     try:
         return json.loads(out)
@@ -110,6 +192,14 @@ async def build_custom_tools(
             )
         ).scalars()
     )
+    # 保存时已经拒掉写坏的参数定义，但那道关卡之前存进去的还在库里。不交给
+    # schema_to_model 去炸——那样节点只能报一句「'str' object has no attribute 'get'」，
+    # 看不出是哪个工具。也不悄悄跳过它接着跑：少了一个它指望的工具，模型只会
+    # 假装调过、编出一个答案。绑了它的节点失败，协作成员这一步记为失败交给调度者
+    broken = [broken_tool_message(row.name, problem) for row in rows
+              if (problem := schema_problem(row.parameters or {}))]
+    if broken:
+        raise ToolBuildError("；".join(broken))
     tools: list[BaseTool] = []
     for row in rows:
         args_model = schema_to_model(row.name, row.parameters or {})
@@ -138,14 +228,16 @@ async def build_custom_tools(
     return tools
 
 
-async def run_custom_tool(
-    session: AsyncSession, name: str, args: dict[str, Any], ctx: ToolContext
-) -> Any:
-    row = (
-        await session.execute(select(CustomTool).where(CustomTool.name == name))
-    ).scalar_one_or_none()
-    if not row:
-        raise KeyError(f"找不到自定义工具 {name!r}")
+async def trial(row: CustomTool, args: dict[str, Any], ctx: ToolContext) -> tuple[Any, str | None]:
+    """试跑一次，参数的处理和运行时一样：先按参数 schema 校验、纠正，再执行。
+
+    row 可以是还没保存的草稿。以前试跑直接把参数原样塞进去，运行时却要过
+    schema——试跑通过的参数，到了工作流里被拒。参数不对抛 ToolArgsError。
+
+    返回 (结果, 纠正说明或 None)。参数名写错被替换时，运行时会把说明报出去；
+    试跑也得报，否则用户照着一份「跑通了」的错参数去配工作流。
+    """
+    payload, note = prepare_args(schema_to_model(row.name or "draft", row.parameters or {}), args)
     if row.kind == "python":
-        return await _run_python(row, args, ctx)
-    return await _run_http(row, args)
+        return await _run_python(row, payload, ctx), note
+    return await _run_http(row, payload), note
diff --git a/backend/app/tools/datasource.py b/backend/app/tools/datasource.py
index 80bcc96e..fae3fe23 100644
--- a/backend/app/tools/datasource.py
+++ b/backend/app/tools/datasource.py
@@ -20,7 +20,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.data import introspect
-from app.data.engine import run_query
+from app.data.engine import query_timeout, run_query
 from app.data.guard import QueryLimits, SqlRejected, is_write
 from app.db.models import DataSource
 from app.tools.registry import ToolContext
@@ -123,8 +123,12 @@ async def build_datasource_tools(
 
 
 def _make_query_tool(source: DataSource, ctx: ToolContext) -> StructuredTool:
+    # 数据源在 options.query_timeout_s 里配了就用它，否则取缺省。数据库按它停下语句，
+    # 引擎按它告诉界面上限是多少（metadata["timeout_s"]）
+    seconds = query_timeout(source)
+
     async def _run(sql: str, limit: int | None = None) -> str:
-        limits = QueryLimits(max_rows=int(limit)) if limit else QueryLimits()
+        limits = QueryLimits(timeout_seconds=seconds, **({"max_rows": int(limit)} if limit else {}))
         try:
             result = await run_query(source, sql, limits=limits)
         except SqlRejected as e:
@@ -132,7 +136,7 @@ def _make_query_tool(source: DataSource, ctx: ToolContext) -> StructuredTool:
             # 给一句笼统的"失败了"只会让它瞎猜
             return f"SQL 被拒绝：{e}"
         except Exception as e:  # noqa: BLE001
-            from app.api.errors import explain, first_line
+            from app.core.errors import explain, first_line
 
             # 驱动的原话留着（"no such table: x" 正是模型改写 SQL 要的线索），
             # 类名和 SQLAlchemy 的包装前缀去掉：这一行也会原样出现在运行面板上
@@ -159,7 +163,8 @@ def _make_query_tool(source: DataSource, ctx: ToolContext) -> StructuredTool:
         coroutine=_run,
         func=None,
         # 同一个工具，危不危险看这一次的 SQL。审批关卡经 registry.call_is_dangerous 问它
-        metadata={"dangerous_if": lambda args: is_dangerous_call(source, str(args.get("sql") or ""))},
+        metadata={"dangerous_if": lambda args: is_dangerous_call(source, str(args.get("sql") or "")),
+                  "timeout_s": seconds},
     )
 
 
diff --git a/backend/app/tools/mcp_manager.py b/backend/app/tools/mcp_manager.py
index cf39313b..6e16071c 100644
--- a/backend/app/tools/mcp_manager.py
+++ b/backend/app/tools/mcp_manager.py
@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import logging
+import time
 from typing import Any
 
 from langchain_core.tools import BaseTool
@@ -24,64 +26,110 @@ def _server_config(row: McpServer) -> dict[str, Any]:
     }
 
 
+def _config_key(row: McpServer) -> str:
+    """一个服务的连接配置，缓存据此判断手上的工具是不是按现在这份配置建的。"""
+    return json.dumps(_server_config(row), sort_keys=True, ensure_ascii=False)
+
+
 class McpManager:
     """管理外部 MCP server 的连接与工具缓存。
 
     工具在图里用 `mcp:<server>/<tool>` 引用。连接是懒建立的，
     并且按 server 缓存，避免每个节点都去重新拉起一次 stdio 子进程。
+
+    缓存按服务逐个补、逐个作废。以前只在「一个都没加载过」时整批建一次：改了
+    启动命令，运行照样用旧命令建出来的工具；删掉的服务照样调得到；缓存建好之后
+    新加的服务，工具列表里一直没有它，除非有人去点刷新。现在每次取工具都先对一遍
+    库里启用着的服务：缺的连上，配置变了的重连，删了、停用了的不再交出去。
     """
 
     def __init__(self) -> None:
         self._tools: dict[str, list[BaseTool]] = {}  # server name -> tools
+        #: 每个服务的工具是按哪份连接配置建的（_config_key）
+        self._built_from: dict[str, str] = {}
         self._lock = asyncio.Lock()
 
-    async def _load_servers(self) -> list[McpServer]:
+    def invalidate(self, *names: str) -> None:
+        """服务改了、删了：丢掉按旧配置建的工具，下次用到时再连。"""
+        for name in names:
+            self._tools.pop(name, None)
+            self._built_from.pop(name, None)
+
+    def _fresh(self, row: McpServer) -> bool:
+        return row.name in self._tools and self._built_from.get(row.name) == _config_key(row)
+
+    async def _load_servers(self, names: list[str] | None = None) -> list[McpServer]:
         async with SessionLocal() as session:
-            rows = await session.execute(select(McpServer).where(McpServer.enabled.is_(True)))
+            query = select(McpServer).where(McpServer.enabled.is_(True))
+            if names is not None:
+                query = query.where(McpServer.name.in_(names))
+            rows = await session.execute(query)
             return list(rows.scalars())
 
-    async def _connect(self, rows: list[McpServer]) -> dict[str, list[BaseTool]]:
+    async def _connect(self, rows: list[McpServer]) -> None:
         from langchain_mcp_adapters.client import MultiServerMCPClient
 
-        out: dict[str, list[BaseTool]] = {}
         for row in rows:
+            key = _config_key(row)
+            started = time.perf_counter()
             try:
                 client = MultiServerMCPClient({row.name: _server_config(row)})
-                tools = await asyncio.wait_for(client.get_tools(), timeout=30)
-                out[row.name] = list(tools)
-                await self._mark(row.id, "ok", None, [t.name for t in tools])
+                tools = list(await asyncio.wait_for(client.get_tools(), timeout=30))
+                status, error = "ok", None
             except Exception as e:  # noqa: BLE001 - 一个 server 挂了不影响其他的
                 logger.warning("MCP server %s 连接失败: %s", row.name, e)
-                out[row.name] = []
-                await self._mark(row.id, "error", _reason(e), [])
-        return out
+                tools, status, error = [], "error", _reason(e, row.command)
+            # 连不上也缓存成空：不然每次取工具都要再等一轮 30 秒超时。改配置或刷新时重连
+            self._tools[row.name] = tools
+            self._built_from[row.name] = key
+            await self._mark(row.id, key, status, error, [t.name for t in tools], started)
 
     async def _mark(
-        self, server_id: str, status: str, error: str | None, tool_names: list[str]
+        self, server_id: str, key: str, status: str, error: str | None, tool_names: list[str],
+        started: float,
     ) -> None:
+        from app.api.health import record
+
         async with SessionLocal() as session:
             row = await session.get(McpServer, server_id)
-            if row:
+            # 连到一半服务被改了：这次连的是旧配置，它的结论不能盖掉改完之后的「未检查」
+            if row and _config_key(row) == key:
                 row.status = status
                 row.last_error = error
                 row.tools_cache = tool_names
+                # 加载工具本身就是一次连接：记下来，工具页不用再单独测一次才知道
+                row.last_check = record(
+                    status == "ok", int((time.perf_counter() - started) * 1000), error)
                 await session.commit()
 
+    async def _ensure(self, rows: list[McpServer]) -> None:
+        """rows 里还没连过、或者是按旧配置连的，连一次补上。"""
+        if all(self._fresh(r) for r in rows):
+            return
+        async with self._lock:
+            # 等锁的时候别人可能已经连好了
+            stale = [r for r in rows if not self._fresh(r)]
+            if stale:
+                await self._connect(stale)
+
     async def refresh(self) -> dict[str, list[str]]:
+        """全部重连一遍（服务端的工具变了，配置没变时用）。"""
         async with self._lock:
             rows = await self._load_servers()
-            self._tools = await self._connect(rows)
-        return {name: [t.name for t in tools] for name, tools in self._tools.items()}
+            self.invalidate(*(set(self._tools) - {r.name for r in rows}))
+            await self._connect(rows)
+        return {r.name: [t.name for t in self._tools.get(r.name, [])] for r in rows}
 
     async def ensure_loaded(self) -> None:
-        if not self._tools:
-            await self.refresh()
+        await self._ensure(await self._load_servers())
 
     async def list_tools(self) -> list[dict[str, Any]]:
-        await self.ensure_loaded()
+        rows = await self._load_servers()
+        await self._ensure(rows)
         out: list[dict[str, Any]] = []
-        for server, tools in self._tools.items():
-            for tool in tools:
+        for row in rows:
+            server = row.name
+            for tool in self._tools.get(server, []):
                 out.append(
                     {
                         "id": f"mcp:{server}/{tool.name}",
@@ -97,13 +145,21 @@ class McpManager:
         return out
 
     async def get_tools(self, refs: list[str]) -> list[BaseTool]:
-        """按 `mcp:<server>/<tool>` 取工具；`mcp:<server>/*` 表示该 server 全部工具。"""
-        await self.ensure_loaded()
-        wanted: list[BaseTool] = []
+        """按 `mcp:<server>/<tool>` 取工具；`mcp:<server>/*` 表示该 server 全部工具。
+
+        只交出库里还在、并且启用着的服务的工具：删了、停用了的，缓存里就算还有也不给。
+        """
+        parsed = []
         for ref in refs:
             body = ref[4:] if ref.startswith("mcp:") else ref
             server, _, tool_name = body.partition("/")
-            tools = self._tools.get(server, [])
+            parsed.append((server, tool_name))
+        rows = await self._load_servers(sorted({server for server, _ in parsed}))
+        await self._ensure(rows)
+        live = {r.name for r in rows}
+        wanted: list[BaseTool] = []
+        for server, tool_name in parsed:
+            tools = self._tools.get(server, []) if server in live else []
             if tool_name in ("", "*"):
                 wanted.extend(tools)
                 continue
@@ -127,20 +183,22 @@ class McpManager:
                 ],
             }
         except Exception as e:  # noqa: BLE001
-            from app.api.errors import raw
+            from app.core.errors import raw
 
-            return {"ok": False, "error": _reason(e), "detail": raw(e)}
+            return {"ok": False, "error": _reason(e, row.command), "detail": raw(e)}
 
 
-def _reason(e: BaseException) -> str:
+def _reason(e: BaseException, command: str | None = None) -> str:
     """连不上 MCP 服务的原因，写成工具页上看得懂的话。
 
     最常见的两种：命令不存在（没装 npx / uvx）和超时（进程起来了但不讲 MCP）。
     """
-    from app.api.errors import explain
+    from app.core.errors import explain
 
     if isinstance(e, FileNotFoundError):
-        return f"启动不了：找不到命令 {e.filename or ''}。确认它已安装、并且在后端的 PATH 里"
+        # stdio 客户端抛的这个异常常常不带文件名，只剩「找不到命令 」半句：补上配置的命令
+        missing = e.filename or command or ""
+        return f"启动不了：找不到命令 {missing}。确认它已安装、并且在后端的 PATH 里"
     if isinstance(e, asyncio.TimeoutError):
         return "连上了但 30 秒内没有应答：确认这个命令启动的是 MCP 服务，参数有没有写错"
     reason, hint = explain(e)
diff --git a/backend/app/tools/registry.py b/backend/app/tools/registry.py
index 82c8d90a..d4cd7a99 100644
--- a/backend/app/tools/registry.py
+++ b/backend/app/tools/registry.py
@@ -166,6 +166,14 @@ async def build_tools(
     return tools
 
 
+class ToolBuildError(ValueError):
+    """绑定的工具建不出来：它自己的配置写坏了（比如自定义工具的参数定义）。
+
+    message 直接给人看：是哪个工具、坏在哪、去哪里改。节点据此报一句清楚的错，
+    而不是让 schema 转换在半路炸出一句「'str' object has no attribute 'get'」。
+    """
+
+
 class ToolArgsError(ValueError):
     """工具参数对不上 schema。
 
diff --git a/backend/tests/test_api_messages.py b/backend/tests/test_api_messages.py
index 6b6a69ef..b2295684 100644
--- a/backend/tests/test_api_messages.py
+++ b/backend/tests/test_api_messages.py
@@ -38,7 +38,7 @@ def _clean(text: str) -> None:
 def test_common_failures_are_put_in_plain_words():
     import httpx
 
-    from app.api.errors import explain, graph_error, raw
+    from app.core.errors import explain, graph_error, raw
 
     reason, hint = explain(httpx.ConnectError("[Errno 61] Connection refused"))
     assert "连不上" in reason and hint
diff --git a/backend/tests/test_conversation_status.py b/backend/tests/test_conversation_status.py
new file mode 100644
index 00000000..3b37ca5a
--- /dev/null
+++ b/backend/tests/test_conversation_status.py
@@ -0,0 +1,195 @@
+"""会话列表认得每个会话的最后一轮停在哪；轮次的可信度元数据有自己的一列。
+
+以前左栏只能给「这次打开页面以来取回过内存」的会话标状态。没打开过的会话，
+哪怕最后一轮正停在审批上、或者已经失败，列表里也和正常完成的长得一样——
+人得一个个点进去才知道哪里在等他。
+
+元数据（出具档位、运行类别、未查库、结局、耗时…）以前挂在 review.meta 下，
+于是没复核过的轮次 review 也不为空，「没复核过」和「复核过、没问题」分不开。
+"""
+from __future__ import annotations
+
+from datetime import timedelta
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.db.base import SessionLocal, utcnow
+from app.db.models import Approval, ConversationTurn, Run
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+async def _conversation(client, title: str) -> str:
+    r = await client.post("/api/conversations", json={"kind": "chat", "title": title})
+    assert r.status_code == 201, r.text
+    return r.json()["id"]
+
+
+async def _turn(client, conv_id: str, question: str = "订单数多少", **patch) -> dict:
+    r = await client.post(f"/api/conversations/{conv_id}/turns", json={"question": question})
+    assert r.status_code == 201, r.text
+    turn = r.json()
+    if patch:
+        r = await client.patch(f"/api/conversations/{conv_id}/turns/{turn['id']}", json=patch)
+        assert r.status_code == 200, r.text
+        turn = r.json()
+    return turn
+
+
+async def _run(status: str, *, pending: bool = False) -> str:
+    async with SessionLocal() as session:
+        run = Run(workflow_name="状态测试", status=status)
+        session.add(run)
+        await session.flush()
+        if pending:
+            session.add(Approval(run_id=run.id, node_id="gate", status="pending"))
+        await session.commit()
+        return run.id
+
+
+async def _listed(client) -> dict[str, dict]:
+    r = await client.get("/api/conversations")
+    assert r.status_code == 200, r.text
+    return {c["id"]: c for c in r.json()}
+
+
+# --------------------------------------------------------------------------
+# REQ-1：meta 自己一列
+# --------------------------------------------------------------------------
+
+META = {"v": 1, "runClass": "exploratory", "noQuery": True, "ms": 8200, "queries": 0}
+
+
+async def test_turn_meta_is_stored_and_read_back_on_its_own(client):
+    conv = await _conversation(client, "元数据")
+    turn = await _turn(client, conv, meta=META, status="done", answer="12 家")
+    assert turn["meta"] == META
+    assert turn["review"] is None, "只写了 meta，review 得还是「没复核过」"
+
+    detail = (await client.get(f"/api/conversations/{conv}")).json()
+    assert detail["turns"][0]["meta"] == META
+
+
+async def test_patching_review_and_meta_do_not_overwrite_each_other(client):
+    conv = await _conversation(client, "互不覆盖")
+    turn = await _turn(client, conv, meta=META)
+    review = {"verdict": "annotated", "note": "检索降级"}
+    r = await client.patch(f"/api/conversations/{conv}/turns/{turn['id']}", json={"review": review})
+    assert r.json()["meta"] == META
+    r = await client.patch(f"/api/conversations/{conv}/turns/{turn['id']}",
+                           json={"meta": {**META, "ms": 9000}})
+    assert r.json()["review"] == review
+    assert r.json()["meta"]["ms"] == 9000
+
+
+async def test_old_turns_with_meta_under_review_still_read_as_meta(client):
+    """迁移之前写进去的：meta 挂在 review 下。读的时候由后端兜底，前端只认 turn.meta。"""
+    conv = await _conversation(client, "老数据")
+    legacy = {"verdict": "ok", "meta": {"v": 1, "outcome": "cancelled"}}
+    turn = await _turn(client, conv, review=legacy, status="error", error="已取消")
+    assert turn["meta"] == {"v": 1, "outcome": "cancelled"}
+    # 新列一旦写过就以它为准
+    r = await client.patch(f"/api/conversations/{conv}/turns/{turn['id']}", json={"meta": META})
+    assert r.json()["meta"] == META
+
+
+# --------------------------------------------------------------------------
+# REQ-2：列表里的最后一轮状态
+# --------------------------------------------------------------------------
+
+
+async def test_the_list_says_where_each_conversation_last_stopped(client):
+    cases: dict[str, tuple[str, str | None]] = {}
+
+    conv = await _conversation(client, "完成")
+    run = await _run("succeeded")
+    await _turn(client, conv, run_id=run, status="done", answer="12")
+    cases[conv] = ("done", run)
+
+    conv = await _conversation(client, "失败")
+    run = await _run("failed")
+    await _turn(client, conv, run_id=run, status="error", error="查询超时")
+    cases[conv] = ("error", run)
+
+    conv = await _conversation(client, "取消")
+    await _turn(client, conv, status="error", error="已取消")
+    cases[conv] = ("cancelled", None)
+
+    conv = await _conversation(client, "重启挂起")
+    run = await _run("interrupted")
+    await _turn(client, conv, run_id=run, status="error", error="服务重启，这一轮中断了",
+                meta={"v": 1, "outcome": "suspended", "runId": run})
+    cases[conv] = ("suspended", run)
+
+    conv = await _conversation(client, "在跑")
+    run = await _run("running")
+    await _turn(client, conv, run_id=run)
+    cases[conv] = ("running", run)
+
+    conv = await _conversation(client, "等审批")
+    run = await _run("interrupted", pending=True)
+    await _turn(client, conv, run_id=run)
+    cases[conv] = ("waiting", run)
+
+    conv = await _conversation(client, "停着没审批")
+    run = await _run("interrupted")
+    await _turn(client, conv, run_id=run)
+    cases[conv] = ("suspended", run)
+
+    conv = await _conversation(client, "页面关了但跑完了")
+    run = await _run("succeeded")
+    await _turn(client, conv, run_id=run)
+    cases[conv] = ("done", run)
+
+    conv = await _conversation(client, "页面关了而且失败了")
+    run = await _run("failed")
+    await _turn(client, conv, run_id=run)
+    cases[conv] = ("error", run)
+
+    conv = await _conversation(client, "正在建图")
+    await _turn(client, conv)
+    cases[conv] = ("running", None)
+
+    listed = await _listed(client)
+    got = {cid: (listed[cid]["last_status"], listed[cid]["last_run_id"]) for cid in cases}
+    assert got == cases
+
+
+async def test_only_the_last_turn_counts(client):
+    conv = await _conversation(client, "后来好了")
+    await _turn(client, conv, status="error", error="查询超时")
+    run = await _run("succeeded")
+    await _turn(client, conv, run_id=run, status="done", answer="好了")
+    assert (await _listed(client))[conv]["last_status"] == "done"
+
+
+async def test_a_build_abandoned_long_ago_is_not_shown_as_running(client):
+    """建图是跟着浏览器那条流走的：页面关了就没了，轮次却一直停在 running。"""
+    conv = await _conversation(client, "建到一半关了")
+    turn = await _turn(client, conv)
+    async with SessionLocal() as session:
+        row = await session.get(ConversationTurn, turn["id"])
+        row.updated_at = utcnow() - timedelta(hours=2)
+        await session.commit()
+    assert (await _listed(client))[conv]["last_status"] == "error"
+
+
+async def test_an_empty_conversation_has_no_status(client):
+    conv = await _conversation(client, "空的")
+    item = (await _listed(client))[conv]
+    assert item["last_status"] is None and item["last_run_id"] is None
+
+
+async def test_the_detail_carries_the_same_status(client):
+    conv = await _conversation(client, "详情也带")
+    run = await _run("interrupted", pending=True)
+    await _turn(client, conv, run_id=run)
+    detail = (await client.get(f"/api/conversations/{conv}")).json()
+    assert (detail["last_status"], detail["last_run_id"]) == ("waiting", run)
diff --git a/backend/tests/test_copilot_merge.py b/backend/tests/test_copilot_merge.py
new file mode 100644
index 00000000..1e24fd1e
--- /dev/null
+++ b/backend/tests/test_copilot_merge.py
@@ -0,0 +1,497 @@
+"""助手改节点是合并，不是整体替换；工具绑定变了要说出来。
+
+起因是一次真实运行：助手用 update_node 改写了一个查库的 agent 和一个协作团队。
+协议写的是「config 整体替换」，模型只写了要改的提示词、没写 tools，
+于是三个要查库的 agent 全部丢了工具——查库的 agent 只能写「假设调用工具」，
+协作成员把模型自带的工具调用标记当文字吐了 4 轮，最后一堆原始标记被当成答案
+交了出去，数据库一次都没查。
+
+这里守三件事：
+1. update_node 只写要改的字段，没写的保留；显式写 null 才删。协作成员按 name
+   合并，成员条目里没写 tools 的保留它原来的 tools。
+2. 给模型看的协议文案和合并语义一致，不再说「整体替换」。
+3. 改完之后工具集合变小、而指令里没让删工具的，自查给 warning，final 里带
+   「工具绑定变化」的回执。
+
+示例图全是通用名（db_query__shop、orders），不含任何真实库名。
+"""
+from __future__ import annotations
+
+import copy
+import json
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+QUERY_TOOLS = ["db_query__shop", "db_schema__shop"]
+
+#: 第 1 轮搭好的图：一个查库的 agent，一个带成员的协作团队。工具都绑好了
+ROUND_ONE = {
+    "nodes": [
+        {"id": "start", "type": "input", "position": {"x": 0, "y": 0},
+         "data": {"label": "输入", "config": {}}},
+        {"id": "query_data", "type": "agent", "position": {"x": 300, "y": 0},
+         "data": {"label": "数据查询", "config": {
+             "system": "你是取数助手。",
+             "prompt": "查 orders 表里每个门店的订单数",
+             "tools": list(QUERY_TOOLS),
+             "assign_to": "rows",
+         }}},
+        {"id": "review_team", "type": "supervisor", "position": {"x": 600, "y": 0},
+         "data": {"label": "复核团队", "config": {
+             "goal": "核对订单数",
+             "agents": [
+                 {"name": "取数员", "description": "负责查库", "system": "只用 SQL 取数",
+                  "tools": ["db_query__shop"]},
+                 {"name": "撰稿员", "description": "写结论", "system": "写一段结论",
+                  "tools": []},
+             ],
+             "max_rounds": 4,
+         }}},
+        {"id": "out", "type": "output", "position": {"x": 900, "y": 0},
+         "data": {"label": "成果", "config": {
+             "fields": [{"name": "answer", "value": "{{ vars.rows }}"}]}}},
+    ],
+    "edges": [
+        {"source": "start", "target": "query_data"},
+        {"source": "query_data", "target": "review_team"},
+        {"source": "review_team", "target": "out"},
+    ],
+}
+
+#: 第 2 轮模型实际发的：两条 update_node，都只写了提示词，没写 tools
+ROUND_TWO_OPS = [
+    {"op": "plan", "summary": "沿用上一轮的图，按月份拆"},
+    {"op": "update_node", "id": "query_data", "label": "数据查询",
+     "config": {"system": "你是取数助手，按月份汇总。", "prompt": "按月份统计 orders 的订单数"}},
+    {"op": "update_node", "id": "review_team",
+     "config": {"goal": "核对按月的订单数",
+                "agents": [{"name": "取数员", "system": "按月份取数"},
+                           {"name": "撰稿员", "system": "按月写结论"}]}},
+    {"op": "done", "explanation": "改成按月份统计", "run": True},
+]
+
+
+class _Scripted:
+    """第一轮吐 first；收到自查请求时吐 fix（默认什么都不改）。"""
+
+    def __init__(self, first: list[dict], fix: list[dict] | None = None) -> None:
+        self.first = [json.dumps(o, ensure_ascii=False) for o in first]
+        self.fix = [json.dumps(o, ensure_ascii=False) for o in (fix or [{"op": "done"}])]
+        self.calls: list[str] = []
+
+    async def astream(self, messages):
+        from langchain_core.messages import AIMessageChunk
+
+        human = next(text for role, text in messages if role == "human")
+        self.calls.append(human)
+        for line in (self.fix if "上线前自查" in human else self.first):
+            yield AIMessageChunk(content=line + "\n")
+
+
+async def _stream(client, monkeypatch, model, body: dict) -> list[dict]:
+    import app.api.copilot as copilot
+
+    async def _model(*_a, **_k):
+        return model, "mock-fast"
+
+    monkeypatch.setattr(copilot, "get_chat_model", _model)
+    events: list[dict] = []
+    async with client.stream("POST", "/api/copilot/generate-stream", json=body) as r:
+        assert r.status_code == 200, await r.aread()
+        async for line in r.aiter_lines():
+            if line.startswith("data: "):
+                events.append(json.loads(line[6:]))
+    return events
+
+
+def _node(graph: dict, node_id: str) -> dict:
+    return next(n for n in graph["nodes"] if n["id"] == node_id)
+
+
+def _config(graph: dict, node_id: str) -> dict:
+    return _node(graph, node_id)["data"]["config"]
+
+
+def _member(graph: dict, node_id: str, name: str) -> dict:
+    return next(a for a in _config(graph, node_id)["agents"] if a["name"] == name)
+
+
+async def _chat_with_round_one(client) -> str:
+    r = await client.post("/api/conversations", json={"kind": "chat"})
+    conv_id = r.json()["id"]
+    r = await client.post(f"/api/conversations/{conv_id}/turns", json={"question": "每个门店多少单"})
+    turn_id = r.json()["id"]
+    r = await client.patch(f"/api/conversations/{conv_id}/turns/{turn_id}", json={
+        "graph": ROUND_ONE, "answer": "一共 12 家店", "status": "done",
+    })
+    assert r.status_code == 200, r.text
+    return conv_id
+
+
+# --------------------------------------------------------------------------
+# 1. 还原那次运行：问数据页的追问，模型只发了不带 tools 的 update_node
+# --------------------------------------------------------------------------
+
+
+async def test_a_follow_up_that_rewrites_prompts_keeps_every_tool(client, monkeypatch):
+    conv_id = await _chat_with_round_one(client)
+    events = await _stream(client, monkeypatch, _Scripted(ROUND_TWO_OPS), {
+        "instruction": "按月份拆一下", "intent": "answer", "conversation_id": conv_id,
+    })
+    final = events[-1]
+    assert final["op"] == "final", final
+    graph = final["graph"]
+
+    agent = _config(graph, "query_data")
+    assert agent["tools"] == QUERY_TOOLS, "只改提示词不能把工具改没了"
+    assert agent["assign_to"] == "rows", "没写的键要保留"
+    assert agent["prompt"] == "按月份统计 orders 的订单数", "写了的键要真的改上去"
+
+    team = _config(graph, "review_team")
+    assert team["goal"] == "核对按月的订单数"
+    assert team["max_rounds"] == 4
+    fetcher = _member(graph, "review_team", "取数员")
+    assert fetcher["tools"] == ["db_query__shop"], "成员条目没写 tools，要保留成员原来的"
+    assert fetcher["system"] == "按月份取数"
+    assert fetcher["description"] == "负责查库", "成员没写的字段也保留"
+    assert [a["name"] for a in team["agents"]] == ["取数员", "撰稿员"]
+
+    # 工具一个都没变：回执是空的，也不该有「工具被删了」的警告
+    assert final["tool_changes"] == []
+    assert not [i for i in final["issues"] if i.get("code") == "tools_dropped"]
+
+
+async def test_the_same_edit_on_the_canvas_keeps_every_tool(client, monkeypatch):
+    """画布那条路径（带 base_graph）是同一套合并。"""
+    events = await _stream(client, monkeypatch, _Scripted(ROUND_TWO_OPS), {
+        "instruction": "按月份拆一下", "base_graph": copy.deepcopy(ROUND_ONE),
+    })
+    final = events[-1]
+    assert final["op"] == "final", final
+    assert _config(final["graph"], "query_data")["tools"] == QUERY_TOOLS
+    assert _member(final["graph"], "review_team", "取数员")["tools"] == ["db_query__shop"]
+    assert final["tool_changes"] == []
+
+
+async def test_the_streamed_update_op_is_forwarded_as_the_model_wrote_it(client, monkeypatch):
+    """转给前端的操作不改写：前端按同一套合并规则自己落到画布上。"""
+    events = await _stream(client, monkeypatch, _Scripted(ROUND_TWO_OPS), {
+        "instruction": "按月份拆一下", "base_graph": copy.deepcopy(ROUND_ONE),
+    })
+    ups = [e for e in events if e.get("op") == "update_node"]
+    assert [u["id"] for u in ups] == ["query_data", "review_team"]
+    assert "tools" not in ups[0]["config"]
+
+
+# --------------------------------------------------------------------------
+# 2. 合并规则本身
+# --------------------------------------------------------------------------
+
+
+def _apply(graph: dict, op: dict) -> dict[str, dict]:
+    from app.api.copilot import _apply_op
+
+    nodes = {n["id"]: copy.deepcopy(n) for n in graph["nodes"]}
+    edges = copy.deepcopy(graph["edges"])
+    assert _apply_op(nodes, edges, op) is True
+    return nodes
+
+
+def test_null_deletes_a_key_and_unmentioned_keys_stay():
+    nodes = _apply(ROUND_ONE, {"op": "update_node", "id": "query_data",
+                               "config": {"assign_to": None, "temperature": 0.2}})
+    cfg = nodes["query_data"]["data"]["config"]
+    assert "assign_to" not in cfg
+    assert cfg["temperature"] == 0.2
+    assert cfg["tools"] == QUERY_TOOLS
+    assert cfg["prompt"] == "查 orders 表里每个门店的订单数"
+
+
+def test_explicit_tools_replace_the_old_list():
+    nodes = _apply(ROUND_ONE, {"op": "update_node", "id": "query_data",
+                               "config": {"tools": ["db_query__shop"]}})
+    assert nodes["query_data"]["data"]["config"]["tools"] == ["db_query__shop"]
+
+
+def test_members_merge_by_name_and_can_be_added_or_removed():
+    nodes = _apply(ROUND_ONE, {"op": "update_node", "id": "review_team", "config": {"agents": [
+        {"name": "撰稿员", "remove": True},
+        {"name": "核对员", "description": "复核口径", "tools": ["db_schema__shop"]},
+        {"name": "取数员", "tools": None},
+    ]}})
+    agents = nodes["review_team"]["data"]["config"]["agents"]
+    assert [a["name"] for a in agents] == ["取数员", "核对员"], "原有成员保持原来的顺序，新成员接在后面"
+    assert "tools" not in agents[0], "成员字段写 null 才删"
+    assert agents[0]["system"] == "只用 SQL 取数"
+    assert agents[1]["tools"] == ["db_schema__shop"]
+
+
+def test_merging_builds_a_new_config_instead_of_editing_the_old_one():
+    """合并出来的 config 是新的：改之前的那份还要拿去比对工具变化。"""
+    from app.api.copilot import _apply_op
+
+    base = copy.deepcopy(ROUND_ONE)
+    nodes = {n["id"]: n for n in base["nodes"]}
+    old = nodes["review_team"]["data"]["config"]
+    snapshot = copy.deepcopy(old)
+    _apply_op(nodes, [], {"op": "update_node", "id": "review_team",
+                          "config": {"goal": "换个目标", "agents": [{"name": "取数员", "tools": []}]}})
+    assert old == snapshot, "旧 config（连同成员）被原地改掉了"
+    assert nodes["review_team"]["data"]["config"]["agents"][0]["tools"] == []
+
+
+def test_label_only_updates_leave_the_config_alone():
+    nodes = _apply(ROUND_ONE, {"op": "update_node", "id": "query_data", "label": "取数"})
+    assert nodes["query_data"]["data"]["label"] == "取数"
+    assert nodes["query_data"]["data"]["config"]["tools"] == QUERY_TOOLS
+
+
+# --------------------------------------------------------------------------
+# 3. 协议文案和合并语义一致
+# --------------------------------------------------------------------------
+
+
+def test_the_protocol_no_longer_tells_the_model_to_replace_the_whole_config():
+    from app.api.copilot import _STREAM_PROTOCOL, _repair_request
+
+    assert "整体替换" not in _STREAM_PROTOCOL
+    assert "只写要改的" in _STREAM_PROTOCOL
+    assert "null" in _STREAM_PROTOCOL, "删键的写法要告诉模型"
+    assert "name" in _STREAM_PROTOCOL and "remove" in _STREAM_PROTOCOL, "成员按 name 合并、怎么删成员要写清"
+
+    nodes = {n["id"]: copy.deepcopy(n) for n in ROUND_ONE["nodes"]}
+
+    issue = {"level": "error", "node_id": "query_data", "message": "缺了点什么", "field": None}
+    text = _repair_request(nodes, list(ROUND_ONE["edges"]), [issue])
+    assert "整体替换" not in text and "完整的 config" not in text
+    assert "只写要改的" in text
+
+
+# --------------------------------------------------------------------------
+# 4. 工具集合变小了：自查报 warning，回执列出变化
+# --------------------------------------------------------------------------
+
+
+async def test_dropping_tools_without_being_asked_is_called_out(client, monkeypatch):
+    ops = [
+        {"op": "plan", "summary": "改提示词"},
+        {"op": "update_node", "id": "query_data", "config": {"prompt": "简短一点", "tools": []}},
+        {"op": "update_node", "id": "review_team",
+         "config": {"agents": [{"name": "取数员", "tools": []}]}},
+        {"op": "done", "explanation": "改短了"},
+    ]
+    events = await _stream(client, monkeypatch, _Scripted(ops), {
+        "instruction": "提示词写短一点", "base_graph": copy.deepcopy(ROUND_ONE),
+    })
+    final = events[-1]
+    assert final["op"] == "final", final
+
+    changes = {(c["node_id"], c.get("member")): c for c in final["tool_changes"]}
+    agent = changes[("query_data", None)]
+    assert agent["before"] == QUERY_TOOLS and agent["after"] == []
+    assert agent["removed"] == QUERY_TOOLS and agent["added"] == []
+    assert agent["label"] == "数据查询"
+    member = changes[("review_team", "取数员")]
+    assert member["before"] == ["db_query__shop"] and member["after"] == []
+
+    dropped = [i for i in final["issues"] if i.get("code") == "tools_dropped"]
+    assert {i["node_id"] for i in dropped} == {"query_data", "review_team"}
+    assert all(i["level"] == "warning" for i in dropped)
+    text = next(i["message"] for i in dropped if i["node_id"] == "query_data")
+    assert "数据查询" in text and "db_query__shop、db_schema__shop" in text and "变成了空" in text
+    text = next(i["message"] for i in dropped if i["node_id"] == "review_team")
+    assert "取数员" in text and "db_query__shop" in text
+
+    # 自查那一步也要说出来，不能只埋在 final 里
+    check = next(e for e in events if e.get("op") == "check" and e["status"] in ("passed", "failed"))
+    assert {w["node_id"] for w in check["warnings"]} == {"query_data", "review_team"}
+
+
+async def test_dropping_tools_on_request_is_listed_but_not_warned(client, monkeypatch):
+    ops = [
+        {"op": "update_node", "id": "query_data", "config": {"tools": ["db_query__shop"]}},
+        {"op": "done", "explanation": "去掉了查表结构"},
+    ]
+    events = await _stream(client, monkeypatch, _Scripted(ops), {
+        "instruction": "数据查询节点去掉查表结构的工具", "base_graph": copy.deepcopy(ROUND_ONE),
+    })
+    final = events[-1]
+    assert [(c["node_id"], c["removed"]) for c in final["tool_changes"]] == [
+        ("query_data", ["db_schema__shop"])]
+    assert not [i for i in final["issues"] if i.get("code") == "tools_dropped"]
+
+
+async def test_swapping_one_tool_for_another_is_listed_but_not_warned(client, monkeypatch):
+    ops = [
+        {"op": "update_node", "id": "query_data",
+         "config": {"tools": ["db_query__sales", "db_schema__sales"]}},
+        {"op": "done", "explanation": "换到 sales"},
+    ]
+    events = await _stream(client, monkeypatch, _Scripted(ops), {
+        "instruction": "改成查 sales 库", "base_graph": copy.deepcopy(ROUND_ONE),
+    })
+    final = events[-1]
+    change = final["tool_changes"][0]
+    assert change["added"] == ["db_query__sales", "db_schema__sales"]
+    assert change["removed"] == QUERY_TOOLS
+    assert not [i for i in final["issues"] if i.get("code") == "tools_dropped"]
+
+
+async def test_a_fresh_build_has_no_tool_changes(client, monkeypatch):
+    ops = [
+        {"op": "add_node", "node": {"id": "start", "type": "input", "label": "输入", "config": {}}},
+        {"op": "add_node", "node": {"id": "out", "type": "output", "label": "成果", "config": {}}},
+        {"op": "add_edge", "edge": {"source": "start", "target": "out"}},
+        {"op": "done", "explanation": "空壳"},
+    ]
+    events = await _stream(client, monkeypatch, _Scripted(ops), {"instruction": "随便搭一个"})
+    assert events[-1]["tool_changes"] == []
+
+
+async def test_the_one_shot_generate_reports_tool_changes_too(client, monkeypatch):
+    """非流式的 /generate 交回的是整张新图：照样比对、照样提醒。"""
+    import app.api.copilot as copilot
+
+    rewritten = copy.deepcopy(ROUND_ONE)
+    del _config(rewritten, "query_data")["tools"]
+    raw = {
+        "explanation": "改了提示词",
+        "nodes": [{"id": n["id"], "type": n["type"], "label": n["data"]["label"],
+                   "config": n["data"]["config"]} for n in rewritten["nodes"]],
+        "edges": rewritten["edges"],
+    }
+
+    class _OneShot:
+        def with_structured_output(self, *_a, **_k):
+            return self
+
+        async def ainvoke(self, _messages):
+            return raw
+
+    async def _model(*_a, **_k):
+        return _OneShot(), "mock-fast"
+
+    monkeypatch.setattr(copilot, "get_chat_model", _model)
+    r = await client.post("/api/copilot/generate", json={
+        "instruction": "提示词写短一点", "base_graph": copy.deepcopy(ROUND_ONE),
+    })
+    assert r.status_code == 200, r.text
+    body = r.json()
+    assert [(c["node_id"], c["after"]) for c in body["tool_changes"]] == [("query_data", [])]
+    assert [i["node_id"] for i in body["issues"] if i.get("code") == "tools_dropped"] == ["query_data"]
+
+
+# --------------------------------------------------------------------------
+# 5. 「指令里让没让删工具」得看删的是不是工具，不能见词就算
+# --------------------------------------------------------------------------
+#
+# 以前只要指令里某处有「不要 / 不用 / 取消」、另一处有「工具」就当成让删了。
+# 可出事之后用户最可能的追问恰恰是「这次要真的用工具查库，不要编造数字」——
+# 两个词都在，警告被关掉，没工具的图照样自动运行。
+
+
+def _dropped(instruction: str, *, query: list[str], fetcher: list[str] | None = None) -> set[str]:
+    """把数据查询的工具改成 query（取数员改成 fetcher），看哪些节点会报 tools_dropped。"""
+    from app.api.copilot import dropped_tool_warnings, tool_changes
+
+    after = copy.deepcopy(ROUND_ONE)
+    _config(after, "query_data")["tools"] = query
+    if fetcher is not None:
+        _member(after, "review_team", "取数员")["tools"] = fetcher
+    warnings = dropped_tool_warnings(tool_changes(ROUND_ONE["nodes"], after["nodes"]), instruction)
+    assert all(w["code"] == "tools_dropped" and w["level"] == "warning" for w in warnings)
+    return {w["node_id"] for w in warnings}
+
+
+@pytest.mark.parametrize("instruction", [
+    "把 system 改成英文，不用改工具",
+    "这次要真的用工具查库，不要编造数字",
+    "数据查询要真的用工具查库，不要编造数字",
+    "取消复核团队，工具保留",
+    "别用假设的方式，必须调用工具",
+    "别用假设的方式调用工具",
+    "不要把工具去掉，提示词短一点",
+    "千万别删除工具",
+    "工具不用动，按月份拆",
+    "去掉提示词里的废话然后让它调用工具",
+    "don't remove any tools, just make the prompt shorter",
+    "answer without making up numbers, use the tools",
+])
+def test_asking_to_keep_or_use_tools_still_warns_when_they_vanish(instruction):
+    assert _dropped(instruction, query=[], fetcher=[]) == {"query_data", "review_team"}
+
+
+@pytest.mark.parametrize("instruction", [
+    "去掉查表结构的工具",
+    "数据查询节点去掉查表结构的工具",
+    "不要用 db_schema__shop",
+    "把查表结构的工具去掉",
+    "db_schema__shop 不要了",
+    "查表结构那个工具也删了吧",
+    "remove the schema tool",
+    "drop db_schema__shop from the query node",
+])
+def test_asking_to_drop_a_tool_is_not_warned(instruction):
+    assert _dropped(instruction, query=["db_query__shop"]) == set()
+
+
+def test_naming_one_tool_does_not_excuse_losing_the_others():
+    """点名删 db_schema__shop，模型却把 db_query__shop 也删了：少掉的那个没人要求。"""
+    assert _dropped("去掉 db_schema__shop", query=[]) == {"query_data"}
+    assert _dropped("去掉 db_schema__shop", query=["db_query__shop"]) == set()
+
+
+def test_keeping_only_some_tools_counts_as_asking_to_drop_the_rest():
+    assert _dropped("数据查询只保留 db_query__shop", query=["db_query__shop"]) == set()
+    # 「只保留」的那个也没了，就不是用户要的
+    assert _dropped("数据查询只保留 db_query__shop", query=[]) == {"query_data"}
+    assert _dropped("只保留查库的工具", query=["db_query__shop"]) == set()
+    assert _dropped("只保留查库的工具", query=[]) == {"query_data"}
+
+
+def test_deleting_some_other_field_is_not_asking_to_drop_tools():
+    assert _dropped("去掉 assign_to", query=[]) == {"query_data"}
+    assert _dropped("删除取数员的 description", query=[], fetcher=[]) == {"query_data", "review_team"}
+
+
+def _resend_everything_without_tools() -> list[dict]:
+    """问数据页的追问：模型把整张图用 add_node 重发了一遍，每个节点都没写 tools。"""
+    ops: list[dict] = [{"op": "plan", "summary": "重搭一遍"}]
+    for n in ROUND_ONE["nodes"]:
+        cfg = copy.deepcopy(n["data"]["config"])
+        cfg.pop("tools", None)
+        for member in cfg.get("agents") or []:
+            member.pop("tools", None)
+        ops.append({"op": "add_node", "node": {"id": n["id"], "type": n["type"],
+                                               "label": n["data"]["label"], "config": cfg}})
+    ops += [{"op": "add_edge", "edge": e} for e in ROUND_ONE["edges"]]
+    ops.append({"op": "done", "explanation": "按要求重搭", "run": True})
+    return ops
+
+
+async def test_a_chat_follow_up_that_loses_every_tool_is_called_out(client, monkeypatch):
+    conv_id = await _chat_with_round_one(client)
+    events = await _stream(client, monkeypatch, _Scripted(_resend_everything_without_tools()), {
+        "instruction": "这次要真的用工具查库，不要编造数字", "intent": "answer",
+        "conversation_id": conv_id,
+    })
+    final = events[-1]
+    assert final["op"] == "final", final
+    lost = {(c["node_id"], c["member"]) for c in final["tool_changes"]}
+    assert lost == {("query_data", None), ("review_team", "取数员")}
+
+    dropped = [i for i in final["issues"] if i.get("code") == "tools_dropped"]
+    assert {i["node_id"] for i in dropped} == {"query_data", "review_team"}
+    check = next(e for e in events if e.get("op") == "check" and e["status"] in ("passed", "failed"))
+    assert {w["node_id"] for w in check["warnings"]} == {"query_data", "review_team"}
diff --git a/backend/tests/test_copilot_scope.py b/backend/tests/test_copilot_scope.py
new file mode 100644
index 00000000..d0ed604e
--- /dev/null
+++ b/backend/tests/test_copilot_scope.py
@@ -0,0 +1,197 @@
+"""问数据时可以把这一轮限定在某几个数据源上。
+
+问数据页的数据源标签要能「点一下，这次只查这个库」。以前助手每一轮都看得到
+全部数据源，追问时还会沿用上一轮接的那个库——用户明明想换一个库问，得到的
+还是旧库上的答案，而且说不清为什么。
+
+限定之后：给模型看的工具和结构只剩这几个库；图里用了范围外的库，按自查的
+规则交回去改，改不掉就不自动运行。
+"""
+from __future__ import annotations
+
+import json
+import sqlite3
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.db.base import SessionLocal
+from app.db.models import DataSource
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+@pytest.fixture
+async def sources(tmp_path):
+    """两个库：scope_shop（orders）和 scope_sales（sales_daily）。"""
+    made: dict[str, str] = {}
+    async with SessionLocal() as session:
+        for name, table in (("scope_shop", "orders"), ("scope_sales", "sales_daily")):
+            path = tmp_path / f"{name}.db"
+            db = sqlite3.connect(path)
+            db.execute(f"CREATE TABLE {table} (id INTEGER PRIMARY KEY, amount REAL)")
+            db.commit()
+            db.close()
+            row = DataSource(name=name, kind="sqlite", database=str(path), description=f"{table} 库",
+                             schema_cache={"tables": {table: {"qualified": table, "columns": [
+                                 {"name": "id", "type": "INTEGER"}, {"name": "amount", "type": "REAL"}]}}})
+            session.add(row)
+            await session.flush()
+            made[name] = row.id
+        await session.commit()
+    yield made
+    async with SessionLocal() as session:
+        for source_id in made.values():
+            row = await session.get(DataSource, source_id)
+            if row:
+                await session.delete(row)
+        await session.commit()
+
+
+class _Scripted:
+    def __init__(self, first: list[dict], fix: list[dict] | None = None) -> None:
+        self.first = [json.dumps(o, ensure_ascii=False) for o in first]
+        self.fix = [json.dumps(o, ensure_ascii=False) for o in (fix or [{"op": "done"}])]
+        self.systems: list[str] = []
+        self.humans: list[str] = []
+
+    async def astream(self, messages):
+        from langchain_core.messages import AIMessageChunk
+
+        self.systems.append(next(t for r, t in messages if r == "system"))
+        human = next(t for r, t in messages if r == "human")
+        self.humans.append(human)
+        for line in (self.fix if "上线前自查" in human else self.first):
+            yield AIMessageChunk(content=line + "\n")
+
+
+def _graph_using(tool: str) -> list[dict]:
+    return [
+        {"op": "add_node", "node": {"id": "start", "type": "input", "label": "输入", "config": {}}},
+        {"op": "add_node", "node": {"id": "ask", "type": "agent", "label": "查库", "config": {
+            "prompt": "{{ input.question }}", "tools": [tool], "assign_to": "answer"}}},
+        {"op": "add_edge", "edge": {"source": "start", "target": "ask"}},
+        {"op": "add_node", "node": {"id": "out", "type": "output", "label": "成果", "config": {
+            "fields": [{"name": "answer", "value": "{{ vars.answer }}"}]}}},
+        {"op": "add_edge", "edge": {"source": "ask", "target": "out"}},
+        {"op": "done", "explanation": "查一下", "run": True},
+    ]
+
+
+async def _stream(client, monkeypatch, model, body: dict) -> tuple[int, list[dict]]:
+    import app.api.copilot as copilot
+
+    async def _model(*_a, **_k):
+        return model, "mock-fast"
+
+    monkeypatch.setattr(copilot, "get_chat_model", _model)
+    events: list[dict] = []
+    async with client.stream("POST", "/api/copilot/generate-stream", json=body) as r:
+        if r.status_code != 200:
+            return r.status_code, [json.loads(await r.aread())]
+        async for line in r.aiter_lines():
+            if line.startswith("data: "):
+                events.append(json.loads(line[6:]))
+    return 200, events
+
+
+async def test_without_a_scope_the_model_sees_every_source(client, monkeypatch, sources):
+    model = _Scripted(_graph_using("db_query__scope_shop"))
+    await _stream(client, monkeypatch, model, {"instruction": "订单多少", "intent": "answer"})
+    assert "db_query__scope_shop" in model.systems[0]
+    assert "db_query__scope_sales" in model.systems[0]
+
+
+async def test_a_scope_narrows_what_the_model_sees(client, monkeypatch, sources):
+    model = _Scripted(_graph_using("db_query__scope_shop"))
+    status, events = await _stream(client, monkeypatch, model, {
+        "instruction": "订单多少", "intent": "answer", "datasource_ids": [sources["scope_shop"]],
+    })
+    assert status == 200
+    system = model.systems[0]
+    assert "db_query__scope_shop" in system and "orders" in system
+    assert "db_query__scope_sales" not in system and "sales_daily" not in system
+    assert "只查" in system and "scope_shop" in system, "限定要明说，不然模型会沿用上一轮的库"
+    final = events[-1]
+    assert final["op"] == "final" and final["autorun"] is True
+    assert not [i for i in final["issues"] if i.get("code") == "datasource_out_of_scope"]
+
+
+async def test_a_scope_can_name_sources_too(client, monkeypatch, sources):
+    model = _Scripted(_graph_using("db_query__scope_sales"))
+    await _stream(client, monkeypatch, model, {
+        "instruction": "销售额", "intent": "answer", "datasource_ids": ["scope_sales"],
+    })
+    assert "db_query__scope_sales" in model.systems[0]
+    assert "db_query__scope_shop" not in model.systems[0]
+
+
+async def test_using_a_source_outside_the_scope_is_sent_back(client, monkeypatch, sources):
+    fix = [{"op": "update_node", "id": "ask", "config": {"tools": ["db_query__scope_shop"]}},
+           {"op": "done"}]
+    model = _Scripted(_graph_using("db_query__scope_sales"), fix)
+    _, events = await _stream(client, monkeypatch, model, {
+        "instruction": "订单多少", "intent": "answer", "datasource_ids": [sources["scope_shop"]],
+    })
+    checks = [e for e in events if e.get("op") == "check"]
+    assert [c["status"] for c in checks] == ["repairing", "passed"], checks
+    out_of_scope = [i for i in checks[0]["issues"] if "scope_sales" in i["message"]]
+    assert out_of_scope, checks[0]
+    assert out_of_scope[0]["node_id"] == "ask"
+    assert out_of_scope[0]["code"] == "datasource_out_of_scope", "和 final.issues 同一个 code"
+    final = events[-1]
+    ask = next(n for n in final["graph"]["nodes"] if n["id"] == "ask")
+    assert ask["data"]["config"]["tools"] == ["db_query__scope_shop"]
+    assert final["autorun"] is True
+
+
+async def test_a_scope_that_is_never_honoured_is_not_run(client, monkeypatch, sources):
+    model = _Scripted(_graph_using("db_query__scope_sales"))
+    _, events = await _stream(client, monkeypatch, model, {
+        "instruction": "订单多少", "intent": "answer", "datasource_ids": [sources["scope_shop"]],
+    })
+    final = events[-1]
+    assert final["autorun"] is False
+    out_of_scope = [i for i in final["issues"] if i.get("code") == "datasource_out_of_scope"]
+    assert [i["node_id"] for i in out_of_scope] == ["ask"]
+    assert "scope_sales" in out_of_scope[0]["message"] and "scope_shop" in out_of_scope[0]["message"]
+
+
+async def test_a_scope_of_unknown_sources_is_refused_up_front(client, monkeypatch, sources):
+    status, body = await _stream(client, monkeypatch, _Scripted([]), {
+        "instruction": "订单多少", "intent": "answer", "datasource_ids": ["no_such_source"],
+    })
+    assert status == 400
+    detail = body[0]["detail"]
+    assert "数据源" in detail and "no_such_source" not in detail.split("：")[0]
+
+
+async def test_the_one_shot_generate_honours_the_scope(client, monkeypatch, sources):
+    import app.api.copilot as copilot
+
+    seen: list = []
+
+    class _OneShot:
+        def with_structured_output(self, *_a, **_k):
+            return self
+
+        async def ainvoke(self, messages):
+            seen.append(messages)
+            return {"nodes": [], "edges": []}
+
+    async def _model(*_a, **_k):
+        return _OneShot(), "mock-fast"
+
+    monkeypatch.setattr(copilot, "get_chat_model", _model)
+    r = await client.post("/api/copilot/generate", json={
+        "instruction": "订单多少", "datasource_ids": [sources["scope_shop"]],
+    })
+    assert r.status_code == 200, r.text
+    system = next(t for role, t in seen[0] if role == "system")
+    assert "db_query__scope_shop" in system and "db_query__scope_sales" not in system
diff --git a/backend/tests/test_copilot_selfcheck.py b/backend/tests/test_copilot_selfcheck.py
index dca7d36b..6e56e193 100644
--- a/backend/tests/test_copilot_selfcheck.py
+++ b/backend/tests/test_copilot_selfcheck.py
@@ -100,7 +100,7 @@ async def test_a_broken_condition_is_sent_back_and_fixed_before_delivery(client,
 
     checks = [e for e in events if e["op"] == "check"]
     assert [c["status"] for c in checks] == ["repairing", "passed"], checks
-    assert any("len(x)" in i for i in checks[0]["issues"]), "交回去的问题里得带着能照改的提示"
+    assert any("len(x)" in i["message"] for i in checks[0]["issues"]), "交回去的问题里得带着能照改的提示"
     assert "len(x)" in model.calls[1], "自查请求没把问题原文交给模型"
 
     final = events[-1]
@@ -138,3 +138,23 @@ async def test_template_braces_are_accepted_without_a_rework(client, monkeypatch
     final = events[-1]
     assert final["autorun"] is True
     assert any("是多余的" in i["message"] for i in final["issues"])
+
+
+async def test_check_issues_point_at_the_node_and_the_field(client, monkeypatch):
+    """自查的问题是对象，不是拼好的一行字：界面要靠 node_id 定位到卡片、靠 field
+    落到检查器里具体的输入框。以前是「「lp」循环条件写错了」，节点 id 只能从字里抠。"""
+    model = _Scripted(_graph_ops("foo(vars.items)"), _fix_ops("bar(vars.items)"))
+    events = await _generate(client, monkeypatch, model)
+
+    checks = [e for e in events if e["op"] == "check"]
+    assert [c["status"] for c in checks] == ["repairing", "repairing", "failed"], checks
+    for check in checks:
+        assert check["issues"], check
+        for issue in check["issues"]:
+            assert isinstance(issue, dict), f"自查问题还是一行字：{issue!r}"
+            assert issue["node_id"] == "lp" and issue["field"] == "condition", issue
+            assert issue["level"] == "error"
+            assert issue["message"] and not issue["message"].startswith("「"), \
+                "节点另有 node_id，消息里不该再拼一遍"
+    # 交回模型的修正请求照旧是能读的一行一条，节点 id 在前
+    assert "「lp」" in model.calls[1]
diff --git a/backend/tests/test_custom_tool_draft.py b/backend/tests/test_custom_tool_draft.py
new file mode 100644
index 00000000..55382603
--- /dev/null
+++ b/backend/tests/test_custom_tool_draft.py
@@ -0,0 +1,227 @@
+"""自定义工具没保存也能试跑；试跑和运行时走同一套参数校验；工具自己报的失败算失败。
+
+以前编辑器里的「试跑」只能跑已保存的版本：新建时要先保存才能试，改了代码要先
+保存再试——而保存就意味着节点里立刻能用上一个还没试过的工具。
+
+另外两件：试跑以前不按参数 schema 校验，运行时却校验，于是试跑通过的参数到了
+工作流里被拒；沙箱里代码报错、地址被拦时，结果照样标「成功」，再附一段报错 JSON。
+"""
+from __future__ import annotations
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import func, select
+
+from app.db.base import SessionLocal
+from app.db.models import CustomTool
+from app.main import app
+from app.sandbox.base import ExecResult
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+class _FakeSandbox:
+    def __init__(self, result: ExecResult) -> None:
+        self.result = result
+        self.codes: list[str] = []
+
+    async def run(self, code, **_kw):  # noqa: ANN001, ANN003, ANN201
+        self.codes.append(code)
+        return self.result
+
+
+def _sandbox(monkeypatch, **result) -> _FakeSandbox:
+    import app.tools.custom as custom
+
+    fake = _FakeSandbox(ExecResult(**{"ok": True, "exit_code": 0, "stdout": "", "stderr": "", **result}))
+    monkeypatch.setattr(custom, "sandbox_manager", fake)
+    return fake
+
+
+async def _tool_count() -> int:
+    async with SessionLocal() as session:
+        return int((await session.execute(select(func.count(CustomTool.id)))).scalar_one())
+
+
+PARAMS = {"type": "object", "properties": {"store": {"type": "string"}, "days": {"type": "integer"}},
+          "required": ["store"]}
+
+
+async def test_an_unsaved_python_tool_can_be_tried(client, monkeypatch):
+    fake = _sandbox(monkeypatch, stdout='{"orders": 42}\n')
+    before = await _tool_count()
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "python", "parameters": PARAMS,
+        "config": {"code": "print(json.dumps({'orders': 42}))"},
+        "args": {"store": "north", "days": "7"},
+    })
+    body = r.json()
+    assert body["ok"] is True, body
+    assert body["result"] == {"orders": 42}
+    assert body["duration_ms"] >= 0
+    # 参数和运行时一样先过 schema：字符串 "7" 被纠正成整数 7（代码前导里是转义过的 JSON）
+    assert '\\"days\\": 7' in fake.codes[0] and '\\"store\\": \\"north\\"' in fake.codes[0]
+    assert await _tool_count() == before, "试跑不该落库"
+
+
+async def test_arguments_that_the_schema_rejects_fail_like_they_would_at_runtime(client, monkeypatch):
+    _sandbox(monkeypatch, stdout="1")
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "python", "parameters": PARAMS, "config": {"code": "print(1)"}, "args": {"days": 3},
+    })
+    body = r.json()
+    assert body["ok"] is False
+    assert "store" in body["error"], "缺了哪个参数得说出来"
+
+
+async def test_code_that_crashes_is_reported_as_a_failure(client, monkeypatch):
+    _sandbox(monkeypatch, ok=False, exit_code=1,
+             stderr="Traceback (most recent call last):\n  ...\nNameError: name 'x' is not defined")
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "python", "config": {"code": "print(x)"}, "args": {},
+    })
+    body = r.json()
+    assert body["ok"] is False, "沙箱里报错了，不能标成功"
+    assert "退出码 1" in body["error"]
+    assert "NameError" in body["detail"], "原始报错要留着，用户得照着改代码"
+    assert body["hint"]
+
+
+async def test_an_http_tool_to_a_private_address_is_blocked_and_says_so(client):
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "http", "config": {"url": "http://127.0.0.1:9/orders", "method": "GET"}, "args": {},
+    })
+    body = r.json()
+    assert body["ok"] is False
+    assert "拦截" in body["error"] or "内网" in body["error"], body
+
+
+async def test_an_http_tool_renders_its_template_with_the_args(client, monkeypatch):
+    import app.tools.custom as custom
+
+    seen: dict = {}
+
+    async def fake_request(method, url, **kw):
+        seen.update(method=method, url=url, **kw)
+        return {"status": 200, "body": '{"count": 3}'}
+
+    monkeypatch.setattr(custom, "safe_request", fake_request)
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "http", "parameters": PARAMS,
+        "config": {"url": "https://api.example.com/orders?store={{ store }}", "method": "GET",
+                   "parse_json": True},
+        "args": {"store": "north"},
+    })
+    body = r.json()
+    assert body["ok"] is True, body
+    assert seen["url"] == "https://api.example.com/orders?store=north"
+    assert body["result"] == {"status": 200, "data": {"count": 3}}
+
+
+@pytest.mark.parametrize("draft, words", [
+    ({"kind": "http", "config": {}}, "接口地址"),
+    ({"kind": "python", "config": {"code": "  "}}, "代码"),
+    ({"kind": "graphql", "config": {}}, "graphql"),
+])
+async def test_an_incomplete_draft_says_what_is_missing(client, draft, words):
+    body = (await client.post("/api/custom-tools/test", json={**draft, "args": {}})).json()
+    assert body["ok"] is False and words in body["error"], body
+
+
+async def test_a_misspelt_argument_name_is_run_but_not_kept_quiet(client, monkeypatch):
+    """参数名写错、只有一个候选时，运行时替它改名跑通，但一定会说出来（fix_note）。
+
+    试跑以前把这句说明丢了：{"cuont": 3} 照样 ok，结果里也看不出哪里不对，
+    用户照着这份参数去配工作流，错的名字就一直留着。
+    """
+    fake = _sandbox(monkeypatch, stdout='{"count": 3}')
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "python", "config": {"code": "print(json.dumps(args))"},
+        "parameters": {"type": "object", "properties": {"count": {"type": "integer"}},
+                       "required": ["count"]},
+        "args": {"cuont": 3},
+    })
+    body = r.json()
+    assert body["ok"] is True, body
+    assert '\\"count\\": 3' in fake.codes[0], "改名之后照样执行"
+    assert "cuont" in body["note"] and "count" in body["note"], body
+
+    # 名字写对了就不多嘴
+    r = await client.post("/api/custom-tools/test", json={
+        "kind": "python", "config": {"code": "print(1)"},
+        "parameters": {"type": "object", "properties": {"count": {"type": "integer"}}},
+        "args": {"count": 3},
+    })
+    assert "note" not in r.json(), r.json()
+
+
+async def test_the_tool_library_run_also_says_when_it_renamed_an_argument(client):
+    """工具库的「执行」和试跑是同一种形状，纠正说明也一样要带上。"""
+    r = await client.post("/api/tools/memory_recall/run", json={"args": {"query": "口径", "limt": 3}})
+    body = r.json()
+    assert body["ok"] is True, body
+    assert "limt" in body["note"] and "limit" in body["note"], body
+
+
+@pytest.mark.parametrize("parameters, words", [
+    ({"properties": "bad"}, "properties"),
+    ({"properties": {"n": "int"}}, "n"),
+    ({"properties": {"n": {"type": "int"}}}, "int"),
+    ({"properties": {"n": {"type": ["integer", "null"]}}}, "n"),
+    ({"properties": {"n": {"type": "integer"}}, "required": "n"}, "required"),
+])
+async def test_a_malformed_parameter_schema_is_the_users_to_fix(client, monkeypatch, parameters, words):
+    """参数定义是用户手写的 JSON。写坏了是配置问题，不能说成「后端内部出错了」。"""
+    fake = _sandbox(monkeypatch, stdout="1")
+    body = (await client.post("/api/custom-tools/test", json={
+        "kind": "python", "config": {"code": "print(1)"}, "parameters": parameters, "args": {},
+    })).json()
+    assert body["ok"] is False, body
+    assert "参数定义" in body["error"] and words in body["error"], body
+    assert "内部" not in body["error"] and "维护者" not in (body["hint"] or ""), body
+    assert not fake.codes, "参数定义都不对，就别去沙箱里跑了"
+
+
+async def test_the_saved_tool_trial_follows_the_same_rules(client, monkeypatch):
+    _sandbox(monkeypatch, ok=False, exit_code=2, stderr="boom")
+    r = await client.post("/api/custom-tools", json={
+        "name": "trial_saved", "kind": "python", "parameters": PARAMS, "config": {"code": "print(1)"},
+    })
+    tool = r.json()
+    try:
+        body = (await client.post(f"/api/custom-tools/{tool['id']}/test",
+                                  json={"args": {"store": "north"}})).json()
+        assert body["ok"] is False and "退出码 2" in body["error"]
+        body = (await client.post(f"/api/custom-tools/{tool['id']}/test", json={"args": {}})).json()
+        assert body["ok"] is False and "store" in body["error"]
+    finally:
+        await client.delete(f"/api/custom-tools/{tool['id']}")
+
+
+async def test_at_runtime_a_crash_still_reaches_the_model_as_an_error_payload(monkeypatch):
+    """运行时的行为不变：失败以 {"error": …} 的 JSON 交给模型，由它决定怎么办。"""
+    import json
+
+    from app.tools.custom import build_custom_tools
+    from app.tools.registry import ToolContext
+
+    _sandbox(monkeypatch, ok=False, exit_code=1, stderr="boom")
+    async with SessionLocal() as session:
+        session.add(CustomTool(name="trial_runtime", kind="python", parameters={},
+                               config={"code": "raise SystemExit(1)"}))
+        await session.commit()
+        try:
+            tools = await build_custom_tools(["trial_runtime"], ToolContext(run_id="r", node_id="n"),
+                                             session)
+            out = json.loads(await tools[0].coroutine(input=""))
+            assert out["exit_code"] == 1 and out["error"]
+        finally:
+            row = (await session.execute(
+                select(CustomTool).where(CustomTool.name == "trial_runtime"))).scalar_one()
+            await session.delete(row)
+            await session.commit()
diff --git a/backend/tests/test_custom_tool_schema.py b/backend/tests/test_custom_tool_schema.py
new file mode 100644
index 00000000..cf878e91
--- /dev/null
+++ b/backend/tests/test_custom_tool_schema.py
@@ -0,0 +1,307 @@
+"""自定义工具的参数定义写坏了：保存时就拒掉；库里已经存着的坏工具，运行时说清是哪个、坏在哪。
+
+参数定义是用户在编辑器里手写的 JSON Schema。以前保存照单全收，写成
+{"city": "string"} 或 {"type": "int"} 都存得进去；到了工作流绑定这个工具的那一刻，
+schema_to_model 在 .get 上炸掉，运行记录里只剩一句「执行出错：'str' object has no
+attribute 'get'」——既不知道是哪个工具，也不知道该去哪里改。
+"""
+from __future__ import annotations
+
+import asyncio
+import uuid
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import func, select
+
+from app.db.base import SessionLocal
+from app.db.models import CustomTool, Run, RunEvent
+from app.engine.runner import run_manager
+from app.main import app
+
+GOOD = {"type": "object", "properties": {"store": {"type": "string", "description": "门店"}},
+        "required": ["store"]}
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+def _name() -> str:
+    return f"lookup_{uuid.uuid4().hex[:6]}"
+
+
+async def _count() -> int:
+    async with SessionLocal() as session:
+        return int((await session.execute(select(func.count(CustomTool.id)))).scalar_one())
+
+
+# --------------------------------------------------------------------------
+# 保存时拒掉
+# --------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("parameters, words", [
+    ({"type": "object", "properties": {"city": "string"}}, ["city", '{"type": "string"}']),
+    ({"type": "object", "properties": {"n": {"type": "int"}}}, ["n", "「int」", "integer"]),
+    ({"type": "object", "properties": {"n": {"type": "integer"}}, "required": "n"}, ["required"]),
+    ({"type": "object", "properties": ["city"]}, ["properties"]),
+    ({"type": "object", "properties": {"_id": {"type": "string"}}}, ["_id", "下划线"]),
+    ({"type": "object", "properties": {"model_config": {"type": "string"}}}, ["model_config"]),
+    ({"type": "object", "properties": {"": {"type": "string"}}}, ["参数名"]),
+])
+async def test_a_malformed_schema_is_refused_with_words(client, parameters, words):
+    before = await _count()
+    r = await client.post("/api/custom-tools", json={
+        "name": _name(), "kind": "http", "parameters": parameters,
+        "config": {"url": "https://example.com/api"}})
+    assert r.status_code == 422, r.text
+    detail = r.json()["detail"]
+    assert isinstance(detail, str), f"detail 要是一句话，不是 pydantic 的错误列表：{detail!r}"
+    for word in words:
+        assert word in detail, (word, detail)
+    assert "Error" not in detail and "Traceback" not in detail
+    assert await _count() == before, "写坏的工具不该落库"
+
+
+@pytest.mark.parametrize("spec, fix, not_this", [
+    # 照抄报错里的写法就能改好：写的是 "string"，就别让人改成 integer
+    ("string", '{"type": "string"}', "integer"),
+    ("int", '{"type": "integer"}', None),
+    ("Number", '{"type": "number"}', None),
+    ("bool", '{"type": "boolean"}', None),
+    (5, '{"type": "string"}', None),
+])
+def test_the_example_in_the_message_is_the_type_they_meant(spec, fix, not_this):
+    from app.tools.custom import schema_problem
+
+    problem = schema_problem({"type": "object", "properties": {"store": spec}})
+    assert problem and fix in problem, problem
+    if not_this:
+        assert not_this not in problem, problem
+
+
+@pytest.mark.parametrize("kind, guess", [("int", "integer"), ("String", "string"), ("float", "number"),
+                                         ("dict", "object")])
+def test_a_near_miss_type_gets_a_suggestion(kind, guess):
+    from app.tools.custom import schema_problem
+
+    problem = schema_problem({"type": "object", "properties": {"n": {"type": kind}}})
+    assert problem and f"是不是想写 {guess}" in problem, problem
+
+
+def test_an_unrecognisable_type_gets_no_guess():
+    from app.tools.custom import schema_problem
+
+    problem = schema_problem({"type": "object", "properties": {"n": {"type": "timestamp"}}})
+    assert problem and "「timestamp」" in problem and "是不是想写" not in problem, problem
+
+
+async def test_parameters_that_are_not_an_object_are_refused_in_words_too(client):
+    r = await client.post("/api/custom-tools", json={
+        "name": _name(), "kind": "http", "parameters": ["city"], "config": {}})
+    assert r.status_code == 422
+    assert r.json()["detail"] == "参数定义要是一个 JSON 对象"
+
+
+async def test_editing_a_tool_into_a_broken_schema_is_refused_and_nothing_changes(client):
+    r = await client.post("/api/custom-tools", json={
+        "name": _name(), "kind": "http", "parameters": GOOD,
+        "config": {"url": "https://example.com/api"}})
+    assert r.status_code == 201, r.text
+    tool = r.json()
+    try:
+        broken = {**tool, "parameters": {"type": "object", "properties": {"store": "string"}}}
+        r = await client.patch(f"/api/custom-tools/{tool['id']}", json=broken)
+        assert r.status_code == 422, r.text
+        assert "store" in r.json()["detail"]
+        async with SessionLocal() as session:
+            row = await session.get(CustomTool, tool["id"])
+            assert row.parameters == GOOD, "被拒的修改不能落一半"
+    finally:
+        await client.delete(f"/api/custom-tools/{tool['id']}")
+
+
+async def test_a_good_schema_still_saves(client):
+    r = await client.post("/api/custom-tools", json={
+        "name": _name(), "kind": "http", "parameters": GOOD,
+        "config": {"url": "https://example.com/api"}})
+    assert r.status_code == 201, r.text
+    assert r.json()["problem"] is None
+    await client.delete(f"/api/custom-tools/{r.json()['id']}")
+
+
+@pytest.mark.filterwarnings("ignore:Field name .* shadows an attribute")
+def test_every_schema_the_check_lets_through_really_builds():
+    """schema_problem 放行的，schema_to_model 一定建得出来：它是两者之间唯一的关卡。"""
+    from app.tools.custom import schema_problem, schema_to_model
+
+    for name in ("store", "城市", "my-field", "json", "copy", "model_name"):
+        schema = {"type": "object", "properties": {name: {"type": "string"}}}
+        assert schema_problem(schema) is None, name
+        schema_to_model("t", schema).model_json_schema()
+
+
+# --------------------------------------------------------------------------
+# 库里已经存着的坏工具
+# --------------------------------------------------------------------------
+
+BROKEN = {"type": "object", "properties": {"store": "string"}}
+
+
+@pytest.fixture
+async def broken_tool():
+    """绕过接口直接写库：模拟这次改动之前就存进去的坏工具。"""
+    name = _name()
+    async with SessionLocal() as session:
+        row = CustomTool(name=name, kind="http", parameters=BROKEN,
+                         config={"url": "https://example.com/api"}, description="查门店")
+        session.add(row)
+        await session.commit()
+        tool_id = row.id
+    yield name
+    async with SessionLocal() as session:
+        row = await session.get(CustomTool, tool_id)
+        if row:
+            await session.delete(row)
+            await session.commit()
+
+
+@pytest.fixture
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def chain(*nodes):
+    return {"nodes": list(nodes),
+            "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
+
+
+async def _finish(graph) -> tuple[Run, list[RunEvent]]:
+    run = await run_manager.start(graph=graph, input_payload={"question": "北区门店"})
+    for _ in range(300):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, run.id)
+            if row.status in ("succeeded", "failed", "cancelled", "interrupted"):
+                break
+    async with SessionLocal() as session:
+        events = list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run.id).order_by(RunEvent.seq)
+        )).scalars())
+    return row, events
+
+
+def _clear(text: str | None, name: str) -> None:
+    text = text or ""
+    assert name in text, f"没说是哪个工具：{text}"
+    assert "参数定义" in text and "store" in text, f"没说坏在哪：{text}"
+    assert "工具" in text and "改" in text, f"没说去哪里改：{text}"
+    for noise in ("执行出错", "内部", "attribute", "object has no"):
+        assert noise not in text, f"还是笼统的内部错误：{text}"
+
+
+async def test_an_agent_bound_to_a_broken_tool_fails_saying_which_and_why(engine_up, broken_tool):
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("ask", "agent", prompt="查一下门店", tools=[broken_tool], max_steps=2),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.ask.text }}"}]),
+    ))
+    assert row.status == "failed"
+    assert row.error_node_id == "ask"
+    _clear(row.error, broken_tool)
+    failed = next(e.data for e in events if e.type == "node.failed")
+    _clear(failed["error"], broken_tool)
+
+
+async def test_a_tool_node_bound_to_a_broken_tool_fails_saying_which_and_why(engine_up, broken_tool):
+    row, _ = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("call", "tool", tool=broken_tool, args={"store": "north"}, approval="never"),
+        node("out", "output", fields=[]),
+    ))
+    assert row.status == "failed"
+    assert row.error_node_id == "call"
+    _clear(row.error, broken_tool)
+
+
+async def test_a_team_member_with_a_broken_tool_fails_that_step_with_the_reason(
+    engine_up, broken_tool, monkeypatch,
+):
+    import json
+
+    from langchain_core.messages import AIMessage
+
+    from app.providers import mock_model
+
+    routed: list[str] = []
+
+    def _decide(self, messages):
+        if self.response_format:   # 调度者：派一次，看到结果就收工
+            plan = ({"assignments": [{"agent": "查数员", "instruction": "查门店"}]} if not routed
+                    else {"assignments": [], "done": True, "reason": "查数员的工具坏了，先收工"})
+            routed.append("x")
+            return AIMessage(content=json.dumps(plan, ensure_ascii=False))
+        return AIMessage(content="北区 3 家")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    _, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("team", "supervisor", goal="查门店", max_rounds=2, approval="never", agents=[
+            {"name": "查数员", "system": "你负责查", "tools": [broken_tool], "max_steps": 2}]),
+        node("out", "output", fields=[]),
+    ))
+    step = next(e.data for e in events if e.type == "agent.step.end")
+    assert step.get("failed") is True, step
+    _clear(step.get("error"), broken_tool)
+
+
+async def test_the_tool_library_marks_a_stored_broken_tool(client, broken_tool):
+    listed = next(t for t in (await client.get("/api/custom-tools")).json() if t["name"] == broken_tool)
+    assert listed["problem"] and "store" in listed["problem"]
+    item = next(t for t in (await client.get("/api/tools")).json() if t["id"] == broken_tool)
+    assert item["problem"] == listed["problem"]
+    good = [t for t in (await client.get("/api/tools")).json() if t["source"] == "builtin"]
+    assert good and all("problem" not in t for t in good), "内置工具不用带这个字段"
+
+
+async def test_running_a_broken_tool_from_the_library_says_why(client, broken_tool):
+    r = await client.post(f"/api/tools/{broken_tool}/run", json={"args": {"store": "north"},
+                                                                 "confirm": True})
+    body = r.json()
+    assert body["ok"] is False
+    _clear(body["error"], broken_tool)
+
+
+async def test_a_broken_tool_does_not_take_its_neighbours_down(broken_tool):
+    """同一个节点绑了好几个工具时，报错只点坏的那一个。"""
+    from app.tools.registry import ToolBuildError, ToolContext, build_tools
+
+    good = _name()
+    async with SessionLocal() as session:
+        session.add(CustomTool(name=good, kind="http", parameters=GOOD,
+                               config={"url": "https://example.com/api"}))
+        await session.commit()
+    try:
+        async with SessionLocal() as session:
+            ctx = ToolContext(run_id="t", node_id="n")
+            built = await build_tools([good], ctx, session=session)
+            assert [t.name for t in built] == [good]
+            with pytest.raises(ToolBuildError) as caught:
+                await build_tools([good, broken_tool], ctx, session=session)
+        assert broken_tool in str(caught.value) and good not in str(caught.value)
+    finally:
+        async with SessionLocal() as session:
+            row = (await session.execute(select(CustomTool).where(CustomTool.name == good))).scalar_one()
+            await session.delete(row)
+            await session.commit()
diff --git a/backend/tests/test_datasource_preview.py b/backend/tests/test_datasource_preview.py
new file mode 100644
index 00000000..7dcae041
--- /dev/null
+++ b/backend/tests/test_datasource_preview.py
@@ -0,0 +1,136 @@
+"""换个 schema 看看，不擅自改缓存；表结构给结构化的列；卡片知道缓存是按哪个 schema 探的。
+
+「换个 schema 看看」以前一探就把缓存换成那个 schema 的结构——哪怕用户随后选了
+「只看看，不改」，助手此刻看到的已经是另一套表了。前端只好再探一次配置里的
+schema 把缓存换回来，而那一次要是失败，缓存和配置就对不上，只剩一条会消失的 toast。
+
+表结构以前只有一段给模型看的文本，前端照着文本格式去解析列，格式一改就全乱。
+"""
+from __future__ import annotations
+
+import sqlite3
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+@pytest.fixture
+async def source(client, tmp_path):
+    path = tmp_path / "preview.db"
+    db = sqlite3.connect(path)
+    db.execute("CREATE TABLE orders (id INTEGER PRIMARY KEY, store TEXT NOT NULL, amount REAL)")
+    db.execute("CREATE TABLE sales_daily (day TEXT, total REAL)")
+    db.execute("CREATE VIEW v_big_orders AS SELECT * FROM orders WHERE amount > 100")
+    db.commit()
+    db.close()
+    r = await client.post("/api/datasources", json={"name": "preview_src", "kind": "sqlite",
+                                                   "database": str(path)})
+    assert r.status_code == 201, r.text
+    yield r.json()
+    await client.delete(f"/api/datasources/{r.json()['id']}")
+
+
+async def _cache(source_id: str) -> dict:
+    from app.db.base import SessionLocal
+    from app.db.models import DataSource
+
+    async with SessionLocal() as session:
+        row = await session.get(DataSource, source_id)
+        return {"cache": dict(row.schema_cache or {}), "synced": row.schema_synced_at}
+
+
+# --------------------------------------------------------------------------
+# REQ-7：缓存是按哪个 schema 探的
+# --------------------------------------------------------------------------
+
+
+async def test_cached_schema_says_which_schema_the_cache_came_from(client, source):
+    assert source["cached_schema"] is None, "没探过就是没有缓存"
+    r = await client.post(f"/api/datasources/{source['id']}/introspect")
+    assert r.json()["cached_schema"] == "", "按默认 schema 探的写空串，和「没探过」分开"
+    r = await client.post(f"/api/datasources/{source['id']}/introspect", params={"schema": "main"})
+    assert r.json()["cached_schema"] == "main"
+    listed = next(s for s in (await client.get("/api/datasources")).json() if s["id"] == source["id"])
+    assert listed["cached_schema"] == "main"
+
+
+# --------------------------------------------------------------------------
+# REQ-6 ①：只看看，不改缓存
+# --------------------------------------------------------------------------
+
+
+async def test_a_dry_run_shows_what_is_there_without_touching_the_cache(client, source):
+    await client.post(f"/api/datasources/{source['id']}/introspect")
+    before = await _cache(source["id"])
+
+    r = await client.post(f"/api/datasources/{source['id']}/introspect",
+                          params={"schema": "main", "dry_run": "true"})
+    assert r.status_code == 200, r.text
+    preview = r.json()
+    assert preview["dry_run"] is True
+    assert preview["schema"] == "main"
+    assert preview["table_count"] == 3
+    assert set(preview["tables"]) == {"main.orders", "main.sales_daily", "main.v_big_orders"}
+    assert preview["schema_error"] == ""
+
+    after = await _cache(source["id"])
+    assert after == before, "只看看也把缓存换掉了——助手此刻看到的就不是配置里那个 schema 了"
+
+
+async def test_a_dry_run_that_finds_nothing_says_why_and_still_leaves_the_cache(client, source):
+    await client.post(f"/api/datasources/{source['id']}/introspect")
+    before = await _cache(source["id"])
+
+    r = await client.post(f"/api/datasources/{source['id']}/introspect",
+                          params={"schema": "no_such_schema", "dry_run": "true"})
+    preview = r.json()
+    assert preview["dry_run"] is True and preview["table_count"] == 0
+    assert preview["schema_error"], "探失败了要说出来，不能看起来像「这个 schema 是空的」"
+    assert "main" in preview["available_schemas"]
+    assert await _cache(source["id"]) == before
+
+
+async def test_without_dry_run_the_cache_is_still_replaced(client, source):
+    r = await client.post(f"/api/datasources/{source['id']}/introspect", params={"schema": "main"})
+    assert r.json()["table_count"] == 3
+    assert (await _cache(source["id"]))["cache"]["schema"] == "main"
+
+
+# --------------------------------------------------------------------------
+# REQ-6 ②：表结构的结构化列
+# --------------------------------------------------------------------------
+
+
+async def test_table_schema_comes_with_structured_columns(client, source):
+    await client.post(f"/api/datasources/{source['id']}/introspect")
+    body = (await client.get(f"/api/datasources/{source['id']}/schema",
+                             params={"table": "orders"})).json()
+    assert body["found"] is True
+    assert body["kind"] == "table" and body["qualified"] == "orders"
+    assert body["detail"].startswith("表 orders"), "给模型看的那段文本照旧"
+    assert body["columns"] == [
+        {"name": "id", "type": "INTEGER", "pk": True, "not_null": False, "comment": None},
+        {"name": "store", "type": "TEXT", "pk": False, "not_null": True, "comment": None},
+        {"name": "amount", "type": "REAL", "pk": False, "not_null": False, "comment": None},
+    ]
+
+    view = (await client.get(f"/api/datasources/{source['id']}/schema",
+                             params={"table": "V_BIG_ORDERS"})).json()
+    assert view["found"] is True and view["kind"] == "view", "和给模型的那份一样，大小写不敏感"
+
+
+async def test_an_unknown_table_has_no_columns_but_keeps_the_explanation(client, source):
+    await client.post(f"/api/datasources/{source['id']}/introspect")
+    body = (await client.get(f"/api/datasources/{source['id']}/schema",
+                             params={"table": "nope"})).json()
+    assert body["found"] is False and body["columns"] == []
+    assert "没有 nope" in body["detail"]
diff --git a/backend/tests/test_graph_checks.py b/backend/tests/test_graph_checks.py
new file mode 100644
index 00000000..2b884faa
--- /dev/null
+++ b/backend/tests/test_graph_checks.py
@@ -0,0 +1,252 @@
+"""校验要指到字段上；提示词点名要用的工具，节点得真的绑了它。
+
+field：检查器要把问题落到具体的输入框下面。以前 ValidationIssue 只有 node_id，前端
+只能拿消息原文去猜是哪个字段（认 {{ path }}、认几句固定说法），认不出就只挂在
+面板顶上。
+
+工具绑定：一次真实的运行里，助手改图时把三个查库 agent 的 tools 丢了，提示词里却
+还写着「用 db_query__… 查」。模型拿不到工具，只能写一句「假设调用工具」，再往下
+编。这种图在跑之前就能认出来：提示词点名了工具、节点却没绑定，判 error——
+Copilot 的自查读的是同一份 error，搭图时就会交回模型去修。
+"""
+from __future__ import annotations
+
+import pytest
+
+from app.engine.schema import GraphSpec, validate_graph
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def graph(*nodes, edges=None):
+    ids = [n["id"] for n in nodes]
+    return GraphSpec.model_validate({
+        "nodes": list(nodes),
+        "edges": edges if edges is not None else
+        [{"source": a, "target": b} for a, b in zip(ids, ids[1:])],
+    })
+
+
+def issues_of(spec, node_id=None):
+    return [i for i in validate_graph(spec).issues if node_id is None or i.node_id == node_id]
+
+
+# --------------------------------------------------------------------------
+# 提示词点名的工具
+# --------------------------------------------------------------------------
+
+
+def test_a_named_tool_that_is_not_bound_is_an_error():
+    spec = graph(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("query", "agent", model="m", system="你负责取数。",
+             prompt="用 db_query__shop 查 orders 表的总数：{{ input.question }}", tools=[]),
+        node("out", "output"),
+    )
+    errors = [i for i in issues_of(spec, "query") if i.level == "error"]
+    assert errors, issues_of(spec)
+    assert "提示词要求用「db_query__shop」，但节点没有绑定它" in errors[0].message
+    assert errors[0].field == "prompt"
+    assert not validate_graph(spec).ok
+
+
+def test_builtin_tool_names_are_recognised_too():
+    spec = graph(
+        node("start", "input"),
+        node("calc", "agent", model="m", system="算完用 python_exec 核对一遍", tools=["calculator"]),
+    )
+    hit = [i for i in issues_of(spec, "calc") if "python_exec" in i.message]
+    assert hit and hit[0].level == "error" and hit[0].field == "system"
+
+
+def test_a_bound_tool_is_fine():
+    spec = graph(
+        node("start", "input"),
+        node("query", "agent", model="m", prompt="用 db_query__shop 查一下", tools=["db_query__shop"]),
+    )
+    assert not [i for i in issues_of(spec, "query") if "提示词要求用" in i.message]
+
+
+def test_saying_not_to_use_a_tool_is_not_asking_for_it():
+    spec = graph(
+        node("start", "input"),
+        node("query", "agent", model="m", prompt="不要用 python_exec，直接心算", tools=[]),
+    )
+    assert not [i for i in issues_of(spec, "query") if "python_exec" in i.message]
+
+
+def test_a_vague_request_for_tools_without_any_bound_is_a_warning():
+    spec = graph(
+        node("start", "input"),
+        node("query", "agent", model="m", prompt="调用工具查一下数据库，再回答", tools=[]),
+    )
+    vague = [i for i in issues_of(spec, "query") if "没有绑定任何工具" in i.message]
+    assert vague and vague[0].level == "warning" and vague[0].field == "prompt"
+    assert validate_graph(spec).ok
+
+
+def test_team_members_are_checked_against_their_own_tools():
+    spec = graph(
+        node("start", "input"),
+        node("team", "supervisor", model="m", goal="核对迁移记录", agents=[
+            {"name": "核对员", "system": "用 db_query__shop 独立重查一遍条数", "tools": []},
+            {"name": "撰稿员", "system": "根据复核结果写结论"},
+        ]),
+    )
+    errors = [i for i in issues_of(spec, "team") if i.level == "error"]
+    assert errors and "核对员" in errors[0].message and "db_query__shop" in errors[0].message
+    assert errors[0].field == "agents[0].system"
+
+
+def test_a_team_goal_naming_a_tool_nobody_has():
+    spec = graph(
+        node("start", "input"),
+        node("team", "supervisor", model="m", goal="先用 db_schema__shop 看表结构", agents=[
+            {"name": "甲", "system": "你负责查", "tools": ["db_query__shop"]}]),
+    )
+    errors = [i for i in issues_of(spec, "team") if i.level == "error"]
+    assert errors and errors[0].field == "goal", issues_of(spec)
+
+
+# 误报：这条 error 会挡住运行，还会作为自查的阻断项交回 Copilot（模型可能反过来把
+# 禁用的工具绑上去），宁可漏判不可误判
+
+
+def _errors_about(tool, **config):
+    spec = graph(node("start", "input"), node("bot", "agent", model="m", **config))
+    return [i for i in issues_of(spec, "bot") if i.level == "error" and tool in i.message]
+
+
+@pytest.mark.parametrize("prompt", [
+    "Never call web_search; answer from the notes only.",
+    "Avoid web_fetch.",
+    "Do not use web_search.",
+    "Don't use the web_search tool, and never call web_fetch or http_request.",
+    "You must not call web_search under any circumstances.",
+    "You cannot use web_fetch here, and no http_request either.",
+])
+def test_english_negation_is_not_a_request(prompt):
+    for tool in ("web_search", "web_fetch", "http_request"):
+        assert not _errors_about(tool, prompt=prompt, tools=[]), (prompt, tool)
+
+
+@pytest.mark.parametrize("prompt", [
+    "查过一次就不再调用 python_exec，直接给结论",
+    "表结构已经给你了，无须再调用 db_schema__shop",
+    "拿到结果后别再用 db_query__shop",
+    "毋须使用 web_search",
+])
+def test_more_chinese_negations(prompt):
+    for tool in ("python_exec", "db_schema__shop", "db_query__shop", "web_search"):
+        assert not _errors_about(tool, prompt=prompt, tools=[]), (prompt, tool)
+
+
+def test_an_mcp_wildcard_covers_its_tools():
+    assert not _errors_about("mcp:fs/read_file", prompt="用 mcp:fs/read_file 读 notes.md",
+                             tools=["mcp:fs/*"])
+    assert not _errors_about("mcp:fs/read_file", prompt="用 mcp:fs/read_file 读 notes.md",
+                             tools=["mcp:fs"])
+    # 别的 server 的通配不算
+    assert _errors_about("mcp:fs/read_file", prompt="用 mcp:fs/read_file 读 notes.md",
+                         tools=["mcp:web/*"])
+
+
+def test_a_team_goal_is_covered_by_a_member_wildcard():
+    spec = graph(
+        node("start", "input"),
+        node("team", "supervisor", model="m", goal="先用 mcp:fs/list_dir 看目录", agents=[
+            {"name": "甲", "system": "你负责查", "tools": ["mcp:fs/*"]}]),
+    )
+    assert not [i for i in issues_of(spec, "team") if i.level == "error"], issues_of(spec)
+
+
+@pytest.mark.parametrize("prompt", [
+    "You may use a calculator if needed.",
+    "Work it out like a calculator would, step by step.",
+    "如有需要可以用 calculator 核对",
+    "必要时用 python_exec 验算一下",
+    "You can call db_query__shop when needed.",
+])
+def test_plain_words_and_optional_mentions_are_only_warnings(prompt):
+    spec = graph(node("start", "input"), node("bot", "agent", model="m", prompt=prompt, tools=[]))
+    found = issues_of(spec, "bot")
+    assert not [i for i in found if i.level == "error"], (prompt, found)
+
+
+def test_a_plain_word_tool_still_counts_when_clearly_asked_for():
+    for prompt in ("用 calculator 算出总价", "Use calculator to add them up.", "call `calculator` twice"):
+        errors = _errors_about("calculator", prompt=prompt, tools=[])
+        assert errors and errors[0].field == "prompt", prompt
+    # 提到了但没明确要求：给一条 warning，不挡运行
+    spec = graph(node("start", "input"),
+                 node("bot", "agent", model="m", prompt="You may use a calculator if needed.", tools=[]))
+    warned = [i for i in issues_of(spec, "bot") if "calculator" in i.message]
+    assert warned and warned[0].level == "warning", warned
+    assert validate_graph(spec).ok
+
+
+# --------------------------------------------------------------------------
+# field：指到字段
+# --------------------------------------------------------------------------
+
+
+def test_issues_carry_the_field_they_are_about():
+    spec = graph(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("route", "branch", cases=[
+            {"key": "a", "condition": "vars.x == 1"},
+            {"key": "b", "condition": "vars.y ==="},
+        ]),
+        node("shape", "transform", mode="expression", expression=""),
+        node("say", "llm", model="m", prompt="回答 {{ input.questoin }}"),
+        edges=[{"source": "start", "target": "route"},
+               {"source": "route", "target": "shape", "sourceHandle": "a"},
+               {"source": "shape", "target": "say"}],
+    )
+    by = {(i.node_id, i.field) for i in validate_graph(spec).issues}
+    assert ("route", "cases[1].condition") in by, by
+    assert ("route", "cases[1].key") in by or ("route", "cases") in by, by   # b 没有连出去的边
+    assert ("shape", "expression") in by, by
+    assert ("say", "prompt") in by, by       # 变量拼错
+
+
+def test_graph_level_issues_have_no_field():
+    spec = GraphSpec.model_validate({"nodes": []})
+    assert all(i.field is None for i in validate_graph(spec).issues)
+
+
+# --------------------------------------------------------------------------
+# 报错的人话规则只有一份
+# --------------------------------------------------------------------------
+
+
+def test_one_set_of_words_for_both_layers():
+    import importlib.util
+
+    import httpx
+
+    from app.core.errors import describe_exception, explain
+
+    for old in ("app.engine.errors", "app.api.errors"):
+        assert importlib.util.find_spec(old) is None, f"{old} 不该再有自己的一份"
+    req = httpx.Request("GET", "https://x/v1/models")
+    denied = httpx.HTTPStatusError("401", request=req, response=httpx.Response(401, request=req))
+    assert describe_exception(denied) == explain(denied)[0]
+    assert describe_exception(TimeoutError()) == explain(TimeoutError())[0]
+    # 分叉只在程序自己的毛病上：接口里是后端 bug，节点里多半是参数传错了
+    wrong = TypeError("_run() got an unexpected keyword argument 'query'")
+    assert "内部" in explain(wrong)[0]
+    assert "query" in describe_exception(wrong)
+
+
+def test_a_list_of_forbidden_tools_is_not_a_request():
+    spec = graph(
+        node("start", "input"),
+        node("team", "supervisor", model="m", goal="只用内部资料，严禁调用 web_search、web_fetch、http_request 等联网工具",
+             agents=[{"name": "甲", "system": "禁止使用 web_fetch 和 http_request，只查知识库",
+                      "tools": ["kb_search"]}]),
+    )
+    assert not [i for i in issues_of(spec, "team") if i.level == "error"], issues_of(spec)
diff --git a/backend/tests/test_health_record.py b/backend/tests/test_health_record.py
new file mode 100644
index 00000000..bf1b58e5
--- /dev/null
+++ b/backend/tests/test_health_record.py
@@ -0,0 +1,209 @@
+"""最近一次测连接的结果记在对象上，换台浏览器也看得到。
+
+以前这份结果只存在当前浏览器的 localStorage 里：换台电脑、清个缓存，所有数据源、
+模型接入、MCP 服务都回到「未测试」，而它们上周是不是连得通，谁也说不清。
+
+记在对象上还有两条规矩：
+- 在表单里测过、紧接着保存的，保存下来的对象直接带上那次结果——后端自己核对
+  过测的就是这份配置，不用前端转述。
+- 连接配置改过了，旧结果就不再代表它，清掉；只改说明之类的不清。
+"""
+from __future__ import annotations
+
+import sqlite3
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from app.db.base import SessionLocal
+from app.db.models import Provider
+from app.main import app
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+@pytest.fixture
+def orders_db(tmp_path):
+    path = tmp_path / "orders.db"
+    db = sqlite3.connect(path)
+    db.execute("CREATE TABLE orders (id INTEGER PRIMARY KEY, amount REAL)")
+    db.commit()
+    db.close()
+    return str(path)
+
+
+def _health(item: dict) -> tuple:
+    return (item["last_check_ok"], item["last_error"],
+            item["last_checked_at"] is not None, item["last_latency_ms"] is not None)
+
+
+async def _source(client, name: str) -> dict:
+    return next(s for s in (await client.get("/api/datasources")).json() if s["name"] == name)
+
+
+# --------------------------------------------------------------------------
+# 数据源
+# --------------------------------------------------------------------------
+
+
+async def test_testing_a_saved_source_is_remembered_on_it(client, orders_db):
+    r = await client.post("/api/datasources", json={"name": "health_src", "kind": "sqlite",
+                                                   "database": orders_db})
+    src = r.json()
+    try:
+        assert _health(src) == (None, None, False, False), "没测过就是没测过"
+        body = (await client.post(f"/api/datasources/{src['id']}/test")).json()
+        assert body["ok"] is True
+        assert _health(await _source(client, "health_src")) == (True, None, True, True)
+
+        # 连接配置变了：旧结果不再代表它
+        r = await client.patch(f"/api/datasources/{src['id']}", json={"database": orders_db + ".gone"})
+        assert _health(r.json()) == (None, None, False, False)
+        body = (await client.post(f"/api/datasources/{src['id']}/test")).json()
+        assert body["ok"] is False
+        item = await _source(client, "health_src")
+        assert item["last_check_ok"] is False and item["last_error"] == body["error"]
+        assert item["last_checked_at"]
+
+        # 只改说明：连接没变，结果留着
+        r = await client.patch(f"/api/datasources/{src['id']}", json={"description": "订单库"})
+        assert r.json()["last_check_ok"] is False
+    finally:
+        await client.delete(f"/api/datasources/{src['id']}")
+
+
+async def test_a_draft_tested_then_saved_keeps_its_result(client, orders_db):
+    body = (await client.post("/api/datasources/test", json={"kind": "sqlite",
+                                                            "database": orders_db})).json()
+    assert body["ok"] is True
+    r = await client.post("/api/datasources", json={"name": "health_draft", "kind": "sqlite",
+                                                   "database": orders_db})
+    src = r.json()
+    try:
+        assert _health(src) == (True, None, True, True), "刚在表单里测通的，保存之后不该变回未测试"
+        assert src["last_latency_ms"] == body["elapsed_ms"]
+    finally:
+        await client.delete(f"/api/datasources/{src['id']}")
+
+
+async def test_a_draft_result_does_not_stick_to_a_different_config(client, orders_db, tmp_path):
+    await client.post("/api/datasources/test", json={"kind": "sqlite", "database": orders_db})
+    other = tmp_path / "other.db"
+    sqlite3.connect(other).close()
+    r = await client.post("/api/datasources", json={"name": "health_other", "kind": "sqlite",
+                                                   "database": str(other)})
+    src = r.json()
+    try:
+        assert _health(src) == (None, None, False, False)
+    finally:
+        await client.delete(f"/api/datasources/{src['id']}")
+
+
+async def test_a_draft_test_of_the_unchanged_saved_config_updates_it(client, orders_db):
+    r = await client.post("/api/datasources", json={"name": "health_edit", "kind": "sqlite",
+                                                   "database": orders_db})
+    src = r.json()
+    try:
+        await client.post("/api/datasources/test", json={"id": src["id"], "kind": "sqlite",
+                                                        "database": orders_db})
+        assert (await _source(client, "health_edit"))["last_check_ok"] is True
+        # 编辑框里改了路径再测：测的是另一份配置，不能记到已保存的那个头上
+        await client.post("/api/datasources/test", json={"id": src["id"], "kind": "sqlite",
+                                                        "database": orders_db + ".typo"})
+        assert (await _source(client, "health_edit"))["last_check_ok"] is True
+    finally:
+        await client.delete(f"/api/datasources/{src['id']}")
+
+
+# --------------------------------------------------------------------------
+# 模型接入
+# --------------------------------------------------------------------------
+
+
+async def _provider(client, name: str) -> dict:
+    return next(p for p in (await client.get("/api/providers")).json() if p["name"] == name)
+
+
+async def test_testing_a_saved_provider_is_remembered_on_it(client):
+    r = await client.post("/api/providers", json={"name": "health-mock", "kind": "mock",
+                                                 "default_model": "mock-fast"})
+    prov = r.json()
+    try:
+        assert _health(prov) == (None, None, False, False)
+        assert (await client.post(f"/api/providers/{prov['id']}/test", json={})).json()["ok"] is True
+        item = await _provider(client, "health-mock")
+        assert _health(item) == (True, None, True, True)
+        assert "last_check" not in item["extra"], "结果是后端记的，不该混进用户填的 extra 里回显"
+
+        # 前端保存时会把 extra 原样带回来：不能因此把结果抹掉
+        r = await client.patch(f"/api/providers/{prov['id']}", json={"extra": item["extra"],
+                                                                    "enabled": True})
+        assert r.json()["last_check_ok"] is True
+        # 换了默认模型：测的那个不是它了
+        r = await client.patch(f"/api/providers/{prov['id']}", json={"default_model": "mock-slow"})
+        assert _health(r.json()) == (None, None, False, False)
+    finally:
+        await client.delete(f"/api/providers/{prov['id']}")
+
+
+async def test_a_provider_draft_tested_then_saved_keeps_its_result(client):
+    body = (await client.post("/api/providers/test", json={"kind": "mock",
+                                                          "default_model": "mock-fast"})).json()
+    assert body["ok"] is True
+    r = await client.post("/api/providers", json={"name": "health-draft", "kind": "mock",
+                                                 "default_model": "mock-fast"})
+    prov = r.json()
+    try:
+        assert _health(prov) == (True, None, True, True)
+    finally:
+        await client.delete(f"/api/providers/{prov['id']}")
+
+
+async def test_saving_a_provider_does_not_replace_its_headers_with_the_mask(client):
+    """列表里请求头的值回显成 ***；设置页原样带回来保存，真值就被 *** 盖掉了。"""
+    r = await client.post("/api/providers", json={
+        "name": "health-headers", "kind": "openai_compatible", "base_url": "http://127.0.0.1:9/v1",
+        "api_key": "k", "default_model": "m", "extra": {"headers": {"X-Token": "real-value"}},
+    })
+    prov = r.json()
+    try:
+        shown = (await _provider(client, "health-headers"))["extra"]
+        assert shown["headers"] == {"X-Token": "***"}
+        await client.patch(f"/api/providers/{prov['id']}", json={
+            "extra": {**shown, "headers": {**shown["headers"], "X-Other": "new"}}})
+        async with SessionLocal() as session:
+            row = await session.get(Provider, prov["id"])
+            assert row.extra["headers"] == {"X-Token": "real-value", "X-Other": "new"}
+    finally:
+        await client.delete(f"/api/providers/{prov['id']}")
+
+
+# --------------------------------------------------------------------------
+# MCP
+# --------------------------------------------------------------------------
+
+
+async def test_probing_an_mcp_server_is_remembered_with_when_and_how_long(client):
+    r = await client.post("/api/mcp/servers", json={
+        "name": "health-mcp", "transport": "stdio", "command": "agentlab-no-such-command-xyz"})
+    server = r.json()
+    try:
+        assert _health(server) == (None, None, False, False)
+        body = (await client.post(f"/api/mcp/servers/{server['id']}/probe")).json()
+        assert body["ok"] is False
+        item = next(s for s in (await client.get("/api/mcp/servers")).json() if s["id"] == server["id"])
+        assert item["last_check_ok"] is False and item["last_error"] == body["error"]
+        assert item["last_checked_at"] and item["last_latency_ms"] is not None
+
+        # 改了启动命令：旧结论不再算数
+        r = await client.patch(f"/api/mcp/servers/{server['id']}", json={
+            "name": "health-mcp", "transport": "stdio", "command": "another-command"})
+        assert _health(r.json()) == (None, None, False, False)
+        assert r.json()["status"] == "unknown"
+    finally:
+        await client.delete(f"/api/mcp/servers/{server['id']}")
diff --git a/backend/tests/test_issuance_matched.py b/backend/tests/test_issuance_matched.py
new file mode 100644
index 00000000..1a4d17fc
--- /dev/null
+++ b/backend/tests/test_issuance_matched.py
@@ -0,0 +1,64 @@
+"""出具时逐个说清：叙述里的每个数字回指到了哪张口径卡的哪个指标。
+
+以前事件和成果里只有 matched_numbers 这一个计数。界面想在正文里把数字逐个标出
+「来自口径卡指标 orders · 销售口径 @ v2」，拿不到对应关系，只能标出没对上的那些。
+"""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Run, RunEvent
+from app.engine.runner import run_manager
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+async def test_each_traced_number_names_its_metric_and_caliber():
+    graph = {
+        "nodes": [
+            node("start", "input"),
+            node("card", "metrics", caliber="销售口径", caliber_version="v2", metrics=[
+                {"id": "orders", "expression": "120"},
+                {"id": "aov", "expression": "35.5"},
+            ]),
+            node("draft", "transform", mode="template", assign_to="summary",
+                 template="本周订单 120 单，客单价 35.5 元，另有 7 单"),
+            node("out", "output", fields=[{"name": "结论", "value": "{{ vars.summary }}"}],
+                 contract={"metrics_from": "card", "narrative": "{{ vars.summary }}"}),
+        ],
+        "edges": [{"source": "start", "target": "card"}, {"source": "card", "target": "draft"},
+                  {"source": "draft", "target": "out"}],
+    }
+    run = await run_manager.start(graph=graph, input_payload={})
+    for _ in range(200):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, run.id)
+            if row.status in ("succeeded", "failed"):
+                break
+    assert row.status == "succeeded", row.error
+
+    expected = [{"token": "120", "metric": "orders", "caliber": "销售口径 @ v2"},
+                {"token": "35.5", "metric": "aov", "caliber": "销售口径 @ v2"}]
+    assert row.output["_issuance"]["matched"] == expected
+    assert row.output["_issuance"]["matched_numbers"] == 2
+    async with SessionLocal() as session:
+        issuance = (await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run.id, RunEvent.type == "issuance")
+        )).scalars().one()
+    assert issuance.data["matched"] == expected
+    assert issuance.data["matched_numbers"] == 2
diff --git a/backend/tests/test_kb_progress.py b/backend/tests/test_kb_progress.py
new file mode 100644
index 00000000..3d8055a1
--- /dev/null
+++ b/backend/tests/test_kb_progress.py
@@ -0,0 +1,257 @@
+"""知识库调试台看得见每条命中的分从哪来；重建索引有真实进度。
+
+总分是向量、关键词两路各自在候选集上归一化之后按 α 加权的和。前端拿到的只有
+两路的原始分（余弦、BM25），复现不了那个归一化，于是命中只能画一根总分条，
+说不清「这条是靠语义排上来的还是靠关键词」。contrib 把两路的贡献直接交出去，
+两者之和就是总分。
+
+重建索引以前压在一个请求里：几千段配远端 embedding 要好几分钟，界面只能转圈
+加一个已用时间。改成后台任务之后按批报「总数 / 已完成」，界面才画得出真进度。
+"""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Chunk, MemoryItem
+from app.main import app
+from app.memory import embeddings as emb
+from app.memory import kb, store
+
+
+@pytest.fixture(autouse=True)
+def _local_embedder():
+    emb.configure("local")
+    yield
+    emb.configure("local")
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+DOCS = [
+    "平台管理员一共有六个人，负责审批权限。",
+    "商家账户共五个，按地区划分。",
+    "订单表 orders 记录每一笔订单的金额和门店。",
+    "每日销售汇总在 sales_daily 表里，按门店和日期聚合。",
+]
+
+
+async def _seed(collection: str) -> None:
+    async with SessionLocal() as session:
+        for text in DOCS:
+            await kb.ingest_document(session, collection=collection, title=text[:8], content=text)
+
+
+# --------------------------------------------------------------------------
+# 命中的分数贡献
+# --------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("alpha", [0.0, 0.3, 0.7, 1.0])
+async def test_each_hit_says_how_much_each_signal_contributed(client, alpha):
+    await _seed(f"contrib_{int(alpha * 10)}")
+    r = await client.get("/api/kb/search", params={
+        "q": "订单 门店", "collection": f"contrib_{int(alpha * 10)}", "limit": 4, "alpha": alpha,
+    })
+    hits = r.json()["results"]
+    assert hits
+    for hit in hits:
+        contrib = hit["contrib"]
+        assert set(contrib) == {"vector", "keyword"}
+        assert abs(contrib["vector"] + contrib["keyword"] - hit["score"]) < 1e-6, hit
+        assert 0 <= contrib["vector"] <= alpha + 1e-9
+        assert 0 <= contrib["keyword"] <= 1 - alpha + 1e-9
+    if alpha == 0.0:
+        assert all(h["contrib"]["vector"] == 0 for h in hits)
+    if alpha == 1.0:
+        assert all(h["contrib"]["keyword"] == 0 for h in hits)
+    # 原始信号照旧给：调试台上还要写余弦和 BM25 的原数
+    assert set(hits[0]["signals"]) == {"vector", "keyword"}
+
+
+async def test_the_contributions_come_from_the_same_normalisation_as_the_score():
+    from app.memory.embeddings import hybrid_contrib, hybrid_rank
+
+    texts = ["订单金额", "门店数量", "订单和门店"]
+    vectors = [await emb.embed_text(t) for t in texts]
+    query = await emb.embed_text("订单")
+    ranked = hybrid_rank("订单", texts, vectors, query, alpha=0.4)
+    detailed = hybrid_contrib("订单", texts, vectors, query, alpha=0.4)
+    assert [(i, s) for i, s, _ in ranked] == [(r.index, r.score) for r in detailed]
+    for r in detailed:
+        assert abs(r.contrib["vector"] + r.contrib["keyword"] - r.score) < 1e-12
+
+
+async def test_a_degraded_search_puts_everything_on_keywords(client):
+    await _seed("contrib_stale")
+    async with SessionLocal() as session:
+        for row in (await session.execute(
+                select(Chunk).where(Chunk.collection == "contrib_stale"))).scalars():
+            row.embed_model, row.embed_dim = "旧模型", 7
+        await session.commit()
+    body = (await client.get("/api/kb/search", params={
+        "q": "订单", "collection": "contrib_stale", "alpha": 0.7})).json()
+    assert body["degraded"]
+    assert all(h["contrib"]["vector"] == 0 for h in body["results"])
+
+
+# --------------------------------------------------------------------------
+# 重建索引：后台跑，按批报进度
+# --------------------------------------------------------------------------
+
+
+async def test_reindex_reports_progress_batch_by_batch(monkeypatch):
+    await _seed("progress_kb")
+    monkeypatch.setattr(kb, "_EMBED_BATCH", 2)
+    seen: list[tuple[int, int]] = []
+    async with SessionLocal() as session:
+        out = await kb.reindex(session, "progress_kb", on_progress=lambda d, t: seen.append((d, t)))
+    assert out["reindexed"] == len(DOCS)
+    assert seen == [(2, 4), (4, 4)]
+
+
+async def test_memory_reindex_reports_progress_too(monkeypatch):
+    async with SessionLocal() as session:
+        for i in range(3):
+            await store.remember(session, scope="progress_mem", content=f"第 {i} 条要记住的口径",
+                                 dedupe=False)
+    monkeypatch.setattr(kb, "_EMBED_BATCH", 2)
+    seen: list[tuple[int, int]] = []
+    async with SessionLocal() as session:
+        n = await store.reindex(session, "progress_mem", on_progress=lambda d, t: seen.append((d, t)))
+    assert n == 3 and seen == [(2, 3), (3, 3)]
+
+
+async def _wait_done(client, timeout: float = 10.0) -> dict:
+    loop = asyncio.get_running_loop()
+    deadline = loop.time() + timeout
+    while True:
+        job = (await client.get("/api/kb/reindex")).json()
+        if job["state"] != "running" or loop.time() > deadline:
+            return job
+        await asyncio.sleep(0.02)
+
+
+async def test_a_background_reindex_returns_at_once_and_can_be_polled(client):
+    await _seed("progress_bg")
+    async with SessionLocal() as session:
+        for row in (await session.execute(
+                select(Chunk).where(Chunk.collection == "progress_bg"))).scalars():
+            row.embed_model, row.embed_dim = "旧模型", 7
+        await session.commit()
+
+    r = await client.post("/api/kb/reindex", params={"collection": "progress_bg", "background": "true"})
+    assert r.status_code == 202, r.text
+    started = r.json()
+    assert started["state"] in ("running", "done")
+    assert started["collection"] == "progress_bg"
+    memories = await _count_memories()
+    assert started["chunks"]["total"] == len(DOCS), "总数要在开始时就知道，进度条才有分母"
+    assert started["total"] == len(DOCS) + memories
+
+    job = await _wait_done(client)
+    assert job["state"] == "done", job
+    assert job["id"] == started["id"]
+    assert job["done"] == job["total"]
+    assert job["chunks"] == {"total": len(DOCS), "done": len(DOCS)}
+    assert job["result"]["reindexed"] == len(DOCS)
+    assert job["result"]["memories_reindexed"] == memories
+    assert job["finished_at"]
+    async with SessionLocal() as session:
+        assert await kb.stale_count(session, "progress_bg") == 0
+
+
+async def test_a_second_reindex_while_one_is_running_is_refused(client, monkeypatch):
+    from app.api import knowledge
+
+    gate = asyncio.Event()
+    real = kb.reindex
+
+    async def slow(session, collection=None, *, on_progress=None):
+        await gate.wait()
+        return await real(session, collection, on_progress=on_progress)
+
+    monkeypatch.setattr(kb, "reindex", slow)
+    try:
+        # 后台跑的话这一步立刻返回；压在请求里跑的话会一直等着 gate
+        first = await asyncio.wait_for(
+            client.post("/api/kb/reindex", params={"background": "true"}), timeout=5)
+        assert first.status_code == 202
+        again = await client.post("/api/kb/reindex", params={"background": "true"})
+        assert again.status_code == 409
+        assert "重建" in again.json()["detail"]
+        sync = await asyncio.wait_for(client.post("/api/kb/reindex"), timeout=5)
+        assert sync.status_code == 409, "同步那条路也不能和后台的并发跑"
+    finally:
+        gate.set()
+    job = await _wait_done(client)
+    assert job["state"] == "done"
+    assert knowledge.reindex_job() is not None
+
+
+async def test_two_reindexes_started_at_the_same_moment_do_not_both_run(client, monkeypatch):
+    """连点两下、两个标签页同时点：只能起一个。
+
+    先查「有没有在跑」、再 await 两次计数、最后才记下任务，中间的 await 让第二个
+    请求也看到「没在跑」——两个都 202，embedding 被重复计费，第一个的进度被覆盖。
+    """
+    gate = asyncio.Event()
+    real = kb.reindex
+    started: list[str | None] = []
+
+    async def slow(session, collection=None, *, on_progress=None):
+        started.append(collection)
+        await gate.wait()
+        return await real(session, collection, on_progress=on_progress)
+
+    monkeypatch.setattr(kb, "reindex", slow)
+    try:
+        replies = await asyncio.wait_for(asyncio.gather(*(
+            client.post("/api/kb/reindex", params={"background": "true"}) for _ in range(3)
+        )), timeout=5)
+        codes = sorted(r.status_code for r in replies)
+        assert codes == [202, 409, 409], [(r.status_code, r.text) for r in replies]
+        await asyncio.sleep(0.05)
+        assert len(started) == 1, "只能真的起一个重建"
+    finally:
+        gate.set()
+    job = await _wait_done(client)
+    assert job["state"] == "done"
+    accepted = next(r for r in replies if r.status_code == 202).json()
+    assert job["id"] == accepted["id"], "进度查到的得是被接下来的那一个"
+
+
+async def test_a_failed_reindex_says_why(client, monkeypatch):
+    async def broken(session, collection=None, *, on_progress=None):
+        raise RuntimeError("Connection refused")
+
+    monkeypatch.setattr(kb, "reindex", broken)
+    r = await client.post("/api/kb/reindex", params={"background": "true"})
+    assert r.status_code == 202
+    job = await _wait_done(client)
+    assert job["state"] == "failed"
+    assert job["error"] and "RuntimeError" not in job["error"]
+
+
+async def test_before_any_reindex_the_status_is_idle(client, monkeypatch):
+    from app.api import knowledge
+
+    monkeypatch.setattr(knowledge, "_REINDEX", None)
+    job = (await client.get("/api/kb/reindex")).json()
+    assert job == {"state": "idle"}
+
+
+async def _count_memories() -> int:
+    from sqlalchemy import func
+
+    async with SessionLocal() as session:
+        return int((await session.execute(select(func.count(MemoryItem.id)))).scalar_one())
diff --git a/backend/tests/test_markup_leak.py b/backend/tests/test_markup_leak.py
new file mode 100644
index 00000000..3d1aea45
--- /dev/null
+++ b/backend/tests/test_markup_leak.py
@@ -0,0 +1,234 @@
+"""模型把工具调用当成文字写出来，这一步没有真的调用工具——要认出来，不能当成功交出去。
+
+一次真实运行的最终答案是一整段 `<｜｜DSML｜｜ invoke name="db_schema__…">` 标记：
+协作成员没有绑定工具，模型把自己那套工具调用格式当正文输出了四轮，数据库一次
+都没查，运行却是 succeeded。换成 agent 节点、单次模型调用也是一样。
+
+处理：先带一句纠正提示重试一次；仍然如此就判失败，说清原因和怎么办，并发一条
+code=tool_markup_leak 的警告。协作成员这样时，这一步记为失败，原因交回调度者。
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Run, RunEvent
+from app.engine.runner import run_manager
+from app.engine.toolcalls import leaked_markup
+
+DSML = ('我将真正执行数据库工具，先取表结构。\n\n<｜｜DSML｜｜ calls>\n'
+        '<｜｜DSML｜｜ invoke name="db_schema__shop">\n'
+        '<｜｜DSML｜｜ parameter name="table">orders</｜｜DSML｜｜ parameter>\n'
+        '</｜｜DSML｜｜ invoke>\n</｜｜DSML｜｜ calls>')
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def chain(*nodes):
+    return {"nodes": list(nodes),
+            "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
+
+
+async def _finish(graph) -> tuple[Run, list[RunEvent]]:
+    run = await run_manager.start(graph=graph, input_payload={"question": "orders 有多少"})
+    for _ in range(300):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, run.id)
+            if row.status in ("succeeded", "failed"):
+                break
+    async with SessionLocal() as session:
+        events = list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run.id).order_by(RunEvent.seq)
+        )).scalars())
+    return row, events
+
+
+def _leaks(monkeypatch, *, until: int | None = None) -> list[list]:
+    """模型一直（或前 until 次）把工具调用写成文字。返回每次收到的消息。"""
+    from app.providers import mock_model
+
+    seen: list[list] = []
+
+    def _decide(self, messages):
+        if self.response_format:           # 协作团队的调度者：先派查数员，之后收工
+            routed = sum(1 for batch in seen if batch and batch[0] == "route")
+            seen.append(["route", "\n".join(str(m.content) for m in messages)])
+            plan = ({"assignments": [{"agent": "查数员", "instruction": "查 orders 有多少"}]}
+                    if routed == 0 else {"assignments": [], "done": True, "reason": "够了"})
+            return AIMessage(content=json.dumps(plan, ensure_ascii=False))
+        seen.append(list(messages))
+        calls = sum(1 for batch in seen if batch and batch[0] != "route")
+        if until is None or calls <= until:
+            return AIMessage(content=DSML)
+        return AIMessage(content="orders 一共 12 条。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    return seen
+
+
+# --------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("text", [
+    DSML,
+    "<|tool▁calls▁begin|><|tool▁call▁begin|>function<|tool▁sep|>db_query__shop",
+    '<tool_call>\n{"name": "db_query__shop", "arguments": {"sql": "SELECT 1"}}\n</tool_call>',
+    '<function_call>{"name": "python_exec"}</function_call>',
+    '<invoke name="db_query__shop"><parameter name="sql">SELECT 1</parameter></invoke>',
+    '假设调用工具得到：{"tool": "db_query__shop", "sql": "SELECT COUNT(*) FROM orders"}',
+])
+def test_markup_is_recognised(text):
+    assert leaked_markup(text)
+
+
+@pytest.mark.parametrize("text", [
+    "orders 一共 12 条。",
+    "查询用的是 `SELECT COUNT(*) FROM orders`，结果 12。",
+    '返回的 JSON 是 {"tool": "calculator", "result": 3}',     # 没自称「假设调用」
+    "工具调用失败了，原因是连接超时。",
+])
+def test_ordinary_answers_are_not(text):
+    assert not leaked_markup(text)
+
+
+async def test_an_agent_that_keeps_writing_markup_fails(monkeypatch):
+    _leaks(monkeypatch)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("query", "agent", prompt="查 orders 有多少", tools=[], max_steps=4),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.query.text }}"}]),
+    ))
+    assert row.status == "failed", f"一堆标记被当成了答案：{row.output}"
+    assert "工具调用的原始标记" in (row.error or "") and "没有真正调用工具" in (row.error or "")
+    assert row.error_node_id == "query"
+    assert "tool_markup_leak" in [e.data.get("code") for e in events if e.type == "log"]
+
+
+async def test_an_agent_gets_one_corrective_retry(monkeypatch):
+    seen = _leaks(monkeypatch, until=1)
+    row, _ = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("query", "agent", prompt="查 orders 有多少", tools=[], max_steps=4),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.query.text }}"}]),
+    ))
+    assert row.status == "succeeded", row.error
+    assert row.output["r"] == "orders 一共 12 条。"
+    retry = seen[1]
+    assert isinstance(retry[-1], HumanMessage) and "没有" in str(retry[-1].content)
+
+
+async def test_a_plain_model_call_that_writes_markup_fails(monkeypatch):
+    _leaks(monkeypatch)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("say", "llm", prompt="回答 {{ input.question }}"),
+        node("out", "output", fields=[]),
+    ))
+    assert row.status == "failed"
+    assert "工具调用的原始标记" in (row.error or "")
+    ends = [e for e in events if e.type == "llm.end" and e.node_id == "say"]
+    assert len(ends) == 2, "重试那一次也是一次模型调用，要记账"
+
+
+async def test_a_team_member_writing_markup_fails_its_step_and_the_coordinator_is_told(monkeypatch):
+    seen = _leaks(monkeypatch)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("team", "supervisor", goal="查 orders 有多少", max_rounds=3, agents=[
+            {"name": "查数员", "system": "你负责查库", "max_steps": 3}]),
+        node("out", "output", fields=[]),
+    ))
+    step = next(e.data for e in events if e.type == "agent.step.end")
+    assert step.get("failed") is True and "原始标记" in step["preview"], step
+    assert "tool_markup_leak" in [e.data.get("code") for e in events if e.type == "log"]
+    # 调度者下一轮读到的进展里有这条失败的原因
+    routes = [batch[1] for batch in seen if batch and batch[0] == "route"]
+    assert len(routes) == 2 and "原始标记" in routes[1], routes
+    assert "<｜｜DSML" not in json.dumps(row.output, ensure_ascii=False)
+
+
+async def test_markup_in_the_settle_round_keeps_what_the_agent_found(monkeypatch):
+    """步数用完后的收尾轮（不带工具）写出调用标记：不是「没绑工具」，不能判失败、把查到的丢掉。"""
+    from langchain_core.messages import ToolMessage
+
+    from app.providers import mock_model
+
+    def _decide(self, messages):
+        if self.tools:                      # 前面的步数：真的在调工具
+            done = sum(isinstance(m, ToolMessage) for m in messages)
+            return AIMessage(content=f"先算第 {done + 1} 步。", tool_calls=[
+                {"name": "calculator", "args": {"expression": f"{done} + 1"}, "id": f"c{done}"}])
+        return AIMessage(content=DSML)      # 收尾轮：还想接着查
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("query", "agent", prompt="算一下", tools=["calculator"], max_steps=2),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.query.text }}"}]),
+    ))
+    assert row.status == "succeeded", row.error
+    assert [e.type for e in events].count("tool.end") == 2
+    assert "<｜｜DSML" not in row.output["r"]
+    assert "先算第 2 步。" in row.output["r"] and "用满了 2 步" in row.output["r"], row.output
+    leak = [e.data for e in events if e.type == "log" and e.data.get("code") == "tool_markup_leak"]
+    assert leak and "收尾轮" in leak[0]["message"], leak
+
+
+async def test_markup_to_the_very_end_without_any_real_call_still_fails(monkeypatch):
+    """纠正之后步数就用完了、收尾轮还是标记：一次真调用都没有，仍是「调不了工具」。"""
+    _leaks(monkeypatch)
+    row, _ = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("query", "agent", prompt="查 orders 有多少", tools=["calculator"], max_steps=1),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.query.text }}"}]),
+    ))
+    assert row.status == "failed" and "工具调用的原始标记" in (row.error or ""), row.error
+
+
+async def test_a_member_whose_settle_round_writes_markup_keeps_its_findings(monkeypatch):
+    from langchain_core.messages import ToolMessage
+
+    from app.providers import mock_model
+
+    routed = {"n": 0}
+
+    def _decide(self, messages):
+        if self.response_format:
+            routed["n"] += 1
+            plan = ({"assignments": [{"agent": "查数员", "instruction": "算"}]} if routed["n"] == 1
+                    else {"assignments": [], "done": True, "reason": "够了"})
+            return AIMessage(content=json.dumps(plan, ensure_ascii=False))
+        if self.tools:
+            done = sum(isinstance(m, ToolMessage) for m in messages)
+            return AIMessage(content=f"第 {done + 1} 步：先算一下。", tool_calls=[
+                {"name": "calculator", "args": {"expression": "1 + 1"}, "id": f"c{done}"}])
+        return AIMessage(content=DSML)
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("team", "supervisor", goal="算一下", max_rounds=3, agents=[
+            {"name": "查数员", "system": "你负责算", "tools": ["calculator"], "max_steps": 2}]),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.team.text }}"}]),
+    ))
+    assert row.status == "succeeded", row.error
+    step = next(e.data for e in events if e.type == "agent.step.end")
+    assert not step.get("failed"), step
+    assert "第 2 步" in row.output["r"] and "<｜｜DSML" not in row.output["r"], row.output
+    assert "tool_markup_leak" in [e.data.get("code") for e in events if e.type == "log"]
diff --git a/backend/tests/test_mcp_cache.py b/backend/tests/test_mcp_cache.py
new file mode 100644
index 00000000..22c9db44
--- /dev/null
+++ b/backend/tests/test_mcp_cache.py
@@ -0,0 +1,230 @@
+"""MCP 服务改了、删了、新加了，运行时拿到的工具要跟着变。
+
+mcp_manager 按服务名缓存工具（每次都拉起一个 stdio 子进程太贵），而以前缓存只在
+「一个都没加载过」时才建：改了启动命令，运行照样用旧命令建出来的工具；删掉的服务
+照样能被节点调到；缓存建好之后新加的服务，工具列表里永远没有它，除非有人去点刷新。
+
+这里用一个假的 MCP 客户端：它建出来的工具在 description 里写着自己是按哪个命令
+（或地址）连的，于是一眼看得出拿到的是新配置还是旧配置。
+"""
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from langchain_core.tools import StructuredTool
+
+from app.main import app
+
+
+class _FakeClient:
+    """一次连接 = 一次 get_tools。connects 记下每次连的是哪个服务、按什么配置。"""
+
+    connects: list[tuple[str, str]] = []
+
+    def __init__(self, servers: dict[str, dict[str, Any]]) -> None:
+        self.servers = servers
+
+    async def get_tools(self) -> list[StructuredTool]:
+        (name, cfg), = self.servers.items()
+        via = cfg.get("command") or cfg.get("url") or ""
+        _FakeClient.connects.append((name, via))
+
+        async def _echo(text: str = "") -> str:
+            return f"{via}:{text}"
+
+        return [StructuredTool.from_function(coroutine=_echo, name="echo",
+                                             description=f"via {via}")]
+
+
+@pytest.fixture
+def manager(monkeypatch):
+    """每个测试一个干净的 McpManager，接口层和运行时拿到的是同一个。"""
+    import langchain_mcp_adapters.client as mcp_client
+
+    import app.api.tools as tools_api
+    import app.tools.mcp_manager as mcp_module
+
+    _FakeClient.connects = []
+    monkeypatch.setattr(mcp_client, "MultiServerMCPClient", _FakeClient)
+    fresh = mcp_module.McpManager()
+    monkeypatch.setattr(mcp_module, "mcp_manager", fresh)
+    monkeypatch.setattr(tools_api, "mcp_manager", fresh)
+    return fresh
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+@pytest.fixture
+async def server(client, manager):
+    """一个叫 files 的 stdio 服务，测完删掉（测试里已经删了的就不用再删）。"""
+    r = await client.post("/api/mcp/servers", json={
+        "name": "files", "transport": "stdio", "command": "fs-v1"})
+    assert r.status_code == 201, r.text
+    row = r.json()
+    yield row
+    await client.delete(f"/api/mcp/servers/{row['id']}")
+
+
+def _body(row: dict[str, Any], **changes: Any) -> dict[str, Any]:
+    keys = ("name", "transport", "command", "args", "env", "url", "enabled")
+    return {**{k: row[k] for k in keys}, **changes}
+
+
+async def _via(manager, ref: str) -> list[str]:
+    """运行时按引用取到的工具，各自是按什么配置连的。"""
+    return [t.description for t in await manager.get_tools([ref])]
+
+
+async def test_changing_the_command_drops_the_tools_built_from_the_old_one(client, manager, server):
+    assert await _via(manager, "mcp:files/echo") == ["via fs-v1"]
+
+    r = await client.patch(f"/api/mcp/servers/{server['id']}", json=_body(server, command="fs-v2"))
+    assert r.status_code == 200, r.text
+    assert "files" not in manager._tools, "保存之后旧工具就该丢掉，而不是等下次有人用"
+
+    assert await _via(manager, "mcp:files/echo") == ["via fs-v2"], "改了启动命令，运行还在用旧命令建的工具"
+    listed = [t for t in await manager.list_tools() if t["server"] == "files"]
+    assert [t["description"] for t in listed] == ["via fs-v2"]
+
+
+async def test_changing_the_address_of_an_http_server_reconnects(client, manager):
+    r = await client.post("/api/mcp/servers", json={
+        "name": "remote", "transport": "http", "url": "https://mcp-a.example/mcp"})
+    row = r.json()
+    try:
+        assert await _via(manager, "mcp:remote/*") == ["via https://mcp-a.example/mcp"]
+        await client.patch(f"/api/mcp/servers/{row['id']}",
+                           json=_body(row, url="https://mcp-b.example/mcp"))
+        assert await _via(manager, "mcp:remote/*") == ["via https://mcp-b.example/mcp"]
+    finally:
+        await client.delete(f"/api/mcp/servers/{row['id']}")
+
+
+async def test_a_deleted_server_is_gone_from_runs_and_from_the_list(client, manager, server):
+    assert await _via(manager, "mcp:files/*") == ["via fs-v1"]
+
+    r = await client.delete(f"/api/mcp/servers/{server['id']}")
+    assert r.status_code == 204
+    assert "files" not in manager._tools
+
+    assert await manager.get_tools(["mcp:files/*"]) == [], "删掉的服务还能被节点调到"
+    assert not [t for t in await manager.list_tools() if t["server"] == "files"]
+    tools = (await client.get("/api/tools")).json()
+    assert not [t for t in tools if t["id"].startswith("mcp:files/")]
+
+
+async def test_a_disabled_server_is_not_handed_out(client, manager, server):
+    assert await _via(manager, "mcp:files/*") == ["via fs-v1"]
+    await client.patch(f"/api/mcp/servers/{server['id']}", json=_body(server, enabled=False))
+    assert await manager.get_tools(["mcp:files/*"]) == []
+
+    # 再打开：下次用时照常连上
+    await client.patch(f"/api/mcp/servers/{server['id']}", json=_body(server, enabled=True))
+    assert await _via(manager, "mcp:files/*") == ["via fs-v1"]
+
+
+async def test_renaming_moves_the_tools_to_the_new_name(client, manager, server):
+    assert await _via(manager, "mcp:files/*") == ["via fs-v1"]
+    await client.patch(f"/api/mcp/servers/{server['id']}", json=_body(server, name="documents"))
+    assert await manager.get_tools(["mcp:files/*"]) == []
+    assert await _via(manager, "mcp:documents/echo") == ["via fs-v1"]
+
+
+async def test_a_server_added_after_the_cache_is_warm_shows_up(client, manager, server):
+    assert await _via(manager, "mcp:files/*") == ["via fs-v1"]
+    r = await client.post("/api/mcp/servers", json={
+        "name": "later", "transport": "stdio", "command": "later-v1"})
+    row = r.json()
+    try:
+        servers = {t["server"] for t in await manager.list_tools()}
+        assert {"files", "later"} <= servers, "缓存建好之后新加的服务，工具列表里没有它"
+        assert await _via(manager, "mcp:later/echo") == ["via later-v1"]
+    finally:
+        await client.delete(f"/api/mcp/servers/{row['id']}")
+
+
+async def test_unchanged_servers_are_not_reconnected_on_every_use(client, manager, server):
+    for _ in range(3):
+        await manager.get_tools(["mcp:files/*"])
+        await manager.list_tools()
+    assert _FakeClient.connects.count(("files", "fs-v1")) == 1
+
+    # 只改名字以外无关连接的保存（原样再存一次）也不该重连
+    await client.patch(f"/api/mcp/servers/{server['id']}", json=_body(server))
+    await manager.get_tools(["mcp:files/*"])
+    assert _FakeClient.connects.count(("files", "fs-v1")) == 1
+
+
+async def test_a_change_made_behind_the_api_is_still_noticed(client, manager, server):
+    """缓存认的是连接配置，不只是接口层的通知：库里的配置变了，下次用时就重连。"""
+    from app.db.base import SessionLocal
+    from app.db.models import McpServer
+
+    assert await _via(manager, "mcp:files/*") == ["via fs-v1"]
+    async with SessionLocal() as session:
+        row = await session.get(McpServer, server["id"])
+        row.command = "fs-v3"
+        await session.commit()
+    assert await _via(manager, "mcp:files/*") == ["via fs-v3"]
+
+
+async def test_a_load_that_raced_with_an_edit_is_not_cached(client, manager, server, monkeypatch):
+    """连接要花时间（stdio 子进程、最长 30 秒）。连到一半服务被改了，这次连的是旧配置，
+    结果不能进缓存，也不能把旧配置的「连得上」写回库里。"""
+    import asyncio
+
+    gate = asyncio.Event()
+    started = asyncio.Event()
+    original = _FakeClient.get_tools
+
+    async def _slow(self):
+        started.set()
+        await gate.wait()
+        return await original(self)
+
+    monkeypatch.setattr(_FakeClient, "get_tools", _slow)
+    loading = asyncio.create_task(manager.get_tools(["mcp:files/*"]))
+    await started.wait()
+    await client.patch(f"/api/mcp/servers/{server['id']}", json=_body(server, command="fs-v2"))
+    gate.set()
+    await loading   # 这一次拿到什么都行：它开始时配置还是旧的
+
+    async def _row() -> dict[str, Any]:
+        return next(s for s in (await client.get("/api/mcp/servers")).json() if s["id"] == server["id"])
+
+    stale = await _row()
+    assert stale["status"] == "unknown" and stale["last_check_ok"] is None, \
+        f"旧配置那次连接的结论写回了库里：{stale}"
+
+    monkeypatch.setattr(_FakeClient, "get_tools", original)
+    assert await _via(manager, "mcp:files/*") == ["via fs-v2"]
+    fresh = await _row()
+    assert fresh["status"] == "ok" and fresh["last_check_ok"] is True
+
+
+async def test_a_missing_command_is_named_in_the_error(client, manager, monkeypatch):
+    """stdio 客户端抛的 FileNotFoundError 常常不带文件名，报错里得补上配置的那条命令，
+    不能只剩一句「找不到命令 」。"""
+    async def _missing(self):
+        raise FileNotFoundError()
+
+    monkeypatch.setattr(_FakeClient, "get_tools", _missing)
+    r = await client.post("/api/mcp/servers", json={
+        "name": "ghost", "transport": "stdio", "command": "ghost-mcp-server", "args": ["--stdio"]})
+    row = r.json()
+    try:
+        assert await manager.get_tools(["mcp:ghost/*"]) == []
+        listed = next(s for s in (await client.get("/api/mcp/servers")).json() if s["id"] == row["id"])
+        assert listed["status"] == "error"
+        assert "ghost-mcp-server" in listed["last_error"], listed["last_error"]
+        probe = (await client.post(f"/api/mcp/servers/{row['id']}/probe")).json()
+        assert probe["ok"] is False and "ghost-mcp-server" in probe["error"], probe
+    finally:
+        await client.delete(f"/api/mcp/servers/{row['id']}")
diff --git a/backend/tests/test_query_deadline.py b/backend/tests/test_query_deadline.py
new file mode 100644
index 00000000..5a7030b2
--- /dev/null
+++ b/backend/tests/test_query_deadline.py
@@ -0,0 +1,402 @@
+"""查询时限要让数据库自己停下，而不只是后端不再等。
+
+以前时限只有数据层的一道 asyncio.wait_for：到点取消、放弃等待，可数据库那边的语句
+照样在跑，占着连接池里的一个连接，直到它自己跑完（Oracle 实测多占了 60 秒）；
+aiosqlite 更糟，语句在线程里跑，取消之后关连接要排在它后面，一条不收敛的查询
+就能让这次调用永远回不来。
+
+现在每条语句执行前先给数据库下一个语句级时限，到点由数据库自己中止：
+- SQLite：进度回调（progress handler），超时后返回非零，SQLite 中止当前语句；
+- PostgreSQL：SET LOCAL statement_timeout，只管这一个事务；
+- MySQL：SET SESSION max_execution_time（MariaDB 是 max_statement_time），用完恢复；
+- Oracle：驱动连接的 call_timeout，用完恢复。
+
+SQLite 用真库测；另外三家用一个记账的假连接，断言下发的语句和参数。
+数据源还可以在 options.query_timeout_s 里按源配置时限，db_query 工具把它声明在
+metadata["timeout_s"] 上，引擎据此告诉界面上限是多少。
+"""
+from __future__ import annotations
+
+import asyncio
+import sqlite3
+import time
+import types
+import uuid
+from contextlib import asynccontextmanager
+from typing import Any
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import event, text
+
+from app.data import engine as data_engine
+from app.data.engine import build_url, engines, run_query
+from app.data.guard import QueryLimits, SqlRejected
+from app.main import app
+
+#: 永远跑不完的查询：递归 CTE 没有终止条件。不靠机器快慢，时限不生效它就不会结束
+RUNAWAY = "WITH RECURSIVE c(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM c) SELECT count(*) FROM c"
+#: 跑得完、但要走过成千上万条 SQLite 指令的查询：进度回调要是没摘掉，它会被立刻中止
+BUSY = ("WITH RECURSIVE c(x) AS (SELECT 1 UNION ALL SELECT x + 1 FROM c WHERE x < 200000) "
+        "SELECT count(*) FROM c")
+
+
+def _source(path, *, readonly: bool = True, **options: Any) -> Any:
+    return types.SimpleNamespace(
+        id=f"deadline_{uuid.uuid4().hex[:8]}", name="shop", kind="sqlite", database=str(path),
+        readonly=readonly, options=options, host=None, port=None, username=None, password=None,
+        description="", schema_cache={},
+    )
+
+
+@pytest.fixture
+def shop_db(tmp_path):
+    path = tmp_path / "shop.db"
+    conn = sqlite3.connect(path)
+    conn.execute("CREATE TABLE orders (id INTEGER)")
+    conn.executemany("INSERT INTO orders VALUES (?)", [(i,) for i in range(5)])
+    conn.commit()
+    conn.close()
+    return path
+
+
+@pytest.fixture
+async def sqlite_source(shop_db):
+    """真实的 SQLite 数据源。测完把还卡在语句上的连接打断，免得时限没生效时测试进程挂住。"""
+    made: list[Any] = []
+
+    async def make(**kw: Any) -> Any:
+        source = _source(shop_db, **kw)
+        engine = (await engines.get(source)).sync_engine
+        event.listen(engine, "connect", lambda dbapi_conn, _rec: raws.append(dbapi_conn))
+        made.append(source)
+        return source
+
+    raws: list[Any] = []
+    yield make
+    for dbapi_conn in raws:
+        try:
+            dbapi_conn._connection._conn.interrupt()
+        except Exception:  # noqa: BLE001 - 已经关掉的连接
+            pass
+    for source in made:
+        await engines.invalidate(source.id)
+
+
+async def _within(coro, seconds: float) -> tuple[bool, Any, float]:
+    """跑 coro，最多等 seconds 秒；超时不取消（取消本身也会卡住），只报没回来。"""
+    started = time.perf_counter()
+    task = asyncio.ensure_future(coro)
+    done, _ = await asyncio.wait({task}, timeout=seconds)
+    if task not in done:
+        task.add_done_callback(lambda f: f.cancelled() or f.exception())
+        return False, None, time.perf_counter() - started
+    return True, task.exception() or task.result(), time.perf_counter() - started
+
+
+# --------------------------------------------------------------------------
+# SQLite：真库
+# --------------------------------------------------------------------------
+
+
+async def test_sqlite_stops_a_runaway_query_at_the_limit(sqlite_source):
+    source = await sqlite_source()
+    back, outcome, took = await _within(
+        run_query(source, RUNAWAY, limits=QueryLimits(timeout_seconds=1)), 6)
+    assert back, "查询时限到了，语句还在数据库里跑，调用一直没回来"
+    assert isinstance(outcome, SqlRejected), outcome
+    assert "1s" in str(outcome) and "被中断" in str(outcome)
+    assert took < 3, f"1s 的时限等了 {took:.1f}s"
+    engine = await engines.get(source)
+    assert engine.sync_engine.pool.checkedout() == 0, "被中断的查询还占着连接"
+
+
+async def test_the_limit_does_not_leak_onto_the_next_user_of_the_connection(sqlite_source):
+    source = await sqlite_source()
+    back, outcome, _ = await _within(
+        run_query(source, RUNAWAY, limits=QueryLimits(timeout_seconds=1)), 6)
+    assert back and isinstance(outcome, SqlRejected)
+
+    # 同一个连接（池里只剩它）接着给别人用：时限早就过了，回调要是还挂着，这条会被立刻中止
+    engine = await engines.get(source)
+    async with engine.connect() as conn:
+        assert (await conn.execute(text(BUSY))).scalar() == 200000
+    result = await run_query(source, BUSY)
+    assert result.rows == [[200000]]
+
+
+async def test_a_runaway_write_is_stopped_and_rolled_back(sqlite_source, shop_db):
+    source = await sqlite_source(readonly=False)
+    runaway_insert = ("INSERT INTO orders (id) WITH RECURSIVE c(x) AS "
+                      "(SELECT 1 UNION ALL SELECT x + 1 FROM c) SELECT x FROM c")
+    back, outcome, took = await _within(
+        run_query(source, runaway_insert, limits=QueryLimits(timeout_seconds=1)), 6)
+    assert back, "写操作的时限到了，语句还在跑"
+    assert isinstance(outcome, SqlRejected) and "已回滚" in str(outcome), outcome
+    assert took < 3
+    conn = sqlite3.connect(shop_db)
+    assert conn.execute("SELECT count(*) FROM orders").fetchone() == (5,), "被中断的写没有回滚"
+    conn.close()
+
+
+async def test_a_source_can_set_its_own_limit(sqlite_source):
+    # 表单里填的是字符串
+    source = await sqlite_source(query_timeout_s="1")
+    back, outcome, took = await _within(run_query(source, RUNAWAY), 6)
+    assert back and isinstance(outcome, SqlRejected), outcome
+    assert "1s" in str(outcome) and took < 3
+
+
+def test_the_limit_is_read_from_options_and_defaults_otherwise(shop_db):
+    from app.data.engine import query_timeout
+
+    assert query_timeout(_source(shop_db)) == QueryLimits().timeout_seconds
+    assert query_timeout(_source(shop_db, query_timeout_s="45")) == 45
+    assert query_timeout(_source(shop_db, query_timeout_s=2.5)) == 2.5
+    # 库里存着的坏值不让查询跑不起来：退回缺省
+    for bad in ("abc", "0", "-3", "", None, True, "99999"):
+        assert query_timeout(_source(shop_db, query_timeout_s=bad)) == QueryLimits().timeout_seconds, bad
+
+
+def test_the_limit_is_not_passed_to_the_driver(shop_db):
+    source = types.SimpleNamespace(
+        id="x", name="shop", kind="mysql", host="db.example", port=3306, database="shop",
+        username="reader", password=None, readonly=True,
+        options={"charset": "utf8mb4", "query_timeout_s": "60", "schema": "sales"})
+    url = build_url(source)
+    assert "charset=utf8mb4" in url
+    assert "query_timeout_s" not in url, "时限是 AgentLab 自己的配置，驱动不认识它"
+
+
+async def test_the_query_tool_declares_the_limit(sqlite_source, monkeypatch):
+    from app.engine.toolcalls import limit_of
+    from app.tools.datasource import _make_query_tool
+    from app.tools.registry import ToolContext
+
+    ctx = ToolContext(run_id="t", node_id="n")
+    default = _make_query_tool(await sqlite_source(), ctx)
+    assert default.metadata["timeout_s"] == QueryLimits().timeout_seconds
+
+    tool = _make_query_tool(await sqlite_source(query_timeout_s="1"), ctx)
+    assert tool.metadata["timeout_s"] == 1
+    limit = limit_of(tool, tool.name, {"sql": RUNAWAY})
+    assert limit.seconds == 1 and limit.kind == "query" and limit.self_timed
+
+    back, outcome, took = await _within(tool.coroutine(sql=RUNAWAY), 6)
+    assert back and "1s" in str(outcome) and took < 3, (outcome, took)
+
+
+# --------------------------------------------------------------------------
+# PostgreSQL / MySQL / MariaDB / Oracle：假连接记账
+# --------------------------------------------------------------------------
+
+
+class _Result:
+    def __init__(self, rows: list[list[Any]]) -> None:
+        self._rows = rows
+        self.returns_rows = True
+        self.rowcount = len(rows)
+
+    def keys(self) -> list[str]:
+        return ["n"]
+
+    def fetchmany(self, n: int) -> list[list[Any]]:
+        return self._rows[:n]
+
+    def __aiter__(self):
+        async def gen():
+            for row in self._rows:
+                yield row
+        return gen()
+
+
+class _FakeConn:
+    def __init__(self, log: list[str], driver: Any, mariadb: bool, fail: Exception | None) -> None:
+        self.log, self.driver, self.fail = log, driver, fail
+        self.dialect = types.SimpleNamespace(is_mariadb=mariadb)
+
+    async def execute(self, clause):
+        sql = str(clause)
+        self.log.append(sql)
+        if sql.startswith("SET"):
+            return _Result([])
+        if self.fail:
+            raise self.fail
+        return _Result([[1]])
+
+    async def stream(self, clause):
+        self.log.append(str(clause))
+        self.log.append(f"call_timeout={getattr(self.driver, 'call_timeout', None)}")
+        if self.fail:
+            raise self.fail
+        return _Result([[1]])
+
+    async def get_raw_connection(self):
+        return types.SimpleNamespace(driver_connection=self.driver)
+
+
+class _FakeEngine:
+    def __init__(self, *, mariadb: bool = False, fail: Exception | None = None) -> None:
+        self.log: list[str] = []
+        self.driver = types.SimpleNamespace(call_timeout=0)
+        self.mariadb, self.fail = mariadb, fail
+
+    @asynccontextmanager
+    async def connect(self):
+        yield _FakeConn(self.log, self.driver, self.mariadb, self.fail)
+
+    begin = connect
+
+
+def _fake(monkeypatch, **kw: Any) -> _FakeEngine:
+    fake = _FakeEngine(**kw)
+
+    async def _get(_source):
+        return fake
+
+    monkeypatch.setattr(engines, "get", _get)
+    return fake
+
+
+def _remote(kind: str, *, readonly: bool = True) -> Any:
+    return types.SimpleNamespace(id=f"r_{kind}", name="shop", kind=kind, readonly=readonly,
+                                 options={}, database="shop")
+
+
+async def test_postgres_gets_a_statement_timeout_for_this_transaction_only(monkeypatch):
+    fake = _fake(monkeypatch)
+    await run_query(_remote("postgres"), "SELECT 1", limits=QueryLimits(timeout_seconds=5))
+    assert fake.log[:2] == ["SET LOCAL statement_timeout = 5000", "SELECT 1"], fake.log
+    # SET LOCAL 随事务回滚作废，不用也不该再发一条恢复
+    assert not [s for s in fake.log[2:] if s.startswith("SET")]
+
+
+async def test_postgres_writes_are_bounded_too(monkeypatch):
+    fake = _fake(monkeypatch)
+    await run_query(_remote("postgresql", readonly=False), "UPDATE orders SET id = 1",
+                    limits=QueryLimits(timeout_seconds=5))
+    assert fake.log[:2] == ["SET LOCAL statement_timeout = 5000", "UPDATE orders SET id = 1"]
+
+
+async def test_mysql_gets_max_execution_time_and_it_is_put_back(monkeypatch):
+    fake = _fake(monkeypatch)
+    await run_query(_remote("mysql"), "SELECT 1", limits=QueryLimits(timeout_seconds=5))
+    assert fake.log[0] == "SET SESSION max_execution_time = 5000"
+    assert "SELECT 1" in fake.log
+    # 会话级设置跟着连接回池子：用完恢复成服务器的缺省，探查结构这类长操作不受它牵连
+    assert fake.log[-1] == "SET SESSION max_execution_time = DEFAULT"
+
+
+async def test_mariadb_uses_its_own_variable_in_seconds(monkeypatch):
+    fake = _fake(monkeypatch, mariadb=True)
+    await run_query(_remote("mysql"), "SELECT 1", limits=QueryLimits(timeout_seconds=5))
+    assert fake.log[0] == "SET SESSION max_statement_time = 5"
+    assert fake.log[-1] == "SET SESSION max_statement_time = DEFAULT"
+
+
+async def test_oracle_gets_a_call_timeout_and_it_is_put_back(monkeypatch):
+    fake = _fake(monkeypatch)
+    await run_query(_remote("oracle"), "SELECT 1 FROM DUAL", limits=QueryLimits(timeout_seconds=5))
+    assert "call_timeout=5000" in fake.log, fake.log
+    assert fake.driver.call_timeout == 0, "call_timeout 跟着连接回池子，探查结构时也会被它掐"
+
+
+@pytest.mark.parametrize("kind, driver_error", [
+    ("postgres", "canceling statement due to statement timeout"),
+    ("mysql", "(3024, 'Query execution was interrupted, maximum statement execution time exceeded')"),
+    ("mariadb", "(1969, 'Query execution was interrupted (max_statement_time exceeded)')"),
+    ("oracle", "DPY-4024: call timeout of 5000 ms exceeded"),
+])
+async def test_a_query_stopped_by_the_database_reads_as_a_timeout(monkeypatch, kind, driver_error):
+    _fake(monkeypatch, mariadb=kind == "mariadb", fail=RuntimeError(driver_error))
+    with pytest.raises(SqlRejected) as caught:
+        await run_query(_remote(kind), "SELECT 1", limits=QueryLimits(timeout_seconds=5))
+    assert "查询超过 5s 被中断" in str(caught.value), caught.value
+
+
+class _PgCanceled(Exception):
+    """asyncpg 的 QueryCanceledError：错误码在 sqlstate 上，文字跟着服务器的语言走。"""
+
+    sqlstate = "57014"
+
+
+class _Wrapped(Exception):
+    """SQLAlchemy 包过一层的驱动异常：原始异常在 .orig 上。"""
+
+    def __init__(self, orig: Exception) -> None:
+        super().__init__(f"(wrapped) {type(orig).__name__}")
+        self.orig = orig
+
+
+@pytest.mark.parametrize("kind, error", [
+    # 中文环境的 PostgreSQL（真库实测就是这句）：按英文原文一个也认不出来，得认错误码
+    ("postgres", _PgCanceled("由于语句执行超时，正在取消查询命令")),
+    ("postgres", _Wrapped(_PgCanceled("由于语句执行超时，正在取消查询命令"))),
+    ("mysql", RuntimeError(3024, "查询执行被中断，超过了最长执行时间")),
+    ("mariadb", _Wrapped(RuntimeError(1969, "查询执行被中断"))),
+])
+async def test_a_localized_timeout_is_recognised_by_its_code(monkeypatch, kind, error):
+    _fake(monkeypatch, mariadb=kind == "mariadb", fail=error)
+    with pytest.raises(SqlRejected) as caught:
+        await run_query(_remote(kind), "SELECT 1", limits=QueryLimits(timeout_seconds=5))
+    assert "查询超过 5s 被中断" in str(caught.value), caught.value
+
+
+async def test_other_errors_are_not_mistaken_for_a_timeout(monkeypatch):
+    _fake(monkeypatch, fail=RuntimeError('relation "orderz" does not exist'))
+    with pytest.raises(RuntimeError, match="orderz"):
+        await run_query(_remote("postgres"), "SELECT 1", limits=QueryLimits(timeout_seconds=5))
+
+
+# --------------------------------------------------------------------------
+# 接口：按源配置的时限
+# --------------------------------------------------------------------------
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+async def test_the_form_offers_the_limit_for_every_kind(client):
+    kinds = (await client.get("/api/datasources/kinds")).json()
+    for kind in kinds["kinds"]:
+        field = next((a for a in kind["advanced"] if a["key"] == "query_timeout_s"), None)
+        assert field and "秒" in field["label"], kind["value"]
+
+
+@pytest.mark.parametrize("bad", ["abc", "0", "-5", "100000"])
+async def test_a_bad_limit_is_refused_in_words(client, shop_db, bad):
+    r = await client.post("/api/datasources", json={
+        "name": f"shop_{uuid.uuid4().hex[:6]}", "kind": "sqlite", "database": str(shop_db),
+        "options": {"query_timeout_s": bad}})
+    assert r.status_code == 422, r.text
+    detail = r.json()["detail"]
+    assert isinstance(detail, str) and "查询时限" in detail, detail
+
+
+async def test_a_good_limit_is_saved_and_can_be_changed(client, shop_db):
+    r = await client.post("/api/datasources", json={
+        "name": f"shop_{uuid.uuid4().hex[:6]}", "kind": "sqlite", "database": str(shop_db),
+        "options": {"query_timeout_s": "45"}})
+    assert r.status_code == 201, r.text
+    row = r.json()
+    try:
+        r = await client.patch(f"/api/datasources/{row['id']}",
+                               json={"options": {"query_timeout_s": "nope"}})
+        assert r.status_code == 422
+        r = await client.patch(f"/api/datasources/{row['id']}",
+                               json={"options": {"query_timeout_s": "90"}})
+        assert r.status_code == 200 and r.json()["options"]["query_timeout_s"] == "90"
+    finally:
+        await client.delete(f"/api/datasources/{row['id']}")
+
+
+def test_the_data_layer_backstop_stays_inside_the_engine_grace():
+    """数据库按时限停下之后，数据层自己的兜底要比引擎放弃得早：引擎放弃时只撒手、
+    不取消（见 toolcalls.Limit.self_timed），数据层这句「超过 Ns 被中断」才是给人看的那句。"""
+    from app.engine.toolcalls import GRACE_S
+
+    assert 0 < data_engine.BACKSTOP_S < GRACE_S
diff --git a/backend/tests/test_replay_side_effects.py b/backend/tests/test_replay_side_effects.py
new file mode 100644
index 00000000..43965e6a
--- /dev/null
+++ b/backend/tests/test_replay_side_effects.py
@@ -0,0 +1,317 @@
+"""审批恢复之后，节点从头重放；已经执行过的工具不能再执行一次，也不能在轨迹里再"执行"一次。
+
+LangGraph 恢复一个停在 interrupt 上的节点，是把整个节点函数从头再跑一遍，
+interrupt() 按出现的顺序返回已经给过的答复。节点里一连串的「问人 → 调工具」
+于是每恢复一次就重放一遍前面所有的步骤：
+
+- 工具真的再执行一次，副作用就翻倍（写库、发请求、沙箱里改文件）；
+- 就算结果取自缓存，重放时照样发一遍 human.requested / human.resolved /
+  tool.start / tool.end，时间线和审计轨迹里同一次调用出现两回——运行 fac480ff
+  的轨迹里 python_exec 就这么「执行了两次」，排查的人只能照字面理解。
+
+这里用一个带副作用计数的工具，在同一个节点里连续审批两次、恢复两次。
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+
+import pytest
+from langchain_core.messages import AIMessage, ToolMessage
+from pydantic import BaseModel
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Run, RunEvent
+from app.engine.runner import run_manager
+from app.tools.registry import register
+
+#: 真实执行次数。注册表是进程级的，所以工具只注册一次，计数按测试清零
+CALLS: list[dict] = []
+
+
+class _TallyArgs(BaseModel):
+    label: str
+
+
+@register("tally_side_effect", "测试用：每执行一次记一笔", "test", _TallyArgs,
+          dangerous=True, needs_context=False)
+async def _tally(label: str) -> str:
+    CALLS.append({"label": label})
+    return json.dumps({"label": label, "n": len(CALLS)})
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    CALLS.clear()
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def chain(*nodes):
+    return {"nodes": list(nodes),
+            "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
+
+
+async def _wait(run_id: str, statuses: tuple[str, ...], timeout: float = 20.0) -> Run:
+    deadline = asyncio.get_event_loop().time() + timeout
+    while asyncio.get_event_loop().time() < deadline:
+        async with SessionLocal() as session:
+            row = await session.get(Run, run_id)
+            if row and row.status in statuses:
+                return row
+        await asyncio.sleep(0.05)
+    raise AssertionError(f"等超时了，run {run_id} 没有进入 {statuses}")
+
+
+async def _events(run_id: str) -> list[RunEvent]:
+    async with SessionLocal() as session:
+        return list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run_id).order_by(RunEvent.seq)
+        )).scalars())
+
+
+def _script_two_calls(monkeypatch) -> None:
+    """第一轮调一次、看到结果再调一次、看到两次结果就收口。"""
+    from app.providers import mock_model
+
+    def _decide(self, messages):
+        done = sum(isinstance(m, ToolMessage) for m in messages)
+        if self.tools and done < 2:
+            return AIMessage(content="", tool_calls=[
+                {"name": "tally_side_effect", "args": {"label": f"第{done + 1}次"},
+                 "id": f"call_{done + 1}"}])
+        return AIMessage(content="两次都记好了。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+
+
+async def _approve_until_done(run_id: str, times: int) -> Run:
+    for _ in range(times):
+        run = await _wait(run_id, ("interrupted", "failed", "succeeded"))
+        assert run.status == "interrupted", f"还没审批就结束了：{run.status} {run.error}"
+        await run_manager.resume(run_id, {"approved": True})
+    return await _wait(run_id, ("failed", "succeeded"))
+
+
+async def test_an_agent_that_asks_twice_runs_each_tool_exactly_once(monkeypatch):
+    _script_two_calls(monkeypatch)
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="记两笔", tools=["tally_side_effect"],
+             approval="always", max_steps=5),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.bot.text }}"}]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "记两笔"})
+    final = await _approve_until_done(run.id, 2)
+
+    assert final.status == "succeeded", final.error
+    assert [c["label"] for c in CALLS] == ["第1次", "第2次"], f"副作用翻倍了：{CALLS}"
+
+    events = await _events(run.id)
+    starts = [e.data["call_id"] for e in events if e.type == "tool.start"]
+    ends = [e.data["call_id"] for e in events if e.type == "tool.end"]
+    # 每次调用在轨迹里只出现一回：重放取的是缓存，不是又执行了一次
+    assert starts == ["call_1", "call_2"], starts
+    assert ends == ["call_1", "call_2"], ends
+    asked = [e.data.get("tool") for e in events if e.type == "human.requested"]
+    answered = [e.data.get("approved") for e in events if e.type == "human.resolved"]
+    assert asked == ["tally_side_effect", "tally_side_effect"], asked
+    assert answered == [True, True], answered
+
+
+async def test_parallel_tool_calls_after_one_approval_are_not_replayed(monkeypatch):
+    """一轮里两个调用、各要审批一次：第二次恢复时第一个已经跑过的不能再跑。"""
+    from app.providers import mock_model
+
+    def _decide(self, messages):
+        if self.tools and not any(isinstance(m, ToolMessage) for m in messages):
+            return AIMessage(content="", tool_calls=[
+                {"name": "tally_side_effect", "args": {"label": "甲"}, "id": "call_a"},
+                {"name": "tally_side_effect", "args": {"label": "乙"}, "id": "call_b"},
+            ])
+        return AIMessage(content="都记了。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="记两笔", tools=["tally_side_effect"],
+             approval="always", parallel_tools=True, max_steps=3),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "记"})
+    final = await _approve_until_done(run.id, 2)
+
+    assert final.status == "succeeded", final.error
+    assert sorted(c["label"] for c in CALLS) == ["乙", "甲"], CALLS
+    starts = [e.data["call_id"] for e in await _events(run.id) if e.type == "tool.start"]
+    assert starts == ["call_a", "call_b"], starts
+
+
+async def test_a_tool_node_asks_once_in_the_trail():
+    """工具节点恢复时整个节点重放：请求审批那条以前会再发一遍，时间线上像是又问了一次。"""
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("t", "tool", tool="tally_side_effect", args={"label": "一次"}, approval="always"),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "x"})
+    final = await _approve_until_done(run.id, 1)
+    assert final.status == "succeeded", final.error
+    assert len(CALLS) == 1
+
+    kinds = [e.type for e in await _events(run.id) if e.node_id == "t"]
+    assert kinds.count("human.requested") == 1, kinds
+    assert kinds.count("human.resolved") == 1, kinds
+    assert kinds.count("tool.start") == 1, kinds
+
+
+async def test_a_human_node_is_requested_once():
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("h", "human", mode="approve", title="看一眼"),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "x"})
+    final = await _approve_until_done(run.id, 1)
+    assert final.status == "succeeded", final.error
+    kinds = [e.type for e in await _events(run.id) if e.node_id == "h"]
+    assert kinds.count("human.requested") == 1, kinds
+    assert kinds.count("human.resolved") == 1, kinds
+
+
+async def test_continuing_after_a_failure_does_not_repeat_the_tool_in_the_trail(monkeypatch):
+    """模型调用在工具之后挂了，接着跑：工具结果取自断点，轨迹里也不能再出现一次执行。"""
+    from app.providers import mock_model
+
+    state = {"fail": True}
+
+    def _decide(self, messages):
+        if self.tools and not any(isinstance(m, ToolMessage) for m in messages):
+            return AIMessage(content="", tool_calls=[
+                {"name": "tally_side_effect", "args": {"label": "只一次"}, "id": "call_once"}])
+        if state["fail"]:
+            raise RuntimeError("供应商那边断了")
+        return AIMessage(content="好了。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="记一笔", tools=["tally_side_effect"], approval="never",
+             max_steps=3),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "x"})
+    first = await _wait(run.id, ("failed", "succeeded"))
+    assert first.status == "failed"
+
+    state["fail"] = False
+    await run_manager.continue_failed(run.id)
+    final = await _wait(run.id, ("failed", "succeeded"))
+    assert final.status == "succeeded", final.error
+    assert len(CALLS) == 1
+    starts = [e.data["call_id"] for e in await _events(run.id) if e.type == "tool.start"]
+    assert starts == ["call_once"], starts
+
+
+# --------------------------------------------------------------------------
+# 升级前停下的断点
+#
+# LangGraph 认 task 缓存靠「函数名 + 节点里第几次调用」。这一版多了 once / ask 的记录
+# task、tool_step 也换了位置：旧版停下的断点照新代码重放，节点里已经执行过的工具对不上
+# 旧位置，会再执行一次。checkpoint 的 metadata 里记着重放协议版本，对不上又有这种风险
+# 时拒绝恢复。这里把「旧版」模拟成协议版本低一号写下的断点。
+# --------------------------------------------------------------------------
+
+
+def _older_protocol(monkeypatch) -> None:
+    from app.engine import runner
+
+    monkeypatch.setattr(runner, "PROTOCOL", runner.PROTOCOL - 1)
+
+
+def _upgrade(monkeypatch) -> None:
+    from app.engine import replay, runner
+
+    monkeypatch.setattr(runner, "PROTOCOL", replay.PROTOCOL)
+
+
+async def test_an_old_pause_after_tools_ran_is_refused(monkeypatch):
+    _script_two_calls(monkeypatch)
+    _older_protocol(monkeypatch)
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="记两笔", tools=["tally_side_effect"],
+             approval="always", max_steps=5),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "记两笔"})
+    await _wait(run.id, ("interrupted",))
+    await run_manager.wait_idle(run.id)
+    await run_manager.resume(run.id, {"approved": True})        # 第一笔：旧版里批的、执行的
+    await asyncio.sleep(0.1)
+    await _wait(run.id, ("interrupted",))
+    await run_manager.wait_idle(run.id)
+    assert len(CALLS) == 1
+
+    _upgrade(monkeypatch)
+    with pytest.raises(ValueError, match="再执行一次"):
+        await run_manager.resume(run.id, {"approved": True})
+    assert len(CALLS) == 1
+    async with SessionLocal() as session:
+        row = await session.get(Run, run.id)
+    assert row.status == "interrupted", "拒绝恢复不能动运行的状态：它还可以被放弃"
+    assert await run_manager.cancel(run.id) == "cancelled"
+
+
+async def test_an_old_pause_before_anything_ran_still_resumes(monkeypatch):
+    """停在第一次审批上、之前什么都没做：重放只会多发一条 human.requested，照常放行。"""
+    _script_two_calls(monkeypatch)
+    _older_protocol(monkeypatch)
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="记两笔", tools=["tally_side_effect"],
+             approval="always", max_steps=5),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "记两笔"})
+    await _wait(run.id, ("interrupted",))
+    await run_manager.wait_idle(run.id)
+
+    _upgrade(monkeypatch)
+    final = await _approve_until_done(run.id, 2)
+    assert final.status == "succeeded", final.error
+    assert [c["label"] for c in CALLS] == ["第1次", "第2次"]
+
+
+async def test_continuing_an_old_failure_after_tools_ran_is_refused(monkeypatch):
+    from app.providers import mock_model
+
+    def _decide(self, messages):
+        if self.tools and not any(isinstance(m, ToolMessage) for m in messages):
+            return AIMessage(content="", tool_calls=[
+                {"name": "tally_side_effect", "args": {"label": "只一次"}, "id": "call_once"}])
+        raise RuntimeError("供应商那边断了")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    _older_protocol(monkeypatch)
+    graph = chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="记一笔", tools=["tally_side_effect"], approval="never",
+             max_steps=3),
+        node("out", "output", fields=[]),
+    )
+    run = await run_manager.start(graph=graph, input_payload={"question": "x"})
+    assert (await _wait(run.id, ("failed", "succeeded"))).status == "failed"
+    await run_manager.wait_idle(run.id)
+
+    _upgrade(monkeypatch)
+    with pytest.raises(ValueError, match="再执行一次"):
+        await run_manager.continue_failed(run.id)
+    assert len(CALLS) == 1
diff --git a/backend/tests/test_run_races.py b/backend/tests/test_run_races.py
new file mode 100644
index 00000000..b8172d5c
--- /dev/null
+++ b/backend/tests/test_run_races.py
@@ -0,0 +1,288 @@
+"""运行收尾和几条并发路径上的竞态。
+
+终态事件和运行记录要同时可见。两边都有人在读：
+- 收到 run.finished 的客户端马上 GET 这次运行取完整成果（事件里的 output 是截断的）；
+  以前先落事件、隔一个事务才提交状态，每次都读到 running 和空的 output，问数据页
+  于是把截断过的成果标成残缺存进会话；
+- 读到 failed 的一方马上去翻事件，要翻得到 run.failed。更早以前是先提交状态，这一边
+  偶尔翻不到。
+两边都要成立，只能放进同一个事务。
+
+恢复 / 接着跑和「放弃这次运行」抢同一次运行：读到 interrupted 之后隔了好几次 await
+才写 running，放弃正好在这中间提交的话，一次已经取消、封存、发过 run.cancelled 的
+运行会被改回 running，又拉起来跑。
+
+刚停到审批上、还在落 interrupted 状态的那一刻点「放弃」：以前直接取消执行任务，把
+收尾从中间打断——状态停在 running、审批还挂着、任务没了，再点一次只剩 409。
+"""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+from sqlalchemy import select
+
+from app.core.bus import bus
+from app.db.base import SessionLocal
+from app.db.models import Approval, Run, RunEvent
+from app.engine import compiler, runner
+from app.engine.context import NodeError
+from app.engine.runner import RunManager, run_manager
+from app.engine.schema import NodeType
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def chain(*nodes):
+    return {"nodes": list(nodes),
+            "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
+
+
+@pytest.fixture
+def slow(monkeypatch):
+    """transform 节点慢一点，好让订阅先接上；id 为 boom 的直接失败，id 为 stuck 的一直卡着。"""
+    original = compiler.RUNNERS[NodeType.TRANSFORM]
+
+    async def run(state, ctx):
+        await asyncio.sleep(30 if ctx.node.id == "stuck" else 0.15)
+        if ctx.node.id == "boom":
+            raise NodeError(ctx.node.id, "炸了")
+        return await original(state, ctx)
+
+    monkeypatch.setitem(compiler.RUNNERS, NodeType.TRANSFORM, run)
+
+
+def _graph(work_id: str = "work", *, gate: bool = False) -> dict:
+    nodes = [node("start", "input", fields=[{"name": "q"}]),
+             node(work_id, "transform", mode="template", template="成果全文")]
+    if gate:
+        nodes.append(node("gate", "human", mode="approve", title="放行吗"))
+    nodes.append(node("out", "output", fields=[{"name": "r", "value": f"{{{{ nodes.{work_id} }}}}"}]))
+    return chain(*nodes)
+
+
+async def _status(run_id: str) -> str:
+    async with SessionLocal() as session:
+        return (await session.get(Run, run_id)).status
+
+
+async def _until(check, timeout: float = 15.0) -> None:
+    deadline = asyncio.get_event_loop().time() + timeout
+    while asyncio.get_event_loop().time() < deadline:
+        if await check():
+            return
+        await asyncio.sleep(0.02)
+    raise AssertionError("等超时了")
+
+
+async def _events(run_id: str) -> list[RunEvent]:
+    async with SessionLocal() as session:
+        return list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run_id).order_by(RunEvent.seq)
+        )).scalars())
+
+
+async def _row_when(run_id: str, terminal: str, act=None) -> Run:
+    """订阅这次运行，一收到 terminal 事件就读运行记录——客户端就是这么做的。"""
+    sub = bus.attach(run_id)
+    acting = asyncio.ensure_future(act()) if act is not None else None
+    try:
+        async for event in sub.stream():
+            if str(event.type) == terminal:
+                async with SessionLocal() as session:
+                    return await session.get(Run, run_id)
+    finally:
+        sub.close()
+        if acting is not None:
+            await acting
+    raise AssertionError(f"没等到 {terminal}")
+
+
+# --------------------------------------------------------------------------
+# 终态事件和运行记录同时可见
+# --------------------------------------------------------------------------
+
+
+async def test_the_run_is_final_when_run_finished_arrives(slow):
+    for _ in range(5):
+        run = await run_manager.start(graph=_graph(), input_payload={"q": "x"})
+        row = await _row_when(run.id, "run.finished")
+        assert row.status == "succeeded", f"收到 run.finished 时运行还是 {row.status}"
+        assert row.output == {"r": "成果全文"}, row.output
+        assert row.finished_at is not None and row.usage.get("wall_ms") is not None
+        await run_manager.wait_idle(run.id)
+
+
+async def test_the_run_is_final_when_run_failed_arrives(slow):
+    for _ in range(5):
+        run = await run_manager.start(graph=_graph("boom"), input_payload={"q": "x"})
+        row = await _row_when(run.id, "run.failed")
+        assert row.status == "failed" and "炸了" in (row.error or ""), (row.status, row.error)
+        assert row.error_node_id == "boom"
+        await run_manager.wait_idle(run.id)
+
+
+async def test_the_terminal_event_is_there_once_the_status_is(slow):
+    """反方向：读到终态状态时，终态事件一定已经在库里。"""
+    for work_id, terminal in (("work", "run.finished"), ("boom", "run.failed")):
+        for _ in range(3):
+            run = await run_manager.start(graph=_graph(work_id), input_payload={"q": "x"})
+
+            async def settled(run_id=run.id) -> bool:
+                return await _status(run_id) in ("succeeded", "failed")
+
+            await _until(settled)
+            assert (await _events(run.id))[-1].type == terminal
+            await run_manager.wait_idle(run.id)
+
+
+async def test_the_run_is_final_when_a_stop_arrives(slow):
+    run = await run_manager.start(graph=_graph("stuck"), input_payload={"q": "x"})
+    await _until(lambda: _started(run.id, "stuck"))
+    row = await _row_when(run.id, "run.cancelled", act=lambda: run_manager.cancel(run.id))
+    assert row.status == "cancelled" and row.finished_at is not None
+
+
+async def test_the_run_is_final_when_an_abandon_arrives(slow):
+    run = await run_manager.start(graph=_graph(gate=True), input_payload={"q": "x"})
+    await _until(lambda: _is(run.id, "interrupted"))
+    await run_manager.wait_idle(run.id)
+    row = await _row_when(run.id, "run.cancelled", act=lambda: run_manager.cancel(run.id))
+    assert row.status == "cancelled" and row.finished_at is not None
+    assert row.last_seq == (await _events(run.id))[-1].seq
+
+
+async def _started(run_id: str, node_id: str) -> bool:
+    return any(e.type == "node.started" and e.node_id == node_id for e in await _events(run_id))
+
+
+async def _is(run_id: str, status: str) -> bool:
+    return await _status(run_id) == status
+
+
+# --------------------------------------------------------------------------
+# 恢复 / 接着跑 和 放弃 抢同一次运行
+# --------------------------------------------------------------------------
+
+
+async def _suspended_run() -> str:
+    """服务重启挂起的运行：interrupted，没有待审批，断点完好。"""
+    run = await run_manager.start(graph=_graph("stuck"), input_payload={"q": "x"})
+    await _until(lambda: _started(run.id, "stuck"))
+    await run_manager.shutdown()
+    await run_manager.setup()
+    assert await _status(run.id) == "interrupted"
+    return run.id
+
+
+def _abandon_in_between(monkeypatch) -> None:
+    """在「读到 interrupted」和「写 running」之间，放弃这次运行的请求先提交了。"""
+    async def racing(run_id, spec, snapshot):
+        assert await run_manager._abandon(run_id, "另一个人")
+        return None
+
+    monkeypatch.setattr(runner, "_stale_replay", racing)
+
+
+@pytest.mark.parametrize("path", ["resume", "continue"])
+async def test_a_run_abandoned_mid_way_is_not_revived(slow, monkeypatch, path):
+    run_id = await _suspended_run()
+    _abandon_in_between(monkeypatch)
+    with pytest.raises(ValueError, match="已取消"):
+        if path == "resume":
+            await run_manager.resume(run_id, None)
+        else:
+            await run_manager.continue_failed(run_id)
+    assert not run_manager.is_active(run_id), "取消了的运行又被拉起来跑了"
+    assert await _status(run_id) == "cancelled"
+    events = await _events(run_id)
+    assert events[-1].type == "run.cancelled" and not [e for e in events if e.type == "run.resumed"]
+
+
+async def test_an_approval_closed_by_an_abandon_is_not_answered_again(slow, monkeypatch):
+    run = await run_manager.start(graph=_graph(gate=True), input_payload={"q": "x"})
+    await _until(lambda: _is(run.id, "interrupted"))
+    await run_manager.wait_idle(run.id)
+    _abandon_in_between(monkeypatch)
+    with pytest.raises(ValueError):
+        await run_manager.resume(run.id, {"approved": True})
+    async with SessionLocal() as session:
+        approval = (await session.execute(
+            select(Approval).where(Approval.run_id == run.id))).scalar_one()
+    assert approval.status == "cancelled", approval.status
+    assert await _status(run.id) == "cancelled" and not run_manager.is_active(run.id)
+
+
+# --------------------------------------------------------------------------
+# 刚停到审批上、还在落状态时点「放弃」
+# --------------------------------------------------------------------------
+
+
+async def test_abandoning_while_the_pause_is_being_recorded(slow, monkeypatch):
+    original = RunManager._finalize
+    recording = asyncio.Event()
+
+    async def slow_finalize(self, run_id, status, *args, **kwargs):
+        if status == "interrupted":
+            recording.set()
+            await asyncio.sleep(0.4)        # 落 interrupted 状态的这一段被拉长
+        return await original(self, run_id, status, *args, **kwargs)
+
+    monkeypatch.setattr(RunManager, "_finalize", slow_finalize)
+    run = await run_manager.start(graph=_graph(gate=True), input_payload={"q": "x"})
+    await asyncio.wait_for(recording.wait(), 10)
+    assert run.id in run_manager._finalizing
+
+    assert await run_manager.cancel(run.id, actor="审核员") == "cancelled"
+    assert await _status(run.id) == "cancelled"
+    async with SessionLocal() as session:
+        approval = (await session.execute(
+            select(Approval).where(Approval.run_id == run.id))).scalar_one()
+    assert approval.status == "cancelled" and approval.resolved_by == "审核员"
+    assert (await _events(run.id))[-1].type == "run.cancelled"
+
+
+async def test_an_approval_closed_just_before_it_is_marked_answered(slow, monkeypatch):
+    """放弃恰好提交在「读到这条审批还是 pending」和「把它记成已回复」之间。"""
+    import sqlite3
+
+    from sqlalchemy import event
+
+    from app.db.base import engine
+
+    run = await run_manager.start(graph=_graph(gate=True), input_payload={"q": "x"})
+    await _until(lambda: _is(run.id, "interrupted"))
+    await run_manager.wait_idle(run.id)
+    armed = {"on": True}
+
+    def abandon_first(conn, cursor, statement, params, context, executemany):
+        if armed["on"] and statement.lstrip().upper().startswith("UPDATE APPROVALS"):
+            armed["on"] = False
+            other = sqlite3.connect(engine.url.database, timeout=5)
+            other.execute("UPDATE approvals SET status='cancelled' WHERE run_id=?", (run.id,))
+            other.execute("UPDATE runs SET status='cancelled' WHERE id=?", (run.id,))
+            other.commit()
+            other.close()
+
+    event.listen(engine.sync_engine, "before_cursor_execute", abandon_first)
+    try:
+        with pytest.raises(ValueError, match="已经处理过了|放弃"):
+            await run_manager.resume(run.id, {"approved": True})
+    finally:
+        event.remove(engine.sync_engine, "before_cursor_execute", abandon_first)
+    assert not armed["on"]
+    async with SessionLocal() as session:
+        approval = (await session.execute(
+            select(Approval).where(Approval.run_id == run.id))).scalar_one()
+    assert approval.status == "cancelled", "关掉的审批被改回了已回复"
+    assert not run_manager.is_active(run.id)
diff --git a/backend/tests/test_runs_cancel_waiting.py b/backend/tests/test_runs_cancel_waiting.py
new file mode 100644
index 00000000..91b07dde
--- /dev/null
+++ b/backend/tests/test_runs_cancel_waiting.py
@@ -0,0 +1,245 @@
+"""停在审批上的运行要能放弃；记录页要能只看「没保存的工作流」跑出来的运行。
+
+放弃：等审批的运行此时没有执行任务，以前 POST /cancel 只会去取消任务，于是一律
+回 409「已经不在执行中」。可它明明还挂着一条待审批——界面上右栏的「去审批」旁边
+给不出「放弃这次运行」，审批卡留在全局待办里，只能批了它、让它跑完。服务重启
+挂起的运行（interrupted、没有待审批）同样没法收掉。
+
+真正的取消：状态置为 cancelled，待审批一并关掉（不再出现在待办里，也不能再批），
+发 run.cancelled 并封存；在线的客户端收到结束标记。
+"""
+from __future__ import annotations
+
+import asyncio
+from urllib.parse import quote
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Approval, Run, RunEvent, Workflow
+from app.engine.runner import run_manager
+from app.main import app
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+@pytest.fixture
+async def client():
+    transport = ASGITransport(app=app)
+    async with AsyncClient(transport=transport, base_url="http://test") as c:
+        yield c
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+GATED = {
+    "nodes": [
+        node("start", "input", fields=[{"name": "question"}]),
+        node("gate", "human", mode="approve", title="放行吗"),
+        node("out", "output", fields=[{"name": "r", "value": "{{ nodes.gate.approved }}"}]),
+    ],
+    "edges": [{"source": "start", "target": "gate"}, {"source": "gate", "target": "out"}],
+}
+
+
+async def _wait(run_id: str, statuses: tuple[str, ...], timeout: float = 15.0) -> Run:
+    deadline = asyncio.get_event_loop().time() + timeout
+    while asyncio.get_event_loop().time() < deadline:
+        async with SessionLocal() as session:
+            row = await session.get(Run, run_id)
+            if row and row.status in statuses:
+                return row
+        await asyncio.sleep(0.05)
+    raise AssertionError(f"run {run_id} 没有进入 {statuses}")
+
+
+async def _waiting_run() -> str:
+    run = await run_manager.start(graph=GATED, input_payload={"question": "x"})
+    await _wait(run.id, ("interrupted",))
+    await run_manager.wait_idle(run.id)
+    return run.id
+
+
+async def _events(run_id: str) -> list[RunEvent]:
+    async with SessionLocal() as session:
+        return list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run_id).order_by(RunEvent.seq)
+        )).scalars())
+
+
+async def test_a_run_waiting_for_approval_can_be_abandoned(client):
+    run_id = await _waiting_run()
+    r = await client.post(f"/api/runs/{run_id}/cancel", headers={"X-Actor": quote("审核员甲")})
+    assert r.status_code == 200, r.text
+    assert r.json()["status"] == "cancelled"
+
+    row = (await client.get(f"/api/runs/{run_id}")).json()
+    assert row["status"] == "cancelled"
+    assert row["finished_at"] and row["manifest_seq"], "取消是终态：要收尾时间，也要封存"
+    assert row["usage"]["wait_ms"] >= 0
+
+    # 待审批一并关掉：不再出现在待办里，谁关的记下来
+    assert (await client.get("/api/approvals", params={"status": "pending",
+                                                        "run_id": run_id})).json() == []
+    async with SessionLocal() as session:
+        approval = (await session.execute(
+            select(Approval).where(Approval.run_id == run_id))).scalar_one()
+    assert approval.status == "cancelled"
+    assert approval.resolved_by == "审核员甲" and approval.resolved_at is not None
+
+    events = await _events(run_id)
+    last = events[-1]
+    assert last.type == "run.cancelled", [e.type for e in events[-3:]]
+    assert set(last.data["timing"]) == {"wall_ms", "active_ms", "wait_ms"}
+    assert last.data.get("actor") == "审核员甲"
+    verified = (await client.get(f"/api/runs/{run_id}/verify")).json()
+    assert verified["sealed"] and verified["ok"], verified
+
+
+async def test_an_abandoned_run_cannot_be_approved_or_continued(client):
+    run_id = await _waiting_run()
+    assert (await client.post(f"/api/runs/{run_id}/cancel")).status_code == 200
+    async with SessionLocal() as session:
+        approval = (await session.execute(
+            select(Approval).where(Approval.run_id == run_id))).scalar_one()
+
+    r = await client.post(f"/api/approvals/{approval.id}/decide", json={"approved": True})
+    assert r.status_code == 409
+    r = await client.post(f"/api/runs/{run_id}/resume", json={"response": True})
+    assert r.status_code == 409
+    r = await client.post(f"/api/runs/{run_id}/continue", json={})
+    assert r.status_code == 409 and "已取消" in r.json()["detail"]
+    # 再取消一次是 409：已经是终态了
+    r = await client.post(f"/api/runs/{run_id}/cancel")
+    assert r.status_code == 409
+
+
+async def test_a_run_suspended_by_a_restart_can_be_abandoned_too(client):
+    async with SessionLocal() as session:
+        run = Run(workflow_name="挂起", status="interrupted", graph=GATED, input={},
+                  error="服务重启，运行已挂起，可从断点恢复")
+        session.add(run)
+        await session.commit()
+        run_id = run.id
+    r = await client.post(f"/api/runs/{run_id}/cancel")
+    assert r.status_code == 200, r.text
+    row = (await client.get(f"/api/runs/{run_id}")).json()
+    assert row["status"] == "cancelled"
+    assert (await _events(run_id))[-1].type == "run.cancelled"
+
+
+async def test_finished_runs_still_refuse_to_be_cancelled(client):
+    async with SessionLocal() as session:
+        run = Run(workflow_name="完了", status="succeeded", graph=GATED, input={})
+        session.add(run)
+        await session.commit()
+        run_id = run.id
+    r = await client.post(f"/api/runs/{run_id}/cancel")
+    assert r.status_code == 409
+    assert "已完成" in r.json()["detail"]
+    assert (await client.post("/api/runs/nope/cancel")).status_code == 404
+
+
+class _Socket:
+    """够 stream_run 用的最小 WebSocket：记下发出去的帧。"""
+
+    def __init__(self) -> None:
+        self.query_params: dict[str, str] = {}
+        self.sent: list[dict] = []
+        self.closed = asyncio.Event()
+
+    async def accept(self) -> None:
+        pass
+
+    async def send_json(self, frame: dict) -> None:
+        self.sent.append(frame)
+
+    async def receive_text(self) -> str:
+        await self.closed.wait()
+        from starlette.websockets import WebSocketDisconnect
+
+        raise WebSocketDisconnect()
+
+    async def close(self) -> None:
+        self.closed.set()
+
+
+async def test_a_live_stream_ends_when_the_waiting_run_is_abandoned():
+    """停在审批上时在线的连接不关（它在等恢复）。放弃之后它要收到 run.cancelled 和结束标记。"""
+    from app.api.runs import stream_run
+
+    run_id = await _waiting_run()
+    async with SessionLocal() as session:
+        # 让连接以为运行还在进行：审批停下时在线的客户端就是这个处境
+        (await session.get(Run, run_id)).status = "running"
+        await session.commit()
+    socket = _Socket()
+    listening = asyncio.create_task(stream_run(socket, run_id))
+    await asyncio.sleep(0.2)
+    async with SessionLocal() as session:
+        (await session.get(Run, run_id)).status = "interrupted"
+        await session.commit()
+
+    assert await run_manager.cancel(run_id) == "cancelled"
+    await asyncio.wait_for(listening, 5)
+    types = [f.get("type") for f in socket.sent]
+    assert "run.cancelled" in types, types
+    assert socket.sent[-1]["type"] == "stream.end"
+    assert socket.sent[-1]["data"]["status"] == "cancelled"
+
+
+# --------------------------------------------------------------------------
+# 记录页：只看没保存的工作流跑出来的运行
+# --------------------------------------------------------------------------
+
+
+async def test_runs_can_be_filtered_to_unsaved_workflows(client):
+    async with SessionLocal() as session:
+        workflow = Workflow(name="已保存的", graph=GATED)
+        session.add(workflow)
+        await session.flush()
+        saved = Run(workflow_id=workflow.id, workflow_name="已保存的", graph=GATED, input={},
+                    status="succeeded")
+        loose = Run(workflow_id=None, workflow_name="临时图", graph=GATED, input={},
+                    status="succeeded")
+        session.add_all([saved, loose])
+        await session.commit()
+        saved_id, loose_id = saved.id, loose.id
+
+    ids = [r["id"] for r in (await client.get(
+        "/api/runs", params={"workflow_id": "__none__", "limit": 200})).json()]
+    assert loose_id in ids and saved_id not in ids
+    assert all(r["workflow_id"] is None for r in (await client.get(
+        "/api/runs", params={"workflow_id": "__none__"})).json())
+
+
+async def test_stopping_a_running_run_records_who_stopped_it(client, monkeypatch):
+    from app.engine import compiler
+    from app.engine.schema import NodeType
+
+    async def slow(state, ctx):
+        await asyncio.sleep(5)
+        return {"nodes": {ctx.node.id: "x"}}
+
+    monkeypatch.setitem(compiler.RUNNERS, NodeType.TRANSFORM, slow)
+    graph = {"nodes": [node("start", "input"), node("work", "transform", mode="template", template="x")],
+             "edges": [{"source": "start", "target": "work"}]}
+    run = await run_manager.start(graph=graph, input_payload={})
+    await _wait(run.id, ("running",))
+    await asyncio.sleep(0.2)
+    r = await client.post(f"/api/runs/{run.id}/cancel", headers={"X-Actor": quote("值班员")})
+    assert r.json()["status"] == "stopping"
+    await _wait(run.id, ("cancelled",))
+    await run_manager.wait_idle(run.id)
+    last = (await _events(run.id))[-1]
+    assert last.type == "run.cancelled" and last.data["actor"] == "值班员", last.data
diff --git a/backend/tests/test_team_exhausted.py b/backend/tests/test_team_exhausted.py
new file mode 100644
index 00000000..9fc5137d
--- /dev/null
+++ b/backend/tests/test_team_exhausted.py
@@ -0,0 +1,214 @@
+"""协作团队用完轮数、调度者始终没判定完成：不许把成员原话当作成功结果交出去。
+
+一次真实运行：成员没有工具，模型把工具调用标记当文字写了四轮；调度者每轮都说
+「核对员还没查到数据，本轮继续派核对员」，四轮用完，节点把核对员最后那段标记
+当作结论交了出去，运行 succeeded。负责写结论的成员一次都没被派到。
+
+新配置 on_exhausted：fail（默认）判失败，说清调度者最后一轮的理由、谁从没被派到；
+degrade 照样交付，但产出里带 exhausted: true、发 team_exhausted 警告，复核和出具
+都据此降档。
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+
+import pytest
+from langchain_core.messages import AIMessage
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Run, RunEvent
+from app.engine import review
+from app.engine.runner import run_manager
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def _never_done(monkeypatch) -> None:
+    """调度者每轮都继续派核对员，理由一样；核对员每次都交不出东西。"""
+    from app.providers import mock_model
+
+    def _decide(self, messages):
+        if self.response_format:
+            return AIMessage(content=json.dumps({
+                "assignments": [{"agent": "核对员", "instruction": "独立重查一遍"}],
+                "done": False, "reason": "核对员还没拿到真实条数，定稿要等复核结果",
+            }, ensure_ascii=False))
+        return AIMessage(content="我还需要再查一次。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+
+
+def _graph(**team):
+    return {
+        "nodes": [
+            node("start", "input", fields=[{"name": "question"}]),
+            node("team", "supervisor", goal="核对订单条数", agents=[
+                {"name": "核对员", "system": "你负责复核", "max_steps": 1},
+                {"name": "撰稿员", "system": "你负责写结论", "max_steps": 1},
+            ], **{"max_rounds": 3, **team}),
+            node("out", "output", fields=[{"name": "r", "value": "{{ nodes.team.text }}"}],
+                 contract={"metrics_from": "card", "narrative": "{{ nodes.team.text }}"}),
+            node("card", "metrics", metrics=[{"id": "n", "expression": "1"}]),
+        ],
+        "edges": [{"source": "start", "target": "card"}, {"source": "card", "target": "team"},
+                  {"source": "team", "target": "out"}],
+    }
+
+
+async def _finish(graph) -> tuple[Run, list[RunEvent]]:
+    run = await run_manager.start(graph=graph, input_payload={"question": "x"})
+    for _ in range(300):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, run.id)
+            if row.status in ("succeeded", "failed"):
+                break
+    async with SessionLocal() as session:
+        events = list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run.id).order_by(RunEvent.seq)
+        )).scalars())
+    return row, events
+
+
+async def test_running_out_of_rounds_fails_by_default(monkeypatch):
+    _never_done(monkeypatch)
+    row, events = await _finish(_graph())
+    assert row.status == "failed", f"成员原话被当成了结论：{row.output}"
+    assert "协作团队用完 3 轮仍未完成：核对员还没拿到真实条数，定稿要等复核结果" in row.error
+    assert "撰稿员" in row.error, "从没被派过的成员要点出来"
+    assert row.error_node_id == "team"
+
+
+async def test_degrade_delivers_but_says_so(monkeypatch):
+    _never_done(monkeypatch)
+    row, events = await _finish(_graph(on_exhausted="degrade"))
+    assert row.status == "succeeded", row.error
+
+    finished = next(e.data for e in events if e.type == "node.finished" and e.node_id == "team")
+    assert finished["preview"]["exhausted"] is True
+    warn = next(e.data for e in events if e.type == "log" and e.data.get("code") == "team_exhausted")
+    assert "撰稿员" in warn["message"] and "3 轮" in warn["message"]
+
+    # 出具降档，理由写在 gaps 里
+    issuance = row.output["_issuance"]
+    assert issuance["tier"] == "degraded"
+    assert any("用完 3 轮" in g for g in issuance["gaps"]), issuance["gaps"]
+    # 复核也认这条警告
+    signals = review.scan(events, row.output)
+    assert any(s.kind == "team_exhausted" for s in signals), signals
+
+
+async def test_a_team_that_finishes_is_unaffected(monkeypatch):
+    from app.providers import mock_model
+
+    turns = {"n": 0}
+
+    def _decide(self, messages):
+        if self.response_format:
+            turns["n"] += 1
+            plan = ({"assignments": [{"agent": "核对员", "instruction": "查"}]} if turns["n"] == 1
+                    else {"assignments": [], "done": True, "reason": "查清楚了"})
+            return AIMessage(content=json.dumps(plan, ensure_ascii=False))
+        return AIMessage(content="一共 1 条。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    row, events = await _finish(_graph())
+    assert row.status == "succeeded", row.error
+    assert not [e for e in events if e.data.get("code") == "team_exhausted"]
+
+
+# --------------------------------------------------------------------------
+# 最后一轮派出去的成员交回来之后，调度者还要看一眼
+# --------------------------------------------------------------------------
+
+
+async def test_a_pipeline_that_needs_exactly_max_rounds_succeeds(monkeypatch):
+    """2 轮的流水线（查数 → 撰稿），最多轮数也是 2：第二轮的撰稿员交回来之后，调度者
+    以前再没机会说「完成」，轮数一到就算用完，缺省判失败。"""
+    from app.providers import mock_model
+
+    routed = {"n": 0}
+
+    def _decide(self, messages):
+        if self.response_format:
+            text = "\n".join(str(m.content) for m in messages)
+            if "轮数已经用完" in text:
+                plan = {"assignments": [], "done": "撰稿员" in text and "结论" in text,
+                        "reason": "结论已经写好"}
+            else:
+                routed["n"] += 1
+                who = "核对员" if routed["n"] == 1 else "撰稿员"
+                plan = {"assignments": [{"agent": who, "instruction": "做你那部分"}],
+                        "done": False, "reason": f"交给{who}"}
+            return AIMessage(content=json.dumps(plan, ensure_ascii=False))
+        return AIMessage(content="结论：一共 1 条。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    row, events = await _finish(_graph(max_rounds=2))
+    assert row.status == "succeeded", row.error
+    assert row.output["r"] == "结论：一共 1 条。"
+    closing = [e.data for e in events if e.type == "agent.route.end" and e.data.get("closing")]
+    assert len(closing) == 1 and closing[0]["done"] is True, closing
+    assert not [e for e in events if e.data.get("code") == "team_exhausted"]
+
+
+async def test_the_closing_look_can_still_say_not_done(monkeypatch):
+    _never_done(monkeypatch)
+    row, events = await _finish(_graph(max_rounds=2))
+    assert row.status == "failed"
+    closing = [e.data for e in events if e.type == "agent.route.end" and e.data.get("closing")]
+    assert len(closing) == 1 and closing[0]["done"] is False, closing
+    # 收尾那一次也是调度者的一次模型调用，要记账
+    coordinator = [e for e in events if e.type == "llm.end" and e.data.get("agent") == "调度者"]
+    assert len(coordinator) == 3
+
+
+# --------------------------------------------------------------------------
+# 接着跑一个失败的团队节点：前几轮取自断点，时间线上不再出现一遍
+# --------------------------------------------------------------------------
+
+
+async def test_continuing_a_failed_team_does_not_replay_its_rounds(monkeypatch):
+    _never_done(monkeypatch)
+    row, events = await _finish(_graph(max_rounds=2))
+    assert row.status == "failed"
+
+    def tally(evs):
+        kinds = ("agent.route.start", "agent.route.end", "agent.step.start", "agent.step.end",
+                 "llm.end")
+        counts = {k: sum(1 for e in evs if e.type == k and e.node_id == "team") for k in kinds}
+        counts["调度"] = sum(1 for e in evs if e.type == "log" and e.node_id == "team"
+                           and str(e.data.get("message", "")).startswith("调度 →"))
+        return counts
+
+    before = tally(events)
+    assert before["agent.step.start"] == 2 and before["agent.route.start"] == 3, before
+
+    graph = _graph(max_rounds=2, on_exhausted="degrade")
+    await run_manager.continue_failed(row.id, graph=graph)
+    for _ in range(300):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, row.id)
+            if row.status in ("succeeded", "failed"):
+                break
+    assert row.status == "succeeded", row.error
+    async with SessionLocal() as session:
+        after_events = list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == row.id).order_by(RunEvent.seq)
+        )).scalars())
+    assert tally(after_events) == before, "接着跑把前几轮的调度和成员又发了一遍"
+    # 前几轮取自断点，用量不能跟着丢：成员的调用也要算进去
+    assert row.usage["calls"] == before["llm.end"], (row.usage, before)
diff --git a/backend/tests/test_tool_deadline.py b/backend/tests/test_tool_deadline.py
new file mode 100644
index 00000000..cebdc71a
--- /dev/null
+++ b/backend/tests/test_tool_deadline.py
@@ -0,0 +1,265 @@
+"""工具的时限要按时生效，并且事先告诉界面这个时限是多少。
+
+真实运行里有一次查询：tool.end 的 duration_ms 是 90628，报错却写着「查询超过 30s
+被中断」。30 秒时限确实到了，取消也发出去了——但 asyncio.wait_for 取消之后要**等被
+取消的那一方收完尾**，而驱动收尾（关连接、回滚）要等数据库把那条语句跑完。于是
+「30 秒被中断」实际等了 90 秒，报错还说的是 30。
+
+这里把两件事钉住：
+- 到了时限，节点就拿回控制权、如实说「等了多久、放弃了」，驱动的收尾放到后台；
+- tool.start 带上 timeout_s，界面据此写「已超出 30s 上限」，不在前端写死。
+
+慢收尾的工具用两种方式造：一个假的（取消后还要磨蹭一阵才肯退出），和一个真的
+SQLite 查询（aiosqlite 在线程里跑语句，关连接要排在那条语句后面）。
+"""
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import json
+import sqlite3
+import uuid
+
+import pytest
+from langchain_core.messages import AIMessage, ToolMessage
+from langchain_core.tools import StructuredTool
+from pydantic import BaseModel
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import DataSource, Run, RunEvent
+from app.engine.runner import run_manager
+
+#: 假工具声明的时限。取消之后它还要再磨蹭 CLEANUP 秒才退出，像一个在等服务端的驱动
+LIMIT = 0.3
+CLEANUP = 2.0
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+    # 被放弃的调用在后台收尾（假工具要再磨蹭 CLEANUP 秒，SQLite 要等语句跑完才还连接）。
+    # 等它们收完再结束，测试的事件循环关掉时不该还挂着占着连接的任务
+    others = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+    if others:
+        await asyncio.wait(others, timeout=15)
+
+
+class _Args(BaseModel):
+    sql: str
+
+
+def _slow_tool(name: str = "slow_lookup") -> StructuredTool:
+    async def _run(sql: str) -> str:
+        try:
+            await asyncio.sleep(30)
+        except asyncio.CancelledError:
+            await asyncio.sleep(CLEANUP)      # 驱动收尾：等服务端把语句跑完才肯关连接
+            raise
+        return "不会走到这里"
+
+    return StructuredTool(name=name, description="慢查询", args_schema=_Args, coroutine=_run,
+                          func=None, metadata={"timeout_s": LIMIT})
+
+
+def _serve(monkeypatch, tool: StructuredTool) -> None:
+    """让各节点按名字拿到这个工具。"""
+    async def _build(names, ctx, *, session=None):
+        return [tool] if tool.name in names else []
+
+    import app.engine.nodes.llm as llm_nodes
+    import app.engine.nodes.multi as multi_nodes
+    import app.engine.nodes.tools as tool_nodes
+    import app.tools.registry as registry
+
+    for module in (llm_nodes, multi_nodes, tool_nodes, registry):
+        monkeypatch.setattr(module, "build_tools", _build)
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def chain(*nodes):
+    return {"nodes": list(nodes),
+            "edges": [{"source": a["id"], "target": b["id"]} for a, b in zip(nodes, nodes[1:])]}
+
+
+async def _finish(graph) -> tuple[Run, list[RunEvent]]:
+    run = await run_manager.start(graph=graph, input_payload={"question": "x"})
+    for _ in range(400):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, run.id)
+            if row.status in ("succeeded", "failed", "cancelled", "interrupted"):
+                break
+    else:
+        pytest.fail("运行没有在 20 秒内结束")
+    async with SessionLocal() as session:
+        events = list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run.id).order_by(RunEvent.seq)
+        )).scalars())
+    return row, events
+
+
+def _script_one_call(monkeypatch, tool_name: str, sql: str = "SELECT 1") -> list[str]:
+    """第一轮调一次工具，看到结果就收口。返回模型看到的工具结果，供断言。"""
+    from app.providers import mock_model
+
+    seen: list[str] = []
+
+    def _decide(self, messages):
+        results = [m for m in messages if isinstance(m, ToolMessage)]
+        if self.response_format:
+            return AIMessage(content=json.dumps(
+                {"assignments": [], "done": True} if seen or results else
+                {"assignments": [{"agent": "查数员", "instruction": "查一下"}]}))
+        if self.tools and not results:
+            return AIMessage(content="", tool_calls=[
+                {"name": tool_name, "args": {"sql": sql}, "id": "call_slow"}])
+        seen.extend(str(m.content) for m in results)
+        return AIMessage(content="查询超时了，缩小范围再试。")
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    return seen
+
+
+# --------------------------------------------------------------------------
+
+
+async def test_an_agent_gets_control_back_when_the_limit_is_reached(monkeypatch):
+    tool = _slow_tool()
+    _serve(monkeypatch, tool)
+    seen = _script_one_call(monkeypatch, tool.name)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="查", tools=[tool.name], approval="never", max_steps=3),
+        node("out", "output", fields=[]),
+    ))
+    assert row.status == "succeeded", row.error
+
+    start = next(e.data for e in events if e.type == "tool.start")
+    assert start["timeout_s"] == LIMIT, start
+    end = next(e.data for e in events if e.type in ("tool.end", "tool.error"))
+    assert end["duration_ms"] < (LIMIT + CLEANUP) * 1000 * 0.75, \
+        f"时限 {LIMIT}s，却等到了驱动收尾：{end['duration_ms']}ms"
+    assert end.get("timed_out") is True, end
+    # 模型要知道是超时、超了多久，才会去缩小查询范围
+    assert seen and "0.3" in seen[0] and "放弃" in seen[0], seen
+
+
+async def test_a_tool_node_reports_the_real_limit(monkeypatch):
+    tool = _slow_tool()
+    _serve(monkeypatch, tool)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("q", "tool", tool=tool.name, args={"sql": "SELECT 1"}, approval="never"),
+        node("out", "output", fields=[]),
+    ))
+    assert row.status == "failed"
+    assert "0.3" in (row.error or "") and "放弃" in (row.error or ""), row.error
+    start = next(e.data for e in events if e.type == "tool.start")
+    assert start["timeout_s"] == LIMIT
+    err = next(e.data for e in events if e.type == "tool.error")
+    assert err["duration_ms"] < (LIMIT + CLEANUP) * 1000 * 0.75, err
+    assert err.get("timed_out") is True
+
+
+async def test_a_team_member_gets_control_back_too(monkeypatch):
+    tool = _slow_tool()
+    _serve(monkeypatch, tool)
+    _script_one_call(monkeypatch, tool.name)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("team", "supervisor", goal="查", max_rounds=3, approval="never", agents=[
+            {"name": "查数员", "system": "你负责查库", "tools": [tool.name], "max_steps": 3}]),
+        node("out", "output", fields=[]),
+    ))
+    assert row.status == "succeeded", row.error
+    start = next(e.data for e in events if e.type == "tool.start")
+    assert start["timeout_s"] == LIMIT
+    end = next(e.data for e in events if e.type in ("tool.end", "tool.error"))
+    assert end["duration_ms"] < (LIMIT + CLEANUP) * 1000 * 0.75, end
+
+
+# --------------------------------------------------------------------------
+# 真实的驱动：SQLite 的慢查询。关连接要排在那条语句后面
+# --------------------------------------------------------------------------
+
+#: 一条在时限之前一定跑不完的查询：pause 是测试里注册给 SQLite 的函数，在执行语句的
+#: 那个线程里睡够秒数再返回。以前用递归 CTE 造慢查询，快几倍的机器上它不到 1 秒就跑完了
+PAUSE_S = 4
+SLOW_SQL = f"SELECT pause({PAUSE_S}) AS n"
+
+
+@pytest.fixture
+async def slow_source(tmp_path, monkeypatch):
+    import time
+
+    from sqlalchemy import event
+
+    from app.data import guard
+    from app.data.engine import engines
+    import app.tools.datasource as datasource_tools
+
+    @dataclasses.dataclass(frozen=True)
+    class OneSecond(guard.QueryLimits):
+        timeout_seconds: int = 1
+
+    monkeypatch.setattr(guard, "QueryLimits", OneSecond)
+    monkeypatch.setattr(datasource_tools, "QueryLimits", OneSecond)
+
+    path = tmp_path / "orders.db"
+    conn = sqlite3.connect(path)
+    conn.execute("CREATE TABLE orders (id INTEGER)")
+    conn.commit()
+    conn.close()
+    name = f"shop_{uuid.uuid4().hex[:6]}"
+    async with SessionLocal() as session:
+        source = DataSource(name=name, kind="sqlite", database=str(path), readonly=True,
+                            description="测试库", options={}, schema_cache={}, enabled=True)
+        session.add(source)
+        await session.commit()
+
+    def _register(dbapi_conn, _record):
+        dbapi_conn.create_function("pause", 1, lambda seconds: time.sleep(seconds) or seconds)
+
+    engine = (await engines.get(source)).sync_engine
+    event.listen(engine, "connect", _register)
+    yield f"db_query__{name}"
+    event.remove(engine, "connect", _register)
+
+
+async def test_a_slow_query_is_abandoned_on_time(slow_source, monkeypatch):
+    _script_one_call(monkeypatch, slow_source, SLOW_SQL)
+    row, events = await _finish(chain(
+        node("start", "input", fields=[{"name": "question"}]),
+        node("bot", "agent", prompt="查", tools=[slow_source], max_steps=3),
+        node("out", "output", fields=[]),
+    ))
+    assert row.status == "succeeded", row.error
+    start = next(e.data for e in events if e.type == "tool.start")
+    assert start["timeout_s"] == 1, start
+    end = next(e.data for e in events if e.type in ("tool.end", "tool.error"))
+    assert end["duration_ms"] < 3000, f"1s 的查询时限等了 {end['duration_ms']}ms"
+    assert "1s" in end["preview"], end
+
+
+def test_where_each_limit_comes_from():
+    from app.data.guard import QueryLimits
+    from app.engine.toolcalls import limit_fields, limit_of
+
+    query = limit_of(None, "db_query__shop", {"sql": "SELECT 1"})
+    assert query.seconds == QueryLimits().timeout_seconds and query.enforce and query.self_timed
+    # 数据源自己声明了时限：用它，但仍按「数据层自己掐、自己收尾」对待
+    declared_query = limit_of(_slow_tool("db_query__shop"), "db_query__shop", {"sql": "x"})
+    assert declared_query.seconds == LIMIT and declared_query.self_timed
+    # 沙箱的时限由沙箱执行：界面要知道上限，引擎不按它掐（里面含着起虚拟机的时间）
+    sandbox = limit_of(None, "python_exec", {"code": "print(1)", "timeout": 45})
+    assert sandbox.seconds == 45 and not sandbox.enforce
+    assert limit_of(None, "calculator", {"expression": "1+1"}) is None
+    assert limit_fields(query) == {"timeout_s": QueryLimits().timeout_seconds}
+    assert limit_fields(None) == {}
diff --git a/backend/tests/test_validate_repair.py b/backend/tests/test_validate_repair.py
new file mode 100644
index 00000000..53ffcc7e
--- /dev/null
+++ b/backend/tests/test_validate_repair.py
@@ -0,0 +1,170 @@
+"""校验节点的自动修复只许改格式，不许补数据。
+
+一次真实运行：上游的查询 agent 没有工具，交上来的是「假设调用工具」加一段 SQL，
+里面一个数都没有。校验第一次失败（缺 total_count），自动修复把原文喂给模型让它
+「修正后重新输出」——模型就编了一个 total_count: 0，校验通过，运行成功，最后
+交到用户手上的是一个凭空的 0。
+
+修复提示词要说清楚「原文没有的值填 null」，但光靠提示词拦不住。修复之后要核对：
+修复结果里出现了原文没有的数字或文字，这次修复就作废，报错写清是哪个值。
+另外修复是一次真实的模型调用，它的用量以前没发 llm.end，也没算进 usage。
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+
+import pytest
+from langchain_core.messages import AIMessage
+from sqlalchemy import select
+
+from app.db.base import SessionLocal
+from app.db.models import Run, RunEvent
+from app.engine.runner import run_manager
+
+SCHEMA = {
+    "type": "object",
+    "properties": {"total_count": {"type": "integer"}, "table": {"type": "string"}},
+    "required": ["total_count"],
+}
+
+
+@pytest.fixture(autouse=True)
+async def engine_up():
+    await run_manager.setup()
+    yield
+    await run_manager.shutdown()
+
+
+def node(nid, ntype, **config):
+    return {"id": nid, "type": ntype, "position": {"x": 0, "y": 0},
+            "data": {"label": nid, "config": config}}
+
+
+def _graph(upstream_text: str, **validate):
+    return {
+        "nodes": [
+            node("start", "input"),
+            node("draft", "transform", mode="template", template=upstream_text),
+            node("check", "validate", schema=SCHEMA, source="{{ nodes.draft }}", max_retries=2,
+                 **validate),
+            node("out", "output", fields=[{"name": "r", "value": "{{ nodes.check.data }}"}]),
+        ],
+        "edges": [{"source": "start", "target": "draft"}, {"source": "draft", "target": "check"},
+                  {"source": "check", "target": "out"}],
+    }
+
+
+def _repairs_with(monkeypatch, *replies: dict) -> list[str]:
+    """修复模型依次交回这些 JSON。返回它收到的提示词。"""
+    from app.providers import mock_model
+
+    prompts: list[str] = []
+
+    def _decide(self, messages):
+        prompts.append("\n".join(str(m.content) for m in messages))
+        reply = replies[min(len(prompts) - 1, len(replies) - 1)]
+        return AIMessage(content=json.dumps(reply, ensure_ascii=False))
+
+    monkeypatch.setattr(mock_model.MockChatModel, "_decide", _decide)
+    return prompts
+
+
+async def _finish(graph) -> tuple[Run, list[RunEvent]]:
+    run = await run_manager.start(graph=graph, input_payload={})
+    for _ in range(200):
+        await asyncio.sleep(0.05)
+        async with SessionLocal() as session:
+            row = await session.get(Run, run.id)
+            if row.status in ("succeeded", "failed"):
+                break
+    async with SessionLocal() as session:
+        events = list((await session.execute(
+            select(RunEvent).where(RunEvent.run_id == run.id).order_by(RunEvent.seq)
+        )).scalars())
+    return row, events
+
+
+PRETEND = "我假设调用工具 db_query__shop 执行：\nSELECT COUNT(*) FROM orders\n结果应该能反映订单总数。"
+
+
+async def test_a_repair_that_invents_a_number_fails(monkeypatch):
+    prompts = _repairs_with(monkeypatch, {"total_count": 0})
+    row, events = await _finish(_graph(PRETEND))
+
+    assert row.status == "failed", f"修复编出来的 0 被当成了结果：{row.output}"
+    assert "修复时出现了原文没有的值：total_count=0" in (row.error or ""), row.error
+    # 提示词里要把规矩说在前面
+    assert prompts and "null" in prompts[0] and "编造" in prompts[0]
+
+
+async def test_a_repair_that_only_reformats_passes(monkeypatch):
+    _repairs_with(monkeypatch, {"total_count": 1284, "table": "orders"})
+    row, _ = await _finish(_graph("查到了：orders 表一共 1,284 条记录。"))
+    assert row.status == "succeeded", row.error
+    assert json.loads(row.output["r"]) == {"total_count": 1284, "table": "orders"}
+
+
+async def test_a_repair_that_admits_there_is_no_data_still_fails_the_schema(monkeypatch):
+    _repairs_with(monkeypatch, {"total_count": None})
+    row, _ = await _finish(_graph(PRETEND))
+    assert row.status == "failed"
+    assert "total_count" in (row.error or "") and "原文没有的值" not in (row.error or "")
+
+
+async def test_repair_calls_are_counted(monkeypatch):
+    _repairs_with(monkeypatch, {"total_count": 0})
+    row, events = await _finish(_graph(PRETEND))
+    ends = [e.data for e in events if e.type == "llm.end" and e.node_id == "check"]
+    assert len(ends) == 2, "两次修复各是一次模型调用，都要记账"
+    assert row.usage.get("output_tokens", 0) >= sum(e["output_tokens"] for e in ends) > 0
+
+
+async def test_numbers_written_in_chinese_count_as_present(monkeypatch):
+    _repairs_with(monkeypatch, {"total_count": 12, "table": "orders"})
+    row, _ = await _finish(_graph("orders 表里一共有十二条记录。"))
+    assert row.status == "succeeded", row.error
+
+
+# SQL 里的数字不是证据：WHERE status > 0、LIMIT 10 这类写法到处都是，认它们的话，
+# 编出来的 total_count: 0 就有了「出处」——这恰恰是「假设调用工具 + SQL」最常见的形状
+
+
+@pytest.mark.parametrize("upstream, invented", [
+    ('{"sql":"SELECT COUNT(*) FROM orders WHERE status > 0"}', {"total_count": 0}),
+    ('假设调用工具：{"tool": "db_query__shop", "sql": "SELECT COUNT(*) FROM orders LIMIT 10"}',
+     {"total_count": 10}),
+    ("我假设调用工具执行了 SELECT COUNT(*) FROM orders WHERE deleted = 0，结果还没拿到",
+     {"total_count": 0}),
+    ("```sql\nSELECT COUNT(*) FROM orders\nWHERE status > 0\nLIMIT 10\n```\n查询已提交", {"total_count": 10}),
+    ('{"sql":"SELECT COUNT(*) FROM orders WHERE status > 0"}', {"total_count": "0"}),
+])
+def test_numbers_inside_sql_do_not_count(upstream, invented):
+    from app.engine.nodes.human import _invented
+
+    assert _invented(invented, upstream, SCHEMA), (upstream, invented)
+
+
+def test_numbers_outside_the_sql_still_count():
+    from app.engine.nodes.human import _invented
+
+    text = "执行了 SELECT COUNT(*) FROM orders WHERE status > 0，结果一共 12 条"
+    assert _invented({"total_count": 12}, text, SCHEMA) == []
+    fenced = '```json\n{"total_count": 12}\n```'
+    assert _invented({"total_count": 12}, fenced, SCHEMA) == []
+
+
+def test_a_percentage_may_be_written_as_a_fraction():
+    from app.engine.nodes.human import _invented
+
+    assert _invented({"rate": 0.125, "mom": -0.03}, "转化率 12.5%，环比 -3%", {}) == []
+    assert _invented({"rate": 12.5}, "转化率 12.5%", {}) == []
+    assert _invented({"rate": 0.2}, "转化率 12.5%", {}) == ["rate=0.2"]
+
+
+async def test_a_repair_that_takes_its_number_from_the_sql_fails(monkeypatch):
+    _repairs_with(monkeypatch, {"total_count": 0})
+    row, _ = await _finish(_graph('假设调用工具：{"tool": "db_query__shop", '
+                                  '"sql": "SELECT COUNT(*) FROM orders WHERE status > 0"}'))
+    assert row.status == "failed", f"SQL 里的 0 被当成了出处：{row.output}"
+    assert "修复时出现了原文没有的值：total_count=0" in (row.error or ""), row.error
diff --git a/backend/tests/test_validation_text.py b/backend/tests/test_validation_text.py
index 69cacfec..14b2dc72 100644
--- a/backend/tests/test_validation_text.py
+++ b/backend/tests/test_validation_text.py
@@ -173,7 +173,7 @@ async def test_resume_refusal_does_not_leak_the_status_enum(engine_up):
 
 
 def test_exception_wording_helper():
-    from app.engine.errors import describe_exception
+    from app.core.errors import describe_exception
 
     assert "query" in describe_exception(TypeError(RAW))
     assert "TypeError" not in describe_exception(TypeError(RAW))
diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx
index 18cbba7c..91be0f5e 100644
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -4,7 +4,7 @@ import { Link, NavLink, Navigate, Route, Routes, useLocation, useNavigate } from
 import { Bell, BellOff, Moon, RotateCw, Sun, UserRound } from 'lucide-react'
 import clsx from 'clsx'
 import { ApiError, NETWORK_MESSAGE, api } from './api/client'
-import { useCatalog, useOnReconnect } from './store/catalog'
+import { CATALOG_TIMEOUT_MS, catalogListState, useCatalog, useOnReconnect } from './store/catalog'
 import type { CatalogCheck } from './store/catalog'
 import { useStudio } from './store/studio'
 import { useChat } from './store/chat'
@@ -22,7 +22,7 @@ import {
   CommandPalette, PAGES, ShortcutHelp, flushThemePref, openShortcutHelp, toggleCommandPalette, toggleNotify,
   toggleTheme, useTheme, waitedFor,
 } from './components/CommandPalette'
-import { ErrorBoundary, Kbd, OfflineBanner, Spinner, StatusBadge, isComposing, toast } from './components/ui'
+import { ErrorBoundary, Kbd, OfflineBanner, Spinner, StatusBadge, isComposing, toast, useTicker } from './components/ui'
 import { applyTheme, normalizeTheme } from './lib/theme'
 import { ariaShortcut, isTypingTarget, matchShortcut } from './lib/keys'
 import { formatDateTime, formatDuration, formatRelative, shortId } from './lib/format'
@@ -32,6 +32,7 @@ import {
   composeTitle, flagAttention, notifyInBackground, notifySupported, paintFavicon, useSignals,
 } from './lib/notify'
 import type { Attention, FaviconDot } from './lib/notify'
+import { useLeaveBlocker } from './lib/leave'
 
 export default function App() {
   const loaded = useCatalog((s) => s.loaded)
@@ -66,7 +67,6 @@ export default function App() {
   // 断线时换的那一下当时没存上：恢复后补存，而不是去读服务端
   useOnReconnect(() => { if (!flushThemePref()) loadTheme() })
 
-  useBootReport(loaded)
   // 在 App 这一层算，从启动那一刻起计时：从启动页「先进去看看」时已经卡了好几秒，
   // 进门那一下就得是琥珀，不能进了门再从头等
   const stalled = useStalledChecks()
@@ -74,8 +74,8 @@ export default function App() {
   // 从没连上过就断着：停在启动页说清楚原因，而不是放人进去看一屏「还没有…」
   const offlineAtBoot = !everOk && (backend === 'down' || (allFailed && backend === 'checking'))
   const booting = !offlineOk && (!loaded || offlineAtBoot)
-  // 启动页的清单自己会说哪几项还在等；进了外壳才需要当面提醒
-  useStallWarning(booting ? NO_CHECKS : stalled)
+  // 启动页的清单自己会说哪几项还在等、哪几项失败了；进了外壳才需要当面提醒
+  useCatalogWarning(stalled, !booting)
   if (booting) return <BootScreen onEnterOffline={() => setOfflineOk(true)} />
 
   return (
@@ -123,6 +123,7 @@ export default function App() {
       <ShortcutHelp />
       <ShellKeys />
       <ShellSignals />
+      <LeaveBlocker />
     </div>
   )
 }
@@ -131,6 +132,15 @@ export default function App() {
 // 全局快捷键
 // -------------------------------------------------------------------------
 
+/**
+ * 离开前确认的那一个 blocker（lib/leave）：导航、链接、⌘K、⌥ 数字、浏览器后退，
+ * 换页都先经过页面登记的守卫。单独成一个组件，blocker 变了只重绘它
+ */
+function LeaveBlocker() {
+  useLeaveBlocker()
+  return null
+}
+
 /** 启动页上不挂：那时按下的 ⌘K 会在加载完之后才突然弹出面板 */
 function ShellKeys() {
   const navigate = useNavigate()
@@ -161,6 +171,7 @@ function ShellKeys() {
       const page = PAGES.find((p) => matchShortcut(e, p.shortcut))
       if (page) {
         e.preventDefault()
+        // 有没保存的改动时由 LeaveBlocker 先问，这里照常跳
         navRef.current(page.to)
       }
     }
@@ -454,10 +465,10 @@ const STALL_MS = 3000
 /**
  * 卡着没回来的 catalog 请求（后端没断时）。
  *
- * refresh 是一个 Promise.all：一张表卡住（后端连得上、就是不回），六张表全都还是
- * 空的，backend 却是 ok——遥测点一片绿，编排页一屏「还没有工作流 / 新建工作流」，
- * 正是离线横幅要消灭的那种假空态，只是换了个来路。正常刷新几十毫秒就回，不到
- * STALL_MS 不算，免得每次刷新遥测点都闪一下琥珀。
+ * refresh 按表各自请求、先回先填，每个请求最多等 CATALOG_TIMEOUT_MS。一张表卡住
+ * （后端连得上、就是不回）只拖它自己：卡着的这段时间遥测点是「加载中」，到点那一项
+ * 记成出错，遥测点转成「降级」。正常刷新几十毫秒就回，不到 STALL_MS 不算，免得
+ * 每次刷新遥测点都闪一下琥珀。
  */
 function useStalledChecks(): CatalogCheck[] {
   const waiting = useCatalog((s) => s.checks.some((c) => c.state === 'pending'))
@@ -473,26 +484,52 @@ function useStalledChecks(): CatalogCheck[] {
   return stalled && waiting && !down ? checks.filter((c) => c.state === 'pending') : NO_CHECKS
 }
 
+/** 失败的那一项怎么说：回了错误码写码；等满 CATALOG_TIMEOUT_MS 才断的是超时；其余是够不着 */
+function failWord(c: CatalogCheck): string {
+  if (c.status) return String(c.status)
+  return c.ms != null && c.ms >= CATALOG_TIMEOUT_MS ? '超时' : '连不上'
+}
+
 /**
- * 进了外壳还有请求卡着：挂一条常驻提示，点名是哪几项；全部回来（或者断开，归
- * 横幅管）就撤掉。遥测点只是一个小琥珀点，人眼前是「还没有工作流」和一个「新建」
- * 按钮，得当面说一句。点名的是卡住那一刻的几项，实时的看遥测浮层。
+ * 眼下是空的、却不能当「没有」的那几张表：从没取回来过（catalogListState 不是 ok），
+ * 请求又卡着（超过 STALL_MS）或者已经失败了（回了错误码、超时）。人眼前是「还没有
+ * 工作流」和一个「新建」按钮，得当面说一句，而且一直挂着，直到那几张表取回来：
+ * 卡着的那一项到点超时，提示跟着改口说「没加载成功」，不能悄悄撤掉。
+ *
+ * 取回来过的表刷新卡住、失败了都不算：失败不清空，手上的还是真数据，遥测点说一声
+ * 就够。后端断开归离线横幅说；启动页上清单自己会说（enabled=false）。
  */
-function useStallWarning(stalled: CatalogCheck[]) {
-  const any = stalled.length > 0
-  const latest = useRef(stalled)
-  latest.current = stalled
+function useCatalogWarning(stalled: CatalogCheck[], enabled: boolean) {
+  // 选成字符串：只在「是哪几张表」变了的时候才换提示
+  const waiting = useCatalog((s) => stalled
+    .filter((c) => catalogListState(s, c.key) === 'loading').map((c) => c.key).join(','))
+  const failed = useCatalog((s) => s.checks
+    .filter((c) => catalogListState(s, c.key) === 'error').map((c) => c.key).join(','))
   useEffect(() => {
-    if (!any) return
-    const labels = latest.current.map((c) => c.label)
-    const id = toast.warn(`还有 ${labels.length} 项没取回来（${labels.join('、')}）：列表可能不全，先别新建`, {
+    if (!enabled || (!waiting && !failed)) return
+    const { checks } = useCatalog.getState()
+    const pick = (keys: string) => keys.split(',').filter(Boolean)
+      .map((k) => checks.find((c) => c.key === k)).filter((c): c is CatalogCheck => !!c)
+    const w = pick(waiting)
+    const f = pick(failed)
+    const text = [
+      w.length ? `还有 ${w.length} 项没取回来（${w.map((c) => c.label).join('、')}）` : '',
+      f.length ? `${w.length ? '' : '有 '}${f.length} 项没加载成功（${f.map((c) => `${c.label} ${failWord(c)}`).join('、')}）` : '',
+    ].filter(Boolean).join('，')
+    const detail = [
+      w.length ? '后端连得上，但这几个请求发出去好几秒了还没回来。' : '',
+      ...f.map((c) => `${c.label}：${c.error ?? failWord(c)}`),
+      '在它们取回来之前，对应的列表和下拉可能是空的，不代表数据没了。导航最底下的连接指示灯里能看到每一项的情况。',
+    ].filter(Boolean).join('\n')
+    // 键跟着「是哪几张表」走：同一个键的提示只会累计次数，不会换字
+    const id = toast.warn(`${text}：列表可能不全，先别新建`, {
       sticky: true,
-      key: 'boot-pending',
-      detail: '后端连得上，但这几个请求发出去好几秒了还没回来。在它们回来之前，工作流、知识库这些列表可能是空的，不代表数据没了。导航最底下的连接指示灯里能看到哪一项回来了。',
+      key: `catalog-unknown:${waiting}|${failed}`,
+      detail,
       action: { label: '重试', onClick: () => void useCatalog.getState().refresh() },
     })
     return () => toast.dismiss(id)
-  }, [any])
+  }, [enabled, waiting, failed])
 }
 
 /** 连接遥测点：导航最底下，像仪表盘上的指示灯。点开看地址、延迟、最近一次错误 */
@@ -535,17 +572,6 @@ function Telemetry({ stalled }: { stalled: CatalogCheck[] }) {
   )
 }
 
-function useTicker(active: boolean, ms = 1000): number {
-  const [now, setNow] = useState(() => Date.now())
-  useEffect(() => {
-    if (!active) return
-    setNow(Date.now())
-    const t = setInterval(() => setNow(Date.now()), ms)
-    return () => clearInterval(t)
-  }, [active, ms])
-  return now
-}
-
 function TelemetryPanel({ onClose, anchor, stalled }: {
   onClose: (refocus: boolean) => void
   anchor: RefObject<HTMLButtonElement | null>
@@ -560,8 +586,10 @@ function TelemetryPanel({ onClose, anchor, stalled }: {
   const [busy, setBusy] = useState(false)
   const ref = useRef<HTMLDivElement>(null)
   const down = backend === 'down'
-  const now = useTicker(down)
+  const now = useTicker(1000, down)
   const tone = backendTone(backend, latency, useFailingChecks(), stalled.length)
+  // 卡着的里头有没有从没取回来过的：有的话那张表眼下是空的，才要劝一句别急着新建
+  const unknown = useCatalog((s) => stalled.some((c) => catalogListState(s, c.key) !== 'ok'))
 
   const onCloseRef = useRef(onClose)
   onCloseRef.current = onClose
@@ -634,7 +662,11 @@ function TelemetryPanel({ onClose, anchor, stalled }: {
         <div className="mx-3 mb-2.5 rounded-md border px-2 py-1.5 text-2xs leading-relaxed"
              style={{ borderColor: 'color-mix(in srgb, var(--warn) 35%, var(--border))', background: 'var(--st-waiting-soft)' }}>
           <div className="text-[var(--st-waiting)]">{stalled.map((c) => c.label).join('、')}还没回来</div>
-          <div className="mt-0.5 text-dim">在那之前各页的列表可能不全，不代表数据没了，先别急着新建。</div>
+          <div className="mt-0.5 text-dim">
+            {unknown
+              ? '在那之前各页的列表可能不全，不代表数据没了，先别急着新建。'
+              : '页面上是上次取回来的列表，回来之后自动换新。'}
+          </div>
         </div>
       )}
       {checks.length > 0 && (
@@ -667,7 +699,7 @@ function CheckList({ checks, lead }: { checks: CatalogCheck[]; lead?: ReactNode
             <span className="sr-only">{c.state === 'pending' ? '还在等' : c.state === 'ok' ? '已取回 ' : '失败 '}</span>
             {c.state === 'pending'
               ? <span aria-hidden>…</span>
-              : c.state === 'ok' ? `${c.ms ?? '—'} ms` : c.status ? String(c.status) : '连不上'}
+              : c.state === 'ok' ? `${c.ms ?? '—'} ms` : failWord(c)}
           </span>
         </li>
       ))}
@@ -711,7 +743,7 @@ function BootScreen({ onEnterOffline }: { onEnterOffline: () => void }) {
   const retryAt = useCatalog((s) => s.retryAt)
   const loaded = useCatalog((s) => s.loaded)
   const [t0] = useState(() => Date.now())
-  const now = useTicker(true, 250)
+  const now = useTicker(250)
   const [busy, setBusy] = useState(false)
   const elapsed = now - t0
   const down = backend === 'down'
@@ -719,8 +751,8 @@ function BootScreen({ onEnterOffline }: { onEnterOffline: () => void }) {
   // 一闪而过的启动（本机几十毫秒）不画清单，免得整屏跳一下
   const reveal = down || elapsed > 300
 
-  // 请求没有超时，后端卡死（连得上但不回）时会一直挂着：到点主动探一次 /health，
-  // 它带超时，卡死和断开都能在这里判出来
+  // 每张表要等满 CATALOG_TIMEOUT_MS 才记成失败，后端卡死（连得上但不回）时启动页得
+  // 干等 15 秒：到点先主动探一次 /health，它的超时短得多，卡死和断开都能在这里先判出来
   useEffect(() => { if (slow) void useCatalog.getState().checkBackend() }, [slow])
 
   const retry = async () => {
@@ -827,30 +859,6 @@ function BootScreen({ onEnterOffline }: { onEnterOffline: () => void }) {
   )
 }
 
-/**
- * 启动时部分请求失败（后端连着，但某几张表报错）：进页面，但要说出来。
- * 不说的话，那几张表对应的下拉、列表就是空的，看着像"没有"。
- */
-function useBootReport(loaded: boolean) {
-  const reported = useRef(false)
-  useEffect(() => {
-    if (!loaded || reported.current) return
-    reported.current = true
-    // 只报后端回了错误码的那几项：够不着后端（没有状态码）归启动页和离线横幅说，
-    // 这里再弹一条「6 项没加载成功」就是同一件事说两遍
-    const bad = useCatalog.getState().checks.filter((c) => c.state === 'error' && c.status)
-    if (!bad.length) return
-    toast.warn(
-      `有 ${bad.length} 项没加载成功：${bad.map((c) => (c.status ? `${c.label}（${c.status}）` : c.label)).join('、')}`,
-      {
-        detail: bad.map((c) => `${c.label}：${c.error ?? ''}`).join('\n'),
-        action: { label: '重试', onClick: () => void useCatalog.getState().refresh() },
-        key: 'boot-partial',
-      },
-    )
-  }, [loaded])
-}
-
 // -------------------------------------------------------------------------
 // 后台信号：标题、favicon、系统通知
 // -------------------------------------------------------------------------
diff --git a/frontend/src/api/client.ts b/frontend/src/api/client.ts
index cc1de487..05f5b776 100644
--- a/frontend/src/api/client.ts
+++ b/frontend/src/api/client.ts
@@ -1,6 +1,6 @@
 import type {
   Approval, Conversation, ConversationDetail, ConversationTurn, GraphSpec,
-  KbDocument, MemoryItem, Provider, ReviewResult, Run, RunEvent, RunStatus, Skill, ToolInfo,
+  KbDocument, MemoryItem, Provider, ReviewResult, Run, RunEvent, RunStatus, Skill, ToolChange, ToolInfo,
   ValidationIssue, VarIssue, Variable, Workflow, WorkflowVersion,
 } from '../types'
 
@@ -129,35 +129,107 @@ async function request<T>(path: string, init?: RequestInit & { timeoutMs?: numbe
   } finally {
     if (timer) clearTimeout(timer)
   }
-  if (!res.ok) {
-    const text = await res.text().catch(() => '')
-    let body: any
-    let isJson = false
-    try { body = JSON.parse(text); isJson = true } catch { /* 响应体不是 JSON */ }
-    if (isGatewayFailure(res.status, text, isJson)) {
-      const err = new ApiError(res.status, NETWORK_MESSAGE, {
-        kind: 'network', raw: `${res.status} ${res.statusText}${text ? `\n${text.slice(0, 500)}` : ''}`,
-      })
-      report(false, err)
-      throw err
-    }
-    report(true)
-    if (isJson) {
-      const detail = body?.detail ?? body
-      throw new ApiError(res.status, describeDetail(detail), {
-        detail, raw: typeof body?.raw === 'string' ? body.raw : `${res.status} ${text.slice(0, 2000)}`,
-      })
-    }
-    const message = res.status >= 500
-      ? `后端出错了（${res.status}），详情看服务日志`
-      : `请求没有成功（${res.status} ${res.statusText}）`
-    throw new ApiError(res.status, message, { raw: `${res.status} ${res.statusText}\n${text.slice(0, 2000)}` })
-  }
+  if (!res.ok) throw failure(res.status, res.statusText, await res.text().catch(() => ''))
   report(true)
   if (res.status === 204) return undefined as T
   return res.json()
 }
 
+/** 非 2xx 的响应 → ApiError，顺带报告连接状态。fetch 和 XHR 两条路共用 */
+function failure(status: number, statusText: string, text: string): ApiError {
+  let body: any
+  let isJson = false
+  try { body = JSON.parse(text); isJson = true } catch { /* 响应体不是 JSON */ }
+  if (isGatewayFailure(status, text, isJson)) {
+    const err = new ApiError(status, NETWORK_MESSAGE, {
+      kind: 'network', raw: `${status} ${statusText}${text ? `\n${text.slice(0, 500)}` : ''}`,
+    })
+    report(false, err)
+    return err
+  }
+  report(true)
+  if (isJson) {
+    const detail = body?.detail ?? body
+    return new ApiError(status, describeDetail(detail), {
+      detail, raw: typeof body?.raw === 'string' ? body.raw : `${status} ${text.slice(0, 2000)}`,
+    })
+  }
+  const message = status >= 500
+    ? `后端出错了（${status}），详情看服务日志`
+    : `请求没有成功（${status} ${statusText}）`
+  return new ApiError(status, message, { raw: `${status} ${statusText}\n${text.slice(0, 2000)}` })
+}
+
+/** 上传进度。字节发完（sent）之后还要等后端解析、切块，那段没有进度可报 */
+export interface UploadProgress {
+  /** 已经发出去的字节 */
+  loaded: number
+  /** 总字节；浏览器算不出来时为 null，这时只能画已发多少，不画百分比 */
+  total: number | null
+  /** 字节已经全部发完，在等后端处理 */
+  sent: boolean
+}
+
+export interface UploadOptions {
+  onProgress?: (p: UploadProgress) => void
+  signal?: AbortSignal
+}
+
+/**
+ * 带字节进度的上传。fetch 拿不到上传进度，只能用 XHR；报错、连接状态、署名头和
+ * request 走同一套，调用方看到的 ApiError 没有区别。取消照旧抛 AbortError。
+ */
+function upload<T>(path: string, form: FormData, opts?: UploadOptions): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const xhr = new XMLHttpRequest()
+    xhr.open('POST', BASE + path)
+    for (const [k, v] of Object.entries(actorHeader())) xhr.setRequestHeader(k, v)
+    const onProgress = opts?.onProgress
+    if (onProgress) {
+      // 进度事件里的字节数含 multipart 的边界和表头，比文件本身略大；发完那一下
+      // 沿用它的总数，前后两个数才对得上
+      let total: number | null = null
+      xhr.upload.onprogress = (e) => {
+        if (e.lengthComputable) total = e.total
+        onProgress({ loaded: e.loaded, total, sent: false })
+      }
+      xhr.upload.onload = () => {
+        const bytes = total ?? [...form.values()].reduce((n, v) => n + (v instanceof Blob ? v.size : 0), 0)
+        onProgress({ loaded: bytes, total: bytes || null, sent: true })
+      }
+    }
+    const abort = () => xhr.abort()
+    opts?.signal?.addEventListener('abort', abort)
+    const cleanup = () => opts?.signal?.removeEventListener('abort', abort)
+    xhr.onload = () => {
+      cleanup()
+      if (xhr.status < 200 || xhr.status >= 300) {
+        reject(failure(xhr.status, xhr.statusText, xhr.responseText ?? ''))
+        return
+      }
+      report(true)
+      if (xhr.status === 204 || !xhr.responseText) { resolve(undefined as T); return }
+      try {
+        resolve(JSON.parse(xhr.responseText))
+      } catch {
+        reject(new ApiError(xhr.status, '后端回的内容读不懂', { raw: xhr.responseText.slice(0, 2000) }))
+      }
+    }
+    xhr.onerror = () => {
+      cleanup()
+      const err = new ApiError(0, NETWORK_MESSAGE, { kind: 'network', raw: `XMLHttpRequest error: POST ${path}` })
+      report(false, err)
+      reject(err)
+    }
+    xhr.onabort = () => {
+      cleanup()
+      reject(new DOMException('上传已取消', 'AbortError'))
+    }
+    if (opts?.signal?.aborted) { xhr.abort(); return }
+    xhr.send(form)
+  })
+}
+
 /**
  * 数据源测连接的结果。ok=false 时 error 是一句人话、hint 是怎么办、detail 是
  * 驱动的原始报错（放进「技术细节」）。
@@ -197,6 +269,89 @@ export interface ProviderDraft {
   extra?: Record<string, any>
 }
 
+/** 探查结构的预览（dry_run）：只看不存，缓存和同步时间都没动 */
+export interface IntrospectPreview {
+  dry_run: true
+  /** 这次探的是哪个 schema，'' 是默认 schema */
+  schema: string
+  table_count: number
+  /** 带 schema 前缀的对象全名，最多 200 个 */
+  tables: string[]
+  truncated: boolean
+  total: number
+  schema_error: string
+  available_schemas: string[]
+}
+
+/** 一张表的结构化列信息（和给模型看的 detail 文本出自同一份缓存） */
+export interface SchemaColumn {
+  name: string
+  type: string
+  pk: boolean
+  not_null: boolean
+  comment: string | null
+}
+
+export interface TableSchema {
+  table: string
+  /** 给模型看的那段文本 */
+  detail: string
+  found: boolean
+  qualified: string | null
+  kind: 'table' | 'view' | null
+  comment: string | null
+  /** 老后端没有，只有 detail */
+  columns?: SchemaColumn[]
+}
+
+/** 知识库检索的一条命中 */
+export interface KbHit {
+  chunk_id: string
+  document_id: string
+  title: string
+  ordinal: number
+  content: string
+  score: number
+  signals?: Record<string, number>
+  /** 向量、关键词两路各贡献了多少分，两者之和等于 score。老后端不给 */
+  contrib?: { vector: number; keyword: number }
+  [key: string]: any
+}
+
+export interface KbSearchResult {
+  query: string
+  collection: string | null
+  results: KbHit[]
+  /** 这次检索降级了（比如退回纯关键词）的说明 */
+  degraded: string[]
+  /** 实际用的混合权重 */
+  alpha?: number
+  [key: string]: any
+}
+
+/**
+ * 后台重建索引的进度。phase：chunks（知识库切块）→ index（倒排，没有分批进度）→
+ * memories（长期记忆）→ done。total / done 是切块加记忆的合计
+ */
+export interface ReindexJob {
+  id: string
+  state: 'running' | 'done' | 'failed'
+  phase: 'chunks' | 'index' | 'memories' | 'done'
+  collection: string | null
+  total: number
+  done: number
+  chunks: { total: number; done: number }
+  memories: { total: number; done: number }
+  started_at: string
+  finished_at: string | null
+  error: string | null
+  hint: string | null
+  result: { reindexed: number; memories_reindexed: number; embedder: string; [key: string]: any } | null
+}
+
+/** runs.list 的 workflow_id 传它：只看没保存成工作流的那些运行（问数据页、画布上的临时图） */
+export const UNSAVED_WORKFLOW_ID = '__none__'
+
 /** 拼查询串：null / undefined / 空串跳过，数组用逗号连起来 */
 function qs(params?: Record<string, unknown>): string {
   if (!params) return ''
@@ -213,7 +368,17 @@ function qs(params?: Record<string, unknown>): string {
   return s ? `?${s}` : ''
 }
 
-const get = <T>(p: string) => request<T>(p)
+/**
+ * 单次请求的选项。timeoutMs 到点就掐断并按网络失败抛出（带 timeoutMs）：连得上但
+ * 卡着不回的接口（MCP 服务不应答时的 /tools）不能让调用方永远等下去，也不该一直
+ * 占着浏览器对同一主机的那几条连接
+ */
+export interface RequestOptions {
+  timeoutMs?: number
+  signal?: AbortSignal
+}
+
+const get = <T>(p: string, opts?: RequestOptions) => request<T>(p, opts)
 const post = <T>(p: string, body?: unknown) =>
   request<T>(p, { method: 'POST', body: JSON.stringify(body ?? {}) })
 const patch = <T>(p: string, body: unknown) =>
@@ -229,7 +394,7 @@ export const api = {
 
   // ---- 工作流 ----
   workflows: {
-    list: () => get<Workflow[]>('/workflows'),
+    list: (opts?: RequestOptions) => get<Workflow[]>('/workflows', opts),
     get: (id: string) => get<Workflow>(`/workflows/${id}`),
     create: (body: { name: string; description?: string; graph?: GraphSpec; tags?: string[] }) =>
       post<Workflow>('/workflows', body),
@@ -261,23 +426,32 @@ export const api = {
     test: (id: string) => post<ConnectionTest>(`/datasources/${id}/test`, {}),
     /** 测一份还没保存的配置，只测连接不落库。编辑时带上 id，后端可以沿用已存的密码 */
     testConfig: (body: any) => post<ConnectionTest>('/datasources/test', body),
-    /** 上传 Excel / CSV，变成一个可以用 SQL 查的数据源。同名就地替换 */
-    uploadTable: (file: File, body: { name: string; description?: string; header_row?: number }) => {
+    /** 上传 Excel / CSV，变成一个可以用 SQL 查的数据源。同名就地替换。onProgress 报字节进度 */
+    uploadTable: (file: File, body: { name: string; description?: string; header_row?: number }, opts?: UploadOptions) => {
       const form = new FormData()
       form.append('file', file)
       form.append('name', body.name)
       form.append('description', body.description ?? '')
       form.append('header_row', String(body.header_row ?? 1))
-      return request<{
+      type Out = {
         source: any; replaced: boolean
         tables: { name: string; sheet: string; rows: number
                   columns: { name: string; type: string }[] }[]
-      }>('/datasources/upload', { method: 'POST', body: form })
+      }
+      return opts?.onProgress
+        ? upload<Out>('/datasources/upload', form, opts)
+        : request<Out>('/datasources/upload', { method: 'POST', body: form, signal: opts?.signal })
     },
     introspect: (id: string, schema?: string) =>
       post<any>(`/datasources/${id}/introspect${schema ? `?schema=${encodeURIComponent(schema)}` : ''}`, {}),
+    /** 换个 schema 看看：只返回探到的结果，不覆盖缓存（Copilot 看到的还是原来那份） */
+    previewSchema: (id: string, schema?: string) =>
+      post<IntrospectPreview>(`/datasources/${id}/introspect${qs({ schema, dry_run: 'true' })}`, {}),
     schema: (id: string, table?: string) =>
       get<any>(`/datasources/${id}/schema${table ? `?table=${encodeURIComponent(table)}` : ''}`),
+    /** 一张表的结构，带结构化的列信息，不用再去解析 detail 文本 */
+    tableSchema: (id: string, table: string) =>
+      get<TableSchema>(`/datasources/${id}/schema?table=${encodeURIComponent(table)}`),
   },
 
   runs: {
@@ -302,7 +476,8 @@ export const api = {
     /** 从失败的节点接着跑。graph 只能带改过配置的同一张图，结构必须一致 */
     continue: (id: string, graph?: GraphSpec | null) =>
       post<Run>(`/runs/${id}/continue`, { graph: graph ?? null }),
-    cancel: (id: string) => post<{ ok: boolean }>(`/runs/${id}/cancel`),
+    // 等审批的运行直接收成 cancelled；在跑的要等引擎收尾，先回 stopping
+    cancel: (id: string) => post<{ ok: boolean; status?: 'stopping' | 'cancelled' }>(`/runs/${id}/cancel`),
     resume: (id: string, response: any) => post<Run>(`/runs/${id}/resume`, { response }),
     events: (id: string, after = 0) => get<RunEvent[]>(`/runs/${id}/events?after=${after}`),
     state: (id: string) => get<any>(`/runs/${id}/state`),
@@ -317,15 +492,15 @@ export const api = {
 
   approvals: {
     /** 老写法 list('pending') 照旧可用。status 可逗号分隔，'all' 取全部 */
-    list: (params: string | { status?: string; run_id?: string; limit?: number } = 'pending') =>
-      get<Approval[]>(`/approvals${qs(typeof params === 'string' ? { status: params } : { status: 'pending', ...params })}`),
+    list: (params: string | { status?: string; run_id?: string; limit?: number } = 'pending', opts?: RequestOptions) =>
+      get<Approval[]>(`/approvals${qs(typeof params === 'string' ? { status: params } : { status: 'pending', ...params })}`, opts),
     decide: (id: string, body: { approved: boolean; note?: string; value?: any; args?: any }) =>
       post<Run>(`/approvals/${id}/decide`, body),
   },
 
   // ---- 设置 ----
   providers: {
-    list: () => get<Provider[]>('/providers'),
+    list: (opts?: RequestOptions) => get<Provider[]>('/providers', opts),
     catalog: () => get<any>('/providers/catalog'),
     create: (body: any) => post<Provider>('/providers', body),
     update: (id: string, body: any) => patch<Provider>(`/providers/${id}`, body),
@@ -347,7 +522,7 @@ export const api = {
 
   // ---- 工具 ----
   tools: {
-    list: () => get<ToolInfo[]>('/tools'),
+    list: (opts?: RequestOptions) => get<ToolInfo[]>('/tools', opts),
     /** 危险工具要 confirm，否则后端回 409，detail 写明它会做什么 */
     run: (name: string, args: Record<string, any>, opts?: { confirm?: boolean }) =>
       post<any>(`/tools/${name}/run`, opts?.confirm ? { args, confirm: true } : { args }),
@@ -358,6 +533,11 @@ export const api = {
     update: (id: string, body: any) => patch<any>(`/custom-tools/${id}`, body),
     remove: (id: string) => del(`/custom-tools/${id}`),
     test: (id: string, args: Record<string, any>) => post<any>(`/custom-tools/${id}/test`, { args }),
+    /** 试跑一份还没保存的配置，不落库。失败时回 {ok:false, error, hint, detail, duration_ms} */
+    testDraft: (body: {
+      name?: string; kind: string; parameters?: Record<string, any>; config?: Record<string, any>
+      args?: Record<string, any>
+    }) => post<any>('/custom-tools/test', body),
   },
   mcp: {
     list: () => get<any[]>('/mcp/servers'),
@@ -398,18 +578,26 @@ export const api = {
     clearScope: (scope: string) => del(`/memory/scope/${scope}`),
   },
   kb: {
-    collections: () => get<{ collection: string; documents: number; chunks: number }[]>('/kb/collections'),
+    collections: (opts?: RequestOptions) =>
+      get<{ collection: string; documents: number; chunks: number }[]>('/kb/collections', opts),
     documents: (collection?: string) =>
       get<KbDocument[]>(`/kb/documents${collection ? `?collection=${collection}` : ''}`),
     ingest: (body: { collection?: string; title?: string; content: string; source?: string }) =>
       post<KbDocument>('/kb/documents', body),
-    upload: (file: File, collection = 'default') => {
+    /**
+     * 上传一份文档。给了 onProgress 就报真实的字节进度（XHR）；字节发完以后是后端
+     * 在解析、切块，那段没有进度，调用方写「处理中」，不要把条拉满冒充完成
+     */
+    upload: (file: File, collection = 'default', opts?: UploadOptions) => {
       const form = new FormData()
       form.append('file', file)
-      return request<KbDocument>(`/kb/upload?collection=${collection}`, { method: 'POST', body: form })
+      const path = `/kb/upload?collection=${encodeURIComponent(collection)}`
+      return opts?.onProgress
+        ? upload<KbDocument>(path, form, opts)
+        : request<KbDocument>(path, { method: 'POST', body: form, signal: opts?.signal })
     },
     search: (q: string, collection?: string, alpha = 0.5) =>
-      get<any & { alpha?: number }>(`/kb/search?q=${encodeURIComponent(q)}&alpha=${alpha}${collection ? `&collection=${collection}` : ''}`),
+      get<KbSearchResult>(`/kb/search?q=${encodeURIComponent(q)}&alpha=${alpha}${collection ? `&collection=${encodeURIComponent(collection)}` : ''}`),
     /** 上传框能收哪些文件。以后端解析器为准，免得界面放行了后端必拒的格式 */
     formats: () => get<{
       extensions: string[]; text: string[]; tabular: string[]; legacy: string[]; accept: string
@@ -440,12 +628,21 @@ export const api = {
     probeEmbedding: (baseUrl: string) =>
       get<{ base_url: string; models: string[] }>(
         `/kb/embedding/probe?base_url=${encodeURIComponent(baseUrl)}`),
+    /** 等做完再返回。几千段配远端 embedding 要好几分钟，界面上用 startReindex */
     reindex: (collection?: string) =>
       post<{ reindexed: number; memories_reindexed: number; embedder: string }>(
-        `/kb/reindex${collection ? `?collection=${collection}` : ''}`),
+        `/kb/reindex${qs({ collection })}`),
+    /**
+     * 后台重建，立刻返回任务；进度用 reindexStatus 轮询。已经有一次在跑时回 409，
+     * detail 写着进度
+     */
+    startReindex: (collection?: string) =>
+      post<ReindexJob>(`/kb/reindex${qs({ collection, background: 'true' })}`),
+    /** 最近一次重建的进度。进程里只记最近一次，还没重建过是 {state:'idle'} */
+    reindexStatus: () => get<ReindexJob | { state: 'idle' }>('/kb/reindex'),
   },
   skills: {
-    list: () => get<Skill[]>('/skills'),
+    list: (opts?: RequestOptions) => get<Skill[]>('/skills', opts),
     create: (body: Partial<Skill>) => post<Skill>('/skills', body),
     update: (id: string, body: Partial<Skill>) => patch<Skill>(`/skills/${id}`, body),
     remove: (id: string) => del(`/skills/${id}`),
@@ -481,9 +678,15 @@ export const api = {
     generate: (body: {
       instruction: string; base_graph?: GraphSpec | null
       conversation_id?: string | null
+      /** 这一轮只查这几个数据源（id 或名字）。不传或空表示不限 */
+      datasource_ids?: string[] | null
     }) =>
-      post<{ graph: GraphSpec; explanation: string; issues: ValidationIssue[] }>(
-        '/copilot/generate', body),
+      post<{
+        graph: GraphSpec; explanation: string; issues: ValidationIssue[]
+        layout?: { mode: 'keep' | 'full'; placed: string[] }
+        /** 改图前后都在、工具绑定却变了的节点和成员。老后端不给 */
+        tool_changes?: ToolChange[]
+      }>('/copilot/generate', body),
     explain: (graph: GraphSpec) => post<{ explanation: string }>('/copilot/explain', { graph }),
     layout: (graph: GraphSpec) => post<GraphSpec>('/copilot/layout', { graph }),
     fromRun: (runId: string, name?: string) =>
@@ -514,7 +717,10 @@ export function streamCopilot(
     intent?: 'build' | 'answer'
     /** 属于哪次对话。带上它，这一轮才知道前面聊过什么 */
     conversation_id?: string | null
+    /** 这一轮只查这几个数据源（id 或名字）。不传或空表示不限 */
+    datasource_ids?: string[] | null
   },
+  // final 操作里带 tool_changes（ToolChange[]）：改图回执要显式列出工具绑定的变化
   onOp: (op: any) => void,
   onEnd: (error?: string) => void,
 ): () => void {
diff --git a/frontend/src/canvas/FlowCanvas.tsx b/frontend/src/canvas/FlowCanvas.tsx
index 542853df..aa3f9bfe 100644
--- a/frontend/src/canvas/FlowCanvas.tsx
+++ b/frontend/src/canvas/FlowCanvas.tsx
@@ -1,27 +1,29 @@
 import './surface.css'
 import {
-  createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState, type CSSProperties,
+  createContext, memo, useCallback, useContext, useEffect, useId, useMemo, useRef, useState, type CSSProperties,
 } from 'react'
 import {
   Background, BackgroundVariant, ControlButton, Controls, MiniMap, ReactFlow, ReactFlowProvider,
-  useReactFlow, useStoreApi, type AriaLabelConfig, type Edge, type MiniMapNodeProps, type Viewport,
+  useReactFlow, useStoreApi, ViewportPortal, type AriaLabelConfig, type Edge, type MiniMapNodeProps, type Viewport,
 } from '@xyflow/react'
-import { Crosshair, Lock, Route as RouteIcon } from 'lucide-react'
+import { Crosshair, Lock, PanelRightOpen, Route as RouteIcon, Search } from 'lucide-react'
 import clsx from 'clsx'
 import { FlowEdge, MomentContext, RoutingContext, type EdgeRunState, type EdgeView } from './FlowEdge'
+import { openInspector, stepsFirst, useSheet } from './InspectorSheet'
 import { NodeCard } from './NodeCard'
+import { NODE_CATEGORIES, NODE_DEFS, type NodeDef } from './nodeDefs'
 import { buildRoutes, NODE_WIDTH } from './routing'
 import { RunTimeline, useDock } from './RunTimeline'
-import { toast } from '../components/ui'
+import { isComposing, toast } from '../components/ui'
 import { runClassLabel } from '../lib/terms'
 import { shortId } from '../lib/format'
 import {
-  activeEdgesOf, applyDerived, edgeIdOf, edgeKey, heldEdgesOf, topology, walkedEdges, type GraphLike,
+  activeEdgesOf, edgeIdOf, edgeKey, heldEdgesOf, topology, walkedEdges, type GraphLike,
 } from '../run/derive'
 import {
   isActivePhase, isTerminal, type NodeState, type NodeTrace, type RunPhase, type Trace,
 } from '../run/trace'
-import { projectCached } from '../run/useNodeView'
+import { replayTraceCached } from '../run/useNodeView'
 import { useStudio, type FlowNode } from '../store/studio'
 import type { NodeType } from '../types'
 
@@ -30,6 +32,11 @@ const edgeTypes = { flow: FlowEdge }
 
 /** 读得清卡片字的最低缩放。低于它，12px 的标题落到 7px 以下，光弧也细到看不见 */
 const READABLE_ZOOM = 0.6
+/**
+ * 精简档里标题换成放大的字（见 NodeCard 的 .nc-lod），0.4 倍时屏幕上仍有 11px 以上。
+ * 整张图在可读缩放下放不下、在这里放得下时，打开就看全图的形状，而不是只看前两列
+ */
+const COMPACT_ZOOM = 0.4
 /** 语义缩放三档的门槛，上下各留 0.02 的回滞，免得停在门槛上来回跳 */
 const LOD_FULL = 0.6
 const LOD_SIGNAL = 0.35
@@ -105,31 +112,43 @@ let lastFocus: object | null = null
 const setStudio = useStudio.setState as (patch: Record<string, unknown>) => void
 
 // -------------------------------------------------------------------------
-// 回放：把航迹投影到游标那一刻，边和小地图按那一刻的样子画
+// 回放：航迹投影到游标那一刻（run/useNodeView 的 replayTraceCached，卡片读同一份），
+// 边、小地图、回边的圈数都按那一刻画
 // -------------------------------------------------------------------------
 
-function replayTrace(t: Trace, at: number, graph: GraphLike): Trace {
-  const proj = projectCached(t, at)
-  const nodes: Record<string, NodeTrace> = {}
-  for (const [id, n] of Object.entries(t.nodes)) {
-    const p = proj.nodes[id]
-    const taken: string[] = []
-    let looping = false
-    for (const s of n.segments) {
-      if (s.kind !== 'run' || s.start > at) continue
-      if (s.handle && !taken.includes(s.handle)) taken.push(s.handle)
-      looping = s.handle === 'body' && s.end != null && s.end <= at
-    }
-    const state = p?.state ?? 'idle'
-    // 人工审批的通过 / 驳回只记在节点上，不在段上：它结束了就用节点上的
-    const finished = state === 'done' || state === 'failed'
-    const decided = taken.length ? taken : finished ? n.taken ?? [] : []
-    nodes[id] = {
-      ...n, state, count: p?.count ?? 0, taken: decided, takenHandle: decided[decided.length - 1],
-      looping: state === 'running' && looping,
-    }
+/**
+ * 回边兜回去了几次：目标这一次进入以来开跑的次数减一。回放截到游标。
+ * 走过 done 出口的那一段是上一次进入的收尾——嵌套在外层循环里时，内层每次进来
+ * 重新数，和循环卡片上「第几轮」同一个口径。审批恢复的重放不算又跑了一次
+ */
+function loopsOf(n: NodeTrace | undefined, at: number | null): number {
+  if (!n) return 0
+  let runs = 0
+  for (let i = n.segments.length - 1; i >= 0; i -= 1) {
+    const s = n.segments[i]
+    if (s.kind !== 'run' || s.resumed || (at != null && s.start > at)) continue
+    if (s.handle === 'done' && runs > 0) break
+    runs += 1
   }
-  return applyDerived({ ...t, phase: proj.phase, nodes }, graph)
+  return Math.max(0, runs - 1)
+}
+
+/**
+ * 运行中点了一个跑过的节点：右栏滚到它的步骤。右栏归助手面板，它接这个事件
+ * （在对话层时先切到运行层），接了就 preventDefault；没人接时自己找步骤行描一圈
+ */
+function revealStep(nodeId: string): void {
+  const runId = useStudio.getState().run?.id
+  const handled = !window.dispatchEvent(new CustomEvent('agentlab:reveal-step', {
+    detail: { runId, nodeId }, cancelable: true,
+  }))
+  if (handled) return
+  const rows = document.querySelectorAll<HTMLElement>(`[data-step-status][data-node-id="${CSS.escape(nodeId)}"]`)
+  const row = rows[rows.length - 1]
+  if (!row) return
+  row.scrollIntoView({ block: 'center', behavior: reducedMotion() ? 'auto' : 'smooth' })
+  row.dataset.flash = 'focus'
+  setTimeout(() => { if (row.dataset.flash === 'focus') delete row.dataset.flash }, 1800)
 }
 
 /** 每条边此刻的运行态 */
@@ -211,6 +230,160 @@ const typeColor = (n: { data?: unknown }): string => {
   return type ? `var(--nt-${type})` : 'var(--text-faint)'
 }
 
+// -------------------------------------------------------------------------
+// Copilot 这一轮删掉的节点：原地留一道虚线框，停一下再淡出
+// -------------------------------------------------------------------------
+
+/** 虚线框停留的总时长，和 surface.css 里 sf-ghost-out 的时长一致 */
+const GHOST_MS = 2400
+
+interface Ghost {
+  id: string
+  x: number
+  y: number
+  w: number
+  h: number
+  label: string
+  type: NodeType
+}
+
+const ghostOf = (n: FlowNode): Ghost => ({
+  id: n.id, x: n.position.x, y: n.position.y,
+  w: n.measured?.width ?? NODE_WIDTH, h: n.measured?.height ?? 80,
+  label: n.data.label || NODE_DEFS[n.data.nodeType]?.label || n.id, type: n.data.nodeType,
+})
+
+/**
+ * 助手改完图，新加的节点有入场、改过的有标记，删掉的却是一声不响就没了——回执写着
+ * 「删除 1」，画布上看不出删的是哪一个、原来在哪。在它原来的位置画一道虚线框、
+ * 写上名字，停两秒淡出。只由这一轮落定触发、只播一次；关了动效就不画（回执里照样写着）
+ */
+function useRemovedGhosts(): { seq: number; items: Ghost[] } | null {
+  const [ghosts, setGhosts] = useState<{ seq: number; items: Ghost[] } | null>(null)
+  useEffect(() => {
+    // 这一轮开始前的样子：删掉的节点可能在流式途中就没了，落定时 store 里已经找不到
+    let before = new Map<string, Ghost>()
+    let timer = 0
+    const unsub = useStudio.subscribe((s, prev) => {
+      if (s.copilot.active && !prev.copilot.active) before = new Map(prev.nodes.map((n) => [n.id, ghostOf(n)]))
+      if (s.copilotTurns === prev.copilotTurns) return
+      const turn = s.copilotTurns[s.copilotTurns.length - 1]
+      if (!turn || turn.phase !== 'done' || turn.outcome !== 'applied') return
+      if (prev.copilotTurns.find((t) => t.id === turn.id)?.phase === 'done') return
+      const items = (turn.diff?.removed ?? []).flatMap((id) => before.get(id) ?? [])
+      before = new Map()
+      if (!items.length || reducedMotion()) return
+      clearTimeout(timer)
+      setGhosts((g) => ({ seq: (g?.seq ?? 0) + 1, items }))
+      timer = window.setTimeout(() => setGhosts(null), GHOST_MS)
+    })
+    return () => {
+      unsub()
+      clearTimeout(timer)
+    }
+  }, [])
+  return ghosts
+}
+
+// -------------------------------------------------------------------------
+// 双击空白处快速添加：在光标处搜类型、回车放下。和节点库读同一份节点定义
+// -------------------------------------------------------------------------
+
+const QUICK_W = 248
+const QUICK_H = 312
+
+function QuickAdd({ x, y, bounds, onPick, onClose }: {
+  /** 双击处，相对画布容器的像素 */
+  x: number
+  y: number
+  bounds: { w: number; h: number }
+  onPick: (type: NodeType) => void
+  onClose: () => void
+}) {
+  const [query, setQuery] = useState('')
+  const [cur, setCur] = useState(0)
+  const box = useRef<HTMLDivElement>(null)
+  const list = useRef<HTMLDivElement>(null)
+  const defs = useMemo(() => {
+    const q = query.trim().toLowerCase()
+    // 按节点库的分组顺序排；搜的时候名字里有的排在只是说明里提到的前面——搜「分」
+    // 要的是「条件分支」，不是说明里写着「分派」的协作节点
+    const all = NODE_CATEGORIES.flatMap((c) => Object.values(NODE_DEFS).filter((d) => d.category === c))
+    if (!q) return all
+    const named = (d: NodeDef) => d.label.toLowerCase().includes(q) || d.type.includes(q)
+    return [...all.filter(named), ...all.filter((d) => !named(d) && d.description.toLowerCase().includes(q))]
+  }, [query])
+  const at = Math.min(cur, Math.max(0, defs.length - 1))
+  const listId = useId()
+
+  // 点到外面就收起；它是个一次性的小面板，不该留在那儿挡画布
+  useEffect(() => {
+    const onDown = (e: PointerEvent) => { if (!box.current?.contains(e.target as Node)) onClose() }
+    document.addEventListener('pointerdown', onDown, true)
+    return () => document.removeEventListener('pointerdown', onDown, true)
+  }, [onClose])
+  useEffect(() => {
+    list.current?.querySelector<HTMLElement>(`[data-i="${at}"]`)?.scrollIntoView({ block: 'nearest' })
+  }, [at])
+
+  const onKeyDown = (e: React.KeyboardEvent) => {
+    if (isComposing(e)) return
+    if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+      e.preventDefault()
+      setCur(Math.max(0, Math.min(defs.length - 1, at + (e.key === 'ArrowDown' ? 1 : -1))))
+    } else if (e.key === 'Enter') {
+      e.preventDefault()
+      if (defs[at]) onPick(defs[at].type)
+    } else if (e.key === 'Escape') {
+      // 用掉这一下：别再让它去关属性面板、清运行结果
+      e.preventDefault()
+      e.stopPropagation()
+      onClose()
+    }
+  }
+  // 贴着光标放，放不下就往回收，不伸出画布
+  const left = Math.max(8, Math.min(x, bounds.w - QUICK_W - 8))
+  const top = Math.max(8, Math.min(y, bounds.h - QUICK_H - 8))
+  const optId = (i: number) => `${listId}-${i}`
+  return (
+    <div ref={box} className="sf-quick sheet-in nodrag nopan nowheel" style={{ left, top, width: QUICK_W }}
+         role="dialog" aria-label="快速添加节点" data-esc-layer onKeyDown={onKeyDown}>
+      <label className="sf-quick-search">
+        <Search size={12} aria-hidden />
+        <input
+          autoFocus
+          value={query}
+          placeholder="添加节点：搜名字或用途"
+          role="combobox"
+          aria-expanded
+          aria-controls={listId}
+          aria-activedescendant={defs[at] ? optId(at) : undefined}
+          aria-autocomplete="list"
+          onChange={(e) => { setQuery(e.target.value); setCur(0) }}
+        />
+      </label>
+      <div className="sf-quick-list" role="listbox" id={listId} ref={list} aria-label="节点类型">
+        {defs.map((d, i) => {
+          const Icon = d.icon
+          return (
+            <div key={d.type} id={optId(i)} data-i={i} role="option" aria-selected={i === at}
+                 className={clsx('sf-quick-item', `nt-${d.type}`, i === at && 'is-active')}
+                 title={d.description}
+                 onPointerEnter={() => setCur(i)}
+                 onClick={() => onPick(d.type)}>
+              <span className="sf-quick-icon"><Icon size={12} aria-hidden /></span>
+              <span className="min-w-0 flex-1 truncate">{d.label}</span>
+              <span className="sf-dim">{d.category}</span>
+            </div>
+          )
+        })}
+        {!defs.length && <div className="sf-quick-empty">没有叫「{query.trim()}」的节点</div>}
+      </div>
+      <div className="sf-quick-foot">↑↓ 选择 · ↵ 放在这里 · Esc 关闭</div>
+    </div>
+  )
+}
+
 // -------------------------------------------------------------------------
 
 function CanvasInner() {
@@ -231,6 +404,7 @@ function CanvasInner() {
   const selectedId = useStudio((s) => s.selectedId)
   const follow = useStudio((s) => s.follow)
   const pathOnly = useDock((s) => s.pathOnly)
+  const sheetOpen = useSheet((s) => s.open)
   // 动作从 getState 取：整个 useStudio() 解构会订阅全部字段，每个 token 都让画布重渲染一次
   const actions = useStudio.getState()
 
@@ -248,9 +422,10 @@ function CanvasInner() {
   const routes = useMemo(() => buildRoutes(nodes, edges), [nodes, edges])
 
   // ---- 此刻（实时或回放游标那一刻）的航迹 ----
+  // graph 直接用 store 里的 nodes / edges 数组：卡片那边按同样的引用取，缓存才对得上
   const view = useMemo(() => {
     if (replayAt == null) return { trace, phase: runPhase, flowing: activeEdges }
-    const t = replayTrace(trace, replayAt, graph)
+    const t = replayTraceCached(trace, replayAt, graph)
     return { trace: t, phase: t.phase, flowing: activeEdgesOf(t, graph) }
   }, [trace, runPhase, activeEdges, replayAt, graph])
 
@@ -307,10 +482,9 @@ function CanvasInner() {
     return edges.map((e) => {
       const state = edgeStates.get(e.id) ?? 'idle'
       const back = topo.back.has(edgeKey(e))
-      const target = view.trace.nodes[e.target]
       const sf: EdgeView = {
         state, back, rank: topo.rank[e.target] ?? 0,
-        loops: back ? Math.max(0, target?.iteration ?? (target?.count ?? 1) - 1) : 0,
+        loops: back ? loopsOf(view.trace.nodes[e.target], replayAt) : 0,
       }
       const className = clsx(
         `sf-e-${state}`,
@@ -321,7 +495,7 @@ function CanvasInner() {
       // animated 一律关掉：React Flow 的 animated 是一条永远在走的虚线，方向和"是否真在流"都说不清
       return { ...e, type: 'flow', className, animated: false, data: { ...e.data, sf } }
     })
-  }, [edges, edgeStates, topo, view.trace, hasRun, selectedId, pathView])
+  }, [edges, edgeStates, topo, view.trace, replayAt, hasRun, selectedId, pathView])
 
   // ---- 节点：注入拓扑层级（一次性时刻按它错开），只看执行路径时压暗没走的 ----
   // 按原节点对象缓存：拖一个节点只换那一个的副本，其余卡片的 data 引用不变，memo 生效
@@ -385,6 +559,15 @@ function CanvasInner() {
     })
   }, [rfStore, applyZoom])
 
+  // ---- 取景 ----
+  /**
+   * 正在飞的那一次程序取景（跟随、点名定位、Copilot 跟镜头）。画布尺寸恰好在
+   * 半路变了（运行一开始航迹坞就升起来）时，下面的保持中心会打断它；这里记着
+   * 目标，打断之后重新飞一次，不然镜头停在半路、要看的节点还在视口外
+   */
+  const flight = useRef<{ ids: string[]; zoomAtLeast?: number; until: number } | null>(null)
+  const retarget = useRef<(() => void) | null>(null)
+
   // 画布尺寸变了（航迹坞出现、变量抽屉挤进来）时保持视口中心不动。React Flow
   // 默认钉住左上角，坞一升起来，画面下半截的节点就被它盖住了
   const box = useRef<HTMLDivElement>(null)
@@ -398,6 +581,7 @@ function CanvasInner() {
       if (last.w && last.h && (w !== last.w || h !== last.h)) {
         const { x, y, zoom } = getViewport()
         void setViewport({ x: x + (w - last.w) / 2, y: y + (h - last.h) / 2, zoom })
+        if (flight.current && Date.now() < flight.current.until) requestAnimationFrame(() => retarget.current?.())
       }
       last = { w, h }
     })
@@ -405,7 +589,6 @@ function CanvasInner() {
     return () => ro.disconnect()
   }, [getViewport, setViewport])
 
-  // ---- 取景 ----
   const pausedUntil = useRef(0)
   /**
    * 人手动平移、缩放的那一下：开始时记下视口，结束时真的动过才让跟随让路。
@@ -426,7 +609,7 @@ function CanvasInner() {
   /**
    * 打开一张图时的取景。整图放得下、缩放不低于可读下限就整图居中；放不下就
    * 不再硬塞——以入口为左锚、按可读缩放只取前几列，其余交给小地图。以前一律
-   * 整图塞进来，12 节点的图缩到 0.2，标题只剩 3px。
+   * 整图塞进来，12 节点的图缩到 0.2，标题只剩 3px。窄画布另有一档，见下面 narrow。
    */
   const frame = useCallback((duration: number) => {
     const el = rf.current
@@ -442,16 +625,26 @@ function CanvasInner() {
       void fitView({ padding: 0.12, maxZoom: 1.1, minZoom: READABLE_ZOOM, duration, interpolate: LINEAR })
       return
     }
-    // 按列聚类，取前四列的跨度定缩放
+    // 按列聚类
     const xs = [...new Set(all.map((n) => Math.round(n.position.x)))].sort((a, b) => a - b)
     const cols: number[] = []
     for (const x of xs) if (!cols.length || x - cols[cols.length - 1] > 60) cols.push(x)
-    const firstCols = cols.slice(0, 4)
-    const span = (firstCols[firstCols.length - 1] ?? bounds.x) + NODE_WIDTH - bounds.x
-    let zoom = Math.min(1, Math.max(READABLE_ZOOM, (W - 2 * PAD) / Math.max(span, NODE_WIDTH)))
+    const spanOf = (k: number) => (cols[Math.min(k, cols.length) - 1] ?? bounds.x) + NODE_WIDTH - bounds.x
+    // 窄画布（1024 宽、两边栏都开着时只剩五百来 px）：可读缩放下连前三列都放不下，
+    // 打开只看得见两张半卡片。这时退到精简档：整张图放得下就看全图，放不下就多看几列。
+    // 宽画布照旧按可读缩放——精简卡没有摘要和遥测，能看清就不该让人先放大一次
+    const narrow = cols.length >= 3 && spanOf(3) * READABLE_ZOOM > W - 2 * PAD
+    if (narrow && fit >= COMPACT_ZOOM) {
+      void fitView({ padding: 0.12, maxZoom: READABLE_ZOOM, minZoom: COMPACT_ZOOM, duration, interpolate: LINEAR })
+      return
+    }
+    // 取前四列的跨度定缩放
+    let zoom = narrow
+      ? Math.max(COMPACT_ZOOM, Math.min(READABLE_ZOOM, (W - 2 * PAD) / spanOf(4)))
+      : Math.min(1, Math.max(READABLE_ZOOM, (W - 2 * PAD) / Math.max(spanOf(4), NODE_WIDTH)))
     // 竖直方向放得下就别再放大：宁可多看几列
     const vfit = (H - 2 * PAD) / bounds.height
-    if (vfit >= READABLE_ZOOM) zoom = Math.min(zoom, vfit)
+    if (vfit >= (narrow ? COMPACT_ZOOM : READABLE_ZOOM)) zoom = Math.min(zoom, vfit)
     const entries = all.filter((n) => (n.data as FlowNode['data']).nodeType === 'input')
     const anchor = entries[0] ?? all.reduce((a, b) => (a.position.x <= b.position.x ? a : b))
     const anchorH = anchor.measured?.height ?? 80
@@ -511,9 +704,15 @@ function CanvasInner() {
     const fits = (maxX - minX) * z <= el.clientWidth - 2 * M && (maxY - minY) * z <= el.clientHeight - 2 * M
     const target = fits ? { cx: (minX + maxX) / 2, cy: (minY + maxY) / 2 }
       : { cx: rects[0].x + rects[0].w / 2, cy: rects[0].y + rects[0].h / 2 }
-    void setCenter(target.cx, target.cy, { zoom: z, duration: reducedMotion() ? 0 : 320, interpolate: LINEAR })
+    const duration = reducedMotion() ? 0 : 320
+    flight.current = { ids, zoomAtLeast: opts.zoomAtLeast, until: Date.now() + duration + 80 }
+    void setCenter(target.cx, target.cy, { zoom: z, duration, interpolate: LINEAR })
     return true
   }, [getInternalNode, getViewport, setCenter])
+  retarget.current = () => {
+    const f = flight.current
+    if (f) bringIntoView(f.ids, { force: true, zoomAtLeast: f.zoomAtLeast })
+  }
 
   // 跟随执行：有节点实时开跑、而它在视口外时平移过去。只由 node.started 驱动，
   // 不新增任何动画循环；同一帧里一起开跑的并成一次
@@ -541,6 +740,31 @@ function CanvasInner() {
     }
   }, [bringIntoView])
 
+  // Copilot 搭图时镜头跟着它刚动过的节点：落在视口外就平移过去，不改缩放（新节点
+  // 本来就落在上游旁边或视口中心附近的空地上）。人一旦手动平移、缩放，这一轮就不再跟；
+  // 节点还在滑向落点时每帧都会变，飞行途中不重新起飞，免得镜头追着它抖
+  const copilotOff = useRef(false)
+  useEffect(() => {
+    let raf = 0
+    const unsub = useStudio.subscribe((s, prev) => {
+      if (s.copilot.active && !prev.copilot.active) copilotOff.current = false
+      if (!s.copilot.active || !s.copilotCursor || copilotOff.current) return
+      if (s.copilotCursor === prev.copilotCursor && s.nodes === prev.nodes) return
+      if (raf) return
+      raf = requestAnimationFrame(() => {
+        raf = 0
+        const st = useStudio.getState()
+        if (!st.copilot.active || !st.copilotCursor || copilotOff.current || userMove.current) return
+        if (flight.current && Date.now() < flight.current.until) return
+        bringIntoView([st.copilotCursor])
+      })
+    })
+    return () => {
+      unsub()
+      cancelAnimationFrame(raf)
+    }
+  }, [bringIntoView])
+
   // 右栏、时间轴、胶囊请求取景：点名要看它，就算已在视口里也居中一下。
   // focusRequest 每次请求都是新对象（seq +1），同一个节点连点两次也会再取景
   useEffect(() => {
@@ -585,6 +809,41 @@ function CanvasInner() {
     [actions, screenToFlowPosition, formalLock],
   )
 
+  const ghosts = useRemovedGhosts()
+
+  // ---- 双击空白处快速添加 ----
+  const [quick, setQuick] = useState<{ x: number; y: number; flow: { x: number; y: number } } | null>(null)
+  const closeQuick = useCallback(() => setQuick(null), [])
+  const onPaneDoubleClick = (e: React.MouseEvent) => {
+    if (!(e.target as Element).classList?.contains('react-flow__pane')) return
+    if (formalLock) {
+      toast.warn('正式运行进行中，画布只读。等它结束再改')
+      return
+    }
+    if (useStudio.getState().copilot.active) {
+      toast.info('助手正在改这张图，等这一轮结束再加节点')
+      return
+    }
+    const r = box.current?.getBoundingClientRect()
+    if (!r) return
+    setQuick({ x: e.clientX - r.left, y: e.clientY - r.top, flow: screenToFlowPosition({ x: e.clientX, y: e.clientY }) })
+  }
+  const pickQuick = (type: NodeType) => {
+    const at = quick?.flow
+    setQuick(null)
+    // 双击处是卡片的中心，不是左上角
+    if (at) actions.addNode(type, { x: at.x - NODE_WIDTH / 2, y: at.y - 40 })
+  }
+
+  // ---- 运行中点节点：先看它的步骤，属性面板是次级入口 ----
+  // 看运行（进行中或回放）时点了跑过的节点，属性面板不自动盖上右栏（见 InspectorSheet）；
+  // 这里给一个明确的入口，双击节点也能开
+  // 选中了却没开面板，只会是「先看步骤」那条路。运行结束后它照样留着：不然节点选中着、
+  // 面板没开、入口也没了
+  const peekId = selectedId && sheetOpen !== selectedId ? selectedId : null
+  const peekNode = peekId ? nodes.find((n) => n.id === peekId) : undefined
+  const peekLabel = peekNode ? peekNode.data.label || NODE_DEFS[peekNode.data.nodeType]?.label || peekNode.id : ''
+
   const rootStyle = useMemo(
     () => (moment?.kind === 'failed' ? { '--moment-origin': moment.origin } as CSSProperties : undefined),
     [moment],
@@ -619,22 +878,42 @@ function CanvasInner() {
               onNodesChange={actions.onNodesChange}
               onEdgesChange={actions.onEdgesChange}
               onConnect={actions.onConnect}
-              onNodeClick={(_, node) => actions.select(node.id)}
+              onNodeClick={(_, node) => {
+                if (!stepsFirst(node.id)) {
+                  // 点的是已经选中、面板却没开的节点（先看过步骤、运行随后结束了）：
+                  // 选中不变就不会触发面板的订阅，这里直接点名打开
+                  openInspector(node.id)
+                  return
+                }
+                actions.select(node.id)
+                revealStep(node.id)
+              }}
+              onNodeDoubleClick={(_, node) => openInspector(node.id)}
               onPaneClick={() => actions.select(null)}
+              onDoubleClick={onPaneDoubleClick}
+              zoomOnDoubleClick={false}
               onNodeMouseEnter={(_, node) => { if (hasRun) useDock.getState().set({ canvasHover: node.id }) }}
               onNodeMouseLeave={() => { if (hasRun) useDock.getState().set({ canvasHover: null }) }}
               onMoveStart={(event, vp) => {
                 // 程序取景（跟随、聚焦）没有 event；有 event 的是人在拖、在滚轮
                 if (event) userMove.current = vp
               }}
-              onMoveEnd={(_, vp) => {
+              onMoveEnd={(event, vp) => {
                 applyZoom(vp.zoom, true)
+                // 只认人手的那一下收尾。程序取景飞到一半被人抓住时，d3 先收掉那段动画，
+                // React Flow 却把它的收尾推迟到下一拍才报——那时人的拖动已经开始，这条
+                // 不带 event 的收尾要是也来结账，就把人的起点吃掉了，拖完跟随照样不暂停
+                if (!event) return
                 const from = userMove.current
                 if (!from) return
                 userMove.current = null
                 const moved = Math.abs(vp.x - from.x) > 2 || Math.abs(vp.y - from.y) > 2
                   || Math.abs(vp.zoom - from.zoom) > 1e-3
-                if (moved && active) pauseFollow()
+                if (!moved) return
+                // 人接过了镜头：程序取景不再续飞，Copilot 这一轮也不再跟
+                flight.current = null
+                if (useStudio.getState().copilot.active) copilotOff.current = true
+                if (active) pauseFollow()
               }}
               onDrop={onDrop}
               onDragOver={(e) => {
@@ -674,6 +953,16 @@ function CanvasInner() {
                 style={{ width: 150, height: 100 }}
                 ariaLabel={hasRun ? '小地图（按运行状态着色）' : '小地图'}
               />
+              {ghosts && (
+                <ViewportPortal>
+                  {ghosts.items.map((g) => (
+                    <div key={`${ghosts.seq}:${g.id}`} className={clsx('sf-ghost', `nt-${g.type}`)} data-ghost={g.id}
+                         style={{ transform: `translate(${g.x}px, ${g.y}px)`, width: g.w, height: g.h }} aria-hidden>
+                      <span className="sf-ghost-tag">已删除 · {g.label}</span>
+                    </div>
+                  ))}
+                </ViewportPortal>
+              )}
             </ReactFlow>
           </MiniStates.Provider>
         </MomentContext.Provider>
@@ -681,7 +970,7 @@ function CanvasInner() {
 
       {/* 画布顶上的浮条排成一行：跟随在左，只读横幅居中；放不下时横幅折到下一行、
           再不够就截掉说明文字。各自绝对定位的话，笔记本宽度下横幅会盖住「恢复」 */}
-      {(formalLock || showFollow) && (
+      {(formalLock || showFollow || peekId) && (
         <div className="sf-float">
           {showFollow && (
             <div className={clsx('sf-follow', followPaused && 'is-paused')}>
@@ -698,6 +987,14 @@ function CanvasInner() {
               )}
             </div>
           )}
+          {peekId && (
+            <button type="button" className="sf-peek" onClick={() => openInspector(peekId)}
+                    title="属性面板会盖住右栏的运行视图，底部那一条点一下就回来。双击节点也能打开">
+              <PanelRightOpen size={11} aria-hidden />
+              <span className="sf-peek-name">{peekLabel}</span>
+              <span>的配置</span>
+            </button>
+          )}
           {formalLock && (
             <div className="sf-banner" role="status">
               <Lock size={12} />
@@ -707,6 +1004,11 @@ function CanvasInner() {
           )}
         </div>
       )}
+
+      {quick && box.current && (
+        <QuickAdd x={quick.x} y={quick.y} bounds={{ w: box.current.clientWidth, h: box.current.clientHeight }}
+                  onPick={pickQuick} onClose={closeQuick} />
+      )}
     </div>
   )
 }
diff --git a/frontend/src/canvas/FlowEdge.tsx b/frontend/src/canvas/FlowEdge.tsx
index 5eaf8785..1fd12229 100644
--- a/frontend/src/canvas/FlowEdge.tsx
+++ b/frontend/src/canvas/FlowEdge.tsx
@@ -28,7 +28,7 @@ export interface EdgeView {
   back: boolean
   /** 目标节点的拓扑层级，一次性时刻按它错开 */
   rank: number
-  /** 回边已经兜回去几次（循环第几轮）。0 不显示 */
+  /** 回边已经兜回去几次：这一次进入循环以来，回放截到游标。0 不显示 */
   loops?: number
 }
 
diff --git a/frontend/src/canvas/Inspector.tsx b/frontend/src/canvas/Inspector.tsx
index 68ab5b33..e100a4b8 100644
--- a/frontend/src/canvas/Inspector.tsx
+++ b/frontend/src/canvas/Inspector.tsx
@@ -1,11 +1,12 @@
 import { useEffect, useId, useMemo, useState } from 'react'
 import { createPortal } from 'react-dom'
-import { AlertTriangle, ChevronLeft, Copy, Maximize2, Plus, Trash2, X, XCircle } from 'lucide-react'
+import { AlertTriangle, ChevronLeft, Copy, Lock, Maximize2, Plus, Trash2, X, XCircle } from 'lucide-react'
 import clsx from 'clsx'
 import { NODE_DEFS, syntaxOf, type FieldDef, type FieldSyntax } from './nodeDefs'
-import { fieldOfIssue, type FieldRef } from './issues'
+import { fieldOfIssue, unboundToolOf, withToolBound, type FieldRef } from './issues'
 import { hintOf } from './shortcuts'
-import { useStudio } from '../store/studio'
+import { isActivePhase } from '../run/trace'
+import { EDIT_LOCK_TEXT, useEditLock, useStudio } from '../store/studio'
 import { useCatalog, modelOptions } from '../store/catalog'
 import { api } from '../api/client'
 import { IconButton, JsonInput, Modal, isComposing } from '../components/ui'
@@ -35,12 +36,61 @@ function useRunDefaults() {
   return value
 }
 
+interface ToolOption { value: string; label: string; hint?: string; danger?: boolean; group?: string }
+
+/**
+ * 数据源的查询工具（db_query__<源> / db_schema__<源>）。/tools 的列表只有内置、自定义和 MCP，
+ * 以前检查器里挑不到它们：校验说「提示词要求用 db_query__x，把它加进工具里」，界面上却做不到。
+ * 30 秒内复用上一次的结果：每点一个节点都去问一遍没必要，可刚在数据页加的源也不能一直看不见
+ */
+let sourceTools: { at: number; list: Promise<ToolOption[]> } | null = null
+function useSourceTools(): ToolOption[] {
+  const [value, setValue] = useState<ToolOption[]>([])
+  useEffect(() => {
+    if (!sourceTools || Date.now() - sourceTools.at > 30_000) {
+      sourceTools = {
+        at: Date.now(),
+        list: api.datasources.list().then((rows) => rows
+          .filter((r) => r && r.enabled !== false)
+          .flatMap((r) => (Array.isArray(r.tools) ? r.tools as string[] : []).map((t) => ({
+            value: t, label: t, group: '数据源',
+            hint: `${t.startsWith('db_schema__') ? '查表结构' : '执行 SQL'} · 数据源「${r.name}」`,
+            // 可写的源上，写语句要人确认（运行时的审批关卡认它）
+            danger: t.startsWith('db_query__') && r.readonly === false,
+          }))))
+          .catch(() => { sourceTools = null; return [] }),
+      }
+    }
+    let alive = true
+    void sourceTools?.list.then((v) => { if (alive) setValue(v) })
+    return () => { alive = false }
+  }, [])
+  return value
+}
+
+/** 节点能绑的全部工具：目录里的，加上数据源的 */
+function useToolOptions(): ToolOption[] {
+  const tools = useCatalog((s) => s.tools)
+  const sources = useSourceTools()
+  return useMemo(() => {
+    const known = new Set(tools.map((t) => t.id))
+    return [
+      ...tools.map((t) => ({ value: t.id, label: t.name, hint: t.description, danger: t.dangerous, group: t.category })),
+      ...sources.filter((o) => !known.has(o.value)),
+    ]
+  }, [tools, sources])
+}
+
 /** 属性面板。所有字段都由 nodeDefs 的声明驱动渲染，加节点类型不用改这里。 */
 export function Inspector() {
   const selectedId = useStudio((s) => s.selectedId)
   const node = useStudio((s) => s.nodes.find((n) => n.id === s.selectedId))
   const allIssues = useStudio((s) => s.issues)
-  const locked = useStudio((s) => s.copilot.active)
+  // 助手在改、正式运行在跑：整块只读，说清为什么
+  const lock = useEditLock()
+  const locked = lock != null
+  // 运行中（探索运行也算）不删节点：画布那边同样关了删除键，事件会对到一个已经不在的节点上
+  const running = useStudio((s) => isActivePhase(s.runPhase))
   const runtime = useStudio((s) => (selectedId ? s.runtime[selectedId] : undefined))
   // 动作逐个取：不带选择器的 useStudio() 订阅整个 store，运行时每来一个 token 这块面板都要重渲染
   const updateNode = useStudio((s) => s.updateNode)
@@ -96,12 +146,24 @@ export function Inspector() {
         <span className="min-w-0 flex-1 truncate text-xs font-semibold">{def.label}</span>
         <IconButton label="复制节点" title={hintOf('复制一份', 'duplicate')} disabled={locked}
                     onClick={() => duplicateNode(node.id)} icon={<Copy size={12} />} />
-        <IconButton label="删除节点" title={`${hintOf('删除节点', 'delete')} · 可撤销`} disabled={locked}
+        <IconButton label="删除节点" disabled={locked || running}
+                    title={running && !locked ? '运行中不能删节点：等它结束或者先停下' : `${hintOf('删除节点', 'delete')} · 可撤销`}
                     onClick={() => removeNode(node.id)} icon={<Trash2 size={12} className="text-[var(--err)]" />} />
       </Header>
 
-      {/* 助手改图期间整块只读：这时候改的东西会被它的最终结果悄悄覆盖 */}
+      {/* 助手改图、正式运行期间整块只读：前者改的东西会被它的最终结果悄悄覆盖，后者跑的是
+          已发布的不可变版本 */}
       <fieldset disabled={locked} className="min-h-0 min-w-0 flex-1 overflow-y-auto p-3">
+        {lock && (
+          <div className="mb-3 flex items-start gap-1.5 rounded border px-2 py-1.5 text-2xs leading-snug"
+               role="note" style={{ borderColor: 'var(--border-strong)', background: 'var(--bg-hover)' }}>
+            <Lock size={11} className="mt-px shrink-0 text-dim" aria-hidden />
+            <span className="min-w-0 flex-1">
+              <span className="font-medium">只能看，不能改</span>
+              <span className="text-dim"> · {EDIT_LOCK_TEXT[lock]}</span>
+            </span>
+          </div>
+        )}
         <div className="mb-3 text-2xs leading-relaxed text-faint">{def.description}</div>
 
         {!!loose.length && (
@@ -182,8 +244,10 @@ function Header({ onBack, children }: { onBack: () => void; children?: React.Rea
   )
 }
 
-/** 一条问题。字段下面用行内版，面板顶部用带框的版本 */
-function IssueLine({ issue, boxed }: { issue: Pick<ValidationIssue, 'level' | 'message'>; boxed?: boolean }) {
+/** 一条问题。字段下面用行内版，面板顶部用带框的版本。action 是就地修好它的那个按钮 */
+function IssueLine({ issue, boxed, action }: {
+  issue: Pick<ValidationIssue, 'level' | 'message'>; boxed?: boolean; action?: React.ReactNode
+}) {
   const err = issue.level === 'error'
   const Icon = err ? XCircle : AlertTriangle
   return (
@@ -196,11 +260,30 @@ function IssueLine({ issue, boxed }: { issue: Pick<ValidationIssue, 'level' | 'm
       role={err ? 'alert' : undefined}
     >
       <Icon size={11} className="mt-px shrink-0" aria-hidden />
-      <span className="min-w-0 flex-1">{issue.message}</span>
+      {/* 修法放在话的下面：检查器只有三百来像素宽，并排的话这句要折成七八行 */}
+      <span className="min-w-0 flex-1">
+        {issue.message}
+        {action && <span className="mt-1 flex">{action}</span>}
+      </span>
     </div>
   )
 }
 
+/**
+ * 「提示词要求用 X，但没绑定」的就地修法：把 X 加进这一栏。返回新 config，已经绑了就是 null
+ * （按钮不出现）。修法和问题面板那一行的「绑定」是同一个 withToolBound
+ */
+function bindFix(issue: FieldIssue, config: Record<string, any>, apply: (next: Record<string, any>) => void) {
+  const tool = unboundToolOf(issue.message)
+  const next = tool ? withToolBound(config, issue.at, tool) : null
+  if (!tool || !next) return null
+  return (
+    <button type="button" className="btn btn-xs shrink-0" onClick={() => apply(next)}>
+      <Plus size={10} aria-hidden /> 绑定 {tool}
+    </button>
+  )
+}
+
 // -------------------------------------------------------------------------
 
 /**
@@ -268,7 +351,7 @@ function Field({ field, nodeId, value, config, issues, onChange }: {
       )}
       {!!own.length && (
         <div id={errorId} className="mt-1 space-y-0.5">
-          {own.map((i, k) => <IssueLine key={k} issue={i} />)}
+          {own.map((i, k) => <IssueLine key={k} issue={i} action={bindFix(i, config, (c) => onChange(c[field.key]))} />)}
         </div>
       )}
     </div>
@@ -282,6 +365,7 @@ function FieldInput({ field, id, nodeId, syntax, value, config, invalid, describ
 }) {
   const catalog = useCatalog()
   const defaults = useRunDefaults()
+  const toolOptions = useToolOptions()
   const aria = { 'aria-invalid': invalid || undefined, 'aria-describedby': describedBy }
 
   switch (field.type) {
@@ -401,9 +485,7 @@ function FieldInput({ field, id, nodeId, syntax, value, config, invalid, describ
       )
 
     case 'tools': {
-      const options = catalog.tools.map((t) => ({
-        value: t.id, label: t.name, hint: t.description, danger: t.dangerous, group: t.category,
-      }))
+      const options = toolOptions
       // tool 节点只选一个，agent 节点可以多选
       if (field.help?.includes('只能选一个')) {
         return (
@@ -437,7 +519,7 @@ function FieldInput({ field, id, nodeId, syntax, value, config, invalid, describ
       return <MetricList nodeId={nodeId} value={value ?? []} issues={issues} onChange={onChange} />
 
     case 'agents':
-      return <AgentList value={value ?? []} onChange={onChange} />
+      return <AgentList value={value ?? []} issues={issues} config={config} onChange={onChange} />
 
     default:
       return <input id={id} className="field" value={value ?? ''} onChange={(e) => onChange(e.target.value)} />
@@ -608,12 +690,14 @@ function MultiPick({ options, value, onChange, empty }: {
   )
 }
 
-function Row({ children, onRemove, removeLabel, tone }: {
+function Row({ children, onRemove, removeLabel, tone, item }: {
   children: React.ReactNode; onRemove: () => void; removeLabel: string
   tone?: 'error' | 'warning'
+  /** 第几项。问题面板定位时按 [data-field] [data-item] 滚到这一项 */
+  item?: number
 }) {
   return (
-    <div className="mb-1.5 rounded border bg-bg p-2"
+    <div className="mb-1.5 rounded border bg-bg p-2" data-item={item}
          style={tone ? { borderColor: tone === 'error' ? 'var(--err)' : 'var(--warn)' } : undefined}>
       <div className="flex items-start gap-1.5">
         <div className="min-w-0 flex-1 space-y-1.5">{children}</div>
@@ -653,7 +737,7 @@ function IoFieldList({ nodeId, value, issues, onChange }: {
       {value.map((field, i) => {
         const own = issues.filter((x) => x.at?.index === i)
         return (
-          <Row key={i} removeLabel={`删除字段 ${field.name || i + 1}`}
+          <Row key={i} item={i} removeLabel={`删除字段 ${field.name || i + 1}`}
                tone={own.some((x) => x.level === 'error') ? 'error' : own.length ? 'warning' : undefined}
                onRemove={() => onChange(value.filter((_, idx) => idx !== i))}>
             <Sub label="字段名" htmlFor={`${uid}-${i}-name`}>
@@ -775,7 +859,7 @@ function CaseList({ nodeId, mode, value, issues, onChange }: {
           : keyIssue || own.length ? 'warning' : undefined
         const condBad = own.some((x) => x.at?.sub === 'condition' && x.level === 'error')
         return (
-          <Row key={i} removeLabel={`删除分支 ${c.label || c.key || i + 1}`} tone={tone}
+          <Row key={i} item={i} removeLabel={`删除分支 ${c.label || c.key || i + 1}`} tone={tone}
                onRemove={() => onChange(value.filter((_, idx) => idx !== i))}>
             <div className="flex gap-1.5">
               <Sub label="标识（连线出口）" htmlFor={`${uid}-${i}-key`} className="w-[42%] shrink-0">
@@ -848,7 +932,7 @@ function MetricList({ nodeId, value, issues, onChange }: {
       {value.map((m, i) => {
         const own = issues.filter((x) => x.at?.index === i)
         return (
-          <Row key={i} removeLabel={`删除指标 ${m.id || i + 1}`}
+          <Row key={i} item={i} removeLabel={`删除指标 ${m.id || i + 1}`}
                tone={own.some((x) => x.level === 'error') ? 'error' : own.length ? 'warning' : undefined}
                onRemove={() => onChange(value.filter((_, idx) => idx !== i))}>
             <div className="flex gap-1.5">
@@ -886,45 +970,65 @@ function MetricList({ nodeId, value, issues, onChange }: {
   )
 }
 
-function AgentList({ value, onChange }: { value: any[]; onChange: (v: any[]) => void }) {
-  const catalog = useCatalog()
+/**
+ * 协作成员。成员自己的问题（提示词点名的工具没绑、角色设定写得不对）落在那个成员的那一栏下面：
+ * 以前它们既不在成员行里、也不在面板顶上，问题面板说有错，点过来却什么都看不见
+ */
+function AgentList({ value, issues, config, onChange }: {
+  value: any[]; issues: FieldIssue[]; config: Record<string, any>; onChange: (v: any[]) => void
+}) {
+  const options = useToolOptions()
   const uid = useId()
   const update = (i: number, patch: any) =>
     onChange(value.map((a, idx) => (idx === i ? { ...a, ...patch } : a)))
+  const fix = (x: FieldIssue) => bindFix(x, config, (c) => onChange(c.agents))
   return (
     <div>
-      {value.map((agent, i) => (
-        <Row key={i} removeLabel={`删除成员 ${agent.name || i + 1}`}
-             onRemove={() => onChange(value.filter((_, idx) => idx !== i))}>
-          <div className="flex gap-1.5">
-            <Sub label="成员名（英文）" htmlFor={`${uid}-${i}-name`} className="min-w-0 flex-1">
-              <input id={`${uid}-${i}-name`} className="field mono text-xs" placeholder="researcher"
-                     value={agent.name ?? ''} onChange={(e) => update(i, { name: e.target.value })} />
+      {value.map((agent, i) => {
+        const own = issues.filter((x) => x.at?.index === i)
+        const at = (sub: string) => own.filter((x) => x.at?.sub === sub)
+        const rest = own.filter((x) => x.at?.sub !== 'system' && x.at?.sub !== 'tools')
+        return (
+          <Row key={i} item={i} removeLabel={`删除成员 ${agent.name || i + 1}`}
+               tone={own.some((x) => x.level === 'error') ? 'error' : own.length ? 'warning' : undefined}
+               onRemove={() => onChange(value.filter((_, idx) => idx !== i))}>
+            <div className="flex gap-1.5">
+              <Sub label="成员名（英文）" htmlFor={`${uid}-${i}-name`} className="min-w-0 flex-1">
+                <input id={`${uid}-${i}-name`} className="field mono text-xs" placeholder="researcher"
+                       value={agent.name ?? ''} onChange={(e) => update(i, { name: e.target.value })} />
+              </Sub>
+              <Sub label="最多几步" htmlFor={`${uid}-${i}-steps`} className="w-20 shrink-0">
+                <input id={`${uid}-${i}-steps`} className="field tnum" type="number" min={1} max={30} placeholder="4"
+                       value={agent.max_steps ?? ''}
+                       onChange={(e) => update(i, { max_steps: e.target.value === '' ? undefined : Number(e.target.value) })} />
+              </Sub>
+            </div>
+            <Sub label="职责（调度者据此分派）" htmlFor={`${uid}-${i}-desc`}>
+              <input id={`${uid}-${i}-desc`} className="field" value={agent.description ?? ''}
+                     onChange={(e) => update(i, { description: e.target.value })} />
             </Sub>
-            <Sub label="最多几步" htmlFor={`${uid}-${i}-steps`} className="w-20 shrink-0">
-              <input id={`${uid}-${i}-steps`} className="field tnum" type="number" min={1} max={30} placeholder="4"
-                     value={agent.max_steps ?? ''}
-                     onChange={(e) => update(i, { max_steps: e.target.value === '' ? undefined : Number(e.target.value) })} />
-            </Sub>
-          </div>
-          <Sub label="职责（调度者据此分派）" htmlFor={`${uid}-${i}-desc`}>
-            <input id={`${uid}-${i}-desc`} className="field" value={agent.description ?? ''}
-                   onChange={(e) => update(i, { description: e.target.value })} />
-          </Sub>
-          {/* 成员的 system 后端直接取值、不过模板渲染：这里不挂补全，免得教人写 {{ }} */}
-          <Sub label="角色设定（system，原样发给模型）" htmlFor={`${uid}-${i}-sys`}>
-            <textarea id={`${uid}-${i}-sys`} className="field" rows={2}
-                      value={agent.system ?? ''} onChange={(e) => update(i, { system: e.target.value })} />
-          </Sub>
-          <div>
-            <div className="mb-0.5 text-2xs text-faint">可用工具</div>
-            <MultiPick
-              options={catalog.tools.map((t) => ({ value: t.id, label: t.name, hint: t.description, group: t.category }))}
-              value={agent.tools ?? []} onChange={(v) => update(i, { tools: v })} empty="没有可用工具"
-            />
-          </div>
-        </Row>
-      ))}
+            {/* 成员的 system 后端直接取值、不过模板渲染：这里不挂补全，免得教人写 {{ }} */}
+            <div data-sub="system">
+              <Sub label="角色设定（system，原样发给模型）" htmlFor={`${uid}-${i}-sys`}>
+                <textarea id={`${uid}-${i}-sys`} className="field" rows={2}
+                          value={agent.system ?? ''} onChange={(e) => update(i, { system: e.target.value })} />
+              </Sub>
+              {at('system').map((x, k) => <IssueLine key={k} issue={x} />)}
+            </div>
+            <div data-sub="tools">
+              <div className="mb-0.5 text-2xs text-faint">可用工具</div>
+              <MultiPick options={options} value={agent.tools ?? []} onChange={(v) => update(i, { tools: v })}
+                         empty="没有可用工具" />
+              {!!at('tools').length && (
+                <div className="mt-1 space-y-0.5">
+                  {at('tools').map((x, k) => <IssueLine key={k} issue={x} action={fix(x)} />)}
+                </div>
+              )}
+            </div>
+            {rest.map((x, k) => <IssueLine key={k} issue={x} />)}
+          </Row>
+        )
+      })}
       <button type="button" className="btn btn-sm w-full justify-center"
               onClick={() => onChange([...value, { name: '', description: '', system: '', tools: [] }])}>
         <Plus size={11} /> 添加成员
diff --git a/frontend/src/canvas/InspectorSheet.tsx b/frontend/src/canvas/InspectorSheet.tsx
index 18efbb28..db70c9d0 100644
--- a/frontend/src/canvas/InspectorSheet.tsx
+++ b/frontend/src/canvas/InspectorSheet.tsx
@@ -1,6 +1,7 @@
 import { useEffect } from 'react'
 import { ChevronLeft } from 'lucide-react'
 import clsx from 'clsx'
+import { create } from 'zustand'
 import { useStudio } from '../store/studio'
 import { StatusBadge } from '../components/ui'
 import { formatClock } from '../lib/format'
@@ -10,6 +11,45 @@ import { useRunGlance } from '../run/RunHud'
 import { isActivePhase } from '../run/trace'
 import { Inspector } from './Inspector'
 
+type StudioSnapshot = ReturnType<typeof useStudio.getState>
+
+/**
+ * 属性面板此刻为哪个节点开着。选中节点不再一律等于打开：看运行时点了跑过的节点，
+ * 右栏要留给那个节点的步骤（runfx-11），面板等人明确要了才盖上来。
+ */
+export const useSheet = create<{ open: string | null }>(() => ({ open: null }))
+
+/**
+ * 点这个节点是不是应该先看它的步骤：在看运行（进行中，或者在回放），而它这次
+ * 跑过——没跑过的节点在右栏里没有步骤可看，那就照常打开属性面板
+ */
+export function stepsFirst(id: string, s: StudioSnapshot = useStudio.getState()): boolean {
+  if (!isActivePhase(s.runPhase) && s.replayAt == null) return false
+  const n = s.trace.nodes[id]
+  return !!n && (n.count > 0 || n.state !== 'idle')
+}
+
+/** 明确要看配置（双击节点、画布上的「…的配置」）：运行中也打开 */
+export function openInspector(id: string): void {
+  // 先记下再选中：选中触发的订阅看到它已经点名要开，就不再按「先看步骤」收回去
+  useSheet.setState({ open: id })
+  useStudio.getState().select(id)
+}
+
+// 选中 → 面板开不开。放在模块级：选中可能来自别处（问题面板定位、发布弹窗、快捷键），
+// 规则只写这一份
+useStudio.subscribe((s, prev) => {
+  if (s.selectedId === prev.selectedId) return
+  const id = s.selectedId
+  const cur = useSheet.getState().open
+  if (!id) {
+    if (cur) useSheet.setState({ open: null })
+    return
+  }
+  if (cur === id) return
+  useSheet.setState({ open: stepsFirst(id, s) ? null : id })
+})
+
 /**
  * 属性面板：盖在助手栏上的一层，不是和它并列的 tab。
  *
@@ -19,10 +59,12 @@ import { Inspector } from './Inspector'
  *
  * 改成"盖上去"之后：助手一直在下面活着，属性是临时造访者，关掉就回到原处。
  * 选中节点即滑入，Esc 或点画布空白处即滑出——不需要专门去找一个 tab。
+ * 例外是看运行时点了跑过的节点：那时要看的是它的步骤，面板不自动盖上来（见 useSheet）。
  */
 export function InspectorSheet() {
   const selectedId = useStudio((s) => s.selectedId)
   const select = useStudio((s) => s.select)
+  const open = useSheet((s) => s.open)
 
   // Esc 关闭。这是"覆盖层"这种东西的通用约定，没有它就只能去找那个 ×
   useEffect(() => {
@@ -39,12 +81,12 @@ export function InspectorSheet() {
     return () => window.removeEventListener('keydown', onKey)
   }, [selectedId, select])
 
-  if (!selectedId) return null
+  if (!selectedId || open !== selectedId) return null
 
   return (
     // key 带上 selectedId：换一个节点时重播一次滑入，让人知道内容换了。
     // 不重播的话，点另一个节点看起来像什么都没发生
-    <div key={selectedId}
+    <div key={selectedId} data-inspector-sheet
          className="sheet-in absolute inset-0 z-20 flex flex-col overflow-hidden bg-panel"
          style={{ boxShadow: '-10px 0 28px -14px rgba(0,0,0,.5)' }}>
       <div className="min-h-0 flex-1">
diff --git a/frontend/src/canvas/NodeCard.tsx b/frontend/src/canvas/NodeCard.tsx
index 7bd52f30..654ef42c 100644
--- a/frontend/src/canvas/NodeCard.tsx
+++ b/frontend/src/canvas/NodeCard.tsx
@@ -8,16 +8,21 @@ import { Sparkles, Wrench } from 'lucide-react'
 import clsx from 'clsx'
 import { NODE_DEFS, sourceHandles } from './nodeDefs'
 import { NODE_WIDTH } from './routing'
-import { LiveClock, stillClock, TeamMatrix, teamBrief } from './TeamMatrix'
+import { LiveClock, stillClock, TeamMatrix, teamBrief, type TeamEnding } from './TeamMatrix'
 import { edgeKey, topology } from '../run/derive'
 import { api } from '../api/client'
-import { isComposing, StatusBadge } from '../components/ui'
+import { isComposing, StatusBadge, toast } from '../components/ui'
+import { explainRunError } from '../lib/explain'
 import { formatClock, formatDuration, formatNumber, formatTokens, NONE } from '../lib/format'
 import { statusMeta } from '../lib/status'
 import { issuanceLabel, RUN_CLASS_LABEL } from '../lib/terms'
 import { ApprovalCard } from '../run/RunPanel'
 import type { NodeState, NodeTrace } from '../run/trace'
-import { loopSince, loopSpan, openSince, useNodeView, type NodeView } from '../run/useNodeView'
+import { useRunClock } from '../run/useRunClock'
+import {
+  execStart, lastIn, loopSince, loopSpan, openCall, openSince, repairsOf, useNodeFacts, useNodeView, within,
+  type NodeFacts, type NodeUsage, type NodeView, type ToolSpan,
+} from '../run/useNodeView'
 import { useCatalog } from '../store/catalog'
 import { configSig, useStudio, type FlowNode } from '../store/studio'
 import type { Approval, NodeType, RunEvent, ValidationIssue } from '../types'
@@ -96,15 +101,21 @@ function issueKey(issues: ValidationIssue[], id: string): string {
  * 出具判定挂在哪个成果节点上、什么时候落下的（毫秒，和航迹同一条时间轴，回放时
  * 游标没走到这一刻就不盖章）。按事件数组缓存：一张图里通常只有一两个成果节点在问
  */
-const issuanceCache = new WeakMap<RunEvent[], { id: string | null; at: number | null }>()
-function issuanceOf(events: RunEvent[]): { id: string | null; at: number | null } {
+interface IssuanceAt {
+  id: string | null
+  at: number | null
+  /** 事件原样的 data：运行还没结束时 run.output 里还没有 _issuance，悬停说明从这里取 */
+  data?: Record<string, any>
+}
+const issuanceCache = new WeakMap<RunEvent[], IssuanceAt>()
+function issuanceOf(events: RunEvent[]): IssuanceAt {
   const hit = issuanceCache.get(events)
   if (hit) return hit
-  let found = { id: null as string | null, at: null as number | null }
+  let found: IssuanceAt = { id: null, at: null }
   for (let i = events.length - 1; i >= 0; i -= 1) {
     const e = events[i]
     if (e.type === 'issuance') {
-      found = { id: e.node_id ?? null, at: typeof e.ts === 'number' ? e.ts * 1000 : null }
+      found = { id: e.node_id ?? null, at: typeof e.ts === 'number' ? e.ts * 1000 : null, data: e.data ?? undefined }
       break
     }
   }
@@ -112,6 +123,55 @@ function issuanceOf(events: RunEvent[]): { id: string | null; at: number | null
   return found
 }
 
+/** 点印章够不够得着出具横幅：横幅或右栏（助手面板）看得见就行，右栏在对话层时会自己切过去 */
+function issuanceReachable(): boolean {
+  return ['[data-issuance-banner]', '[data-assistant-panel]'].some((sel) => {
+    const el = document.querySelector<HTMLElement>(sel)
+    return !!el && el.offsetWidth > 0 && getComputedStyle(el).visibility === 'visible'
+  })
+}
+
+/**
+ * 印章 → 右栏运行视图里的出具横幅。和「去审批」同一个约定：先广播，右栏在对话层时
+ * 自己切过去；接手了就 preventDefault。没人接手时这里等几帧找横幅滚过去，还是找不到
+ * 就说一声，不让印章像是点坏了
+ */
+function gotoIssuance(runId: string | undefined): void {
+  const handled = !window.dispatchEvent(new CustomEvent('agentlab:goto-issuance', {
+    detail: { runId }, cancelable: true,
+  }))
+  if (handled) return
+  let tries = 0
+  const find = () => {
+    const banner = document.querySelector<HTMLElement>('[data-issuance-banner]')
+    if (banner && banner.offsetWidth > 0 && getComputedStyle(banner).visibility === 'visible') {
+      const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches
+      banner.scrollIntoView({ behavior: reduced ? 'auto' : 'smooth', block: 'center' })
+      return
+    }
+    if (tries++ < 12) requestAnimationFrame(find)
+    else toast.info('右栏收起来了：展开助手栏，在运行视图的成果区看完整判定', { key: 'card:issuance' })
+  }
+  requestAnimationFrame(find)
+}
+
+/**
+ * 回指上了哪些数字、各按哪个口径核的：「12.4% → 毛利率（月度口径 @ v2）」。
+ * 口径带版本，同一个指标换过口径时一眼看得出这次按的是哪一版。悬停里只放前几条
+ */
+function matchedLines(matched: unknown): string {
+  if (!Array.isArray(matched) || !matched.length) return ''
+  const lines = matched.slice(0, 5).map((m: any) => {
+    const token = String(m?.token ?? '').trim()
+    const metric = String(m?.metric ?? '').trim()
+    const caliber = typeof m?.caliber === 'string' && m.caliber.trim() ? `（${m.caliber.trim()}）` : ''
+    return token ? `  ${token}${metric ? ` → ${metric}` : ''}${caliber}` : ''
+  }).filter(Boolean)
+  if (!lines.length) return ''
+  const more = matched.length > lines.length ? `\n  …另有 ${matched.length - lines.length} 个` : ''
+  return `回指明细：\n${lines.join('\n')}${more}`
+}
+
 /**
  * 每个节点有几路上游（不算循环的回边）。排队中的节点据此说清在等什么：
  * 汇合点是「等其余上游」，单入口的只是轮到它之前那一拍。按拓扑缓存
@@ -149,9 +209,42 @@ function takenAt(n: NodeTrace | undefined, at: number): string | undefined {
   return handle
 }
 
+/**
+ * 失败摘要。「模型没真调工具」「团队用完轮数」「修复想凑数」「提示词点名的工具没绑」
+ * 这几类是图本身有缺口，后端的原话很长、槽里只截得下半句：换成 lib/explain 的短标题，
+ * 原因和下一步放悬停。别的失败照原话的第一句——它们本来就是写给人看的，
+ * 再归一次类会把「工艺员 30 秒没有回应」这种具体的话抹成「等待超时」
+ */
+function failureOf(error: string): { note: string; title: string } {
+  if (!error) return { note: '没有给出原因', title: '' }
+  const ex = explainRunError(error)
+  if (ex.continuable || ex.fix !== 'canvas') return { note: firstSentence(error), title: error }
+  return {
+    note: ex.title,
+    title: [ex.title, ex.reason, ex.action ? `怎么办：${ex.action}` : ''].filter(Boolean).join('\n'),
+  }
+}
+
+/** 协作团队是不是因为轮数用完而失败的（后端的报错首句「协作团队用完 N 轮仍未完成」） */
+const EXHAUSTED_ERROR = /用完\s*\d+\s*轮(?:仍|还)?未完成/
+
+/**
+ * 「协作团队用完 N 轮仍未完成：<理由>。一次都没被派到的成员：A、B。…」里的轮数、理由
+ * 和没派到的人。判失败的报错和降档的那条日志是同一个开头；产出里的 never_dispatched
+ * 进事件时被缩成了「[1 项]」，成员名只能从这句话里认。只认这一次执行的那句话——
+ * 右栏泳道那份结局是整次运行攒下来的，接着跑成功之后还留着上一次的
+ */
+function exhaustedText(text: string): { rounds?: number; reason?: string; never: string[] } | undefined {
+  const m = text.match(/用完\s*(\d+)\s*轮(?:仍|还)?未完成[：:]\s*([\s\S]*?)(?:。一次都没被派到的成员|。先看成员|。按降档交付|$)/)
+  if (!m) return undefined
+  const never = text.match(/一次都没被派到的成员[：:]\s*([^。]+)/)?.[1]
+    .split('、').map((s) => s.trim()).filter(Boolean) ?? []
+  return { rounds: Number(m[1]) || undefined, reason: m[2].trim() || undefined, never }
+}
+
 /** 完成之后的产出量：模型出了多少 token、查到几行、取回几条 */
-function outputOf(n: NodeTrace | undefined, preview: any): string {
-  if (n && n.tokensOut > 0) return formatTokens(n.tokensOut, { compact: true })
+function outputOf(u: NodeUsage, preview: any): string {
+  if (u.tokensOut > 0) return formatTokens(u.tokensOut, { compact: true })
   if (Array.isArray(preview)) return `${formatNumber(preview.length)} 条`
   if (preview && typeof preview === 'object') {
     if (typeof preview.row_count === 'number') return `${formatNumber(preview.row_count)} 行`
@@ -172,6 +265,8 @@ interface Reading {
   /** 主读数之后的补充：理由、错误摘要、产出量 */
   note?: ReactNode
   noteTitle?: string
+  /** 跑完了但有要留意的事（降档交付、收尾时还想调工具）：note 用琥珀色 */
+  noteWarn?: boolean
   /** 靠右的一组小读数：token、工具 */
   side?: ReactNode
 }
@@ -185,6 +280,12 @@ interface ReadingInput {
   timed: boolean
   /** 上游有几路：排队时说清在等什么 */
   fanIn: number
+  facts?: NodeFacts
+  /** 卡片在说的那一次执行的起点（execStart）：事件里捞的事只算这之后的 */
+  since: number
+  /** 这一次执行的报错 */
+  error: string
+  ending?: TeamEnding
 }
 
 /**
@@ -229,10 +330,104 @@ function LoopProgress({ n, iteration = 0, config, phase }: {
   )
 }
 
-function readingOf({ state, view, type, config, skewMs, timed, fanIn }: ReadingInput): Reading {
+/**
+ * 在跑的那次工具调用。后端声明了时限（tool.start.timeout_s）的，超出之后直说
+ * 「已超出 30s 上限」，不再写一个看不出等了多久的「⋯」。没超出时照常安静
+ */
+function ToolTag({ call, at, skewMs }: { call: ToolSpan; at: number | null; skewMs: number }) {
+  // 老事件没有时间戳时起点是 0，算不出等了多久，就不判超没超
+  if (!call.limitS || !call.start) return <ToolName tool={call.tool} />
+  if (at != null) return <ToolTagText call={call} elapsed={at - call.start} />
+  return <LiveToolTag call={call} skewMs={skewMs} />
+}
+
+function LiveToolTag({ call, skewMs }: { call: ToolSpan; skewMs: number }) {
+  const now = useRunClock(true)
+  return <ToolTagText call={call} elapsed={now - skewMs - call.start} />
+}
+
+/**
+ * 超出之后槽里只放得下一件事：说超时，不再写工具名（扳手已经说了是工具，名字在悬停里）。
+ * db_query__shop 这种名字加上「已超出 30s 上限」，比卡片还宽
+ */
+function ToolTagText({ call, elapsed }: { call: ToolSpan; elapsed: number }) {
+  if (elapsed <= call.limitS! * 1000) return <ToolName tool={call.tool} />
+  return <span className="nc-over">已超出 {call.limitS}s 上限</span>
+}
+
+/** 在跑的工具名：名字长时截掉，省略号前后都留着「⋯」这个在跑的记号 */
+const ToolName = ({ tool }: { tool: string }) => <><span className="nc-tool-name">{tool}</span> ⋯</>
+
+/** 工具明细（放悬停）：谁调的（成员首字）、调了什么、成没成、有没有超时 */
+function toolLines(calls: { tool: string; agent?: string; ok?: boolean; timedOut?: boolean; limitS?: number }[]): string {
+  return calls.slice(-8).map((c) => `${c.agent ? `[${c.agent.slice(0, 1)}] ` : ''}${c.tool} ${
+    c.timedOut ? `⏱ 超时${c.limitS ? `（上限 ${c.limitS}s）` : ''}`
+      : c.ok === false ? '✗ 失败' : c.ok ? '✓' : `⋯ 进行中${c.limitS ? `（上限 ${c.limitS}s）` : ''}`}`).join('\n')
+}
+
+/**
+ * 跑完之后那半句：平常是产出量；有要留意的事时换成那件事——降档交付、
+ * 收尾时还想调工具、纠正过工具调用、校验靠修复才过。正常态安静，只在这些时候上琥珀色。
+ * 只看这一次执行（since 之后）：上一轮循环、接着跑之前的事不挂到这一次的结果上
+ */
+function doneNote(type: NodeType, u: NodeUsage, preview: any, facts: NodeFacts | undefined,
+                  ending: TeamEnding | undefined, at: number | null, since: number, maxRounds: number,
+): Pick<Reading, 'note' | 'noteTitle' | 'noteWarn'> {
+  if (ending?.exhausted === 'degrade') {
+    const rounds = ending.rounds ?? (maxRounds || '全部')
+    return {
+      note: `用完 ${rounds} 轮未完成 · 降档交付`,
+      noteTitle: [
+        `协作团队用完 ${rounds} 轮，调度者始终没有判定完成`,
+        ending.reason ? `理由：${ending.reason}` : '',
+        '按降档交付：成果是成员最后的原话，不是调度者认可的结论。下游的复核、出具会跟着降档',
+      ].filter(Boolean).join('\n'),
+      noteWarn: true,
+    }
+  }
+  const marks = within(facts?.markups, at, since)
+  const settle = marks.filter((m) => m.settle).pop()
+  if (settle) {
+    return {
+      note: '收尾时仍想调用工具',
+      noteTitle: `${settle.message}\n步数用完之后模型还在要工具：交出来的是它前面写的内容，可能不完整`,
+      noteWarn: true,
+    }
+  }
+  // 写成文字、被提醒之后重答了：成果是重答的那一次，不是不完整。复核仍按降档算，所以还是琥珀。
+  // 协作成员提醒之后还这样的，这一步记失败（矩阵里那一格是红的），不能说成重答了
+  const fails = type === 'supervisor' ? within(facts?.memberErrors, at, since) : []
+  const nudged = marks.filter((m) => !m.settle && !fails.some((f) => f.at >= m.at && m.message.startsWith(f.agent)))
+  if (nudged.length) {
+    return {
+      note: nudged.length > 1 ? `纠正过 ${nudged.length} 次工具调用` : '纠正过一次工具调用',
+      noteTitle: [
+        ...nudged.slice(-3).map((m) => m.message),
+        `${type === 'supervisor' ? '成员' : '模型'}把工具调用写成了文字，提醒之后重答了，成果是重答的那一次；复核按降档算`,
+      ].join('\n'),
+      noteWarn: true,
+    }
+  }
+  const repairs = type === 'validate' ? repairsOf(facts, at, since) : 0
+  if (repairs) {
+    // 有一次修复想拿原文没有的值凑数、被作废了：最后虽然过了，复核照样按降档算
+    const invented = lastIn(facts?.inventions, at, since)
+    return {
+      note: `修复 ${repairs} 次后通过`,
+      noteTitle: invented
+        ? `第一次没过校验。其中一次修复出现了原文没有的值，已作废：${invented.message}\n最后通过的那次只调整了格式，复核按降档算`
+        : '第一次没过校验，模型只调整了格式，没有补数据',
+      noteWarn: !!invented,
+    }
+  }
+  return { note: outputOf(u, preview) }
+}
+
+function readingOf({ state, view, type, config, skewMs, timed, fanIn, facts, since, error, ending }: ReadingInput): Reading {
   const n = view.trace
   const runtime = view.runtime
   const at = view.at
+  const u = view.usage
   // 回放时计时是定值：游标减去那一段的起点。实时的交给 LiveClock 自己走
   const clock = (from: number | undefined, coarse = false): ReactNode => {
     if (at != null) return stillClock(from != null ? at - from : undefined)
@@ -241,42 +436,49 @@ function readingOf({ state, view, type, config, skewMs, timed, fanIn }: ReadingI
   const loop = (phase: 'live' | 'done' | 'stopped') => (
     <LoopProgress n={n} iteration={view.iteration} config={config} phase={phase} />
   )
-  const tokens = (n?.tokensIn ?? 0) + (n?.tokensOut ?? 0)
-  const failedTools = (runtime?.toolCalls ?? []).filter((c) => c.ok === false).length
-  const runningTool = n?.toolsRunning
-    ? [...(runtime?.toolCalls ?? [])].reverse().find((c) => c.ok === undefined)?.tool
+  const tokens = u.tokensIn + u.tokensOut
+  // 工具调用：事件里捞出来的那份带起止和时限，回放能按游标截；没有时退回 runtime。
+  // 只数这一次执行的：上一轮失败的调用不能让这一轮的扳手变红
+  const calls = facts
+    ? facts.calls.filter((c) => c.start >= since && (at == null || c.start <= at))
+      .map((c) => (at != null && c.end != null && c.end > at ? { ...c, ok: undefined, timedOut: false } : c))
+    : runtime?.toolCalls ?? []
+  const failedTools = calls.filter((c) => c.ok === false).length
+  const open = u.toolsRunning ? openCall(facts, at, since) : undefined
+  const runningTool = u.toolsRunning
+    ? open?.tool ?? [...(runtime?.toolCalls ?? [])].reverse().find((c) => c.ok === undefined)?.tool
     : undefined
-  // 工具明细放悬停：谁调的（成员首字）、调了什么、成没成
-  const toolTitle = (runtime?.toolCalls ?? []).slice(-8).map((c) =>
-    `${c.agent ? `[${c.agent.slice(0, 1)}] ` : ''}${c.tool} ${c.ok === false ? '✗ 失败' : c.ok ? '✓' : '⋯ 进行中'}`).join('\n')
+  const toolTitle = toolLines(calls)
   const side = (
     <>
       {tokens > 0 && (
-        <span className="tnum" title={`输入 ${formatNumber(n?.tokensIn)} · 输出 ${formatNumber(n?.tokensOut)} tokens`}>
+        <span className="tnum" title={`输入 ${formatNumber(u.tokensIn)} · 输出 ${formatNumber(u.tokensOut)} tokens`}>
           {formatTokens(tokens, { compact: true })}
         </span>
       )}
-      {!!n?.tools && (
+      {!!u.tools && (
         <span
           className={clsx('nc-tools tnum', runningTool && 'is-live', failedTools && 'is-bad')}
           title={toolTitle}
         >
           <Wrench size={9} aria-hidden />
-          {runningTool ? `${runningTool} ⋯` : n.tools}
+          {open ? <ToolTag call={open} at={at} skewMs={skewMs} /> : runningTool ? <ToolName tool={runningTool} /> : u.tools}
         </span>
       )}
     </>
   )
 
-  // 航迹里的 token、工具是整次运行的累计，回放到半路时它们还没发生：不拿终值冒充那一刻
-  const final = at == null || view.count === (n?.count ?? 0)
+  // 预览（查到几行、取回几条）只有最后一次执行的：回放到更早的一次执行时不拿它冒充那一刻。
+  // token、工具次数不受这个限制，投影给的就是那一刻的读数
+  const lastExec = at == null || view.count === (n?.count ?? 0)
+  const preview = lastExec ? runtime?.preview : undefined
 
   switch (state) {
     case 'running':
       if (type === 'loop') {
         return { main: loop('live'), side: clock(loopSince(n, at), true) }
       }
-      return { main: clock(openSince(n, 'run', at)), side: at == null ? side : undefined }
+      return { main: clock(openSince(n, 'run', at)), side }
     case 'waiting':
       return { main: <>已等 {clock(openSince(n, 'wait', at), true)}</> }
     case 'done':
@@ -285,23 +487,23 @@ function readingOf({ state, view, type, config, skewMs, timed, fanIn }: ReadingI
       }
       return {
         main: formatDuration(at != null ? view.replayElapsedMs : n?.lastDurationMs ?? runtime?.durationMs),
-        note: final ? outputOf(n, runtime?.preview) : '',
+        ...doneNote(type, u, preview, facts, ending, at, since, Number(config.max_rounds) || 0),
         // 跑完了只留工具次数：token 已经在产出量里说过（输出多少），再挂一个总数是两套数
-        side: n?.tools && final ? (
+        side: u.tools ? (
           <span className={clsx('nc-tools tnum', failedTools && 'is-bad')} title={toolTitle}>
-            <Wrench size={9} aria-hidden />{n.tools}
+            <Wrench size={9} aria-hidden />{u.tools}
           </span>
         ) : undefined,
       }
     case 'failed': {
-      const error = n?.error || runtime?.error || ''
+      const why = failureOf(error)
       if (type === 'loop') {
-        return { main: loop('stopped'), note: firstSentence(error), noteTitle: error }
+        return { main: loop('stopped'), note: error ? why.note : '', noteTitle: why.title }
       }
       return {
         main: formatDuration(n?.lastDurationMs ?? runtime?.durationMs),
-        note: firstSentence(error) || '没有给出原因',
-        noteTitle: error,
+        note: why.note,
+        noteTitle: why.title,
       }
     }
     case 'queued':
@@ -484,6 +686,7 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
   const def = NODE_DEFS[data.nodeType]
   const type = data.nodeType
   const view = useNodeView(id)
+  const facts = useNodeFacts(id)
   const { state, runtime, trace: nt } = view
 
   const runActive = useStudio((s) => s.runPhase !== 'idle')
@@ -504,7 +707,8 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
     (type === 'output' && issuanceOf(s.events).id === id ? s.trace.issuance : undefined))
   const issuedAt = useStudio((s) => (type === 'output' ? issuanceOf(s.events).at : null))
   const issuanceDetail = useStudio((s) =>
-    (type === 'output' ? (s.run?.output as any)?._issuance as Record<string, any> | undefined : undefined))
+    (type === 'output' ? (s.run?.output as any)?._issuance as Record<string, any> | undefined
+      ?? (issuanceOf(s.events).id === id ? issuanceOf(s.events).data : undefined) : undefined))
   // 只有排队中的卡片要知道自己有几路上游，别的卡片不必为改图重跑这一趟
   const fanIn = useStudio((s) => (state === 'queued' ? fanInOf(s.nodes, s.edges)[id] ?? 0 : 0))
 
@@ -563,7 +767,53 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
   const streamText = executing && !view.replay ? (runtime?.tokens || runtime?.thinking || '') : ''
   const thinkingOnly = !!streamText && !runtime?.tokens
 
-  const reading = readingOf({ state, view, type, config: data.config, skewMs, timed, fanIn })
+  // 这张卡在说哪一次执行：循环的下一轮、失败后接着跑都是新的一次，事件里捞的事只算
+  // 这一次的。不截的话，调大轮数接着跑成功了，表头还挂着上一次的「判定未完成」
+  const since = execStart(nt, view.at, facts)
+  const lastExec = view.at == null || view.count === (nt?.count ?? 0)
+  // 报错：航迹、runtime 上的是最后一次执行的；回放到更早的一次失败时取那一次的原话
+  const failure = view.at != null ? lastIn(facts?.failures, view.at, since) : undefined
+  const error = failure?.message || (lastExec ? nt?.error || runtime?.error || '' : '')
+  const preview = lastExec ? runtime?.preview : undefined
+
+  // 协作团队怎么收场：收尾判定、用完轮数之后是失败还是降档。卡片和矩阵说同一件事
+  const verdictMark = type === 'supervisor' ? lastIn(facts?.closings, view.at, since) : undefined
+  // 判定开始了、结论还没到（回放时按游标：那一刻结论还没出来也算在判）
+  const verdictOpen = !!verdictMark && (verdictMark.end == null || (view.at != null && verdictMark.end > view.at))
+  const exhaustedLog = type === 'supervisor' ? lastIn(facts?.exhausts, view.at, since) : undefined
+  const failedOut = type === 'supervisor' && state === 'failed' && EXHAUSTED_ERROR.test(error)
+  const degraded = type === 'supervisor' && state === 'done' && (preview?.exhausted === true || !!exhaustedLog)
+  const told = failedOut ? exhaustedText(error) : degraded && exhaustedLog ? exhaustedText(exhaustedLog.message) : undefined
+  const exhaustedReason = typeof preview?.exhausted_reason === 'string' ? preview.exhausted_reason : told?.reason ?? ''
+  // 产出进事件时数组会被缩成「[1 项]」，是数组才用；否则用报错、日志原话里认出来的
+  const neverSig = failedOut || degraded
+    ? (Array.isArray(preview?.never_dispatched) ? preview.never_dispatched.map(String) : told?.never ?? []).join('\u0000')
+    : ''
+  const exhaustedRounds = told?.rounds
+  const ending = useMemo<TeamEnding | undefined>(() => {
+    if (!verdictMark && !failedOut && !degraded) return undefined
+    const verdict = verdictMark && {
+      at: verdictMark.at,
+      done: !verdictOpen && verdictMark.done,
+      reason: verdictOpen ? '' : verdictMark.reason,
+      open: verdictOpen,
+    }
+    return {
+      verdict,
+      exhausted: failedOut ? 'fail' : degraded ? 'degrade' : undefined,
+      reason: verdict?.reason || exhaustedReason,
+      never: neverSig ? neverSig.split('\u0000') : undefined,
+      rounds: exhaustedRounds,
+    }
+  }, [verdictMark, verdictOpen, failedOut, degraded, exhaustedReason, neverSig, exhaustedRounds])
+  // 成员失败的原因也只要这一次执行的
+  const memberErrors = useMemo(() => {
+    const out: Record<string, string> = {}
+    for (const f of within(facts?.memberErrors, view.at, since)) out[f.agent] = f.error
+    return out
+  }, [facts?.memberErrors, view.at, since])
+
+  const reading = readingOf({ state, view, type, config: data.config, skewMs, timed, fanIn, facts, since, error, ending })
 
   // 编辑态（没有运行）槽里放校验问题，有运行时放遥测
   const [errCount, warnCount, firstIssue] = issues ? issues.split('\u0000') : ['0', '0', '']
@@ -581,7 +831,8 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
   // 模型名放悬停：槽里放不下 claude-sonnet-4-5 这么长的名字，也不是一眼要看的东西
   const teleTitle = !editing && nt ? [
     nt.model ? `模型 ${nt.model}` : '',
-    nt.tokensIn + nt.tokensOut > 0 ? `输入 ${formatNumber(nt.tokensIn)} · 输出 ${formatNumber(nt.tokensOut)} tokens` : '',
+    view.usage.tokensIn + view.usage.tokensOut > 0
+      ? `输入 ${formatNumber(view.usage.tokensIn)} · 输出 ${formatNumber(view.usage.tokensOut)} tokens` : '',
     retries > 0 ? `失败后重试了 ${retries} 次` : '',
   ].filter(Boolean).join('\n') || undefined : undefined
 
@@ -602,6 +853,7 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
       ? `无法回指的数字：${(detail?.unmatched_numbers ?? issuance?.unmatched).map((u: any) => u?.token ?? u).join('、')}`
       : issuance?.unmatchedCount ? `无法回指的数字 ${issuance.unmatchedCount} 个` : '',
     (detail?.missing_expected ?? []).length ? `缺数据声明：${detail!.missing_expected.join('、')} 本期缺失` : '',
+    matchedLines(detail?.matched),
     runClass === 'exploratory' ? '探索运行的结论不进正式归档' : '',
     '完整判定在右栏运行视图的成果区',
   ].filter(Boolean).join('\n') : ''
@@ -666,6 +918,9 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
           {retries > 0 && (
             <span className="nc-chip nc-chip-warn tnum" title={`失败后重试了 ${retries} 次`}>↻{retries}</span>
           )}
+          {ending?.exhausted === 'degrade' && (
+            <span className="nc-chip nc-chip-warn" title="轮数用完仍未完成，按降档交付">降档</span>
+          )}
           {(runActive || state !== 'idle') && (
             <StatusBadge status={state} size={14} animate={executing} className="nc-badge" />
           )}
@@ -682,6 +937,8 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
             maxRounds={Number(data.config.max_rounds) || 0}
             maxParallel={Number(data.config.max_parallel) || 0}
             skewMs={skewMs}
+            ending={ending}
+            memberErrors={memberErrors}
           />
         ) : (
           <div className={clsx('nc-body', streamText && 'is-stream')}>
@@ -711,7 +968,9 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
               <span className="nc-tele-state" style={{ color: meta.color }}>{meta.short}</span>
               {reading.main !== '' && <span className="nc-tele-main tnum">{reading.main}</span>}
               {reading.note && (
-                <span className="nc-tele-note" title={reading.noteTitle}>{reading.note}</span>
+                <span className={clsx('nc-tele-note', reading.noteWarn && 'is-warn')} title={reading.noteTitle}>
+                  {reading.note}
+                </span>
               )}
               <span className="flex-1" />
               {reading.side && <span className="nc-tele-side">{reading.side}</span>}
@@ -744,7 +1003,7 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
             这里不再写状态字，把位置让给计时、进度；没有读数的状态才写状态字 */}
         <div className="nc-lod-read tnum" style={{ color: state === 'idle' ? undefined : meta.color }}>
           {isTeam && state === 'running'
-            ? teamBrief(runtime?.team, nt, true, view.at)
+            ? teamBrief(runtime?.team, nt, true, view.at, ending?.verdict)
             : state === 'idle' ? (runActive ? NONE : '') : reading.main !== '' ? reading.main : meta.short}
         </div>
       </div>
@@ -774,21 +1033,20 @@ function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>
       )}
 
       {/* 出具印章：成果节点上，跟着 issuance 事件落下。它是一枚章不是按钮：
-          只有右栏的出具横幅在页面上时，点它才滚过去（悬停时看一眼，届时才有
-          手形光标）；没有横幅就是一张带悬停说明的图，不装作能点 */}
+          点它是去右栏看完整判定的捷径（悬停时看一眼够不够得着，届时才有手形光标），
+          够不着就是一张带悬停说明的图，不装作能点。右栏停在对话层时横幅不在页面上，
+          由右栏听 agentlab:goto-issuance 自己切到运行层 */}
       {tier && (
         <span
           role="img"
           aria-label={stampTitle}
           className={clsx('nc-stamp', tierClass, stampLive.current && 'nc-stamp-in', stampLink && 'is-link nodrag')}
           title={stampTitle}
-          onPointerEnter={() => setStampLink(!!document.querySelector('[data-issuance-banner]'))}
+          onPointerEnter={() => setStampLink(issuanceReachable())}
           onPointerDown={stampLink ? (e) => e.stopPropagation() : undefined}
           onClick={stampLink ? (e) => {
-            const banner = document.querySelector('[data-issuance-banner]')
-            if (!banner) return
             e.stopPropagation()
-            banner.scrollIntoView({ behavior: 'smooth', block: 'center' })
+            gotoIssuance(useStudio.getState().run?.id)
           } : undefined}
         >
           <StatusBadge status={tier === 'formal' ? 'done' : tier === 'withheld' ? 'failed' : 'waiting'} size={11} animate={false} decorative />
diff --git a/frontend/src/canvas/Palette.tsx b/frontend/src/canvas/Palette.tsx
index 5b29465e..2a3c2174 100644
--- a/frontend/src/canvas/Palette.tsx
+++ b/frontend/src/canvas/Palette.tsx
@@ -1,10 +1,10 @@
 import { useState } from 'react'
 import { createPortal } from 'react-dom'
-import { PanelLeftClose, PanelLeftOpen } from 'lucide-react'
+import { Lock, PanelLeftClose, PanelLeftOpen } from 'lucide-react'
 import clsx from 'clsx'
 import { NODE_CATEGORIES, NODE_DEFS, type NodeDef } from './nodeDefs'
 import { hintOf } from './shortcuts'
-import { useStudio } from '../store/studio'
+import { EDIT_LOCK_TEXT, useEditLock, useStudio } from '../store/studio'
 import { IconButton } from '../components/ui'
 import type { NodeType } from '../types'
 
@@ -25,9 +25,11 @@ const startDrag = (e: React.DragEvent, def: NodeDef) => {
 export function Palette({ collapsed, onToggle }: { collapsed: boolean; onToggle: () => void }) {
   const [query, setQuery] = useState('')
   const addNode = useStudio((s) => s.addNode)
-  const locked = useStudio((s) => s.copilot.active)
+  // 助手在改、正式运行在跑：点了、拖了都落不下来，整块置灰并说清为什么
+  const lock = useEditLock()
+  const locked = lock != null
 
-  if (collapsed) return <Rail onToggle={onToggle} onAdd={(t) => addNode(t)} locked={locked} />
+  if (collapsed) return <Rail onToggle={onToggle} onAdd={(t) => addNode(t)} lock={lock} />
 
   const q = query.trim().toLowerCase()
   const defs = Object.values(NODE_DEFS).filter(
@@ -98,10 +100,17 @@ export function Palette({ collapsed, onToggle }: { collapsed: boolean; onToggle:
           <div className="px-2 py-6 text-center text-2xs text-faint">没有匹配的节点</div>
         )}
       </div>
-      <div className="border-t px-3 py-2 text-2xs leading-relaxed text-faint">
-        拖到画布，或点击放在视野中间。<br />
-        从节点右侧圆点拖到另一个节点左侧即可连线。
-      </div>
+      {lock ? (
+        <div className="flex items-start gap-1.5 border-t px-3 py-2 text-2xs leading-relaxed text-dim" role="note">
+          <Lock size={11} className="mt-0.5 shrink-0" aria-hidden />
+          <span>{EDIT_LOCK_TEXT[lock]}</span>
+        </div>
+      ) : (
+        <div className="border-t px-3 py-2 text-2xs leading-relaxed text-faint">
+          拖到画布，或点击放在视野中间。<br />
+          从节点右侧圆点拖到另一个节点左侧即可连线。
+        </div>
+      )}
     </div>
   )
 }
@@ -125,22 +134,26 @@ function TypeIcon({ def, size = 20 }: { def: NodeDef; size?: number }) {
  * 收起后的图标轨。说明不用原生 title：原生提示要停一秒多才出来，而且只能一行灰字；
  * 这里悬停即浮出名字和一句话说明。浮层挂到 body 上，不被这一栏的滚动裁掉
  */
-function Rail({ onToggle, onAdd, locked }: {
-  onToggle: () => void; onAdd: (t: NodeType) => void; locked: boolean
+function Rail({ onToggle, onAdd, lock }: {
+  onToggle: () => void; onAdd: (t: NodeType) => void; lock: ReturnType<typeof useEditLock>
 }) {
+  const locked = lock != null
   const [tip, setTip] = useState<{ def: NodeDef; top: number; left: number } | null>(null)
   const show = (def: NodeDef, el: HTMLElement) => {
     const r = el.getBoundingClientRect()
     setTip({ def, top: r.top + r.height / 2, left: r.right + 8 })
   }
   return (
-    <div className="flex h-full flex-col items-center" aria-label="节点库（已收起）">
+    <div className="flex h-full flex-col items-center" aria-label="节点库（已收起）"
+         title={lock ? EDIT_LOCK_TEXT[lock] : undefined}>
       <div className="flex w-full justify-center border-b py-2">
         <IconButton label="展开节点库" title={hintOf('展开节点库', 'palette')} onClick={onToggle}
                     icon={<PanelLeftOpen size={13} />} />
       </div>
+      {/* 置灰的图标轨接不到悬停，也就没有说明可看：原因挂在外面那一层的 title 上 */}
       <div className={clsx('flex w-full flex-1 flex-col items-center gap-0.5 overflow-y-auto py-1.5',
         locked && 'pointer-events-none opacity-50')}
+           aria-disabled={locked || undefined}
            onMouseLeave={() => setTip(null)}>
         {NODE_CATEGORIES.map((category, ci) => (
           <div key={category} className="flex w-full flex-col items-center gap-0.5">
diff --git a/frontend/src/canvas/ProblemsPanel.tsx b/frontend/src/canvas/ProblemsPanel.tsx
index fc157f3e..c612012f 100644
--- a/frontend/src/canvas/ProblemsPanel.tsx
+++ b/frontend/src/canvas/ProblemsPanel.tsx
@@ -1,11 +1,11 @@
 import { useEffect, useRef } from 'react'
-import { AlertTriangle, CheckCircle2, CornerDownRight, RotateCw, Trash2, Unlink, Workflow, XCircle } from 'lucide-react'
+import { AlertTriangle, CheckCircle2, CornerDownRight, Plus, RotateCw, Trash2, Unlink, Workflow, XCircle } from 'lucide-react'
 import clsx from 'clsx'
 import { NODE_DEFS } from './nodeDefs'
-import type { FieldRef, Problem } from './issues'
+import { unboundToolOf, withToolBound, type FieldRef, type Problem } from './issues'
 import { formatShortcut } from '../lib/keys'
 import { useCatalog } from '../store/catalog'
-import { useStudio } from '../store/studio'
+import { useEditLock, useStudio } from '../store/studio'
 import { Spinner } from '../components/ui'
 
 /**
@@ -129,10 +129,15 @@ function ProblemRow({ problem: p, active, onLocate, onDeleteEdge }: {
   problem: Problem; active: boolean; onLocate: () => void; onDeleteEdge: (id: string) => void
 }) {
   const node = useStudio((s) => (p.nodeId ? s.nodes.find((n) => n.id === p.nodeId) : undefined))
+  const updateNode = useStudio((s) => s.updateNode)
+  const locked = useEditLock() != null
   const err = p.level === 'error'
   const Icon = err ? XCircle : AlertTriangle
-  const where = fieldLabel(p.field, node?.data.nodeType)
+  const where = fieldLabel(p.field, node?.data.nodeType, node?.data.config)
   const locatable = p.scope === 'node' && !!node
+  // 提示词点了名的工具没绑：就地绑上，和检查器里那个按钮是同一个修法
+  const tool = unboundToolOf(p.message)
+  const bound = node && tool ? withToolBound(node.data.config ?? {}, p.field, tool) : null
   return (
     <div role="listitem" data-problem={p.id}
          className={clsx('group flex items-start gap-2 pl-6 pr-2', active && 'bg-hover')}>
@@ -153,6 +158,13 @@ function ProblemRow({ problem: p, active, onLocate, onDeleteEdge }: {
           </span>
         )}
       </button>
+      {bound && tool && (
+        <button type="button" className="btn btn-xs my-0.5 shrink-0" disabled={locked}
+                title={`把 ${tool} 加进${where || '这个节点的工具'}`}
+                onClick={() => updateNode(node!.id, { config: bound })}>
+          <Plus size={10} aria-hidden /> 绑定 {tool}
+        </button>
+      )}
       {/* 悬空边（指向不存在的节点）：React Flow 不画它，画布上看不见、点不到，只能在这儿删 */}
       {p.scope === 'edge' && p.edgeId && (
         <button type="button" className="btn btn-xs my-0.5 shrink-0" onClick={() => onDeleteEdge(p.edgeId!)}>
@@ -163,13 +175,18 @@ function ProblemRow({ problem: p, active, onLocate, onDeleteEdge }: {
   )
 }
 
-function fieldLabel(field: FieldRef | null | undefined, type?: string): string {
+const SUB_LABEL: Record<string, string> = { condition: '的条件', key: '的标识', tools: '的工具', system: '的角色设定' }
+
+function fieldLabel(field: FieldRef | null | undefined, type?: string, config?: Record<string, any>): string {
   if (!field) return ''
   if (field.key === 'label') return '节点名称'
   const def = type ? NODE_DEFS[type as keyof typeof NODE_DEFS] : undefined
   const base = def?.fields.find((f) => f.key === field.key)?.label ?? field.key
   if (field.index == null) return base
+  const sub = (field.sub && SUB_LABEL[field.sub]) || ''
+  // 成员有名字就叫名字：「第 2 个成员」还得数，「成员 writer」一眼就知道是谁
+  const name = field.key === 'agents' ? config?.agents?.[field.index]?.name : undefined
+  if (name) return `成员「${name}」${sub}`
   const item = ({ cases: '分支', fields: '字段', metrics: '指标', agents: '成员' } as Record<string, string>)[field.key]
-  const sub = field.sub === 'condition' ? '的条件' : field.sub === 'key' ? '的标识' : ''
   return item ? `第 ${field.index + 1} 个${item}${sub}` : `${base} · 第 ${field.index + 1} 项`
 }
diff --git a/frontend/src/canvas/PublishDialog.tsx b/frontend/src/canvas/PublishDialog.tsx
index cdf3b54e..b82ac871 100644
--- a/frontend/src/canvas/PublishDialog.tsx
+++ b/frontend/src/canvas/PublishDialog.tsx
@@ -31,8 +31,7 @@ const readActor = () => {
  * 门禁拦下的问题一条一行、前置节点名，点一下关掉弹窗、定位到那个节点。
  */
 export function PublishDialog({ workflow, onClose, onDone, onLocate }: {
-  // published_by 后端已经给了，types.ts 还没跟上
-  workflow: Workflow & { published_by?: string | null }
+  workflow: Workflow
   onClose: () => void
   onDone: () => void
   onLocate: (nodeId: string) => void
diff --git a/frontend/src/canvas/RunTimeline.tsx b/frontend/src/canvas/RunTimeline.tsx
index 9087ceb0..fba1c7ad 100644
--- a/frontend/src/canvas/RunTimeline.tsx
+++ b/frontend/src/canvas/RunTimeline.tsx
@@ -7,8 +7,8 @@ import { formatClock, formatDuration, formatTokens, NONE } from '../lib/format'
 import { statusMeta } from '../lib/status'
 import { topology, type GraphLike } from '../run/derive'
 import {
-  isActivePhase, isTerminal, liveAt, project, type NodeState, type NodeTrace, type Projection, type Segment,
-  type Trace,
+  isActivePhase, isTerminal, lastEventAt, liveAt, project, type NodeState, type NodeTrace, type Projection,
+  type Segment, type Trace,
 } from '../run/trace'
 import { projectCached } from '../run/useNodeView'
 import { useRunClock } from '../run/useRunClock'
@@ -277,8 +277,11 @@ function measuredOf(n: NodeTrace | undefined, at: number): number | undefined {
   return runs.length === 1 && runs[0].end != null && runs[0].end <= at ? n.lastDurationMs : undefined
 }
 
-/** 一条泳道右侧的摘要：执行了几次、一共多久、等了多久、用了多少 token */
-function summarize(n: NodeTrace | undefined, state: NodeState, at: number): string {
+/**
+ * 一条泳道右侧的摘要：执行了几次、一共多久、等了多久、用了多少 token。
+ * tokens 回放时是游标那一刻的读数（投影给的），实时是累计
+ */
+function summarize(n: NodeTrace | undefined, state: NodeState, at: number, tokens?: number): string {
   if (!n || state === 'idle' || state === 'queued') return state === 'queued' ? '排队' : NONE
   if (state === 'blocked') return '阻断'
   if (state === 'unreached') return '未到达'
@@ -296,7 +299,7 @@ function summarize(n: NodeTrace | undefined, state: NodeState, at: number): stri
   const measured = measuredOf(n, at)
   if (run > 0 || state === 'done') parts.push(formatDuration(measured ?? (run || n.lastDurationMs)))
   if (wait > 0) parts.push(`等 ${formatClock(wait).replace(/\.\d$/, '')}`)
-  const tok = n.tokensIn + n.tokensOut
+  const tok = tokens ?? n.tokensIn + n.tokensOut
   if (tok > 0 && parts.length < 3) parts.push(formatTokens(tok, { compact: true }))
   return parts.join(' · ') || NONE
 }
@@ -312,13 +315,15 @@ function buildRows(trace: Trace, graph: TimelineGraph, at: number, labels: Map<s
   for (const id of ids) {
     const n = trace.nodes[id]
     // 回放时状态取游标那一刻的投影：摘要和泳道底色要和画布上的卡片一致
-    const state: NodeState = states ? states[id]?.state ?? 'idle' : n?.state ?? 'idle'
+    const p = states?.[id]
+    const state: NodeState = states ? p?.state ?? 'idle' : n?.state ?? 'idle'
     const type = nodeTypeOf(byId.get(id))
     const label = labels.get(id) ?? id
     rows.push({
       key: id, kind: 'node', nodeId: id, label, type,
       segs: (n?.segments ?? []).filter((s) => s.kind === 'run' || s.kind === 'wait' || s.kind === 'retry'),
-      state, count: n?.count ?? 0, summary: summarize(n, state, at), measuredMs: measuredOf(n, at),
+      state, count: n?.count ?? 0, measuredMs: measuredOf(n, at),
+      summary: summarize(n, state, at, states ? (p?.tokensIn ?? 0) + (p?.tokensOut ?? 0) : undefined),
       note: state === 'blocked' ? (failedLabel ? `阻断：上游「${failedLabel}」失败` : '阻断：上游失败')
         : state === 'unreached' ? '未到达' : undefined,
       name: label, top, height: ROW_H,
@@ -381,11 +386,11 @@ export function lastStampOf(trace: Trace, stamps: number[] = stampsOf(trace)): n
 
 /**
  * 停下的运行此刻的样子。project 在「不早于最后一条事件」时读节点的当前状态（含推导出的
- * 阻断、未到达）和后端给的权威时长，早于它就按段重建、这两样都丢了。最后一条事件的时刻
- * 只记在内部簿记里，所以有 endedAt 时取一个一定不早于它的时刻；结束时刻照样按 endedAt 算
+ * 阻断、未到达）和后端给的权威时长，早于它就按段重建、这两样都丢了。所以按最后一条事件
+ * 的时刻投影；结束时刻照样按 endedAt 算
  */
 export function projectSettled(trace: Trace): Projection {
-  return project(trace, trace.endedAt != null ? Number.MAX_SAFE_INTEGER : lastStampOf(trace))
+  return project(trace, lastEventAt(trace))
 }
 
 /**
diff --git a/frontend/src/canvas/TeamMatrix.tsx b/frontend/src/canvas/TeamMatrix.tsx
index df276989..27dfd359 100644
--- a/frontend/src/canvas/TeamMatrix.tsx
+++ b/frontend/src/canvas/TeamMatrix.tsx
@@ -3,6 +3,7 @@ import clsx from 'clsx'
 import { StatusBadge } from '../components/ui'
 import { formatClock, formatDuration, NONE } from '../lib/format'
 import { statusMeta } from '../lib/status'
+import type { TeamMemberEx } from '../run/decode'
 import type { NodeTrace, Segment } from '../run/trace'
 import { useRunClock } from '../run/useRunClock'
 import type { TeamMember, TeamRound, TeamRun } from '../types'
@@ -63,6 +64,27 @@ interface Roster {
   description?: string
 }
 
+/**
+ * 轮数用完之后怎么收场。后端在最后一轮交回之后还会让调度者只判定、不派活地
+ * 看一次（agent.route.* 带 closing）：它说完成了就正常交付；没说完成，节点按
+ * 「用完轮数时」的配置失败或降档交付。这一次判定不是新的一轮，矩阵不给它加列
+ */
+export interface TeamEnding {
+  /**
+   * 收尾判定。open = 调度者还在判；at 是开始判定的时刻（agent.route.start），
+   * 矩阵据此认出哪一段调度是这次判定。老后端没有这一步
+   */
+  verdict?: { done: boolean; reason: string; open: boolean; at?: number }
+  /** 用完轮数仍未完成：fail 节点失败，degrade 降档交付（成果是成员最后的原话） */
+  exhausted?: 'fail' | 'degrade'
+  /** 调度者最后给的理由：收尾判定的，没有就取报错或产出里的 */
+  reason?: string
+  /** 后端点名的「一次都没被派到」的成员（报错原话、产出的 never_dispatched） */
+  never?: string[]
+  /** 报错、日志原话里的「用完 N 轮」：配置里的最多轮数可能在运行之后改过 */
+  rounds?: number
+}
+
 interface Props {
   roster: Roster[]
   /** 还没跑过就没有：这时矩阵就是花名册 */
@@ -79,6 +101,18 @@ interface Props {
   maxParallel?: number
   /** 服务端时钟偏差，实时计时要扣掉 */
   skewMs?: number
+  ending?: TeamEnding
+  /** 成员失败的原因（agent.step.end 的 error），按名字 */
+  memberErrors?: Record<string, string>
+}
+
+/**
+ * 真正派过活的轮次。调度者的理由按轮记，收尾判定那一次（round = 上限）也会记下
+ * 一条只有理由、没有成员的「轮」——它不是一轮协作，不能让表头写成「第 5 轮 / 上限 4」
+ */
+function worked(team: TeamRun | undefined): TeamRun | undefined {
+  if (!team || team.rounds.every((r) => r.members.length)) return team
+  return { ...team, rounds: team.rounds.filter((r) => r.members.length) }
 }
 
 /** 当前该看哪一轮：有在跑的就看那一轮，否则看最后一轮 */
@@ -88,6 +122,24 @@ function currentRound(team: TeamRun | undefined) {
   return running.length ? running[running.length - 1] : team.rounds[team.rounds.length - 1]
 }
 
+/**
+ * 这一段调度是不是轮数用完后的收尾判定。认事件（agent.route.* 带 closing，卡片折成
+ * verdict）：不拿轮次和配置里的「最多轮数」比——没配时后端按缺省值跑，运行之后还可能
+ * 改过（调大了再接着跑、回放历史运行），那样比出来的是错的。收尾判定是这一次执行里
+ * 最后一段调度，它开始之后的那段就是它
+ */
+const isClosing = (seg: Segment | undefined, verdict: TeamEnding['verdict']): boolean =>
+  !!seg && !!verdict && (verdict.at == null || seg.start >= verdict.at)
+
+/** 收尾判定的一句话。reason 太长的放悬停，表头只放得下结论 */
+export function verdictText(v: TeamEnding['verdict'], full = false): string {
+  if (!v) return ''
+  if (v.open) return '轮数用完 · 调度者在判定'
+  if (v.done) return full ? '轮数用完 · 调度者判定：已完成' : '轮数用完 · 判定已完成'
+  const why = v.reason.trim()
+  return full ? `轮数用完 · 调度者判定：未完成${why ? `（${why}）` : ''}` : '轮数用完 · 判定未完成'
+}
+
 /**
  * 这一轮是几个人并行：按派出去的人数，不按此刻还有几个在跑。三人并行的一轮
  * 交回两个之后仍是并行的一轮，说成「串行推进」就和底部的「并行省下」打架了。
@@ -156,15 +208,16 @@ export function teamAt(team: TeamRun | undefined, trace: NodeTrace | undefined,
  * 「2/3 在跑 · 第 2 轮」「调度中 · 第 2 轮」「共 3 轮 · 并行省下 28.4 s」
  * 进行中的把此刻的读数放前面：精简档缩到 0.4 倍以下时这一句放不全，截掉的该是轮次
  */
-export function teamBrief(team: TeamRun | undefined, trace: NodeTrace | undefined, live: boolean, at?: number | null): string {
-  team = teamAt(team, trace, at)
+export function teamBrief(team: TeamRun | undefined, trace: NodeTrace | undefined, live: boolean, at?: number | null,
+                          verdict?: TeamEnding['verdict']): string {
+  team = worked(teamAt(team, trace, at))
   const round = currentRound(team)
   const dispatch = lastSeg(trace, 'dispatch', undefined, at)
   const thinking = live && dispatch && dispatch.end == null
   if (!team?.rounds.length) return thinking ? '调度中' : live ? '进行中' : NONE
   const no = `第 ${(round?.round ?? 0) + 1} 轮`
   if (live) {
-    if (thinking) return `调度中 · ${no}`
+    if (thinking) return isClosing(dispatch, verdict) ? '轮数用完 · 收尾判定中' : `调度中 · ${no}`
     const running = round?.members.filter((m) => m.status === 'running').length ?? 0
     const size = round?.members.length ?? 0
     if (running) return `${running}/${size} 在跑 · ${no}`
@@ -192,8 +245,10 @@ function memberText(m: TeamMember | undefined, status = m?.status): string {
   return statusMeta(status).short
 }
 
-function TeamMatrixImpl({ roster, team: final, trace, live, replay, at, maxRounds, maxParallel, skewMs = 0 }: Props) {
-  const team = teamAt(final, trace, at)
+function TeamMatrixImpl({
+  roster, team: final, trace, live, replay, at, maxRounds, maxParallel, skewMs = 0, ending, memberErrors,
+}: Props) {
+  const team = worked(teamAt(final, trace, at))
   const round = currentRound(team)
   // 事件里出现过、但花名册里没有的名字也要显示。配置被人改过、或者调度者报了
   // 一个不存在的成员时，这里至少能看出"确实派过这么个人"
@@ -224,8 +279,16 @@ function TeamMatrixImpl({ roster, team: final, trace, live, replay, at, maxRound
       status,
       roundNo,
       hint: roster.find((r) => r.name === name)?.description,
+      // 原因按轮记在 reduceTeam 给的那一格上；老数据没有就用事件里捞到的最后一次
+      error: status === 'failed' ? (member as TeamMemberEx | undefined)?.error || memberErrors?.[name] : undefined,
     }
   })
+  // 轮数用完还没完成时，一次都没被派到的人要点出来：负责定稿的那个常常就在里面，
+  // 写「—」看着像它还没轮到，其实是整次协作都没用上它
+  const undone = !!ending?.exhausted || (!!ending?.verdict && !ending.verdict.open && !ending.verdict.done)
+  const never = undone && !live ? new Set(rows.filter((r) => !r.member).map((r) => r.name)) : null
+  // 悬停里的名单再并上后端点的名：花名册在运行之后被改过时，矩阵里可能已经没有那一行
+  const neverNamed = never ? [...new Set([...never, ...(ending?.never ?? [])])] : []
 
   // 条形按同一批数归一化，长短才可比
   const busiest = Math.max(1, ...rows.map((r) => (r.active ? r.member?.ms ?? 0 : 0)))
@@ -236,43 +299,66 @@ function TeamMatrixImpl({ roster, team: final, trace, live, replay, at, maxRound
   const dispatch = lastSeg(trace, 'dispatch', undefined, at)
   const thinking = live && !!dispatch && dispatch.end == null
   const decided = dispatch?.end != null ? dispatch.end - dispatch.start : undefined
+  const verdict = ending?.verdict
+  const closing = isClosing(dispatch, verdict)
   const dispatchRound = team?.rounds.find((r) => r.round === (dispatch?.iteration ?? 0) - 1)
   const dispatchNote = dispatch && !thinking
-    ? dispatchRound?.members.length ? `派 ${dispatchRound.members.length} 人` : '收尾'
+    ? closing ? '收尾判定' : dispatchRound?.members.length ? `派 ${dispatchRound.members.length} 人` : '收尾'
     : ''
+  // 用完了几轮：以报错、日志原话为准，配置里的数可能在运行之后改过
+  const usedUp = ending?.rounds ?? (maxRounds || team?.rounds.length)
 
   const width = widthOf(round)
   let headRight = ''
+  /** 表头右边这句的语气：用完轮数没完成时失败是红、降档是琥珀，别的安静 */
+  let headTone: 'err' | 'warn' | '' = ''
   if (!team) headRight = maxParallel ? `并发上限 ${maxParallel}` : ''
   else if (live) {
-    headRight = thinking ? '调度中'
+    headRight = thinking ? closing ? verdictText({ done: false, reason: '', open: true }) : '调度中'
       : width > 1 ? runningNow ? `本轮 ${width} 人并行 · ${runningNow} 人在跑` : `本轮 ${width} 人已交回`
         : runningNow ? '串行推进' : '等调度者'
+  } else if (ending?.exhausted) {
+    headRight = `用完 ${usedUp} 轮 · 未完成`
+    headTone = ending.exhausted === 'fail' ? 'err' : 'warn'
+  } else if (verdict && !verdict.open) {
+    headRight = verdictText(verdict)
+    headTone = verdict.done ? '' : 'warn'
   } else {
     headRight = unsettledNote(rows.filter((r) => r.active && r.member)
       .map((r) => ({ ...r.member!, status: r.status! })))
       || (width > 1 ? `${width} 人并行完成` : team.finished ? '已收尾' : '')
   }
+  const reason = ending?.reason || verdict?.reason || ''
+  const headTitle = ending?.exhausted || verdict
+    ? [
+        verdict ? verdictText(verdict, true) : `协作团队用完 ${usedUp} 轮仍未完成`,
+        ending?.exhausted === 'degrade' ? '按降档交付：成果是成员最后的原话，不是调度者认可的结论' : '',
+        ending?.exhausted === 'fail' ? '节点判为失败。可以调大「最多轮数」，或把「用完轮数时」改成降档交付' : '',
+        reason && !(verdict && !verdict.done && !verdict.open) ? `理由：${reason}` : '',
+        neverNamed.length ? `一次都没被派到：${neverNamed.join('、')}` : '',
+      ].filter(Boolean).join('\n')
+    : undefined
   // 省下多少只算整轮交齐的；有并行过但没交齐（失败、取消）的不能说成"全程串行"
   const serialOnly = !!team?.finished && !team.rounds.some((r) => widthOf(r) > 1)
 
   return (
     <div className={clsx('team-matrix', live && 'is-live')}>
-      <div className="team-head">
+      <div className="team-head" title={headTitle}>
         <span className="tnum">
           {team?.rounds.length
             ? `第 ${(round?.round ?? 0) + 1} 轮${maxRounds ? ` / 上限 ${maxRounds}` : ''}`
             : `花名册${maxRounds ? ` · 上限 ${maxRounds} 轮` : ''}`}
         </span>
         <span className="team-head-rule" />
-        <span>{headRight}</span>
+        <span className={clsx('team-head-right', headTone && `is-${headTone}`)}>{headRight}</span>
       </div>
 
       <div
         className={clsx('team-row team-row-dispatch', thinking && 'team-row-running', !dispatch && 'team-row-idle')}
         title={[
           '调度者：决定下一轮派谁、几个人同时做',
-          round?.reason ? `理由：${round.reason}` : '',
+          closing && verdict ? verdictText(verdict, true)
+            : round?.reason ? `理由：${round.reason}` : '',
           dispatch?.estimated ? '耗时由事件间隔推算' : '',
         ].filter(Boolean).join('\n')}
       >
@@ -283,19 +369,20 @@ function TeamMatrixImpl({ roster, team: final, trace, live, replay, at, maxRound
         </span>
         <span className="team-ms tnum">
           {thinking ? (
-            ticking ? <>思考 <LiveClock from={dispatch!.start} skewMs={skewMs} coarse /></>
-              : at != null ? `思考 ${stillClock(at - dispatch!.start)}` : '思考中'
+            ticking ? <>{closing ? '判定' : '思考'} <LiveClock from={dispatch!.start} skewMs={skewMs} coarse /></>
+              : at != null ? `${closing ? '判定' : '思考'} ${stillClock(at - dispatch!.start)}` : '思考中'
           ) : decided != null ? (
             `${dispatch?.estimated ? '≈' : ''}${formatDuration(decided)}${dispatchNote ? ` · ${dispatchNote}` : ''}`
           ) : NONE}
         </span>
       </div>
 
-      {rows.map(({ name, active, member, status, roundNo, hint }) => {
+      {rows.map(({ name, active, member, status, roundNo, hint, error }) => {
         const running = status === 'running'
         const done = status === 'done'
         const failed = status === 'failed'
         const open = running ? lastSeg(trace, 'member', name, at) : undefined
+        const unused = !!never?.has(name)
         return (
           <div
             key={name}
@@ -305,14 +392,17 @@ function TeamMatrixImpl({ roster, team: final, trace, live, replay, at, maxRound
               done && 'team-row-done',
               failed && 'team-row-failed',
               active && 'team-row-active',
-              !member && 'team-row-idle',
+              !member && !unused && 'team-row-idle',
+              unused && 'team-row-never',
               member && !active && 'team-row-past',
             )}
-            data-member-status={status ?? 'idle'}
+            data-member-status={unused ? 'never' : status ?? 'idle'}
             title={[
               hint,
               running && member?.instruction ? `在做：${member.instruction}` : '',
               member ? `第 ${roundNo + 1} 轮 · ${memberText(member, status)}` : '',
+              failed && error ? `原因：${error}` : '',
+              unused ? `用完 ${usedUp} 轮，一次都没被派到` : '',
             ].filter(Boolean).join('\n') || name}
           >
             <StatusBadge status={status ?? 'idle'} size={9} decorative />
@@ -332,7 +422,7 @@ function TeamMatrixImpl({ roster, team: final, trace, live, replay, at, maxRound
               {running && open && open.end == null && ticking
                 ? <LiveClock from={open.start} skewMs={skewMs} coarse />
                 : running && open && at != null ? stillClock(at - open.start)
-                : memberText(member, status)}
+                : unused ? '未派到' : memberText(member, status)}
             </span>
           </div>
         )
diff --git a/frontend/src/canvas/VersionsSheet.tsx b/frontend/src/canvas/VersionsSheet.tsx
index ca9175b8..883a9f3b 100644
--- a/frontend/src/canvas/VersionsSheet.tsx
+++ b/frontend/src/canvas/VersionsSheet.tsx
@@ -2,7 +2,9 @@ import { useEffect, useMemo, useState } from 'react'
 import { ChevronLeft, History, RotateCcw, ShieldCheck } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../api/client'
-import { diffGraphs, toFlow, useStudio, type FlowNode, type GraphDiff } from '../store/studio'
+import {
+  EDIT_LOCK_TEXT, diffGraphs, toFlow, useEditLock, useStudio, type EditLock, type FlowNode, type GraphDiff,
+} from '../store/studio'
 import { ErrorState, Skeleton, toast } from '../components/ui'
 import { formatDateTime, formatTime } from '../lib/format'
 import { WORKFLOW_STATUS_LABEL } from '../lib/terms'
@@ -29,7 +31,8 @@ export function VersionsSheet({ workflow, onClose }: { workflow: Workflow; onClo
   const nodes = useStudio((s) => s.nodes)
   const edges = useStudio((s) => s.edges)
   const dirty = useStudio((s) => s.dirty)
-  const locked = useStudio((s) => s.copilot.active)
+  // 助手在改、正式运行在跑：恢复旧版也是改图，一样拦下
+  const lock = useEditLock()
   const restoreVersion = useStudio((s) => s.restoreVersion)
   const undo = useStudio((s) => s.undo)
 
@@ -135,7 +138,7 @@ export function VersionsSheet({ workflow, onClose }: { workflow: Workflow; onClo
                           : 'error' in detail ? <ErrorState error={detail.error} compact />
                           : target && diff && (
                             <VersionPreview version={v.version} target={target} diff={diff}
-                                            locked={locked} onRestore={restore} />
+                                            lock={lock} onRestore={restore} />
                           )}
                       </div>
                     )}
@@ -153,9 +156,9 @@ export function VersionsSheet({ workflow, onClose }: { workflow: Workflow; onClo
   )
 }
 
-function VersionPreview({ version, target, diff, locked, onRestore }: {
+function VersionPreview({ version, target, diff, lock, onRestore }: {
   version: number; target: { nodes: FlowNode[]; edges: Edge[] }; diff: GraphDiff
-  locked: boolean; onRestore: () => void
+  lock: EditLock; onRestore: () => void
 }) {
   const current = useStudio((s) => s.nodes)
   const same = diff.total === 0
@@ -192,8 +195,8 @@ function VersionPreview({ version, target, diff, locked, onRestore }: {
           </ul>
         </>
       )}
-      <button type="button" className="btn btn-sm mt-2 w-full justify-center" disabled={same || locked}
-              title={locked ? '助手正在改这张工作流，等它做完' : undefined} onClick={onRestore}>
+      <button type="button" className="btn btn-sm mt-2 w-full justify-center" disabled={same || lock != null}
+              title={lock ? EDIT_LOCK_TEXT[lock] : undefined} onClick={onRestore}>
         <RotateCcw size={11} /> 恢复 v{version} 到画布
       </button>
     </div>
diff --git a/frontend/src/canvas/copilotMerge.ts b/frontend/src/canvas/copilotMerge.ts
new file mode 100644
index 00000000..24428965
--- /dev/null
+++ b/frontend/src/canvas/copilotMerge.ts
@@ -0,0 +1,150 @@
+/**
+ * 助手的 update_node 怎么落到节点上，以及改完之后工具绑定变了什么。
+ *
+ * 规则和后端 app/api/copilot.py 的 merge_node_config / tool_changes 一字不差：
+ * 流式期间画布按这里逐条落，收尾时 final.graph 是后端按同一套规则合好的整张图。
+ * 两边口径一不一样，画布就会在 final 到来那一下跳一次——更糟的是以前前端整体替换
+ * config，流到一半断掉时，画布上的半成品里 agent 的工具已经没了。
+ *
+ * 以前是整体替换：模型只想改一句提示词，也得把整份 config 抄一遍，漏抄的字段就没了。
+ * 真出过事——改写提示词时漏了 tools，要查库的 agent 全丢了工具，最后把一堆工具调用
+ * 的原始标记当答案交了出去。
+ *
+ * 纯函数，不依赖 React 和 store，检查脚本能直接 import。
+ */
+import type { ToolChange } from '../types'
+
+type Config = Record<string, any>
+
+/** 成员条目里写 remove: true 表示删掉这个成员 */
+const REMOVE_MEMBER = 'remove'
+
+const isObject = (v: unknown): v is Config => !!v && typeof v === 'object' && !Array.isArray(v)
+
+// 和 engine/nodes/multi.py 的叫法一致：没起名字的成员按位置叫 agentN
+const memberKey = (member: Config, index: number): string => String(member.name || `agent${index}`)
+
+/** 按字段合并：写了的覆盖，写 null 的删掉，没写的原样保留。返回新对象 */
+function mergeFields(old: Config, patch: Config): Config {
+  const out: Config = { ...old }
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === null) delete out[key]
+    else if (value !== undefined) out[key] = value
+  }
+  return out
+}
+
+/** 协作成员按 name 合并。原有成员保持原来的次序，新名字接在后面 */
+function mergeMembers(old: unknown[], patch: unknown[]): unknown[] {
+  const merged = [...old]
+  const where = new Map<string, number>()
+  merged.forEach((m, i) => { if (isObject(m)) where.set(memberKey(m, i), i) })
+  const dropped = new Set<number>()
+  patch.forEach((entry, i) => {
+    if (!isObject(entry)) return
+    const key = memberKey(entry, i)
+    const at = where.get(key)
+    if (entry[REMOVE_MEMBER] === true) {
+      if (at != null) dropped.add(at)
+      return
+    }
+    const { [REMOVE_MEMBER]: _flag, ...fields } = entry
+    if (at != null) {
+      merged[at] = mergeFields(merged[at] as Config, fields)
+    } else {
+      where.set(key, merged.length)
+      merged.push(Object.fromEntries(Object.entries(fields).filter(([, v]) => v != null)))
+    }
+  })
+  return merged.filter((_, i) => !dropped.has(i))
+}
+
+/**
+ * update_node 的 config 落到节点上：
+ * 1. 顶层按字段浅合并。写 null 删键；没写的保留；args、output_schema 这类嵌套对象整个换掉。
+ * 2. 只有 supervisor 的 agents 是列表时，成员按 name（没名字按 agentN）合并；
+ *    成员自己的字段同样浅合并（没写 tools 的保留原来的 tools）。
+ * 3. {name, remove: true} 删掉那个成员；不认识的名字接在后面，写 null 的字段不留。
+ */
+export function mergeNodeConfig(nodeType: string, old: Config, patch: Config): Config {
+  let next = patch
+  if (nodeType === 'supervisor' && Array.isArray(patch.agents)) {
+    const members = Array.isArray(old.agents) ? old.agents : []
+    next = { ...patch, agents: mergeMembers(members, patch.agents) }
+  }
+  return mergeFields(old, next)
+}
+
+// -------------------------------------------------------------------------
+// 工具绑定变化
+// -------------------------------------------------------------------------
+
+/** GraphSpec 的节点和画布上的 FlowNode 都认：FlowNode 的 type 是 'card'，真类型在 data.nodeType */
+interface NodeLike {
+  id: string
+  type?: string
+  data?: { nodeType?: string; label?: string; config?: Config }
+}
+
+const toolNames = (value: unknown): string[] =>
+  Array.isArray(value) ? value.filter((t): t is string => typeof t === 'string' && !!t) : []
+
+interface Binding { nodeId: string; member: string | null; label: string; field: string; tools: string[] }
+
+/** (节点 id, 成员名) → 绑定的工具。成员名为 null 的是 agent 节点本身 */
+function bindings(nodes: NodeLike[]): Map<string, Binding> {
+  const out = new Map<string, Binding>()
+  for (const node of nodes) {
+    const type = node.data?.nodeType ?? node.type
+    const cfg = node.data?.config ?? {}
+    const label = node.data?.label || node.id
+    if (type === 'agent') {
+      out.set(JSON.stringify([node.id, null]),
+        { nodeId: node.id, member: null, label, field: 'tools', tools: toolNames(cfg.tools) })
+    } else if (type === 'supervisor' && Array.isArray(cfg.agents)) {
+      cfg.agents.forEach((m: unknown, i: number) => {
+        if (!isObject(m)) return
+        const member = memberKey(m, i)
+        out.set(JSON.stringify([node.id, member]),
+          { nodeId: node.id, member, label, field: `agents[${i}].tools`, tools: toolNames(m.tools) })
+      })
+    }
+  }
+  return out
+}
+
+/**
+ * 改图前后都在、而绑定的工具不一样了的节点和成员，按改后的图排序。和后端 tool_changes
+ * 同一套口径：新加、删掉的节点不算，那是结构变化，回执本来就会列出来。
+ * 老后端的 final 不带 tool_changes 时用它自己比。
+ */
+export function toolChangesOf(before: NodeLike[], after: NodeLike[]): ToolChange[] {
+  const old = bindings(before)
+  const out: ToolChange[] = []
+  for (const [key, now] of bindings(after)) {
+    const was = old.get(key)
+    if (!was) continue
+    const a = new Set(was.tools)
+    const b = new Set(now.tools)
+    if (a.size === b.size && [...a].every((t) => b.has(t))) continue
+    out.push({
+      node_id: now.nodeId, label: now.label, member: now.member, field: now.field,
+      before: was.tools, after: now.tools,
+      added: now.tools.filter((t) => !a.has(t)),
+      removed: was.tools.filter((t) => !b.has(t)),
+    })
+  }
+  return out
+}
+
+/** 工具集合变小了的那几条。换一个工具（数量没少）是正常改图，不算 */
+export function shrunkTools(changes: ToolChange[]): ToolChange[] {
+  return changes.filter((c) => c.removed.length > 0 && new Set(c.after).size < new Set(c.before).size)
+}
+
+/** 回执里的一行：「数据查询」：db_query__shop、db_schema__shop → 空 */
+export function describeToolChange(c: ToolChange): string {
+  const who = c.member ? `「${c.label}」的成员「${c.member}」` : `「${c.label}」`
+  const list = (xs: string[]) => (xs.length ? xs.join('、') : '空')
+  return `${who}：${list(c.before)} → ${list(c.after)}`
+}
diff --git a/frontend/src/canvas/issues.ts b/frontend/src/canvas/issues.ts
index 76da57db..b46b7cc2 100644
--- a/frontend/src/canvas/issues.ts
+++ b/frontend/src/canvas/issues.ts
@@ -1,12 +1,14 @@
 /**
  * 校验问题 → 能定位的东西：哪一类（图级 / 节点 / 边）、哪个节点、节点里的哪个字段。
  *
- * 后端的 ValidationIssue 只带 node_id / edge_id，不带字段。可检查器要把消息落到具体
- * 输入框下面——「分支「协作」的条件写错了」只挂在面板顶上，人还得自己去找是第几个
- * case。这里按两条线索补上字段：
+ * 检查器要把消息落到具体输入框下面——「分支「协作」的条件写错了」只挂在面板顶上，人还得
+ * 自己去找是第几个 case。后端给了 field 就用它；老后端不给时按两条线索补上：
  *   1. 消息里带 {{ path }} 的（变量问题），去节点配置里找写着这个引用的字段；
  *   2. 其余按后端 schema.py 里那几句固定说法认（「跳过条件」「分支「X」的条件」……）。
- * 认不出来的就不认，留在面板顶部，不猜。后端哪天给了 field，优先用它。
+ * 认不出来的就不认，留在面板顶部，不猜。
+ *
+ * 例外是「提示词要求用 X，但没绑定」：后端的 field 指着点名的那句提示词，可修法在工具
+ * 那一栏，定位落到工具上（见 toolBindingOf）。
  */
 import type { FlowNode } from '../store/studio'
 import type { ValidationIssue } from '../types'
@@ -59,6 +61,53 @@ function findText(config: Record<string, any>, needle: string): string | null {
   return walk(config, '')
 }
 
+/**
+ * 「提示词要求用「X」，但节点没有绑定它」这一类（后端 schema._check_named_tools）。
+ * 点了名的是 error，只是「提到了」的是 warning；笼统的「要求调用工具，但没有绑定任何工具」
+ * 没有点名。三种的修法都是去绑工具
+ */
+const NAMED_TOOL = /(?:要求用|提到了)「([^」]+)」，但/
+const VAGUE_TOOL = /要求调用工具，但(?:这个节点|这个成员)没有绑定任何工具/
+
+/** 这条问题要绑的是哪个工具。不是这一类、或者没有点名，返回 null */
+export function unboundToolOf(message: string): string | null {
+  return NAMED_TOOL.exec(message)?.[1] ?? null
+}
+
+/** 工具没绑的问题落到哪一栏：agent 的「可用工具」，或者那个成员的工具；协作目标点的名落到成员列表 */
+function toolBindingOf(issue: ValidationIssue, node: FlowNode): FieldRef | null {
+  if (!NAMED_TOOL.test(issue.message) && !VAGUE_TOOL.test(issue.message)) return null
+  const at = issue.field ? parseFieldPath(issue.field) : null
+  if (at?.key === 'agents' && at.index != null) return { key: 'agents', index: at.index, sub: 'tools' }
+  if (node.data.nodeType === 'supervisor') return { key: 'agents' }
+  if (node.data.nodeType === 'agent') return { key: 'tools' }
+  return at
+}
+
+const toolList = (v: unknown): string[] => (Array.isArray(v) ? v.filter((t) => typeof t === 'string') : [])
+
+/**
+ * 一键绑定：把 tool 加进 at 指着的那一栏（agent 的 tools，或第 i 个成员的 tools），返回新的
+ * config。已经绑了、或者 at 指的不是工具栏，返回 null——按钮就不出现
+ */
+export function withToolBound(
+  config: Record<string, any>, at: FieldRef | null | undefined, tool: string,
+): Record<string, any> | null {
+  if (!at) return null
+  if (at.key === 'tools' && at.index == null) {
+    const cur = toolList(config.tools)
+    return cur.includes(tool) ? null : { ...config, tools: [...cur, tool] }
+  }
+  if (at.key === 'agents' && at.index != null && at.sub === 'tools' && Array.isArray(config.agents)) {
+    const member = config.agents[at.index]
+    if (!member || typeof member !== 'object') return null
+    const cur = toolList(member.tools)
+    if (cur.includes(tool)) return null
+    return { ...config, agents: config.agents.map((a: any, i: number) => (i === at.index ? { ...a, tools: [...cur, tool] } : a)) }
+  }
+  return null
+}
+
 /** 后端 schema.py 的固定说法 → 字段。顺序有讲究：具体的在前 */
 const RULES: [RegExp, string][] = [
   [/^跳过条件/, 'skip_if'],
@@ -74,9 +123,9 @@ const RULES: [RegExp, string][] = [
   [/代码把输出交给/, 'code'],
 ]
 
-export function fieldOfIssue(
-  issue: ValidationIssue & { field?: string | null }, node: FlowNode | undefined,
-): FieldRef | null {
+export function fieldOfIssue(issue: ValidationIssue, node: FlowNode | undefined): FieldRef | null {
+  const binding = node ? toolBindingOf(issue, node) : null
+  if (binding) return binding
   if (issue.field) return parseFieldPath(issue.field)
   if (!node) return null
   const config = node.data.config ?? {}
diff --git a/frontend/src/canvas/nodeDefs.ts b/frontend/src/canvas/nodeDefs.ts
index a6567e4d..179c0564 100644
--- a/frontend/src/canvas/nodeDefs.ts
+++ b/frontend/src/canvas/nodeDefs.ts
@@ -195,7 +195,21 @@ export const NODE_DEFS: Record<NodeType, NodeDef> = {
     fields: [
       { key: 'goal', label: '团队目标', type: 'prompt' },
       { key: 'agents', label: '团队成员', type: 'agents' },
-      { key: 'max_rounds', label: '最大轮次', type: 'number', min: 1, max: 25 },
+      // 叫「最多轮数」：团队用完轮数的报错和右栏都说「调大『最多轮数』」，字段名得对得上
+      { key: 'max_rounds', label: '最多轮数', type: 'number', min: 1, max: 25 },
+      {
+        // 以前轮数用完就把成员最后的原话当成功结果交出去：成员一直没查到数、只会输出
+        // 工具调用的原始标记，运行照样显示「已完成」。默认改成判失败，降档要自己选
+        key: 'on_exhausted', label: '用完轮数时', type: 'select',
+        // 没写和写 fail 是一回事（后端只认 degrade）。选项用 fail：没写时下拉框落在第一项上
+        options: [
+          { value: 'fail', label: '判为失败（默认）' },
+          { value: 'degrade', label: '降档交付' },
+        ],
+        help: '最后一轮调度者仍没判定完成时怎么收场。判为失败：节点报错、运行停下，并点出一次都没'
+          + '被派到的成员；降档交付：把成员最后的原话交给下游，标上「未完成」，出具和复核随之降档。'
+          + '要出数、要出报告的，留在判为失败',
+      },
       {
         key: 'max_parallel', label: '每轮最多同时派几人', type: 'number', min: 1, max: 6,
         help: '互不依赖的任务调度者可以放在同一轮同时执行，总耗时按最慢的那个算。'
diff --git a/frontend/src/canvas/shortcuts.ts b/frontend/src/canvas/shortcuts.ts
index 0c8dcca8..ae22603b 100644
--- a/frontend/src/canvas/shortcuts.ts
+++ b/frontend/src/canvas/shortcuts.ts
@@ -48,7 +48,9 @@ export const STUDIO_SHORTCUTS: StudioShortcut[] = [
   { id: 'delete', combo: 'Backspace', alt: ['Delete'], label: '删除选中的节点或连线', group: '编辑', passive: true },
 
   { id: 'focus', combo: 'F', label: '镜头对准选中的节点（运行中没有选中时：逐个对准要处理的节点）', group: '画布' },
-  { id: 'fit', combo: 'Shift+1', label: '缩放到看全所有节点', group: '画布' },
+  // 它回到打开时的取景（从入口看起，缩放不低于可读下限），不是「看全所有节点」：大图上
+  // 看全要把卡片缩到读不清。真要看全，用画布左下角的「适配全图」
+  { id: 'fit', combo: 'Shift+1', label: '重新取景（回到打开时的视角，从入口看起）', group: '画布' },
   { id: 'layout', combo: 'Shift+L', label: '自动排版', group: '画布' },
   { id: 'search', combo: '/', label: '搜索节点库', group: '画布' },
   { id: 'nextProblem', combo: 'F8', label: '跳到下一个问题', group: '画布' },
diff --git a/frontend/src/canvas/surface.css b/frontend/src/canvas/surface.css
index 0f955573..1d46386c 100644
--- a/frontend/src/canvas/surface.css
+++ b/frontend/src/canvas/surface.css
@@ -313,6 +313,161 @@
   text-underline-offset: 2px;
 }
 
+/* 看运行时选中了跑过的节点：属性面板不自动盖上右栏，这里给一个明确的入口 */
+.sf-peek {
+  display: inline-flex;
+  flex: none;
+  max-width: 260px;
+  pointer-events: auto;
+  align-items: center;
+  gap: 5px;
+  padding: 2px 9px;
+  border-radius: 999px;
+  border: 1px solid var(--border-strong);
+  background: color-mix(in srgb, var(--bg-panel) 92%, transparent);
+  box-shadow: var(--elev-1);
+  color: var(--text-dim);
+  font-size: var(--text-2xs);
+  line-height: 18px;
+  white-space: nowrap;
+  transition: color var(--dur-fast) var(--ease-out), border-color var(--dur-fast) var(--ease-out);
+}
+.sf-peek:hover {
+  border-color: var(--accent);
+  color: var(--text);
+}
+.sf-peek:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 1px;
+}
+.sf-peek-name {
+  min-width: 0;
+  overflow: hidden;
+  color: var(--text);
+  font-weight: 600;
+  text-overflow: ellipsis;
+}
+
+/* Copilot 这一轮删掉的节点：原地一道虚线框，停一下再淡出（时长和 FlowCanvas 的
+   GHOST_MS 一致）。框在画布坐标里，跟着平移缩放；标签的字按缩放补回来，精简档里
+   （窄画布打开就是 0.4）也不小于 11px，到远景档才跟着缩小。长名字由 max-width 截成省略号 */
+.sf-ghost {
+  position: absolute;
+  top: 0;
+  left: 0;
+  border: 1.5px dashed color-mix(in srgb, var(--nt, var(--text-faint)) 60%, var(--text-faint));
+  border-radius: var(--radius-lg);
+  background: color-mix(in srgb, var(--nt, var(--text-faint)) 5%, transparent);
+  pointer-events: none;
+  animation: sf-ghost-out 2400ms var(--ease-out) forwards;
+}
+.sf-ghost-tag {
+  position: absolute;
+  top: 0;
+  left: 10px;
+  max-width: calc(100% - 20px);
+  padding: 0 6px;
+  overflow: hidden;
+  transform: translateY(-50%);
+  border-radius: 999px;
+  background: var(--bg-panel);
+  color: var(--text-dim);
+  font-size: calc(11px / min(max(var(--zoom, 1), 0.35), 1));
+  line-height: 1.5;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+@keyframes sf-ghost-out {
+  0% { opacity: 0; }
+  10% { opacity: 1; }
+  70% { opacity: 1; }
+  100% { opacity: 0; }
+}
+
+/* 双击空白处的快速添加 */
+.sf-quick {
+  position: absolute;
+  z-index: 30;
+  display: flex;
+  flex-direction: column;
+  max-height: 312px;
+  overflow: hidden;
+  border-radius: var(--radius-xl);
+  border: 1px solid var(--border);
+  background: var(--bg-panel);
+  box-shadow: var(--elev-3);
+}
+.sf-quick-search {
+  display: flex;
+  flex: none;
+  align-items: center;
+  gap: 6px;
+  padding: 8px 10px;
+  border-bottom: 1px solid var(--border);
+  color: var(--text-faint);
+}
+.sf-quick-search input {
+  flex: 1;
+  min-width: 0;
+  background: transparent;
+  color: var(--text);
+  font-size: var(--text-xs);
+  outline: none;
+}
+.sf-quick-search input::placeholder {
+  color: var(--text-faint);
+}
+.sf-quick-search:focus-within {
+  color: var(--accent);
+}
+.sf-quick-list {
+  flex: 1;
+  min-height: 0;
+  padding: 4px;
+  overflow-y: auto;
+}
+.sf-quick-item {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 5px 6px;
+  border-radius: var(--radius-md);
+  color: var(--text-dim);
+  font-size: var(--text-xs);
+  cursor: pointer;
+}
+.sf-quick-item.is-active {
+  background: var(--bg-hover);
+  color: var(--text);
+}
+.sf-quick-item .sf-dim {
+  flex: none;
+  font-size: var(--text-2xs);
+}
+.sf-quick-icon {
+  display: inline-flex;
+  flex: none;
+  width: 20px;
+  height: 20px;
+  align-items: center;
+  justify-content: center;
+  border-radius: var(--radius-sm);
+  background: color-mix(in srgb, var(--nt) 18%, transparent);
+  color: var(--nt);
+}
+.sf-quick-empty {
+  padding: 10px 8px;
+  color: var(--text-faint);
+  font-size: var(--text-2xs);
+}
+.sf-quick-foot {
+  flex: none;
+  padding: 5px 10px;
+  border-top: 1px solid var(--hairline);
+  color: var(--text-faint);
+  font-size: var(--text-2xs);
+}
+
 /* --------------------------------------------------------------------------
    运行胶囊（工具栏）
    -------------------------------------------------------------------------- */
@@ -425,6 +580,15 @@
   background: var(--text-faint);
 }
 
+/* 运行类别的记号：正式实心、探索空心，颜色跟字走 */
+.sf-dot {
+  flex: none;
+}
+/* 放弃停在审批上的运行：次级动作，悬停才露出危险色 */
+.sf-btn-abandon:hover:not(:disabled) {
+  color: var(--st-failed);
+}
+
 /* 发起浮层 */
 .sf-pop {
   position: absolute;
@@ -537,6 +701,7 @@
 .sf-class {
   display: inline-flex;
   align-items: center;
+  gap: 5px;
   padding: 0 7px;
   border-radius: 999px;
   border: 1px solid var(--border);
@@ -1280,7 +1445,8 @@
    -------------------------------------------------------------------------- */
 @media (prefers-reduced-motion: reduce) {
   .sf-canvas .edge-packet,
-  .sf-sweep {
+  .sf-sweep,
+  .sf-ghost {
     display: none;
   }
   .sf-canvas[data-moment='failed'] .react-flow__edge.sf-e-cut .react-flow__edge-path,
diff --git a/frontend/src/components/CommandPalette.tsx b/frontend/src/components/CommandPalette.tsx
index 7b3ca50b..508a61b8 100644
--- a/frontend/src/components/CommandPalette.tsx
+++ b/frontend/src/components/CommandPalette.tsx
@@ -22,6 +22,7 @@ import { statusLabel } from '../lib/status'
 import { WORKFLOW_STATUS_LABEL, runClassLabel } from '../lib/terms'
 import { errorMessage } from '../lib/errors'
 import { disableNotify, enableNotify, notifySupported, useSignals } from '../lib/notify'
+import { canLeave, leavePass } from '../lib/leave'
 import type { Run } from '../types'
 
 /**
@@ -165,14 +166,23 @@ export async function toggleNotify(): Promise<void> {
 }
 
 export async function newConversation(navigate: NavigateFunction): Promise<void> {
+  // 先问再建：跳的时候才问的话，人点了「留下」，会话已经建出来了
+  if (!(await canLeave())) return
   try {
     const id = await useConversations.getState().create()
-    navigate(`/chat/${id}`)
+    navigate(`/chat/${id}`, leavePass())
   } catch (e) {
     toast.error(e)
   }
 }
 
+/** 同上：先问离开，再问名字、建工作流 */
+async function newWorkflow(navigate: NavigateFunction): Promise<void> {
+  if (!(await canLeave())) return
+  // 和编排页的「新建工作流」同一条路：同名校验、画布上有没保存的改动先问
+  await createWorkflow((to, opts) => navigate(to, leavePass(opts)), () => useCatalog.getState().refresh())
+}
+
 /** 等了多久，给待审批用：「12 分钟」「3 小时」「8 天」。粗粒度就够，要的是一眼看出晾了多久 */
 export function waitedFor(createdAt: string | null | undefined, now = Date.now()): string | null {
   const d = parseServerTime(createdAt)
@@ -247,6 +257,7 @@ function PaletteView() {
   const [query, setQuery] = useState('')
   const [active, setActive] = useState(0)
   const inputRef = useRef<HTMLInputElement>(null)
+  const panelRef = useRef<HTMLDivElement>(null)
   const listId = useId()
   const workflows = useCatalog((s) => s.workflows)
   const approvals = useCatalog((s) => s.approvals)
@@ -269,6 +280,16 @@ function PaletteView() {
     }
   }, [opener])
 
+  // 开着时焦点只在面板里：刚跳过去的页面挂载时会自动聚焦（画布助手的输入框），
+  // 焦点一被抢走，接着打的字和 Esc 就都落到了面板底下
+  useEffect(() => {
+    const onFocusIn = (e: FocusEvent) => {
+      if (e.target instanceof Node && !panelRef.current?.contains(e.target)) inputRef.current?.focus({ preventScroll: true })
+    }
+    document.addEventListener('focusin', onFocusIn)
+    return () => document.removeEventListener('focusin', onFocusIn)
+  }, [])
+
   // 最近运行、最近会话是打开面板时才取：常驻轮询它们不值得
   useEffect(() => {
     if (backend === 'down') return
@@ -324,8 +345,7 @@ function PaletteView() {
       {
         id: 'act:new-workflow', group: 'actions', label: '新建工作流', hint: '起手是一个输入、一个成果',
         keywords: 'new workflow 画布 编排 创建', icon: <Plus size={14} />,
-        // 和编排页的「新建工作流」同一条路：同名校验、画布上有没保存的改动先问
-        run: () => void createWorkflow((to, opts) => navigate(to, opts), () => useCatalog.getState().refresh()),
+        run: () => void newWorkflow(navigate),
       },
       {
         id: 'act:theme', group: 'actions',
@@ -455,6 +475,7 @@ function PaletteView() {
       onKeyDown={onKeyDown}
     >
       <div
+        ref={panelRef}
         role="dialog"
         aria-modal="true"
         aria-label="命令面板"
diff --git a/frontend/src/components/ui.tsx b/frontend/src/components/ui.tsx
index 7e9c40e7..6dfd2f20 100644
--- a/frontend/src/components/ui.tsx
+++ b/frontend/src/components/ui.tsx
@@ -4,15 +4,18 @@ import type {
   ButtonHTMLAttributes, CSSProperties, ErrorInfo, KeyboardEvent as ReactKeyboardEvent, ReactNode, RefObject,
 } from 'react'
 import {
-  AlertCircle, AlertTriangle, Check, CheckCircle2, CloudOff, Copy, Info, Loader2, RotateCw, X,
+  AlertCircle, AlertTriangle, Check, CheckCircle2, CloudOff, Copy, Info, Loader2, RotateCw, Trash2, X,
 } from 'lucide-react'
 import clsx from 'clsx'
-import { useCatalog } from '../store/catalog'
+import { CATALOG_LABELS, catalogListState, useCatalog } from '../store/catalog'
+import type { CatalogKey } from '../store/catalog'
 import { humanizeError } from '../lib/errors'
 import { ariaShortcut, formatShortcut } from '../lib/keys'
 import { STATUS, statusMeta } from '../lib/status'
 import type { StatusShape } from '../lib/status'
-import { formatDateTime, formatTime } from '../lib/format'
+import { formatDateTime, formatDuration, formatRelative, formatTime } from '../lib/format'
+import type { HealthRecord } from '../lib/health'
+import { useRunClock } from '../run/useRunClock'
 
 /**
  * 输入法正在组字吗。组字期间的回车是"选词"，不是"提交"——不判这一条，中文
@@ -76,7 +79,7 @@ export class ErrorBoundary extends Component<
 }
 
 /** 「技术细节」折叠区：原文给运维复制用，默认收起 */
-function TechDetails({ raw, summary, className }: { raw: string; summary?: string; className?: string }) {
+export function TechDetails({ raw, summary, className }: { raw: string; summary?: string; className?: string }) {
   return (
     <details className={clsx('w-full text-left text-[11px] text-faint', className)}>
       <summary className="cursor-pointer select-none hover:text-dim">
@@ -218,7 +221,8 @@ const TOAST_VISIBLE = 3
  * 位置在内容区顶部居中、各页工具栏的下沿之下：右下角正好压在助手栏的输入区
  * 上，问数据页的输入框又在底部居中；贴着顶边又会盖住工具栏右侧的按钮（1280 宽
  * 时画布的 Copilot 按钮），而出错的 toast 是常驻的，一直盖着。工具栏最高 48px，
- * 离线横幅出现时再让出它的高度。左边让出 56px 的导航栏，在内容区里居中。
+ * 离线横幅出现时再让出它的高度。左边让出 64px 的导航栏（App 里的 w-16），在内容区
+ * 里居中。
  */
 export function ToastHost({ children }: { children?: ReactNode }) {
   const items = useSyncExternalStore(subscribeToasts, () => toastItems, () => toastItems)
@@ -232,7 +236,7 @@ export function ToastHost({ children }: { children?: ReactNode }) {
       {children}
       <DialogHost />
       <div
-        className="pointer-events-none fixed left-14 right-0 z-[100] flex justify-center px-4"
+        className="pointer-events-none fixed left-16 right-0 z-[100] flex justify-center px-4"
         style={{ top: 'calc(3.5rem + var(--offline-banner-h, 0px))' }}
       >
         <div className="flex w-full max-w-md flex-col gap-2">
@@ -788,13 +792,47 @@ export const Spinner = ({ size = 14 }: { size?: number }) => (
  * 默认感知连接状态：后端断开时"空"不代表"没有"，改说「暂时拿不到数据」并把
  * 「新建」这类动作收起来——之前后端挂了，整站都在说「还没有工作流」并引导新建，
  * 用户照做就是一堆重复配置。纯本地的空（比如搜索没匹配）传 offline={false}。
+ *
+ * 后端连着也可能是假的空：某张表卡着没回来、超时或报错，列表照样是 []。这份空
+ * 来自 catalog 的哪张表，就把 source 传进来（source="workflows"），那张表从没
+ * 取回来过时改说「还在读取 / 没取回来」，同样收起动作。
  */
-export function EmptyState({ icon, title, body, action, offline = 'auto', className }: {
+export function EmptyState({ icon, title, body, action, offline = 'auto', source, className }: {
   icon?: ReactNode; title: string; body?: ReactNode; action?: ReactNode
-  offline?: 'auto' | false; className?: string
+  offline?: 'auto' | false
+  /** 这份空来自 catalog 的哪张表。页面自己拉的列表不传，自己区分加载中和出错 */
+  source?: CatalogKey
+  className?: string
 }) {
   const backend = useCatalog((s) => s.backend)
   const checkBackend = useCatalog((s) => s.checkBackend)
+  const list = useCatalog((s) => (source && offline === 'auto' ? catalogListState(s, source) : 'ok'))
+  const listError = useCatalog((s) => (source && offline === 'auto' && catalogListState(s, source) === 'error'
+    ? s.checks.find((c) => c.key === source)?.error ?? null : null))
+  if (offline === 'auto' && source && (list === 'loading' || list === 'error')) {
+    const label = CATALOG_LABELS[source]
+    const loading = list === 'loading'
+    return (
+      <div
+        className={clsx('flex flex-col items-center justify-center gap-2 px-6 py-14 text-center', className)}
+        role={loading ? 'status' : 'alert'}
+        data-empty-unknown={list}
+      >
+        <div className="text-faint">{loading ? <Spinner size={20} /> : <AlertCircle size={22} aria-hidden />}</div>
+        <div className="text-sm text-dim">{loading ? `正在读取${label}` : `${label}没取回来`}</div>
+        <div className="max-w-sm text-xs leading-relaxed text-faint">
+          {loading
+            ? '后端连着，这份列表还在路上。取回来之前，空着不代表没有。'
+            : <>{listError ? `${humanizeError(listError).title.replace(/[。.！!]$/, '')}。` : ''}这里显示为空不代表没有数据。</>}
+        </div>
+        {!loading && (
+          <button className="btn btn-sm mt-2" onClick={() => void useCatalog.getState().refresh()}>
+            <RotateCw size={12} aria-hidden /> 重新读取
+          </button>
+        )}
+      </div>
+    )
+  }
   if (offline === 'auto' && backend === 'down') {
     return (
       <div className={clsx('flex flex-col items-center justify-center gap-2 px-6 py-14 text-center', className)}>
@@ -822,10 +860,10 @@ export function EmptyState({ icon, title, body, action, offline = 'auto', classN
 }
 
 /** 老名字。hint 就是 EmptyState 的 body */
-export function Empty({ icon, title, hint, action, offline }: {
-  icon?: ReactNode; title: string; hint?: string; action?: ReactNode; offline?: 'auto' | false
+export function Empty({ icon, title, hint, action, offline, source }: {
+  icon?: ReactNode; title: string; hint?: string; action?: ReactNode; offline?: 'auto' | false; source?: CatalogKey
 }) {
-  return <EmptyState icon={icon} title={title} body={hint} action={action} offline={offline} />
+  return <EmptyState icon={icon} title={title} body={hint} action={action} offline={offline} source={source} />
 }
 
 /**
@@ -877,15 +915,32 @@ export function ErrorNotice(props: { error: unknown; onRetry?: () => void; class
   return <ErrorState {...props} compact />
 }
 
-/** 每 intervalMs 刷新一次的「现在」。只在 active 时计时，不做常驻定时器 */
-function useNow(active: boolean, intervalMs = 1000): number {
+/**
+ * 每 ms 毫秒重渲染一次的「现在」，给倒计时、「3 分钟前」这类相对时间保鲜。
+ * 只在 active 时计时，不做常驻定时器；页面不可见时不跳，回到前台立刻补一拍，
+ * 不让人看到一个停在几分钟前的数。
+ *
+ * 算相对时间时要现取 Date.now()：返回值是上一拍的时刻，比刚到的结果还早，拿它
+ * 算会把「刚刚」写成一个钟点。运行计时（100ms 一跳、全站同拍）用 useRunClock。
+ */
+export function useTicker(ms: number, active = true): number {
   const [now, setNow] = useState(() => Date.now())
+  const started = useRef(false)
   useEffect(() => {
+    // 挂载那一次不补：初值就是此刻。之后（从停着变成走着）要补，否则头一拍要等满
+    // ms，离线横幅刚出来时的倒计时就是拿挂载时刻算的
+    const first = !started.current
+    started.current = true
     if (!active) return
-    setNow(Date.now())
-    const t = setInterval(() => setNow(Date.now()), intervalMs)
-    return () => clearInterval(t)
-  }, [active, intervalMs])
+    if (!first) setNow(Date.now())
+    const tick = () => { if (!document.hidden) setNow(Date.now()) }
+    const t = setInterval(tick, ms)
+    document.addEventListener('visibilitychange', tick)
+    return () => {
+      clearInterval(t)
+      document.removeEventListener('visibilitychange', tick)
+    }
+  }, [ms, active])
   return now
 }
 
@@ -900,7 +955,7 @@ export function OfflineBanner({ className }: { className?: string }) {
   const lastOkAt = useCatalog((s) => s.lastOkAt)
   const checkBackend = useCatalog((s) => s.checkBackend)
   const down = backend === 'down'
-  const now = useNow(down)
+  const now = useTicker(1000, down)
   const [busy, setBusy] = useState(false)
   const ref = useRef<HTMLDivElement>(null)
 
@@ -922,7 +977,7 @@ export function OfflineBanner({ className }: { className?: string }) {
   return (
     <div
       ref={ref}
-      role="alert"
+      data-offline-banner=""
       className={clsx('flex min-h-7 flex-wrap items-center gap-x-2 gap-y-0.5 border-b px-3 py-1 text-[11.5px]', className)}
       style={{
         color: 'var(--err)',
@@ -931,14 +986,18 @@ export function OfflineBanner({ className }: { className?: string }) {
       }}
       title={backendError ?? undefined}
     >
-      <CloudOff size={13} className="shrink-0" aria-hidden />
-      <span className="font-medium">后端未连接</span>
-      <span className="text-dim">当前看到的空列表不代表数据丢失</span>
-      {lastOkAt && (
-        <span className="text-faint tabular-nums" title={formatDateTime(lastOkAt)}>· 最后连通 {formatTime(lastOkAt)}</span>
-      )}
+      {/* 播报区只放不变的那几句：role=alert 是整块重念的，倒计时一秒一跳，放进来
+          读屏就一秒念一遍整条横幅 */}
+      <span role="alert" className="flex flex-wrap items-center gap-x-2 gap-y-0.5">
+        <CloudOff size={13} className="shrink-0" aria-hidden />
+        <span className="font-medium">后端未连接</span>
+        <span className="text-dim">当前看到的空列表不代表数据丢失</span>
+        {lastOkAt && (
+          <span className="text-faint tabular-nums" title={formatDateTime(lastOkAt)}>· 最后连通 {formatTime(lastOkAt)}</span>
+        )}
+      </span>
       <span className="ml-auto flex items-center gap-2">
-        {secs != null && !busy && <span className="text-faint tabular-nums">{secs} 秒后自动重试</span>}
+        {secs != null && !busy && <span className="text-faint tabular-nums" aria-hidden>{secs} 秒后自动重试</span>}
         <button
           className="btn btn-sm"
           disabled={busy}
@@ -1033,11 +1092,7 @@ export function Tabs({ tabs, active, onChange, label, idPrefix }: {
 }) {
   const refs = useRef<Record<string, HTMLButtonElement | null>>({})
   const move = (e: ReactKeyboardEvent, i: number) => {
-    let next = -1
-    if (e.key === 'ArrowRight') next = (i + 1) % tabs.length
-    else if (e.key === 'ArrowLeft') next = (i - 1 + tabs.length) % tabs.length
-    else if (e.key === 'Home') next = 0
-    else if (e.key === 'End') next = tabs.length - 1
+    const next = rovingTarget(e, i, tabs.length, 'horizontal')
     if (next < 0) return
     e.preventDefault()
     const key = tabs[next].key
@@ -1083,6 +1138,48 @@ export function Tabs({ tabs, active, onChange, label, idPrefix }: {
   )
 }
 
+/**
+ * 一组「只占一个 Tab 位、组内用方向键走」的控件（标签页、单选组）里，这一键要
+ * 去第几个。首尾相接，Home / End 到两头；不是移动键返回 -1。带 Alt / ⌘ / Ctrl 的
+ * 不接：Alt+← 是浏览器后退
+ */
+export function rovingTarget(e: ReactKeyboardEvent, i: number, n: number, axis: 'horizontal' | 'both'): number {
+  if (!n || e.altKey || e.metaKey || e.ctrlKey) return -1
+  if (e.key === 'ArrowRight' || (axis === 'both' && e.key === 'ArrowDown')) return (i + 1) % n
+  if (e.key === 'ArrowLeft' || (axis === 'both' && e.key === 'ArrowUp')) return (i - 1 + n) % n
+  if (e.key === 'Home') return 0
+  if (e.key === 'End') return n - 1
+  return -1
+}
+
+/**
+ * 单选组（role=radiogroup）的键盘约定：整组只占一个 Tab 位，落在选中项上；
+ * ←→↑↓ 在组内移动并选中，首尾相接，Home / End 到两头。标了 radio 却每项一个
+ * Tab 位、方向键没反应，等于对读屏用户许了个做不到的诺。
+ *
+ * 用法：const radio = useRadioGroup(values, value, onChange)，每个选项展开
+ * {...radio(v)}，点击照旧自己写 onClick；外层容器自己写 role="radiogroup" 和名字。
+ */
+export function useRadioGroup<T extends string>(values: readonly T[], value: T | undefined, onChange: (v: T) => void) {
+  const refs = useRef(new Map<T, HTMLElement | null>())
+  // 选中的值不在选项里（还没加载完之类）：让第一项接住 Tab
+  const focusable = value !== undefined && values.includes(value) ? value : values[0]
+  return (v: T) => ({
+    ref: (el: HTMLElement | null) => { refs.current.set(v, el) },
+    role: 'radio' as const,
+    'aria-checked': v === value,
+    tabIndex: v === focusable ? 0 : -1,
+    onKeyDown: (e: ReactKeyboardEvent) => {
+      const i = rovingTarget(e, values.indexOf(v), values.length, 'both')
+      if (i < 0) return
+      e.preventDefault()
+      const next = values[i]
+      if (next !== value) onChange(next)
+      refs.current.get(next)?.focus()
+    },
+  })
+}
+
 export function TabPanel({ idPrefix, tabKey, children, className }: {
   idPrefix: string; tabKey: string; children: ReactNode; className?: string
 }) {
@@ -1432,3 +1529,226 @@ export function CopyButton({ text }: { text: string }) {
     </button>
   )
 }
+
+// -------------------------------------------------------------------------
+// 页头、分节、删除按钮：工具、知识、数据、设置、记录几页共用
+// -------------------------------------------------------------------------
+
+/**
+ * 页头：图标、标题、一句说明、页面级按钮。
+ *
+ * 高度卡死 48px：toast 从 56px 起，工具栏比这高，常驻的出错 toast 就会压住
+ * 按钮。标签页（如果有）紧贴在页头下面、左边缘对齐。
+ */
+export function PageHeader({ icon, title, subtitle, actions }: {
+  icon: ReactNode; title: string; subtitle?: string; actions?: ReactNode
+}) {
+  return (
+    <header className="flex h-12 shrink-0 items-center gap-2.5 border-b bg-panel px-4">
+      <span className="flex h-6 w-6 shrink-0 items-center justify-center rounded-md border bg-elev text-dim" aria-hidden>
+        {icon}
+      </span>
+      <h1 className="shrink-0 text-sm font-semibold">{title}</h1>
+      {subtitle && <p className="min-w-0 truncate text-xs text-faint" title={subtitle}>{subtitle}</p>}
+      <span className="flex-1" />
+      {actions}
+    </header>
+  )
+}
+
+/** 标签页里一节的标题行：左边标题和一句说明，右边这一节的按钮 */
+export function SectionBar({ title, hint, children }: { title: string; hint?: ReactNode; children?: ReactNode }) {
+  return (
+    <div className="mb-3 flex flex-wrap items-end gap-x-3 gap-y-2">
+      <div className="min-w-0 flex-1">
+        <h2 className="text-sm font-semibold">{title}</h2>
+        {hint && <p className="mt-0.5 text-xs leading-relaxed text-faint">{hint}</p>}
+      </div>
+      {children && <div className="flex flex-wrap items-center gap-2">{children}</div>}
+    </div>
+  )
+}
+
+/** 删除类的纯图标按钮：悬停铺 10% 的 err 底，读屏念得出删的是谁 */
+export function DeleteButton({ label, onClick, disabled }: { label: string; onClick: () => void; disabled?: boolean }) {
+  return (
+    <IconButton
+      label={label}
+      onClick={onClick}
+      disabled={disabled}
+      className="text-faint hover:bg-st-failed/10 hover:text-[var(--err)]"
+      icon={<Trash2 size={12} />}
+    />
+  )
+}
+
+/**
+ * 连通状态胶囊：状态剪影 + 一句话。结果存在 lib/health（useHealth / checkHealth）。
+ *
+ * 和画布运行态同一套语言：进行中是转着的圆环、正常是带勾的方块、失败是三角、
+ * 没测过是空心点——去掉颜色也认得出。正常态安静（字是 dim），出错才用 err 色。
+ * 结果刚到的那一下，状态点外圈扩散一次；进页时从缓存读出的旧结果不播。
+ */
+export function HealthPill({ record, checkingSince, labels, className, stale }: {
+  record?: HealthRecord | null
+  checkingSince?: number
+  labels?: { idle?: string; checking?: string; ok?: string; fail?: string }
+  className?: string
+  /** 结果已经不代表眼前这份配置（改过了），淡出显示并提示重测 */
+  stale?: boolean
+}) {
+  const clock = useRunClock(!!checkingSince)
+  useTicker(30_000, !!record && !checkingSince)
+  const state = checkingSince ? 'checking' : !record ? 'idle' : record.ok ? 'ok' : 'fail'
+  const status = ({ idle: 'idle', checking: 'running', ok: 'done', fail: 'failed' } as const)[state]
+  const color = `var(--st-${status})`
+
+  const [ping, setPing] = useState(0)
+  const lastAt = useRef(record?.at)
+  useEffect(() => {
+    const at = record?.at
+    if (at && at !== lastAt.current && Date.now() - at < 3000) setPing(at)
+    lastAt.current = at
+  }, [record?.at])
+
+  // at 为 0：后端记的上次结果，不知道是什么时候测的，就不写时间。带个「测」字：
+  // 这是上次测的时刻，不是此刻的状态
+  const rel = record?.at ? formatRelative(record.at) : ''
+  const when = !rel ? '' : rel === '刚刚' ? '刚测过' : /前$/.test(rel) ? `${rel}测` : `${rel} 测`
+  const text = state === 'checking'
+    ? `${labels?.checking ?? '正在测'} · ${formatDuration(Math.max(0, clock - (checkingSince ?? clock)))}`
+    : state === 'idle'
+      ? (labels?.idle ?? '未测试')
+      : state === 'ok'
+        ? [labels?.ok ?? '已连通', record?.ms != null ? formatDuration(record.ms) : null, when].filter(Boolean).join(' · ')
+        : [labels?.fail ?? '连不上', when].filter(Boolean).join(' · ')
+  const tip = record
+    ? [
+        record.at ? `${formatDateTime(record.at)} 测的` : '上次探测的结果',
+        record.ok ? record.note : record.error,
+        stale ? '配置改过了，这个结果不代表眼前这份，重测一次' : null,
+      ].filter(Boolean).join('\n')
+    : undefined
+  // 念给读屏的那一句只在状态切换时变：看得见的那句里有 100ms 一跳的计时和
+  // 「3 分钟前」，放进播报区的话测连接期间会一直念、之后每分钟每张卡再念一遍。
+  // 时刻写成钟点，不写相对时间
+  const spoken = state === 'checking'
+    ? '正在测连接'
+    : state === 'idle' || !record
+      ? ''
+      : [
+          record.ok
+            ? [labels?.ok ?? '已连通', record.ms != null ? formatDuration(record.ms) : null].filter(Boolean).join(' ')
+            : `${labels?.fail ?? '连不上'}${record.error ? `：${record.error}` : ''}`,
+          record.at ? `${formatTime(record.at)} 测的` : null,
+          stale ? '配置改过了，这个结果不代表眼前这份' : null,
+        ].filter(Boolean).join('，')
+
+  return (
+    <>
+      <span
+        aria-hidden
+        data-health={state}
+        title={tip}
+        className={clsx('inline-flex items-center gap-1.5 whitespace-nowrap text-2xs tnum', stale && 'opacity-55', className)}
+        style={{ color: state === 'fail' ? color : state === 'checking' ? 'var(--accent)' : state === 'ok' ? 'var(--text-dim)' : 'var(--text-faint)' }}
+      >
+        <span className="relative inline-flex">
+          {ping > 0 && (
+            <span
+              key={ping}
+              className="absolute inset-0 animate-ping rounded-full"
+              style={{ background: color, animationIterationCount: 1, animationFillMode: 'forwards' }}
+              onAnimationEnd={() => setPing(0)}
+            />
+          )}
+          <StatusBadge status={status} size={12} decorative />
+        </span>
+        {text}
+        {stale && state !== 'checking' && <span className="text-faint">· 配置改过了</span>}
+      </span>
+      <span role="status" className="sr-only">{spoken}</span>
+    </>
+  )
+}
+
+// -------------------------------------------------------------------------
+// 删除后可撤销
+// -------------------------------------------------------------------------
+
+const UNDO_MS = 5000
+const pendingDeletes = new Map<number, string>()
+let pendingSeq = 0
+/**
+ * 已经点了删除的对象（按 DELETE 的 url 记）。撤销窗口里 DELETE 还没发，这时列表
+ * 一刷新（知识库有文档在处理时 2 秒轮询一次、写完记忆、存完工具都会重拉），后端
+ * 照样返回它，行就回来了——toast 还写着「已删除」，再点一次删除还会多排一个
+ * DELETE，头一个落地后第二个 404。所以各列表的 load 都要过一遍 withoutDeferred。
+ *
+ * 撤销、或者删失败放回原处时才拿出去；删成功了也不拿：id 不会再出现，而删之前
+ * 发出、删之后才回来的那次列表请求里还带着它
+ */
+const deferredGone = new Set<string>()
+
+/** 滤掉还在撤销窗口里（或已经删掉）的行。base 是 DELETE 地址去掉 id 的那段 */
+export function withoutDeferred<T extends { id: string }>(rows: T[], base: string): T[] {
+  return deferredGone.size ? rows.filter((r) => !deferredGone.has(`${base}/${r.id}`)) : rows
+}
+
+// 关页、刷新时，还在撤销窗口里的删除照样发出去：用户已经点了删除，刷新一下它
+// 又回来了，比多等 5 秒更让人糊涂。keepalive 让请求活过页面卸载
+if (typeof window !== 'undefined') {
+  window.addEventListener('pagehide', () => {
+    for (const url of pendingDeletes.values()) {
+      void fetch(url, { method: 'DELETE', keepalive: true }).catch(() => {})
+    }
+    pendingDeletes.clear()
+  })
+}
+
+/**
+ * 低代价的删除：列表里先拿掉，toast 给 5 秒「撤销」，到点才真发 DELETE。
+ * 比弹窗确认少一次打断，误删了又救得回来。发失败了放回原处并说明。
+ *
+ * url 是关页时补发用的（/api/...），commit 是正常路径。url 同时是「已删」的
+ * 记号：列表的 load 用 withoutDeferred 按它滤掉这一行。
+ */
+export function deferDelete({ what, url, hide, restore, commit, done }: {
+  what: string
+  url: string
+  hide: () => void
+  restore: () => void
+  commit: () => Promise<unknown>
+  done?: () => void
+}) {
+  deferredGone.add(url)
+  hide()
+  const id = ++pendingSeq
+  pendingDeletes.set(id, url)
+  // 先拿掉记号再 restore：restore 多半是重拉列表，记号还在的话又被滤掉
+  const putBack = () => { deferredGone.delete(url); restore() }
+  const timer = setTimeout(async () => {
+    if (!pendingDeletes.delete(id)) return
+    toast.dismiss(toastId)
+    try {
+      await commit()
+      done?.()
+    } catch (e) {
+      putBack()
+      const h = humanizeError(e)
+      toast.error(`没删掉${what}：${h.reason ? `${h.title}，${h.reason}` : h.title}`, { detail: h.raw })
+    }
+  }, UNDO_MS)
+  const toastId = toast(`已删除${what}`, 'info', {
+    duration: UNDO_MS,
+    key: `undo:${id}`,
+    action: {
+      label: '撤销',
+      onClick: () => {
+        if (!pendingDeletes.delete(id)) return
+        clearTimeout(timer)
+        putBack()
+      },
+    },
+  })
+}
diff --git a/frontend/src/dev/preview.tsx b/frontend/src/dev/preview.tsx
index 5725d8cf..2af79dff 100644
--- a/frontend/src/dev/preview.tsx
+++ b/frontend/src/dev/preview.tsx
@@ -11,7 +11,8 @@ import type { RunEvent } from '../types'
 import fixtures from '../run/__tests__/fixtures.json'
 import mdSamples from '../run/__tests__/markdown-samples.json'
 import {
-  COPILOT_STUCK, MIXED_OUTPUT, cancelledRun, longLoop, mixedRun, pipelineRun, teamRun,
+  COPILOT_STUCK, COPILOT_TOOLS_DROPPED, MIXED_OUTPUT, abandonedRun, cancelledRun, exhaustedTeam, longLoop,
+  markupRun, mixedRun, pipelineRun, repairRun, teamRun, timeoutRun,
 } from '../run/__tests__/synthetic'
 import '../index.css'
 
@@ -285,6 +286,53 @@ function synthetic(name: string): StreamTurn[] {
       return [{ id: 'schema', question: '看看有哪些人事表', phase: 'done', status: '已完成',
                 steps: decodeRun(ev, { status: 'succeeded' }) }]
     }
+    // ---- 平台问题的几种结局（NI-3/4/5）：失败的轮次把 run.failed 的原话交给流，和运行页、画布右栏一样
+    case 'exhausted':
+    case 'markup':
+    case 'repair': {
+      const ev = name === 'exhausted' ? exhaustedTeam('fail') : name === 'markup' ? markupRun() : repairRun()
+      const end = ev[ev.length - 1].data
+      return [{ id: name, question: '上月各区域订单额', phase: 'error', steps: decodeRun(ev), runId: `syn-${name}`,
+                error: { error: String(end.error), ...(end.detail ? { detail: end.detail } : {}) } }]
+    }
+    case 'exhausted-degrade': {
+      const ev = exhaustedTeam('degrade')
+      return [{ id: 'exhausted-degrade', question: '上月各区域订单额', phase: 'done', steps: decodeRun(ev),
+                output: { 结论: ev[ev.length - 1].data.output.结论, _issuance: {
+                  tier: 'degraded', calibers: [], metrics_checked: 0, matched_numbers: 0, unmatched_numbers: [],
+                  missing_required: [], missing_expected: [],
+                  gaps: ['协作团队「销售分析团队」用完 2 轮仍未完成，交来的是成员最后的原话'] } },
+                runId: 'syn-exhausted-degrade', runClass: 'exploratory' }]
+    }
+    case 'exhausted-closing': {
+      const ev = rebase(exhaustedTeam('closing'))
+      return [{ id: 'exhausted-closing', question: '上月各区域订单额', phase: 'running', steps: decodeRun(ev),
+                runId: 'syn-exhausted-closing' }]
+    }
+    case 'timeout-live': {
+      // 查询已经走了 34 秒，时限是 30 秒：秒表要说破「已超出上限」
+      const ev = rebase(timeoutRun('live'), 34000)
+      return [{ id: 'timeout-live', question: '把订单明细全拉出来', phase: 'running', steps: decodeRun(ev),
+                runId: 'syn-timeout-live' }]
+    }
+    case 'timeout':
+      return [{ id: 'timeout', question: '把订单明细全拉出来', phase: 'error', steps: decodeRun(timeoutRun('done')),
+                runId: 'syn-timeout', error: { error: '查询超过 30s 没有返回，已放弃等待（数据库那边可能还在跑，连接会在后台收回）。加上 WHERE 条件或 LIMIT 缩小范围再查' } }]
+    case 'abandoned':
+      return [{ id: 'abandoned', question: '把这份报表发出去', phase: 'done', statusCode: 'cancelled',
+                steps: decodeRun(abandonedRun()), runId: 'syn-abandoned' }]
+    case 'structured':
+      // 页面已经把报错拆好了（问数据页的 Failure）：照原样画，不再翻译一遍
+      return [{ id: 'structured', question: '上周各区域订单数', phase: 'error', steps: [],
+                error: { title: '操作超时', reason: '查询超时：数据库 90 秒没有返回', hint: '缩小时间范围后点「重试这一轮」',
+                         detail: 'OperationalError: (3024) maximum statement execution time exceeded' } }]
+    case 'restored':
+      // 从库里恢复的一轮：没有事件，查询次数由页面从落库的 meta 带过来
+      return [{ id: 'restored', question: '上周各区域订单数', phase: 'done', steps: [], queries: 3, elapsedMs: 8400,
+                output: { answer: '华东 1,204 单，华南 986 单，华北 731 单。' }, runId: 'syn-restored' }]
+    case 'tools-dropped':
+      return [{ id: 'tools-dropped', question: '只查上月的数据', phase: 'done', status: '已更新画布（修改 1）',
+                tone: 'warn', steps: decodeCopilot(COPILOT_TOOLS_DROPPED, { context: 'canvas' }) }]
     default:
       return []
   }
diff --git a/frontend/src/dev/ui-harness.tsx b/frontend/src/dev/ui-harness.tsx
index 1f751b33..77bcb46f 100644
--- a/frontend/src/dev/ui-harness.tsx
+++ b/frontend/src/dev/ui-harness.tsx
@@ -2,10 +2,11 @@ import { useEffect, useState } from 'react'
 import type { ReactNode } from 'react'
 import { createRoot } from 'react-dom/client'
 import { BrowserRouter } from 'react-router-dom'
-import { Inbox, Plus, Trash2, RefreshCw } from 'lucide-react'
+import { Database, Inbox, Plus, Trash2, RefreshCw } from 'lucide-react'
 import {
-  EmptyState, ErrorState, Field, IconButton, Kbd, Modal, OfflineBanner, Skeleton, StatusBadge,
-  StatusPill, Tabs, TabPanel, ToastHost, confirmDialog, promptDialog, toast,
+  DeleteButton, EmptyState, ErrorState, Field, HealthPill, IconButton, Kbd, Modal, OfflineBanner, PageHeader,
+  SectionBar, Skeleton, StatusBadge, StatusPill, Tabs, TabPanel, ToastHost, confirmDialog, deferDelete,
+  promptDialog, toast, useRadioGroup, withoutDeferred,
 } from '../components/ui'
 import { ApiError, api } from '../api/client'
 import { useCatalog, useOnReconnect } from '../store/catalog'
@@ -16,6 +17,8 @@ import * as status from '../lib/status'
 import * as keys from '../lib/keys'
 import * as terms from '../lib/terms'
 import * as errors from '../lib/errors'
+import * as explain from '../lib/explain'
+import * as health from '../lib/health'
 import '../index.css'
 
 /**
@@ -101,6 +104,63 @@ function LocalListDemo() {
   )
 }
 
+const DEMO_ROWS = [
+  { id: 'orders', name: 'orders' }, { id: 'sales_daily', name: 'sales_daily' }, { id: 'hr_attendance', name: 'hr_attendance' },
+]
+const RADIO = ['service_name', 'sid', 'dsn'] as const
+
+/** 管理页共用件：页头、分节、连通胶囊、单选组、删除后可撤销 */
+function ManageKitDemo() {
+  const [rows, setRows] = useState(DEMO_ROWS)
+  const [mode, setMode] = useState<(typeof RADIO)[number]>('service_name')
+  const radio = useRadioGroup(RADIO, mode, setMode)
+  const [now] = useState(() => Date.now())
+  const reload = () => setRows(withoutDeferred(DEMO_ROWS, '/api/__harness__/rows'))
+  return (
+    <div className="flex flex-col gap-3">
+      <div className="overflow-hidden rounded-lg border" id="page-header-demo">
+        <PageHeader icon={<Database size={13} />} title="数据" subtitle="接入的数据库和传上来的表格" actions={<button className="btn btn-sm">刷新</button>} />
+      </div>
+      <SectionBar title="数据库" hint="接入后助手编排时看得见这些库的结构">
+        <button className="btn btn-sm btn-primary"><Plus size={12} /> 接入数据库</button>
+      </SectionBar>
+      <div className="flex flex-wrap items-center gap-x-4 gap-y-2" id="health-demo">
+        <HealthPill />
+        <HealthPill checkingSince={now - 1200} />
+        <HealthPill record={{ ok: true, ms: 42, at: now - 3 * 60_000 }} />
+        <HealthPill record={{ ok: false, at: now - 60 * 60_000, error: '连不上：端口没开' }} />
+        <HealthPill record={{ ok: true, ms: 380, at: 0 }} stale />
+        <HealthPill record={{ ok: false, at: 0, error: '连不上：认证没通过' }} />
+      </div>
+      <div role="radiogroup" aria-label="连接方式" className="flex gap-1" id="radio-demo">
+        {RADIO.map((v) => (
+          <button key={v} type="button" className={v === mode ? 'btn btn-sm btn-primary' : 'btn btn-sm'} {...radio(v)} onClick={() => setMode(v)}>
+            {v}
+          </button>
+        ))}
+      </div>
+      <ul className="flex flex-col gap-1 text-xs" id="defer-demo">
+        {rows.map((r) => (
+          <li key={r.id} className="flex items-center gap-2" data-row={r.id}>
+            <span className="mono flex-1">{r.name}</span>
+            <DeleteButton
+              label={`删除 ${r.name}`}
+              onClick={() => deferDelete({
+                what: `「${r.name}」`,
+                url: `/api/__harness__/rows/${r.id}`,
+                hide: () => setRows((l) => l.filter((x) => x.id !== r.id)),
+                restore: reload,
+                commit: () => Promise.resolve(),
+              })}
+            />
+          </li>
+        ))}
+      </ul>
+      <button className="btn btn-sm self-start" id="defer-reload" onClick={reload}>重拉列表</button>
+    </div>
+  )
+}
+
 function Harness() {
   const [theme, setTheme] = useState<'dark' | 'light'>(() => {
     // 没有显式主题时会跟随系统；预览要确定是哪一套，开场就钉住
@@ -261,6 +321,14 @@ function Harness() {
                 action={<button className="btn btn-sm btn-primary"><Plus size={12} /> 新建工作流</button>}
               />
               <EmptyState title="没有匹配的工具" offline={false} className="py-4" />
+              <div id="empty-source-demo" className="border-t">
+                <EmptyState
+                  source="workflows"
+                  title="还没有工作流"
+                  className="py-4"
+                  action={<button className="btn btn-sm btn-primary" id="empty-source-action"><Plus size={12} /> 新建</button>}
+                />
+              </div>
             </Block>
             <Block title="出错 ErrorState">
               <ErrorState
@@ -313,6 +381,10 @@ function Harness() {
             </Block>
           </div>
 
+          <Block title="管理页共用件">
+            <ManageKitDemo />
+          </Block>
+
           <Block title="标签页 Tabs · 表单字段 Field">
             <Tabs
               label="示例标签"
@@ -339,7 +411,7 @@ function Harness() {
 ;(window as any).__ui = {
   toast, confirmDialog, promptDialog, useCatalog, ApiError, api,
   // 检查脚本直接拿应用同一份模块实例测 lib：instanceof ApiError 才靠得住
-  lib: { format, status, keys, terms, errors },
+  lib: { format, status, keys, terms, errors, explain, health },
 }
 
 createRoot(document.getElementById('root')!).render(
diff --git a/frontend/src/index.css b/frontend/src/index.css
index b941cf2a..c553c8a2 100644
--- a/frontend/src/index.css
+++ b/frontend/src/index.css
@@ -589,17 +589,45 @@
   overflow: hidden;
   text-overflow: ellipsis;
 }
+/* 跑完了但有要留意的事：降档交付、收尾时还想调工具 */
+.nc-tele-note.is-warn {
+  color: var(--st-waiting);
+}
+/* 工具调用超出了后端声明的时限：只有这时才上色，平常是安静的「⋯」 */
+.nc-over {
+  color: var(--st-waiting);
+  font-family: var(--font-sans);
+  font-weight: 600;
+}
 .nc-tele-side {
   display: flex;
-  flex: none;
+  flex: 0 1 auto;
+  min-width: 0;
   align-items: center;
   gap: 7px;
   font-family: var(--font-mono);
 }
+.nc-tele-side > * {
+  flex: none;
+}
+/* 在跑的工具名可以很长（db_query__warehouse）：只有它让位，截成省略号 */
+.nc-tele-side > .nc-tools {
+  flex: 0 1 auto;
+  min-width: 0;
+}
 .nc-tools {
   display: inline-flex;
   align-items: center;
   gap: 2px;
+  white-space: nowrap;
+}
+.nc-tools > svg {
+  flex: none;
+}
+.nc-tool-name {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
 }
 .nc-tools.is-live {
   color: var(--st-running);
@@ -1347,9 +1375,24 @@
 }
 .team-head-rule {
   flex: 1;
+  min-width: 6px;
   height: 1px;
   background: linear-gradient(to right, var(--hairline), transparent);
 }
+.team-head-right {
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+/* 用完轮数仍未完成：失败是红、降档交付是琥珀。平常的表头是安静的灰 */
+.team-head-right.is-err {
+  color: var(--st-failed);
+  font-weight: 600;
+}
+.team-head-right.is-warn {
+  color: var(--st-waiting);
+  font-weight: 600;
+}
 
 .team-row {
   position: relative;
@@ -1379,6 +1422,14 @@
 .team-row-past {
   opacity: 0.6;
 }
+/* 轮数用完、一次都没被派到：不压暗，左边一道琥珀虚线——它正是这次没做完的线索 */
+.team-row-never {
+  border-left: 2px dashed color-mix(in srgb, var(--st-waiting) 70%, transparent);
+}
+.team-row-never .team-name,
+.team-row-never .team-ms {
+  color: var(--st-waiting);
+}
 /* 调度者那一行：和成员分开，底下一道细线 */
 .team-row-dispatch {
   margin-bottom: 2px;
diff --git a/frontend/src/lib/errors.ts b/frontend/src/lib/errors.ts
index 701e661c..730db9a3 100644
--- a/frontend/src/lib/errors.ts
+++ b/frontend/src/lib/errors.ts
@@ -36,6 +36,8 @@ export const NETWORK_ERROR: Omit<HumanError, 'raw'> = {
 /** Python 异常类名前缀：「KeyError: 'x'」「sqlalchemy.exc.OperationalError: …」 */
 const PY_EXC_RE = /^(?:[a-z_][\w.]*\.)?([A-Z]\w*(?:Error|Exception|Exit|Timeout))\s*:\s*/
 
+const CJK_RE = /[一-鿿]/
+
 /**
  * network=false 用在「后端已经回了话」的文本上：那里面提到 fetch failed、
  * ECONNREFUSED，说的是后端够不着的下游（模型、数据库、MCP），不是我们连不上后端。
@@ -65,7 +67,9 @@ function fromText(text: string, { network = true }: { network?: boolean } = {}):
       raw,
     }
   }
-  if (/timed? ?out|timeout|超时/i.test(raw) && raw.length < 200) {
+  // 只接英文原文（「ReadTimeout: timed out」）。带中文的已经是后端写好的人话，
+  // 标题、原因、怎么办都在句子里：再套一个「操作超时」，标题和原因就说了两遍
+  if (!CJK_RE.test(raw) && /timed? ?out|timeout/i.test(raw) && raw.length < 200) {
     return { title: '操作超时', reason: raw.replace(PY_EXC_RE, ''), action: '稍后重试；反复超时就调大超时或检查下游服务。', raw }
   }
   // 类名前缀去掉，剩下的才是给人看的；类名留在 raw 里
diff --git a/frontend/src/pages/runs/explain.ts b/frontend/src/lib/explain.ts
similarity index 76%
rename from frontend/src/pages/runs/explain.ts
rename to frontend/src/lib/explain.ts
index 46e971f7..b8b1856d 100644
--- a/frontend/src/pages/runs/explain.ts
+++ b/frontend/src/lib/explain.ts
@@ -1,7 +1,7 @@
 /**
  * 失败运行的「为什么 + 怎么办」。
  *
- * 新后端的 run.error 已经是人话（engine/errors.py），但库里大量老运行留的是原始
+ * 新后端的 run.error 已经是人话（后端 app/core/errors.py），但库里大量老运行留的是原始
  * 异常：「NodeError: AnthropicModelNotFoundError: Error code: 404 - {…}」「_make_
  * query_tool.<locals>._run() got an unexpected keyword argument」。排错的人要的是
  * 哪个节点、为什么、下一步点哪里，所以这里按库里真实出现过的失败归类，并说清
@@ -9,10 +9,12 @@
  * 这个按钮。
  *
  * 归类之外的一律交给 lib/errors 的 humanizeError（去掉异常类名、拆标题和原因）。
- * 这份规则应当和助手流的报错行共用，先放在记录页，见 requests。
+ *
+ * 记录页的失败横幅、列表行，助手流的报错行、失败的步骤，问数据页的失败轮次都读
+ * 这一份：同一次失败在三处说法不一，人就不知道该信哪句、该点哪个按钮。
  */
 
-import { humanizeError } from '../../lib/errors'
+import { humanizeError } from './errors'
 
 export type FixKind = 'settings' | 'canvas' | 'rerun' | 'tools'
 
@@ -59,6 +61,56 @@ export function explainRunError(error: string | null | undefined, detail?: strin
   if (!text) {
     return { title: '运行失败，但没有留下原因', action: '打开「原始事件」看最后几条记录。', continuable: true, raw }
   }
+  // 下面四类是「图本身有缺口」：模型没真调工具、团队轮数用完、校验修复想凑数、
+  // 提示词点名的工具没绑定。原样接着跑是同一份配置，只会再来一遍，所以都不给
+  // 「接着跑」，指到画布上去改
+  if (/没有真正调用工具|工具调用的原始标记|tool_markup_leak/.test(text)) {
+    return {
+      title: '模型没有真正调用工具',
+      reason: '它把工具调用当成文字写了出来，这一步一次都没查到数据。常见原因是节点没有绑定工具，或者模型、服务不支持工具调用。',
+      action: '到画布里确认这个节点绑定了要用的工具；绑定了还这样，就换一个支持工具调用的模型。改完再运行。',
+      continuable: false,
+      fix: 'canvas',
+      raw,
+    }
+  }
+  const exhausted = plain.match(/用完\s*(\d+)\s*轮(?:仍|还)?未完成[：:]?\s*(.*)/s)
+  if (exhausted || /team_exhausted/.test(text)) {
+    return {
+      title: exhausted ? `协作团队用完 ${exhausted[1]} 轮仍未完成` : '协作团队用完了轮数仍未完成',
+      reason: exhausted?.[2]?.trim() || '调度者一直没有判定完成，成员的原话不能当作结论交出去。',
+      action: '到画布里看看成员有没有绑定要用的工具，再调大这个团队的最多轮数；也可以把「用完轮数时」改成降档交付。',
+      continuable: false,
+      fix: 'canvas',
+      raw,
+    }
+  }
+  if (/原文没有的值|修复.*编造/.test(text)) {
+    const values = plain.match(/原文没有的值[：:]\s*([^\n。]+)/)?.[1]?.trim()
+    return {
+      title: '校验修复被拒绝：修复结果里出现了原文没有的值',
+      reason: `上游产出里没有这些数据${values ? `（${values}）` : ''}，修复不许凑数，这次校验判为失败。`,
+      action: '先看上游节点为什么没拿到数据（常见是没有绑定查询工具），改好后重新运行。',
+      continuable: false,
+      fix: 'canvas',
+      raw,
+    }
+  }
+  // 节点和协作成员两种说法：「…但节点没有绑定它」「成员「X」的…但没有给这个成员绑定它」
+  const unbound = plain.match(/提示词要求用\s*「?([^」，,\s]+?)」?\s*[，,]?\s*但(?:节点)?没有(?:给这个成员)?绑定/)
+  if (unbound) {
+    const member = plain.match(/成员「([^」]+)」的提示词/)?.[1]
+    return {
+      title: member
+        ? `成员「${member}」的提示词要求用「${unbound[1]}」，但没有给它绑定`
+        : `提示词要求用「${unbound[1]}」，但节点没有绑定它`,
+      reason: '运行时模型拿不到这个工具，只能编一个结果出来。',
+      action: '到画布里给这个节点绑定该工具，或者改掉提示词里的要求。',
+      continuable: false,
+      fix: 'canvas',
+      raw,
+    }
+  }
   if (/人工驳回/.test(text)) {
     return {
       title: '人工审批驳回，运行终止',
diff --git a/frontend/src/lib/format.ts b/frontend/src/lib/format.ts
index acb71a70..65927833 100644
--- a/frontend/src/lib/format.ts
+++ b/frontend/src/lib/format.ts
@@ -170,6 +170,18 @@ export function formatRelative(v: string | number | Date | null | undefined, now
   return formatTime(d, now)
 }
 
+/** 文件大小：「820 B」「12.4 KB」「3.1 MB」「1.2 GB」 */
+export function formatBytes(n: number | null | undefined): string {
+  if (!isNum(n) || n < 0) return NONE
+  if (n < 1024) return `${Math.round(n)} B`
+  if (n < 1024 ** 2) return `${(n / 1024).toFixed(1)} KB`
+  if (n < 1024 ** 3) return `${(n / 1024 ** 2).toFixed(1)} MB`
+  return `${(n / 1024 ** 3).toFixed(1)} GB`
+}
+
+/** 去掉名字后面括号里的补充说明：「OpenAI 兼容（DeepSeek、通义…）」→「OpenAI 兼容」 */
+export const shortLabel = (label?: string | null): string => (label ?? '').replace(/[（(].*$/, '').trim()
+
 /** 短 id：「#66a5a6」。完整 id 放 title，点击复制由调用方决定 */
 export function shortId(id: string | null | undefined, len = 6): string {
   if (!id) return NONE
diff --git a/frontend/src/lib/health.ts b/frontend/src/lib/health.ts
new file mode 100644
index 00000000..aea4bfe8
--- /dev/null
+++ b/frontend/src/lib/health.ts
@@ -0,0 +1,133 @@
+import { useSyncExternalStore } from 'react'
+import { toast } from '../components/ui'
+import type { ServerHealth } from '../types'
+import { humanizeError } from './errors'
+import { parseServerTime } from './format'
+
+/**
+ * 连没连上：统一、持久的状态。
+ *
+ * 一次「测连接」的结果按 `种类:id` 存：模型接入 provider:<id>、数据源
+ * datasource:<id>、MCP mcp:<id>。
+ *
+ * 以前测完只弹 4 秒 toast，结果存在组件 state 里，切个标签就没了；卡片上的圆点
+ * 又各说各的（模型卡的绿点其实是「启用」）。管理页最核心的问题是「现在能不能
+ * 用」，答案得留在对象上，并注明是什么时候测的。
+ *
+ * 模块级而不是组件 state：切标签、换页都还在。再写一份到 localStorage，刷新
+ * 也还在——只是这台浏览器的缓存，所以一律带上「几分钟前测的」。后端也记着上次
+ * 的结果时（列表接口里的 last_check_*），用 healthFromServer 取出来当初值，
+ * useHealth 取两边较新的那份。
+ */
+export interface HealthRecord {
+  ok: boolean
+  /** 往返毫秒 */
+  ms?: number | null
+  /** 测的时刻（ms）。0 = 知道结果、不知道是什么时候测的 */
+  at: number
+  error?: string
+  hint?: string
+  detail?: string
+  /** 成功时的补充：用的哪个模型、回了什么 */
+  note?: string
+}
+
+const HEALTH_KEY = 'agentlab.health'
+
+/**
+ * 后端记着的上次结果（列表接口里平铺的 last_check_* 四个字段）→ HealthRecord。
+ * 没测过、或者连接配置改过之后后端给的全是 null，这里返回 undefined。
+ * 测的时刻解析不出来时 at 为 0：知道结果，不写「几分钟前测」
+ */
+export function healthFromServer(o: ServerHealth | null | undefined): HealthRecord | undefined {
+  if (!o || typeof o.last_check_ok !== 'boolean') return undefined
+  return {
+    ok: o.last_check_ok,
+    ms: o.last_latency_ms ?? null,
+    at: parseServerTime(o.last_checked_at)?.getTime() ?? 0,
+    ...(o.last_error ? { error: o.last_error } : {}),
+  }
+}
+
+function readHealth(): Record<string, HealthRecord> {
+  try {
+    const raw = JSON.parse(localStorage.getItem(HEALTH_KEY) ?? '{}')
+    return raw && typeof raw === 'object' ? raw : {}
+  } catch {
+    return {}
+  }
+}
+
+let healthSnap: { records: Record<string, HealthRecord>; checking: Record<string, number> } = {
+  records: readHealth(), checking: {},
+}
+const healthListeners = new Set<() => void>()
+const subscribeHealth = (l: () => void) => {
+  healthListeners.add(l)
+  return () => { healthListeners.delete(l) }
+}
+function emitHealth(next: Partial<typeof healthSnap>, persist = false) {
+  healthSnap = { ...healthSnap, ...next }
+  if (persist) {
+    try { localStorage.setItem(HEALTH_KEY, JSON.stringify(healthSnap.records)) } catch { /* 隐私模式：只是刷新后不记得 */ }
+  }
+  healthListeners.forEach((l) => l())
+}
+
+/**
+ * 某个对象最近一次的测连接结果，以及是不是正在测。
+ *
+ * server 是后端记着的那份（healthFromServer 的结果）：换了台浏览器、清了缓存也
+ * 还在。两份都有时取测得晚的那份——本机刚测过的比后端上次记的新。
+ */
+export function useHealth(key: string, server?: HealthRecord | null): { record?: HealthRecord; checkingSince?: number } {
+  const snap = useSyncExternalStore(subscribeHealth, () => healthSnap, () => healthSnap)
+  const local = snap.records[key]
+  const record = !server ? local : !local ? server : server.at > local.at ? server : local
+  return { record, checkingSince: snap.checking[key] }
+}
+
+export function setHealth(key: string, record: HealthRecord) {
+  emitHealth({ records: { ...healthSnap.records, [key]: record } }, true)
+}
+
+export function forgetHealth(key: string) {
+  const { [key]: _gone, ...rest } = healthSnap.records
+  emitHealth({ records: rest }, true)
+}
+
+/**
+ * 测一次并记下结果。run 返回后端的 {ok, error, hint, detail}；ms 和 note 由调用方
+ * 从各自的字段里取（latency_ms / elapsed_ms）。
+ *
+ * 后端本身够不着时不记：那说的是「我们连不上后端」，不是这个库或模型坏了，
+ * 记成它的失败就是冤枉它。只弹 toast。
+ */
+export async function checkHealth(
+  key: string,
+  run: () => Promise<Omit<HealthRecord, 'at'>>,
+): Promise<HealthRecord | null> {
+  if (healthSnap.checking[key]) return null
+  emitHealth({ checking: { ...healthSnap.checking, [key]: Date.now() } })
+  let record: HealthRecord | null = null
+  try {
+    record = { ...(await run()), at: Date.now() }
+  } catch (e) {
+    const h = humanizeError(e)
+    if (h.kind === 'network') {
+      toast.error(e)
+    } else {
+      record = {
+        ok: false, at: Date.now(),
+        error: h.reason ? `${h.title}：${h.reason}` : h.title, hint: h.action, detail: h.raw,
+      }
+    }
+  } finally {
+    const { [key]: _done, ...checking } = healthSnap.checking
+    emitHealth({
+      checking,
+      ...(record ? { records: { ...healthSnap.records, [key]: record } } : {}),
+    }, !!record)
+  }
+  return record
+}
diff --git a/frontend/src/lib/leave.ts b/frontend/src/lib/leave.ts
new file mode 100644
index 00000000..5d4af95c
--- /dev/null
+++ b/frontend/src/lib/leave.ts
@@ -0,0 +1,168 @@
+/**
+ * 离开前确认：页面有没保存的改动时登记一道守卫，站内的每一次换页都先经过它——
+ * 左侧导航、页面里的链接、⌘K、⌥ 数字、浏览器前进后退、代码里的 navigate()——
+ * 关页和刷新也会让浏览器问一句。
+ *
+ * 以前设置页自己在捕获阶段拦 <a> 的点击：⌘K 和快捷键直接调 navigate()，浏览器
+ * 后退也不走 <a>，改到一半的表单照样丢。路由换成 data router 之后，react-router 的
+ * useBlocker 拦得住所有换页；但一个 router 同时只认一个 blocker，所以由外壳挂唯一
+ * 那一个（useLeaveBlocker），页面只往这里登记，别自己调 useBlocker。
+ *
+ *   useLeaveGuard(dirty > 0, () => confirmDialog({ title: `有 ${dirty} 项设置还没保存`, … }))
+ */
+import { useEffect, useRef } from 'react'
+import { NavigationType, parsePath, useBlocker } from 'react-router-dom'
+import type { BlockerFunction, NavigateOptions, Path } from 'react-router-dom'
+
+export interface LeaveGuard {
+  /**
+   * 这一次换页要不要拦。next 为 null 表示去向还没定（canLeave() 不带目标时）。
+   * 默认：路径变了就拦；只改 ?query 或 #hash 不算，同一页里换个筛选不会丢表单
+   */
+  blocks?: (next: Path | null, current: Path) => boolean
+  /** 拦下之后怎么问：true 放行，false 留下。抛错按留下算 */
+  confirm: (next: Path | null) => Promise<boolean>
+  /** 关页、刷新时要不要让浏览器问一句，默认要。浏览器只给通用文案，写不了自己的话 */
+  unload?: boolean
+}
+
+const guards = new Set<LeaveGuard>()
+
+const pathChanged = (next: Path | null, current: Path) => next == null || next.pathname !== current.pathname
+
+function blocking(next: Path | null, current: Path): LeaveGuard[] {
+  return [...guards].filter((g) => {
+    try {
+      return (g.blocks ?? pathChanged)(next, current)
+    } catch {
+      return true
+    }
+  })
+}
+
+const onBeforeUnload = (e: BeforeUnloadEvent) => {
+  e.preventDefault()
+  e.returnValue = ''
+}
+let unloadOn = false
+
+/** 只在有守卫时挂 beforeunload：常驻的监听会让浏览器的往返缓存失效 */
+function syncUnload() {
+  const want = [...guards].some((g) => g.unload !== false)
+  if (want === unloadOn || typeof window === 'undefined') return
+  unloadOn = want
+  if (want) window.addEventListener('beforeunload', onBeforeUnload)
+  else window.removeEventListener('beforeunload', onBeforeUnload)
+}
+
+/** 登记一道守卫，返回撤销函数。组件里用 useLeaveGuard，它管登记和撤销的时机 */
+export function registerLeaveGuard(guard: LeaveGuard): () => void {
+  guards.add(guard)
+  syncUnload()
+  return () => {
+    guards.delete(guard)
+    syncUnload()
+  }
+}
+
+/** 一道一道地问：同时弹两个确认框，人不知道先答哪个。有一道说留下就留下 */
+async function ask(list: LeaveGuard[], next: Path | null): Promise<boolean> {
+  for (const g of list) {
+    let ok = false
+    try {
+      ok = await g.confirm(next)
+    } catch {
+      ok = false
+    }
+    if (!ok) return false
+  }
+  return true
+}
+
+const here = (): Path => ({ pathname: location.pathname, search: location.search, hash: location.hash })
+
+/**
+ * 有没保存的改动时拦住离开。active 为 false 时什么都不登记。
+ * confirm、blocks 每次渲染取最新的，不必包 useCallback。
+ */
+export function useLeaveGuard(
+  active: boolean,
+  confirm: (next: Path | null) => Promise<boolean>,
+  opts?: Pick<LeaveGuard, 'blocks' | 'unload'>,
+): void {
+  const latest = useRef({ confirm, blocks: opts?.blocks })
+  latest.current = { confirm, blocks: opts?.blocks }
+  const unload = opts?.unload
+  useEffect(() => {
+    if (!active) return
+    return registerLeaveGuard({
+      confirm: (next) => latest.current.confirm(next),
+      blocks: (next, current) => (latest.current.blocks ?? pathChanged)(next, current),
+      unload,
+    })
+  }, [active, unload])
+}
+
+/**
+ * 先问、再做。「新对话」「新建工作流」要先建出东西、建完才跳：等到跳的时候才问，
+ * 人点了「留下」，东西已经建出来了。所以先问一遍；问过之后的那次跳转带上
+ * leavePass()，不再问第二遍。没有拦着的守卫就直接是 true。
+ * to 省略表示去向还没定：只要有守卫在就问。
+ */
+export function canLeave(to?: string): Promise<boolean> {
+  const next = to == null ? null : { pathname: '/', search: '', hash: '', ...parsePath(to) }
+  const list = blocking(next, here())
+  return list.length ? ask(list, next) : Promise.resolve(true)
+}
+
+const PASS = '__leaveConfirmed'
+
+/** 给 canLeave() 问过的那一次跳转放行：navigate(to, leavePass(opts)) */
+export function leavePass<T extends NavigateOptions>(opts?: T): T {
+  const state = opts?.state && typeof opts.state === 'object' ? opts.state : {}
+  return { ...opts, state: { ...state, [PASS]: true } } as T
+}
+
+/** 拦下时那几道守卫：问的时候就问它们，不再重新挑（后退时地址已经变过一次了） */
+let held: LeaveGuard[] = []
+
+const shouldBlock: BlockerFunction = ({ currentLocation, nextLocation, historyAction }) => {
+  // 后退前进不认通行证：它存在历史记录的 state 里，退回那一条时还在
+  if (historyAction !== NavigationType.Pop && (nextLocation.state as Record<string, unknown> | null)?.[PASS]) return false
+  held = blocking(nextLocation, currentLocation)
+  return held.length > 0
+}
+
+/**
+ * 外壳挂一次（App 里）。一个 router 同时只认一个 blocker：页面别自己调 useBlocker，
+ * 用 useLeaveGuard 登记。
+ */
+export function useLeaveBlocker(): void {
+  const blocker = useBlocker(shouldBlock)
+  const latest = useRef(blocker)
+  latest.current = blocker
+  // 正在问的是哪一次：StrictMode 下 effect 会跑两遍，同一次别问两回
+  const asking = useRef<string | null>(null)
+  useEffect(() => {
+    if (blocker.state !== 'blocked') {
+      asking.current = null
+      return
+    }
+    const key = blocker.location.key
+    if (asking.current === key) return
+    asking.current = key
+    void ask(held, blocker.location).then((ok) => {
+      const b = latest.current
+      // 问的时候人又点了别处（比如又按了后退），这一问就作废，归新的那次
+      if (b.state !== 'blocked' || b.location.key !== key) return
+      if (ok) b.proceed()
+      else b.reset()
+    })
+  }, [blocker])
+}
+
+// 开发期挂到 window 上，好让 check-shell 登记一道测试守卫，看各条换页的路都拦得住。
+// 生产构建里去掉
+if (import.meta.env.DEV && typeof window !== 'undefined') {
+  ;(window as any).__leave = { register: registerLeaveGuard, count: () => guards.size }
+}
diff --git a/frontend/src/lib/mentions.ts b/frontend/src/lib/mentions.ts
new file mode 100644
index 00000000..48093b84
--- /dev/null
+++ b/frontend/src/lib/mentions.ts
@@ -0,0 +1,21 @@
+import type { Workflow } from '../types'
+
+/**
+ * 图里引用了这些名字（工具名、模型 id）的工作流。按 JSON 里的整串值匹配，不做子串：
+ * 删一个叫 db_query 的工具，不该把只用了 db_query__shop 的工作流也算进来。
+ * 删除、停用之前先说清会波及谁。
+ */
+export function workflowsMentioning(workflows: Workflow[], tokens: string[]): Workflow[] {
+  const needles = tokens.filter(Boolean).map((t) => JSON.stringify(t))
+  if (!needles.length) return []
+  return workflows.filter((w) => {
+    const text = JSON.stringify(w.graph ?? {})
+    return needles.some((n) => text.includes(n))
+  })
+}
+
+/** 「3 个工作流（「周报」「巡检」 等）」 */
+export function workflowList(list: Workflow[], max = 3): string {
+  const names = list.slice(0, max).map((w) => `「${w.name}」`).join('')
+  return `${list.length} 个工作流（${names}${list.length > max ? ' 等' : ''}）`
+}
diff --git a/frontend/src/main.tsx b/frontend/src/main.tsx
index 0377dbec..d0eca76c 100644
--- a/frontend/src/main.tsx
+++ b/frontend/src/main.tsx
@@ -1,16 +1,29 @@
 import { StrictMode } from 'react'
 import { createRoot } from 'react-dom/client'
-import { BrowserRouter } from 'react-router-dom'
+import { RouterProvider, createBrowserRouter } from 'react-router-dom'
 import App from './App'
-import { ToastHost } from './components/ui'
+import { ErrorBoundary, ToastHost } from './components/ui'
 import './index.css'
 
+// data router：离开前确认（lib/leave）靠它的 useBlocker 才拦得住 navigate() 和浏览器
+// 后退。路由表仍在 App 里用 <Routes> 写，这里只挂一条通配。
+// ErrorBoundary 兜住外壳自己（导航、信号）出的错：页面的错 App 里那一层先接住；
+// 不兜的话落到 react-router 默认的英文报错页
+const router = createBrowserRouter([
+  {
+    path: '*',
+    element: (
+      <ToastHost>
+        <ErrorBoundary>
+          <App />
+        </ErrorBoundary>
+      </ToastHost>
+    ),
+  },
+])
+
 createRoot(document.getElementById('root')!).render(
   <StrictMode>
-    <BrowserRouter>
-      <ToastHost>
-        <App />
-      </ToastHost>
-    </BrowserRouter>
+    <RouterProvider router={router} />
   </StrictMode>,
 )
diff --git a/frontend/src/pages/ChatPage.tsx b/frontend/src/pages/ChatPage.tsx
index 4f5dc14a..c7ffc507 100644
--- a/frontend/src/pages/ChatPage.tsx
+++ b/frontend/src/pages/ChatPage.tsx
@@ -1,8 +1,8 @@
 import { useEffect, useMemo, useRef, useState, type CSSProperties, type ReactNode, type RefObject } from 'react'
 import { Link, useNavigate, useParams } from 'react-router-dom'
 import {
-  AlertCircle, ArrowRight, BookOpen, ChevronRight, CloudOff, Database, History, ListTree, MessageSquare,
-  PenLine, Play, RotateCw, StepForward, Wrench,
+  AlertCircle, ArrowRight, BookOpen, Check, ChevronDown, ChevronRight, CloudOff, Database, History, ListTree,
+  MessageSquare, PenLine, Play, RotateCw, StepForward, Trash2, Wrench,
 } from 'lucide-react'
 import clsx from 'clsx'
 import { ApiError, api } from '../api/client'
@@ -10,15 +10,17 @@ import { ApprovalCard } from '../run/RunPanel'
 import { AssistantStream, type StreamTurn } from '../run/AssistantStream'
 import { PromptBox } from '../run/Composer'
 import { decodeCopilot, decodeRun } from '../run/decode'
-import { CopyButton, Skeleton, Spinner, StatusBadge, toast } from '../components/ui'
+import { isComposing, PageHeader, Skeleton, Spinner, StatusBadge, TechDetails, toast } from '../components/ui'
 import { humanizeError } from '../lib/errors'
 import { formatNumber, formatTime } from '../lib/format'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import {
-  agentSteps, busyTurn, isBusy, stepsVisible, useChat, type Attempt, type ChatTurn,
+  agentSteps, busyTurn, isBusy, stepsVisible, useChat, type Attempt, type ChatTurn, type Failure, type ScopeSource,
 } from '../store/chat'
 import { lastVisited, useConversations } from '../store/conversations'
-import { ConversationList } from './ConversationList'
+import {
+  ConversationList, purgeConversation, restoreConversation, RUNNING_NO_DELETE, stillRunning,
+} from './ConversationList'
 
 /**
  * 对话式入口。
@@ -34,7 +36,7 @@ import { ConversationList } from './ConversationList'
  * dense 一个开关。两边各写一套的话，同一次运行在两个页面会讲出不同的故事。
  */
 export function ChatPage() {
-  const { ask, stop, load, hydrate } = useChat()
+  const { ask, stop, load, hydrate, recheck, setScope } = useChat()
   const { conversationId } = useParams()
   const navigate = useNavigate()
   const currentId = useConversations((s) => s.currentId)
@@ -47,11 +49,18 @@ export function ChatPage() {
   const loadError = useChat((s) => (currentId ? s.loadError[currentId] : undefined))
   const byConversation = useChat((s) => s.byConversation)
   const backend = useCatalog((s) => s.backend)
+  // 在回收站里的对话可以点开看，但不能接着问：问了它也还在回收站里，左栏找不到
+  const trashed = useConversations((s) => (currentId ? s.trash.find((c) => c.id === currentId) : undefined))
+  const scopeKey = currentId ?? ''
+  const scope = useChat((s) => s.scopes[scopeKey]) ?? NO_SCOPE
   const [draft, setDraft] = useState('')
   const [tip, setTip] = useState<string | null>(null)
   const inputRef = useRef<HTMLTextAreaElement>(null)
   const sources = useDataSources()
+  // 停用的库后端不给查（限定了它会被 400 拒掉），范围里只摆启用着的
+  const usable = useMemo(() => sources.list.filter((s) => s.enabled !== false), [sources.list])
   const refreshCatalog = useCatalog((s) => s.refresh)
+  const pickScope = (next: ScopeSource[]) => setScope(scopeKey, next)
 
   // URL → store。这是 currentId 唯一的写入口，别处一律靠导航
   useEffect(() => { select(conversationId ?? null) }, [conversationId, select])
@@ -103,10 +112,26 @@ export function ChatPage() {
     if (st.loadState[currentId] === 'error') void load(currentId, { force: true })
     for (const t of st.byConversation[currentId] ?? []) {
       if (t.phase === 'checking' && !t.hydrated) void hydrate(currentId, t.id)
+      if (t.phase === 'unknown') void recheck(currentId, t.id)
     }
   })
 
+  // 范围里的库不在了（删了、停用了）：从范围里拿掉并说一声。不拿掉的话下一问会被
+  // 后端 400 拒掉；悄悄拿掉的话，人以为还只查那个库
+  useEffect(() => {
+    if (sources.state !== 'ready' || !scope.length) return
+    const alive = new Set(usable.map((s) => s.id))
+    const gone = scope.filter((s) => !alive.has(s.id))
+    if (!gone.length) return
+    const left = scope.filter((s) => alive.has(s.id))
+    setScope(scopeKey, left)
+    toast.info(`数据源「${gone.map((s) => s.name).join('、')}」已经删掉或停用了，`
+      + (left.length ? '已经从这个对话的范围里拿掉' : '这个对话改回不限数据源'))
+  }, [sources.state, usable, scope, scopeKey, setScope])
+
   const busy = busyTurn(turns)
+  // 回收站里接回了一次还活着的运行：和列表里一样，停下来之前不给彻底删除
+  const trashBusy = !!trashed && stillRunning(trashed, turns)
   // 另一个会话在跑：这里照样能问（各跑各的），但得让人知道那边没停
   const elsewhere = useMemo(() => {
     for (const [id, ts] of Object.entries(byConversation)) {
@@ -119,6 +144,7 @@ export function ChatPage() {
 
   const blocked = loadState === 'loading' ? '正在取回这个对话的历史…'
     : loadState === 'error' ? '历史没取回来，先点上面的「重试」'
+    : trashed ? '这个对话在回收站里，恢复之后才能接着问'
     : backend === 'down' ? '后端没连上，这会儿发不出去'
     : null
 
@@ -135,9 +161,14 @@ export function ChatPage() {
         return
       }
     }
+    // 首屏上点过的范围跟着带进新建出来的会话，首屏那份用完就清掉
+    if (!currentId) {
+      setScope(id, scope)
+      setScope('', [])
+    }
     // 地址要跟上，否则内容已经在新对话里、地址栏还停在 /chat
     if (id !== currentId) navigate(`/chat/${id}`, { replace: true })
-    if (!ask(id, q)) return
+    if (!ask(id, q, { scope })) return
     setDraft('')
     setTip(null)
   }
@@ -172,6 +203,13 @@ export function ChatPage() {
       : !turns?.length ? 'hero'
       : 'stream'
 
+  // 库列表还在取、或者没取回来时也挂着：从上一问接过来的范围照样会发出去，得看得见。
+  // 没东西可摆时它自己不画
+  const picker = usable.length > 0 || scope.length > 0 || sources.state !== 'ready'
+    ? <ScopePicker sources={usable} scope={scope} onChange={pickScope}
+                   unconfirmed={sources.state === 'loading' ? '正在确认' : sources.state === 'error' ? '没取到状态' : undefined} />
+    : undefined
+
   const dock = (
     <div className="shrink-0 border-t px-4 pb-3 pt-2">
       <div className="mx-auto max-w-3xl">
@@ -199,6 +237,7 @@ export function ChatPage() {
           blocked={blocked}
           label="向数据提问"
           placeholder="问点什么…"
+          leading={picker}
         />
       </div>
     </div>
@@ -209,6 +248,10 @@ export function ChatPage() {
     body = (
       <ChatHero
         sources={sources}
+        usable={usable}
+        scope={scope}
+        onScope={pickScope}
+        picker={picker}
         inputRef={inputRef}
         draft={draft}
         setDraft={setDraft}
@@ -235,11 +278,12 @@ export function ChatPage() {
     body = (
       <AssistantStream
         turns={streamTurns}
-        approvalsFor={(t) => <TurnExtras turnId={t.id} />}
+        approvalsFor={(t) => <TurnExtras turnId={t.id} readOnly={!!trashed} />}
         renderTurnActions={(t) => {
           const turn = turns?.find((x) => x.id === t.id)
           return currentId && turn && hasRemedies(turn)
-            ? <Remedies conversationId={currentId} turnId={t.id} last={t.id === lastId} onRephrase={rephrase} />
+            ? <Remedies conversationId={currentId} turnId={t.id} last={t.id === lastId} onRephrase={rephrase}
+                        readOnly={!!trashed} />
             : null
         }}
         onFollowUp={(text) => {
@@ -271,15 +315,26 @@ export function ChatPage() {
     <div className="flex h-full">
       <ConversationList />
       <div className="flex min-w-0 flex-1 flex-col">
-        <header className="flex shrink-0 items-center gap-2 border-b px-4 py-2">
-          <MessageSquare size={14} style={{ color: 'var(--accent)' }} aria-hidden />
-          <h1 className="text-sm font-semibold">问数据</h1>
-          <span className="truncate text-2xs text-faint">
-            说需求，它自己接数据源、建流程、跑完给结论
-          </span>
-        </header>
+        <PageHeader icon={<MessageSquare size={14} />} title="问数据"
+                    subtitle="说需求，它自己接数据源、建流程、跑完给结论" />
+        {trashed && (
+          // 输入框那里也写着为什么发不出去；这里给出路，免得人再回左栏的回收站里找它
+          <div data-trash-banner="" role="status"
+               className="flex shrink-0 items-center gap-2 border-b bg-elev px-4 py-1.5 text-xs">
+            <Trash2 size={13} className="shrink-0 text-faint" aria-hidden />
+            <span className="min-w-0 flex-1 text-dim">这个对话在回收站里。可以翻看，恢复之后才能接着问。</span>
+            <button className="btn btn-xs btn-primary" onClick={() => void restoreConversation(trashed, navigate)}>
+              恢复
+            </button>
+            <button className="btn btn-xs btn-ghost text-[var(--err)]"
+                    disabled={trashBusy} title={trashBusy ? RUNNING_NO_DELETE : undefined}
+                    onClick={() => void purgeConversation(trashed, navigate)}>
+              彻底删除
+            </button>
+          </div>
+        )}
         {/* min-h-0 是关键：AssistantStream 的根是 h-full，内容一长，flex 子项的
-            min-height:auto 就不让它收缩，再加上面 37px 的页头，输入框和发送键
+            min-height:auto 就不让它收缩，再加上面 48px 的页头，输入框和发送键
             被推出视口，整页还能多滚一截 */}
         <div className="flex min-h-0 flex-1 flex-col">{body}</div>
       </div>
@@ -312,24 +367,25 @@ function toStreamTurn(turn: ChatTurn): StreamTurn {
     phase: turn.phase === 'waiting' ? 'waiting'
       : turn.phase === 'error' ? 'error'
       : live || turn.phase === 'checking' ? 'running' : 'done',
+    // 没核对上的不知道结局，用「未运行」那个空心点，不画成完成也不画成失败
     statusCode: turn.phase === 'cancelled' ? 'cancelled'
       : turn.phase === 'suspended' ? 'suspended'
-      : turn.phase === 'ready' ? 'idle'
+      : turn.phase === 'ready' || turn.phase === 'unknown' ? 'idle'
       : undefined,
-    tone: turn.phase === 'suspended' ? 'warn' : undefined,
+    tone: turn.phase === 'suspended' || turn.phase === 'unknown' ? 'warn' : undefined,
     // 进行中的写此刻在做什么；结束了的用全站统一的状态词
     status: live ? liveLine(turn)
-      : turn.phase === 'checking' || turn.phase === 'suspended' || turn.phase === 'ready' ? turn.status
-      : undefined,
+      : turn.phase === 'checking' || turn.phase === 'suspended' || turn.phase === 'ready' || turn.phase === 'unknown'
+        ? turn.status
+        : undefined,
     // 从库里恢复、还没点开「执行过程」的轮次只有问题和答案；点开后又收起的，
     // 步骤留在内存里但不画
     steps: stepsVisible(turn) ? [...decodeCopilot(turn.ops), ...decodeRun(turn.events, turn.final)] : [],
     thinking: turn.thinking,
     output: turn.output,
-    // 结构化的交给流里的报错块：原因、怎么办分开写，原文收进技术细节
-    error: turn.phase === 'error' && f
-      ? { error: f.source ?? (f.reason ? `${f.title}：${f.reason}` : f.title), hint: f.hint, detail: f.detail }
-      : turn.error || undefined,
+    error: turn.phase === 'error' && f ? streamError(turn, f) : turn.error || undefined,
+    // 事件没取回来时头部的「N 次查询」靠落库的次数
+    queries: turn.meta?.queries,
     runId: turn.run?.id,
     runClass: turn.run?.run_class,
     graph: turn.graph,
@@ -345,6 +401,17 @@ function toStreamTurn(turn: ChatTurn): StreamTurn {
   return out
 }
 
+/**
+ * 交给流里报错块的那份。运行的失败交原话：报错块按 lib/explain 讲，和记录页同一套说法，
+ * 还给得出「去模型接入」这类直达入口。别的（建图失败、发起没到后端、核对不到运行）
+ * 交拆好的标题和原因，照原样画——拼成一行「标题：原因」交出去，会被当成一句原话，
+ * 整句成了粗体标题
+ */
+function streamError(turn: ChatTurn, f: Failure): StreamTurn['error'] {
+  if (f.source && turn.run?.id) return { error: f.source, detail: f.detail }
+  return { title: f.title, reason: f.reason, hint: f.hint, detail: f.detail }
+}
+
 /**
  * 进行中的那一句。模型出字时说写了多少，只在想时说想到哪了——一次模型调用
  * 常常要几十秒，以前这几十秒里只有一行不动的「正在分析…」，分不清是在写还是卡住。
@@ -375,7 +442,11 @@ function lastSentence(text: string): string {
  * 从库里恢复的轮次没有事件流——一次会话几十轮，把每轮的事件都预加载回来
  * 是几十个请求换一堆没人看的步骤。所以默认只显示问题和答案，想看过程再取。
  */
-function TurnExtras({ turnId }: { turnId: string }) {
+function TurnExtras({ turnId, readOnly }: {
+  turnId: string
+  /** 会话在回收站里：只能看，不发起运行，审批也等恢复之后再处理 */
+  readOnly: boolean
+}) {
   const conversationId = useConversations((s) => s.currentId)
   const turn = useChat((s) => (conversationId ? s.byConversation[conversationId]?.find((t) => t.id === turnId) : undefined))
   const approvals = useCatalog((s) => s.approvals)
@@ -385,15 +456,23 @@ function TurnExtras({ turnId }: { turnId: string }) {
   const runId = turn.run?.id
   const pending = runId ? approvals.filter((a) => a.run_id === runId && a.status === 'pending') : []
   const canSteps = !!turn.restored && !!runId && !BUSY.has(turn.phase)
+  const scoped = !!turn.scope?.length
 
-  if (!pending.length && !turn.pendingRun && !canSteps) return null
+  if (!pending.length && !turn.pendingRun && !canSteps && !scoped) return null
   return (
     <>
+      {/* 和「没查库」一样，写在结论前面：这个答案只看了这几个库 */}
+      {scoped && (
+        <div className="mt-2 flex items-center gap-1 text-2xs text-faint" data-turn-scope="">
+          <Database size={11} className="shrink-0" aria-hidden />
+          <span className="min-w-0 truncate">这一问只查 {turn.scope!.map((s) => s.name).join('、')}</span>
+        </div>
+      )}
       {(turn.pendingRun || canSteps) && (
         <div className="mt-2 flex flex-wrap items-center gap-1.5">
           {turn.pendingRun && (
-            <button className="btn btn-xs btn-primary" disabled={busy}
-                    title={busy ? '这个对话还有一轮在跑' : '按搭好的流程跑一次'}
+            <button className="btn btn-xs btn-primary" disabled={busy || readOnly}
+                    title={readOnly ? IN_TRASH : busy ? '这个对话还有一轮在跑' : '按搭好的流程跑一次'}
                     onClick={() => runNow(conversationId, turn.id)}>
               <Play size={11} /> 跑一下
             </button>
@@ -408,7 +487,15 @@ function TurnExtras({ turnId }: { turnId: string }) {
           )}
         </div>
       )}
-      {!!pending.length && (
+      {/* 通过了运行就接着跑：回收站里的会话左栏找不到，跑起来没人看着 */}
+      {!!pending.length && readOnly && (
+        <div className="mt-2 flex items-center gap-1.5 text-2xs text-faint" data-pending-approval="">
+          <StatusBadge status="waiting" size={11} decorative />
+          <span className="min-w-0 flex-1">这一轮停在审批上。恢复这个对话之后在这里处理，或者到「记录」的待审批里处理。</span>
+          <Link to="/runs?tab=approvals" className="shrink-0 text-[var(--accent)] hover:underline">去审批</Link>
+        </div>
+      )}
+      {!!pending.length && !readOnly && (
         <div className="mt-2 overflow-hidden rounded border" style={{ borderColor: 'var(--st-waiting)' }}>
           {pending.map((a) => (
             <ApprovalCard key={a.id} approval={a}
@@ -422,31 +509,42 @@ function TurnExtras({ turnId }: { turnId: string }) {
 
 const BUSY = new Set(['planning', 'building', 'running', 'checking'])
 
+const IN_TRASH = '这个对话在回收站里，恢复之后才能接着跑'
+
 /**
  * 补救动作，排在这一轮的卡片下面。
  *
- * 失败、结论不可用、被打断的轮次，以前只剩一行红字——真库里用户手打过「重试」
- * 「重来」「再找找」「你自己调大」，每一句都另起一轮，会话被这些噪音塞满，
+ * 失败、结论不可用、被打断的轮次，以前只剩一行红字——人只好自己再打一句「重试」
+ * 「重来」「步数调大点」，每一句都另起一轮，会话被这些噪音塞满，
  * 失败原因也读不全。这里把能做的事直接摆出来：
  *
- * - 接着跑：只给失败的、和被服务重启打断的。已取消的续不上（后端回 409）。
+ * - 接着跑：只给失败的、和被服务重启打断的。已取消的续不上（后端回 409）；缺输入、
+ *   人驳回、工具没绑这类原样接着跑还会再失败一次的也不给（lib/explain 的 continuable）。
  * - 重试这一轮：带着上一次的原因重来，上一次折叠留档，不覆盖。
- * - 重跑这一轮：取消了、中断了的，流程本身没问题，原样再跑。
+ * - 重跑这一轮：取消了、中断了、发起时没到后端的，流程本身没问题，原样再跑。
+ * - 不限数据源重试：限定的库都不在了，带着原范围重试只会再被拒一次。
  * - 放宽步数重跑：复核说步数用满了才出现，目标值写在按钮上。
  * - 换个说法：原问题填回输入框。
+ * - 重新核对：核对撞上后端出错，不知道它现在怎样。只给这一个——另起一次运行的按钮
+ *   在旧运行可能还活着的时候不能给。
  *
  * 出了什么错、为什么、怎么办由流里的报错块说（卡片顶上），这里不再重复。
  */
-function Remedies({ conversationId, turnId, last, onRephrase }: {
+function Remedies({ conversationId, turnId, last, onRephrase, readOnly }: {
   conversationId: string
   turnId: string
   /** 只有最后一轮能原地重来；更早的轮次后面已经接着问过了，原地改答案会让后面的问答失去依据 */
   last: boolean
   onRephrase: (question: string) => void
+  /**
+   * 会话在回收站里。会另起（或接着）一次运行的按钮都关掉：跑起来左栏找不到、没人看着，
+   * 却照样计费。按钮留着不藏，恢复之后能做什么一眼看得到；核对、换个说法不发起运行，照常
+   */
+  readOnly: boolean
 }) {
   const turn = useChat((s) => s.byConversation[conversationId]?.find((t) => t.id === turnId))
   const busy = useChat((s) => isBusy(s.byConversation[conversationId]))
-  const { retryTurn, continueTurn, ask } = useChat.getState()
+  const { retryTurn, continueTurn, ask, recheck, setScope } = useChat.getState()
   const cap = useStepCap()
   const [resuming, setResuming] = useState(false)
   if (!turn) return null
@@ -457,8 +555,9 @@ function Remedies({ conversationId, turnId, last, onRephrase }: {
   const current = agentSteps(turn.graph)
   const target = current && cap ? Math.min(cap, Math.max(current * 2, current + 8)) : null
   const canContinue = !!turn.run?.id && (kind === 'suspended'
-    || (kind === 'failed' && turn.runStatus === 'failed'))
-  const busyNote = busy ? '这个对话还有一轮在跑，等它结束' : undefined
+    || (kind === 'failed' && turn.runStatus === 'failed' && turn.failure?.continuable !== false))
+  const offNote = readOnly ? IN_TRASH : busy ? '这个对话还有一轮在跑，等它结束' : undefined
+  const off = busy || readOnly
   // 异常态醒目、正常态安静：失败、中断、不可用的第一个动作是实心的
   const alarm = kind === 'failed' || kind === 'suspended' || kind === 'unusable'
 
@@ -473,45 +572,62 @@ function Remedies({ conversationId, turnId, last, onRephrase }: {
       setResuming(false)
     }
   }
-  const again = (opts?: { maxSteps?: number; rerun?: boolean }) => {
+  const again = (opts?: { maxSteps?: number; rerun?: boolean; scope?: ScopeSource[] }) => {
     if (last) retryTurn(conversationId, turn.id, opts)
-    else if (ask(conversationId, turn.question)) toast.info('已经在对话末尾用同一个问题再问了一次')
+    else if (ask(conversationId, turn.question, opts?.scope ? { scope: opts.scope } : undefined)) {
+      toast.info('已经在对话末尾用同一个问题再问了一次')
+    }
   }
 
   const buttons: ReactNode[] = []
+  if (kind === 'unknown') {
+    buttons.push(
+      <button key="recheck" className="btn btn-xs" onClick={() => void recheck(conversationId, turn.id)}
+              title="再去后端查一次这一轮的运行现在怎样了">
+        <RotateCw size={11} /> 重新核对
+      </button>,
+    )
+  }
   if (canContinue) {
     buttons.push(
-      <button key="continue" className="btn btn-xs btn-primary" disabled={busy || resuming}
-              title={busyNote ?? '从断点接着跑：前面跑过的步骤不重来。要改配置请到画布上改'}
+      <button key="continue" className="btn btn-xs btn-primary" disabled={off || resuming}
+              title={offNote ?? '从断点接着跑：前面跑过的步骤不重来。要改配置请到画布上改'}
               onClick={() => void resume()}>
         {resuming ? <Spinner size={11} /> : <StepForward size={11} />} 接着跑
       </button>,
     )
   }
-  if (kind) {
-    const plain = kind === 'cancelled' || kind === 'suspended'
-    const label = !last ? '重新问一次' : plain && graphful ? '重跑这一轮' : '重试这一轮'
+  if (kind && kind !== 'unknown') {
+    const scopeGone = !!turn.failure?.scopeGone
+    const plain = (kind === 'cancelled' || kind === 'suspended' || !!turn.failure?.rerun) && graphful
+    const label = scopeGone ? '不限数据源重试' : !last ? '重新问一次' : plain ? '重跑这一轮' : '重试这一轮'
     buttons.push(
       <button key="retry" className={clsx('btn btn-xs', alarm && !canContinue && 'btn-primary')}
-              disabled={busy}
-              title={busyNote ?? (!last ? '在对话末尾用同一个问题再问一次'
-                : plain && graphful ? '按原来的流程从头再跑一次，上一次留档可以对照'
+              disabled={off}
+              title={offNote ?? (scopeGone ? '去掉数据源限定，由它自己挑库，再问一次'
+                : !last ? '在对话末尾用同一个问题再问一次'
+                : plain ? '按原来的流程从头再跑一次，上一次留档可以对照'
                 : '带着上一次的原因重来，它会先调整流程；上一次留档可以对照')}
-              onClick={() => again(plain && graphful ? { rerun: true } : undefined)}>
+              onClick={() => {
+                if (!scopeGone) return again(plain ? { rerun: true } : undefined)
+                // 输入框左边的范围也一起放开，不然下一问又撞上同一个 400
+                setScope(conversationId, [])
+                again({ scope: [] })
+              }}>
         <RotateCw size={11} /> {label}
       </button>,
     )
   }
   if (stepSignal && last && graphful && current && target && target > current) {
     buttons.push(
-      <button key="steps" className="btn btn-xs" disabled={busy}
-              title={busyNote ?? `把 agent 的步数上限从 ${current} 调到 ${target}（全局上限 ${cap} 步，在设置里改），流程不变，重跑一次`}
+      <button key="steps" className="btn btn-xs" disabled={off}
+              title={offNote ?? `把 agent 的步数上限从 ${current} 调到 ${target}（全局上限 ${cap} 步，在设置里改），流程不变，重跑一次`}
               onClick={() => again({ maxSteps: target })}>
         <ArrowRight size={11} /> 放宽步数重跑（{current} → {target} 步）
       </button>,
     )
   }
-  if (kind) {
+  if (kind && kind !== 'unknown') {
     buttons.push(
       <button key="rephrase" className="btn btn-xs btn-ghost" onClick={() => onRephrase(turn.question)}
               title="把这个问题填回输入框，改一改再问">
@@ -520,13 +636,13 @@ function Remedies({ conversationId, turnId, last, onRephrase }: {
     )
   }
 
-  // 中断、取消在流里不出红框（它们不是故障），为什么停、停了意味着什么在这里说
-  const note = kind === 'suspended' ? turn.failure
+  // 中断、取消、没核对上在流里不出红框（它们不是故障），为什么停、停了意味着什么在这里说
+  const note = kind === 'suspended' || kind === 'unknown' ? turn.failure
     : kind === 'cancelled' ? { title: '', reason: turn.run ? '你停下了这一轮，后端的运行也一并取消了。' : '你在搭流程时停下了这一轮。' }
     : null
 
   return (
-    <div className="w-full" data-remedy={kind ?? undefined}>
+    <div className="w-full" data-remedy={kind ?? (turn.clipped ? 'clipped' : 'attempts')}>
       {turn.clipped && (
         <div className="mb-1.5 rounded border px-2 py-1.5 text-2xs leading-relaxed text-dim"
              style={{ borderColor: 'color-mix(in srgb, var(--st-waiting) 40%, var(--border))' }} role="note">
@@ -539,6 +655,7 @@ function Remedies({ conversationId, turnId, last, onRephrase }: {
         <div className="mb-1.5 text-xs leading-relaxed">
           {note.reason && <span className="text-dim">{note.reason}</span>}
           {note.hint && <span className="text-faint"> {note.hint}</span>}
+          {kind === 'unknown' && turn.failure?.detail && <TechDetails raw={turn.failure.detail} className="mt-1" />}
         </div>
       )}
       {!!buttons.length && <div className="flex flex-wrap items-center gap-1.5">{buttons}</div>}
@@ -579,32 +696,18 @@ function useLazyHydrate(conversationId: string | null, turns: ChatTurn[] | undef
   }, [conversationId, turns])
 }
 
-type Remedy = 'failed' | 'suspended' | 'cancelled' | 'unusable' | 'partial'
+type Remedy = 'failed' | 'suspended' | 'cancelled' | 'unusable' | 'partial' | 'unknown'
 
 function remedyOf(t: ChatTurn): Remedy | null {
   if (t.phase === 'error') return 'failed'
   if (t.phase === 'suspended') return 'suspended'
   if (t.phase === 'cancelled') return 'cancelled'
+  if (t.phase === 'unknown') return 'unknown'
   if (t.phase === 'done' && t.review?.severity === 'broken') return 'unusable'
   if (t.phase === 'done' && t.review?.severity === 'degraded') return 'partial'
   return null
 }
 
-/** 原文折起来，要的人展开、复制去问维护者。不再截成一行、也不再原样甩在头部 */
-function TechDetails({ raw }: { raw: string }) {
-  return (
-    <details className="mt-1.5 text-2xs text-faint">
-      <summary className="cursor-pointer select-none hover:text-dim">技术细节</summary>
-      <div className="mt-1 flex items-start gap-1.5">
-        <pre className="mono max-h-40 min-w-0 flex-1 overflow-auto whitespace-pre-wrap break-all rounded border bg-bg p-2 text-2xs leading-relaxed text-dim">
-          {raw}
-        </pre>
-        <CopyButton text={raw} />
-      </div>
-    </details>
-  )
-}
-
 const OUTCOME: Record<Attempt['outcome'], string> = {
   failed: 'failed', cancelled: 'cancelled', suspended: 'suspended',
   unusable: 'failed', partial: 'waiting', done: 'succeeded',
@@ -630,7 +733,7 @@ function AttemptHistory({ attempts }: { attempts: Attempt[] }) {
                 {a.answer}
               </div>
             )}
-            {a.detail && <TechDetails raw={a.detail} />}
+            {a.detail && <TechDetails raw={a.detail} className="mt-1.5" />}
             {a.runId && (
               <Link to={`/runs/${a.runId}`} className="mono inline-block text-[var(--accent)] hover:underline">
                 运行 #{a.runId.slice(0, 6)}
@@ -710,8 +813,13 @@ function TurnSkeleton() {
  * 大输入框的 hero 态，默认落地页反而更简陋。第一印象该是「它懂我的业务」：
  * 能接到哪些库、有没有知识库和工具摆在输入框下面，例句用的是这些库自己的词。
  */
-function ChatHero({ sources, inputRef, draft, setDraft, onSend, onPick, blocked }: {
+function ChatHero({ sources, usable, scope, onScope, picker, inputRef, draft, setDraft, onSend, onPick, blocked }: {
   sources: SourcesState
+  /** 能限定的库（启用着的） */
+  usable: Source[]
+  scope: ScopeSource[]
+  onScope: (scope: ScopeSource[]) => void
+  picker?: ReactNode
   inputRef: RefObject<HTMLTextAreaElement | null>
   draft: string
   setDraft: (v: string) => void
@@ -723,7 +831,8 @@ function ChatHero({ sources, inputRef, draft, setDraft, onSend, onPick, blocked
   const tools = useCatalog((s) => s.tools)
   const byConversation = useChat((s) => s.byConversation)
   const list = sources.list
-  const suggestions = useMemo(() => suggestFrom(list), [list])
+  // 停用的库 Copilot 看不见，拿它造句等于教人问一个答不了的问题
+  const suggestions = useMemo(() => suggestFrom(usable), [usable])
   const recent = useMemo(() => recentQuestions(byConversation), [byConversation])
   const none = sources.state === 'ready' && !list.length
 
@@ -750,19 +859,47 @@ function ChatHero({ sources, inputRef, draft, setDraft, onSend, onPick, blocked
           blocked={blocked}
           label="向数据提问"
           placeholder="问点什么…"
+          leading={picker}
         />
 
         <div className="mt-3 flex flex-wrap items-center justify-center gap-1.5 text-2xs">
           <Capability to="/data" icon={<Database size={11} />}
             text={sources.state === 'loading' ? '数据源 —'
               : sources.state === 'error' ? '数据源没取回来'
-              : list.length ? `${list.length} 个数据源 · ${list.map((s) => s.name).slice(0, 3).join(' / ')}${list.length > 3 ? ' …' : ''}`
+              : list.length ? `${list.length} 个数据源`
               : '还没有数据源'} />
           <Capability to="/knowledge" icon={<BookOpen size={11} />}
             text={`知识库 ${collections.length} 个`} />
           <Capability to="/tools" icon={<Wrench size={11} />} text={`工具 ${tools.length} 个`} />
         </div>
 
+        {/* 库名本身就是开关：点一下这一问只查它。以前它只是一行说明文字，想换个库问
+            只能在问题里写「查 xx 库」，Copilot 还未必照办 */}
+        {usable.length > 0 && (
+          <div className="mt-2 flex flex-wrap items-center justify-center gap-1.5 text-2xs"
+               role="group" aria-label="限定只查哪些数据源">
+            <span className="text-faint">{scope.length ? '只查' : '点一个，只查它'}</span>
+            {usable.slice(0, HERO_CHIPS).map((s) => {
+              const on = scope.some((x) => x.id === s.id)
+              return (
+                <button key={s.id} type="button" data-scope-chip={s.id} aria-pressed={on}
+                        title={on ? `只查 ${s.name}。再点一下取消` : `这一问只查 ${s.name}`}
+                        className={clsx('inline-flex items-center gap-1 rounded-full border px-2 py-0.5 transition-colors',
+                          on ? 'border-[var(--accent)] bg-accent-soft text-[var(--accent)]'
+                            : 'text-dim hover:border-[var(--border-strong)] hover:text-fg')}
+                        onClick={() => onScope(on ? scope.filter((x) => x.id !== s.id)
+                          : [...scope, { id: s.id, name: s.name }])}>
+                  {on ? <Check size={10} aria-hidden /> : <Database size={10} aria-hidden />}
+                  {s.name}
+                </button>
+              )
+            })}
+            {usable.length > HERO_CHIPS && (
+              <span className="text-faint">另外 {usable.length - HERO_CHIPS} 个在输入框左边选</span>
+            )}
+          </div>
+        )}
+
         {none && (
           <div className="mt-6 rounded-lg border bg-panel px-4 py-3 text-center text-xs leading-relaxed text-dim">
             还没有接入数据源。接一个数据库或者传一张表，就能直接问它问题了。
@@ -786,6 +923,115 @@ function ChatHero({ sources, inputRef, draft, setDraft, onSend, onPick, blocked
   )
 }
 
+const NO_SCOPE: ScopeSource[] = []
+
+/** 首屏直接摆出来当开关的库。再多就挤成好几行，剩下的去输入框左边的范围里选 */
+const HERO_CHIPS = 6
+
+const scopeText = (scope: ScopeSource[]) => !scope.length ? '全部数据源'
+  : scope.length <= 2 ? `只查 ${scope.map((s) => s.name).join('、')}`
+  : `只查 ${scope.length} 个库`
+
+/**
+ * 这一问查哪些库，挂在输入框左边。默认不限：它自己挑。限定之后 Copilot 只拿得到这几个
+ * 库的工具，搭出来的流程要是查到别的库，自查就不让它跑。
+ *
+ * 按会话记，写在输入框旁边而不是藏在设置里：追问时沿用上一问的范围是暗中发生的，
+ * 得一直看得见、一下就能改
+ */
+function ScopePicker({ sources, scope, onChange, unconfirmed }: {
+  sources: Source[]
+  scope: ScopeSource[]
+  onChange: (scope: ScopeSource[]) => void
+  /** 库列表还没取回来（或取失败了）时，范围里那几个库旁边注一句 */
+  unconfirmed?: string
+}) {
+  const [open, setOpen] = useState(false)
+  const wrap = useRef<HTMLDivElement>(null)
+  const button = useRef<HTMLButtonElement>(null)
+  const picked = new Set(scope.map((s) => s.id))
+  const text = scopeText(scope)
+  // 范围里有、列表里没有的库：列表还没取回来。照样列出来才取消得掉；打开期间取消勾选的
+  // 留在原处，不然一点就从眼前消失
+  const known = new Set(sources.map((s) => s.id))
+  const [held, setHeld] = useState<ScopeSource[]>([])
+  const stray = [...held, ...scope.filter((s) => !held.some((h) => h.id === s.id))].filter((s) => !known.has(s.id))
+
+  useEffect(() => {
+    if (!open) return
+    const away = (e: PointerEvent) => { if (!wrap.current?.contains(e.target as Node)) setOpen(false) }
+    document.addEventListener('pointerdown', away)
+    return () => document.removeEventListener('pointerdown', away)
+  }, [open])
+
+  const close = () => {
+    setOpen(false)
+    button.current?.focus()
+  }
+  const toggle = (s: ScopeSource) =>
+    onChange(picked.has(s.id) ? scope.filter((x) => x.id !== s.id) : [...scope, { id: s.id, name: s.name }])
+
+  // 没有库可选、也没限定：什么都不画。开着的时候不收——刚取消勾选的那一项还得留在原处
+  if (!open && !sources.length && !scope.length) return null
+
+  return (
+    <div ref={wrap} className="relative min-w-0"
+         onKeyDown={(e) => {
+           if (e.key !== 'Escape' || !open || isComposing(e)) return
+           e.stopPropagation()
+           close()
+         }}>
+      <button ref={button} type="button" aria-haspopup="dialog" aria-expanded={open}
+              aria-label={`数据源范围：${text}`} title="限定这一问只查哪些数据源"
+              className={clsx('flex min-w-0 max-w-[16rem] items-center gap-1 rounded-md px-1.5 py-1 text-2xs transition-colors hover:bg-hover',
+                scope.length ? 'text-[var(--accent)]' : 'text-faint hover:text-dim')}
+              onClick={() => {
+                if (!open) setHeld(scope.filter((s) => !known.has(s.id)))
+                setOpen(!open)
+              }}>
+        <Database size={11} className="shrink-0" aria-hidden />
+        <span className="min-w-0 truncate">{text}</span>
+        <ChevronDown size={10} aria-hidden className={clsx('shrink-0 transition-transform', open && 'rotate-180')} />
+      </button>
+      {open && (
+        // 输入框贴着页面底部，往上弹
+        <div role="dialog" aria-label="数据源范围"
+             className="fade-up absolute bottom-full left-0 z-20 mb-1.5 w-64 rounded-lg border bg-panel p-1.5 shadow-elev-2">
+          <div className="px-1.5 pb-1 pt-0.5 text-2xs leading-relaxed text-faint">
+            这一问只查勾上的库；都不勾就由它自己挑
+          </div>
+          <div className="max-h-56 overflow-y-auto">
+            {sources.map((s, i) => (
+              <label key={s.id}
+                     className="flex cursor-pointer items-center gap-2 rounded-md px-1.5 py-1 text-xs hover:bg-hover">
+                <input type="checkbox" checked={picked.has(s.id)} onChange={() => toggle(s)} autoFocus={i === 0} />
+                <span className="min-w-0 flex-1 truncate">{s.name}</span>
+                {s.kind && <span className="shrink-0 text-2xs text-faint" aria-hidden>{s.kind}</span>}
+              </label>
+            ))}
+            {stray.map((s, i) => (
+              <label key={s.id} data-scope-stray=""
+                     className="flex cursor-pointer items-center gap-2 rounded-md px-1.5 py-1 text-xs hover:bg-hover">
+                <input type="checkbox" checked={picked.has(s.id)} onChange={() => toggle(s)}
+                       autoFocus={!sources.length && i === 0} />
+                <span className="min-w-0 flex-1 truncate">{s.name}</span>
+                {unconfirmed && <span className="shrink-0 text-2xs text-faint">{unconfirmed}</span>}
+              </label>
+            ))}
+          </div>
+          <div className="mt-1 flex items-center gap-1 border-t px-0.5 pt-1.5">
+            <button type="button" className="btn btn-xs btn-ghost" disabled={!scope.length} onClick={() => onChange([])}>
+              不限，全部数据源
+            </button>
+            <span className="flex-1" />
+            <button type="button" className="btn btn-xs" onClick={close}>好了</button>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
 function Capability({ to, icon, text }: { to: string; icon: ReactNode; text: string }) {
   return (
     <Link to={to} className="inline-flex items-center gap-1 rounded-full border px-2 py-0.5 text-faint transition-colors hover:border-[var(--border-strong)] hover:text-dim">
@@ -821,7 +1067,7 @@ function SuggestionGroup({ title, icon, items, onPick, offset }: {
 
 /**
  * 系统表：迁移记录、测试、临时、审计、日志、备份、缓存……以前例句取的是字母序
- * 前三张表，于是第一句建议是「__drizzle_migrations 有多少条记录？」——真有人点了，
+ * 前三张表，于是第一句建议是「__prisma_migrations 有多少条记录？」——真有人点了，
  * 而且直接失败了。
  */
 function isSystemTable(full: string): boolean {
@@ -876,7 +1122,7 @@ function recentQuestions(byConversation: Record<string, ChatTurn[]>): string[] {
   return [...new Set(done.map((t) => t.question.trim()))].filter(Boolean).slice(0, 2)
 }
 
-interface Source { id: string; name: string; description?: string; tables?: string[] }
+interface Source { id: string; name: string; kind?: string; enabled?: boolean; description?: string; tables?: string[] }
 interface SourcesState { state: 'loading' | 'ready' | 'error'; list: Source[] }
 
 function useDataSources(): SourcesState {
diff --git a/frontend/src/pages/ConversationList.tsx b/frontend/src/pages/ConversationList.tsx
index 1a78e443..7bc6cd20 100644
--- a/frontend/src/pages/ConversationList.tsx
+++ b/frontend/src/pages/ConversationList.tsx
@@ -1,8 +1,11 @@
-import { useEffect, useMemo, useRef, useState } from 'react'
-import { useNavigate } from 'react-router-dom'
-import { Check, MessageSquarePlus, PanelLeftClose, PanelLeftOpen, Pencil, RotateCw, Search, Trash2, X } from 'lucide-react'
+import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
+import { useNavigate, type NavigateFunction } from 'react-router-dom'
+import {
+  ArchiveRestore, ArrowLeft, Check, MessageSquarePlus, PanelLeftClose, PanelLeftOpen, Pencil, RotateCw, Search,
+  Trash2, X,
+} from 'lucide-react'
 import clsx from 'clsx'
-import { confirmDialog, isComposing, Skeleton, StatusBadge, toast } from '../components/ui'
+import { confirmDialog, IconButton, isComposing, Skeleton, StatusBadge, toast, useTicker } from '../components/ui'
 import { formatDateTime, formatRelative, parseServerTime } from '../lib/format'
 import { statusLabel } from '../lib/status'
 import { humanizeError } from '../lib/errors'
@@ -22,14 +25,18 @@ import type { Conversation } from '../types'
  *
  * 历史会话是反复回来取结论的地方，所以每一条要一眼看出三件事：是哪次聊天
  * （标题）、什么时候（相对时间）、现在怎么样（在跑、等审批、挂了）。
+ *
+ * 删除先进回收站（归档），回收站在这一栏底部：撤销只有几秒，误删一个聊了七轮的
+ * 对话，过了那几秒就该还有地方找回来。真正的删除只在回收站里做，而且要确认。
  */
 export function ConversationList() {
-  const { list, currentId, loading, error, load, create, rename, archive, restore } = useConversations()
+  const { list, trash, showTrash, currentId, loading, error, load, create, rename, archive, restore, setShowTrash } =
+    useConversations()
   const byConversation = useChat((s) => s.byConversation)
   const forget = useChat((s) => s.forget)
   const navigate = useNavigate()
-  // 相对时间和分组每分钟重算一次；格式化时取当下，刚问过的那条才是「刚刚」
-  const now = useMinute()
+  // 相对时间和分组一分钟重算一次就够：「刚刚」「3 分钟前」不需要更细
+  const now = useTicker(60_000)
 
   // 切会话 = 换地址，不是改 store。store 那个 currentId 是 URL 的派生缓存，
   // 在这里直接 set 的话，地址栏不动、刷新就跳回旧的那个，前进后退也全失效
@@ -38,22 +45,17 @@ export function ConversationList() {
   const startNew = async () => {
     try {
       const id = await create()
+      setShowTrash(false)
       navigate(`/chat/${id}`)
     } catch (e) {
       toast.error(e)
     }
   }
 
+  // 不再先弹确认：回收站和撤销就是后悔药，每删一个都打断一次反而让人不看就点确定
   const drop = async (c: Conversation) => {
     const index = list.findIndex((x) => x.id === c.id)
-    const ok = await confirmDialog({
-      title: `删除「${c.title || '新对话'}」？`,
-      body: '它会从列表里移走。删除后几秒内可以撤销。',
-      consequences: c.turn_count ? [`${c.turn_count} 轮问答和它们的结论一起移走`] : undefined,
-      confirmLabel: '删除',
-      danger: true,
-    })
-    if (!ok) return
+    const wasCurrent = c.id === currentId
     let next: string | null
     try {
       next = await archive(c.id)
@@ -64,13 +66,13 @@ export function ConversationList() {
     forget(c.id)
     // 删的是当前这个才需要换地方；archive 会把该去哪告诉我们
     if (next !== currentId) navigate(next ? `/chat/${next}` : '/chat', { replace: true })
-    toast.ok(`已删除「${c.title || '新对话'}」`, {
+    toast.ok(`「${c.title || '新对话'}」已移到回收站`, {
       duration: 8000,
       action: {
         label: '撤销',
         onClick: () => {
           void restore(c, index).then(
-            () => navigate(`/chat/${c.id}`),
+            () => { if (wasCurrent) navigate(`/chat/${c.id}`) },
             (e) => toast.error(e),
           )
         },
@@ -90,7 +92,7 @@ export function ConversationList() {
   // 一条，列表很快被空壳淹掉。真正需要会话的时刻是用户开口那一下，
   // ChatPage 的 send 会在那时按需建——在此之前空列表配空态提示就是对的。
 
-  // 同名的会话不少（「我是谁」「shop 里…」各有好几条），光靠翻很难找；
+  // 同名的会话不少（同一句「上月销量」「orders 里…」常常问好几回），光靠翻很难找；
   // 最后一问也算进去，标题常常只是第一句话
   const needle = query.trim().toLowerCase()
   const shown = useMemo(() => (needle
@@ -112,9 +114,15 @@ export function ConversationList() {
     )
   }
 
+  if (showTrash) {
+    // 相对时间跟着这一层每分钟重渲染
+    return <TrashView items={trash} currentId={currentId} onBack={() => setShowTrash(false)} />
+  }
+
   return (
     <aside className="flex w-60 shrink-0 flex-col border-r bg-panel" aria-label="对话列表">
-      <div className="flex items-center gap-1 px-2 py-2">
+      {/* 和右边的页头同高（48px）、同一条底线：两栏顶边对齐 */}
+      <div className="flex h-12 shrink-0 items-center gap-1 border-b px-2">
         <button className="btn btn-sm btn-ghost flex-1 justify-start gap-1.5 text-xs"
                 onClick={() => void startNew()}>
           <MessageSquarePlus size={13} /> 新对话
@@ -125,10 +133,12 @@ export function ConversationList() {
         </button>
       </div>
 
-      {list.length >= 8 && (
-        <div className="relative px-2 pb-1">
+      {/* 有筛选词时一直留着：删掉一条、列表不够 8 条时框跟着消失的话，筛选词还在生效，
+          剩下的对话全被藏住，只有刷新页面才清得掉 */}
+      {(list.length >= 8 || !!query) && (
+        <div className="relative px-2 pb-1 pt-2">
           <Search size={12} aria-hidden
-                  className="pointer-events-none absolute left-4 top-1/2 -translate-y-1/2 -mt-0.5 text-faint" />
+                  className="pointer-events-none absolute left-4 top-1/2 -translate-y-1/2 mt-0.5 text-faint" />
           <input
             type="search"
             className="field h-7 w-full pl-7 text-xs"
@@ -152,10 +162,10 @@ export function ConversationList() {
             </button>
           </div>
         )}
-        {!list.length && !loading && !error && (
+        {!list.length && !loading && !error && !query && (
           <p className="px-2 py-4 text-2xs text-faint">还没有对话。在右边问第一句，就会出现在这里。</p>
         )}
-        {!!list.length && !shown.length && (
+        {!shown.length && !!query.trim() && (
           <p className="px-2 py-4 text-2xs leading-relaxed text-faint">
             没有标题或问题里带「{query.trim()}」的对话
           </p>
@@ -165,8 +175,9 @@ export function ConversationList() {
             <div className="px-2 pb-0.5 pt-2.5 text-2xs text-faint">{g.label}</div>
             {g.items.map((c) => {
               const turns = byConversation[c.id]
-              const live = liveStatus(turns)
-              const running = !!busyTurn(turns)
+              // 取回内存的以内存为准（它是这一刻的）；没打开过的看列表接口带来的最后一轮状态
+              const live = turns ? liveStatus(turns) : listStatus(c)
+              const running = stillRunning(c, turns)
               const active = c.id === currentId
               const when = c.last_active_at ?? c.created_at
               return (
@@ -205,37 +216,19 @@ export function ConversationList() {
                           </span>
                         </div>
                         <div className="mt-px truncate text-2xs text-faint">
-                          {/* 状态写成字：去掉颜色、关掉动效时也认得出这条在跑 */}
-                          {live && (
-                            <span style={{ color: live === 'running' ? 'var(--st-running)' : undefined }}
-                                  className={clsx(live !== 'running' && statusTone(live))}>
-                              {statusLabel(live, { short: true })}
-                              {c.turn_count > 0 ? ' · ' : ''}
-                            </span>
-                          )}
+                          {live && <StatusText code={live} tail={c.turn_count > 0} />}
                           {c.turn_count > 0 ? `${c.turn_count} 轮` : live ? '' : '还没问过'}
                         </div>
                       </button>
                       {/* 操作浮在右侧，悬停或键盘聚焦时才出现，不占标题的宽度 */}
-                      <div
-                        className="pointer-events-none absolute inset-y-0 right-0 flex items-center gap-0.5 rounded-r-lg pl-6 pr-1 opacity-0 transition-opacity group-focus-within:pointer-events-auto group-focus-within:opacity-100 group-hover:pointer-events-auto group-hover:opacity-100"
-                        style={{ background: 'linear-gradient(to right, transparent, var(--bg-hover) 34%)' }}
-                      >
-                        <button className="btn btn-xs btn-ghost" title="重命名" aria-label={`重命名「${c.title}」`}
-                                onClick={() => setEditing(c.id)}>
-                          <Pencil size={11} />
-                        </button>
+                      <RowActions>
+                        <IconButton size="md" className="btn-xs" label={`重命名「${c.title}」`} title="重命名"
+                                    icon={<Pencil size={11} />} onClick={() => setEditing(c.id)} />
                         {/* 正在跑的不给删：底下还挂着一条事件流和一个真在跑、在计费的运行 */}
-                        <button
-                          className="btn btn-xs btn-ghost"
-                          title={running ? '这个对话正在运行，先停下来再删' : '删除'}
-                          aria-label={`删除「${c.title}」`}
-                          disabled={running}
-                          onClick={() => void drop(c)}
-                        >
-                          <Trash2 size={11} />
-                        </button>
-                      </div>
+                        <IconButton size="md" className="btn-xs" label={`删除「${c.title}」`}
+                                    title={running ? RUNNING_NO_DELETE : '删除（先放进回收站）'}
+                                    disabled={running} icon={<Trash2 size={11} />} onClick={() => void drop(c)} />
+                      </RowActions>
                     </>
                   )}
                 </div>
@@ -244,16 +237,211 @@ export function ConversationList() {
           </section>
         ))}
       </div>
+
+      <div className="shrink-0 border-t px-1.5 py-1.5">
+        <button
+          className="flex w-full items-center gap-1.5 rounded-lg px-2 py-1.5 text-xs text-faint transition-colors hover:bg-hover hover:text-dim"
+          title="删掉的对话在这里，可以恢复"
+          aria-label={`打开回收站${trash.length ? `（${trash.length} 个对话）` : ''}`}
+          onClick={() => setShowTrash(true)}
+        >
+          <Trash2 size={12} aria-hidden />
+          <span className="flex-1 text-left">回收站</span>
+          {trash.length > 0 && <span className="tnum text-2xs">{trash.length}</span>}
+        </button>
+      </div>
     </aside>
   )
 }
 
+/** 行尾的浮层按钮：悬停或键盘聚焦到这一行才出现，渐隐背景盖住标题尾巴而不挤占宽度 */
+function RowActions({ children }: { children: ReactNode }) {
+  return (
+    <div
+      className="pointer-events-none absolute inset-y-0 right-0 flex items-center gap-0.5 rounded-r-lg pl-6 pr-1 opacity-0 transition-opacity group-focus-within:pointer-events-auto group-focus-within:opacity-100 group-hover:pointer-events-auto group-hover:opacity-100"
+      style={{ background: 'linear-gradient(to right, transparent, var(--bg-hover) 34%)' }}
+    >
+      {children}
+    </div>
+  )
+}
+
 /**
- * 这个会话此刻值得标出来的状态。只看已经取回内存的会话——没打开过的，列表接口
- * 不带轮次状态，宁可不标也不猜。正常完成的不标：正常态安静，异常态才醒目。
+ * 回收站。点开一条是预览（问数据页会说明它在回收站里、不能接着问）；恢复放回列表，
+ * 彻底删除要确认——这一下之后就真没了。正在跑的（点开预览时发现运行还活着、接回去了）
+ * 和列表里一样不给删
  */
-function liveStatus(turns: ChatTurn[] | undefined): string | null {
-  if (!turns?.length) return null
+function TrashView({ items, currentId, onBack }: {
+  items: Conversation[]
+  currentId: string | null
+  onBack: () => void
+}) {
+  const navigate = useNavigate()
+  const emptyTrash = useConversations((s) => s.emptyTrash)
+  const byConversation = useChat((s) => s.byConversation)
+  const sorted = useMemo(() => [...items].sort((a, b) => stamp(b) - stamp(a)), [items])
+  const idle = items.filter((c) => !stillRunning(c, byConversation[c.id]))
+
+  const emptyAll = async () => {
+    // 确认框开着的时候谁又跑起来了，以点确认那一刻为准，所以挑两次
+    const pick = () => {
+      const mem = useChat.getState().byConversation
+      const trash = useConversations.getState().trash
+      return {
+        doomed: trash.filter((c) => !stillRunning(c, mem[c.id])),
+        kept: trash.filter((c) => stillRunning(c, mem[c.id])),
+      }
+    }
+    const first = pick()
+    if (!first.doomed.length) return
+    const rounds = first.doomed.reduce((n, c) => n + (c.turn_count || 0), 0)
+    const ok = await confirmDialog({
+      title: '清空回收站？',
+      body: `里面的 ${first.doomed.length} 个对话会被彻底删除，删除后找不回来。`,
+      consequences: [
+        ...(rounds ? [`一共 ${rounds} 轮问答和它们的结论`] : []),
+        ...(first.kept.length ? [`${titles(first.kept)}正在运行，这次不删，留在回收站里`] : []),
+        '跑过的运行记录不受影响，还在「记录」页',
+      ],
+      confirmLabel: '全部删除',
+      danger: true,
+    })
+    if (!ok) return
+    const { doomed, kept } = pick()
+    const ids = doomed.map((c) => c.id)
+    const failed = ids.length ? await emptyTrash(ids) : 0
+    const left = new Set(useConversations.getState().trash.map((c) => c.id))
+    for (const id of ids) if (!left.has(id)) useChat.getState().forget(id)
+    if (currentId && ids.includes(currentId) && !left.has(currentId)) navigate('/chat', { replace: true })
+    if (failed) toast.error(`有 ${failed} 个对话没删掉，稍后再试一次`)
+    else if (kept.length) toast.info(`删掉了 ${ids.length} 个；${titles(kept)}正在运行，留在回收站里，停下来之后再删`)
+    else toast.ok('回收站清空了')
+  }
+
+  return (
+    <aside className="flex w-60 shrink-0 flex-col border-r bg-panel" aria-label="回收站">
+      <div className="flex h-12 shrink-0 items-center gap-1 border-b px-2">
+        <IconButton label="返回对话列表" icon={<ArrowLeft size={13} />} onClick={onBack} />
+        <h2 className="min-w-0 flex-1 truncate text-xs font-semibold">回收站</h2>
+        {items.length > 0 && (
+          <button className="btn btn-xs btn-ghost text-[var(--err)]" aria-label="清空回收站"
+                  disabled={!idle.length} title={idle.length ? undefined : '回收站里的对话正在运行，先停下来再删'}
+                  onClick={() => void emptyAll()}>
+            清空
+          </button>
+        )}
+      </div>
+      <p className="px-3 pb-1 pt-2 text-2xs leading-relaxed text-faint">
+        删掉的对话先放在这里。恢复后回到列表；彻底删除后就找不回来了。
+      </p>
+      <div className="min-h-0 flex-1 overflow-y-auto px-1.5 pb-2">
+        {!items.length && (
+          <p className="px-2 py-4 text-2xs leading-relaxed text-faint">回收站是空的。</p>
+        )}
+        {sorted.map((c) => {
+          const active = c.id === currentId
+          const title = c.title || '新对话'
+          const when = c.last_active_at ?? c.created_at
+          const turns = byConversation[c.id]
+          const live = turns ? liveStatus(turns) : listStatus(c)
+          const running = stillRunning(c, turns)
+          return (
+            <div key={c.id}
+                 className={clsx('group relative mb-0.5 rounded-lg text-xs',
+                   active ? 'bg-hover text-fg' : 'text-dim hover:bg-hover')}>
+              <button
+                className="block w-full rounded-lg px-2 py-1.5 text-left"
+                onClick={() => navigate(`/chat/${c.id}`)}
+                aria-current={active ? 'page' : undefined}
+                title={[title, c.last_question && c.last_question !== c.title ? `最后一问：${c.last_question}` : '',
+                  when ? `最后活跃 ${formatDateTime(when)}` : ''].filter(Boolean).join('\n')}
+              >
+                <div className="flex items-center gap-1.5">
+                  {live && <StatusBadge status={live} size={11} decorative />}
+                  <span className="min-w-0 flex-1 truncate">{title}</span>
+                  <span className="tnum shrink-0 text-2xs text-faint">{when ? formatRelative(when) : ''}</span>
+                </div>
+                <div className="mt-px truncate text-2xs text-faint">
+                  {live && <StatusText code={live} tail={c.turn_count > 0} />}
+                  {c.turn_count > 0 ? `${c.turn_count} 轮` : live ? '' : '还没问过'}
+                </div>
+              </button>
+              <RowActions>
+                <IconButton size="md" className="btn-xs" label={`恢复「${title}」`} title="恢复到列表"
+                            icon={<ArchiveRestore size={11} />}
+                            onClick={() => void restoreConversation(c, navigate)} />
+                <IconButton size="md" className="btn-xs hover:text-[var(--err)]" label={`彻底删除「${title}」`}
+                            title={running ? RUNNING_NO_DELETE : '彻底删除'} disabled={running}
+                            icon={<Trash2 size={11} />}
+                            onClick={() => void purgeConversation(c, navigate)} />
+              </RowActions>
+            </div>
+          )
+        })}
+      </div>
+    </aside>
+  )
+}
+
+/** 从回收站拿回来。不是正在看的那个，就在提示里给一个「打开」 */
+export async function restoreConversation(c: Conversation, navigate: NavigateFunction): Promise<void> {
+  const st = useConversations.getState()
+  try {
+    await st.restore(c)
+  } catch (e) {
+    toast.error(e)
+    return
+  }
+  const title = c.title || '新对话'
+  if (st.currentId === c.id) {
+    // 正在看的那个恢复了：左栏回到列表，它就在里面，可以接着问
+    st.setShowTrash(false)
+    toast.ok(`「${title}」已恢复到列表`)
+  } else {
+    toast.ok(`「${title}」已恢复到列表`, { action: { label: '打开', onClick: () => navigate(`/chat/${c.id}`) } })
+  }
+}
+
+/**
+ * 彻底删除：先确认，确认了才发 DELETE。删的是正在看的那个就离开它。删掉了返回 true。
+ * 正在跑的不删，确认之后再看一次：确认框开着的时候，核对可能刚把一次还活着的运行接回来
+ */
+export async function purgeConversation(c: Conversation, navigate: NavigateFunction): Promise<boolean> {
+  const title = c.title || '新对话'
+  const running = () => stillRunning(c, useChat.getState().byConversation[c.id])
+  const refuse = () => { toast.info(`「${title}」正在运行，先停下来再删`); return false }
+  if (running()) return refuse()
+  const ok = await confirmDialog({
+    title: `彻底删除「${title}」？`,
+    body: '删除后找不回来。',
+    consequences: [
+      ...(c.turn_count ? [`${c.turn_count} 轮问答和它们的结论一起删除`] : []),
+      '跑过的运行记录不受影响，还在「记录」页',
+    ],
+    confirmLabel: '彻底删除',
+    danger: true,
+  })
+  if (!ok) return false
+  if (running()) return refuse()
+  const st = useConversations.getState()
+  try {
+    await st.purge(c.id)
+  } catch (e) {
+    toast.error(e)
+    return false
+  }
+  useChat.getState().forget(c.id)
+  if (st.currentId === c.id) navigate('/chat', { replace: true })
+  toast.ok(`已彻底删除「${title}」`)
+  return true
+}
+
+/**
+ * 这个会话此刻值得标出来的状态（已经取回内存的）。正常完成的不标：正常态安静，
+ * 异常态才醒目。
+ */
+function liveStatus(turns: ChatTurn[]): string | null {
+  if (!turns.length) return null
   if (busyTurn(turns)) return 'running'
   if (turns.some((t) => t.phase === 'waiting')) return 'waiting'
   const last = turns[turns.length - 1]
@@ -262,9 +450,41 @@ function liveStatus(turns: ChatTurn[] | undefined): string | null {
   return null
 }
 
+/** 没打开过的会话：列表接口带来的最后一轮状态。完成、取消的不标，同上 */
+const LIST_STATUS: Partial<Record<NonNullable<Conversation['last_status']>, string>> = {
+  running: 'running', waiting: 'waiting', error: 'failed', suspended: 'suspended',
+}
+const listStatus = (c: Conversation): string | null => (c.last_status && LIST_STATUS[c.last_status]) || null
+
+/**
+ * 这个会话底下有没有正在跑的东西。取回内存的看轮次的相位，没打开过的看列表接口的
+ * last_status。正在跑的不给删：删掉只关得掉这一头的事件流，后端的运行照样跑、照样计费，
+ * 从此没有哪一页还看得见它
+ */
+export function stillRunning(c: Conversation, turns: ChatTurn[] | undefined): boolean {
+  return turns ? !!busyTurn(turns) : c.last_status === 'running'
+}
+
+export const RUNNING_NO_DELETE = '这个对话正在运行，先停下来再删'
+
+const titles = (list: Conversation[]) => list.map((c) => `「${c.title || '新对话'}」`).join('、')
+
+/** 行里第二行开头那个状态词：去掉颜色、关掉动效时也认得出这条在跑 */
+function StatusText({ code, tail }: { code: string; tail: boolean }) {
+  return (
+    <span style={{ color: code === 'running' ? 'var(--st-running)' : undefined }}
+          className={clsx(code !== 'running' && statusTone(code))}>
+      {statusLabel(code, { short: true })}
+      {tail ? ' · ' : ''}
+    </span>
+  )
+}
+
 const statusTone = (code: string) =>
   code === 'failed' ? 'text-[var(--st-failed)]' : 'text-[var(--st-waiting)]'
 
+const stamp = (c: Conversation) => parseServerTime(c.last_active_at ?? c.created_at ?? '')?.getTime() ?? 0
+
 /** 今天 / 昨天 / 近 7 天 / 更早：历史会话按「多久以前」找，比按字母找快 */
 function groupByDay(list: Conversation[], now: number): { label: string; items: Conversation[] }[] {
   const start = new Date(now)
@@ -279,23 +499,12 @@ function groupByDay(list: Conversation[], now: number): { label: string; items:
   ]
   const out = buckets.map(([label]) => ({ label, items: [] as Conversation[] }))
   for (const c of list) {
-    const t = parseServerTime(c.last_active_at ?? c.created_at)?.getTime() ?? 0
-    const i = buckets.findIndex(([, hit]) => hit(t))
+    const i = buckets.findIndex(([, hit]) => hit(stamp(c)))
     out[i].items.push(c)
   }
   return out.filter((g) => g.items.length)
 }
 
-/** 相对时间一分钟刷一次就够：「刚刚」「3 分钟前」不需要更细 */
-function useMinute(): number {
-  const [now, setNow] = useState(() => Date.now())
-  useEffect(() => {
-    const t = setInterval(() => setNow(Date.now()), 60_000)
-    return () => clearInterval(t)
-  }, [])
-  return now
-}
-
 function RenameField({ initial, onSubmit, onCancel }: {
   initial: string
   onSubmit: (title: string) => void
diff --git a/frontend/src/pages/DataPage.tsx b/frontend/src/pages/DataPage.tsx
index 7653775e..a4e53d04 100644
--- a/frontend/src/pages/DataPage.tsx
+++ b/frontend/src/pages/DataPage.tsx
@@ -1,6 +1,6 @@
 import { Database } from 'lucide-react'
-import { TabPanel, Tabs, useTabRoute } from '../components/ui'
-import { DataSourcesTab, PageHeader } from './DataSourcesTab'
+import { PageHeader, TabPanel, Tabs, useTabRoute } from '../components/ui'
+import { DataSourcesTab } from './DataSourcesTab'
 import type { DataView } from './DataSourcesTab'
 
 /**
diff --git a/frontend/src/pages/DataSourcesTab.tsx b/frontend/src/pages/DataSourcesTab.tsx
index 400bd3d1..9ef74624 100644
--- a/frontend/src/pages/DataSourcesTab.tsx
+++ b/frontend/src/pages/DataSourcesTab.tsx
@@ -1,412 +1,25 @@
-import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from 'react'
-import type { KeyboardEvent as ReactKeyboardEvent, ReactNode } from 'react'
+import { useEffect, useMemo, useRef, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
 import {
   AlertTriangle, ChevronRight, Database, FileSpreadsheet, Info, KeyRound, Lock, Plug, Plus, RefreshCw,
-  Search, Table2, Trash2, Upload, X,
+  Search, Table2, Upload, X,
 } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../api/client'
+import type { IntrospectPreview, TableSchema, UploadProgress } from '../api/client'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import {
-  confirmDialog, EmptyState, ErrorState, Field, IconButton, Modal, promptDialog, Skeleton, Spinner, StatusBadge,
-  toast,
+  confirmDialog, DeleteButton, EmptyState, ErrorState, Field, HealthPill, IconButton, Modal, promptDialog,
+  SectionBar, Skeleton, Spinner, toast, useRadioGroup, useTicker,
 } from '../components/ui'
 import { humanizeError } from '../lib/errors'
-import { formatDateTime, formatDuration, formatNumber, formatRelative, formatTime, parseServerTime } from '../lib/format'
+import {
+  formatBytes, formatDateTime, formatDuration, formatNumber, formatRelative, parseServerTime, shortLabel,
+} from '../lib/format'
+import { checkHealth, forgetHealth, healthFromServer, setHealth, useHealth } from '../lib/health'
+import type { HealthRecord } from '../lib/health'
+import { workflowList, workflowsMentioning } from '../lib/mentions'
 import { useRunClock } from '../run/useRunClock'
-import type { Workflow } from '../types'
-
-// ===========================================================================
-// 管理页共用件：工具、知识、数据、设置四页都用。
-//
-// 暂住在这里：这一轮不动 components/ui.tsx，也不另开文件。等 ui.tsx 能改了，
-// PageHeader / HealthPill / deferDelete 挪过去。
-// ===========================================================================
-
-/**
- * 页头：图标、标题、一句说明、页面级按钮。
- *
- * 高度卡死 48px：toast 从 56px 起，工具栏比这高，常驻的出错 toast 就会压住
- * 按钮。标签页（如果有）紧贴在页头下面、左边缘对齐。
- */
-export function PageHeader({ icon, title, subtitle, actions }: {
-  icon: ReactNode; title: string; subtitle?: string; actions?: ReactNode
-}) {
-  return (
-    <header className="flex h-12 shrink-0 items-center gap-2.5 border-b bg-panel px-4">
-      <span className="flex h-6 w-6 shrink-0 items-center justify-center rounded-md border bg-elev text-dim" aria-hidden>
-        {icon}
-      </span>
-      <h1 className="shrink-0 text-sm font-semibold">{title}</h1>
-      {subtitle && <p className="min-w-0 truncate text-xs text-faint" title={subtitle}>{subtitle}</p>}
-      <span className="flex-1" />
-      {actions}
-    </header>
-  )
-}
-
-/** 标签页里一节的标题行：左边标题和一句说明，右边这一节的按钮 */
-export function SectionBar({ title, hint, children }: { title: string; hint?: ReactNode; children?: ReactNode }) {
-  return (
-    <div className="mb-3 flex flex-wrap items-end gap-x-3 gap-y-2">
-      <div className="min-w-0 flex-1">
-        <h2 className="text-sm font-semibold">{title}</h2>
-        {hint && <p className="mt-0.5 text-xs leading-relaxed text-faint">{hint}</p>}
-      </div>
-      {children && <div className="flex flex-wrap items-center gap-2">{children}</div>}
-    </div>
-  )
-}
-
-/** 删除类的纯图标按钮：悬停铺 10% 的 err 底，读屏念得出删的是谁 */
-export function DeleteButton({ label, onClick, disabled }: { label: string; onClick: () => void; disabled?: boolean }) {
-  return (
-    <IconButton
-      label={label}
-      onClick={onClick}
-      disabled={disabled}
-      className="text-faint hover:bg-st-failed/10 hover:text-[var(--err)]"
-      icon={<Trash2 size={12} />}
-    />
-  )
-}
-
-/**
- * 单选组（role=radiogroup）的键盘约定：整组只占一个 Tab 位，落在选中项上；
- * ←→↑↓ 在组内移动并选中，首尾相接。标了 radio 却每项一个 Tab 位、方向键没反应，
- * 等于对读屏用户许了个做不到的诺。
- *
- * 用法：const radio = useRadioGroup(values, value, onChange)，每个选项展开
- * {...radio(v)}，点击照旧自己写 onClick。
- */
-export function useRadioGroup<T extends string>(values: readonly T[], value: T | undefined, onChange: (v: T) => void) {
-  const refs = useRef(new Map<T, HTMLElement | null>())
-  // 选中的值不在选项里（还没加载完之类）：让第一项接住 Tab
-  const focusable = value !== undefined && values.includes(value) ? value : values[0]
-  return (v: T) => ({
-    ref: (el: HTMLElement | null) => { refs.current.set(v, el) },
-    role: 'radio' as const,
-    'aria-checked': v === value,
-    tabIndex: v === focusable ? 0 : -1,
-    onKeyDown: (e: ReactKeyboardEvent) => {
-      const step = e.key === 'ArrowRight' || e.key === 'ArrowDown' ? 1 : e.key === 'ArrowLeft' || e.key === 'ArrowUp' ? -1 : 0
-      if (!step || e.altKey || e.metaKey || e.ctrlKey) return
-      e.preventDefault()
-      const i = values.indexOf(v)
-      const next = values[(i + step + values.length) % values.length]
-      if (next !== value) onChange(next)
-      refs.current.get(next)?.focus()
-    },
-  })
-}
-
-/**
- * 每 ms 毫秒重渲染一次，给「3 分钟前」这类相对时间保鲜。
- * 只负责触发重渲染：算相对时间时要现取 Date.now()——返回值是上一拍的时刻，
- * 比刚到的结果还早，拿它算会把「刚刚」写成一个钟点。
- */
-export function useTicker(ms: number, active = true): number {
-  const [now, setNow] = useState(() => Date.now())
-  useEffect(() => {
-    if (!active) return
-    const t = setInterval(() => setNow(Date.now()), ms)
-    return () => clearInterval(t)
-  }, [ms, active])
-  return now
-}
-
-/** 图里引用了这些名字（工具名、模型 id）的工作流。按 JSON 里的整串值匹配，不做子串 */
-export function workflowsMentioning(workflows: Workflow[], tokens: string[]): Workflow[] {
-  const needles = tokens.filter(Boolean).map((t) => JSON.stringify(t))
-  if (!needles.length) return []
-  return workflows.filter((w) => {
-    const text = JSON.stringify(w.graph ?? {})
-    return needles.some((n) => text.includes(n))
-  })
-}
-
-/** 「3 个工作流（周报、巡检 等）」 */
-export function workflowList(list: Workflow[], max = 3): string {
-  const names = list.slice(0, max).map((w) => `「${w.name}」`).join('')
-  return `${list.length} 个工作流（${names}${list.length > max ? ' 等' : ''}）`
-}
-
-// ---------------------------------------------------------------------------
-// 连没连上：统一、持久的状态
-// ---------------------------------------------------------------------------
-
-/**
- * 一次「测连接」的结果。按 `种类:id` 存：模型接入 provider:<id>、数据源
- * datasource:<id>、MCP mcp:<id>。
- *
- * 以前测完只弹 4 秒 toast，结果存在组件 state 里，切个标签就没了；卡片上的圆点
- * 又各说各的（模型卡的绿点其实是「启用」）。管理页最核心的问题是「现在能不能
- * 用」，答案得留在对象上，并注明是什么时候测的。
- *
- * 模块级而不是组件 state：切标签、换页都还在。再写一份到 localStorage，刷新
- * 也还在——只是这台浏览器的缓存，后端不记，所以一律带上「几分钟前测的」。
- */
-export interface HealthRecord {
-  ok: boolean
-  /** 往返毫秒 */
-  ms?: number | null
-  /** 测的时刻（ms） */
-  at: number
-  error?: string
-  hint?: string
-  detail?: string
-  /** 成功时的补充：用的哪个模型、回了什么 */
-  note?: string
-}
-
-const HEALTH_KEY = 'agentlab.health'
-
-function readHealth(): Record<string, HealthRecord> {
-  try {
-    const raw = JSON.parse(localStorage.getItem(HEALTH_KEY) ?? '{}')
-    return raw && typeof raw === 'object' ? raw : {}
-  } catch {
-    return {}
-  }
-}
-
-let healthSnap: { records: Record<string, HealthRecord>; checking: Record<string, number> } = {
-  records: readHealth(), checking: {},
-}
-const healthListeners = new Set<() => void>()
-const subscribeHealth = (l: () => void) => {
-  healthListeners.add(l)
-  return () => { healthListeners.delete(l) }
-}
-function emitHealth(next: Partial<typeof healthSnap>, persist = false) {
-  healthSnap = { ...healthSnap, ...next }
-  if (persist) {
-    try { localStorage.setItem(HEALTH_KEY, JSON.stringify(healthSnap.records)) } catch { /* 隐私模式：只是刷新后不记得 */ }
-  }
-  healthListeners.forEach((l) => l())
-}
-
-export function useHealth(key: string): { record?: HealthRecord; checkingSince?: number } {
-  const snap = useSyncExternalStore(subscribeHealth, () => healthSnap, () => healthSnap)
-  return { record: snap.records[key], checkingSince: snap.checking[key] }
-}
-
-export function setHealth(key: string, record: HealthRecord) {
-  emitHealth({ records: { ...healthSnap.records, [key]: record } }, true)
-}
-
-export function forgetHealth(key: string) {
-  const { [key]: _gone, ...rest } = healthSnap.records
-  emitHealth({ records: rest }, true)
-}
-
-/**
- * 测一次并记下结果。run 返回后端的 {ok, error, hint, detail}；ms 和 note 由调用方
- * 从各自的字段里取（latency_ms / elapsed_ms）。
- *
- * 后端本身够不着时不记：那说的是「我们连不上后端」，不是这个库或模型坏了，
- * 记成它的失败就是冤枉它。只弹 toast。
- */
-export async function checkHealth(
-  key: string,
-  run: () => Promise<Omit<HealthRecord, 'at'>>,
-): Promise<HealthRecord | null> {
-  if (healthSnap.checking[key]) return null
-  emitHealth({ checking: { ...healthSnap.checking, [key]: Date.now() } })
-  let record: HealthRecord | null = null
-  try {
-    record = { ...(await run()), at: Date.now() }
-  } catch (e) {
-    const h = humanizeError(e)
-    if (h.kind === 'network') {
-      toast.error(e)
-    } else {
-      record = {
-        ok: false, at: Date.now(),
-        error: h.reason ? `${h.title}：${h.reason}` : h.title, hint: h.action, detail: h.raw,
-      }
-    }
-  } finally {
-    const { [key]: _done, ...checking } = healthSnap.checking
-    emitHealth({
-      checking,
-      ...(record ? { records: { ...healthSnap.records, [key]: record } } : {}),
-    }, !!record)
-  }
-  return record
-}
-
-/**
- * 连通状态胶囊：状态剪影 + 一句话。
- *
- * 和画布运行态同一套语言：进行中是转着的圆环、正常是带勾的方块、失败是三角、
- * 没测过是空心点——去掉颜色也认得出。正常态安静（字是 dim），出错才用 err 色。
- * 结果刚到的那一下，状态点外圈扩散一次；进页时从缓存读出的旧结果不播。
- */
-export function HealthPill({ record, checkingSince, labels, className, stale }: {
-  record?: HealthRecord | null
-  checkingSince?: number
-  labels?: { idle?: string; checking?: string; ok?: string; fail?: string }
-  className?: string
-  /** 结果已经不代表眼前这份配置（改过了），淡出显示并提示重测 */
-  stale?: boolean
-}) {
-  const clock = useRunClock(!!checkingSince)
-  useTicker(30_000, !!record && !checkingSince)
-  const state = checkingSince ? 'checking' : !record ? 'idle' : record.ok ? 'ok' : 'fail'
-  const status = ({ idle: 'idle', checking: 'running', ok: 'done', fail: 'failed' } as const)[state]
-  const color = `var(--st-${status})`
-
-  const [ping, setPing] = useState(0)
-  const lastAt = useRef(record?.at)
-  useEffect(() => {
-    const at = record?.at
-    if (at && at !== lastAt.current && Date.now() - at < 3000) setPing(at)
-    lastAt.current = at
-  }, [record?.at])
-
-  // at 为 0：后端记的上次结果，不知道是什么时候测的，就不写时间。带个「测」字：
-  // 这是上次测的时刻，不是此刻的状态
-  const rel = record?.at ? formatRelative(record.at) : ''
-  const when = !rel ? '' : rel === '刚刚' ? '刚测过' : /前$/.test(rel) ? `${rel}测` : `${rel} 测`
-  const text = state === 'checking'
-    ? `${labels?.checking ?? '正在测'} · ${formatDuration(Math.max(0, clock - (checkingSince ?? clock)))}`
-    : state === 'idle'
-      ? (labels?.idle ?? '未测试')
-      : state === 'ok'
-        ? [labels?.ok ?? '已连通', record?.ms != null ? formatDuration(record.ms) : null, when].filter(Boolean).join(' · ')
-        : [labels?.fail ?? '连不上', when].join(' · ')
-  const tip = record
-    ? [
-        record.at ? `${formatDateTime(record.at)} 测的` : '上次探测的结果',
-        record.ok ? record.note : record.error,
-        stale ? '配置改过了，这个结果不代表眼前这份，重测一次' : null,
-      ].filter(Boolean).join('\n')
-    : undefined
-  // 念给读屏的那一句只在状态切换时变：看得见的那句里有 100ms 一跳的计时和
-  // 「3 分钟前」，放进播报区的话测连接期间会一直念、之后每分钟每张卡再念一遍。
-  // 时刻写成钟点，不写相对时间
-  const spoken = state === 'checking'
-    ? '正在测连接'
-    : state === 'idle' || !record
-      ? ''
-      : [
-          record.ok
-            ? [labels?.ok ?? '已连通', record.ms != null ? formatDuration(record.ms) : null].filter(Boolean).join(' ')
-            : `${labels?.fail ?? '连不上'}${record.error ? `：${record.error}` : ''}`,
-          record.at ? `${formatTime(record.at)} 测的` : null,
-          stale ? '配置改过了，这个结果不代表眼前这份' : null,
-        ].filter(Boolean).join('，')
-
-  return (
-    <>
-      <span
-        aria-hidden
-        data-health={state}
-        title={tip}
-        className={clsx('inline-flex items-center gap-1.5 whitespace-nowrap text-2xs tnum', stale && 'opacity-55', className)}
-        style={{ color: state === 'fail' ? color : state === 'checking' ? 'var(--accent)' : state === 'ok' ? 'var(--text-dim)' : 'var(--text-faint)' }}
-      >
-        <span className="relative inline-flex">
-          {ping > 0 && (
-            <span
-              key={ping}
-              className="absolute inset-0 animate-ping rounded-full"
-              style={{ background: color, animationIterationCount: 1, animationFillMode: 'forwards' }}
-              onAnimationEnd={() => setPing(0)}
-            />
-          )}
-          <StatusBadge status={status} size={12} decorative />
-        </span>
-        {text}
-        {stale && state !== 'checking' && <span className="text-faint">· 配置改过了</span>}
-      </span>
-      <span role="status" className="sr-only">{spoken}</span>
-    </>
-  )
-}
-
-// ---------------------------------------------------------------------------
-// 删除后可撤销
-// ---------------------------------------------------------------------------
-
-const UNDO_MS = 5000
-const pendingDeletes = new Map<number, string>()
-let pendingSeq = 0
-/**
- * 已经点了删除的对象（按 DELETE 的 url 记）。撤销窗口里 DELETE 还没发，这时列表
- * 一刷新（知识库有文档在处理时 2 秒轮询一次、写完记忆、存完工具都会重拉），后端
- * 照样返回它，行就回来了——toast 还写着「已删除」，再点一次删除还会多排一个
- * DELETE，头一个落地后第二个 404。所以各列表的 load 都要过一遍 withoutDeferred。
- *
- * 撤销、或者删失败放回原处时才拿出去；删成功了也不拿：id 不会再出现，而删之前
- * 发出、删之后才回来的那次列表请求里还带着它
- */
-const deferredGone = new Set<string>()
-
-/** 滤掉还在撤销窗口里（或已经删掉）的行。base 是 DELETE 地址去掉 id 的那段 */
-export function withoutDeferred<T extends { id: string }>(rows: T[], base: string): T[] {
-  return deferredGone.size ? rows.filter((r) => !deferredGone.has(`${base}/${r.id}`)) : rows
-}
-
-// 关页、刷新时，还在撤销窗口里的删除照样发出去：用户已经点了删除，刷新一下它
-// 又回来了，比多等 5 秒更让人糊涂。keepalive 让请求活过页面卸载
-if (typeof window !== 'undefined') {
-  window.addEventListener('pagehide', () => {
-    for (const url of pendingDeletes.values()) {
-      void fetch(url, { method: 'DELETE', keepalive: true }).catch(() => {})
-    }
-    pendingDeletes.clear()
-  })
-}
-
-/**
- * 低代价的删除：列表里先拿掉，toast 给 5 秒「撤销」，到点才真发 DELETE。
- * 比弹窗确认少一次打断，误删了又救得回来。发失败了放回原处并说明。
- *
- * url 是关页时补发用的（/api/...），commit 是正常路径。url 同时是「已删」的
- * 记号：列表的 load 用 withoutDeferred 按它滤掉这一行。
- */
-export function deferDelete({ what, url, hide, restore, commit, done }: {
-  what: string
-  url: string
-  hide: () => void
-  restore: () => void
-  commit: () => Promise<unknown>
-  done?: () => void
-}) {
-  deferredGone.add(url)
-  hide()
-  const id = ++pendingSeq
-  pendingDeletes.set(id, url)
-  // 先拿掉记号再 restore：restore 多半是重拉列表，记号还在的话又被滤掉
-  const putBack = () => { deferredGone.delete(url); restore() }
-  const timer = setTimeout(async () => {
-    if (!pendingDeletes.delete(id)) return
-    toast.dismiss(toastId)
-    try {
-      await commit()
-      done?.()
-    } catch (e) {
-      putBack()
-      const h = humanizeError(e)
-      toast.error(`没删掉${what}：${h.reason ? `${h.title}，${h.reason}` : h.title}`, { detail: h.raw })
-    }
-  }, UNDO_MS)
-  const toastId = toast(`已删除${what}`, 'info', {
-    duration: UNDO_MS,
-    key: `undo:${id}`,
-    action: {
-      label: '撤销',
-      onClick: () => {
-        if (!pendingDeletes.delete(id)) return
-        clearTimeout(timer)
-        putBack()
-      },
-    },
-  })
-}
 
 // ===========================================================================
 // 数据源
@@ -428,9 +41,6 @@ export const isUploadedTable = (row: any): boolean =>
 
 const NAME_RE = /^[a-z][a-z0-9_]{0,40}$/
 
-/** 「OpenAI 兼容（DeepSeek / …）」→「OpenAI 兼容」。卡片上的类型标签要短 */
-export const shortLabel = (label?: string | null) => (label ?? '').replace(/[（(].*$/, '').trim()
-
 export function DataSourcesTab({ view = 'databases' }: { view?: DataView }) {
   const navigate = useNavigate()
   const [rows, setRows] = useState<any[] | null>(null)
@@ -546,11 +156,14 @@ export function DataSourcesTab({ view = 'databases' }: { view?: DataView }) {
           source={editing}
           kinds={kinds}
           onClose={() => setEditing(null)}
-          onSaved={(row, tested) => {
+          onSaved={(row, tested, reconnected) => {
             const isNew = !editing.id
             setEditing(null)
             upsert(row)
+            // 本机记着的那次测连接说的是改之前的库：换了地址、账号或连接参数就不作数了
+            // （后端同样清掉了自己记的那份，除非表单里刚测过这一份）
             if (tested) setHealth(`datasource:${row.id}`, tested)
+            else if (reconnected) forgetHealth(`datasource:${row.id}`)
             if (isNew) {
               toast.ok(`已接入「${row.name}」。下一步：探查结构，助手靠它写 SQL`, {
                 action: { label: '探查结构', onClick: () => setKick({ id: row.id, seq: Date.now() }) },
@@ -590,7 +203,8 @@ function SourceCard({ row, meta, onChange, onRemoved, onEdit, onReupload, kick }
   kick: number
 }) {
   const healthKey = `datasource:${row.id}`
-  const { record, checkingSince } = useHealth(healthKey)
+  // 后端记着上次测的结果：换了浏览器、清了缓存也还在。本机刚测过的更新就用本机的
+  const { record, checkingSince } = useHealth(healthKey, healthFromServer(row))
   const workflows = useCatalog((s) => s.workflows)
   const [busy, setBusy] = useState('')
   const uploaded = isUploadedTable(row)
@@ -608,17 +222,19 @@ function SourceCard({ row, meta, onChange, onRemoved, onEdit, onReupload, kick }
 
   const configured: string = row.options?.schema ?? ''
   const configuredLabel = configured || '默认 schema'
+  // 缓存是按哪个 schema 探的（null：老缓存没记，或者还没探过）。和配置对不上时，
+  // 助手写 SQL 用的是另一个 schema 的表——改了配置没重探、或者重探失败都会这样
+  const cachedSchema: string | null = row.cached_schema ?? null
+  const schemaDrift = cachedSchema != null && cachedSchema !== configured
 
-  const introspect = async (schema?: string) => {
+  const introspect = async () => {
     if (busy) return
     busySince.current = Date.now()
-    setBusy(schema ? `schema:${schema}` : 'introspect')
+    setBusy('introspect')
     try {
-      const next = await api.datasources.introspect(row.id, schema)
+      const next = await api.datasources.introspect(row.id)
       onChange(next)
-      if (schema && schema !== configured) {
-        await settleOther(schema, next)
-      } else if (next.table_count) {
+      if (next.table_count) {
         toast.ok(`「${row.name}」探到 ${formatNumber(next.table_count)} 个对象`)
       } else if (!next.schema_error) {
         // 连得上、也没报错，就是这个 schema 下真的没有对象。探查失败的红字
@@ -633,72 +249,86 @@ function SourceCard({ row, meta, onChange, onRemoved, onEdit, onReupload, kick }
   }
 
   /**
-   * 用别的 schema 探完之后：要么写进配置，要么马上换回配置里的。
+   * 换个 schema 看看：只看不存（dry_run），缓存和配置都不动。探到对象再问要不要
+   * 写进配置；要，就改配置并按新配置真探一次。
    *
-   * 后端的探查没有「只看不存」，结果直接落进缓存——助手和「问数据」此刻看到的
-   * 已经是这份。以前「只看看，不改」就停在这儿：卡片上的 schema 还写着原来的，
-   * 对象数和结构却是另一个 schema 的，只有一条几秒就消失的 toast 提过一句。
-   * 现在不写进配置就重新探一次配置里的，让缓存和配置始终对得上
+   * 以前后端没有「只看」，一探结果就落进缓存，选「不改」还得马上再探一次换回去，
+   * 换回去失败时助手看到的就是另一个 schema 的表
    */
-  const settleOther = async (schema: string, next: any) => {
-    if (!next.table_count) {
-      await restoreConfigured(schema, `「${schema}」下没探到对象，配置不改`)
+  const probeOther = async (schema: string) => {
+    if (busy) return
+    busySince.current = Date.now()
+    setBusy(`schema:${schema}`)
+    let preview: IntrospectPreview
+    try {
+      preview = await api.datasources.previewSchema(row.id, schema)
+    } catch (e) {
+      toast.error(e)
+      return
+    } finally {
+      setBusy('')
+    }
+    if (preview.schema_error) {
+      toast.warn(`「${schema}」探不出来：${preview.schema_error}`, { detail: '只是看看：配置和缓存都没动' })
       return
     }
-    const names: string[] = await api.datasources.schema(row.id).then((s) => s.tables ?? [], () => [])
-    const sample = names.slice(0, 6).map((t) => t.slice(t.lastIndexOf('.') + 1))
+    if (!preview.table_count) {
+      toast.info(`「${schema}」下没有对象。只是看看，配置和缓存都没动`)
+      return
+    }
+    const total = Math.max(preview.table_count, preview.total ?? 0)
+    const sample = preview.tables.slice(0, 6).map((t) => t.slice(t.lastIndexOf('.') + 1))
     const ok = await confirmDialog({
       title: `把 schema 改成「${schema}」？`,
-      body: `用 ${schema} 探到了 ${formatNumber(next.table_count)} 个对象${sample.length ? `，比如 ${sample.join('、')}${names.length > sample.length ? ' 等' : ''}` : ''}。`,
+      body: `「${schema}」下有 ${formatNumber(total)} 个对象${sample.length ? `，比如 ${sample.join('、')}${total > sample.length ? ' 等' : ''}` : ''}。`,
       consequences: [
-        `改：写进这个数据源的配置，以后探查结构、助手写 SQL 都用 ${schema}`,
-        `不改：马上重新探查配置里的「${configuredLabel}」，助手看到的结构跟着换回去`,
+        `改：写进这个数据源的配置并重新探查，以后助手写 SQL 都用 ${schema}`,
+        `不改：什么都不动。刚才只是看看，助手看到的还是「${configuredLabel}」的结构`,
       ],
       confirmLabel: `改成 ${schema}`,
-      cancelLabel: `不改，换回 ${configured || '默认'}`,
+      cancelLabel: '不改',
     })
-    if (!ok) {
-      await restoreConfigured(schema, '没改配置')
-      return
-    }
-    try {
-      onChange(await api.datasources.update(row.id, { options: { ...(next.options ?? {}), schema } }))
-      toast.ok(`已把「${row.name}」的 schema 改成 ${schema}`)
-    } catch (e) {
-      const h = humanizeError(e)
-      toast.error(`没改成（${h.title}）：配置里还是「${configuredLabel}」，缓存里却是 ${schema} 的结构。再点一次「探查结构」换回去`, { detail: h.raw })
-    }
-  }
-
-  const restoreConfigured = async (probed: string, lead: string) => {
+    if (!ok) return
     busySince.current = Date.now()
     setBusy('introspect')
     try {
-      onChange(await api.datasources.introspect(row.id))
-      toast.info(`${lead}。已重新探查「${configuredLabel}」，助手看到的结构和配置一致`)
+      // options 整组替换：Oracle 的 service_name / sid 这些要原样带上
+      onChange(await api.datasources.update(row.id, { options: { ...(row.options ?? {}), schema } }))
     } catch (e) {
       const h = humanizeError(e)
-      toast.error(`${lead}，但没能换回「${configuredLabel}」的结构（${h.title}）：助手眼下看到的还是 ${probed} 的。再点一次「探查结构」`, { detail: h.raw })
+      toast.error(`没改成（${h.title}）：配置还是「${configuredLabel}」，缓存也没动`, { detail: h.raw })
+      setBusy('')
+      return
+    }
+    try {
+      const next = await api.datasources.introspect(row.id)
+      onChange(next)
+      toast.ok(`已把「${row.name}」的 schema 改成 ${schema}，探到 ${formatNumber(next.table_count ?? 0)} 个对象`)
+    } catch (e) {
+      // 配置已经改了、缓存还是旧的：卡片上那行「结构和配置对不上」会一直提醒
+      const h = humanizeError(e)
+      toast.error(`schema 已改成 ${schema}，但重新探查没成功（${h.title}）：助手眼下看到的还是原来的结构。再点一次「探查结构」`, { detail: h.raw })
+    } finally {
+      setBusy('')
     }
   }
 
   useEffect(() => { if (kick) void introspect() }, [kick])
 
-  // 配置里的 schema 探不出对象（失败或是空的）时，才给「换个 schema」：换着探
-  // 会改掉缓存，好好的库没必要冒这个险——要换 schema 走「编辑」
+  // 只看不存，好好的库也可以随手看看别的 schema；单文件的 SQLite 和传上来的表没有 schema 可换
   const synced = parseServerTime(row.schema_synced_at)?.getTime() ?? 0
-  const canProbeOther = !uploaded && row.kind !== 'sqlite' && !row.table_count && (!!row.schema_error || synced > 0)
+  const canProbeOther = !uploaded && row.kind !== 'sqlite'
   const introspectOther = async () => {
     const others: string[] = (row.available_schemas ?? []).filter((s: string) => s !== configured).slice(0, 8)
     const schema = await promptDialog({
-      title: '用哪个 schema 探查？',
-      body: `探到的结构会先换掉眼下缓存的那份；探到对象再问要不要写进配置，不写就马上换回「${configuredLabel}」。${others.length ? `这台服务器上还有：${others.join('、')}` : ''}`,
+      title: '看看哪个 schema？',
+      body: `只看不存：缓存和配置都不动，探到对象再问要不要写进配置。${others.length ? `这台服务器上还有：${others.join('、')}` : ''}`,
       label: 'schema',
       placeholder: others[0] ?? (row.kind === 'postgres' ? 'public' : row.kind === 'oracle' ? 'ANALYTICS' : row.database || ''),
-      confirmLabel: '探查',
+      confirmLabel: '看看',
       validate: (v) => (!v ? '填一个 schema 名' : v === configured ? `「${v}」就是配置里的，点「探查结构」就行` : null),
     })
-    if (schema) await introspect(schema)
+    if (schema) await probeOther(schema)
   }
 
   const remove = async () => {
@@ -798,13 +428,13 @@ function SourceCard({ row, meta, onChange, onRemoved, onEdit, onReupload, kick }
           {!!row.available_schemas?.length && (
             <div className="mt-2 flex flex-wrap items-center gap-1.5">
               <span className="text-faint">
-                当前是「{row.options?.schema || row.database || '默认'}」。这台服务器上还有，点一个换它探查：
+                当前是「{row.options?.schema || row.database || '默认'}」。这台服务器上还有，点一个看看（只看不存）：
               </span>
               {row.available_schemas.slice(0, 12).map((s: string) => (
                 <button key={s} className="chip hover:border-[var(--accent)] hover:text-fg" disabled={!!busy}
-                        onClick={() => void introspect(s)}>
+                        onClick={() => void probeOther(s)}>
                   {busy === `schema:${s}` ? <Spinner size={10} /> : <Search size={10} aria-hidden />}
-                  用 {s} 探查
+                  看看 {s}
                 </button>
               ))}
             </div>
@@ -812,6 +442,28 @@ function SourceCard({ row, meta, onChange, onRemoved, onEdit, onReupload, kick }
         </div>
       )}
 
+      {schemaDrift && (
+        <div
+          className="mx-3 mb-3 flex flex-wrap items-center gap-x-2 gap-y-1 rounded-lg border px-3 py-2 text-xs leading-relaxed"
+          style={{
+            borderColor: 'color-mix(in srgb, var(--warn) 45%, var(--border))',
+            background: 'color-mix(in srgb, var(--warn) 7%, transparent)',
+          }}
+          data-schema-drift
+        >
+          <AlertTriangle size={12} className="shrink-0 text-[var(--warn)]" aria-hidden />
+          <span className="min-w-0 flex-1">
+            <span className="text-[var(--warn)]">
+              助手看到的结构是按「{cachedSchema || '默认 schema'}」探的，配置里写的是「{configuredLabel}」
+            </span>
+            <span className="text-dim">：它写 SQL 用的表可能不在配置的 schema 里。</span>
+          </span>
+          <button className="btn btn-xs" disabled={!!busy} onClick={() => void introspect()}>
+            <RefreshCw size={11} aria-hidden /> 按配置重新探查
+          </button>
+        </div>
+      )}
+
       <div className="flex items-center gap-2 border-t px-3 py-1.5 text-2xs">
         {row.table_count ? (
           <button
@@ -835,11 +487,12 @@ function SourceCard({ row, meta, onChange, onRemoved, onEdit, onReupload, kick }
           <span className="text-[var(--warn)]">结构还没探查 · 助手看不到有哪些表</span>
         )}
         {canProbeOther && (
-          <button className="inline-flex items-center gap-1 rounded px-1 py-0.5 text-faint hover:bg-hover hover:text-fg disabled:opacity-50"
+          <button className="tnum inline-flex items-center gap-1 rounded px-1 py-0.5 text-faint hover:bg-hover hover:text-fg disabled:opacity-50"
                   disabled={!!busy} onClick={() => void introspectOther()} data-probe-schema
-                  title="指定一个 schema 探查；探到了再决定要不要写进配置，不写就换回原来的">
-            {busy.startsWith('schema:') ? <Spinner size={10} /> : <Search size={10} aria-hidden />}
-            换个 schema 探查…
+                  title="指定一个 schema 看看有哪些对象：只看不存，缓存和配置都不动；探到了再决定要不要写进配置">
+            {busy.startsWith('schema:')
+              ? <><Spinner size={10} /> 在看「{busy.slice(7)}」 {formatDuration(clock - busySince.current)}</>
+              : <><Search size={10} aria-hidden /> 换个 schema 看看…</>}
           </button>
         )}
         <span className="flex-1" />
@@ -877,60 +530,24 @@ function Address({ row, meta, uploaded }: { row: any; meta?: any; uploaded: bool
   )
 }
 
-interface TableDetail {
-  kind: string
-  name: string
-  comment?: string
-  columns: { name: string; type: string; pk: boolean; notNull: boolean; note: string }[]
-  /** 解析不出来时的原文（比如「数据源里没有这张表」） */
-  text?: string
-}
-
-/**
- * 解析 GET /datasources/{id}/schema?table= 的 detail 文本：
- *   视图 ANALYTICS.X（注释，可能跨行）
- *     COL  TYPE  主键、非空、列注释
- * 列之间用两个以上空格分隔。
- */
-export function parseTableDetail(text: string): TableDetail {
-  const lines = (text ?? '').split('\n')
-  const first = lines.findIndex((l) => l.startsWith('  '))
-  const head = (first < 0 ? lines : lines.slice(0, first)).join('\n')
-  const m = head.match(/^(表|视图) (\S+?)(?:（([\s\S]*)）)?$/)
-  if (!m) return { kind: '', name: '', columns: [], text }
-  const columns: TableDetail['columns'] = []
-  for (const line of first < 0 ? [] : lines.slice(first)) {
-    if (!line.startsWith('  ')) {
-      // 列注释里的换行：接到上一列后面
-      const last = columns[columns.length - 1]
-      if (last) last.note = `${last.note}\n${line}`.trim()
-      continue
-    }
-    const [name, type = '', marks = ''] = line.trim().split(/\s{2,}/)
-    const tags = marks ? marks.split('、') : []
-    columns.push({
-      name, type,
-      pk: tags.includes('主键'),
-      notNull: tags.includes('非空'),
-      note: tags.filter((t) => t !== '主键' && t !== '非空').join('、'),
-    })
-  }
-  return { kind: m[1], name: m[2], comment: m[3]?.trim(), columns }
-}
-
 /** 一次最多画这么多行：上千个对象的库全画出来会卡，过滤一下就够用了 */
 const SCHEMA_ROWS = 300
 
+type ColumnsState = TableSchema | { error: unknown } | 'loading'
+
 /**
- * 结构浏览器：Copilot 写 SQL 靠的就是这份结构，用户得能方便地核对「它看到了
+ * 结构浏览器：助手写 SQL 靠的就是这份结构，用户得能方便地核对「它看到了
  * 什么」。按 schema 分组，一行一张表，点开懒加载列（名称 / 类型 / 说明）。
+ *
+ * 列信息取后端给的结构化字段（columns / kind / comment / found）。以前解析给
+ * 模型看的那段 detail 文本，列注释里带两个空格或换行就会错位
  */
 function SchemaBrowser({ row }: { row: any }) {
   const [tables, setTables] = useState<string[] | null>(null)
   const [error, setError] = useState<unknown>(null)
   const [q, setQ] = useState('')
   const [expanded, setExpanded] = useState<Set<string>>(() => new Set())
-  const [details, setDetails] = useState<Record<string, TableDetail | { error: unknown } | 'loading'>>({})
+  const [details, setDetails] = useState<Record<string, ColumnsState>>({})
 
   // 重新探查后表清单和列都可能变了：重取清单、清掉列缓存，但展开着的那几张
   // 保持展开（下面会按需重取）
@@ -948,8 +565,8 @@ function SchemaBrowser({ row }: { row: any }) {
     for (const t of expanded) {
       if (details[t]) continue
       setDetails((d) => ({ ...d, [t]: 'loading' }))
-      api.datasources.schema(row.id, t).then(
-        (s) => setDetails((d) => ({ ...d, [t]: parseTableDetail(s.detail ?? '') })),
+      api.datasources.tableSchema(row.id, t).then(
+        (s) => setDetails((d) => ({ ...d, [t]: s })),
         (e) => setDetails((d) => ({ ...d, [t]: { error: e } })),
       )
     }
@@ -1007,6 +624,7 @@ function SchemaBrowser({ row }: { row: any }) {
             {list.map((t) => {
               const isOpen = expanded.has(t)
               const d = details[t]
+              const loaded = d && typeof d === 'object' && 'table' in d ? d : null
               return (
                 <div key={t}>
                   <button
@@ -1016,8 +634,9 @@ function SchemaBrowser({ row }: { row: any }) {
                   >
                     <ChevronRight size={11} className={clsx('shrink-0 text-faint transition-transform', isOpen && 'rotate-90')} aria-hidden />
                     <span className="mono truncate text-xs">{group ? t.slice(group.length + 1) : t}</span>
-                    {d && typeof d === 'object' && 'columns' in d && d.columns.length > 0 && (
-                      <span className="tnum text-2xs text-faint">{d.columns.length} 列</span>
+                    {loaded?.kind === 'view' && <span className="text-2xs text-faint">视图</span>}
+                    {!!loaded?.columns?.length && (
+                      <span className="tnum text-2xs text-faint">{loaded.columns.length} 列</span>
                     )}
                   </button>
                   {isOpen && <ColumnList detail={d} />}
@@ -1036,46 +655,60 @@ function SchemaBrowser({ row }: { row: any }) {
   )
 }
 
-function ColumnList({ detail }: { detail?: TableDetail | { error: unknown } | 'loading' }) {
+function ColumnList({ detail }: { detail?: ColumnsState }) {
   if (!detail || detail === 'loading') {
     return <div className="mb-1 ml-5 py-1"><Skeleton rows={3} height={9} gap={6} /></div>
   }
   if ('error' in detail) return <div className="mb-1.5 ml-5"><ErrorState compact error={detail.error} /></div>
-  if (!detail.columns.length) {
-    return <div className="mb-1.5 ml-5 whitespace-pre-line text-2xs text-faint">{detail.text || '没有列信息'}</div>
+  if (!detail.found) {
+    // 清单里有、缓存里却找不到：清单和列是两次请求取的，中间重新探查过
+    return (
+      <div className="mb-1.5 ml-5 text-2xs text-faint">
+        缓存里没有这张表的结构了，多半是刚重新探查过。收起再展开，或者点「探查结构」
+      </div>
+    )
   }
+  // 老后端只给 detail 文本：原样显示，不去解析
+  if (!detail.columns) {
+    return <div className="mono mb-1.5 ml-5 whitespace-pre-wrap text-2xs text-dim">{detail.detail || '没有列信息'}</div>
+  }
+  const view = detail.kind === 'view'
   return (
     <div className="mb-1.5 ml-5 mt-0.5 overflow-hidden rounded-md border bg-bg">
-      {(detail.comment || detail.kind === '视图') && (
+      {(detail.comment || view) && (
         <div className="flex gap-2 border-b px-2 py-1 text-2xs text-dim">
-          {detail.kind === '视图' && <span className="chip">视图</span>}
+          {view && <span className="chip">视图</span>}
           {detail.comment && <span className="whitespace-pre-line">{detail.comment}</span>}
         </div>
       )}
-      <table className="w-full text-2xs">
-        <thead className="text-faint">
-          <tr className="border-b">
-            <th className="w-[38%] px-2 py-1 text-left font-medium">列</th>
-            <th className="w-[24%] px-2 py-1 text-left font-medium">类型</th>
-            <th className="px-2 py-1 text-left font-medium">说明</th>
-          </tr>
-        </thead>
-        <tbody>
-          {detail.columns.map((c) => (
-            <tr key={c.name} className="border-b border-[var(--hairline)] last:border-0">
-              <td className="mono px-2 py-[3px]">
-                {c.pk && <KeyRound size={9} className="mr-1 inline text-[var(--accent)]" aria-label="主键" />}
-                {c.name}
-              </td>
-              <td className="mono px-2 py-[3px] text-faint">{c.type}</td>
-              <td className="px-2 py-[3px] text-dim">
-                {c.notNull && <span className="mr-1.5 text-faint">非空</span>}
-                <span className="whitespace-pre-line">{c.note}</span>
-              </td>
+      {!detail.columns.length ? (
+        <div className="px-2 py-1.5 text-2xs text-faint">探查时没读到列信息</div>
+      ) : (
+        <table className="w-full text-2xs">
+          <thead className="text-faint">
+            <tr className="border-b">
+              <th className="w-[38%] px-2 py-1 text-left font-medium">列</th>
+              <th className="w-[24%] px-2 py-1 text-left font-medium">类型</th>
+              <th className="px-2 py-1 text-left font-medium">说明</th>
             </tr>
-          ))}
-        </tbody>
-      </table>
+          </thead>
+          <tbody>
+            {detail.columns.map((c) => (
+              <tr key={c.name} className="border-b border-[var(--hairline)] last:border-0">
+                <td className="mono px-2 py-[3px]">
+                  {c.pk && <KeyRound size={9} className="mr-1 inline text-[var(--accent)]" aria-label="主键" />}
+                  {c.name}
+                </td>
+                <td className="mono px-2 py-[3px] text-faint">{c.type}</td>
+                <td className="px-2 py-[3px] text-dim">
+                  {c.not_null && <span className="mr-1.5 text-faint">非空</span>}
+                  {c.comment && <span className="whitespace-pre-line">{c.comment}</span>}
+                </td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
     </div>
   )
 }
@@ -1165,9 +798,22 @@ const FIELD_LABEL: Record<string, string> = {
   host: '主机', database: '数据库', username: '用户名',
 }
 
+/**
+ * 决定连到哪个库的那几项（提交体里的）。schema 不在内：它只影响探查哪一片，不影响
+ * 连不连得上，后端判断测连接结果还作不作数时同样不看它
+ */
+function connectionOf(body: any): string {
+  const { schema: _schema, ...options } = body.options ?? {}
+  return JSON.stringify([
+    body.kind, body.host ?? null, body.port ?? null, body.database ?? null, body.username ?? null,
+    options, !!body.password,
+  ])
+}
+
 function SourceEditor({ source, kinds, onClose, onSaved }: {
   source: any; kinds: any[]; onClose: () => void
-  onSaved: (row: any, tested?: HealthRecord) => void
+  /** reconnected：连接配置改过了，之前测的结果不再代表它 */
+  onSaved: (row: any, tested?: HealthRecord, reconnected?: boolean) => void
 }) {
   const isNew = !source.id
   const [initial] = useState(() => toForm(source))
@@ -1232,7 +878,8 @@ function SourceEditor({ source, kinds, onClose, onSaved }: {
       const row = isNew
         ? await api.datasources.create(body)
         : await api.datasources.update(source.id, body)
-      onSaved(row, testFresh ? test.result : undefined)
+      const before = connectionOf(toBody(initial, isNew, source.kind === 'oracle'))
+      onSaved(row, testFresh ? test.result : undefined, connectionOf(body) !== before)
     } catch (e) {
       toast.error(e)
     } finally {
@@ -1508,6 +1155,56 @@ function suspiciousColumns(cols: { name: string }[]): Set<string> {
   return out
 }
 
+const isAbort = (e: unknown) => e instanceof DOMException && e.name === 'AbortError'
+
+/**
+ * 上传的真实进度：字节发了多少（XHR 的上传进度），发完之后是后端在处理，那段
+ * 没有进度可报——只写「处理中」和已等了多久，不把条拉满冒充完成。浏览器算不出
+ * 总字节时只写已发多少，不画百分比。
+ *
+ * 知识库的上传占位行也用它
+ */
+export function UploadMeter({ progress, startedAt, sentAt, processing, now }: {
+  progress: UploadProgress | null
+  /** 开始发的时刻；还没轮到它时不传 */
+  startedAt?: number
+  /** 字节发完的时刻 */
+  sentAt?: number
+  /** 发完之后后端在干什么，比如「正在读表、推断列类型」 */
+  processing: string
+  now: number
+}) {
+  if (!startedAt) return <span className="text-faint">排队中，前面的传完就轮到它</span>
+  if (progress?.sent) {
+    return (
+      <span className="inline-flex items-center gap-1.5 text-dim" data-upload-phase="processing">
+        <Spinner size={10} /> 传完了，{processing} · <span className="tnum">{formatDuration(now - (sentAt ?? now))}</span>
+      </span>
+    )
+  }
+  // 浏览器还没报过进度（刚开始，或者中间有层拦着不报）：不写「已传 0 B」，只写在传
+  const loaded = progress?.loaded ?? null
+  const total = progress?.total ?? null
+  const pct = total && loaded != null ? Math.min(1, loaded / total) : null
+  return (
+    <span className="block" data-upload-phase="sending">
+      <span className="tnum flex flex-wrap gap-x-1.5 text-dim">
+        <span>上传中{loaded != null && <> · 已传 {formatBytes(loaded)}{total ? ` / ${formatBytes(total)}` : ''}</>}</span>
+        {pct != null && <span>· {Math.round(pct * 100)}%</span>}
+        <span className="text-faint">· {formatDuration(now - startedAt)}</span>
+      </span>
+      {pct != null && (
+        <span className="mt-1 block h-1 overflow-hidden rounded-full bg-hover" role="progressbar"
+              aria-label="上传进度" aria-valuemin={0} aria-valuemax={100} aria-valuenow={Math.round(pct * 100)}>
+          {/* 用 scaleX 推进而不是改 width：只动 transform，不触发重排 */}
+          <span className="block h-full origin-left rounded-full bg-[var(--st-running)] transition-transform duration-200"
+                style={{ transform: `scaleX(${pct})` }} />
+        </span>
+      )}
+    </span>
+  )
+}
+
 /**
  * 传一个 Excel / CSV，变成可以用 SQL 查的表。
  *
@@ -1532,11 +1229,18 @@ function TableUploader({ initialName, taken, onClose, onImported }: {
   const [description, setDescription] = useState('')
   const [headerRow, setHeaderRow] = useState(1)
   const [busy, setBusy] = useState(false)
+  const [progress, setProgress] = useState<{ p: UploadProgress; sentAt?: number } | null>(null)
   const [dragging, setDragging] = useState(false)
   const [result, setResult] = useState<Awaited<ReturnType<typeof api.datasources.uploadTable>> | null>(null)
   const headerRef = useRef<HTMLInputElement>(null)
   const clock = useRunClock(busy)
   const busySince = useRef(0)
+  const upload = useRef<{ abort: () => void; sent: boolean } | null>(null)
+  const sent = !!progress?.p.sent
+
+  // 弹窗关掉时字节还没发完，就不传了：后端收不全，什么都不会建。已经发完的让它
+  // 做完——后端已经在建表，这时断开只会让人以为没传上
+  useEffect(() => () => { if (upload.current && !upload.current.sent) upload.current.abort() }, [])
 
   const pick = (f: File | null) => {
     setFile(f)
@@ -1556,16 +1260,29 @@ function TableUploader({ initialName, taken, onClose, onImported }: {
 
   const submit = async () => {
     if (!file || !name || nameError) return
+    const ctl = new AbortController()
+    const handle = { abort: () => ctl.abort(), sent: false }
+    upload.current = handle
     busySince.current = Date.now()
+    setProgress(null)
     setBusy(true)
     try {
-      const out = await api.datasources.uploadTable(file, { name, description, header_row: headerRow })
+      const out = await api.datasources.uploadTable(file, { name, description, header_row: headerRow }, {
+        signal: ctl.signal,
+        onProgress: (p) => {
+          if (p.sent) handle.sent = true
+          setProgress((cur) => ({ p, sentAt: cur?.sentAt ?? (p.sent ? Date.now() : undefined) }))
+        },
+      })
       setResult(out)
       onImported(out.source)
     } catch (e) {
-      toast.error(e)
+      if (isAbort(e)) toast.info(`没传完就取消了，「${name}」没有建也没有改`)
+      else toast.error(e)
     } finally {
+      if (upload.current === handle) upload.current = null
       setBusy(false)
+      setProgress(null)
     }
   }
 
@@ -1644,7 +1361,12 @@ function TableUploader({ initialName, taken, onClose, onImported }: {
       title="传表格"
       footer={
         <>
-          <button className="btn" onClick={onClose} disabled={busy}>取消</button>
+          {busy && !sent ? (
+            <button className="btn" onClick={() => upload.current?.abort()}>取消上传</button>
+          ) : (
+            <button className="btn" onClick={onClose} disabled={busy}
+                    title={busy ? '文件已经传完，后端正在建表，等它做完' : undefined}>取消</button>
+          )}
           <button className="btn btn-primary tnum" onClick={() => void submit()}
                   disabled={busy || !file || !name || !!nameError}
                   title={!file ? '先选一个文件' : !name ? '给数据源起个名' : undefined}>
@@ -1656,12 +1378,13 @@ function TableUploader({ initialName, taken, onClose, onImported }: {
       <div className="space-y-3">
         <label
           className={clsx(
-            'flex cursor-pointer flex-col items-center justify-center gap-1.5 rounded-lg border border-dashed px-4 py-5 text-center transition-colors',
-            dragging ? 'border-[var(--accent)] bg-accent-soft' : 'hover:border-[var(--border-strong)] hover:bg-hover',
+            'flex flex-col items-center justify-center gap-1.5 rounded-lg border border-dashed px-4 py-5 text-center transition-colors',
+            busy ? 'opacity-60' : 'cursor-pointer',
+            dragging ? 'border-[var(--accent)] bg-accent-soft' : !busy && 'hover:border-[var(--border-strong)] hover:bg-hover',
           )}
-          onDragOver={(e) => { e.preventDefault(); setDragging(true) }}
+          onDragOver={(e) => { e.preventDefault(); if (!busy) setDragging(true) }}
           onDragLeave={() => setDragging(false)}
-          onDrop={(e) => { e.preventDefault(); setDragging(false); pick(e.dataTransfer.files?.[0] ?? null) }}
+          onDrop={(e) => { e.preventDefault(); setDragging(false); if (!busy) pick(e.dataTransfer.files?.[0] ?? null) }}
         >
           <FileSpreadsheet size={20} className={file ? 'text-[var(--accent)]' : 'text-faint'} aria-hidden />
           {file ? (
@@ -1670,10 +1393,17 @@ function TableUploader({ initialName, taken, onClose, onImported }: {
             <span className="text-xs text-dim">拖一个文件进来，或点这里选</span>
           )}
           <span className="text-2xs text-faint">Excel（.xlsx）或 CSV / TSV，每个工作表变成一张表。.xls 是老格式，先另存为 .xlsx</span>
-          <input type="file" className="sr-only" accept=".xlsx,.xlsm,.csv,.tsv" aria-label="选择表格文件"
+          <input type="file" className="sr-only" accept=".xlsx,.xlsm,.csv,.tsv" aria-label="选择表格文件" disabled={busy}
                  onChange={(e) => pick(e.target.files?.[0] ?? null)} />
         </label>
 
+        {busy && (
+          <div className="rounded-lg border bg-bg px-3 py-2 text-2xs" data-upload-progress>
+            <UploadMeter progress={progress?.p ?? null} startedAt={busySince.current} sentAt={progress?.sentAt}
+                         processing="正在读表、推断列类型" now={clock} />
+          </div>
+        )}
+
         <div className="grid grid-cols-[1fr_120px] gap-3">
           <Field label="数据源名" required error={nameError}
                  hint={`会成为工具名的一部分（db_query__${name || 'sales'}）；同名重传就地替换`}>
@@ -1701,10 +1431,3 @@ function TableUploader({ initialName, taken, onClose, onImported }: {
     </Modal>
   )
 }
-
-export function formatBytes(n: number): string {
-  if (!Number.isFinite(n)) return '—'
-  if (n < 1024) return `${n} B`
-  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`
-  return `${(n / 1024 / 1024).toFixed(1)} MB`
-}
diff --git a/frontend/src/pages/KnowledgePage.tsx b/frontend/src/pages/KnowledgePage.tsx
index 61da1f57..7906dc0f 100644
--- a/frontend/src/pages/KnowledgePage.tsx
+++ b/frontend/src/pages/KnowledgePage.tsx
@@ -6,22 +6,22 @@ import {
   X,
 } from 'lucide-react'
 import clsx from 'clsx'
-import { api } from '../api/client'
+import { api, ApiError } from '../api/client'
+import type { KbHit, KbSearchResult, ReindexJob, UploadProgress } from '../api/client'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import {
-  confirmDialog, EmptyState, ErrorState, Field, IconButton, isComposing, Modal, promptDialog, Skeleton, Spinner,
-  StatusBadge, TabPanel, Tabs, toast, useTabRoute,
+  confirmDialog, deferDelete, DeleteButton, EmptyState, ErrorState, Field, IconButton, isComposing, Modal,
+  PageHeader, promptDialog, SectionBar, Skeleton, Spinner, StatusBadge, TabPanel, Tabs, toast, useRadioGroup,
+  useTabRoute, useTicker, withoutDeferred,
 } from '../components/ui'
 import { humanizeError } from '../lib/errors'
 import {
-  formatDateTime, formatDuration, formatNumber, formatRelative, formatTime, parseServerTime, shortId,
+  formatBytes, formatDateTime, formatDuration, formatNumber, formatRelative, formatTime, NONE, parseServerTime, shortId,
 } from '../lib/format'
 import { matchShortcut } from '../lib/keys'
 import { useRunClock } from '../run/useRunClock'
 import type { KbDocument, MemoryItem, MemorySource, Skill } from '../types'
-import {
-  DeleteButton, deferDelete, formatBytes, PageHeader, SectionBar, useRadioGroup, useTicker, withoutDeferred,
-} from './DataSourcesTab'
+import { UploadMeter } from './DataSourcesTab'
 
 // 提到模块级：tab 名同时是 URL 的最后一段，两处各写一份迟早对不上
 const TABS = [
@@ -102,13 +102,57 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
   const [baseUrl, setBaseUrl] = useState('')
   const [models, setModels] = useState<string[]>([])
   const [model, setModel] = useState('')
-  const since = useRef(0)
-  const clock = useRunClock(busy === 'rebuild')
+  // 在看的那次重建（后台跑，轮询进度）。只有看着它跑完的，才报「重建完了」
+  const [job, setJob] = useState<ReindexJob | null>(null)
+  const [jobFailed, setJobFailed] = useState<ReindexJob | null>(null)
+  const running = job?.state === 'running'
+  // 重建途中换模型，前半截是旧模型建的、后半截是新的：跑着的时候把换模型也锁上
+  const locked = !!busy || running
+  const clock = useRunClock(running)
 
   useEffect(() => {
     if (info) { setBaseUrl(info.base_url || ''); setModel(info.model || '') }
   }, [info?.base_url, info?.model])
 
+  // 进页先看一眼：刷新之前、或者别的标签页点的重建可能还在跑，接着显示它的进度
+  useEffect(() => {
+    let live = true
+    api.kb.reindexStatus().then((j) => { if (live && j.state === 'running') setJob(j) }, () => {})
+    return () => { live = false }
+  }, [])
+
+  // 一秒问一次进度，拿到的就是后端按批记下的真实数字，不在两次之间插值
+  useEffect(() => {
+    if (!running) return
+    let live = true
+    const t = setTimeout(async () => {
+      let next: ReindexJob | { state: 'idle' }
+      try {
+        next = await api.kb.reindexStatus()
+      } catch {
+        // 这一拍没问到（后端抖了一下）：原样再排一拍
+        if (live) setJob((j) => (j ? { ...j } : j))
+        return
+      }
+      if (!live) return
+      if (next.state === 'running') { setJob(next); return }
+      setJob(null)
+      if (next.state === 'idle') {
+        // 进度只记在后端进程里：重启过就没了，重建多半也没做完
+        toast.warn('后端重启过，这次重建的进度丢了：看一眼还剩多少对不上的，需要就再点一次重建')
+      } else if (next.state === 'failed') {
+        setJobFailed(next)
+      } else {
+        const r = next.result
+        const mem = r?.memories_reindexed ?? 0
+        toast.ok(`已用 ${r?.embedder ?? '当前模型'} 重建 ${formatNumber(r?.reindexed ?? 0)} 段知识` + (mem ? ` 和 ${formatNumber(mem)} 条记忆` : ''))
+      }
+      await refresh()
+      await onChanged()
+    }, 1000)
+    return () => { live = false; clearTimeout(t) }
+  }, [job])
+
   if (!info) return <Skeleton rows={1} height={44} className="mb-3" />
   // 记忆和知识库共用一个 embedder，换模型时一起失效。只报一个的话，
   // 用户点完重建还是想不起事，而且不知道为什么
@@ -193,17 +237,24 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
     } finally { setBusy('') }
   }
 
+  /**
+   * 后台重建：立刻回来，进度靠轮询。几千段配远端 embedding 要好几分钟，以前整个
+   * 请求压着，按钮上只有一个不知道还要多久的计时
+   */
   const rebuild = async () => {
-    since.current = Date.now()
+    setJobFailed(null)
     setBusy('rebuild')
     try {
-      const out = await api.kb.reindex(collection)
-      const mem = out.memories_reindexed ?? 0
-      toast.ok(`已用 ${out.embedder} 重建 ${formatNumber(out.reindexed)} 段知识` + (mem ? ` 和 ${formatNumber(mem)} 条记忆` : ''))
-      await refresh()
-      await onChanged()
+      setJob(await api.kb.startReindex(collection))
     } catch (e) {
-      toast.error(e)
+      if (e instanceof ApiError && e.status === 409) {
+        // 已经有一次在跑（别的标签页，或者别人点的）：不再起第二次，接着看它的进度
+        toast.info(e.message)
+        const cur = await api.kb.reindexStatus().catch(() => null)
+        if (cur?.state === 'running') setJob(cur)
+      } else {
+        toast.error(e)
+      }
     } finally { setBusy('') }
   }
 
@@ -214,20 +265,28 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
         <span className="mono">{info.embedder} · <span className="tnum">{info.dim}</span> 维</span>
         {/* 看实际在用的那个，不看配的是什么 */}
         <SemanticPill info={info} />
-        <button className="btn btn-sm btn-ghost" disabled={!!busy} aria-expanded={editing}
+        <button className="btn btn-sm btn-ghost" disabled={locked} aria-expanded={editing}
                 onClick={() => setEditing((v) => !v)}>
           {editing ? '收起' : '换一个'}
         </button>
         <span className="flex-1" />
-        {stale > 0 && !fallback && (
-          <button className="btn btn-sm btn-primary tnum" disabled={!!busy} onClick={() => void rebuild()}>
-            {busy === 'rebuild'
-              ? <><Spinner size={11} /> 重建中 {formatDuration(clock - since.current)}</>
+        {(running || (stale > 0 && !fallback)) && (
+          <button className="btn btn-sm btn-primary tnum" disabled={locked || running} onClick={() => void rebuild()}>
+            {running || busy === 'rebuild'
+              ? <><Spinner size={11} /> 重建中</>
               : <>重建索引（{formatNumber(stale)} 段）</>}
           </button>
         )}
       </div>
 
+      {running && job && <ReindexProgress job={job} now={clock} />}
+      {jobFailed && !running && (
+        <div className="mx-3 mb-3">
+          <ErrorState compact error={{ ok: false, error: jobFailed.error ?? '重建索引没做完', hint: jobFailed.hint ?? undefined }}
+                      onRetry={() => void rebuild()} />
+        </div>
+      )}
+
       {fallback && (
         <div className="mx-3 mb-3 rounded-lg border px-3 py-2 text-xs leading-relaxed"
              style={{ borderColor: 'color-mix(in srgb, var(--warn) 45%, var(--border))', background: 'color-mix(in srgb, var(--warn) 7%, transparent)' }}>
@@ -243,7 +302,7 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
             </p>
           )}
           <div className="mt-2 flex flex-wrap items-center gap-2">
-            <button className="btn btn-sm btn-primary" disabled={!!busy}
+            <button className="btn btn-sm btn-primary" disabled={locked}
                     onClick={() => void pickModel(info.model, info.base_url)}>
               {busy === 'pick' ? <Spinner size={11} /> : null} 重新连接
             </button>
@@ -260,21 +319,21 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
             </div>
             <div className="flex flex-wrap items-center gap-1.5">
               <input className="field h-7 flex-1" placeholder="http://127.0.0.1:1234/v1" aria-label="embedding 服务地址"
-                     value={baseUrl} disabled={!!busy}
+                     value={baseUrl} disabled={locked}
                      onChange={(e) => setBaseUrl(e.target.value)} />
               {/* 模型名手填太容易错：LM Studio 里叫 text-embedding-qwen3-embedding-4b，
                   不是 Qwen3-Embedding-4B。填错的表现是切换时 404，人还以为服务没起 */}
-              <button className="btn btn-sm" disabled={!!busy || !baseUrl.trim()} onClick={() => void probe()}>
+              <button className="btn btn-sm" disabled={locked || !baseUrl.trim()} onClick={() => void probe()}>
                 {busy === 'probe' ? <Spinner size={11} /> : null} 看看有哪些模型
               </button>
             </div>
             {!!models.length && (
               <div className="mt-1.5 flex flex-wrap items-center gap-1.5">
-                <select className="field h-7 flex-1" value={model} disabled={!!busy} aria-label="embedding 模型"
+                <select className="field h-7 flex-1" value={model} disabled={locked} aria-label="embedding 模型"
                         onChange={(e) => setModel(e.target.value)}>
                   {models.map((m) => <option key={m} value={m}>{m}</option>)}
                 </select>
-                <button className="btn btn-sm btn-primary" disabled={!!busy || !model}
+                <button className="btn btn-sm btn-primary" disabled={locked || !model}
                         onClick={() => void pickModel(model, baseUrl)}>用它</button>
               </div>
             )}
@@ -283,7 +342,7 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
             </p>
           </div>
 
-          <button className="btn btn-sm w-full justify-start" disabled={!!busy || info.kind === 'local'}
+          <button className="btn btn-sm w-full justify-start" disabled={locked || info.kind === 'local'}
                   onClick={() => void pickLocal()}>
             本地哈希向量 <span className="font-normal text-faint">— 零配置、不联网、免费，但只认字面不认语义（全局降级，会先确认）</span>
           </button>
@@ -311,6 +370,48 @@ function EmbedderBar({ info, collection, refresh, onChanged }: {
   )
 }
 
+/**
+ * 重建索引的进度：后端按批（64 条一批）记下的真实数字，不插值。
+ *
+ * 三段：知识片段的向量 → 倒排索引 → 记忆的向量。倒排那一段后端没有分批进度，
+ * 条停在片段做完的位置，写明「这一步没有分批进度」，不去假装它在走
+ */
+function ReindexProgress({ job, now }: { job: ReindexJob; now: number }) {
+  const started = parseServerTime(job.started_at)?.getTime()
+  const pct = job.total > 0 ? Math.min(1, job.done / job.total) : null
+  const step = job.phase === 'index'
+    ? '正在重建倒排索引'
+    : job.phase === 'memories'
+      ? `正在重算记忆的向量 · ${formatNumber(job.memories.done)} / ${formatNumber(job.memories.total)} 条`
+      : `正在重算知识片段的向量 · ${formatNumber(job.chunks.done)} / ${formatNumber(job.chunks.total)} 段`
+  return (
+    <div className="border-t px-3 py-2.5" data-reindex={job.phase}>
+      <div className="flex flex-wrap items-center gap-x-2 gap-y-1 text-xs">
+        <span className="tnum">{step}</span>
+        <span className="flex-1" />
+        <span className="tnum text-2xs text-faint">
+          {pct != null && <>合计 {formatNumber(job.done)} / {formatNumber(job.total)} · {Math.round(pct * 100)}% · </>}
+          已用 {started ? formatDuration(Math.max(0, now - started)) : NONE}
+        </span>
+      </div>
+      {pct != null && (
+        <div className="mt-1.5 h-1 overflow-hidden rounded-full bg-hover" role="progressbar" aria-label="重建索引进度"
+             aria-valuemin={0} aria-valuemax={job.total} aria-valuenow={job.done}
+             aria-valuetext={`${step}，合计 ${job.done} / ${job.total}`}>
+          {/* 用 scaleX 推进而不是改 width：只动 transform，不触发重排 */}
+          <div className="h-full origin-left rounded-full bg-[var(--st-running)] transition-transform duration-500"
+               style={{ transform: `scaleX(${pct})` }} />
+        </div>
+      )}
+      <p className="mt-1.5 text-2xs text-faint">
+        {job.phase === 'index'
+          ? '片段的向量都算完了，在把倒排索引整个重建一遍。这一步没有分批进度，库大的话要等一会儿。'
+          : `${job.collection ? `只重建「${job.collection}」的片段；` : ''}记忆和知识库共用一个向量模型，一起重建。可以离开这一页，回来还能看到进度。`}
+      </p>
+    </div>
+  )
+}
+
 // -------------------------------------------------------------------------
 
 function KbTab() {
@@ -486,7 +587,14 @@ const FALLBACK_FORMATS = {
   legacy: ['.doc', '.ppt', '.xls'],
 }
 
-interface Uploading { key: number; name: string; size: number; at: number }
+interface Uploading {
+  key: number; name: string; size: number
+  /** 轮到它、开始发的时刻。一次传一个，排在后面的还没开始 */
+  startedAt?: number
+  progress?: UploadProgress
+  /** 字节发完的时刻：之后是后端在解析、切块 */
+  sentAt?: number
+}
 
 function KbList() {
   const navigate = useNavigate()
@@ -501,6 +609,7 @@ function KbList() {
   const [dragging, setDragging] = useState(false)
   const fileRef = useRef<HTMLInputElement>(null)
   const uploadSeq = useRef(0)
+  const aborts = useRef(new Map<number, AbortController>())
   const { info, refresh: refreshInfo } = useEmbedding(collection)
 
   const load = async () => {
@@ -544,23 +653,41 @@ function KbList() {
       }
     }
     if (!ok.length) return
-    const items = ok.map((f) => ({ key: ++uploadSeq.current, name: f.name, size: f.size, at: Date.now(), file: f }))
+    const items = ok.map((f) => ({ key: ++uploadSeq.current, name: f.name, size: f.size, file: f }))
+    for (const item of items) aborts.current.set(item.key, new AbortController())
     setUploads((u) => [...items.map(({ file: _f, ...rest }) => rest), ...u])
+    const patch = (key: number, next: (x: Uploading) => Partial<Uploading>) =>
+      setUploads((u) => u.map((x) => (x.key === key ? { ...x, ...next(x) } : x)))
+    // 一次传一个：并发传几个大文件，每个都慢，谁都等不到「处理中」
     for (const item of items) {
+      const ctl = aborts.current.get(item.key)
       try {
-        await api.kb.upload(item.file, collection)
+        if (!ctl || ctl.signal.aborted) continue
+        patch(item.key, () => ({ startedAt: Date.now() }))
+        await api.kb.upload(item.file, collection, {
+          signal: ctl.signal,
+          onProgress: (p) => patch(item.key, (x) => ({ progress: p, sentAt: x.sentAt ?? (p.sent ? Date.now() : undefined) })),
+        })
         await load()
       } catch (e) {
+        // 人点的取消：不算出错
+        if (e instanceof DOMException && e.name === 'AbortError') continue
         const h = humanizeError(e)
         const text = `${item.name} 没传上：${h.reason ? `${h.title}，${h.reason}` : h.title}`
         toast.error(text, { detail: h.raw, action: /表格|数据源/.test(text) ? toData : undefined })
       } finally {
+        aborts.current.delete(item.key)
         setUploads((u) => u.filter((x) => x.key !== item.key))
       }
     }
     await load()
     await refreshCatalog()
   }
+  // 排着队的直接拿掉；在传的由上面那个循环收尾（它会拿到 AbortError）
+  const cancelUpload = (key: number) => {
+    aborts.current.get(key)?.abort()
+    setUploads((u) => u.filter((x) => x.key !== key || !!x.startedAt))
+  }
 
   const newCollection = async () => {
     const name = await promptDialog({
@@ -646,7 +773,7 @@ function KbList() {
           </div>
         )}
 
-        {uploads.map((u) => <UploadingRow key={u.key} item={u} />)}
+        {uploads.map((u) => <UploadingRow key={u.key} item={u} onCancel={() => cancelUpload(u.key)} />)}
 
         {docs === null ? (
           docsError ? <ErrorState compact error={docsError} onRetry={() => void load()} className="m-3" />
@@ -676,15 +803,31 @@ function KbList() {
   )
 }
 
-function UploadingRow({ item }: { item: Uploading }) {
+/**
+ * 上传占位行：真实的字节进度，发完之后写「处理中」。字节没发完之前可以取消——
+ * 后端收不全就什么都不会建；发完了后端已经在切块，取消只会让人以为没传上
+ */
+function UploadingRow({ item, onCancel }: { item: Uploading; onCancel: () => void }) {
   const now = useRunClock(true)
+  const sent = !!item.progress?.sent
   return (
     <div className="flex items-center gap-3 border-b px-3 py-2" data-uploading>
-      <Spinner size={14} />
+      {item.startedAt ? <Spinner size={14} /> : <Upload size={14} className="shrink-0 text-faint" aria-hidden />}
       <div className="min-w-0 flex-1">
-        <div className="truncate text-sm">{item.name}</div>
-        <div className="tnum text-2xs text-faint">上传中 · {formatBytes(item.size)} · {formatDuration(now - item.at)}</div>
+        <div className="flex items-baseline gap-2">
+          <span className="truncate text-sm">{item.name}</span>
+          <span className="tnum shrink-0 text-2xs text-faint">{formatBytes(item.size)}</span>
+        </div>
+        <div className="mt-0.5 text-2xs">
+          <UploadMeter progress={item.progress ?? null} startedAt={item.startedAt} sentAt={item.sentAt}
+                       processing="后端在解析、切块" now={now} />
+        </div>
       </div>
+      {!sent && (
+        <button className="btn btn-sm btn-ghost shrink-0" onClick={onCancel} aria-label={`取消上传 ${item.name}`}>
+          <X size={12} aria-hidden /> 取消
+        </button>
+      )}
     </div>
   )
 }
@@ -765,7 +908,7 @@ function KbSearch({ collection, info }: { collection: string; info: EmbeddingInf
   const [query, setQuery] = useState('')
   const [alpha, setAlpha] = useState<number | null>(null)
   const [busy, setBusy] = useState(false)
-  const [res, setRes] = useState<{ results: any[]; degraded?: string[]; alpha?: number } | null>(null)
+  const [res, setRes] = useState<KbSearchResult | null>(null)
 
   // 集合切换、或运行时默认值变了（换了 embedder），就回到运行时的值
   useEffect(() => { if (runtime != null) setAlpha(runtime) }, [collection, runtime])
@@ -846,6 +989,13 @@ function KbSearch({ collection, info }: { collection: string; info: EmbeddingInf
             {!!res.degraded?.length && (
               <span className="text-[var(--warn)]" title={res.degraded.join('\n')}>已退回关键词：{res.degraded[0]}</span>
             )}
+            {res.results.some((h) => h.contrib) && (
+              <span className="ml-auto inline-flex items-center gap-1.5" data-contrib-legend>
+                总分 =
+                <Swatch color={VIA_SEMANTIC} /> 语义贡献 +
+                <Swatch color={VIA_KEYWORD} /> 关键词贡献
+              </span>
+            )}
           </div>
           {!res.results.length && <div className="text-xs text-faint">没有命中</div>}
           {res.results.map((hit) => <HitCard key={hit.chunk_id} hit={hit} />)}
@@ -856,13 +1006,31 @@ function KbSearch({ collection, info }: { collection: string; info: EmbeddingInf
 }
 
 /**
- * 一条命中。总分是候选集上归一化后的混合分（0–1），可以画成条；语义分是原始
- * 余弦（0–1）也可以；关键词分是原始 BM25，没有上界，画条会误导——只写数。
+ * 贡献条的两种颜色：分类色，只说「哪一路检索」，不表达状态（ok / warn / err /
+ * accent 留给状态）。亮暗各一套，都过了色觉区分度和对表面的对比度检查；跟着
+ * color-scheme 走，所以写成 light-dark()
  */
-function HitCard({ hit }: { hit: any }) {
+const VIA_SEMANTIC = 'light-dark(#0a7ea4, #2b95c0)'
+const VIA_KEYWORD = 'light-dark(#c2447a, #d55181)'
+
+function Swatch({ color }: { color: string }) {
+  return <i aria-hidden className="inline-block h-2 w-2 shrink-0 rounded-[2px]" style={{ background: color }} />
+}
+
+/**
+ * 一条命中。总分是候选集上归一化后的混合分（0–1），拆成两段：语义那一路贡献了
+ * 多少、关键词那一路贡献了多少（两段之和就是总分，后端按 α 加权后给的）。人一眼
+ * 看得出这条是靠哪一路捞上来的，调 α 时知道在动哪一段。
+ *
+ * 原始分另外写成数：语义是余弦（0–1），关键词是 BM25（没有上界，画条会误导）。
+ * 老后端没有 contrib，就退回一根总分条
+ */
+function HitCard({ hit }: { hit: KbHit }) {
   const vec = typeof hit.signals?.vector === 'number' ? hit.signals.vector : null
   const kw = typeof hit.signals?.keyword === 'number' ? hit.signals.keyword : null
+  const c = hit.contrib
   const only = vec && !kw ? '只靠语义命中' : kw && !vec ? '只靠关键词命中' : null
+  const raw = (v: number | null, digits: number) => (v == null ? '—' : v.toFixed(digits))
   return (
     <Link to={`/knowledge/kb/${hit.document_id}#chunk-${hit.ordinal}`}
           className="block rounded-lg border bg-bg p-2.5 hover:border-[var(--border-strong)]" data-hit>
@@ -871,18 +1039,47 @@ function HitCard({ hit }: { hit: any }) {
         <span className="shrink-0">片段 {hit.ordinal}</span>
         {only && <span className="chip shrink-0">{only}</span>}
         <span className="ml-auto shrink-0">总分</span>
-        <Bar value={hit.score} />
+        {c ? <ContribBar vector={c.vector} keyword={c.keyword} /> : <Bar value={hit.score} />}
         <span className="mono tnum w-11 shrink-0 text-right text-dim">{Number(hit.score).toFixed(3)}</span>
       </div>
-      <div className="mt-1 flex items-center gap-3 text-2xs text-faint">
-        <span className="inline-flex items-center gap-1.5">语义余弦 <Bar value={vec ?? 0} thin /> <span className="mono tnum">{vec == null ? '—' : vec.toFixed(3)}</span></span>
-        <span>关键词 BM25 <span className="mono tnum">{kw == null ? '—' : kw.toFixed(2)}</span></span>
-      </div>
+      {c ? (
+        <div className="mt-1 flex flex-wrap items-center gap-x-3 gap-y-0.5 text-2xs text-faint" data-contrib>
+          <span className="inline-flex items-center gap-1">
+            <Swatch color={VIA_SEMANTIC} />语义 <span className="mono tnum text-dim">+{Math.max(0, c.vector).toFixed(3)}</span>
+            <span>（余弦 <span className="mono tnum">{raw(vec, 3)}</span>）</span>
+          </span>
+          <span className="inline-flex items-center gap-1">
+            <Swatch color={VIA_KEYWORD} />关键词 <span className="mono tnum text-dim">+{Math.max(0, c.keyword).toFixed(3)}</span>
+            <span>（BM25 <span className="mono tnum">{raw(kw, 2)}</span>）</span>
+          </span>
+        </div>
+      ) : (
+        <div className="mt-1 flex items-center gap-3 text-2xs text-faint">
+          <span className="inline-flex items-center gap-1.5">语义余弦 <Bar value={vec ?? 0} thin /> <span className="mono tnum">{raw(vec, 3)}</span></span>
+          <span>关键词 BM25 <span className="mono tnum">{raw(kw, 2)}</span></span>
+        </div>
+      )}
       <div className="mt-1.5 line-clamp-3 text-xs leading-relaxed">{hit.content}</div>
     </Link>
   )
 }
 
+/**
+ * 总分拆成两段的条：整根轨道是 1 分，两段依次排开，中间留 2px 缝。关键词那段是
+ * 后端用减法算出来的，四舍五入可能出一点点负数，画的时候当 0
+ */
+function ContribBar({ vector, keyword }: { vector: number; keyword: number }) {
+  const v = Math.max(0, Math.min(1, vector))
+  const k = Math.max(0, Math.min(1 - v, keyword))
+  return (
+    <span className="inline-flex h-1.5 w-16 shrink-0 gap-[2px] overflow-hidden rounded-full bg-hover" aria-hidden
+          title={`语义贡献 ${v.toFixed(3)} + 关键词贡献 ${k.toFixed(3)} = 总分 ${(v + k).toFixed(3)}`}>
+      {v > 0 && <span className="h-full shrink-0 rounded-l-full" style={{ width: `${v * 100}%`, background: VIA_SEMANTIC }} />}
+      {k > 0 && <span className={clsx('h-full shrink-0', !v && 'rounded-l-full')} style={{ width: `${k * 100}%`, background: VIA_KEYWORD }} />}
+    </span>
+  )
+}
+
 function Bar({ value, thin = false }: { value: number; thin?: boolean }) {
   const pct = Math.max(0, Math.min(1, Number(value) || 0)) * 100
   return (
@@ -1304,6 +1501,7 @@ function SkillsTab() {
         <EmptyState
           icon={<Sparkles size={22} />}
           title="还没有 Skill"
+          source="skills"
           body="把「先给结论、区分事实与推断」「口径卡怎么写」这类做事方法写成 Skill，挂到节点上复用。"
           action={<button className="btn btn-primary btn-sm" onClick={create}><Plus size={12} aria-hidden /> 新建 Skill</button>}
         />
diff --git a/frontend/src/pages/RunsPage.tsx b/frontend/src/pages/RunsPage.tsx
index d5f5fd97..d22f6ce9 100644
--- a/frontend/src/pages/RunsPage.tsx
+++ b/frontend/src/pages/RunsPage.tsx
@@ -1,7 +1,8 @@
 import { useCallback, useEffect, useMemo, useRef, useState, type KeyboardEvent } from 'react'
 import { useLocation, useNavigate, useParams, useSearchParams } from 'react-router-dom'
 import { History, Inbox, RefreshCw } from 'lucide-react'
-import { EmptyState, IconButton, StatusBadge } from '../components/ui'
+import { EmptyState, IconButton, PageHeader, StatusBadge, useTicker } from '../components/ui'
+import { UNSAVED_WORKFLOW_ID } from '../api/client'
 import { STATUS, type StatusCode } from '../lib/status'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import type { Approval, Run } from '../types'
@@ -10,10 +11,10 @@ import {
 } from './runs/RunList'
 import { RunDetailView } from './runs/RunDetailView'
 import {
-  RUNS_TABS, TAB_CODES, TAB_LABEL, ageMs, asTab, duplicateNames, formatSpan, isLiveRun, matchesCodes,
+  RUNS_TABS, TAB_CODES, TAB_LABEL, UNSAVED_NAME, ageMs, asTab, duplicateNames, formatSpan, isLiveRun, matchesCodes,
   parseQuery, runCode, stripStatusWords, type RunsTab,
 } from './runs/model'
-import { RunTabs, useNow, type TabItem } from './runs/parts'
+import { RunTabs, type TabItem } from './runs/parts'
 import { useApprovalQueue, useRunList, useStatusCounts } from './runs/useRunsData'
 import './runs/runs.css'
 
@@ -133,7 +134,7 @@ export function RunsPage() {
   // 待审批页签也吃同样的类别、工作流、名称条件
   const approvalFilter = useCallback((a: Approval) => {
     if (runClass && a.run_class !== runClass) return false
-    if (workflowId && a.workflow_id !== workflowId) return false
+    if (workflowId === UNSAVED_WORKFLOW_ID ? !!a.workflow_id : workflowId && a.workflow_id !== workflowId) return false
     if (parsed.q && !(a.workflow_name ?? '').toLowerCase().includes(parsed.q.toLowerCase())) return false
     return true
   }, [runClass, workflowId, parsed.q])
@@ -161,7 +162,7 @@ export function RunsPage() {
     navigate({ pathname: '/runs', search: location.search }, { replace: true })
   }, [removeRow, navigate, location.search])
 
-  const now = useNow(60_000)
+  const now = useTicker(60_000)
   const queueItems = queue.items.filter(approvalFilter)
   const oldest = oldestAge(queueItems, now)
   const running = (counts.counts.running ?? 0) + (counts.counts.queued ?? 0)
@@ -205,17 +206,13 @@ export function RunsPage() {
 
   return (
     <div className="flex h-full flex-col" data-runs-page="">
-      {/* 页头和工具、知识、数据、设置几页同一个样子：48px 高、图标框、标题、一句
-          说明。待审批的数不在这里重复——紧下面的页签上就有 */}
-      <header className="flex h-12 shrink-0 items-center gap-2.5 border-b bg-panel px-4">
-        <span className="flex h-6 w-6 shrink-0 items-center justify-center rounded-md border bg-elev text-dim" aria-hidden>
-          <History size={13} />
-        </span>
-        <h1 className="shrink-0 text-sm font-semibold">记录</h1>
-        <p className="min-w-0 truncate text-xs text-faint">每次运行的完整轨迹、待处理的审批和封存凭证</p>
-        <span className="flex-1" />
-        <IconButton label="刷新" icon={<RefreshCw size={12} aria-hidden />} onClick={refreshAll} data-runs-refresh="" />
-      </header>
+      {/* 待审批的数不在页头里重复——紧下面的页签上就有 */}
+      <PageHeader
+        icon={<History size={13} />}
+        title="记录"
+        subtitle="每次运行的完整轨迹、待处理的审批和封存凭证"
+        actions={<IconButton label="刷新" icon={<RefreshCw size={12} aria-hidden />} onClick={refreshAll} data-runs-refresh="" />}
+      />
 
       <div className="flex min-h-0 flex-1">
         <aside className="flex w-[360px] shrink-0 flex-col border-r bg-panel xl:w-[400px]" aria-label="运行列表">
@@ -299,7 +296,8 @@ function describeFilters({ tab, parsed, segment, runClass, workflowId, workflows
   else if (tab === 'all' && segment.length) parts.push(`状态「${segment.map((c) => STATUS[c].short).join('、')}」`)
   if (parsed.q) parts.push(`名称含「${parsed.q}」`)
   if (runClass) parts.push(runClass === 'formal' ? '正式运行' : '探索运行')
-  if (workflowId) parts.push(`工作流「${workflows.find((w) => w.id === workflowId)?.name ?? '已删除的工作流'}」`)
+  if (workflowId === UNSAVED_WORKFLOW_ID) parts.push(UNSAVED_NAME)
+  else if (workflowId) parts.push(`工作流「${workflows.find((w) => w.id === workflowId)?.name ?? '已删除的工作流'}」`)
   if (!parts.length) return null
   return `筛选条件：${parts.join(' · ')}${tab !== 'all' ? `（在「${TAB_LABEL[tab]}」里）` : ''}`
 }
diff --git a/frontend/src/pages/SettingsPage.tsx b/frontend/src/pages/SettingsPage.tsx
index ee674883..2593838a 100644
--- a/frontend/src/pages/SettingsPage.tsx
+++ b/frontend/src/pages/SettingsPage.tsx
@@ -9,19 +9,18 @@ import { api } from '../api/client'
 import type { ProviderDraft } from '../api/client'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import {
-  confirmDialog, EmptyState, ErrorState, Field, isComposing, Modal, promptDialog, Skeleton, Spinner,
-  TabPanel, Tabs, toast, useTabRoute,
+  confirmDialog, DeleteButton, EmptyState, ErrorState, Field, HealthPill, isComposing, Modal, PageHeader,
+  promptDialog, SectionBar, Skeleton, Spinner, TabPanel, Tabs, toast, useRadioGroup, useTabRoute,
 } from '../components/ui'
+import { setThemePref, useTheme } from '../components/CommandPalette'
 import { humanizeError } from '../lib/errors'
-import { formatNumber } from '../lib/format'
+import { formatNumber, shortLabel } from '../lib/format'
+import { checkHealth, forgetHealth, healthFromServer, setHealth, useHealth } from '../lib/health'
+import type { HealthRecord } from '../lib/health'
+import { workflowList, workflowsMentioning } from '../lib/mentions'
 import type { Provider } from '../types'
-import { applyTheme, normalizeTheme, readThemePref } from '../lib/theme'
+import { normalizeTheme } from '../lib/theme'
 import type { ThemePref } from '../lib/theme'
-import {
-  checkHealth, DeleteButton, forgetHealth, HealthPill, PageHeader, SectionBar, setHealth, shortLabel,
-  useHealth, useRadioGroup, workflowList, workflowsMentioning,
-} from './DataSourcesTab'
-import type { HealthRecord } from './DataSourcesTab'
 
 // 提到模块级：tab 名同时是 URL 的最后一段，两处各写一份迟早对不上。
 // 数据源搬去了顶级的「数据」页（/data），/settings/datasources 跳过去
@@ -127,6 +126,7 @@ function ProvidersTab() {
         <EmptyState
           icon={<KeyRound size={22} />}
           title="还没有配置模型"
+          source="providers"
           body="接一个 Anthropic、OpenAI，或任何 OpenAI 兼容的服务（DeepSeek、通义、本机 Ollama…），agent 才跑得起来。"
           action={<button className="btn btn-primary btn-sm" onClick={() => setEditing('new')}><Plus size={12} aria-hidden /> 添加接入</button>}
         />
@@ -144,9 +144,12 @@ function ProvidersTab() {
           provider={editing === 'new' ? null : editing}
           catalog={catalog}
           onClose={() => setEditing(null)}
-          onSaved={(saved, tested) => {
+          onSaved={(saved, tested, reconnected) => {
             setEditing(null)
+            // 本机记着的那次测连接说的是改之前的配置：换了地址、钥匙或默认模型，
+            // 它就不作数了（后端同样清掉了自己记的那份）
             if (tested) setHealth(`provider:${saved.id}`, tested)
+            else if (reconnected) forgetHealth(`provider:${saved.id}`)
             void refresh()
             toast.ok(`已保存「${saved.name}」`)
           }}
@@ -160,7 +163,8 @@ function ProviderCard({ provider: p, kindLabel, onEdit, onRemove }: {
   provider: Provider; kindLabel: string; onEdit: () => void; onRemove: () => void
 }) {
   const key = `provider:${p.id}`
-  const { record, checkingSince } = useHealth(key)
+  // 后端记着上次测的结果：换了浏览器、清了缓存也还在。本机刚测过的更新就用本机的
+  const { record, checkingSince } = useHealth(key, healthFromServer(p))
   const test = () => checkHealth(key, async () => {
     const r = await api.providers.test(p.id, { model: p.default_model ?? undefined })
     return {
@@ -215,9 +219,18 @@ interface ProviderForm {
   extra: Record<string, any>
 }
 
+/**
+ * 决定「连不连得上」的那几项：类型、地址、钥匙、请求头、测的哪个模型。和后端
+ * 判断测连接结果还作不作数的那份指纹是同一组字段，改名字、改可选模型不算
+ */
+const providerConnection = (f: ProviderForm) => JSON.stringify([
+  f.kind, f.base_url.trim(), !!f.api_key, f.extra?.auth_style ?? null, f.extra?.headers ?? null, f.default_model,
+])
+
 function ProviderEditor({ provider, catalog, onClose, onSaved }: {
   provider: Provider | null; catalog: any; onClose: () => void
-  onSaved: (saved: Provider, tested?: HealthRecord) => void
+  /** reconnected：连接配置改过了，之前测的结果不再代表它 */
+  onSaved: (saved: Provider, tested?: HealthRecord, reconnected?: boolean) => void
 }) {
   const [initial, setInitial] = useState<ProviderForm>(() => ({
     name: provider?.name ?? '',
@@ -353,7 +366,7 @@ function ProviderEditor({ provider, catalog, onClose, onSaved }: {
       const saved = provider
         ? await api.providers.update(provider.id, payload)
         : await api.providers.create(payload)
-      onSaved(saved, testFresh ? test.result : undefined)
+      onSaved(saved, testFresh ? test.result : undefined, providerConnection(form) !== providerConnection(initial))
     } catch (e) {
       toast.error(e)
     } finally {
@@ -579,8 +592,8 @@ function ProviderEditor({ provider, catalog, onClose, onSaved }: {
 
 /**
  * 偏好设置。保存规则只有两条，页面上写明：
- * - 主题：选中即生效、即保存（只 PUT ui.theme）。它当场就变了样，再要求点保存，
- *   用户离开时会以为已经存了，下次打开又回到旧主题；
+ * - 主题：选中即生效、即保存（setThemePref，和导航、⌘K 的切换同一条路）。它当场
+ *   就变了样，再要求点保存，用户离开时会以为已经存了，下次打开又回到旧主题；
  * - 其余（署名、运行默认值）：改完点「保存设置」，底部常驻一条「有 N 项未保存」，
  *   切标签、点导航、关页都会先问。危险工具审批这种安全开关不能误点一下就生效，
  *   所以不做自动保存。署名以前每敲一个字就写 localStorage，现在跟着一起保存。
@@ -590,8 +603,6 @@ function PrefsTab({ onDirty }: { onDirty: (n: number) => void }) {
   const [values, setValues] = useState<Record<string, any> | null>(null)
   const [loadError, setLoadError] = useState<unknown>(null)
   const [scopes, setScopes] = useState<{ scope: string; count: number }[]>([])
-  const [theme, setTheme] = useState<ThemePref>(() => readThemePref())
-  const [themeSave, setThemeSave] = useState<{ state: 'saving' | 'saved' | 'error'; error?: unknown } | null>(null)
   // 署名存在 localStorage，保存后成为新的基线，不再算作改动
   const savedActor = useRef<string>((() => { try { return localStorage.getItem('agentlab_actor') ?? '' } catch { return '' } })())
   const [draft, setDraft] = useState<{ actor: string; scope: string; collection: string; confirm: boolean } | null>(null)
@@ -601,9 +612,7 @@ function PrefsTab({ onDirty }: { onDirty: (n: number) => void }) {
 
   const load = async () => {
     try {
-      const v = await api.settings.get()
-      setValues(v)
-      setTheme(normalizeTheme(v?.ui?.theme))
+      setValues(await api.settings.get())
       setLoadError(null)
     } catch (e) {
       setLoadError(e)
@@ -632,63 +641,52 @@ function PrefsTab({ onDirty }: { onDirty: (n: number) => void }) {
     const t = setTimeout(() => setSavedFlash(0), 1600)
     return () => clearTimeout(t)
   }, [savedFlash])
-  // 主题旁的「已保存」同样只亮一下：一直挂着就不再是「刚存上」的回执了
-  useEffect(() => {
-    if (themeSave?.state !== 'saved') return
-    const t = setTimeout(() => setThemeSave((s) => (s?.state === 'saved' ? null : s)), 1600)
-    return () => clearTimeout(t)
-  }, [themeSave])
 
   const edit = (patch: Partial<typeof saved>) => {
     setSaveError(null)
     setDraft({ ...cur, ...patch })
   }
 
-  const pickTheme = async (next: ThemePref) => {
-    setTheme(next)
-    applyTheme(normalizeTheme(next))
-    if (!values) return
-    setThemeSave({ state: 'saving' })
-    try {
-      const out = await api.settings.put({ ui: { ...(values.ui ?? {}), theme: next } })
-      setValues((v) => ({ ...(v ?? {}), ui: out?.ui ?? { ...(v?.ui ?? {}), theme: next } }))
-      setThemeSave({ state: 'saved' })
-    } catch (e) {
-      setThemeSave({ state: 'error', error: e })
-    }
-  }
-
+  /**
+   * 署名只在这台浏览器里，先落本机：它不该跟着后端一起「没存上」。运行默认值
+   * 有改动才 PUT——只改了署名时不必碰服务端，断线时也存得上
+   */
   const save = async () => {
     if (!values || !dirty) return
     setSaving(true)
     setSaveError(null)
-    try {
-      const run = {
-        ...(values.run ?? {}),
-        default_memory_scope: cur.scope,
-        default_collection: cur.collection,
-        confirm_dangerous_tools: cur.confirm,
-      }
-      const out = await api.settings.put({ run })
+    const actor = cur.actor.trim()
+    if (actor !== savedActor.current) {
       try {
-        if (cur.actor.trim()) localStorage.setItem('agentlab_actor', cur.actor.trim())
+        if (actor) localStorage.setItem('agentlab_actor', actor)
         else localStorage.removeItem('agentlab_actor')
       } catch { /* 隐私模式：署名只能这一次会话有效 */ }
-      setValues((v) => ({ ...(v ?? {}), run: out?.run ?? run }))
-      savedActor.current = cur.actor.trim()
+      savedActor.current = actor
+      // 同一个标签页里写 localStorage 不触发 storage 事件：导航底部的署名首字靠它立刻跟上
+      window.dispatchEvent(new Event('agentlab:actor'))
+    }
+    const runChanged = changed.some((k) => k !== 'actor')
+    try {
+      if (runChanged) {
+        const run = {
+          ...(values.run ?? {}),
+          default_memory_scope: cur.scope,
+          default_collection: cur.collection,
+          confirm_dangerous_tools: cur.confirm,
+        }
+        const out = await api.settings.put({ run })
+        setValues((v) => ({ ...(v ?? {}), run: out?.run ?? run }))
+      }
       setDraft(null)
       setSavedFlash(Date.now())
     } catch (e) {
+      // 署名已经存上了：留在草稿里的只剩运行默认值，条上的计数跟着变少
+      setDraft({ ...cur, actor })
       setSaveError(e)
     } finally {
       setSaving(false)
     }
   }
-  if (!values) {
-    return loadError
-      ? <ErrorState error={loadError} onRetry={() => void load()} />
-      : <Skeleton rows={6} height={14} />
-  }
 
   const scopeOptions = [...new Set(['default', ...scopes.map((s) => s.scope), cur.scope])]
   const collectionNames = collections.map((c) => c.collection)
@@ -696,83 +694,77 @@ function PrefsTab({ onDirty }: { onDirty: (n: number) => void }) {
 
   return (
     <div className="max-w-2xl space-y-6 pb-20">
-      <section>
-        <SectionBar title="界面" hint="选中就生效、就保存，所有设备共用。" />
-        <div className="flex flex-wrap items-center gap-3">
-          <ThemeChoice value={theme} onChange={(v) => void pickTheme(v)} />
-          <span className="text-2xs" aria-live="polite" data-theme-save={themeSave?.state}>
-            {themeSave?.state === 'saving' && <span className="inline-flex items-center gap-1 text-faint"><Spinner size={10} /> 正在保存…</span>}
-            {themeSave?.state === 'saved' && <span className="fade-up text-faint"><Check size={11} className="mr-0.5 inline text-[var(--ok)]" aria-hidden />已保存</span>}
-            {themeSave?.state === 'error' && (
-              <span className="text-[var(--err)]">
-                没存上（{humanizeError(themeSave.error).title}），下次打开会回到原来的主题
-                <button className="btn btn-xs ml-2" onClick={() => void pickTheme(theme)}>重试</button>
+      {/* 主题不依赖设置接口：断线时也能换，恢复后自动补存 */}
+      <ThemeSection />
+
+      {!values ? (
+        loadError
+          ? <ErrorState error={loadError} onRetry={() => void load()} />
+          : <Skeleton rows={6} height={14} />
+      ) : (
+        <>
+          <section>
+            <SectionBar title="操作者署名" hint="只存在这台浏览器里，换台电脑要重新填。" />
+            <Field label="名字" htmlFor="pref-actor"
+                   hint="发布、审批、发起正式运行会记到这个名下，随请求头 X-Actor 发送。这是归属记录不是身份认证——多人环境需要真正的登录体系。">
+              <input id="pref-actor" className="field max-w-60" value={cur.actor} placeholder="例如 yilun"
+                     aria-describedby="pref-actor-hint"
+                     onChange={(e) => edit({ actor: e.target.value })} />
+            </Field>
+          </section>
+
+          <section>
+            <SectionBar title="运行默认值" hint="存在服务端，所有人共用。发起运行时没单独指定，就用这里的。" />
+            <div className="grid grid-cols-2 gap-3">
+              <Field label="默认记忆作用域" htmlFor="pref-scope" hint="agent 读写长期记忆用哪一格">
+                <select id="pref-scope" className="field" value={cur.scope}
+                        aria-describedby="pref-scope-hint"
+                        onChange={async (e) => {
+                          if (e.target.value !== '__new__') { edit({ scope: e.target.value }); return }
+                          const name = await promptDialog({
+                            title: '新的记忆作用域', label: '作用域名', placeholder: '比如 quality',
+                            validate: (v) => (/^[\w.-]{1,64}$/.test(v) ? null : '只用字母、数字、下划线、点和短横'),
+                            confirmLabel: '用这个',
+                          })
+                          if (name) edit({ scope: name })
+                        }}>
+                  {scopeOptions.map((s) => {
+                    const n = scopes.find((x) => x.scope === s)?.count
+                    return <option key={s} value={s}>{s}{n != null ? ` · ${formatNumber(n)} 条` : ' · 还没有记忆'}</option>
+                  })}
+                  <option value="__new__">新建一个作用域…</option>
+                </select>
+              </Field>
+              <Field label="默认知识库" htmlFor="pref-collection"
+                     error={collectionMissing ? `「${cur.collection}」这个知识库不存在：检索会落到空库上` : undefined}
+                     hint="检索节点没指定知识库时查它">
+                <select id="pref-collection" className="field" value={cur.collection}
+                        aria-describedby={collectionMissing ? 'pref-collection-error' : 'pref-collection-hint'}
+                        aria-invalid={collectionMissing || undefined}
+                        onChange={(e) => edit({ collection: e.target.value })}>
+                  {collectionMissing && <option value={cur.collection}>{cur.collection}（不存在）</option>}
+                  {collections.map((c) => (
+                    <option key={c.collection} value={c.collection}>
+                      {c.collection} · {formatNumber(c.documents)} 篇 / {formatNumber(c.chunks)} 段
+                    </option>
+                  ))}
+                </select>
+              </Field>
+            </div>
+            <label className="mt-3 flex items-start gap-2 text-xs">
+              <input type="checkbox" className="mt-0.5" checked={cur.confirm}
+                     aria-describedby="pref-confirm-hint"
+                     onChange={(e) => edit({ confirm: e.target.checked })} />
+              <span>
+                危险工具默认需要人工审批
+                <span id="pref-confirm-hint" className="mt-0.5 block text-2xs leading-relaxed text-faint">
+                  只影响探索运行里没单独配置审批策略的节点；正式运行始终至少审批危险工具。受管工作流的发布门禁另外生效。
+                </span>
               </span>
-            )}
-          </span>
-        </div>
-      </section>
-
-      <section>
-        <SectionBar title="操作者署名" hint="只存在这台浏览器里，换台电脑要重新填。" />
-        <Field label="名字" htmlFor="pref-actor"
-               hint="发布、审批、发起正式运行会记到这个名下，随请求头 X-Actor 发送。这是归属记录不是身份认证——多人环境需要真正的登录体系。">
-          <input id="pref-actor" className="field max-w-60" value={cur.actor} placeholder="例如 yilun"
-                 aria-describedby="pref-actor-hint"
-                 onChange={(e) => edit({ actor: e.target.value })} />
-        </Field>
-      </section>
-
-      <section>
-        <SectionBar title="运行默认值" hint="存在服务端，所有人共用。发起运行时没单独指定，就用这里的。" />
-        <div className="grid grid-cols-2 gap-3">
-          <Field label="默认记忆作用域" htmlFor="pref-scope" hint="agent 读写长期记忆用哪一格">
-            <select id="pref-scope" className="field" value={cur.scope}
-                    aria-describedby="pref-scope-hint"
-                    onChange={async (e) => {
-                      if (e.target.value !== '__new__') { edit({ scope: e.target.value }); return }
-                      const name = await promptDialog({
-                        title: '新的记忆作用域', label: '作用域名', placeholder: '比如 quality',
-                        validate: (v) => (/^[\w.-]{1,64}$/.test(v) ? null : '只用字母、数字、下划线、点和短横'),
-                        confirmLabel: '用这个',
-                      })
-                      if (name) edit({ scope: name })
-                    }}>
-              {scopeOptions.map((s) => {
-                const n = scopes.find((x) => x.scope === s)?.count
-                return <option key={s} value={s}>{s}{n != null ? ` · ${formatNumber(n)} 条` : ' · 还没有记忆'}</option>
-              })}
-              <option value="__new__">新建一个作用域…</option>
-            </select>
-          </Field>
-          <Field label="默认知识库" htmlFor="pref-collection"
-                 error={collectionMissing ? `「${cur.collection}」这个知识库不存在：检索会落到空库上` : undefined}
-                 hint="检索节点没指定知识库时查它">
-            <select id="pref-collection" className="field" value={cur.collection}
-                    aria-describedby={collectionMissing ? 'pref-collection-error' : 'pref-collection-hint'}
-                    aria-invalid={collectionMissing || undefined}
-                    onChange={(e) => edit({ collection: e.target.value })}>
-              {collectionMissing && <option value={cur.collection}>{cur.collection}（不存在）</option>}
-              {collections.map((c) => (
-                <option key={c.collection} value={c.collection}>
-                  {c.collection} · {formatNumber(c.documents)} 篇 / {formatNumber(c.chunks)} 段
-                </option>
-              ))}
-            </select>
-          </Field>
-        </div>
-        <label className="mt-3 flex items-start gap-2 text-xs">
-          <input type="checkbox" className="mt-0.5" checked={cur.confirm}
-                 aria-describedby="pref-confirm-hint"
-                 onChange={(e) => edit({ confirm: e.target.checked })} />
-          <span>
-            危险工具默认需要人工审批
-            <span id="pref-confirm-hint" className="mt-0.5 block text-2xs leading-relaxed text-faint">
-              只影响探索运行里没单独配置审批策略的节点；正式运行始终至少审批危险工具。受管工作流的发布门禁另外生效。
-            </span>
-          </span>
-        </label>
-      </section>
+            </label>
+          </section>
+        </>
+      )}
 
       {(dirty > 0 || savedFlash > 0 || saveError != null) && (
         <div
@@ -811,6 +803,50 @@ function PrefsTab({ onDirty }: { onDirty: (n: number) => void }) {
   )
 }
 
+/**
+ * 主题：选中即生效、即保存。显示的是眼下实际应用的偏好（useTheme）——从导航、
+ * ⌘K 换了主题，这里跟着变，不会留着旧值。
+ *
+ * setThemePref 自己处理失败：断线时先在本机生效、恢复后补存，别的失败弹提示。
+ * 它不告诉调用方存没存上，所以「已保存」这句回执是把设置读回来核对过才写的，
+ * 不是猜的；没核对上就不写，失败的那句提示由 setThemePref 给
+ */
+function ThemeSection() {
+  const { pref } = useTheme()
+  const [receipt, setReceipt] = useState<'saving' | 'saved' | null>(null)
+  const latest = useRef<ThemePref>(pref)
+
+  useEffect(() => {
+    if (receipt !== 'saved') return
+    // 「已保存」只亮一下：一直挂着就不再是「刚存上」的回执了
+    const t = setTimeout(() => setReceipt((r) => (r === 'saved' ? null : r)), 1600)
+    return () => clearTimeout(t)
+  }, [receipt])
+
+  const pick = async (next: ThemePref) => {
+    latest.current = next
+    setReceipt('saving')
+    await setThemePref(next)
+    if (latest.current !== next) return
+    const stored = await api.settings.get().then((s) => normalizeTheme(s?.ui?.theme), () => null)
+    if (latest.current !== next) return
+    setReceipt(stored === next ? 'saved' : null)
+  }
+
+  return (
+    <section>
+      <SectionBar title="界面" hint="选中就生效、就保存，所有设备共用。" />
+      <div className="flex flex-wrap items-center gap-3">
+        <ThemeChoice value={pref} onChange={(v) => void pick(v)} />
+        <span className="text-2xs" aria-live="polite" data-theme-save={receipt ?? undefined}>
+          {receipt === 'saving' && <span className="inline-flex items-center gap-1 text-faint"><Spinner size={10} /> 正在保存…</span>}
+          {receipt === 'saved' && <span className="fade-up text-faint"><Check size={11} className="mr-0.5 inline text-[var(--ok)]" aria-hidden />已保存</span>}
+        </span>
+      </div>
+    </section>
+  )
+}
+
 const THEMES: { value: ThemePref; label: string; Icon: typeof Sun }[] = [
   { value: 'system', label: '跟随系统', Icon: Monitor },
   { value: 'light', label: '浅色', Icon: Sun },
diff --git a/frontend/src/pages/StudioPage.tsx b/frontend/src/pages/StudioPage.tsx
index a8ad91f8..4cb151bc 100644
--- a/frontend/src/pages/StudioPage.tsx
+++ b/frontend/src/pages/StudioPage.tsx
@@ -20,7 +20,7 @@ import { AssistantPanel } from '../run/AssistantPanel'
 import { RunControl } from '../run/RunControl'
 import { useRunClock } from '../run/useRunClock'
 import { topology } from '../run/derive'
-import { useStudio, toGraph } from '../store/studio'
+import { EDIT_LOCK_TEXT, editLockOf, toGraph, useEditLock, useStudio } from '../store/studio'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import {
   EmptyState, ErrorState, IconButton, Spinner, isComposing, promptDialog, toast,
@@ -68,6 +68,9 @@ function matches(e: KeyboardEvent, combo: string): boolean {
     && !e.metaKey && !e.ctrlKey && !e.altKey
 }
 
+/** 改图的快捷键。正式运行期间按了要说为什么没反应，不能安静地什么都不做 */
+const EDIT_SHORTCUTS = new Set<StudioShortcutId>(['undo', 'redo', 'paste', 'duplicate', 'layout'])
+
 const PHASE_TEXT: Record<string, string> = {
   connecting: '正在连接模型',
   planning: '正在理解需求、规划步骤',
@@ -98,6 +101,8 @@ export function StudioPage() {
   const redoLabel = useStudio((s) => s.future[s.future.length - 1]?.label)
   const pendingNote = useStudio((s) => s.pendingNote)
   const copilotActive = useStudio((s) => s.copilot.active)
+  // 正式运行在跑已发布的版本：改图的按钮置灰（运行控制照常能用，停得下来）
+  const formalLock = useEditLock() === 'formal'
   // 动作逐个取：解构整个 store 会让这一页跟着每一次状态变化（运行时每个 token）重渲染
   const load = useStudio((s) => s.load)
   const save = useStudio((s) => s.save)
@@ -300,8 +305,9 @@ export function StudioPage() {
   }, [dirty])
 
   const relayout = useCallback(async () => {
-    const { nodes, edges, copilot } = useStudio.getState()
-    if (copilot.active || !nodes.length) return
+    const s = useStudio.getState()
+    const { nodes, edges } = s
+    if (editLockOf(s) || !nodes.length) return
     try {
       setGraph(await api.copilot.layout(toGraph(nodes, edges)))
       toast.ok('已重新排版', { key: 'studio:layout', action: { label: '撤销', onClick: () => useStudio.getState().undo() } })
@@ -329,11 +335,15 @@ export function StudioPage() {
     select(p.nodeId)
     focusNode(p.nodeId)
     if (p.field) {
-      // 检查器是跟着 selectedId 挂上的：等它渲染出来再滚
-      const key = p.field.key
+      // 检查器是跟着 selectedId 挂上的：等它渲染出来再滚。能落到第几项、项里的哪一栏
+      // （第 2 个成员的工具）就落到那儿：成员一多，只滚到「团队成员」还得自己往下找
+      const { key, index, sub } = p.field
       requestAnimationFrame(() => requestAnimationFrame(() => {
-        const el = document.querySelector(`[data-field="${CSS.escape(key)}"]`)
-        el?.scrollIntoView({ block: 'center', behavior: 'smooth' })
+        const field = document.querySelector(`[data-field="${CSS.escape(key)}"]`)
+        const item = index != null ? field?.querySelector(`[data-item="${index}"]`) : null
+        const part = sub ? item?.querySelector(`[data-sub="${CSS.escape(sub)}"]`) : null
+        const still = window.matchMedia('(prefers-reduced-motion: reduce)').matches
+        ;(part ?? item ?? field)?.scrollIntoView({ block: 'center', behavior: still ? 'auto' : 'smooth' })
       }))
     }
   }, [select, focusNode])
@@ -406,6 +416,11 @@ export function StudioPage() {
       if (!hit) return
       // 输入框里只放行保存和 F8：撤销、复制粘贴、⌥V 在那儿是给文字的
       if (isTypingTarget(e.target) && !hit.inInputs && hit.id !== 'nextProblem' && hit.id !== 'prevProblem') return
+      if (EDIT_SHORTCUTS.has(hit.id) && editLockOf(useStudio.getState()) === 'formal') {
+        e.preventDefault()
+        toast.warn(EDIT_LOCK_TEXT.formal, { key: 'studio:readonly' })
+        return
+      }
       if (run(hit.id)) e.preventDefault()
     }
     window.addEventListener('keydown', onKey)
@@ -418,6 +433,7 @@ export function StudioPage() {
     return (
       <EmptyState
         className="h-full"
+        source="workflows"
         title="还没有工作流"
         body="新建一张空白工作流，从模板开始，或者在右边用助手直接把想法生成出来。"
         action={<button className="btn btn-primary" onClick={() => void createWorkflow(navigate, refresh)}>
@@ -457,15 +473,18 @@ export function StudioPage() {
             半张图，运行跑的也是半张图，排版会被它的最终结果覆盖 */}
         <fieldset disabled={copilotActive} className="flex min-w-0 items-center gap-1.5">
           <div className="flex items-center">
-            <IconButton label="撤销" title={undoLabel ? `${hintOf('撤销', 'undo')}：${undoLabel}` : hintOf('撤销', 'undo')}
-                        disabled={!canUndo} onClick={undo} icon={<Undo2 size={13} />} />
-            <IconButton label="重做" title={redoLabel ? `${hintOf('重做', 'redo')}：${redoLabel}` : hintOf('重做', 'redo')}
-                        disabled={!canRedo} onClick={redo} icon={<Redo2 size={13} />} />
+            <IconButton label="撤销" title={formalLock ? EDIT_LOCK_TEXT.formal
+                          : undoLabel ? `${hintOf('撤销', 'undo')}：${undoLabel}` : hintOf('撤销', 'undo')}
+                        disabled={!canUndo || formalLock} onClick={undo} icon={<Undo2 size={13} />} />
+            <IconButton label="重做" title={formalLock ? EDIT_LOCK_TEXT.formal
+                          : redoLabel ? `${hintOf('重做', 'redo')}：${redoLabel}` : hintOf('重做', 'redo')}
+                        disabled={!canRedo || formalLock} onClick={redo} icon={<Redo2 size={13} />} />
           </div>
           <span className="h-4 w-px shrink-0" style={{ background: 'var(--border)' }} />
           <button
             className="btn shrink-0"
-            title="用自然语言生成或修改工作流（Copilot）"
+            title={formalLock ? EDIT_LOCK_TEXT.formal : '用自然语言生成或修改工作流（Copilot）'}
+            disabled={formalLock}
             onClick={() => {
               select(null)   // 属性面板盖着的话先让开
               setHistory(false)
@@ -488,8 +507,9 @@ export function StudioPage() {
                       aria-pressed={history} disabled={!workflow}
                       className={clsx(history && 'bg-hover')} onClick={openHistory}
                       icon={<History size={12} />} />
-          <IconButton label="自动排版" title={hintOf('自动排版', 'layout')} variant="default"
-                      disabled={!nodeCount} onClick={() => void relayout()} icon={<LayoutGrid size={12} />} />
+          <IconButton label="自动排版" title={formalLock ? EDIT_LOCK_TEXT.formal : hintOf('自动排版', 'layout')}
+                      variant="default" disabled={!nodeCount || formalLock}
+                      onClick={() => void relayout()} icon={<LayoutGrid size={12} />} />
           <button className="btn shrink-0" onClick={() => setPublishing(true)} disabled={!workflow || dirty}
                   title={dirty ? '先保存再发布' : '把当前版本立为已发布版本，正式运行只认它'}>
             <ShieldCheck size={12} /> <span className="@max-[1000px]:hidden">发布</span>
@@ -606,7 +626,7 @@ function WidthHandle({ width, onChange }: { width: number; onChange: (w: number)
  * 仍由 published_version 指着。以前只显示一个「草稿」，看不出正式运行其实还能跑、
  * 跑的是哪一版。
  */
-function VersionLabel({ workflow: w }: { workflow: Workflow & { published_by?: string | null } }) {
+function VersionLabel({ workflow: w }: { workflow: Workflow }) {
   const p = w.published_version
   // 画布就是已发布的那一版才算「在线」。老数据里有状态还挂着受管、版本却已经往前走了的
   // （旧的 restore 接口不退回草稿），那也得说清画布是草稿
diff --git a/frontend/src/pages/ToolsPage.tsx b/frontend/src/pages/ToolsPage.tsx
index 5e4d656f..d947940a 100644
--- a/frontend/src/pages/ToolsPage.tsx
+++ b/frontend/src/pages/ToolsPage.tsx
@@ -5,18 +5,16 @@ import clsx from 'clsx'
 import { api, ApiError } from '../api/client'
 import { useCatalog, useOnReconnect } from '../store/catalog'
 import {
-  confirmDialog, EmptyState, ErrorState, Field, JsonInput, Kbd, Modal, Skeleton, Spinner, StatusBadge, TabPanel,
-  Tabs, toast, useTabRoute,
+  confirmDialog, deferDelete, DeleteButton, EmptyState, ErrorState, Field, HealthPill, JsonInput, Kbd, Modal,
+  PageHeader, SectionBar, Skeleton, Spinner, StatusBadge, TabPanel, Tabs, toast, useTabRoute, withoutDeferred,
 } from '../components/ui'
 import { formatDuration } from '../lib/format'
+import { checkHealth, forgetHealth, healthFromServer, useHealth } from '../lib/health'
+import type { HealthRecord } from '../lib/health'
 import { ariaShortcut, matchShortcut } from '../lib/keys'
+import { workflowList, workflowsMentioning } from '../lib/mentions'
 import { useRunClock } from '../run/useRunClock'
 import type { ToolInfo } from '../types'
-import {
-  checkHealth, DeleteButton, deferDelete, forgetHealth, HealthPill, PageHeader, SectionBar, useHealth,
-  withoutDeferred, workflowList, workflowsMentioning,
-} from './DataSourcesTab'
-import type { HealthRecord } from './DataSourcesTab'
 
 // 提到模块级：tab 名同时是 URL 的最后一段，两处各写一份迟早对不上
 const TABS = [
@@ -281,15 +279,33 @@ function ApprovalTag({ tool, long = false }: { tool: ToolInfo; long?: boolean })
   return null
 }
 
-function ToolResult({ result }: { result: any }) {
+/**
+ * 执行 / 试跑的结果。
+ *
+ * note：后端把拼错的参数名按唯一候选纠正了（「参数名 cuont 不存在，已按唯一候选
+ * count 执行」）。跑是跑通了，但人会照着这份参数去配工作流，所以跟在结果下面
+ * 用 warn 写出来，不能只当成功
+ */
+function ToolResult({ result, stale = false }: { result: any; stale?: boolean }) {
   const failed = result.ok === false
   return (
-    <div className="mt-3" data-tool-result={failed ? 'fail' : 'ok'}>
+    <div className={clsx('mt-3', stale && 'opacity-60')} data-tool-result={failed ? 'fail' : 'ok'}>
       <div className="mb-1 flex items-center gap-1.5 text-xs">
         <StatusBadge status={failed ? 'failed' : 'done'} size={12} decorative />
         <span style={{ color: failed ? 'var(--err)' : 'var(--text-dim)' }}>{failed ? '失败' : '成功'}</span>
         {result.duration_ms != null && <span className="tnum text-faint">· {formatDuration(result.duration_ms)}</span>}
+        {stale && <span className="text-faint">· 配置或参数改过了，这是改之前的结果</span>}
       </div>
+      {result.note && (
+        <div className="mb-1.5 flex items-start gap-1.5 rounded-md border px-2 py-1.5 text-xs leading-relaxed" data-tool-note
+             style={{ borderColor: 'color-mix(in srgb, var(--warn) 40%, var(--border))', background: 'color-mix(in srgb, var(--warn) 7%, transparent)' }}>
+          <AlertTriangle size={12} className="mt-0.5 shrink-0 text-[var(--warn)]" aria-hidden />
+          <span>
+            <span className="text-[var(--warn)]">{String(result.note).replace(/[。.]\s*$/, '')}</span>
+            <span className="text-dim">。这次按纠正后的名字跑了，往工作流里抄参数前先把名字改对</span>
+          </span>
+        </div>
+      )}
       {failed ? (
         <ErrorState compact error={result.thrown ?? result} />
       ) : (
@@ -466,7 +482,7 @@ function CustomTools() {
         <EmptyState
           icon={<Wrench size={22} />}
           title="还没有自定义工具"
-          body="把 MES、ERP 的查询接口包成工具，模型就能按需调用。写好参数说明，保存后能直接试跑。"
+          body="把 MES、ERP 的查询接口包成工具，模型就能按需调用。写好参数说明，不用先保存就能试跑。"
           action={<button className="btn btn-primary btn-sm" onClick={create}><Plus size={12} aria-hidden /> 新建工具</button>}
         />
       ) : (
@@ -526,12 +542,16 @@ function CustomToolEditor({ row, onClose, onSaved }: { row: any; onClose: () =>
   const noParams = !Object.keys(form.parameters?.properties ?? {}).length
   const [busy, setBusy] = useState(false)
   const [args, setArgs] = useState<any>(() => exampleArgs(initial.parameters, true))
-  const [trial, setTrial] = useState<{ busy?: boolean; result?: any } | null>(null)
+  const [trial, setTrial] = useState<{ since?: number; result?: any; sig?: string } | null>(null)
+  const clock = useRunClock(!!trial?.since)
 
   const nameError = form.name && !TOOL_NAME_RE.test(form.name) ? '只能用英文字母、数字、下划线，不能以数字开头' : null
   const dirty = JSON.stringify(form) !== JSON.stringify(initial)
-  const missing = [!form.name && '名称', form.kind === 'http' && !form.config.url && 'URL', form.kind === 'python' && !form.config.code && '代码']
+  const missingConfig = [form.kind === 'http' && !form.config.url && 'URL', form.kind === 'python' && !form.config.code && '代码']
     .filter(Boolean) as string[]
+  const missing = [...(form.name ? [] : ['名称']), ...missingConfig]
+  // 试跑结果对应的是哪一份配置和参数：之后改了就把结果标成旧的，免得拿旧结果当新配置的
+  const trialSig = JSON.stringify([form.kind, form.parameters ?? {}, form.config, args ?? {}])
 
   const submit = async () => {
     if (missing.length || nameError) return
@@ -546,12 +566,22 @@ function CustomToolEditor({ row, onClose, onSaved }: { row: any; onClose: () =>
     }
   }
 
+  /**
+   * 试跑眼前这份配置（testDraft），不落库。以前只能跑已保存的：新建要先保存，
+   * 改了代码也得先存——保存等于让节点立刻用上一个还没试过的版本
+   */
   const tryIt = async () => {
-    setTrial({ busy: true })
+    if (trial?.since || missingConfig.length) return
+    const sig = trialSig
+    setTrial({ since: Date.now() })
     try {
-      setTrial({ result: await api.customTools.test(row.id, args ?? {}) })
+      const result = await api.customTools.testDraft({
+        name: form.name && !nameError ? form.name : undefined,
+        kind: form.kind, parameters: form.parameters ?? {}, config: form.config, args: args ?? {},
+      })
+      setTrial({ result, sig })
     } catch (e) {
-      setTrial({ result: { ok: false, thrown: e } })
+      setTrial({ result: { ok: false, thrown: e }, sig })
     }
   }
 
@@ -660,7 +690,9 @@ function CustomToolEditor({ row, onClose, onSaved }: { row: any; onClose: () =>
           <div className="mb-1.5 flex items-center gap-2">
             <span className="text-xs font-medium">试跑</span>
             <span className="text-2xs text-faint">
-              {!row.id ? '先保存，才能试跑' : dirty ? '跑的是已保存的版本：改动先保存再试' : '带上参数跑一次，看返回的样子'}
+              {!row.id
+                ? '用眼前这份配置跑一次，不用先保存'
+                : dirty ? '跑的是眼前这份（含没保存的改动），已保存的版本不受影响' : '带上参数跑一次，看返回的样子'}
             </span>
             <button className="btn btn-xs ml-auto" onClick={() => setArgs(exampleArgs(form.parameters, true))}
                     title="按参数 Schema 重新填示例">
@@ -668,10 +700,14 @@ function CustomToolEditor({ row, onClose, onSaved }: { row: any; onClose: () =>
             </button>
           </div>
           <JsonInput value={args} onChange={setArgs} rows={3} placeholder="{}" />
-          <button className="btn btn-sm mt-2" disabled={!row.id || !!trial?.busy} onClick={() => void tryIt()}>
-            {trial?.busy ? <Spinner size={11} /> : <Play size={11} aria-hidden />} 试跑
+          <button className="btn btn-sm tnum mt-2" disabled={!!trial?.since || missingConfig.length > 0}
+                  title={missingConfig.length ? `还缺：${missingConfig.join('、')}` : '用眼前这份配置和参数跑一次，不保存'}
+                  onClick={() => void tryIt()}>
+            {trial?.since
+              ? <><Spinner size={11} /> 试跑中 {formatDuration(clock - trial.since)}</>
+              : <><Play size={11} aria-hidden /> 试跑</>}
           </button>
-          {trial?.result && <ToolResult result={trial.result} />}
+          {trial?.result && <ToolResult result={trial.result} stale={trial.sig !== trialSig} />}
         </div>
       </div>
     </Modal>
@@ -680,14 +716,18 @@ function CustomToolEditor({ row, onClose, onSaved }: { row: any; onClose: () =>
 
 // -------------------------------------------------------------------------
 
-/** MCP 的连通状态：这次会话里测过的用测的结果，否则用后端记的上次探测状态（不知道是何时的） */
-function mcpRecord(row: any, tested?: HealthRecord): HealthRecord | undefined {
-  if (tested) return tested
-  if (row.status === 'ok') return { ok: true, at: 0, note: `上次探测发现 ${row.tools_cache?.length ?? 0} 个工具` }
-  if (row.status === 'error') return { ok: false, at: 0, error: row.last_error || '上次探测失败' }
-  return undefined
+/**
+ * 后端记着的上次探测（last_check_*，含启动和「重新加载」时的那次连接）。成功时
+ * 补一句发现了几个工具——探测的结论后端只记了连没连上，工具数在 tools_cache 里
+ */
+function mcpServerRecord(row: any): HealthRecord | undefined {
+  const rec = healthFromServer(row)
+  return rec?.ok ? { ...rec, note: `发现 ${row.tools_cache?.length ?? 0} 个工具` } : rec
 }
 
+/** 决定连哪个进程 / 地址的那几项。改了它们，上次探测的结果说的就是另一个服务了 */
+const mcpConnection = (f: any) => JSON.stringify([f.transport, f.command.trim(), f.args.trim(), f.env ?? {}, f.url.trim()])
+
 function McpServers() {
   const refresh = useCatalog((s) => s.refresh)
   const tools = useCatalog((s) => s.tools)
@@ -785,7 +825,14 @@ function McpServers() {
 
       {editing && (
         <McpEditor row={editing} onClose={() => setEditing(null)}
-                   onSaved={async (name) => { setEditing(null); await load(); await refresh(); toast.ok(`已保存 MCP 服务「${name}」`) }} />
+                   onSaved={async (name, reconnected) => {
+                     // 本机记的那次探测说的是改之前的命令 / 地址（后端同样清掉了自己记的）
+                     if (reconnected && editing.id) forgetHealth(`mcp:${editing.id}`)
+                     setEditing(null)
+                     await load()
+                     await refresh()
+                     toast.ok(`已保存 MCP 服务「${name}」`)
+                   }} />
       )}
     </div>
   )
@@ -795,14 +842,15 @@ function McpCard({ row, onEdit, onRemove, onProbed }: {
   row: any; onEdit: () => void; onRemove: () => void; onProbed: () => Promise<void>
 }) {
   const key = `mcp:${row.id}`
-  const { record, checkingSince } = useHealth(key)
-  const shown = mcpRecord(row, record)
+  const { record: shown, checkingSince } = useHealth(key, mcpServerRecord(row))
   const probe = async () => {
     await checkHealth(key, async () => {
       const t0 = performance.now()
       const res = await api.mcp.probe(row.id)
       return {
-        ok: !!res.ok, ms: Math.round(performance.now() - t0), error: res.error, hint: res.hint, detail: res.detail,
+        // 后端量的是连上并列出工具的时间；老后端没有就用往返时间
+        ok: !!res.ok, ms: res.elapsed_ms ?? Math.round(performance.now() - t0),
+        error: res.error, hint: res.hint, detail: res.detail,
         note: res.ok ? `发现 ${res.tools?.length ?? 0} 个工具` : undefined,
       }
     })
@@ -836,7 +884,11 @@ function McpCard({ row, onEdit, onRemove, onProbed }: {
   )
 }
 
-function McpEditor({ row, onClose, onSaved }: { row: any; onClose: () => void; onSaved: (name: string) => void }) {
+function McpEditor({ row, onClose, onSaved }: {
+  row: any; onClose: () => void
+  /** reconnected：连接配置改过了，之前的探测结果不再代表它 */
+  onSaved: (name: string, reconnected: boolean) => void
+}) {
   const [initial] = useState(() => ({
     name: row.name ?? '', transport: row.transport ?? 'stdio', command: row.command ?? '',
     args: (row.args ?? []).join(' '), env: row.env ?? {}, url: row.url ?? '', enabled: row.enabled ?? true,
@@ -857,7 +909,7 @@ function McpEditor({ row, onClose, onSaved }: { row: any; onClose: () => void; o
       const payload = { ...form, args: form.args.split(/\s+/).filter(Boolean) }
       if (row.id) await api.mcp.update(row.id, payload)
       else await api.mcp.create(payload)
-      onSaved(form.name)
+      onSaved(form.name, mcpConnection(form) !== mcpConnection(initial))
     } catch (e) {
       toast.error(e)
     } finally {
diff --git a/frontend/src/pages/runs/ArtifactsPane.tsx b/frontend/src/pages/runs/ArtifactsPane.tsx
new file mode 100644
index 00000000..cd98f0f4
--- /dev/null
+++ b/frontend/src/pages/runs/ArtifactsPane.tsx
@@ -0,0 +1,281 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { FileBox, History } from 'lucide-react'
+import clsx from 'clsx'
+import { api } from '../../api/client'
+import { EmptyState, ErrorState, Skeleton, StatusBadge } from '../../components/ui'
+import { formatBytes, formatClock, formatDateTime, formatNumber, formatTime, parseServerTime } from '../../lib/format'
+import { nodeTypeLabel } from '../../lib/terms'
+import { ArtifactViewer } from '../../run/AssistantStream'
+import { topology } from '../../run/derive'
+import type { Trace } from '../../run/trace'
+import type { GraphSpec } from '../../types'
+import { artifactKindLabel, isEvidence, type RunArtifact } from './model'
+
+// -------------------------------------------------------------------------
+// 数据
+// -------------------------------------------------------------------------
+
+export interface ArtifactList {
+  /** null = 还没取回来过 */
+  items: RunArtifact[] | null
+  state: 'loading' | 'ok' | 'error'
+  error: unknown
+  reload: () => void
+}
+
+/** 跑着的运行每完成一个节点都会多几件：最多两秒取一次，不跟着每条事件敲 */
+const REFRESH_EVERY_MS = 2000
+
+/**
+ * 这次运行的工件清单。页签上要写件数，所以在详情一打开就取；refreshKey 变了
+ * （又有节点跑完、运行收尾）再取，节流到两秒一次。刷新失败保留原来的清单。
+ */
+export function useRunArtifacts(runId: string, refreshKey: string): ArtifactList {
+  const [items, setItems] = useState<RunArtifact[] | null>(null)
+  const [state, setState] = useState<ArtifactList['state']>('loading')
+  const [error, setError] = useState<unknown>(null)
+  const epoch = useRef(0)
+  const lastAt = useRef(0)
+
+  const load = useCallback(async () => {
+    const my = ++epoch.current
+    lastAt.current = Date.now()
+    try {
+      const list = await api.runs.artifacts(runId)
+      if (my !== epoch.current) return
+      setItems(Array.isArray(list) ? (list as RunArtifact[]) : [])
+      setError(null)
+      setState('ok')
+    } catch (e) {
+      if (my !== epoch.current) return
+      setError(e)
+      setState((s) => (s === 'ok' ? s : 'error'))
+    }
+  }, [runId])
+
+  useEffect(() => {
+    const t = window.setTimeout(() => void load(), Math.max(0, lastAt.current + REFRESH_EVERY_MS - Date.now()))
+    return () => window.clearTimeout(t)
+  }, [load, refreshKey])
+
+  return { items, state, error, reload: () => void load() }
+}
+
+// -------------------------------------------------------------------------
+// 页签
+// -------------------------------------------------------------------------
+
+type KindFilter = 'all' | 'evidence' | 'output'
+const FILTER_LABEL: Record<KindFilter, string> = { all: '全部', evidence: '证据快照', output: '节点产出' }
+const FILTER_HINT: Record<KindFilter, string> = {
+  all: '',
+  evidence: '查询、工具调用、知识检索的原始结果：结论里的数字从这里来',
+  output: '每个节点每执行一次的产出：循环里每一轮都有一件',
+}
+/** 一次循环能有上千件：先列这么多，其余点了再展开 */
+const FIRST_ROWS = 300
+
+/**
+ * 工件：这次运行按内容哈希存下来的每一件东西——查询和工具调用的原始结果、每个
+ * 节点每一次的产出。审阅出具物时从这里下钻到证据；打开时按哈希复验。
+ *
+ * 按节点分组、按执行顺序排，和航迹的泳道同一个顺序。能对上时刻的，一键跳到
+ * 航迹里它产出的那一刻。
+ */
+export function ArtifactsPane({ list, graph, trace, labelOf, onMoment }: {
+  list: ArtifactList
+  graph: GraphSpec | null
+  trace: Trace
+  labelOf: (id?: string | null) => string | undefined
+  /** 在航迹里看这件工件产出的那一刻（毫秒时间戳，和航迹同一个钟） */
+  onMoment?: (at: number, nodeId: string | null) => void
+}) {
+  const [filter, setFilter] = useState<KindFilter>('all')
+  const [all, setAll] = useState(false)
+  const [open, setOpen] = useState<{ id: string; title: string } | null>(null)
+  const items = list.items
+
+  const counts = useMemo(() => {
+    const c: Record<KindFilter, number> = { all: 0, evidence: 0, output: 0 }
+    for (const a of items ?? []) {
+      c.all += 1
+      c[isEvidence(a.kind) ? 'evidence' : 'output'] += 1
+    }
+    return c
+  }, [items])
+  const bytes = useMemo(() => (items ?? []).reduce((n, a) => n + (a.size ?? 0), 0), [items])
+
+  const groups = useMemo(() => {
+    const shown = (items ?? []).filter((a) => filter === 'all' || (filter === 'evidence') === isEvidence(a.kind))
+    const order = graph ? topology(graph).order : []
+    const rank = new Map(order.map((id, i) => [id, i]))
+    const byNode = new Map<string, RunArtifact[]>()
+    for (const a of shown) {
+      const key = a.node_id ?? ''
+      const g = byNode.get(key)
+      if (g) g.push(a)
+      else byNode.set(key, [a])
+    }
+    // 图里有的按拓扑序；图里没有的（快照取不到、子工作流里的）按第一件出现的先后排在后面
+    return [...byNode].sort(([a], [b]) => (rank.get(a) ?? Infinity) - (rank.get(b) ?? Infinity))
+  }, [items, filter, graph])
+
+  if (!items) {
+    if (list.state === 'error') return <ErrorState error={list.error} onRetry={list.reload} className="h-full" />
+    return <div className="p-4" aria-busy="true"><Skeleton rows={6} height={22} /></div>
+  }
+  if (!items.length) {
+    return (
+      <EmptyState
+        icon={<FileBox size={22} />}
+        title="这次运行没有工件"
+        body="节点每执行一次的产出、查询和工具调用的原始结果，都会按内容哈希存成工件；一个节点都还没跑完的运行没有。"
+        className="h-full"
+      />
+    )
+  }
+
+  const t0 = trace.timed ? trace.startedAt : undefined
+  let budget = all ? Infinity : FIRST_ROWS
+  const hidden = Math.max(0, groups.reduce((n, [, g]) => n + g.length, 0) - FIRST_ROWS)
+
+  return (
+    <div className="flex h-full min-h-0 flex-col" data-run-artifacts="">
+      <div className="flex shrink-0 flex-wrap items-center gap-x-3 gap-y-1 border-b px-4 py-1.5 text-2xs text-faint">
+        <div className="flex gap-0.5" role="group" aria-label="按类型筛选工件">
+          {(Object.keys(FILTER_LABEL) as KindFilter[]).map((k) => (
+            <button
+              key={k}
+              type="button"
+              aria-pressed={filter === k}
+              disabled={k !== 'all' && !counts[k]}
+              title={FILTER_HINT[k] || undefined}
+              onClick={() => setFilter(k)}
+              data-artifact-kind={k}
+              className={clsx(
+                'inline-flex h-6 items-center gap-1 rounded-full border px-2 transition-colors disabled:opacity-45',
+                filter === k ? 'border-[var(--border-strong)] bg-hover text-fg' : 'border-transparent hover:bg-hover hover:text-dim',
+              )}
+            >
+              {FILTER_LABEL[k]} <span className="tnum">{counts[k]}</span>
+            </button>
+          ))}
+        </div>
+        <span className="flex-1" />
+        <span className="tnum" title="按内容哈希存放：打开时重算一遍，和运行时记下的对得上才显示">
+          合计 {formatBytes(bytes)} · 打开时按哈希复验
+        </span>
+      </div>
+
+      <div className="min-h-0 flex-1 overflow-y-auto">
+        {groups.map(([nodeId, rows]) => {
+          if (budget <= 0) return null
+          const take = rows.slice(0, budget)
+          budget -= take.length
+          return (
+            <Group key={nodeId || '—'} nodeId={nodeId} rows={take} total={rows.length} graph={graph} trace={trace}
+                   labelOf={labelOf} t0={t0} onOpen={setOpen} onMoment={onMoment} />
+          )
+        })}
+        {!all && hidden > 0 && (
+          <div className="flex items-center justify-center gap-2 px-4 py-3 text-2xs text-faint">
+            <span className="tnum">还有 {formatNumber(hidden)} 件没列出</span>
+            <button type="button" className="btn btn-sm" onClick={() => setAll(true)}>全部列出</button>
+          </div>
+        )}
+      </div>
+
+      <ArtifactViewer id={open?.id ?? null} title={open?.title} onClose={() => setOpen(null)} />
+    </div>
+  )
+}
+
+function Group({ nodeId, rows, total, graph, trace, labelOf, t0, onOpen, onMoment }: {
+  nodeId: string
+  rows: RunArtifact[]
+  total: number
+  graph: GraphSpec | null
+  trace: Trace
+  labelOf: (id?: string | null) => string | undefined
+  t0?: number
+  onOpen: (v: { id: string; title: string }) => void
+  onMoment?: (at: number, nodeId: string | null) => void
+}) {
+  const node = graph?.nodes.find((n) => n.id === nodeId)
+  const label = nodeId ? labelOf(nodeId) ?? nodeId : '不属于某个节点'
+  const state = nodeId ? trace.nodes[nodeId]?.state : undefined
+  // 同一个节点同一类的第几件：循环里几十件「节点产出」要能分得开；只有一件的不编号
+  const ordinal = new Map<string, number>()
+  const perKind = new Map<string, number>()
+  for (const a of rows) perKind.set(a.kind, (perKind.get(a.kind) ?? 0) + 1)
+  return (
+    <section aria-label={label} data-artifact-group={nodeId}>
+      <h3 className="sticky top-0 z-10 flex items-center gap-2 border-b bg-panel px-4 py-1 text-2xs">
+        <span aria-hidden className="h-3 w-[3px] shrink-0 rounded-sm"
+              style={{ background: node ? `var(--nt-${node.type}, var(--text-faint))` : 'var(--text-faint)' }} />
+        <span className="min-w-0 truncate font-medium text-fg">{label}</span>
+        {node && <span className="shrink-0 text-faint">{nodeTypeLabel(node.type)}</span>}
+        {nodeId && label !== nodeId && <span className="mono shrink-0 text-faint">{nodeId}</span>}
+        {state && <StatusBadge status={state} size={11} animate={false} />}
+        <span className="flex-1" />
+        <span className="tnum shrink-0 text-faint">{total} 件</span>
+      </h3>
+      {rows.map((a) => {
+        const n = (ordinal.get(a.kind) ?? 0) + 1
+        ordinal.set(a.kind, n)
+        const kind = artifactKindLabel(a.kind)
+        const attempt = Number(a.meta?.attempt)
+        const created = parseServerTime(a.created_at ?? null)?.getTime()
+        const at = t0 != null && created != null && created >= t0 ? created : null
+        const numbered = (perKind.get(a.kind) ?? 0) > 1
+        const title = `${label} · ${kind}${numbered ? ` #${n}` : ''}`
+        return (
+          <div key={a.id} className="flex items-center gap-2 border-b px-4 py-1 last:border-0 hover:bg-hover"
+               data-artifact-id={a.id}>
+            <button
+              type="button"
+              className="flex min-w-0 flex-1 items-center gap-2 rounded py-0.5 text-left outline-none focus-visible:ring-1 focus-visible:ring-[var(--accent)]"
+              onClick={() => onOpen({ id: a.id, title })}
+              title={`打开${kind}（取回时按内容哈希复验）`}
+              data-action="artifact-open"
+            >
+              <span className={clsx('chip shrink-0', isEvidence(a.kind) && 'text-fg')}
+                    style={isEvidence(a.kind) ? { borderColor: 'var(--border-strong)' } : undefined}>
+                {kind}
+              </span>
+              <span className="min-w-0 truncate text-xs text-dim">
+                {describe(a.kind)}
+                {numbered && <span className="tnum text-faint"> #{n}</span>}
+                {attempt > 1 && <span className="text-faint"> · 第 {attempt} 次尝试</span>}
+              </span>
+              <span className="flex-1" />
+              <span className="mono shrink-0 text-2xs text-faint" title={`内容哈希 ${a.id}`}>{a.id.slice(0, 8)}</span>
+              <span className="tnum w-16 shrink-0 text-right text-2xs text-faint">{formatBytes(a.size)}</span>
+            </button>
+            {at != null && onMoment ? (
+              <button type="button" className="btn btn-xs btn-ghost tnum w-[86px] shrink-0 justify-end"
+                      onClick={() => onMoment(at, a.node_id)} data-action="artifact-moment"
+                      title={`在航迹里看它产出的那一刻（${formatDateTime(a.created_at ?? null)}）`}>
+                <History size={11} aria-hidden /> T+{formatClock(Math.round(at - t0!))}
+              </button>
+            ) : (
+              <span className="tnum w-[86px] shrink-0 text-right text-2xs text-faint" title={formatDateTime(a.created_at ?? null)}>
+                {formatTime(a.created_at ?? null)}
+              </span>
+            )}
+          </div>
+        )
+      })}
+    </section>
+  )
+}
+
+function describe(kind: string): string {
+  switch (kind) {
+    case 'query_snapshot': return '查询：SQL 和结果集'
+    case 'tool_snapshot': return '工具调用：参数和返回'
+    case 'retrieval_snapshot': return '知识检索：命中的片段'
+    case 'node_output': return '这一次执行的产出'
+    default: return '工件'
+  }
+}
diff --git a/frontend/src/pages/runs/Banners.tsx b/frontend/src/pages/runs/Banners.tsx
index 67961981..52e44bac 100644
--- a/frontend/src/pages/runs/Banners.tsx
+++ b/frontend/src/pages/runs/Banners.tsx
@@ -1,10 +1,10 @@
 import type { ReactNode } from 'react'
 import { Link } from 'react-router-dom'
-import { ArrowDown, Copy, Crosshair, Play, RotateCcw, Settings2, Wrench, X } from 'lucide-react'
+import { ArrowDown, Ban, ChartGantt, Copy, Crosshair, Play, RotateCcw, Settings2, Wrench, X } from 'lucide-react'
 import { CopyButton, Spinner, StatusBadge } from '../../components/ui'
 import { formatDateTime, formatTime } from '../../lib/format'
 import type { Approval } from '../../types'
-import type { RunErrorExplain } from './explain'
+import type { RunErrorExplain } from '../../lib/explain'
 import { LONG_WAIT_MS, ageMs, formatSpan } from './model'
 import { copyText } from './parts'
 
@@ -32,13 +32,15 @@ function Shell({ color, children, data }: { color: string; children: ReactNode;
  * 断点续跑在这一页用不上。
  */
 export function FailedBanner({
-  explain, nodeId, nodeLabel, canvasHref, onContinue, onRerun, busy,
+  explain, nodeId, nodeLabel, canvasHref, onShowInTrace, onContinue, onRerun, busy,
 }: {
   explain: RunErrorExplain
   nodeId?: string | null
   nodeLabel?: string
   /** 有工作流才能回画布定位；未保存的图没有地方可回，不放一个点了没用的按钮 */
   canvasHref?: string | null
+  /** 工作流之后改过结构、失败的节点已经不在了：画布上定位不到，改去航迹看它当时的样子 */
+  onShowInTrace?: () => void
   onContinue: () => void
   /** 缺输入的失败：补上那一项，用同一张图重新发起 */
   onRerun?: (field: string) => void
@@ -98,6 +100,12 @@ export function FailedBanner({
                 <Crosshair size={11} aria-hidden /> 在画布中定位
               </Link>
             )}
+            {!canvasHref && onShowInTrace && (
+              <button type="button" className="btn btn-sm" onClick={onShowInTrace} data-action="locate-trace"
+                      title={'工作流在这次运行之后改过结构，现在的图里已经没有这个节点，画布上定位不到它。\n航迹用的是运行时的快照，能看到它当时的样子'}>
+                <ChartGantt size={11} aria-hidden /> 在航迹中看
+              </button>
+            )}
             <button type="button" className="btn btn-sm btn-ghost" data-action="copy-error"
                     onClick={() => void copyText(explain.raw, '报错原文')}>
               <Copy size={11} aria-hidden /> 复制错误
@@ -124,8 +132,13 @@ export function FailedBanner({
 // 挂起
 // -------------------------------------------------------------------------
 
-/** 中断了却没有待审批：服务重启时停下的，断点还在。以前卡头写「等待人工介入」，却没有任何东西可以点 */
-export function HeldBanner({ reason, onContinue, busy }: { reason?: string | null; onContinue: () => void; busy: boolean }) {
+/**
+ * 中断了却没有待审批：服务重启时停下的，断点还在。以前卡头写「等待人工介入」，却没有任何东西可以点。
+ * 不打算再跑的就放弃：挂起的运行没人会再去接，不放弃就在记录里永远挂着「可续跑」
+ */
+export function HeldBanner({ reason, onContinue, onAbandon, busy }: {
+  reason?: string | null; onContinue: () => void; onAbandon: () => void; busy: boolean
+}) {
   return (
     <Shell color="var(--st-suspended)" data="held">
       <div className="flex items-center gap-2.5 text-xs">
@@ -134,6 +147,7 @@ export function HeldBanner({ reason, onContinue, busy }: { reason?: string | nul
           <span className="font-medium text-fg">已挂起，可以接着跑</span>
           <span className="text-dim"> · {reason || '这次运行停在断点上，没有待处理的审批'}。前面跑完的节点不会重跑。</span>
         </span>
+        <AbandonButton onClick={onAbandon} disabled={busy} />
         <button type="button" className="btn btn-sm btn-primary" disabled={busy} onClick={onContinue} data-action="resume">
           {busy ? <Spinner size={11} /> : <Play size={11} aria-hidden />} 接着跑
         </button>
@@ -142,6 +156,16 @@ export function HeldBanner({ reason, onContinue, busy }: { reason?: string | nul
   )
 }
 
+/** 放弃是低频、不可逆的：安静的次级按钮，放在主动作左边，点了还要确认一次 */
+function AbandonButton({ onClick, disabled }: { onClick: () => void; disabled: boolean }) {
+  return (
+    <button type="button" className="btn btn-sm btn-ghost shrink-0" disabled={disabled} onClick={onClick}
+            data-action="abandon" title="不再往下跑：记为已取消，待审批一并关闭；已经跑完的节点和产出保留">
+      <Ban size={11} aria-hidden /> 放弃这次运行
+    </button>
+  )
+}
+
 // -------------------------------------------------------------------------
 // 等审批
 // -------------------------------------------------------------------------
@@ -150,8 +174,9 @@ export function HeldBanner({ reason, onContinue, busy }: { reason?: string | nul
  * 停在审批上：说清楚卡在哪、等了多久，审批卡本身在时间线里（和它要确认的
  * 那件事挨着）。按钮把人带过去。
  */
-export function WaitingBanner({ approvals, labelOf, onJump, now }: {
-  approvals: Approval[]; labelOf: (id?: string | null) => string | undefined; onJump: (id: string) => void; now: number
+export function WaitingBanner({ approvals, labelOf, onJump, onAbandon, busy, now }: {
+  approvals: Approval[]; labelOf: (id?: string | null) => string | undefined; onJump: (id: string) => void
+  onAbandon: () => void; busy: boolean; now: number
 }) {
   const first = approvals[0]
   const waited = ageMs(first.created_at, now)
@@ -172,6 +197,7 @@ export function WaitingBanner({ approvals, labelOf, onJump, now }: {
           </span>
           {approvals.length > 1 && <span className="text-faint"> · 共 {approvals.length} 张审批卡</span>}
         </span>
+        <AbandonButton onClick={onAbandon} disabled={busy} />
         <button type="button" className="btn btn-sm" onClick={() => onJump(first.id)} data-action="jump-approval">
           <ArrowDown size={11} aria-hidden /> 去审批卡
         </button>
diff --git a/frontend/src/pages/runs/RunDetailView.tsx b/frontend/src/pages/runs/RunDetailView.tsx
index bbd2cdbe..87ee00bf 100644
--- a/frontend/src/pages/runs/RunDetailView.tsx
+++ b/frontend/src/pages/runs/RunDetailView.tsx
@@ -1,10 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { Link, useLocation, useNavigate } from 'react-router-dom'
-import { Code2, Copy, GitFork, Link2, Square, SquareArrowOutUpRight, Trash2 } from 'lucide-react'
+import { Link, useLocation, useNavigate, useSearchParams } from 'react-router-dom'
+import { Code2, Copy, GitFork, Link2, Rewind, Square, SquareArrowOutUpRight, Trash2 } from 'lucide-react'
 import clsx from 'clsx'
 import { ApiError, api } from '../../api/client'
 import {
-  ErrorState, IconButton, Skeleton, Spinner, confirmDialog, promptDialog, toast,
+  ErrorState, IconButton, Skeleton, Spinner, confirmDialog, promptDialog, toast, useTicker,
 } from '../../components/ui'
 import { formatDateTime, formatNumber, formatTime, shortId } from '../../lib/format'
 import { resolveStatus, statusLabel, type StatusCode } from '../../lib/status'
@@ -15,16 +15,26 @@ import { runStatusOf, type RunPhase } from '../../run/trace'
 import { useCatalog } from '../../store/catalog'
 import type { Approval, Run, RunEvent } from '../../types'
 import { FailedBanner, FeedbackStrip, HeldBanner, WaitingBanner, type Feedback } from './Banners'
-import { explainRunError } from './explain'
-import { UNSAVED_HINT, duplicateNames, idTail, isLiveRun, isUnsaved, runName, runScope } from './model'
-import { ClassChip, MoreMenu, TierChip, copyText, useNow, type MenuItem } from './parts'
+import { explainRunError } from '../../lib/explain'
+import {
+  UNSAVED_HINT, asView, duplicateNames, graphShape, idTail, isLiveRun, isUnsaved, runName, runScope, type DetailView,
+} from './model'
+import { ArtifactsPane, useRunArtifacts } from './ArtifactsPane'
+import { ClassChip, MoreMenu, RunTabs, TierChip, copyText, type MenuItem, type TabItem } from './parts'
 import { ProvenanceBar, Telemetry, runClocks } from './Telemetry'
+import { TracePane } from './TracePane'
 import { useRunDetail } from './useRunDetail'
 
 /**
- * 一次运行的详情：头部读数、凭证、排错路径，下面是和画布助手栏、问数据页同一个
- * 解码器、同一个组件画的时间线——三处各写一套的话，同一次运行会被讲成三个
- * 不同的故事，而用户没法判断哪个是真的。
+ * 一次运行的详情：头部读数、凭证、排错路径，下面分三个视图——
+ *
+ * - 时间线：和画布助手栏、问数据页同一个解码器、同一个组件画的逐步叙述。三处各写
+ *   一套的话，同一次运行会被讲成三个不同的故事，而用户没法判断哪个是真的；
+ * - 航迹：和画布底部同一个航迹坞，按时间摊开，能拖到任意一刻回放；
+ * - 工件：这次运行按内容哈希存下的每一件证据和产出。
+ *
+ * 视图记在地址的 ?view= 里，换一条运行时留在同一个视图；?at= 是航迹上的时刻
+ * （相对开始的毫秒），从工件、分享的链接直接落到那一刻。
  */
 export function RunDetailView({ runId, onChange, onDeleted }: {
   runId: string
@@ -34,15 +44,17 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
 }) {
   const navigate = useNavigate()
   const { search } = useLocation()
+  const [params, setParams] = useSearchParams()
   const d = useRunDetail(runId, onChange)
   const workflows = useCatalog((s) => s.workflows)
   const catalogLoaded = useCatalog((s) => s.loaded)
   const refreshCatalog = useCatalog((s) => s.refresh)
+  const refreshApprovals = useCatalog((s) => s.refreshApprovals)
   const [raw, setRaw] = useState(false)
-  const [busy, setBusy] = useState<null | 'stop' | 'continue' | 'rerun' | 'extract' | 'delete'>(null)
+  const [busy, setBusy] = useState<null | 'stop' | 'continue' | 'rerun' | 'extract' | 'delete' | 'abandon'>(null)
   const [feedback, setFeedback] = useState<Feedback | null>(null)
   const streamBox = useRef<HTMLDivElement>(null)
-  const now = useNow(60_000)
+  const now = useTicker(60_000)
 
   useEffect(() => {
     if (d.state !== 'missing') return
@@ -63,6 +75,59 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
   const steps = useMemo(() => decodeRun(d.events, final), [d.events, final])
   const code = run ? displayCode(run, phase, pendingFlag) : 'idle'
 
+  // ---- 视图、航迹游标 ----
+  const view = asView(params.get('view'))
+  const setView = useCallback((v: DetailView) => {
+    setParams((prev) => {
+      const next = new URLSearchParams(prev)
+      if (v === 'stream') next.delete('view')
+      else next.set('view', v)
+      return next
+    }, { replace: true })
+  }, [setParams])
+  const [replayAt, setReplayAt] = useState<number | null>(null)
+  // 航迹上选中的节点；undefined 是还没人点过（点过「收起」就是 null）
+  const [traceNode, setTraceNode] = useState<string | null | undefined>(undefined)
+  // 地址里的时刻只在进来时读一次，读完摘掉：拖动游标不回写地址（一帧一次会让
+  // 整页跟着重渲染），留着就和游标对不上了。等事件到了、知道从哪一刻开始才读
+  const atParam = params.get('at')
+  const t0 = d.trace.timed ? d.trace.startedAt : undefined
+  useEffect(() => {
+    if (atParam == null || d.state !== 'ok') return
+    const ms = Number(atParam)
+    if (t0 != null && Number.isFinite(ms) && ms >= 0) setReplayAt(t0 + ms)
+    setParams((prev) => {
+      const next = new URLSearchParams(prev)
+      next.delete('at')
+      return next
+    }, { replace: true })
+  }, [atParam, d.state, t0, setParams])
+  // 失败的、等审批的，航迹上默认就看那个节点。和数据同一次渲染就定下来，不等一个
+  // effect：航迹坞按读数区第一次画出来的高度分地方，晚一拍才出现的节点卡会被压住
+  const focusDefault = d.trace.failedNodeId ?? d.trace.waitingNodeId ?? null
+  const traceSelected = traceNode === undefined ? focusDefault : traceNode
+  const pickTraceNode = useCallback((id: string | null) => setTraceNode(id), [])
+
+  // 从航迹、工件、原始事件切回时间线之后要做的定位（去审批卡、描出某个节点那几步）。
+  // 视图是经地址切的，提交要晚好几帧：固定等两帧的话，焦点会落进还 inert 着的
+  // 时间线，什么也不发生，焦点留在横幅的按钮上。所以等切回来的那次提交再做
+  const reveal = useRef<(() => void) | null>(null)
+  useEffect(() => {
+    const fn = reveal.current
+    if (!fn || view !== 'stream' || raw) return
+    reveal.current = null
+    // inert 已经随这次提交摘掉；再等一帧，让刚换回来的可读视图把审批卡画出来
+    requestAnimationFrame(fn)
+  }, [view, raw])
+
+  // 工件：页签上要写件数，一打开详情就取；又有节点跑完、运行收尾时再取
+  const artifactKey = useMemo(() => {
+    let n = 0
+    for (const e of d.events) if (e.type === 'node.finished' || e.type === 'tool.end' || e.type === 'tool.error') n += 1
+    return `${d.run?.status ?? ''}|${n}`
+  }, [d.events, d.run?.status])
+  const artifacts = useRunArtifacts(runId, artifactKey)
+
   // 接流期间状态变了（跑完、停到审批上）：左边那一行跟着变，不用等整表刷新
   const lastPhase = useRef<RunPhase | null>(null)
   useEffect(() => {
@@ -102,9 +167,24 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
   const workflowGone = !!run.workflow_id && catalogLoaded && !workflows.some((w) => w.id === run.workflow_id)
   const waitingNode = d.trace.waitingNodeId ?? d.pending?.[0]?.node_id
   const focus = code === 'failed' ? failedNode : code === 'waiting' ? waitingNode : null
-  const canvasHref = run.workflow_id && !workflowGone
-    ? `/studio/${run.workflow_id}?run=${run.id}${focus ? `&focus=${encodeURIComponent(focus)}` : ''}`
-    : null
+  // 画布上回放是把这次的事件套在工作流「现在」的图上。之后改过结构的，对不上的
+  // 节点不会亮——先说清，并指到航迹：那里用的是运行时的快照
+  const current = run.workflow_id ? workflows.find((w) => w.id === run.workflow_id)?.graph : undefined
+  const drift = !!d.graph && !!current && graphShape(d.graph) !== graphShape(current)
+  // 这个节点在现在的图里已经没有了：画布上对准它，什么也对不到。工作流还没取回来时
+  // 不知道，照常给
+  const goneFromCanvas = (node?: string | null) => !!node && !!current && !current.nodes.some((n) => n.id === node)
+  const canvasBase = run.workflow_id && !workflowGone ? `/studio/${run.workflow_id}?run=${run.id}` : null
+  // 对准某个节点的入口（失败横幅的定位、航迹节点卡）：节点不在了就不给，免得放一个
+  // 点了落空的按钮
+  const hrefFor = (node?: string | null) => (canvasBase && !goneFromCanvas(node)
+    ? `${canvasBase}${node ? `&focus=${encodeURIComponent(node)}` : ''}`
+    : null)
+  // 详情头是回放整次运行，一直给；对准的节点不在了就只打开，不带 focus
+  const aimed = focus && !goneFromCanvas(focus) ? focus : null
+  const canvasHref = hrefFor(aimed)
+  // 还在往前走的叫「打开」（接着看实时的、去处理），停下的叫「回放」
+  const replayable = code === 'succeeded' || code === 'failed' || code === 'cancelled'
   const dup = !!run.workflow_id && duplicateNames(workflows.map((w) => ({ id: w.id, name: w.name }))).has(run.workflow_name)
 
   // ---- 动作 ----
@@ -121,6 +201,38 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
     }
   }
 
+  // 等审批、挂起的运行不再往下跑：收成已取消，待审批一并关闭（后端记下署名）
+  const abandon = async () => {
+    const n = d.pending?.length ?? 0
+    const actor = localActor()
+    const ok = await confirmDialog({
+      title: '放弃这次运行？',
+      body: code === 'waiting'
+        ? `「${runName(run)}」停在审批上。放弃之后它不会再往下跑，也不能再恢复。`
+        : `「${runName(run)}」挂起在断点上。放弃之后不能再接着跑。`,
+      consequences: [
+        ...(n ? [`${n} 条待审批一并关闭，${actor ? `留痕署名「${actor}」` : '留痕记为未署名（署名在 设置 → 偏好设置 里填）'}`] : []),
+        '运行记为已取消；已经跑完的节点、产出和事件照样保留',
+      ],
+      danger: true,
+      confirmLabel: '放弃这次运行',
+    })
+    if (!ok) return
+    setBusy('abandon')
+    try {
+      await api.runs.cancel(run.id)
+      toast.ok('已放弃这次运行')
+      await d.reload()
+      void d.refreshPending()
+      void refreshApprovals()
+    } catch (e) {
+      toast.error(e)
+      void d.reload()
+    } finally {
+      setBusy(null)
+    }
+  }
+
   const carryOn = async () => {
     setBusy('continue')
     const resume = code !== 'failed'
@@ -206,16 +318,54 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
     void d.refreshPending()
   }
 
-  const jumpToApproval = (id: string) => {
+  // 审批卡、某个节点的几步都在时间线里：别的视图上点过来，先切回时间线，等它
+  // 回来了再定位（见上面的 reveal）
+  const inStream = (fn: () => void) => {
+    if (view === 'stream' && !raw) {
+      fn()
+      return
+    }
+    reveal.current = fn
+    if (raw) setRaw(false)
+    if (view !== 'stream') setView('stream')
+  }
+  const reduceMotion = () => !!window.matchMedia?.('(prefers-reduced-motion: reduce)').matches
+
+  const jumpToApproval = (id: string) => inStream(() => {
     const el = streamBox.current?.querySelector<HTMLElement>(`[data-approval-card="${id}"]`)
     if (!el) return
-    const reduce = window.matchMedia?.('(prefers-reduced-motion: reduce)').matches
-    el.scrollIntoView({ behavior: reduce ? 'auto' : 'smooth', block: 'center' })
+    el.scrollIntoView({ behavior: reduceMotion() ? 'auto' : 'smooth', block: 'center' })
     el.classList.remove('runs-focus-ring')
     void el.offsetWidth
     el.classList.add('runs-focus-ring')
     setTimeout(() => el.classList.remove('runs-focus-ring'), 1500)
     el.querySelector<HTMLElement>('textarea, input, button')?.focus({ preventScroll: true })
+  })
+
+  // 航迹上选中的节点，回到时间线里看它那几步：定位到第一步，用强调色描一下
+  // （data-flash 是时间线自己的描边样式，和点名定位同一种）
+  const revealStep = (nodeId: string) => inStream(() => {
+    const rows = [...(streamBox.current?.querySelectorAll<HTMLElement>(`[data-node-id="${CSS.escape(nodeId)}"]`) ?? [])]
+    if (!rows.length) {
+      toast.info(`时间线里没有「${labelOf(nodeId) ?? nodeId}」的步骤：它没有执行过`)
+      return
+    }
+    rows[0].scrollIntoView({ behavior: reduceMotion() ? 'auto' : 'smooth', block: 'center' })
+    for (const el of rows) el.dataset.flash = 'focus'
+    setTimeout(() => { for (const el of rows) if (el.dataset.flash === 'focus') delete el.dataset.flash }, 1800)
+  })
+
+  // 工件产出的那一刻：去航迹，游标落在那里，选中产出它的节点
+  const showMoment = (at: number, nodeId: string | null) => {
+    setReplayAt(at)
+    if (nodeId) pickTraceNode(nodeId)
+    setView('trace')
+  }
+  // 画布上已经没有的节点：去航迹看它停下时的样子
+  const showInTrace = (nodeId: string) => {
+    setReplayAt(null)
+    pickTraceNode(nodeId)
+    setView('trace')
   }
 
   const extract = async () => {
@@ -337,10 +487,19 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
   ) : null
 
   const unsaved = isUnsaved(run)
+  const artifactCount = artifacts.items?.length
+  const viewTabs: TabItem<DetailView>[] = [
+    { key: 'stream', label: '时间线', title: '逐步看每个节点做了什么、说了什么' },
+    { key: 'trace', label: '航迹', title: '按时间摊开：慢在哪、卡在哪、谁和谁同时；拖到任意一刻回放' },
+    {
+      key: 'artifacts', label: '工件', count: artifactCount, unit: '件', tone: 'quiet',
+      title: artifactCount == null ? '这次运行存下的证据和产出' : `${artifactCount} 件：查询和工具调用的原始结果、每个节点每一次的产出`,
+    },
+  ]
 
   return (
     <div className="flex min-h-0 min-w-0 flex-1 flex-col" data-run-detail={run.id} data-run-code={code}>
-      <header className="shrink-0 border-b">
+      <header className="runs-head shrink-0 border-b">
         <div className="flex items-start gap-3 px-4 pb-2 pt-2.5">
           <div className="min-w-0 flex-1">
             <div className="flex min-w-0 items-center gap-2">
@@ -374,10 +533,21 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
                 {busy === 'stop' ? <Spinner size={11} /> : <Square size={10} aria-hidden fill="currentColor" />} 停止
               </button>
             )}
-            {canvasHref && code !== 'failed' && (
-              <Link className="btn btn-sm" to={canvasHref} data-action="open-canvas"
-                    title={code === 'waiting' ? '打开这张工作流，并对准等审批的节点' : '在画布里打开这张工作流和这次运行'}>
-                <SquareArrowOutUpRight size={11} aria-hidden /> 在画布中打开
+            {canvasHref && (
+              <Link className="btn btn-sm relative" to={canvasHref} data-action="open-canvas"
+                    data-canvas-mode={replayable ? 'replay' : 'live'} data-graph-drift={drift ? '1' : undefined}
+                    title={[
+                      replayable
+                        ? `在画布上回放这次运行：拖底部的航迹，卡片回到那一刻${aimed ? '；对准失败的节点' : ''}`
+                        : code === 'waiting' && aimed ? '打开这张工作流，并对准等审批的节点' : '在画布里打开这张工作流，接着看这次运行',
+                      drift ? '注意：工作流在这次运行之后改过结构，画布上是现在的图，对不上的节点不会亮起来；当时的全貌看「航迹」' : '',
+                    ].filter(Boolean).join('\n')}>
+                {replayable ? <Rewind size={11} aria-hidden /> : <SquareArrowOutUpRight size={11} aria-hidden />}
+                {replayable ? '在画布中回放' : '在画布中打开'}
+                {drift && (
+                  <span aria-hidden className="absolute -right-1 -top-1 h-2 w-2 rounded-full border-2"
+                        style={{ background: 'var(--st-waiting)', borderColor: 'var(--bg)' }} />
+                )}
               </Link>
             )}
             {code === 'succeeded' && run.run_class !== 'formal' && (
@@ -386,6 +556,32 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
                 {busy === 'extract' ? <Spinner size={11} /> : <GitFork size={11} aria-hidden />} 提取模板
               </button>
             )}
+            <MoreMenu items={menu} />
+          </div>
+        </div>
+        <Telemetry run={run} trace={d.trace} phase={phase} code={code} streaming={d.streaming}
+                   pending={d.pending} labelOf={labelOf} cancelled={lastOf(d.events, 'run.cancelled')?.data} />
+        <ProvenanceBar run={run} eventCount={d.events.length} phase={phase} />
+        {explain && (
+          <FailedBanner explain={explain} nodeId={failedNode} nodeLabel={labelOf(failedNode)}
+                        canvasHref={hrefFor(failedNode)}
+                        onShowInTrace={failedNode && goneFromCanvas(failedNode) ? () => showInTrace(failedNode) : undefined}
+                        onContinue={() => void carryOn()}
+                        onRerun={(field) => void rerun(field)} busy={busy === 'continue' || busy === 'rerun'} />
+        )}
+        {(code === 'held' || code === 'suspended') && (
+          <HeldBanner reason={run.error} onContinue={() => void carryOn()} onAbandon={() => void abandon()}
+                      busy={busy === 'continue' || busy === 'abandon'} />
+        )}
+        {code === 'waiting' && !!d.pending?.length && (
+          <WaitingBanner approvals={d.pending} labelOf={labelOf} onJump={jumpToApproval}
+                         onAbandon={() => void abandon()} busy={busy === 'abandon'} now={now} />
+        )}
+        {feedback && <FeedbackStrip feedback={feedback} onDismiss={() => setFeedback(null)} />}
+        <div className="flex items-center border-t pr-2">
+          <RunTabs tabs={viewTabs} active={view} onChange={setView} label="运行详情视图" idPrefix="run-view"
+                   className="min-w-0 flex-1" />
+          {view === 'stream' && (
             <IconButton
               label={raw ? '回到可读视图' : `看原始事件（${d.events.length} 条）`}
               aria-pressed={raw}
@@ -394,39 +590,41 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
               icon={<Code2 size={13} aria-hidden />}
               data-action="raw"
             />
-            <MoreMenu items={menu} />
-          </div>
+          )}
         </div>
-        <Telemetry run={run} trace={d.trace} phase={phase} code={code} streaming={d.streaming}
-                   pending={d.pending} labelOf={labelOf} />
-        <ProvenanceBar run={run} eventCount={d.events.length} phase={phase} />
-        {explain && (
-          <FailedBanner explain={explain} nodeId={failedNode} nodeLabel={labelOf(failedNode)}
-                        canvasHref={canvasHref} onContinue={() => void carryOn()}
-                        onRerun={(field) => void rerun(field)} busy={busy === 'continue' || busy === 'rerun'} />
-        )}
-        {(code === 'held' || code === 'suspended') && (
-          <HeldBanner reason={run.error} onContinue={() => void carryOn()} busy={busy === 'continue'} />
-        )}
-        {code === 'waiting' && !!d.pending?.length && (
-          <WaitingBanner approvals={d.pending} labelOf={labelOf} onJump={jumpToApproval} now={now} />
-        )}
-        {feedback && <FeedbackStrip feedback={feedback} onDismiss={() => setFeedback(null)} />}
       </header>
 
-      <div ref={streamBox} className="min-h-0 flex-1">
-        {raw
-          ? <RawEvents events={d.events} />
-          : (
-            // 回看历史停在摘要（第一处失败、审批卡或顶部），在跑的才贴着最新处
-            <AssistantStream
-              key={run.id}
-              turns={[turn]}
-              approvalsFor={() => cards}
-              landing={live ? 'end' : 'summary'}
-              clockSkewMs={d.trace.skewMs ?? 0}
-            />
-          )}
+      {/* 时间线一直挂着（换视图回来还停在原来的位置，也不重新解码），不在看时只是
+          不可见、不可聚焦；航迹和工件用到才挂 */}
+      <div className="relative min-h-0 flex-1" role="tabpanel" id="run-view-panel" aria-labelledby={`run-view-tab-${view}`}>
+        <div ref={streamBox} className={clsx('absolute inset-0', view !== 'stream' && 'invisible')}
+             inert={view !== 'stream'} data-view-pane="stream">
+          {raw
+            ? <RawEvents events={d.events} />
+            : (
+              // 回看历史停在摘要（第一处失败、审批卡或顶部），在跑的才贴着最新处
+              <AssistantStream
+                key={run.id}
+                turns={[turn]}
+                approvalsFor={() => cards}
+                landing={live ? 'end' : 'summary'}
+                clockSkewMs={d.trace.skewMs ?? 0}
+              />
+            )}
+        </div>
+        {view === 'trace' && (
+          <div className="absolute inset-0" data-view-pane="trace">
+            <TracePane run={run} events={d.events} trace={d.trace} graph={d.graph} code={code}
+                       replayAt={replayAt} onReplayAt={setReplayAt} selected={traceSelected} onSelect={pickTraceNode}
+                       labelOf={labelOf} nodeHref={hrefFor} goneFromCanvas={goneFromCanvas} onRevealStep={revealStep} />
+          </div>
+        )}
+        {view === 'artifacts' && (
+          <div className="absolute inset-0" data-view-pane="artifacts">
+            <ArtifactsPane list={artifacts} graph={d.graph} trace={d.trace} labelOf={labelOf}
+                           onMoment={t0 != null ? showMoment : undefined} />
+          </div>
+        )}
       </div>
 
       <footer className="flex shrink-0 items-center gap-3 border-t px-4 py-1.5 text-2xs text-faint">
@@ -443,6 +641,11 @@ export function RunDetailView({ runId, onChange, onDeleted }: {
   )
 }
 
+/** 本机填的署名：随 X-Actor 发给后端，写进审批和取消的留痕 */
+function localActor(): string {
+  try { return (localStorage.getItem('agentlab_actor') ?? '').trim() } catch { return '' }
+}
+
 /** 事件之外的事实（查到的状态、有没有审批）和事件推出的相位合成一个显示码 */
 function displayCode(run: Run, phase: RunPhase, pending: boolean | undefined): StatusCode {
   switch (phase) {
diff --git a/frontend/src/pages/runs/RunList.tsx b/frontend/src/pages/runs/RunList.tsx
index 71d4711d..4e8f1a1d 100644
--- a/frontend/src/pages/runs/RunList.tsx
+++ b/frontend/src/pages/runs/RunList.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useMemo, useRef, useState, type ReactNode } from 'react'
 import { ChevronRight, History, Inbox, Search, X } from 'lucide-react'
 import clsx from 'clsx'
-import { EmptyState, ErrorState, Skeleton, Spinner, StatusBadge } from '../../components/ui'
+import { EmptyState, ErrorState, Skeleton, Spinner, StatusBadge, useTicker } from '../../components/ui'
 import { STATUS, statusMeta, type StatusCode } from '../../lib/status'
 import {
   formatCost, formatDateTime, formatDay, formatTime, formatTokens, parseServerTime, shortId,
@@ -9,12 +9,13 @@ import {
 import { RUN_CLASS_LABEL, runClassLabel } from '../../lib/terms'
 import { summarizeRun } from '../../run/decode'
 import type { Approval, Run, Workflow } from '../../types'
-import { explainRunError } from './explain'
+import { UNSAVED_WORKFLOW_ID } from '../../api/client'
+import { explainRunError } from '../../lib/explain'
 import {
-  LONG_WAIT_MS, SEARCH_PLACEHOLDER, SEGMENT_CODES, UNSAVED_HINT, ageMs, formatSpan, headlineMs, idTail,
-  isLiveRun, isUnsaved, runName, runTiming, timingTitle, type ParsedQuery,
+  LONG_WAIT_MS, SEARCH_PLACEHOLDER, SEGMENT_CODES, UNSAVED_HINT, UNSAVED_NAME, ageMs, cancelReason, formatSpan,
+  headlineMs, idTail, isLiveRun, isUnsaved, runName, runShape, runTiming, timingTitle, type ParsedQuery,
 } from './model'
-import { ClassChip, LiveElapsed, TierChip, useNow } from './parts'
+import { ClassChip, LiveElapsed, TierChip } from './parts'
 import type { ApprovalQueue, RunList, StatusCounts } from './useRunsData'
 
 // -------------------------------------------------------------------------
@@ -39,7 +40,7 @@ export function FilterBar({
     [workflows],
   )
   // 链接里带着一个已经删掉的工作流：下拉里也得有它，否则选中项和实际筛选对不上
-  const orphan = workflowId && !workflows.some((w) => w.id === workflowId)
+  const orphan = workflowId && workflowId !== UNSAVED_WORKFLOW_ID && !workflows.some((w) => w.id === workflowId)
   return (
     <div className="flex shrink-0 flex-col gap-1.5 px-3 pt-2.5">
       <div className="relative">
@@ -86,12 +87,18 @@ export function FilterBar({
           data-runs-workflow=""
         >
           <option value="">全部工作流</option>
-          {orphan && <option value={workflowId}>已删除的工作流 {idTail(workflowId)}</option>}
-          {options.map((w) => (
-            <option key={w.id} value={w.id}>
-              {w.name}{dupNames.has(w.name) ? `  ${idTail(w.id)}` : ''}
-            </option>
-          ))}
+          {/* 画布、问数据当场建的图没有工作流 id，按名字筛不出来，单列一项 */}
+          <option value={UNSAVED_WORKFLOW_ID} title={UNSAVED_HINT}>{UNSAVED_NAME}</option>
+          {(orphan || options.length > 0) && (
+            <optgroup label="工作流">
+              {orphan && <option value={workflowId}>已删除的工作流 {idTail(workflowId)}</option>}
+              {options.map((w) => (
+                <option key={w.id} value={w.id}>
+                  {w.name}{dupNames.has(w.name) ? `  ${idTail(w.id)}` : ''}
+                </option>
+              ))}
+            </optgroup>
+          )}
         </select>
       </div>
       {parsed.words.length > 0 && (
@@ -183,7 +190,7 @@ export function RunRows({
   onClear: () => void
 }) {
   const changed = useChangedRows(list.rows)
-  const now = useNow(60_000)
+  const now = useTicker(60_000)
 
   if (list.state === 'loading') {
     return <div className="p-3"><Skeleton rows={6} height={46} gap={8} /></div>
@@ -347,22 +354,46 @@ function RunRow({ run, code, approval, selected, dup, flash, now, onOpen }: {
         </time>
       </div>
       <RowContext run={run} code={code} approval={approval} now={now} />
-      <div className="flex items-center gap-2 text-2xs text-faint">
-        <span className="tnum" title={timingTitle(timing)} data-run-duration="">
+      {/* 一行放不下时让时长那一段截断（完整的分项在 title 里），别的都不折行：
+          折成两行时「2.8k tok」会被拆开，缩略条也跟着掉到下一行 */}
+      <div className="flex items-center gap-2 whitespace-nowrap text-2xs text-faint">
+        <span className="tnum min-w-0 truncate" title={timingTitle(timing)} data-run-duration="">
           {live ? <LiveElapsed since={run.started_at ?? run.created_at} prefix="" /> : formatSpan(headlineMs(timing))}
           {timing.source === 'usage' && (timing.waitMs ?? 0) > 0 && (
             <span className="text-faint"> · 含等人 {formatSpan(timing.waitMs, { coarse: (timing.waitMs ?? 0) >= 3_600_000 })}</span>
           )}
         </span>
-        {tokens ? <span className="tnum">{formatTokens(tokens, { compact: true })}</span> : null}
-        {run.usage?.cost_usd ? <span className="tnum">{formatCost(Number(run.usage.cost_usd))}</span> : null}
+        <ShapeBar run={run} code={code} waitingSince={approval?.created_at} now={now} />
+        {tokens ? <span className="tnum shrink-0">{formatTokens(tokens, { compact: true })}</span> : null}
+        {run.usage?.cost_usd ? <span className="tnum shrink-0">{formatCost(Number(run.usage.cost_usd))}</span> : null}
         <span className="flex-1" />
-        <span className="mono">{shortId(run.id)}</span>
+        <span className="mono shrink-0">{shortId(run.id)}</span>
       </div>
     </button>
   )
 }
 
+/**
+ * 一行一条缩略条：墙钟里执行、等人各占多少，收在什么结局上。执行是安静的灰，
+ * 等人铺斜纹的琥珀，失败和取消在末端点一下——一眼扫下去，挂着等人的、失败的
+ * 自己会跳出来。构成怎么来的见 runShape
+ */
+function ShapeBar({ run, code, waitingSince, now }: {
+  run: Run; code: StatusCode; waitingSince?: string | null; now: number
+}) {
+  const shape = runShape(run, code, { waitingSince, now })
+  return (
+    <span className="runs-shape" title={shape.title} data-run-shape="" data-empty={shape.segs.length ? undefined : ''}
+          aria-hidden>
+      {shape.segs.map((s, i) => (
+        <i key={i} className={`runs-shape-${s.kind}`} style={{ width: `${s.frac * 100}%` }}
+           data-shape-seg={s.kind} data-open={s.open ? '' : undefined} />
+      ))}
+      {shape.end && <b className="runs-shape-end" data-shape-end={shape.end} />}
+    </span>
+  )
+}
+
 /** 第二行：最该知道的那一句。失败写原因，等人写等谁、等多久，成功写内容摘要 */
 function RowContext({ run, code, approval, now }: {
   run: Run; code: StatusCode; approval?: Approval; now: number
@@ -403,8 +434,10 @@ function RowContext({ run, code, approval, now }: {
           {code === 'queued' ? '排队中，等待开始' : '正在运行'}
         </div>
       )
-    case 'cancelled':
-      return <div className={clsx(line, 'text-faint')}>已取消{run.error && run.error !== '用户取消' ? ` · ${run.error}` : ''}</div>
+    case 'cancelled': {
+      const reason = cancelReason(run.error)
+      return <div className={clsx(line, 'text-faint')} title={run.error ?? undefined}>已取消{reason ? ` · ${reason}` : ''}</div>
+    }
     default: {
       const summary = summarizeRun(run.input, run.output)
       return summary
@@ -435,7 +468,7 @@ export function ApprovalRows({ queue, filter, onOpen, selectedId, dupNames }: {
   selectedId?: string
   dupNames: Set<string>
 }) {
-  const now = useNow(60_000)
+  const now = useTicker(60_000)
   if (queue.state === 'loading' && !queue.items.length) {
     return <div className="p-3"><Skeleton rows={3} height={56} gap={8} /></div>
   }
diff --git a/frontend/src/pages/runs/Telemetry.tsx b/frontend/src/pages/runs/Telemetry.tsx
index a602a785..517b99b2 100644
--- a/frontend/src/pages/runs/Telemetry.tsx
+++ b/frontend/src/pages/runs/Telemetry.tsx
@@ -2,7 +2,7 @@ import { useState, type ReactNode } from 'react'
 import { ChevronDown, Shield, ShieldAlert, ShieldCheck } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../../api/client'
-import { StatusPill, toast } from '../../components/ui'
+import { StatusPill, toast, useTicker } from '../../components/ui'
 import {
   NONE, formatClock, formatCost, formatDateTime, formatNumber, formatTime, formatTokens, shortId,
 } from '../../lib/format'
@@ -11,9 +11,9 @@ import { isExecuting, liveAt, project, type Projection, type RunPhase, type Trac
 import { useRunClock } from '../../run/useRunClock'
 import type { Approval, Run } from '../../types'
 import {
-  LONG_WAIT_MS, UNSAVED_HINT, ageMs, formatSpan, isUnsaved, runName, runScope, runTiming, type RunTiming,
+  LONG_WAIT_MS, UNSAVED_HINT, ageMs, cancelReason, formatSpan, isUnsaved, runName, runScope, runTiming, type RunTiming,
 } from './model'
-import { CLOCK_MAX_MS, CopyValue, useNow } from './parts'
+import { CLOCK_MAX_MS, CopyValue } from './parts'
 
 const isNum = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v)
 
@@ -62,7 +62,7 @@ export function runClocks(run: Run, trace: Trace, phase: RunPhase, streaming: bo
  *
  * 数从哪来见 runClocks。都拿不到就写「—」，不猜。
  */
-export function Telemetry({ run, trace, phase, code, streaming, pending, labelOf }: {
+export function Telemetry({ run, trace, phase, code, streaming, pending, labelOf, cancelled }: {
   run: Run
   trace: Trace
   phase: RunPhase
@@ -70,11 +70,13 @@ export function Telemetry({ run, trace, phase, code, streaming, pending, labelOf
   streaming: boolean
   pending: Approval[] | null
   labelOf: (id?: string | null) => string | undefined
+  /** run.cancelled 的 data：谁停的、为什么。老后端没有这两个字段 */
+  cancelled?: Record<string, any> | null
 }) {
   const executing = streaming && (phase === 'running' || phase === 'queued')
   const clock = useRunClock(executing)
   // 等审批的时候数字按分钟涨就够了
-  const slow = useNow(30_000, phase === 'waiting')
+  const slow = useTicker(30_000, phase === 'waiting')
   const now = executing ? clock : Math.max(slow, Date.now())
 
   const usage = run.usage ?? {}
@@ -109,7 +111,7 @@ export function Telemetry({ run, trace, phase, code, streaming, pending, labelOf
   } else if (code === 'held' || code === 'suspended') {
     sub = '断点还在，可接着跑'
   } else if (code === 'cancelled') {
-    sub = run.error && run.error !== '用户取消' ? run.error : '用户取消'
+    sub = cancelNote(run.error, cancelled)
   }
 
   const nodesTotal = proj?.nodesTotal ?? 0
@@ -121,11 +123,7 @@ export function Telemetry({ run, trace, phase, code, streaming, pending, labelOf
   const activeTicks = executing && isNum(active) && active < CLOCK_MAX_MS
 
   return (
-    <div
-      className="grid border-t"
-      style={{ gridTemplateColumns: 'minmax(140px, 1.5fr) repeat(5, minmax(76px, 1fr))' }}
-      data-run-telemetry=""
-    >
+    <div className="runs-telemetry grid border-t" data-run-telemetry="">
       <Cell label="状态" first>
         <StatusPill status={code} className="-ml-1.5 self-start" />
         {sub && <Sub title={sub}>{sub}</Sub>}
@@ -163,6 +161,20 @@ export function Telemetry({ run, trace, phase, code, streaming, pending, labelOf
   )
 }
 
+/**
+ * 已取消的那一句：谁、做了什么。事件里带了 actor 键（哪怕是 null）就说人，没署名写
+ * 「未署名」；老数据没有这个键，只说原因
+ */
+export function cancelNote(error: string | null | undefined, data?: Record<string, any> | null): string {
+  const reason = cancelReason(error)
+  const signed = !!data && 'actor' in data
+  const who = signed ? (typeof data!.actor === 'string' && data!.actor.trim() ? data!.actor.trim() : '未署名') : null
+  const message = typeof data?.message === 'string' && data.message.trim() ? data.message.trim() : null
+  if (who && message) return `${who} ${message}`
+  if (who) return reason ? `${who} · ${reason}` : `${who} 停止了运行`
+  return reason ?? '用户取消'
+}
+
 function Cell({ label, title, first, children }: { label: string; title?: string; first?: boolean; children: ReactNode }) {
   return (
     <div className={clsx('flex min-w-0 flex-col gap-0.5 px-3 py-2 xl:px-4', !first && 'border-l')} title={title}>
diff --git a/frontend/src/pages/runs/TracePane.tsx b/frontend/src/pages/runs/TracePane.tsx
new file mode 100644
index 00000000..1093d737
--- /dev/null
+++ b/frontend/src/pages/runs/TracePane.tsx
@@ -0,0 +1,707 @@
+import { useLayoutEffect, useMemo, useRef, useState, type ReactNode } from 'react'
+import { Link } from 'react-router-dom'
+import { Crosshair, ListTree, TriangleAlert, X } from 'lucide-react'
+import clsx from 'clsx'
+import '../../canvas/surface.css'
+import { RunTimeline, lastStampOf, projectSettled, waitedMs, type DockUi } from '../../canvas/RunTimeline'
+import { EmptyState, StatusBadge, StatusPill } from '../../components/ui'
+import { explainRunError } from '../../lib/explain'
+import {
+  NONE, formatCost, formatDateTime, formatNumber, formatTokens, shortId,
+} from '../../lib/format'
+import { runClassLabel, nodeTypeLabel } from '../../lib/terms'
+import { topology, type GraphLike } from '../../run/derive'
+import {
+  isActivePhase, isSettled, liveAt, project, type NodeState, type Projection, type RunPhase, type Trace,
+} from '../../run/trace'
+import {
+  factsOf, happened, openCall, projectCached, replayTraceCached, type NodeFacts,
+} from '../../run/useNodeView'
+import { useRunClock } from '../../run/useRunClock'
+import type { StatusCode } from '../../lib/status'
+import type { GraphSpec, Run, RunEvent } from '../../types'
+import { cancelReason, formatOffset, formatSpan } from './model'
+
+const EMPTY_GRAPH: GraphSpec = { nodes: [], edges: [] }
+
+// 坞头 34 + 吸顶三行 70；泳道 22，协作的子泳道 18（和 RunTimeline 的排版一致）
+const DOCK_HEAD = 34 + 70
+const LANE_H = 22
+const SUB_H = 18
+// 坞能拖到的最矮（RunTimeline 的 MIN_H）：刻度行和整次运行那一条还在，泳道在坞里滚
+const MIN_DOCK = 132
+
+const DOCK_KEY = 'agentlab.runs.dock'
+function readDock(): Pick<DockUi, 'open' | 'compress'> {
+  try {
+    const raw = JSON.parse(localStorage.getItem(DOCK_KEY) ?? 'null')
+    if (raw && typeof raw === 'object') {
+      return { open: raw.open !== false, compress: raw.compress !== false }
+    }
+  } catch { /* 隐私窗口、禁用存储：用默认值 */ }
+  return { open: true, compress: true }
+}
+function saveDock(ui: DockUi): void {
+  try { localStorage.setItem(DOCK_KEY, JSON.stringify({ open: ui.open, compress: ui.compress })) } catch { /* 记不住就算了 */ }
+}
+
+/**
+ * 航迹页签：和画布底部同一个航迹坞（canvas/RunTimeline），上面换成「游标读数」——
+ * 画布上拖游标，卡片回到那一刻；这里没有画布，拖到哪一刻，就读出那一刻的相位、
+ * 三种时长、用量、在跑和在等的节点，点一条泳道看那个节点那一刻的样子。
+ *
+ * 用的是运行时的图快照（GET /runs/{id}/graph），不是工作流现在的样子：未保存的
+ * 工作流、改过结构的工作流，也只有这里能看到当时的全貌。
+ */
+export function TracePane({
+  run, events, trace, graph, code, replayAt, onReplayAt, selected, onSelect, labelOf, nodeHref, goneFromCanvas, onRevealStep,
+}: {
+  run: Run
+  /** 航迹不存的几件事（在调哪个工具、模型把工具调用写成了文字…）要从事件里捞，和画布卡片同一份 */
+  events: RunEvent[]
+  trace: Trace
+  graph: GraphSpec | null
+  /** 详情头的显示码：没拖游标时状态格和它说同一句 */
+  code: StatusCode
+  replayAt: number | null
+  onReplayAt: (at: number | null) => void
+  selected: string | null
+  onSelect: (id: string | null) => void
+  labelOf: (id?: string | null) => string | undefined
+  /** 在画布里看这个节点（带 run 和 focus）；回不到画布的返回 null */
+  nodeHref: (id: string) => string | null
+  /** 工作流之后改过结构，这个节点在现在的图里已经没有了（节点卡说明为什么没有「在画布中看」） */
+  goneFromCanvas?: (id: string) => boolean
+  /** 切回时间线并描出这个节点的那几步 */
+  onRevealStep: (id: string) => void
+}) {
+  const g = graph ?? EMPTY_GRAPH
+  const [hovered, setHovered] = useState<string | null>(null)
+
+  // ---- 坞：开合、压缩空闲记在本机；高度按读数区和泳道分，拖过就听人的 ----
+  const box = useRef<HTMLDivElement>(null)
+  const [ui, setUi] = useState<DockUi>(() => ({ ...readDock(), height: 0, playing: false, speed: 1 }))
+  const sized = useRef(false)
+  const lanes = useMemo(() => {
+    let n = new Set([...g.nodes.map((x) => x.id), ...Object.keys(trace.nodes)]).size * LANE_H
+    for (const t of Object.values(trace.nodes)) {
+      if (t.segments.some((s) => s.kind === 'dispatch')) n += SUB_H
+      n += new Set(t.segments.filter((s) => s.kind === 'member').map((s) => s.agent)).size * SUB_H
+    }
+    return n
+  }, [g.nodes, trace.nodes])
+  // 读数区先拿够它要的（八格读数，加上此刻、节点卡、关键时刻），坞拿剩下的：屏幕矮、
+  // 节点多时，按泳道要的高度给坞会把读数区挤得只剩八格，默认选中的失败节点卡、关键
+  // 时刻全落在视线外。坞最矮到能拖到的最矮，泳道在坞里滚。只在面板尺寸、泳道数变了时
+  // 重分：拖游标、点节点时读数区的高度在变，坞跟着跳的话，手底下的泳道会挪走
+  const empty = !Object.keys(trace.nodes).length && trace.startedAt == null
+  useLayoutEffect(() => {
+    const el = box.current
+    if (!el) return
+    const fit = () => {
+      const h = el.clientHeight
+      const cap = Math.max(MIN_DOCK, h * 0.7)
+      const read = el.querySelector<HTMLElement>('[data-trace-readout]')
+      const need = read ? [...read.children].reduce((n, c) => n + c.getBoundingClientRect().height, 0) : 0
+      setUi((cur) => {
+        const want = sized.current ? cur.height : Math.min(DOCK_HEAD + lanes + 10, h - Math.ceil(need))
+        const height = Math.round(Math.min(cap, Math.max(MIN_DOCK, want)))
+        return height === cur.height ? cur : { ...cur, height }
+      })
+    }
+    fit()
+    const ro = new ResizeObserver(fit)
+    ro.observe(el)
+    return () => ro.disconnect()
+  }, [lanes, empty])
+  const patchUi = (p: Partial<DockUi>) => {
+    if ('height' in p) sized.current = true
+    setUi((cur) => {
+      const next = { ...cur, ...p }
+      if ('open' in p || 'compress' in p) saveDock(next)
+      return next
+    })
+  }
+
+  // ---- 游标那一刻 ----
+  // 停在审批上的也算「还在走」：等人的时长在涨，和下面坞里的游标同一拍走
+  const live = replayAt == null
+  const active = isActivePhase(trace.phase)
+  const now = useRunClock(live && active)
+  const t0 = trace.startedAt
+  const at = replayAt ?? (active ? liveAt(trace, now) : lastStampOf(trace))
+  const proj: Projection = !live ? projectCached(trace, replayAt!) : active ? project(trace, liveAt(trace, now)) : projectSettled(trace)
+  // 回放时的节点状态要按图再推一遍（排队、阻断、未到达），和画布卡片读同一份
+  const view = useMemo(() => (live ? trace : replayTraceCached(trace, replayAt!, g as GraphLike)), [live, trace, replayAt, g])
+  const order = useMemo(() => {
+    const ids = topology(g as GraphLike).order
+    return [...ids, ...Object.keys(trace.nodes).filter((id) => !ids.includes(id))]
+  }, [g, trace.nodes])
+  const stateOf = (id: string): NodeState => view.nodes[id]?.state ?? 'idle'
+  const facts = useMemo(() => factsOf(events), [events])
+  const moments = useMemo(
+    () => momentsOf(trace, facts, order, labelOf, code, run.error),
+    [trace, facts, order, labelOf, code, run.error],
+  )
+
+  if (empty) {
+    return (
+      <EmptyState
+        icon={<ListTree size={22} />}
+        title="这次运行没有节点执行的记录"
+        body="还没开始就停下了，或者是没有事件的老数据：航迹要靠节点开始、结束的事件摊开。"
+        className="h-full"
+      />
+    )
+  }
+
+  const title = `${runClassLabel(run.run_class ?? trace.runClass ?? 'exploratory', run.version)} ${shortId(run.id)}`
+  const pick = (id: string | null) => onSelect(id === selected ? null : id)
+
+  return (
+    <div ref={box} className="flex h-full min-h-0 flex-col" data-run-trace="">
+      <Readout
+        trace={trace} proj={proj} at={at} t0={t0} live={live} active={active} code={code}
+        order={order} stateOf={stateOf} labelOf={labelOf} hovered={hovered} onHover={setHovered}
+        selected={selected} onPick={pick} graph={g} nodeHref={nodeHref} goneFromCanvas={goneFromCanvas}
+        onRevealStep={onRevealStep} facts={facts} moments={moments} onReplayAt={onReplayAt}
+      />
+      {ui.height > 0 && (
+        <RunTimeline
+          trace={trace}
+          graph={g}
+          title={title}
+          replayAt={replayAt}
+          onReplayAt={onReplayAt}
+          hoveredNodeId={hovered ?? selected}
+          onHoverNode={setHovered}
+          onFocusNode={(id) => onSelect(id)}
+          ui={ui}
+          onUi={patchUi}
+        />
+      )}
+    </div>
+  )
+}
+
+// -------------------------------------------------------------------------
+// 游标读数
+// -------------------------------------------------------------------------
+
+function Readout({
+  trace, proj, at, t0, live, active, code, order, stateOf, labelOf, hovered, onHover, selected, onPick, graph,
+  nodeHref, goneFromCanvas, onRevealStep, facts, moments, onReplayAt,
+}: {
+  trace: Trace; proj: Projection; at: number; t0?: number; live: boolean; active: boolean; code: StatusCode
+  order: string[]; stateOf: (id: string) => NodeState; labelOf: (id?: string | null) => string | undefined
+  hovered: string | null; onHover: (id: string | null) => void
+  selected: string | null; onPick: (id: string | null) => void; graph: GraphSpec
+  nodeHref: (id: string) => string | null; goneFromCanvas?: (id: string) => boolean
+  onRevealStep: (id: string) => void
+  facts: Record<string, NodeFacts>; moments: Moment[]; onReplayAt: (at: number | null) => void
+}) {
+  // 时刻是秒级浮点换算来的，差的那一丝不该让 2.1 s 显示成 00:02.0：先取整到毫秒
+  const offset = t0 != null && trace.timed ? Math.max(0, Math.round(at - t0)) : null
+  const mode = !live ? '回放' : active ? '实时' : '终态'
+  const phase: string = live ? code : proj.phase
+  // 整次运行一次模型都没调过：和详情头一样写「—」，不写「0 tok / $0」
+  const metered = trace.usageSeries.length > 0 || trace.tokensIn + trace.tokensOut > 0 || trace.costUsd > 0
+  const tokens = metered && proj.tokensIn != null && proj.tokensOut != null ? proj.tokensIn + proj.tokensOut : undefined
+
+  // 下面还有没露出来的（节点卡、关键时刻）：底边淡出一截，看得出能往下滚
+  const scroller = useRef<HTMLDivElement>(null)
+  const [more, setMore] = useState(false)
+  useLayoutEffect(() => {
+    const el = scroller.current
+    if (!el) return
+    const check = () => setMore(el.scrollHeight - el.scrollTop - el.clientHeight > 4)
+    check()
+    el.addEventListener('scroll', check, { passive: true })
+    const ro = new ResizeObserver(check)
+    ro.observe(el)
+    for (const c of el.children) ro.observe(c)
+    return () => {
+      el.removeEventListener('scroll', check)
+      ro.disconnect()
+    }
+  }, [])
+
+  return (
+    <div ref={scroller} className="runs-trace-read min-h-0 flex-1 overflow-y-auto" data-trace-readout="" data-mode={mode}
+         data-more={more ? '' : undefined}>
+      <div className="runs-trace-grid border-b">
+        {/* 实时、回放、终态写在标签那一行：数值那一行要留给跨天的时刻 */}
+        <Metric label="游标" data="at" title={trace.timed ? formatDateTime(at) : '老数据没有时间戳：只能按先后顺序回放'}
+                tag={<span className={clsx(!live && 'text-[var(--accent)]')} data-readout-mode="">{mode}</span>}>
+          {offset != null ? `T+${formatOffset(offset)}` : NONE}
+        </Metric>
+        <Metric label="状态" data="phase">
+          {/* 格子窄，两种挂起写短名（「已挂起 · 可续跑」会被截成「已挂起 · 可续…」）；全称在详情头 */}
+          <StatusPill status={phase} short={phase === 'held' || phase === 'suspended'} className="-ml-1.5" />
+        </Metric>
+        <Metric label="墙钟" data="wall" title="从第一次开始到游标那一刻">{span(proj.elapsedMs, trace.timed)}</Metric>
+        <Metric label="执行" data="active" title="到游标那一刻为止，各段执行之和">{span(proj.activeMs, true)}</Metric>
+        <Metric label="等人" data="wait" title="到游标那一刻为止，挂在人工审批上的时长"
+                tone={proj.phase === 'waiting' ? 'var(--st-waiting)' : undefined}>
+          {span(proj.waitMs, trace.timed)}
+        </Metric>
+        <Metric label="节点" data="nodes" title="已完成（含跳过）/ 图上的节点总数"
+                sub={proj.parallelNow > 1 ? `${proj.parallelNow} 个并行` : undefined}>
+          {proj.nodesTotal ? <>{proj.nodesDone}<span className="text-faint">/{proj.nodesTotal}</span></> : NONE}
+        </Metric>
+        <Metric label="用量" data="tokens"
+                title={!metered ? '这次运行没有调用过模型'
+                  : tokens == null ? '各次模型调用加起来对不上后端的总数（老后端的部分调用不回报用量），这一刻的读数不可信，不拿终值冒充'
+                  : '到游标那一刻为止的 tokens'}
+                sub={tokens ? `入 ${formatNumber(proj.tokensIn)} · 出 ${formatNumber(proj.tokensOut)}` : undefined}>
+          {tokens == null ? NONE : formatTokens(tokens, { compact: true })}
+        </Metric>
+        <Metric label="成本" data="cost">{!metered || proj.costUsd == null ? NONE : formatCost(proj.costUsd)}</Metric>
+      </div>
+
+      <div className="runs-trace-cols">
+        <NowList trace={trace} proj={proj} at={at} order={order} stateOf={stateOf} labelOf={labelOf}
+                 hovered={hovered} onHover={onHover} selected={selected} onPick={onPick} />
+        {selected
+          ? <NodeCard id={selected} trace={trace} proj={proj} state={stateOf(selected)} graph={graph}
+                      facts={facts[selected]} at={live ? null : at}
+                      labelOf={labelOf} href={nodeHref(selected)} gone={!!goneFromCanvas?.(selected)}
+                      onClose={() => onPick(null)} onRevealStep={onRevealStep} />
+          : <Slowest trace={trace} order={order} labelOf={labelOf} activeMs={projectSettledActive(trace)}
+                     onHover={onHover} onPick={onPick} />}
+        <Moments moments={moments} at={at} live={live} t0={trace.timed ? t0 : undefined}
+                 onHover={onHover} onJump={(m) => onReplayAt(m.end ? null : m.at)} />
+      </div>
+    </div>
+  )
+}
+
+/** 整次运行的执行时长：最耗时那一栏算占比用，和游标无关 */
+function projectSettledActive(t: Trace): number {
+  return t.timing?.activeMs ?? t.drives.reduce((n, [a, b]) => n + Math.max(0, (b ?? a) - a), 0)
+}
+
+/** 没有时间戳的老数据，墙钟和等人都不可知 */
+const span = (ms: number | undefined, known: boolean) => (known && ms != null ? formatSpan(ms) : NONE)
+
+function Metric({ label, tag, data, title, sub, tone, children }: {
+  label: string; tag?: ReactNode; data: string; title?: string; sub?: string; tone?: string; children: ReactNode
+}) {
+  return (
+    <div className="flex min-w-0 flex-col gap-0.5 px-3 py-1.5" title={title}>
+      <div className="flex min-w-0 gap-1.5 truncate text-2xs text-faint">{label}{tag}</div>
+      <div className="mono tnum flex min-w-0 items-center truncate text-sm leading-5 text-fg"
+           style={tone ? { color: tone } : undefined} data-readout={data}>
+        {children}
+      </div>
+      {sub && <div className="tnum truncate text-2xs text-faint">{sub}</div>}
+    </div>
+  )
+}
+
+// -------------------------------------------------------------------------
+// 此刻在做什么
+// -------------------------------------------------------------------------
+
+function NowList({ trace, proj, at, order, stateOf, labelOf, hovered, onHover, selected, onPick }: {
+  trace: Trace; proj: Projection; at: number; order: string[]; stateOf: (id: string) => NodeState
+  labelOf: (id?: string | null) => string | undefined
+  hovered: string | null; onHover: (id: string | null) => void
+  selected: string | null; onPick: (id: string | null) => void
+}) {
+  // 循环容器在两轮之间也是 running，真正在跑的是循环体：不列它
+  const running = order.filter((id) => stateOf(id) === 'running' && !trace.nodes[id]?.looping)
+  const waiting = order.filter((id) => stateOf(id) === 'waiting')
+  const settled = proj.phase === 'succeeded' || proj.phase === 'failed' || proj.phase === 'cancelled' || proj.phase === 'suspended'
+
+  let empty: ReactNode = null
+  if (!running.length && !waiting.length) {
+    if (proj.phase === 'idle' || proj.phase === 'queued' || (trace.startedAt != null && at < trace.startedAt)) {
+      empty = '还没开始'
+    } else if (settled) {
+      const tally = new Map<NodeState, number>()
+      for (const id of order) tally.set(stateOf(id), (tally.get(stateOf(id)) ?? 0) + 1)
+      const parts = ([['done', '完成'], ['failed', '失败'], ['skipped', '跳过'], ['blocked', '阻断'], ['unreached', '未到达'],
+        ['cancelled', '取消']] as [NodeState, string][])
+        .filter(([s]) => tally.get(s)).map(([s, l]) => `${l} ${tally.get(s)}`)
+      empty = `已经停下：${parts.join(' · ') || '没有节点跑过'}`
+    } else {
+      empty = '此刻没有节点在执行：两步之间，或者在等下游汇合'
+    }
+  }
+
+  const chip = (id: string, state: NodeState, text: string) => (
+    <button
+      key={id}
+      type="button"
+      className={clsx(
+        'inline-flex max-w-full items-center gap-1.5 rounded-full border px-2 py-0.5 text-xs transition-colors hover:bg-hover',
+        (hovered === id || selected === id) && 'bg-hover',
+      )}
+      style={{ borderColor: `color-mix(in srgb, ${state === 'waiting' ? 'var(--st-waiting)' : 'var(--st-running)'} 45%, var(--border))` }}
+      onMouseEnter={() => onHover(id)}
+      onMouseLeave={() => onHover(null)}
+      onFocus={() => onHover(id)}
+      onBlur={() => onHover(null)}
+      onClick={() => onPick(id)}
+      aria-pressed={selected === id}
+      data-now-node={id}
+    >
+      <StatusBadge status={state} size={11} animate={false} decorative />
+      <span className="min-w-0 truncate text-fg">{labelOf(id) ?? id}</span>
+      <span className="tnum shrink-0 text-2xs text-faint">{text}</span>
+    </button>
+  )
+
+  return (
+    // 标题和内容写在同一行：多半只有一两个节点或一句话，单占一行的标题白占高度
+    <section className="runs-trace-now min-w-0 px-4 py-2" aria-label="游标那一刻" data-trace-now="">
+      <div className="flex flex-wrap items-center gap-x-2 gap-y-1.5">
+        <h4 className="text-2xs font-medium text-faint">此刻</h4>
+        {empty
+          ? <p className="text-xs text-dim">{empty}</p>
+          : (
+            <>
+              {running.map((id) => chip(id, 'running', `已跑 ${formatSpan(proj.nodes[id]?.elapsedMs)}`))}
+              {waiting.map((id) => {
+                const w = waitedMs(trace, id, at)
+                return chip(id, 'waiting', w != null ? `等审批 ${formatSpan(w)}` : '等审批')
+              })}
+            </>
+          )}
+      </div>
+    </section>
+  )
+}
+
+// -------------------------------------------------------------------------
+// 关键时刻
+// -------------------------------------------------------------------------
+
+interface Moment {
+  key: string
+  at: number
+  /** 徽标：运行或节点的状态；warn 是引擎判了降档、失败的那几种警告 */
+  status: string | 'warn'
+  text: string
+  sub?: string
+  nodeId?: string
+  /** 结局那一条：跳过去就是终态（推导出的阻断、未到达都在），不是按段重建的那一刻 */
+  end?: boolean
+}
+
+/** 列太多就不是「关键」了：循环里几十次重试时只列前面这些 */
+const MOMENTS_MAX = 40
+
+/**
+ * 一次运行里值得停下来看的几个时刻：开始、停下等审批、审批处理完、失败、重试、
+ * 接着跑、引擎的警告、结局。都来自航迹（和坞里的泳道同一份）和节点上的那几件事，
+ * 不另读事件。长时间等人被压缩的空档、几百条事件的循环里，拖游标很难正好停在
+ * 那一下——这里点一下就到
+ */
+function momentsOf(
+  trace: Trace, facts: Record<string, NodeFacts>, order: string[],
+  labelOf: (id?: string | null) => string | undefined, code: StatusCode, error: string | null | undefined,
+): Moment[] {
+  const out: Moment[] = []
+  const name = (id: string) => `「${labelOf(id) ?? id}」`
+  if (trace.startedAt != null) out.push({ key: 'start', at: trace.startedAt, status: 'running', text: '开始运行' })
+  const ended = isSettled(trace.phase) && trace.endedAt != null
+  for (const id of order) {
+    const n = trace.nodes[id]
+    if (!n) continue
+    const lastFail = n.segments.reduce((k, s, i) => (s.kind === 'run' && s.status === 'failed' ? i : k), -1)
+    n.segments.forEach((s, i) => {
+      if (s.kind === 'wait') {
+        out.push({ key: `${id}:w${i}`, at: s.start, status: 'waiting', text: `${name(id)}停下等审批`, nodeId: id })
+        // 以放弃、挂起收场的等待，结局那一条会说
+        if (s.end != null && s.status !== 'cancelled' && s.status !== 'suspended') {
+          out.push({
+            key: `${id}:r${i}`, at: s.end, status: 'done', text: `${name(id)}审批已处理`,
+            sub: `等了 ${formatSpan(s.end - s.start)}`, nodeId: id,
+          })
+        }
+      } else if (s.kind === 'retry') {
+        out.push({ key: `${id}:t${i}`, at: s.start, status: 'running', text: `${name(id)}重试`, nodeId: id })
+      } else if (s.kind === 'run' && s.status === 'failed' && s.end != null) {
+        // 让整次运行失败的那一下由结局那一条说，这里只列失败了还接着走下去的
+        if (ended && trace.phase === 'failed' && id === trace.failedNodeId && i === lastFail) return
+        out.push({
+          key: `${id}:f${i}`, at: s.end, status: 'failed', text: `${name(id)}失败`, nodeId: id,
+          sub: i === lastFail && n.error ? explainRunError(n.error).title : undefined,
+        })
+      }
+    })
+    const f = facts[id]
+    if (f?.markup) out.push({ key: `${id}:markup`, at: f.markup.at, status: 'warn', text: `${name(id)}把工具调用写成了文字`, nodeId: id })
+    if (f?.exhausted) out.push({ key: `${id}:exhausted`, at: f.exhausted.at, status: 'warn', text: `${name(id)}协作轮数用完，降档交付`, nodeId: id })
+    if (f?.invented) out.push({ key: `${id}:invented`, at: f.invented.at, status: 'warn', text: `${name(id)}校验修复编了原文没有的值`, nodeId: id })
+  }
+  // 失败、挂起之后又跑起来：接着跑。等审批之后的恢复已经由「审批已处理」说了
+  let prev: RunPhase | null = null
+  trace.phases.forEach(([at, phase], i) => {
+    if (phase === 'running' && (prev === 'failed' || prev === 'suspended')) {
+      out.push({ key: `go${i}`, at, status: 'running', text: prev === 'failed' ? '从失败处接着跑' : '从断点接着跑' })
+    }
+    prev = phase
+  })
+  if (ended) {
+    const failed = trace.phase === 'failed' ? trace.failedNodeId : undefined
+    const why = trace.phase === 'failed'
+      ? explainRunError((failed && trace.nodes[failed]?.error) || error).title
+      : trace.phase === 'cancelled' ? cancelReason(error) ?? undefined
+      : trace.phase === 'suspended' ? error?.trim() || undefined : undefined
+    out.push({
+      key: 'end', at: trace.endedAt!, end: true,
+      // 挂起分两种（服务重启、可续跑），详情头已经分好了，照它的说
+      status: trace.phase === 'suspended' ? code : trace.phase,
+      text: trace.phase === 'succeeded' ? '运行完成'
+        : failed ? `失败于${name(failed)}`
+        : trace.phase === 'failed' ? '运行失败'
+        : trace.phase === 'cancelled' ? '运行取消' : '运行挂起',
+      sub: why,
+    })
+  }
+  return out.sort((a, b) => a.at - b.at || (a.end ? 1 : 0) - (b.end ? 1 : 0))
+}
+
+function Moments({ moments, at, live, t0, onHover, onJump }: {
+  moments: Moment[]; at: number; live: boolean; t0?: number
+  onHover: (id: string | null) => void; onJump: (m: Moment) => void
+}) {
+  if (moments.length < 2) return null
+  // 游标落在哪一段里：最后一个不晚于它的时刻。停下的运行没拖游标时就是结局
+  const settledEnd = live && moments[moments.length - 1].end
+  let current = -1
+  if (settledEnd) current = moments.length - 1
+  else for (let i = 0; i < moments.length; i += 1) if (moments[i].at <= at) current = i
+  const shown = moments.length > MOMENTS_MAX
+    ? [...moments.slice(0, MOMENTS_MAX - 1), moments[moments.length - 1]]
+    : moments
+  const hidden = moments.length - shown.length
+
+  return (
+    <section className="runs-trace-moments min-w-0 px-4 py-2.5" aria-label="关键时刻" data-trace-moments="">
+      <h4 className="mb-1 flex items-center gap-2 text-2xs font-medium text-faint">
+        关键时刻
+        <span className="font-normal">· 点一下，游标跳到那一刻</span>
+      </h4>
+      <ol className="runs-moments -mx-1">
+        {shown.map((m) => {
+          const i = moments.indexOf(m)
+          const here = i === current
+          return (
+            <li key={m.key}>
+              <button
+                type="button"
+                className={clsx(
+                  'items-center rounded px-1 py-0.5 text-left text-xs transition-colors hover:bg-hover',
+                  here && 'bg-hover',
+                )}
+                aria-current={here ? 'step' : undefined}
+                onClick={() => onJump(m)}
+                onMouseEnter={() => m.nodeId && onHover(m.nodeId)}
+                onMouseLeave={() => m.nodeId && onHover(null)}
+                title={m.end ? '回到终态' : '游标跳到这一刻'}
+                data-moment={m.key}
+              >
+                <span className={clsx('mono tnum text-2xs', here ? 'text-fg' : 'text-faint')} data-moment-at="">
+                  {t0 != null ? `T+${formatOffset(Math.max(0, Math.round(m.at - t0)))}` : NONE}
+                </span>
+                {m.status === 'warn'
+                  ? <TriangleAlert size={11} aria-hidden style={{ color: 'var(--st-waiting)' }} />
+                  : <StatusBadge status={m.status} size={11} animate={false} decorative />}
+                <span className="min-w-0 truncate">
+                  <span className={here ? 'text-fg' : 'text-dim'}>{m.text}</span>
+                  {m.sub && <span className="text-faint"> · {m.sub}</span>}
+                </span>
+              </button>
+            </li>
+          )
+        })}
+      </ol>
+      {hidden > 0 && <p className="mt-1 px-1 text-2xs text-faint">另有 {hidden} 个时刻没列出：在下面的航迹上拖游标看</p>}
+    </section>
+  )
+}
+
+// -------------------------------------------------------------------------
+// 最耗时的节点（没选节点时）
+// -------------------------------------------------------------------------
+
+function Slowest({ trace, order, labelOf, activeMs, onHover, onPick }: {
+  trace: Trace; order: string[]; labelOf: (id?: string | null) => string | undefined; activeMs: number
+  onHover: (id: string | null) => void; onPick: (id: string | null) => void
+}) {
+  const end = lastStampOf(trace)
+  const rows = order
+    .map((id) => {
+      const n = trace.nodes[id]
+      const total = (n?.segments ?? []).reduce(
+        (sum, s) => (s.kind === 'run' ? sum + Math.max(0, (s.end ?? end) - s.start) : sum), 0)
+      return { id, total, count: n?.count ?? 0 }
+    })
+    .filter((r) => r.total > 0)
+    .sort((a, b) => b.total - a.total)
+    .slice(0, 3)
+  const top = rows[0]?.total ?? 0
+  return (
+    <section className="runs-trace-side min-w-0 px-4 py-2.5" aria-label="最耗时的节点" data-trace-slowest="">
+      <h4 className="mb-1.5 flex items-center gap-2 text-2xs font-medium text-faint">
+        整次运行里最耗时的
+        <span className="font-normal">· 点一条泳道看那个节点在游标那一刻的样子</span>
+      </h4>
+      {!rows.length ? <p className="text-xs text-dim">没有节点执行过</p> : (
+        <div className="space-y-1">
+          {rows.map((r) => (
+            <button
+              key={r.id}
+              type="button"
+              className="grid w-full grid-cols-[minmax(0,1fr)_72px_auto] items-center gap-2 rounded px-1 py-0.5 text-left text-xs hover:bg-hover"
+              onMouseEnter={() => onHover(r.id)}
+              onMouseLeave={() => onHover(null)}
+              onClick={() => onPick(r.id)}
+              data-slow-node={r.id}
+              title={activeMs > 0 ? `占执行时长的 ${Math.round((r.total / activeMs) * 100)}%` : undefined}
+            >
+              <span className="min-w-0 truncate text-fg">
+                {labelOf(r.id) ?? r.id}
+                {r.count > 1 && <span className="tnum text-2xs text-faint"> ×{r.count}</span>}
+              </span>
+              <span className="h-1.5 overflow-hidden rounded-full bg-hover" aria-hidden>
+                <span className="block h-full rounded-full" style={{
+                  width: `${Math.max(4, (r.total / Math.max(1, top)) * 100)}%`,
+                  background: 'color-mix(in srgb, var(--text-faint) 75%, transparent)',
+                }} />
+              </span>
+              <span className="tnum text-right text-2xs text-dim">{formatSpan(r.total)}</span>
+            </button>
+          ))}
+        </div>
+      )}
+    </section>
+  )
+}
+
+// -------------------------------------------------------------------------
+// 选中的节点在游标那一刻
+// -------------------------------------------------------------------------
+
+function NodeCard({ id, trace, proj, state, graph, facts, at, labelOf, href, gone, onClose, onRevealStep }: {
+  id: string; trace: Trace; proj: Projection; state: NodeState; graph: GraphSpec
+  facts?: NodeFacts
+  /** 游标那一刻；null = 实时 / 终态 */
+  at: number | null
+  labelOf: (id?: string | null) => string | undefined; href: string | null
+  /** 现在的图里已经没有这个节点 */
+  gone: boolean
+  onClose: () => void; onRevealStep: (id: string) => void
+}) {
+  const n = trace.nodes[id]
+  const p = proj.nodes[id]
+  const node = graph.nodes.find((x) => x.id === id)
+  const label = labelOf(id) ?? id
+  // 从没调过模型、工具的节点（输入、分支、人工审批）没有这两项，写「—」而不是 0
+  const metered = !!n?.marks?.length
+  const tokens = p ? p.tokensIn + p.tokensOut : 0
+  const error = state === 'failed' && n?.error ? explainRunError(n.error) : null
+  const rows: [string, ReactNode][] = []
+  if (n?.model) rows.push(['模型', <span className="mono">{n.model}</span>])
+  if (n?.takenHandle && (state === 'done' || state === 'failed')) rows.push(['出口', <span className="mono">{n.takenHandle}</span>])
+  if (n?.reason) rows.push(['理由', n.reason])
+  if (state === 'skipped' && n?.skippedReason) rows.push(['跳过', n.skippedReason])
+  // 那一刻卡在哪个工具上：「慢在哪」往往就是这一次查询。实时只看这一次执行里开着的
+  const call = state === 'running' ? openCall(facts, at) : undefined
+  if (call) {
+    const since = (at ?? Date.now() - (trace.skewMs ?? 0)) - call.start
+    rows.push(['在调', (
+      <span data-node-field="call">
+        <span className="mono">{call.tool}</span>
+        {call.agent && <span className="text-faint">（{call.agent}）</span>}
+        <span className="tnum text-faint"> · 已 {formatSpan(Math.max(0, since))}{call.limitS ? ` / 上限 ${call.limitS} s` : ''}</span>
+      </span>
+    )])
+  }
+  // 引擎判为降档、失败的几种「没按要求做完」：到游标那一刻已经发生的才说
+  const warns = [
+    happened(facts?.markup, at) && '模型把工具调用写成了文字，没有真正调用工具',
+    happened(facts?.exhausted, at) && '协作轮数用完仍未完成，按降档交付',
+    happened(facts?.invented, at) && '校验修复时出现了原文没有的值，修复被拒',
+  ].filter((w): w is string => !!w)
+
+  return (
+    <section className="runs-trace-side min-w-0 px-4 py-2" aria-label={`节点「${label}」`} data-trace-node={id}>
+      <div className="flex min-w-0 items-center gap-2">
+        <span aria-hidden className="h-3.5 w-[3px] shrink-0 rounded-sm"
+              style={{ background: node ? `var(--nt-${node.type}, var(--text-faint))` : 'var(--text-faint)' }} />
+        <span className="min-w-0 truncate text-xs font-semibold text-fg">{label}</span>
+        {node && <span className="shrink-0 text-2xs text-faint">{nodeTypeLabel(node.type)}</span>}
+        <StatusPill status={state} className="shrink-0" />
+        <span className="flex-1" />
+        <button type="button" className="rounded p-0.5 text-faint hover:bg-hover hover:text-dim" onClick={onClose}
+                aria-label="收起节点" title="收起">
+          <X size={11} aria-hidden />
+        </button>
+      </div>
+      <dl className="mt-1.5 grid grid-cols-4 gap-x-3 gap-y-0.5 text-2xs">
+        <Fact label="用时" data="elapsed"
+              sub={p && p.count > 1 ? `第 ${p.count} 次` : p?.iteration != null ? `第 ${p.iteration} 轮` : undefined}>
+          {p?.elapsedMs != null ? formatSpan(p.elapsedMs) : NONE}
+        </Fact>
+        <Fact label="用量" data="tokens"
+              sub={metered && tokens ? `入 ${formatNumber(p?.tokensIn)} · 出 ${formatNumber(p?.tokensOut)}` : undefined}>
+          {metered ? formatTokens(tokens, { compact: true }) : NONE}
+        </Fact>
+        <Fact label="成本" data="cost">{metered && p ? formatCost(p.costUsd) : NONE}</Fact>
+        <Fact label="工具" data="tools" sub={p?.toolsRunning ? `${p.toolsRunning} 个进行中` : undefined}>
+          {metered && p ? `${p.tools} 次` : NONE}
+        </Fact>
+      </dl>
+      {rows.length > 0 && (
+        <dl className="mt-1 grid gap-x-2 text-2xs" style={{ gridTemplateColumns: 'max-content minmax(0,1fr)' }}>
+          {rows.map(([k, v]) => (
+            <div key={k} className="contents">
+              <dt className="text-faint">{k}</dt>
+              <dd className="min-w-0 truncate text-dim">{v}</dd>
+            </div>
+          ))}
+        </dl>
+      )}
+      {warns.map((w) => (
+        <p key={w} className="mt-1 flex items-center gap-1 truncate text-2xs" style={{ color: 'var(--st-waiting)' }}
+           data-node-warn="">
+          <TriangleAlert size={11} aria-hidden className="shrink-0" /> {w}
+        </p>
+      ))}
+      {error && (
+        <p className="mt-1 truncate text-2xs" style={{ color: 'var(--st-failed)' }} title={error.raw}>{error.title}</p>
+      )}
+      <div className="mt-1.5 flex flex-wrap gap-1.5">
+        <button type="button" className="btn btn-xs" onClick={() => onRevealStep(id)} data-action="node-stream"
+                title="切回时间线，把这个节点的那几步描出来">
+          <ListTree size={11} aria-hidden /> 在时间线里看
+        </button>
+        {href ? (
+          <Link className="btn btn-xs" to={href} data-action="node-canvas" title="打开这张工作流，回放这次运行，并对准这个节点">
+            <Crosshair size={11} aria-hidden /> 在画布中看这一步
+          </Link>
+        ) : gone && (
+          <span className="self-center text-2xs text-faint" data-node-gone=""
+                title="工作流在这次运行之后改过结构，现在的图里已经没有这个节点：画布上看不到它，当时的样子就在这里">
+            画布上已没有这个节点
+          </span>
+        )}
+      </div>
+    </section>
+  )
+}
+
+function Fact({ label, data, sub, children }: { label: string; data: string; sub?: string; children: ReactNode }) {
+  return (
+    <div className="min-w-0">
+      <dt className="text-faint">{label}</dt>
+      <dd className="mono tnum truncate text-xs text-fg" data-node-field={data}>{children}</dd>
+      {sub && <dd className="tnum truncate text-faint">{sub}</dd>}
+    </div>
+  )
+}
diff --git a/frontend/src/pages/runs/model.ts b/frontend/src/pages/runs/model.ts
index 4f3c9bee..53193221 100644
--- a/frontend/src/pages/runs/model.ts
+++ b/frontend/src/pages/runs/model.ts
@@ -9,7 +9,7 @@ import type { Approval, Run, RunStatus, RunUsage } from '../../types'
 import {
   RUN_STATUS_ORDER, STATUS, resolveStatus, serverStatusOf, type StatusCode,
 } from '../../lib/status'
-import { NONE, formatDuration, parseServerTime } from '../../lib/format'
+import { NONE, formatClock, formatDuration, parseServerTime } from '../../lib/format'
 import { hasPendingApproval } from '../../store/catalog'
 
 // -------------------------------------------------------------------------
@@ -202,6 +202,136 @@ export function runTiming(run: Pick<Run, 'usage' | 'created_at' | 'started_at' |
 /** 列表里那一个数：优先墙钟 */
 export const headlineMs = (t: RunTiming): number | null => t.wallMs ?? t.activeMs
 
+// -------------------------------------------------------------------------
+// 列表行的缩略条
+// -------------------------------------------------------------------------
+
+/**
+ * active：执行；wait：等人审批；other：墙钟里既不算执行也不算等人的部分（排队、
+ * 两段之间的空当）；unknown：老数据，只知道总长、分不出执行和等人；live：还在跑
+ */
+export type ShapeKind = 'active' | 'wait' | 'other' | 'unknown' | 'live'
+
+export interface RunShape {
+  /** 各段占墙钟的比例，加起来是 1；空数组 = 连墙钟都不知道 */
+  segs: { kind: ShapeKind; frac: number; open?: boolean }[]
+  /** 收在哪种结局上：只给要注意的几种，已完成不标 */
+  end: 'failed' | 'cancelled' | 'suspended' | null
+  title: string
+}
+
+/**
+ * 一条运行的墙钟里执行、等人各占多少。只用列表里就有的 usage 和审批，不为每一
+ * 行去拉事件——所以它是构成，不是时间顺序：几段审批各在哪里，要进详情看航迹。
+ * 唯一的例外是正在等的那一段，它一定在最后。
+ *
+ * 分不出来的（老数据没有分段计时）画成虚的一整条，不按比例猜。
+ */
+export function runShape(
+  run: Pick<Run, 'usage' | 'created_at' | 'started_at' | 'finished_at' | 'status'>,
+  code: StatusCode,
+  opts: { waitingSince?: string | null; now?: number } = {},
+): RunShape {
+  const now = opts.now ?? Date.now()
+  if (code === 'running' || code === 'queued') {
+    return { segs: [{ kind: 'live', frac: 1 }], end: null, title: code === 'queued' ? '排队中' : '运行中：跑完才分得出执行和等人' }
+  }
+  const t = runTiming(run)
+  const pieces =(wall: number, active: number | null, wait: number, openWait = 0) => {
+    const f = (ms: number) => Math.max(0, Math.min(1, ms / wall))
+    const segs: RunShape['segs'] = []
+    if (active != null) segs.push({ kind: 'active', frac: f(active) })
+    if (wait > 0) segs.push({ kind: 'wait', frac: f(wait) })
+    const used = segs.reduce((n, s) => n + s.frac, 0) + f(openWait)
+    const rest = Math.max(0, 1 - used)
+    if (rest > 0.005) segs.push({ kind: active == null ? 'unknown' : 'other', frac: rest })
+    if (openWait > 0) segs.push({ kind: 'wait', frac: f(openWait), open: true })
+    return segs
+  }
+
+  if (code === 'waiting') {
+    const start = parseServerTime(run.started_at ?? run.created_at ?? null)?.getTime()
+    const since = parseServerTime(opts.waitingSince ?? null)?.getTime()
+    if (start == null || since == null || now <= start) return { segs: [], end: null, title: '等待审批' }
+    const wall = now - start
+    const open = Math.max(0, now - since)
+    const active = t.source === 'usage' ? t.activeMs : null
+    const before = t.source === 'usage' ? t.waitMs ?? 0 : 0
+    return {
+      segs: pieces(wall, active, before, open),
+      end: null,
+      title: `墙钟 ${formatSpan(wall)}（至今） · 执行 ${formatSpan(active)} · 等人 ${formatSpan(before + open)}（还在等）`,
+    }
+  }
+
+  const end: RunShape['end'] = code === 'failed' ? 'failed' : code === 'cancelled' ? 'cancelled'
+    : code === 'held' || code === 'suspended' ? 'suspended' : null
+  if (t.wallMs == null || t.wallMs <= 0) {
+    return { segs: [], end, title: t.activeMs != null ? timingTitle(t) : '没有时长记录' }
+  }
+  return { segs: pieces(t.wallMs, t.activeMs, t.waitMs ?? 0), end, title: timingTitle(t) }
+}
+
+// -------------------------------------------------------------------------
+// 取消
+// -------------------------------------------------------------------------
+
+/**
+ * 取消的原因，去掉后端统一加的「用户取消：」前缀；只有那四个字的（跑着时点了
+ * 停止）没有别的原因，返回 null。列表写「已取消 · 在等审批时放弃了这次运行」，
+ * 不写「已取消 · 用户取消：在等审批时…」
+ */
+export function cancelReason(error: string | null | undefined): string | null {
+  const text = (error ?? '').trim()
+  if (!text || text === '用户取消') return null
+  return text.replace(/^用户取消\s*[:：]\s*/, '') || null
+}
+
+// -------------------------------------------------------------------------
+// 详情的几个视图
+// -------------------------------------------------------------------------
+
+/** stream：时间线（逐步的文字）；trace：航迹（按时间摊开、可回放）；artifacts：工件 */
+export type DetailView = 'stream' | 'trace' | 'artifacts'
+export const DETAIL_VIEWS: readonly DetailView[] = ['stream', 'trace', 'artifacts']
+export const asView = (v: string | null | undefined): DetailView =>
+  (DETAIL_VIEWS as readonly string[]).includes(v ?? '') ? (v as DetailView) : 'stream'
+
+/**
+ * 图的骨架：节点 id 和连线。运行时的快照和工作流现在的样子骨架不同，画布上回放
+ * 就是把这次的事件套在另一张图上——对不上的节点不会亮，要先说清
+ */
+export function graphShape(g: { nodes?: { id: string }[]; edges?: { source: string; target: string; sourceHandle?: string | null }[] } | null | undefined): string | null {
+  if (!g?.nodes) return null
+  const ids = g.nodes.map((n) => n.id).sort().join(',')
+  const links = (g.edges ?? []).map((e) => `${e.source}>${e.target}:${e.sourceHandle ?? ''}`).sort().join(',')
+  return `${ids}|${links}`
+}
+
+// -------------------------------------------------------------------------
+// 工件
+// -------------------------------------------------------------------------
+
+export interface RunArtifact {
+  id: string
+  kind: string
+  node_id: string | null
+  size: number | null
+  meta: Record<string, any> | null
+  created_at: string | null
+}
+
+export const ARTIFACT_KIND_LABEL: Record<string, string> = {
+  query_snapshot: '查询快照',
+  tool_snapshot: '工具快照',
+  retrieval_snapshot: '检索快照',
+  node_output: '节点产出',
+}
+export const artifactKindLabel = (kind: string): string => ARTIFACT_KIND_LABEL[kind] ?? kind
+
+/** 证据：查询、工具、检索的快照。节点产出是过程里的中间值，一次循环就是几十件 */
+export const isEvidence = (kind: string): boolean => kind !== 'node_output'
+
 /** 三种时长写进 title：「墙钟 1 分 27 秒 · 执行 7.6 s · 等人 1 分 14 秒」 */
 export function timingTitle(t: RunTiming): string {
   const parts = [
@@ -240,6 +370,19 @@ export function formatSpan(ms: number | null | undefined, opts?: { coarse?: bool
   return formatDuration(ms)
 }
 
+/**
+ * 航迹上相对开始的时刻（不带「T+」）。一天以内是秒表读数「05:03.4」「3:05:03.4」；
+ * 过了一天写「9 天 00:38:26」：「216:38:26.2」得自己除 24，而同一行的墙钟、等人
+ * 写的是「9 天」。十分之一秒放不下了，隔了几天也没人要它
+ */
+export function formatOffset(ms: number | null | undefined): string {
+  if (!isNum(ms) || ms < 0) return NONE
+  const DAY = 86_400_000
+  if (ms < DAY) return formatClock(ms)
+  const secs = Math.floor((ms % DAY) / 1000)
+  return `${Math.floor(ms / DAY)} 天 ${pad2(Math.floor(secs / 3600))}:${pad2(Math.floor(secs / 60) % 60)}:${pad2(secs % 60)}`
+}
+
 /** 等了多久算"久"：超过一天就该有人管了 */
 export const LONG_WAIT_MS = 86_400_000
 
@@ -281,11 +424,7 @@ export const isUnsaved = (run: Pick<Run, 'workflow_id' | 'workflow_name'>): bool
 export const runName = (run: Pick<Run, 'workflow_id' | 'workflow_name'>): string =>
   isUnsaved(run) ? UNSAVED_NAME : run.workflow_name
 
-/**
- * 这次运行实际用的记忆域和知识库。后端 RunOut 已经带着，types.ts 的 Run 还没
- * 声明（第二波不能改 types），先在这里收窄一次，别处不再写 as any。
- */
+/** 这次运行实际用的记忆域和知识库，null 收成 undefined：重新发起时原样带上，没有就不带 */
 export function runScope(run: Run): { memory_scope?: string; collection?: string } {
-  const r = run as Run & { memory_scope?: string | null; collection?: string | null }
-  return { memory_scope: r.memory_scope ?? undefined, collection: r.collection ?? undefined }
+  return { memory_scope: run.memory_scope ?? undefined, collection: run.collection ?? undefined }
 }
diff --git a/frontend/src/pages/runs/parts.tsx b/frontend/src/pages/runs/parts.tsx
index e7567927..54124f88 100644
--- a/frontend/src/pages/runs/parts.tsx
+++ b/frontend/src/pages/runs/parts.tsx
@@ -1,7 +1,7 @@
 import { useEffect, useRef, useState, type KeyboardEvent, type ReactNode } from 'react'
 import { Check, Copy, MoreHorizontal, ShieldCheck } from 'lucide-react'
 import clsx from 'clsx'
-import { toast } from '../../components/ui'
+import { rovingTarget, toast, useTicker } from '../../components/ui'
 import { formatClock, parseServerTime } from '../../lib/format'
 import { ISSUANCE_LABEL, runClassLabel } from '../../lib/terms'
 import { useRunClock } from '../../run/useRunClock'
@@ -17,6 +17,8 @@ export interface TabItem<K extends string> {
   /** 右侧的计数。tone 决定它醒不醒目：待审批要人处理，失败是历史，不该一样响 */
   count?: number | null
   countLabel?: string
+  /** 读屏念计数时的量词：运行、审批论「条」，工件论「件」 */
+  unit?: string
   tone?: 'alert' | 'live' | 'quiet'
   title?: string
 }
@@ -26,23 +28,21 @@ export interface TabItem<K extends string> {
  * 多了一样：计数分轻重。Tabs 的徽标只有一种强调色，「失败 32」天天亮着就成了
  * 噪音，而「待审批 2」必须醒目。
  */
-export function RunTabs<K extends string>({ tabs, active, onChange, label, idPrefix }: {
+export function RunTabs<K extends string>({ tabs, active, onChange, label, idPrefix, className }: {
   tabs: TabItem<K>[]; active: K; onChange: (k: K) => void; label: string; idPrefix: string
+  /** 换掉默认的底边线（放进已经有分隔线的地方时） */
+  className?: string
 }) {
   const refs = useRef<Record<string, HTMLButtonElement | null>>({})
   const move = (e: KeyboardEvent, i: number) => {
-    let next = -1
-    if (e.key === 'ArrowRight') next = (i + 1) % tabs.length
-    else if (e.key === 'ArrowLeft') next = (i - 1 + tabs.length) % tabs.length
-    else if (e.key === 'Home') next = 0
-    else if (e.key === 'End') next = tabs.length - 1
+    const next = rovingTarget(e, i, tabs.length, 'horizontal')
     if (next < 0) return
     e.preventDefault()
     onChange(tabs[next].key)
     refs.current[tabs[next].key]?.focus()
   }
   return (
-    <div className="flex shrink-0 gap-0.5 border-b px-2" role="tablist" aria-label={label}>
+    <div className={clsx('flex shrink-0 gap-0.5 px-2', className ?? 'border-b')} role="tablist" aria-label={label}>
       {tabs.map((t, i) => {
         const selected = t.key === active
         const n = t.count ?? 0
@@ -74,7 +74,7 @@ export function RunTabs<K extends string>({ tabs, active, onChange, label, idPre
                   t.tone === 'live' && 'text-st-running',
                   (!t.tone || t.tone === 'quiet') && 'text-faint',
                 )}
-                aria-label={`${t.countLabel ?? n} 条`}
+                aria-label={`${t.countLabel ?? n} ${t.unit ?? '条'}`}
               >
                 {t.countLabel ?? n}
               </span>
@@ -149,7 +149,7 @@ export function LiveElapsed({ since, prefix = '已运行 ' }: { since?: string |
   const start = parseServerTime(since ?? null)?.getTime()
   const long = start != null && Date.now() - start >= CLOCK_MAX_MS
   const tick = useRunClock(!long)
-  const slow = useNow(60_000, long)
+  const slow = useTicker(60_000, long)
   if (start == null) return <span className="tnum">{prefix}—</span>
   const ms = Math.max(0, (long ? Math.max(slow, Date.now()) : tick) - start)
   return <span className="tnum">{prefix}{long ? formatSpan(ms) : formatClock(ms)}</span>
@@ -158,20 +158,6 @@ export function LiveElapsed({ since, prefix = '已运行 ' }: { since?: string |
 /** 秒表读数只用到一小时以内；再长就换成「X 小时 YY 分」「X 天 YY 小时」 */
 export const CLOCK_MAX_MS = 3_600_000
 
-/**
- * 慢节拍的「现在」：等了几天的审批按分钟刷新就够了，用不着 100ms 一拍的运行
- * 时钟。页面不可见时不刷。
- */
-export function useNow(intervalMs: number, active = true): number {
-  const [now, setNow] = useState(() => Date.now())
-  useEffect(() => {
-    if (!active) return
-    const t = setInterval(() => { if (!document.hidden) setNow(Date.now()) }, intervalMs)
-    return () => clearInterval(t)
-  }, [intervalMs, active])
-  return now
-}
-
 // -------------------------------------------------------------------------
 // 复制
 // -------------------------------------------------------------------------
diff --git a/frontend/src/pages/runs/runs.css b/frontend/src/pages/runs/runs.css
index 00a4b47b..47566fa3 100644
--- a/frontend/src/pages/runs/runs.css
+++ b/frontend/src/pages/runs/runs.css
@@ -73,6 +73,184 @@
   100% { opacity: 0; }
 }
 
+/* 列表行的缩略条：墙钟里执行、等人各占多少。执行是安静的灰，等人用斜纹的
+   琥珀（和航迹里等人的段同一种纹理），失败、取消、挂起在末端点一下。颜色之外
+   还有纹理和位置两条通道，去掉颜色也分得出 */
+.runs-shape {
+  position: relative;
+  display: inline-flex;
+  flex: none;
+  width: 40px;
+  height: 5px;
+  overflow: hidden;
+  border-radius: 2px;
+  background: var(--bg-hover);
+}
+.runs-shape[data-empty] {
+  background: none;
+  box-shadow: inset 0 0 0 1px var(--border);
+}
+.runs-shape > i {
+  display: block;
+  flex: none;
+  height: 100%;
+}
+/* 太短的段也留 2px：墙钟里占 1% 的执行照样看得见"有过" */
+.runs-shape > i:not([style*='width: 0%']) {
+  min-width: 2px;
+}
+.runs-shape-active {
+  background: color-mix(in srgb, var(--text-faint) 75%, transparent);
+}
+.runs-shape-live {
+  background: color-mix(in srgb, var(--st-running) 60%, transparent);
+}
+.runs-shape-wait {
+  background: repeating-linear-gradient(
+    135deg,
+    var(--st-waiting) 0 2px,
+    color-mix(in srgb, var(--st-waiting) 35%, transparent) 2px 4px
+  );
+}
+.runs-shape-other {
+  background: transparent;
+}
+.runs-shape-unknown {
+  background: repeating-linear-gradient(
+    90deg,
+    color-mix(in srgb, var(--text-faint) 55%, transparent) 0 2px,
+    transparent 2px 4px
+  );
+}
+.runs-shape-end {
+  position: absolute;
+  top: 0;
+  right: 0;
+  bottom: 0;
+  width: 3px;
+  background: var(--st-cancelled);
+}
+.runs-shape-end[data-shape-end='failed'] {
+  background: var(--st-failed);
+}
+.runs-shape-end[data-shape-end='suspended'] {
+  background: var(--st-suspended);
+}
+
+/* 详情头的六格读数。1024 宽下详情区只有 600px，一格不到 70px 的字宽：「5 分 06 秒」
+   「2.8k tok」差几像素就被截成省略号。按详情区自己的宽度（不是视口）让状态格让出
+   一点、收紧边距、小一号字 */
+.runs-head {
+  container: rhead / inline-size;
+}
+.runs-telemetry {
+  grid-template-columns: minmax(140px, 1.5fr) repeat(5, minmax(76px, 1fr));
+}
+@container rhead (max-width: 720px) {
+  .runs-telemetry {
+    grid-template-columns: minmax(124px, 1.2fr) repeat(5, minmax(0, 1fr));
+  }
+  .runs-telemetry > * {
+    padding-inline: 8px;
+  }
+  .runs-telemetry [data-telemetry] {
+    font-size: var(--text-sm);
+  }
+}
+
+/* 航迹页签上面的游标读数。按自己的宽度排（左栏 360–400px、详情区从 600px 起），
+   不按视口：窄时八格排两行、「此刻」和节点卡上下叠 */
+.runs-trace-read {
+  container: tread / inline-size;
+}
+.runs-trace-grid {
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+.runs-trace-grid > * {
+  border-left: 1px solid var(--hairline);
+}
+.runs-trace-grid > :nth-child(4n + 1) {
+  border-left: 0;
+}
+.runs-trace-grid > :nth-child(n + 5) {
+  border-top: 1px solid var(--hairline);
+}
+/* 排成两行时每格少 4px 的上下留白：两行省下的，正好让节点卡露全 */
+.runs-trace-grid > * {
+  padding-block: 4px;
+}
+/* 很窄时（左栏里）从上往下：此刻、节点（或最耗时的）、关键时刻；详情区里就分两栏，
+   左栏上下是此刻和关键时刻，右栏是节点——点了关键时刻，右边的节点卡跟着换成那一刻。
+   1024 宽时详情区只有 600px、下面还有航迹坞，叠成一栏的话节点卡和关键时刻都在视线外 */
+.runs-trace-cols {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr);
+  grid-template-areas: 'now' 'side' 'moments';
+}
+.runs-trace-now {
+  grid-area: now;
+}
+.runs-trace-side {
+  grid-area: side;
+  border-top: 1px solid var(--hairline);
+}
+.runs-trace-moments {
+  grid-area: moments;
+  border-top: 1px solid var(--hairline);
+}
+/* 排成一行要每格都放得下最长的读数：游标「T+10 天 05:30:07」约 123px，跨天的时长
+   「10 天 05 小时」约 94px。1440 宽时详情区 976px，左右各留 10px 刚好；再窄就排两行 */
+@container tread (min-width: 948px) {
+  .runs-trace-grid {
+    grid-template-columns: minmax(0, 1.32fr) repeat(7, minmax(0, 1fr));
+  }
+  .runs-trace-grid > :nth-child(4n + 1) {
+    border-left: 1px solid var(--hairline);
+  }
+  .runs-trace-grid > :first-child {
+    border-left: 0;
+  }
+  .runs-trace-grid > :nth-child(n + 5) {
+    border-top: 0;
+  }
+  .runs-trace-grid > * {
+    padding-block: 6px;
+    padding-inline: 10px;
+  }
+}
+@container tread (min-width: 560px) {
+  .runs-trace-cols {
+    grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+    grid-template-rows: auto 1fr;
+    grid-template-areas: 'now side' 'moments side';
+  }
+  .runs-trace-side {
+    border-top: 0;
+    border-left: 1px solid var(--hairline);
+  }
+}
+
+/* 读数区放不下、下面还有：底边淡出一截，看得出能往下滚。遮罩按滚动框算，不随内容走 */
+.runs-trace-read[data-more] {
+  -webkit-mask-image: linear-gradient(to bottom, #000 calc(100% - 28px), transparent);
+  mask-image: linear-gradient(to bottom, #000 calc(100% - 28px), transparent);
+}
+
+/* 关键时刻：时刻那一栏按最宽的一条排齐（「T+05:03.4」到「T+9 天 00:38:26」），
+   各行共用一套列，不猜一个固定宽度——固定 76px 时跨天的时刻压到了后面的徽标上 */
+.runs-moments {
+  display: grid;
+  grid-template-columns: max-content 14px minmax(0, 1fr);
+  column-gap: 6px;
+}
+.runs-moments > li,
+.runs-moments > li > button {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: subgrid;
+}
+
 @media (prefers-reduced-motion: reduce) {
   /* 扫描线停了就等于没有：直接不画，凭证条上的「核对中…」文字照样在 */
   .runs-verify-scan {
diff --git a/frontend/src/run/AssistantPanel.tsx b/frontend/src/run/AssistantPanel.tsx
index 92dd4d57..88e06ef7 100644
--- a/frontend/src/run/AssistantPanel.tsx
+++ b/frontend/src/run/AssistantPanel.tsx
@@ -1,22 +1,24 @@
 import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
 import { Link } from 'react-router-dom'
 import {
-  ChevronLeft, ChevronRight, Code2, Crosshair, Hand, History, MessageSquarePlus, Play, Square,
-  Undo2, Wand2,
+  Ban, ChevronLeft, ChevronRight, Code2, Crosshair, Hand, History, MessageSquarePlus, Play, Square,
+  Undo2, Wand2, Wrench,
 } from 'lucide-react'
 import clsx from 'clsx'
 import { useCatalog } from '../store/catalog'
 import { useStudio, type CopilotTurn } from '../store/studio'
-import { IconButton, StatusBadge, toast } from '../components/ui'
+import { confirmDialog, IconButton, StatusBadge, toast } from '../components/ui'
 import { formatClock, formatCost, formatDuration, formatTokens, shortId, NONE } from '../lib/format'
 import { statusLabel } from '../lib/status'
 import { runClassLabel } from '../lib/terms'
+import type { ToolChange } from '../types'
 import { AssistantStream, type StreamTurn } from './AssistantStream'
 import { Composer } from './Composer'
 import {
-  copilotOutcome, decodeCopilot, decodeRun, SELF_CHECK_ROUNDS, type CopilotIssue, type Step,
+  copilotOutcome, decodeCopilot, decodeRun, SELF_CHECK_ROUNDS, type CopilotIssue,
 } from './decode'
 import { ApprovalCard } from './RunPanel'
+import { useRunGlance } from './RunHud'
 import { isSettled, liveAt, project, type RunPhase } from './trace'
 import { useRunClock } from './useRunClock'
 
@@ -42,21 +44,58 @@ import { useRunClock } from './useRunClock'
 export function AssistantPanel() {
   const run = useStudio((s) => s.run)
   const [view, setView] = useState<'chat' | 'run'>('chat')
+  const [reveal, setReveal] = useState<Reveal | null>(null)
+  const rootRef = useRef<HTMLDivElement>(null)
 
   // 发起一次新运行就把这一层推到前面——那是此刻唯一在发生的事
   useEffect(() => {
     if (run?.id) setView('run')
+    setReveal(null)
   }, [run?.id])
 
+  // 画布上的胶囊「去审批」、成果节点的出具印章要把人带到右栏的审批卡 / 出具横幅。右栏停在
+  // 对话层时那两样根本不在页面上，以前只能退回一句 toast——所以由右栏自己听、自己切过去，
+  // 并 preventDefault 告诉派发方「接手了」。右栏收起时它还挂着（只是藏起来），那时不接：
+  // 切过去也没人看得见，让派发方自己兜底
+  useEffect(() => {
+    const listen = (kind: Reveal['kind']) => (e: Event) => {
+      const runId = (e as CustomEvent<{ runId?: string }>).detail?.runId
+      const s = useStudio.getState()
+      const root = rootRef.current
+      if (!s.run || (runId && runId !== s.run.id)) return
+      if (!root || !root.offsetWidth || getComputedStyle(root).visibility !== 'visible') return
+      e.preventDefault()
+      // 属性面板盖在右栏上：先让开，要看的东西在它下面
+      s.select(null)
+      setView('run')
+      setReveal((r) => ({ kind, seq: (r?.seq ?? 0) + 1 }))
+    }
+    const approval = listen('approval')
+    const issuance = listen('issuance')
+    window.addEventListener('agentlab:goto-approval', approval)
+    window.addEventListener('agentlab:goto-issuance', issuance)
+    return () => {
+      window.removeEventListener('agentlab:goto-approval', approval)
+      window.removeEventListener('agentlab:goto-issuance', issuance)
+    }
+  }, [])
+
   return (
-    <div className="relative flex h-full min-h-0 flex-col">
+    // data-assistant-panel：画布上的出具印章据此判断「点了有人接」，右栏在对话层时它照样能点
+    <div ref={rootRef} data-assistant-panel="" className="relative flex h-full min-h-0 flex-col">
       {view === 'run' && run
-        ? <RunView onBack={() => setView('chat')} />
+        ? <RunView onBack={() => setView('chat')} reveal={reveal} />
         : <ChatView hasRun={!!run} onOpenRun={() => setView('run')} />}
     </div>
   )
 }
 
+/** 别处请右栏摆到眼前的东西：审批卡、出具横幅。seq 让同一个请求连着来两次也会再做一遍 */
+interface Reveal {
+  kind: 'approval' | 'issuance'
+  seq: number
+}
+
 // -------------------------------------------------------------------------
 // 对话：和 Copilot 说话的地方
 // -------------------------------------------------------------------------
@@ -84,7 +123,10 @@ function copilotTurn(t: TurnExtras, live: { lastOp: string; phase: string; repai
   const foundN = Array.isArray(found?.issues) ? found!.issues.length : 0
   const reply = out.reply ?? t.reply
   const errorOp = out.error
-  const steps = decodeCopilot(t.ops, { context: 'canvas' })
+  const unchanged = t.outcome === 'unchanged'
+  const steps = decodeCopilot(t.ops, { context: 'canvas', unchanged })
+  // 模型改提示词时漏写了 tools、把节点的工具抹掉了：图照样能跑，只是什么都查不到
+  const lost = out.toolChanges.filter((c) => c.removed.length)
   // 回执说清改了什么：「流程已更新」不说改了哪几处，改坏了都不知道从哪看起
   const d = t.diff
   const changed = d ? [
@@ -111,13 +153,22 @@ function copilotTurn(t: TurnExtras, live: { lastOp: string; phase: string; repai
     status = '已回答（没有改动画布）'
   } else if (out.kind === 'built') {
     if (out.check?.status === 'failed') {
-      status = `已放到画布，但还有 ${out.check.issues.length} 处问题要你处理`
+      status = unchanged
+        ? `画布没有改动，但还有 ${out.check.issues.length} 处问题要你处理`
+        : `已放到画布，但还有 ${out.check.issues.length} 处问题要你处理`
       tone = 'warn'
     } else if (out.skipped.length) {
       status = `已放到画布，但有 ${out.skipped.length} 步没放上`
       tone = 'warn'
+    } else if (lost.length) {
+      status = `${updated} · ${lost.length} 处工具被去掉了`
+      tone = 'warn'
+    } else if (unchanged) {
+      // 收到了 final，但一处都没变：说「已更新画布」是在报一个没发生的改动
+      status = '看过了，画布没有需要改的地方'
     } else if (out.check?.status === 'passed' && out.check.repaired) {
-      status = `${updated} · 自查发现 ${foundN || '几'} 处问题，已自动修好`
+      // 修了几处只有「交回去改」那一条带着数；没有它（一次就修好）时不硬凑「几 处」
+      status = `${updated} · ${foundN ? `自查发现 ${foundN} 处问题，已自动修好` : '自查发现的问题已自动修好'}`
     } else if (out.check?.status === 'passed') {
       status = `${updated} · 自查通过`
     } else {
@@ -200,25 +251,32 @@ function ChatView({ hasRun, onOpenRun }: { hasRun: boolean; onOpenRun: () => voi
       )
     }
     const issues = out.check?.status === 'failed' ? out.check.issues : []
+    const lost = out.toolChanges.filter((c) => c.removed.length)
     const undo = source.outcome === 'applied' || (out.kind === 'built' && source.outcome !== 'reverted')
-    if (!issues.length && !out.skipped.length) {
+    if (!issues.length && !out.skipped.length && !lost.length) {
       return undo ? (
         <button type="button" className="btn btn-xs btn-ghost" onClick={() => undoCopilotTurn(source.id)}>
           <Undo2 size={11} aria-hidden /> 撤销这次生成
         </button>
       ) : null
     }
+    // 只是工具被抹掉了：让 Copilot 再修不管用（自查是通过的），撤回这一轮才是一步到位的补救
+    const repairable = issues.length > 0 || out.skipped.length > 0
     return (
       <div className="w-full space-y-1.5">
         {/* 没修好的问题直接摊开，不折叠：这是此刻唯一要做的事 */}
         {issues.length > 0 && <IssueList issues={issues} onLocate={locate} />}
+        {lost.length > 0 && <ToolLossList changes={lost} onLocate={locate} />}
         <div className="flex flex-wrap items-center gap-1.5">
-          <button type="button" className="btn btn-xs btn-primary"
-                  onClick={() => repairWithCopilot(source.id)}>
-            <Wand2 size={11} aria-hidden /> {issues.length ? '让 Copilot 再修' : '让 Copilot 补上'}
-          </button>
+          {repairable && (
+            <button type="button" className="btn btn-xs btn-primary"
+                    onClick={() => repairWithCopilot(source.id)}>
+              <Wand2 size={11} aria-hidden /> {issues.length ? '让 Copilot 再修' : '让 Copilot 补上'}
+            </button>
+          )}
           {undo && (
-            <button type="button" className="btn btn-xs btn-ghost" onClick={() => undoCopilotTurn(source.id)}>
+            <button type="button" className={clsx('btn btn-xs', repairable ? 'btn-ghost' : 'btn-primary')}
+                    onClick={() => undoCopilotTurn(source.id)}>
               <Undo2 size={11} aria-hidden /> 撤销这次生成
             </button>
           )}
@@ -305,41 +363,76 @@ function IssueList({ issues, onLocate }: { issues: CopilotIssue[]; onLocate: (id
   )
 }
 
+/**
+ * 这一轮被去掉的工具，逐个节点列出来：去掉了什么、还剩什么。「修改 1」说不出节点的
+ * 查库工具被整个抹掉了，要到运行结果不对才会发现
+ */
+function ToolLossList({ changes, onLocate }: { changes: ToolChange[]; onLocate: (id: string) => void }) {
+  return (
+    <ul data-tool-changes="" className="space-y-0.5 rounded border px-2 py-1.5 text-2xs leading-relaxed"
+        style={{ borderColor: 'color-mix(in srgb, var(--st-waiting) 45%, var(--border))',
+                 background: 'var(--st-waiting-soft)' }}>
+      {changes.map((c) => (
+        <li key={`${c.node_id}|${c.member ?? ''}`} className="flex items-start gap-1.5">
+          <Wrench size={10} className="mt-[3px] shrink-0" style={{ color: 'var(--st-waiting)' }} aria-hidden />
+          <span className="min-w-0 flex-1 [overflow-wrap:anywhere]">
+            「{c.label}」{c.member ? `的成员「${c.member}」` : ''}去掉了{' '}
+            <span className="mono">{c.removed.join('、')}</span>
+            {c.after.length ? `，还剩 ${c.after.join('、')}` : '，现在一个工具都没有'}
+          </span>
+          {c.node_id && (
+            <button type="button"
+                    className="inline-flex shrink-0 items-center gap-0.5 rounded px-1 text-dim transition-colors hover:bg-hover hover:text-fg"
+                    onClick={() => onLocate(c.node_id)}>
+              <Crosshair size={10} aria-hidden /> 定位
+            </button>
+          )}
+        </li>
+      ))}
+    </ul>
+  )
+}
+
 /**
  * 对话下面那条运行进度。
  *
  * 运行搬去自己那一层之后，这条是它在对话视图里留下的唯一痕迹——没有它，
- * 点了运行再切回对话，这次运行在眼前就彻底没了。状态只读 runPhase：以前这里
- * 看步骤、审批列表、streaming 三样各自猜，等审批时会同时写"正在执行"。
+ * 点了运行再切回对话，这次运行在眼前就彻底没了。相位、那一句话和计时读
+ * useRunGlance，和画布上的胶囊同一份：以前这里自己解码步骤、自己起名，同一时刻
+ * 胶囊写「停在『主管审批』」、这里写「等待审批」，计时也各走各的。
  */
 function RunStrip({ onClick }: { onClick: () => void }) {
   const run = useStudio((s) => s.run)
-  const events = useStudio((s) => s.events)
-  const phase = useStudio((s) => s.runPhase)
-  const steps = useMemo(() => (phase === 'running' ? decodeRun(events) : []), [events, phase])
+  const g = useRunGlance(true)
   if (!run) return null
 
-  const last = phase === 'running' ? lastMeaningful(steps) : undefined
+  const phase = g.phase
   const waiting = phase === 'waiting'
   const alert = phase === 'failed' || phase === 'suspended'
+  const ticking = phase === 'running' || phase === 'queued'
 
   return (
     <button
       type="button"
+      data-run-strip={phase}
       className="flex w-full shrink-0 items-center gap-2 border-t px-2.5 py-1.5 text-left text-2xs transition-colors hover:bg-hover"
       style={waiting ? { background: 'var(--st-waiting-soft)' } : undefined}
       title="看这次运行的完整过程" onClick={onClick}
     >
       {phase === 'idle'
         ? <Play size={10} className="shrink-0 text-faint" fill="currentColor" aria-hidden />
-        : <StatusBadge status={phase === 'succeeded' ? 'succeeded' : phase} size={11} decorative />}
-      <span className={clsx('min-w-0 flex-1 truncate', !waiting && !alert && 'text-dim')}
-            style={waiting ? { color: 'var(--st-waiting)' } : alert ? { color: 'var(--st-failed)' } : undefined}>
-        {waiting ? `${statusLabel('waiting')} · 去处理`
-          : phase === 'running' ? (last?.title || statusLabel('running'))
-          : phase === 'idle' ? '运行'
-          : `这次运行${statusLabel(phase)}`}
+        : <StatusBadge status={phase} size={11} decorative />}
+      <span className="min-w-0 flex-1 truncate">
+        <span className={clsx('font-medium', !waiting && !alert && 'text-fg')}
+              style={waiting ? { color: 'var(--st-waiting)' } : alert ? { color: 'var(--st-failed)' } : undefined}>
+          {phase === 'idle' ? '运行' : g.label}
+        </span>
+        {g.headline && phase !== 'idle' && <span className="text-dim"> · {g.headline}</span>}
+        {waiting && <span style={{ color: 'var(--st-waiting)' }}> · 去处理</span>}
       </span>
+      {ticking && (
+        <span className="mono tnum shrink-0" style={{ color: 'var(--st-running)' }}>{formatClock(g.elapsedMs)}</span>
+      )}
       <ChevronRight size={11} className="shrink-0 text-faint" aria-hidden />
     </button>
   )
@@ -354,7 +447,7 @@ const STREAM_PHASE: Record<RunPhase, StreamTurn['phase']> = {
   succeeded: 'done', failed: 'error', cancelled: 'done', suspended: 'done',
 }
 
-function RunView({ onBack }: { onBack: () => void }) {
+function RunView({ onBack, reveal }: { onBack: () => void; reveal: Reveal | null }) {
   const run = useStudio((s) => s.run)!
   const events = useStudio((s) => s.events)
   const phase = useStudio((s) => s.runPhase)
@@ -363,6 +456,7 @@ function RunView({ onBack }: { onBack: () => void }) {
   const stopRun = useStudio((s) => s.stopRun)
   const setHoveredNode = useStudio((s) => s.setHoveredNode)
   const focusNode = useStudio((s) => s.focusNode)
+  const select = useStudio((s) => s.select)
   const hoveredNodeId = useStudio((s) => s.hoveredNodeId)
   const approvals = useCatalog((s) => s.approvals)
   const refreshApprovals = useCatalog((s) => s.refreshApprovals)
@@ -430,14 +524,63 @@ function RunView({ onBack }: { onBack: () => void }) {
       setStopping(false)
     }
   }
+  /**
+   * 放弃停在审批上（或服务重启时挂起）的运行。它已经不在执行，没有「停止」可言；后端
+   * 把它直接收成已取消，待审批一并关闭。关掉的审批找不回来，所以先问一句——和画布
+   * 胶囊上的「放弃」同一套说法
+   */
+  const abandon = async () => {
+    const ok = await confirmDialog({
+      title: '放弃这次运行？',
+      body: phase === 'suspended'
+        ? '运行在服务重启时挂起了。放弃之后它记为已取消，不能再从断点接着跑。'
+        : '运行停在审批上。放弃之后它记为已取消，不能再接着跑。',
+      consequences: [
+        ...(pending.length ? [`这次运行的 ${pending.length} 条待审批一并关闭，留痕里写上是谁放弃的`] : []),
+        '已经跑完的节点结果照样留在记录里',
+      ],
+      confirmLabel: '放弃这次运行',
+      danger: true,
+    })
+    if (ok) await stop()
+  }
+  const reducedMotion = () => typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches
   const toApproval = () => {
     const slot = bodyRef.current?.querySelector<HTMLElement>('[data-approval-slot]:not(:empty)')
-    const reduced = typeof matchMedia === 'function' && matchMedia('(prefers-reduced-motion: reduce)').matches
-    slot?.scrollIntoView({ block: 'center', behavior: reduced ? 'auto' : 'smooth' })
-    slot?.querySelector<HTMLElement>('textarea, input, button')?.focus({ preventScroll: true })
+    if (!slot) return
+    const card = slot.querySelector<HTMLElement>('[data-approval]') ?? slot
+    card.scrollIntoView({ block: 'center', behavior: reducedMotion() ? 'auto' : 'smooth' })
+    card.querySelector<HTMLElement>('textarea, input, button')?.focus({ preventScroll: true })
+    // 和胶囊找到卡片时同一个描边：人从画布那头被带过来，得知道「是这张」
+    card.classList.add('sf-flash')
+    setTimeout(() => card.classList.remove('sf-flash'), 1600)
+  }
+  const toIssuance = () => {
+    const banner = bodyRef.current?.querySelector<HTMLElement>('[data-issuance-banner]')
+    if (!banner) return
+    banner.scrollIntoView({ block: 'start', behavior: reducedMotion() ? 'auto' : 'smooth' })
+    banner.focus({ preventScroll: true })
+    banner.dataset.flash = 'focus'
+    setTimeout(() => { if (banner.dataset.flash === 'focus') delete banner.dataset.flash }, 1600)
   }
 
+  // 别处请这一层把审批卡 / 出具横幅摆到眼前（胶囊的「去审批」、成果节点的出具印章）。
+  // 卡片跟着审批列表来，刚停下时可能还在路上：等取回来（或确认没有）再办，别滚到空处
+  const revealed = useRef(0)
+  useEffect(() => {
+    if (!reveal || reveal.seq === revealed.current) return
+    if (raw) { setRaw(false); return }
+    if (reveal.kind === 'approval' && !hasCard && phase === 'waiting' && looked !== run.id) return
+    revealed.current = reveal.seq
+    // 等这一帧的布局落定：运行层刚挂上时，助手流自己也在做打开时的定位。不在清理里
+    // 取消——紧跟着来一条事件就会把这次请求吞掉；卸载了的话两个函数找不到东西自然不做
+    requestAnimationFrame(reveal.kind === 'approval' ? toApproval : toIssuance)
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [reveal, raw, hasCard, phase, looked, run.id, turns])
+
   const live = phase === 'running' || phase === 'queued'
+  // 停在审批上、服务重启时挂起的：不在执行，给的是「放弃」而不是「停止」
+  const parked = phase === 'waiting' || phase === 'suspended'
 
   return (
     <div className="sheet-in flex h-full min-h-0 flex-col">
@@ -458,12 +601,16 @@ function RunView({ onBack }: { onBack: () => void }) {
         </Link>
         <span className="flex-1" />
         {phase === 'waiting' && pending.length > 0 && (
-          // 等人时工具栏不给"停止"（后端对停在审批上的运行没有取消路径，点了必然
-          // 409），给的是此刻真正该做的事
+          // 等人时首要的是此刻真正该做的事；「放弃」是次一级的，收成一枚图标
           <button type="button" className="btn btn-xs" style={{ color: 'var(--st-waiting)' }} onClick={toApproval}>
             <Hand size={11} aria-hidden /> 去审批
           </button>
         )}
+        {parked && (
+          <IconButton label="放弃这次运行" variant="danger" disabled={stopping} onClick={() => void abandon()}>
+            <Ban size={12} aria-hidden />
+          </IconButton>
+        )}
         {live && (
           <IconButton label="停止这次运行" variant="danger" disabled={stopping} onClick={() => void stop()}>
             <Square size={11} fill="currentColor" aria-hidden />
@@ -489,6 +636,8 @@ function RunView({ onBack }: { onBack: () => void }) {
             clockSkewMs={trace.skewMs ?? 0}
             onStepHover={setHoveredNode}
             onStepFocus={focusNode}
+            // 没绑工具、轮数不够这种要去画布上改的：直接打开那个节点的设置，镜头也带过去
+            onStepOpen={(id) => { select(id); focusNode(id) }}
             activeNodeId={hoveredNodeId}
             // 审批卡插在它所属的那一轮里，而不是浮在整栏顶上：
             // 要确认的那件事和确认按钮之间不该隔着整条执行过程
@@ -577,17 +726,6 @@ function RunFooter() {
   )
 }
 
-/** 最后一条有意义的步骤：跳过生命周期行，那才是"此刻在干什么"。 */
-export function lastMeaningful(steps: Step[]): Step | undefined {
-  const flat: Step[] = []
-  const walk = (list: Step[]) => list.forEach((s) => {
-    flat.push(s)
-    if (s.children) walk(s.children)
-  })
-  walk(steps)
-  return [...flat].reverse().find((s) => s.kind !== 'lifecycle') ?? flat[flat.length - 1]
-}
-
 /** 原始事件。翻译层出问题时用来对照，平时收着。和步骤流一样只在贴底时跟随 */
 function RawEvents() {
   const events = useStudio((s) => s.events)
diff --git a/frontend/src/run/AssistantStream.tsx b/frontend/src/run/AssistantStream.tsx
index 524edbfe..84391690 100644
--- a/frontend/src/run/AssistantStream.tsx
+++ b/frontend/src/run/AssistantStream.tsx
@@ -4,19 +4,22 @@ import {
 } from 'react'
 import { Link } from 'react-router-dom'
 import {
-  AlertTriangle, ArrowDown, Brain, ChevronRight, CircleCheck, CircleDot, Database, Download,
-  ExternalLink, FileCode, FileDown, GitBranch, Hand, Info, Play, ShieldCheck, Sparkles,
-  Table2, Terminal, Users, Wrench, XCircle,
+  AlertCircle, AlertTriangle, ArrowDown, Brain, ChevronRight, CircleCheck, CircleDot, CornerDownRight,
+  Database, Download, ExternalLink, FileCode, FileDown, GitBranch, Hand, Info, Play, Settings2,
+  ShieldCheck, Sparkles, Table2, Terminal, UserX, Users, Wrench, XCircle,
 } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../api/client'
 import { ErrorNotice, Modal, Skeleton, StatusBadge } from '../components/ui'
+import { humanizeError } from '../lib/errors'
+import { explainRunError } from '../lib/explain'
 import { formatClock, formatDuration, formatNumber, shortId } from '../lib/format'
 import { statusLabel } from '../lib/status'
 import { issuanceLabel, nodeTypeLabel } from '../lib/terms'
 import {
-  childrenByExec, compactSteps, parseQueryResult, progressOf, spread,
-  type Exec, type ResultTable as Table, type Step, type StepKind, type TeamRun,
+  childrenByExec, compactSteps, parseQueryResult, progressOf, spread, teamVerdictOf,
+  type Exec, type FixKind, type ResultTable as Table, type Step, type StepKind, type TeamMemberEx,
+  type TeamRun,
 } from './decode'
 import { CODE_COLUMN, CopyChip, LEADING_ZERO, Markdown, type MarkSpec } from './Markdown'
 import { useRunClock } from './useRunClock'
@@ -34,6 +37,22 @@ import type { ReviewResult } from '../types'
  * 在哪儿看讲的都是同一个故事。
  */
 
+/**
+ * 页面已经拆好的报错：问数据页的 Failure、记录页的 explainRunError。照原样画，不再
+ * 交给 humanizeError 翻一遍——已经是人话的「操作超时：查询超时…」再翻一遍，就成了
+ * 「操作超时 / 操作超时：查询超时…」
+ */
+export interface TurnFailure {
+  title: string
+  reason?: string
+  /** 怎么办 */
+  hint?: string
+  /** 原文，收进技术细节 */
+  detail?: string
+  /** 该去哪儿改（lib/explain 的 fix）：给了就在报错里放直达入口 */
+  fix?: FixKind | 'rerun'
+}
+
 export interface StreamTurn {
   id: string
   /** 用户说了什么。画布上的 Copilot 指令也走这个字段 */
@@ -45,8 +64,18 @@ export interface StreamTurn {
   /** 还在流的思考（尚未成为 Step）。只有 Anthropic 系模型会有 */
   thinking?: string
   output?: Record<string, any> | null
-  /** 一句报错，或者 {error, hint, detail}（Copilot 的 error 操作）：原因和怎么办分开写，原文收进技术细节 */
-  error?: string | { error: string; hint?: string; detail?: string }
+  /**
+   * 报错，三种给法：
+   * - 一句原话：运行的失败按 lib/explain 讲清为什么、怎么办，别的按 humanizeError；
+   * - {error, hint?, detail?}：原话 + 怎么办 + 原文（Copilot 的 error 操作）；
+   * - TurnFailure：页面已经拆好的，照原样画。
+   */
+  error?: string | { error: string; hint?: string; detail?: string } | TurnFailure
+  /**
+   * 这一轮查了几次库。从库里恢复的轮次没有事件，步骤里数不出来，页面手上有落库的
+   * 次数就传进来；步骤里数得出来时以步骤为准
+   */
+  queries?: number
   runId?: string
   /** formal / exploratory。出具横幅要据此标注"不进正式归档" */
   runClass?: string
@@ -83,6 +112,8 @@ interface StreamCtx {
   dense: boolean
   onHover?: (nodeId: string | null) => void
   onFocus?: (nodeId: string) => void
+  /** 打开这个节点的设置去改（编排页）。下一步是「去画布改」的行据此给直达入口 */
+  onOpen?: (nodeId: string) => void
   activeNodeId?: string | null
   skewMs: number
   openArtifact: (id: string, title?: string) => void
@@ -119,7 +150,7 @@ const STICK_PX = 64
 
 export function AssistantStream({
   turns, dense = false, empty, approvalsFor, onOpenGraph, footer, renderTurnActions,
-  onStepHover, onStepFocus, activeNodeId, follow = true, landing, onFollowUp,
+  onStepHover, onStepFocus, onStepOpen, activeNodeId, follow = true, landing, onFollowUp,
   clockSkewMs = 0, className, resetKey,
 }: {
   turns: StreamTurn[]
@@ -136,6 +167,11 @@ export function AssistantStream({
   /** 编排页：步骤行悬停 / 点击时联动画布。问数据页没有画布，不传 */
   onStepHover?: (nodeId: string | null) => void
   onStepFocus?: (nodeId: string) => void
+  /**
+   * 编排页：打开某个节点的设置。节点没绑工具、团队轮数不够这类要去画布上改的，
+   * 报错和提醒行据此给「打开设置」；不传就只说该去哪儿改
+   */
+  onStepOpen?: (nodeId: string) => void
   /** 画布上悬停的节点：对应的步骤行高亮 */
   activeNodeId?: string | null
   /** 贴着底部时，新步骤到来自动滚到底。离开底部就不再拽人 */
@@ -236,9 +272,9 @@ export function AssistantStream({
   }
 
   const ctx = useMemo<StreamCtx>(() => ({
-    dense, onHover: onStepHover, onFocus: onStepFocus, activeNodeId, skewMs: clockSkewMs,
+    dense, onHover: onStepHover, onFocus: onStepFocus, onOpen: onStepOpen, activeNodeId, skewMs: clockSkewMs,
     openArtifact: (id, title) => setArtifact({ id, title }), reduced,
-  }), [dense, onStepHover, onStepFocus, activeNodeId, clockSkewMs, reduced])
+  }), [dense, onStepHover, onStepFocus, onStepOpen, activeNodeId, clockSkewMs, reduced])
 
   const rootClass = clsx('flex h-full min-h-0 flex-1 flex-col', className)
   if (!turns.length && empty) {
@@ -314,11 +350,12 @@ function TurnCard({ turn, last, approvals, onOpenGraph, onFollowUp }: {
   onFollowUp?: (text: string) => void
 }) {
   const { dense } = useContext(Ctx)
-  // 报错已经在卡片顶上说了一遍（带原因、怎么办、技术细节），步骤列表末尾
-  // 那条同一句话的红行不再重复
-  const errText = typeof turn.error === 'string' ? turn.error : turn.error?.error
-  const steps = turn.phase === 'error' && errText
-    ? turn.steps.filter((s) => !(s.kind === 'error' && s.title === errText))
+  // 报错已经在卡片顶上说了一遍（带原因、怎么办、技术细节），步骤列表末尾那条运行级的
+  // 红行（run.failed）不再重复。页面拆好的报错标题是改写过的，对不上原话，所以按来源认
+  const errText = typeof turn.error === 'string' ? turn.error
+    : turn.error && 'error' in turn.error ? turn.error.error : undefined
+  const steps = turn.phase === 'error' && turn.error
+    ? turn.steps.filter((s) => !(s.kind === 'error' && (s.title === errText || s.id.startsWith('rf-'))))
     : turn.steps
   const plan = steps.filter((s) => s.stage === 'plan')
   // 「开始执行（6 个节点）」「完成」和轮次头说的是同一件事（状态、节点数、耗时），
@@ -354,7 +391,7 @@ function TurnCard({ turn, last, approvals, onOpenGraph, onFollowUp }: {
         <div className={clsx(dense ? 'px-2.5 pb-2.5' : 'px-3 pb-3')}>
           {turn.phase === 'error' && turn.error && (
             // 报错不截成一行：原因和怎么办要读得全，原文收进可展开的技术细节
-            <ErrorNotice error={turn.error} className="mt-2" />
+            <TurnError turn={turn} />
           )}
 
           {/* 还在流、但还没成为步骤的思考。解码器已经把思考并成了步骤行的话就不再
@@ -439,10 +476,14 @@ function TurnHead({ turn }: { turn: StreamTurn }) {
     : turn.phase === 'error' ? 'failed'
     : 'succeeded'
 
+  // 协作团队用完轮数、按降档交付：节点「完成」了，交出去的却是成员最后的原话
+  const teamShort = useMemo(() => !!findFirst(turn.steps, (s) =>
+    s.code === 'team_exhausted' || (!!s.team && teamVerdictOf(s.team)?.outcome === 'degraded')), [turn.steps])
   // 跑完了但复核说结论不能用：头部不能还是一个安静的「完成」
   const base = turn.status || statusLabel(turn.statusCode ?? code)
   const verdict = turn.phase === 'done' && review === 'broken' ? '结论不可用'
-    : turn.phase === 'done' && review === 'degraded' ? '有缺口' : ''
+    : turn.phase === 'done' && review === 'degraded' ? '有缺口'
+    : turn.phase === 'done' && teamShort ? '协作团队没做完' : ''
   // 复核结论说的是答案，不是运行：运行确实跑完了，徽标和「已完成」照常，红 / 琥珀只
   // 落在结论那几个字上。把完成的勾染成红色，形状说成功、颜色说失败，两头打架
   const tone = turn.tone === 'failed' ? 'var(--st-failed)'
@@ -462,8 +503,12 @@ function TurnHead({ turn }: { turn: StreamTurn }) {
   const took = turn.elapsedMs != null ? (turn.elapsedMs >= 10 ? formatDuration(turn.elapsedMs) : '')
     : doneRow?.meta ?? ''
   const elapsed = live && started != null ? Math.max(0, now - skewMs - started) : undefined
-  const queries = useMemo(() => countKind(turn.steps, 'query'), [turn.steps])
-  const tier = typeof turn.output?._issuance?.tier === 'string' ? turn.output._issuance.tier as string : ''
+  // 从库里恢复的轮次没有事件，步骤里数不出查询：用页面带过来的落库次数
+  const counted = useMemo(() => countKind(turn.steps, 'query'), [turn.steps])
+  const queries = counted || turn.queries || 0
+  // 档位优先取成果里那份（带全了核对明细），失败的运行、成果被替换过的轮次退到出具那一行
+  const tierStep = useMemo(() => findFirst(turn.steps, (s) => s.kind === 'issuance' && !!s.tier)?.tier, [turn.steps])
+  const tier = typeof turn.output?._issuance?.tier === 'string' ? turn.output._issuance.tier as string : tierStep ?? ''
 
   const tags = [
     progress.total ? `${progress.done}/${progress.total} 节点` : '',
@@ -494,10 +539,14 @@ function TurnHead({ turn }: { turn: StreamTurn }) {
           <span className="tnum min-w-0 shrink truncate text-2xs text-dim">{tags.join(' · ')}</span>
         )}
         {tier && (
-          // 出具档位也挂在吸顶的头上：往下翻到报告中段时，"这份结论能不能当真"还看得见
-          <span className="shrink-0 rounded px-1 text-2xs font-medium"
+          // 出具档位也挂在吸顶的头上：往下翻到报告中段时，"这份结论能不能当真"还看得见。
+          // 降档、不予出具带个警示形状，只靠颜色的话色弱的人读不出它和「完整出具」的差别
+          <span data-head-tier={tier}
+                className="inline-flex shrink-0 items-center gap-0.5 rounded px-1 text-2xs font-medium"
+                title={TIER_META[tier]?.hint}
                 style={{ color: TIER_META[tier]?.color ?? 'var(--st-waiting)',
                          background: TIER_META[tier]?.soft ?? 'var(--st-waiting-soft)' }}>
+            {tier !== 'formal' && <AlertTriangle size={10} aria-hidden />}
             {issuanceLabel(tier)}
           </span>
         )}
@@ -514,7 +563,9 @@ function TurnHead({ turn }: { turn: StreamTurn }) {
             {shortId(turn.runId)}
           </Link>
         )}
-        <span className="sr-only" role="status" aria-live="polite">{`${base}${verdict ? `，${verdict}` : ''}`}</span>
+        <span className="sr-only" role="status" aria-live="polite">
+          {`${base}${verdict ? `，${verdict}` : ''}${tier ? `，${issuanceLabel(tier)}` : ''}`}
+        </span>
       </div>
       {live && progress.current && (
         <div className="mt-0.5 truncate pl-[21px] text-2xs text-dim" title={progress.current.title}>
@@ -636,8 +687,8 @@ function StepSection({ label, steps, turn, defaultOpen, titled = true }: {
  * 「→ 已放行」已经说过了，而且步骤按节点归并之后它的位置也对不上真实的先后
  */
 const redundant = (s: Step): boolean =>
-  s.kind === 'lifecycle' && (s.title.startsWith('开始执行') || s.title === '完成' || s.title === '已取消'
-    || (s.title === '继续执行' && !s.sub))
+  s.kind === 'lifecycle' && (s.title.startsWith('开始执行') || s.title === '完成'
+    || ((s.title === '已取消' || s.title === '继续执行') && !s.sub))
 
 /** 这一轮一共跑了多久，给耗时细条当分母 */
 function turnMs(turn: StreamTurn): number | undefined {
@@ -685,6 +736,110 @@ function ReviewNote({ review }: { review: ReviewResult }) {
   )
 }
 
+/** 拆好的一处报错：发生了什么、为什么、怎么办、该去哪儿改、原文 */
+interface Failure {
+  title: string
+  reason?: string
+  action?: string
+  raw?: string
+  fix?: FixKind | 'rerun'
+}
+
+/** 这一轮是不是一次运行。Copilot 建图、发起就失败的，不能按运行的失败去讲（「接着跑」无从谈起） */
+const isRunTurn = (turn: StreamTurn): boolean =>
+  !!turn.runId || turn.steps.some((s) => s.stage !== 'plan')
+
+function failureOf(turn: StreamTurn): Failure | null {
+  const e = turn.error
+  if (!e) return null
+  if (typeof e === 'object' && 'title' in e) {
+    return { title: e.title, reason: e.reason, action: e.hint, raw: e.detail || undefined, fix: e.fix }
+  }
+  const text = typeof e === 'string' ? e : e.error
+  const detail = typeof e === 'string' ? undefined : e.detail
+  const hint = typeof e === 'string' ? undefined : e.hint
+  // 运行的失败和记录页、问数据页读同一份「为什么 + 怎么办」：同一次失败三处说法不一，
+  // 人就不知道该信哪句、该点哪个按钮
+  if (!hint && isRunTurn(turn)) {
+    const x = explainRunError(text, detail)
+    return { title: x.title, reason: x.reason, action: x.action, fix: x.fix,
+             raw: x.raw && x.raw !== x.title ? x.raw : undefined }
+  }
+  const h = humanizeError(hint || detail ? { error: text, hint, detail } : text)
+  return { title: h.title, reason: h.reason, action: h.action, raw: h.raw && h.raw !== h.title ? h.raw : undefined }
+}
+
+/**
+ * 下一步的直达入口。要去画布上改的，编排页能直接打开那个节点的设置；别处只说该去哪儿，
+ * 不装作能点。「接着跑」「重新运行」由页面自己放（renderTurnActions），这里不给
+ */
+function FixAction({ fix, nodeId, label }: { fix?: FixKind | 'rerun'; nodeId?: string; label?: string }) {
+  const { onOpen } = useContext(Ctx)
+  const cls = 'inline-flex shrink-0 items-center gap-1 rounded px-1 text-2xs text-[var(--accent)] underline-offset-2 transition-colors hover:bg-hover hover:underline'
+  if (fix === 'canvas' && nodeId && onOpen) {
+    return (
+      <button type="button" className={cls} data-fix="canvas" onClick={() => onOpen(nodeId)}>
+        <Settings2 size={10} aria-hidden /> 打开{label ? `「${label}」的` : ''}设置
+      </button>
+    )
+  }
+  if (fix === 'settings') {
+    return <Link to="/settings/providers" className={cls} data-fix="settings"><Settings2 size={10} aria-hidden /> 去模型接入</Link>
+  }
+  if (fix === 'tools') {
+    return <Link to="/tools" className={cls} data-fix="tools"><Wrench size={10} aria-hidden /> 去工具库</Link>
+  }
+  return null
+}
+
+/**
+ * 轮次级的报错。样子和 ErrorState 的 compact 版一致，但先把话讲清再画：运行的失败走
+ * lib/explain（模型没真调工具、团队轮数用完这类，给的是「去画布改」而不是「接着跑」），
+ * 页面拆好的照原样，其余交给 humanizeError。出错的是哪个节点也写在这里，点一下画布取景
+ */
+function TurnError({ turn }: { turn: StreamTurn }) {
+  const { onFocus } = useContext(Ctx)
+  const f = useMemo(() => failureOf(turn), [turn])
+  if (!f) return null
+  // run.failed 那一行定位得到节点就用它（它在流里已经不单列了），否则第一个失败的节点
+  const rf = findFirst(turn.steps, (s) => s.kind === 'error' && s.id.startsWith('rf-') && !!s.nodeId)
+  const node = findFirst(turn.steps, (s) => s.kind === 'node' && s.status === 'failed' && !!s.nodeId)
+  const whereId = rf?.nodeId ?? node?.nodeId
+  const whereLabel = rf?.sub?.replace(/^出错的节点：/, '') || node?.title
+  return (
+    <div role="alert" data-turn-error=""
+         className="mt-2 flex items-start gap-2 rounded-lg border px-3 py-2 text-xs"
+         style={{ borderColor: 'color-mix(in srgb, var(--st-failed) 35%, var(--border))',
+                  background: 'color-mix(in srgb, var(--st-failed) 6%, transparent)' }}>
+      <AlertCircle size={14} className="mt-0.5 shrink-0" style={{ color: 'var(--st-failed)' }} aria-hidden />
+      <div className="min-w-0 flex-1">
+        <div className="font-medium text-fg [overflow-wrap:anywhere]">{f.title}</div>
+        {whereId && whereLabel && (
+          onFocus
+            ? (
+              <button type="button" className="mt-0.5 text-2xs text-dim underline-offset-2 hover:text-fg hover:underline"
+                      title="在画布上定位这个节点" onClick={() => onFocus(whereId)}>
+                出错的节点：「{whereLabel}」
+              </button>
+            )
+            : <div className="mt-0.5 text-2xs text-dim">出错的节点：「{whereLabel}」</div>
+        )}
+        {f.reason && <div className="mt-0.5 leading-relaxed text-dim [overflow-wrap:anywhere]">{f.reason}</div>}
+        {f.action && (
+          <div className="mt-0.5 flex items-start gap-1 leading-relaxed text-dim">
+            <CornerDownRight size={11} className="mt-[3px] shrink-0" aria-hidden />
+            <span className="min-w-0 flex-1 [overflow-wrap:anywhere]">{f.action}</span>
+          </div>
+        )}
+        <div className="flex flex-wrap items-center gap-x-2">
+          <FixAction fix={f.fix} nodeId={whereId} label={whereLabel} />
+        </div>
+        {f.raw && <div className="mt-1"><TechDetails raw={f.raw} /></div>}
+      </div>
+    </div>
+  )
+}
+
 /** 思考的尾窗：只露最后几行并跟着滚，不然一大坨会把步骤挤到屏幕外。 */
 function ThinkingTail({ text }: { text: string }) {
   const ref = useRef<HTMLDivElement>(null)
@@ -780,6 +935,11 @@ function StepLine({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
   const expandable = !!(step.detail || result || step.raw || step.artifact)
   const table = result ? parseQueryResult(result) : null
   const status = step.status ?? 'done'
+  // 失败的节点：收着的时候就说为什么（和轮次顶上的报错同一份 lib/explain），展开再看原因、
+  // 怎么办和原话。以前这一行只有节点名和一个红叉，得点开才知道是没绑工具还是超时
+  const explained = useMemo(() => (step.kind === 'node' && status === 'failed' && step.detail
+    ? explainRunError(step.detail, step.raw) : null), [step.kind, status, step.detail, step.raw])
+  const sub = step.sub ?? explained?.title
 
   // 失败要压过 kind：一条 lifecycle 跑挂了还画成打勾的"完成"图标，是把失败说成了成功
   const failed = status === 'failed' || step.level === 'error'
@@ -818,6 +978,7 @@ function StepLine({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
       style={running && reduced ? { borderColor: 'var(--st-running)' } : undefined}
       data-node-id={step.nodeId}
       data-step-status={failed ? 'failed' : status}
+      data-step-code={step.code}
       aria-busy={running || undefined}
     >
       <button
@@ -845,9 +1006,14 @@ function StepLine({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
             running && !reduced && !step.children?.length && 'shimmer')}>
             {step.title}
           </span>
-          {step.sub && (
-            <span className="block truncate text-2xs italic leading-snug text-faint" title={step.sub}>
-              {step.sub}
+          {sub && (
+            // 副标题平时是淡色斜体的旁白（这次调用前在想什么、为什么跳过）；出了事的行
+            // 它说的是为什么，用正体、跟着行的颜色，别让最要紧的那句成了最淡的字
+            <span className={clsx('block truncate text-2xs leading-snug',
+                    failed || step.level === 'warn' ? 'not-italic' : 'italic text-faint')}
+                  style={failed ? { color: 'var(--st-failed)' } : step.level === 'warn' ? { color: 'var(--text-dim)' } : undefined}
+                  title={sub}>
+              {sub}
             </span>
           )}
         </span>
@@ -858,7 +1024,18 @@ function StepLine({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
         )}
       </button>
 
-      {open && <StepDetail step={step} table={table} />}
+      {step.next && (
+        // 下一步不收进展开区：模型没真调工具、团队轮数用完这种，人要的就是这一句
+        <div data-step-next="" className="flex flex-wrap items-start gap-x-1.5 pl-[18px] text-2xs leading-snug text-dim">
+          <span className="flex min-w-0 flex-1 items-start gap-1">
+            <CornerDownRight size={10} className="mt-[2px] shrink-0" aria-hidden />
+            <span className="min-w-0 [overflow-wrap:anywhere]">{step.next}</span>
+          </span>
+          <FixAction fix={step.fix} nodeId={step.nodeId} />
+        </div>
+      )}
+
+      {open && <StepDetail step={step} table={table} explained={explained} />}
 
       {/* 泳道排在子步骤**前面**：先给一眼看清的形状（谁做了哪几轮、哪些是
           同时进行的、各花多久），再往下是每一步的内容。反过来的话，得把
@@ -908,7 +1085,7 @@ function StepMeta({ step, depth, turnMs }: { step: Step; depth: number; turnMs?:
       )}
       {/* 「开始执行」那一行的秒表和轮次头部的是同一个数，不重复 */}
       {running && step.startedAt != null && step.kind !== 'lifecycle'
-        ? <LiveClock since={step.startedAt} label={reduced ? '进行中' : undefined} />
+        ? <LiveClock since={step.startedAt} label={reduced ? '进行中' : undefined} limitS={step.limitS} />
         : (step.meta || STOPPED[step.status ?? '']) && !(running && step.startedAt != null) && (
           <span className={clsx('tnum mt-[1px] shrink-0 text-dim', dense ? 'text-[10px]' : 'text-2xs',
             step.meta && 'mono')}>
@@ -926,15 +1103,21 @@ const STOPPED: Record<string, string> = {
   suspended: statusLabel('suspended', { short: true }),
 }
 
-/** 进行中那一行的秒表。只有它订阅时钟，其余行不会跟着每 100ms 重画 */
-function LiveClock({ since, label }: { since: number; label?: string }) {
+/**
+ * 进行中那一行的秒表。只有它订阅时钟，其余行不会跟着每 100ms 重画。
+ * 带时限的工具越过上限就换成提醒色、说破「已超出」：引擎马上会放弃等待，秒表一声
+ * 不吭地接着走，看着像还有指望
+ */
+function LiveClock({ since, label, limitS }: { since: number; label?: string; limitS?: number }) {
   const { dense, skewMs } = useContext(Ctx)
   const now = useRunClock(true)
   const ms = Math.max(0, now - skewMs - since)
+  const over = limitS != null && ms > limitS * 1000
   return (
     <span className={clsx('mono tnum mt-[1px] shrink-0', dense ? 'text-[10px]' : 'text-2xs')}
-          style={{ color: 'var(--st-running)' }}>
-      {label ? `${label} · ` : ''}{formatClock(ms)}
+          style={{ color: over ? 'var(--st-waiting)' : 'var(--st-running)' }}
+          {...(over ? { 'data-over-limit': '', title: `这一步的时限是 ${formatNumber(limitS!)} s，到点会放弃等待` } : {})}>
+      {over ? `已超出 ${formatNumber(limitS!)} s 上限 · ` : label ? `${label} · ` : ''}{formatClock(ms)}
     </span>
   )
 }
@@ -1126,13 +1309,31 @@ function ExecGroups({ step, turnMs }: { step: Step; turnMs?: number }) {
 }
 
 /** 展开区：跑的是什么（SQL、代码、参数）+ 跑出了什么 + 技术细节 + 完整证据 */
-function StepDetail({ step, table }: { step: Step; table: Table | null }) {
+function StepDetail({ step, table, explained }: {
+  step: Step; table: Table | null
+  /** 失败节点按 lib/explain 讲的为什么、怎么办 */
+  explained?: { reason?: string; action?: string; fix?: FixKind | 'rerun' } | null
+}) {
   const { openArtifact, dense } = useContext(Ctx)
   const pre = clsx('mono max-h-40 overflow-auto whitespace-pre-wrap rounded bg-bg px-2 py-1.5 leading-relaxed text-dim [overflow-wrap:anywhere]',
     dense ? 'text-[10.5px]' : 'text-2xs')
   const result = step.result
   return (
     <div className="mb-1 mt-1 space-y-1.5 pl-[18px]">
+      {explained && (explained.reason || explained.action) && (
+        <div className="space-y-0.5 text-2xs leading-relaxed text-dim" data-step-explain="">
+          {explained.reason && <div className="[overflow-wrap:anywhere]">{explained.reason}</div>}
+          {explained.action && (
+            <div className="flex flex-wrap items-start gap-x-1.5">
+              <span className="flex min-w-0 flex-1 items-start gap-1">
+                <CornerDownRight size={10} className="mt-[3px] shrink-0" aria-hidden />
+                <span className="min-w-0 [overflow-wrap:anywhere]">{explained.action}</span>
+              </span>
+              <FixAction fix={explained.fix} nodeId={step.nodeId} label={step.title} />
+            </div>
+          )}
+        </div>
+      )}
       {step.detail && (
         <div className="group/detail relative">
           {step.kind === 'query' && (
@@ -1211,12 +1412,29 @@ function TeamLanes({ team }: { team: TeamRun }) {
   const slowest = Math.max(1, ...team.rounds.flatMap((r) => r.members.map((m) => m.ms)))
   const parallelRounds = team.rounds.filter((r) => r.parallel > 1).length
   const liveRound = [...team.rounds].reverse().find((r) => r.members.some((m) => m.status === 'running'))
+  const verdict = teamVerdictOf(team)
+  // 一次都没派到的成员也占一行：团队「没做完」时，最该被看见的往往就是那个从没上过场的
+  const never = (verdict?.never ?? []).filter((n) => !team.members.includes(n))
+  const rounds = verdict?.rounds ?? team.rounds.length
+  const ending = verdict?.outcome === 'failed'
+    ? { text: `用完 ${rounds} 轮仍未完成`, color: 'var(--st-failed)' }
+    : verdict?.outcome === 'degraded'
+      ? { text: `用完 ${rounds} 轮仍未完成 · 按降档交付`, color: 'var(--st-waiting)' }
+    : verdict?.closing && verdict.done
+      ? { text: '轮数用完 · 调度者判定：已完成', color: 'var(--text-dim)' }
+    : verdict?.closing && verdict.done === false
+      ? { text: '轮数用完 · 调度者判定：未完成', color: 'var(--st-waiting)' }
+    // 还在判定。运行在这时停了（取消、失败）团队会被收成 finished，就不再说「在判定」
+    : verdict?.closing && !team.finished
+      ? { text: '轮数用完 · 调度者在判定…', color: 'var(--st-running)' }
+    : null
+  const laneLabel = clsx('shrink-0 truncate text-2xs text-dim', dense ? 'w-14' : 'w-20')
 
   return (
-    <div className="mt-2 rounded-lg border bg-bg p-2">
+    <div className="mt-2 rounded-lg border bg-bg p-2" data-team-lanes="">
       <div className="mb-2 flex flex-wrap items-center gap-x-2.5 gap-y-1 text-2xs text-dim">
         <span className="flex items-center gap-1">
-          <Users size={11} aria-hidden /> {team.members.length} 名成员 · {team.rounds.length} 轮
+          <Users size={11} aria-hidden /> {team.members.length + never.length} 名成员 · {team.rounds.length} 轮
         </span>
         {liveRound && (
           <span style={{ color: 'var(--st-running)' }}>
@@ -1228,11 +1446,22 @@ function TeamLanes({ team }: { team: TeamRun }) {
             并行省下 {formatDuration(team.savedMs)}（{parallelRounds} 轮并行）
           </span>
         )}
-        {parallelRounds === 0 && team.finished && (
+        {parallelRounds === 0 && team.finished && !verdict?.outcome && (
           // 全程串行不是故障，但值得说一句——任务本来就互相依赖时它就该是串行的
           <span title="调度者每轮只派了一个人：后一步依赖前一步的结论">全程串行</span>
         )}
       </div>
+      {ending && (
+        // 怎么收的尾单独一行：只说「3 轮」的话，调度者说完成了和轮数用完硬停长得一样
+        <div className="-mt-1 mb-2 flex items-start gap-1 text-2xs font-medium leading-snug" style={{ color: ending.color }}
+             data-team-ending={verdict?.outcome ?? (verdict?.done ? 'done' : verdict?.done === false ? 'undone' : 'judging')}>
+          {verdict?.outcome && <AlertTriangle size={11} className="mt-[1px] shrink-0" aria-hidden />}
+          <span className="min-w-0 [overflow-wrap:anywhere]">
+            {ending.text}
+            {verdict?.reason && <span className="font-normal text-dim">：{verdict.reason}</span>}
+          </span>
+        </div>
+      )}
 
       <div className="space-y-1">
         {team.members.map((name) => (
@@ -1253,7 +1482,8 @@ function TeamLanes({ team }: { team: TeamRun }) {
                   : running ? 'var(--st-running)'
                   : 'var(--text-faint)'
                 const hatched = running || stopped
-                const said = running ? '进行中' : stopped ? statusLabel(m!.status, { short: true }) : formatDuration(m?.ms)
+                const said = running ? '进行中' : stopped ? statusLabel(m!.status, { short: true })
+                  : m?.status === 'failed' ? `失败 · ${formatDuration(m.ms)}` : formatDuration(m?.ms)
                 return (
                   <div key={r.round} className="min-w-0 flex-1 rounded-sm" style={{ background: 'var(--bg-hover)' }}>
                     {m ? (
@@ -1280,6 +1510,19 @@ function TeamLanes({ team }: { team: TeamRun }) {
           </div>
         ))}
 
+        {never.map((name) => (
+          <div key={`never-${name}`} className="flex items-center gap-1.5" data-never-dispatched={name}>
+            <div className={clsx(laneLabel, 'text-faint line-through decoration-dotted')} title={`${name}：一次都没被派到`}>
+              {name}
+            </div>
+            <div className="flex h-4 min-w-0 flex-1 items-center gap-1 rounded-sm border border-dashed px-1.5 text-2xs text-dim"
+                 style={{ borderColor: 'var(--border-strong, var(--border))' }}>
+              <UserX size={10} aria-hidden className="shrink-0" />
+              <span className="truncate">没派到：{rounds} 轮里调度者一次都没派给它</span>
+            </div>
+          </div>
+        ))}
+
         <div className="flex items-center gap-1.5 pt-0.5">
           <div className={clsx('shrink-0', dense ? 'w-14' : 'w-20')} />
           <div className="flex min-w-0 flex-1 gap-1">
@@ -1304,18 +1547,22 @@ function TeamLanes({ team }: { team: TeamRun }) {
       {openKey && (() => {
         const [rd, name] = openKey.split(':')
         const m = team.rounds.find((r) => String(r.round) === rd)
-          ?.members.find((x) => x.agent === name)
+          ?.members.find((x) => x.agent === name) as TeamMemberEx | undefined
         if (!m) return null
         return (
           <div className="mt-2 rounded border bg-panel p-2 text-2xs leading-relaxed">
             <div className="mb-1 text-dim">
               {name} · 第 {Number(rd) + 1} 轮 · {m.status === 'running' ? '进行中'
                 : m.status === 'cancelled' || m.status === 'suspended' ? statusLabel(m.status, { short: true })
+                : m.status === 'failed' ? `失败 · ${formatDuration(m.ms)}`
                 : formatDuration(m.ms)}
             </div>
             {m.instruction && (
               <div className="mb-1.5 text-dim">任务：{m.instruction}</div>
             )}
+            {m.error && (
+              <div className="mb-1.5 [overflow-wrap:anywhere]" style={{ color: 'var(--st-failed)' }}>为什么失败：{m.error}</div>
+            )}
             {m.result && (
               <pre className="mono max-h-36 overflow-auto whitespace-pre-wrap text-dim">
                 {m.result.slice(0, 1200)}
@@ -1815,9 +2062,19 @@ export function IssuanceBanner({ issuance, runClass }: {
   const gaps: string[] = Array.isArray(issuance?.gaps) ? issuance.gaps.map(String) : []
   const calibers: any[] = issuance?.calibers ?? []
   const matched = Number(issuance?.matched_numbers ?? 0)
+  // 逐个数字的出处（matched[].caliber 形如「口径名 @ v2」）：有它就能按卡数清楚，
+  // 不必只在「只有一张卡」时才敢说数字来自哪
+  const perCaliber = new Map<string, number>()
+  for (const m of Array.isArray(issuance?.matched) ? issuance.matched : []) {
+    if (m?.caliber) perCaliber.set(String(m.caliber), (perCaliber.get(String(m.caliber)) ?? 0) + 1)
+  }
+  const hitsOf = (c: any): number | undefined =>
+    perCaliber.get([c?.caliber, c?.version].filter(Boolean).join(' @ '))
 
   return (
-    <div className="rounded-lg border p-2" style={{ borderColor: meta.color }}>
+    // data-issuance-banner：画布上成果节点的出具印章据此滚过来；tabIndex 让「去看出具」能把焦点带到这里
+    <div className="scroll-mt-14 rounded-lg border p-2 outline-none data-[flash]:outline data-[flash]:outline-2 data-[flash]:outline-offset-1 data-[flash=focus]:outline-[color:var(--accent)]"
+         style={{ borderColor: meta.color }} data-issuance-banner={tier} tabIndex={-1}>
       <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
         <span className="rounded px-1.5 py-px text-xs font-semibold" style={{ color: meta.color, background: meta.soft }}>
           ⚖ {issuanceLabel(tier)}
@@ -1864,15 +2121,18 @@ export function IssuanceBanner({ issuance, runClass }: {
         // 数字回指到哪张口径卡。后端目前只给「回指了几个」，没给逐个数字对哪张卡；
         // 只有一张卡时，回指上的数字必然来自它，可以直说
         <div className="mt-1.5 space-y-0.5 border-t pt-1.5 text-2xs text-dim">
-          {calibers.map((c: any) => (
-            <div key={c.node ?? c.caliber} className="flex items-center gap-1.5">
-              <FileCode size={10} aria-hidden className="shrink-0" />
-              <span>口径卡「{c.caliber}」<span className="mono">{c.version}</span></span>
-              {calibers.length === 1 && matched > 0 && (
-                <span style={{ color: 'var(--st-done)' }}>· 回指上的 {matched} 个数字都来自这张卡</span>
-              )}
-            </div>
-          ))}
+          {calibers.map((c: any) => {
+            const hits = hitsOf(c)
+            return (
+              <div key={c.node ?? c.caliber} className="flex items-center gap-1.5">
+                <FileCode size={10} aria-hidden className="shrink-0" />
+                <span>口径卡「{c.caliber}」<span className="mono">{c.version}</span></span>
+                {calibers.length === 1 && matched > 0 && (hits == null || hits === matched)
+                  ? <span style={{ color: 'var(--st-done)' }}>· 回指上的 {matched} 个数字都来自这张卡</span>
+                  : hits != null && <span className="tnum" style={{ color: 'var(--st-done)' }}>· 回指 {hits} 个数字</span>}
+              </div>
+            )
+          })}
         </div>
       )}
     </div>
diff --git a/frontend/src/run/Composer.tsx b/frontend/src/run/Composer.tsx
index 34782a72..02e3b5cb 100644
--- a/frontend/src/run/Composer.tsx
+++ b/frontend/src/run/Composer.tsx
@@ -1,10 +1,11 @@
-import { useEffect, useRef, useState, type ReactNode, type RefObject } from 'react'
-import { ArrowUp, Database, Settings2, Sparkles, Square, Wrench } from 'lucide-react'
+import { useEffect, useRef, useState, type CSSProperties, type ReactNode, type RefObject } from 'react'
+import { AlertCircle, ArrowUp, CornerDownRight, Database, Settings2, Sparkles, Square, Wrench } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../api/client'
 import { useCatalog, modelOptions } from '../store/catalog'
 import { useStudio } from '../store/studio'
-import { isComposing, Spinner } from '../components/ui'
+import { isComposing, Spinner, TechDetails, useRadioGroup } from '../components/ui'
+import { formatShortcut } from '../lib/keys'
 
 /**
  * Copilot 的输入。
@@ -69,7 +70,11 @@ export function Composer({ hero, onFocusChange }: {
     if (!q || copilot.active) return
     runCopilot(q, useBase && nodes.length > 0, model || undefined)
     setText('')
+    // 从头生成是一次性的：新图一落到画布上，下一句多半是在它上面改。停在「从头生成」
+    // 的话，下一句又把刚生成的图整张换掉（撤销找得回，但人得先发现）
+    setUseBase(true)
   }
+  const mode = useRadioGroup(MODES, useBase ? 'base' : 'fresh', (m) => setUseBase(m === 'base'))
 
   const options = modelOptions(providers)
   const groups = [...new Set(options.map((o) => o.group))]
@@ -79,14 +84,29 @@ export function Composer({ hero, onFocusChange }: {
     <div className={clsx('shrink-0', hero ? 'px-4' : 'border-t px-2.5 pb-2.5 pt-2')}>
       {hero && <HeroHeader sources={sources} toolCount={tools?.length ?? 0} />}
 
-      {copilot.error && (
-        <div role="alert" className="fade-up mb-2 flex items-center gap-2 rounded-lg border px-2.5 py-1.5 text-[10.5px]"
-             style={{ borderColor: 'var(--err)', color: 'var(--err)' }}>
-          <span className="min-w-0 flex-1 leading-relaxed">{copilot.error}</span>
+      {/* 说过话之后，出错的那一轮在上面的流里自己有报错块（怎么办、原文、「用同一句话
+          重试」都在），这里再摆一条就是同一句话说两遍。只有还没有轮次可挂的时候才由它说。
+          样子和流里的报错块一致：发生了什么、怎么办分开写，原文折进技术细节 */}
+      {copilot.error && hero && (
+        <div role="alert" data-copilot-error=""
+             className="fade-up mb-2 flex items-start gap-2 rounded-lg border px-2.5 py-1.5 text-2xs"
+             style={{ borderColor: 'color-mix(in srgb, var(--st-failed) 35%, var(--border))',
+                      background: 'color-mix(in srgb, var(--st-failed) 6%, transparent)' }}>
+          <AlertCircle size={12} className="mt-px shrink-0" style={{ color: 'var(--st-failed)' }} aria-hidden />
+          <div className="min-w-0 flex-1 leading-relaxed">
+            <div className="font-medium text-fg [overflow-wrap:anywhere]">{copilot.error}</div>
+            {copilot.errorHint && (
+              <div className="mt-0.5 flex items-start gap-1 text-dim">
+                <CornerDownRight size={10} className="mt-[3px] shrink-0" aria-hidden />
+                <span className="min-w-0 flex-1 [overflow-wrap:anywhere]">{copilot.errorHint}</span>
+              </div>
+            )}
+            {copilot.errorDetail && <TechDetails raw={copilot.errorDetail} className="mt-1" />}
+          </div>
           {/* 失败多半跟需求本身无关（模型抽风、协议跑偏、网断了），
               不该逼用户把需求再敲一遍 */}
           {copilot.lastInstruction && (
-            <button className="btn btn-sm shrink-0" onClick={retryCopilot}>重试</button>
+            <button className="btn btn-xs shrink-0" onClick={retryCopilot}>重试</button>
           )}
         </div>
       )}
@@ -111,22 +131,29 @@ export function Composer({ hero, onFocusChange }: {
             <button
               className={clsx('rounded-md p-1.5 transition-colors hover:bg-hover',
                 opts ? 'text-[var(--accent)]' : 'text-faint')}
-              title="模型和生成方式"
-              aria-label="模型和生成方式"
+              title="助手用哪个模型"
+              aria-label="助手用哪个模型"
               aria-expanded={opts}
               onClick={() => setOpts((v) => !v)}
             >
               <Settings2 size={13} />
             </button>
+            {/* 两种方式并排摆出来，选中的那个就是这一句会怎么做。以前是一个 10px 的字，
+                点一下就翻成另一个词，看不出它是开关，更看不出另一头是什么。从头生成
+                不再二次确认：整轮是一步撤销，失败、停止、只回一句话都会把画布放回原样 */}
             {!!nodes.length && (
-              <button
-                className={clsx('rounded-md px-1.5 py-1 text-[10px] transition-colors hover:bg-hover',
-                  useBase ? 'text-dim' : 'text-faint')}
-                title={useBase ? '在当前这张图上改' : '不看现有的图，重新生成一张'}
-                onClick={() => setUseBase((v) => !v)}
-              >
-                {useBase ? '改现有的图' : '重新生成'}
-              </button>
+              <span role="radiogroup" aria-label="生成方式" className="inline-flex rounded-md border p-px">
+                {MODES.map((m) => (
+                  <button key={m} type="button" {...mode(m)}
+                          className={clsx('rounded px-1.5 text-2xs leading-5 transition-colors',
+                            (m === 'base') === useBase ? 'bg-accent-soft text-fg' : 'text-faint hover:text-dim')}
+                          title={m === 'base' ? '把现在这张图交给助手，在它上面改'
+                            : `不看现有的图，整张重新生成。原图可以撤销（${formatShortcut('Mod+Z')}）找回`}
+                          onClick={() => setUseBase(m === 'base')}>
+                    {m === 'base' ? '在现有图上改' : '从头生成'}
+                  </button>
+                ))}
+              </span>
             )}
           </>
         }
@@ -135,8 +162,8 @@ export function Composer({ hero, onFocusChange }: {
       {opts && (
         <div className="fade-up mt-2 space-y-2 rounded-lg border bg-panel p-2.5">
           <div>
-            <label className="label">Copilot 用哪个模型</label>
-            <select className="field" value={model} onChange={(e) => pickModel(e.target.value)}>
+            <label className="label" htmlFor="copilot-model">助手用哪个模型</label>
+            <select id="copilot-model" className="field" value={model} onChange={(e) => pickModel(e.target.value)}>
               <option value="">跟随默认{effective ? `（当前：${effective}）` : ''}</option>
               {groups.map((g) => (
                 <optgroup key={g} label={g}>
@@ -146,8 +173,8 @@ export function Composer({ hero, onFocusChange }: {
                 </optgroup>
               ))}
             </select>
-            <div className="mt-1 text-[10px] leading-snug text-faint">
-              只影响 Copilot 自己，不改节点上的模型。它要按协议逐行输出操作，
+            <div className="mt-1 text-2xs leading-snug text-faint">
+              只影响助手自己，不改节点上的模型。它要按协议逐行输出操作，
               指令遵循弱的模型生成不出东西。
             </div>
           </div>
@@ -155,7 +182,7 @@ export function Composer({ hero, onFocusChange }: {
       )}
 
       {copilot.active && (
-        <div className="fade-up mt-2 flex items-center gap-1.5 text-[10px] text-faint">
+        <div className="fade-up mt-2 flex items-center gap-1.5 text-2xs text-faint">
           <Spinner size={10} />
           <span className="min-w-0 flex-1 truncate">
             {copilot.lastOp || PHASE_TEXT[copilot.phase] || '正在起草…'}
@@ -173,7 +200,7 @@ export function Composer({ hero, onFocusChange }: {
             <button
               key={ex}
               className="rise-in w-full rounded-lg border bg-panel px-3 py-2 text-left text-[11.5px] leading-relaxed text-dim transition-colors hover:border-[var(--accent)] hover:text-fg"
-              style={{ '--i': i + 1 } as any}
+              style={{ '--i': i + 1 } as CSSProperties}
               onClick={() => send(ex)}
             >
               {ex}
@@ -313,7 +340,7 @@ function HeroHeader({ sources, toolCount }: { sources: any[]; toolCount: number
       <div className="mt-1 text-2xs leading-relaxed text-faint">
         说一句话，它把流程画到左边的画布上
       </div>
-      <div className="mt-2 flex items-center justify-center gap-3 text-[10px] text-faint">
+      <div className="mt-2 flex items-center justify-center gap-3 text-2xs text-faint">
         <span className="flex items-center gap-1">
           <Database size={10} />
           {sources.length ? `${sources.length} 个数据源` : '未接数据源'}
@@ -350,6 +377,8 @@ function exampleFor(nodeCount: number, sources: any[]): string[] {
   ]
 }
 
+const MODES = ['base', 'fresh'] as const
+
 // 从提交到第一个节点落地中间有 5~30 秒。阶段会变本身就是"它还活着"的信号，
 // 恒定的"正在起草…"让人分不清是在想还是已经卡死
 export const PHASE_TEXT: Record<string, string> = {
diff --git a/frontend/src/run/RunControl.tsx b/frontend/src/run/RunControl.tsx
index 4d33930f..15932e22 100644
--- a/frontend/src/run/RunControl.tsx
+++ b/frontend/src/run/RunControl.tsx
@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useRef, useState } from 'react'
-import { ChevronDown, Play, ShieldCheck } from 'lucide-react'
+import { ChevronDown, Play } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../api/client'
 import { isComposing, Kbd, Skeleton, Spinner, toast } from '../components/ui'
@@ -8,7 +8,7 @@ import { matchShortcut } from '../lib/keys'
 import { runClassLabel } from '../lib/terms'
 import { useStudio } from '../store/studio'
 import type { WorkflowVersion } from '../types'
-import { escapeRun, RunCapsule } from './RunHud'
+import { ClassDot, escapeRun, RunCapsule } from './RunHud'
 import { isActivePhase } from './trace'
 
 /**
@@ -177,7 +177,7 @@ function ExploreLauncher({ tight }: { tight: boolean }) {
       {open && (
         <div className="sf-pop sheet-in" role="dialog" aria-label={runClassLabel('exploratory')} data-esc-layer>
           <div className="sf-pop-head">
-            <Play size={11} fill="currentColor" className="text-[var(--accent)]" />
+            <ClassDot formal={false} />
             <span>{runClassLabel('exploratory')}</span>
             <span className="sf-dim">· 用画布当前内容，结果不归档</span>
           </div>
@@ -262,8 +262,9 @@ function FormalLauncher({ workflowId, version }: { workflowId: string; version:
         title={`从已发布的 v${version} 发起${runClassLabel('formal')}，结果归档、可审计${ahead ? '。不含画布上的改动' : ''}`}
         onClick={() => setOpen((v) => !v)}
       >
-        {busy ? <Spinner size={11} /> : <ShieldCheck size={12} />}
-        {/* 窄屏上工具栏放不下全名：留盾牌和版本号，全名在 aria-label 和 title 里 */}
+        {/* 实心圆点是正式运行的记号（探索运行空心）；盾牌只留给发布等级，不再两处混用 */}
+        {busy ? <Spinner size={11} /> : <ClassDot formal />}
+        {/* 窄屏上工具栏放不下全名：留圆点和版本号，全名在 aria-label 和 title 里 */}
         <span aria-hidden><span className="hidden xl:inline">{runClassLabel('formal')} </span>v{version}</span>
         <ChevronDown size={10} className="hidden opacity-60 transition-transform xl:block"
                      style={{ transform: open ? 'rotate(180deg)' : 'none' }} />
@@ -272,7 +273,7 @@ function FormalLauncher({ workflowId, version }: { workflowId: string; version:
       {open && (
         <div className="sf-pop sheet-in" role="dialog" aria-label={label} data-esc-layer>
           <div className="sf-pop-head">
-            <ShieldCheck size={12} />
+            <ClassDot formal />
             <span>{label}</span>
             <span className="sf-dim">· 已发布的不可变版本，结果归档</span>
           </div>
@@ -298,7 +299,7 @@ function FormalLauncher({ workflowId, version }: { workflowId: string; version:
           )}
           <button type="button" className="btn w-full justify-center sf-formal-go"
                   disabled={busy || fields == null} onClick={() => void launch()}>
-            {busy ? <Spinner size={11} /> : <ShieldCheck size={12} />} {label}
+            {busy ? <Spinner size={11} /> : <ClassDot formal />} {label}
           </button>
           {!!fields?.length && (
             <div className="mt-1.5 flex items-center gap-1 text-2xs text-faint">
diff --git a/frontend/src/run/RunHud.tsx b/frontend/src/run/RunHud.tsx
index e40cc46a..82c20dbc 100644
--- a/frontend/src/run/RunHud.tsx
+++ b/frontend/src/run/RunHud.tsx
@@ -1,16 +1,17 @@
 import { useEffect, useMemo, useRef, useState, type ButtonHTMLAttributes, type ReactNode } from 'react'
 import {
-  ChevronDown, Crosshair, Eraser, Hand, History, LocateFixed, Radio, RotateCw, Square,
+  Ban, ChevronDown, Crosshair, Eraser, Hand, History, LocateFixed, Radio, RotateCw, Square,
 } from 'lucide-react'
 import clsx from 'clsx'
 import { api } from '../api/client'
-import { Kbd, Spinner, StatusBadge, toast } from '../components/ui'
+import { confirmDialog, Kbd, Spinner, StatusBadge, toast } from '../components/ui'
 import { formatClock, formatCost, formatDuration, formatTokens, NONE } from '../lib/format'
 import { isTypingTarget, matchShortcut } from '../lib/keys'
 import { statusMeta, STATUS, type StatusCode } from '../lib/status'
 import { issuanceLabel, runClassLabel } from '../lib/terms'
 import { lastStampOf, projectSettled, useDock, waitedMs } from '../canvas/RunTimeline'
 import { structureSig, useStudio } from '../store/studio'
+import type { RunEvent } from '../types'
 import { topology } from './derive'
 import {
   isActivePhase, isSettled, isTerminal, liveAt, project, type NodeState, type RunPhase, type Trace,
@@ -29,7 +30,8 @@ import { useRunClock } from './useRunClock'
  *   走不到，循环会让同一节点跑好几遍，百分比要么停在 6/8 要么超过 100%）。
  * - 正常态安静：运行中只有一圈转动的徽标；等人、失败、挂起才上底色。
  * - 主动作随相位变：在跑能停止，等人去审批，失败定位 + 接着跑，结束了回放 + 清除。
- *   等审批时后端已经不在执行，停止必然 409，所以那时不给停止。
+ *   等审批时后端已经不在执行，没有「停止」可言；次级动作是「放弃这次运行」——后端把
+ *   停在审批上的运行直接收成已取消，待审批一并关闭。
  */
 
 // -------------------------------------------------------------------------
@@ -103,8 +105,31 @@ export function phaseLabel(phase: RunPhase): string {
   return statusMeta(phase).label
 }
 
+/**
+ * 这次运行是怎么取消的：run.cancelled 带着谁放弃的（actor）和一句说明（放弃等审批、
+ * 挂起的运行时才有，如「放弃了这次运行，1 条待审批一并关闭」）。按事件数组缓存
+ */
+const cancelCache = new WeakMap<RunEvent[], string>()
+function cancelNote(events: RunEvent[]): string {
+  const hit = cancelCache.get(events)
+  if (hit != null) return hit
+  let note = ''
+  for (let i = events.length - 1; i >= 0; i -= 1) {
+    const e = events[i]
+    if (!String(e.type).startsWith('run.')) continue
+    if (e.type === 'run.cancelled') {
+      const who = typeof e.data?.actor === 'string' ? e.data.actor.trim() : ''
+      const what = typeof e.data?.message === 'string' ? e.data.message.trim() : ''
+      note = what ? `${who ? `${who} ` : ''}${what}` : who ? `${who} 取消了这次运行` : ''
+    }
+    break
+  }
+  cancelCache.set(events, note)
+  return note
+}
+
 function headlineOf(t: Trace, phase: RunPhase, states: Record<string, NodeState>, at: number,
-                    label: (id: string) => string, errorText: string | null | undefined): string {
+                    label: (id: string) => string, errorText: string | null | undefined, cancelled = ''): string {
   const running = Object.keys(states).filter((id) => states[id] === 'running')
   switch (phase) {
     case 'queued':
@@ -139,7 +164,8 @@ function headlineOf(t: Trace, phase: RunPhase, states: Record<string, NodeState>
       return t.issuance?.tier ? `执行完成 · ${issuanceLabel(t.issuance.tier)}` : '执行完成'
     case 'cancelled': {
       const stopped = Object.keys(states).filter((id) => states[id] === 'cancelled')
-      return stopped.length ? `停在「${label(stopped[0])}」` : '已取消'
+      const where = stopped.length ? `停在「${label(stopped[0])}」` : '已取消'
+      return cancelled ? `${cancelled} · ${where}` : where
     }
     case 'suspended':
       return '服务重启时挂起，可从断点接着跑'
@@ -157,6 +183,7 @@ export function useRunGlance(active: boolean): RunGlance {
   const runError = useStudio((s) => s.run?.error)
   const nodes = useStudio((s) => s.nodes)
   const edges = useStudio((s) => s.edges)
+  const cancelled = useStudio((s) => (s.runPhase === 'cancelled' ? cancelNote(s.events) : ''))
   const limitMs = useRunLimit()
   const ticking = active && replayAt == null && isActivePhase(phaseLive)
   const now = useRunClock(ticking)
@@ -187,8 +214,10 @@ export function useRunGlance(active: boolean): RunGlance {
     : settledUsage ? num(runUsage.total_tokens) : null
   const backendCost = settledUsage ? num(runUsage.cost_usd) : null
   const seen = usage.tokensIn + usage.tokensOut > 0 || usage.costUsd > 0
-  const tokens = replayAt != null ? null : backendTok ?? (seen ? usage.tokensIn + usage.tokensOut : null)
-  const cost = replayAt != null ? null : backendCost ?? (seen ? usage.costUsd : null)
+  // 回放读投影在游标那一刻的刻度；刻度加起来对不上后端总数时投影给 undefined，写「—」
+  const replayTok = proj.tokensIn != null && proj.tokensOut != null ? proj.tokensIn + proj.tokensOut : null
+  const tokens = replayAt != null ? replayTok : backendTok ?? (seen ? usage.tokensIn + usage.tokensOut : null)
+  const cost = replayAt != null ? proj.costUsd ?? null : backendCost ?? (seen ? usage.costUsd : null)
 
   // 时限按"这一段执行"计：等人工审批时执行已经结束，那段不算（和后端一致）
   const drive = trace.drives[trace.drives.length - 1]
@@ -219,7 +248,7 @@ export function useRunGlance(active: boolean): RunGlance {
   return {
     phase, code: phase, label: phaseLabel(phase), replay: replayAt != null, at,
     elapsedMs: proj.elapsedMs, activeMs: proj.activeMs, waitMs: proj.waitMs,
-    headline: headlineOf(trace, phase, states, at, label, runError),
+    headline: headlineOf(trace, phase, states, at, label, runError, replayAt == null ? cancelled : ''),
     executing: phase === 'running' && cells.some((c) => c.state === 'running' && !trace.nodes[c.id]?.looping),
     cells, done, visited, parallelNow: proj.parallelNow, series: trace.parallelSeries,
     tokens, cost, remainingMs, limitMs, attention,
@@ -233,15 +262,19 @@ export function useRunGlance(active: boolean): RunGlance {
 
 /**
  * 去审批：不在画布上另做审批控件，只把人带到右栏那张审批卡——同一个组件、同一套
- * 治理口径（只认明确的同意，带备注）。右栏归助手面板：先广播一声，让它在对话层时
- * 切到运行层；再等几帧找卡片，找到就滚过去、描一圈、把焦点放进去。
+ * 治理口径（只认明确的同意，带备注）。右栏归助手面板：广播 agentlab:goto-approval，
+ * 它在对话层时先切到运行层，再滚到卡片、把焦点放进去，并 preventDefault 表示接手了。
+ * 没人接手（右栏收起、老版本的面板）时这里自己等几帧找卡片，找到就滚过去、描一圈。
  */
-function gotoApproval(nodeId: string | undefined): void {
+export function gotoApproval(nodeId: string | undefined): void {
   const s = useStudio.getState()
   // 属性面板盖在右栏上：先让开，审批卡在右栏里
   s.select(null)
   if (nodeId) s.focusNode(nodeId)
-  window.dispatchEvent(new CustomEvent('agentlab:goto-approval', { detail: { runId: s.run?.id, nodeId } }))
+  const handled = !window.dispatchEvent(new CustomEvent('agentlab:goto-approval', {
+    detail: { runId: s.run?.id, nodeId }, cancelable: true,
+  }))
+  if (handled) return
   let tries = 0
   const find = () => {
     const slot = document.querySelector<HTMLElement>('[data-approval-slot]:not(:empty)')
@@ -271,6 +304,22 @@ async function stop(): Promise<void> {
   }
 }
 
+/**
+ * 放弃停在审批上的运行。它已经不在执行，没有「停止」可言；后端把它直接收成已取消，
+ * 待审批一并关闭。关掉的审批找不回来，所以先问一句
+ */
+async function abandon(): Promise<void> {
+  const ok = await confirmDialog({
+    title: '放弃这次运行？',
+    body: '运行停在审批上，放弃之后它记为已取消，不能再接着跑。',
+    consequences: ['等着处理的审批卡一并关闭，留痕里写上是谁放弃的', '已经跑完的节点结果照样留在记录里'],
+    confirmLabel: '放弃这次运行',
+    danger: true,
+  })
+  if (!ok) return
+  await stop()
+}
+
 function startReplay(trace: Trace): void {
   if (trace.startedAt == null) return
   useDock.getState().set({ open: true, playing: true })
@@ -470,9 +519,14 @@ export function RunCapsule() {
         )
       case 'waiting':
         return (
-          <Act className="sf-btn-warn" icon={<Hand size={11} />} text="去审批"
-               title="到右栏的审批卡上处理。等审批时运行已经停在断点上，停止不了"
-               onClick={() => gotoApproval(g.waitingNodeId ?? g.attention.find((a) => a.kind === 'waiting')?.nodeId)} />
+          <>
+            <Act className="sf-btn-warn" icon={<Hand size={11} />} text="去审批"
+                 title="到右栏的审批卡上处理"
+                 onClick={() => gotoApproval(g.waitingNodeId ?? g.attention.find((a) => a.kind === 'waiting')?.nodeId)} />
+            {/* 次级动作：胶囊里只留图标，面板里写全名 */}
+            <Act className="btn-ghost sf-btn-abandon" icon={<Ban size={11} />} text="放弃这次运行" iconOnly={compact}
+                 title="不批了：这次运行记为已取消，待审批一并关闭" onClick={() => void abandon()} />
+          </>
         )
       case 'failed':
         return (
@@ -553,6 +607,7 @@ export function RunCapsule() {
               <div className="flex items-center gap-2">
                 <span className="sf-hud-phase">{g.replay ? `回放 · ${g.label}` : g.label}</span>
                 <span className={clsx('sf-class', runClass === 'formal' && 'is-formal')}>
+                  <ClassDot formal={runClass === 'formal'} />
                   {runClassLabel(runClass, run?.version)}{runClass === 'formal' && active ? ' · 画布只读' : ''}
                 </span>
               </div>
@@ -671,6 +726,18 @@ export function RunCapsule() {
   )
 }
 
+/**
+ * 运行类别的记号：正式运行实心、探索运行空心。盾牌只留给发布等级（已发布 / 受管），
+ * 「正式」一词在发布、运行、出具三层各指一件事，记号不能再混用
+ */
+export function ClassDot({ formal, size = 8 }: { formal: boolean; size?: number }) {
+  return (
+    <svg className="sf-dot" width={size} height={size} viewBox="0 0 8 8" aria-hidden data-class={formal ? 'formal' : 'exploratory'}>
+      <circle cx="4" cy="4" r="3" fill={formal ? 'currentColor' : 'none'} stroke="currentColor" strokeWidth="1.4" />
+    </svg>
+  )
+}
+
 /** 文字从多宽开始露出来。类名要写全，Tailwind 按字面扫描 */
 const TEXT_FROM = { xl: 'hidden xl:inline', '2xl': 'hidden 2xl:inline' } as const
 
diff --git a/frontend/src/run/__tests__/synthetic.ts b/frontend/src/run/__tests__/synthetic.ts
index d50e81fe..8864c2af 100644
--- a/frontend/src/run/__tests__/synthetic.ts
+++ b/frontend/src/run/__tests__/synthetic.ts
@@ -189,6 +189,167 @@ export function cancelledRun(): RunEvent[] {
   return out
 }
 
+// ---------------------------------------------------------------------------
+// 平台问题的几种结局（NI-3/4/5）：模型把工具调用写成文字、团队用完轮数、校验修复
+// 想凑数、工具超时、放弃等审批的运行。文案逐字照后端（toolcalls.py、multi.py、
+// human.py、runner.py），名字全是编的通用示例
+// ---------------------------------------------------------------------------
+
+const MARKUP = '<｜｜DSML｜｜invoke name="db_query__shop">'
+const MEMBER_MARKUP_FAILED = '模型输出了工具调用的原始标记，但没有真正调用工具，这一步什么都没查到'
+  + '（常见原因：这个成员没有绑定工具，或者模型、服务不支持工具调用）'
+export const TOOL_MARKUP_ERROR = '模型输出了工具调用的原始标记，但没有真正调用工具，这一步一次都没查到数据。'
+  + '常见原因：节点没有绑定工具，或者模型、服务不支持工具调用。'
+  + '到画布里给这个节点绑定要用的工具；绑定了还这样，就换一个支持工具调用的模型'
+
+/**
+ * 两轮就用完的协作团队：取数员每轮都把工具调用写成文字（成员失败），汇总员一次都没派到。
+ * mode：fail 默认的判失败；degrade 降档交付；judged 最后那次判定说完成了；closing 停在
+ * 最后那次判定还没出结果。upto='closing' 用来看「调度者在做最后判定」那一行
+ */
+export function exhaustedTeam(mode: 'fail' | 'degrade' | 'judged' | 'closing' = 'fail'): RunEvent[] {
+  const { out, ev } = builder(`syn-exhausted-${mode}`)
+  const reason = '还没有查到任何订单数据'
+  ev('run.started', null, { nodes: 3, resumed: false, replay_protocol: 2 })
+  ev('node.started', 'in', { node_type: 'input', label: '问题' })
+  ev('node.finished', 'in', { duration_ms: 1, attempt: 1, preview: { q: '上月各区域订单额' } })
+  ev('node.started', 'team', { node_type: 'supervisor', label: '销售分析团队' })
+  const member = (round: number, parallel: number, name: string, task: string, ok: boolean) => {
+    ev('agent.step.start', 'team', { agent: name, instruction: task, round, parallel }, 0.001)
+    if (!ok) {
+      ev('llm.end', 'team', { agent: name, model: 'demo-chat', duration_ms: 1800, input_tokens: 500, output_tokens: 90, cost_usd: 0.001 }, 1.8)
+      ev('log', 'team', { level: 'warn', code: 'tool_markup_leak',
+        message: `${name}把工具调用写成了文字（${MARKUP}…），没有真正调用工具，已提醒它重试一次` })
+      ev('llm.end', 'team', { agent: name, model: 'demo-chat', duration_ms: 1500, input_tokens: 620, output_tokens: 80, cost_usd: 0.001 }, 1.5)
+      ev('agent.step.end', 'team', { agent: name, duration_ms: 3300, round, parallel,
+        preview: `（${name} 这一步失败：${MEMBER_MARKUP_FAILED}）`, failed: true, error: MEMBER_MARKUP_FAILED })
+    } else {
+      ev('llm.end', 'team', { agent: name, model: 'demo-chat', duration_ms: 2100, input_tokens: 480, output_tokens: 150, cost_usd: 0.001 }, 2.1)
+      ev('agent.step.end', 'team', { agent: name, duration_ms: 2100, round, parallel, preview: '没有数据可分析，等取数员交回订单明细' })
+    }
+  }
+  ev('agent.route.start', 'team', { round: 0 })
+  ev('llm.end', 'team', { agent: '调度者', model: 'demo-chat', duration_ms: 1200, input_tokens: 400, output_tokens: 60, cost_usd: 0.0008 }, 1.2)
+  ev('agent.route.end', 'team', { round: 0, duration_ms: 1200, agents: ['取数员'], parallel: 1, done: false, reason: '先把订单明细查出来' })
+  ev('log', 'team', { level: 'info', round: 0, parallel: 1, agents: ['取数员'], done: false, reason: '先把订单明细查出来', message: '调度 → 取数员（先把订单明细查出来）' })
+  member(0, 1, '取数员', '查上月 orders 表按区域汇总的订单额', false)
+  ev('agent.route.start', 'team', { round: 1 })
+  ev('llm.end', 'team', { agent: '调度者', model: 'demo-chat', duration_ms: 1100, input_tokens: 700, output_tokens: 60, cost_usd: 0.0009 }, 1.1)
+  ev('agent.route.end', 'team', { round: 1, duration_ms: 1100, agents: ['取数员', '分析员'], parallel: 2, done: false, reason: '取数员再试一次，分析员先准备口径' })
+  ev('log', 'team', { level: 'info', round: 1, parallel: 2, agents: ['取数员', '分析员'], done: false, reason: '取数员再试一次，分析员先准备口径', message: '调度 → 取数员、分析员（取数员再试一次，分析员先准备口径） · 2 人同时进行' })
+  member(1, 2, '分析员', '准备各区域订单额的对比口径', true)
+  member(1, 2, '取数员', '再查一次上月 orders 表', false)
+  // 两轮都派过了、调度者一次都没说完成：补一次只判定、不派活的决定
+  ev('agent.route.start', 'team', { round: 2, closing: true })
+  if (mode === 'closing') return out
+  const judged = mode === 'judged'
+  ev('llm.end', 'team', { agent: '调度者', model: 'demo-chat', duration_ms: 900, input_tokens: 900, output_tokens: 50, cost_usd: 0.001 }, 0.9)
+  ev('agent.route.end', 'team', { round: 2, duration_ms: 900, agents: [], parallel: 0, done: judged,
+    reason: judged ? '分析员给出了口径，可以收尾' : reason, closing: true })
+  if (judged) {
+    ev('log', 'team', { level: 'info', round: 2, agents: [], done: true, closing: true, message: '调度 → 结束协作（分析员给出了口径，可以收尾）' })
+    ev('node.finished', 'team', { duration_ms: 9800, attempt: 1, preview: { text: '口径已备好', rounds: 2 } })
+    ev('run.finished', null, { output: { 结论: '口径已备好' }, usage: { input_tokens: 4600, output_tokens: 620, cost_usd: 0.008 },
+      duration_ms: 10000, timing: { wall_ms: 10000, active_ms: 10000, wait_ms: 0 } })
+    return out
+  }
+  const summary = `协作团队用完 2 轮仍未完成：${reason}。一次都没被派到的成员：汇总员`
+  if (mode === 'fail') {
+    const error = `${summary}。先看成员有没有绑定要用的工具，再调大「最多轮数」；也可以把「用完轮数时」改成降档交付`
+    ev('node.failed', 'team', { error, duration_ms: 9800, detail: null })
+    ev('run.failed', null, { error, node_id: 'team', label: '销售分析团队', timing: { wall_ms: 10000, active_ms: 10000, wait_ms: 0 } })
+    return out
+  }
+  ev('log', 'team', { level: 'warn', code: 'team_exhausted', message: `${summary}。按降档交付：成果是成员最后的原话，不是调度者认可的结论` })
+  ev('node.finished', 'team', { duration_ms: 9800, attempt: 1, preview: {
+    text: `（取数员 这一步失败：${MEMBER_MARKUP_FAILED}）`, rounds: 2, exhausted: true, exhausted_reason: reason, never_dispatched: '[1 项]' } })
+  ev('node.started', 'out', { node_type: 'output', label: '成果' })
+  ev('issuance', 'out', { tier: 'degraded', missing_required: [], missing_expected: [], unmatched: 0, calibers: [],
+    gaps: ['协作团队「销售分析团队」用完 2 轮仍未完成，交来的是成员最后的原话'], metrics_checked: 0, matched_numbers: 0, matched: [] })
+  ev('node.finished', 'out', { duration_ms: 2, attempt: 1, preview: {} })
+  ev('run.finished', null, { output: { 结论: `（取数员 这一步失败：${MEMBER_MARKUP_FAILED}）` },
+    usage: { input_tokens: 4600, output_tokens: 620, cost_usd: 0.008 }, duration_ms: 10000, timing: { wall_ms: 10000, active_ms: 10000, wait_ms: 0 } })
+  return out
+}
+
+/** 没绑工具的 agent：把工具调用写成了文字，纠正一次还这样，判失败 */
+export function markupRun(): RunEvent[] {
+  const { out, ev } = builder('syn-markup')
+  ev('run.started', null, { nodes: 3, resumed: false })
+  ev('node.started', 'in', { node_type: 'input', label: '问题' })
+  ev('node.finished', 'in', { duration_ms: 1, attempt: 1, preview: { q: '上月订单额' } })
+  ev('node.started', 'query', { node_type: 'agent', label: '数据查询' })
+  ev('llm.start', 'query', { model: 'demo-chat', message_count: 2 })
+  ev('llm.end', 'query', { agent: '数据查询', model: 'demo-chat', duration_ms: 2200, input_tokens: 900, output_tokens: 140, total_tokens: 1040, cost_usd: 0.002, calls: 1 }, 2.2)
+  ev('log', 'query', { level: 'warn', code: 'tool_markup_leak',
+    message: `模型把工具调用写成了文字（${MARKUP}…），没有真正调用工具，已提醒它重试一次` })
+  ev('llm.start', 'query', { model: 'demo-chat', message_count: 4 })
+  ev('llm.end', 'query', { agent: '数据查询', model: 'demo-chat', duration_ms: 1900, input_tokens: 1100, output_tokens: 120, total_tokens: 1220, cost_usd: 0.002, calls: 1 }, 1.9)
+  ev('node.failed', 'query', { error: TOOL_MARKUP_ERROR, duration_ms: 4200, detail: null })
+  ev('run.failed', null, { error: TOOL_MARKUP_ERROR, node_id: 'query', label: '数据查询', timing: { wall_ms: 4300, active_ms: 4300, wait_ms: 0 } })
+  return out
+}
+
+/** 结构化校验：原文里没有数，修复两次都编出了 total_count=0，两次都作废，判失败 */
+export function repairRun(): RunEvent[] {
+  const { out, ev } = builder('syn-repair')
+  ev('run.started', null, { nodes: 3, resumed: false })
+  ev('node.started', 'query', { node_type: 'agent', label: '数据查询' })
+  ev('node.finished', 'query', { duration_ms: 2400, attempt: 1, preview: { text: '假设调用工具：SELECT region, SUM(amount) FROM orders GROUP BY region' } }, 2.4)
+  ev('node.started', 'check', { node_type: 'validate', label: '结构校验' })
+  ev('log', 'check', { level: 'warn', code: 'validate_retry', message: '第 1 次校验失败：输出不是合法 JSON' })
+  ev('llm.end', 'check', { model: 'demo-chat', purpose: 'repair', duration_ms: 1300, input_tokens: 600, output_tokens: 40, total_tokens: 640, cost_usd: 0.001, calls: 1 }, 1.3)
+  ev('log', 'check', { level: 'warn', code: 'repair_invented', message: '第 1 次修复作废：修复时出现了原文没有的值：total_count=0' })
+  ev('llm.end', 'check', { model: 'demo-chat', purpose: 'repair', duration_ms: 1200, input_tokens: 600, output_tokens: 40, total_tokens: 640, cost_usd: 0.001, calls: 1 }, 1.2)
+  ev('log', 'check', { level: 'warn', code: 'repair_invented', message: '第 2 次修复作废：修复时出现了原文没有的值：total_count=0' })
+  const error = '结构化校验未通过：修复时出现了原文没有的值：total_count=0'
+  ev('node.failed', 'check', { error, duration_ms: 2600, detail: null })
+  ev('run.failed', null, { error, node_id: 'check', label: '结构校验', timing: { wall_ms: 5200, active_ms: 5200, wait_ms: 0 } })
+  return out
+}
+
+/** 查询带着 30 秒时限：upto='live' 停在还没回来（已经超时），否则到点被放弃 */
+export function timeoutRun(upto: 'live' | 'done' = 'done'): RunEvent[] {
+  const { out, ev } = builder('syn-timeout')
+  ev('run.started', null, { nodes: 2, resumed: false })
+  ev('node.started', 'query', { node_type: 'tool', label: '取订单明细' })
+  ev('tool.start', 'query', { tool: 'db_query__shop', timeout_s: 30, args: { sql: 'SELECT * FROM orders' } })
+  if (upto === 'live') return out
+  ev('tool.error', 'query', { tool: 'db_query__shop', timed_out: true, duration_ms: 31000,
+    error: '查询超过 30s 没有返回，已放弃等待（数据库那边可能还在跑，连接会在后台收回）。加上 WHERE 条件或 LIMIT 缩小范围再查' }, 31)
+  ev('node.failed', 'query', { error: '查询超过 30s 没有返回，已放弃等待（数据库那边可能还在跑，连接会在后台收回）。加上 WHERE 条件或 LIMIT 缩小范围再查。数据量大就在参数里缩小范围；对方偶尔卡住的话，稍后「接着跑」即可', duration_ms: 31000 })
+  return out
+}
+
+/** 停在审批上被放弃：run.cancelled 带操作人和一句说明 */
+export function abandonedRun(): RunEvent[] {
+  const { out, ev } = builder('syn-abandoned')
+  ev('run.started', null, { nodes: 3, resumed: false })
+  ev('node.started', 'review', { node_type: 'human', label: '主管审批' })
+  ev('human.requested', 'review', { kind: 'human_node', node_id: 'review', mode: 'approve', title: '这份报表可以发出吗？' })
+  ev('run.interrupted', 'review', { payload: { node_id: 'review', title: '这份报表可以发出吗？' } })
+  ev('run.cancelled', null, { timing: { wall_ms: 60000, active_ms: 400, wait_ms: 59600 }, actor: '张工',
+    message: '放弃了这次运行，1 条待审批一并关闭' }, 60)
+  return out
+}
+
+/** 改图时模型漏写了 tools：自查带回 tools_dropped 警告，final 带回工具绑定变化 */
+export const COPILOT_TOOLS_DROPPED = [
+  { op: 'update_node', id: 'query', label: '数据查询', config: { system: '只查上月的数据' } },
+  { op: 'done', explanation: '改了提示词' },
+  { op: 'check', status: 'passed', repaired: 0, warnings: [
+    { level: 'warning', node_id: 'query', edge_id: null, code: 'tools_dropped', field: 'tools',
+      message: '「数据查询」的工具从 db_query__shop、db_schema__shop 变成了空：这一轮的要求里没有提到去掉工具' },
+  ] },
+  { op: 'final', graph: { nodes: [{ id: 'in' }, { id: 'query' }, { id: 'out' }] }, tool_changes: [
+    { node_id: 'query', label: '数据查询', member: null, field: 'tools',
+      before: ['db_query__shop', 'db_schema__shop'], after: [], added: [], removed: ['db_query__shop', 'db_schema__shop'] },
+  ], issues: [
+    { level: 'warning', node_id: 'query', code: 'tools_dropped', field: 'tools',
+      message: '「数据查询」的工具从 db_query__shop、db_schema__shop 变成了空：这一轮的要求里没有提到去掉工具' },
+  ] },
+]
+
 /** Copilot 操作流：思考被心跳打断、自查修一轮没修好、模型写了不存在的节点类型 */
 export const COPILOT_STUCK = [
   { op: 'heartbeat', phase: 'planning', elapsed_ms: 3000 },
diff --git a/frontend/src/run/decode.ts b/frontend/src/run/decode.ts
index b0dea52b..5da9b0da 100644
--- a/frontend/src/run/decode.ts
+++ b/frontend/src/run/decode.ts
@@ -1,4 +1,4 @@
-import type { RunEvent, TeamMember, TeamRound, TeamRun } from '../types'
+import type { RunEvent, TeamMember, TeamRound, TeamRun, ToolChange } from '../types'
 import type { NodeState, RunPhase } from './trace'
 import { formatDuration, formatNumber } from '../lib/format'
 import { TYPE_LABEL, issuanceLabel, nodeTypeLabel } from '../lib/terms'
@@ -7,6 +7,35 @@ import { TYPE_LABEL, issuanceLabel, nodeTypeLabel } from '../lib/terms'
 // types.ts 里；这里再导出一遍，老引用不用改
 export type { TeamMember, TeamRound, TeamRun }
 
+/**
+ * 协作团队怎么收的尾。只看 finished 分不出「调度者说完成了」和「轮数用完、硬停」——
+ * 后者以前把成员的原话当结论交了出去，画布和右栏却都是一个安静的「完成」。
+ */
+export interface TeamVerdict {
+  /** 轮数用完后补的那一次只判定、不派活的决定（agent.route.* 带 closing） */
+  closing?: boolean
+  /** 那次判定的结论 */
+  done?: boolean
+  reason?: string
+  /** 用完轮数仍未完成的结局：failed 判失败（默认），degraded 降档交付 */
+  outcome?: 'failed' | 'degraded'
+  /** 一共派了几轮 */
+  rounds?: number
+  /** 一次都没被派到的成员 */
+  never?: string[]
+}
+
+/** 成员这一步为什么失败（agent.step.end 的 error）。types.ts 冻结，先在这里扩 */
+export interface TeamMemberEx extends TeamMember { error?: string }
+export interface TeamRunEx extends TeamRun { verdict?: TeamVerdict }
+
+/** 画布的协作矩阵读这个：runtime.team 是 reduceTeam 给的，带着结局 */
+export const teamVerdictOf = (team: TeamRun | undefined | null): TeamVerdict | undefined =>
+  (team as TeamRunEx | undefined | null)?.verdict
+
+/** 下一步该去哪儿改。界面据此给一个直达的入口，而不只是一句话 */
+export type FixKind = 'canvas' | 'settings' | 'tools'
+
 /**
  * 事件 → 人能看懂的步骤。
  *
@@ -98,6 +127,16 @@ export interface Step {
   source?: string
   /** 相邻的同一件事合并成一行后的统计（见 compactSteps） */
   repeat?: { count: number; ms: number[] }
+  /** 后端给的机读代号（log.code 等）：tool_markup_leak、team_exhausted、repair… */
+  code?: string
+  /** 怎么办：出了状况的行直接说下一步，不让人自己去猜 */
+  next?: string
+  /** 下一步该去的地方 */
+  fix?: FixKind
+  /** 工具的时限（秒，tool.start.timeout_s）。进行中的行超过它就要说破 */
+  limitS?: number
+  /** 出具那一行的档位（formal / degraded / withheld） */
+  tier?: string
 }
 
 // 这两个是流式增量，后端根本不落库（_EPHEMERAL）。单次运行的 delta 量级会
@@ -554,6 +593,54 @@ function queryTitle(sql: string, source: string): string {
   return clip(`查询 ${what}${how ? ` · ${how}` : ''}`)
 }
 
+/**
+ * 几种「看着跑完了、其实没做成」的状况（NI-3/4/5）。后端这几条日志是写给排查的，原样
+ * 贴出来是一串标记和术语，而且不说该去哪儿改——这里说成人话，并给出下一步。
+ * 认不得的 code 返回 null，照原话显示
+ */
+function explainLog(code: string | undefined, message: string): Pick<Step, 'title' | 'sub' | 'next' | 'fix'> | null {
+  switch (code) {
+    case 'tool_markup_leak': {
+      // 「数据查询把工具调用写成了文字（<｜｜DSML｜｜…），没有真正调用工具，已提醒它重试一次」
+      const who = message.match(/^(.+?)把工具调用写成了文字/)?.[1]?.trim() || '模型'
+      // 收尾轮那种是真调过工具、只是步数用完了还想接着查：不是没绑工具，节点也照常完成，
+      // 说成「没有真正执行」会让人去查一个并不存在的故障
+      const settle = message.includes('收尾轮')
+      return {
+        title: settle ? `${who === '模型' ? '' : `${who}：`}步数用完了，收尾时还想接着查`
+          : `${who}把工具调用写成了文字，没有真正执行`,
+        sub: settle ? '收尾那一轮的调用没有执行，结论只基于之前查到的部分'
+          : message.includes('重试') ? '已提醒它重试一次' : undefined,
+        next: settle ? '到画布里调大这一步的「最多步数」，或者把问题问得更具体'
+          : `常见原因：${who === '模型' ? '这个节点' : `成员「${who}」`}没有绑定工具，或者模型不支持工具调用。到画布里给它绑定要用的工具`,
+        fix: 'canvas',
+      }
+    }
+    case 'team_exhausted': {
+      const x = exhaustedOf(message)
+      return {
+        title: `协作团队${x?.rounds != null ? `用完 ${x.rounds} 轮` : '用完了轮数'}仍未完成 · 按降档交付`,
+        sub: [x?.reason, x?.never?.length ? `没派到：${x.never.join('、')}` : ''].filter(Boolean).join(' · ') || undefined,
+        next: '交出去的是成员最后的原话，不能当结论用。到画布里看成员有没有绑定要用的工具，再调大「最多轮数」',
+        fix: 'canvas',
+      }
+    }
+    case 'repair_invented': {
+      // 「第 1 次修复作废：修复时出现了原文没有的值：total_count=0」
+      const values = message.match(/原文没有的值[：:]\s*(.+)$/)?.[1]?.trim()
+      const what = values ? `（${values}）` : ''
+      return {
+        title: clip(`修复被作废：出现了原文没有的值${what}`),
+        sub: `结果里有原文没有的值${what}，已作废`,
+        next: '修复只许改格式、不许补数据。先看上游节点为什么没拿到数据（常见是没有绑定查询工具）',
+        fix: 'canvas',
+      }
+    }
+    default:
+      return null
+  }
+}
+
 function toolStep(seq: number, tool: string, args: Record<string, any>): Step {
   const base = { id: `tool-${seq}`, seq, status: 'running' as StepStatus }
   // 数据库工具单独认：它是这个产品最主要的取数方式，"调用 db_query__warehouse"
@@ -659,6 +746,20 @@ function groupConcurrent(
   }
 }
 
+/**
+ * 「协作团队用完 N 轮仍未完成：<理由>。一次都没被派到的成员：A、B。…」里的几样东西。
+ * 判失败的报错和降档的那条日志是同一个开头；产出里的 never_dispatched 进事件时被
+ * 缩成了「[1 项]」，成员名只能从这句话里认
+ */
+function exhaustedOf(text: string): Pick<TeamVerdict, 'rounds' | 'reason' | 'never'> | null {
+  const m = text.match(/用完\s*(\d+)\s*轮仍未完成[：:]\s*([\s\S]*?)(?:。一次都没被派到的成员|。先看成员|。按降档交付|$)/)
+  if (!m) return null
+  const never = text.match(/一次都没被派到的成员[：:]\s*([^。]+)/)?.[1]
+    .split('、').map((s) => s.trim()).filter(Boolean) ?? []
+  const reason = m[2].trim()
+  return { rounds: Number(m[1]), ...(reason ? { reason } : {}), never }
+}
+
 /**
  * 把一个事件并进协作团队的泳道数据，返回**新的** TeamRun。
  *
@@ -672,10 +773,13 @@ function groupConcurrent(
  *
  * 返回 null 表示这个事件和协作团队无关（绝大多数事件都是）。
  */
-export function reduceTeam(prev: TeamRun | undefined, event: RunEvent): TeamRun | null {
+export function reduceTeam(prev: TeamRun | undefined, event: RunEvent): TeamRunEx | null {
   const d = (event.data ?? {}) as Record<string, any>
   const nodeId = event.node_id
   if (!nodeId) return null
+  const verdictOf = (team: TeamRun) => (team as TeamRunEx).verdict
+  const withVerdict = (team: TeamRun, patch: TeamVerdict): TeamRunEx =>
+    ({ ...team, verdict: { ...verdictOf(team), ...patch } })
 
   const roundOf = (team: TeamRun, round: number): TeamRound =>
     team.rounds.find((x) => x.round === round) ?? {
@@ -718,10 +822,15 @@ export function reduceTeam(prev: TeamRun | undefined, event: RunEvent): TeamRun
       const cur = roundOf(prev, round)
       const ms = num(d.duration_ms) ?? 0
       const preview = String(d.preview ?? '').slice(0, 2000)
+      // 失败的成员（异常，或者把工具调用写成了文字）：格子画成失败，而不是一个写着
+      // 失败原因的「完成」格子
+      const ended: Partial<TeamMemberEx> = d.failed
+        ? { ms, status: 'failed', result: preview || undefined, error: String(d.error ?? '') || undefined }
+        : { ms, status: 'done', result: preview || undefined }
       const idx = cur.members.findIndex((x) => x.agent === name && x.status === 'running')
-      const members = idx >= 0
-        ? cur.members.map((x, i) => (i === idx ? { ...x, ms, status: 'done' as const, result: preview || undefined } : x))
-        : [...cur.members, { agent: name, instruction: '', ms, status: 'done' as const, result: preview || undefined }]
+      const members: TeamMember[] = idx >= 0
+        ? cur.members.map((x, i) => (i === idx ? { ...x, ...ended } : x))
+        : [...cur.members, { agent: name, instruction: '', ms, status: 'done', ...ended }]
       // 这一轮实际花的是最慢那个，各人之和减去它就是省下的
       return withRound(prev, round, {
         members,
@@ -731,6 +840,11 @@ export function reduceTeam(prev: TeamRun | undefined, event: RunEvent): TeamRun
     }
 
     case 'log': {
+      // 降档交付的那一条：轮数用完、调度者始终没说完成，按降档把成员原话交出去
+      if (d.code === 'team_exhausted') {
+        const team = prev ?? { members: [], rounds: [], savedMs: 0, finished: false }
+        return withVerdict({ ...team, finished: true }, { outcome: 'degraded', ...exhaustedOf(String(d.message ?? '')) })
+      }
       // 带 round 的 info 日志是调度决策，不是排查日志
       if (String(d.level ?? 'info') !== 'info' || d.round == null) return null
       const team = prev ?? { members: [], rounds: [], savedMs: 0, finished: false }
@@ -740,18 +854,52 @@ export function reduceTeam(prev: TeamRun | undefined, event: RunEvent): TeamRun
       const done = structured ? !!d.done : legacy?.[1]?.trim() === 'FINISH'
       const reason = structured ? String(d.reason ?? '') : (legacy?.[2]?.trim() ?? '')
       if (done) return { ...team, finished: true }
+      // 最后那次判定的 round 是「派过的轮数」，不是新的一轮：记进一列的话矩阵会多出一列空的
+      if (d.closing) return team
       return reason ? withRound(team, num(d.round) ?? 0, { reason }) : team
     }
 
+    case 'agent.route.start': {
+      // 普通的一轮等 route.end 带着派给谁再记；只有收尾判定要先记一笔「在判定」，
+      // 不然那几秒泳道上什么都不说，看着像卡住了
+      if (!d.closing) return null
+      return withVerdict(prev ?? { members: [], rounds: [], savedMs: 0, finished: false }, { closing: true })
+    }
+
     case 'agent.route.end': {
       // 调度者的结构化决策。后端同一轮还会再发一条带 round 的 log，两条说的是
       // 同一件事，按哪条来结果都一样；只认 log 的话，哪天 log 不发了理由就丢了
       const team = prev ?? { members: [], rounds: [], savedMs: 0, finished: false }
-      if (d.done) return { ...team, finished: true }
       const reason = String(d.reason ?? '')
+      if (d.closing) {
+        // 轮数用完后补的那一次判定：只下结论、不派活，不是第 N+1 轮
+        const judged = withVerdict(team, { closing: true, done: !!d.done, ...(reason ? { reason } : {}) })
+        return d.done ? { ...judged, finished: true } : judged
+      }
+      if (d.done) return { ...team, finished: true }
       return reason ? withRound(team, num(d.round) ?? 0, { reason }) : team
     }
 
+    case 'node.finished': {
+      // 降档交付：产出里带 exhausted。老后端没有 team_exhausted 那条日志时也认得出
+      const p = d.preview
+      if (!prev || !p || typeof p !== 'object' || !p.exhausted) return null
+      const rounds = num(p.rounds)
+      const known = verdictOf(prev)
+      return withVerdict({ ...prev, finished: true }, {
+        outcome: 'degraded',
+        ...(rounds != null ? { rounds } : {}),
+        ...(!known?.reason && p.exhausted_reason ? { reason: String(p.exhausted_reason) } : {}),
+      })
+    }
+
+    case 'node.failed': {
+      // 判失败（on_exhausted 默认）：报错首句就是「协作团队用完 N 轮仍未完成：…」
+      if (!prev) return null
+      const exhausted = exhaustedOf(String(d.error ?? ''))
+      return exhausted ? withVerdict({ ...prev, finished: true }, { outcome: 'failed', ...exhausted }) : null
+    }
+
     default:
       return null
   }
@@ -786,7 +934,9 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
   /** 已经有结构化调度事件的轮次。同一轮那条带 round 的 log 说的是同一件事，不再成行 */
   const routed = new Set<string>()
   /** node_id → 协作团队的泳道数据。边解码边攒，最后挂到该节点的顶层 Step 上 */
-  const teams = new Map<string, TeamRun>()
+  const teams = new Map<string, TeamRunEx>()
+  /** node_id → 校验节点最近一次修复。被作废的说明（repair_invented）折进这一行 */
+  const repairs = new Map<string, Step>()
   /** node_id → 起止时刻。用来事后认出"哪几个节点是同时跑的" */
   const spans = new Map<string, { start: number; end: number; ms: number }>()
 
@@ -1034,7 +1184,14 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
             const preview = typeof raw === 'string' ? raw : JSON.stringify(raw, null, 2)
             step.detail = preview.slice(0, 4000)
           }
+          // 协作团队降档交付：节点确实跑完了，但交出去的是成员最后的原话，不是一个安静的勾
+          if (raw && typeof raw === 'object' && raw.exhausted) {
+            step.level = 'warn'
+            const rounds = num(raw.rounds)
+            step.sub = `${rounds != null ? `用完 ${rounds} 轮` : '用完了轮数'}仍未完成，按降档交付`
+          }
         }
+        trackTeam(event)
         break
       }
 
@@ -1056,6 +1213,7 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
           push({ id: `e-${seq}`, seq, kind: 'error', level: 'error', status: 'failed',
                  title: String(d.error ?? '这一步失败了'), nodeId, raw }, nodeId)
         }
+        trackTeam(event)
         break
       }
 
@@ -1073,6 +1231,19 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
       }
 
       case 'llm.end': {
+        if (d.purpose === 'repair') {
+          // 校验节点让模型修格式：一次真实的模型调用（前面没有 llm.start）。以前它不成行，
+          // 修复编出来的值被作废时，时间线上连「修过」这件事都看不到
+          const ms = num(d.duration_ms)
+          const step: Step = {
+            id: `rp-${seq}`, seq, kind: 'llm', code: 'repair', nodeId, status: 'done',
+            title: '让模型修复格式', ms, meta: dur(ms),
+            ...(d.model ? { detail: `模型：${d.model}` } : {}),
+          }
+          repairs.set(nodeId ?? '_', step)
+          push(step, nodeId)
+          break
+        }
         const step = pendingLlm.get(nodeId ?? '_')
         if (!step) break
         step.status = 'done'
@@ -1112,6 +1283,9 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
         const step = toolStep(seq, String(d.tool ?? ''), d.args ?? {})
         step.nodeId = nodeId
         step.startedAt = at
+        // 引擎到点会放弃等待：进行中的秒表越过它时，界面要说「已超出上限」，而不是一直走
+        const limit = num(d.timeout_s)
+        if (limit != null && limit > 0) step.limitS = limit
         // 协作成员调的工具说清是谁调的
         if (d.agent) step.sub = `${d.agent} 调用`
         // call_id 才是可靠的配对键：同一节点并发调同名工具时，按名字配会错位。
@@ -1131,6 +1305,13 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
             || preview.startsWith('查询失败')
           step.status = failed ? 'failed' : 'done'
           if (failed) step.level = 'error'
+          if (d.timed_out) {
+            // 到点被放弃的：数据库那边可能还在跑，这里只是不等了。上限写出来，才知道
+            // 该缩小查询范围还是去调时限
+            const limit = step.limitS ?? num(Number(preview.match(/超过\s*(\d+(?:\.\d+)?)\s*s/)?.[1]))
+            const why = limit != null ? `超过 ${formatNumber(limit)} s 上限，已放弃等待` : '超过时限，已放弃等待'
+            step.sub = d.agent ? `${why} · ${d.agent} 调用` : why
+          }
           // tool.error 只有 {tool,error}，没有 duration_ms/preview——不能假设统一形状
           const rows = rowCountOf(preview)
           step.ms = num(d.duration_ms)
@@ -1264,7 +1445,7 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
           num(d.matched_numbers) != null ? `回指 ${d.matched_numbers} 个数字` : '',
         ].filter(Boolean).join(' · ')
         out.push({
-          id: `is-${seq}`, seq, kind: 'issuance', status: 'done',
+          id: `is-${seq}`, seq, kind: 'issuance', status: 'done', ...(tier ? { tier } : {}),
           level: tier === 'formal' ? 'info' : tier === 'withheld' ? 'error' : 'warn',
           title: clip(gaps.length ? `${label}：${gaps.join('；')}` : label, 120),
           // 核对了几个指标、回指了几个数字放进展开区：横幅上有同样的数，窄栏的行尾放不下
@@ -1286,10 +1467,13 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
         const round = num(d.round) ?? 0
         const step: Step = {
           id: `rs-${seq}`, seq, kind: 'branch', nodeId, status: 'running', startedAt: at,
-          title: `第 ${round + 1} 轮：调度者在想下一步…`,
+          // 轮数用完后补的那一次只判定、不派活。它的 round 是「派过几轮」，写成「第 N+1 轮」
+          // 读起来像还有新的一轮
+          title: d.closing ? '轮数用完 · 调度者在做最后判定…' : `第 ${round + 1} 轮：调度者在想下一步…`,
         }
         pendingRoutes.set(`${nodeId}|${round}`, step)
         push(step, nodeId)
+        trackTeam(event)
         break
       }
 
@@ -1298,19 +1482,24 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
         const key = `${nodeId}|${round}`
         routed.add(key)
         const agents: string[] = Array.isArray(d.agents) ? d.agents.map(String) : []
-        const title = d.done || !agents.length ? `第 ${round + 1} 轮：结束协作`
-          : agents.length > 1 ? `第 ${round + 1} 轮：交给 ${agents.join('、')}（并行）`
-          : `第 ${round + 1} 轮：交给 ${agents[0]}`
         const ms = num(d.duration_ms)
         const reason = String(d.reason ?? '')
+        // 最后那次判定说「没完成」时不能写「结束协作」：那读起来像团队正常收尾了
+        const title = d.closing
+          ? d.done ? '轮数用完 · 调度者判定：已完成'
+            : clip(`轮数用完 · 调度者判定：未完成${reason ? `（${reason}）` : ''}`)
+          : d.done || !agents.length ? `第 ${round + 1} 轮：结束协作`
+          : agents.length > 1 ? `第 ${round + 1} 轮：交给 ${agents.join('、')}（并行）`
+          : `第 ${round + 1} 轮：交给 ${agents[0]}`
+        const verdictLevel = d.closing && !d.done ? { level: 'warn' as const } : {}
         const step = pendingRoutes.get(key)
         if (step) {
-          Object.assign(step, { status: 'done', title, ms, meta: dur(ms),
+          Object.assign(step, { status: 'done', title, ms, meta: dur(ms), ...verdictLevel,
                                 ...(reason ? { detail: reason } : {}) })
           pendingRoutes.delete(key)
         } else {
           push({ id: `re-${seq}`, seq, kind: 'branch', nodeId, status: 'done', title, ms,
-                 meta: dur(ms), ...(reason ? { detail: reason } : {}) }, nodeId)
+                 meta: dur(ms), ...verdictLevel, ...(reason ? { detail: reason } : {}) }, nodeId)
         }
         trackTeam(event)
         break
@@ -1335,8 +1524,16 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
         const step = pendingAgents.get(key)
         const preview = String(d.preview ?? '').slice(0, 2000)
         const ms = num(d.duration_ms)
+        // 成员这一步失败了（异常，或者把工具调用写成了文字）：原因写在副标题上，不用展开才看得到。
+        // 标记那种的原话是一整句排查说明，窄栏里截断后只剩半句，这里换成和报错行同一个说法
+        const why = String(d.error ?? '')
+        const failure: Partial<Step> = d.failed
+          ? { status: 'failed', level: 'error',
+              sub: /没有真正调用工具|工具调用的原始标记/.test(why) ? '模型没有真正调用工具，这一步什么都没查到'
+                : clip(why || '这一步失败了', 80) }
+          : { status: 'done' }
         if (step) {
-          step.status = 'done'
+          Object.assign(step, failure)
           step.ms = ms
           step.meta = dur(ms)
           step.result = preview || undefined
@@ -1345,7 +1542,7 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
           push({
             id: `ae-${seq}`, seq, kind: 'note', nodeId, status: 'done',
             title: `${d.agent} 回复`, ms, meta: dur(ms),
-            detail: preview || undefined,
+            detail: preview || undefined, ...failure,
           }, nodeId)
         }
         trackTeam(event)
@@ -1400,11 +1597,26 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
         }
         // 其余 info 是给排查用的，不进主流程——但 warn/error 用户必须看到
         if (level === 'info' || !message) break
+        const code = typeof d.code === 'string' && d.code ? d.code : undefined
+        const said = explainLog(code, message)
+        if (code === 'repair_invented') {
+          // 修复编出了原文没有的值：折进刚才那一行「让模型修复格式」，一件事一行
+          const repair = repairs.get(nodeId ?? '_')
+          if (repair && said) {
+            Object.assign(repair, { level: 'warn', sub: said.sub, next: said.next, fix: said.fix,
+                                    detail: [repair.detail, message].filter(Boolean).join('\n') })
+            repairs.delete(nodeId ?? '_')
+            break
+          }
+        }
+        if (code === 'team_exhausted') trackTeam(event)
         push({
           id: `lg-${seq}`, seq, kind: 'note', nodeId, status: 'done',
           level: level === 'error' ? 'error' : 'warn',
-          title: clip(message, 120),
-          ...(message.length > 120 ? { detail: message } : {}),
+          ...(code ? { code } : {}),
+          ...(said
+            ? { ...said, detail: message }
+            : { title: clip(message, 120), ...(message.length > 120 ? { detail: message } : {}) }),
         }, nodeId)
         break
       }
@@ -1431,11 +1643,18 @@ export function decodeRun(events: RunEvent[], final?: RunFinal): Step[] {
         break
       }
 
-      case 'run.cancelled':
-        // 用户主动停下的，不是出错：收成中性的"已取消"，不画红色的失败
+      case 'run.cancelled': {
+        // 用户主动停下的，不是出错：收成中性的"已取消"，不画红色的失败。谁停的、放弃等
+        // 审批时一并关了几条，写在副标题上——多人用时「怎么没了」得有个交代
         settle(endingOf(event, awaiting)!)
-        out.push({ id: `rc-${seq}`, seq, kind: 'lifecycle', status: 'cancelled', title: '已取消' })
+        // 说法和画布胶囊的那一句一致：「张工 放弃了这次运行，1 条待审批一并关闭」
+        const who = typeof d.actor === 'string' && d.actor.trim() ? d.actor.trim() : ''
+        const said = String(d.message ?? '').trim()
+        const sub = said ? `${who ? `${who} ` : ''}${said}` : who ? `${who} 取消了这次运行` : ''
+        out.push({ id: `rc-${seq}`, seq, kind: 'lifecycle', status: 'cancelled', title: '已取消',
+                   ...(sub ? { sub } : {}) })
         break
+      }
 
       case 'run.finished': {
         // 开头那条"开始执行"要收尾，否则跑完了还挂着一个转圈的图标。
@@ -1648,8 +1867,10 @@ const median = (xs: number[]): number => {
  */
 export function compactSteps(steps: Step[]): Step[] {
   const out: Step[] = []
+  // 出了状况的行，副标题和下一步说的是为什么、怎么办：说法不同就是两件事，并成一行只剩第一件
   const same = (a: Step, b: Step) => a.kind === b.kind && a.title === b.title
     && a.level === b.level && a.status === b.status && a.nodeId === b.nodeId
+    && (!a.level || (a.sub === b.sub && a.next === b.next))
   const mergeable = (s: Step) => !s.children?.length && !s.team && !s.execs?.length
     && s.status !== 'running' && s.status !== 'waiting'
   for (const s of steps) {
@@ -1769,8 +1990,11 @@ function parseIssue(v: unknown): CopilotIssue {
  *
  * context：画布上从不自动运行，「没有自动运行」是问数据页的说法，放到画布上
  * 读起来像出了别的故障。
+ *
+ * unchanged：收到了 final，但画布一处都没变（store 比对出来的，操作流里看不出）。
+ * 那一行不能再说「流程搭好了」。
  */
-export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'chat' }): Step[] {
+export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'chat'; unchanged?: boolean }): Step[] {
   const canvas = opts?.context === 'canvas'
   const out: Step[] = []
   let i = 0
@@ -1896,8 +2120,14 @@ export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'c
                 detail: lines.join('\n') || undefined })
         } else if (op.status === 'passed') {
           settleAll('done')
+          // 规则上通过了，但有节点的工具被悄悄去掉了（模型改提示词时漏写 tools）：这不是
+          // 一句安静的「自查通过」能交代的，图照样能跑，只是跑起来什么都查不到
+          const dropped = droppedOf(op)
           add({ id: `ck-${i}`, seq: i, kind: 'note', status: 'done',
-                title: op.repaired ? '自查通过：问题已经改好' : '自查通过' })
+                title: `${op.repaired ? '自查通过：问题已经改好' : '自查通过'}${dropped.length
+                  ? `，但有 ${dropped.length} 处工具被去掉了` : ''}`,
+                ...(dropped.length ? { level: 'warn' as const, code: 'tools_dropped',
+                                       detail: dropped.map((x) => x.message).join('\n') } : {}) })
         } else {
           // 修正那一轮本身是跑完了的；没修好由下面这行红字说，不把阶段行也画红
           settleAll('done')
@@ -1907,7 +2137,7 @@ export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'c
                     ? `自查后还有 ${issues.length} 处问题没能自动修好`
                     : `自查后还有 ${issues.length} 处问题，没有自动运行`
                   : String(op.message ?? '自查没能完成'),
-                detail: lines.join('\n') || undefined,
+                detail: [...lines, ...droppedOf(op).map((x) => x.message)].join('\n') || undefined,
                 ...(typeof op.detail === 'string' && op.detail ? { raw: op.detail } : {}) })
         }
         break
@@ -1922,9 +2152,10 @@ export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'c
         const built = [...out].reverse().find((s) => s.id.startsWith('cd-'))
           ?? (last?.kind === 'lifecycle' ? last : undefined)
         if (total && built) {
-          built.title = nodeCount && nodeCount < total
-            ? `流程搭好了，加了 ${nodeCount} 步，整张图共 ${total} 步`
-            : `流程搭好了，共 ${total} 步`
+          built.title = opts?.unchanged ? `看过了，没有改动（整张图共 ${total} 步）`
+            : nodeCount && nodeCount < total
+              ? `流程搭好了，加了 ${nodeCount} 步，整张图共 ${total} 步`
+              : `流程搭好了，共 ${total} 步`
         }
         settleAll('done')
         // 模型写了不存在的节点类型：那一步被跳过了。不说出来的话"共 N 步"是
@@ -1933,6 +2164,24 @@ export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'c
           add({ id: `cm-${i}-${t}`, seq: i, kind: 'note', status: 'done', level: 'warn',
                 title: clip(`少了一步：模型用了不存在的节点类型「${t}」，已跳过`, 80) })
         }
+        // 工具绑定变化单独成一行：改图回执以前只说「修改 1」，模型改提示词时漏写 tools、
+        // 把查库的工具整个抹掉，要到运行结果不对才发现
+        const changes = toolChangesOf(op)
+        if (changes.length) {
+          const lost = changes.filter((c) => c.removed.length)
+          const one = changes.length === 1 ? changes[0] : null
+          add({
+            id: `cg-${i}`, seq: i, kind: 'tool', status: 'done', code: 'tool_changes',
+            ...(lost.length ? { level: 'warn' as const } : {}),
+            title: clip(one
+              ? one.removed.length && !one.after.length ? `${changeWho(one)}的工具被清空了`
+                : one.removed.length ? `${changeWho(one)}少了 ${one.removed.length} 个工具`
+                : `${changeWho(one)}的工具变了`
+              : `${changes.length} 处工具绑定变了${lost.length ? `，${lost.length} 处少了工具` : ''}`, 80),
+            detail: changes.map((c) => `${changeWho(c)}：${c.before.join('、') || '（空）'} → ${c.after.join('、') || '（空）'}`)
+              .join('\n'),
+          })
+        }
         break
       }
       case 'reply':
@@ -1953,6 +2202,30 @@ export function decodeCopilot(ops: CopilotOp[], opts?: { context?: 'canvas' | 'c
   return out
 }
 
+/** final.tool_changes：后端比对新旧图得出的工具绑定变化（NI-1） */
+function toolChangesOf(op: CopilotOp): ToolChange[] {
+  const list: any[] = Array.isArray(op.tool_changes) ? op.tool_changes : []
+  const names = (v: unknown): string[] => (Array.isArray(v) ? v.map(String) : [])
+  return list.filter((c) => c && typeof c === 'object').map((c) => ({
+    node_id: String(c.node_id ?? ''),
+    field: String(c.field ?? 'tools'),
+    label: String(c.label ?? c.node_id ?? ''),
+    member: c.member == null ? null : String(c.member),
+    before: names(c.before), after: names(c.after), added: names(c.added), removed: names(c.removed),
+  }))
+}
+
+/** 「数据查询」/「销售分析团队」的成员「取数员」 */
+const changeWho = (c: ToolChange): string =>
+  c.member ? `「${c.label}」的成员「${c.member}」` : `「${c.label}」`
+
+/** 自查带回的「工具被去掉了」警告（code=tools_dropped）。check 里有就用它，否则看 final.issues */
+function droppedOf(op: CopilotOp): CopilotIssue[] {
+  const list: any[] = [...(Array.isArray(op.warnings) ? op.warnings : []),
+                       ...(op.op === 'final' && Array.isArray(op.issues) ? op.issues : [])]
+  return list.filter((x) => x && typeof x === 'object' && x.code === 'tools_dropped').map(parseIssue)
+}
+
 function skippedTypes(op: CopilotOp): string[] {
   const issues: any[] = Array.isArray(op.issues) ? op.issues : []
   return [...new Set(issues
@@ -1983,10 +2256,17 @@ export interface CopilotOutcome {
   updated: number
   removed: number
   error?: { message: string; hint?: string; raw?: string }
+  /** 工具绑定变化（final.tool_changes）。removed 非空的那几处要提醒 */
+  toolChanges: ToolChange[]
+  /** 自查的「工具被去掉了」警告（tools_dropped）：这一轮的要求里没提到去掉 */
+  dropped: CopilotIssue[]
 }
 
 export function copilotOutcome(ops: CopilotOp[], running = false): CopilotOutcome {
-  const res: CopilotOutcome = { kind: running ? 'running' : 'empty', skipped: [], added: 0, updated: 0, removed: 0 }
+  const res: CopilotOutcome = {
+    kind: running ? 'running' : 'empty', skipped: [], added: 0, updated: 0, removed: 0,
+    toolChanges: [], dropped: [],
+  }
   for (const op of ops) {
     switch (op.op) {
       case 'add_node': res.added += 1; break
@@ -2006,12 +2286,16 @@ export function copilotOutcome(ops: CopilotOp[], running = false): CopilotOutcom
             repaired: num(op.repaired) ?? 0,
             issues,
           }
+          res.dropped = droppedOf(op)
         }
         break
       }
       case 'final':
         res.total = op.graph?.nodes?.length
         res.skipped = skippedTypes(op)
+        res.toolChanges = toolChangesOf(op)
+        // 同一批警告 final.issues 里也有一份：自查已经带回来了就不再算一遍
+        if (!res.dropped.length) res.dropped = droppedOf(op)
         if (!running) res.kind = 'built'
         break
       case 'error':
diff --git a/frontend/src/run/trace.ts b/frontend/src/run/trace.ts
index ad317d65..da4281bc 100644
--- a/frontend/src/run/trace.ts
+++ b/frontend/src/run/trace.ts
@@ -43,6 +43,12 @@ export interface Segment {
   resumed?: boolean
 }
 
+/**
+ * 用量刻度：这一刻为止的累计 [时刻, 输入 tokens, 输出 tokens, 成本, 工具调用次数, 在跑的工具数]。
+ * 只在数变了的时候记一条（llm.end、tool.start、tool.end / tool.error）
+ */
+export type UsageMark = [at: number, tokensIn: number, tokensOut: number, costUsd: number, tools: number, toolsRunning: number]
+
 export interface NodeTrace {
   id: string
   state: NodeState
@@ -74,6 +80,8 @@ export interface NodeTrace {
   taken?: string[]
   /** 分支命中的理由 */
   reason?: string
+  /** 用量随时间的累计，回放时按游标取那一刻的 tokens 和工具数。没调过模型和工具的节点没有 */
+  marks?: UsageMark[]
 }
 
 export interface Trace {
@@ -103,6 +111,11 @@ export interface Trace {
   lastSeq: number
   /** [时刻, 此刻同时在跑的数量]，只在数量变化时记一条 */
   parallelSeries: [number, number][]
+  /**
+   * [时刻, 输入 tokens, 输出 tokens, 成本]：各次 llm.end 累加到这一刻的整次运行用量。
+   * run.finished 用后端累计校正 tokensIn 等总数时不记在这里——那不是某一刻的读数
+   */
+  usageSeries: [number, number, number, number][]
 
   /** false = 老数据没有 ts：段按顺序排、宽度只来自 duration_ms，墙钟和等人时长不可知 */
   timed: boolean
@@ -155,7 +168,29 @@ export interface Projection {
   nodesDone: number
   nodesTotal: number
   parallelNow: number
-  nodes: Record<string, { state: NodeState; elapsedMs?: number; count: number; iteration?: number }>
+  /**
+   * 这一刻为止的整次运行用量。回放时如果各次 llm.end 加起来对不上后端的总数（老
+   * 后端的 agent / 协作调用不发 llm.end），那一刻的读数不可信，给 undefined，不拿
+   * 终值冒充
+   */
+  tokensIn?: number
+  tokensOut?: number
+  costUsd?: number
+  nodes: Record<string, ProjectedNode>
+}
+
+export interface ProjectedNode {
+  state: NodeState
+  elapsedMs?: number
+  count: number
+  iteration?: number
+  /** 这一刻为止这个节点的用量和工具调用次数（实时就是当前值） */
+  tokensIn: number
+  tokensOut: number
+  costUsd: number
+  tools: number
+  /** 这一刻正在跑的工具数。节点不在跑时是 0 */
+  toolsRunning: number
 }
 
 // 流式增量：后端不落库，刷新后也不会回来。航迹不能建立在它们之上
@@ -194,10 +229,17 @@ export function runStatusOf(phase: RunPhase): RunStatus | null {
  */
 export const liveAt = (t: Trace, now: number): number => now - (t.skewMs ?? 0)
 
+/**
+ * 最后一条事件的时刻（毫秒；没有 ts 的老数据是按时长推出来的虚拟时钟）。
+ * project(t, lastEventAt(t)) 就是「此刻的样子」：节点的当前状态（含推导出的阻断、
+ * 未到达）和后端给的权威时长都在，而不是按段重建的回放
+ */
+export const lastEventAt = (t: Trace): number => t.book.clock
+
 export function emptyTrace(): Trace {
   return {
     phase: 'idle', waitMs: 0, nodes: {}, tokensIn: 0, tokensOut: 0, costUsd: 0,
-    lastSeq: 0, parallelSeries: [], timed: true, drives: [], waits: [], phases: [],
+    lastSeq: 0, parallelSeries: [], usageSeries: [], timed: true, drives: [], waits: [], phases: [],
     lastReplay: false,
     book: { clock: 0, awaiting: false, dispatchFrom: {}, exactDispatch: {}, asking: {} },
   }
@@ -390,6 +432,10 @@ export function foldEvent(t: Trace, ev: RunEvent): Trace {
     const last = next.drives[next.drives.length - 1]
     if (!last || last[1] != null) next.drives = [...next.drives, [dr.at, null]]
   }
+  /** 节点的用量、工具数变了：记一条刻度，回放才知道那一刻是多少 */
+  const mark = (n: NodeTrace) => {
+    n.marks = [...(n.marks ?? []), [at, n.tokensIn, n.tokensOut, n.costUsd, n.tools, n.toolsRunning]]
+  }
   /** 续跑、恢复之后：上一回合的失败、推出来的"被阻断 / 没走到"都不再成立 */
   const reopen = () => {
     next.endedAt = undefined
@@ -479,7 +525,7 @@ export function foldEvent(t: Trace, ev: RunEvent): Trace {
         n.endedAt = undefined
         n.lastDurationMs = undefined
         n.error = undefined
-        n.toolsRunning = 0
+        if (n.toolsRunning) { n.toolsRunning = 0; mark(n) }
         if (num(d.iteration) != null) n.iteration = num(d.iteration)
         book().dispatchFrom[nodeId] = at
       }
@@ -546,7 +592,8 @@ export function foldEvent(t: Trace, ev: RunEvent): Trace {
       if (!tsOk) at = dr.at = Math.max(at, end)
       n.endedAt = end
       n.lastDurationMs = ms ?? (open >= 0 ? Math.max(0, end - n.segments[open].start) : undefined)
-      n.toolsRunning = 0
+      // 漏了 tool.end 的工具随节点一起收掉；记一条刻度，下一轮回放时不带着上一轮的「在跑」
+      if (n.toolsRunning) { n.toolsRunning = 0; mark(n) }
       n.looping = looping
       n.state = failed ? 'failed' : looping ? 'running' : 'done'
       if (failed) {
@@ -602,12 +649,17 @@ export function foldEvent(t: Trace, ev: RunEvent): Trace {
         const n = node(nodeId)
         n.tools += 1
         n.toolsRunning += 1
+        mark(n)
       }
       break
 
     case 'tool.end':
     case 'tool.error':
-      if (nodeId && next.nodes[nodeId]?.toolsRunning) node(nodeId).toolsRunning -= 1
+      if (nodeId && next.nodes[nodeId]?.toolsRunning) {
+        const n = node(nodeId)
+        n.toolsRunning -= 1
+        mark(n)
+      }
       break
 
     case 'llm.start':
@@ -621,12 +673,14 @@ export function foldEvent(t: Trace, ev: RunEvent): Trace {
       next.tokensIn += inTok
       next.tokensOut += outTok
       next.costUsd += cost
+      next.usageSeries = [...next.usageSeries, [at, next.tokensIn, next.tokensOut, next.costUsd]]
       if (nodeId) {
         const n = node(nodeId)
         n.tokensIn += inTok
         n.tokensOut += outTok
         n.costUsd += cost
         if (d.model) n.model = String(d.model)
+        mark(n)
       }
       break
     }
@@ -849,6 +903,19 @@ function phaseAt(t: Trace, at: number): RunPhase {
 const clipped = (spans: [number, number | null][], at: number): number =>
   spans.reduce((acc, [s, e]) => (s > at ? acc : acc + Math.max(0, Math.min(e ?? at, at) - s)), 0)
 
+/** 按时刻排好的序列里，不晚于 at 的最后一条 */
+function lastAt<T extends [number, ...unknown[]]>(series: T[] | undefined, at: number): T | undefined {
+  if (!series?.length || series[0][0] > at) return undefined
+  let lo = 0
+  let hi = series.length - 1
+  while (lo < hi) {
+    const mid = (lo + hi + 1) >> 1
+    if (series[mid][0] <= at) lo = mid
+    else hi = mid - 1
+  }
+  return series[lo]
+}
+
 /**
  * 把航迹投影到某一刻：实时时 at 取 liveAt(trace, now)，回放时取游标。
  *
@@ -870,7 +937,7 @@ export function project(t: Trace, at: number): Projection {
   const nodes: Projection['nodes'] = {}
   let nodesDone = 0
   for (const n of Object.values(t.nodes)) {
-    let view: Projection['nodes'][string]
+    let view: ProjectedNode
     if (live) {
       const open = n.segments[openIndex(n.segments, 'run')]
       view = {
@@ -880,6 +947,8 @@ export function project(t: Trace, at: number): Projection {
         ...(open && n.state === 'running'
           ? { elapsedMs: Math.max(0, (t.timed ? at : t.book.clock) - open.start) }
           : n.lastDurationMs != null ? { elapsedMs: n.lastDurationMs } : {}),
+        tokensIn: n.tokensIn, tokensOut: n.tokensOut, costUsd: n.costUsd, tools: n.tools,
+        toolsRunning: n.state === 'running' ? n.toolsRunning : 0,
       }
     } else {
       let state: NodeState = 'idle'
@@ -903,8 +972,17 @@ export function project(t: Trace, at: number): Projection {
           elapsedMs = s.end - s.start
         }
       }
-      view = { state, count, ...(iteration != null ? { iteration } : {}),
-               ...(elapsedMs != null ? { elapsedMs } : {}) }
+      // 没有刻度 = 到这一刻为止没有过 llm.end / tool.start，就是 0
+      const m = lastAt(n.marks, at)
+      view = {
+        state, count, ...(iteration != null ? { iteration } : {}),
+        ...(elapsedMs != null ? { elapsedMs } : {}),
+        tokensIn: m?.[1] ?? 0,
+        tokensOut: m?.[2] ?? 0,
+        costUsd: m?.[3] ?? 0,
+        tools: m?.[4] ?? 0,
+        toolsRunning: state === 'running' ? m?.[5] ?? 0 : 0,
+      }
     }
     if (view.state === 'done' || view.state === 'skipped') nodesDone += 1
     nodes[n.id] = view
@@ -918,9 +996,22 @@ export function project(t: Trace, at: number): Projection {
     }
   }
 
+  // 整次运行的用量：实时读总数（终态时已按后端校正）；回放读刻度，但刻度加起来得
+  // 对得上总数才算数
+  let usage: Pick<Projection, 'tokensIn' | 'tokensOut' | 'costUsd'> = {}
+  if (live) {
+    usage = { tokensIn: t.tokensIn, tokensOut: t.tokensOut, costUsd: t.costUsd }
+  } else {
+    const final = t.usageSeries[t.usageSeries.length - 1]
+    const complete = final ? final[1] === t.tokensIn && final[2] === t.tokensOut
+      : t.tokensIn === 0 && t.tokensOut === 0
+    const u = complete ? lastAt(t.usageSeries, at) : undefined
+    if (complete) usage = { tokensIn: u?.[1] ?? 0, tokensOut: u?.[2] ?? 0, costUsd: u?.[3] ?? 0 }
+  }
+
   return {
     phase, elapsedMs, activeMs, waitMs, nodesDone,
     nodesTotal: t.nodesTotal ?? Object.keys(t.nodes).length,
-    parallelNow, nodes,
+    parallelNow, ...usage, nodes,
   }
 }
diff --git a/frontend/src/run/useNodeView.ts b/frontend/src/run/useNodeView.ts
index 7e48ba46..0202e44b 100644
--- a/frontend/src/run/useNodeView.ts
+++ b/frontend/src/run/useNodeView.ts
@@ -1,7 +1,18 @@
 import { useStudio } from '../store/studio'
 import { applyDerived, type GraphLike } from './derive'
 import { project, type NodeState, type NodeTrace, type Projection, type Trace } from './trace'
-import type { NodeRuntime } from '../types'
+import type { NodeRuntime, RunEvent } from '../types'
+
+/** 某一刻为止的用量：实时是航迹上的累计，回放是那一刻的刻度 */
+export interface NodeUsage {
+  tokensIn: number
+  tokensOut: number
+  costUsd: number
+  tools: number
+  toolsRunning: number
+}
+
+const NO_USAGE: NodeUsage = { tokensIn: 0, tokensOut: 0, costUsd: 0, tools: 0, toolsRunning: 0 }
 
 /**
  * 节点卡取状态的唯一入口。
@@ -24,6 +35,8 @@ export interface NodeView {
   /** 执行了几次（循环、接着跑都会 > 1）。回放时是那一刻之前的次数 */
   count: number
   iteration?: number
+  /** token 和工具次数。回放时是游标那一刻的读数，不拿终值冒充 */
+  usage: NodeUsage
   /** 回放时这一刻的执行用时（进行中是已经用了多久，结束了是那一段的用时） */
   replayElapsedMs?: number
   /** 回放游标（毫秒时间戳）；实时为 null。卡片据此把计时、协作矩阵截到那一刻 */
@@ -110,6 +123,7 @@ export function useNodeView(id: string): NodeView {
       trace: node,
       count: projected?.count ?? 0,
       iteration: projected?.iteration,
+      usage: projected ?? NO_USAGE,
       replayElapsedMs: projected?.elapsedMs,
       at,
       looping: !!derived?.looping,
@@ -122,11 +136,305 @@ export function useNodeView(id: string): NodeView {
     trace: node,
     count: node?.count ?? 0,
     iteration: node?.iteration ?? runtime?.iteration,
+    usage: node ?? NO_USAGE,
     at: null,
     looping: !!node?.looping,
   }
 }
 
+// -------------------------------------------------------------------------
+// 节点上的几件"事"：航迹只记状态和用量，这些要从事件里捞
+// -------------------------------------------------------------------------
+
+/** 一次工具调用的起止。时刻都是毫秒，和航迹同一条时间轴 */
+export interface ToolSpan {
+  tool: string
+  agent?: string
+  callId?: string
+  start: number
+  end?: number
+  /** 后端声明的时限（tool.start.timeout_s）。没声明的工具不掐时 */
+  limitS?: number
+  ok?: boolean
+  timedOut?: boolean
+}
+
+/** 某件事什么时候发生、原话怎么说 */
+export interface FactMark {
+  at: number
+  message: string
+}
+
+/**
+ * 模型把工具调用写成了文字（log code=tool_markup_leak）。后端在两种时候发它：
+ * 写成文字被提醒、重答了（nudge，「…已提醒它重试一次」），成果是重答的那一次；
+ * 步数用完后的收尾轮还想要工具（settle，「…收尾轮仍想调用工具」），交出来的是
+ * 它前面写的内容，可能不完整。两件事对成果的意思不一样，卡片分开说
+ */
+export interface MarkupMark extends FactMark {
+  settle: boolean
+}
+
+/**
+ * 协作团队的收尾判定：轮数用完之后调度者只判定、不派活的那一次决定。它不是新的
+ * 一轮，矩阵不给它加一列。at 是开始判定（agent.route.start），end 是给出结论
+ */
+export interface ClosingMark {
+  at: number
+  end?: number
+  round: number
+  done: boolean
+  reason: string
+}
+
+/** 协作成员失败（agent.step.end 的 failed / error） */
+export interface MemberFail {
+  at: number
+  agent: string
+  error: string
+}
+
+/**
+ * 卡片要说清的几件事。它们都藏在事件里：log 的 code、agent.route 的 closing、
+ * tool.start 的 timeout_s——航迹不存，runtime 也不存。按节点归好，卡片直接取。
+ *
+ * 一次运行里同一个节点会执行好几次（循环体每一轮、失败后接着跑），每件事都按
+ * 先后留着：卡片只说游标所在的那一次执行里发生的（见 execStart、lastIn），上一次
+ * 用完轮数、收尾时还想调工具，不能挂到这一次干干净净的结果上
+ */
+export interface NodeFacts {
+  /** 整次运行里的工具调用，按开始先后。回放按游标截 */
+  calls: ToolSpan[]
+  /**
+   * 最近一次执行从什么时候开始（审批恢复的重放不算新的一次，接着跑算）。
+   * 卡片取执行的起点用 execStart：它和卡片上的执行次数同出航迹，回放也认得
+   */
+  since: number
+  /** 在等审批：这之后再来的 node.started 是恢复重放，不是新的一次执行 */
+  paused?: boolean
+  /** 下面三个是整次运行里最后的那一次，给只看整次运行的地方；卡片用对应的列表 */
+  markup?: MarkupMark
+  exhausted?: FactMark
+  invented?: FactMark
+  /** 模型把工具调用写成了文字，每次都留着 */
+  markups: MarkupMark[]
+  /** 协作团队轮数用完、按降档交付（log code=team_exhausted） */
+  exhausts: FactMark[]
+  /** 修复被拒：结果里出现了原文没有的值（log code=repair_invented） */
+  inventions: FactMark[]
+  closings: ClosingMark[]
+  memberErrors: MemberFail[]
+  /** 每一次失败的报错（node.failed）。回放到更早的一次失败时取那一次的原话 */
+  failures: FactMark[]
+  /** 校验修复调模型的时刻（llm.end purpose=repair），按先后 */
+  repairs: number[]
+}
+
+const EMPTY_FACTS: NodeFacts = {
+  calls: [], since: 0, markups: [], exhausts: [], inventions: [], closings: [], memberErrors: [], failures: [], repairs: [],
+}
+
+const tsOf = (e: RunEvent): number | undefined =>
+  (typeof e.ts === 'number' && Number.isFinite(e.ts) ? e.ts * 1000 : undefined)
+
+/**
+ * 事件落到哪个节点上。等审批的两条有时不带 node_id，节点写在 data 里
+ */
+function factNode(e: RunEvent, d: Record<string, any>): string | undefined {
+  if (e.node_id) return e.node_id
+  if (e.type === 'run.interrupted' && d.payload?.node_id) return String(d.payload.node_id)
+  if (e.type === 'human.requested' && d.node_id) return String(d.node_id)
+  return undefined
+}
+
+/** clock：没带时间戳的事件记在最近一个时间戳上，和航迹的时间轴一致 */
+function foldFacts(map: Record<string, NodeFacts>, e: RunEvent, clock: number): void {
+  const d = (e.data ?? {}) as Record<string, any>
+  const id = factNode(e, d)
+  if (!id) return
+  const at = tsOf(e) ?? clock
+  const cur = map[id] ?? EMPTY_FACTS
+  let next: NodeFacts | null = null
+  switch (e.type) {
+    case 'node.started':
+      // 和航迹同一条规则：只有等审批之后的那次重放接着算同一次执行。接着跑时
+      // 后端也给失败的节点标 resumed，但那是重新执行，上一次的事不再算它的
+      next = cur.paused ? { ...cur, paused: false } : { ...cur, since: at }
+      break
+    case 'human.requested':
+    case 'run.interrupted':
+      if (!cur.paused) next = { ...cur, paused: true }
+      break
+    case 'node.finished':
+    case 'node.skipped':
+      if (cur.paused) next = { ...cur, paused: false }
+      break
+    case 'node.failed':
+      next = {
+        ...cur, paused: false,
+        failures: [...cur.failures, { at, message: typeof d.error === 'string' ? d.error : '' }],
+      }
+      break
+    case 'tool.start': {
+      const limit = Number(d.timeout_s)
+      next = {
+        ...cur,
+        calls: [...cur.calls, {
+          tool: String(d.tool ?? ''), start: at,
+          ...(d.agent != null ? { agent: String(d.agent) } : {}),
+          ...(d.call_id != null ? { callId: String(d.call_id) } : {}),
+          ...(Number.isFinite(limit) && limit > 0 ? { limitS: limit } : {}),
+        }],
+      }
+      break
+    }
+    case 'tool.end':
+    case 'tool.error': {
+      // 有 call_id 按它配；老事件没有就按「同一个成员、同名、还开着的最后一次」
+      const tool = String(d.tool ?? '')
+      let i = -1
+      for (let k = cur.calls.length - 1; k >= 0; k -= 1) {
+        const c = cur.calls[k]
+        if (c.end != null) continue
+        if (d.call_id != null ? c.callId === String(d.call_id)
+          : c.tool === tool && (d.agent == null || c.agent === String(d.agent))) { i = k; break }
+      }
+      if (i < 0) break
+      const calls = [...cur.calls]
+      calls[i] = { ...calls[i], end: at, ok: e.type === 'tool.end', ...(d.timed_out ? { timedOut: true } : {}) }
+      next = { ...cur, calls }
+      break
+    }
+    case 'log': {
+      const message = String(d.message ?? '')
+      if (d.code === 'tool_markup_leak') {
+        const mark = { at, message, settle: /收尾轮/.test(message) }
+        next = { ...cur, markup: mark, markups: [...cur.markups, mark] }
+      } else if (d.code === 'team_exhausted') {
+        next = { ...cur, exhausted: { at, message }, exhausts: [...cur.exhausts, { at, message }] }
+      } else if (d.code === 'repair_invented') {
+        next = { ...cur, invented: { at, message }, inventions: [...cur.inventions, { at, message }] }
+      }
+      break
+    }
+    case 'agent.route.start':
+      if (d.closing) {
+        next = { ...cur, closings: [...cur.closings, { at, round: Number(d.round) || 0, done: false, reason: '' }] }
+      }
+      break
+    case 'agent.route.end':
+      if (d.closing) {
+        // 收掉开着的那一次；老后端没发 route.start 时起止记成同一刻
+        const last = cur.closings[cur.closings.length - 1]
+        const open = last && last.end == null ? last : undefined
+        const mark: ClosingMark = {
+          at: open?.at ?? at, end: at, round: Number(d.round) || 0, done: d.done === true, reason: String(d.reason ?? ''),
+        }
+        next = { ...cur, closings: open ? [...cur.closings.slice(0, -1), mark] : [...cur.closings, mark] }
+      }
+      break
+    case 'agent.step.end':
+      if (d.failed || d.error) {
+        const agent = String(d.agent ?? '')
+        const error = typeof d.error === 'string' && d.error.trim() ? d.error.trim() : '这一步失败了，没有给出原因'
+        next = { ...cur, memberErrors: [...cur.memberErrors, { at, agent, error }] }
+      }
+      break
+    case 'llm.end':
+      if (d.purpose === 'repair') next = { ...cur, repairs: [...cur.repairs, at] }
+      break
+  }
+  if (next) map[id] = next
+}
+
+/**
+ * 事件只会往后追加：上一次折到第几条就从第几条接着折，每来一条只做一条的事。
+ * 没变的节点沿用原对象，卡片的选择器拿到的引用不变，不会跟着别的节点重渲染
+ */
+let factsMemo: { events: RunEvent[]; map: Record<string, NodeFacts>; clock: number } | null = null
+
+export function factsOf(events: RunEvent[]): Record<string, NodeFacts> {
+  const memo = factsMemo
+  if (memo && memo.events === events) return memo.map
+  const n = memo?.events.length ?? 0
+  const appended = !!memo && events.length >= n && (n === 0 || events[n - 1] === memo.events[n - 1])
+  const map: Record<string, NodeFacts> = appended ? { ...memo!.map } : {}
+  let clock = appended ? memo!.clock : 0
+  for (let i = appended ? n : 0; i < events.length; i += 1) {
+    const ts = tsOf(events[i])
+    if (ts != null && ts > clock) clock = ts
+    foldFacts(map, events[i], clock)
+  }
+  factsMemo = { events, map, clock }
+  return map
+}
+
+export function useNodeFacts(id: string): NodeFacts | undefined {
+  return useStudio((s) => factsOf(s.events)[id])
+}
+
+/**
+ * 卡片在说的那一次执行从什么时候开始：游标那一刻（实时是最后）所在的那一次。
+ *
+ * 取航迹上最后一段已经开始的执行段——卡片头上的「×N」、回放时的状态都出自航迹，
+ * 事实跟着同一个划分走，才不会说成两次执行。审批恢复接回的段（resumed）和中断前
+ * 是同一次，不算起点；接着跑、循环的下一轮是新的一次。航迹里没有这个节点时退回
+ * 事件里记的起点，回放时就不截
+ */
+export function execStart(n: NodeTrace | undefined, at: number | null, facts?: NodeFacts): number {
+  const segs = n?.segments ?? []
+  for (let i = segs.length - 1; i >= 0; i -= 1) {
+    const s = segs[i]
+    if (s.kind !== 'run' || s.resumed || (at != null && s.start > at)) continue
+    return s.start
+  }
+  return at == null ? facts?.since ?? -Infinity : -Infinity
+}
+
+/** 从 since 到游标那一刻（实时到最后）之间的那几件，按先后 */
+export function within<T extends { at: number }>(list: readonly T[] | undefined, at: number | null, since = -Infinity): T[] {
+  return (list ?? []).filter((x) => x.at >= since && (at == null || x.at <= at))
+}
+
+/** 从 since 到游标那一刻之间最后的那一件 */
+export function lastIn<T extends { at: number }>(list: readonly T[] | undefined, at: number | null, since = -Infinity): T | undefined {
+  const all = list ?? []
+  for (let i = all.length - 1; i >= 0; i -= 1) {
+    const x = all[i]
+    if (at != null && x.at > at) continue
+    return x.at >= since ? x : undefined
+  }
+  return undefined
+}
+
+/**
+ * 某一刻在跑的那次工具调用（回放给游标，实时给 null）。多个同时开着时取最后开的，
+ * 卡片槽里只放得下一个名字。since 是这一次执行的起点：上一次撒手没收尾的调用不算
+ */
+export function openCall(facts: NodeFacts | undefined, at: number | null,
+                         since = at == null ? facts?.since ?? 0 : -Infinity): ToolSpan | undefined {
+  const calls = facts?.calls ?? []
+  for (let i = calls.length - 1; i >= 0; i -= 1) {
+    const c = calls[i]
+    if (c.start < since) continue
+    if (at == null ? c.end == null : c.start <= at && (c.end == null || c.end > at)) return c
+  }
+  return undefined
+}
+
+/** 这一次执行里校验修复了几次。回放时数到游标为止 */
+export function repairsOf(facts: NodeFacts | undefined, at: number | null,
+                          since = at == null ? facts?.since ?? 0 : -Infinity): number {
+  return (facts?.repairs ?? []).filter((t) => t >= since && (at == null || t <= at)).length
+}
+
+/**
+ * 某件事在游标那一刻发生了没有（实时一律算发生了）。给了 since 就只认这一次执行里的。
+ * 这里只有最后那一件：回放到更早的一次执行时它可能还没发生，要逐次看就用 lastIn
+ */
+export const happened = <T extends { at: number }>(fact: T | undefined, at: number | null, since = -Infinity): T | undefined =>
+  (fact && (at == null || fact.at <= at) && fact.at >= since ? fact : undefined)
+
 /**
  * 最后一段还开着的某类段从什么时候开始。实时计时从这里起算。
  * 给了回放游标就只看那一刻：那时已经开始、还没结束的段
diff --git a/frontend/src/store/catalog.ts b/frontend/src/store/catalog.ts
index 2e133665..6150c812 100644
--- a/frontend/src/store/catalog.ts
+++ b/frontend/src/store/catalog.ts
@@ -12,9 +12,12 @@ import type { Approval, Provider, Skill, ToolInfo, Workflow } from '../types'
  */
 export type BackendState = 'checking' | 'ok' | 'down'
 
+/** catalog 里的一张表 */
+export type CatalogKey = 'providers' | 'tools' | 'skills' | 'collections' | 'workflows' | 'approvals'
+
 /** 启动清单里的一行：catalog.refresh 的一个真实请求 */
 export interface CatalogCheck {
-  key: 'providers' | 'tools' | 'skills' | 'collections' | 'workflows' | 'approvals'
+  key: CatalogKey
   label: string
   state: 'pending' | 'ok' | 'error'
   ms?: number
@@ -22,25 +25,45 @@ export interface CatalogCheck {
   error?: string
 }
 
-const CHECK_LABELS: Record<CatalogCheck['key'], string> = {
+/** 各张表的中文名。启动清单、「正在读取工作流」这类空态用 */
+export const CATALOG_LABELS: Record<CatalogKey, string> = {
   providers: '模型接入', tools: '工具', skills: 'Skill',
   collections: '知识库', workflows: '工作流', approvals: '待审批',
 }
 
+const CATALOG_KEYS = Object.keys(CATALOG_LABELS) as CatalogKey[]
+
+/**
+ * refresh 里每个请求最多等多久。一个接口卡住（MCP 服务不应答时的 /tools）不能
+ * 让它那张表永远停在「加载中」；到点掐断、记成出错，别的表不受影响
+ */
+export const CATALOG_TIMEOUT_MS = 15_000
+
 /** 心跳间隔：连着时复用 4 秒一次的待审批轮询，不另起请求 */
 const HEARTBEAT_MS = 4000
 /** 断开后的重试退避 */
 const BACKOFF_MS = [4000, 8000, 16000]
 
 /** 全局参照数据：属性面板的各种下拉都从这里取，只加载一次。 */
-interface CatalogState {
+export interface CatalogState {
   providers: Provider[]
   tools: ToolInfo[]
   skills: Skill[]
   collections: { collection: string; documents: number; chunks: number }[]
   workflows: Workflow[]
   approvals: Approval[]
+  /**
+   * 启动后的第一次 refresh 已经落定（每个请求都回来了或超时了）。只从 false 变 true，
+   * 之后的刷新不会把它打回去——所以它不能回答「这张表是真的空还是没取到」，那个
+   * 看 loadedAt / catalogListState
+   */
   loaded: boolean
+  /** 每张表最近一次成功取回的时刻（ms）。没有这一项 = 从没取到过，空列表不能当「没有」 */
+  loadedAt: Partial<Record<CatalogKey, number>>
+  /**
+   * 重拉全部六张表，谁先回来先填谁：一张表卡住不拖累别的表。每个请求最多等
+   * CATALOG_TIMEOUT_MS，超时记成那一项出错
+   */
   refresh: () => Promise<void>
   refreshApprovals: () => Promise<void>
 
@@ -71,6 +94,9 @@ let probing: Promise<boolean> | null = null
 let retryTimer: ReturnType<typeof setTimeout> | undefined
 let heartbeatOwner: symbol | null = null
 let markUpRef: (latencyMs?: number) => void = () => {}
+/** 第几次 refresh。两次 refresh 交叠时，晚发的那次的结果不能被早发、晚到的覆盖 */
+let refreshEpoch = 0
+const appliedGen: Partial<Record<CatalogKey, number>> = {}
 
 export const useCatalog = create<CatalogState>((set, get) => {
   let backoffStep = 0
@@ -112,6 +138,7 @@ export const useCatalog = create<CatalogState>((set, get) => {
     workflows: [],
     approvals: [],
     loaded: false,
+    loadedAt: {},
 
     backend: 'checking',
     latencyMs: null,
@@ -122,41 +149,50 @@ export const useCatalog = create<CatalogState>((set, get) => {
     reconnects: 0,
 
     refresh: async () => {
-      const keys = Object.keys(CHECK_LABELS) as CatalogCheck['key'][]
-      set({ checks: keys.map((key) => ({ key, label: CHECK_LABELS[key], state: 'pending' })) })
-      const update = (key: CatalogCheck['key'], patch: Partial<CatalogCheck>) =>
+      const gen = ++refreshEpoch
+      const keys = CATALOG_KEYS
+      set({ checks: keys.map((key) => ({ key, label: CATALOG_LABELS[key], state: 'pending' })) })
+      // 清单只归最新一次 refresh 写：交叠时早发的那次别把新清单的行改回去
+      const update = (key: CatalogKey, patch: Partial<CatalogCheck>) => {
+        if (gen !== refreshEpoch) return
         set((s) => ({ checks: s.checks.map((c) => (c.key === key ? { ...c, ...patch } : c)) }))
+      }
+      const opts = { timeoutMs: CATALOG_TIMEOUT_MS }
+      const fetchers: Record<CatalogKey, () => Promise<unknown[]>> = {
+        providers: () => api.providers.list(opts),
+        tools: () => api.tools.list(opts),
+        skills: () => api.skills.list(opts),
+        collections: () => api.kb.collections(opts),
+        workflows: () => api.workflows.list(opts),
+        approvals: () => api.approvals.list('pending', opts),
+      }
 
       let networkFailures = 0
-      let lastError = ''
-      // 单项失败不该让整个面板空掉，各自兜底；但要记下是不是"够不着"，
-      // 六个全是网络失败就是后端断了，不是"什么都没有"
-      const track = <T>(key: CatalogCheck['key'], p: Promise<T>): Promise<T | []> => {
+      // 各张表回来一张填一张：以前是 Promise.all 全到齐才一起写，/tools 卡着不回，
+      // 工作流也跟着一直是空的，编排页就说「还没有工作流」。单项失败各自兜底，
+      // 列表保持原样（不清成 []）；但要记下是不是"够不着"，六个全是网络失败就是
+      // 后端断了，不是"什么都没有"
+      const track = async (key: CatalogKey) => {
         const t0 = performance.now()
-        return p.then(
-          (v) => { update(key, { state: 'ok', ms: Math.round(performance.now() - t0) }); return v },
-          (e: unknown) => {
-            const err = e instanceof ApiError ? e : null
-            if (err?.kind === 'network') networkFailures++
-            lastError = err?.message ?? String((e as any)?.message ?? e)
-            update(key, {
-              state: 'error', ms: Math.round(performance.now() - t0),
-              status: err?.status || undefined, error: lastError,
-            })
-            return []
-          },
-        )
+        try {
+          const rows = await fetchers[key]()
+          update(key, { state: 'ok', ms: Math.round(performance.now() - t0) })
+          if ((appliedGen[key] ?? 0) > gen) return
+          appliedGen[key] = gen
+          set((s) => ({ [key]: rows, loadedAt: { ...s.loadedAt, [key]: Date.now() } }) as Partial<CatalogState>)
+        } catch (e) {
+          const err = e instanceof ApiError ? e : null
+          if (err?.kind === 'network') networkFailures++
+          update(key, {
+            state: 'error', ms: Math.round(performance.now() - t0),
+            status: err?.status || undefined,
+            error: err?.message ?? String((e as any)?.message ?? e),
+          })
+        }
       }
       const t0 = performance.now()
-      const [providers, tools, skills, collections, workflows, approvals] = await Promise.all([
-        track('providers', api.providers.list()),
-        track('tools', api.tools.list()),
-        track('skills', api.skills.list()),
-        track('collections', api.kb.collections()),
-        track('workflows', api.workflows.list()),
-        track('approvals', api.approvals.list()),
-      ])
-      set({ providers, tools, skills, collections, workflows, approvals, loaded: true })
+      await Promise.all(keys.map(track))
+      if (!get().loaded) set({ loaded: true })
       if (networkFailures === keys.length) {
         // 第一个失败的请求已经通过 onConnectivity 起了一次探活；这里并进同一次，
         // 不另记一笔——两笔会让第一次断开就跳到退避的第二档（8 秒而不是 4 秒）
@@ -176,8 +212,14 @@ export const useCatalog = create<CatalogState>((set, get) => {
       }
       const t0 = performance.now()
       try {
-        const approvals = await api.approvals.list()
-        set({ approvals, latencyMs: Math.round(performance.now() - t0), lastOkAt: Date.now() })
+        const gen = refreshEpoch
+        const approvals = await api.approvals.list('pending', { timeoutMs: CATALOG_TIMEOUT_MS })
+        // 这一拍在路上时又发起了 refresh、而且那次已经填过了：以那次为准
+        if ((appliedGen.approvals ?? 0) > gen) return
+        set((s) => ({
+          approvals, latencyMs: Math.round(performance.now() - t0), lastOkAt: Date.now(),
+          loadedAt: { ...s.loadedAt, approvals: Date.now() },
+        }))
       } catch (e) {
         // 后端回了错误码说明它还活着，列表保持原样；够不着才去确认是否断开
         if (e instanceof ApiError && e.kind === 'network' && get().backend !== 'down') await get().checkBackend()
@@ -251,6 +293,29 @@ export function useOnReconnect(cb: () => void): void {
   }), [])
 }
 
+/**
+ * 某张表眼下能不能当真：
+ * - ok：至少成功取回过一次。之后的刷新失败了，手上的也还是真数据；
+ * - offline：从没取到过，后端也断着；
+ * - loading：从没取到过，请求还在路上（或还没发）；
+ * - error：从没取到过，最近一次请求出错或超时了。
+ * 后三种时列表是空的，但那不是「没有」。
+ */
+export type CatalogListState = 'ok' | 'loading' | 'error' | 'offline'
+
+export function catalogListState(
+  s: Pick<CatalogState, 'loadedAt' | 'backend' | 'checks'>, key: CatalogKey,
+): CatalogListState {
+  if (s.loadedAt[key] != null) return 'ok'
+  if (s.backend === 'down') return 'offline'
+  return s.checks.find((c) => c.key === key)?.state === 'error' ? 'error' : 'loading'
+}
+
+/** 同 catalogListState，订阅版。页面判断「空」之前先看它是不是 ok */
+export function useCatalogListState(key: CatalogKey): CatalogListState {
+  return useCatalog((s) => catalogListState(s, key))
+}
+
 /** 这条运行有没有待处理的审批。区分「等待审批」和「已挂起 · 可续跑」要用它 */
 export function hasPendingApproval(approvals: Approval[], runId: string | null | undefined): boolean {
   if (!runId) return false
diff --git a/frontend/src/store/chat.ts b/frontend/src/store/chat.ts
index 19ef70cc..1be10379 100644
--- a/frontend/src/store/chat.ts
+++ b/frontend/src/store/chat.ts
@@ -2,7 +2,8 @@ import { create } from 'zustand'
 import { ApiError, api, streamCopilot, streamRun } from '../api/client'
 import type { CopilotOp, RunFinal } from '../run/decode'
 import { decodeRun } from '../run/decode'
-import { humanizeError } from '../lib/errors'
+import { errorMessage, humanizeError, isNetworkError } from '../lib/errors'
+import { explainRunError } from '../lib/explain'
 import { parseServerTime } from '../lib/format'
 import { useCatalog } from './catalog'
 import { useConversations } from './conversations'
@@ -45,6 +46,11 @@ export type Phase =
   | 'error'
   | 'cancelled'   // 用户点了停止。不是出错：不画红，也不给「接着跑」
   | 'suspended'   // 服务重启打断了，断点还在，可以接着跑
+  /**
+   * 核对撞上后端出错、超时：不知道它现在是在跑、跑完了还是失败了。只给「重新核对」——
+   * 给「重试」会在旧运行可能还活着的时候另起一次
+   */
+  | 'unknown'
 
 /** 占着这个会话的相位：这时再问一句、或者删掉这个会话，都会撞上正在跑的东西 */
 const BUSY_PHASES: ReadonlySet<Phase> = new Set(['planning', 'building', 'running'])
@@ -56,10 +62,23 @@ export interface Failure {
   hint?: string
   detail?: string
   /**
-   * 翻成人话之前的那句原话。流里的报错块会自己再翻一遍，交给它的得是原话：
-   * 把翻好的「操作超时：查询超时…」再翻一遍，标题和原因就成了两遍「操作超时」
+   * 翻成人话之前的那句原话。运行的失败把它交给流里的报错块按 lib/explain 再讲一遍；
+   * 别的交拆好的 title / reason——把翻好的「操作超时：查询超时…」再翻一遍，标题和
+   * 原因就成了两遍「操作超时」
    */
   source?: string
+  /** 原样接着跑也过不去（缺输入、人驳回、没绑工具…），不给「接着跑」。见 lib/explain */
+  continuable?: false
+  /** 流程本身没问题，是发起那一下没到后端：原图再发起一次就行，不必让 Copilot 重新搭 */
+  rerun?: true
+  /** 限定的数据源都不在了（删了、停用了）。带着原范围重试只会再被拒一次 */
+  scopeGone?: true
+}
+
+/** 限定这一问只查哪些数据源。名字跟着存：库删了之后，这一轮查的是谁还得说得出来 */
+export interface ScopeSource {
+  id: string
+  name: string
 }
 
 /**
@@ -80,12 +99,11 @@ export interface Attempt {
 }
 
 /**
- * 刷新之后还得在的可信度信息。
+ * 刷新之后还得在的可信度信息，存在 conversation_turns.meta。
  *
- * conversation_turns 没有专门放它的列：出具档位、运行类别、「这一条没查库」
- * 以前都只活在内存里，刷新就没了——而历史会话恰恰是事后复盘、转发结论时最常看
- * 的地方。后端补上 meta 列之前，它挂在 review 这个 JSON 字段的 meta 键下：
- * 后端对 review 只读 note，多一个键不影响任何逻辑。读的时候两处都认。
+ * 出具档位、运行类别、「这一条没查库」以前都只活在内存里，刷新就没了——而历史
+ * 会话恰恰是事后复盘、转发结论时最常看的地方。老轮次把它挂在 review.meta 下，
+ * 后端读出来时已经统一放进 meta，这里只认 meta。
  */
 export interface TurnMeta {
   v: 1
@@ -103,6 +121,18 @@ export interface TurnMeta {
   ms?: number
   /** 查了几次库 */
   queries?: number
+  /**
+   * 答案没取全。不记下来的话，刷新之后只能靠「恰好 2000 字」去猜：多个成果键拼起来的
+   * 答案比 2000 长，猜不中，「刷新后会自动补全」的承诺就落空了
+   */
+  clipped?: 'partial' | 'lost'
+  /** 这一问限定了只查哪些数据源 */
+  scope?: ScopeSource[]
+  /**
+   * 这份 meta 写下的时刻（本机时钟）。断在建图阶段的轮次按它和 created_at 里晚的那个算
+   * 有多久没动静：后端按 updated_at 算，而重试一轮昨天的问题时 created_at 是昨天的
+   */
+  at?: number
 }
 
 export interface ChatTurn {
@@ -174,6 +204,8 @@ export interface ChatTurn {
    * 复核完才摆出来，这里给的是「它没卡住」的证据，不是提前看答案的口子
    */
   writing?: { chars: number; thought: string } | null
+  /** 这一问只查这几个数据源。重试、重新问都沿用它 */
+  scope?: ScopeSource[]
 }
 
 export type LoadState = 'loading' | 'ready' | 'error'
@@ -190,12 +222,21 @@ interface ChatState {
    */
   loadState: Record<string, LoadState>
   loadError: Record<string, unknown>
+  /**
+   * 每个会话限定查哪些数据源，空数组 = 不限。键 '' 是还没建出会话的首屏：开口那一下
+   * 建出会话后由调用方带过去。按会话记：换一个会话问别的库，回来还是原来的范围
+   */
+  scopes: Record<string, ScopeSource[]>
+  setScope: (key: string, scope: ScopeSource[]) => void
 
   turnsOf: (conversationId: string | null) => ChatTurn[]
   /** force：已经取回来过也再取一次（重连后、点重试时） */
   load: (conversationId: string, opts?: { force?: boolean }) => Promise<void>
-  /** 发出去了返回 true。会话还在加载或加载失败、或者正忙时不发 */
-  ask: (conversationId: string, question: string) => boolean
+  /**
+   * 发出去了返回 true。会话还在加载或加载失败、或者正忙时不发。
+   * scope 不给就用这个会话眼下的范围
+   */
+  ask: (conversationId: string, question: string, opts?: { scope?: ScopeSource[] }) => boolean
   /** 只停这个会话自己正在跑的那一轮 */
   stop: (conversationId: string) => void
   /** 审批完成后重新接上运行 */
@@ -209,11 +250,17 @@ interface ChatState {
   /**
    * 用户主动重试这一轮：上一次折叠留档，新的一次接在同一轮里。
    * maxSteps：把图里 agent 的步数上限调到这个值，原图重跑（「放宽步数重跑」）；
-   * rerun：原图原样重跑（取消了、中断了的那种，不需要改）
+   * rerun：原图原样重跑（取消了、中断了的那种，不需要改）；
+   * scope：换一个数据源范围重来（限定的库不在了），不给就沿用这一轮的
    */
-  retryTurn: (conversationId: string, turnId: string, opts?: { maxSteps?: number; rerun?: boolean }) => void
+  retryTurn: (
+    conversationId: string, turnId: string,
+    opts?: { maxSteps?: number; rerun?: boolean; scope?: ScopeSource[] },
+  ) => void
   /** 向后端核对一轮历史：真实状态、完整答案、档位。只做一次 */
   hydrate: (conversationId: string, turnId: string) => Promise<void>
+  /** 上次核对撞上后端出错（unknown）的轮次，再核对一次 */
+  recheck: (conversationId: string, turnId: string) => Promise<void>
   /** 会话被删了，把内存里那一桶也丢掉 */
   forget: (conversationId: string) => void
 }
@@ -233,6 +280,7 @@ const PHASE_TEXT: Record<Phase, string> = {
   error: '失败',
   cancelled: '已取消',
   suspended: '服务重启，这一轮中断了',
+  unknown: '没核对上这一轮现在的状态',
 }
 
 const EMPTY: ChatTurn[] = []
@@ -249,6 +297,24 @@ const REVIEW_TIMEOUT_MS = 25_000
  */
 const LEGACY_CLIP = 2000
 
+/**
+ * 是不是恰好切在 LEGACY_CLIP。后端按码点切，JS 的 length 数的是 UTF-16：答案里
+ * 有一个 emoji 就多出一个，按 length 比就认不出来了
+ */
+function atClip(s: string): boolean {
+  if (s.length < LEGACY_CLIP || s.length > LEGACY_CLIP * 2) return false
+  let n = 0
+  for (const _ of s) n++
+  return n === LEGACY_CLIP
+}
+
+/**
+ * 还停在 running 的轮次、又没有运行：断在建图阶段了。建图跟着页面那条流走，页面一关
+ * 就停；这么久还没动静就当它断了（和后端 conversations.BUILD_STALE 一致）。「动静」
+ * 按最后一次落库算，见 TurnMeta.at
+ */
+const BUILD_STALE_MS = 15 * 60_000
+
 /** 留档的旧答案存多少。它是用来对照的，不是用来读全文的——全文在运行记录里 */
 const ATTEMPT_ANSWER_CAP = 4000
 
@@ -312,7 +378,7 @@ function answerText(output: Record<string, any> | null | undefined): string {
 /** 事件里那份 output 看起来是不是被切过：老后端不带 output_truncated，只能看长度 */
 function looksClipped(output: Record<string, any> | null | undefined): boolean {
   if (!output) return false
-  return Object.values(output).some((v) => typeof v === 'string' && v.length === LEGACY_CLIP)
+  return Object.values(output).some((v) => typeof v === 'string' && atClip(v))
 }
 
 /** 出具信息存进 meta 前瘦一下身：无法回指的数字可能有上百个，横幅只列得下一行 */
@@ -328,13 +394,10 @@ function countQueries(events: RunEvent[]): number {
 }
 
 export function metaOf(t: ConversationTurn): TurnMeta | null {
-  const own = (t as any).meta
-  if (own && typeof own === 'object') return own as TurnMeta
-  const bridged = (t.review as any)?.meta
-  return bridged && typeof bridged === 'object' ? (bridged as TurnMeta) : null
+  return t.meta && typeof t.meta === 'object' ? (t.meta as TurnMeta) : null
 }
 
-/** review 字段里真正的复核结论。只挂了 meta、没有 verdict 的不算复核过 */
+/** review 字段里真正的复核结论。只挂了 meta、没有 verdict 的不算复核过（老轮次的 meta 在里面，剥掉） */
 function reviewOf(t: ConversationTurn): ReviewResult | null {
   const r = t.review as any
   if (!r || typeof r !== 'object' || !r.verdict) return null
@@ -355,29 +418,60 @@ function buildMeta(t: ChatTurn): TurnMeta {
     attempts: t.attempts?.length ? t.attempts : undefined,
     ms: t.endedAt ? t.endedAt - t.startedAt : t.meta?.ms,
     queries: t.events.length ? countQueries(t.events) : t.meta?.queries,
+    clipped: t.clipped,
+    scope: t.scope?.length ? t.scope : undefined,
+    at: Date.now(),
   }
 }
 
-/** 写回 review 字段的那份：复核原样 + meta */
-function packReview(t: ChatTurn): Record<string, any> {
-  return { ...(t.reviewRaw ?? {}), meta: buildMeta(t) }
-}
-
-/** 一行错误文案 → 结构化。后端的 detail 按约定已是人话，humanizeError 只做拆句和去类名 */
+/**
+ * 一行错误文案 → 结构化。后端的 detail 按约定已是人话，humanizeError 只做拆句和去类名。
+ * 运行本身的失败不走这里，走 runFailure
+ */
 function failureOf(e: unknown, extra?: { hint?: string; detail?: string }): Failure {
   const h = humanizeError(e)
+  // 原话留一份（后端的 detail）。连不上后端时原话是「Failed to fetch」，没有留的价值
+  const source = h.kind === 'network' ? undefined
+    : typeof e === 'string' ? e
+    : e instanceof ApiError ? e.message
+    : undefined
   return {
     title: h.title,
     reason: h.reason,
-    hint: extra?.hint || h.action,
+    // 通用的「稍等几秒会自动重试」在这一页不成立：没有谁会替这一轮重发，得人来点
+    hint: extra?.hint || (h.kind === 'network' ? '后端连上之后点「重试这一轮」。' : h.action),
     detail: extra?.detail || (h.raw && h.raw !== h.title ? h.raw : undefined),
-    // 连不上后端时原话是「Failed to fetch」，再翻一遍不会再判成网络问题，不能交出去
-    ...(typeof e === 'string' && h.kind !== 'network' ? { source: e } : {}),
+    ...(source ? { source } : {}),
+  }
+}
+
+/**
+ * 运行失败的说明：和记录页、画布右栏读同一份 lib/explain，同一次失败三处说法一致。
+ * 它还说得出「原样接着跑有没有用」：缺输入、人驳回、工具没绑，接着跑只会再失败一次。
+ * 原话跟着留：流里的报错块拿它按同一份 lib/explain 再讲一遍，才给得出「去模型接入」
+ * 这类直达入口
+ */
+function runFailure(error: string | null | undefined, detail?: string | null): Failure {
+  const x = explainRunError(error, detail)
+  return {
+    title: x.title,
+    reason: x.reason,
+    hint: x.action,
+    detail: x.raw && x.raw !== x.title ? x.raw : undefined,
+    ...(x.continuable ? {} : { continuable: false as const }),
+    ...(error ? { source: error } : {}),
   }
 }
 
 const lineOf = (f: Failure) => (f.reason ? `${f.title}：${f.reason}` : f.title)
 
+/** 运行记录被删了：没有断点可续，也补不回完整答案 */
+const GONE: Failure = {
+  title: '上次没有跑完',
+  reason: '对应的运行记录已经删掉了，没有断点可以接着跑。',
+  hint: '点「重试这一轮」重新来一次。',
+}
+
 const SUSPENDED: Failure = {
   title: PHASE_TEXT.suspended,
   reason: '断点还在，前面查过的表、跑过的步骤都保留着。',
@@ -412,11 +506,21 @@ function findTurn(conversationId: string, turnId: string): ChatTurn | undefined
   return useChat.getState().byConversation[conversationId]?.find((t) => t.id === turnId)
 }
 
-/** 带上 meta 一起写：review 字段是整块替换的，只写一半另一半就没了 */
+/**
+ * 在回收站里的会话只能翻看。从这里发起的运行左栏找不到、没人看着，却照样计费；
+ * 跑着的时候又不能彻底删除。按钮已经按这个关掉了，这里再守一道
+ */
+const inTrash = (conversationId: string) =>
+  useConversations.getState().trash.some((c) => c.id === conversationId)
+
+/**
+ * 连同 meta 和复核一起写。两者在后端都是整块替换。review 写 {} 而不是 null：null 等于
+ * 「这次不改」，重试之后上一次的复核就留在库里，刷新后挂到新答案头上
+ */
 function persist(conversationId: string, turnId: string, body: Record<string, any> = {}) {
   const turn = findTurn(conversationId, turnId)
   if (!turn) return Promise.resolve()
-  return saver(conversationId, turnId)({ ...body, review: packReview(turn) })
+  return saver(conversationId, turnId)({ ...body, meta: buildMeta(turn), review: turn.reviewRaw ?? {} })
 }
 
 /**
@@ -467,7 +571,9 @@ function restoreTurn(t: ConversationTurn): ChatTurn {
   // 老数据没有 meta：停止写的是 status=error + 「已取消」
   const outcome = meta?.outcome ?? (t.status === 'error' && t.error === '已取消' ? 'cancelled' : undefined)
   const answer = t.answer ?? ''
-  const failure = meta?.failure ?? (t.error && t.error !== '已取消' ? failureOf(t.error) : null)
+  // 老数据没有 meta.failure，error 列里是原始异常：有运行的按运行失败解释
+  const failure = meta?.failure
+    ?? (t.error && t.error !== '已取消' ? (runId ? runFailure(t.error) : failureOf(t.error)) : null)
 
   let phase: Phase
   let status: string
@@ -531,9 +637,13 @@ function restoreTurn(t: ConversationTurn): ChatTurn {
     reviewRaw: review,
     rawOutput: review?.original ? { answer: review.original } : null,
     attempts: meta?.attempts,
-    // 旧版本切在 2000 字、运行也删了：补不回来，但至少别装作完整
-    clipped: !runId && graphful && answer.length === LEGACY_CLIP && !review?.answer ? 'lost' : undefined,
+    // 上次记下没取全的：运行还在就等 hydrate 补，运行没了就补不回来了。
+    // 老数据没记过，只能看是不是恰好切在 2000 字——运行也删了的，至少别装作完整
+    clipped: meta?.clipped === 'partial' ? (runId ? 'partial' : 'lost')
+      : meta?.clipped === 'lost' ? 'lost'
+      : !runId && graphful && atClip(answer) && !review?.answer ? 'lost' : undefined,
     meta,
+    scope: meta?.scope,
   }
 }
 
@@ -543,9 +653,9 @@ function needsEagerHydrate(t: ChatTurn): boolean {
   if (t.phase === 'checking' || t.phase === 'suspended') return true
   // 「接着跑」给不给取决于运行现在的状态；老数据没存过
   if (t.phase === 'error' && !t.runStatus) return true
-  // 旧版本被切在 2000 字的答案：运行还在就把完整版补回来
+  // 答案没取全：运行还在就把完整版补回来
   return t.phase === 'done' && !t.review?.answer
-    && typeof t.output?.answer === 'string' && t.output.answer.length === LEGACY_CLIP
+    && (t.clipped === 'partial' || (typeof t.output?.answer === 'string' && atClip(t.output.answer)))
 }
 
 
@@ -553,6 +663,9 @@ export const useChat = create<ChatState>((set, get) => ({
   byConversation: {},
   loadState: {},
   loadError: {},
+  scopes: {},
+
+  setScope: (key, scope) => set((s) => ({ scopes: { ...s.scopes, [key]: scope } })),
 
   turnsOf: (conversationId) =>
     (conversationId && get().byConversation[conversationId]) || EMPTY,
@@ -581,15 +694,28 @@ export const useChat = create<ChatState>((set, get) => ({
         // 完整的事件和进行中的流。库里多出来的补在前面
         const known = new Set(mem.map((t) => t.serverId).filter(Boolean))
         const extra = restored.filter((t) => !known.has(t.serverId))
+        // 数据源范围接着上一问的：回来追问的多半还是那个库。输入框旁写着范围，不是暗中沿用
+        const lastScope = restored[restored.length - 1]?.scope
         return {
           byConversation: { ...s.byConversation, [conversationId]: mem.length ? [...extra, ...mem] : restored },
           loadState: { ...s.loadState, [conversationId]: 'ready' },
           loadError: { ...s.loadError, [conversationId]: undefined },
+          ...(lastScope && !(conversationId in s.scopes) ? { scopes: { ...s.scopes, [conversationId]: lastScope } } : {}),
         }
       })
-      for (const t of restored) {
+      // 内存里已有的那几轮没有并进来，下面对它们的 hydrate / persist 按 id 找不到，自然跳过
+      const now = Date.now()
+      detail.turns.forEach((row, i) => {
+        const t = restored[i]
         if (needsEagerHydrate(t)) void get().hydrate(conversationId, t.id)
-      }
+        // 断在建图阶段、早就没动静的：库里那行一直是 running，每次进来都当它还在跑，
+        // Copilot 的上下文也把它当成没答完的一轮漏掉。认定断了就写回去。
+        // 动静按最后一次落库算：重试昨天那一轮时 created_at 是昨天，而它正在别的页面里建图
+        const at = Math.max(parseServerTime(row.created_at ?? null)?.getTime() ?? 0, t.meta?.at ?? 0)
+        if (row.status === 'running' && !t.run && t.phase === 'error' && at && now - at > BUILD_STALE_MS) {
+          void persist(conversationId, t.id, { status: 'error', error: lineOf(t.failure ?? GONE) })
+        }
+      })
     } catch (e) {
       set((s) => ({
         loadState: { ...s.loadState, [conversationId]: 'error' },
@@ -618,14 +744,15 @@ export const useChat = create<ChatState>((set, get) => ({
     }
   },
 
-  ask: (conversationId, question) => {
+  ask: (conversationId, question, opts) => {
     const state = get().loadState[conversationId]
     // 历史还没回来就提问，新的一轮会把"这个会话"变成只有它一轮；加载失败时
     // 页面上什么都没有，更像是空会话——两种情况都先别让它发
     if (state === 'loading' || state === 'error') return false
-    if (isBusy(get().byConversation[conversationId])) return false
+    if (isBusy(get().byConversation[conversationId]) || inTrash(conversationId)) return false
 
     const id = newId()
+    const scope = opts?.scope ?? get().scopes[conversationId] ?? []
     set((s) => ({
       byConversation: {
         ...s.byConversation,
@@ -635,7 +762,7 @@ export const useChat = create<ChatState>((set, get) => ({
             id, serverId: null, question, phase: 'planning', status: PHASE_TEXT.planning,
             thinking: '', ops: [], events: [], graph: null, explanation: '',
             run: null, output: null, error: '', startedAt: Date.now(),
-            lastSeq: 0, cancel: null, attempt: 0,
+            lastSeq: 0, cancel: null, attempt: 0, scope: scope.length ? scope : undefined,
           },
         ],
       },
@@ -656,7 +783,7 @@ export const useChat = create<ChatState>((set, get) => ({
       .catch(() => null)
     serverIds.set(id, started)
 
-    plan(flow, { question, instruction: question, attempt: 0 })
+    plan(flow, { question, instruction: question, attempt: 0, scope })
     return true
   },
 
@@ -682,7 +809,7 @@ export const useChat = create<ChatState>((set, get) => ({
 
   runNow: (conversationId, turnId) => {
     const turn = findTurn(conversationId, turnId)
-    if (!turn?.graph || isBusy(get().byConversation[conversationId])) return
+    if (!turn?.graph || isBusy(get().byConversation[conversationId]) || inTrash(conversationId)) return
     const flow = flowOf(conversationId, turnId)
     flow.patch(() => ({
       phase: 'running', status: PHASE_TEXT.running, pendingRun: false,
@@ -699,7 +826,7 @@ export const useChat = create<ChatState>((set, get) => ({
     //
     // 接上之后 run.finished 照常触发 settle，复核层自动覆盖这一次
     const turn = findTurn(conversationId, turnId)
-    if (!turn?.run || isBusy(get().byConversation[conversationId])) return false
+    if (!turn?.run || isBusy(get().byConversation[conversationId]) || inTrash(conversationId)) return false
     try {
       await api.runs.continue(turn.run.id)
     } catch (e) {
@@ -716,13 +843,19 @@ export const useChat = create<ChatState>((set, get) => ({
   retryTurn: (conversationId, turnId, opts) => {
     const turns = get().byConversation[conversationId]
     const turn = turns?.find((t) => t.id === turnId)
-    if (!turn || isBusy(turns)) return
+    if (!turn || isBusy(turns) || inTrash(conversationId)) return
     turn.cancel?.()
+    // 服务重启挂起的旧运行没人会再去续它：不取消的话，它在记录里一直是「已挂起 · 可续跑」。
+    // 停在审批上的不算——重试不会从那里发起
+    if (turn.run?.id && turn.phase !== 'waiting' && (turn.phase === 'suspended' || turn.runStatus === 'interrupted')) {
+      void api.runs.cancel(turn.run.id).catch(() => undefined)
+    }
     const flow = flowOf(conversationId, turnId)
     const base = turn.graph && (turn.graph.nodes?.length ?? 0) > 0 ? turn.graph : null
     const record = attemptOf(turn)
     const reason = record.detail ? `${record.summary}（${record.detail.slice(0, 300)}）` : record.summary
     const direct = !!base && !!(opts?.maxSteps || opts?.rerun)
+    const scope = opts?.scope ?? turn.scope
 
     // 上一次原样留档，这一次从头记：旧的事件、答案、复核留在这里只会让人分不清
     // 哪段是最终那次
@@ -735,7 +868,7 @@ export const useChat = create<ChatState>((set, get) => ({
       rawOutput: null, failure: null, error: '', lastSeq: 0, final: undefined,
       runStatus: undefined, clipped: undefined, pendingRun: false, steps: undefined,
       hydrated: 'done', startedAt: Date.now(), endedAt: undefined, attempt: 0, cancel: null,
-      noQuery: false, thinking: '', writing: null,
+      noQuery: false, thinking: '', writing: null, scope: scope?.length ? scope : undefined,
     }))
     void flow.persist({ status: 'running', error: '', answer: '' })
 
@@ -746,7 +879,7 @@ export const useChat = create<ChatState>((set, get) => ({
       return
     }
     plan(flow, {
-      question: turn.question, attempt: 0, baseGraph: base,
+      question: turn.question, attempt: 0, baseGraph: base, scope,
       instruction: base
         ? `这张流程上一次没有给出可用的结果：${reason}。\n\n`
           + `请针对这个原因改它（比如调大最大步数、改正工具参数、换个查询方式），`
@@ -764,29 +897,51 @@ export const useChat = create<ChatState>((set, get) => ({
     const stale = () => (epochs.get(turnId) ?? 0) !== epoch
     const patch = patcher(set, conversationId, turnId)
     patch(() => ({ hydrated: 'pending' }))
+    /**
+     * 查到了库里那行还不知道的结局：内存里改，库里也改。只改内存的话那行永远是
+     * running——每次进来都要再核对一遍，Copilot 的上下文把它当没答完的一轮漏掉，
+     * 运行一删它就只能退成「上次没有跑完」，连「已取消」都说不出来了
+     */
+    const conclude = (fields: Partial<ChatTurn>, error: string) => {
+      patch(() => fields)
+      void persist(conversationId, turnId, { status: 'error', error })
+    }
     let run: Run
     try {
       run = await api.runs.get(runId)
     } catch (e) {
-      if (stale()) return
+      const cur = findTurn(conversationId, turnId)
+      if (stale() || !cur) return
       if (e instanceof ApiError && e.status === 404) {
-        // 运行被删了：没有断点可续，也补不回完整答案
-        patch((t) => ({
-          hydrated: 'done',
-          runStatus: 'gone',
-          ...(t.phase === 'checking' ? {
-            phase: 'error' as Phase, status: PHASE_TEXT.error, error: '上次没有跑完',
-            failure: {
-              title: '上次没有跑完',
-              reason: '对应的运行记录已经删掉了，没有断点可以接着跑。',
-              hint: '点「重试这一轮」重新来一次。',
-            },
-          } : {}),
-          clipped: t.phase === 'done' && !t.review?.answer
-            && String(t.output?.answer ?? '').length === LEGACY_CLIP ? 'lost' : t.clipped,
+        if (cur.phase === 'checking') {
+          conclude({
+            hydrated: 'done', runStatus: 'gone', phase: 'error', status: PHASE_TEXT.error,
+            error: GONE.title, failure: GONE,
+          }, GONE.title)
+          return
+        }
+        // 没取全的答案，运行又删了：补不回来，但得说出来，也记下来
+        const lost = cur.phase === 'done' && !cur.review?.answer
+          && (cur.clipped === 'partial' || atClip(String(cur.output?.answer ?? '')))
+        patch((t) => ({ hydrated: 'done', runStatus: 'gone', clipped: lost ? 'lost' : t.clipped }))
+        if (lost) void persist(conversationId, turnId)
+      } else if (cur.phase === 'checking') {
+        // 后端出错、超时：不知道它现在怎样，但不能一直停在「正在核对」转圈——那之后
+        // 再也没有人来核对（重连只在断开过之后才触发）。说清楚，给「重新核对」
+        const said = errorMessage(e)
+        const raw = humanizeError(e).raw
+        const failure: Failure = {
+          title: PHASE_TEXT.unknown,
+          reason: `去后端查这一轮的运行时出错了（${said}）。它可能还在跑，也可能已经结束。`,
+          hint: '稍后点「重新核对」；后端断开又连上时会自动再核对一次。',
+          // 原话已经在括号里的，技术细节不再重复一遍
+          detail: raw && !said.includes(raw) ? raw : undefined,
+        }
+        patch(() => ({
+          hydrated: undefined, phase: 'unknown', status: PHASE_TEXT.unknown, failure, error: lineOf(failure),
         }))
       } else {
-        patch(() => ({ hydrated: undefined }))   // 网断了之类：下次再试
+        patch(() => ({ hydrated: undefined }))   // 已经有个结局摆着，下次再补
       }
       return
     }
@@ -800,41 +955,54 @@ export const useChat = create<ChatState>((set, get) => ({
     if (run.status === 'running' || run.status === 'queued') {
       if (unsettled) {
         const flow = flowOf(conversationId, turnId)
-        flow.patch(() => ({ phase: 'running', status: PHASE_TEXT.running, failure: null, error: '', endedAt: undefined }))
+        // 计时不从提问那天算：中断过的接着上次停下的地方走，停在半路的从运行开始算
+        const spent = cur.endedAt ? Math.max(0, cur.endedAt - cur.startedAt) : null
+        const startedAt = spent != null ? Date.now() - spent
+          : parseServerTime(run.started_at ?? null)?.getTime() ?? cur.startedAt
+        flow.patch(() => ({
+          phase: 'running', status: PHASE_TEXT.running, failure: null, error: '', startedAt, endedAt: undefined,
+        }))
         watch(flow, run.id, cur.lastSeq, cur.question)
       }
       return
     }
     if (run.status === 'interrupted') {
       if (pending) {
+        // 还在等人：库里那行保持 running 就是对的，它确实没结束
         patch(() => ({ phase: 'waiting', status: PHASE_TEXT.waiting, failure: null, error: '' }))
         void useCatalog.getState().refreshApprovals()
-      } else if (cur.phase !== 'done') {
-        patch(() => ({ phase: 'suspended', status: PHASE_TEXT.suspended, failure: SUSPENDED, error: '' }))
+      } else if (cur.phase !== 'done' && cur.phase !== 'suspended') {
+        conclude({ phase: 'suspended', status: PHASE_TEXT.suspended, failure: SUSPENDED, error: '' }, PHASE_TEXT.suspended)
       }
       return
     }
-    if (run.status === 'cancelled' && cur.phase !== 'done') {
-      patch(() => ({ phase: 'cancelled', status: PHASE_TEXT.cancelled, failure: null, error: '' }))
+    if (run.status === 'cancelled') {
+      if (cur.phase !== 'done' && cur.phase !== 'cancelled') {
+        conclude({ phase: 'cancelled', status: PHASE_TEXT.cancelled, failure: null, error: '' }, '已取消')
+      }
       return
     }
-    if (run.status === 'failed' && cur.phase !== 'done') {
-      const failure = cur.phase === 'error' && cur.failure ? cur.failure : failureOf(run.error || '运行失败')
-      patch(() => ({ phase: 'error', status: PHASE_TEXT.error, failure, error: lineOf(failure) }))
+    if (run.status === 'failed') {
+      if (cur.phase === 'error' && cur.failure) return
+      if (cur.phase !== 'done') {
+        const failure = runFailure(run.error || '')
+        conclude({ phase: 'error', status: PHASE_TEXT.error, failure, error: lineOf(failure) }, lineOf(failure))
+      }
       return
     }
     if (run.status !== 'succeeded') return
     if (unsettled) {
       // 跑完了，但交付没赶上（复核期间关了页面、服务重启）：把这一轮补完，
-      // 走一遍和实时一样的复核与落库
+      // 走一遍和实时一样的复核与落库。相位停在「正在核对」而不是「运行中」：运行
+      // 早就结束了，按实时算的计时会从提问那天一路数到现在（「72:00:01」）
       const flow = flowOf(conversationId, turnId)
-      flow.patch(() => ({ phase: 'running', status: '正在核对结果…', failure: null, error: '' }))
+      flow.patch(() => ({ phase: 'checking', status: '正在核对结果…', failure: null, error: '' }))
       // 耗时按运行真正结束的时刻算：补交付可能发生在几天之后
       const endedAt = parseServerTime(run.finished_at ?? null)?.getTime()
       void settle(flow, run.id, cur.question, run.output ?? null, { run, endedAt })
       return
     }
-    // 已经交付过的：答案被旧版本切过就换成完整的，顺手把档位补回来
+    // 已经交付过的：答案没取全就换成完整的，顺手把档位补回来
     const full = answerText(run.output)
     const stored = String(cur.output?.answer ?? '')
     const repaired = !cur.review?.answer && stored.length >= 200
@@ -848,6 +1016,15 @@ export const useChat = create<ChatState>((set, get) => ({
     }
   },
 
+  recheck: (conversationId, turnId) => {
+    const turn = findTurn(conversationId, turnId)
+    if (!turn || turn.phase !== 'unknown') return Promise.resolve()
+    patcher(set, conversationId, turnId)(() => ({
+      phase: 'checking', status: PHASE_TEXT.checking, failure: null, error: '', hydrated: undefined,
+    }))
+    return get().hydrate(conversationId, turnId)
+  },
+
   reattach: async (conversationId, turnId) => {
     const turn = findTurn(conversationId, turnId)
     if (!turn?.run) return
@@ -1005,6 +1182,8 @@ interface PlanArgs {
   /** 重试时把上一次那张图交回去，让它改而不是重建。null = 从零建 */
   baseGraph?: GraphSpec | null
   attempt: number
+  /** 这一问限定只查的数据源。空或不给 = 不限 */
+  scope?: ScopeSource[]
 }
 
 /**
@@ -1015,8 +1194,8 @@ interface PlanArgs {
  * 本来就是在手动做这件事。
  */
 function plan(flow: Flow, args: PlanArgs) {
-  const { question, instruction, baseGraph, attempt } = args
-  const { patch, save } = flow
+  const { question, instruction, baseGraph, attempt, scope } = args
+  const { patch } = flow
 
   /** 这一轮建出来的图。retry 要把它交回去，所以得在闭包里留一份 */
   let built: GraphSpec | null = baseGraph ?? null
@@ -1049,6 +1228,7 @@ function plan(flow: Flow, args: PlanArgs) {
       question,
       attempt: attempt + 1,
       baseGraph: base,
+      scope,
       instruction: base
         ? `这张流程上一次运行没有成功：${reason}。\n\n`
           + `请针对这个原因改它（比如调大最大步数、改正工具参数、换个查询方式），`
@@ -1069,7 +1249,10 @@ function plan(flow: Flow, args: PlanArgs) {
   }
 
   const cancelCopilot = streamCopilot(
-    { instruction, base_graph: baseGraph ?? null, intent: 'answer', conversation_id: flow.conversationId },
+    {
+      instruction, base_graph: baseGraph ?? null, intent: 'answer', conversation_id: flow.conversationId,
+      ...(scope?.length ? { datasource_ids: scope.map((d) => d.id) } : {}),
+    },
     (op) => {
       // 停止之后缓冲里还没派发完的操作：一条 final 就能把这一轮又跑起来
       if (!flow.alive()) return
@@ -1120,7 +1303,8 @@ function plan(flow: Flow, args: PlanArgs) {
         case 'final': {
           const graph = op.graph as GraphSpec
           built = graph          // 要重试的话，交回去的就是它
-          void save({ graph, explanation: op.explanation ?? '' })
+          // 连 meta 一起写：它的 at 是「建图还有动静」的凭据，后端这时也会刷新 updated_at
+          void flow.persist({ graph, explanation: op.explanation ?? '' })
 
           // 没过校验的图不能拿去跑：引擎会照实抛出它自己的措辞（"图是空的，
           // 先拖一个节点进来"），而用户根本不在画布上，这句话对他毫无意义。
@@ -1174,6 +1358,19 @@ function plan(flow: Flow, args: PlanArgs) {
       if (!error || !flow.alive()) return
       const turn = findTurn(flow.conversationId, flow.turnId)
       if (!turn || !BUSY_PHASES.has(turn.phase) || turn.run) return
+      // 限定的库一个都不在了：后端在开流之前就 400。流的结束回调只拿得到那句 detail，
+      // 按它认；认出来了，补救得是「不限数据源重试」，带着原范围重试只会再被拒一次
+      if (scope?.length && error.startsWith('限定的数据源')) {
+        const at = error.indexOf('：')
+        fail({
+          title: at > 0 ? error.slice(0, at) : error,
+          reason: at > 0 ? `${error.slice(at + 1).split('。')[0]}。` : undefined,
+          hint: '点「不限数据源重试」；想还只查它，先到「数据」页确认它还在、而且是启用的。',
+          detail: error,
+          scopeGone: true,
+        })
+        return
+      }
       fail(failureOf(error))
     },
   )
@@ -1194,10 +1391,18 @@ async function launch(
       return
     }
     patch(() => ({ run, runStatus: run.status }))
-    void flow.save({ run_id: run.id })
+    // meta 里的 runId 优先于 run_id 列（重试建图失败时那一列清不掉），所以得一起改：
+    // 只写列的话，重试出来的这次运行在库里一直挂着 runId=null，跑着的时候刷新或者
+    // 另开一页，它就成了「断在建图阶段」，放久了还会被当成断了写回 error。
+    // 「跑一下」发起时库里那行还是 done，一并改成 running
+    void flow.persist({ run_id: run.id, status: 'running' })
     watch(flow, run.id, 0, question, retry)
   } catch (e) {
-    const failure = failureOf(e)
+    // 发起那一下没到后端：流程是好的，原样再发起就行。通用的「稍等几秒会自动重试」
+    // 在这里不成立——这一页没有谁会替它重发
+    const failure: Failure = isNetworkError(e)
+      ? { ...failureOf(e, { hint: '后端连上之后点「重跑这一轮」，搭好的流程不用重来。' }), rerun: true }
+      : failureOf(e)
     patch(() => ({
       phase: 'error', status: PHASE_TEXT.error, error: lineOf(failure), failure,
       cancel: null, endedAt: Date.now(),
@@ -1359,7 +1564,7 @@ function watch(
       case 'run.failed': {
         ended = true
         batch.now()
-        const failure = failureOf(String(d.error ?? '运行失败'), { detail: d.detail ? String(d.detail) : undefined })
+        const failure = runFailure(d.error ? String(d.error) : '', d.detail ? String(d.detail) : undefined)
         patch(() => ({
           phase: 'error', status: PHASE_TEXT.error, error: lineOf(failure), failure,
           cancel: null, endedAt: Date.now(), runStatus: 'failed', final: { status: 'failed' },
@@ -1482,7 +1687,8 @@ async function settle(
     reviewRaw: result,
     cancel: null,
     endedAt: opts.endedAt ?? Date.now(),
-    clipped,
+    // 复核改写时读的是库里那份完整成果，改写出来的答案不缺尾巴
+    clipped: rewritten ? undefined : clipped,
     // 到这一步才把成果摆出来：复核说明和结论同时出现，而不是结论先读完
     output,
     // 改写是有损的，原件得留着——界面上可以展开对照。它跟着 review 一起
diff --git a/frontend/src/store/conversations.ts b/frontend/src/store/conversations.ts
index dd0e2538..fc4774c9 100644
--- a/frontend/src/store/conversations.ts
+++ b/frontend/src/store/conversations.ts
@@ -1,5 +1,6 @@
 import { create } from 'zustand'
 import { api } from '../api/client'
+import { parseServerTime } from '../lib/format'
 import type { Conversation } from '../types'
 
 /**
@@ -27,8 +28,24 @@ export const lastVisited = (): string | null => {
   }
 }
 
+/**
+ * 列表接口带上已归档的（回收站）。client 的 list 还不认 include_archived 参数（已提给 3c），
+ * kind 原样拼进查询串，先借它带上
+ */
+const WITH_TRASH = 'chat&include_archived=true' as 'chat'
+
+/** 按最后活跃时间排：恢复出来的会话回到它原本该在的位置 */
+const activeAt = (c: Conversation) => parseServerTime(c.last_active_at ?? c.created_at ?? '')?.getTime() ?? 0
+
 interface ConversationState {
   list: Conversation[]
+  /**
+   * 回收站：删掉（归档）的会话。删除先归档，是因为误删一个聊了七轮的对话没有别的
+   * 找回途径；撤销只有几秒，回收站一直在
+   */
+  trash: Conversation[]
+  /** 左栏在看回收站。放在 store 里：问数据页的「恢复」要能把左栏切回列表 */
+  showTrash: boolean
   currentId: string | null
   loading: boolean
   /** 列表取失败了。和「一个对话都没有」要分开说 */
@@ -40,23 +57,31 @@ interface ConversationState {
   /** 由 URL 回流调用，把「在看哪个」记下来。不要在别处直接调它 */
   select: (id: string | null) => void
   rename: (id: string, title: string) => Promise<void>
-  /** 删掉，返回接下来该去哪个（列表空了就是 null），由调用方导航 */
-  remove: (id: string) => Promise<string | null>
+  setShowTrash: (show: boolean) => void
   /**
-   * 从列表里拿掉（归档），返回接下来该去哪个。撤销就是 restore。
+   * 从列表里拿掉、放进回收站（归档），返回接下来该去哪个。撤销就是 restore。
    *
    * 用归档而不是「先藏起来、过几秒再真删」：延迟删除在关掉标签页、切走页面时
    * 要么没删成、要么撤销不了。归档是一次就落库的状态，撤不撤都不会丢
    */
   archive: (id: string) => Promise<string | null>
-  /** 撤销归档，放回原来的位置 */
-  restore: (item: Conversation, index: number) => Promise<void>
+  /** 从回收站拿回来。index 是撤销时的原位置；不给就按最后活跃时间插回去 */
+  restore: (item: Conversation, index?: number) => Promise<void>
+  /** 真删（DELETE）。只从回收站里发起，调用方负责先确认 */
+  purge: (id: string) => Promise<void>
+  /**
+   * 回收站里的这些真删（不给就是全部），返回没删掉的个数。正在跑的由调用方挑出去：
+   * 删掉会话只会关掉这一头的事件流，后端的运行照样跑、照样计费
+   */
+  emptyTrash: (ids?: string[]) => Promise<number>
   /** 有人在这个会话里说话了，把它顶到列表最前并刷新副标题 */
   touch: (id: string, lastQuestion?: string) => void
 }
 
 export const useConversations = create<ConversationState>((set, get) => ({
   list: [],
+  trash: [],
+  showTrash: false,
   currentId: null,   // 由 URL 填，见 ChatPage 的同步 effect
   loading: false,
   error: null,
@@ -66,7 +91,13 @@ export const useConversations = create<ConversationState>((set, get) => ({
     // 两边都能定就会互相覆盖：深链接进来，列表一加载完又被拽回上次那个
     set({ loading: true })
     try {
-      set({ list: await api.conversations.list('chat'), loading: false, error: null })
+      const rows = await api.conversations.list(WITH_TRASH)
+      set({
+        list: rows.filter((c) => !c.archived),
+        trash: rows.filter((c) => c.archived),
+        loading: false,
+        error: null,
+      })
     } catch (e) {
       set({ loading: false, error: e })
     }
@@ -102,23 +133,18 @@ export const useConversations = create<ConversationState>((set, get) => ({
     }
   },
 
-  remove: async (id) => {
-    await api.conversations.remove(id)
-    const list = get().list.filter((c) => c.id !== id)
-    set({ list })
-    // 删的不是当前这个就原地不动；删的是当前这个才需要换地方
-    return get().currentId === id ? (list[0]?.id ?? null) : get().currentId
-  },
+  setShowTrash: (show) => set({ showTrash: show }),
 
   archive: async (id) => {
-    const before = get().list
+    const { list: before, trash } = get()
+    const item = before.find((c) => c.id === id)
     const list = before.filter((c) => c.id !== id)
     // 先从列表里拿掉再发请求：删除该是即时的，失败了再放回去
-    set({ list })
+    set({ list, trash: item ? [{ ...item, archived: true }, ...trash] : trash })
     try {
       await api.conversations.update(id, { archived: true })
     } catch (e) {
-      set({ list: before })
+      set({ list: before, trash })
       throw e
     }
     return get().currentId === id ? (list[0]?.id ?? null) : get().currentId
@@ -127,13 +153,29 @@ export const useConversations = create<ConversationState>((set, get) => ({
   restore: async (item, index) => {
     await api.conversations.update(item.id, { archived: false })
     set((s) => {
-      if (s.list.some((c) => c.id === item.id)) return s
+      const trash = s.trash.filter((c) => c.id !== item.id)
+      if (s.list.some((c) => c.id === item.id)) return { trash }
       const list = [...s.list]
-      list.splice(Math.min(index, list.length), 0, { ...item, archived: false })
-      return { list }
+      const later = list.findIndex((c) => activeAt(c) < activeAt(item))
+      const at = index ?? (later < 0 ? list.length : later)
+      list.splice(Math.min(at, list.length), 0, { ...item, archived: false })
+      return { list, trash }
     })
   },
 
+  purge: async (id) => {
+    await api.conversations.remove(id)
+    set((s) => ({ trash: s.trash.filter((c) => c.id !== id), list: s.list.filter((c) => c.id !== id) }))
+  },
+
+  emptyTrash: async (only) => {
+    const ids = get().trash.map((c) => c.id).filter((id) => !only || only.includes(id))
+    const results = await Promise.allSettled(ids.map((id) => api.conversations.remove(id)))
+    const gone = new Set(ids.filter((_, i) => results[i].status === 'fulfilled'))
+    set((s) => ({ trash: s.trash.filter((c) => !gone.has(c.id)) }))
+    return ids.length - gone.size
+  },
+
   touch: (id, lastQuestion) => {
     set((s) => {
       const hit = s.list.find((c) => c.id === id)
diff --git a/frontend/src/store/studio.ts b/frontend/src/store/studio.ts
index 5fdbe01a..ebf4f24b 100644
--- a/frontend/src/store/studio.ts
+++ b/frontend/src/store/studio.ts
@@ -4,6 +4,7 @@ import {
   type Connection, type Edge, type EdgeChange, type Node, type NodeChange,
 } from '@xyflow/react'
 import { api, streamCopilot, streamRun } from '../api/client'
+import { describeToolChange, mergeNodeConfig, shrunkTools, toolChangesOf } from '../canvas/copilotMerge'
 import { NODE_DEFS, sourceHandles } from '../canvas/nodeDefs'
 import { toast } from '../components/ui'
 import { humanizeError } from '../lib/errors'
@@ -16,7 +17,7 @@ import {
   type NodeState, type RunPhase, type Trace,
 } from '../run/trace'
 import type {
-  ConversationTurn, GraphEdge, GraphSpec, NodeRuntime, NodeType, Run, RunEvent, ValidationIssue,
+  ConversationTurn, GraphEdge, GraphSpec, NodeRuntime, NodeType, Run, RunEvent, ToolChange, ValidationIssue,
   VarIssue, Variable, Workflow,
 } from '../types'
 
@@ -114,9 +115,24 @@ export interface CopilotTurn {
     round?: number
     repaired?: number
     message?: string
+    /** 自查时发现的工具被删（tools_dropped）。不挡运行，但要在这一步说出来 */
+    warnings?: string[]
   }
   /** 这一轮开始前打的撤销点。还在栈顶时「撤销这次」直接撤它 */
   checkpoint?: number
+  /** 提交的时刻（毫秒）。助手流的头部据此走实时计时，不用等 3 秒一次的心跳 */
+  startedAt?: number
+  /**
+   * 这一轮改了哪些节点、成员的工具绑定。画布上看不出来（节点还在），跑起来才发现查不了库，
+   * 所以回执要明说。取后端 final.tool_changes；老后端不给时前端自己比对前后两张图
+   */
+  toolChanges?: ToolChange[]
+  /**
+   * 工具集合变小、而这一轮的指令没让删的提醒（check.warnings 和 final.issues 里
+   * code === 'tools_dropped' 的，去重）。单独放：和「成果字段可能为空」这类普通校验提示
+   * 混在一起，最要紧的这句就淹没了
+   */
+  toolWarnings?: CopilotIssue[]
 }
 
 export interface CopilotIssue {
@@ -125,8 +141,34 @@ export interface CopilotIssue {
   node_id?: string | null
   code?: string
   type?: string
+  field?: string | null
 }
 
+/**
+ * 画布此刻为什么改不了：
+ * - copilot：助手正在改它，这时候的手动编辑会被它的最终结果悄悄覆盖；
+ * - formal：正式运行在跑已发布的不可变版本，此刻改图既改不了它，还会让事件对到
+ *   已经被删掉的节点上。画布那边（FlowCanvas）按同一个条件写 data-readonly
+ */
+export type EditLock = 'copilot' | 'formal' | null
+
+const formalRunning = (s: Pick<StudioState, 'runPhase' | 'trace' | 'run'>): boolean =>
+  isActivePhase(s.runPhase) && (s.trace.runClass ?? s.run?.run_class) === 'formal'
+
+export function editLockOf(s: Pick<StudioState, 'copilot' | 'runPhase' | 'trace' | 'run'>): EditLock {
+  if (s.copilot.active) return 'copilot'
+  return formalRunning(s) ? 'formal' : null
+}
+
+/** 改图入口被拦下时说的话。检查器、节点库、快捷键都用这一份 */
+export const EDIT_LOCK_TEXT: Record<Exclude<EditLock, null>, string> = {
+  copilot: '助手正在改这张工作流：等它做完，或者先停下',
+  formal: '正式运行进行中，画布只读：它跑的是已发布的不可变版本，结束后再改',
+}
+
+/** 组件里订阅锁：只在锁的原因变了时重渲染 */
+export const useEditLock = (): EditLock => useStudio(editLockOf)
+
 /** 两张图差在哪。只看节点的名字和配置，挪位置不算改动 */
 export interface GraphDiff {
   added: string[]
@@ -138,6 +180,17 @@ export interface GraphDiff {
   total: number
 }
 
+/** 自查的 warnings 和 final.issues 里是同样的几条：按节点、字段、文字去重 */
+function dedupeIssues(list: CopilotIssue[]): CopilotIssue[] {
+  const seen = new Set<string>()
+  return list.filter((i) => {
+    const key = `${i.node_id ?? ''}|${i.field ?? ''}|${i.message}`
+    if (seen.has(key)) return false
+    seen.add(key)
+    return true
+  })
+}
+
 // 只留最近几轮。画布只反映最后一次生成的结果，更早的轮次是参考而不是现状，
 // 无上限地攒着只会把内存和滚动条都撑坏。
 const COPILOT_TURN_LIMIT = 10
@@ -458,6 +511,10 @@ interface StudioState {
     lastOp: string
     explanation: string
     error: string
+    /** 出错时「怎么办」（后端 error 操作的 hint）。Composer 的错误条和问数据页一样摊开它 */
+    errorHint: string
+    /** 出错时的原始报错（后端 error 操作的 detail），折叠在技术细节里 */
+    errorDetail: string
     model: string
     // 从提交到第一个操作之间有 5~30 秒，得让用户看见这段在发生什么
     phase: 'connecting' | 'planning' | 'building' | 'wiring' | 'finalizing' | 'repairing' | ''
@@ -505,7 +562,11 @@ interface StudioState {
 
   startRun: (input: Record<string, any>) => Promise<Run | null>
   startFormalRun: (input: Record<string, any>) => Promise<Run | null>
-  runCopilot: (instruction: string, useBase: boolean, model?: string | null) => void
+  /**
+   * 开始一轮助手改图。返回开没开始：正式运行期间画布只读，会被拦下（并提示为什么），
+   * 输入框据此决定要不要清掉用户刚写的那句
+   */
+  runCopilot: (instruction: string, useBase: boolean, model?: string | null) => boolean
   /** 停掉这一轮，画布退回这一轮之前（半成品进 future，⇧⌘Z 能找回来） */
   stopCopilot: () => void
   retryCopilot: () => void
@@ -831,8 +892,8 @@ function commit(
   return entry
 }
 
-/** 画布锁着：助手正在改这张图，这时候的手动编辑会被它的最终结果悄悄覆盖 */
-const locked = (get: () => StudioState) => get().copilot.active
+/** 画布锁着：助手正在改，或者正式运行在跑（见 editLockOf） */
+const locked = (get: () => StudioState) => editLockOf(get()) !== null
 
 /** 撤销 / 重做之后：选中的节点没了就收起检查器，未保存标记按内容重算 */
 function afterJump(set: SetFn, get: () => StudioState, nodes: FlowNode[], edges: Edge[]) {
@@ -977,7 +1038,7 @@ export const useStudio = create<StudioState>((set, get) => ({
   copilotConversationId: null,
   copilotMemory: { past: [], total: 0, turns: 0 },
   copilotCursor: null,
-  copilot: { active: false, lastOp: '', explanation: '', error: '', model: '',
+  copilot: { active: false, lastOp: '', explanation: '', error: '', errorHint: '', errorDetail: '', model: '',
              phase: '', thinking: '', elapsedMs: 0, lastInstruction: '', lastUseBase: false },
   copilotNew: [],
   copilotTurns: [],
@@ -1014,7 +1075,8 @@ export const useStudio = create<StudioState>((set, get) => ({
       copilotTurns: [],
       copilotNew: [],
       copilotCursor: null,
-      copilot: { ...get().copilot, active: false, phase: '', thinking: '', lastOp: '', error: '' },
+      copilot: { ...get().copilot, active: false, phase: '', thinking: '', lastOp: '', error: '',
+                 errorHint: '', errorDetail: '' },
       cancelCopilot: null,
       // 先清空再去解析：留着上一张图的会话 id，这中间的任何一条指令
       // 都会带着别的图的上下文发出去
@@ -1415,6 +1477,11 @@ export const useStudio = create<StudioState>((set, get) => ({
   },
 
   runCopilot: (instruction, useBase, model) => {
+    // 正式运行跑的是已发布的版本，画布此刻只读：助手改完的图落不下来，不如先说清楚
+    if (formalRunning(get())) {
+      toast.warn(EDIT_LOCK_TEXT.formal, { key: 'studio:readonly' })
+      return false
+    }
     // 上一轮还在跑：先按停止收掉，免得两条流一起往画布上写
     if (get().copilot.active) get().stopCopilot()
     glideSeq++
@@ -1432,6 +1499,8 @@ export const useStudio = create<StudioState>((set, get) => ({
     const anchored = new Set<string>()
     /** 前端认不出来、没放上画布的节点类型。后端 final.issues 没说到的，收尾时补上，不能安静地少一步 */
     const dropped: string[] = []
+    /** 自查时报出来的工具被删（check.warnings）。收尾时和 final 里同样的那几条合并去重 */
+    const toolDrops: CopilotIssue[] = []
     const withDropped = (raw: unknown): CopilotIssue[] => {
       const issues: CopilotIssue[] = Array.isArray(raw) ? [...raw] : []
       for (const type of dropped) {
@@ -1444,7 +1513,7 @@ export const useStudio = create<StudioState>((set, get) => ({
 
     set({
       copilot: {
-        active: true, lastOp: '', explanation: '', error: '', model: model ?? '',
+        active: true, lastOp: '', explanation: '', error: '', errorHint: '', errorDetail: '', model: model ?? '',
         phase: 'connecting', thinking: '', elapsedMs: 0,
         lastInstruction: instruction, lastUseBase: useBase,
       },
@@ -1456,7 +1525,7 @@ export const useStudio = create<StudioState>((set, get) => ({
       copilotTurns: [
         ...state.copilotTurns.slice(-(COPILOT_TURN_LIMIT - 1)),
         { id: turnId, instruction, ops: [], phase: 'running', explanation: '', error: '',
-          useBase, checkpoint: checkpoint.id },
+          useBase, checkpoint: checkpoint.id, startedAt: Date.now() },
       ],
     })
 
@@ -1488,7 +1557,7 @@ export const useStudio = create<StudioState>((set, get) => ({
       if (activeTurn?.id === turnId) activeTurn = null
       set({
         copilot: { ...get().copilot, active: false, lastOp: '', phase: '', thinking: '',
-                   elapsedMs: 0, ...patch },
+                   elapsedMs: 0, errorHint: '', errorDetail: '', ...patch },
         cancelCopilot: null, copilotCursor: null,
       })
     }
@@ -1541,8 +1610,17 @@ export const useStudio = create<StudioState>((set, get) => ({
       (op) => {
         if (finished) return
         const s = get()
-        // 卡片上的「少了一步」读的是记下来的 final：这里认不出来而后端没提的，一并记进去
-        record(op.op === 'final' && dropped.length ? { ...op, issues: withDropped(op.issues) } : op)
+        if (op.op === 'final') {
+          // 卡片上的「少了一步」、回执里的工具绑定变化读的都是记下来的 final：这里认不出来
+          // 而后端没提的类型，老后端不给的 tool_changes（前端自己比对），一并补齐了再记
+          op = {
+            ...op,
+            issues: withDropped(op.issues),
+            tool_changes: Array.isArray(op.tool_changes) ? op.tool_changes
+              : toolChangesOf(before.nodes, op.graph ? toFlow(op.graph).nodes : []),
+          }
+        }
+        record(op)
         switch (op.op) {
           case 'model':
             // 后端首帧告知实际用的模型，浮条上直接显示，不用猜
@@ -1573,16 +1651,21 @@ export const useStudio = create<StudioState>((set, get) => ({
             break
           case 'check': {
             // 服务端自查：用运行时同一套规则过一遍，有问题交回模型改
-            // 现在是一句话；以后后端会改成 {node_id, message}（能定位到节点），两种都接住。
+            // 以前是一句话，后端改成 {node_id, message, field?} 之后能定位到节点，两种都接住。
             // 带节点的前面补上节点名，「再修一次」拼指令时模型才知道说的是哪个
-            const issues = (op.issues ?? []).map((x: any) => {
+            const lineOf = (x: any): string => {
               if (typeof x === 'string') return x
               const message = String(x?.message ?? JSON.stringify(x))
               const label = x?.node_id ? s.nodes.find((n) => n.id === x.node_id)?.data.label : ''
               return label && !message.includes(`「${label}」`) ? `「${label}」：${message}` : message
-            })
+            }
+            const issues = (op.issues ?? []).map(lineOf)
+            // 工具被删不挡运行，但自查这一步就要说出来（tools_dropped）
+            const warnings: any[] = Array.isArray(op.warnings) ? op.warnings : []
+            for (const w of warnings) if (w && typeof w === 'object') toolDrops.push(w)
             settle({ check: { status: op.status, issues, round: op.round, repaired: op.repaired,
-                              message: op.message } })
+                              message: op.message,
+                              ...(warnings.length ? { warnings: warnings.map(lineOf) } : {}) } })
             set({ copilot: { ...s.copilot,
               phase: op.status === 'repairing' ? 'repairing' : s.copilot.phase,
               lastOp: op.status === 'repairing'
@@ -1634,21 +1717,27 @@ export const useStudio = create<StudioState>((set, get) => ({
             })
             break
           }
-          case 'update_node':
-            if (!s.nodes.some((x) => x.id === op.id)) break
+          case 'update_node': {
+            const target = s.nodes.find((x) => x.id === op.id)
+            if (!target) break
+            // 按字段合并，和后端 merge_node_config 同一套规则：没写的保留、写 null 删键、
+            // 协作成员按 name 合并。整体替换的话，模型只改一句提示词，工具就跟着没了——
+            // 流到一半断掉时，重做栈里的半成品就是那个没有工具的样子
+            const patch = op.config && typeof op.config === 'object' && !Array.isArray(op.config) ? op.config : null
             set({
               nodes: s.nodes.map((x) =>
                 x.id === op.id
                   ? { ...x, data: { ...x.data,
                       ...(op.label != null ? { label: op.label } : {}),
-                      ...(op.config != null ? { config: op.config } : {}) } }
+                      ...(patch ? { config: mergeNodeConfig(x.data.nodeType, x.data.config ?? {}, patch) } : {}) } }
                   : x),
               copilotNew: s.copilotNew.includes(op.id) ? s.copilotNew : [...s.copilotNew, op.id],
               copilotCursor: op.id,
-              copilot: { ...s.copilot, lastOp: `修改节点：${op.label || op.id}` },
+              copilot: { ...s.copilot, lastOp: `修改节点：${op.label || target.data.label || op.id}` },
               dirty: true,
             })
             break
+          }
           case 'remove_node':
             set({
               nodes: s.nodes.filter((x) => x.id !== op.id),
@@ -1709,7 +1798,10 @@ export const useStudio = create<StudioState>((set, get) => ({
               }
             })
             const diff = diffGraphs(before, { nodes, edges: next.edges })
-            const issues = withDropped(op.issues)
+            // 上面记录时已经补齐：认不出的类型并进了 issues，老后端缺的 tool_changes 由前端比对
+            const issues: CopilotIssue[] = op.issues
+            const toolChanges: ToolChange[] = op.tool_changes
+            const toolWarnings = dedupeIssues([...toolDrops, ...issues.filter((i) => i.code === 'tools_dropped')])
             const explanation = op.explanation ?? get().copilot.explanation
             const outcome = diff.total ? 'applied' : 'unchanged'
             if (!diff.total) {
@@ -1740,7 +1832,7 @@ export const useStudio = create<StudioState>((set, get) => ({
             })
             // 落定之后再取景：取景时节点还在半路的话，镜头对着的是它们出发的地方
             if (moving) glide(set, get, targets, () => { if (refit) set({ fitRequest: get().fitRequest + 1 }) })
-            settle({ phase: 'done', outcome, diff, issues, explanation })
+            settle({ phase: 'done', outcome, diff, issues, explanation, toolChanges, toolWarnings })
             finish({ explanation, error: '' })
             recordCanvasTurn(get().copilotConversationId, instruction, {
               graph: op.graph, explanation: explanation ?? '', status: 'done',
@@ -1754,12 +1846,25 @@ export const useStudio = create<StudioState>((set, get) => ({
               const turn = get().copilotTurns.find((t) => t.id === turnId)
               const missing = issues.filter((i) => i.code === 'unknown_node_type').length
               const left = turn?.check?.status === 'failed' ? turn.check.issues.length : 0
+              // 工具绑定变了画布上看不出来，回执里逐条写明前后。变少了用 warn 色：指令里
+              // 没让删的（后端 tools_dropped）常驻到人看过为止——没工具的 agent 照样能跑，
+              // 只是跑出来的是模型「假设」查过库的答案
+              const shrunk = shrunkTools(toolChanges)
+              const unasked = shrunk.length > 0 && toolWarnings.length > 0
+              const head = left ? `已放到画布，但还有 ${left} 处问题要你处理`
+                : missing ? `已应用 ${diff.total} 处改动，但有 ${missing} 步没放上`
+                : `已应用 ${diff.total} 处改动`
+              const lines = shrunk.length
+                ? [unasked ? '工具绑定变少了，这一轮没让删，确认一下是不是改漏了：' : '工具绑定变少了：',
+                   ...shrunk.map(describeToolChange)]
+                : []
               toast(
-                left ? `已放到画布，但还有 ${left} 处问题要你处理`
-                  : missing ? `已应用 ${diff.total} 处改动，但有 ${missing} 步没放上`
-                  : `已应用 ${diff.total} 处改动`,
-                left || missing ? 'warn' : 'ok',
-                { key: `copilot:${turnId}`, duration: 8000,
+                [toolChanges.length && !shrunk.length ? `${head} · 工具绑定变了 ${toolChanges.length} 处` : head,
+                 ...lines].join('\n'),
+                left || missing || shrunk.length ? 'warn' : 'ok',
+                { key: `copilot:${turnId}`, duration: 8000, sticky: unasked,
+                  ...(toolChanges.length > shrunk.length
+                    ? { detail: toolChanges.map(describeToolChange).join('\n') } : {}),
                   action: { label: '撤销', onClick: () => { get().undoCopilotTurn(turnId) } } },
               )
             }
@@ -1771,7 +1876,10 @@ export const useStudio = create<StudioState>((set, get) => ({
             const message = op.message ?? '生成失败'
             const outcome = revert()
             settle({ phase: 'error', error: message, outcome })
-            finish({ explanation: '', error: message })
+            // 「怎么办」和原始报错一起留下：Composer 的错误条和问数据页一样摊开它们
+            finish({ explanation: '', error: message,
+                     errorHint: typeof op.hint === 'string' ? op.hint : '',
+                     errorDetail: typeof op.detail === 'string' ? op.detail : '' })
             recordCanvasTurn(get().copilotConversationId, instruction, { status: 'error', error: message }, set)
             break
           }
@@ -1808,6 +1916,7 @@ export const useStudio = create<StudioState>((set, get) => ({
       },
     }
     set({ cancelCopilot: stop })
+    return true
   },
 
   stopCopilot: () => {
@@ -1879,6 +1988,11 @@ export const useStudio = create<StudioState>((set, get) => ({
     const s = get()
     const turn = s.copilotTurns.find((t) => t.id === turnId)
     const top = s.past[s.past.length - 1]
+    // 正式运行期间 undo 会被锁拦下、画布不动：不能照样把这一轮标成「已撤回」
+    if (formalRunning(s)) {
+      toast.warn(EDIT_LOCK_TEXT.formal, { key: 'studio:readonly' })
+      return false
+    }
     if (!turn?.checkpoint || !top || top.id !== turn.checkpoint || s.copilot.active) {
       toast.warn(`这一轮之后画布又改过了，不能单独撤掉它。用 ${formatShortcut('Mod+Z')} 逐步撤回，或者在版本历史里找回`)
       return false
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 7dfe0ff7..bff6cd6a 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -36,6 +36,8 @@ export interface Workflow {
   is_template: boolean
   status?: 'draft' | 'published' | 'governed'
   published_version?: number | null
+  /** 最近一次发布的署名。发布时没有署名为 null */
+  published_by?: string | null
   run_count?: number
   created_at?: string
   updated_at?: string
@@ -100,6 +102,9 @@ export interface Run {
   /** 失败时能定位到的节点 */
   error_node_id?: string | null
   started_by?: string | null
+  /** 发起时实际生效的记忆域和知识库（没指定时取设置里的默认值）。老后端不给 */
+  memory_scope?: string | null
+  collection?: string | null
   created_at?: string
   started_at?: string
   finished_at?: string | null
@@ -135,7 +140,19 @@ export interface Approval {
   resolved_at?: string | null
 }
 
-export interface Provider {
+/**
+ * 后端记着的最近一次测连接（模型接入、数据源、MCP 的列表接口都平铺这四项）。
+ * 没测过、或者连接配置改过之后全是 null。用 lib/health 的 healthFromServer 转成
+ * HealthRecord 给 HealthPill
+ */
+export interface ServerHealth {
+  last_checked_at?: string | null
+  last_check_ok?: boolean | null
+  last_latency_ms?: number | null
+  last_error?: string | null
+}
+
+export interface Provider extends ServerHealth {
   id: string
   name: string
   kind: string
@@ -220,6 +237,8 @@ export interface ValidationIssue {
   node_id?: string | null
   edge_id?: string | null
   message: string
+  /** 出问题的是节点配置里的哪一项：'prompt'、'tools'、'cases[1].condition'。老后端不给 */
+  field?: string | null
 }
 
 /** 单个节点在一次运行中的实时状态，驱动画布上的高亮。 */
@@ -323,6 +342,13 @@ export interface Conversation {
   turn_count: number
   /** 列表里的副标题，让人一眼认出是哪次聊天 */
   last_question: string
+  /**
+   * 最后一轮停在哪。左栏对这次没打开过的会话也能标出运行中、待审批、失败。
+   * 没有轮次时为 null；老后端不给
+   */
+  last_status?: 'running' | 'waiting' | 'error' | 'cancelled' | 'suspended' | 'done' | null
+  /** 最后一轮的运行。建图阶段就断了的没有 */
+  last_run_id?: string | null
 }
 
 export interface ConversationDetail extends Conversation {
@@ -342,9 +368,31 @@ export interface ConversationTurn {
   error: string
   /** 复核结论。null = 这一轮没复核过，和「复核过、没发现问题」不是一回事 */
   review?: ReviewResult | null
+  /**
+   * 可信度元数据（出具档位、运行类别、耗时、查库次数……），前端整块写、整块读，
+   * 后端只用它算 last_status。老轮次挂在 review.meta 下，后端读出来时统一放到这里
+   */
+  meta?: Record<string, any> | null
   created_at?: string
 }
 
+/**
+ * Copilot 改图前后都在、而绑定的工具变了的节点或协作成员。
+ * 画布上看不出来（节点还在），跑起来才发现查不了库，所以改图回执要明说
+ */
+export interface ToolChange {
+  node_id: string
+  label: string
+  /** 协作成员的名字；节点本身的工具为 null */
+  member: string | null
+  /** 配置里的哪一项：'tools' 或 'agents[2].tools' */
+  field: string
+  before: string[]
+  after: string[]
+  added: string[]
+  removed: string[]
+}
+
 /**
  * 一次运行跑完之后的复核结论（后端 engine/review.py）。
  *
diff --git a/scripts/check-canvas-fx.mjs b/scripts/check-canvas-fx.mjs
index 69c2d7a3..e331c94c 100644
--- a/scripts/check-canvas-fx.mjs
+++ b/scripts/check-canvas-fx.mjs
@@ -19,7 +19,11 @@
 // - 定位 / 去审批取景半路被拉远，落地卡在 compact 档（错误正文被藏）；
 // - 「只看执行路径」带进下一次运行；正式运行横幅盖住「恢复」；
 // - 同一刻的等人时长几处写几个数；只是点一下画布就暂停跟随；
-// - Esc 在右栏里按也清掉整次运行；泳道、节点格、坞高只能用鼠标。
+// - Esc 在右栏里按也清掉整次运行；泳道、节点格、坞高只能用鼠标；
+// - 运行中点节点，属性面板整块盖住右栏的运行视图（应当先请右栏滚到它的步骤）；
+// - 等审批时只能批不能放弃；回放时回边的 ×N、面板的用量拿终值冒充那一刻；
+// - Copilot 搭图时新节点落在视口外看不见；双击空白处只会缩放；1024 宽打开只看得见两张半卡；
+// - Copilot 删掉的节点一声不响就没了，看不出删的是哪个、原来在哪。
 import { chromium } from '../frontend/node_modules/playwright-core/index.mjs'
 
 const WEB = process.env.AGENTLAB_WEB ?? 'http://localhost:5273'
@@ -187,6 +191,13 @@ async function openStudio({ id = FX_ID, theme = 'dark', ...extra } = {}) {
   page.on('pageerror', (e) => errors.push('pageerror: ' + e.message))
   page.on('console', (m) => { if (m.type() === 'error' && !m.text().includes('404') && !m.text().includes('409')) errors.push(m.text()) })
   await fakeBackend(page)
+  // 主题：设置接口里存的偏好会在启动时盖过本地缓存，不改它的话「暗色」那一遍画出来是亮的
+  await page.route('**/api/settings', async (route) => {
+    if (route.request().method() !== 'GET') return route.continue()
+    const res = await route.fetch()
+    const body = await res.json().catch(() => ({}))
+    await route.fulfill({ response: res, json: { ...body, ui: { ...(body.ui ?? {}), theme } } })
+  })
   await page.goto(`${WEB}/studio/${id}`, { waitUntil: 'networkidle' })
   await page.waitForFunction((wid) => window.__studio?.getState().workflow?.id === wid, id, { timeout: 15000 })
   await page.waitForTimeout(700)
@@ -207,6 +218,18 @@ const seedRun = (page, extra = {}) => page.evaluate((x) => {
 }, extra)
 
 const count = (page, sel) => page.locator(sel).count()
+/** 轮询到条件成立或超时。取景有动画、热更新可能插一脚，固定等几百毫秒会偶发失败 */
+async function until(fn, { timeout = 3000, every = 100 } = {}) {
+  const end = Date.now() + timeout
+  for (;;) {
+    const v = await fn().catch(() => false)
+    if (v || Date.now() > end) return v
+    await new Promise((r) => setTimeout(r, every))
+  }
+}
+/** 开发服务器热更新会把页面整个重载（别的代理恰好在改代码），store 里灌的运行就没了 */
+const markBoot = (page) => page.evaluate(() => { window.__fxBoot = true })
+const reloaded = (page) => page.evaluate(() => !window.__fxBoot).catch(() => true)
 const capsule = (page) => page.locator('.sf-capsule')
 /** 工具栏上的「运行」发起按钮（胶囊的名字也以「运行中」开头，按全名找） */
 const launcher = (page) => page.locator('[data-run-control]').getByRole('button', { name: /^运行$/ })
@@ -330,6 +353,7 @@ console.log('=== 运行中：胶囊、光点、计时 ===')
 console.log('=== 等人：入边闸门，不流光点；去审批代替停止 ===')
 {
   const { browser, page } = await openStudio()
+  await markBoot(page)
   await seedRun(page)
   await feed(page, [...PARALLEL, ...TEAM_DONE, ...TO_REVIEW])
   await page.waitForTimeout(400)
@@ -351,12 +375,34 @@ console.log('=== 等人：入边闸门，不流光点；去审批代替停止 ==
   check('等人时全图 0 个光点', await count(page, '.edge-packet') === 0, `${await count(page, '.edge-packet')} 个`)
   check('小地图上等人的节点放大了一圈', await count(page, '.sf-mm-ring.sf-mm-waiting') === 1)
 
-  // 去审批：属性面板盖在右栏上时先让开，画布取景到等人的节点
-  await page.evaluate(() => window.__studio.setState({ focusRequest: null, selectedId: 'gate' }))
+  // 去审批：属性面板盖在右栏上时先让开，画布取景到等人的节点。右栏（助手面板）接
+  // agentlab:goto-approval 事件切到运行层、滚到审批卡；它接了（preventDefault）胶囊就不再自己找
+  await page.evaluate(() => {
+    window.__goto = []
+    window.addEventListener('agentlab:goto-approval', (e) => { window.__goto.push(e.detail); e.preventDefault() })
+    window.__studio.setState({ focusRequest: null, selectedId: 'gate' })
+    // 胶囊自己兜底时在整页里找审批卡（document.querySelector）；右栏接手时只在自己的
+    // 滚动区里找。数一下前者，就知道胶囊有没有在右栏接手之后还去找
+    window.__slotLookups = 0
+    const find = Document.prototype.querySelector
+    window.__restoreQuery = () => { Document.prototype.querySelector = find }
+    Document.prototype.querySelector = function (sel) {
+      if (String(sel).includes('data-approval-slot')) window.__slotLookups += 1
+      return find.call(this, sel)
+    }
+  })
   await capsule(page).getByRole('button', { name: /去审批/ }).click()
   await page.waitForTimeout(200)
   const went = await page.evaluate(() => ({ sel: window.__studio.getState().selectedId, focus: window.__studio.getState().focusRequest?.id }))
   check('去审批：属性面板让开、取景到等人的节点', went.sel === null && went.focus === 'review', JSON.stringify(went))
+  const goto = await page.evaluate(() => window.__goto)
+  check('去审批：广播给右栏（带运行和节点）', goto.length === 1 && goto[0].nodeId === 'review' && goto[0].runId === 'fxrun000001',
+    JSON.stringify(goto))
+  // 描边、滚动都不能拿来判断——右栏接手时自己也描同一圈、滚到同一张卡
+  await page.waitForTimeout(600)
+  const lookups = await page.evaluate(() => { window.__restoreQuery(); return window.__slotLookups })
+  check('右栏接手之后胶囊不再自己找卡片、不报「还没出现」', lookups === 0
+    && !(await page.locator('[aria-live]').allInnerTexts()).join('').includes('审批卡还没出现'), `整页找了 ${lookups} 次`)
 
   // F：在需要处理的队列里逐个定位
   await page.evaluate(() => window.__studio.setState({ focusRequest: null }))
@@ -365,6 +411,32 @@ console.log('=== 等人：入边闸门，不流光点；去审批代替停止 ==
   await page.waitForTimeout(200)
   const focus = await page.evaluate(() => window.__studio.getState().focusRequest?.id)
   check('F 定位到等人的节点', focus === 'review', String(focus))
+
+  // 放弃这次运行：等审批时的次级动作。关掉的审批找不回来，先问一句；确认后才调 /cancel
+  let cancels = 0
+  await page.route(/\/api\/runs\/fxrun000001\/cancel$/, (route) => {
+    cancels += 1
+    return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify({ ok: true, status: 'cancelled' }) })
+  })
+  const abandon = capsule(page).getByRole('button', { name: '放弃这次运行' })
+  check('等审批时有「放弃这次运行」', await abandon.count() === 1)
+  await abandon.click()
+  const ask = page.getByRole('dialog').filter({ hasText: '放弃这次运行？' })
+  await ask.waitFor({ timeout: 3000 }).catch(() => {})
+  const askText = (await ask.innerText().catch(() => '')).replace(/\s+/g, ' ')
+  check('放弃之前先问一句，写清后果', askText.includes('审批卡一并关闭') && cancels === 0, askText.slice(0, 80))
+  await ask.getByRole('button', { name: '放弃这次运行' }).click().catch(() => {})
+  await until(async () => cancels === 1, { timeout: 2000 })
+  check('确认后才调 /cancel', cancels === 1, String(cancels))
+  await feed(page, [ev(19, 'run.cancelled', null, {
+    timing: { wall_ms: 20000, active_ms: 14000, wait_ms: 6000 }, actor: '检查员', message: '放弃了这次运行，1 条待审批一并关闭',
+  }, 20)])
+  await page.waitForTimeout(300)
+  // 胶囊不见了多半是别的代理改代码触发了整页热更新（灌进 store 的运行没了）：报出来，别卡 30 秒崩掉
+  const opened = await capsule(page).locator('.sf-cap-main').click({ timeout: 5000 }).then(() => true).catch(() => false)
+  const line = opened ? await page.locator('.sf-hud-line').innerText().catch(() => '') : ''
+  check('取消之后说清谁放弃的、关了什么', line.includes('检查员 放弃了这次运行，1 条待审批一并关闭'),
+    opened ? line : `胶囊不见了${await reloaded(page) ? '：页面被热更新重载过，重跑确认' : ''}`)
   await browser.close()
 }
 
@@ -691,6 +763,17 @@ console.log('=== 正式运行：入口看 published_version；运行期间画布
   const formal = page.getByRole('button', { name: /正式运行 v2/ })
   check('草稿状态下正式运行入口还在（看 published_version）', await formal.count() === 1)
   check('画布有未保存改动时也能点', await formal.isEnabled())
+  // 运行类别的记号：正式运行实心圆点、探索运行空心；盾牌只留给发布等级，不在发起入口上混用
+  const marks = (sel) => page.evaluate((sel) => {
+    const root = document.querySelector(sel)
+    return {
+      formal: root?.querySelectorAll('svg.sf-dot[data-class="formal"]').length ?? 0,
+      exploratory: root?.querySelectorAll('svg.sf-dot[data-class="exploratory"]').length ?? 0,
+      shield: root?.querySelectorAll('.lucide-shield-check, svg[class*="shield"]').length ?? 0,
+    }
+  }, sel)
+  const bar = await marks('[data-run-control]')
+  check('正式运行入口是实心圆点，没有盾牌', bar.formal === 1 && bar.shield === 0, JSON.stringify(bar))
   await formal.click()
   await page.waitForSelector('.sf-pop', { timeout: 5000 })
   await page.waitForTimeout(400)
@@ -699,6 +782,16 @@ console.log('=== 正式运行：入口看 published_version；运行期间画布
   check('表单字段取已发布版本的（topic），不取画布的（q）',
     await page.locator('.sf-pop textarea#run-field-topic').count() === 1
     && await page.locator('.sf-pop textarea#run-field-q').count() === 0)
+  const formalPop = await marks('.sf-pop')
+  check('正式运行浮层的标题和确认按钮都是实心圆点', formalPop.formal === 2 && formalPop.exploratory === 0 && formalPop.shield === 0,
+    JSON.stringify(formalPop))
+  await page.keyboard.press('Escape')
+  await page.waitForTimeout(150)
+  await launcher(page).click()
+  await page.waitForSelector('.sf-pop', { timeout: 5000 })
+  const explorePop = await marks('.sf-pop')
+  check('探索运行浮层是空心圆点', explorePop.exploratory === 1 && explorePop.formal === 0 && explorePop.shield === 0,
+    JSON.stringify(explorePop))
   await page.keyboard.press('Escape')
 
   await page.evaluate(() => window.__studio.setState({ dirty: false }))
@@ -782,13 +875,30 @@ console.log('=== 打开宽图：以入口为左锚，缩放不低于可读下限
   const vp = () => page.evaluate(() => document.querySelector('.react-flow__viewport').style.transform)
   const t0 = Date.now() / 1000
   const wev = (seq, type, node_id, dt) => ({ seq, type, node_id, data: {}, ts: t0 + dt })
+  await markBoot(page)
   await seedRun(page, { workflow_id: WIDE_ID })
   await feed(page, [wev(1, 'run.started', null, 0), wev(2, 'node.started', 'n0', 0.1), wev(3, 'node.finished', 'n0', 0.2)])
+  // 航迹坞升起来、画布变矮之后再量：坞出现时保持中心的那一下也会挪视口
+  await page.waitForSelector('.tl', { timeout: 3000 }).catch(() => {})
   await page.waitForTimeout(300)
   check('n9 起初在视口外', !(await inView('n9')))
+  const vpFrom = await vp()
   await feed(page, [wev(4, 'node.started', 'n9', 0.3)])
-  await page.waitForTimeout(700)
-  check('跟随执行：视口外的节点开跑，镜头跟过去', await inView('n9'))
+  // 等视口真的动了、并且停在 n9 上：取景有 320ms 的动画，固定等一段时间会偶发落空
+  const followed = await until(async () => (await vp()) !== vpFrom && await inView('n9'))
+  const why = followed ? '' : JSON.stringify({
+    reloaded: await reloaded(page),
+    phase: await page.evaluate(() => window.__studio?.getState().runPhase).catch(() => null),
+    follow: await page.evaluate(() => window.__studio?.getState().follow).catch(() => null),
+    moved: (await vp()) !== vpFrom,
+  })
+  check('跟随执行：视口外的节点开跑，镜头跟过去', !!followed, why)
+  // 等这一趟飞完，再让下一个远处的节点开跑，趁镜头飞到一半时人抓住画布拖一下。
+  // React Flow 把被打断的那段动画的收尾推迟一拍才报，报到时人的拖动已经开始——
+  // 以前它把人的起点吃掉，拖完跟随照样不暂停
+  await until(async () => { const a = await vp(); await new Promise((r) => setTimeout(r, 120)); return a === await vp() })
+  await feed(page, [wev(5, 'node.finished', 'n9', 0.4), wev(6, 'node.started', 'n1', 0.5)])
+  await page.waitForTimeout(110)
   const pane = await page.locator('.react-flow__pane').boundingBox()
   await page.mouse.move(pane.x + 300, pane.y + 60)
   await page.mouse.down()
@@ -796,14 +906,21 @@ console.log('=== 打开宽图：以入口为左锚，缩放不低于可读下限
   await page.mouse.up()
   await page.waitForTimeout(200)
   const paused = await vp()
-  check('手动拖过画布：显示「已暂停跟随」', (await page.locator('.sf-follow').innerText()).includes('已暂停跟随'))
-  await feed(page, [wev(5, 'node.finished', 'n9', 0.4), wev(6, 'node.started', 'n2', 0.5)])
+  check('镜头飞到一半被人拖住：显示「已暂停跟随」',
+    (await page.locator('.sf-follow').innerText({ timeout: 3000 }).catch(() => '')).includes('已暂停跟随'))
+  await feed(page, [wev(7, 'node.finished', 'n1', 0.6), wev(8, 'node.started', 'n2', 0.7)])
   await page.waitForTimeout(700)
   check('暂停期间不再抢镜头', await vp() === paused)
   // 点名取景：已暂停也照做（是人要看它）
   await page.evaluate(() => window.__studio.getState().focusNode('n11'))
-  await page.waitForTimeout(700)
-  check('focusNode：画布取景到点名的节点', await inView('n11'))
+  check('focusNode：画布取景到点名的节点', !!(await until(() => inView('n11'))))
+  // 画布尺寸恰好在取景半路变了（航迹坞收起、升起）：保持中心那一下会打断动画，
+  // 打断之后要重新飞到目标，不能停在半路
+  await page.evaluate(() => window.__studio.getState().focusNode('n0'))
+  await page.waitForTimeout(90)
+  await page.locator('.tl').getByRole('button', { name: '收起航迹' }).click().catch(() => {})
+  check('取景半路画布变高：照样落到目标上', !!(await until(() => inView('n0'))))
+  await page.locator('.tl').getByRole('button', { name: '展开' }).click().catch(() => {})
   await page.evaluate(() => window.__studio.getState().clearRun())
   await page.waitForTimeout(200)
 
@@ -820,6 +937,294 @@ console.log('=== 打开宽图：以入口为左锚，缩放不低于可读下限
   await browser.close()
 }
 
+// ---------------------------------------------------------------- 运行中点节点
+
+console.log('=== 运行中点节点：先看它的步骤，属性面板是次级入口 ===')
+{
+  const { browser, page, errors } = await openStudio()
+  await seedRun(page)
+  await feed(page, PARALLEL_NOW)
+  await page.waitForTimeout(400)
+  await page.evaluate(() => {
+    window.__reveal = []
+    window.addEventListener('agentlab:reveal-step', (e) => window.__reveal.push(e.detail))
+  })
+  const sheet = () => count(page, '[data-inspector-sheet]')
+  const head = (id) => page.locator(`.react-flow__node[data-id="${id}"] .nc-head`)
+  await head('start').click()
+  await page.waitForTimeout(250)
+  const picked = await page.evaluate(() => ({ sel: window.__studio.getState().selectedId, reveal: window.__reveal }))
+  check('点跑过的节点：选中它', picked.sel === 'start', String(picked.sel))
+  check('属性面板不自动盖上右栏', await sheet() === 0)
+  check('请右栏滚到它的步骤（agentlab:reveal-step）', picked.reveal.length === 1 && picked.reveal[0].nodeId === 'start'
+    && picked.reveal[0].runId === 'fxrun000001', JSON.stringify(picked.reveal))
+  const peek = page.locator('.sf-peek')
+  check('画布上给出「…的配置」入口', await peek.count() === 1 && (await peek.innerText()).includes('问题'), await peek.innerText().catch(() => ''))
+  await peek.click()
+  await page.waitForTimeout(250)
+  check('点入口才打开属性面板', await sheet() === 1 && await count(page, '.sf-peek') === 0)
+  check('打开之后底部留着回到运行的那一条', await count(page, '[data-inspector-sheet] [data-run-phase]') === 1)
+  // 没跑过的节点在右栏里没有步骤可看：照常打开属性面板
+  await page.locator('.react-flow__pane').click({ position: { x: 20, y: 300 } })
+  await page.waitForTimeout(150)
+  await page.evaluate(() => { window.__reveal = [] })
+  await head('gate').click()
+  await page.waitForTimeout(250)
+  check('点没跑过的节点：照常打开属性面板，不请右栏滚动', await sheet() === 1
+    && await page.evaluate(() => window.__reveal.length) === 0)
+  // 双击跑过的节点：直接看配置
+  await page.locator('.react-flow__pane').click({ position: { x: 20, y: 300 } })
+  await page.waitForTimeout(150)
+  await head('team').dblclick()
+  await page.waitForTimeout(250)
+  check('双击节点直接打开属性面板', await sheet() === 1 && await page.evaluate(() => window.__studio.getState().selectedId) === 'team')
+  await page.keyboard.press('Escape')
+  await page.waitForTimeout(150)
+  check('Esc 收起属性面板、取消选中，运行还在', await sheet() === 0
+    && await page.evaluate(() => window.__studio.getState().runPhase) === 'running')
+  // 先看了步骤、运行随后结束：节点还选中着、面板没开。再点它（选中没变）也得打开面板
+  await head('start').click()
+  await page.waitForTimeout(200)
+  await page.evaluate(() => window.__studio.getState().clearRun())
+  await page.waitForTimeout(200)
+  const kept = await page.evaluate(() => window.__studio.getState().selectedId)
+  check('运行清掉之后仍选中的节点留着「…的配置」入口', kept !== 'start' || await count(page, '.sf-peek') === 1, String(kept))
+  await head('start').click()
+  await page.waitForTimeout(250)
+  check('没有运行时再点这个节点：打开属性面板', await sheet() === 1)
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await browser.close()
+}
+
+// ---------------------------------------------------------------- 回放：回边圈数、用量跟着游标
+
+console.log('=== 回放：回边的 ×N 和面板的用量都是那一刻的 ===')
+{
+  const { browser, page, errors } = await openStudio()
+  await seedRun(page)
+  // 两次模型调用，一次在第 5 秒、一次在第 12 秒；终态的后端累计和它们对得上
+  const usage = [
+    ev(30, 'llm.end', 'team', { agent: '检索员', model: 'm', input_tokens: 600, output_tokens: 200, cost_usd: 0.002 }, 5),
+    ev(31, 'llm.end', 'team', { agent: '分析员', model: 'm', input_tokens: 400, output_tokens: 200, cost_usd: 0.001 }, 12),
+  ]
+  const finished = TO_LOOP.map((e) => (e.type === 'run.finished'
+    ? { ...e, data: { ...e.data, usage: { input_tokens: 1000, output_tokens: 400, cost_usd: 0.003 } } } : e))
+  const all = [...PARALLEL, ...usage, ...TEAM_DONE, ...finished].sort((a, b) => a.ts - b.ts)
+    .map((e, i) => ({ ...e, seq: i + 1, replay: true }))
+  await feed(page, all)
+  await page.waitForTimeout(400)
+  const badge = () => page.locator('.sf-loop-badge').innerText().catch(() => '')
+  check('跑完：回边写兜回去几次（↺ ×1）', (await badge()).replace(/\s+/g, ' ') === '↺ ×1', await badge())
+  const at = (t) => page.evaluate((ms) => window.__studio.getState().setReplayAt(ms), (BASE + t) * 1000)
+  // 返工的第一轮还在跑：还没兜回去过
+  await at(18)
+  await page.waitForTimeout(250)
+  check('回放到第一轮：回边还没兜回去，不写次数', (await badge()).trim() === '↺', await badge())
+  // 协作团队跑到一半：只有第一次模型调用
+  await at(8)
+  await page.waitForTimeout(250)
+  await capsule(page).locator('.sf-cap-main').click()
+  const usageOf = async () => (await page.locator('.sf-metric', { hasText: '用量' }).innerText().catch(() => '')).replace(/\s+/g, ' ')
+  const mid = await usageOf()
+  check('回放：面板的用量是那一刻的（800 tok），不是终值', /800 tok/.test(mid) && !/1\.4k/.test(mid), mid)
+  const side = await page.locator('.react-flow__node[data-id="team"] .nc-tele-side').innerText().catch(() => '')
+  check('回放：卡片上的 token 也是那一刻的', /800 tok/.test(side), side)
+  await page.keyboard.press('Escape')
+  await page.evaluate(() => window.__studio.getState().setReplayAt(null))
+  await page.waitForTimeout(250)
+  await capsule(page).locator('.sf-cap-main').click()
+  const live = await usageOf()
+  check('回到实时：用量是整次运行的（1.4k tok）', /1\.4k tok/.test(live), live)
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await browser.close()
+}
+
+// ---------------------------------------------------------------- Copilot 搭图时的镜头
+
+console.log('=== Copilot 搭图：新节点在视口外时镜头跟过去，人一动手这一轮就不跟 ===')
+for (const reducedMotion of ['no-preference', 'reduce']) {
+  const { browser, page, errors } = await openStudio({ id: WIDE_ID, reducedMotion })
+  const inView = (id) => page.evaluate((nid) => {
+    const pane = document.querySelector('.react-flow').getBoundingClientRect()
+    const r = document.querySelector(`.react-flow__node[data-id="${nid}"]`).getBoundingClientRect()
+    return r.left >= pane.left && r.right <= pane.right && r.top >= pane.top && r.bottom <= pane.bottom
+  }, id)
+  const vp = () => page.evaluate(() => document.querySelector('.react-flow__viewport').style.transform)
+  const building = (on, cursor) => page.evaluate(({ on, cursor }) => {
+    const st = window.__studio
+    st.setState({ copilot: { ...st.getState().copilot, active: on }, copilotCursor: cursor })
+  }, { on, cursor })
+  const label = reducedMotion === 'reduce' ? '（减少动效）' : ''
+  check(`n11 起初在视口外${label}`, !(await inView('n11')))
+  await building(true, 'n11')
+  if (reducedMotion === 'reduce') {
+    // 减少动效时不做动画：下一帧就到位
+    await page.waitForTimeout(120)
+    check('减少动效：镜头直接到位，不飞', await inView('n11'))
+  } else {
+    check('助手刚放下的节点在视口外：镜头跟过去', !!(await until(() => inView('n11'))))
+    const z0 = await page.evaluate(() => document.querySelector('.react-flow').style.getPropertyValue('--zoom'))
+    // 人拖了一下画布：这一轮不再跟
+    const pane = await page.locator('.react-flow__pane').boundingBox()
+    await page.mouse.move(pane.x + 200, pane.y + 200)
+    await page.mouse.down()
+    await page.mouse.move(pane.x + 380, pane.y + 240, { steps: 5 })
+    await page.mouse.up()
+    await page.waitForTimeout(250)
+    const held = await vp()
+    await building(true, 'n0')
+    await page.waitForTimeout(700)
+    check('人动过镜头之后，这一轮不再抢', await vp() === held)
+    // 下一轮重新跟
+    await building(false, null)
+    await building(true, 'n0')
+    check('下一轮又跟上', !!(await until(() => inView('n0'))))
+    const z1 = await page.evaluate(() => document.querySelector('.react-flow').style.getPropertyValue('--zoom'))
+    check('跟镜头只平移，不改缩放', z0 === z1, `${z0} → ${z1}`)
+  }
+  await building(false, null)
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await browser.close()
+}
+
+// ---------------------------------------------------------------- Copilot 删掉的节点：原地虚线框
+
+console.log('=== Copilot 这一轮删掉的节点：原地留一道虚线框，停一下再淡出 ===')
+/** 照 store 的真实顺序走一轮：开始 → 节点没了 → 这一轮落定（diff 写着删了谁）→ 结束 */
+const removeInTurn = (page, id) => page.evaluate((id) => {
+  const st = window.__studio
+  const turn = { id: 'fx-turn', instruction: '去掉返工那一步', ops: [], phase: 'running', explanation: '', error: '' }
+  st.setState({ copilot: { ...st.getState().copilot, active: true } })
+  st.setState({ copilotTurns: [...st.getState().copilotTurns, turn] })
+  st.setState({
+    nodes: st.getState().nodes.filter((n) => n.id !== id),
+    edges: st.getState().edges.filter((e) => e.source !== id && e.target !== id),
+  })
+  st.setState({ copilotTurns: st.getState().copilotTurns.map((t) => (t.id === turn.id ? {
+    ...t, phase: 'done', outcome: 'applied',
+    diff: { added: [], removed: [id], changed: [], edgesAdded: 0, edgesRemoved: 2, total: 3 },
+  } : t)) })
+  st.setState({ copilot: { ...st.getState().copilot, active: false } })
+}, id)
+for (const reducedMotion of ['no-preference', 'reduce']) {
+  const { browser, page, errors } = await openStudio({ reducedMotion })
+  const was = await page.locator('.react-flow__node[data-id="fix"]').boundingBox()
+  await removeInTurn(page, 'fix')
+  await page.waitForTimeout(400)
+  const ghost = page.locator('.sf-ghost[data-ghost="fix"]')
+  if (reducedMotion === 'reduce') {
+    check('减少动效：不画虚线框', await ghost.count() === 0)
+  } else {
+    const box = await ghost.boundingBox()
+    const tag = await ghost.innerText().catch(() => '')
+    check('删掉的节点原地留一道虚线框，写着删的是谁', !!box && tag.includes('已删除 · 返工'), tag)
+    check('框就在它原来的位置、一样大', !!box && !!was && Math.abs(box.x - was.x) < 4 && Math.abs(box.y - was.y) < 4
+      && Math.abs(box.width - was.width) < 4, JSON.stringify({ was, box }))
+    const tagPx = await ghost.locator('.sf-ghost-tag').evaluate((el) => el.getBoundingClientRect().height)
+    check('标签在屏幕上读得清', tagPx >= 14, `${tagPx.toFixed(1)}px`)
+    check('虚线框不挡操作', await ghost.evaluate((el) => getComputedStyle(el).pointerEvents) === 'none')
+    await page.screenshot({ path: '/tmp/agentlab-canvas-fx-ghost.png' })
+    check('停一下就淡出、收掉', !!(await until(async () => await ghost.count() === 0, { timeout: 4000 })))
+  }
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await browser.close()
+}
+// 窄画布打开就是精简档（缩放 0.4 上下）：标签的字照样补回 11px，不跟着缩成 7px
+{
+  const { browser, page, errors } = await openStudio({ viewport: { width: 1024, height: 768 } })
+  await page.waitForTimeout(400)
+  const zoom = Number(await page.evaluate(() => document.querySelector('.react-flow').style.getPropertyValue('--zoom')))
+  // 质量门在前三列里，这个缩放下在视口内：截图看得到
+  await removeInTurn(page, 'gate')
+  await page.waitForTimeout(400)
+  const tag = await page.locator('.sf-ghost[data-ghost="gate"] .sf-ghost-tag').evaluate((el) => ({
+    h: el.getBoundingClientRect().height, font: parseFloat(getComputedStyle(el).fontSize),
+    clipped: el.scrollWidth > el.clientWidth + 1,
+  })).catch(() => null)
+  const px = tag ? tag.font * zoom : 0
+  check(`精简档（缩放 ${zoom.toFixed(2)}）：虚线框的标签照样读得清（屏幕上 ≥ 11px、高 ≥ 14px）`,
+    zoom < 0.5 && !!tag && px >= 10.9 && tag.h >= 14 && !tag.clipped,
+    tag ? `字 ${px.toFixed(1)}px · 高 ${tag.h.toFixed(1)}px${tag.clipped ? ' · 被截断' : ''}` : '没画虚线框')
+  await page.screenshot({ path: '/tmp/agentlab-canvas-fx-ghost-compact.png' })
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await browser.close()
+}
+
+// ---------------------------------------------------------------- 双击快速添加
+
+console.log('=== 双击空白处：在光标处快速添加节点 ===')
+{
+  const { browser, page, errors } = await openStudio()
+  const spot = await emptySpot(page)
+  const zoomOf = () => page.evaluate(() => document.querySelector('.react-flow').style.getPropertyValue('--zoom'))
+  const z0 = await zoomOf()
+  const n0 = await page.evaluate(() => window.__studio.getState().nodes.length)
+  await page.mouse.dblclick(spot.x, spot.y)
+  await page.waitForTimeout(250)
+  const quick = page.locator('.sf-quick')
+  check('双击空白处打开快速添加', await quick.count() === 1)
+  check('双击不再缩放画布', await zoomOf() === z0, `${z0} → ${await zoomOf()}`)
+  check('焦点直接在搜索框里', await page.evaluate(() => !!document.activeElement?.closest('.sf-quick input')))
+  const panel = await quick.boundingBox()
+  check('面板贴着双击处', !!panel && Math.abs(panel.x - spot.x) < 260 && Math.abs(panel.y - spot.y) < 320,
+    panel ? `${Math.round(panel.x)},${Math.round(panel.y)} / ${Math.round(spot.x)},${Math.round(spot.y)}` : '没有面板')
+  // 只打一个字：名字里有它的排在只是说明里提到它的前面（协作节点的说明里有「分派」）
+  await page.keyboard.type('分')
+  await page.waitForTimeout(100)
+  const first = await quick.locator('[role="option"][aria-selected="true"]').innerText().catch(() => '')
+  check('按名字搜，第一个就是要的', first.includes('条件分支'), first)
+  await page.keyboard.press('Enter')
+  await page.waitForTimeout(300)
+  const added = await page.evaluate(() => {
+    const st = window.__studio.getState()
+    const n = st.nodes[st.nodes.length - 1]
+    const el = document.querySelector(`.react-flow__node[data-id="${n.id}"]`)?.getBoundingClientRect()
+    return { total: st.nodes.length, type: n.data.nodeType, cx: el ? el.left + el.width / 2 : null, cy: el ? el.top + el.height / 2 : null }
+  })
+  check('回车放下一个条件分支', added.total === n0 + 1 && added.type === 'branch', JSON.stringify(added))
+  check('落在双击处（卡片中心对着光标）', added.cx != null && Math.abs(added.cx - spot.x) < 40 && Math.abs(added.cy - spot.y) < 40,
+    JSON.stringify({ spot, at: [added.cx, added.cy] }))
+  check('放下之后面板收起', await quick.count() === 0)
+  await page.evaluate(() => window.__studio.getState().select(null))
+  const spot2 = await emptySpot(page)
+  await page.mouse.dblclick(spot2.x, spot2.y)
+  await page.waitForTimeout(200)
+  await page.keyboard.press('Escape')
+  await page.waitForTimeout(150)
+  check('Esc 收起、不加节点', await quick.count() === 0
+    && await page.evaluate(() => window.__studio.getState().nodes.length) === n0 + 1)
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await browser.close()
+}
+
+// ---------------------------------------------------------------- 窄画布的打开取景
+
+console.log('=== 1024 宽打开：可读缩放下放不下三列时退到精简档，多看几列 ===')
+for (const theme of ['dark', 'light']) {
+  const { browser, page } = await openStudio({ theme, viewport: { width: 1024, height: 768 } })
+  await page.waitForTimeout(500)
+  // 两遍真的是两套主题：不然「亮暗都看过」只是同一张图看了两次
+  const shown = await page.evaluate(() => ({
+    attr: document.documentElement.dataset.theme ?? null,
+    scheme: getComputedStyle(document.documentElement).colorScheme,
+  }))
+  check(`${theme}: 画出来的确实是这一套主题`, shown.attr === theme && shown.scheme.includes(theme), JSON.stringify(shown))
+  const view = await page.evaluate(() => {
+    const rf = document.querySelector('.react-flow')
+    const pane = rf.getBoundingClientRect()
+    const nodes = [...document.querySelectorAll('.react-flow__node')]
+    const whole = nodes.filter((n) => {
+      const r = n.getBoundingClientRect()
+      return r.left >= pane.left && r.right <= pane.right && r.top >= pane.top && r.bottom <= pane.bottom
+    }).length
+    return { zoom: Number(rf.style.getPropertyValue('--zoom')), lod: rf.dataset.lod, whole, total: nodes.length, w: Math.round(pane.width) }
+  })
+  check(`${theme}: 1024 宽打开至少看得全四张卡`, view.whole >= 4, JSON.stringify(view))
+  check(`${theme}: 缩放不低于精简档下限 0.4，档位是精简卡`, view.zoom >= 0.4 - 1e-3 && view.lod === 'compact', JSON.stringify(view))
+  await page.screenshot({ path: `/tmp/agentlab-canvas-fx-open-1024-${theme}.png` })
+  await browser.close()
+}
+
 // ---------------------------------------------------------------- 关掉动效
 
 console.log('=== 系统关了动效 ===')
diff --git a/scripts/check-chat.mjs b/scripts/check-chat.mjs
index 9d5200e6..2540d188 100644
--- a/scripts/check-chat.mjs
+++ b/scripts/check-chat.mjs
@@ -13,9 +13,19 @@
 //   3. 服务重启：stream.end status=interrupted 且没有待审批，这一轮收成
 //      「服务重启，这一轮中断了」，给接着跑，不再转圈；
 //   4. 加载中 / 加载失败 / 真的是空的 三种状态分开，加载失败时不能在空态上提问；
-//   5. 已取消的轮次没有「接着跑」，续跑被拒时说人话；
+//   5. 已取消的、人驳回这类原样续上还会失败的轮次没有「接着跑」，续跑被拒时说人话；
 //   6. 1440×900 下长会话的输入框和发送键完整可见，整页不多滚；
-//   7. 首屏例句不拿系统表造句；可信度信息刷新后还在。
+//   7. 首屏例句不拿系统表造句；可信度信息刷新后还在，且写进单独的 meta，不夹在 review 里；
+//   8. 从库里恢复的半路轮次：核对撞上 500 有出路、补交付不走实时计时、查到的终态落库；
+//   9. 长答案没取全要记进 meta，刷新后补全；2000 字按码点数，不按 UTF-16；
+//  10. 发起运行失败：报错不糊成一整行粗体，不许诺不存在的自动重试；重跑挂起的轮次
+//      顺手取消旧运行；断在建图阶段按最后一次落库算有没有动静，发起运行时 meta 跟上新运行；
+//  11. 左栏：没打开过的会话也标得出状态；筛选框在有筛选词时不消失；删掉的会话进回收站，
+//      能预览、恢复、彻底删除（要确认）；回收站里只能看，不发起任何运行，正在跑的不给
+//      彻底删除（清空也跳过它）；
+//  12. 限定数据源：点一下只查这个库，请求里带上 datasource_ids，库不在了说人话、补救是放开范围；
+//      库列表没取回来时，从上一问接过来的范围照样看得见；
+//  13. 画布助手的「在现有图上改 | 从头生成」分段控件；助手出错时同一句报错只说一遍。
 //
 // 所有写请求都被拦在浏览器里，不碰任何库。
 import { chromium } from '../frontend/node_modules/playwright-core/index.mjs'
@@ -45,12 +55,17 @@ const check = (name, cond, detail = '') => {
 // ---------------------------------------------------------------- 伪造的数据
 
 const iso = (minsAgo) => new Date(Date.now() - minsAgo * 60_000).toISOString()
-const conv = (id, title, turns, minsAgo) => ({
+const YESTERDAY_NOON = Math.round((Date.now() - new Date(new Date().setHours(12, 0, 0, 0) - 86_400_000).getTime()) / 60_000)
+const conv = (id, title, turns, minsAgo, extra = {}) => ({
   id, title, kind: 'chat', workflow_id: null, archived: false,
   created_at: iso(minsAgo + 5), last_active_at: iso(minsAgo), turn_count: turns, last_question: title,
+  last_status: turns ? 'done' : null, last_run_id: null, ...extra,
 })
 const LONG = (n) => Array.from({ length: n }, (_, i) =>
   `${i + 1}. 这一段是很长的结论正文，用来把会话撑到超过一屏，检查输入框会不会被挤出视口。`).join('\n')
+const FULL = '这是完整答案的开头。' + '正文'.repeat(1920) + '【完整结尾】'   // 3,850 字左右
+// 后端按码点截在 2000：带 BMP 之外的字符时，JS 的 length 会比 2000 多
+const ASTRAL_2000 = '旧'.repeat(1995) + '📊'.repeat(5)
 const turn = (id, question, extra = {}) => ({
   id, seq: 0, question, answer: '', explanation: '', graph: null, run_id: null,
   status: 'done', error: '', review: null, created_at: iso(30), ...extra,
@@ -70,16 +85,40 @@ const CONVS = {
   longC: conv('c0longc', '会话 C：长会话，检查布局', 6, 60),
   slowD: conv('c0slowd', '会话 D：历史取得慢', 2, 90),
   failE: conv('c0faile', '会话 E：历史取失败', 3, 120),
-  histF: conv('c0histf', '会话 F：取消过、失败过、不可用的历史', 4, 60 * 30),
+  // 「昨天」按日历算：写死 30 小时前的话，凌晨 6 点前跑会落进前天，分组检查就挂了
+  histF: conv('c0histf', '会话 F：取消过、失败过、不可用的历史', 4, YESTERDAY_NOON),
   emptyG: conv('c0emptg', '新对话', 0, 60 * 24 * 3),
   truncH: conv('c0trunc', '会话 H：长答案', 0, 60 * 24 * 10),
-  restI: conv('c0resti', '会话 I：跑到一半服务重启', 0, 60 * 24 * 12),
-  buildJ: conv('c0buildj', '会话 J：建流程就失败', 0, 60 * 24 * 13),
-  waitK: conv('c0waitk', '会话 K：停在审批上', 0, 60 * 24 * 14),
-  writeL: conv('c0writel', '会话 L：模型正在出字', 0, 60 * 24 * 15),
+  // 下面四个在「列表」那段里没打开过：状态只能从列表接口的 last_status 来
+  restI: conv('c0resti', '会话 I：跑到一半服务重启', 0, 60 * 24 * 12, { last_status: 'suspended' }),
+  buildJ: conv('c0buildj', '会话 J：建流程就失败', 0, 60 * 24 * 13, { last_status: 'error' }),
+  waitK: conv('c0waitk', '会话 K：停在审批上', 0, 60 * 24 * 14, { last_status: 'waiting', last_run_id: 'run-wait' }),
+  writeL: conv('c0writel', '会话 L：模型正在出字', 0, 60 * 24 * 15, { last_status: 'running' }),
   metaM: conv('c0metam', '会话 M：刷新之后的可信度', 1, 60 * 24 * 16),
   killN: conv('c0killn', '会话 N：服务被强杀', 0, 60 * 24 * 17),
-  suspO: conv('c0suspo', '会话 O：三天前被重启打断的', 1, 60 * 24 * 3),
+  suspO: conv('c0suspo', '会话 O：三天前被重启打断的', 1, 60 * 24 * 3, { last_status: 'suspended' }),
+  unkP: conv('c0unkp', '会话 P：核对时后端出错', 1, 60 * 24 * 18),
+  lateQ: conv('c0lateq', '会话 Q：跑完了、没来得及交付', 1, 60 * 24 * 3),
+  termR: conv('c0termr', '会话 R：停在半路的几轮', 5, 60 * 24 * 19),
+  clipS: conv('c0clips', '会话 S：长答案没取全', 0, 60 * 24 * 20),
+  clipT: conv('c0clipt', '会话 T：刷新之后补全长答案', 3, 60 * 24 * 21),
+  launchU: conv('c0launu', '会话 U：发起运行失败', 0, 60 * 24 * 22),
+  scopeV: conv('c0scopv', '会话 V：限定数据源', 1, 60 * 24 * 23),
+  scopeW: conv('c0scopw', '会话 W：上一问限定过数据源', 1, 60 * 24 * 24),
+  buildX: conv('c0buildx', '会话 X：两天前的问题，别处刚又跑了一遍', 2, 60 * 24 * 25),
+}
+/** 回收站里的：列表接口只有带 include_archived 才给 */
+const TRASHED = {
+  trash1: conv('c0trash1', '删掉的对话甲', 3, 60 * 24 * 2, { archived: true }),
+  trash2: conv('c0trash2', '删掉的对话乙', 1, 60 * 24 * 40, { archived: true }),
+}
+/** 只在「回收站里只能看」那段出现，免得别的段数回收站里有几个时数错 */
+const TRASH_MORE = {
+  // 各种能补救的轮次都有一个：没跑的、停在审批上的、跑挂了的、结论不可用的
+  trash3: conv('c0trash3', '删掉的对话丙：各种没跑完的', 4, 60 * 24 * 4, { archived: true, last_status: 'done' }),
+  // 删掉之后又跑起来了（比如在「记录」里通过了审批）：它底下有一个真在跑的运行
+  trash4: conv('c0trash4', '删掉的对话丁：还在跑', 1, 60 * 24 * 5,
+    { archived: true, last_status: 'running', last_run_id: 'run-trash-live' }),
 }
 const DETAIL = {
   c0busya: [],
@@ -93,6 +132,8 @@ const DETAIL = {
     turn('tf1', '被我停下的那一轮', { status: 'error', error: '已取消', graph: GRAPH, run_id: 'run-cancelled' }),
     // 运行失败了：可以接着跑，但这次后端会拒绝（比如别处已经把它续跑完了）
     turn('tf2', '跑挂了的那一轮', { status: 'error', error: 'KeyError: 查询超时，数据库没有在 30 秒内返回', graph: GRAPH, run_id: 'run-failed' }),
+    // 人工驳回：原样接着跑只会再被驳回一次（lib/explain 的 continuable=false），不给「接着跑」
+    turn('tf5', '被人驳回的那一轮', { status: 'error', error: '人工驳回：数字对不上', graph: GRAPH, run_id: 'run-rejected' }),
     // 没有运行、没有图，却有答案：reply，没查库。老数据没有 meta，靠推断
     turn('tf3', '上一轮的数字是多少', { answer: '上一轮查到的是 42。' }),
     // 复核判为不可用，原因是步数用满
@@ -101,8 +142,8 @@ const DETAIL = {
       review: {
         verdict: 'annotated', note: 'agent 用满了 12 步还没给出结论。', answer: null, retry: true, severity: 'broken',
         signals: [{ kind: 'step_limit', detail: 'agent 用满了 12 步', severity: 'broken' }],
-        meta: { v: 1, runId: 'run-broken', runClass: 'exploratory', runStatus: 'succeeded', queries: 3, ms: 41000 },
       },
+      meta: { v: 1, runId: 'run-broken', runClass: 'exploratory', runStatus: 'succeeded', queries: 3, ms: 41000 },
     }),
   ],
   c0emptg: [],
@@ -115,37 +156,129 @@ const DETAIL = {
   // 三天前服务重启打断、跑了 42 秒的那一轮
   c0suspo: [turn('to1', '三天前没跑完的问题', {
     status: 'error', error: '服务重启，这一轮中断了', graph: GRAPH, run_id: 'run-susp', created_at: iso(60 * 24 * 3),
-    review: { meta: { v: 1, runId: 'run-susp', runStatus: 'interrupted', outcome: 'suspended', ms: 42000 } },
+    meta: { v: 1, runId: 'run-susp', runStatus: 'interrupted', outcome: 'suspended', ms: 42000 },
   })],
-  // 出具档位、运行类别、耗时、查库次数只存在 review.meta 里：刷新后得从这里读回来，
+  // 出具档位、运行类别、耗时、查库次数只存在 meta 里：刷新后得从这里读回来，
   // 而不是再去问一遍运行
   c0metam: [turn('tm1', '上个月各产线的出勤率', {
     answer: '一线 96.2%，二线 91.0%。', graph: GRAPH, run_id: 'run-meta',
-    review: { meta: {
+    meta: {
       v: 1, runId: 'run-meta', runClass: 'exploratory', runStatus: 'succeeded', ms: 12300, queries: 2,
       issuance: { tier: 'degraded', gaps: ['叙述模板渲染为空'], matched_numbers: 2, metrics_checked: 3, unmatched_numbers: [] },
-    } },
+    },
   })],
+  // 上次停在半路（轮次还是 running），核对时后端回 500
+  c0unkp: [turn('tp1', '核对时撞上后端出错的那一轮', {
+    status: 'running', graph: GRAPH, run_id: 'run-unk', created_at: iso(60 * 24 * 2),
+  })],
+  // 运行三天前就跑完了，交付没赶上：补交付期间不能按实时运行从三天前起算计时
+  c0lateq: [turn('tq1', '三天前跑完、没交付的问题', {
+    status: 'running', graph: GRAPH, run_id: 'run-late', created_at: iso(60 * 24 * 3),
+  })],
+  // 轮次都还是 running，运行早已各有结局：查到之后要落库，不能每次进来都重新核对
+  c0termr: [
+    turn('tr1', '在别处被取消的那一轮', { status: 'running', graph: GRAPH, run_id: 'run-t-cancel' }),
+    turn('tr2', '在别处失败的那一轮', { status: 'running', graph: GRAPH, run_id: 'run-t-failed' }),
+    turn('tr3', '服务重启挂起的那一轮', { status: 'running', graph: GRAPH, run_id: 'run-t-susp' }),
+    turn('tr4', '运行记录被删掉的那一轮', { status: 'running', graph: GRAPH, run_id: 'run-404-t' }),
+    turn('tr5', '还停在审批上的那一轮', { status: 'running', graph: GRAPH, run_id: 'run-t-wait' }),
+  ],
+  c0clips: [],
+  c0clipt: [
+    // 上次交付时 GET 运行失败，只拿到事件里截断的那份：meta 记着 partial，刷新后要补全。
+    // 多个键拼起来比 2000 长，光看长度是认不出来的
+    turn('tt1', '多个成果键的长答案', {
+      answer: `${FULL.slice(0, 2000)}\n附注：另一个成果键`, graph: GRAPH, run_id: 'run-multi',
+      meta: { v: 1, runId: 'run-multi', runStatus: 'succeeded', clipped: 'partial' },
+    }),
+    // 恰好 2000 个码点（UTF-16 是 2005）、运行也没了：补不回来，但要标出来
+    turn('tt2', '旧版本被截断、运行没了的长答案', { answer: ASTRAL_2000, graph: GRAPH }),
+    turn('tt3', '旧版本被截断、运行记录删掉了的长答案', { answer: ASTRAL_2000, graph: GRAPH, run_id: 'run-404-clip' }),
+  ],
+  c0launu: [],
+  c0scopv: [turn('tv1', '上一问', { answer: '上一问的答案', graph: GRAPH, run_id: 'run-b1' })],
+  c0scopw: [turn('tw0', '上一问只查了一个库', {
+    answer: '上一问的答案 W', graph: GRAPH, run_id: 'run-b1',
+    meta: { v: 1, runId: 'run-b1', runStatus: 'succeeded', scope: [{ id: 'ds-plant', name: 'factory' }] },
+  })],
+  // 两天前问的、刚被重试过：run_id 列还指着上一次的运行（清不掉），meta.runId 是 null。
+  // 有没有动静按 meta.at 算——取的那一刻才定，脚本跑得再久也是「2 分钟前」「20 分钟前」
+  c0buildx: () => [
+    turn('tx7', '两分钟前在别的页面里重试的问题', {
+      status: 'running', graph: GRAPH, run_id: 'run-failed', created_at: iso(60 * 24 * 2),
+      meta: { v: 1, runId: null, at: Date.now() - 2 * 60_000 },
+    }),
+    turn('tx8', '重试之后二十分钟没动静的问题', {
+      status: 'running', graph: GRAPH, run_id: 'run-failed', created_at: iso(60 * 24 * 2),
+      meta: { v: 1, runId: null, at: Date.now() - 20 * 60_000 },
+    }),
+  ],
+  c0trash1: [turn('tx1', '回收站里的问题', { answer: '回收站里的答案', graph: GRAPH, run_id: 'run-b1' })],
+  c0trash2: [],
+  c0trash3: [
+    turn('ty0', '搭好了没跑的问题', { graph: GRAPH }),
+    turn('ty1', '停在审批上的问题', { status: 'running', graph: GRAPH, run_id: 'run-trash-wait' }),
+    turn('ty2', '跑挂了的问题', {
+      status: 'error', error: '查询超时', graph: GRAPH, run_id: 'run-failed',
+      meta: { v: 1, runId: 'run-failed', runStatus: 'failed' },
+    }),
+    turn('ty3', '步数用满、结论不可用的问题', {
+      answer: '只查了一半的结论', graph: GRAPH, run_id: 'run-broken',
+      review: {
+        verdict: 'annotated', note: 'agent 用满了 12 步还没给出结论。', answer: null, retry: true, severity: 'broken',
+        signals: [{ kind: 'step_limit', detail: 'agent 用满了 12 步', severity: 'broken' }],
+      },
+      meta: { v: 1, runId: 'run-broken', runStatus: 'succeeded' },
+    }),
+  ],
+  c0trash4: [turn('tz1', '删掉之后还在跑的问题', { status: 'running', graph: GRAPH, run_id: 'run-trash-live', created_at: iso(10) })],
 }
 const RUNS = {
   'run-cancelled': { status: 'cancelled', output: {}, error: null },
   'run-failed': { status: 'failed', output: {}, error: '查询超时' },
+  'run-rejected': { status: 'failed', output: {}, error: '人工驳回：数字对不上' },
   'run-broken': { status: 'succeeded', output: { answer: '只查了一半的结论' }, error: null },
+  'run-late': { status: 'succeeded', output: { answer: '补交付的答案：三条记录。' }, error: null,
+                started_at: iso(60 * 24 * 3 - 1), finished_at: iso(60 * 24 * 3 - 1.5) },
+  'run-t-cancel': { status: 'cancelled', output: {}, error: null },
+  'run-t-failed': { status: 'failed', output: {}, error: '鉴权没通过（401）：对方拒绝了这把密钥' },
+  'run-multi': { status: 'succeeded', output: { answer: FULL, note: '附注：另一个成果键' }, error: null },
+  'run-trash-live': { status: 'running', output: {}, error: null },
 }
-const FULL = '这是完整答案的开头。' + '正文'.repeat(1920) + '【完整结尾】'   // 3,850 字左右
 const SOURCES = [
   { id: 'ds-mig', name: 'shop', kind: 'mysql', description: '' },
-  { id: 'ds-bi', name: 'bi', kind: 'oracle', description: '示例 BI 库：采购、物料、生产、设备' },
+  { id: 'ds-plant', name: 'factory', kind: 'oracle', description: '示例工厂库：采购、物料、生产、设备' },
 ]
 const TABLES = {
-  'ds-mig': ['__drizzle_migrations', '_migrations', 'admin_audit_log', 'app_log', 'test_sales', 'user', 'orders'],
-  'ds-bi': ['ANALYTICS.test_sales', 'ANALYTICS.job_etl_audit', 'ANALYTICS.v_demo_table'],
+  'ds-mig': ['__prisma_migrations', 'schema_migrations', 'admin_audit_log', 'app_log', 'test_sales', 'user', 'orders'],
+  'ds-plant': ['ANALYTICS.test_sales', 'ANALYTICS.job_etl_audit', 'ANALYTICS.v_demo_table'],
 }
 
 // ---------------------------------------------------------------- 伪造的后端
 
-const log = { patches: [], cancels: [], continues: [], runStarts: [], archived: [], posts: [], approvalGets: [], runGets: [] }
-const ctl = { slowMs: 0, failE: true, wsClosed: {}, approvals: [], thinkGo: false, writingGo: false, writingAt: 0 }
+const log = {
+  patches: [], cancels: [], continues: [], runStarts: [], archived: [], posts: [], approvalGets: [], runGets: [],
+  deleted: [], gens: [],
+}
+const ctl = {
+  slowMs: 0, failE: true, wsClosed: {}, approvals: [], thinkGo: false, writingGo: false, writingAt: 0,
+  /** 列表只给前 8 个：筛选框刚好出现，删一个就不够 8 个了 */
+  few: false, run500: true, reviewDelay: {}, launchFail: true, scope400: false,
+  /** 回收站里多摆两个（TRASH_MORE） */
+  trashMore: false,
+  /** 数据源列表取不回来 */
+  sourcesFail: false,
+}
+/** 会话的归档 / 删除状态。各段各自 resetDb，免得上一段删掉的会话影响下一段 */
+const db = { archived: new Set(), purged: new Set() }
+const resetDb = () => {
+  db.archived = new Set([...Object.values(TRASHED), ...Object.values(TRASH_MORE)].map((c) => c.id))
+  db.purged = new Set()
+}
+resetDb()
+const allConvs = () => [...Object.values(CONVS), ...Object.values(TRASHED), ...(ctl.trashMore ? Object.values(TRASH_MORE) : [])]
+  .filter((c) => !db.purged.has(c.id))
+  .map((c) => ({ ...c, archived: db.archived.has(c.id) }))
 let runSeq = 0
 
 async function fakeApi(route) {
@@ -156,18 +289,36 @@ async function fakeApi(route) {
   const json = (body, status = 200) => route.fulfill({ status, json: body })
   const body = () => { try { return req.postDataJSON() } catch { return {} } }
 
-  if (path === '/conversations' && method === 'GET') return json(Object.values(CONVS))
+  if (path === '/conversations' && method === 'GET') {
+    if (url.searchParams.get('kind') === 'canvas') return json([])
+    const rows = allConvs()
+    const live = rows.filter((c) => !c.archived)
+    const shown = ctl.few ? live.slice(0, 8) : live
+    return json(url.searchParams.get('include_archived') === 'true' ? [...shown, ...rows.filter((c) => c.archived)] : shown)
+  }
   if (path === '/conversations' && method === 'POST') return json({ ...conv('c0new', '新对话', 0, 0), turns: [] }, 201)
   let m = path.match(/^\/conversations\/([^/]+)$/)
   if (m && method === 'GET') {
     const id = m[1]
     if (id === 'c0slowd') await new Promise((r) => setTimeout(r, ctl.slowMs))
     if (id === 'c0faile' && ctl.failE) return json({ detail: '数据库暂时不可用' }, 500)
-    const known = Object.values(CONVS).find((c) => c.id === id)
+    const known = allConvs().find((c) => c.id === id)
     if (!known && id !== 'c0new') return json({ detail: '这个对话不存在，可能已经被删了' }, 404)
-    return json({ ...known, turns: DETAIL[id] ?? [] })
+    const turns = typeof DETAIL[id] === 'function' ? DETAIL[id]() : DETAIL[id]
+    return json({ ...(known ?? conv('c0new', '新对话', 0, 0)), turns: turns ?? [] })
+  }
+  if (m && method === 'PATCH') {
+    const b = body()
+    log.archived.push([m[1], b])
+    if (b.archived === true) db.archived.add(m[1])
+    if (b.archived === false) db.archived.delete(m[1])
+    return json({ ...allConvs().find((c) => c.id === m[1]), ...b })
+  }
+  if (m && method === 'DELETE') {
+    log.deleted.push(m[1])
+    db.purged.add(m[1])
+    return route.fulfill({ status: 204, body: '' })
   }
-  if (m && method === 'PATCH') { log.archived.push([m[1], body()]); return json({ ...CONVS[m[1]], ...body() }) }
   m = path.match(/^\/conversations\/([^/]+)\/turns$/)
   if (m && method === 'POST') {
     log.posts.push(m[1])
@@ -177,7 +328,12 @@ async function fakeApi(route) {
   if (m && method === 'PATCH') { log.patches.push({ conv: m[1], turn: m[2], body: body() }); return json(turn(m[2], '', body())) }
 
   if (path === '/copilot/generate-stream' && method === 'POST') {
-    if (String(body().instruction ?? '').includes('建流程就失败')) {
+    const b = body()
+    log.gens.push(b)
+    if (ctl.scope400 && b.datasource_ids?.length) {
+      return json({ detail: '限定的数据源都不在了：可能已经被删掉或停用。去掉限定再问，或者到「数据」页确认它还在、而且是启用的' }, 400)
+    }
+    if (String(b.instruction ?? '').includes('建流程就失败')) {
       // 后端的 error 操作是三段：人话、怎么办、原始异常
       const ops = [
         { op: 'heartbeat', phase: 'planning', elapsed_ms: 400 },
@@ -199,12 +355,16 @@ async function fakeApi(route) {
       body: ops.map((o) => `data: ${JSON.stringify(o)}\n\n`).join('') })
   }
   if (path === '/copilot/review' && method === 'POST') {
+    const wait = ctl.reviewDelay[body().run_id]
+    if (wait) await new Promise((r) => setTimeout(r, wait))
     return json({ verdict: 'ok', note: '', answer: null, retry: false, severity: '', signals: [] })
   }
   if (path === '/runs' && method === 'POST') {
     const b = body()
     const conversation = String(b.input?.question ?? '')
-    const id = conversation.includes('长答案') ? 'run-long'
+    // 发起请求根本没到后端（网断了、后端正在重启）
+    if (conversation.includes('启动失败') && ctl.launchFail) return route.abort('connectionrefused')
+    const id = conversation.includes('长答案') ? (conversation.includes('取不到运行') ? 'run-noget' : 'run-long')
       : conversation.includes('审批') ? 'run-wait'
       : conversation.includes('重启') ? 'run-restart'
       : conversation.includes('正在写') ? 'run-writing'
@@ -226,6 +386,9 @@ async function fakeApi(route) {
     const id = m[1]
     log.runGets.push(id)
     if (id === 'run-long') return json({ id, status: 'succeeded', run_class: 'exploratory', output: { answer: FULL }, usage: {} })
+    if (id === 'run-noget' || (id === 'run-unk' && ctl.run500)) return json({ detail: '后端出错了，详情看服务日志' }, 500)
+    if (id === 'run-unk') return json({ id, status: 'cancelled', run_class: 'exploratory', output: {}, usage: {} })
+    if (id.startsWith('run-404')) return json({ detail: '运行不存在' }, 404)
     if (RUNS[id]) return json({ id, run_class: 'exploratory', usage: {}, ...RUNS[id] })
     if (id.startsWith('run-c') || id === 'run-b1') return json({ id, status: 'succeeded', run_class: 'exploratory', output: {}, usage: {} })
     return json({ id, status: 'interrupted', run_class: 'exploratory', output: {}, usage: {} })
@@ -240,7 +403,9 @@ async function fakeApi(route) {
     return json([ev(1, 'run.started', null, { nodes: 3 }), ev(2, 'node.started', 'ag', {}),
       ev(3, 'node.finished', 'ag', { duration_ms: 700 }), ev(4, 'run.finished', null, { output: {} })])
   }
-  if (path === '/datasources' && method === 'GET') return json(SOURCES)
+  if (path === '/datasources' && method === 'GET') {
+    return ctl.sourcesFail ? json({ detail: '数据源列表暂时取不到' }, 500) : json(SOURCES)
+  }
   m = path.match(/^\/datasources\/([^/]+)\/schema$/)
   if (m) return json({ tables: TABLES[m[1]] ?? [] })
 
@@ -251,6 +416,17 @@ async function fakeApi(route) {
 /** 每条运行的事件剧本。done=true 时剧本放完就发 stream.end */
 const ev = (seq, type, node_id, data = {}) => ({ seq, type, node_id, data, ts: Date.now() / 1000 })
 function script(runId, after = 0) {
+  if (runId === 'run-noget') {
+    // 事件里的成果被切过，交付时 GET 运行又失败了：只能先交这一份，并且要记下来
+    return {
+      events: [
+        ev(1, 'run.started', null, { nodes: 3 }),
+        ev(2, 'node.finished', 'ag', { duration_ms: 900 }),
+        ev(3, 'run.finished', null, { output: { answer: FULL.slice(0, 2000), note: '附注' }, output_truncated: true }),
+      ],
+      end: 'succeeded',
+    }
+  }
   if (runId === 'run-long') {
     return {
       events: [
@@ -315,7 +491,7 @@ function script(runId, after = 0) {
         ev(1, 'run.started', null, { nodes: 3 }),
         ev(2, 'node.started', 'ag', {}),
         ev(3, 'llm.start', 'ag', { model: 'm' }),
-        ev(4, 'llm.thinking.delta', 'ag', { delta: '先看看 bi 里有哪些表。' }),
+        ev(4, 'llm.thinking.delta', 'ag', { delta: '先看看 factory 里有哪些表。' }),
         ev(5, 'llm.thinking.delta', 'ag', { delta: '然后按月汇总出勤' }),
         { gate: 'thinkGo' },
         ev(6, 'llm.thinking.delta', 'ag', { delta: '率，再和上个月比。' }),
@@ -414,8 +590,8 @@ for (const theme of THEMES) {
     const hints = await page.locator('button[title="填进输入框，改一改再发"]').allInnerTexts()
     check('有例句', hints.length > 0, hints.join(' | '))
     check('例句里没有系统表',
-      hints.every((h) => !/__drizzle|_migrations|test_|etl_audit|_log\b/.test(h)), hints.join(' | '))
-    check('描述里的业务词造了句', hints.some((h) => /bi：/.test(h)), hints.join(' | '))
+      hints.every((h) => !/__prisma|_migrations|test_|etl_audit|_log\b/.test(h)), hints.join(' | '))
+    check('描述里的业务词造了句', hints.some((h) => /factory：/.test(h)), hints.join(' | '))
     const ph = await page.getByRole('textbox', { name: '向数据提问' }).getAttribute('placeholder')
     check('占位符简短', !!ph && ph.length <= 12, ph ?? '')
     const box = await page.getByRole('textbox', { name: '向数据提问' }).boundingBox()
@@ -550,11 +726,16 @@ for (const theme of THEMES) {
     check('落库的也是完整答案', saved.length > 0 && saved.every((p) => p.body.answer.length === FULL.length),
       saved.map((p) => p.body.answer.length).join(','))
     // 落库是排队异步发的，交付之后再等它一下
-    await until(() => log.patches.slice(patchesBefore).some((p) => p.body.review?.meta))
-    const metas = log.patches.slice(patchesBefore).map((p) => p.body.review?.meta).filter(Boolean)
+    await until(() => log.patches.slice(patchesBefore).some((p) => p.body.meta))
+    const metas = log.patches.slice(patchesBefore).map((p) => p.body.meta).filter(Boolean)
     const meta = metas.at(-1)
     check('可信度信息跟着落库（运行、类别、查库次数）', meta?.runId === 'run-long' && meta?.runClass === 'exploratory',
       JSON.stringify(metas))
+    // 后端有了单独的 meta 列：review 只放复核结论，不再夹带
+    check('meta 单独写，不再塞进 review', log.patches.slice(patchesBefore)
+      .every((p) => !p.body.review || !('meta' in p.body.review)),
+      JSON.stringify(log.patches.slice(patchesBefore).map((p) => Object.keys(p.body.review ?? {}))))
+    check('完整答案取到了，meta 里没有「没取全」', !meta?.clipped, JSON.stringify(meta?.clipped))
     await page.getByText('展开全部').first().click().catch(() => {})
     check('完整结尾在页面上', await shows(page, '【完整结尾】'))
     check('没有运行时报错', errors.length === 0, errors[0] ?? '')
@@ -569,8 +750,9 @@ for (const theme of THEMES) {
     await page.waitForTimeout(300)
     const t = (await chatState(page)).byConversation.c0resti.at(-1)
     check('这一轮收成挂起', t.phase === 'suspended', t.phase)
-    const spinning = await page.locator('main .animate-spin, [role="main"] .animate-spin').count()
-      + await page.locator('.animate-spin').count()
+    // 只数这一轮自己和它在左栏的那一行：左栏里夹具的会话 L 本来就标着运行中，它转是对的
+    const spinning = await page.locator('[data-turn] .animate-spin').count()
+      + await page.locator('aside[aria-label="对话列表"] div.group', { hasText: '会话 I' }).locator('.animate-spin').count()
     check('不再转圈', spinning === 0, `${spinning} 个转圈`)
     check('给「接着跑」', await page.getByRole('button', { name: '接着跑' }).count() === 1)
     check('给「重跑这一轮」', await page.getByRole('button', { name: '重跑这一轮' }).count() === 1)
@@ -627,10 +809,14 @@ for (const theme of THEMES) {
     check('失败那一轮按运行状态给「接着跑」', turns[1].runStatus === 'failed'
       && await page.locator('[data-remedy="failed"]').getByRole('button', { name: '接着跑' }).count() === 1)
     const failedCard = await page.locator('[data-turn="tf2"]').innerText()
-    check('失败原因说人话、不露 Python 类名', failedCard.includes('查询超时') && !failedCard.includes('KeyError'),
-      failedCard.split('\n').slice(0, 4).join(' / '))
+    // 说法和记录页同一份（lib/explain）：它把超时归成「等待超时」，原话收进技术细节
+    check('失败原因说人话、不露 Python 类名', /超时/.test(failedCard) && !failedCard.includes('KeyError'),
+      failedCard.split('\n').slice(0, 6).join(' / '))
     // 人话只翻一遍：翻好的「操作超时：查询超时…」再翻一遍，标题和原因会各写一次「操作超时」
     check('报错标题和原因不重复', !failedCard.includes('操作超时：'), failedCard.split('\n').slice(2, 6).join(' / '))
+    const rejected = page.locator('[data-turn="tf5"] + * [data-remedy="failed"]')
+    check('人驳回的失败：不给「接着跑」（原样续上只会再被驳回）', await rejected.count() === 1
+      && !(await rejected.getByRole('button', { name: '接着跑' }).count()), (await rejected.innerText().catch(() => '')).replace(/\n/g, ' / '))
     check('没查库的老答案标出来了', await shows(page, '这一条没有查库'))
     const stepBtn = page.getByRole('button', { name: /放宽步数重跑（12 → 24 步）/ })
     check('步数用满给出「放宽步数重跑」并写明目标值', await stepBtn.count() === 1)
@@ -734,7 +920,7 @@ for (const theme of THEMES) {
       if (reducedMotion === 'no-preference') {
         const said = (text) => head.getByText(text, { exact: true }).first()
           .waitFor({ timeout: 8000 }).then(() => true, () => false)
-        check('思考时头部写出最后一句完整的话', await said('正在思考：先看看 bi 里有哪些表'))
+        check('思考时头部写出最后一句完整的话', await said('正在思考：先看看 factory 里有哪些表'))
         await page.waitForTimeout(400)
         check('还在写的半句不上头部', !(await head.getByText('然后按月汇总出勤').count()))
         await page.screenshot({ path: `${SHOTS}/thinking-${theme}.png` })
@@ -782,7 +968,8 @@ for (const theme of THEMES) {
     await ctx.close()
   }
 
-  if (section('list', '会话列表：分组、相对时间、完整标题、筛选')) {
+  if (section('list', '会话列表：分组、相对时间、完整标题、筛选、没打开过的也标状态')) {
+    resetDb()
     const { page, ctx, errors } = await open(theme)
     await goto(page, 'c0idleb')
     const aside = page.locator('aside[aria-label="对话列表"]')
@@ -793,6 +980,16 @@ for (const theme of THEMES) {
     check('写相对时间', /分钟前|刚刚/.test(await rowA.innerText()), (await rowA.innerText()).replace(/\n/g, ' / '))
     const tip = await aside.locator('div.group', { hasText: '会话 F' }).locator('button').first().getAttribute('title')
     check('悬停能看到完整标题', !!tip && tip.startsWith('会话 F：取消过、失败过、不可用的历史'), tip ?? '')
+    // 这几条这次都没打开过，状态只能来自列表接口的 last_status
+    const rowText = async (t) => (await aside.locator('div.group', { hasText: t }).innerText()).replace(/\n/g, ' / ')
+    check('没打开过的：停在审批上的标「待审批」', (await rowText('会话 K')).includes('待审批'), await rowText('会话 K'))
+    check('没打开过的：失败的标「失败」', (await rowText('会话 J')).includes('失败'), await rowText('会话 J'))
+    check('没打开过的：服务重启挂起的标「已中断」', (await rowText('会话 I')).includes('已中断'), await rowText('会话 I'))
+    check('没打开过的：在跑的标「运行中」', (await rowText('会话 L')).includes('运行中'), await rowText('会话 L'))
+    check('正常完成的不标', !/待审批|失败|已中断|运行中/.test(await rowText('会话 M')), await rowText('会话 M'))
+    const rowL = aside.locator('div.group', { hasText: '会话 L' })
+    await rowL.hover()
+    check('列表说它在跑的，也不能删', await rowL.getByRole('button', { name: /删除/ }).isDisabled())
     const box = aside.getByRole('searchbox', { name: '按标题或问过的话找对话' })
     await box.fill('长会话')
     const hits = await aside.locator('div.group').allInnerTexts()
@@ -802,24 +999,69 @@ for (const theme of THEMES) {
     check('Esc 清掉筛选', (await aside.locator('div.group').count()) === Object.keys(CONVS).length)
     await box.fill('没有这样的对话')
     check('没有匹配时说一声', await aside.getByText('没有标题或问题里带「没有这样的对话」的对话').count() === 1)
+    await box.fill('')
+    await page.screenshot({ path: `${SHOTS}/list-status-${theme}.png` })
     check('没有运行时报错', errors.length === 0, errors[0] ?? '')
     await ctx.close()
   }
 
-  if (section('delete', '删除：确认，且可以撤销')) {
+  if (section('filter', '筛选框：有筛选词时不跟着列表变短一起消失')) {
+    resetDb()
+    ctl.few = true
+    const { page, ctx, errors } = await open(theme)
+    await goto(page, 'c0busya')
+    const aside = page.locator('aside[aria-label="对话列表"]')
+    const box = aside.getByRole('searchbox', { name: '按标题或问过的话找对话' })
+    check('8 个对话时有筛选框', await box.waitFor({ timeout: 6000 }).then(() => true, () => false))
+    await box.fill('会话 B')
+    const row = aside.locator('div.group', { hasText: '会话 B' })
+    await row.hover()
+    await row.getByRole('button', { name: /删除/ }).click()
+    // 老版本删除前还要确认一次
+    if (await page.getByRole('dialog').waitFor({ timeout: 800 }).then(() => true, () => false)) {
+      await page.getByRole('dialog').getByRole('button', { name: '删除' }).click()
+    }
+    await until(() => db.archived.has('c0idleb'))
+    await page.waitForTimeout(300)
+    check('删到 7 个：筛选词还在，筛选框也还在', await box.isVisible().catch(() => false)
+      && (await box.inputValue().catch(() => '')) === '会话 B')
+    await page.screenshot({ path: `${SHOTS}/filter-shrunk-${theme}.png` })
+    // 老版本框已经没了，清不掉：不在这里卡 30 秒，下面几条照样判红
+    await box.fill('', { timeout: 2000 }).catch(() => {})
+    await page.waitForTimeout(200)
+    check('清掉筛选词：剩下 7 个都回来了', (await aside.locator('div.group').count()) === 7,
+      String(await aside.locator('div.group').count()))
+    check('没有筛选词、不够 8 个时，筛选框收起', !(await box.isVisible().catch(() => false)))
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    ctl.few = false
+    resetDb()
+    await ctx.close()
+  }
+
+  if (section('delete', '删除：先进回收站，可以撤销')) {
+    resetDb()
     const { page, ctx, errors } = await open(theme)
     await goto(page, 'c0idleb')
     await shows(page, 'B 的答案')
+    const aside = page.locator('aside')
+    const trashBtn = aside.getByRole('button', { name: /^打开回收站/ })
+    check('回收站入口写着里面有几个', /2/.test(await trashBtn.innerText().catch(() => '')),
+      await trashBtn.innerText().catch(() => '没有入口'))
     const row = page.locator('aside[aria-label="对话列表"] div.group', { hasText: '会话 B' })
     await row.hover()
     await row.getByRole('button', { name: /删除/ }).click()
-    check('删除前先确认', await page.getByRole('dialog').waitFor({ timeout: 3000 }).then(() => true, () => false))
-    await page.getByRole('dialog').getByRole('button', { name: '删除' }).click()
+    // 回收站能找回来：删除不再先弹一次确认，撤销和回收站就是后悔药
+    const asked = await page.getByRole('dialog').waitFor({ timeout: 800 }).then(() => true, () => false)
+    check('删除不再先弹确认', !asked)
+    if (asked) await page.getByRole('dialog').getByRole('button', { name: '删除' }).click()
     await until(() => log.archived.some(([id, b]) => id === 'c0idleb' && b.archived === true))
-    check('删除是归档，不是真删', log.archived.some(([id, b]) => id === 'c0idleb' && b.archived === true))
-    check('给了撤销', await page.getByRole('button', { name: '撤销' }).first()
-      .waitFor({ timeout: 4000 }).then(() => true, () => false))
-    await page.getByRole('button', { name: '撤销' }).first().click()
+    check('删除是归档，不是真删', log.archived.some(([id, b]) => id === 'c0idleb' && b.archived === true)
+      && !log.deleted.includes('c0idleb'))
+    const undo = page.getByRole('button', { name: '撤销' }).first()
+    check('给了撤销', await undo.waitFor({ timeout: 4000 }).then(() => true, () => false))
+    check('提示里说去了回收站', await page.getByText(/已移到回收站/).count() > 0)
+    check('回收站的数跟着变成 3', /3/.test(await trashBtn.innerText().catch(() => '')), await trashBtn.innerText().catch(() => ''))
+    await undo.click().catch(() => {})
     await until(() => log.archived.some(([id, b]) => id === 'c0idleb' && b.archived === false))
     await page.waitForTimeout(200)
     check('撤销放回去了', log.archived.some(([id, b]) => id === 'c0idleb' && b.archived === false)
@@ -827,6 +1069,479 @@ for (const theme of THEMES) {
     check('没有运行时报错', errors.length === 0, errors[0] ?? '')
     await ctx.close()
   }
+
+  if (section('trash', '回收站：预览、恢复、彻底删除（要确认）')) {
+    resetDb()
+    const deletedBefore = log.deleted.length
+    const { page, ctx, errors } = await open(theme)
+    await goto(page, 'c0idleb')
+    await shows(page, 'B 的答案')
+    await page.locator('aside').getByRole('button', { name: /^打开回收站/ }).click()
+    const bin = page.locator('aside[aria-label="回收站"]')
+    check('打开回收站', await bin.waitFor({ timeout: 3000 }).then(() => true, () => false))
+    const rows = bin.locator('div.group')
+    check('列出回收站里的对话', (await rows.count()) === 2, (await rows.allInnerTexts()).map((t) => t.split('\n')[0]).join(' | '))
+    check('顶行和页头一样高（48px）', await bin.evaluate((el) => Math.round(el.firstElementChild.getBoundingClientRect().height)) === 48)
+    await page.screenshot({ path: `${SHOTS}/trash-${theme}.png` })
+
+    // 点开看一眼：内容照常显示，但不能接着问
+    await rows.filter({ hasText: '删掉的对话甲' }).locator('button').first().click()
+    await page.waitForURL(/\/chat\/c0trash1$/, { timeout: 5000 }).catch(() => {})
+    check('能打开回收站里的对话看内容', await shows(page, '回收站里的答案'))
+    check('说清它在回收站里', await shows(page, '这个对话在回收站里'))
+    await page.getByRole('textbox', { name: '向数据提问' }).fill('回收站里还能问吗')
+    check('在回收站里不能接着问', await page.getByRole('button', { name: '发送' }).isDisabled())
+    await page.waitForTimeout(800)   // 轮次有入场动画，等它落定再截
+    await page.screenshot({ path: `${SHOTS}/trash-preview-${theme}.png` })
+    await page.locator('[data-trash-banner]').getByRole('button', { name: '恢复' }).click()
+    await until(() => log.archived.some(([id, b]) => id === 'c0trash1' && b.archived === false))
+    await page.waitForTimeout(300)
+    check('恢复：放回列表，提示条收起，可以接着问', !(await page.locator('[data-trash-banner]').count())
+      && !(await page.getByRole('button', { name: '发送' }).isDisabled()))
+    check('恢复之后回到对话列表，它在里面', await page.locator('aside[aria-label="对话列表"]')
+      .getByText('删掉的对话甲').count() > 0)
+
+    // 彻底删除：要确认，确认后才发 DELETE
+    await page.locator('aside').getByRole('button', { name: /^打开回收站/ }).click()
+    const left = bin.locator('div.group', { hasText: '删掉的对话乙' })
+    await left.hover()
+    await left.getByRole('button', { name: /彻底删除/ }).click()
+    const dialog = page.getByRole('dialog')
+    check('彻底删除前先确认', await dialog.waitFor({ timeout: 3000 }).then(() => true, () => false))
+    check('确认框说清找不回来', (await dialog.innerText().catch(() => '')).includes('找不回来'))
+    await page.waitForTimeout(300)
+    await page.screenshot({ path: `${SHOTS}/trash-purge-${theme}.png` })
+    await dialog.getByRole('button', { name: '彻底删除' }).click()
+    await until(() => log.deleted.length > deletedBefore)
+    check('确认后才真删', log.deleted.slice(deletedBefore).join() === 'c0trash2', log.deleted.slice(deletedBefore).join())
+    check('回收站空了就说一声', await shows(page, '回收站是空的'))
+    await bin.getByRole('button', { name: /返回/ }).click()
+    check('返回对话列表', await page.locator('aside[aria-label="对话列表"]').waitFor({ timeout: 3000 }).then(() => true, () => false))
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    resetDb()
+    await ctx.close()
+  }
+
+  if (section('readonly', '回收站里只能看：不发起运行，正在跑的不给彻底删除')) {
+    resetDb()
+    ctl.trashMore = true
+    ctl.approvals = [{ id: 'ap-bin', run_id: 'run-trash-wait', node_id: 'ag', mode: 'approve', title: '确认一下再查',
+      payload: {}, status: 'pending', response: {}, created_at: new Date().toISOString() }]
+    const { page, ctx, errors } = await open(theme)
+    const counts = () => ({ starts: log.runStarts.length, continues: log.continues.length, gens: log.gens.length, posts: log.posts.length })
+    const before = counts()
+    await goto(page, 'c0trash3')
+    await page.locator('[data-trash-banner]').waitFor({ timeout: 6000 }).catch(() => {})
+    // 停在审批上的那一轮要核对完、成了「等待审批」，四种补救才都摆出来
+    await page.waitForFunction(() => window.__chat.getState().byConversation.c0trash3?.find((t) => t.id === 'ty1')?.phase === 'waiting',
+      null, { timeout: 6000 }).catch(() => {})
+    await page.waitForTimeout(400)
+    const STARTERS = /接着跑|重试这一轮|重跑这一轮|重新问一次|不限数据源重试|放宽步数|跑一下/
+    // 补救动作排在轮次卡片外面（AssistantStream 的动作槽），整页找
+    const starters = page.locator('button', { hasText: STARTERS })
+    const labels = await starters.evaluateAll((bs) => bs.map((b) => `${b.textContent.trim()}${b.disabled ? '' : '（可点）'}`))
+    const has = (re) => labels.some((l) => re.test(l))
+    check('会发起运行的按钮照样摆着（恢复之后能做什么看得到）',
+      has(/跑一下/) && has(/接着跑/) && has(/重新问一次|重试这一轮/) && has(/放宽步数/), labels.join(' | '))
+    check('……但一个都点不了', labels.length > 0 && labels.every((l) => !l.endsWith('（可点）')), labels.join(' | '))
+    const why = await starters.evaluateAll((bs) => [...new Set(bs.map((b) => b.title))])
+    check('按钮上说清为什么点不了', why.length === 1 && /回收站/.test(why[0]), why.join(' | '))
+    check('换个说法照常能用（它不发起运行）',
+      await page.locator('[data-remedy]').getByRole('button', { name: '换个说法' }).first().isEnabled().catch(() => false))
+    check('看执行过程照常能用', await page.getByRole('button', { name: '看执行过程' }).first().isEnabled().catch(() => false))
+    check('停在审批上的：不摆能点「通过」的审批卡，说清恢复之后再处理',
+      !(await page.getByRole('button', { name: '通过' }).count())
+        && (await page.locator('[data-pending-approval]').innerText().catch(() => '')).includes('恢复这个对话之后'))
+    // 按钮之外再绕一道：绕过禁用直接点、直接调 store，也一次运行都发不出去
+    await starters.evaluateAll((bs) => bs.forEach((b) => b.click()))
+    await page.evaluate(() => {
+      const s = window.__chat.getState()
+      s.retryTurn('c0trash3', 'ty3')
+      s.retryTurn('c0trash3', 'ty2', { rerun: true })
+      s.runNow('c0trash3', 'ty0')
+      void s.continueTurn('c0trash3', 'ty2')
+      s.ask('c0trash3', '回收站里偷偷问一句')
+    })
+    await page.waitForTimeout(900)
+    const after = counts()
+    check('一次运行都没发起：不建图、不开轮、不 POST /runs、不接着跑',
+      JSON.stringify(after) === JSON.stringify(before), `${JSON.stringify(before)} → ${JSON.stringify(after)}`)
+    await page.locator('[data-turn="ty2"]').scrollIntoViewIfNeeded().catch(() => {})
+    await page.waitForTimeout(300)
+    await page.screenshot({ path: `${SHOTS}/trash-readonly-${theme}.png` })
+
+    // 删掉之后又跑起来的：和列表里一样不给彻底删除
+    await page.locator('aside').getByRole('button', { name: /^打开回收站/ }).click()
+    const bin = page.locator('aside[aria-label="回收站"]')
+    const liveRow = bin.locator('div.group', { hasText: '删掉的对话丁' })
+    await liveRow.waitFor({ timeout: 3000 }).catch(() => {})
+    check('回收站里标出它在运行', (await liveRow.innerText().catch(() => '')).includes('运行中'),
+      (await liveRow.innerText().catch(() => '')).replace(/\n/g, ' / '))
+    await liveRow.hover()
+    const rowPurge = liveRow.getByRole('button', { name: /彻底删除/ })
+    check('正在跑的：行上的彻底删除点不了，说清为什么', await rowPurge.isDisabled().catch(() => false)
+      && (await rowPurge.getAttribute('title')) === '这个对话正在运行，先停下来再删', await rowPurge.getAttribute('title').catch(() => ''))
+    await liveRow.locator('button').first().click()
+    const live = await page.waitForFunction(() => window.__chat.getState().byConversation.c0trash4?.[0]?.phase === 'running',
+      null, { timeout: 6000 }).then(() => true, () => false)
+    check('打开它：核对发现运行还活着，接了回去', live, (await chatState(page)).byConversation.c0trash4?.[0]?.phase)
+    const bannerPurge = page.locator('[data-trash-banner]').getByRole('button', { name: '彻底删除' })
+    check('提示条上的彻底删除也点不了', await bannerPurge.isDisabled().catch(() => false))
+    const stop = page.getByRole('button', { name: '停止这一轮' })
+    check('在回收站里也停得下来', await stop.count() === 1)
+    await page.waitForTimeout(300)
+    await page.screenshot({ path: `${SHOTS}/trash-running-${theme}.png` })
+
+    // 清空：只删没在跑的；在跑的留下，确认框里先说
+    const deletedBefore = log.deleted.length
+    await bin.getByRole('button', { name: '清空回收站' }).click()
+    const dialog = page.getByRole('dialog')
+    await dialog.waitFor({ timeout: 3000 }).catch(() => {})
+    const said = await dialog.innerText().catch(() => '')
+    check('清空前说清在跑的这次不删', said.includes('删掉的对话丁') && said.includes('正在运行'), said.replace(/\n/g, ' / '))
+    await dialog.getByRole('button', { name: '全部删除' }).click().catch(() => {})
+    await until(() => log.deleted.length - deletedBefore >= 3, 4000)
+    await page.waitForTimeout(300)
+    const gone = log.deleted.slice(deletedBefore)
+    check('清空：没在跑的都删了，在跑的没删', ['c0trash1', 'c0trash2', 'c0trash3'].every((id) => gone.includes(id))
+      && !gone.includes('c0trash4'), gone.join(','))
+    check('在跑的那条事件流没被关掉、运行没被丢下', ctl.wsClosed['run-trash-live'] === false
+      && (await chatState(page)).byConversation.c0trash4?.[0]?.phase === 'running')
+    check('它还在回收站里', await bin.locator('div.group', { hasText: '删掉的对话丁' }).count() === 1)
+
+    // 停下来之后就能删了
+    await stop.click().catch(() => {})
+    await until(() => log.cancels.includes('run-trash-live'), 3000)
+    await page.waitForTimeout(200)
+    check('停下之后：彻底删除可以点了', await bannerPurge.isEnabled().catch(() => false))
+    await bannerPurge.click().catch(() => {})
+    await dialog.waitFor({ timeout: 3000 }).catch(() => {})
+    await dialog.getByRole('button', { name: '彻底删除' }).click().catch(() => {})
+    await until(() => log.deleted.slice(deletedBefore).includes('c0trash4'), 3000)
+    check('确认之后删掉了', log.deleted.slice(deletedBefore).includes('c0trash4'))
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    ctl.trashMore = false
+    ctl.approvals = []
+    resetDb()
+    await ctx.close()
+  }
+
+  if (section('recheck', '恢复的半路轮次：核对撞上 500 有出路、补交付不计实时、终态落库')) {
+    const { page, ctx, errors } = await open(theme)
+    ctl.run500 = true
+    await goto(page, 'c0unkp')
+    // 先等这一轮取回来：取回来之前「不在核对」是空洞地成立的
+    const settled = await page.waitForFunction(() => {
+      const t = window.__chat.getState().byConversation.c0unkp?.[0]
+      return !!t && t.hydrated !== 'pending' && t.phase !== 'checking'
+    }, null, { timeout: 5000 }).then(() => true, () => false)
+    check('核对撞上 500：不再一直停在「正在核对」', settled, (await chatState(page)).byConversation.c0unkp?.[0]?.phase)
+    check('说清没核对上', await shows(page, '没核对上这一轮现在的状态'))
+    const recheck = page.locator('[data-remedy]').getByRole('button', { name: '重新核对' })
+    check('给「重新核对」', await recheck.count() === 1)
+    check('不给会另起运行的按钮', !(await page.getByRole('button', { name: /重试这一轮|重跑这一轮|接着跑/ }).count()))
+    check('这时不转圈', !(await page.locator('[data-turn="tp1"] .animate-spin').count()))
+    await page.screenshot({ path: `${SHOTS}/recheck-failed-${theme}.png` })
+    ctl.run500 = false
+    await recheck.click().catch(() => {})
+    check('重新核对：按运行的真实状态收尾', await page.waitForFunction(
+      () => window.__chat.getState().byConversation.c0unkp?.[0]?.phase === 'cancelled', null, { timeout: 5000 })
+      .then(() => true, () => false), (await chatState(page)).byConversation.c0unkp?.[0]?.phase)
+    ctl.run500 = true
+
+    // 三天前跑完、交付没赶上：补交付（等复核）期间不按实时运行计时
+    ctl.reviewDelay['run-late'] = 1800
+    await goto(page, 'c0lateq')
+    await page.waitForFunction(() => window.__chat.getState().byConversation.c0lateq?.[0]?.hydrated === 'done', null, { timeout: 5000 }).catch(() => {})
+    await page.waitForTimeout(300)
+    const mid = (await chatState(page)).byConversation.c0lateq?.[0]
+    check('补交付期间不算「运行中」', mid?.phase !== 'running' && mid?.phase !== 'done', mid?.phase)
+    const clock = await page.locator('[data-turn="tq1"] [title="已运行"]').allInnerTexts()
+    check('补交付期间头部不走实时计时（不会从三天前算起）', clock.length === 0, clock.join(','))
+    await page.screenshot({ path: `${SHOTS}/late-delivery-${theme}.png` })
+    check('补交付完成', await shows(page, '补交付的答案：三条记录。', 5000))
+    delete ctl.reviewDelay['run-late']
+
+    // 停在半路的几轮：各自的终态查到之后要落库，下次进来不再核对
+    ctl.approvals = [{ id: 'ap-t', run_id: 'run-t-wait', node_id: 'ag', mode: 'approve', title: '确认一下',
+      payload: {}, status: 'pending', response: {}, created_at: new Date().toISOString() }]
+    const patchesBefore = log.patches.length
+    await goto(page, 'c0termr')
+    await until(() => ['tr1', 'tr2', 'tr3', 'tr4'].every((id) =>
+      log.patches.slice(patchesBefore).some((p) => p.turn === id && p.body.status === 'error')), 6000)
+    await page.waitForTimeout(300)
+    const saved = (id) => log.patches.slice(patchesBefore).filter((p) => p.turn === id).at(-1)?.body
+    check('在别处取消的：落库成已取消', saved('tr1')?.status === 'error' && saved('tr1')?.error === '已取消'
+      && saved('tr1')?.meta?.outcome === 'cancelled', JSON.stringify(saved('tr1')))
+    check('在别处失败的：落库成失败，原因跟着写', saved('tr2')?.status === 'error' && /鉴权/.test(saved('tr2')?.error ?? ''),
+      JSON.stringify(saved('tr2'))?.slice(0, 160))
+    check('服务重启挂起的：落库成中断', saved('tr3')?.status === 'error' && saved('tr3')?.meta?.outcome === 'suspended',
+      JSON.stringify(saved('tr3'))?.slice(0, 160))
+    check('运行被删掉的：落库成「上次没有跑完」', saved('tr4')?.status === 'error' && saved('tr4')?.error === '上次没有跑完',
+      JSON.stringify(saved('tr4'))?.slice(0, 160))
+    check('还在等审批的不落库（它还没结束）', !saved('tr5'), JSON.stringify(saved('tr5')))
+    ctl.approvals = []
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
+
+  if (section('clipped', '长答案没取全：记进 meta、刷新后补全，2000 字按码点数')) {
+    const { page, ctx, errors } = await open(theme)
+    const patchesBefore = log.patches.length
+    await goto(page, 'c0clips')
+    await send(page, '一份取不到运行的长答案')
+    await page.waitForFunction(() => window.__chat.getState().byConversation.c0clips?.at(-1)?.phase === 'done', null, { timeout: 10000 }).catch(() => {})
+    const t = (await chatState(page)).byConversation.c0clips.at(-1)
+    check('GET 运行失败：先交截断的那份并标出来', t.clipped === 'partial', t.clipped)
+    await until(() => log.patches.slice(patchesBefore).some((p) => p.body.meta?.clipped === 'partial'))
+    check('「没取全」写进 meta，刷新后还认得出来', log.patches.slice(patchesBefore).some((p) => p.body.meta?.clipped === 'partial'),
+      JSON.stringify(log.patches.slice(patchesBefore).map((p) => p.body.meta?.clipped)))
+
+    const runGetsBefore = log.runGets.length
+    await goto(page, 'c0clipt')
+    await shows(page, '多个成果键的长答案')
+    await until(() => log.runGets.slice(runGetsBefore).includes('run-multi'), 4000)
+    check('meta 说没取全：一进来就去补，不等滚进视口', log.runGets.slice(runGetsBefore).includes('run-multi'),
+      log.runGets.slice(runGetsBefore).join(','))
+    await page.waitForFunction(() => String(window.__chat.getState().byConversation.c0clipt?.[0]?.output?.answer ?? '').includes('【完整结尾】'),
+      null, { timeout: 4000 }).catch(() => {})
+    const tt1 = (await chatState(page)).byConversation.c0clipt[0]
+    check('多个成果键的长答案补全了', String(tt1.output?.answer ?? '').includes('【完整结尾】') && !tt1.clipped,
+      `${String(tt1.output?.answer ?? '').length} 字 · ${tt1.clipped}`)
+    await page.waitForTimeout(300)
+    const lost = await page.locator('[data-remedy]', { hasText: '截在了 2000 字' }).count()
+    check('恰好 2000 个码点（UTF-16 不是 2000）也认得出被截断、补不回来', lost === 2, `${lost} 处`)
+    await page.locator('[data-turn="tt2"]').scrollIntoViewIfNeeded().catch(() => {})
+    await page.screenshot({ path: `${SHOTS}/clipped-${theme}.png` })
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
+
+  if (section('launch', '发起运行失败：报错分得清标题和原因，补救说真话')) {
+    const { page, ctx, errors } = await open(theme)
+    ctl.launchFail = true
+    await goto(page, 'c0launu')
+    await send(page, '一个启动失败的问题')
+    const alert = page.locator('[data-turn] [role="alert"]').first()
+    await alert.waitFor({ timeout: 8000 }).catch(() => {})
+    const title = await alert.locator('.font-medium').first().innerText().catch(() => '')
+    check('标题只是「连不上后端服务」，原因不糊进粗体', title === '连不上后端服务', title)
+    const text = await alert.innerText().catch(() => '')
+    check('不许诺页面上不存在的自动重试', !text.includes('自动重试'), text.replace(/\n/g, ' / '))
+    const rerun = page.locator('[data-remedy="failed"]').getByRole('button', { name: '重跑这一轮' })
+    check('流程已经搭好：给「重跑这一轮」，不让它重新搭', await rerun.count() === 1)
+    check('说出怎么办：连上之后点「重跑这一轮」', text.includes('重跑这一轮'), text.replace(/\n/g, ' / '))
+    await page.screenshot({ path: `${SHOTS}/launch-failed-${theme}.png` })
+    ctl.launchFail = false
+    const gensBefore = log.gens.length
+    const startsBefore = log.runStarts.length
+    await rerun.click().catch(() => {})
+    await until(() => log.runStarts.length > startsBefore, 5000)
+    check('重跑：原图直接发起，不再去问 Copilot', log.runStarts.length > startsBefore && log.gens.length === gensBefore,
+      `${log.runStarts.length - startsBefore} 次发起 · ${log.gens.length - gensBefore} 次建图`)
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    ctl.launchFail = true
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
+
+  if (section('rerun', '重跑服务重启挂起的那一轮：旧运行顺手取消')) {
+    const { page, ctx, errors } = await open(theme)
+    await goto(page, 'c0suspo')
+    await shows(page, '服务重启，这一轮中断了')
+    const before = log.cancels.length
+    const startsBefore = log.runStarts.length
+    await page.locator('[data-remedy="suspended"]').getByRole('button', { name: '重跑这一轮' }).click()
+    await until(() => log.runStarts.length > startsBefore, 5000)
+    await until(() => log.cancels.slice(before).includes('run-susp'), 2000)
+    check('挂起的旧运行被取消，不会一直挂在记录里', log.cancels.slice(before).includes('run-susp'), log.cancels.slice(before).join(','))
+    check('新的一次照常发起', log.runStarts.length > startsBefore)
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
+
+  if (section('stale', '断在建图阶段：按最后一次落库算有没有动静；发起运行时 meta 跟上新运行')) {
+    const { page, ctx, errors } = await open(theme)
+    const patchesBefore = log.patches.length
+    await goto(page, 'c0buildx')
+    await shows(page, '重试之后二十分钟没动静的问题')
+    await until(() => log.patches.slice(patchesBefore).some((p) => p.turn === 'tx8'), 3000)
+    await page.waitForTimeout(400)
+    const mine = () => log.patches.slice(patchesBefore)
+    check('两天前问的、两分钟前刚重试过：不当成断了写回 error',
+      !mine().some((p) => p.turn === 'tx7' && p.body.status === 'error'), JSON.stringify(mine().filter((p) => p.turn === 'tx7')))
+    check('重试之后二十分钟没动静的：认定断了，写回 error',
+      mine().some((p) => p.turn === 'tx8' && p.body.status === 'error'), JSON.stringify(mine().filter((p) => p.turn === 'tx8')).slice(0, 200))
+
+    // 重试一次：搭好图时连 meta 一起写（有动静的凭据），发起运行时 meta.runId 换成新运行
+    const startsBefore = log.runStarts.length
+    const retryAt = log.patches.length
+    await page.locator('[data-remedy="failed"]').getByRole('button', { name: '重试这一轮' }).click()
+    await until(() => log.runStarts.length > startsBefore, 6000)
+    const newRun = log.runStarts.at(-1)?.id
+    await until(() => log.patches.slice(retryAt).some((p) => p.turn === 'tx8' && p.body.run_id === newRun), 3000)
+    const ps = log.patches.slice(retryAt).filter((p) => p.turn === 'tx8').map((p) => p.body)
+    const graphSave = ps.find((b) => b.graph)
+    check('搭好图时连 meta 一起写，带上此刻', !!graphSave?.meta && Math.abs(Date.now() - (graphSave.meta.at ?? 0)) < 30_000,
+      JSON.stringify(graphSave?.meta ?? null)?.slice(0, 120))
+    const started = ps.find((b) => b.run_id === newRun)
+    check('发起运行：run_id 列和 meta.runId 一起换成新运行，状态是 running',
+      !!newRun && started?.meta?.runId === newRun && started?.status === 'running', JSON.stringify(started ?? null)?.slice(0, 160))
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
+
+  if (section('scope', '限定数据源：点一下只查这个库')) {
+    const { page, ctx, errors } = await open(theme)
+    await goto(page, 'c0emptg')
+    await shows(page, '问你的数据')
+    const chip = page.locator('[data-scope-chip="ds-plant"]')
+    check('首屏的数据源标签可以点', await chip.waitFor({ timeout: 5000 }).then(() => true, () => false))
+    check('默认不限', (await chip.getAttribute('aria-pressed')) === 'false')
+    await chip.click()
+    check('点一下就限定成它', (await chip.getAttribute('aria-pressed')) === 'true')
+    await page.waitForTimeout(300)   // 颜色有过渡，等它换完再截
+    await page.screenshot({ path: `${SHOTS}/scope-hero-${theme}.png` })
+    const gensBefore = log.gens.length
+    await send(page, '只查这个库的问题')
+    await until(() => log.gens.length > gensBefore, 5000)
+    check('请求里带上 datasource_ids', JSON.stringify(log.gens.at(-1)?.datasource_ids) === '["ds-plant"]',
+      JSON.stringify(log.gens.at(-1)?.datasource_ids))
+    check('这一轮上写着只查了哪个库', await shows(page, '只查 factory'))
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    await page.waitForTimeout(200)
+
+    // 在对话里：输入框左边的范围选择
+    await goto(page, 'c0scopv')
+    await shows(page, '上一问的答案')
+    const picker = page.getByRole('button', { name: /数据源范围/ })
+    check('输入框旁有数据源范围', await picker.count() === 1)
+    check('默认写「全部数据源」', (await picker.innerText().catch(() => '')).includes('全部数据源'), await picker.innerText().catch(() => ''))
+    await picker.click()
+    await page.getByRole('checkbox', { name: 'shop' }).check()
+    check('选了之后按钮写「只查 shop」', (await picker.innerText().catch(() => '')).includes('只查 shop'), await picker.innerText().catch(() => ''))
+    await page.screenshot({ path: `${SHOTS}/scope-picker-${theme}.png` })
+    await page.keyboard.press('Escape')
+    const before2 = log.gens.length
+    await send(page, '在对话里限定的问题')
+    await until(() => log.gens.length > before2, 5000)
+    check('对话里限定的也带上', JSON.stringify(log.gens.at(-1)?.datasource_ids) === '["ds-mig"]',
+      JSON.stringify(log.gens.at(-1)?.datasource_ids))
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    await page.waitForTimeout(200)
+
+    // 限定的库被删了、停用了：后端 400，把原因原样说出来
+    ctl.scope400 = true
+    await send(page, '限定的库已经不在了')
+    check('库不在了：说清原因', await shows(page, '限定的数据源都不在了'))
+    await page.screenshot({ path: `${SHOTS}/scope-400-${theme}.png` })
+    // 带着原范围的「重试这一轮」只会再撞一次 400：补救得是放开范围
+    const loose = page.locator('[data-remedy="failed"]').getByRole('button', { name: '不限数据源重试' })
+    check('库不在了：补救是「不限数据源重试」', await loose.count() === 1)
+    const before3 = log.gens.length
+    await loose.click().catch(() => {})
+    await until(() => log.gens.length > before3, 5000)
+    check('不限数据源重试：请求里不再带 datasource_ids', log.gens.length > before3 && !log.gens.at(-1)?.datasource_ids?.length,
+      JSON.stringify(log.gens.at(-1)?.datasource_ids))
+    check('输入框旁的范围也一起放开', (await picker.innerText().catch(() => '')).includes('全部数据源'),
+      await picker.innerText().catch(() => ''))
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    ctl.scope400 = false
+
+    // 库列表没取回来：从上一问接过来的范围照样会发出去，所以照样得摆在眼前
+    ctl.sourcesFail = true
+    await goto(page, 'c0scopw')
+    await shows(page, '上一问的答案 W')
+    const picker2 = page.getByRole('button', { name: /数据源范围/ })
+    await picker2.waitFor({ timeout: 3000 }).catch(() => {})
+    check('库列表没取回来：范围照样摆在输入框旁', (await picker2.innerText().catch(() => '')).includes('只查 factory'),
+      await picker2.innerText().catch(() => '没有范围按钮'))
+    await picker2.click().catch(() => {})
+    const stray = page.locator('[data-scope-stray]')
+    check('范围里的库照样列出来，注明没取到状态', (await stray.innerText().catch(() => '')).includes('没取到状态')
+      && await stray.getByRole('checkbox').isChecked().catch(() => false), await stray.innerText().catch(() => ''))
+    await page.waitForTimeout(250)
+    await page.screenshot({ path: `${SHOTS}/scope-unconfirmed-${theme}.png` })
+    await stray.getByRole('checkbox').uncheck().catch(() => {})
+    check('取消勾选之后它还留在原处，按钮写回「全部数据源」', await stray.count() === 1
+      && (await picker2.innerText().catch(() => '')).includes('全部数据源'), await picker2.innerText().catch(() => ''))
+    await stray.getByRole('checkbox').check().catch(() => {})
+    await page.keyboard.press('Escape')
+    const before4 = log.gens.length
+    await send(page, '库列表没取回来时的问题')
+    await until(() => log.gens.length > before4, 5000)
+    check('发出去的范围和看得见的一致', JSON.stringify(log.gens.at(-1)?.datasource_ids) === '["ds-plant"]',
+      JSON.stringify(log.gens.at(-1)?.datasource_ids))
+    await page.getByRole('button', { name: '停止这一轮' }).click().catch(() => {})
+    ctl.sourcesFail = false
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
+
+  if (section('composer', '画布助手：「在现有图上改 | 从头生成」分段控件')) {
+    const { page, ctx, errors } = await open(theme)
+    const WF = {
+      id: 'wf-chat-check', name: '__chat_check_composer__', description: '检查脚本伪造的工作流', graph: GRAPH,
+      tags: [], version: 1, is_template: false, status: 'draft', published_version: null, published_by: null,
+      run_count: 0, created_at: iso(60), updated_at: iso(60),
+    }
+    await page.route(/\/api\/workflows(\?.*)?$/, (route) => (route.request().method() === 'GET'
+      ? route.fulfill({ json: [WF] }) : route.fallback()))
+    await page.route(/\/api\/workflows\/wf-chat-check(\/.*)?(\?.*)?$/, (route) => {
+      const url = new URL(route.request().url())
+      if (route.request().method() !== 'GET') return route.abort()
+      if (url.pathname.endsWith('/versions')) return route.fulfill({ json: [] })
+      return route.fulfill({ json: WF })
+    })
+    await page.goto(`${WEB}/studio/wf-chat-check`)
+    await page.waitForFunction(() => window.__studio?.getState().workflow?.id === 'wf-chat-check', null, { timeout: 15000 })
+      .catch(() => {})
+    const group = page.getByRole('radiogroup', { name: '生成方式' })
+    check('有「生成方式」分段控件', await group.waitFor({ timeout: 6000 }).then(() => true, () => false))
+    const base = group.getByRole('radio', { name: '在现有图上改' })
+    const fresh = group.getByRole('radio', { name: '从头生成' })
+    check('默认「在现有图上改」', (await base.getAttribute('aria-checked')) === 'true'
+      && (await fresh.getAttribute('aria-checked')) === 'false')
+    const size = await fresh.evaluate((el) => parseFloat(getComputedStyle(el).fontSize)).catch(() => 0)
+    check('字不小于 11px', size >= 11, `${size}px`)
+    await base.focus()
+    await page.keyboard.press('ArrowRight')
+    check('方向键切到「从头生成」', (await fresh.getAttribute('aria-checked')) === 'true'
+      && await fresh.evaluate((el) => el === document.activeElement))
+    await page.waitForTimeout(300)   // 底色有过渡，等它换完再截
+    await page.screenshot({ path: `${SHOTS}/composer-fresh-${theme}.png` })
+    const gensBefore = log.gens.length
+    const box = page.getByRole('textbox', { name: '告诉助手要画什么流程' })
+    await box.fill('重新画一张三步的图')
+    await box.press('Enter')
+    await until(() => log.gens.length > gensBefore, 5000)
+    check('从头生成：不带现有的图', log.gens.at(-1)?.base_graph === null, JSON.stringify(log.gens.at(-1)?.base_graph)?.slice(0, 60))
+    await page.waitForFunction(() => !window.__studio.getState().copilot.active, null, { timeout: 8000 }).catch(() => {})
+    await base.click()
+    await box.fill('在最后加一步人工审批')
+    await box.press('Enter')
+    await until(() => log.gens.length > gensBefore + 1, 5000)
+    check('在现有图上改：带上现有的图', !!log.gens.at(-1)?.base_graph?.nodes?.length)
+
+    // 助手出错：出错的那一轮自己有报错块（怎么办、原文都在），输入框上面不再重复一条
+    await page.waitForFunction(() => !window.__studio.getState().copilot.active, null, { timeout: 8000 }).catch(() => {})
+    await box.fill('这一句会让建流程就失败')
+    await box.press('Enter')
+    const card = page.locator('[data-turn-error]', { hasText: '模型交回的工作流结构不对' })
+    const shown = await card.first().waitFor({ timeout: 6000 }).then(() => true, () => false)
+    const said = await card.first().innerText().catch(() => '')
+    check('助手出错：那一轮写出发生了什么和怎么办', shown && said.includes('再试一次，或者把需求说得更具体些'),
+      said.replace(/\n/g, ' / '))
+    check('同一句报错只说一遍（输入框上面不再摆一条）', await card.count() === 1
+      && await page.locator('[data-copilot-error]').count() === 0,
+      `${await card.count()} 块 · 错误条 ${await page.locator('[data-copilot-error]').count()} 条`)
+    await page.waitForTimeout(300)
+    await page.screenshot({ path: `${SHOTS}/composer-error-${theme}.png` })
+    check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+    await ctx.close()
+  }
 }
 
 await browser.close()
diff --git a/scripts/check-decode.mjs b/scripts/check-decode.mjs
index 9e6f750c..4e95265a 100644
--- a/scripts/check-decode.mjs
+++ b/scripts/check-decode.mjs
@@ -592,6 +592,14 @@ console.log('\n=== 长运行：按轮折叠（runs-5）===')
   check('相邻重复行并成一行', rows.length === 2, rows.map((r) => r.title).join(' | '))
   check('并后的行写出次数、中位和最慢', rows[0].meta === '×3 · 中位 12 ms · 最慢 63 ms', rows[0].meta)
   check('警告并完还是警告', rows[1].level === 'warn' && rows[1].repeat?.count === 2)
+  // 出了状况的行，副标题说的是为什么：两次修复凑出来的值不一样，并成一行就只剩第一次的
+  const why = mod.compactSteps([
+    { id: 'r1', seq: 1, kind: 'llm', title: '让模型修复格式', level: 'warn', status: 'done', sub: '出现了原文没有的值（total_count=0）' },
+    { id: 'r2', seq: 2, kind: 'llm', title: '让模型修复格式', level: 'warn', status: 'done', sub: '出现了原文没有的值（region=华东）' },
+    { id: 'r3', seq: 3, kind: 'llm', title: '让模型修复格式', level: 'warn', status: 'done', sub: '出现了原文没有的值（region=华东）' },
+  ])
+  check('原因不同的警告不并成一行，原因相同的照并', why.length === 2 && why[1].repeat?.count === 2,
+    why.map((r) => `${r.sub} ${r.meta ?? ''}`).join(' | '))
 
   // 恢复后的重放（resumed）不算新的一轮；循环体真的又跑一次才算
   const replay = mod.decodeRun([
@@ -654,6 +662,180 @@ console.log('\n=== Copilot：心跳穿插、回话、少了一步、报错 ===')
   check('结局里的报错分开带着 hint 和 detail', eo.kind === 'error' && eo.error?.hint === 'h' && eo.error?.raw === 'd')
 }
 
+console.log('\n=== 协作团队用完轮数：最后那次判定不是新的一轮（REQ-3A-3、NI-5）===')
+{
+  const team = (evts) => mod.decodeRun(evts).find((s) => s.nodeId === 'team')
+  const routes = (evts) => flatten(mod.decodeRun(evts)).filter((s) => s.kind === 'branch' && s.nodeId === 'team')
+
+  // 以前 closing 判定被写成「第 3 轮：调度者在想下一步…」→「第 3 轮：结束协作」，done=false 时
+  // 读起来像团队正常收尾了；泳道还多出一列空的第 3 轮
+  const failRoutes = routes(synthetic.exhaustedTeam('fail'))
+  const closing = failRoutes[failRoutes.length - 1]
+  check('判定没完成：说「轮数用完 · 调度者判定：未完成」并带理由',
+    closing?.title === '轮数用完 · 调度者判定：未完成（还没有查到任何订单数据）', closing?.title)
+  check('判定没完成的那一行是提醒色', closing?.level === 'warn', closing?.level)
+  check('不再把判定写成「第 3 轮」', !failRoutes.some((s) => s.title.includes('第 3 轮')),
+    failRoutes.map((s) => s.title).join(' | '))
+  const judged = routes(synthetic.exhaustedTeam('judged'))
+  check('判定完成：说「轮数用完 · 调度者判定：已完成」',
+    judged[judged.length - 1]?.title === '轮数用完 · 调度者判定：已完成', judged[judged.length - 1]?.title)
+  const live = routes(synthetic.exhaustedTeam('closing'))
+  const pending = live[live.length - 1]
+  check('还在判定时有一行进行中，不说「第 3 轮」',
+    pending?.status === 'running' && pending.title === '轮数用完 · 调度者在做最后判定…', `${pending?.status} ${pending?.title}`)
+
+  for (const mode of ['fail', 'judged', 'degrade']) {
+    const t = team(synthetic.exhaustedTeam(mode))?.team
+    check(`${mode}：泳道只有派过活的 2 轮，判定不加列`, t?.rounds.length === 2, `${t?.rounds.length} 轮`)
+  }
+  // reduceTeam 是画布协作矩阵和右栏共用的那一份：直接喂事件也不能多出一列
+  let direct
+  for (const e of synthetic.exhaustedTeam('fail')) {
+    const next = mod.reduceTeam(direct, e)
+    if (next && e.node_id === 'team') direct = next
+  }
+  check('reduceTeam 直接喂也只有 2 轮', direct?.rounds.length === 2, `${direct?.rounds.length}`)
+  check('reduceTeam 记下了判定结论', direct?.verdict?.closing === true && direct.verdict.done === false
+    && direct.verdict.reason === '还没有查到任何订单数据', JSON.stringify(direct?.verdict))
+  // 还在判定：泳道据此写「调度者在判定」，而不是空着或多一列
+  let judging
+  for (const e of synthetic.exhaustedTeam('closing')) {
+    const next = mod.reduceTeam(judging, e)
+    if (next && e.node_id === 'team') judging = next
+  }
+  check('判定进行中：记下在判定、还没有结论，也不加列', judging?.verdict?.closing === true && judging.verdict.done === undefined
+    && judging.rounds.length === 2, JSON.stringify(judging?.verdict))
+  const judgedTeam = team(synthetic.exhaustedTeam('judged'))?.team
+  check('判定完成时团队算收尾了', judgedTeam?.finished === true && judgedTeam.verdict?.done === true)
+
+  // 成员把工具调用写成文字：这一步是失败，不是一个写着失败原因的「完成」格子
+  const r0 = direct?.rounds[0]?.members.find((m) => m.agent === '取数员')
+  check('失败的成员格子是 failed', r0?.status === 'failed', r0?.status)
+  check('失败的成员带着原因', !!r0?.error?.includes('没有真正调用工具'), r0?.error)
+  const r1 = direct?.rounds[1]?.members.find((m) => m.agent === '分析员')
+  check('同一轮做完的成员照常是 done', r1?.status === 'done', r1?.status)
+  const memberRow = flatten(mod.decodeRun(synthetic.exhaustedTeam('fail')))
+    .find((s) => s.title.startsWith('取数员：') && s.status === 'failed')
+  check('失败的成员那一行也画成失败', !!memberRow && memberRow.level === 'error', memberRow?.status)
+  check('失败的成员那一行说清为什么', !!memberRow?.sub?.includes('没有真正调用工具'), memberRow?.sub)
+  check('一轮里有人失败时不算「省下」', direct?.savedMs === 0, `${direct?.savedMs}`)
+
+  // 判失败：矩阵和右栏都要说「用完 N 轮未完成」，点出从没派到的成员
+  check('判失败：团队的结局是 failed', direct?.verdict?.outcome === 'failed', JSON.stringify(direct?.verdict))
+  check('判失败：认出轮数', direct?.verdict?.rounds === 2, `${direct?.verdict?.rounds}`)
+  check('判失败：点出从没派到的成员', direct?.verdict?.never?.join(',') === '汇总员', direct?.verdict?.never?.join(','))
+
+  // 降档交付：节点「完成」了，但不能是一个安静的勾
+  const degraded = mod.decodeRun(synthetic.exhaustedTeam('degrade'))
+  const node = degraded.find((s) => s.nodeId === 'team')
+  check('降档：团队节点行是提醒色', node?.status === 'done' && node.level === 'warn', `${node?.status} ${node?.level}`)
+  check('降档：团队节点行说清是降档交付', !!node?.sub?.includes('用完 2 轮') && node.sub.includes('降档'), node?.sub)
+  check('降档：泳道的结局是 degraded，点出没派到的成员',
+    node?.team?.verdict?.outcome === 'degraded' && node.team.verdict.never?.join(',') === '汇总员',
+    JSON.stringify(node?.team?.verdict))
+  const note = flatten(degraded).find((s) => s.code === 'team_exhausted')
+  check('降档那条提醒说人话', note?.title === '协作团队用完 2 轮仍未完成 · 按降档交付', note?.title)
+  check('降档那条提醒给出下一步', !!note?.next && note.fix === 'canvas', `${note?.next} / ${note?.fix}`)
+  // 认不出轮数（老后端、措辞变了）时照实说「用完了轮数」，不拿「?」凑一个数
+  const vague = flatten(mod.decodeRun([
+    { seq: 1, type: 'node.started', node_id: 'team', ts: 1, data: { node_type: 'supervisor', label: '团队' } },
+    { seq: 2, type: 'log', node_id: 'team', ts: 2, data: { level: 'warn', code: 'team_exhausted', message: '协作团队没做完，按降档交付' } },
+    { seq: 3, type: 'node.finished', node_id: 'team', ts: 3, data: { duration_ms: 5, preview: { text: 'x', exhausted: true } } },
+  ]))
+  const vagueNote = vague.find((s) => s.code === 'team_exhausted')
+  const vagueNode = vague.find((s) => s.kind === 'node' && s.nodeId === 'team')
+  check('认不出轮数时不写「?」', !vagueNote?.title.includes('?') && !vagueNode?.sub?.includes('?')
+    && !!vagueNote?.title.includes('用完了轮数'), `${vagueNote?.title} / ${vagueNode?.sub}`)
+}
+
+console.log('\n=== 模型把工具调用写成了文字（NI-4）===')
+{
+  const all = flatten(mod.decodeRun(synthetic.markupRun()))
+  const warn = all.find((s) => s.code === 'tool_markup_leak')
+  check('提醒行说人话，不贴原始标记', warn?.title === '模型把工具调用写成了文字，没有真正执行'
+    && !warn.title.includes('DSML'), warn?.title)
+  check('说清已经提醒它重试', !!warn?.sub?.includes('重试一次'), warn?.sub)
+  check('给出下一步：去画布绑定工具', !!warn?.next?.includes('绑定') && warn.fix === 'canvas', `${warn?.next} / ${warn?.fix}`)
+  check('原始标记留在展开区给排查', !!warn?.detail?.includes('DSML'))
+  const team = flatten(mod.decodeRun(synthetic.exhaustedTeam('fail'))).find((s) => s.code === 'tool_markup_leak')
+  check('成员写成文字时说是哪个成员', team?.title === '取数员把工具调用写成了文字，没有真正执行', team?.title)
+  const node = mod.decodeRun(synthetic.markupRun()).find((s) => s.nodeId === 'query')
+  check('失败的节点照常是失败，原因留在详情', node?.status === 'failed' && !!node.detail?.includes('原始标记'))
+  // 收尾轮那种：真调过工具，只是步数用完了还想接着查。节点照常完成，不能说成「没有真正执行」
+  const settle = flatten(mod.decodeRun([
+    { seq: 1, type: 'node.started', node_id: 'q', ts: 1, data: { node_type: 'agent', label: '数据查询' } },
+    { seq: 2, type: 'log', node_id: 'q', ts: 2, data: { level: 'warn', code: 'tool_markup_leak',
+      message: '模型把工具调用写成了文字（<tool_call>{"name": "db_query__shop"…），没有真正调用工具：步数用完后的收尾轮仍想调用工具，结论只基于之前查到的部分' } },
+    { seq: 3, type: 'node.finished', node_id: 'q', ts: 3, data: { duration_ms: 9, preview: { text: '华东 1,204 单' } } },
+  ])).find((s) => s.code === 'tool_markup_leak')
+  check('收尾轮还想查：说步数用完，不说没有真正执行', !!settle?.title.includes('步数用完') && !settle.title.includes('没有真正执行'),
+    settle?.title)
+  check('收尾轮还想查：下一步是调大最多步数', !!settle?.next?.includes('最多步数'), settle?.next)
+}
+
+console.log('\n=== 校验修复想凑数（NI-3）===')
+{
+  const all = flatten(mod.decodeRun(synthetic.repairRun()))
+  const repairs = all.filter((s) => s.code === 'repair')
+  check('每次修复是一行模型调用', repairs.length === 2 && repairs.every((s) => s.kind === 'llm' && s.title === '让模型修复格式'),
+    repairs.map((s) => s.title).join(' | '))
+  check('修复调用带着耗时', repairs[0]?.meta === '1.3 s', repairs[0]?.meta)
+  check('被作废的修复折进那一行，不另起孤行', !all.some((s) => s.code === 'repair_invented'),
+    all.filter((s) => s.code === 'repair_invented').map((s) => s.title).join(','))
+  check('作废的修复画成提醒，说出凑出来的值', repairs.every((s) => s.level === 'warn' && s.sub?.includes('total_count=0')),
+    repairs.map((s) => `${s.level} ${s.sub}`).join(' | '))
+  check('作废的修复给出下一步', !!repairs[0]?.next?.includes('上游'), repairs[0]?.next)
+  check('第一次校验失败那条照常显示', all.some((s) => s.code === 'validate_retry' && s.title.includes('第 1 次校验失败')))
+  // 老数据：没有 purpose=repair 的 llm.end，作废说明也不能丢
+  const legacy = flatten(mod.decodeRun(synthetic.repairRun().filter((e) => e.type !== 'llm.end')))
+  const orphan = legacy.find((s) => s.code === 'repair_invented')
+  check('没有修复行可折时单独成一行说人话', !!orphan?.title.includes('修复被作废') && orphan.level === 'warn', orphan?.title)
+}
+
+console.log('\n=== 工具时限（timeout_s / timed_out）===')
+{
+  const live = flatten(mod.decodeRun(synthetic.timeoutRun('live'))).find((s) => s.kind === 'query')
+  check('进行中的查询带着时限', live?.limitS === 30 && live.status === 'running', `${live?.limitS} ${live?.status}`)
+  const done = flatten(mod.decodeRun(synthetic.timeoutRun('done'))).find((s) => s.kind === 'query')
+  check('超时的查询是失败', done?.status === 'failed' && done.level === 'error', done?.status)
+  check('超时的查询说清超了多少上限、已放弃等待', done?.sub === '超过 30 s 上限，已放弃等待', done?.sub)
+  check('超时的原话留在结果里', !!done?.result?.includes('缩小范围'))
+}
+
+console.log('\n=== 放弃等审批的运行 ===')
+{
+  const steps = mod.decodeRun(synthetic.abandonedRun())
+  const row = steps.find((s) => s.kind === 'lifecycle' && s.status === 'cancelled')
+  check('取消那一行说清谁放弃的、一并关了什么', !!row?.sub?.includes('张工') && row.sub.includes('1 条待审批一并关闭'), row?.sub)
+  check('放弃之后审批不再是待办', !flatten(steps).some((s) => s.status === 'waiting' || s.status === 'running'))
+  const plain = mod.decodeRun(synthetic.cancelledRun()).find((s) => s.kind === 'lifecycle' && s.status === 'cancelled')
+  check('老数据的取消行不硬编副标题', plain && !plain.sub, plain?.sub)
+}
+
+console.log('\n=== 出具那一行记着档位 ===')
+{
+  const is = mod.decodeRun(synthetic.mixedRun()).find((s) => s.kind === 'issuance')
+  check('出具步骤带 tier，头部能据此提醒', is?.tier === 'degraded', is?.tier)
+}
+
+console.log('\n=== Copilot 改图：工具绑定变化（NI-1）===')
+{
+  const steps = mod.decodeCopilot(synthetic.COPILOT_TOOLS_DROPPED, { context: 'chat' })
+  const change = steps.find((s) => s.code === 'tool_changes')
+  check('工具绑定变化单独成一行', !!change, steps.map((s) => s.title).join(' | '))
+  check('工具少了用提醒色，说清是哪个节点', change?.level === 'warn' && change.title.includes('数据查询'), change?.title)
+  check('逐项列出前后', !!change?.detail?.includes('db_query__shop') && change.detail.includes('→'), change?.detail)
+  const selfCheck = steps.find((s) => s.title.startsWith('自查通过'))
+  check('自查通过但有工具被去掉：自查那一行是提醒，不是安静的通过', selfCheck?.level === 'warn'
+    && selfCheck.title.includes('工具'), `${selfCheck?.level} ${selfCheck?.title}`)
+  const out = mod.copilotOutcome(synthetic.COPILOT_TOOLS_DROPPED)
+  check('结局里带着工具绑定变化', out.toolChanges?.length === 1 && out.toolChanges[0].removed.length === 2,
+    JSON.stringify(out.toolChanges))
+  check('结局里带着「工具被去掉」的警告', out.dropped?.length === 1, JSON.stringify(out.dropped))
+  const plain = mod.copilotOutcome(synthetic.COPILOT_STUCK)
+  check('没有变化时两样都是空的', !plain.toolChanges?.length && !plain.dropped?.length)
+}
+
 console.log('\n=== 术语 ===')
 {
   // 没起名的节点退到类型名，类型名跟全站同一张表
diff --git a/scripts/check-guards.mjs b/scripts/check-guards.mjs
index c2e63568..33782356 100644
--- a/scripts/check-guards.mjs
+++ b/scripts/check-guards.mjs
@@ -1,5 +1,5 @@
-// 几道"坏了就是整页事故"的护栏：输入法回车、未知节点类型、页面级错误边界、
-// 全局快捷键不抢输入框、未知地址不是白板。
+// 几道"坏了就是整页事故"的护栏：输入法回车、未知节点类型、页面级和外壳级的
+// 错误边界、全局快捷键不抢输入框、未知地址不是白板。
 //
 // 出事时的样子都很重：中文用户每选一个词就把半句话发去建图、跑图；
 // Copilot 编出一个不存在的节点类型，整站白屏、没保存的编辑一起丢；任何组件渲染
@@ -90,6 +90,20 @@ await page.waitForURL(/\/chat/)
 check('换一页就恢复', await page.getByText('这一页出错了').waitFor({ state: 'detached', timeout: 8000 })
   .then(() => true, () => false))
 
+console.log('\n=== 外壳自己出错：落在中文错误页，不是路由库的英文报错页 ===')
+// 导航、后台信号不在页面那一层错误边界里。路由换成 data router 之后，它们一出错，
+// 没人接的话 react-router 会画它自带的「Unexpected Application Error!」和一屏堆栈。
+// 导航上的「有运行在跑」要读画布的 trace：跑着却没有 trace，导航渲染就会抛
+await page.evaluate(() => {
+  window.__savedTrace = window.__studio.getState().trace
+  window.__studio.setState({ runPhase: 'running', trace: null })
+})
+check('给出中文的错误页', await shows('这一页出错了'))
+check('不是 react-router 的英文报错页', !(await page.locator('body').innerText()).includes('Unexpected Application Error'))
+await page.evaluate(() => window.__studio.setState({ runPhase: 'idle', trace: window.__savedTrace }))
+await page.getByRole('button', { name: '重试' }).first().click()
+check('点「重试」外壳就回来', await page.locator('nav[aria-label="主导航"]').waitFor({ timeout: 8000 }).then(() => true, () => false))
+
 console.log('\n=== 全局快捷键：不抢输入框 ===')
 // 外壳在 window 的捕获阶段听键盘，比谁都先拿到。判错一次，问题框里打个问号就
 // 弹出一层面板、⌥3 直接把人带离写了一半的问题
diff --git a/scripts/check-manage.mjs b/scripts/check-manage.mjs
index 707a88bf..171a11b2 100644
--- a/scripts/check-manage.mjs
+++ b/scripts/check-manage.mjs
@@ -41,15 +41,55 @@ try {
 
 const browser = await chromium.launch({ executablePath: CHROME })
 
+/**
+ * 上传进度靠浏览器的 xhr.upload 事件，而 page.route 拦下的请求 Chrome 一个进度事件
+ * 都不报（真请求会报，已实测）。所以在页面里替 XHR 报：发 /upload 时先报 40%，
+ * 0.7 秒后报发完，再真正 send（被 page.route 接住）。发之前 abort 的，照浏览器的
+ * 样子报一次 abort。只测界面怎么接这些事件，不碰后端
+ */
+function fakeUploadProgress() {
+  const open = XMLHttpRequest.prototype.open
+  const send = XMLHttpRequest.prototype.send
+  const abort = XMLHttpRequest.prototype.abort
+  XMLHttpRequest.prototype.open = function (method, url, ...rest) {
+    this.__url = String(url)
+    return open.call(this, method, url, ...rest)
+  }
+  XMLHttpRequest.prototype.abort = function () {
+    if (this.__pending) {
+      this.__pending = false
+      this.dispatchEvent(new ProgressEvent('abort'))
+      return
+    }
+    return abort.call(this)
+  }
+  XMLHttpRequest.prototype.send = function (body) {
+    if (!/\/upload(\?|$)/.test(this.__url ?? '')) return send.call(this, body)
+    const total = 2_000_000
+    const up = this.upload
+    this.__pending = true
+    const fire = (type, loaded) => up.dispatchEvent(new ProgressEvent(type, { lengthComputable: true, loaded, total }))
+    setTimeout(() => { if (this.__pending) fire('progress', 800_000) }, 50)
+    setTimeout(() => {
+      if (!this.__pending) return
+      this.__pending = false
+      fire('progress', total)
+      fire('load', total)
+      send.call(this, body)
+    }, 700)
+  }
+}
+
 /**
  * 开一页：GET 放行，写请求交给 handlers（按「METHOD 路径正则」匹配），没配的一律
  * 拦成 503——既不写库，也顺带检验「写失败有反馈」。所有原生对话框都算失败。
  */
-async function open(path, { handlers = [], theme = THEME, viewport = { width: 1280, height: 860 } } = {}) {
+async function open(path, { handlers = [], theme = THEME, viewport = { width: 1280, height: 860 }, uploadProgress = false } = {}) {
   const ctx = await browser.newContext({ viewport, colorScheme: theme, timezoneId: 'Asia/Shanghai' })
   await ctx.addInitScript((t) => {
     try { localStorage.setItem('agentlab.theme', t); localStorage.removeItem('agentlab.health') } catch { /* noop */ }
   }, theme)
+  if (uploadProgress) await ctx.addInitScript(fakeUploadProgress)
   const page = await ctx.newPage()
   const sent = []
   const errors = []
@@ -85,6 +125,15 @@ const goto = async (page, path) => {
   await page.waitForTimeout(300)
 }
 const json = (data, status = 200) => (route) => route.fulfill({ status, contentType: 'application/json', body: JSON.stringify(data) })
+/** 多久之前的服务器时间（后端列表里的 last_checked_at 就是这种带时区的 ISO） */
+const ago = (ms) => new Date(Date.now() - ms).toISOString()
+/** 等到条件成立或超时，返回最后一次的值 */
+const until = async (fn, ms = 8000, step = 200) => {
+  const end = Date.now() + ms
+  let v = await fn()
+  while (!v && Date.now() < end) { await new Promise((r) => setTimeout(r, step)); v = await fn() }
+  return v
+}
 const delayed = (ms, data, status = 200) => async (route) => { await new Promise((r) => setTimeout(r, ms)); return json(data, status)(route) }
 const shot = async (page, name) => { if (SHOTS) await page.screenshot({ path: `${SHOTS}/${name}.png` }) }
 const text = (page) => page.locator('main').innerText()
@@ -135,8 +184,14 @@ for (const [path, title] of [['/tools', '工具'], ['/knowledge', '知识'], ['/
 console.log('\n=== 设置 · 模型接入 ===')
 {
   const p0 = providers[0]
+  // 后端记着上次测连接的结果（last_check_*）：第一张卡 3 小时前测过、没通过，其余没测过
+  const listed = providers.map((p, i) => (i === 0 ? {
+    ...p, last_checked_at: ago(3 * 3600_000), last_check_ok: false, last_latency_ms: null,
+    last_error: '鉴权没通过（401）：对方拒绝了这把密钥',
+  } : { ...p, last_checked_at: null, last_check_ok: null, last_latency_ms: null, last_error: null }))
   const { page, sent, natives, errors, close } = await open('/settings/providers', {
     handlers: [
+      [/^GET \/providers$/, json(listed)],
       [/^POST \/providers\/[^/]+\/test$/, delayed(300, { ok: true, latency_ms: 128, model: p0?.default_model ?? 'm', reply: 'pong' })],
       [/^POST \/providers\/test$/, json({ ok: false, error: '测试没通过：连不上对方的服务', hint: '核对地址和端口，确认服务已经启动', detail: 'OpenAIConnectionError: Connection error.' })],
       [/^POST \/providers\/models$/, json({ ok: true, models: ['qwen-max', 'qwen-plus'], url: 'x' })],
@@ -144,7 +199,14 @@ console.log('\n=== 设置 · 模型接入 ===')
   })
   if (p0) {
     const card = page.locator(`[data-provider="${p0.name}"]`)
-    check('卡片上的状态点说的是连通，没测过写「未测试」', (await card.locator('[data-health]').getAttribute('data-health')) === 'idle')
+    const first = await card.locator('[data-health]').innerText()
+    check('卡片初值是后端记着的上次结果：连不上 · 3 小时前测（换了浏览器也在）', /连不上.*3 小时前测/.test(first), first)
+    check('……原因也写在卡片上', (await card.innerText()).includes('对方拒绝了这把密钥'))
+    const p1 = providers[1]
+    if (p1) {
+      check('后端没测过的卡片写「未测试」',
+            (await page.locator(`[data-provider="${p1.name}"] [data-health]`).getAttribute('data-health')) === 'idle')
+    }
     const disabled = providers.find((p) => !p.enabled)
     if (disabled) {
       check('停用单独标「已停用」，不再借圆点表达',
@@ -155,7 +217,7 @@ console.log('\n=== 设置 · 模型接入 ===')
     check('测试中状态点在转、写已用时间', (await card.locator('[data-health]').getAttribute('data-health')) === 'checking')
     await page.waitForTimeout(600)
     const pill = await card.locator('[data-health]').innerText()
-    check('测完留在卡片上，写明是什么时候测的：已连通 · 128 ms · 刚测过', /已连通.*128 ms.*刚测过/.test(pill), pill)
+    check('本机刚测的比后端记的新，用本机的：已连通 · 128 ms · 刚测过', /已连通.*128 ms.*刚测过/.test(pill), pill)
     await shot(page, 'providers-tested')
     await page.getByRole('tab', { name: '运行环境' }).click()
     await page.waitForTimeout(300)
@@ -214,27 +276,45 @@ console.log('\n=== 设置 · 模型接入 ===')
 
 console.log('\n=== 设置 · 偏好 ===')
 {
-  const settings = await get('/settings')
+  // 设置读写都走假的一份：PUT 写进去，GET 读回来（主题的「已保存」是读回来核对过才写的）
+  let stored = await get('/settings')
   const { page, sent, natives, close } = await open('/settings/prefs', {
-    handlers: [[/^PUT \/settings$/, (route, { body }) => json({ ...settings, ...body.values })(route)]],
+    handlers: [
+      [/^GET \/settings$/, (route) => json(stored)(route)],
+      [/^PUT \/settings$/, (route, { body }) => { stored = { ...stored, ...body.values }; return json(stored)(route) }],
+    ],
   })
+  const themeRadio = (label) => page.getByRole('radiogroup', { name: '主题' }).getByRole('radio', { name: label })
+  const checkedTheme = () => page.getByRole('radiogroup', { name: '主题' }).locator('[aria-checked="true"]').innerText()
   // 选一个和这次要截图的主题一致的值（浅色跑选「跟随系统」，上下文的 colorScheme
   // 是浅色）；它已经是选中的就先绕一下别的，点选中项不会发请求
   const [label, value] = THEME === 'dark' ? ['深色', 'dark'] : ['跟随系统', 'system']
-  const radio = page.getByRole('radio', { name: label })
-  if ((await radio.getAttribute('aria-checked')) === 'true') {
-    await page.getByRole('radio', { name: '浅色' }).click()
-    await page.waitForTimeout(300)
+  if ((await themeRadio(label).getAttribute('aria-checked')) === 'true') {
+    await themeRadio('浅色').click()
+    await page.waitForTimeout(400)
   }
-  await radio.click()
-  await page.waitForTimeout(400)
+  await themeRadio(label).click()
+  await page.waitForTimeout(500)
   const put = sent.filter((s) => s.key === 'PUT /settings').at(-1)
   check('主题选中即保存，只 PUT ui 一组', !!put && Object.keys(put.body?.values ?? {}).join() === 'ui' && put.body.values.ui.theme === value,
         JSON.stringify(put?.body ?? {}).slice(0, 100))
-  check('主题旁显示「已保存」', (await page.locator('[data-theme-save]').innerText()).includes('已保存'))
+  check('主题旁显示「已保存」（读回来核对过）', (await page.locator('[data-theme-save]').innerText()).includes('已保存'))
   await page.waitForTimeout(1600)
   check('……约 1.6 秒后淡出，不一直挂着', await page.getByText('已保存', { exact: true }).count() === 0
         && await page.locator('[data-theme-save="saved"]').count() === 0)
+
+  // REQ：从导航（或 ⌘K）换主题时偏好页开着，选项要跟着变，不能还显示旧值
+  const resolvedBefore = await page.evaluate(() => {
+    const a = document.documentElement.getAttribute('data-theme')
+    return a === 'light' || a === 'dark' ? a : (matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark')
+  })
+  await page.getByRole('button', { name: /^切换到(浅色|深色)主题$/ }).click()
+  await page.waitForTimeout(500)
+  const synced = await checkedTheme()
+  check('从导航换主题：偏好页的主题选项跟着变', synced.includes(resolvedBefore === 'dark' ? '浅色' : '深色'), synced)
+  await themeRadio(label).click()
+  await page.waitForTimeout(500)
+
   check('默认知识库是下拉，选项来自已有知识库',
         await page.locator('#pref-collection').evaluate((el) => el.tagName) === 'SELECT'
         && (await page.locator('#pref-collection option').allInnerTexts()).some((t) => t.startsWith(collections[0]?.collection ?? 'default')))
@@ -252,23 +332,71 @@ console.log('\n=== 设置 · 偏好 ===')
   await page.waitForTimeout(200)
   check('选「留下」就还在偏好页', page.url().endsWith('/settings/prefs'), page.url())
 
+  const putsBefore = sent.filter((s) => s.key === 'PUT /settings').length
+  await page.getByRole('button', { name: /保存设置/ }).click()
+  await page.waitForTimeout(250)
+  check('只改署名：存在本机就行，不发 PUT', sent.filter((s) => s.key === 'PUT /settings').length === putsBefore)
+  check('保存后说「已保存」', (await page.locator('[data-prefs-bar]').innerText().catch(() => '')).includes('已保存'))
+  check('署名写进本机', await page.evaluate(() => localStorage.getItem('agentlab_actor')) === '检查脚本')
+  const initial = await page.locator('nav a[href="/settings/prefs"]').first().innerText().catch(() => '')
+  check('……导航底部的署名首字立刻换成「检」（同一个标签页也收得到）', initial.trim() === '检', initial)
+
+  await page.locator('#pref-confirm-hint').locator('xpath=ancestor::label//input').click()
   await page.getByRole('button', { name: /保存设置/ }).click()
   await page.waitForTimeout(400)
   const put2 = sent.filter((s) => s.key === 'PUT /settings').at(-1)
-  check('保存设置只 PUT run 一组', Object.keys(put2?.body?.values ?? {}).join() === 'run', JSON.stringify(put2?.body ?? {}).slice(0, 100))
-  check('保存后说「已保存」', (await page.locator('[data-prefs-bar]').innerText().catch(() => '')).includes('已保存'))
-  check('署名跟着保存写进本机', await page.evaluate(() => localStorage.getItem('agentlab_actor')) === '检查脚本')
+  check('改了运行默认值：保存只 PUT run 一组', Object.keys(put2?.body?.values ?? {}).join() === 'run', JSON.stringify(put2?.body ?? {}).slice(0, 100))
   check('没有原生对话框', natives.length === 0, natives.join(' | '))
   await close()
 
   // 保存失败要看得见（以前 pageerror 一条，界面毫无变化）
   const failing = await open('/settings/prefs')
   await failing.page.locator('#pref-actor').fill('x')
+  await failing.page.locator('#pref-confirm-hint').locator('xpath=ancestor::label//input').click()
   await failing.page.getByRole('button', { name: /保存设置/ }).click()
   await failing.page.waitForTimeout(600)
-  check('保存失败：条上写「没存上」', (await failing.page.locator('[data-prefs-bar]').innerText()).includes('没存上'))
+  const bar = await failing.page.locator('[data-prefs-bar]').innerText()
+  check('保存失败：条上写「没存上」', bar.includes('没存上'))
+  check('……署名只在本机，已经存上了；条上只剩危险工具审批一项', bar.includes('有 1 项未保存') && bar.includes('危险工具审批') && !bar.includes('署名'), bar.replace(/\s+/g, ' '))
   check('保存失败不抛未捕获异常', failing.errors.length === 0, failing.errors[0] ?? '')
   await failing.close()
+
+  // 断线时在偏好页换的主题：先在本机生效，恢复后自动补存，而不是被服务端的旧值翻回去。
+  // 断线要断得像真的：/health 也够不着，catalog 才会判断开、恢复时才算「重连」
+  let offline = false
+  let puts = 0
+  let stored2 = await get('/settings')
+  const cut = (route) => route.abort('internetdisconnected')
+  const off = await open('/settings/prefs', {
+    handlers: [
+      [/^GET \/settings$/, (route) => (offline ? cut(route) : json(stored2)(route))],
+      [/^PUT \/settings$/, (route, { body }) => {
+        puts++
+        if (offline) return cut(route)
+        stored2 = { ...stored2, ...body.values }
+        return json(stored2)(route)
+      }],
+      [/^GET \//, (route) => (offline ? cut(route) : route.continue())],
+    ],
+  })
+  const offRadio = (l) => off.page.getByRole('radiogroup', { name: '主题' }).getByRole('radio', { name: l })
+  const target = (await offRadio('浅色').getAttribute('aria-checked')) === 'true' ? ['深色', 'dark'] : ['浅色', 'light']
+  offline = true
+  await offRadio(target[0]).click()
+  await off.page.waitForTimeout(800)
+  check('断线时换主题：说清先在本机生效、连上后自动存', (await off.page.locator('body').innerText()).includes('连上后端后自动存进设置'))
+  check('……选项和页面都已经是新主题', (await offRadio(target[0]).getAttribute('aria-checked')) === 'true'
+        && await off.page.evaluate(() => document.documentElement.getAttribute('data-theme')) === target[1])
+  const down = await until(() => off.page.locator('[data-offline-banner]').count().then((n) => n > 0), 6000)
+  check('……整站也判了断开（横幅出来了）', !!down)
+  const putsOffline = puts
+  offline = false
+  await until(() => stored2?.ui?.theme === target[1], 20000)
+  await off.page.waitForTimeout(400)
+  check('……后端恢复后自动补存这个主题', puts > putsOffline && stored2?.ui?.theme === target[1], `PUT ${puts} 次，存的是 ${stored2?.ui?.theme}`)
+  check('……没有被服务端的旧值翻回去', await off.page.evaluate(() => document.documentElement.getAttribute('data-theme')) === target[1]
+        && (await offRadio(target[0]).getAttribute('aria-checked')) === 'true')
+  await off.close()
 }
 
 console.log('\n=== 数据 · 数据库 ===')
@@ -276,22 +404,50 @@ console.log('\n=== 数据 · 数据库 ===')
   const dbs = sources.filter((s) => !/[\\/]uploads[\\/]tables[\\/]/.test(s.database ?? ''))
   const first = dbs.find((s) => s.table_count > 0) ?? dbs[0]
   const oracle = dbs.find((s) => s.kind === 'oracle')
-  // 一个配置里的 schema 探不出对象的假库：只有这种库才给「换个 schema 探查」。
-  // 顺带是个免密库（has_password:false），验证密码不再拦保存
+  const noCheck = { last_checked_at: null, last_check_ok: null, last_latency_ms: null, last_error: null }
+  // 假库一：配置里的 schema 探不出对象；后端记着 2 小时前测连接没通过。顺带是个免密库
+  // （has_password:false），验证密码不再拦保存
   const empty = {
     id: 'check-manage-empty', name: 'zz_probe', kind: 'postgres', host: '10.0.0.9', port: null, database: 'mes',
-    username: 'reader', options: { schema: 'ods' }, readonly: true, description: '检查脚本的假库', enabled: true,
-    password_masked: '', has_password: false, table_count: 0, schema_synced_at: null,
+    username: 'reader', options: { schema: 'ods', sslmode: 'disable' }, readonly: true, description: '检查脚本的假库', enabled: true,
+    password_masked: '', has_password: false, table_count: 0, schema_synced_at: null, cached_schema: 'ods',
     schema_error: 'NoSuchTableError: ods', available_schemas: ['mes', 'ods', 'public'], tools: ['db_query__zz_probe'],
+    last_checked_at: ago(2 * 3600_000), last_check_ok: false, last_latency_ms: null, last_error: '连不上：认证失败',
   }
-  const probed = { ...empty, table_count: 3, schema_error: '', schema_synced_at: new Date().toISOString() }
+  // 假库二：配置改成了 sales，缓存还是按 legacy 探的——助手看到的和配置对不上
+  const drifted = {
+    ...empty, ...noCheck, id: 'check-manage-drift', name: 'zz_drift', options: { schema: 'sales' }, cached_schema: 'legacy',
+    table_count: 2, schema_error: '', available_schemas: [], schema_synced_at: ago(3600_000), tools: ['db_query__zz_drift'],
+  }
+  let cur = empty
+  let drift = drifted
   const { page, sent, natives, errors, close } = await open('/data/databases', {
     handlers: [
-      [/^GET \/datasources$/, json([...sources, empty])],
-      [/^GET \/datasources\/check-manage-empty\/schema$/, json({ tables: ['mes.work_order', 'mes.line', 'mes.shift'], summary: '', synced_at: probed.schema_synced_at })],
-      [/^POST \/datasources\/check-manage-empty\/introspect$/, (route, { url }) =>
-        json(url.searchParams.get('schema') === 'mes' ? probed : empty)(route)],
-      [/^PATCH \/datasources\/check-manage-empty$/, (route, { body }) => json({ ...empty, ...body, options: body?.options ?? empty.options })(route)],
+      [/^GET \/datasources$/, (route) => json([...sources, cur, drift])(route)],
+      [/^GET \/datasources\/check-manage-empty\/schema$/, json({ tables: ['mes.work_order', 'mes.line', 'mes.shift'], summary: '', synced_at: ago(0) })],
+      [/^GET \/datasources\/check-manage-drift\/schema$/, json({ tables: ['sales.orders', 'sales.sales_daily'], summary: '', synced_at: ago(0) })],
+      [/^POST \/datasources\/check-manage-empty\/introspect$/, (route, { url }) => {
+        const schema = url.searchParams.get('schema')
+        if (url.searchParams.get('dry_run') === 'true') {
+          return json(schema === 'mes'
+            ? { dry_run: true, schema: 'mes', table_count: 3, tables: ['mes.work_order', 'mes.line', 'mes.shift'], truncated: false, total: 3, schema_error: '', available_schemas: empty.available_schemas }
+            : { dry_run: true, schema, table_count: 0, tables: [], truncated: false, total: 0, schema_error: '', available_schemas: empty.available_schemas })(route)
+        }
+        const hit = cur.options.schema === 'mes'
+        cur = { ...cur, cached_schema: cur.options.schema ?? '', table_count: hit ? 3 : 0, schema_error: hit ? '' : empty.schema_error,
+                schema_synced_at: hit ? ago(0) : cur.schema_synced_at }
+        return json(cur)(route)
+      }],
+      [/^POST \/datasources\/check-manage-drift\/introspect$/, (route) => {
+        drift = { ...drift, cached_schema: drift.options.schema, schema_synced_at: ago(0) }
+        return json(drift)(route)
+      }],
+      // 后端的规矩：连接配置（地址、账号、库）改了，上次测连接的结果作废
+      [/^PATCH \/datasources\/check-manage-empty$/, (route, { body }) => {
+        const reconnect = ['host', 'port', 'database', 'username'].some((k) => k in (body ?? {}) && body[k] !== cur[k]) || 'password' in (body ?? {})
+        cur = { ...cur, ...body, options: body?.options ?? cur.options, ...(reconnect ? noCheck : {}) }
+        return json(cur)(route)
+      }],
       [/^POST \/datasources\/[^/]+\/test$/, delayed(250, { ok: true, elapsed_ms: 42, url: 'x' })],
       [/^POST \/datasources\/test$/, json({ ok: false, error: '连不上：认证失败', hint: '核对用户名和密码', detail: 'ORA-01017' })],
       [/^POST \/datasources\/[^/]+\/introspect/, (route, { url }) => {
@@ -332,7 +488,7 @@ console.log('\n=== 数据 · 数据库 ===')
       await rows.first().click()
       await page.waitForTimeout(800)
       const cols = await card.locator('[data-schema-browser] tbody tr').count()
-      check('点表名懒加载出逐列信息', cols > 0, `${cols} 列`)
+      check('点表名懒加载出逐列信息（后端给的结构化列）', cols > 0, `${cols} 列`)
       const scroller = card.locator('[data-schema-browser] .overflow-y-auto')
       await scroller.evaluate((el) => { el.scrollTop = 60 })
       const before = await scroller.evaluate((el) => el.scrollTop)
@@ -345,8 +501,9 @@ console.log('\n=== 数据 · 数据库 ===')
       await shot(page, 'datasource-schema')
     }
 
-    // 好好的库不给「换个 schema 探查」：后端探查会落进缓存，换着探就把助手看到的结构换掉了
-    check('结构正常的库不给「换个 schema 探查」', await card.locator('[data-probe-schema]').count() === 0)
+    // 「换个 schema 看看」只看不存，好好的库也给；单文件的 SQLite 没有 schema 可换
+    check(first.kind === 'sqlite' ? 'SQLite 不给「换个 schema 看看」' : '结构正常的库也能「换个 schema 看看」（只看不存，没有风险）',
+          await card.locator('[data-probe-schema]').count() === (first.kind === 'sqlite' ? 0 : 1))
 
     await card.getByRole('button', { name: `删除数据源 ${first.name}` }).click()
     const del = dialog(page)
@@ -358,40 +515,50 @@ console.log('\n=== 数据 · 数据库 ===')
   }
 
   {
-    // 配置里的 schema 探不出东西：才给「换个 schema 探查」
     const ec = page.locator(`[data-source="${empty.name}"]`)
-    check('探查失败的库给「换个 schema 探查」', await ec.locator('[data-probe-schema]').count() === 1)
+    const pill0 = await ec.locator('[data-health]').innerText()
+    check('卡片初值是后端记着的上次测连接：连不上 · 2 小时前测', /连不上.*2 小时前测/.test(pill0), pill0)
+    check('……原因写在卡片上', (await ec.innerText()).includes('认证失败'))
+
+    // 换个 schema 看看：只看不存（dry_run），缓存和配置都不动
+    check('探查失败的库给「换个 schema 看看」', await ec.locator('[data-probe-schema]').count() === 1)
     await ec.locator('[data-probe-schema]').click()
     const pd = dialog(page)
     const pdText = await pd.innerText()
-    check('……先说清楚：探到的结构会换掉缓存，不写进配置就换回来', pdText.includes('换掉') && pdText.includes('换回「ods」'), pdText.slice(0, 120))
+    check('……先说清楚：只看不存，缓存和配置都不动', pdText.includes('只看不存') && pdText.includes('缓存和配置都不动'), pdText.slice(0, 120))
     await pd.locator('input').fill('mes')
-    await pd.getByRole('button', { name: '探查', exact: true }).click()
+    await pd.getByRole('button', { name: '看看', exact: true }).click()
     await page.waitForTimeout(500)
     const probeReq = sent.filter((s) => s.key.endsWith('/introspect')).at(-1)
-    check('……请求带上指定的 schema', !!probeReq?.url.includes('schema=mes'), probeReq?.url ?? '')
+    check('……请求带上 schema 和 dry_run=true（不写缓存）', !!probeReq?.url.includes('schema=mes') && probeReq.url.includes('dry_run=true'), probeReq?.url ?? '')
     const ask = dialog(page)
     const askText = await ask.innerText().catch(() => '')
     check('……探到了再问要不要写进配置，并举出探到的表名', askText.includes('mes') && askText.includes('work_order'), askText.slice(0, 160))
+    check('……「不改」说的是什么都不动，不再「换回去」', askText.includes('什么都不动') && !askText.includes('换回'), askText.slice(0, 200))
     await shot(page, 'datasource-probe-schema')
-    const before = sent.filter((s) => s.key.endsWith('/introspect')).length
-    await ask.getByRole('button', { name: '不改，换回 ods' }).click()
+    const before = sent.length
+    await ask.getByRole('button', { name: '不改', exact: true }).click()
     await page.waitForTimeout(500)
-    const restore = sent.filter((s) => s.key.endsWith('/introspect')).slice(before)
-    check('……不改：马上按配置里的 schema 重探一次，缓存和配置对得上',
-          restore.length === 1 && !restore[0].url.includes('schema='), restore.map((r) => r.url).join(' | '))
-    check('……不改就不发 PATCH', !sent.some((s) => s.key.startsWith('PATCH /datasources')))
-    check('……卡片回到配置里那份（探查失败、0 个对象）', (await ec.innerText()).includes('上次探查失败'))
+    check('……不改：一个请求都不再发（以前要再探一次把缓存换回来）', sent.length === before, sent.slice(before).map((r) => r.url).join(' | '))
+    check('……卡片还是配置里那份（探查失败、0 个对象）', (await ec.innerText()).includes('上次探查失败'))
 
-    // 失败框里的候选 chip：探到了选「改」就写进配置
-    await ec.getByRole('button', { name: '用 mes 探查' }).click()
+    // 失败框里的候选 chip：探到了选「改」就写进配置，再按新配置真探一次
+    await ec.getByRole('button', { name: '看看 mes' }).click()
     await page.waitForTimeout(500)
     await dialog(page).getByRole('button', { name: '改成 mes' }).click()
-    await page.waitForTimeout(400)
+    await page.waitForTimeout(600)
     const patch = sent.filter((s) => s.key === 'PATCH /datasources/check-manage-empty').at(-1)
-    check('……选「改成 mes」：PATCH 写进 options.schema', patch?.body?.options?.schema === 'mes', JSON.stringify(patch?.body ?? {}))
+    check('……选「改成 mes」：PATCH 写进 options.schema，别的连接参数原样带上',
+          patch?.body?.options?.schema === 'mes' && patch?.body?.options?.sslmode === 'disable', JSON.stringify(patch?.body ?? {}))
+    const real = sent.filter((s) => s.key.endsWith('check-manage-empty/introspect')).at(-1)
+    check('……再按新配置真探一次（不带 dry_run）', !!real && !real.url.includes('dry_run') && !real.url.includes('schema='), real?.url ?? '')
+    const ecText = await ec.innerText()
+    check('……卡片换成新 schema 的结构', /3\s*个对象/.test(ecText) && !ecText.includes('上次探查失败'), ecText.replace(/\s+/g, ' ').slice(0, 160))
 
-    // 免密库：密码不拦保存
+    // 本机刚测的比后端记的新；只改说明不动它，改了连接配置就作废
+    await ec.getByRole('button', { name: /测连接/ }).click()
+    await page.waitForTimeout(500)
+    check('本机刚测过：卡片换成本机的结果', /已连通.*42 ms/.test(await ec.locator('[data-health]').innerText()))
     await ec.getByRole('button', { name: '编辑' }).click()
     const ed = dialog(page)
     await ed.getByLabel('说明', { exact: true }).fill('检查脚本的假库（改过说明）')
@@ -407,6 +574,24 @@ console.log('\n=== 数据 · 数据库 ===')
     const saved = sent.filter((s) => s.key === 'PATCH /datasources/check-manage-empty').at(-1)
     check('……保存时不带 password（不动它）', !!saved && !('password' in (saved.body ?? {})) && saved.body?.description?.includes('改过说明'),
           JSON.stringify(saved?.body ?? {}).slice(0, 120))
+    check('……只改说明：刚测的结果还作数', /已连通/.test(await ec.locator('[data-health]').innerText()))
+    await ec.getByRole('button', { name: '编辑' }).click()
+    await dialog(page).getByLabel(/主机/).fill('10.0.0.10')
+    await dialog(page).getByRole('button', { name: '保存' }).click()
+    await page.waitForTimeout(400)
+    const after = await ec.locator('[data-health]').innerText()
+    check('……换了主机：之前测的不再代表它，回到「未测试」', after.includes('未测试'), after)
+
+    // 缓存和配置对不上：常驻一行 warn，一键按配置重探
+    const dc = page.locator(`[data-source="${drifted.name}"]`)
+    const driftText = await dc.locator('[data-schema-drift]').innerText().catch(() => '')
+    check('缓存按 legacy 探、配置写着 sales：卡片上常驻一行说对不上', driftText.includes('legacy') && driftText.includes('sales'), driftText)
+    await shot(page, 'datasource-drift')
+    await dc.getByRole('button', { name: '按配置重新探查' }).click()
+    await page.waitForTimeout(500)
+    const re = sent.filter((s) => s.key === 'POST /datasources/check-manage-drift/introspect').at(-1)
+    check('……点「按配置重新探查」：按配置真探（不带 schema、不带 dry_run）', !!re && !re.url.includes('?'), re?.url ?? '')
+    check('……探完那行 warn 就消失', await dc.locator('[data-schema-drift]').count() === 0)
   }
 
   if (oracle) {
@@ -463,11 +648,21 @@ console.log('\n=== 数据 · 表格 ===')
     ] }],
   }
   const { page, sent, natives, close } = await open('/data/tables', {
+    uploadProgress: true,
     handlers: [
       [/^POST \/datasources\/upload$/, delayed(400, fake, 201)],
       // 传上来的表只有一两张，卡片会自动摊开结构：假的那张也得有结构可取
+      // 列注释里带两个空格：以前解析 detail 文本（按两个以上空格切列），「见附表」会被切丢
       [/^GET \/datasources\/check-manage-fake\/schema$/, (route, { url }) => json(url.searchParams.get('table')
-        ? { table: 'sales_demo', detail: '表 sales_demo\n  2026-01  REAL\n  region  TEXT\n  Unnamed: 2  TEXT' }
+        ? {
+            table: 'sales_demo', found: true, qualified: 'sales_demo', kind: 'table', comment: '按月的销售明细',
+            detail: '表 sales_demo（按月的销售明细）\n  2026-01  REAL\n  region  TEXT  主键、非空、销售区域  见附表\n  Unnamed: 2  TEXT',
+            columns: [
+              { name: '2026-01', type: 'REAL', pk: false, not_null: false, comment: null },
+              { name: 'region', type: 'TEXT', pk: true, not_null: true, comment: '销售区域  见附表' },
+              { name: 'Unnamed: 2', type: 'TEXT', pk: false, not_null: false, comment: null },
+            ],
+          }
         : { tables: ['sales_demo'], summary: '', synced_at: fake.source.schema_synced_at })(route)],
     ],
   })
@@ -476,8 +671,21 @@ console.log('\n=== 数据 · 表格 ===')
   await dlg.locator('input[type="file"]').setInputFiles({ name: 'sales_demo.csv', mimeType: 'text/csv', buffer: Buffer.from('2026-01,region\n1,east\n') })
   check('文件名自动变成数据源名', (await dlg.locator('input.mono').first().inputValue()) === 'sales_demo')
   await dlg.getByRole('button', { name: /导入/ }).click()
-  await page.waitForTimeout(100)
+  await page.waitForTimeout(250)
   check('导入中按钮写已用时间', /导入中/.test(await dlg.getByRole('button', { name: /导入中/ }).innerText().catch(() => '')))
+  const sending = await dlg.locator('[data-upload-progress]').innerText().catch(() => '')
+  check('上传中画真实的字节进度：已传多少 / 总共多少 · 百分比', sending.includes('已传') && sending.includes('40%')
+        && (await dlg.locator('[data-upload-progress] [role="progressbar"]').getAttribute('aria-valuenow').catch(() => '')) === '40',
+        sending.replace(/\s+/g, ' '))
+  check('……字节没发完之前可以取消', await dlg.getByRole('button', { name: '取消上传' }).count() === 1)
+  await shot(page, 'table-uploading')
+  await page.waitForTimeout(650)
+  const processing = await dlg.locator('[data-upload-progress]').innerText().catch(() => '')
+  check('……发完写「正在读表」，不把条拉满冒充完成', processing.includes('正在读表')
+        && await dlg.locator('[data-upload-progress] [role="progressbar"]').count() === 0, processing.replace(/\s+/g, ' '))
+  const cancel = dlg.getByRole('button', { name: '取消', exact: true })
+  check('……发完之后不能取消（后端已经在建表），悬停说明为什么',
+        await cancel.isDisabled() && ((await cancel.getAttribute('title')) ?? '').includes('传完'))
   await page.waitForTimeout(700)
   const res = await dialog(page).innerText()
   check('导入完弹窗不关，停在列名和类型上', res.includes('region') && res.includes('TEXT'))
@@ -490,7 +698,26 @@ console.log('\n=== 数据 · 表格 ===')
   await dialog(page).getByRole('button', { name: /表头不对/ }).click()
   await page.waitForTimeout(200)
   check('改行号重传：回到表单，行号 +1', (await dialog(page).locator('input[type="number"]').inputValue()) === '2')
+  // 这次发到一半取消：后端收不全，什么都不会建
+  await dialog(page).getByRole('button', { name: /导入/ }).click()
+  await page.waitForTimeout(250)
+  await dialog(page).getByRole('button', { name: '取消上传' }).click()
+  await page.waitForTimeout(900)
+  check('发到一半取消：说清什么都没建，弹窗留在表单上', (await page.locator('body').innerText()).includes('没传完就取消了')
+        && await dialog(page).getByRole('button', { name: /导入/ }).isEnabled())
   await dialog(page).getByRole('button', { name: '取消' }).click()
+  await page.waitForTimeout(300)
+  // 结构浏览器的列清单用后端给的结构化列，不再解析 detail 文本
+  const tcard = page.locator('[data-source="sales_demo"]')
+  await tcard.locator('[data-schema-browser] button[aria-expanded]').first().click()
+  await page.waitForTimeout(500)
+  const region = tcard.locator('[data-schema-browser] tbody tr', { hasText: 'region' })
+  const cells = await region.locator('td').allInnerTexts()
+  check('列清单：类型、主键、非空、说明各归各的格子', cells.length === 3 && cells[1] === 'TEXT'
+        && await region.locator('[aria-label="主键"]').count() === 1 && cells[2].includes('非空'), cells.join(' | '))
+  check('……列注释里的两个空格不再把说明切丢（「见附表」还在）', cells[2]?.includes('销售区域') && cells[2]?.includes('见附表'), cells[2] ?? '')
+  check('……表注释写在列表上方', (await tcard.locator('[data-schema-browser]').innerText()).includes('按月的销售明细'))
+  await shot(page, 'table-columns')
   check('没有原生对话框', natives.length === 0, natives.join(' | '))
   check('上传只发了一次', sent.filter((s) => s.key === 'POST /datasources/upload').length === 1)
   await close()
@@ -499,6 +726,7 @@ console.log('\n=== 数据 · 表格 ===')
 console.log('\n=== 知识库 ===')
 {
   const { page, sent, natives, errors, close } = await open('/knowledge/kb', {
+    uploadProgress: true,
     handlers: [[/^POST \/kb\/upload$/, delayed(1200, {
       id: 'fake-doc', collection: 'default', title: 'note.md', source: 'note.md', mime: 'text/markdown',
       chunk_count: 0, status: 'processing', meta: { progress: { done: 1, total: 4 } },
@@ -515,13 +743,34 @@ console.log('\n=== 知识库 ===')
   await page.locator('[data-alpha-off] button', { hasText: '重置' }).click()
   check('一键回到运行时值', Number(await page.locator('input[data-alpha]').inputValue()) === embedding.default_alpha)
 
-  await page.locator('input[data-kb-upload]').setInputFiles({ name: 'note.md', mimeType: 'text/markdown', buffer: Buffer.from('# hi') })
-  await page.waitForTimeout(250)
-  check('上传中列表顶上有占位行', await page.locator('[data-uploading]').count() === 1)
+  // 一次选两份：一次传一个，第二份排队；排队的能取消
+  await page.locator('input[data-kb-upload]').setInputFiles([
+    { name: 'note.md', mimeType: 'text/markdown', buffer: Buffer.from('# hi') },
+    { name: 'more.md', mimeType: 'text/markdown', buffer: Buffer.from('# more') },
+  ])
+  await page.waitForTimeout(300)
+  check('上传中列表顶上有占位行，一份一行', await page.locator('[data-uploading]').count() === 2)
   check('上传按钮写着上传中', (await page.getByRole('button', { name: /上传中/ }).count()) === 1)
+  const first = page.locator('[data-uploading]', { hasText: 'note.md' })
+  const sendingRow = await first.innerText()
+  check('……在传的那份画真实的字节进度', sendingRow.includes('已传') && sendingRow.includes('40%')
+        && await first.locator('[role="progressbar"]').count() === 1, sendingRow.replace(/\s+/g, ' '))
+  const second = page.locator('[data-uploading]', { hasText: 'more.md' })
+  check('……第二份写「排队中」，还能取消', (await second.innerText()).includes('排队中')
+        && await second.getByRole('button', { name: '取消上传 more.md' }).count() === 1)
   await shot(page, 'kb-uploading')
-  await page.waitForTimeout(1300)
+  await second.getByRole('button', { name: '取消上传 more.md' }).click()
+  await page.waitForTimeout(200)
+  check('……排队的取消了立刻从列表拿掉', await page.locator('[data-uploading]', { hasText: 'more.md' }).count() === 0)
+  await page.waitForTimeout(500)
+  const processingRow = await first.innerText()
+  check('……字节发完写「处理中」（后端在解析、切块），不把条拉满冒充完成',
+        processingRow.includes('后端在解析、切块') && await first.locator('[role="progressbar"]').count() === 0,
+        processingRow.replace(/\s+/g, ' '))
+  check('……发完的那份不给取消（后端已经在切块）', await page.getByRole('button', { name: '取消上传 note.md' }).count() === 0)
+  await page.waitForTimeout(1500)
   check('传完占位行消失', await page.locator('[data-uploading]').count() === 0)
+  check('……取消的那份没有发出去', sent.filter((s) => s.key === 'POST /kb/upload').length === 1)
 
   await page.locator('input[data-kb-upload]').setInputFiles({ name: 'data.csv', mimeType: 'text/csv', buffer: Buffer.from('a,b\n1,2') })
   await page.waitForTimeout(300)
@@ -548,6 +797,104 @@ console.log('\n=== 知识库 ===')
   await close()
 }
 
+console.log('\n=== 知识库 · 检索贡献条与重建进度 ===')
+{
+  const hits = {
+    query: '出勤', collection: 'default', degraded: [], alpha: embedding.default_alpha ?? 0.5,
+    results: [
+      { chunk_id: 'c1', document_id: 'd1', title: 'hr_attendance.md', ordinal: 3, content: '出勤率 = 实际出勤 / 计划出勤',
+        score: 0.42, signals: { vector: 0.6, keyword: 3.21 }, contrib: { vector: 0.3, keyword: 0.12 } },
+      { chunk_id: 'c2', document_id: 'd1', title: 'hr_attendance.md', ordinal: 4, content: '计划出勤按排班表算',
+        score: 0.25, signals: { vector: 0.5 }, contrib: { vector: 0.25, keyword: 0 } },
+    ],
+  }
+  const job = (phase, chunks, memories, state = 'running') => ({
+    id: 'check-job', state, phase, collection: 'default', total: 15, done: chunks + memories,
+    chunks: { total: 12, done: chunks }, memories: { total: 3, done: memories },
+    started_at: ago(4000), finished_at: state === 'running' ? null : ago(0), error: null, hint: null,
+    result: state === 'done' ? { reindexed: 12, memories_reindexed: 3, embedder: 'openai:demo-embed' } : null,
+  })
+  // GET /kb/reindex：点重建之前没在跑（开发模式下进页那一眼会问两次）；之后依次是
+  // 片段 → 倒排 → 记忆 → 做完
+  const steps = [job('chunks', 6, 0), job('index', 12, 0), job('memories', 12, 2), job('done', 12, 3, 'done')]
+  let started = false
+  let polled = 0
+  let rebuilt = false
+  const { page, sent, natives, errors, close } = await open('/knowledge/kb', {
+    handlers: [
+      [/^GET \/kb\/search$/, json(hits)],
+      [/^GET \/kb\/embedding$/, (route) => json({ ...embedding, fallback: false, has_semantics: true, unindexed_chunks: 0,
+        stale_chunks: rebuilt ? 0 : 12, stale_memories: rebuilt ? 0 : 3 })(route)],
+      [/^POST \/kb\/reindex$/, (route) => { started = true; return json(job('chunks', 0, 0), 202)(route) }],
+      [/^GET \/kb\/reindex$/, (route) => {
+        if (!started) return json({ state: 'idle' })(route)
+        const out = steps[Math.min(polled++, steps.length - 1)]
+        if (out.state === 'done') rebuilt = true
+        return json(out)(route)
+      }],
+    ],
+  })
+  await page.getByLabel('检索内容').fill('出勤')
+  await page.getByRole('button', { name: '检索', exact: true }).click()
+  await page.waitForTimeout(400)
+  const hit = page.locator('[data-hit]').first()
+  const contrib = await hit.locator('[data-contrib]').innerText().catch(() => '')
+  check('命中拆成两路贡献：语义 +0.300、关键词 +0.120（两段之和就是总分）',
+        /语义\s*\+0\.300/.test(contrib) && /关键词\s*\+0\.120/.test(contrib), contrib.replace(/\s+/g, ' '))
+  check('……原始分另写成数：余弦、BM25', contrib.includes('余弦') && contrib.includes('0.600') && contrib.includes('3.21'))
+  const segs = await hit.locator('span[title^="语义贡献"] > span').count()
+  const segs2 = await page.locator('[data-hit]').nth(1).locator('span[title^="语义贡献"] > span').count()
+  check('……贡献条两段；只靠语义命中的那条只有一段', segs === 2 && segs2 === 1, `${segs} / ${segs2}`)
+  check('……结果上方有图例：总分 = 语义贡献 + 关键词贡献', (await page.locator('[data-contrib-legend]').innerText().catch(() => '')).includes('关键词贡献'))
+  await shot(page, 'kb-search-contrib')
+
+  const rebuild = page.getByRole('button', { name: /重建索引（15 段）/ })
+  check('向量对不上时给「重建索引（15 段）」', await rebuild.count() === 1,
+        (await page.locator('[data-embedder]').innerText().catch(() => '')).replace(/\s+/g, ' ').slice(0, 160))
+  await rebuild.click()
+  const post = sent.find((s) => s.key === 'POST /kb/reindex')
+  check('重建走后台：POST 带 background=true', !!post?.url.includes('background=true'), post?.url ?? '')
+  const chunksText = await until(async () => {
+    const t = await page.locator('[data-reindex="chunks"]').innerText().catch(() => '')
+    return t.includes('6 / 12') ? t : ''
+  }, 4000)
+  check('进度是后端按批记的真实数：正在重算知识片段的向量 · 6 / 12 段', !!chunksText, chunksText)
+  check('……进度条的值就是 done / total', (await page.locator('[data-reindex] [role="progressbar"]').getAttribute('aria-valuenow').catch(() => '')) === '6')
+  check('……跑着的时候不能换向量模型', await page.getByRole('button', { name: '换一个' }).isDisabled())
+  await shot(page, 'kb-reindex-progress')
+  const indexText = await until(() => page.locator('[data-reindex="index"]').innerText().catch(() => ''), 4000)
+  check('倒排那一段没有分批进度：写明，不去假装它在走', indexText.includes('没有分批进度'), indexText.replace(/\s+/g, ' '))
+  const memText = await until(() => page.locator('[data-reindex="memories"]').innerText().catch(() => ''), 4000)
+  check('……接着重算记忆：2 / 3 条', memText.includes('2 / 3 条'), memText.replace(/\s+/g, ' '))
+  const doneToast = await until(async () => {
+    const t = await page.locator('body').innerText()
+    return t.includes('重建 12 段知识') ? t : ''
+  }, 4000)
+  check('做完了报一句：用哪个模型重建了多少', !!doneToast && doneToast.includes('openai:demo-embed') && doneToast.includes('3 条记忆'))
+  check('……进度收起，重建按钮也跟着消失（不再有对不上的）',
+        await page.locator('[data-reindex]').count() === 0 && await page.getByRole('button', { name: /重建索引/ }).count() === 0)
+  check('没有原生对话框', natives.length === 0, natives.join(' | '))
+  check('没有运行时报错', errors.length === 0, errors[0] ?? '')
+  await close()
+
+  // 已经有一次在跑：回 409 就说明，并接着看它的进度，不起第二次
+  let other = false
+  const busy = await open('/knowledge/kb', {
+    handlers: [
+      [/^GET \/kb\/embedding$/, json({ ...embedding, fallback: false, has_semantics: true, unindexed_chunks: 0, stale_chunks: 12, stale_memories: 3 })],
+      [/^POST \/kb\/reindex$/, (route) => { other = true; return json({ detail: '已经在重建索引了（全部集合，已完成 3/15），等它做完再点' }, 409)(route) }],
+      // 进页那一眼还没在跑；点了之后别处起的那一次才露面
+      [/^GET \/kb\/reindex$/, (route) => json(other ? { ...job('chunks', 3, 0), collection: null } : { state: 'idle' })(route)],
+    ],
+  })
+  await busy.page.getByRole('button', { name: /重建索引（15 段）/ }).click()
+  await busy.page.waitForTimeout(600)
+  check('已经在重建：回 409 时说明已经在跑', (await busy.page.locator('body').innerText()).includes('已经在重建索引了'))
+  check('……接着显示那一次的进度', ((await busy.page.locator('[data-reindex]').innerText().catch(() => '')).includes('3 / 12')))
+  check('……只发了一次 POST，不起第二次', busy.sent.filter((s) => s.key === 'POST /kb/reindex').length === 1)
+  await busy.close()
+}
+
 console.log('\n=== 长期记忆 ===')
 {
   const withRun = memories.find((m) => m.source?.kind === 'run' && m.source?.run_exists)
@@ -607,6 +954,20 @@ console.log('\n=== 长期记忆 ===')
   await close()
 }
 
+console.log('\n=== 目录没取回来：空态不冒充「还没有」 ===')
+for (const [path, pattern, label] of [
+  ['/settings/providers', /^GET \/providers$/, '模型接入'],
+  ['/knowledge/skills', /^GET \/skills$/, 'Skill'],
+]) {
+  const { page, close } = await open(path, { handlers: [[pattern, json({ detail: '后端出错了' }, 500)]] })
+  await page.waitForTimeout(600)
+  const el = page.locator('main [data-empty-unknown]')
+  check(`${label}那张表没取回来：不说「还没有」，说没取回来并给「重新读取」`,
+        (await el.getAttribute('data-empty-unknown').catch(() => null)) === 'error' && (await el.innerText().catch(() => '')).includes('重新读取'))
+  check('……收起「添加 / 新建」这类动作，免得照着建出重复的', await el.getByRole('button', { name: /添加接入|新建 Skill/ }).count() === 0)
+  await close()
+}
+
 console.log('\n=== Skill ===')
 {
   const { page, sent, natives, close } = await open('/knowledge/skills', {
@@ -637,10 +998,23 @@ console.log('\n=== 工具 ===')
       [/^POST \/tools\/[^/]+\/run$/, (route, { body }) => {
         calls++
         return body?.confirm
-          ? json({ ok: true, result: 'done', duration_ms: 5 })(route)
+          ? json({ ok: true, result: 'done', duration_ms: 5, note: '参数名 cuont 不存在，已按唯一候选 count 执行' })(route)
           : json({ detail: '会在 playground 工作目录里写入「x.txt」，同名文件会被覆盖。在工具库里执行不经过审批，确认后才会执行。' }, 409)(route)
       }],
       [/^POST \/mcp\/refresh$/, (route) => route.abort()],
+      [/^POST \/custom-tools\/test$/, (route, { body }) => json(body?.config?.url?.includes('fail')
+        ? { ok: false, error: '工具执行失败：HTTP 404', hint: '核对接口地址', detail: '', duration_ms: 12 }
+        : { ok: true, result: { echo: body?.args ?? {} }, duration_ms: 34, note: '参数名 qurey 不存在，已按唯一候选 query 执行' })(route)],
+      // 沙箱里没有 MCP 服务：两台假的，一台后端记着 5 分钟前连上过，一台老数据只有 status、没有测连接记录
+      [/^GET \/mcp\/servers$/, json([
+        { id: 'check-mcp-ok', name: 'files_demo', transport: 'stdio', command: 'npx', args: ['-y', 'demo-mcp'], env: {}, url: null,
+          enabled: true, status: 'ok', last_error: null, tools_cache: ['read', 'list'],
+          last_checked_at: ago(5 * 60_000), last_check_ok: true, last_latency_ms: 88 },
+        { id: 'check-mcp-old', name: 'legacy_demo', transport: 'http', command: null, args: [], env: {}, url: 'https://example.com/mcp',
+          enabled: true, status: 'error', last_error: '连不上', tools_cache: [],
+          last_checked_at: null, last_check_ok: null, last_latency_ms: null },
+      ])],
+      [/^POST \/mcp\/servers\/check-mcp-ok\/probe$/, delayed(200, { ok: true, tools: [{ name: 'read' }, { name: 'list' }, { name: 'write' }], elapsed_ms: 120 })],
     ],
   })
   if (danger) {
@@ -661,17 +1035,52 @@ console.log('\n=== 工具 ===')
     const runs = sent.filter((s) => /^POST \/tools\/.+\/run$/.test(s.key))
     check('确认后带 confirm:true 重发', runs.length === 2 && runs[1].body?.confirm === true, JSON.stringify(runs.map((r) => r.body?.confirm)))
     check('结果显示成功', (await page.locator('[data-tool-result]').getAttribute('data-tool-result')) === 'ok')
+    const note = await page.locator('[data-tool-note]').innerText().catch(() => '')
+    check('参数名被纠正过：成功结果下面用 warn 写出来，提醒先改对再抄进工作流', note.includes('cuont') && note.includes('改对'), note)
   }
   await page.getByRole('tab', { name: '自定义工具' }).click()
   await page.waitForTimeout(400)
   await page.getByRole('button', { name: /新建工具/ }).first().click()
-  const params = await dialog(page).locator('textarea').nth(1).inputValue()
+  const ed = dialog(page)
+  const params = await ed.locator('textarea').nth(1).inputValue()
   check('新建工具的参数给了能跑的示例，不是 {}', params.includes('"query"'), params.slice(0, 60))
-  check('编辑器里有试跑区（保存后可用）', (await dialog(page).locator('[data-tool-trial]').innerText()).includes('先保存'))
-  await dialog(page).getByRole('button', { name: '取消' }).click()
+  const trialBox = ed.locator('[data-tool-trial]')
+  check('新建时不用先保存就能试跑', (await trialBox.innerText()).includes('不用先保存'))
+  const tryBtn = trialBox.getByRole('button', { name: /试跑/ }).last()
+  check('……URL 还没填时试跑不可点，悬停说缺什么', await tryBtn.isDisabled() && ((await tryBtn.getAttribute('title')) ?? '').includes('URL'))
+  await ed.getByLabel(/^URL/).fill('https://api.example.com/search?q={{ query }}')
+  await tryBtn.click()
+  await page.waitForTimeout(400)
+  const draft = sent.filter((s) => s.key === 'POST /custom-tools/test').at(-1)
+  check('……试跑的是眼前这份没保存的配置（POST /custom-tools/test）',
+        draft?.body?.kind === 'http' && draft?.body?.config?.url?.includes('api.example.com') && 'query' in (draft?.body?.parameters?.properties ?? {})
+        && 'args' in (draft?.body ?? {}), JSON.stringify(draft?.body ?? {}).slice(0, 160))
+  check('……没有保存（没发 POST /custom-tools）', !sent.some((s) => s.key === 'POST /custom-tools'))
+  const trialNote = await trialBox.locator('[data-tool-note]').innerText().catch(() => '')
+  check('……试跑结果里参数名被纠正过也写出来', trialNote.includes('qurey'), trialNote)
+  await shot(page, 'custom-tool-trial')
+  await ed.getByLabel(/^URL/).fill('https://api.example.com/fail')
+  check('……改了配置，刚才的结果标成旧的', (await trialBox.innerText()).includes('这是改之前的结果'))
+  await tryBtn.click()
+  await page.waitForTimeout(400)
+  check('……失败：原因和怎么办写在试跑区', (await trialBox.innerText()).includes('HTTP 404') && (await trialBox.innerText()).includes('核对接口地址'))
+  await ed.getByRole('button', { name: '取消' }).click()
+  await page.waitForTimeout(200)
+  const discard = dialog(page).getByRole('button', { name: '放弃修改' })
+  if (await discard.count()) await discard.click()
 
   await page.getByRole('tab', { name: 'MCP 接入' }).click()
   await page.waitForTimeout(400)
+  const okCard = page.locator('article', { hasText: 'files_demo' })
+  const okPill = await okCard.locator('[data-health]').innerText().catch(() => '')
+  check('MCP 卡片初值是后端记着的上次探测：已连通 · 88 ms · 5 分钟前测', /已连通.*88 ms.*5 分钟前测/.test(okPill), okPill)
+  check('……只有 status、没有测连接记录的老数据写「未测试」，不再拿 status 猜',
+        (await page.locator('article', { hasText: 'legacy_demo' }).locator('[data-health]').getAttribute('data-health')) === 'idle')
+  await okCard.getByRole('button', { name: /测试/ }).click()
+  await page.waitForTimeout(500)
+  const probed = await okCard.locator('[data-health]').innerText()
+  check('……测一次：用后端量的耗时（120 ms），不是往返时间', /已连通.*120 ms.*刚测过/.test(probed), probed)
+  await shot(page, 'mcp-health')
   await page.getByRole('button', { name: /重新加载/ }).click()
   await page.waitForTimeout(700)
   check('写操作失败有 error toast（以前一声不响）', await page.locator('[role="alert"][aria-live="assertive"] > *').count() > 0)
diff --git a/scripts/check-run-states.mjs b/scripts/check-run-states.mjs
index 5598e817..bc8b0205 100644
--- a/scripts/check-run-states.mjs
+++ b/scripts/check-run-states.mjs
@@ -14,6 +14,9 @@
 //   这些推导状态和循环容器「两轮之间」也按那一刻算
 // - 协作矩阵的表头不和底部打架：并行的一轮交回一部分、全部交回等调度时都不说「串行」
 // - 去审批浮层键盘可达；出口密的分支节点标签不压别人的线；精简档读数够大
+// - 收场要说人话：协作团队用完轮数（判失败 / 降档交付）写清「用完 N 轮未完成」、点出
+//   一次都没被派到的成员，收尾判定不另算一轮；模型把工具调用写成文字的失败写原因，
+//   不是半句原话；工具超出后端声明的时限直说「已超出 Ns 上限」；校验靠修复才过要提一句
 //
 // 用法：AGENTLAB_WEB=http://localhost:5373 AGENTLAB_API=http://localhost:8100/api node scripts/check-run-states.mjs
 // 截图落在 RUN_STATES_SHOTS（默认 /tmp/agentlab-run-states）。
@@ -25,8 +28,10 @@ const API = process.env.AGENTLAB_API ?? 'http://localhost:8000/api'
 const CHROME = process.env.CHROME_PATH
   ?? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'
 const SHOTS = process.env.RUN_STATES_SHOTS ?? '/tmp/agentlab-run-states'
+// 截图的像素密度：要看清卡片里 11px 的字时设成 2
+const DSF = Number(process.env.RUN_STATES_DSF ?? 1) || 1
 mkdirSync(SHOTS, { recursive: true })
-// 只跑其中几段（逗号分隔：themes, interact, team, replay, history, reduced, exits），调样式时省时间
+// 只跑其中几段（逗号分隔：themes, interact, team, endings, replay, history, reduced, exits），调样式时省时间
 const ONLY = (process.env.RUN_STATES_ONLY ?? '').split(',').filter(Boolean)
 const want = (part) => !ONLY.length || ONLY.includes(part)
 
@@ -237,6 +242,7 @@ async function open({ theme = 'dark', reduced = false, workflow = WORKFLOW } = {
   const browser = await chromium.launch({ executablePath: CHROME })
   const ctx = await browser.newContext({
     viewport: { width: 1440, height: 900 },
+    deviceScaleFactor: DSF,
     colorScheme: theme,
     reducedMotion: reduced ? 'reduce' : 'no-preference',
   })
@@ -372,6 +378,20 @@ async function shot(page, name) {
   return path
 }
 
+/** 只截几张卡（外扩一圈）：看卡片里的字用，整张画布截图里它们太小 */
+async function cardShot(page, ids, name) {
+  const boxes = (await Promise.all(ids.map((id) => page.locator(`.react-flow__node[data-id="${id}"]`).boundingBox())))
+    .filter(Boolean)
+  if (!boxes.length) return null
+  const x = Math.min(...boxes.map((b) => b.x)) - 16
+  const y = Math.min(...boxes.map((b) => b.y)) - 16
+  const w = Math.max(...boxes.map((b) => b.x + b.width)) + 16 - x
+  const h = Math.max(...boxes.map((b) => b.y + b.height)) + 16 - y
+  const path = `${SHOTS}/${name}.png`
+  await page.screenshot({ path, clip: { x: Math.max(0, x), y: Math.max(0, y), width: w, height: h } })
+  return path
+}
+
 const SCENARIOS = [
   { key: 'live', events: LIVE, expect: { team: 'running', loop: 'running', body: 'running', join: 'queued', skip: 'skipped', gate: 'idle', in: 'done' } },
   { key: 'waiting', events: WAITING, expect: { human: 'waiting', body: 'done', loop: 'done', team: 'done', out: 'idle' } },
@@ -717,10 +737,32 @@ if (want('interact')) {
   const stampInfo = await stamp.evaluate((el) => ({
     tag: el.tagName, role: el.getAttribute('role'), tab: el.tabIndex, cursor: getComputedStyle(el).cursor, title: el.title,
   })).catch(() => null)
-  // 右栏还没有可以滚过去的出具横幅：它是一枚章，不装作能点
-  check('印章不是个点了没反应的按钮', !!stampInfo && stampInfo.tag !== 'BUTTON' && stampInfo.role === 'img'
+  // 它是一枚章，不是按钮：不进 Tab 序列，悬停前没有手形
+  check('印章不是个按钮', !!stampInfo && stampInfo.tag !== 'BUTTON' && stampInfo.role === 'img'
     && stampInfo.tab < 0 && stampInfo.cursor !== 'pointer', JSON.stringify(stampInfo && { ...stampInfo, title: undefined }))
   check('印章悬停写出「校验没跑全」', (stampInfo?.title ?? '').includes('校验没跑全：指标集为空'), (stampInfo?.title ?? '').split('\n').join(' / '))
+  // 右栏看得见时点它是去看完整判定的捷径：广播 agentlab:goto-issuance，右栏在对话层时自己切过去
+  await page.evaluate(() => {
+    window.__issuance = []
+    window.addEventListener('agentlab:goto-issuance', (e) => window.__issuance.push(e.detail))
+  })
+  await stamp.hover()
+  const cursor = await stamp.evaluate((el) => getComputedStyle(el).cursor)
+  await stamp.click()
+  const went = await page.evaluate(() => window.__issuance)
+  check('右栏看得见：悬停成了链接，点它请右栏摆出出具横幅', cursor === 'pointer' && went.length === 1 && went[0].runId === RUN_ID,
+    `${cursor} · ${JSON.stringify(went)}`)
+  // 回指明细带口径（issuance.matched[].caliber）：同一个指标换过口径，看得出这次按的是哪一版
+  await page.evaluate(() => {
+    const st = window.__studio
+    const out = st.getState().run.output
+    st.setState({ run: { ...st.getState().run, output: { ...out, _issuance: { ...out._issuance,
+      matched: [{ token: '12.4%', metric: '毛利率', caliber: '月度口径 @ v2' }, { token: '1,204', metric: '订单数' }] } } } })
+  })
+  await page.waitForTimeout(150)
+  const matchedTitle = await stamp.getAttribute('title')
+  check('印章悬停列出回指明细和口径', (matchedTitle ?? '').includes('12.4% → 毛利率（月度口径 @ v2）')
+    && (matchedTitle ?? '').includes('1,204 → 订单数'), (matchedTitle ?? '').split('\n').join(' / '))
   check('运行结束后端口恢复可连', await page.evaluate(() =>
     document.querySelector('.react-flow__node[data-id="gate"] .react-flow__handle')?.classList.contains('connectable')))
   // 探索运行进行中也不能连线：端口跟着 React Flow 的 connectable 走
@@ -787,6 +829,371 @@ if (want('team')) {
   await browser.close()
 }
 
+// ---------------------------------------------------------------- 收场：用完轮数、写成文字的工具调用、超时
+
+if (want('endings')) {
+  // 一张小图：协作团队两轮上限、三个成员（「定稿员」一次都派不到）；一个 agent 节点把
+  // 工具调用写成了文字；一个工具节点查询超时；一个校验节点靠修复才过
+  const graph = await (await fetch(`${API}/copilot/layout`, {
+    method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ graph: {
+      nodes: [
+        { id: 'in', type: 'input', data: { label: '入口', config: { fields: [{ name: 'week' }] } } },
+        { id: 'team', type: 'supervisor', data: { label: '复盘小组', config: {
+          goal: '汇总本周订单异常', max_rounds: 2, max_parallel: 2,
+          agents: [agent('检索员', '拉订单明细'), agent('分析员', '找异常原因'), agent('定稿员', '写结论')],
+        } } },
+        { id: 'ask', type: 'agent', data: { label: '订单查询', config: { prompt: '查 orders 本周异常', tools: ['db_query__shop'] } } },
+        { id: 'q', type: 'tool', data: { label: '取订单', config: { tool: 'db_query__shop' } } },
+        { id: 'chk', type: 'validate', data: { label: '结构校验', config: { repair_with_llm: true, max_retries: 2 } } },
+        { id: 'out', type: 'output', data: { label: '周报', config: { fields: [{ name: 'report' }] } } },
+      ],
+      edges: [
+        { source: 'in', target: 'team' }, { source: 'in', target: 'ask' }, { source: 'in', target: 'q' },
+        { source: 'q', target: 'chk' }, { source: 'team', target: 'out' }, { source: 'ask', target: 'out' },
+        { source: 'chk', target: 'out' },
+      ],
+    } }),
+  })).json()
+  const workflow = { ...WORKFLOW, id: 'wcard-endings', name: '__endings__', graph }
+
+  const MARKUP = '模型输出了工具调用的原始标记，但没有真正调用工具。常见原因：节点没有绑定工具，或者模型、服务不支持工具调用。'
+  const EXHAUSTED = '协作团队用完 2 轮仍未完成：还没有定稿。一次都没被派到的成员：定稿员。先看成员有没有绑定要用的工具，再调大「最多轮数」；也可以把「用完轮数时」改成降档交付'
+  const START = [
+    [0, 'run.started', null, { nodes: 6 }],
+    [0.1, 'node.started', 'in', {}],
+    [0.05, 'node.finished', 'in', { duration_ms: 3, preview: { week: '2026-W39' } }],
+  ]
+  // 两轮都派了、调度者始终没说完成；第一轮的检索员把工具调用写成了文字，这一步记失败
+  const ROUNDS = [
+    [0.05, 'node.started', 'team', {}],
+    [0.02, 'agent.route.start', 'team', { round: 0 }],
+    [1.2, 'agent.route.end', 'team', { round: 0, duration_ms: 1200, agents: ['检索员'], parallel: 1, done: false, reason: '先拉订单明细' }],
+    [0.02, 'agent.step.start', 'team', { agent: '检索员', instruction: '拉本周订单', round: 0, parallel: 1 }],
+    [2.0, 'agent.step.end', 'team', { agent: '检索员', duration_ms: 2000, round: 0, parallel: 1, preview: '<tool_call>{"name": "db_query__shop"}</tool_call>',
+      failed: true, error: '模型输出了工具调用的原始标记，但没有真正调用工具' }],
+    [0.02, 'agent.route.start', 'team', { round: 1 }],
+    [1.0, 'agent.route.end', 'team', { round: 1, duration_ms: 1000, agents: ['分析员'], parallel: 1, done: false, reason: '换人分析' }],
+    [0.02, 'agent.step.start', 'team', { agent: '分析员', instruction: '找异常原因', round: 1, parallel: 1 }],
+    [1.5, 'agent.step.end', 'team', { agent: '分析员', duration_ms: 1500, round: 1, parallel: 1, preview: '缺数据，无法判断' }],
+  ]
+  // 轮数用完之后的收尾判定：只判定、不派活，round 是上限（从 0 数就是「第 3 轮」）
+  const closing = (done, reason) => [
+    [0.02, 'agent.route.start', 'team', { round: 2, closing: true }],
+    [0.9, 'agent.route.end', 'team', { round: 2, closing: true, duration_ms: 900, agents: [], parallel: 0, done, reason }],
+    [0.05, 'llm.end', 'team', { agent: '调度者', model: 'm', input_tokens: 900, output_tokens: 120, cost_usd: 0.001 }],
+  ]
+  const FAIL = script([...START,
+    [0.02, 'node.started', 'ask', {}],
+    ...ROUNDS, ...closing(false, '还没有定稿'),
+    [0.02, 'log', 'ask', { level: 'warn', code: 'tool_markup_leak', message: '模型输出了工具调用的原始标记，但没有真正调用工具' }],
+    [0.02, 'node.failed', 'ask', { duration_ms: 6800, error: MARKUP }],
+    [0.05, 'node.failed', 'team', { duration_ms: 6800, error: EXHAUSTED }],
+    [0.05, 'run.failed', null, { error: '「复盘小组」失败', node_id: 'team', timing: { wall_ms: 7000, active_ms: 7000, wait_ms: 0 } }],
+  ])
+  const DEGRADE = script([...START,
+    [0.02, 'node.started', 'ask', {}],
+    // 第一次查询超出声明的 2s 时限被放弃，第二次查到了；收尾时模型还想要工具
+    [0.05, 'tool.start', 'ask', { tool: 'db_query__shop', call_id: 'c1', timeout_s: 2 }],
+    [3.0, 'tool.error', 'ask', { tool: 'db_query__shop', call_id: 'c1', duration_ms: 3000, timed_out: true, error: '查询超过 2s 没有返回，已放弃等待' }],
+    [0.05, 'tool.start', 'ask', { tool: 'db_query__shop', call_id: 'c2', timeout_s: 2 }],
+    [0.4, 'tool.end', 'ask', { tool: 'db_query__shop', call_id: 'c2', duration_ms: 400, preview: '{"row_count": 12}' }],
+    [0.1, 'log', 'ask', { level: 'warn', code: 'tool_markup_leak', message: '收尾轮仍想调用工具：步数用完了' }],
+    [0.05, 'llm.end', 'ask', { agent: '订单查询', model: 'm', input_tokens: 1200, output_tokens: 300, cost_usd: 0.002 }],
+    [0.02, 'node.finished', 'ask', { duration_ms: 3700, preview: { text: '本周异常 12 单' } }],
+    [0.02, 'node.started', 'q', {}],
+    [0.02, 'tool.start', 'q', { tool: 'db_query__shop', call_id: 'c3', timeout_s: 30 }],
+    [0.3, 'tool.end', 'q', { tool: 'db_query__shop', call_id: 'c3', duration_ms: 300, preview: '{"row_count": 12}' }],
+    [0.02, 'node.finished', 'q', { duration_ms: 320, preview: { row_count: 12 } }],
+    [0.02, 'node.started', 'chk', {}],
+    [0.4, 'llm.end', 'chk', { model: 'm', purpose: 'repair', duration_ms: 400, input_tokens: 300, output_tokens: 40, cost_usd: 0.0005, calls: 1 }],
+    [0.02, 'log', 'chk', { level: 'warn', code: 'repair_invented', message: '修复时出现了原文没有的值：total_count=0' }],
+    [0.4, 'llm.end', 'chk', { model: 'm', purpose: 'repair', duration_ms: 400, input_tokens: 300, output_tokens: 40, cost_usd: 0.0005, calls: 1 }],
+    [0.02, 'node.finished', 'chk', { duration_ms: 850, preview: { total_count: 12 } }],
+    ...ROUNDS, ...closing(false, '还没有定稿'),
+    [0.02, 'log', 'team', { level: 'warn', code: 'team_exhausted', message: '协作团队用完 2 轮仍未完成：还没有定稿。一次都没被派到的成员：定稿员。按降档交付' }],
+    [0.02, 'node.finished', 'team', { duration_ms: 6800, preview: { exhausted: true, exhausted_reason: '还没有定稿', never_dispatched: '[1 项]', text: '缺数据，无法判断' } }],
+    [0.05, 'node.started', 'out', {}],
+    [0.05, 'node.finished', 'out', { duration_ms: 4, preview: { report: '…' } }],
+    [0.05, 'run.finished', null, { output: {}, usage: {}, duration_ms: 9000, timing: { wall_ms: 9000, active_ms: 9000, wait_ms: 0 } }],
+  ])
+  // 进行中：收尾判定还没出结论；工具节点的查询已经超出声明的 2s
+  const LIVE_JUDGING = script([...START,
+    ...ROUNDS,
+    [0.02, 'agent.route.start', 'team', { round: 2, closing: true }],
+    [0.02, 'node.started', 'q', {}],
+    [0.02, 'tool.start', 'q', { tool: 'db_query__shop', call_id: 'c9', timeout_s: 2 }],
+    [3.2, 'log', null, { level: 'info', message: '心跳' }],
+  ])
+  // 收尾判定说完成了：正常交付，表头说清是轮数用完之后判的，不点名谁没被派到
+  const CLOSED_OK = script([...START,
+    ...ROUNDS, ...closing(true, '材料够了，可以收尾'),
+    [0.05, 'node.finished', 'team', { duration_ms: 6800, preview: { text: '结论：…' } }],
+    [0.05, 'run.finished', null, { output: {}, usage: {}, duration_ms: 7000, timing: { wall_ms: 7000, active_ms: 7000, wait_ms: 0 } }],
+  ])
+  const askLlm = (out) => [0.05, 'llm.end', 'ask', { agent: '订单查询', model: 'm', input_tokens: 600, output_tokens: out, cost_usd: 0.001 }]
+  // 同一个节点执行两次：第一次的收场不能挂到第二次上。团队用完轮数判失败 → 调大轮数
+  // 接着跑（后端给失败的节点标 resumed，但这是重新执行；前两轮在断点里，不重发）→ 派到
+  // 定稿员、调度者判完成。agent 第一次收尾时还想调工具，第二次（循环体每一轮也是这样）干干净净
+  const RERUN = script([...START,
+    [0.02, 'node.started', 'ask', {}],
+    [0.3, 'log', 'ask', { level: 'warn', code: 'tool_markup_leak',
+      message: '模型把工具调用写成了文字（<tool_call>{"name": "db_query__shop"…），没有真正调用工具：步数用完后的收尾轮仍想调用工具，没能给出结论' }],
+    askLlm(300),
+    [0.02, 'node.finished', 'ask', { duration_ms: 400, preview: { text: '本周异常 12 单' } }],
+    ...ROUNDS, ...closing(false, '还没有定稿'),
+    [0.05, 'node.failed', 'team', { duration_ms: 6800, error: EXHAUSTED }],
+    [0.05, 'run.failed', null, { error: '「复盘小组」失败', node_id: 'team', timing: { wall_ms: 7000, active_ms: 7000, wait_ms: 0 } }],
+    [2.0, 'run.resumed', null, { from: ['team'], message: '从「复盘小组」接着跑，前面 2 个节点的结果保留' }],
+    [0.02, 'run.started', null, { nodes: 6, resumed: true }],
+    [0.05, 'node.started', 'team', { resumed: true }],
+    [0.02, 'agent.route.start', 'team', { round: 2 }],
+    [0.8, 'agent.route.end', 'team', { round: 2, duration_ms: 800, agents: ['定稿员'], parallel: 1, done: false, reason: '派定稿员写结论' }],
+    [0.02, 'agent.step.start', 'team', { agent: '定稿员', instruction: '写结论', round: 2, parallel: 1 }],
+    [1.2, 'agent.step.end', 'team', { agent: '定稿员', duration_ms: 1200, round: 2, parallel: 1, preview: '结论：…' }],
+    [0.02, 'agent.route.start', 'team', { round: 3 }],
+    [0.6, 'agent.route.end', 'team', { round: 3, duration_ms: 600, agents: [], parallel: 0, done: true, reason: '已经定稿' }],
+    [0.05, 'node.finished', 'team', { duration_ms: 2700, preview: { text: '结论：…' } }],
+    [0.05, 'node.started', 'ask', {}],
+    askLlm(240),
+    [0.3, 'node.finished', 'ask', { duration_ms: 320, preview: { text: '本周异常 9 单' } }],
+    [0.05, 'node.started', 'out', {}],
+    [0.05, 'node.finished', 'out', { duration_ms: 4, preview: { report: '…' } }],
+    [0.05, 'run.finished', null, { output: {}, usage: {}, duration_ms: 12000, timing: { wall_ms: 12000, active_ms: 10000, wait_ms: 0 } }],
+  ])
+  // 写成文字、被提醒之后重答了：成果是重答的那一次，不是「收尾时仍想调用工具」那种不完整。
+  // 团队里检索员提醒后重答了；分析员提醒后还这样，这一步记失败，不能算进「纠正过」
+  const NUDGE = script([...START,
+    [0.02, 'node.started', 'ask', {}],
+    [0.3, 'log', 'ask', { level: 'warn', code: 'tool_markup_leak',
+      message: '模型把工具调用写成了文字（<tool_call>{"name": "db_query__shop"…），没有真正调用工具，已提醒它重试一次' }],
+    [0.02, 'tool.start', 'ask', { tool: 'db_query__shop', call_id: 'n1', timeout_s: 30 }],
+    [0.3, 'tool.end', 'ask', { tool: 'db_query__shop', call_id: 'n1', duration_ms: 300, preview: '{"row_count": 12}' }],
+    askLlm(280),
+    [0.02, 'node.finished', 'ask', { duration_ms: 700, preview: { text: '本周异常 12 单' } }],
+    [0.02, 'node.started', 'team', {}],
+    [0.02, 'agent.route.start', 'team', { round: 0 }],
+    [0.8, 'agent.route.end', 'team', { round: 0, duration_ms: 800, agents: ['检索员', '分析员'], parallel: 2, done: false, reason: '先拉明细、再找原因' }],
+    [0.02, 'agent.step.start', 'team', { agent: '检索员', instruction: '拉本周订单', round: 0, parallel: 2 }],
+    [0.01, 'agent.step.start', 'team', { agent: '分析员', instruction: '找异常原因', round: 0, parallel: 2 }],
+    [0.4, 'log', 'team', { level: 'warn', code: 'tool_markup_leak',
+      message: '检索员把工具调用写成了文字（<tool_call>{"name": "db_query__shop"…），没有真正调用工具，已提醒它重试一次' }],
+    [0.2, 'log', 'team', { level: 'warn', code: 'tool_markup_leak',
+      message: '分析员把工具调用写成了文字（<tool_call>{"name": "db_query__shop"…），没有真正调用工具，已提醒它重试一次' }],
+    [0.6, 'agent.step.end', 'team', { agent: '检索员', duration_ms: 1200, round: 0, parallel: 2, preview: '拉到 12 单' }],
+    [0.3, 'agent.step.end', 'team', { agent: '分析员', duration_ms: 1500, round: 0, parallel: 2, preview: '',
+      failed: true, error: '模型输出了工具调用的原始标记，但没有真正调用工具，这一步什么都没查到' }],
+    [0.02, 'agent.route.start', 'team', { round: 1 }],
+    [0.6, 'agent.route.end', 'team', { round: 1, duration_ms: 600, agents: [], parallel: 0, done: true, reason: '明细够了' }],
+    [0.05, 'node.finished', 'team', { duration_ms: 2500, preview: { text: '结论：…' } }],
+    [0.05, 'run.finished', null, { output: {}, usage: {}, duration_ms: 3500, timing: { wall_ms: 3500, active_ms: 3500, wait_ms: 0 } }],
+  ])
+  /** 改团队节点的配置（运行之后调过「最多轮数」、或者压根没配）。值给 null 就是删掉这一项 */
+  const setTeamConfig = (page, patch) => page.evaluate((patch) => {
+    const st = window.__studio
+    const node = st.getState().nodes.find((n) => n.id === 'team')
+    const config = { ...node.data.config, ...patch }
+    for (const [k, v] of Object.entries(patch)) if (v === null) delete config[k]
+    st.setState({ nodes: st.getState().nodes.map((n) => (n.id === 'team' ? { ...n, data: { ...n.data, config } } : n)) })
+  }, patch)
+
+  const at = (page, id) => page.locator(`.react-flow__node[data-id="${id}"]`)
+  const flat = (t) => (t ?? '').replace(/\s+/g, ' ').trim()
+  const matrixOf = (page) => page.evaluate(() => {
+    const m = document.querySelector('.react-flow__node[data-id="team"] .team-matrix')
+    const right = m?.querySelector('.team-head-right')
+    const row = (name) => [...(m?.querySelectorAll('.team-row') ?? [])].find((r) => r.textContent.includes(name))
+    const member = (name) => {
+      const r = row(name)
+      return r ? { status: r.dataset.memberStatus, text: r.innerText.replace(/\s+/g, ' ').trim(), title: r.title } : null
+    }
+    return {
+      head: (m?.querySelector('.team-head')?.textContent ?? '').replace(/\s+/g, ' ').trim(),
+      headTitle: m?.querySelector('.team-head')?.getAttribute('title') ?? '',
+      right: right?.textContent ?? '', tone: right?.classList.contains('is-err') ? 'err' : right?.classList.contains('is-warn') ? 'warn' : '',
+      dispatch: (m?.querySelector('.team-row-dispatch')?.textContent ?? '').replace(/\s+/g, ' ').trim(),
+      a: member('检索员'), b: member('分析员'), c: member('定稿员'),
+    }
+  })
+  const note = (page, id) => page.evaluate((id) => {
+    const el = document.querySelector(`.react-flow__node[data-id="${id}"] .nc-tele-note`)
+    return el ? { text: el.textContent.trim(), title: el.title, warn: el.classList.contains('is-warn') } : null
+  }, id)
+
+  for (const theme of ['dark', 'light']) {
+    console.log(`\n=== ${theme === 'dark' ? '暗色' : '亮色'}：收场说人话（用完轮数、工具调用写成文字、超时、修复） ===`)
+    const { browser, page, errors } = await open({ theme, workflow })
+    await setLod(page, 'full')
+    const base = Object.fromEntries(Object.entries(await cards(page)).map(([id, c]) => [id, c.h]))
+
+    // ---- 判失败：用完轮数（默认）
+    await feed(page, FAIL(Date.now()))
+    await page.waitForTimeout(900)
+    let c = await cards(page)
+    let m = await matrixOf(page)
+    const teamNote = await note(page, 'team')
+    check(`${theme}: 团队用完轮数判失败，卡片写「用完 2 轮仍未完成」`, c.team.state === 'failed'
+      && teamNote?.text === '协作团队用完 2 轮仍未完成', JSON.stringify(teamNote?.text))
+    check(`${theme}: 悬停写清理由和怎么办`, (teamNote?.title ?? '').includes('还没有定稿') && (teamNote?.title ?? '').includes('怎么办'),
+      flat(teamNote?.title))
+    check(`${theme}: 收尾判定不另算一轮（表头仍是第 2 轮 / 上限 2）`, m.head.startsWith('第 2 轮 / 上限 2'), m.head)
+    check(`${theme}: 表头说「用完 2 轮 · 未完成」，失败上红`, m.right === '用完 2 轮 · 未完成' && m.tone === 'err', `${m.right} · ${m.tone}`)
+    check(`${theme}: 调度者那一行写「收尾判定」`, m.dispatch.includes('收尾判定'), m.dispatch)
+    check(`${theme}: 一次都没被派到的成员点出来`, m.c?.status === 'never' && m.c.text.includes('未派到')
+      && m.headTitle.includes('一次都没被派到：定稿员'), JSON.stringify(m.c))
+    check(`${theme}: 成员把工具调用写成文字：格子是失败，悬停写原因`, m.a?.status === 'failed'
+      && (m.a.title ?? '').includes('原因：模型输出了工具调用的原始标记'), JSON.stringify(m.a))
+    const askNote = await note(page, 'ask')
+    check(`${theme}: agent 把工具调用写成文字而失败：卡片写原因，不是半句原话`, c.ask.state === 'failed'
+      && askNote?.text === '模型没有真正调用工具' && (askNote?.title ?? '').includes('怎么办'), JSON.stringify(askNote))
+    const grew = Object.entries(c).filter(([id, x]) => x.h !== base[id])
+    check(`${theme}: 失败收场不撑高卡片`, grew.length === 0, grew.map(([id, x]) => `${id} ${base[id]}→${x.h}`).join(', '))
+    shots.push(await shot(page, `${theme}-endings-failed`), await cardShot(page, ['team', 'ask'], `${theme}-endings-failed-cards`))
+
+    // ---- 降档交付、收尾时还想调工具、查询超时、修复才过
+    await feed(page, DEGRADE(Date.now()))
+    await page.waitForTimeout(900)
+    c = await cards(page)
+    m = await matrixOf(page)
+    const degr = await note(page, 'team')
+    const chip = await at(page, 'team').locator('.nc-head .nc-chip-warn', { hasText: '降档' }).count()
+    check(`${theme}: 降档交付：卡片写「用完 2 轮未完成 · 降档交付」，琥珀色、带「降档」标`, c.team.state === 'done'
+      && degr?.text === '用完 2 轮未完成 · 降档交付' && degr.warn && chip === 1, JSON.stringify({ degr, chip }))
+    check(`${theme}: 降档交付：表头琥珀、点出没被派到的成员`, m.right === '用完 2 轮 · 未完成' && m.tone === 'warn'
+      && m.c?.status === 'never', `${m.right} · ${m.tone} · ${m.c?.status}`)
+    const askDone = await note(page, 'ask')
+    check(`${theme}: 收尾时还想调工具：跑完了但琥珀色提一句`, c.ask.state === 'done' && askDone?.text === '收尾时仍想调用工具' && askDone.warn,
+      JSON.stringify(askDone))
+    const tools = await at(page, 'ask').locator('.nc-tools').evaluate((el) => ({ bad: el.classList.contains('is-bad'), title: el.title }))
+      .catch(() => null)
+    check(`${theme}: 超时的那次调用算失败，悬停写「超时（上限 2s）」`, !!tools?.bad && tools.title.includes('超时（上限 2s）'), JSON.stringify(tools))
+    const chkNote = await note(page, 'chk')
+    check(`${theme}: 校验靠修复才过：写「修复 2 次后通过」，有一次凑数被作废就上琥珀`, chkNote?.text === '修复 2 次后通过'
+      && chkNote.warn && chkNote.title.includes('total_count=0'), JSON.stringify(chkNote))
+    shots.push(await shot(page, `${theme}-endings-degraded`), await cardShot(page, ['team', 'ask', 'q'], `${theme}-endings-degraded-cards`))
+    // 校验节点在右边，常被右栏挡住：取景过去再截
+    await page.evaluate(() => window.__studio.getState().focusNode('chk'))
+    await page.waitForTimeout(600)
+    shots.push(await cardShot(page, ['chk'], `${theme}-endings-degraded-validate`))
+
+    // 回放到收尾判定还没出结论的那一刻：不提前降档、不提前点名
+    const judging = await page.evaluate(() => {
+      const segs = window.__studio.getState().trace.nodes.team.segments.filter((s) => s.kind === 'dispatch')
+      return segs[segs.length - 1].start + 300
+    })
+    await page.evaluate((t) => window.__studio.getState().setReplayAt(t), judging)
+    await page.waitForTimeout(300)
+    m = await matrixOf(page)
+    const early = await at(page, 'team').locator('.nc-head .nc-chip-warn', { hasText: '降档' }).count()
+    check(`${theme}: 回放到收尾判定中：表头写「调度者在判定」，不提前降档、不点名`, m.right.includes('调度者在判定') && early === 0
+      && m.c?.status !== 'never', `${m.right} · 降档标 ${early} · ${m.c?.status}`)
+    await page.evaluate(() => window.__studio.getState().setReplayAt(null))
+
+    // ---- 进行中：收尾判定中；查询超出声明的时限
+    await feed(page, LIVE_JUDGING(Date.now()))
+    await page.waitForTimeout(600)
+    m = await matrixOf(page)
+    check(`${theme}: 进行中的收尾判定：表头写「轮数用完 · 调度者在判定」，不是新的一轮`,
+      m.right === '轮数用完 · 调度者在判定' && m.head.startsWith('第 2 轮 / 上限 2') && m.dispatch.includes('判定'), `${m.head} | ${m.dispatch}`)
+    const over = await at(page, 'q').locator('.nc-over').innerText().catch(() => '')
+    const overTitle = await at(page, 'q').locator('.nc-tools').getAttribute('title').catch(() => '') ?? ''
+    // 这句话整个落在卡片里，不被右边沿切掉
+    const overFits = await page.evaluate(() => {
+      const el = document.querySelector('.react-flow__node[data-id="q"] .nc-over')
+      const card = el?.closest('.nc')
+      if (!el || !card) return false
+      return el.getBoundingClientRect().right <= card.getBoundingClientRect().right - 2
+    })
+    check(`${theme}: 查询超出声明的时限：直说「已超出 2s 上限」，工具名在悬停里`, over === '已超出 2s 上限' && overTitle.includes('db_query__shop ⋯ 进行中（上限 2s）') && overFits, `${over} · ${flat(overTitle)}${overFits ? '' : ' · 超出了卡片'}`)
+    shots.push(await shot(page, `${theme}-endings-live`), await cardShot(page, ['team', 'q'], `${theme}-endings-live-cards`))
+    await setLod(page, 'compact')
+    const brief = await at(page, 'team').locator('.nc-lod-read').innerText()
+    check(`${theme}: 精简档：收尾判定中写清是判定，不写「第 3 轮」`, brief === '轮数用完 · 收尾判定中', brief)
+    // 收尾判定认事件里的 closing，不拿配置里的「最多轮数」比：没配（后端按缺省值跑）、
+    // 运行之后调大了（接着跑之前、回放历史运行），照样认得出是在判定
+    await setTeamConfig(page, { max_rounds: null })
+    await page.waitForTimeout(150)
+    const briefBare = await at(page, 'team').locator('.nc-lod-read').innerText()
+    await setLod(page, 'full')
+    m = await matrixOf(page)
+    check(`${theme}: 没配最多轮数：照样认出收尾判定（精简档、表头、调度者那一行）`, briefBare === '轮数用完 · 收尾判定中'
+      && m.right === '轮数用完 · 调度者在判定' && m.dispatch.includes('判定'), `${briefBare} | ${m.right} | ${m.dispatch}`)
+    await setTeamConfig(page, { max_rounds: 4 })
+    await page.waitForTimeout(150)
+    m = await matrixOf(page)
+    check(`${theme}: 运行之后调大了最多轮数：照样认出收尾判定`, m.right === '轮数用完 · 调度者在判定'
+      && m.dispatch.includes('判定'), `${m.right} | ${m.dispatch}`)
+    await setTeamConfig(page, { max_rounds: 2 })
+
+    // ---- 收尾判定说完成了
+    await feed(page, CLOSED_OK(Date.now()))
+    await page.waitForTimeout(600)
+    m = await matrixOf(page)
+    check(`${theme}: 收尾判定已完成：表头说清、安静、不点名`, m.right === '轮数用完 · 判定已完成' && m.tone === ''
+      && m.head.startsWith('第 2 轮 / 上限 2') && m.c?.status !== 'never', `${m.head} · ${m.tone} · ${m.c?.status}`)
+    check(`${theme}: 悬停写完整判定`, m.headTitle.includes('轮数用完 · 调度者判定：已完成') && m.headTitle.includes('材料够了'), flat(m.headTitle))
+
+    // ---- 同一个节点执行第二次：上一次的收场不挂到这一次上。照真实流程先把最多轮数调大
+    // 再接着跑：回放到第一次时「用完 2 轮」得按那一次的原话，不按现在的配置写成 4
+    await setTeamConfig(page, { max_rounds: 4 })
+    await feed(page, RERUN(Date.now()))
+    await page.waitForTimeout(700)
+    const quietEnding = async (label) => {
+      const cs = await cards(page)
+      const mx = await matrixOf(page)
+      const never = await at(page, 'team').locator('[data-member-status="never"]').count()
+      const chips = await at(page, 'team').locator('.nc-head .nc-chip-warn', { hasText: '降档' }).count()
+      const tn = await note(page, 'team')
+      const an = await note(page, 'ask')
+      check(`${theme}: ${label}：团队表头不挂上一次的「判定未完成」、安静、不点名`, cs.team.state === 'done' && mx.tone === ''
+        && !mx.right.includes('未完成') && !mx.headTitle.includes('未完成') && never === 0 && chips === 0 && !tn?.warn,
+        `${mx.right} · 语气「${mx.tone}」· 未派到 ${never} · 降档标 ${chips} · ${JSON.stringify(tn)}`)
+      check(`${theme}: ${label}：agent 这一次干干净净，写产出量，不写上一次的「收尾时仍想调用工具」`, cs.ask.state === 'done'
+        && !!an && !an.warn && /tok/.test(an.text), JSON.stringify(an))
+    }
+    await quietEnding('调大轮数接着跑成功、agent 再执行一次')
+    shots.push(await cardShot(page, ['team', 'ask'], `${theme}-endings-rerun-cards`))
+    const execs = await page.evaluate(() => {
+      const n = window.__studio.getState().trace.nodes
+      const runs = (id) => n[id].segments.filter((s) => s.kind === 'run')
+      return { teamRuns: runs('team').length, askRuns: runs('ask').length,
+               first: runs('team')[0].end + 300, second: runs('ask').at(-1).end + 10 }
+    })
+    check(`${theme}: 夹具确实是两次执行（团队、agent 各两段）`, execs.teamRuns === 2 && execs.askRuns === 2, JSON.stringify(execs))
+    await page.evaluate((t) => window.__studio.getState().setReplayAt(t), execs.second)
+    await page.waitForTimeout(300)
+    await quietEnding('回放到第二次执行里')
+    // 回放到第一次失败的那一刻：说的是那一次的收场，不因为后来成功了就不说
+    await page.evaluate((t) => window.__studio.getState().setReplayAt(t), execs.first)
+    await page.waitForTimeout(300)
+    m = await matrixOf(page)
+    const firstTeam = await note(page, 'team')
+    const firstAsk = await note(page, 'ask')
+    check(`${theme}: 回放到第一次失败那一刻：团队写那一次的「用完 2 轮仍未完成」，表头红、点名定稿员`,
+      firstTeam?.text === '协作团队用完 2 轮仍未完成' && m.right === '用完 2 轮 · 未完成' && m.tone === 'err' && m.c?.status === 'never',
+      `${JSON.stringify(firstTeam?.text)} · ${m.right} · ${m.tone} · ${m.c?.status}`)
+    check(`${theme}: 回放到第一次执行：agent 写那一次的「收尾时仍想调用工具」`, firstAsk?.text === '收尾时仍想调用工具' && firstAsk.warn,
+      JSON.stringify(firstAsk))
+    await page.evaluate(() => window.__studio.getState().setReplayAt(null))
+    await setTeamConfig(page, { max_rounds: 2 })
+
+    // ---- 写成文字、被提醒之后重答了：不是「收尾时仍想调用工具」
+    await feed(page, NUDGE(Date.now()))
+    await page.waitForTimeout(700)
+    const askNudge = await note(page, 'ask')
+    check(`${theme}: agent 写成文字被提醒后重答了：写「纠正过一次工具调用」，不说成果可能不完整`,
+      askNudge?.text === '纠正过一次工具调用' && askNudge.warn && askNudge.title.includes('提醒之后重答了')
+      && !askNudge.title.includes('可能不完整'), JSON.stringify(askNudge))
+    const teamNudge = await note(page, 'team')
+    check(`${theme}: 协作成员提醒后重答了：团队卡同样写「纠正过一次」，提醒后仍失败的那位不算进去`,
+      teamNudge?.text === '纠正过一次工具调用' && teamNudge.warn && teamNudge.title.includes('检索员')
+      && !teamNudge.title.includes('分析员'), JSON.stringify(teamNudge))
+    shots.push(await cardShot(page, ['team', 'ask'], `${theme}-endings-nudge-cards`))
+    check('没有运行时报错', errors.length === 0, errors.slice(0, 3).join(' | '))
+    await browser.close()
+  }
+}
+
 if (want('replay')) {
   console.log('\n=== 回放：卡片回到游标那一刻 ===')
   const { browser, page, errors } = await open({ theme: 'dark' })
diff --git a/scripts/check-runs.mjs b/scripts/check-runs.mjs
index fccb3834..e4d30b20 100644
--- a/scripts/check-runs.mjs
+++ b/scripts/check-runs.mjs
@@ -357,9 +357,28 @@ if (authFail) {
   check('有「接着跑」', await page.locator('[data-run-banner=failed] [data-action=continue]').count() === 1)
   check('有「去模型接入」', await page.locator('[data-run-banner=failed] [data-action=settings]').count() === 1)
   check('有「复制错误」', await page.locator('[data-run-banner=failed] [data-action=copy-error]').count() === 1)
-  const href = await page.locator('[data-run-banner=failed] [data-action=locate]').getAttribute('href')
-  check('「在画布中定位」带 run 和 focus', href === `/studio/${authFail.workflow_id}?run=${authFail.id}&focus=${full.error_node_id}`, href ?? '')
   check('失败的运行不给「提取模板」', await page.locator('[data-action=extract]').count() === 0)
+  // 横幅里的定位是排错的主路，详情头上的回放是看全程：两处都得够得着画布。失败的节点
+  // 在工作流现在的图里已经没了的话（之后改过结构），对准它会落空：横幅改给「在航迹中看」，
+  // 详情头照样回放、只是不带 focus。两种情形下面的航迹夹具各测一遍，这里按库里的实情测
+  const authWf = (await getJson('/workflows')).find((w) => w.id === authFail.workflow_id)
+  const stillThere = !!authWf?.graph?.nodes?.some((n) => n.id === full.error_node_id)
+  const canvasBase = `/studio/${authFail.workflow_id}?run=${authFail.id}`
+  const headLink = page.locator('[data-run-detail] > header [data-action=open-canvas]')
+  const headHref = await headLink.getAttribute('href').catch(() => null)
+  const headText = await headLink.innerText().catch(() => '')
+  if (stillThere) {
+    const href = await page.locator('[data-run-banner=failed] [data-action=locate]').getAttribute('href').catch(() => null)
+    check('「在画布中定位」带 run 和 focus', href === `${canvasBase}&focus=${full.error_node_id}`, href ?? '')
+    check('失败的运行详情头上也有「在画布中回放」，对准失败的节点',
+      headText.includes('在画布中回放') && headHref === href, headHref ?? '没有这个按钮')
+  } else {
+    check('失败的节点在工作流现在的图里没了：不给落空的「在画布中定位」，改给「在航迹中看」',
+      await page.locator('[data-run-banner=failed] [data-action=locate]').count() === 0
+        && await page.locator('[data-run-banner=failed] [data-action=locate-trace]').count() === 1)
+    check('失败的运行详情头上照样「在画布中回放」，不带对不上的 focus',
+      headText.includes('在画布中回放') && headHref === canvasBase, headHref ?? '没有这个按钮')
+  }
 
   // 接着跑：POST 伪造成功，实时流在上面已经伪造好
   fakes.set(`POST /api/runs/${authFail.id}/continue`, () => ({
@@ -463,7 +482,16 @@ if (syntaxFail) {
   await page.locator('[data-run-banner=failed]').waitFor()
   check('表达式写错的失败不给「接着跑」', await page.locator('[data-run-banner=failed] [data-action=continue]').count() === 0)
   const locate = page.locator('[data-run-banner=failed] [data-action=locate]')
-  check('「在画布中定位」成了主按钮', await locate.count() === 1 && /\bbtn-primary\b/.test(await locate.getAttribute('class') ?? ''))
+  // 失败的节点在工作流现在的图里没了的话，定位落空，主路改成去航迹看（定位作主按钮的
+  // 情形由后面「模型没有真正调用工具」的夹具测）
+  const synNode = (await getJson(`/runs/${syntaxFail.id}`)).error_node_id
+  const synWf = (await getJson('/workflows')).find((w) => w.id === syntaxFail.workflow_id)
+  if (synWf?.graph?.nodes?.some((n) => n.id === synNode)) {
+    check('「在画布中定位」成了主按钮', await locate.count() === 1 && /\bbtn-primary\b/.test(await locate.getAttribute('class') ?? ''))
+  } else {
+    check('失败的节点在工作流现在的图里没了：不给落空的定位，给「在航迹中看」',
+      await locate.count() === 0 && await page.locator('[data-run-banner=failed] [data-action=locate-trace]').count() === 1)
+  }
 } else {
   check('沙箱里有一条表达式写错的失败运行', false)
 }
@@ -478,6 +506,8 @@ if (held) {
   await page.waitForTimeout(500)
   check('显示「已挂起」而不是「等待审批」', await page.locator('[data-run-detail]').getAttribute('data-run-code') === 'held')
   check('挂起横幅带「接着跑」', await page.locator('[data-run-banner=held] [data-action=resume]').count() === 1)
+  // 挂起的没人会再去接：不放弃的话它在记录里永远挂着「可续跑」
+  check('挂起横幅也能放弃这次运行', await page.locator('[data-run-banner=held] [data-action=abandon]').count() === 1)
 }
 
 // ------------------------------------------------------------------ 封存凭证
@@ -573,6 +603,16 @@ await page.waitForTimeout(700)
 const clockB = await page.locator('[data-telemetry=wall]').innerText()
 check('墙钟在走（mm:ss.s）', /^\d\d:\d\d\.\d$/.test(clockB) && clockA !== clockB, `${clockA} → ${clockB}`)
 check('状态格写着当前节点', (await page.locator('[data-run-telemetry]').innerText()).includes('当前「总结」'))
+// 在跑的运行看航迹：游标跟着现在走，「此刻」列出在跑的节点
+await page.locator('[data-run-detail] [role=tab][data-tab=trace]').click()
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+const liveAtA = await page.locator('[data-trace-readout] [data-readout=at]').innerText().catch(() => '')
+await page.waitForTimeout(500)
+const liveAtB = await page.locator('[data-trace-readout] [data-readout=at]').innerText().catch(() => '')
+const liveMode = await page.locator('[data-trace-readout]').getAttribute('data-mode').catch(() => '')
+check('航迹上游标是实时的，而且在走', liveMode === '实时' && liveAtA !== liveAtB, `${liveMode} ${liveAtA} → ${liveAtB}`.replace(/\s+/g, ' '))
+check('「此刻」列出在跑的「总结」', await page.locator('[data-trace-now] [data-now-node=b]').count() === 1)
+await page.locator('[data-run-detail] [role=tab][data-tab=stream]').click()
 await page.getByRole('button', { name: '更多操作' }).click()
 const del = page.locator('[data-menu=delete]')
 check('运行中「删除记录」不可点，并说明要先停止', await del.isDisabled() && (await del.innerText()).includes('先停止'))
@@ -703,8 +743,583 @@ await page.getByRole('dialog').getByRole('button', { name: '删除记录' }).cli
 check('409 时把后端的话原样告诉人', await page.getByText('先停止它，再删除').first().waitFor({ timeout: 4000 }).then(() => true, () => false))
 check('409 时停在原地', new URL(page.url()).pathname === `/runs/${BUSY}`)
 
+// ------------------------------------------------------------------ 航迹
+
+console.log('\n=== 航迹：按时间摊开，拖到哪一刻读到哪一刻 ===')
+// 一次等过 5 分钟审批的运行：查询 → 审批 → 汇总。名字都是编的通用示例
+const wfHost = (await getJson('/workflows'))[0]
+const iso = (s) => new Date(s * 1000).toISOString()
+const TRACE = 'fake0trace00000000000000000000'
+const TRACE_OFF = 'fake0traceoff00000000000000000'
+const tt = Date.now() / 1000 - 3600
+const WAIT_S = 300
+const traceGraph = { nodes: [
+  { id: 'in', type: 'input', position: { x: 0, y: 0 }, data: { label: '输入', config: {} } },
+  { id: 'query', type: 'agent', position: { x: 200, y: 0 }, data: { label: '查询订单', config: { tools: ['db_query__shop'] } } },
+  { id: 'gate', type: 'human', position: { x: 400, y: 0 }, data: { label: '人工审批', config: {} } },
+  { id: 'sum', type: 'llm', position: { x: 600, y: 0 }, data: { label: '汇总', config: {} } },
+], edges: [{ source: 'in', target: 'query' }, { source: 'query', target: 'gate' }, { source: 'gate', target: 'sum' }] }
+const traceEvents = (usageIn = 2000) => [
+  { seq: 1, type: 'run.started', node_id: null, ts: tt, data: { nodes: 4 } },
+  { seq: 2, type: 'node.started', node_id: 'in', ts: tt + 0.1, data: { node_type: 'input', label: '输入' } },
+  { seq: 3, type: 'node.finished', node_id: 'in', ts: tt + 0.2, data: { duration_ms: 100 } },
+  { seq: 4, type: 'node.started', node_id: 'query', ts: tt + 0.3, data: { node_type: 'agent', label: '查询订单' } },
+  { seq: 5, type: 'tool.start', node_id: 'query', ts: tt + 0.5,
+    data: { tool: 'db_query__shop', call_id: 'c1', args: { sql: 'select count(*) as n from orders' } } },
+  { seq: 6, type: 'tool.end', node_id: 'query', ts: tt + 2.5,
+    data: { tool: 'db_query__shop', call_id: 'c1', duration_ms: 2000, preview: '{"columns":["n"],"rows":[[42]]}' } },
+  { seq: 7, type: 'llm.end', node_id: 'query', ts: tt + 3.0,
+    data: { agent: '查询订单', model: 'demo-model', input_tokens: 1200, output_tokens: 300, cost_usd: 0.004 } },
+  { seq: 8, type: 'node.finished', node_id: 'query', ts: tt + 3.1, data: { duration_ms: 2800, preview: '共 42 单' } },
+  { seq: 9, type: 'node.started', node_id: 'gate', ts: tt + 3.2, data: { node_type: 'human', label: '人工审批' } },
+  { seq: 10, type: 'human.requested', node_id: 'gate', ts: tt + 3.3, data: { mode: 'approve', prompt: '放行吗？' } },
+  { seq: 11, type: 'run.interrupted', node_id: null, ts: tt + 3.4, data: {} },
+  { seq: 12, type: 'human.resolved', node_id: 'gate', ts: tt + 3.4 + WAIT_S, data: { response: { approved: true }, actor: '张工' } },
+  { seq: 13, type: 'run.resumed', node_id: null, ts: tt + 3.4 + WAIT_S, data: { actor: '张工' } },
+  { seq: 14, type: 'node.finished', node_id: 'gate', ts: tt + 3.5 + WAIT_S, data: { duration_ms: 1 } },
+  { seq: 15, type: 'node.started', node_id: 'sum', ts: tt + 3.6 + WAIT_S, data: { node_type: 'llm', label: '汇总' } },
+  { seq: 16, type: 'llm.end', node_id: 'sum', ts: tt + 6.0 + WAIT_S,
+    data: { model: 'demo-model', input_tokens: 800, output_tokens: 500, cost_usd: 0.003 } },
+  { seq: 17, type: 'node.finished', node_id: 'sum', ts: tt + 6.1 + WAIT_S, data: { duration_ms: 2500 } },
+  { seq: 18, type: 'run.finished', node_id: null, ts: tt + 6.2 + WAIT_S, data: {
+    output: { answer: '共 42 单' }, usage: { input_tokens: usageIn, output_tokens: 800, cost_usd: 0.007 },
+    timing: { wall_ms: (6.2 + WAIT_S) * 1000, active_ms: 6200, wait_ms: WAIT_S * 1000 } } },
+]
+const traceRun = (id, usageIn = 2000) => ({
+  ...base, id, workflow_id: wfHost.id, workflow_name: wfHost.name, status: 'succeeded', run_class: 'exploratory',
+  version: null, version_hash: null, manifest_hash: null, manifest_seq: null, error: null, error_node_id: null,
+  input: { q: '上周的订单' }, output: { answer: '共 42 单' },
+  usage: { input_tokens: usageIn, output_tokens: 800, cost_usd: 0.007, duration_ms: 6200,
+           wall_ms: (6.2 + WAIT_S) * 1000, active_ms: 6200, wait_ms: WAIT_S * 1000 },
+  created_at: iso(tt), started_at: iso(tt), finished_at: iso(tt + 6.2 + WAIT_S),
+})
+const ART_Q = 'a1'.repeat(32)
+const ART_QOUT = 'b2'.repeat(32)
+const ART_SUM = 'c3'.repeat(32)
+const traceArtifacts = [
+  { id: ART_Q, kind: 'query_snapshot', node_id: 'query', size: 2048, meta: {}, created_at: iso(tt + 2.5) },
+  { id: ART_QOUT, kind: 'node_output', node_id: 'query', size: 120, meta: { type: 'agent', attempt: 1 }, created_at: iso(tt + 3.1) },
+  { id: ART_SUM, kind: 'node_output', node_id: 'sum', size: 300, meta: { type: 'llm', attempt: 1 }, created_at: iso(tt + 6.1 + WAIT_S) },
+]
+for (const [id, usageIn] of [[TRACE, 2000], [TRACE_OFF, 5000]]) {
+  fakes.set(`GET /api/runs/${id}`, () => ({ status: 200, json: traceRun(id, usageIn) }))
+  fakes.set(`GET /api/runs/${id}/events`, () => ({ status: 200, json: traceEvents(usageIn) }))
+  fakes.set(`GET /api/runs/${id}/graph`, () => ({ status: 200, json: { graph: traceGraph, workflow_id: wfHost.id, version: null } }))
+  fakes.set(`GET /api/runs/${id}/artifacts`, () => ({ status: 200, json: traceArtifacts }))
+}
+fakes.set(`GET /api/artifacts/${ART_Q}`, () => ({ status: 200, json: { id: ART_Q, content: {
+  tool: 'db_query__shop', args: { sql: 'select count(*) as n from orders' }, result: '{"columns":["n"],"rows":[[42]]}',
+} } }))
+// 工作流「现在」的图：这些运行之后改过结构——「汇总」删了，换成「通知」；「查询订单」还在。
+// 画布上还对得准的节点给「在画布中看这一步」，已经没了的不给（给了也对不到任何东西）
+const wfNow = (await getJson('/workflows')).map((w) => (w.id !== wfHost.id ? w : { ...w, graph: {
+  nodes: [...traceGraph.nodes.filter((n) => n.id !== 'sum'),
+    { id: 'notify', type: 'output', position: { x: 600, y: 0 }, data: { label: '通知', config: {} } }],
+  edges: [...traceGraph.edges.filter((e) => e.target !== 'sum'), { source: 'gate', target: 'notify' }],
+} }))
+fakes.set('GET /api/workflows', () => ({ status: 200, json: wfNow }))
+
+const viewTab = (k) => page.locator(`[data-run-detail] [role=tab][data-tab=${k}]`)
+const readout = (k) => page.locator(`[data-trace-readout] [data-readout=${k}]`).innerText().catch(() => '')
+// 实时、回放、终态写在游标那一格的标签行，数值那一行只有时刻
+const mode = () => page.locator('[data-trace-readout]').getAttribute('data-mode').catch(() => '')
+await page.goto(`${WEB}/runs/${TRACE}`, { waitUntil: 'networkidle' })
+await page.locator('[data-run-detail]').waitFor()
+check('详情分「时间线 / 航迹 / 工件」三个页签',
+  await viewTab('stream').count() === 1 && await viewTab('trace').count() === 1 && await viewTab('artifacts').count() === 1)
+check('默认停在时间线', await viewTab('stream').getAttribute('aria-selected').catch(() => null) === 'true')
+check('工件页签上写着有几件', (await viewTab('artifacts').innerText().catch(() => '')).includes('3'))
+check('读屏念的是「3 件」，不是「3 条」',
+  await viewTab('artifacts').locator('[aria-label]').getAttribute('aria-label').catch(() => null) === '3 件',
+  await viewTab('artifacts').locator('[aria-label]').getAttribute('aria-label').catch(() => '') ?? '')
+await viewTab('trace').click().catch(() => {})
+await page.locator('[data-run-trace] section[aria-label="航迹"]').waitFor({ timeout: 5000 }).catch(() => {})
+check('点「航迹」地址记下 ?view=trace', new URL(page.url()).searchParams.get('view') === 'trace')
+const lanes = await page.locator('[data-run-trace] [data-lane]').evaluateAll((els) => els.map((e) => e.getAttribute('data-lane')))
+check('每个节点一条泳道，按执行顺序排', lanes.join(',') === 'in,query,gate,sum', lanes.join(',') || '没有泳道')
+check('没拖游标时读的是终态：已完成、2.8k tok',
+  (await readout('phase')).includes('已完成') && (await readout('tokens')).includes('2.8k'),
+  `${await readout('phase')} / ${await readout('tokens')}`)
+check('没选节点时列出最耗时的节点（慢在哪）',
+  (await page.locator('[data-trace-slowest] [data-slow-node]').first().getAttribute('data-slow-node').catch(() => null)) === 'query')
+
+// 地址里带着时刻：从工件、分享的链接直接落到那一刻
+await page.goto(`${WEB}/runs/${TRACE}?view=trace&at=2500`, { waitUntil: 'networkidle' })
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+check('?at=2500 落到 T+00:02.5', (await readout('at')).includes('00:02.5'), await readout('at'))
+check('游标在时间轴上也在回放', (await page.locator('[data-run-trace] [role=slider]').getAttribute('aria-valuenow').catch(() => null)) === '2500')
+check('那一刻在跑的是「查询订单」', await page.locator('[data-trace-now] [data-now-node=query]').count() === 1)
+check('那一刻整次运行还没用 token（模型 3.0 s 才回）', /^0\b/.test((await readout('tokens')).trim()), await readout('tokens'))
+check('进来之后地址里的时刻摘掉（拖动时不再和它对不上）', !new URL(page.url()).searchParams.has('at'))
+
+// 慢在哪：那一刻卡在哪个工具上（查询 0.5 s 开始、2.5 s 返回）
+await page.goto(`${WEB}/runs/${TRACE}?view=trace&at=2000`, { waitUntil: 'networkidle' })
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+await page.locator('[data-run-trace] [data-lane=query] .tl-label').click().catch(() => {})
+const callText = await page.locator('[data-trace-node=query] [data-node-field=call]').innerText().catch(() => '')
+check('那一刻在跑的节点，卡片写着正在调哪个工具、调了多久', /db_query__shop.*已 1\.5 s/.test(callText), callText || '没有这一行')
+check('点泳道名只是选中节点，游标不动', (await readout('at')).includes('00:02.0'), await readout('at'))
+
+// 拖动：在坞的刻度行上按下、拖过去，读数跟着游标走
+const track = page.locator('[data-run-trace] .tl-scrub').first()
+const box = await track.boundingBox().catch(() => null)
+if (box) {
+  await page.mouse.move(box.x + box.width * 0.05, box.y + box.height / 2)
+  await page.mouse.down()
+  await page.mouse.move(box.x + box.width * 0.15, box.y + box.height / 2, { steps: 4 })
+  await page.waitForTimeout(120)
+  const mid = `${await mode()} ${await readout('at')}`
+  await page.mouse.move(box.x + box.width * 0.3, box.y + box.height / 2, { steps: 4 })
+  await page.mouse.up()
+  await page.waitForTimeout(150)
+  const after = `${await mode()} ${await readout('at')}`
+  check('拖动游标：读数跟着走，并标成回放', mid.includes('回放') && after.includes('回放') && mid !== after, `${mid} → ${after}`)
+} else {
+  check('拖动游标：读数跟着走，并标成回放', false, '找不到坞的刻度行')
+}
+const slider = page.locator('[data-run-trace] [role=slider]')
+await slider.focus().catch(() => {})
+await page.keyboard.press('Home')
+await page.waitForTimeout(100)
+check('键盘 Home：游标回到开始', (await readout('at')).includes('00:00.0'), await readout('at'))
+await page.keyboard.press('End')
+await page.waitForTimeout(100)
+check('键盘 End：回到终态读数', await mode() === '终态', await mode())
+
+// 关键时刻：长时间等人的空档被压缩了，拖游标很难正好停在那一下
+const moments = page.locator('[data-trace-moments] [data-moment]')
+const momentText = (await moments.allInnerTexts().catch(() => [])).map((t) => t.replace(/\s+/g, ' '))
+check('列出关键时刻：开始、停下等审批、审批已处理（等了多久）、结局',
+  momentText.length === 4 && momentText[0].includes('开始运行') && momentText[1].includes('「人工审批」停下等审批')
+    && momentText[2].includes('审批已处理') && momentText[2].includes('5 分 00 秒') && momentText[3].includes('运行完成'),
+  momentText.join(' | '))
+check('没拖游标时，当前落在结局那一条', await moments.nth(3).getAttribute('aria-current').catch(() => null) === 'step')
+await moments.nth(2).click().catch(() => {})
+await page.waitForTimeout(150)
+check('点「审批已处理」：游标跳到那一刻（T+05:03.4）', await mode() === '回放' && (await readout('at')).includes('05:03.4'),
+  `${await mode()} ${await readout('at')}`)
+check('跳过去之后它成了当前那一条', await moments.nth(2).getAttribute('aria-current').catch(() => null) === 'step')
+check('坞上的游标也跟着过去', (await slider.getAttribute('aria-valuenow').catch(() => null)) === '303400',
+  await slider.getAttribute('aria-valuenow').catch(() => '') ?? '')
+await moments.nth(3).click().catch(() => {})
+await page.waitForTimeout(150)
+check('点结局那一条回到终态', await mode() === '终态', await mode())
+
+await page.goto(`${WEB}/runs/${TRACE}?view=trace&at=30000`, { waitUntil: 'networkidle' })
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+check('拖到等审批那一段：状态是等待审批', (await readout('phase')).includes('等待审批'), await readout('phase'))
+check('那一刻等审批的是「人工审批」', await page.locator('[data-trace-now] [data-now-node=gate]').count() === 1)
+check('用量只算到那一刻：1.5k', (await readout('tokens')).includes('1.5k'), await readout('tokens'))
+await page.locator('[data-run-trace] [data-lane=query]').click().catch(() => {})
+const nodeCard = page.locator('[data-trace-node=query]')
+check('点泳道看这个节点在那一刻的样子', await nodeCard.count() === 1)
+check('节点的用量、工具数取自那一刻',
+  (await nodeCard.locator('[data-node-field=tokens]').innerText().catch(() => '')).includes('1.5k')
+    && (await nodeCard.locator('[data-node-field=tools]').innerText().catch(() => '')).includes('1'))
+check('节点卡能回画布看这一步',
+  (await nodeCard.locator('[data-action=node-canvas]').getAttribute('href').catch(() => null)) === `/studio/${wfHost.id}?run=${TRACE}&focus=query`)
+await page.locator('[data-run-trace] [data-lane=sum] .tl-label').click().catch(() => {})
+const goneCard = page.locator('[data-trace-node=sum]')
+check('工作流现在的图里已经没有的节点：节点卡不给落空的「在画布中看这一步」，说明为什么',
+  await goneCard.count() === 1 && await goneCard.locator('[data-action=node-canvas]').count() === 0
+    && await goneCard.locator('[data-node-gone]').count() === 1)
+await page.locator('[data-run-trace] [data-lane=query] .tl-label').click().catch(() => {})
+await nodeCard.locator('[data-action=node-stream]').click().catch(() => {})
+await page.waitForTimeout(300)
+check('「在时间线里看」切回时间线', await viewTab('stream').getAttribute('aria-selected').catch(() => null) === 'true')
+check('并且把那一步描出来', await page.locator('[data-run-detail] [data-node-id="query"][data-flash]').count() >= 1)
+
+await page.goto(`${WEB}/runs/${TRACE_OFF}?view=trace&at=30000`, { waitUntil: 'networkidle' })
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+check('各次调用加起来对不上后端总数时，那一刻的用量写「—」，不拿终值冒充', (await readout('tokens')).trim().startsWith('—'), await readout('tokens'))
+
+// 模型把工具调用写成了文字、一次都没真正查（引擎判失败）：结局是失败，而且说得出为什么
+console.log('\n=== 航迹：模型没有真正调用工具 ===')
+const LEAK = 'fake0leak000000000000000000000'
+const LEAK_ERROR = '模型输出了工具调用的原始标记，但没有真正调用工具，这一步一次都没查到数据。常见原因：节点没有绑定工具，或者模型、服务不支持工具调用。到画布里给这个节点绑定要用的工具；绑定了还这样，就换一个支持工具调用的模型'
+fakes.set(`GET /api/runs/${LEAK}`, () => ({ status: 200, json: {
+  ...traceRun(LEAK), status: 'failed', output: null, error: LEAK_ERROR, error_node_id: 'query',
+  usage: { input_tokens: 900, output_tokens: 400, cost_usd: 0.002, duration_ms: 4200, wall_ms: 4200, active_ms: 4200, wait_ms: 0 },
+  finished_at: iso(tt + 4.2),
+} }))
+fakes.set(`GET /api/runs/${LEAK}/events`, () => ({ status: 200, json: [
+  ...traceEvents().slice(0, 4),
+  { seq: 5, type: 'llm.end', node_id: 'query', ts: tt + 2.0,
+    data: { agent: '查询订单', model: 'demo-model', input_tokens: 450, output_tokens: 200, cost_usd: 0.001 } },
+  { seq: 6, type: 'log', node_id: 'query', ts: tt + 2.1, data: {
+    level: 'warn', code: 'tool_markup_leak', message: '模型把工具调用写成了文字（<｜｜DSML｜｜invoke name="db_query__shop"…），没有真正调用工具' } },
+  { seq: 7, type: 'llm.end', node_id: 'query', ts: tt + 4.0,
+    data: { agent: '查询订单', model: 'demo-model', input_tokens: 450, output_tokens: 200, cost_usd: 0.001 } },
+  { seq: 8, type: 'node.failed', node_id: 'query', ts: tt + 4.1, data: { error: LEAK_ERROR, duration_ms: 3800 } },
+  { seq: 9, type: 'run.failed', node_id: null, ts: tt + 4.2, data: {
+    error: LEAK_ERROR, node_id: 'query', timing: { wall_ms: 4200, active_ms: 4200, wait_ms: 0 } } },
+] }))
+fakes.set(`GET /api/runs/${LEAK}/graph`, () => ({ status: 200, json: { graph: traceGraph, workflow_id: wfHost.id, version: null } }))
+fakes.set(`GET /api/runs/${LEAK}/artifacts`, () => ({ status: 200, json: [] }))
+await page.goto(`${WEB}/runs/${LEAK}?view=trace`, { waitUntil: 'networkidle' })
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+const leakBanner = (await page.locator('[data-run-banner=failed]').innerText().catch(() => '')).replace(/\s+/g, ' ')
+check('失败横幅说清是模型没有真正调用工具', leakBanner.includes('没有真正调用工具'), leakBanner.slice(0, 60))
+const leakLocate = page.locator('[data-run-banner=failed] [data-action=locate]')
+check('失败的节点还在工作流现在的图里：「在画布中定位」对准它；接着跑过不去，它就是主按钮',
+  await leakLocate.getAttribute('href').catch(() => null) === `/studio/${wfHost.id}?run=${LEAK}&focus=query`
+    && /\bbtn-primary\b/.test(await leakLocate.getAttribute('class').catch(() => '') ?? '')
+    && await page.locator('[data-run-banner=failed] [data-action=locate-trace]').count() === 0)
+const leakMoments = (await page.locator('[data-trace-moments] [data-moment]').allInnerTexts().catch(() => [])).map((t) => t.replace(/\s+/g, ' '))
+check('关键时刻里有那一下警告，结局写失败于哪个节点',
+  leakMoments.some((t) => t.includes('「查询订单」把工具调用写成了文字'))
+    && (leakMoments.at(-1) ?? '').includes('失败于「查询订单」') && (leakMoments.at(-1) ?? '').includes('没有真正调用工具'),
+  leakMoments.join(' | '))
+const leakCard = (await page.locator('[data-trace-node=query]').innerText().catch(() => '')).replace(/\s+/g, ' ')
+check('失败的节点默认选中，卡片上写着警告和原因',
+  leakCard.includes('把工具调用写成了文字') && leakCard.includes('没有真正调用工具') && leakCard.includes('失败'),
+  leakCard.slice(0, 80))
+await page.locator('[data-trace-moments] [data-moment="query:markup"]').click().catch(() => {})
+await page.waitForTimeout(150)
+check('跳到警告那一刻：节点还在跑，卡片上已经有警告',
+  (await readout('at')).includes('00:02.1') && (await page.locator('[data-trace-node=query] [data-node-warn]').count()) === 1,
+  await readout('at'))
+
+// 失败在「汇总」上，而工作流之后把「汇总」删了：画布上对准它什么也对不到
+console.log('\n=== 失败的节点在工作流现在的图里已经没了 ===')
+const GONE = 'fake0gonefail00000000000000000'
+const GONE_ERROR = '节点「汇总」失败：模型服务出错了（HTTP 500）'
+fakes.set(`GET /api/runs/${GONE}`, () => ({ status: 200, json: {
+  ...traceRun(GONE), status: 'failed', output: null, error: GONE_ERROR, error_node_id: 'sum', finished_at: iso(tt + 6.2 + WAIT_S),
+} }))
+fakes.set(`GET /api/runs/${GONE}/events`, () => ({ status: 200, json: [
+  ...traceEvents().slice(0, 15),
+  { seq: 16, type: 'node.failed', node_id: 'sum', ts: tt + 6.0 + WAIT_S, data: { error: GONE_ERROR, duration_ms: 2400 } },
+  { seq: 17, type: 'run.failed', node_id: null, ts: tt + 6.1 + WAIT_S, data: {
+    error: GONE_ERROR, node_id: 'sum', timing: { wall_ms: (6.1 + WAIT_S) * 1000, active_ms: 6100, wait_ms: WAIT_S * 1000 } } },
+] }))
+fakes.set(`GET /api/runs/${GONE}/graph`, () => ({ status: 200, json: { graph: traceGraph, workflow_id: wfHost.id, version: null } }))
+fakes.set(`GET /api/runs/${GONE}/artifacts`, () => ({ status: 200, json: [] }))
+await page.goto(`${WEB}/runs/${GONE}`, { waitUntil: 'networkidle' })
+await page.locator('[data-run-banner=failed]').waitFor({ timeout: 5000 }).catch(() => {})
+check('横幅不给落空的「在画布中定位」，改给「在航迹中看」',
+  await page.locator('[data-run-banner=failed] [data-action=locate]').count() === 0
+    && await page.locator('[data-run-banner=failed] [data-action=locate-trace]').count() === 1)
+const goneHead = page.locator('[data-run-detail] > header [data-action=open-canvas]')
+check('详情头照样能在画布中回放，只是不带对不上的 focus',
+  await goneHead.getAttribute('href').catch(() => null) === `/studio/${wfHost.id}?run=${GONE}`
+    && !/对准/.test(await goneHead.getAttribute('title').catch(() => '') ?? ''),
+  await goneHead.getAttribute('href').catch(() => '没有这个按钮') ?? '')
+await page.locator('[data-run-banner=failed] [data-action=locate-trace]').click().catch(() => {})
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+check('「在航迹中看」：切到航迹，选中失败的那个节点，停在终态',
+  await viewTab('trace').getAttribute('aria-selected').catch(() => null) === 'true'
+    && await page.locator('[data-trace-node=sum]').count() === 1 && await mode() === '终态')
+check('那张节点卡也说清画布上已经没有它', await page.locator('[data-trace-node=sum] [data-node-gone]').count() === 1)
+
+// ------------------------------------------------------------------ 工件
+
+console.log('\n=== 工件：按节点分组，就地打开 ===')
+await page.goto(`${WEB}/runs/${TRACE}?view=artifacts`, { waitUntil: 'networkidle' })
+await page.locator('[data-run-artifacts]').waitFor({ timeout: 5000 }).catch(() => {})
+const groups = await page.locator('[data-run-artifacts] [data-artifact-group]').evaluateAll((els) => els.map((e) => e.getAttribute('data-artifact-group')))
+check('按节点分组，按执行顺序', groups.join(',') === 'query,sum', groups.join(',') || '没有分组')
+const qText = await page.locator(`[data-artifact-id="${ART_Q}"]`).innerText().catch(() => '')
+check('每件写着类型和大小', qText.includes('查询快照') && qText.includes('2.0 KB'), qText.replace(/\s+/g, ' '))
+await page.locator(`[data-artifact-id="${ART_Q}"] [data-action=artifact-open]`).click().catch(() => {})
+const artDialog = page.getByRole('dialog')
+// 弹窗先出来、内容取回来之后才画表：等到解开的那一块再读
+await artDialog.locator('[data-artifact]').waitFor({ timeout: 5000 }).catch(() => {})
+const artText = await artDialog.innerText().catch(() => '')
+check('用证据查看器打开：带节点名，解开 SQL 和结果表',
+  artText.includes('查询订单') && artText.includes('select count(*)') && artText.includes('42'), artText.replace(/\s+/g, ' ').slice(0, 90))
+await page.keyboard.press('Escape')
+await page.locator(`[data-artifact-id="${ART_Q}"] [data-action=artifact-moment]`).click().catch(() => {})
+await page.waitForTimeout(400)
+check('「在航迹里看这一刻」跳到航迹、定位到它产出的时刻',
+  await viewTab('trace').getAttribute('aria-selected').catch(() => null) === 'true' && (await readout('at')).includes('00:02.5'),
+  await readout('at'))
+const realWithArt = []
+for (const r of allRuns.slice(0, 40)) {
+  const a = await getJson(`/runs/${r.id}/artifacts`)
+  if (a.length) { realWithArt.push([r, a]); break }
+}
+if (realWithArt.length) {
+  const [r, a] = realWithArt[0]
+  await page.goto(`${WEB}/runs/${r.id}`, { waitUntil: 'networkidle' })
+  await page.locator('[data-run-detail]').waitFor()
+  await page.waitForTimeout(300)
+  check('真实运行：工件页签的数和接口一致', (await viewTab('artifacts').innerText().catch(() => '')).includes(String(a.length)),
+    `接口 ${a.length} 件`)
+}
+
+// ------------------------------------------------------------------ 回画布
+
+console.log('\n=== 在画布中回放 ===')
+await page.goto(`${WEB}/runs/${TRACE}`, { waitUntil: 'networkidle' })
+await page.locator('[data-run-detail]').waitFor()
+const replayLink = page.locator('[data-run-detail] > header [data-action=open-canvas]')
+check('跑完的运行，详情头是「在画布中回放」',
+  (await replayLink.innerText().catch(() => '')).includes('在画布中回放')
+    && await replayLink.getAttribute('href').catch(() => null) === `/studio/${wfHost.id}?run=${TRACE}`,
+  await replayLink.getAttribute('href').catch(() => '') ?? '')
+check('工作流之后改过结构：链接说明画布上是现在的图',
+  await replayLink.getAttribute('data-graph-drift').catch(() => null) === '1'
+    && /改过/.test(await replayLink.getAttribute('title').catch(() => '') ?? ''))
+fakes.delete('GET /api/workflows')
+
+// ------------------------------------------------------------------ 列表：缩略条、取消原因
+
+console.log('\n=== 列表：每行一条缩略条 ===')
+const FAILED_ROW = 'fake0failedrow0000000000000000'
+const CANCEL_ROW = 'fake0cancelrow0000000000000000'
+const failedRow = { ...traceRun(FAILED_ROW), status: 'failed', error: '节点「汇总」失败：模型服务出错了（HTTP 500）', error_node_id: 'sum',
+  usage: { wall_ms: 4000, active_ms: 4000, wait_ms: 0, duration_ms: 4000 }, finished_at: iso(tt + 4) }
+const cancelRow = { ...traceRun(CANCEL_ROW), status: 'cancelled', error: '用户取消：在等审批时放弃了这次运行',
+  usage: { wall_ms: 90000, active_ms: 3000, wait_ms: 87000, duration_ms: 3000 }, finished_at: iso(tt + 90) }
+fakes.set('GET /api/runs', () => ({ status: 200, json: [traceRun(TRACE), failedRow, cancelRow, ...listTop] }))
+await page.goto(`${WEB}/runs`, { waitUntil: 'networkidle' })
+await rowsOf().first().waitFor()
+const shapeCount = await page.locator('[data-runs-list] [data-run-id] [data-run-shape]').count()
+check('每一行都有一条缩略条', shapeCount === await rowsOf().count() && shapeCount > 0, `${shapeCount} 条`)
+const waitFrac = await page.locator(`[data-run-id="${TRACE}"] [data-shape-seg=wait]`).evaluate(
+  (el) => el.getBoundingClientRect().width / el.parentElement.getBoundingClientRect().width).catch(() => 0)
+check('等人占了九成八的墙钟，缩略条上等人那段也占大半', waitFrac > 0.9, waitFrac.toFixed(2))
+check('失败的那一行收在失败色上', await page.locator(`[data-run-id="${FAILED_ROW}"] [data-shape-end=failed]`).count() === 1)
+check('缩略条的 title 写着执行和等人',
+  /执行 .+ · 等人 .+/.test(await page.locator(`[data-run-id="${TRACE}"] [data-run-shape]`).getAttribute('title').catch(() => '') ?? ''))
+const cancelText = (await page.locator(`[data-run-id="${CANCEL_ROW}"]`).innerText().catch(() => '')).replace(/\s+/g, ' ')
+check('已取消写原因，不重复「用户取消」', cancelText.includes('在等审批时放弃了这次运行') && !cancelText.includes('用户取消'), cancelText.slice(0, 80))
+fakes.delete('GET /api/runs')
+
+console.log('\n=== 工作流筛选：未保存的工作流 ===')
+await page.goto(`${WEB}/runs`, { waitUntil: 'networkidle' })
+await rowsOf().first().waitFor()
+const wfOptions = await page.locator('[data-runs-workflow] option').evaluateAll((els) => els.map((e) => e.value))
+check('工作流下拉里有「未保存的工作流」', wfOptions.includes('__none__'))
+if (wfOptions.includes('__none__')) {
+  await listAfter(() => page.locator('[data-runs-workflow]').selectOption('__none__'), (p) => p.get('workflow_id') === '__none__')
+  check('地址记下 ?wf=__none__', new URL(page.url()).searchParams.get('wf') === '__none__')
+  const names = await page.locator('[data-runs-list] [data-run-id] > div:first-of-type').evaluateAll((els) => els.map((e) => e.textContent ?? ''))
+  check('筛出来的都是未保存的工作流', names.length > 0 && names.every((n) => n.includes('未保存的工作流')), `${names.length} 行`)
+  await page.locator('[data-runs-workflow]').selectOption('')
+  await settle()
+}
+
+// ------------------------------------------------------------------ 放弃
+
+if (pending.length) {
+  console.log('\n=== 等审批的运行就地放弃 ===')
+  const target = pending[0]
+  const full = await getJson(`/runs/${target.run_id}`)
+  const evs = await getJson(`/runs/${target.run_id}/events`)
+  await page.goto(`${WEB}/runs/${target.run_id}`, { waitUntil: 'networkidle' })
+  await page.locator('[data-run-detail][data-run-code=waiting]').waitFor({ timeout: 8000 }).catch(() => {})
+  const abandon = page.locator('[data-run-banner=waiting] [data-action=abandon]')
+  check('等审批的横幅上有「放弃这次运行」', await abandon.count() === 1)
+  if (await abandon.count()) {
+    let cancelCalls = 0
+    fakes.set(`POST /api/runs/${target.run_id}/cancel`, () => { cancelCalls++; return { status: 200, json: { ok: true, status: 'cancelled' } } })
+    await abandon.click()
+    const ask = page.getByRole('dialog')
+    await ask.waitFor({ timeout: 5000 }).catch(() => {})
+    check('放弃前要确认，并写清待审批一并关闭', (await ask.innerText().catch(() => '')).includes('待审批'))
+    const tc = Date.now() / 1000
+    fakes.set(`GET /api/runs/${target.run_id}`, () => ({ status: 200, json: {
+      ...full, status: 'cancelled', error: '用户取消：在等审批时放弃了这次运行', finished_at: iso(tc),
+    } }))
+    fakes.set(`GET /api/runs/${target.run_id}/events`, () => ({ status: 200, json: [...evs, {
+      seq: (evs.at(-1)?.seq ?? 0) + 1, type: 'run.cancelled', node_id: null, ts: tc,
+      data: { actor: '张工', message: '放弃了这次运行，1 条待审批一并关闭', timing: { wall_ms: 1000, active_ms: 10, wait_ms: 990 } },
+    }] }))
+    fakes.set('GET /api/approvals', (url) => ({
+      status: 200, json: pending.filter((a) => a.id !== target.id && (!url.searchParams.get('run_id') || a.run_id === url.searchParams.get('run_id'))),
+    }))
+    await ask.getByRole('button', { name: '放弃这次运行' }).click({ timeout: 5000 }).catch(() => {})
+    const gone = await page.waitForFunction(
+      () => document.querySelector('[data-run-detail]')?.getAttribute('data-run-code') === 'cancelled',
+      null, { timeout: 6000 },
+    ).then(() => true, () => false)
+    check('发的是 POST /cancel', cancelCalls === 1)
+    check('状态变成已取消', gone)
+    const status = (await page.locator('[data-run-telemetry]').innerText().catch(() => '')).replace(/\s+/g, ' ')
+    check('状态格写着谁放弃的', status.includes('张工') && status.includes('放弃'), status.slice(0, 60))
+    fakes.delete(`POST /api/runs/${target.run_id}/cancel`)
+    fakes.delete(`GET /api/runs/${target.run_id}`)
+    fakes.delete(`GET /api/runs/${target.run_id}/events`)
+    fakes.delete('GET /api/approvals')
+  }
+}
+
+// ------------------------------------------------------------------ 等了几天、窄屏
+
+console.log('\n=== 等了几天的审批、1024 宽 ===')
+// 停在审批上十天多：等人要写「10 天 05 小时」，而不是被截成「245 小时 3…」；游标写「T+10 天 05:30:07」，
+// 不写「T+245:30:07.3」（同一行的墙钟、等人写的是「10 天」，而且放不下）。等人的时长在涨，游标要走
+const STALE = 'fake0stalewait0000000000000000'
+const tw = Date.now() / 1000 - 10 * 86400 - 5.5 * 3600
+const longApproval = {
+  id: 'fake0longappr0000000000000000', run_id: STALE, node_id: 'gate', mode: 'approve', title: '放行吗？',
+  payload: { kind: 'human_node', node_id: 'gate', mode: 'approve', title: '放行吗？', message: '', schema: {}, context: {} },
+  status: 'pending', response: {}, created_at: iso(tw + 3.3), resolved_by: null, resolved_at: null,
+  workflow_id: wfHost.id, workflow_name: '订单日报', node_label: '人工审批', run_status: 'interrupted', run_class: 'exploratory',
+}
+fakes.set(`GET /api/runs/${STALE}`, () => ({ status: 200, json: {
+  ...traceRun(STALE), status: 'interrupted', output: null, finished_at: null, created_at: iso(tw), started_at: iso(tw),
+  usage: { input_tokens: 1200, output_tokens: 300, cost_usd: 0.004 },
+} }))
+fakes.set(`GET /api/runs/${STALE}/events`, () => ({ status: 200, json: traceEvents().slice(0, 11).map((e) => ({ ...e, ts: e.ts - tt + tw })) }))
+fakes.set(`GET /api/runs/${STALE}/graph`, () => ({ status: 200, json: { graph: traceGraph, workflow_id: wfHost.id, version: null } }))
+fakes.set(`GET /api/runs/${STALE}/artifacts`, () => ({ status: 200, json: [] }))
+fakes.set('GET /api/approvals', (url) => ({
+  status: 200, json: !url.searchParams.get('run_id') || url.searchParams.get('run_id') === STALE ? [longApproval] : [],
+}))
+const fits = (sel) => page.locator(sel).evaluateAll((els) => els.length > 0 && els.every((e) => e.scrollWidth <= e.clientWidth + 0.5))
+const DAY_AT = /^T\+10 天 05:3\d:\d\d$/
+// 1300 宽：详情区 836px，排成一行的话一格只剩 78px，「10 天 05 小时」放不下，得排两行
+for (const [w, h] of [[1440, 900], [1300, 860], [1024, 768]]) {
+  await page.setViewportSize({ width: w, height: h })
+  await page.goto(`${WEB}/runs/${STALE}?view=trace`, { waitUntil: 'networkidle' })
+  await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+  const waitRead = await readout('wait')
+  check(`${w} 宽：等人写成跨天的跨度（10 天 05 小时），不被截断`,
+    waitRead.startsWith('10 天 05 小时') && await fits('[data-trace-readout] [data-readout=wait]'), waitRead)
+  const atRead = (await readout('at')).trim()
+  check(`${w} 宽：游标写成跨天的时刻（T+10 天 05:30:xx），不被截断`,
+    DAY_AT.test(atRead) && await fits('[data-trace-readout] [data-readout=at]'), atRead)
+}
+await page.setViewportSize({ width: 1440, height: 900 })
+await page.goto(`${WEB}/runs/${STALE}?view=trace`, { waitUntil: 'networkidle' })
+await page.locator('[data-trace-readout]').waitFor({ timeout: 5000 }).catch(() => {})
+check('「此刻」的等审批也写跨天', (await page.locator('[data-trace-now] [data-now-node=gate]').innerText().catch(() => '')).includes('10 天 05 小时'))
+const waitAtA = await readout('at')
+// 跨天的时刻只写到秒：隔一秒多再读
+await page.waitForTimeout(1100)
+const waitAtB = await readout('at')
+check('停在审批上时游标照样跟着现在走（和坞里同一拍）', await mode() === '实时' && waitAtA !== waitAtB, `${waitAtA} → ${waitAtB}`.replace(/\s+/g, ' '))
+
+// 去审批卡：审批卡在时间线里。从航迹、工件、原始事件点过来，要切回时间线、描一下卡片，
+// 并且焦点进到卡片里——键盘和读屏用户才接得着。视图经地址切，提交比点击晚好几帧
+console.log('\n=== 去审批卡：从哪个视图点都能把焦点送进卡片 ===')
+for (const [from, label] of [['trace', '航迹'], ['artifacts', '工件'], ['raw', '原始事件'], ['stream', '时间线']]) {
+  await page.goto(`${WEB}/runs/${STALE}${from === 'trace' || from === 'artifacts' ? `?view=${from}` : ''}`, { waitUntil: 'networkidle' })
+  await page.locator('[data-run-banner=waiting] [data-action=jump-approval]').waitFor({ timeout: 5000 }).catch(() => {})
+  if (from === 'raw') {
+    await page.locator('[data-action=raw]').click().catch(() => {})
+    await page.locator('[data-raw-events]').waitFor({ timeout: 3000 }).catch(() => {})
+  }
+  await page.locator('[data-run-banner=waiting] [data-action=jump-approval]').click().catch(() => {})
+  const into = await page.waitForFunction(() => !!document.activeElement?.closest('[data-approval-card]'), null, { timeout: 3000 })
+    .then(() => true, () => false)
+  const ringed = await page.locator(`[data-approval-card="${longApproval.id}"].runs-focus-ring`).count()
+  const back = await viewTab('stream').getAttribute('aria-selected').catch(() => null) === 'true'
+  check(`从「${label}」点「去审批卡」：回到时间线，焦点进了审批卡，卡片描了一下边`, into && ringed === 1 && back,
+    `时间线 ${back ? '是' : '否'} · 描边 ${ringed} · 焦点在 ${await page.evaluate(() => {
+      const a = document.activeElement
+      return `${a?.tagName}${a?.getAttribute('data-action') ? `[${a.getAttribute('data-action')}]` : ''}`
+    })}`)
+}
+
+// 批过的十天等待：「审批已处理」「运行完成」都在 T+10 天之后。关键时刻里时刻那一栏按最宽的
+// 一条排齐，不压到后面的徽标上；终态的游标放得下
+console.log('\n=== 跨天的关键时刻 ===')
+const LONGDONE = 'fake0longdone00000000000000000'
+const td = Date.now() / 1000 - 11 * 86400
+const LONG_S = 10 * 86400
+const longTiming = { wall_ms: (6.2 + LONG_S) * 1000, active_ms: 6200, wait_ms: LONG_S * 1000 }
+fakes.set(`GET /api/runs/${LONGDONE}`, () => ({ status: 200, json: {
+  ...traceRun(LONGDONE), created_at: iso(td), started_at: iso(td), finished_at: iso(td + 6.2 + LONG_S),
+  usage: { input_tokens: 2000, output_tokens: 800, cost_usd: 0.007, duration_ms: 6200, ...longTiming },
+} }))
+fakes.set(`GET /api/runs/${LONGDONE}/events`, () => ({ status: 200, json: traceEvents().map((e) => ({
+  ...e,
+  ts: e.ts - tt + td + (e.seq >= 12 ? LONG_S - WAIT_S : 0),
+  ...(e.type === 'run.finished' ? { data: { ...e.data, timing: longTiming } } : {}),
+})) }))
+fakes.set(`GET /api/runs/${LONGDONE}/graph`, () => ({ status: 200, json: { graph: traceGraph, workflow_id: wfHost.id, version: null } }))
+fakes.set(`GET /api/runs/${LONGDONE}/artifacts`, () => ({ status: 200, json: [] }))
+const momentsAligned = () => page.locator('[data-trace-moments] [data-moment]').evaluateAll((els) => {
+  const cols = els.map((b) => {
+    const at = b.querySelector('[data-moment-at]')
+    return { at: at.getBoundingClientRect(), fit: at.scrollWidth <= at.clientWidth + 0.5, mark: at.nextElementSibling.getBoundingClientRect().left }
+  })
+  return cols.length > 0 && cols.every((c) => c.fit && c.at.right <= c.mark + 0.5 && Math.abs(c.mark - cols[0].mark) < 0.5)
+})
+for (const [w, h] of [[1440, 900], [1024, 768]]) {
+  await page.setViewportSize({ width: w, height: h })
+  await page.goto(`${WEB}/runs/${LONGDONE}?view=trace`, { waitUntil: 'networkidle' })
+  await page.locator('[data-trace-moments]').waitFor({ timeout: 5000 }).catch(() => {})
+  const texts = (await page.locator('[data-trace-moments] [data-moment]').allInnerTexts().catch(() => [])).map((t) => t.replace(/\s+/g, ' '))
+  check(`${w} 宽：跨天的关键时刻写「T+10 天 00:00:03」，时刻一栏排齐、不压到徽标上`,
+    texts.some((t) => t.includes('T+10 天 00:00:03') && t.includes('审批已处理') && t.includes('等了 10 天')) && await momentsAligned(),
+    texts.join(' | '))
+  check(`${w} 宽：终态的游标写「T+10 天 00:00:06」，放得下`,
+    (await readout('at')).trim() === 'T+10 天 00:00:06' && await fits('[data-trace-readout] [data-readout=at]'), await readout('at'))
+}
+
+// 屏幕矮、节点多：九个节点的失败运行，横幅占去一截。读数区先拿够它要的，默认选中的失败
+// 节点卡、关键时刻都得在首屏；坞拿剩下的，不矮过能拖到的最矮，泳道在坞里滚
+console.log('\n=== 屏幕矮、节点多：读数区不被航迹坞压住 ===')
+const FAN = 'fake0fanfail000000000000000000'
+const FAN_ERROR = '节点「查询订单」失败：模型服务出错了（HTTP 500）'
+const FAN_STEPS = ['check', 'score', 'route', 'publish', 'archive']
+const fanGraph = {
+  nodes: [...traceGraph.nodes, ...FAN_STEPS.map((id, i) => ({
+    id, type: 'llm', position: { x: 800 + i * 200, y: 0 }, data: { label: `步骤 ${i + 1}`, config: {} },
+  }))],
+  edges: [...traceGraph.edges, ...FAN_STEPS.map((id, i) => ({ source: i ? FAN_STEPS[i - 1] : 'sum', target: id }))],
+}
+fakes.set(`GET /api/runs/${FAN}`, () => ({ status: 200, json: {
+  ...traceRun(FAN), status: 'failed', output: null, error: FAN_ERROR, error_node_id: 'query',
+  usage: { input_tokens: 0, output_tokens: 0, cost_usd: 0, duration_ms: 1200, wall_ms: 1200, active_ms: 1200, wait_ms: 0 },
+  finished_at: iso(tt + 1.2),
+} }))
+fakes.set(`GET /api/runs/${FAN}/events`, () => ({ status: 200, json: [
+  ...traceEvents().slice(0, 4),
+  { seq: 5, type: 'node.failed', node_id: 'query', ts: tt + 1.1, data: { error: FAN_ERROR, duration_ms: 800 } },
+  { seq: 6, type: 'run.failed', node_id: null, ts: tt + 1.2, data: {
+    error: FAN_ERROR, node_id: 'query', timing: { wall_ms: 1200, active_ms: 1200, wait_ms: 0 } } },
+] }))
+fakes.set(`GET /api/runs/${FAN}/graph`, () => ({ status: 200, json: { graph: fanGraph, workflow_id: wfHost.id, version: null } }))
+fakes.set(`GET /api/runs/${FAN}/artifacts`, () => ({ status: 200, json: [] }))
+const firstScreen = () => page.evaluate(() => {
+  const read = document.querySelector('[data-trace-readout]')?.getBoundingClientRect()
+  const whole = (sel) => {
+    const b = document.querySelector(sel)?.getBoundingClientRect()
+    return !!b && !!read && b.top >= read.top - 0.5 && b.bottom <= read.bottom + 1
+  }
+  return {
+    card: whole('[data-trace-node=query]'), moments: whole('[data-trace-moments]'),
+    dock: Math.round(document.querySelector('[data-run-trace] section[aria-label="航迹"]')?.getBoundingClientRect().height ?? 0),
+  }
+})
+for (const [w, h] of [[1440, 900], [1180, 800], [1024, 768]]) {
+  await page.setViewportSize({ width: w, height: h })
+  await page.goto(`${WEB}/runs/${FAN}?view=trace`, { waitUntil: 'networkidle' })
+  await page.locator('[data-trace-node=query]').waitFor({ timeout: 5000 }).catch(() => {})
+  await page.waitForTimeout(150)
+  const seen = await firstScreen()
+  check(`${w}×${h}：失败节点卡、关键时刻整块都在首屏，坞不矮过 132px`, seen.card && seen.moments && seen.dock >= 132, JSON.stringify(seen))
+}
+// 再矮（或者横幅更高）就放不下了：坞不再让，读数区底边淡出，看得出下面还有
+await page.setViewportSize({ width: 1024, height: 640 })
+await page.waitForTimeout(300)
+check('1024×640：读数区放不下时底边淡出，提示能往下滚', await page.locator('[data-trace-readout][data-more]').count() === 1)
+
+// 1024 宽：详情区只有 600px，读数一格不到 70px 的字宽
+await page.setViewportSize({ width: 1024, height: 768 })
+fakes.set('GET /api/runs', () => ({ status: 200, json: [traceRun(TRACE), ...listTop] }))
+await page.goto(`${WEB}/runs/${TRACE}`, { waitUntil: 'networkidle' })
+await page.locator('[data-run-telemetry]').waitFor({ timeout: 5000 }).catch(() => {})
+const cut = await page.locator('[data-run-telemetry] [data-telemetry]').evaluateAll((els) =>
+  els.filter((e) => e.scrollWidth > e.clientWidth + 0.5).map((e) => `${e.getAttribute('data-telemetry')}「${e.textContent}」`))
+check('1024 宽：详情头的读数没有一格被截成省略号', cut.length === 0, cut.join('、') || '全部放得下')
+const footH = await page.locator(`[data-runs-list] [data-run-id="${TRACE}"] [data-run-duration]`).evaluate(
+  (el) => el.parentElement.getBoundingClientRect().height).catch(() => 99)
+check('1024 宽：列表行底下那一行不折行（时长太长就截断，用量不被拆开）', footH <= 18, `${footH}px`)
+await page.setViewportSize({ width: 1440, height: 900 })
+fakes.delete('GET /api/runs')
+fakes.delete('GET /api/approvals')
+
 console.log('\n=== 收尾 ===')
-check('只有伪造过的写请求', writes.every((w) => /\/continue$|\/cancel$|\/copilot\/from-run$|DELETE \/api\/runs\/fake0|^POST \/api\/runs$/.test(w)),
+// 提取模板之后会跳进画布：画布一打开就拿图去做校验、变量分析，这两个是带图的只读 POST
+// （同样被探针拦下，不落库）。赶上它们发出来之前就离开了画布的话就没有
+check('只有伪造过的写请求', writes.every((w) => /\/continue$|\/cancel$|\/copilot\/from-run$|DELETE \/api\/runs\/fake0|^POST \/api\/runs$|^POST \/api\/workflows\/(validate|variables)$/.test(w)),
   writes.join(', '))
 check('没有未捕获的运行时错误', errors.length === 0, errors[0] ?? '')
 
diff --git a/scripts/check-shell.mjs b/scripts/check-shell.mjs
index 0c723dbc..279c67ba 100644
--- a/scripts/check-shell.mjs
+++ b/scripts/check-shell.mjs
@@ -82,6 +82,8 @@ async function open({ theme = 'dark', state }) {
     if (state.offline) return route.abort('connectionrefused')
     // 后端连得上但不回：/health 照常，其余请求一直挂着
     if (state.hang && url.pathname !== '/api/health') return
+    // 只卡一张表：别的照常回
+    if (state.hangPath === url.pathname) return
     if (r.method() !== 'GET') {
       state.writes.push({ method: r.method(), path: url.pathname, body: r.postData() })
       return route.fulfill({ json: {} })
@@ -98,11 +100,19 @@ async function open({ theme = 'dark', state }) {
 const nav = (page) => page.locator('nav[aria-label="主导航"]')
 const waitNav = (page) => nav(page).waitFor({ timeout: 15000 })
 const isMac = process.platform === 'darwin'
+// 只跑其中几段：CHECK_ONLY=离开前确认,启动页 node scripts/check-shell.mjs（按段名包含匹配）
+const ONLY = process.env.CHECK_ONLY?.split(',').map((s) => s.trim()).filter(Boolean)
+const want = (name) => !ONLY?.length || ONLY.some((k) => name.includes(k))
+/** 这一段要跑就打出段标题、返回 true */
+const section = (name, title) => {
+  if (!want(name)) return false
+  console.log(title)
+  return true
+}
 const MOD = isMac ? 'Meta' : 'Control'
 
 // ---------------------------------------------------------------------------
-console.log('=== 导航 ===')
-{
+if (section('导航', '=== 导航 ===')) {
   const state = { approvals: PENDING, offline: false, writes: [] }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/chat`)
@@ -187,8 +197,7 @@ console.log('=== 导航 ===')
 }
 
 // ---------------------------------------------------------------------------
-console.log('\n=== 待审批徽标 ===')
-for (const theme of ['dark', 'light']) {
+if (section('待审批徽标', '\n=== 待审批徽标 ===')) for (const theme of ['dark', 'light']) {
   const state = { approvals: PENDING, offline: false, writes: [] }
   const { ctx, page } = await open({ theme, state })
   await page.goto(`${WEB}/chat`)
@@ -225,8 +234,7 @@ for (const theme of ['dark', 'light']) {
 }
 
 // ---------------------------------------------------------------------------
-console.log('\n=== 404 ===')
-{
+if (section('404', '\n=== 404 ===')) {
   const state = { approvals: [], offline: false, writes: [] }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/does-not-exist/at-all`)
@@ -244,8 +252,7 @@ console.log('\n=== 404 ===')
 }
 
 // ---------------------------------------------------------------------------
-console.log('\n=== 标签页标题、favicon、后台提醒 ===')
-{
+if (section('标签页标题', '\n=== 标签页标题、favicon、后台提醒 ===')) {
   const state = { approvals: [], offline: false, writes: [] }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/runs`)
@@ -331,8 +338,7 @@ console.log('\n=== 标签页标题、favicon、后台提醒 ===')
 }
 
 // ---------------------------------------------------------------------------
-console.log('\n=== ⌘K 命令面板 ===')
-{
+if (section('⌘K 命令面板', '\n=== ⌘K 命令面板 ===')) {
   const state = { approvals: PENDING, offline: false, writes: [] }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/runs`)
@@ -374,6 +380,22 @@ console.log('\n=== ⌘K 命令面板 ===')
     check('点工作流进它的画布', await page.waitForURL(new RegExp(`/studio/${wf.id}`), { timeout: 5000 }).then(() => true, () => false), page.url())
   }
 
+  // 页面刚挂载时的自动聚焦（比如画布助手的输入框）会把焦点从开着的面板里抢走，
+  // 之后打的字、按的 Esc 就都落到了面板底下
+  await page.keyboard.press(`${MOD}+KeyK`)
+  await dialog.waitFor({ timeout: 3000 })
+  const stolen = await page.evaluate(() => {
+    const el = document.querySelector('main textarea') ?? document.querySelector('main input, main button, nav a')
+    el?.focus()
+    return el?.tagName ?? null
+  })
+  check('面板开着时焦点被页面抢走，会回到搜索框', await dialog.getByRole('combobox').evaluate((el) => el === document.activeElement),
+    `${stolen} → ${await page.evaluate(() => document.activeElement?.tagName)}`)
+  await page.keyboard.press('Escape')
+  check('……Esc 照样关掉面板', await dialog.waitFor({ state: 'detached', timeout: 3000 }).then(() => true, () => false))
+  // 上面没过时面板还开着：⌘K 再按一下把它收掉，后面几项照常跑
+  if (await dialog.count()) await page.keyboard.press(`${MOD}+KeyK`)
+
   await page.keyboard.press(`${MOD}+KeyK`)
   await dialog.getByRole('combobox').fill('zzqq没有这个东西')
   check('没结果时说清楚', (await dialog.innerText()).includes('没有匹配'))
@@ -403,8 +425,7 @@ console.log('\n=== ⌘K 命令面板 ===')
 }
 
 // ---------------------------------------------------------------------------
-console.log('\n=== ? 快捷键说明 ===')
-{
+if (section('快捷键说明', '\n=== ? 快捷键说明 ===')) {
   const state = { approvals: [], offline: false, writes: [] }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/studio`)
@@ -428,8 +449,117 @@ console.log('\n=== ? 快捷键说明 ===')
 }
 
 // ---------------------------------------------------------------------------
-console.log('\n=== 离线横幅 ===')
-{
+if (section('离开前确认', '\n=== 离开前确认 ===')) {
+  // 页面有没保存的改动时登记一道守卫（lib/leave）。以前设置页只在捕获阶段拦 <a> 的
+  // 点击：⌘K、⌥ 数字直接调 navigate()，浏览器后退也不走 <a>，改到一半的表单就这么丢了。
+  // 这里用 dev 构建挂出的 window.__leave 登记一道测试守卫：每问一次记一笔，答案由脚本给
+  const state = { approvals: PENDING, offline: false, writes: [] }
+  const { ctx, page } = await open({ state })
+  await page.goto(`${WEB}/runs`)
+  await waitNav(page)
+  const hooked = await page.waitForFunction(() => !!window.__leave, null, { timeout: 5000 }).then(() => true, () => false)
+  check('dev 构建挂出了 window.__leave', hooked)
+  if (hooked) {
+    await page.evaluate(() => {
+      window.__asks = []
+      window.__answer = null
+      window.__unguard = window.__leave.register({
+        confirm: (next) => new Promise((resolve) => {
+          window.__asks.push(next ? next.pathname + next.search : null)
+          window.__answer = resolve
+        }),
+      })
+    })
+    const asks = () => page.evaluate(() => window.__asks.length)
+    const asked = (n) => page.waitForFunction((n) => window.__asks.length >= n, n, { timeout: 3000 }).then(() => true, () => false)
+    const answer = (ok) => page.evaluate((ok) => { const r = window.__answer; window.__answer = null; r?.(ok) }, ok)
+    const where = () => { const u = new URL(page.url()); return u.pathname + u.search }
+    const settle = () => page.waitForTimeout(250)
+    const dialog = page.getByRole('dialog', { name: '命令面板' })
+
+    await page.keyboard.press(`${MOD}+KeyK`)
+    await dialog.getByRole('combobox').fill('设置')
+    await page.keyboard.press('Enter')
+    check('⌘K 跳页先问守卫，问的时候地址不动', await asked(1) && where().startsWith('/runs'), `${await asks()} 次 · ${where()}`)
+    check('守卫拿得到要去哪', (await page.evaluate(() => window.__asks[0])) === '/settings', await page.evaluate(() => window.__asks[0]))
+    await answer(false)
+    await settle()
+    check('选「留下」：还在原地，面板也关了', where().startsWith('/runs') && (await dialog.count()) === 0, where())
+
+    await page.evaluate(() => document.activeElement?.blur())
+    await page.keyboard.press('Alt+Digit1')
+    check('⌥1 切页先问守卫', await asked(2) && where().startsWith('/runs'), where())
+    await answer(true)
+    check('选「离开」：去到问数据', await page.waitForURL(/\/chat/, { timeout: 5000 }).then(() => true, () => false), where())
+
+    await nav(page).locator('a[href="/data"]').click()
+    check('点左侧导航先问守卫', await asked(3))
+    await answer(false)
+    await settle()
+    check('选「留下」：地址不变', where().startsWith('/chat'), where())
+
+    await page.evaluate(() => history.back())
+    check('浏览器后退也先问守卫', await asked(4))
+    await answer(false)
+    await page.waitForTimeout(400)
+    check('选「留下」：地址退回原处', where().startsWith('/chat'), where())
+    await page.evaluate(() => history.back())
+    await asked(5)
+    await answer(true)
+    check('后退时选「离开」：真的退回去了', await page.waitForURL(/\/runs/, { timeout: 5000 }).then(() => true, () => false), where())
+
+    const before = await asks()
+    await page.locator('[data-approval-badge]').click()
+    await page.waitForURL(/tab=approvals/, { timeout: 5000 }).catch(() => {})
+    check('同一页里只换 ?tab 不问', (await asks()) === before && /\/runs\?tab=approvals/.test(where()), `${await asks() - before} 次 · ${where()}`)
+
+    // 先建东西再跳的命令：得先问，不然人点了「留下」，会话已经建出来了
+    state.writes.length = 0
+    await page.keyboard.press(`${MOD}+KeyK`)
+    await dialog.getByRole('combobox').fill('新对话')
+    await page.keyboard.press('Enter')
+    check('⌘K「新对话」先问守卫', await asked(before + 1))
+    check('……问的时候还没建会话', !state.writes.some((w) => w.method === 'POST' && w.path === '/api/conversations'),
+      state.writes.map((w) => `${w.method} ${w.path}`).join(', '))
+    await answer(false)
+    await settle()
+    check('选「留下」：不建会话、不跳', !state.writes.some((w) => w.method === 'POST' && w.path === '/api/conversations')
+      && where().startsWith('/runs'), where())
+
+    await page.keyboard.press(`${MOD}+KeyK`)
+    await dialog.getByRole('combobox').fill('新建工作流')
+    await page.keyboard.press('Enter')
+    check('⌘K「新建工作流」先问守卫，再问名字', await asked(before + 2)
+      && (await page.getByRole('dialog', { name: '新建工作流' }).count()) === 0)
+    await answer(false)
+    await settle()
+    check('选「留下」：不弹起名框', (await page.getByRole('dialog', { name: '新建工作流' }).count()) === 0 && where().startsWith('/runs'))
+
+    // 关页、刷新：守卫在时浏览器会问（它只给通用文案），撤了就不问
+    const unloadAsks = []
+    page.on('dialog', (d) => { unloadAsks.push(d.type()); void d.dismiss() })
+    await page.close({ runBeforeUnload: true })
+    await page.waitForTimeout(500)
+    check('有守卫时关页，浏览器先问', unloadAsks.includes('beforeunload') && !page.isClosed(), unloadAsks.join(',') || '没问')
+
+    await page.evaluate(() => window.__unguard())
+    const n = await asks()
+    await page.evaluate(() => document.activeElement?.blur())
+    await page.keyboard.press('Alt+Digit1')
+    check('撤掉守卫后照常切页，不再问', await page.waitForURL(/\/chat/, { timeout: 5000 }).then(() => true, () => false)
+      && (await asks()) === n, where())
+    unloadAsks.length = 0
+    await page.close({ runBeforeUnload: true })
+    // 页面这回真关了，只能在外面等
+    await new Promise((r) => setTimeout(r, 500))
+    check('撤掉守卫后关页不再问', unloadAsks.length === 0 && page.isClosed(), unloadAsks.join(','))
+  }
+  check('没有未捕获的运行时错误', page.errors.length === 0, page.errors[0] ?? '')
+  await ctx.close()
+}
+
+// ---------------------------------------------------------------------------
+if (section('离线横幅', '\n=== 离线横幅 ===')) {
   const state = { approvals: [], offline: false, writes: [] }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/chat`)
@@ -440,7 +570,11 @@ console.log('\n=== 离线横幅 ===')
   const banner = page.locator('main').getByText('后端未连接')
   check('断网后出横幅', await banner.waitFor({ timeout: 15000 }).then(() => true, () => false))
   check('横幅是主区第一个孩子（toast 才会跟着下移）',
-    await page.evaluate(() => document.querySelector('main')?.firstElementChild?.getAttribute('role') === 'alert'))
+    // role=alert 只包不变的那几句（整块重念会把倒计时也念一遍），外层认 data-offline-banner
+    await page.evaluate(() => document.querySelector('main')?.firstElementChild?.hasAttribute('data-offline-banner') === true))
+  const alertText = await page.evaluate(() => document.querySelector('[data-offline-banner] [role="alert"]')?.textContent ?? null)
+  check('横幅的播报区只有不变的那几句：倒计时不在里面', alertText != null && alertText.includes('后端未连接') && !/秒后/.test(alertText)
+    && /秒后自动重试/.test(await page.locator('[data-offline-banner]').innerText()), alertText ?? '没有 role=alert')
   check('遥测点变成离线', /离线/.test(await nav(page).locator('[data-telemetry]').innerText()))
   state.offline = false
   await page.getByRole('button', { name: '立即重试' }).first().click()
@@ -463,8 +597,7 @@ const bootLiveRegions = (page) => page.evaluate(() => {
 })
 
 // ---------------------------------------------------------------------------
-console.log('\n=== 启动页 ===')
-for (const theme of ['dark', 'light']) {
+if (section('启动页', '\n=== 启动页 ===')) for (const theme of ['dark', 'light']) {
   const state = { approvals: [], offline: true, writes: [] }
   const { ctx, page } = await open({ theme, state })
   await page.goto(`${WEB}/chat`)
@@ -488,20 +621,27 @@ for (const theme of ['dark', 'light']) {
   await ctx.close()
 }
 
-{
+if (want('启动页')) {
   // 后端连着、只有一张表报错：照常进，但要说出来，不然那张表对应的下拉就是空的，看着像"没有"
   const state = { approvals: [], offline: false, writes: [], broken: '/api/skills' }
   const { ctx, page } = await open({ state })
   await page.goto(`${WEB}/chat`)
   await waitNav(page)
-  const warned = await page.getByText(/有 1 项没加载成功：Skill（500）/).waitFor({ timeout: 5000 }).then(() => true, () => false)
+  const warn = page.getByText(/有 1 项没加载成功（Skill 500）/)
+  const warned = await warn.waitFor({ timeout: 5000 }).then(() => true, () => false)
   check('部分请求报错：照常进页面，并说出哪一项没加载', warned)
   const tone = await nav(page).locator('[data-telemetry]').getAttribute('data-tone')
   check('遥测点记为「降级」（琥珀），不是一片绿', tone === '降级', tone)
+  // 那张表一直是空的，提示就一直在：4 秒一闪就没，人还是会对着空列表去新建
+  await page.waitForTimeout(4500)
+  check('提示常驻，直到那张表取回来', await warn.isVisible())
+  state.broken = null
+  await page.locator('[role="status"] > div', { hasText: '没加载成功' }).getByRole('button', { name: '重试' }).click({ timeout: 5000 }).catch(() => {})
+  check('重试取回来：提示撤掉', await warn.waitFor({ state: 'detached', timeout: 5000 }).then(() => true, () => false))
   await ctx.close()
 }
 
-{
+if (want('启动页')) {
   // 后端连得上、请求却卡着不回：「先进去看看」之后不能是一片绿加一屏「还没有工作流」
   const state = { approvals: [], offline: false, writes: [], hang: true }
   const { ctx, page } = await open({ state })
@@ -515,6 +655,9 @@ for (const theme of ['dark', 'light']) {
   await enter.click()
   await waitNav(page)
   const telemetry = nav(page).locator('[data-telemetry]')
+  // 这一路唯一的 /health 探活和「先进去看看」同时出现，按钮点得快时它还在路上
+  await page.waitForFunction(() => document.querySelector('[data-telemetry]')?.getAttribute('data-telemetry') !== 'checking', null, { timeout: 5000 })
+    .catch(() => {})
   const tone = await telemetry.getAttribute('data-tone')
   check('进去以后遥测点不是「在线」，而是「加载中」', tone === '加载中', `${tone} / ${await telemetry.innerText()}`)
   const warn = page.getByText(/没取回来.*先别新建/)
@@ -537,7 +680,62 @@ for (const theme of ['dark', 'light']) {
   await ctx.close()
 }
 
-{
+if (want('启动页')) {
+  // 只有一张表卡住（后端连着）：每个请求最多等 15 秒，到点记成出错。遥测点从「加载中」
+  // 转成「降级」，提示也得跟着改口说「没加载成功」，而不是悄悄撤掉——那张表还是空的
+  const state = { approvals: [], offline: false, writes: [], hangPath: '/api/tools' }
+  const { ctx, page } = await open({ state })
+  await page.goto(`${WEB}/chat`)
+  // 第一次全量加载要等那一项超时才算落定，启动页到点自己放人进来
+  const entered = await nav(page).waitFor({ timeout: 25000 }).then(() => true, () => false)
+  check('卡住的那一项超时后，启动页自己放人进来', entered)
+  const warn = page.getByText(/有 1 项没加载成功（工具 超时）.*先别新建/)
+  check('超时的那一项：进门就说它没加载成功，劝先别新建', await warn.waitFor({ timeout: 5000 }).then(() => true, () => false),
+    await warn.innerText().catch(() => '没有这条提示'))
+  const telemetry = nav(page).locator('[data-telemetry]')
+  check('遥测点记为「降级」', (await telemetry.getAttribute('data-tone')) === '降级', await telemetry.getAttribute('data-tone'))
+  await telemetry.click()
+  const row = page.getByRole('dialog', { name: '后端连接' }).locator('[data-check="tools"]')
+  const rowText = (await row.innerText()).replace(/\s+/g, ' ')
+  check('加载清单里那一项写「超时」，不写「连不上」', /超时/.test(rowText), rowText)
+  await page.keyboard.press('Escape')
+  await page.waitForTimeout(4500)
+  check('提示常驻，不会自己消失', await warn.isVisible())
+  state.hangPath = null
+  await page.locator('[role="status"] > div', { hasText: '没加载成功' }).getByRole('button', { name: '重试' }).click({ timeout: 5000 }).catch(() => {})
+  check('重试取回来：提示撤掉', await warn.waitFor({ state: 'detached', timeout: 5000 }).then(() => true, () => false))
+  check('遥测点回到「在线」', await page.waitForFunction(() => document.querySelector('[data-telemetry]')?.getAttribute('data-tone') === '在线', null, { timeout: 8000 })
+    .then(() => true, () => false), await telemetry.getAttribute('data-tone'))
+  check('没有未捕获的运行时错误', page.errors.length === 0, page.errors[0] ?? '')
+  await ctx.close()
+}
+
+if (want('启动页')) {
+  // 取回来过的表，后来的刷新卡住了：手上的列表是真的（失败不清空），遥测点说「加载中」
+  // 就够了，不能再弹「列表可能不全，先别新建」吓人
+  const state = { approvals: [], offline: false, writes: [] }
+  const { ctx, page } = await open({ state })
+  await page.goto(`${WEB}/chat`)
+  await waitNav(page)
+  const telemetry = nav(page).locator('[data-telemetry]')
+  await page.waitForFunction(() => document.querySelector('[data-telemetry]')?.getAttribute('data-tone') === '在线', null, { timeout: 10000 }).catch(() => {})
+  state.hangPath = '/api/tools'
+  await telemetry.click()
+  await page.getByRole('dialog', { name: '后端连接' }).getByRole('button', { name: '重新检测' }).click()
+  await page.keyboard.press('Escape')
+  await page.waitForTimeout(3800)
+  check('刷新卡住：遥测点说「加载中」', (await telemetry.getAttribute('data-tone')) === '加载中', await telemetry.getAttribute('data-tone'))
+  check('……但不弹「先别新建」：那张表之前取回来过', (await page.getByText(/先别新建/).count()) === 0)
+  await telemetry.click()
+  const panel = page.getByRole('dialog', { name: '后端连接' })
+  check('遥测浮层照样写出哪一项还没回来，但不劝别新建', /工具还没回来/.test(await panel.innerText()) && !/先别急着新建/.test(await panel.innerText()),
+    (await panel.innerText()).replace(/\n/g, ' '))
+  await page.keyboard.press('Escape')
+  check('没有未捕获的运行时错误', page.errors.length === 0, page.errors[0] ?? '')
+  await ctx.close()
+}
+
+if (want('启动页')) {
   // 断线时在导航上换了主题：重连后补存进设置，不能被服务端的旧值翻回去
   const state = { approvals: [], offline: true, writes: [] }
   const { ctx, page } = await open({ state })
diff --git a/scripts/check-stream.mjs b/scripts/check-stream.mjs
index 8427e487..a1dbf190 100644
--- a/scripts/check-stream.mjs
+++ b/scripts/check-stream.mjs
@@ -939,6 +939,401 @@ console.log('\n=== 编号列、追问、CSV ===')
   await q.page.close()
 }
 
+// ---------------------------------------------------------------- 第三波
+/** 量一个 CSS 颜色表达式算出来的 rgb，跟元素的实际颜色比 */
+const colorOf = (page, v) => page.evaluate((expr) => {
+  const probe = document.createElement('span')
+  probe.style.color = expr
+  document.body.append(probe)
+  const c = getComputedStyle(probe).color
+  probe.remove()
+  return c
+}, v)
+const count = (text, needle) => text.split(needle).length - 1
+
+console.log('\n=== 协作团队用完轮数：泳道、头部、报错（NI-5、REQ-3A-3）===')
+for (const [w, dense, label] of [[1100, '0', '宽栏'], [380, '1', '窄栏']]) {
+  const { page, errors } = await open(`syn=exhausted&dense=${dense}`, { w, h: 900, name: `exhausted-${dense === '1' ? 'dense' : 'wide'}` })
+  const body = await page.locator('body').innerText()
+  const lanes = await page.locator('[data-team-lanes]').innerText().catch(() => '')
+  check(`${label}：泳道头说「用完 2 轮仍未完成」`, lanes.includes('用完 2 轮仍未完成'), lanes.split('\n')[0])
+  check(`${label}：泳道点出从没派到的成员`, lanes.includes('汇总员') && lanes.includes('没派到'), lanes.replace(/\n/g, ' ').slice(0, 120))
+  check(`${label}：最后那次判定不画成第 3 轮`, !/第\s?3\s?轮/.test(lanes), lanes.replace(/\n/g, ' ').slice(0, 160))
+  const cell = await page.evaluate(() => {
+    const b = document.querySelector('[data-team-lanes] button[aria-label^="取数员 第 1 轮"]')
+    return b ? getComputedStyle(b).backgroundColor : ''
+  })
+  check(`${label}：失败的成员格子是失败色`, !!cell && cell === await colorOf(page, 'var(--st-failed)'), cell)
+  check(`${label}：判定那一行说「轮数用完 · 调度者判定：未完成」`, body.includes('轮数用完 · 调度者判定：未完成'))
+  // 报错用 lib/explain 讲清为什么、怎么办，不再原样贴后端那一整句
+  const alert = await page.locator('[data-turn] [role="alert"]').first().innerText().catch(() => '')
+  check(`${label}：报错标题说人话`, alert.startsWith('协作团队用完 2 轮仍未完成'), alert.split('\n')[0])
+  check(`${label}：报错给出怎么办`, alert.includes('最多轮数'), alert.replace(/\n/g, ' ').slice(0, 160))
+  check(`${label}：没有运行时报错`, errors.length === 0, errors.join(' | '))
+  const overflow = await page.evaluate(() => document.documentElement.scrollWidth - document.documentElement.clientWidth)
+  check(`${label}：不横向溢出`, overflow <= 0, `${overflow}px`)
+  await page.close()
+}
+{
+  const { page } = await open('syn=exhausted-degrade', { w: 1100, h: 900, name: 'exhausted-degrade' })
+  const head = await page.locator('[data-turn] .sticky').first().innerText()
+  check('降档交付：头部不是一个安静的「已完成」', head.includes('协作团队没做完'), head.replace(/\n/g, ' '))
+  const lanes = await page.locator('[data-team-lanes]').innerText().catch(() => '')
+  check('降档交付：泳道头说按降档交付', lanes.includes('按降档交付'), lanes.split('\n')[0])
+  const body = await page.locator('body').innerText()
+  check('降档交付：团队那一行说清是降档', body.includes('用完 2 轮仍未完成，按降档交付'))
+  check('降档交付：提醒行给出下一步', body.includes('不能当结论用'))
+  await page.close()
+  const r = await open('syn=exhausted-closing&dense=1', { w: 380, h: 800, name: 'exhausted-closing' })
+  const rb = await r.page.locator('body').innerText()
+  check('最后那次判定进行中：写「调度者在做最后判定」', rb.includes('轮数用完 · 调度者在做最后判定'))
+  check('最后那次判定进行中：不写「第 3 轮」', !rb.includes('第 3 轮'))
+  const rl = await r.page.locator('[data-team-lanes]').innerText().catch(() => '')
+  check('最后那次判定进行中：泳道也说在判定', rl.includes('轮数用完 · 调度者在判定'), rl.split('\n').slice(0, 2).join(' '))
+  await r.page.close()
+}
+
+console.log('\n=== 模型把工具调用写成文字、修复凑数、工具超时（NI-3/4）===')
+{
+  const { page, errors } = await open('syn=markup&dense=1', { w: 380, h: 900, name: 'markup' })
+  const body = await page.locator('body').innerText()
+  const alert = await page.locator('[data-turn] [role="alert"]').first().innerText().catch(() => '')
+  check('报错标题：模型没有真正调用工具', alert.startsWith('模型没有真正调用工具'), alert.split('\n')[0])
+  check('报错说原因和怎么办', alert.includes('当成文字') && alert.includes('绑定'), alert.replace(/\n/g, ' '))
+  check('原始标记不出现在正文里', !body.includes('DSML'))
+  const row = await page.locator('[data-node-id="query"][data-step-status="failed"]').first().innerText().catch(() => '')
+  check('失败的节点行说人话', row.includes('模型没有真正调用工具'), row.replace(/\n/g, ' '))
+  const warn = page.locator('[data-step-code="tool_markup_leak"]').first()
+  const warnText = await warn.innerText().catch(() => '')
+  check('提醒行说人话', warnText.includes('模型把工具调用写成了文字，没有真正执行'), warnText.replace(/\n/g, ' '))
+  check('下一步不用展开就看得到', await warn.locator('[data-step-next]').count() === 1
+    && (await warn.locator('[data-step-next]').innerText()).includes('绑定'))
+  check('没有运行时报错', errors.length === 0, errors.join(' | '))
+  await page.close()
+
+  const rp = await open('syn=repair', { w: 1100, h: 900, name: 'repair' })
+  const rbody = await rp.page.locator('body').innerText()
+  // 两次修复凑出的是同一个值：并成一行「×2」，原因照样写在行上；值不同时分行（见 check-decode）
+  check('每次修复都算上、说出凑出来的值', rbody.includes('让模型修复格式') && /×2/.test(rbody) && rbody.includes('total_count=0'),
+    rbody.split('\n').filter((l) => l.includes('修复') || l.includes('×')).join(' | '))
+  const ralert = await rp.page.locator('[data-turn] [role="alert"]').first().innerText().catch(() => '')
+  check('报错：校验修复被拒绝', ralert.startsWith('校验修复被拒绝'), ralert.split('\n')[0])
+  await rp.page.close()
+
+  const tl = await open('syn=timeout-live&dense=1', { w: 380, h: 700, name: 'timeout-live' })
+  const over = await tl.page.evaluate(() => {
+    const row = document.querySelector('[aria-busy="true"][data-step-status="running"]')
+    const clock = row?.querySelector('[data-over-limit]')
+    return { text: clock?.textContent ?? '', color: clock ? getComputedStyle(clock).color : '' }
+  })
+  check('进行中的查询越过时限要说破', over.text.includes('已超出 30 s 上限'), over.text)
+  check('越过时限的秒表是提醒色', over.color === await colorOf(tl.page, 'var(--st-waiting)'), over.color)
+  await tl.page.close()
+  const td = await open('syn=timeout', { w: 1100, h: 700 })
+  check('超时的查询写明超了多少上限', (await td.page.locator('body').innerText()).includes('超过 30 s 上限，已放弃等待'))
+  await td.page.close()
+}
+
+console.log('\n=== 放弃、结构化的报错、恢复的轮次、出具横幅（REQ-1/5/6、REQ-3A-2）===')
+{
+  const { page } = await open('syn=abandoned', { w: 1100, h: 600, name: 'abandoned' })
+  const mark = await page.locator('[data-phase-mark]').allInnerTexts()
+  check('放弃的运行：分段线说清谁放弃的、一并关了什么', mark.some((t) => t.includes('已取消') && t.includes('张工')
+    && t.includes('1 条待审批一并关闭')), mark.join(' | '))
+  await page.close()
+
+  const s = await open('syn=structured', { w: 1100, h: 600, name: 'structured' })
+  const alert = await s.page.locator('[data-turn] [role="alert"]').first().innerText()
+  // 以前页面拆好的「操作超时」又被翻译一遍：「操作超时 / 操作超时：查询超时…」
+  check('拆好的报错照原样画，标题不重复', count(alert, '操作超时') === 1 && alert.startsWith('操作超时'), alert.replace(/\n/g, ' '))
+  check('原因、怎么办各一行', alert.includes('查询超时：数据库 90 秒没有返回') && alert.includes('缩小时间范围'))
+  check('原文收进技术细节', !alert.includes('OperationalError') && alert.includes('技术细节'))
+  await s.page.close()
+
+  const r = await open('syn=restored', { w: 1100, h: 600 })
+  const head = await r.page.locator('[data-turn] .sticky').first().innerText()
+  check('恢复的轮次：头部照样写几次查询', head.includes('3 次查询'), head.replace(/\n/g, ' '))
+  await r.page.close()
+
+  const i = await open('syn=issued', { w: 1100, h: 900 })
+  check('出具横幅带 data-issuance-banner（画布印章据此滚过来）', await i.page.locator('[data-issuance-banner]').count() === 1)
+  const live = await i.page.locator('[data-turn] [role="status"][aria-live="polite"]').first().innerText()
+  check('读屏也播报出具档位', live.includes('降档出具'), live)
+  await i.page.close()
+
+  const c = await open('syn=tools-dropped&dense=1', { w: 380, h: 700, name: 'tools-dropped' })
+  const cb = await c.page.locator('body').innerText()
+  check('改图时工具被清空要单独说', cb.includes('「数据查询」的工具被清空了'))
+  check('自查通过但工具被去掉，自查那行不是安静的通过', cb.includes('自查通过，但有 1 处工具被去掉了'))
+  await c.page.close()
+}
+
+console.log('\n=== 吸顶的轮次头贴着顶边（REQ-8）===')
+for (const [q, w, h, label] of [['syn=mixed', 1024, 768, '宽栏 1024'], ['syn=mixed', 1180, 800, '宽栏 1180'],
+                                ['syn=mixed&dense=1', 380, 700, '窄栏']]) {
+  const { page } = await open(q, { w, h })
+  const gap = await page.evaluate(() => {
+    const sc = document.querySelector('[data-stream-scroll]')
+    sc.scrollTop = Math.min(sc.scrollHeight - sc.clientHeight, 260)
+    sc.dispatchEvent(new Event('scroll'))
+    const head = document.querySelector('[data-turn] .sticky')
+    const s = sc.getBoundingClientRect()
+    const hd = head.getBoundingClientRect()
+    // 顶边往下 1px 那一行像素：落在头上才算没缝
+    const hit = document.elementFromPoint(s.left + s.width / 2, s.top + 1)
+    return { gap: Math.round(hd.top - s.top), onHead: !!hit && head.contains(hit), scrolled: sc.scrollTop }
+  })
+  check(`${label}：往下翻后轮次头贴着滚动区顶边，上面不露正文`, gap.scrolled > 0 && gap.gap === 0 && gap.onHead, JSON.stringify(gap))
+  await page.close()
+}
+
+console.log('\n=== 画布右栏：去审批、放弃、出具横幅、回执（REQ-1/3/4、REQ-3A-2）===')
+{
+  const WF_ID = 'fx-stream3'
+  const RUN = 'fxstream0003'
+  const GRAPH = {
+    nodes: [
+      { id: 'in', type: 'input', position: { x: 0, y: 0 }, data: { label: '问题', config: { fields: [{ name: 'q' }] } } },
+      { id: 'review', type: 'human', position: { x: 300, y: 0 }, data: { label: '主管审批', config: { mode: 'approve' } } },
+      { id: 'out', type: 'output', position: { x: 620, y: 0 }, data: { label: '成果', config: {} } },
+      { id: 'query', type: 'agent', position: { x: 300, y: 200 }, data: { label: '数据查询', config: { tools: [] } } },
+    ],
+    edges: [{ id: 'e1', source: 'in', target: 'review' }, { id: 'e2', source: 'review', target: 'out', sourceHandle: 'approved' }],
+  }
+  const WF = { id: WF_ID, name: '右栏检查三', description: '', graph: GRAPH, tags: [], version: 1, status: 'draft',
+    published_version: null, run_count: 0, created_at: '2026-09-26T00:00:00Z', updated_at: '2026-09-26T00:00:00Z' }
+  const APPROVAL = { id: 'ap-3', run_id: RUN, node_id: 'review', mode: 'approve', title: '这份报表可以发出吗？',
+    payload: { message: '华东 1,204 单' }, status: 'pending', response: {}, created_at: new Date(Date.now() - 60_000).toISOString(),
+    workflow_name: '右栏检查三', node_label: '主管审批', run_class: 'exploratory' }
+  const ctx = await browser.newContext({ viewport: { width: 1440, height: 900 }, colorScheme: 'dark' })
+  await ctx.addInitScript(() => { try { localStorage.setItem('agentlab_actor', '张工') } catch { /* 隐私窗口 */ } })
+  const page = await ctx.newPage()
+  const errors = []
+  page.on('pageerror', (e) => errors.push(e.message))
+  const json = (route, body, status = 200) => route.fulfill({ status, contentType: 'application/json', body: JSON.stringify(body) })
+  let pending = true
+  let status = 'interrupted'
+  const cancels = []
+  await page.route(/\/api\/workflows(\?.*)?$/, async (route) => {
+    if (route.request().method() !== 'GET') return json(route, { detail: '检查脚本不写库' }, 409)
+    const real = await (await route.fetch()).json().catch(() => [])
+    return json(route, [WF, ...(Array.isArray(real) ? real : [])])
+  })
+  await page.route(/\/api\/workflows\/fx-stream3(\/.*)?(\?.*)?$/, (route) =>
+    route.request().method() === 'GET' ? json(route, WF) : json(route, { detail: '检查脚本不写库' }, 409))
+  await page.route(/\/api\/conversations(\/.*)?(\?.*)?$/, (route) =>
+    route.request().method() === 'GET' ? json(route, []) : json(route, { id: 'fx-conv3', kind: 'canvas', title: '', turns: [] }))
+  await page.route(/\/api\/approvals(\/.*)?(\?.*)?$/, (route) =>
+    route.request().method() !== 'GET' ? json(route, { detail: '检查脚本不写库' }, 409) : json(route, pending ? [APPROVAL] : []))
+  await page.route(/\/api\/runs(\/.*)?(\?.*)?$/, (route) => {
+    const req = route.request()
+    if (req.method() === 'POST' && req.url().includes(`${RUN}/cancel`)) {
+      cancels.push(req.headers()['x-actor'] ?? '')
+      return json(route, { ok: true, status: 'cancelled' })
+    }
+    if (req.method() === 'GET' && req.url().includes(RUN)) {
+      return json(route, { id: RUN, workflow_id: WF_ID, status, input: {}, output: {}, error: null, usage: {}, run_class: 'exploratory' })
+    }
+    return req.method() === 'GET' ? route.continue() : json(route, { detail: '检查脚本不写库' }, 409)
+  })
+  await page.goto(`${WEB}/studio/${WF_ID}`, { waitUntil: 'networkidle' })
+  await page.waitForFunction((id) => window.__studio?.getState().workflow?.id === id, WF_ID, { timeout: 15000 })
+  const now = Date.now() / 1000
+  const ev = (seq, type, node_id, data = {}, t = 0) => ({ seq, type, node_id, data, ts: now - 30 + t })
+  const WAIT = [
+    ev(1, 'run.started', null, { nodes: 3 }, 0),
+    ev(2, 'node.started', 'in', { node_type: 'input', label: '问题' }, 0.1),
+    ev(3, 'node.finished', 'in', { duration_ms: 3, preview: { q: 'x' } }, 0.2),
+    ev(4, 'node.started', 'review', { node_type: 'human', label: '主管审批' }, 0.3),
+    ev(5, 'human.requested', 'review', { kind: 'human_node', node_id: 'review', mode: 'approve', title: '这份报表可以发出吗？' }, 0.4),
+    ev(6, 'run.interrupted', 'review', { payload: { node_id: 'review', title: '这份报表可以发出吗？' } }, 0.5),
+  ]
+  const feed = (list) => page.evaluate((l) => { const s = window.__studio.getState(); for (const e of l) s.applyEvent(e) }, list)
+  await page.evaluate((run) => window.__studio.setState({ run: { id: run, workflow_id: 'fx-stream3', status: 'queued', input: {},
+    output: {}, error: null, usage: {}, run_class: 'exploratory', version: null }, streaming: true, unsubscribe: () => {} }), RUN)
+  await feed(WAIT)
+  await page.waitForTimeout(600)
+  const panel = page.locator('.sheet-in').first()
+  check('等人：栏头「去审批」旁边有「放弃这次运行」', await panel.getByRole('button', { name: '放弃这次运行' }).count() === 1)
+
+  // 胶囊的「去审批」在右栏处于对话层时派发 agentlab:goto-approval：右栏得自己切过去、把焦点放进审批卡
+  await panel.getByRole('button', { name: /助手/ }).first().click()
+  await page.waitForTimeout(300)
+  check('回到对话层后运行层收起', await page.locator('.sheet-in').count() === 0)
+  // 右栏条和胶囊同一套说法：停在谁、等了多久
+  const strip = await page.locator('[data-run-strip]').innerText().catch(() => '')
+  check('对话层的运行条说停在哪个节点', strip.includes('主管审批'), strip.replace(/\n/g, ' '))
+  if (SHOTS) {
+    for (const theme of ['dark', 'light']) {
+      await page.evaluate((t) => document.documentElement.setAttribute('data-theme', t), theme)
+      await page.waitForTimeout(200)
+      await page.locator('[data-assistant-panel]').screenshot({ path: `${SHOTS}/stream-panel-strip-${theme}.png` })
+    }
+    await page.evaluate(() => document.documentElement.setAttribute('data-theme', 'dark'))
+  }
+  // 右栏收起时它还挂着（只是藏起来）：那时不接手，让胶囊自己兜底，别切到一层没人看得见的运行层
+  const unhandled = await page.evaluate((run) => {
+    const aside = document.querySelector('[data-assistant-panel]').closest('aside')
+    aside.style.visibility = 'hidden'
+    const passed = window.dispatchEvent(new CustomEvent('agentlab:goto-approval', { detail: { runId: run }, cancelable: true }))
+    aside.style.visibility = ''
+    return passed
+  }, RUN)
+  await page.waitForTimeout(200)
+  check('右栏收起时不接手 goto-approval', unhandled && await page.locator('.sheet-in').count() === 0)
+  await page.evaluate((run) => window.dispatchEvent(new CustomEvent('agentlab:goto-approval', { detail: { runId: run, nodeId: 'review' } })), RUN)
+  await page.waitForTimeout(900)
+  const focusIn = await page.evaluate(() => !!document.activeElement?.closest('[data-approval]'))
+  check('goto-approval：切到运行层', await page.locator('.sheet-in').count() === 1)
+  check('goto-approval：焦点落在审批卡里', focusIn)
+  check('goto-approval：审批卡描了一圈', await page.locator('[data-approval].sf-flash').count() === 1)
+  if (SHOTS) await page.screenshot({ path: `${SHOTS}/stream-panel-goto-approval-dark.png` })
+
+  // 放弃：确认之后调 cancel，带着署名；事件流过来就收成「已取消」，说清是谁放弃的
+  await page.locator('.sheet-in').first().getByRole('button', { name: '放弃这次运行' }).click()
+  await page.waitForTimeout(300)
+  const dialog = await page.locator('[role="dialog"]').innerText().catch(() => '')
+  check('放弃前先确认，说清后果', dialog.includes('待审批') && dialog.includes('不能再接着跑'), dialog.replace(/\n/g, ' ').slice(0, 160))
+  await page.locator('[role="dialog"]').getByRole('button', { name: '放弃这次运行' }).click()
+  await page.waitForTimeout(400)
+  check('放弃：调了 cancel，带着署名', cancels.length === 1 && decodeURIComponent(cancels[0]) === '张工', JSON.stringify(cancels))
+  pending = false
+  status = 'cancelled'
+  await feed([ev(7, 'run.cancelled', null, { timing: { wall_ms: 30000, active_ms: 500, wait_ms: 29500 }, actor: '张工',
+    message: '放弃了这次运行，1 条待审批一并关闭' }, 30), ev(8, 'stream.end', null, { status: 'cancelled' }, 30)])
+  await page.waitForTimeout(500)
+  const head = await page.locator('.sheet-in [data-turn] .sticky').first().innerText().catch(() => '')
+  check('放弃：头部写已取消', head.includes('已取消'), head.replace(/\n/g, ' '))
+  const marks = await page.locator('.sheet-in [data-phase-mark]').allInnerTexts()
+  check('放弃：分段线写清谁放弃、一并关了什么', marks.some((t) => t.includes('张工') && t.includes('一并关闭')), marks.join(' | '))
+  check('放弃之后不再给「去审批」和「放弃」', await page.locator('.sheet-in').getByRole('button', { name: /去审批|放弃这次运行/ }).count() === 0)
+  if (SHOTS) {
+    for (const theme of ['dark', 'light']) {
+      await page.evaluate((t) => document.documentElement.setAttribute('data-theme', t), theme)
+      await page.waitForTimeout(200)
+      await page.screenshot({ path: `${SHOTS}/stream-panel-abandoned-${theme}.png` })
+    }
+    await page.evaluate(() => document.documentElement.setAttribute('data-theme', 'dark'))
+  }
+
+  // 出具横幅：画布上的印章派发 agentlab:goto-issuance；右栏在对话层时先切过去再滚到横幅
+  await page.evaluate((run) => {
+    const s = window.__studio.getState()
+    s.clearRun()
+    window.__studio.setState({ run: { id: run, workflow_id: 'fx-stream3', status: 'succeeded', input: {}, output: {
+      结论: '华东 1,204 单', _issuance: { tier: 'degraded', calibers: [], metrics_checked: 1, matched_numbers: 0,
+        unmatched_numbers: [{ token: '1,204', context: '华东 1,204 单' }], missing_required: [], missing_expected: [], gaps: [] } },
+      error: null, usage: {}, run_class: 'exploratory', version: null }, streaming: false, unsubscribe: () => {} })
+  }, RUN)
+  await feed([ev(1, 'run.started', null, { nodes: 3 }, 0), ev(2, 'node.started', 'out', { node_type: 'output', label: '成果' }, 0.1),
+    ev(3, 'issuance', 'out', { tier: 'degraded', unmatched: 1, gaps: [], metrics_checked: 1, matched_numbers: 0 }, 0.2),
+    ev(4, 'node.finished', 'out', { duration_ms: 2, preview: {} }, 0.3),
+    ev(5, 'run.finished', null, { output: { 结论: '华东 1,204 单', _issuance: { tier: 'degraded', calibers: [], metrics_checked: 1,
+      matched_numbers: 0, unmatched_numbers: [{ token: '1,204', context: '华东 1,204 单' }], missing_required: [], missing_expected: [], gaps: [] } },
+      usage: {}, duration_ms: 400, timing: { wall_ms: 400, active_ms: 400, wait_ms: 0 } }, 0.4)])
+  await page.waitForTimeout(400)
+  await page.locator('.sheet-in').first().getByRole('button', { name: /助手/ }).first().click()
+  await page.waitForTimeout(300)
+  await page.evaluate((run) => window.dispatchEvent(new CustomEvent('agentlab:goto-issuance', { detail: { runId: run } })), RUN)
+  await page.waitForTimeout(900)
+  const banner = await page.evaluate(() => {
+    const b = document.querySelector('.sheet-in [data-issuance-banner]')
+    const s = b?.closest('[data-stream-scroll]')?.getBoundingClientRect()
+    const r = b?.getBoundingClientRect()
+    return { found: !!b, inView: !!r && !!s && r.top >= s.top - 1 && r.top < s.bottom, focused: !!b && document.activeElement === b }
+  })
+  check('goto-issuance：切到运行层、横幅在视野里', banner.found && banner.inView, JSON.stringify(banner))
+  // 焦点带过去：读屏和键盘用户从画布那头被带过来，得落在横幅上，而不是留在画布的印章上
+  check('goto-issuance：焦点落在出具横幅上', banner.focused)
+
+  // 回执：看过了没改（unchanged）不说「已更新画布」；修过几处数不出来时不写「几 处」
+  await page.locator('.sheet-in').first().getByRole('button', { name: /助手/ }).first().click()
+  await page.evaluate(() => {
+    const s = window.__studio.getState()
+    s.clearRun()
+    const base = { explanation: '', error: '', phase: 'done' }
+    window.__studio.setState({ copilotTurns: [
+      { ...base, id: 'u1', instruction: '检查一下有没有问题', outcome: 'unchanged',
+        ops: [{ op: 'done', explanation: '' }, { op: 'check', status: 'passed', repaired: 0 }, { op: 'final', graph: { nodes: [{ id: 'in' }] } }] },
+      { ...base, id: 'u2', instruction: '把循环条件改对', outcome: 'applied', diff: { added: [], changed: ['review'], removed: [], total: 1 },
+        ops: [{ op: 'update_node', id: 'review' }, { op: 'check', status: 'passed', repaired: 1 }, { op: 'final', graph: { nodes: [{ id: 'in' }] } }] },
+    ] })
+  })
+  await page.waitForTimeout(400)
+  const turns = await page.locator('[data-turn]').allInnerTexts()
+  check('unchanged：说「看过了，画布没有需要改的地方」', turns[0]?.includes('看过了，画布没有需要改的地方')
+    && !turns[0]?.includes('已更新画布'), turns[0]?.split('\n').slice(0, 3).join(' '))
+  check('修过但数不出几处：不写「几 处」', turns[1]?.includes('自查发现的问题已自动修好') && !turns[1]?.includes('几 处'),
+    turns[1]?.split('\n').slice(0, 3).join(' '))
+
+  // 改图时模型漏写了 tools：回执逐项列出去掉了什么；自查是通过的，「让 Copilot 再修」不管用，撤销是首选
+  const dropped = { level: 'warning', node_id: 'query', code: 'tools_dropped', field: 'tools',
+    message: '「数据查询」的工具从 db_query__shop 变成了空：这一轮的要求里没有提到去掉工具' }
+  await page.evaluate((warn) => {
+    window.__studio.setState({ copilotTurns: [{ explanation: '', error: '', phase: 'done', id: 'u3', instruction: '只查上月的数据',
+      outcome: 'applied', diff: { added: [], changed: ['query'], removed: [], total: 1 },
+      ops: [{ op: 'update_node', id: 'query', label: '数据查询', config: { system: '只查上月' } },
+        { op: 'check', status: 'passed', repaired: 0, warnings: [warn] },
+        { op: 'final', graph: { nodes: [{ id: 'in' }, { id: 'query' }] }, issues: [warn], tool_changes: [{ node_id: 'query',
+          label: '数据查询', member: null, field: 'tools', before: ['db_query__shop'], after: [], added: [], removed: ['db_query__shop'] }] }] }] })
+  }, dropped)
+  await page.waitForTimeout(400)
+  const loss = await page.locator('[data-tool-changes]').innerText().catch(() => '')
+  check('回执逐项列出被去掉的工具', loss.includes('「数据查询」去掉了') && loss.includes('db_query__shop') && loss.includes('一个工具都没有'),
+    loss.replace(/\n/g, ' '))
+  const head3 = await page.locator('[data-turn="u3"] .sticky').innerText().catch(() => '')
+  check('回执头部是提醒，写清几处工具被去掉', head3.includes('1 处工具被去掉了'), head3.replace(/\n/g, ' '))
+  check('只丢了工具时不给「让 Copilot 再修」，撤销是主按钮',
+    await page.getByRole('button', { name: /让 Copilot/ }).count() === 0
+    && await page.locator('button.btn-primary', { hasText: '撤销这次生成' }).count() === 1)
+  if (SHOTS) {
+    for (const theme of ['dark', 'light']) {
+      await page.evaluate((t) => document.documentElement.setAttribute('data-theme', t), theme)
+      await page.waitForTimeout(200)
+      await page.locator('[data-assistant-panel]').screenshot({ path: `${SHOTS}/stream-panel-tools-lost-${theme}.png` })
+    }
+    await page.evaluate(() => document.documentElement.setAttribute('data-theme', 'dark'))
+  }
+
+  // 模型把工具调用写成文字、判失败：报错和提醒行给「打开『数据查询』的设置」，点了就是那个节点的属性面板
+  const MARKUP_ERROR = '模型输出了工具调用的原始标记，但没有真正调用工具，这一步一次都没查到数据。常见原因：节点没有绑定工具，或者模型、服务不支持工具调用。到画布里给这个节点绑定要用的工具；绑定了还这样，就换一个支持工具调用的模型'
+  await page.evaluate((run) => {
+    window.__studio.setState({ copilotTurns: [] })
+    window.__studio.setState({ run: { id: run, workflow_id: 'fx-stream3', status: 'running', input: {}, output: {}, error: null,
+      usage: {}, run_class: 'exploratory', version: null }, streaming: true, unsubscribe: () => {} })
+  }, RUN)
+  await feed([ev(1, 'run.started', null, { nodes: 4 }, 0), ev(2, 'node.started', 'query', { node_type: 'agent', label: '数据查询' }, 0.1),
+    ev(3, 'llm.start', 'query', { model: 'demo-chat' }, 0.2),
+    ev(4, 'llm.end', 'query', { model: 'demo-chat', duration_ms: 1800, input_tokens: 800, output_tokens: 90, cost_usd: 0.001 }, 2),
+    ev(5, 'log', 'query', { level: 'warn', code: 'tool_markup_leak', message: '模型把工具调用写成了文字（<｜｜DSML｜｜invoke name="db_query__shop">…），没有真正调用工具，已提醒它重试一次' }, 2.1),
+    ev(6, 'node.failed', 'query', { error: MARKUP_ERROR, duration_ms: 3900 }, 4),
+    ev(7, 'run.failed', null, { error: MARKUP_ERROR, node_id: 'query', label: '数据查询', timing: { wall_ms: 4000, active_ms: 4000, wait_ms: 0 } }, 4)])
+  await page.waitForTimeout(500)
+  const runPanel = page.locator('.sheet-in').first()
+  const alertText = await runPanel.locator('[data-turn-error]').innerText().catch(() => '')
+  check('右栏报错说人话：模型没有真正调用工具', alertText.startsWith('模型没有真正调用工具') && !alertText.includes('DSML'),
+    alertText.split('\n')[0])
+  check('提醒行的下一步也给直达入口', await runPanel.locator('[data-step-code="tool_markup_leak"] [data-fix="canvas"]').count() === 1)
+  if (SHOTS) {
+    for (const theme of ['dark', 'light']) {
+      await page.evaluate((t) => document.documentElement.setAttribute('data-theme', t), theme)
+      await page.waitForTimeout(200)
+      await page.locator('[data-assistant-panel]').screenshot({ path: `${SHOTS}/stream-panel-markup-${theme}.png` })
+    }
+    await page.evaluate(() => document.documentElement.setAttribute('data-theme', 'dark'))
+  }
+  const openSettings = runPanel.locator('[data-turn-error]').getByRole('button', { name: '打开「数据查询」的设置' })
+  check('报错给「打开『数据查询』的设置」', await openSettings.count() === 1)
+  if (await openSettings.count()) {
+    await openSettings.click()
+    await page.waitForTimeout(300)
+    check('点「打开设置」就是那个节点的属性面板', await page.evaluate(() => window.__studio.getState().selectedId) === 'query')
+  }
+
+  check('画布右栏没有运行时报错', errors.length === 0, errors.join(' | '))
+  await ctx.close()
+}
+
 await browser.close()
 console.log(failed ? `\n✗ ${failed} 项未通过` : '\n✓ 助手流渲染全部通过')
 process.exit(failed ? 1 : 0)
diff --git a/scripts/check-studio.mjs b/scripts/check-studio.mjs
index 553eaa2d..a735468c 100644
--- a/scripts/check-studio.mjs
+++ b/scripts/check-studio.mjs
@@ -51,6 +51,34 @@ const GRAPH = {
 }
 const V1 = { nodes: GRAPH.nodes.slice(0, 3).concat([GRAPH.nodes[6]]), edges: [edge('start', 'lookup'), edge('lookup', 'gate'), edge('gate', 'done', 'fast')] }
 
+// 查库的 agent 和带成员的协作团队：助手改节点时工具不能被悄悄改没（NI-1），提示词点名的
+// 工具没绑定要能定位到工具那一栏（NI-2）。全是通用示例名
+const QUERY_TOOLS = ['db_query__shop', 'db_schema__shop']
+const TEAM_GRAPH = {
+  nodes: [
+    node('start', 'input', 0, 200, '输入', { fields: [{ name: 'question', required: true }] }),
+    node('fetch', 'agent', 300, 200, '数据查询', {
+      system: '你是取数助手。', prompt: '先用 db_schema__shop 看表结构，再用 db_query__shop 查 orders 表里每个门店的订单数',
+      tools: ['db_query__shop'], assign_to: 'rows', max_steps: 8,
+    }),
+    node('team', 'supervisor', 600, 200, '复核团队', {
+      goal: '核对订单数', max_rounds: 4,
+      agents: [
+        { name: 'fetcher', description: '负责查库', system: '只用 SQL 取数', tools: ['db_query__shop'] },
+        { name: 'writer', description: '写结论', system: '用 python_exec 算出占比再写结论', tools: [] },
+      ],
+    }),
+    node('done', 'output', 900, 200, '成果', { fields: [{ name: 'answer', value: '{{ vars.rows }}' }] }),
+  ],
+  edges: [edge('start', 'fetch'), edge('fetch', 'team'), edge('team', 'done')],
+}
+/** 工具都绑好了的那一版：合并语义要守住的就是它 */
+const TEAM_BOUND = {
+  ...TEAM_GRAPH,
+  nodes: TEAM_GRAPH.nodes.map((n) => (n.id === 'fetch'
+    ? { ...n, data: { ...n.data, config: { ...n.data.config, tools: [...QUERY_TOOLS] } } } : n)),
+}
+
 const wf = (id, extra) => ({
   id, name: extra.name, description: extra.description ?? '检查脚本伪造的工作流', graph: extra.graph ?? GRAPH,
   tags: extra.tags ?? [], version: extra.version ?? 3, is_template: !!extra.is_template,
@@ -62,6 +90,8 @@ const FAKES = {
   'st-main': wf('st-main', { name: '__studio_check__', version: 3, published_version: 2 }),
   'st-gov': wf('st-gov', { name: '__studio_check_gov__', status: 'governed', version: 3, published_version: 3, published_by: '张工' }),
   'st-tpl': wf('st-tpl', { name: '__studio_check_tpl__', is_template: true, tags: ['extracted'] }),
+  'st-team': wf('st-team', { name: '__studio_check_team__', graph: TEAM_BOUND, version: 2, published_version: 2, status: 'published' }),
+  'st-lint': wf('st-lint', { name: '__studio_check_lint__', graph: TEAM_GRAPH, version: 1 }),
 }
 const VERSIONS = [
   { id: 'v3', version: 3, note: '', created_at: '2026-09-26T02:00:00Z' },
@@ -182,7 +212,7 @@ async function open({ width = 1440, height = 900, path = '/studio/st-main', pref
   return { ctx, page, errors, state }
 }
 
-const S = (page, fn) => page.evaluate(fn)
+const S = (page, fn, arg) => page.evaluate(fn, arg)
 const st = (page) => page.evaluate(() => {
   const s = window.__studio.getState()
   return { nodes: s.nodes.map((n) => n.id), edges: s.edges.length, selectedId: s.selectedId,
@@ -675,9 +705,10 @@ console.log('=== 助手改图：一步撤销、回执、只回话、失败退回
         message: '模型写了一个不存在的节点类型「magic」，这一步已跳过' }] },
   ]
   const past0 = (await st(page)).past
-  await S(page, () => window.__studio.getState().runCopilot('给快速回答后面加一步润色', true))
+  const began = await S(page, () => window.__studio.getState().runCopilot('给快速回答后面加一步润色', true))
   await page.waitForFunction(() => window.__studio.getState().copilotTurns.at(-1)?.phase !== 'running')
   const t1 = await S(page, () => window.__studio.getState().copilotTurns.at(-1))
+  check('开始了就告诉输入框（runCopilot 返回 true）', began === true, String(began))
   check('收到 final：这一轮是「已应用」', t1.outcome === 'applied', t1.outcome)
   check('diff 记下新增和改动', t1.diff?.added.includes('polish') && t1.diff?.changed.includes('answer'), JSON.stringify(t1.diff))
   check('final.issues 进了这一轮（少了一步）', t1.issues?.some((i) => i.code === 'unknown_node_type'))
@@ -767,8 +798,7 @@ console.log('=== 助手改图：一步撤销、回执、只回话、失败退回
   await page.waitForFunction(() => window.__studio.getState().copilotTurns.at(-1)?.phase !== 'running')
   state.stream = [{ op: 'model', model: 'fake-model' }, { op: 'reply', text: '好' }]
   const turnId = await S(page, () => window.__studio.getState().copilotTurns.at(-1).id)
-  await S(page, (id) => window.__studio.getState().repairWithCopilot(id), turnId).catch(() => null)
-  await page.evaluate((id) => window.__studio.getState().repairWithCopilot(id), turnId)
+  await S(page, (id) => window.__studio.getState().repairWithCopilot(id), turnId)
   await page.waitForTimeout(400)
   const lastBody = state.bodies.at(-1)
   check('再修一次：指令里带着剩下的问题', lastBody?.instruction?.includes('还没选工具') && !!lastBody?.base_graph,
@@ -798,7 +828,7 @@ console.log('=== 入口：?run=&focus=、选择器、发布弹窗 ===')
   await page.keyboard.type('__studio_check')
   await page.waitForTimeout(200)
   const rows = await count(page, '[role="listbox"][aria-label="工作流"] > li')
-  check('选择器能搜索', rows === 3, `${rows} 条`)
+  check('选择器能搜索', rows === Object.keys(FAKES).length, `${rows} 条`)
   check('当前工作流有底色和勾', await count(page, 'li[aria-selected="true"] .bg-accent-solid') === 1)
   check('模板行常驻「用它新建」', await count(page, 'li:has-text("__studio_check_tpl__") button:has-text("用它新建")') === 1)
   check('标签本地化（extracted → 从运行提取）', await count(page, 'li:has-text("__studio_check_tpl__") :text("从运行提取")') === 1)
@@ -822,7 +852,8 @@ console.log('=== 入口：?run=&focus=、选择器、发布弹窗 ===')
     : route.fallback()))
   await S(pub.page, () => { const s = window.__studio.getState(); s.updateNode('lookup', { label: '背景检索2' }); s.undo() })
   const pb = await S(pub.page, () => { const s = window.__studio.getState(); return { future: s.future.length, fit: s.fitRequest, dirty: s.dirty } })
-  await pub.page.locator('button:has-text("发布")').first().click()
+  await pub.page.getByRole('button', { name: '发布', exact: true }).click()
+  await pub.page.waitForSelector('[role="dialog"] button.btn-primary', { timeout: 5000 }).catch(() => {})
   await pub.page.waitForTimeout(300)
   await pub.page.locator('[role="dialog"] button.btn-primary').click()
   await pub.page.waitForFunction(() => window.__studio.getState().workflow?.status === 'published', null, { timeout: 5000 }).catch(() => {})
@@ -843,17 +874,348 @@ console.log('=== 入口：?run=&focus=、选择器、发布弹窗 ===')
   await win.ctx.close()
 
   const gov = await open({ path: '/studio/st-gov' })
-  await gov.page.locator('button:has-text("发布")').first().click()
+  // 按名字找：别的按钮（版本标签、提示）也可能带着「发布」两个字
+  await gov.page.getByRole('button', { name: '发布', exact: true }).click()
+  await gov.page.waitForSelector('[role="dialog"] [role="radio"]', { timeout: 5000 }).catch(() => {})
   await gov.page.waitForTimeout(300)
-  const radio = await gov.page.locator('[role="radio"][aria-checked="true"]').innerText()
+  // 只看发布弹窗里的：助手输入框的「在现有图上改 | 从头生成」也是一组 radio
+  const radio = await gov.page.locator('[role="dialog"] [role="radio"][aria-checked="true"]').innerText()
   check('受管工作流的发布默认选「受管」', radio.includes('受管'), radio.slice(0, 20))
   check('选项用统一术语（已发布 — 可发起正式运行）', await gov.page.getByText('已发布 — 可发起正式运行').count() === 1)
   check('写明以谁的名义发布', await gov.page.getByText('检查脚本').count() >= 1)
-  await gov.page.locator('[role="radio"]:has-text("已发布")').click()
+  await gov.page.locator('[role="dialog"] [role="radio"]:has-text("已发布")').click()
   check('从受管降级要说出来', await gov.page.getByText(/会降级/).count() === 1)
   await gov.ctx.close()
 }
 
+// ================================================================ 6b
+console.log('=== 助手改节点是合并，不是整体替换（NI-1）；出错留下「怎么办」 ===')
+{
+  const { ctx, page, state, errors } = await open({ path: '/studio/st-team' })
+  // 流在最后一步出错：画布退回这一轮之前，半成品进重做栈。读重做栈顶就是按操作流逐条
+  // 落上去的样子——final 会拿后端合并好的整张图覆盖，只看 final 看不出前端合得对不对
+  state.stream = [
+    { op: 'model', model: 'fake-model' },
+    { op: 'update_node', id: 'fetch', label: '数据查询',
+      config: { system: '你是取数助手，按月份汇总。', prompt: '按月份统计 orders 的订单数' } },
+    { op: 'update_node', id: 'team', config: { goal: '核对按月的订单数', agents: [
+      { name: 'fetcher', system: '按月份取数' },
+      { name: 'writer', remove: true },
+      { name: 'checker', description: '复核口径', tools: ['db_schema__shop'], system: null },
+    ] } },
+    { op: 'update_node', id: 'fetch', config: { max_steps: null } },
+    { op: 'error', message: '助手这一轮没跑完：等待超时', hint: '换一个响应快的模型再试', detail: 'ReadTimeout: 120s' },
+  ]
+  await S(page, () => window.__studio.getState().runCopilot('按月份拆一下', true))
+  await page.waitForFunction(() => window.__studio.getState().copilotTurns.at(-1)?.phase !== 'running')
+  const half = await S(page, () => {
+    const s = window.__studio.getState()
+    const nodes = s.future.at(-1)?.nodes ?? []
+    const cfg = (id) => nodes.find((n) => n.id === id)?.data.config ?? null
+    return { fetch: cfg('fetch'), team: cfg('team') }
+  })
+  const f = half.fetch ?? {}
+  const members = half.team?.agents ?? []
+  const fetcher = members.find((m) => m.name === 'fetcher') ?? {}
+  const checker = members.find((m) => m.name === 'checker') ?? {}
+  check('只改提示词：agent 的工具一个不少', JSON.stringify(f.tools) === JSON.stringify(QUERY_TOOLS), JSON.stringify(f.tools))
+  check('写了的键改上去、没写的键保留', f.prompt === '按月份统计 orders 的订单数' && f.assign_to === 'rows',
+    `${f.prompt} / ${f.assign_to}`)
+  check('写 null 的键删掉', !('max_steps' in f), JSON.stringify(Object.keys(f)))
+  check('成员按 name 合并：没写 tools 的保留原来的 tools 和别的字段',
+    JSON.stringify(fetcher.tools) === '["db_query__shop"]' && fetcher.system === '按月份取数' && fetcher.description === '负责查库',
+    JSON.stringify(fetcher))
+  check('{name, remove:true} 删掉成员，新名字接在后面', members.map((m) => m.name).join(',') === 'fetcher,checker',
+    members.map((m) => m.name).join(','))
+  check('新成员里写 null 的字段不留', !('system' in checker) && JSON.stringify(checker.tools) === '["db_schema__shop"]',
+    JSON.stringify(checker))
+  check('团队没写的顶层键保留', half.team?.max_rounds === 4 && half.team?.goal === '核对按月的订单数')
+  const cp = await S(page, () => window.__studio.getState().copilot)
+  check('出错时保留「怎么办」和技术细节（Composer 的错误条要用）',
+    cp.error.includes('等待超时') && cp.errorHint === '换一个响应快的模型再试' && cp.errorDetail === 'ReadTimeout: 120s',
+    JSON.stringify({ hint: cp.errorHint, detail: cp.errorDetail }))
+  const t0 = await S(page, () => window.__studio.getState().copilotTurns.at(-1))
+  check('这一轮记下开始时刻（助手流头部的实时计时用）', typeof t0.startedAt === 'number'
+    && Math.abs(Date.now() - t0.startedAt) < 60_000, String(t0.startedAt))
+
+  // 改图回执：后端 final 带回的工具绑定变化。工具集合变小、指令又没让删的，warn 色、可一键撤销
+  const dropped = {
+    ...TEAM_BOUND,
+    nodes: TEAM_BOUND.nodes.map((n) => {
+      if (n.id === 'fetch') return { ...n, data: { ...n.data, config: { ...n.data.config, prompt: '简短一点', tools: [] } } }
+      if (n.id === 'team') {
+        return { ...n, data: { ...n.data, config: { ...n.data.config,
+          agents: n.data.config.agents.map((a) => (a.name === 'fetcher' ? { ...a, tools: [] } : a)) } } }
+      }
+      return n
+    }),
+  }
+  const warn = (id, field, message) => ({ level: 'warning', node_id: id, edge_id: null, code: 'tools_dropped', field, message })
+  const warnings = [
+    warn('fetch', 'tools', '「数据查询」的工具从 db_query__shop、db_schema__shop 变成了空。这一轮的要求里没有提到去掉工具，确认一下是不是改漏了'),
+    warn('team', 'agents[0].tools', '「复核团队」的成员「fetcher」的工具从 db_query__shop 变成了空。这一轮的要求里没有提到去掉工具，确认一下是不是改漏了'),
+  ]
+  const changes = [
+    { node_id: 'fetch', label: '数据查询', member: null, field: 'tools', before: QUERY_TOOLS, after: [], added: [], removed: QUERY_TOOLS },
+    { node_id: 'team', label: '复核团队', member: 'fetcher', field: 'agents[0].tools', before: ['db_query__shop'], after: [], added: [], removed: ['db_query__shop'] },
+  ]
+  state.stream = [
+    { op: 'model', model: 'fake-model' },
+    { op: 'update_node', id: 'fetch', config: { prompt: '简短一点', tools: [] } },
+    { op: 'update_node', id: 'team', config: { agents: [{ name: 'fetcher', tools: [] }] } },
+    { op: 'done', explanation: '改短了' },
+    { op: 'check', status: 'passed', repaired: 0, warnings },
+    { op: 'final', graph: dropped, explanation: '改短了', layout: { mode: 'keep', placed: [] },
+      issues: [...warnings, { level: 'warning', node_id: 'done', edge_id: null, message: '成果字段引用的变量可能为空' }],
+      tool_changes: changes },
+  ]
+  await S(page, () => window.__studio.getState().runCopilot('提示词写短一点', true))
+  await page.waitForFunction(() => window.__studio.getState().copilotTurns.at(-1)?.phase !== 'running')
+  const t1 = await S(page, () => window.__studio.getState().copilotTurns.at(-1))
+  check('回执记下后端给的工具绑定变化', t1.toolChanges?.length === 2 && t1.toolChanges[0].node_id === 'fetch',
+    JSON.stringify(t1.toolChanges?.map((c) => c.node_id)))
+  check('工具被删的提醒单独记，不混进普通校验提示', t1.toolWarnings?.length === 2
+    && t1.toolWarnings.every((w) => w.code === 'tools_dropped'), JSON.stringify(t1.toolWarnings?.map((w) => w.node_id)))
+  check('自查那一步也带着这两条提醒', t1.check?.warnings?.length === 2, JSON.stringify(t1.check?.warnings))
+  check('记下的 final 操作带着 tool_changes（右栏回执从它解码）',
+    t1.ops.find((o) => o.op === 'final')?.tool_changes?.length === 2)
+  const toastBox = page.locator('[role="status"] > div').filter({ hasText: '工具绑定变少了' })
+  const toastText = (await toastBox.first().innerText().catch(() => '')).replace(/\s+/g, ' ')
+  check('工具集合变小：回执是 warn 色，逐条列出前后', await toastBox.count() === 1
+    && toastText.includes('「数据查询」') && toastText.includes('db_query__shop、db_schema__shop → 空')
+    && toastText.includes('fetcher'), toastText.slice(0, 120))
+  check('工具被删的回执用 warn 色边框', await toastBox.first().evaluate((el) =>
+    el.getAttribute('style')?.includes('var(--warn)'), null, { timeout: 2000 }).catch(() => false))
+  await toastBox.first().locator('button:has-text("撤销")').click({ timeout: 2000 }).catch(() => {})
+  await page.waitForTimeout(250)
+  const back = await S(page, () => window.__studio.getState().nodes.find((n) => n.id === 'fetch').data.config.tools)
+  check('回执里一键撤销：工具回来了', JSON.stringify(back) === JSON.stringify(QUERY_TOOLS), JSON.stringify(back))
+
+  // 老后端的 final 不带 tool_changes：前端自己比对前后两张图
+  state.stream = [
+    { op: 'model', model: 'fake-model' },
+    { op: 'update_node', id: 'fetch', config: { tools: ['db_query__shop', 'python_exec'] } },
+    { op: 'final', graph: { ...TEAM_BOUND, nodes: TEAM_BOUND.nodes.map((n) => (n.id === 'fetch'
+      ? { ...n, data: { ...n.data, config: { ...n.data.config, tools: ['db_query__shop', 'python_exec'] } } } : n)) },
+      explanation: '', layout: { mode: 'keep', placed: [] }, issues: [] },
+  ]
+  await S(page, () => window.__studio.getState().runCopilot('查表结构换成算一下', true))
+  await page.waitForFunction(() => window.__studio.getState().copilotTurns.at(-1)?.phase !== 'running')
+  const t2 = await S(page, () => window.__studio.getState().copilotTurns.at(-1))
+  const c2 = t2.toolChanges?.[0]
+  check('老后端不给 tool_changes：前端自己比对出来', t2.toolChanges?.length === 1 && c2.node_id === 'fetch'
+    && c2.added.join() === 'python_exec' && c2.removed.join() === 'db_schema__shop' && c2.member === null,
+    JSON.stringify(t2.toolChanges))
+  check('换了一个工具（数量没少）不算被删，没有提醒', !(t2.toolWarnings ?? []).length)
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await ctx.close()
+
+  // 合并规则本身：和后端 merge_node_config 同一组用例（backend/tests/test_copilot_merge.py）
+  const unit = await open({ path: '/studio/st-team' })
+  const r = await unit.page.evaluate(async () => {
+    const m = await import('/src/canvas/copilotMerge.ts')
+    const old = { prompt: 'p', tools: ['db_query__shop', 'db_schema__shop'], assign_to: 'rows',
+      agents: [{ name: '取数员', system: '只用 SQL 取数', tools: ['db_query__shop'] }, { system: '无名', tools: ['x'] }] }
+    const snapshot = JSON.stringify(old)
+    const a = m.mergeNodeConfig('agent', old, { assign_to: null, temperature: 0.2 })
+    const b = m.mergeNodeConfig('agent', old, { tools: ['db_query__shop'] })
+    const c = m.mergeNodeConfig('supervisor', old, { agents: [
+      { name: 'agent1', tools: null }, { name: '核对员', tools: ['db_schema__shop'], note: null }, { name: '取数员', remove: true }] })
+    // agents 不是列表、或者不是 supervisor：整体替换这一个键（和后端一样只对 supervisor 的成员列表按 name 合并）
+    const d = m.mergeNodeConfig('agent', old, { agents: [{ name: 'x' }] })
+    return { a, b, c, d, untouched: JSON.stringify(old) === snapshot }
+  })
+  check('合并：null 删键，没写的留着', !('assign_to' in r.a) && r.a.temperature === 0.2 && r.a.tools.length === 2, JSON.stringify(r.a))
+  check('合并：显式写 tools 就换成新的', r.b.tools.join() === 'db_query__shop')
+  // 没名字的那个按 agent1 认出来、合并进去：条目里写的 name 也跟着落上（后端同样如此）
+  check('合并：没名字的成员按 agentN 认；删成员、新名字接在后面', r.c.agents.map((x) => x.name).join() === 'agent1,核对员'
+    && !('tools' in r.c.agents[0]) && r.c.agents[0].system === '无名' && !('note' in r.c.agents[1]), JSON.stringify(r.c.agents))
+  check('合并：不是 supervisor 时 agents 整体替换', JSON.stringify(r.d.agents) === '[{"name":"x"}]')
+  check('合并：旧 config 不被原地改（比对工具变化还要用它）', r.untouched)
+  await unit.ctx.close()
+}
+
+// ================================================================ 6c
+console.log('=== 正式运行期间画布只读：调色板、粘贴、复制、排版、检查器、撤销都拦下 ===')
+{
+  const { ctx, page, errors, state } = await open({ path: '/studio/st-team' })
+  const layoutCalls = []
+  page.on('request', (req) => { if (req.url().includes('/copilot/layout')) layoutCalls.push(req.url()) })
+  const formal = (phase) => page.evaluate((p) => window.__studio.setState((s) => ({
+    run: { id: 'st-formal-0001', workflow_id: 'st-team', status: p === 'succeeded' ? 'succeeded' : 'running',
+      run_class: 'formal', version: 2, input: {}, output: {}, error: '', usage: {}, created_at: '2026-09-26T02:00:00Z' },
+    runPhase: p, trace: { ...s.trace, phase: p, runClass: 'formal' },
+  })), phase)
+  // 先选中一个节点、复制下来，再开始正式运行
+  await S(page, () => window.__studio.getState().select('fetch'))
+  await blur(page)
+  await S(page, () => window.__studio.getState().select('fetch'))
+  await page.evaluate(() => document.activeElement instanceof HTMLElement && document.activeElement.blur())
+  await page.keyboard.press(`${MOD}+c`)
+  // 助手先改一轮（改成果节点的名字），正式运行开始后再点这一轮的「撤销这次生成」
+  const renamed = { ...TEAM_BOUND, nodes: TEAM_BOUND.nodes.map((n) => (n.id === 'done'
+    ? { ...n, data: { ...n.data, label: '成果（按月）' } } : n)) }
+  state.stream = [
+    { op: 'model', model: 'fake-model' },
+    { op: 'update_node', id: 'done', label: '成果（按月）' },
+    { op: 'final', graph: renamed, explanation: '', layout: { mode: 'keep', placed: [] }, issues: [] },
+  ]
+  await S(page, () => window.__studio.getState().runCopilot('成果改个名字', true))
+  await page.waitForFunction(() => window.__studio.getState().copilotTurns.at(-1)?.phase !== 'running')
+  const turnId = await S(page, () => window.__studio.getState().copilotTurns.at(-1).id)
+  await formal('running')
+  await page.waitForTimeout(200)
+  const s0 = await st(page)
+
+  await page.locator('button:has-text("模型调用"), button[aria-label="添加模型调用"]').first().click({ force: true, timeout: 2000 }).catch(() => {})
+  await S(page, () => window.__studio.getState().addNode('llm'))
+  check('调色板点击添加被拦下', (await st(page)).nodes.length === s0.nodes.length)
+  check('调色板标成不可用并说明为什么', await count(page, '[aria-label^="节点库"] [aria-disabled="true"]') === 1
+    && (await page.locator('[aria-label^="节点库"]').innerText()).includes('只读'))
+
+  await page.evaluate(() => document.activeElement instanceof HTMLElement && document.activeElement.blur())
+  await page.keyboard.press(`${MOD}+v`)
+  await page.keyboard.press(`${MOD}+d`)
+  await page.keyboard.press('Shift+KeyL')
+  await page.keyboard.press(`${MOD}+z`)
+  await page.waitForTimeout(400)
+  const s1 = await st(page)
+  check('⌘V 粘贴、⌘D 复制、⇧L 排版、⌘Z 撤销都不改图', s1.nodes.length === s0.nodes.length && s1.past === s0.past
+    && layoutCalls.length === 0, `${s1.nodes.length}/${s0.nodes.length} 节点 · 排版请求 ${layoutCalls.length}`)
+  check('按了改图快捷键会说为什么不行', await page.getByText(/正式运行进行中/).count() >= 1)
+  check('工具栏的撤销、自动排版置灰', await page.getByRole('button', { name: '自动排版' }).isDisabled()
+    && await page.getByRole('button', { name: '撤销', exact: true }).first().isDisabled())
+  // 撤销被锁拦下、画布没动：这一轮不能被标成「已撤回」，回执也不能说撤掉了
+  const undone = await S(page, (id) => window.__studio.getState().undoCopilotTurn(id), turnId)
+  const kept = await S(page, (id) => {
+    const s = window.__studio.getState()
+    return { outcome: s.copilotTurns.find((t) => t.id === id)?.outcome,
+      label: s.nodes.find((n) => n.id === 'done')?.data.label }
+  }, turnId)
+  check('「撤销这次生成」也拦下，这一轮不被标成已撤回', undone === false && kept.outcome === 'applied'
+    && kept.label === '成果（按月）', JSON.stringify({ undone, ...kept }))
+
+  await S(page, () => window.__studio.getState().select('fetch'))
+  await page.waitForTimeout(300)
+  check('检查器整块只读，并说明原因', await count(page, 'fieldset[disabled]:has([data-field="prompt"])') === 1
+    && await page.getByText('只能看，不能改').count() === 1)
+  await S(page, () => window.__studio.getState().updateNode('fetch', { label: '改不动' }))
+  check('store 这一层也拦着（直接调 updateNode 不生效）',
+    (await S(page, () => window.__studio.getState().nodes.find((n) => n.id === 'fetch').data.label)) === '数据查询')
+  const prompt0 = await S(page, () => window.__studio.getState().copilotTurns.length)
+  // 返回 false：输入框据此留着用户刚写的那句，不能拦下了还把它清掉
+  const started = await S(page, () => window.__studio.getState().runCopilot('加一步', true))
+  check('正式运行期间不让助手改图（并告诉输入框没开始）', started === false
+    && (await S(page, () => window.__studio.getState().copilotTurns.length)) === prompt0
+    && !(await S(page, () => window.__studio.getState().copilot.active)), String(started))
+
+  // 跑完就能改了
+  await formal('succeeded')
+  await page.waitForTimeout(150)
+  await S(page, () => window.__studio.getState().addNode('llm'))
+  check('正式运行结束后恢复编辑', (await st(page)).nodes.length === s0.nodes.length + 1)
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+
+  // Shift+1 的名字要和它做的事一致：它回到打开时的取景（从入口看起），不是「看全所有节点」
+  const fit = await page.evaluate(async () => (await import('/src/canvas/shortcuts.ts')).studioShortcut('fit').label)
+  check('Shift+1 叫「重新取景」', fit.startsWith('重新取景') && !fit.includes('看全'), fit)
+  await ctx.close()
+}
+
+// ================================================================ 6d
+console.log('=== 提示词点名的工具没绑定：问题面板定位到工具那一栏，一键绑定（NI-2）；团队用完轮数（NI-5） ===')
+{
+  const { ctx, page, errors } = await open({ path: '/studio/st-lint' })
+  await page.waitForFunction(() => window.__studio.getState().analysis === 'ok', null, { timeout: 8000 })
+  const lint = await S(page, () => window.__studio.getState().issues
+    .filter((i) => /要求用「/.test(i.message)).map((i) => ({ node: i.node_id, field: i.field, msg: i.message.slice(0, 30) })))
+  check('后端校验报出两处「提示词要求用 X 但没绑定」', lint.length === 2, JSON.stringify(lint))
+
+  await page.locator('button[aria-expanded]').filter({ hasText: /错|提示|可运行/ }).first().click()
+  await page.waitForTimeout(250)
+  const agentRow = page.locator('[data-problem]').filter({ hasText: '节点没有绑定它' })
+  check('问题面板里这一条指向「可用工具」', (await agentRow.innerText().catch(() => '')).includes('可用工具'),
+    (await agentRow.innerText().catch(() => '')).replace(/\s+/g, ' ').slice(-20))
+  const memberRow = page.locator('[data-problem]').filter({ hasText: '没有给这个成员绑定它' })
+  check('成员那一条指向「成员「writer」的工具」', (await memberRow.innerText().catch(() => '')).includes('成员「writer」的工具'),
+    (await memberRow.innerText().catch(() => '')).replace(/\s+/g, ' ').slice(-20))
+
+  await agentRow.locator('button').first().click({ timeout: 2000 }).catch(() => {})
+  await page.waitForTimeout(500)
+  const tools = page.locator('[data-field="tools"]')
+  check('点一下：检查器翻到工具那一栏，问题落在那儿', await S(page, () => window.__studio.getState().selectedId) === 'fetch'
+    && (await tools.innerText()).includes('db_schema__shop'))
+  await tools.locator('button:has-text("绑定 db_schema__shop")').click({ timeout: 2000 }).catch(() => {})
+  await page.waitForTimeout(200)
+  const bound = await S(page, () => window.__studio.getState().nodes.find((n) => n.id === 'fetch').data.config.tools)
+  check('一键绑定：工具加进这个节点', JSON.stringify(bound) === JSON.stringify(['db_query__shop', 'db_schema__shop']), JSON.stringify(bound))
+
+  await memberRow.locator('button').first().click({ timeout: 2000 }).catch(() => {})
+  await page.waitForTimeout(500)
+  const member = page.locator('[data-field="agents"] [data-item="1"]')
+  check('成员那一条落在第 2 个成员的工具下面', (await member.locator('[data-sub="tools"]').innerText({ timeout: 2000 })
+    .catch(() => '')).includes('没有给这个成员绑定它'))
+  const inView = await member.locator('[data-sub="tools"]').evaluate((el) => {
+    const r = el.getBoundingClientRect()
+    return r.top >= 0 && r.bottom <= window.innerHeight
+  }, null, { timeout: 2000 }).catch(() => false)
+  check('镜头滚到那个成员的工具', inView)
+  await member.locator('button:has-text("绑定 python_exec")').click({ timeout: 2000 }).catch(() => {})
+  await page.waitForTimeout(200)
+  const mt = await S(page, () => window.__studio.getState().nodes.find((n) => n.id === 'team').data.config.agents[1].tools)
+  check('一键绑定到那个成员', JSON.stringify(mt) === '["python_exec"]', JSON.stringify(mt))
+  await page.waitForFunction(() => !window.__studio.getState().issues.some((i) => /要求用「/.test(i.message)), null, { timeout: 6000 }).catch(() => {})
+  check('绑好之后这两条问题消失', !(await S(page, () => window.__studio.getState().issues.some((i) => /要求用「/.test(i.message)))))
+
+  // 数据源的查询工具要能在选择器里挑到：不然「把它加进工具里」这句话做不到
+  await member.locator('button:has-text("添加")').click({ timeout: 2000 }).catch(() => {})
+  await page.waitForTimeout(300)
+  const pick = await member.innerText({ timeout: 2000 }).catch(() => '')
+  check('工具选择器列出数据源的 db_query__ / db_schema__ 工具', /db_query__/.test(pick) && /db_schema__/.test(pick))
+  await member.locator('button:has-text("收起")').click({ timeout: 2000 }).catch(() => {})
+
+  // NI-5：协作团队用完轮数时怎么收场
+  await S(page, () => window.__studio.getState().select('team'))
+  await page.waitForTimeout(300)
+  const ex = page.locator('[data-field="on_exhausted"]')
+  const exText = await ex.innerText().catch(() => '')
+  check('团队有「用完轮数时」，默认判为失败', exText.includes('用完轮数时')
+    && String(await ex.locator('select').evaluate((el) => el.options[el.selectedIndex].text, null, { timeout: 2000 })
+      .catch(() => '')).includes('判为失败'), exText.slice(0, 40))
+  check('选项说清两者差别', /降档/.test(exText) && /失败/.test(exText) && exText.length > 40)
+  // 报错和右栏都叫人「调大『最多轮数』」：字段名得是这四个字，照着找得到
+  check('轮数字段叫「最多轮数」，和报错里的说法一致',
+    (await page.locator('[data-field="max_rounds"]').innerText().catch(() => '')).includes('最多轮数'))
+  await ex.locator('select').selectOption({ label: '降档交付' }, { timeout: 2000 }).catch(() => {})
+  check('选降档交付写进配置', (await S(page, () => window.__studio.getState().nodes.find((n) => n.id === 'team').data.config.on_exhausted)) === 'degrade')
+  check('没有运行时报错', errors.length === 0, errors.slice(0, 2).join(' | '))
+  await ctx.close()
+}
+
+// ================================================================ 7b
+console.log('=== 工作流目录没取回来：不劝人新建（EmptyState source） ===')
+{
+  // 目录还在读、或者读失败时，「还没有工作流 · 新建」是一句假话：库里可能有几十张
+  for (const mode of ['loading', 'error']) {
+    const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } })
+    const page = await ctx.newPage()
+    await page.route(/\/api\/workflows(\?.*)?$/, (route) => {
+      if (route.request().method() !== 'GET') return route.fallback()
+      return mode === 'loading' ? new Promise(() => {})
+        : route.fulfill({ status: 500, contentType: 'application/json', body: JSON.stringify({ detail: '检查脚本伪造的 500' }) })
+    })
+    await page.goto(`${WEB}/studio`, { waitUntil: 'domcontentloaded' })
+    // 目录一直不回来时，启动屏 5 秒后给「先进去看看」：进去之后才轮到编排页说话
+    if (mode === 'loading') await page.getByRole('button', { name: '先进去看看' }).click({ timeout: 12000 }).catch(() => {})
+    const hit = await page.waitForSelector(`[data-empty-unknown="${mode}"]`, { timeout: 8000 }).then(() => true).catch(() => false)
+    check(mode === 'loading' ? '目录还在读：说「正在读取」' : '目录没取回来：说没取回来、给重新读取', hit
+      && (mode === 'loading' ? /正在读取/ : /没取回来/).test(await page.locator('[data-empty-unknown]').innerText()))
+    check(mode === 'loading' ? '读的时候不劝人新建' : '读失败时不劝人新建',
+      await page.getByRole('button', { name: /新建工作流/ }).count() === 0)
+    await ctx.close()
+  }
+}
+
 // ================================================================ 8
 console.log('=== 删掉眼前这张 ===')
 {
diff --git a/scripts/check-trace.mjs b/scripts/check-trace.mjs
index 89232b5b..bfb5a0ec 100644
--- a/scripts/check-trace.mjs
+++ b/scripts/check-trace.mjs
@@ -541,6 +541,76 @@ console.log('\n=== 右栏收尾（decodeRun） ===')
     fold([start('甲', 1), start('乙', 2), end('甲', 3, 100), end('乙', 4, 300)]).savedMs === 100)
 }
 
+console.log('\n=== 回放时的用量和工具数（逐刻度） ===')
+{
+  // 回放到半路，卡片和 HUD 要写「那一刻」的 tokens 和工具数，而不是拿终值冒充
+  const ev = (seq, type, node_id, data = {}) => ({ seq, type, node_id, ts: 5000 + seq, data })
+  const events = [
+    ev(1, 'run.started', null, { nodes: 2 }),
+    ev(2, 'node.started', 'agent'),
+    ev(3, 'llm.end', 'agent', { input_tokens: 100, output_tokens: 20, cost_usd: 0.001 }),
+    ev(4, 'tool.start', 'agent', { tool: 'db_query__shop' }),
+    ev(5, 'tool.end', 'agent', { tool: 'db_query__shop' }),
+    ev(6, 'tool.start', 'agent', { tool: 'db_query__shop' }),
+    ev(7, 'tool.end', 'agent', { tool: 'db_query__shop' }),
+    ev(8, 'llm.end', 'agent', { input_tokens: 300, output_tokens: 80, cost_usd: 0.004 }),
+    ev(9, 'node.finished', 'agent', { duration_ms: 7000 }),
+    ev(10, 'node.started', 'out'), ev(11, 'node.finished', 'out'),
+    ev(12, 'run.finished', null, { usage: { input_tokens: 400, output_tokens: 100, cost_usd: 0.005 } }),
+  ]
+  const gr = g(['agent', 'out'], [['agent', 'out']])
+  const t = run(events, gr)
+  const at = (seq) => (5000 + seq) * 1000
+  const p4 = project(t, at(4) + 1)
+  check('第一次调工具那一刻：1 次工具、1 个在跑、tokens 只有第一轮',
+    p4.nodes.agent.tools === 1 && p4.nodes.agent.toolsRunning === 1 && p4.nodes.agent.tokensIn === 100
+    && p4.nodes.agent.tokensOut === 20,
+    JSON.stringify(p4.nodes.agent))
+  const p6 = project(t, at(6) + 0.5)
+  check('第二次调工具时：2 次，第一次已经回来', p6.nodes.agent.tools === 2 && p6.nodes.agent.toolsRunning === 1,
+    JSON.stringify(p6.nodes.agent))
+  const p9 = project(t, at(9) + 1)
+  check('节点跑完：用量是这个节点的最终值、没有在跑的工具', p9.nodes.agent.tokensIn === 400
+    && p9.nodes.agent.tokensOut === 100 && p9.nodes.agent.tools === 2 && p9.nodes.agent.toolsRunning === 0,
+    JSON.stringify(p9.nodes.agent))
+  check('回放到开始之前：0，不是终值', project(t, at(1)).nodes.agent.tools === 0
+    && project(t, at(1)).nodes.agent.tokensIn === 0)
+  check('整次运行的用量也按刻度走', p4.tokensIn === 100 && p4.tokensOut === 20 && p9.tokensIn === 400,
+    `${p4.tokensIn}/${p4.tokensOut} → ${p9.tokensIn}`)
+  const live = project(t, trace.lastEventAt(t))
+  check('此刻（实时）读节点的当前值', live.nodes.agent.tokensIn === 400 && live.nodes.agent.tools === 2
+    && live.tokensIn === 400)
+  // 老后端：agent 的调用不发 llm.end，run.finished 的总数比刻度加起来多——回放时那一刻的
+  // 整次用量不可信，给 undefined，不拿终值冒充
+  const old = run([...events.slice(0, 11),
+    ev(12, 'run.finished', null, { usage: { input_tokens: 9000, output_tokens: 900, cost_usd: 0.05 } })], gr)
+  const op = project(old, at(4) + 1)
+  check('刻度对不上后端总数：回放时整次用量写不出', op.tokensIn === undefined && op.tokensOut === undefined,
+    `${op.tokensIn}/${op.tokensOut}`)
+  check('……实时时照样是后端的总数', project(old, trace.lastEventAt(old)).tokensIn === 9000)
+  check('没有 tool / llm 事件的节点刻度为空、读数是 0',
+    t.nodes.out.marks === undefined && project(t, at(11)).nodes.out.tools === 0)
+}
+
+console.log('\n=== 最后一条事件的时刻（lastEventAt） ===')
+{
+  const ev = (seq, type, node_id, data = {}) => ({ seq, type, node_id, ts: 6000 + seq, data })
+  const gr = g([{ id: 'in', type: 'input' }, 'boom', 'after'], [['in', 'boom'], ['boom', 'after']])
+  const t = run([
+    ev(1, 'run.started', null, { nodes: 3 }),
+    ev(2, 'node.started', 'in'), ev(3, 'node.finished', 'in'),
+    ev(4, 'node.started', 'boom'), ev(5, 'node.failed', 'boom', { error: 'x' }),
+    ev(6, 'run.failed', null, { error: 'x', timing: { wall_ms: 5000, active_ms: 4000, wait_ms: 0 } }),
+  ], gr)
+  check('lastEventAt 是最后一条事件的 ts（毫秒）', trace.lastEventAt(t) === 6006 * 1000, `${trace.lastEventAt(t)}`)
+  const settled = project(t, trace.lastEventAt(t))
+  check('投影到这一刻 = 此刻：推导出的阻断还在', settled.nodes.after?.state === 'blocked', settled.nodes.after?.state)
+  check('……后端给的权威时长也在', settled.elapsedMs === 5000 && settled.activeMs === 4000,
+    `${settled.elapsedMs}/${settled.activeMs}`)
+  check('早一毫秒就是按段重建的回放（阻断不在）', project(t, trace.lastEventAt(t) - 1).nodes.after?.state !== 'blocked')
+  check('空航迹的 lastEventAt 是 0', trace.lastEventAt(emptyTrace()) === 0)
+}
+
 console.log('\n=== 性能 ===')
 {
   // 256 段的大循环（真实运行里见过）：一次折叠 + 投影都要快，拖游标才不卡
diff --git a/scripts/check-ui-kit.mjs b/scripts/check-ui-kit.mjs
index c4599b55..ddec323a 100644
--- a/scripts/check-ui-kit.mjs
+++ b/scripts/check-ui-kit.mjs
@@ -1,5 +1,7 @@
-// 基础组件（components/ui.tsx）、前端工具库（lib/*）和连接状态（store/catalog.ts）
-// 的回归检查。
+// 基础组件（components/ui.tsx）、前端工具库（lib/*）、连接状态（store/catalog.ts）
+// 和 api/client 的上传进度的回归检查。管理页共用件（页头、连通胶囊、单选组、删除
+// 后撤销）和失败说明（lib/explain）也在这里：它们从页面挪进了公共层，页面级检查
+// 只走得到其中一两种情况。
 //
 // 这几样是全站的地基，坏了不会在哪一页上报错，只会悄悄变样：弹窗的焦点漏到页面
 // 上、组字时按 Esc 把半屏草稿关掉、toast 压住工具栏按钮、后端一抖整站说「还没有
@@ -105,6 +107,11 @@ for (const [name, ok, detail] of await page.evaluate(() => {
   eq('相对时间：59.6 分钟进位到小时档', ago(59.6 * 60_000), '1 小时前')
   ok('相对时间：23.6 小时不写「24 小时前」', !/24 小时前/.test(ago(23.6 * 3_600_000)), ago(23.6 * 3_600_000))
   eq('短 id', f.shortId('66a5a6ff0011'), '#66a5a6')
+  eq('文件大小：字节', f.formatBytes(820), '820 B')
+  eq('文件大小：KB', f.formatBytes(12_700), '12.4 KB')
+  eq('文件大小：MB', f.formatBytes(3.1 * 1024 * 1024), '3.1 MB')
+  eq('文件大小拿不到写 —', f.formatBytes(undefined), '—')
+  eq('短名去掉括号里的补充', f.shortLabel('OpenAI 兼容（DeepSeek、通义…）'), 'OpenAI 兼容')
 
   // 状态
   eq('succeeded = 已完成', st.statusLabel('succeeded'), '已完成')
@@ -157,6 +164,29 @@ for (const [name, ok, detail] of await page.evaluate(() => {
   ok('isNetworkError 对 HTTP 错误为假', !e.isNetworkError(new ApiError(500, 'NetworkError when attempting to fetch resource')))
   ok('测连接结果里的 ECONNREFUSED 不算连不上后端',
     e.humanizeError({ ok: false, error: 'connect ECONNREFUSED 10.0.0.5:5432' }).title !== '连不上后端服务')
+  // 已经是「标题：原因」的中文人话，不再套一个「操作超时」、把整句当原因（标题说两遍）
+  const zh = e.humanizeError(new ApiError(504, '数据库查询超时：超过 30 秒没有返回，已中断。缩小查询范围后重试。'))
+  ok('中文人话里的「超时」不套「操作超时」', zh.title !== '操作超时' && !(zh.reason ?? '').includes('操作超时')
+    && !(zh.reason && zh.reason.includes(zh.title)), JSON.stringify(zh))
+  eq('英文 timeout 原文照样翻成「操作超时」', e.humanizeError('ReadTimeout: timed out').title, '操作超时')
+  ok('……原因里不带异常类名', !/ReadTimeout/.test(e.humanizeError('ReadTimeout: timed out').reason ?? ''))
+
+  // 失败说明（lib/explain）：记录页、助手流、问数据页共用一份
+  const x = window.__ui.lib.explain
+  const leak = x.explainRunError('模型输出了工具调用的原始标记，但没有真正调用工具。常见原因：节点没有绑定工具，或者模型、服务不支持工具调用。')
+  ok('工具调用标记泄漏：说人话、不给接着跑、指到画布', leak.title === '模型没有真正调用工具' && !leak.continuable && leak.fix === 'canvas', JSON.stringify(leak))
+  const tired = x.explainRunError('NodeError: 协作团队用完 4 轮仍未完成：还缺汇总员的结论')
+  ok('团队轮数用完：标题带轮数，原因是调度者最后的理由', tired.title === '协作团队用完 4 轮仍未完成'
+    && tired.reason === '还缺汇总员的结论' && !tired.continuable, JSON.stringify(tired))
+  const made = x.explainRunError('校验修复无效：修复时出现了原文没有的值：total_count=0')
+  ok('校验修复编造数值：点出是哪个值、不给接着跑', made.reason.includes('total_count=0') && !made.continuable, JSON.stringify(made))
+  eq('提示词点名的工具没绑定', x.explainRunError('提示词要求用 db_query__shop，但节点没有绑定它').title,
+    '提示词要求用「db_query__shop」，但节点没有绑定它')
+  eq('老运行的鉴权失败', x.explainRunError('NodeError: AuthenticationError: Error code: 401 - invalid_api_key').title, '模型鉴权没通过')
+  const miss = x.explainRunError('缺少必填输入：region')
+  ok('缺必填输入：给出是哪一项、重新发起', miss.missingInput === 'region' && miss.fix === 'rerun' && !miss.continuable)
+  eq('没留原因', x.explainRunError(null).title, '运行失败，但没有留下原因')
+  ok('兜底：句中的异常类名也去掉', !/ValueError/.test(x.explainRunError('结构不对：ValueError: bad').title))
   return out
 })) check(name, ok, detail)
 
@@ -305,12 +335,13 @@ await page.waitForTimeout(100)
 check('出错的在 assertive 区', (await page.locator('[role="alert"][aria-live="assertive"]').innerText()).includes('保存失败'))
 check('普通的在 polite 区', (await page.locator('[role="status"][aria-live="polite"]').first().innerText()).includes('已复制到剪贴板'))
 check('出错的能复制', (await page.getByRole('button', { name: '复制详情' }).count()) >= 1)
-// 位置：内容区（让出 56px 导航）居中，顶边在 48px 工具栏之下
+// 位置：内容区（让出 64px 的导航，App 里的 w-16）居中，顶边在 48px 工具栏之下
+const NAV_W = 64
 const stackBox = await page.locator('[role="alert"][aria-live="assertive"]').boundingBox()
 const vw = page.viewportSize().width
 check('toast 在工具栏下沿之下（≥ 56px）', stackBox.y >= 56, `top=${Math.round(stackBox.y)}`)
-check('toast 在内容区里居中', Math.abs(stackBox.x + stackBox.width / 2 - (56 + vw) / 2) < 4,
-  `中线 ${Math.round(stackBox.x + stackBox.width / 2)}，内容区中线 ${(56 + vw) / 2}`)
+check('toast 在内容区里居中', Math.abs(stackBox.x + stackBox.width / 2 - (NAV_W + vw) / 2) < 2,
+  `中线 ${Math.round(stackBox.x + stackBox.width / 2)}，内容区中线 ${(NAV_W + vw) / 2}`)
 const infoCard = page.getByText('已复制到剪贴板')
 await infoCard.hover()
 await page.waitForTimeout(4600)
@@ -339,14 +370,24 @@ const emptyBlock = page.locator('[data-block="空态 EmptyState（模拟离线
 await page.click('#toggle-offline')
 await page.waitForTimeout(100)
 check('横幅出现', (await page.getByText('后端未连接').count()) === 1)
-check('空态改说拿不到数据', (await emptyBlock.getByText('暂时拿不到数据').count()) === 1)
+// 横幅早就挂着（连着时什么都不画），计时器是这一刻才走起来的：头一个数得按此刻算
+const firstSecs = Number((await page.getByText(/秒后自动重试/).innerText()).match(/\d+/)?.[0])
+check('刚断开时倒计时从此刻算（8 秒）', firstSecs === 8 || firstSecs === 7, `横幅 ${firstSecs} 秒`)
+check('空态改说拿不到数据', (await emptyBlock.getByText('暂时拿不到数据').count()) >= 1)
 check('离线空态不许诺「会自动刷新」', (await emptyBlock.getByText(/自动刷新/).count()) === 0)
 check('离线时收起「新建」', (await page.getByRole('button', { name: '新建工作流' }).count()) === 0)
 check('本地空态不受影响', (await page.getByText('没有匹配的工具').count()) === 1)
+// role=alert 整块重念：倒计时一秒一跳，放在里面读屏就一秒念一遍整条横幅
+const bannerAlert = page.locator('[data-offline-banner] [role="alert"]')
+check('横幅外层不是 role=alert', (await page.locator('[data-offline-banner]').getAttribute('role')) === null)
+check('横幅的播报区只有不变的那几句', (await bannerAlert.count()) === 1
+  && (await bannerAlert.innerText()).includes('后端未连接') && !/秒后自动重试/.test(await bannerAlert.innerText()),
+  await bannerAlert.innerText().catch(() => ''))
+check('倒计时对读屏隐藏', (await page.getByText(/秒后自动重试/).getAttribute('aria-hidden')) === 'true')
 // 横幅把工具栏往下推了多少，toast 就跟着让多少
 await page.click('#toast-error')
 await page.waitForTimeout(80)
-const bannerH = (await page.locator('[role="alert"]', { hasText: '后端未连接' }).boundingBox()).height
+const bannerH = (await page.locator('[data-offline-banner]').boundingBox()).height
 const offTop = (await page.locator('[role="alert"][aria-live="assertive"]').boundingBox()).y
 check('离线时 toast 再让出横幅的高度', Math.abs(offTop - (56 + bannerH)) < 2, `top=${Math.round(offTop)}，横幅 ${Math.round(bannerH)}px`)
 await page.evaluate(() => window.__ui.toast.dismiss())
@@ -364,6 +405,158 @@ const wantAria = await page.evaluate(() => window.__ui.lib.keys.ariaShortcut('Mo
 const gotAria = await page.getByRole('button', { name: '刷新列表' }).getAttribute('aria-keyshortcuts')
 check('IconButton 的 aria-keyshortcuts 按平台写', gotAria === wantAria && !/Ctrl|Mod/.test(gotAria), gotAria)
 
+console.log('\n=== 管理页共用件：页头、连通胶囊、单选组、删除后撤销 ===')
+check('页头 48px 高', Math.round((await page.locator('#page-header-demo header').boundingBox()).height) === 48)
+const pills = await page.locator('#health-demo [data-health]').evaluateAll((els) => els.map((el) => el.textContent))
+// 「3 分钟前」是从预览页挂载时算的，跑到这里可能已经过了一分钟
+check('连通胶囊五种说法', pills[0] === '未测试' && /^正在测 · /.test(pills[1]) && /^已连通 · 42 ms · [34] 分钟前测$/.test(pills[2])
+  && pills[3] === '连不上 · 1 小时前测' && /已连通 · 380 ms.*配置改过了/.test(pills[4]), pills.join(' | '))
+check('不知道测的时刻：不留一个悬空的「 · 」', pills[5] === '连不上', JSON.stringify(pills[5]))
+const spoken = await page.locator('#health-demo [role="status"]').evaluateAll((els) => els.map((el) => el.textContent))
+check('读屏那一句不带跳动的计时和相对时间', spoken[1] === '正在测连接' && /^已连通 42 ms，\d\d:\d\d 测的$/.test(spoken[2]), spoken.join(' | '))
+
+const radios = page.locator('#radio-demo [role="radio"]')
+check('单选组只占一个 Tab 位', JSON.stringify(await radios.evaluateAll((els) => els.map((el) => el.tabIndex))) === '[0,-1,-1]')
+const checkedRadio = () => page.locator('#radio-demo [role="radio"][aria-checked="true"]').innerText()
+const focusedRadio = () => page.evaluate(() => document.activeElement?.textContent)
+await radios.first().focus()
+await page.keyboard.press('ArrowRight')
+check('→ 选中下一项并聚焦', (await checkedRadio()) === 'sid' && (await focusedRadio()) === 'sid')
+await page.keyboard.press('End')
+check('End 到最后一项', (await checkedRadio()) === 'dsn')
+await page.keyboard.press('ArrowDown')
+check('↓ 首尾相接', (await checkedRadio()) === 'service_name')
+await page.keyboard.press('ArrowUp')
+await page.keyboard.press('Home')
+check('↑ 往回、Home 到第一项', (await checkedRadio()) === 'service_name' && (await focusedRadio()) === 'service_name')
+await page.keyboard.press('Alt+ArrowRight')
+check('带 Alt 的方向键不接（那是浏览器后退 / 前进）', (await checkedRadio()) === 'service_name')
+await page.getByRole('tab', { name: '模型接入' }).focus()
+await page.keyboard.press('End')
+check('标签页：End 到最后一个', (await page.getByRole('tab', { name: '偏好' }).getAttribute('aria-selected')) === 'true')
+await page.keyboard.press('Home')
+
+let deletes = 0
+page.on('request', (r) => { if (r.method() === 'DELETE') deletes++ })
+const rowShown = (id) => page.locator(`#defer-demo [data-row="${id}"]`).count()
+const undoBtn = page.locator('[role="status"][aria-live="polite"]').getByRole('button', { name: '撤销' })
+await page.getByRole('button', { name: '删除 orders' }).click()
+await page.waitForTimeout(80)
+check('删除：行先拿掉，toast 给「撤销」', (await rowShown('orders')) === 0
+  && (await page.getByText('已删除「orders」').count()) === 1 && (await undoBtn.count()) === 1)
+await page.click('#defer-reload')
+await page.waitForTimeout(50)
+check('撤销窗口里重拉列表，删掉的行不回来', (await rowShown('orders')) === 0)
+await undoBtn.click()
+await page.waitForTimeout(80)
+check('撤销：行回来了，一个 DELETE 都没发', (await rowShown('orders')) === 1 && deletes === 0)
+await page.evaluate(() => window.__ui.toast.dismiss())
+
+console.log('\n=== 空态：catalog 的表没取回来时不说「还没有」 ===')
+const sourceEmpty = page.locator('#empty-source-demo')
+await page.evaluate(() => window.__ui.useCatalog.getState().refresh())
+check('取回来了：照常说「还没有工作流」、给新建', (await sourceEmpty.getByText('还没有工作流').count()) === 1
+  && (await sourceEmpty.locator('#empty-source-action').count()) === 1)
+const realCatalog = await page.evaluate(() => {
+  const s = window.__ui.useCatalog.getState()
+  return { loadedAt: s.loadedAt, checks: s.checks }
+})
+await page.evaluate(() => window.__ui.useCatalog.setState({
+  loadedAt: {}, checks: [{ key: 'workflows', label: '工作流', state: 'pending' }],
+}))
+await page.waitForTimeout(50)
+check('从没取回来过、还在路上：说「正在读取工作流」、收起新建', (await sourceEmpty.getByText('正在读取工作流').count()) === 1
+  && (await sourceEmpty.locator('#empty-source-action').count()) === 0
+  && (await sourceEmpty.locator('[data-empty-unknown="loading"]').getAttribute('role')) === 'status')
+await page.evaluate(() => window.__ui.useCatalog.setState({
+  checks: [{ key: 'workflows', label: '工作流', state: 'error', error: '后端 15 秒没有响应，稍后重试' }],
+}))
+await page.waitForTimeout(50)
+check('超时或报错：说「工作流没取回来」和原因、给重新读取', (await sourceEmpty.getByText('工作流没取回来').count()) === 1
+  && (await sourceEmpty.getByText(/15 秒没有响应.*这里显示为空不代表没有数据/).count()) === 1
+  && (await sourceEmpty.getByRole('button', { name: '重新读取' }).count()) === 1
+  && (await sourceEmpty.locator('#empty-source-action').count()) === 0)
+await page.evaluate((c) => window.__ui.useCatalog.setState(c), realCatalog)
+
+console.log('\n=== catalog：一张表卡住不拖累别的表 ===')
+// /tools 连得上但不回（MCP 服务不应答时就是这样）：以前 Promise.all 等它，工作流也一直空着
+const toolsBefore = await page.evaluate(() => window.__ui.useCatalog.getState().tools.length)
+// unroute 要拿同一个函数引用才摘得掉
+const isTools = (u) => new URL(u).pathname === '/api/tools'
+await page.route(isTools, () => { /* 永远不回 */ })
+const expectWf = await fetch(`${API}/workflows`).then((r) => r.json()).then((l) => l.length, () => null)
+await page.evaluate(() => window.__ui.useCatalog.setState({ workflows: [] }))
+const tHang = Date.now()
+let settled = false
+const hung = page.evaluate(() => window.__ui.useCatalog.getState().refresh()).then(() => { settled = true })
+await page.waitForFunction(() => window.__ui.useCatalog.getState().workflows.length > 0, null, { timeout: 8000 }).catch(() => {})
+let cat = await page.evaluate(() => {
+  const s = window.__ui.useCatalog.getState()
+  return { wf: s.workflows.length, wfAt: s.loadedAt.workflows, tools: s.checks.find((c) => c.key === 'tools')?.state }
+})
+if (expectWf) {
+  check('工作流先回来先填，不等卡住的工具', cat.wf === expectWf && cat.wfAt >= tHang && cat.tools === 'pending',
+    `${JSON.stringify(cat)}，后端有 ${expectWf} 个工作流`)
+}
+// 最多等 20 秒：没有超时的话 refresh 永远不落定，检查自己也不能跟着挂死
+await Promise.race([hung, new Promise((r) => setTimeout(r, 20_000))])
+const hangMs = Date.now() - tHang
+check('refresh 在超时之后落定', settled, `${hangMs}ms 还没落定`)
+cat = await page.evaluate(() => {
+  const s = window.__ui.useCatalog.getState()
+  const c = s.checks.find((x) => x.key === 'tools')
+  return { state: c?.state, error: c?.error, backend: s.backend, tools: s.tools.length, loaded: s.loaded }
+})
+check('卡住的那张 15 秒超时，记成出错并说清', cat.state === 'error' && /15 秒/.test(cat.error ?? '') && hangMs > 14_500 && hangMs < 18_000,
+  `${cat.state} ${cat.error} ${hangMs}ms`)
+check('一张表超时不算后端断开', cat.backend === 'ok', cat.backend)
+check('超时不清空手上已有的那份', cat.tools === toolsBefore, `${toolsBefore} → ${cat.tools}`)
+await page.unroute(isTools)
+
+console.log('\n=== 上传进度（kb.upload 走 XHR） ===')
+const isUpload = (u) => new URL(u).pathname === '/api/kb/upload'
+const uploadVia = async (handler) => {
+  await page.unroute(isUpload)
+  await page.route(isUpload, handler)
+}
+const tryUpload = (size) => page.evaluate(async (size) => {
+  const events = []
+  try {
+    const doc = await window.__ui.api.kb.upload(new File([new Uint8Array(size)], 'orders.csv', { type: 'text/csv' }), 'default',
+      { onProgress: (p) => events.push(p) })
+    return { events, doc }
+  } catch (e) {
+    return { events, err: { isApi: e instanceof window.__ui.ApiError, status: e.status, kind: e.kind, message: e.message } }
+  }
+}, size)
+// 上传进度只有真的走网络才有（page.route 直接 fulfill 时浏览器不发进度事件）。
+// 转给 dev server 上一个不存在的地址：字节真发出去，回 404，什么都不写
+await uploadVia((r) => r.continue({ url: `${WEB}/__upload_probe__` }))
+let up = await tryUpload(300_000)
+const lastUp = up.events.at(-1)
+check('字节发完报 sent，已发 = 总数，且不小于文件大小', !!lastUp?.sent && lastUp.loaded === lastUp.total && lastUp.total >= 300_000,
+  JSON.stringify(up.events.slice(-2)))
+check('sent 只在最后', up.events.filter((p) => p.sent).length === 1 && !up.events.slice(0, -1).some((p) => p.sent))
+check('非 JSON 的错误响应：http 类的 ApiError', up.err?.isApi && up.err.kind === 'http' && up.err.status === 404, JSON.stringify(up.err))
+await uploadVia((r) => r.fulfill({
+  status: 200, contentType: 'application/json',
+  body: JSON.stringify({ id: 'doc_demo', collection: 'default', title: 'orders.csv', source: 'upload', mime: 'text/csv', chunk_count: 0, status: 'processing' }),
+}))
+up = await tryUpload(10)
+check('成功：返回值照常解析', up.doc?.id === 'doc_demo', JSON.stringify(up.err ?? up.doc))
+await uploadVia((r) => r.fulfill({
+  status: 409, contentType: 'application/json', body: JSON.stringify({ detail: '同名文档已经在处理：等它处理完再传' }),
+}))
+up = await tryUpload(10)
+check('后端拒绝：和 fetch 那条路一样的 ApiError，message 是 detail', up.err?.isApi && up.err.status === 409
+  && up.err.kind === 'http' && up.err.message === '同名文档已经在处理：等它处理完再传', JSON.stringify(up.err))
+await uploadVia((r) => r.abort('connectionrefused'))
+up = await tryUpload(10)
+check('连不上：network 类的 ApiError', up.err?.isApi && up.err.kind === 'network' && up.err.status === 0, JSON.stringify(up.err))
+await page.unroute(isUpload)
+// 网络失败会顺手探一次活，等它落定再往下，免得下一段的探活计数多一次
+await page.evaluate(() => window.__ui.useCatalog.getState().checkBackend())
+
 console.log('\n=== 连接状态：心跳、退避、恢复 ===')
 const expectRuns = await fetch(`${API}/runs?limit=3`).then((r) => r.json()).then((r) => r.length, () => null)
 await page.evaluate(() => window.__ui.useCatalog.getState().refresh())