codebee 0.1.56 → 0.1.58

package/app/core/skill_scan.py

@@ -19,14 +19,19 @@ _PATTERNS = [
     (r"\beval\s*\(", "代码执行", "动态 eval 执行任意代码"),
     (r"\bexec\s*\(", "代码执行", "exec 执行任意代码"),
     (r"subprocess|os\.system|Popen", "代码执行", "起子进程执行命令"),
+    (r"child_process", "代码执行", "Node.js 子进程（可能执行任意命令）"),
     # 数据外发
     (r"https?://(?!api\.|docs\.|github\.com|raw\.githubusercontent)[a-z0-9.-]+/(upload|collect|track|ingest|webhook|callback)",
      "数据外发", "向非常规端点上传/回调数据"),
     (r"requests\.post|urllib\.request|fetch\s*\(", "网络请求", "发起网络请求（确认目标可信）"),
+    (r"base64.{0,10}(decode|b64decode|atob)", "数据外发",
+     "base64 解码（可能隐藏混淆载荷）"),
     # 敏感信息读取
     (r"os\.environ|process\.env|getenv", "环境读取", "读取环境变量（可能带走密钥）"),
     (r"\.ssh/|\.aws/|\.npmrc|\.gitconfig|credentials|\.env\b", "敏感文件", "触碰凭据/密钥文件路径"),
     (r"keychain|credential manager|dpapi", "敏感文件", "访问系统凭据库"),
+    (r"\.claude/|\.zcode/|\.kimi-code/|\.codebee/", "敏感文件",
+     "触碰 AI 助手配置目录（可能篡改系统提示词或模型绑定）"),
     # 提示注入特征
     (r"(ignore|disregard|forget).{0,30}(previous|above|prior|all).{0,20}(instruction|prompt|rule)",
      "提示注入", "指令覆盖话术（试图无视既有规则）"),
@@ -65,13 +70,17 @@ def scan_text(text, max_findings=12):
 def risk_label(findings):
     """发现列表 → 风险标签（装前提示行用）。
 
-    高危（代码执行/敏感文件/可疑意图）任一命中 = 高风险；否则有发现 = 注意；
-    空 = 干净。"""
+    三级：高危（代码执行/敏感文件/可疑意图/数据外发/base64 解码）任一
+    命中 = 高风险；中危类（网络请求/环境读取/提示注入/越权人格）≥2 类
+    同时命中 = 中风险；有发现 = 注意；空 = 干净。"""
     if not findings:
         return ""
     cats = {f["category"] for f in findings}
     if cats & {"代码执行", "敏感文件", "可疑意图", "数据外发"}:
         return "⚠ 高风险"
+    medium_cats = cats & {"网络请求", "环境读取", "提示注入", "越权人格"}
+    if len(medium_cats) >= 2:
+        return "⚠ 中风险"
     return "△ 注意"
 
 

package/app/core/store.py

@@ -28,11 +28,11 @@ _RUNS = {}
 # 长跑也不会无限增长（finish_step 里调 clear_stream_state）。
 _STREAM_LOCK = threading.Lock()
 _STREAM_TS = {}
-LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
-
-DEFAULT_TASK_TIMEOUT_S = 3600
-MIN_TASK_TIMEOUT_S = 1
-MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
+LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
+
+DEFAULT_TASK_TIMEOUT_S = 3600
+MIN_TASK_TIMEOUT_S = 1
+MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
 
 # ---------------------------------------------------------------- 状态版本（SSE 事件驱动）
 # 任何落盘写都算状态变化：SSE 连接等版本号变化才构建/推送全量状态，
@@ -61,38 +61,38 @@ def wait_state_change(last_ver, timeout):
         return _STATE_VER
 
 
-def _new_id(prefix):
-    stamp = time.strftime("%Y%m%d-%H%M%S")
-    # 10k random suffixes are not unique under a burst of task/run creation.
-    # Reserve against both indexes and disk so a collision cannot silently
-    # overwrite a queued run and make one of several submissions disappear.
-    with LOCK:
-        for _ in range(100):
-            candidate = "%s-%s-%04d" % (prefix, stamp, secrets.randbelow(10000))
-            if candidate in _TASKS or candidate in _RUNS:
-                continue
-            if (paths.TASKS_DIR / (candidate + ".json")).exists():
-                continue
-            if (paths.RUNS_DIR / candidate).exists():
-                continue
-            return candidate
-    raise RuntimeError("无法生成唯一记录 ID")
-
-
-def _safe_name(s):
-    return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
-
-
-def _task_timeout_s(value=None):
-    """Resolve one bounded wall-clock budget for a task."""
-    raw = value
-    if raw in (None, ""):
-        raw = os.environ.get("TUTTI_TASK_TIMEOUT_S", DEFAULT_TASK_TIMEOUT_S)
-    try:
-        seconds = int(float(raw))
-    except (TypeError, ValueError):
-        seconds = DEFAULT_TASK_TIMEOUT_S
-    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
+def _new_id(prefix):
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    # 10k random suffixes are not unique under a burst of task/run creation.
+    # Reserve against both indexes and disk so a collision cannot silently
+    # overwrite a queued run and make one of several submissions disappear.
+    with LOCK:
+        for _ in range(100):
+            candidate = "%s-%s-%04d" % (prefix, stamp, secrets.randbelow(10000))
+            if candidate in _TASKS or candidate in _RUNS:
+                continue
+            if (paths.TASKS_DIR / (candidate + ".json")).exists():
+                continue
+            if (paths.RUNS_DIR / candidate).exists():
+                continue
+            return candidate
+    raise RuntimeError("无法生成唯一记录 ID")
+
+
+def _safe_name(s):
+    return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
+
+
+def _task_timeout_s(value=None):
+    """Resolve one bounded wall-clock budget for a task."""
+    raw = value
+    if raw in (None, ""):
+        raw = os.environ.get("TUTTI_TASK_TIMEOUT_S", DEFAULT_TASK_TIMEOUT_S)
+    try:
+        seconds = int(float(raw))
+    except (TypeError, ValueError):
+        seconds = DEFAULT_TASK_TIMEOUT_S
+    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
 
 
 # ---------------------------------------------------------------- 任务
@@ -158,8 +158,8 @@ def create_task(payload):
         "status": "created",
     }
     thinking = str(payload.get("thinking") or "standard").strip().lower()
-    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
-    task["timeout_s"] = _task_timeout_s(payload.get("timeout_s"))
+    task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
+    task["timeout_s"] = _task_timeout_s(payload.get("timeout_s"))
     if flow["engine"] == "direct":
         task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
                                             "direct_provider_id")[:80]
@@ -546,7 +546,7 @@ def load_all():
                 _save_json(paths.TASKS_DIR / (t["id"] + ".json"), t)
                 continue
             latest = max(runs, key=lambda r: r["id"])
-            if latest.get("status") in ("done", "failed", "cancelled", "timeout"):
+            if latest.get("status") in ("done", "failed", "cancelled", "timeout"):
                 t["status"] = latest["status"]
                 _save_json(paths.TASKS_DIR / (t["id"] + ".json"), t)
 
@@ -562,7 +562,7 @@ def set_run_estimator(estimator):
     _RUN_ESTIMATOR = estimator if callable(estimator) else None
 
 
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
@@ -570,14 +570,14 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "task_id": task_id, "entry_id": entry_id, "op": op,
         "status": "queued", "steps": [], "messages": [],
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "started_at": None, "ended_at": None,
-        "deadline_at": None,
+        "started_at": None, "ended_at": None,
+        "deadline_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
         "verdict": None, "summary": "",
     }
-    if kind == "orchestration" and task_id:
-        task = get_task(task_id) or {}
-        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
         try:
             eta = _RUN_ESTIMATOR(
                 task_type=task.get("type") or "", mode=task.get("mode") or "auto",
@@ -661,6 +661,37 @@ def task_runs(task_id):
     return runs
 
 
+def task_runs_page(task_id, offset=0, limit=3):
+    """分页读取任务运行，只复制当前页；全量轻统计在详情打开时按需计算。"""
+    with LOCK:
+        runs = [r for r in _RUNS.values() if r.get("task_id") == task_id]
+    runs.sort(key=lambda run: run["id"], reverse=True)
+    page = [dict(run) for run in runs[offset:offset + limit]]
+    total_steps = settled_steps = total_tokens = 0
+    total_cost = 0.0
+    for run in runs:
+        steps = run.get("steps") or []
+        total_steps += len(steps)
+        settled_steps += sum(1 for step in steps
+                             if step.get("status") not in ("running", "queued"))
+        try:
+            total_cost += float(run.get("cost_usd") or 0)
+        except (TypeError, ValueError):
+            pass
+        try:
+            total_tokens += int(run.get("tokens") or 0)
+        except (TypeError, ValueError):
+            pass
+    return {
+        "runs": page,
+        "total": len(runs),
+        "offset": offset,
+        "has_more": offset + len(page) < len(runs),
+        "totals": {"steps": total_steps, "settled_steps": settled_steps,
+                   "cost_usd": total_cost, "tokens": total_tokens},
+    }
+
+
 def task_side(task_id):
     """任务检查器（右缘停靠列）的轻量聚合：最新 run 摘要 + 进度步骤 +
     git 分支/裁决状态 + 变更行级统计 + 成品文件。
@@ -762,27 +793,27 @@ def update_run(run_id, expected_status=None, **fields):
         # 这套在落终态瞬间即时收口——打磨组长被取消/异常打断时 UI 不闪
         # 假「工作中」）。run 终态后不可能还有步骤在真跑。
         st = fields.get("status")
-        if st in ("done", "failed", "cancelled", "timeout"):
-            end_s = time.strftime("%H:%M:%S")
-            for s in run["steps"]:
-                if s.get("status") in ("queued", "running"):
-                    s["status"] = "timeout" if st == "timeout" else "cancelled"
-                    s["ended_at"] = s.get("ended_at") or end_s
-                    if not s.get("summary"):
-                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
-                                         if st == "timeout" else
-                                         "步骤未正常收尾（终态自动恢复）")
+        if st in ("done", "failed", "cancelled", "timeout"):
+            end_s = time.strftime("%H:%M:%S")
+            for s in run["steps"]:
+                if s.get("status") in ("queued", "running"):
+                    s["status"] = "timeout" if st == "timeout" else "cancelled"
+                    s["ended_at"] = s.get("ended_at") or end_s
+                    if not s.get("summary"):
+                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
+                                         if st == "timeout" else
+                                         "步骤未正常收尾（终态自动恢复）")
         _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         # 状态回填：起跑与结束都同步任务状态。只回填终态的话，run 在跑、
         # 任务永远显示「排队中」（2026-09-18 实案：「# 重写·续」run 已 running
         # 写了一小时，任务卡 queued，用户以为卡死连点重试）。
-        if st in ("running", "done", "failed", "cancelled", "timeout"):
+        if st in ("running", "done", "failed", "cancelled", "timeout"):
             tid = run.get("task_id")
             task = _TASKS.get(tid) if tid else None
             if task:
                 task["status"] = st
                 _save_json(paths.TASKS_DIR / (tid + ".json"), task)
-        if st in ("done", "failed", "cancelled", "timeout"):
+        if st in ("done", "failed", "cancelled", "timeout"):
             # run_end 钩子（2026-09-22）：终态即触发，后台跑副作用型脚本
             # （回写知识库等）；失败/超时静默，绝不拖慢收尾路径
             try:
@@ -873,17 +904,17 @@ def recover_orphaned_runs():
     step_now = time.strftime("%H:%M:%S")
     with LOCK:
         for r in _RUNS.values():
-            if r.get("status") not in ("done", "failed", "cancelled", "timeout"):
-                continue
+            if r.get("status") not in ("done", "failed", "cancelled", "timeout"):
+                continue
             changed = False
             for s in r.get("steps") or []:
                 if s.get("status") in ("queued", "running"):
-                    s["status"] = "timeout" if r.get("status") == "timeout" else "cancelled"
+                    s["status"] = "timeout" if r.get("status") == "timeout" else "cancelled"
                     s["ended_at"] = s.get("ended_at") or step_now
                     if not s.get("summary"):
-                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
-                                         if r.get("status") == "timeout" else
-                                         "步骤未正常收尾（取消/中断自动恢复）")
+                        s["summary"] = ("步骤未正常收尾（任务总时限已到）"
+                                         if r.get("status") == "timeout" else
+                                         "步骤未正常收尾（取消/中断自动恢复）")
                     changed = True
             if changed:
                 _save_json(paths.RUNS_DIR / r["id"] / "run.json", r)

package/app/core/zentao.py

@@ -329,6 +329,10 @@ _TOKEN = {"v": "", "at": 0.0}
 _APIBASE = {}
 # 通道自适应：原始地址 → "rest"（≥15 REST v1）/ "old"（老版 module-method JSON 接口）
 _MODE = {}
+# web 端路由形态：原始地址 → "pathinfo"（伪静态 bug-view-N.html，官方默认）
+# / "get"（index.php?m=bug&f=view&bugID=N）。bug 详情链接用（2026-09-23 真机实证
+# 伪静态部署对 GET 式链接不路由）。
+_WEBSTYLE = {}
 _OLD = {"api": "", "sid": "", "at": 0.0}
 _OLD_FORM = {"form": ""}      # 命中的密码形态 "plain" | "md5chain"，缓存避免重复试
 _REST_LAST_ERR = {"msg": ""}
@@ -349,6 +353,37 @@ def resolved_base_url(base_url):
     return re.sub(r"/api\.php/v1$", "", hit)
 
 
+def probe_web_style(base_url):
+    """探测禅道 web 端路由形态（bug 详情链接用）：GET web 根（裸根 + 常见 /zentao
+    子路径都试），看登录跳转里是伪静态路由（user-login-xxx.html）还是 GET 式
+    （index.php?m=user）。尽力而为：任何网络/守卫异常回空串，绝不影响登录与
+    扫描主流程；探出即缓存。"""
+    try:
+        b = _raw_base(base_url)
+    except ZenError:
+        return ""
+    if _WEBSTYLE.get(b):
+        return _WEBSTYLE[b]
+    style = ""
+    for root in (b + "/", b + "/zentao/"):
+        body = ""
+        try:
+            req = urllib.request.Request(_guard_url(root), headers={"Accept": "text/html"})
+            with _no_redirect_opener().open(req, timeout=HTTP_TIMEOUT) as r:
+                body = (r.read(65536) or b"").decode("utf-8", "replace")
+        except Exception:
+            body = ""
+        if "user-login-" in body or re.search(r"[a-z]+-view-\d+[^\"]*\.html", body):
+            style = "pathinfo"
+        elif "index.php?m=" in body:
+            style = "get"
+        if style:
+            break
+    if style:
+        _WEBSTYLE[b] = style
+    return style
+
+
 def _raw_base(base_url):
     b = str(base_url or "").strip().rstrip("/")
     if not b:
@@ -415,6 +450,7 @@ def _rest_login(base_url, account, password):
             _APIBASE[b] = api
             _TOKEN["v"] = tok
             _TOKEN["at"] = time.time()
+            probe_web_style(b)      # bug 链接形态探测，失败不影响登录
             return tok
         # HTTP 200 但没有 token：REST 在但不认账密（如只认应用 code 的部署）
         _REST_LAST_ERR["msg"] = "REST 接口不认账密（%s）" % (
@@ -592,6 +628,7 @@ def _old_login(cfg, rest_err=""):
                 _OLD.update(api=api, sid=sid, at=time.time())
                 _OLD_FORM["form"] = form
                 _MODE[b] = "old"
+                probe_web_style(b)  # bug 链接形态探测，失败不影响登录
                 return
             last = err
         break       # 同一台服务，账密结果与子路径无关，别再烧尝试次数
@@ -897,6 +934,40 @@ def list_bugs(cfg, product_id, profile=None):
     return out[:MAX_BUGS]
 
 
+def weekly_brief(limit=12):
+    """本周工作素材（工作汇报起草注入用，2026-09-23 Weekly Report Generator 借鉴
+    ——「从工作系统取数入素材」）：分配给我的活跃任务 + 指派给我的活跃 Bug 摘要。
+    尽力而为：未配置/不可达/响应形状不对一律返回空串，绝不阻塞汇报起草。
+    多产品档案逐个聚合（同 _scan 口径），条目总量封顶 limit*2。"""
+    lines = []
+    try:
+        cfg = _cfg()
+        for profile in _profiles(cfg):
+            assigned = str(profile.get("assigned_to") or "").strip()
+            if not assigned:
+                continue
+            try:
+                d = _call("GET", "/tasks?%s" % urllib.parse.urlencode(
+                    {"assignedTo": assigned, "limit": limit}), cfg=cfg)
+                tasks = d.get("tasks") if isinstance(d, dict) else None
+                for t in (tasks or [])[:limit]:
+                    if isinstance(t, dict) and t.get("status") in ("wait", "doing"):
+                        lines.append("- [任务#%s] %s（%s）" % (
+                            t.get("id"), t.get("name") or "", t.get("status") or ""))
+            except Exception:
+                pass
+            try:
+                for b in list_bugs(cfg, profile.get("product"), profile)[:limit]:
+                    lines.append("- [Bug#%s] %s（严重级 %s）" % (
+                        b.get("id"), b.get("title") or "",
+                        b.get("severity") or b.get("status") or ""))
+            except Exception:
+                pass
+    except Exception:
+        return ""
+    return "\n".join(lines[:limit * 2])
+
+
 def fetch_modules(product_id):
     """拉产品模块清单（模块路由配置辅助）。接口不存在/失败报人话，提示手填 ID。"""
     _ensure_loaded()
@@ -1976,6 +2047,13 @@ def bug_web_base(cfg=None):
     return b if b.startswith(("http://", "https://")) else ""
 
 
+def bug_link_style(cfg=None):
+    """bug 详情链接形态：探测缓存优先，没探出来按伪静态（官方默认形态）。"""
+    c = dict(cfg) if cfg else _cfg()
+    b = str(c.get("base_url") or "").strip().rstrip("/")
+    return _WEBSTYLE.get(b) or "pathinfo"
+
+
 def view():
     """前端视图：配置脱敏（password 只回是否已设）+ claims 列表（新在前）。"""
     _ensure_loaded()
@@ -1989,6 +2067,7 @@ def view():
                         key=lambda c: str(c.get("claimed_at") or ""), reverse=True)
         return {"config": cfg,
                 "bug_base": bug_base,
+                "bug_style": bug_link_style(cfg),
                 "claims": [dict(c) for c in claims],
                 "last_scan": _STATE.get("last_scan") or "",
                 "next_scan": _STATE.get("next_scan") or "",
@@ -2003,6 +2082,7 @@ def _test_reset():
         _STATE["last_scan"] = _STATE["next_scan"] = _STATE["last_error"] = ""
         _reset_token()
         _APIBASE.clear()
+        _WEBSTYLE.clear()
         _MODE.clear()
         _OLD.update(api="", sid="", at=0.0)
         _OLD_FORM["form"] = ""

package/app/main.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import argparse
 import json
 import logging
+import math
 import os
 import re
 import socket
@@ -434,7 +435,15 @@ class Handler(BaseHTTPRequestHandler):
                 # 任务级详情用：该任务全部 run（含 steps），不受前端 run 窗口限制
                 if not store.get_task(m.group(1)):
                     return self._json(404, {"error": "not found"})
-                return self._json(200, {"runs": store.task_runs(m.group(1))})
+                query = parse_qs(urlparse(self.path).query)
+                if "limit" not in query:
+                    return self._json(200, {"runs": store.task_runs(m.group(1))})
+                try:
+                    limit = max(1, min(20, int((query.get("limit") or [3])[0])))
+                    offset = max(0, int((query.get("offset") or [0])[0]))
+                except (TypeError, ValueError):
+                    return self._json(400, {"error": "invalid pagination"})
+                return self._json(200, store.task_runs_page(m.group(1), offset, limit))
             m = re.match(r"^/api/tasks/([^/]+)/bible$", path)
             if m:
                 # 故事圣经：查看（无令牌豁免走 _authed 已过；本机免令牌）
@@ -1988,6 +1997,13 @@ class Handler(BaseHTTPRequestHandler):
         verdict = latest.get("verdict") or {}
         route = latest.get("route") or {}
 
+        def _seconds(value):
+            try:
+                value = float(value)
+            except (OverflowError, TypeError, ValueError):
+                return None
+            return value if math.isfinite(value) and value >= 0 else None
+
         def _sec(a, b):
             try:
                 return max(0, int(time.mktime(time.strptime(b, "%Y-%m-%d %H:%M:%S")) -
@@ -1995,6 +2011,28 @@ class Handler(BaseHTTPRequestHandler):
             except Exception:
                 return None
         t0 = latest.get("started_at") or latest.get("created_at")
+        # Run timestamps are stored only to whole seconds; two timestamps in the
+        # same second therefore produce a misleading 0 even when a CLI step ran
+        # for a minute. Prefer the precise persisted duration, then the sum of
+        # step durations, and use wall-clock timestamps only as a legacy fallback.
+        duration_s = _seconds(latest.get("duration_s"))
+        step_durations = []
+        for step in latest.get("steps") or []:
+            if isinstance(step, dict):
+                value = _seconds(step.get("duration_s"))
+                if value is not None:
+                    step_durations.append(value)
+        step_duration_s = round(sum(step_durations), 1) if step_durations else None
+        if duration_s is None or duration_s == 0:
+            if step_duration_s is not None and step_duration_s > 0:
+                duration_s = step_duration_s
+            else:
+                timestamp_duration_s = (_sec(t0, latest.get("ended_at") or "")
+                                        if t0 and latest.get("ended_at") else None)
+                if timestamp_duration_s is not None:
+                    duration_s = timestamp_duration_s
+                elif step_duration_s is not None:
+                    duration_s = step_duration_s
         wd, files = "", []
         try:
             wd, files = store.run_artifacts(latest.get("id") or "", limit=12)
@@ -2007,8 +2045,7 @@ class Handler(BaseHTTPRequestHandler):
             "error": (latest.get("error") or "") if st in ("failed", "timeout") else "",
             "executor": route.get("implementer") or verdict.get("impl") or "",
             "turns": verdict.get("turns") or 0,
-            "duration_s": _sec(t0, latest.get("ended_at") or "")
-                if t0 and latest.get("ended_at") else None,
+            "duration_s": duration_s,
             "workdir": wd,
             "files": files,
         }
@@ -2504,6 +2541,19 @@ def main():
                         help="自更新重启用：先等旧实例释放端口再启动（Windows 双 LISTEN 防护）")
     args = parser.parse_args()
 
+    # 测试实例禁止使用默认端口 8765（2026-09-23 实案：代理测试忘带 --port，
+    # 启动清场把真实服务当旧实例杀掉后鸠占鹊巢）。测试请显式指定独立端口。
+    try:
+        from core.manager import tmp_data_no_home_write as _tdnhw
+    except Exception:
+        _tdnhw = None
+    if _tdnhw and _tdnhw() and args.port == 8765 and "--port" not in sys.argv:
+        raise SystemExit("[CodeBee] 测试实例禁止使用默认端口 8765（会与真实服务冲突），"
+                         "请显式指定 --port <独立端口>")
+    if _tdnhw and _tdnhw() and args.port == 8765:
+        print("[CodeBee] ⚠ 测试实例正占用默认端口 8765——真实服务将无法启动；"
+              "请改用独立端口", flush=True)
+
     # 启动每步都落一行进度（flush 强制落屏）：冷启动在慢盘/杀软扫描下可能几十秒，
     # 不打印会让用户以为卡死（真实案例：npm 装完首启只看到横幅像挂了）。
     # 看门狗：任何阶段卡超过 20 秒，自动把所有线程堆栈打到控制台（每 20s 重复）——
@@ -2665,8 +2715,16 @@ def main():
         from core import portscan as _ps, portguard as _pg
         _hint = ""
         try:
-            _cleared, _hint = _pg.clear_stale_port(
-                args.port, paths.APP_DIR / "main.py")
+            from core.manager import tmp_data_no_home_write
+            if tmp_data_no_home_write():
+                # 测试实例不清场：TUTTI_DATA 在临时目录的进程若占用了真实
+                # 端口（如 8765），清场会误杀生产服务（2026-09-23 实案）
+                _cleared, _hint = False, "测试实例不执行端口清场"
+            else:
+                _cleared, _hint = _pg.clear_stale_port(
+                    args.port, paths.APP_DIR / "main.py")
+        except Exception:
+            _cleared, _hint = False, 
         except Exception:
             _cleared, _hint = False, ""
         if _cleared: