codebee 0.1.66 → 0.1.67

package/app/core/revisions.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""Small, content-addressed revision helpers.
+
+The execution layer stores revision identifiers and digests instead of copying
+skill/knowledge bodies into every run.  A digest is deliberately based on the
+semantic payload supplied by the caller, so formatting-only metadata changes do
+not silently change the meaning of an existing run.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+
+
+def canonical_json(value) -> str:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True,
+                      separators=(",", ":"), default=str)
+
+
+def content_sha256(value) -> str:
+    if not isinstance(value, str):
+        value = canonical_json(value)
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def revision_id(prefix: str, digest: str) -> str:
+    return "%s-%s" % (str(prefix or "rev"), str(digest or "")[:16])
+
+
+def make_revision(prefix: str, content, *, source="", created_at=None) -> dict:
+    digest = content_sha256(content)
+    return {
+        "revision_id": revision_id(prefix, digest),
+        "content_sha256": digest,
+        "source": str(source or "")[:160],
+        "created_at": created_at or time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+
+
+def revision_record(prefix: str, content, *, source="", created_at=None,
+                    extra=None) -> dict:
+    out = make_revision(prefix, content, source=source, created_at=created_at)
+    if isinstance(extra, dict):
+        out.update(extra)
+    return out
+
+
+def stable_digest(items) -> str:
+    """Digest a list/dict of revision metadata without embedding content."""
+    return content_sha256(items)

package/app/core/runner.py

@@ -184,18 +184,23 @@ def _kill_tree(pid):
     某些机器状态下 taskkill /F /T 对普通进程也挂死 30s+，等满 15s 超时会让每次
     超时杀进程都卡 20s，看门狗/超时全被拖死；漏杀的孙进程由启动孤儿清扫兜底）。
     POSIX 靠 spawn 时的 start_new_session（子进程自成一个进程组，pgid==pid）
-    用 killpg 连孙带杀。"""
+    用 killpg 连孙带杀。
+
+    返回是否确认整树清空（借鉴 WorkDSH 取消结算分层：kill 动作完成 ≠ 停稳）：
+    Windows 以 taskkill /T 在 1.2s 内退出且返回 0 为准；POSIX 以 killpg 成功
+    为准。返回 False = 停稳未知（孙进程可能仍在），调用方据此落
+    quiescence_unknown 诊断，不改变任何终态语义。"""
     if os.name != "nt":
         try:
             os.killpg(pid, signal.SIGKILL)
-            return
+            return True
         except Exception:
             pass
         try:
-            os.kill(pid, signal.SIGKILL)
+            os.kill(pid, signal.SIGKILL)   # 组杀失败退而杀根：子孙已不可确认
         except Exception:
             pass
-        return
+        return False
     # Windows 没有 signal.SIGKILL（直接引用会 AttributeError）；os.kill 带任意
     # 信号值都走 TerminateProcess，用 SIGTERM
     try:
@@ -211,8 +216,9 @@ def _kill_tree(pid):
             stderr=subprocess.DEVNULL, close_fds=True,   # 不继承被杀进程的管道句柄，否则 EOF 永不来、drain 烧满超时
             creationflags=CREATE_NO_WINDOW)
         tk.wait(timeout=1.2)           # 健康机器 <1s；卡死就不再陪等（后台自行结束）
+        return tk.returncode == 0
     except Exception:
-        pass
+        return False
 
 
 def _drain_streams(proc, t_out, t_err, *, timeout=10):
@@ -647,7 +653,8 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
     为 timeout，而不是把它误记成普通供应商失败。
 
     返回 {ok, exit_code, stdout, stderr, duration, cancelled, timed_out, stalled,
-    deadline_exceeded, abort_marker}。
+    deadline_exceeded, abort_marker}；杀树后未能确认整树清空时额外带
+    quiescence_unknown=True（孙进程可能仍在，诊断用，不改变终态语义）。
     """
     if shell_cmd:
         # shell 串的解析器随平台：重定向/引号语法两边通用，只是解释器不同
@@ -736,6 +743,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
         cancelled = timed_out = stalled = repeat_aborted = False
         deadline_exceeded = False
         abort_marker = None
+        tree_quiet = None   # 杀树结果：None=未杀，True=确认清空，False=停稳未知
         while True:
             try:
                 proc.wait(timeout=0.4)
@@ -744,13 +752,13 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 pass
             if cancel_event is not None and cancel_event.is_set():
                 cancelled = True
-                _kill_tree(proc.pid)
+                tree_quiet = _kill_tree(proc.pid)
                 _drain_streams(proc, t_out, t_err, timeout=10)
                 break
             if deadline is not None and time.monotonic() >= deadline:
                 deadline_exceeded = True
                 timed_out = True
-                _kill_tree(proc.pid)
+                tree_quiet = _kill_tree(proc.pid)
                 _drain_streams(proc, t_out, t_err, timeout=5)
                 break
             elapsed = time.monotonic() - start_mono
@@ -763,7 +771,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                           and elapsed < timeout + activity_timeout)
                 if not active:
                     timed_out = True
-                    _kill_tree(proc.pid)
+                    tree_quiet = _kill_tree(proc.pid)
                     _drain_streams(proc, t_out, t_err, timeout=5)
                     break
             if stall_timeout and time.time() - stamp[0] > stall_timeout:
@@ -771,7 +779,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                 # 超时不如提前杀——错误按超时归类，走既有的换模型/换将链路
                 stalled = True
                 timed_out = True
-                _kill_tree(proc.pid)
+                tree_quiet = _kill_tree(proc.pid)
                 _drain_streams(proc, t_out, t_err, timeout=5)
                 break
             if aborts:
@@ -783,7 +791,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
                             repeat_aborted = True
                             abort_marker = marker
                             timed_out = True
-                            _kill_tree(proc.pid)
+                            tree_quiet = _kill_tree(proc.pid)
                             _drain_streams(proc, t_out, t_err, timeout=5)
                             break
                     if repeat_aborted:
@@ -821,7 +829,7 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
             stderr += "\n[输出停滞 %ss，已终止进程树]" % stall_timeout
         elif timed_out:
             stderr += "\n[超时 %ss，已终止进程树]" % timeout
-        return {
+        result = {
             "ok": exit_code == 0 and not cancelled and not timed_out,
             "exit_code": exit_code, "stdout": stdout, "stderr": stderr,
             "duration": duration, "cancelled": cancelled, "timed_out": timed_out,
@@ -832,6 +840,13 @@ def run_process(argv=None, shell_cmd=None, stdin_text=None, cwd=None, env=None,
             "activity_timeout": activity_timeout,
             "last_output_age": max(0.0, time.time() - stamp[0]),
         }
+        if tree_quiet is False:
+            # 杀树完成但未确认整树清空（taskkill 卡死放弃 / killpg 失手只杀了
+            # 根）：孙进程可能仍在运行。只落诊断标记，不改变 cancelled/timed_out
+            # 等任何终态语义——KEY 冷却豁免、健康惩罚仍按结构化取消标记判断。
+            result["quiescence_unknown"] = True
+            result["stderr"] += "\n[进程树未确认清空：孙进程可能仍在运行]"
+        return result
     finally:
         if log_fh:
             try:

package/app/core/skills.py

@@ -25,7 +25,7 @@ import threading
 import time
 from pathlib import Path
 
-from . import paths
+from . import paths, revisions
 
 _LOCK = threading.RLock()
 _FILE = paths.DATA_DIR / "skills.json"
@@ -189,6 +189,8 @@ def _load_user_pack(path):
         "user": True,
     }
     pack["body"] = body
+    pack.update({k: revisions.make_revision("packrev", body, source=key)[k]
+                 for k in ("revision_id", "content_sha256")})
     with _LOCK:
         _user_pack_cache[key] = (mt, pack)
     return pack
@@ -265,6 +267,38 @@ def list_packs():
     return out
 
 
+def revision_for_task(task) -> dict:
+    """Return the skill inputs selected for a task as a compact revision set."""
+    scope = str((task or {}).get("type") or "*")
+    packs = []
+    for pack in all_packs():
+        if scope not in (pack.get("scopes") or ["*"]) and "*" not in (pack.get("scopes") or []):
+            continue
+        if not _pack_enabled(pack.get("id")):
+            continue
+        body = pack_text(pack)
+        rev = revisions.make_revision("packrev", body, source=pack.get("id") or "")
+        packs.append({"id": pack.get("id") or "", "revision_id": rev["revision_id"],
+                      "content_sha256": rev["content_sha256"]})
+    lessons = []
+    for lesson in list_lessons(scope=scope, only_enabled=True):
+        current_digest = revisions.content_sha256(lesson.get("content") or "")
+        stored_digest = str(lesson.get("content_sha256") or "")
+        drift = bool(stored_digest and stored_digest != current_digest)
+        lessons.append({"id": lesson.get("id") or "",
+                        "revision_id": (lesson.get("revision_id")
+                                        if stored_digest == current_digest else
+                                        revisions.revision_id("skrev", current_digest)) or
+                        revisions.revision_id("skrev", current_digest),
+                        "content_sha256": current_digest,
+                        "revision_drift": drift})
+    payload = {"scope": scope, "packs": packs, "lessons": lessons}
+    digest = revisions.stable_digest(payload)
+    return {"revision_id": revisions.revision_id("skills", digest),
+            "content_sha256": digest, "scope": scope,
+            "packs": packs, "lessons": lessons}
+
+
 def _pack_enabled(pid):
     with _LOCK:
         st = (_load().get("packs") or {}).get(pid) or {}
@@ -364,7 +398,16 @@ def upsert_lesson(scope, title, content, source="", category=None, dim=None):
                     break
         if hit is not None:
             it = hit
+            old_content = str(it.get("content") or "")
+            new_rev = revisions.make_revision("skrev", content, source=source)
+            if old_content and old_content != content:
+                it.setdefault("revisions", []).append(
+                    revisions.revision_record(
+                        "skrev", old_content, source=it.get("source") or "",
+                        extra={"content": old_content}))
+                it["revisions"] = it["revisions"][-5:]
             it["content"] = content
+            it.update({k: new_rev[k] for k in ("revision_id", "content_sha256")})
             it["seen"] = int(it.get("seen") or 1) + 1
             it["updated_at"] = _now()
             # 合并时不降级已有分类：除非本次归到了明确类别，或该条原本没有分类
@@ -374,6 +417,7 @@ def upsert_lesson(scope, title, content, source="", category=None, dim=None):
                 it["source"] = source
             _save(data)
             return it
+        rev = revisions.make_revision("skrev", content, source=source)
         it = {"id": lid, "scope": scope, "title": title, "content": content,
               "source": source, "hits": 0, "seen": 1, "enabled": True,
               "category": cat,
@@ -381,6 +425,7 @@ def upsert_lesson(scope, title, content, source="", category=None, dim=None):
               # 稳定 token（procedure=程序性做法 / lesson=规避性教训）；
               # 展示层 view() 翻译成「做法/教训」，持久层不用中文防改文案伤数据
               "kind": ("procedure" if title.startswith("做法：") else "lesson")}
+        it.update({k: rev[k] for k in ("revision_id", "content_sha256")})
         items.append(it)
         _save(data)
         return it
@@ -452,6 +497,54 @@ def relevance_top(lessons, task, limit):
     return sorted(lessons, key=rank)[:limit]
 
 
+def evolve_lessons(min_hits=6, min_karma=0.75, min_won=1, max_items=10):
+    """教训半自动晋升技能包（ECC /evolve 借鉴）：把被任务面反复验证的教训
+    （注入 ≥min_hits、可信度下界 ≥min_karma、成功归因 ≥min_won）聚成一份
+    用户包**草稿**写入 data/skillpacks/evolve-<时间戳>.md。
+
+    草稿默认停用（packs 状态写 enabled=False）——晋升必须过人工审阅这道闸：
+    技能库页审后启用/改 scopes/编辑正文；不自动生效，避免聚合噪音直接进
+    全量任务注入。返回 (文件名, 收录条数)；无可晋升教训返回 (None, 0)。"""
+    with _LOCK:
+        items = list((_load().get("lessons") or []))
+    picked = [x for x in items
+              if x.get("enabled", True)
+              and int(x.get("hits") or 0) >= min_hits
+              and int(x.get("won") or 0) >= min_won
+              and _karma(x) >= min_karma]
+    picked.sort(key=lambda x: (-_karma(x), -int(x.get("hits") or 0)))
+    picked = picked[:max_items]
+    if not picked:
+        return None, 0
+    scopes = sorted({str(x.get("scope") or "*") for x in picked})
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    fname = "evolve-%s.md" % stamp
+    lines = ["# 晋升自项目教训（evolve 草稿，待人工审阅启用）", "",
+             "以下教训经任务面反复验证聚合而成；逐条确认后可编辑删改，"
+             "确认无误再在技能库页启用本包。", ""]
+    for x in picked:
+        lines.append("- **%s**（可信度 %.0f%%，注入 %d 次/成功归因 %d 次）：%s"
+                     % (x.get("title") or x.get("id"),
+                        _karma(x) * 100, int(x.get("hits") or 0),
+                        int(x.get("won") or 0), x.get("content") or ""))
+    fm = ["---",
+          "name: 教训晋升草稿·%s" % time.strftime("%Y-%m-%d %H:%M"),
+          "scopes:"] + ["  - %s" % s for s in scopes] + [
+          "note: evolve 自动聚合的高可信教训草稿（默认停用，审阅后启用）",
+          "---", ""]
+    d = _user_pack_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    (d / fname).write_text("\n".join(fm + lines) + "\n", encoding="utf-8")
+    # 草稿停用态：pid 与 _load_user_pack 的 path.stem 哈希口径一致
+    stem = fname[:-3] if fname.endswith(".md") else fname
+    pid = "user-" + hashlib.sha256(stem.encode("utf-8")).hexdigest()[:10]
+    with _LOCK:
+        data = _load()
+        data.setdefault("packs", {})[pid] = {"enabled": False, "evolved": True}
+        _save(data)
+    return fname, len(picked)
+
+
 # 运行级注入登记（outcome 加权用）：run_id → 注入的教训 id 列表。
 # 容量有界防泄漏；run 收尾 learn_from_run 时消费清除。
 _INJECTED = {}

package/app/core/store.py

@@ -160,6 +160,19 @@ def create_task(payload):
     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"))
+    # 流程修订出处（借鉴 WorkDSH ADR-0010）：创建时钉住当时流程定义的指纹。
+    # 固化参数已保证「改流程不影响本任务」，digest 再补上可对账的一面——
+    # 续跑/重试时若流程已改，flows.flow_drift 能给出明确诊断而非静默换新。
+    flow_content_sha = flows_mod.flow_content_sha256(flow)
+    task["flow_snapshot"] = {"id": flow["id"], "name": (flow.get("name") or "")[:40],
+                             "engine": flow["engine"],
+                             "edited": bool(flow.get("edited")),
+                             "digest": flow_content_sha[:16],
+                             "revision_id": "flowrev-" + flow_content_sha[:16],
+                             "content_sha256": flow_content_sha}
+    # 参数修订号（借鉴 WorkDSH 契约纪律 expectedRevision）：写接口据此做过期
+    # 写入检测。老任务无此键按 1 处理；不带 expected_rev 的调用不受影响。
+    task["rev"] = 1
     if flow["engine"] == "direct":
         task["direct_provider_id"] = _text(payload.get("direct_provider_id"),
                                             "direct_provider_id")[:80]
@@ -312,8 +325,20 @@ def create_task(payload):
     att_ids = payload.get("attachments")
     if isinstance(att_ids, list) and att_ids:
         from . import attachments as att_mod
-        items = [a for a in att_ids if isinstance(a, dict) and a.get("path")]
-        if not items:  # 纯 id 形态 → 从待提交区移入工作目录
+        dict_items = [a for a in att_ids if isinstance(a, dict) and a.get("path")]
+        if dict_items:
+            root = Path(str(wd)).resolve()
+            items = []
+            for raw in dict_items[:att_mod.MAX_FILES]:
+                rel = att_mod.norm_rel(raw)
+                fp = (root / rel).resolve() if rel else root / "__invalid__"
+                if rel and root in fp.parents and fp.is_file():
+                    item = dict(raw)
+                    item["path"] = rel
+                    items.append(item)
+            if not items:
+                raise ValueError("附件路径必须位于工作目录的 _attachments/ 内")
+        else:  # 纯 id 形态 → 从待提交区移入工作目录
             try:
                 items = att_mod.commit_to_workdir(
                     str(wd), [str(x) for x in att_ids][:att_mod.MAX_FILES])
@@ -321,6 +346,18 @@ def create_task(payload):
                 raise ValueError("附件落盘失败: %s" % e)
         if items:
             task["attachments"] = items
+            task["asset_refs"] = att_mod.asset_refs(str(wd), items)
+            try:
+                from . import assets
+                for ref in task["asset_refs"]:
+                    saved = assets.register(str(wd), ref.get("path"),
+                                            owner_type="task", owner_id=task["id"],
+                                            name=ref.get("name"), mime=ref.get("mime"))
+                    if saved:
+                        ref.update({k: saved[k] for k in ("asset_id", "revision_id",
+                                                          "content_sha256")})
+            except Exception:
+                pass
             task["context"] = att_mod.merge_context(
                 task["context"], items, workdir=str(wd))
     with LOCK:
@@ -569,6 +606,100 @@ def set_run_auditor(auditor):
     _RUN_AUDITOR = auditor if callable(auditor) else None
 
 
+def _execution_snapshot(task):
+    """Capture the redacted execution inputs at run creation time.
+
+    This is intentionally a snapshot of identities and revisions, never API
+    keys or task bodies.  Later binding/skill/knowledge changes therefore do
+    not rewrite the explanation of an existing run.
+    """
+    task = task or {}
+    flow_snapshot = dict(task.get("flow_snapshot") or {})
+    flow_digest = str(flow_snapshot.get("digest") or "")
+    flow_content_sha = str(flow_snapshot.get("content_sha256") or "")
+    flow_revision_id = str(flow_snapshot.get("revision_id") or "")
+    if not flow_content_sha and len(flow_digest) == 64:
+        flow_content_sha = flow_digest
+    if not flow_revision_id and flow_digest:
+        flow_revision_id = "flowrev-" + flow_digest[:16]
+
+    def _redact_command(command):
+        value = str(command or "")[:300]
+        if not value:
+            return ""
+        pattern = re.compile(
+            r"(?i)(api[_-]?key|access[_-]?token|auth(?:orization)?|password|passwd|secret|token)"
+            r"(\s*[:=]\s*|\s+)([^\s]+)")
+        return pattern.sub(lambda m: m.group(1) + m.group(2) + "<redacted>", value)
+
+    snapshot = {
+        "captured_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+        "task_id": task.get("id") or "",
+        "flow_revision": flow_digest,
+        "flow_revision_id": flow_revision_id,
+        "flow_content_sha256": flow_content_sha,
+        "flow_snapshot": flow_snapshot,
+        "workdir": str(task.get("workdir") or "")[:500],
+        "git_rev": str(task.get("git_rev") or "")[:160],
+        "verify_command": _redact_command(task.get("verify_command") or ""),
+        "quality_gate": {
+            "threshold": task.get("threshold"),
+            "rubric": list(task.get("rubric") or [])[:8],
+            "rounds": task.get("rounds"),
+            "best_of": task.get("best_of"),
+        },
+    }
+    try:
+        from . import knowledge, modelhub, skills
+        snapshot["skills"] = skills.revision_for_task(task)
+        snapshot["knowledge"] = knowledge.revision_for_task(task)
+        providers = {str(p.get("id") or ""): p for p in modelhub.providers()}
+        bindings = {}
+        for agent_id, binding in (modelhub.bindings() or {}).items():
+            chain = []
+            for item in (binding or {}).get("chain") or []:
+                pid = str(item.get("provider_id") or "")
+                prov = providers.get(pid) or {}
+                try:
+                    key_ids = [str(k.get("id") or "") for k in modelhub._provider_keys(prov)
+                               if k.get("id")]
+                except Exception:
+                    key_ids = []
+                entry = {
+                    "provider_id": pid,
+                    "model": str(item.get("model") or "")[:160],
+                    "key_ids": key_ids[:8],
+                }
+                if pid:
+                    entry.update(modelhub.connection_identity(pid, key_ids[0] if key_ids else ""))
+                chain.append(entry)
+            bindings[str(agent_id)[:80]] = {
+                "difficulty_routing": bool((binding or {}).get("difficulty_routing")),
+                "chain": chain,
+            }
+        snapshot["agent_bindings"] = bindings
+        if task.get("direct_provider_id") or task.get("direct_model"):
+            direct = {
+                "provider_id": str(task.get("direct_provider_id") or "")[:80],
+                "model": str(task.get("direct_model") or "")[:160],
+                "agent": str(task.get("direct_agent") or "")[:80],
+            }
+            direct_pid = str(task.get("direct_provider_id") or "")
+            direct_prov = providers.get(direct_pid) or {}
+            direct_keys = modelhub._provider_keys(direct_prov)
+            if direct_pid:
+                direct.update(modelhub.connection_identity(
+                    direct_pid, str((direct_keys[0] if direct_keys else {}).get("id") or "")))
+            snapshot["direct"] = direct
+    except Exception:
+        # A snapshot is diagnostic metadata.  A broken optional catalog must
+        # never prevent the task from being created.
+        snapshot.setdefault("skills", {})
+        snapshot.setdefault("knowledge", {})
+        snapshot.setdefault("agent_bindings", {})
+    return snapshot
+
+
 # run 终态集合：与 CAS 收口、状态回填共用同一份定义
 TERMINAL_STATUSES = ("done", "failed", "cancelled", "timeout")
 
@@ -589,6 +720,7 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
     if kind == "orchestration" and task_id:
         task = get_task(task_id) or {}
         run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
+        run["execution_snapshot"] = _execution_snapshot(task)
         try:
             eta = _RUN_ESTIMATOR(
                 task_type=task.get("type") or "", mode=task.get("mode") or "auto",
@@ -816,7 +948,6 @@ def update_run(run_id, expected_status=None, **fields):
                         s["summary"] = ("步骤未正常收尾（任务总时限已到）"
                                          if st == "timeout" else
                                          "步骤未正常收尾（终态自动恢复）")
-        _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         # 状态回填：起跑与结束都同步任务状态。只回填终态的话，run 在跑、
         # 任务永远显示「排队中」（2026-09-18 实案：「# 重写·续」run 已 running
         # 写了一小时，任务卡 queued，用户以为卡死连点重试）。
@@ -826,6 +957,16 @@ def update_run(run_id, expected_status=None, **fields):
             if task:
                 task["status"] = st
                 _save_json(paths.TASKS_DIR / (tid + ".json"), task)
+        if st in TERMINAL_STATUSES:
+            try:
+                from . import acceptance
+                run["acceptance"] = acceptance.evaluate_run(
+                    run, (_TASKS.get(run.get("task_id")) if run.get("task_id") else None) or {})
+            except Exception:
+                # Acceptance reporting is evidence enrichment; it must not
+                # prevent the primary run from reaching a terminal state.
+                pass
+        _save_json(paths.RUNS_DIR / run_id / "run.json", run)
         if st in TERMINAL_STATUSES and prev_status not in TERMINAL_STATUSES:
             # 事后对账：只有「非终态 → 终态」这一次翻转才记账，重复写终态
             # （UI 补写、迟到写手）不得二次入账。快照在锁内浅拷，锁外调用
@@ -1038,6 +1179,29 @@ def run_artifacts(run_id, limit=200, cache=False):
                               running=running, cache=cache)
 
 
+def run_asset_refs(run_id, limit=200):
+    """Return content-addressed references for this run's output files."""
+    wd, files = run_artifacts(run_id, limit=limit, cache=False)
+    if not wd:
+        return []
+    from . import attachments
+    refs = attachments.asset_refs(wd, [{"path": f.get("name") or f.get("path") or ""}
+                                       for f in files if isinstance(f, dict)])
+    try:
+        from . import assets
+        run = get_run(run_id) or {}
+        for ref in refs:
+            saved = assets.register(wd, ref.get("path"), owner_type="run",
+                                    owner_id=run_id, name=ref.get("name"),
+                                    mime=ref.get("mime"))
+            if saved:
+                ref.update({k: saved[k] for k in ("asset_id", "revision_id",
+                                                  "content_sha256")})
+    except Exception:
+        pass
+    return refs
+
+
 def task_step_count(task_id):
     """该任务所有 run 的步骤总数（含进行中）。
 
@@ -1529,30 +1693,47 @@ def rename_task(task_id, title):
 
 
 def update_task_params(task_id, patch):
-    """更新任务编排参数（对话条三件套：mode/thinking/direct_provider_id/direct_model）。
-    只在任务未在跑时生效——运行中改参数不会影响当前执行，静默跳过避免误导。"""
+    """更新任务编排参数（对话条三件套：mode/thinking/direct_provider_id/direct_model，
+    另有 timeout_s 任务总时限）。
+    只在任务未在跑时生效——运行中改参数不会影响当前执行，静默跳过避免误导。
+
+    修订 CAS（借鉴 WorkDSH 契约纪律 expectedRevision）：patch 携带整数
+    expected_rev 时与任务当前 rev 比对，不符=别处已先改——拒绝写入并说明，
+    不做过期覆盖；不带 expected_rev 的旧调用保持原行为。写成功 rev+1，
+    调用方（路由）从 get_task 回读新 rev 交前端续用。"""
     if not _valid_id(task_id):
         return False, "非法的任务 ID"
+    patch = dict(patch) if isinstance(patch, dict) else {}
+    expected_rev = patch.pop("expected_rev", None)
     with LOCK:
         task = _TASKS.get(task_id)
         if not task:
             return False, "任务不存在"
         if task.get("status") in ("queued", "running"):
             return False, "任务运行中，参数不可改"
+        if expected_rev is not None:
+            try:
+                want_rev = int(expected_rev)
+                cur_rev = int(task.get("rev") or 1)
+            except (TypeError, ValueError):
+                return False, "expected_rev 必须是整数"
+            if want_rev != cur_rev:
+                return False, ("任务参数已被其他窗口修改（当前修订 %d），"
+                               "已拒绝过期写入，界面稍后自动同步最新值" % cur_rev)
         changed = False
-        mode = str((patch or {}).get("mode") or "").strip()
+        mode = str(patch.get("mode") or "").strip()
         if mode in ("auto", "fast", "expert", "manual"):
             if task.get("mode") != mode:
                 task["mode"] = mode
                 changed = True
-        thinking = str((patch or {}).get("thinking") or "").strip()
+        thinking = str(patch.get("thinking") or "").strip()
         if thinking in ("auto", "low", "standard", "high"):
             if task.get("thinking") != thinking:
                 task["thinking"] = thinking
                 changed = True
         if task.get("engine") == "direct":
-            pv = str((patch or {}).get("direct_provider_id") or "").strip()[:80]
-            mv = str((patch or {}).get("direct_model") or "").strip()[:160]
+            pv = str(patch.get("direct_provider_id") or "").strip()[:80]
+            mv = str(patch.get("direct_model") or "").strip()[:160]
             if mv and not pv:
                 return False, "指定对话模型时必须同时指定厂商"
             if task.get("direct_provider_id") != pv or task.get("direct_model") != mv:
@@ -1561,17 +1742,28 @@ def update_task_params(task_id, patch):
                 changed = True
             # 执行 CLI 可改/可清（清空 = 回内置智能体或模型绑定）；与模型绑定
             # 允许共存，运行时 CLI 优先
-            av = str((patch or {}).get("direct_agent") or "").strip()[:80]
+            av = str(patch.get("direct_agent") or "").strip()[:80]
             if task.get("direct_agent") != av and (av or task.get("direct_agent")):
                 task["direct_agent"] = av
                 changed = True
+        # 任务总时限（秒）：建任务时写入，此后靠这里改——下次重试/续跑的
+        # create_run 会按它重新给满预算（2026-09-24 戍边骑奴案：12 章连载
+        # 默认 1 小时在慢链天跑不完，只能人工反复重试）。走 _task_timeout_s
+        # 统一钳制 [1s, 7天]，脏值回落默认；空闲时才可改（与三件套同闸）。
+        raw_ts = patch.get("timeout_s")
+        if raw_ts not in (None, ""):
+            new_ts = _task_timeout_s(raw_ts)
+            if task.get("timeout_s") != new_ts:
+                task["timeout_s"] = new_ts
+                changed = True
         if changed:
+            task["rev"] = int(task.get("rev") or 1) + 1
             _save_json(paths.TASKS_DIR / (task_id + ".json"), task)
             bump_state()
     return True, ""
 
 
-def add_step(run_id, role, agent_id, agent_label, note="", model=""):
+def add_step(run_id, role, agent_id, agent_label, note="", model="", provider=""):
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
@@ -1583,6 +1775,10 @@ def add_step(run_id, role, agent_id, agent_label, note="", model=""):
             # 起跑即记解析到的模型：运行中蜂巢卡/步骤列表就能看到「在用哪个模型」，
             # 不必等 finish_step 用实际结果覆盖（换将成功后以实际为准）
             "model": str(model or "")[:80],
+            # 绑定速记（借鉴 WorkDSH ResolvedExecutionBinding）：本步实际用的
+            # provider 链与上游 host——烧错配额/模型漂移直接对账步骤行。
+            # 只记身份不记密钥；老数据无此键，读取一律 .get
+            "provider": str(provider or "")[:120],
             "status": "running", "started_at": time.strftime("%H:%M:%S"),
             "ended_at": None, "duration_s": None, "exit_code": None,
             "summary": "", "log": None, "cost_usd": 0.0, "tokens": 0,