feat: complete nation personnel and finance parity

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

@@ -23,6 +23,7 @@ import {
     type ItemModule,
     type TriggerValue,
 } from '@sammo-ts/logic';
+import { simpleSerialize } from '@sammo-ts/logic/war/utils.js';
 import {
     cloneItemInventory,
     ensureItemInventory,
@@ -56,6 +57,51 @@ const readMetaNumber = (meta: Record<string, unknown>, key: string, fallback: nu
     return fallback;
 };
 
+const hasOfficerLock = (meta: Record<string, unknown>, key: string, officerLevel: number): boolean =>
+    (readMetaNumber(meta, key, 0) & (1 << officerLevel)) !== 0;
+
+const setOfficerLock = (
+    meta: Record<string, TriggerValue>,
+    key: string,
+    officerLevel: number
+): Record<string, TriggerValue> => ({
+    ...meta,
+    [key]: readMetaNumber(meta, key, 0) | (1 << officerLevel),
+});
+
+const resolveNationChiefLevel = (nationLevel: number): number => {
+    if (nationLevel >= 6) return 5;
+    if (nationLevel >= 4) return 7;
+    if (nationLevel >= 2) return 9;
+    return 11;
+};
+
+const resolvePermissionKind = (general: TurnGeneral): 'normal' | 'ambassador' | 'auditor' => {
+    const permission = general.meta.permission;
+    return permission === 'ambassador' || permission === 'auditor' ? permission : 'normal';
+};
+
+const resolveMaxSecretPermission = (general: TurnGeneral): number => {
+    const penalty = asRecord(general.penalty);
+    if (penalty.noTopSecret || penalty.noChief) return 1;
+    if (penalty.noAmbassador) return 2;
+    return 4;
+};
+
+const refreshActorKillturn = (world: InMemoryTurnWorld, actor: TurnGeneral): void => {
+    const worldKillturn = readMetaNumber(asRecord(world.getState().meta), 'killturn', 0);
+    const actorKillturn = readMetaNumber(asRecord(actor.meta), 'killturn', 0);
+    if (worldKillturn <= actorKillturn) {
+        return;
+    }
+    world.updateGeneral(actor.id, {
+        meta: {
+            ...actor.meta,
+            killturn: worldKillturn,
+        },
+    });
+};
+
 interface CommandHandlerContext {
     world: InMemoryTurnWorld;
     commandDb?: GamePrisma.TransactionClient;
@@ -868,20 +914,57 @@ async function handleChangePermission(
         };
     }
     const nation = world.getNationById(general.nationId);
-    if (!nation || nation.chiefGeneralId !== general.id) {
-        return { type: 'changePermission', ok: false, generalId: command.generalId, reason: '권한이 없습니다.' };
+    if (!nation || general.officerLevel !== 12 || nation.chiefGeneralId !== general.id) {
+        return { type: 'changePermission', ok: false, generalId: command.generalId, reason: '군주가 아닙니다.' };
     }
 
-    for (const targetId of command.targetGeneralIds) {
+    const uniqueTargetIds = [...new Set(command.targetGeneralIds)];
+    if (uniqueTargetIds.length > 2) {
+        return {
+            type: 'changePermission',
+            ok: false,
+            generalId: command.generalId,
+            reason: command.isAmbassador
+                ? '외교권자는 최대 둘까지만 설정 가능합니다.'
+                : '조언자는 최대 둘까지만 설정 가능합니다.',
+        };
+    }
+
+    const targetType = command.isAmbassador ? 'ambassador' : 'auditor';
+    const requiredPermission = command.isAmbassador ? 4 : 3;
+    const targets: TurnGeneral[] = [];
+    for (const targetId of uniqueTargetIds) {
         const target = world.getGeneralById(targetId);
-        if (target && target.nationId === general.nationId) {
-            world.updateGeneral(targetId, {
-                meta: {
-                    ...target.meta,
-                    permission: command.isAmbassador ? 'ambassador' : 'auditor',
-                },
-            });
+        if (
+            !target ||
+            target.nationId !== general.nationId ||
+            target.officerLevel === 12 ||
+            !['normal', targetType].includes(resolvePermissionKind(target)) ||
+            resolveMaxSecretPermission(target) < requiredPermission
+        ) {
+            continue;
         }
+        targets.push(target);
+    }
+
+    for (const candidate of world.listGenerals()) {
+        if (candidate.nationId !== general.nationId || resolvePermissionKind(candidate) !== targetType) {
+            continue;
+        }
+        world.updateGeneral(candidate.id, {
+            meta: {
+                ...candidate.meta,
+                permission: 'normal',
+            },
+        });
+    }
+    for (const target of targets) {
+        world.updateGeneral(target.id, {
+            meta: {
+                ...target.meta,
+                permission: targetType,
+            },
+        });
     }
     return { type: 'changePermission', ok: true, generalId: command.generalId };
 }
@@ -896,12 +979,24 @@ async function handleKick(
         return { type: 'kick', ok: false, generalId: command.generalId, reason: '장수 정보를 찾을 수 없습니다.' };
     }
     const nation = world.getNationById(general.nationId);
-    if (!nation || nation.chiefGeneralId !== general.id) {
-        return { type: 'kick', ok: false, generalId: command.generalId, reason: '권한이 없습니다.' };
+    if (!nation || general.officerLevel < 5) {
+        return { type: 'kick', ok: false, generalId: command.generalId, reason: '수뇌가 아닙니다.' };
+    }
+    const actorPenalty = asRecord(general.penalty);
+    if (actorPenalty.noBanGeneral) {
+        return { type: 'kick', ok: false, generalId: command.generalId, reason: '추방할 수 없는 상태입니다.' };
+    }
+    if (hasOfficerLock(asRecord(nation.meta), 'chief_set', general.officerLevel)) {
+        return {
+            type: 'kick',
+            ok: false,
+            generalId: command.generalId,
+            reason: '이미 추방 권한을 사용했습니다.',
+        };
     }
 
     const target = world.getGeneralById(command.destGeneralId);
-    if (!target || target.nationId !== general.nationId) {
+    if (!target || target.id === general.id || target.nationId !== general.nationId) {
         return {
             type: 'kick',
             ok: false,
@@ -909,11 +1004,138 @@ async function handleKick(
             reason: '대상을 찾을 수 없거나 같은 국가가 아닙니다.',
         };
     }
+    if (resolveMaxSecretPermission(target) === 4 && resolvePermissionKind(target) === 'ambassador') {
+        return {
+            type: 'kick',
+            ok: false,
+            generalId: command.generalId,
+            reason: '외교권자는 추방할 수 없습니다.',
+        };
+    }
+
+    const config = asRecord(world.getScenarioConfig().const);
+    const defaultGold = readMetaNumber(config, 'defaultGold', 1000);
+    const defaultRice = readMetaNumber(config, 'defaultRice', 1000);
+    const returnedGold = Math.max(0, target.gold - defaultGold);
+    const returnedRice = Math.max(0, target.rice - defaultRice);
+    const targetMeta = target.meta;
+    const nextMeta: TurnGeneral['meta'] = {
+        ...targetMeta,
+        officerCity: 0,
+        officer_city: 0,
+        belong: 0,
+        makelimit: 12,
+        permission: 'normal',
+    };
+
+    const worldState = world.getState();
+    const scenarioMeta = asRecord(asRecord(worldState.meta).scenarioMeta);
+    const startYear = readMetaNumber(scenarioMeta, 'startYear', worldState.currentYear);
+    if (worldState.currentYear > startYear || target.npcState >= 2) {
+        const betray = Math.max(0, readMetaNumber(targetMeta, 'betray', 0));
+        const maxBetrayCnt = readMetaNumber(config, 'maxBetrayCnt', 9);
+        nextMeta.betray = Math.min(maxBetrayCnt, betray + 1);
+        world.updateGeneral(target.id, {
+            experience: Math.max(0, Math.floor(target.experience - target.experience * 0.15 * betray)),
+            dedication: Math.max(0, Math.floor(target.dedication - target.dedication * 0.15 * betray)),
+        });
+    } else {
+        nextMeta.makelimit = targetMeta.makelimit ?? 12;
+    }
+    if (worldState.currentYear < startYear + 3) {
+        const ruler = world.getGeneralById(nation.chiefGeneralId ?? 0);
+        if (ruler) {
+            world.updateGeneral(ruler.id, { injury: Math.min(80, ruler.injury + 1) });
+        }
+    }
+
+    if (target.troopId === target.id) {
+        for (const member of world.listGenerals()) {
+            if (member.troopId === target.id) {
+                world.updateGeneral(member.id, { troopId: 0 });
+            }
+        }
+        world.removeTroop(target.id);
+    }
 
     world.updateGeneral(command.destGeneralId, {
         nationId: 0,
         officerLevel: 0,
+        troopId: 0,
+        gold: Math.min(target.gold, defaultGold),
+        rice: Math.min(target.rice, defaultRice),
+        meta: nextMeta,
     });
+    const nationMeta =
+        worldState.currentYear >= startYear + 3
+            ? setOfficerLock(nation.meta, 'chief_set', general.officerLevel)
+            : { ...nation.meta };
+    nationMeta.gennum = Math.max(0, readMetaNumber(nation.meta, 'gennum', 0) - (target.npcState !== 5 ? 1 : 0));
+    world.updateNation(nation.id, {
+        gold: nation.gold + returnedGold,
+        rice: nation.rice + returnedRice,
+        meta: nationMeta,
+    });
+    refreshActorKillturn(world, general);
+
+    const josaYi = JosaUtil.pick(target.name, '이');
+    world.pushLog({
+        scope: LogScope.SYSTEM,
+        category: LogCategory.SUMMARY,
+        format: LogFormat.MONTH,
+        text: `<Y>${target.name}</>${josaYi} <D><b>${nation.name}</b></>에서 <R>추방</>당했습니다.`,
+        meta: {},
+    });
+    world.pushLog({
+        scope: LogScope.GENERAL,
+        category: LogCategory.HISTORY,
+        format: LogFormat.YEAR_MONTH,
+        text: `<D>${nation.name}</>에서 추방됨`,
+        generalId: target.id,
+        meta: {},
+    });
+    if (target.npcState >= 2) {
+        const worldMeta = asRecord(worldState.meta);
+        const hiddenSeed = worldMeta.hiddenSeed ?? worldMeta.seed ?? worldState.id;
+        const rng = new RandUtil(
+            new LiteHashDRBG(
+                simpleSerialize(
+                    typeof hiddenSeed === 'string' || typeof hiddenSeed === 'number' ? hiddenSeed : String(hiddenSeed),
+                    'BanNPC',
+                    worldState.currentYear,
+                    worldState.currentMonth,
+                    target.id
+                )
+            )
+        );
+        const npcBanMessageProb = readMetaNumber(config, 'npcBanMessageProb', 0.01);
+        if (rng.nextBool(npcBanMessageProb)) {
+            const text = rng.choice([
+                '날 버리다니... 곧 전장에서 복수해주겠다...',
+                '추방이라... 내가 무얼 잘못했단 말인가...',
+                '어디 추방해가면서 잘되나 보자... 꼭 복수하겠다.',
+                '인덕이 제일이거늘... 추방이 웬말인가... 저주한다!',
+                '날 추방했으니 그 복수로 적국에 정보를 팔아 넘겨야겠군요. 그럼 이만.',
+            ]);
+            const messageTarget = {
+                generalId: target.id,
+                generalName: target.name,
+                nationId: nation.id,
+                nationName: nation.name,
+                color: nation.color,
+                icon: target.picture === null ? '' : String(target.picture),
+            };
+            world.queueMessage({
+                msgType: 'public',
+                src: messageTarget,
+                dest: messageTarget,
+                text,
+                time: new Date(),
+                validUntil: new Date('9999-12-31T00:00:00.000Z'),
+                option: {},
+            });
+        }
+    }
     return { type: 'kick', ok: true, generalId: command.generalId };
 }
 
@@ -927,8 +1149,17 @@ async function handleAppoint(
         return { type: 'appoint', ok: false, generalId: command.generalId, reason: '장수 정보를 찾을 수 없습니다.' };
     }
     const nation = world.getNationById(general.nationId);
-    if (!nation || nation.chiefGeneralId !== general.id) {
-        return { type: 'appoint', ok: false, generalId: command.generalId, reason: '권한이 없습니다.' };
+    if (!nation || general.officerLevel < 5) {
+        return { type: 'appoint', ok: false, generalId: command.generalId, reason: '수뇌가 아닙니다.' };
+    }
+    const actorPenalty = asRecord(general.penalty);
+    if (command.officerLevel === 12) {
+        return {
+            type: 'appoint',
+            ok: false,
+            generalId: command.generalId,
+            reason: '군주를 대상으로 할 수 없습니다.',
+        };
     }
 
     const target = world.getGeneralById(command.destGeneralId);
@@ -941,16 +1172,72 @@ async function handleAppoint(
         };
     }
 
-    if (command.officerLevel >= 5) {
+    if (command.officerLevel >= 5 && command.officerLevel < 12) {
+        if (actorPenalty.noChiefChange) {
+            return {
+                type: 'appoint',
+                ok: false,
+                generalId: command.generalId,
+                reason: '수뇌를 임명할 수 없는 상태입니다.',
+            };
+        }
+        const minLevel = resolveNationChiefLevel(nation.level);
+        if (command.officerLevel < minLevel) {
+            return {
+                type: 'appoint',
+                ok: false,
+                generalId: command.generalId,
+                reason: '임명불가능한 관직입니다.',
+            };
+        }
+        if (hasOfficerLock(asRecord(nation.meta), 'chief_set', command.officerLevel)) {
+            return {
+                type: 'appoint',
+                ok: false,
+                generalId: command.generalId,
+                reason: '지금은 임명할 수 없습니다.',
+            };
+        }
+        if (target) {
+            const targetPenalty = asRecord(target.penalty);
+            if (targetPenalty.noChief) {
+                return {
+                    type: 'appoint',
+                    ok: false,
+                    generalId: command.generalId,
+                    reason: '수뇌가 될 수 없는 상태입니다.',
+                };
+            }
+            const chiefStatMin = world.getScenarioConfig().stat.chiefMin;
+            if (command.officerLevel !== 11 && command.officerLevel % 2 === 0 && target.stats.strength < chiefStatMin) {
+                return { type: 'appoint', ok: false, generalId: command.generalId, reason: '무력이 부족합니다.' };
+            }
+            if (
+                command.officerLevel !== 11 &&
+                command.officerLevel % 2 === 1 &&
+                target.stats.intelligence < chiefStatMin
+            ) {
+                return { type: 'appoint', ok: false, generalId: command.generalId, reason: '지력이 부족합니다.' };
+            }
+        }
         for (const g of world.listGenerals()) {
             if (g.nationId === general.nationId && g.officerLevel === command.officerLevel) {
-                world.updateGeneral(g.id, { officerLevel: 0 });
+                world.updateGeneral(g.id, {
+                    officerLevel: 1,
+                    meta: { ...g.meta, officerCity: 0, officer_city: 0 },
+                });
             }
         }
         if (command.destGeneralId !== 0) {
-            world.updateGeneral(command.destGeneralId, { officerLevel: command.officerLevel });
+            world.updateGeneral(command.destGeneralId, {
+                officerLevel: command.officerLevel,
+                meta: { ...target!.meta, officerCity: 0, officer_city: 0 },
+            });
         }
-    } else {
+        world.updateNation(nation.id, {
+            meta: setOfficerLock(nation.meta, 'chief_set', command.officerLevel),
+        });
+    } else if (command.officerLevel >= 2 && command.officerLevel <= 4) {
         const city = world.getCityById(command.destCityId);
         if (!city || city.nationId !== general.nationId) {
             return {
@@ -960,22 +1247,54 @@ async function handleAppoint(
                 reason: '도시를 찾을 수 없거나 아군 도시가 아닙니다.',
             };
         }
+        if (hasOfficerLock(asRecord(city.meta), 'officer_set', command.officerLevel)) {
+            return {
+                type: 'appoint',
+                ok: false,
+                generalId: command.generalId,
+                reason: '이미 다른 장수가 임명되어있습니다.',
+            };
+        }
+        if (target && target.officerLevel >= 4 && actorPenalty.noChiefChange) {
+            return {
+                type: 'appoint',
+                ok: false,
+                generalId: command.generalId,
+                reason: '수뇌인 장수를 변경할 수 없는 상태입니다.',
+            };
+        }
+        const chiefStatMin = world.getScenarioConfig().stat.chiefMin;
+        if (target && command.officerLevel === 4 && target.stats.strength < chiefStatMin) {
+            return { type: 'appoint', ok: false, generalId: command.generalId, reason: '무력이 부족합니다.' };
+        }
+        if (target && command.officerLevel === 3 && target.stats.intelligence < chiefStatMin) {
+            return { type: 'appoint', ok: false, generalId: command.generalId, reason: '지력이 부족합니다.' };
+        }
         for (const g of world.listGenerals()) {
             if (
                 g.nationId === general.nationId &&
                 g.meta.officerCity === command.destCityId &&
                 g.officerLevel === command.officerLevel
             ) {
-                world.updateGeneral(g.id, { officerLevel: 0, meta: { ...g.meta, officerCity: 0 } });
+                world.updateGeneral(g.id, {
+                    officerLevel: 1,
+                    meta: { ...g.meta, officerCity: 0, officer_city: 0 },
+                });
             }
         }
         if (command.destGeneralId !== 0) {
             world.updateGeneral(command.destGeneralId, {
                 officerLevel: command.officerLevel,
-                meta: { ...target!.meta, officerCity: command.destCityId },
+                meta: { ...target!.meta, officerCity: command.destCityId, officer_city: command.destCityId },
             });
         }
+        world.updateCity(city.id, {
+            meta: setOfficerLock(city.meta, 'officer_set', command.officerLevel),
+        });
+    } else {
+        return { type: 'appoint', ok: false, generalId: command.generalId, reason: '올바르지 않은 지정입니다.' };
     }
+    refreshActorKillturn(world, general);
     return { type: 'appoint', ok: true, generalId: command.generalId };
 }
 

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

@@ -0,0 +1,350 @@
+import { describe, expect, it } from 'vitest';
+
+import type { TriggerValue, TurnSchedule } from '@sammo-ts/logic';
+
+import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
+import type { TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
+import { createTurnDaemonCommandHandler } from '../src/turn/worldCommandHandler.js';
+
+const schedule: TurnSchedule = { entries: [{ startMinute: 0, tickMinutes: 10 }] };
+
+const buildGeneral = (id: number, overrides: Partial<TurnGeneral> = {}): TurnGeneral => ({
+    id,
+    userId: `user-${id}`,
+    name: `장수${id}`,
+    nationId: 1,
+    cityId: 1,
+    troopId: 0,
+    stats: { leadership: 70, strength: 70, intelligence: 70 },
+    turnTime: new Date('0185-01-01T00:00:00Z'),
+    recentWarTime: null,
+    role: {
+        items: { horse: null, weapon: null, book: null, item: null },
+        personality: null,
+        specialDomestic: null,
+        specialWar: null,
+    },
+    triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
+    meta: { killturn: 12, belong: 5, permission: 'normal' },
+    penalty: {},
+    officerLevel: 1,
+    experience: 1_000,
+    dedication: 2_000,
+    injury: 0,
+    gold: 1_500,
+    rice: 1_600,
+    crew: 100,
+    crewTypeId: 0,
+    train: 0,
+    atmos: 0,
+    age: 30,
+    npcState: 0,
+    ...overrides,
+});
+
+const buildWorld = (options: {
+    generals?: TurnGeneral[];
+    nationMeta?: Record<string, TriggerValue>;
+    cityMeta?: Record<string, TriggerValue>;
+    currentYear?: number;
+    scenarioConst?: Record<string, unknown>;
+}) => {
+    const state: TurnWorldState = {
+        id: 1,
+        currentYear: options.currentYear ?? 185,
+        currentMonth: 1,
+        tickSeconds: 600,
+        lastTurnTime: new Date('0185-01-01T00:00:00Z'),
+        meta: { killturn: 24, scenarioMeta: { startYear: 180 } },
+    };
+    const snapshot: TurnWorldSnapshot = {
+        generals: options.generals ?? [
+            buildGeneral(1, { officerLevel: 12 }),
+            buildGeneral(2, { officerLevel: 5 }),
+            buildGeneral(3),
+        ],
+        cities: [
+            {
+                id: 1,
+                name: '허창',
+                nationId: 1,
+                level: 7,
+                state: 0,
+                population: 1_000,
+                populationMax: 2_000,
+                agriculture: 1_000,
+                agricultureMax: 2_000,
+                commerce: 1_000,
+                commerceMax: 2_000,
+                security: 1_000,
+                securityMax: 2_000,
+                supplyState: 1,
+                frontState: 0,
+                defence: 1_000,
+                defenceMax: 2_000,
+                wall: 1_000,
+                wallMax: 2_000,
+                meta: options.cityMeta ?? {},
+            },
+        ],
+        nations: [
+            {
+                id: 1,
+                name: '위',
+                color: '#777777',
+                capitalCityId: 1,
+                chiefGeneralId: 1,
+                gold: 10_000,
+                rice: 20_000,
+                power: 0,
+                level: 3,
+                typeCode: 'che_법가',
+                meta: options.nationMeta ?? {},
+            },
+        ],
+        troops: [],
+        diplomacy: [],
+        events: [],
+        initialEvents: [],
+        scenarioConfig: {
+            stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 65 },
+            iconPath: '',
+            map: {},
+            const: { defaultGold: 1000, defaultRice: 1000, ...options.scenarioConst },
+            environment: { mapName: 'test', unitSet: 'test' },
+        },
+        scenarioMeta: {
+            title: 'test',
+            startYear: 180,
+            life: null,
+            fiction: null,
+            history: [],
+            ignoreDefaultEvents: false,
+        },
+        map: {
+            id: 'test',
+            name: 'test',
+            cities: [],
+            defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
+        },
+    };
+    const world = new InMemoryTurnWorld(state, snapshot, { schedule });
+    return { world, handler: createTurnDaemonCommandHandler({ world }) };
+};
+
+describe('nation personnel world commands', () => {
+    it('allows any unlocked head officer to appoint and preserves legacy officer state', async () => {
+        const { world, handler } = buildWorld({});
+        await expect(
+            handler.handle({ type: 'appoint', generalId: 2, destGeneralId: 3, destCityId: 0, officerLevel: 9 })
+        ).resolves.toMatchObject({ ok: true });
+        expect(world.getGeneralById(3)).toMatchObject({
+            officerLevel: 9,
+            meta: expect.objectContaining({ officerCity: 0, officer_city: 0 }),
+        });
+        expect(world.getGeneralById(2)?.meta.killturn).toBe(24);
+        expect(Number(world.getNationById(1)?.meta.chief_set) & (1 << 9)).toBe(1 << 9);
+    });
+
+    it('enforces actor, stat, penalty, and monthly lock boundaries without partial mutation', async () => {
+        const weak = buildGeneral(3, { stats: { leadership: 70, strength: 64, intelligence: 64 } });
+        const fixture = buildWorld({
+            generals: [buildGeneral(1, { officerLevel: 12 }), buildGeneral(2, { officerLevel: 5 }), weak],
+        });
+        await expect(
+            fixture.handler.handle({
+                type: 'appoint',
+                generalId: 3,
+                destGeneralId: 2,
+                destCityId: 0,
+                officerLevel: 9,
+            })
+        ).resolves.toMatchObject({ ok: false, reason: '수뇌가 아닙니다.' });
+        await expect(
+            fixture.handler.handle({
+                type: 'appoint',
+                generalId: 2,
+                destGeneralId: 3,
+                destCityId: 0,
+                officerLevel: 9,
+            })
+        ).resolves.toMatchObject({ ok: false, reason: '지력이 부족합니다.' });
+        expect(fixture.world.getGeneralById(3)?.officerLevel).toBe(1);
+
+        const locked = buildWorld({ nationMeta: { chief_set: 1 << 9 } });
+        await expect(
+            locked.handler.handle({
+                type: 'appoint',
+                generalId: 2,
+                destGeneralId: 3,
+                destCityId: 0,
+                officerLevel: 9,
+            })
+        ).resolves.toMatchObject({ ok: false, reason: '지금은 임명할 수 없습니다.' });
+    });
+
+    it('appoints city officers, releases prior holders to general, and respects city locks', async () => {
+        const previous = buildGeneral(4, { officerLevel: 4, meta: { killturn: 12, officerCity: 1 } });
+        const fixture = buildWorld({
+            generals: [
+                buildGeneral(1, { officerLevel: 12 }),
+                buildGeneral(2, { officerLevel: 5 }),
+                buildGeneral(3),
+                previous,
+            ],
+        });
+        await expect(
+            fixture.handler.handle({
+                type: 'appoint',
+                generalId: 2,
+                destGeneralId: 3,
+                destCityId: 1,
+                officerLevel: 4,
+            })
+        ).resolves.toMatchObject({ ok: true });
+        expect(fixture.world.getGeneralById(4)).toMatchObject({
+            officerLevel: 1,
+            meta: expect.objectContaining({ officerCity: 0 }),
+        });
+        expect(fixture.world.getGeneralById(3)).toMatchObject({
+            officerLevel: 4,
+            meta: expect.objectContaining({ officerCity: 1 }),
+        });
+
+        const locked = buildWorld({ cityMeta: { officer_set: 1 << 4 } });
+        await expect(
+            locked.handler.handle({
+                type: 'appoint',
+                generalId: 2,
+                destGeneralId: 3,
+                destCityId: 1,
+                officerLevel: 4,
+            })
+        ).resolves.toMatchObject({ ok: false, reason: '이미 다른 장수가 임명되어있습니다.' });
+    });
+
+    it('replaces only eligible permission holders and rejects non-ruler or oversized requests', async () => {
+        const fixture = buildWorld({
+            generals: [
+                buildGeneral(1, { officerLevel: 12 }),
+                buildGeneral(2, { officerLevel: 5, meta: { killturn: 12, permission: 'ambassador' } }),
+                buildGeneral(3),
+                buildGeneral(4, { penalty: { noAmbassador: true } }),
+                buildGeneral(5),
+                buildGeneral(6),
+            ],
+        });
+        await expect(
+            fixture.handler.handle({
+                type: 'changePermission',
+                generalId: 2,
+                isAmbassador: true,
+                targetGeneralIds: [3],
+            })
+        ).resolves.toMatchObject({ ok: false, reason: '군주가 아닙니다.' });
+        await expect(
+            fixture.handler.handle({
+                type: 'changePermission',
+                generalId: 1,
+                isAmbassador: true,
+                targetGeneralIds: [3, 5, 6],
+            })
+        ).resolves.toMatchObject({ ok: false, reason: expect.stringContaining('최대 둘') });
+
+        await expect(
+            fixture.handler.handle({
+                type: 'changePermission',
+                generalId: 1,
+                isAmbassador: true,
+                targetGeneralIds: [2, 3, 4],
+            })
+        ).resolves.toMatchObject({ ok: false, reason: expect.stringContaining('최대 둘') });
+
+        await expect(
+            fixture.handler.handle({
+                type: 'changePermission',
+                generalId: 1,
+                isAmbassador: true,
+                targetGeneralIds: [2, 3],
+            })
+        ).resolves.toMatchObject({ ok: true });
+        expect(fixture.world.getGeneralById(2)?.meta.permission).toBe('ambassador');
+        expect(fixture.world.getGeneralById(3)?.meta.permission).toBe('ambassador');
+        expect(fixture.world.getGeneralById(4)?.meta.permission).toBe('normal');
+    });
+
+    it('kicks for an unlocked head officer with resource, troop, permission, and log side effects', async () => {
+        const target = buildGeneral(3, {
+            troopId: 3,
+            gold: 2_500,
+            rice: 3_000,
+            experience: 1_000,
+            dedication: 2_000,
+            meta: { killturn: 12, permission: 'normal', belong: 8, betray: 1 },
+        });
+        const member = buildGeneral(4, { troopId: 3 });
+        const fixture = buildWorld({
+            generals: [buildGeneral(1, { officerLevel: 12 }), buildGeneral(2, { officerLevel: 5 }), target, member],
+            nationMeta: { gennum: 4 },
+        });
+        fixture.world.createTroop({ id: 3, nationId: 1, name: '추방대' });
+
+        await expect(fixture.handler.handle({ type: 'kick', generalId: 2, destGeneralId: 3 })).resolves.toMatchObject({
+            ok: true,
+        });
+        expect(fixture.world.getGeneralById(3)).toMatchObject({
+            nationId: 0,
+            officerLevel: 0,
+            troopId: 0,
+            gold: 1_000,
+            rice: 1_000,
+            experience: 850,
+            dedication: 1_700,
+            meta: expect.objectContaining({ belong: 0, permission: 'normal', betray: 2 }),
+        });
+        expect(fixture.world.getGeneralById(4)?.troopId).toBe(0);
+        expect(fixture.world.getTroopById(3)).toBeNull();
+        expect(fixture.world.getNationById(1)).toMatchObject({
+            gold: 11_500,
+            rice: 22_000,
+            meta: expect.objectContaining({ gennum: 3 }),
+        });
+        expect(fixture.world.peekDirtyState().logs).toHaveLength(2);
+    });
+
+    it('preserves the legacy kick year boundaries and deterministic NPC public message', async () => {
+        const early = buildWorld({
+            currentYear: 181,
+            generals: [
+                buildGeneral(1, { officerLevel: 12 }),
+                buildGeneral(2, { officerLevel: 5 }),
+                buildGeneral(3, { meta: { killturn: 12, belong: 8, permission: 'normal', betray: 1 } }),
+            ],
+        });
+        await early.handler.handle({ type: 'kick', generalId: 2, destGeneralId: 3 });
+        expect(early.world.getGeneralById(3)).toMatchObject({
+            experience: 850,
+            dedication: 1_700,
+            meta: expect.objectContaining({ betray: 2 }),
+        });
+        expect(early.world.getGeneralById(1)?.injury).toBe(1);
+        expect(Number(early.world.getNationById(1)?.meta.chief_set ?? 0)).toBe(0);
+
+        const npc = buildWorld({
+            currentYear: 185,
+            scenarioConst: { npcBanMessageProb: 1 },
+            generals: [
+                buildGeneral(1, { officerLevel: 12 }),
+                buildGeneral(2, { officerLevel: 5 }),
+                buildGeneral(3, { npcState: 2 }),
+            ],
+        });
+        await npc.handler.handle({ type: 'kick', generalId: 2, destGeneralId: 3 });
+        expect(npc.world.peekDirtyState().messages).toHaveLength(1);
+        expect(npc.world.peekDirtyState().messages[0]).toMatchObject({
+            msgType: 'public',
+            src: { generalId: 3, nationId: 1 },
+            dest: { generalId: 3, nationId: 1 },
+        });
+    });
+});