codebee 0.1.65 → 0.1.67

package/app/core/step_runner.py

@@ -1,133 +1,133 @@
-# -*- coding: utf-8 -*-
-"""Step 执行器：压缩触发的重试守门（复用已渲染 prompt，不重复组装）。
-
-设计稿：docs/migration/02-context-compaction.md §1D。
-参考 dsh packages/core/agent-loop/src/agent.ts:307-378：
-  失败重试只在「前进 surface generation」时返回 {kind:'retry'}，
-  复用已渲染 PromptAssembly，不重跑 pre-step / 组装 / 用户消息准入。
-
-Tutti 语境：runner.run_agent 自带 prompt（已渲染）；重试的风险不是重复渲染
-（prompt 是同一个字符串），而是「不压缩直接重试」必然再次撑爆。
-本模块的守门：仅当 maybe_compact 真正前进了 surface generation 才重试一次。
-"""
-from __future__ import annotations
-
-import logging
-
-from .compaction import maybe_compact, DEFAULT_PRESSURE_THRESHOLD
-from .error_codes import ErrorCode
-
-log = logging.getLogger(__name__)
-
-# 触发「压缩后重试」的错误码
-_OVERFLOW_CODES = {ErrorCode.CONTEXT_OVERFLOW, ErrorCode.MAX_TOKENS}
-
-# 事前预检阈值：最近一次调用的上下文锚点已占本步模型容量九成 → 第一个请求
-# 大概率被供应商拒。只拦「大概率必死」，不提前压缩平时的高压（used() 是累计
-# 口径，比真实上下文偏大；0.8 的响应式阈值语义与此不同，勿混用）。
-_PRECHECK_RATIO = 0.9
-
-
-def _v2_compaction_tuning():
-    """settings_v2 orchestrator.compaction 微调 → (threshold|None, retain|None)。
-
-    None = 未配置（走 maybe_compact 的模块默认）；读取/注册失败静默回落。
-    retain 允许 0（尾部不保留），与 None（未配置）语义不同，勿合并。"""
-    try:
-        from .settings_schema import get as ss_get, register_default_namespaces
-        register_default_namespaces()
-        c = (ss_get("orchestrator") or {}).get("compaction") or {}
-        th = c.get("pressure_threshold")
-        rt = c.get("retain_tail_tokens")
-        return (float(th) if th else None,
-                int(rt) if rt is not None else None)
-    except Exception:
-        return None, None
-
-
-def execute_step(session, run_agent_fn, prompt, *, model: str = "",
-                 llm_caller=None, retain_tail_tokens=None, **kwargs):
-    """执行一次 step；撑爆时压缩并守门重试一次。
-
-    事前预检（借鉴 freebuff base-chat 每步容量重估）：换将切到小窗口模型后，
-    响应式路径要等供应商报 CONTEXT_OVERFLOW 才压缩——报得不干净就直接卡死。
-    先用「最近一次调用上下文 vs 本步模型容量」判一次，超阈先压缩再发。
-
-    Args:
-        session: session_log.Session（记录 replace_generation）
-        run_agent_fn: runner.run_agent（或测试替身），签名 (prompt, **kwargs) -> dict
-        prompt: 已渲染的提示词（重试时原样复用，不重新渲染）
-        model: 本步将要使用的模型名（容量与压力估算都按它算）
-        llm_caller: 压缩摘要 LLM（None = 不压缩，永不重试）
-        **kwargs: 透传 run_agent_fn
-
-    Returns:
-        (result, retried: bool)
-    """
-    v2_th, v2_rt = _v2_compaction_tuning()
-    compact_kwargs = {}
-    if retain_tail_tokens is not None:
-        compact_kwargs["retain_tail_tokens"] = retain_tail_tokens
-    elif v2_rt is not None:
-        compact_kwargs["retain_tail_tokens"] = v2_rt
-    if v2_th is not None:
-        compact_kwargs["threshold"] = v2_th
-    if llm_caller is not None and model:
-        try:
-            from .token_meter import token_meter
-            ctx = token_meter.last_context(session.run_id)
-            cap = token_meter.capacity(model)
-            if ctx > 0 and cap > 0 and ctx > cap * _PRECHECK_RATIO:
-                gen_p0 = session.replace_generation()
-                if maybe_compact(session, model=model, llm_caller=llm_caller,
-                                 run_id=session.run_id, **compact_kwargs) \
-                        and session.replace_generation() > gen_p0:
-                    log.info("precheck: last ctx~%d > %.0f%% of cap(%s)=%d, "
-                             "compacted before step", ctx, _PRECHECK_RATIO * 100,
-                             model, cap)
-        except Exception:
-            log.debug("precheck skipped", exc_info=True)
-    gen0 = session.replace_generation()
-    result = run_agent_fn(prompt, **kwargs)
-    code = result.get("error_code") or ""
-    if code not in _OVERFLOW_CODES or llm_caller is None:
-        return result, False
-    # 撑爆 → 尝试压缩
-    compacted = maybe_compact(session, model=model, llm_caller=llm_caller,
-                              run_id=session.run_id, **compact_kwargs)
-    gen1 = session.replace_generation()
-    if not compacted or gen1 <= gen0:
-        # 压缩未发生或未前进 generation：重试必然再次撑爆，不重试
-        log.info("overflow but no compaction progress (gen %s->%s), no retry",
-                 gen0, gen1)
-        return result, False
-    # 压缩生效：surface 已折叠。**真正替换 CLI 请求上下文**（2026-09-21
-    # 清最老待深挖项：此前重试仍发原 prompt + 续旧 resume 会话——摘要只进
-    # 审计日志，CLI 看到的上下文一点没小，重试必然再爆）：
-    # ①重试 prompt 改用 session 派生转录（折叠摘要 + 近尾消息，体量骤降）；
-    # ②弃 resume（旧会话本体仍是膨胀态，续上就前功尽弃）。
-    msgs = []
-    try:
-        msgs = session.derive_messages()
-    except Exception:
-        log.debug("derive_messages failed on retry", exc_info=True)
-    kwargs2 = dict(kwargs)
-    if msgs:
-        transcript = "\n\n".join("[%s] %s" % (m.get("role"), m.get("content"))
-                                 for m in msgs)
-        if len(transcript) > 24_000:
-            transcript = transcript[-24_000:]
-        retry_prompt = transcript
-        # 本步指令必须在场：被折叠/截断掉就显式补在尾部（缺失指令比重复严重）
-        tail = transcript[-2000:]
-        if prompt[:400] not in tail:
-            retry_prompt = transcript + "\n\n" + prompt
-        kwargs2.pop("resume", None)
-        log.info("compaction advanced gen %s->%s, retrying with derived "
-                 "context (%d msgs, resume dropped)", gen0, gen1, len(msgs))
-        result2 = run_agent_fn(retry_prompt, **kwargs2)
-    else:
-        log.info("compaction advanced gen %s->%s but no surface derived, "
-                 "retrying same prompt", gen0, gen1)
-        result2 = run_agent_fn(prompt, **kwargs)
+# -*- coding: utf-8 -*-
+"""Step 执行器：压缩触发的重试守门（复用已渲染 prompt，不重复组装）。
+
+设计稿：docs/migration/02-context-compaction.md §1D。
+参考 dsh packages/core/agent-loop/src/agent.ts:307-378：
+  失败重试只在「前进 surface generation」时返回 {kind:'retry'}，
+  复用已渲染 PromptAssembly，不重跑 pre-step / 组装 / 用户消息准入。
+
+Tutti 语境：runner.run_agent 自带 prompt（已渲染）；重试的风险不是重复渲染
+（prompt 是同一个字符串），而是「不压缩直接重试」必然再次撑爆。
+本模块的守门：仅当 maybe_compact 真正前进了 surface generation 才重试一次。
+"""
+from __future__ import annotations
+
+import logging
+
+from .compaction import maybe_compact, DEFAULT_PRESSURE_THRESHOLD
+from .error_codes import ErrorCode
+
+log = logging.getLogger(__name__)
+
+# 触发「压缩后重试」的错误码
+_OVERFLOW_CODES = {ErrorCode.CONTEXT_OVERFLOW, ErrorCode.MAX_TOKENS}
+
+# 事前预检阈值：最近一次调用的上下文锚点已占本步模型容量九成 → 第一个请求
+# 大概率被供应商拒。只拦「大概率必死」，不提前压缩平时的高压（used() 是累计
+# 口径，比真实上下文偏大；0.8 的响应式阈值语义与此不同，勿混用）。
+_PRECHECK_RATIO = 0.9
+
+
+def _v2_compaction_tuning():
+    """settings_v2 orchestrator.compaction 微调 → (threshold|None, retain|None)。
+
+    None = 未配置（走 maybe_compact 的模块默认）；读取/注册失败静默回落。
+    retain 允许 0（尾部不保留），与 None（未配置）语义不同，勿合并。"""
+    try:
+        from .settings_schema import get as ss_get, register_default_namespaces
+        register_default_namespaces()
+        c = (ss_get("orchestrator") or {}).get("compaction") or {}
+        th = c.get("pressure_threshold")
+        rt = c.get("retain_tail_tokens")
+        return (float(th) if th else None,
+                int(rt) if rt is not None else None)
+    except Exception:
+        return None, None
+
+
+def execute_step(session, run_agent_fn, prompt, *, model: str = "",
+                 llm_caller=None, retain_tail_tokens=None, **kwargs):
+    """执行一次 step；撑爆时压缩并守门重试一次。
+
+    事前预检（借鉴 freebuff base-chat 每步容量重估）：换将切到小窗口模型后，
+    响应式路径要等供应商报 CONTEXT_OVERFLOW 才压缩——报得不干净就直接卡死。
+    先用「最近一次调用上下文 vs 本步模型容量」判一次，超阈先压缩再发。
+
+    Args:
+        session: session_log.Session（记录 replace_generation）
+        run_agent_fn: runner.run_agent（或测试替身），签名 (prompt, **kwargs) -> dict
+        prompt: 已渲染的提示词（重试时原样复用，不重新渲染）
+        model: 本步将要使用的模型名（容量与压力估算都按它算）
+        llm_caller: 压缩摘要 LLM（None = 不压缩，永不重试）
+        **kwargs: 透传 run_agent_fn
+
+    Returns:
+        (result, retried: bool)
+    """
+    v2_th, v2_rt = _v2_compaction_tuning()
+    compact_kwargs = {}
+    if retain_tail_tokens is not None:
+        compact_kwargs["retain_tail_tokens"] = retain_tail_tokens
+    elif v2_rt is not None:
+        compact_kwargs["retain_tail_tokens"] = v2_rt
+    if v2_th is not None:
+        compact_kwargs["threshold"] = v2_th
+    if llm_caller is not None and model:
+        try:
+            from .token_meter import token_meter
+            ctx = token_meter.last_context(session.run_id)
+            cap = token_meter.capacity(model)
+            if ctx > 0 and cap > 0 and ctx > cap * _PRECHECK_RATIO:
+                gen_p0 = session.replace_generation()
+                if maybe_compact(session, model=model, llm_caller=llm_caller,
+                                 run_id=session.run_id, **compact_kwargs) \
+                        and session.replace_generation() > gen_p0:
+                    log.info("precheck: last ctx~%d > %.0f%% of cap(%s)=%d, "
+                             "compacted before step", ctx, _PRECHECK_RATIO * 100,
+                             model, cap)
+        except Exception:
+            log.debug("precheck skipped", exc_info=True)
+    gen0 = session.replace_generation()
+    result = run_agent_fn(prompt, **kwargs)
+    code = result.get("error_code") or ""
+    if code not in _OVERFLOW_CODES or llm_caller is None:
+        return result, False
+    # 撑爆 → 尝试压缩
+    compacted = maybe_compact(session, model=model, llm_caller=llm_caller,
+                              run_id=session.run_id, **compact_kwargs)
+    gen1 = session.replace_generation()
+    if not compacted or gen1 <= gen0:
+        # 压缩未发生或未前进 generation：重试必然再次撑爆，不重试
+        log.info("overflow but no compaction progress (gen %s->%s), no retry",
+                 gen0, gen1)
+        return result, False
+    # 压缩生效：surface 已折叠。**真正替换 CLI 请求上下文**（2026-09-21
+    # 清最老待深挖项：此前重试仍发原 prompt + 续旧 resume 会话——摘要只进
+    # 审计日志，CLI 看到的上下文一点没小，重试必然再爆）：
+    # ①重试 prompt 改用 session 派生转录（折叠摘要 + 近尾消息，体量骤降）；
+    # ②弃 resume（旧会话本体仍是膨胀态，续上就前功尽弃）。
+    msgs = []
+    try:
+        msgs = session.derive_messages()
+    except Exception:
+        log.debug("derive_messages failed on retry", exc_info=True)
+    kwargs2 = dict(kwargs)
+    if msgs:
+        transcript = "\n\n".join("[%s] %s" % (m.get("role"), m.get("content"))
+                                 for m in msgs)
+        if len(transcript) > 24_000:
+            transcript = transcript[-24_000:]
+        retry_prompt = transcript
+        # 本步指令必须在场：被折叠/截断掉就显式补在尾部（缺失指令比重复严重）
+        tail = transcript[-2000:]
+        if prompt[:400] not in tail:
+            retry_prompt = transcript + "\n\n" + prompt
+        kwargs2.pop("resume", None)
+        log.info("compaction advanced gen %s->%s, retrying with derived "
+                 "context (%d msgs, resume dropped)", gen0, gen1, len(msgs))
+        result2 = run_agent_fn(retry_prompt, **kwargs2)
+    else:
+        log.info("compaction advanced gen %s->%s but no surface derived, "
+                 "retrying same prompt", gen0, gen1)
+        result2 = run_agent_fn(prompt, **kwargs)
     return result2, True

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:
@@ -554,6 +591,7 @@ def load_all():
 # ---------------------------------------------------------------- 运行（含管理操作）
 
 _RUN_ESTIMATOR = None
+_RUN_AUDITOR = None
 
 
 def set_run_estimator(estimator):
@@ -562,6 +600,110 @@ def set_run_estimator(estimator):
     _RUN_ESTIMATOR = estimator if callable(estimator) else None
 
 
+def set_run_auditor(auditor):
+    """注入 run 终态对账器（usage.audit_run），同样不让存储层依赖用量模块。"""
+    global _RUN_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")
+
+
 def create_run(kind, title, task_id=None, entry_id=None, op=None):
     run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
@@ -578,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",
@@ -776,12 +919,14 @@ def update_run(run_id, expected_status=None, **fields):
     当前状态不等于 expected_status 则拒绝写入并返回 None，
     防止陈旧执行方（被取消的 worker、崩溃恢复前的旧线程）覆盖新状态
     ——防御模式「异步状态不是同步状态」。不传则保持原行为。"""
+    audit = None
     with LOCK:
         run = _RUNS.get(run_id)
         if not run:
             return None
         if expected_status is not None and run.get("status") != expected_status:
             return None
+        prev_status = str(run.get("status") or "")
         for k in ("error", "summary"):
             if isinstance(fields.get(k), str):
                 # 错误串多是我们自己拼的 CLI 尾巴（含 ANSI/覆写/乱码墙）：
@@ -803,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，用户以为卡死连点重试）。
@@ -813,6 +957,21 @@ 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 补写、迟到写手）不得二次入账。快照在锁内浅拷，锁外调用
+            # 审计器——审计器会回读 store，锁内调用即自锁。
+            audit = dict(run)
         if st in ("done", "failed", "cancelled", "timeout"):
             # run_end 钩子（2026-09-22）：终态即触发，后台跑副作用型脚本
             # （回写知识库等）；失败/超时静默，绝不拖慢收尾路径
@@ -831,6 +990,11 @@ def update_run(run_id, expected_status=None, **fields):
     # 「在跑」直到下一次无关 bump（2026-09-22 侧栏假在跑案）。
     # 调用都是步骤级边界，不会形成推送风暴；CAS 拒绝/无此 run 的早退
     # 路径不动版本号。
+    if audit is not None and _RUN_AUDITOR is not None:
+        try:
+            _RUN_AUDITOR(audit)
+        except Exception:
+            pass    # 对账永远不能拖垮终态收尾
     bump_state()
     return run
 
@@ -1015,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 的步骤总数（含进行中）。
 
@@ -1506,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:
@@ -1538,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:
@@ -1560,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,