The total out of 600.

Scoring.score/2 walks the guess, finds each emoji’s home in the secret, and folds the per-position points into a total. It returns the total, the max of 600, the percentage computed on read, and a per-position breakdown — the total is a sum, nothing more.

def score(secret, guess) when length(secret) == 6 and length(guess) == 6 do
  breakdown =
    for {emoji, i} <- Enum.with_index(guess) do
      case Enum.find_index(secret, &(&1 == emoji)) do
        nil -> {i, emoji, :miss, 0, status(:miss)}
        j   -> d = distance(i, j); {i, emoji, d, points(d), status(d)}
      end
    end

  total = breakdown |> Enum.map(&elem(&1, 3)) |> Enum.sum()
  %{total: total, max: 600, percentage: round(total / 600 * 100), breakdown: breakdown}
end

The scoring story pins four totals against one secret, and they read straight off this fold: an exact crack is 600 at 100%; positions 0 and 1 swapped are each ADJACENT (80 points), the rest exact — 560 at 93%; the two ends swapped are MAX distance (0 points each) — 400 at 67%; one emoji absent is a clean MISS — 500 at 83%.

The leaderboard is one Valkey sorted set per game, and a player’s score on it is their best linear total. Board.record/3 reads the player’s current best from the cm:<game>:base hash, folds the new score in with max, and writes that best straight to the board ZSET — no read-modify-write beyond the best-of. Move an incoming score below to watch the fold.

def record(game, player, base) do
  old = hget_int(conn, k(game, "base"), player)
  new_base = max(old, base)
  Cmd.hset(k(game, "base"), player, to_string(new_base)) |> Wire.run(conn)   # cm:<game>:base
  Cmd.zadd(k(game, "board")) |> Cmd.score(new_base, player) |> Wire.run(conn) # cm:<game>:board
  new_base
end

There is no ptier, bonus, or tierfirst layer, and the guesses row stores only the linear points — no tier and no percentage column. The board ranks the raw best total, so the score a player sees is the score they earned.

eff = Board.record(game, player, s.total)
# ... classic feedback fans out on the bus and over PubSub ...
if s.total == 600 and started?(game), do: Rooms.close_game(game)

# the authoritative state gate — only an :open game settles on a 600
defp started?(game), do: Map.get(Store.game(game) || %{}, :status) == :open

started?/1 reads the status from the system of record, not the cache, because a Golden Room’s cached status can lag its gather. So a 600 during a Golden Room’s :gathering builds standing without settling an unfilled pool — only an :open game closes on the crack. That close is the seam into settlement.

Next — C4.3 takes the close: the race resolved exactly once, and the three payout strategies the game selects.