fix(walker): streamline door and transport handoffs

Author: chsami

docs/entity-guides/movement.md

@@ -194,8 +194,8 @@ if (bothEndpointTilesReachable
     continue;
 }
 if (doorOpenedButPlayerDidNotTraverse) {
-    // Only count this as success if the nudge actually reaches/crosses the door edge.
-    tryDoorEdgeCrossNudge(from, to, currentTarget);
+    // Record the open edge, then let normal route selection choose the next click.
+    markStationaryDoorOpened(doorTile);
 }
 if (hasPendingDoorLikeSceneObjectBeforeDirectClick(rawPath, path, playerLoc, DIRECT_CLICK_MAX_DISTANCE)
         || handlePendingDoorBeforeRouteClick(rawPath, path, i, targetIdx, smoothedToRaw, timeoutMs,
@@ -295,3 +295,23 @@ Sticky interim targets should also clear when route-index progress goes stale. I
 When a route-following minimap click is outside the minimap clip, fallback clicks must stay on the raw path. A generic "reachable tile closer to target" fallback can select a tile far away from the route in open areas, especially near the final destination.
 
 For adjacent same-plane shortcuts, do not treat any movement away from the origin as success. Some shortcuts, such as stepping stones, can fail and place the player on a fallback tile; once the player is settled away from the expected destination, stop the landing wait and replan from the actual tile.
+
+## 14. Resume normal route selection after opening a door
+
+Opening a door should only resolve the blocked route edge. Do not follow it with a special canvas click on the adjacent far-side tile. Once the open edge is stable, yield the pass and let the normal route selector click the furthest reachable raw-path tile toward the destination.
+
+**Why this matters:** An explicit one-tile cross-door nudge produces a conspicuous `Open door -> Walk here on the next tile` sequence and can fail even though the newly opened route is already clear. The ordinary minimap route click both crosses the doorway and carries movement forward naturally.
+
+**Pattern to follow:**
+
+```java
+if (isDoorEdgeResolved(from, to)) {
+    markStationaryDoorOpened(doorTile);
+    markNearbyDoorFamilyOpened(door, doorTile, action, radius);
+}
+return true; // next pass selects the furthest reachable route tile
+```
+
+**Where this applies:** `Rs2Walker` door interaction handlers, recent-door recovery, and any post-door continuation logic.
+
+**Defensive check:** After an `Open` interaction, the next walk action should target a forward route checkpoint, not the door edge's adjacent destination tile.

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

@@ -67,8 +67,11 @@ protected void append(ILoggingEvent event) {
         if (!Microbot.isLoggedIn()) return;
 
         final String formatted = layout.doLayout(event);
-        // use invoke so we don't stall the calling thread
-        Microbot.getClientThread().invoke(() ->
+        // AppenderBase holds its monitor while append runs. A synchronous client-thread invoke here
+        // deadlocks when the client thread logs at the same time: the background logger owns the
+        // appender monitor and waits for Client, while Client waits for the appender monitor.
+        // Chat mirroring is fire-and-forget, so enqueue it without waiting.
+        Microbot.getClientThread().invokeLater(() ->
                 Microbot.getClient().addChatMessage(ChatMessageType.ENGINE, "", formatted, "", false)
         );
     }

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

@@ -117,6 +117,7 @@ protected void handleRequest(HttpExchange exchange) throws IOException {
 				if (walkFuture.isDone()) {
 					state = walkFuture.get();
 					timedOut = false;
+					completeActiveWalk(walkFuture, "agent-server:walk-completed-" + state.name());
 					break;
 				}
 
@@ -126,7 +127,7 @@ protected void handleRequest(HttpExchange exchange) throws IOException {
 					arrivedByPosition = true;
 					timedOut = false;
 					walkFuture.cancel(true);
-					clearActiveWalk(walkFuture);
+					completeActiveWalk(walkFuture, "agent-server:arrived-by-position");
 					break;
 				}
 
@@ -187,16 +188,23 @@ private static synchronized Future<WalkerState> submitWalk(WorldPoint destinatio
 		}
 		if (activeWalk != null && !activeWalk.isDone()) {
 			activeWalk.cancel(true);
-			Rs2Walker.setTarget(null);
+			Rs2Walker.clearWalkingRoute("agent-server:walk-replaced");
 		}
 		activeWalkTarget = destination;
 		activeWalkReachedDistance = reachedDistance;
 		activeWalk = WALK_EXECUTOR.submit(() -> Rs2Walker.walkWithState(destination, reachedDistance));
 		return activeWalk;
 	}
 
-	private static synchronized void clearActiveWalk(Future<WalkerState> walkFuture) {
+	/**
+	 * Clears both the request bookkeeping and the route rendered by Shortest Path.
+	 *
+	 * <p>The identity check matters when overlapping HTTP requests replace a walk: a late
+	 * completion from the cancelled request must not clear the newer request's route.</p>
+	 */
+	private static synchronized void completeActiveWalk(Future<WalkerState> walkFuture, String reason) {
 		if (activeWalk == walkFuture) {
+			Rs2Walker.clearWalkingRoute(reason);
 			activeWalk = null;
 			activeWalkTarget = null;
 			activeWalkReachedDistance = DEFAULT_REACHED_DISTANCE;