codebee 0.1.67 → 0.1.68

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

@@ -18,7 +18,7 @@ import threading
 import time
 from pathlib import Path
 
-from . import artifacts, paths, runner, volumes
+from . import artifacts, paths, runner, tracing, volumes
 
 LOCK = threading.RLock()
 _TASKS = {}
@@ -30,9 +30,12 @@ _STREAM_LOCK = threading.Lock()
 _STREAM_TS = {}
 LIVE_TEXT_MAX = 20000   # 单步骤实时思考/正文的保留上限（与 builtin_agent 同口径）
 
-DEFAULT_TASK_TIMEOUT_S = 3600
-MIN_TASK_TIMEOUT_S = 1
-MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
+DEFAULT_TASK_TIMEOUT_S = 3600
+MIN_TASK_TIMEOUT_S = 1
+MAX_TASK_TIMEOUT_S = 7 * 24 * 3600
+REVIEW_TASK_TIMEOUT_S = 7200
+LONG_TASK_TIMEOUT_S = 14400
+SERIAL_EXTRA_CHAPTER_S = 1800
 
 # ---------------------------------------------------------------- 状态版本（SSE 事件驱动）
 # 任何落盘写都算状态变化：SSE 连接等版本号变化才构建/推送全量状态，
@@ -83,7 +86,7 @@ def _safe_name(s):
     return re.sub(r"[^0-9A-Za-z_-]+", "-", str(s))[:40].strip("-") or "x"
 
 
-def _task_timeout_s(value=None):
+def _task_timeout_s(value=None):
     """Resolve one bounded wall-clock budget for a task."""
     raw = value
     if raw in (None, ""):
@@ -92,7 +95,27 @@ def _task_timeout_s(value=None):
         seconds = int(float(raw))
     except (TypeError, ValueError):
         seconds = DEFAULT_TASK_TIMEOUT_S
-    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
+    return max(MIN_TASK_TIMEOUT_S, min(MAX_TASK_TIMEOUT_S, seconds))
+
+
+def _default_timeout_s(task):
+    """Choose a bounded default from the amount of work, not one hour for all."""
+    env_value = os.environ.get("TUTTI_TASK_TIMEOUT_S")
+    if env_value not in (None, ""):
+        return _task_timeout_s(env_value)
+    serial = task.get("serial")
+    if isinstance(serial, dict) and serial.get("chapters"):
+        try:
+            chapters = max(1, min(20, int(serial["chapters"])))
+        except (TypeError, ValueError):
+            chapters = 8
+        return min(MAX_TASK_TIMEOUT_S,
+                   LONG_TASK_TIMEOUT_S + max(0, chapters - 8) * SERIAL_EXTRA_CHAPTER_S)
+    if task.get("engine") == "code":
+        return LONG_TASK_TIMEOUT_S
+    if task.get("engine") == "review":
+        return REVIEW_TASK_TIMEOUT_S
+    return DEFAULT_TASK_TIMEOUT_S
 
 
 # ---------------------------------------------------------------- 任务
@@ -159,7 +182,6 @@ 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 能给出明确诊断而非静默换新。
@@ -234,11 +256,11 @@ def create_task(payload):
         if serial_value is None or (isinstance(serial_value, dict) and
                                     serial_value.get("enabled") is False):
             serial = None
-        elif isinstance(serial_value, dict):
-            serial = serial_value
-        else:
-            serial = flow.get("serial")
-        if isinstance(serial, dict) and serial.get("chapters"):
+        elif isinstance(serial_value, dict):
+            serial = serial_value
+        else:
+            serial = flow.get("serial")
+        if isinstance(serial, dict) and serial.get("chapters"):
             try:
                 s = {
                     # 续写批次允许只续 1 章，下限放宽到 1（全新连载仍由前端约束 ≥2）
@@ -290,10 +312,13 @@ def create_task(payload):
                 if vol_spec:
                     s["volumes"] = vol_spec
                 vper = volumes.norm_per(serial.get("volume_chapters"))
-                if vper:
-                    s["volume_chapters"] = vper
-                task["serial"] = s
-    critics = payload.get("critics")
+                if vper:
+                    s["volume_chapters"] = vper
+                task["serial"] = s
+    raw_timeout = payload.get("timeout_s")
+    task["timeout_s"] = (_task_timeout_s(raw_timeout)
+                         if raw_timeout not in (None, "") else _default_timeout_s(task))
+    critics = payload.get("critics")
     if isinstance(critics, list) and critics:
         task["critics"] = [str(c) for c in critics]
     # 初始故事圣经必须在任务入队前落盘，保证首个章节步骤就能读到设定。
@@ -704,8 +729,8 @@ def _execution_snapshot(task):
 TERMINAL_STATUSES = ("done", "failed", "cancelled", "timeout")
 
 
-def create_run(kind, title, task_id=None, entry_id=None, op=None):
-    run = {
+def create_run(kind, title, task_id=None, entry_id=None, op=None):
+    run = {
         "id": _new_id("r" if kind == "orchestration" else "m"),
         "kind": kind,  # orchestration | mgmt
         "title": title,
@@ -715,11 +740,19 @@ def create_run(kind, title, task_id=None, entry_id=None, op=None):
         "started_at": None, "ended_at": None,
         "deadline_at": None,
         "cost_usd": 0.0, "tokens": 0, "error": "",
-        "verdict": None, "summary": "",
-    }
-    if kind == "orchestration" and task_id:
-        task = get_task(task_id) or {}
-        run["deadline_at"] = time.time() + _task_timeout_s(task.get("timeout_s"))
+        "verdict": None, "summary": "",
+    }
+    # Persist trace identity at run creation so replay remains stable across
+    # process restarts and legacy readers can still use the normal run shape.
+    run["trace_schema_version"] = tracing.SCHEMA_VERSION
+    run["trace_id"] = tracing.trace_id(run["id"])
+    run["root_span_id"] = tracing.root_span_id(run["id"])
+    if kind == "orchestration" and task_id:
+        task = get_task(task_id) or {}
+        run["timeout_budget_s"] = _task_timeout_s(task.get("timeout_s"))
+        # Provisional for direct callers; jobs resets it at worker claim so
+        # queued/backoff time does not shorten the actual execution budget.
+        run["deadline_at"] = time.time() + run["timeout_budget_s"]
         run["execution_snapshot"] = _execution_snapshot(task)
         try:
             eta = _RUN_ESTIMATOR(
@@ -1746,10 +1779,9 @@ def update_task_params(task_id, patch):
             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天]，脏值回落默认；空闲时才可改（与三件套同闸）。
+        # 任务总时限（秒）：建任务时按工作量给默认值，此处支持空闲时显式改。
+        # 下次重试/续跑按新值重新给预算；已在跑的 run 保持原截止时间。
+        # 统一钳制 [1s, 7天]，脏值回落基础默认。
         raw_ts = patch.get("timeout_s")
         if raw_ts not in (None, ""):
             new_ts = _task_timeout_s(raw_ts)
@@ -1769,7 +1801,7 @@ def add_step(run_id, role, agent_id, agent_label, note="", model="", provider=""
         if not run:
             return None, None
         n = len(run["steps"]) + 1
-        step = {
+        step = {
             "n": n, "role": role, "agent": agent_id, "agent_label": agent_label,
             "note": note,
             # 起跑即记解析到的模型：运行中蜂巢卡/步骤列表就能看到「在用哪个模型」，
@@ -1779,8 +1811,13 @@ def add_step(run_id, role, agent_id, agent_label, note="", model="", provider=""
             # 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,
+            "status": "running", "started_at": time.strftime("%H:%M:%S"),
+            "started_at_epoch": time.time(),
+            "trace_id": str(run.get("trace_id") or tracing.trace_id(run_id)),
+            "span_id": tracing.span_id(run_id, n),
+            "parent_span_id": str(run.get("root_span_id") or
+                                   tracing.root_span_id(run_id)),
+            "ended_at": None, "duration_s": None, "exit_code": None,
             "summary": "", "log": None, "cost_usd": 0.0, "tokens": 0,
         }
         run["steps"].append(step)
@@ -1850,8 +1887,9 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
             return
         for s in run["steps"]:
             if s["n"] == n:
-                s["status"] = status
-                s["ended_at"] = time.strftime("%H:%M:%S")
+                s["status"] = status
+                s["ended_at"] = time.strftime("%H:%M:%S")
+                s["ended_at_epoch"] = time.time()
                 # 步骤摘要是 CLI 文本的汇聚点（失败时=错误尾巴，成功时=智能体结论）：
                 # 落盘前统一清洗，避免 ANSI/覆写/乱码墙进 UI 与报告
                 s["summary"] = runner.clean_cli_text(summary)
@@ -1860,8 +1898,11 @@ def finish_step(run_id, n, status, summary="", exit_code=None,
                 s["tokens"] = tokens
                 if model:
                     s["model"] = str(model)[:80]
-                if duration_s is not None:
-                    s["duration_s"] = round(duration_s, 1)
+                if duration_s is not None:
+                    s["duration_s"] = round(duration_s, 1)
+                elif s.get("started_at_epoch") is not None:
+                    s["duration_s"] = round(max(
+                        0.0, s["ended_at_epoch"] - s["started_at_epoch"]), 1)
                 if output is not None:
                     # output 是智能体正文（对话气泡直读）：只剥 ANSI，不做噪声折叠
                     # ——正文里的装饰性长串是作者写的，不能替它省略