Bound Creative agent parsing and remove faulty respawn mod

minecraft_stack.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-import hashlib
+import hashlib
+import uuid
 import json
 import os
 import re
@@ -289,25 +290,22 @@ class MinecraftStack:
             ("fabric-api-0.58.0+1.19.jar", FABRIC_API_URL, FABRIC_API_SHA256),
             ("completeconfig-2.0.0.jar", COMPLETE_CONFIG_URL, COMPLETE_CONFIG_SHA256),
             ("Multiplayer-Server-Pause-1.19-Fabric-1.1.0.jar", SERVER_PAUSE_URL, SERVER_PAUSE_SHA256),
-            ("better-respawn-fabric-1.19-2.0.0.jar", BETTER_RESPAWN_URL, BETTER_RESPAWN_SHA256),
         )
-        for filename, url, sha256 in mods:
-            _download(url, mods_dir / filename, sha256)
-
-        # Voyager documentation config for Better Respawn. The actual 1.19 mod
-        # uses config/better_respawn/better_respawn.properties.
-        config_dir = JAVA_DIR / "config" / "better_respawn"
-        config_dir.mkdir(parents=True, exist_ok=True)
-        (config_dir / "better_respawn.properties").write_text(
-            "respawn_block_range=32\n"
-            "max_respawn_distance=32\n"
-            "min_respawn_distance=0\n",
-            encoding="utf-8",
-        )
-        _log(
-            "Official Voyager Fabric mods ready: Fabric API 0.58.0+1.19, "
-            "CompleteConfig 2.0.0, Multiplayer Server Pause 1.1.0, "
-            "Better Respawn 1.19-2.0.0. Mod Menu is client-only and is "
+        for filename, url, sha256 in mods:
+            _download(url, mods_dir / filename, sha256)
+
+        # The pinned Better Respawn 1.19 mixin dereferences an uninitialized
+        # respawnDimension while saving a newly connected Creative player.
+        # Remove only this faulty mod from the ephemeral Fabric installation;
+        # never edit the persistent world, playerdata, or Voyager checkpoint.
+        faulty_mod = mods_dir / "better-respawn-fabric-1.19-2.0.0.jar"
+        if faulty_mod.exists():
+            faulty_mod.unlink()
+            _log("Removed faulty Better Respawn 1.19 mod from Fabric mods directory")
+        _log(
+            "Official Voyager Fabric mods ready: Fabric API 0.58.0+1.19, "
+            "CompleteConfig 2.0.0, Multiplayer Server Pause 1.1.0. "
+            "Better Respawn 1.19-2.0.0 is disabled due to its player-save NPE. Mod Menu is client-only and is "
             "intentionally omitted on this headless dedicated server."
         )
 
@@ -571,13 +569,37 @@ class MinecraftStack:
         items = LOG_PATH.read_text(encoding="utf-8", errors="replace").splitlines()
         return "\n".join(items[-max(10, min(lines, 500)):])
 
-    def status(self) -> dict[str, Any]:
-        with self.lock:
+    def status(self) -> dict[str, Any]:
+        with self.lock:
             processes = {
                 name: {"pid": proc.pid, "running": proc.poll() is None, "returncode": proc.poll()}
                 for name, proc in self.processes.items()
             }
-            log = self.tail(120)
+            log = self.tail(120)
+            try:
+                all_lines = LOG_PATH.read_text(encoding="utf-8", errors="replace").splitlines()
+                boot = next((i for i in range(len(all_lines) - 1, -1, -1)
+                             if "=== Minecraft stack bootstrap ===" in all_lines[i]), 0)
+                server_lines = [line for line in all_lines[boot:] if "minecraft>" in line]
+            except OSError:
+                server_lines = []
+            offline_uuid = uuid.UUID(bytes=hashlib.md5(
+                f"OfflinePlayer:{BOT_USERNAME}".encode("utf-8")
+            ).digest(), version=3)
+            player_file = WORLD_DIR / "playerdata" / f"{offline_uuid}.dat"
+            try:
+                player_stat = player_file.stat()
+            except OSError:
+                player_stat = None
+            player_save = {
+                "better_respawn_jar_present": (JAVA_DIR / "mods" / "better-respawn-fabric-1.19-2.0.0.jar").exists(),
+                "failed_saves_since_boot": sum("Failed to save player data" in line for line in server_lines),
+                "respawn_npe_since_boot": sum("respawnDimension" in line and "null" in line
+                                             for line in server_lines),
+                "player_file_exists": player_stat is not None,
+                "player_file_size": player_stat.st_size if player_stat else None,
+                "player_file_mtime": player_stat.st_mtime if player_stat else None,
+            }
             login_url = None
             device_code = None
             url_match = re.findall(r"https://(?:www\.)?microsoft\.com/link", log, flags=re.I)
@@ -602,7 +624,8 @@ class MinecraftStack:
                 "auth_persistence": str(RELAY_DIR / "token.json"),
                 "auth_token_cached": (RELAY_DIR / "token.json").exists(),
                 "persistent_root": str(PERSIST_ROOT),
-                "world_persistence": str(WORLD_DIR),
+                "world_persistence": str(WORLD_DIR),
+                "player_save": player_save,
                 "bot_username": BOT_USERNAME,
                 "bot_display_name": "Naldo Bot",
                 "bedrock_protocol": BEDROCK_PROTOCOL,

tests/test_player_save_diagnostics.py

@@ -2,6 +2,7 @@
 from pathlib import Path
 import subprocess
 import tempfile
+import importlib.util
 
 root = Path(__file__).resolve().parents[1]
 with tempfile.TemporaryDirectory() as directory:
@@ -29,3 +30,23 @@ public class class_29 {
     assert "exception logging hooks=1" in result.stderr
     assert result.stdout == "original catch retained\nnormal return retained\n"
     print("PASS player-save exception visible; original catch and normal return unchanged")
+
+# Isolate the Fabric mod installer: only the known faulty JAR is removed.
+spec = importlib.util.spec_from_file_location("minecraft_stack_test", root / "minecraft_stack.py")
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+with tempfile.TemporaryDirectory() as directory:
+    module.JAVA_DIR = Path(directory)
+    module._download = lambda _url, path, _sha: path.write_bytes(b"unrelated mod")
+    module._log = lambda _message: None
+    mods = module.JAVA_DIR / "mods"
+    mods.mkdir()
+    faulty = mods / "better-respawn-fabric-1.19-2.0.0.jar"
+    faulty.write_bytes(b"the pinned faulty mod")
+    marker = mods / "custom-mod.jar"
+    marker.write_bytes(b"preserve")
+    module.MinecraftStack()._ensure_voyager_mods()
+    assert not faulty.exists()
+    assert marker.read_bytes() == b"preserve"
+    assert len(list(mods.glob("*.jar"))) == 4  # Three required mods plus the marker.
+    print("PASS faulty Better Respawn mixin excluded; other Fabric mods retained")

tests/test_voyager_patch.py

@@ -21,7 +21,11 @@ from unittest.mock import Mock, patch
 
 ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT))
-from voyager_verification import validate_task, verify_task, quarantine_invalid_skills, task_history
+from voyager_verification import (
+    choose_curriculum_task, fallback_curriculum_task, task_spec, validate_task,
+    verify_task, quarantine_invalid_skills, task_history,
+)
+from voyager_action_parse import extract_action_code
 
 
 def functions(filename, names, namespace):
@@ -80,10 +84,16 @@ def test_resume():
             file = ckpt / rel
             file.parent.mkdir(parents=True, exist_ok=True)
             file.write_text("{}")
+        original_completed = ["Mine 1 stone block to upgrade tools", "Mine 1 stone", "Place 4 snow_block"]
+        original_failed = ["Mine 1 stone", "Craft a stone pickaxe", "Craft a stone pickaxe"]
+        (ckpt / "curriculum/completed_tasks.json").write_text(json.dumps(original_completed))
+        (ckpt / "curriculum/failed_tasks.json").write_text(json.dumps(original_failed))
         voyager = Mock()
         voyager.return_value.skill_manager.skills = {}
         voyager.return_value.env.mineflayer.process.poll.return_value = None
-        ns = dict(os=os, json=json, logging=logging, Path=Path, Voyager=voyager, VOYAGER_HOME=Path("upstream"), quarantine_invalid_skills=quarantine_invalid_skills)
+        ns = dict(os=os, json=json, logging=logging, Path=Path, Voyager=voyager,
+                  VOYAGER_HOME=Path("upstream"), quarantine_invalid_skills=quarantine_invalid_skills,
+                  task_spec=task_spec)
         functions("voyager_runner.py", {"env", "main"}, ns)
         with patch.dict(os.environ, {"VOYAGER_CKPT_DIR": folder, "VOYAGER_MODEL": "main",
                                      "VOYAGER_AUX_MODEL": "aux"}):
@@ -98,6 +108,10 @@ def test_resume():
             assert kw[agent + "_temperature"] == 0
         voyager.return_value.learn.assert_called_once_with(reset_env=False)
         voyager.return_value.env.mineflayer.process.terminate.assert_called_once_with()
+        assert json.loads((ckpt / "curriculum/completed_tasks.json").read_text()) == original_completed[::2]
+        assert json.loads((ckpt / "curriculum/failed_tasks.json").read_text()) == ["Craft a stone pickaxe"]
+        archive = json.loads((ckpt / "quarantine/curriculum_history_before_semantic_compaction_v1.json").read_text())
+        assert archive == {"completed": original_completed, "failed": original_failed}
         voyager.return_value.learn.side_effect = RuntimeError("fatal curriculum error")
         with patch.dict(os.environ, {"VOYAGER_CKPT_DIR": folder}):
             try:
@@ -113,7 +127,10 @@ def check_curriculum_behavior(source):
     cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "CurriculumAgent")
     names = {"get_task_context", "propose_next_ai_task", "parse_ai_message", "render_human_message", "render_observation"}
     methods = [n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name in names]
-    ns = {"AIMessage": SimpleNamespace, "HumanMessage": SimpleNamespace, "validate_task": validate_task, "task_history": task_history}
+    ns = {"AIMessage": SimpleNamespace, "HumanMessage": SimpleNamespace,
+          "choose_curriculum_task": choose_curriculum_task,
+          "fallback_curriculum_task": fallback_curriculum_task,
+          "task_history": task_history}
     exec(compile(ast.Module(body=methods, type_ignores=[]), "curriculum.py", "exec"), ns)
     agent = SimpleNamespace(completed_tasks=["Obtain a spruce log"], failed_tasks=[])
     for name in names:
@@ -126,7 +143,7 @@ def check_curriculum_behavior(source):
     task, context = agent.propose_next_ai_task(messages=messages)
     assert task == "Mine 1 gravel" and "Creative mode" in context
     retry = agent.llm.call_args_list[1].args[0]
-    assert len(retry) == 4 and "Task already completed" in retry[-1].content
+    assert len(retry) == 4 and "No new, valid single Creative task" in retry[-1].content
     assert len(messages) == 2
     agent.progress = 100
     agent.warm_up = {"optional_inventory_items": 0}
@@ -147,6 +164,68 @@ def check_curriculum_behavior(source):
     agent.run_qa.assert_not_called()
     print("PASS curriculum retry changes input; Creative context and observation bypass Survival QA")
 
+    agent.completed_tasks, agent.failed_tasks = ["Mine 1 stone block to upgrade tools"], []
+    agent.llm = Mock(side_effect=[SimpleNamespace(content="Task: Mine 4 coal_ore, Place 4 coal_block")])
+    assert agent.propose_next_ai_task(messages=messages)[0] == "Mine 4 coal_ore"
+    agent.completed_tasks.append("Mine 4 coal ore")
+    agent.llm = Mock(side_effect=[SimpleNamespace(content="Task: Mine 4 coal_ore, Place 4 coal_block")])
+    assert agent.propose_next_ai_task(messages=messages)[0] == "Place 4 coal_block"
+    agent.llm = Mock(side_effect=[SimpleNamespace(content="Mine 1 gravel")])
+    assert agent.propose_next_ai_task(messages=messages)[0] == "Mine 1 gravel"
+    agent.llm = Mock(side_effect=[SimpleNamespace(content="Task: Craft a stone pickaxe"),
+                                    SimpleNamespace(content="Task: Obtain a wood log")])
+    task, _ = agent.propose_next_ai_task(messages=messages, max_retries=2)
+    assert task == "Explore 16 blocks north"
+    agent.llm = Mock(side_effect=[SimpleNamespace(content="Explain only") for _ in range(3)])
+    task, _ = agent.propose_next_ai_task(messages=[SimpleNamespace(content="Nearby blocks: dirt, stone")])
+    assert task == "Mine 1 dirt" and agent.llm.call_count == 3
+    assert task_spec(task) not in {task_spec(old) for old in agent.completed_tasks + agent.failed_tasks}
+    print("PASS valid, composite, duplicate, Survival, unlabeled and exhausted Curriculum outputs")
+
+
+def check_action_behavior(source):
+    tree = ast.parse(source)
+    cls = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "ActionAgent")
+    method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == "process_ai_message")
+
+    class Node(dict):
+        def __getattr__(self, name):
+            return self[name]
+
+    def parse_js(code):
+        subprocess.run(["node", "--check", "-"], input=code, text=True,
+                       capture_output=True, check=True)
+        node = Node(type="FunctionDeclaration", id=SimpleNamespace(name="placeStone"),
+                    params=[SimpleNamespace(type="Identifier", name="bot")])
+        node["async"] = True
+        return SimpleNamespace(program=SimpleNamespace(body=[node]))
+
+    generator = lambda node: SimpleNamespace(code="async function placeStone(bot) { await placeBlocks(bot, 'stone', 1); }")
+    require = lambda package: (SimpleNamespace(parse=parse_js) if package == "@babel/core"
+                               else SimpleNamespace(default=generator))
+    ns = {"extract_action_code": extract_action_code, "require": require}
+    exec(compile(ast.Module(body=[method], type_ignores=[]), "action.py", "exec"), ns)
+    process = MethodType(ns["process_ai_message"], SimpleNamespace())
+    samples = [
+        ("```js\nasync function placeStone(bot) { await placeBlocks(bot, 'stone', 1); }\n```", True),
+        ("Explain: ready\n```javascript\nasync function placeStone(bot) { await placeBlocks(bot, 'stone', 1); }\n```", True),
+        ("```js\nExplain: ready\nPlan: place block\nCode:\nasync function placeStone(bot) { await placeBlocks(bot, 'stone', 1); }\n```", True),
+        ("```js\nExplain: prelude\n```\n```js\nasync function placeStone(bot) { await placeBlocks(bot, 'stone', 1); }\n```", True),
+        ("```js\nasync function placeStone(bot) { await placeBlocks(bot, 'stone', 1);", False),
+        ("```js\nasync function placeStone(bot) { Explain: no; await placeBlocks(bot, 'stone', 1); }\n```", False),
+        ("```js\nasync function placeStone(bot) { await placeBlocks(bot, 'stone', 1); }\nfunction helper() {}\n```", False),
+        ("```js\nasync function placeStone(bot) {}\n```\n```js\nasync function again(bot) {}\n```", False),
+    ]
+    for content, valid in samples:
+        result = process(SimpleNamespace(content=content))
+        assert isinstance(result, dict) is valid, (content, result)
+        if valid:
+            assert result["program_name"] == "placeStone"
+            assert "Explain" not in result["program_code"]
+        else:
+            assert "before program execution" in result
+    print("PASS Action parser normalizes prose, rejects ambiguity, truncation and extra functions")
+
 
 def check_explore_behavior(source):
     harness = r'''
@@ -214,9 +293,9 @@ def check_clean_upstream(repo):
         assert "creativeGiveItem" in rendered_prompt
         curriculum = (stack.SRC / "voyager/agents/curriculum.py").read_text()
         assert "Creative deployment: skip Survival QA" in curriculum
-        assert "Creative mode rejects starter crafting grind" in curriculum
-        assert "Creative mode rejects Survival smelting grind" in curriculum
+        assert "Curriculum fallback after bounded retries" in curriculum
         check_curriculum_behavior(curriculum)
+        check_action_behavior((stack.SRC / "voyager/agents/action.py").read_text())
         exploration = (stack.SRC / "voyager/control_primitives/exploreUntil.js").read_text()
         assert "Math.sign(Number(direction.x))" in exploration
         assert "dy = 0" in exploration

voyager_action_parse.py

@@ -0,0 +1,75 @@
+"""Extract one executable Action function from small-model responses."""
+
+import re
+
+
+_FENCE = re.compile(r"```([^\n`]*)\n(.*?)```", re.DOTALL)
+_FUNCTION = re.compile(
+    r"(?m)^\s*async\s+function\s+[A-Za-z_$][\w$]*\s*\(\s*bot\s*\)\s*\{"
+)
+_OTHER_CODE = re.compile(r"\b(?:async\s+)?function\b|(?m:^\s*(?:class|import|export|const|let|var)\b)")
+_PROSE_INSIDE = re.compile(r"\b(?:Explain|Plan|Code)(?:\s*\([^\n]*\))?\s*:", re.IGNORECASE)
+
+
+def _function_end(source: str, opening: int) -> int:
+    """Find the closing brace, ignoring braces inside JS strings and comments."""
+    depth = 0
+    state = "code"
+    index = opening
+    while index < len(source):
+        char = source[index]
+        next_char = source[index + 1] if index + 1 < len(source) else ""
+        if state == "code":
+            if char in ("'", '"', "`"):
+                state = char
+            elif char == "/" and next_char in ("/", "*"):
+                state = next_char
+                index += 1
+            elif char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+                if depth == 0:
+                    return index + 1
+        elif state in ("'", '"', "`"):
+            if char == "\\":
+                index += 1
+            elif char == state:
+                state = "code"
+        elif state == "/" and char == "\n":
+            state = "code"
+        elif state == "*" and char == "*" and next_char == "/":
+            state = "code"
+            index += 1
+        index += 1
+    raise ValueError("Truncated JavaScript function; request a new Action response")
+
+
+def extract_action_code(response: str) -> str:
+    """Remove surrounding prose; reject ambiguous code and prose inside the function.
+
+    Babel validates JavaScript syntax and the exact top-level AST after this step.
+    A damaged function body is retried, never executed after deleting its lines.
+    """
+    response = str(response or "")
+    fences = _FENCE.findall(response)
+    if "```" in response and not fences:
+        raise ValueError("Unclosed Action code fence")
+    candidates = [body for language, body in fences if language.strip().lower() in ("", "js", "javascript")]
+    if not fences:
+        candidates = [response]
+    functions = []
+    for candidate in candidates:
+        match = _FUNCTION.search(candidate)
+        if not match:
+            continue
+        end = _function_end(candidate, candidate.index("{", match.start()))
+        if _OTHER_CODE.search(candidate[end:]):
+            raise ValueError("Extra top-level JavaScript after the Action function")
+        code = candidate[match.start():end].strip()
+        if _PROSE_INSIDE.search(code):
+            raise ValueError("Explain/Plan/Code prose inside the Action function")
+        functions.append(code)
+    if len(functions) != 1:
+        raise ValueError(f"Expected exactly one complete Action function; found {len(functions)}")
+    return functions[0]

voyager_runner.py

@@ -11,7 +11,7 @@ if str(VOYAGER_HOME) not in sys.path:
     sys.path.insert(0, str(VOYAGER_HOME))
 
 from voyager import Voyager  # noqa: E402
-from voyager_verification import quarantine_invalid_skills
+from voyager_verification import quarantine_invalid_skills, task_spec
 
 
 def env(name: str, default: str) -> str:
@@ -40,18 +40,31 @@ def main() -> None:
     # leave the same task in failed_tasks many times, including tasks that were
     # later completed under a spelling variant such as copper ore/copper_ore.
     if resume:
-        def _norm_task(value: str) -> str:
-            return " ".join(str(value).lower().replace("_", " ").split())
+        def _norm_task(value: str):
+            return task_spec(value) or " ".join(str(value).lower().replace("_", " ").split())
 
         completed_path = ckpt / "curriculum" / "completed_tasks.json"
         failed_path = ckpt / "curriculum" / "failed_tasks.json"
         try:
-            completed = json.loads(completed_path.read_text(encoding="utf-8"))
-            failed = json.loads(failed_path.read_text(encoding="utf-8"))
-            completed = list(dict.fromkeys(str(item) for item in completed))
+            original_completed = json.loads(completed_path.read_text(encoding="utf-8"))
+            original_failed = json.loads(failed_path.read_text(encoding="utf-8"))
+            archive = ckpt / "quarantine" / "curriculum_history_before_semantic_compaction_v1.json"
+            if not archive.exists():
+                archive.parent.mkdir(parents=True, exist_ok=True)
+                archive.write_text(json.dumps({"completed": original_completed, "failed": original_failed}, indent=2) + "\n", encoding="utf-8")
+
+            def unique(values):
+                seen, result = set(), []
+                for value in values:
+                    key = _norm_task(value)
+                    if key not in seen:
+                        seen.add(key)
+                        result.append(str(value))
+                return result
+
+            completed = unique(original_completed)
             completed_norm = {_norm_task(item) for item in completed}
-            failed = list(dict.fromkeys(str(item) for item in failed))
-            failed = [item for item in failed if _norm_task(item) not in completed_norm]
+            failed = [item for item in unique(original_failed) if _norm_task(item) not in completed_norm]
 
             # One-time repair for failures recorded while the Creative helper
             # context file was missing. Those attempts never reached the model
@@ -62,8 +75,11 @@ def main() -> None:
                 repair_marker.write_text("ok\n", encoding="utf-8")
                 print("[voyager] removed false starter-task failure from missing Creative context", flush=True)
 
-            completed_path.write_text(json.dumps(completed, indent=2) + "\n", encoding="utf-8")
-            failed_path.write_text(json.dumps(failed, indent=2) + "\n", encoding="utf-8")
+            for path, values, original in ((completed_path, completed, original_completed), (failed_path, failed, original_failed)):
+                if values != original:
+                    temporary = path.with_suffix(".json.tmp")
+                    temporary.write_text(json.dumps(values, indent=2) + "\n", encoding="utf-8")
+                    temporary.replace(path)
         except Exception as exc:
             print(f"[voyager] checkpoint curriculum cleanup skipped: {exc}", flush=True)
 

voyager_stack.py

@@ -507,7 +507,40 @@ async function exploreUntil(bot, direction, maxTime = 60, callback) {
             '            observation += f"Critique: {critique}\\n\\n"',
             '            observation += f"Critique: {critique[:1200]}\\n\\n"',
         )
-        action_agent_path.write_text(action_agent_text, encoding="utf-8")
+        safe_action_parser = '''    def process_ai_message(self, message):
+        # Do not concatenate fences or try the same malformed response 3 times.
+        # The caller retries with fresh feedback while Mineflayer stays connected.
+        try:
+            code = extract_action_code(message.content)
+            babel = require("@babel/core")
+            babel_generator = require("@babel/generator").default
+            parsed = babel.parse(code)
+            body = list(parsed.program.body)
+            if len(body) != 1 or body[0].type != "FunctionDeclaration" or not body[0]["async"]:
+                raise ValueError("Action must have exactly one top-level async function")
+            node = body[0]
+            params = list(node["params"])
+            if len(params) != 1 or params[0].type != "Identifier" or params[0].name != "bot":
+                raise ValueError("Action function must take exactly one bot argument")
+            return {
+                "program_code": babel_generator(node).code,
+                "program_name": node.id.name,
+                "exec_code": f"await {node.id.name}(bot);",
+            }
+        except Exception as error:
+            return f"Error parsing action response (before program execution): {error}"
+
+'''
+        action_agent_text, action_parser_count = re.subn(
+            r'(?ms)^    def process_ai_message\(self, message\):\n.*?(?=^    def summarize_chatlog\(self, events\):)',
+            lambda match: safe_action_parser,
+            action_agent_text,
+            count=1,
+        )
+        if action_parser_count != 1:
+            raise RuntimeError("Voyager Action parser marker changed")
+        action_agent_text = 'from voyager_action_parse import extract_action_code\n' + action_agent_text
+        action_agent_path.write_text(action_agent_text, encoding="utf-8")
 
         # Bound curriculum memory rendered into every task proposal. The full
         # persistent lists remain on disk; only the prompt view is compacted.
@@ -677,7 +710,54 @@ async function exploreUntil(bot, direction, maxTime = 60, callback) {
         curriculum_text = curriculum_text.replace(
             '", ".join(self.completed_tasks)', 'task_history(self.completed_tasks)',
         ).replace('", ".join(self.failed_tasks)', 'task_history(self.failed_tasks)')
-        curriculum_path.write_text(curriculum_text, encoding="utf-8")
+        safe_curriculum_method = '''    def propose_next_ai_task(self, *, messages, max_retries=5):
+        # A local model at temperature zero can repeat one malformed composite
+        # indefinitely. Each attempt gets fresh feedback; exhaustion uses a
+        # deterministic, verified Creative task without exiting Voyager.
+        conversation = list(messages)
+        for attempt in range(max(0, min(int(max_retries), 3))):
+            curriculum = ""
+            try:
+                curriculum = self.llm(conversation).content
+                print(f"Curriculum Agent proposal: {curriculum}", flush=True)
+                next_task = choose_curriculum_task(
+                    curriculum, self.completed_tasks, self.failed_tasks
+                )
+                return next_task, self.get_task_context(next_task)
+            except Exception as error:
+                print(f"Rejected Curriculum proposal {attempt + 1}: {error}", flush=True)
+                if curriculum:
+                    conversation.append(AIMessage(content=curriculum[:1200]))
+                conversation.append(HumanMessage(content=(
+                    f"Rejected proposal: {error}. Choose one NEW Creative objective. "
+                    "Use one Task: Mine/Place/Obtain/Equip N minecraft_id or "
+                    "Explore 16/24/32 blocks north/south/east/west."
+                )))
+        next_task = fallback_curriculum_task(messages, self.completed_tasks, self.failed_tasks)
+        print(f"Curriculum fallback after bounded retries: {next_task}", flush=True)
+        return next_task, self.get_task_context(next_task)
+
+'''
+        curriculum_text, safe_curriculum_count = re.subn(
+            r'(?ms)^    def propose_next_ai_task\(self, \*, messages, max_retries=5\):\n.*?(?=^    def parse_ai_message\(self, message\):)',
+            lambda match: safe_curriculum_method,
+            curriculum_text,
+            count=1,
+        )
+        if safe_curriculum_count != 1:
+            raise RuntimeError("Voyager Curriculum method marker changed")
+        curriculum_text = curriculum_text.replace(
+            'from voyager_verification import validate_task, task_history',
+            'from voyager_verification import (choose_curriculum_task, fallback_curriculum_task, '
+            'task_history, task_spec, validate_task)',
+            1,
+        )
+        curriculum_text = curriculum_text.replace(
+            'return " ".join(str(value).lower().replace("_", " ").split())',
+            'return task_spec(value) or " ".join(str(value).lower().replace("_", " ").split())',
+            1,
+        )
+        curriculum_path.write_text(curriculum_text, encoding="utf-8")
 
         # The upstream prompt contains a Survival wood-log example and forbids
         # building. Appending a Creative rule leaves contradictory instructions.
@@ -1094,9 +1174,30 @@ async function exploreUntil(bot, direction, maxTime = 60, callback) {
         except Exception:
             return {"ready": False}
 
-    def status(self) -> dict[str, Any]:
-        mineflayer = self._mineflayer_status()
-        with self.lock:
+    def status(self) -> dict[str, Any]:
+        mineflayer = self._mineflayer_status()
+        try:
+            lines = LOG_PATH.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            lines = []
+        try:
+            completed = json.loads((CKPT_DIR / "curriculum" / "completed_tasks.json").read_text(encoding="utf-8"))
+            failed = json.loads((CKPT_DIR / "curriculum" / "failed_tasks.json").read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            completed, failed = [], []
+        activity = {
+            "completed_count": len(completed),
+            "failed_count": len(failed),
+            "recent_completed": completed[-5:],
+            "curriculum_fallbacks": sum("Curriculum fallback after bounded retries" in line for line in lines),
+            "action_parse_errors": sum("Error parsing action response (before program execution)" in line for line in lines),
+            "curriculum_value_errors": sum("ValueError:" in line and "Use exactly Mine/Place" in line for line in lines),
+            "partial_read_errors": sum("PartialReadError" in line for line in lines),
+            "file_not_found_errors": sum("FileNotFoundError" in line for line in lines),
+            "index_errors": sum("IndexError" in line for line in lines),
+            "syntax_errors": sum("SyntaxError" in line for line in lines),
+        }
+        with self.lock:
             proc = self.proc
             return {
                 "state": self.state,
@@ -1113,7 +1214,8 @@ async function exploreUntil(bot, direction, maxTime = 60, callback) {
                 "bot_username": BOT_USERNAME,
                 "bot_display_name": BOT_DISPLAY_NAME,
                 "checkpoint_dir": str(CKPT_DIR),
-                "checkpoint_persistent": str(CKPT_DIR).startswith("/persist/"),
+                "checkpoint_persistent": str(CKPT_DIR).startswith("/persist/"),
+                "activity": activity,
                 "restart_count": self.restart_count,
                 "mineflayer": mineflayer,
                 "log_tail": self.tail(120),

voyager_verification.py

@@ -71,21 +71,114 @@ def validate_task(task, completed, failed):
     return task
 
 
-def task_history(tasks):
+def canonical_task(value):
+    """Convert one legacy/LLM objective into the permitted Creative grammar."""
+    spec = task_spec(value)
+    if not spec:
+        return None
+    kind, count, name = spec
+    if kind == "explore":
+        task = f"Explore {count} blocks {name}"
+    else:
+        task = f"{kind.title()} {count} {name}"
+    if not re.fullmatch(r"(?:Mine|Place|Obtain|Equip) [1-4] [a-z][a-z0-9_]*|Explore (?:16|24|32) blocks (?:north|south|east|west)", task):
+        return None
+    if kind == "equip" and count != 1:
+        return None
+    # These are either Survival starter grind or unbreakable/impractical goals.
+    if kind in {"mine", "place"} and name in {"bedrock", "obsidian", "air", "water", "lava", "barrier"}:
+        return None
+    if kind == "obtain" and name in {
+        "wood_log", "wooden_log", "planks", "stick", "sticks", "wooden_pickaxe",
+        "stone_pickaxe", "crafting_table", "furnace",
+    }:
+        return None
+    return task
+
+
+def curriculum_candidates(response):
+    """Return single actions in order, splitting model-generated compound tasks."""
+    lines = re.findall(r"(?im)^\s*Task\s*:\s*(.+)$", str(response or ""))
+    if not lines:
+        lines = str(response or "").splitlines()
+    for line in lines:
+        for part in re.split(
+            r"\s*[,;]\s*|\s+(?:and then|then|and)\s+(?=(?:Mine|Place|Obtain|Equip|Explore)\b)",
+            line, flags=re.IGNORECASE,
+        ):
+            candidate = canonical_task(part.strip(" .:-\t"))
+            if candidate:
+                yield candidate
+
+
+def choose_curriculum_task(response, completed, failed):
+    for task in curriculum_candidates(response):
+        try:
+            return validate_task(task, completed, failed)
+        except ValueError:
+            continue
+    raise ValueError("No new, valid single Creative task in Curriculum response")
+
+
+def fallback_curriculum_task(messages, completed, failed):
+    """Use observed blocks first; otherwise rotate through safe Creative goals."""
+    observed = "\n".join(str(getattr(message, "content", message)) for message in messages)
+    nearby = re.findall(r"(?im)^Nearby blocks:\s*([^\n]+)", observed)
+    if nearby:
+        for name in nearby[-1].split(","):
+            name = name.strip().lower().replace(" ", "_")
+            if name != "none" and re.fullmatch(r"[a-z][a-z0-9_]*", name):
+                task = canonical_task(f"Mine 1 {name}")
+                if task:
+                    try:
+                        return validate_task(task, completed, failed)
+                    except ValueError:
+                        pass
+    for distance in (16, 24, 32):
+        for direction in ("north", "east", "south", "west"):
+            task = f"Explore {distance} blocks {direction}"
+            try:
+                return validate_task(task, completed, failed)
+            except ValueError:
+                pass
+    palette = (
+        "stone", "dirt", "grass_block", "cobblestone", "oak_planks", "spruce_planks",
+        "birch_planks", "sandstone", "bricks", "glass", "white_wool", "orange_wool",
+        "red_wool", "blue_wool", "green_wool", "white_concrete", "red_concrete",
+        "blue_concrete", "terracotta", "polished_andesite", "polished_granite",
+        "deepslate_bricks", "moss_block", "quartz_block", "glowstone", "sea_lantern",
+        "copper_block", "iron_block", "gold_block", "diamond_block", "emerald_block",
+        "netherite_block", "oak_log", "spruce_log", "birch_log", "snow_block",
+    )
+    for count in (1, 2, 3, 4):
+        for name in palette:
+            task = f"Place {count} {name}"
+            try:
+                return validate_task(task, completed, failed)
+            except ValueError:
+                pass
+    # The finite grammar can theoretically be exhausted. Keep Voyager alive;
+    # in practice hundreds of distinct safe objectives remain in the palette.
+    return "Explore 16 blocks north"
+
+
+def task_history(tasks, limit=48):
     """Compact legacy prose in prompts while retaining the full checkpoint."""
     entries = []
     legacy = 0
     for task in tasks:
         spec = task_spec(task)
-        if spec:
+        if spec and canonical_task(task):
             kind, count, item = spec
             entry = f"{kind.title()} {count} {'blocks ' if kind == 'explore' else ''}{item}"
             if entry not in entries:
                 entries.append(entry)
         else:
             legacy += 1
-    if legacy:
-        entries.append(f"{legacy} older objectives retained in checkpoint")
+    omitted = max(0, len(entries) - limit)
+    entries = entries[-limit:]
+    if legacy or omitted:
+        entries.append(f"{legacy + omitted} older objectives retained in checkpoint")
     return ", ".join(entries) or "None"