몬스터를 만드는 도구부터,
파괴되는 전장의 규칙까지.

        public static MonsterMakerWriteResult BuildAndRegister(
            MonsterMakerDraft draft,
            MonsterCatalog catalog = null,
            MonsterRarityCatalog rarityCatalog = null)
        {
            draft?.EditorSyncActiveAttackAuthoring();
            var preflight = MonsterMakerValidator.Validate(draft);
            if (preflight.HasErrors)
            {
                throw new InvalidOperationException(BuildIssueText(preflight.Issues));
            }

            catalog ??= AssetDatabase.LoadAssetAtPath<MonsterCatalog>(MonsterCatalogPath);
            rarityCatalog ??= AssetDatabase.LoadAssetAtPath<MonsterRarityCatalog>(MonsterRarityCatalogPath);
            if (catalog == null || rarityCatalog == null)
            {
                throw new InvalidOperationException("MonsterCatalog 또는 MonsterRarityCatalog을 찾을 수 없습니다.");
            }

            var paths = BuildPaths(draft.MonsterId);
            var generatesUniquePassive = draft.UsePassiveSkill &&
                                         draft.RarityPassiveSkill is GenericMonsterPassiveSkill;
            var generatesAttackActive = draft.UseActiveSkill &&
                                        draft.Rarity >= MonsterRarity.Legendary &&
                                        draft.HasActiveProfile;
            var passivePath = BuildPassivePath(draft.MonsterId);
            var extraPaths = new List<string>();
            if (generatesUniquePassive) extraPaths.Add(passivePath);
            if (generatesAttackActive) extraPaths.Add(BuildActivePath(draft.MonsterId));
            var outputPaths = paths.Concat(extraPaths).ToArray();
            var dataFolder = DataRoot + "/" + draft.MonsterId;
            var artFolder = ArtRoot + "/" + draft.MonsterId;
            var catalogPath = RequirePersistentAssetPath(catalog, "MonsterCatalog");
            var rarityCatalogPath = RequirePersistentAssetPath(rarityCatalog, "MonsterRarityCatalog");
            ValidateProductionDraftOwnership(draft, catalogPath, rarityCatalogPath);
            var writesProductionAiCatalog =
                string.Equals(catalogPath, MonsterCatalogPath, StringComparison.OrdinalIgnoreCase) &&
                string.Equals(rarityCatalogPath, MonsterRarityCatalogPath, StringComparison.OrdinalIgnoreCase);
            var transactionPaths = outputPaths.Concat(new[] { catalogPath, rarityCatalogPath });
            if (writesProductionAiCatalog)
            {
                transactionPaths = transactionPaths.Concat(new[]
                {
                    CastleRaidAIProfileCatalogPath,
                    MainBattleAIProfileCatalogPath
                });
            }
            var transaction = MonsterMakerWriteTransaction.Capture(
                transactionPaths,
                new[] { dataFolder, artFolder });

            try
            {
                EnsureFolder("Assets/ProjectMT/02_Shared/Unit/Data", "Monsters");
                EnsureFolder(DataRoot, draft.MonsterId);
                EnsureFolder("Assets/ProjectMT/05_Art", "Monsters");

            definition = AssetDatabase.LoadAssetAtPath<MonsterDefinition>(paths[0]);
            var outputValidation = MonsterDefinitionValidator.Validate(definition, true);
            if (outputValidation.HasErrors)
            {
                throw new InvalidOperationException(BuildRuntimeIssueText(outputValidation.Issues));
            }

            RegisterLast(catalog, rarityCatalog, definition, draft, uniquePassive, attackActive);
            SaveAssetsIfDirty(catalog, rarityCatalog, castleRaidAiCatalog, mainBattleAiCatalog);
            AssetDatabase.Refresh();

            if (!catalog.TryGet(draft.MonsterId, out var registered) || registered != definition)
            {
                throw new InvalidOperationException("생성물 검증 뒤 MonsterCatalog 등록을 확인하지 못했습니다.");
            }

            if (!rarityCatalog.TryGetRarity(draft.MonsterId, out var rarity) || rarity != draft.Rarity)
            {
                throw new InvalidOperationException("생성물 검증 뒤 MonsterRarityCatalog 등록을 확인하지 못했습니다.");
            }

            var assignedAiProfile = castleRaidAiCatalog?.Resolve(draft.MonsterId);
            if (castleRaidAiCatalog != null && (assignedAiProfile == null ||
                assignedAiProfile.Pattern != draft.CastleRaidAiPattern))
            {
                throw new InvalidOperationException("생성물 검증 뒤 Hex Castle Raid AI Profile 등록을 확인하지 못했습니다.");
            }

            if (mainBattleAiCatalog != null &&
                (!mainBattleAiCatalog.TryResolve(draft.MonsterId, out var mainBattleProfile) ||
                 mainBattleProfile.Role != draft.MainBattleRole ||
                 mainBattleProfile.TargetPriority != draft.MainBattleTargetPriority))
            {
                throw new InvalidOperationException("생성물 검증 뒤 MainBattle AI Profile 등록을 확인하지 못했습니다.");
            }

            var guidAfter = outputPaths.ToDictionary(path => path, AssetDatabase.AssetPathToGUID);
            for (var index = 0; index < outputPaths.Length; index++)
            {
                var before = guidBefore[outputPaths[index]];
                if (!string.IsNullOrEmpty(before) && !string.Equals(before, guidAfter[outputPaths[index]], StringComparison.Ordinal))
                {
                    throw new InvalidOperationException("기존 Asset GUID가 변경되었습니다: " + outputPaths[index]);
                }
            }

                var result = new MonsterMakerWriteResult(
                    definition,
                    updatedExisting,
                    outputPaths,
                    guidBefore,
                    guidAfter,
                    outputValidation);
                transaction.Commit();
                return result;
            }
            catch (Exception buildException)
            {
                try
                {
                    transaction.Rollback();
                }
                catch (Exception rollbackException)
                {
                    throw new AggregateException(
                        "Monster Maker 생성과 원상복구가 모두 실패했습니다.",
                        buildException,
                        rollbackException);
                }

                throw;

        public static IReadOnlyList<string> BuildPaths(string monsterId)
        {
            var data = DataRoot + "/" + monsterId;
            var art = ArtRoot + "/" + monsterId;
            return new[]
            {
                data + "/MD_" + monsterId + ".asset",
                data + "/MB_" + monsterId + ".asset",
                data + "/MM_" + monsterId + ".asset",
                data + "/MC_" + monsterId + ".asset",
                data + "/MA_" + monsterId + ".asset",
                data + "/MF_" + monsterId + ".asset",
                data + "/MR_" + monsterId + ".asset",
                art + "/AC_" + monsterId + ".controller",
                art + "/PF_" + monsterId + "_VisualAdapter.prefab"
            };

        private void SaveCurrentAsNew()
        {
            if (mode == WorkshopMode.Basic) basicSession.SaveAsNew(out _);
            else if (mode == WorkshopMode.Attack)
            {
                attackSerialized.ApplyModifiedProperties();
                if (MonsterActiveAttackAuthoringService.TryCreate(attackWorking, out var created, out _, out var error))
                { LoadAttack(created); attackMessage = "새 공격 액티브 프리셋을 저장했습니다."; }
                else attackMessage = "오류: " + error;
            }
            else
            {
                effectSerialized.ApplyModifiedProperties();
                if (MonsterEffectActiveAuthoringService.TryCreate(effectWorking, out var created, out _, out var error))
                { LoadEffect(created); effectMessage = "새 효과형 액티브 프리셋을 저장했습니다."; }
                else effectMessage = "오류: " + error;
            }
            libraryDirty = true;
            RebuildCurrent();
        }

        private void UpdateCurrent()
        {
            if (mode == WorkshopMode.Basic) basicSession.UpdateLoaded();
            else if (mode == WorkshopMode.Attack)
            {
                attackSerialized.ApplyModifiedProperties();
                if (MonsterActiveAttackAuthoringService.TryUpdate(attackWorking, attackLoaded, out var error))
                {
                    var loaded = attackLoaded;
                    LoadAttack(loaded);
                    NotifyActiveProfileUpdated();
                    attackMessage = "현재 공격 액티브 프리셋을 저장했습니다.";
                }
                else attackMessage = "오류: " + error;
            }

        public static string ValidateProfileJson(string json)
        {
            if (!TryBuildProfile(json, out var profile, out var error))
            {
                return BuildResult(false, "validate", string.Empty, string.Empty, error);
            }
            try
            {
                var success = MonsterActiveAttackAuthoringService.TryValidate(profile, null, out error);
                return BuildResult(success, "validate", profile.ProfileId, string.Empty, error);
            }
            finally
            {
                UnityEngine.Object.DestroyImmediate(profile);
            }
        }

        public static string CreateProfileFromJson(string json)
        {
            if (!TryBuildProfile(json, out var profile, out var error))
            {
                return BuildResult(false, "create", string.Empty, string.Empty, error);
            }
            try
            {
                var success = MonsterActiveAttackAuthoringService.TryCreate(
                    profile,
                    out var createdAsset,
                    out var assetPath,
                    out error);
                return BuildResult(success, "create", createdAsset != null ? createdAsset.ProfileId : profile.ProfileId,
                    assetPath, error);
            }
            finally
            {
                UnityEngine.Object.DestroyImmediate(profile);
            }
        }

        public static string UpdateProfileFromJson(string assetPath, string json)
        {
            var target = string.IsNullOrWhiteSpace(assetPath)
                ? null
                : AssetDatabase.LoadAssetAtPath<MonsterActiveAttackProfile>(assetPath);
            if (target == null)
            {
                return BuildResult(false, "update", string.Empty, assetPath,
                    $"업데이트할 공격 액티브 프로필을 찾지 못했습니다: {assetPath}");
            }
            if (!TryBuildProfile(json, out var profile, out var error))
            {
                return BuildResult(false, "update", target.ProfileId, assetPath, error);
            }
            try
            {
                var success = MonsterActiveAttackAuthoringService.TryUpdate(profile, target, out error);
                return BuildResult(success, "update", target.ProfileId, assetPath, error);
            }
            finally
            {
                UnityEngine.Object.DestroyImmediate(profile);
            }
        }

    public static class MonsterActiveAttackAuthoringService // GUI와 선택형 API가 공유하는 단일 프로필 저장 경계
    {
        public const string ProfileRoot = "Assets/ProjectMT/02_Shared/Unit/Data/ActiveAttackProfiles";
        public const string CustomProfileRoot = ProfileRoot + "/Custom";

        public static bool TryValidate(
            MonsterActiveAttackProfile source,
            MonsterActiveAttackProfile excludedProfile,
            out string error)
        {
            if (source == null)
            {
                error = "공격 액티브 작업 사본이 없습니다.";
                return false;
            }
            if (!source.TryValidate(out error)) return false;
            for (var stepIndex = 0; stepIndex < source.Steps.Count; stepIndex++)
            {
                var step = source.Steps[stepIndex];
                if (MonsterActiveAttackBlockContractTemplates.TryValidateCurrent(step, out error)) continue;
                error = $"Step {stepIndex + 1:00}의 VFX/SFX 계약이 유효하지 않습니다. {error}";
                return false;
            }
            if (excludedProfile != null && !string.Equals(
                    source.ProfileId,
                    excludedProfile.ProfileId,
                    StringComparison.OrdinalIgnoreCase))
            {
                error = $"저장된 프리셋의 ID는 바꿀 수 없습니다. 새 ID가 필요하면 새 프리셋으로 분기하세요: {excludedProfile.ProfileId}";
                return false;
            }

            var guids = AssetDatabase.IsValidFolder(ProfileRoot)
                ? AssetDatabase.FindAssets("t:MonsterActiveAttackProfile", new[] { ProfileRoot })
                : Array.Empty<string>();
            for (var index = 0; index < guids.Length; index++)
            {
                var candidate = AssetDatabase.LoadAssetAtPath<MonsterActiveAttackProfile>(
                    AssetDatabase.GUIDToAssetPath(guids[index]));
                if (candidate == null || candidate == excludedProfile) continue;
                if (!string.Equals(candidate.ProfileId, source.ProfileId, StringComparison.OrdinalIgnoreCase)) continue;
                error = $"같은 프리셋 ID가 이미 있습니다: [{candidate.ProfileId}] {candidate.DisplayName}";
                return false;
            }

            error = string.Empty;
            return true;
        }

    internal sealed class MonsterActiveAttackAuthoringContract
    {
        public int schemaVersion = 2;
        public string scope = "한 번 호출할 때 공격 액티브 프로필 하나만 작성합니다.";
        public string stepIdentity = "Step ID는 step_01부터 순서대로, 표시 이름은 공격 형태에서 자동 생성합니다.";
        public string vfxSfxContract = "각 Step의 VFX/SFX 공간은 기본공격 공용 계약에서 자동 생성합니다.";
        public string dataOwnership = "기본공격 프리셋을 가져와도 독립 복사하며 기본공격 자산을 참조 연결하지 않습니다.";
        public string multiHit = "hitCount 0은 공격 형태 기본값, 직접 공격은 1~3타, 왕복 투사체는 2타 고정입니다.";
        public string damageRange = "useDamageRange를 켜면 각 Step 실행 때 damageMultiplier~maximumDamageMultiplier를 한 번 독립 추첨합니다.";
        public string[] operations;
        public string[] patterns;
        public string[] progressions;
        public string[] targetPolicies;
        public string[] projectileFormations;
        public string[] instantMagicTargets;
        public string[] magicDirections;
        public string[] hitEffectTypes;
        public MonsterActiveAttackAuthoringRequest example;
    }

    public static class MonsterActiveAttackAuthoringApi // 폴더째 제거 가능한 AI용 단일 프리셋 어댑터
    {
        public static string GetContractJson()
        {
            var contract = new MonsterActiveAttackAuthoringContract
            {
                operations = new[] { "ValidateProfileJson", "CreateProfileFromJson", "UpdateProfileFromJson" },
                patterns = Enum.GetNames(typeof(MonsterActiveAttackPattern)),
                progressions = Enum.GetNames(typeof(MonsterActiveAttackProgression)),
                targetPolicies = Enum.GetNames(typeof(MonsterActiveTargetPolicy)),
                projectileFormations = Enum.GetNames(typeof(MonsterActiveProjectileFormation)),
                instantMagicTargets = Enum.GetNames(typeof(MonsterActiveInstantMagicTarget)),
                magicDirections = Enum.GetNames(typeof(MonsterActiveMagicDirection)),
                hitEffectTypes = Enum.GetNames(typeof(MonsterActiveHitEffectType)),
                example = CreateExampleRequest()
            };
            return JsonUtility.ToJson(contract, true);
        }

        public bool TryResolveFrontRoute(HexCoordinates start, float damagePerSecond, float moveSpeed,
            int topologyVersion, out HexCastleAssaultRoutePlan plan)
        {
            plan = null;
            if (!cells.ContainsKey(start) || palaceFootprint.Contains(start) ||
                !HexAttackSlotAllocator.Finite(damagePerSecond) || !HexAttackSlotAllocator.Finite(moveSpeed)) return false;
            FrontRouteBuildCount++;
            var path = new List<HexCoordinates> { start };
            var current = start;
            var axis = start.ToWorld(1f);
            var hasObstacle = false;
            var obstacle = default(HexCoordinates);
            var approach = start;
            var cost = 0f;
            while (!palaceApproaches.Contains(current))
            {
                var found = false;
                var next = default(HexCoordinates);
                var bestDeviation = float.PositiveInfinity;
                for (var direction = 0; direction < 6; direction++)
                {
                    var candidate = current.Neighbor(direction);
                    if (candidate.DistanceFromOrigin >= current.DistanceFromOrigin ||
                        !cells.TryGetValue(candidate, out var cell) || cell == null || palaceFootprint.Contains(candidate)) continue;
                    var point = candidate.ToWorld(1f);
                    var deviation = Mathf.Abs(axis.x * point.z - axis.z * point.x);
                    if (found && (deviation > bestDeviation + .0001f ||
                        Mathf.Abs(deviation - bestDeviation) <= .0001f && candidate.CompareTo(next) >= 0)) continue;
                    next = candidate; bestDeviation = deviation; found = true;
                }
                if (!found) return false;
                var target = cells[next];
                if (!target.CanTraverse(HexCastleTraversalFaction.Assault) && !target.IsDamageable) return false;
                cost += Vector3.Distance(cells[current].transform.position, target.transform.position) / Mathf.Max(.1f, moveSpeed);
                if (target.IsBlocked)
                {
                    if (!hasObstacle) { obstacle = next; approach = current; hasObstacle = true; }
                    cost += target.CurrentHealth / Mathf.Max(.1f, damagePerSecond);
                }
                path.Add(next); current = next;
            }
            var sector = ResolveSector(start);
            var anchor = hasObstacle ? obstacle : current;
            plan = new HexCastleAssaultRoutePlan(path, cost, current, obstacle, approach, hasObstacle,
                ResolveRouteId(sector, anchor), sector, topologyVersion);
            return true; // 소환 전면에서 첫 돌파 대상 선택
        }

        public void BeginDecision(HexCastleAssaultUnit unit)
        {
            sharedSearch = null;
            actor = unit; distance.Clear(); previous.Clear(); queue.Clear(); order.Clear(); paths.Clear();
            if (unit == null || !Open(unit.CurrentCoordinates)) return;
            FullSearchCount++;
            SearchOpenCells(unit.CurrentCoordinates, int.MaxValue);
            FullVisitedCellCount += order.Count;
        }

        public void BeginDecision(HexCastleAssaultUnit unit, int cohortId, HexCastleAssaultUnit leader)
        {
            if (cohortId <= 0 || leader == null || !leader.IsAlive) { BeginDecision(unit); return; }
            if (!sharedSearches.TryGetValue(cohortId, out var search))
            {
                BeginDecision(leader);
                search = new SharedSearch { Root = leader.CurrentCoordinates, Order = order.ToArray(),
                    Previous = new Dictionary<HexCoordinates, HexCoordinates>(previous) };
                search.Dependencies.Add(search.Root);
                sharedSearches.Add(cohortId, search); SharedSearchBuildCount++;
            }
            actor = unit; activeLeader = leader; activeCohort = cohortId; sharedSearch = search; retriedSharedSearch = false;
            distance.Clear(); previous.Clear(); queue.Clear(); order.Clear(); paths.Clear();
            if (unit == null || !Open(unit.CurrentCoordinates)) return;
            LocalConnectionSearchCount++;
            SearchOpenCells(unit.CurrentCoordinates, 3);
            LocalVisitedCellCount += order.Count;
            foreach (var c in search.Order) if (!distance.ContainsKey(c)) order.Add(c);
        }

        public void ForgetCohort(int cohortId) => sharedSearches.Remove(cohortId);

        public void InvalidateSharedSearchesAt(HexCoordinates changed)
        {
            var affected = new List<int>();
            foreach (var pair in sharedSearches)
            {
                var touches = pair.Value.Dependencies.Contains(changed);
                for (var d = 0; d < 6 && !touches; d++) touches = pair.Value.Dependencies.Contains(changed.Neighbor(d));
                if (touches) affected.Add(pair.Key);
            }
            foreach (var id in affected) sharedSearches.Remove(id);
        }

        private void SearchOpenCells(HexCoordinates start, int maximumSteps)
        {
            distance.Add(start, 0); queue.Enqueue(start);
            while (queue.Count > 0)
            {
                var c = queue.Dequeue(); order.Add(c);
                if (distance[c] >= maximumSteps) continue;
                for (var d = 0; d < 6; d++)
                {
                    var next = c.Neighbor(d);
                    if (distance.ContainsKey(next) || !Open(next) ||
                        !HexRoutePlanner.CanTraverseStep(cells[c], cells[next], d, HexCastleTraversalFaction.Assault)) continue;
                    distance.Add(next, distance[c] + 1); previous.Add(next, c); queue.Enqueue(next);
                }
            }
        }
        public bool TryPlan(HexCastleAssaultUnit unit, HexCastleAssaultTarget target, int range,
            Func<HexAttackSlotKey, bool> attackPredicate, bool holding,
            out HexAssaultApproachPlan plan, out HexAssaultFailureReason failure,
            Action<HexAttackSlotKey, HexAssaultFailureReason> rejected = null)
        {
            plan = null; failure = HexAssaultFailureReason.NoReachableApproach;
            if (actor != unit) BeginDecision(unit);
            if (unit == null || (!holding && !target.IsValid)) { failure = HexAssaultFailureReason.TargetInvalid; return false; }
            var best = float.PositiveInfinity;
            var radius = unit.SlotBodyRadius;
            var revision = slots.Revision;
            var hasReachablePath = false;
            for (var oi = 0; oi < order.Count; oi++)
            {
                var c = order[oi];
                if (holding)
                {
                    if (!distance.TryGetValue(c, out var holdingDistance) || holdingDistance > 3 || !HoldingCell(c)) continue;
                }
                else if (c.DistanceTo(target.Coordinates) > Math.Max(1, range)) continue;
                var path = Reconstruct(c);
                if (path.Length == 0) continue;
                if (!holding && !StaysOnAdvanceFront(unit, target, range, path))
                { failure = HexAssaultFailureReason.SlotApproachBlocked; continue; }
                hasReachablePath = true;
                var lowerBound = Math.Max(0, path.Length - 3) * pitch / unit.EffectiveMoveSpeed;
                if (lowerBound > best + 0.0001f) continue;
                var entry = path.Length <= 2 ? unit.transform.position : Centre(path[path.Length - 2]);
                var prefixLength = 0f; var prefixPosition = unit.transform.position;
                for (var pi = 1; pi < path.Length - 1; pi++)
                {
                    var next = Centre(path[pi]); next.y = prefixPosition.y;
                    prefixLength += Vector3.Distance(prefixPosition, next); prefixPosition = next;
                }
                for (var si = 0; si < slots.CandidateCount(radius); si++)
                {
                    var key = slots.Candidate(c, radius, si);
                    if (!slots.CanReserve(unit, key, radius, out var reason))
                    { failure = reason; rejected?.Invoke(key, reason); continue; }
                    if (attackPredicate != null && !attackPredicate(key))
                    { failure = HexAssaultFailureReason.AttackLaneBlocked; rejected?.Invoke(key, failure); continue; }
                    var destination = slots.Position(key); destination.y = unit.GroundWorldY;
                    var flatEntry = entry; flatEntry.y = destination.y;
                    // 우회 거리는 직선거리 이상입니다.
                    // 동률은 기존 후보 순서를 따릅니다.
                    if ((prefixLength + Vector3.Distance(flatEntry, destination)) / unit.EffectiveMoveSpeed >= best - 0.0001f) continue;
                    if (!TryFinalPath(unit, entry, destination, c, out var local, out var localLength))
                    { failure = HexAssaultFailureReason.SlotApproachBlocked; rejected?.Invoke(key, failure); continue; }
                    var cost = (prefixLength + localLength) / unit.EffectiveMoveSpeed;
                    if (cost >= best - 0.0001f) continue;
                    best = cost;
                    plan = new HexAssaultApproachPlan(key, path, local, cost, revision, order.Count);
                }
            }
            if (plan == null)
            {
                if (!hasReachablePath && sharedSearch != null && !retriedSharedSearch && activeLeader != null &&
                    sharedSearch.Root != activeLeader.CurrentCoordinates)
                {
                    ForgetCohort(activeCohort);
                    BeginDecision(unit, activeCohort, activeLeader); retriedSharedSearch = true;
                    return TryPlan(unit, target, range, attackPredicate, holding, out plan, out failure, rejected);
                }
                return false;
            }
            failure = HexAssaultFailureReason.None;
            return true;
        }
        private static bool StaysOnAdvanceFront(HexCastleAssaultUnit unit, HexCastleAssaultTarget target,
            int range, HexCoordinates[] path)
        {
            if (target.Structure == null) return true; // 위협 대응과 아군 지원의 이동은 제한하지 않는다.
            var outerRing = Math.Max(unit.CurrentCoordinates.DistanceFromOrigin,
                target.Coordinates.DistanceFromOrigin + Math.Max(1, range));
            foreach (var cell in path)
                if (cell.DistanceFromOrigin > outerRing) return false; // 공격 자리 탐색을 현재 전면 안으로 제한
            return true;
        }
        private bool HoldingCell(HexCoordinates c)
        {
            if (!Open(c)) return false; // 파괴되어 열린 구조물 자리도 전진 후보에 포함한다.
            var open = 0;
            for (var d = 0; d < 6; d++) if (Open(c.Neighbor(d))) open++;
            return open >= 4; // 1칸 통로에서는 대기하지 않습니다.
        }

        private sealed class AdvanceEstimate
        {
            public HexCastleCellRuntime Target;
            public HexAssaultApproachPlan Approach;
            public int MoveMs, DestroyMs, ContinuationMs;
            public float SupportingDps;
            public int TotalMs => MoveMs + DestroyMs + ContinuationMs;
        }

        private bool TryEstimateAdvance(HexCastleAssaultUnit unit, HexCastleCellRuntime target, out AdvanceEstimate estimate)
        {
            estimate = null;
            if (target == null || !target.IsAlive) return false;
            var palace = target == palaceCore;
            var assaultTarget = new HexCastleAssaultTarget(target, palace);
            var range = palace ? HexCastleFoundationGenerator.PalaceFootprintRadius + 1 : unit.AttackRangeCells;
            if (!approachPlanner.TryPlan(unit, assaultTarget, range,
                    slot => !unit.ShouldAvoidSlot(slot) && CanAttackFromPosition(unit, assaultTarget, slot), false,
                    out var approach, out _)) return false; // 즉시 예약 불가 자리는 무한 대기로 취급
            var supportingDps = ActiveAttackDps(target, approach.Cost);
            estimate = new AdvanceEstimate { Target = target, Approach = approach, SupportingDps = supportingDps,
                MoveMs = Mathf.CeilToInt(approach.Cost * 1000f),
                DestroyMs = palace ? 0 : EstimateRemainingDestructionMilliseconds(target.CurrentHealth,
                    unit.EstimatedDamagePerSecond, supportingDps, approach.Cost),
                ContinuationMs = 0 }; // 현재 전면의 작업 비용만 비교한다.
            return true;
        }

        private bool TryResolveEfficientAdvance(HexCastleAssaultUnit unit, HexCastleAssaultRoutePlan route,
            out HexCastleAssaultDecision decision)
        {
            decision = default;
            var estimates = new List<AdvanceEstimate>();
            if (!route.HasFirstObstacle && TryEstimateAdvance(unit, palaceCore, out var palace)) estimates.Add(palace);
            foreach (var target in cells.Values.Where(value => value != null).OrderBy(value => value.Coordinates))
            {
                if (!IsOnAssaultFront(route, target) || !target.IsAlive || !target.IsBlocked || !target.IsDamageable || target == palaceCore ||
                    target.Kind == HexCastleCellKind.Palace ||
                    target.DefenseLayer > unit.ExpectedDefenseLayer && target.Coordinates.DistanceTo(unit.CurrentCoordinates) > LocalWorkRadiusCells) continue;
                if (target != unit.CommittedTarget.Structure && target.Coordinates != route.FirstObstacle &&
                    !(IsRingWall(target) && target.DefenseLayer == unit.ExpectedDefenseLayer) &&
                    target.Coordinates.DistanceTo(unit.CurrentCoordinates) > LocalWorkRadiusCells) continue;
                var routeId = ResolveDecisionRouteId(route.SectorId, target.Coordinates);
                if (IsOuterRingWall(target) && !CanReserveBreach(routeId, target)) continue;
                if (TryEstimateAdvance(unit, target, out var estimate)) estimates.Add(estimate);
            }
            if (estimates.Count == 0) return false;
            estimates.Sort((a, b) => a.TotalMs != b.TotalMs ? a.TotalMs.CompareTo(b.TotalMs) : a.Target.Coordinates.CompareTo(b.Target.Coordinates));
            var selected = estimates[0];
            var current = estimates.Find(value => value.Target == unit.CommittedTarget.Structure);
            var retainCurrent = current != null && current != selected && ShouldRetainCurrentAdvance(
                unit.RecoveryRequested, Time.time - unit.LastTargetSwitchTime, current.TotalMs, selected.TotalMs);
            if (retainCurrent && Time.time - unit.LastTargetSwitchTime < 1f)
                unit.DeferRouteCostReview(1f - (Time.time - unit.LastTargetSwitchTime));
            if (retainCurrent) selected = current;
            var intent = selected.Target == palaceCore ? HexCastleAssaultIntentKind.Palace :
                !unit.HasSelectedInitialWall && IsRingWall(selected.Target) && selected.Target.DefenseLayer == unit.ExpectedDefenseLayer
                    ? HexCastleAssaultIntentKind.InitialBreach : HexCastleAssaultIntentKind.Progress;
            var changed = unit.CommittedTarget.IsValid && selected.Target != unit.CommittedTarget.Structure;
            if (!TryCreateCellDecision(unit, selected.Target, selected.Target == palaceCore, route, intent,
                    out decision, null, changed, HexAssaultFailureReason.None)) return false;
            var alternative = estimates.FirstOrDefault(value => value != selected);
            unit.RecordAdvanceCost(selected.MoveMs, selected.DestroyMs, selected.ContinuationMs,
                alternative?.Target.Coordinates, alternative?.TotalMs ?? 0);
            if (selected.SupportingDps > 0 || alternative?.SupportingDps > 0) unit.DeferRouteCostReview(1f);
            if (selected.Target != palaceCore)
                unit.RecordBreachCostEvaluation(selected.Target.Coordinates, selected.MoveMs / 1000f, selected.DestroyMs / 1000f,
                    unit.EstimatedDamagePerSecond + selected.SupportingDps, alternative?.Target.Coordinates, (alternative?.MoveMs ?? 0) / 1000f,
                    (alternative?.DestroyMs ?? 0) / 1000f);
            return true;
        }

        private static bool ShouldRetainCurrentAdvance(bool recovering, float sinceSwitch, int currentMs, int bestMs) =>
            !recovering && (sinceSwitch < 1f || currentMs - bestMs < Math.Max(1000, Mathf.CeilToInt(currentMs * .1f)));

        private void RefreshActiveAttackDps(HexCastleAssaultUnit selectingUnit)
        {
            activeAttackDps.Clear(); // 판단 1회당 실제 정착·공격 중인 병력만 집계
            foreach (var attacker in units)
            {
                if (attacker == null || attacker == selectingUnit || !attacker.IsAlive ||
                    attacker.ExecutionState != HexAssaultExecutionState.Attacking ||
                    attacker.CurrentTarget.Structure == null ||
                    !CanAttackFromSlot(attacker, attacker.CurrentTarget, attacker.CurrentSlotLease)) continue;
                var key = attacker.CurrentTarget.Structure.GetInstanceID();
                activeAttackDps.TryGetValue(key, out var previous);
                activeAttackDps[key] = previous + attacker.EstimatedDamagePerSecond;
            }
        }

        private float ActiveAttackDps(HexCastleCellRuntime target, float approachSeconds) => approachSeconds <= 1f && target != null &&
            activeAttackDps.TryGetValue(target.GetInstanceID(), out var value) ? value : 0f;

        private static int EstimateRemainingDestructionMilliseconds(float hp, float ownDps, float activeDps, float approachSeconds)
        {
            var remaining = Mathf.Max(0f, hp - Mathf.Max(0f, activeDps) * Mathf.Max(0f, approachSeconds));
            return Mathf.CeilToInt(remaining / Mathf.Max(.1f, ownDps + Mathf.Max(0f, activeDps)) * 1000f);
        }

        private bool TryResolveLocalFallback(HexCastleAssaultUnit unit, out HexCastleAssaultDecision decision, int beforeTravelMs = int.MaxValue)
        {
            decision = default;
            var hasRoute = TryResolveCohortRoute(unit, out var route);
            if (!hasRoute) route = new HexCastleAssaultRoutePlan(new[] { unit.CurrentCoordinates }, 0f,
                unit.CurrentCoordinates, default, unit.CurrentCoordinates, false, unit.RouteId,
                unit.RouteSector, topologyVersion); // 지역 전투 문맥만 유지
            // 대기 중에도 가까운 전면을 공격합니다.
            // 전략 목표와 부대 소속은 유지합니다.
            var estimates = new List<BreachTimeEstimate>();
            foreach (var target in cells.Values.Where(c => IsEligibleLocalWorkTarget(unit, c, null, true) &&
                         IsInDeploymentFront(unit, c.Coordinates)))
            {
                if (TryEstimateBreachTime(unit, target, out var estimate)) estimates.Add(estimate);
            }
            var nearest = estimates.Count == 0 ? 0 : estimates.Min(value => value.MovementMilliseconds);
            foreach (var estimate in estimates.Where(value => value.MovementMilliseconds <= nearest + LocalWorkMovementBandMilliseconds)
                         .OrderBy(value => value.Target.CurrentHealth).ThenBy(value => value.TotalMilliseconds).ThenBy(value => value.Target.Coordinates))
            {
                if (beforeTravelMs != int.MaxValue && !ShouldCompleteLocalWorkBeforeTravel(beforeTravelMs, estimate.TotalMilliseconds)) continue;
                var routeId = ResolveDecisionRouteId(route.SectorId, estimate.Target.Coordinates);
                if (TryCreateCellDecision(unit, estimate.Target, false, route, HexCastleAssaultIntentKind.LocalFallback,
                        out decision, routeId))
                {
                    RecordBreachCostEvaluation(unit, estimate, estimates);
                    return true;
                }
            }
            return false;
        }

        private bool TryResolveRankedOverflowTarget(
            HexCastleAssaultUnit unit,
            HexCastleAssaultRoutePlan route,
            HexCastleCellRuntime saturatedTarget,
            HexAssaultFailureReason saturationReason,
            out HexCastleAssaultDecision decision)
        {
            decision = default;
            var estimates = new List<BreachTimeEstimate>();
            foreach (var target in cells.Values.Where(value =>
                         IsEligibleLocalWorkTarget(unit, value, saturatedTarget, true) && IsOnAssaultFront(route, value)))
            {
                if (TryEstimateBreachTime(unit, target, out var estimate))
                {
                    estimates.Add(estimate);
                }
            }

            // 가까운 작업의 완료 시간을 비교합니다.
            // 먼저 끝나면 기존 목표를 유지한 채 처리합니다.
            // 서로 다른 최종 목표는 직접 비교하지 않습니다.
            var minimumMovementMilliseconds = estimates.Count > 0
                ? estimates.Min(value => value.MovementMilliseconds) : int.MaxValue;
            var fourthPriority = estimates
                .Where(value => value.MovementMilliseconds <= minimumMovementMilliseconds + LocalWorkMovementBandMilliseconds)
                .OrderBy(value => value.Target.CurrentHealth)
                .ThenBy(value => value.TotalMilliseconds)
                .ThenBy(value => value.Target.Coordinates)
                .Take(1).ToArray();
            var ranked = estimates
                .Where(value => value.Target.DefenseLayer <= unit.ExpectedDefenseLayer && IsStrategicOverflowTarget(saturatedTarget, value.Target))
                .OrderBy(value => value.TotalMilliseconds)
                .ThenBy(value => value.Target.Coordinates)
                .Take(MaximumRankedOverflowTargets)
                .ToArray();
            for (var index = 0; index < ranked.Length; index++)
            {
                var estimate = ranked[index];
                if (fourthPriority.Length > 0 &&
                    ShouldCompleteLocalWorkBeforeTravel(estimate.MovementMilliseconds, fourthPriority[0].TotalMilliseconds)) continue;
                var routeId = ResolveDecisionRouteId(route.SectorId, estimate.Target.Coordinates);
                if (!TryCreateCellDecision(
                        unit,
                        estimate.Target,
                        false,
                        route,
                        HexCastleAssaultIntentKind.Progress,
                        out decision,
                        routeId,
                        true,
                        saturationReason))
                {
                    continue;
                }

                RecordBreachCostEvaluation(unit, estimate, estimates);
                return true;
            }

            // 네 번째 우선순위는 가까운 임시 공격입니다.
            // 최근접 작업과 250ms 이내 후보만 남깁니다.
            // 그중 남은 HP가 가장 낮은 대상을 고릅니다.
            if (fourthPriority.Length > 0)
            {
                var estimate = fourthPriority[0];
                var routeId = ResolveDecisionRouteId(route.SectorId, estimate.Target.Coordinates);
                if (TryCreateCellDecision(
                        unit,
                        estimate.Target,
                        false,
                        route,
                        HexCastleAssaultIntentKind.LocalFallback,
                        out decision,
                        routeId))
                {
                    RecordBreachCostEvaluation(unit, estimate, estimates);
                    return true;
                }
            }

            return false;
        }

        private static bool ShouldCompleteLocalWorkBeforeTravel(int travelMilliseconds, int localCompletionMilliseconds)
            => travelMilliseconds > (long)localCompletionMilliseconds + 1000L;

        private static bool IsStrategicOverflowTarget(
            HexCastleCellRuntime saturatedTarget,
            HexCastleCellRuntime candidate)
        {
            if (saturatedTarget == null || candidate == null)
            {
                return false;
            }

            if (IsRingWall(saturatedTarget))
            {
                return IsRingWall(candidate) &&
                       candidate.DefenseLayer == saturatedTarget.DefenseLayer;
            }

            if (saturatedTarget.BuildingRole != HexCastleBuildingRole.None)
            {
                return candidate.BuildingRole == saturatedTarget.BuildingRole;
            }

            return candidate.Kind == saturatedTarget.Kind;
        }

        private static bool IsEligibleLocalWorkTarget(
            HexCastleAssaultUnit unit,
            HexCastleCellRuntime target,
            HexCastleCellRuntime excluded, bool allowRecoveryLayer = false)
        {
            if (unit == null || target == null || target == excluded || !target.IsAlive ||
                !target.IsBlocked || !target.IsDamageable || target.Kind == HexCastleCellKind.Palace ||
                (!allowRecoveryLayer && target.DefenseLayer > unit.ExpectedDefenseLayer) ||
                target.Coordinates.DistanceTo(unit.CurrentCoordinates) > LocalWorkRadiusCells)
            {
                return false;
            }

            var targetPosition = target.Coordinates.ToWorld(1f);
            var unitPosition = unit.CurrentCoordinates.ToWorld(1f);
            return Vector3.Dot(targetPosition, unitPosition) >= 0f;
        }

        private bool TryEstimateBreachTime(
            HexCastleAssaultUnit unit,
            HexCastleCellRuntime target,
            out BreachTimeEstimate estimate)
        {
            estimate = default;
            if (unit == null || target == null || !target.IsAlive || !target.IsBlocked || !target.IsDamageable)
                return false;
            var assaultTarget = new HexCastleAssaultTarget(target, false);
            if (!approachPlanner.TryPlan(unit, assaultTarget, unit.AttackRangeCells,
                    slot => !unit.ShouldAvoidSlot(slot) && CanAttackFromPosition(unit, assaultTarget, slot), false,
                    out var approach, out _)) return false;
            // 이 유닛이 끝낼 수 있는 시간을 비교합니다.
            // 부대 선호는 제한 범위 안에서만 적용합니다.
            var ownDps = Mathf.Max(0.1f, unit.EstimatedDamagePerSecond);
            var supportingDps = ActiveAttackDps(target, approach.Cost);
            var expectedDps = ownDps + supportingDps;
            estimate = new BreachTimeEstimate(
                target,
                Mathf.CeilToInt(approach.Cost * 1000f),
                EstimateRemainingDestructionMilliseconds(target.CurrentHealth, ownDps, supportingDps, approach.Cost),
                expectedDps);
            return true;
        }

        private static void RecordBreachCostEvaluation(
            HexCastleAssaultUnit unit,
            BreachTimeEstimate selected,
            IEnumerable<BreachTimeEstimate> candidates)
        {
            var alternatives = candidates
                .Where(value => value.Target != selected.Target)
                .OrderBy(value => value.TotalMilliseconds)
                .ThenBy(value => value.Target.Coordinates)
                .Take(1)
                .ToArray();
            var hasAlternative = alternatives.Length > 0;
            var alternative = hasAlternative ? alternatives[0] : default;
            unit.RecordBreachCostEvaluation(
                selected.Target.Coordinates,
                selected.MovementMilliseconds / 1000f,
                selected.DestructionMilliseconds / 1000f,
                selected.ExpectedDamagePerSecond,
                hasAlternative ? alternative.Target.Coordinates : (HexCoordinates?)null,
                hasAlternative ? alternative.MovementMilliseconds / 1000f : 0f,
                hasAlternative ? alternative.DestructionMilliseconds / 1000f : 0f);
        }

        private bool TryCreateHoldPlan(HexCastleAssaultUnit unit, out HexCastleAssaultDecision decision)
        {
            decision = default;
            if (unit.IsInSafeMotion || unit.CurrentTarget.IsValid) return false;
            HexAssaultApproachPlan candidate = null;
            if (TryResolveCohortRoute(unit, out var route))
            {
                var front = route.HasFirstObstacle ? route.FirstObstacleApproach : route.DestinationApproach;
                var distance = unit.CurrentCoordinates.DistanceTo(front);
                for (var progress = Math.Min(3, distance); progress > 0 && candidate == null; progress--)
                {
                    var remaining = distance - progress;
                    approachPlanner.TryPlan(unit, default, 3, slot =>
                        slot.Cell.DistanceTo(front) <= remaining &&
                        slot.Cell.DistanceFromOrigin <= unit.CurrentCoordinates.DistanceFromOrigin &&
                        IsInDeploymentFront(unit, slot.Cell), true, out candidate, out _);
                }
            }
            if (candidate == null && unit.TryRetainHold(topologyVersion, out decision)) return true;
            if (candidate == null && !approachPlanner.TryPlan(unit, default, 3, null, true, out candidate, out _)) return false;
            if (!slotAllocator.TryCommit(unit, default, candidate.Slot, unit.SlotBodyRadius, candidate.Cost,
                    candidate.OccupancyRevision, true, out var lease, out _)) return false;
            ReleaseBreachReservation(unit);
            decision = new HexCastleAssaultDecision(default, candidate.Cells, candidate.Slot.Cell, unit.RouteId,
                unit.RouteSector, topologyVersion, HexCastleAssaultIntentKind.HoldPosition,
                slotLease: lease, finalApproach: candidate.FinalPath, planKind: HexAssaultPlanKind.Hold);
            Record(HexAssaultTraceKind.SlotReserved, unit, 0, lease, HexAssaultFailureReason.WaitingForOpening);
            return true;
        }

        [Test]
        public void RuntimeAssembly_DoesNotReferenceSquareCastleRaidAssembly()
        {
            var references = typeof(HexCoordinates).Assembly.GetReferencedAssemblies()
                .Select(reference => reference.Name)
                .ToArray();

            Assert.That(references, Does.Not.Contain("ProjectMT.Contents.CastleRaid"));
        }

        [Test]
        public void RuntimeAssembly_DoesNotReferenceNavigationAssemblies()
        {
            var references = typeof(HexCoordinates).Assembly.GetReferencedAssemblies()
                .Select(reference => reference.Name)
                .ToArray();

            Assert.That(references, Does.Not.Contain("Unity.AI.Navigation"));
            Assert.That(references, Does.Not.Contain("UnityEngine.AIModule"));
        }

        private HexCastleAssaultCohortAssignment ResolveCohort(
            HexCastleAssaultUnit unit,
            HexCastleAssaultRoutePlan route,
            int? routeIdOverride)
        {
            var unitId = unit.GetInstanceID();
            MaintainCohort(unit);
            if (unitCohorts.TryGetValue(unitId, out var existing))
            {
                return existing;
            }

            CohortRecord selected = null;
            for (var index = 0; index < cohorts.Count; index++)
            {
                var cohort = cohorts[index];
                RefreshCohortLeader(cohort);
                if (cohort.MemberCount >= MaximumCohortSize || !CanJoinCohort(unit, cohort, CohortJoinDistanceCells))
                {
                    continue;
                }

                selected = cohort;
                break;
            }

            if (selected == null)
            {
                if (route == null) navigation.TryResolveFrontRoute(unit.CurrentCoordinates,
                    unit.EstimatedDamagePerSecond, unit.EffectiveMoveSpeed, topologyVersion, out route);
                selected = new CohortRecord
                {
                    CohortId = nextCohortId++,
                    RouteId = routeIdOverride ?? route?.RouteId ?? unit.RouteId,
                    SectorId = route?.SectorId ?? unit.RouteSector,
                    SharedRoute = route
                };
                cohorts.Add(selected);
            }

            selected.Members.Add(unit);
            RefreshCohortLeader(selected);
            var assignment = new HexCastleAssaultCohortAssignment(
                selected.CohortId,
                selected.RouteId,
                selected.SectorId);
            unitCohorts[unitId] = assignment;
            return assignment;
        }

        private bool TryResolveCohortRoute(HexCastleAssaultUnit unit, out HexCastleAssaultRoutePlan route)
        {
            var assignment = ResolveCohort(unit, null, null);
            var cohort = cohorts.First(value => value.CohortId == assignment.CohortId);
            var leader = cohort.Leader;
            route = cohort.SharedRoute;
            if (route != null && route.HasFirstObstacle &&
                (!cells.TryGetValue(route.FirstObstacle, out var obstacle) || obstacle == null ||
                 obstacle.CanTraverse(HexCastleTraversalFaction.Assault) ||
                 leader.CurrentCoordinates.DistanceFromOrigin < route.FirstObstacle.DistanceFromOrigin)) route = null;
            if (route != null) { SharedFrontRouteReuseCount++; return true; }
            if (leader == null || !navigation.TryResolveFrontRoute(leader.CurrentCoordinates,
                    leader.EstimatedDamagePerSecond, leader.EffectiveMoveSpeed, topologyVersion, out route)) return false;
            cohort.SharedRoute = route; cohort.RouteVersion++;
            return true;
        }

        public HexCastleAssaultUnit GetCohortLeader(HexCastleAssaultUnit unit)
        {
            if (unit == null || !unitCohorts.TryGetValue(unit.GetInstanceID(), out var assignment)) return null;
            var cohort = cohorts.FirstOrDefault(value => value.CohortId == assignment.CohortId);
            if (cohort == null) return null;
            RefreshCohortLeader(cohort);
            return cohort.Leader;
        }

        private void RefreshCohortLeader(CohortRecord cohort)
        {
            cohort.Members.RemoveAll(member => member == null || !member.IsAlive);
            HexCastleAssaultUnit leader = null;
            foreach (var member in cohort.Members)
                if (leader == null || member.CurrentCoordinates.DistanceFromOrigin < leader.CurrentCoordinates.DistanceFromOrigin ||
                    member.CurrentCoordinates.DistanceFromOrigin == leader.CurrentCoordinates.DistanceFromOrigin &&
                    ResolveSpawnOrder(member) < ResolveSpawnOrder(leader)) leader = member;
            cohort.Leader = leader; // 팀장 승계 후 경로·자리·목표 유지
        }

        private bool CanJoinCohort(HexCastleAssaultUnit unit, CohortRecord cohort, int steps)
        {
            var leader = cohort.Leader;
            if (leader == null || !unit.IsAlive) return false;
            if (leader == unit) return true;
            var from = deploymentFronts.TryGetValue(unit.GetInstanceID(), out var a) ? a : unit.CurrentCoordinates;
            var to = deploymentFronts.TryGetValue(leader.GetInstanceID(), out var b) ? b : leader.CurrentCoordinates;
            if (Vector3.Dot(from.ToWorld(1f).normalized, to.ToWorld(1f).normalized) < .5f) return false;
            return HasShortCohortConnection(unit.CurrentCoordinates, leader.CurrentCoordinates, steps);
        }

        private bool IsInDeploymentFront(HexCastleAssaultUnit unit, HexCoordinates target)
        {
            var start = deploymentFronts.TryGetValue(unit.GetInstanceID(), out var deployed) ? deployed : unit.CurrentCoordinates;
            return Vector3.Dot(start.ToWorld(1f).normalized, target.ToWorld(1f).normalized) >= .5f;
        }

        private bool HasShortCohortConnection(HexCoordinates start, HexCoordinates goal, int steps)
        {
            if (start.DistanceTo(goal) > steps || !cells.TryGetValue(start, out var first) ||
                first == null || !first.CanTraverse(HexCastleTraversalFaction.Assault)) return false;
            if (start == goal) return true;
            cohortJoinDistances.Clear(); cohortJoinQueue.Clear();
            cohortJoinDistances.Add(start, 0); cohortJoinQueue.Enqueue(start);
            while (cohortJoinQueue.Count > 0)
            {
                var at = cohortJoinQueue.Dequeue();
                if (cohortJoinDistances[at] >= steps) continue;
                for (var d = 0; d < 6; d++)
                {
                    var next = at.Neighbor(d);
                    if (cohortJoinDistances.ContainsKey(next) || !cells.TryGetValue(next, out var cell) ||
                        cell == null || !HexRoutePlanner.CanTraverseStep(cells[at], cell, d, HexCastleTraversalFaction.Assault)) continue;
                    if (next == goal) return true;
                    cohortJoinDistances.Add(next, cohortJoinDistances[at] + 1); cohortJoinQueue.Enqueue(next);
                }
            }
            return false;
        }

        private void MaintainCohort(HexCastleAssaultUnit unit)
        {
            if (unit == null || !unitCohorts.TryGetValue(unit.GetInstanceID(), out var assignment)) return;
            var current = cohorts.FirstOrDefault(value => value.CohortId == assignment.CohortId);
            if (current == null) { unitCohorts.Remove(unit.GetInstanceID()); return; }
            RefreshCohortLeader(current);
            if (!unit.IsAlive || !CanJoinCohort(unit, current, CohortJoinDistanceCells + 1))
            {
                ReleaseCohort(unit);
                if (unit.IsAlive) unit.RequestStrategicDecision(true);
                return;
            }
            foreach (var candidate in cohorts)
            {
                RefreshCohortLeader(candidate);
                if (candidate.CohortId >= current.CohortId || candidate.MemberCount + current.MemberCount > MaximumCohortSize ||
                    !CanJoinCohort(unit, candidate, CohortJoinDistanceCells)) continue;
                var canMerge = true;
                foreach (var member in current.Members)
                    if (!CanJoinCohort(member, candidate, CohortJoinDistanceCells)) { canMerge = false; break; }
                if (!canMerge) continue;
                foreach (var member in current.Members)
                {
                    candidate.Members.Add(member);
                    unitCohorts[member.GetInstanceID()] = new HexCastleAssaultCohortAssignment(candidate.CohortId, candidate.RouteId, candidate.SectorId);
                    Record(HexAssaultTraceKind.CohortReassigned, member);
                }
                current.Members.Clear(); approachPlanner?.ForgetCohort(current.CohortId); cohorts.Remove(current);
                RefreshCohortLeader(candidate);
                return; // 더 이른 부대로만 합쳐 왕복 재가입을 막는다.
            }
        }

    public enum HexAssaultExecutionState { Inactive, AwaitInitialPlan, Traversing, Aligning, Attacking, Holding, Recovering }

        private void TickDynamicRuntime(float deltaTime)
        {
            if (attackActionRunning)
            {
                ExecutionState = HexAssaultExecutionState.Attacking;
                TickAttackAction(deltaTime); return;
            }
            if (motionActive)
            {
                if (trapMovementLockRemaining > 0f) { animationDriver?.PlayIdle(); return; }
                if (!CanDynamicStep(motionFrom, motionTo))
                {
                    motionActive = false;
                    MarkNoProgress(HexAssaultFailureReason.NoReachableApproach);
                    return;
                }
                if (motionFinal && !assaultWorld.ApproachPlanner.SegmentClear(this, transform.position, motionEnd))
                {
                    motionActive = false;
                    if (TryRefreshFinalApproach()) { BeginFinalApproach(deltaTime); return; }
                    MarkNoProgress(HexAssaultFailureReason.SlotApproachBlocked);
                    return;
                }
                AdvanceMotion(deltaTime); return;
            }
            if (movementPath != null && pathIndex < movementPath.Count - 1)
            {
                if (trapMovementLockRemaining > 0f) { animationDriver?.PlayIdle(); return; }
                var next = movementPath[pathIndex + 1];
                if (!CanDynamicStep(CurrentCoordinates, next))
                { MarkNoProgress(HexAssaultFailureReason.NoReachableApproach); return; }
                if (!finishSafeSegmentOnly && activePlan.FinalApproach != null && activePlan.FinalApproach.Count > 0 && pathIndex == movementPath.Count - 2)
                { BeginFinalApproach(deltaTime); return; }
                BeginMotion(next, ResolvePosition(next), false);
                AdvanceMotion(deltaTime); return;
            }
            if (activePlan.SlotLease.IsValid && finalApproachIndex < activePlan.FinalApproach.Count)
            {
                if (trapMovementLockRemaining > 0f) { animationDriver?.PlayIdle(); return; }
                BeginFinalApproach(deltaTime); return;
            }
            if (activePlan.PlanKind == HexAssaultPlanKind.Hold)
            {
                ExecutionState = HexAssaultExecutionState.Holding;
                strategicDecisionRequested = true; // 재판단 시점은 대기 시간이 결정한다.
                CheckNoProgress(); animationDriver?.PlayIdle(); return;
            }
            if (!currentTarget.IsValid)
            {
                ExecutionState = HexAssaultExecutionState.Holding;
                strategicDecisionRequested = true;
                CheckNoProgress(); animationDriver?.PlayIdle(); return;
            }
            if (currentTarget.Kind == HexCastleAssaultTargetKind.Ally)
            { TickSupportTarget(); return; }
            if (!CanAttackTarget(currentTarget))
            {
                strategicDecisionRequested = true;
                CheckNoProgress(); animationDriver?.PlayIdle(); return;
            }
            ExecutionState = HexAssaultExecutionState.Attacking;
            animationDriver?.PlayIdle();
            FaceTowards(ResolveTargetPosition(currentTarget), deltaTime);
            if (Time.time >= nextAttackTime) StartDynamicAttack(currentTarget);
        }

        public HexCastleLayout Generate(
            int seed,
            int defenseLayerCount,
            HexCastleTheme theme = HexCastleTheme.CentralCompartment,
            HexCastleThemeOneTuning tuning = null)
        {
            return GenerateInternal(seed, defenseLayerCount, theme, tuning, null);
        }

        public HexCastleLayout GenerateForDifficulty(
            int seed,
            int difficultyLevel,
            HexCastleTheme theme = HexCastleTheme.CentralCompartment,
            HexCastleThemeOneTuning tuning = null)
        {
            var profile = HexCastleDifficultyProfile.Resolve(difficultyLevel, seed);
            return GenerateInternal(seed, profile.DefenseLayerCount, theme, tuning, profile);
        }

        private static HexCastleLayout GenerateInternal(
            int seed,
            int defenseLayerCount,
            HexCastleTheme theme,
            HexCastleThemeOneTuning tuning,
            HexCastleDifficultyProfile difficultyProfile)
        {
            if (defenseLayerCount < 2 || defenseLayerCount > CanonicalWallRadii.Length)
            {
                throw new ArgumentOutOfRangeException(nameof(defenseLayerCount), "방어선은 2~4중이어야 합니다.");
            }

            if (!HexCastleSilhouettePlanner.SupportedThemes.Contains(theme))
            {
                throw new ArgumentOutOfRangeException(
                    nameof(theme),
                    $"{theme}은 정식 육각 성 테마가 아닙니다.");
            }

            tuning = tuning ?? HexCastleThemeOneTuning.CreateDraftDefaults();
            tuning.Validate(defenseLayerCount);

            var wallRadii = ResolveCanonicalWallRadii(defenseLayerCount).ToArray();
            var requiredGateSocketCount = difficultyProfile == null
                ? 1
                : Enumerable.Range(0, wallRadii.Length - 1)
                    .Max(bandIndex => ResolveOpenPartitionGateTargetCount(
                        seed,
                        bandIndex,
                        tuning,
                        difficultyProfile));
            var plan = HexCastleSilhouettePlanner.Build(
                theme,
                seed,
                wallRadii,
                requiredGateSocketCount);
            var buildRadius = plan.MaximumRadius;
            var boardRadius = buildRadius + HexSpatialContract.MinimumDeploymentRings;
            var request = new HexCastleGenerationRequest(
                seed,
                theme,
                defenseLayerCount,
                boardRadius,
                buildRadius,
                PalaceFootprintRadius,
                difficultyProfile?.Level ?? 0);
            var cells = HexCoordinates.EnumerateRadius(boardRadius).ToDictionary(
                coordinate => coordinate,
                coordinate => CreateOpenCell(coordinate, buildRadius));

            ApplyPalace(cells, tuning);
            var reservedGateApproaches = ApplyWallNetwork(
                cells,
                seed,
                plan,
                wallRadii,
                tuning,
                difficultyProfile);
            ExpandExteriorDeployment(cells); // 실제 성벽 굴곡 바깥의 열린 바닥까지 배치 영역으로 연결
            var palaceGuardDirection = ApplyPalaceGuardBarracks(
                cells,
                seed,
                defenseLayerCount,
                tuning,
                difficultyProfile);
            ApplyPalaceGuardTurrets(cells, seed, defenseLayerCount, tuning, palaceGuardDirection);
            ApplyFoundationBuildings(
                cells,
                seed,
                plan,
                wallRadii,
                tuning,
                reservedGateApproaches,
                difficultyProfile);
            var traps = HexCastleTrapPlanner.Build(
                cells,
                wallRadii,
                difficultyProfile,
                buildRadius,
                seed);
            return new HexCastleLayout(
                request,
                cells,
                wallRadii,
                FoundationRulesVersionBase + tuning.DraftVersion,
                traps);

        public static readonly IReadOnlyList<HexCastleTheme> SupportedThemes = new[]
        {
            HexCastleTheme.CentralCompartment,
            HexCastleTheme.DiamondRadial,
            HexCastleTheme.CompositeCompartments,
            HexCastleTheme.HexHoneycomb,
            HexCastleTheme.PetalBloom,
            HexCastleTheme.CrystalMandala,
            HexCastleTheme.FractalBastion,
            HexCastleTheme.VoronoiCrystal,
            HexCastleTheme.IrisShutter
        };

        public static HexCastleSilhouettePlan Build(
            HexCastleTheme theme,
            int seed,
            IReadOnlyList<int> wallRadii,
            int requiredGateSocketCountPerBand = 1)
        {
            ValidateRadii(wallRadii);
            requiredGateSocketCountPerBand = Math.Max(1, Math.Min(2, requiredGateSocketCountPerBand));
            HexCastleSilhouettePlan result;
            switch (theme)
            {
                case HexCastleTheme.CentralCompartment:
                    result = BuildCentralPlan(wallRadii);
                    break;
                case HexCastleTheme.DiamondRadial:
                    result = BuildDiamondPlan(seed, wallRadii);
                    break;
                case HexCastleTheme.CompositeCompartments:
                    result = BuildCompositePlan(seed, wallRadii);
                    break;
                case HexCastleTheme.HexHoneycomb:
                    result = BuildHoneycombPlan(seed, wallRadii);
                    break;
                case HexCastleTheme.PetalBloom:
                    result = BuildPetalPlan(seed, wallRadii);
                    break;
                case HexCastleTheme.CrystalMandala:
                    result = BuildCrystalPlan(seed, wallRadii);
                    break;
                case HexCastleTheme.FractalBastion:
                    result = BuildFractalBastionPlan(seed, wallRadii);
                    break;
                case HexCastleTheme.VoronoiCrystal:
                    result = BuildVoronoiCrystalPlan(seed, wallRadii);
                    break;
                case HexCastleTheme.IrisShutter:
                    result = BuildIrisShutterPlan(seed, wallRadii);
                    break;
                default:
                    throw new InvalidOperationException(
                        $"{theme}은 아직 실제 육각 생성 규칙이 구현되지 않은 테마입니다.");
            }

            result = EnsureFormalGateSockets(result, seed, requiredGateSocketCountPerBand);
            ValidatePlan(result);
            return result;

        [Test]
        public void ThemeOneFoundation_IsDeterministicAndSeedChangesBuildingLayout()
        {
            var generator = new HexCastleFoundationGenerator();
            var first = generator.Generate(10801, 3);
            var repeat = generator.Generate(10801, 3);
            var changed = generator.Generate(10802, 3);

            Assert.That(repeat.LayoutSignature, Is.EqualTo(first.LayoutSignature));
            Assert.That(repeat.StructureSignature, Is.EqualTo(first.StructureSignature));
            Assert.That(changed.StructureSignature, Is.Not.EqualTo(first.StructureSignature));
            Assert.That(changed.LayoutSignature, Is.Not.EqualTo(first.LayoutSignature));
        }

        [Test]
        public void FormalThemeCatalog_IsExactlyAThroughIAndPreservesInnerRingsWhenExpanded()
        {
            const int seed = 10801;
            var themes = HexCastleThemeCatalog.ComparisonThemes;
            Assert.That(themes, Is.EqualTo(new[]
            {
                HexCastleTheme.CentralCompartment,
                HexCastleTheme.DiamondRadial,
                HexCastleTheme.CompositeCompartments,
                HexCastleTheme.HexHoneycomb,
                HexCastleTheme.PetalBloom,
                HexCastleTheme.CrystalMandala,
                HexCastleTheme.FractalBastion,
                HexCastleTheme.VoronoiCrystal,
                HexCastleTheme.IrisShutter
            }));
            Assert.That(themes.Select(HexCastleThemeCatalog.ResolveCode),
                Is.EqualTo("ABCDEFGHI".ToCharArray()));
            var signatures = new HashSet<string>();
            foreach (var theme in themes)
            {
                HexCastleSilhouettePlan previous = null;
                for (var defenseLayers = 2; defenseLayers <= 4; defenseLayers++)
                {
                    var radii = HexCastleFoundationGenerator.ResolveCanonicalWallRadii(defenseLayers);
                    var plan = HexCastleSilhouettePlanner.Build(theme, seed, radii);
                    Assert.That(plan.Rings.Count, Is.EqualTo(defenseLayers), theme.ToString());
                    if (previous != null)
                    {
                        for (var index = 0; index < previous.Rings.Count; index++)
                        {
                            Assert.That(plan.Rings[index].Cells,
                                Is.EqualTo(previous.Rings[index].Cells),
                                $"{theme}의 {index + 1}중벽 안쪽 골격이 증축 중 바뀌었습니다.");
                        }
                    }

                    previous = plan;
                }

                var largestPlan = previous;
                var signature = string.Join("|", largestPlan.Rings.Select(ring =>
                    string.Join(";", ring.Cells.Select(cell => $"{cell.Q},{cell.R}"))));
                Assert.That(signatures.Add(signature), Is.True, $"{theme} 외곽·중벽이 다른 후보와 같습니다.");
            }
        }

        [Test]
        public void FormalThemes_SeedSweepPreservesConnectedTopologyAndValidation()
        {
            var pipeline = new HexCastleGenerationPipeline();
            var themes = HexCastleThemeCatalog.Themes;
            foreach (var theme in themes)
            {
                for (var defenseLayers = 2; defenseLayers <= 4; defenseLayers++)
                {
                    for (var index = 0; index < 24; index++)
                    {
                        var seed = unchecked(10801 + index * 7919);
                        HexCastleCandidate candidate = null;
                        Assert.DoesNotThrow(() => candidate = pipeline.GenerateFoundation(
                            seed,
                            defenseLayers,
                            theme), $"{theme}/{defenseLayers}중벽/Seed {seed}");
                        Assert.That(candidate.Validation.IsValid, Is.True,
                            $"{theme}/{defenseLayers}중벽/Seed {seed}: " +
                            string.Join(" | ", candidate.Validation.Errors));
                    }
                }
            }
        }

            var wallTopology = HexCastleWallTopologyResolver.Build(layout);
            foreach (var pair in wallTopology)
            {
                var cell = layout.Cells[pair.Key];
                if (cell.Kind == HexCastleCellKind.Tower && pair.Value.ConnectionCount < 3)
                {
                    errors.Add($"2방향 성벽 {pair.Key}에 불필요한 연결 타워가 남았습니다.");
                }

                if (cell.Kind == HexCastleCellKind.Wall && pair.Value.ConnectionCount != 2)
                {
                    errors.Add($"일반 성벽 {pair.Key}의 연결 수가 2가 아닙니다.");
                }
            }

            var planner = new HexRoutePlanner();
            for (var direction = 0; direction < HexCoordinates.Directions.Length; direction++)
            {
                var start = HexCoordinates.Directions[direction] * layout.BattlefieldRadius;
                var route = planner.FindMinimumBreachRoute(layout, start);
                routes.Add(route);
                if (!route.IsComplete)
                {
                    errors.Add($"진입 방향 {direction}에서 왕궁까지 경로가 없습니다.");
                    continue;
                }

                var expectedLayers = Enumerable.Range(1, layout.DefenseLayerCount).ToArray();
                if (!route.CrossedDefenseLayers.SequenceEqual(expectedLayers))
                {
                    errors.Add($"진입 방향 {direction}의 방어층 순서가 {string.Join(",", route.CrossedDefenseLayers)}입니다.");
                }
            }

        private string CalculateSignature(bool includeContents)
        {
            unchecked
            {
                const ulong offset = 1469598103934665603UL;
                const ulong prime = 1099511628211UL;
                var hash = offset;
                var source = includeContents
                    ? cells.Values
                    : cells.Values.Where(cell =>
                        cell.IsWallPathCell || cell.Kind == HexCastleCellKind.Palace);
                foreach (var cell in source.OrderBy(value => value.Coordinates))
                {
                    hash ^= (uint)cell.Coordinates.Q;
                    hash *= prime;
                    hash ^= (uint)cell.Coordinates.R;
                    hash *= prime;
                    hash ^= (uint)cell.Kind;
                    hash *= prime;
                    hash ^= (uint)cell.DefenseLayer;
                    hash *= prime;
                    hash ^= (uint)cell.WallRole;
                    hash *= prime;
                    hash ^= (uint)cell.DistrictId;
                    hash *= prime;
                    hash ^= (uint)(cell.WallConnectionMask + 1);
                    hash *= prime;
                    if (cell.HasExplicitGateState)
                    {
                        hash ^= 0x47415433u;
                        hash *= prime;
                        hash ^= (uint)cell.GateRole;
                        hash *= prime;
                        hash ^= (uint)cell.GatePassageMask;
                        hash *= prime;
                    }
                    if (includeContents)
                    {
                        hash ^= (uint)Mathf.RoundToInt(cell.HitPoints * 10f);
                        hash *= prime;
                        hash ^= (uint)cell.RewardValue;
                        hash *= prime;

    public enum MonsterBasicAttackDeliveryModule // 피해가 목표까지 전달되는 핵심 방식
    {
        Direct,
        Projectile,
        TravelingArea
    }

    public enum MonsterBasicAttackCollisionModule // 이동 판정의 충돌 처리
    {
        DirectResolve,
        StopOnFirstTarget,
        Pierce,
        AreaImpact,
        PassThrough
    }

    public enum MonsterBasicAttackSequenceModule // 한 Marker 뒤 피해 단계 구성
    {
        Single,
        Burst,
        ReturnPasses
    }

    public enum MonsterBasicAttackMovementModule // 공격자 논리 루트 이동
    {
        None,
        Dash
    }

    public enum MonsterBasicAttackPresentationKind // 기본 연출 슬롯을 고르는 비전투 태그
    {
        Contact,
        Shot,
        Sweep,
        Thrust,
        Slam,
        Explosion,
        Instant,
        Dash,
        Combo,
        Scatter,
        Returning,
        Breath,
        Beam,
        Wave
    }

    public enum MonsterBasicAttackShape // XZ 판정 모양
    {
        Single,
        Fan,
        Line,
        Circle
    }

        private bool TryValidateModuleCombination(out string error)
        {
            if (DeliveryModule != MonsterBasicAttackDeliveryModule.Direct && combatType != MonsterCombatType.Ranged)
            {
                error = $"Moving Basic Attack delivery requires Ranged combat type. Profile={name}";
                return false;
            }

            if (DeliveryModule == MonsterBasicAttackDeliveryModule.Direct)
            {
                if (projectileTravel != MonsterBasicAttackProjectileTravel.None ||
                    CollisionModule != MonsterBasicAttackCollisionModule.DirectResolve || projectileCount != 1)
                {
                    error = $"Direct Basic Attack cannot use projectile travel, collision, or volley. Profile={name}";
                    return false;
                }
            }
            else if (DeliveryModule == MonsterBasicAttackDeliveryModule.Projectile)
            {
                if (projectileTravel == MonsterBasicAttackProjectileTravel.None ||
                    CollisionModule == MonsterBasicAttackCollisionModule.DirectResolve)
                {
                    error = $"Projectile Basic Attack requires travel and collision modules. Profile={name}";
                    return false;
                }

                if (CollisionModule == MonsterBasicAttackCollisionModule.AreaImpact && shape != MonsterBasicAttackShape.Circle)
                {
                    error = $"Area-impact Projectile requires a Circle shape. Profile={name}";
                    return false;
                }

                if (CollisionModule == MonsterBasicAttackCollisionModule.Pierce &&
                    projectileTravel != MonsterBasicAttackProjectileTravel.Straight)
                {
                    error = $"Piercing Projectile requires Straight travel. Profile={name}";
                    return false;
                }
            }
            else if (projectileTravel != MonsterBasicAttackProjectileTravel.Straight ||
                     CollisionModule != MonsterBasicAttackCollisionModule.PassThrough || projectileCount != 1)
            {
                error = $"Traveling Area requires Straight travel, PassThrough collision, and one actor. Profile={name}";
                return false;
            }

            switch (SequenceModule)
            {
                case MonsterBasicAttackSequenceModule.Single when HitCount != 1:
                    error = $"Single sequence requires one damage ratio. Profile={name}";
                    return false;
                case MonsterBasicAttackSequenceModule.Burst when
                    HitCount < 2 || DeliveryModule != MonsterBasicAttackDeliveryModule.Direct:
                    error = $"Burst sequence requires two or more Direct damage stages. Profile={name}";
                    return false;
                case MonsterBasicAttackSequenceModule.ReturnPasses when
                    HitCount != 2 || DeliveryModule != MonsterBasicAttackDeliveryModule.Projectile ||
                    projectileTravel != MonsterBasicAttackProjectileTravel.Returning ||
                    CollisionModule != MonsterBasicAttackCollisionModule.PassThrough || projectileCount != 1:
                    error = $"Return-pass sequence requires one Returning Projectile and two damage ratios. Profile={name}";
                    return false;
            }

            if (projectileTravel == MonsterBasicAttackProjectileTravel.Returning &&
                SequenceModule != MonsterBasicAttackSequenceModule.ReturnPasses)
            {
                error = $"Returning travel requires ReturnPasses sequence. Profile={name}";
                return false;
            }

            if (projectileCount > 1 &&
                (DeliveryModule != MonsterBasicAttackDeliveryModule.Projectile ||
                 projectileTravel != MonsterBasicAttackProjectileTravel.Straight ||
                 CollisionModule == MonsterBasicAttackCollisionModule.DirectResolve))
            {
                error = $"Volley requires a Straight Projectile collision recipe. Profile={name}";
                return false;
            }

            if (MovementModule == MonsterBasicAttackMovementModule.Dash &&
                dashDistance <= 0f)
            {
                error = $"Dash movement requires a positive distance. Profile={name}";
                return false;
            }

            if (sweepDirection != MonsterBasicAttackSweepDirection.Simultaneous &&
                (DeliveryModule != MonsterBasicAttackDeliveryModule.Direct ||
                 shape != MonsterBasicAttackShape.Fan || SequenceModule != MonsterBasicAttackSequenceModule.Single))
            {
                error = $"Directional sweep requires one Direct Fan hit. Profile={name}";
                return false;
            }

            error = null;
            return true;

    public static class MonsterBasicAttackBindingProjection // Draft 보관값에서 현재 공격에 필요한 연결만 투영
    {
        public static IReadOnlyList<MonsterBasicAttackBindingRequirement> BuildRequirements(
            MonsterBasicAttackProfile profile,
            IReadOnlyList<MonsterMakerAttackDraft> attacks)
        {
            var result = new List<MonsterBasicAttackBindingRequirement>();
            if (profile == null)
            {
                return result;
            }

            var motionIds = ResolveMotionIds(attacks);
            foreach (var slot in profile.VfxSlots)
            {
                if (slot == null)
                {
                    continue;
                }

                if (slot.AssignmentScope == MonsterBasicAttackVfxAssignmentScope.MonsterShared)
                {
                    result.Add(new MonsterBasicAttackBindingRequirement(profile.AttackId, slot, string.Empty));
                    continue;
                }

                foreach (var motionId in motionIds)
                {
                    result.Add(new MonsterBasicAttackBindingRequirement(profile.AttackId, slot, motionId));
                }
            }

            return result;
        }

        public static IReadOnlyList<MonsterBasicAttackVfxBinding> BuildActiveBindings(
            MonsterMakerDraft draft)
        {
            var result = new List<MonsterBasicAttackVfxBinding>();
            if (draft?.BasicAttackProfile == null)
            {
                return result;
            }

            foreach (var requirement in BuildRequirements(draft.BasicAttackProfile, draft.Attacks))
            {
                var binding = ResolveLast(draft.BasicAttackVfxBindings, requirement.Key);
                if (binding != null)
                {
                    result.Add(binding);
                }
            }

            return result;

    public sealed class MonsterBasicAttackExecutor : IMonsterActionExecutor // 15종 Profile을 조립 실행하는 단일 경계
    {
        private readonly List<UnitActor> targets = new List<UnitActor>();

        public bool Execute(MonsterActionExecutionContext context)
        {
            var action = context.AssetSet?.CombatProfile?.Action;
            var profile = context.ResolvedAttackBlock;
            if (profile == null || context.World == null || context.Source == null ||
                context.PrimaryTarget == null || !context.PrimaryTarget.IsAlive)
            {
                return false;
            }

            var origin = ResolveOrigin(context);
            var primaryPosition = context.PrimaryTarget.Position;
            var forward = ResolveForward(context.Source.transform.forward, origin, primaryPosition);
            context.World.ShowMonsterBasicAttackArea(
                profile,
                context.Source,
                origin,
                forward,
                primaryPosition,
                context.ResolvedAttackRange);

            if (profile.MovementModule == MonsterBasicAttackMovementModule.Dash)
            {
                var primaryActor = ResolveActor(context.PrimaryTarget);
                var stopDistance = context.Source.BodyRadius + (primaryActor?.BodyRadius ?? 0.25f);
                if (profile.VfxSlots.Count > 0)
                {
                    MonsterBasicAttackVfxRuntime.Dispatch(
                        MonsterBasicAttackVfxEvent.DashExit,
                        CreateVfxContext(
                            context,
                            profile,
                            origin,
                            primaryPosition,
                            primaryPosition,
                            Quaternion.LookRotation(forward, Vector3.up)));
                }
                context.Source.AdvanceForBasicAttack(
                    primaryPosition,
                    profile.DashDistance,
                    stopDistance,
                    profile.DashDuration / context.PlaybackSpeed);
                origin = context.Source.transform.position;
                forward = ResolveForward(forward, origin, primaryPosition);
                if (profile.VfxSlots.Count > 0)
                {
                    MonsterBasicAttackVfxRuntime.Dispatch(
                        MonsterBasicAttackVfxEvent.DashEnter,
                        CreateVfxContext(
                            context,
                            profile,
                            origin,
                            primaryPosition,
                            primaryPosition,
                            Quaternion.LookRotation(forward, Vector3.up)));
                }
            }

            var attackRotation = Quaternion.LookRotation(forward, Vector3.up);
            if (profile.VfxSlots.Count > 0)
            {
                MonsterBasicAttackVfxRuntime.Dispatch(
                    MonsterBasicAttackVfxEvent.RecipeExecute,
                    CreateVfxContext(context, profile, origin, primaryPosition, primaryPosition, attackRotation));
            }
            else
            {
                context.World.PlayMonsterFeedbackAt(
                    profile.LaunchFeedback,
                    origin,
                    attackRotation,
                    context.AssetSet?.BodyProfile?.VfxScale ?? 1f);
            }
            context.World.PlayBasicAttackFeelAt(
                profile.LaunchFeel,
                origin,
                attackRotation,
                context.AssetSet?.BodyProfile?.VfxScale ?? 1f,
                ResolveUnitFeelTarget(context.Source),
                ResolveFeelIntensity(context));

            if (profile.UsesProjectileVisual)
            {
                return LaunchProjectiles(
                    context,
                    profile,
                    context.AttackBlock == null ? action as ProjectileActionDefinition : null,
                    origin,
                    forward);
            }

            if (profile.Progression != MonsterBasicAttackProgression.Simultaneous &&
                profile.SequenceModule == MonsterBasicAttackSequenceModule.Single)
            {
                context.World.StartCoroutine(ContinueProgressiveHit(context, profile, origin, forward));
                return true;
            }

            if (profile.Shape == MonsterBasicAttackShape.Fan &&
                profile.SweepDirection != MonsterBasicAttackSweepDirection.Simultaneous &&
                profile.SequenceModule == MonsterBasicAttackSequenceModule.Single)
            {
                context.World.StartCoroutine(ContinueFanSweep(context, profile, origin, forward));
                return true;
            }

            if (profile.SequenceModule == MonsterBasicAttackSequenceModule.Burst)
            {
                var firstApplied = ApplyInstantHit(context, profile, origin, forward, 0);
                context.World.StartCoroutine(ContinueRepeatedHit(context, profile, origin, forward));
                return firstApplied;
            }

            return ApplyInstantHit(context, profile, origin, forward, 0);
        }

        private async Task<(bool Success, CommanderSkillSummonReceipt Receipt)> ApplyAndSaveCoreAsync(GameProgressChange change)
        {
            var notifyChanged = false;
            CommanderSkillSummonReceipt receipt = null;
            await gate.WaitAsync();
            try
            {
                if (!IsLoaded)
                {
                    ProjectMT.Shared.Audio.SfxProgressSounds.Notify(change, false);
                    return (false, null);
                }

                var candidate = current.Clone(
                    commanderSkillBalanceConfig,
                    commanderSkillSummonConfig); // 원본 보존 후 변경 검증
                if (!candidate.TryApply(
                        change,
                        commanderGrowthConfig,
                        itemCatalog,
                        equipmentBalanceConfig,
                        commanderSkillBalanceConfig,
                        commanderSkillSummonConfig))
                {
                    ProjectMT.Shared.Audio.SfxProgressSounds.Notify(change, false);
                    return (false, null);
                }

                try { await saveService.SaveAsync(candidate); } // 저장 성공을 먼저 확인
                catch
                {
                    try { ProjectMT.Shared.Audio.SfxEvents.Play2D(ProjectMT.Shared.Audio.SfxEvents.SaveError); }
                    catch (Exception soundError) { UnityEngine.Debug.LogException(soundError); }
                    throw;
                }
                current = candidate; // 성공한 후보만 확정
                receipt = candidate.CommanderSkillSummonReceipt;
                notifyChanged = !change.SuppressChangedNotification;
            }
            finally
            {
                gate.Release();
            }

            ProjectMT.Shared.Audio.SfxProgressSounds.Notify(change, true);
            if (notifyChanged)
            {
                Changed?.Invoke();
            }

            return (true, receipt);

        public async Task SaveAsync(GameProgressData data)
        {
            var envelope = new SaveEnvelope
            {
                dataVersion = CurrentDataVersion,
                savedAtUtc = DateTime.UtcNow.ToString("O"),
                gameData = data.Clone()
            };

            var json = JsonUtility.ToJson(envelope, true);
            var verification = JsonUtility.FromJson<SaveEnvelope>(json); // 쓰기 전 역직렬화 검증
            if (verification == null || verification.dataVersion != CurrentDataVersion || verification.gameData == null)
            {
                throw new InvalidOperationException("Serialized save verification failed.");
            }

            await fileStore.ReplaceAsync(savePath, Encoding.UTF8.GetBytes(json)); // 검증된 내용만 교체
        }

        public async Task ReplaceAsync(string path, byte[] bytes)
        {
            var directory = Path.GetDirectoryName(path);
            if (!string.IsNullOrEmpty(directory))
            {
                Directory.CreateDirectory(directory);
            }

            var temporaryPath = path + ".tmp"; // 완성 전 임시 파일
            var backupPath = path + ".bak"; // 교체 중 복구 파일
            await File.WriteAllBytesAsync(temporaryPath, bytes);

            if (!File.Exists(path))
            {
                File.Move(temporaryPath, path); // 첫 저장은 바로 이동
                return;
            }

            try
            {
                File.Replace(temporaryPath, path, backupPath, true); // 기존 파일 원자 교체
                if (File.Exists(backupPath))
                {
                    File.Delete(backupPath);
                }
            }
            catch (PlatformNotSupportedException)
            {
                File.Copy(temporaryPath, path, true); // 미지원 플랫폼 대체 경로
                File.Delete(temporaryPath);
            }

        private async Task HandleExitAsync(ActiveRun run, ContentOutcome outcome, IContentResultData result)
        {
            if (run == null || !ReferenceEquals(activeRun, run) || Interlocked.Exchange(ref run.ExitAccepted, 1) != 0) // 늦거나 중복된 결과 무시
            {
                return;
            }

            Phase = ContentFlowPhase.Finishing;
            if (outcome == ContentOutcome.Cancel || run.Definition.ResultAdapter == null)
            {
                FinishRun(run);
                return;
            }

            var adapter = run.Definition.ResultAdapter;
            var runInfo = run.Context.RunInfo;
            if (outcome != ContentOutcome.Complete || !adapter.IsSuccessfulResult(result))
            {
                run.PendingResultPresentation = new ContentResultPresentation(
                    run.Definition.ContentId,
                    run.Definition.DisplayName,
                    ContentOutcome.Fail,
                    adapter.CreateResultSummary(result, runInfo, ContentOutcome.Fail),
                    null);
                await ShowResultAndFinishAsync(run);
                return;
            }

        private async Task TrySaveAndFinishAsync(ActiveRun run)
        {
            if (run == null || !ReferenceEquals(activeRun, run) || Phase != ContentFlowPhase.Finishing ||
                run.PendingChange == null || Interlocked.Exchange(ref run.SettlementInFlight, 1) != 0)
            {
                return;
            }

            run.CanRetry = false;
            ShowSaving();

            var saved = false;
            try
            {
                saved = await progress.TryApplyAndSaveAsync(run.PendingChange);
            }
            catch (Exception exception)
            {
                Debug.LogException(exception);
            }
            finally
            {
                Interlocked.Exchange(ref run.SettlementInFlight, 0);
            }

            if (!ReferenceEquals(activeRun, run))
            {
                return;
            }

            if (!saved)
            {
                Debug.LogError($"Content progress could not be saved. Content={run.Definition.ContentId}");
                run.CanRetry = true;
                ShowSaveFailed(() => RetrySave(run));
                return;
            }

            HideFinishFeedback();
            PlayResultSound(run);
            if (run.PendingResultPresentation != null && resultView != null)
            {
                try
                {
                    await resultView.ShowAsync(run.PendingResultPresentation);
                }
                catch (Exception exception)
                {
                    Debug.LogException(exception); // 결과 표현 실패가 복귀를 막지 않음
                }

                if (!ReferenceEquals(activeRun, run))
                {
                    return;
                }
            }

            if (run.PendingPresentation != null)
            {
                try
                {
                    rewardPresentation?.PlayConfirmed(run.PendingPresentation); // 저장 성공 뒤에만 화면 연출 허용
                }
                catch (Exception exception)
                {
                    Debug.LogException(exception); // 표현 실패가 콘텐츠 복귀를 막지 않음
                }
            }

            FinishRun(run);

        public async Task CommanderLegionGrowth_SaveFailureLeavesConfirmedProgressUnchanged()
        {
            var config = ScriptableObject.CreateInstance<CommanderGrowthConfig>();
            var itemCatalog = AssetDatabase.LoadAssetAtPath<ItemCatalog>(
                "Assets/ProjectMT/02_Shared/Items/Data/ItemCatalog.asset");
            var store = new MemoryFileStore();
            var service = new GameDataService(new SaveService(store, "memory"), config, itemCatalog);
            await service.LoadAsync();

            try
            {
                Assert.That(await service.TryApplyAndSaveAsync(
                    GameProgressChange.GrantItems(new ItemAmount(ItemIds.Gold, 100L))), Is.True);
                store.FailWrites = true;

                Assert.ThrowsAsync<System.IO.IOException>(async () =>
                    await service.TryApplyAndSaveAsync(
                        GameProgressChange.UpgradeCommanderLegionStat(CommanderLegionStat.Defense, 0)));
                Assert.That(service.View.Gold, Is.EqualTo(100L));
                Assert.That(service.View.CommanderLegionGrowth.DefenseLevel, Is.Zero);
            }
            finally
            {
                UnityEngine.Object.DestroyImmediate(config);
            }
        }