ui/phase-14: rename planet end-to-end + order read-back

Wires the first end-to-end command through the full pipeline:
inspector rename action → local order draft → user.games.order
submit → optimistic overlay on map / inspector → server hydration
on cache miss via the new user.games.order.get message type.

Backend: GET /api/v1/user/games/{id}/orders forwards to engine
GET /api/v1/order. Gateway parses the engine PUT response into the
extended UserGamesOrderResponse FBS envelope and adds
executeUserGamesOrderGet for the read-back path. Frontend ports
ValidateTypeName to TS, lands the inline rename editor + Submit
button, and exposes a renderedReport context so consumers see the
overlay-applied snapshot.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

backend/internal/server/contract_test.go

@@ -50,6 +50,14 @@ var pathParamStubs = map[string]string{
 	"turn": "42",
 }
 
+// queryParamStubs lists the deterministic substitutions used to fill
+// query-string parameters declared in `openapi.yaml`. Every required
+// query parameter must have an entry here; optional ones can stay
+// blank (the contract test omits them when no stub is registered).
+var queryParamStubs = map[string]string{
+	"turn": "42",
+}
+
 // requestBodyStubs lists the JSON request bodies the contract test sends for
 // each operationId. Operations missing from the map default to an empty
 // object `{}`, which is a valid placeholder thanks to `additionalProperties:
@@ -323,6 +331,9 @@ func buildRequest(t *testing.T, c contractOperation) *http.Request {
 	t.Helper()
 
 	target := substitutePathParams(t, c.path)
+	if query := buildQuery(t, c); query != "" {
+		target += "?" + query
+	}
 	url := "http://backend.internal" + target
 
 	body := bodyFor(t, c)
@@ -376,6 +387,31 @@ func bodyFor(t *testing.T, c contractOperation) requestBody {
 	}
 }
 
+func buildQuery(t *testing.T, c contractOperation) string {
+	t.Helper()
+	if c.op == nil {
+		return ""
+	}
+	values := make([]string, 0, len(c.op.Parameters))
+	for _, p := range c.op.Parameters {
+		if p == nil || p.Value == nil {
+			continue
+		}
+		if p.Value.In != "query" {
+			continue
+		}
+		stub, ok := queryParamStubs[p.Value.Name]
+		if !ok {
+			if p.Value.Required {
+				t.Fatalf("operation %q requires query parameter %q with no stub registered", c.operationID, p.Value.Name)
+			}
+			continue
+		}
+		values = append(values, p.Value.Name+"="+stub)
+	}
+	return strings.Join(values, "&")
+}
+
 func substitutePathParams(t *testing.T, templated string) string {
 	t.Helper()
 

backend/internal/server/handlers_user_games.go

@@ -136,6 +136,64 @@ func (h *UserGamesHandlers) Orders() gin.HandlerFunc {
 	}
 }
 
+// GetOrders handles GET /api/v1/user/games/{game_id}/orders?turn=N.
+// Forwards to the engine's `GET /api/v1/order` with the player rebound
+// from the runtime mapping. The query parameter `turn` is required
+// and must be a non-negative integer; the engine itself enforces the
+// same rule, but rejecting up-front saves a network hop.
+//
+// On `204 No Content` the handler answers `204` so the gateway can
+// translate the FBS envelope to `found = false`. On `200` the
+// engine's body is forwarded verbatim — the gateway re-encodes the
+// JSON `UserGamesOrder` shape into FlatBuffers.
+func (h *UserGamesHandlers) GetOrders() gin.HandlerFunc {
+	if h == nil || h.runtime == nil || h.engine == nil {
+		return handlers.NotImplemented("userGamesGetOrders")
+	}
+	return func(c *gin.Context) {
+		gameID, ok := parseGameIDParam(c)
+		if !ok {
+			return
+		}
+		turnRaw := c.Query("turn")
+		if turnRaw == "" {
+			httperr.Abort(c, http.StatusBadRequest, httperr.CodeInvalidRequest, "turn is required")
+			return
+		}
+		turn, err := strconv.Atoi(turnRaw)
+		if err != nil || turn < 0 {
+			httperr.Abort(c, http.StatusBadRequest, httperr.CodeInvalidRequest, "turn must be a non-negative integer")
+			return
+		}
+		userID, ok := userid.FromContext(c.Request.Context())
+		if !ok {
+			httperr.Abort(c, http.StatusBadRequest, httperr.CodeInvalidRequest, "user id missing")
+			return
+		}
+		ctx := c.Request.Context()
+		mapping, err := h.runtime.ResolvePlayerMapping(ctx, gameID, userID)
+		if err != nil {
+			respondGameProxyError(c, h.logger, "user games get orders", ctx, err)
+			return
+		}
+		endpoint, err := h.runtime.EngineEndpoint(ctx, gameID)
+		if err != nil {
+			respondGameProxyError(c, h.logger, "user games get orders", ctx, err)
+			return
+		}
+		body, status, err := h.engine.GetOrder(ctx, endpoint, mapping.RaceName, turn)
+		if err != nil {
+			respondEngineProxyError(c, h.logger, "user games get orders", ctx, body, err)
+			return
+		}
+		if status == http.StatusNoContent {
+			c.Status(http.StatusNoContent)
+			return
+		}
+		c.Data(http.StatusOK, "application/json", body)
+	}
+}
+
 // Report handles GET /api/v1/user/games/{game_id}/reports/{turn}.
 func (h *UserGamesHandlers) Report() gin.HandlerFunc {
 	if h == nil || h.runtime == nil || h.engine == nil {

backend/internal/server/router.go

@@ -261,6 +261,7 @@ func registerUserRoutes(router *gin.Engine, instruments *metrics.Instruments, de
 	userGames := group.Group("/games")
 	userGames.POST("/:game_id/commands", deps.UserGames.Commands())
 	userGames.POST("/:game_id/orders", deps.UserGames.Orders())
+	userGames.GET("/:game_id/orders", deps.UserGames.GetOrders())
 	userGames.GET("/:game_id/reports/:turn", deps.UserGames.Report())
 
 	userSessions := group.Group("/sessions")