codebee 0.1.49 → 0.1.51

package/app/core/settings.py

@@ -25,13 +25,18 @@ DEFAULTS = {"max_concurrent_jobs": 12, "default_workdir": "", "hooks_token": "",
             "telemetry_errors": True, "publish_daily_cap": 10,
             "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": "",
             "pet_enabled": True, "pet_mode": "always", "pet_skin": "plush",
-            "cleanup_enabled": True, "cleanup_retention_days": 14}
+            "cleanup_enabled": True, "cleanup_retention_days": 14,
+            # claude_config_sync：打开/运行前防线是否直写 ~/.claude/settings.json。
+            # 关闭后交互 claude 配置归用户手动管理（cc-switch 等），编排步骤经
+            # runner 一次性 --settings 注入绑定链，路由不受影响（manager 读取）
+            "claude_config_sync": True}
 # 桌宠形象白名单（与 app/pet.py 的 SKINS 对齐；这里不 import pet 模块，避免
 # core 反向依赖 app 根目录脚本）
 PET_SKINS = ("plush", "robot")
-# 并发保护上限 12：任务有空位即直接启动，满载明确返回忙，不进入等待队列；
-# 同任务单飞守卫在 jobs 层。默认取上限，对齐「默认不排队」的使用预期。
-MIN_WORKERS, MAX_WORKERS = 1, 12
+# 并发保护上限 24：编排任务有空位即直接启动，满载回滚 queued 排队自动补跑，
+# 不秒判失败；同任务单飞守卫在 jobs 层。该上限保护的是本机资源（CLI 子进程
+# 数），与各 API 厂商的限流无关；direct 对话走 jobs 轻量池不占此额度。
+MIN_WORKERS, MAX_WORKERS = 1, 24
 
 
 def builtin_workdir():
@@ -127,6 +132,8 @@ def save(patch):
             cur["pet_skin"] = ps
         if "cleanup_enabled" in patch:
             cur["cleanup_enabled"] = bool(patch.get("cleanup_enabled"))
+        if "claude_config_sync" in patch:
+            cur["claude_config_sync"] = bool(patch.get("claude_config_sync"))
         if "cleanup_retention_days" in patch:
             try:
                 cur["cleanup_retention_days"] = int(patch.get("cleanup_retention_days"))

package/app/core/skills.py

@@ -300,11 +300,26 @@ def list_lessons(scope=None, only_enabled=False, category=None):
     return items
 
 
+def _title_containment(a, b):
+    """标题近似度：字符 bigram 包含度（交集/较短者）。与 knowledge._title_sim
+    同款度量（追加后缀形态 Jaccard 漏、包含度=1.0），教训/知识去重口径一致。"""
+    ga, gb = _text_bigrams(a), _text_bigrams(b)
+    if not ga or not gb:
+        return 0.0
+    return len(ga & gb) / float(min(len(ga), len(gb)))
+
+
+_LESSON_NEAR_DUP = 0.8   # 同 scope 教训标题包含度 ≥0.8 视为同一条（近似题合并）
+
+
 def upsert_lesson(scope, title, content, source="", category=None, dim=None):
     """写入/合并一条教训：同 scope 同标题视为同一条（seen+1，内容取新的）。
 
     category 为闭集枚举之一（见 LESSON_CATEGORIES）；输入非法时退到 dim 关键词映射，
     仍归不出则落「未分类」。id 仍只按 scope+标题哈希，故老教训再沉淀会合并而非分裂。
+    近似题合并（与知识库同款防膨胀）：自动复盘每次 done 运行都跑，「节奏拖沓」与
+    「节奏拖沓问题」会各占一条；同 scope 标题包含度 ≥0.8 也视为同一条，合并语义
+    与精确同题一致。<4 字符短题只认精确（bigram 噪声大）。
     """
     title = str(title or "").strip()[:60]
     content = str(content or "").strip()[:1200]
@@ -315,18 +330,27 @@ def upsert_lesson(scope, title, content, source="", category=None, dim=None):
     with _LOCK:
         data = _load()
         items = data.setdefault("lessons", [])
-        for it in items:
-            if it.get("id") == lid:
-                it["content"] = content
-                it["seen"] = int(it.get("seen") or 1) + 1
-                it["updated_at"] = _now()
-                # 合并时不降级已有分类：除非本次归到了明确类别，或该条原本没有分类
-                if cat != LESSON_UNCATEGORIZED or not it.get("category"):
-                    it["category"] = cat
-                if source:
-                    it["source"] = source
-                _save(data)
-                return it
+        hit = next((x for x in items if x.get("id") == lid), None)
+        if hit is None and len(title) >= 4:
+            for x in items:
+                if x.get("scope") != scope:
+                    continue
+                xt = str(x.get("title") or "")
+                if len(xt) >= 4 and _title_containment(title, xt) >= _LESSON_NEAR_DUP:
+                    hit = x
+                    break
+        if hit is not None:
+            it = hit
+            it["content"] = content
+            it["seen"] = int(it.get("seen") or 1) + 1
+            it["updated_at"] = _now()
+            # 合并时不降级已有分类：除非本次归到了明确类别，或该条原本没有分类
+            if cat != LESSON_UNCATEGORIZED or not it.get("category"):
+                it["category"] = cat
+            if source:
+                it["source"] = source
+            _save(data)
+            return it
         it = {"id": lid, "scope": scope, "title": title, "content": content,
               "source": source, "hits": 0, "seen": 1, "enabled": True,
               "category": cat,

package/app/core/store.py

@@ -24,6 +24,12 @@ LOCK = threading.RLock()
 _TASKS = {}
 _RUNS = {}
 
+# 流式实时落盘的节流表：(run_id, 步骤号) -> 上次落盘时刻。步骤收尾即清，
+# 长跑也不会无限增长（finish_step 里调 clear_stream_state）。
+_STREAM_LOCK = threading.Lock()
+_STREAM_TS = {}
+LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
+
 # ---------------------------------------------------------------- 状态版本（SSE 事件驱动）
 # 任何落盘写都算状态变化：SSE 连接等版本号变化才构建/推送全量状态，
 # 空闲时连接零开销（此前每连接每 0.8s 盲构建全量 payload，多端并发会放大成假死）
@@ -547,6 +553,9 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
             _RUNS.pop(run["id"], None)
             raise
         _RUNS[run["id"]] = run
+    # 新 run（排队/起跑）必须唤醒 SSE：否则侧栏 task_latest 感知不到
+    # 「最新一次运行」已易主，字形/时间停在上一轮（2026-09-22 侧栏假在跑案）
+    bump_state()
     return run
 
 
@@ -737,7 +746,13 @@ def update_run(run_id, expected_status=None, **fields):
                                     "error": str(run.get("error") or "")[:300]}}).start()
             except Exception:
                 pass
-        return run
+    # 每次成功写入都唤醒 SSE：run 的状态/步骤变化从前只能靠无关操作
+    # （自动化落盘、删记录）顺带广播，空闲时侧栏 task_latest 会冻在
+    # 「在跑」直到下一次无关 bump（2026-09-22 侧栏假在跑案）。
+    # 调用都是步骤级边界，不会形成推送风暴；CAS 拒绝/无此 run 的早退
+    # 路径不动版本号。
+    bump_state()
+    return run
 
 
 def run_dir(run_id):
@@ -1524,9 +1539,58 @@ def add_step(run_id, role, agent_id, agent_label, note=""):
         return step, log_abs
 
 
+def stream_step(run_id, n, thinking=None, text=None, activity=None, min_secs=0.6):
+    """步骤运行中实时落一段「思考过程/正文/活动」——对话时间线边跑边打印。
+
+    直连对话此前整轮只有三点打字动画（32 秒黑箱，用户 2026-09-22 反馈）；
+    模型的思维链与正文在流式回调里到达，这里节流落盘（默认 0.6s 一次），
+    前端 2s 轮询一次读到的就是「它正在想什么」。
+
+    节流按步骤记忆上次落盘时刻；收尾时 finish_step 会写入最终值并清掉
+    live 标记。返回是否真的落盘（调用方可据此决定要不要做下一步）。
+    """
+    key = (run_id, int(n))
+    now = time.time()
+    with _STREAM_LOCK:
+        last = _STREAM_TS.get(key, 0)
+        if min_secs and now - last < min_secs:
+            return False
+        _STREAM_TS[key] = now
+    with LOCK:
+        run = _RUNS.get(run_id)
+        if not run:
+            return False
+        for s in run["steps"]:
+            if s["n"] != n:
+                continue
+            if thinking is not None:
+                s["thinking"] = str(thinking)[-LIVE_TEXT_MAX:]
+            if text is not None:
+                s["stream"] = str(text)[-LIVE_TEXT_MAX:]
+            if activity:
+                acts = list(s.get("activity") or [])
+                if not acts or acts[-1] != activity:
+                    acts.append(str(activity)[:200])
+                s["activity"] = acts[-8:]
+            s["live"] = int(s.get("live") or 0) + 1   # 前端重绘签名（内容变即刷新）
+            _save_json(paths.RUNS_DIR / run_id / "run.json", run)
+            return True
+    return False
+
+
+def clear_stream_state(run_id=None, n=None):
+    """清掉流式节流状态（步骤收尾/测试收场用），避免字典随长跑无限增长。"""
+    with _STREAM_LOCK:
+        if run_id is None:
+            _STREAM_TS.clear()
+            return
+        for key in [k for k in _STREAM_TS if k[0] == run_id and (n is None or k[1] == n)]:
+            _STREAM_TS.pop(key, None)
+
+
 def finish_step(run_id, n, status, summary="", exit_code=None,
                 cost_usd=0.0, tokens=0.0, duration_s=None, model=None, output=None,
-                followups=None):
+                followups=None, thinking=None):
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
@@ -1549,12 +1613,20 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                     # output 是智能体正文（对话气泡直读）：只剥 ANSI，不做噪声折叠
                     # ——正文里的装饰性长串是作者写的，不能替它省略
                     s["output"] = runner.strip_ansi(str(output))[:6000]
+                if thinking is not None:
+                    s["thinking"] = runner.strip_ansi(str(thinking))[:LIVE_TEXT_MAX]
                 if followups:
                     s["followups"] = list(followups)[:3]
+                # 收尾即清运行中态：stream/activity/live 只是过程快照，留着会让
+                # 前端把「已结束」的步骤仍当实时流渲染（也白占 run.json 体积）
+                s.pop("stream", None)
+                s.pop("activity", None)
+                s.pop("live", None)
                 break
         run["cost_usd"] = round(run.get("cost_usd", 0.0) + cost_usd, 4)
         run["tokens"] = run.get("tokens", 0) + tokens
         _save_json(paths.RUNS_DIR / run_id / "run.json", run)
+    clear_stream_state(run_id, n)
 
 
 # ---------------------------------------------------------------- 运行中指挥（消息信箱）

package/app/core/zentao.py

@@ -4,7 +4,7 @@
 数据落盘 <data>/zentao.json（tmp + os.replace 原子写；TUTTI_DATA 环境变量感知）。
 修复走与 /api/tasks 完全相同的链路（store.create_task → store.create_run →
 jobs.enqueue，code 引擎=实现→验证→评审→修复），不自造运行器。调度挂在
-automation._tick（同 publish/auto.fire_due 模式），内部按 interval_hours 节流。
+automation._tick（同 publish/auto.fire_due 模式），内部按 interval_minutes 节流。
 
 禅道 REST API v1（开源版 15.x+；请求头 Token: <token>）：
   POST {base}/api.php/v1/tokens               {account, password} → {token}
@@ -34,6 +34,12 @@ backend | frontend | both | not_ours | unknown。
   unknown       → 不碰 bug，need_manual + 群通知（下轮扫描 bug 仍激活则重排查）
   修复任务失败  → 评论尝试记录 + 转派该端负责人（模块路由 account > 端负责人）
 
+落库纪律：修复任务落单即带基线（档案配了用档案，没配取工作目录当前 HEAD）
+走任务分支隔离，修完的代码自动提交在任务分支上，对账合并后才算落库；
+resolve 前再验一遍——没基线的任务改动只在工作区，有未提交的已跟踪改动
+不 resolve（转 done_manual 人工收口），auto_merge 关闭同理。
+对账（_reconcile）认任务最新一次运行：人工重试换 run 不影响回写判断。
+
 出网边界（SSRF 防护，_guard_url）：请求目标来自用户自配禅道地址——内网按设计
 放行；强制 http(s)、解析主机并阻断云元数据/链路本地地址、禁跟随重定向。
 """
@@ -69,6 +75,7 @@ _STATE = {
     "last_error": "",
 }
 _LOADED = False
+_BOOT_TIMER = None     # 启动补对账的兜底 Timer（测试里要能拿到并取消）
 
 TOKEN_TTL = 23 * 3600
 HTTP_TIMEOUT = 15
@@ -76,7 +83,9 @@ PAGE_LIMIT = 100
 MAX_BUGS = 500
 RESOLVE_MAX_ATTEMPTS = 3
 RETRY_DELAY_MIN = 30
-INTERVAL_MIN, INTERVAL_MAX = 1, 168
+INTERVAL_MIN, INTERVAL_MAX = 5, 10080   # 扫描间隔（分钟）：5 分钟 ~ 7 天
+INTERVAL_DEFAULT = 5
+_LEGACY_INTERVAL_HOURS_DEFAULT = 2      # 老配置 interval_hours 缺省值（迁移用）
 
 SIDES = ("backend", "frontend")
 TRIAGE_SIDES = ("backend", "frontend", "both", "not_ours")   # unknown 单列
@@ -91,7 +100,7 @@ _CFG_DEFAULTS = {
     "auto_merge": True,
     "triage_ai": True,         # 模块路由未命中时用 AI 兜底排查
     "poll_enabled": False,
-    "interval_hours": 2,
+    "interval_minutes": INTERVAL_DEFAULT,
 }
 
 _REPO_DEFAULTS = {"workdir": "", "git_rev": "", "verify_command": ""}
@@ -109,7 +118,7 @@ _PROFILE_DEFAULTS = {
 
 _UPDATABLE = ("base_url", "account", "password", "product_profiles",
               "auto_resolve", "auto_merge", "triage_ai",
-              "poll_enabled", "interval_hours")
+              "poll_enabled", "interval_minutes")
 
 
 # ---------------------------------------------------------------- 出网边界（SSRF）
@@ -232,6 +241,17 @@ def load(force=False):
         # 必须在按 _CFG_DEFAULTS 过滤之前完成迁移）
         if isinstance(cfg, dict) and not cfg.get("product_profiles"):
             cfg = _migrate_legacy(dict(cfg))
+        # 老配置用 interval_hours（小时），新配置改用 interval_minutes（分钟）：
+        # 用户没动过间隔（还是老默认 2 小时）就跟随新默认 5 分钟；真改过的按小时换算保留。
+        if isinstance(cfg, dict) and "interval_minutes" not in cfg \
+                and "interval_hours" in cfg:
+            try:
+                hours = int(cfg.get("interval_hours") or _LEGACY_INTERVAL_HOURS_DEFAULT)
+            except (TypeError, ValueError):
+                hours = _LEGACY_INTERVAL_HOURS_DEFAULT
+            cfg = dict(cfg)
+            mins = INTERVAL_DEFAULT if hours == _LEGACY_INTERVAL_HOURS_DEFAULT else hours * 60
+            cfg["interval_minutes"] = max(INTERVAL_MIN, min(INTERVAL_MAX, mins))
         merged = dict(_CFG_DEFAULTS)
         if isinstance(cfg, dict):
             merged.update({k: v for k, v in cfg.items() if k in _CFG_DEFAULTS})
@@ -623,7 +643,8 @@ def _pairs_to_list(pairs, id_key, name_key):
 def _module_items(d):
     """老版模块树形状兼容（2026-09-21 真机反馈「响应形状不认识」）：
     sons/modules 数组、{id: {name,...}} 字典、children/sons 嵌套树，统一
-    递归展开成 [{id,name}] 平铺清单（id=0 是树根容器，跳过）。"""
+    递归展开成 [{id,name}] 平铺清单（id=0 是树根容器，跳过）；全数字键的
+    {id: 名字} 扁平映射也认（部分版本的模块摘要形状）。"""
     out = []
 
     def walk(node):
@@ -637,11 +658,19 @@ def _module_items(d):
                     if isinstance(node.get(k), (list, dict)):
                         walk(node[k])
             else:
+                if node and all(str(k).isdigit() for k in node.keys()):
+                    flat = [{"id": k, "name": str(v)}
+                            for k, v in node.items() if str(v or "").strip()]
+                    if flat:
+                        out.extend(flat)
+                        return
                 for v in node.values():
                     walk(v)
 
     if isinstance(d, dict):
-        walk(d.get("sons") or d.get("modules") or d.get("tree") or d)
+        # tree 优先：真机 tree=带 children 的完整嵌套树，sons 只有顶层扁平表
+        # （走 sons 会漏子模块）
+        walk(d.get("tree") or d.get("sons") or d.get("modules") or d)
     elif isinstance(d, list):
         walk(d)
     return out
@@ -724,8 +753,27 @@ def _old_route(api, method, p, q, body):
 
     m = re.match(r"^/products/(\d+)/modules$", p)
     if m and method == "GET":
-        d = go(get("/tree-browse-%s-module.json" % m.group(1)), "（拉模块清单）")
-        return {"_list": [x for x in _module_items(d) if isinstance(x, dict) and x.get("id")]}
+        # 2026-09-22 真机实探：该版模块行 type=story，viewType=module 查出空树
+        # （status 仍 success）——「响应形状不认识」的真根因。改按 bug 视图拉
+        # （bug 表单模块下拉用的就是这棵树），story/case 兜底。
+        pid = m.group(1)
+        last, saw_js = None, False
+        for vt in ("bug", "story", "case"):
+            d = go(get("/tree-browse-%s-%s.json" % (pid, vt)), "（拉模块清单）")
+            last = d
+            if isinstance(d, dict) and d.get("_js"):
+                saw_js = True            # 接口回了页面脚本：换视图再试
+                continue
+            items = [x for x in _module_items(d) if isinstance(x, dict) and x.get("id")]
+            if items:
+                return {"_list": items}
+        if saw_js:
+            raise ZenError("禅道老接口（拉模块清单）：回了页面脚本而不是数据"
+                           "（模块树接口不在或被重定向）——请在禅道产品视图 URL 里查模块 ID 手工填写")
+        keys = ",".join(sorted(str(k) for k in last.keys())) \
+            if isinstance(last, dict) else type(last).__name__
+        raise ZenError("该产品模块树为空（bug/story/case 三个视图都没拉到模块，"
+                       "响应顶层键：%s）——请到禅道确认产品下建过模块，或手工填模块 ID" % keys)
 
     if p == "/products" and method == "GET":
         d = go(get("/api-getmodel-product-getpairs.json"), "（拉产品清单）")
@@ -847,8 +895,12 @@ def fetch_modules(product_id):
     try:
         d = _call("GET", "/products/%s/modules" % product_id, cfg=cfg)
     except ZenError as e:
-        return {"ok": False,
-                "error": "%s——也可能你的禅道没有该接口：请在禅道产品视图 URL 里查模块 ID 手工填写" % e}
+        msg = str(e)
+        # 只有「接口不存在」类错误才补「没有该接口」提示；老通道自己报的
+        # 空树/脚本回包已带人话结论，别再叠一层误导
+        if "404" in msg or "不认识" in msg:
+            msg += "——也可能你的禅道没有该接口：请在禅道产品视图 URL 里查模块 ID 手工填写"
+        return {"ok": False, "error": msg}
     # 形状兼容器（{_list} / {modules:[...]} / {id:{...}} 字典 / 裸数组）
     items = _list_items(d, "modules")
     if items is None:
@@ -858,6 +910,11 @@ def fetch_modules(product_id):
         if isinstance(m, dict) and m.get("id"):
             out.append({"id": m.get("id"), "name": str(m.get("name") or "")})
     if not out:
+        if isinstance(d, dict) and set(d.keys()) == {"_list"}:
+            # 自家归一包装（裸数组进 _api/_old_route 时打的包）：空清单=
+            # 产品真没模块，不是形状问题，别拿顶层键吓人
+            return {"ok": False,
+                    "error": "禅道回了空模块清单（该产品可能没建模块）——请手工填模块 ID"}
         # 带响应形状摘要帮排查（顶层键名，不吐正文——用户实测反馈
         # 「响应形状不认识」却看不到真实形状，没法报修）
         keys = ",".join(sorted(str(k) for k in d.keys())) if isinstance(d, dict) else type(d).__name__
@@ -1114,8 +1171,14 @@ def _launch_fix(bug, profile, side, cfg):
     title = ("[禅道#%s][%s] %s" % (bid, SIDE_CN.get(side, side),
                                    str(bug.get("title") or "").strip())).strip()[:60]
     payload = {"type": "code", "title": title, "goal": _goal_text(bug, side), "workdir": wd}
-    if str(repo.get("git_rev") or "").strip():
-        payload["git_rev"] = str(repo["git_rev"]).strip()
+    base = str(repo.get("git_rev") or "").strip()
+    if not base:
+        # 档案没配基线就取落单时点的 HEAD：让修复走任务分支隔离——修完自动
+        # 提交在任务分支上，对账合并才真正落库，resolve 才站得住（#27697 案：
+        # 无基线任务修完只躺在工作区，闭环永远不会替你提交）。
+        base = _head_rev(wd)
+    if base:
+        payload["git_rev"] = base
     if str(repo.get("verify_command") or "").strip():
         payload["verify_command"] = str(repo["verify_command"]).strip()
     task = None
@@ -1280,6 +1343,42 @@ def _merge_branch(workdir, task):
         return False, "合并异常：%s" % e, None
 
 
+def _head_rev(workdir):
+    """工作目录当前 HEAD 短哈希（作任务隔离基线）。非仓库/拿不到返回空串。"""
+    try:
+        from . import gitmod, runner
+        r = runner.run_process(
+            argv=["git", "-C", str(workdir), "rev-parse", "--short", "HEAD"], timeout=20)
+        if r.get("ok"):
+            rev = (r.get("stdout") or "").strip()
+            if rev and gitmod.valid_rev(rev):
+                return rev
+    except Exception:
+        log.debug("zentao: 读取 HEAD 失败", exc_info=True)
+    return ""
+
+
+def _uncommitted(workdir):
+    """工作目录里有没有未提交的已跟踪改动（untracked 不算——CLI 噪音文件太多）。
+
+    返回 (是否脏, 人话明细)。目录不是 git 仓库视为不脏（无提交语义，放行）。
+    """
+    try:
+        from . import runner
+        if not workdir:
+            return False, ""
+        r = runner.run_process(
+            argv=["git", "-C", str(workdir), "status", "--porcelain", "-uno", "--", "."],
+            timeout=20)
+        if r.get("ok"):
+            dirty = [ln.strip() for ln in (r.get("stdout") or "").splitlines() if ln.strip()]
+            if dirty:
+                return True, "未提交改动 %d 处（如 %s）" % (len(dirty), dirty[0][:80])
+    except Exception:
+        log.debug("zentao: 工作区状态检查失败", exc_info=True)
+    return False, ""
+
+
 def _set_claim(bid, **patch):
     with _LOCK:
         c = _STATE["claims"].get(str(bid))
@@ -1307,20 +1406,38 @@ def _finish_ok(claim, cfg):
     tasks = claim.get("tasks") or []
     runs = {t.get("run_id"): store.get_run(t.get("run_id") or "") for t in tasks}
     # 1) 逐任务合并（任一失败即停：不转派不 resolve，绝不带着没落库的修复转派）
-    if cfg.get("auto_merge"):
-        for t in tasks:
-            task = store.get_task(t.get("task_id") or "")
-            if task is None or not task.get("git_rev"):
-                continue
-            ok, err, _info = _merge_branch(str(_repo_of(profile, t.get("side")).get("workdir")
-                                               or settings.default_workdir()), task)
-            if not ok:
-                _set_claim(bid, state="merge_failed",
-                           note="【%s】任务分支合并失败：%s（不转派不 resolve，留人工）"
-                                % (SIDE_CN.get(t.get("side"), t.get("side")), err))
-                _notify("🐛❌ 禅道 Bug #%s 的%s修复代码合并失败：%s\n修复任务：%s"
-                        % (bid, SIDE_CN.get(t.get("side"), ""), err, t.get("task_id") or "?"))
-                return
+    if not cfg.get("auto_merge"):
+        _set_claim(bid, state="done_manual",
+                   note="修复完成；auto_merge 已关，请人工合并落库后到禅道解决 bug")
+        return
+    for t in tasks:
+        task = store.get_task(t.get("task_id") or "")
+        if task is None or not task.get("git_rev"):
+            continue
+        ok, err, _info = _merge_branch(str(_repo_of(profile, t.get("side")).get("workdir")
+                                           or settings.default_workdir()), task)
+        if not ok:
+            _set_claim(bid, state="merge_failed",
+                       note="【%s】任务分支合并失败：%s（不转派不 resolve，留人工）"
+                            % (SIDE_CN.get(t.get("side"), t.get("side")), err))
+            _notify("🐛❌ 禅道 Bug #%s 的%s修复代码合并失败：%s\n修复任务：%s"
+                    % (bid, SIDE_CN.get(t.get("side"), ""), err, t.get("task_id") or "?"))
+            return
+    # 1.5) 落库闸：没基线的任务不走任务分支隔离，改动只躺在工作区——带着
+    # 未提交的已跟踪改动点 resolve 是对禅道撒谎（#27697 案），拦下转人工。
+    for t in tasks:
+        task = store.get_task(t.get("task_id") or "")
+        if task is None or task.get("git_rev"):
+            continue
+        dirty, detail = _uncommitted(str(_repo_of(profile, t.get("side")).get("workdir")
+                                         or settings.default_workdir()))
+        if dirty:
+            _set_claim(bid, state="done_manual",
+                       note="修复完成但工作区有未提交改动（%s），已阻止自动 resolve"
+                            "——请人工提交后到禅道解决" % detail)
+            _notify("🐛⚠️ 禅道 Bug #%s 修复完成但未提交落库，已阻止自动 resolve\n%s"
+                    % (bid, claim.get("title") or ""))
+            return
     # 2) 需要转派的端 = 判定端 - 我方端（both 且我方只管一端时非空）
     verdict_sides = ([tri["side"]] if tri.get("side") in SIDES
                      else list(SIDES) if tri.get("side") == "both" else [])
@@ -1413,6 +1530,25 @@ def _finish_failed(claim, cfg):
                claim.get("title") or "", "、".join(t.get("task_id") or "" for t in tasks)))
 
 
+def _refresh_claim_runs(claim):
+    """把 claim.tasks 的 run_id 对齐到各任务最新一次运行，返回 (tasks, 是否换绑)。
+
+    领单时钉住的 run 失败后，人工重试会换新 run——对账只认旧 run 会把已经
+    成功的修复判成失败（2026-09-22 #27697 误报失败评论案）。
+    """
+    fresh, changed = [], False
+    for t in claim.get("tasks") or []:
+        tid = str(t.get("task_id") or "")
+        if tid:
+            runs = store.task_runs(tid)
+            rid = str((runs[0].get("id") if runs else "") or "")
+            if rid and rid != t.get("run_id"):
+                t = dict(t, run_id=rid)
+                changed = True
+        fresh.append(t)
+    return fresh, changed
+
+
 def _reconcile(cfg):
     """对账：fixing 中的 claim 查各 run 终态并回写。单条异常只跳过该条。"""
     with _LOCK:
@@ -1420,7 +1556,10 @@ def _reconcile(cfg):
     for claim in fixing:
         bid = str(claim.get("bug_id"))
         try:
-            tasks = claim.get("tasks") or []
+            tasks, moved = _refresh_claim_runs(claim)
+            if moved:
+                _set_claim(bid, tasks=tasks)
+                claim = dict(claim, tasks=tasks)
             runs = {t.get("run_id"): store.get_run(t.get("run_id") or "") for t in tasks}
             if any(r is None for r in runs.values()):
                 _set_claim(bid, state="lost", note="运行记录不存在（可能被清理）")
@@ -1627,7 +1766,7 @@ def _poll(force=False):
         err = "扫描失败：%s" % e
         log.warning("zentao: %s", err)
     now = datetime.now()
-    delay = timedelta(hours=max(INTERVAL_MIN, int(cfg.get("interval_hours") or 2)))
+    delay = timedelta(minutes=max(INTERVAL_MIN, int(cfg.get("interval_minutes") or INTERVAL_DEFAULT)))
     if err:
         delay = timedelta(minutes=RETRY_DELAY_MIN)
     with _LOCK:
@@ -1654,14 +1793,34 @@ def scan_now():
     return _poll(force=True)
 
 
+def _boot_reconcile():
+    """服务重启后补一次对账：上个进程死亡窗口里的终态变化别等下个 tick
+    （#27697 案：服务死窗 7 小时，失败转派被拖到重启后才发现）。"""
+    try:
+        _ensure_loaded()
+        with _LOCK:
+            cfg = _cfg()
+        _reconcile(cfg)
+    except Exception:
+        log.exception("zentao: 启动补对账失败")
+
+
 def start():
     """服务启动接线：加载状态（含老配置迁移）。"""
+    global _BOOT_TIMER
     n = load()
     with _LOCK:
         cfg = _STATE.get("config") or {}
         if cfg.get("poll_enabled") and not _STATE.get("next_scan"):
             _STATE["next_scan"] = time.strftime("%Y-%m-%d %H:%M:%S")
             _save_locked()
+        pending = any(c.get("state") == "fixing" for c in _STATE["claims"].values())
+    if pending:
+        if _BOOT_TIMER is not None:
+            _BOOT_TIMER.cancel()
+        _BOOT_TIMER = threading.Timer(3.0, _boot_reconcile)
+        _BOOT_TIMER.daemon = True
+        _BOOT_TIMER.start()
     return n
 
 
@@ -1770,11 +1929,11 @@ def save_config(patch):
                 v = _norm_profiles(v)
                 if v is None:
                     continue
-            elif k == "interval_hours":
+            elif k == "interval_minutes":
                 try:
                     v = max(INTERVAL_MIN, min(INTERVAL_MAX, int(v)))
                 except (TypeError, ValueError):
-                    raise ValueError("interval_hours 必须是 %d-%d 的整数"
+                    raise ValueError("interval_minutes 必须是 %d-%d 的整数"
                                      % (INTERVAL_MIN, INTERVAL_MAX))
             elif k in ("auto_resolve", "auto_merge", "triage_ai", "poll_enabled"):
                 v = bool(v)