codebee 0.1.55 → 0.1.57

package/app/core/beekeeper.py

@@ -0,0 +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)

package/app/core/branching.py

@@ -83,12 +83,7 @@ def _append_audit(workdir, chapter, branches, pick):
     if not workdir:
         return
     try:
-        p = os.path.abspath(os.path.join(str(workdir), ".codebee",
-                                         "branch-plans.md"))
-        root = os.path.abspath(str(workdir))
-        if root not in p.split(os.sep)[:-len([".codebee", "branch-plans.md"])]:
-            if not p.startswith(root + os.sep):
-                return
+        p = _audit_path(workdir)
         os.makedirs(os.path.dirname(p), exist_ok=True)
         with open(p, "a", encoding="utf-8") as f:
             if f.tell() == 0:
@@ -103,3 +98,33 @@ def _append_audit(workdir, chapter, branches, pick):
             f.write("\n")
     except Exception:
         pass
+
+
+def _audit_path(workdir):
+    """审计文件路径（越界拒绝：workdir 必须存在的目录）。"""
+    from pathlib import Path
+    root = Path(workdir).resolve()
+    if not root.is_dir():
+        raise ValueError("workdir 必须是已存在的目录")
+    return root / ".codebee" / "branch-plans.md"
+
+
+def mark_stale(workdir, chapter):
+    """正史重写后旧推演标过期（inkos 借鉴：分支计划随正史失效）。
+
+    修订步骤改写章稿后，本章的分支计划节头追加「（已过期，正史已重写）」——
+    防止后续翻看审计时把旧推演当成当前正史的来源。失败静默。"""
+    if not workdir:
+        return
+    try:
+        p = _audit_path(workdir)
+        if not p.is_file():
+            return
+        txt = p.read_text(encoding="utf-8", errors="replace")
+        header = "## 第 %d 章\n" % chapter
+        stale_header = "## 第 %d 章（已过期，正史已重写）\n" % chapter
+        if header in txt and stale_header not in txt:
+            p.write_text(txt.replace(header, stale_header, 1),
+                         encoding="utf-8")
+    except Exception:
+        pass

package/app/core/jobs.py

@@ -260,10 +260,10 @@ def wait_for_idle(timeout=10):
 
 
 def begin_restart_drain():
-    """升级任务已退出执行位且没有用户任务时，原子停止接单。"""
+    """升级任务已退出执行位且没有用户任务或 direct 对话时，原子停止接单。"""
     global _restart_drain
     with _pool_lock:
-        if _restart_drain or _alive != 0:
+        if _restart_drain or _alive != 0 or _chat_alive != 0:
             return False
         _restart_drain = True
         return True
@@ -344,12 +344,12 @@ def _requeue_await_slot(job, waits_left=None):
             return
         if _restart_drain:
             _close_unstarted(job, "服务正在完成升级重启；本次未排队，请稍后重试",
-                             statuses=("running",))
+                             statuses=("queued", "running"))
         elif waits_left > 0:
             _requeue_await_slot(job, waits_left - 1)
         else:
             _close_unstarted(job, "并发位已满，排队等待超时仍未起跑，请稍后重试",
-                             statuses=("running",))
+                             statuses=("queued", "running"))
 
     with _timer_lock:
         if run_id in _deferred_timers:
@@ -921,7 +921,7 @@ def _do_selfupgrade(job, ev):
     if ev.is_set() or (store.get_run(run_id) or {}).get("status") != "running":
         return
     store.finish_step(run_id, step["n"], "done" if res["ok"] else "failed",
-                      summary="升级完成，点「重启」生效" if res["ok"]
+                      summary="升级完成，服务将自动重启生效" if res["ok"]
                       else ("升级失败: " + res["error"][:300]),
                       exit_code=res.get("exit_code"))
     # expected_status 守卫：用户已强制终止的运行保持 cancelled，不被改写

package/app/core/knowledge.py

@@ -251,6 +251,11 @@ def block_for(task):
         stale = _is_stale(x.get("as_of"))
         mark = ("（事实截至 %s，可能过期，请自行核实时效）" % x.get("as_of") if stale
                 else ("（事实截至 %s）" % x.get("as_of") if x.get("as_of") else ""))
+        # 置信标注（引用核验续）：medium 不标（默认噪音为零），low 早已
+        # 在学习口丢弃——只有 high 显式加冕，模型据以分配采信权重
+        conf = str(x.get("confidence") or "medium").strip().lower()
+        if conf == "high":
+            mark += "［有据］"
         lines.append("- **%s**%s：%s" % (x["title"], mark, x["body"]))
         used.append(x["id"])
     text = "## 知识库（已确认的领域知识，供参考）\n\n" + "\n".join(lines)

package/app/core/modelhub.py

@@ -681,6 +681,7 @@ def provider_view():
 # 读取点（凭据注入/健康探测/取模型列表）无需感知多 KEY 结构。没配 keys 的老数据
 # 由 _provider_keys 按 api_key 现场合成一条——文件一个字节都不用改。
 _KEY_COOLDOWN_S = 30 * 60      # 欠费类失败后的冷却时长
+_AUTH_COOLDOWN_S = 30 * 60     # 明确认证拒绝后的冷却时长，可在 UI 手动恢复
 MAX_PROVIDER_KEYS = 8          # 单厂商 KEY 上限
 MAX_CHAIN_ATTEMPTS = 8         # 链展开后的尝试上限（模型 × KEY）
 # 欠费/配额/限流类失败：换 KEY 有意义（同厂商另一账号=另一份额度与并发桶），
@@ -699,6 +700,19 @@ def _quota_error(err):
     return any(k in e for k in _QUOTA_HINTS)
 
 
+_AUTH_HINTS = ("invalid api key", "invalid_api_key", "api key is invalid",
+               "incorrect api key", "unauthorized", "unauthorised",
+               "authentication failed", "authentication error",
+               "authentication_error", "invalid token", "invalid_token",
+               "http 401", "status code 401")
+
+
+def _auth_error(err):
+    """明确的凭据认证拒绝；不把一般 403/模型权限错误误判成 KEY 错误。"""
+    e = (err or "").lower()
+    return any(k in e for k in _AUTH_HINTS)
+
+
 def _provider_keys(prov, available_only=False, now=None):
     """供应商的 KEY 列表，顺序=调用顺序。返回 [{id,key,label,enabled,cooling,...}]。
 
@@ -826,7 +840,7 @@ def key_op(provider_id, op, key_id="", key="", label="", enabled=None, ids=None)
 
 
 def note_key_error(provider_id, key_id, error=""):
-    """一次 KEY 级失败回写：欠费类进冷却（后续解析自动跳过 → 切备用 KEY）。"""
+    """一次 KEY 级失败回写：欠费或明确认证拒绝进冷却，后续解析切备用 KEY。"""
     import time as _t
     if not provider_id or not key_id:
         return
@@ -842,6 +856,8 @@ def note_key_error(provider_id, key_id, error=""):
         target["last_fail_at"] = _t.time()
         if _quota_error(error):
             target["cool_until"] = _t.time() + _KEY_COOLDOWN_S
+        elif _auth_error(error):
+            target["cool_until"] = _t.time() + _AUTH_COOLDOWN_S
         _sync_api_key(prov)
         _save(data)