codebee 0.1.95 → 0.1.97

package/app/core/history.py

@@ -1,38 +1,38 @@
-# -*- coding: utf-8 -*-
-"""历史统计：从过往运行记录提取每个智能体在每种任务类型上的胜率，反哺路由。"""
-from __future__ import annotations
-
-from . import store
-
-
-def agent_stats(limit=200):
-    """返回 {agent_id: {task_type: {"runs": n, "wins": w}}}。"""
-    stats = {}
-
-    def bump(aid, ttype, win):
-        if not aid:
-            return
-        s = stats.setdefault(aid, {}).setdefault(ttype, {"runs": 0, "wins": 0})
-        s["runs"] += 1
-        if win:
-            s["wins"] += 1
-
-    for run in store.list_runs(limit):
-        if run.get("kind") != "orchestration":
-            continue
-        # 失败运行也要进历史（记为全负）：以前只数 done——常挂的 CLI 永远
-        # 「无历史记录」满血参选，2026-09-17 opencode 当日秒挂 3 次仍被换将
-        # 选中。cancelled 不算（用户取消非智能体之过）。
-        if run.get("status") not in ("done", "failed"):
-            continue
-        verdict = run.get("verdict") or {}
-        task = store.get_task(run.get("task_id")) if run.get("task_id") else None
-        ttype = (task or {}).get("type") or verdict.get("type")
-        if not ttype:
-            continue
-        win = run.get("status") == "done" and bool(
-            verdict.get("pass") or verdict.get("publishable"))
-        for s in run.get("steps") or []:
-            if s.get("role") in ("implement", "draft"):
-                bump(s.get("agent"), ttype, win)
-    return stats
+# -*- coding: utf-8 -*-
+"""历史统计：从过往运行记录提取每个智能体在每种任务类型上的胜率，反哺路由。"""
+from __future__ import annotations
+
+from . import store
+
+
+def agent_stats(limit=200):
+    """返回 {agent_id: {task_type: {"runs": n, "wins": w}}}。"""
+    stats = {}
+
+    def bump(aid, ttype, win):
+        if not aid:
+            return
+        s = stats.setdefault(aid, {}).setdefault(ttype, {"runs": 0, "wins": 0})
+        s["runs"] += 1
+        if win:
+            s["wins"] += 1
+
+    for run in store.list_runs(limit):
+        if run.get("kind") != "orchestration":
+            continue
+        # 失败运行也要进历史（记为全负）：以前只数 done——常挂的 CLI 永远
+        # 「无历史记录」满血参选，2026-09-17 opencode 当日秒挂 3 次仍被换将
+        # 选中。cancelled 不算（用户取消非智能体之过）。
+        if run.get("status") not in ("done", "failed"):
+            continue
+        verdict = run.get("verdict") or {}
+        task = store.get_task(run.get("task_id")) if run.get("task_id") else None
+        ttype = (task or {}).get("type") or verdict.get("type")
+        if not ttype:
+            continue
+        win = run.get("status") == "done" and bool(
+            verdict.get("pass") or verdict.get("publishable"))
+        for s in run.get("steps") or []:
+            if s.get("role") in ("implement", "draft"):
+                bump(s.get("agent"), ttype, win)
+    return stats

package/app/core/hooks.py

@@ -1,162 +1,162 @@
-# -*- coding: utf-8 -*-
-"""任务生命周期钩子（借鉴 ZCode hooks，收窄为三个事件——2026-09-22 用户立项）：
-
-- task_start     任务开跑前（编排/直连都触发）：stdout 可注入文本，追加进任务上下文
-- message_submit 用户消息送达前：stdout 可注入文本，随消息进提示词头
-- run_end        每轮运行结束：纯副作用型（回写知识库等），输出被忽略
-
-协议：钩子命令从 stdin 收 JSON（事件+上下文）；stdout 若为 {"inject": "..."}
-取该字段为注入文本，否则把非空 stdout 整体当注入文本。
-失败/超时一律静默跳过（外部脚本不稳绝不拖死编排主流程）。
-
-命令执行：shlex 分词（保 Windows 反斜杠）后走参数列表，不经 shell——
-不支持管道/重定向等 shell 语法，需要时写 .py/.bat 包装脚本。
-配置：DATA_DIR/hooks.json，纯本机设置。"""
-from __future__ import annotations
-
-import json
-import logging
-import os
-import shlex
-import subprocess
-
-from . import paths
-
-log = logging.getLogger(__name__)
-
-EVENTS = ("task_start", "message_submit", "run_end")
-_DEFAULT_TIMEOUT = 10
-_FILE = None          # 测试重绑（同 modelhub._FILE 惯例）
-
-_CREATE_NO_WINDOW = 0x08000000 if hasattr(subprocess, "CREATE_NO_WINDOW") else 0
-
-
-def _path():
-    return _FILE or (paths.DATA_DIR / "hooks.json")
-
-
-def _default_list():
-    return []
-
-
-def load_list():
-    """读钩子配置列表；损坏/缺省回落空表。"""
-    try:
-        data = json.loads(_path().read_text(encoding="utf-8"))
-        return data if isinstance(data, list) else _default_list()
-    except Exception:
-        return _default_list()
-
-
-def save_list(items):
-    """整表保存（UI 全量提交）。字段归一 + 事件白名单。"""
-    if not isinstance(items, list):
-        raise ValueError("hooks 必须是数组")
-    out = []
-    for i, h in enumerate(items):
-        if not isinstance(h, dict):
-            continue
-        name = str(h.get("name") or "").strip()[:60]
-        event = str(h.get("event") or "").strip()
-        cmd = str(h.get("cmd") or "").strip()
-        if not cmd:
-            continue
-        if event not in EVENTS:
-            raise ValueError("第 %d 条钩子 event 非法（%s）" % (i + 1, event))
-        try:
-            timeout = max(1, min(120, int(h.get("timeout_s") or _DEFAULT_TIMEOUT)))
-        except (TypeError, ValueError):
-            timeout = _DEFAULT_TIMEOUT
-        out.append({"id": str(h.get("id") or ("hk-%d" % (i + 1)))[:40],
-                    "name": name or ("钩子 %d" % (i + 1)),
-                    "event": event, "cmd": cmd,
-                    "enabled": bool(h.get("enabled", True)),
-                    "timeout_s": timeout})
-    tmp = _path().with_suffix(".tmp")
-    tmp.write_text(json.dumps(out, ensure_ascii=False, indent=1), encoding="utf-8")
-    tmp.replace(_path())
-    return out
-
-
-def _argv(cmd):
-    """命令串 → 参数列表。Windows 反斜杠路径保真（posix=False），支持引号分组；
-    分词后剥掉 token 首尾引号（CreateProcess 不认字面引号路径）。"""
-    toks = shlex.split(str(cmd or ""), posix=False)
-    out = []
-    for t in toks:
-        if len(t) >= 2 and t[0] == t[-1] and t[0] in ('"', "'"):
-            t = t[1:-1]
-        if t:
-            out.append(t)
-    return out
-
-
-def _run_one(h, payload):
-    """跑单条钩子。返回注入文本或 None（失败/超时/空输出）。"""
-    try:
-        argv = _argv(h.get("cmd"))
-    except ValueError as e:
-        log.warning("hook[%s %s] 命令解析失败：%s", h.get("name"), h.get("event"), str(e)[:120])
-        return None
-    if not argv:
-        return None
-    try:
-        # Hook input/output is a UTF-8 JSON/text protocol. Python subprocesses on
-        # Windows otherwise inherit the OEM code page and their Chinese stdout is
-        # decoded as mojibake below. Non-Python hooks ignore this variable.
-        env = os.environ.copy()
-        env["PYTHONIOENCODING"] = "utf-8"
-        proc = subprocess.run(
-            argv, shell=False,
-            input=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
-            capture_output=True, timeout=int(h.get("timeout_s") or _DEFAULT_TIMEOUT),
-            creationflags=_CREATE_NO_WINDOW, env=env)
-    except subprocess.TimeoutExpired:
-        log.warning("hook[%s %s] 超时，已跳过", h.get("name"), h.get("event"))
-        return None
-    except Exception as e:
-        log.warning("hook[%s %s] 执行失败：%s", h.get("name"), h.get("event"), str(e)[:120])
-        return None
-    out = (proc.stdout or b"").decode("utf-8", "replace").strip()
-    if not out:
-        return None
-    try:
-        data = json.loads(out)
-        if isinstance(data, dict):
-            return str(data.get("inject") or "") or None
-    except Exception:
-        pass
-    return out
-
-
-def run_event(event, ctx=None, task_id=None, run_id=None, text=None):
-    """触发事件：依次跑启用的钩子，合并注入文本。任何异常不外抛。
-
-    ctx 附带任务/运行摘要；text 仅 message_submit 时传用户消息原文。
-    返回拼接好的注入文本（可为空串）。"""
-    if event not in EVENTS:
-        return ""
-    try:
-        items = [h for h in load_list() if h.get("enabled") and h.get("event") == event]
-    except Exception:
-        return ""
-    if not items:
-        return ""
-    payload = {"event": event, "task_id": task_id or "", "run_id": run_id or "",
-               "text": text or ""}
-    if ctx is not None:
-        payload["ctx"] = ctx
-    outs = []
-    for h in items:
-        piece = _run_one(h, payload)
-        if piece:
-            outs.append(piece.strip())
-    return "\n\n".join(outs)
-
-
-def test_one(cmd, event="task_start", timeout_s=None):
-    """设置页「测试」：手动跑一条钩子，返回 (ok, 输出/错误人话)。"""
-    h = {"name": "test", "event": event if event in EVENTS else "task_start",
-         "cmd": cmd, "timeout_s": timeout_s or _DEFAULT_TIMEOUT}
-    piece = _run_one(h, {"event": h["event"], "task_id": "", "run_id": "", "text": ""})
-    return True, piece if piece else "（无输出，未注入）"
+# -*- coding: utf-8 -*-
+"""任务生命周期钩子（借鉴 ZCode hooks，收窄为三个事件——2026-09-22 用户立项）：
+
+- task_start     任务开跑前（编排/直连都触发）：stdout 可注入文本，追加进任务上下文
+- message_submit 用户消息送达前：stdout 可注入文本，随消息进提示词头
+- run_end        每轮运行结束：纯副作用型（回写知识库等），输出被忽略
+
+协议：钩子命令从 stdin 收 JSON（事件+上下文）；stdout 若为 {"inject": "..."}
+取该字段为注入文本，否则把非空 stdout 整体当注入文本。
+失败/超时一律静默跳过（外部脚本不稳绝不拖死编排主流程）。
+
+命令执行：shlex 分词（保 Windows 反斜杠）后走参数列表，不经 shell——
+不支持管道/重定向等 shell 语法，需要时写 .py/.bat 包装脚本。
+配置：DATA_DIR/hooks.json，纯本机设置。"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shlex
+import subprocess
+
+from . import paths
+
+log = logging.getLogger(__name__)
+
+EVENTS = ("task_start", "message_submit", "run_end")
+_DEFAULT_TIMEOUT = 10
+_FILE = None          # 测试重绑（同 modelhub._FILE 惯例）
+
+_CREATE_NO_WINDOW = 0x08000000 if hasattr(subprocess, "CREATE_NO_WINDOW") else 0
+
+
+def _path():
+    return _FILE or (paths.DATA_DIR / "hooks.json")
+
+
+def _default_list():
+    return []
+
+
+def load_list():
+    """读钩子配置列表；损坏/缺省回落空表。"""
+    try:
+        data = json.loads(_path().read_text(encoding="utf-8"))
+        return data if isinstance(data, list) else _default_list()
+    except Exception:
+        return _default_list()
+
+
+def save_list(items):
+    """整表保存（UI 全量提交）。字段归一 + 事件白名单。"""
+    if not isinstance(items, list):
+        raise ValueError("hooks 必须是数组")
+    out = []
+    for i, h in enumerate(items):
+        if not isinstance(h, dict):
+            continue
+        name = str(h.get("name") or "").strip()[:60]
+        event = str(h.get("event") or "").strip()
+        cmd = str(h.get("cmd") or "").strip()
+        if not cmd:
+            continue
+        if event not in EVENTS:
+            raise ValueError("第 %d 条钩子 event 非法（%s）" % (i + 1, event))
+        try:
+            timeout = max(1, min(120, int(h.get("timeout_s") or _DEFAULT_TIMEOUT)))
+        except (TypeError, ValueError):
+            timeout = _DEFAULT_TIMEOUT
+        out.append({"id": str(h.get("id") or ("hk-%d" % (i + 1)))[:40],
+                    "name": name or ("钩子 %d" % (i + 1)),
+                    "event": event, "cmd": cmd,
+                    "enabled": bool(h.get("enabled", True)),
+                    "timeout_s": timeout})
+    tmp = _path().with_suffix(".tmp")
+    tmp.write_text(json.dumps(out, ensure_ascii=False, indent=1), encoding="utf-8")
+    tmp.replace(_path())
+    return out
+
+
+def _argv(cmd):
+    """命令串 → 参数列表。Windows 反斜杠路径保真（posix=False），支持引号分组；
+    分词后剥掉 token 首尾引号（CreateProcess 不认字面引号路径）。"""
+    toks = shlex.split(str(cmd or ""), posix=False)
+    out = []
+    for t in toks:
+        if len(t) >= 2 and t[0] == t[-1] and t[0] in ('"', "'"):
+            t = t[1:-1]
+        if t:
+            out.append(t)
+    return out
+
+
+def _run_one(h, payload):
+    """跑单条钩子。返回注入文本或 None（失败/超时/空输出）。"""
+    try:
+        argv = _argv(h.get("cmd"))
+    except ValueError as e:
+        log.warning("hook[%s %s] 命令解析失败：%s", h.get("name"), h.get("event"), str(e)[:120])
+        return None
+    if not argv:
+        return None
+    try:
+        # Hook input/output is a UTF-8 JSON/text protocol. Python subprocesses on
+        # Windows otherwise inherit the OEM code page and their Chinese stdout is
+        # decoded as mojibake below. Non-Python hooks ignore this variable.
+        env = os.environ.copy()
+        env["PYTHONIOENCODING"] = "utf-8"
+        proc = subprocess.run(
+            argv, shell=False,
+            input=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
+            capture_output=True, timeout=int(h.get("timeout_s") or _DEFAULT_TIMEOUT),
+            creationflags=_CREATE_NO_WINDOW, env=env)
+    except subprocess.TimeoutExpired:
+        log.warning("hook[%s %s] 超时，已跳过", h.get("name"), h.get("event"))
+        return None
+    except Exception as e:
+        log.warning("hook[%s %s] 执行失败：%s", h.get("name"), h.get("event"), str(e)[:120])
+        return None
+    out = (proc.stdout or b"").decode("utf-8", "replace").strip()
+    if not out:
+        return None
+    try:
+        data = json.loads(out)
+        if isinstance(data, dict):
+            return str(data.get("inject") or "") or None
+    except Exception:
+        pass
+    return out
+
+
+def run_event(event, ctx=None, task_id=None, run_id=None, text=None):
+    """触发事件：依次跑启用的钩子，合并注入文本。任何异常不外抛。
+
+    ctx 附带任务/运行摘要；text 仅 message_submit 时传用户消息原文。
+    返回拼接好的注入文本（可为空串）。"""
+    if event not in EVENTS:
+        return ""
+    try:
+        items = [h for h in load_list() if h.get("enabled") and h.get("event") == event]
+    except Exception:
+        return ""
+    if not items:
+        return ""
+    payload = {"event": event, "task_id": task_id or "", "run_id": run_id or "",
+               "text": text or ""}
+    if ctx is not None:
+        payload["ctx"] = ctx
+    outs = []
+    for h in items:
+        piece = _run_one(h, payload)
+        if piece:
+            outs.append(piece.strip())
+    return "\n\n".join(outs)
+
+
+def test_one(cmd, event="task_start", timeout_s=None):
+    """设置页「测试」：手动跑一条钩子，返回 (ok, 输出/错误人话)。"""
+    h = {"name": "test", "event": event if event in EVENTS else "task_start",
+         "cmd": cmd, "timeout_s": timeout_s or _DEFAULT_TIMEOUT}
+    piece = _run_one(h, {"event": h["event"], "task_id": "", "run_id": "", "text": ""})
+    return True, piece if piece else "（无输出，未注入）"

package/app/core/jobs.py

@@ -750,6 +750,7 @@ def _maybe_auto_resume(run_id):
 
 
 RESUME_WINDOW_HOURS = 24   # 启动恢复只看最近 24h 内中断的运行（更早的视为已放弃）
+UNCLAIMED_QUEUE_MAX_AGE_S = RESUME_WINDOW_HOURS * 3600
 
 
 def _recent(run):
@@ -887,15 +888,35 @@ def requeue_pending(limit=10, max_age_s=None):
             kind = run.get("kind")
             if run.get("status") != "queued" or kind not in ("orchestration", "mgmt"):
                 continue
+            # requeue_pending 也会在进程存活期间由巡检线程调用。load_all() 只
+            # 能清理启动时发现的 queued 残留；如果进程一直不重启，旧的测试/异常
+            # 创建记录会永远绕过 _recent() 留在「排队中」。超过恢复窗口的记录
+            # 已不具备自动恢复价值，直接收口并同步任务状态，保留用户手动重试入口。
+            # 明确的未来 resume_enqueue_at 属于有意退避，即使创建时间很老也不能提前
+            # 打断；到点后下一轮巡检会重新进入这里。
+            if _in_resume_backoff(run):
+                continue
+            if kind == "orchestration":
+                if not run.get("task_id") or not _recent(run):
+                    # Keep malformed/old records eligible for the expiry path,
+                    # but never let an old duplicate override a newer run.
+                    if run.get("task_id") and _task_active_run(
+                            run["task_id"], exclude_run_id=run["id"]):
+                        continue
+                elif _task_active_run(run["task_id"], exclude_run_id=run["id"]):
+                    continue   # 同任务已有更活跃的运行，别收口/再排一份
+            if _age_s(run) >= UNCLAIMED_QUEUE_MAX_AGE_S:
+                store.update_run(
+                    run["id"], expected_status="queued", status="failed",
+                    ended_at=_now(),
+                    error="排队记录已过期，服务未能在恢复窗口内启动，可重试",
+                )
+                continue
             if max_age_s is not None and _age_s(run) < max_age_s:
                 continue
             if kind == "orchestration":
                 if not run.get("task_id") or not _recent(run):
                     continue
-                if _in_resume_backoff(run):
-                    continue   # 退避窗口内的续跑副本：到点 Timer 自会入队
-                if _task_active_run(run["task_id"], exclude_run_id=run["id"]):
-                    continue   # 同任务已有更活跃的运行，别再排一份
             else:
                 eid = run.get("entry_id")
                 if eid:

package/app/core/knowledge_pipeline.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+"""Source hashing, chunking and quality reporting for the local knowledge index."""
+from __future__ import annotations
+
+import hashlib
+import json
+import threading
+import time
+
+from . import paths, retrieval
+
+_REPORT_FILE = paths.DATA_DIR / "knowledge_pipeline.json"
+_LOCK = threading.RLock()
+
+
+def chunk_text(text, chunk_size=1200, overlap=120):
+    text = str(text or "")
+    try:
+        size = max(100, min(10000, int(chunk_size)))
+        overlap = max(0, min(size // 2, int(overlap)))
+    except (TypeError, ValueError):
+        size, overlap = 1200, 120
+    if not text:
+        return []
+    out, start = [], 0
+    while start < len(text):
+        end = min(len(text), start + size)
+        part = text[start:end].strip()
+        if part:
+            out.append(part)
+        if end >= len(text):
+            break
+        start = end - overlap
+    return out
+
+
+def _load():
+    try:
+        data = json.loads(_REPORT_FILE.read_text(encoding="utf-8"))
+        return data if isinstance(data, dict) else {}
+    except (OSError, TypeError, ValueError):
+        return {}
+
+
+def ingest(source, text, metadata=None, *, chunk_size=1200, overlap=120):
+    source = str(source or "").strip()[:500]
+    text = str(text or "")
+    if len(text) > 2 * 1024 * 1024:
+        raise ValueError("text 过大（最大 2 MiB）")
+    if not source or not text.strip():
+        raise ValueError("source 和 text 不能为空")
+    source_hash = hashlib.sha256(text.encode("utf-8")).hexdigest()
+    ingest_id = "ingest-" + hashlib.sha256((source + "\0" + source_hash).encode("utf-8")).hexdigest()[:20]
+    chunks = chunk_text(text, chunk_size, overlap)
+    if metadata is not None and not isinstance(metadata, dict):
+        raise ValueError("metadata 必须是对象")
+    meta = {str(k)[:60]: str(v)[:500] for k, v in (metadata or {}).items()
+            if isinstance(k, (str, int)) and isinstance(v, (str, int, float, bool))}
+    indexed = []
+    for index, part in enumerate(chunks):
+        indexed.append(retrieval.upsert(
+            "%s#%d" % (source, index + 1), part,
+            dict(meta, source=source, source_sha256=source_hash,
+                 ingest_id=ingest_id, chunk_index=index, chunk_count=len(chunks)),
+            doc_id="%s-%04d" % (ingest_id, index)))
+    report = {"ingest_id": ingest_id, "source": source, "source_sha256": source_hash,
+              "chunks": len(chunks), "indexed_chunks": len(indexed),
+              "chars": len(text), "created_at": time.time(),
+              "quality": {"non_empty_ratio": round(sum(bool(x.strip()) for x in chunks) /
+                                                        float(max(1, len(chunks))), 4),
+                          "unique_ratio": round(len(set(chunks)) / float(max(1, len(chunks))), 4),
+                          "avg_chunk_chars": round(sum(map(len, chunks)) / float(max(1, len(chunks))), 2)}}
+    with _LOCK:
+        data = _load()
+        data[ingest_id] = report
+        _REPORT_FILE.parent.mkdir(parents=True, exist_ok=True)
+        tmp = _REPORT_FILE.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        tmp.replace(_REPORT_FILE)
+    return report
+
+
+def quality_report(ingest_id):
+    with _LOCK:
+        return _load().get(str(ingest_id or ""), {"ingest_id": str(ingest_id or ""),
+                                                    "indexed_chunks": 0, "quality": {}})