fix: 개인 기록에 장수별 실행 시각을 보존

로그 발생 시각과 트랜잭션 flush 시각을 분리하고, 정규 및 즉시 장수 행동 로그에는 실행 전 장수 턴 시각을 기록한다. 기존 로그 행은 변경하지 않는다.

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

@@ -814,7 +814,11 @@ export class InMemoryTurnWorld {
         };
     }
 
-    pushLog(entry: LogEntryDraft): void {
+    pushLog(entry: LogEntryDraft, occurredAt?: Date): void {
+        if (occurredAt && !entry.occurredAt) {
+            this.logs.push({ ...entry, occurredAt: new Date(occurredAt.getTime()) });
+            return;
+        }
         this.logs.push(entry);
     }
 
@@ -1382,7 +1386,12 @@ export class InMemoryTurnWorld {
             this.dirtyNationIds.add(result.nation.id);
         }
         if (result.logs && result.logs.length > 0) {
-            this.logs.push(...result.logs);
+            // Ref command logs use the executing general's pre-advance turntime.
+            // Preserve that per-entry occurrence time instead of replacing every
+            // log in the transaction with the shared completion cursor at flush.
+            for (const log of result.logs) {
+                this.pushLog(log, currentGeneral.turnTime);
+            }
         }
         if (result.messages && result.messages.length > 0) {
             this.messages.push(...result.messages);

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

@@ -2245,10 +2245,13 @@ export const createImmediateGeneralActionExecutor = async (options: {
                     definition.formatConstraintFailure?.(reason, constraintCtx, args, view) ??
                     `${reason} ${definition.name} 실패.`;
                 if (input.actionKey === 'che_접경귀환' || input.actionKey === 'che_등용수락') {
-                    options.world.pushLog({
+                    options.world.pushLog(
-                        ...createActionLog(failureText),
+                        {
-                        generalId: general.id,
+                            ...createActionLog(failureText),
-                    });
+                            generalId: general.id,
+                        },
+                        general.turnTime
+                    );
                 }
                 return { ok: false, reason: failureText };
             }
@@ -2325,7 +2328,7 @@ export const createImmediateGeneralActionExecutor = async (options: {
 
             if (input.actionKey === 'che_접경귀환' && (resolution.general as TurnGeneral).cityId === general.cityId) {
                 for (const log of resolution.logs) {
-                    options.world.pushLog(log);
+                    options.world.pushLog(log, general.turnTime);
                 }
                 return { ok: false, reason: '가까운 아국 도시가 없습니다.' };
             }
@@ -2409,7 +2412,7 @@ export const createImmediateGeneralActionExecutor = async (options: {
                 options.world.removeTroop(troopId);
             }
             for (const log of [...resolution.logs, ...progressionLogs]) {
-                options.world.pushLog(log);
+                options.world.pushLog(log, general.turnTime);
             }
             options.world.updateGeneral(input.generalId, nextGeneral);
             return { ok: true };

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

@@ -1,5 +1,6 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
+import { LogCategory, LogScope } from '@sammo-ts/logic';
 
 import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
 import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
@@ -15,6 +16,7 @@ integration('general access score reset persistence', () => {
     let closeDb: (() => Promise<void>) | undefined;
 
     const cleanup = async () => {
+        await db.logEntry.deleteMany({ where: { generalId } });
         await db.generalAccessLog.deleteMany({ where: { generalId } });
         await db.general.deleteMany({ where: { id: generalId } });
         await db.worldState.deleteMany({ where: { scenarioCode } });
@@ -33,8 +35,9 @@ integration('general access score reset persistence', () => {
         await closeDb?.();
     });
 
-    it('commits the own-turn reset marker in the same world flush', async () => {
+    it('commits the own-turn reset marker and per-entry log occurrence time in the same world flush', async () => {
         const turnTime = new Date('2026-08-15T00:10:00.000Z');
+        const occurredAt = new Date('2026-08-15T00:07:43.000Z');
         await db.general.create({
             data: {
                 id: generalId,
@@ -95,6 +98,13 @@ integration('general access score reset persistence', () => {
             { schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] } }
         );
         world.markGeneralAccessScoreReset(generalId);
+        world.pushLog({
+            scope: LogScope.GENERAL,
+            category: LogCategory.ACTION,
+            text: '<C>●</>1월:아무것도 실행하지 않았습니다.',
+            generalId,
+            occurredAt,
+        });
         const hooks = await createDatabaseTurnHooks(databaseUrl!, world);
 
         try {
@@ -113,6 +123,12 @@ integration('general access score reset persistence', () => {
                 refreshScoreTotal: 999,
             });
             expect(world.peekDirtyState().accessScoreResetGeneralIds).toEqual([]);
+            expect(
+                await db.logEntry.findFirstOrThrow({
+                    where: { generalId, category: LogCategory.ACTION },
+                    select: { createdAt: true },
+                })
+            ).toEqual({ createdAt: occurredAt });
         } finally {
             await hooks.close();
         }

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

@@ -159,6 +159,25 @@ const makeState = (meta: Record<string, unknown> = {}): TurnWorldState => ({
 });
 
 describe('legacy general turn lifecycle', () => {
+    it('timestamps action logs with the executing general turn instead of the shared flush cursor', async () => {
+        const flushCursor = new Date('0200-01-01T00:35:00.000Z');
+        const generalTurnTime = new Date('0200-01-01T00:37:43.000Z');
+        const harness = await createTurnTestHarness({
+            snapshot: makeSnapshot([makeGeneral({ turnTime: generalTurnTime })]),
+            state: { ...makeState(), lastTurnTime: flushCursor },
+            schedule,
+            map,
+        });
+        harness.reservedTurnStore.getGeneralTurns(1)[0] = { action: '휴식', args: {} };
+
+        await harness.runOneTick();
+
+        const actionLog = harness.world
+            .peekDirtyState()
+            .logs.find((log) => log.text.includes('아무것도 실행하지 않았습니다.'));
+        expect(actionLog?.occurredAt).toEqual(generalTurnTime);
+    });
+
     it('emits legacy plain logs when command gains cross experience and dedication levels', async () => {
         const harness = await createTurnTestHarness({
             snapshot: makeSnapshot([

packages/logic/src/logging/entries.ts

@@ -47,8 +47,9 @@ export const finalizeLogEntry = (entry: LogEntryDraft, context: LogContext): Log
     if (entry.meta !== undefined) {
         record.meta = entry.meta;
     }
-    if (context.at !== undefined) {
+    const createdAt = entry.occurredAt ?? context.at;
-        record.createdAt = context.at;
+    if (createdAt !== undefined) {
+        record.createdAt = createdAt;
     }
 
     return record;

packages/logic/src/logging/types.ts

@@ -31,6 +31,8 @@ export interface LogEntryDraft {
     /** 월 경계 전 action처럼 flush 시점과 다른 달에 귀속되는 로그의 명시적 날짜. */
     year?: number;
     month?: number;
+    /** 로그를 만든 논리 게임 시각. 생략하면 flush context의 시각을 사용한다. */
+    occurredAt?: Date;
 }
 
 export interface LogEntryRecord {

packages/logic/test/loggingEntries.test.ts

@@ -22,4 +22,22 @@ describe('finalizeLogEntry', () => {
             text: '<C>●</>193년 12월:이전 달 사건',
         });
     });
+
+    it('keeps an explicit occurrence time instead of replacing it with the flush time', () => {
+        const occurredAt = new Date('0200-01-01T00:37:43.000Z');
+        const flushAt = new Date('0200-01-01T00:40:00.000Z');
+
+        expect(
+            finalizeLogEntry(
+                {
+                    scope: LogScope.GENERAL,
+                    category: LogCategory.ACTION,
+                    text: '상업 투자를 실행했습니다.',
+                    generalId: 1,
+                    occurredAt,
+                },
+                { year: 200, month: 1, at: flushAt }
+            )?.createdAt
+        ).toEqual(occurredAt);
+    });
 });