codebee 0.1.101 → 0.1.103

package/app/core/beekeeper.py

@@ -1,183 +1,183 @@
-# -*- coding: utf-8 -*-
-"""蜂巢保全：服务无论以何种方式退出，本服务拉起的蜜蜂 CLI 一起带走。
-
-背景（2026-09-23 用户定案）：CodeBee 关闭后——无论正常退出、Ctrl+C、崩溃
-还是被 taskkill 硬杀——在跑的 CLI/蜜蜂（codex/claude/kimi 等）必须一起杀
-掉，否则孤儿进程把内存吃满。当天 16:50 一次服务重启就留过一只孤儿
-claude.exe（直到管道断裂才饿死）。
-
-Windows：Job Object（JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE）。蜜蜂 Popen 一出生
-就 AssignProcessToJobObject 挂进蜂巢，整棵子进程树自动继承巢内身份；服务进
-程死亡（哪怕 os._exit 跳过 atexit、被 TerminateProcess 断头）时内核关闭巢柄，
-负责把巢内进程全部收走——这是唯一能覆盖「任意死法」的机制。
-  - 升级重启的新实例（selfupdate.relaunch）不经 run_process、不挂巢，得以
-    存活——否则就地重启等于自杀。桌面蜜蜂、explorer、cmd /k 交互终端同理豁免。
-POSIX（含 Mac）：没有 Job Object 也没有 Linux 的 prctl PDEATHSIG，靠登记 +
-atexit 清扫兜底：run_process 的子进程本就 start_new_session（自成进程组，
-pgid==pid），sweep 用 killpg 连树杀。正常退出 / Ctrl+C / SIGTERM/SIGHUP
-（main.py 已把它们转成 SystemExit，atexit 照跑）全覆盖；仅 kill -9 无解
-（任何机制都救不了，属已知边界）。
-
-本模块绝不抛异常：挂巢失败只降级为旧行为（取消/超时收尸仍在），绝不影响
-蜜蜂正常起跑。不依赖 pywin32，ctypes 直调 kernel32。
-"""
-from __future__ import annotations
-
-import atexit
-import collections
-import os
-import signal
-import weakref
-
-# 近期蜜蜂登记：只保最近若干条防无限增长。Windows 上 Job 是主机制、登记只是
-# atexit 兜底的补充；POSIX 上登记是主机制（sweep 全靠它）。
-_RECENT = collections.deque(maxlen=256)
-
-
-# ---------------------------------------------------------------- Windows 巢
-if os.name == "nt":
-    import ctypes
-    from ctypes import wintypes
-
-    _LIMIT_KILL_ON_JOB_CLOSE = 0x00002000
-    _INFO_JOB_OBJECT_EXTENDED_LIMIT = 9
-    _STILL_ACTIVE = 259
-
-    class _IO_COUNTERS(ctypes.Structure):
-        _fields_ = [(n, ctypes.c_ulonglong) for n in (
-            "ReadOperationCount", "WriteOperationCount", "OtherOperationCount",
-            "ReadTransferCount", "WriteTransferCount", "OtherTransferCount")]
-
-    class _JOBOBJECT_BASIC_LIMIT_INFORMATION(ctypes.Structure):
-        _fields_ = [
-            ("PerProcessUserTimeLimit", ctypes.c_longlong),
-            ("PerJobUserTimeLimit", ctypes.c_longlong),
-            ("LimitFlags", wintypes.DWORD),
-            ("MinimumWorkingSetSize", ctypes.c_size_t),
-            ("MaximumWorkingSetSize", ctypes.c_size_t),
-            ("ActiveProcessLimit", wintypes.DWORD),
-            ("Affinity", ctypes.c_size_t),          # ULONG_PTR
-            ("PriorityClass", wintypes.DWORD),
-            ("SchedulingClass", wintypes.DWORD),
-        ]
-
-    class _JOBOBJECT_EXTENDED_LIMIT_INFORMATION(ctypes.Structure):
-        _fields_ = [
-            ("BasicLimitInformation", _JOBOBJECT_BASIC_LIMIT_INFORMATION),
-            ("IoInfo", _IO_COUNTERS),
-            ("ProcessMemoryLimit", ctypes.c_size_t),
-            ("JobMemoryLimit", ctypes.c_size_t),
-            ("PeakProcessMemoryUsed", ctypes.c_size_t),
-            ("PeakJobMemoryUsed", ctypes.c_size_t),
-        ]
-
-    _kernel32 = ctypes.windll.kernel32
-
-    class BeeNest:
-        """一个 KILL_ON_JOB_CLOSE 巢。生产用模块单例 NEST；测试自建私有巢。"""
-
-        def __init__(self):
-            self._handle = None
-            self.assigned = 0
-
-        def _ensure_job(self):
-            if self._handle:
-                return self._handle
-            h = _kernel32.CreateJobObjectW(None, None)
-            if not h:
-                return None
-            info = _JOBOBJECT_EXTENDED_LIMIT_INFORMATION()
-            info.BasicLimitInformation.LimitFlags = _LIMIT_KILL_ON_JOB_CLOSE
-            if not _kernel32.SetInformationJobObject(
-                    h, _INFO_JOB_OBJECT_EXTENDED_LIMIT,
-                    ctypes.byref(info), ctypes.sizeof(info)):
-                _kernel32.CloseHandle(h)
-                return None
-            self._handle = h
-            return h
-
-        def adopt(self, proc):
-            h = self._ensure_job()
-            if not h:
-                return
-            handle = getattr(proc, "_handle", None)
-            if not handle:
-                return
-            # 子进程树（cmd /c 垫片 → claude.exe → 其孙）自动继承巢内身份，
-            # 只需挂直系子进程。Win8+ 支持嵌套 Job，外层有别的 Job 也不碍事。
-            if _kernel32.AssignProcessToJobObject(h, int(handle)):
-                self.assigned += 1
-
-        def close(self):
-            """主动关巢：巢内进程全部被内核收走（等价于服务进程死亡）。"""
-            if self._handle:
-                try:
-                    _kernel32.CloseHandle(self._handle)
-                except Exception:
-                    pass
-                self._handle = None
-
-else:
-    class BeeNest:
-        """POSIX 占位巢：杀全靠 sweep()（登记 + killpg），close 无事可做。"""
-
-        def __init__(self):
-            self.assigned = 0
-
-        def adopt(self, proc):
-            self.assigned += 1
-
-        def close(self):
-            pass
-
-
-NEST = BeeNest()
-
-
-def adopt(proc):
-    """把蜜蜂进程挂巢：服务死则蜜蜂亡。绝不抛异常、绝不拖慢起跑。"""
-    if proc is None:
-        return
-    try:
-        _RECENT.append((proc.pid, weakref.ref(proc)))
-        NEST.adopt(proc)
-    except Exception:
-        pass
-
-
-def sweep():
-    """退出清扫：登记在册且仍存活的蜜蜂连树杀。
-
-    POSIX 主机制（atexit 在正常退出/Ctrl+C/SIGTERM→SystemExit 时都会跑）；
-    Windows 只是 Job 的兜底（Job 建不出来或句柄异常时仍能杀到登记的直系
-    进程，孙进程交给既有 taskkill /T 收尸路径）。Windows 端拿不到 Popen
-    存活证据的条目不盲杀——防 PID 复用误伤无辜进程（反正有 Job 兜底）。
-    """
-    while _RECENT:
-        pid, ref = _RECENT.popleft()
-        proc = ref() if ref else None
-        if proc is not None:
-            try:
-                if proc.poll() is not None:
-                    continue          # 已退出，跳过
-            except Exception:
-                pass
-        if os.name == "nt":
-            if proc is None:
-                continue
-            try:
-                os.kill(pid, signal.SIGTERM)   # Windows 语义 = TerminateProcess
-            except Exception:
-                pass
-        else:
-            # run_process 子进程 start_new_session：pgid==pid，killpg 连树杀
-            try:
-                os.killpg(pid, signal.SIGKILL)
-            except Exception:
-                try:
-                    os.kill(pid, signal.SIGKILL)
-                except Exception:
-                    pass
-
-
-atexit.register(sweep)
+# -*- coding: utf-8 -*-
+"""蜂巢保全：服务无论以何种方式退出，本服务拉起的蜜蜂 CLI 一起带走。
+
+背景（2026-09-23 用户定案）：CodeBee 关闭后——无论正常退出、Ctrl+C、崩溃
+还是被 taskkill 硬杀——在跑的 CLI/蜜蜂（codex/claude/kimi 等）必须一起杀
+掉，否则孤儿进程把内存吃满。当天 16:50 一次服务重启就留过一只孤儿
+claude.exe（直到管道断裂才饿死）。
+
+Windows：Job Object（JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE）。蜜蜂 Popen 一出生
+就 AssignProcessToJobObject 挂进蜂巢，整棵子进程树自动继承巢内身份；服务进
+程死亡（哪怕 os._exit 跳过 atexit、被 TerminateProcess 断头）时内核关闭巢柄，
+负责把巢内进程全部收走——这是唯一能覆盖「任意死法」的机制。
+  - 升级重启的新实例（selfupdate.relaunch）不经 run_process、不挂巢，得以
+    存活——否则就地重启等于自杀。桌面蜜蜂、explorer、cmd /k 交互终端同理豁免。
+POSIX（含 Mac）：没有 Job Object 也没有 Linux 的 prctl PDEATHSIG，靠登记 +
+atexit 清扫兜底：run_process 的子进程本就 start_new_session（自成进程组，
+pgid==pid），sweep 用 killpg 连树杀。正常退出 / Ctrl+C / SIGTERM/SIGHUP
+（main.py 已把它们转成 SystemExit，atexit 照跑）全覆盖；仅 kill -9 无解
+（任何机制都救不了，属已知边界）。
+
+本模块绝不抛异常：挂巢失败只降级为旧行为（取消/超时收尸仍在），绝不影响
+蜜蜂正常起跑。不依赖 pywin32，ctypes 直调 kernel32。
+"""
+from __future__ import annotations
+
+import atexit
+import collections
+import os
+import signal
+import weakref
+
+# 近期蜜蜂登记：只保最近若干条防无限增长。Windows 上 Job 是主机制、登记只是
+# atexit 兜底的补充；POSIX 上登记是主机制（sweep 全靠它）。
+_RECENT = collections.deque(maxlen=256)
+
+
+# ---------------------------------------------------------------- Windows 巢
+if os.name == "nt":
+    import ctypes
+    from ctypes import wintypes
+
+    _LIMIT_KILL_ON_JOB_CLOSE = 0x00002000
+    _INFO_JOB_OBJECT_EXTENDED_LIMIT = 9
+    _STILL_ACTIVE = 259
+
+    class _IO_COUNTERS(ctypes.Structure):
+        _fields_ = [(n, ctypes.c_ulonglong) for n in (
+            "ReadOperationCount", "WriteOperationCount", "OtherOperationCount",
+            "ReadTransferCount", "WriteTransferCount", "OtherTransferCount")]
+
+    class _JOBOBJECT_BASIC_LIMIT_INFORMATION(ctypes.Structure):
+        _fields_ = [
+            ("PerProcessUserTimeLimit", ctypes.c_longlong),
+            ("PerJobUserTimeLimit", ctypes.c_longlong),
+            ("LimitFlags", wintypes.DWORD),
+            ("MinimumWorkingSetSize", ctypes.c_size_t),
+            ("MaximumWorkingSetSize", ctypes.c_size_t),
+            ("ActiveProcessLimit", wintypes.DWORD),
+            ("Affinity", ctypes.c_size_t),          # ULONG_PTR
+            ("PriorityClass", wintypes.DWORD),
+            ("SchedulingClass", wintypes.DWORD),
+        ]
+
+    class _JOBOBJECT_EXTENDED_LIMIT_INFORMATION(ctypes.Structure):
+        _fields_ = [
+            ("BasicLimitInformation", _JOBOBJECT_BASIC_LIMIT_INFORMATION),
+            ("IoInfo", _IO_COUNTERS),
+            ("ProcessMemoryLimit", ctypes.c_size_t),
+            ("JobMemoryLimit", ctypes.c_size_t),
+            ("PeakProcessMemoryUsed", ctypes.c_size_t),
+            ("PeakJobMemoryUsed", ctypes.c_size_t),
+        ]
+
+    _kernel32 = ctypes.windll.kernel32
+
+    class BeeNest:
+        """一个 KILL_ON_JOB_CLOSE 巢。生产用模块单例 NEST；测试自建私有巢。"""
+
+        def __init__(self):
+            self._handle = None
+            self.assigned = 0
+
+        def _ensure_job(self):
+            if self._handle:
+                return self._handle
+            h = _kernel32.CreateJobObjectW(None, None)
+            if not h:
+                return None
+            info = _JOBOBJECT_EXTENDED_LIMIT_INFORMATION()
+            info.BasicLimitInformation.LimitFlags = _LIMIT_KILL_ON_JOB_CLOSE
+            if not _kernel32.SetInformationJobObject(
+                    h, _INFO_JOB_OBJECT_EXTENDED_LIMIT,
+                    ctypes.byref(info), ctypes.sizeof(info)):
+                _kernel32.CloseHandle(h)
+                return None
+            self._handle = h
+            return h
+
+        def adopt(self, proc):
+            h = self._ensure_job()
+            if not h:
+                return
+            handle = getattr(proc, "_handle", None)
+            if not handle:
+                return
+            # 子进程树（cmd /c 垫片 → claude.exe → 其孙）自动继承巢内身份，
+            # 只需挂直系子进程。Win8+ 支持嵌套 Job，外层有别的 Job 也不碍事。
+            if _kernel32.AssignProcessToJobObject(h, int(handle)):
+                self.assigned += 1
+
+        def close(self):
+            """主动关巢：巢内进程全部被内核收走（等价于服务进程死亡）。"""
+            if self._handle:
+                try:
+                    _kernel32.CloseHandle(self._handle)
+                except Exception:
+                    pass
+                self._handle = None
+
+else:
+    class BeeNest:
+        """POSIX 占位巢：杀全靠 sweep()（登记 + killpg），close 无事可做。"""
+
+        def __init__(self):
+            self.assigned = 0
+
+        def adopt(self, proc):
+            self.assigned += 1
+
+        def close(self):
+            pass
+
+
+NEST = BeeNest()
+
+
+def adopt(proc):
+    """把蜜蜂进程挂巢：服务死则蜜蜂亡。绝不抛异常、绝不拖慢起跑。"""
+    if proc is None:
+        return
+    try:
+        _RECENT.append((proc.pid, weakref.ref(proc)))
+        NEST.adopt(proc)
+    except Exception:
+        pass
+
+
+def sweep():
+    """退出清扫：登记在册且仍存活的蜜蜂连树杀。
+
+    POSIX 主机制（atexit 在正常退出/Ctrl+C/SIGTERM→SystemExit 时都会跑）；
+    Windows 只是 Job 的兜底（Job 建不出来或句柄异常时仍能杀到登记的直系
+    进程，孙进程交给既有 taskkill /T 收尸路径）。Windows 端拿不到 Popen
+    存活证据的条目不盲杀——防 PID 复用误伤无辜进程（反正有 Job 兜底）。
+    """
+    while _RECENT:
+        pid, ref = _RECENT.popleft()
+        proc = ref() if ref else None
+        if proc is not None:
+            try:
+                if proc.poll() is not None:
+                    continue          # 已退出，跳过
+            except Exception:
+                pass
+        if os.name == "nt":
+            if proc is None:
+                continue
+            try:
+                os.kill(pid, signal.SIGTERM)   # Windows 语义 = TerminateProcess
+            except Exception:
+                pass
+        else:
+            # run_process 子进程 start_new_session：pgid==pid，killpg 连树杀
+            try:
+                os.killpg(pid, signal.SIGKILL)
+            except Exception:
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                except Exception:
+                    pass
+
+
+atexit.register(sweep)

package/app/core/benchstore.py

@@ -1,102 +1,102 @@
-# -*- coding: utf-8 -*-
-"""评测基准台存储层（L0）：data/eval_bench.json 的读写与「实测分软信号」。
-
-evalbench（L2，跑评测）与 dispatch（L0，模型链评分）都要摸这份数据——
-读写下沉到这里，两边同层合法引用（dispatch 不能 import L2 的 evalbench，
-分层政策 L_i 只准 import L_j (j<=i)）。
-
-实测分软信号口径（写入 docs/execution-standard.md 候选打分权重表）：
-  bonus = clamp((overall − 7.0) × 1.5, −4.5, +4.5)
-  7 分以下开始倒扣、9 分封顶 +4.5；无数据/超新鲜度记 0——缺数据不猜分。
-  新鲜度 14 天：评测会过期（evaluation.py 同理念），过期实测不参与排序。
-"""
-from __future__ import annotations
-
-import json
-import threading
-import time
-from pathlib import Path
-
-from . import paths
-
-_LOCK = threading.RLock()
-FRESH_DAYS = 14            # 实测分新鲜度（天）；0 = 永不过期（测试用）
-_BASELINE = 7.0            # 及格线：低于它开始倒扣
-_K = 1.5                   # 斜率：每 1 分 ±1.5
-_MAX_BONUS = 4.5           # 封顶（与在线信号 ±6 同量级，翻不动硬约束）
-
-
-def _path():
-    return Path(paths.DATA_DIR) / "eval_bench.json"
-
-
-def read_doc():
-    with _LOCK:
-        try:
-            data = json.loads(_path().read_text(encoding="utf-8"))
-            return data if isinstance(data, dict) else {}
-        except Exception:
-            return {}
-
-
-def write_doc(data):
-    with _LOCK:
-        _path().parent.mkdir(parents=True, exist_ok=True)
-        tmp = _path().with_suffix(".tmp")
-        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-        tmp.replace(_path())
-
-
-def read_results():
-    results = read_doc().get("results")
-    return [r for r in results if isinstance(r, dict)] if isinstance(results, list) else []
-
-
-def _fresh(row, max_age_days):
-    """行是否在新鲜度窗口内。ts 缺失/解析失败按过期处理（宁缺毋滥）。"""
-    if max_age_days <= 0:
-        return True
-    try:
-        ts = time.mktime(time.strptime(str(row.get("ts") or ""),
-                                       "%Y-%m-%d %H:%M:%S"))
-    except ValueError:
-        return False
-    return (time.time() - ts) <= max_age_days * 86400.0
-
-
-def bonus_map(max_age_days=FRESH_DAYS):
-    """{(provider_id, model): {"overall": x, "ts": s}}——每键取最新一条
-    已得分记录，且必须在新鲜度窗口内。"""
-    latest = {}
-    for r in read_results():
-        if not r.get("scored") or r.get("overall") is None:
-            continue
-        key = (str(r.get("provider_id") or ""), str(r.get("model") or ""))
-        if not key[1]:
-            continue
-        prev = latest.get(key)
-        if prev is None or str(r.get("ts") or "") > str(prev.get("ts") or ""):
-            latest[key] = r
-    out = {}
-    for k, v in latest.items():
-        if not _fresh(v, max_age_days):
-            continue
-        overall = float(v["overall"])
-        out[k] = {"overall": overall, "ts": str(v.get("ts") or ""),
-                  "bonus": round(max(-_MAX_BONUS, min(_MAX_BONUS,
-                                                      (overall - _BASELINE) * _K)), 2)}
-    return out
-
-
-def bonus_for(provider_id, model, max_age_days=FRESH_DAYS):
-    """单条目的实测软信号。返回 (score, reason)；无数据/过期 → (0.0, "")。"""
-    try:
-        info = bonus_map(max_age_days).get((str(provider_id or ""), str(model or "")))
-        if not info:
-            return 0.0, ""
-        score = max(-_MAX_BONUS, min(_MAX_BONUS, (info["overall"] - _BASELINE) * _K))
-        score = round(score, 2)
-        return score, "实测 %.1f 分（%+.1f，%s）" % (
-            info["overall"], score, (info.get("ts") or "")[:10])
-    except Exception:
-        return 0.0, ""
+# -*- coding: utf-8 -*-
+"""评测基准台存储层（L0）：data/eval_bench.json 的读写与「实测分软信号」。
+
+evalbench（L2，跑评测）与 dispatch（L0，模型链评分）都要摸这份数据——
+读写下沉到这里，两边同层合法引用（dispatch 不能 import L2 的 evalbench，
+分层政策 L_i 只准 import L_j (j<=i)）。
+
+实测分软信号口径（写入 docs/execution-standard.md 候选打分权重表）：
+  bonus = clamp((overall − 7.0) × 1.5, −4.5, +4.5)
+  7 分以下开始倒扣、9 分封顶 +4.5；无数据/超新鲜度记 0——缺数据不猜分。
+  新鲜度 14 天：评测会过期（evaluation.py 同理念），过期实测不参与排序。
+"""
+from __future__ import annotations
+
+import json
+import threading
+import time
+from pathlib import Path
+
+from . import paths
+
+_LOCK = threading.RLock()
+FRESH_DAYS = 14            # 实测分新鲜度（天）；0 = 永不过期（测试用）
+_BASELINE = 7.0            # 及格线：低于它开始倒扣
+_K = 1.5                   # 斜率：每 1 分 ±1.5
+_MAX_BONUS = 4.5           # 封顶（与在线信号 ±6 同量级，翻不动硬约束）
+
+
+def _path():
+    return Path(paths.DATA_DIR) / "eval_bench.json"
+
+
+def read_doc():
+    with _LOCK:
+        try:
+            data = json.loads(_path().read_text(encoding="utf-8"))
+            return data if isinstance(data, dict) else {}
+        except Exception:
+            return {}
+
+
+def write_doc(data):
+    with _LOCK:
+        _path().parent.mkdir(parents=True, exist_ok=True)
+        tmp = _path().with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(_path())
+
+
+def read_results():
+    results = read_doc().get("results")
+    return [r for r in results if isinstance(r, dict)] if isinstance(results, list) else []
+
+
+def _fresh(row, max_age_days):
+    """行是否在新鲜度窗口内。ts 缺失/解析失败按过期处理（宁缺毋滥）。"""
+    if max_age_days <= 0:
+        return True
+    try:
+        ts = time.mktime(time.strptime(str(row.get("ts") or ""),
+                                       "%Y-%m-%d %H:%M:%S"))
+    except ValueError:
+        return False
+    return (time.time() - ts) <= max_age_days * 86400.0
+
+
+def bonus_map(max_age_days=FRESH_DAYS):
+    """{(provider_id, model): {"overall": x, "ts": s}}——每键取最新一条
+    已得分记录，且必须在新鲜度窗口内。"""
+    latest = {}
+    for r in read_results():
+        if not r.get("scored") or r.get("overall") is None:
+            continue
+        key = (str(r.get("provider_id") or ""), str(r.get("model") or ""))
+        if not key[1]:
+            continue
+        prev = latest.get(key)
+        if prev is None or str(r.get("ts") or "") > str(prev.get("ts") or ""):
+            latest[key] = r
+    out = {}
+    for k, v in latest.items():
+        if not _fresh(v, max_age_days):
+            continue
+        overall = float(v["overall"])
+        out[k] = {"overall": overall, "ts": str(v.get("ts") or ""),
+                  "bonus": round(max(-_MAX_BONUS, min(_MAX_BONUS,
+                                                      (overall - _BASELINE) * _K)), 2)}
+    return out
+
+
+def bonus_for(provider_id, model, max_age_days=FRESH_DAYS):
+    """单条目的实测软信号。返回 (score, reason)；无数据/过期 → (0.0, "")。"""
+    try:
+        info = bonus_map(max_age_days).get((str(provider_id or ""), str(model or "")))
+        if not info:
+            return 0.0, ""
+        score = max(-_MAX_BONUS, min(_MAX_BONUS, (info["overall"] - _BASELINE) * _K))
+        score = round(score, 2)
+        return score, "实测 %.1f 分（%+.1f，%s）" % (
+            info["overall"], score, (info.get("ts") or "")[:10])
+    except Exception:
+        return 0.0, ""

package/app/core/board.py

@@ -66,22 +66,16 @@ def run_detail(run_id):
     }
 
 
-def _tail(step):
-    """步骤实时流（正文优先，其次思考）的最后一行，给大屏跑马灯。"""
-    for key in ("stream", "thinking"):
-        v = step.get(key)
-        if isinstance(v, str) and v.strip():
-            lines = [ln.strip() for ln in v.strip().splitlines() if ln.strip()]
-            if lines:
-                return lines[-1][:_TAIL_MAX]
-    return ""
-
-
-def _live_block(step):
+def _live_windows(run_id, step):
     """步骤实时流窗口：尾部多行（正文优先，其次思考），供大屏看它在想什么。
 
     返回 (来源标签 code, 文本)；标签是 code（output/thinking），由前端 i18n
-    翻译——大屏要做多语言，后端不下发中文。都没有返回 ("", "")。
+    翻译——大屏要做多语言，后端不下发中文。
+
+    内置智能体步骤边跑边把流写进步骤记录（store.stream_step）；外部 CLI 步骤
+    只落日志文件、run.json 里没有 stream——此前的连载全 CLI 流程在大屏上永远
+    「等待实时输出…」（弹窗日志却有内容，2026-10-10 用户反馈）。故回退读日志
+    尾巴：与蜂巢卡 hiveTick 同源同窗口（tail 夹取，不整读大日志）。
     """
     for key, code in (("stream", "output"), ("thinking", "thinking")):
         v = step.get(key)
@@ -91,6 +85,14 @@ def _live_block(step):
         lines = [ln for ln in lines if ln]
         if lines:
             return code, "\n".join(lines[-_TAIL_LINES:])
+    rel = step.get("log")
+    if rel and run_id:
+        from . import store
+        text = store.read_step_log(str(run_id), str(rel), tail=2400, pretty=True)
+        lines = [ln.strip()[:_TAIL_LINE_CHARS] for ln in (text or "").splitlines()]
+        lines = [ln for ln in lines if ln]
+        if lines:
+            return "output", "\n".join(lines[-_TAIL_LINES:])
     return "", ""
 
 
@@ -129,18 +131,19 @@ def _duration_s(run):
     return None
 
 
-def _step_view(steps, prov_map):
+def _step_view(steps, prov_map, run_id=""):
     """进度概要：完成数 + 当前运行中步骤（含模型/厂商/实时流）。"""
     done = sum(1 for s in steps if s.get("status") == "done")
     cur = next((s for s in steps if s.get("status") == "running"), None)
     cur_v = None
     if cur:
-        live_label, live_text = _live_block(cur)
+        live_label, live_text = _live_windows(run_id, cur)
         model = str(cur.get("model") or "")[:60]
+        tail = (live_text.splitlines() or [""])[-1][:_TAIL_MAX] if live_text else ""
         cur_v = {"n": cur.get("n"), "role": cur.get("role") or "",
                  "agent": cur.get("agent_label") or cur.get("agent") or "",
                  "summary": (cur.get("summary") or "")[:80],
-                 "tail": _tail(cur),
+                 "tail": tail,
                  "model": model, "provider": prov_map.get(model, "") if model else "",
                  "live_label": live_label, "live_text": live_text}
     return done, len(steps), cur_v
@@ -167,7 +170,8 @@ def _build():
         run = latest.get(tid)
         status = t.get("status")
         if status == "running" and run and run.get("status") == "running":
-            done, total, cur = _step_view(run.get("steps") or [], prov_map)
+            done, total, cur = _step_view(run.get("steps") or [], prov_map,
+                                          run_id=run.get("id"))
             running.append({
                 "task_id": tid, "run_id": run.get("id"),
                 "title": t.get("title") or "", "goal": (t.get("goal") or "")[:120],