dsh-open-dream-rsi 0.2.3 → 0.3.8

package/README.md

@@ -40,8 +40,8 @@ directory holding your `tasks.json`:
 
 ```bash
 # from the npm registry, a tarball, a checkout, or straight from GitHub — pick one:
-dsh plugin --profile <name> add dsh-open-dream-rsi            # or pin: dsh-open-dream-rsi@0.2.1
-dsh plugin --profile <name> add /path/to/dsh-open-dream-rsi-0.2.1.tgz
+dsh plugin --profile <name> add dsh-open-dream-rsi            # or pin: dsh-open-dream-rsi@0.3.1
+dsh plugin --profile <name> add /path/to/dsh-open-dream-rsi-0.3.1.tgz
 dsh plugin --profile <name> add /path/to/open-dream-rsi/plugins/deepseek_harness
 dsh plugin --profile <name> add github:patrykorwat/open-dream-rsi#path:plugins/deepseek_harness
 
@@ -58,6 +58,27 @@ dsh plugin --profile <name> add "github:patrykorwat/open-dream-rsi#<sha>&path:pl
 (The pin must point at a commit that already contains this directory —
 pnpm fetches sources, not releases.)
 
+## Updating
+
+The bundle is self-contained (the Python server is vendored, no pip, no
+build step), so updating is a re-install of the same package id:
+
+```bash
+dsh plugin --profile <name> add dsh-open-dream-rsi
+```
+
+Installed from git instead? Pin a commit that already contains the bundle
+files — an older sha registers a synthetic `0.0.0` package and dsh dies in
+`resolveBundleDir`:
+
+```bash
+dsh plugin --profile <name> add github:patrykorwat/open-dream-rsi#<sha>&path:plugins/deepseek_harness
+```
+
+Verify the installed version afterwards with your profile's plugin list
+(see `dsh plugin --help`). Re-installs never touch your memory:
+`tasks.json` / `.dream_rsi` live beside the directory dsh launches from.
+
 ## Install (stdio, `--patch` overlay)
 
 1. Make the server importable (not on PyPI — install from the repo):

package/open_dream_rsi/__init__.py

@@ -46,7 +46,7 @@ from open_dream_rsi.bench_policy import (
     run_policy_benchmark,
 )
 
-__version__ = "0.2.1"
+__version__ = "0.3.8"
 
 __all__ = [
     "DiscoveryTree",

package/open_dream_rsi/bench.py

@@ -19,8 +19,8 @@ import json
 import shutil
 import tempfile
 import time
-from dataclasses import asdict, dataclass, field
-from typing import Any, Callable, Dict, List, Optional
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, List, Optional
 
 from open_dream_rsi.loop import AutoRSIRuntime, Task
 from open_dream_rsi.memory import DreamMemory
@@ -85,6 +85,9 @@ def run_arm(
             # benchmarks (bench-policy) — keep the machinery under test pure.
             enable_knowledge=False,
             enable_thoughts=False,
+            # Published arm numbers are byte-stable: the fair queue must not
+            # reorder these tasks (benchmarks size their budget per task set).
+            fair_queue=False,
         )
         runtime.api_calls_used = 0
         report = runtime.run_once()

package/open_dream_rsi/bench_policy.py

@@ -20,6 +20,11 @@ expansion strategy differs):
 * ``evolved_policy``  — the loop asks the LLM for a policy program per
   category, gates it by counterfactual rollout, and (on evidence) steers
   online expansion with the promoted code.
+* ``sentinel_guided`` — same, but the recorded tree carries structured
+  Sentinel facts: nodes whose error class keeps repeating are recorded
+  BLOCKED (choice removal, the TravelPlanner-measured mechanism), and the
+  promoted policy reads ``sentinel_blocked`` to skip them — structure
+  over luck: no epsilon, no lessons, no thoughts.
 
 The scripted model plays two roles deterministically (like ``MockLLM`` in
 ``bench.py``): a task solver following the family ladder, and a policy
@@ -37,10 +42,13 @@ import re
 import tempfile
 import time
 from dataclasses import asdict, dataclass, field
-from typing import Any, Dict, List, Optional, Sequence
+from typing import Any, Dict, List, Sequence
+
+from pathlib import Path
 
 from open_dream_rsi.loop import AutoRSIRuntime, Task
 from open_dream_rsi.memory import DreamMemory
+from open_dream_rsi.sentinel import SentinelEngine, SentinelObservation
 
 # ---------------------------------------------------------------------------
 # The decoy-trap suite. Each category has exactly three code families whose
@@ -156,6 +164,63 @@ TRAP_LESSON_TEXT = (
 )
 
 
+#: The policy program the scripted policy-writer returns when the recorded
+#: tree carries Sentinel repeats (the generation prompt's tree summary shows
+#: ``same_error=`` lines): the structural explorer (oldest fresh node,
+#: periodic root re-entry) restricted to nodes whose error class has NOT
+#: kept repeating. The blocked facts prune the dead side-chains from the
+#: exploration queue, so the promising branch is reached with fewer live
+#: attempts; on a fact-free tree the same code reduces to the plain
+#: explorer (asserted in tests/test_bench_policy.py).
+SENTINEL_EXPLORER_POLICY = """
+def choose_action(frontier, step):
+    if not frontier:
+        return None
+    def born(n):
+        tail = n['node_id'].rsplit('/', 1)[-1]
+        digits = ''.join(ch for ch in tail if ch.isdigit())
+        return int(digits) if digits else -1
+    clean = [n for n in frontier if not n.get('sentinel_blocked')]
+    pool = clean or frontier
+    fresh = [n for n in pool if n['children'] == 0]
+    if fresh and step % 3 != 0:
+        return min(fresh, key=born)['node_id']
+    return min(pool, key=born)['node_id']
+"""
+
+
+class _RepeatBlockSentinel:
+    """Benchmark-side engine wrapper: repeats become BLOCKED (choice removal).
+
+    The runtime's ``observe_structured()`` path records replay-safe facts on
+    each node; this wrapper composes the TravelPlanner-measured mechanism —
+    once an error class has repeated >= threshold inside the episode, the
+    observation is marked blocked, so the frontier feature (and any policy
+    reading it) treats the branch as removed. Pure composition: the engine
+    itself never blocks (SentinelObservation is rebuilt, never mutated).
+    """
+
+    def __init__(self, engine: SentinelEngine, repeat_threshold: int) -> None:
+        self.engine = engine
+        self.repeat_threshold = int(repeat_threshold)
+
+    def observe_structured(self, tool, result, session_id, status=None,
+                           error_message=None, budget=None, blocked=False):
+        obs = self.engine.observe_structured(
+            tool, result, session_id, status=status,
+            error_message=error_message, budget=budget, blocked=blocked)
+        if (obs.error_class is not None
+                and obs.in_session_count >= self.repeat_threshold):
+            obs = SentinelObservation(
+                signature=obs.signature, error_class=obs.error_class,
+                in_session_count=obs.in_session_count,
+                cross_session_count=obs.cross_session_count,
+                recurring=obs.recurring, finalize_nudge=obs.finalize_nudge,
+                budget_used=obs.budget_used, budget_total=obs.budget_total,
+                blocked=True)
+        return obs
+
+
 #: One-line PLAN texts the scripted solver states per code family when
 #: thoughts are requested (system prompt mentions PLAN). Plain English — no
 #: family code appears here, so the ideas ledger can never leak code into
@@ -262,6 +327,10 @@ class TrapSolver:
         user = messages[-1]["content"]
         if "exploration policy" in system:
             self.policy_calls += 1
+            if "same_error=" in user:
+                # the tree summary shows Sentinel repeats: write the
+                # blocked-aware explorer instead of the plain round-robin
+                return f"```python\n{SENTINEL_EXPLORER_POLICY}\n```"
             return f"```python\n{EXPLORER_POLICY}\n```"
         if "knowledge curator" in system:
             self.curator_calls += 1
@@ -338,6 +407,15 @@ ARMS: Dict[str, Dict[str, Any]] = {
     # KB. Any improvement over epsilon_greedy is attributable to thoughts.
     "thought_guided":   dict(enable_policy_code=False, enable_knowledge=False,
                              explore_epsilon=0.3, enable_thoughts=True),
+    # Sentinel-guided arm: the runtime gets a repeat-block Sentinel engine
+    # (wired by run_policy_arm from the sentinel_repeat_block key, which
+    # must never reach AutoRSIRuntime itself); the LLM-written policy reads
+    # sentinel_blocked and stops re-picking nodes whose error class keeps
+    # repeating — the TravelPlanner choice-removal mechanism, ported to
+    # exploration structure. No epsilon, no lessons, no thoughts.
+    "sentinel_guided":  dict(enable_policy_code=True,  enable_knowledge=False,
+                             enable_thoughts=False, explore_epsilon=0.0,
+                             sentinel_repeat_block=2),
 }
 
 
@@ -376,17 +454,31 @@ def run_policy_arm(arm: str, cfg: Dict[str, Any], cycles: int, budget: int,
     t0 = time.time()
     total_solves = total_calls = total_policy = total_curator = 0
     rates: List[List[float]] = []
+    # The sentinel arm wires a repeat-block engine into the runtime: error
+    # classes repeating >= threshold inside the episode are recorded BLOCKED
+    # on the node, surfacing as the sentinel_blocked frontier feature the
+    # promoted policy reads. The raw SentinelEngine only observes; the
+    # repeat->blocked mapping is the benchmark composition of the
+    # TravelPlanner gate (choice removal recorded on the world).
+    block_cfg = int(cfg.get("sentinel_repeat_block") or 0)
+    arm_cfg = {k: v for k, v in cfg.items() if k != "sentinel_repeat_block"}
     for seed in seeds:
         tasks = _trap_tasks()
         solver = TrapSolver()
         root = tempfile.mkdtemp(prefix=f"odr-polbench-{arm}-")
+        engine = None
+        if block_cfg:
+            engine = _RepeatBlockSentinel(
+                SentinelEngine(state_path=Path(root) / "sentinel_state.json"),
+                block_cfg)
         rates.append([])
         for c in range(cycles):
             memory = DreamMemory(root)  # persistent across cycles within a run
             runtime = AutoRSIRuntime(
                 client=solver, memory=memory, tasks=tasks,
                 api_call_budget=budget, dream_iterations=dream_iterations,
-                rng_seed=seed * 100 + c, **cfg,
+                rng_seed=seed * 100 + c, fair_queue=False,
+                sentinel_engine=engine, **arm_cfg,
             )
             runtime.api_calls_used = 0
             report = runtime.run_once()
@@ -450,11 +542,14 @@ def to_markdown(summary: Dict[str, Any]) -> str:
               "trap tasks and then burns its whole budget re-polishing the decoy; "
               "replay-gated LLM-written policies reach the hidden fixes and reuse "
               "them as warm starts; the curated knowledge base lets epsilon alone "
-              "spend luck elsewhere because the trap itself is remembered.", ""]
+              "spend luck elsewhere because the trap itself is remembered; the "
+              "sentinel-guided arm re-derives the same escape from structured "
+              "failure facts — nodes whose error class keeps repeating are "
+              "skipped, no luck and no lesson text required.", ""]
     return "\n".join(lines)
 
 
-def to_svg(summary: Dict[str, Any], width: int = 860, height: int = 300,
+def to_svg(summary: Dict[str, Any], width: int = 960, height: int = 300,
            theme: str = "dark") -> str:
     """Grouped bar chart: solve rate (%) per cycle per arm. Pure SVG, no deps.
 
@@ -465,9 +560,11 @@ def to_svg(summary: Dict[str, Any], width: int = 860, height: int = 300,
     cycles = summary["cycles"]
     dark = theme == "dark"
     colors = ({"greedy": "#e5534b", "epsilon_greedy": "#d4a72c", "evolved_policy": "#3fb950",
-               "knowledge_curator": "#58a6ff", "thought_guided": "#bc8cff"} if dark else
+               "knowledge_curator": "#58a6ff", "thought_guided": "#bc8cff",
+               "sentinel_guided": "#f0883e"} if dark else
               {"greedy": "#c0392b", "epsilon_greedy": "#b8860b", "evolved_policy": "#1e7d3c",
-               "knowledge_curator": "#1f6fb2", "thought_guided": "#6f42c1"})
+               "knowledge_curator": "#1f6fb2", "thought_guided": "#6f42c1",
+               "sentinel_guided": "#d97706"})
     palette = dict(bg="#0d1117", grid="#21262d", axis="#8b949e", text="#c9d1d9") if dark \
         else dict(bg="#ffffff", grid="#d8dee4", axis="#57606a", text="#24292f")
     pad_l, pad_r, pad_t, pad_b = 48, 16, 30, 46
@@ -510,7 +607,7 @@ def to_svg(summary: Dict[str, Any], width: int = 860, height: int = 300,
         lx += 150
     parts.append(f'<text x="{pad_l}" y="18" fill="{palette["text"]}" font-size="13" '
                  f'font-weight="600">Decoy-trap suite — solve rate per cycle '
-                 f'(greedy vs ε-greedy vs replay-gated policies vs curated KB vs thoughts)</text>')
+                 f'({len(arms)} arms, mean over {summary.get("runs", 1)} seeds)</text>')
     parts.append("</svg>")
     return "\n".join(parts)
 

package/open_dream_rsi/cli.py

@@ -60,6 +60,7 @@ def cmd_loop(args: argparse.Namespace) -> int:
         interval_seconds=args.interval,
         max_tokens=args.max_tokens,
         enable_policy_code=not args.no_policy_code,
+        enable_evolution_stop=bool(getattr(args, "evolution_stop", False)),
         enable_knowledge=not args.no_knowledge,
         enable_thoughts=not args.no_thoughts,
         enable_judge=not args.no_judge,
@@ -147,31 +148,49 @@ def cmd_sessions(args: argparse.Namespace) -> int:
     memory = DreamMemory(args.memory)
     provider = getattr(args, "provider", "openai")
     if args.dry_run:
+        from open_dream_rsi.corrections import user_corrections
         for ep in eps[: args.limit or len(eps)]:
             fails = episode_failures(ep)
+            corrs = user_corrections(ep)
             print(f"[{ep.source}:{ep.session_id[:12]}] {ep.title[:60]} "
-                  f"— {len(fails)} failure-shaped record(s)")
-            for f in fails[:3]:
+                  f"— {len(fails)} failure-shaped, {len(corrs)} correction-shaped record(s)")
+            for f in (fails + corrs)[:3]:
                 print("   ", f["errors"][0][:100])
         return 0
     from open_dream_rsi.cli import _build_client
     client = _build_client(provider, args.model)
     curator = KnowledgeCurator(client)
+    from open_dream_rsi.corrections import (
+        dedupe_corrections,
+        distillable,
+        user_corrections,
+    )
     total_added = 0
-    for ep in eps:
-        failures = episode_failures(ep)
-        if not failures:
+    ep_evidence = [(ep, episode_failures(ep), user_corrections(ep))
+                   for ep in eps]
+    all_corr = distillable(
+        dedupe_corrections([c for _, _, cs in ep_evidence for c in cs]))
+    kept = {(c.get("session_id"), c.get("msg_index")) for c in all_corr}
+    for ep, failures, corr_raw in ep_evidence:
+        corrections = [c for c in corr_raw
+                       if (c.get("session_id"), c.get("msg_index")) in kept]
+        if corrections:
+            memory.log_event("user_correction_found", source=ep.source,
+                             session_id=ep.session_id, count=len(corrections),
+                             classes=[c.get("class", "") for c in corrections][:6])
+        evidence = failures + corrections
+        if not evidence:
             continue
         category = args.category or (
             Path(ep.cwd).name if ep.cwd else ep.source)
         distilled, err = curator.distill(category, ep.title or category,
-                                         failures, memory.get_lessons(category))
+                                         evidence, memory.get_lessons(category))
         if err or not distilled:
             memory.log_event("lesson_rejected", source=ep.source,
                              session_id=ep.session_id, reason=(err or "empty")[:300])
             continue
         result = curate_lessons(memory.get_lessons(category), distilled,
-                                evidence=evidence_snippets(failures))
+                                evidence=evidence_snippets(evidence))
         memory.replace_lessons(category, result.entries)
         memory.log_event("lessons_curated", source=ep.source,
                          session_id=ep.session_id, category=category,
@@ -336,6 +355,8 @@ def cmd_artifacts(args: argparse.Namespace) -> int:
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(prog="odr", description="Open Dream-RSI autonomous supervisor")
     parser.add_argument("--memory", default=".dream_rsi", help="memory directory (one per instance)")
+    from open_dream_rsi import __version__ as _v
+    parser.add_argument("--version", action="version", version=f"open-dream-rsi {_v}")
     sub = parser.add_subparsers(dest="command", required=True)
 
     loop = sub.add_parser("loop", help="run the self-improvement cycle")
@@ -351,6 +372,10 @@ def main(argv: list[str] | None = None) -> int:
     loop.add_argument("--dream-iters", type=int, default=60)
     loop.add_argument("--no-policy-code", action="store_true",
                       help="disable LLM-written exploration policies (section-3 step)")
+    loop.add_argument("--evolution-stop", action="store_true",
+                      help="anytime-valid stopping for policy evolution "
+                           "(freeze regeneration after a betting-martingale "
+                           "alarm; the last promoted policy stays active)")
     loop.add_argument("--no-knowledge", action="store_true",
                       help="disable the knowledge curator (lessons.json KB, section-4 step)")
     loop.add_argument("--no-thoughts", action="store_true",
@@ -389,7 +414,7 @@ def main(argv: list[str] | None = None) -> int:
                     help="force one KB category (default: per-episode cwd)")
     dr.add_argument("--budget", type=int, default=20,
                     help="max API calls for a FULL dream (default 20)")
-    dr.add_argument("--max-tokens", type=int, default=4096)
+    dr.add_argument("--max-tokens", type=int, default=100_000)
     dr.add_argument("--offline", action="store_true",
                     help="no LLM: lifecycle maintenance only")
     dr.set_defaults(func=cmd_dream)

package/open_dream_rsi/core/agent.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, runtime_checkable
+from typing import Callable, Dict, List, Optional, Protocol, Tuple, runtime_checkable
 
 from open_dream_rsi.core.tree import DiscoveryTree
 from open_dream_rsi.core.dreamer import DreamEngine

package/open_dream_rsi/core/curator.py

@@ -23,8 +23,10 @@ A distilled payload is a JSON array of at most ``max_lessons`` objects::
     {"trigger": str, "text": str}
 
 ``trigger``: 1-4 lowercase keywords tying the lesson to a task/failure
-family; ``text``: one actionable insight (<= 280 chars) grounded in the
-failure evidence shown to the curator. Generic advice is rejected.
+family; ``text``: one actionable insight (<= 3000 chars) grounded in the
+failure evidence shown to the curator — the observation, the mechanism
+that made it fail, and the bounded fix with its stop condition. Generic
+advice is rejected.
 """
 
 from __future__ import annotations
@@ -38,14 +40,16 @@ from typing import Any, Dict, List, Optional, Tuple
 #: Hard caps enforced by the structural gate — oversized or vague records
 #: never enter the knowledge base (cheap gate: lessons are retrieved text,
 #: so contamination is the failure mode to defend against).
-MAX_LESSON_CHARS = 280
+MAX_LESSON_CHARS = 3_000
 MIN_TRIGGER_WORDS = 1
 MAX_TRIGGER_WORDS = 4
 MAX_LESSONS_PER_CATEGORY = 8
 #: Retrieval: how many lessons a single proposal prompt may carry and the
-#: total character budget for them (keeps the solver prompt honest).
+#: total character budget for them (keeps the solver prompt honest). The
+#: budget scales with the text cap so a detailed lesson is never silently
+#: dropped at retrieval time (select_lessons skips what does not fit).
 MAX_LESSONS_IN_PROMPT = 4
-MAX_PROMPT_LESSON_CHARS = 700
+MAX_PROMPT_LESSON_CHARS = 15_000
 #: Pruning: a lesson used this many times with zero recorded solves is
 #: dead weight and gets retired to keep the KB from rotting. Retirement is
 #: a LIFECYCLE transition (STALE -> ARCHIVED via the Artifact Lifecycle
@@ -84,14 +88,20 @@ LESSON_CONTRACT = (
     "Reply with ONLY one fenced ```json``` block containing an array of "
     "objects, each exactly: {{\"trigger\": \"...\", \"text\": \"...\"}}. "
     "'trigger' is 1-4 lowercase keywords tying the lesson to this failure "
-    "family; 'text' is one actionable insight in at most 280 characters, "
-    "grounded ONLY in the evidence shown. Phrase the insight as a "
+    "family; 'text' is one actionable insight in at most 3000 characters, "
+    "grounded ONLY in the evidence shown. Be SPECIFIC, not terse: name the "
+    "observable signal (the exact error shape, tool, or state that "
+    "recurs), the mechanism that made the attempt fail, and the bounded "
+    "behavior that avoids it - a lesson a future reader could act on "
+    "without seeing this evidence is the goal. Prefer the longer end of "
+    "the range when the evidence supports it; do not compress a real "
+    "mechanism into a slogan. Phrase the insight as a "
     "DECLARATIVE fact about the task family, never as a command to the "
     "solver: measured on a greedy decoder, the imperative form of exact "
     "true facts lost 12 paired comparisons with 0 wins against their "
     "declarative form. EVERY lesson MUST end with an "
     "explicit stop condition (e.g. '...then answer immediately', '...at "
-    "most one extra lookup') — never instruct open-ended searching: models "
+    "most one extra lookup') - never instruct open-ended searching: models "
     "with deterministic decoding treat 'keep checking' as a command to "
     "never finish. No generic advice ('write better code'), no "
     "task-specific constants, no restate-the-error entries; if the evidence "
@@ -380,7 +390,7 @@ class KnowledgeCurator:
     """
 
     def __init__(self, client: Any, max_lessons: int = 3,
-                 max_repair: int = 1, max_tokens: int = 4096):
+                 max_repair: int = 1, max_tokens: int = 100_000):
         self.client = client
         self.max_lessons = max_lessons
         self.max_repair = max_repair
@@ -397,11 +407,16 @@ class KnowledgeCurator:
         known = "\n".join(f"  - [{l.get('trigger', '')}] {l.get('text', '')}"
                           for l in existing[-MAX_LESSONS_PER_CATEGORY:]) or "(empty KB)"
         feedback = ""
+        has_corr = any("user said:" in e for e in evidence)
         for attempt in range(1 + self.max_repair):
             user = (f"Category [{category}]: {task_prompt}\n\n"
                     f"Lessons already in the knowledge base (do not restate):\n{known}\n\n"
-                    f"Failed attempts this cycle:\n" + "\n".join(evidence) + "\n\n"
-                    f"Previous rejection reason: {feedback or '(none)'}\n\n"
+                    f"Failed attempts this cycle:\n" + "\n".join(evidence) +
+                    ("\n\nNote: some records are user corrections (action starts with "
+                     "'user_correction'): the user's wording is evidence worth testing, "
+                     "not verified truth; distil only the reusable, scoped rule."
+                     if has_corr else "") +
+                    f"\n\nPrevious rejection reason: {feedback or '(none)'}\n\n"
                     f"Return the JSON array of at most {self.max_lessons} lessons.")
             kwargs: Dict[str, Any] = {"temperature": 0.5}  # distillation, not creativity
             kwargs["max_tokens"] = self.max_tokens

package/open_dream_rsi/core/policygen.py

@@ -68,6 +68,13 @@ from open_dream_rsi.sandbox import run_isolated
 #: score ones — the counterfactual counterpart of UCB's visit-count term).
 #: Applied identically to candidates and the greedy baseline.
 DIVERSITY_BETA = 0.2
+
+#: Weight of the discovery-efficiency term (Dream-RSI v2 scores policies on
+#: completed rounds per call; over a recorded tree the analog is the share of
+#: rollout steps that harvest a NEW (node, reward) pair — a step re-paying a
+#: value already recorded from that node is a wasted call on an exhausted
+#: branch). Applied identically to candidate and baseline.
+EFFICIENCY_BETA = 0.1
 #: Fraction of rollout steps that must return a frontier-valid choice for a
 #: candidate to be promotable at all.
 MIN_VALIDITY = 0.8
@@ -99,7 +106,10 @@ POLICY_CONTRACT = (
     "that will fail hidden tests forever — re-expanding it burns the budget, "
     "while branches with different (or no) failures hide the real prize. "
     "Good policies balance exploiting promising branches against trying "
-    "under-expanded ones. "
+    "under-expanded ones. Policies are also scored on DISCOVERY "
+    "EFFICIENCY: a step that re-pays a value already recorded from the "
+    "same node (an exhausted branch) is a wasted call — do not camp on "
+    "branches whose recorded children you have already harvested. "
     "Rules: pure stdlib, no imports, no file/network/process access, no "
     "leading-underscore attributes, must terminate, must handle an empty "
     "frontier (return None)."
@@ -512,10 +522,32 @@ def _simulate_step_rewards(world: Dict[str, Any], pick_fn: Any) -> Tuple[List[fl
 
 
 def _rollout_objective(rewards: List[float], picks: List[str]) -> float:
-    """Mean reward + branch-diversity bonus (beta_2), comparable across arms."""
+    """Mean reward + diversity bonus - discovery-inefficiency penalty.
+
+    The efficiency term operationalizes Dream-RSI v2's rounds-per-call
+    efficiency over a recorded tree: a rollout step that pays a (node,
+    reward) pair ALREADY harvested from that node re-plays an exhausted
+    ladder — a call producing no new discovery. e = fresh steps / steps;
+    camping on one branch pays its recorded children once and then burns
+    the horizon re-harvesting the last one. (Note: this is NOT payoff
+    latency — an earlier measurement showed latency mis-ranks structural
+    explorers below lucky ladder-order harvests on decoy fixtures.)
+    """
     total = len(rewards) or 1
+    mean = sum(rewards) / total
     distinct = len({p for p in picks if p != "!invalid"})
-    return sum(rewards) / total + DIVERSITY_BETA * distinct / total
+    obj = mean + DIVERSITY_BETA * distinct / total
+    seen: set = set()
+    fresh = 0
+    for pick, r in zip(picks, rewards):
+        if pick == "!invalid":
+            continue  # already punished by reward 0 + the validity floor
+        key = (pick, round(r, 9))
+        if key not in seen:
+            seen.add(key)
+            fresh += 1
+    obj -= EFFICIENCY_BETA * (1.0 - fresh / total)
+    return obj
 
 
 def rollout_score(
@@ -677,10 +709,14 @@ class PolicyGenerator:
                 continue
             if source == incumbent_source:
                 return GenerationResult(None, score, "identical to incumbent")
-            if score < incumbent_score - 1e-9:
+            if score <= incumbent_score + 1e-9:
+                # STRICT improvement only: a tie is not evidence (the same
+                # philosophy as the lesson gate's confirmed-strict-win rule).
+                # A tying challenger must not displace a trusted incumbent.
                 return GenerationResult(
                     None, score,
-                    f"replay score {score:.4f} < incumbent {incumbent_score:.4f}")
+                    f"replay score {score:.4f} did not strictly beat "
+                    f"incumbent {incumbent_score:.4f}")
             return GenerationResult(source, score, "")
         return GenerationResult(None, float("-inf"), feedback or "generation failed")
 

package/open_dream_rsi/corrections.py

@@ -0,0 +1,213 @@
+"""User-correction extraction (issue #6): natural-language evidence.
+
+Host sessions contain corrections the user states in prose ("nie tak,
+użyj istniejącego klienta", "don't create another client") — invisible to
+:func:`open_dream_rsi.sessions.episode_failures`, which scans tool output
+for error markers. This module turns such turns into evidence records
+shaped like failure records (``action`` / ``score`` / ``errors``) so the
+existing curator and replay-gate flow consumes them without a second
+pipeline, while keeping the ``user_correction`` evidence kind and
+provenance recoverable (README § Verdicts must be replayable).
+
+Trust model is unchanged: a user correction is *evidence worth testing*,
+not verified truth. Nothing here can make a lesson ACTIVE — candidates
+enter staging like every other lesson and face the same paired-replay
+gate. Extraction is deterministic and deliberately conservative: only
+obvious, well-scoped candidates are kept; ambiguous negatives, ordinary
+follow-ups and task expansions stay unclassified.
+"""
+
+import re
+from typing import Any, Dict, List, Optional
+
+__all__ = ["classify_user_message", "user_corrections", "dedupe_corrections",
+           "prioritize_corrections", "distillable"]
+
+#: Turns that reject a result or approach ("Correction" / "Approach
+#: redirect" in issue #6). Kept tight on purpose — a broad "nie|not" net
+#: would swallow ordinary follow-ups (the measured v3 lesson: trust is
+#: earned per class, never by breadth).
+_CORRECTION_HINTS = re.compile(
+    r"\b(?:nie\s+tak|nie\s+o\s+to|nie\s+chodzi\s+o|chodzi\s+mi\s+o|"
+    r"źle|błędnie|błędne|błędn|złe\s+założen|przecież|zamiast|"
+    r"nadpis|nie\s+wolno|nie\s+rób|nie\s+używaj|nie\s+twórz|"
+    r"weź\s+pod\s+uwagę|uwzględnij|użyj\s+istniejąc|skorzystaj\s+z\s+istniejąc|"
+    r"jak\s+(?:napisałem|mówiłem|prosiłem)|już\s+(?:pisałem|mówiłem|prosiłem)|"
+    r"znowu\s+(?:to\s+samo|piszesz|robisz)|"
+    r"\bwrong\b|\bincorrectly?\b|that'?s\s+not|that\s+is\s+not|instead\s+of|"
+    r"don't\s+(?:do|create|use|touch|add|overwrite)|do\s+not\s+(?:do|create|use|touch|add|overwrite)|"
+    r"reuse\s+(?:the\s+)?(?:existing|shared)|as\s+i\s+(?:said|wrote|told|asked)|"
+    r"we\s+already\s+(?:tried|did|fixed)|\bbreaks\b|\bbroke\b|stop\s+(?:doing|touching|creating)"
+    r")", re.IGNORECASE)
+
+#: Stated conventions ("Preference" in issue #6). Legitimate scoped-rule
+#: evidence, but never framed as a failure lesson by the caller.
+_PREFERENCE_HINTS = re.compile(
+    r"\b(?:preferuję|wolę|zawsze\s+(?:używaj|pisz|rób|dziel)|"
+    r"nigdy\s+(?:nie\s+)?(?:używaj|pisz|rób)|trzymaj\s+się\s+konwencji|"
+    r"\bprefer\b|\bi\s+prefer\b|\bi\s+usually\b|always\s+(?:use|write|split)|"
+    r"never\s+(?:use|do|commit)|convention\s+is\b)", re.IGNORECASE)
+
+#: Task expansion / new requirement ("New requirement or clarification").
+#: Extracted for completeness (the classes must be distinguishable) but
+#: NOT distillation-ready by default: it is not evidence of a mistake.
+_REQUIREMENT_HINTS = re.compile(
+    r"\b(?:dodaj\s+jeszcze|dołóż|także\s+|poza\s+tym|oprócz\s+tego|"
+    r"a\s+co\s+z\s+|możesz\s+też|przy\s+okazji|"
+    r"what\s+about\b|also\s+add|in\s+addition|one\s+more\s+thing|"
+    r"while\s+you'?re\s+at\s+it)", re.IGNORECASE)
+
+#: Cheap ambiguity guards: short reactions, thanks, questions and bare
+#: acknowledgements are never promoted (issue §1: reject or leave
+#: unclassified rather than promote).
+_AMBIGUITY = re.compile(
+    r"^\s*(?:no|no,|nope|ok|okej|okay|super|spoko|git|dobrze|dziękuję|dzieki|thanks|"
+    r"thank\s+you|thx|why|czemu|dlaczego|ale\b)[.!?,\s]|(\?)")
+
+#: Assistant replies that suggest the session recovered after the
+#: correction ("subsequent outcome supports the correction").
+_OUTCOME_MARKERS = ("działa", "dziala", "zrobione", "gotowe", "naprawione",
+                    "passes", "passed", "fixed", "works now", "solved")
+
+_MIN_TEXT = 25
+_MAX_RECORDS = 6
+_MAX_TEXT = 220
+
+_STOPWORDS = {
+    "this", "that", "with", "have", "jest", "nie", "jak", "dla", "ale",
+    "się", "sie", "tym", "tego", "który", "ktore", "ktora", "jestem",
+    "made", "make", "want", "need", "please", "prosze", "proszę", "the",
+    "and", "you", "your", "have", "that", "this", "with", "dont", "don't",
+}
+
+
+def classify_user_message(text: str) -> Optional[str]:
+    """Classify one user turn: ``correction`` | ``approach_redirect`` |
+    ``preference`` | ``new_requirement`` | ``None`` (not a candidate).
+
+    ``correction`` wins over ``approach_redirect`` when both fire — a
+    rejection with a proposed alternative is recorded as the correction
+    it is; the redirect nuance lives in the text, not the label.
+    """
+    t = (text or "").strip()
+    if len(t) < _MIN_TEXT or _AMBIGUITY.search(t[:24] or t):
+        return None
+    corr = _CORRECTION_HINTS.search(t)
+    pref = _PREFERENCE_HINTS.search(t)
+    # Earliest explicit signal wins: "Preferuję małe commity zamiast jednego
+    # dużego" states a preference — the comparative "zamiast" is not a
+    # rejection — while "Nie twórz X, zamiast tego użyj Y" leads with the
+    # rejection. Ties resolve to correction (the class the gate and priority
+    # ranking are calibrated for).
+    if pref and (not corr or pref.start() < corr.start()):
+        return "preference"
+    if corr:
+        return "correction"
+    if _REQUIREMENT_HINTS.search(t):
+        return "new_requirement"
+    return None
+
+
+def user_corrections(ep: Any, max_items: int = _MAX_RECORDS) -> List[Dict[str, Any]]:
+    """Extract user-correction evidence records from one episode.
+
+    Each record pairs the correction with the assistant turn it targets
+    (nearest preceding assistant message, tool rows skipped) and carries
+    provenance (source host, session id, workspace, message index) plus
+    ``outcome_supported`` — whether the next assistant reply suggests the
+    session recovered after the correction. Message text arrives already
+    secret-redacted from the readers; nothing is added back.
+    """
+    records: List[Dict[str, Any]] = []
+    msgs = list(getattr(ep, "messages", []))
+    for i, m in enumerate(msgs):
+        if getattr(m, "role", "") != "user":
+            continue
+        cls = classify_user_message(m.text or "")
+        if cls is None:
+            continue
+        assistant_text = ""
+        for j in range(i - 1, -1, -1):
+            if msgs[j].role == "assistant":
+                assistant_text = msgs[j].text or ""
+                break
+        outcome = False
+        for j in range(i + 1, len(msgs)):
+            if msgs[j].role == "assistant":
+                low = (msgs[j].text or "").lower()
+                outcome = any(k in low for k in _OUTCOME_MARKERS)
+                break
+        records.append({
+            "action": f"user_correction:{getattr(ep, 'source', '')}:"
+                      f"{str(getattr(ep, 'session_id', ''))[:12]}#{i}",
+            "score": 0.0,
+            "errors": [
+                f"user said: {(m.text or '')[:_MAX_TEXT]}",
+                f"assistant had: {assistant_text[:_MAX_TEXT]}",
+                f"outcome: {'confirmed' if outcome else 'unverified'}",
+            ],
+            "kind": "user_correction",
+            "class": cls,
+            "source": getattr(ep, "source", ""),
+            "session_id": getattr(ep, "session_id", ""),
+            "cwd": getattr(ep, "cwd", ""),
+            "msg_index": i,
+            "outcome_supported": outcome,
+            "repeats": 1,
+            "occurrences": 1,
+        })
+    return records[-max_items:]
+
+
+def _content_words(text: str) -> frozenset:
+    words = re.findall(r"[a-ząćęłńóśźż]{4,}", (text or "").lower())
+    return frozenset(w for w in words if w not in _STOPWORDS)
+
+
+def dedupe_corrections(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Collapse near-identical corrections before any paid curator call.
+
+    Two records merge when their content words overlap (Jaccard >= 0.6).
+    Repeats inside ONE episode do not strengthen the evidence: ``repeats``
+    counts distinct episodes behind the observation, ``occurrences`` the
+    raw message count (issue §3).
+    """
+    kept: List[Dict[str, Any]] = []
+    sigs: List[frozenset] = []
+    for rec in records:
+        sig = _content_words(" ".join(rec.get("errors", [])))
+        merged = False
+        for k, (old, old_sig) in enumerate(zip(kept, sigs)):
+            if old_sig and sig and (len(sig & old_sig) / len(sig | old_sig)) >= 0.6:
+                old["occurrences"] += 1
+                if old.get("session_id") != rec.get("session_id"):
+                    old["repeats"] += 1
+                if rec.get("outcome_supported") and not old.get("outcome_supported"):
+                    old["outcome_supported"] = True
+                    old["errors"] = list(old["errors"])[:2] + ["outcome: confirmed"]
+                merged = True
+                break
+        if not merged:
+            kept.append(rec)
+            sigs.append(sig)
+    return kept
+
+
+def prioritize_corrections(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Highest-priority first (issue §3): confirmed outcome > repeated
+    across episodes > bare correction > preference. Stable sort."""
+    def rank(r: Dict[str, Any]) -> tuple:
+        return (
+            3 if r.get("outcome_supported") else 0,
+            2 if r.get("repeats", 1) >= 2 else 0,
+            1 if r.get("class") == "correction" else 0,
+        )
+    return sorted(records, key=rank, reverse=True)
+
+
+def distillable(records: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """Records eligible for the existing curator flow: corrections,
+    redirects and preferences — never new requirements or unclassified
+    turns (issue §1/§3: a task expansion is not evidence of a mistake)."""
+    return [r for r in records
+            if r.get("class") in ("correction", "approach_redirect", "preference")]

package/open_dream_rsi/cursor_agent.py

@@ -19,7 +19,7 @@ import os
 import shutil
 import subprocess
 import sys
-from typing import Any, Dict, List, Optional
+from typing import Dict, List, Optional
 
 #: Hard ceiling for one headless agent turn. The curator's distill prompt is
 #: small; a hang here must not stall the dream cycle.

package/open_dream_rsi/dream.py

@@ -144,6 +144,46 @@ def _append_probe_tasks(memory_root: Path, probes: List[Dict[str, Any]]) -> int:
     return added
 
 
+#: Queue backstop: how many probe tasks may sit in tasks.json once they have
+#: been processed. The fair queue (AutoRSIRuntime.fair_queue) is the actual
+#: starvation fix — this cap only retires OLD, already-attempted probes.
+MAX_PROBE_TASKS = 60
+
+
+def _cap_probe_queue(memory_root: Path) -> int:
+    """Retire old probe tasks AFTER they were processed (backstop, not the
+    fix). A probe that never got an attempt is NEVER dropped — unprocessed
+    work always deserves its turn, and the fair queue guarantees it gets
+    one before the tail of the backlog. Returns the number removed.
+    """
+    tp = memory_root / "tasks.json"
+    try:
+        tasks = json.loads(tp.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return 0
+    probes = [(i, t) for i, t in enumerate(tasks)
+              if str(t.get("task_id", "")).startswith("probe:")]
+    if len(probes) <= MAX_PROBE_TASKS:
+        return 0
+    try:
+        attempts = json.loads((memory_root / "task_attempts.json")
+                              .read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        attempts = {}
+    # probe ids embed a sortable timestamp: oldest first
+    probes.sort(key=lambda it: str(it[1].get("task_id", "")))
+    stale = probes[:-MAX_PROBE_TASKS]
+    drop = {i for i, t in stale
+            if int(attempts.get(str(t.get("task_id")), 0)) > 0}
+    if not drop:
+        return 0
+    out = [t for i, t in enumerate(tasks) if i not in drop]
+    tmp = tp.with_suffix(".json.tmp")
+    tmp.write_text(json.dumps(out, indent=1), encoding="utf-8")
+    tmp.replace(tp)
+    return len(drop)
+
+
 def ingest_sessions(memory, sessions_db: "str | Path", *,
                     source: str = "hermes",
                     limit: int = 25, client=None,
@@ -164,6 +204,11 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
                                              evidence_snippets,
                                              KnowledgeCurator)
     from open_dream_rsi.sessions import episode_failures, read_hermes_sessions
+    from open_dream_rsi.corrections import (
+        dedupe_corrections,
+        distillable,
+        user_corrections,
+    )
 
     root = Path(memory.root)
     state = _load_state(root)
@@ -191,13 +236,28 @@ def ingest_sessions(memory, sessions_db: "str | Path", *,
     added_total = 0
     deferred = 0
     probes: List[Dict[str, Any]] = []
-    for ep in new:
+    # Issue #6: user corrections are a second evidence class. Collect per
+    # episode, dedupe deterministically ACROSS the batch before any paid
+    # curator call, then distil failures + surviving corrections together
+    # — one pipeline, one gate, no second learning path.
+    ep_evidence = [(ep, episode_failures(ep), user_corrections(ep))
+                   for ep in new]
+    all_corr = distillable(
+        dedupe_corrections([c for _, _, cs in ep_evidence for c in cs]))
+    kept = {(c.get("session_id"), c.get("msg_index")) for c in all_corr}
+    for ep, failures, corr_raw in ep_evidence:
         seen.add(ep.session_id)
-        failures = episode_failures(ep)
-        if not failures:
+        corrections = [c for c in corr_raw
+                       if (c.get("session_id"), c.get("msg_index")) in kept]
+        if corrections:
+            memory.log_event("user_correction_found", source=ep.source,
+                             session_id=ep.session_id, count=len(corrections),
+                             classes=[c.get("class", "") for c in corrections][:6])
+        evidence = failures + corrections
+        if not evidence:
             continue
         cat = category or (Path(ep.cwd).name if ep.cwd else ep.source)
-        distilled, err = curator.distill(cat, ep.title or cat, failures,
+        distilled, err = curator.distill(cat, ep.title or cat, evidence,
                                          memory.get_lessons(cat))
         if err and err.startswith("llm error"):
             # Transport failure (connect/HTTP/response shape): this session
@@ -242,7 +302,7 @@ def dream_once(memory_root: "str | Path", *,
                session_source: str = "hermes",
                skills_out: "str | Path | None" = None,
                client=None, tasks: Optional[List[Any]] = None,
-               budget: int = 20, max_tokens: int = 4096,
+               budget: int = 20, max_tokens: int = 100_000,
                category: Optional[str] = None,
                min_new_evidence: int = DEFAULT_MIN_NEW_EVIDENCE,
                max_age_seconds: float = DEFAULT_MAX_AGE_SECONDS) -> Dict[str, Any]:
@@ -291,6 +351,12 @@ def dream_once(memory_root: "str | Path", *,
             state["last_full_dream"] = time.time()
             _save_state(root, state)
 
+        # 3b. queue backstop — AFTER processing, never before. Starvation is
+        # fixed by the loop's fair queue (least-processed task first); this
+        # cap only retires probes that already had their one attempt. A probe
+        # never attempted is NEVER dropped — it still deserves its turn.
+        report["queue_pruned"] = _cap_probe_queue(root)
+
         # 4. publish earned knowledge (cheap; surfaces new ACTIVE lessons)
         if skills_out:
             report["skills"] = len(lessons_to_skills(memory, skills_out))

package/open_dream_rsi/evolution.py

@@ -0,0 +1,88 @@
+"""Anytime-valid stopping for policy evolution.
+
+Inspired by "When Is Enough Enough in Self-Evolving LLM Systems?"
+(arXiv:2610.04756): self-evolving loops that run to a fixed budget waste
+compute after improvement saturates and risk overfitting the evaluation
+signal with late updates. The paper's answer is a betting-martingale
+stopping rule over paired evaluation outcomes plus a change-point choice
+of the artifact to output.
+
+Mapped onto this loop (policy evolution only, opt-in):
+
+* the paired outcome per round is binary — did the category's policy
+  regeneration PROMOTE this cycle (evidence of life) or not;
+* ``p0`` (the null "still improvable" rate) is calibrated from the first
+  ``calibration`` rounds and floored at 0.5, so a dead category still
+  alarms — just later (~8 betting rounds at lambda=0.5);
+* each non-promoting round multiplies the wealth by
+  ``1 - lam + lam * (1 - x) / (1 - p0)`` (> 1 on a miss, < 1 on a
+  promotion — promotions crash the wealth, evidence of life resets
+  progress); each factor is positive, so the test is anytime-valid at
+  level ``alpha`` with threshold ``1/alpha``;
+* "what to output" is trivial here: the loop never discards the incumbent
+  on freezing — the last PROMOTED policy stays active and only
+  regeneration spending stops.
+
+Stdlib only. The stopper is in-memory runtime state; freezing is an
+economic decision, not a correctness surface.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+
+class EvolutionStopper:
+    """Per-category wealth process over promotion outcomes."""
+
+    def __init__(self, alpha: float = 0.05, lam: float = 0.5,
+                 calibration: int = 3, min_rounds: int = 4,
+                 threshold: Optional[float] = None) -> None:
+        self.alpha = float(alpha)
+        self.lam = float(min(max(float(lam), 0.05), 0.95))
+        self.calibration = max(int(calibration), 1)
+        self.min_rounds = max(int(min_rounds), 1)
+        self.threshold = float(threshold if threshold is not None
+                               else 1.0 / self.alpha)
+        self._state: Dict[str, Dict[str, Any]] = {}
+
+    def observe(self, category: str, promoted: bool) -> Dict[str, Any]:
+        """Record one round (cycle) for ``category``; return the decision."""
+        st = self._state.setdefault(category, {
+            "rounds": 0, "history": [], "wealth": 1.0,
+            "p0": None, "frozen": False, "alarm_round": None,
+        })
+        if st["frozen"]:
+            return {"frozen": True, "wealth": st["wealth"], "p0": st["p0"],
+                    "rounds": st["rounds"], "alarm_round": st["alarm_round"]}
+        st["rounds"] += 1
+        x = 1 if promoted else 0
+        st["history"].append(x)
+        if st["p0"] is None:
+            # calibration window: no betting yet
+            if len(st["history"]) >= self.calibration:
+                rate = sum(st["history"]) / len(st["history"])
+                # conservative floor: a never-promoting category still
+                # detects as dead, just slower (f(0) = 1.5 per miss);
+                # cap at 0.99 — a perfect calibration window means the
+                # first miss is massive evidence (f(0) = 50.5), not inf
+                st["p0"] = min(max(rate, 0.5), 0.99)
+        else:
+            factor = 1.0 - self.lam + self.lam * ((1.0 - x) / (1.0 - st["p0"]))
+            st["wealth"] *= factor
+        if (st["rounds"] >= self.min_rounds
+                and st["wealth"] >= self.threshold):
+            st["frozen"] = True
+            st["alarm_round"] = st["rounds"]
+        return {"frozen": st["frozen"], "wealth": st["wealth"],
+                "p0": st["p0"], "rounds": st["rounds"],
+                "alarm_round": st["alarm_round"]}
+
+    def is_frozen(self, category: str) -> bool:
+        st = self._state.get(category)
+        return bool(st and st["frozen"])
+
+    def reset(self, category: Optional[str] = None) -> None:
+        if category is None:
+            self._state.clear()
+        else:
+            self._state.pop(category, None)

package/open_dream_rsi/loop.py

@@ -38,6 +38,7 @@ from open_dream_rsi.core.curator import (
     select_lessons,
 )
 from open_dream_rsi.core.dreamer import DreamEngine
+from open_dream_rsi.evolution import EvolutionStopper
 from open_dream_rsi.core.policygen import (
     PolicyGenerator,
     PolicySandbox,
@@ -206,7 +207,9 @@ class AutoRSIRuntime:
         explore_epsilon: float = 0.15,
         rng_seed: int = 0,
         enable_judge: bool = True,
+        fair_queue: bool = True,
         sentinel_engine: Any = None,
+        enable_evolution_stop: bool = False,
         alm: Optional["ArtifactLifecycleManager"] = None,
     ):
         self.client = client
@@ -231,6 +234,12 @@ class AutoRSIRuntime:
         self.enable_judge = enable_judge
         self._judge = LLMJudge(client, max_tokens=256) if enable_judge else None
         self._rng = random.Random(rng_seed)
+        # Fair queue: order the task list by processed-attempt count (least
+        # processed first) so a budget-capped cycle can never starve the
+        # tail of the backlog — starvation is fixed by PROCESSING, and the
+        # prune in dream_once stays what it is: a backstop, not the fix.
+        # Benchmarks pin this OFF so published arm numbers stay byte-stable.
+        self.fair_queue = fair_queue
         # Section-3 "dreaming with code": the LLM rewrites the exploration
         # policy itself; promoted candidates steer tree expansion online.
         self.enable_policy_code = enable_policy_code
@@ -257,6 +266,13 @@ class AutoRSIRuntime:
         # episode's stop cause is recorded (node.termination_reason).
         # Default None = trees byte-identical to pre-observation runs.
         self.sentinel = sentinel_engine
+        # Anytime-valid evolution stopping (opt-in; arXiv:2610.04756): a
+        # betting martingale per category over "did regeneration promote
+        # this cycle". After an alarm the loop keeps the last promoted
+        # policy and stops spending calls on regeneration attempts.
+        self.enable_evolution_stop = enable_evolution_stop
+        self._evolution = EvolutionStopper()
+        self._cycle_policy_promoted: set = set()
         # Artifact Lifecycle Manager (issue #3): the loop OWNS learning —
         # what to create and whether a promotion is earned — the ALM OWNS
         # lifecycle bookkeeping (validation, activation events, staleness,
@@ -422,18 +438,40 @@ class AutoRSIRuntime:
         report = CycleReport()
         self._drain_staging(report)      # gate leftovers from previous cycles
         tasks = self._tasks() if callable(self._tasks) else list(self._tasks)
+        if self.fair_queue and len(tasks) > 1:
+            # Least-processed first (stable: ties keep queue order) so a
+            # budget-capped cycle rotates through the backlog instead of
+            # always dying at the same head — starvation is fixed by
+            # PROCESSING; the queue cap downstream is only a backstop.
+            attempts = self.memory.get_all_task_attempts()
+            tasks = sorted(tasks, key=lambda t: attempts.get(t.task_id, 0))
         self._emit("cycle_start", tasks=[t.task_id for t in tasks])
+        attempted_categories: set = set()
         for task in tasks:
             if self.api_calls_used >= self.api_call_budget:
                 report.stopped_reason = "api_budget_exhausted"
                 break
+            attempted_categories.add(task.category)
             solved, improved = self._work_on_task(task, report)
+            self.memory.record_task_attempt(task.task_id)
             report.tasks_attempted += 1
             if solved:
                 report.tasks_solved += 1
             if improved:
                 report.improvements.append(improved)
 
+        if self.enable_evolution_stop:
+            for cat in sorted(attempted_categories):
+                prev = self._evolution.is_frozen(cat)
+                d = self._evolution.observe(
+                    cat, promoted=cat in self._cycle_policy_promoted)
+                if d["frozen"] and not prev:
+                    self.memory.log_event(
+                        "evolution_alarm", category=cat, rounds=d["rounds"],
+                        wealth=round(d["wealth"], 4), p0=d["p0"])
+                    self._emit("evolution_alarm", category=cat,
+                               rounds=d["rounds"])
+            self._cycle_policy_promoted.clear()
         self.memory.log_event("cycle", **report.to_dict())
         self._emit("cycle_done", **report.to_dict())
         self._alm_maintenance()
@@ -475,8 +513,12 @@ class AutoRSIRuntime:
                 continue
             verdict = headroom_verdict(self.memory.get_task_outcomes(cat))
             if not verdict["has_headroom"]:
+                # verdict carries its own ``reason``; fold it into a field
+                # that cannot collide with the log_event kwarg (TypeError).
+                v = dict(verdict)
+                v["headroom_reason"] = v.pop("reason", "")
                 self.memory.log_event("lesson_gate_skipped", category=cat,
-                                      reason="no_headroom", **verdict)
+                                      reason="no_headroom", **v)
                 continue
             self._gate_staging_lessons(task, staged, report)
 
@@ -896,6 +938,8 @@ class AutoRSIRuntime:
         """Section-3 step: LLM rewrites the exploration policy, gate promotes on evidence."""
         if not self.enable_policy_code or self.api_calls_used >= self.api_call_budget:
             return
+        if self.enable_evolution_stop and self._evolution.is_frozen(task.category):
+            return
         entry = self.memory.get_policy_code(task.category)
         if solved and entry:
             # the category already solves itself — exploration calls are for
@@ -944,6 +988,7 @@ class AutoRSIRuntime:
             return
         if self.memory.save_policy_code(task.category, result.source, result.score,
                                         steps=steps):
+            self._cycle_policy_promoted.add(task.category)
             report.improvements.append(
                 f"{task.category}: new exploration policy (replay {result.score:.3f})")
             self.memory.log_event("policy_promoted", task_id=task.task_id,
@@ -977,8 +1022,10 @@ class AutoRSIRuntime:
         if not verdict["has_headroom"]:
             # v3-v9 measured: no injection mechanism beats a cheap cold
             # baseline — do not spend a curator or gate call on this category.
+            v = dict(verdict)
+            v["headroom_reason"] = v.pop("reason", "")
             self.memory.log_event("lesson_gate_skipped", category=task.category,
-                                  reason="no_headroom", **verdict)
+                                  reason="no_headroom", **v)
             return
         existing = self.memory.get_lessons(task.category)
         seen_evidence = set(self.memory.get_digested(task.category))

package/open_dream_rsi/mcp.py

@@ -28,7 +28,7 @@ import json
 import os
 import sys
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 PROTOCOL_VERSION = "2025-06-18"
 SERVER_NAME = "open-dream-rsi"
@@ -194,7 +194,7 @@ def tool_odr_run_once(args: Dict[str, Any]) -> Dict[str, Any]:
         memory=DreamMemory(_memory_root(args)),
         tasks=tasks,
         api_call_budget=int(args.get("budget", 10)),
-        max_tokens=int(args.get("max_tokens", 4096)),
+        max_tokens=int(args.get("max_tokens", 100_000)),
         # Thought-conditioned branching ships ON (library default): attempts
         # record their PLAN line, proposals see the tried-idea ledger, and
         # expansion leaves dead idea families. Harnesses can opt out.
@@ -236,7 +236,7 @@ def tool_odr_dream(args: Dict[str, Any]) -> Dict[str, Any]:
         skills_out=args.get("skills_out") or os.environ.get("ODR_SKILLS_OUT"),
         client=client,
         budget=int(args.get("budget", 20)),
-        max_tokens=int(args.get("max_tokens", 4096)),
+        max_tokens=int(args.get("max_tokens", 100_000)),
         category=args.get("category"),
         min_new_evidence=int(args.get("min_new_evidence", 3)),
         max_age_seconds=float(args.get("max_age_seconds", 6 * 3600)),
@@ -305,7 +305,7 @@ TOOLS: Dict[str, Dict[str, Any]] = {
             "thoughts": {"type": "boolean",
                          "description": "thought-conditioned branching (default true)"},
             "max_tokens": {"type": "integer",
-                           "description": "completion budget per LLM call (default 4096; "
+                           "description": "completion budget per LLM call (default 100000; "
                                           "raise for reasoning models)"},
             "timeout": {"type": "number",
                         "description": "seconds per LLM call (default 300; slow local "

package/open_dream_rsi/memory.py

@@ -149,6 +149,25 @@ class DreamMemory:
         data = self._load(self.root / "task_outcomes.json", {})
         return list(data.get(category, []))
 
+    # -- per-task attempt counters (queue fairness) --------------------------------
+
+    def record_task_attempt(self, task_id: str) -> None:
+        """Count one processed cycle for a task. The fairness ordering in
+        ``run_once`` reads these so a task that never got its turn moves to
+        the FRONT of the next queue — backlog starvation is fixed by
+        processing, not by pruning."""
+        data = self._load(self.root / "task_attempts.json", {})
+        data[task_id] = int(data.get(task_id, 0)) + 1
+        self._save(self.root / "task_attempts.json", data)
+
+    def get_task_attempts(self, task_id: str) -> int:
+        data = self._load(self.root / "task_attempts.json", {})
+        return int(data.get(task_id, 0))
+
+    def get_all_task_attempts(self) -> Dict[str, int]:
+        """Whole attempt-count map (one file read for a whole cycle)."""
+        return dict(self._load(self.root / "task_attempts.json", {}))
+
     # -- digested failure evidence (survives lesson pruning) ----------------------
 
     def get_digested(self, category: str) -> List[str]:

package/open_dream_rsi/py.typed

@@ -0,0 +1 @@
+Marking this package as providing inline type information (PEP 561).

package/open_dream_rsi/sandbox.py

@@ -21,6 +21,7 @@ container) so the OS enforces what the AST gate cannot.
 
 from __future__ import annotations
 
+import logging
 import os
 import shlex
 import signal
@@ -128,6 +129,31 @@ def jail_prefix() -> List[str]:
     return shlex.split(raw) if raw else []
 
 
+#: Set once the no-jail warning has been logged in this process.
+_JAIL_WARNED = False
+
+
+def _warn_no_jail_once() -> None:
+    """Log a one-time warning when generated code runs without a jail.
+
+    ``python -I`` plus rlimits is defence in depth only: it does NOT restrict
+    filesystem or network access. Deployments that ingest hostile task
+    sources should set ``ODR_SANDBOX_CMD`` or containerise the loop (see
+    ``SECURITY.md``).
+    """
+    global _JAIL_WARNED
+    if _JAIL_WARNED or jail_prefix():
+        return
+    _JAIL_WARNED = True
+    logging.getLogger(__name__).warning(
+        "ODR_SANDBOX_CMD is unset: generated code runs with process isolation "
+        "only (python -I, rlimits, process-group kill) and NO filesystem or "
+        "network restriction. For hostile task sources set ODR_SANDBOX_CMD "
+        "(e.g. 'bwrap --unshare-all --die-with-parent --ro-bind / /') or run "
+        "the loop inside a container - see SECURITY.md."
+    )
+
+
 def run_isolated(
     argv: List[str],
     *,
@@ -143,7 +169,12 @@ def run_isolated(
 
     Raises the same :class:`subprocess.TimeoutExpired` as ``subprocess.run``
     so callers keep their existing handling.
+
+    POSIX gets the full wall (rlimits + whole-process-group kill); on Windows
+    there are no rlimits and the timeout kills only the direct child — treat
+    Windows as out of scope for hostile task sources.
     """
+    _warn_no_jail_once()
     argv = [*jail_prefix(), *argv]
     env = SANDBOX_ENV if env is None else env
     kwargs = {}

package/open_dream_rsi/share.py

@@ -31,7 +31,7 @@ import subprocess
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 from open_dream_rsi.sessions import redact_secrets
 

package/open_dream_rsi/utils/goose.py

@@ -26,7 +26,7 @@ import subprocess
 import sys
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 #: Env var that overrides the goose config dir (useful in tests / CI).
 CONFIG_DIR_ENV = "ODR_GOOSE_CONFIG_DIR"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-open-dream-rsi",
-  "version": "0.2.3",
+  "version": "0.3.8",
   "description": "Let your coding agent dream: strategies must survive counterfactual replay before they earn trust. An offline self-improvement loop over an evolving world model — no fine-tuning, the LLM stays frozen. Speaks MCP. Ships its Python server inside the package — the only requirement is a system python3 (3.10+) on PATH — and the plugin's bridge serves the dreamer's LLM calls from the model your harness is already configured with (no API keys, no env, no extra endpoints).",
   "type": "module",
   "license": "MIT",