codebee 0.1.21 → 0.1.23

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,54 +391,16 @@ def relevance_top(lessons, task, limit):
     if not probe:
         return lessons[:limit]
 
-    def rank(x):
-        grams = _text_bigrams(x.get("title")) | _text_bigrams(x.get("content"))
-        return (-len(probe & grams), x.get("id") or "")
-
     # 使用反馈闭环（pmb「量化记忆真实帮助」借鉴）：被选中次数多的教训排前
-    hits = _load_hits()
     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, -hits.get(lid, 0), lid)
+        return (overlap, -int(x.get("hits") or 0), lid)
 
     return sorted(lessons, key=rank)[:limit]
 
 
-def _hits_path():
-    return paths.DATA_DIR / "skill_hits.json"
-
-
-def _load_hits():
-    """读取教训使用计数（{lesson_id: 次数}）。文件缺失/损坏返回空 dict。"""
-    try:
-        p = _hits_path()
-        if p.is_file():
-            import json
-            return json.loads(p.read_text(encoding="utf-8"))
-    except Exception:
-        pass
-    return {}
-
-
-def _bump_hits(ids):
-    """注入后递增使用计数并持久化（fire-and-forget，失败静默）。"""
-    try:
-        import json
-        p = _hits_path()
-        hits = _load_hits()
-        for lid in ids:
-            if lid:
-                hits[lid] = hits.get(lid, 0) + 1
-        p.parent.mkdir(parents=True, exist_ok=True)
-        tmp = p.with_suffix(".tmp")
-        tmp.write_text(json.dumps(hits, ensure_ascii=False), encoding="utf-8")
-        tmp.replace(p)
-    except Exception:
-        pass
-
-
 def block_for(task, scope_override=None, *, stable_order=False):
     """生成注入提示词的经验块。命中即计数。返回 (文本, 命中的 id 列表)。
 
@@ -446,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 = [], []
+    parts, used, lesson_ids = [], [], []
 
     for p in all_packs():
         if scope not in p["scopes"] and "*" not in p["scopes"]:
@@ -458,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()))
@@ -467,6 +438,7 @@ 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 "")
@@ -474,17 +446,24 @@ def block_for(task, scope_override=None, *, stable_order=False):
         for x in lessons:
             lines.append("- **%s**：%s" % (x["title"], x["content"]))
             used.append(x["id"])
-        parts.append("### 【本项目已沉淀的教训（历史评审反复出现，务必规避）】\n" + "\n".join(lines))
+            lesson_ids.append(x["id"])
+        lesson_part = ("### 【本项目已沉淀的教训（历史评审反复出现，务必规避）】\n"
+                       + "\n".join(lines))
 
-    if not parts:
+    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 used:
-        _bump_hits(used)   # 使用反馈闭环：被选中的教训递增计数，下次排序升权
-    if used:
-        bump_hits(used)
+    if lesson_ids:
+        bump_hits(lesson_ids)  # 包 id 不参与教训热度，命中数据只保留一份真源
     return text, used
 
 

package/app/core/task_compile.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+"""任务编译器：把用户任务和预置流程编译成统一、可审计的运行规格。"""
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from . import dispatch, flows
+
+SCHEMA_VERSION = 1
+DIFFICULTIES = ("easy", "default", "hard")
+
+
+def _difficulty(task, flow):
+    explicit = str((task or {}).get("difficulty") or "").strip().lower()
+    if explicit in DIFFICULTIES:
+        return explicit, "用户指定"
+    try:
+        threshold = float((task or {}).get("threshold")
+                          if (task or {}).get("threshold") is not None
+                          else (flow or {}).get("threshold") or 7.0)
+    except (TypeError, ValueError):
+        threshold = 7.0
+    if threshold >= 8.5:
+        return "hard", "高质量门槛"
+    if threshold <= 6.0:
+        return "easy", "快速交付门槛"
+    if str((task or {}).get("type") or "").lower() in (
+            "research", "tech_proposal", "rank_scan"):
+        return "hard", "研究/方案类默认需要深度"
+    return "default", "标准难度"
+
+
+def _capabilities(task, dimension, engine):
+    caps = [dimension]
+    if engine == "code" or (task or {}).get("verify_command"):
+        caps.extend(["filesystem", "verification"])
+    if (task or {}).get("serial"):
+        caps.extend(["long_context", "continuity"])
+    if (task or {}).get("attachments"):
+        caps.append("attachments")
+    return list(dict.fromkeys(caps))
+
+
+def compile_task(task):
+    """返回统一任务规格；输入缺失或字段异常时保持可编排的安全兜底。"""
+    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
+                 ("code" if ttype == "code" else "review")).strip()
+    if engine not in flows.ENGINES:
+        engine = flow.get("engine") or ("code" if ttype == "code" else "review")
+    difficulty, difficulty_reason = _difficulty(raw, flow)
+    dimension = dispatch.task_dimension(ttype, raw.get("role") or "")
+    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
+    return {
+        "schema_version": SCHEMA_VERSION,
+        "type": ttype,
+        "title": str(raw.get("title") or "")[:120],
+        "goal": str(raw.get("goal") or "")[:2000],
+        "engine": engine,
+        "dimension": dimension,
+        "difficulty": difficulty,
+        "difficulty_reason": difficulty_reason,
+        "capabilities": _capabilities(raw, dimension, engine),
+        "deliverable": deliverable,
+        "quality_dimensions": rubric,
+        "serial": serial,
+        "explicit_agent": str(raw.get("implementer") or "").strip(),
+        "has_verification": bool(raw.get("verify_command")),
+    }
+
+
+def summary(spec):
+    """给运行日志/UI 的短说明，不包含用户正文。"""
+    spec = spec or {}
+    return "%s/%s/%s（能力：%s）" % (
+        spec.get("type") or "direct", spec.get("engine") or "direct",
+        spec.get("difficulty") or "default",
+        "、".join(spec.get("capabilities") or []) or "通用")

package/app/main.py

@@ -296,6 +296,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 +572,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()
@@ -2412,6 +2440,20 @@ def main():
             hint = ("（Windows 排查：netstat -ano | findstr :%d 找到 PID，"
                     "tasklist /FI \"PID eq <PID>\" 看是谁；旧进程杀掉或换 --port）"
                     % args.port)
+        # 端口占用自动指认（借鉴 leftopen 38★）：直接报出 PID/进程/项目归属，
+        # 用户不用再手跑 netstat+tasklist 两连。识别不出时回落上面的手工指路。
+        try:
+            from core import portscan as _ps
+            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）；旧进程杀掉或换 --port 重启"
+                        % (_h.get("pid") or 0, _who, _proj))
+                break
+        except Exception:
+            pass
         raise SystemExit("[CodeBee] 端口 %d 已被占用，无法启动：%s %s"
                          % (args.port, e, hint))
 

package/app/pet.py

@@ -30,8 +30,10 @@ import http.client
 import json
 import math
 import os
+import queue
 import random
 import sys
+import threading
 import time
 import webbrowser
 from pathlib import Path
@@ -39,7 +41,8 @@ from pathlib import Path
 # --------------------------------------------------------------- 纯逻辑（可测试）
 
 ACTIVE_STATUSES = ("queued", "running")
-BAD_STATUSES = ("failed", "cancelled")
+GOOD_STATUSES = ("done",)
+BAD_STATUSES = ("failed", "cancelled", "timeout")
 POLL_MS = 4000          # 轮询间隔
 POLL_TIMEOUT = 2.5      # 单次拉取超时（秒）
 MAX_MISS = 15           # 连续拉不到服务 N 次后自离（约 1 分钟，防孤儿常驻）
@@ -49,20 +52,32 @@ HOVER_MS = 250          # 指针轮询周期
 HOVER_DELAY_MS = 350    # 悬停多久后才弹任务清单（扫过不弹）
 
 
+def _safe_int(value, default=0, minimum=0):
+    """外部状态里的计数可能是空值或脏字符串；统一兜底并限制为非负数。"""
+    try:
+        number = int(value)
+    except (TypeError, ValueError, OverflowError):
+        number = int(default)
+    return max(minimum, number)
+
+
 def parse_snapshot(raw):
     """把 /api/pet_state 响应裁成蜜蜂关心的最小集。字段缺失一律兜底，不抛。"""
     raw = raw if isinstance(raw, dict) else {}
-    st = raw.get("settings") or {}
+    st = raw.get("settings") if isinstance(raw.get("settings"), dict) else {}
+    workers = raw.get("workers") if isinstance(raw.get("workers"), dict) else {}
+    digest = raw.get("digest") if isinstance(raw.get("digest"), dict) else {}
+    task_rows = raw.get("tasks") if isinstance(raw.get("tasks"), list) else []
     tasks = []
-    for t in (raw.get("tasks") or [])[:300]:
+    for t in task_rows[:300]:
         if not isinstance(t, dict):
             continue
         tasks.append({
             "id": str(t.get("id") or ""),
             "title": str(t.get("title") or t.get("id") or ""),
             "run_status": str(t.get("run_status") or ""),
-            "steps_done": int(t.get("steps_done") or 0),
-            "steps_total": int(t.get("steps_total") or 0),
+            "steps_done": _safe_int(t.get("steps_done")),
+            "steps_total": _safe_int(t.get("steps_total")),
             "step_current": str(t.get("step_current") or ""),
             "error": str(t.get("error") or ""),
         })
@@ -73,15 +88,14 @@ def parse_snapshot(raw):
             "pet_skin": str(st.get("pet_skin") or DEFAULT_SKIN),
         },
         "workers": {
-            "running": int((raw.get("workers") or {}).get("running") or 0),
-            "queued": int((raw.get("workers") or {}).get("queued") or 0),
+            "running": _safe_int(workers.get("running")),
+            "queued": _safe_int(workers.get("queued")),
         },
         "tasks": tasks,
         "digest": {
-            "unseen": int((raw.get("digest") or {}).get("unseen") or 0),
-            "latest": (raw.get("digest") or {}).get("latest")
-                      if isinstance((raw.get("digest") or {}).get("latest"), dict)
-                      else None,
+            "unseen": _safe_int(digest.get("unseen")),
+            "latest": digest.get("latest")
+                      if isinstance(digest.get("latest"), dict) else None,
         },
     }
 
@@ -105,10 +119,12 @@ def derive_state(prev_active_ids, tasks):
         by_id = {t["id"]: t for t in tasks}
         for tid in prev_active_ids:
             t = by_id.get(tid)
-            if t is None or t["run_status"] not in BAD_STATUSES:
-                info["good"].append(t or {"id": tid, "title": tid})
-            else:
+            if t is None:
+                continue
+            if t["run_status"] in BAD_STATUSES:
                 info["bad"].append(t)
+            elif t["run_status"] in GOOD_STATUSES:
+                info["good"].append(t)
         if info["bad"]:
             return "alert", info
         if info["good"]:
@@ -276,7 +292,10 @@ def _http_json(port, path, body=None):
             method = "POST"
         conn.request(method, path, body=payload, headers=headers)
         resp = conn.getresponse()
-        return json.loads(resp.read().decode("utf-8"))
+        data = resp.read()
+        if not 200 <= resp.status < 300:
+            raise RuntimeError("CodeBee API 返回 HTTP %d" % resp.status)
+        return json.loads(data.decode("utf-8"))
     finally:
         conn.close()
 
@@ -405,6 +424,14 @@ class PetApp:
         self.hop_until = 0.0                        # 冒气泡时的蹦跶动作截止
         self.next_chatter = time.time() + random.uniform(90, 240)
         self.seen_digests = 0   # 本轮已通知过的摘要未读数（涨了才报，不重复轰炸）
+        self._polling = False
+        self._poll_results = queue.Queue(maxsize=1)
+        self._settings_lock = threading.Lock()
+        self._settings_pending = {}
+        self._settings_desired = {}
+        self._settings_confirmed = {}
+        self._settings_seq = 0
+        self._settings_worker_running = False
 
         if self.frames:
             self._build_sprite()
@@ -583,10 +610,7 @@ class PetApp:
             return
         self.skin = skin
         self._save_cfg(skin=skin)
-        try:
-            _http_json(self.port, "/api/settings", body={"pet_skin": skin})
-        except Exception:
-            pass
+        self._post_settings({"pet_skin": skin})
         self._rebuild_sprite()
 
     def _rebuild_sprite(self):
@@ -841,16 +865,92 @@ class PetApp:
         else:
             self._show([self.pbar_bg, self.pbar_fg], False)
 
-    # ---- 数据轮询（4s 一拍）----
+    def _post_settings(self, body):
+        """合并并串行发送设置，保证快速连点时最后一次选择最终生效。"""
+        patch = dict(body or {})
+        if not patch:
+            return
+        with self._settings_lock:
+            self._settings_seq += 1
+            seq = self._settings_seq
+            for key, value in patch.items():
+                self._settings_pending[key] = (seq, value)
+                self._settings_desired[key] = (seq, value)
+            if self._settings_worker_running:
+                return
+            self._settings_worker_running = True
+
+        def send():
+            while True:
+                with self._settings_lock:
+                    if not self._settings_pending:
+                        self._settings_worker_running = False
+                        return
+                    current = dict(self._settings_pending)
+                    self._settings_pending.clear()
+                try:
+                    _http_json(self.port, "/api/settings",
+                               body={key: item[1] for key, item in current.items()})
+                    with self._settings_lock:
+                        for key, item in current.items():
+                            self._settings_confirmed[key] = max(
+                                item[0], self._settings_confirmed.get(key, 0))
+                except Exception:
+                    # 新值优先；失败的旧值只补回尚未被新点击覆盖的键。
+                    with self._settings_lock:
+                        for key, item in current.items():
+                            self._settings_pending.setdefault(key, item)
+                    time.sleep(1.0)
+        threading.Thread(target=send, name="pet-settings", daemon=True).start()
+
+    def _reconcile_desired_settings(self, snap, confirmed_at_poll_start):
+        """只覆盖写入确认前已发出的旧轮询；确认后的快照以服务端为准。"""
+        with self._settings_lock:
+            for key, item in list(self._settings_desired.items()):
+                seq, value = item
+                if confirmed_at_poll_start.get(key, 0) >= seq:
+                    del self._settings_desired[key]
+                else:
+                    snap["settings"][key] = value
+
+    # ---- 数据轮询（4s 一拍；网络请求不占 Tk 主线程）----
     def _tick(self):
         self._touch_lock()
-        snap = None
+        if self._polling:
+            return
+        self._polling = True
+        with self._settings_lock:
+            confirmed_at_poll_start = dict(self._settings_confirmed)
+
+        def fetch():
+            snap = None
+            error = None
+            try:
+                snap = parse_snapshot(_http_json(self.port, "/api/pet_state"))
+            except Exception as exc:
+                error = exc
+            try:
+                self._poll_results.put_nowait(
+                    (snap, error, confirmed_at_poll_start))
+            except queue.Full:
+                pass
+
+        threading.Thread(target=fetch, name="pet-poll", daemon=True).start()
+        self.root.after(50, self._collect_poll)
+
+    def _collect_poll(self):
         try:
-            snap = parse_snapshot(_http_json(self.port, "/api/pet_state"))
-            self.miss = 0
-        except Exception:
+            snap, error, confirmed_at_poll_start = self._poll_results.get_nowait()
+        except queue.Empty:
+            self.root.after(50, self._collect_poll)
+            return
+        self._polling = False
+        if error is not None:
             self.miss += 1
+        else:
+            self.miss = 0
         if snap is not None:
+            self._reconcile_desired_settings(snap, confirmed_at_poll_start)
             if not snap["settings"]["pet_enabled"]:
                 return self._bye()
             self.snap = snap
@@ -1187,10 +1287,7 @@ class PetApp:
         return m
 
     def _set_mode(self, mode):
-        try:
-            _http_json(self.port, "/api/settings", body={"pet_mode": mode})
-        except Exception:
-            pass
+        self._post_settings({"pet_mode": mode})
 
     def _set_lang(self, lang):
         self.lang = lang