codebee 0.1.22 → 0.1.24

package/app/core/skills.py

@@ -38,6 +38,7 @@ def _user_pack_dir():
 
 MAX_INJECT_CHARS = 9000      # 单次注入上限（防止提示词爆炸；七猫+番茄双平台包并存后上调）
 MAX_LESSONS_INJECT = 8       # 注入的自动教训条数上限
+WILDCARD_PACK_CHAR_CAP = 2400  # wildcard（scope=*）包单包注入预算：市场通配技能动辄数万字，全文注入会挤掉项目教训
 
 # 自动教训的问题分类：闭集枚举，对齐评审维度。沉淀时由复盘官归类（兜底路径按评审
 # 维度关键词映射），UI 据此分类过滤查看。刻意保持小而稳，避免类别爆炸让过滤失去意义。
@@ -390,14 +391,14 @@ def relevance_top(lessons, task, limit):
     if not probe:
         return lessons[:limit]
 
-    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
-    def rank(x):
-        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
-        overlap = -len(probe & grams)
-        lid = x.get("id") or ""
-        return (overlap, -int(x.get("hits") or 0), lid)
-
-    return sorted(lessons, key=rank)[:limit]
+    # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
+    def rank(x):
+        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
+        overlap = -len(probe & grams)
+        lid = x.get("id") or ""
+        return (overlap, -int(x.get("hits") or 0), lid)
+
+    return sorted(lessons, key=rank)[:limit]
 
 
 def block_for(task, scope_override=None, *, stable_order=False):
@@ -408,9 +409,14 @@ def block_for(task, scope_override=None, *, stable_order=False):
     stable_order=True（docs/migration/07-token-cost.md T1.2'）：教训按 id 排序
     而非 hits——hits 在任务中途变化会让技能块字节级不稳定，打碎供应商的
     前缀缓存（同一任务 8 章应看到完全相同的技能块）。内容不变，只稳排序。
+
+    预算纪律（2026-09-21 巡检实锤引入）：wildcard（scope=*）包动辄数万字，
+    39 个全文注入会先把 9000 字全局上限吃光，项目教训排在末尾被整段截掉。
+    两道预算：①wildcard 包单包限额（定向命中的包不受限）；②教训保底——
+    包区最多吃到「全局上限 − 教训长度」，教训永远完整注入。
     """
     scope = scope_override or task.get("type") or "*"
-    parts, used, lesson_ids = [], [], []
+    parts, used, lesson_ids = [], [], []
 
     for p in all_packs():
         if scope not in p["scopes"] and "*" not in p["scopes"]:
@@ -420,6 +426,9 @@ def block_for(task, scope_override=None, *, stable_order=False):
         txt = pack_text(p).strip()
         if not txt and not p.get("persona"):
             continue
+        # wildcard 包（仅靠 * 命中，非定向）单包限预算；定向命中不限，走全局
+        if scope not in p["scopes"] and len(txt) > WILDCARD_PACK_CHAR_CAP:
+            txt = txt[:WILDCARD_PACK_CHAR_CAP] + "\n…（本包超出通配注入预算已截断，完整内容见技能库）"
         # 3B：persona 独立成块（角色设定与规范正文分开，模型更易区分 obey 层级）
         if p.get("persona"):
             parts.append("### 【角色设定：%s】\n%s" % (p["name"], str(p["persona"]).strip()))
@@ -429,23 +438,32 @@ def block_for(task, scope_override=None, *, stable_order=False):
 
     lessons = relevance_top(list_lessons(scope, only_enabled=True), task,
                             MAX_LESSONS_INJECT)
+    lesson_part = ""
     if lessons:
         if stable_order:
             lessons.sort(key=lambda x: x.get("id") or "")
         lines = []
-        for x in lessons:
-            lines.append("- **%s**：%s" % (x["title"], x["content"]))
-            used.append(x["id"])
-            lesson_ids.append(x["id"])
-        parts.append("### 【本项目已沉淀的教训（历史评审反复出现，务必规避）】\n" + "\n".join(lines))
-
-    if not parts:
+        for x in lessons:
+            lines.append("- **%s**：%s" % (x["title"], x["content"]))
+            used.append(x["id"])
+            lesson_ids.append(x["id"])
+        lesson_part = ("### 【本项目已沉淀的教训（历史评审反复出现，务必规避）】\n"
+                       + "\n".join(lines))
+
+    if not parts and not lesson_part:
         return "", []
-    text = "## 经验库（写作/工程规范 + 历史教训，必须遵守）\n\n" + "\n\n".join(parts)
+
+    header = "## 经验库（写作/工程规范 + 历史教训，必须遵守）\n\n"
+    budget = max(600, MAX_INJECT_CHARS - len(lesson_part))
+    body = "\n\n".join(parts)
+    if len(body) > budget:
+        body = body[:budget] + "\n…（包区已按预算截断，优先保住项目教训）"
+    body = (body + "\n\n" + lesson_part) if (body and lesson_part) else (body or lesson_part)
+    text = header + body
     if len(text) > MAX_INJECT_CHARS:
         text = text[:MAX_INJECT_CHARS] + "\n…（已截断）"
-    if lesson_ids:
-        bump_hits(lesson_ids)  # 包 id 不参与教训热度，命中数据只保留一份真源
+    if lesson_ids:
+        bump_hits(lesson_ids)  # 包 id 不参与教训热度，命中数据只保留一份真源
     return text, used
 
 

package/app/core/store.py

@@ -246,10 +246,8 @@ def create_task(payload):
                 raise ValueError("附件落盘失败: %s" % e)
         if items:
             task["attachments"] = items
-            blk = att_mod.context_block(items)
-            # 复制清单场景下 context 已含附件块（随旧任务沿用），别重复追加
-            if blk and "## 附件材料" not in task["context"]:
-                task["context"] = (task["context"] + blk).strip()
+            task["context"] = att_mod.merge_context(
+                task["context"], items, workdir=str(wd))
     with LOCK:
         _TASKS[task["id"]] = task
         _save_json(paths.TASKS_DIR / (task["id"] + ".json"), task)

package/app/core/task_compile.py

@@ -2,6 +2,8 @@
 """任务编译器：把用户任务和预置流程编译成统一、可审计的运行规格。"""
 from __future__ import annotations
 
+from collections.abc import Mapping
+
 from . import dispatch, flows
 
 SCHEMA_VERSION = 1
@@ -41,7 +43,7 @@ def _capabilities(task, dimension, engine):
 
 def compile_task(task):
     """返回统一任务规格；输入缺失或字段异常时保持可编排的安全兜底。"""
-    raw = dict(task or {})
+    raw = dict(task) if isinstance(task, Mapping) else {}
     ttype = str(raw.get("type") or "direct").strip().lower()
     flow = flows.get_flow(ttype) or {}
     engine = str(raw.get("engine") or flow.get("engine") or
@@ -53,6 +55,8 @@ def compile_task(task):
     rubric = raw.get("rubric") or flow.get("rubric") or []
     if isinstance(rubric, str):
         rubric = [x.strip() for x in rubric.replace("，", ",").split(",") if x.strip()]
+    elif not isinstance(rubric, (list, tuple)):
+        rubric = flow.get("rubric") or []
     rubric = [str(x).strip() for x in rubric if str(x).strip()][:8]
     deliverable = str(raw.get("manuscript") or flow.get("manuscript") or "").strip()
     serial = raw.get("serial") if isinstance(raw.get("serial"), dict) else None

package/app/core/usage.py

@@ -10,8 +10,9 @@
 """
 from __future__ import annotations
 
-import json
-import threading
+import json
+import math
+import threading
 import time
 
 from . import paths
@@ -32,8 +33,12 @@ FIELDS = ("ts", "day", "run_id", "step", "task_id", "task_type", "role", "agent"
           "input", "output", "cached", "reasoning", "total", "cost_usd", "source")
 
 
-def _month_file(day):
-    return paths.USAGE_DIR / ("usage-%s.jsonl" % day[:7].replace("-", ""))
+def _month_file(day):
+    return paths.USAGE_DIR / ("usage-%s.jsonl" % day[:7].replace("-", ""))
+
+
+def _quality_file(day):
+    return paths.USAGE_DIR / ("routing-quality-%s.jsonl" % day[:7].replace("-", ""))
 
 
 def _parse_int(v):
@@ -93,10 +98,13 @@ def record(source="", run_id="", task_id="", task_type="", role="", step=0,
         rec.update({"input": inp, "output": out, "cached": cach,
                     "reasoning": reas, "total": total})
         line = json.dumps(rec, ensure_ascii=False)
-        with LOCK:
-            paths.USAGE_DIR.mkdir(parents=True, exist_ok=True)
-            with open(_month_file(rec["day"]), "a", encoding="utf-8") as f:
-                f.write(line + "\n")
+        with LOCK:
+            paths.USAGE_DIR.mkdir(parents=True, exist_ok=True)
+            with open(_month_file(rec["day"]), "a", encoding="utf-8") as f:
+                f.write(line + "\n")
+            _ROUTING_CACHE["data"].clear()
+            _ROUTING_RECORDS_CACHE.clear()
+            _HOURLY_CACHE["ts"] = 0.0
     except Exception:
         pass
 
@@ -196,8 +204,11 @@ def _tool_of(agent_id):
     return a or "unknown"
 
 
-_HOURLY_CACHE = {"ts": 0.0, "val": {}}
-_HOURLY_TTL = 60.0   # 秒：路由调用频繁但台账追加低频，60s 缓存足够新鲜
+_HOURLY_CACHE = {"ts": 0.0, "val": {}}
+_HOURLY_TTL = 60.0   # 秒：路由调用频繁但台账追加低频，60s 缓存足够新鲜
+_ROUTING_CACHE = {"data": {}}
+_ROUTING_RECORDS_CACHE = {}
+_ROUTING_TTL = 15.0
 
 
 def agent_tokens_recent(agent, hours=1):
@@ -224,7 +235,7 @@ def agent_tokens_recent(agent, hours=1):
         return 0
 
 
-def _iter_records(days):
+def _iter_records(days):
     """按时间范围读取台账（days=0 表示全部）。返回按写入顺序的记录列表。"""
     out = []
     try:
@@ -232,11 +243,14 @@ def _iter_records(days):
     except Exception:
         return out
     since_day = ""
-    if days:
-        import datetime
-        d = (datetime.date.today() - datetime.timedelta(days=int(days) - 1)).isoformat()
-        since_day = d
-    for p in files:
+    if days:
+        import datetime
+        d = (datetime.date.today() - datetime.timedelta(days=int(days) - 1)).isoformat()
+        since_day = d
+    since_month = since_day[:7].replace("-", "") if since_day else ""
+    for p in files:
+        if since_month and p.stem.rsplit("-", 1)[-1] < since_month:
+            continue
         try:
             for line in p.read_text(encoding="utf-8", errors="replace").splitlines():
                 line = line.strip()
@@ -253,14 +267,202 @@ def _iter_records(days):
                 out.append(r)
         except Exception:
             continue
-    return out
-
-
-def _num(r, key):
-    return _parse_int(r.get(key))
-
-
-def _group(records, key):
+    return out
+
+
+def _iter_quality_records(days):
+    """读取独立质量台账；不混入用量统计的调用数、token 和成本。"""
+    out = []
+    try:
+        files = sorted(paths.USAGE_DIR.glob("routing-quality-*.jsonl")) \
+            if paths.USAGE_DIR.is_dir() else []
+    except Exception:
+        return out
+    since_day = ""
+    if days:
+        import datetime
+        since_day = (datetime.date.today()
+                     - datetime.timedelta(days=int(days) - 1)).isoformat()
+    since_month = since_day[:7].replace("-", "") if since_day else ""
+    for path in files:
+        if since_month and path.stem.rsplit("-", 1)[-1] < since_month:
+            continue
+        try:
+            for line in path.read_text(encoding="utf-8", errors="replace").splitlines():
+                try:
+                    row = json.loads(line)
+                except Exception:
+                    continue
+                if isinstance(row, dict) and (not since_day or row.get("day", "") >= since_day):
+                    out.append(row)
+        except Exception:
+            continue
+    return out
+
+
+def _routing_records(days):
+    """同一轮候选评分共享一次台账解析，避免每个候选重复扫全盘。"""
+    key = (str(paths.USAGE_DIR), int(days))
+    now = time.time()
+    with LOCK:
+        cached = _ROUTING_RECORDS_CACHE.get(key)
+        if cached and now - cached[0] <= _ROUTING_TTL:
+            return list(cached[1]), list(cached[2])
+    calls, quality = _iter_records(days), _iter_quality_records(days)
+    with LOCK:
+        _ROUTING_RECORDS_CACHE[key] = (now, list(calls), list(quality))
+    return calls, quality
+
+
+def record_quality_for_run(run_id, quality_ok, agent=""):
+    """把验收结论归因到最终实际产出者，不重复计入用量。"""
+    try:
+        run_id = str(run_id or "")[:64]
+        if not run_id:
+            return 0
+        calls = [r for r in _iter_records(2)
+                 if r.get("run_id") == run_id and r.get("ok") is True]
+        prefixes = ("implement", "fix", "draft", "revise", "polish", "direct", "author")
+        calls = [r for r in calls if str(r.get("role") or "").lower().startswith(prefixes)]
+        agent = str(agent or "")[:40]
+        unique = {}
+        for row in calls:
+            key = tuple(str(row.get(k) or "") for k in
+                        ("task_id", "task_type", "role", "agent", "model", "provider"))
+            unique[key] = row
+        if not unique:
+            return 0
+        existing = {(r.get("run_id"), r.get("role"), r.get("agent"),
+                     r.get("model"), r.get("provider"))
+                    for r in _iter_quality_records(2)}
+        day = time.strftime("%Y-%m-%d")
+        rows = []
+        for row in unique.values():
+            identity = (run_id, row.get("role"), row.get("agent"),
+                        row.get("model"), row.get("provider"))
+            if identity in existing:
+                continue
+            # 成功调用不等于产出通过。换将前的实现者即使传输成功，也已被质量
+            # 门淘汰，必须留下负样本；最终实际产出者才继承本次验收结论。
+            row_quality_ok = bool(quality_ok)
+            if agent and str(row.get("agent") or "") != agent:
+                row_quality_ok = False
+            rows.append({"ts": time.strftime("%Y-%m-%d %H:%M:%S"), "day": day,
+                         "run_id": run_id, "task_id": row.get("task_id") or "",
+                         "task_type": row.get("task_type") or "unknown",
+                         "role": row.get("role") or "unknown",
+                         "agent": row.get("agent") or "unknown",
+                         "model": row.get("model") or "(默认)",
+                         "provider": row.get("provider") or "",
+                         "quality_ok": row_quality_ok})
+        if not rows:
+            return 0
+        with LOCK:
+            paths.USAGE_DIR.mkdir(parents=True, exist_ok=True)
+            with open(_quality_file(day), "a", encoding="utf-8") as handle:
+                for row in rows:
+                    handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+            _ROUTING_CACHE["data"].clear()
+            _ROUTING_RECORDS_CACHE.clear()
+        return len(rows)
+    except Exception:
+        return 0
+
+
+def _num(r, key):
+    return _parse_int(r.get(key))
+
+
+def _percentile(values, percentile):
+    """线性插值百分位，空样本返回 0。"""
+    if not values:
+        return 0.0
+    ordered = sorted(float(v) for v in values)
+    if len(ordered) == 1:
+        return round(ordered[0], 2)
+    pos = (len(ordered) - 1) * float(percentile)
+    lo = int(math.floor(pos))
+    hi = int(math.ceil(pos))
+    if lo == hi:
+        return round(ordered[lo], 2)
+    return round(ordered[lo] + (ordered[hi] - ordered[lo]) * (pos - lo), 2)
+
+
+def routing_stats(task_type="", role="", agent="", model="", provider="",
+                  days=90, min_samples=3):
+    """返回路由用的近期真实运行指标。
+
+    只读取脱敏用量台账；精确维度样本不足时依次回退到任务+角色、任务、
+    全局，成功率使用 Beta(3, 1) 平滑，避免单次失败永久压低新候选。
+    """
+    try:
+        task_type = str(task_type or "")[:32]
+        role = str(role or "")[:40]
+        agent = str(agent or "")[:40]
+        model = str(model or "")[:80]
+        provider = str(provider or "")[:60]
+        days = max(0, int(days))
+        min_samples = max(1, int(min_samples))
+    except (TypeError, ValueError):
+        days, min_samples = 90, 3
+    # DATA_DIR 可在测试、多实例或运行时配置切换；纳入缓存键，避免跨目录
+    # 复用另一套台账的线上指标。
+    key = (str(paths.DATA_DIR), task_type, role, agent, model, provider,
+           days, min_samples)
+    now = time.time()
+    with LOCK:
+        cached = _ROUTING_CACHE["data"].get(key)
+        if cached and now - cached[0] <= _ROUTING_TTL:
+            return dict(cached[1])
+    records, quality_records = _routing_records(days)
+
+    def matches(record, filters):
+        return all(str(record.get(field) or "") == value
+                   for field, value in filters.items() if value)
+
+    # 先保留所有已提供的维度；后续逐层放宽，确保模型和 CLI 都能共享一套查询。
+    exact = {"task_type": task_type, "role": role, "agent": agent,
+             "model": model, "provider": provider}
+    fallbacks = [(exact, "exact")]
+    task_role = {"task_type": task_type, "role": role}
+    if task_role != exact:
+        fallbacks.append((task_role, "task-role"))
+    if task_type:
+        fallbacks.append(({"task_type": task_type}, "task"))
+    fallbacks.append(({}, "global"))
+    selected, label = [], "global"
+    for filters, candidate_label in fallbacks:
+        candidate = [r for r in records if matches(r, filters)]
+        if len(candidate) >= min_samples or (candidate_label == "global" and candidate):
+            selected, label = candidate, candidate_label
+            break
+    chosen_filters = next((filters for filters, candidate_label in fallbacks
+                           if candidate_label == label), {})
+    quality_selected = [r for r in quality_records if matches(r, chosen_filters)]
+    success_rows = quality_selected or selected
+    success_key = "quality_ok" if quality_selected else "ok"
+    successes = sum(1 for r in success_rows if bool(r.get(success_key)))
+    durations = [max(0.0, _parse_float(r.get("duration_s"))) for r in selected]
+    costs = [max(0.0, _parse_float(r.get("cost_usd"))) for r in selected]
+    samples = len(selected)
+    success_samples = len(success_rows)
+    result = {
+        "samples": samples,
+        "quality_samples": len(quality_selected),
+        "success_samples": success_samples,
+        "successes": successes,
+        "success_rate": round((successes + 3.0) / (success_samples + 4.0), 4),
+        "p50_duration_s": _percentile(durations, 0.50),
+        "p95_duration_s": _percentile(durations, 0.95),
+        "avg_cost_usd": round(sum(costs) / samples, 6) if samples else 0.0,
+        "fallback": label,
+    }
+    with LOCK:
+        _ROUTING_CACHE["data"][key] = (now, dict(result))
+    return result
+
+
+def _group(records, key):
     """按 key 聚合：{name: {calls, ok, tokens, input, output, cached, cache_rate, cost_usd, duration_s}}。"""
     groups = {}
     for r in records:

package/app/main.py

@@ -284,6 +284,18 @@ class Handler(BaseHTTPRequestHandler):
                 except ValueError:
                     edays = 90
                 return self._json(200, usage.estimate(task_type=ttype, days=edays))
+            if path == "/api/dispatch/replay":
+                from core import dispatch_log
+                q = parse_qs(urlparse(self.path).query)
+                try:
+                    limit = max(1, min(1000, int((q.get("limit") or ["100"])[0])))
+                except (TypeError, ValueError):
+                    limit = 100
+                events = dispatch_log.replay(
+                    run_id=(q.get("run_id") or [""])[0],
+                    task_type=(q.get("task_type") or [""])[0],
+                    limit=limit)
+                return self._json(200, {"events": events, "count": len(events)})
             if path == "/api/diagnostics/bundle":
                 # 诊断包（zip）：脱敏错误台账 + 用量台账 + 环境元信息，供用户贴 Issue
                 from core import telemetry
@@ -296,6 +308,18 @@ class Handler(BaseHTTPRequestHandler):
                 # 一键反馈 Issue 的预填摘要（标题+正文，全程脱敏，用户亲手提交）
                 from core import telemetry
                 return self._json(200, telemetry.issue_report(days=30))
+            if path == "/api/ports":
+                # 端口占用诊断（借鉴 leftopen）：谁在听、PID/进程/项目归属、
+                # 是否仅本机。?port=N 只看单端口。只读，不碰任何进程。
+                from core import portscan
+                q = parse_qs(urlparse(self.path).query)
+                ports = portscan.listening_ports()
+                focus = (q.get("port") or [""])[0]
+                if focus.isdigit():
+                    ports = [p for p in ports if p["port"] == int(focus)]
+                for p in ports:
+                    p["self"] = p.get("pid") == os.getpid()
+                return self._json(200, {"ports": ports})
             m = re.match(r"^/api/runs/([^/]+)$", path)
             if m:
                 run = store.get_run(m.group(1))
@@ -560,6 +584,22 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(200, {"ok": True, "health": health.snapshot()})
         if path == "/api/attachments":
             return self._api_add_attachment()
+        if path == "/api/ports/close":
+            # 温和关闭端口占用进程（借鉴 leftopen）：SIGTERM only、关前重验
+            # PID 绑定；系统进程/自身服务在 portscan 内拒关。设备控制权守卫
+            # 已在上方统一生效（不在豁免清单里）。
+            from core import portscan
+            body = self._body()
+            try:
+                cport = int(body.get("port") or 0)
+            except (TypeError, ValueError):
+                return self._json(400, {"error": "port 必须是数字"})
+            if not (1 <= cport <= 65535):
+                return self._json(400, {"error": "port 越界"})
+            ok, msg = portscan.close_port(cport)
+            return self._json(200 if ok else 409,
+                              {"ok": ok, "message": msg,
+                               "error": None if ok else msg})
         if path == "/api/dir/save":
             # 「查看文件」弹窗编辑保存（本机 + 控制权 + 防穿越 + mtime 冲突检测）
             return self._api_dir_save()
@@ -713,14 +753,13 @@ class Handler(BaseHTTPRequestHandler):
         if path == "/api/selfupdate/apply":
             from core import selfupdate
             try:
-                res = selfupdate.apply_upgrade()
+                res = selfupdate.apply_upgrade(PORT)
             except Exception:
                 log.exception("自更新任务创建失败")
                 return self._json(503, {"error": "升级任务创建失败，请稍后重试"})
             return self._json(400, res) if res.get("error") else self._json(200, dict(res, ok=True))
         if path == "/api/selfupdate/restart":
             from core import selfupdate
-            global PORT
             if not selfupdate.relaunch(PORT):
                 return self._json(400, {"error": "重启参数非法"})
             def _bye():
@@ -2407,13 +2446,47 @@ def main():
         # 分发，表现为"时好时坏"）；加独占锁后双起在这里干净失败并指路。
         # （此处不能局部 import os：会让 os 变 main() 的局部名，后面 2127 行
         #  的 os.name 直接 UnboundLocalError——顶部已有全局导入，直接用）
-        hint = ""
-        if os.name == "nt":
-            hint = ("（Windows 排查：netstat -ano | findstr :%d 找到 PID，"
-                    "tasklist /FI \"PID eq <PID>\" 看是谁；旧进程杀掉或换 --port）"
-                    % args.port)
-        raise SystemExit("[CodeBee] 端口 %d 已被占用，无法启动：%s %s"
-                         % (args.port, e, hint))
+        # 端口占用自动清场（用户拍板 2026-09-21）：升级/重启最常见的占用者是
+        # 没退干净的 CodeBee 自家旧实例——先杀再起，别让用户手动 netstat+taskkill。
+        # 判定（main.py 完整路径/npm 打包路径）与清场在 core.portguard。
+        from core import portscan as _ps, portguard as _pg
+        _hint = ""
+        try:
+            _cleared, _hint = _pg.clear_stale_port(
+                args.port, paths.APP_DIR / "main.py")
+        except Exception:
+            _cleared, _hint = False, ""
+        if _cleared:
+            try:
+                print("[CodeBee] 端口 %d 被旧实例占用，已自动清场，正在重新绑定…"
+                      % args.port, flush=True)
+                time.sleep(1.0)   # 让被清进程的监听 socket 完全释放
+                httpd = ThreadedServer((args.host, args.port), Handler)
+            except OSError:
+                httpd = None
+        else:
+            httpd = None
+        if httpd is None:
+            # 清场没成：带占用者指认退出（识别不出回落手工排查提示）
+            hint = ""
+            if os.name == "nt":
+                hint = ("（Windows 排查：netstat -ano | findstr :%d 找到 PID，"
+                        "tasklist /FI \"PID eq <PID>\" 看是谁；旧进程杀掉或换 --port）"
+                        % args.port)
+            try:
+                for _h in _ps.listening_ports():
+                    if _h.get("port") != args.port:
+                        continue
+                    _who = _h.get("process") or "未知进程"
+                    _proj = ("，项目 %s" % _h["project"]) if _h.get("project") else ""
+                    hint = ("占用者：PID %d（%s%s）%s"
+                            % (_h.get("pid") or 0, _who, _proj,
+                               ("；" + _hint) if _hint else "；旧进程杀掉或换 --port 重启"))
+                    break
+            except Exception:
+                pass
+            raise SystemExit("[CodeBee] 端口 %d 已被占用，无法启动：%s %s"
+                             % (args.port, e, hint))
 
     def _announce_public(url):
         print("[CodeBee] 公网     %s/?token=%s" % (url, tok))

package/app/pet.py

@@ -1283,7 +1283,8 @@ class PetApp:
                           command=lambda: self._set_lang("en"),
                           variable=self._lang_var, value="en")
         m.add_separator()
-        m.add_command(label=self._L("close"), command=self._bye)
+        m.add_command(label=self._L("close"),
+                      command=lambda: self._bye(write_setting=True))
         return m
 
     def _set_mode(self, mode):
@@ -1308,6 +1309,8 @@ class PetApp:
         cv = self.cv
         self._press = None
         self._moved = False
+        self._drag_to = None
+        self._drag_pending = False
         cv.bind("<ButtonPress-1>", self._on_press)
         cv.bind("<B1-Motion>", self._on_motion)
         cv.bind("<ButtonRelease-1>", self._on_release)
@@ -1316,22 +1319,32 @@ class PetApp:
         self.root.protocol("WM_DELETE_WINDOW", self._bye)
 
     def _on_press(self, e):
-        self._press = e
+        # 窗口拖动起点：屏幕坐标 + 窗口原点一起记（scan_mark/scan_dragto 是
+        # canvas 系 widget 的子命令，顶层窗口没有——此前绑定在这里的拖动
+        # 实际全部抛 AttributeError 被 except 吞掉，表现为「拖不动」）
+        self._press = (e.x_root, e.y_root, self.root.winfo_x(), self.root.winfo_y())
         self._moved = False
-        try:
-            self.root.scan_mark(e.x_root, e.y_root)   # Tk 内置 C 级拖动，跟手
-        except Exception:
-            pass
 
     def _on_motion(self, e):
         if not self._press:
             return
-        if (abs(e.x - self._press.x) + abs(e.y - self._press.y) > 4):
+        px, py, wx, wy = self._press
+        if (abs(e.x_root - px) + abs(e.y_root - py) > 4):
             self._moved = True
-        # 逐事件 geometry() 会把透明层窗拖成PPT（每次回调都走 Python+重排）；
-        # scan_dragto 在 C 里完成同样的移动，丝滑
+        # geometry 逐事件会卡成 PPT；这里合并到 ~60fps 节流（事件风暴只在
+        # 节流窗内记终点，一次 geometry 落位），实测跟手且不吃 CPU
+        self._drag_to = (wx + (e.x_root - px), wy + (e.y_root - py))
+        if self._drag_pending:
+            return
+        self._drag_pending = True
+        self.root.after(16, self._apply_drag)
+
+    def _apply_drag(self):
+        self._drag_pending = False
+        if not self._drag_to:
+            return
         try:
-            self.root.scan_dragto(e.x_root, e.y_root, 1)
+            self.root.geometry("+%d+%d" % self._drag_to)
         except Exception:
             pass
 
@@ -1344,7 +1357,17 @@ class PetApp:
         else:
             self._open_ui()
 
-    def _bye(self):
+    def _bye(self, write_setting=False):
+        """退出。write_setting=True（右键菜单「关闭桌宠」）先把 pet_enabled=False
+        写回服务端设置——否则看护/下次启动都会按设置里的 enabled 把蜜蜂复活，
+        用户点关闭等于没关（2026-09-21 用户实测「宠物关不了」的根因：菜单
+        关闭只销毁窗口不落设置，与注释宣称的契约相反）。服务端 pet_enabled
+        已为 False 的自离路径（轮询发现/miss 超限）无需再写。"""
+        if write_setting:
+            try:
+                self._post_settings({"pet_enabled": False})
+            except Exception:
+                pass
         try:
             self._save_cfg(x=self.root.winfo_x(), y=self.root.winfo_y())
         except Exception: