ui/phase-14: auto-sync order draft + always GET on boot + header headline

Replaces the manual Submit button with an auto-sync pipeline driven
by `OrderDraftStore`: every successful add / remove / move
coalesces a `submitOrder` call so the engine always mirrors the
local draft. Removing the last command sends an empty cmd[] PUT —
the engine, repo, and rest model now accept that as a valid
"player cleared their draft" state.

`hydrateFromServer` is now invoked unconditionally on game boot so
a fresh device picks up the player's stored order, and the local
cache is overwritten by the server's view (server is the source of
truth).

Header replaces the static "race ?" + turn counter with a single
headline string `<race> @ <game>, turn <n>`, sourced from the
engine's Report.race + the lobby's GameSummary.gameName + the live
turn number, with a `?` fallback while any piece is loading.

Tests:
- engine: empty PUT round-trips, repo round-trips empty Commands
- order-draft: auto-sync sends full draft on every mutation,
  rejected response surfaces error sync status, rapid mutations
  coalesce, server hydration overwrites cache
- order-tab: per-row status flips through the auto-sync lifecycle,
  remove → empty cmd[] PUT, rejected → retry button
- inspector overlay: applied + valid + submitting all participate
  in the optimistic projection
- header: live race / game / turn rendering with fall-back

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

game/internal/repo/game.go

@@ -12,7 +12,6 @@ package repo
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
 
 	"galaxy/model/order"
@@ -234,15 +233,16 @@ func loadOrder(s Storage, t uint, id uuid.UUID) (*order.UserGamesOrder, bool, er
 	if err := s.ReadSafe(path, stored); err != nil {
 		return nil, false, NewStorageError(err)
 	}
+	// An empty stored batch is a valid state — the player either
+	// cleared their draft or never added a command yet. We round-
+	// trip it as `(*UserGamesOrder, true, nil)` with an empty
+	// `Commands` slice so callers can distinguish "no order yet"
+	// (ok=false) from "order exists but is empty" (ok=true).
 	result := &order.UserGamesOrder{
 		GameID:    stored.GameID,
 		UpdatedAt: stored.UpdatedAt,
 		Commands:  make([]order.DecodableCommand, len(stored.Commands)),
 	}
-	if len(stored.Commands) == 0 {
-		return nil, false, errors.New("no commands were stored")
-	}
-
 	for i := range stored.Commands {
 		command, err := ParseOrder(stored.Commands[i], nil)
 		if err != nil {

game/internal/repo/repo_test.go

@@ -104,6 +104,50 @@ func LoadOrderTest(t *testing.T, s repo.Storage, root string, turn uint, id uuid
 	CommandResultTest(t, o)
 }
 
+func TestSaveOrderEmptyRoundTrip(t *testing.T) {
+	// An empty order is a legal player intent (the user removed
+	// every command from the draft). The repo round-trips it as an
+	// `(*UserGamesOrder, true, nil)` triple with `Commands` empty
+	// so the front-end can distinguish "no order yet" (ok=false)
+	// from "order exists but is empty" (ok=true).
+	root := t.ArtifactDir()
+	s, err := fs.NewFileStorage(root)
+	assert.NoError(t, err)
+	id := uuid.New()
+	gameID := uuid.New()
+	now := time.Now().UTC().UnixMilli()
+	o := &order.UserGamesOrder{
+		GameID:    gameID,
+		UpdatedAt: now,
+	}
+	var turn uint = 3
+
+	assert.NoError(t, repo.SaveOrder_T(s, turn, id, o))
+	assert.FileExists(t, filepath.Join(root, repo.OrderDir(turn, id)))
+
+	loaded, ok, err := repo.LoadOrder_T(s, turn, id)
+	assert.NoError(t, err)
+	assert.True(t, ok, "empty order must surface as ok=true so callers can tell it apart from a missing one")
+	assert.NotNil(t, loaded)
+	assert.Equal(t, gameID, loaded.GameID)
+	assert.Equal(t, now, loaded.UpdatedAt)
+	assert.Empty(t, loaded.Commands)
+}
+
+func TestLoadOrderMissing(t *testing.T) {
+	// A turn that has never had a PUT must come back as
+	// `(nil, false, nil)` — the engine's "no stored order" path.
+	root := t.ArtifactDir()
+	s, err := fs.NewFileStorage(root)
+	assert.NoError(t, err)
+	id := uuid.New()
+
+	loaded, ok, err := repo.LoadOrder_T(s, 7, id)
+	assert.NoError(t, err)
+	assert.False(t, ok)
+	assert.Nil(t, loaded)
+}
+
 func CommandResultTest(t *testing.T, o *order.UserGamesOrder) {
 	assert.NotEmpty(t, o.Commands)
 	for i := range o.Commands {