feat: Ref 호환 접속 제한과 벌점 초기화 구현

실행 중인 프로필에서만 접속 벌점을 누적하고 제한 임계값과 대상 경로를 Ref 순서에 맞춘다. 자기 턴 명령 성공 시 순간 점수를 같은 flush에서 초기화하며 월간 누적 감쇠는 유지한다. 제한 중 메인 자동 갱신과 실시간 구독을 중지하고 수동 갱신 성공 시 복구한다.

app/game-engine/src/turn/databaseHooks.ts

@@ -914,6 +914,7 @@ export const createDatabaseTurnHooks = async (
         let persistedVisibleLogs: PersistedVisibleLogRow[] = [];
         let visibleLogFloor = directLogFloor;
         const {
+            accessScoreResetGeneralIds,
             generals,
             cities,
             nations,
@@ -1012,6 +1013,13 @@ export const createDatabaseTurnHooks = async (
                 world.gameTickToDate(state.clockTick ?? state.lastTurnTick ?? 0)
             );
 
+            if (accessScoreResetGeneralIds.length > 0) {
+                await prisma.generalAccessLog.updateMany({
+                    where: { generalId: { in: accessScoreResetGeneralIds } },
+                    data: { refreshScore: 0 },
+                });
+            }
+
             if (inheritancePointAdjustments.length > 0) {
                 const grouped = new Map<string, { userId: string; key: string; amount: number }>();
                 for (const entry of inheritancePointAdjustments) {

app/game-engine/src/turn/inMemoryTurnProcessor.ts

@@ -2,7 +2,7 @@ import type { TurnCheckpoint, TurnProcessor, TurnRunBudget, TurnRunResult } from
 import { getNextTickTime } from '../lifecycle/getNextTickTime.js';
 import type { InMemoryTurnWorld } from './inMemoryWorld.js';
 import type { TurnGeneral } from './types.js';
-import { asNumber, asRecord } from '@sammo-ts/common';
+import { asNumber, asRecord, calculateAccessRefreshLimit } from '@sammo-ts/common';
 
 export interface InMemoryTurnProcessorOptions {
     tickMinutes?: number;
@@ -50,6 +50,9 @@ export class InMemoryTurnProcessor implements TurnProcessor {
         const isBudgetExpired = () => Date.now() >= deadlineMs;
 
         this.world.setCheckpoint(checkpoint);
+        this.world.updateWorldMeta({
+            refreshLimit: calculateAccessRefreshLimit(this.world.getState().tickSeconds),
+        });
 
         let processedGenerals = 0;
         let processedTurns = 0;
@@ -97,6 +100,9 @@ export class InMemoryTurnProcessor implements TurnProcessor {
             if (executionError !== undefined) {
                 throw executionError;
             }
+            // Ref의 updateTurnTime()은 장수 명령이 성공한 뒤 그 장수의
+            // 순간 벌점을 같은 턴 flush에서 초기화한다.
+            this.world.markGeneralAccessScoreReset(general.id);
             processedGenerals += 1;
             nextCheckpoint = {
                 turnTime: executedAt.toISOString(),

app/game-engine/src/turn/inMemoryWorld.ts

@@ -115,6 +115,7 @@ export interface InMemoryGameClockState {
 }
 
 export interface TurnWorldChanges {
+    accessScoreResetGeneralIds: number[];
     generals: TurnGeneral[];
     cities: City[];
     nations: Nation[];
@@ -156,6 +157,7 @@ export interface InMemoryTurnWorldStateSnapshot {
     dirtyNationIds: number[];
     dirtyTroopIds: number[];
     dirtyDiplomacyKeys: string[];
+    accessScoreResetGeneralIds: number[];
     createdGeneralIds: number[];
     createdNationIds: number[];
     createdTroopIds: number[];
@@ -419,6 +421,7 @@ export class InMemoryTurnWorld {
     private readonly dirtyNationIds = new Set<number>();
     private readonly dirtyTroopIds = new Set<number>();
     private readonly dirtyDiplomacyKeys = new Set<string>();
+    private readonly accessScoreResetGeneralIds = new Set<number>();
     private readonly createdGeneralIds = new Set<number>();
     private nextLegacyGeneralScanOrder = 0;
     private readonly createdNationIds = new Set<number>();
@@ -606,6 +609,7 @@ export class InMemoryTurnWorld {
             dirtyNationIds: Array.from(this.dirtyNationIds),
             dirtyTroopIds: Array.from(this.dirtyTroopIds),
             dirtyDiplomacyKeys: Array.from(this.dirtyDiplomacyKeys),
+            accessScoreResetGeneralIds: Array.from(this.accessScoreResetGeneralIds),
             createdGeneralIds: Array.from(this.createdGeneralIds),
             createdNationIds: Array.from(this.createdNationIds),
             createdTroopIds: Array.from(this.createdTroopIds),
@@ -644,6 +648,7 @@ export class InMemoryTurnWorld {
         this.replaceSet(this.dirtyNationIds, restored.dirtyNationIds);
         this.replaceSet(this.dirtyTroopIds, restored.dirtyTroopIds);
         this.replaceSet(this.dirtyDiplomacyKeys, restored.dirtyDiplomacyKeys);
+        this.replaceSet(this.accessScoreResetGeneralIds, restored.accessScoreResetGeneralIds ?? []);
         this.replaceSet(this.createdGeneralIds, restored.createdGeneralIds);
         this.replaceSet(this.createdNationIds, restored.createdNationIds);
         this.replaceSet(this.createdTroopIds, restored.createdTroopIds);
@@ -693,6 +698,12 @@ export class InMemoryTurnWorld {
         };
     }
 
+    markGeneralAccessScoreReset(generalId: number): void {
+        if (Number.isSafeInteger(generalId) && generalId > 0) {
+            this.accessScoreResetGeneralIds.add(generalId);
+        }
+    }
+
     changeTurnTerm(tickMinutes: number): void {
         if (!Number.isInteger(tickMinutes) || tickMinutes <= 0) {
             throw new Error('Turn term must be a positive integer.');
@@ -1512,8 +1523,12 @@ export class InMemoryTurnWorld {
         }));
         const pendingYearbookSnapshots = structuredClone(this.pendingYearbookSnapshots);
         const pendingUnificationFinalizations = structuredClone(this.pendingUnificationFinalizations);
+        const accessScoreResetGeneralIds = Array.from(this.accessScoreResetGeneralIds).sort(
+            (left, right) => left - right
+        );
 
         return {
+            accessScoreResetGeneralIds,
             generals,
             cities,
             nations,
@@ -1542,6 +1557,7 @@ export class InMemoryTurnWorld {
     }
 
     acknowledgeDirtyState(changes: TurnWorldChanges): void {
+        for (const id of changes.accessScoreResetGeneralIds) this.accessScoreResetGeneralIds.delete(id);
         for (const general of changes.generals) this.dirtyGeneralIds.delete(general.id);
         for (const city of changes.cities) this.dirtyCityIds.delete(city.id);
         for (const nation of changes.nations) this.dirtyNationIds.delete(nation.id);

app/game-engine/test/generalAccessScoreResetPersistence.integration.test.ts

@@ -0,0 +1,120 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
+
+import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
+import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
+import type { TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
+
+const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
+const integration = describe.skipIf(!databaseUrl);
+const generalId = 991_815;
+const scenarioCode = 'general-access-score-reset-persistence';
+
+integration('general access score reset persistence', () => {
+    let db: GamePrismaClient;
+    let closeDb: (() => Promise<void>) | undefined;
+
+    const cleanup = async () => {
+        await db.generalAccessLog.deleteMany({ where: { generalId } });
+        await db.general.deleteMany({ where: { id: generalId } });
+        await db.worldState.deleteMany({ where: { scenarioCode } });
+    };
+
+    beforeAll(async () => {
+        const connector = createGamePostgresConnector({ url: databaseUrl! });
+        await connector.connect();
+        db = connector.prisma;
+        closeDb = () => connector.disconnect();
+        await cleanup();
+    });
+
+    afterAll(async () => {
+        await cleanup();
+        await closeDb?.();
+    });
+
+    it('commits the own-turn reset marker in the same world flush', async () => {
+        const turnTime = new Date('2026-08-15T00:10:00.000Z');
+        await db.general.create({
+            data: {
+                id: generalId,
+                userId: 'access-reset-persistence-user',
+                name: '접속점수초기화장수',
+                turnTime,
+            },
+        });
+        await db.generalAccessLog.create({
+            data: {
+                generalId,
+                userId: 'access-reset-persistence-user',
+                lastRefresh: new Date('2026-08-15T00:09:59.000Z'),
+                refresh: 120,
+                refreshTotal: 500,
+                refreshScore: 351,
+                refreshScoreTotal: 999,
+            },
+        });
+        const row = await db.worldState.create({
+            data: {
+                scenarioCode,
+                currentYear: 200,
+                currentMonth: 1,
+                tickSeconds: 600,
+                config: {},
+                meta: {},
+            },
+        });
+        const state: TurnWorldState = {
+            id: row.id,
+            currentYear: 200,
+            currentMonth: 1,
+            tickSeconds: 600,
+            lastTurnTime: new Date('2026-08-15T00:00:00.000Z'),
+            meta: {},
+        };
+        const scenarioConfig: TurnWorldSnapshot['scenarioConfig'] = {
+            stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 75, npcMin: 10, chiefMin: 70 },
+            iconPath: '.',
+            map: {},
+            const: {},
+            environment: { mapName: 'test', unitSet: 'default' },
+        };
+        const world = new InMemoryTurnWorld(
+            state,
+            {
+                scenarioConfig,
+                map: { id: 'test', name: 'test', cities: [] },
+                generals: [],
+                cities: [],
+                nations: [],
+                troops: [],
+                diplomacy: [],
+                events: [],
+                initialEvents: [],
+            },
+            { schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] } }
+        );
+        world.markGeneralAccessScoreReset(generalId);
+        const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
+
+        try {
+            await hooks.hooks.flushChanges?.({
+                lastTurnTime: state.lastTurnTime.toISOString(),
+                processedGenerals: 1,
+                processedTurns: 1,
+                durationMs: 0,
+                partial: false,
+            });
+
+            expect(await db.generalAccessLog.findUniqueOrThrow({ where: { generalId } })).toMatchObject({
+                refresh: 120,
+                refreshTotal: 500,
+                refreshScore: 0,
+                refreshScoreTotal: 999,
+            });
+            expect(world.peekDirtyState().accessScoreResetGeneralIds).toEqual([]);
+        } finally {
+            await hooks.close();
+        }
+    });
+});

app/game-engine/test/turnOrder.test.ts

@@ -174,6 +174,8 @@ describe('InMemoryTurnProcessor ordering', () => {
         const tiedGeneralResult = await processor.run(new Date(addMinutes(baseTime, 10).getTime() + 1), budget);
         expect(tiedGeneralResult.processedTurns).toBe(0);
         expect(executed).toEqual([3, 2]);
+        expect(world.peekDirtyState().accessScoreResetGeneralIds).toEqual([2, 3]);
+        expect(world.getState().meta).toMatchObject({ refreshLimit: 350 });
         expect(world.getGeneralById(2)?.recentWarTime?.getTime()).toBe(baseTime.getTime());
         expect(world.getGeneralById(2)?.recentWarTick).not.toBeNull();
         expect(Number(world.getGeneralById(2)?.turnTick) % 10).toBe(4);