So i dont fuck the walker kek

docs/AGENT_SERVER.md

@@ -273,6 +273,52 @@ Body: `{"name": "Banker", "action": "Bank"}` or `{"id": 3010, "action": "Attack"
 }
 ```
 
+#### GET /objects/neighbours
+
+Same filters as `GET /objects`, plus the walkability of the tiles surrounding each match. Use it to
+catalogue obstacles that sit *between* two walkable tiles — Motherlode rockfalls, rubble, rock
+slides — where modelling the obstacle as a transport in `transports.tsv` needs both of its open
+ends, which the object's own position does not give you.
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `id` / `name` / `nameContains` | - | Same filters as `GET /objects` |
+| `maxDistance` | `20` | Max tile distance (scene radius is ~104) |
+| `radius` | `1` | Neighbour ring size, clamped to 1-5 |
+| `limit` | config max | Max results |
+
+`sides` pairs opposing neighbours on each axis, so a blocking obstacle's two endpoints can be read
+straight off the response. Walkability comes from the **live scene** collision flags, not the
+bundled collision map, so it reflects what the player can actually do right now — which is the
+point when the bundled map has an obstacle baked in as a permanent wall.
+
+```bash
+curl -s -H "X-Agent-Token: $(cat ~/.runelite/.agent-token)" \
+  "http://127.0.0.1:8081/objects/neighbours?id=26679&maxDistance=104&limit=200"
+```
+
+```json
+{
+  "count": 1, "total": 1, "radius": 1,
+  "objects": [
+    {
+      "id": 26679, "name": "Rockfall", "type": "GAME", "reachable": true,
+      "position": {"x": 3742, "y": 5668, "plane": 0},
+      "selfWalkable": false,
+      "neighbours": [
+        {"position": {"x": 3741, "y": 5668, "plane": 0}, "dx": -1, "dy": 0, "walkable": true}
+      ],
+      "sides": {
+        "eastWest":   {"a": {"...": "dx=-1"}, "b": {"...": "dx=+1"}, "bothWalkable": true},
+        "northSouth": {"a": {"...": "dy=-1"}, "b": {"...": "dy=+1"}, "bothWalkable": false}
+      }
+    }
+  ]
+}
+```
+
+The axis whose `bothWalkable` is `true` gives the transport's origin/destination pair.
+
 #### POST /objects/interact
 
 Body: `{"name": "Oak tree", "action": "Chop down"}`

runelite-client/src/main/java/net/runelite/client/plugins/microbot/Script.java

@@ -3,7 +3,7 @@
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 import net.runelite.api.coords.WorldPoint;
-import net.runelite.client.plugins.microbot.shortestpath.ShortestPathPlugin;
+import net.runelite.client.plugins.microbot.util.walker.Rs2PathApi;
 import net.runelite.client.plugins.microbot.util.Global;
 import net.runelite.client.plugins.microbot.agentserver.handler.ScriptHeartbeatRegistry;
 import net.runelite.client.plugins.microbot.util.antiban.SessionFatigue;
@@ -56,7 +56,7 @@ public void shutdown() {
         ScriptHeartbeatRegistry.remove(this.getClass().getName());
         if (mainScheduledFuture != null && !mainScheduledFuture.isDone()) {
             mainScheduledFuture.cancel(true);
-            ShortestPathPlugin.exit();
+            Rs2PathApi.exit();
             if (Microbot.getClientThread().scheduledFuture != null)
                 Microbot.getClientThread().scheduledFuture.cancel(true);
             initialPlayerLocation = null;

runelite-client/src/main/java/net/runelite/client/plugins/microbot/agentserver/handler/ObjectHandler.java

@@ -36,6 +36,10 @@ protected void handleRequest(HttpExchange exchange) throws IOException {
 			case "/interact":
 				handleInteract(exchange);
 				break;
+			case "/neighbours":
+			case "/neighbors":
+				handleNeighbours(exchange);
+				break;
 			default:
 				sendJson(exchange, 404, errorResponse("Unknown path: /objects" + sub));
 		}
@@ -133,6 +137,147 @@ private void handleInteract(HttpExchange exchange) throws IOException {
 		sendJson(exchange, 200, response);
 	}
 
+	/**
+	 * Like the plain query, but also reports the walkability of the tiles surrounding each match.
+	 *
+	 * <p>Exists to catalogue obstacles that sit <em>between</em> two walkable tiles — Motherlode
+	 * rockfalls, rubble, rock slides. Modelling one as a transport needs both sides, which the
+	 * object's own position does not give you. {@code sides} pairs opposing neighbours on each axis
+	 * so a blocking obstacle's two open ends can be read straight off the response.
+	 *
+	 * <p>Walkability comes from the <em>live scene</em> collision flags, not the bundled collision
+	 * map, so it reflects what the player can actually do right now. The flag array is read once per
+	 * request rather than per tile, since each {@code Rs2Tile.isWalkable} call hops the client thread.
+	 */
+	private void handleNeighbours(HttpExchange exchange) throws IOException {
+		try {
+			requireGet(exchange);
+		} catch (HttpMethodException e) {
+			sendJson(exchange, 405, errorResponse(e.getMessage()));
+			return;
+		}
+
+		Map<String, String> params = parseQuery(exchange.getRequestURI());
+		String name = params.get("name");
+		String nameContains = params.get("nameContains");
+		int id = getIntParam(params, "id", -1);
+		int maxDistance = getIntParam(params, "maxDistance", 20);
+		int limit = getIntParam(params, "limit", defaultLimit);
+		int radius = Math.max(1, Math.min(5, getIntParam(params, "radius", 1)));
+
+		var query = Microbot.getRs2TileObjectCache().query();
+		if (id >= 0) {
+			query = query.withId(id);
+		}
+		if (name != null && !name.isEmpty()) {
+			query = query.withName(name);
+		} else if (nameContains != null && !nameContains.isEmpty()) {
+			query = query.withNameContains(nameContains);
+		}
+		query = query.within(maxDistance);
+
+		List<Rs2TileObjectModel> objects = query.toListOnClientThread();
+		List<Rs2TileObjectModel> limited = objects.stream().limit(limit).collect(Collectors.toList());
+
+		List<Map<String, Object>> serialized = Microbot.getClientThread().runOnClientThreadOptional(() -> {
+			var wv = Microbot.getClient().getTopLevelWorldView();
+			if (wv == null) {
+				return null;
+			}
+			var collisionData = wv.getCollisionMaps();
+			int[][] flags = collisionData != null ? collisionData[wv.getPlane()].getFlags() : null;
+
+			List<Map<String, Object>> out = new ArrayList<>();
+			for (Rs2TileObjectModel obj : limited) {
+				Map<String, Object> map = serializeObject(obj);
+				WorldPoint loc = obj.getWorldLocation();
+				if (loc == null) {
+					out.add(map);
+					continue;
+				}
+
+				Map<String, Map<String, Object>> byOffset = new LinkedHashMap<>();
+				List<Map<String, Object>> neighbours = new ArrayList<>();
+				for (int dx = -radius; dx <= radius; dx++) {
+					for (int dy = -radius; dy <= radius; dy++) {
+						if (dx == 0 && dy == 0) {
+							continue;
+						}
+						WorldPoint p = new WorldPoint(loc.getX() + dx, loc.getY() + dy, loc.getPlane());
+						Map<String, Object> entry = new LinkedHashMap<>();
+						entry.put("position", positionOf(p));
+						entry.put("dx", dx);
+						entry.put("dy", dy);
+						entry.put("walkable", isWalkableInScene(wv, flags, p));
+						neighbours.add(entry);
+						byOffset.put(dx + "," + dy, entry);
+					}
+				}
+				map.put("neighbours", neighbours);
+
+				// Opposing pairs on each axis: for an obstacle standing between two open tiles these
+				// are the transport's two endpoints.
+				Map<String, Object> sides = new LinkedHashMap<>();
+				sides.put("eastWest", axisPair(byOffset, -1, 0, 1, 0));
+				sides.put("northSouth", axisPair(byOffset, 0, -1, 0, 1));
+				map.put("sides", sides);
+
+				map.put("selfWalkable", isWalkableInScene(wv, flags, loc));
+				out.add(map);
+			}
+			return out;
+		}).orElse(null);
+
+		if (serialized == null) {
+			sendJson(exchange, 503, errorResponse("Scene unavailable (not logged in?)"));
+			return;
+		}
+
+		Map<String, Object> response = new LinkedHashMap<>();
+		response.put("count", serialized.size());
+		response.put("total", objects.size());
+		response.put("radius", radius);
+		response.put("objects", serialized);
+		sendJson(exchange, 200, response);
+	}
+
+	private static Map<String, Object> axisPair(Map<String, Map<String, Object>> byOffset,
+												int aDx, int aDy, int bDx, int bDy) {
+		Map<String, Object> a = byOffset.get(aDx + "," + aDy);
+		Map<String, Object> b = byOffset.get(bDx + "," + bDy);
+		Map<String, Object> pair = new LinkedHashMap<>();
+		pair.put("a", a);
+		pair.put("b", b);
+		pair.put("bothWalkable", a != null && b != null
+				&& Boolean.TRUE.equals(a.get("walkable")) && Boolean.TRUE.equals(b.get("walkable")));
+		return pair;
+	}
+
+	private static Map<String, Integer> positionOf(WorldPoint p) {
+		Map<String, Integer> position = new LinkedHashMap<>();
+		position.put("x", p.getX());
+		position.put("y", p.getY());
+		position.put("plane", p.getPlane());
+		return position;
+	}
+
+	/** Live-scene walkability; false when the tile is outside the loaded scene. */
+	private static boolean isWalkableInScene(net.runelite.api.WorldView wv, int[][] flags, WorldPoint p) {
+		if (flags == null) {
+			return false;
+		}
+		net.runelite.api.coords.LocalPoint lp = net.runelite.api.coords.LocalPoint.fromWorld(wv, p);
+		if (lp == null) {
+			return false;
+		}
+		int sx = lp.getSceneX();
+		int sy = lp.getSceneY();
+		if (sx < 0 || sy < 0 || sx >= flags.length || sy >= flags[sx].length) {
+			return false;
+		}
+		return (flags[sx][sy] & net.runelite.api.CollisionDataFlag.BLOCK_MOVEMENT_FULL) == 0;
+	}
+
 	private Map<String, Object> serializeObject(Rs2TileObjectModel obj) {
 		Map<String, Object> map = new LinkedHashMap<>();
 		map.put("id", obj.getId());

runelite-client/src/main/java/net/runelite/client/plugins/microbot/questhelper/.quest-helper-sync

@@ -8,16 +8,22 @@
 # Use the quest-helper update scripts to manage synchronization.
 
 # Current sync position - this is the last external commit that has been integrated
-5539626281a502ba8c44fe59b8b57bce32fe4f16
+ae1f441248b9742c1eaa667b18052785eb6ed058
 
 # Sync metadata (for script reference)
-# External repo HEAD at last check: 5539626281a502ba8c44fe59b8b57bce32fe4f16
-# Last sync date: 2025-08-29
-# Sync method: automated script with manual package transformation
-# Integration branch: quest-helper-update-20250829_063754
-# Local commit: cb416ef02a (quest-helper: polish Enakhras Lament)
+# External repo HEAD at last check: ae1f441248b9742c1eaa667b18052785eb6ed058
+# Last sync date: 2026-07-19
+# Sync method: upstream source mirror with manual package transformation and Microbot hook preservation
+# Integration branch: local workspace
+# Local commit: pending
 
 # Sync history log:
+# 2026-07-19 - Complete sync to upstream ae1f4412 (Quest Helper 4.16.1 source)
+#   - Mirrored upstream src/main/java and src/main/resources into the Microbot package
+#   - Preserved Microbot QuestScript, custom quest logic, config toggles, and agent-server start hook
+#   - Package transformation: com.questhelper -> net.runelite.client.plugins.microbot.questhelper
+#   - Status: SUCCESS
+#
 # 2025-08-29 07:14:46 - Applied commit 55396262 (Polish enahkras lament #2294)
 #   - Enhanced EnakhrasLament.java with better code organization
 #   - Fixed Shadow Room brazier puzzle sequence and locations
@@ -43,9 +49,9 @@
 #   - Status: INITIALIZED
 
 # Integration status
-# Current external version: 4.10.0+
+# Current external version: 4.16.1
 # Integration health: HEALTHY  
-# Last validation: 2025-08-29
+# Last validation: 2026-07-19
 # Compilation status: SUCCESS
 # Package transformation: COMPLETE
-# Sync file location: CORRECT (moved from project root)
+# Sync file location: CORRECT (moved from project root)

runelite-client/src/main/java/net/runelite/client/plugins/microbot/questhelper/QuestHelperConfig.java

@@ -46,6 +46,8 @@ public interface QuestHelperConfig extends Config
 	String QUEST_HELPER_GROUP = "questhelper";
 	String QUEST_BACKGROUND_GROUP = "questhelpervars";
 	String QUEST_HELPER_SIDEBAR_ORDER_KEY_START = "quest-sidebar-order-";
+	/** Per-helper persisted manual step skips (JSON map of stable slot id to true). */
+	String QUEST_HELPER_MANUAL_SKIPS_KEY_PREFIX = "manual-step-skips-";
 
 	enum QuestOrdering implements Comparator<QuestHelper>
 	{
@@ -237,32 +239,33 @@ enum InventoryItemHighlightStyle
 	}
 
 	@ConfigSection(
-			position = 0,
-			name = "Microbot",
-			description = "Microbot Options",
-			closedByDefault = false
+		position = 0,
+		name = "Microbot",
+		description = "Microbot Options",
+		closedByDefault = false
 	)
 	String microbotSection = "microbotSection";
 
-
 	@ConfigItem(
-			keyName = "TurnOn",
-			name = "Enable QuestHelper",
-			description = "Enable the quest helper that will automatically help with quests.",
-			section = microbotSection
+		keyName = "TurnOn",
+		name = "Enable QuestHelper",
+		description = "Enable the quest helper that will automatically help with quests.",
+		section = microbotSection
 	)
-	default boolean startStopQuestHelper() {
+	default boolean startStopQuestHelper()
+	{
 		return true;
 	}
 
 	@ConfigItem(
-			keyName = "obtainMissingItems",
-			name = "Obtain Missing Items",
-			description = "Controls whether the quest helper automatically obtains missing items from the bank and Grand Exchange. 'Ask' will prompt you the first time items are needed.",
-			section = microbotSection,
-			position = 1
+		keyName = "obtainMissingItems",
+		name = "Obtain Missing Items",
+		description = "Controls whether the quest helper automatically obtains missing items from the bank and Grand Exchange. 'Ask' will prompt you the first time items are needed.",
+		section = microbotSection,
+		position = 1
 	)
-	default ObtainMissingItemsOption obtainMissingItems() {
+	default ObtainMissingItemsOption obtainMissingItems()
+	{
 		return ObtainMissingItemsOption.ASK;
 	}
 
@@ -332,14 +335,15 @@ public String toString()
 	}
 
 	@ConfigItem(
-			keyName = "valeTotemsWoodType",
-			name = "Vale Totems wood type",
-			description = "Which wood type the quester should gather for the Vale Totems miniquest. " +
-					"Must match the wood you used to build the totem. " +
-					"Leave on 'Ask me' to be prompted the first time the quest runs.",
-			section = microbotSection
+		keyName = "valeTotemsWoodType",
+		name = "Vale Totems wood type",
+		description = "Which wood type the quester should gather for the Vale Totems miniquest. " +
+			"Must match the wood you used to build the totem. " +
+			"Leave on 'Ask me' to be prompted the first time the quest runs.",
+		section = microbotSection
 	)
-	default ValeTotemsWoodType valeTotemsWoodType() {
+	default ValeTotemsWoodType valeTotemsWoodType()
+	{
 		return ValeTotemsWoodType.ASK;
 	}
 
@@ -791,6 +795,25 @@ default boolean showCompletedQuests()
 		return false;
 	}
 
+	enum RegionFilterVisibility
+	{
+		AUTO,
+		SHOW,
+		HIDE
+	}
+
+	@ConfigItem(
+		keyName = "regionFilterVisibility",
+		name = "Region filtering",
+		description = "Controls when the league region filter is shown. Auto shows it only on league worlds.",
+		position = 5,
+		section = filterSection
+	)
+	default RegionFilterVisibility regionFilterVisibility()
+	{
+		return RegionFilterVisibility.AUTO;
+	}
+
 	@ConfigSection(
 		position = 5,
 		name = "Development",