Add cross-platform prebuilt release workflow

Derive main-quest season routes at projection time
Pair gacha costume bonuses via curated lookup table
2026-07-02 05:43:41 +03:00 · 2026-05-22 23:12:08 +03:00 · 2026-05-22 17:24:30 +03:00 · 2026-05-21 17:49:19 +03:00 · 2026-05-21 14:15:11 +03:00
32 changed files with 1759 additions and 347 deletions
@@ -0,0 +1,117 @@
 name: Build and Publish Release Binaries
 on:
  push:
    tags:
      - 'v*'
  workflow_dispatch:
 permissions:
  contents: write
 jobs:
  build:
    name: Build ${{ matrix.goos }}/${{ matrix.goarch }}
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false
      matrix:
        include:
          - { goos: linux,   goarch: amd64, archive: tar.gz }
          - { goos: linux,   goarch: arm64, archive: tar.gz }
          - { goos: darwin,  goarch: amd64, archive: tar.gz }
          - { goos: darwin,  goarch: arm64, archive: tar.gz }
          - { goos: windows, goarch: amd64, archive: zip    }
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.25'
          cache-dependency-path: server/go.sum
      - name: Install protoc
        run: sudo apt-get update && sudo apt-get install -y protobuf-compiler
      - name: Install protoc-gen-go plugins
        run: |
          go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
          go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
          echo "$(go env GOPATH)/bin" >> "$GITHUB_PATH"
      - name: Generate proto stubs
        working-directory: server
        run: make proto
      - name: Cross-compile binaries
        working-directory: server
        env:
          GOOS: ${{ matrix.goos }}
          GOARCH: ${{ matrix.goarch }}
          CGO_ENABLED: '0'
        run: |
          set -euo pipefail
          stage="staging"
          mkdir -p "$stage/bin"
          ext=""
          if [ "$GOOS" = "windows" ]; then ext=".exe"; fi
          build() {
            local name="$1" dest="$2"
            go build -trimpath -ldflags="-s -w" -o "$dest/${name}${ext}" "./cmd/${name}"
          }
          # Wizard sits at the root so end-users see it immediately.
          build wizard         "$stage"
          # Sub-services and admin tools go in bin/ to match the runtime layout.
          for name in dev lunar-tear octo-cdn auth-server import-snapshot claim-account register-account wizard-restore; do
            build "$name" "$stage/bin"
          done
      - name: Stage docs
        working-directory: server
        run: |
          cp ../README.md staging/README.md
          cp ../LICENSE staging/LICENSE
      - name: Archive
        working-directory: server
        run: |
          set -euo pipefail
          name="lunar-tear-server-${{ github.ref_name }}-${{ matrix.goos }}-${{ matrix.goarch }}"
          mv staging "$name"
          if [ "${{ matrix.archive }}" = "zip" ]; then
            zip -r "${name}.zip" "$name"
          else
            tar -czf "${name}.tar.gz" "$name"
          fi
          ls -lh "${name}".*
      - uses: actions/upload-artifact@v4
        with:
          name: lunar-tear-server-${{ matrix.goos }}-${{ matrix.goarch }}
          path: server/lunar-tear-server-*.${{ matrix.archive }}
          if-no-files-found: error
  release:
    name: Attach archives to GitHub Release
    needs: build
    if: startsWith(github.ref, 'refs/tags/v')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/download-artifact@v4
        with:
          path: artifacts
          merge-multiple: true
      - name: List downloaded artifacts
        run: ls -lh artifacts/
      - uses: softprops/action-gh-release@v2
        with:
          files: artifacts/*
          generate_release_notes: true
          draft: true
@@ -5,7 +5,14 @@ Discord server: https://discord.gg/MZAf5aVkJG
 ## How To Launch The Server
-### Prerequisites
+### Download & Run (no setup)
 Prebuilt binaries are published for Linux, macOS, and Windows on the [Releases page](https://github.com/Walter-Sparrow/lunar-tear/releases).
 1. Download the archive for your OS/arch (`lunar-tear-server-<version>-<os>-<arch>.{tar.gz,zip}`).
 2. Run `./wizard` (macOS/Linux) or double-click `wizard.exe` (Windows).
 ### Prerequisites (build from source)
 - Go 1.25+
 - [goose](https://github.com/pressly/goose) migration tool
@@ -40,12 +47,12 @@ By default the wizard uses ports 8003 (gRPC), 8080 (CDN), and 3000 (auth). Overr
 go run ./cmd/wizard --grpc-port 9003 --cdn-port 9080
 ```
-| Flag             | Default | Description                        |
+| Flag             | Default | Description                                                                                                              |
-| ---------------- | ------- | ---------------------------------- |
+| ---------------- | ------- | ------------------------------------------------------------------------------------------------------------------------ |
-| `--prefer-saved` | `false` | Reuse saved config without prompting |
+| `--prefer-saved` | `false` | Reuse saved config without prompting                                                                                     |
-| `--grpc-port`    | `8003`  | gRPC server port                   |
+| `--grpc-port`    | `8003`  | gRPC server port                                                                                                         |
-| `--cdn-port`     | `8080`  | CDN server port                    |
+| `--cdn-port`     | `8080`  | CDN server port                                                                                                          |
-| `--auth-port`    | `3000`  | Auth server port                   |
+| `--auth-port`    | `3000`  | Auth server port                                                                                                         |
 | `--admin-port`   | `0`     | Admin webhook port (`0` = disabled). Bound on `127.0.0.1`; only takes effect when `LUNAR_ADMIN_TOKEN` is set in the env. |
 Custom ports are saved to `.wizard.json` alongside your other settings. On the next run the saved ports are reused automatically — no need to pass the flags again. If you later pass different port flags, the wizard warns you that the ports changed and asks for confirmation before continuing.
@@ -105,9 +112,9 @@ go run ./cmd/import-snapshot \
 | Flag         | Default      | Description                                   |
 | ------------ | ------------ | --------------------------------------------- |
-| `--snapshot` | *(required)* | Path to JSON snapshot file                     |
+| `--snapshot` | _(required)_ | Path to JSON snapshot file                    |
-| `--uuid`     | *(required)* | UUID to assign (must match the client's UUID)  |
+| `--uuid`     | _(required)_ | UUID to assign (must match the client's UUID) |
-| `--db`       | `db/game.db` | SQLite database path                           |
+| `--db`       | `db/game.db` | SQLite database path                          |
 ### Run
@@ -174,40 +181,40 @@ Or via `make`:
 make dev ARGS="--grpc.listen 0.0.0.0:9000 --grpc.public-addr 10.0.2.2:9000"
 ```
-| Flag                  | Default            | Description                              |
+| Flag                 | Default                 | Description                                                                                                          |
-| --------------------- | ------------------ | ---------------------------------------- |
+| -------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| `--auth.listen`       | `0.0.0.0:3000`     | auth-server listen address               |
+| `--auth.listen`      | `0.0.0.0:3000`          | auth-server listen address                                                                                           |
-| `--auth.db`           | `db/auth.db`       | auth-server SQLite database path         |
+| `--auth.db`          | `db/auth.db`            | auth-server SQLite database path                                                                                     |
-| `--cdn.listen`        | `0.0.0.0:8080`     | octo-cdn local bind address              |
+| `--cdn.listen`       | `0.0.0.0:8080`          | octo-cdn local bind address                                                                                          |
-| `--cdn.public-addr`   | `10.0.2.2:8080`    | octo-cdn externally-reachable addr       |
+| `--cdn.public-addr`  | `10.0.2.2:8080`         | octo-cdn externally-reachable addr                                                                                   |
-| `--grpc.listen`       | `0.0.0.0:8003`     | lunar-tear gRPC listen address           |
+| `--grpc.listen`      | `0.0.0.0:8003`          | lunar-tear gRPC listen address                                                                                       |
-| `--grpc.public-addr`  | `10.0.2.2:8003`    | lunar-tear externally-reachable addr     |
+| `--grpc.public-addr` | `10.0.2.2:8003`         | lunar-tear externally-reachable addr                                                                                 |
-| `--grpc.octo-url`     | `http://10.0.2.2:8080` | Octo CDN base URL passed to lunar-tear |
+| `--grpc.octo-url`    | `http://10.0.2.2:8080`  | Octo CDN base URL passed to lunar-tear                                                                               |
-| `--grpc.auth-url`     | `http://localhost:3000` | auth server base URL passed to lunar-tear |
+| `--grpc.auth-url`    | `http://localhost:3000` | auth server base URL passed to lunar-tear                                                                            |
-| `--no-register`       | `false`            | disable new user registrations (only already registered users can connect). |
+| `--no-register`      | `false`                 | disable new user registrations (only already registered users can connect).                                          |
-| `--admin.listen`      | *(empty)*          | lunar-tear admin webhook bind. Empty = leave default; webhook only binds when `LUNAR_ADMIN_TOKEN` is set in the env. |
+| `--admin.listen`     | _(empty)_               | lunar-tear admin webhook bind. Empty = leave default; webhook only binds when `LUNAR_ADMIN_TOKEN` is set in the env. |
-| `--no-color`          | `false`            | disable colored output                   |
+| `--no-color`         | `false`                 | disable colored output                                                                                               |
 ### Ports
-| Protocol | Port | Binary        | Notes                                                       |
+| Protocol | Port | Binary        | Notes                                                                                                            |
-| -------- | ---- | ------------- | ----------------------------------------------------------- |
+| -------- | ---- | ------------- | ---------------------------------------------------------------------------------------------------------------- |
-| gRPC     | 443  | `lunar-tear`  | default; configurable with `--listen` (requires patched client) |
+| gRPC     | 443  | `lunar-tear`  | default; configurable with `--listen` (requires patched client)                                                  |
-| HTTP     | 8080 | `octo-cdn`    | Octo asset API + game web pages                             |
+| HTTP     | 8080 | `octo-cdn`    | Octo asset API + game web pages                                                                                  |
 | HTTP     | 8082 | `lunar-tear`  | admin webhook (`/api/admin/master-data/reload`); loopback by default, only binds when `LUNAR_ADMIN_TOKEN` is set |
-| HTTP     | 3000 | `auth-server` | account registration and login                              |
+| HTTP     | 3000 | `auth-server` | account registration and login                                                                                   |
 ### Game Server Flags (`lunar-tear`)
-| Flag             | Default           | Description                                          |
+| Flag             | Default          | Description                                                                 |
-| ---------------- | ----------------- | ---------------------------------------------------- |
+| ---------------- | ---------------- | --------------------------------------------------------------------------- |
-| `--listen`       | `0.0.0.0:443`     | gRPC listen address (host:port)                      |
+| `--listen`       | `0.0.0.0:443`    | gRPC listen address (host:port)                                             |
-| `--public-addr`  | `127.0.0.1:443`   | externally-reachable host:port advertised to clients  |
+| `--public-addr`  | `127.0.0.1:443`  | externally-reachable host:port advertised to clients                        |
-| `--octo-url`     | *(required)*      | CDN base URL the client uses for assets (e.g. `http://10.0.2.2:8080`) |
+| `--octo-url`     | _(required)_     | CDN base URL the client uses for assets (e.g. `http://10.0.2.2:8080`)       |
-| `--db`           | `db/game.db`      | SQLite database path                                 |
+| `--db`           | `db/game.db`     | SQLite database path                                                        |
-| `--auth-url`     | *(empty)*         | Auth server base URL (e.g. `http://localhost:3000`)  |
+| `--auth-url`     | _(empty)_        | Auth server base URL (e.g. `http://localhost:3000`)                         |
-| `--admin-listen` | `127.0.0.1:8082`  | Admin webhook listen address. Only binds when `LUNAR_ADMIN_TOKEN` is set. |
+| `--admin-listen` | `127.0.0.1:8082` | Admin webhook listen address. Only binds when `LUNAR_ADMIN_TOKEN` is set.   |
-| `--no-register`  | `false`           | Disable new user registrations (only already registered users can connect). |
+| `--no-register`  | `false`          | Disable new user registrations (only already registered users can connect). |
 ### Live Master Data Reload
@@ -231,11 +238,11 @@ Security defaults are fail-closed:
 ### CDN Flags (`octo-cdn`)
-| Flag            | Default           | Description                                              |
+| Flag            | Default          | Description                                               |
-| --------------- | ----------------- | -------------------------------------------------------- |
+| --------------- | ---------------- | --------------------------------------------------------- |
-| `--listen`      | `0.0.0.0:8080`    | local bind address                                       |
+| `--listen`      | `0.0.0.0:8080`   | local bind address                                        |
-| `--public-addr` | `127.0.0.1:8080`  | externally-reachable address (used in list.bin rewriting) |
+| `--public-addr` | `127.0.0.1:8080` | externally-reachable address (used in list.bin rewriting) |
-| `--assets-dir`  | `.`               | root directory containing the `assets/` tree             |
+| `--assets-dir`  | `.`              | root directory containing the `assets/` tree              |
 ### Docker
@@ -250,22 +257,22 @@ The `db/` directory is mounted as a volume so both `game.db` and `auth.db` persi
 Each service has its own image and can be deployed independently:
-| Service  | Image                       | Default Port | Notes                          |
+| Service  | Image                       | Default Port | Notes                            |
-| -------- | --------------------------- | ------------ | ------------------------------ |
+| -------- | --------------------------- | ------------ | -------------------------------- |
 | `server` | `kretts/lunar-tear:latest`  | 8003, 8082   | gRPC game server + admin webhook |
-| `cdn`    | `kretts/octo-cdn:latest`    | 8080         | HTTP asset CDN                 |
+| `cdn`    | `kretts/octo-cdn:latest`    | 8080         | HTTP asset CDN                   |
-| `auth`   | `kretts/auth-server:latest` | 3000         | Account registration and login |
+| `auth`   | `kretts/auth-server:latest` | 3000         | Account registration and login   |
 The game server is configured via environment variables in the compose file:
-| Env var               | Description                                                                                  |
+| Env var              | Description                                                                           |
-| --------------------- | -------------------------------------------------------------------------------------------- |
+| -------------------- | ------------------------------------------------------------------------------------- |
-| `LUNAR_LISTEN`        | gRPC bind address                                                                            |
+| `LUNAR_LISTEN`       | gRPC bind address                                                                     |
-| `LUNAR_PUBLIC_ADDR`   | Client-facing address advertised to the game                                                 |
+| `LUNAR_PUBLIC_ADDR`  | Client-facing address advertised to the game                                          |
-| `LUNAR_OCTO_URL`      | CDN base URL the client uses for assets                                                      |
+| `LUNAR_OCTO_URL`     | CDN base URL the client uses for assets                                               |
-| `LUNAR_AUTH_URL`      | Auth server base URL (optional)                                                              |
+| `LUNAR_AUTH_URL`     | Auth server base URL (optional)                                                       |
-| `LUNAR_ADMIN_LISTEN`  | Admin webhook bind address inside the container (compose default: `0.0.0.0:8082`)            |
+| `LUNAR_ADMIN_LISTEN` | Admin webhook bind address inside the container (compose default: `0.0.0.0:8082`)     |
-| `LUNAR_ADMIN_TOKEN`   | Bearer token for the admin webhook. **The webhook does not bind unless this is set.**        |
+| `LUNAR_ADMIN_TOKEN`  | Bearer token for the admin webhook. **The webhook does not bind unless this is set.** |
 Auth is optional — if `LUNAR_AUTH_URL` is unset the game server starts without it. The admin webhook is published to `127.0.0.1:8082` on the host so the master-data reload endpoint stays loopback-only by default; set `LUNAR_ADMIN_TOKEN` (e.g. via a `.env` file) before bringing the stack up.
@@ -273,22 +280,22 @@ Auth is optional — if `LUNAR_AUTH_URL` is unset the game server starts without
 All targets run from the `server/` directory.
-| Target         | Description                                             |
+| Target                        | Description                                            |
-| -------------- | ------------------------------------------------------- |
+| ----------------------------- | ------------------------------------------------------ |
-| `make proto`   | Regenerate protobuf stubs                               |
+| `make proto`                  | Regenerate protobuf stubs                              |
-| `make build`   | Build the game server binary                            |
+| `make build`                  | Build the game server binary                           |
-| `make build-cdn` | Build the CDN binary                                  |
+| `make build-cdn`              | Build the CDN binary                                   |
-| `make build-auth` | Build the auth server binary                          |
+| `make build-auth`             | Build the auth server binary                           |
-| `make build-dev` | Build the dev runner binary to `bin/`                  |
+| `make build-dev`              | Build the dev runner binary to `bin/`                  |
-| `make build-all` | Build all service binaries to `bin/`                   |
+| `make build-all`              | Build all service binaries to `bin/`                   |
-| `make build-import` | Build the import-snapshot tool                     |
+| `make build-import`           | Build the import-snapshot tool                         |
-| `make build-claim-account` | Build the claim-account tool                |
+| `make build-claim-account`    | Build the claim-account tool                           |
-| `make build-register-account` | Build the register-account tool           |
+| `make build-register-account` | Build the register-account tool                        |
-| `make clean`   | Remove the `bin/` directory                              |
+| `make clean`                  | Remove the `bin/` directory                            |
-| `make dev`     | Run all three services with one command                  |
+| `make dev`                    | Run all three services with one command                |
-| `make migrate` | Run goose migrations on `db/game.db`                    |
+| `make migrate`                | Run goose migrations on `db/game.db`                   |
-| `make restore` | Interactive restore of `db/game.db` from `db/backups/`   |
+| `make restore`                | Interactive restore of `db/game.db` from `db/backups/` |
-| `make import`  | Import a snapshot (`SNAPSHOT=... UUID=...` required)     |
+| `make import`                 | Import a snapshot (`SNAPSHOT=... UUID=...` required)   |
 ## Claim Account
@@ -301,10 +308,10 @@ cd server
 go run ./cmd/claim-account --name "PlayerName" --db db/game.db
 ```
-| Flag     | Default      | Description                                          |
+| Flag     | Default      | Description                  |
-| -------- | ------------ | ---------------------------------------------------- |
+| -------- | ------------ | ---------------------------- |
-| `--name` | *(required)* | In-game player name to claim                         |
+| `--name` | _(required)_ | In-game player name to claim |
-| `--db`   | `db/game.db` | SQLite database path                                 |
+| `--db`   | `db/game.db` | SQLite database path         |
 ## Auth Server
@@ -323,12 +330,12 @@ The `--secret` flag accepts a hex-encoded HMAC key. If omitted, a random key is
 ### Flags
-| Flag             | Default         | Description                                  |
+| Flag            | Default        | Description                                                                |
-| ---------------- | --------------- | -------------------------------------------- |
+| --------------- | -------------- | -------------------------------------------------------------------------- |
-| `--listen`       | `0.0.0.0:3000`  | HTTP listen address (host:port)              |
+| `--listen`      | `0.0.0.0:3000` | HTTP listen address (host:port)                                            |
-| `--db`           | `db/auth.db`    | SQLite database path for auth users          |
+| `--db`          | `db/auth.db`   | SQLite database path for auth users                                        |
-| `--secret`       | *(generated)*   | Hex-encoded HMAC secret for token signing    |
+| `--secret`      | _(generated)_  | Hex-encoded HMAC secret for token signing                                  |
-| `--no-register`  | `false`         | Disable new user registrations (only already registered users can log in). |
+| `--no-register` | `false`        | Disable new user registrations (only already registered users can log in). |
 ## Create account
@@ -339,13 +346,13 @@ A primary mean of registering new accounts when `--no-register` flag is passed t
 go run ./cmd/register-account --name "AccountName" --password "AccountPassword" --platform "android"
 ```
-| Flag         | Default      | Description                                                  |
+| Flag         | Default      | Description                                       |
-| ------------ | ------------ | ------------------------------------------------------------ |
+| ------------ | ------------ | ------------------------------------------------- |
-| `--name`     | *(required)* | Auth Server account nickname to be registered                |
+| `--name`     | _(required)_ | Auth Server account nickname to be registered     |
-| `--password` | *(required)* | Auth Server account password to be registered                |
+| `--password` | _(required)_ | Auth Server account password to be registered     |
-| `--platform` | `android`    | Platform of new user account (`android` or `ios`)            |
+| `--platform` | `android`    | Platform of new user account (`android` or `ios`) |
-| `--db`       | `db/game.db` | SQLite main database path                                    |
+| `--db`       | `db/game.db` | SQLite main database path                         |
-| `--auth-db`  | `db/auth.db` | SQLite Auth Server database path                             |
+| `--auth-db`  | `db/auth.db` | SQLite Auth Server database path                  |
 This only sets the nickname of Auth Server account, a player can choose their in-game nickname upon first login!
@@ -40,6 +40,7 @@ var childTables = []string{
 	"user_big_hunt_max_scores",
 	"user_quest_limit_content_status",
 	"user_side_story_quests",
 	"user_main_quest_season_routes",
 	"user_missions",
 	"user_quest_missions",
 	"user_quests",
@@ -120,8 +120,12 @@ func main() {
 		colorCyan = ""
 	}
-	log.Println("building services...")
+	if _, err := os.Stat("go.mod"); err == nil {
-	buildAll()
+		log.Println("building services...")
 		buildAll()
 	} else {
 		log.Println("prebuilt mode: skipping build, using bin/ from archive")
 	}
 	ext := binExt()
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
@@ -27,31 +27,39 @@ func backupGameDB() {
 		return
 	}
-	_ = spinner.New().Title("  Backing up db/game.db...").Action(func() {
+	if !sourceMode {
-		if err := os.MkdirAll(backupDir, 0o755); err != nil {
+		fmt.Println("  Backing up db/game.db...")
-			fmt.Fprintf(os.Stderr, "  failed to create %s: %v\n", backupDir, err)
+		doBackupGameDB()
-			return
+		return
-		}
+	}
-		ts := time.Now().UTC().Format("20060102T150405Z")
+	_ = spinner.New().Title("  Backing up db/game.db...").Action(doBackupGameDB).Run()
-		dest := filepath.Join(backupDir, fmt.Sprintf("game.db.%s%s", ts, backupSuffix))
+}
-		db, err := sql.Open("sqlite", gameDBPath+"?_pragma=busy_timeout(5000)")
+func doBackupGameDB() {
-		if err != nil {
+	if err := os.MkdirAll(backupDir, 0o755); err != nil {
-			fmt.Fprintf(os.Stderr, "  failed to open %s: %v\n", gameDBPath, err)
+		fmt.Fprintf(os.Stderr, "  failed to create %s: %v\n", backupDir, err)
-			return
+		return
-		}
+	}
 		defer db.Close()
-		escaped := strings.ReplaceAll(dest, "'", "''")
+	ts := time.Now().UTC().Format("20060102T150405Z")
-		if _, err := db.Exec(fmt.Sprintf("VACUUM INTO '%s'", escaped)); err != nil {
+	dest := filepath.Join(backupDir, fmt.Sprintf("game.db.%s%s", ts, backupSuffix))
 			fmt.Fprintf(os.Stderr, "  VACUUM INTO failed: %v\n", err)
 			_ = os.Remove(dest)
 			return
 		}
-		pruneOldBackups()
+	db, err := sql.Open("sqlite", gameDBPath+"?_pragma=busy_timeout(5000)")
-	}).Run()
+	if err != nil {
 		fmt.Fprintf(os.Stderr, "  failed to open %s: %v\n", gameDBPath, err)
 		return
 	}
 	defer db.Close()
 	escaped := strings.ReplaceAll(dest, "'", "''")
 	if _, err := db.Exec(fmt.Sprintf("VACUUM INTO '%s'", escaped)); err != nil {
 		fmt.Fprintf(os.Stderr, "  VACUUM INTO failed: %v\n", err)
 		_ = os.Remove(dest)
 		return
 	}
 	pruneOldBackups()
 }
 func pruneOldBackups() {
@@ -74,14 +74,21 @@ func main() {
 	fmt.Print(banner)
 	sourceMode = isSourceCheckout()
 	if !*setupOnly {
 		validateAssets()
-		validateTools()
+		if sourceMode {
-		validateProtocIncludes()
+			validateTools()
-		runProtoc()
+			validateProtocIncludes()
-		backupGameDB()
+			runProtoc()
-		runMigrate()
+			backupGameDB()
-		downloadDeps()
+			runMigrate()
 			downloadDeps()
 		} else {
 			backupGameDB()
 			runMigrateEmbedded()
 		}
 	}
 	ip, cfg, firstRun := resolveIP(*preferSaved)
@@ -901,13 +908,15 @@ func launchDev(ip string, p ports) {
 	}
 	devBin := filepath.Join("bin", "dev"+ext)
-	_ = spinner.New().Title("  Building services...").Action(func() {
+	if sourceMode {
-		if err := os.MkdirAll("bin", 0755); err != nil {
+		_ = spinner.New().Title("  Building services...").Action(func() {
-			fmt.Fprintf(os.Stderr, "  Failed to create bin/: %v\n", err)
+			if err := os.MkdirAll("bin", 0755); err != nil {
-			os.Exit(1)
+				fmt.Fprintf(os.Stderr, "  Failed to create bin/: %v\n", err)
-		}
+				os.Exit(1)
-		runQuiet(exec.Command("go", "build", "-o", devBin, "./cmd/dev"), "build dev")
+			}
-	}).Run()
+			runQuiet(exec.Command("go", "build", "-o", devBin, "./cmd/dev"), "build dev")
 		}).Run()
 	}
 	devArgs := []string{
 		"--grpc.listen", fmt.Sprintf("0.0.0.0:%d", p.GRPC),
@@ -0,0 +1,40 @@
 package main
 import (
 	"context"
 	"database/sql"
 	"fmt"
 	"os"
 	"lunar-tear/server/migrations"
 )
 var sourceMode bool
 func isSourceCheckout() bool {
 	if _, err := os.Stat("go.mod"); err != nil {
 		return false
 	}
 	if _, err := os.Stat("proto"); err != nil {
 		return false
 	}
 	return true
 }
 func runMigrateEmbedded() {
 	fmt.Println("  Running migrations...")
 	if err := os.MkdirAll("db", 0755); err != nil {
 		fmt.Fprintf(os.Stderr, "  Failed to create db/: %v\n", err)
 		os.Exit(1)
 	}
 	db, err := sql.Open("sqlite", gameDBPath+"?_pragma=busy_timeout(5000)")
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "  open db: %v\n", err)
 		os.Exit(1)
 	}
 	defer db.Close()
 	if err := migrations.Up(context.Background(), db); err != nil {
 		fmt.Fprintf(os.Stderr, "  migration failed: %v\n", err)
 		os.Exit(1)
 	}
 }
@@ -7,12 +7,12 @@ require (
 	github.com/pierrec/lz4/v4 v4.1.26
 	github.com/vmihailenco/msgpack/v5 v5.4.1
 	golang.org/x/crypto v0.50.0
-	golang.org/x/net v0.52.0
+	golang.org/x/net v0.53.0
 	golang.org/x/sys v0.43.0
 	golang.org/x/term v0.42.0
-	google.golang.org/grpc v1.79.1
+	google.golang.org/grpc v1.80.0
 	google.golang.org/protobuf v1.36.11
-	modernc.org/sqlite v1.48.2
+	modernc.org/sqlite v1.49.1
 )
 require (
@@ -34,21 +34,25 @@ require (
 	github.com/clipperhouse/uax29/v2 v2.7.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-isatty v0.0.21 // indirect
 	github.com/mattn/go-runewidth v0.0.20 // indirect
 	github.com/mfridman/interpolate v0.0.2 // indirect
 	github.com/mitchellh/hashstructure/v2 v2.0.2 // indirect
 	github.com/muesli/cancelreader v0.2.2 // indirect
 	github.com/ncruces/go-strftime v1.0.0 // indirect
 	github.com/pressly/goose/v3 v3.27.1 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/sethvargo/go-retry v0.3.0 // indirect
 	github.com/stretchr/testify v1.11.1 // indirect
 	github.com/vmihailenco/tagparser/v2 v2.0.0 // indirect
 	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
-	go.opentelemetry.io/otel v1.40.0 // indirect
+	go.opentelemetry.io/otel v1.43.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	golang.org/x/sync v0.20.0 // indirect
 	golang.org/x/text v0.36.0 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260217215200-42d3e9bedb6d // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260420184626-e10c466a9529 // indirect
-	modernc.org/libc v1.70.0 // indirect
+	modernc.org/libc v1.72.1 // indirect
 	modernc.org/mathutil v1.7.1 // indirect
 	modernc.org/memory v1.11.0 // indirect
 )
@@ -54,8 +54,12 @@ github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQ
 github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.21 h1:xYae+lCNBP7QuW4PUnNG61ffM4hVIfm+zUzDuSzYLGs=
 github.com/mattn/go-isatty v0.0.21/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
 github.com/mattn/go-runewidth v0.0.20 h1:WcT52H91ZUAwy8+HUkdM3THM6gXqXuLJi9O3rjcQQaQ=
 github.com/mattn/go-runewidth v0.0.20/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
 github.com/mfridman/interpolate v0.0.2 h1:pnuTK7MQIxxFz1Gr+rjSIx9u7qVjf5VOoM/u6BbAxPY=
 github.com/mfridman/interpolate v0.0.2/go.mod h1:p+7uk6oE07mpE/Ik1b8EckO0O4ZXiGAfshKBWLUM9Xg=
 github.com/mitchellh/hashstructure/v2 v2.0.2 h1:vGKWl0YJqUNxE8d+h8f6NJLcCJrgbhC4NcD46KavDd4=
 github.com/mitchellh/hashstructure/v2 v2.0.2/go.mod h1:MG3aRVU/N29oo/V/IhBX8GR/zz4kQkprJgF2EVszyDE=
 github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
@@ -66,10 +70,14 @@ github.com/pierrec/lz4/v4 v4.1.26 h1:GrpZw1gZttORinvzBdXPUXATeqlJjqUG/D87TKMnhjY
 github.com/pierrec/lz4/v4 v4.1.26/go.mod h1:EoQMVJgeeEOMsCqCzqFm2O0cJvljX2nGZjcRIPL34O4=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pressly/goose/v3 v3.27.1 h1:6uEvcprBybDmW4hcz3gYujhARhye+GoWKhEWyzD5sh4=
 github.com/pressly/goose/v3 v3.27.1/go.mod h1:maruOxsPnIG2yHHyo8UqKWXYKFcH7Q76csUV7+7KYoM=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
 github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/sethvargo/go-retry v0.3.0 h1:EEt31A35QhrcRZtrYFDTBg91cqZVnFL2navjDrah2SE=
 github.com/sethvargo/go-retry v0.3.0/go.mod h1:mNX17F0C/HguQMyMyJxcnU471gOZGxCLyYaFyAZraas=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/vmihailenco/msgpack/v5 v5.4.1 h1:cQriyiUvjTwOHg8QZaPihLWeRAAVoCpE00IUPn0Bjt8=
@@ -82,20 +90,28 @@ go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ
 go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
 go.opentelemetry.io/otel v1.40.0 h1:oA5YeOcpRTXq6NN7frwmwFR0Cn3RhTVZvXsP4duvCms=
 go.opentelemetry.io/otel v1.40.0/go.mod h1:IMb+uXZUKkMXdPddhwAHm6UfOwJyh4ct1ybIlV14J0g=
 go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
 go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
 go.opentelemetry.io/otel/metric v1.40.0 h1:rcZe317KPftE2rstWIBitCdVp89A2HqjkxR3c11+p9g=
 go.opentelemetry.io/otel/metric v1.40.0/go.mod h1:ib/crwQH7N3r5kfiBZQbwrTge743UDc7DTFVZrrXnqc=
 go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
 go.opentelemetry.io/otel/sdk v1.39.0 h1:nMLYcjVsvdui1B/4FRkwjzoRVsMK8uL/cj0OyhKzt18=
 go.opentelemetry.io/otel/sdk v1.39.0/go.mod h1:vDojkC4/jsTJsE+kh+LXYQlbL8CgrEcwmt1ENZszdJE=
 go.opentelemetry.io/otel/sdk/metric v1.39.0 h1:cXMVVFVgsIf2YL6QkRF4Urbr/aMInf+2WKg+sEJTtB8=
 go.opentelemetry.io/otel/sdk/metric v1.39.0/go.mod h1:xq9HEVH7qeX69/JnwEfp6fVq5wosJsY1mt4lLfYdVew=
 go.opentelemetry.io/otel/trace v1.40.0 h1:WA4etStDttCSYuhwvEa8OP8I5EWu24lkOzp+ZYblVjw=
 go.opentelemetry.io/otel/trace v1.40.0/go.mod h1:zeAhriXecNGP/s2SEG3+Y8X9ujcJOTqQ5RgdEJcawiA=
 go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
 golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
 golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI=
 golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY=
 golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
 golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
 golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
 golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
 golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
 golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
@@ -109,18 +125,25 @@ golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s=
 golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0=
 gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
 gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
 gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260217215200-42d3e9bedb6d h1:t/LOSXPJ9R0B6fnZNyALBRfZBH0Uy0gT+uR+SJ6syqQ=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260217215200-42d3e9bedb6d/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260420184626-e10c466a9529 h1:XF8+t6QQiS0o9ArVan/HW8Q7cycNPGsJf6GA2nXxYAg=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20260420184626-e10c466a9529/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/grpc v1.79.1 h1:zGhSi45ODB9/p3VAawt9a+O/MULLl9dpizzNNpq7flY=
 google.golang.org/grpc v1.79.1/go.mod h1:KmT0Kjez+0dde/v2j9vzwoAScgEPx/Bw1CYChhHLrHQ=
 google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM=
 google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4=
 google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
 google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 modernc.org/cc/v4 v4.27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis=
 modernc.org/cc/v4 v4.27.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
 modernc.org/cc/v4 v4.28.1 h1:XpLbkYVQ24E8tX5u8+yWGvaxerxkR/S4zqxI8ZoSBuc=
 modernc.org/ccgo/v4 v4.32.0 h1:hjG66bI/kqIPX1b2yT6fr/jt+QedtP2fqojG2VrFuVw=
 modernc.org/ccgo/v4 v4.32.0/go.mod h1:6F08EBCx5uQc38kMGl+0Nm0oWczoo1c7cgpzEry7Uc0=
 modernc.org/ccgo/v4 v4.33.0 h1:dspBCm75jsj8Y/ufwAMVfe375L2iYdMyQ2QG/v3hL54=
 modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
 modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
 modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
@@ -131,16 +154,21 @@ modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
 modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
 modernc.org/libc v1.70.0 h1:U58NawXqXbgpZ/dcdS9kMshu08aiA6b7gusEusqzNkw=
 modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJo=
 modernc.org/libc v1.72.1 h1:db1xwJ6u1kE3KHTFTTbe2GCrczHPKzlURP0aDC4NGD0=
 modernc.org/libc v1.72.1/go.mod h1:HRMiC/PhPGLIPM7GzAFCbI+oSgE3dhZ8FWftmRrHVlY=
 modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
 modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
 modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
 modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
 modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
 modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
 modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg=
 modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
 modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
 modernc.org/sqlite v1.48.2 h1:5CnW4uP8joZtA0LedVqLbZV5GD7F/0x91AXeSyjoh5c=
 modernc.org/sqlite v1.48.2/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig=
 modernc.org/sqlite v1.49.1 h1:dYGHTKcX1sJ+EQDnUzvz4TJ5GbuvhNJa8Fg6ElGx73U=
 modernc.org/sqlite v1.49.1/go.mod h1:m0w8xhwYUVY3H6pSDwc3gkJ/irZT/0YEXwBlhaxQEew=
 modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
 modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
 modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
@@ -0,0 +1,286 @@
 package masterdata
 // Source: based on public_costumes_link_export_2026-05-21_142314.csv by @Keziah,
 // with each weapon resolved to its m_weapon_evolution_group EvolutionOrder=1 root
 var costumeWeaponPairings = map[int32]int32{
 	10100: 101001,
 	10101: 101011,
 	10102: 101021,
 	10103: 101031,
 	10104: 101041,
 	10105: 101051,
 	10106: 101061,
 	10107: 101071,
 	10108: 101081,
 	10109: 101091,
 	10110: 101101,
 	10111: 101121,
 	10112: 101111,
 	10113: 101131,
 	10114: 101141,
 	10115: 101151,
 	10116: 101161,
 	10117: 101171,
 	10118: 101181,
 	10119: 101191,
 	10120: 101201,
 	10121: 101211,
 	21000: 210161,
 	21001: 210031,
 	21002: 210171,
 	21003: 210181,
 	21004: 210191,
 	21005: 210271,
 	22000: 220081,
 	22001: 220021,
 	22002: 220051,
 	22003: 220061,
 	22004: 220141,
 	22005: 220161,
 	22006: 220181,
 	22007: 220191,
 	22008: 220211,
 	22009: 220231,
 	22010: 220241,
 	23000: 230001,
 	23001: 230021,
 	23004: 230051,
 	23005: 230151,
 	23006: 230261,
 	23007: 230271,
 	23008: 230281,
 	24000: 240091,
 	24001: 240121,
 	24002: 240131,
 	24003: 240011,
 	24004: 240081,
 	24005: 240201,
 	24006: 240221,
 	24007: 240241,
 	24008: 240271,
 	24009: 240311,
 	25000: 250121,
 	25001: 250071,
 	25002: 250011,
 	25003: 250151,
 	25005: 250021,
 	25006: 250171,
 	25007: 250221,
 	25008: 250231,
 	25009: 250261,
 	31000: 310081,
 	31001: 310061,
 	31002: 310021,
 	31004: 310191,
 	31005: 310211,
 	31008: 310221,
 	31009: 310241,
 	31010: 310261,
 	31011: 310291,
 	31013: 310321,
 	31014: 310331,
 	31015: 310371,
 	31016: 310401,
 	31017: 310411,
 	31018: 310421,
 	31019: 310431,
 	31020: 310461,
 	31021: 310471,
 	31022: 310481,
 	31023: 310511,
 	31024: 310531,
 	31025: 310541,
 	31026: 310551,
 	31027: 310571,
 	31028: 310591,
 	31029: 310621,
 	31030: 310641,
 	31031: 310661,
 	31032: 310691,
 	31033: 310701,
 	31034: 310711,
 	32000: 320081,
 	32001: 320041,
 	32002: 320011,
 	32003: 320111,
 	32004: 320051,
 	32005: 320141,
 	32006: 320151,
 	32007: 320171,
 	32008: 320181,
 	32009: 320201,
 	32011: 320231,
 	32012: 320241,
 	32013: 320271,
 	32014: 320281,
 	32015: 320301,
 	32016: 320331,
 	32017: 320351,
 	32018: 320371,
 	32019: 320381,
 	32020: 320391,
 	32021: 320421,
 	32022: 320431,
 	32023: 320441,
 	32024: 320451,
 	32025: 320461,
 	32026: 320471,
 	32027: 320501,
 	32028: 320531,
 	32029: 320541,
 	32030: 320551,
 	32031: 320561,
 	32032: 320581,
 	32033: 320601,
 	32034: 320611,
 	32035: 320621,
 	32036: 320641,
 	33000: 330001,
 	33001: 330121,
 	33002: 330011,
 	33003: 330021,
 	33005: 330161,
 	33006: 330171,
 	33007: 330191,
 	33009: 330211,
 	33010: 330231,
 	33011: 330261,
 	33012: 330281,
 	33013: 330321,
 	33014: 330341,
 	33015: 330381,
 	33016: 330401,
 	33017: 330421,
 	33018: 330451,
 	33019: 330471,
 	33020: 330501,
 	33021: 330521,
 	33022: 330541,
 	33023: 330551,
 	33024: 330561,
 	33025: 330571,
 	33026: 330581,
 	33027: 330591,
 	33028: 330601,
 	33029: 330631,
 	33030: 330641,
 	33031: 330671,
 	33032: 330691,
 	33033: 330701,
 	34000: 340011,
 	34001: 340121,
 	34002: 340151,
 	34003: 340161,
 	34004: 340131,
 	34005: 340071,
 	34009: 340231,
 	34010: 340241,
 	34011: 340251,
 	34012: 340261,
 	34013: 340281,
 	34014: 340291,
 	34015: 340301,
 	34016: 340321,
 	34017: 340341,
 	34018: 340351,
 	34019: 340361,
 	34020: 340381,
 	34021: 340391,
 	34022: 340411,
 	34023: 340421,
 	34024: 340441,
 	34025: 340451,
 	34026: 340461,
 	34027: 340491,
 	34028: 340501,
 	34029: 340521,
 	34030: 340531,
 	34031: 340541,
 	34032: 340571,
 	34033: 340601,
 	34034: 340611,
 	34035: 340621,
 	34036: 340631,
 	34037: 340651,
 	34038: 340681,
 	34039: 340701,
 	34040: 340721,
 	34041: 340731,
 	34042: 340751,
 	34043: 340761,
 	34044: 340781,
 	34045: 340801,
 	34046: 340831,
 	34047: 340861,
 	34048: 340871,
 	35000: 350011,
 	35001: 350161,
 	35002: 350141,
 	35003: 350061,
 	35005: 350081,
 	35006: 350121,
 	35008: 350181,
 	35009: 350191,
 	35010: 350221,
 	35011: 350231,
 	35012: 350261,
 	35013: 350271,
 	35014: 350301,
 	35015: 350321,
 	35016: 350341,
 	35017: 350361,
 	35018: 350391,
 	35019: 350401,
 	35020: 350411,
 	35021: 350431,
 	35022: 350441,
 	35023: 350451,
 	35024: 350461,
 	35025: 350491,
 	35026: 350501,
 	35027: 350511,
 	35028: 350531,
 	35029: 350551,
 	35030: 350601,
 	35031: 350621,
 	35032: 350631,
 	35033: 350641,
 	35034: 350661,
 	35035: 350681,
 	35036: 350691,
 	35037: 350701,
 	35038: 350711,
 	41000: 410031,
 	41001: 410071,
 	41002: 410111,
 	41003: 410151,
 	42000: 420031,
 	42001: 420071,
 	42002: 420111,
 	42003: 420151,
 	43000: 430031,
 	43001: 430071,
 	43002: 430111,
 	43003: 430151,
 	44000: 440031,
 	44001: 440071,
 	44002: 440111,
 	44003: 440151,
 	44004: 440191,
 	45000: 450031,
 	45001: 450071,
 	45002: 450111,
 	45003: 450151,
 	51001: 510011,
 	51002: 510021,
 	51003: 510031,
 	52001: 520011,
 	52002: 520021,
 	53001: 530011,
 	53002: 530021,
 	54001: 540011,
 	54002: 540021,
 	55001: 550011,
 	55002: 550021,
 	55003: 550031,
 }
@@ -3,7 +3,6 @@ package masterdata
 import (
 	"fmt"
 	"log"
 	"slices"
 	"sort"
 	"lunar-tear/server/internal/model"
@@ -126,27 +125,16 @@ func LoadGachaPool() (*GachaCatalog, error) {
 	}
 	catalogCostumeSet := make(map[int32]bool, len(catalogCostumes))
 	costumeTermId := make(map[int32]int32, len(catalogCostumes))
 	for _, c := range catalogCostumes {
 		catalogCostumeSet[c.CostumeId] = true
 		costumeTermId[c.CostumeId] = c.CatalogTermId
 	}
 	catalogWeaponSet := make(map[int32]bool, len(catalogWeapons))
 	for _, w := range catalogWeapons {
 		catalogWeaponSet[w.WeaponId] = true
 	}
 	costumeWeaponType := make(map[int32]int32, len(costumes))
 	for _, c := range costumes {
 		costumeWeaponType[c.CostumeId] = c.SkillfulWeaponType
 	}
 	weaponTypeById := make(map[int32]int32, len(weapons))
 	weaponRarityById := make(map[int32]int32, len(weapons))
 	restrictedWeapons := make(map[int32]bool)
 	for _, w := range weapons {
 		weaponTypeById[w.WeaponId] = w.WeaponType
 		weaponRarityById[w.WeaponId] = w.RarityType
 		if w.IsRestrictDiscard {
 			restrictedWeapons[w.WeaponId] = true
 		}
@@ -262,60 +250,12 @@ func LoadGachaPool() (*GachaCatalog, error) {
 	log.Printf("[GachaPool] pool excludes %d evolved, %d quest-granted costumes, %d quest-granted weapons, %d restricted weapons",
 		evolvedFilteredCount, questGrantedCostumeCount, questGrantedWeaponCount, restrictedCount)
-	type weaponKey struct {
+	for costumeId := range pool.CostumeById {
-		TermId     int32
+		if wid, ok := costumeWeaponPairings[costumeId]; ok {
-		WeaponType int32
+			pool.CostumeWeaponMap[costumeId] = wid
 		Rarity     int32
 	}
 	weaponsByKey := make(map[weaponKey][]int32)
 	for _, cw := range catalogWeapons {
 		if evolvedWeapons[cw.WeaponId] || restrictedWeapons[cw.WeaponId] {
 			continue
 		}
 		wt := weaponTypeById[cw.WeaponId]
 		r := weaponRarityById[cw.WeaponId]
 		if wt == 0 || r < model.RaritySRare {
 			continue
 		}
 		k := weaponKey{TermId: cw.CatalogTermId, WeaponType: wt, Rarity: r}
 		weaponsByKey[k] = append(weaponsByKey[k], cw.WeaponId)
 	}
 	for k, ids := range weaponsByKey {
 		slices.Sort(ids)
 		weaponsByKey[k] = ids
 	}
 	exact, pattern, bestGuess := 0, 0, 0
 	for costumeId, item := range pool.CostumeById {
 		tid := costumeTermId[costumeId]
 		wt := costumeWeaponType[costumeId]
 		k := weaponKey{TermId: tid, WeaponType: wt, Rarity: item.RarityType}
 		candidates := weaponsByKey[k]
 		if len(candidates) == 0 {
 			continue
 		}
 		if len(candidates) == 1 {
 			pool.CostumeWeaponMap[costumeId] = candidates[0]
 			exact++
 			continue
 		}
 		idPattern := costumeId*10 + 1
 		found := false
 		for _, wid := range candidates {
 			if wid == idPattern {
 				pool.CostumeWeaponMap[costumeId] = wid
 				pattern++
 				found = true
 				break
 			}
 		}
 		if !found {
 			pool.CostumeWeaponMap[costumeId] = candidates[0]
 			bestGuess++
 		}
 	}
-	log.Printf("[GachaPool] costume-weapon pairing: %d exact, %d id-pattern, %d best-guess, %d total",
+	log.Printf("[GachaPool] costume-weapon pairing: %d entries from lookup table", len(pool.CostumeWeaponMap))
 		exact, pattern, bestGuess, len(pool.CostumeWeaponMap))
 	for _, m := range materials {
 		pool.Materials = append(pool.Materials, GachaPoolItem{
@@ -330,7 +270,6 @@ func LoadGachaPool() (*GachaCatalog, error) {
 func (pool *GachaCatalog) BuildShopFeatured(shop *ShopCatalog) {
 	pool.ShopFeaturedByMedal = make(map[int32][]ShopFeaturedEntry)
 	shopPairs := 0
 	for _, cells := range shop.ExchangeShopCells {
 		consumableId := shop.Items[cells[0].ShopItemId].PriceId
@@ -350,16 +289,12 @@ func (pool *GachaCatalog) BuildShopFeatured(shop *ShopCatalog) {
 				continue
 			}
 			entries = append(entries, ShopFeaturedEntry{CostumeId: costumeId, WeaponId: weaponId})
 			if costumeId != 0 && weaponId != 0 {
 				pool.CostumeWeaponMap[costumeId] = weaponId
 				shopPairs++
 			}
 		}
 		if len(entries) > 0 {
 			pool.ShopFeaturedByMedal[consumableId] = entries
 		}
 	}
-	log.Printf("[GachaPool] shop featured: %d consumables, %d costume-weapon pairs overridden", len(pool.ShopFeaturedByMedal), shopPairs)
+	log.Printf("[GachaPool] shop featured: %d consumables", len(pool.ShopFeaturedByMedal))
 }
 func (pool *GachaCatalog) PruneUnpairedCostumes() {
@@ -3,57 +3,463 @@ package masterdata
 import (
 	"fmt"
 	"log"
 	"sort"
 	"sync"
 	"lunar-tear/server/internal/gametime"
 	"lunar-tear/server/internal/model"
 	"lunar-tear/server/internal/store"
 	"lunar-tear/server/internal/utils"
 )
 // MaxUserGimmickRows is the server's per-table cap for gimmick projections and the
 // in-memory user.Gimmick.Sequences map. The client hard-caps each of its
 // IUserGimmick* tables at 1024 rows; we project up to this many with a small
 // safety margin so we never overflow client buffers. Shared by InitSequenceSchedule
 // (limits user.Gimmick.Sequences map size) and the IUserGimmick / Ornament /
 // Sequence projections.
 const MaxUserGimmickRows = 1000
 type gimmickScheduleEntry struct {
 	ScheduleId      int32
 	StartDatetime   int64
 	EndDatetime     int64
 	FirstSequenceId int32
 	RequiredQuestId int32 // 0 = always active
 	IsHidden        bool  // hidden-story or cage-memory gimmick: bypasses the quest gate
 	Rank            int   // trim priority — see gimmickTypeRank
 }
 func readGimmickTable[T any](name, what string) ([]T, bool) {
 	rows, err := utils.ReadTable[T](name)
 	if err != nil {
 		log.Printf("[gimmick] %s unavailable, %s empty: %v", name, what, err)
 		return nil, false
 	}
 	return rows, true
 }
 func gimmickTypeRank(t model.GimmickType) int {
 	switch t {
 	case model.GimmickTypeReport: // hidden missions / stories
 		return 0
 	case model.GimmickTypeCageMemory: // lost archives
 		return 1
 	case model.GimmickTypeCageTreasureHunt: // treasure
 		return 2
 	case model.GimmickTypeBrokenObelisk, model.GimmickTypeFirstBrokenObelisk:
 		return 3
 	case model.GimmickTypeIronGrill:
 		return 4
 	case model.GimmickTypeRadioMessage:
 		return 5
 	case model.GimmickTypeMapOnlyCageTreasureHunt, model.GimmickTypeMapOnlyHideObelisk:
 		return 6
 	case model.GimmickTypeCageIntervalDropItem, model.GimmickTypeMapOnlyCageIntervalDrop:
 		return 7 // birds — bottom
 	}
 	return 8
 }
 type gimmickTypeTables struct {
 	byGimmick  map[int32]model.GimmickType
 	bySequence map[int32]model.GimmickType
 }
 var gimmickTypes = sync.OnceValue(loadGimmickTypes)
 func loadGimmickTypes() gimmickTypeTables {
 	empty := gimmickTypeTables{
 		byGimmick:  map[int32]model.GimmickType{},
 		bySequence: map[int32]model.GimmickType{},
 	}
 	gimmicks, ok := readGimmickTable[EntityMGimmick]("m_gimmick", "type tables")
 	if !ok {
 		return empty
 	}
 	groups, ok := readGimmickTable[EntityMGimmickGroup]("m_gimmick_group", "type tables")
 	if !ok {
 		return empty
 	}
 	sequences, ok := readGimmickTable[EntityMGimmickSequence]("m_gimmick_sequence", "type tables")
 	if !ok {
 		return empty
 	}
 	byGimmick := make(map[int32]model.GimmickType, len(gimmicks))
 	for _, g := range gimmicks {
 		byGimmick[g.GimmickId] = model.GimmickType(g.GimmickType)
 	}
 	typeByGroup := make(map[int32]model.GimmickType, len(groups))
 	for _, grp := range groups {
 		if _, seen := typeByGroup[grp.GimmickGroupId]; seen {
 			continue
 		}
 		if t, ok := byGimmick[grp.GimmickId]; ok {
 			typeByGroup[grp.GimmickGroupId] = t
 		}
 	}
 	bySequence := make(map[int32]model.GimmickType, len(sequences))
 	for _, seq := range sequences {
 		if t, ok := typeByGroup[seq.GimmickGroupId]; ok {
 			bySequence[seq.GimmickSequenceId] = t
 		}
 	}
 	return gimmickTypeTables{byGimmick: byGimmick, bySequence: bySequence}
 }
 func gimmickSequenceTypes() map[int32]model.GimmickType {
 	return gimmickTypes().bySequence
 }
 func LoadGimmickSequenceRanks() map[int32]int {
 	types := gimmickSequenceTypes()
 	out := make(map[int32]int, len(types))
 	for sid, t := range types {
 		out[sid] = gimmickTypeRank(t)
 	}
 	return out
 }
 type SequenceReward struct {
 	PossessionType int32
 	PossessionId   int32
 	Count          int32
 }
 type GimmickCatalog struct {
-	schedules []gimmickScheduleEntry
+	schedules         []gimmickScheduleEntry
 	hiddenSequences   map[int32]bool             // GimmickSequenceId -> report/cage-memory
 	sequenceRewards   map[int32][]SequenceReward // GimmickSequenceId -> clear rewards
 	gimmickTypes      map[int32]model.GimmickType
 	cageMemoryItems   map[int32]int32 // CageMemory GimmickId -> ImportantItemId (type 4)
 	hiddenBirdRewards map[GimmickOrnamentRef]SequenceReward
 }
-func LoadGimmickCatalog(resolver *ConditionResolver) (*GimmickCatalog, error) {
+func LoadGimmickCatalog(resolver *ConditionResolver, cageOrnaments *CageOrnamentCatalog) (*GimmickCatalog, error) {
 	rows, err := utils.ReadTable[EntityMGimmickSequenceSchedule]("m_gimmick_sequence_schedule")
 	if err != nil {
 		return nil, fmt.Errorf("load gimmick sequence schedule table: %w", err)
 	}
-	entries := make([]gimmickScheduleEntry, 0, len(rows))
+	seqTypes := gimmickSequenceTypes()
 	hiddenSeq := make(map[int32]bool, len(seqTypes))
 	for sid, t := range seqTypes {
 		if t == model.GimmickTypeReport || t == model.GimmickTypeCageMemory {
 			hiddenSeq[sid] = true
 		}
 	}
 	// Pick rule: prefer schedules with EndDatetime in the future (so the client's
 	// in-cage filter doesn't drop them), then by lowest StartDatetime (longest
 	// historical validity, tends to carry the simplest RequiredQuestId), tie-broken
 	// by lowest ScheduleId for determinism. The future-end preference matters for
 	// "Fickle Black Birds" (type 1) where real expiry dates vary; other types have
 	// EndDatetime = 9999-03-31 so the preference is a no-op.
 	now := gametime.NowMillis()
 	bestBySeq := make(map[int32]gimmickScheduleEntry, len(rows))
 	for _, r := range rows {
 		entry := gimmickScheduleEntry{
 			ScheduleId:      r.GimmickSequenceScheduleId,
 			StartDatetime:   r.StartDatetime,
 			EndDatetime:     r.EndDatetime,
 			FirstSequenceId: r.FirstGimmickSequenceId,
 			IsHidden:        hiddenSeq[r.FirstGimmickSequenceId],
 			Rank:            gimmickTypeRank(seqTypes[r.FirstGimmickSequenceId]),
 		}
 		if r.ReleaseEvaluateConditionId != 0 {
 			if qid, ok := resolver.RequiredQuestId(r.ReleaseEvaluateConditionId); ok {
 				entry.RequiredQuestId = qid
 			}
 		}
-		entries = append(entries, entry)
+		if existing, ok := bestBySeq[entry.FirstSequenceId]; ok {
 			existingFuture := existing.EndDatetime > now
 			entryFuture := entry.EndDatetime > now
 			if existingFuture != entryFuture {
 				// Future-end schedule wins over expired one.
 				if existingFuture {
 					continue
 				}
 			} else if existing.StartDatetime < entry.StartDatetime ||
 				(existing.StartDatetime == entry.StartDatetime && existing.ScheduleId <= entry.ScheduleId) {
 				continue
 			}
 		}
 		bestBySeq[entry.FirstSequenceId] = entry
 	}
-	log.Printf("gimmick catalog loaded: %d schedules", len(entries))
+	entries := make([]gimmickScheduleEntry, 0, len(bestBySeq))
-	return &GimmickCatalog{schedules: entries}, nil
+	hiddenCount := 0
 	for _, entry := range bestBySeq {
 		if entry.IsHidden {
 			hiddenCount++
 		}
 		entries = append(entries, entry)
 	}
 	dedupedCount := len(rows) - len(entries)
 	// Sort by (Rank, ScheduleId) so ActiveScheduleKeys returns the priority order
 	// directly: treasure/lost-archives/hidden-missions first, birds last. This is
 	// what lets InitSequenceSchedule's 1000-row cap trim from the bottom.
 	sort.Slice(entries, func(i, j int) bool {
 		if entries[i].Rank != entries[j].Rank {
 			return entries[i].Rank < entries[j].Rank
 		}
 		return entries[i].ScheduleId < entries[j].ScheduleId
 	})
 	sequenceRewards := loadGimmickSequenceRewards()
 	cageMemoryItems := loadCageMemoryImportantItems(gimmickTypes().byGimmick)
 	hiddenBirdRewards := loadHiddenBirdRewards(cageOrnaments)
 	log.Printf("gimmick catalog loaded: %d schedules (%d hidden-content, %d duplicates dropped), %d reward sequences, %d cage-memory items, %d hidden-bird rewards",
 		len(entries), hiddenCount, dedupedCount, len(sequenceRewards), len(cageMemoryItems), len(hiddenBirdRewards))
 	return &GimmickCatalog{
 		schedules:         entries,
 		hiddenSequences:   hiddenSeq,
 		sequenceRewards:   sequenceRewards,
 		gimmickTypes:      gimmickTypes().byGimmick,
 		cageMemoryItems:   cageMemoryItems,
 		hiddenBirdRewards: hiddenBirdRewards,
 	}, nil
 }
 // HiddenBirdReward returns the per-tap reward for a MAP_ONLY_CAGE_TREASURE_HUNT
 // ("Hidden Black Birds", type 7) ornament. Returns false if there's no mapping
 // (e.g. the ornament view has no corresponding cage-ornament-reward entry).
 func (c *GimmickCatalog) HiddenBirdReward(gimmickId, ornamentIndex int32) (SequenceReward, bool) {
 	r, ok := c.hiddenBirdRewards[GimmickOrnamentRef{GimmickId: gimmickId, OrnamentIndex: ornamentIndex}]
 	return r, ok
 }
 // loadHiddenBirdRewards resolves (GimmickId, OrnamentIndex) -> CageOrnamentReward for
 // every type-7 ("Hidden Black Birds") gimmick. The mapping is structural:
 //
 //	m_gimmick (GimmickType == 7) -> GimmickOrnamentGroupId
 //	m_gimmick_ornament (matching group) -> GimmickOrnamentViewId
 //	m_cage_ornament (CageOrnamentId == ViewId) -> CageOrnamentRewardId
 //	m_cage_ornament_reward (matching id) -> PossessionType / PossessionId / Count
 //
 // 110 of 114 type-7 ornaments have a matching m_cage_ornament row in the current
 // data; the rest log a warning and are silently skipped so the player just gets
 // no reward on those (no crash).
 func loadHiddenBirdRewards(cageOrnaments *CageOrnamentCatalog) map[GimmickOrnamentRef]SequenceReward {
 	empty := map[GimmickOrnamentRef]SequenceReward{}
 	if cageOrnaments == nil {
 		return empty
 	}
 	gimmicks, ok := readGimmickTable[EntityMGimmick]("m_gimmick", "hidden-bird rewards")
 	if !ok {
 		return empty
 	}
 	ornaments, ok := readGimmickTable[EntityMGimmickOrnament]("m_gimmick_ornament", "hidden-bird rewards")
 	if !ok {
 		return empty
 	}
 	gimmicksByGroup := make(map[int32][]int32)
 	for _, g := range gimmicks {
 		if model.GimmickType(g.GimmickType) == model.GimmickTypeMapOnlyCageTreasureHunt {
 			gimmicksByGroup[g.GimmickOrnamentGroupId] = append(gimmicksByGroup[g.GimmickOrnamentGroupId], g.GimmickId)
 		}
 	}
 	out := make(map[GimmickOrnamentRef]SequenceReward)
 	missing := 0
 	for _, o := range ornaments {
 		gids, ok := gimmicksByGroup[o.GimmickOrnamentGroupId]
 		if !ok {
 			continue
 		}
 		reward, ok := cageOrnaments.LookupReward(o.GimmickOrnamentViewId)
 		if !ok {
 			missing++
 			continue
 		}
 		entry := SequenceReward{
 			PossessionType: reward.PossessionType,
 			PossessionId:   reward.PossessionId,
 			Count:          reward.Count,
 		}
 		for _, gid := range gids {
 			out[GimmickOrnamentRef{GimmickId: gid, OrnamentIndex: o.GimmickOrnamentIndex}] = entry
 		}
 	}
 	if missing > 0 {
 		log.Printf("[gimmick] %d hidden-bird ornaments had no m_cage_ornament_reward row", missing)
 	}
 	return out
 }
 func (c *GimmickCatalog) GimmickType(gimmickId int32) model.GimmickType {
 	return c.gimmickTypes[gimmickId]
 }
 // CageMemoryImportantItem returns the ImportantItemId (type 4) that the library uses
 // to mark a tapped cage memory as collected, given the world-gimmick id. The mapping
 // is derived from m_gimmick_additional_asset texture suffixes — see
 // loadCageMemoryImportantItems.
 func (c *GimmickCatalog) CageMemoryImportantItem(gimmickId int32) (int32, bool) {
 	id, ok := c.cageMemoryItems[gimmickId]
 	return id, ok
 }
 // importantItemTypeCageMemory mirrors EntityMImportantItem.ImportantItemType==4 — the
 // CageMemory entry that the library's HasCageMemory check resolves to.
 const importantItemTypeCageMemory int32 = 4
 func loadCageMemoryImportantItems(typeByGimmick map[int32]model.GimmickType) map[int32]int32 {
 	empty := map[int32]int32{}
 	ornaments, ok := readGimmickTable[EntityMGimmickOrnament]("m_gimmick_ornament", "cage-memory items")
 	if !ok {
 		return empty
 	}
 	chapters, ok := readGimmickTable[EntityMMainQuestChapter]("m_main_quest_chapter", "cage-memory items")
 	if !ok {
 		return empty
 	}
 	routes, ok := readGimmickTable[EntityMMainQuestRoute]("m_main_quest_route", "cage-memory items")
 	if !ok {
 		return empty
 	}
 	cageMemories, ok := readGimmickTable[EntityMCageMemory]("m_cage_memory", "cage-memory items")
 	if !ok {
 		return empty
 	}
 	items, ok := readGimmickTable[EntityMImportantItem]("m_important_item", "cage-memory items")
 	if !ok {
 		return empty
 	}
 	chapterByOrnamentGroup := make(map[int32]int32, len(ornaments))
 	for _, o := range ornaments {
 		if _, seen := chapterByOrnamentGroup[o.GimmickOrnamentGroupId]; seen {
 			continue
 		}
 		chapterByOrnamentGroup[o.GimmickOrnamentGroupId] = o.ChapterId
 	}
 	routeByChapter := make(map[int32]int32, len(chapters))
 	for _, c := range chapters {
 		routeByChapter[c.MainQuestChapterId] = c.MainQuestRouteId
 	}
 	seasonByRoute := make(map[int32]int32, len(routes))
 	for _, r := range routes {
 		seasonByRoute[r.MainQuestRouteId] = r.MainQuestSeasonId
 	}
 	cmsBySeason := make(map[int32][]int32)
 	for _, c := range cageMemories {
 		cmsBySeason[c.MainQuestSeasonId] = append(cmsBySeason[c.MainQuestSeasonId], c.CageMemoryId)
 	}
 	for s := range cmsBySeason {
 		sort.Slice(cmsBySeason[s], func(i, j int) bool { return cmsBySeason[s][i] < cmsBySeason[s][j] })
 	}
 	itemByCageMemory := make(map[int32]int32)
 	for _, it := range items {
 		if it.ImportantItemType == importantItemTypeCageMemory && it.CageMemoryId != 0 {
 			itemByCageMemory[it.CageMemoryId] = it.ImportantItemId
 		}
 	}
 	gimmicksByRoute := make(map[int32][]int32)
 	for gid, t := range typeByGimmick {
 		if t != model.GimmickTypeCageMemory {
 			continue
 		}
 		chapter, ok := chapterByOrnamentGroup[gid]
 		if !ok {
 			log.Printf("[gimmick] cage-memory %d has no ornament row, skipping mapping", gid)
 			continue
 		}
 		route, ok := routeByChapter[chapter]
 		if !ok {
 			log.Printf("[gimmick] cage-memory %d chapter %d has no route, skipping mapping", gid, chapter)
 			continue
 		}
 		gimmicksByRoute[route] = append(gimmicksByRoute[route], gid)
 	}
 	for r := range gimmicksByRoute {
 		sort.Slice(gimmicksByRoute[r], func(i, j int) bool { return gimmicksByRoute[r][i] < gimmicksByRoute[r][j] })
 	}
 	out := make(map[int32]int32)
 	for route, gids := range gimmicksByRoute {
 		season, ok := seasonByRoute[route]
 		if !ok {
 			log.Printf("[gimmick] route %d has no season, skipping %d cage-memory gimmicks", route, len(gids))
 			continue
 		}
 		seasonCms := cmsBySeason[season]
 		for i, gid := range gids {
 			if i >= len(seasonCms) {
 				log.Printf("[gimmick] route %d (season %d) has %d cage-memory gimmicks but only %d cage memories; gimmick %d skipped",
 					route, season, len(gids), len(seasonCms), gid)
 				continue
 			}
 			cageMemoryId := seasonCms[i]
 			itemId, ok := itemByCageMemory[cageMemoryId]
 			if !ok {
 				log.Printf("[gimmick] cage memory %d (gimmick %d) has no m_important_item row (type 4), skipping",
 					cageMemoryId, gid)
 				continue
 			}
 			out[gid] = itemId
 		}
 	}
 	return out
 }
 func loadGimmickSequenceRewards() map[int32][]SequenceReward {
 	empty := map[int32][]SequenceReward{}
 	sequences, ok := readGimmickTable[EntityMGimmickSequence]("m_gimmick_sequence", "sequence rewards")
 	if !ok {
 		return empty
 	}
 	rewardGroups, ok := readGimmickTable[EntityMGimmickSequenceRewardGroup]("m_gimmick_sequence_reward_group", "sequence rewards")
 	if !ok {
 		return empty
 	}
 	rewardsByGroup := make(map[int32][]SequenceReward)
 	for _, rg := range rewardGroups {
 		if rg.PossessionType == 0 || rg.PossessionId == 0 {
 			continue
 		}
 		rewardsByGroup[rg.GimmickSequenceRewardGroupId] = append(
 			rewardsByGroup[rg.GimmickSequenceRewardGroupId], SequenceReward{
 				PossessionType: rg.PossessionType,
 				PossessionId:   rg.PossessionId,
 				Count:          rg.Count,
 			})
 	}
 	rewardsBySequence := make(map[int32][]SequenceReward, len(sequences))
 	for _, seq := range sequences {
 		if rewards := rewardsByGroup[seq.GimmickSequenceRewardGroupId]; len(rewards) > 0 {
 			rewardsBySequence[seq.GimmickSequenceId] = rewards
 		}
 	}
 	return rewardsBySequence
 }
 func (c *GimmickCatalog) IsHiddenSequence(sequenceId int32) bool {
 	return c.hiddenSequences[sequenceId]
 }
 func (c *GimmickCatalog) SequenceRewards(sequenceId int32) []SequenceReward {
 	return c.sequenceRewards[sequenceId]
 }
 func (c *GimmickCatalog) ActiveScheduleKeys(user store.UserState, nowMillis int64) []store.GimmickSequenceKey {
-	var keys []store.GimmickSequenceKey
+	keys := make([]store.GimmickSequenceKey, 0, len(c.schedules))
 	for _, s := range c.schedules {
-		if nowMillis < s.StartDatetime || nowMillis > s.EndDatetime {
+		if nowMillis < s.StartDatetime {
-			continue
+			continue // future schedules still skipped
 		}
-		if s.RequiredQuestId != 0 {
+		if !s.IsHidden && s.RequiredQuestId != 0 {
 			q, ok := user.Quests[s.RequiredQuestId]
 			if !ok || q.QuestStateType != model.UserQuestStateTypeCleared {
 				continue
@@ -66,3 +472,126 @@ func (c *GimmickCatalog) ActiveScheduleKeys(user store.UserState, nowMillis int6
 	}
 	return keys
 }
 type GimmickOrnamentRef struct {
 	GimmickId     int32
 	OrnamentIndex int32
 }
 func LoadGimmickOrnamentRefs() map[int32][]GimmickOrnamentRef {
 	empty := map[int32][]GimmickOrnamentRef{}
 	sequences, ok := readGimmickTable[EntityMGimmickSequence]("m_gimmick_sequence", "ornament refs")
 	if !ok {
 		return empty
 	}
 	groups, ok := readGimmickTable[EntityMGimmickGroup]("m_gimmick_group", "ornament refs")
 	if !ok {
 		return empty
 	}
 	gimmicks, ok := readGimmickTable[EntityMGimmick]("m_gimmick", "ornament refs")
 	if !ok {
 		return empty
 	}
 	ornaments, ok := readGimmickTable[EntityMGimmickOrnament]("m_gimmick_ornament", "ornament refs")
 	if !ok {
 		return empty
 	}
 	indicesByOrnamentGroup := make(map[int32][]int32)
 	for _, o := range ornaments {
 		indicesByOrnamentGroup[o.GimmickOrnamentGroupId] = append(
 			indicesByOrnamentGroup[o.GimmickOrnamentGroupId], o.GimmickOrnamentIndex)
 	}
 	ornamentGroupByGimmick := make(map[int32]int32, len(gimmicks))
 	for _, g := range gimmicks {
 		ornamentGroupByGimmick[g.GimmickId] = g.GimmickOrnamentGroupId
 	}
 	gimmicksByGroup := make(map[int32][]int32)
 	for _, grp := range groups {
 		gimmicksByGroup[grp.GimmickGroupId] = append(gimmicksByGroup[grp.GimmickGroupId], grp.GimmickId)
 	}
 	refsBySequence := make(map[int32][]GimmickOrnamentRef, len(sequences))
 	for _, seq := range sequences {
 		var refs []GimmickOrnamentRef
 		for _, gimmickId := range gimmicksByGroup[seq.GimmickGroupId] {
 			for _, ornamentIndex := range indicesByOrnamentGroup[ornamentGroupByGimmick[gimmickId]] {
 				refs = append(refs, GimmickOrnamentRef{GimmickId: gimmickId, OrnamentIndex: ornamentIndex})
 			}
 		}
 		if len(refs) > 0 {
 			refsBySequence[seq.GimmickSequenceId] = refs
 		}
 	}
 	log.Printf("gimmick ornament refs loaded: %d sequences", len(refsBySequence))
 	return refsBySequence
 }
 func LoadHiddenGimmickSequenceIDs() map[int32]bool {
 	types := gimmickSequenceTypes()
 	out := make(map[int32]bool, len(types))
 	for sid, t := range types {
 		if t == model.GimmickTypeReport || t == model.GimmickTypeCageMemory || t == model.GimmickTypeMapOnlyCageTreasureHunt {
 			out[sid] = true
 		}
 	}
 	return out
 }
 func LoadBirdGimmickIDs() map[int32]bool {
 	byGimmick := gimmickTypes().byGimmick
 	out := make(map[int32]bool, len(byGimmick))
 	for gid, t := range byGimmick {
 		if t == model.GimmickTypeCageIntervalDropItem || t == model.GimmickTypeMapOnlyCageIntervalDrop {
 			out[gid] = true
 		}
 	}
 	return out
 }
 func LoadGimmickSequenceChains() map[int32][]int32 {
 	empty := map[int32][]int32{}
 	sequences, ok := readGimmickTable[EntityMGimmickSequence]("m_gimmick_sequence", "sequence chains")
 	if !ok {
 		return empty
 	}
 	groups, ok := readGimmickTable[EntityMGimmickSequenceGroup]("m_gimmick_sequence_group", "sequence chains")
 	if !ok {
 		return empty
 	}
 	membersByGroup := make(map[int32][]int32)
 	for _, g := range groups {
 		membersByGroup[g.GimmickSequenceGroupId] = append(membersByGroup[g.GimmickSequenceGroupId], g.GimmickSequenceId)
 	}
 	nextGroupBySequence := make(map[int32]int32, len(sequences))
 	for _, seq := range sequences {
 		nextGroupBySequence[seq.GimmickSequenceId] = seq.NextGimmickSequenceGroupId
 	}
 	chains := make(map[int32][]int32, len(sequences))
 	for _, seq := range sequences {
 		start := seq.GimmickSequenceId
 		seen := map[int32]bool{start: true}
 		chain := []int32{start}
 		for queue := []int32{start}; len(queue) > 0; {
 			cur := queue[0]
 			queue = queue[1:]
 			nextGroup := nextGroupBySequence[cur]
 			if nextGroup == 0 {
 				continue
 			}
 			for _, member := range membersByGroup[nextGroup] {
 				if !seen[member] {
 					seen[member] = true
 					chain = append(chain, member)
 					queue = append(queue, member)
 				}
 			}
 		}
 		chains[start] = chain
 	}
 	return chains
 }
@@ -0,0 +1,103 @@
 package masterdata
 import (
 	"log"
 	"lunar-tear/server/internal/model"
 	"lunar-tear/server/internal/store"
 	"lunar-tear/server/internal/utils"
 )
 type HiddenStoryRequirements struct {
 	MissionIds    []int32
 	QuestMissions []store.QuestMissionKey
 }
 func LoadHiddenStoryRequirements() HiddenStoryRequirements {
 	var empty HiddenStoryRequirements
 	gimmicks, err := utils.ReadTable[EntityMGimmick]("m_gimmick")
 	if err != nil {
 		log.Printf("[hiddenstory] m_gimmick unavailable: %v", err)
 		return empty
 	}
 	conditions, err := utils.ReadTable[EntityMEvaluateCondition]("m_evaluate_condition")
 	if err != nil {
 		log.Printf("[hiddenstory] m_evaluate_condition unavailable: %v", err)
 		return empty
 	}
 	valueGroups, err := utils.ReadTable[EntityMEvaluateConditionValueGroup]("m_evaluate_condition_value_group")
 	if err != nil {
 		log.Printf("[hiddenstory] m_evaluate_condition_value_group unavailable: %v", err)
 		return empty
 	}
 	condById := make(map[int32]EntityMEvaluateCondition, len(conditions))
 	for _, c := range conditions {
 		condById[c.EvaluateConditionId] = c
 	}
 	valuesByGroup := make(map[int32]map[int32]int64)
 	for _, vg := range valueGroups {
 		g := valuesByGroup[vg.EvaluateConditionValueGroupId]
 		if g == nil {
 			g = make(map[int32]int64)
 			valuesByGroup[vg.EvaluateConditionValueGroupId] = g
 		}
 		g[vg.GroupIndex] = vg.Value
 	}
 	missionSet := make(map[int32]struct{})
 	questMissionSet := make(map[store.QuestMissionKey]struct{})
 	seen := make(map[int32]bool)
 	var resolve func(conditionId int32, depth int)
 	resolve = func(conditionId int32, depth int) {
 		if conditionId == 0 || depth > 16 || seen[conditionId] {
 			return
 		}
 		seen[conditionId] = true
 		c, ok := condById[conditionId]
 		if !ok {
 			return
 		}
 		group := valuesByGroup[c.EvaluateConditionValueGroupId]
 		switch model.EvaluateConditionFunctionType(c.EvaluateConditionFunctionType) {
 		case model.EvaluateConditionFunctionTypeRecursion:
 			// Value-group entries are sub-condition ids; satisfying all leaves makes
 			// both AND and OR recursion conditions evaluate true.
 			for _, sub := range group {
 				resolve(int32(sub), depth+1)
 			}
 		case model.EvaluateConditionFunctionTypeMissionClear:
 			if v, ok := group[defaultGroupIndex]; ok {
 				missionSet[int32(v)] = struct{}{}
 			}
 		case model.EvaluateConditionFunctionTypeQuestMissionClear:
 			questId, ok1 := group[1]
 			questMissionId, ok2 := group[2]
 			if ok1 && ok2 {
 				questMissionSet[store.QuestMissionKey{
 					QuestId:        int32(questId),
 					QuestMissionId: int32(questMissionId),
 				}] = struct{}{}
 			}
 		}
 	}
 	for _, g := range gimmicks {
 		switch model.GimmickType(g.GimmickType) {
 		case model.GimmickTypeReport, model.GimmickTypeCageMemory:
 			resolve(g.ClearEvaluateConditionId, 0)
 		}
 	}
 	req := HiddenStoryRequirements{}
 	for id := range missionSet {
 		req.MissionIds = append(req.MissionIds, id)
 	}
 	for key := range questMissionSet {
 		req.QuestMissions = append(req.QuestMissions, key)
 	}
 	log.Printf("hidden-story requirements: %d missions, %d quest-missions", len(req.MissionIds), len(req.QuestMissions))
 	return req
 }
@@ -34,6 +34,8 @@ type QuestCatalog struct {
 	TutorialUnlockConditions           []EntityMTutorialUnlockCondition
 	ChapterLastSceneByQuestId          map[int32]int32
 	SeasonIdByRouteId                  map[int32]int32
 	RoutesBySeason                     map[int32][]int32
 	RouteCompletionQuestId             map[int32]int32
 	BattleOnlyTargetSceneByQuestId     map[int32]int32
 	UserExpThresholds       []int32
@@ -114,8 +116,53 @@ func LoadQuestCatalog(partsCatalog *PartsCatalog) (*QuestCatalog, error) {
 		return nil, fmt.Errorf("load main quest route table: %w", err)
 	}
 	seasonIdByRouteId := make(map[int32]int32, len(routes))
 	routesBySeason := make(map[int32][]int32, len(routes))
 	sortOrderByRoute := make(map[int32]int32, len(routes))
 	for _, r := range routes {
 		seasonIdByRouteId[r.MainQuestRouteId] = r.MainQuestSeasonId
 		routesBySeason[r.MainQuestSeasonId] = append(routesBySeason[r.MainQuestSeasonId], r.MainQuestRouteId)
 		sortOrderByRoute[r.MainQuestRouteId] = r.SortOrder
 	}
 	for seasonId, ids := range routesBySeason {
 		s := ids
 		sort.Slice(s, func(i, j int) bool { return sortOrderByRoute[s[i]] > sortOrderByRoute[s[j]] })
 		routesBySeason[seasonId] = s
 	}
 	anotherReplayConds, err := utils.ReadTable[EntityMMainQuestRouteAnotherReplayFlowUnlockCondition]("m_main_quest_route_another_replay_flow_unlock_condition")
 	if err != nil {
 		return nil, fmt.Errorf("load main quest route another replay flow unlock condition table: %w", err)
 	}
 	evaluateConds, err := utils.ReadTable[EntityMEvaluateCondition]("m_evaluate_condition")
 	if err != nil {
 		return nil, fmt.Errorf("load evaluate condition table: %w", err)
 	}
 	valueGroupByConditionId := make(map[int32]int32, len(evaluateConds))
 	for _, c := range evaluateConds {
 		valueGroupByConditionId[c.EvaluateConditionId] = c.EvaluateConditionValueGroupId
 	}
 	evaluateValueGroups, err := utils.ReadTable[EntityMEvaluateConditionValueGroup]("m_evaluate_condition_value_group")
 	if err != nil {
 		return nil, fmt.Errorf("load evaluate condition value group table: %w", err)
 	}
 	valueByGroupId := make(map[int32]int32, len(evaluateValueGroups))
 	for _, vg := range evaluateValueGroups {
 		if _, exists := valueByGroupId[vg.EvaluateConditionValueGroupId]; exists {
 			continue
 		}
 		valueByGroupId[vg.EvaluateConditionValueGroupId] = int32(vg.Value)
 	}
 	routeCompletionQuestId := make(map[int32]int32, len(anotherReplayConds))
 	for _, c := range anotherReplayConds {
 		valueGroupId, ok := valueGroupByConditionId[c.UnlockEvaluateConditionId]
 		if !ok {
 			continue
 		}
 		questId, ok := valueByGroupId[valueGroupId]
 		if !ok {
 			continue
 		}
 		routeCompletionQuestId[c.MainQuestRouteId] = questId
 	}
 	firstClearSwitches, err := utils.ReadTable[EntityMQuestFirstClearRewardSwitch]("m_quest_first_clear_reward_switch")
@@ -539,6 +586,8 @@ func LoadQuestCatalog(partsCatalog *PartsCatalog) (*QuestCatalog, error) {
 		TutorialUnlockConditions:           tutorialUnlockConds,
 		ChapterLastSceneByQuestId:          chapterLastSceneByQuestId,
 		SeasonIdByRouteId:                  seasonIdByRouteId,
 		RoutesBySeason:                     routesBySeason,
 		RouteCompletionQuestId:             routeCompletionQuestId,
 		BattleOnlyTargetSceneByQuestId:     battleOnlyTargetSceneByQuestId,
 		UserExpThresholds:       BuildExpThresholds(paramMapRows, 1),
@@ -0,0 +1,18 @@
 package model
 type GimmickType int32
 const (
 	GimmickTypeUnknown                 GimmickType = 0
 	GimmickTypeCageTreasureHunt        GimmickType = 1  // "Fickle Black Birds" — in-cage flick-and-tap birds
 	GimmickTypeCageIntervalDropItem    GimmickType = 2  // "Lost Items" — in-cage 3-dot drops that respawn on interval
 	GimmickTypeBrokenObelisk           GimmickType = 3  // "Broken Scarecrow" (per tip text); zero rows in m_gimmick, unused
 	GimmickTypeIronGrill               GimmickType = 4  // unused (zero rows in m_gimmick), in-game name unknown
 	GimmickTypeRadioMessage            GimmickType = 5  // unused (zero rows in m_gimmick); client has GimmickRadioMessage class but no data
 	GimmickTypeFirstBrokenObelisk      GimmickType = 6  // variant of Broken Scarecrow; zero rows in m_gimmick, unused
 	GimmickTypeMapOnlyCageTreasureHunt GimmickType = 7  // "Hidden Black Birds" — world-map birds; per-tap reward from m_cage_ornament_reward
 	GimmickTypeMapOnlyCageIntervalDrop GimmickType = 8  // map-side variant of Lost Items
 	GimmickTypeReport                  GimmickType = 9  // "Hidden Stories" — hidden mission markers
 	GimmickTypeCageMemory              GimmickType = 10 // "Lost Archives" — collectible library entries (one-shot ImportantItem type-4)
 	GimmickTypeMapOnlyHideObelisk      GimmickType = 11 // "Stray Scarecrow" — world-map scarecrows (not yet implemented)
 )
@@ -43,6 +43,15 @@ const (
 	QuestResultTypeFullResult QuestResultType = 3
 )
 type MissionProgressStatusType int32
 const (
 	MissionProgressStatusTypeUnknown        MissionProgressStatusType = 0
 	MissionProgressStatusTypeInProgress     MissionProgressStatusType = 1
 	MissionProgressStatusTypeClear          MissionProgressStatusType = 2
 	MissionProgressStatusTypeRewardReceived MissionProgressStatusType = 9
 )
 type QuestSceneType int32
 const (
@@ -185,8 +185,8 @@ func (h *QuestHandler) menuPickSceneId(questId int32, isBattleOnly bool) int32 {
 func (h *QuestHandler) applyQuestVictory(user *store.UserState, questId int32, outcome *FinishOutcome, nowMillis int64, wasReplay bool) {
 	questState := user.Quests[questId]
 	h.applyExpAndGoldRewards(user, questId, nowMillis)
 	if !questState.IsRewardGranted {
 		h.applyExpAndGoldRewards(user, questId, nowMillis)
 		if !wasReplay {
 			h.applyFirstClearItemRewards(user, questId, nowMillis)
 			outcome.ChangedWeaponStoryIds = append(outcome.ChangedWeaponStoryIds,
@@ -46,7 +46,6 @@ func (h *QuestHandler) advanceMainFlowScene(user *store.UserState, questId, scen
 		user.MainQuest.CurrentMainQuestRouteId = routeId
 		if seasonId, ok := h.SeasonIdByRouteId[routeId]; ok {
 			user.MainQuest.MainQuestSeasonId = seasonId
 			RecordSeasonRoute(user, seasonId, routeId, gametime.NowMillis())
 		}
 	}
 }
@@ -59,22 +58,27 @@ func (h *QuestHandler) advanceReplayFlowScene(user *store.UserState, sceneId int
 	user.MainQuest.ReplayFlowHeadQuestSceneId = sceneId
 }
-func RecordSeasonRoute(user *store.UserState, seasonId, routeId int32, nowMillis int64) {
+func (h *QuestHandler) SeasonRoutesFor(user *store.UserState) map[int32]int32 {
-	if seasonId <= 0 || routeId <= 0 {
+	out := make(map[int32]int32)
-		return
+	for seasonId, routes := range h.RoutesBySeason {
 		if seasonId <= 1 {
 			continue
 		}
 		for _, routeId := range routes {
 			finalQuestId, ok := h.RouteCompletionQuestId[routeId]
 			if !ok {
 				continue
 			}
 			if q, ok := user.Quests[finalQuestId]; ok && q.ClearCount > 0 {
 				out[seasonId] = routeId
 				break
 			}
 		}
 	}
-	if user.MainQuestSeasonRoutes == nil {
+	if cur := user.MainQuest.MainQuestSeasonId; cur >= 2 && user.MainQuest.CurrentMainQuestRouteId > 0 {
-		user.MainQuestSeasonRoutes = make(map[store.SeasonRouteKey]store.SeasonRouteEntry)
+		out[cur] = user.MainQuest.CurrentMainQuestRouteId
 	}
 	key := store.SeasonRouteKey{MainQuestSeasonId: seasonId, MainQuestRouteId: routeId}
 	if _, exists := user.MainQuestSeasonRoutes[key]; exists {
 		return
 	}
 	user.MainQuestSeasonRoutes[key] = store.SeasonRouteEntry{
 		MainQuestSeasonId: seasonId,
 		MainQuestRouteId:  routeId,
 		LatestVersion:     nowMillis,
 	}
 	return out
 }
 func (h *QuestHandler) HandleMainFlowSceneProgress(user *store.UserState, questSceneId int32, nowMillis int64) {
@@ -177,15 +181,8 @@ func (h *QuestHandler) replayFlowTypeForRoute(user *store.UserState, routeId int
 	if !ok {
 		return model.QuestFlowTypeReplayFlow
 	}
-	for key, entry := range user.MainQuestSeasonRoutes {
+	pairs := h.SeasonRoutesFor(user)
-		if key.MainQuestSeasonId == seasonId && entry.MainQuestRouteId != routeId {
+	if recorded, ok := pairs[seasonId]; ok && recorded != routeId {
 			return model.QuestFlowTypeAnotherRouteReplayFlow
 		}
 	}
 	if len(user.MainQuestSeasonRoutes) == 0 &&
 		user.MainQuest.MainQuestSeasonId == seasonId &&
 		user.MainQuest.CurrentMainQuestRouteId != 0 &&
 		user.MainQuest.CurrentMainQuestRouteId != routeId {
 		return model.QuestFlowTypeAnotherRouteReplayFlow
 	}
 	return model.QuestFlowTypeReplayFlow
@@ -8,6 +8,7 @@ import (
 	"lunar-tear/server/internal/masterdata"
 	"lunar-tear/server/internal/masterdata/memorydb"
 	"lunar-tear/server/internal/questflow"
 	"lunar-tear/server/internal/userdata"
 )
 // buildCatalogs runs the full Load*/Build*/Enrich* sequence against whatever
@@ -35,6 +36,7 @@ func buildCatalogs() (*Catalogs, error) {
 	}
 	sideStoryCatalog := masterdata.LoadSideStoryCatalog()
 	questHandler := questflow.NewQuestHandler(questCatalog, gameConfig, sideStoryCatalog)
 	userdata.SetQuestHandler(questHandler)
 	gachaEntries, medalInfo, err := masterdata.LoadGachaCatalog()
 	if err != nil {
@@ -114,7 +116,7 @@ func buildCatalogs() (*Catalogs, error) {
 	}
 	log.Printf("explore catalog loaded: %d explores, %d grade assets", len(exploreCatalog.Explores), len(exploreCatalog.GradeAssets))
-	gimmickCatalog, err := masterdata.LoadGimmickCatalog(conditionResolver)
+	gimmickCatalog, err := masterdata.LoadGimmickCatalog(conditionResolver, cageOrnamentCatalog)
 	if err != nil {
 		return nil, fmt.Errorf("load gimmick catalog: %w", err)
 	}
@@ -27,10 +27,6 @@ func (s *CageOrnamentServiceServer) ReceiveReward(ctx context.Context, req *pb.R
 	cat := s.holder.Get()
 	reward, ok := cat.CageOrnament.LookupReward(req.CageOrnamentId)
 	if !ok {
 		log.Fatalf("[CageOrnamentService] ReceiveReward: no reward for cageOrnamentId=%d", req.CageOrnamentId)
 	}
 	granter := cat.QuestHandler.Granter
 	userId := CurrentUserId(ctx, s.users, s.sessions)
 	nowMillis := gametime.NowMillis()
@@ -40,9 +36,21 @@ func (s *CageOrnamentServiceServer) ReceiveReward(ctx context.Context, req *pb.R
 			AcquisitionDatetime: nowMillis,
 			LatestVersion:       nowMillis,
 		}
-		granter.GrantFull(user, model.PossessionType(reward.PossessionType), reward.PossessionId, reward.Count, nowMillis)
+		if ok {
 			cat.QuestHandler.Granter.GrantFull(user, model.PossessionType(reward.PossessionType), reward.PossessionId, reward.Count, nowMillis)
 		}
 	})
 	if !ok {
 		// "Fickle Black Birds" (type-1 gimmicks) tap into this RPC with CageOrnamentIds
 		// not present in m_cage_ornament_reward (their GimmickOrnamentViewIds are 101/103,
 		// not the 1002xxx-style ids the table uses). Record the access and return an empty
 		// reward so the client doesn't hang and the server doesn't crash.
 		log.Printf("[CageOrnamentService] ReceiveReward: no reward mapping for cageOrnamentId=%d, returning empty",
 			req.CageOrnamentId)
 		return &pb.ReceiveRewardResponse{}, nil
 	}
 	return &pb.ReceiveRewardResponse{
 		CageOrnamentReward: []*pb.CageOrnamentReward{
 			{
@@ -6,6 +6,8 @@ import (
 	pb "lunar-tear/server/gen/proto"
 	"lunar-tear/server/internal/gametime"
 	"lunar-tear/server/internal/masterdata"
 	"lunar-tear/server/internal/model"
 	"lunar-tear/server/internal/runtime"
 	"lunar-tear/server/internal/store"
@@ -43,6 +45,10 @@ func (s *GimmickServiceServer) UpdateGimmickProgress(ctx context.Context, req *p
 	log.Printf("[GimmickService] UpdateGimmickProgress: scheduleId=%d sequenceId=%d gimmickId=%d ornamentIndex=%d progressValueBit=%d flowType=%d",
 		req.GimmickSequenceScheduleId, req.GimmickSequenceId, req.GimmickId, req.GimmickOrnamentIndex, req.ProgressValueBit, req.FlowType)
 	userId := CurrentUserId(ctx, s.users, s.sessions)
 	cat := s.holder.Get()
 	var ornamentRewards []*pb.GimmickReward
 	var sequenceCleared bool
 	s.users.UpdateUser(userId, func(user *store.UserState) {
 		nowMillis := gametime.NowMillis()
 		progressKey := store.GimmickKey{
@@ -53,7 +59,6 @@ func (s *GimmickServiceServer) UpdateGimmickProgress(ctx context.Context, req *p
 		progress := user.Gimmick.Progress[progressKey]
 		progress.Key = progressKey
 		progress.StartDatetime = nowMillis
 		user.Gimmick.Progress[progressKey] = progress
 		ornamentKey := store.GimmickOrnamentKey{
 			GimmickSequenceScheduleId: req.GimmickSequenceScheduleId,
@@ -66,28 +71,151 @@ func (s *GimmickServiceServer) UpdateGimmickProgress(ctx context.Context, req *p
 		ornament.ProgressValueBit = req.ProgressValueBit
 		ornament.BaseDatetime = nowMillis
 		user.Gimmick.OrnamentProgress[ornamentKey] = ornament
 		// Per-type branches:
 		//   * Report (type 9, "Hidden Stories")            — mark gimmick + sequence
 		//     cleared, grant SequenceRewards (ImportantItem type 3, library reads it).
 		//   * MapOnlyCageTreasureHunt (type 7, "Hidden Black Birds") — same as Report
 		//     but the per-tap reward also comes back from m_cage_ornament_reward via
 		//     GimmickOrnamentViewId.
 		//   * CageMemory (type 10, "Lost Archives")        — resolve an ImportantItem
 		//     (type 4) from the gimmick's monitor texture and grant it. IsGimmickCleared
 		//     stays false (matches original userdata; only ornament progress flips).
 		//   * CageTreasureHunt / CageIntervalDropItem*     — stub per-tap material so
 		//     the client's reward popup fires; real reward source still unmapped.
 		switch cat.Gimmick.GimmickType(req.GimmickId) {
 		case model.GimmickTypeReport:
 			progress.IsGimmickCleared = true
 			sequenceCleared = markSequenceClearedOnce(user, cat, req.GimmickSequenceScheduleId, req.GimmickSequenceId, nowMillis)
 		case model.GimmickTypeMapOnlyCageTreasureHunt:
 			r, ok := cat.Gimmick.HiddenBirdReward(req.GimmickId, req.GimmickOrnamentIndex)
 			if !ok {
 				log.Printf("[GimmickService] UpdateGimmickProgress: hidden-bird %d ornament %d has no reward mapping, skipping",
 					req.GimmickId, req.GimmickOrnamentIndex)
 				break
 			}
 			cat.QuestHandler.Granter.GrantFull(user, model.PossessionType(r.PossessionType), r.PossessionId, r.Count, nowMillis)
 			ornamentRewards = append(ornamentRewards, &pb.GimmickReward{
 				PossessionType: r.PossessionType,
 				PossessionId:   r.PossessionId,
 				Count:          r.Count,
 			})
 			progress.IsGimmickCleared = true
 			sequenceCleared = markSequenceClearedOnce(user, cat, req.GimmickSequenceScheduleId, req.GimmickSequenceId, nowMillis)
 		case model.GimmickTypeCageMemory:
 			itemId, ok := cat.Gimmick.CageMemoryImportantItem(req.GimmickId)
 			if !ok {
 				log.Printf("[GimmickService] UpdateGimmickProgress: cage memory %d has no important-item mapping, skipping grant",
 					req.GimmickId)
 				break
 			}
 			if _, owned := user.ImportantItems[itemId]; owned {
 				break
 			}
 			cat.QuestHandler.Granter.GrantFull(user, model.PossessionTypeImportantItem, itemId, 1, nowMillis)
 			ornamentRewards = append(ornamentRewards, &pb.GimmickReward{
 				PossessionType: int32(model.PossessionTypeImportantItem),
 				PossessionId:   itemId,
 				Count:          1,
 			})
 		case model.GimmickTypeCageTreasureHunt,
 			model.GimmickTypeCageIntervalDropItem,
 			model.GimmickTypeMapOnlyCageIntervalDrop:
 			// Per-tap drops with no per-gimmick reward in master data:
 			//   * type 1 — "Fickle Black Birds" in the cage
 			//   * type 2 — "Lost Items" in the cage
 			//   * type 8 — Lost Items (map variant)
 			// Stub: grant 1 of Material 100004 (the most-common reward across
 			// m_cage_ornament_reward — 15 occurrences — likely a low-tier shard) per
 			// tap so the client's reward-popup path fires and the player accumulates
 			// something. Replace once a real per-gimmick mapping surfaces.
 			const stubMaterialId = int32(100004)
 			const stubMaterialCount = int32(1)
 			cat.QuestHandler.Granter.GrantFull(user, model.PossessionTypeMaterial, stubMaterialId, stubMaterialCount, nowMillis)
 			ornamentRewards = append(ornamentRewards, &pb.GimmickReward{
 				PossessionType: int32(model.PossessionTypeMaterial),
 				PossessionId:   stubMaterialId,
 				Count:          stubMaterialCount,
 			})
 		}
 		user.Gimmick.Progress[progressKey] = progress
 	})
 	var clearReward []*pb.GimmickReward
 	if sequenceCleared {
 		for _, r := range cat.Gimmick.SequenceRewards(req.GimmickSequenceId) {
 			clearReward = append(clearReward, &pb.GimmickReward{
 				PossessionType: r.PossessionType,
 				PossessionId:   r.PossessionId,
 				Count:          r.Count,
 			})
 		}
 	}
 	return &pb.UpdateGimmickProgressResponse{
-		GimmickOrnamentReward:      []*pb.GimmickReward{},
+		GimmickOrnamentReward:      ornamentRewards,
-		IsSequenceCleared:          false,
+		IsSequenceCleared:          sequenceCleared,
-		GimmickSequenceClearReward: []*pb.GimmickReward{},
+		GimmickSequenceClearReward: clearReward,
 	}, nil
 }
 func markSequenceClearedOnce(user *store.UserState, cat *runtime.Catalogs, scheduleId, sequenceId int32, nowMillis int64) bool {
 	seqKey := store.GimmickSequenceKey{
 		GimmickSequenceScheduleId: scheduleId,
 		GimmickSequenceId:         sequenceId,
 	}
 	sequence := user.Gimmick.Sequences[seqKey]
 	sequence.Key = seqKey
 	defer func() { user.Gimmick.Sequences[seqKey] = sequence }()
 	if sequence.IsGimmickSequenceCleared {
 		return false
 	}
 	sequence.IsGimmickSequenceCleared = true
 	sequence.ClearDatetime = nowMillis
 	for _, r := range cat.Gimmick.SequenceRewards(sequenceId) {
 		cat.QuestHandler.Granter.GrantFull(user, model.PossessionType(r.PossessionType), r.PossessionId, r.Count, nowMillis)
 	}
 	return true
 }
 func (s *GimmickServiceServer) InitSequenceSchedule(ctx context.Context, _ *emptypb.Empty) (*pb.InitSequenceScheduleResponse, error) {
 	log.Printf("[GimmickService] InitSequenceSchedule")
 	userId := CurrentUserId(ctx, s.users, s.sessions)
 	now := gametime.NowMillis()
 	s.users.UpdateUser(userId, func(user *store.UserState) {
 		eligible := s.holder.Get().Gimmick.ActiveScheduleKeys(*user, now)
 		eligibleSet := make(map[store.GimmickSequenceKey]struct{}, len(eligible))
 		for _, key := range eligible {
 			eligibleSet[key] = struct{}{}
 		}
 		pruned := 0
 		for key, entry := range user.Gimmick.Sequences {
 			if _, ok := eligibleSet[key]; ok {
 				continue
 			}
 			if entry.IsGimmickSequenceCleared {
 				continue
 			}
 			delete(user.Gimmick.Sequences, key)
 			pruned++
 		}
 		added := 0
-		for _, key := range s.holder.Get().Gimmick.ActiveScheduleKeys(*user, now) {
+		for _, key := range eligible {
 			if len(user.Gimmick.Sequences) >= masterdata.MaxUserGimmickRows {
 				break
 			}
 			if _, exists := user.Gimmick.Sequences[key]; !exists {
 				user.Gimmick.Sequences[key] = store.GimmickSequenceState{Key: key}
 				added++
 			}
 		}
-		if added > 0 {
+		if pruned > 0 || added > 0 {
-			log.Printf("[GimmickService] InitSequenceSchedule: added %d sequences (total %d)", added, len(user.Gimmick.Sequences))
+			log.Printf("[GimmickService] InitSequenceSchedule: pruned %d stale, added %d sequences (total %d, eligible %d, cap %d)",
 				pruned, added, len(user.Gimmick.Sequences), len(eligible), masterdata.MaxUserGimmickRows)
 		}
 	})
 	return &pb.InitSequenceScheduleResponse{}, nil
@@ -198,7 +198,6 @@ func (s *QuestServiceServer) SetRoute(ctx context.Context, req *pb.SetRouteReque
 		user.MainQuest.CurrentMainQuestRouteId = req.MainQuestRouteId
 		if seasonId, ok := engine.SeasonIdByRouteId[req.MainQuestRouteId]; ok {
 			user.MainQuest.MainQuestSeasonId = seasonId
 			questflow.RecordSeasonRoute(user, seasonId, req.MainQuestRouteId, gametime.NowMillis())
 		}
 		now := gametime.NowMillis()
 		user.PortalCageStatus.IsCurrentProgress = false
@@ -8,7 +8,6 @@ const (
 	starterMissionId         = int32(1)
 	starterMainQuestRouteId  = int32(1)
 	starterMainQuestSeasonId = int32(1)
 	missionInProgress        = int32(1)
 	defaultBirthYear            = int32(2000)
 	defaultBirthMonth           = int32(1)
@@ -114,7 +113,7 @@ func SeedUserState(userId int64, uuid string, nowMillis int64, platform model.Cl
 			starterMissionId: {
 				MissionId:                 starterMissionId,
 				StartDatetime:             nowMillis,
-				MissionProgressStatusType: missionInProgress,
+				MissionProgressStatusType: int32(model.MissionProgressStatusTypeInProgress),
 			},
 		},
 		Gimmick: GimmickState{
@@ -86,7 +86,6 @@ func initMaps(u *store.UserState) {
 	u.CharacterRebirths = make(map[int32]store.CharacterRebirthState)
 	u.AutoSaleSettings = make(map[int32]store.AutoSaleSettingState)
 	u.SideStoryQuests = make(map[int32]store.SideStoryQuestProgress)
 	u.MainQuestSeasonRoutes = make(map[store.SeasonRouteKey]store.SeasonRouteEntry)
 	u.QuestLimitContentStatus = make(map[int32]store.QuestLimitContentStatus)
 	u.BigHuntMaxScores = make(map[int32]store.BigHuntMaxScore)
 	u.BigHuntStatuses = make(map[int32]store.BigHuntStatus)
@@ -378,16 +377,6 @@ func loadMapTables(db *sql.DB, uid int64, u *store.UserState) {
 		}
 	})
 	queryRows(db, `SELECT main_quest_season_id, main_quest_route_id, latest_version
 		FROM user_main_quest_season_routes WHERE user_id=?`, uid, func(rows *sql.Rows) {
 		var seasonId, routeId int32
 		var lv int64
 		rows.Scan(&seasonId, &routeId, &lv)
 		u.MainQuestSeasonRoutes[store.SeasonRouteKey{MainQuestSeasonId: seasonId, MainQuestRouteId: routeId}] = store.SeasonRouteEntry{
 			MainQuestSeasonId: seasonId, MainQuestRouteId: routeId, LatestVersion: lv,
 		}
 	})
 	queryRows(db, `SELECT limit_content_id, limit_content_quest_status_type, event_quest_chapter_id, latest_version
 		FROM user_quest_limit_content_status WHERE user_id=?`, uid, func(rows *sql.Rows) {
 		var id int32
@@ -224,12 +224,6 @@ func writeUserState(tx *sql.Tx, uid int64, u *store.UserState) error {
 			return err
 		}
 	}
 	for k, v := range u.MainQuestSeasonRoutes {
 		if err := exec(`INSERT INTO user_main_quest_season_routes (user_id, main_quest_season_id, main_quest_route_id, latest_version) VALUES (?,?,?,?)`,
 			uid, k.MainQuestSeasonId, k.MainQuestRouteId, v.LatestVersion); err != nil {
 			return err
 		}
 	}
 	for id, v := range u.QuestLimitContentStatus {
 		if err := exec(`INSERT INTO user_quest_limit_content_status (user_id, limit_content_id, limit_content_quest_status_type, event_quest_chapter_id, latest_version) VALUES (?,?,?,?,?)`,
 			uid, id, v.LimitContentQuestStatusType, v.EventQuestChapterId, v.LatestVersion); err != nil {
@@ -798,17 +792,6 @@ func diffAndSave(tx *sql.Tx, uid int64, before, after *store.UserState) error {
 			return []any{0, v.HeadSideStoryQuestSceneId, int32(v.SideStoryQuestStateType), v.LatestVersion}
 		}, "side_story_quest_id, head_side_story_quest_scene_id, side_story_quest_state_type, latest_version")
 	for k, v := range after.MainQuestSeasonRoutes {
 		if old, ok := before.MainQuestSeasonRoutes[k]; !ok || old != v {
 			exec(`INSERT OR REPLACE INTO user_main_quest_season_routes (user_id, main_quest_season_id, main_quest_route_id, latest_version) VALUES (?,?,?,?)`,
 				uid, k.MainQuestSeasonId, k.MainQuestRouteId, v.LatestVersion)
 		}
 	}
 	for k := range before.MainQuestSeasonRoutes {
 		if _, ok := after.MainQuestSeasonRoutes[k]; !ok {
 			exec(`DELETE FROM user_main_quest_season_routes WHERE user_id=? AND main_quest_season_id=? AND main_quest_route_id=?`, uid, k.MainQuestSeasonId, k.MainQuestRouteId)
 		}
 	}
 	diffMapInt32(tx, uid, before.QuestLimitContentStatus, after.QuestLimitContentStatus, "user_quest_limit_content_status", "limit_content_id",
 		func(v store.QuestLimitContentStatus) []any {
 			return []any{0, v.LimitContentQuestStatusType, v.EventQuestChapterId, v.LatestVersion}
@@ -41,7 +41,6 @@ type UserState struct {
 	LoginBonus              UserLoginBonusState
 	Tutorials               map[int32]TutorialProgressState
 	MainQuest               MainQuestState
 	MainQuestSeasonRoutes   map[SeasonRouteKey]SeasonRouteEntry
 	EventQuest              EventQuestState
 	ExtraQuest              ExtraQuestState
 	SideStoryQuests         map[int32]SideStoryQuestProgress
@@ -162,9 +161,6 @@ func (u *UserState) EnsureMaps() {
 	if u.SideStoryQuests == nil {
 		u.SideStoryQuests = make(map[int32]SideStoryQuestProgress)
 	}
 	if u.MainQuestSeasonRoutes == nil {
 		u.MainQuestSeasonRoutes = make(map[SeasonRouteKey]SeasonRouteEntry)
 	}
 	if u.QuestLimitContentStatus == nil {
 		u.QuestLimitContentStatus = make(map[int32]QuestLimitContentStatus)
 	}
@@ -590,17 +586,6 @@ type SideStoryActiveProgress struct {
 	LatestVersion                int64
 }
 type SeasonRouteKey struct {
 	MainQuestSeasonId int32
 	MainQuestRouteId  int32
 }
 type SeasonRouteEntry struct {
 	MainQuestSeasonId int32
 	MainQuestRouteId  int32
 	LatestVersion     int64
 }
 type QuestLimitContentStatus struct {
 	LimitContentQuestStatusType int32
 	EventQuestChapterId         int32
@@ -101,8 +101,9 @@ func ChangedTables(before, after *store.UserState) []string {
 		add("IUserMainQuestMainFlowStatus")
 		add("IUserMainQuestProgressStatus")
 		add("IUserMainQuestReplayFlowStatus")
-	}
+		// IUserMainQuestSeasonRoute is derived from MainQuest + Quests at projection
-	if !mapsEqualStruct(before.MainQuestSeasonRoutes, after.MainQuestSeasonRoutes) {
+		// time (see proj_quest.go / questflow.QuestHandler.SeasonRoutesFor) — flag it
 		// whenever either of those upstream inputs changes.
 		add("IUserMainQuestSeasonRoute")
 	}
 	if before.EventQuest != after.EventQuest {
@@ -202,6 +203,7 @@ func ChangedTables(before, after *store.UserState) []string {
 	}
 	if !mapsEqualStruct(before.Quests, after.Quests) {
 		add("IUserQuest")
 		add("IUserMainQuestSeasonRoute")
 	}
 	if !mapsEqualStruct(before.QuestMissions, after.QuestMissions) {
 		add("IUserQuestMission")
@@ -287,10 +289,12 @@ func ChangedTables(before, after *store.UserState) []string {
 	}
 	if !gimmickStateEqual(before.Gimmick, after.Gimmick) {
-		if !mapsEqualStruct(before.Gimmick.Progress, after.Gimmick.Progress) {
+		if !mapsEqualStruct(before.Gimmick.Progress, after.Gimmick.Progress) ||
 			!mapsEqualStruct(before.Gimmick.Sequences, after.Gimmick.Sequences) {
 			add("IUserGimmick")
 		}
-		if !mapsEqualStruct(before.Gimmick.OrnamentProgress, after.Gimmick.OrnamentProgress) {
+		if !mapsEqualStruct(before.Gimmick.OrnamentProgress, after.Gimmick.OrnamentProgress) ||
 			!mapsEqualStruct(before.Gimmick.Sequences, after.Gimmick.Sequences) {
 			add("IUserGimmickOrnamentProgress")
 		}
 		if !mapsEqualStruct(before.Gimmick.Sequences, after.Gimmick.Sequences) {
@@ -2,11 +2,21 @@ package userdata
 import (
 	"sort"
 	"sync"
 	"lunar-tear/server/internal/masterdata"
 	"lunar-tear/server/internal/store"
 	"lunar-tear/server/internal/utils"
 )
 var gimmickOrnamentRefs = sync.OnceValue(masterdata.LoadGimmickOrnamentRefs)
 var gimmickSequenceChains = sync.OnceValue(masterdata.LoadGimmickSequenceChains)
 var hiddenSequenceSet = sync.OnceValue(masterdata.LoadHiddenGimmickSequenceIDs)
 var gimmickSequenceRanks = sync.OnceValue(masterdata.LoadGimmickSequenceRanks)
 var birdGimmicks = sync.OnceValue(masterdata.LoadBirdGimmickIDs)
 const birdDefaultBaseDatetime int64 = 1577836800000 // 2020-01-01 00:00:00 UTC in ms
 func init() {
 	register("IUserGimmick", func(user store.UserState) string {
 		s, _ := utils.EncodeJSONMaps(sortedGimmickRecords(user)...)
@@ -26,9 +36,65 @@ func init() {
 	})
 }
 func projectActiveChainOrnaments(
 	user store.UserState,
 	addKey func(seqKey store.GimmickSequenceKey, seqId int32, ref masterdata.GimmickOrnamentRef),
 	sizeFn func() int,
 	cap int,
 ) {
 	refs := gimmickOrnamentRefs()
 	chains := gimmickSequenceChains()
 	hiddenSeq := hiddenSequenceSet()
 	walkChain := func(seqKey store.GimmickSequenceKey) {
 		chain := chains[seqKey.GimmickSequenceId]
 		if len(chain) == 0 {
 			chain = []int32{seqKey.GimmickSequenceId}
 		}
 		for _, seqId := range chain {
 			for _, ref := range refs[seqId] {
 				addKey(seqKey, seqId, ref)
 			}
 		}
 	}
 	var nonHidden []store.GimmickSequenceKey
 	for seqKey := range user.Gimmick.Sequences {
 		if hiddenSeq[seqKey.GimmickSequenceId] {
 			walkChain(seqKey)
 		} else {
 			nonHidden = append(nonHidden, seqKey)
 		}
 	}
 	for _, seqKey := range nonHidden {
 		if sizeFn() >= cap {
 			break
 		}
 		walkChain(seqKey)
 	}
 }
 func sortedGimmickRecords(user store.UserState) []map[string]any {
-	keys := make([]store.GimmickKey, 0, len(user.Gimmick.Progress))
+
 	keySet := make(map[store.GimmickKey]struct{})
 	// Real progress rows (genuine user data) — always kept.
 	for key := range user.Gimmick.Progress {
 		keySet[key] = struct{}{}
 	}
 	projectActiveChainOrnaments(user,
 		func(seqKey store.GimmickSequenceKey, seqId int32, ref masterdata.GimmickOrnamentRef) {
 			keySet[store.GimmickKey{
 				GimmickSequenceScheduleId: seqKey.GimmickSequenceScheduleId,
 				GimmickSequenceId:         seqId,
 				GimmickId:                 ref.GimmickId,
 			}] = struct{}{}
 		},
 		func() int { return len(keySet) },
 		masterdata.MaxUserGimmickRows,
 	)
 	keys := make([]store.GimmickKey, 0, len(keySet))
 	for key := range keySet {
 		keys = append(keys, key)
 	}
 	sort.Slice(keys, func(i, j int) bool {
@@ -37,57 +103,103 @@ func sortedGimmickRecords(user store.UserState) []map[string]any {
 	records := make([]map[string]any, 0, len(keys))
 	for _, key := range keys {
-		row := user.Gimmick.Progress[key]
+		isGimmickCleared := false
 		startDatetime := user.GameStartDatetime
 		latestVersion := user.GameStartDatetime
 		if row, ok := user.Gimmick.Progress[key]; ok {
 			isGimmickCleared = row.IsGimmickCleared
 			startDatetime = row.StartDatetime
 			latestVersion = row.LatestVersion
 		}
 		records = append(records, map[string]any{
 			"userId":                    user.UserId,
-			"gimmickSequenceScheduleId": row.Key.GimmickSequenceScheduleId,
+			"gimmickSequenceScheduleId": key.GimmickSequenceScheduleId,
-			"gimmickSequenceId":         row.Key.GimmickSequenceId,
+			"gimmickSequenceId":         key.GimmickSequenceId,
-			"gimmickId":                 row.Key.GimmickId,
+			"gimmickId":                 key.GimmickId,
-			"isGimmickCleared":          row.IsGimmickCleared,
+			"isGimmickCleared":          isGimmickCleared,
-			"startDatetime":             row.StartDatetime,
+			"startDatetime":             startDatetime,
-			"latestVersion":             row.LatestVersion,
+			"latestVersion":             latestVersion,
 		})
 	}
 	return records
 }
 func sortedGimmickOrnamentProgressRecords(user store.UserState) []map[string]any {
-	keys := make([]store.GimmickOrnamentKey, 0, len(user.Gimmick.OrnamentProgress))
+
 	keySet := make(map[store.GimmickOrnamentKey]struct{})
 	// Real progress rows (genuine user data) — always kept.
 	for key := range user.Gimmick.OrnamentProgress {
 		keySet[key] = struct{}{}
 	}
 	projectActiveChainOrnaments(user,
 		func(seqKey store.GimmickSequenceKey, seqId int32, ref masterdata.GimmickOrnamentRef) {
 			keySet[store.GimmickOrnamentKey{
 				GimmickSequenceScheduleId: seqKey.GimmickSequenceScheduleId,
 				GimmickSequenceId:         seqId,
 				GimmickId:                 ref.GimmickId,
 				GimmickOrnamentIndex:      ref.OrnamentIndex,
 			}] = struct{}{}
 		},
 		func() int { return len(keySet) },
 		masterdata.MaxUserGimmickRows,
 	)
 	keys := make([]store.GimmickOrnamentKey, 0, len(keySet))
 	for key := range keySet {
 		keys = append(keys, key)
 	}
 	sort.Slice(keys, func(i, j int) bool {
 		return compareGimmickOrnamentKey(keys[i], keys[j]) < 0
 	})
 	birdG := birdGimmicks()
 	records := make([]map[string]any, 0, len(keys))
 	for _, key := range keys {
-		row := user.Gimmick.OrnamentProgress[key]
+		progressValueBit := int32(0)
 		baseDatetime := user.GameStartDatetime
 		latestVersion := user.GameStartDatetime
 		if row, ok := user.Gimmick.OrnamentProgress[key]; ok {
 			progressValueBit = row.ProgressValueBit
 			baseDatetime = row.BaseDatetime
 			latestVersion = row.LatestVersion
 		} else if birdG[key.GimmickId] {
 			baseDatetime = birdDefaultBaseDatetime
 		}
 		records = append(records, map[string]any{
 			"userId":                    user.UserId,
-			"gimmickSequenceScheduleId": row.Key.GimmickSequenceScheduleId,
+			"gimmickSequenceScheduleId": key.GimmickSequenceScheduleId,
-			"gimmickSequenceId":         row.Key.GimmickSequenceId,
+			"gimmickSequenceId":         key.GimmickSequenceId,
-			"gimmickId":                 row.Key.GimmickId,
+			"gimmickId":                 key.GimmickId,
-			"gimmickOrnamentIndex":      row.Key.GimmickOrnamentIndex,
+			"gimmickOrnamentIndex":      key.GimmickOrnamentIndex,
-			"progressValueBit":          row.ProgressValueBit,
+			"progressValueBit":          progressValueBit,
-			"baseDatetime":              row.BaseDatetime,
+			"baseDatetime":              baseDatetime,
-			"latestVersion":             row.LatestVersion,
+			"latestVersion":             latestVersion,
 		})
 	}
 	return records
 }
 func sortedGimmickSequenceRecords(user store.UserState) []map[string]any {
 	ranks := gimmickSequenceRanks()
 	keys := make([]store.GimmickSequenceKey, 0, len(user.Gimmick.Sequences))
 	for key := range user.Gimmick.Sequences {
 		keys = append(keys, key)
 	}
 	sort.Slice(keys, func(i, j int) bool {
 		ri, rj := ranks[keys[i].GimmickSequenceId], ranks[keys[j].GimmickSequenceId]
 		if ri != rj {
 			return ri < rj
 		}
 		if keys[i].GimmickSequenceScheduleId != keys[j].GimmickSequenceScheduleId {
 			return keys[i].GimmickSequenceScheduleId < keys[j].GimmickSequenceScheduleId
 		}
 		return keys[i].GimmickSequenceId < keys[j].GimmickSequenceId
 	})
 	if len(keys) > masterdata.MaxUserGimmickRows {
 		keys = keys[:masterdata.MaxUserGimmickRows]
 	}
 	records := make([]map[string]any, 0, len(keys))
 	for _, key := range keys {
@@ -33,8 +33,26 @@ func sortedQuestRecords(user store.UserState) []map[string]any {
 }
 func sortedQuestMissionRecords(user store.UserState) []map[string]any {
-	keys := make([]store.QuestMissionKey, 0, len(user.QuestMissions))
+	questMissions := make(map[store.QuestMissionKey]store.UserQuestMissionState, len(user.QuestMissions))
-	for key := range user.QuestMissions {
+	for key, qm := range user.QuestMissions {
 		questMissions[key] = qm
 	}
 	// Force-clear hidden-story quest-missions so their report gimmicks unlock.
 	for _, key := range hiddenStoryRequirements().QuestMissions {
 		if existing, ok := questMissions[key]; ok && existing.IsClear {
 			continue
 		}
 		questMissions[key] = store.UserQuestMissionState{
 			QuestId:             key.QuestId,
 			QuestMissionId:      key.QuestMissionId,
 			IsClear:             true,
 			LatestClearDatetime: user.GameStartDatetime,
 			LatestVersion:       user.GameStartDatetime,
 		}
 	}
 	keys := make([]store.QuestMissionKey, 0, len(questMissions))
 	for key := range questMissions {
 		keys = append(keys, key)
 	}
 	sort.Slice(keys, func(i, j int) bool {
@@ -45,7 +63,7 @@ func sortedQuestMissionRecords(user store.UserState) []map[string]any {
 	})
 	records := make([]map[string]any, 0, len(keys))
 	for _, key := range keys {
-		row := user.QuestMissions[key]
+		row := questMissions[key]
 		records = append(records, map[string]any{
 			"userId":              user.UserId,
 			"questId":             row.QuestId,
@@ -98,38 +116,29 @@ func init() {
 		return s
 	})
 	register("IUserMainQuestSeasonRoute", func(user store.UserState) string {
-		if len(user.MainQuestSeasonRoutes) == 0 {
+		if questHandler == nil {
-			// Fallback to current (season, route) for legacy saves with no history.
+			return "[]"
 			s, _ := utils.EncodeJSONMaps(map[string]any{
 				"userId":            user.UserId,
 				"mainQuestSeasonId": user.MainQuest.MainQuestSeasonId,
 				"mainQuestRouteId":  user.MainQuest.CurrentMainQuestRouteId,
 				"latestVersion":     user.MainQuest.LatestVersion,
 			})
 			return s
 		}
-		keys := make([]store.SeasonRouteKey, 0, len(user.MainQuestSeasonRoutes))
+		pairs := questHandler.SeasonRoutesFor(&user)
-		for k := range user.MainQuestSeasonRoutes {
+		if len(pairs) == 0 {
-			keys = append(keys, k)
+			return "[]"
 		}
-		sort.Slice(keys, func(i, j int) bool {
+		seasons := make([]int32, 0, len(pairs))
-			if keys[i].MainQuestSeasonId != keys[j].MainQuestSeasonId {
+		for s := range pairs {
-				return keys[i].MainQuestSeasonId < keys[j].MainQuestSeasonId
+			seasons = append(seasons, s)
-			}
+		}
-			return keys[i].MainQuestRouteId < keys[j].MainQuestRouteId
+		sort.Slice(seasons, func(i, j int) bool { return seasons[i] < seasons[j] })
-		})
+		records := make([]map[string]any, 0, len(seasons))
-		records := make([]map[string]any, 0, len(keys))
+		for _, s := range seasons {
 		for _, k := range keys {
 			e := user.MainQuestSeasonRoutes[k]
 			records = append(records, map[string]any{
 				"userId":            user.UserId,
-				"mainQuestSeasonId": e.MainQuestSeasonId,
+				"mainQuestSeasonId": s,
-				"mainQuestRouteId":  e.MainQuestRouteId,
+				"mainQuestRouteId":  pairs[s],
-				"latestVersion":     e.LatestVersion,
+				"latestVersion":     user.MainQuest.LatestVersion,
 			})
 		}
-		s, _ := utils.EncodeJSONMaps(records...)
+		out, _ := utils.EncodeJSONMaps(records...)
-		return s
+		return out
 	})
 	register("IUserEventQuestProgressStatus", func(user store.UserState) string {
 		s, _ := utils.EncodeJSONMaps(map[string]any{
@@ -2,8 +2,11 @@ package userdata
 import (
 	"sort"
 	"sync"
 	"lunar-tear/server/internal/gametime"
 	"lunar-tear/server/internal/masterdata"
 	"lunar-tear/server/internal/model"
 	"lunar-tear/server/internal/store"
 	"lunar-tear/server/internal/utils"
 )
@@ -192,16 +195,35 @@ func sortedTutorialRecords(user store.UserState) []map[string]any {
 	return records
 }
 var hiddenStoryRequirements = sync.OnceValue(masterdata.LoadHiddenStoryRequirements)
 func sortedMissionRecords(user store.UserState) []map[string]any {
-	ids := make([]int, 0, len(user.Missions))
+	missions := make(map[int32]store.UserMissionState, len(user.Missions))
-	for id := range user.Missions {
+	for id, m := range user.Missions {
 		missions[id] = m
 	}
 	for _, missionId := range hiddenStoryRequirements().MissionIds {
 		if existing, ok := missions[missionId]; ok && existing.MissionProgressStatusType >= int32(model.MissionProgressStatusTypeClear) {
 			continue
 		}
 		missions[missionId] = store.UserMissionState{
 			MissionId:                 missionId,
 			StartDatetime:             user.GameStartDatetime,
 			MissionProgressStatusType: int32(model.MissionProgressStatusTypeClear),
 			ClearDatetime:             user.GameStartDatetime,
 			LatestVersion:             user.GameStartDatetime,
 		}
 	}
 	ids := make([]int, 0, len(missions))
 	for id := range missions {
 		ids = append(ids, int(id))
 	}
 	sort.Ints(ids)
 	records := make([]map[string]any, 0, len(ids))
 	for _, id := range ids {
-		row := user.Missions[int32(id)]
+		row := missions[int32(id)]
 		records = append(records, map[string]any{
 			"userId":                    user.UserId,
 			"missionId":                 row.MissionId,
@@ -3,6 +3,7 @@ package userdata
 import (
 	"sort"
 	"lunar-tear/server/internal/questflow"
 	"lunar-tear/server/internal/store"
 )
@@ -10,6 +11,12 @@ type Projector func(user store.UserState) string
 var projectors = make(map[string]Projector)
 var questHandler *questflow.QuestHandler
 func SetQuestHandler(h *questflow.QuestHandler) {
 	questHandler = h
 }
 func register(tableName string, fn Projector) {
 	projectors[tableName] = fn
 }
@@ -0,0 +1,21 @@
 package migrations
 import (
 	"context"
 	"database/sql"
 	"embed"
 	"github.com/pressly/goose/v3"
 )
 //go:embed *.sql
 var FS embed.FS
 func Up(ctx context.Context, db *sql.DB) error {
 	goose.SetBaseFS(FS)
 	goose.SetLogger(goose.NopLogger())
 	if err := goose.SetDialect("sqlite3"); err != nil {
 		return err
 	}
 	return goose.UpContext(ctx, db, ".", goose.WithAllowMissing())
 }
Author	SHA1	Message	Date
Ilya Groshev	2d0c0d8ef0	Add cross-platform prebuilt release workflow Build and Push Docker images to Docker Hub / build-and-push (push) Has been cancelled Details	2026-05-22 23:12:08 +03:00
Ilya Groshev	810adcf990	Derive main-quest season routes at projection time	2026-05-22 17:24:30 +03:00
Ilya Groshev	ef69c54949	Pair gacha costume bonuses via curated lookup table Build and Push Docker images to Docker Hub / build-and-push (push) Has been cancelled Details	2026-05-21 17:49:19 +03:00
Ilya Groshev	b65c1c5fce	Implement world-map entities Build and Push Docker images to Docker Hub / build-and-push (push) Has been cancelled Details	2026-05-21 14:15:11 +03:00