Merge branch 'main' into feature/dynasty-list-parity

# Conflicts:
#	tools/frontend-legacy-parity/playwright.config.mjs

app/game-api/src/battleSim/inMemoryTransport.ts

@@ -4,16 +4,20 @@ import type { BattleSimJobPayload, BattleSimResultPayload, BattleSimTransportRes
 import { processBattleSimJob } from './processor.js';
 
 export class InMemoryBattleSimTransport {
-    private readonly results = new Map<string, BattleSimResultPayload>();
+    private readonly results = new Map<string, { requesterUserId: string; payload: BattleSimResultPayload }>();
 
-    public async simulate(payload: BattleSimJobPayload): Promise<BattleSimTransportResponse> {
+    public async simulate(payload: BattleSimJobPayload, requesterUserId: string): Promise<BattleSimTransportResponse> {
         const jobId = crypto.randomUUID();
         const result = processBattleSimJob(payload);
-        this.results.set(jobId, result);
+        this.results.set(jobId, { requesterUserId, payload: result });
         return { status: 'completed', jobId, payload: result };
     }
 
-    public async getSimulationResult(jobId: string): Promise<BattleSimResultPayload | null> {
-        return this.results.get(jobId) ?? null;
+    public async getSimulationResult(jobId: string, requesterUserId: string): Promise<BattleSimResultPayload | null> {
+        const result = this.results.get(jobId);
+        if (!result || result.requesterUserId !== requesterUserId) {
+            return null;
+        }
+        return result.payload;
     }
 }

app/game-api/src/battleSim/redisTransport.ts

@@ -44,16 +44,16 @@ export class RedisBattleSimTransport {
         this.resultTtlSeconds = options.resultTtlSeconds;
     }
 
-    private buildResultKey(jobId: string): string {
-        return `${this.keys.resultKeyPrefix}${jobId}`;
+    private buildResultKey(jobId: string, requesterUserId: string): string {
+        return `${this.keys.resultKeyPrefix}${encodeURIComponent(requesterUserId)}:${jobId}`;
     }
 
-    private buildNotifyKey(jobId: string): string {
-        return `${this.keys.notifyKeyPrefix}${jobId}`;
+    private buildNotifyKey(jobId: string, requesterUserId: string): string {
+        return `${this.keys.notifyKeyPrefix}${encodeURIComponent(requesterUserId)}:${jobId}`;
     }
 
-    private async readResult(jobId: string): Promise<BattleSimResultPayload | null> {
-        const raw = await this.client.get(this.buildResultKey(jobId));
+    private async readResult(jobId: string, requesterUserId: string): Promise<BattleSimResultPayload | null> {
+        const raw = await this.client.get(this.buildResultKey(jobId, requesterUserId));
         if (!raw) {
             return null;
         }
@@ -64,44 +64,49 @@ export class RedisBattleSimTransport {
         }
     }
 
-    private async waitForResult(jobId: string, timeoutMs: number): Promise<BattleSimResultPayload | null> {
-        const existing = await this.readResult(jobId);
+    private async waitForResult(
+        jobId: string,
+        requesterUserId: string,
+        timeoutMs: number
+    ): Promise<BattleSimResultPayload | null> {
+        const existing = await this.readResult(jobId, requesterUserId);
         if (existing) {
             return existing;
         }
 
-        const notifyKey = this.buildNotifyKey(jobId);
+        const notifyKey = this.buildNotifyKey(jobId, requesterUserId);
         const timeoutSec = toTimeoutSeconds(timeoutMs);
         const signal = await this.client.blPop(notifyKey, timeoutSec);
         if (!parseBlPopValue(signal)) {
             return null;
         }
-        return this.readResult(jobId);
+        return this.readResult(jobId, requesterUserId);
     }
 
-    public async simulate(payload: BattleSimJobPayload): Promise<BattleSimTransportResponse> {
+    public async simulate(payload: BattleSimJobPayload, requesterUserId: string): Promise<BattleSimTransportResponse> {
         const jobId = crypto.randomUUID();
         const job = {
             jobId,
+            requesterUserId,
             requestedAt: new Date().toISOString(),
             payload,
         };
         await this.client.rPush(this.keys.queueKey, JSON.stringify(job));
 
-        const result = await this.waitForResult(jobId, this.requestTimeoutMs);
+        const result = await this.waitForResult(jobId, requesterUserId, this.requestTimeoutMs);
         if (result) {
             return { status: 'completed', jobId, payload: result };
         }
         return { status: 'queued', jobId };
     }
 
-    public async getSimulationResult(jobId: string): Promise<BattleSimResultPayload | null> {
-        return this.readResult(jobId);
+    public async getSimulationResult(jobId: string, requesterUserId: string): Promise<BattleSimResultPayload | null> {
+        return this.readResult(jobId, requesterUserId);
     }
 
-    public async pushResult(jobId: string, payload: BattleSimResultPayload): Promise<void> {
-        const resultKey = this.buildResultKey(jobId);
-        const notifyKey = this.buildNotifyKey(jobId);
+    public async pushResult(jobId: string, requesterUserId: string, payload: BattleSimResultPayload): Promise<void> {
+        const resultKey = this.buildResultKey(jobId, requesterUserId);
+        const notifyKey = this.buildNotifyKey(jobId, requesterUserId);
         await this.client.set(resultKey, JSON.stringify(payload), {
             EX: this.resultTtlSeconds,
         });

app/game-api/src/battleSim/transport.ts

@@ -1,6 +1,6 @@
 import type { BattleSimJobPayload, BattleSimResultPayload, BattleSimTransportResponse } from './types.js';
 
 export interface BattleSimTransport {
-    simulate(payload: BattleSimJobPayload): Promise<BattleSimTransportResponse>;
-    getSimulationResult(jobId: string): Promise<BattleSimResultPayload | null>;
+    simulate(payload: BattleSimJobPayload, requesterUserId: string): Promise<BattleSimTransportResponse>;
+    getSimulationResult(jobId: string, requesterUserId: string): Promise<BattleSimResultPayload | null>;
 }

app/game-api/src/battleSim/types.ts

@@ -134,6 +134,7 @@ export interface BattleSimResultPayload {
 
 export interface BattleSimJob {
     jobId: string;
+    requesterUserId: string;
     requestedAt: string;
     payload: BattleSimJobPayload;
 }

app/game-api/src/battleSim/worker.ts

@@ -18,7 +18,11 @@ const parseBlPopValue = (result: RedisBlPopResult): string | null => {
     return result.element ?? null;
 };
 
-export const runBattleSimWorker = async (): Promise<void> => {
+export interface BattleSimWorkerOptions {
+    signal?: AbortSignal;
+}
+
+export const runBattleSimWorker = async (options: BattleSimWorkerOptions = {}): Promise<void> => {
     const config = resolveGameApiConfigFromEnv();
     const redis = createRedisConnector(resolveRedisConfigFromEnv());
     await redis.connect();
@@ -30,35 +34,49 @@ export const runBattleSimWorker = async (): Promise<void> => {
         resultTtlSeconds: config.battleSimResultTtlSeconds,
     });
 
-    const handleExit = async () => {
-        await redis.disconnect();
+    let stopped = options.signal?.aborted ?? false;
+    const handleExit = () => {
+        stopped = true;
+    };
+    const handleAbort = () => {
+        stopped = true;
     };
     process.on('SIGINT', handleExit);
     process.on('SIGTERM', handleExit);
+    options.signal?.addEventListener('abort', handleAbort, { once: true });
 
-    while (true) {
-        const item = await redis.client.blPop(keys.queueKey, 0);
-        const raw = parseBlPopValue(item);
-        if (!raw) {
-            continue;
-        }
+    try {
+        while (!stopped) {
+            // A finite block lets SIGTERM and test AbortSignal stop the worker without
+            // leaving a Redis operation or a detached lifecycle process behind.
+            const item = await redis.client.blPop(keys.queueKey, 1);
+            const raw = parseBlPopValue(item);
+            if (!raw) {
+                continue;
+            }
 
-        let job: BattleSimJob | null = null;
-        try {
-            job = JSON.parse(raw) as BattleSimJob;
-        } catch {
-            continue;
-        }
+            let job: BattleSimJob | null = null;
+            try {
+                job = JSON.parse(raw) as BattleSimJob;
+            } catch {
+                continue;
+            }
 
-        try {
-            const result = processBattleSimJob(job.payload);
-            await transport.pushResult(job.jobId, result);
-        } catch (error) {
-            const reason = error instanceof Error ? error.message : '전투 시뮬레이션 오류';
-            await transport.pushResult(job.jobId, {
-                result: false,
-                reason,
-            });
+            try {
+                const result = processBattleSimJob(job.payload);
+                await transport.pushResult(job.jobId, job.requesterUserId, result);
+            } catch (error) {
+                const reason = error instanceof Error ? error.message : '전투 시뮬레이션 오류';
+                await transport.pushResult(job.jobId, job.requesterUserId, {
+                    result: false,
+                    reason,
+                });
+            }
         }
+    } finally {
+        process.off('SIGINT', handleExit);
+        process.off('SIGTERM', handleExit);
+        options.signal?.removeEventListener('abort', handleAbort);
+        await redis.disconnect();
     }
 };

app/game-api/src/index.ts

@@ -30,6 +30,9 @@ export * from './auction/types.js';
 export * from './auction/keys.js';
 export * from './auction/scheduler.js';
 export * from './auction/worker.js';
+export * from './tournament/keys.js';
+export * from './tournament/store.js';
+export * from './tournament/types.js';
 export * from './tournament/worker.js';
 
 // Types for TRPC consumer

app/game-api/src/messages/targets.ts

@@ -23,13 +23,14 @@ export const resolveNationInfo = async (
 
 export const buildTargetFromGeneral = async (db: DatabaseClient, general: GeneralRow): Promise<MessageTarget> => {
     const nation = await resolveNationInfo(db, general.nationId);
+    const picture = general.picture?.trim() || 'default.jpg';
     return {
         generalId: general.id,
         generalName: general.name,
         nationId: general.nationId,
         nationName: nation.name,
         color: nation.color,
-        icon: '',
+        icon: general.imageServer ? `d_pic/${picture}` : `/image/icons/${picture}`,
     };
 };
 

app/game-api/src/router/battle/index.ts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import { asRecord } from '@sammo-ts/common';
 import { getDexLevel } from '@sammo-ts/logic';
 
-import { authedProcedure, procedure, router } from '../../trpc.js';
+import { authedProcedure, readOnlyAuthedProcedure, router } from '../../trpc.js';
 import { buildBattleSimEnvironment, buildBattleSimJobPayload } from '../../battleSim/environment.js';
 import { zBattleSimJobId, zBattleSimRequest } from '../../battleSim/schema.js';
 import {
@@ -30,6 +30,14 @@ const normalizeOptionalKey = (value: string | null): string | null => {
     return value;
 };
 
+const getAuthenticatedUserId = (auth: { user: { id: string } } | null): string => {
+    const userId = auth?.user.id;
+    if (!userId) {
+        throw new TRPCError({ code: 'UNAUTHORIZED', message: 'Unauthorized' });
+    }
+    return userId;
+};
+
 const resolveExpLevel = (meta: Record<string, unknown>, experience: number): number => {
     const expLevel = meta.explevel ?? meta.expLevel;
     if (typeof expLevel === 'number' && Number.isFinite(expLevel)) {
@@ -48,7 +56,7 @@ const resolveDexValue = (meta: Record<string, unknown>, key: string): number =>
 };
 
 export const battleRouter = router({
-    simulate: procedure.input(zBattleSimRequest).mutation(async ({ ctx, input }) => {
+    simulate: readOnlyAuthedProcedure.input(zBattleSimRequest).mutation(async ({ ctx, input }) => {
         const worldState = await ctx.db.worldState.findFirst();
         if (!worldState) {
             throw new TRPCError({
@@ -58,10 +66,10 @@ export const battleRouter = router({
         }
 
         const payload = await buildBattleSimJobPayload(worldState, input, ctx.profile.id);
-        return ctx.battleSim.simulate(payload);
+        return ctx.battleSim.simulate(payload, getAuthenticatedUserId(ctx.auth));
     }),
-    getSimulation: procedure.input(zBattleSimJobId).query(async ({ ctx, input }) => {
-        const result = await ctx.battleSim.getSimulationResult(input.jobId);
+    getSimulation: readOnlyAuthedProcedure.input(zBattleSimJobId).query(async ({ ctx, input }) => {
+        const result = await ctx.battleSim.getSimulationResult(input.jobId, getAuthenticatedUserId(ctx.auth));
         if (!result) {
             return { status: 'queued', jobId: input.jobId };
         }

app/game-api/src/router/general/index.ts

@@ -37,15 +37,19 @@ const normalizeItemCode = (value: string | null): string | null => {
 };
 
 const resolveUserSettings = (meta: Record<string, unknown>) => {
-    const settings = asRecord(meta.userSettings);
-    const mysetRaw = settings.myset;
+    // The legacy general columns are persisted at the top level of General.meta.
+    // Keep reading the short-lived nested shape for installations that ran the
+    // initial rewrite implementation before this compatibility fix.
+    const nestedSettings = asRecord(meta.userSettings);
+    const readSetting = (key: string): unknown => meta[key] ?? nestedSettings[key];
+    const mysetRaw = readSetting('myset');
     const myset = typeof mysetRaw === 'number' && Number.isFinite(mysetRaw) ? mysetRaw : null;
 
     return {
-        tnmt: readNumber(settings.tnmt, 1),
-        defence_train: readNumber(settings.defence_train, 80),
-        use_treatment: readNumber(settings.use_treatment, 10),
-        use_auto_nation_turn: readNumber(settings.use_auto_nation_turn, 1),
+        tnmt: readNumber(readSetting('tnmt'), 1),
+        defence_train: readNumber(readSetting('defence_train'), 80),
+        use_treatment: readNumber(readSetting('use_treatment'), 10),
+        use_auto_nation_turn: readNumber(readSetting('use_auto_nation_turn'), 1),
         myset,
     };
 };
@@ -262,29 +266,6 @@ export const generalRouter = router({
             throw new TRPCError({ code: 'BAD_REQUEST', message: result.reason });
         }
 
-        const metaRecord = asRecord(general.meta);
-        const prevSettings = asRecord(metaRecord.userSettings);
-        const prevMyset = typeof prevSettings.myset === 'number' && Number.isFinite(prevSettings.myset)
-            ? prevSettings.myset
-            : null;
-        const nextSettings = {
-            ...prevSettings,
-            ...input,
-        } as Record<string, unknown>;
-        if (typeof prevMyset === 'number') {
-            nextSettings.myset = Math.max(0, prevMyset - 1);
-        }
-
-        await ctx.db.general.update({
-            where: { id: general.id },
-            data: {
-                meta: {
-                    ...metaRecord,
-                    userSettings: nextSettings,
-                },
-            } as any,
-        });
-
         return { ok: true };
     }),
     dropItem: authedProcedure.input(z.object({ itemType: z.string() })).mutation(async ({ ctx, input }) => {

app/game-api/src/router/inherit/index.ts

@@ -3,7 +3,14 @@ import { z } from 'zod';
 
 import { authedProcedure, router } from '../../trpc.js';
 import { asNumber, asRecord, parseJson, LiteHashDRBG } from '@sammo-ts/common';
-import { loadWarTraitModules, WarTraitLoader, WAR_TRAIT_KEYS, isWarTraitKey } from '@sammo-ts/logic';
+import {
+    ItemLoader,
+    isItemKey,
+    loadWarTraitModules,
+    WarTraitLoader,
+    WAR_TRAIT_KEYS,
+    isWarTraitKey,
+} from '@sammo-ts/logic';
 import type { InheritBuffType } from '@sammo-ts/logic';
 import {
     appendInheritanceLog,
@@ -23,8 +30,8 @@ const BUFF_KEYS: InheritBuffType[] = [
     'warAvoidRatio',
     'warCriticalRatio',
     'warMagicTrialProb',
-    'success',
-    'fail',
+    'domesticSuccessProb',
+    'domesticFailProb',
     'warAvoidRatioOppose',
     'warCriticalRatioOppose',
     'warMagicTrialProbOppose',
@@ -34,8 +41,8 @@ const BUFF_LABELS: Record<InheritBuffType, string> = {
     warAvoidRatio: '회피 확률 증가',
     warCriticalRatio: '필살 확률 증가',
     warMagicTrialProb: '전투계략 시도 확률 증가',
-    success: '내정 성공률 증가',
-    fail: '내정 실패율 감소',
+    domesticSuccessProb: '내정 성공률 증가',
+    domesticFailProb: '내정 실패율 감소',
     warAvoidRatioOppose: '상대 회피 확률 감소',
     warCriticalRatioOppose: '상대 필살 확률 감소',
     warMagicTrialProbOppose: '상대 전투계략 시도 확률 감소',
@@ -58,6 +65,37 @@ const parseBuffRecord = (raw: unknown): Record<string, number> => {
 
 const serializeBuffRecord = (buff: Record<string, number>): string => JSON.stringify(buff);
 
+const readBuffLevel = (buff: Record<string, number>, key: InheritBuffType): number => {
+    const compatibilityKey = key === 'domesticSuccessProb' ? 'success' : key === 'domesticFailProb' ? 'fail' : null;
+    return Math.max(0, Math.min(5, Math.floor(buff[key] ?? (compatibilityKey ? buff[compatibilityKey] : 0) ?? 0)));
+};
+
+const loadAvailableUniqueItems = async (worldState: WorldStateRow) => {
+    const configuredItems = asRecord(asRecord(worldState.config).const).allItems;
+    const enabledKeys: Array<Parameters<ItemLoader['load']>[0]> = [];
+    for (const entries of Object.values(asRecord(configuredItems))) {
+        for (const [key, amount] of Object.entries(asRecord(entries))) {
+            if (asNumber(amount, 0) !== 0 && isItemKey(key)) {
+                enabledKeys.push(key);
+            }
+        }
+    }
+
+    const loader = new ItemLoader();
+    const items = await Promise.all(
+        [...new Set(enabledKeys)].map(async (key) => {
+            const item = await loader.load(key);
+            return {
+                key,
+                name: item.name,
+                rawName: item.rawName,
+                info: item.info ?? '',
+            };
+        })
+    );
+    return items.sort((left, right) => left.name.localeCompare(right.name, 'ko'));
+};
+
 const resolveWorld = async (ctx: { db: { worldState: { findFirst: () => Promise<unknown> } } }) => {
     const worldState = await ctx.db.worldState.findFirst();
     if (!worldState || typeof worldState !== 'object') {
@@ -199,6 +237,9 @@ export const inheritRouter = router({
                 special2Code: true,
                 meta: true,
                 turnTime: true,
+                leadership: true,
+                strength: true,
+                intel: true,
             },
         });
 
@@ -219,7 +260,7 @@ export const inheritRouter = router({
         const inheritConst = resolveInheritConstants(worldState);
         const buffState = parseBuffRecord(asRecord(general.meta).inheritBuff);
         const buffLevels = BUFF_KEYS.reduce<Record<string, number>>((acc, key) => {
-            acc[key] = Math.max(0, Math.min(5, Math.floor(buffState[key] ?? 0)));
+            acc[key] = readBuffLevel(buffState, key);
             return acc;
         }, {});
 
@@ -240,11 +281,14 @@ export const inheritRouter = router({
             info: trait.info ?? '',
         }));
 
-        const others = await ctx.db.general.findMany({
-            where: { id: { not: general.id }, userId: { not: null } },
-            select: { id: true, name: true },
-            orderBy: { id: 'asc' },
-        });
+        const [others, availableUnique] = await Promise.all([
+            ctx.db.general.findMany({
+                where: { id: { not: general.id }, npcState: { lt: 2 }, userId: { not: null } },
+                select: { id: true, name: true },
+                orderBy: { id: 'asc' },
+            }),
+            loadAvailableUniqueItems(worldState),
+        ]);
 
         return {
             items,
@@ -260,10 +304,16 @@ export const inheritRouter = router({
                 resetTurnTime: resetTurnLevel,
             },
             availableSpecialWar: warSpecials,
+            availableUnique,
             availableTargetGenerals: others,
             turnTimeZones: buildTurnTimeZoneList(Math.max(1, Math.round(worldState.tickSeconds / 60))),
             isUnited,
             currentSpecialWar: general.special2Code ?? 'None',
+            currentStat: {
+                leadership: general.leadership,
+                strength: general.strength,
+                intel: general.intel,
+            },
         };
     }),
     getLogs: authedProcedure
@@ -285,7 +335,7 @@ export const inheritRouter = router({
                 },
                 orderBy: { id: 'desc' },
                 take: 30,
-                select: { id: true, year: true, month: true, text: true },
+                select: { id: true, year: true, month: true, text: true, createdAt: true },
             });
             return logs;
         }),
@@ -318,7 +368,7 @@ export const inheritRouter = router({
             }
 
             const buff = parseBuffRecord(asRecord(general.meta).inheritBuff);
-            const prevLevel = Math.max(0, Math.min(5, Math.floor(buff[input.type] ?? 0)));
+            const prevLevel = readBuffLevel(buff, input.type);
             if (input.level === prevLevel) {
                 throw new TRPCError({ code: 'BAD_REQUEST', message: '이미 구입했습니다.' });
             }
@@ -417,7 +467,12 @@ export const inheritRouter = router({
                 },
             });
 
-            await setInheritancePoint(ctx.db, userId, 'previous', currentPoint - inheritConst.inheritSpecificSpecialPoint);
+            await setInheritancePoint(
+                ctx.db,
+                userId,
+                'previous',
+                currentPoint - inheritConst.inheritSpecificSpecialPoint
+            );
             await appendInheritanceLog(
                 ctx.db,
                 userId,
@@ -460,7 +515,8 @@ export const inheritRouter = router({
         }
 
         const meta = asRecord(general.meta);
-        const prevList = parseJson<string[]>(typeof meta.prev_types_special2 === 'string' ? meta.prev_types_special2 : null) ?? [];
+        const prevList =
+            parseJson<string[]>(typeof meta.prev_types_special2 === 'string' ? meta.prev_types_special2 : null) ?? [];
         prevList.push(general.special2Code);
 
         await patchGeneral(ctx, general.id, {
@@ -473,7 +529,13 @@ export const inheritRouter = router({
         });
 
         await setInheritancePoint(ctx.db, userId, 'previous', currentPoint - cost);
-        await appendInheritanceLog(ctx.db, userId, worldState.currentYear, worldState.currentMonth, `${cost} 포인트로 전투 특기 초기화`);
+        await appendInheritanceLog(
+            ctx.db,
+            userId,
+            worldState.currentYear,
+            worldState.currentMonth,
+            `${cost} 포인트로 전투 특기 초기화`
+        );
         return { ok: true };
     }),
     resetTurnTime: authedProcedure.mutation(async ({ ctx }) => {
@@ -624,9 +686,7 @@ export const inheritRouter = router({
             const finalBonus =
                 bonusSum === 0
                     ? buildRandomBonus(
-                          new LiteHashDRBG(
-                              `${asRecord(worldState.meta).hiddenSeed ?? 'inherit'}:ResetStat:${userId}`
-                          ),
+                          new LiteHashDRBG(`${asRecord(worldState.meta).hiddenSeed ?? 'inherit'}:ResetStat:${userId}`),
                           [input.leadership, input.strength, input.intel]
                       )
                     : (bonus as [number, number, number]);
@@ -674,9 +734,7 @@ export const inheritRouter = router({
             if (seasonValue !== null) {
                 const userState = await readUserStateMeta(ctx.db, userId);
                 const resetSeasons = readResetSeasons(userState);
-                const nextSeasons = resetSeasons.includes(seasonValue)
-                    ? resetSeasons
-                    : [...resetSeasons, seasonValue];
+                const nextSeasons = resetSeasons.includes(seasonValue) ? resetSeasons : [...resetSeasons, seasonValue];
                 await writeUserStateMeta(ctx.db, userId, {
                     ...userState,
                     last_stat_reset: nextSeasons,
@@ -709,7 +767,10 @@ export const inheritRouter = router({
         }
         const meta = asRecord(general.meta);
         if (meta.inheritRandomUnique !== undefined && meta.inheritRandomUnique !== null) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: '이미 구입 명령을 내렸습니다. 다음 턴까지 기다려주세요.' });
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: '이미 구입 명령을 내렸습니다. 다음 턴까지 기다려주세요.',
+            });
         }
 
         await patchGeneral(ctx, general.id, {
@@ -803,7 +864,9 @@ export const inheritRouter = router({
                 throw new TRPCError({ code: 'BAD_REQUEST', message: '자신의 정보는 확인할 수 없습니다.' });
             }
 
-            const ownerName = typeof asRecord(target.meta).ownerName === 'string' ? (asRecord(target.meta).ownerName as string) : target.userId;
+            const rawOwnerName = asRecord(target.meta).ownerName;
+            const ownerName =
+                typeof rawOwnerName === 'string' && rawOwnerName.trim().length > 0 ? rawOwnerName : '알수없음';
 
             await setInheritancePoint(ctx.db, userId, 'previous', currentPoint - inheritConst.inheritCheckOwnerPoint);
             await appendInheritanceLog(

app/game-api/src/router/messages/index.ts

@@ -1,5 +1,7 @@
 import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
+import { asRecord } from '@sammo-ts/common';
+import type { UserSanctions } from '@sammo-ts/common/auth/gameToken';
 
 import { authedProcedure, router } from '../../trpc.js';
 import {
@@ -26,6 +28,75 @@ import { respondToDiplomaticMessage } from '../../messages/diplomaticResponse.js
 
 const zMessageType = z.enum(['private', 'public', 'national', 'diplomacy']);
 
+const redactDiplomacyMessages = (messages: MessageView[], permission: number): MessageView[] => {
+    if (permission >= 3) {
+        return messages;
+    }
+    return messages.map((message) => {
+        if (!message.dest || message.dest.nationId === 0) {
+            return message;
+        }
+        return {
+            ...message,
+            text: '(외교 메시지입니다)',
+            option: {
+                ...(message.option ?? {}),
+                invalid: true,
+            },
+        };
+    });
+};
+
+const isFutureDate = (value: string | undefined, now = Date.now()): boolean => {
+    if (!value) {
+        return false;
+    }
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) && parsed > now;
+};
+
+const isMessageFeatureBlocked = (sanctions: UserSanctions, profileNames: string[]): boolean => {
+    if (
+        isFutureDate(sanctions.mutedUntil) ||
+        isFutureDate(sanctions.suspendedUntil) ||
+        isFutureDate(sanctions.bannedUntil)
+    ) {
+        return true;
+    }
+    for (const profileName of profileNames) {
+        const restriction = sanctions.serverRestrictions?.[profileName];
+        if (!restriction) {
+            continue;
+        }
+        if (restriction.until && !isFutureDate(restriction.until)) {
+            continue;
+        }
+        if (restriction.blockedFeatures?.includes('messages')) {
+            return true;
+        }
+    }
+    return false;
+};
+
+const readPenaltyNumber = (penalty: unknown, key: string, fallback: number): number => {
+    const value = asRecord(penalty)[key];
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+};
+
+const hasPenalty = (penalty: unknown, key: string): boolean => {
+    const value = asRecord(penalty)[key];
+    return value === true || value === 1 || value === '1';
+};
+
 export const messagesRouter = router({
     getRecent: authedProcedure
         .input(
@@ -85,11 +156,12 @@ export const messagesRouter = router({
                         : null,
                 ]);
 
+            const permission = nationId > 0 && nation ? resolveNationPermission(general, nation.meta, false) : -1;
             const messageBuckets: Record<MessageType, MessageView[]> = {
                 private: privateMessages,
                 public: publicMessages,
                 national: nationalMessages,
-                diplomacy: diplomacyMessages,
+                diplomacy: redactDiplomacyMessages(diplomacyMessages, permission),
             };
 
             let nextSequence = sequence;
@@ -128,10 +200,8 @@ export const messagesRouter = router({
                 sequence: nextSequence,
                 nationId: nationId,
                 generalName: general.name,
-                canRespondDiplomacy:
-                    general.officerLevel > 4 &&
-                    nation !== null &&
-                    resolveNationPermission(general, nation.meta, false) >= 4,
+                permission,
+                canRespondDiplomacy: permission >= 4 && general.officerLevel > 4,
                 latestRead: {
                     diplomacy: readState?.latestDiplomacyMessage ?? 0,
                     private: readState?.latestPrivateMessage ?? 0,
@@ -178,6 +248,7 @@ export const messagesRouter = router({
             ];
             return {
                 nation: nationList.map((nation) => ({
+                    nationId: nation.id,
                     mailbox: MESSAGE_MAILBOX_NATIONAL_BASE + nation.id,
                     name: nation.name,
                     color: nation.color,
@@ -234,14 +305,24 @@ export const messagesRouter = router({
             if (message.payload.src.generalId !== general.id) {
                 throw new TRPCError({ code: 'FORBIDDEN', message: '본인의 메시지만 삭제할 수 있습니다.' });
             }
-            if (message.msgType === 'diplomacy' || message.payload.option?.deletable === false) {
+            if (message.msgType === 'diplomacy' && message.payload.option?.action) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: '시스템 외교 메시지는 삭제할 수 없습니다.',
+                });
+            }
+            if (message.payload.option?.deletable === false) {
                 throw new TRPCError({ code: 'BAD_REQUEST', message: '삭제할 수 없는 메시지입니다.' });
             }
             if (Date.now() - message.time.getTime() > 5 * 60 * 1000) {
                 throw new TRPCError({ code: 'BAD_REQUEST', message: '5분 이내의 메시지만 삭제할 수 있습니다.' });
             }
             const receiverMessageId = message.payload.option?.receiverMessageID;
-            const ids = [message.id, ...(typeof receiverMessageId === 'number' ? [receiverMessageId] : [])];
+            const shouldDeleteReceiverCopy = message.msgType === 'private' || message.msgType === 'national';
+            const ids = [
+                message.id,
+                ...(shouldDeleteReceiverCopy && typeof receiverMessageId === 'number' ? [receiverMessageId] : []),
+            ];
             await invalidateMessages(ctx.db, ids);
             return { ok: true, deletedIds: ids };
         }),
@@ -291,6 +372,14 @@ export const messagesRouter = router({
             const general = await getOwnedGeneral(ctx, input.generalId);
 
             const nationId = general.nationId;
+            const nation =
+                nationId > 0
+                    ? await ctx.db.nation.findUnique({
+                          where: { id: nationId },
+                          select: { meta: true },
+                      })
+                    : null;
+            const permission = nationId > 0 && nation ? resolveNationPermission(general, nation.meta, false) : -1;
             const mailboxes = {
                 private: general.id,
                 public: MESSAGE_MAILBOX_PUBLIC,
@@ -312,7 +401,8 @@ export const messagesRouter = router({
                 toSeq: input.to,
                 limit: 15,
             });
-            messageBuckets[input.type] = messages;
+            messageBuckets[input.type] =
+                input.type === 'diplomacy' ? redactDiplomacyMessages(messages, permission) : messages;
 
             return {
                 result: true,
@@ -320,6 +410,7 @@ export const messagesRouter = router({
                 sequence: 0,
                 nationId,
                 generalName: general.name,
+                permission,
                 ...messageBuckets,
             };
         }),
@@ -333,6 +424,12 @@ export const messagesRouter = router({
         )
         .mutation(async ({ ctx, input }) => {
             const general = await getOwnedGeneral(ctx, input.generalId);
+            if (!ctx.auth || isMessageFeatureBlocked(ctx.auth.sanctions, [ctx.profile.name, ctx.profile.id])) {
+                throw new TRPCError({
+                    code: 'FORBIDDEN',
+                    message: '메시지 전송이 제한된 계정입니다.',
+                });
+            }
 
             const src = await buildTargetFromGeneral(ctx.db, general);
             const now = new Date();
@@ -340,28 +437,93 @@ export const messagesRouter = router({
 
             let msgType: MessageType;
             let dest = src;
+            let receiverMailbox = input.mailbox;
 
             if (input.mailbox === MESSAGE_MAILBOX_PUBLIC) {
-                msgType = 'public';
-            } else if (input.mailbox >= MESSAGE_MAILBOX_NATIONAL_BASE) {
-                const destNationId = input.mailbox - MESSAGE_MAILBOX_NATIONAL_BASE;
-                if (destNationId <= 0) {
+                if (hasPenalty(general.penalty, 'noSendPublicMsg')) {
                     throw new TRPCError({
-                        code: 'BAD_REQUEST',
-                        message: 'Invalid nation mailbox.',
+                        code: 'FORBIDDEN',
+                        message: '공개 메세지를 보낼 수 없습니다.',
                     });
                 }
+                msgType = 'public';
+            } else if (input.mailbox >= MESSAGE_MAILBOX_NATIONAL_BASE) {
+                const sourceNation =
+                    general.nationId > 0
+                        ? await ctx.db.nation.findUnique({
+                              where: { id: general.nationId },
+                              select: { meta: true },
+                          })
+                        : null;
+                const permission =
+                    general.nationId > 0 && sourceNation ? resolveNationPermission(general, sourceNation.meta) : -1;
+                const destNationId = permission < 4 ? general.nationId : input.mailbox - MESSAGE_MAILBOX_NATIONAL_BASE;
                 const nationInfo = await resolveNationInfo(ctx.db, destNationId);
+                if (destNationId > 0) {
+                    const destNation = await ctx.db.nation.findUnique({ where: { id: destNationId } });
+                    if (!destNation) {
+                        throw new TRPCError({
+                            code: 'NOT_FOUND',
+                            message: '존재하지 않는 국가입니다.',
+                        });
+                    }
+                }
                 dest = buildNationTarget(destNationId, nationInfo.name, nationInfo.color);
                 msgType = destNationId === general.nationId ? 'national' : 'diplomacy';
+                receiverMailbox = MESSAGE_MAILBOX_NATIONAL_BASE + destNationId;
             } else if (input.mailbox > 0) {
+                if (hasPenalty(general.penalty, 'noSendPrivateMsg')) {
+                    throw new TRPCError({
+                        code: 'FORBIDDEN',
+                        message: '개인 메세지를 보낼 수 없습니다.',
+                    });
+                }
+                const intervalSeconds = Math.max(
+                    0,
+                    Math.ceil(readPenaltyNumber(general.penalty, 'sendPrivateMsgDelay', 2))
+                );
+                if (intervalSeconds > 0) {
+                    const rateLimitKey = `game:${ctx.profile.name}:message:private:${ctx.auth.sessionId}`;
+                    const acquired = await ctx.redis.set(rateLimitKey, '1', {
+                        NX: true,
+                        PX: intervalSeconds * 1000,
+                    });
+                    if (acquired === null) {
+                        throw new TRPCError({
+                            code: 'TOO_MANY_REQUESTS',
+                            message: `개인메세지는 ${intervalSeconds}초당 1건만 보낼 수 있습니다!`,
+                        });
+                    }
+                }
                 const destGeneral = await ctx.db.general.findUnique({
                     where: { id: input.mailbox },
                 });
                 if (!destGeneral) {
                     throw new TRPCError({
                         code: 'NOT_FOUND',
-                        message: 'Destination general not found.',
+                        message: '존재하지 않는 유저입니다.',
+                    });
+                }
+                const [sourceNation, destNation] = await Promise.all([
+                    general.nationId > 0
+                        ? ctx.db.nation.findUnique({ where: { id: general.nationId }, select: { meta: true } })
+                        : null,
+                    destGeneral.nationId > 0
+                        ? ctx.db.nation.findUnique({ where: { id: destGeneral.nationId }, select: { meta: true } })
+                        : null,
+                ]);
+                const sourcePermission =
+                    sourceNation && general.nationId > 0
+                        ? resolveNationPermission(general, sourceNation.meta, false)
+                        : -1;
+                const destPermission =
+                    destNation && destGeneral.nationId > 0
+                        ? resolveNationPermission(destGeneral, destNation.meta, false)
+                        : -1;
+                if (sourcePermission === 4 && destPermission === 4 && destGeneral.nationId !== general.nationId) {
+                    throw new TRPCError({
+                        code: 'FORBIDDEN',
+                        message: '외교권자끼리는 메시지를 보낼 수 없습니다.',
                     });
                 }
                 dest = await buildTargetFromGeneral(ctx.db, destGeneral);
@@ -394,7 +556,7 @@ export const messagesRouter = router({
                 await publishRealtimeEvent(ctx.redis, ctx.profile.name, {
                     type: 'messageCreated',
                     at: now.toISOString(),
-                    mailbox: input.mailbox,
+                    mailbox: receiverMailbox,
                     msgType,
                     messageId: result.receiverId,
                     senderId: general.id,

app/game-api/src/router/nation/endpoints/getGeneralList.ts

@@ -2,7 +2,21 @@ import { TRPCError } from '@trpc/server';
 
 import { authedProcedure } from '../../../trpc.js';
 import { getMyGeneral } from '../../shared/general.js';
-import { assertNationAccess, loadTraitNames, mapGeneralList, resolveChiefStatMin } from '../shared.js';
+import {
+    assertNationAccess,
+    loadTraitNames,
+    mapGeneralList,
+    resolveChiefStatMin,
+    resolveNationPermission,
+} from '../shared.js';
+
+const experienceLevel = (experience: number): number =>
+    Math.max(
+        0,
+        Math.min(100, experience < 1000 ? Math.floor(experience / 100) : Math.floor(Math.sqrt(experience / 10)))
+    );
+const dedicationLevel = (dedication: number): number =>
+    Math.max(0, Math.min(10, Math.ceil(Math.sqrt(dedication) / 10)));
 
 export const getGeneralList = authedProcedure.query(async ({ ctx }) => {
     const general = await getMyGeneral(ctx);
@@ -62,7 +76,38 @@ export const getGeneralList = authedProcedure.query(async ({ ctx }) => {
     const cityNameMap = new Map(cityRows.map((city) => [city.id, city.name]));
     const troopNameMap = new Map(troopRows.map((troop) => [troop.troopLeaderId, troop.name]));
     const list = await mapGeneralList(generalRows, cityNameMap, troopNameMap);
+    const accessRows = generalRows.length
+        ? await ctx.db.generalAccessLog.findMany({
+              where: { generalId: { in: generalRows.map((entry) => entry.id) } },
+              select: { generalId: true, refreshScoreTotal: true },
+          })
+        : [];
+    const accessByGeneral = new Map(accessRows.map((entry) => [entry.generalId, entry.refreshScoreTotal]));
     const nationTrait = (await loadTraitNames([nation.typeCode], 'nation')).get(nation.typeCode);
+    const permission = resolveNationPermission(general, nation.meta, true);
+    const visibleList = list.map((entry) => {
+        const { permission: _targetPermission, ...safeEntry } = entry;
+        if (permission >= 1) {
+            return {
+                ...safeEntry,
+                refreshScoreTotal: accessByGeneral.get(entry.id) ?? 0,
+                experienceLevel: experienceLevel(entry.experience),
+                dedicationLevel: dedicationLevel(entry.dedication),
+            };
+        }
+        const { crew: _crew, experience: _experience, dedication: _dedication, ...visible } = safeEntry;
+        return {
+            ...visible,
+            refreshScoreTotal: accessByGeneral.get(entry.id) ?? 0,
+            officerLevel: entry.officerLevel >= 5 ? entry.officerLevel : Math.min(1, entry.officerLevel),
+            cityName: null,
+            troopName: null,
+            officerCity: 0,
+            officerCityName: null,
+            experienceLevel: experienceLevel(entry.experience),
+            dedicationLevel: dedicationLevel(entry.dedication),
+        };
+    });
 
     return {
         nation: {
@@ -79,6 +124,7 @@ export const getGeneralList = authedProcedure.query(async ({ ctx }) => {
             capitalCityId: nation.capitalCityId ?? 0,
         },
         chiefStatMin: resolveChiefStatMin(worldState),
-        generals: list,
+        viewer: { generalId: general.id, permission },
+        generals: visibleList,
     };
 });

app/game-api/src/router/nation/endpoints/getSecretGeneralList.ts

@@ -0,0 +1,141 @@
+import { TRPCError } from '@trpc/server';
+
+import { asRecord } from '@sammo-ts/common';
+
+import { authedProcedure } from '../../../trpc.js';
+import { getMyGeneral } from '../../shared/general.js';
+import { assertNationAccess, resolveNationPermission } from '../shared.js';
+
+const readNumber = (record: Record<string, unknown>, keys: string[], fallback = 0): number => {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === 'number' && Number.isFinite(value)) return value;
+    }
+    return fallback;
+};
+const woundedStat = (value: number, injury: number): number =>
+    injury > 0 ? Math.floor((value * (100 - injury)) / 100) : value;
+const experienceLevel = (experience: number): number =>
+    Math.max(
+        0,
+        Math.min(100, experience < 1000 ? Math.floor(experience / 100) : Math.floor(Math.sqrt(experience / 10)))
+    );
+const leadershipBonus = (officerLevel: number, nationLevel: number): number =>
+    officerLevel === 12 ? nationLevel * 2 : officerLevel >= 5 ? nationLevel : 0;
+const defenceTrainText = (value: number): string =>
+    value === 999 ? '×' : value >= 90 ? '☆' : value >= 80 ? '◎' : value >= 60 ? '○' : '△';
+
+export const getSecretGeneralList = authedProcedure.query(async ({ ctx }) => {
+    const me = await getMyGeneral(ctx);
+    assertNationAccess(me);
+    const nation = await ctx.db.nation.findUnique({
+        where: { id: me.nationId },
+        select: { id: true, name: true, color: true, level: true, meta: true },
+    });
+    if (!nation) throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
+    const permission = resolveNationPermission(me, nation.meta, true);
+    if (permission < 1) {
+        throw new TRPCError({
+            code: 'FORBIDDEN',
+            message: '권한이 부족합니다. 수뇌부가 아니거나 사관년도가 부족합니다.',
+        });
+    }
+
+    const [cities, troops, generalRows] = await Promise.all([
+        ctx.db.city.findMany({ select: { id: true, name: true } }),
+        ctx.db.troop.findMany({
+            where: { nationId: me.nationId },
+            select: { troopLeaderId: true, name: true },
+        }),
+        ctx.db.general.findMany({
+            where: { nationId: me.nationId },
+            orderBy: [{ turnTime: 'asc' }, { id: 'asc' }],
+        }),
+    ]);
+    const generalIds = generalRows.map((general) => general.id);
+    const turns = generalIds.length
+        ? await ctx.db.generalTurn.findMany({
+              where: { generalId: { in: generalIds }, turnIdx: { lt: 5 } },
+              select: { generalId: true, turnIdx: true, actionCode: true },
+              orderBy: [{ generalId: 'asc' }, { turnIdx: 'asc' }],
+          })
+        : [];
+    const cityNames = new Map(cities.map((city) => [city.id, city.name]));
+    const troopNames = new Map(troops.map((troop) => [troop.troopLeaderId, troop.name]));
+    const turnMap = new Map<number, string[]>();
+    for (const turn of turns) {
+        const list = turnMap.get(turn.generalId) ?? [];
+        list[turn.turnIdx] = turn.actionCode;
+        turnMap.set(turn.generalId, list);
+    }
+    const generals = generalRows.map((general) => {
+        const meta = asRecord(general.meta);
+        const defenceTrain = readNumber(meta, ['defenceTrain', 'defence_train'], 80);
+        return {
+            id: general.id,
+            name: general.name,
+            npcState: general.npcState,
+            injury: general.injury,
+            stats: {
+                leadership: woundedStat(general.leadership, general.injury),
+                strength: woundedStat(general.strength, general.injury),
+                intelligence: woundedStat(general.intel, general.injury),
+            },
+            leadershipBonus: leadershipBonus(general.officerLevel, nation.level),
+            experienceLevel: experienceLevel(general.experience),
+            troopId: general.troopId,
+            troopName: troopNames.get(general.troopId) ?? null,
+            gold: general.gold,
+            rice: general.rice,
+            cityId: general.cityId,
+            cityName: cityNames.get(general.cityId) ?? null,
+            defenceTrain,
+            defenceTrainText: defenceTrainText(defenceTrain),
+            crewTypeId: general.crewTypeId,
+            crew: general.crew,
+            train: general.train,
+            atmos: general.atmos,
+            killTurn: readNumber(meta, ['killturn', 'killTurn']),
+            turnTime: general.turnTime.toISOString(),
+            reservedCommands: general.npcState < 2 ? (turnMap.get(general.id) ?? []) : [],
+        };
+    });
+    const counted = generals.filter((general) => general.npcState !== 5);
+    const summary = counted.reduce(
+        (result, general) => {
+            result.gold += general.gold;
+            result.rice += general.rice;
+            result.crew += general.crew;
+            if (general.crew > 0) {
+                for (const threshold of [90, 80, 60] as const) {
+                    if (general.train >= threshold && general.atmos >= threshold) {
+                        result.readiness[threshold].crew += general.crew;
+                        result.readiness[threshold].generals += 1;
+                    }
+                }
+            }
+            return result;
+        },
+        {
+            gold: 0,
+            rice: 0,
+            crew: 0,
+            readiness: {
+                90: { crew: 0, generals: 0 },
+                80: { crew: 0, generals: 0 },
+                60: { crew: 0, generals: 0 },
+            },
+        }
+    );
+    return {
+        nation: { id: nation.id, name: nation.name, color: nation.color, level: nation.level },
+        viewer: { generalId: me.id, permission },
+        summary: {
+            ...summary,
+            generalCount: counted.length,
+            averageGold: counted.length ? summary.gold / counted.length : 0,
+            averageRice: counted.length ? summary.rice / counted.length : 0,
+        },
+        generals,
+    };
+});

app/game-api/src/router/nation/index.ts

@@ -5,6 +5,7 @@ import { getBattleCenter } from './endpoints/getBattleCenter.js';
 import { getChiefCenter } from './endpoints/getChiefCenter.js';
 import { getCityOverview } from './endpoints/getCityOverview.js';
 import { getGeneralList } from './endpoints/getGeneralList.js';
+import { getSecretGeneralList } from './endpoints/getSecretGeneralList.js';
 import { getGeneralLog } from './endpoints/getGeneralLog.js';
 import { getNationInfo } from './endpoints/getNationInfo.js';
 import { getPersonnelInfo } from './endpoints/getPersonnelInfo.js';
@@ -21,6 +22,7 @@ import { setSecretLimit } from './endpoints/setSecretLimit.js';
 export const nationRouter = router({
     getNationInfo,
     getGeneralList,
+    getSecretGeneralList,
     getCityOverview,
     getPersonnelInfo,
     getStratFinan,

app/game-api/src/router/npc/index.ts

@@ -1,5 +1,3 @@
-import path from 'node:path';
-
 import { TRPCError } from '@trpc/server';
 import { z } from 'zod';
 
@@ -165,8 +163,6 @@ const FLOAT_POLICY_KEYS = ['safeRecruitCityPopulationRatio'] as const;
 type NumericPolicyKey = (typeof INTEGER_POLICY_KEYS)[number];
 type FloatPolicyKey = (typeof FLOAT_POLICY_KEYS)[number];
 
-const UNIT_SET_ROOT = path.resolve(process.cwd(), 'resources', 'unitset');
-
 const readNumber = (value: unknown, fallback = 0): number => {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
@@ -353,8 +349,8 @@ const buildZeroPolicy = async (
     }
 ): Promise<NationPolicy> => {
     const { statMax, statNpcMax, nationTech, develCost, defaultCrewTypeId, unitSetName } = options;
-    const unitSet = await loadUnitSetDefinitionByName(unitSetName, { unitSetRoot: UNIT_SET_ROOT });
-    const crewType = findCrewTypeById(unitSet, defaultCrewTypeId);
+    const unitSet = await loadUnitSetDefinitionByName(unitSetName);
+    const crewType = findCrewTypeById(unitSet, defaultCrewTypeId || unitSet.defaultCrewTypeId || 0);
     const techCost = getTechCost(nationTech);
     const next = clonePolicy(policy);
 
@@ -364,7 +360,7 @@ const buildZeroPolicy = async (
 
     if (next.reqNPCWarGold === 0 || next.reqNPCWarRice === 0) {
         const baseGold = crewType ? crewType.cost * techCost * statNpcMax : 0;
-        const baseRice = statNpcMax;
+        const baseRice = crewType ? crewType.rice * techCost * statNpcMax : 0;
         if (next.reqNPCWarGold === 0) {
             next.reqNPCWarGold = roundTo(baseGold * 4, -2);
         }
@@ -375,7 +371,7 @@ const buildZeroPolicy = async (
 
     if (next.reqHumanWarUrgentGold === 0 || next.reqHumanWarUrgentRice === 0) {
         const baseGold = crewType ? crewType.cost * techCost * statMax : 0;
-        const baseRice = statMax;
+        const baseRice = crewType ? crewType.rice * techCost * statMax : 0;
         if (next.reqHumanWarUrgentGold === 0) {
             next.reqHumanWarUrgentGold = roundTo(baseGold * 6, -2);
         }
@@ -415,8 +411,6 @@ const resolveSetterInfo = (policy: Record<string, unknown>, kind: 'value' | 'pri
     };
 };
 
-const ensureUniquePriority = (priority: string[]): string[] => Array.from(new Set(priority));
-
 const validateGeneralPriority = (priority: string[]): string | null => {
     const orderRequired: Array<[string, string]> = [['출병', '일반내정']];
     const mustHave = new Set(['출병', '일반내정']);
@@ -461,6 +455,7 @@ export const npcRouter = router({
                     id: true,
                     name: true,
                     level: true,
+                    tech: true,
                     meta: true,
                 },
             }),
@@ -508,9 +503,9 @@ export const npcRouter = router({
         const stat = resolveScenarioStat(config);
         const env = resolveCommandEnv(config);
         const unitSetName = resolveUnitSetName(config, 'che');
-        const nationTech = readNumber(asRecord(nationMeta).tech, 0);
+        const nationTech = readNumber(nation.tech, 0);
 
-        const zeroPolicy = await buildZeroPolicy(defaultNationPolicy, {
+        const zeroPolicy = await buildZeroPolicy(DEFAULT_NATION_POLICY, {
             statMax: stat.max,
             statNpcMax: stat.npcMax,
             nationTech,
@@ -542,277 +537,272 @@ export const npcRouter = router({
             permissionLevel,
         };
     }),
-    setNationPolicy: authedProcedure
-        .input(z.record(z.string(), z.unknown()))
-        .mutation(async ({ ctx, input }) => {
-            const general = await getMyGeneral(ctx);
-            if (general.nationId <= 0) {
-                throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Nation membership required.' });
-            }
+    setNationPolicy: authedProcedure.input(z.record(z.string(), z.unknown())).mutation(async ({ ctx, input }) => {
+        const general = await getMyGeneral(ctx);
+        if (general.nationId <= 0) {
+            throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Nation membership required.' });
+        }
 
-            const nation = await ctx.db.nation.findUnique({
-                where: { id: general.nationId },
-                select: { id: true, meta: true },
-            });
-            if (!nation) {
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
-            }
+        const nation = await ctx.db.nation.findUnique({
+            where: { id: general.nationId },
+            select: { id: true, meta: true },
+        });
+        if (!nation) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
+        }
 
-            const permissionLevel = resolveSecretPermission(
-                {
-                    nationId: general.nationId,
-                    officerLevel: general.officerLevel,
-                    meta: general.meta,
-                    penalty: general.penalty,
-                },
-                nation.meta
-            );
-            if (permissionLevel < 3) {
-                throw new TRPCError({ code: 'FORBIDDEN', message: '권한이 부족합니다.' });
-            }
+        const permissionLevel = resolveSecretPermission(
+            {
+                nationId: general.nationId,
+                officerLevel: general.officerLevel,
+                meta: general.meta,
+                penalty: general.penalty,
+            },
+            nation.meta
+        );
+        if (permissionLevel < 3) {
+            throw new TRPCError({ code: 'FORBIDDEN', message: '권한이 부족합니다.' });
+        }
 
-            const keys = Object.keys(input);
-            for (const key of keys) {
-                if (!NATION_POLICY_KEYS.has(key as keyof NationPolicy)) {
+        const keys = Object.keys(input);
+        for (const key of keys) {
+            if (!NATION_POLICY_KEYS.has(key as keyof NationPolicy)) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 정책값이 아닙니다.` });
+            }
+        }
+
+        const troopRows = await ctx.db.troop.findMany({
+            where: { nationId: general.nationId },
+            select: { troopLeaderId: true },
+        });
+        const cityRows = await ctx.db.city.findMany({ select: { id: true } });
+
+        const troopSet = new Set(troopRows.map((row) => row.troopLeaderId));
+        const citySet = new Set(cityRows.map((row) => row.id));
+        const assigned = new Set<number>();
+
+        const nationMeta = asRecord(nation.meta);
+        const policyRoot = asRecord(nationMeta.npc_nation_policy);
+        const nextValues = applyPolicyValues(DEFAULT_NATION_POLICY, asRecord(policyRoot.values));
+
+        for (const key of INTEGER_POLICY_KEYS) {
+            if (!(key in input)) {
+                continue;
+            }
+            const value = input[key];
+            if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value)) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 값이 아닙니다.` });
+            }
+            nextValues[key] = Math.max(0, value);
+        }
+
+        for (const key of FLOAT_POLICY_KEYS) {
+            if (!(key in input)) {
+                continue;
+            }
+            const value = input[key];
+            if (typeof value !== 'number' || !Number.isFinite(value)) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 값이 아닙니다.` });
+            }
+            nextValues[key] = value;
+        }
+
+        if ('CombatForce' in input) {
+            const rawCombat = input.CombatForce;
+            if (!isRecord(rawCombat)) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: 'CombatForce는 올바른 정책값이 아닙니다.' });
+            }
+            const combatForce: Record<number, [number, number]> = {};
+            for (const [rawKey, rawValue] of Object.entries(rawCombat)) {
+                const leaderId = Number(rawKey);
+                if (!Number.isFinite(leaderId)) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: `${rawKey}는 올바른 부대가 아닙니다.` });
+                }
+                if (!troopSet.has(leaderId)) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: `${leaderId}는 국가의 부대가 아닙니다.` });
+                }
+                if (assigned.has(leaderId)) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `부대(${leaderId})는 하나의 역할만 지정할 수 있습니다.`,
+                    });
+                }
+                if (!Array.isArray(rawValue) || rawValue.length < 2) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `${leaderId}의 입력양식이 올바르지 않습니다.`,
+                    });
+                }
+                const fromCity = Number(rawValue[0]);
+                const toCity = Number(rawValue[1]);
+                if (!citySet.has(fromCity) || !citySet.has(toCity)) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `${leaderId}의 도시 ${fromCity}, ${toCity}가 올바른 도시 번호가 아닙니다.`,
+                    });
+                }
+                combatForce[leaderId] = [fromCity, toCity];
+                assigned.add(leaderId);
+            }
+            nextValues.CombatForce = combatForce;
+        }
+
+        for (const key of ['SupportForce', 'DevelopForce'] as const) {
+            if (!(key in input)) {
+                continue;
+            }
+            const rawList = input[key];
+            if (!Array.isArray(rawList)) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 정책값이 아닙니다.` });
+            }
+            const list: number[] = [];
+            for (const rawValue of rawList) {
+                if (typeof rawValue !== 'number' || !Number.isFinite(rawValue)) {
                     throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 정책값이 아닙니다.` });
                 }
-            }
-
-            const troopRows = await ctx.db.troop.findMany({
-                where: { nationId: general.nationId },
-                select: { troopLeaderId: true },
-            });
-            const cityRows = await ctx.db.city.findMany({ select: { id: true } });
-
-            const troopSet = new Set(troopRows.map((row) => row.troopLeaderId));
-            const citySet = new Set(cityRows.map((row) => row.id));
-            const assigned = new Set<number>();
-
-            const nationMeta = asRecord(nation.meta);
-            const policyRoot = asRecord(nationMeta.npc_nation_policy);
-            const nextValues = applyPolicyValues(DEFAULT_NATION_POLICY, asRecord(policyRoot.values));
-
-            for (const key of INTEGER_POLICY_KEYS) {
-                if (!(key in input)) {
-                    continue;
+                if (!troopSet.has(rawValue)) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `${rawValue}는 국가의 부대가 아닙니다.`,
+                    });
                 }
-                const value = input[key];
-                if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value)) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 값이 아닙니다.` });
+                if (assigned.has(rawValue)) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `부대(${rawValue})는 하나의 역할만 지정할 수 있습니다.`,
+                    });
                 }
-                nextValues[key] = Math.max(0, value);
+                assigned.add(rawValue);
+                list.push(rawValue);
             }
-
-            for (const key of FLOAT_POLICY_KEYS) {
-                if (!(key in input)) {
-                    continue;
-                }
-                const value = input[key];
-                if (typeof value !== 'number' || !Number.isFinite(value)) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 값이 아닙니다.` });
-                }
-                nextValues[key] = Math.max(0, value);
+            if (key === 'SupportForce') {
+                nextValues.SupportForce = list;
+            } else {
+                nextValues.DevelopForce = list;
             }
+        }
 
-            if ('CombatForce' in input) {
-                const rawCombat = input.CombatForce;
-                if (!isRecord(rawCombat)) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: 'CombatForce는 올바른 정책값이 아닙니다.' });
-                }
-                const combatForce: Record<number, [number, number]> = {};
-                for (const [rawKey, rawValue] of Object.entries(rawCombat)) {
-                    const leaderId = Number(rawKey);
-                    if (!Number.isFinite(leaderId)) {
-                        throw new TRPCError({ code: 'BAD_REQUEST', message: `${rawKey}는 올바른 부대가 아닙니다.` });
-                    }
-                    if (!troopSet.has(leaderId)) {
-                        throw new TRPCError({ code: 'BAD_REQUEST', message: `${leaderId}는 국가의 부대가 아닙니다.` });
-                    }
-                    if (assigned.has(leaderId)) {
-                        throw new TRPCError({
-                            code: 'BAD_REQUEST',
-                            message: `부대(${leaderId})는 하나의 역할만 지정할 수 있습니다.`,
-                        });
-                    }
-                    if (!Array.isArray(rawValue) || rawValue.length < 2) {
-                        throw new TRPCError({ code: 'BAD_REQUEST', message: `${leaderId}의 입력양식이 올바르지 않습니다.` });
-                    }
-                    const fromCity = Number(rawValue[0]);
-                    const toCity = Number(rawValue[1]);
-                    if (!citySet.has(fromCity) || !citySet.has(toCity)) {
-                        throw new TRPCError({
-                            code: 'BAD_REQUEST',
-                            message: `${leaderId}의 도시 ${fromCity}, ${toCity}가 올바른 도시 번호가 아닙니다.`,
-                        });
-                    }
-                    combatForce[leaderId] = [fromCity, toCity];
-                    assigned.add(leaderId);
-                }
-                nextValues.CombatForce = combatForce;
+        const nextPolicyRoot = {
+            ...policyRoot,
+            values: nextValues,
+            valueSetter: general.name,
+            valueSetTime: new Date().toISOString(),
+        };
+
+        await updateNationMeta(
+            ctx,
+            nation.id,
+            {
+                npc_nation_policy: nextPolicyRoot,
+            },
+            nationMeta
+        );
+
+        return { ok: true };
+    }),
+    setNationPriority: authedProcedure.input(z.array(z.string())).mutation(async ({ ctx, input }) => {
+        const general = await getMyGeneral(ctx);
+        if (general.nationId <= 0) {
+            throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Nation membership required.' });
+        }
+
+        const nation = await ctx.db.nation.findUnique({
+            where: { id: general.nationId },
+            select: { id: true, meta: true },
+        });
+        if (!nation) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
+        }
+
+        const permissionLevel = resolveSecretPermission(
+            {
+                nationId: general.nationId,
+                officerLevel: general.officerLevel,
+                meta: general.meta,
+                penalty: general.penalty,
+            },
+            nation.meta
+        );
+        if (permissionLevel < 3) {
+            throw new TRPCError({ code: 'FORBIDDEN', message: '권한이 부족합니다.' });
+        }
+
+        for (const item of input) {
+            if (!DEFAULT_NATION_PRIORITY.includes(item as (typeof DEFAULT_NATION_PRIORITY)[number])) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: `${item}은 올바른 명령이 아닙니다.` });
             }
+        }
 
-            for (const key of ['SupportForce', 'DevelopForce'] as const) {
-                if (!(key in input)) {
-                    continue;
-                }
-                const rawList = input[key];
-                if (!Array.isArray(rawList)) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 정책값이 아닙니다.` });
-                }
-                const list: number[] = [];
-                for (const rawValue of rawList) {
-                    if (typeof rawValue !== 'number' || !Number.isFinite(rawValue)) {
-                        throw new TRPCError({ code: 'BAD_REQUEST', message: `${key}는 올바른 정책값이 아닙니다.` });
-                    }
-                    if (!troopSet.has(rawValue)) {
-                        throw new TRPCError({
-                            code: 'BAD_REQUEST',
-                            message: `${rawValue}는 국가의 부대가 아닙니다.`,
-                        });
-                    }
-                    if (assigned.has(rawValue)) {
-                        throw new TRPCError({
-                            code: 'BAD_REQUEST',
-                            message: `부대(${rawValue})는 하나의 역할만 지정할 수 있습니다.`,
-                        });
-                    }
-                    assigned.add(rawValue);
-                    list.push(rawValue);
-                }
-                if (key === 'SupportForce') {
-                    nextValues.SupportForce = list;
-                } else {
-                    nextValues.DevelopForce = list;
-                }
-            }
+        const nationMeta = asRecord(nation.meta);
+        const policyRoot = asRecord(nationMeta.npc_nation_policy);
+        const nextPolicyRoot = {
+            ...policyRoot,
+            priority: input,
+            prioritySetter: general.name,
+            prioritySetTime: new Date().toISOString(),
+        };
 
-            const nextPolicyRoot = {
-                ...policyRoot,
-                values: nextValues,
-                valueSetter: general.name,
-                valueSetTime: new Date().toISOString(),
-            };
+        await updateNationMeta(
+            ctx,
+            nation.id,
+            {
+                npc_nation_policy: nextPolicyRoot,
+            },
+            nationMeta
+        );
 
-            await updateNationMeta(
-                ctx,
-                nation.id,
-                {
-                    npc_nation_policy: nextPolicyRoot,
-                },
-                nationMeta
-            );
+        return { ok: true };
+    }),
+    setGeneralPriority: authedProcedure.input(z.array(z.string())).mutation(async ({ ctx, input }) => {
+        const general = await getMyGeneral(ctx);
+        if (general.nationId <= 0) {
+            throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Nation membership required.' });
+        }
 
-            return { ok: true };
-        }),
-    setNationPriority: authedProcedure
-        .input(z.array(z.string()))
-        .mutation(async ({ ctx, input }) => {
-            const general = await getMyGeneral(ctx);
-            if (general.nationId <= 0) {
-                throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Nation membership required.' });
-            }
+        const nation = await ctx.db.nation.findUnique({
+            where: { id: general.nationId },
+            select: { id: true, meta: true },
+        });
+        if (!nation) {
+            throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
+        }
 
-            const nation = await ctx.db.nation.findUnique({
-                where: { id: general.nationId },
-                select: { id: true, meta: true },
-            });
-            if (!nation) {
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
-            }
+        const permissionLevel = resolveSecretPermission(
+            {
+                nationId: general.nationId,
+                officerLevel: general.officerLevel,
+                meta: general.meta,
+                penalty: general.penalty,
+            },
+            nation.meta
+        );
+        if (permissionLevel < 3) {
+            throw new TRPCError({ code: 'FORBIDDEN', message: '권한이 부족합니다.' });
+        }
 
-            const permissionLevel = resolveSecretPermission(
-                {
-                    nationId: general.nationId,
-                    officerLevel: general.officerLevel,
-                    meta: general.meta,
-                    penalty: general.penalty,
-                },
-                nation.meta
-            );
-            if (permissionLevel < 3) {
-                throw new TRPCError({ code: 'FORBIDDEN', message: '권한이 부족합니다.' });
-            }
+        const validationError = validateGeneralPriority(input);
+        if (validationError) {
+            throw new TRPCError({ code: 'BAD_REQUEST', message: validationError });
+        }
 
-            const unique = ensureUniquePriority(input);
-            for (const item of unique) {
-                if (!DEFAULT_NATION_PRIORITY.includes(item as (typeof DEFAULT_NATION_PRIORITY)[number])) {
-                    throw new TRPCError({ code: 'BAD_REQUEST', message: `${item}은 올바른 명령이 아닙니다.` });
-                }
-            }
+        const nationMeta = asRecord(nation.meta);
+        const policyRoot = asRecord(nationMeta.npc_general_policy);
+        const nextPolicyRoot = {
+            ...policyRoot,
+            priority: input,
+            prioritySetter: general.name,
+            prioritySetTime: new Date().toISOString(),
+        };
 
-            const nationMeta = asRecord(nation.meta);
-            const policyRoot = asRecord(nationMeta.npc_nation_policy);
-            const nextPolicyRoot = {
-                ...policyRoot,
-                priority: unique,
-                prioritySetter: general.name,
-                prioritySetTime: new Date().toISOString(),
-            };
+        await updateNationMeta(
+            ctx,
+            nation.id,
+            {
+                npc_general_policy: nextPolicyRoot,
+            },
+            nationMeta
+        );
 
-            await updateNationMeta(
-                ctx,
-                nation.id,
-                {
-                    npc_nation_policy: nextPolicyRoot,
-                },
-                nationMeta
-            );
-
-            return { ok: true };
-        }),
-    setGeneralPriority: authedProcedure
-        .input(z.array(z.string()))
-        .mutation(async ({ ctx, input }) => {
-            const general = await getMyGeneral(ctx);
-            if (general.nationId <= 0) {
-                throw new TRPCError({ code: 'PRECONDITION_FAILED', message: 'Nation membership required.' });
-            }
-
-            const nation = await ctx.db.nation.findUnique({
-                where: { id: general.nationId },
-                select: { id: true, meta: true },
-            });
-            if (!nation) {
-                throw new TRPCError({ code: 'NOT_FOUND', message: 'Nation not found' });
-            }
-
-            const permissionLevel = resolveSecretPermission(
-                {
-                    nationId: general.nationId,
-                    officerLevel: general.officerLevel,
-                    meta: general.meta,
-                    penalty: general.penalty,
-                },
-                nation.meta
-            );
-            if (permissionLevel < 3) {
-                throw new TRPCError({ code: 'FORBIDDEN', message: '권한이 부족합니다.' });
-            }
-
-            const unique = ensureUniquePriority(input);
-            const validationError = validateGeneralPriority(unique);
-            if (validationError) {
-                throw new TRPCError({ code: 'BAD_REQUEST', message: validationError });
-            }
-
-            const nationMeta = asRecord(nation.meta);
-            const policyRoot = asRecord(nationMeta.npc_general_policy);
-            const nextPolicyRoot = {
-                ...policyRoot,
-                priority: unique,
-                prioritySetter: general.name,
-                prioritySetTime: new Date().toISOString(),
-            };
-
-            await updateNationMeta(
-                ctx,
-                nation.id,
-                {
-                    npc_general_policy: nextPolicyRoot,
-                },
-                nationMeta
-            );
-
-            return { ok: true };
-        }),
+        return { ok: true };
+    }),
 });

app/game-api/src/router/public/index.ts

@@ -42,6 +42,14 @@ type NationCountRow = {
 
 type NpcListSort = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
 
+type TrafficHistoryItem = {
+    year: number;
+    month: number;
+    refresh: number;
+    online: number;
+    date: string;
+};
+
 const PUBLIC_CACHE_TTL_SECONDS = 600;
 
 const buildPublicCacheKey = (ctx: GameApiContext, key: string): string =>
@@ -163,6 +171,26 @@ const readFiniteMetaNumber = (meta: Record<string, unknown>, key: string): numbe
     return typeof value === 'number' && Number.isFinite(value) ? value : 0;
 };
 
+const parseTrafficHistory = (value: unknown): TrafficHistoryItem[] => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
+    const result: TrafficHistoryItem[] = [];
+    for (const item of value) {
+        const row = asRecord(item);
+        const year = readFiniteMetaNumber(row, 'year');
+        const month = readFiniteMetaNumber(row, 'month');
+        const refresh = readFiniteMetaNumber(row, 'refresh');
+        const online = readFiniteMetaNumber(row, 'online');
+        const date = typeof row.date === 'string' ? row.date : '';
+        if (year > 0 && month > 0 && date) {
+            result.push({ year, month, refresh, online, date });
+        }
+    }
+    return result;
+};
+
 const compareString = (left: string, right: string): number => {
     if (left === right) {
         return 0;
@@ -222,6 +250,95 @@ export const publicRouter = router({
     getNationList: procedure.query(async ({ ctx }) => {
         return loadCachedNationList(ctx);
     }),
+    getTraffic: procedure.query(async ({ ctx }) => {
+        const worldState = await ctx.db.worldState.findFirst();
+        if (!worldState) {
+            throw new TRPCError({
+                code: 'PRECONDITION_FAILED',
+                message: 'World state is not initialized.',
+            });
+        }
+
+        const meta = asRecord(worldState.meta);
+        const rawOnlineSince = meta.lastTurnTime ?? meta.turntime;
+        const parsedOnlineSince =
+            typeof rawOnlineSince === 'string' || rawOnlineSince instanceof Date
+                ? new Date(rawOnlineSince)
+                : null;
+        const onlineSince =
+            parsedOnlineSince && Number.isFinite(parsedOnlineSince.getTime())
+                ? parsedOnlineSince
+                : new Date(Date.now() - worldState.tickSeconds * 1_000);
+        const [accessTotal, currentOnline, topAccess] = await Promise.all([
+            ctx.db.generalAccessLog.aggregate({
+                _sum: {
+                    refresh: true,
+                    refreshScoreTotal: true,
+                },
+            }),
+            ctx.db.generalAccessLog.count({
+                where: {
+                    lastRefresh: {
+                        gte: onlineSince,
+                    },
+                },
+            }),
+            ctx.db.generalAccessLog.findMany({
+                orderBy: [{ refresh: 'desc' }, { generalId: 'asc' }],
+                take: 5,
+                select: {
+                    generalId: true,
+                    refresh: true,
+                    refreshScoreTotal: true,
+                },
+            }),
+        ]);
+
+        const generalIds = topAccess.map((entry) => entry.generalId);
+        const generalRows =
+            generalIds.length > 0
+                ? await ctx.db.general.findMany({
+                      where: { id: { in: generalIds } },
+                      select: { id: true, name: true },
+                  })
+                : [];
+        const generalName = new Map(generalRows.map((general) => [general.id, general.name]));
+        const totalRefresh = accessTotal._sum.refresh ?? 0;
+        const totalRefreshScore = accessTotal._sum.refreshScoreTotal ?? 0;
+        const currentRefresh = Math.max(readFiniteMetaNumber(meta, 'refresh'), totalRefresh);
+        const history = parseTrafficHistory(meta.recentTraffic);
+        history.push({
+            year: worldState.currentYear,
+            month: worldState.currentMonth,
+            refresh: currentRefresh,
+            online: currentOnline,
+            date: new Date().toISOString(),
+        });
+
+        return {
+            history,
+            maxRefresh: Math.max(
+                1,
+                readFiniteMetaNumber(meta, 'maxrefresh'),
+                ...history.map((entry) => entry.refresh)
+            ),
+            maxOnline: Math.max(1, readFiniteMetaNumber(meta, 'maxonline'), ...history.map((entry) => entry.online)),
+            suspects: [
+                {
+                    generalId: null,
+                    name: '접속자 총합',
+                    refresh: totalRefresh,
+                    refreshScoreTotal: totalRefreshScore,
+                },
+                ...topAccess.map((entry) => ({
+                    generalId: entry.generalId,
+                    name: generalName.get(entry.generalId) ?? `장수 ${entry.generalId}`,
+                    refresh: entry.refresh,
+                    refreshScoreTotal: entry.refreshScoreTotal,
+                })),
+            ],
+        };
+    }),
     getGeneralList: procedure.query(async ({ ctx }) => {
         const [generals, nations] = await Promise.all([
             ctx.db.general.findMany({

app/game-api/src/router/ranking/index.ts

@@ -2,8 +2,11 @@ import { z } from 'zod';
 
 import { asRecord, HALL_OF_FAME_TYPES, type HallOfFameType } from '@sammo-ts/common';
 import { ITEM_KEYS, ItemLoader, loadItemModules } from '@sammo-ts/logic/items/index.js';
+import type { ItemModule } from '@sammo-ts/logic/items/types.js';
+import { buildLegacyDefaultUniqueItemPool } from '@sammo-ts/logic/rewards/legacyUniqueItemPool.js';
+import { resolveUniqueConfig } from '@sammo-ts/logic/rewards/uniqueLottery.js';
 
-import { procedure, router } from '../../trpc.js';
+import { authedProcedure, procedure, router } from '../../trpc.js';
 
 const DEFAULT_BG_COLOR = '#2b2b2b';
 const DEFAULT_FG_COLOR = '#ffffff';
@@ -23,31 +26,31 @@ const readMetaNumber = (value: unknown): number => {
 
 const percentText = (value: number): string => `${(value * 100).toFixed(2)}%`;
 
+const readOwnerDisplayName = (value: unknown): string | null => {
+    const meta = asRecord(value);
+    if (typeof meta.ownerName === 'string' && meta.ownerName.length > 0) {
+        return meta.ownerName;
+    }
+    if (typeof meta.owner_name === 'string' && meta.owner_name.length > 0) {
+        return meta.owner_name;
+    }
+    return null;
+};
+
 const itemLoader = new ItemLoader();
-let cachedUniqueItems: Promise<
-    Array<{ key: string; name: string; slot: string; unique: boolean; buyable: boolean; info: string }>
-> | null = null;
+let cachedUniqueItems: Promise<ItemModule[]> | null = null;
 
 const loadUniqueItems = () => {
     if (!cachedUniqueItems) {
         cachedUniqueItems = loadItemModules([...ITEM_KEYS], itemLoader).then((modules) =>
-            modules
-                .filter((module) => module.unique && !module.buyable)
-                .map((module) => ({
-                    key: module.key,
-                    name: module.name,
-                    slot: module.slot,
-                    unique: module.unique,
-                    buyable: module.buyable,
-                    info: module.info,
-                }))
+            modules.filter((module) => module.unique && !module.buyable)
         );
     }
     return cachedUniqueItems;
 };
 
 export const rankingRouter = router({
-    getBestGeneral: procedure
+    getBestGeneral: authedProcedure
         .input(
             z
                 .object({
@@ -57,7 +60,7 @@ export const rankingRouter = router({
         )
         .query(async ({ ctx, input }) => {
             const worldState = await ctx.db.worldState.findFirst({
-                select: { meta: true },
+                select: { meta: true, config: true },
             });
             const meta = asRecord(worldState?.meta);
             const isUnited = typeof meta.isUnited === 'number' && meta.isUnited !== 0;
@@ -76,6 +79,7 @@ export const rankingRouter = router({
                         userId: true,
                         picture: true,
                         imageServer: true,
+                        meta: true,
                         experience: true,
                         dedication: true,
                         horseCode: true,
@@ -185,7 +189,7 @@ export const rankingRouter = router({
                         let display = {
                             id: general.id,
                             name: general.name,
-                            ownerName: general.userId ?? null,
+                            ownerName: isUnited ? readOwnerDisplayName(general.meta) : null,
                             nationName: nation?.name ?? '재야',
                             bgColor: nation?.color ?? DEFAULT_BG_COLOR,
                             fgColor: DEFAULT_FG_COLOR,
@@ -217,46 +221,91 @@ export const rankingRouter = router({
             });
 
             const uniqueItems = await loadUniqueItems();
-            const itemEntries = uniqueItems.map((item) => {
-                const owners = generals.filter((general) => {
-                    if (item.slot === 'horse') {
-                        return general.horseCode === item.key;
+            const itemRegistry = new Map(uniqueItems.map((item) => [item.key, item]));
+            const uniqueConfig = resolveUniqueConfig(asRecord(asRecord(worldState?.config).const));
+            if (Object.keys(uniqueConfig.allItems).length === 0) {
+                uniqueConfig.allItems = buildLegacyDefaultUniqueItemPool(itemRegistry);
+            }
+            const activeAuctions = await ctx.db.auction.findMany({
+                where: {
+                    type: 'UNIQUE_ITEM',
+                    status: { in: ['OPEN', 'FINALIZING'] },
+                    targetCode: { not: null },
+                },
+                select: { targetCode: true },
+            });
+            const auctionCounts = new Map<string, number>();
+            for (const auction of activeAuctions) {
+                if (auction.targetCode) {
+                    auctionCounts.set(auction.targetCode, (auctionCounts.get(auction.targetCode) ?? 0) + 1);
+                }
+            }
+            const slotTitles = {
+                horse: '명 마',
+                weapon: '명 검',
+                book: '명 서',
+                item: '도 구',
+            } as const;
+            const itemEntries = (['horse', 'weapon', 'book', 'item'] as const).map((slot) => {
+                const configuredItems = Object.entries(uniqueConfig.allItems[slot] ?? {}).reverse();
+                const entries = configuredItems.flatMap(([itemKey, rawCount]) => {
+                    const item = itemRegistry.get(itemKey);
+                    if (!item || item.buyable) {
+                        return [];
                     }
-                    if (item.slot === 'weapon') {
-                        return general.weaponCode === item.key;
+                    const owners = generals
+                        .filter((general) => {
+                            if (slot === 'horse') {
+                                return general.horseCode === itemKey;
+                            }
+                            if (slot === 'weapon') {
+                                return general.weaponCode === itemKey;
+                            }
+                            if (slot === 'book') {
+                                return general.bookCode === itemKey;
+                            }
+                            return general.itemCode === itemKey;
+                        })
+                        .map((general) => {
+                            const nation = nationMap.get(general.nationId) ?? null;
+                            return {
+                                id: general.id,
+                                name: general.name,
+                                nationName: nation?.name ?? '재야',
+                                bgColor: nation?.color ?? DEFAULT_BG_COLOR,
+                                fgColor: DEFAULT_FG_COLOR,
+                                picture: general.picture ?? null,
+                                imageServer: general.imageServer ?? 0,
+                            };
+                        });
+                    for (let index = 0; index < (auctionCounts.get(itemKey) ?? 0); index += 1) {
+                        owners.push({
+                            id: 0,
+                            name: '경매중',
+                            nationName: '-',
+                            bgColor: '#00582c',
+                            fgColor: '#ffffff',
+                            picture: null,
+                            imageServer: 0,
+                        });
                     }
-                    if (item.slot === 'book') {
-                        return general.bookCode === item.key;
-                    }
-                    return general.itemCode === item.key;
+                    const count = Math.max(0, Math.floor(rawCount));
+                    return Array.from({ length: count }, (_, index) => ({
+                        itemKey,
+                        itemName: item.name,
+                        itemInfo: item.info,
+                        owner: owners[index] ?? {
+                            id: 0,
+                            name: '미발견',
+                            nationName: '-',
+                            bgColor: DEFAULT_BG_COLOR,
+                            fgColor: DEFAULT_FG_COLOR,
+                            picture: null,
+                            imageServer: 0,
+                        },
+                    }));
                 });
-
-                const displayOwners = owners.length
-                    ? owners.map((general) => {
-                          const nation = nationMap.get(general.nationId) ?? null;
-                          return {
-                              id: general.id,
-                              name: general.name,
-                              nationName: nation?.name ?? '재야',
-                              bgColor: nation?.color ?? DEFAULT_BG_COLOR,
-                              fgColor: DEFAULT_FG_COLOR,
-                          };
-                      })
-                    : [
-                          {
-                              id: 0,
-                              name: '미발견',
-                              nationName: '-',
-                              bgColor: DEFAULT_BG_COLOR,
-                              fgColor: DEFAULT_FG_COLOR,
-                          },
-                      ];
-
-                return {
-                    title: item.name,
-                    slot: item.slot,
-                    owners: displayOwners,
-                };
+                return { title: slotTitles[slot], slot, entries };
             });
 
             return {
@@ -339,6 +388,10 @@ export const rankingRouter = router({
                         return {
                             generalId: row.generalNo,
                             name: String(aux.name ?? ''),
+                            ownerName:
+                                typeof aux.ownerDisplayName === 'string' && aux.ownerDisplayName.length > 0
+                                    ? aux.ownerDisplayName
+                                    : null,
                             nationName: String(aux.nationName ?? ''),
                             bgColor: String(aux.bgColor ?? DEFAULT_BG_COLOR),
                             fgColor: String(aux.fgColor ?? DEFAULT_FG_COLOR),

app/game-api/src/router/world/index.ts

@@ -7,6 +7,7 @@ import { authedProcedure } from '../../trpc.js';
 import { asRecord, isRecord } from '@sammo-ts/common';
 import { loadWorldMap } from '../../maps/worldMap.js';
 import { loadMapLayout } from '../../maps/mapLayout.js';
+import { loadUnitSetDefinitionByName } from '../../battleSim/unitSetLoader.js';
 import { getMyGeneral, getOwnedGeneral } from '../shared/general.js';
 
 const isWorldAdmin = (roles: readonly string[]): boolean =>
@@ -33,6 +34,29 @@ const defenceTrain = (meta: unknown): number => {
     return typeof raw === 'number' && Number.isFinite(raw) ? raw : 0;
 };
 
+const unitSetName = (world: WorldStateRow | null, fallback: string): string => {
+    const config = asRecord(world?.config);
+    const environment = asRecord(config.environment ?? config.map);
+    return typeof environment.unitSet === 'string' && environment.unitSet.trim() ? environment.unitSet : fallback;
+};
+
+const crewTypeNameCache = new Map<string, Promise<Map<number, string>>>();
+const loadCrewTypeNames = (name: string): Promise<Map<number, string>> => {
+    const cached = crewTypeNameCache.get(name);
+    if (cached) return cached;
+    const pending = loadUnitSetDefinitionByName(name)
+        .then((definition) => new Map((definition.crewTypes ?? []).map((crewType) => [crewType.id, crewType.name])))
+        .catch(() => new Map<number, string>());
+    crewTypeNameCache.set(name, pending);
+    return pending;
+};
+
+const leadershipBonus = (officerLevel: number, nationLevel: number): number => {
+    if (officerLevel === 12) return nationLevel * 2;
+    if (officerLevel >= 5) return nationLevel;
+    return 0;
+};
+
 const toWorldStateSnapshot = (row: WorldStateRow) => ({
     scenarioCode: row.scenarioCode,
     currentYear: row.currentYear,
@@ -122,6 +146,8 @@ export const worldRouter = router({
             if (me.officerLevel > 0 && me.nationId > 0) {
                 cities.filter((city) => city.nationId === me.nationId).forEach((city) => selectable.add(city.id));
                 nationGenerals.forEach((general) => selectable.add(general.cityId));
+            }
+            if ((nation?.level ?? 0) > 0) {
                 Object.keys(spy).forEach((id) => selectable.add(Number(id)));
             }
             if (admin) cities.forEach((city) => selectable.add(city.id));
@@ -150,6 +176,8 @@ export const worldRouter = router({
                 turnMap.set(turn.generalId, list);
             }
             const nationMap = new Map(nations.map((item) => [item.id, item]));
+            const selectedNation = nationMap.get(selected.nationId);
+            const crewTypeNames = await loadCrewTypeNames(unitSetName(world, ctx.profile.id));
             const officers = await ctx.db.general.findMany({
                 where: { officerLevel: { in: [2, 3, 4] } },
                 select: { name: true, officerLevel: true, meta: true },
@@ -175,14 +203,59 @@ export const worldRouter = router({
                     intelligence: general.intel,
                     injury: general.injury,
                     officerLevel: general.officerLevel,
+                    leadershipBonus: leadershipBonus(general.officerLevel, nationMap.get(general.nationId)?.level ?? 0),
                     defenceTrain: ours ? defenceTrain(general.meta) : null,
                     crewTypeId: ours ? general.crewTypeId : null,
+                    crewTypeName: ours ? (crewTypeNames.get(general.crewTypeId) ?? null) : null,
                     crew: ours || full ? general.crew : null,
                     train: ours ? general.train : null,
                     atmos: ours ? general.atmos : null,
                     turns: ours && general.npcState <= 1 ? (turnMap.get(general.id) ?? []) : [],
                 };
             });
+            const forceSummary = mappedGenerals.reduce(
+                (summary, general) => {
+                    if (general.nationId > 0 && me.nationId > 0 && general.nationId !== me.nationId) {
+                        summary.enemyGenerals += 1;
+                        if (general.crew !== null && general.crew >= 0) summary.enemyCrew += general.crew;
+                        if (general.crew !== null && general.crew > 0) summary.enemyArmedGenerals += 1;
+                        return summary;
+                    }
+                    if (me.nationId <= 0 || general.nationId !== me.nationId) return summary;
+                    summary.ownGenerals += 1;
+                    summary.ownCrew += general.crew ?? 0;
+                    if ((general.crew ?? 0) <= 0) return summary;
+                    summary.ownArmedGenerals += 1;
+                    const readiness = Math.min(general.train ?? -1, general.atmos ?? -1);
+                    if (readiness >= 90) {
+                        summary.ready90Crew += general.crew ?? 0;
+                        summary.ready90Generals += 1;
+                    }
+                    if (readiness >= 60) {
+                        summary.ready60Crew += general.crew ?? 0;
+                        summary.ready60Generals += 1;
+                    }
+                    if (general.defenceTrain !== null && readiness >= general.defenceTrain) {
+                        summary.defenceReadyCrew += general.crew ?? 0;
+                        summary.defenceReadyGenerals += 1;
+                    }
+                    return summary;
+                },
+                {
+                    enemyCrew: 0,
+                    enemyArmedGenerals: 0,
+                    enemyGenerals: 0,
+                    ownCrew: 0,
+                    ownArmedGenerals: 0,
+                    ownGenerals: 0,
+                    ready90Crew: 0,
+                    ready90Generals: 0,
+                    ready60Crew: 0,
+                    ready60Generals: 0,
+                    defenceReadyCrew: 0,
+                    defenceReadyGenerals: 0,
+                }
+            );
             return {
                 me: { id: me.id, nationId: me.nationId, officerLevel: me.officerLevel, admin },
                 options: [...selectable]
@@ -194,6 +267,7 @@ export const worldRouter = router({
                     id: selected.id,
                     name: selected.name,
                     nationId: selected.nationId,
+                    nationColor: selectedNation?.color ?? '#000000',
                     level: selected.level,
                     region: selected.region,
                     population: redact(selected.population),
@@ -217,8 +291,11 @@ export const worldRouter = router({
                     },
                 },
                 generals: mappedGenerals,
+                forceSummary,
                 lastExecute:
-                    typeof asRecord(world?.meta).turntime === 'string' ? String(asRecord(world?.meta).turntime) : '',
+                    typeof asRecord(world?.meta).turntime === 'string'
+                        ? String(asRecord(world?.meta).turntime).slice(5, 19)
+                        : '',
             };
         }),
     getState: procedure.query(async ({ ctx }) => {

app/game-api/src/tournament/worker.ts

@@ -1,15 +1,15 @@
-import { createTournamentRng } from '@sammo-ts/common';
+import { createTournamentRng, type TurnDaemonCommandResult } from '@sammo-ts/common';
 import { resolveTournamentBattle } from '@sammo-ts/logic';
 import {
     createGamePostgresConnector,
     createRedisConnector,
     resolvePostgresConfigFromEnv,
     resolveRedisConfigFromEnv,
+    type GamePrismaClient,
 } from '@sammo-ts/infra';
 
 import { resolveGameApiConfigFromEnv } from '../config.js';
-import { RedisTurnDaemonTransport } from '../daemon/redisTransport.js';
-import { buildTurnDaemonStreamKeys } from '../daemon/streamKeys.js';
+import { DatabaseTurnDaemonTransport } from '../daemon/databaseTransport.js';
 import type { TurnDaemonTransport } from '../daemon/transport.js';
 import { buildTournamentKeys } from './keys.js';
 import { TournamentStore } from './store.js';
@@ -462,13 +462,30 @@ export const settleTournamentOutcome = async (options: {
         return null;
     }
 
-    let settledState: TournamentState | null = null;
+    let settledState = state;
+    let changed = false;
 
-    if (!state.rewardSettled) {
+    const requireSuccessfulResult = (
+        result: TurnDaemonCommandResult | null,
+        expectedType: TurnDaemonCommandResult['type']
+    ): void => {
+        if (!result) {
+            throw new Error(`${expectedType} 명령 응답 시간이 초과되었습니다.`);
+        }
+        if (result.type !== expectedType) {
+            throw new Error(`${expectedType} 명령에 잘못된 응답(${result.type})을 받았습니다.`);
+        }
+        if (!result.ok) {
+            throw new Error(`${expectedType} 명령이 실패했습니다: ${result.reason}`);
+        }
+    };
+
+    if (!settledState.rewardSettled) {
         const matches = await store.getMatches();
         const rewardPayload = buildTournamentRewardPayload(matches);
-        await daemonTransport.sendCommand({
+        const result = await daemonTransport.requestCommand({
             type: 'tournamentReward',
+            requestId: `tournament:${state.bettingId ?? `${state.openYear}:${state.openMonth}:${state.type}`}:reward`,
             tournamentType: state.type,
             winnerId: rewardPayload.winnerId,
             runnerUpId: rewardPayload.runnerUpId,
@@ -476,46 +493,100 @@ export const settleTournamentOutcome = async (options: {
             top8: rewardPayload.top8,
             top4: rewardPayload.top4,
         });
+        requireSuccessfulResult(result, 'tournamentReward');
         settledState = {
-            ...(settledState ?? state),
+            ...settledState,
             rewardSettled: true,
         };
+        changed = true;
+        await store.setState(settledState);
     }
 
-    if (state.bettingId && !state.bettingSettled) {
+    if (settledState.bettingId && !settledState.bettingSettled) {
         const bettingEntries = await store.getBettingEntries();
         if (bettingEntries.length > 0) {
-            const payoutInfo = buildBettingPayouts(state.winnerId, bettingEntries);
+            const payoutInfo = buildBettingPayouts(settledState.winnerId!, bettingEntries);
             if (payoutInfo.payouts.length > 0) {
                 if (payoutInfo.refundAll) {
-                    await daemonTransport.sendCommand({
+                    const result = await daemonTransport.requestCommand({
                         type: 'tournamentRefund',
-                        bettingId: state.bettingId,
+                        requestId: `tournament:${settledState.bettingId}:betting-refund`,
+                        bettingId: settledState.bettingId,
                         refunds: payoutInfo.payouts,
                         reason: 'no_winner',
                     });
+                    requireSuccessfulResult(result, 'tournamentRefund');
                 } else {
-                    await daemonTransport.sendCommand({
+                    const result = await daemonTransport.requestCommand({
                         type: 'tournamentBettingPayout',
-                        bettingId: state.bettingId,
+                        requestId: `tournament:${settledState.bettingId}:betting-payout`,
+                        bettingId: settledState.bettingId,
                         payouts: payoutInfo.payouts,
                         reason: 'winner_payout',
                     });
+                    requireSuccessfulResult(result, 'tournamentBettingPayout');
                 }
             }
         }
 
         settledState = {
-            ...(settledState ?? state),
+            ...settledState,
             bettingSettled: true,
         };
-    }
-
-    if (settledState) {
+        changed = true;
         await store.setState(settledState);
     }
 
-    return settledState;
+    return changed ? settledState : null;
+};
+
+const needsSettlement = (state: TournamentState): boolean =>
+    state.stage === 0 &&
+    Boolean(state.winnerId) &&
+    (!state.rewardSettled || (Boolean(state.bettingId) && !state.bettingSettled));
+
+export const processTournamentTick = async (options: {
+    store: TournamentStore;
+    prisma: GamePrismaClient;
+    daemonTransport: TurnDaemonTransport;
+    now?: () => number;
+}): Promise<TournamentState | null> => {
+    const { store, prisma, daemonTransport } = options;
+    const now = options.now ?? Date.now;
+    let processedState: TournamentState | null = null;
+
+    await store.withMutationLock(async () => {
+        const state = await store.getState();
+        if (!state || (!state.auto && !needsSettlement(state))) {
+            return;
+        }
+        const nextAt = new Date(state.nextAt).getTime();
+        if (state.auto && Number.isFinite(nextAt) && nextAt > now()) {
+            return;
+        }
+
+        if (needsSettlement(state)) {
+            processedState = (await settleTournamentOutcome({ store, daemonTransport, state })) ?? state;
+            return;
+        }
+
+        const worldState = await prisma.worldState.findFirst();
+        const baseSeed = (worldState?.meta as Record<string, unknown> | null)?.hiddenSeed ?? 'tournament';
+        let nextState = state;
+        if (isBattleStage(state.stage)) {
+            nextState = await applyBattle(store, state, String(baseSeed), daemonTransport);
+        } else if (isPreBattleStage(state.stage)) {
+            nextState = await applyPreBattleStage(store, prisma, state, String(baseSeed), daemonTransport);
+        }
+        processedState =
+            (await settleTournamentOutcome({
+                store,
+                daemonTransport,
+                state: nextState,
+            })) ?? nextState;
+    });
+
+    return processedState;
 };
 
 export const runTournamentWorker = async (): Promise<void> => {
@@ -527,10 +598,7 @@ export const runTournamentWorker = async (): Promise<void> => {
     await redis.connect();
 
     const store = new TournamentStore(redis.client, buildTournamentKeys(config.profileName));
-    const daemonTransport = new RedisTurnDaemonTransport(redis.client, {
-        keys: buildTurnDaemonStreamKeys(config.profileName),
-        requestTimeoutMs: config.daemonRequestTimeoutMs,
-    });
+    const daemonTransport = new DatabaseTurnDaemonTransport(postgres.prisma, config.daemonRequestTimeoutMs);
 
     const handleExit = async () => {
         await redis.disconnect();
@@ -541,49 +609,23 @@ export const runTournamentWorker = async (): Promise<void> => {
 
     while (true) {
         const state = await store.getState();
-        if (!state || !state.auto) {
+        if (!state || (!state.auto && !needsSettlement(state))) {
             await sleepMs(config.tournamentPollMs);
             continue;
         }
 
         const nextAt = new Date(state.nextAt).getTime();
         const now = Date.now();
-        if (Number.isFinite(nextAt) && nextAt > now) {
+        if (state.auto && Number.isFinite(nextAt) && nextAt > now) {
             await sleepMs(Math.min(config.tournamentPollMs, nextAt - now));
             continue;
         }
 
         try {
-            await store.withMutationLock(async () => {
-                const lockedState = await store.getState();
-                if (!lockedState || !lockedState.auto) {
-                    return;
-                }
-                const lockedNextAt = new Date(lockedState.nextAt).getTime();
-                if (Number.isFinite(lockedNextAt) && lockedNextAt > Date.now()) {
-                    return;
-                }
-
-                const worldState = await postgres.prisma.worldState.findFirst();
-                const baseSeed = (worldState?.meta as Record<string, unknown> | null)?.hiddenSeed ?? 'tournament';
-                let nextState = lockedState;
-                if (isBattleStage(lockedState.stage)) {
-                    nextState = await applyBattle(store, lockedState, String(baseSeed), daemonTransport);
-                } else if (isPreBattleStage(lockedState.stage)) {
-                    nextState = await applyPreBattleStage(
-                        store,
-                        postgres.prisma,
-                        lockedState,
-                        String(baseSeed),
-                        daemonTransport
-                    );
-                }
-
-                await settleTournamentOutcome({
-                    store,
-                    daemonTransport,
-                    state: nextState,
-                });
+            await processTournamentTick({
+                store,
+                prisma: postgres.prisma,
+                daemonTransport,
             });
         } catch (error) {
             const message = error instanceof Error ? error.message : 'Unknown error';
@@ -603,9 +645,9 @@ export const runTournamentWorker = async (): Promise<void> => {
                     },
                 },
             });
+            const currentState = (await store.getState()) ?? state;
             const nextState: TournamentState = {
-                ...state,
-                auto: false,
+                ...currentState,
                 lastError: message,
                 lastErrorAt: now,
             };

app/game-api/src/tournament/workerHelpers.ts

@@ -520,8 +520,9 @@ export const buildBettingPayouts = (
     const winners = entries.filter((entry) => entry.targetId === winnerId);
     const winnersTotal = winners.reduce((sum, entry) => sum + entry.amount, 0);
     if (winnersTotal <= 0) {
-        const refunds = entries.map((entry) => ({ generalId: entry.generalId, amount: entry.amount }));
-        return { payouts: refunds, total, refundAll: true };
+        // Legacy Betting::_calcRewardExclusive() builds a refund candidate list
+        // but returns no rewards when nobody selected the winner.
+        return { payouts: [], total, refundAll: false };
     }
     const ratio = total / winnersTotal;
     const payouts = winners.map((entry) => ({

app/game-api/src/trpc.ts

@@ -7,6 +7,21 @@ import { DuplicateInputEventError, executeInputEvent } from './inputEventBoundar
 
 const t = initTRPC.context<GameApiContext>().create();
 
+const requireAuthMiddleware = t.middleware(({ ctx, next }) => {
+    if (!ctx.auth) {
+        throw new TRPCError({
+            code: 'UNAUTHORIZED',
+            message: 'Unauthorized',
+        });
+    }
+    return next({
+        ctx: {
+            ...ctx,
+            auth: ctx.auth,
+        },
+    });
+});
+
 const inputEventMiddleware = t.middleware(async ({ ctx, type, path, next }) => {
     if (type !== 'mutation' || !ctx.db.$transaction) {
         return next();
@@ -46,17 +61,8 @@ const inputEventMiddleware = t.middleware(async ({ ctx, type, path, next }) => {
 
 export const router = t.router;
 export const procedure = t.procedure.use(inputEventMiddleware);
-export const authedProcedure: typeof procedure = procedure.use(({ ctx, next }) => {
-    if (!ctx.auth) {
-        throw new TRPCError({
-            code: 'UNAUTHORIZED',
-            message: 'Unauthorized',
-        });
-    }
-    return next({
-        ctx: {
-            ...ctx,
-            auth: ctx.auth,
-        },
-    });
-});
+export const authedProcedure: typeof procedure = procedure.use(requireAuthMiddleware);
+
+// 시뮬레이터처럼 게임 상태를 변경하지 않는 계산은 input-event transaction과
+// 이벤트 원장을 만들지 않는다. 인증은 유지하되 lifecycle DB 경계 밖에서 실행한다.
+export const readOnlyAuthedProcedure: typeof procedure = t.procedure.use(requireAuthMiddleware);

app/game-api/src/turns/commandTable.ts

@@ -203,6 +203,8 @@ const buildCommandEnv = (worldState: WorldStateRow): CommandEnv => {
         initialAllowedTechLevel: resolveNumber(constValues, ['initialAllowedTechLevel'], 1),
         baseGold: resolveNumber(constValues, ['baseGold', 'basegold'], 0),
         baseRice: resolveNumber(constValues, ['baseRice', 'baserice'], 0),
+        generalMinimumGold: resolveNumber(constValues, ['generalMinimumGold'], 0),
+        generalMinimumRice: resolveNumber(constValues, ['generalMinimumRice'], 500),
         maxResourceActionAmount: resolveNumber(constValues, ['maxResourceActionAmount'], 0),
     };
 };