codebee 0.1.22 → 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,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/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/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/ui/app.js

@@ -3420,6 +3420,7 @@ function drawTaskDetail(key, runs) {
     '<span class="stat">tokens <b>' + sum("tokens") + "</b></span>" +
     (latest.error ? '<span class="stat err">' + errTag(latest.error) + esc(latest.error.slice(0, 200)) + "</span>" : "");
   $("rd-plan").classList.add("hidden");
+  renderRouting(latest);
   let html = "";
   ordered.forEach((r, i) => {
     const runNo = runs.length - i;
@@ -3800,6 +3801,7 @@ async function renderRunDetail() {
     '<span class="stat tasksum hidden" id="rd-meta-task"></span>';
   if (S.detailSide) fillMetaTask(S.detailSide.stats || {});   // 缓存命中：轮询重画不闪丢累计组
   renderPlan(run);
+  renderRouting(run);
   // 详情页优先展示最近一步，排查运行中的任务时无需滚到底部；
   // 蜂巢泳道仍按原始流程顺序呈现，避免破坏阶段语义。
   $("rd-steps").innerHTML = (run.steps || []).slice().reverse().map((s) =>
@@ -5443,6 +5445,75 @@ function renderPlan(run) {
       '<span class="role">' + esc(s.title || "") + "</span>" +
       '<span class="sum">' + esc(s.detail || "") + "</span></div>").join("") + "</div>" + routeHtml;
 }
+
+/* 运行详情的统一调度审计：任务画像和实际选路来自同一次编译结果。
+ * 旧运行没有 task_spec/route_plan 时保持隐藏，避免把历史数据伪装成当前决策。 */
+function renderRouting(run) {
+  let box = $("rd-routing");
+  if (!box) {
+    const steps = $("rd-steps");
+    if (!steps || !steps.parentNode) return;
+    box = document.createElement("div");
+    box.id = "rd-routing";
+    box.className = "rd-routing hidden";
+    steps.parentNode.insertBefore(box, steps);
+  }
+  const spec = run && run.task_spec;
+  const plan = run && run.route_plan;
+  if (!spec || !plan) { box.classList.add("hidden"); box.innerHTML = ""; return; }
+  const type = spec.type || "direct";
+  const difficulty = spec.difficulty || "default";
+  const dimension = spec.dimension || "reasoning";
+  const caps = Array.isArray(spec.capabilities) ? spec.capabilities.filter(Boolean) : [];
+  const typeLabel = ((flowById(type) || {}).name) || type;
+  const difficultyLabel = t(({ easy: "简单", default: "标准", hard: "困难" })[difficulty] || difficulty);
+  const dimensionLabel = t(({ coding: "编码", writing: "写作", reasoning: "推理", vision: "视觉" })[dimension] || dimension);
+  const capLabels = {
+    coding: "编码", writing: "写作", reasoning: "推理", vision: "视觉",
+    filesystem: "文件读写", verification: "验证", long_context: "长上下文",
+    continuity: "连续性", attachments: "附件",
+  };
+  const capsText = caps.length ? caps.map((x) => t(capLabels[x] || x)).join(t("、")) : t("通用能力");
+  const selectedLabel = (entry) => entry && (entry.label || entry.agent_id || "") || t("未选定");
+  const roleBlock = (key, title) => {
+    const route = plan[key] || {};
+    const candidates = Array.isArray(route.candidates) ? route.candidates : [];
+    if (!route.selected && !candidates.length) return "";
+    const selected = candidates.find((x) => x.agent_id === route.selected) || candidates[0];
+    const participants = Array.isArray(route.participants) ? route.participants : [];
+    const activeIds = participants.length ? participants.slice() : (route.selected ? [route.selected] : []);
+    if (route.selected && activeIds.includes(route.selected)) {
+      activeIds.splice(activeIds.indexOf(route.selected), 1);
+      activeIds.unshift(route.selected);
+    }
+    const activeLabels = activeIds.map((id) => {
+      const item = candidates.find((x) => x.agent_id === id);
+      return selectedLabel(item || { agent_id: id });
+    }).filter(Boolean);
+    const fallback = Array.isArray(route.fallback) ? route.fallback : [];
+    const fallbackLabels = fallback.map((id) => {
+      const item = candidates.find((x) => x.agent_id === id);
+      return selectedLabel(item || { agent_id: id });
+    }).filter(Boolean);
+    const rows = candidates.map((x) =>
+      '<div class="rd-route-row"><span class="rd-route-score">' + esc(Number(x.score || 0).toFixed(1)) +
+      '</span><span class="rd-route-agent">' + esc(selectedLabel(x)) + '</span><span class="rd-route-reason">' +
+      esc(x.reason || "") + '</span></div>').join("");
+    return '<div class="rd-route-role"><div class="rd-route-role-head"><b>' + esc(title) +
+      '</b><span>' + esc(activeLabels.join(" + ") || selectedLabel(selected)) + '</span></div>' +
+      (route.selection_reason ? '<div class="rd-route-selection">' + esc(route.selection_reason) + '</div>' : "") +
+      (fallbackLabels.length ? '<div class="rd-route-fallback">' + esc(t("降级：")) + esc(fallbackLabels.join(" → ")) + '</div>' : "") +
+      (rows ? '<details class="rd-route-candidates"><summary>' + esc(t("查看候选评分")) + '</summary>' + rows + '</details>' : "") +
+      '</div>';
+  };
+  const roles = [roleBlock("implement", t("执行")), roleBlock("review", t("评审"))].filter(Boolean).join("");
+  if (!roles) { box.classList.add("hidden"); box.innerHTML = ""; return; }
+  box.classList.remove("hidden");
+  box.innerHTML = '<div class="rd-routing-head"><span class="rd-routing-title">' + esc(t("任务画像与调度")) +
+    '</span><span class="rd-routing-spec">' + esc(t("{0} · {1} · {2}", t(typeLabel), difficultyLabel, dimensionLabel)) + '</span></div>' +
+    '<div class="rd-routing-caps"><span>' + esc(t("需要：")) + '</span>' + esc(capsText) + '</div>' +
+    '<div class="rd-route-roles">' + roles + '</div>';
+}
 /* 日志框顶部状态条：运行中 → ● 实时（呼吸点 + 最后刷新时间）；结束 → 灰字已结束。
  * 没有它，用户分不清"日志在刷但 CLI 暂无输出"和"刷新坏了"——两者长得一模一样。 */
 function logLiveBadge(live) {
@@ -9348,6 +9419,64 @@ async function reportIssue() {
   }
 }
 
+/* 端口占用诊断（借鉴 leftopen）：谁占着端口、属于哪个项目；可温和关闭 */
+async function scanPorts() {
+  const box = $("ports-list");
+  if (!box) return;
+  const b = $("ports-scan");
+  if (b) b.disabled = true;
+  try {
+    const r = await api("/api/ports");
+    const ports = r.ports || [];
+    if (!ports.length) { box.innerHTML = '<span class="hint">' + esc(t("没有发现监听端口")) + "</span>"; return; }
+    box.innerHTML = "";
+    const tbl = document.createElement("table");
+    tbl.style.width = "100%";
+    tbl.style.fontSize = "12px";
+    tbl.style.borderCollapse = "collapse";
+    const th = (s) => '<th style="text-align:left;padding:4px 8px;opacity:.7">' + esc(s) + "</th>";
+    tbl.innerHTML = "<thead><tr>" + th(t("端口")) + th(t("进程")) + th(t("项目")) + th("") + "</tr></thead>";
+    const tb = document.createElement("tbody");
+    for (const p of ports) {
+      const tr = document.createElement("tr");
+      const td = (s) => '<td style="padding:4px 8px;border-top:1px solid var(--border)">' + s + "</td>";
+      tr.innerHTML =
+        td(p.port + (p.local_only ? ' <span class="pill">' + esc(t("仅本机")) + "</span>" : "") + (p.self ? ' <span class="pill">' + esc(t("本服务")) + "</span>" : "")) +
+        td(esc((p.process || "?") + (p.pid ? " · pid " + p.pid : ""))) +
+        td(p.project ? esc(p.project) : "-") +
+        "<td></td>";
+      const act = tr.lastElementChild;
+      if (!p.self && p.pid) {
+        const btn = document.createElement("button");
+        btn.className = "ghost small";
+        btn.textContent = t("关闭");
+        btn.onclick = () => closePort(p.port);
+        act.appendChild(btn);
+      }
+      tb.appendChild(tr);
+    }
+    tbl.appendChild(tb);
+    box.appendChild(tbl);
+  } catch (e) {
+    box.innerHTML = '<span class="hint">' + esc(t("扫描失败：") + (e.message || e)) + "</span>";
+  } finally {
+    if (b) b.disabled = false;
+  }
+}
+
+async function closePort(port) {
+  if (!confirm(t("向占用端口 %1 的进程发送温和关闭信号？（系统进程会被拒绝）").replace("%1", port))) return;
+  try {
+    const r = await api("/api/ports/close", { method: "POST", body: JSON.stringify({ port }) });
+    toast(r.message || (r.ok ? t("已发送关闭信号") : t("未能关闭")), !r.ok);
+    scanPorts();
+  } catch (e) {
+    toast(e.message || t("关闭失败"), true);
+  }
+}
+
+
+
 async function suCheck() {
   const b = $("su-check");
   if (b) b.disabled = true;

package/app/ui/i18n.js

@@ -1867,6 +1867,23 @@
     "一键反馈 Issue": "Report Issue",
     "已打开 GitHub 反馈页，内容已预填，可直接提交（也可附上诊断包 zip）": "GitHub issue page opened with the report pre-filled — submit it, and feel free to attach the diagnostics zip",
     "反馈摘要生成失败：": "Failed to build issue summary: ",
+    "端口占用": "Port Usage",
+    "扫描本机端口": "Scan local ports",
+    "谁占着端口、属于哪个项目一目了然；「仅本机」的端口外网不可达。关闭只发温和信号，系统进程与本服务自身拒绝关闭。": "See at a glance which process holds each port and which project it belongs to; \"local only\" ports are unreachable from outside. Close sends a gentle termination signal only — system processes and this service itself are refused.",
+    "端口": "Port",
+    "进程": "Process",
+    "项目": "Project",
+    "仅本机": "local only",
+    "本服务": "this service",
+    "关闭": "Close",
+    "没有发现监听端口": "No listening ports found",
+    "扫描失败：": "Scan failed: ",
+    "向占用端口 %1 的进程发送温和关闭信号？（系统进程会被拒绝）": "Send a gentle close signal to the process holding port %1? (system processes are refused)",
+    "已发送关闭信号": "Close signal sent",
+    "未能关闭": "Could not close",
+    "关闭失败": "Close failed",
+
+
 
     // —— 禅道 Bug 自动修复 ——
     "禅道": "ZenTao",
@@ -2261,6 +2278,23 @@
     "旧版浏览器缓存残留": "Legacy browser cache remains",
     "历史备份包": "Old backup archives",
     "服务日志瘦身": "Service log trim",
+    "任务画像与调度": "Task profile & routing",
+    "通用能力": "general capabilities",
+    "未选定": "Not selected",
+    "执行": "Implement",
+    "降级：": "Fallback: ",
+    "查看候选评分": "View candidate scores",
+    "需要：": "Needs: ",
+    "简单": "Easy",
+    "标准": "Standard",
+    "困难": "Hard",
+    "编码": "Coding",
+    "写作": "Writing",
+    "推理": "Reasoning",
+    "视觉": "Vision",
+    "文件读写": "File access",
+    "长上下文": "Long context",
+    "连续性": "Continuity",
     "发布浏览器缓存": "Publishing browser cache",
     "保留运行记录与结果报告，只删过程中的原始日志": "Keeps run records and result reports; only raw process logs are deleted",
     "发布过程留档截图，超期即清": "Screenshots kept as publishing evidence, removed once expired",