codebee 0.1.73 → 0.1.74

package/app/core/runner.py

@@ -12,6 +12,7 @@
 """
 from __future__ import annotations
 
+import glob
 import json
 import os
 import re
@@ -68,10 +69,50 @@ def find_git_bash():
     return None
 
 
+_CLI_EXTS = (".exe", ".cmd", ".bat")
+
+
+def _fallback_probe_cli(name):
+    """which() 落空时按常见安装位兜底找 CLI（Windows only），返回全路径或 None。
+
+    服务进程的 PATH 是启动那一刻的快照：CLI 在服务起跑之后才安装/迁移（如
+    2026-09-30 claude 转 winget 原生安装）时，快照里没有新目录，which 解析
+    不到、裸名直传 Popen 直接 FileNotFoundError，直到重启服务才自愈。这里
+    只探测磁盘已知落点，不改 PATH、不缓存（装没装是低频事件，探几次不亏）。
+    """
+    if os.name != "nt":
+        return None
+    name = str(name)
+    if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]*", name):
+        return None   # 带斜杠/参数形态的不是裸命令名，交给原路径逻辑
+    local = os.environ.get("LOCALAPPDATA") or ""
+    home = os.path.expanduser("~")
+    appdata = os.environ.get("APPDATA") or os.path.join(home, "AppData", "Roaming")
+    flat_dirs = (
+        os.path.join(local, "Microsoft", "WinGet", "Links"),
+        os.path.join(home, ".local", "bin"),
+        os.path.join(appdata, "npm"),
+    )
+    for d in flat_dirs:
+        for ext in _CLI_EXTS:
+            p = os.path.join(d, name + ext)
+            if os.path.isfile(p):
+                return p
+    # winget 便携包：Packages\<厂商.Id_*>\name.EXE（目录名带来源哈希，glob 一层）
+    pkgs = os.path.join(local, "Microsoft", "WinGet", "Packages")
+    try:
+        for p in glob.glob(os.path.join(pkgs, "*", name + ".*")):
+            if p.lower().endswith(_CLI_EXTS) and os.path.isfile(p):
+                return p
+    except OSError:
+        pass
+    return None
+
+
 def resolve_command(command):
     """命令名 → 可直接 spawn 的 argv 前缀（.cmd/.bat 垫片必须经 cmd /c）。"""
-    path = shutil.which(command) or command
-    low = path.lower()
+    path = shutil.which(command) or _fallback_probe_cli(command) or command
+    low = str(path).lower()
     if low.endswith(".cmd") or low.endswith(".bat"):
         return ["cmd", "/c", path]
     return [path]
@@ -719,6 +760,16 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 stdout=subprocess.PIPE, stderr=subprocess.PIPE,
                 creationflags=CREATE_NO_WINDOW,
                 start_new_session=(os.name != "nt"))  # POSIX 需独立进程组供 killpg 杀树；Windows 忽略该参数
+        except FileNotFoundError as e:
+            # filename=None 时 %r 只有一句「系统找不到指定的文件」，无从排查
+            # （2026-09-30 claude winget 迁移实案：服务 PATH 快照过旧）。
+            tgt = str(argv[0]) if argv else ""
+            return {"ok": False, "exit_code": None, "stdout": "",
+                    "stderr": ("启动失败：找不到可执行文件「%s」。CLI 未安装或已卸载；"
+                               "若刚安装，重启 CodeBee 服务让 PATH 生效即可。"
+                               % tgt),
+                    "duration": 0.0, "cancelled": False, "timed_out": False,
+                    "stalled": False, "deadline_exceeded": False, "abort_marker": None}
         except Exception as e:
             return {"ok": False, "exit_code": None, "stdout": "",
                     "stderr": "启动失败: %r" % e, "duration": 0.0,
@@ -1578,6 +1629,30 @@ def _invalid_model(model):
     return str(model or "").strip().lower() in _INVALID_MODEL_NAMES
 
 
+# opencode 启动横幅形如「> build · glm-5.3」（ANSI 清洗后一行、圆点分隔）；
+# 真错误（配额/配置/网络）CLI 都会另打印文本，不会是纯横幅形态
+_OC_BANNER_LINE_RE = re.compile(r"^\s*>?\s*[^\s·•]+\s*[·•]\s*\S+\s*$")
+
+
+def _opencode_fast_banner_death(res):
+    """opencode 启动期秒退签名：退出码 1、总时长很短、输出清洗 ANSI 后只剩
+    启动横幅、没有任何错误文本。真实失败不走这个形态；该形态只值得原地
+    立即重试一次（配置写读竞态/端口抢占类瞬时抖动，2026-09-30 实案：
+    并行评审爆发期连续三发「退出码 1；stderr/stdout: > build · glm-5.3」，
+    数分钟后同进程自愈）。"""
+    if res.get("ok") or res.get("exit_code") != 1:
+        return False
+    try:
+        if float(res.get("duration") or 0) > 15.0:
+            return False
+    except (TypeError, ValueError):
+        return False
+    blob = clean_cli_text((res.get("stderr") or "") + "\n"
+                          + (res.get("stdout") or ""))
+    lines = [ln.strip() for ln in blob.splitlines() if ln.strip()]
+    return bool(lines) and all(_OC_BANNER_LINE_RE.match(ln) for ln in lines)
+
+
 def run_agent(agent, prompt, workdir=None, readonly=True,
               timeout=DEFAULT_TIMEOUT, cancel_event=None, log_path=None, resume=None,
               images=None, require_tools=False, deadline=None):
@@ -1801,6 +1876,14 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                    "provider_id": att.get("provider_id") or "",
                    "provider": att.get("provider") or {}}
             if not res["ok"]:
+                if (kind == "opencode" and attempt == 0
+                        and _opencode_fast_banner_death(res)
+                        and not (cancel_event is not None
+                                 and cancel_event.is_set())):
+                    _log_note(log_path,
+                              "opencode 启动即退（仅横幅无错误文本）——按瞬时抖动 2s 后原地重试一次")
+                    time.sleep(2.0)
+                    continue
                 # stderr 与 stdout 都要进错误串：codex 把 "Reading prompt from
                 # stdin..." 打在 stderr，真正的配额/限流错误全在 stdout 的 JSONL
                 # 里——只取其一会让 _quota_error/_transient_error 判空。

package/app/core/store.py

@@ -195,6 +195,18 @@ def create_task(payload):
     # 参数修订号（借鉴 WorkDSH 契约纪律 expectedRevision）：写接口据此做过期
     # 写入检测。老任务无此键按 1 处理；不带 expected_rev 的调用不受影响。
     task["rev"] = 1
+    # Durable task contract: acceptance criteria and approval requirement are
+    # persisted outside the task JSON so evidence/audit history survives task
+    # parameter edits and can be consumed by API/MCP clients independently.
+    raw_criteria = payload.get("acceptance_criteria")
+    if raw_criteria not in (None, "") and not isinstance(raw_criteria, list):
+        raise ValueError("acceptance_criteria 必须是列表")
+    task["acceptance_criteria"] = [str(x).strip()[:500] for x in
+                                    (raw_criteria or []) if str(x).strip()][:40]
+    approval_required = payload.get("approval_required", False)
+    if not isinstance(approval_required, bool):
+        raise ValueError("approval_required 必须是布尔值")
+    task["approval_required"] = approval_required
     if flow["engine"] == "direct":
         task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
                                             "direct_provider_id")[:80]
@@ -388,6 +400,24 @@ def create_task(payload):
     with LOCK:
         _TASKS[task["id"]] = task
         _save_json(paths.TASKS_DIR / (task["id"] + ".json"), task)
+    try:
+        from . import contracts
+        contracts.create(task["id"], {
+            "acceptance_criteria": task.get("acceptance_criteria"),
+            "approval_required": task.get("approval_required"),
+            "actor": "system",
+        })
+    except Exception:
+        # Contracts are an evidence enrichment layer; legacy task creation
+        # must remain available if a damaged optional contract file is found.
+        pass
+    if task.get("serial"):
+        try:
+            from . import story_tracking
+            story_tracking.init(task["workdir"], task["id"], task["title"],
+                                premise=task.get("context") or task.get("goal") or "")
+        except Exception:
+            pass
     return task
 
 
@@ -535,6 +565,30 @@ def serial_chain_ids(task_id):
     return order
 
 
+def chain_book_meta(task, platform):
+    """任务在某平台的作品信息「面板视图」：根优先返回首个有状态的条目。
+
+    与 inherited_book_meta 同为根优先，但不筛 done——生成可从链上任意任务
+    触发、落点在根任务，running/failed 也要沿链可见，否则续写批次触发生成
+    后面板永远空转。running/done 优先于 failed（旧失败不遮新结果）。"""
+    task = task or {}
+    platform = str(platform)
+    own = ((task.get("book_meta") or {}).get(platform)) or {}
+    first_failed = None
+    for tid in serial_chain_ids(task.get("id") or ""):
+        t = task if tid == str(task.get("id")) else get_task(tid)
+        if not t:
+            continue
+        e = ((t.get("book_meta") or {}).get(platform)) or {}
+        if not (isinstance(e, dict) and e.get("status")):
+            continue
+        if e.get("status") in ("running", "done"):
+            return e
+        if first_failed is None:
+            first_failed = e
+    return first_failed or own
+
+
 def inherited_book_meta(task, platform):
     """任务在某平台的作品信息：连载链上「生成完成」的条目整链共用（都是用第一个）。
 
@@ -1050,6 +1104,22 @@ def update_run(run_id, expected_status=None, **fields):
                 # Acceptance reporting is evidence enrichment; it must not
                 # prevent the primary run from reaching a terminal state.
                 pass
+            try:
+                from . import contracts
+                for case in (run.get("acceptance") or {}).get("cases") or []:
+                    contracts.add_evidence(
+                        run.get("task_id") or "",
+                        {"criterion": "acceptance:%s" % case.get("case"),
+                         "status": "passed" if case.get("status") == "passed" else case.get("status"),
+                         "summary": case.get("reason") or "acceptance matrix",
+                         "source": "acceptance"}, actor="system")
+                contracts.record_acceptance_cases(
+                    run.get("task_id") or "",
+                    (run.get("acceptance") or {}).get("cases") or [],
+                    actor="system")
+                contracts.complete(run.get("task_id") or "", run)
+            except Exception:
+                pass
         _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         if st in TERMINAL_STATUSES and prev_status not in TERMINAL_STATUSES:
             # 事后对账：只有「非终态 → 终态」这一次翻转才记账，重复写终态
@@ -1720,6 +1790,8 @@ def continue_task(task_id, chapters=None):
         "difficulty": task.get("difficulty") or "auto",
         "implementer": task.get("implementer") or "",
         "critics": task.get("critics") or [],
+        "acceptance_criteria": task.get("acceptance_criteria") or [],
+        "approval_required": bool(task.get("approval_required")),
         "manuscript": task.get("manuscript") or "manuscript.md",
         "threshold": task.get("threshold") or 7.0,
         "serial": {"chapters": batch,

package/app/core/story_tracking.py

@@ -0,0 +1,241 @@
+"""Structured, deterministic long-form fiction tracking.
+
+The JSON state is the source of truth. Markdown files under ``derived`` are
+regenerated from that state and are checked for drift before a run consumes
+them. This keeps long serial projects resumable without requiring a vector DB.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import time
+from pathlib import Path
+
+_MAX_CHAPTERS = 5000
+_STATE_REL = Path(".codebee") / "story_tracking.json"
+_DERIVED = Path(".codebee") / "derived"
+_CHAPTERS = Path(".codebee") / "chapters"
+
+
+def _now():
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def _root(workdir):
+    root = Path(workdir).expanduser().resolve()
+    if not root.is_dir():
+        raise ValueError("工作目录不存在")
+    return root
+
+
+def _state_path(root):
+    return root / _STATE_REL
+
+
+def _digest(text):
+    return hashlib.sha256(str(text).encode("utf-8")).hexdigest()
+
+
+def _empty(task_id, title, premise=""):
+    return {"version": 1, "task_id": str(task_id), "title": str(title or "")[:120],
+            "premise": str(premise or "")[:2000], "state_revision": 0,
+            "current_chapter": 0, "facts": [], "characters": [], "timeline": [],
+            "foreshadowing": [], "next_promises": [], "author_truth": [],
+            "reader_known": [], "chapters": [], "derived_digests": {},
+            "created_at": _now(), "updated_at": _now()}
+
+
+def _save(root, state):
+    path = _state_path(root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(state, ensure_ascii=False, indent=2), encoding="utf-8")
+    tmp.replace(path)
+
+
+def _load(root):
+    path = _state_path(root)
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except FileNotFoundError:
+        return None
+    except (OSError, ValueError) as exc:
+        raise ValueError("故事追踪状态不可读: %s" % exc)
+    if not isinstance(data, dict) or data.get("version") != 1:
+        raise ValueError("不支持的故事追踪状态版本")
+    for name in ("facts", "characters", "timeline", "foreshadowing",
+                 "next_promises", "author_truth", "reader_known", "chapters"):
+        if not isinstance(data.get(name), list):
+            raise ValueError("故事追踪状态字段 %s 必须是列表" % name)
+    if not isinstance(data.get("derived_digests"), dict):
+        raise ValueError("故事追踪状态字段 derived_digests 必须是对象")
+    if any(not isinstance(row, dict) for row in data.get("chapters") or []):
+        raise ValueError("故事追踪状态 chapters 含无效记录")
+    return data
+
+
+def init(workdir, task_id, title, premise=""):
+    root = _root(workdir)
+    state = _load(root)
+    if state is None:
+        state = _empty(task_id, title, premise)
+        _save(root, state)
+    _render(root, state)
+    return state
+
+
+def load(workdir):
+    return _load(_root(workdir))
+
+
+def _clean_lines(values, limit=100):
+    result = []
+    for value in values if isinstance(values, list) else []:
+        text = str(value or "").strip()[:1000]
+        if text and text not in result:
+            result.append(text)
+        if len(result) >= limit:
+            break
+    return result
+
+
+def _clean_foreshadowing(values):
+    result = []
+    for raw in values if isinstance(values, list) else []:
+        if not isinstance(raw, dict):
+            continue
+        item = {"id": str(raw.get("id") or "").strip()[:40],
+                "text": str(raw.get("text") or "").strip()[:1000],
+                "status": str(raw.get("status") or "active").strip()[:30],
+                "planted_chapter": raw.get("planted_chapter"),
+                "payoff_chapter": raw.get("payoff_chapter")}
+        if item["id"] and item["text"]:
+            result.append(item)
+    return result[-500:]
+
+
+def commit_chapter(workdir, chapter_no, outline, prose, *, facts=None, characters=None,
+                   timeline=None, foreshadowing=None, next_promises=None,
+                   author_truth=None, reader_known=None):
+    root = _root(workdir)
+    try:
+        number = int(chapter_no)
+    except (TypeError, ValueError):
+        raise ValueError("章节号无效")
+    if not 1 <= number <= _MAX_CHAPTERS:
+        raise ValueError("章节号必须在 1-%d 之间" % _MAX_CHAPTERS)
+    outline = str(outline or "").strip()
+    prose = str(prose or "").strip()
+    if not outline:
+        raise ValueError("提交章节前必须有细纲")
+    if not prose:
+        raise ValueError("正文不能为空")
+    state = _load(root)
+    if state is None:
+        state = _empty("", root.name)
+    # A shared workdir can be used by continuation tasks.  The structured
+    # tracking file is book-level state, so accepting a newer task id here
+    # would make the next run look like a foreign-state drift.  Keep the
+    # original owner and append chapters to the existing book timeline.
+    record = {"chapter": number, "outline": outline[:12000], "prose_digest": _digest(prose),
+              "word_count": len(prose), "committed_at": _now(),
+              "facts": _clean_lines(facts), "characters": _clean_lines(characters),
+              "timeline": _clean_lines(timeline), "foreshadowing": _clean_foreshadowing(foreshadowing),
+              "next_promises": _clean_lines(next_promises, 20),
+              "author_truth": _clean_lines(author_truth, 100), "reader_known": _clean_lines(reader_known, 100)}
+    existing = next((x for x in state["chapters"] if x.get("chapter") == number), None)
+    if existing and existing.get("prose_digest") == record["prose_digest"] and existing.get("outline") == outline:
+        return state
+    if existing:
+        state["chapters"] = [x for x in state["chapters"] if x.get("chapter") != number]
+    state["chapters"].append(record)
+    state["chapters"].sort(key=lambda x: int(x.get("chapter") or 0))
+    state["current_chapter"] = max(int(state.get("current_chapter") or 0), number)
+    state["facts"] = _clean_lines([x for c in state["chapters"] for x in c.get("facts", [])], 500)
+    state["characters"] = _clean_lines([x for c in state["chapters"] for x in c.get("characters", [])], 300)
+    state["timeline"] = _clean_lines([x for c in state["chapters"] for x in c.get("timeline", [])], 500)
+    state["foreshadowing"] = _clean_foreshadowing([x for c in state["chapters"] for x in c.get("foreshadowing", [])])
+    state["next_promises"] = record["next_promises"]
+    state["author_truth"] = record["author_truth"]
+    state["reader_known"] = record["reader_known"]
+    state["state_revision"] = int(state.get("state_revision") or 0) + 1
+    state["updated_at"] = _now()
+    chapter_dir = _CHAPTERS / ("%04d" % number)
+    (root / chapter_dir).mkdir(parents=True, exist_ok=True)
+    (root / chapter_dir / "outline.md").write_text(outline + "\n", encoding="utf-8")
+    (root / chapter_dir / "prose.md").write_text(prose + "\n", encoding="utf-8")
+    _save(root, state)
+    _render(root, state)
+    return state
+
+
+def _render(root, state):
+    derived = root / _DERIVED
+    derived.mkdir(parents=True, exist_ok=True)
+    lines = ["# 故事上下文", "", "- 书名：%s" % state.get("title", ""),
+             "- 当前章：第%s章" % state.get("current_chapter", 0),
+             "- 状态修订：%s" % state.get("state_revision", 0), ""]
+    if state.get("premise"):
+        lines += ["## 核心 premise", "", state["premise"], ""]
+    lines += ["## 长期事实", ""] + ["- " + x for x in state.get("facts", [])] + [""]
+    lines += ["## 活跃伏笔", ""]
+    for item in state.get("foreshadowing", []):
+        lines.append("- %s｜%s｜%s" % (item.get("id"), item.get("text"), item.get("status")))
+    lines += ["", "## 下一章承诺", ""] + ["- " + x for x in state.get("next_promises", [])] + [""]
+    lines += ["## 作者真相", ""] + ["- " + x for x in state.get("author_truth", [])] + [""]
+    lines += ["## 读者已知", ""] + ["- " + x for x in state.get("reader_known", [])] + [""]
+    context = "\n".join(lines).rstrip() + "\n"
+    (derived / "context.md").write_text(context, encoding="utf-8")
+    (derived / "foreshadowing.md").write_text("# 伏笔\n\n" + "\n".join(
+        "- %s｜%s｜%s" % (x.get("id"), x.get("text"), x.get("status"))
+        for x in state.get("foreshadowing", [])) + "\n", encoding="utf-8")
+    (derived / "timeline.md").write_text("# 时间线\n\n" + "\n".join(
+        "- " + x for x in state.get("timeline", [])) + "\n", encoding="utf-8")
+    state["derived_digests"] = {}
+    for name in ("context.md", "foreshadowing.md", "timeline.md"):
+        state["derived_digests"][name] = _digest((derived / name).read_text(encoding="utf-8"))
+    _save(root, state)
+    try:
+        from . import retrieval
+        for name in ("context.md", "foreshadowing.md", "timeline.md"):
+            path = derived / name
+            retrieval.upsert(str(path), path.read_text(encoding="utf-8"),
+                             {"task_id": state.get("task_id"), "kind": "story_tracking"})
+    except Exception:
+        pass
+
+
+def check(workdir):
+    root = _root(workdir)
+    state = _load(root)
+    if not state:
+        return {"ok": False, "errors": ["缺少故事追踪状态"]}
+    errors = []
+    for name, digest in (state.get("derived_digests") or {}).items():
+        path = root / _DERIVED / name
+        if not path.is_file():
+            errors.append("缺少派生文件 %s" % name)
+            continue
+        actual = _digest(path.read_text(encoding="utf-8"))
+        if actual != digest:
+            errors.append("派生文件已被手工修改: %s" % name)
+    for chapter in state.get("chapters") or []:
+        number = int(chapter.get("chapter") or 0)
+        outline = root / _CHAPTERS / ("%04d" % number) / "outline.md"
+        prose = root / _CHAPTERS / ("%04d" % number) / "prose.md"
+        if not outline.is_file() or not prose.is_file():
+            errors.append("章节文件缺失: %04d" % number)
+        elif outline.read_text(encoding="utf-8").strip() != str(chapter.get("outline") or "").strip():
+            # A continuation run may legitimately replace the shared outline
+            # with a book-level outline containing additional future chapters.
+            # Only reject a mismatch when the persisted chapter's own outline
+            # is no longer represented in the current file.
+            persisted = str(chapter.get("outline") or "").strip()
+            current = outline.read_text(encoding="utf-8").strip()
+            if persisted and persisted not in current:
+                errors.append("章节细纲不一致: %04d" % number)
+        elif _digest(prose.read_text(encoding="utf-8").strip()) != chapter.get("prose_digest"):
+            errors.append("章节正文不一致: %04d" % number)
+    return {"ok": not errors, "errors": errors, "state_revision": state.get("state_revision", 0),
+            "current_chapter": state.get("current_chapter", 0)}