codebee 0.1.3 → 0.1.4

package/app/core/pipeline.py

@@ -20,6 +20,7 @@ import threading
 import time
 
 from . import catalog, history, jobs, manager, modelhub, mocks, planner, registry, router, runner, skills, store, usage
+from . import builtin_agent
 from . import diagnostics
 from . import paths as paths_mod
 from . import session_log as session_log_mod
@@ -325,6 +326,55 @@ def _run_step(run_id, role, agent, prompt, workdir, readonly, ev, timeout=runner
     return res
 
 
+def _run_builtin_step(run_id, role, bi, prompt, workdir, ev, note=""):
+    """内置智能体步骤：直连模型 API + 工具循环（builtin_agent），不经 CLI 进程。
+
+    与 _run_step 对齐的三件事：暂停/取消闸门、运行中指令 drain 注入、重复调用
+    守门；结果同样经 _finish_step_result 落步骤（output=干净回答）并入用量台账。
+    日志只有「迭代/工具」摘要行——对话视图吃 output，日志抽屉看工具轨迹。"""
+    _wait_gate(run_id, ev)
+    step, log_abs = store.add_step(run_id, role, "builtin", "内置智能体", note=note)
+    start = time.time()
+    agent_pseudo = {"id": "builtin", "label": "内置智能体", "kind": "builtin", "mode": "real",
+                    "provider": {"id": bi.get("provider_id") or "",
+                                 "name": bi.get("provider_name") or ""}}
+    guard = repeat_guard.check(run_id, role, prompt)
+    if guard["should_stop"]:
+        from .error_codes import ErrorCode
+        res = {"ok": False, "text": "", "usage": None, "cost_usd": 0.0, "tokens": 0,
+               "error": guard["reminder"], "error_code": ErrorCode.ENV_BLOCK,
+               "raw": {"exit_code": None}, "model": bi.get("model")}
+        _finish_step_result(run_id, step, res, role, agent_pseudo, start)
+        return res
+    # 运行中指挥：drain 用户追加的指令/附件，注入本轮（与 _run_step 同语义）
+    directive_block, _imgs = _drain_directives(run_id, workdir, role=role, step_n=step["n"])
+    if directive_block:
+        prompt = directive_block + "\n\n---\n\n" + prompt
+    if guard["reminder"]:
+        prompt = guard["reminder"] + "\n\n---\n\n" + prompt
+    lines = ["内置智能体（%s · %s）" % (bi.get("provider_name"), bi.get("model"))]
+
+    def _log(line):
+        lines.append(str(line))
+
+    res = builtin_agent.run(bi, prompt, workdir, cancel_event=ev, log=_log)
+    if log_abs:
+        try:
+            log_abs.write_text("\n".join(lines) + "\n", encoding="utf-8")
+        except Exception:
+            pass
+    usage = res.get("usage") or {}
+    res.setdefault("raw", {})
+    res["raw"]["exit_code"] = 0 if res.get("ok") else 1
+    res["raw"]["duration"] = time.time() - start
+    res["tokens"] = int(usage.get("total") or 0)
+    res.setdefault("cost_usd", 0.0)
+    # 先收尾再查取消：与 _run_step 同序，防步骤记录停在「运行中」变僵尸
+    _finish_step_result(run_id, step, res, role, agent_pseudo, start)
+    _check_cancel(ev)
+    return res
+
+
 def _budget_max_tokens():
     """§07 T2.1：单次 run 的 token 预算上限；0/未配置 = 不限。
 
@@ -851,6 +901,28 @@ DIRECT_DONE: <一句话说明本轮做了什么>
 
 DIRECT_MAX_TURNS = 200   # 对话续轮上限（每轮都要用户主动发消息才触发，防意外打满）
 
+# 内置智能体版：人格与工具说明在 builtin_agent._SYSTEM_PROMPT，这里只给任务输入；
+# 不要求 DIRECT_DONE 协议尾行——builtin 的最终回答本身就是干净文本
+BUILTIN_DIRECT_PROMPT = """## 任务
+__GOAL__
+
+## 背景与上下文
+__CONTEXT__
+
+## 要求
+- 能改直接改、能写直接写（用工具，限本工作目录内），产出文件一律 UTF-8 编码。
+- 完成后直接给用户一段简短说明：做了什么、产出/修改了哪些文件。"""
+
+BUILTIN_FOLLOWUP_PROMPT = """## 原始任务
+__GOAL__
+
+## 上一轮输出（结尾）
+__PREV__
+
+## 要求
+- 优先回应用户的新消息（继续做/改/答疑均可），仍限本工作目录内，工具可用。
+- 回复直接说清本轮做了什么、答案是什么。"""
+
 
 def _pending_messages(run_id):
     """该 run 信箱里未消费消息列表（读不到时当空，绝不因信箱异常打断执行）。"""
@@ -885,25 +957,36 @@ def _direct_last_text(run):
 
 
 def _run_direct(run, task, agents, ev, stats, mode):
-    """直连引擎：目标+附件直接交给一个 CLI，跑完即止。
-
-    无规划/评审/验证/换将——快档位，质量交给执行 CLI 自身。对话式续轮：
-    运行中信箱来消息 → drain 注入下一步（_run_step 既有机制）；步骤结束后
-    信箱还有未消费消息就再续一轮（会话续接，同一 CLI 连续对话）；信箱空了
-    收工为 done。运行结束后再来消息走 retry_task（消息自动继承到新 run）。
+    """直连引擎：目标+附件直接交给一个执行者，跑完即止。
+
+    执行者优先级：内置智能体（直连模型 API + 工具循环，无 CLI 进程）→ CLI 智能体。
+    任务显式声明 CLI 会话续接（resume）或手动指定了执行者时尊重选择走 CLI；
+    无可用供应商时回退 CLI。无规划/评审/验证/换将——快档位。对话式续轮：
+    运行中信箱来消息 → drain 注入下一步；步骤结束后信箱还有未消费消息就
+    再续一轮；信箱空了收工为 done。运行结束后再来消息走 retry_task
+    （消息自动继承到新 run）。
     """
     run_id = run["id"]
     workdir = task["workdir"]
     route = {}
     resume_ctx = _valid_resume(task, agents)
-    if resume_ctx is not None:
+    bi = None
+    if resume_ctx is None and not (mode == "manual" and task.get("implementer")):
+        try:
+            bi = builtin_agent.resolve()
+        except Exception:
+            bi = None
+    if bi is not None:
+        impl = None
+        route["implementer"] = "内置智能体（%s · %s）" % (bi["provider_name"], bi["model"])
+    elif resume_ctx is not None:
         impl = resume_ctx["agent"]
         route["implementer"] = resume_ctx["note"]
     elif mode == "manual":
         impl, _ = _pick_implementer(agents, task.get("implementer"))
     else:
         impl, route["implementer"] = router.pick(agents, "implement", task["type"], stats)
-    if impl is None:
+    if impl is None and bi is None:
         store.update_run(run_id, status="failed", error="没有可用智能体", ended_at=_now())
         return
     difficulty = task.get("difficulty") or "default"
@@ -913,8 +996,8 @@ def _run_direct(run, task, agents, ev, stats, mode):
     sid = (resume_ctx["session"] if resume_ctx else "") or ""
     last_text = ""
     # 追话起跑（/api/runs/<id>/chat → retry_task）：信箱已有未消费消息 = 这是对话
-    # 的下一轮而非首轮。继承上一轮的 CLI 会话 id，让它真的「接着上次聊」；
-    # 同时把首步切成续轮档（DIRECT_FOLLOWUP），避免又走一遍开场的完整任务框架。
+    # 的下一轮而非首轮。CLI 继承上一轮的会话 id（真的「接着上次聊」），内置智能体
+    # 靠「上一轮输出（结尾）」块带上下文；同时把首步切成续轮档。
     try:
         pending0 = store.peek_messages(run_id)
     except Exception:
@@ -923,7 +1006,7 @@ def _run_direct(run, task, agents, ev, stats, mode):
         prev = _direct_prev_run(task["id"], run_id)
         if prev:
             ps = (prev.get("direct_session") or {})
-            if ps.get("agent") == impl["id"] and ps.get("session"):
+            if impl is not None and ps.get("agent") == impl["id"] and ps.get("session"):
                 sid = sid or ps["session"]
             if ps.get("workdir"):
                 step_wd = ps["workdir"]
@@ -933,38 +1016,55 @@ def _run_direct(run, task, agents, ev, stats, mode):
     while True:
         _wait_gate(run_id, ev)
         if first:
-            prompt = (DIRECT_PROMPT
-                      .replace("__GOAL__", task["goal"])
-                      .replace("__CONTEXT__", task.get("context") or "（无）"))
+            if bi is not None:
+                prompt = (BUILTIN_DIRECT_PROMPT
+                          .replace("__GOAL__", task["goal"])
+                          .replace("__CONTEXT__", task.get("context") or "（无）"))
+            else:
+                prompt = (DIRECT_PROMPT
+                          .replace("__GOAL__", task["goal"])
+                          .replace("__CONTEXT__", task.get("context") or "（无）"))
             note = route.get("implementer", "")
             images = _task_images(task, workdir)
         else:
-            prompt = DIRECT_FOLLOWUP_PROMPT.replace("__GOAL__", task["goal"])
-            if not sid and last_text:
-                # 无会话续接能力的 CLI（如 dsh 一次性任务）：把上一轮输出尾部带进上下文
-                prompt += "\n\n## 上一轮输出（结尾）\n" + last_text[-3000:]
+            if bi is not None:
+                prompt = (BUILTIN_FOLLOWUP_PROMPT
+                          .replace("__GOAL__", task["goal"])
+                          .replace("__PREV__", (last_text or "（无）")[-3000:]))
+            else:
+                prompt = DIRECT_FOLLOWUP_PROMPT.replace("__GOAL__", task["goal"])
+                if not sid and last_text:
+                    # 无会话续接能力的 CLI（如 dsh 一次性任务）：把上一轮输出尾部带进上下文
+                    prompt += "\n\n## 上一轮输出（结尾）\n" + last_text[-3000:]
             note = "对话续轮"
             images = None
         # 续轮判据：只有「本步执行期间新到」的消息才再开一轮。
-        # 不能只看「信箱非空」——真实步骤的 drain 在 _run_step 内部发生，起跑前
-        # 就积压的消息会被本步吃掉（peek 归零）；而 mock/不走 drain 的路径消息
-        # 永远不消费，只看非空会空转到轮数上限。比较步骤前后的未消费数即可区分。
+        # 不能只看「信箱非空」——真实步骤的 drain 在 _run_step/_run_builtin_step
+        # 内部发生，起跑前就积压的消息会被本步吃掉（peek 归零）；而 mock/不走
+        # drain 的路径消息永远不消费，只看非空会空转到轮数上限。
+        # 比较步骤前后的未消费数即可区分。
         before_n = len(_pending_messages(run_id))
-        res = _run_step(run_id, "direct" if first else "chat", impl, prompt, step_wd,
-                        readonly=False, ev=ev, note=note,
-                        resume=sid or None, images=images)
+        if bi is not None:
+            res = _run_builtin_step(run_id, "direct" if first else "chat", bi, prompt,
+                                    step_wd, ev=ev, note=note)
+        else:
+            res = _run_step(run_id, "direct" if first else "chat", impl, prompt, step_wd,
+                            readonly=False, ev=ev, note=note,
+                            resume=sid or None, images=images)
         if not res["ok"]:
             store.update_run(run_id, status="failed",
                              error="执行失败: %s" % res.get("error"), ended_at=_now())
             return
         turns += 1
         last_text = (res.get("text") or "").strip()
-        new_sid = _resume_sid(impl, res.get("sid"))
-        if new_sid:
-            sid = new_sid
+        if impl is not None:
+            new_sid = _resume_sid(impl, res.get("sid"))
+            if new_sid:
+                sid = new_sid
         try:
-            store.update_run(run_id, direct_session={"agent": impl["id"], "session": sid,
-                                                     "workdir": step_wd})
+            store.update_run(run_id, direct_session={
+                "agent": "builtin" if bi is not None else impl["id"],
+                "session": sid, "workdir": step_wd})
         except Exception:
             pass
         if turns >= DIRECT_MAX_TURNS:
@@ -974,9 +1074,12 @@ def _run_direct(run, task, agents, ev, stats, mode):
         first = False
 
     verdict = {"type": task["type"], "engine": "direct", "pass": True, "mode": mode,
-               "direct": True, "turns": turns, "impl": impl["id"], "route": route}
+               "direct": True, "turns": turns,
+               "impl": "builtin" if bi is not None else impl["id"], "route": route}
+    impl_label = ("内置智能体（%s · %s）" % (bi["provider_name"], bi["model"])
+                  if bi is not None else impl.get("label"))
     report = ["# 直连任务：%s" % task["title"], "",
-              "- 执行者：%s（%d 轮对话）" % (impl.get("label"), turns), ""]
+              "- 执行者：%s（%d 轮对话）" % (impl_label, turns), ""]
     if last_text:
         report += ["## 最近一轮输出", "", last_text[-5000:], ""]
     store.write_report(run_id, "\n".join(report))

package/app/main.py

@@ -1142,14 +1142,13 @@ class Handler(BaseHTTPRequestHandler):
                 "id": m.get("id"),
             })
         for s in (run.get("steps") or []):
-            # 正文优先取步骤记录里的 output（runner 抽好的最终回答，干净）；
-            # 老 run 没有该字段时退回日志——日志是全量事件流（含【思考】【命令】），
-            # 塞进对话气泡就成了「看日志」，只作兜底。
+            # 正文只认 output（runner 抽好的最终回答）→ summary。绝不回退读原始
+            # 日志：日志是全量事件流（下发提示词回显 + CLI 报错），塞进气泡就成了
+            # 「看日志」（2026-09-17 实测症状）；运行中的步骤两者都还没有，留空给
+            # 前端显示「正在执行」占位。
             body = s.get("output") or ""
             if not body:
                 body = s.get("summary") or ""
-            if not body and s.get("log"):
-                body = store.read_step_log(run_id, s["log"], tail=8000, pretty=True)
             items.append({
                 "kind": "agent",
                 "at": s.get("ended_at") or s.get("started_at") or "",
@@ -1343,6 +1342,13 @@ def main():
 
     # 启动每步都落一行进度（flush 强制落屏）：冷启动在慢盘/杀软扫描下可能几十秒，
     # 不打印会让用户以为卡死（真实案例：npm 装完首启只看到横幅像挂了）。
+    # 看门狗：任何阶段卡超过 20 秒，自动把所有线程堆栈打到控制台（每 20s 重复）——
+    # 用户截图即可精确定位卡点，不用猜。
+    try:
+        import faulthandler
+        faulthandler.dump_traceback_later(20, repeat=True, file=sys.stderr)
+    except Exception:
+        pass
     _t0 = time.time()
 
     def _step(msg):
@@ -1431,6 +1437,11 @@ def main():
     print("[CodeBee] 本机     http://127.0.0.1:%d" % args.port, flush=True)
     print("[CodeBee] 数据目录 %s" % paths.DATA_DIR, flush=True)
     print("[CodeBee] ✔ 已就绪，浏览器即将自动打开；不要关闭本窗口。", flush=True)
+    try:
+        import faulthandler
+        faulthandler.cancel_dump_traceback_later()  # 启动完成，看门狗退役（否则运行期每 20s 误报堆栈）
+    except Exception:
+        pass
     if remote.PUBLIC_URL:
         print("[CodeBee] 公网     %s/?token=%s   ← 任何网络可访问（反代回源已强制校验令牌）"
               % (remote.PUBLIC_URL, tok))

package/app/ui/app.js

@@ -5029,11 +5029,13 @@ async function renderChat(run, active) {
     }
     // 协议尾行是给编排器判收的机器标记，不该出现在聊天正文里（真源在提示词约定）
     const body = String(it.text || "").replace(/\n*DIRECT_DONE:.*\s*$/s, "").trim();
+    // 运行中的步骤还没有正文（output/summary 都空）：给占位，不渲染空气泡
+    const shown = body || (it.status === "running" ? t("正在执行…") : t("（本轮无文本输出）"));
     // 智能体回复：头像 + 整幅正文（不套气泡框），元信息小字落在正文下方
     return '<div class="chat-row">' +
       '<span class="chat-avatar" aria-hidden="true"><svg class="ico"><use href="#i-bee"></use></svg></span>' +
       '<div class="chat-bubble agent">' +
-      '<pre class="chat-body">' + esc(body) + "</pre>" +
+      '<pre class="chat-body">' + esc(shown) + "</pre>" +
       '<div class="chat-meta">' + esc(it.who || "") + " " + esc(it.at || "") +
       (it.note ? " · " + esc(it.note) : "") +
       (it.status && it.status !== "done" ? " · " + esc(it.status) : "") + "</div></div></div>";

package/app/ui/i18n.js

@@ -263,6 +263,8 @@
     "操作失败：": "Operation failed: ",
     "暂停": "Pause",
     "继续执行": "Resume",
+    "正在执行…": "Working…",
+    "（本轮无文本输出）": "(no text output this turn)",
     "也可直接粘贴截图": "or paste a screenshot directly",
     "添加附件": "Add attachment",
     "添加附件：截图/文本/代码/PDF 等，创建任务时落盘到工作目录 _attachments/": "Add attachments — screenshots/text/code/PDF; saved to the task workdir under _attachments/ on creation",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebee",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "CodeBee · 多智能体编排台 — 统一编排本机 AI 编码 CLI（Codex / Claude Code / QwenCode / OpenCode / Aider…）：目标→拆解→路由→执行→验证→跨厂商评审→修复→报告。纯 Python 标准库实现，本地 Web UI。",
   "license": "MIT",
   "bin": {