chore(cleanup): purge /command residuals — fakeEngine, canon golden, openapi

Follow-up tidy after the cross-service /command removal (#73):

- Rename the router test double dummyExecutor -> fakeEngine (and the
  newExecutor / setupRouterExecutor helpers -> newFakeEngine /
  setupRouterEngine): it implements handler.Engine now, "executor" was a
  leftover of the removed adapter. Test-only.

- Regenerate the ui/core canon signing golden onto user.games.order
  (request_user_games_command.json -> request_user_games_order.json, fresh
  canonical bytes + Ed25519 signature) and drop the last
  user.games.command references from the Go/TS tests and docs.

- Align game openapi: CommandRequest.cmd no longer carries minItems: 1. It
  is now used only by PUT /api/v1/order, which accepts an empty batch
  (clearing the player's stored order, equivalent to removing every
  command); the contract test freezes the empty-allowed shape.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

game/internal/router/battle_test.go

@@ -29,8 +29,8 @@ func TestGetBattleValidation(t *testing.T) {
 		{"Invalid uuid", "0", invalidId, http.StatusBadRequest},
 	} {
 		t.Run(tc.description, func(t *testing.T) {
-			e := &dummyExecutor{}
-			r := setupRouterExecutor(e)
+			e := &fakeEngine{}
+			r := setupRouterEngine(e)
 
 			w := httptest.NewRecorder()
 			path := fmt.Sprintf("/api/v1/battle/%s/%s", tc.turn, tc.battleID)
@@ -81,11 +81,11 @@ func TestGetBattleFound(t *testing.T) {
 			{Attacker: 0, AttackerShipClass: 10, Defender: 1, DefenderShipClass: 20, Destroyed: true},
 		},
 	}
-	e := &dummyExecutor{
+	e := &fakeEngine{
 		FetchBattleResult: stored,
 		FetchBattleOK:     true,
 	}
-	r := setupRouterExecutor(e)
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	path := fmt.Sprintf("/api/v1/battle/%d/%s", 7, id.String())
@@ -111,11 +111,11 @@ func TestGetBattleFound(t *testing.T) {
 
 func TestGetBattleTurnZero(t *testing.T) {
 	id := uuid.New()
-	e := &dummyExecutor{
+	e := &fakeEngine{
 		FetchBattleResult: &report.BattleReport{ID: id},
 		FetchBattleOK:     true,
 	}
-	r := setupRouterExecutor(e)
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/api/v1/battle/0/%s", id.String()), nil)
@@ -128,8 +128,8 @@ func TestGetBattleTurnZero(t *testing.T) {
 
 func TestGetBattleNotFound(t *testing.T) {
 	id := uuid.New()
-	e := &dummyExecutor{FetchBattleOK: false}
-	r := setupRouterExecutor(e)
+	e := &fakeEngine{FetchBattleOK: false}
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/api/v1/battle/3/%s", id.String()), nil)
@@ -141,8 +141,8 @@ func TestGetBattleNotFound(t *testing.T) {
 }
 
 func TestGetBattleEngineError(t *testing.T) {
-	e := &dummyExecutor{FetchBattleErr: errors.New("engine boom")}
-	r := setupRouterExecutor(e)
+	e := &fakeEngine{FetchBattleErr: errors.New("engine boom")}
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("/api/v1/battle/3/%s", uuid.NewString()), nil)

game/internal/router/order_test.go

@@ -68,8 +68,8 @@ func TestOrderRaceQuit(t *testing.T) {
 	payload = &rest.Command{
 		Actor: commandDefaultActor,
 	}
-	exec := &dummyExecutor{}
-	emptyRouter := setupRouterExecutor(exec)
+	exec := &fakeEngine{}
+	emptyRouter := setupRouterEngine(exec)
 
 	w = httptest.NewRecorder()
 	req, _ = http.NewRequest(apiCommandMethod, apiOrderPath, asBody(payload))
@@ -927,8 +927,8 @@ func TestOrderPlanetRouteRemove(t *testing.T) {
 }
 
 func TestMultipleCommandOrder(t *testing.T) {
-	e := newExecutor()
-	r := setupRouterExecutor(e)
+	e := newFakeEngine()
+	r := setupRouterEngine(e)
 
 	payload := &rest.Command{
 		Actor: commandDefaultActor,
@@ -951,11 +951,11 @@ func TestMultipleCommandOrder(t *testing.T) {
 
 	assert.Equal(t, commandNoErrorsStatus, w.Code, w.Body)
 
-	assert.Equal(t, 2, e.(*dummyExecutor).CommandsExecuted)
+	assert.Equal(t, 2, e.(*fakeEngine).CommandsExecuted)
 }
 
 func TestPutOrderResponseBody(t *testing.T) {
-	e := &dummyExecutor{
+	e := &fakeEngine{
 		ValidateOrderResult: &order.UserGamesOrder{
 			GameID:    uuid.New(),
 			UpdatedAt: 1700,
@@ -967,7 +967,7 @@ func TestPutOrderResponseBody(t *testing.T) {
 			},
 		},
 	}
-	r := setupRouterExecutor(e)
+	r := setupRouterEngine(e)
 
 	payload := &rest.Command{
 		Actor: commandDefaultActor,
@@ -997,8 +997,8 @@ func TestPutOrderResponseBody(t *testing.T) {
 }
 
 func TestPutOrderEngineError(t *testing.T) {
-	e := &dummyExecutor{ValidateOrderErr: errors.New("engine boom")}
-	r := setupRouterExecutor(e)
+	e := &fakeEngine{ValidateOrderErr: errors.New("engine boom")}
+	r := setupRouterEngine(e)
 
 	payload := &rest.Command{
 		Actor: commandDefaultActor,
@@ -1054,8 +1054,8 @@ func TestPutOrderPerCommandRejection(t *testing.T) {
 			},
 		},
 	}
-	executor := &dummyExecutor{ValidateOrderResult: result}
-	r := setupRouterExecutor(executor)
+	executor := &fakeEngine{ValidateOrderResult: result}
+	r := setupRouterEngine(executor)
 
 	payload := &rest.Command{
 		Actor: commandDefaultActor,
@@ -1112,8 +1112,8 @@ func TestPutOrderPerCommandRejection(t *testing.T) {
 // *GenericError on the input shelf, which must map to HTTP 400 with
 // the `{"generic_error","code"}` envelope rather than 500.
 func TestPutOrderStructuralRejection(t *testing.T) {
-	executor := &dummyExecutor{ValidateOrderErr: e.NewQuitCommandFollowedByCommandError()}
-	r := setupRouterExecutor(executor)
+	executor := &fakeEngine{ValidateOrderErr: e.NewQuitCommandFollowedByCommandError()}
+	r := setupRouterEngine(executor)
 
 	payload := &rest.Command{
 		Actor: commandDefaultActor,
@@ -1152,8 +1152,8 @@ func TestGetOrderQueryValidation(t *testing.T) {
 		{"Non-numeric turn", "?player=Race_01&turn=abc", http.StatusBadRequest},
 	} {
 		t.Run(tc.description, func(t *testing.T) {
-			e := &dummyExecutor{}
-			r := setupRouterExecutor(e)
+			e := &fakeEngine{}
+			r := setupRouterEngine(e)
 
 			w := httptest.NewRecorder()
 			req, _ := http.NewRequest(http.MethodGet, apiOrderPath+tc.query, nil)
@@ -1176,11 +1176,11 @@ func TestGetOrderFound(t *testing.T) {
 			},
 		},
 	}
-	e := &dummyExecutor{
+	e := &fakeEngine{
 		FetchOrderResult: stored,
 		FetchOrderOK:     true,
 	}
-	r := setupRouterExecutor(e)
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, apiOrderPath+"?player=Race_01&turn=3", nil)
@@ -1202,11 +1202,11 @@ func TestGetOrderFound(t *testing.T) {
 }
 
 func TestGetOrderTurnDefaultsToZero(t *testing.T) {
-	e := &dummyExecutor{
+	e := &fakeEngine{
 		FetchOrderResult: &order.UserGamesOrder{GameID: uuid.New(), UpdatedAt: 1, Commands: []order.DecodableCommand{}},
 		FetchOrderOK:     true,
 	}
-	r := setupRouterExecutor(e)
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, apiOrderPath+"?player=Race_01", nil)
@@ -1217,8 +1217,8 @@ func TestGetOrderTurnDefaultsToZero(t *testing.T) {
 }
 
 func TestGetOrderNotFound(t *testing.T) {
-	e := &dummyExecutor{FetchOrderOK: false}
-	r := setupRouterExecutor(e)
+	e := &fakeEngine{FetchOrderOK: false}
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, apiOrderPath+"?player=Race_01&turn=2", nil)
@@ -1231,8 +1231,8 @@ func TestGetOrderNotFound(t *testing.T) {
 }
 
 func TestGetOrderEngineError(t *testing.T) {
-	e := &dummyExecutor{FetchOrderErr: errors.New("engine boom")}
-	r := setupRouterExecutor(e)
+	e := &fakeEngine{FetchOrderErr: errors.New("engine boom")}
+	r := setupRouterEngine(e)
 
 	w := httptest.NewRecorder()
 	req, _ := http.NewRequest(http.MethodGet, apiOrderPath+"?player=Race_01&turn=0", nil)

game/internal/router/router_helper_test.go

@@ -31,7 +31,7 @@ func id() string {
 	return uuid.New().String()
 }
 
-type dummyExecutor struct {
+type fakeEngine struct {
 	CommandsExecuted int
 
 	// ValidateOrderResult, when non-nil, is returned from ValidateOrder.
@@ -55,7 +55,7 @@ type dummyExecutor struct {
 	FetchBattleErr    error
 }
 
-func (e *dummyExecutor) ValidateOrder(actor string, cmd ...order.DecodableCommand) (*order.UserGamesOrder, error) {
+func (e *fakeEngine) ValidateOrder(actor string, cmd ...order.DecodableCommand) (*order.UserGamesOrder, error) {
 	e.CommandsExecuted = len(cmd)
 	if e.ValidateOrderErr != nil {
 		return nil, e.ValidateOrderErr
@@ -70,48 +70,48 @@ func (e *dummyExecutor) ValidateOrder(actor string, cmd ...order.DecodableComman
 	}, nil
 }
 
-func (e *dummyExecutor) FetchOrder(actor string, turn uint) (*order.UserGamesOrder, bool, error) {
+func (e *fakeEngine) FetchOrder(actor string, turn uint) (*order.UserGamesOrder, bool, error) {
 	e.FetchOrderActor = actor
 	e.FetchOrderTurn = turn
 	return e.FetchOrderResult, e.FetchOrderOK, e.FetchOrderErr
 }
 
-func (e *dummyExecutor) FetchBattle(turn uint, ID uuid.UUID) (*report.BattleReport, bool, error) {
+func (e *fakeEngine) FetchBattle(turn uint, ID uuid.UUID) (*report.BattleReport, bool, error) {
 	e.FetchBattleTurn = turn
 	e.FetchBattleID = ID
 	return e.FetchBattleResult, e.FetchBattleOK, e.FetchBattleErr
 }
 
-func (e *dummyExecutor) GenerateGame(gameID uuid.UUID, races []string) (game.State, error) {
+func (e *fakeEngine) GenerateGame(gameID uuid.UUID, races []string) (game.State, error) {
 	return game.State{ID: gameID}, nil
 }
 
-func (e *dummyExecutor) GenerateTurn() (game.State, error) {
+func (e *fakeEngine) GenerateTurn() (game.State, error) {
 	return game.State{}, nil
 }
 
-func (e *dummyExecutor) BanishRace(raceName string) error {
+func (e *fakeEngine) BanishRace(raceName string) error {
 	return nil
 }
 
-func (e *dummyExecutor) GameState() (game.State, error) {
+func (e *fakeEngine) GameState() (game.State, error) {
 	return game.State{}, nil
 }
 
-func (e *dummyExecutor) LoadReport(actor string, turn uint) (*report.Report, error) {
+func (e *fakeEngine) LoadReport(actor string, turn uint) (*report.Report, error) {
 	return &report.Report{}, nil
 }
 
 func setupRouter() *gin.Engine {
-	return setupRouterExecutor(newExecutor())
+	return setupRouterEngine(newFakeEngine())
 }
 
-func setupRouterExecutor(e handler.Engine) *gin.Engine {
+func setupRouterEngine(e handler.Engine) *gin.Engine {
 	return router.SetupRouter(e)
 }
 
-func newExecutor() handler.Engine {
-	return &dummyExecutor{}
+func newFakeEngine() handler.Engine {
+	return &fakeEngine{}
 }
 
 // newService builds a real controller.Service backed by a storage directory,

game/openapi.yaml

@@ -436,21 +436,24 @@ components:
     CommandRequest:
       type: object
       description: |
-        Batch command payload. `actor` identifies the race submitting the commands.
-        Each element of `cmd` is a polymorphic command object discriminated by the
-        `@type` field. At least one command is required.
+        Order payload for `PUT /api/v1/order`. `actor` identifies the race
+        submitting the order. Each element of `cmd` is a polymorphic command
+        object discriminated by the `@type` field. An empty `cmd` array is
+        valid: it clears the player's stored order for the turn (equivalent to
+        removing every command).
       required:
         - actor
         - cmd
       properties:
         actor:
           type: string
-          description: Race name of the actor submitting the commands. Must be non-blank.
+          description: Race name of the actor submitting the order. Must be non-blank.
           minLength: 1
         cmd:
           type: array
-          description: One or more commands to execute in order.
-          minItems: 1
+          description: >-
+            The player's commands, applied in submission order at turn
+            generation. May be empty to clear the stored order.
           items:
             $ref: "#/components/schemas/Command"
     UserGamesOrder:

game/openapi_contract_test.go

@@ -275,7 +275,8 @@ func TestGameOpenAPISpecFreezesCommandRequest(t *testing.T) {
 
 	cmdSchema := schema.Value.Properties["cmd"]
 	require.NotNil(t, cmdSchema, "CommandRequest.cmd schema must exist")
-	require.Equal(t, uint64(1), cmdSchema.Value.MinItems, "CommandRequest.cmd minItems must be 1")
+	require.Zero(t, cmdSchema.Value.MinItems,
+		"CommandRequest.cmd must allow an empty batch — an empty order clears the player's stored order")
 }
 
 func TestGameOpenAPISpecFreezesGetBattleOperation(t *testing.T) {