diff --git a/predicators/agent_sdk/belief_probe.py b/predicators/agent_sdk/belief_probe.py
index 96e0f7509..0ddab1a7a 100644
--- a/predicators/agent_sdk/belief_probe.py
+++ b/predicators/agent_sdk/belief_probe.py
@@ -177,9 +177,13 @@ class _StrLikeResult:
     """String conveniences shared by the probe result types.
 
     The results print like strings, so agents naturally slice
-    (``res[-800:]``) and search (``'Goal reached: True' in res``) them;
-    without these dunders both moves are ``TypeError``s that cost a
-    recovery turn (and recur after compaction erases the lesson).
+    (``res[-800:]``), search (``'Goal reached: True' in res``), and call
+    string methods (``res.split('\\n')`` destroyed a 1200 s refine
+    result in run_20260830_145216 - AttributeError, then a full
+    identical re-run); without these both moves are errors that cost a
+    recovery turn (and recur after compaction erases the lesson). Any
+    ``str`` method not shadowed by a real attribute delegates to the
+    rendered report, so the whole string API works.
     """
 
     @property
@@ -196,6 +200,16 @@ def __contains__(self, item: str) -> bool:
     def __len__(self) -> int:
         return len(repr(self))
 
+    def __getattr__(self, name: str) -> Any:
+        # Only reached for attributes not found normally (dataclass
+        # fields and real methods take precedence). Delegate public str
+        # methods (.split, .splitlines, .find, .lower, ...) to the
+        # rendered report; anything else raises AttributeError as usual.
+        if not name.startswith("_") and hasattr(str, name):
+            return getattr(repr(self), name)
+        raise AttributeError(
+            f"{type(self).__name__!r} object has no attribute {name!r}")
+
 
 @dataclasses.dataclass(repr=False)
 class ProbeResult(_StrLikeResult):
@@ -271,7 +285,8 @@ def __repr__(self) -> str:
                     "trial - the rate estimates real execution reliability"
                     if self.fresh_env_per_trial else
                     "shared session env - trials are correlated, treat the "
-                    "rate as optimistic")
+                    "rate as optimistic; this session has no fresh-env "
+                    "scope, so fresh=True is likewise unavailable")
         scored = [t for t in self.trials if t.get("solved") is not None]
         headline = f"Trials: {self.successes}/{n} reached the goal"
         if scored:
@@ -834,8 +849,11 @@ def state(
     ) -> Union[Dict[str, Dict[str, float]], Dict[str, float]]:
         """Full-precision feature dict of the current state.
 
-        ``state()`` -> ``{obj: {feat: value}}`` for all objects;
-        ``state("domino_1")`` -> that object's ``{feat: value}``.
+        ``state()`` -> ``{"name:type": {feat: value}}`` for all objects
+        - keys use the same ``name:type`` form as atoms, plan lines, and
+        the prompt, so a key read anywhere else indexes here directly;
+        ``state("domino_1")`` and ``state("domino_1:domino")`` both ->
+        that object's ``{feat: value}``.
         """
         cur = self._require_state()
 
@@ -847,13 +865,17 @@ def _features(obj: Any) -> Dict[str, float]:
 
         if obj_name is not None:
             # Sweep loops call the single-object form per iteration;
-            # keep it O(one object), not O(scene).
+            # keep it O(one object), not O(scene). Accept both the bare
+            # name and the name:type form every other surface prints
+            # (bare-only lookups cost a KeyError per session:
+            # run_20260830 hit it in four sessions).
+            bare = obj_name.split(":", 1)[0]
             for obj in cur:
-                if obj.name == obj_name:
+                if obj.name == bare:
                     return _features(obj)
             raise ValueError(f"Unknown object '{obj_name}'. Available: "
-                             f"{sorted(o.name for o in cur)}")
-        return {obj.name: _features(obj) for obj in sorted(cur, key=str)}
+                             f"{sorted(str(o) for o in cur)}")
+        return {str(obj): _features(obj) for obj in sorted(cur, key=str)}
 
     def atoms(self) -> List[str]:
         """Sorted ground atoms true in the current state."""
@@ -1074,7 +1096,12 @@ def run(
         ``submit_plan``'s validation rollouts report theirs the
         same way. A single run (``trials=1``) executes entirely at
         ``S``; a physics sweep runs every point at ``S`` instead of the
-        base.
+        base. Without ``seed=``, and from the task's unmodified initial
+        state (plain ``reset()``, no rollout since), ``trials=N`` runs
+        the IDENTICAL rollout set as ``submit_plan``'s N-rollout capture
+        gate (fresh env per rollout, planner seeds ``base..base+N-1``),
+        so a trials score here is exactly the gate's verdict on this
+        plan.
 
         SUBSTRATE: a default single run executes on the WARM shared
         session env from the probe's current state - a feature for
@@ -1135,13 +1162,16 @@ def run(
         ctx.test_call_id += 1
         probe_task, sketch_steps, all_predicates, notices = \
             self._parse_sketch(plan_text)
+        # Ground via the shared helper so an annotated Wait waits for
+        # its annotated atoms here exactly as in refine, submit_plan,
+        # and real execution (see submit_plan's grounding comment).
         grounded: List[Any] = []
         for st in sketch_steps:
             params = (st.initial_params if st.initial_params is not None else
                       np.array([], dtype=np.float32))
             grounded.append(
-                st.option.ground(list(st.objects),
-                                 np.asarray(params, dtype=np.float32)))
+                bilevel_sketch.ground_step(
+                    st, np.asarray(params, dtype=np.float32)))
 
         report_preds = ctx.predicates
 
@@ -1177,8 +1207,12 @@ def _horizon_note(total_actions: int) -> Optional[str]:
                     "physics_sweep=True, but no identified physical "
                     "parameters with nonzero posterior width are deployed "
                     "this cycle, so there is no uncertainty range to "
-                    "sweep. Use trials= to measure execution reliability "
-                    "at the current physics instead.")
+                    "sweep. (submit_plan's rule-parameter ensemble margin "
+                    "is a different, automatic gate over the learned rule "
+                    "constants - it still runs at submission and is not "
+                    "reachable through physics_sweep.) Use trials= to "
+                    "measure execution reliability at the current physics "
+                    "instead.")
             point_dicts: List[Dict[str, Any]] = []
             all_points: List[Optional[Dict[str, float]]] = \
                 [None] + sweep_points
@@ -1462,6 +1496,14 @@ def _on_step(i: int, outcome: Any) -> None:
             img = render_scene_image(
                 ctx,
                 f"probe_step_{i}_{outcome.option.name}") if render else None
+            if (outcome.option.name == "Wait" and failure is None and
+                    outcome.num_actions >= CFG.max_num_steps_option_rollout):
+                notices.append(
+                    f"step {i} (Wait) ran to the option-rollout cap "
+                    f"({outcome.num_actions} actions): its wait-target "
+                    "atoms never became true in the belief (and no other "
+                    "atom changed). Check whether the awaited change is "
+                    "modeled, or drop the Wait.")
             step_dicts.append({
                 "option":
                 sig,
@@ -2011,9 +2053,20 @@ def gated_solved_check(states: List[State], labels: List[Any],
                        "full rollout of these params as a solve.")
         elif require_goal:
             verdict = ("goal-reached - the task's goal atoms held at the "
-                       "final step; no evaluator verdict (use "
-                       "require_solved=True from a pristine reset() for "
-                       "that).")
+                       "final step")
+            # Recommend the evaluator gate only when the task HAS an
+            # evaluator: sessions without one wasted a call per session
+            # following this advice into "this task defines no task
+            # evaluator" (run_20260830, three sessions).
+            if (self._base_task is not None
+                    and self._base_task.evaluator is not None):
+                verdict += ("; no evaluator verdict (use "
+                            "require_solved=True from a pristine reset() "
+                            "for that).")
+            else:
+                verdict += (" (this task defines no evaluator, so "
+                            "goal-reached is the strongest verdict "
+                            "available).")
         else:
             verdict = ("executed - every step established its subgoal "
                        "annotation; the task goal was NOT checked (set "
diff --git a/predicators/agent_sdk/bilevel_sketch.py b/predicators/agent_sdk/bilevel_sketch.py
index 6feed94c5..ff66682b1 100644
--- a/predicators/agent_sdk/bilevel_sketch.py
+++ b/predicators/agent_sdk/bilevel_sketch.py
@@ -8,8 +8,9 @@
 - ``sketch_types``: shared dataclasses (``GroundSampler``,
   ``SketchStep``) that parsing constructs and refinement/execution
   consume.
-- ``sketch_prompts``: ``build_solve_prompt``, the solve/explore prompt
-  builder.
+- ``sketch_prompts``: ``build_solve_system_prompt`` and
+  ``build_solve_prompt``, the solve/explore system-prompt and query
+  builders (rendered from ``prompts/*.md``).
 - ``sketch_parsing``: the sketch-line grammar - step/plan formatters
   and the parsers for subgoal / ``~`` ground-sampler annotations and
   continuous params.
@@ -26,7 +27,8 @@
     parse_region_annotations, parse_sketch_from_text, \
     parse_subgoal_annotations, strip_code_fences, strip_region_annotations, \
     strip_subgoal_annotations
-from predicators.agent_sdk.sketch_prompts import build_solve_prompt
+from predicators.agent_sdk.sketch_prompts import build_early_stop_note, \
+    build_solve_prompt, build_solve_system_prompt
 from predicators.agent_sdk.sketch_refinement import DeepestFailure, \
     InfoScorer, RefineOutcome, StepProbeSuggestion, ground_step, \
     refine_and_validate_report, refine_sketch, resolve_refine_timeout, \
@@ -42,7 +44,9 @@
     "SketchStep",
     "StepOutcome",
     "StepProbeSuggestion",
+    "build_early_stop_note",
     "build_solve_prompt",
+    "build_solve_system_prompt",
     "execute_plan_forward",
     "format_plan_lines",
     "format_sketch_lines",
diff --git a/predicators/agent_sdk/docker_sandbox.py b/predicators/agent_sdk/docker_sandbox.py
index 16607556a..69ec6dd8c 100644
--- a/predicators/agent_sdk/docker_sandbox.py
+++ b/predicators/agent_sdk/docker_sandbox.py
@@ -73,8 +73,8 @@
 _STDERR_TAIL_LINES = 20
 
 # Build Docker-specific prompts from shared templates.
-# CLAUDE.md is built per-instance with the phase tag so the agent reads
-# phase-appropriate strategy guidance every turn (see build_claude_md).
+# CLAUDE.md (sandbox mechanics only; see build_claude_md) is written
+# into the sandbox when it is populated.
 _SANDBOX_SYSTEM_PROMPT = build_sandbox_system_prompt(
     env_description="an isolated Docker sandbox",
     workspace_description="/sandbox/",
diff --git a/predicators/agent_sdk/journal.py b/predicators/agent_sdk/journal.py
index b5bc3293f..6d45998f3 100644
--- a/predicators/agent_sdk/journal.py
+++ b/predicators/agent_sdk/journal.py
@@ -96,7 +96,12 @@ def read_strategy(sandbox_dir: Optional[str],
     with open(path, "r", encoding="utf-8") as f:
         content = f.read().strip()
     if len(content) > max_chars:
-        content = (content[:max_chars].rstrip() +
+        # Cut at a line boundary, never mid-word.
+        head = content[:max_chars]
+        cut = head.rfind("\n")
+        if cut > 0:
+            head = head[:cut]
+        content = (head.rstrip() +
                    "\n[strategy truncated at the prompt cap - read "
                    f"./{STRATEGY_FILENAME} for the rest]")
     return content
diff --git a/predicators/agent_sdk/learn_prompts.py b/predicators/agent_sdk/learn_prompts.py
new file mode 100644
index 000000000..9173a12cc
--- /dev/null
+++ b/predicators/agent_sdk/learn_prompts.py
@@ -0,0 +1,231 @@
+"""Prompt construction for the learning (simulator synthesis) phase.
+
+Rendered from ``learn_system.md``, ``learn_message.md``,
+``learn_predicate_invention.md``, and ``learn_partial_observability.md``
+in ``predicators/agent_sdk/prompts`` (see :mod:`prompt_templates`). The
+approach classes gather the per-instance values (digests, data roster,
+reports, paths) and call these pure builders, so every prompt can be
+rendered and reviewed without a live session.
+"""
+import re
+from typing import Any, Mapping, Sequence
+
+from predicators.agent_sdk.prompt_templates import render
+
+_BLANK_RUN_RE = re.compile(r"\n{3,}")
+
+
+def _join(parts: Sequence[str]) -> str:
+    text = "\n\n".join(p.strip("\n") for p in parts if p and p.strip())
+    return _BLANK_RUN_RE.sub("\n\n", text).strip("\n") + "\n"
+
+
+# ---------------------------------------------------------------------------
+# System prompt
+# ---------------------------------------------------------------------------
+
+
+def build_learn_system_prompt(
+    *,
+    partially_observable: bool,
+    residual_rule_signature: str,
+    scene_viz_hint: str,
+    physical_params_section: str = "",
+    extra_sections: Sequence[str] = (),
+    latent_extra_sections: Sequence[str] = (),
+    workflow_extra: str = "",
+) -> str:
+    """Compose the synthesis system prompt.
+
+    ``partially_observable`` selects the recurrent 5-argument rule
+    signature and appends the recurrent-rules tutorial;
+    ``residual_rule_signature`` is the matching ``def`` line for the
+    geometric-gate example. ``physical_params_section`` is the rendered
+    system-identification section (empty when the env reveals no
+    parameters). ``extra_sections`` (subclass additions such as
+    predicate invention) are inserted after the validation guidance;
+    ``latent_extra_sections`` follow the recurrent-rules tutorial (only
+    rendered when ``partially_observable``); ``workflow_extra`` is
+    appended to the workflow's validation step.
+    """
+    signature = render(
+        "learn_system",
+        "rule_signature_po" if partially_observable else "rule_signature_fo")
+    parts = [
+        render("learn_system", "intro"),
+        render("learn_system", "produce"),
+        physical_params_section,
+        signature,
+        render("learn_system", "cmds"),
+        render("learn_system", "multi_object"),
+        render("learn_system", "timing"),
+        render("learn_system",
+               "geometric_gates",
+               residual_rule_signature=residual_rule_signature,
+               scene_viz_hint=scene_viz_hint),
+        render("learn_system", "paramspec"),
+        render("learn_system", "preinjected"),
+        render("learn_system", "tools"),
+        render("learn_system", "validation"),
+        *extra_sections,
+    ]
+    if partially_observable:
+        parts.append(render("learn_partial_observability", "rules"))
+        parts.extend(latent_extra_sections)
+    parts += [
+        render("learn_system", "plan_format"),
+        render("learn_system", "deliverables"),
+        render("learn_system",
+               "workflow",
+               workflow_extra=(" " +
+                               workflow_extra) if workflow_extra else ""),
+    ]
+    return _join(parts)
+
+
+def render_physical_params_section(
+        info: Mapping[str, Mapping[str, Any]]) -> str:
+    """The ``PHYSICAL_PARAMS`` section for a revealed parameter menu.
+
+    ``info`` maps a parameter name to its ``default``, ``lo``, ``hi``,
+    ``description``, and optional ``scale``; empty input renders
+    nothing, so envs without a menu never see the feature mentioned.
+    """
+    if not info:
+        return ""
+    lines = []
+    for name, meta in info.items():
+        scale_note = (", fitted in log-space"
+                      if meta.get("scale") == "log" else "")
+        lines.append(f"- `{name}` (built-in {meta['default']:.4g}, fit "
+                     f"box [{meta['lo']:.4g}, {meta['hi']:.4g}]"
+                     f"{scale_note}): {meta['description']}")
+    return render("learn_system",
+                  "physical_params",
+                  param_list="\n".join(lines))
+
+
+def render_predicate_invention_section(scene_workbench: str) -> str:
+    """The predicate-invention system-prompt section."""
+    return render("learn_predicate_invention",
+                  "system",
+                  scene_workbench=scene_workbench)
+
+
+def render_predicate_latent_section() -> str:
+    """The predicate-side latent guidance (invention arms, PO only)."""
+    return render("learn_partial_observability", "predicates")
+
+
+def render_predicate_workflow_extra() -> str:
+    """The invention arm's addition to the workflow's validation step."""
+    return render("learn_predicate_invention", "workflow_extra")
+
+
+# ---------------------------------------------------------------------------
+# First message
+# ---------------------------------------------------------------------------
+
+
+def build_learn_message(
+        *,
+        n_trajs: int,
+        n_transitions: int,
+        n_demos: int,
+        n_interaction: int,
+        trajectory_listing: str,
+        structs_ref: str,
+        inferred_hint: str,
+        predicate_listing: str,
+        types_digest: str,
+        options_digest: str,
+        simulator_file: str,
+        objective_block: str = "",
+        prior_state_block: str = "",
+        divergence_block: str = "",
+        base_sim_block: str = "",
+        tools_block: str = "",
+        extra_messages: Sequence[str] = (),
+) -> str:
+    """Compose the synthesis session's first message.
+
+    Every block argument is already rendered (see the ``render_*``
+    helpers below) or empty. ``extra_messages`` (predicate invention,
+    partial observability, sampler synthesis) are appended in order.
+    """
+    body = render(
+        "learn_message",
+        "skeleton",
+        n_trajs=str(n_trajs),
+        n_transitions=str(n_transitions),
+        n_demos=str(n_demos),
+        n_interaction=str(n_interaction),
+        trajectory_listing=trajectory_listing.strip("\n"),
+        objective_block=objective_block,
+        prior_state_block=prior_state_block,
+        divergence_block=divergence_block,
+        structs_ref=structs_ref,
+        base_sim_block=base_sim_block,
+        inferred_hint=inferred_hint,
+        predicate_listing=predicate_listing,
+        types_digest=types_digest.strip("\n"),
+        options_digest=options_digest.strip("\n"),
+        tools_block=tools_block,
+        simulator_file=simulator_file,
+    )
+    return _join([body, *extra_messages])
+
+
+def render_divergence_block(report: str, has_prior_model: bool) -> str:
+    """The start-of-session residual report section."""
+    return render("learn_message",
+                  "divergence_prior" if has_prior_model else "divergence_base",
+                  report=report.strip("\n"))
+
+
+def render_base_sim_block(refs: Sequence[str]) -> str:
+    """The base-simulator source listing, or empty."""
+    if not refs:
+        return ""
+    return render("learn_message",
+                  "base_sim",
+                  ref_listing="\n".join(f"  - {r}" for r in refs))
+
+
+def render_tools_block(tool_names: Sequence[str]) -> str:
+    """The session's tool roster, or empty."""
+    if not tool_names:
+        return ""
+    return render("learn_message",
+                  "tools",
+                  tool_listing="\n".join(f"  - {t}" for t in tool_names))
+
+
+def render_objective_block(description: str) -> str:
+    """The env's public task objective section, or empty."""
+    if not description:
+        return ""
+    return render("learn_message", "objective", description=description)
+
+
+def render_prior_state_block(prior_files: Sequence[str]) -> str:
+    """The prior-cycle-state paragraph for the artifacts found, or empty."""
+    if not prior_files:
+        return ""
+    return render("learn_message",
+                  "prior_state",
+                  prior_files=" and ".join(prior_files))
+
+
+def render_predicate_invention_message(predicates_file: str,
+                                       goal_block: str) -> str:
+    """The invention arm's addition to the first message."""
+    return render("learn_predicate_invention",
+                  "message",
+                  predicates_file=predicates_file,
+                  goal_block=goal_block.strip("\n"))
+
+
+def render_partial_observability_message() -> str:
+    """The short partial-observability note for the first message."""
+    return render("learn_partial_observability", "message")
diff --git a/predicators/agent_sdk/local_sandbox.py b/predicators/agent_sdk/local_sandbox.py
index 3b87e9397..37b15453c 100644
--- a/predicators/agent_sdk/local_sandbox.py
+++ b/predicators/agent_sdk/local_sandbox.py
@@ -55,8 +55,8 @@
 _DEADLINE_INTERRUPT_SLACK_S = 180
 
 # Build local-sandbox-specific prompts from shared templates.
-# CLAUDE.md is built per-instance with the phase tag so the agent reads
-# phase-appropriate strategy guidance every turn (see build_claude_md).
+# CLAUDE.md (sandbox mechanics only; see build_claude_md) is written
+# into the sandbox when it is populated.
 _LOCAL_SANDBOX_SYSTEM_PROMPT = build_sandbox_system_prompt(
     env_description="a local sandbox environment",
     workspace_description="the current directory",
diff --git a/predicators/agent_sdk/log_formatter.py b/predicators/agent_sdk/log_formatter.py
index 548e2d307..304da0ad5 100644
--- a/predicators/agent_sdk/log_formatter.py
+++ b/predicators/agent_sdk/log_formatter.py
@@ -52,19 +52,48 @@ def format_conversation_markdown(
     lines.append("## Conversation\n")
 
     turn_num = 0
+    # Duplicate suppression: the SDK can deliver the same assistant
+    # message (and its tool results) more than once, and tool_use /
+    # tool_result ids are unique per call, so a repeated id is always a
+    # re-render of an already-logged turn (run_20260830 transcripts
+    # rendered turns twice verbatim).
+    seen_tool_use_ids: set = set()
+    seen_tool_result_ids: set = set()
     for entry in collected:
         etype = entry.get("type", "")
 
         if etype == "assistant":
+            blocks = entry.get("content", [])
+            ids = [
+                b.get("id") for b in blocks if isinstance(b, dict)
+                and b.get("type") == "tool_use" and b.get("id")
+            ]
+            if ids and all(i in seen_tool_use_ids for i in ids):
+                continue
+            # Render into a buffer first: a turn whose blocks produce no
+            # output (empty or redacted thinking) gets no header at all,
+            # instead of an empty "### Turn N" stub.
+            body: List[str] = []
+            for block in blocks:
+                _format_assistant_block(block, body)
+            if not body:
+                continue
+            seen_tool_use_ids.update(ids)
             turn_num += 1
             if turn_num > 1:
                 lines.append("---\n")
             lines.append(f"### Turn {turn_num}\n")
-            for block in entry.get("content", []):
-                _format_assistant_block(block, lines)
+            lines.extend(body)
 
         elif etype == "user":
             for block in entry.get("content", []):
+                if (isinstance(block, dict)
+                        and block.get("type") == "tool_result"):
+                    tid = block.get("tool_use_id")
+                    if tid and tid in seen_tool_result_ids:
+                        continue
+                    if tid:
+                        seen_tool_result_ids.add(tid)
                 _format_user_block(block, lines)
 
         elif etype == "result":
diff --git a/predicators/agent_sdk/prompt_templates.py b/predicators/agent_sdk/prompt_templates.py
new file mode 100644
index 000000000..ffa4e8bde
--- /dev/null
+++ b/predicators/agent_sdk/prompt_templates.py
@@ -0,0 +1,137 @@
+"""Loader for the agent prompt templates in ``predicators/agent_sdk/prompts``.
+
+Every prompt the agent receives (per-phase system prompts, the solve
+and explore query, the synthesis learn message, the sandbox CLAUDE.md)
+is authored as Markdown in that directory and composed here, so the
+text can be read, diffed, and reproduced as a document rather than
+reassembled from string concatenation.
+
+Template format:
+
+- A file is split into named sections by marker lines of the form
+  ``<!-- section: name -->``.  Text before the first marker is ignored
+  (it is the file's own header comment).
+- ``__UPPER_SNAKE__`` placeholders are substituted at render time.
+  Rendering fails loudly when a template placeholder has no value, so
+  a renamed placeholder cannot silently ship as literal text.
+- Prose is authored hard-wrapped; :func:`render` joins wrapped prose
+  lines into one line per paragraph while preserving headings, lists,
+  tables, code fences, and indented lines.
+"""
+import functools
+import os
+import re
+from typing import Dict, List
+
+_PROMPTS_DIR = os.path.join(os.path.dirname(__file__), "prompts")
+_SECTION_RE = re.compile(r"^<!-- section: ([a-z0-9_]+) -->[ \t]*$",
+                         re.MULTILINE)
+_PLACEHOLDER_RE = re.compile(r"__([A-Z][A-Z0-9_]*)__")
+# Matches "1. ", "12) " etc. at the start of a stripped line.
+_NUMBERED_ITEM_RE = re.compile(r"^\d+[.)]\s")
+
+
+@functools.lru_cache(maxsize=None)
+def load_sections(template: str) -> Dict[str, str]:
+    """Return ``{section_name: raw_text}`` for ``prompts/<template>.md``.
+
+    Section text keeps its internal formatting; leading and trailing
+    blank lines are stripped.
+    """
+    path = os.path.join(_PROMPTS_DIR, f"{template}.md")
+    with open(path, "r", encoding="utf-8") as f:
+        text = f.read()
+    matches = list(_SECTION_RE.finditer(text))
+    assert matches, f"{path} declares no <!-- section: name --> markers"
+    sections: Dict[str, str] = {}
+    for i, match in enumerate(matches):
+        name = match.group(1)
+        assert name not in sections, f"{path}: duplicate section {name!r}"
+        start = match.end()
+        end = matches[i + 1].start() if i + 1 < len(matches) else len(text)
+        sections[name] = text[start:end].strip("\n")
+    return sections
+
+
+def placeholders(text: str) -> List[str]:
+    """The distinct ``__NAME__`` placeholders in ``text``, in order."""
+    seen: List[str] = []
+    for name in _PLACEHOLDER_RE.findall(text):
+        if name not in seen:
+            seen.append(name)
+    return seen
+
+
+def render(template: str, section: str, **values: str) -> str:
+    """Render one template section with its placeholders substituted.
+
+    ``values`` are keyed by the lower-case placeholder name (``foo_bar``
+    fills ``__FOO_BAR__``).  Every placeholder in the section must be
+    given; extra values are rejected too, so the call site and the
+    template cannot drift apart.  The result is prose-unwrapped (one
+    line per paragraph).
+    """
+    raw = load_sections(template)[section]
+    needed = placeholders(raw)
+    given = {name.upper() for name in values}
+    missing = [p for p in needed if p not in given]
+    unused = sorted(given - set(needed))
+    assert not missing and not unused, (
+        f"{template}.md#{section}: missing placeholders {missing}, "
+        f"unused values {unused}")
+    # Unwrap the template's own prose first, then substitute: values are
+    # either already-rendered snippets or verbatim data (a journal, a
+    # state dump, atom listings) that must keep its line structure.
+    out = unwrap_prose_lines(raw)
+    for name in needed:
+        out = out.replace(f"__{name}__", values[name.lower()])
+    return out
+
+
+def unwrap_prose_lines(text: str) -> str:
+    """Join hard-wrapped prose lines into single-line paragraphs.
+
+    Joins a line onto the previous one when both are plain prose, or
+    when the previous line is a list item and the current line is its
+    hanging-indented continuation. Preserves verbatim: blank lines,
+    fenced code blocks, headings, list items, tables, blockquotes, and
+    indented lines that do not continue a list item.
+    """
+    out: List[str] = []
+    in_fence = False
+    prev_is_item = False
+    for line in text.split("\n"):
+        stripped = line.lstrip()
+        is_fence = stripped.startswith("```")
+        if is_fence:
+            in_fence = not in_fence
+            out.append(line)
+            prev_is_item = False
+            continue
+        if in_fence:
+            out.append(line)
+            continue
+        is_item = (stripped.startswith(("- ", "* ", "+ "))
+                   or _NUMBERED_ITEM_RE.match(stripped) is not None)
+        indented = bool(stripped) and line[0] in " \t"
+        if indented and prev_is_item and not is_item:
+            out[-1] = out[-1].rstrip() + " " + stripped
+            continue
+        starts_structure = (
+            not stripped  # blank
+            or indented  # code / aligned examples
+            or stripped.startswith(("#", ">", "|"))  # heading/quote/table
+            or is_item)
+        prev = out[-1] if out else ""
+        prev_stripped = prev.lstrip()
+        prev_joinable = (
+            bool(prev_stripped) and prev_stripped != "---"
+            and prev[0] not in " \t"  # never join onto verbatim lines
+            and not prev_stripped.startswith(
+                ("#", "|", ">")) and not prev_stripped.startswith("```"))
+        if starts_structure or not prev_joinable:
+            out.append(line)
+            prev_is_item = is_item
+        else:
+            out[-1] = prev.rstrip() + " " + stripped
+    return "\n".join(out)
diff --git a/predicators/agent_sdk/prompts/learn_message.md b/predicators/agent_sdk/prompts/learn_message.md
new file mode 100644
index 000000000..4e37156db
--- /dev/null
+++ b/predicators/agent_sdk/prompts/learn_message.md
@@ -0,0 +1,148 @@
+# Synthesis (learn) first message
+
+Composed by `AgentSimLearningApproach._build_synthesis_learn_message`
+through `learn_prompts.build_learn_message`. The message carries this
+cycle's data and digests; the rules of the phase live in the system
+prompt (`learn_system.md`).
+
+<!-- section: skeleton -->
+Synthesize a residual dynamics simulator for this environment. There
+are __N_TRAJS__ trajectories (__N_TRANSITIONS__ step transitions)
+available: __N_DEMOS__ oracle demonstration(s), which reached the goal
+by construction, and __N_INTERACTION__ interaction trajectory/ies
+collected during online learning, some of which may have failed to
+reach the goal.
+
+__TRAJECTORY_LISTING__
+
+Each trajectory carries a `train_task_idx`. `is_goal_state(state,
+task_idx)` (equivalently `train_tasks[task_idx].goal_holds(state)`)
+checks a single state for the goal atoms. Reaching the goal atoms does
+not by itself mean an episode is solved; when a task objective is
+stated below, score full trajectories with `evaluate_trajectory`. Use
+`is_goal_state` to confirm which trajectories reached the goal atoms
+and to treat failed interaction trajectories as counterexamples: places
+where a predicate or rule said "this should work" and the environment
+disagreed.
+
+__OBJECTIVE_BLOCK__
+
+__PRIOR_STATE_BLOCK__
+
+__DIVERGENCE_BLOCK__
+
+Data-structure source code is at: __STRUCTS_REF__
+
+__BASE_SIM_BLOCK__
+
+A residual scan between the base simulator's prediction and the
+observed next state suggests that these features carry residual
+dynamics (a starting hint; it may include base-sim jitter, so refine it
+as you go):
+
+__INFERRED_HINT__
+
+## Available Predicates (for subgoal annotations)
+
+__PREDICATE_LISTING__
+
+Subgoal annotations in plans for `sim.refine` / `sim.run` must
+reference these predicate names with matching arity and types. Any
+threshold or condition you bake into a rule must be consistent with
+what the predicate's classifier checks, or refinement rejects
+parameter samples that look correct on paper.
+
+## Object Types
+
+__TYPES_DIGEST__
+
+## Options
+
+Plans (for `sim.refine` / `sim.run`) and rules must match these typed
+signatures and parameter boxes exactly:
+
+__OPTIONS_DIGEST__
+
+__TOOLS_BLOCK__
+
+## This session
+
+Read the data-structures file first, then explore the trajectory data
+with `run_python`. Write your simulator to `__SIMULATOR_FILE__`,
+defining `RESIDUAL_RULES`, `PARAM_SPECS`, and `RESIDUAL_FEATURES`, and
+iterate with `Edit` and re-scoring. Pass `task_idx` explicitly to
+`sim.reset`; `sim.task(task_idx)` prints a task digest. Finish with the
+deliverables listed in the system prompt: a final `sim.fit()`, the
+GO/NO-GO check, the decision record, `./open_questions.md`, and
+`./strategy.md`.
+
+<!-- section: divergence_prior -->
+## Where the prior model diverges from the data
+
+Computed just now from the prior cycle's `simulator.py` with its
+parameters refit to all trajectories above, so the remaining
+mismatches need structural fixes, not tuning. Re-score any edit with
+`sim.residuals()` (same report, current file):
+
+__REPORT__
+
+<!-- section: divergence_base -->
+## Where the base simulator diverges from the data
+
+No prior model exists yet, so every feature below is an unmodeled
+mechanism: this is the map of what your `simulator.py` needs to cover,
+each with its worst transition located in the data. Re-score any edit
+with `sim.residuals()` (same report, current file):
+
+__REPORT__
+
+<!-- section: base_sim -->
+The base simulator's own source code is available (read-only):
+
+__REF_LISTING__
+
+These files are byte-identical to the code your base-sim rollouts
+execute: scene geometry and constants, body construction, stepping,
+and state read/write. They deliberately omit the environment's hidden
+domain-specific step, the residual dynamics you are here to model, and
+its task generation and goal semantics. Use them to ground hypotheses
+(masses, damping, substeps per action, how switches toggle) instead of
+re-measuring those from data.
+
+<!-- section: tools -->
+## Available Tools
+
+__TOOL_LISTING__
+
+<!-- section: objective -->
+## Task objective (env ground-truth reward)
+
+__DESCRIPTION__
+
+The trajectory roster above shows each interaction episode's
+env-computed reward. In `run_python`, `evaluate_trajectory(states,
+actions=None, task_idx=0)` scores any state sequence with the same
+ground-truth evaluator: a collected trajectory's `states` and
+`actions`, or a rollout of your simulator (where the verdict is only
+as trustworthy as the simulator). It returns `{reward, solved}`;
+`solved` means the episode is scored as a success, and a rollout can
+reach the goal atoms and still be `solved=False`.
+
+<!-- section: prior_state -->
+Prior cycle state: __PRIOR_FILES__ already exist in the sandbox from a
+previous learning cycle. Read them first: they are the previous cycle's
+committed result and a reasonable starting point for incremental
+refinement, though a fresh rewrite is fine if the prior approach looks
+fundamentally wrong. Structural decisions are not binding across
+cycles: re-read the decision record at the top of `simulator.py` and
+re-decide the architecture itself (what the base sim carries and what
+the rules model, which features the rules own, the latent structure,
+whether disclosed base-sim parameters should be identified) rather
+than only tuning what exists. In particular, if the trajectory roster
+shows goal-reaching episodes scored `solved=0`, suspect a structural
+modeling error (for example mis-calibrated base physics that the rules
+only paper over near the fit data), not only parameter values. Earlier
+versions are in `./simulator_versions/` and `./predicates_versions/`
+(named `cycle_XXX_vers_YYY_*.py`); cross-reference the roster's
+provenance tags against those files to see which rules and predicates
+produced each failed plan.
diff --git a/predicators/agent_sdk/prompts/learn_partial_observability.md b/predicators/agent_sdk/prompts/learn_partial_observability.md
new file mode 100644
index 000000000..6c21cda0f
--- /dev/null
+++ b/predicators/agent_sdk/prompts/learn_partial_observability.md
@@ -0,0 +1,178 @@
+# Partial observability (learn phase)
+
+Appended under `CFG.partially_observable`: the simulator-side
+recurrent-rules tutorial (all sim-learning arms), the short first-
+message note, and the predicate-side latent guidance (predicate
+invention arms only).
+
+<!-- section: rules -->
+## Recurrent rules (partial observability)
+
+The observation may omit causally important quantities: several, one,
+or none. Anything omitted is absent from the state entirely (under no
+name, not even as a placeholder), so you cannot read it and must infer
+its existence and dynamics from how the observable features evolve.
+Inspect the trajectories first to judge how many latents you need: a
+feature that drifts or ramps with no visible observed driver is likely
+downstream of an accumulating latent; if every observable is explained
+by other observed quantities, you need no latent at all, so keep the
+5-argument signature and leave `latent` untouched. A common case is a
+hidden continuous quantity surfaced only through a derived observable
+that ramps once the latent crosses a threshold.
+
+Model the hidden state explicitly: each state you predict is one
+sample of an augmented state, the observable features plus the latent
+dimensions you infer (a free-form dict such as `{"level": 0.73}` or
+`{"count": 22}`). Rules read and advance that latent through the
+`latent` argument of the 5-argument signature. Declare the initial
+latent block:
+
+```python
+LATENT_INIT = {"level": 0.0, "count": 0}
+# OR a zero-arg callable returning such a dict.
+# Use ParamSpec("name", ...) values to make an init value learnable.
+```
+
+### Structure the latent like the state (per object)
+
+A hidden quantity almost always belongs to an individual object: a
+vessel's hidden `heat` is another feature of that vessel that happens
+to be unobserved. Shape the latent like `data`, object first and then
+feature, so that `latent[jug.name]["heat"]` reads in parallel with
+`observation.get(jug, "water_volume")`. With several same-type objects
+a flat `{"heat": 0.0}` collapses them into one shared accumulator,
+which is wrong, exactly as rules must loop over every object rather
+than indexing `[0]`.
+
+```python
+LATENT_INIT = {}          # {jug_name: {"heat": value}}, filled lazily
+
+def heat_rule(observation, latent, history, updates, params):
+    jugs = [o for o in observation.data if o.type.name == "jug"]
+    for jug in jugs:
+        jl = latent.setdefault(jug.name, {})    # this jug's hidden dims
+        h = jl.get("heat", 0.0)
+        if on_active_burner(observation, jug, params):
+            h += 1.0
+        jl["heat"] = h
+        updates.setdefault(jug, {})["bubbling_level"] = readout(h, params)
+    return updates
+```
+
+Two deliberate differences from `data`: (1) key by the stable string
+`obj.name`, not the live `Object` (the latent is deep-copied and
+reconstructed at every search node, so a live key risks identity
+mismatch); (2) keep it a free-form JSON-like nest of dicts and numbers
+with no registered schema. A genuinely global hidden quantity (a world
+clock, an ambient temperature) stays a top-level scalar. Top-level
+scalar entries may be `ParamSpec`s to make their initial value
+learnable; seed each per-object slot lazily from such a shared init.
+
+### Two synthesis patterns (pick per latent)
+
+Pattern A, counter plus threshold: carry a step counter and flip the
+observable when it crosses a learnable threshold. Same statistical
+shape as a delayed discrete event.
+
+```python
+PARAM_SPECS = [ParamSpec("delay", init_value=33, lo=1, hi=200)]
+LATENT_INIT = {"count": 0}
+
+def count_rule(observation, latent, history, updates, params):
+    active = is_widget_at_fixture(observation)  # observable check
+    fixture_on = observation.get(fixture, "is_on") > 0.5
+    if active and fixture_on:
+        latent["count"] += 1
+    else:
+        latent["count"] = 0
+    fired = latent["count"] >= params["delay"]
+    updates[widget]["progress"] = 1.0 if fired else 0.0
+    return updates
+```
+
+Pattern B, physical latent plus readout: carry an estimate of the
+unobserved quantity and map it through a (typically monotone) function
+to predict the observable. Higher resolution: the observable co-varies
+smoothly with the latent before the symbolic "done" point.
+
+```python
+PARAM_SPECS = [ParamSpec("rate", init_value=0.03, lo=0.0, hi=0.1)]
+LATENT_INIT = {"level": 0.0}
+
+def level_rule(observation, latent, history, updates, params):
+    active = is_widget_at_fixture(observation)
+    fixture_on = observation.get(fixture, "is_on") > 0.5
+    if active and fixture_on:
+        latent["level"] += params["rate"]
+    lvl = latent["level"]
+    # monotone readout: ramps from 0 once `lvl` passes an onset (~0.85)
+    updates[widget]["progress"] = max(0.0, min(1.0, (lvl - 0.85) / 0.15))
+    return updates
+```
+
+How to choose: a smooth ramp across many steps in the derived
+observable calls for Pattern B (a partial-progress signal whose rate is
+identifiable from a single trajectory by slope fit); a clean discrete
+flip at a variable tick may only need Pattern A (one learnable
+threshold calibrated from the flip-time distribution across
+trajectories). Different latents may use different patterns within one
+simulator.
+
+### Keep carried state in `latent`, not in emitted observables
+
+Anything a rule must remember across steps (a counter, an accumulated
+level, an irreversible "done" flag) belongs in `latent`. The
+observables you write to `updates` are outputs only: recompute them
+from `latent` and base-owned inputs each step, and never read one of
+your own emitted features back in as state. The planner resets and
+replays states during refinement, and only `latent` is guaranteed to
+be threaded across those jumps, so a rule that latches on its own
+output can pass a step-by-step rollout and break at refinement time.
+Reading features the base sim owns (positions, `is_on`, `is_held`) is
+fine; those are restored faithfully.
+
+<!-- section: message -->
+## Partial observability
+
+Some causally important quantities may be absent from the observation
+entirely (under no name), possibly several, possibly none. Inspect the
+trajectories first to judge whether any hidden process is at work and
+which observable features are your window into it; then, if latents
+are needed, model them in `latent` with Pattern A or Pattern B (or a
+mix).
+
+<!-- section: predicates -->
+### Predicate signature
+
+Classifiers may stay observation-only or take an optional `latent`
+kwarg. The latent block is available at refinement time too: the
+planner threads it through `state.latent` across search nodes, and
+`Predicate.holds` routes it into classifiers that opted in. Be
+defensive: at the very first step `state.latent` may still be `{}` if
+`LATENT_INIT` is empty, and during predicate-quality scoring on raw
+env trajectories `latent` is the block materialized by your rules (so
+meaningful, but only as accurate as the rules).
+
+```python
+# Observation-only (robust to bad rule chains; preferred when the
+# observable carries enough signal):
+Predicate("ProcessDone", [widget_type],
+          lambda s, objs, latent=None:
+              s.get(objs[0], "progress") > 0.5)
+
+# Latent-aware (inherits simulator correctness; defend against
+# missing keys at step 0):
+Predicate("ProcessDone", [widget_type],
+          lambda s, objs, latent=None:
+              (latent or {}).get("level", 0.0) >= params["done_thresh"])
+```
+
+The kwarg must be named exactly `latent` for the routing to apply.
+Latent-aware predicates inherit the simulator's correctness;
+observation-only predicates are robust to bad rules but only work when
+the observable carries enough signal.
+
+`sim.predicates()` rolls each trajectory through your simulator to
+materialize the latent before scoring classifiers, so latent-aware
+predicates get a real block there. Use its report to localize failures
+(bad rule chain versus bad threshold).
diff --git a/predicators/agent_sdk/prompts/learn_predicate_invention.md b/predicators/agent_sdk/prompts/learn_predicate_invention.md
new file mode 100644
index 000000000..839d964dc
--- /dev/null
+++ b/predicators/agent_sdk/prompts/learn_predicate_invention.md
@@ -0,0 +1,140 @@
+# Predicate invention (learn phase)
+
+Appended to the synthesis system prompt and first message by
+`AgentSimPredicateInventionApproach`.
+
+<!-- section: system -->
+## Predicate Invention (required for plan subgoals)
+
+You also invent the symbolic predicates the planner uses as subgoal
+atoms in plan sketches. Only `Holding` is provided as a primitive;
+placement, device-state, and process-completion predicates do not
+exist until you invent them.
+
+Goals are presented in natural language (see the first message) and
+goal achievement is checked externally by the environment through
+`is_goal_state(state, task_idx)` / `train_tasks[task_idx].goal_holds(state)`.
+You need not invent goal-named predicates or match environment
+predicate names: invented predicates exist for plan-sketch subgoals
+(gating `Wait`, `Place`, and similar steps) and can be named freely.
+
+Define them in `predicates.py` (path given in the first message):
+
+```python
+LEARNED_PREDICATES: List[Predicate]
+```
+
+The exec namespace pre-injects `Predicate`, `np`, and a
+`<typename>_type` binding for each env type (for example `widget_type`,
+`fixture_type`). The names below are illustrative; use the types,
+features, and parameter names your digests and the trajectory data
+report.
+
+```python
+# Placement: object xy within a learned distance of the fixture's
+# functional point, NOT its recorded origin (see "Geometric gates").
+# The local-frame offset is declared as ParamSpecs in simulator.py
+# and shared with the rule that gates the same physics.
+def _widget_at_fixture(s, objs):
+    widget, fixture = objs
+    rot = s.get(fixture, "rot")
+    cos_r, sin_r = np.cos(rot), np.sin(rot)
+    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
+    local_offset = np.array([params["fixture_local_dx"],
+                             params["fixture_local_dy"]])
+    origin = np.array([s.get(fixture, "x"), s.get(fixture, "y")])
+    anchor = origin + rot_mat @ local_offset  # world-frame point
+    widget_xy = np.array([s.get(widget, "x"), s.get(widget, "y")])
+    dist = np.linalg.norm(widget_xy - anchor)
+    return dist < params["widget_at_fixture_dist"]
+
+LEARNED_PREDICATES = [
+    Predicate("WidgetAtFixture", [widget_type, fixture_type],
+              _widget_at_fixture),
+    # Device state: a feature exceeding a fixed cutoff (no learned param).
+    Predicate("FixtureActive", [fixture_type],
+              lambda s, objs: s.get(objs[0], "is_on") > 0.5),
+    # Process completion: a rule-driven feature reaches a learned threshold.
+    Predicate("WidgetReady", [widget_type],
+              lambda s, objs: s.get(objs[0], "progress") >= params["ready_threshold"]),
+]
+```
+
+A pre-injected `params` view is in scope and always reads the current
+fitted values of every `ParamSpec` declared in `simulator.py`; after
+each refit, predicates reading `params["name"]` see the new values.
+Whenever one physical gate drives both a rule's firing condition and a
+predicate's "subgoal reached" check, declare its parameters (the
+distance threshold and the local-frame anchor offset it is measured
+from) once in `PARAM_SPECS` and reference `params["name"]` from both.
+That keeps the two anchored to the same point and gives the offset a
+fitting signal from the rule's step data. A parameter used only by
+predicates has no fitting signal and stays at its `init_value`, so
+choose those initial values carefully.
+
+What you typically need:
+
+- Placement predicates (object at a target location) for every
+  open-ended option such as `Place`; without them refinement picks an
+  arbitrary location.
+- Device-state predicates (on/off) for every toggle option.
+- Process-completion predicates over the features your rules drive, so
+  `Wait` steps know when to terminate. Keep classifier thresholds
+  consistent with the rules' saturation values; an inconsistency makes
+  `sim.fit` look fine while `sim.refine` gets stuck on the `Wait`
+  subgoal.
+- Coverage: every option you expect in a sketch should have predicates
+  that express its post-condition, so every sketch step can carry a
+  subgoal annotation. Annotations are checked against the real state
+  during execution to detect and replan diverged steps; a step with no
+  annotatable effect is unmonitored. While drafting sketches, a step
+  you cannot annotate with any invented predicate is a missing
+  predicate.
+
+Verify every classifier against the scene and the data. A classifier
+picks features and parameter values, and both can be wrong, so commit
+neither from intuition: follow the threshold-fitting protocol in
+"Geometric gates" for every numeric cutoff, and use __SCENE_WORKBENCH__
+for geometry and `run_python` for the numeric sweep over trajectory
+states.
+
+`sim.predicates()` validates cheaply (first-flip step, monotonicity,
+coverage across all trajectories) and is also the loader: it updates
+the predicate set `sim.refine` uses, so call it after every edit to
+`predicates.py` and before re-running refinement. On goal-reaching
+trajectories (`reached_goal=True` in `describe_trajectory`) a milestone
+predicate should flip from false to true exactly once and stay true.
+On failed interaction trajectories (`reached_goal=False`) the same
+predicate may fire while the rest of the trajectory shows no goal
+completion; that is the signature of an over-loose threshold (the
+predicate fires, the downstream physics does not follow), so tighten
+it or share the gating parameter with the rule so they are fitted
+jointly.
+
+Predicates persist across online cycles: the file is preserved between
+synthesis sessions, and every successful `Write`/`Edit` (plus a final
+post-session check) is snapshotted to
+`predicates_versions/cycle_XXX_vers_YYY_predicates.py`. Each cycle
+re-runs synthesis with the full trajectory history, so failed past
+attempts remain visible.
+
+<!-- section: message -->
+## Predicate Invention
+
+Only the predicates under "Available Predicates" above exist; this
+approach stripped the environment's symbolic predicates down to that
+allowlist. Invent every other subgoal predicate in `__PREDICATES_FILE__`
+as `LEARNED_PREDICATES`, following the system prompt's "Predicate
+Invention" section.
+
+__GOAL_BLOCK__
+
+Workflow: edit `predicates.py`, call `sim.predicates()` in
+`run_python`, then run `sim.refine` / `sim.run` with sketches that
+reference your invented names. Any predicate a sketch references must
+exist in `predicates.py` first.
+
+<!-- section: workflow_extra -->
+Step 4's sketches need subgoal predicates that do not exist until you
+invent them: before validating, write them to `predicates.py` and load
+them with `sim.predicates()` (see "Predicate Invention").
diff --git a/predicators/agent_sdk/prompts/learn_system.md b/predicators/agent_sdk/prompts/learn_system.md
new file mode 100644
index 000000000..3cfa063cf
--- /dev/null
+++ b/predicators/agent_sdk/prompts/learn_system.md
@@ -0,0 +1,555 @@
+# Synthesis (learn) system prompt
+
+Composed by `AgentSimLearningApproach._build_synthesis_system_prompt`.
+Sections are joined in the order listed below; the rule-signature
+section and the physical-parameter section are chosen per instance,
+and subclass extras (`learn_predicate_invention.md`,
+`learn_partial_observability.md`) are inserted before the plan format.
+
+<!-- section: intro -->
+You are synthesizing a parameterized residual-dynamics simulator for a
+robotic manipulation environment.
+
+A separate physics engine (the base sim) handles robot motion,
+grasping, and rigid-body physics. Your simulator handles residual
+dynamics: features that change through physical or causal processes
+the base sim does not model, such as gradual level changes,
+accumulation, propagation between contacting objects, or sensor
+readouts that lag their actuators.
+
+<!-- section: produce -->
+## What you produce
+
+One file, `simulator.py` (path given in the first message), defining
+three top-level names:
+
+```python
+RESIDUAL_RULES:    List[Callable]            # rule functions (signature below)
+PARAM_SPECS:       List[ParamSpec]           # learnable parameters
+RESIDUAL_FEATURES: Dict[str, List[str]]      # {type_name: [feature_names]} your rules predict
+```
+
+`RESIDUAL_FEATURES` defines both the loss scope and the test-time
+overwrite scope: only the listed `(type, feature)` pairs are scored
+against observations, and only those are written on top of the base
+sim at test time. List exactly the features your rules update; a
+listed feature no rule writes inflates the loss without giving the fit
+anything to optimize.
+
+<!-- section: physical_params -->
+## Base-sim system identification (`PHYSICAL_PARAMS`)
+
+The base sim's rigid-body physics is itself parameterized, and its
+built-in values may be mis-calibrated relative to the real environment.
+It reveals these tunable parameters:
+
+__PARAM_LIST__
+
+When observed trajectories diverge from the base sim on rigid-body
+motion itself (not on a process layered on top of it), declare a fourth
+export:
+
+```python
+PHYSICAL_PARAMS: List[ParamSpec]  # subset of the names above; init = your hypothesis, lo/hi from the box
+```
+
+- Decide from open-loop evidence, in either direction. Per-step
+  (teacher-forced) residuals predict each step from the recorded state,
+  so the compounding divergence a wrong friction or mass produces is
+  invisible to them; near-zero per-step residuals are compatible with
+  free-running rollouts that are far worse than at the correct value.
+  Run `sim.residuals(rollout=True, sweep_params="all")` (or name the
+  suspect parameters): it replays the recorded trajectories
+  free-running and sweeps each parameter across its box, and
+  `phys_params={name: value}` scores one hypothesized point. Declare a
+  parameter whose sweep is materially better away from the baseline; a
+  flat sweep is honest evidence that the data cannot constrain it, and
+  the only justification for omitting it.
+- Undeclared parameters keep their built-in values in every base-sim
+  rollout, including the verification replay that decides what counts
+  as a solve. Rules fit to observed data can compensate for a mis-set
+  built-in value only near that data; identifying the parameter fixes
+  the substrate itself.
+- Start with one parameter, the one with a physical story for the
+  observed residual, and add another only if the calibrated fit still
+  leaves structure unexplained. Co-declared parameters compensate each
+  other along a data-equivalent ridge, and a parameter cannot be
+  identified from data that does not exercise it.
+- `sim.fit()` reports per-parameter identifiability (posterior
+  contraction). Drop a parameter reported not identified or
+  insensitive; its fitted value is noise. A parameter reported
+  "anchored" moved only to compensate the others and was reverted to
+  its baseline; keep it only if you can collect an interaction that
+  excites it specifically.
+- With `PHYSICAL_PARAMS` declared, the fit matches free-running
+  rollouts of full trajectories and fits physical and rule parameters
+  jointly in one posterior, so rules cannot silently absorb physics
+  error. A physics-only artifact is valid: `RESIDUAL_RULES = []` and
+  `PARAM_SPECS = []` with a non-empty `PHYSICAL_PARAMS` means the
+  calibrated base sim carries all the dynamics; `RESIDUAL_FEATURES`
+  must still name the features the rollout is scored on.
+- After the fit, the identified values are applied to the planning base
+  env, so probe rollouts and test-time planning use the calibrated
+  physics.
+
+<!-- section: rule_signature_fo -->
+### Rule signature
+
+```python
+def rule(state, updates, params):
+    # state:   the current env State
+    # updates: Dict[Object, Dict[str, float]] accumulated from prior rules
+    # params:  Dict[str, float], one entry per ParamSpec
+    #
+    # Accumulate, don't replace:
+    #     updates.setdefault(obj, {})[feat] = new_value
+    # Return the same dict.
+    ...
+```
+
+<!-- section: rule_signature_po -->
+### Rule signature
+
+This is a partial-observability task. Write every rule with the
+recurrent 5-argument signature below; the second parameter must be
+named `latent` (the engine inspects each rule's signature and threads
+the latent block and the read-only history only into rules that
+declare it):
+
+```python
+def rule(observation, latent, history, updates, params):
+    # observation: the current observation (a State holding the
+    #          observable features ONLY - hidden quantities appear
+    #          under no name; infer them into `latent`)
+    # latent:  Dict[str, Any], mutated in place - the hidden dims you
+    #          infer, threaded across steps (see "Recurrent rules" below)
+    # history: List[Tuple[State, Optional[Action]]] of past
+    #          observations, read-only; newest last
+    # updates: Dict[Object, Dict[str, float]] accumulated from prior rules
+    # params:  Dict[str, float], one entry per ParamSpec
+    #
+    # Accumulate, don't replace:
+    #     updates.setdefault(obj, {})[feat] = new_value
+    # Return the same dict.
+    ...
+```
+
+A rule that needs no hidden state can ignore its `latent` and
+`history` arguments, but keeps the 5-argument shape so the tools and
+the fitting engine call every rule the same way. See "Recurrent rules
+(partial observability)" below for `LATENT_INIT` and the two
+latent-modelling patterns.
+
+<!-- section: cmds -->
+### Physics commands (`cmds`): moving rigid bodies through the engine
+
+A rule may declare one extra trailing parameter named `cmds` to gain a
+second output channel: rigid-body actuation executed by the base sim's
+physics engine.
+
+```python
+def rule(..., cmds):        # same leading args as above, plus `cmds`
+    cmds.apply_force(obj, (fx, fy, fz))    # world-frame Newtons
+    cmds.apply_torque(obj, (tx, ty, tz))   # world-frame N*m
+    cmds.set_velocity(obj, linear=(vx, vy, vz))   # kinematic override
+    cmds.attach(obj_a, obj_b)   # rigid weld at their CURRENT relative pose
+    return updates
+```
+
+`cmds.attach` is the primitive for two bodies that move as one rigid
+body from some event on (a cured joint, a latch, a magnetized contact):
+the engine creates a fixed constraint at the pair's current relative
+pose and keeps it exactly while the command is re-emitted, so the base
+sim carries the whole assembly through pick, transport, and contact.
+Latch the decision in the rule's latent or feature state and re-emit
+from the latch every step. Do not emulate a weld by writing follower
+poses from the leader's pose: pose-written followers do not collide,
+do not support anything, and swing free during a carry, so plans
+validate in the belief and fail for real.
+
+Commands act during the next env action and then expire, so re-emit
+them on every step the process is active (a force that acts while a
+device is on is "emit the force whenever `is_on > 0.5`"). A force or
+torque is re-applied on every physics substep of that action, like a
+continuous push. The engine resolves whatever the commanded motion
+runs into (contact stops, sliding, deflection); do not re-derive
+collision handling in rule code.
+
+Choosing the channel, in order:
+
+1. The base sim already produces the motion but quantitatively off
+   (bodies move on replay, with drifting angles or timing): the
+   mechanism lives in the engine and the error is a function of its
+   physical parameters. Declare `PHYSICAL_PARAMS` and write no rule for
+   it.
+2. A body moves in the data but is inert in base-sim replay whenever
+   some observable condition holds: the mechanism is missing, an
+   influence the engine knows nothing about. Model it with force or
+   velocity commands gated on the condition. If the missing mechanism
+   is that two bodies move together rigidly after an event, the command
+   is `cmds.attach`, not a pose rule.
+3. The feature is not a rigid-body pose at all (a level, a
+   temperature, a counter): use the feature-update channel.
+
+Never write a rule that overwrites or pushes a body the base sim is
+already moving: the two fight, and the fit lets the rule absorb
+physics error. Prefer the simplest force hypothesis: a body that moves
+at a constant rate while a condition holds and stops when it ends, or
+when something is in the way, is a constant force plus engine
+contacts, not a decaying gust, a one-shot kick, or an edge-triggered
+pulse.
+
+Declaring `cmds` switches fitting and residual scoring to
+env-in-the-loop rollout matching automatically (`sim.fit` reports it);
+command effects cannot be scored teacher-forced. `RESIDUAL_FEATURES`
+still declares the features your dynamics own: list the pose features
+your commands move (for example `{"ball": ["x", "y"]}`); they are
+scored against observations but not overwritten at test time, because
+the engine moves them.
+
+<!-- section: multi_object -->
+### Multiple objects of the same type
+
+A task may contain several objects of the same type, and the count
+varies from task to task. Rules run once per step over the entire
+state, so they act on whatever objects are present, never on a
+hard-coded slot: `widgets[0]` silently ignores every other instance and
+breaks the moment a task has a different count than the trajectory you
+calibrated on.
+
+Gather the relevant objects by type and loop over the bindings the rule
+acts on, emitting updates keyed by the specific object the effect
+applies to:
+
+```python
+widgets  = [o for o in state.data if o.type.name == "widget"]
+fixtures = [o for o in state.data if o.type.name == "fixture"]
+for widget in widgets:
+    for fixture in fixtures:           # all pairs, or pair each widget
+        if at_fixture(state, widget, fixture, params):   # to its nearest
+            wv = state.get(widget, "progress")
+            updates.setdefault(widget, {})["progress"] = wv + params["rate"]
+```
+
+The same `params` apply to every object of a type: you are learning the
+shared physics of "a widget", not per-instance constants. If a rule
+genuinely needs exactly one object (a single global clock, say), assert
+that rather than silently indexing `[0]`.
+
+The type, feature, latent, and parameter names in every example here
+(`widget`, `fixture`, `progress`, `level`, ...) are illustrative; use
+the names your prompt digests and the trajectory data report.
+
+<!-- section: timing -->
+### Timing
+
+Each rule fires once per step:
+
+```
+state[t] --base sim--> draft state[t+1] --your rules--> final state[t+1]
+                                          (only RESIDUAL_FEATURES are overwritten)
+```
+
+Rules see `state[t]`. They cannot see actions, the base sim's draft, or
+`state[t+2]`. If a feature changes one step after its gating event (an
+action toggles a flag at `t`, and the feature it drives starts changing
+at `t+1`), that is an inherent one-step lag in the data: accept the
+single boundary residual or model the delay with a parameter, rather
+than chasing it with ever-stricter conditions.
+
+<!-- section: geometric_gates -->
+### Geometric gates
+
+When a rule's firing condition depends on the relative position of two
+bodies, do not gate on the raw distance between their recorded poses.
+`obj.x, obj.y` is the recorded pose origin, usually a body's base or
+frame center, while the point that drives the physics (a contact
+surface, an outlet on the body's side, an end-effector tip, a
+container opening, a handle) is typically offset from it. That offset
+lives in the body's local frame, so it rotates with the body's `rot`
+feature; gating on raw origin distance bakes in one task's orientation
+and breaks on any task where the fixture is rotated differently.
+
+Default to a learned, rotation-aware anchor offset: express every
+two-body geometric gate as a distance to an anchored point, the fixture
+origin plus a local-frame offset rotated into the world frame by the
+fixture's `rot`, with the offset declared as learnable parameters:
+
+```python
+PARAM_SPECS = [
+    # Functional point offset, in the fixture's LOCAL frame:
+    ParamSpec("fixture_local_dx",       0.0,  lo=-0.3, hi=0.3),
+    ParamSpec("fixture_local_dy",       0.0,  lo=-0.3, hi=0.3),
+    ParamSpec("widget_at_fixture_dist", 0.10, lo=0.0,  hi=0.4),
+]
+
+# `fixture`, `widget`: the relevant object pair (bind as your rule needs).
+__RESIDUAL_RULE_SIGNATURE__
+    rot = state.get(fixture, "rot")
+    cos_r, sin_r = np.cos(rot), np.sin(rot)
+    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
+    local_offset = np.array([params["fixture_local_dx"],
+                             params["fixture_local_dy"]])
+    origin = np.array([state.get(fixture, "x"), state.get(fixture, "y")])
+    anchor = origin + rot_mat @ local_offset  # world-frame point
+    widget_xy = np.array([state.get(widget, "x"), state.get(widget, "y")])
+    if np.linalg.norm(widget_xy - anchor) < params["widget_at_fixture_dist"]:
+        ...  # fire
+```
+
+If the functional point coincides with the recorded origin, the fit
+drives the offsets to zero at no cost. Use a threshold-only gate only
+after positively confirming that the recorded origin is the functional
+point. Share the offset and distance parameters with the gating
+predicate so the rule and the predicate anchor to the same point.
+
+Threshold-fitting protocol, for every predicate or rule condition that
+compares a recorded feature against a learned cutoff:
+
+1. Bucket trajectory steps by whether the downstream effect actually
+   occurred (the rule-relevant feature advanced, the goal-relevant
+   quantity changed). Compute the candidate quantity at each step.
+2. Inspect the two buckets' value ranges. They must separate by a
+   clear margin. If they overlap, or the gap is narrower than about 5%
+   of the value range, stop: a knife-edge separator is a symptom, not a
+   fit, and a threshold flush against the data boundary is rejected.
+   The candidate quantity is measured from the wrong reference point;
+   do not widen the threshold to absorb the gap.
+3. Find the anchor offset visually: __SCENE_VIZ_HINT__. The gap between
+   the recorded origin and the effect-firing cluster is the offset.
+4. Re-derive the candidate quantity from the anchored reference and
+   refit. Commit only once the buckets separate by a comfortable
+   margin.
+
+Render the scene, rather than trusting coordinates, whenever a new
+predicate is proposed (one state where it should hold and one where it
+should not), whenever a classifier looks right numerically but the
+downstream signal (refinement success, residual reduction, plan
+completion) does not follow, and whenever you choose between candidate
+reference points. Staging and rendering are free: use them before, not
+after, committing a numeric fit.
+
+<!-- section: paramspec -->
+### ParamSpec
+
+```python
+ParamSpec(name: str, init_value: float,
+          lo: Optional[float] = None, hi: Optional[float] = None)
+```
+
+Bounds shape both the fit's prior and the warm-start clamp. Set
+`lo=0.0` for non-negative rates and similar constraints.
+
+<!-- section: preinjected -->
+### Pre-injected when `simulator.py` is executed
+
+`numpy as np` and `ParamSpec`. Import anything else at the top of the
+file. The data classes (`State`, `Object`, `Action`, ...) come from
+`predicators.structs`; the source is in the reference file linked in
+the first message.
+
+<!-- section: tools -->
+## Tools
+
+`Write` and `Edit` on `simulator.py` are your coding loop. Every
+successful write is snapshotted to
+`simulator_versions/cycle_XXX_vers_YYY_simulator.py` (deduplicated by
+content; `XXX` is the current cycle and `YYY` resets per cycle).
+`sim.fit`, `sim.residuals`, and the probe's candidate-model refit load
+the file fresh on every call and prefix their reports with
+`[cycle_XXX_vers_YYY]`, so iterations can be compared.
+
+`run_python(code)` is both data exploration and validation.
+`trajectories`, `train_tasks`, `is_goal_state`,
+`describe_trajectory(traj_idx)` (a per-timestep digest), `np`, and
+`ParamSpec` are in scope, plus `evaluate_trajectory(states,
+actions=None, task_idx=0)` when the learn message states a task
+objective (it scores a state sequence with the env's ground-truth
+evaluator; on your own simulator's rollouts the verdict is only as good
+as the simulator). The `sim` probe over your candidate simulator lives
+in the same namespace:
+
+- `sim.fit()`: parameter fitting plus report; the cheap inner-loop
+  signal.
+- `sim.residuals()`: per-feature breakdown (mismatch counts, mean and
+  max absolute error, improvement over the base sim where a negative
+  value means the rules add error, worst-N example transitions); the
+  diagnostic for which rule to fix.
+- `sim.refine(plan)`: backtracking parameter search on a plan sketch.
+- `sim.run(plan)`: forward rollout with subgoal checking.
+- `sim.reset(task_idx=..., mods={...})` and `sim.render(label,
+  annotations=[...])`: stage a state and render it with overlays,
+  without physics.
+
+The probe forward-rolls the candidate simulator at the parameters of
+your last `sim.fit()`; it never fits on its own, so after a structural
+edit its results are marked UNFITTED until you run `sim.fit()` on the
+current file. Its rollouts are candidate predictions; do not confuse
+them with the recorded `trajectories`.
+
+<!-- section: validation -->
+### Refinement vs. forward validation
+
+`sim.fit` and refine-then-run test complementary things: pointwise
+accuracy versus goal reachability. A rule can have a tiny fitting error
+and still place a saturation threshold or an alignment cap just wrong
+enough that refinement cannot satisfy a subgoal. Use `sim.fit` and
+`sim.residuals` as the fast inner loop and refine-then-run as the slow,
+goal-relevant gate before declaring done.
+
+The two validation passes run under the same option model.
+`sim.refine` samples continuous parameters, up to 50 attempts per
+parametric step, and snapshots the state at each backtrack, so failures
+are isolated per step. The forward pass, one continuous `sim.run` of
+the refined plan with the state carried across all options and each
+subgoal annotation checked, matches how test time executes it. A
+divergence between the two means the learned model is more permissive
+than the environment's effective behavior: refinement's looser gates
+accept a step that the continuous rollout does not achieve.
+
+When `sim.refine` passes but `sim.run` reports a subgoal not reached
+(or the goal check fails), the cause is almost always one of these:
+
+1. A learned gate threshold is wider than the environment's effective
+   threshold. Refinement accepts a placement inside the learned gate
+   that lies outside the environment's; the environment's process never
+   starts, and the `Wait` runs to its cap. Fix: tighten the gate to the
+   empirical boundary; do not widen it for slack.
+2. A wait-termination cutoff fires before the environment-side feature
+   catches up. Refinement's subgoal passes on the learned simulator's
+   readout, but the final-state goal check on env state fails. Fix:
+   align the predicate's cutoff with the environment's effective
+   cutoff, then confirm by re-running refinement.
+
+Rule of thumb: when in doubt, tighten learned thresholds toward the
+empirical boundary, never loosen them. Widening hides discrepancies
+during refinement and reveals them at test time as failed solves.
+
+<!-- section: plan_format -->
+## Plan format for `sim.refine` / `sim.run`
+
+One option call per line, with every option argument supplied as a
+typed object reference (`obj:type`), matching the options digest in
+your prompt exactly. The parser is strict: an omitted argument is not
+auto-filled. Example:
+
+```
+PickWidget(robot:robot, widget0:widget)
+Place(robot:robot) -> {WidgetAtFixture(widget0:widget, fixture0:fixture)}
+ActivateFixture(robot:robot, fixture0:fixture)
+Wait(robot:robot) -> {WidgetReady(widget0:widget)}
+```
+
+The names are illustrative; use the options, types, and predicates your
+prompt digests list. Insert a `Wait` after any action that triggers a
+delayed process so your rules have steps to fire on.
+
+Subgoal annotations (`-> {Atom(obj:type, ...)}` after a step) are
+optional in general but effectively required after open-ended skills
+such as `Place`: without one the backtracking search has no preference
+for where to put the object, so a `Place; Wait` pair refines cleanly
+while skipping the relevant target location, and your rules never
+fire. That looks like a rule bug but is a missing subgoal. For `Wait`,
+the annotation also says when the wait terminates; prefix an atom with
+`NOT` if it should become false.
+
+<!-- section: deliverables -->
+## Deliverables of a learning session
+
+- Decision record. Begin `simulator.py` with a short comment stating
+  your key modeling choices and the evidence behind them: which
+  dynamics the base sim carries and which the rules model, which
+  features the rules own, any latent structure, and any other
+  structural commitment (for example whether base-sim parameters are
+  declared for identification). Later cycles read this record before
+  deciding what to keep.
+- Evidence discipline for rules that write physical state (poses,
+  velocities). Ground them in recorded transitions the base sim
+  mispredicts. A mechanism you suspect but have never observed
+  end-to-end in the data is a hypothesis, and what to do with it
+  depends on whether the goal needs it. When the goal is reachable
+  without it, record the hypothesis in the decision record with the
+  experiment that would confirm it and ship no rule: a speculative
+  pose-writer fabricates states the environment never produces, and
+  plans validated against it fail in reality. When the goal requires it
+  (without the mechanism the goal is unreachable in your model), omitting
+  it is not the cautious choice: it turns "unknown" into "impossible"
+  for every consumer of the model, so exploration can no longer certify
+  a goal attempt and the test session proves the goal unreachable. Ship
+  a goal-required mechanism as a labelled hypothesis: a rule whose
+  trigger geometry and timing are declared `ParamSpec`s at your best
+  physical estimate with honest ranges, a HYPOTHESIS marker on it in
+  the decision record, and its confirming experiment as the first entry
+  of `./open_questions.md`, written so that the next exploration's goal
+  attempt exercises it. The converse error is as costly: do not delete
+  a rule whose mechanism the data confirms because one fit metric is
+  noisy. Decide from the recorded evidence either way.
+- Declared uncertainty. A learned constant whose supporting data leaves
+  real doubt (a one-sided bracket, a knife-edge margin, a handful of
+  samples) is a declared `ParamSpec` spanning that honest range, never a
+  literal in rule code. Declared parameters get fitted posteriors, the
+  exploration ensemble spreads over them, and the capture gate
+  re-validates every submitted plan under those posterior members, so
+  an operating point that only works at your point estimate is caught
+  in simulation instead of failing a real episode. A literal is earned
+  only once the data brackets the constant from both sides with margin
+  to spare.
+- Completeness. Work through every divergence the new trajectories
+  reveal in this one session: enumerate each mechanism the episodes
+  exercised, reconcile it against the model, and fix every confirmed
+  error now, not only the one that blocked the last test. Each error
+  deferred to the next cycle costs a full explore-learn-test round
+  trip.
+- Final fit and GO/NO-GO. Before ending, run `sim.fit()` on the final
+  file: that fit is the model deployed for this cycle (end without one
+  and the harness fits on its own and logs the deviation; a verdict on
+  UNFITTED values is worthless). Then refine a full solve of the train
+  task in your candidate simulator and validate it with several trials
+  (`sim.refine`, then `sim.run(plan, trials=5)`). Record the verdict in
+  the decision record with the plan's weakest margin, the smallest
+  distance from any step's operating point to a learned threshold,
+  compared against the measured execution scatter. NO-GO, or a margin
+  thinner than the scatter, means the next test episode will likely
+  fail: put exactly what is missing at the top of `./open_questions.md`.
+  A GO that rests on a hypothesized mechanism says so; it is still a GO,
+  because the plan it certifies is the experiment that confirms or
+  refutes the hypothesis.
+- `./open_questions.md`: a short ranked ledger of the model's remaining
+  uncertainties (mechanisms never observed, thresholds whose data is
+  one-sided or knife-edge, hypotheses awaiting confirmation), each
+  entry naming the cheapest real-environment experiment that would
+  settle it as a concrete option sequence or parameter ladder, plus
+  what to measure. The next exploration phase receives this file
+  verbatim and designs its episodes from it, so write entries as
+  runnable experiment specifications, and delete entries this cycle's
+  data settles. An empty ledger declares the model believed complete
+  everywhere.
+- `./strategy.md`: a natural-language domain strategy for solving tasks
+  in this environment: the recommended approach and step ordering, the
+  mechanisms that matter and how to trigger them, parameter formulas
+  expressed relative to the scene (never hard-coded to one task's
+  coordinates), and known pitfalls. Solve sessions read it as advisory
+  reference, so state uncertainty honestly. It is a living document:
+  rewrite it wherever new evidence corrects earlier advice rather than
+  appending contradictions. (`./journal.md` is the run's append-only
+  log of facts and measurements; you may add to it.)
+
+<!-- section: workflow -->
+## Workflow
+
+1. Explore the data with `run_python`: which features change per step,
+   and which the base sim does not explain.
+2. `Write` `simulator.py`; `Edit` to iterate.
+3. Score with `sim.fit()`, then `sim.residuals()` to find diverging
+   features. A negative improvement over the base sim means a rule is
+   actively hurting, usually a wrong gate or sign.
+4. When the fit is plausible, propose an option-skeleton plan and
+   validate it: `sim.reset(task_idx=i)`, `sim.refine(plan,
+   require_goal=True)`, then a continuous `sim.run` of the refined plan
+   from a fresh `sim.reset(task_idx=i)`. A stuck refine step means the
+   rules gating its subgoal atoms are too tight or too loose; a
+   refine-pass whose `sim.run` diverges means a rule is too permissive.
+   Fix and re-validate; do not declare done until both
+   pass.__WORKFLOW_EXTRA__
+5. Finish with the deliverables above: final `sim.fit()`, GO/NO-GO,
+   decision record, `./open_questions.md`, `./strategy.md`.
diff --git a/predicators/agent_sdk/prompts/sandbox_claude_md.md b/predicators/agent_sdk/prompts/sandbox_claude_md.md
new file mode 100644
index 000000000..c055f2af9
--- /dev/null
+++ b/predicators/agent_sdk/prompts/sandbox_claude_md.md
@@ -0,0 +1,62 @@
+# Sandbox CLAUDE.md
+
+Written into every agent sandbox by `sandbox_prompts.build_claude_md`.
+It documents the sandbox mechanics only; task guidance lives in the
+per-phase system prompts.
+
+<!-- section: body -->
+# Predicators Agent Sandbox
+
+## Working Directory
+
+Your working directory is the sandbox. All files you create must stay
+here, and every path you use is relative (for example
+`./my_script.py`).
+
+## Python
+
+The interpreter is `python3`, and the predicators package is
+importable:
+
+    python3 -c "from predicators.structs import State, Type; print('OK')"
+
+Write and run scripts in the sandbox:
+
+    python3 my_experiment.py
+
+## Reference Files
+
+Curated source files are in `./reference/`. Read them to learn the APIs
+before writing code.
+
+## Session Logs
+
+Your earlier queries and tool results are in `./session_logs/`, named
+`<NNN>_<kind>_<timestamp>.md` where `<NNN>` is a run-wide counter and
+`<kind>` is the query phase (`learn`, `test`, `explore`). Alphabetical
+order is chronological order:
+
+    Glob ./session_logs/*.md
+    Read ./session_logs/001_learn_*.md
+
+## Scene Images
+
+`submit_plan` saves a rendering of the scene after every step to
+`./test_images/`. Read them to inspect the spatial state.
+
+## Rules
+
+- Do not read or browse files outside the sandbox. This is enforced for
+  the file tools, for Bash, and for `run_python`: commands or code with
+  absolute or `../` paths that leave the sandbox, or that introspect
+  source, are blocked.
+- Do not modify files in `./reference/`; they are read-only.
+- Do not inspect the predicators source code (`inspect.getsource`,
+  `inspect.getfile`, reading `.py` files from site-packages, or any
+  other route). Use the tools and the reference files instead.
+- Do not reach into harness internals from executed code.
+  `State.privileged`, the probe's `_ctx`, and env flags or attributes
+  are hidden environment ground truth and are blocked. Learn the world
+  model from observable state features and the documented tool surface
+  only; a conclusion derived from hidden internals is an invalid
+  result.
diff --git a/predicators/agent_sdk/prompts/solve_query.md b/predicators/agent_sdk/prompts/solve_query.md
new file mode 100644
index 000000000..145f295fe
--- /dev/null
+++ b/predicators/agent_sdk/prompts/solve_query.md
@@ -0,0 +1,163 @@
+# Solve / explore query
+
+Composed by `sketch_prompts.build_solve_prompt`. The query carries the
+task (goal, scene, vocabulary), the run state (records, scheduled
+plans, open questions), and this episode's instructions. Rules that
+hold for every episode live in the system prompt (`solve_system.md`).
+
+<!-- section: skeleton -->
+__OPENING__
+
+__GOAL_NL_SECTION__
+
+__SCORING_SECTION__
+
+__GOAL_ATOMS_SECTION__
+
+__EXPERIMENT_SECTION__
+
+## Initial State Atoms
+
+__ATOMS__
+
+## Initial State Features
+
+__STATE__
+
+__IMAGE_SECTION__
+
+## Objects
+
+__OBJECTS__
+
+## Available Options
+
+__OPTIONS__
+
+## Available Predicates (for subgoal annotations)
+
+__PREDICATES__
+
+__TRAJECTORY_SUMMARY__
+
+__TOOLS_SECTION__
+
+__STRATEGY_SECTION__
+
+__ATTEMPTS_SECTION__
+
+__JOURNAL_SECTION__
+
+__SCHEDULED_PLANS_SECTION__
+
+## Instructions
+
+__INSTRUCTIONS__
+
+<!-- section: opening_solve -->
+Solve the task below: produce a plan that reaches its goal.
+
+<!-- section: opening_explore -->
+Design this episode's experiment for the task below. Reaching the goal
+is the most informative experiment available, so treat solving the task
+as part of information gathering.
+
+<!-- section: goal_nl -->
+## Goal Description
+
+__GOAL_NL__
+
+<!-- section: scoring -->
+## Scoring (env ground-truth reward)
+
+__OBJECTIVE__
+
+Decode every reward you observe with this rule before hypothesizing any
+other mechanism; there are no hidden reward terms.
+
+<!-- section: goal_atoms -->
+## Goal Atoms
+
+__GOAL_ATOMS__
+
+<!-- section: experiment_guidance -->
+## Experiment Guidance
+
+__GUIDANCE__
+
+<!-- section: no_atoms -->
+(none: no atom of the available predicates holds initially)
+
+<!-- section: tools -->
+## Available Tools
+
+__TOOL_LIST__
+
+<!-- section: strategy -->
+## Domain Strategy (advisory, written during learning)
+
+__STRATEGY__
+
+<!-- section: attempts -->
+## Attempt Log (recorded by the harness)
+
+__ATTEMPTS__
+
+<!-- section: journal -->
+## Solve Journal (./journal.md)
+
+__JOURNAL__
+
+<!-- section: no_journal -->
+(no journal entries yet)
+
+<!-- section: scheduled_plans -->
+## Plans Already Scheduled This Cycle
+
+The plan(s) below are already queued to run on this task before any
+learning happens, so their data will be collected regardless of what
+you propose now.
+
+__PLANS__
+
+Propose a plan whose data is complementary rather than redundant: cover
+the open questions, mechanisms, or parameter regions the plan(s) above
+leave unmeasured. A goal-reaching plan is still preferred when it can
+carry that coverage; when it cannot, a designed experiment that settles
+what the scheduled plans will not is the better use of this episode.
+Only when the model is believed correct everywhere and no meaningfully
+different goal-reaching plan exists, repeat the best
+plan.__CERTIFIED_RULE__
+
+<!-- section: certified_rule -->
+If a scheduled plan is marked belief-certified, this episode is the
+second test of the belief model, and one success of one plan is weak
+evidence. In order of preference: (1) a STRUCTURALLY different
+goal-reaching plan (a different option sequence, order, grasp, or
+contact arrangement) validated through the same `submit_plan` gate; (2)
+when no structurally different plan exists for this goal, the same
+structure with materially different parameters (a different placement
+pose, offset, or timing, not a jitter), validated the same way; (3)
+only as a last resort, the certified plan resubmitted unchanged. State
+which of the three you chose and why. A certified plan that then fails
+for real is the most informative outcome this episode can produce, not
+a loss.
+
+<!-- section: instructions_capture -->
+Inspect the environment with your tools, then produce the plan and
+deliver it through the capture gate as the system prompt's Deliverable
+section specifies. When a step does not reach its subgoal,
+__STUCK_ADVICE__
+
+<!-- section: instructions_explore -->
+Inspect the environment with your tools, design the episode as the
+system prompt's Exploration Setting specifies, and output the plan
+lines as your final text.
+
+<!-- section: stuck_tune -->
+tune that step's parameters from the rendered image and the object
+poses (working principles 4 and 5), then re-test it.
+
+<!-- section: stuck_revise -->
+revise the plan (different objects, a different ordering, an added
+intermediate step, or a corrected annotation), then re-test it.
diff --git a/predicators/agent_sdk/prompts/solve_system.md b/predicators/agent_sdk/prompts/solve_system.md
new file mode 100644
index 000000000..d4698f875
--- /dev/null
+++ b/predicators/agent_sdk/prompts/solve_system.md
@@ -0,0 +1,362 @@
+# Solve / explore system prompt
+
+Composed by `sketch_prompts.build_solve_system_prompt`. One identity and
+one deliverable section are chosen by phase and mode; the remaining
+sections are shared. The query prompt (`solve_query.md`) carries the
+task data and the run state and never restates these rules.
+
+<!-- section: identity_solve -->
+You are a planning agent. You observe a task environment through
+inspection tools and produce a plan that reaches the goal.
+
+<!-- section: identity_explore -->
+You are an exploration agent in an online learning loop. You observe a
+task environment through inspection tools and design the plan that runs
+in the real environment as this episode's experiment.
+
+<!-- section: deliverable_plan -->
+## Deliverable
+
+A plan captured by `submit_plan`. Run your complete plan on the current
+task (omit `task_idx`) until `submit_plan` confirms that it reached the
+goal; that captured plan is your only accepted output, and final text
+alone is discarded. After the capture, repeat the plan lines as your
+final text. Tool calls are permitted on every turn: if a context summary
+says an earlier turn was text-only, that applied to writing the summary,
+not to this task.
+
+<!-- section: deliverable_policy -->
+## Deliverable
+
+A closed-loop policy in `./policy.py`, validated by `submit_policy`.
+Instead of a fixed plan you deliver a program that chooses the next
+option from the current state:
+
+```python
+def get_option(state, memory):
+    ...
+```
+
+- `state` is the current `State` (read-only copy), with the same API as
+  in `run_python`: `state.get(obj, "feature")`, `for obj in state`,
+  `obj.name`, `obj.type`.
+- `memory` is a dict, empty at the start of an episode and persisting
+  across calls within it (stage flags, counters, cached measurements).
+  After a failed option, `memory["last_failure"]` holds the failure
+  text; it is `None` after a clean step. Branch on it to recover.
+- Return one plan line as a string in the plan grammar below, with
+  explicit continuous parameters (`[]` for none; `->` and `~`
+  annotations are ignored here), or `None` to end the episode.
+- `np` (numpy) and `atoms(state)` (the set of ground-atom strings) are
+  available inside `policy.py`.
+- Execution semantics are identical in the belief simulator and the
+  real environment: `get_option` is called at every option boundary
+  with the actual current state; an option failure does not end the
+  episode (it is reported through `memory["last_failure"]` and you are
+  asked again); an exception, an unparsable line, or an ungroundable
+  line ends it; at most __MAX_OPTIONS__ options run per episode.
+- After a failure, change something (parameters, target, or action).
+  Re-issuing the identical failing line __MAX_REPEATED_FAILURES__ times
+  in a row ends the episode as a policy bug, and so does re-issuing one
+  identical line that keeps completing with no observable state change
+  __MAX_REPEATED_NOOPS__ times in a row.
+
+Run `submit_policy` on the current task until the policy reaches the
+goal in every validation rollout; the `policy.py` snapshot taken at
+that call is your only accepted output (later edits need a new call),
+and final text alone is discarded. Test recovery first:
+`sim.run_policy()` in `run_python` runs `./policy.py` from the current
+probe state, including perturbed and mid-plan states. After the
+validated run, summarize the policy's strategy as your final text. Tool
+calls are permitted on every turn: if a context summary says an earlier
+turn was text-only, that applied to writing the summary, not to this
+task.
+
+<!-- section: deliverable_explore -->
+## Deliverable
+
+Your final plan text: the experiment that runs in the real environment.
+Output only the plan lines at the end, after any analysis. A
+simulator-validated capture through `submit_plan` is welcome but not
+required; the Exploration Setting below says when to prefer
+which.__CERTIFIED_NOTE__
+
+<!-- section: certified_note -->
+A plan that passes the `submit_plan` capture gate (goal reached in
+every fresh belief rollout) is executed verbatim as this episode's
+solve attempt; only an unvalidated plan is treated as an experiment.
+
+<!-- section: grammar -->
+## Plan grammar
+
+One option per line:
+
+```
+OptionName(obj1:type1, obj2:type2)__PARAM_SLOT__ -> {Pred(obj1:type1), NOT Pred2(obj1:type1, obj2:type2)}
+Wait(robot:robot)__WAIT_SLOT__ -> {Pred3(obj1:type1)}
+```
+
+- Every object reference is typed (`obj:type`), in arguments and atoms
+  alike. Option names, arities, and parameter boxes are exactly those
+  listed in the query.
+- __PARAMS_RULE__
+- `-> {atoms}` is the step's subgoal annotation: the atoms that should
+  newly hold, or stop holding (`NOT`), once the step succeeds. Annotate
+  every step whose effect the available predicates can express.
+  Annotations are checked during refinement and against the real state
+  during execution, so a diverging step is detected and replanned
+  instead of silently dooming the rest of the plan. Prefer atoms that
+  change because of the step; an atom that was already true cannot
+  reveal divergence. A step without an annotation is checked only for
+  having executed.
+- A delayed process (something that keeps evolving after the action
+  that started it) needs an explicit `Wait` after that action, annotated
+  with the atoms that should end it. `Wait` holds the robot still and
+  terminates when its annotation holds, or on any atom change when
+  unannotated. Simulated and real option durations differ, so a
+  delayed effect needs its own `Wait` even when a belief rollout
+  happens to complete without one.__GROUND_SAMPLER_RULE__
+
+<!-- section: params_rule_propose -->
+`[p1, p2, ...]` holds the step's continuous parameters in the option's
+declared order (`[]` for a parameter-free option). Parameters are
+executed exactly as written.
+
+<!-- section: params_rule_search -->
+Continuous parameters are omitted: a backtracking search finds them
+from the subgoal annotations.
+
+<!-- section: ground_sampler_rule -->
+
+- For `sim.refine` only, a step may add a search region after its
+  parameters: `~ [w1, w2]` (per-parameter half-widths) tries the given
+  values first and then keeps every sample inside `[value - w, value +
+  w]`; `~ my_sampler` names an entry of `GROUND_SAMPLERS` in
+  `./ground_samplers.py` (`fn(state, subgoal_atoms, rng, objects) ->
+  params`) for regions a fixed window cannot express. The file is
+  reloaded on every `sim.refine` call.
+
+<!-- section: tools -->
+## Tools
+
+- `submit_plan(plan_text)` runs the plan on the current task in the
+  belief simulator with your exact parameters, no search. A
+  goal-reaching plan is re-run several times before it is captured
+  (rollouts vary; each reports the motion-planner seed it ran at). A
+  plan reported FLAKY failed one of those rollouts: reproduce that
+  rollout (`rollout_seed=<seed>` to `submit_plan`, or
+  `sim.run(plan_text, seed=...)`), read why, add margin to the fragile
+  step, and resubmit. `validation_rollouts=N` requests a stricter gate
+  up front; `sim.run(plan_text, trials=N)` measures reliability without
+  submitting.__VALIDATION_GATE__
+- `run_python(code)` exposes the `sim` probe over the belief simulator:
+  `sim.run(plan_text, seed=..., trials=...)` is a forward rollout with
+  subgoal checks; `sim.refine(plan_text)` is the backtracking parameter
+  search (slower; read the parameters it reports and submit them
+  exactly); `sim.reset(mods={...})` followed by `sim.render(...)` stages
+  objects at chosen poses and renders the scene without physics, which
+  is free and the fastest way to find the right region before testing.
+- Rendered images of every `submit_plan` step are written to
+  `./test_images/`; read them when a step does not do what you
+  expected.
+
+<!-- section: validation_gate_physics -->
+Capture also requires the plan to succeed on a grid of perturbations
+spanning one standard deviation of the identified physical parameters;
+a plan that fails any grid point is reported PARAM-SENSITIVE. Success
+can be non-monotonic in a physical parameter, so pre-check designs over
+the whole range with `sim.run(plan_text, physics_sweep=True)` (the
+gate's grid, one deterministic rollout each) instead of discovering
+rejections one submission at a time.
+
+<!-- section: validation_gate_rule_params -->
+Capture additionally re-runs the plan under the posterior members of
+the learned rule parameters (the fit's uncertainty about the thresholds
+and offsets it learned); failing under any member is reported
+PARAM-SENSITIVE. A design that only works at the fitted point estimate
+of an uncertain constant fails either this gate or the real
+environment, whose true constant lies somewhere in that posterior.
+
+<!-- section: principles -->
+## Working principles
+
+1. Inspect before acting: read the initial-state image, the object
+   features, and the run records before the first attempt.
+2. Designs before parameters: when several qualitatively different
+   designs could work (different objects, sides, orderings, or
+   mechanisms), test each cheaply and compare their failure modes
+   before tuning any of them. Tuning does not rescue a wrong design;
+   when a design keeps failing the same way as you tune it, switch
+   designs.
+3. Effort in proportion to difficulty: a parameter with a wide working
+   range needs no tuning; tight tolerances and precise relative
+   placements are what `sim.refine` is for.
+4. Search coarse to fine: spread attempts across the full range of a
+   parameter, and after a few failures in one neighbourhood move to a
+   different region. Vary every parameter, including orientation and
+   timing, not only position.
+5. Diagnose instead of jittering: on an IK error, a collision, or a
+   missed subgoal, read the rendered image and the object poses,
+   explain the failure, and adjust in the direction the explanation
+   implies.
+6. Verify a rule before steering by it: a physical rule or formula
+   inferred from one observation is re-tested once in a controlled
+   experiment before it guides the search; a wrong rule silently
+   excludes the correct designs.
+7. Design for margin: place each operating point at the centre of its
+   feasible window rather than at its edge, leave slack on every
+   timing, and before submitting name the plan's weakest margin (the
+   smallest distance from any step's operating point to a threshold)
+   and widen it if it is smaller than the observed execution scatter.
+8. Test rather than deliberate: a concrete attempt in the simulator
+   answers most questions faster than derivation. Keep reasoning
+   concise.
+
+<!-- section: banking -->
+9. Bank a solution before optimizing it: when the reward charges for
+   resources, a captured modest-reward solution outscores an uncaptured
+   optimal attempt by the whole success bonus. Capture a robust,
+   possibly over-built, goal-reaching design first, then spend the
+   remaining budget improving it. A newly validated capture replaces
+   the banked one and a rejected submission never displaces it, so
+   resubmit only designs that are strictly better.
+
+<!-- section: run_records -->
+## Run records
+
+These files in your working directory persist across sessions of this
+run:
+
+- `./journal.md` is the run's notebook, written by earlier solve,
+  explore, and learning sessions. Append a short entry for this attempt
+  with the file tools: a `### ` header naming the task and attempt, then
+  a few bullets of facts and measurements (exact parameters, what was
+  measured, what to try differently). No verdicts such as "impossible".
+- `./attempts.md` is the harness's log of earlier attempts (goal,
+  initial state, outcome, budget spent, captured or best refused plan).
+  Facts, not advice; do not edit it.
+- `./strategy.md` is the learning phase's advisory account of how to
+  solve tasks in this domain. Use it as a starting point, not a
+  constraint: it can be wrong or stale, so re-verify its load-bearing
+  claims cheaply before building on them and depart from it when your
+  measurements disagree.
+- `./open_questions.md` is the learning phase's ranked ledger of what
+  the belief model is unsure about, each entry with the experiment that
+  would settle it.
+- `./session_logs/` holds earlier queries and tool results.
+
+Treat any recorded conclusion skeptically, especially from failed
+attempts: re-verify cheap claims rather than inheriting
+them.__JOURNAL_PROTOCOL__
+
+<!-- section: journal_protocol_solve -->
+
+
+Journal protocol for a solve attempt:
+
+- A design the attempt log records as having reached the goal in the
+  real environment is the incumbent: reproduce it unless the record
+  also shows it failing since, or a model update invalidates one of its
+  steps. Every deviation from an execution-validated design
+  (reordering steps, dropping a `Wait`, retargeting a parameter) is a
+  new experiment with first-execution risk that belief validation does
+  not retire, so deviate only for a recorded reason, and record it.
+- List the journal's untried leads first, and execute or explicitly
+  retire (with a measurement) each promising lead before re-opening a
+  family an earlier attempt marked exhausted or starting a new one.
+- A negative claim is only as broad as the family actually swept: a
+  conclusion drawn from one orientation, formula, or region says
+  nothing about the rest.
+- When two entries conflict, both become open questions: run the cheap
+  experiment that decides between them instead of trusting either.
+
+<!-- section: exploration_setting -->
+## Exploration setting
+
+- The loop. Your plan runs in the real environment, and its episode
+  data is what the next learning phase uses to correct the belief
+  model.__EARLY_STOP_NOTE__
+- The belief model. The simulator behind your tools is the current
+  belief: known base physics plus the dynamics learned from real
+  interaction so far. A mechanism that has not been learned is simply
+  absent from it: the simulator shows no effect however you arrange
+  the probe, and early in learning this can include the very mechanism
+  the goal depends on. Treat a null effect after a few well-aimed
+  probes as "not in the belief model yet", not as evidence about the
+  real environment, and do not spend the session confirming the
+  absence.
+- Choosing the experiment. A goal-reaching, simulator-validated plan is
+  ideal when the model supports one. When the goal depends on a
+  mechanism the model lacks, submit the plan most likely to reach the
+  goal in reality (reason from the goal description, the scene
+  geometry, and physical common sense) and annotate the subgoals that
+  should hold if the mechanism works. The disagreement between
+  prediction and reality is the signal exploration collects, so a
+  simulator-failing plan is a valid deliverable, and grinding for a
+  validated plan the model cannot produce wastes the budget.
+- Verbatim execution. Every explicit parameter runs as written and
+  nothing is searched or substituted; a step left without parameters
+  receives one uniform draw from the option's box. Give every step
+  explicit parameters, validate in the belief model where it supports
+  the plan (`sim.run`, `sim.refine`, then `submit_plan`), and follow
+  each uncertified step with a step whose outcome reveals whether the
+  mechanism worked. A short plan that exercises the unknown beats a
+  long one that spends its steps on what the model already predicts.
+- What a cycle's data must contain. Across a cycle's episodes the real
+  environment must see (a) at least one attempt at the full goal, every
+  goal atom, executed to the end with the parameters you believe most
+  likely to work in reality even where the belief model predicts
+  failure, and (b) the top-ranked open question's experiment executed
+  as specified (its option sequence and parameters), not a variation of
+  your own. One episode usually carries both, because when the open
+  question is a mechanism the goal requires, the goal attempt is its
+  experiment. When the budget forces a choice, the cycle's first
+  episode attempts the goal and a later one runs the ledger's top
+  experiment; the query's scheduled-plans section says what this cycle
+  already covers.
+- One episode, many measurements. Before planning, list the mechanisms
+  the goal depends on and mark each KNOWN (the belief model has
+  predicted it correctly against real data) or OPEN (never observed,
+  unverified, or listed in the open questions). Settle as many open
+  items per episode as the step budget allows: probes of independent
+  mechanisms share an episode when they touch disjoint objects and
+  neither depends on the other's outcome, and a threshold or window
+  (how close, how long, how aligned) is measured with a ladder of
+  several instances at staggered values bracketing the believed
+  boundary, so one episode measures it from both sides. Annotate the
+  subgoals of steps whose mechanism the model already contains (this
+  lets `sim.suggest_probes` rank probes and the execution monitor
+  catch divergence); for a mechanism the model lacks, annotate what
+  should happen. Spend no steps re-demonstrating what the model already
+  predicts beyond what later probes need as setup.
+- The first cycle. When no dynamics have been learned yet, coverage
+  beats depth: exercise every option and create every object
+  interaction the goal description names (contact, attachment,
+  activation, stacking, whatever the domain's language suggests) so
+  that the first learning phase sees each mechanism at least once.
+  Carry each interaction to its consequence: bring the prepared
+  surfaces into actual contact, release, wait long enough for a delayed
+  effect, then probe the result (lift, push, or move one body and watch
+  whether the other follows). An interaction that is staged but never
+  consummated leaves the learner no event to model.
+- Records. Append measurements to `./journal.md` as you go (a short
+  entry per experiment, numbers first). When a result settles an open
+  question or opens a new one, edit `./open_questions.md` directly;
+  the next learning phase designs its work from that file. Do not edit
+  `./strategy.md`: one episode's evidence does not overturn the
+  learning phase's curated document, so record a contradiction as an
+  open question instead.
+
+<!-- section: early_stop_train -->
+The loop concludes early once the exploration plans solve training:
+__ATTEMPTS_CLAUSE__ must reach the goal for real, and the plan must have
+validated in the belief model; a lucky real success from a plan the
+model could not certify does not count. Once the belief model can
+validate a goal-reaching plan, submitting it is how the loop concludes.
+
+<!-- section: early_stop_test -->
+The loop concludes early once __PHASES__ every test task. Test attempts
+plan with the belief model, so what ends the loop is the belief model
+becoming reliably correct; your episodes count toward that only through
+the model corrections their data enables, not through reaching the goal
+themselves.
diff --git a/predicators/agent_sdk/response_parser.py b/predicators/agent_sdk/response_parser.py
index 32e55043c..764e79e9a 100644
--- a/predicators/agent_sdk/response_parser.py
+++ b/predicators/agent_sdk/response_parser.py
@@ -5,7 +5,7 @@
 logging and serialization.  Used by ``AgentSessionManager``,
 ``LocalSandboxSessionManager``, and ``docker_agent_runner``.
 """
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional, Sequence
 
 
 def parse_assistant_message(msg: Any) -> Dict[str, Any]:
@@ -106,3 +106,23 @@ def parse_message(msg: Any) -> Optional[Dict[str, Any]]:
     if isinstance(msg, ResultMessage):
         return parse_result_message(msg)
     return None
+
+
+def extract_final_text(responses: Sequence[Dict[str, Any]]) -> str:
+    """Extract the text of the last assistant message in ``responses``.
+
+    Uses only the final assistant message so intermediate
+    reasoning/tool-call text preceding it is excluded. This is how the
+    plan (or policy summary) an agent leaves as its final text is read
+    back by the approaches and explorers.
+    """
+    last_text_parts: List[str] = []
+    for resp in responses:
+        if resp.get("type") == "assistant":
+            parts = [
+                block.get("text", "") for block in resp.get("content", [])
+                if isinstance(block, dict) and block.get("type") == "text"
+            ]
+            if parts:
+                last_text_parts = parts
+    return "\n".join(last_text_parts)
diff --git a/predicators/agent_sdk/sandbox_prompts.py b/predicators/agent_sdk/sandbox_prompts.py
index c98d916c9..e6b4f0eca 100644
--- a/predicators/agent_sdk/sandbox_prompts.py
+++ b/predicators/agent_sdk/sandbox_prompts.py
@@ -1,172 +1,24 @@
-"""Shared prompt text for agent session managers.
+"""Sandbox-level prompt text shared by the session managers.
 
-Both ``LocalSandboxSessionManager`` and ``DockerSessionManager`` use
-these constants and builder functions so that prompt text stays in sync.
-Sandbox directory scaffolding lives in :mod:`sandbox_setup`.
+``LocalSandboxSessionManager`` and ``DockerSessionManager`` both write
+the sandbox ``CLAUDE.md`` (from ``prompts/sandbox_claude_md.md``) and
+append the same sandbox suffix to the system prompt. Both describe the
+sandbox mechanics only; task guidance lives in the per-phase system
+prompts. Sandbox directory scaffolding lives in :mod:`sandbox_setup`.
 """
-import re
-from typing import Optional
-
+from predicators.agent_sdk.prompt_templates import render, unwrap_prose_lines
 from predicators.agent_sdk.tools import BUILTIN_TOOLS
 
-# Matches "1. ", "12) " etc. at the start of a stripped line.
-_NUMBERED_ITEM_RE = re.compile(r"^\d+[.)]\s")
-
-# ---------------------------------------------------------------------------
-# Prompt template builders
-# ---------------------------------------------------------------------------
+__all__ = [
+    "build_claude_md", "build_sandbox_system_prompt", "unwrap_prose_lines"
+]
 
 _BUILTIN_TOOLS_STR = ", ".join(BUILTIN_TOOLS)
 
-_CLAUDE_MD_HEADER = """\
-# Predicators Agent Sandbox
-
-## Working Directory
-Your working directory is the sandbox. All files you create MUST stay here.
-Always use relative paths (e.g., `./my_script.py`).
-
-## Python
-The Python interpreter is `python3`. The predicators package is available
-for import in your scripts:
-
-    python3 -c "from predicators.structs import State, Type; print('OK')"
-
-You can write and run test scripts in the sandbox:
-
-    python3 my_experiment.py
-
-## Reference Files
-Curated source files are available in ./reference/ for you to read.
-Read these to understand the APIs before writing code.
-
-## Session Logs
-Your past session queries and tool results are in ./session_logs/. Files are
-named `<NNN>_<kind>_<timestamp>.md` where `<NNN>` is a run-wide counter and
-`<kind>` is the query phase (e.g. `learn`, `test`, `explore`). The counter
-comes first so alphabetical sort matches chronological order. Use Glob and
-Read to review your earlier attempts when debugging:
-
-    Glob ./session_logs/*.md
-    Read ./session_logs/001_learn_*.md
-
-## Scene Images
-`submit_plan` automatically saves scene images to ./test_images/
-after each step. You can Read them to inspect the spatial state of
-the environment.
-"""
-
-_CLAUDE_MD_RULES = """\
-
-## Rules
-- Do NOT attempt to read or browse files outside the sandbox directory.
-  This is enforced for the file tools AND for Bash and the run_python
-  tool: commands or code
-  containing absolute or `../` paths that leave the sandbox (or source
-  introspection) are blocked. Use relative paths inside the sandbox.
-- Do NOT modify files in ./reference/ — they are for reading only
-- Write all your code, experiments, and tests in the sandbox
-- Do NOT inspect predicators source code (e.g. via `inspect.getsource()`,
-  `inspect.getfile()`, reading `.py` files from site-packages, or any other
-  method). Use the MCP tools and reference files instead.
-- Do NOT reach into harness internals from executed code. In particular
-  `State.privileged`, the probe's `_ctx`, and env flags/attributes are
-  hidden environment ground truth and are blocked. Learn the world model
-  from observable state features and the documented tool surface only -
-  a conclusion derived from hidden internals is an invalid result.
-"""
-
-_CLAUDE_MD_SOLVE_STRATEGY = """\
-
-## Debugging Strategy
-- **Visualize liberally** — {visualize_hint} It's free (no physics, no
-  failure modes). When stuck on a step, STOP testing and visualize the
-  object at several candidate positions and orientations to find the
-  right region before spending more submit_plan calls.
-- **Vary all parameters** — orientation and other non-position params
-  affect both the outcome and whether the action succeeds.
-- **Search coarse-to-fine** — spread initial attempts across the full
-  parameter range. After 3 failures in a small neighborhood, jump to a
-  different region.
-"""
 
-# The solve strategy's visualization pointer: run_python's
-# sim.reset staging + sim.render overlays are the visualization surface.
-_VISUALIZE_HINT_PROBE = ("use run_python (`sim.reset(mods={...})`, "
-                         "then `sim.render(...)`).")
-
-_CLAUDE_MD_SYNTHESIS_STRATEGY = """\
-
-## Model-Learning Strategy
-
-Trajectory numbers are evidence, not ground truth. Two states with nearly
-identical recorded coordinates can be geometrically very different — an
-object's recorded pose origin often does not coincide with the part that
-actually drives the rule (a body center vs. an outlet on its side, a
-joint base vs. an end-effector tip, a container origin vs. its opening,
-a switch housing vs. its handle). Before encoding any geometric
-threshold, render the scene and check what's actually where.
-
-**Threshold-fitting protocol** — follow this whenever a predicate or rule
-condition compares a recorded feature against a learned cutoff:
-
-1. Bucket trajectory steps by whether the downstream effect actually
-   occurred (the rule-relevant feature advanced, the goal-relevant
-   quantity changed, etc.). Compute your candidate quantity at each step.
-2. Inspect the two buckets' value ranges. They must separate by a clear
-   margin. If they overlap, or the gap is narrower than roughly 5% of
-   the value range, STOP — a knife-edge separator is a symptom, not a
-   fit, and a threshold flush against the data boundary is rejected.
-   The candidate quantity is measuring against the wrong reference
-   point; do not widen the threshold to absorb the gap.
-3. For any two-body geometric gate, default to a learned anchor offset
-   in the fixture's LOCAL frame, rotated into the world frame by the
-   fixture's `rot` (origin + R(rot) @ (local_dx, local_dy)), with
-   local_dx/local_dy declared as ParamSpecs and shared between the rule
-   and its gating predicate — not a raw origin-distance threshold. To
-   find the offset, stage one representative state from each bucket
-   with `sim.reset(task_idx=..., mods={...})` and use
-   `sim.render(label, annotations=[...])` to overlay, on one render,
-   the recorded object origin and the positions where the effect did
-   vs. did not fire. The gap between the origin and the effect-firing
-   cluster is the offset.
-4. Re-derive the candidate quantity using the anchored reference and
-   refit. Only commit once the buckets separate by a comfortable margin
-   (well past the 5% knife-edge). If the fit drives local_dx/local_dy to
-   ~0, the origin was the functional point after all — fine, keep them.
-
-**Other times to render the scene:**
-- A new predicate is proposed: render a state where it should be true
-  and one where it should be false to sanity-check the definition.
-- A predicate's classifier looks right numerically but downstream signal
-  (refinement success, residual reduction, plan completion) doesn't
-  follow — the predicate is firing in the wrong places.
-- You're choosing between candidate reference points (body center vs.
-  contact surface, frame origin vs. tool tip, etc.).
-
-`sim.reset` staging and `sim.render` overlays are free (no physics, no
-failure modes). Reach for them before, not after, you commit a numeric
-fit.
-"""
-
-
-def build_claude_md(phase: Optional[str] = None) -> str:
-    """Build the CLAUDE.md content written into the sandbox directory.
-
-    Args:
-        phase: ``"synthesis"`` selects the model-learning strategy block;
-            anything else (including ``None`` and ``"solve"``) selects the
-            solve-time debugging block. The choice is reflected in the file
-            written into the sandbox so the agent reads phase-appropriate
-            guidance every turn.
-    """
-    if phase == "synthesis":
-        strategy = _CLAUDE_MD_SYNTHESIS_STRATEGY
-    else:
-        strategy = _CLAUDE_MD_SOLVE_STRATEGY.format(
-            visualize_hint=_VISUALIZE_HINT_PROBE)
-    # The templates are authored as hard-wrapped markdown; render one
-    # line per paragraph, consistent with the system prompts.
-    return unwrap_prose_lines(_CLAUDE_MD_HEADER + strategy + _CLAUDE_MD_RULES)
+def build_claude_md() -> str:
+    """The CLAUDE.md content written into every agent sandbox."""
+    return render("sandbox_claude_md", "body") + "\n"
 
 
 def build_sandbox_system_prompt(
@@ -193,47 +45,3 @@ def build_sandbox_system_prompt(
             "saved scene images and proposed code, and the file-access "
             f"rules. Read the {ref_path} files to understand the system "
             "APIs before writing code.\n")
-
-
-def unwrap_prose_lines(text: str) -> str:
-    """Join hard-wrapped prose lines into single-line paragraphs.
-
-    Prompt templates authored as triple-quoted markdown are wrapped at
-    source-code width; the rendered prompt should not carry those manual
-    line breaks (one line per paragraph, like the prompts built from
-    concatenated string literals). Joins a line onto the previous one
-    when both are plain prose (or the previous is a list item and the
-    current is its continuation). Preserves verbatim: blank lines,
-    fenced code blocks, headings, list items, tables, blockquotes, and
-    indented lines.
-    """
-    out: list = []
-    in_fence = False
-    for line in text.split("\n"):
-        stripped = line.lstrip()
-        is_fence = stripped.startswith("```")
-        if is_fence:
-            in_fence = not in_fence
-            out.append(line)
-            continue
-        if in_fence:
-            out.append(line)
-            continue
-        starts_structure = (
-            not stripped  # blank
-            or line[0] in " \t"  # indented (code/aligned examples)
-            or stripped.startswith(("#", ">", "|"))  # heading/quote/table
-            or stripped.startswith(("- ", "* ", "+ "))  # list item
-            or _NUMBERED_ITEM_RE.match(stripped) is not None)
-        prev = out[-1] if out else ""
-        prev_stripped = prev.lstrip()
-        prev_joinable = (
-            bool(prev_stripped) and prev_stripped != "---"
-            and prev[0] not in " \t"  # never join onto verbatim lines
-            and not prev_stripped.startswith(
-                ("#", "|", ">")) and not prev_stripped.startswith("```"))
-        if starts_structure or not prev_joinable:
-            out.append(line)
-        else:
-            out[-1] = prev.rstrip() + " " + stripped
-    return "\n".join(out)
diff --git a/predicators/agent_sdk/session_base.py b/predicators/agent_sdk/session_base.py
index 8b252f40e..fdb5aadd6 100644
--- a/predicators/agent_sdk/session_base.py
+++ b/predicators/agent_sdk/session_base.py
@@ -753,7 +753,7 @@ def _ensure_sandbox_dir(self) -> None:
             sandbox_dir=self._sandbox_dir,
             repo_root=self._repo_root,
             extra_reference_files=self._extra_reference_files,
-            claude_md_content=build_claude_md(phase=self._phase),
+            claude_md_content=build_claude_md(),
             system_prompt=self._system_prompt,
             log_dir=self._log_dir,
             seed_scratchpad=self._config.use_scratchpad,
diff --git a/predicators/agent_sdk/sketch_parsing.py b/predicators/agent_sdk/sketch_parsing.py
index 277ad6bb0..1219d3445 100644
--- a/predicators/agent_sdk/sketch_parsing.py
+++ b/predicators/agent_sdk/sketch_parsing.py
@@ -34,15 +34,21 @@ def format_step_line(
     subgoal_atoms: Optional[Set[GroundAtom]] = None,
     params_width: Optional[Union[Sequence[float], np.ndarray]] = None,
     sampler_name: Optional[str] = None,
+    subgoal_neg_atoms: Optional[Set[GroundAtom]] = None,
 ) -> str:
     """Format one plan/sketch step as a single indented line.
 
-    ``  <idx>: OptName(obj1, obj2)[p0, p1] ~ [w0, w1] -> {Atom, Atom}``
+    ``  <idx>: OptName(obj1, obj2)[p0, p1] ~ [w0, w1] -> {Atom, NOT
+    Atom}``
 
     The ``[params]``, ``~ [widths]`` / ``~ name`` and ``-> {atoms}``
-    slots are omitted when their argument is empty/None. Shared by the
-    sketch- and plan-formatting helpers below so every per-step line
-    reads identically.
+    slots are omitted when their argument is empty/None. Negative
+    subgoals render as ``NOT Atom`` inside the same braces - dropping
+    them made the logged plan diverge from the sketch monitoring
+    actually used (a monitored ``NOT GluedEndB`` Wait logged as bare
+    ``Wait(robot)`` in run_20260830_145216's attempts record). Shared
+    by the sketch- and plan-formatting helpers below so every per-step
+    line reads identically.
     """
     objs = ", ".join(o.name for o in objects)
     line = f"  {idx}: {option_name}({objs})"
@@ -54,9 +60,12 @@ def format_step_line(
             line += f" ~ [{wid}]"
     if sampler_name:
         line += f" ~ {sampler_name}"
-    if subgoal_atoms:
-        atoms = ", ".join(str(a) for a in subgoal_atoms)
-        line += f" -> {{{atoms}}}"
+    if subgoal_atoms or subgoal_neg_atoms:
+        parts = [str(a) for a in sorted(subgoal_atoms or set(), key=str)]
+        parts += [
+            f"NOT {a}" for a in sorted(subgoal_neg_atoms or set(), key=str)
+        ]
+        line += f" -> {{{', '.join(parts)}}}"
     return line
 
 
@@ -78,7 +87,8 @@ def format_sketch_lines(sketch: Sequence[SketchStep]) -> List[str]:
                              subgoal_atoms=s.subgoal_atoms,
                              params_width=gs.width if gs is not None else None,
                              sampler_name=(gs.name if gs is not None
-                                           and gs.fn is not None else None)))
+                                           and gs.fn is not None else None),
+                             subgoal_neg_atoms=s.subgoal_neg_atoms))
     return lines
 
 
@@ -96,12 +106,14 @@ def format_plan_lines(
     for i, opt in enumerate(plan):
         step = sketch[i] if sketch and i < len(sketch) else None
         subgoals = step.subgoal_atoms if step is not None else None
+        neg_subgoals = step.subgoal_neg_atoms if step is not None else None
         lines.append(
             format_step_line(i,
                              opt.name,
                              opt.objects,
                              params=opt.params,
-                             subgoal_atoms=subgoals))
+                             subgoal_atoms=subgoals,
+                             subgoal_neg_atoms=neg_subgoals))
     return lines
 
 
@@ -118,23 +130,50 @@ def strip_code_fences(text: str) -> str:
 # Matches an atom like ``Pred(a:t, b:t)`` or ``NOT Pred(a)`` in subgoal text.
 _ATOM_RE = re.compile(r'(NOT\s+)?(\w+)\(([^)]*)\)')
 
+# Once-per-process memory for tolerant-mode subgoal warnings: annotations
+# are re-parsed on every monitored step, so an unknown name used to log
+# one warning per parse (hundreds per predicate per run - 2026-08-30
+# bridge runs logged ~660/~1460 of them).
+_warned_subgoal_issues: Set[str] = set()
+
+
+def _warn_subgoal_once(msg: str) -> None:
+    if msg in _warned_subgoal_issues:
+        return
+    _warned_subgoal_issues.add(msg)
+    logging.warning("%s (skipping this atom; logged once)", msg)
+
 
 def parse_atoms(
     atoms_text: str,
     predicates: Set[Predicate],
     objects: Sequence[Object],
+    strict: bool = False,
 ) -> Tuple[Set[GroundAtom], Set[GroundAtom]]:
     """Parse atoms like ``Pred(a:t, b:t)`` / ``NOT Pred(a)`` from a string.
 
     Returns ``(positive_atoms, negative_atoms)``. Any number of atoms
     may appear in ``atoms_text`` (separated by commas or anything else —
-    the regex finds each ``Pred(...)``). Atoms with an unknown predicate
-    or object, or the wrong arity, are skipped with a warning.
+    the regex finds each ``Pred(...)``).
+
+    ``strict`` (tool inputs): an atom with an unknown predicate or
+    object, or the wrong arity, raises ``ValueError`` naming the
+    problem - silently dropping it would monitor a different sketch
+    than the agent wrote (a literal ``NotARealPredicate`` annotation
+    passed refinement untouched in run_20260830_145226). Tolerant mode
+    (re-parsing logged plans) skips such atoms with a once-per-process
+    warning.
     """
     pred_map = {p.name: p for p in predicates}
     obj_map = {o.name: o for o in objects}
     pos_atoms: Set[GroundAtom] = set()
     neg_atoms: Set[GroundAtom] = set()
+
+    def _bad(msg: str, hint: str) -> None:
+        if strict:
+            raise ValueError(f"{msg} in subgoal annotation - {hint}")
+        _warn_subgoal_once(f"{msg} in subgoal")
+
     for atom_match in _ATOM_RE.finditer(atoms_text):
         is_neg = atom_match.group(1) is not None
         pred_name = atom_match.group(2)
@@ -142,17 +181,21 @@ def parse_atoms(
             n.strip().split(':')[0] for n in atom_match.group(3).split(',')
         ]
         if pred_name not in pred_map:
-            logging.warning(f"Unknown predicate in subgoal: {pred_name}")
+            _bad(f"Unknown predicate {pred_name!r}",
+                 f"available predicates: {sorted(pred_map)}")
             continue
         pred = pred_map[pred_name]
-        try:
-            objs = [obj_map[n] for n in obj_names]
-        except KeyError as e:
-            logging.warning(f"Unknown object in subgoal: {e}")
+        missing = [n for n in obj_names if n not in obj_map]
+        if missing:
+            _bad(f"Unknown object(s) {missing} for {pred_name}",
+                 f"available objects: {sorted(obj_map)}")
             continue
+        objs = [obj_map[n] for n in obj_names]
         if len(objs) != len(pred.types):
-            logging.warning(f"Arity mismatch for {pred_name}: expected "
-                            f"{len(pred.types)}, got {len(objs)}")
+            _bad(
+                f"Arity mismatch for {pred_name}: expected "
+                f"{len(pred.types)}, got {len(objs)}",
+                "give one argument per predicate type")
             continue
         (neg_atoms if is_neg else pos_atoms).add(GroundAtom(pred, objs))
     return pos_atoms, neg_atoms
@@ -163,12 +206,14 @@ def parse_subgoal_annotations(
     predicates: Set[Predicate],
     objects: Sequence[Object],
     option_names: Set[str],
+    strict: bool = False,
 ) -> List[Optional[Tuple[Set[GroundAtom], Set[GroundAtom]]]]:
     """Parse ``-> {Pred(...), NOT Pred(...)}`` annotations from plan text.
 
     Returns a list parallel to the option lines in ``text``. Each entry
     is ``None`` for a line with no annotation, or ``(positive_atoms,
-    negative_atoms)`` otherwise.
+    negative_atoms)`` otherwise. ``strict`` makes a malformed atom raise
+    instead of being skipped (see ``parse_atoms``).
     """
     subgoal_re = re.compile(r'->\s*\{([^}]*)\}')
     results: List[Optional[Tuple[Set[GroundAtom], Set[GroundAtom]]]] = []
@@ -190,8 +235,10 @@ def parse_subgoal_annotations(
             results.append(None)
             continue
 
-        pos_atoms, neg_atoms = parse_atoms(sg_match.group(1), predicates,
-                                           objects)
+        pos_atoms, neg_atoms = parse_atoms(sg_match.group(1),
+                                           predicates,
+                                           objects,
+                                           strict=strict)
         if pos_atoms or neg_atoms:
             results.append((pos_atoms, neg_atoms))
         else:
@@ -356,6 +403,9 @@ def parse_sketch_from_text(
     default freeform tolerance (skip preamble, drop malformed lines,
     truncate at the first non-option line). Without it, a dropped line
     also silently misaligns the per-line subgoal annotations below.
+    Strict mode also validates every subgoal atom: an unknown predicate
+    or object, or a wrong arity, raises instead of being silently
+    dropped from the monitored sketch (see ``parse_atoms``).
 
     When ``parse_continuous_params`` is set, each step's ``[p0, p1, ...]``
     block is parsed by the SAME canonical parser the open-loop planner
@@ -399,8 +449,11 @@ def parse_sketch_from_text(
     if not parsed:
         return []
 
-    subgoals = parse_subgoal_annotations(cleaned_text, predicates, objects,
-                                         option_names)
+    subgoals = parse_subgoal_annotations(cleaned_text,
+                                         predicates,
+                                         objects,
+                                         option_names,
+                                         strict=strict)
     regions = (parse_region_annotations(cleaned_text, option_names)
                if parse_continuous_params else [])
 
diff --git a/predicators/agent_sdk/sketch_prompts.py b/predicators/agent_sdk/sketch_prompts.py
index b4eaa49aa..8523599dc 100644
--- a/predicators/agent_sdk/sketch_prompts.py
+++ b/predicators/agent_sdk/sketch_prompts.py
@@ -1,15 +1,154 @@
-"""Prompt construction for bilevel plan-sketch solving/exploration.
-
-Split out of ``bilevel_sketch`` (see that module's docstring for the
-full layout); holds ``build_solve_prompt``, the solve/explore prompt
-asking the agent for a plan sketch in the grammar that
-``sketch_parsing`` reads back.
+"""Prompt construction for the solve and explore phases.
+
+Two builders, both rendered from the Markdown templates in
+``predicators/agent_sdk/prompts`` (see :mod:`prompt_templates`):
+
+- :func:`build_solve_system_prompt` composes ``solve_system.md``: the
+  agent's identity, its deliverable contract, the plan grammar, the
+  tool semantics, the working principles, the run-record protocol,
+  and (explore phase) the exploration setting. Everything that holds
+  for every episode of a phase lives here.
+- :func:`build_solve_prompt` composes ``solve_query.md``: the task
+  (goal, scene, vocabulary), the run state (records, scheduled plans,
+  open questions), and this episode's instructions.
+
+The query never restates a rule from the system prompt; the split is
+what keeps each rule stated exactly once.
 """
+import re
 from typing import Optional, Sequence, Set
 
 from predicators import utils
+from predicators.agent_sdk.prompt_templates import render
 from predicators.settings import CFG
-from predicators.structs import ParameterizedOption, Predicate, Task
+from predicators.structs import LowLevelTrajectory, ParameterizedOption, \
+    Predicate, Task
+
+_BLANK_RUN_RE = re.compile(r"\n{3,}")
+
+
+def _join(parts: Sequence[str]) -> str:
+    """Join non-empty prompt parts with blank lines, squeezing runs of blank
+    lines that empty optional sections leave behind."""
+    text = "\n\n".join(p for p in parts if p)
+    return _BLANK_RUN_RE.sub("\n\n", text).strip("\n") + "\n"
+
+
+def build_early_stop_note() -> str:
+    """The exploration setting's early-stop sentence, from ``CFG``.
+
+    Empty when early stopping is off. Describes the rule the run uses
+    (train-driven: every attempt must be certified and solve for real;
+    test-driven: consecutive perfect test phases).
+    """
+    if not CFG.online_learning_early_stopping:
+        return ""
+    if CFG.online_learning_early_stopping_by_test_solve_rate:
+        n_perfect = CFG.online_learning_early_stopping_consecutive_perfect_tests
+        phases = ("the next test phase solves" if n_perfect <= 1 else
+                  f"{n_perfect} consecutive test phases each solve")
+        return render("solve_system", "early_stop_test", phases=phases)
+    attempts_clause = ("every episode of a cycle" if
+                       CFG.online_learning_early_stopping_require_all_attempts
+                       else "each train task's first episode of a cycle")
+    return render("solve_system",
+                  "early_stop_train",
+                  attempts_clause=attempts_clause)
+
+
+def build_solve_system_prompt(
+    *,
+    explore: bool,
+    policy_mode: bool = False,
+    propose_params: bool = True,
+    ground_samplers: bool = False,
+    physics_margin: bool = False,
+    rule_param_margin: bool = False,
+    use_journal: bool = True,
+    execute_certified_plan: bool = True,
+    early_stop_note: str = "",
+    policy_max_options: int = 0,
+    policy_max_repeated_failures: int = 0,
+    policy_max_repeated_noops: int = 0,
+) -> str:
+    """Compose the solve-phase or explore-phase system prompt.
+
+    ``explore`` selects the exploration identity, deliverable, and
+    setting (``early_stop_note`` and ``execute_certified_plan`` only
+    matter there); otherwise ``policy_mode`` selects the closed-loop
+    policy deliverable over the captured plan. ``propose_params`` and
+    ``ground_samplers`` shape the grammar; ``physics_margin`` and
+    ``rule_param_margin`` describe the capture gate's extra checks;
+    ``use_journal`` includes the run-record protocol.
+    """
+    assert not (explore and policy_mode), (
+        "exploration delivers a plan sketch even in policy-mode runs")
+    identity = render("solve_system",
+                      "identity_explore" if explore else "identity_solve")
+    if explore:
+        certified_note = ""
+        if execute_certified_plan:
+            certified_note = " " + render("solve_system", "certified_note")
+        deliverable = render("solve_system",
+                             "deliverable_explore",
+                             certified_note=certified_note)
+    elif policy_mode:
+        deliverable = render(
+            "solve_system",
+            "deliverable_policy",
+            max_options=str(policy_max_options),
+            max_repeated_failures=str(policy_max_repeated_failures),
+            max_repeated_noops=str(policy_max_repeated_noops))
+    else:
+        deliverable = render("solve_system", "deliverable_plan")
+
+    params_rule = render(
+        "solve_system",
+        "params_rule_propose" if propose_params else "params_rule_search")
+    ground_sampler_rule = ""
+    if propose_params and ground_samplers:
+        ground_sampler_rule = "\n" + render("solve_system",
+                                            "ground_sampler_rule")
+    grammar = render("solve_system",
+                     "grammar",
+                     param_slot="[p1, p2]" if propose_params else "",
+                     wait_slot="[]" if propose_params else "",
+                     params_rule=params_rule,
+                     ground_sampler_rule=ground_sampler_rule)
+
+    validation_gate = ""
+    if physics_margin:
+        validation_gate += " " + render("solve_system",
+                                        "validation_gate_physics")
+    if rule_param_margin:
+        validation_gate += " " + render("solve_system",
+                                        "validation_gate_rule_params")
+    tools = render("solve_system", "tools", validation_gate=validation_gate)
+
+    principles = render("solve_system", "principles")
+    if not explore:
+        principles += "\n" + render("solve_system", "banking")
+
+    run_records = ""
+    if use_journal:
+        journal_protocol = ""
+        if not explore:
+            journal_protocol = "\n\n" + render("solve_system",
+                                               "journal_protocol_solve")
+        run_records = render("solve_system",
+                             "run_records",
+                             journal_protocol=journal_protocol)
+
+    setting = ""
+    if explore:
+        note = (" " + early_stop_note.strip()) if early_stop_note else ""
+        setting = render("solve_system",
+                         "exploration_setting",
+                         early_stop_note=note)
+
+    return _join([
+        identity, deliverable, grammar, tools, principles, run_records, setting
+    ])
 
 
 def build_solve_prompt(
@@ -25,742 +164,211 @@ def build_solve_prompt(
     propose_params: bool = False,
     require_tool_validation: bool = False,
     explore_mode: bool = False,
-    ground_samplers: bool = False,
     journal: str = "",
     strategy: str = "",
     attempts: str = "",
-    physics_margin: bool = False,
-    policy_mode: bool = False,
 ) -> str:
-    """Build the bilevel solve/explore prompt asking for a plan sketch.
-
-    ``ground_samplers`` is the caller-threaded value of
-    ``RefinementConfig.ground_samplers``; when False the prompt never
-    mentions the ``~`` annotation channel.
-
-    Mirrors ``AgentModelBasedApproach._build_solve_prompt`` but takes
-    dependencies explicitly so explorers can reuse it.
-
-    ``scheduled_plans`` lists sketch-line descriptions of exploration
-    plans already generated this online-learning cycle (all of a cycle's
-    requests are generated before any executes). When given, the prompt
-    asks for a plan that still achieves the goal but differs meaningfully,
-    so the cycle's interaction data is complementary instead of the same
-    plan repeated per request.
-
-    ``propose_params`` switches the prompt from "param-free sketch, search
-    finds all continuous params" to "propose your best continuous params in
-    ``[...]`` per step; the search refines them and samples on failure".
-
-    ``require_tool_validation`` tells the agent it MUST submit a
-    goal-reaching ``submit_plan`` run on the current task (the
-    captured, validated plan is the only output) - used when the approach
-    has no refinement fallback. When False, validation is merely
-    encouraged.
-
-    ``explore_mode`` marks the query as an exploration request whose
-    sketch will run in the REAL environment as an experiment. It adds a
-    belief-model disclosure (the simulator is base physics plus dynamics
-    learned so far, so an unlearned mechanism shows zero effect) and an
-    explicit delivery contract: a simulator-failing sketch is a valid
-    deliverable when the goal depends on a mechanism the belief model
-    lacks. Without it, agents have burned entire sessions exhaustively
-    proving such a mechanism's absence instead of submitting the
-    experiment that would let it be learned.
-
-    ``journal`` is the agent's own notebook (``journal.md``) and
-    ``attempts`` the harness's attempt log (``attempts.md``); see
-    ``predicators/agent_sdk/journal.py``. Both are injected so
-    fresh-context sessions inherit what worked (and what was already
-    swept) without inheriting failed attempts' conclusions.
-
-    ``strategy`` is the learn-phase-maintained domain strategy document
-    (``strategy.md``): the learn agent's best current natural-language
-    account of how to solve tasks in this domain, rewritten freely
-    across learning cycles. Injected as explicitly-advisory reference -
-    the knowledge can be wrong, so the prompt tells the solver to
-    re-verify rather than inherit.
-
-    ``policy_mode`` (``CFG.agent_solve_policy_mode``): the deliverable
-    becomes a closed-loop ./policy.py validated via ``submit_policy``
-    instead of a fixed submit_plan capture; the submit and
-    closing guidance swap to the policy contract.
-
-    ``physics_margin`` is the caller-threaded value of
-    ``CFG.agent_plan_validation_physics_margin``: when True (and
-    ``require_tool_validation``), the submit guidance tells the agent
-    the capture gate also sweeps the identified physical parameters'
-    uncertainty range, and to pre-check designs with
-    ``sim.run(..., physics_sweep=True)`` instead of discovering
-    PARAM-SENSITIVE rejections one submission at a time.
+    """Compose the solve or explore query for ``task``.
+
+    ``propose_params`` labels each option's parameter box as proposed by
+    the agent (otherwise as found by the search) and picks the stuck-
+    step advice. ``require_tool_validation`` selects the capture-gate
+    instructions; ``explore_mode`` the experiment instructions (the two
+    are exclusive). ``scheduled_plans`` lists the plans this cycle
+    already queued, so the agent is asked for a complementary one.
+    ``journal``, ``attempts``, and ``strategy`` are the run records'
+    contents (``journal.py``); the protocol for using them is in the
+    system prompt.
     """
     assert not (explore_mode and require_tool_validation), (
         "explore_mode accepts an uncaptured experiment sketch, which "
         "contradicts the hard capture gate of require_tool_validation")
-    assert not policy_mode or require_tool_validation, (
-        "policy_mode is a hard capture gate (submit_policy), so it "
-        "requires require_tool_validation")
 
     init_state = task.init
-    objects = list(init_state)
-
-    obj_strs = []
-    for obj in sorted(objects, key=lambda o: o.name):
-        obj_strs.append(f"  {obj.name}: {obj.type.name}")
+    objects = sorted(init_state, key=lambda o: o.name)
+    obj_lines = [f"  {obj.name}: {obj.type.name}" for obj in objects]
 
     # Only expose goal atoms whose predicate is in the agent's current
-    # predicate set. Approaches that strip env predicates (e.g.
-    # agent_sim_predicate_invention) rely on goal_nl to communicate the
-    # goal; leaking unfiltered task.goal atoms would expose predicates the
-    # agent is supposed to invent for itself.
-    goal_strs = [
+    # predicate set: approaches that strip env predicates rely on
+    # goal_nl and must not leak atoms of predicates the agent invents.
+    goal_atoms = [
         str(a) for a in sorted(task.goal, key=str)
         if a.predicate in all_predicates
     ]
 
-    option_strs = []
+    option_lines = []
     for opt in sorted(all_options, key=lambda o: o.name):
         type_sig = ", ".join(t.name for t in opt.types)
         params_dim = opt.params_space.shape[0]
+        param_info = ""
         if params_dim > 0:
             low = opt.params_space.low.tolist()
             high = opt.params_space.high.tolist()
             label = "params" if propose_params else "auto-searched params"
-            if opt.params_description:
-                desc = ", ".join(opt.params_description)
-                param_info = (f"  [{label}: {desc}, "
-                              f"range {low} to {high}]")
-            else:
-                kind = f"{params_dim}d"
-                param_info = (f"  [{label}: {kind}, "
-                              f"range {low} to {high}]")
-        else:
-            param_info = ""
-        option_strs.append(f"  {opt.name}({type_sig}){param_info}")
+            desc = (", ".join(opt.params_description)
+                    if opt.params_description else f"{params_dim}d")
+            param_info = f"  [{label}: {desc}, range {low} to {high}]"
+        option_lines.append(f"  {opt.name}({type_sig}){param_info}")
 
     atoms = utils.abstract(init_state, all_predicates)
-    atom_strs = [str(a) for a in sorted(atoms, key=str)]
+    atom_lines = [str(a) for a in sorted(atoms, key=str)]
 
-    state_str = init_state.dict_str(indent=2)
+    pred_lines = []
+    any_latent = False
+    for pred in sorted(all_predicates, key=lambda p: p.name):
+        type_sig = ", ".join(t.name for t in pred.types)
+        line = f"  {pred.name}({type_sig})"
+        if pred.accepts_latent:
+            line += " [reads belief latent]"
+            any_latent = True
+        if pred.natural_language_assertion is not None:
+            names = [t.name for t in pred.types]
+            line += f": {pred.natural_language_assertion(names)}"
+        pred_lines.append(line)
+    if any_latent:
+        pred_lines.append(
+            "  ([reads belief latent]: its truth can depend on belief-only "
+            "state that real observations never carry, so an annotation "
+            "using it may be dropped from closed-loop monitoring at "
+            "capture as execution-unverifiable - prefer predicates over "
+            "observable features for monitored subgoals.)")
 
-    tools_str = ""
-    if tool_names:
-        tool_list = "\n".join(f"  - {t}" for t in tool_names)
-        tools_str = f"\n## Available Tools\n{tool_list}\n"
+    goal_nl_section = ""
+    if task.goal_nl:
+        goal_nl_section = render("solve_query",
+                                 "goal_nl",
+                                 goal_nl=task.goal_nl)
+
+    # The env's public reward form (success condition plus costs) when
+    # the task ships an evaluator that states one; never oracle values.
+    scoring_section = ""
+    evaluator = getattr(task, "evaluator", None)
+    if evaluator is not None and evaluator.objective_description():
+        scoring_section = render("solve_query",
+                                 "scoring",
+                                 objective=evaluator.objective_description())
+
+    goal_atoms_section = ""
+    if goal_atoms:
+        goal_atoms_section = render("solve_query",
+                                    "goal_atoms",
+                                    goal_atoms="\n".join(goal_atoms))
 
     experiment_section = ""
     if experiment_guidance:
-        experiment_section = (f"\n## Experiment Guidance\n"
-                              f"{experiment_guidance}\n")
-
-    # Everything explore-specific lives in this ONE section: loop
-    # context, belief-model semantics, and experiment-design principles.
-    # The deliverable contract stays in closing_block; the system prompt
-    # never repeats any of it.
-    setting_section = ""
-    if explore_mode:
-        early_stop_note = ""
-        if (CFG.online_learning_early_stopping
-                and not CFG.online_learning_early_stopping_by_test_solve_rate):
-            attempts_clause = (
-                "every episode of a cycle"
-                if CFG.online_learning_early_stopping_require_all_attempts else
-                "each train task's first episode of a cycle")
-            early_stop_note = (
-                " The loop concludes early once the exploration plans "
-                f"solve training: {attempts_clause} must reach the goal "
-                "for real, AND the plan must have validated in the belief "
-                "model - a lucky real success from a plan the model could "
-                "not certify does not count. Once the belief model can "
-                "validate a goal-reaching plan, submitting it (even "
-                "unchanged) is how the loop concludes." +
-                (" A plan that passes submit_plan's validation "
-                 "gate (goal reached in every fresh belief rollout) is "
-                 "executed VERBATIM as this episode's solve attempt and "
-                 "replayed for the cycle's remaining episodes; only an "
-                 "unvalidated sketch is treated as an experiment."
-                 if CFG.agent_explorer_replay_certified_plan else ""))
-        elif CFG.online_learning_early_stopping_by_test_solve_rate:
-            n_perfect = (
-                CFG.online_learning_early_stopping_consecutive_perfect_tests)
-            phases = ("the next test phase solves" if n_perfect <= 1 else
-                      f"{n_perfect} consecutive test phases each solve")
-            early_stop_note = (
-                f" The loop concludes early once {phases} every test "
-                "task. Test attempts plan with the belief model, so what "
-                "ends the loop is the belief model becoming reliably "
-                "correct - your episodes count toward that only through "
-                "the model corrections their data enables, not through "
-                "reaching the goal themselves.")
-        setting_section = (
-            "\n## Exploration Setting\n"
-            "You are the explorer in an online learning loop: the plan "
-            "you submit runs in the REAL environment as an experiment, "
-            "and its episode data is what the next learning phase uses "
-            "to correct the belief model." + early_stop_note + "\n\n"
-            "The simulator behind your tools is that belief model: known "
-            "base physics plus whatever additional dynamics have been "
-            "learned from real interaction data so far. A mechanism that "
-            "has not been learned yet is simply ABSENT from it - the "
-            "simulator shows zero effect no matter how you arrange the "
-            "probe, and early in learning this can include the very "
-            "mechanism the goal depends on. Treat a null effect after a "
-            "few well-aimed probes as \"not in the belief model yet\", "
-            "not as evidence about the real environment, and do not "
-            "spend the session exhaustively confirming the absence.\n\n"
-            "Design the experiment accordingly. A goal-reaching, "
-            "simulator-validated plan is ideal when the model supports "
-            "one; when the goal depends on a mechanism the model lacks, "
-            "submit the plan most likely to achieve the goal in reality "
-            "- reason from the goal description, the scene geometry, and "
-            "physical common sense - and annotate the subgoals that "
-            "SHOULD hold if the mechanism works: the disagreement "
-            "between prediction and reality is exactly the signal "
-            "exploration exists to collect, so a simulator-failing "
-            "sketch is a valid deliverable, and grinding for a validated "
-            "plan the model cannot produce is wasted budget. An "
-            "experiment's information comes from the steps the belief "
-            "model cannot predict. Your sketch runs in the real "
-            "environment EXACTLY as written: every explicit parameter "
-            "executes verbatim, nothing is searched or substituted, and "
-            "a step you leave without parameters gets one uniform draw "
-            "from the option's box - so propose explicit parameters for "
-            "every step. Validate in the belief model yourself where it "
-            "supports the plan (`sim.run`, `sim.refine`, then "
-            "`submit_plan` to submit), and follow each "
-            "uncertified step with a step whose outcome reveals whether "
-            "the mechanism worked - a short plan that exercises the "
-            "unknown beats a long one that spends the episode's steps "
-            "on what the model already predicts.\n\n"
-            "What a cycle's data must contain. Across a cycle's "
-            "episodes the real environment must see (a) at least one "
-            "attempt at the FULL goal - every goal atom, executed to "
-            "the end, with the parameters you believe most likely to "
-            "work in reality even where the belief model predicts "
-            "failure - and (b) the top-ranked open question's "
-            "experiment executed as it is specified (its option "
-            "sequence and parameters), not a variation of your own. "
-            "One episode usually carries both, because when the open "
-            "question is a mechanism the goal requires, the goal "
-            "attempt IS its experiment; when the budget forces a "
-            "choice, the cycle's first episode attempts the goal and a "
-            "later one runs the ledger's top experiment - the "
-            "scheduled-plans section below tells you what this cycle "
-            "already covers.\n\n"
-            "Experiment design - one episode, many measurements. Before "
-            "sketching, list the mechanisms the goal depends on and "
-            "mark each KNOWN (the belief model has predicted it "
-            "correctly against real data) or OPEN (never observed, "
-            "unverified, or flagged in the guidance below). Design the "
-            "episode to settle as many OPEN items as its step budget "
-            "allows, not one per episode: probes of independent "
-            "mechanisms can share an episode when they touch disjoint "
-            "objects and neither depends on the other's outcome. When "
-            "an open item is a threshold or window (how close, how "
-            "long, how aligned), stage a LADDER: several independent "
-            "instances at staggered values bracketing the believed "
-            "boundary - e.g. object pairs at several spacings - so one "
-            "episode measures the boundary from both sides instead of "
-            "contributing a single incidental sample; every threshold "
-            "pinned this way is a cycle of drift-by-refit avoided "
-            "later. When combining probes, annotate the subgoals of "
-            "steps whose mechanism the belief model already CONTAINS "
-            "(annotations there let `sim.suggest_probes` rank probes and "
-            "let the execution monitor catch divergence, and cost "
-            "nothing). For a mechanism the model entirely LACKS, "
-            "annotate what SHOULD happen: the annotation documents the "
-            "disagreement to measure, and your explicit parameters keep "
-            "the later probes exactly as designed. "
-            "Spend no steps re-demonstrating what the model already "
-            "predicts well beyond what later probes need as setup.\n\n"
-            "When the belief model has learned no dynamics at all yet "
-            "(the first cycle of a fresh run), coverage beats depth: "
-            "design the episode to exercise every option and to create "
-            "every object interaction the goal description names "
-            "(contact, attachment, activation, stacking - whatever the "
-            "domain's language suggests), so the first learning phase "
-            "sees each mechanism at least once, instead of spending the "
-            "episode polishing a single goal attempt whose failure "
-            "reveals only its first missing mechanism. Carry each "
-            "interaction to its CONSEQUENCE, not just its setup: bring "
-            "the prepared surfaces into actual contact, release, wait "
-            "long enough for a delayed effect, then probe the result "
-            "(lift, push, or move one body and watch whether the other "
-            "follows). An interaction the episode stages but never "
-            "consummates - glue applied to a face that touches nothing, "
-            "parts placed near but not against each other - leaves the "
-            "learner with no event to model, and the cycle is spent.\n\n"
-            "Ledger upkeep is part of the deliverable. Append "
-            "measurements to ./journal.md as you go (a short entry per "
-            "experiment - lead with the numbers), and when a result "
-            "settles an open question or opens a new one, edit "
-            "open_questions.md directly with the file tools - the next "
-            "learning phase designs its work from that file, and a "
-            "result that only lives in a truncated journal entry is a "
-            "result lost. Do NOT edit strategy.md: it is the learning "
-            "phase's curated document, and one exploration episode's "
-            "evidence does not overturn it - when your measurements "
-            "contradict a recipe, record the contradiction as an open "
-            "question instead.\n")
-
-    scheduled_plans_section = ""
-    if scheduled_plans:
-        plan_blocks = "\n".join(f"Plan {i + 1}:\n{p}"
-                                for i, p in enumerate(scheduled_plans))
-        scheduled_plans_section = (
-            "\n## Plans Already Scheduled This Cycle\n"
-            "The plan(s) below are already queued to run on this same task "
-            "before any learning happens, so their interaction data will be "
-            "collected regardless of what you propose now.\n"
-            f"{plan_blocks}\n"
-            "\nPropose a plan whose DATA is complementary rather than "
-            "redundant: cover open questions, mechanisms, or parameter "
-            "regions the plan(s) above leave unmeasured. A goal-reaching "
-            "plan is still preferred when it can carry that coverage; "
-            "when it cannot, a designed experiment that settles what the "
-            "scheduled plans will not is the better use of this episode. "
-            "Only if the model is believed correct everywhere and no "
-            "meaningfully different goal-reaching plan exists, repeat "
-            "the best plan.\n")
+        experiment_section = render("solve_query",
+                                    "experiment_guidance",
+                                    guidance=experiment_guidance)
+
+    tools_section = ""
+    if tool_names:
+        tools_section = render("solve_query",
+                               "tools",
+                               tool_list="\n".join(f"  - {t}"
+                                                   for t in tool_names))
 
     strategy_section = ""
     if strategy:
-        strategy_section = (
-            "\n## Domain Strategy (advisory, written during learning)\n"
-            "The learning phase maintains this strategy document - its "
-            "best current account of how to solve tasks in this domain "
-            "(approach, mechanisms, parameter formulas, pitfalls). Use "
-            "it as a reference and starting point, but you are NOT "
-            "limited to it: it can be wrong or stale, so re-verify its "
-            "load-bearing claims cheaply before building on them, and "
-            "depart from it whenever your own measurements disagree.\n\n"
-            f"{strategy}\n")
+        strategy_section = render("solve_query", "strategy", strategy=strategy)
 
     attempts_section = ""
     if attempts:
-        attempts_section = (
-            "\n## Attempt Log (recorded by the harness)\n"
-            "Outcomes of earlier solve attempts and tasks in this run, "
-            "recorded automatically in ./attempts.md (do not edit it): "
-            "each task's goal and initial state, and per attempt the "
-            "outcome, the budget spent, and the captured or best refused "
-            "plan. Facts, not advice.\n\n"
-            f"{attempts}\n")
+        attempts_section = render("solve_query", "attempts", attempts=attempts)
+
     journal_section = ""
     if journal or attempts:
-        journal_section = (
-            "\n## Solve Journal (./journal.md)\n"
-            "You start with fresh context. The journal is this run's "
-            "persistent notebook, written by earlier solve and learning "
-            "sessions with the file tools; with the attempt log it is "
-            "the record of what was tried. Use it - reproduce what "
-            "worked, do not repeat parameter sweeps it already covers - "
-            "but treat any recorded conclusion skeptically: re-verify "
-            "cheap claims rather than inheriting them, especially from "
-            "failed attempts.\n"
-            "Journal protocol for this attempt:\n"
-            "- A design the attempt log records as having reached the "
-            "goal in the REAL environment is the INCUMBENT: reproduce it "
-            "unless the record also shows it failing since, or a model "
-            "update invalidates one of its steps. Every deviation from "
-            "an execution-validated design - reordering steps, dropping "
-            "a Wait, retargeting a parameter - is a NEW experiment "
-            "carrying first-execution risk that belief validation does "
-            "NOT retire (real option durations and placement scatter "
-            "differ), so deviate only for a recorded reason and record "
-            "that reason.\n"
-            "- FIRST list the journal's untried leads, then execute or "
-            "explicitly retire (with a measurement) each promising lead "
-            "BEFORE re-opening a family an earlier attempt already marked "
-            "exhausted or opening a brand-new one. Attempts have been "
-            "wasted re-litigating condemned designs while a recorded, "
-            "concrete, untried lead sat unexecuted.\n"
-            "- A negative claim is only as broad as the family actually "
-            "swept: before trusting 'X never works', check what was "
-            "tested - a claim derived from one orientation, formula, or "
-            "region says nothing about the rest.\n"
-            "- If two entries conflict (one rules a mechanism out, another "
-            "recommends it), BOTH demote to open questions: design the "
-            "cheap experiment that decides between them instead of "
-            "silently trusting either.\n"
-            "Add your own lessons for future attempts by appending a "
-            "short entry to ./journal.md with the file tools: a `### ` "
-            "header naming the task and attempt, then a few bullets of "
-            "facts and measurements only - exact parameters, what was "
-            "measured, what to try differently; no verdicts like "
-            "'impossible'.\n\n"
-            f"{journal or '(no journal entries yet)'}\n")
-
-    goal_nl_section = ""
-    if task.goal_nl:
-        goal_nl_section = f"\n## Goal Description\n{task.goal_nl}\n"
-
-    # The env's public reward form (success condition + costs), when the
-    # task ships an evaluator that states one. Without it, agents burn
-    # turns reverse-engineering scores and induce false rules from them
-    # (run_20260729_001752 hypothesized a "-0.10 binary route-rejected
-    # flag" and a "-0.30 excess-blue penalty" from raw numbers the
-    # formula decodes instantly). Public by design: reward FORM only,
-    # never oracle quantities.
-    scoring_section = ""
-    evaluator = getattr(task, "evaluator", None)
-    if evaluator is not None:
-        objective = evaluator.objective_description()
-        if objective:
-            scoring_section = (
-                "\n## Scoring (env ground-truth reward)\n"
-                f"{objective}\n"
-                "Decode every reward you observe with this scoring rule "
-                "before hypothesizing any other mechanism - there are no "
-                "hidden reward terms.\n")
+        journal_section = render("solve_query",
+                                 "journal",
+                                 journal=journal
+                                 or render("solve_query", "no_journal"))
 
-    goal_atoms_section = ""
-    if goal_strs:
-        goal_atoms_section = (f"\n## Goal Atoms\n{chr(10).join(goal_strs)}\n")
-
-    pred_strs = []
-    for pred in sorted(all_predicates, key=lambda p: p.name):
-        type_sig = ", ".join(t.name for t in pred.types)
-        line = f"  {pred.name}({type_sig})"
-        if pred.natural_language_assertion is not None:
-            names = [t.name for t in pred.types]
-            line += f" — {pred.natural_language_assertion(names)}"
-        pred_strs.append(line)
-
-    # Tool-availability-aware references: guidance must not name a
-    # capability the session lacks (a simulator-free session has no
-    # probe). ``tool_names=None`` means the full surface.
-    tool_set = set(tool_names) if tool_names is not None else None
-
-    def _has_tool(name: str) -> bool:
-        return tool_set is None or name in tool_set
-
-    refine_ref = "`sim.refine` (in `run_python`)"
-    if _has_tool("run_python"):
-        visualize_advice = (
-            "- Use `run_python` (`sim.reset(mods={...})`, then "
-            "`sim.render(...)`) to move objects to candidate positions and "
-            "orientations for free (no physics) and find the right region "
-            "visually before testing.\n")
-    else:
-        # No visualization surface offered: no bullet, rather than
-        # advice naming a capability the session lacks.
-        visualize_advice = ""
-
-    # Advice for a step the search reports stuck (SAMPLE_EXHAUSTED). When the
-    # agent proposes params it tunes that step's values; otherwise it can only
-    # change the skeleton.
-    deep_tune_advice = (
-        "deep-tune just that step (it needs precise values from you), then "
-        "re-test it. When deep-tuning a step with `submit_plan`:\n"
-        "- Inspect the rendered images in `./test_images/` to see what "
-        "actually happened.\n"
-        "- For a failure like an IK error or collision, use the image and "
-        "object poses to reason about WHY and adjust params directionally — "
-        "don't try random nearby values.\n" + visualize_advice +
-        "- Vary ALL parameters, not just position — orientation and others "
-        "affect both the outcome and whether the action succeeds.\n"
-        "- Search coarse-to-fine: spread attempts across the full range; if "
-        "several nearby values fail the same way, jump to a different region "
-        "instead of continuing to tweak.\n"
-        "- Before steering a search with a DERIVED formula or geometric "
-        "prediction (e.g. which way an object moves, falls, or deflects), "
-        "validate the formula on one clean controlled experiment first. A "
-        "wrong formula makes correct designs look refuted, and that false "
-        "negative then silently excludes the right design family from the "
-        "rest of the search.")
-    revise_sketch_advice = (
-        "revise the sketch — try different objects, a different ordering, an "
-        "added intermediate step, or a corrected subgoal annotation — then "
-        "re-test.")
-
-    if propose_params:
-        ground_sampler_guidance = ""
-        ground_sampler_format = ""
-        if ground_samplers:
-            ground_sampler_guidance = (
-                " Confine its search near your estimate by appending a "
-                "region `~ [w1, w2]` (per-parameter half-widths) after a "
-                "step's `[params]`: the exact center is tried first, then "
-                "every sample for that step stays inside "
-                "`[center - w, center + w]` instead of the full range. For "
-                "regions a fixed window cannot express (state-dependent or "
-                "curved), write a function in `ground_samplers.py` "
-                "(`GROUND_SAMPLERS = {\"my_sampler\": fn}`, "
-                "`fn(state, subgoal_atoms, rng, objects) -> params`) and "
-                "reference it as `~ my_sampler` instead; the file is "
-                f"reloaded on every {refine_ref} call.")
-            ground_sampler_format = (
-                f"\n(For {refine_ref} only, a step may add a search "
-                "region after its params: "
-                "`OptionName(obj1:type1)[p1, p2] ~ [w1, w2] -> {...}`, or "
-                "`... ~ my_sampler` naming a GROUND_SAMPLERS entry.)")
-        sketch_kind_guidance = (
-            "Generate a plan — the sequence of options with object arguments "
-            "and continuous parameters in `[...]` per step (see each option's "
-            "params and range above; use `[]` for options with no "
-            "parameters).\n\n"
-            "Explore designs before tuning parameters: when several "
-            "qualitatively different designs could work (different objects, "
-            "orientations, sides, orderings, or mechanisms), run a cheap "
-            "test of each and compare failure modes BEFORE fine-tuning any "
-            "one of them. Parameter tuning cannot rescue the wrong design - "
-            "if a design keeps failing the same way as you tune it, switch "
-            "designs rather than tightening values. And before building on "
-            "a physics rule or constraint you inferred from a single "
-            "observation, re-test it once with a clean experiment; a wrong "
-            "rule adopted early can quietly rule out the correct designs.\n\n"
-            "Spend effort on parameters in proportion to difficulty:\n"
-            "- Where a WIDE range of values works, any reasonable value is "
-            "fine — don't over-tune these.\n"
-            "- Where good values are hard to hit — tight tolerances or exact "
-            "relative placements (e.g. positioning one object at a precise "
-            f"offset from another) - use {refine_ref} to search for a "
-            "working value (it's slower) and read the value it found." +
-            ground_sampler_guidance)
-        format_block = (
-            "Output the plan with one option per line in this format:\n"
-            "  OptionName(obj1:type1, obj2:type2)[param1, param2] -> "
-            "{Pred(obj1:type1), Pred2(obj1:type1, obj2:type2)}\n"
-            "  Wait(robot:robot)[] -> "
-            "{Pred3(obj1:type1), NOT Pred4(obj1:type1, obj2:type2)}" +
-            ground_sampler_format)
-    else:
-        sketch_kind_guidance = (
-            "Generate a plan sketch — the sequence of options with object "
-            "arguments, WITHOUT continuous parameters; a backtracking search "
-            "finds them for you.")
-        format_block = (
-            "Output the plan sketch with one option per line in this "
-            "format:\n"
-            "  OptionName(obj1:type1, obj2:type2) -> "
-            "{Pred(obj1:type1), Pred2(obj1:type1, obj2:type2)}\n"
-            "  Wait(robot:robot) -> "
-            "{Pred3(obj1:type1), NOT Pred4(obj1:type1, obj2:type2)}")
-
-    if require_tool_validation:
-        stuck_advice = (deep_tune_advice
-                        if propose_params else revise_sketch_advice)
-        margin_guidance = ""
-        if physics_margin:
-            margin_guidance = (
-                "Capture also requires the plan to succeed at a grid of "
-                "perturbations spanning +-1 sigma of the identified "
-                "physical parameters (the physics fit's own uncertainty); "
-                "a plan that fails any point is reported PARAM-SENSITIVE "
-                "instead of captured. Success can be NON-MONOTONIC in a "
-                "physical parameter - a design can pass just above and "
-                "just below a value and fail exactly at it - so tune "
-                "designs that pass the WHOLE range: pre-check with "
-                "`sim.run(plan_text, physics_sweep=True)` in run_python "
-                "(same points as the gate, one deterministic rollout each) "
-                "instead of discovering rejections one submission at a "
-                "time. ")
-        if CFG.agent_plan_validation_rule_param_margin:
-            margin_guidance += (
-                "Capture additionally re-runs the plan under the "
-                "calibrated posterior members of the LEARNED rule "
-                "parameters (the fit's honest uncertainty about the "
-                "thresholds and offsets it learned from data); failing "
-                "under any member is rejected PARAM-SENSITIVE. So design "
-                "MAX-MARGIN, not merely feasible: place every operating "
-                "point at the CENTER of its learned feasibility window "
-                "(aim an applicator at the target point itself, put a "
-                "placement mid-window, leave slack on every timing) - a "
-                "design that only works at the fitted point estimate of "
-                "an uncertain constant will fail either this gate or the "
-                "real environment, whose true constant sits somewhere in "
-                "that posterior. Before submitting, name your plan's "
-                "WEAKEST margin (the smallest distance from any step's "
-                "operating point to a learned threshold) and widen it if "
-                "it is smaller than the measured execution scatter. ")
-        submit_guidance = (
-            "SUBMIT via `submit_plan`: pass your full plan as text "
-            "(one option per line, `Option(obj:type)[params] -> {subgoals}`, "
-            "with EXACT params) and run it on the CURRENT task (omit "
-            "task_idx). When it reaches the goal, that plan is captured as "
-            "your answer, so do NOT finish until submit_plan "
-            "CONFIRMS the capture. A goal-reaching plan is re-run several "
-            "times before capture (simulation varies across runs; each "
-            "rollout reports the motion-planner seed it ran at); if it is "
-            "reported FLAKY, reproduce the failed rollout exactly (pass "
-            "its reported seed as rollout_seed to submit_plan, or "
-            "`sim.run(plan_text, seed=...)` in run_python) to see WHY, "
-            "then add margin to the fragile step and resubmit. For a plan "
-            "you suspect is marginal, request a stricter gate up front "
-            "with validation_rollouts=N (more repeats; never fewer than "
-            "configured) or measure reliability first with "
-            "`sim.run(plan_text, trials=N)`. " + margin_guidance +
-            "CAPTURE FIRST, OPTIMIZE SECOND: when the reward charges for "
-            "resources used (read the scoring section), a captured "
-            "modest-reward solve outscores an uncaptured optimal attempt "
-            "by the entire success bonus - so bank a ROBUST goal-reaching "
-            "design early, even an over-built one (extra margin, extra "
-            "resources), and only then spend remaining budget improving "
-            "it. This is safe: a newly VALIDATED capture replaces the "
-            "banked one, while a rejected submission (flaky, "
-            "param-sensitive, evaluator-rejected, or short of the goal) "
-            "never displaces it - but do not resubmit designs that are "
-            "not strictly better, since a validated worse plan would "
-            "replace the banked answer. Robust-but-wasteful designs live "
-            "AWAY from the feasibility boundary that minimal designs sit "
-            "on, so they are usually far easier to find and validate. "
-            "It runs your EXACT parameters with no sampling. To find "
-            f"working parameters you MAY use {refine_ref} (it searches "
-            "but is slower); read the parameters it reports and submit them "
-            "via submit_plan. If a step does not reach its subgoal, " +
-            stuck_advice)
-    elif propose_params:
-        submit_guidance = (
-            f"You may validate with {refine_ref} (it tries your "
-            "parameters first, then samples) and deep-tune any step it "
-            "reports stuck before finishing.")
-    else:
-        submit_guidance = (
-            f"You may vet a sketch with {refine_ref} before finishing; "
-            "the backtracking search will find continuous parameters.")
-    # Explore-specific delivery guidance lives in the Exploration
-    # Setting section above (single source); nothing to append here.
-
-    if policy_mode:
-        submit_guidance = (
-            "## Deliverable: Closed-Loop Policy (./policy.py)\n"
-            "Instead of a fixed plan, you deliver a PROGRAM that chooses "
-            "the next option from the current state. Write it to "
-            "./policy.py:\n\n"
-            "    def get_option(state, memory):\n"
-            "        ...\n\n"
-            "- `state`: the current State object (read-only copy). Same "
-            "API as run_python: `state.get(obj, 'feature')`, iterate "
-            "objects with `for obj in state`, `obj.name`, `obj.type`.\n"
-            "- `memory`: a dict, initially empty, persisting across calls "
-            "within ONE episode (phase flags, counters, cached "
-            "measurements); reset between episodes. After a failed "
-            "option, `memory['last_failure']` holds the failure text - "
-            "branch on it to RECOVER (re-place a drifted block, adjust a "
-            "target after a motion-planning refusal); it is None on clean "
-            "steps.\n"
-            "- Return ONE plan line as a string, in the exact sketch "
-            "grammar `OptionName(obj:type, ...)[p1, p2]` with exact "
-            "continuous parameters (`[]` for none; `->`/`~` annotations "
-            "are ignored here). Return None to declare the episode "
-            "finished.\n"
-            "- Helpers available inside policy.py: `np` (numpy) and "
-            "`atoms(state)` -> set of ground-atom strings.\n"
-            "- Execution semantics (identical in the belief simulator and "
-            "the real environment): get_option is called once per option "
-            "boundary with the ACTUAL current state; option failures do "
-            "NOT end the episode (they surface via memory['last_failure'] "
-            "and you are asked again); exceptions in get_option or "
-            "unparsable/ungroundable lines DO end it; a hard cap of "
-            f"{CFG.agent_policy_max_options} options bounds every "
-            "episode. After a failure, CHANGE something before retrying "
-            "(parameters, target object, or action) - re-issuing the "
-            "byte-identical line that just failed "
-            f"{CFG.agent_policy_max_repeated_failures} times in a row "
-            "ends the episode as a policy bug, because an unchanged "
-            "command fails the same way. The same applies to a no-op "
-            "livelock: re-issuing one identical line that keeps "
-            "COMPLETING with no observable state change "
-            f"{CFG.agent_policy_max_repeated_noops} times in a row also "
-            "ends the episode - if your stage logic is not advancing, "
-            "fix the stage test, do not re-send the same command.\n"
-            "SUBMIT via `submit_policy` on the CURRENT task until it "
-            "reaches the goal across all validation rollouts - the "
-            "validated policy.py snapshot (taken at call time; later "
-            "edits need a new call) is your ONLY accepted output. Test "
-            "recovery behavior first: in run_python, "
-            "`sim.run_policy()` runs ./policy.py from the CURRENT probe "
-            "state (including perturbed or mid-plan states), so check "
-            "that the policy recovers from off-nominal states, not just "
-            "the initial one. " + margin_guidance)
-        closing_block = (
-            "Your answer is ONLY accepted from a goal-reaching "
-            "`submit_policy` run on the CURRENT task; final text alone "
-            "is discarded, so never finish without that validated run. "
-            "After the goal-reaching run, summarize the policy's strategy "
-            "as your final text.")
-    if require_tool_validation and not policy_mode:
-        # Plain text is NOT a submission in this mode; saying "output the
-        # plan lines" as the closing instruction has led agents (especially
-        # right after an SDK context compaction, whose text-only summary
-        # instruction bleeds into the task) to answer with an unvalidated
-        # text sketch and finish, wasting the whole attempt.
-        closing_block = (
-            "Your answer is ONLY accepted from a goal-reaching "
-            "`submit_plan` run on the CURRENT task; final text "
-            "alone is discarded, so never finish without that validated "
-            "run. Tool calls are permitted on every turn of this "
-            "conversation. If an earlier context summary says a turn was "
-            "text-only, that applied to writing the summary itself, not to "
-            "this task; resume calling tools. After the goal-reaching run, "
-            "repeat its plan lines as your final text.")
-    elif explore_mode:
-        closing_block = (
-            "This is an EXPLORE query: your final plan-sketch text IS the "
-            "deliverable (a simulator-validated capture is welcome but NOT "
-            "required). Output ONLY the plan sketch lines at the end, "
-            "after any analysis.")
-    elif not policy_mode:
-        # (In policy mode the closing block was set above.)
-        closing_block = (
-            "Output ONLY the plan sketch lines at the end, after any "
-            "analysis.")
-
-    atoms_block = chr(10).join(atom_strs) if atom_strs else (
-        "  (none - no atom of the available predicates holds initially)")
+    scheduled_section = ""
+    if scheduled_plans:
+        plans = "\n".join(f"Plan {i + 1}:\n{p}"
+                          for i, p in enumerate(scheduled_plans))
+        certified_rule = ""
+        if any("belief-certified" in p for p in scheduled_plans):
+            certified_rule = "\n\n" + render("solve_query", "certified_rule")
+        scheduled_section = render("solve_query",
+                                   "scheduled_plans",
+                                   plans=plans,
+                                   certified_rule=certified_rule)
 
     if explore_mode:
-        opening = (
-            "You are exploring a task environment to gather information. "
-            "Generate a plan sketch to run in the real environment as an "
-            "experiment. Achieving the goal is the most informative "
-            "experiment available, so treat solving the task as part of "
-            "information gathering.")
+        instructions = render("solve_query", "instructions_explore")
+    elif require_tool_validation:
+        stuck = render("solve_query",
+                       "stuck_tune" if propose_params else "stuck_revise")
+        instructions = render("solve_query",
+                              "instructions_capture",
+                              stuck_advice=stuck)
     else:
-        opening = ("You are solving a task. Generate a plan sketch to "
-                   "achieve the goal.")
-
-    prompt = f"""{opening}
-{goal_nl_section}{scoring_section}{goal_atoms_section}{setting_section}\
-{experiment_section}
-## Initial State Atoms
-{atoms_block}
-
-## Initial State Features
-{state_str}
-{initial_image_section}
-## Objects
-{chr(10).join(obj_strs)}
-
-## Available Options
-{chr(10).join(option_strs)}
-
-## Available Predicates (for subgoal annotations)
-{chr(10).join(pred_strs)}
-{trajectory_summary}{tools_str}{strategy_section}{attempts_section}\
-{journal_section}\
-{scheduled_plans_section}
-## Instructions
-Use your available tools to inspect the environment before producing the plan.
-
-{sketch_kind_guidance}
-
-{submit_guidance}
-
-{format_block}
-
-Follow the system prompt's Subgoal Annotations contract: annotate every \
-step whose effect the available predicates can express (typed obj:type \
-references in arguments and atoms alike), insert a Wait after any action \
-whose subgoal depends on a delayed process, and annotate each Wait with \
-the atoms that should end it. A delayed process needs its EXPLICIT Wait \
-even when a belief rollout completes without one: belief and real option \
-durations differ, so a plan that borrows other steps' incidental \
-duration to cover a hidden timer validates in belief and loses the \
-timing race in reality. A step without `-> {{atoms}}` is only \
-checked for "executed" - search and execution monitoring are blind there.
-
-{closing_block}"""
-
-    return prompt
+        instructions = render("solve_query",
+                              "instructions_capture",
+                              stuck_advice=render("solve_query",
+                                                  "stuck_revise"))
+
+    body = render(
+        "solve_query",
+        "skeleton",
+        opening=render("solve_query",
+                       "opening_explore" if explore_mode else "opening_solve"),
+        goal_nl_section=goal_nl_section,
+        scoring_section=scoring_section,
+        goal_atoms_section=goal_atoms_section,
+        experiment_section=experiment_section,
+        atoms="\n".join(atom_lines) if atom_lines else render(
+            "solve_query", "no_atoms"),
+        # 4 decimals (0.1 mm at metric scale), matching the per-step
+        # state dumps: the default 2 dp misstated mm-scale geometry
+        # (a 0.025 half-extent printed as 0.03) and sent agents to
+        # sim.task()/sim.state() to re-derive every number.
+        state=init_state.dict_str(indent=2, num_decimal_points=4),
+        image_section=initial_image_section.strip("\n"),
+        objects="\n".join(obj_lines),
+        options="\n".join(option_lines),
+        predicates="\n".join(pred_lines),
+        trajectory_summary=trajectory_summary.strip("\n"),
+        tools_section=tools_section,
+        strategy_section=strategy_section,
+        attempts_section=attempts_section,
+        journal_section=journal_section,
+        scheduled_plans_section=scheduled_section,
+        instructions=instructions,
+    )
+    return _join([body])
+
+
+def summarize_trajectories(trajectories: Sequence[LowLevelTrajectory],
+                           predicates: Set[Predicate]) -> str:
+    """The ``## Trajectory Summary`` query section, or "".
+
+    Per recent trajectory (the last
+    ``CFG.agent_sdk_max_trajectories_in_context``), the atoms gained and
+    lost between its first and last state. Shared by the solve approach
+    and the explorers.
+    """
+    if not trajectories:
+        return ""
+    max_trajs = CFG.agent_sdk_max_trajectories_in_context
+    recent = trajectories[-max_trajs:]
+    lines = [
+        f"\n## Trajectory Summary ({len(trajectories)} total, "
+        f"showing last {len(recent)})"
+    ]
+    for i, traj in enumerate(recent):
+        n_steps = len(traj.actions)
+        init_atoms = utils.abstract(traj.states[0], predicates)
+        final_atoms = utils.abstract(traj.states[-1], predicates)
+        new_atoms = final_atoms - init_atoms
+        lost_atoms = init_atoms - final_atoms
+        lines.append(f"\nTrajectory {i}: {n_steps} steps")
+        if new_atoms:
+            lines.append(
+                "  Gained: " +
+                f"{', '.join(str(a) for a in sorted(new_atoms, key=str))}")
+        if lost_atoms:
+            lines.append(
+                "  Lost: " +
+                f"{', '.join(str(a) for a in sorted(lost_atoms, key=str))}")
+    return "\n".join(lines)
diff --git a/predicators/agent_sdk/tools/context.py b/predicators/agent_sdk/tools/context.py
index 702e4c6b9..801a43626 100644
--- a/predicators/agent_sdk/tools/context.py
+++ b/predicators/agent_sdk/tools/context.py
@@ -80,14 +80,14 @@ class ToolContext:
     probe_residuals_provider: Optional[Callable[..., str]] = None
     # Active-experiment info-gain scorer, synced from the learning
     # approach when info-seeking exploration is on:
-    # ``(state, atoms) -> disagreement``. The agent_bilevel explorer
+    # ``(state, atoms) -> disagreement``. The agent_model_based explorer
     # passes it into refinement so continuous-parameter search prefers
     # candidates that straddle the learned model's decision boundaries.
     # None ⇒ plain feasibility search (default).
     atom_disagreement_fn: Optional[Callable[[State, Any], float]] = None
     # Synthesized per-skill samplers (option name -> sampler), synced from
     # the learning approach when agent_sim_learn_parameterized_samplers is on.
-    # The agent_bilevel explorer and synthesis tools pass these into
+    # The agent_model_based explorer and synthesis tools pass these into
     # refinement so continuous-parameter search aims at each step's subgoal
     # instead of drawing uniformly. Empty ⇒ uniform sampling (default).
     parameterized_samplers: Dict[str, ParameterizedSampler] = field(
@@ -124,7 +124,7 @@ class ToolContext:
     # frozen for the session's lifetime. Subclasses set this before
     # opening a fresh session and clear it on close.
     extra_session_hooks: Dict[str, list] = field(default_factory=dict)
-    # Populated by AgentBilevelExplorer so learning approaches can diff
+    # Populated by AgentModelBasedExplorer so learning approaches can diff
     # mental-model subgoals against real trajectories.
     # TODO(sim-learning): consume these in learn_from_interaction_results.
     last_sketch_subgoals: Optional[Any] = None
@@ -138,29 +138,21 @@ class ToolContext:
     # them as Wait targets; False (bare observations) strips them.
     latent_tracking_available: bool = False
     last_sketch_options: Optional[Any] = None
-    # Set by AgentBilevelExplorer per request: did the mental model reach
+    # Set by AgentModelBasedExplorer per request: did the mental model reach
     # the task goal during refinement? Read by get_interaction_requests to
     # stamp InteractionRequest.mental_model_solved (None ⇒ no verdict).
     last_mental_model_solved: Optional[bool] = None
     # Sketch-line descriptions of the exploration plans already generated
     # this online-learning cycle (a cycle's requests are all generated
     # before any executes). Cleared by get_interaction_requests per cycle,
-    # appended by AgentBilevelExplorer per request, and shown in the next
+    # appended by AgentModelBasedExplorer per request, and shown in the next
     # explore prompt so the agent proposes a complementary plan instead of
     # repeating the identical one for every request.
     cycle_scheduled_plans: List[str] = field(default_factory=list)
-    # Grounded plans that passed the belief's capture gate this cycle,
-    # keyed by train task index. Cleared by get_interaction_requests per
-    # cycle, written by AgentBilevelExplorer when an explore session's
-    # tool-validated capture reached the goal; the cycle's remaining
-    # requests on that task replay the plan (no new query), so a plan
-    # the belief certifies and reality solves on every attempt ends the
-    # loop (see agent_explorer_replay_certified_plan).
-    cycle_certified_plans: Dict[int, List[Any]] = field(default_factory=dict)
     # Digest of the latest rollout system-ID fit's weak spots
     # (unexplainable segments, unidentified/insensitive params,
     # cross-cycle conflicts), synced from the sim-learning approach.
-    # The agent_bilevel explorer appends it to its experiment guidance
+    # The agent_model_based explorer appends it to its experiment guidance
     # so the next exploration targets the gaps. None ⇒ no fit ran yet
     # (or it had no weak spots).
     sysid_diagnostics: Optional[str] = None
diff --git a/predicators/agent_sdk/tools/python_exec.py b/predicators/agent_sdk/tools/python_exec.py
index e9be16038..8b05ae59f 100644
--- a/predicators/agent_sdk/tools/python_exec.py
+++ b/predicators/agent_sdk/tools/python_exec.py
@@ -196,6 +196,17 @@ def _footer() -> str:
 
         old_stdout = sys.stdout
         sys.stdout = captured = io.StringIO()
+        # Execute with the sandbox as the working directory, so the
+        # agent's relative paths (open("plan.txt"), np.save(...)) hit
+        # the same files as its Read/Write/Bash tools instead of the
+        # repo root (run_20260830: a stale repo-root plan.txt from one
+        # session was silently executed by the next). exec blocks the
+        # event loop, so no other tool call can observe the changed
+        # cwd; harness paths reachable from tool code are absolute
+        # (see _get_log_dir).
+        prev_cwd = os.getcwd()
+        if sandbox_dir is not None:
+            os.chdir(sandbox_dir)
         try:
             exec(compile(code, label, "exec"), exec_ns)  # pylint: disable=exec-used
         except ProbeBudgetExceeded as e:
@@ -215,6 +226,8 @@ def _footer() -> str:
             prefix = f"{partial}\n" if partial else ""
             return text_result(f"{prefix}Error:\n{tb}{_footer()}")
         finally:
+            if sandbox_dir is not None:
+                os.chdir(prev_cwd)
             if watchdog_disarm is not None:
                 watchdog_disarm()
             sys.stdout = old_stdout
diff --git a/predicators/agent_sdk/tools/synthesis.py b/predicators/agent_sdk/tools/synthesis.py
index f0ff47a79..93ffeb357 100644
--- a/predicators/agent_sdk/tools/synthesis.py
+++ b/predicators/agent_sdk/tools/synthesis.py
@@ -860,6 +860,15 @@ def _run_rollout_residuals(rules: list, specs: list, latent_init: Any,
                         "list of registry names or the string 'all', got "
                         f"{sweep_params!r} (available: "
                         f"{sorted(sweepable)}).")
+            if not sweepable:
+                # Say so instead of silently degrading to the bare
+                # baseline report (which then advises passing
+                # sweep_params - the argument the caller already passed).
+                return (f"[{version_tag}] Error: sweep_params='all', but "
+                        "the env's physical-param registry has no "
+                        "sweepable entries (none declare a lo/hi range), "
+                        "so there is nothing to sweep. Use phys_params="
+                        "{name: value} to score explicit points instead.")
             selected = dict(sweepable)
         else:
             unknown = sorted(set(sweep_params) - set(sweepable))
@@ -1132,7 +1141,20 @@ def run_residuals(max_transitions: int = 100,
         answers whether the base physics is globally faithful, which
         per-step residuals cannot see.
         """
-        p = path or simulator_file
+        if path is not None:
+            # Resolve a relative path against the sandbox (where the
+            # canonical simulator.py lives), never the process cwd, and
+            # error on a missing file instead of falling through to the
+            # no-simulator baseline report: run_20260830_145216 scored
+            # "simulator_glueonly.py" as the bare base sim for a whole
+            # session because the path resolved against the repo root.
+            p = (path if os.path.isabs(path) else os.path.join(
+                os.path.dirname(simulator_file), path))
+            if not os.path.isfile(p):
+                return (f"Error: path={path!r} not found (resolved to "
+                        f"{p}). Pass a file that exists in the sandbox.")
+        else:
+            p = simulator_file
         if not os.path.isfile(p):
             # No simulator.py yet (a fresh cycle-0 learn session): score
             # the BASE simulator alone. Everything is out of scope, so
diff --git a/predicators/agent_sdk/tools/testing.py b/predicators/agent_sdk/tools/testing.py
index 5739e0c59..5910735c4 100644
--- a/predicators/agent_sdk/tools/testing.py
+++ b/predicators/agent_sdk/tools/testing.py
@@ -19,7 +19,7 @@
     _capture_task_key, decorrelated_rollout_seed
 from predicators.agent_sdk.tools.results import _error_result
 from predicators.agent_sdk.tools.scene import format_object_poses, \
-    render_scene_image
+    render_pybullet_image
 from predicators.agent_sdk.tools.tasks import _resolve_task
 from predicators.agent_sdk.tools.verdicts import _EvalStateCollector, \
     _format_evaluator_verdict, _resolve_task_evaluator, _sandbox_base, \
@@ -188,9 +188,12 @@ def _build_testing_tools(ctx: ToolContext, _text_result: Callable,
         "closed-loop (monitored, with replan-on-divergence). Capture is "
         "gated: a goal-reaching plan is re-run several times (simulation "
         "varies across runs; each rollout reports the motion-planner seed "
-        "it ran at) and a FLAKY plan is reported instead of captured - "
-        "reproduce a failed rollout with `sim.run(plan, seed=S)` in "
-        "run_python, add margin, and resubmit. `validation_rollouts` "
+        "it ran at) and a FLAKY plan is reported instead of captured. The "
+        "gate's rollout set is exactly what `sim.run(plan, trials=N)` runs "
+        "(fresh env per rollout, same planner seeds), so measure "
+        "reliability there BEFORE submitting, and reproduce one failed "
+        "rollout with `sim.run(plan, seed=S, fresh=True)`; then add "
+        "margin and resubmit. `validation_rollouts` "
         "requests a STRICTER gate for this submission (more rollouts; never "
         "fewer than configured). This is the ONLY path that captures an "
         "answer: explore (other tasks, modified states, partial plans, "
@@ -328,15 +331,21 @@ async def submit_plan(args: Dict[str, Any]) -> Dict[str, Any]:
                 "Parsed empty plan. Each line must be "
                 "`Option(obj:type, ...)[params] -> {subgoals}` with a known "
                 "option, typed object refs, and exact params in `[]`.")
-        # Ground each step with its parsed exact params.
+        # Ground each step with its parsed exact params, via the same
+        # helper the refine path uses: an annotated Wait gets its
+        # wait_target_atoms installed, so it waits for the annotated
+        # atoms here exactly as in refine and in real execution -
+        # grounding directly made the same Wait terminate on the first
+        # incidental atom change in this rollout but wait for its
+        # targets in refine, two different durations for one plan.
         grounded_plan: List[Any] = []
         for step_idx, st in enumerate(sketch_steps):
             params = (st.initial_params if st.initial_params is not None else
                       np.array([], dtype=np.float32))
             try:
                 grounded_plan.append(
-                    st.option.ground(list(st.objects),
-                                     np.asarray(params, dtype=np.float32)))
+                    bilevel_sketch.ground_step(
+                        st, np.asarray(params, dtype=np.float32)))
             except Exception as e:  # pylint: disable=broad-except
                 return _error_result(f"Failed to ground step {step_idx} "
                                      f"({st.option.name}): {e}")
@@ -359,6 +368,13 @@ def _report_step(i: int, outcome: Any) -> None:
                              f"{format_object_poses(outcome.pre_state)}")
                 return
             step_line = f"Step {i}: {sig} ({outcome.num_actions} actions)"
+            if (opt.name == "Wait" and outcome.failure_reason is None and
+                    outcome.num_actions >= CFG.max_num_steps_option_rollout):
+                step_line += (
+                    "\n  NOTE: this Wait ran to the option-rollout cap - "
+                    "its wait-target atoms never became true in the "
+                    "belief (and no other atom changed). Check whether "
+                    "the awaited change is modeled, or drop the Wait.")
             if outcome.failure_reason is not None:
                 step_line += (f"\n  FAILURE REASON: {outcome.failure_reason}"
                               "\n  Object poses at failure:\n"
@@ -375,24 +391,71 @@ def _report_step(i: int, outcome: Any) -> None:
                 step_line += ("\n  State:\n" +
                               post.dict_str(indent=4, num_decimal_points=4))
             lines.append(step_line)
-            img_block = render_scene_image(ctx, f"step_{i}_{opt.name}")
+            # Render from the outcome's state explicitly: the rollout
+            # runs on the gate's fresh env (see fresh_scope below) while
+            # the renderer draws the shared session env, so without the
+            # state the images would show a stale scene.
+            img_block = render_pybullet_image(
+                ctx,
+                f"step_{i}_{opt.name}",
+                state=post if post is not None else outcome.pre_state)
             if img_block and img_block.get("saved_path"):
                 saved_image_paths.append(img_block["saved_path"])
 
+        # One substrate for the WHOLE gate: rollout 1 (the capture
+        # rollout) runs on the same freshly constructed env as the
+        # validation repeats, at the base planner seed. This makes the
+        # gate reproducible from inside the session - sim.run(plan,
+        # trials=N) runs the identical rollout set (fresh env per trial,
+        # planner seeds base..base+N-1) - and stops a submission from
+        # advancing the shared session env. Rollout 1 on the warm shared
+        # env was a different physics substrate from every repeat: the
+        # 2026-08-30 bridge runs tuned plans to 27/27 on one substrate
+        # that then scored 1/10 on the other, with no way to reproduce
+        # the gate's rollouts.
+        fresh_scope = (ctx.validation_env_scope
+                       if validation_cfg.fresh_env else None)
         # Execute exactly like the real closed-loop executor: abort at the
         # first failing option (0-action collision / not-initiable / env
         # failure) instead of pressing on. Otherwise forward simulation can
         # continue past a collision and report a goal that the real rollout —
         # which ends the episode at that failed option — never reaches.
         ctx.attempt_rollout_count += 1
-        result = bilevel_sketch.execute_plan_forward(task,
-                                                     grounded_plan,
-                                                     ctx.option_model,
-                                                     predicates=all_predicates,
-                                                     sketch=sketch_steps,
-                                                     on_step=_report_step,
-                                                     stop_on_failure=True)
-        final_atoms = utils.abstract(result.final_state, ctx.predicates)
+        with (fresh_scope()
+              if fresh_scope is not None else contextlib.nullcontext()):
+            result = bilevel_sketch.execute_plan_forward(
+                task,
+                grounded_plan,
+                ctx.option_model,
+                predicates=all_predicates,
+                sketch=sketch_steps,
+                on_step=_report_step,
+                stop_on_failure=True)
+            final_atoms = utils.abstract(result.final_state, ctx.predicates)
+            # Task-evaluator verdict on this belief-sim rollout, computed
+            # BEFORE capture and INSIDE the scope (certificate probes must
+            # judge on the env the rollout ran on): the real evaluator
+            # applies the same certificate, so a goal-reaching but
+            # illegitimate plan can never count as a solve and must not be
+            # captured as the answer (run_20260712_173955 tasks 1-2:
+            # flagged-illegitimate captures stood all session and were
+            # executed only to be rejected). Failure-tolerant: verdict
+            # stays None when the task has no evaluator or nothing
+            # executed. A coarse verdict (option-boundary states only) can
+            # falsely reject a legitimate cascade, so it never blocks
+            # capture.
+            evaluator = _resolve_task_evaluator(ctx, task_label)
+            verdict: Optional[Dict[str, Any]] = None
+            if evaluator is not None and len(eval_collector.states) > 1:
+                try:
+                    verdict = evaluate_states_with(evaluator,
+                                                   eval_collector.states,
+                                                   eval_collector.labels,
+                                                   sim_env=getattr(
+                                                       ctx.option_model,
+                                                       "sim_env", None))
+                except Exception as e:  # pylint: disable=broad-except
+                    logging.debug("Task-evaluator verdict failed: %s", e)
         # Use the env's goal-check (its own classifiers); robust to invented
         # predicates that don't reuse env names.
         goal_reached = result.goal_reached
@@ -406,27 +469,6 @@ def _report_step(i: int, outcome: Any) -> None:
                           and result.actions_to_goal <= horizon)
         goal_achieved = (goal_reached and result.clean_to_goal
                          and within_horizon)
-        # Task-evaluator verdict on this belief-sim rollout, computed BEFORE
-        # capture: the real evaluator applies the same certificate, so a
-        # goal-reaching but illegitimate plan can never count as a solve and
-        # must not be captured as the answer (run_20260712_173955 tasks 1-2:
-        # flagged-illegitimate captures stood all session and were executed
-        # only to be rejected). Failure-tolerant: verdict stays None when the
-        # task has no evaluator or nothing executed. A coarse verdict
-        # (option-boundary states only) can falsely reject a legitimate
-        # cascade, so it never blocks capture.
-        evaluator = _resolve_task_evaluator(ctx, task_label)
-        verdict: Optional[Dict[str, Any]] = None
-        if evaluator is not None and len(eval_collector.states) > 1:
-            try:
-                verdict = evaluate_states_with(evaluator,
-                                               eval_collector.states,
-                                               eval_collector.labels,
-                                               sim_env=getattr(
-                                                   ctx.option_model, "sim_env",
-                                                   None))
-            except Exception as e:  # pylint: disable=broad-except
-                logging.debug("Task-evaluator verdict failed: %s", e)
         evaluator_rejected = (verdict is not None and not verdict["legitimate"]
                               and not eval_collector.coarse)
         # An evaluator rejection only disqualifies a capture when the goal
@@ -526,12 +568,10 @@ def _validation_rollout() -> Tuple[bool, str, List[Optional[State]]]:
                     f"NOTE: validation_rollouts={requested_rollouts} capped "
                     f"at {_MAX_REQUESTED_ROLLOUTS}.")
             n_rollouts = max(n_rollouts, capped_request)
-        # Fresh env per validation rollout when the approach provides one:
-        # repeats on the shared env are correlated (its reset cannot
-        # reconstruct state exactly), so only fresh envs sample the same
-        # distribution the real episode will.
-        fresh_scope = (ctx.validation_env_scope
-                       if validation_cfg.fresh_env else None)
+        # fresh_scope (computed above, shared with rollout 1): repeats on
+        # the shared env are correlated (its reset cannot reconstruct
+        # state exactly), so only fresh envs sample the same distribution
+        # the real episode will.
         rollout_outcomes: List[str] = []
         # Per-step post-states of PASSING validation rollouts, for the
         # captured-annotation intersection filter. Failing rollouts are
@@ -597,7 +637,8 @@ def _repeat_rollout(
                     f"{base_planner_seed + n_rollouts - 1}; the "
                     "simulator's motion planning and physics stepping vary "
                     "across runs; repeats sample that execution "
-                    f"variability{fresh_note}).")
+                    f"variability{fresh_note}; sim.run(plan, "
+                    f"trials={n_rollouts}) reruns this exact rollout set).")
 
         # Parameter-margin gates (see _parameter_margin_sweep): the
         # execution repeats above all run AT the fitted parameters, so
@@ -738,6 +779,25 @@ def _probe_without_latent(atom: Any,
                                               subgoal_atoms=pos_held or None,
                                               subgoal_neg_atoms=neg_held
                                               or None))
+            # Re-align each Wait's target atoms with the FILTERED
+            # sketch: the real executor waits on exactly the monitored
+            # (execution-verifiable) atoms. A latent-only target (e.g. a
+            # belief Bonded) reads false on every real observation, so
+            # leaving it in the grounded option's memory would stall the
+            # real Wait to its step-cap backstop no matter what happens.
+            # With every target filtered away the Wait falls back to
+            # any-atom-change, the same rule the belief rollout then
+            # shares.
+            for g_opt, cap_step in zip(grounded_plan, captured_sketch):
+                if g_opt.name != "Wait":
+                    continue
+                g_opt.memory.pop("wait_target_atoms", None)
+                g_opt.memory.pop("wait_target_neg_atoms", None)
+                if cap_step.subgoal_atoms:
+                    g_opt.memory["wait_target_atoms"] = cap_step.subgoal_atoms
+                if cap_step.subgoal_neg_atoms:
+                    g_opt.memory["wait_target_neg_atoms"] = \
+                        cap_step.subgoal_neg_atoms
             ctx.solved_plan = grounded_plan
             ctx.solved_sketch = captured_sketch
             ctx.solved_plan_reached_goal = validated_solve
@@ -829,10 +889,14 @@ def _probe_without_latent(atom: Any,
                 "planning and physics stepping vary across runs, and the "
                 "real environment samples the same variability - a plan "
                 "that only sometimes succeeds in simulation will likely "
-                "fail for real. To debug a failed rollout first, re-run "
-                "it exactly in run_python: sim.run(plan, seed=<the failed "
-                "rollout's planner seed>) gives full per-step reporting at "
-                "that seed. Then add margin (e.g. tighter spacing, aim "
+                "fail for real. This gate is reproducible in run_python: "
+                f"sim.run(plan, trials={n_rollouts}) runs the identical "
+                "rollout set (fresh env per trial, same planner seeds), "
+                "and sim.run(plan, seed=<the failed rollout's planner "
+                "seed>, fresh=True) re-runs one failed rollout exactly "
+                "with full per-step reporting (without fresh=True the "
+                "warm session env is a different, optimistic substrate). "
+                "Then add margin (e.g. tighter spacing, aim "
                 "impacts closer to the middle of the fall path) and "
                 "resubmit. Because this task has now produced a flaky "
                 f"submission, captures require {escalated_n}/{escalated_n} "
@@ -1056,17 +1120,44 @@ def _report_step(i: int, outcome: Any) -> None:
                 step_line += (f"\n  Added:   {{{added_s}}}"
                               f"\n  Deleted: {{{del_s}}}")
             lines.append(step_line)
-            img_block = render_scene_image(ctx, f"policy_step_{i}_{opt.name}")
+            # Explicit state: the rollout runs on the gate's fresh env
+            # while the renderer draws the shared session env (see
+            # submit_plan's _report_step).
+            img_block = render_pybullet_image(
+                ctx,
+                f"policy_step_{i}_{opt.name}",
+                state=post if post is not None else outcome.pre_state)
             if img_block and img_block.get("saved_path"):
                 saved_image_paths.append(img_block["saved_path"])
 
+        # One substrate for the whole gate, as in submit_plan: rollout 1
+        # runs on the same fresh env as the validation repeats, at the
+        # base planner seed, so the gate is reproducible in-session.
+        fresh_scope = (ctx.validation_env_scope
+                       if validation_cfg.fresh_env else None)
         ctx.attempt_rollout_count += 1
-        result = execute_policy_forward(task,
-                                        option_fn,
-                                        model,
-                                        predicates=all_predicates,
-                                        max_policy_options=max_opts,
-                                        on_step=_report_step)
+        with (fresh_scope()
+              if fresh_scope is not None else contextlib.nullcontext()):
+            result = execute_policy_forward(task,
+                                            option_fn,
+                                            model,
+                                            predicates=all_predicates,
+                                            max_policy_options=max_opts,
+                                            on_step=_report_step)
+            # Verdict INSIDE the scope: certificate probes must judge on
+            # the env the rollout ran on.
+            evaluator = _resolve_task_evaluator(ctx, task_label)
+            verdict: Optional[Dict[str, Any]] = None
+            if evaluator is not None and len(eval_collector.states) > 1:
+                try:
+                    verdict = evaluate_states_with(evaluator,
+                                                   eval_collector.states,
+                                                   eval_collector.labels,
+                                                   sim_env=getattr(
+                                                       ctx.option_model,
+                                                       "sim_env", None))
+                except Exception as e:  # pylint: disable=broad-except
+                    logging.debug("Task-evaluator verdict failed: %s", e)
 
         goal_reached = result.goal_reached
         within_horizon = (result.actions_to_goal is not None
@@ -1086,18 +1177,6 @@ def _report_step(i: int, outcome: Any) -> None:
         # and policy-code errors gate.
         goal_achieved = (goal_reached and within_horizon
                          and result.policy_error is None)
-        evaluator = _resolve_task_evaluator(ctx, task_label)
-        verdict: Optional[Dict[str, Any]] = None
-        if evaluator is not None and len(eval_collector.states) > 1:
-            try:
-                verdict = evaluate_states_with(evaluator,
-                                               eval_collector.states,
-                                               eval_collector.labels,
-                                               sim_env=getattr(
-                                                   ctx.option_model, "sim_env",
-                                                   None))
-            except Exception as e:  # pylint: disable=broad-except
-                logging.debug("Task-evaluator verdict failed: %s", e)
         evaluator_rejected = (verdict is not None and not verdict["legitimate"]
                               and not eval_collector.coarse)
         reward_hack = (evaluator_rejected and verdict is not None
@@ -1153,8 +1232,7 @@ def _policy_validation_rollout() -> Tuple[bool, str]:
         if requested_rollouts is not None:
             n_rollouts = max(n_rollouts,
                              min(requested_rollouts, _MAX_REQUESTED_ROLLOUTS))
-        fresh_scope = (ctx.validation_env_scope
-                       if validation_cfg.fresh_env else None)
+        # fresh_scope computed above, shared with rollout 1.
         rollout_outcomes: List[str] = []
         base_planner_seed = CFG.seed
         if (ctx.capture_goal_reaching_plans and goal_achieved
diff --git a/predicators/approaches/__init__.py b/predicators/approaches/__init__.py
index 502e46736..05c521b00 100644
--- a/predicators/approaches/__init__.py
+++ b/predicators/approaches/__init__.py
@@ -1,5 +1,6 @@
 """Handle creation of approaches."""
 
+import logging
 from typing import List, Set
 from typing import Type as TypingType
 
@@ -15,8 +16,44 @@
 # Find the subclasses.
 utils.import_submodules(__path__, __name__)
 
+# Deprecated CLI aliases from before the agent approaches' model-free /
+# model-based rename (2026-08-30); old commands and configs still pass
+# them.
+_DEPRECATED_APPROACH_ALIASES = {
+    "agent_planner": "agent_model_free",
+    "agent_bilevel": "agent_model_based",
+}
+
+# Deprecated CLI aliases from before the agent approaches' model-free /
+# model-based rename (2026-08-30); old commands and configs still pass
+# them.
+_DEPRECATED_APPROACH_ALIASES = {
+    "agent_planner": "agent_model_free",
+    "agent_bilevel": "agent_model_based",
+}
+
+# Deprecated CLI aliases from before the agent approaches' model-free /
+# model-based rename (2026-08-30); old commands and configs still pass
+# them.
+_DEPRECATED_APPROACH_ALIASES = {
+    "agent_planner": "agent_model_free",
+    "agent_bilevel": "agent_model_based",
+}
+
 
 def _get_approach_cls_from_name(name: str) -> TypingType[BaseApproach]:
+    if name in _DEPRECATED_APPROACH_ALIASES:
+        logging.warning("Approach name %r is deprecated; use %r.", name,
+                        _DEPRECATED_APPROACH_ALIASES[name])
+        name = _DEPRECATED_APPROACH_ALIASES[name]
+    if name in _DEPRECATED_APPROACH_ALIASES:
+        logging.warning("Approach name %r is deprecated; use %r.", name,
+                        _DEPRECATED_APPROACH_ALIASES[name])
+        name = _DEPRECATED_APPROACH_ALIASES[name]
+    if name in _DEPRECATED_APPROACH_ALIASES:
+        logging.warning("Approach name %r is deprecated; use %r.", name,
+                        _DEPRECATED_APPROACH_ALIASES[name])
+        name = _DEPRECATED_APPROACH_ALIASES[name]
     for cls in utils.get_all_subclasses(BaseApproach):
         if not cls.__abstractmethods__ and cls.get_name() == name:
             return cls
diff --git a/predicators/approaches/agent_model_based_approach.py b/predicators/approaches/agent_model_based_approach.py
index 015a222ac..7fa957ece 100644
--- a/predicators/approaches/agent_model_based_approach.py
+++ b/predicators/approaches/agent_model_based_approach.py
@@ -9,15 +9,15 @@
 suffix replans, but there is no approach-side refinement of unvalidated
 sketches.
 
-Registered under the CLI approach name ``agent_bilevel`` (kept stable so
-existing configs and logs remain valid).
+Registered under the CLI approach name ``agent_model_based``
+(``agent_bilevel`` is kept as a deprecated alias).
 
 Example command::
 
     python predicators/main.py --env pybullet_domino \
-        --approach agent_bilevel --seed 0 \
+        --approach agent_model_based --seed 0 \
         --num_train_tasks 1 --num_test_tasks 1 \
-        --num_online_learning_cycles 1 --explorer agent_plan
+        --num_online_learning_cycles 1 --explorer agent_model_free
 """
 import dataclasses
 import hashlib
@@ -159,7 +159,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
 
     @classmethod
     def get_name(cls) -> str:
-        return "agent_bilevel"
+        return "agent_model_based"
 
     # ------------------------------------------------------------------ #
     # Execution monitoring (closed-loop test execution)
@@ -206,129 +206,31 @@ def _get_synthesis_tool_names(self) -> Optional[List[str]]:
         return []
 
     # ------------------------------------------------------------------ #
-    # System prompt (simplified - no parameter tuning workflow)
+    # System prompt
     # ------------------------------------------------------------------ #
 
     def _get_agent_system_prompt(self) -> str:
-        propose = CFG.agent_bilevel_use_llm_initial_params
-        refine_ref = "sim.refine (in run_python)"
-        # What a sketch step consists of (shared between modes).
-        if propose:
-            sketch_desc = (
-                "a sequence of skills (parameterized options) with object "
-                "arguments, subgoal atoms after each step, and the continuous "
-                "parameters for each step")
-        else:
-            sketch_desc = (
-                "a sequence of skills (parameterized options) with object "
-                "arguments and subgoal atoms after each step, plus continuous "
-                f"parameters you find with {refine_ref}")
-
         # Sessions are per-phase (see _ensure_agent_session: a phase
         # change closes and rebuilds the session), so a solve session
         # only ever receives solve queries and an explore session only
-        # explore queries - each phase's system prompt states just its
-        # own delivery contract. SOLVE is a hard capture gate; EXPLORE
-        # delivers an experiment sketch as text (the belief model may
-        # lack goal-critical dynamics, so a goal-reaching capture can be
-        # impossible by construction).
-        if self._explore_phase:
-            contract = ("Your deliverable is your final plan-sketch TEXT: an "
-                        "experiment to run in the real environment. A "
-                        "simulator-validated sketch is preferred when the "
-                        "current model supports one; when it does not, submit "
-                        "the sketch most likely to work in reality instead of "
-                        "grinding for a capture the model cannot produce.")
-        elif CFG.agent_solve_policy_mode:
-            contract = (
-                "You DELIVER a closed-loop PROGRAM, not a fixed plan: "
-                "write ./policy.py with `get_option(state, memory)` "
-                "returning ONE plan line (the same sketch grammar) from "
-                "the actual current state, or None when finished, then "
-                "run submit_policy on the current task until it "
-                "reaches the goal - that validated policy.py snapshot is "
-                "your ONLY accepted output. Option failures do NOT end "
-                "an episode: they arrive in memory['last_failure'] and "
-                "get_option is asked again, so RECOVERY (re-place a "
-                "drifted block, re-aim after a motion-planning refusal) "
-                "is your policy's job. After a failure your policy MUST "
-                "change something - parameters, target, or action: "
-                "re-issuing the identical failing line "
-                f"{CFG.agent_policy_max_repeated_failures} times in a "
-                "row ends the episode as a policy bug, and so does "
-                "re-issuing one identical line that keeps completing "
-                "with NO state change (a no-op livelock). Sketches and "
-                "subgoal annotations remain useful for exploration "
-                "(sim.run / sim.refine) but are not the deliverable.")
-        else:
-            contract = (
-                "You DELIVER by running submit_plan with "
-                "per-step subgoals on the current task until it reaches "
-                "the goal - that captured plan is your ONLY accepted "
-                "output, so do not finish until submit_plan "
-                "reaches the goal.")
-        job = ("Your job is to produce a plan - " + sketch_desc +
-               " - that reaches the goal. " + contract + "\n"
-               "submit_plan runs your EXACT parameters with no "
-               "sampling, so every parameter must be right. To find working "
-               f"values you MAY use {refine_ref} while reasoning (it "
-               "searches for parameters but is slower); read the parameters "
-               "it reports and submit them via submit_plan. Use "
-               "whatever tools help.")
-        # Parameter-effort and ground-sampler guidance live in the query's
-        # Instructions (sketch_prompts.build_solve_prompt) - single source.
-
-        # Keep responses short: the model's deliberation is the main driver of
-        # the output-token overflow, and testing is often faster than deriving.
-        brevity = (
-            " Keep your reasoning concise: prefer making a concrete attempt "
-            f"and testing it with {refine_ref} / submit_plan to "
-            "let the simulator tell you what's wrong.")
-        params_clause = job + brevity + "\n\n"
-        # Keep the subgoal-annotation template's option format consistent with
-        # the solve prompt: show the [params] slot iff the agent proposes them.
-        param_slot = "[param1, param2]" if propose else ""
-        wait_slot = "[]" if propose else ""
-        if self._explore_phase:
-            identity = (
-                "You are an exploration agent in an online learning "
-                "loop. You observe task environments through inspection "
-                "tools and design plan sketches as experiments that "
-                "gather information about the real environment.")
-        else:
-            identity = (
-                "You are a planning agent. You observe task environments "
-                "through inspection tools and generate plan sketches to "
-                "achieve goals.")
-        return (
-            identity + " "
-            "You have access to read-only tools to inspect predicates, "
-            "options, trajectories, and training tasks.\n\n"
-            f"{params_clause}"
-            "Some effects may not be immediate - if an action triggers a "
-            "delayed process (e.g. gradual accumulation, propagation "
-            "through contacting objects, a sensor catching up to an "
-            "actuator), insert a Wait after it so the effect has time "
-            "to occur before the next action.\n\n"
-            "## Subgoal Annotations\n"
-            "After each step, annotate which predicate atoms should hold "
-            "after that step succeeds. Use the format:\n"
-            f"  OptionName(obj1:type1, obj2:type2){param_slot} -> "
-            "{Pred(obj1:type1), Pred2(obj1:type1, obj2:type2)}\n"
-            "Always use typed references (obj:type) in subgoal atoms.\n"
-            "Annotate EVERY step whose effect the predicates can express. "
-            "Annotations are not just search hints: refinement validates "
-            "each annotated step, and at execution time they are checked "
-            "against the real state, so a step that diverges can be "
-            "detected and replanned instead of silently dooming the rest "
-            "of the plan. Prefer atoms that NEWLY hold (or stop holding) "
-            "because of the step - atoms that were already true beforehand "
-            "cannot reveal divergence. A step you cannot annotate is a "
-            "blind spot for both search and recovery.\n"
-            "For Wait steps, the annotation also specifies exactly when the "
-            "Wait should terminate. Use `NOT Pred(...)` for atoms that should "
-            f"become false (e.g. `Wait(robot:robot){wait_slot} -> "
-            "{Ready(widget:widget)}`).")
+        # explore queries: each phase's system prompt states just its
+        # own deliverable contract and rules. The query carries the task
+        # data and the run state (sketch_prompts.build_solve_prompt).
+        return bilevel_sketch.build_solve_system_prompt(
+            explore=self._explore_phase,
+            policy_mode=CFG.agent_solve_policy_mode,
+            propose_params=CFG.agent_bilevel_use_llm_initial_params,
+            ground_samplers=CFG.agent_bilevel_ground_samplers,
+            physics_margin=CFG.agent_plan_validation_physics_margin,
+            rule_param_margin=CFG.agent_plan_validation_rule_param_margin,
+            use_journal=CFG.agent_solve_use_journal,
+            execute_certified_plan=CFG.agent_explorer_execute_certified_plan,
+            early_stop_note=bilevel_sketch.build_early_stop_note(),
+            policy_max_options=CFG.agent_policy_max_options,
+            policy_max_repeated_failures=CFG.
+            agent_policy_max_repeated_failures,
+            policy_max_repeated_noops=CFG.agent_policy_max_repeated_noops,
+        )
 
     # ------------------------------------------------------------------ #
     # Solve prompt (no continuous params, subgoal format)
@@ -358,12 +260,9 @@ def _build_solve_prompt(self, task: Task) -> str:
             initial_image_section=self._initial_image_section(),
             propose_params=CFG.agent_bilevel_use_llm_initial_params,
             require_tool_validation=True,
-            ground_samplers=CFG.agent_bilevel_ground_samplers,
             journal=journal_text,
             strategy=strategy_text,
             attempts=attempts_text,
-            physics_margin=CFG.agent_plan_validation_physics_margin,
-            policy_mode=CFG.agent_solve_policy_mode,
         )
 
     def _solve_prompt_tool_names(self) -> Optional[List[str]]:
@@ -552,9 +451,17 @@ def _append_journal_auto_entry(self, header: str,
         return True
 
     def _journal_task_label(self) -> str:
-        """The journal's label for the task currently being solved."""
+        """The journal's label for the task currently being solved.
+
+        Carries the HARNESS cycle number so the attempt log anchors a
+        canonical numbering: without it agents invented their own cycle
+        counts (a journal's "cycle 4" was the harness's cycle 1), and
+        cross-referencing run logs against the journal needed a mental
+        offset.
+        """
         idx = self._tool_context.test_task_idx
-        return f"task {idx}" if idx is not None else "task ?"
+        task_part = f"task {idx}" if idx is not None else "task ?"
+        return f"cycle {self._tool_context.iteration_id} {task_part}"
 
     def _record_task_context_in_journal(self, task: Task) -> None:
         """Append the task's goal + init-state entry, once per task.
diff --git a/predicators/approaches/agent_model_free_approach.py b/predicators/approaches/agent_model_free_approach.py
index 1ac4771e3..9f80574b1 100644
--- a/predicators/approaches/agent_model_free_approach.py
+++ b/predicators/approaches/agent_model_free_approach.py
@@ -2,18 +2,18 @@
 
 The agent plans directly from its own world knowledge - no simulator
 (model) is required to validate a plan before execution. Combines online
-trajectory collection (via AgentPlanExplorer) with open-loop option plan
+trajectory collection (via AgentModelFreeExplorer) with open-loop option plan
 generation (via Claude Agent SDK). No predicate/process/type invention -
 just stores trajectories and generates plans.
 
-Registered under the CLI approach name ``agent_planner`` (kept stable so
-existing configs and logs remain valid).
+Registered under the CLI approach name ``agent_model_free``
+(``agent_planner`` is kept as a deprecated alias).
 
 Example command:
     python predicators/main.py --env pybullet_domino \
-        --approach agent_planner --seed 0 \
+        --approach agent_model_free --seed 0 \
         --num_train_tasks 1 --num_test_tasks 1 \
-        --num_online_learning_cycles 1 --explorer agent_plan
+        --num_online_learning_cycles 1 --explorer agent_model_free
 """
 import copy
 import datetime
@@ -29,8 +29,10 @@
 
 from predicators import utils
 from predicators.agent_sdk.rendering import save_task_state_image
+from predicators.agent_sdk.response_parser import extract_final_text
 from predicators.agent_sdk.session_base import AgentSessionFatalError, \
     query_fatal_error
+from predicators.agent_sdk.sketch_prompts import summarize_trajectories
 from predicators.agent_sdk.tools import agent_render_resolution
 from predicators.agent_sdk.tools.digests import render_options_digest, \
     render_types_digest
@@ -52,7 +54,7 @@
 class AgentModelFreeApproach(AgentSessionMixin, BaseApproach):
     """Fixed-vocabulary open-loop planning via Claude Agent SDK.
 
-    - Collects trajectories online using AgentPlanExplorer
+    - Collects trajectories online using AgentModelFreeExplorer
     - At solve time, queries the agent for an option plan
     - No predicate/process/type invention
     """
@@ -148,7 +150,7 @@ def __init__(self,
 
     @classmethod
     def get_name(cls) -> str:
-        return "agent_planner"
+        return "agent_model_free"
 
     @property
     def is_learning_based(self) -> bool:
@@ -410,7 +412,6 @@ def get_interaction_requests(self) -> List[InteractionRequest]:
             # the explorer shows each query the plans already scheduled this
             # cycle and asks for a complementary one. Fresh list per cycle.
             self._tool_context.cycle_scheduled_plans = []
-            self._tool_context.cycle_certified_plans = {}
             for _ in range(CFG.online_nsrt_learning_requests_per_cycle):
                 task_idx = self._rng.choice(len(self._train_tasks))
                 # Clear so a planning explorer's verdict is read fresh per
@@ -922,55 +923,13 @@ def _build_solve_prompt(self, task: Task) -> str:
 
     def _build_trajectory_summary(self) -> str:
         """Summarize trajectory data for context."""
-        all_trajs = self._get_all_trajectories()
-        if not all_trajs:
-            return ""
-
-        max_trajs = CFG.agent_sdk_max_trajectories_in_context
-        recent = all_trajs[-max_trajs:]
-        all_preds = self._get_all_predicates()
-        lines = [
-            f"\n## Trajectory Summary ({len(all_trajs)} total, "
-            f"showing last {len(recent)})"
-        ]
+        return summarize_trajectories(self._get_all_trajectories(),
+                                      self._get_all_predicates())
 
-        for i, traj in enumerate(recent):
-            n_steps = len(traj.actions)
-            init_atoms = utils.abstract(traj.states[0], all_preds)
-            final_atoms = utils.abstract(traj.states[-1], all_preds)
-            new_atoms = final_atoms - init_atoms
-            lost_atoms = init_atoms - final_atoms
-            lines.append(f"\nTrajectory {i}: {n_steps} steps")
-            if new_atoms:
-                lines.append(
-                    f"  Gained: "
-                    f"{', '.join(str(a) for a in sorted(new_atoms, key=str))}")
-            if lost_atoms:
-                lines.append(
-                    f"  Lost: "
-                    f"{', '.join(str(a) for a in sorted(lost_atoms, key=str))}"
-                )
-
-        return "\n".join(lines)
-
-    def _extract_option_plan_text(self, responses: List[Dict[str,
-                                                             Any]]) -> str:
-        """Extract plan text from the last assistant text response.
-
-        Only uses the final assistant message to avoid including
-        intermediate reasoning/tool-call text that precedes the actual
-        option plan.
-        """
-        last_text_parts: List[str] = []
-        for resp in responses:
-            if resp.get("type") == "assistant":
-                parts = [
-                    block.get("text", "") for block in resp.get("content", [])
-                    if isinstance(block, dict) and block.get("type") == "text"
-                ]
-                if parts:
-                    last_text_parts = parts
-        return "\n".join(last_text_parts)
+    @staticmethod
+    def _extract_option_plan_text(responses: List[Dict[str, Any]]) -> str:
+        """Extract plan text from the last assistant text response."""
+        return extract_final_text(responses)
 
     @staticmethod
     def _strip_code_fences(text: str) -> str:
@@ -1071,7 +1030,8 @@ def _parse_and_ground_plan(self, plan_text: str, task: Task) -> list:
 
     def _create_explorer(self) -> BaseExplorer:
         """Create explorer for interaction requests."""
-        if CFG.explorer in ("agent_plan", "agent_bilevel"):
+        if CFG.explorer in ("agent_model_free", "agent_model_based",
+                            "agent_plan", "agent_bilevel"):
             self._sync_tool_context()
             return self._create_agent_explorer(
                 self._get_all_predicates(),
diff --git a/predicators/approaches/agent_session_mixin.py b/predicators/approaches/agent_session_mixin.py
index b008db164..14e9e4ad1 100644
--- a/predicators/approaches/agent_session_mixin.py
+++ b/predicators/approaches/agent_session_mixin.py
@@ -288,13 +288,18 @@ def _ensure_agent_session(self) -> None:
                 f.write(self._get_agent_system_prompt())
 
     def _get_log_dir(self) -> str:
-        """Return the log directory, using the approach name."""
+        """Return the log directory, using the approach name.
+
+        Always absolute: agent tool code (``run_python``) executes with
+        the sandbox as its working directory, so any path that harness
+        code may touch mid-call must not depend on the process cwd.
+        """
         if hasattr(CFG, 'log_file') and CFG.log_file:
-            return CFG.log_file
+            return os.path.abspath(CFG.log_file)
         name = (
             self.get_name()  # type: ignore[attr-defined]
             if hasattr(self, 'get_name') else self._log_subdir)
-        return os.path.join("logs", name)
+        return os.path.abspath(os.path.join("logs", name))
 
     def _close_agent_session(self) -> None:
         """Close and discard the current agent session, if one exists."""
@@ -323,7 +328,7 @@ def _create_agent_explorer(
         self,
         predicates: Set[Predicate],
         options: Set[ParameterizedOption],
-        name: str = "agent_plan",
+        name: str = "agent_model_free",
     ) -> BaseExplorer:
         """Create an agent explorer with tool_context and agent_session."""
         self._ensure_agent_session()
diff --git a/predicators/approaches/agent_sim_learning_approach.py b/predicators/approaches/agent_sim_learning_approach.py
index e09d9f426..09e10cc82 100644
--- a/predicators/approaches/agent_sim_learning_approach.py
+++ b/predicators/approaches/agent_sim_learning_approach.py
@@ -14,7 +14,7 @@
     python predicators/main.py --env pybullet_boil \
         --approach agent_sim_learning --seed 0 \
         --num_train_tasks 10 --num_test_tasks 5 \
-        --num_online_learning_cycles 5 --explorer agent_plan
+        --num_online_learning_cycles 5 --explorer agent_model_free
 """
 
 import copy
@@ -34,6 +34,7 @@
 from gym.spaces import Box
 
 from predicators import utils
+from predicators.agent_sdk import learn_prompts
 from predicators.agent_sdk.session_base import AgentSessionFatalError, \
     max_session_log_number, query_fatal_error
 from predicators.agent_sdk.tools import SYNTHESIS_TOOL_NAMES, \
@@ -80,564 +81,6 @@
 
 logger = logging.getLogger(__name__)
 
-# Canonical "### Rule signature" blocks for the synthesis system prompt,
-# spliced in at the ``__RULE_SIGNATURE_SECTION__`` placeholder by
-# ``_build_synthesis_system_prompt``. Which one renders is decided by
-# ``CFG.partially_observable`` (see ``_rule_signature_section``): the
-# same flag that swaps the env's observation and the GT simulator
-# module, so the prompt can never disagree with the world's
-# observability regime. Under the flag the prompt never shows the 3-arg
-# form as canonical - the 3-arg form sitting beside the PO guidance
-# previously led the agent to write a 3-arg rule the recurrent engine
-# rejects.
-_FO_RULE_SIGNATURE_SECTION = '''\
-### Rule signature
-
-```python
-def rule(state, updates, params):
-    # state:   the current env State
-    # updates: Dict[Object, Dict[str, float]] accumulated from prior rules
-    # params:  Dict[str, float], one entry per ParamSpec
-    #
-    # Accumulate, don't replace:
-    #     updates.setdefault(obj, {})[feat] = new_value
-    # Return the same dict.
-    ...
-```'''
-
-_PO_RULE_SIGNATURE_SECTION = '''\
-### Rule signature
-
-This is a **partial-observability** task. Write every rule with the
-recurrent 5-arg signature below - the 2nd parameter MUST be named
-`latent` (the engine inspects each rule's signature and threads the
-latent block / read-only history only into rules that declare it):
-
-```python
-def rule(observation, latent, history, updates, params):
-    # observation: the current observation (a State holding the
-    #          observable features ONLY - hidden quantities appear
-    #          under no name; infer them into `latent`)
-    # latent:  Dict[str, Any], mutated in place - the hidden dims you
-    #          infer, threaded across steps (see "Recurrent rules" below)
-    # history: List[Tuple[State, Optional[Action]]] of past
-    #          observations, read-only; newest last
-    # updates: Dict[Object, Dict[str, float]] accumulated from prior rules
-    # params:  Dict[str, float], one entry per ParamSpec
-    #
-    # Accumulate, don't replace:
-    #     updates.setdefault(obj, {})[feat] = new_value
-    # Return the same dict.
-    ...
-```
-
-A rule that needs no hidden state can ignore its `latent`/`history`
-args, but keep the 5-arg shape so the tools and the fitting engine call
-every rule the same way. See "## Recurrent rules (partial observability)"
-below for `LATENT_INIT` and the two latent-modelling patterns.'''
-
-# Simulator-side latent tutorial appended to the synthesis system prompt
-# under ``CFG.partially_observable`` (see
-# ``_extra_synthesis_system_prompt``). Predicate-invention arms append
-# their predicate-side counterpart after this
-# (``agent_sim_predicate_invention_approach._RECURRENT_PREDICATE_SECTION``).
-_RECURRENT_PROMPT_SECTION = """\
-## Recurrent rules (partial observability)
-
-This approach handles partial observability: the observation may omit
-causally-important quantities - there may be several, one, or none.
-Anything omitted is *absent entirely* from the state (it appears under
-no name, not even as a NaN placeholder), so you cannot read it and
-must *infer* its existence and dynamics from how the observable
-features evolve. Inspect the trajectories first to judge how many
-latents (if any) you need: a feature that drifts or ramps with no
-visible observed driver is likely downstream of an accumulating
-latent; if every observable is already explained by other observed
-quantities, you need no latent at all - keep the 5-arg signature and
-simply leave `latent` untouched. One common case: a hidden continuous
-quantity surfaced only through a derived observable that ramps once the
-latent crosses a threshold.
-
-Model the hidden state explicitly: each ``State`` you predict is one
-sample of an *augmented* state - the observable features plus the
-latent dimensions you infer (a free-form dict like ``{"level": 0.73}``
-or ``{"count": 22}``). Rules read and advance that latent through the
-``latent`` argument of the 5-arg signature defined in "### Rule
-signature" above. Declare the initial latent block:
-
-```python
-LATENT_INIT = {"level": 0.0, "count": 0}
-# OR a zero-arg callable returning such a dict.
-# Use ParamSpec("name", ...) values to make an init value learnable.
-```
-
-### Structure the latent like the state (per-object)
-
-The augmented state is the observable features in ``observation.data``
-*plus* the latent dims you infer: a jug's hidden ``heat`` is just
-another feature of that jug that happens to be unobserved. So **shape
-the latent like ``data`` - object first, then feature**:
-``latent[jug.name]["heat"]`` should read in parallel with
-``observation.get(jug, "water_volume")``. The
-hidden quantities almost always belong to *individual* objects (each jug
-its own heat, each faucet its own spill buffer), and with several
-same-type objects a flat ``{"heat": 0.0}`` collapses them into one shared
-accumulator, which is wrong - exactly as your rules must loop over every
-object rather than indexing ``[0]``.
-
-```python
-LATENT_INIT = {}          # {jug_name: {"heat": value}}, filled lazily
-
-def heat_rule(observation, latent, history, updates, params):
-    jugs = [o for o in observation.data if o.type.name == "jug"]
-    for jug in jugs:
-        jl = latent.setdefault(jug.name, {})    # this jug's hidden dims
-        h = jl.get("heat", 0.0)
-        if on_active_burner(observation, jug, params):
-            h += 1.0
-        jl["heat"] = h
-        updates.setdefault(jug, {})["bubbling_level"] = readout(h, params)
-    return updates
-```
-
-Two deliberate differences from ``data``, though - the latent is **not**
-a typed feature array, and must not be made into one: (1) key by the
-stable string ``obj.name``, not the live ``Object`` (``data`` keys by
-``Object``, but the latent is deep-copied / reconstructed at every search
-node, so a live key risks identity mismatch); (2) keep it a free-form
-JSON-like nest of dicts / numbers with no registered schema - the agent
-invents these dims, and the engine threads and deep-copies whatever
-structure you put here. A genuinely global hidden quantity (a world
-clock, ambient temperature) stays a top-level scalar rather than being
-forced under an object. (Top-level scalar latent entries may be
-``ParamSpec``s to make their initial value learnable; seed each
-per-object slot lazily from such a shared init.)
-
-The type, feature, latent, and parameter names in the examples below
-(`widget`, `fixture`, `progress`, `level`, ...) are illustrative - use
-whatever your prompt digests and the trajectory data actually report
-for your task.
-
-### Two synthesis patterns (agent picks per latent)
-
-**Pattern A - Counter + threshold.** Carry a step counter; flip the
-observable when it crosses a learnable threshold. Same statistical
-shape as a delayed discrete event:
-
-```python
-PARAM_SPECS = [ParamSpec("delay", init_value=33, lo=1, hi=200)]
-LATENT_INIT = {"count": 0}
-
-def count_rule(observation, latent, history, updates, params):
-    active = is_widget_at_fixture(observation)  # observable check
-    fixture_on = observation.get(fixture, "is_on") > 0.5
-    if active and fixture_on:
-        latent["count"] += 1
-    else:
-        latent["count"] = 0
-    fired = latent["count"] >= params["delay"]
-    updates[widget]["progress"] = 1.0 if fired else 0.0
-    return updates
-```
-
-**Pattern B - Physical latent + readout.** Carry an estimate of the
-unobserved quantity; map it through a (typically monotone) function to
-predict the observable. Higher resolution: the observable co-varies
-smoothly with the latent before the symbolic "done" point.
-
-```python
-PARAM_SPECS = [ParamSpec("rate", init_value=0.03, lo=0.0, hi=0.1)]
-LATENT_INIT = {"level": 0.0}
-
-def level_rule(observation, latent, history, updates, params):
-    active = is_widget_at_fixture(observation)
-    fixture_on = observation.get(fixture, "is_on") > 0.5
-    if active and fixture_on:
-        latent["level"] += params["rate"]
-    lvl = latent["level"]
-    # monotone readout: ramps from 0 once `lvl` passes an onset (~0.85)
-    updates[widget]["progress"] = max(0.0, min(1.0, (lvl - 0.85) / 0.15))
-    return updates
-```
-
-**How to choose.** Look at the derived observable in the inspect
-tools:
-- Smooth ramp across many steps ⇒ Pattern B (partial-progress
-  signal; rate identifiable from a single trajectory by slope-fit).
-- Clean discrete flip at a variable tick ⇒ Pattern A may suffice
-  (one learnable threshold, calibrated from the empirical
-  flip-time distribution across trajectories).
-- Mixing is fine: different rules / different latents can use
-  different patterns within the same simulator.
-
-### Keep carried state in `latent`, not in your emitted observables
-
-Anything your rule must remember across steps - a counter, an accumulated
-level, an irreversible "done" flag - belongs in `latent`. Treat the
-observables you write to `updates` as **outputs only**: recompute them
-from `latent` (and base-owned inputs) each step; never read one of your
-own emitted features back in as state. The planner resets and replays
-states during refinement, and only `latent` is guaranteed to be threaded
-across those jumps - an emitted observable may not survive a reset, so a
-rule that latches on its own output can pass a step-by-step rollout yet
-break at refinement time. Patterns A and B above already follow this: the
-observable is a fresh readout of `latent`. (Reading features the base sim
-owns - positions, `is_on`, `is_held` - is fine; those are restored
-faithfully.)
-"""
-
-# Short partial-observability note appended to the agent's first
-# synthesis message under ``CFG.partially_observable`` (see
-# ``_extra_synthesis_message``).
-_RECURRENT_MESSAGE_SECTION = """\
-## Partial observability
-
-Some causally-important quantities may be absent from the agent-visible
-observation entirely (under no name, not even as NaN) - possibly
-several, possibly none. Inspect the trajectories first to judge whether
-any hidden process is at work and which observable features are your
-window into it; then, if any latents are needed, choose Pattern A or
-Pattern B (or mix) to model the underlying dynamics in `latent`.
-"""
-
-# Synthesis system prompt, rendered by
-# ``AgentSimLearningApproach._build_synthesis_system_prompt``: the
-# ``__UPPER_SNAKE__`` placeholders are substituted per instance
-# (observability, env parameter menu, tool surface, subclass extras).
-_SYNTHESIS_SYSTEM_PROMPT_TEMPLATE = """\
-You are synthesizing a parameterized residual-dynamics simulator for a \
-robotic manipulation environment.
-
-A separate PyBullet base sim handles robot movement, grasping, and rigid- \
-body physics. Your simulator handles **residual dynamics** - features \
-that change due to physical or causal processes (gradual level changes, \
-accumulation, propagation between contacting objects, sensor readouts \
-that lag actuators, etc.) that the base sim doesn't model.
-
-## What you produce
-
-One file `simulator.py` (path given in the first message) defining three \
-top-level names:
-
-```python
-RESIDUAL_RULES:    List[Callable]            # rule functions (see signature below)
-PARAM_SPECS:      List[ParamSpec]           # learnable parameters
-RESIDUAL_FEATURES: Dict[str, List[str]]      # {type_name: [feature_names]} your rules predict
-```
-
-`RESIDUAL_FEATURES` defines both the loss scope and the test-time overwrite \
-scope: only the listed `(type, feature)` pairs are scored against \
-observations, and only those are written on top of the base sim at test \
-time. Be honest - listing features your rules don't actually update \
-inflates the loss without giving MCMC anything to optimise.
-__PHYSICAL_PARAMS_SECTION__
-__RULE_SIGNATURE_SECTION__
-
-### Physics commands (`cmds`) - moving rigid bodies through the engine
-
-A rule may declare one extra trailing parameter named `cmds` to gain a \
-second output channel: generic rigid-body actuation executed by the \
-base sim's physics engine.
-
-```python
-def rule(..., cmds):        # same leading args as above, plus `cmds`
-    cmds.apply_force(obj, (fx, fy, fz))    # world-frame Newtons
-    cmds.apply_torque(obj, (tx, ty, tz))   # world-frame N*m
-    cmds.set_velocity(obj, linear=(vx, vy, vz))   # kinematic override
-    cmds.attach(obj_a, obj_b)   # rigid weld at their CURRENT relative pose
-    return updates
-```
-
-`cmds.attach` is the primitive for two bodies that move as ONE rigid \
-body from some event on (a cured glue joint, a latch, a magnetised \
-contact): the engine creates a fixed constraint at the pair's current \
-relative pose and keeps it exactly while the command is re-emitted, so \
-the base sim carries the whole assembly through pick, transport, and \
-contact. Latch the decision in the rule's latent/feature state and \
-re-emit from the latch every step. Do NOT emulate a weld by writing \
-follower poses from the leader's pose each step: pose-written \
-followers do not collide, do not support anything, and swing free \
-during a carry, so plans validate in the belief and fail for real.
-
-Commands act during the NEXT env action and then expire - re-emit \
-them each step the process is active (a wind that blows while a \
-device is on is simply "emit the force whenever `is_on > 0.5`"). \
-A force/torque is re-applied on every physics substep of that action: \
-a continuous push, like real wind or a magnet. The engine resolves \
-everything the commanded motion runs into: contact stops, sliding \
-along surfaces, deflection. Do NOT re-derive collision handling in \
-rule code on top of commands.
-
-**Choosing the channel - run this diagnostic ladder, in order:**
-
-1. **The base sim already produces the motion, but quantitatively \
-off** (bodies move on replay, with drifting angles/timing): the \
-mechanism lives in the engine and the error is a function of its \
-physical parameters. Declare `PHYSICAL_PARAMS` and write NO rule for \
-it.
-2. **A body moves in the data but is inert in base-sim replay** \
-whenever some observable condition holds: the mechanism is missing - \
-an exogenous influence the engine knows nothing about. Model it with \
-force/velocity commands gated on the condition. If the missing \
-mechanism is that two bodies move together rigidly after an event, \
-the command is `cmds.attach`, not a pose rule.
-3. **The feature is not a rigid-body pose at all** (a level, a \
-temperature, a counter): use the feature-update channel.
-
-Never write a rule that overwrites or pushes a body the base sim is \
-already moving - the two fight, and the fit lets the rule absorb \
-physics error. And prefer the simplest force hypothesis first: a \
-body that moves at a constant rate while a condition holds and stops \
-when it ends (or when something is in the way) is a constant force \
-plus engine contacts, not a decaying gust, a one-shot kick, or an \
-edge-triggered pulse.
-
-Declaring `cmds` switches fitting and residual scoring to \
-env-in-the-loop rollout matching automatically (`sim.fit` reports it); \
-command effects cannot be scored teacher-forced. `RESIDUAL_FEATURES` \
-still declares the features your dynamics own - list the pose \
-features your commands move (e.g. `{"ball": ["x", "y"]}`); they are \
-scored against observations but NOT overwritten at test time (the \
-engine moves them).
-
-### Multiple objects of the same type
-
-A task may contain **several objects of the same type** - two widgets, \
-three fixtures, or one of each - and the count varies from task to task. \
-Your rules run once per step over the entire `State`, so they must act on \
-*whatever objects are present*, never a hard-coded slot. Code like \
-`widgets[0]` silently ignores every other instance and breaks the moment \
-a task has more (or fewer) objects than the trajectory you calibrated on.
-
-Gather the relevant objects by type and loop over the binding(s) the rule \
-acts on, emitting updates keyed by the specific object the effect applies \
-to:
-
-```python
-widgets  = [o for o in state.data if o.type.name == "widget"]
-fixtures = [o for o in state.data if o.type.name == "fixture"]
-for widget in widgets:
-    for fixture in fixtures:           # all pairs, or pair each widget
-        if at_fixture(state, widget, fixture, params):   # to its nearest
-            wv = state.get(widget, "progress")
-            updates.setdefault(widget, {})["progress"] = wv + params["rate"]
-```
-
-The same `params` apply to every object of a type: you are learning the \
-shared physics of "a widget", not per-instance constants. If a rule \
-genuinely needs exactly one object (a single global clock, say), assert \
-that rather than silently indexing `[0]`.
-
-### Timing
-
-Each rule fires once per step:
-
-```
-state[t] ──base_sim──▶ draft state[t+1] ──your rules──▶ final state[t+1]
-                                               ^^^^^^^
-                        (only RESIDUAL_FEATURES are overwritten)
-```
-
-Rules see `state[t]`. They cannot see actions, the base sim's draft, or \
-`state[t+2]`. If a feature changes one step *after* its gating event \
-(e.g. an action toggles a gating flag at `t`, but the feature it drives \
-only starts changing at `t+1`), that's an inherent 1-step lag in the \
-data - accept the single boundary residual or model the delay with an \
-extra parameter rather than chasing it with ever-stricter conditions.
-
-### Geometric gates
-
-If a rule's firing condition depends on the relative position of two \
-bodies, do **not** gate on the raw distance between their recorded \
-poses. `obj.x, obj.y` is the recorded pose origin - usually a body's \
-base or frame center - while the point that actually drives the \
-physics (a contact surface, an outlet on the body's side, an \
-end-effector tip, a container opening, a handle) is typically offset \
-from it. That offset lives in the body's **local frame**, so it \
-rotates with the body's `rot` feature; gating on raw origin distance \
-silently bakes in one task's orientation and breaks on any task where \
-the fixture is rotated differently.
-
-**Default to a learned, rotation-aware anchor offset.** Express every \
-two-body geometric gate as a distance to an *anchored* point - the \
-fixture origin plus a local-frame offset rotated into the world frame \
-by the fixture's `rot` - with the offset declared as learnable params:
-
-```python
-PARAM_SPECS = [
-    # Functional point offset, in the fixture's LOCAL frame:
-    ParamSpec("fixture_local_dx",       0.0,  lo=-0.3, hi=0.3),
-    ParamSpec("fixture_local_dy",       0.0,  lo=-0.3, hi=0.3),
-    ParamSpec("widget_at_fixture_dist", 0.10, lo=0.0,  hi=0.4),
-]
-
-# `fixture`, `widget`: the relevant object pair (bind as your rule needs).
-__RESIDUAL_RULE_SIGNATURE__
-    rot = state.get(fixture, "rot")
-    cos_r, sin_r = np.cos(rot), np.sin(rot)
-    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
-    local_offset = np.array([params["fixture_local_dx"],
-                             params["fixture_local_dy"]])
-    origin = np.array([state.get(fixture, "x"), state.get(fixture, "y")])
-    anchor = origin + rot_mat @ local_offset  # world-frame point
-    widget_xy = np.array([state.get(widget, "x"), state.get(widget, "y")])
-    if np.linalg.norm(widget_xy - anchor) < params["widget_at_fixture_dist"]:
-        ...  # fire
-```
-
-If the functional point really does coincide with the recorded origin, \
-the fit drives the offsets to ~0 - no harm done. A threshold-only gate \
-(no offset) is the exception: use one only after you have positively \
-confirmed the recorded origin *is* the functional point. Share the \
-offset and distance params with the gating predicate so the rule and \
-predicate anchor to the same point.
-
-**Before committing any geometric gate**, run the threshold-fitting \
-protocol in CLAUDE.md: bucket trajectory steps by whether the gated \
-effect actually fired and require a clear margin between the buckets - \
-overlap or a knife-edge gap means the gate references the wrong point, \
-so add or refit the anchor offset rather than nudging the threshold. \
-To find the offset, __SCENE_VIZ_HINT__; the gap between the origin and \
-the effect-firing cluster is the offset.
-
-### ParamSpec
-
-```python
-ParamSpec(name: str, init_value: float,
-          lo: Optional[float] = None, hi: Optional[float] = None)
-```
-
-Bounds shape both the MCMC prior and the warm-start clamp. Set `lo=0.0` \
-for non-negative rates, etc.
-
-### Pre-injected when `simulator.py` is exec'd
-
-`numpy as np`, `ParamSpec`. Import anything else at the top of the file. \
-The data classes (`State`, `Object`, `Action`, ...) come from \
-`predicators.structs`; source is in the reference file linked in the \
-first message.
-
-## Tools
-
-`Write` / `Edit` `simulator.py` is your normal coding loop. Every \
-successful write is snapshotted to \
-`simulator_versions/cycle_XXX_vers_YYY_simulator.py` (deduped by \
-content; ``XXX`` is the current cycle, ``YYY`` resets per cycle). \
-`sim.fit` / `sim.residuals` (and the probe's candidate-model refit) \
-load the file fresh on every call and prefix their reports with \
-`[cycle_XXX_vers_YYY]` so you and reviewers can diff iterations.
-
-- `run_python(code)` - ad-hoc data exploration AND validation. \
-`trajectories`, `np`, `ParamSpec` in scope; when the learn message \
-states a task objective, `evaluate_trajectory(states, actions=None, \
-task_idx=0)` scores a state sequence with the env's ground-truth \
-evaluator (returns reward / solved; on your own simulator's rollouts \
-the verdict is only as good as the simulator). The `sim` probe over \
-your CANDIDATE simulator also lives here: `sim.fit()` (parameter \
-fitting + report; cheap inner-loop signal), `sim.residuals()` \
-(per-feature breakdown: mismatch counts, mean / max abs error, \
-vs-baseline improvement (negative ⇒ rules are adding error), worst-N \
-example transitions - diagnostic for *which* rule to fix), \
-`sim.refine` (backtracking parameter search on a plan sketch), \
-`sim.run` (forward rollout with subgoal checking). **Does not** \
-define rules.
-
-`sim.fit` and the refine-then-run protocol test complementary \
-things - pointwise accuracy vs. goal reachability. A rule can have \
-ε-small SSE and still get a saturation threshold or alignment cap *just* \
-wrong enough that refinement can't satisfy a subgoal. Use `sim.fit` + \
-`sim.residuals` as the fast inner loop, and refine-then-run as the \
-slow goal-relevant gate before declaring done.
-
-### Refinement vs. forward validation (read before tuning a threshold)
-
-Validation is two checks under the same option model. `sim.refine` \
-samples continuous params with up to 50 attempts per \
-parametric step and snapshots state at each backtrack - failures are \
-isolated per step. The forward pass - one continuous `sim.run` of the \
-refined plan, state carrying forward across all options, subgoal \
-annotations checked per step - matches how test time will execute it. \
-Any divergence between the \
-two indicates the learned model is *more permissive* than the env's \
-effective behavior: refinement's looser gates accept a Place/Wait \
-that the env-driven rollout won't actually achieve.
-
-When `sim.refine` passes but the continuous `sim.run` reports a \
-`SUBGOAL NOT REACHED` (or the goal check fails), the failure mode is \
-almost always one of these:
-
-1. **A learned gate threshold is wider than the env's effective \
-threshold.** Example: the env's residual rule only fires when the \
-widget-to-fixture distance < 0.05, but you set \
-`widget_at_fixture_dist = 0.063` for "safety margin". Refinement \
-accepts a Place at distance 0.05–0.063 (your `WidgetAtFixture` \
-predicate is true and your learned rule fires); forward validation \
-runs the same Place, the env's rule never fires (distance > env \
-threshold), and Wait runs to its step cap without `WidgetReady` \
-holding. **Fix:** tighten the gate to match the env's empirical \
-boundary, do not widen for slack.
-2. **A wait-termination cutoff fires before the env-side feature \
-catches up.** Example: `WidgetReady = process_value >= 0.99` fires at \
-the learned simulator's step 34 (process_value=0.9996), but the env's \
-goal-check requires the underlying feature to reach 1.0 - refinement's \
-subgoal passes, but the final-state goal check on env state fails. \
-**Fix:** align the predicate's cutoff with the env's effective \
-cutoff, *and* confirm by re-running plan refinement after the change.
-
-**Rule of thumb:** when in doubt, *tighten* learned thresholds toward \
-the env's empirical boundary, never loosen them. Widening hides \
-discrepancies during refinement and reveals them at test time as \
-0-solve regressions.
-__SYNTHESIS_PROMPT_EXTRA__
-## Plan format for `sim.refine` / `sim.run`
-
-One option call per line, **with every option argument supplied and using \
-typed object references** (`obj:type`), matching exactly the Options \
-digest in your prompt. Use that digest (or `run_python` over a trajectory) \
-to read off the right names and arities - the parser is strict and \
-silently omitting an argument will not be auto-filled. Example:
-
-```
-PickWidget(robot:robot, widget0:widget)
-Place(robot:robot) -> {WidgetAtFixture(widget0:widget, fixture0:fixture)}
-ActivateFixture(robot:robot, fixture0:fixture)
-Wait(robot:robot) -> {WidgetReady(widget0:widget)}
-...
-```
-
-(The names above are illustrative - use whatever options, types, and \
-predicates your prompt digests actually list for your task.) Insert a \
-`Wait` after any action that triggers a delayed process (gradual \
-accumulation, propagation, sensor catch-up) so your rules have steps to \
-fire on.
-
-**Subgoal annotations** (`-> {Atom(obj:type, ...)}` after a step) are \
-optional in general but **effectively required after open-ended skills \
-like `Place`**. Without one the backtracking search has no preference for \
-*where* to put the object, so a `Place; Wait` pair will refine cleanly \
-but skip past the relevant target location and your rules never fire - \
-the run looks like a rule bug but is actually a missing subgoal. For \
-`Wait`, the annotation also specifies when the wait should terminate; \
-prefix an atom with `NOT` if it should become false.
-
-## Workflow
-
-1. Explore data with `run_python` - what features change per step, \
-which ones aren't explained by the base sim.
-2. `Write` `simulator.py`; `Edit` to iterate.
-3. Score with `sim.fit()`, then `sim.residuals()` to find \
-diverging features. Negative `vs base` ⇒ a rule is actively hurting - \
-usually a wrong gate or sign.
-4. When SSE is plausible, propose an option-skeleton plan and validate: \
-`sim.reset(task_idx=i)`, `sim.refine(plan, require_goal=True)`, then a \
-continuous `sim.run` of the refined plan from a fresh \
-`sim.reset(task_idx=i)`. A stuck refine step means the rules gating \
-its subgoal atoms are too tight or too loose; a refine-pass whose \
-`sim.run` diverges means a rule is too permissive. Fix and \
-re-validate - do not declare done until BOTH pass.\
-__WORKFLOW_EXTRA__
-"""
-
 
 def _fit_space_dist(a: float, b: float, scale: str) -> float:
     """Distance between two param values in their fit space.
@@ -1034,17 +477,25 @@ def _extra_synthesis_message(self, extra_paths: Dict[str, str]) -> str:
         ``super()`` so the note survives.
         """
         del extra_paths
-        return _RECURRENT_MESSAGE_SECTION if CFG.partially_observable else ""
+        if CFG.partially_observable:
+            return learn_prompts.render_partial_observability_message()
+        return ""
 
-    def _extra_synthesis_system_prompt(self) -> str:
-        """Return text to append to the synthesis system prompt.
+    def _extra_synthesis_system_prompt_sections(self) -> List[str]:
+        """Sections a subclass adds to the synthesis system prompt.
 
-        Under ``CFG.partially_observable`` this is the simulator-side
-        recurrent-rules tutorial (``LATENT_INIT``, latent shaping,
-        Patterns A/B); subclasses that override MUST chain via
-        ``super()`` so the tutorial survives.
+        Inserted after the validation guidance and before the recurrent
+        rules tutorial (partial observability) and the plan format.
+        Subclasses that override MUST chain via ``super()``.
         """
-        return _RECURRENT_PROMPT_SECTION if CFG.partially_observable else ""
+        return []
+
+    def _extra_synthesis_latent_sections(self) -> List[str]:
+        """Sections a subclass adds after the recurrent-rules tutorial.
+
+        Only rendered under ``CFG.partially_observable``.
+        """
+        return []
 
     def _post_synthesis_loading(
         self,
@@ -1791,7 +1242,7 @@ def score_atom_disagreement(self, state: State,
         i.e. an informative experiment. Returns 0.0 when the ensemble is
         trivial (<=1 member) or no atoms are given.
 
-        Wired into refinement as the info-scorer for the agent_bilevel
+        Wired into refinement as the info-scorer for the agent_model_based
         explorer; a read-only query that leaves ``_fitted_params``
         unchanged on return.
         """
@@ -2158,262 +1609,63 @@ def _build_synthesis_learn_message(
     ) -> str:
         """Compose the synthesis session's first user message.
 
-        Reads the just-opened session's tool names, so the session must
-        be open before this is called.
+        Gathers this cycle's data roster, digests, and reports and
+        renders ``learn_message.md``. Reads the just-opened session's
+        tool names, so the session must be open before this is called.
         """
         n_trajs = len(trajectories)
         n_demos = sum(1 for t in trajectories if t.is_demo)
-        n_interaction = n_trajs - n_demos
-        predicate_listing = self._format_predicate_signatures(
-            self._get_all_predicates())
-        # Static per-session digests, injected instead of costing a tool
-        # turn (see the roster note in _get_synthesis_tool_names).
-        types_digest = render_types_digest(self._tool_context.types)
-        options_digest = render_options_digest(
-            self._tool_context.options,
-            gt_options_ref_path=self._tool_context.gt_options_ref_path)
-        trajectory_listing = self._format_trajectory_listing(trajectories)
-        prior_state_block = self._format_prior_state_block(paths.base)
         # Start-of-session divergence report: when a prior model exists,
         # score it (params refit to ALL data, so what remains is the
         # structural gap) before the agent's first turn - the session
         # then starts from "here is where the model breaks" instead of
         # spending turns rediscovering it. The same report stays callable
-        # as `sim.residuals()` against every subsequent edit, so this is
-        # the first data point of an iteration loop, not a one-shot.
+        # as `sim.residuals()` against every subsequent edit. With no
+        # prior model the "prior" is the bare base simulator and every
+        # mismatch is an unmodeled mechanism.
+        prior_state_block = self._format_prior_state_block(paths.base)
         divergence_block = ""
         if self._tool_context.probe_residuals_provider is not None:
             try:
                 report = self._tool_context.probe_residuals_provider(
                     max_transitions=100000, fit_params=True)
-                if prior_state_block:
-                    divergence_block = (
-                        "## Where the prior model diverges from the data\n"
-                        "Computed just now from the prior cycle's "
-                        "`simulator.py` with its params refit to all "
-                        "trajectories above - remaining mismatches need "
-                        "structural fixes, not tuning. Re-score any edit "
-                        "with `sim.residuals()` (same report, current "
-                        "file):\n\n"
-                        f"{report}\n\n")
-                else:
-                    # Cycle 0: no prior model, so the "prior" is the bare
-                    # base simulator and every mismatch is an unmodeled
-                    # mechanism - the map of what the first simulator.py
-                    # needs to cover.
-                    divergence_block = (
-                        "## Where the base simulator diverges from the "
-                        "data\n"
-                        "No prior model exists yet, so every feature "
-                        "below is an unmodeled mechanism: this is the map "
-                        "of what your `simulator.py` needs to cover, each "
-                        "with its worst transition located in the data. "
-                        "Re-score any edit with `sim.residuals()` (same "
-                        "report, current file):\n\n"
-                        f"{report}\n\n")
+                divergence_block = learn_prompts.render_divergence_block(
+                    report, has_prior_model=bool(prior_state_block))
             except Exception as e:  # pylint: disable=broad-except
                 logger.warning("Skipping start-of-session residual report: %s",
                                e)
-        objective_block = self._format_objective_block()
-        simulator_file_for_agent = paths.simulator_file_for_agent
-        # The probe rides inside run_python's namespace (one exec
-        # namespace per session): `trajectories` is the recorded DATA,
-        # `sim` forward-rolls the CANDIDATE simulator. One sentence so
-        # the two are not conflated; details live in the tool
-        # description.
-        probe_note = (
-            "\n\nThe `sim` probe inside `run_python` forward-rolls "
-            "the CANDIDATE simulator you are editing at the params "
-            "of your last `sim.fit()` - it never fits on its own, so "
-            "after a structural edit its results are marked UNFITTED "
-            "until you run `sim.fit()` on the current file; pass "
-            "task_idx explicitly to `sim.reset`, `sim.task(task_idx)` "
-            "for a task digest). Its rollouts "
-            "are candidate predictions - do not mix them up with the "
-            "recorded real `trajectories`. Usage and the validation "
-            "protocol are in the system prompt's Tools section.")
-        # Tool surface of the (just-opened) synthesis session, rendered
-        # the same way the solve/explore prompts list theirs.
-        # ``tool_names`` already merges the sandbox built-ins with the
-        # declared MCP subset, prefix-stripped.
-        tools_block = ""
         session_tool_names = (self._agent_session.tool_names
                               if self._agent_session is not None else [])
-        if session_tool_names:
-            tool_listing = "\n".join(f"  - {t}" for t in session_tool_names)
-            tools_block = f"## Available Tools\n{tool_listing}\n\n"
-        base_sim_block = ""
-        if base_sim_refs:
-            ref_listing = "\n".join(f"  - {r}" for r in base_sim_refs)
-            base_sim_block = (
-                "\nThe BASE SIMULATOR's own source code is available "
-                "(read-only) - the robot knows its own simulator:\n"
-                f"{ref_listing}\n"
-                "These files are byte-identical to the code your base-sim "
-                "rollouts execute: scene geometry and constants, body "
-                "construction, stepping, and state read/write. What they "
-                "deliberately do NOT contain is the environment's hidden "
-                "domain-specific step - the residual dynamics you are "
-                "here to model - nor task generation or goal semantics. "
-                "Use them to ground hypotheses (masses, damping, substeps "
-                "per action, how switches toggle) instead of re-measuring "
-                "those from data.\n")
-        message = f"""\
-Synthesize a residual dynamics simulator for this environment. \
-There are {n_trajs} trajectories ({len(obs_triples)} step \
-transitions) available: {n_demos} oracle demonstration(s) (goal \
-reached by construction) and {n_interaction} interaction \
-trajectory/ies (collected during online learning; some may have \
-failed to reach the goal).
-
-{trajectory_listing}
-Each trajectory carries a `train_task_idx`. You can query the \
-ground-truth goal-atom check by calling \
-`is_goal_state(state, task_idx)`. Equivalently \
-`train_tasks[task_idx].goal_holds(state)`. This checks a single \
-STATE for the goal atoms only - reaching the goal atoms does not by \
-itself mean an episode is solved; when a task objective is stated \
-below, score full trajectories with `evaluate_trajectory`. Use \
-`is_goal_state` to (1) confirm which trajectories reached the goal \
-atoms and (2) treat failed interaction trajectories as \
-counterexamples - places where your predicate or rule said "this \
-should work" but the env disagreed.
-
-{objective_block}{prior_state_block}{divergence_block}Data-structure \
-source code is at: \
-{structs_ref}
-{base_sim_block}
-A residual scan between the base simulator's prediction and the \
-observed next state suggests these features carry residual dynamics \
-(starting hint, may include base-sim jitter - refine as you go):
-{inferred_hint}
-
-## Available Predicates (for subgoal annotations)
-{predicate_listing}
-
-Subgoal annotations in your plans for `sim.refine` / `sim.run` \
-must reference these predicate names with matching arity and types. \
-Any threshold or condition you bake into a rule must be consistent \
-with what the predicate's classifier actually checks, or refinement \
-will reject parameter samples that look correct on paper.
-
-## Object Types
-{types_digest}
-
-## Options
-Plans (for `sim.refine` / `sim.run`) and rules must match these \
-typed signatures and parameter boxes exactly:
-{options_digest}
-
-{tools_block}Read the data-structures file first, then explore the trajectory \
-data with `run_python` (variables: `trajectories`, `train_tasks`, \
-`is_goal_state`, `describe_trajectory(traj_idx)` for a per-timestep \
-digest, `np`, `ParamSpec`, plus `evaluate_trajectory` when a \
-task objective is stated above). Write your simulator to \
-`{simulator_file_for_agent}` - define RESIDUAL_RULES, PARAM_SPECS, \
-and RESIDUAL_FEATURES there. Begin the file with a short DECISION \
-RECORD comment stating your key modeling choices and the evidence \
-behind them: which dynamics the base sim carries vs. your process \
-rules, which features the rules own, any latent structure, and any \
-other structural commitments (e.g. whether base-sim parameters are \
-declared for identification, when the environment discloses them). \
-Later cycles read this record before deciding what to keep. Iterate \
-with `Edit` and re-score; every successful write is snapshotted and \
-version-tagged (see the system prompt's Tools section).{probe_note}
-
-Evidence discipline for rules that WRITE physical state (poses, \
-velocities): ground them in recorded transitions the base sim \
-mispredicts. A mechanism you suspect but have never observed \
-end-to-end in the data is a HYPOTHESIS, and what to do with it \
-depends on whether the goal needs it. When the goal is reachable \
-without it, record it in the decision record with the experiment \
-that would confirm it and ship no rule: a speculative pose-writer \
-fabricates states the environment never produces, and plans \
-validated against it fail in reality. When the goal REQUIRES it - \
-without the mechanism the goal is unreachable in your model (an \
-assembly that must be carried as one body, a latch that must hold, \
-an activation that must take effect) - omitting it is NOT the \
-cautious choice: it turns "unknown" into "impossible" for every \
-consumer of the model, so the explorer can no longer certify a goal \
-attempt and the test session proves the goal unreachable and gives \
-up. Ship a goal-required mechanism as a LABELLED HYPOTHESIS: a rule \
-whose trigger geometry and timing are declared ParamSpecs at your \
-best physical estimate with honest ranges (the ensemble spreads over \
-them and the capture gate validates plans under that spread), a \
-HYPOTHESIS marker on it in the decision record, and its confirming \
-experiment as the FIRST entry of open_questions.md, written so that \
-the next exploration's goal attempt exercises it. The converse error \
-is just as costly: do not delete a rule whose mechanism you have \
-confirmed merely because one fit metric is noisy - decide from the \
-recorded evidence either way.
-
-Work through EVERY divergence this cycle's new trajectories reveal \
-in this one session: enumerate each mechanism the episodes \
-exercised, reconcile it against the model, and fix all confirmed \
-errors now - not just the one that blocked the last test or the \
-first one you find. Each error deferred to the next cycle costs a \
-full explore-learn-test round trip, which is the main thing that \
-makes learning slow.
-
-Declare your uncertainty. A learned constant whose supporting data \
-leaves real doubt - a one-sided bracket, a knife-edge margin, a \
-handful of samples - must be a declared ParamSpec spanning that \
-honest range, never a bare literal baked into rule code: declared \
-params get fitted posteriors, the exploration ensemble spreads over \
-them, and the capture gate re-validates every submitted plan under \
-those posterior members, so an operating point that only works at \
-your point estimate is caught in simulation instead of failing a \
-real test episode. A literal is earned only once the data brackets \
-the constant from both sides with margin to spare.
-
-Before ending the session, run `sim.fit()` on the final file (that \
-fit IS the model deployed for this cycle - end without one and the \
-harness fits on its own and logs the deviation; a GO verdict on \
-UNFITTED values is worthless) and then a GO/NO-GO check: refine a \
-full solve of the train task in your candidate simulator and validate \
-it with several trials (`sim.refine` / `sim.run(plan, trials=5)`). \
-Record the verdict in the decision record together with the plan's \
-WEAKEST margin - the smallest distance from any step's operating \
-point to a learned threshold - compared against the measured \
-execution scatter. NO-GO, or a margin thinner than the scatter, \
-means the next test episode will likely fail: put exactly what is \
-missing at the top of `./open_questions.md`. A GO that rests on a \
-hypothesised mechanism says so in the verdict; it is still a GO - \
-the plan it certifies is the experiment that confirms or refutes \
-the hypothesis in the real environment.
-
-Also maintain `./open_questions.md`: a short RANKED ledger of the \
-model's remaining uncertainties - mechanisms never observed, \
-thresholds whose supporting data is one-sided or knife-edge, \
-hypotheses awaiting confirmation - each entry naming the cheapest \
-real-environment experiment that would settle it, as a concrete \
-option sequence or parameter ladder (e.g. "place pairs at spacings \
-bracketing the believed window"), plus what to measure. The next \
-exploration phase receives this file verbatim and designs its \
-episodes from it, so write entries as runnable experiment specs, \
-not prose; DELETE entries this cycle's data settles. An empty \
-ledger declares the model believed complete everywhere.
-
-Separately, maintain `./strategy.md`: a natural-language DOMAIN \
-STRATEGY for solving tasks in this environment - the recommended \
-approach and step ordering, the mechanisms that matter and how to \
-trigger them, parameter formulas expressed relative to the scene \
-(never hard-coded to one task's coordinates), and known pitfalls. \
-Future solve sessions read it as advisory reference (clearly framed \
-as possibly wrong), so state uncertainty honestly. Unlike the \
-journal (`./journal.md`, an append-only log of facts and \
-measurements that you may also add to), strategy.md is a LIVING \
-document: REWRITE it \
-freely this cycle wherever new evidence corrects or supersedes \
-earlier advice, rather than appending contradictions."""
-
+        extra_messages = []
         extra_message = self._extra_synthesis_message(extra_paths)
         if extra_message:
-            message = message + "\n\n" + extra_message
+            extra_messages.append(extra_message)
         if self._do_synthesize_samplers:
-            message = message + "\n\n" + \
-                self._sampler_synthesis_message(sampler_paths)
-        return message
+            extra_messages.append(
+                self._sampler_synthesis_message(sampler_paths))
+        return learn_prompts.build_learn_message(
+            n_trajs=n_trajs,
+            n_transitions=len(obs_triples),
+            n_demos=n_demos,
+            n_interaction=n_trajs - n_demos,
+            trajectory_listing=self._format_trajectory_listing(trajectories),
+            structs_ref=structs_ref,
+            inferred_hint=str(inferred_hint),
+            predicate_listing=self._format_predicate_signatures(
+                self._get_all_predicates()),
+            types_digest=render_types_digest(self._tool_context.types),
+            options_digest=render_options_digest(
+                self._tool_context.options,
+                gt_options_ref_path=self._tool_context.gt_options_ref_path),
+            simulator_file=paths.simulator_file_for_agent,
+            objective_block=self._format_objective_block(),
+            prior_state_block=prior_state_block,
+            divergence_block=divergence_block,
+            base_sim_block=learn_prompts.render_base_sim_block(base_sim_refs
+                                                               or []),
+            tools_block=learn_prompts.render_tools_block(session_tool_names),
+            extra_messages=extra_messages,
+        )
 
     def _load_synthesis_artifacts(
         self,
@@ -3661,23 +2913,7 @@ def _format_objective_block(self) -> str:
             (t.evaluator.objective_description()
              for t in self._train_tasks if t.evaluator is not None
              and t.evaluator.objective_description()), "")
-        if not description:
-            return ""
-        return f"""\
-## Task objective (env ground-truth reward)
-{description}
-
-The trajectory roster above shows each interaction episode's \
-env-computed reward. In `run_python`, \
-`evaluate_trajectory(states, actions=None, task_idx=0)` scores any \
-state sequence with the same ground-truth evaluator - a collected \
-trajectory's `states`/`actions`, or a rollout of YOUR simulator \
-(there the verdict is only as trustworthy as your simulator). It \
-returns {{reward, solved}}. `solved` means the episode is scored as \
-a success; a rollout can reach the goal atoms and still be \
-solved=False.
-
-"""
+        return learn_prompts.render_objective_block(description)
 
     def _format_prior_state_block(self, base: str) -> str:
         """Tell the agent about any simulator/predicates left over from a
@@ -3689,34 +2925,11 @@ def _format_prior_state_block(self, base: str) -> str:
         for ``simulator.py`` / ``predicates.py``.
         """
         prior: List[str] = []
-        sim_path = os.path.join(base, "simulator.py")
-        preds_path = os.path.join(base, "predicates.py")
-        if os.path.isfile(sim_path):
+        if os.path.isfile(os.path.join(base, "simulator.py")):
             prior.append("`./simulator.py`")
-        if os.path.isfile(preds_path):
+        if os.path.isfile(os.path.join(base, "predicates.py")):
             prior.append("`./predicates.py`")
-        if not prior:
-            return ""
-        joined = " and ".join(prior)
-        return f"""\
-Prior cycle state: {joined} already exist in the sandbox from a previous \
-learning cycle. Read them first - they are the previous cycle's committed \
-result and a reasonable starting point for incremental refinement (though \
-a fresh rewrite is fine if the prior approach looks fundamentally wrong). \
-Structural decisions are NOT binding across cycles: re-read the decision \
-record at the top of `simulator.py` and re-decide the architecture itself \
-- what the base sim carries vs. what the rules model, which features the \
-rules own, the latent structure, and whether disclosed base-sim \
-parameters should be identified - rather than only tuning what exists. \
-In particular, if the trajectory roster shows goal-reaching episodes \
-scored solved=0, suspect a structural modeling error (e.g. mis-calibrated \
-base physics that your rules only paper over near the fit data), not just \
-parameter values. Earlier versions are in `./simulator_versions/` and \
-`./predicates_versions/` (named `cycle_XXX_vers_YYY_*.py`); \
-cross-reference the trajectory roster's provenance tags against those \
-files to see exactly which rules and predicates produced each failed plan.
-
-"""
+        return learn_prompts.render_prior_state_block(prior)
 
     @staticmethod
     def _load_simulator_from_module_file(
@@ -4091,35 +3304,24 @@ def step(state: State, action: Action) -> State:
         return make_stepper
 
     def _build_synthesis_system_prompt(self) -> str:
-        """Render the synthesis system prompt from the module template.
-
-        Substitutes the placeholders that vary per instance: the
-        rule-signature blocks (flag-gated on
-        ``CFG.partially_observable`` - under the flag the prompt
-        presents only the recurrent 5-arg form as canonical), the
-        optional PHYSICAL_PARAMS section (env parameter menu), the
-        scene-visualization hint (tool surface), and the subclass extra
-        section.
-        """
-        prompt = _SYNTHESIS_SYSTEM_PROMPT_TEMPLATE
-        prompt = prompt.replace("__RULE_SIGNATURE_SECTION__",
-                                self._rule_signature_section())
-        prompt = prompt.replace("__RESIDUAL_RULE_SIGNATURE__",
-                                self._residual_rule_signature())
-        prompt = prompt.replace("__PHYSICAL_PARAMS_SECTION__",
-                                self._physical_params_prompt_section())
-        prompt = prompt.replace("__SCENE_VIZ_HINT__", self._scene_viz_hint())
-        prompt = prompt.replace("__WORKFLOW_EXTRA__",
-                                self._synthesis_workflow_extra())
-        extra = self._extra_synthesis_system_prompt()
-        extra_block = "\n" + extra.rstrip() + "\n" if extra else ""
-        prompt = prompt.replace("__SYNTHESIS_PROMPT_EXTRA__", extra_block)
-        # The template (and the blocks spliced into it) is authored as
-        # hard-wrapped markdown; the rendered prompt keeps one line per
-        # paragraph like every other phase's prompt.
-        # pylint: disable-next=import-outside-toplevel
-        from predicators.agent_sdk.sandbox_prompts import unwrap_prose_lines
-        return unwrap_prose_lines(prompt)
+        """Compose the synthesis system prompt from the templates.
+
+        Per-instance choices: the rule signature (flag-gated on
+        ``CFG.partially_observable``, which also swaps the env's
+        observation and the GT simulator module, so prompt and world
+        never disagree; under the flag only the recurrent 5-arg form is
+        shown), the optional PHYSICAL_PARAMS section (env parameter
+        menu), the scene-visualization hint, and the subclass extras.
+        """
+        return learn_prompts.build_learn_system_prompt(
+            partially_observable=CFG.partially_observable,
+            residual_rule_signature=self._residual_rule_signature(),
+            scene_viz_hint=self._scene_viz_hint(),
+            physical_params_section=self._physical_params_prompt_section(),
+            extra_sections=self._extra_synthesis_system_prompt_sections(),
+            latent_extra_sections=self._extra_synthesis_latent_sections(),
+            workflow_extra=self._synthesis_workflow_extra(),
+        )
 
     def _synthesis_workflow_extra(self) -> str:
         """Extra text appended to the Workflow list.
@@ -4159,118 +3361,14 @@ def _physical_params_prompt_section(self) -> str:
         getter = getattr(base_env, "get_physical_param_info", None)
         if callable(getter):
             info = getter() or {}
-        if not info:
-            return ""
-        lines = [
-            "",
-            "## Base-sim system identification "
-            "(`PHYSICAL_PARAMS`) - decide, don't default",
-            "",
-            "The base sim's rigid-body physics is itself parameterized, "
-            "and its built-in values may be MIS-CALIBRATED (the real "
-            "environment may run different physics). It reveals these "
-            "tunable parameters:",
-            "",
-        ]
-        for name, meta in info.items():
-            scale_note = (", fitted in log-space"
-                          if meta.get("scale") == "log" else "")
-            lines.append(f"- `{name}` (built-in {meta['default']:.4g}, fit "
-                         f"box [{meta['lo']:.4g}, {meta['hi']:.4g}]"
-                         f"{scale_note}): {meta['description']}")
-        lines.extend([
-            "",
-            "If observed trajectories diverge from the base sim on "
-            "*rigid-body motion itself* (not a hidden process layered on "
-            "top of it), declare a fourth export:",
-            "",
-            "```python",
-            "PHYSICAL_PARAMS: List[ParamSpec]  # subset of the names "
-            "above; init = your hypothesis, lo/hi from the box",
-            "```",
-            "",
-            "Guidance:",
-            "",
-            "- **This decision requires open-loop evidence - in either "
-            "direction.** Per-step (teacher-forced) residuals CANNOT "
-            "rule a mis-set physical parameter in or out: they predict "
-            "each step from the RECORDED state, so compounding "
-            "divergence - exactly how a wrong friction or mass "
-            "manifests - is invisible to them. Near-zero per-step "
-            "residuals are fully compatible with rollouts that are "
-            "hundreds of times worse than at the correct value. Before "
-            "deciding, run `sim.residuals(rollout=True, "
-            "sweep_params='all')` (or name the suspect parameters): it "
-            "replays the recorded trajectories free-running and sweeps "
-            "each requested parameter across its box; "
-            "`phys_params={name: value}` instead scores one "
-            "hypothesized point. Declare a parameter whose sweep is "
-            "materially better away from the baseline; a flat sweep is "
-            "honest evidence the data cannot constrain it. Omitting "
-            "PHYSICAL_PARAMS is justified by a flat rollout sweep, "
-            "never by small per-step residuals.",
-            "- **Undeclared parameters keep their built-in values in "
-            "every base-sim rollout** - including an evaluator's "
-            "verification replay deciding what counts as a SOLVE. Your "
-            "rules ride on top of the base sim everywhere, but rules "
-            "fit to observed data can only compensate for a mis-set "
-            "built-in value near that data; identifying the parameter "
-            "fixes the substrate itself.",
-            "- **Start with ONE parameter** - the single one with a "
-            "physical story for the observed residual (e.g. cascades "
-            "stopping short of the sim's prediction implicates sliding "
-            "friction) - and add another only if the calibrated fit "
-            "still leaves structure unexplained. Co-declared parameters "
-            "can compensate each other's errors along a data-equivalent "
-            "ridge, so every extra parameter costs fit budget and adds a "
-            "way to be confidently wrong; a parameter cannot be "
-            "identified from data that does not exercise it (a collision "
-            "parameter needs collisions).",
-            "- `sim.fit()` returns a per-parameter identifiability "
-            "report (posterior contraction). Drop any parameter reported "
-            "NOT identified or insensitive - its fitted value is "
-            "arbitrary noise. A parameter reported 'anchored' moved only "
-            "to compensate the others and was reverted to its baseline; "
-            "keep it only if you can collect an interaction that excites "
-            "it specifically.",
-            "- With `PHYSICAL_PARAMS` declared, the fit switches to "
-            "matching **free-running rollouts** of full trajectories "
-            "(momentum accrues in-sim, which the per-step teacher-forced "
-            "fit destroys), and physical + rule parameters are fit "
-            "**jointly** in one posterior, so rules cannot silently "
-            "absorb physics error.",
-            "- A physics-only artifact is valid: `RESIDUAL_RULES = []` and "
-            "`PARAM_SPECS = []` with a non-empty `PHYSICAL_PARAMS` means "
-            "the calibrated base sim carries all the dynamics. "
-            "`RESIDUAL_FEATURES` must still be declared - it defines which "
-            "features the rollout is scored on (e.g. the pose features "
-            "of the objects whose motion you are calibrating).",
-            "- After the fit, the identified values are applied to the "
-            "planning base env, so probe rollouts and "
-            "test-time planning use the calibrated physics.",
-        ])
-        return "\n".join(lines) + "\n"
-
-    def _rule_signature_section(self) -> str:
-        """Markdown for the '### Rule signature' block.
-
-        Decided by ``CFG.partially_observable`` - the same flag that
-        swaps the env's observation and the GT simulator module, so
-        prompt and world can never disagree. Fully observable: the
-        legacy 3-arg signature. Partially observable: the recurrent
-        5-arg signature only, so the prompt never advertises the 3-arg
-        form as canonical.
-        """
-        if CFG.partially_observable:
-            return _PO_RULE_SIGNATURE_SECTION
-        return _FO_RULE_SIGNATURE_SECTION
+        return learn_prompts.render_physical_params_section(info)
 
     def _residual_rule_signature(self) -> str:
         """The ``def`` line used in the geometric-gate example.
 
-        Matches the signature advertised by
-        :meth:`_rule_signature_section` so the worked example doesn't
-        contradict the canonical signature.
+        Matches the canonical rule signature the prompt advertises
+        (``CFG.partially_observable`` selects it) so the worked example
+        doesn't contradict it.
         """
         if CFG.partially_observable:
             return ("def residual_rule(observation, latent, history, "
diff --git a/predicators/approaches/agent_sim_predicate_invention_approach.py b/predicators/approaches/agent_sim_predicate_invention_approach.py
index c3b2d647b..0919aad33 100644
--- a/predicators/approaches/agent_sim_predicate_invention_approach.py
+++ b/predicators/approaches/agent_sim_predicate_invention_approach.py
@@ -34,13 +34,14 @@
         --approach agent_sim_predicate_invention --seed 0 \
         --num_train_tasks 10 --num_test_tasks 5 \
         --partially_observable True \
-        --num_online_learning_cycles 2 --explorer agent_plan
+        --num_online_learning_cycles 2 --explorer agent_model_free
 """
 
 import logging
 import os
 from typing import Any, Dict, FrozenSet, List, Set, Tuple
 
+from predicators.agent_sdk import learn_prompts
 from predicators.agent_sdk.tools import _SnapshotTarget, \
     finalize_versioned_snapshot, make_predicate_quality_loader
 from predicators.approaches.agent_sim_learning_approach import \
@@ -162,36 +163,10 @@ def _build_write_snapshot_targets(
         return targets
 
     def _extra_synthesis_message(self, extra_paths: Dict[str, str]) -> str:
-        path = extra_paths["predicates_file_for_agent"]
-        goal_block = self._format_goal_nl_block()
-        return f"""\
-## Predicate Invention
-
-Only the predicates in "## Available Predicates" above exist - this \
-approach stripped the env's symbolic predicates down to that allowlist. \
-Invent every other subgoal predicate (placements, device states, \
-process completions) in `{path}` as `LEARNED_PREDICATES`; the file \
-format, parameter sharing, coverage rules, and verification protocol \
-are in the system prompt's "Predicate Invention" section.
-
-{goal_block}\
-Goal achievement is checked externally - the env owns the goal \
-definition; check any state with the black-box `is_goal_state` (see \
-above). Your invented predicates only need to support plan-sketch \
-subgoals (gating Wait, Place, etc.) and may use any names.
-
-Failure trajectories are signal: when an interaction trajectory has \
-`reached_goal=False`, look for points where your predicate was true but \
-downstream progress stalled (e.g. a placement predicate fires but the \
-relevant rule feature stops advancing). That's evidence the threshold \
-is too loose; tighten it or share the gating parameter with the rule \
-via `params[...]` so MCMC can fit them jointly.
-
-Workflow: edit `predicates.py`, call `sim.predicates()` in `run_python` \
-(fast, also reloads predicates into the live set), then run \
-`sim.refine` / `sim.run` with sketches that reference your invented \
-names. Any predicate you reference in a sketch must exist in \
-`predicates.py` first.""" + self._chained_extra_message(extra_paths)
+        message = learn_prompts.render_predicate_invention_message(
+            extra_paths["predicates_file_for_agent"],
+            self._format_goal_nl_block())
+        return message + self._chained_extra_message(extra_paths)
 
     def _chained_extra_message(self, extra_paths: Dict[str, str]) -> str:
         """The base class's extra message (the partial-observability note under
@@ -219,35 +194,28 @@ def _format_goal_nl_block(self) -> str:
         return f"Goals across train tasks (natural language):\n{bullets}\n\n"
 
     def _synthesis_workflow_extra(self) -> str:
-        # The base workflow's step 4 depends on invented predicates:
-        # sketches can only reference predicates that already exist.
-        return ("\nStep 4's sketches need subgoal predicates that do not "
-                "exist until you invent them: before validating, write them "
-                "to `predicates.py` and load with `sim.predicates()` "
-                "(see \"Predicate Invention\").")
-
-    def _extra_synthesis_system_prompt(self) -> str:
+        # The base workflow's validation step depends on invented
+        # predicates: sketches can only reference predicates that exist.
+        return learn_prompts.render_predicate_workflow_extra()
+
+    def _extra_synthesis_system_prompt_sections(self) -> List[str]:
         # The scene workbench is the sim probe inside run_python (the
         # probe is unconditional in synthesis sessions).
         workbench = ("the `sim` probe in `run_python` as scene workbench "
-                     "- `sim.reset(task_idx=..., mods={...})` to stage "
+                     "(`sim.reset(task_idx=..., mods={...})` to stage "
                      "states, `sim.render(label, annotations=[...])` "
-                     "to render with overlays")
-        render_ref = "`sim.render`"
-        section = _PREDICATE_PROMPT_SECTION.replace("__SCENE_WORKBENCH__",
-                                                    workbench).replace(
-                                                        "__SCENE_RENDER_REF__",
-                                                        render_ref)
-        # Chain the base class's extra (the recurrent-rules tutorial
-        # under CFG.partially_observable), then the predicate-side
-        # latent guidance that belongs to invention arms only.
-        parts = [section]
-        base = super()._extra_synthesis_system_prompt()
-        if base:
-            parts.append(base)
-        if CFG.partially_observable:
-            parts.append(_RECURRENT_PREDICATE_SECTION)
-        return "\n\n".join(parts)
+                     "to render with overlays)")
+        sections = super()._extra_synthesis_system_prompt_sections()
+        sections.append(
+            learn_prompts.render_predicate_invention_section(workbench))
+        return sections
+
+    def _extra_synthesis_latent_sections(self) -> List[str]:
+        # The predicate-side latent guidance belongs to invention arms
+        # only and follows the simulator-side tutorial it refers to.
+        sections = super()._extra_synthesis_latent_sections()
+        sections.append(learn_prompts.render_predicate_latent_section())
+        return sections
 
     def _post_synthesis_loading(
         self,
@@ -359,181 +327,3 @@ def _load_predicates_from_module_file(self, path: str) -> Set[Predicate]:
             seen_names.add(entry.name)
 
         return valid
-
-
-_PREDICATE_PROMPT_SECTION = """\
-## Predicate Invention (required for plan subgoals)
-
-You are responsible for inventing the symbolic predicates the planner \
-will use as subgoal atoms in plan sketches. Only `Holding` is provided \
-as a primitive; placement, device-state, and process-completion \
-predicates do not exist until you invent them.
-
-Goals are presented to you in natural language (see the synthesis \
-message). Goal achievement is checked externally by the env via \
-`is_goal_state(state, task_idx)` / `train_tasks[task_idx].goal_holds(state)`. \
-You do **not** need to invent any goal-named predicates and you do \
-**not** need to match env predicate names. Your invented predicates \
-are purely for plan-sketch subgoals (gating Wait/Place/etc.) and can \
-be named freely.
-
-Define them in `predicates.py` (path given in the first message):
-
-```python
-LEARNED_PREDICATES: List[Predicate]
-```
-
-The exec namespace pre-injects `Predicate`, `np`, and a `<typename>_type` \
-binding for each env type (e.g. `widget_type`, `fixture_type`). The names \
-below are illustrative - use whatever types, features, and parameter names \
-your prompt digests and the trajectory data actually report for your task.
-
-```python
-# Placement: object xy within a learned distance of the fixture's
-# *functional point* - NOT its recorded origin. `fixture.x, fixture.y`
-# is usually the body base; the point the predicate should fire at
-# (a contact surface, an outlet, an opening) is offset from it, and
-# that offset lives in the fixture's LOCAL frame, so it rotates with
-# the fixture's `rot`. Declare the local offset as ParamSpecs in
-# simulator.py and share them with the rule that gates the same
-# physics. A raw origin-distance gate only holds when the fixture's
-# rotation never varies across tasks.
-def _widget_at_fixture(s, objs):
-    widget, fixture = objs
-    rot = s.get(fixture, "rot")
-    cos_r, sin_r = np.cos(rot), np.sin(rot)
-    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
-    local_offset = np.array([params["fixture_local_dx"],
-                             params["fixture_local_dy"]])
-    origin = np.array([s.get(fixture, "x"), s.get(fixture, "y")])
-    anchor = origin + rot_mat @ local_offset  # world-frame point
-    widget_xy = np.array([s.get(widget, "x"), s.get(widget, "y")])
-    dist = np.linalg.norm(widget_xy - anchor)
-    return dist < params["widget_at_fixture_dist"]
-
-LEARNED_PREDICATES = [
-    Predicate("WidgetAtFixture", [widget_type, fixture_type],
-              _widget_at_fixture),
-    # Device state: a feature exceeding a fixed cutoff (no learned param).
-    Predicate("FixtureActive", [fixture_type],
-              lambda s, objs: s.get(objs[0], "is_on") > 0.5),
-    # Process completion: a rule-driven feature reaches a learned threshold.
-    Predicate("WidgetReady", [widget_type],
-              lambda s, objs: s.get(objs[0], "progress") >= params["ready_threshold"]),
-]
-```
-
-A pre-injected `params` view is in scope; it always reads the **current \
-fitted values** of every `ParamSpec` declared in `simulator.py`. Whenever \
-MCMC re-fits, predicates picking up `params["name"]` see the new values \
-automatically. To share parameters between a rule and a predicate - a \
-distance threshold, and the local-frame anchor offset (`*_local_dx`, \
-`*_local_dy`) it is measured from - declare them once in `PARAM_SPECS` \
-and reference `params["name"]` from both. This is the recommended \
-pattern whenever a single physical gate drives both residual dynamics \
-(the rule's "fire" condition) and a control-relevant predicate (the \
-planner's "this subgoal is reached" check); it also gives the anchor \
-offset an SSE signal from the rule's step data, which a predicate-only \
-parameter would lack (see next caveat).
-
-Caveat: a parameter used only by predicates (not by any rule) has no SSE \
-signal - it stays at `init_value`. Pick good initial values for those.
-
-What you'll need (typical pattern):
-- Placement predicates (object at a target location) for any open-ended \
-option like Place - refinement needs these or it picks an arbitrary location.
-- Device-state predicates (on/off) for any toggle option.
-- Process-completion predicates over the features your rules drive, so \
-Wait steps know when to terminate. Keep classifier thresholds consistent \
-with rule saturation values; an inconsistency causes sim.fit to \
-look fine while sim.refine gets stuck on the Wait subgoal.
-- Coverage rule of thumb: every option you expect to use in a sketch \
-should have predicates that can express its post-condition, so every \
-sketch step can carry a subgoal annotation. Annotations are checked \
-against the real state during execution to detect and replan diverged \
-steps; a step with no annotatable effect is unmonitored. While drafting \
-sketches, a step you cannot annotate with any invented predicate is a \
-missing predicate - invent it.
-
-Verifying classifiers against the scene and data (applies to all \
-predicates): a classifier picks features and parameter values, and both \
-can be wrong - never commit either from intuition. Follow CLAUDE.md's \
-threshold-fitting protocol whenever you fit a numeric cutoff: bucket \
-trajectory steps by whether the downstream effect actually happened, \
-require the buckets to separate by a clear margin (overlap or a \
-knife-edge gap means the candidate quantity references the wrong point \
-- add a learned, rotation-aware anchor offset shared with the gating \
-rule instead of widening the threshold), and visualize before fitting. \
-Your two workbenches: __SCENE_WORKBENCH__ for geometry - a body's \
-recorded pose origin often is not the functional point (body center vs. \
-outlet, joint base vs. tool tip, housing vs. handle), so use one \
-__SCENE_RENDER_REF__ render to confirm what's actually where - and \
-`run_python` for the numeric sweep over trajectory states.
-
-Validate with `sim.predicates()` (cheap; reports first-flip step, \
-monotonicity, coverage across all available trajectories). On goal-reaching \
-trajectories (`reached_goal=True` in `describe_trajectory`) a milestone \
-predicate should flip False→True exactly once and stay true; on failed \
-interaction trajectories (`reached_goal=False`) the same predicate may \
-fire but the rest of the trajectory won't show goal completion - useful \
-signal for spotting an over-loose threshold (predicate fires, downstream \
-physics doesn't follow). A placement predicate should be true exactly \
-when an object is at its intended location and false otherwise.
-
-`sim.predicates()` is also the loader: it updates the predicate \
-set used by `sim.refine`. Call it after every edit to \
-`predicates.py` before re-running plan refinement.
-
-Predicates persist across online cycles - the file is preserved between \
-synthesis sessions. Edit it freely; every successful Write/Edit (and a \
-final post-session check) is snapshotted to \
-`predicates_versions/cycle_XXX_vers_YYY_predicates.py`. Each online cycle \
-re-runs synthesis with the full trajectory history (offline demos + every \
-interaction trajectory collected so far), so failed past attempts remain \
-visible for the agent to learn from.
-"""
-
-# Predicate-side latent guidance appended (after the base class's
-# simulator-side recurrent tutorial) under ``CFG.partially_observable``.
-# Invention-only: it teaches the optional ``latent`` classifier kwarg
-# and the latent materialisation in ``sim.predicates()``,
-# which non-invention arms have no use for.
-_RECURRENT_PREDICATE_SECTION = """\
-### Predicate signature
-
-Classifiers may stay observation-only or take an optional ``latent``
-kwarg. The latent block is available at refinement time too - the
-planner threads it through ``state.latent`` across search nodes, and
-``Predicate.holds`` auto-routes it into classifiers that opted in. Be
-defensive: at the very first step ``state.latent`` may still be ``{}``
-if the agent's ``LATENT_INIT`` is empty, and during predicate-quality
-scoring on *raw env* trajectories ``latent`` will be the block
-materialised by the agent's rules (so still meaningful, but only as
-accurate as the rules themselves).
-
-```python
-# Observation-only (robust to bad rule chains; preferred when the
-# observable carries enough signal):
-Predicate("ProcessDone", [widget_type],
-          lambda s, objs, latent=None:
-              s.get(objs[0], "progress") > 0.5)
-
-# Latent-aware (inherits simulator correctness; defend against
-# missing keys at step 0):
-Predicate("ProcessDone", [widget_type],
-          lambda s, objs, latent=None:
-              (latent or {}).get("level", 0.0) >= params["done_thresh"])
-```
-
-The kwarg MUST be named exactly ``latent`` for the auto-routing to
-fire. Trade-off: latent-aware predicates inherit the simulator's
-correctness; observation-only predicates are robust to bad rules
-but only work when the observable carries enough signal.
-
-### Diagnostics
-
-`sim.predicates()` rolls each trajectory through your
-simulator to materialise the latent before scoring classifiers, so
-latent-aware predicates get a real block there. Use the eval
-report to localise failures (bad rule chain vs. bad threshold).
-"""
diff --git a/predicators/cogman.py b/predicators/cogman.py
index 9d9dab07e..ff0eccc86 100644
--- a/predicators/cogman.py
+++ b/predicators/cogman.py
@@ -307,10 +307,15 @@ def _certified_solved() -> bool:
                 actions.append(act)
                 observations.append(obs)
             except Exception as e:
-                logging.debug(f"[CogMan] State at the exception {e}: "
-                              f"{utils.abstract(obs, env.predicates)}")
-                logging.debug(
-                    f"[CogMan] Full traceback:\n{traceback.format_exc()}")
+                # A plan_exhausted OptionExecutionFailure is how a
+                # completed plan ENDS (see below), not an error - dumping
+                # its state and full traceback buried the real failures
+                # under dozens of end-of-plan stacks per run.
+                if not getattr(e, "info", {}).get("plan_exhausted"):
+                    logging.debug(f"[CogMan] State at the exception {e}: "
+                                  f"{utils.abstract(obs, env.predicates)}")
+                    logging.debug(
+                        f"[CogMan] Full traceback:\n{traceback.format_exc()}")
                 # pylint: disable-next=import-outside-toplevel
                 from predicators.agent_sdk.session_base import \
                     AgentSessionFatalError
diff --git a/predicators/explorers/__init__.py b/predicators/explorers/__init__.py
index 33ab653b4..31995dffb 100644
--- a/predicators/explorers/__init__.py
+++ b/predicators/explorers/__init__.py
@@ -1,11 +1,13 @@
 """Handle creation of explorers."""
 
+import logging
 from typing import TYPE_CHECKING, Callable, Dict, List, Optional, Set
 
 from gym.spaces import Box
 
 from predicators import utils
 from predicators.competence_models import SkillCompetenceModel
+from predicators.explorers.agent_explorer_base import AgentExplorerBase
 from predicators.explorers.base_explorer import BaseExplorer
 from predicators.explorers.bilevel_planning_explorer import \
     BilevelPlanningExplorer
@@ -53,6 +55,17 @@ def create_explorer(
     """Create an explorer given its name."""
     if max_steps_before_termination is None:
         max_steps_before_termination = CFG.max_num_steps_interaction_request
+    # Deprecated aliases from before the explorers' model-free /
+    # model-based rename (2026-08-30); old launch commands and
+    # requeued jobs still pass them.
+    aliases = {
+        "agent_plan": "agent_model_free",
+        "agent_bilevel": "agent_model_based",
+    }
+    if name in aliases:
+        logging.warning("Explorer name %r is deprecated; use %r.", name,
+                        aliases[name])
+        name = aliases[name]
     for cls in utils.get_all_subclasses(BaseExplorer):
         if not cls.__abstractmethods__ and cls.get_name() == name:
             # Special case GLIB because it uses babble predicates and an atom
@@ -109,7 +122,7 @@ def create_explorer(
                                action_space, train_tasks,
                                max_steps_before_termination, nsrts,
                                maple_q_function)
-            elif name in ("agent_plan", "agent_bilevel"):
+            elif issubclass(cls, AgentExplorerBase):
                 assert tool_context is not None
                 assert agent_session is not None
                 explorer = cls(initial_predicates, initial_options, types,
diff --git a/predicators/explorers/agent_explorer_base.py b/predicators/explorers/agent_explorer_base.py
new file mode 100644
index 000000000..ead31f0c4
--- /dev/null
+++ b/predicators/explorers/agent_explorer_base.py
@@ -0,0 +1,63 @@
+"""Shared plumbing for the agent explorers.
+
+Both agent explorers query a Claude agent session for a plan and roll it
+out in the real environment; they differ in what the agent is given (the
+model-based explorer exposes the learned belief simulator through tools,
+the model-free one only the task description). This base class holds the
+common session wiring: construction, the trajectory summary shown to the
+agent, final-text extraction, and the random-options fallback.
+"""
+
+from typing import Any, Dict, List, Optional, Set
+
+from gym.spaces import Box
+
+from predicators import utils
+from predicators.agent_sdk.response_parser import extract_final_text
+from predicators.agent_sdk.session_manager import SessionManagerProtocol
+from predicators.agent_sdk.sketch_prompts import summarize_trajectories
+from predicators.agent_sdk.tools import ToolContext
+from predicators.explorers.base_explorer import BaseExplorer
+from predicators.structs import Action, ExplorationStrategy, \
+    ParameterizedOption, Predicate, State, Task, Type
+
+
+class AgentExplorerBase(BaseExplorer):
+    """Base class for explorers that query a Claude agent session."""
+
+    def __init__(self, predicates: Set[Predicate],
+                 options: Set[ParameterizedOption], types: Set[Type],
+                 action_space: Box, train_tasks: List[Task],
+                 max_steps_before_termination: int, tool_context: ToolContext,
+                 agent_session: SessionManagerProtocol) -> None:
+        super().__init__(predicates, options, types, action_space, train_tasks,
+                         max_steps_before_termination)
+        self._tool_context = tool_context
+        self._agent_session = agent_session
+
+    def _agent_tool_names(self) -> Optional[List[str]]:
+        """Return tool names exposed by the current session, if any."""
+        return getattr(self._agent_session, "tool_names", None)
+
+    def _random_options_fallback(self) -> ExplorationStrategy:
+        """Fall back to random option sampling."""
+
+        def fallback_policy(state: State) -> Action:
+            del state
+            raise utils.RequestActPolicyFailure(
+                "Random option sampling failed!")
+
+        policy = utils.create_random_option_policy(self._options, self._rng,
+                                                   fallback_policy)
+        return policy, lambda _: False
+
+    def _build_trajectory_summary(self) -> str:
+        """Summarize trajectory data for the agent."""
+        all_trajs = (self._tool_context.offline_trajectories +
+                     self._tool_context.online_trajectories)
+        return summarize_trajectories(all_trajs, self._predicates)
+
+    @staticmethod
+    def _extract_option_plan_text(responses: List[Dict[str, Any]]) -> str:
+        """Extract plan text from the last assistant text response."""
+        return extract_final_text(responses)
diff --git a/predicators/explorers/agent_bilevel_explorer.py b/predicators/explorers/agent_model_based_explorer.py
similarity index 79%
rename from predicators/explorers/agent_bilevel_explorer.py
rename to predicators/explorers/agent_model_based_explorer.py
index d56fb5afd..ddd42bae2 100644
--- a/predicators/explorers/agent_bilevel_explorer.py
+++ b/predicators/explorers/agent_model_based_explorer.py
@@ -1,5 +1,5 @@
-"""Agent bilevel explorer: the agent sketches an experiment, it runs as
-written.
+"""Agent model-based explorer: the agent sketches an experiment against the
+learned belief model, and it runs as written.
 
 Queries a Claude agent for a fully parameterized plan sketch and rolls
 it out for real exactly as written. The agent refines and validates
@@ -12,48 +12,38 @@
 trajectory is a targeted learning signal for online simulator
 synthesis.
 
-Parallels ``AgentPlanExplorer`` for session plumbing and
-``AgentModelBasedApproach`` for the sketch workflow.
+Parallels ``AgentModelBasedApproach`` for the sketch workflow; the
+session plumbing lives in ``AgentExplorerBase``.
+
+Registered under the CLI explorer name ``agent_model_based``
+(``agent_bilevel`` is kept as a deprecated alias).
 """
 
 import logging
 import os
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set
+from typing import Any, Callable, Dict, List, Optional, Sequence
 
 import numpy as np
-from gym.spaces import Box
 
 from predicators import utils
 from predicators.agent_sdk import bilevel_sketch
 from predicators.agent_sdk.rendering import save_task_state_image
 from predicators.agent_sdk.session_base import AgentSessionFatalError, \
     query_fatal_error
-from predicators.agent_sdk.session_manager import SessionManagerProtocol, \
-    run_query_sync
-from predicators.agent_sdk.tools import PlanCapture, ToolContext, \
-    agent_render_resolution, load_ground_sampler_fns
-from predicators.explorers.base_explorer import BaseExplorer
+from predicators.agent_sdk.session_manager import run_query_sync
+from predicators.agent_sdk.tools import PlanCapture, agent_render_resolution, \
+    load_ground_sampler_fns
+from predicators.explorers.agent_explorer_base import AgentExplorerBase
 from predicators.settings import CFG
-from predicators.structs import Action, ExplorationStrategy, \
-    ParameterizedOption, Predicate, State, Task, Type
+from predicators.structs import Action, ExplorationStrategy, State, Task
 
 
-class AgentBilevelExplorer(BaseExplorer):
+class AgentModelBasedExplorer(AgentExplorerBase):
     """Queries a Claude agent for a plan sketch and executes it as written."""
 
-    def __init__(self, predicates: Set[Predicate],
-                 options: Set[ParameterizedOption], types: Set[Type],
-                 action_space: Box, train_tasks: List[Task],
-                 max_steps_before_termination: int, tool_context: ToolContext,
-                 agent_session: SessionManagerProtocol) -> None:
-        super().__init__(predicates, options, types, action_space, train_tasks,
-                         max_steps_before_termination)
-        self._tool_context = tool_context
-        self._agent_session = agent_session
-
     @classmethod
     def get_name(cls) -> str:
-        return "agent_bilevel"
+        return "agent_model_based"
 
     # ------------------------------------------------------------------ #
     # Exploration strategy
@@ -66,29 +56,13 @@ def _get_exploration_strategy(self, train_task_idx: int,
         # this explorer, so reading here picks up the latest learned model.
         option_model = self._tool_context.option_model
         assert option_model is not None, \
-            "agent_bilevel explorer needs a synced option_model"
+            "agent_model_based explorer needs a synced option_model"
 
         # Reset the per-request mental-model verdict so a stale value can't
         # leak if the query below throws or falls back to random before
         # producing one.
         self._tool_context.last_mental_model_solved = None
 
-        # A plan this cycle already certified on this task (see the
-        # capture branch below) is replayed for the cycle's remaining
-        # requests without a new query: the train-driven early-stop rule
-        # needs EVERY attempt of the cycle to solve, and a second real
-        # execution of the certified plan is the cheapest evidence.
-        certified = self._tool_context.cycle_certified_plans.get(
-            train_task_idx)
-        if certified is not None and \
-                CFG.agent_explorer_replay_certified_plan:
-            logging.info(
-                "agent_bilevel explorer: replaying this cycle's "
-                "belief-certified plan for train task %d (%d steps) "
-                "without a new query.", train_task_idx, len(certified))
-            self._tool_context.last_mental_model_solved = True
-            return self._certified_plan_strategy(certified)
-
         # Point the agent's interactive tools (submit_plan, the
         # sim probe) at the EXPLORE task. They
         # default to ctx.current_task when the agent omits task_idx, and
@@ -137,7 +111,6 @@ def _get_exploration_strategy(self, train_task_idx: int,
                 # the belief model may lack goal-critical dynamics, so a
                 # simulator-failing sketch is a valid deliverable.
                 explore_mode=True,
-                ground_samplers=CFG.agent_bilevel_ground_samplers,
             )
             responses = run_query_sync(self._agent_session,
                                        prompt,
@@ -158,15 +131,19 @@ def _get_exploration_strategy(self, train_task_idx: int,
             # (submit_plan, N fresh
             # rollouts). ``reached_goal`` is the gate's verdict.
             capture = self._tool_context.take_plan_capture()
-            if CFG.agent_explorer_replay_certified_plan and capture.plan \
+            if CFG.agent_explorer_execute_certified_plan and capture.plan \
                     and capture.reached_goal is True:
                 # Certified: the mental model solves the task with THIS
                 # plan, so run it verbatim as a solve attempt instead of
                 # re-searching (or boundary-probing) its parameters. A
-                # real success now counts for early stopping.
+                # real success now counts for early stopping. The cycle's
+                # later requests see it under "plans already scheduled"
+                # and are asked for a DIFFERENT certified plan (a second
+                # test of the model), resubmitting this one only as a
+                # last resort.
                 plan = list(capture.plan)
                 logging.info(
-                    "agent_bilevel explorer: the agent's tool-validated "
+                    "agent_model_based explorer: the agent's tool-validated "
                     "plan passed the belief's capture gate (%s); executing "
                     "it verbatim as this episode's solve attempt (mental "
                     "model solved the goal).", capture.validation_summary
@@ -181,12 +158,10 @@ def _get_exploration_strategy(self, train_task_idx: int,
                         for s in capture.sketch
                     ]
                 self._tool_context.last_mental_model_solved = True
-                self._tool_context.cycle_certified_plans[train_task_idx] = plan
                 self._tool_context.cycle_scheduled_plans.append(
                     self._format_plan(plan) +
                     "\n  NOTE: belief-certified; executes verbatim as a "
-                    "solve attempt and is replayed for this cycle's "
-                    "remaining episodes.")
+                    "solve attempt.")
                 return self._certified_plan_strategy(plan)
             if not plan_text and not capture.plan:
                 raise ValueError("agent returned empty plan text")
@@ -225,7 +200,7 @@ def _get_exploration_strategy(self, train_task_idx: int,
             self._tool_context.last_mental_model_solved = False
             record = self._format_sketch(sketch, plan)
             logging.info(
-                "agent_bilevel explorer: executing the agent's sketch "
+                "agent_model_based explorer: executing the agent's sketch "
                 "verbatim for train task %d (%d steps; not "
                 "belief-certified):\n%s", train_task_idx, len(plan), record)
             self._tool_context.cycle_scheduled_plans.append(
@@ -241,12 +216,12 @@ def _get_exploration_strategy(self, train_task_idx: int,
             # re-raise so the run terminates.
             raise
         except Exception as e:  # pylint: disable=broad-except
-            logging.warning(f"agent_bilevel explorer failed: {e}. "
+            logging.warning(f"agent_model_based explorer failed: {e}. "
                             "Falling back to random options.")
 
         if not CFG.agent_explorer_fallback_to_random:
             raise utils.RequestActPolicyFailure(
-                "agent_bilevel explorer failed and fallback disabled.")
+                "agent_model_based explorer failed and fallback disabled.")
         return self._random_options_fallback()
 
     # ------------------------------------------------------------------ #
@@ -284,7 +259,8 @@ def _sketch_from_capture(
                     subgoal_neg_atoms=step.subgoal_neg_atoms,
                     initial_params=params))
         logging.info(
-            "agent_bilevel explorer: final text didn't parse, recovered the "
+            "agent_model_based explorer: final text didn't parse, recovered "
+            "the "
             "agent's tool-validated plan from capture (%d steps); executing "
             "it at the captured params.", len(seeded))
         return seeded
@@ -307,7 +283,7 @@ def _ground_sketch_verbatim(
             if params is None or len(params) != dim:
                 if dim > 0:
                     logging.warning(
-                        "agent_bilevel explorer: step %d (%s) has no "
+                        "agent_model_based explorer: step %d (%s) has no "
                         "usable proposed params (%s); drawing one sample "
                         "from the option's box - propose every "
                         "parameter explicitly.", i, step.option.name,
@@ -350,7 +326,7 @@ def _format_plan(plan: Sequence[Any]) -> str:
     def _certified_plan_strategy(self,
                                  plan: Sequence[Any]) -> ExplorationStrategy:
         """Execute a belief-certified grounded plan verbatim."""
-        logging.info("agent_bilevel explorer: certified plan:\n%s",
+        logging.info("agent_model_based explorer: certified plan:\n%s",
                      self._format_plan(plan))
         policy = utils.option_plan_to_policy(
             list(plan),
@@ -375,22 +351,6 @@ def _wrapped(state: State) -> Action:
 
         return _wrapped
 
-    def _random_options_fallback(self) -> ExplorationStrategy:
-        """Fall back to random option sampling."""
-
-        def fallback_policy(state: State) -> Action:
-            del state
-            raise utils.RequestActPolicyFailure(
-                "Random option sampling failed!")
-
-        policy = utils.create_random_option_policy(self._options, self._rng,
-                                                   fallback_policy)
-        return policy, lambda _: False
-
-    def _agent_tool_names(self) -> Optional[List[str]]:
-        """Return tool names exposed by the current session, if any."""
-        return getattr(self._agent_session, "tool_names", None)
-
     def _initial_image_section(self, task: Task, train_task_idx: int) -> str:
         """Render the explore task's initial state and return a prompt section
         pointing at it, mirroring what test-time solves get.
@@ -483,8 +443,18 @@ def _read_open_questions(self) -> str:
         except OSError:
             return ""
         if len(text) > self._MAX_OPEN_QUESTIONS_CHARS:
-            text = (text[:self._MAX_OPEN_QUESTIONS_CHARS] +
-                    "\n[... ledger truncated; lower-ranked entries omitted]")
+            # Cut at an entry boundary, never mid-sentence, and point at
+            # the file: a mid-sentence cut silently dropped the entries
+            # the header told the agent to fold in (run_20260830).
+            head = text[:self._MAX_OPEN_QUESTIONS_CHARS]
+            cut = head.rfind("\n#")
+            if cut <= 0:
+                cut = head.rfind("\n\n")
+            if cut > 0:
+                head = head[:cut]
+            text = (head.rstrip() +
+                    "\n[... ledger truncated at the prompt cap - read "
+                    "./open_questions.md for the remaining entries]")
         return text
 
     def _build_disagreement_summary(self) -> str:
@@ -527,8 +497,9 @@ def _build_disagreement_summary(self) -> str:
         # ensemble is internally confident (or too tight) everywhere.
         all_ranked = sorted(((v, k) for k, v in best.items()), reverse=True)
         logging.info(
-            "agent_bilevel explorer: per-predicate max ensemble disagreement "
-            "over %d states — %s.", len(states),
+            "agent_model_based explorer: per-predicate max ensemble "
+            "disagreement "
+            "over %d states - %s.", len(states),
             ", ".join(f"{k}={v:.4f}" for v, k in all_ranked) or "(none)")
         ranked = [(v, k) for v, k in all_ranked if v > 0.05][:4]
         if not ranked:
@@ -538,50 +509,3 @@ def _build_disagreement_summary(self) -> str:
                 f"internally uncertain about: {named}. A sketch that puts "
                 "these predicates on the critical path will be most "
                 "informative.")
-
-    def _build_trajectory_summary(self) -> str:
-        """Summarize trajectory data for the agent."""
-        all_trajs = (self._tool_context.offline_trajectories +
-                     self._tool_context.online_trajectories)
-        if not all_trajs:
-            return ""
-
-        max_trajs = CFG.agent_sdk_max_trajectories_in_context
-        recent = all_trajs[-max_trajs:]
-        lines = [
-            f"\n## Trajectory Summary ({len(all_trajs)} total, "
-            f"showing last {len(recent)})"
-        ]
-
-        for i, traj in enumerate(recent):
-            n_steps = len(traj.actions)
-            init_atoms = utils.abstract(traj.states[0], self._predicates)
-            final_atoms = utils.abstract(traj.states[-1], self._predicates)
-            new_atoms = final_atoms - init_atoms
-            lost_atoms = init_atoms - final_atoms
-            lines.append(f"\nTrajectory {i}: {n_steps} steps")
-            if new_atoms:
-                lines.append(
-                    "  Gained: " +
-                    f"{', '.join(str(a) for a in sorted(new_atoms, key=str))}")
-            if lost_atoms:
-                lines.append(
-                    "  Lost: " +
-                    f"{', '.join(str(a) for a in sorted(lost_atoms, key=str))}"
-                )
-
-        return "\n".join(lines)
-
-    def _extract_option_plan_text(self, responses: List[Dict[str,
-                                                             Any]]) -> str:
-        """Extract plan text from the last assistant text response."""
-        last_text_parts: List[str] = []
-        for resp in responses:
-            if resp.get("type") == "assistant":
-                parts = [
-                    block.get("text", "") for block in resp.get("content", [])
-                    if isinstance(block, dict) and block.get("type") == "text"
-                ]
-                if parts:
-                    last_text_parts = parts
-        return "\n".join(last_text_parts)
diff --git a/predicators/explorers/agent_plan_explorer.py b/predicators/explorers/agent_model_free_explorer.py
similarity index 58%
rename from predicators/explorers/agent_plan_explorer.py
rename to predicators/explorers/agent_model_free_explorer.py
index fe49b9a5d..22ef21c07 100644
--- a/predicators/explorers/agent_plan_explorer.py
+++ b/predicators/explorers/agent_model_free_explorer.py
@@ -1,45 +1,35 @@
-"""Agent plan explorer: Claude agent generates grounded option plans.
+"""Agent model-free explorer: Claude agent generates grounded option plans
+without a learned world model.
 
 Produces fully-grounded option plans (including continuous parameters)
-and rolls them out in the real environment. Unlike
-``AgentBilevelExplorer``, it runs no backtracking refinement against a
-learned option model; the agent must supply complete parameters itself.
+from a one-shot task description and rolls them out in the real
+environment. Unlike ``AgentModelBasedExplorer``, the agent has no belief
+simulator to validate against and no backtracking refinement; it must
+supply complete parameters itself.
+
+Registered under the CLI explorer name ``agent_model_free``
+(``agent_plan`` is kept as a deprecated alias).
 """
 
 import logging
-from typing import Any, Dict, List, Set
 
 import numpy as np
-from gym.spaces import Box
 
 from predicators import utils
 from predicators.agent_sdk.session_base import AgentSessionFatalError, \
     query_fatal_error
-from predicators.agent_sdk.session_manager import SessionManagerProtocol, \
-    run_query_sync
-from predicators.agent_sdk.tools import ToolContext
-from predicators.explorers.base_explorer import BaseExplorer
+from predicators.agent_sdk.session_manager import run_query_sync
+from predicators.explorers.agent_explorer_base import AgentExplorerBase
 from predicators.settings import CFG
-from predicators.structs import Action, ExplorationStrategy, \
-    ParameterizedOption, Predicate, State, Task, Type
+from predicators.structs import ExplorationStrategy, Task
 
 
-class AgentPlanExplorer(BaseExplorer):
+class AgentModelFreeExplorer(AgentExplorerBase):
     """Queries a Claude agent to produce grounded option plans."""
 
-    def __init__(self, predicates: Set[Predicate],
-                 options: Set[ParameterizedOption], types: Set[Type],
-                 action_space: Box, train_tasks: List[Task],
-                 max_steps_before_termination: int, tool_context: ToolContext,
-                 agent_session: SessionManagerProtocol) -> None:
-        super().__init__(predicates, options, types, action_space, train_tasks,
-                         max_steps_before_termination)
-        self._tool_context = tool_context
-        self._agent_session = agent_session
-
     @classmethod
     def get_name(cls) -> str:
-        return "agent_plan"
+        return "agent_model_free"
 
     def _get_exploration_strategy(self, train_task_idx: int,
                                   timeout: int) -> ExplorationStrategy:
@@ -51,7 +41,7 @@ def _get_exploration_strategy(self, train_task_idx: int,
                                        kind="explore")
             dead = query_fatal_error(responses)
             if dead is not None:
-                # See agent_bilevel_explorer: never explore at random
+                # See agent_model_based_explorer: never explore at random
                 # because the session backend is down.
                 raise AgentSessionFatalError(
                     "explore query died without the agent doing any work "
@@ -77,18 +67,6 @@ def _get_exploration_strategy(self, train_task_idx: int,
                 "Agent explorer failed and fallback disabled.")
         return self._random_options_fallback()
 
-    def _random_options_fallback(self) -> ExplorationStrategy:
-        """Fall back to random option sampling."""
-
-        def fallback_policy(state: State) -> Action:
-            del state
-            raise utils.RequestActPolicyFailure(
-                "Random option sampling failed!")
-
-        policy = utils.create_random_option_policy(self._options, self._rng,
-                                                   fallback_policy)
-        return policy, lambda _: False
-
     def _build_exploration_prompt(self, train_task_idx: int) -> str:
         """Build a prompt for the agent to produce an option plan."""
         task = self._train_tasks[train_task_idx]
@@ -126,9 +104,9 @@ def _build_exploration_prompt(self, train_task_idx: int) -> str:
 
         # Available tools
         tools_str = ""
-        if self._agent_session.tool_names:
-            tool_list = "\n".join(f"  - {t}"
-                                  for t in self._agent_session.tool_names)
+        tool_names = self._agent_tool_names()
+        if tool_names:
+            tool_list = "\n".join(f"  - {t}" for t in tool_names)
             tools_str = f"\n## Available Tools\n{tool_list}\n"
 
         task_intro = ("You are exploring a task environment. "
@@ -160,57 +138,6 @@ def _build_exploration_prompt(self, train_task_idx: int) -> str:
 
         return prompt
 
-    def _build_trajectory_summary(self) -> str:
-        """Summarize trajectory data for the agent."""
-        all_trajs = (self._tool_context.offline_trajectories +
-                     self._tool_context.online_trajectories)
-        if not all_trajs:
-            return ""
-
-        max_trajs = CFG.agent_sdk_max_trajectories_in_context
-        recent = all_trajs[-max_trajs:]
-        lines = [
-            f"\n## Trajectory Summary ({len(all_trajs)} total, "
-            f"showing last {len(recent)})"
-        ]
-
-        for i, traj in enumerate(recent):
-            n_steps = len(traj.actions)
-            init_atoms = utils.abstract(traj.states[0], self._predicates)
-            final_atoms = utils.abstract(traj.states[-1], self._predicates)
-            new_atoms = final_atoms - init_atoms
-            lost_atoms = init_atoms - final_atoms
-            lines.append(f"\nTrajectory {i}: {n_steps} steps")
-            if new_atoms:
-                lines.append(
-                    "  Gained: " +
-                    f"{', '.join(str(a) for a in sorted(new_atoms, key=str))}")
-            if lost_atoms:
-                lines.append(
-                    "  Lost: " +
-                    f"{', '.join(str(a) for a in sorted(lost_atoms, key=str))}"
-                )
-
-        return "\n".join(lines)
-
-    def _extract_option_plan_text(self, responses: List[Dict[str,
-                                                             Any]]) -> str:
-        """Extract plan text from the last assistant text response.
-
-        Uses only the final assistant message so intermediate
-        reasoning/tool-call text preceding the plan is excluded.
-        """
-        last_text_parts: List[str] = []
-        for resp in responses:
-            if resp.get("type") == "assistant":
-                parts = [
-                    block.get("text", "") for block in resp.get("content", [])
-                    if isinstance(block, dict) and block.get("type") == "text"
-                ]
-                if parts:
-                    last_text_parts = parts
-        return "\n".join(last_text_parts)
-
     def _parse_and_ground_plan(self, plan_text: str, task: Task) -> list:
         """Parse option plan text and ground into executable options."""
         objects = list(task.init)
diff --git a/predicators/ground_truth_models/skill_factories/base.py b/predicators/ground_truth_models/skill_factories/base.py
index 0a47d6e6c..c30daecc3 100644
--- a/predicators/ground_truth_models/skill_factories/base.py
+++ b/predicators/ground_truth_models/skill_factories/base.py
@@ -1620,8 +1620,12 @@ def _diagnose(goal_joints: JointPositions,
                             "clutter (no path or arm branch can fix it)")
 
         if traj is None and not expect_contact:
+            # Debug, not error: a refused pose is a normal search
+            # outcome during sampling/refinement retries (hundreds per
+            # run), and the diagnostics reach the agent-facing failure
+            # reason via _last_plan_diagnostics either way.
             for diag in diagnostics:
-                logging.error("[%s/%s] %s", self._name, phase_name, diag)
+                logging.debug("[%s/%s] %s", self._name, phase_name, diag)
             self._last_plan_diagnostics = diagnostics
 
         return traj
@@ -1852,6 +1856,12 @@ def _check(joints: JointPositions, label: str) -> None:
                 "GOAL with fingers OPEN to release (the opening "
                 "gripper needs side clearance at the drop pose)")
         if log_errors:
+            # ERROR is correct HERE, unlike the demoted _plan failure
+            # site: ``log_errors`` is this method's contract for
+            # final-failure emission - every in-run caller goes through
+            # ``_diagnose(..., log_errors=False)`` and stays quiet, so
+            # the loud path never fires during sampling/refinement
+            # retries and cannot spam a run's log.
             for diag in diagnostics:
                 logging.error("[%s/%s] %s", self._name, phase_name, diag)
         return diagnostics
diff --git a/predicators/option_model.py b/predicators/option_model.py
index 34dfb7fdf..3666e5443 100644
--- a/predicators/option_model.py
+++ b/predicators/option_model.py
@@ -167,8 +167,10 @@ def get_next_state_and_num_actions(self, state: State,
         # Note: mypy complains if this is None instead of DefaultState.
         last_state = DefaultState
 
+        wait_steps = 0
+
         def _terminal(s: State) -> bool:
-            nonlocal last_state
+            nonlocal last_state, wait_steps
             if option_copy.terminal(s):
                 logging.debug("Option reached terminal state.")
                 return True
@@ -186,11 +188,22 @@ def _terminal(s: State) -> bool:
             if (CFG.wait_option_terminate_on_atom_change
                     and option_copy.name == "Wait"
                     and last_state is not DefaultState
-                    and self._abstract_function is not None
-                    and _check_wait_termination(option_copy, s, last_state,
-                                                self._abstract_function)):
-                logging.debug("Wait option terminating early.")
-                return True
+                    and self._abstract_function is not None):
+                wait_steps += 1
+                if _check_wait_termination(option_copy, s, last_state,
+                                           self._abstract_function):
+                    logging.debug("Wait option terminating early.")
+                    return True
+                # Same backstop the real executor applies (utils.py's
+                # wait_option_max_steps branches), so a Wait whose
+                # target atoms never come true ends at the same step
+                # count on both substrates instead of running to this
+                # model's option-rollout cap only in the belief.
+                if wait_steps >= CFG.wait_option_max_steps:
+                    logging.debug(
+                        "Wait terminating: wait_option_max_steps "
+                        "backstop (%d steps).", wait_steps)
+                    return True
             last_state = s
             return False
 
diff --git a/predicators/settings.py b/predicators/settings.py
index f94fbf981..72c8f98e1 100644
--- a/predicators/settings.py
+++ b/predicators/settings.py
@@ -1527,7 +1527,6 @@ class GlobalSettings:
     agent_sdk_use_local_sandbox = False
 
     # Agent explorer settings
-    agent_explorer_max_turns = 5  # max agent turns per exploration query
     agent_explorer_fallback_to_random = True  # fall back to random on failure
 
     # Agent planner approach settings
@@ -1818,11 +1817,14 @@ class GlobalSettings:
     # (submit_plan: goal reached in
     # agent_plan_validation_rollouts fresh belief rollouts) is executed
     # verbatim as the episode's solve attempt with mental_model_solved=
-    # True, and the cycle's remaining requests on that task replay it
-    # without a new query - so a certified plan that solves for real on
-    # every attempt satisfies the train-driven early-stop rule. Off
-    # feeds the capture into the experiment search as seeds instead.
-    agent_explorer_replay_certified_plan = True
+    # True. The cycle's remaining requests on that task still query the
+    # agent, which sees the certified plan among the plans already
+    # scheduled and is asked for a different certified plan (a second,
+    # independent test of the belief), resubmitting the same one only as
+    # a last resort; every certified attempt solving for real satisfies
+    # the train-driven early-stop rule. Off feeds the capture into the
+    # experiment search as seeds instead.
+    agent_explorer_execute_certified_plan = True
     # Per-parameter jitter as a fraction of the ParamSpec box width, for
     # the uniform-fallback ensemble only (see calibrated flag below).
     agent_explorer_info_perturb_frac = 0.15
diff --git a/predicators/structs.py b/predicators/structs.py
index 87b231100..24ed70c33 100644
--- a/predicators/structs.py
+++ b/predicators/structs.py
@@ -522,6 +522,16 @@ def arity(self) -> int:
         """The arity of this predicate (number of arguments)."""
         return len(self.types)
 
+    @cached_property
+    def accepts_latent(self) -> bool:
+        """Whether the classifier reads the belief latent block.
+
+        Such a predicate's truth can depend on belief-only state that
+        real observations do not carry, so it may be unverifiable at
+        execution time (see the capture gate's latent-stripped probe).
+        """
+        return _classifier_accepts_latent(self._classifier)
+
     def holds(self,
               state: State,
               objects: Sequence[Object],
@@ -2564,7 +2574,7 @@ class InteractionRequest:
     # explorers); online learning treats ``False`` as not-solved for
     # early stopping even if real-env execution happens to reach the
     # goal, so a model that executes-but-mispredicts isn't certified as
-    # trained. See AgentBilevelExplorer /
+    # trained. See AgentModelBasedExplorer /
     # run.online_learning.generate_interaction_results.
     mental_model_solved: Optional[bool] = None
 
diff --git a/predicators/utils.py b/predicators/utils.py
index cc7c97723..f0384c81c 100644
--- a/predicators/utils.py
+++ b/predicators/utils.py
@@ -3156,11 +3156,17 @@ def _reject(msg: str) -> None:
                 break
             # Skip preamble lines (analysis text before the plan starts).
             continue
-        if parse_continuous_params and "[" not in option_str:
+        option = option_name_to_option[option_name]
+        # A zero-parameter option (e.g. Wait) may omit its '[]': the
+        # harness's own logs and reports render such steps bracket-free,
+        # and demanding brackets the logs never print cost agents a
+        # rejected submission per session (run_20260830).
+        has_params_block = "[" in option_str
+        if (parse_continuous_params and not has_params_block
+                and option.params_space.shape[0] > 0):
             _reject(f"Line {option_str} output by model doesn't contain a "
                     "'[' and is thus improperly formatted.")
             break
-        option = option_name_to_option[option_name]
         # Now that we have the option, we need to parse out the objects
         # along with specified types.
         try:
@@ -3226,8 +3232,9 @@ def _reject(msg: str) -> None:
                     f"{len(objs_list)} object argument(s) but option "
                     f"{option.name} expects {len(option.types)}.")
             malformed = True
-        # Now, we attempt to parse out the continuous parameters.
-        if parse_continuous_params:
+        # Now, we attempt to parse out the continuous parameters (a
+        # zero-parameter option without a '[]' block has none).
+        if parse_continuous_params and has_params_block:
             params_str_list = option_str_stripped.split('[')[1].strip(
                 ']').split(',')
             for i, continuous_params_str in enumerate(params_str_list):
diff --git a/scripts/configs/predicatorv3/approaches/all.yaml b/scripts/configs/predicatorv3/approaches/all.yaml
index 16896f796..f7d6eceaa 100644
--- a/scripts/configs/predicatorv3/approaches/all.yaml
+++ b/scripts/configs/predicatorv3/approaches/all.yaml
@@ -8,7 +8,7 @@
 # weakest baselines:
 #   OURS         - the method: PO, no GT; learn predicates + hybrid sim + params
 #   ORACLES      - given a GT world model (GT sim / params); upper bounds,
-#                  ablations of OURS, and the oracle-sim agent_planner baseline
+#                  ablations of OURS, and the oracle-sim agent_model_free baseline
 #   BASELINES    - lower bounds (no world model or no learning)
 #   DEMONSTRATOR - the demo source (oracle process planning) + scripted/manual
 #
@@ -40,7 +40,7 @@ APPROACHES:
     SKIP: True
     FLAGS:
       demonstrator: "oracle_process_planning"
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
       option_model_terminate_on_repeat: False
@@ -69,7 +69,7 @@ APPROACHES:
     SKIP: True
     FLAGS:
       demonstrator: "oracle_process_planning"
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
       option_model_terminate_on_repeat: False
@@ -98,14 +98,14 @@ APPROACHES:
   # use_llm_initial_params False the LLM delivers a full, concrete,
   # exact-parameter plan and validates it in the sim via
   # submit_plan -- there is no approach-side backtracking
-  # fallback. On top of plain agent_planner it has sim.refine (an
+  # fallback. On top of plain agent_model_free it has sim.refine (an
   # agent-invokable per-step backtracking parameter search) plus
   # the sketch / per-step-subgoal scaffolding.
   agent_oracle_mono_sim:
-    NAME: "agent_bilevel"
+    NAME: "agent_model_based"
     SKIP: True
     FLAGS:
-      explorer: "agent_plan"
+      explorer: "agent_model_free"
       demonstrator: "oracle_process_planning"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
@@ -128,7 +128,7 @@ APPROACHES:
     FLAGS:
       demonstrator: "oracle_process_planning"
       bilevel_plan_without_sim: True # for the demonstrator
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
       option_model_terminate_on_repeat: False
@@ -151,7 +151,7 @@ APPROACHES:
     NAME: "agent_sim_learning"
     SKIP: True
     FLAGS:
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       demonstrator: "oracle_process_planning"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
@@ -175,7 +175,7 @@ APPROACHES:
   #   FLAGS:
   #     demonstrator: "oracle_process_planning"
   #     bilevel_plan_without_sim: True # for the demonstrator
-  #     explorer: "agent_bilevel"
+  #     explorer: "agent_model_based"
   #     terminate_on_goal_reached_and_option_terminated: True
   #     agent_sdk_use_local_sandbox: True
   #     option_model_terminate_on_repeat: False
@@ -202,7 +202,7 @@ APPROACHES:
   #   FLAGS:
   #     demonstrator: "oracle_process_planning"
   #     bilevel_plan_without_sim: True # for the demonstrator
-  #     explorer: "agent_bilevel"
+  #     explorer: "agent_model_based"
   #     terminate_on_goal_reached_and_option_terminated: True
   #     agent_sdk_use_local_sandbox: True
   #     option_model_terminate_on_repeat: False
@@ -220,7 +220,7 @@ APPROACHES:
     NAME: "agent_sim_learning"
     SKIP: True
     FLAGS:
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       demonstrator: "oracle_process_planning"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
@@ -237,7 +237,7 @@ APPROACHES:
     NAME: "agent_sim_predicate_invention"
     SKIP: True
     FLAGS:
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       demonstrator: "oracle_process_planning"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
@@ -254,12 +254,12 @@ APPROACHES:
   # BASELINES  (lower bounds / alternative learners)
   # ======================================================================
   # Baseline: agent planning does NOT have a simulator / world model
-  # (agent_planner with agent_planner_use_simulator: False).
+  # (agent_model_free with agent_planner_use_simulator: False).
   agent_model_free_planning:
-    NAME: "agent_planner"
+    NAME: "agent_model_free"
     SKIP: True
     FLAGS:
-      explorer: "agent_plan"
+      explorer: "agent_model_free"
       demonstrator: "oracle_process_planning"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
@@ -273,7 +273,7 @@ APPROACHES:
     FLAGS:
       demonstrator: "oracle_process_planning"
       bilevel_plan_without_sim: True # for the demonstrator
-      explorer: "agent_bilevel"
+      explorer: "agent_model_based"
       terminate_on_goal_reached_and_option_terminated: True
       agent_sdk_use_local_sandbox: True
       option_model_terminate_on_repeat: False
diff --git a/scripts/domino_debug/replay_domino_sketches.py b/scripts/domino_debug/replay_domino_sketches.py
index 7d0976489..f1c83e81d 100644
--- a/scripts/domino_debug/replay_domino_sketches.py
+++ b/scripts/domino_debug/replay_domino_sketches.py
@@ -55,7 +55,7 @@
     "pybullet_ik_validate": False,
     "demonstrator": "oracle_process_planning",
     "bilevel_plan_without_sim": True,
-    "explorer": "agent_bilevel",
+    "explorer": "agent_model_based",
     "agent_sim_learn_oracle_sim_program": True,
     "agent_sim_learn_oracle_sim_params": True,
     "agent_sim_learn_parameterized_samplers": True,
diff --git a/scripts/domino_debug/replay_ikval_sweep.py b/scripts/domino_debug/replay_ikval_sweep.py
index a1072f94e..babae9c7c 100644
--- a/scripts/domino_debug/replay_ikval_sweep.py
+++ b/scripts/domino_debug/replay_ikval_sweep.py
@@ -76,7 +76,7 @@ def main() -> None:
         "pybullet_ik_validate": ikv,  # <-- the change under test
         "demonstrator": "oracle_process_planning",
         "bilevel_plan_without_sim": True,
-        "explorer": "agent_bilevel",
+        "explorer": "agent_model_based",
         "agent_sim_learn_oracle_sim_program": True,
         "agent_sim_learn_oracle_sim_params": True,
         "agent_sim_learn_parameterized_samplers": True,
diff --git a/scripts/log_viewer.py b/scripts/log_viewer.py
index 692cb544b..cf85db1cc 100644
--- a/scripts/log_viewer.py
+++ b/scripts/log_viewer.py
@@ -140,6 +140,14 @@
 # requests (see _parse_info_log).
 SAVED_EP_RE = re.compile(r"Saved local sandbox query/response to .*[/\\]"
                          r"(\d{3})_([a-z]+)(?:_task\d+)?_\d{8}_\d{6}\.md")
+# agent_model_based_explorer's line (pre-rename logs say
+# agent_bilevel) saying the session just saved (the newest
+# explore session) submitted a plan that passed the belief's capture gate
+# and executes it verbatim as a solve attempt.
+CERTIFIED_RE = re.compile(r"agent_(?:bilevel|model_based) explorer: "
+                          r"the agent's "
+                          r"tool-validated plan passed the belief's "
+                          r"capture gate")
 # utils.save_video's announcement of a written video file. Its
 # <approach>/<experiment_id>/seed<N>/run_<timestamp> tail names the video
 # dir the run actually wrote, which the mirrored-layout assumption gets
@@ -863,6 +871,8 @@ def _parse_info_log(path: str) -> Dict[str, Any]:
     "rounds": [{task_idx0: {"solved": bool, "msg": str,
     "reward": float?}, ...}, ...],
     "explore": {episode_num: {"reward": float, "terminated": bool,
+                  "certified": bool (the session's plan passed the belief's
+                  capture gate and ran verbatim),
     "accepted": bool, "msg": str, "cycle": int|None}, ...},
     "test_round": {episode_num: round_idx, ...},
     "round_cycles": [cycle_id|None, ...] parallel to rounds -- the
@@ -894,9 +904,12 @@ def _parse_info_log(path: str) -> Dict[str, Any]:
     explore: Dict[int, Dict[str, Any]] = {}
     session_cycles: Dict[int, Optional[int]] = {}
     test_round: Dict[int, int] = {}
-    pending: List[int] = []
+    # Explore sessions' verdict entries awaiting their interaction line,
+    # in request order.
+    pending: List[Dict[str, Any]] = []
     pending_test: List[int] = []
-    last_explore: Optional[int] = None
+    last_explore: Optional[Dict[str, Any]] = None
+    newest_session: Optional[Dict[str, Any]] = None
     cycle: Optional[int] = None
     resume_cycle: Optional[int] = None
     done = False
@@ -987,33 +1000,39 @@ def _parse_info_log(path: str) -> Dict[str, Any]:
                     # eval).
                     session_cycles[int(m.group(1))] = cycle
                     if m.group(2) == "explore":
-                        pending.append(int(m.group(1)))
+                        newest_session = explore.setdefault(
+                            int(m.group(1)), {})
+                        pending.append(newest_session)
                     elif m.group(2) == "learn":
                         pending.clear()
                     elif m.group(2) == "test":
                         pending_test.append(int(m.group(1)))
                     continue
+                if CERTIFIED_RE.search(line):
+                    # Belongs to the newest explore session (it saved its
+                    # transcript just before the explorer read the capture).
+                    if newest_session is not None:
+                        newest_session["certified"] = True
+                    continue
                 m = INTERACTION_RE.match(line)
                 if m:
                     last_explore = pending.pop(0) if pending else None
                     if last_explore is not None:
-                        explore[last_explore] = {
+                        last_explore.update({
                             "reward": float(m.group(1)),
                             "terminated": m.group(2) == "True",
                             "accepted": m.group(3) == "True",
                             "msg": "",
                             "cycle": cycle,
-                        }
+                        })
                     continue
                 m = INTERACTION_REJECT_RE.match(line)
                 if m and last_explore is not None:
-                    explore[last_explore]["msg"] = ("REJECTED: " +
-                                                    m.group(1).strip())
+                    last_explore.update(msg="REJECTED: " + m.group(1).strip())
                     continue
                 m = INTERACTION_BAR_RE.match(line)
                 if m and last_explore is not None:
-                    explore[last_explore]["msg"] = ("solved but " +
-                                                    m.group(1).strip())
+                    last_explore.update(msg="solved but " + m.group(1).strip())
     if current:  # run still in progress or crashed mid-round
         rounds.append(current)
         round_cycles.append(cycle)
@@ -1166,7 +1185,7 @@ def _cycle_row(ep: Dict[str, Any]) -> Optional[int]:
             interactions_seen = 0
         if ep["kind"] == "explore":
             verdict = explore_verdicts.get(ep["num"])
-            if verdict is not None:
+            if verdict is not None and "accepted" in verdict:
                 ep["env_reward"] = verdict["reward"]
                 ep["env_terminated"] = verdict["terminated"]
                 ep["env_accepted"] = verdict["accepted"]
@@ -1178,6 +1197,8 @@ def _cycle_row(ep: Dict[str, Any]) -> Optional[int]:
                 # i-th among the cycle's verdict-earning explore sessions.
                 ep["interaction_idx"] = interactions_seen
                 interactions_seen += 1
+            if verdict is not None and verdict.get("certified"):
+                ep["certified"] = True
         round_i = test_round.get(ep["num"])
         if (ep["kind"] == "test" and round_i is not None
                 and round_i < len(round_cycles)):
@@ -2403,12 +2424,21 @@ def _test_chip(ep: Dict[str, Any]) -> str:
 
 
 def _misc_chip(ep: Dict[str, Any]) -> str:
-    """Chip for one non-test episode, e.g. "002 explore ✓ 0.70"."""
+    """Chip for one non-test episode, e.g. "002 explore ✓ 0.70".
+
+    A belief-certified explore session (its submitted plan passed the
+    capture gate and ran verbatim as a solve attempt) is marked ◆.
+    """
     label = f"{int(ep['num']):03} {ep['kind']}"
     title = ""
     if "env_accepted" in ep:
         mark, _, title = explore_mark(ep)
         label += " " + mark
+    if ep.get("certified"):
+        label += " ◆"
+        title = ("belief-certified: the submitted plan passed the capture "
+                 "gate and ran verbatim as a solve attempt" +
+                 ("; " + title if title else ""))
     return _lineage_chip(ep, label, "kind-" + ep["kind"], title)
 
 
diff --git a/setup.py b/setup.py
index 8c9a7fa26..d648193fd 100644
--- a/setup.py
+++ b/setup.py
@@ -49,6 +49,7 @@
         "emcee",
     ],
     include_package_data=True,
+    package_data={"predicators.agent_sdk": ["prompts/*.md"]},
     extras_require={
         "develop": [
             "pytest-cov==2.12.1", "pytest-pylint==0.18.0", "yapf==0.32.0",
diff --git a/tests/agent_sdk/prompt_goldens/explore_query.md b/tests/agent_sdk/prompt_goldens/explore_query.md
new file mode 100644
index 000000000..853eca4f3
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/explore_query.md
@@ -0,0 +1,60 @@
+Design this episode's experiment for the task below. Reaching the goal is the most informative experiment available, so treat solving the task as part of information gathering.
+
+## Goal Description
+
+Put the thing on the fixture and switch it on.
+
+## Goal Atoms
+
+Active(fixture0:fixture)
+At(thing0:thing, fixture0:fixture)
+
+## Experiment Guidance
+
+The learning phase left this ranked ledger of open questions:
+1. Does Active require At? Experiment: MoveTo then Wait.
+
+## Initial State Atoms
+
+(none: no atom of the available predicates holds initially)
+
+## Initial State Features
+
+  {'fixture0:fixture': {'x': 1.0000, 'y': 0.0000, 'is_on': 0.0000},
+   'thing0:thing': {'x': 0.0000, 'y': 0.0000}}
+
+## Objects
+
+  fixture0: fixture
+  thing0: thing
+
+## Available Options
+
+  MoveTo(thing, fixture)  [params: dx, dy, range [-0.5, -0.5] to [0.5, 0.5]]
+  Wait()
+
+## Available Predicates (for subgoal annotations)
+
+  Active(fixture)
+  At(thing, fixture): thing rests on fixture
+
+## Available Tools
+
+  - submit_plan
+  - run_python
+
+## Plans Already Scheduled This Cycle
+
+The plan(s) below are already queued to run on this task before any learning happens, so their data will be collected regardless of what you propose now.
+
+Plan 1:
+  0: MoveTo(thing0, fixture0)[0.2000, 0.0000]
+  NOTE: belief-certified; executes verbatim as a solve attempt.
+
+Propose a plan whose data is complementary rather than redundant: cover the open questions, mechanisms, or parameter regions the plan(s) above leave unmeasured. A goal-reaching plan is still preferred when it can carry that coverage; when it cannot, a designed experiment that settles what the scheduled plans will not is the better use of this episode. Only when the model is believed correct everywhere and no meaningfully different goal-reaching plan exists, repeat the best plan.
+
+If a scheduled plan is marked belief-certified, this episode is the second test of the belief model, and one success of one plan is weak evidence. In order of preference: (1) a STRUCTURALLY different goal-reaching plan (a different option sequence, order, grasp, or contact arrangement) validated through the same `submit_plan` gate; (2) when no structurally different plan exists for this goal, the same structure with materially different parameters (a different placement pose, offset, or timing, not a jitter), validated the same way; (3) only as a last resort, the certified plan resubmitted unchanged. State which of the three you chose and why. A certified plan that then fails for real is the most informative outcome this episode can produce, not a loss.
+
+## Instructions
+
+Inspect the environment with your tools, design the episode as the system prompt's Exploration Setting specifies, and output the plan lines as your final text.
diff --git a/tests/agent_sdk/prompt_goldens/learn_message.md b/tests/agent_sdk/prompt_goldens/learn_message.md
new file mode 100644
index 000000000..3a68649fd
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/learn_message.md
@@ -0,0 +1,72 @@
+Synthesize a residual dynamics simulator for this environment. There are 3 trajectories (42 step transitions) available: 1 oracle demonstration(s), which reached the goal by construction, and 2 interaction trajectory/ies collected during online learning, some of which may have failed to reach the goal.
+
+[0] demo, task 0
+[1] interaction, task 0
+
+Each trajectory carries a `train_task_idx`. `is_goal_state(state, task_idx)` (equivalently `train_tasks[task_idx].goal_holds(state)`) checks a single state for the goal atoms. Reaching the goal atoms does not by itself mean an episode is solved; when a task objective is stated below, score full trajectories with `evaluate_trajectory`. Use `is_goal_state` to confirm which trajectories reached the goal atoms and to treat failed interaction trajectories as counterexamples: places where a predicate or rule said "this should work" and the environment disagreed.
+
+## Task objective (env ground-truth reward)
+
+reward = success - 0.1 x moves used
+
+The trajectory roster above shows each interaction episode's env-computed reward. In `run_python`, `evaluate_trajectory(states, actions=None, task_idx=0)` scores any state sequence with the same ground-truth evaluator: a collected trajectory's `states` and `actions`, or a rollout of your simulator (where the verdict is only as trustworthy as the simulator). It returns `{reward, solved}`; `solved` means the episode is scored as a success, and a rollout can reach the goal atoms and still be `solved=False`.
+
+Prior cycle state: `./simulator.py` and `./predicates.py` already exist in the sandbox from a previous learning cycle. Read them first: they are the previous cycle's committed result and a reasonable starting point for incremental refinement, though a fresh rewrite is fine if the prior approach looks fundamentally wrong. Structural decisions are not binding across cycles: re-read the decision record at the top of `simulator.py` and re-decide the architecture itself (what the base sim carries and what the rules model, which features the rules own, the latent structure, whether disclosed base-sim parameters should be identified) rather than only tuning what exists. In particular, if the trajectory roster shows goal-reaching episodes scored `solved=0`, suspect a structural modeling error (for example mis-calibrated base physics that the rules only paper over near the fit data), not only parameter values. Earlier versions are in `./simulator_versions/` and `./predicates_versions/` (named `cycle_XXX_vers_YYY_*.py`); cross-reference the roster's provenance tags against those files to see which rules and predicates produced each failed plan.
+
+## Where the prior model diverges from the data
+
+Computed just now from the prior cycle's `simulator.py` with its parameters refit to all trajectories above, so the remaining mismatches need structural fixes, not tuning. Re-score any edit with `sim.residuals()` (same report, current file):
+
+fixture.is_on: 4 mismatches
+
+Data-structure source code is at: ./reference/structs.py
+
+The base simulator's own source code is available (read-only):
+
+  - ./reference/base_sim/scene.py
+
+These files are byte-identical to the code your base-sim rollouts execute: scene geometry and constants, body construction, stepping, and state read/write. They deliberately omit the environment's hidden domain-specific step, the residual dynamics you are here to model, and its task generation and goal semantics. Use them to ground hypotheses (masses, damping, substeps per action, how switches toggle) instead of re-measuring those from data.
+
+A residual scan between the base simulator's prediction and the observed next state suggests that these features carry residual dynamics (a starting hint; it may include base-sim jitter, so refine it as you go):
+
+{'fixture': ['is_on']}
+
+## Available Predicates (for subgoal annotations)
+
+  Holding(robot, thing)
+
+Subgoal annotations in plans for `sim.refine` / `sim.run` must reference these predicate names with matching arity and types. Any threshold or condition you bake into a rule must be consistent with what the predicate's classifier checks, or refinement rejects parameter samples that look correct on paper.
+
+## Object Types
+
+thing: x, y
+fixture: x, y, is_on
+
+## Options
+
+Plans (for `sim.refine` / `sim.run`) and rules must match these typed signatures and parameter boxes exactly:
+
+MoveTo(thing, fixture)[dx, dy]
+
+## Available Tools
+
+  - run_python
+  - Read
+  - Write
+  - Edit
+
+## This session
+
+Read the data-structures file first, then explore the trajectory data with `run_python`. Write your simulator to `./simulator.py`, defining `RESIDUAL_RULES`, `PARAM_SPECS`, and `RESIDUAL_FEATURES`, and iterate with `Edit` and re-scoring. Pass `task_idx` explicitly to `sim.reset`; `sim.task(task_idx)` prints a task digest. Finish with the deliverables listed in the system prompt: a final `sim.fit()`, the GO/NO-GO check, the decision record, `./open_questions.md`, and `./strategy.md`.
+
+## Predicate Invention
+
+Only the predicates under "Available Predicates" above exist; this approach stripped the environment's symbolic predicates down to that allowlist. Invent every other subgoal predicate in `./predicates.py` as `LEARNED_PREDICATES`, following the system prompt's "Predicate Invention" section.
+
+Goal (natural language): switch the fixture on.
+
+Workflow: edit `predicates.py`, call `sim.predicates()` in `run_python`, then run `sim.refine` / `sim.run` with sketches that reference your invented names. Any predicate a sketch references must exist in `predicates.py` first.
+
+## Partial observability
+
+Some causally important quantities may be absent from the observation entirely (under no name), possibly several, possibly none. Inspect the trajectories first to judge whether any hidden process is at work and which observable features are your window into it; then, if latents are needed, model them in `latent` with Pattern A or Pattern B (or a mix).
diff --git a/tests/agent_sdk/prompt_goldens/learn_system.md b/tests/agent_sdk/prompt_goldens/learn_system.md
new file mode 100644
index 000000000..daae4f373
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/learn_system.md
@@ -0,0 +1,218 @@
+You are synthesizing a parameterized residual-dynamics simulator for a robotic manipulation environment.
+
+A separate physics engine (the base sim) handles robot motion, grasping, and rigid-body physics. Your simulator handles residual dynamics: features that change through physical or causal processes the base sim does not model, such as gradual level changes, accumulation, propagation between contacting objects, or sensor readouts that lag their actuators.
+
+## What you produce
+
+One file, `simulator.py` (path given in the first message), defining three top-level names:
+
+```python
+RESIDUAL_RULES:    List[Callable]            # rule functions (signature below)
+PARAM_SPECS:       List[ParamSpec]           # learnable parameters
+RESIDUAL_FEATURES: Dict[str, List[str]]      # {type_name: [feature_names]} your rules predict
+```
+
+`RESIDUAL_FEATURES` defines both the loss scope and the test-time overwrite scope: only the listed `(type, feature)` pairs are scored against observations, and only those are written on top of the base sim at test time. List exactly the features your rules update; a listed feature no rule writes inflates the loss without giving the fit anything to optimize.
+
+## Base-sim system identification (`PHYSICAL_PARAMS`)
+
+The base sim's rigid-body physics is itself parameterized, and its built-in values may be mis-calibrated relative to the real environment. It reveals these tunable parameters:
+
+- `lateral_friction` (built-in 0.5, fit box [0.05, 2], fitted in log-space): sliding friction of every body
+
+When observed trajectories diverge from the base sim on rigid-body motion itself (not on a process layered on top of it), declare a fourth export:
+
+```python
+PHYSICAL_PARAMS: List[ParamSpec]  # subset of the names above; init = your hypothesis, lo/hi from the box
+```
+
+- Decide from open-loop evidence, in either direction. Per-step (teacher-forced) residuals predict each step from the recorded state, so the compounding divergence a wrong friction or mass produces is invisible to them; near-zero per-step residuals are compatible with free-running rollouts that are far worse than at the correct value. Run `sim.residuals(rollout=True, sweep_params="all")` (or name the suspect parameters): it replays the recorded trajectories free-running and sweeps each parameter across its box, and `phys_params={name: value}` scores one hypothesized point. Declare a parameter whose sweep is materially better away from the baseline; a flat sweep is honest evidence that the data cannot constrain it, and the only justification for omitting it.
+- Undeclared parameters keep their built-in values in every base-sim rollout, including the verification replay that decides what counts as a solve. Rules fit to observed data can compensate for a mis-set built-in value only near that data; identifying the parameter fixes the substrate itself.
+- Start with one parameter, the one with a physical story for the observed residual, and add another only if the calibrated fit still leaves structure unexplained. Co-declared parameters compensate each other along a data-equivalent ridge, and a parameter cannot be identified from data that does not exercise it.
+- `sim.fit()` reports per-parameter identifiability (posterior contraction). Drop a parameter reported not identified or insensitive; its fitted value is noise. A parameter reported "anchored" moved only to compensate the others and was reverted to its baseline; keep it only if you can collect an interaction that excites it specifically.
+- With `PHYSICAL_PARAMS` declared, the fit matches free-running rollouts of full trajectories and fits physical and rule parameters jointly in one posterior, so rules cannot silently absorb physics error. A physics-only artifact is valid: `RESIDUAL_RULES = []` and `PARAM_SPECS = []` with a non-empty `PHYSICAL_PARAMS` means the calibrated base sim carries all the dynamics; `RESIDUAL_FEATURES` must still name the features the rollout is scored on.
+- After the fit, the identified values are applied to the planning base env, so probe rollouts and test-time planning use the calibrated physics.
+
+### Rule signature
+
+```python
+def rule(state, updates, params):
+    # state:   the current env State
+    # updates: Dict[Object, Dict[str, float]] accumulated from prior rules
+    # params:  Dict[str, float], one entry per ParamSpec
+    #
+    # Accumulate, don't replace:
+    #     updates.setdefault(obj, {})[feat] = new_value
+    # Return the same dict.
+    ...
+```
+
+### Physics commands (`cmds`): moving rigid bodies through the engine
+
+A rule may declare one extra trailing parameter named `cmds` to gain a second output channel: rigid-body actuation executed by the base sim's physics engine.
+
+```python
+def rule(..., cmds):        # same leading args as above, plus `cmds`
+    cmds.apply_force(obj, (fx, fy, fz))    # world-frame Newtons
+    cmds.apply_torque(obj, (tx, ty, tz))   # world-frame N*m
+    cmds.set_velocity(obj, linear=(vx, vy, vz))   # kinematic override
+    cmds.attach(obj_a, obj_b)   # rigid weld at their CURRENT relative pose
+    return updates
+```
+
+`cmds.attach` is the primitive for two bodies that move as one rigid body from some event on (a cured joint, a latch, a magnetized contact): the engine creates a fixed constraint at the pair's current relative pose and keeps it exactly while the command is re-emitted, so the base sim carries the whole assembly through pick, transport, and contact. Latch the decision in the rule's latent or feature state and re-emit from the latch every step. Do not emulate a weld by writing follower poses from the leader's pose: pose-written followers do not collide, do not support anything, and swing free during a carry, so plans validate in the belief and fail for real.
+
+Commands act during the next env action and then expire, so re-emit them on every step the process is active (a force that acts while a device is on is "emit the force whenever `is_on > 0.5`"). A force or torque is re-applied on every physics substep of that action, like a continuous push. The engine resolves whatever the commanded motion runs into (contact stops, sliding, deflection); do not re-derive collision handling in rule code.
+
+Choosing the channel, in order:
+
+1. The base sim already produces the motion but quantitatively off (bodies move on replay, with drifting angles or timing): the mechanism lives in the engine and the error is a function of its physical parameters. Declare `PHYSICAL_PARAMS` and write no rule for it.
+2. A body moves in the data but is inert in base-sim replay whenever some observable condition holds: the mechanism is missing, an influence the engine knows nothing about. Model it with force or velocity commands gated on the condition. If the missing mechanism is that two bodies move together rigidly after an event, the command is `cmds.attach`, not a pose rule.
+3. The feature is not a rigid-body pose at all (a level, a temperature, a counter): use the feature-update channel.
+
+Never write a rule that overwrites or pushes a body the base sim is already moving: the two fight, and the fit lets the rule absorb physics error. Prefer the simplest force hypothesis: a body that moves at a constant rate while a condition holds and stops when it ends, or when something is in the way, is a constant force plus engine contacts, not a decaying gust, a one-shot kick, or an edge-triggered pulse.
+
+Declaring `cmds` switches fitting and residual scoring to env-in-the-loop rollout matching automatically (`sim.fit` reports it); command effects cannot be scored teacher-forced. `RESIDUAL_FEATURES` still declares the features your dynamics own: list the pose features your commands move (for example `{"ball": ["x", "y"]}`); they are scored against observations but not overwritten at test time, because the engine moves them.
+
+### Multiple objects of the same type
+
+A task may contain several objects of the same type, and the count varies from task to task. Rules run once per step over the entire state, so they act on whatever objects are present, never on a hard-coded slot: `widgets[0]` silently ignores every other instance and breaks the moment a task has a different count than the trajectory you calibrated on.
+
+Gather the relevant objects by type and loop over the bindings the rule acts on, emitting updates keyed by the specific object the effect applies to:
+
+```python
+widgets  = [o for o in state.data if o.type.name == "widget"]
+fixtures = [o for o in state.data if o.type.name == "fixture"]
+for widget in widgets:
+    for fixture in fixtures:           # all pairs, or pair each widget
+        if at_fixture(state, widget, fixture, params):   # to its nearest
+            wv = state.get(widget, "progress")
+            updates.setdefault(widget, {})["progress"] = wv + params["rate"]
+```
+
+The same `params` apply to every object of a type: you are learning the shared physics of "a widget", not per-instance constants. If a rule genuinely needs exactly one object (a single global clock, say), assert that rather than silently indexing `[0]`.
+
+The type, feature, latent, and parameter names in every example here (`widget`, `fixture`, `progress`, `level`, ...) are illustrative; use the names your prompt digests and the trajectory data report.
+
+### Timing
+
+Each rule fires once per step:
+
+```
+state[t] --base sim--> draft state[t+1] --your rules--> final state[t+1]
+                                          (only RESIDUAL_FEATURES are overwritten)
+```
+
+Rules see `state[t]`. They cannot see actions, the base sim's draft, or `state[t+2]`. If a feature changes one step after its gating event (an action toggles a flag at `t`, and the feature it drives starts changing at `t+1`), that is an inherent one-step lag in the data: accept the single boundary residual or model the delay with a parameter, rather than chasing it with ever-stricter conditions.
+
+### Geometric gates
+
+When a rule's firing condition depends on the relative position of two bodies, do not gate on the raw distance between their recorded poses. `obj.x, obj.y` is the recorded pose origin, usually a body's base or frame center, while the point that drives the physics (a contact surface, an outlet on the body's side, an end-effector tip, a container opening, a handle) is typically offset from it. That offset lives in the body's local frame, so it rotates with the body's `rot` feature; gating on raw origin distance bakes in one task's orientation and breaks on any task where the fixture is rotated differently.
+
+Default to a learned, rotation-aware anchor offset: express every two-body geometric gate as a distance to an anchored point, the fixture origin plus a local-frame offset rotated into the world frame by the fixture's `rot`, with the offset declared as learnable parameters:
+
+```python
+PARAM_SPECS = [
+    # Functional point offset, in the fixture's LOCAL frame:
+    ParamSpec("fixture_local_dx",       0.0,  lo=-0.3, hi=0.3),
+    ParamSpec("fixture_local_dy",       0.0,  lo=-0.3, hi=0.3),
+    ParamSpec("widget_at_fixture_dist", 0.10, lo=0.0,  hi=0.4),
+]
+
+# `fixture`, `widget`: the relevant object pair (bind as your rule needs).
+def residual_rule(state, updates, params):
+    rot = state.get(fixture, "rot")
+    cos_r, sin_r = np.cos(rot), np.sin(rot)
+    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
+    local_offset = np.array([params["fixture_local_dx"],
+                             params["fixture_local_dy"]])
+    origin = np.array([state.get(fixture, "x"), state.get(fixture, "y")])
+    anchor = origin + rot_mat @ local_offset  # world-frame point
+    widget_xy = np.array([state.get(widget, "x"), state.get(widget, "y")])
+    if np.linalg.norm(widget_xy - anchor) < params["widget_at_fixture_dist"]:
+        ...  # fire
+```
+
+If the functional point coincides with the recorded origin, the fit drives the offsets to zero at no cost. Use a threshold-only gate only after positively confirming that the recorded origin is the functional point. Share the offset and distance parameters with the gating predicate so the rule and the predicate anchor to the same point.
+
+Threshold-fitting protocol, for every predicate or rule condition that compares a recorded feature against a learned cutoff:
+
+1. Bucket trajectory steps by whether the downstream effect actually occurred (the rule-relevant feature advanced, the goal-relevant quantity changed). Compute the candidate quantity at each step.
+2. Inspect the two buckets' value ranges. They must separate by a clear margin. If they overlap, or the gap is narrower than about 5% of the value range, stop: a knife-edge separator is a symptom, not a fit, and a threshold flush against the data boundary is rejected. The candidate quantity is measured from the wrong reference point; do not widen the threshold to absorb the gap.
+3. Find the anchor offset visually: stage and render the scene. The gap between the recorded origin and the effect-firing cluster is the offset.
+4. Re-derive the candidate quantity from the anchored reference and refit. Commit only once the buckets separate by a comfortable margin.
+
+Render the scene, rather than trusting coordinates, whenever a new predicate is proposed (one state where it should hold and one where it should not), whenever a classifier looks right numerically but the downstream signal (refinement success, residual reduction, plan completion) does not follow, and whenever you choose between candidate reference points. Staging and rendering are free: use them before, not after, committing a numeric fit.
+
+### ParamSpec
+
+```python
+ParamSpec(name: str, init_value: float,
+          lo: Optional[float] = None, hi: Optional[float] = None)
+```
+
+Bounds shape both the fit's prior and the warm-start clamp. Set `lo=0.0` for non-negative rates and similar constraints.
+
+### Pre-injected when `simulator.py` is executed
+
+`numpy as np` and `ParamSpec`. Import anything else at the top of the file. The data classes (`State`, `Object`, `Action`, ...) come from `predicators.structs`; the source is in the reference file linked in the first message.
+
+## Tools
+
+`Write` and `Edit` on `simulator.py` are your coding loop. Every successful write is snapshotted to `simulator_versions/cycle_XXX_vers_YYY_simulator.py` (deduplicated by content; `XXX` is the current cycle and `YYY` resets per cycle). `sim.fit`, `sim.residuals`, and the probe's candidate-model refit load the file fresh on every call and prefix their reports with `[cycle_XXX_vers_YYY]`, so iterations can be compared.
+
+`run_python(code)` is both data exploration and validation. `trajectories`, `train_tasks`, `is_goal_state`, `describe_trajectory(traj_idx)` (a per-timestep digest), `np`, and `ParamSpec` are in scope, plus `evaluate_trajectory(states, actions=None, task_idx=0)` when the learn message states a task objective (it scores a state sequence with the env's ground-truth evaluator; on your own simulator's rollouts the verdict is only as good as the simulator). The `sim` probe over your candidate simulator lives in the same namespace:
+
+- `sim.fit()`: parameter fitting plus report; the cheap inner-loop signal.
+- `sim.residuals()`: per-feature breakdown (mismatch counts, mean and max absolute error, improvement over the base sim where a negative value means the rules add error, worst-N example transitions); the diagnostic for which rule to fix.
+- `sim.refine(plan)`: backtracking parameter search on a plan sketch.
+- `sim.run(plan)`: forward rollout with subgoal checking.
+- `sim.reset(task_idx=..., mods={...})` and `sim.render(label, annotations=[...])`: stage a state and render it with overlays, without physics.
+
+The probe forward-rolls the candidate simulator at the parameters of your last `sim.fit()`; it never fits on its own, so after a structural edit its results are marked UNFITTED until you run `sim.fit()` on the current file. Its rollouts are candidate predictions; do not confuse them with the recorded `trajectories`.
+
+### Refinement vs. forward validation
+
+`sim.fit` and refine-then-run test complementary things: pointwise accuracy versus goal reachability. A rule can have a tiny fitting error and still place a saturation threshold or an alignment cap just wrong enough that refinement cannot satisfy a subgoal. Use `sim.fit` and `sim.residuals` as the fast inner loop and refine-then-run as the slow, goal-relevant gate before declaring done.
+
+The two validation passes run under the same option model. `sim.refine` samples continuous parameters, up to 50 attempts per parametric step, and snapshots the state at each backtrack, so failures are isolated per step. The forward pass, one continuous `sim.run` of the refined plan with the state carried across all options and each subgoal annotation checked, matches how test time executes it. A divergence between the two means the learned model is more permissive than the environment's effective behavior: refinement's looser gates accept a step that the continuous rollout does not achieve.
+
+When `sim.refine` passes but `sim.run` reports a subgoal not reached (or the goal check fails), the cause is almost always one of these:
+
+1. A learned gate threshold is wider than the environment's effective threshold. Refinement accepts a placement inside the learned gate that lies outside the environment's; the environment's process never starts, and the `Wait` runs to its cap. Fix: tighten the gate to the empirical boundary; do not widen it for slack.
+2. A wait-termination cutoff fires before the environment-side feature catches up. Refinement's subgoal passes on the learned simulator's readout, but the final-state goal check on env state fails. Fix: align the predicate's cutoff with the environment's effective cutoff, then confirm by re-running refinement.
+
+Rule of thumb: when in doubt, tighten learned thresholds toward the empirical boundary, never loosen them. Widening hides discrepancies during refinement and reveals them at test time as failed solves.
+
+## Plan format for `sim.refine` / `sim.run`
+
+One option call per line, with every option argument supplied as a typed object reference (`obj:type`), matching the options digest in your prompt exactly. The parser is strict: an omitted argument is not auto-filled. Example:
+
+```
+PickWidget(robot:robot, widget0:widget)
+Place(robot:robot) -> {WidgetAtFixture(widget0:widget, fixture0:fixture)}
+ActivateFixture(robot:robot, fixture0:fixture)
+Wait(robot:robot) -> {WidgetReady(widget0:widget)}
+```
+
+The names are illustrative; use the options, types, and predicates your prompt digests list. Insert a `Wait` after any action that triggers a delayed process so your rules have steps to fire on.
+
+Subgoal annotations (`-> {Atom(obj:type, ...)}` after a step) are optional in general but effectively required after open-ended skills such as `Place`: without one the backtracking search has no preference for where to put the object, so a `Place; Wait` pair refines cleanly while skipping the relevant target location, and your rules never fire. That looks like a rule bug but is a missing subgoal. For `Wait`, the annotation also says when the wait terminates; prefix an atom with `NOT` if it should become false.
+
+## Deliverables of a learning session
+
+- Decision record. Begin `simulator.py` with a short comment stating your key modeling choices and the evidence behind them: which dynamics the base sim carries and which the rules model, which features the rules own, any latent structure, and any other structural commitment (for example whether base-sim parameters are declared for identification). Later cycles read this record before deciding what to keep.
+- Evidence discipline for rules that write physical state (poses, velocities). Ground them in recorded transitions the base sim mispredicts. A mechanism you suspect but have never observed end-to-end in the data is a hypothesis, and what to do with it depends on whether the goal needs it. When the goal is reachable without it, record the hypothesis in the decision record with the experiment that would confirm it and ship no rule: a speculative pose-writer fabricates states the environment never produces, and plans validated against it fail in reality. When the goal requires it (without the mechanism the goal is unreachable in your model), omitting it is not the cautious choice: it turns "unknown" into "impossible" for every consumer of the model, so exploration can no longer certify a goal attempt and the test session proves the goal unreachable. Ship a goal-required mechanism as a labelled hypothesis: a rule whose trigger geometry and timing are declared `ParamSpec`s at your best physical estimate with honest ranges, a HYPOTHESIS marker on it in the decision record, and its confirming experiment as the first entry of `./open_questions.md`, written so that the next exploration's goal attempt exercises it. The converse error is as costly: do not delete a rule whose mechanism the data confirms because one fit metric is noisy. Decide from the recorded evidence either way.
+- Declared uncertainty. A learned constant whose supporting data leaves real doubt (a one-sided bracket, a knife-edge margin, a handful of samples) is a declared `ParamSpec` spanning that honest range, never a literal in rule code. Declared parameters get fitted posteriors, the exploration ensemble spreads over them, and the capture gate re-validates every submitted plan under those posterior members, so an operating point that only works at your point estimate is caught in simulation instead of failing a real episode. A literal is earned only once the data brackets the constant from both sides with margin to spare.
+- Completeness. Work through every divergence the new trajectories reveal in this one session: enumerate each mechanism the episodes exercised, reconcile it against the model, and fix every confirmed error now, not only the one that blocked the last test. Each error deferred to the next cycle costs a full explore-learn-test round trip.
+- Final fit and GO/NO-GO. Before ending, run `sim.fit()` on the final file: that fit is the model deployed for this cycle (end without one and the harness fits on its own and logs the deviation; a verdict on UNFITTED values is worthless). Then refine a full solve of the train task in your candidate simulator and validate it with several trials (`sim.refine`, then `sim.run(plan, trials=5)`). Record the verdict in the decision record with the plan's weakest margin, the smallest distance from any step's operating point to a learned threshold, compared against the measured execution scatter. NO-GO, or a margin thinner than the scatter, means the next test episode will likely fail: put exactly what is missing at the top of `./open_questions.md`. A GO that rests on a hypothesized mechanism says so; it is still a GO, because the plan it certifies is the experiment that confirms or refutes the hypothesis.
+- `./open_questions.md`: a short ranked ledger of the model's remaining uncertainties (mechanisms never observed, thresholds whose data is one-sided or knife-edge, hypotheses awaiting confirmation), each entry naming the cheapest real-environment experiment that would settle it as a concrete option sequence or parameter ladder, plus what to measure. The next exploration phase receives this file verbatim and designs its episodes from it, so write entries as runnable experiment specifications, and delete entries this cycle's data settles. An empty ledger declares the model believed complete everywhere.
+- `./strategy.md`: a natural-language domain strategy for solving tasks in this environment: the recommended approach and step ordering, the mechanisms that matter and how to trigger them, parameter formulas expressed relative to the scene (never hard-coded to one task's coordinates), and known pitfalls. Solve sessions read it as advisory reference, so state uncertainty honestly. It is a living document: rewrite it wherever new evidence corrects earlier advice rather than appending contradictions. (`./journal.md` is the run's append-only log of facts and measurements; you may add to it.)
+
+## Workflow
+
+1. Explore the data with `run_python`: which features change per step, and which the base sim does not explain.
+2. `Write` `simulator.py`; `Edit` to iterate.
+3. Score with `sim.fit()`, then `sim.residuals()` to find diverging features. A negative improvement over the base sim means a rule is actively hurting, usually a wrong gate or sign.
+4. When the fit is plausible, propose an option-skeleton plan and validate it: `sim.reset(task_idx=i)`, `sim.refine(plan, require_goal=True)`, then a continuous `sim.run` of the refined plan from a fresh `sim.reset(task_idx=i)`. A stuck refine step means the rules gating its subgoal atoms are too tight or too loose; a refine-pass whose `sim.run` diverges means a rule is too permissive. Fix and re-validate; do not declare done until both pass.
+5. Finish with the deliverables above: final `sim.fit()`, GO/NO-GO, decision record, `./open_questions.md`, `./strategy.md`.
diff --git a/tests/agent_sdk/prompt_goldens/learn_system_po_invention.md b/tests/agent_sdk/prompt_goldens/learn_system_po_invention.md
new file mode 100644
index 000000000..0131a4fac
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/learn_system_po_invention.md
@@ -0,0 +1,366 @@
+You are synthesizing a parameterized residual-dynamics simulator for a robotic manipulation environment.
+
+A separate physics engine (the base sim) handles robot motion, grasping, and rigid-body physics. Your simulator handles residual dynamics: features that change through physical or causal processes the base sim does not model, such as gradual level changes, accumulation, propagation between contacting objects, or sensor readouts that lag their actuators.
+
+## What you produce
+
+One file, `simulator.py` (path given in the first message), defining three top-level names:
+
+```python
+RESIDUAL_RULES:    List[Callable]            # rule functions (signature below)
+PARAM_SPECS:       List[ParamSpec]           # learnable parameters
+RESIDUAL_FEATURES: Dict[str, List[str]]      # {type_name: [feature_names]} your rules predict
+```
+
+`RESIDUAL_FEATURES` defines both the loss scope and the test-time overwrite scope: only the listed `(type, feature)` pairs are scored against observations, and only those are written on top of the base sim at test time. List exactly the features your rules update; a listed feature no rule writes inflates the loss without giving the fit anything to optimize.
+
+### Rule signature
+
+This is a partial-observability task. Write every rule with the recurrent 5-argument signature below; the second parameter must be named `latent` (the engine inspects each rule's signature and threads the latent block and the read-only history only into rules that declare it):
+
+```python
+def rule(observation, latent, history, updates, params):
+    # observation: the current observation (a State holding the
+    #          observable features ONLY - hidden quantities appear
+    #          under no name; infer them into `latent`)
+    # latent:  Dict[str, Any], mutated in place - the hidden dims you
+    #          infer, threaded across steps (see "Recurrent rules" below)
+    # history: List[Tuple[State, Optional[Action]]] of past
+    #          observations, read-only; newest last
+    # updates: Dict[Object, Dict[str, float]] accumulated from prior rules
+    # params:  Dict[str, float], one entry per ParamSpec
+    #
+    # Accumulate, don't replace:
+    #     updates.setdefault(obj, {})[feat] = new_value
+    # Return the same dict.
+    ...
+```
+
+A rule that needs no hidden state can ignore its `latent` and `history` arguments, but keeps the 5-argument shape so the tools and the fitting engine call every rule the same way. See "Recurrent rules (partial observability)" below for `LATENT_INIT` and the two latent-modelling patterns.
+
+### Physics commands (`cmds`): moving rigid bodies through the engine
+
+A rule may declare one extra trailing parameter named `cmds` to gain a second output channel: rigid-body actuation executed by the base sim's physics engine.
+
+```python
+def rule(..., cmds):        # same leading args as above, plus `cmds`
+    cmds.apply_force(obj, (fx, fy, fz))    # world-frame Newtons
+    cmds.apply_torque(obj, (tx, ty, tz))   # world-frame N*m
+    cmds.set_velocity(obj, linear=(vx, vy, vz))   # kinematic override
+    cmds.attach(obj_a, obj_b)   # rigid weld at their CURRENT relative pose
+    return updates
+```
+
+`cmds.attach` is the primitive for two bodies that move as one rigid body from some event on (a cured joint, a latch, a magnetized contact): the engine creates a fixed constraint at the pair's current relative pose and keeps it exactly while the command is re-emitted, so the base sim carries the whole assembly through pick, transport, and contact. Latch the decision in the rule's latent or feature state and re-emit from the latch every step. Do not emulate a weld by writing follower poses from the leader's pose: pose-written followers do not collide, do not support anything, and swing free during a carry, so plans validate in the belief and fail for real.
+
+Commands act during the next env action and then expire, so re-emit them on every step the process is active (a force that acts while a device is on is "emit the force whenever `is_on > 0.5`"). A force or torque is re-applied on every physics substep of that action, like a continuous push. The engine resolves whatever the commanded motion runs into (contact stops, sliding, deflection); do not re-derive collision handling in rule code.
+
+Choosing the channel, in order:
+
+1. The base sim already produces the motion but quantitatively off (bodies move on replay, with drifting angles or timing): the mechanism lives in the engine and the error is a function of its physical parameters. Declare `PHYSICAL_PARAMS` and write no rule for it.
+2. A body moves in the data but is inert in base-sim replay whenever some observable condition holds: the mechanism is missing, an influence the engine knows nothing about. Model it with force or velocity commands gated on the condition. If the missing mechanism is that two bodies move together rigidly after an event, the command is `cmds.attach`, not a pose rule.
+3. The feature is not a rigid-body pose at all (a level, a temperature, a counter): use the feature-update channel.
+
+Never write a rule that overwrites or pushes a body the base sim is already moving: the two fight, and the fit lets the rule absorb physics error. Prefer the simplest force hypothesis: a body that moves at a constant rate while a condition holds and stops when it ends, or when something is in the way, is a constant force plus engine contacts, not a decaying gust, a one-shot kick, or an edge-triggered pulse.
+
+Declaring `cmds` switches fitting and residual scoring to env-in-the-loop rollout matching automatically (`sim.fit` reports it); command effects cannot be scored teacher-forced. `RESIDUAL_FEATURES` still declares the features your dynamics own: list the pose features your commands move (for example `{"ball": ["x", "y"]}`); they are scored against observations but not overwritten at test time, because the engine moves them.
+
+### Multiple objects of the same type
+
+A task may contain several objects of the same type, and the count varies from task to task. Rules run once per step over the entire state, so they act on whatever objects are present, never on a hard-coded slot: `widgets[0]` silently ignores every other instance and breaks the moment a task has a different count than the trajectory you calibrated on.
+
+Gather the relevant objects by type and loop over the bindings the rule acts on, emitting updates keyed by the specific object the effect applies to:
+
+```python
+widgets  = [o for o in state.data if o.type.name == "widget"]
+fixtures = [o for o in state.data if o.type.name == "fixture"]
+for widget in widgets:
+    for fixture in fixtures:           # all pairs, or pair each widget
+        if at_fixture(state, widget, fixture, params):   # to its nearest
+            wv = state.get(widget, "progress")
+            updates.setdefault(widget, {})["progress"] = wv + params["rate"]
+```
+
+The same `params` apply to every object of a type: you are learning the shared physics of "a widget", not per-instance constants. If a rule genuinely needs exactly one object (a single global clock, say), assert that rather than silently indexing `[0]`.
+
+The type, feature, latent, and parameter names in every example here (`widget`, `fixture`, `progress`, `level`, ...) are illustrative; use the names your prompt digests and the trajectory data report.
+
+### Timing
+
+Each rule fires once per step:
+
+```
+state[t] --base sim--> draft state[t+1] --your rules--> final state[t+1]
+                                          (only RESIDUAL_FEATURES are overwritten)
+```
+
+Rules see `state[t]`. They cannot see actions, the base sim's draft, or `state[t+2]`. If a feature changes one step after its gating event (an action toggles a flag at `t`, and the feature it drives starts changing at `t+1`), that is an inherent one-step lag in the data: accept the single boundary residual or model the delay with a parameter, rather than chasing it with ever-stricter conditions.
+
+### Geometric gates
+
+When a rule's firing condition depends on the relative position of two bodies, do not gate on the raw distance between their recorded poses. `obj.x, obj.y` is the recorded pose origin, usually a body's base or frame center, while the point that drives the physics (a contact surface, an outlet on the body's side, an end-effector tip, a container opening, a handle) is typically offset from it. That offset lives in the body's local frame, so it rotates with the body's `rot` feature; gating on raw origin distance bakes in one task's orientation and breaks on any task where the fixture is rotated differently.
+
+Default to a learned, rotation-aware anchor offset: express every two-body geometric gate as a distance to an anchored point, the fixture origin plus a local-frame offset rotated into the world frame by the fixture's `rot`, with the offset declared as learnable parameters:
+
+```python
+PARAM_SPECS = [
+    # Functional point offset, in the fixture's LOCAL frame:
+    ParamSpec("fixture_local_dx",       0.0,  lo=-0.3, hi=0.3),
+    ParamSpec("fixture_local_dy",       0.0,  lo=-0.3, hi=0.3),
+    ParamSpec("widget_at_fixture_dist", 0.10, lo=0.0,  hi=0.4),
+]
+
+# `fixture`, `widget`: the relevant object pair (bind as your rule needs).
+def residual_rule(observation, latent, history, updates, params):
+    rot = state.get(fixture, "rot")
+    cos_r, sin_r = np.cos(rot), np.sin(rot)
+    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
+    local_offset = np.array([params["fixture_local_dx"],
+                             params["fixture_local_dy"]])
+    origin = np.array([state.get(fixture, "x"), state.get(fixture, "y")])
+    anchor = origin + rot_mat @ local_offset  # world-frame point
+    widget_xy = np.array([state.get(widget, "x"), state.get(widget, "y")])
+    if np.linalg.norm(widget_xy - anchor) < params["widget_at_fixture_dist"]:
+        ...  # fire
+```
+
+If the functional point coincides with the recorded origin, the fit drives the offsets to zero at no cost. Use a threshold-only gate only after positively confirming that the recorded origin is the functional point. Share the offset and distance parameters with the gating predicate so the rule and the predicate anchor to the same point.
+
+Threshold-fitting protocol, for every predicate or rule condition that compares a recorded feature against a learned cutoff:
+
+1. Bucket trajectory steps by whether the downstream effect actually occurred (the rule-relevant feature advanced, the goal-relevant quantity changed). Compute the candidate quantity at each step.
+2. Inspect the two buckets' value ranges. They must separate by a clear margin. If they overlap, or the gap is narrower than about 5% of the value range, stop: a knife-edge separator is a symptom, not a fit, and a threshold flush against the data boundary is rejected. The candidate quantity is measured from the wrong reference point; do not widen the threshold to absorb the gap.
+3. Find the anchor offset visually: stage and render the scene. The gap between the recorded origin and the effect-firing cluster is the offset.
+4. Re-derive the candidate quantity from the anchored reference and refit. Commit only once the buckets separate by a comfortable margin.
+
+Render the scene, rather than trusting coordinates, whenever a new predicate is proposed (one state where it should hold and one where it should not), whenever a classifier looks right numerically but the downstream signal (refinement success, residual reduction, plan completion) does not follow, and whenever you choose between candidate reference points. Staging and rendering are free: use them before, not after, committing a numeric fit.
+
+### ParamSpec
+
+```python
+ParamSpec(name: str, init_value: float,
+          lo: Optional[float] = None, hi: Optional[float] = None)
+```
+
+Bounds shape both the fit's prior and the warm-start clamp. Set `lo=0.0` for non-negative rates and similar constraints.
+
+### Pre-injected when `simulator.py` is executed
+
+`numpy as np` and `ParamSpec`. Import anything else at the top of the file. The data classes (`State`, `Object`, `Action`, ...) come from `predicators.structs`; the source is in the reference file linked in the first message.
+
+## Tools
+
+`Write` and `Edit` on `simulator.py` are your coding loop. Every successful write is snapshotted to `simulator_versions/cycle_XXX_vers_YYY_simulator.py` (deduplicated by content; `XXX` is the current cycle and `YYY` resets per cycle). `sim.fit`, `sim.residuals`, and the probe's candidate-model refit load the file fresh on every call and prefix their reports with `[cycle_XXX_vers_YYY]`, so iterations can be compared.
+
+`run_python(code)` is both data exploration and validation. `trajectories`, `train_tasks`, `is_goal_state`, `describe_trajectory(traj_idx)` (a per-timestep digest), `np`, and `ParamSpec` are in scope, plus `evaluate_trajectory(states, actions=None, task_idx=0)` when the learn message states a task objective (it scores a state sequence with the env's ground-truth evaluator; on your own simulator's rollouts the verdict is only as good as the simulator). The `sim` probe over your candidate simulator lives in the same namespace:
+
+- `sim.fit()`: parameter fitting plus report; the cheap inner-loop signal.
+- `sim.residuals()`: per-feature breakdown (mismatch counts, mean and max absolute error, improvement over the base sim where a negative value means the rules add error, worst-N example transitions); the diagnostic for which rule to fix.
+- `sim.refine(plan)`: backtracking parameter search on a plan sketch.
+- `sim.run(plan)`: forward rollout with subgoal checking.
+- `sim.reset(task_idx=..., mods={...})` and `sim.render(label, annotations=[...])`: stage a state and render it with overlays, without physics.
+
+The probe forward-rolls the candidate simulator at the parameters of your last `sim.fit()`; it never fits on its own, so after a structural edit its results are marked UNFITTED until you run `sim.fit()` on the current file. Its rollouts are candidate predictions; do not confuse them with the recorded `trajectories`.
+
+### Refinement vs. forward validation
+
+`sim.fit` and refine-then-run test complementary things: pointwise accuracy versus goal reachability. A rule can have a tiny fitting error and still place a saturation threshold or an alignment cap just wrong enough that refinement cannot satisfy a subgoal. Use `sim.fit` and `sim.residuals` as the fast inner loop and refine-then-run as the slow, goal-relevant gate before declaring done.
+
+The two validation passes run under the same option model. `sim.refine` samples continuous parameters, up to 50 attempts per parametric step, and snapshots the state at each backtrack, so failures are isolated per step. The forward pass, one continuous `sim.run` of the refined plan with the state carried across all options and each subgoal annotation checked, matches how test time executes it. A divergence between the two means the learned model is more permissive than the environment's effective behavior: refinement's looser gates accept a step that the continuous rollout does not achieve.
+
+When `sim.refine` passes but `sim.run` reports a subgoal not reached (or the goal check fails), the cause is almost always one of these:
+
+1. A learned gate threshold is wider than the environment's effective threshold. Refinement accepts a placement inside the learned gate that lies outside the environment's; the environment's process never starts, and the `Wait` runs to its cap. Fix: tighten the gate to the empirical boundary; do not widen it for slack.
+2. A wait-termination cutoff fires before the environment-side feature catches up. Refinement's subgoal passes on the learned simulator's readout, but the final-state goal check on env state fails. Fix: align the predicate's cutoff with the environment's effective cutoff, then confirm by re-running refinement.
+
+Rule of thumb: when in doubt, tighten learned thresholds toward the empirical boundary, never loosen them. Widening hides discrepancies during refinement and reveals them at test time as failed solves.
+
+## Predicate Invention (required for plan subgoals)
+
+You also invent the symbolic predicates the planner uses as subgoal atoms in plan sketches. Only `Holding` is provided as a primitive; placement, device-state, and process-completion predicates do not exist until you invent them.
+
+Goals are presented in natural language (see the first message) and goal achievement is checked externally by the environment through `is_goal_state(state, task_idx)` / `train_tasks[task_idx].goal_holds(state)`. You need not invent goal-named predicates or match environment predicate names: invented predicates exist for plan-sketch subgoals (gating `Wait`, `Place`, and similar steps) and can be named freely.
+
+Define them in `predicates.py` (path given in the first message):
+
+```python
+LEARNED_PREDICATES: List[Predicate]
+```
+
+The exec namespace pre-injects `Predicate`, `np`, and a `<typename>_type` binding for each env type (for example `widget_type`, `fixture_type`). The names below are illustrative; use the types, features, and parameter names your digests and the trajectory data report.
+
+```python
+# Placement: object xy within a learned distance of the fixture's
+# functional point, NOT its recorded origin (see "Geometric gates").
+# The local-frame offset is declared as ParamSpecs in simulator.py
+# and shared with the rule that gates the same physics.
+def _widget_at_fixture(s, objs):
+    widget, fixture = objs
+    rot = s.get(fixture, "rot")
+    cos_r, sin_r = np.cos(rot), np.sin(rot)
+    rot_mat = np.array([[cos_r, -sin_r], [sin_r, cos_r]])
+    local_offset = np.array([params["fixture_local_dx"],
+                             params["fixture_local_dy"]])
+    origin = np.array([s.get(fixture, "x"), s.get(fixture, "y")])
+    anchor = origin + rot_mat @ local_offset  # world-frame point
+    widget_xy = np.array([s.get(widget, "x"), s.get(widget, "y")])
+    dist = np.linalg.norm(widget_xy - anchor)
+    return dist < params["widget_at_fixture_dist"]
+
+LEARNED_PREDICATES = [
+    Predicate("WidgetAtFixture", [widget_type, fixture_type],
+              _widget_at_fixture),
+    # Device state: a feature exceeding a fixed cutoff (no learned param).
+    Predicate("FixtureActive", [fixture_type],
+              lambda s, objs: s.get(objs[0], "is_on") > 0.5),
+    # Process completion: a rule-driven feature reaches a learned threshold.
+    Predicate("WidgetReady", [widget_type],
+              lambda s, objs: s.get(objs[0], "progress") >= params["ready_threshold"]),
+]
+```
+
+A pre-injected `params` view is in scope and always reads the current fitted values of every `ParamSpec` declared in `simulator.py`; after each refit, predicates reading `params["name"]` see the new values. Whenever one physical gate drives both a rule's firing condition and a predicate's "subgoal reached" check, declare its parameters (the distance threshold and the local-frame anchor offset it is measured from) once in `PARAM_SPECS` and reference `params["name"]` from both. That keeps the two anchored to the same point and gives the offset a fitting signal from the rule's step data. A parameter used only by predicates has no fitting signal and stays at its `init_value`, so choose those initial values carefully.
+
+What you typically need:
+
+- Placement predicates (object at a target location) for every open-ended option such as `Place`; without them refinement picks an arbitrary location.
+- Device-state predicates (on/off) for every toggle option.
+- Process-completion predicates over the features your rules drive, so `Wait` steps know when to terminate. Keep classifier thresholds consistent with the rules' saturation values; an inconsistency makes `sim.fit` look fine while `sim.refine` gets stuck on the `Wait` subgoal.
+- Coverage: every option you expect in a sketch should have predicates that express its post-condition, so every sketch step can carry a subgoal annotation. Annotations are checked against the real state during execution to detect and replan diverged steps; a step with no annotatable effect is unmonitored. While drafting sketches, a step you cannot annotate with any invented predicate is a missing predicate.
+
+Verify every classifier against the scene and the data. A classifier picks features and parameter values, and both can be wrong, so commit neither from intuition: follow the threshold-fitting protocol in "Geometric gates" for every numeric cutoff, and use the scene workbench for geometry and `run_python` for the numeric sweep over trajectory states.
+
+`sim.predicates()` validates cheaply (first-flip step, monotonicity, coverage across all trajectories) and is also the loader: it updates the predicate set `sim.refine` uses, so call it after every edit to `predicates.py` and before re-running refinement. On goal-reaching trajectories (`reached_goal=True` in `describe_trajectory`) a milestone predicate should flip from false to true exactly once and stay true. On failed interaction trajectories (`reached_goal=False`) the same predicate may fire while the rest of the trajectory shows no goal completion; that is the signature of an over-loose threshold (the predicate fires, the downstream physics does not follow), so tighten it or share the gating parameter with the rule so they are fitted jointly.
+
+Predicates persist across online cycles: the file is preserved between synthesis sessions, and every successful `Write`/`Edit` (plus a final post-session check) is snapshotted to `predicates_versions/cycle_XXX_vers_YYY_predicates.py`. Each cycle re-runs synthesis with the full trajectory history, so failed past attempts remain visible.
+
+## Recurrent rules (partial observability)
+
+The observation may omit causally important quantities: several, one, or none. Anything omitted is absent from the state entirely (under no name, not even as a placeholder), so you cannot read it and must infer its existence and dynamics from how the observable features evolve. Inspect the trajectories first to judge how many latents you need: a feature that drifts or ramps with no visible observed driver is likely downstream of an accumulating latent; if every observable is explained by other observed quantities, you need no latent at all, so keep the 5-argument signature and leave `latent` untouched. A common case is a hidden continuous quantity surfaced only through a derived observable that ramps once the latent crosses a threshold.
+
+Model the hidden state explicitly: each state you predict is one sample of an augmented state, the observable features plus the latent dimensions you infer (a free-form dict such as `{"level": 0.73}` or `{"count": 22}`). Rules read and advance that latent through the `latent` argument of the 5-argument signature. Declare the initial latent block:
+
+```python
+LATENT_INIT = {"level": 0.0, "count": 0}
+# OR a zero-arg callable returning such a dict.
+# Use ParamSpec("name", ...) values to make an init value learnable.
+```
+
+### Structure the latent like the state (per object)
+
+A hidden quantity almost always belongs to an individual object: a vessel's hidden `heat` is another feature of that vessel that happens to be unobserved. Shape the latent like `data`, object first and then feature, so that `latent[jug.name]["heat"]` reads in parallel with `observation.get(jug, "water_volume")`. With several same-type objects a flat `{"heat": 0.0}` collapses them into one shared accumulator, which is wrong, exactly as rules must loop over every object rather than indexing `[0]`.
+
+```python
+LATENT_INIT = {}          # {jug_name: {"heat": value}}, filled lazily
+
+def heat_rule(observation, latent, history, updates, params):
+    jugs = [o for o in observation.data if o.type.name == "jug"]
+    for jug in jugs:
+        jl = latent.setdefault(jug.name, {})    # this jug's hidden dims
+        h = jl.get("heat", 0.0)
+        if on_active_burner(observation, jug, params):
+            h += 1.0
+        jl["heat"] = h
+        updates.setdefault(jug, {})["bubbling_level"] = readout(h, params)
+    return updates
+```
+
+Two deliberate differences from `data`: (1) key by the stable string `obj.name`, not the live `Object` (the latent is deep-copied and reconstructed at every search node, so a live key risks identity mismatch); (2) keep it a free-form JSON-like nest of dicts and numbers with no registered schema. A genuinely global hidden quantity (a world clock, an ambient temperature) stays a top-level scalar. Top-level scalar entries may be `ParamSpec`s to make their initial value learnable; seed each per-object slot lazily from such a shared init.
+
+### Two synthesis patterns (pick per latent)
+
+Pattern A, counter plus threshold: carry a step counter and flip the observable when it crosses a learnable threshold. Same statistical shape as a delayed discrete event.
+
+```python
+PARAM_SPECS = [ParamSpec("delay", init_value=33, lo=1, hi=200)]
+LATENT_INIT = {"count": 0}
+
+def count_rule(observation, latent, history, updates, params):
+    active = is_widget_at_fixture(observation)  # observable check
+    fixture_on = observation.get(fixture, "is_on") > 0.5
+    if active and fixture_on:
+        latent["count"] += 1
+    else:
+        latent["count"] = 0
+    fired = latent["count"] >= params["delay"]
+    updates[widget]["progress"] = 1.0 if fired else 0.0
+    return updates
+```
+
+Pattern B, physical latent plus readout: carry an estimate of the unobserved quantity and map it through a (typically monotone) function to predict the observable. Higher resolution: the observable co-varies smoothly with the latent before the symbolic "done" point.
+
+```python
+PARAM_SPECS = [ParamSpec("rate", init_value=0.03, lo=0.0, hi=0.1)]
+LATENT_INIT = {"level": 0.0}
+
+def level_rule(observation, latent, history, updates, params):
+    active = is_widget_at_fixture(observation)
+    fixture_on = observation.get(fixture, "is_on") > 0.5
+    if active and fixture_on:
+        latent["level"] += params["rate"]
+    lvl = latent["level"]
+    # monotone readout: ramps from 0 once `lvl` passes an onset (~0.85)
+    updates[widget]["progress"] = max(0.0, min(1.0, (lvl - 0.85) / 0.15))
+    return updates
+```
+
+How to choose: a smooth ramp across many steps in the derived observable calls for Pattern B (a partial-progress signal whose rate is identifiable from a single trajectory by slope fit); a clean discrete flip at a variable tick may only need Pattern A (one learnable threshold calibrated from the flip-time distribution across trajectories). Different latents may use different patterns within one simulator.
+
+### Keep carried state in `latent`, not in emitted observables
+
+Anything a rule must remember across steps (a counter, an accumulated level, an irreversible "done" flag) belongs in `latent`. The observables you write to `updates` are outputs only: recompute them from `latent` and base-owned inputs each step, and never read one of your own emitted features back in as state. The planner resets and replays states during refinement, and only `latent` is guaranteed to be threaded across those jumps, so a rule that latches on its own output can pass a step-by-step rollout and break at refinement time. Reading features the base sim owns (positions, `is_on`, `is_held`) is fine; those are restored faithfully.
+
+### Predicate signature
+
+Classifiers may stay observation-only or take an optional `latent` kwarg. The latent block is available at refinement time too: the planner threads it through `state.latent` across search nodes, and `Predicate.holds` routes it into classifiers that opted in. Be defensive: at the very first step `state.latent` may still be `{}` if `LATENT_INIT` is empty, and during predicate-quality scoring on raw env trajectories `latent` is the block materialized by your rules (so meaningful, but only as accurate as the rules).
+
+```python
+# Observation-only (robust to bad rule chains; preferred when the
+# observable carries enough signal):
+Predicate("ProcessDone", [widget_type],
+          lambda s, objs, latent=None:
+              s.get(objs[0], "progress") > 0.5)
+
+# Latent-aware (inherits simulator correctness; defend against
+# missing keys at step 0):
+Predicate("ProcessDone", [widget_type],
+          lambda s, objs, latent=None:
+              (latent or {}).get("level", 0.0) >= params["done_thresh"])
+```
+
+The kwarg must be named exactly `latent` for the routing to apply. Latent-aware predicates inherit the simulator's correctness; observation-only predicates are robust to bad rules but only work when the observable carries enough signal.
+
+`sim.predicates()` rolls each trajectory through your simulator to materialize the latent before scoring classifiers, so latent-aware predicates get a real block there. Use its report to localize failures (bad rule chain versus bad threshold).
+
+## Plan format for `sim.refine` / `sim.run`
+
+One option call per line, with every option argument supplied as a typed object reference (`obj:type`), matching the options digest in your prompt exactly. The parser is strict: an omitted argument is not auto-filled. Example:
+
+```
+PickWidget(robot:robot, widget0:widget)
+Place(robot:robot) -> {WidgetAtFixture(widget0:widget, fixture0:fixture)}
+ActivateFixture(robot:robot, fixture0:fixture)
+Wait(robot:robot) -> {WidgetReady(widget0:widget)}
+```
+
+The names are illustrative; use the options, types, and predicates your prompt digests list. Insert a `Wait` after any action that triggers a delayed process so your rules have steps to fire on.
+
+Subgoal annotations (`-> {Atom(obj:type, ...)}` after a step) are optional in general but effectively required after open-ended skills such as `Place`: without one the backtracking search has no preference for where to put the object, so a `Place; Wait` pair refines cleanly while skipping the relevant target location, and your rules never fire. That looks like a rule bug but is a missing subgoal. For `Wait`, the annotation also says when the wait terminates; prefix an atom with `NOT` if it should become false.
+
+## Deliverables of a learning session
+
+- Decision record. Begin `simulator.py` with a short comment stating your key modeling choices and the evidence behind them: which dynamics the base sim carries and which the rules model, which features the rules own, any latent structure, and any other structural commitment (for example whether base-sim parameters are declared for identification). Later cycles read this record before deciding what to keep.
+- Evidence discipline for rules that write physical state (poses, velocities). Ground them in recorded transitions the base sim mispredicts. A mechanism you suspect but have never observed end-to-end in the data is a hypothesis, and what to do with it depends on whether the goal needs it. When the goal is reachable without it, record the hypothesis in the decision record with the experiment that would confirm it and ship no rule: a speculative pose-writer fabricates states the environment never produces, and plans validated against it fail in reality. When the goal requires it (without the mechanism the goal is unreachable in your model), omitting it is not the cautious choice: it turns "unknown" into "impossible" for every consumer of the model, so exploration can no longer certify a goal attempt and the test session proves the goal unreachable. Ship a goal-required mechanism as a labelled hypothesis: a rule whose trigger geometry and timing are declared `ParamSpec`s at your best physical estimate with honest ranges, a HYPOTHESIS marker on it in the decision record, and its confirming experiment as the first entry of `./open_questions.md`, written so that the next exploration's goal attempt exercises it. The converse error is as costly: do not delete a rule whose mechanism the data confirms because one fit metric is noisy. Decide from the recorded evidence either way.
+- Declared uncertainty. A learned constant whose supporting data leaves real doubt (a one-sided bracket, a knife-edge margin, a handful of samples) is a declared `ParamSpec` spanning that honest range, never a literal in rule code. Declared parameters get fitted posteriors, the exploration ensemble spreads over them, and the capture gate re-validates every submitted plan under those posterior members, so an operating point that only works at your point estimate is caught in simulation instead of failing a real episode. A literal is earned only once the data brackets the constant from both sides with margin to spare.
+- Completeness. Work through every divergence the new trajectories reveal in this one session: enumerate each mechanism the episodes exercised, reconcile it against the model, and fix every confirmed error now, not only the one that blocked the last test. Each error deferred to the next cycle costs a full explore-learn-test round trip.
+- Final fit and GO/NO-GO. Before ending, run `sim.fit()` on the final file: that fit is the model deployed for this cycle (end without one and the harness fits on its own and logs the deviation; a verdict on UNFITTED values is worthless). Then refine a full solve of the train task in your candidate simulator and validate it with several trials (`sim.refine`, then `sim.run(plan, trials=5)`). Record the verdict in the decision record with the plan's weakest margin, the smallest distance from any step's operating point to a learned threshold, compared against the measured execution scatter. NO-GO, or a margin thinner than the scatter, means the next test episode will likely fail: put exactly what is missing at the top of `./open_questions.md`. A GO that rests on a hypothesized mechanism says so; it is still a GO, because the plan it certifies is the experiment that confirms or refutes the hypothesis.
+- `./open_questions.md`: a short ranked ledger of the model's remaining uncertainties (mechanisms never observed, thresholds whose data is one-sided or knife-edge, hypotheses awaiting confirmation), each entry naming the cheapest real-environment experiment that would settle it as a concrete option sequence or parameter ladder, plus what to measure. The next exploration phase receives this file verbatim and designs its episodes from it, so write entries as runnable experiment specifications, and delete entries this cycle's data settles. An empty ledger declares the model believed complete everywhere.
+- `./strategy.md`: a natural-language domain strategy for solving tasks in this environment: the recommended approach and step ordering, the mechanisms that matter and how to trigger them, parameter formulas expressed relative to the scene (never hard-coded to one task's coordinates), and known pitfalls. Solve sessions read it as advisory reference, so state uncertainty honestly. It is a living document: rewrite it wherever new evidence corrects earlier advice rather than appending contradictions. (`./journal.md` is the run's append-only log of facts and measurements; you may add to it.)
+
+## Workflow
+
+1. Explore the data with `run_python`: which features change per step, and which the base sim does not explain.
+2. `Write` `simulator.py`; `Edit` to iterate.
+3. Score with `sim.fit()`, then `sim.residuals()` to find diverging features. A negative improvement over the base sim means a rule is actively hurting, usually a wrong gate or sign.
+4. When the fit is plausible, propose an option-skeleton plan and validate it: `sim.reset(task_idx=i)`, `sim.refine(plan, require_goal=True)`, then a continuous `sim.run` of the refined plan from a fresh `sim.reset(task_idx=i)`. A stuck refine step means the rules gating its subgoal atoms are too tight or too loose; a refine-pass whose `sim.run` diverges means a rule is too permissive. Fix and re-validate; do not declare done until both pass. Step 4's sketches need subgoal predicates that do not exist until you invent them: before validating, write them to `predicates.py` and load them with `sim.predicates()` (see "Predicate Invention").
+5. Finish with the deliverables above: final `sim.fit()`, GO/NO-GO, decision record, `./open_questions.md`, `./strategy.md`.
diff --git a/tests/agent_sdk/prompt_goldens/sandbox_claude_md.md b/tests/agent_sdk/prompt_goldens/sandbox_claude_md.md
new file mode 100644
index 000000000..705c16b73
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/sandbox_claude_md.md
@@ -0,0 +1,37 @@
+# Predicators Agent Sandbox
+
+## Working Directory
+
+Your working directory is the sandbox. All files you create must stay here, and every path you use is relative (for example `./my_script.py`).
+
+## Python
+
+The interpreter is `python3`, and the predicators package is importable:
+
+    python3 -c "from predicators.structs import State, Type; print('OK')"
+
+Write and run scripts in the sandbox:
+
+    python3 my_experiment.py
+
+## Reference Files
+
+Curated source files are in `./reference/`. Read them to learn the APIs before writing code.
+
+## Session Logs
+
+Your earlier queries and tool results are in `./session_logs/`, named `<NNN>_<kind>_<timestamp>.md` where `<NNN>` is a run-wide counter and `<kind>` is the query phase (`learn`, `test`, `explore`). Alphabetical order is chronological order:
+
+    Glob ./session_logs/*.md
+    Read ./session_logs/001_learn_*.md
+
+## Scene Images
+
+`submit_plan` saves a rendering of the scene after every step to `./test_images/`. Read them to inspect the spatial state.
+
+## Rules
+
+- Do not read or browse files outside the sandbox. This is enforced for the file tools, for Bash, and for `run_python`: commands or code with absolute or `../` paths that leave the sandbox, or that introspect source, are blocked.
+- Do not modify files in `./reference/`; they are read-only.
+- Do not inspect the predicators source code (`inspect.getsource`, `inspect.getfile`, reading `.py` files from site-packages, or any other route). Use the tools and the reference files instead.
+- Do not reach into harness internals from executed code. `State.privileged`, the probe's `_ctx`, and env flags or attributes are hidden environment ground truth and are blocked. Learn the world model from observable state features and the documented tool surface only; a conclusion derived from hidden internals is an invalid result.
diff --git a/tests/agent_sdk/prompt_goldens/solve_query.md b/tests/agent_sdk/prompt_goldens/solve_query.md
new file mode 100644
index 000000000..7f4e67d07
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/solve_query.md
@@ -0,0 +1,70 @@
+Solve the task below: produce a plan that reaches its goal.
+
+## Goal Description
+
+Put the thing on the fixture and switch it on.
+
+## Scoring (env ground-truth reward)
+
+reward = (1.0 if success else 0.0) - 0.1 x moves used
+
+Decode every reward you observe with this rule before hypothesizing any other mechanism; there are no hidden reward terms.
+
+## Goal Atoms
+
+Active(fixture0:fixture)
+At(thing0:thing, fixture0:fixture)
+
+## Initial State Atoms
+
+(none: no atom of the available predicates holds initially)
+
+## Initial State Features
+
+  {'fixture0:fixture': {'x': 1.0000, 'y': 0.0000, 'is_on': 0.0000},
+   'thing0:thing': {'x': 0.0000, 'y': 0.0000}}
+
+## Initial State Image
+
+A rendering of the initial scene is at `./test_images/task000_initial_state.png`. Read it first.
+
+## Objects
+
+  fixture0: fixture
+  thing0: thing
+
+## Available Options
+
+  MoveTo(thing, fixture)  [params: dx, dy, range [-0.5, -0.5] to [0.5, 0.5]]
+  Wait()
+
+## Available Predicates (for subgoal annotations)
+
+  Active(fixture)
+  At(thing, fixture): thing rests on fixture
+
+## Available Tools
+
+  - submit_plan
+  - run_python
+  - Read
+  - Write
+
+## Domain Strategy (advisory, written during learning)
+
+## Approach
+- move, then activate
+
+## Attempt Log (recorded by the harness)
+
+### task 0 attempt 1/3
+- outcome: no capture
+
+## Solve Journal (./journal.md)
+
+### task 0 attempt 1
+- MoveTo dx=0.2 reached At
+
+## Instructions
+
+Inspect the environment with your tools, then produce the plan and deliver it through the capture gate as the system prompt's Deliverable section specifies. When a step does not reach its subgoal, tune that step's parameters from the rendered image and the object poses (working principles 4 and 5), then re-test it.
diff --git a/tests/agent_sdk/prompt_goldens/solve_system_explore.md b/tests/agent_sdk/prompt_goldens/solve_system_explore.md
new file mode 100644
index 000000000..06f1f2a32
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/solve_system_explore.md
@@ -0,0 +1,59 @@
+You are an exploration agent in an online learning loop. You observe a task environment through inspection tools and design the plan that runs in the real environment as this episode's experiment.
+
+## Deliverable
+
+Your final plan text: the experiment that runs in the real environment. Output only the plan lines at the end, after any analysis. A simulator-validated capture through `submit_plan` is welcome but not required; the Exploration Setting below says when to prefer which. A plan that passes the `submit_plan` capture gate (goal reached in every fresh belief rollout) is executed verbatim as this episode's solve attempt; only an unvalidated plan is treated as an experiment.
+
+## Plan grammar
+
+One option per line:
+
+```
+OptionName(obj1:type1, obj2:type2)[p1, p2] -> {Pred(obj1:type1), NOT Pred2(obj1:type1, obj2:type2)}
+Wait(robot:robot)[] -> {Pred3(obj1:type1)}
+```
+
+- Every object reference is typed (`obj:type`), in arguments and atoms alike. Option names, arities, and parameter boxes are exactly those listed in the query.
+- `[p1, p2, ...]` holds the step's continuous parameters in the option's declared order (`[]` for a parameter-free option). Parameters are executed exactly as written.
+- `-> {atoms}` is the step's subgoal annotation: the atoms that should newly hold, or stop holding (`NOT`), once the step succeeds. Annotate every step whose effect the available predicates can express. Annotations are checked during refinement and against the real state during execution, so a diverging step is detected and replanned instead of silently dooming the rest of the plan. Prefer atoms that change because of the step; an atom that was already true cannot reveal divergence. A step without an annotation is checked only for having executed.
+- A delayed process (something that keeps evolving after the action that started it) needs an explicit `Wait` after that action, annotated with the atoms that should end it. `Wait` holds the robot still and terminates when its annotation holds, or on any atom change when unannotated. Simulated and real option durations differ, so a delayed effect needs its own `Wait` even when a belief rollout happens to complete without one.
+
+## Tools
+
+- `submit_plan(plan_text)` runs the plan on the current task in the belief simulator with your exact parameters, no search. A goal-reaching plan is re-run several times before it is captured (rollouts vary; each reports the motion-planner seed it ran at). A plan reported FLAKY failed one of those rollouts: reproduce that rollout (`rollout_seed=<seed>` to `submit_plan`, or `sim.run(plan_text, seed=...)`), read why, add margin to the fragile step, and resubmit. `validation_rollouts=N` requests a stricter gate up front; `sim.run(plan_text, trials=N)` measures reliability without submitting. Capture also requires the plan to succeed on a grid of perturbations spanning one standard deviation of the identified physical parameters; a plan that fails any grid point is reported PARAM-SENSITIVE. Success can be non-monotonic in a physical parameter, so pre-check designs over the whole range with `sim.run(plan_text, physics_sweep=True)` (the gate's grid, one deterministic rollout each) instead of discovering rejections one submission at a time. Capture additionally re-runs the plan under the posterior members of the learned rule parameters (the fit's uncertainty about the thresholds and offsets it learned); failing under any member is reported PARAM-SENSITIVE. A design that only works at the fitted point estimate of an uncertain constant fails either this gate or the real environment, whose true constant lies somewhere in that posterior.
+- `run_python(code)` exposes the `sim` probe over the belief simulator: `sim.run(plan_text, seed=..., trials=...)` is a forward rollout with subgoal checks; `sim.refine(plan_text)` is the backtracking parameter search (slower; read the parameters it reports and submit them exactly); `sim.reset(mods={...})` followed by `sim.render(...)` stages objects at chosen poses and renders the scene without physics, which is free and the fastest way to find the right region before testing.
+- Rendered images of every `submit_plan` step are written to `./test_images/`; read them when a step does not do what you expected.
+
+## Working principles
+
+1. Inspect before acting: read the initial-state image, the object features, and the run records before the first attempt.
+2. Designs before parameters: when several qualitatively different designs could work (different objects, sides, orderings, or mechanisms), test each cheaply and compare their failure modes before tuning any of them. Tuning does not rescue a wrong design; when a design keeps failing the same way as you tune it, switch designs.
+3. Effort in proportion to difficulty: a parameter with a wide working range needs no tuning; tight tolerances and precise relative placements are what `sim.refine` is for.
+4. Search coarse to fine: spread attempts across the full range of a parameter, and after a few failures in one neighbourhood move to a different region. Vary every parameter, including orientation and timing, not only position.
+5. Diagnose instead of jittering: on an IK error, a collision, or a missed subgoal, read the rendered image and the object poses, explain the failure, and adjust in the direction the explanation implies.
+6. Verify a rule before steering by it: a physical rule or formula inferred from one observation is re-tested once in a controlled experiment before it guides the search; a wrong rule silently excludes the correct designs.
+7. Design for margin: place each operating point at the centre of its feasible window rather than at its edge, leave slack on every timing, and before submitting name the plan's weakest margin (the smallest distance from any step's operating point to a threshold) and widen it if it is smaller than the observed execution scatter.
+8. Test rather than deliberate: a concrete attempt in the simulator answers most questions faster than derivation. Keep reasoning concise.
+
+## Run records
+
+These files in your working directory persist across sessions of this run:
+
+- `./journal.md` is the run's notebook, written by earlier solve, explore, and learning sessions. Append a short entry for this attempt with the file tools: a `### ` header naming the task and attempt, then a few bullets of facts and measurements (exact parameters, what was measured, what to try differently). No verdicts such as "impossible".
+- `./attempts.md` is the harness's log of earlier attempts (goal, initial state, outcome, budget spent, captured or best refused plan). Facts, not advice; do not edit it.
+- `./strategy.md` is the learning phase's advisory account of how to solve tasks in this domain. Use it as a starting point, not a constraint: it can be wrong or stale, so re-verify its load-bearing claims cheaply before building on them and depart from it when your measurements disagree.
+- `./open_questions.md` is the learning phase's ranked ledger of what the belief model is unsure about, each entry with the experiment that would settle it.
+- `./session_logs/` holds earlier queries and tool results.
+
+Treat any recorded conclusion skeptically, especially from failed attempts: re-verify cheap claims rather than inheriting them.
+
+## Exploration setting
+
+- The loop. Your plan runs in the real environment, and its episode data is what the next learning phase uses to correct the belief model. The loop concludes early once the exploration plans solve training: every episode of a cycle must reach the goal for real, and the plan must have validated in the belief model; a lucky real success from a plan the model could not certify does not count. Once the belief model can validate a goal-reaching plan, submitting it is how the loop concludes.
+- The belief model. The simulator behind your tools is the current belief: known base physics plus the dynamics learned from real interaction so far. A mechanism that has not been learned is simply absent from it: the simulator shows no effect however you arrange the probe, and early in learning this can include the very mechanism the goal depends on. Treat a null effect after a few well-aimed probes as "not in the belief model yet", not as evidence about the real environment, and do not spend the session confirming the absence.
+- Choosing the experiment. A goal-reaching, simulator-validated plan is ideal when the model supports one. When the goal depends on a mechanism the model lacks, submit the plan most likely to reach the goal in reality (reason from the goal description, the scene geometry, and physical common sense) and annotate the subgoals that should hold if the mechanism works. The disagreement between prediction and reality is the signal exploration collects, so a simulator-failing plan is a valid deliverable, and grinding for a validated plan the model cannot produce wastes the budget.
+- Verbatim execution. Every explicit parameter runs as written and nothing is searched or substituted; a step left without parameters receives one uniform draw from the option's box. Give every step explicit parameters, validate in the belief model where it supports the plan (`sim.run`, `sim.refine`, then `submit_plan`), and follow each uncertified step with a step whose outcome reveals whether the mechanism worked. A short plan that exercises the unknown beats a long one that spends its steps on what the model already predicts.
+- What a cycle's data must contain. Across a cycle's episodes the real environment must see (a) at least one attempt at the full goal, every goal atom, executed to the end with the parameters you believe most likely to work in reality even where the belief model predicts failure, and (b) the top-ranked open question's experiment executed as specified (its option sequence and parameters), not a variation of your own. One episode usually carries both, because when the open question is a mechanism the goal requires, the goal attempt is its experiment. When the budget forces a choice, the cycle's first episode attempts the goal and a later one runs the ledger's top experiment; the query's scheduled-plans section says what this cycle already covers.
+- One episode, many measurements. Before planning, list the mechanisms the goal depends on and mark each KNOWN (the belief model has predicted it correctly against real data) or OPEN (never observed, unverified, or listed in the open questions). Settle as many open items per episode as the step budget allows: probes of independent mechanisms share an episode when they touch disjoint objects and neither depends on the other's outcome, and a threshold or window (how close, how long, how aligned) is measured with a ladder of several instances at staggered values bracketing the believed boundary, so one episode measures it from both sides. Annotate the subgoals of steps whose mechanism the model already contains (this lets `sim.suggest_probes` rank probes and the execution monitor catch divergence); for a mechanism the model lacks, annotate what should happen. Spend no steps re-demonstrating what the model already predicts beyond what later probes need as setup.
+- The first cycle. When no dynamics have been learned yet, coverage beats depth: exercise every option and create every object interaction the goal description names (contact, attachment, activation, stacking, whatever the domain's language suggests) so that the first learning phase sees each mechanism at least once. Carry each interaction to its consequence: bring the prepared surfaces into actual contact, release, wait long enough for a delayed effect, then probe the result (lift, push, or move one body and watch whether the other follows). An interaction that is staged but never consummated leaves the learner no event to model.
+- Records. Append measurements to `./journal.md` as you go (a short entry per experiment, numbers first). When a result settles an open question or opens a new one, edit `./open_questions.md` directly; the next learning phase designs its work from that file. Do not edit `./strategy.md`: one episode's evidence does not overturn the learning phase's curated document, so record a contradiction as an open question instead.
diff --git a/tests/agent_sdk/prompt_goldens/solve_system_plan.md b/tests/agent_sdk/prompt_goldens/solve_system_plan.md
new file mode 100644
index 000000000..e4f411406
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/solve_system_plan.md
@@ -0,0 +1,57 @@
+You are a planning agent. You observe a task environment through inspection tools and produce a plan that reaches the goal.
+
+## Deliverable
+
+A plan captured by `submit_plan`. Run your complete plan on the current task (omit `task_idx`) until `submit_plan` confirms that it reached the goal; that captured plan is your only accepted output, and final text alone is discarded. After the capture, repeat the plan lines as your final text. Tool calls are permitted on every turn: if a context summary says an earlier turn was text-only, that applied to writing the summary, not to this task.
+
+## Plan grammar
+
+One option per line:
+
+```
+OptionName(obj1:type1, obj2:type2)[p1, p2] -> {Pred(obj1:type1), NOT Pred2(obj1:type1, obj2:type2)}
+Wait(robot:robot)[] -> {Pred3(obj1:type1)}
+```
+
+- Every object reference is typed (`obj:type`), in arguments and atoms alike. Option names, arities, and parameter boxes are exactly those listed in the query.
+- `[p1, p2, ...]` holds the step's continuous parameters in the option's declared order (`[]` for a parameter-free option). Parameters are executed exactly as written.
+- `-> {atoms}` is the step's subgoal annotation: the atoms that should newly hold, or stop holding (`NOT`), once the step succeeds. Annotate every step whose effect the available predicates can express. Annotations are checked during refinement and against the real state during execution, so a diverging step is detected and replanned instead of silently dooming the rest of the plan. Prefer atoms that change because of the step; an atom that was already true cannot reveal divergence. A step without an annotation is checked only for having executed.
+- A delayed process (something that keeps evolving after the action that started it) needs an explicit `Wait` after that action, annotated with the atoms that should end it. `Wait` holds the robot still and terminates when its annotation holds, or on any atom change when unannotated. Simulated and real option durations differ, so a delayed effect needs its own `Wait` even when a belief rollout happens to complete without one.
+- For `sim.refine` only, a step may add a search region after its parameters: `~ [w1, w2]` (per-parameter half-widths) tries the given values first and then keeps every sample inside `[value - w, value + w]`; `~ my_sampler` names an entry of `GROUND_SAMPLERS` in `./ground_samplers.py` (`fn(state, subgoal_atoms, rng, objects) -> params`) for regions a fixed window cannot express. The file is reloaded on every `sim.refine` call.
+
+## Tools
+
+- `submit_plan(plan_text)` runs the plan on the current task in the belief simulator with your exact parameters, no search. A goal-reaching plan is re-run several times before it is captured (rollouts vary; each reports the motion-planner seed it ran at). A plan reported FLAKY failed one of those rollouts: reproduce that rollout (`rollout_seed=<seed>` to `submit_plan`, or `sim.run(plan_text, seed=...)`), read why, add margin to the fragile step, and resubmit. `validation_rollouts=N` requests a stricter gate up front; `sim.run(plan_text, trials=N)` measures reliability without submitting. Capture also requires the plan to succeed on a grid of perturbations spanning one standard deviation of the identified physical parameters; a plan that fails any grid point is reported PARAM-SENSITIVE. Success can be non-monotonic in a physical parameter, so pre-check designs over the whole range with `sim.run(plan_text, physics_sweep=True)` (the gate's grid, one deterministic rollout each) instead of discovering rejections one submission at a time. Capture additionally re-runs the plan under the posterior members of the learned rule parameters (the fit's uncertainty about the thresholds and offsets it learned); failing under any member is reported PARAM-SENSITIVE. A design that only works at the fitted point estimate of an uncertain constant fails either this gate or the real environment, whose true constant lies somewhere in that posterior.
+- `run_python(code)` exposes the `sim` probe over the belief simulator: `sim.run(plan_text, seed=..., trials=...)` is a forward rollout with subgoal checks; `sim.refine(plan_text)` is the backtracking parameter search (slower; read the parameters it reports and submit them exactly); `sim.reset(mods={...})` followed by `sim.render(...)` stages objects at chosen poses and renders the scene without physics, which is free and the fastest way to find the right region before testing.
+- Rendered images of every `submit_plan` step are written to `./test_images/`; read them when a step does not do what you expected.
+
+## Working principles
+
+1. Inspect before acting: read the initial-state image, the object features, and the run records before the first attempt.
+2. Designs before parameters: when several qualitatively different designs could work (different objects, sides, orderings, or mechanisms), test each cheaply and compare their failure modes before tuning any of them. Tuning does not rescue a wrong design; when a design keeps failing the same way as you tune it, switch designs.
+3. Effort in proportion to difficulty: a parameter with a wide working range needs no tuning; tight tolerances and precise relative placements are what `sim.refine` is for.
+4. Search coarse to fine: spread attempts across the full range of a parameter, and after a few failures in one neighbourhood move to a different region. Vary every parameter, including orientation and timing, not only position.
+5. Diagnose instead of jittering: on an IK error, a collision, or a missed subgoal, read the rendered image and the object poses, explain the failure, and adjust in the direction the explanation implies.
+6. Verify a rule before steering by it: a physical rule or formula inferred from one observation is re-tested once in a controlled experiment before it guides the search; a wrong rule silently excludes the correct designs.
+7. Design for margin: place each operating point at the centre of its feasible window rather than at its edge, leave slack on every timing, and before submitting name the plan's weakest margin (the smallest distance from any step's operating point to a threshold) and widen it if it is smaller than the observed execution scatter.
+8. Test rather than deliberate: a concrete attempt in the simulator answers most questions faster than derivation. Keep reasoning concise.
+9. Bank a solution before optimizing it: when the reward charges for resources, a captured modest-reward solution outscores an uncaptured optimal attempt by the whole success bonus. Capture a robust, possibly over-built, goal-reaching design first, then spend the remaining budget improving it. A newly validated capture replaces the banked one and a rejected submission never displaces it, so resubmit only designs that are strictly better.
+
+## Run records
+
+These files in your working directory persist across sessions of this run:
+
+- `./journal.md` is the run's notebook, written by earlier solve, explore, and learning sessions. Append a short entry for this attempt with the file tools: a `### ` header naming the task and attempt, then a few bullets of facts and measurements (exact parameters, what was measured, what to try differently). No verdicts such as "impossible".
+- `./attempts.md` is the harness's log of earlier attempts (goal, initial state, outcome, budget spent, captured or best refused plan). Facts, not advice; do not edit it.
+- `./strategy.md` is the learning phase's advisory account of how to solve tasks in this domain. Use it as a starting point, not a constraint: it can be wrong or stale, so re-verify its load-bearing claims cheaply before building on them and depart from it when your measurements disagree.
+- `./open_questions.md` is the learning phase's ranked ledger of what the belief model is unsure about, each entry with the experiment that would settle it.
+- `./session_logs/` holds earlier queries and tool results.
+
+Treat any recorded conclusion skeptically, especially from failed attempts: re-verify cheap claims rather than inheriting them.
+
+Journal protocol for a solve attempt:
+
+- A design the attempt log records as having reached the goal in the real environment is the incumbent: reproduce it unless the record also shows it failing since, or a model update invalidates one of its steps. Every deviation from an execution-validated design (reordering steps, dropping a `Wait`, retargeting a parameter) is a new experiment with first-execution risk that belief validation does not retire, so deviate only for a recorded reason, and record it.
+- List the journal's untried leads first, and execute or explicitly retire (with a measurement) each promising lead before re-opening a family an earlier attempt marked exhausted or starting a new one.
+- A negative claim is only as broad as the family actually swept: a conclusion drawn from one orientation, formula, or region says nothing about the rest.
+- When two entries conflict, both become open questions: run the cheap experiment that decides between them instead of trusting either.
diff --git a/tests/agent_sdk/prompt_goldens/solve_system_policy.md b/tests/agent_sdk/prompt_goldens/solve_system_policy.md
new file mode 100644
index 000000000..36868ff22
--- /dev/null
+++ b/tests/agent_sdk/prompt_goldens/solve_system_policy.md
@@ -0,0 +1,70 @@
+You are a planning agent. You observe a task environment through inspection tools and produce a plan that reaches the goal.
+
+## Deliverable
+
+A closed-loop policy in `./policy.py`, validated by `submit_policy`. Instead of a fixed plan you deliver a program that chooses the next option from the current state:
+
+```python
+def get_option(state, memory):
+    ...
+```
+
+- `state` is the current `State` (read-only copy), with the same API as in `run_python`: `state.get(obj, "feature")`, `for obj in state`, `obj.name`, `obj.type`.
+- `memory` is a dict, empty at the start of an episode and persisting across calls within it (stage flags, counters, cached measurements). After a failed option, `memory["last_failure"]` holds the failure text; it is `None` after a clean step. Branch on it to recover.
+- Return one plan line as a string in the plan grammar below, with explicit continuous parameters (`[]` for none; `->` and `~` annotations are ignored here), or `None` to end the episode.
+- `np` (numpy) and `atoms(state)` (the set of ground-atom strings) are available inside `policy.py`.
+- Execution semantics are identical in the belief simulator and the real environment: `get_option` is called at every option boundary with the actual current state; an option failure does not end the episode (it is reported through `memory["last_failure"]` and you are asked again); an exception, an unparsable line, or an ungroundable line ends it; at most 40 options run per episode.
+- After a failure, change something (parameters, target, or action). Re-issuing the identical failing line 3 times in a row ends the episode as a policy bug, and so does re-issuing one identical line that keeps completing with no observable state change 5 times in a row.
+
+Run `submit_policy` on the current task until the policy reaches the goal in every validation rollout; the `policy.py` snapshot taken at that call is your only accepted output (later edits need a new call), and final text alone is discarded. Test recovery first: `sim.run_policy()` in `run_python` runs `./policy.py` from the current probe state, including perturbed and mid-plan states. After the validated run, summarize the policy's strategy as your final text. Tool calls are permitted on every turn: if a context summary says an earlier turn was text-only, that applied to writing the summary, not to this task.
+
+## Plan grammar
+
+One option per line:
+
+```
+OptionName(obj1:type1, obj2:type2)[p1, p2] -> {Pred(obj1:type1), NOT Pred2(obj1:type1, obj2:type2)}
+Wait(robot:robot)[] -> {Pred3(obj1:type1)}
+```
+
+- Every object reference is typed (`obj:type`), in arguments and atoms alike. Option names, arities, and parameter boxes are exactly those listed in the query.
+- `[p1, p2, ...]` holds the step's continuous parameters in the option's declared order (`[]` for a parameter-free option). Parameters are executed exactly as written.
+- `-> {atoms}` is the step's subgoal annotation: the atoms that should newly hold, or stop holding (`NOT`), once the step succeeds. Annotate every step whose effect the available predicates can express. Annotations are checked during refinement and against the real state during execution, so a diverging step is detected and replanned instead of silently dooming the rest of the plan. Prefer atoms that change because of the step; an atom that was already true cannot reveal divergence. A step without an annotation is checked only for having executed.
+- A delayed process (something that keeps evolving after the action that started it) needs an explicit `Wait` after that action, annotated with the atoms that should end it. `Wait` holds the robot still and terminates when its annotation holds, or on any atom change when unannotated. Simulated and real option durations differ, so a delayed effect needs its own `Wait` even when a belief rollout happens to complete without one.
+
+## Tools
+
+- `submit_plan(plan_text)` runs the plan on the current task in the belief simulator with your exact parameters, no search. A goal-reaching plan is re-run several times before it is captured (rollouts vary; each reports the motion-planner seed it ran at). A plan reported FLAKY failed one of those rollouts: reproduce that rollout (`rollout_seed=<seed>` to `submit_plan`, or `sim.run(plan_text, seed=...)`), read why, add margin to the fragile step, and resubmit. `validation_rollouts=N` requests a stricter gate up front; `sim.run(plan_text, trials=N)` measures reliability without submitting. Capture additionally re-runs the plan under the posterior members of the learned rule parameters (the fit's uncertainty about the thresholds and offsets it learned); failing under any member is reported PARAM-SENSITIVE. A design that only works at the fitted point estimate of an uncertain constant fails either this gate or the real environment, whose true constant lies somewhere in that posterior.
+- `run_python(code)` exposes the `sim` probe over the belief simulator: `sim.run(plan_text, seed=..., trials=...)` is a forward rollout with subgoal checks; `sim.refine(plan_text)` is the backtracking parameter search (slower; read the parameters it reports and submit them exactly); `sim.reset(mods={...})` followed by `sim.render(...)` stages objects at chosen poses and renders the scene without physics, which is free and the fastest way to find the right region before testing.
+- Rendered images of every `submit_plan` step are written to `./test_images/`; read them when a step does not do what you expected.
+
+## Working principles
+
+1. Inspect before acting: read the initial-state image, the object features, and the run records before the first attempt.
+2. Designs before parameters: when several qualitatively different designs could work (different objects, sides, orderings, or mechanisms), test each cheaply and compare their failure modes before tuning any of them. Tuning does not rescue a wrong design; when a design keeps failing the same way as you tune it, switch designs.
+3. Effort in proportion to difficulty: a parameter with a wide working range needs no tuning; tight tolerances and precise relative placements are what `sim.refine` is for.
+4. Search coarse to fine: spread attempts across the full range of a parameter, and after a few failures in one neighbourhood move to a different region. Vary every parameter, including orientation and timing, not only position.
+5. Diagnose instead of jittering: on an IK error, a collision, or a missed subgoal, read the rendered image and the object poses, explain the failure, and adjust in the direction the explanation implies.
+6. Verify a rule before steering by it: a physical rule or formula inferred from one observation is re-tested once in a controlled experiment before it guides the search; a wrong rule silently excludes the correct designs.
+7. Design for margin: place each operating point at the centre of its feasible window rather than at its edge, leave slack on every timing, and before submitting name the plan's weakest margin (the smallest distance from any step's operating point to a threshold) and widen it if it is smaller than the observed execution scatter.
+8. Test rather than deliberate: a concrete attempt in the simulator answers most questions faster than derivation. Keep reasoning concise.
+9. Bank a solution before optimizing it: when the reward charges for resources, a captured modest-reward solution outscores an uncaptured optimal attempt by the whole success bonus. Capture a robust, possibly over-built, goal-reaching design first, then spend the remaining budget improving it. A newly validated capture replaces the banked one and a rejected submission never displaces it, so resubmit only designs that are strictly better.
+
+## Run records
+
+These files in your working directory persist across sessions of this run:
+
+- `./journal.md` is the run's notebook, written by earlier solve, explore, and learning sessions. Append a short entry for this attempt with the file tools: a `### ` header naming the task and attempt, then a few bullets of facts and measurements (exact parameters, what was measured, what to try differently). No verdicts such as "impossible".
+- `./attempts.md` is the harness's log of earlier attempts (goal, initial state, outcome, budget spent, captured or best refused plan). Facts, not advice; do not edit it.
+- `./strategy.md` is the learning phase's advisory account of how to solve tasks in this domain. Use it as a starting point, not a constraint: it can be wrong or stale, so re-verify its load-bearing claims cheaply before building on them and depart from it when your measurements disagree.
+- `./open_questions.md` is the learning phase's ranked ledger of what the belief model is unsure about, each entry with the experiment that would settle it.
+- `./session_logs/` holds earlier queries and tool results.
+
+Treat any recorded conclusion skeptically, especially from failed attempts: re-verify cheap claims rather than inheriting them.
+
+Journal protocol for a solve attempt:
+
+- A design the attempt log records as having reached the goal in the real environment is the incumbent: reproduce it unless the record also shows it failing since, or a model update invalidates one of its steps. Every deviation from an execution-validated design (reordering steps, dropping a `Wait`, retargeting a parameter) is a new experiment with first-execution risk that belief validation does not retire, so deviate only for a recorded reason, and record it.
+- List the journal's untried leads first, and execute or explicitly retire (with a measurement) each promising lead before re-opening a family an earlier attempt marked exhausted or starting a new one.
+- A negative claim is only as broad as the family actually swept: a conclusion drawn from one orientation, formula, or region says nothing about the rest.
+- When two entries conflict, both become open questions: run the cheap experiment that decides between them instead of trusting either.
diff --git a/tests/agent_sdk/test_bilevel_sketch_regions.py b/tests/agent_sdk/test_bilevel_sketch_regions.py
index 8322ef920..6fce702f5 100644
--- a/tests/agent_sdk/test_bilevel_sketch_regions.py
+++ b/tests/agent_sdk/test_bilevel_sketch_regions.py
@@ -583,3 +583,45 @@ def test_probe_refine_broken_ground_samplers_file(tmp_path):
     with pytest.raises(ValueError, match="Error loading") as excinfo:
         _probe_refine("Move(block0:block)[0.95]", sandbox_dir=str(tmp_path))
     assert "bad" in str(excinfo.value)
+
+
+# --------------------------------------------------------------------------- #
+# Subgoal-annotation validation and step formatting (2026-08-31 fixes).
+# --------------------------------------------------------------------------- #
+
+
+def test_parse_strict_unknown_subgoal_predicate_errors():
+    """Strict mode rejects an annotation naming a predicate that does not
+    exist, instead of silently monitoring a different sketch."""
+    with pytest.raises(ValueError, match="Unknown predicate 'NotAReal'"):
+        _parse("Move(block0:block)[0.7] -> {NotAReal(block0:block)}")
+
+
+def test_parse_strict_unknown_subgoal_object_errors():
+    """Strict mode rejects an annotation naming an unknown object."""
+    with pytest.raises(ValueError, match="Unknown object"):
+        _parse("Move(block0:block)[0.7] -> {ReachedHi(ghost:block)}")
+
+
+def test_parse_nonstrict_unknown_subgoal_predicate_drops_atom():
+    """Tolerant mode (re-parsing logged plans) still skips the bad atom."""
+    sketch = _parse("Move(block0:block)[0.7] -> {NotAReal(block0:block)}",
+                    strict=False)
+    assert len(sketch) == 1
+    assert sketch[0].subgoal_atoms is None
+
+
+def test_parse_zero_param_option_without_brackets():
+    """A zero-parameter option may omit its `[]`, matching how the harness's
+    own logs render such steps."""
+    sketch = _parse("Wait0(block0:block)")
+    assert len(sketch) == 1
+    assert sketch[0].option.name == "Wait0"
+
+
+def test_format_step_line_renders_negative_subgoals():
+    """NOT atoms render inside the same braces so logged plans match the sketch
+    monitoring actually used."""
+    atom = GroundAtom(_ReachedHi, [_block])
+    line = format_step_line(0, "Wait0", [_block], subgoal_neg_atoms={atom})
+    assert "-> {NOT ReachedHi(block0:block)}" in line
diff --git a/tests/agent_sdk/test_prompt_goldens.py b/tests/agent_sdk/test_prompt_goldens.py
new file mode 100644
index 000000000..7c2be861c
--- /dev/null
+++ b/tests/agent_sdk/test_prompt_goldens.py
@@ -0,0 +1,323 @@
+"""Golden renders of every agent prompt.
+
+Each phase's system prompt and query is rendered for a fixed
+configuration and compared byte-for-byte against
+``tests/agent_sdk/prompt_goldens/<name>.md``. The goldens are the
+reviewable form of the prompts: a change to a template or a builder
+shows up as a diff of the text the agent actually receives.
+
+To accept a deliberate change, regenerate the goldens and review the
+diff::
+
+    UPDATE_PROMPT_GOLDENS=1 pytest tests/agent_sdk/test_prompt_goldens.py
+"""
+import difflib
+import glob
+import os
+import re
+
+import numpy as np
+import pytest
+from gym.spaces import Box
+
+from predicators import utils
+from predicators.agent_sdk import learn_prompts
+from predicators.agent_sdk.prompt_templates import _PROMPTS_DIR, \
+    load_sections, placeholders, render
+from predicators.agent_sdk.sandbox_prompts import build_claude_md
+from predicators.agent_sdk.sketch_prompts import build_early_stop_note, \
+    build_solve_prompt, build_solve_system_prompt
+from predicators.structs import Action, GroundAtom, Object, \
+    ParameterizedOption, Predicate, State, Task, TaskEvaluator, Type
+
+_GOLDEN_DIR = os.path.join(os.path.dirname(__file__), "prompt_goldens")
+
+# -- fixtures ----------------------------------------------------------------
+
+_THING = Type("thing", ["x", "y"])
+_FIXTURE = Type("fixture", ["x", "y", "is_on"])
+
+
+def _noop_policy(_s, _m, _o, _p):
+    return Action(np.zeros(1, dtype=np.float32))
+
+
+_MOVE = ParameterizedOption(
+    "MoveTo",
+    types=[_THING, _FIXTURE],
+    params_space=Box(low=np.array([-0.5, -0.5], dtype=np.float32),
+                     high=np.array([0.5, 0.5], dtype=np.float32)),
+    policy=_noop_policy,
+    initiable=lambda _s, _m, _o, _p: True,
+    terminal=lambda _s, _m, _o, _p: True,
+    params_description=("dx", "dy"),
+)
+_WAIT = ParameterizedOption(
+    "Wait",
+    types=[],
+    params_space=Box(low=np.zeros(0, dtype=np.float32),
+                     high=np.zeros(0, dtype=np.float32)),
+    policy=_noop_policy,
+    initiable=lambda _s, _m, _o, _p: True,
+    terminal=lambda _s, _m, _o, _p: True,
+)
+_AT = Predicate(
+    "At", [_THING, _FIXTURE],
+    lambda s, o: abs(s.get(o[0], "x") - s.get(o[1], "x")) < 0.1,
+    natural_language_assertion=lambda names: f"{names[0]} rests on {names[1]}")
+_ON = Predicate("Active", [_FIXTURE], lambda s, o: s.get(o[0], "is_on") > 0.5)
+
+
+class _Evaluator(TaskEvaluator):
+    """Evaluator whose objective statement reaches the prompt."""
+
+    def objective_description(self) -> str:
+        return "reward = (1.0 if success else 0.0) - 0.1 x moves used"
+
+
+def _make_task(with_evaluator: bool) -> Task:
+    thing = Object("thing0", _THING)
+    fixture = Object("fixture0", _FIXTURE)
+    state = State({
+        thing: np.array([0.0, 0.0]),
+        fixture: np.array([1.0, 0.0, 0.0])
+    })
+    goal = {GroundAtom(_AT, [thing, fixture]), GroundAtom(_ON, [fixture])}
+    return Task(state,
+                goal,
+                goal_nl="Put the thing on the fixture and switch it on.",
+                evaluator=_Evaluator(goal) if with_evaluator else None)
+
+
+# -- golden comparison -------------------------------------------------------
+
+
+def _check_golden(name: str, text: str) -> None:
+    path = os.path.join(_GOLDEN_DIR, f"{name}.md")
+    if os.environ.get("UPDATE_PROMPT_GOLDENS"):
+        os.makedirs(_GOLDEN_DIR, exist_ok=True)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(text)
+        return
+    assert os.path.isfile(path), (
+        f"missing golden {path}; run with UPDATE_PROMPT_GOLDENS=1")
+    with open(path, "r", encoding="utf-8") as f:
+        expected = f.read()
+    if text != expected:
+        diff = "\n".join(
+            difflib.unified_diff(expected.splitlines(),
+                                 text.splitlines(),
+                                 fromfile=f"{name}.md (golden)",
+                                 tofile=f"{name} (rendered)",
+                                 lineterm=""))
+        pytest.fail(f"prompt {name} drifted from its golden; review the diff "
+                    f"and rerun with UPDATE_PROMPT_GOLDENS=1 to accept:\n"
+                    f"{diff}")
+
+
+# -- template hygiene --------------------------------------------------------
+
+
+def test_templates_use_plain_dashes_and_declared_sections() -> None:
+    """Templates contain no em dashes, and every section is named once."""
+    paths = sorted(glob.glob(os.path.join(_PROMPTS_DIR, "*.md")))
+    assert paths
+    for path in paths:
+        with open(path, "r", encoding="utf-8") as f:
+            text = f.read()
+        assert "—" not in text, path
+        name = os.path.splitext(os.path.basename(path))[0]
+        assert load_sections(name)
+
+
+def test_render_rejects_missing_and_unused_placeholders() -> None:
+    """A template placeholder without a value, or a value without a
+    placeholder, fails loudly instead of shipping literal text."""
+    with pytest.raises(AssertionError):
+        render("solve_query", "goal_nl")
+    with pytest.raises(AssertionError):
+        render("solve_query", "goal_nl", goal_nl="g", extra="x")
+    assert placeholders("a __B__ c __B__ __D__") == ["B", "D"]
+
+
+def test_rendered_prompts_have_no_leftover_placeholders() -> None:
+    """No rendered prompt carries an unsubstituted ``__NAME__``."""
+    marker = re.compile(r"__[A-Z][A-Z0-9_]*__")
+    for text in (build_solve_system_prompt(explore=False),
+                 build_solve_system_prompt(explore=True), build_claude_md()):
+        assert not marker.search(text), marker.search(text)
+
+
+# -- solve / explore ---------------------------------------------------------
+
+
+def test_golden_solve_system_plan() -> None:
+    """Solve-phase system prompt, captured-plan deliverable, all gates."""
+    _check_golden(
+        "solve_system_plan",
+        build_solve_system_prompt(explore=False,
+                                  propose_params=True,
+                                  ground_samplers=True,
+                                  physics_margin=True,
+                                  rule_param_margin=True,
+                                  use_journal=True))
+
+
+def test_golden_solve_system_policy() -> None:
+    """Solve-phase system prompt, closed-loop policy deliverable."""
+    _check_golden(
+        "solve_system_policy",
+        build_solve_system_prompt(explore=False,
+                                  policy_mode=True,
+                                  rule_param_margin=True,
+                                  policy_max_options=40,
+                                  policy_max_repeated_failures=3,
+                                  policy_max_repeated_noops=5))
+
+
+def test_golden_solve_system_explore() -> None:
+    """Explore-phase system prompt with the train-driven early-stop note."""
+    utils.reset_config({
+        "seed":
+        0,
+        "online_learning_early_stopping":
+        True,
+        "online_learning_early_stopping_require_all_attempts":
+        True,
+    })
+    _check_golden(
+        "solve_system_explore",
+        build_solve_system_prompt(explore=True,
+                                  physics_margin=True,
+                                  rule_param_margin=True,
+                                  early_stop_note=build_early_stop_note()))
+
+
+def test_golden_solve_query() -> None:
+    """Solve query with scoring, run records, and the capture instructions."""
+    utils.reset_config({"seed": 0})
+    _check_golden(
+        "solve_query",
+        build_solve_prompt(
+            _make_task(with_evaluator=True),
+            all_predicates={_AT, _ON},
+            all_options={_MOVE, _WAIT},
+            tool_names=["submit_plan", "run_python", "Read", "Write"],
+            initial_image_section=(
+                "## Initial State Image\n\nA rendering of the initial "
+                "scene is at `./test_images/task000_initial_state.png`. "
+                "Read it first."),
+            propose_params=True,
+            require_tool_validation=True,
+            journal="### task 0 attempt 1\n- MoveTo dx=0.2 reached At",
+            strategy="## Approach\n- move, then activate",
+            attempts="### task 0 attempt 1/3\n- outcome: no capture",
+        ))
+
+
+def test_golden_explore_query() -> None:
+    """Explore query with open questions and a belief-certified scheduled
+    plan."""
+    utils.reset_config({"seed": 0})
+    _check_golden(
+        "explore_query",
+        build_solve_prompt(
+            _make_task(with_evaluator=False),
+            all_predicates={_AT, _ON},
+            all_options={_MOVE, _WAIT},
+            tool_names=["submit_plan", "run_python"],
+            experiment_guidance=("The learning phase left this ranked "
+                                 "ledger of open questions:\n"
+                                 "1. Does Active require At? Experiment: "
+                                 "MoveTo then Wait."),
+            scheduled_plans=[
+                "  0: MoveTo(thing0, fixture0)[0.2000, 0.0000]\n"
+                "  NOTE: belief-certified; executes verbatim as a solve "
+                "attempt."
+            ],
+            propose_params=True,
+            explore_mode=True,
+        ))
+
+
+def test_golden_sandbox_claude_md() -> None:
+    """The sandbox CLAUDE.md."""
+    _check_golden("sandbox_claude_md", build_claude_md())
+
+
+# -- learn -------------------------------------------------------------------
+
+
+def test_golden_learn_system() -> None:
+    """Fully observable learn system prompt with a physical-parameter menu."""
+    physical = learn_prompts.render_physical_params_section({
+        "lateral_friction": {
+            "default": 0.5,
+            "lo": 0.05,
+            "hi": 2.0,
+            "scale": "log",
+            "description": "sliding friction of every body"
+        }
+    })
+    _check_golden(
+        "learn_system",
+        learn_prompts.build_learn_system_prompt(
+            partially_observable=False,
+            residual_rule_signature="def residual_rule(state, updates, "
+            "params):",
+            scene_viz_hint="stage and render the scene",
+            physical_params_section=physical))
+
+
+def test_golden_learn_system_po_invention() -> None:
+    """Partially observable learn system prompt with predicate invention."""
+    _check_golden(
+        "learn_system_po_invention",
+        learn_prompts.build_learn_system_prompt(
+            partially_observable=True,
+            residual_rule_signature="def residual_rule(observation, latent, "
+            "history, updates, params):",
+            scene_viz_hint="stage and render the scene",
+            extra_sections=[
+                learn_prompts.render_predicate_invention_section(
+                    "the scene workbench"),
+            ],
+            latent_extra_sections=[
+                learn_prompts.render_predicate_latent_section(),
+            ],
+            workflow_extra=learn_prompts.render_predicate_workflow_extra()))
+
+
+def test_golden_learn_message() -> None:
+    """Learn first message with a prior model, an objective, base-sim source,
+    and the predicate-invention and partial-observability additions."""
+    _check_golden(
+        "learn_message",
+        learn_prompts.build_learn_message(
+            n_trajs=3,
+            n_transitions=42,
+            n_demos=1,
+            n_interaction=2,
+            trajectory_listing="[0] demo, task 0\n[1] interaction, task 0",
+            structs_ref="./reference/structs.py",
+            inferred_hint="{'fixture': ['is_on']}",
+            predicate_listing="  Holding(robot, thing)",
+            types_digest="thing: x, y\nfixture: x, y, is_on",
+            options_digest="MoveTo(thing, fixture)[dx, dy]",
+            simulator_file="./simulator.py",
+            objective_block=learn_prompts.render_objective_block(
+                "reward = success - 0.1 x moves used"),
+            prior_state_block=learn_prompts.render_prior_state_block(
+                ["`./simulator.py`", "`./predicates.py`"]),
+            divergence_block=learn_prompts.render_divergence_block(
+                "fixture.is_on: 4 mismatches", has_prior_model=True),
+            base_sim_block=learn_prompts.render_base_sim_block(
+                ["./reference/base_sim/scene.py"]),
+            tools_block=learn_prompts.render_tools_block(
+                ["run_python", "Read", "Write", "Edit"]),
+            extra_messages=[
+                learn_prompts.render_predicate_invention_message(
+                    "./predicates.py",
+                    "Goal (natural language): switch the fixture on."),
+                learn_prompts.render_partial_observability_message(),
+            ]))
diff --git a/tests/agent_sdk/test_solve_prompt_strategy.py b/tests/agent_sdk/test_solve_prompt_strategy.py
index e0522b00e..10353c78d 100644
--- a/tests/agent_sdk/test_solve_prompt_strategy.py
+++ b/tests/agent_sdk/test_solve_prompt_strategy.py
@@ -1,16 +1,16 @@
-"""Solve-prompt strategy blocks from the run_20260729_001752 post-mortem.
-
-That run burned five attempts hunting minimal designs at the designed
-k*-boundary (while its sibling banked an over-built solve), induced
-false reward rules from opaque scores, re-litigated a journal-condemned
-family while a concrete untried lead sat unexecuted, and turned an
-unvalidated fall-direction formula into a false physics law. Each block
-tested here is the corresponding general fix.
+"""Behavioral checks on the solve/explore prompts.
+
+Each test pins one rule the prompts must carry (the goldens in
+``test_prompt_goldens.py`` pin the full text): the reward form reaches
+the solver, solutions are banked before being optimized, the run records
+are used skeptically, and exploration is framed as experiment design
+against a belief model.
 """
 import numpy as np
 
 from predicators import utils
-from predicators.agent_sdk.sketch_prompts import build_solve_prompt
+from predicators.agent_sdk.sketch_prompts import build_early_stop_note, \
+    build_solve_prompt, build_solve_system_prompt
 from predicators.structs import Object, State, Task, TaskEvaluator, Type
 
 _DOM = Type("thing", ["x"])
@@ -38,8 +38,16 @@ def _render(task: Task, journal: str = "", strategy: str = "") -> str:
                               propose_params=True,
                               require_tool_validation=True,
                               journal=journal,
-                              strategy=strategy,
-                              physics_margin=True)
+                              strategy=strategy)
+
+
+def _render_explore(task: Task, propose_params: bool = True) -> str:
+    return build_solve_prompt(task,
+                              all_predicates=set(),
+                              all_options=set(),
+                              propose_params=propose_params,
+                              require_tool_validation=False,
+                              explore_mode=True)
 
 
 def test_scoring_section_from_evaluator() -> None:
@@ -50,95 +58,91 @@ def test_scoring_section_from_evaluator() -> None:
     assert "## Scoring (env ground-truth reward)" in prompt
     assert "0.2 x widgets used" in prompt
     assert "Decode every reward you observe" in prompt
-    bare = _render(_make_task(None))
-    assert "## Scoring" not in bare
-
-
-def test_capture_first_strategy_block() -> None:
-    """CAPTURE FIRST guidance states the verified capture semantics: a
-    validated capture replaces the banked one, rejections never do."""
-    utils.reset_config({"seed": 0})
-    prompt = _render(_make_task(None))
-    assert "CAPTURE FIRST, OPTIMIZE SECOND" in prompt
-    assert "never displaces it" in prompt
-    assert "not strictly better" in prompt
-
-
-def test_journal_protocol_block() -> None:
-    """The journal preamble carries the three epistemic rules; no journal, no
-    protocol block."""
-    utils.reset_config({"seed": 0})
-    prompt = _render(_make_task(None), journal="- notes")
-    assert "FIRST list the journal's untried leads" in prompt
+    assert "## Scoring" not in _render(_make_task(None))
+
+
+def test_solve_system_prompt_banks_before_optimizing() -> None:
+    """The solve system prompt states the banking semantics (a validated
+    capture replaces the banked one, a rejection never does); the explore
+    system prompt, which has no capture deliverable, omits them."""
+    prompt = build_solve_system_prompt(explore=False)
+    assert "Bank a solution before optimizing it" in prompt
+    assert "a rejected submission never displaces it" in prompt
+    assert "strictly better" in prompt
+    assert "Bank a solution" not in build_solve_system_prompt(explore=True)
+
+
+def test_solve_system_prompt_journal_protocol() -> None:
+    """The run-record protocol (incumbent, untried leads, scoped negatives,
+    conflicting entries) lives in the solve system prompt and only there."""
+    prompt = build_solve_system_prompt(explore=False, use_journal=True)
+    assert "is the incumbent" in prompt
+    assert "untried leads first" in prompt
     assert "only as broad as the family actually swept" in prompt
-    assert "BOTH demote to open questions" in prompt
-    assert "Journal protocol" not in _render(_make_task(None))
+    assert "both become open questions" in prompt
+    assert "Journal protocol" not in build_solve_system_prompt(
+        explore=False, use_journal=False)
+    assert "Journal protocol" not in build_solve_system_prompt(explore=True)
 
 
-def test_formula_validation_advice() -> None:
-    """Derived formulas must be validated before steering a search."""
-    utils.reset_config({"seed": 0})
-    prompt = _render(_make_task(None))
-    assert "validate the formula on one clean controlled experiment" in prompt
+def test_solve_system_prompt_verifies_rules_before_steering() -> None:
+    """A rule inferred from one observation is re-tested before it guides the
+    search."""
+    prompt = build_solve_system_prompt(explore=False)
+    assert "Verify a rule before steering by it" in prompt
 
 
-def _render_explore(task: Task, propose_params: bool = True) -> str:
-    return build_solve_prompt(task,
-                              all_predicates=set(),
-                              all_options=set(),
-                              propose_params=propose_params,
-                              require_tool_validation=False,
-                              explore_mode=True)
-
-
-def test_explore_mode_belief_model_disclosure() -> None:
-    """Explore queries disclose that the simulator is a belief model whose
-    unlearned mechanisms are absent, so a null effect is not evidence about
-    reality; solve queries carry no such section."""
+def test_query_carries_run_records_not_their_protocol() -> None:
+    """The query renders the journal and strategy contents under their headers;
+    the rules for using them are not repeated there."""
     utils.reset_config({"seed": 0})
-    prompt = _render_explore(_make_task(None))
-    assert "## Exploration Setting" in prompt
-    assert "not in the belief model yet" in prompt
-    solve_prompt = _render(_make_task(None))
-    assert "## Exploration Setting" not in solve_prompt
+    prompt = _render(_make_task(None),
+                     journal="- notes",
+                     strategy="## Glue first\n- dab twice")
+    assert "## Solve Journal (./journal.md)" in prompt
+    assert "- notes" in prompt
+    assert "## Domain Strategy (advisory, written during learning)" in prompt
+    assert "- dab twice" in prompt
+    assert "incumbent" not in prompt
+    bare = _render(_make_task(None))
+    assert "## Solve Journal" not in bare
+    assert "## Domain Strategy" not in bare
 
 
-def test_explore_mode_experiment_delivery_contract() -> None:
-    """Explore queries accept a simulator-failing sketch as the deliverable and
-    forbid grinding for an impossible capture; the closing block marks final
-    text as the deliverable."""
-    utils.reset_config({"seed": 0})
-    prompt = _render_explore(_make_task(None))
-    assert "simulator-failing sketch is a valid deliverable" in prompt
-    assert ("grinding for a validated plan the model cannot produce "
-            "is wasted budget") in prompt
-    assert "This is an EXPLORE query" in prompt
-    solve_prompt = _render(_make_task(None))
-    assert "This is an EXPLORE query" not in solve_prompt
-    assert "do NOT finish until submit_plan CONFIRMS" in solve_prompt
-    # The contract must survive param-free sketch mode too (the search
-    # finds continuous params, but the delivery semantics are the same).
-    sketch_prompt = _render_explore(_make_task(None), propose_params=False)
-    assert "simulator-failing sketch is a valid deliverable" in sketch_prompt
-    assert "This is an EXPLORE query" in sketch_prompt
-
-
-def test_explore_mode_opening_focuses_on_information_gathering() -> None:
-    """Explore queries open with an exploration framing (solving the task is
-    part of information gathering); solve queries keep the solving opening."""
-    utils.reset_config({"seed": 0})
-    prompt = _render_explore(_make_task(None))
-    assert prompt.startswith("You are exploring a task environment")
-    assert "part of information gathering" in prompt
-    solve_prompt = _render(_make_task(None))
-    assert solve_prompt.startswith("You are solving a task.")
-    assert "part of information gathering" not in solve_prompt
-
-
-def test_explore_mode_early_stop_note_credits_exploration_plans() -> None:
-    """The early-stop note attributes loop conclusion to the exploration plans
-    solving training (goal reached for real AND validated in the belief model),
-    and it states the refine-then-seeded-fallback mechanism."""
+def test_explore_system_prompt_states_the_setting() -> None:
+    """The explore system prompt discloses the belief model, accepts a
+    simulator-failing plan, states the cycle data contract and first-cycle
+    coverage, and executes parameters verbatim; the solve prompt has none."""
+    prompt = build_solve_system_prompt(explore=True)
+    assert "## Exploration setting" in prompt
+    assert "not in the belief model yet" in prompt
+    assert "a simulator-failing plan is a valid deliverable" in prompt
+    assert "at least one attempt at the full goal" in prompt
+    assert ("top-ranked open question's experiment executed as specified"
+            in prompt)
+    assert "Carry each interaction to its consequence" in prompt
+    assert "nothing is searched or substituted" in prompt
+    solve = build_solve_system_prompt(explore=False)
+    assert "## Exploration setting" not in solve
+    assert "belief model yet" not in solve
+
+
+def test_explore_deliverable_and_certified_note() -> None:
+    """The explore deliverable is the final plan text; the certified-plan note
+    follows the execute-certified-plan flag."""
+    with_note = build_solve_system_prompt(explore=True,
+                                          execute_certified_plan=True)
+    assert "Your final plan text: the experiment" in with_note
+    assert "executed verbatim as this episode's solve attempt" in with_note
+    without = build_solve_system_prompt(explore=True,
+                                        execute_certified_plan=False)
+    assert "executed verbatim" not in without
+
+
+def test_early_stop_note_follows_config() -> None:
+    """The early-stop note credits certified exploration plans that solve for
+    real (train-driven) or perfect test phases (test-driven), and is absent
+    when early stopping is off."""
     utils.reset_config({
         "seed":
         0,
@@ -147,36 +151,40 @@ def test_explore_mode_early_stop_note_credits_exploration_plans() -> None:
         "online_learning_early_stopping_require_all_attempts":
         True,
     })
-    prompt = _render_explore(_make_task(None))
-    assert ("The loop concludes early once the exploration plans solve "
-            "training") in prompt
-    assert "learned model solves training" not in prompt
-    assert "runs in the real environment EXACTLY as written" in prompt
-    assert "nothing is searched or substituted" in prompt
-    assert "falls back to the explicit parameters" not in prompt
-    assert "truncated just after that step" not in prompt
-
+    note = build_early_stop_note()
+    assert note.startswith("The loop concludes early once the exploration")
+    assert "every episode of a cycle" in note
+    prompt = build_solve_system_prompt(explore=True, early_stop_note=note)
+    assert "exploration plans solve training" in prompt
+    utils.reset_config({
+        "seed":
+        0,
+        "online_learning_early_stopping":
+        True,
+        "online_learning_early_stopping_by_test_solve_rate":
+        True,
+        "online_learning_early_stopping_consecutive_perfect_tests":
+        2,
+    })
+    assert "2 consecutive test phases" in build_early_stop_note()
+    utils.reset_config({"seed": 0, "online_learning_early_stopping": False})
+    assert build_early_stop_note() == ""
 
-def test_explore_mode_states_the_cycle_data_contract() -> None:
-    """Every cycle must attempt the full goal at least once and run the
-    ledger's top experiment as specified, and first-cycle coverage must carry
-    each interaction to its consequence (run_20260829: four cycle-0 episodes
-    staged glue and neighbours without ever consummating a bond, so no learner
-    had the event to model)."""
-    utils.reset_config({"seed": 0})
-    prompt = _render_explore(_make_task(None))
-    assert "attempt at the FULL goal" in prompt
-    assert "top-ranked open question's experiment executed as it is " \
-        "specified" in prompt
-    assert "Carry each interaction to its CONSEQUENCE" in prompt
 
+def test_query_openings_by_phase() -> None:
+    """Explore queries open with the information-gathering framing; solve
+    queries with the solving framing.
 
-def test_domain_strategy_block_is_advisory() -> None:
-    """strategy.md content renders as an advisory section; absent without."""
+    Both end in the instructions.
+    """
     utils.reset_config({"seed": 0})
-    prompt = _render(_make_task(None), strategy="## Glue first\n- dab twice")
-    assert "## Domain Strategy (advisory, written during learning)" in prompt
-    assert "- dab twice" in prompt
-    assert "can be wrong or stale" in prompt
-    assert "you are NOT limited to it" in prompt
-    assert "## Domain Strategy" not in _render(_make_task(None))
+    explore = _render_explore(_make_task(None))
+    assert explore.startswith("Design this episode's experiment")
+    assert "part of information gathering" in explore
+    assert "output the plan lines as your final text" in explore
+    solve = _render(_make_task(None))
+    assert solve.startswith("Solve the task below")
+    assert "deliver it through the capture gate" in solve
+    # Param-free sketch mode keeps the same delivery semantics.
+    sketch = _render_explore(_make_task(None), propose_params=False)
+    assert "output the plan lines as your final text" in sketch
diff --git a/tests/agent_sdk/test_solve_restart_journal.py b/tests/agent_sdk/test_solve_restart_journal.py
index ba5820d92..ca151bedc 100644
--- a/tests/agent_sdk/test_solve_restart_journal.py
+++ b/tests/agent_sdk/test_solve_restart_journal.py
@@ -385,7 +385,7 @@ def test_run_python_no_footer_outside_attempt(tmp_path):
 
 
 def test_solve_prompt_includes_journal_section():
-    """build_solve_prompt renders the journal with its usage guidance."""
+    """build_solve_prompt renders the journal and attempt log contents."""
     # pylint: disable-next=import-outside-toplevel
     from predicators.agent_sdk.sketch_prompts import build_solve_prompt
     utils.reset_config({})
@@ -402,7 +402,6 @@ def test_solve_prompt_includes_journal_section():
     assert "- outcome: no capture" in prompt
     assert "## Solve Journal" in prompt
     assert "- tried x=0.5" in prompt
-    assert "treat any recorded conclusion skeptically" in prompt
     assert "./journal.md" in prompt
     assert "record_journal" not in prompt
     # Without journal content the section is absent entirely.
diff --git a/tests/agent_sdk/test_submit_plan_capture.py b/tests/agent_sdk/test_submit_plan_capture.py
index 95fb6108a..3bae1e920 100644
--- a/tests/agent_sdk/test_submit_plan_capture.py
+++ b/tests/agent_sdk/test_submit_plan_capture.py
@@ -368,8 +368,9 @@ def test_flaky_escalation_is_per_task():
 
 
 def test_validation_rollouts_enter_fresh_env_scope():
-    """Each validation repeat runs inside ``ctx.validation_env_scope``; the
-    reported first rollout stays on the shared env."""
+    """Every gate rollout - the reported first one included - runs inside
+    ``ctx.validation_env_scope``, so the whole gate shares one substrate
+    (reproducible in-session via ``sim.run(plan, trials=N)``)."""
     utils.reset_config({
         "agent_plan_validation_rollouts": 3,
         "agent_plan_validation_fresh_env": True,
@@ -387,8 +388,8 @@ def _scope():
     text = _call_tool(ctx)
     assert "Captured as the current answer" in text
     assert "freshly constructed simulator" in text
-    # Rollouts 2 and 3 of 3; rollout 1 is the reported one.
-    assert len(entered) == 2
+    # All 3 rollouts, the reported first one included.
+    assert len(entered) == 3
 
 
 def test_fresh_env_scope_disabled_by_config():
@@ -481,9 +482,10 @@ def test_param_sensitive_plan_is_not_captured():
     assert "PARAM-SENSITIVE (plan NOT captured)" in text
     assert "lateral_friction=0.48" in text
     assert ctx.solved_plan is None
-    # 2 execution repeats (no overrides) + 2 physics points.
+    # Main rollout + 2 execution repeats (no overrides) + 2 physics
+    # points.
     assert scope_overrides == [
-        None, None, {
+        None, None, None, {
             "lateral_friction": 0.48
         }, {
             "lateral_friction": 0.59
@@ -523,7 +525,7 @@ def test_physics_margin_disabled_by_config():
     text = _call_tool(ctx)
     assert "Captured as the current answer" in text
     assert "PARAM-SENSITIVE" not in text
-    assert scope_overrides == [None, None]
+    assert scope_overrides == [None, None, None]
 
 
 def test_physics_margin_vacuous_without_points():
@@ -538,7 +540,7 @@ def test_physics_margin_vacuous_without_points():
     text = _call_tool(ctx)
     assert "Captured as the current answer" in text
     assert "Physics-margin check passed" not in text
-    assert scope_overrides == [None, None]
+    assert scope_overrides == [None, None, None]
 
 
 def _rule_param_scope_ctx(model, members):
diff --git a/tests/approaches/test_agent_model_based_approach.py b/tests/approaches/test_agent_model_based_approach.py
index f8bcd360d..a79c812c4 100644
--- a/tests/approaches/test_agent_model_based_approach.py
+++ b/tests/approaches/test_agent_model_based_approach.py
@@ -102,7 +102,7 @@ def _make_approach():
 
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "num_train_tasks": 1,
         "num_test_tasks": 1,
         "option_model_name": "oracle",
@@ -592,7 +592,7 @@ def test_backtracking_across_steps(self):
         approach, mock_om, task = _make_approach()
         utils.reset_config({
             "env": "cover",
-            "approach": "agent_bilevel",
+            "approach": "agent_model_based",
             "num_train_tasks": 1,
             "num_test_tasks": 1,
             "seed": 42,
@@ -634,7 +634,7 @@ def test_not_initiable_triggers_resample(self):
         approach, mock_om, task = _make_approach()
         utils.reset_config({
             "env": "cover",
-            "approach": "agent_bilevel",
+            "approach": "agent_model_based",
             "num_train_tasks": 1,
             "num_test_tasks": 1,
             "seed": 42,
@@ -668,7 +668,7 @@ def test_goal_check_on_final_step(self):
         approach, mock_om, task = _make_approach()
         utils.reset_config({
             "env": "cover",
-            "approach": "agent_bilevel",
+            "approach": "agent_model_based",
             "num_train_tasks": 1,
             "num_test_tasks": 1,
             "seed": 42,
@@ -837,7 +837,7 @@ def test_sketch_from_file(self):
 
         utils.reset_config({
             "env": "cover",
-            "approach": "agent_bilevel",
+            "approach": "agent_model_based",
             "num_train_tasks": 1,
             "num_test_tasks": 1,
             "seed": 42,
@@ -1039,7 +1039,12 @@ def test_params_within_bounds(self):
 
 def test_get_name():
     """Test get name."""
-    assert AgentModelBasedApproach.get_name() == "agent_bilevel"
+    assert AgentModelBasedApproach.get_name() == "agent_model_based"
+    # The pre-rename CLI name still resolves to this approach.
+    # pylint: disable=import-outside-toplevel
+    from predicators.approaches import _get_approach_cls_from_name
+    assert _get_approach_cls_from_name(
+        "agent_bilevel") is AgentModelBasedApproach
 
 
 # ---------------------------------------------------------------------------
@@ -1350,7 +1355,7 @@ def _prompt(scheduled_plans):
         from predicators.agent_sdk import sketch_prompts
         utils.reset_config({
             "env": "cover",
-            "approach": "agent_bilevel",
+            "approach": "agent_model_based",
             "seed": 42,
         })
         state = _make_state()
@@ -1379,7 +1384,7 @@ def test_section_lists_plans_and_asks_for_different_one(self):
         assert "## Plans Already Scheduled This Cycle" in prompt
         assert "Plan 1:\n  0: Pick(block0)[0.5000]" in prompt
         assert "Plan 2:\n  0: Place(block0, block1)[0.1000, 0.2000]" in prompt
-        assert "DATA is complementary rather than redundant" in prompt
+        assert "data is complementary rather than redundant" in prompt
         # The instruction must keep the request goal-directed (this is what
         # preserves the train-solve early-stopping semantics).
         assert "repeat the best plan" in " ".join(prompt.split())
@@ -1574,7 +1579,7 @@ def test_policy_mode_constructor_checks():
                        train_tasks=[task])
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 1,
@@ -1584,7 +1589,7 @@ def test_policy_mode_constructor_checks():
         AgentModelBasedApproach(**base_kwargs)
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1599,7 +1604,7 @@ def test_consume_policy_capture_builds_executor():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1628,7 +1633,7 @@ def test_execution_policy_surfaces_option_failures():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1666,7 +1671,7 @@ def test_execution_policy_budget_is_fatal():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1711,7 +1716,7 @@ def test_execution_policy_stuck_loop_is_fatal():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1740,7 +1745,7 @@ def test_execution_policy_stuck_loop_resets_on_changed_params():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1772,7 +1777,7 @@ def test_execution_policy_stuck_loop_on_mid_execution_raise():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1828,7 +1833,7 @@ def test_execution_policy_noop_livelock_is_fatal():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
@@ -1856,7 +1861,7 @@ def test_execution_policy_noop_livelock_resets_on_changed_params():
     approach, _, _ = _make_approach()
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "seed": 42,
         "agent_solve_policy_mode": True,
         "agent_bilevel_max_execution_replans": 0,
diff --git a/tests/approaches/test_agent_sim_learning_approach.py b/tests/approaches/test_agent_sim_learning_approach.py
index 5f7857043..2d13d4037 100644
--- a/tests/approaches/test_agent_sim_learning_approach.py
+++ b/tests/approaches/test_agent_sim_learning_approach.py
@@ -1019,7 +1019,7 @@ def test_checkpoint_cycle_counter_semantics(tmp_path, monkeypatch):
     from predicators.structs import Dataset
     utils.reset_config({
         "env": "cover",
-        "approach": "agent_planner",
+        "approach": "agent_model_free",
         "seed": 0,
         "approach_dir": str(tmp_path),
     })
diff --git a/tests/approaches/test_agent_sim_prompt_formatting.py b/tests/approaches/test_agent_sim_prompt_formatting.py
index 28f8cba88..93490553e 100644
--- a/tests/approaches/test_agent_sim_prompt_formatting.py
+++ b/tests/approaches/test_agent_sim_prompt_formatting.py
@@ -395,19 +395,14 @@ def test_learn_message_ships_goal_required_mechanisms_as_hypotheses():
     hypothesis with declared ParamSpecs and a first-ranked confirming
     experiment).
 
-    The message is composed from live session state, so the guard reads
-    the template source: in run_20260829 both plan-arm learners followed
-    the older "never ship a never-observed mechanism" rule, the belief
-    then had no bond, and the test session proved the goal unreachable.
+    The rule lives in the learn system prompt's deliverables section.
     """
-    import inspect
-
-    from predicators.approaches.agent_sim_learning_approach import \
-        AgentSimLearningApproach
-    src = inspect.getsource(
-        AgentSimLearningApproach._build_synthesis_learn_message)
-    assert "When the goal REQUIRES it" in src
-    assert "LABELLED HYPOTHESIS" in src
-    assert "FIRST entry of open_questions.md" in src
-    assert "A GO that rests on a" in src
-    assert "instead of shipping a speculative rule" not in src
+    from predicators.agent_sdk import learn_prompts
+    prompt = learn_prompts.build_learn_system_prompt(
+        partially_observable=False,
+        residual_rule_signature="def residual_rule(state, updates, params):",
+        scene_viz_hint="render the scene")
+    assert "When the goal requires it" in prompt
+    assert "labelled hypothesis" in prompt
+    assert "first entry of `./open_questions.md`" in prompt
+    assert "A GO that rests on a hypothesized mechanism" in prompt
diff --git a/tests/approaches/test_agent_solve_restart.py b/tests/approaches/test_agent_solve_restart.py
index 7d98fdd9a..682853c75 100644
--- a/tests/approaches/test_agent_solve_restart.py
+++ b/tests/approaches/test_agent_solve_restart.py
@@ -48,7 +48,7 @@ def _make_approach(overrides=None, sandbox_dir=None):
     task = Task(state, {GroundAtom(_Reached, [_block0])})
     config = {
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "num_train_tasks": 1,
         "num_test_tasks": 1,
         "seed": 42,
@@ -187,9 +187,9 @@ def test_journal_auto_entries_record_each_attempt(tmp_path):
     approach._solve(task, timeout=10)
     content = journal_mod.read_journal(str(tmp_path),
                                        filename=journal_mod.ATTEMPTS_FILENAME)
-    assert "### task 0 attempt 1/2 (auto)" in content
+    assert "### cycle 0 task 0 attempt 1/2 (auto)" in content
     assert "- outcome: no capture" in content
-    assert "### task 0 attempt 2/2 (auto)" in content
+    assert "### cycle 0 task 0 attempt 2/2 (auto)" in content
     assert "best-effort capture (evaluator reward -0.05)" in content
     assert "Move(block0:block)" in content
     # The capture-time validation record travels into the auto entry so a
@@ -198,13 +198,13 @@ def test_journal_auto_entries_record_each_attempt(tmp_path):
     # Task context (goal + init state dict, the prompt's own
     # representation) is a dedicated entry written once, at the TOP of
     # the task's section - before any attempt entry.
-    assert content.count("### task 0 goal + initial state (auto)") == 1
+    assert content.count("### cycle 0 task 0 goal + initial state (auto)") == 1
     assert content.count("- goal: Reached(block0:block)") == 1
     assert content.count("- initial state features:") == 1
     assert "'block0:block'" in content
     assert "'x'" in content
     assert content.index("goal + initial state") < content.index(
-        "### task 0 attempt 1/2")
+        "### cycle 0 task 0 attempt 1/2")
 
 
 def test_attempt_bookkeeping_reset_per_attempt():
@@ -349,7 +349,7 @@ def test_journal_task_context_written_once_even_on_resolve(tmp_path):
     approach._solve(task, timeout=10)
     content = journal_mod.read_journal(str(tmp_path),
                                        filename=journal_mod.ATTEMPTS_FILENAME)
-    assert content.count("### task 0 goal + initial state (auto)") == 1
+    assert content.count("### cycle 0 task 0 goal + initial state (auto)") == 1
     assert content.index("- goal:") < content.index("- outcome:")
 
 
@@ -385,7 +385,7 @@ def test_test_phase_journal_archived_and_rolled_back(tmp_path):
               encoding="utf-8") as f:
         f.write("### task 0 attempt 1\n- eval-time note\n")
     content = journal_mod.read_journal(str(sandbox), filename=attempts)
-    assert "### task 0 goal + initial state (auto)" in content
+    assert "### cycle 0 task 0 goal + initial state (auto)" in content
     assert "- learning fact" in journal_mod.read_journal(str(sandbox))
     approach.end_test_phase()
     # Rolled back: learning content survives, eval additions are gone.
@@ -398,7 +398,7 @@ def test_test_phase_journal_archived_and_rolled_back(tmp_path):
     # evaluation phase. This first evaluation precedes any online
     # learning, so it archives as the initial test.
     archived = (log_dir / "attempts_eval_initial.md").read_text()
-    assert "### task 0 goal + initial state (auto)" in archived
+    assert "### cycle 0 task 0 goal + initial state (auto)" in archived
     archived_notes = (log_dir / "journal_eval_initial.md").read_text()
     assert "- learning fact" in archived_notes
     assert "eval-time note" in archived_notes
@@ -411,7 +411,7 @@ def test_test_phase_journal_archived_and_rolled_back(tmp_path):
     ctx.test_task_idx = 0
     approach._solve(task, timeout=10)
     content = journal_mod.read_journal(str(sandbox), filename=attempts)
-    assert content.count("### task 0 goal + initial state (auto)") == 1
+    assert content.count("### cycle 0 task 0 goal + initial state (auto)") == 1
     approach.end_test_phase()
     # The second evaluation ran after cycle 0's learn advanced the
     # counter to 1, so it archives under the 0-based cycle it evaluates.
diff --git a/tests/explorers/test_agent_bilevel_explorer.py b/tests/explorers/test_agent_model_based_explorer.py
similarity index 92%
rename from tests/explorers/test_agent_bilevel_explorer.py
rename to tests/explorers/test_agent_model_based_explorer.py
index e637d081b..3af97c933 100644
--- a/tests/explorers/test_agent_bilevel_explorer.py
+++ b/tests/explorers/test_agent_model_based_explorer.py
@@ -1,4 +1,4 @@
-"""Tests for AgentBilevelExplorer."""
+"""Tests for AgentModelBasedExplorer."""
 # pylint: disable=protected-access
 
 from unittest.mock import AsyncMock, MagicMock
@@ -11,7 +11,8 @@
 from predicators.agent_sdk.sketch_types import SketchStep
 from predicators.agent_sdk.tools import ToolContext
 from predicators.explorers import create_explorer
-from predicators.explorers.agent_bilevel_explorer import AgentBilevelExplorer
+from predicators.explorers.agent_model_based_explorer import \
+    AgentModelBasedExplorer
 from predicators.explorers.base_explorer import BaseExplorer
 from predicators.structs import Action, GroundAtom, Object, \
     ParameterizedOption, Predicate, State, Task, Type
@@ -111,7 +112,7 @@ def _assistant_response(text: str):
 
 
 def _make_explorer(option_model, query_impl):
-    """Build an AgentBilevelExplorer with stubbed session + tool_context."""
+    """Build an AgentModelBasedExplorer with stubbed session + tool_context."""
     tool_context = ToolContext(
         types=_ALL_TYPES,
         predicates=_ALL_PREDICATES,
@@ -122,7 +123,7 @@ def _make_explorer(option_model, query_impl):
     agent_session = MagicMock()
     agent_session.query = query_impl
     agent_session.tool_names = None
-    explorer = AgentBilevelExplorer(
+    explorer = AgentModelBasedExplorer(
         predicates=_ALL_PREDICATES,
         options=_ALL_OPTIONS,
         types=_ALL_TYPES,
@@ -138,7 +139,7 @@ def _make_explorer(option_model, query_impl):
 def _reset_config(**overrides):
     base = {
         "env": "cover",
-        "approach": "agent_bilevel",
+        "approach": "agent_model_based",
         "num_train_tasks": 1,
         "num_test_tasks": 1,
         "seed": 42,
@@ -158,7 +159,8 @@ def _reset_config(**overrides):
 
 
 def test_factory_registration():
-    """AgentBilevelExplorer is reachable through create_explorer."""
+    """AgentModelBasedExplorer is reachable through create_explorer, under its
+    own name and under the deprecated agent_bilevel alias."""
     _reset_config()
     tool_context = ToolContext(
         types=_ALL_TYPES,
@@ -169,7 +171,7 @@ def test_factory_registration():
     )
     agent_session = MagicMock()
     explorer = create_explorer(
-        "agent_bilevel",
+        "agent_model_based",
         _ALL_PREDICATES,
         _ALL_OPTIONS,
         _ALL_TYPES,
@@ -179,7 +181,18 @@ def test_factory_registration():
         agent_session=agent_session,
     )
     assert isinstance(explorer, BaseExplorer)
-    assert isinstance(explorer, AgentBilevelExplorer)
+    assert isinstance(explorer, AgentModelBasedExplorer)
+    legacy = create_explorer(
+        "agent_bilevel",
+        _ALL_PREDICATES,
+        _ALL_OPTIONS,
+        _ALL_TYPES,
+        Box(low=-1, high=1, shape=(1, )),
+        [_make_task()],
+        tool_context=tool_context,
+        agent_session=agent_session,
+    )
+    assert isinstance(legacy, AgentModelBasedExplorer)
 
 
 def test_happy_path_returns_policy_and_stashes_subgoals():
@@ -405,11 +418,11 @@ def _make_certified_capture(pick_params, place_params):
     return grounded_plan, captured_sketch
 
 
-def test_certified_capture_executes_verbatim_and_is_replayed():
+def test_certified_capture_executes_verbatim_and_next_request_queries():
     """A plan the session validated through the capture gate (reached_goal
     True) is executed verbatim as a solve attempt with a True mental-model
-    verdict; the cycle's next request on the task replays it with no new
-    query."""
+    verdict; the cycle's next request on the task queries the agent again
+    (asking for a different certified plan) rather than replaying it."""
     _reset_config(agent_explorer_info_seeking=True)
     option_model = MagicMock()
     option_model.get_next_state_and_num_actions.return_value = (_make_state(
@@ -436,26 +449,29 @@ async def query_impl(msg, **_kw):
     assert not option_model.get_next_state_and_num_actions.called
     assert tool_context.last_mental_model_solved is True
     assert tool_context.solved_plan is None
-    assert tool_context.cycle_certified_plans[0] is not None
     assert "belief-certified" in tool_context.cycle_scheduled_plans[-1]
+    assert "replayed" not in tool_context.cycle_scheduled_plans[-1]
     assert tool_context.last_sketch_options == [("Pick", ["block0"]),
                                                 ("Place", ["block0",
                                                            "block1"])]
     # The policy runs the captured options with their captured params.
     act = policy(_make_state())
     assert isinstance(act, Action)
-    # Second request of the cycle on the same task: replay, no query.
+    # Second request of the cycle on the same task: a new query that
+    # shows the certified plan as already scheduled.
     tool_context.last_mental_model_solved = None
     policy2, _ = explorer._get_exploration_strategy(0, timeout=5)
     assert callable(policy2)
-    assert len(queries) == 1
+    assert len(queries) == 2
+    assert "belief-certified" in queries[1]
+    assert "STRUCTURALLY different" in queries[1]
     assert tool_context.last_mental_model_solved is True
 
 
 def test_uncertified_capture_executes_its_plan_verbatim():
     """A capture whose gate verdict is not True (best-effort, flaky) is not
     certified: it executes at its captured params as an experiment, with a
-    False mental-model verdict and no replay for the cycle."""
+    False mental-model verdict."""
     _reset_config()
     option_model = MagicMock()
     grounded_plan, captured_sketch = _make_captured([0.42], [0.11, 0.22])
@@ -471,5 +487,5 @@ async def query_impl(_msg, **_kw):
     policy, _ = explorer._get_exploration_strategy(0, timeout=5)
     assert callable(policy)
     assert not option_model.get_next_state_and_num_actions.called
-    assert 0 not in tool_context.cycle_certified_plans
+    assert "belief-certified" not in tool_context.cycle_scheduled_plans[-1]
     assert tool_context.last_mental_model_solved is False
diff --git a/tests/test_agent_sdk_tools.py b/tests/test_agent_sdk_tools.py
index 1112815da..94a57f082 100644
--- a/tests/test_agent_sdk_tools.py
+++ b/tests/test_agent_sdk_tools.py
@@ -27,7 +27,7 @@
 
 _CFG_OVERRIDES = {
     "env": "pybullet_domino",
-    "approach": "agent_planner",
+    "approach": "agent_model_free",
     "seed": 0,
     "use_gui": False,
     "domino_restricted_push": True,
diff --git a/tests/test_docker_option_plan.py b/tests/test_docker_option_plan.py
index 0f1f3d6e4..9b12d164b 100644
--- a/tests/test_docker_option_plan.py
+++ b/tests/test_docker_option_plan.py
@@ -31,7 +31,7 @@
 # Config matching predicatorv3/predicator_v3.yaml (mf_agent approach)
 _CFG_OVERRIDES = {
     "env": "pybullet_domino",
-    "approach": "agent_planner",
+    "approach": "agent_model_free",
     "seed": 0,
     "use_gui": False,
     "domino_restricted_push": True,
diff --git a/tests/test_log_viewer.py b/tests/test_log_viewer.py
index e0cd69244..04edd9248 100644
--- a/tests/test_log_viewer.py
+++ b/tests/test_log_viewer.py
@@ -4,7 +4,8 @@
 from pathlib import Path
 from typing import Any, Dict
 
-from scripts.log_viewer import _parse_info_log, chain_summary, resume_chains
+from scripts.log_viewer import _explore_results, _misc_chip, _parse_info_log, \
+    chain_summary, resume_chains
 
 _SAVE = ("INFO: Saved local sandbox query/response to logs/x/sandbox/"
          "session_logs/{name}.md")
@@ -227,3 +228,57 @@ def test_chain_summary_single_run_keeps_rows() -> None:
     merged = chain_summary([a], summaries)
     assert merged["episodes"][0]["round"] == 4
     assert merged["episodes"][0]["superseded"] is False
+
+
+_CERTIFIED = ("INFO: agent_model_based explorer: the agent's "
+              "tool-validated plan passed the belief's capture gate "
+              "(validation: 8/8 rollouts ok); executing it verbatim as "
+              "this episode's solve attempt (mental model solved the "
+              "goal).")
+_VERDICT = ("INFO: Interaction episode on train task 0: reward={r}, "
+            "terminated={t}, accepted={a}")
+
+
+def test_certified_regex_matches_pre_rename_logs() -> None:
+    """Logs written before the explorer rename still mark the certified
+    chip."""
+    # pylint: disable=import-outside-toplevel
+    from scripts.log_viewer import CERTIFIED_RE
+    assert CERTIFIED_RE.search(
+        "INFO: agent_bilevel explorer: the agent's tool-validated "
+        "plan passed the belief's capture gate")
+
+
+def test_certified_session_is_marked(tmp_path: Path) -> None:
+    """The capture-gate line marks the newest explore session as certified; the
+    cycle's second request is an ordinary session with its own transcript and
+    verdict."""
+    path = _write_log(tmp_path, [
+        "ONLINE LEARNING CYCLE 2",
+        _SAVE.format(name="018_explore_20260830_090000"),
+        _CERTIFIED,
+        _SAVE.format(name="019_explore_20260830_093000"),
+        _VERDICT.format(r="1.00", t="True", a="True"),
+        _VERDICT.format(r="0.00", t="False", a="False"),
+    ])
+    ex = _parse_info_log(path)["explore"]
+    assert ex[18]["certified"] is True and ex[18]["accepted"] is True
+    assert "certified" not in ex[19] and ex[19]["accepted"] is False
+
+
+def test_certified_chip_mark() -> None:
+    """A certified session's chip carries the diamond and its tooltip; the
+    tally is unchanged."""
+    ep = {
+        "num": 18,
+        "kind": "explore",
+        "env_reward": 1.0,
+        "env_terminated": True,
+        "env_accepted": True,
+        "env_msg": "",
+        "certified": True,
+    }
+    html = _misc_chip(ep)
+    assert "018 explore ✓ 1.00 ◆" in html
+    assert "belief-certified" in html
+    assert _explore_results([dict(ep, cycle_tag="cycle2")]) == [(2, 1, 1, 1.0)]