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>

gateway/internal/backendclient/games_commands.go

@@ -51,6 +51,12 @@ func (c *RESTClient) ExecuteGameCommand(ctx context.Context, command downstream.
 			return downstream.UnaryResult{}, fmt.Errorf("backendclient: execute game command %q: %w", command.MessageType, err)
 		}
 		return c.executeUserGamesOrder(ctx, command.UserID, req)
+	case ordermodel.MessageTypeUserGamesOrderGet:
+		req, err := transcoder.PayloadToUserGamesOrderGet(command.PayloadBytes)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("backendclient: execute game command %q: %w", command.MessageType, err)
+		}
+		return c.executeUserGamesOrderGet(ctx, command.UserID, req)
 	case reportmodel.MessageTypeUserGamesReport:
 		req, err := transcoder.PayloadToGameReportRequest(command.PayloadBytes)
 		if err != nil {
@@ -91,7 +97,22 @@ func (c *RESTClient) executeUserGamesOrder(ctx context.Context, userID string, r
 	if err != nil {
 		return downstream.UnaryResult{}, fmt.Errorf("execute user.games.order: %w", err)
 	}
-	return projectUserGamesAckResponse(status, respBody, transcoder.EmptyUserGamesOrderResponsePayload)
+	return projectUserGamesOrderResponse(status, respBody)
+}
+
+func (c *RESTClient) executeUserGamesOrderGet(ctx context.Context, userID string, req *ordermodel.UserGamesOrderGet) (downstream.UnaryResult, error) {
+	if req.GameID == uuid.Nil {
+		return downstream.UnaryResult{}, errors.New("execute user.games.order.get: game_id must not be empty")
+	}
+	if req.Turn < 0 {
+		return downstream.UnaryResult{}, fmt.Errorf("execute user.games.order.get: turn must be non-negative, got %d", req.Turn)
+	}
+	target := fmt.Sprintf("%s/api/v1/user/games/%s/orders?turn=%d", c.baseURL, url.PathEscape(req.GameID.String()), req.Turn)
+	respBody, status, err := c.do(ctx, http.MethodGet, target, userID, nil)
+	if err != nil {
+		return downstream.UnaryResult{}, fmt.Errorf("execute user.games.order.get: %w", err)
+	}
+	return projectUserGamesOrderGetResponse(status, respBody)
 }
 
 func (c *RESTClient) executeUserGamesReport(ctx context.Context, userID string, req *reportmodel.GameReportRequest) (downstream.UnaryResult, error) {
@@ -122,10 +143,10 @@ func buildEngineCommandBody(commands []ordermodel.DecodableCommand) (gamerest.Co
 	return gamerest.Command{Actor: "", Commands: raw}, nil
 }
 
-// projectUserGamesAckResponse turns a backend response for command /
-// order routes into a UnaryResult. Engine returns 204 on success, so
-// any 2xx status is treated as ok and answered with the empty typed
-// FB envelope produced by ackBuilder.
+// projectUserGamesAckResponse turns a backend response for the
+// `user.games.command` route into a UnaryResult. Engine returns 204
+// on success, so any 2xx status is treated as ok and answered with
+// the empty typed FB envelope produced by ackBuilder.
 func projectUserGamesAckResponse(statusCode int, payload []byte, ackBuilder func() []byte) (downstream.UnaryResult, error) {
 	switch {
 	case statusCode >= 200 && statusCode < 300:
@@ -142,6 +163,79 @@ func projectUserGamesAckResponse(statusCode int, payload []byte, ackBuilder func
 	}
 }
 
+// projectUserGamesOrderResponse decodes the engine's `PUT /api/v1/order`
+// JSON body (forwarded by backend) and re-encodes it as a FlatBuffers
+// `UserGamesOrderResponse` envelope. The body carries per-command
+// `cmdApplied` / `cmdErrorCode` plus the engine-assigned `updatedAt`,
+// all of which round-trip into FB unchanged. An empty body falls back
+// to a typed empty envelope so the gateway can ack a successful but
+// unstructured 2xx without surfacing an error.
+func projectUserGamesOrderResponse(statusCode int, payload []byte) (downstream.UnaryResult, error) {
+	switch {
+	case statusCode >= 200 && statusCode < 300:
+		var parsed *ordermodel.UserGamesOrder
+		if len(payload) > 0 {
+			decoded, jsonErr := transcoder.JSONToUserGamesOrder(payload)
+			if jsonErr != nil {
+				return downstream.UnaryResult{}, fmt.Errorf("decode engine order response: %w", jsonErr)
+			}
+			parsed = decoded
+		}
+		encoded, err := transcoder.UserGamesOrderResponseToPayload(parsed)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("encode order response payload: %w", err)
+		}
+		return downstream.UnaryResult{
+			ResultCode:   userCommandResultCodeOK,
+			PayloadBytes: encoded,
+		}, nil
+	case statusCode == http.StatusServiceUnavailable:
+		return downstream.UnaryResult{}, downstream.ErrDownstreamUnavailable
+	case statusCode >= 400 && statusCode <= 599:
+		return projectUserBackendError(statusCode, payload)
+	default:
+		return downstream.UnaryResult{}, fmt.Errorf("unexpected HTTP status %d", statusCode)
+	}
+}
+
+// projectUserGamesOrderGetResponse decodes the engine's
+// `GET /api/v1/order` JSON body and re-encodes it as a FlatBuffers
+// `UserGamesOrderGetResponse` envelope. A `204 No Content` from the
+// engine surfaces as `found = false` with no embedded order; `200`
+// surfaces as `found = true` with the decoded order.
+func projectUserGamesOrderGetResponse(statusCode int, payload []byte) (downstream.UnaryResult, error) {
+	switch {
+	case statusCode == http.StatusNoContent:
+		encoded, err := transcoder.UserGamesOrderGetResponseToPayload(nil, false)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("encode order get response payload: %w", err)
+		}
+		return downstream.UnaryResult{
+			ResultCode:   userCommandResultCodeOK,
+			PayloadBytes: encoded,
+		}, nil
+	case statusCode >= 200 && statusCode < 300:
+		decoded, err := transcoder.JSONToUserGamesOrder(payload)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("decode engine order get response: %w", err)
+		}
+		encoded, err := transcoder.UserGamesOrderGetResponseToPayload(decoded, true)
+		if err != nil {
+			return downstream.UnaryResult{}, fmt.Errorf("encode order get response payload: %w", err)
+		}
+		return downstream.UnaryResult{
+			ResultCode:   userCommandResultCodeOK,
+			PayloadBytes: encoded,
+		}, nil
+	case statusCode == http.StatusServiceUnavailable:
+		return downstream.UnaryResult{}, downstream.ErrDownstreamUnavailable
+	case statusCode >= 400 && statusCode <= 599:
+		return projectUserBackendError(statusCode, payload)
+	default:
+		return downstream.UnaryResult{}, fmt.Errorf("unexpected HTTP status %d", statusCode)
+	}
+}
+
 // projectUserGamesReportResponse decodes the engine's Report JSON
 // payload (forwarded verbatim by backend) and re-encodes it as a
 // FlatBuffers Report for the signed-gRPC client.