proteus-evolve 0.2.0__tar.gz → 0.3.0__tar.gz

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proteus-evolve
-Version: 0.2.0
+Version: 0.3.0
 Summary: A harness-agnostic driver for measuring agent self-evolution: plug in any harness × model, evolve it under goal or no-goal conditions, and measure how the harness changes.
 Author: Proteus Authors
 License-Expression: MIT
@@ -47,7 +47,7 @@ Dynamic: license-file
   <a href="https://github.com/proteus-evolve/Proteus/actions/workflows/release-smoke.yml"><img src="https://github.com/proteus-evolve/Proteus/actions/workflows/release-smoke.yml/badge.svg" alt="release smoke"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License"></a>
   <img src="https://img.shields.io/badge/python-3.10%2B-blue.svg" alt="Python 3.10+">
-  <img src="https://img.shields.io/badge/version-0.2.0-informational.svg" alt="v0.2.0">
+  <img src="https://img.shields.io/badge/version-0.3.0-informational.svg" alt="v0.3.0">
   <img src="https://img.shields.io/badge/status-research%20preview-orange.svg" alt="research preview">
 </p>
 
@@ -60,7 +60,7 @@ Dynamic: license-file
   <a href="docs/RECIPES.md">Recipes</a> •
   <a href="docs/BENCHMARKS.md">Bring a Benchmark</a> •
   <a href="docs/MEASUREMENTS.md">Add a Measurement</a> •
-  <a href="docs/releases/v0.2.0.md">v0.2.0 Notes</a> •
+  <a href="docs/releases/v0.3.0.md">v0.3.0 Notes</a> •
   <a href="environments/README.md">Environments</a> •
   <a href="#-measurement">Measurement</a>
 </p>
@@ -307,11 +307,12 @@ roots, so the evolving agent can never read its own condition.
 
 ## 📊 Status
 
-`v0.2.0` (research preview). Working today: the offline `minimal` harness; the live `llm`
+`v0.3.0` (research preview). Working today: the offline `minimal` harness; the live `llm`
 harness; pinned, source-evolving DeepSeek Harness and Pi adapters with frozen per-episode
 activation, automatic rollback, exact-tree boundary gates, rebuild caching, turn budgets,
-and task mounts; the Aki research adapter;
-local, Polyglot, and SWE-bench task integrations; resume-safe sweeps; the full measurement,
+phase-aware act-priority budget plans and agent-authored checkpoint tracking, and task
+mounts; the Aki research adapter; local, Polyglot, and SWE-bench task integrations;
+resume-safe sweeps; the full measurement,
 audit, reliability, report, and repository-export paths; and adapter/environment tooling.
 CI covers Python 3.10–3.14. The separate release-smoke workflow runs two episodes across
 the public release set (`minimal`, `llm`, `dsh`, `pi`), exercises the benchmark path, and
@@ -341,8 +342,9 @@ Where help is wanted, in one line each — the full list with difficulty tags is
 
 - **More harnesses** — Hermes Agent first (Python, built-in self-improvement surfaces),
   then SWE-agent, OpenClaw, Codex CLI, OpenHands, OpenCode, Goose.
-- **More benchmarks** — lightweight offline packs (HumanEval, MBPP, BigCodeBench-lite),
-  SWE-bench Lite/Verified wiring, and finishing sandboxed grading for `swe`.
+- **More benchmarks** — BigCodeBench-lite and a LiveCodeBench subset, SWE-bench
+  Lite/Verified wiring, and finishing sandboxed grading for `swe` (HumanEval and MBPP
+  are shipped).
 - **Analysis** — `proteus compare` for side-by-side arms/runs; an episode-atlas view.
 - **Reproducibility & cost** — per-episode token/cost accounting; one-command reproduce.
 

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/README.md

@@ -13,7 +13,7 @@
   <a href="https://github.com/proteus-evolve/Proteus/actions/workflows/release-smoke.yml"><img src="https://github.com/proteus-evolve/Proteus/actions/workflows/release-smoke.yml/badge.svg" alt="release smoke"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="MIT License"></a>
   <img src="https://img.shields.io/badge/python-3.10%2B-blue.svg" alt="Python 3.10+">
-  <img src="https://img.shields.io/badge/version-0.2.0-informational.svg" alt="v0.2.0">
+  <img src="https://img.shields.io/badge/version-0.3.0-informational.svg" alt="v0.3.0">
   <img src="https://img.shields.io/badge/status-research%20preview-orange.svg" alt="research preview">
 </p>
 
@@ -26,7 +26,7 @@
   <a href="docs/RECIPES.md">Recipes</a> •
   <a href="docs/BENCHMARKS.md">Bring a Benchmark</a> •
   <a href="docs/MEASUREMENTS.md">Add a Measurement</a> •
-  <a href="docs/releases/v0.2.0.md">v0.2.0 Notes</a> •
+  <a href="docs/releases/v0.3.0.md">v0.3.0 Notes</a> •
   <a href="environments/README.md">Environments</a> •
   <a href="#-measurement">Measurement</a>
 </p>
@@ -273,11 +273,12 @@ roots, so the evolving agent can never read its own condition.
 
 ## 📊 Status
 
-`v0.2.0` (research preview). Working today: the offline `minimal` harness; the live `llm`
+`v0.3.0` (research preview). Working today: the offline `minimal` harness; the live `llm`
 harness; pinned, source-evolving DeepSeek Harness and Pi adapters with frozen per-episode
 activation, automatic rollback, exact-tree boundary gates, rebuild caching, turn budgets,
-and task mounts; the Aki research adapter;
-local, Polyglot, and SWE-bench task integrations; resume-safe sweeps; the full measurement,
+phase-aware act-priority budget plans and agent-authored checkpoint tracking, and task
+mounts; the Aki research adapter; local, Polyglot, and SWE-bench task integrations;
+resume-safe sweeps; the full measurement,
 audit, reliability, report, and repository-export paths; and adapter/environment tooling.
 CI covers Python 3.10–3.14. The separate release-smoke workflow runs two episodes across
 the public release set (`minimal`, `llm`, `dsh`, `pi`), exercises the benchmark path, and
@@ -307,8 +308,9 @@ Where help is wanted, in one line each — the full list with difficulty tags is
 
 - **More harnesses** — Hermes Agent first (Python, built-in self-improvement surfaces),
   then SWE-agent, OpenClaw, Codex CLI, OpenHands, OpenCode, Goose.
-- **More benchmarks** — lightweight offline packs (HumanEval, MBPP, BigCodeBench-lite),
-  SWE-bench Lite/Verified wiring, and finishing sandboxed grading for `swe`.
+- **More benchmarks** — BigCodeBench-lite and a LiveCodeBench subset, SWE-bench
+  Lite/Verified wiring, and finishing sandboxed grading for `swe` (HumanEval and MBPP
+  are shipped).
 - **Analysis** — `proteus compare` for side-by-side arms/runs; an episode-atlas view.
 - **Reproducibility & cost** — per-episode token/cost accounting; one-command reproduce.
 

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/proteus/__init__.py

@@ -1,2 +1,2 @@
 """Proteus — a harness-agnostic framework for agent self-evolution."""
-__version__ = "0.2.0"
+__version__ = "0.3.0"

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/proteus/adapters/aki.py

@@ -19,7 +19,8 @@ The adapter never writes into the Aki checkout; all state lands in the Proteus r
 Known limits, stated rather than papered over:
 - Aki's phase prompts live inside the harness (`loop.py`), so `spec.phase_prompts` is not
   injected into the episode yet; no-goal runs — the paper's primary regime — are fully
-  supported, goal-text injection into Aki episodes is not wired.
+  supported, while the framework default epistemic protocol and goal-text injection are
+  not wired into Aki episodes. Other bundled adapters consume `spec.phase_prompts`.
 - Aki couples seeding and disposition install in one `init_run`, so this adapter performs
   both inside `install_disposition` (the framework calls `seed` first; it only records state).
 """

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/proteus/adapters/dsh.py

@@ -34,9 +34,9 @@ from pathlib import Path
 from typing import Optional, Sequence
 
 from proteus.core.adapter import ActionEvent, EpisodeResult, EpisodeSpec, Surface
+from proteus.core.budget import PHASES, budget_plan, phase_prompt
 from proteus.core.continuity import CONTAINER_ROOT, HandoffStore
 from proteus.core.disposition import Disposition
-from proteus.core.episode import PHASES
 
 IMAGE = os.environ.get("PROTEUS_DSH_IMAGE", "proteus-env-dsh-src:0.1.0-rc.7")
 PHASE_TIMEOUT_S = 600
@@ -49,11 +49,15 @@ PHASE_TIMEOUT_S = 600
 SOURCE_TAR = "/opt/dsh-source.tar"
 #: A full build:lib is ~330s; the gate's timeout must cover one on a changed source.
 BOOT_TIMEOUT_S = 900
+#: A 246-package DSH workspace takes roughly 90s to relink and cold-start on Docker
+#: Desktop even with a warm offline store. Keep enough headroom for slower hosts while
+#: still treating a genuine hang as a runtime viability failure.
+COLD_BOOT_TIMEOUT_S = 300
 SEED_INSTRUCTIONS = """\
 # Agent instructions
 
-You maintain and improve your own harness. During a Proteus episode, the harness currently
-running is a frozen, read-only snapshot at `/workspace`; the writable candidate that
+You inhabit, inspect, and may change your own harness. During a Proteus episode, the harness
+currently running is a frozen, read-only snapshot at `/workspace`; the writable candidate that
 persists across phases is `/workspace/candidate`. Make every edit in that candidate. Your
 candidate surfaces are:
 
@@ -70,12 +74,14 @@ Proteus supplies the cross-phase operational handoff at
 runtime context outside the evolving snapshot; do not copy credentials or raw tool output
 into it.
 
-The image already contains an installed, built copy at `/opt/src`. Do not run `pnpm
-install` in either workspace, and do not create `node_modules` or package-manager caches
-in the candidate: those are generated dependencies, not evolution, and would pollute the
-persistent snapshot. `/opt/src` is the build of the frozen active snapshot. Do not sync,
-reload, or execute candidate source during a phase; Proteus owns the model-free boundary
-build and viability gate after reflect.
+The image already contains an installed, built copy at `/opt/src`. Do not create or persist
+`node_modules` or package-manager caches in the candidate: those are generated dependencies,
+not evolution, and would pollute the snapshot. You may add workspace packages or change
+package manifests, but keep `pnpm-lock.yaml` aligned. The boundary gate recreates links with
+a frozen offline install, so an inconsistent lockfile or a dependency absent from the baked
+store is rejected for repair. `/opt/src` is the build of the frozen active snapshot. Do not
+sync, reload, or execute candidate source during a phase; Proteus owns the model-free
+boundary build and viability gate after reflect.
 
 Each session is one phase of an episode. Harness files and the bounded Proteus handoff
 carry over; the raw conversation does not.
@@ -245,20 +251,42 @@ class DshHarness:
         return ((str(task), "/workspace/task"),) if task.is_dir() else ()
 
     def check_boot(self, harness_root: Path) -> str:
-        """Viability gate: sync + rebuild + `--version` through the image's boot wrapper.
-
-        The wrapper rebuilds from /workspace/src, so a type error the agent wrote into
-        its own source surfaces here as a legible build failure (exit 97 with the build
-        log tail), before any API spend. The timeout covers one full build:lib."""
+        """Build once, then cold-start the exact headless runtime in a fresh container.
+
+        The first probe exact-syncs the candidate, validates its dependency graph offline,
+        rebuilds it, writes the dist cache, and runs ``--version``. A second sandbox call
+        starts from a clean image, reloads that cache, and boots the headless plugin tree
+        without provider credentials. Keeping the probes in separate containers is
+        essential: a newly-added workspace package can compile in the build container yet
+        be absent from the cached outputs or runtime links used by episode N+1.
+        """
         harness = Path(harness_root)
         state = harness.parent / ".dsh-state"
         state.mkdir(exist_ok=True)
-        proc = self.sandbox.run(
-            harness.parent, ["--version"], env={}, timeout_s=BOOT_TIMEOUT_S,
-            mounts=((str(harness), "/workspace"), (str(state), "/state")))
+        mounts = ((str(harness), "/workspace"), (str(state), "/state"))
+        try:
+            proc = self.sandbox.run(
+                harness.parent, ["--version"], env={}, timeout_s=BOOT_TIMEOUT_S,
+                mounts=mounts)
+        except subprocess.TimeoutExpired:
+            return f"self-edited source build timed out after {BOOT_TIMEOUT_S}s"
         if proc.returncode != 0:
             return (f"self-edited source does not boot (exit {proc.returncode}): "
-                    f"{(proc.stderr or proc.stdout)[-400:]}")
+                    f"{(proc.stderr or proc.stdout)[-1200:]}")
+        try:
+            cold = self.sandbox.run(
+                harness.parent, ["--proteus-headless-smoke"], env={},
+                timeout_s=COLD_BOOT_TIMEOUT_S, mounts=mounts)
+        except subprocess.TimeoutExpired:
+            return ("self-edited source headless cold start timed out after "
+                    f"{COLD_BOOT_TIMEOUT_S}s")
+        if cold.returncode != 0:
+            detail = (cold.stderr or cold.stdout)[-1200:]
+            if "proteus-headless-smoke" in detail and "unknown option" in detail.lower():
+                return ("DSH source image predates the headless cold-start contract; "
+                        "rebuild environments/dsh-src before running evolution")
+            return (f"self-edited source fails headless cold start "
+                    f"(exit {cold.returncode}): {detail}")
         return ""
 
     def validate_candidate(self, harness_root: Path) -> str:
@@ -327,7 +355,9 @@ class DshHarness:
         mapping: dict[str, list[str]] = {}
         error = ""
         capped = False
-        budget = int(spec.max_turns or 0)
+        checkpoint_misses = 0
+        plan = budget_plan(spec)
+        budget = plan.hard_limit
         episode_dirs: set = set()
         active = Path(spec.active_root) if spec.active_root is not None else harness
         # Core-managed staged episodes already execute a previously validated snapshot.
@@ -347,18 +377,20 @@ class DshHarness:
         workspace_mounts = ((str(active), "/workspace", "ro"),
                             (str(harness), "/workspace/candidate")) \
             if spec.active_root is not None else ((str(harness), "/workspace"),)
-        min_pp = int(getattr(spec, "min_turns_per_phase", 0) or 0)
-        for idx, phase in enumerate(PHASES if not error else ()):
+        for phase in PHASES if not error else ():
             # the budget is enforced twice, both harness-agnostically: exactly, between
             # phases (no new phase once it is spent) and approximately, mid-phase (the
             # session log is polled and the container stopped at the phase's stop line).
-            # The stop line reserves min_turns_per_phase for every later phase, so a
-            # reservation stop moves to the next phase; only a spent budget ends the
+            # BudgetPlan preserves the legacy later-phase reserve or applies the explicit
+            # act-priority plan. A phase stop moves on; only the hard ceiling caps the
             # episode.
-            if budget and self._live_calls(state, episode_dirs, set()) >= budget:
+            used = self._live_calls(state, episode_dirs, set()) if plan.enabled else 0
+            if budget and used >= budget:
                 capped = True
                 break
-            stop_at = budget - min_pp * (len(PHASES) - idx - 1) if budget else 0
+            stop_at = plan.stop_at(phase, used)
+            if budget and used >= stop_at:
+                continue
             handoff_start = handoffs.begin(spec.episode, phase)
             before = self._session_dirs(state)
             fired = [False]
@@ -374,14 +406,14 @@ class DshHarness:
             try:
                 proc = self.sandbox.run(
                     run_root,
-                    ["--profile", "headless", spec.phase_prompts.get(phase, phase)],
+                    ["--profile", "headless", phase_prompt(spec, phase, used)],
                     env={"DEEPSEEK_API_KEY": self.key,
                          "DSH_PERMISSION_MODE": self.permission_mode},
                     timeout_s=self.phase_timeout_s,
                     mounts=workspace_mounts + ((str(state), "/state"),
                             (str(handoffs.root), CONTAINER_ROOT))
                            + self._task_mount(run_root),
-                    stop_check=stop_check if budget else None,
+                    stop_check=stop_check if plan.enabled else None,
                 )
             except subprocess.TimeoutExpired:
                 timed_out = True
@@ -395,8 +427,10 @@ class DshHarness:
                 for session_dir in session_dirs:
                     phase_events.extend(
                         self._session_trace(session_dir, phase, partial=True))
-            handoffs.finish(handoff_start, phase_events,
-                            interrupted=timed_out or fired[0])
+            handoff = handoffs.finish(handoff_start, phase_events,
+                                      interrupted=timed_out or fired[0])
+            if spec.checkpoint_turns and handoff["source"] != "agent":
+                checkpoint_misses += 1
             if timed_out:
                 error = f"phase {phase}: timeout after {self.phase_timeout_s}s"
                 break
@@ -414,10 +448,18 @@ class DshHarness:
         (run_root / "traces" / f"ep{spec.episode:03d}.json").write_text(
             json.dumps(mapping, indent=1))
         trace = self.read_trace(run_root, spec.episode)
+        phase_counts = {
+            phase: sum(1 for event in trace if event.phase == phase and event.tool)
+            for phase in PHASES
+        }
+        counters = {"phases": len(mapping), "turn_capped": capped,
+                    "checkpoint_misses": checkpoint_misses}
+        counters.update({f"phase_{phase}_turns": count
+                         for phase, count in phase_counts.items()})
         return EpisodeResult(
             episode=spec.episode, ok=not error,
             turns=sum(1 for e in trace if e.tool), error=error,
-            counters={"phases": len(mapping), "turn_capped": capped},
+            counters=counters,
         )
 
     def _live_calls(self, state: Path, episode_dirs: set, extra: set) -> int:

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/proteus/adapters/llm.py

@@ -1,10 +1,11 @@
 """A real-LLM harness on the minimal surface set — any OpenAI-compatible endpoint.
 
 The `minimal` harness with the mock policy replaced by a live model: each phase, the model
-is shown its phase prompt (disposition and goal already folded in by the framework) plus the
-current state of its own harness (the files on its surfaces), and returns the actions to
-take as JSON. Only files cross the episode boundary, so this is genuine self-evolution: what
-the model wrote in episode t is the state it wakes up to in episode t+1.
+is shown its phase prompt (default episode protocol, goal, and visible evaluator feedback
+already folded in by the framework) plus the current state of its own harness (the files on
+its surfaces), and returns the actions to take as JSON. Only files cross the episode
+boundary, so this is genuine self-evolution: what the model wrote in episode t is the state
+it wakes up to in episode t+1.
 
 Works against any OpenAI-compatible chat endpoint via stdlib HTTP (no SDK dependency).
 Defaults target DeepSeek:
@@ -26,11 +27,11 @@ from pathlib import Path
 
 from proteus.adapters.minimal import MinimalHarness
 from proteus.core.adapter import EpisodeResult, EpisodeSpec
-from proteus.core.episode import PHASES
+from proteus.core.budget import PHASES, budget_plan, phase_prompt
 
 SYSTEM = """\
-You are an agent that maintains and improves its own harness — the set of files it wakes
-up with each episode. You have two surfaces:
+You are an agent that can inspect and change its own harness — the set of files it wakes up
+with each episode. You have two surfaces:
 - notes/   markdown files (observations, plans, knowledge you want to keep)
 - tools/   small python files (utilities you may want later)
 
@@ -117,21 +118,20 @@ class LLMHarness(MinimalHarness):
         turn = 0
         writes = {"notes": 0, "tools": 0}
         tokens_in = tokens_out = 0
+        phase_counts = {phase: 0 for phase in PHASES}
         error = ""
         capped = False
-        min_pp = int(getattr(spec, "min_turns_per_phase", 0) or 0)
+        plan = budget_plan(spec)
         with trace_path.open("w", encoding="utf-8") as sink:
-            for idx, phase in enumerate(PHASES):
-                # `max_turns` bounds the whole episode, model calls included; the phase
-                # stop line additionally reserves min_turns_per_phase for later phases,
-                # and reaching it ends the phase, not the episode
-                if spec.max_turns and turn >= spec.max_turns:
+            for phase in PHASES:
+                if plan.enabled and turn >= plan.hard_limit:
                     capped = True
                 if capped:
                     break
-                stop_at = (spec.max_turns - min_pp * (len(PHASES) - idx - 1)
-                           if spec.max_turns else 0)
-                prompt = spec.phase_prompts.get(phase, "")
+                stop_at = plan.stop_at(phase, turn)
+                if plan.enabled and turn >= stop_at:
+                    continue
+                prompt = phase_prompt(spec, phase, turn)
                 user = (f"Episode {spec.episode}, phase: {phase}.\n\n"
                         f"{prompt}\n\nCurrent harness state:\n{_render_state(harness)}")
                 try:
@@ -144,11 +144,12 @@ class LLMHarness(MinimalHarness):
                 tokens_in += int(usage.get("prompt_tokens") or 0)
                 tokens_out += int(usage.get("completion_tokens") or 0)
                 turn += 1
+                phase_counts[phase] += 1
                 sink.write(json.dumps({"turn": turn, "phase": phase, "tool": None,
                                        "surface": None, "text": reply[:500]}) + "\n")
                 for act in _parse_actions(reply):
-                    if spec.max_turns and turn >= stop_at:
-                        capped = turn >= spec.max_turns
+                    if plan.enabled and turn >= stop_at:
+                        capped = turn >= plan.hard_limit
                         break
                     tool = act.get("tool", "")
                     name = "".join(c for c in str(act.get("name", "unnamed"))
@@ -165,8 +166,12 @@ class LLMHarness(MinimalHarness):
                         surface = "tools"
                     else:
                         continue
+                    phase_counts[phase] += 1
                     sink.write(json.dumps({"turn": turn, "phase": phase, "tool": tool,
                                            "surface": surface, "text": name}) + "\n")
+        counters = {"writes": writes, "turn_capped": capped,
+                    "tokens_in": tokens_in, "tokens_out": tokens_out}
+        counters.update({f"phase_{phase}_turns": count
+                         for phase, count in phase_counts.items()})
         return EpisodeResult(episode=spec.episode, ok=not error, turns=turn, error=error,
-                             counters={"writes": writes, "turn_capped": capped,
-                                       "tokens_in": tokens_in, "tokens_out": tokens_out})
+                             counters=counters)

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/proteus/adapters/minimal.py

@@ -19,8 +19,8 @@ from pathlib import Path
 from typing import Callable, Optional, Sequence, Tuple
 
 from proteus.core.adapter import ActionEvent, EpisodeResult, EpisodeSpec, Surface
+from proteus.core.budget import PHASES, budget_plan, phase_prompt
 from proteus.core.disposition import Disposition
-from proteus.core.episode import PHASES
 
 # A policy maps (phase, prompt, episode, rng) -> list of (tool, surface, text) actions.
 Action = Tuple[str, Optional[str], str]
@@ -94,22 +94,23 @@ class MinimalHarness:
         trace_path.parent.mkdir(parents=True, exist_ok=True)
         turn = 0
         writes = {"notes": 0, "tools": 0}
+        phase_counts = {phase: 0 for phase in PHASES}
         capped = False
-        min_pp = int(getattr(spec, "min_turns_per_phase", 0) or 0)
+        plan = budget_plan(spec)
         with trace_path.open("w", encoding="utf-8") as sink:
-            for idx, phase in enumerate(PHASES):
+            for phase in PHASES:
+                if plan.enabled and turn >= plan.hard_limit:
+                    capped = True
                 if capped:
                     break
-                # the phase's stop line reserves min_turns_per_phase for every later
-                # phase; reaching it ends THIS phase, only a spent budget ends the episode
-                stop_at = (spec.max_turns - min_pp * (len(PHASES) - idx - 1)
-                           if spec.max_turns else 0)
-                prompt = spec.phase_prompts.get(phase, "")
+                stop_at = plan.stop_at(phase, turn)
+                prompt = phase_prompt(spec, phase, turn)
                 for tool, surface, text in self.policy(phase, prompt, spec.episode, rng):
-                    if spec.max_turns and turn >= stop_at:
-                        capped = turn >= spec.max_turns
+                    if plan.enabled and turn >= stop_at:
+                        capped = turn >= plan.hard_limit
                         break
                     turn += 1
+                    phase_counts[phase] += 1
                     if tool == "write_note":
                         (harness / "notes" / f"{text}.md").write_text(
                             f"episode {spec.episode}: {text}\n")
@@ -122,8 +123,10 @@ class MinimalHarness:
                         "turn": turn, "phase": phase, "tool": tool,
                         "surface": surface, "text": text,
                     }) + "\n")
-        return EpisodeResult(episode=spec.episode, ok=True, turns=turn,
-                             counters={"writes": writes, "turn_capped": capped})
+        counters = {"writes": writes, "turn_capped": capped}
+        counters.update({f"phase_{phase}_turns": count
+                         for phase, count in phase_counts.items()})
+        return EpisodeResult(episode=spec.episode, ok=True, turns=turn, counters=counters)
 
     def read_trace(self, root: Path, episode: int) -> Sequence[ActionEvent]:
         path = root / "traces" / f"ep{episode:03d}.jsonl"

{proteus_evolve-0.2.0 → proteus_evolve-0.3.0}/proteus/adapters/pi.py

@@ -27,9 +27,9 @@ from typing import Optional, Sequence
 
 from proteus.adapters import instructions
 from proteus.core.adapter import ActionEvent, EpisodeResult, EpisodeSpec, Surface
+from proteus.core.budget import PHASES, budget_plan, phase_prompt
 from proteus.core.continuity import CONTAINER_ROOT, HandoffStore
 from proteus.core.disposition import Disposition
-from proteus.core.episode import PHASES
 
 IMAGE = os.environ.get("PROTEUS_PI_IMAGE", "proteus-env-pi-src:0.84.2")
 PHASE_TIMEOUT_S = 600
@@ -44,8 +44,8 @@ SOURCE_TAR = "/opt/pi-source.tar"
 SEED_INSTRUCTIONS = """\
 # Agent instructions
 
-You maintain and improve your own harness. During a Proteus episode, the harness currently
-running is a frozen, read-only snapshot at `/workspace`; the writable candidate that
+You inhabit, inspect, and may change your own harness. During a Proteus episode, the harness
+currently running is a frozen, read-only snapshot at `/workspace`; the writable candidate that
 persists across phases is `/workspace/candidate`. Make every edit in that candidate. Your
 candidate surfaces are:
 
@@ -234,7 +234,9 @@ class PiHarness:
         mapping: dict[str, list[str]] = {}
         error = ""
         capped = False
-        budget = int(spec.max_turns or 0)
+        checkpoint_misses = 0
+        plan = budget_plan(spec)
+        budget = plan.hard_limit
         episode_files: set = set()
         active = Path(spec.active_root) if spec.active_root is not None else harness
         # Core-managed staged episodes already execute a previously validated snapshot.
@@ -252,18 +254,20 @@ class PiHarness:
         workspace_mounts = ((str(active), "/workspace", "ro"),
                             (str(harness), "/workspace/candidate")) \
             if spec.active_root is not None else ((str(harness), "/workspace"),)
-        min_pp = int(getattr(spec, "min_turns_per_phase", 0) or 0)
-        for idx, phase in enumerate(PHASES if not error else ()):
+        for phase in PHASES if not error else ():
             # the budget is enforced twice, both harness-agnostically: exactly, between
             # phases (no new phase once it is spent) and approximately, mid-phase (the
             # session log is polled and the container stopped at the phase's stop line).
-            # The stop line reserves min_turns_per_phase for every later phase, so a
-            # reservation stop moves to the next phase; only a spent budget ends the
+            # BudgetPlan preserves the legacy later-phase reserve or applies the explicit
+            # act-priority plan. A phase stop moves on; only the hard ceiling caps the
             # episode.
-            if budget and self._live_calls(state, episode_files, set()) >= budget:
+            used = self._live_calls(state, episode_files, set()) if plan.enabled else 0
+            if budget and used >= budget:
                 capped = True
                 break
-            stop_at = budget - min_pp * (len(PHASES) - idx - 1) if budget else 0
+            stop_at = plan.stop_at(phase, used)
+            if budget and used >= stop_at:
+                continue
             handoff_start = handoffs.begin(spec.episode, phase)
             before = self._sessions(state)
             fired = [False]
@@ -281,13 +285,13 @@ class PiHarness:
                     run_root,
                     ["--provider", self.provider, "--model", spec.model or self.model,
                      "--session-dir", "/state", "--skill", "/workspace/skills",
-                     "-p", spec.phase_prompts.get(phase, phase)],
+                     "-p", phase_prompt(spec, phase, used)],
                     env={"DEEPSEEK_API_KEY": self.key},
                     timeout_s=self.phase_timeout_s,
                     mounts=workspace_mounts + ((str(state), "/state"),
                             (str(handoffs.root), CONTAINER_ROOT))
                            + self._task_mount(run_root),
-                    stop_check=stop_check if budget else None,
+                    stop_check=stop_check if plan.enabled else None,
                 )
             except subprocess.TimeoutExpired:
                 timed_out = True
@@ -300,8 +304,10 @@ class PiHarness:
                 episode_files |= new
                 for session_path in session_paths:
                     phase_events.extend(self._session_trace(session_path, phase))
-            handoffs.finish(handoff_start, phase_events,
-                            interrupted=timed_out or fired[0])
+            handoff = handoffs.finish(handoff_start, phase_events,
+                                      interrupted=timed_out or fired[0])
+            if spec.checkpoint_turns and handoff["source"] != "agent":
+                checkpoint_misses += 1
             if timed_out:
                 error = f"phase {phase}: timeout after {self.phase_timeout_s}s"
                 break
@@ -319,10 +325,18 @@ class PiHarness:
         (run_root / "traces" / f"ep{spec.episode:03d}.json").write_text(
             json.dumps(mapping, indent=1))
         trace = self.read_trace(run_root, spec.episode)
+        phase_counts = {
+            phase: sum(1 for event in trace if event.phase == phase and event.tool)
+            for phase in PHASES
+        }
+        counters = {"phases": len(mapping), "turn_capped": capped,
+                    "checkpoint_misses": checkpoint_misses}
+        counters.update({f"phase_{phase}_turns": count
+                         for phase, count in phase_counts.items()})
         return EpisodeResult(
             episode=spec.episode, ok=not error,
             turns=sum(1 for e in trace if e.tool), error=error,
-            counters={"phases": len(mapping), "turn_capped": capped},
+            counters=counters,
         )
 
     def _live_calls(self, state: Path, episode_files: set, extra: set) -> int:

proteus_evolve-0.3.0/proteus/bench/_datasets.py

@@ -0,0 +1,39 @@
+"""Verified, atomic downloads for official benchmark datasets."""
+
+from __future__ import annotations
+
+import hashlib
+import tempfile
+from pathlib import Path
+from typing import Callable
+from urllib import request
+
+
+def download_verified(
+    *, name: str, url: str, expected_sha256: str, cache: Path, validate: Callable[[Path], object]
+) -> Path:
+    """Download one official dataset, verify bytes and format, then publish atomically."""
+    cache = Path(cache)
+    if cache.exists():
+        return cache
+    cache.parent.mkdir(parents=True, exist_ok=True)
+    with request.urlopen(url, timeout=30) as response:
+        payload = response.read()
+    actual = hashlib.sha256(payload).hexdigest()
+    if actual != expected_sha256:
+        raise ValueError(
+            f"{name} checksum mismatch: expected {expected_sha256}, got {actual}"
+        )
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            dir=cache.parent, suffix="".join(cache.suffixes), delete=False
+        ) as stream:
+            stream.write(payload)
+            temporary = Path(stream.name)
+        validate(temporary)
+        temporary.replace(cache)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)
+    return cache