codebee 0.1.105 → 0.1.106

package/app/core/publish/manager.py

@@ -99,6 +99,7 @@ def _quality_release_guard(task, plat, action="publish", target_chapter=None,
     decision["version_snapshot"] = quality_gate.local_version(task.get("workdir") or "")
     decision["platform_snapshot"] = ledger.book_for(task.get("id"), plat) or {}
     if verdict:
+        decision["reviewed_through"] = verdict.get("end_chapter") or 0
         decision["quality_status"] = verdict.get("quality_status") or "continue_only"
         decision["review_run_id"] = run.get("id")
     return decision
@@ -720,7 +721,10 @@ def register_book(task_id, plat, title, book_id=""):
                 or old.get("title") != title[:120]):
         ledger.update_book(task_id, plat, remote_total=None, remote_published=None,
                            remote_review=None, remote_rejected=None,
-                           remote_synced_at=None, remote_error=None)
+                           remote_synced_at=None, remote_error=None,
+                           remote_published_nos=None,
+                           confirmed_published_through=None,
+                           confirmed_published_at=None)
     ledger.save_book(task_id, plat, {"book_id": str(book_id or "").strip(),
                                      "title": title[:120], "source": "manual"})
     return True, ""

package/app/core/runtime_lock.py

@@ -0,0 +1,75 @@
+"""One service per data directory, shared by CLI and desktop launchers."""
+from __future__ import annotations
+
+import atexit
+import os
+from pathlib import Path
+from typing import IO, Optional
+
+
+class ServiceAlreadyRunning(RuntimeError):
+    """Another process owns this data directory."""
+
+
+class ServiceLease:
+    """OS-backed lock; a crashed process releases it automatically."""
+
+    def __init__(self, directory: Path):
+        self.directory = Path(directory)
+        self._file: Optional[IO[bytes]] = None
+
+    def acquire(self) -> None:
+        if self._file is not None:
+            return
+        self.directory.mkdir(parents=True, exist_ok=True)
+        # Never unlink this file: replacing its inode defeats POSIX file locks.
+        handle = (self.directory / "service.lock").open("a+b")
+        try:
+            if os.name == "nt":
+                import msvcrt
+                handle.seek(0, os.SEEK_END)
+                if handle.tell() == 0:
+                    handle.write(b"0")
+                    handle.flush()
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+            else:
+                import fcntl
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError as exc:
+            handle.close()
+            raise ServiceAlreadyRunning(
+                "CodeBee 已在使用此数据目录，请先退出已有服务：%s" % self.directory
+            ) from exc
+        self._file = handle
+
+    def release(self) -> None:
+        handle, self._file = self._file, None
+        if handle is not None:
+            # Closing the handle releases both flock and Windows byte locks.
+            handle.close()
+        key = str(self.directory.resolve())
+        if _LEASES.get(key) is self:
+            _LEASES.pop(key, None)
+
+    def __enter__(self) -> "ServiceLease":
+        self.acquire()
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        self.release()
+
+
+_LEASES = {}
+
+
+def acquire_service(directory: Path) -> ServiceLease:
+    """Keep a service lease until process exit; repeated startup calls reuse it."""
+    key = str(Path(directory).resolve())
+    lease = _LEASES.get(key)
+    if lease is None or lease._file is None:
+        lease = ServiceLease(Path(key))
+        lease.acquire()
+        _LEASES[key] = lease
+        atexit.register(lease.release)
+    return lease

package/app/core/selfupdate.py

@@ -50,6 +50,8 @@ def package_version():
 
 def install_mode():
     """npm / repo / source / other（见模块 docstring）。"""
+    if os.environ.get("CODEBEE_DESKTOP") == "1":
+        return "desktop"
     try:
         parts = [p.lower() for p in paths.ROOT.resolve().parts]
     except Exception:
@@ -138,6 +140,10 @@ def check(force=False):
     cur = package_version()
     out = {"mode": mode, "current": cur, "latest": "", "has_update": False,
            "note": "", "notes": "", "whatsnew": changelog_section(cur)}
+    if mode == "desktop":
+        out["download_url"] = "https://github.com/Vercel-By-WXP/CodeBee/releases"
+        out["note"] = "桌面预览版：请从应用菜单打开下载页，退出应用后安装新版；任务和配置保留。"
+        return out
     if mode != "npm":
         out["note"] = ("开发仓库模式：请用 git pull 更新（自动升级会覆盖未提交的代码）"
                        if mode == "repo" else "非 npm 安装，无法自动更新")
@@ -352,6 +358,8 @@ def wait_port_before_bind(port):
 def relaunch(port):
     """就地重启：拉起新实例（--wait-port 等新端口可 bind 时旧实例已自退）。
     调用方发送完重启响应后应 self_quit()。port 经 int() 强校验，argv 全字面量。"""
+    if install_mode() == "desktop":
+        return False  # Only the desktop shell may replace its owned sidecar.
     port = int(port)
     if port < 1 or port > 65535:
         return False

package/app/core/store.py

@@ -2352,8 +2352,31 @@ def write_report(run_id, markdown):
     return p
 
 
+def _builtin_live_log_text(run, rel_path):
+    """内置智能体步骤从不落 steps/*.log（实时流只写 run.json），日志文件缺席
+    时用步骤记录拼一份可读日志兜底——否则所有读日志文件的面板（大屏下钻抽屉/
+    蜂巢弹窗/日志抽屉）对 CodeBee 步骤永远「日志为空」，分不清真死还是在干活
+    （2026-10-12 用户反馈）。运行中：活动+思考+正文流；已结束：思考+正文+摘要
+    （stream/activity 收尾即清，finish_step 另落 output/summary）。"""
+    step = next((s for s in (run.get("steps") or [])
+                 if s.get("log") == rel_path), None)
+    if not step:
+        return ""
+    parts = []
+    for act in (step.get("activity") or []):
+        if act:
+            parts.append("【活动】" + str(act))
+    for key, tag in (("thinking", "【思考】"), ("stream", "【正文】"),
+                     ("output", "【正文】"), ("summary", "【摘要】")):
+        v = str(step.get(key) or "").strip()
+        if v:
+            parts.append(tag + " " + v)
+    return "\n".join(parts)
+
+
 def read_step_log(run_id, rel_path, tail=paths.LOG_TAIL_CHARS, pretty=False):
     p = (paths.RUNS_DIR / run_id / rel_path).resolve()
+    text = ""
     try:
         # 防目录穿越：必须落在本 run 目录内
         if paths.RUNS_DIR.resolve() not in p.parents:
@@ -2369,6 +2392,13 @@ def read_step_log(run_id, rel_path, tail=paths.LOG_TAIL_CHARS, pretty=False):
         text = runner.collapse_dup_lines(runner.clean_cli_text(text))
         if pretty:
             text = runner.pretty_cli_log(text)
-        return text
     except Exception:
-        return ""
+        text = ""
+    if not (text or "").strip():
+        # 文件缺席/为空的兜底：内置智能体只有 run.json 实时流；顺带惠及日志
+        # 已被清理的老 run（终点摘要/思考还在步骤记录里）
+        live = _builtin_live_log_text(get_run(run_id) or {}, str(rel_path))
+        if live:
+            text = live if len(live) <= tail else \
+                "...(已截断)...\n" + live[-int(tail):]
+    return text

package/app/core/usage.py

@@ -173,12 +173,14 @@ def _budget_caps_on():
 
 _ALERT_PUSH = None        # main.py 启动注入 notify.push_text——usage(L0) 不反向
                            # 依赖 notify(L1)，静态图不成环（同 set_run_estimator 模式）
+_ALERT_LOCK = threading.RLock()
 
 
 def set_alert_push(fn):
     """注入花费预警的推送函数；未注入则预警静默跳过。"""
     global _ALERT_PUSH
-    _ALERT_PUSH = fn if callable(fn) else None
+    with _ALERT_LOCK:
+        _ALERT_PUSH = fn if callable(fn) else None
 
 
 def _budget_alert_check(day):
@@ -201,31 +203,34 @@ def _budget_alert_check(day):
                     break
         if not marks:
             return
-        sp = paths.DATA_DIR / "budget_alerts.json"
-        try:
-            st = json.loads(sp.read_text(encoding="utf-8"))
-        except Exception:
-            st = {}
-        if st.get("day") != day or not isinstance(st.get("done"), list):
-            st = {"day": day, "done": []}
-        done = st["done"]
-        new = [m for m in marks if ("%s%d" % (m[0], m[1])) not in done]
-        if not new:
-            return
-        st["done"] = done + ["%s%d" % (m[0], m[1]) for m in new]
-        sp.parent.mkdir(parents=True, exist_ok=True)
-        tmp = sp.with_suffix(".tmp")
-        tmp.write_text(json.dumps(st, ensure_ascii=False), encoding="utf-8")
-        tmp.replace(sp)
-        if not _ALERT_PUSH:
-            return
-        lines = ["💸 CodeBee 花费预警"]
-        for scope, pct, spent, cap in new:
-            lines.append("%s花费 ¥%.2f，已达%s上限 ¥%.2f 的 %d%%" % (
-                "今日" if scope == "d" else "本月", spent,
-                "每日" if scope == "d" else "每月", cap, pct))
-        lines.append("（达 100% 后新步骤将停止，可在设置→编排设置→预算调整）")
-        _ALERT_PUSH("\n".join(lines))
+        with _ALERT_LOCK:
+            push = _ALERT_PUSH
+            if push is None:
+                return
+            sp = paths.DATA_DIR / "budget_alerts.json"
+            try:
+                st = json.loads(sp.read_text(encoding="utf-8"))
+            except Exception:
+                st = {}
+            if st.get("day") != day or not isinstance(st.get("done"), list):
+                st = {"day": day, "done": []}
+            done = st["done"]
+            new = [m for m in marks if ("%s%d" % (m[0], m[1])) not in done]
+            if not new:
+                return
+            lines = ["💸 CodeBee 花费预警"]
+            for scope, pct, spent, cap in new:
+                lines.append("%s花费 ¥%.2f，已达%s上限 ¥%.2f 的 %d%%" % (
+                    "今日" if scope == "d" else "本月", spent,
+                    "每日" if scope == "d" else "每月", cap, pct))
+            lines.append("（达 100% 后新步骤将停止，可在设置→编排设置→预算调整）")
+            if push("\n".join(lines)) is False:
+                return
+            st["done"] = done + ["%s%d" % (m[0], m[1]) for m in new]
+            sp.parent.mkdir(parents=True, exist_ok=True)
+            tmp = sp.with_suffix(".tmp")
+            tmp.write_text(json.dumps(st, ensure_ascii=False), encoding="utf-8")
+            tmp.replace(sp)
     except Exception:
         pass
 

package/app/core/webhooks.py

@@ -8,6 +8,7 @@ import json
 import sqlite3
 import threading
 import time
+from contextlib import closing
 from pathlib import Path
 
 from . import paths
@@ -62,17 +63,19 @@ def claim_delivery(delivery_id, *, now=None, ttl_seconds=86400):
     db_path = _FILE.with_suffix(_FILE.suffix + ".sqlite3")
     with _LOCK:
         db_path.parent.mkdir(parents=True, exist_ok=True)
-        with sqlite3.connect(str(db_path), timeout=5) as db:
-            db.execute("CREATE TABLE IF NOT EXISTS deliveries (delivery_id TEXT PRIMARY KEY, claimed_at REAL NOT NULL)")
-            cutoff = stamp - max(60, int(ttl_seconds))
-            db.execute("DELETE FROM deliveries WHERE claimed_at < ?", (cutoff,))
-            try:
-                db.execute("INSERT INTO deliveries(delivery_id, claimed_at) VALUES (?, ?)",
-                           (delivery_id, stamp))
-            except sqlite3.IntegrityError:
-                return False, {"deduplicated": True, "delivery_id": delivery_id}
-            db.execute("DELETE FROM deliveries WHERE delivery_id NOT IN (SELECT delivery_id FROM deliveries ORDER BY claimed_at DESC LIMIT ?)",
-                       (MAX_DELIVERIES,))
+        # SQLite's transaction context commits/rolls back but does not close.
+        with closing(sqlite3.connect(str(db_path), timeout=5)) as db:
+            with db:
+                db.execute("CREATE TABLE IF NOT EXISTS deliveries (delivery_id TEXT PRIMARY KEY, claimed_at REAL NOT NULL)")
+                cutoff = stamp - max(60, int(ttl_seconds))
+                db.execute("DELETE FROM deliveries WHERE claimed_at < ?", (cutoff,))
+                try:
+                    db.execute("INSERT INTO deliveries(delivery_id, claimed_at) VALUES (?, ?)",
+                               (delivery_id, stamp))
+                except sqlite3.IntegrityError:
+                    return False, {"deduplicated": True, "delivery_id": delivery_id}
+                db.execute("DELETE FROM deliveries WHERE delivery_id NOT IN (SELECT delivery_id FROM deliveries ORDER BY claimed_at DESC LIMIT ?)",
+                           (MAX_DELIVERIES,))
     return True, {"deduplicated": False, "delivery_id": delivery_id}
 
 
@@ -83,7 +86,8 @@ def release_delivery(delivery_id):
     db_path = _FILE.with_suffix(_FILE.suffix + ".sqlite3")
     with _LOCK:
         try:
-            with sqlite3.connect(str(db_path), timeout=5) as db:
-                db.execute("DELETE FROM deliveries WHERE delivery_id = ?", (delivery_id,))
+            with closing(sqlite3.connect(str(db_path), timeout=5)) as db:
+                with db:
+                    db.execute("DELETE FROM deliveries WHERE delivery_id = ?", (delivery_id,))
         except (OSError, sqlite3.Error):
             pass

package/app/desktop_host.py

@@ -0,0 +1,190 @@
+"""Desktop sidecar: the existing engine with private lifecycle endpoints.
+
+The desktop shell owns this process. Its secret stays in the main process and
+sidecar environment, and is never exposed to the renderer or URL parameters.
+"""
+from __future__ import annotations
+
+import argparse
+import hmac
+import json
+import os
+import sys
+import threading
+import time
+import uuid
+from urllib.parse import urlparse
+from typing import Callable, Dict, Tuple
+
+from core import paths
+from core.runtime_lock import ServiceAlreadyRunning, acquire_service
+
+
+class DesktopPipe:
+    """Native picker replies and parent liveness over the inherited stdin pipe."""
+
+    def __init__(self, on_closed: Callable[[], None]):
+        self.on_closed = on_closed
+        self.condition = threading.Condition()
+        self.pending: Dict[str, object] = {}
+        self.closed = False
+
+    def listen(self) -> None:
+        try:
+            while True:
+                line = sys.stdin.buffer.readline(65537)
+                if not line:
+                    break
+                if len(line) > 65536:
+                    continue
+                try:
+                    message = json.loads(line)
+                    if not isinstance(message, dict):
+                        continue
+                    request_id = message.get("id")
+                    if not isinstance(request_id, str):
+                        continue
+                    with self.condition:
+                        if request_id in self.pending:
+                            self.pending[request_id] = str(message.get("path") or "")
+                            self.condition.notify_all()
+                except (ValueError, TypeError):
+                    continue
+        finally:
+            with self.condition:
+                self.closed = True
+                self.condition.notify_all()
+            self.on_closed()
+
+    def pick(self, mode: str, initial: str = "", title: str = "") -> Tuple[str, str, bool]:
+        request_id = uuid.uuid4().hex
+        with self.condition:
+            if self.closed:
+                return "", "桌面窗口已退出", True
+            self.pending[request_id] = None
+            print("CODEBEE_DESKTOP_PICK " + json.dumps({"id": request_id,
+                  "mode": mode, "initial": initial, "title": title}, ensure_ascii=True),
+                  flush=True)
+            self.condition.wait_for(
+                lambda: self.closed or self.pending[request_id] is not None, timeout=600)
+            result = self.pending.pop(request_id)
+            if result is None:
+                return "", "原生对话框未返回", True
+            return str(result), "", False
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="CodeBee desktop sidecar")
+    parser.add_argument("--port", type=int, default=8765)
+    args = parser.parse_args()
+    secret = os.environ.get("CODEBEE_DESKTOP_SECRET", "")
+    if len(secret) < 32:
+        raise SystemExit("Desktop launcher secret is missing")
+    if not 0 <= args.port <= 65535:
+        raise SystemExit("Invalid desktop port")
+    os.environ["CODEBEE_DESKTOP"] = "1"
+    try:
+        acquire_service(paths.DATA_DIR)
+    except ServiceAlreadyRunning as exc:
+        raise SystemExit(str(exc))
+
+    import main as engine
+    from core import jobs, store
+
+    shutdown_started = threading.Event()
+
+    def shutdown(force: bool = False) -> None:
+        if shutdown_started.is_set():
+            return
+        shutdown_started.set()
+        if force:
+            jobs.begin_shutdown_drain()
+            jobs.cancel_all()
+        # Runner cancellation kills child trees first, then drains stdout/stderr
+        # for up to ten seconds. Keep the sidecar alive long enough for that
+        # cleanup so force quit does not leave a CLI child behind.
+        deadline = time.monotonic() + 20
+        while time.monotonic() < deadline:
+            info = jobs.workers_info()
+            if not (info["alive"] or info["chat_alive"]):
+                break
+            time.sleep(0.1)
+        # The shell owns the sidecar process. Once the response is sent and
+        # workers have drained, exit directly; calling HTTPServer.shutdown()
+        # from an auxiliary thread can wait behind a keep-alive request.
+        os._exit(0)
+
+    pipe = DesktopPipe(lambda: shutdown(force=True))
+
+    class DesktopHandler(engine.Handler):
+        def _desktop_authed(self) -> bool:
+            return (
+                self.client_address[0] == "127.0.0.1"
+                and not self.headers.get("X-Forwarded-For")
+                and not self.headers.get("CF-Connecting-IP")
+                and hmac.compare_digest(
+                    self.headers.get("X-CodeBee-Desktop", ""), secret)
+            )
+
+        def _authed(self):
+            # The renderer receives the secret through the private loopback
+            # request interceptor; it never appears in the URL or page DOM.
+            return self._desktop_authed() or super()._authed()
+
+        def _route_get(self):
+            if urlparse(self.path).path != "/api/desktop/status":
+                return super()._route_get()
+            if not self._desktop_authed():
+                return self._json(403, {"error": "desktop authorization required"})
+            events = [{key: run.get(key) for key in
+                       ("id", "title", "task_id", "status", "ended_at")}
+                      for run in store.list_runs(limit=50)]
+            return self._json(200, {"pid": os.getpid(), "jobs": jobs.workers_info(),
+                                    "events": events})
+
+        def _route_post(self):
+            if urlparse(self.path).path != "/api/desktop/shutdown":
+                return super()._route_post()
+            if not self._desktop_authed():
+                return self._json(403, {"error": "desktop authorization required"})
+            body = self._body()
+            if body.get("force") is not True and not jobs.begin_restart_drain():
+                return self._json(409, {"error": "任务仍在运行，请先完成或确认停止任务"})
+            if body.get("force") is True:
+                jobs.begin_shutdown_drain()
+            self._json(200, {"ok": True})
+            threading.Thread(target=shutdown, args=(body.get("force") is True,),
+                             daemon=True).start()
+
+    class DesktopServer(engine.ThreadedServer):
+        daemon_threads = True
+
+        def serve_forever(self, *a, **kw):
+            print("CODEBEE_DESKTOP_READY " + json.dumps(
+                  {"port": self.server_address[1], "pid": os.getpid()}), flush=True)
+            threading.Thread(target=pipe.listen, daemon=True).start()
+            return super().serve_forever(*a, **kw)
+
+    # Bind before recovery/schedulers start. Never enter the CLI's stale-port
+    # cleanup path: a desktop launch must not terminate a running CLI service.
+    try:
+        server = DesktopServer(("127.0.0.1", args.port), DesktopHandler)
+    except OSError as exc:
+        raise SystemExit("CodeBee 端口已被占用，请退出已有服务后重试：%s" % exc)
+    port = server.server_address[1]
+    engine.ThreadedServer = lambda *a, **kw: server
+    engine._start_pet_keeper = lambda *a, **kw: None
+    engine.pick_dialog.ask_directory = lambda initial="", title="选择文件夹": pipe.pick(
+        "directory", initial, title)
+    engine.pick_dialog.ask_file = lambda initial="", title="选择文件": pipe.pick(
+        "file", initial, title)
+    sys.argv = [str(paths.APP_DIR / "main.py"), "--host", "127.0.0.1",
+                "--port", str(port), "--no-browser", "--no-public-tunnel"]
+    try:
+        engine.main()
+    finally:
+        server.server_close()
+
+
+if __name__ == "__main__":
+    main()

package/app/main.py

@@ -31,7 +31,7 @@ if os.environ.get("TUTTI_ISOLATE_HOME", "").strip() == "1":
     os.environ["USERPROFILE"] = _fake_home
     os.environ["HOME"] = _fake_home
 
-from core import automation, board, catalog, flows, jobs, manager, market, market_remote, preview, registry, remote, settings, store
+from core import activity, automation, board, catalog, flows, jobs, manager, market, market_remote, preview, registry, remote, settings, store
 from core import paths
 from core import health
 from core import usage as usage_ledger
@@ -255,6 +255,10 @@ class Handler(BaseHTTPRequestHandler):
                 return self._json(401, {"error": "需要访问令牌（启动 CodeBee 时控制台会显示）"})
             if path == "/api/state":
                 return self._json(200, _state_payload(self._client_id()))
+            if path == "/api/goals":
+                from core import goal_service
+                return self._json(200, {"current": goal_service.current(),
+                                        "goals": goal_service.list_goals()})
             if path == "/api/openapi.json":
                 from core import openapi
                 return self._json(200, openapi.document())
@@ -916,6 +920,75 @@ class Handler(BaseHTTPRequestHandler):
                 return deny
         if path == "/api/tasks":
             return self._api_create_task()
+        if path == "/api/goals":
+            from core import goal_service
+            body = self._body() or {}
+            title = str(body.get("title") or "").strip()
+            description = str(body.get("description") or "").strip()
+            if not title:
+                return self._json(400, {"error": "Goal 标题不能为空"})
+            if len(title) > 160 or len(description) > 4000:
+                return self._json(400, {"error": "Goal 标题最多 160 字，描述最多 4000 字"})
+            try:
+                goal = goal_service.create(title, description)
+            except goal_service.GoalExistsError as exc:
+                return self._json(409, {"error": str(exc), "current": goal_service.current()})
+            except (OSError, TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(200, {"goal": goal})
+        m = re.match(r"^/api/goals/([^/]+)$", path)
+        if m:
+            from core import goal_service
+            body = self._body() or {}
+            revision = body.get("revision")
+            if isinstance(revision, bool) or not isinstance(revision, int) or revision < 1:
+                return self._json(400, {"error": "revision 必须是正整数"})
+            changes = {}
+            for key in ("title", "description", "phase", "rounds_max"):
+                if key in body:
+                    changes[key] = body[key]
+            if not changes:
+                return self._json(400, {"error": "没有可更新的字段"})
+            if "title" in changes:
+                changes["title"] = str(changes["title"] or "").strip()
+                if not changes["title"] or len(changes["title"]) > 160:
+                    return self._json(400, {"error": "Goal 标题不能为空且最多 160 字"})
+            if "description" in changes:
+                changes["description"] = str(changes["description"] or "").strip()
+                if len(changes["description"]) > 4000:
+                    return self._json(400, {"error": "Goal 描述最多 4000 字"})
+            try:
+                goal = goal_service.update(unquote(m.group(1)), revision, **changes)
+            except goal_service.GoalNotFoundError:
+                return self._json(404, {"error": "Goal 不存在"})
+            except goal_service.StaleRevisionError as exc:
+                return self._json(409, {"error": str(exc), "current": goal_service.current()})
+            except (OSError, TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(200, {"goal": goal})
+        m = re.match(r"^/api/goals/([^/]+)/round$", path)
+        if m:
+            from core import goal_service
+            body = self._body() or {}
+            revision = body.get("revision")
+            if isinstance(revision, bool) or not isinstance(revision, int) or revision < 1:
+                return self._json(400, {"error": "revision 必须是正整数"})
+            goal = goal_service.get(unquote(m.group(1)))
+            if not goal:
+                return self._json(404, {"error": "Goal 不存在"})
+            if goal.get("phase") != "active":
+                return self._json(409, {"error": "只有进行中的 Goal 才能开始下一轮", "goal": goal})
+            if int(goal.get("rounds_started") or 0) >= int(goal.get("rounds_max") or 1):
+                return self._json(409, {"error": "Goal 已达到轮数上限", "goal": goal})
+            try:
+                goal = goal_service.increment_rounds(unquote(m.group(1)), revision)
+            except goal_service.GoalNotFoundError:
+                return self._json(404, {"error": "Goal 不存在"})
+            except goal_service.StaleRevisionError as exc:
+                return self._json(409, {"error": str(exc), "current": goal_service.current()})
+            except (OSError, TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(200, {"goal": goal})
         if path == "/api/backend-profiles":
             from core import backend_profiles
             try:
@@ -3427,10 +3500,12 @@ def _state_payload(client_id="", ver=None):
         ver = store.state_version()
     runs = store.list_runs(40)
     latest = store.latest_run_by_task()
+    tasks = store.list_tasks(archived=False)
     return {
         "v": ver,
         "agents": agents,
-        "tasks": store.list_tasks(archived=False),
+        "tasks": tasks,
+        "task_attention": activity.task_attention(tasks, latest),
         # 归档任务默认隐藏；目标/上下文可能很大，只有查看或恢复时再按需读取。
         "archived_tasks": [_state_task_summary(t) for t in store.list_tasks(archived=True)],
         # 每个任务的最近一次运行（不受 runs 窗口限制）：侧栏靠它展示各任务真实近况
@@ -3461,6 +3536,7 @@ def _state_run_summary(run):
               "auto_resumes", "resume_enqueue_at", "cost_usd", "tokens")
     summary = {key: run[key] for key in fields if key in run}
     summary["step_count"] = len(run.get("steps") or [])
+    summary.update(activity.run_activity(run))
     messages = run.get("messages") or []
     summary["message_count"] = len(messages)
     summary["pending_message_count"] = sum(1 for message in messages if not message.get("consumed"))
@@ -3554,6 +3630,13 @@ def main():
                         help="自更新重启用：先等旧实例释放端口再启动（Windows 双 LISTEN 防护）")
     args = parser.parse_args()
 
+    # CLI and desktop must never recover/run the same task store concurrently.
+    from core.runtime_lock import ServiceAlreadyRunning, acquire_service
+    try:
+        acquire_service(paths.DATA_DIR)
+    except ServiceAlreadyRunning as exc:
+        raise SystemExit(str(exc))
+
     # 测试实例禁止使用默认端口 8765（2026-09-23 实案：代理测试忘带 --port，
     # 启动清场把真实服务当旧实例杀掉后鸠占鹊巢）。测试请显式指定独立端口。
     try:
@@ -3590,6 +3673,8 @@ def main():
     print("[CodeBee] v%s" % (_ver or "?"), flush=True)
     _step("正在准备数据目录…")
     paths.ensure_dirs()
+    from core import goal_service
+    goal_service.init()
     from core import backend_profiles as _backend_profiles
     from core import command_auth as _command_auth
     _backend_profiles.init()
@@ -3822,9 +3907,8 @@ def main():
               % (remote.PUBLIC_URL, tok))
     elif not args.no_public_tunnel and args.host != "127.0.0.1":
         if remote.has_local_creds():
-            extra = "，或 start-public.bat" if os.name == "nt" else ""
             print("[CodeBee] （检测到已有 Cloudflare 隧道凭据：临时隧道在此类机器上不可用，"
-                  "请用 --public-url 配固定域名%s）" % extra)
+                  "请用 --public-url 配固定域名）")
         elif remote.start_quick_tunnel(args.port, _announce_public):
             print("[CodeBee] 正在建立 Cloudflare 快速隧道（公网地址几秒后打印；"
                   "若打不开说明当前网络不支持，可改用固定域名或 Tailscale）…")

package/app/pet.py

@@ -433,7 +433,7 @@ def global_lock_held():
 
 
 # 浏览器进程白名单：找已打开的 CodeBee 窗口时只认这些主进程的顶层窗口，
-# 避免把桌宠自身（标题也是 CodeBee）或 start-public.bat 起的「CodeBee」
+# 避免把桌宠自身（标题也是 CodeBee）或 start-service.bat 起的「CodeBee」
 # 控制台窗口误当成浏览器置前。
 _BROWSER_EXES = {
     "msedge.exe", "chrome.exe", "chromium.exe", "firefox.exe",