fix: mineBlock must reach a layer that is ABOVE the bot (measured: gold at y=52, bot stuck at y=51)

voyager_stack.py

@@ -353,7 +353,7 @@ class VoyagerStack:
         maxDistance: 32,
     });
 
-    // Walk down a staircase the bot can always climb back out of. Mirrors the
+    // Walk a staircase the bot can always climb back out of. Mirrors the
     // descent policy in exploreUntil: dig the block underfoot, settle, repeat.
     // Never asks the pathfinder for a lower goal, which is what used to make it
     // drive itself off a ledge.
@@ -377,13 +377,68 @@ class VoyagerStack:
         return false;
     };
 
+    // The bot can end up ABOVE the layer it is looking for -- it dug down
+    // looking for gold, passed through y=52-53 and stalled at y=51 inside the
+    // iron band, with the gold now 1-2 blocks over its head. descendToward()
+    // returns true immediately in that case (pos.y <= targetY is already true),
+    // so the caller searched again, found nothing new, and threw the same error
+    // on every cycle while the observation kept listing gold_ore as nearby.
+    //
+    // When the target layer is above the bot, mine the block overhead and step
+    // up, which is the mirror of the descent and works in a layered world where
+    // the column is solid all the way to the surface.
+    const ascendToward = async (targetY) => {
+        let steps = 0;
+        while (steps < MAX_DIG_DEPTH) {
+            const pos = bot.entity.position;
+            if (Math.floor(pos.y) >= targetY) return true;
+            const above = bot.entity.blockAt(bot.entity.position.offset(0, 2, 0));
+            if (!above) return false;
+            if (above.boundingBox !== "empty" && above.name !== "bedrock") {
+                try {
+                    // Stand still and dig straight up; the block falls into the
+                    // space, then the bot steps up into it.
+                    await bot.dig(above, true);
+                } catch (_) {
+                    return false;
+                }
+            }
+            await bot.waitForTicks(3);
+            try {
+                await bot.pathfinder.goto(new GoalBlock(
+                    Math.floor(pos.x), Math.floor(pos.y) + 1, Math.floor(pos.z)
+                ));
+            } catch (_) {
+                return false;
+            }
+            steps++;
+        }
+        return false;
+    };
+
+    // Reach a target layer that is either above or below the bot, then hand
+    // back a fresh search. Returns null when the layer cannot be reached, so
+    // the caller still reports a real "not here" instead of looping.
+    const approachLayer = async (targetY) => {
+        const botY = Math.floor(bot.entity.position.y);
+        if (targetY < botY) {
+            const reached = await descendToward(targetY);
+            return reached ? findTarget(searchFloorY) : null;
+        }
+        if (targetY > botY) {
+            const reached = await ascendToward(targetY);
+            return reached ? findTarget(searchFloorY) : null;
+        }
+        return null; // same level and still not found: genuinely elsewhere
+    };
+
     while (mined < wanted) {
         let block = findTarget(searchFloorY);
 
         if (!block) {
             // Nothing inside the dig budget at this X/Z. If the target is ores
-            // this map stacks as a layer, walk down toward it; the layer is
-            // continuous, so a straight descent reaches it. Anything else means
+            // this map stacks as a layer, walk to that layer; the layer is
+            // continuous, so a straight approach reaches it. Anything else means
             // the block genuinely is not here and the model must travel.
             const probe = bot.findBlock({
                 matching: (candidate) => Boolean(candidate) &&
@@ -395,8 +450,7 @@ class VoyagerStack:
             });
             const knownOre = /(^|_)ore$/.test(name);
             if (probe && knownOre) {
-                const reached = await descendToward(probe.position.y);
-                block = reached ? findTarget(searchFloorY) : null;
+                block = await approachLayer(probe.position.y);
             }
         }