codebee 0.1.96 → 0.1.97

package/app/core/runner.py

@@ -1370,17 +1370,18 @@ def _attempt_protocol(att):
 
 
 def _codex_sandbox(readonly):
-    """codex 沙箱档位。写步默认 danger-full-access（2026-09-17 用户拍板「默认给全部
-    权限」）：workspace-write 禁网+禁盘外写，模型偶发还会误判沙箱受限、谎报
-    「进程执行被策略拦截」直接躺平（mo-so BUG#27596 实测，沙箱探针证明命令本可跑）。
-    只读步（评审/规划）仍 read-only——评审者可写会污染 git diff 裁决。
-    env TUTTI_CODEX_SANDBOX 可钉死某档（workspace-write / read-only / danger-full-access）。"""
+    """Return the narrowest supported Codex sandbox mode.
+
+    A full-access override defeats task-level filesystem policy and checkpoints;
+    ignore the former ``danger-full-access`` value even if it remains in the
+    user's environment. Read-only review steps must not be able to mutate files.
+    """
     if readonly:
         return "read-only"
     env = os.environ.get("TUTTI_CODEX_SANDBOX", "").strip().lower()
-    if env in ("workspace-write", "read-only", "danger-full-access"):
+    if env in ("workspace-write", "read-only"):
         return env
-    return "danger-full-access"
+    return "workspace-write"
 
 
 def _prompt_to_file(prompt, workdir):

package/app/core/settings.py

@@ -14,8 +14,9 @@ _FILE = paths.DATA_DIR / "settings.json"
 # default_workdir 为空表示未自定义，用 builtin_workdir() 回落；
 # telemetry_errors：匿名错误回传开关（默认开；关掉后版本 ping/错误上传/诊断包遥测部分全部停发，
 # 「导出诊断包」是用户手动操作不受此开关限制）
-# publish_daily_cap / publish_fail_streak：自动发布护栏——每任务每平台每日
-# 成功发章上限、平台连续失败几次后暂停自动发布（publish/auto.py 读取）
+# publish_daily_cap / publish_fail_streak / publish_fail_window_h：自动发布护栏——
+# 每任务每平台每日成功发章上限、平台连续失败几次后暂停自动发布、连败只统计
+# 最近多少小时内的失败（跨天旧失败不进「连续」口径）（publish/auto.py 读取）
 # pet_enabled / pet_mode：桌面蜜蜂（app/pet.py）开关与显示模式（默认关，设置页
 # 可开）。关闭后看护线程不再拉起、在岗蜜蜂轮询到 false 自行退出；mode=always
 # 不再拉起、在岗蜜蜂轮询到 false 自行退出；mode=always 常驻，tasks_only 仅任务
@@ -28,7 +29,8 @@ _FILE = paths.DATA_DIR / "settings.json"
 DEFAULTS = {"max_concurrent_jobs": 12, "default_workdir": "", "hooks_token": "",
             "hooks_signing_secret": "",
             "telemetry_errors": True, "publish_daily_cap": 10,
-            "publish_fail_streak": 3, "notify_webhook": "", "notify_base_url": "",
+            "publish_fail_streak": 3, "publish_fail_window_h": 12,
+            "notify_webhook": "", "notify_base_url": "",
             "notify_bark_server": "", "notify_bark_key": "",
             "notify_ntfy_topic": "", "notify_serverchan_key": "",
             "notify_telegram_token": "", "notify_telegram_chat_id": "",
@@ -142,14 +144,20 @@ def save(patch):
             cur["telemetry_errors"] = bool(patch.get("telemetry_errors"))
         if "publish_daily_cap" in patch:
             try:
-                cur["publish_daily_cap"] = max(1, min(50, int(patch.get("publish_daily_cap"))))
+                v = int(patch.get("publish_daily_cap"))
             except (TypeError, ValueError):
-                return cur, "publish_daily_cap 必须是 1-50 的整数"
+                return cur, "publish_daily_cap 必须是 0-50 的整数（0=不限制）"
+            cur["publish_daily_cap"] = max(0, min(50, v))
         if "publish_fail_streak" in patch:
             try:
                 cur["publish_fail_streak"] = max(1, min(10, int(patch.get("publish_fail_streak"))))
             except (TypeError, ValueError):
                 return cur, "publish_fail_streak 必须是 1-10 的整数"
+        if "publish_fail_window_h" in patch:
+            try:
+                cur["publish_fail_window_h"] = max(1, min(168, float(patch.get("publish_fail_window_h"))))
+            except (TypeError, ValueError):
+                return cur, "publish_fail_window_h 必须是 1-168 的数字"
         if "notify_webhook" in patch:
             cur["notify_webhook"] = str(patch.get("notify_webhook") or "").strip()[:300]
         if "notify_base_url" in patch:

package/app/core/settings_schema.py

@@ -223,8 +223,8 @@ def register_default_namespaces():
         register_namespace(
             "orchestrator",
             fields=[
-                FieldDef("compaction.enabled", "bool", False,
-                         "上下文压缩总开关（灰度：与 TUTTI_COMPACTION 任一开启即生效）"),
+                FieldDef("compaction.enabled", "bool", True,
+                         "上下文压缩总开关（默认开启；可在设置页或用 TUTTI_COMPACTION=0 关闭）"),
                 FieldDef("compaction.pressure_threshold", "float", 0.8,
                          "触发压缩的压力比阈值",
                          clamp=(0.1, 0.99)),
@@ -259,6 +259,17 @@ def register_default_namespaces():
             ],
             validate=lambda v: None,
         )
+
+    # Revision 1 is the pre-release schema default (disabled). Values written
+    # by mutate() advance the namespace to revision 2+, so preserve an explicit
+    # user opt-out while migrating untouched installations to the new default.
+    with _LOCK:
+        orchestrator = _VALUES.get("orchestrator", {})
+        if (_REVISIONS.get("orchestrator") == 1 and
+                _get_path(orchestrator, "compaction.enabled") is False):
+            _set_path(orchestrator, "compaction.enabled", True)
+            _REVISIONS["orchestrator"] = 2
+            _persist()
     if "cascade" not in _NAMESPACES:
         register_namespace(
             "cascade",
@@ -268,4 +279,4 @@ def register_default_namespaces():
                          "FrugalGPT 式级联：easy 任务按 tier 升序重排模型链（需供应商声明 tier）"),
             ],
             validate=lambda v: None,
-        )
+        )

package/app/core/store.py

@@ -180,15 +180,13 @@ def create_task(payload):
         "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
         "status": "created",
     }
-    # Keep the execution policy with the task so runners and integrations
-    # share one bounded, auditable contract. Legacy tasks remain permissive.
+    # Every new task must persist one verified execution policy. If policy
+    # normalization fails, do not silently replace it with a broader default.
     try:
         from . import policy
         task["sandbox"] = policy.normalize_sandbox(payload.get("sandbox"), wd)
-    except Exception:
-        task["sandbox"] = {"allowed_roots": [str(wd)], "env_allowlist": [],
-                            "network": True, "timeout_s": 3600,
-                            "max_output_bytes": 10 * 1024 * 1024}
+    except Exception as exc:
+        raise ValueError("沙箱策略无法验证，任务未创建") from exc
     thinking = str(payload.get("thinking") or "standard").strip().lower()
     task["thinking"] = thinking if thinking in ("auto", "low", "standard", "high") else "auto"
     # 流程修订出处（借鉴 WorkDSH ADR-0010）：创建时钉住当时流程定义的指纹。
@@ -1747,6 +1745,23 @@ def retry_task(task_id):
                         "chapter_scores": scores,
                     }
                     break
+        else:
+            # 断点续跑（代码等非连载任务，A+B）：上一遍失败/取消/超时 run 的
+            # 实现会话（inherit_session，跨 run 续 CLI 会话）与断点简报
+            # （handoff，走到哪/改了什么/还剩什么）继承给新 run——重试从断点
+            # 继续而不是从零烧 token。done 的 run 不继承：主动重跑语义就是重来。
+            prev_runs = sorted((r for r in _RUNS.values()
+                                if r.get("task_id") == task_id and r["id"] != run["id"]),
+                               key=lambda r: r["id"], reverse=True)
+            for prev in prev_runs:
+                if prev.get("status") not in ("failed", "cancelled", "timeout"):
+                    continue
+                if prev.get("impl_session") and "inherit_session" not in run:
+                    run["inherit_session"] = dict(prev["impl_session"])
+                if prev.get("handoff") and "handoff" not in run:
+                    run["handoff"] = dict(prev["handoff"])
+                if "inherit_session" in run or "handoff" in run:
+                    break
         task["status"] = "queued"
         _save_json(paths.TASKS_DIR / (task_id + ".json"), task)
         _save_json(paths.RUNS_DIR / run["id"] / "run.json", run)

package/app/core/tool_outputs.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""Bounded, run-scoped storage for large tool results omitted from model context."""
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import stat
+from pathlib import Path
+
+from . import paths
+
+_DIR = paths.DATA_DIR / "tool_outputs"
+_REF_RE = re.compile(r"^[a-f0-9]{32}$")
+MAX_RESULT_BYTES = 4 * 1024 * 1024
+MAX_RUN_BYTES = 32 * 1024 * 1024
+MAX_READ_CHARS = 20000
+
+
+def _run_dir(run_id):
+    return _DIR / hashlib.sha256(str(run_id or "").encode("utf-8")).hexdigest()
+
+
+def save(run_id, call_id, content):
+    """Store one output and return an opaque reference, or empty string on limits/errors."""
+    if not str(run_id or "").strip():
+        return ""
+    raw = str(content or "").encode("utf-8", errors="replace")
+    if len(raw) > MAX_RESULT_BYTES:
+        return ""
+    run_dir = _run_dir(run_id)
+    ref = hashlib.sha256((str(call_id or "") + "\0").encode("utf-8") + raw).hexdigest()[:32]
+    try:
+        _DIR.mkdir(parents=True, exist_ok=True)
+        run_dir.mkdir(mode=0o700, exist_ok=True)
+        if run_dir.is_symlink() or (hasattr(run_dir, "is_junction") and run_dir.is_junction()):
+            return ""
+        target = run_dir / (ref + ".txt")
+        if target.exists():
+            return ref if target.is_file() and not target.is_symlink() else ""
+        total = sum(p.stat().st_size for p in run_dir.glob("*.txt") if p.is_file())
+        if total + len(raw) > MAX_RUN_BYTES:
+            return ""
+        flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
+        flags |= getattr(os, "O_NOFOLLOW", 0)
+        fd = os.open(str(target), flags, 0o600)
+        try:
+            if not stat.S_ISREG(os.fstat(fd).st_mode):
+                return ""
+            with os.fdopen(fd, "wb", closefd=False) as handle:
+                handle.write(raw)
+                handle.flush()
+        finally:
+            os.close(fd)
+        return ref
+    except (OSError, ValueError):
+        return ""
+
+
+def read(run_id, ref, *, offset=0, limit=MAX_READ_CHARS):
+    """Read a bounded slice, scoped to a single run and an opaque content reference."""
+    if not str(run_id or "").strip() or not _REF_RE.fullmatch(str(ref or "")):
+        return {"ok": False, "error": "工具结果引用无效"}
+    run_dir = _run_dir(run_id)
+    if run_dir.is_symlink() or (hasattr(run_dir, "is_junction") and run_dir.is_junction()):
+        return {"ok": False, "error": "工具结果存储路径不安全"}
+    target = run_dir / (str(ref) + ".txt")
+    if target.is_symlink() or (hasattr(target, "is_junction") and target.is_junction()):
+        return {"ok": False, "error": "工具结果存储路径不安全"}
+    try:
+        offset = max(0, int(offset or 0))
+        limit = max(1, min(MAX_READ_CHARS, int(limit or MAX_READ_CHARS)))
+        with target.open("rb") as handle:
+            handle.seek(offset)
+            raw = handle.read(limit * 4 + 4)
+            text = raw.decode("utf-8", errors="replace")[:limit]
+            end = handle.tell()
+            handle.seek(0, os.SEEK_END)
+            size = handle.tell()
+        return {"ok": True, "text": text, "offset": offset,
+                "next_offset": end if end < size else None, "size_bytes": size}
+    except (OSError, ValueError, TypeError):
+        return {"ok": False, "error": "找不到此运行中的工具结果引用"}
+
+
+def matches_compacted_output(run_id, call_id, ref, head, tail):
+    """Verify a compacted preview belongs to this call and stored full output."""
+    if not str(run_id or "").strip() or not _REF_RE.fullmatch(str(ref or "")):
+        return False
+    run_dir = _run_dir(run_id)
+    if run_dir.is_symlink() or (hasattr(run_dir, "is_junction") and run_dir.is_junction()):
+        return False
+    target = run_dir / (str(ref) + ".txt")
+    if target.is_symlink() or (hasattr(target, "is_junction") and target.is_junction()):
+        return False
+    try:
+        if target.stat().st_size > MAX_RESULT_BYTES:
+            return False
+        raw = target.read_bytes()
+        expected_ref = hashlib.sha256(
+            (str(call_id or "") + "\0").encode("utf-8") + raw).hexdigest()[:32]
+        if expected_ref != ref:
+            return False
+        return (raw.startswith(str(head or "").encode("utf-8", errors="replace"))
+                and raw.endswith(str(tail or "").encode("utf-8", errors="replace")))
+    except (OSError, ValueError):
+        return False

package/app/core/wxdigest.py

@@ -358,7 +358,14 @@ def _summarize(cfg, group, window, watch):
         m["ts"], m["sender"] or "?", m["text"].replace("\n", " ")) for m in window)
     prompt = _PROMPT % (group, len(window), body)
     # 工作目录用专用空目录而非监控文件夹：见 _scratch_dir 的说明
-    r = builtin_agent.run(bi, prompt, workdir=str(_scratch_dir()), timeout=240)
+    scratch = str(_scratch_dir())
+    from . import builtin_agent as _builtin_agent
+    disabled_tools = [str(tool.get("name") or "") for tool in _builtin_agent.TOOLS_SPEC]
+    disabled_tools.extend(["create_task", "read_tool_output"])
+    r = builtin_agent.run(
+        bi, prompt, workdir=scratch, timeout=240,
+        sandbox={"allowed_roots": [scratch], "network": False,
+                 "disabled_tools": disabled_tools})
     if not r.get("ok"):
         raise RuntimeError(r.get("error") or "模型调用失败")
     text = (r.get("text") or "").strip()

package/app/main.py

@@ -286,6 +286,13 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/board":
                 # 任务驾驶舱大屏的轻量聚合（KB 级；别让它去拉 /api/state 全量）
                 return self._json(200, board.payload())
+            if path == "/api/board/run":
+                # 大屏下钻抽屉的步骤链：点开才拉，不进 /api/board 的 8 秒缓存
+                rid = (parse_qs(urlparse(self.path).query).get("run_id") or [""])[0]
+                detail = board.run_detail(rid)
+                if not detail:
+                    return self._json(404, {"error": "not found"})
+                return self._json(200, detail)
             if path == "/api/analytics":
                 from core import analytics
                 return self._json(200, analytics.summary(store))
@@ -341,6 +348,16 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/knowledge":
                 from core import knowledge
                 return self._json(200, knowledge.view())
+            m = re.match(r"^/api/tasks/([^/]+)/memory$", path)
+            if m:
+                task = store.get_task(m.group(1))
+                if not task:
+                    return self._json(404, {"error": "not found"})
+                from core import project_memory
+                try:
+                    return self._json(200, {"entries": project_memory.list_entries(task.get("workdir"))})
+                except (OSError, ValueError) as exc:
+                    return self._json(409, {"error": str(exc)})
             if path == "/api/agents/presence":
                 from core import presence
                 return self._json(200, {"agents": presence.list_agents()})
@@ -592,7 +609,11 @@ class Handler(BaseHTTPRequestHandler):
                 if not store.get_run(m.group(1)):
                     return self._json(404, {"error": "not found"})
                 from core import checkpoints
-                return self._json(200, {"checkpoint": checkpoints.replay_preview(m.group(1))})
+                run = store.get_run(m.group(1)) or {}
+                task = store.get_task(run.get("task_id")) or {}
+                return self._json(200, {
+                    "checkpoint": checkpoints.replay_preview(m.group(1)),
+                    "files": checkpoints.snapshot_preview(m.group(1), task.get("workdir") or "")})
             m = re.match(r"^/api/runs/([^/]+)/preview$", path)
             if m:
                 # 网页成品预览：入口 HTML + 同目录代码文件（前端渲染「预览」页签）
@@ -886,6 +907,22 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(200, {"ok": ok, "output": out})
         if path == "/api/tasks/clarify":
             return self._api_task_clarify()
+        m = re.match(r"^/api/tasks/([^/]+)/memory$", path)
+        if m:
+            task = store.get_task(m.group(1))
+            if not task:
+                return self._json(404, {"error": "not found"})
+            body = self._body() or {}
+            from core import project_memory
+            try:
+                row = project_memory.decide(task.get("workdir"), body.get("id"),
+                                            body.get("action"),
+                                            expected_version=body.get("expected_version"))
+                return self._json(200, {"entry": row})
+            except KeyError as exc:
+                return self._json(404, {"error": str(exc)})
+            except (OSError, TypeError, ValueError) as exc:
+                return self._json(400, {"error": str(exc)})
         if path == "/api/agents/presence":
             from core import presence
             body = self._body() or {}
@@ -1247,6 +1284,35 @@ class Handler(BaseHTTPRequestHandler):
         m = re.match(r"^/api/(tasks|runs)/([^/]+)/reveal$", path)
         if m:
             return self._api_reveal(m.group(1), m.group(2))
+        m = re.match(r"^/api/runs/([^/]+)/checkpoints/restore$", path)
+        if m:
+            if not bool((self._body() or {}).get("confirm")):
+                return self._json(400, {"error": "文件恢复会覆盖检查点记录的文件，请确认 confirm=true 后重试"})
+            run = store.get_run(m.group(1))
+            if not run:
+                return self._json(404, {"error": "not found"})
+            if run.get("status") not in ("done", "failed", "cancelled", "timeout"):
+                return self._json(409, {"error": "任务仍在运行或排队；请先停止并等待终态后再恢复文件"})
+            task = store.get_task(run.get("task_id")) or {}
+            if not task.get("workdir"):
+                return self._json(409, {"error": "任务工作目录不可用，拒绝恢复"})
+            from core import checkpoints
+            # Serialize the final safety check and file restore with run creation
+            # and status transitions. Otherwise a new run can start on this task
+            # after the terminal check and race with restoration in the same tree.
+            with store.LOCK:
+                current = store.get_run(m.group(1)) or {}
+                task = store.get_task(current.get("task_id")) or {}
+                latest = store.latest_run_by_task().get(current.get("task_id")) or {}
+                terminal = ("done", "failed", "cancelled", "timeout")
+                if current.get("status") not in terminal:
+                    return self._json(409, {"error": "任务状态已变化；请等待终态后再恢复文件"})
+                task_active = task.get("status") in ("queued", "running")
+                newer_run_active = latest.get("status") in ("queued", "running")
+                if task_active or newer_run_active:
+                    return self._json(409, {"error": "该任务已有运行中的新任务；请等待其结束后再恢复文件"})
+                return self._json(200, checkpoints.restore_files(
+                    m.group(1), task.get("workdir") or ""))
         m = re.match(r"^/api/runs/([^/]+)/messages$", path)
         if m:
             return self._api_add_message(m.group(1))
@@ -3057,8 +3123,16 @@ class Handler(BaseHTTPRequestHandler):
                   '[{"q": "问题", "options": ["选项1", "选项2"]}]' % (ttype, goal[:200]))
         try:
             # 澄清是可选增强，不能占住创建请求；主流程有自己的执行超时。
+            # 此调用只负责生成问题，不得继承完整执行工具权限或访问网络。
+            from core import policy
+            clarify_sandbox = policy.normalize_sandbox({
+                "network": False,
+                "disabled_tools": ["run_command", "write_file", "edit_file",
+                                   "append_file", "fs_manage", "create_task",
+                                   "read_tool_output"],
+            }, os.getcwd() if hasattr(os, "getcwd") else ".")
             res = builtin_agent.run(bi, prompt, os.getcwd() if hasattr(os, "getcwd") else ".",
-                                    timeout=8)
+                                    timeout=8, sandbox=clarify_sandbox)
             import json as _json
             arr = None
             text = (res.get("text") or "").strip()