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/engineclient/client.go

@@ -196,6 +196,46 @@ func (c *Client) PutOrders(ctx context.Context, baseURL string, payload json.Raw
 	return c.forwardPlayerWrite(ctx, baseURL, pathPlayerOrder, payload, "engine order")
 }
 
+// GetOrder calls `GET /api/v1/order?player=<raceName>&turn=<turn>` and
+// returns the engine response body verbatim. A `204 No Content` body
+// is signalled by `(nil, http.StatusNoContent, nil)` so callers can
+// surface "no stored order" without parsing the empty payload.
+// Other non-`200` statuses come back wrapped in `ErrEngineValidation`
+// (4xx) or `ErrEngineUnreachable` (everything else), matching the
+// existing player-write conventions.
+func (c *Client) GetOrder(ctx context.Context, baseURL, raceName string, turn int) (json.RawMessage, int, error) {
+	if err := validateBaseURL(baseURL); err != nil {
+		return nil, 0, err
+	}
+	if strings.TrimSpace(raceName) == "" {
+		return nil, 0, errors.New("engineclient order get: race name must not be empty")
+	}
+	if turn < 0 {
+		return nil, 0, fmt.Errorf("engineclient order get: turn must not be negative, got %d", turn)
+	}
+	values := url.Values{}
+	values.Set("player", raceName)
+	values.Set("turn", strconv.Itoa(turn))
+	target := baseURL + pathPlayerOrder + "?" + values.Encode()
+	body, status, doErr := c.doRequest(ctx, http.MethodGet, target, nil, c.probeTimeout)
+	if doErr != nil {
+		return nil, 0, fmt.Errorf("%w: engine order get: %w", ErrEngineUnreachable, doErr)
+	}
+	switch status {
+	case http.StatusOK:
+		if len(body) == 0 {
+			return nil, status, fmt.Errorf("%w: engine order get: empty response body", ErrEngineProtocolViolation)
+		}
+		return json.RawMessage(body), status, nil
+	case http.StatusNoContent:
+		return nil, status, nil
+	case http.StatusBadRequest, http.StatusConflict:
+		return json.RawMessage(body), status, fmt.Errorf("%w: engine order get: %s", ErrEngineValidation, summariseEngineError(body, status))
+	default:
+		return nil, status, fmt.Errorf("%w: engine order get: %s", ErrEngineUnreachable, summariseEngineError(body, status))
+	}
+}
+
 // GetReport calls `GET /api/v1/report?player=<raceName>&turn=<turn>`
 // and returns the engine response body verbatim.
 func (c *Client) GetReport(ctx context.Context, baseURL, raceName string, turn int) (json.RawMessage, error) {

backend/internal/engineclient/client_test.go

@@ -195,6 +195,68 @@ func TestClientReportsForwardsQuery(t *testing.T) {
 	}
 }
 
+func TestClientGetOrderForwardsQuery(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != pathPlayerOrder {
+			t.Fatalf("unexpected path: %s", r.URL.Path)
+		}
+		if r.Method != http.MethodGet {
+			t.Fatalf("unexpected method: %s", r.Method)
+		}
+		if r.URL.Query().Get("player") != "alpha" {
+			t.Fatalf("player = %q", r.URL.Query().Get("player"))
+		}
+		if r.URL.Query().Get("turn") != "3" {
+			t.Fatalf("turn = %q", r.URL.Query().Get("turn"))
+		}
+		_, _ = w.Write([]byte(`{"game_id":"abc","updatedAt":99,"cmd":[]}`))
+	}))
+	t.Cleanup(srv.Close)
+
+	cli := newTestClient(t, srv)
+	body, status, err := cli.GetOrder(context.Background(), srv.URL, "alpha", 3)
+	if err != nil {
+		t.Fatalf("GetOrder: %v", err)
+	}
+	if status != http.StatusOK {
+		t.Fatalf("status = %d", status)
+	}
+	if !strings.Contains(string(body), `"updatedAt":99`) {
+		t.Fatalf("body = %s", body)
+	}
+}
+
+func TestClientGetOrderNoContent(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusNoContent)
+	}))
+	t.Cleanup(srv.Close)
+
+	cli := newTestClient(t, srv)
+	body, status, err := cli.GetOrder(context.Background(), srv.URL, "alpha", 3)
+	if err != nil {
+		t.Fatalf("GetOrder: %v", err)
+	}
+	if status != http.StatusNoContent {
+		t.Fatalf("status = %d", status)
+	}
+	if body != nil {
+		t.Fatalf("expected nil body on 204, got %s", body)
+	}
+}
+
+func TestClientGetOrderRejectsBadInput(t *testing.T) {
+	cli := newTestClient(t, httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		t.Fatal("server must not be hit on bad input")
+	})))
+	if _, _, err := cli.GetOrder(context.Background(), "http://example.com", "", 0); err == nil {
+		t.Fatal("expected error on empty race name")
+	}
+	if _, _, err := cli.GetOrder(context.Background(), "http://example.com", "alpha", -1); err == nil {
+		t.Fatal("expected error on negative turn")
+	}
+}
+
 func TestClientHealthzSuccess(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path != pathHealthz {