Bound Creative exploration and favor verifiable flat-world tasks

tests/test_voyager_patch.py

@@ -204,10 +204,10 @@ def check_curriculum_behavior(source):
     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"
+    assert task == "Place 1 stone"
     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 == "Place 1 stone" and agent.llm.call_count == 3
     assert task_spec(task) not in {task_spec(old) for old in agent.completed_tasks + agent.failed_tasks}
     agent.mode = "auto"
     agent.render_system_message = Mock(return_value=SimpleNamespace(content="Creative"))
@@ -297,7 +297,29 @@ async function run(direction, mode) {
     assert.equal(chats,0);
     return goal;
 }
+async function bounded() {
+    let interval, timer;
+    const goals=[];
+    const context={Math,Number,Promise,Error,
+        GoalNearXZ: class {constructor(x,z){Object.assign(this,{x,z});}},
+        setInterval:fn=>(interval=fn,1), setTimeout:fn=>(timer=fn,2),
+        clearInterval:()=>{}, clearTimeout:()=>{}};
+    vm.createContext(context); vm.runInContext(source,context);
+    const bot={game:{gameMode:'creative'},entity:{position:{x:0,y:64,z:0}},
+        pathfinder:{setGoal:g=>goals.push(g)}};
+    const promise=context.exploreUntil(bot,{x:1,y:0,z:1},60,()=>false);
+    for(let i=0;i<12;i++) {
+        interval();
+        const goal=goals[goals.length-1];
+        if(goal===null) break;
+        assert(Math.hypot(goal.x,goal.z)<=32.00001);
+        bot.entity.position.x=goal.x; bot.entity.position.z=goal.z;
+    }
+    assert.equal(await promise,null);
+    assert.equal(goals[goals.length-1],null);
+}
 (async()=>{
+    await bounded();
     const g=await run({x:0.25,y:-0.4,z:-0.75},'creative');
     assert(g.x>0 && g.z<0 && !('y' in g));
     const v=await run({x:0,y:-1,z:0},'creative');

voyager_stack.py

@@ -356,10 +356,11 @@ async function creativeGiveItem(bot, name, count = 1) {
         const candidates = [[1,0],[-1,0],[0,1],[0,-1],[1,1],[1,-1],[-1,1],[-1,-1]];
         [dx, dz] = candidates[Math.floor(Math.random() * candidates.length)];
     }
-    if (bot.game && bot.game.gameMode === "creative") dy = 0;
-
-    maxTime = Math.min(maxTime, 120);
-    return new Promise((resolve, reject) => {
+    if (bot.game && bot.game.gameMode === "creative") dy = 0;
+
+    maxTime = Math.min(maxTime, 120);
+    const start = {x: bot.entity.position.x, z: bot.entity.position.z};
+    return new Promise((resolve, reject) => {
         let explorationInterval;
         let maxTimeTimeout;
         const cleanUp = () => {
@@ -375,7 +376,19 @@ async function creativeGiveItem(bot, name, count = 1) {
                     resolve(result);
                     return;
                 }
-                const distance = Math.floor(Math.random() * 12 + 8);
+                let distance = Math.floor(Math.random() * 12 + 8);
+                if (bot.game && bot.game.gameMode === "creative") {
+                    const travelled = Math.hypot(
+                        bot.entity.position.x - start.x, bot.entity.position.z - start.z
+                    );
+                    const remaining = 32 - travelled;
+                    if (remaining <= 1) {
+                        cleanUp();
+                        resolve(null);
+                        return;
+                    }
+                    distance = Math.min(distance, remaining / Math.hypot(dx, dz));
+                }
                 const x = bot.entity.position.x + distance * dx;
                 const y = bot.entity.position.y + distance * dy;
                 const z = bot.entity.position.z + distance * dz;

voyager_verification.py

@@ -134,26 +134,11 @@ def choose_curriculum_task(response, completed, failed):
 
 
 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
+    """Choose a verifiable Creative placement before bounded exploration.
+
+    Nearby block names lack coordinates. In a flat world they mostly describe
+    the Y=63 floor, which mineBlock deliberately refuses to dig from Y=64.
+    """
     palette = (
         "stone", "dirt", "grass_block", "cobblestone", "oak_planks", "spruce_planks",
         "birch_planks", "sandstone", "bricks", "glass", "white_wool", "orange_wool",
@@ -170,6 +155,13 @@ def fallback_curriculum_task(messages, completed, failed):
                 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
     # 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"