using System;
using System.Collections.Generic;
using UnityEngine;

namespace IdleSpectator;

/// <summary>
/// Soft ~70/30 event-led vs character-led mix with decaying novelty penalties,
/// hard FixedDwell beat cooldowns, consecutive arc drop-off, and a rolling
/// rarity window (common arcs lose score; rare/absent arcs gain score).
/// </summary>
public static class InterestVariety
{
    public static float EventLedTarget => InterestScoringConfig.W.eventLedTarget;
    public static int MixWindow => Mathf.Max(1, InterestScoringConfig.W.mixWindow);
    public static float HardCooldownSeconds => InterestScoringConfig.W.hardCooldownSeconds;
    public static float FixedDwellBeatCooldownSeconds =>
        Mathf.Max(HardCooldownSeconds, InterestScoringConfig.W.fixedDwellBeatCooldownSeconds);
    public static float EditorialReplayCooldownSeconds => Mathf.Max(HardCooldownSeconds, 24f);
    public static float ExactReplayCooldownSeconds => Mathf.Max(HardCooldownSeconds, 90f);
    public static float RoutineReplayCooldownSeconds =>
        Mathf.Max(FixedDwellBeatCooldownSeconds, 120f);

    private static readonly List<InterestLeadKind> RecentMix = new List<InterestLeadKind>(32);
    private static readonly List<string> RecentArcs = new List<string>(32);
    private static readonly Dictionary<string, float> CooldownUntil = new Dictionary<string, float>(64);
    private static readonly System.Random Rng = new System.Random();

    private static readonly List<InterestCandidate> EventPool = new List<InterestCandidate>(64);
    private static readonly List<InterestCandidate> CharPool = new List<InterestCandidate>(64);
    private static readonly List<InterestCandidate> Ranked = new List<InterestCandidate>(16);

    private static string _lastArcKey = "";
    private static int _arcStreak;

    /// <summary>Whether the last <see cref="Pick"/> saw both pools non-empty (for mix metering).</summary>
    public static bool LastPickHadBothPools { get; private set; }

    /// <summary>Harness/debug: last shown variety arc key.</summary>
    public static string LastArcKey => _lastArcKey ?? "";

    /// <summary>Harness/debug: consecutive shows of <see cref="LastArcKey"/>.</summary>
    public static int ArcStreak => _arcStreak;

    /// <summary>Harness/debug: tips recorded in the rarity window.</summary>
    public static int ArcWindowCount => RecentArcs.Count;

    public static bool IsCombatRunBlocked(InterestCandidate candidate, int maxRun = 4)
    {
        if (candidate == null
            || candidate.Completion != InterestCompletionKind.CombatActive
            || RecentArcs.Count < maxRun)
        {
            return false;
        }

        NarrativeFunction function = NarrativeFunctionPolicy.Classify(candidate);
        string text = ((candidate.AssetId ?? "") + " "
                       + (candidate.Verb ?? "") + " "
                       + (candidate.Label ?? "")).ToLowerInvariant();
        bool decisive = function == NarrativeFunction.TurningPoint
                        || function == NarrativeFunction.Resolution
                        || function == NarrativeFunction.Consequence
                        || candidate.EventStrength >= 95f
                        || text.IndexOf("kill", StringComparison.Ordinal) >= 0
                        || text.IndexOf("slain", StringComparison.Ordinal) >= 0
                        || text.IndexOf("victory", StringComparison.Ordinal) >= 0;
        if (decisive)
        {
            return false;
        }

        int start = RecentArcs.Count - maxRun;
        for (int i = start; i < RecentArcs.Count; i++)
        {
            if (!IsCombatArc(RecentArcs[i]))
            {
                return false;
            }
        }

        return true;
    }

    public static bool HarnessProbeStabilityBudgets(out string detail)
    {
        Clear();
        var texture = new InterestCandidate
        {
            SubjectId = 991101,
            AssetId = "find_lover",
            Verb = "decides to find a lover",
            Label = "Probe decides to find a lover",
            Completion = InterestCompletionKind.ActivityActive
        };
        NoteSelection(texture, updateMix: false);
        bool textureBlocked = IsBeatCooled(texture);
        bool loverStillBlockedAtTenMinutes =
            IsBeatCooled(texture, Time.unscaledTime + 600f);
        bool loverEventuallyReopens =
            !IsBeatCooled(texture, Time.unscaledTime + 901f);

        Clear();
        HarnessPushArc("arc:combat:duel", 4);
        var combat = new InterestCandidate
        {
            SubjectId = 991102,
            AssetId = "live_combat",
            Label = "Duel - Probe A vs Probe B",
            Completion = InterestCompletionKind.CombatActive,
            EventStrength = 80f
        };
        bool combatBlocked = IsCombatRunBlocked(combat);
        combat.Label = "Probe A kills Probe B";
        combat.Verb = "kills";
        bool decisiveAllowed = !IsCombatRunBlocked(combat);
        Clear();

        detail = "textureBlocked=" + textureBlocked
                 + " lover10m=" + loverStillBlockedAtTenMinutes
                 + " loverReopens=" + loverEventuallyReopens
                 + " combatBlocked=" + combatBlocked
                 + " decisiveAllowed=" + decisiveAllowed;
        return textureBlocked
               && loverStillBlockedAtTenMinutes
               && loverEventuallyReopens
               && combatBlocked
               && decisiveAllowed;
    }

    public static void Clear()
    {
        RecentMix.Clear();
        RecentArcs.Clear();
        CooldownUntil.Clear();
        LastPickHadBothPools = false;
        _lastArcKey = "";
        _arcStreak = 0;
        CameraDirector.ClearReplayLedger();
    }

    /// <summary>Harness: push an arc into the rarity window without a full selection.</summary>
    public static void HarnessPushArc(string arcKey, int times = 1)
    {
        if (string.IsNullOrEmpty(arcKey))
        {
            return;
        }

        int n = Mathf.Max(1, times);
        for (int i = 0; i < n; i++)
        {
            PushArc(arcKey);
        }
    }

    /// <summary>Harness: seed the rolling mix meter without touching cooldowns.</summary>
    public static void HarnessSeedMix(int eventLedCount, int characterLedCount)
    {
        RecentMix.Clear();
        int e = Mathf.Max(0, eventLedCount);
        int c = Mathf.Max(0, characterLedCount);
        for (int i = 0; i < e; i++)
        {
            RecentMix.Add(InterestLeadKind.EventLed);
        }

        for (int i = 0; i < c; i++)
        {
            RecentMix.Add(InterestLeadKind.CharacterLed);
        }

        while (RecentMix.Count > MixWindow)
        {
            RecentMix.RemoveAt(0);
        }
    }

    public static void NoteSelection(InterestCandidate chosen)
    {
        NoteSelection(chosen, updateMix: LastPickHadBothPools);
    }

    public static void NoteSelection(InterestCandidate chosen, bool updateMix)
    {
        if (chosen == null)
        {
            return;
        }

        NoteVarietyArc(chosen);

        if (updateMix)
        {
            RecentMix.Add(chosen.LeadKind);
            while (RecentMix.Count > MixWindow)
            {
                RecentMix.RemoveAt(0);
            }
        }

        float until = Time.unscaledTime + (updateMix ? HardCooldownSeconds : HardCooldownSeconds * 0.5f);
        StampCooldown("unit:" + chosen.SubjectId, until);
        if (!string.IsNullOrEmpty(chosen.SpeciesId))
        {
            StampCooldown("species:" + chosen.SpeciesId, until * 0.7f);
        }

        if (!string.IsNullOrEmpty(chosen.Category))
        {
            StampCooldown("cat:" + chosen.Category, until * 0.5f);
        }

        if (!string.IsNullOrEmpty(chosen.CityKey))
        {
            StampCooldown("city:" + chosen.CityKey, until * 0.6f);
        }

        if (!string.IsNullOrEmpty(chosen.KingdomKey))
        {
            StampCooldown("kingdom:" + chosen.KingdomKey, until * 0.6f);
        }

        if (!string.IsNullOrEmpty(chosen.RegionKey))
        {
            StampCooldown("region:" + chosen.RegionKey, until * 0.5f);
        }

        if (!string.IsNullOrEmpty(chosen.Verb))
        {
            StampCooldown("verb:" + chosen.Verb, until * 0.4f);
        }

        string textureFamily = LowInformationTextureFamily(chosen);
        if (!string.IsNullOrEmpty(textureFamily) && chosen.SubjectId != 0)
        {
            float textureCooldown = string.Equals(
                textureFamily,
                "seeking_love",
                StringComparison.Ordinal)
                ? 900f
                : RoutineReplayCooldownSeconds;
            StampCooldown(
                "texture:" + chosen.SubjectId + ":" + textureFamily,
                Time.unscaledTime + textureCooldown);
        }

        // Moment beats: hard suppress the same story on the same subject.
        if (IsMomentBeat(chosen))
        {
            float beatSeconds = FixedDwellBeatCooldownSeconds;
            if (IsSoftLifeChapter(chosen))
            {
                float softCool = InterestScoringConfig.Story.familyLifeBeatCooldownSeconds;
                if (softCool > beatSeconds)
                {
                    beatSeconds = softCool;
                }
            }

            float beatUntil = Time.unscaledTime + beatSeconds;
            foreach (string beatKey in EnumerateBeatKeys(chosen))
            {
                StampCooldown(beatKey, beatUntil);
            }

        }

        // Sticky scenes are allowed to remain on screen while live, but once the editor
        // leaves one it must not immediately re-announce the identical phase/card.
        // The organic story-first soak otherwise produced Duel A-vs-B and "A is fighting"
        // several times in succession, plus repeated unchanged family-pack cards.
        string replayKey = EditorialReplayKey(chosen);
        if (!string.IsNullOrEmpty(replayKey))
        {
            StampCooldown(
                replayKey,
                Time.unscaledTime + EditorialReplayCooldownSeconds);
        }

        string routineKey = RoutineReplayKey(chosen);
        if (!string.IsNullOrEmpty(routineKey))
        {
            StampCooldown(
                routineKey,
                Time.unscaledTime + RoutineReplayCooldownSeconds);
        }

        string exactKey = ExactReplayKey(chosen);
        if (!string.IsNullOrEmpty(exactKey))
        {
            StampCooldown(
                exactKey,
                Time.unscaledTime + ExactReplayCooldownSeconds);
        }

        // Soft life chapters cool ledger heat so the same villagers do not monopolize.
        // Soft-life cool no longer demotes saga MCs (CharacterLedger removed).
    }

    /// <summary>
    /// True when the exact sticky editorial card was shown recently. This is deliberately
    /// separate from moment-beat cooling: a live scene may continue, but cannot be selected
    /// again as a fresh cut until another editorial beat has had room to breathe.
    /// </summary>
    public static bool IsEditorialReplayCooled(InterestCandidate c, float now = -1f)
    {
        string key = EditorialReplayKey(c);
        if (string.IsNullOrEmpty(key))
        {
            return false;
        }

        if (now < 0f)
        {
            now = Time.unscaledTime;
        }

        return CooldownUntil.TryGetValue(key, out float until) && now < until;
    }

    /// <summary>
    /// Prevent an identical player-facing sentence from being presented as a fresh cut,
    /// even when separate hooks generated different candidate keys.
    /// </summary>
    public static bool IsExactReplayCooled(InterestCandidate c, float now = -1f)
    {
        string key = ExactReplayKey(c);
        if (string.IsNullOrEmpty(key))
        {
            return false;
        }
        if (now < 0f) now = Time.unscaledTime;
        return CooldownUntil.TryGetValue(key, out float until) && now < until;
    }

    public static bool HarnessProbeEditorialReplay(out string detail)
    {
        Clear();
        var first = new InterestCandidate
        {
            Key = "combat:pair:1:2",
            Label = "Duel - Alpha vs Beta",
            Completion = InterestCompletionKind.CombatActive
        };
        NoteSelection(first, updateMix: false);
        var replay = new InterestCandidate
        {
            Key = "combat:pair:1:2:refresh",
            Label = "Mass - Beta (3) vs Alpha (5)",
            Completion = InterestCompletionKind.CombatActive
        };
        var different = new InterestCandidate
        {
            Key = "combat:pair:1:3",
            Label = "Duel - Alpha vs Gamma",
            Completion = InterestCompletionKind.CombatActive
        };
        var texture = new InterestCandidate
        {
            Key = "status:sleeping:1",
            Label = "Alpha · Falls asleep",
            Completion = InterestCompletionKind.StatusPhase,
            StatusId = "sleeping"
        };
        bool sameCooled = IsEditorialReplayCooled(replay);
        bool structuralExactCooled = IsExactReplayCooled(replay);
        bool differentOpen = !IsEditorialReplayCooled(different);
        bool textureUsesBeatPolicy = !IsEditorialReplayCooled(texture);
        var life = new InterestCandidate
        {
            Key = "relationship:1:2:first",
            Label = "Norron mates with Onaano",
            Completion = InterestCompletionKind.FixedDwell
        };
        NoteSelection(life, updateMix: false);
        var lifeReplay = new InterestCandidate
        {
            Key = "relationship:1:2:second",
            Label = "Norron mates with Onaano",
            Completion = InterestCompletionKind.FixedDwell
        };
        var lifeProgress = new InterestCandidate
        {
            Key = "relationship:1:2:home",
            Label = "Norron finds a home",
            Completion = InterestCompletionKind.FixedDwell
        };
        bool exactLifeCooled = IsExactReplayCooled(lifeReplay);
        bool progressedLifeOpen = !IsExactReplayCooled(lifeProgress);
        bool ok = sameCooled && structuralExactCooled
                  && differentOpen && textureUsesBeatPolicy
                  && exactLifeCooled && progressedLifeOpen;
        detail = "sameCooled=" + sameCooled
                 + " structuralExact=" + structuralExactCooled
                 + " differentOpen=" + differentOpen
                 + " textureUsesBeatPolicy=" + textureUsesBeatPolicy
                 + " exactLife=" + exactLifeCooled
                 + " progressedLife=" + progressedLifeOpen;
        Clear();
        return ok;
    }

    /// <summary>
    /// Routine texture may recur in the simulation, but the editor should not rediscover the
    /// same person's sleep/play/laugh/status beat every short cooldown cycle.
    /// </summary>
    public static bool IsRoutineReplayCooled(InterestCandidate c, float now = -1f)
    {
        string key = RoutineReplayKey(c);
        if (string.IsNullOrEmpty(key))
        {
            return false;
        }

        if (now < 0f)
        {
            now = Time.unscaledTime;
        }

        return CooldownUntil.TryGetValue(key, out float until) && now < until;
    }

    public static bool HarnessProbeRoutineReplay(out string detail)
    {
        Clear();
        var sleeping = new InterestCandidate
        {
            SubjectId = 41,
            StatusId = "sleeping",
            AssetId = "sleeping",
            Completion = InterestCompletionKind.StatusPhase,
            HasNarrativeFunction = true,
            NarrativeFunction = NarrativeFunction.CharacterTexture
        };
        NoteSelection(sleeping, updateMix: false);
        var same = new InterestCandidate
        {
            SubjectId = 41,
            StatusId = "sleeping",
            AssetId = "sleeping",
            Completion = InterestCompletionKind.StatusPhase,
            HasNarrativeFunction = true,
            NarrativeFunction = NarrativeFunction.CharacterTexture
        };
        var other = new InterestCandidate
        {
            SubjectId = 42,
            StatusId = "sleeping",
            AssetId = "sleeping",
            Completion = InterestCompletionKind.StatusPhase,
            HasNarrativeFunction = true,
            NarrativeFunction = NarrativeFunction.CharacterTexture
        };
        var love = new InterestCandidate
        {
            SubjectId = 41,
            HappinessEffectId = "fallen_in_love",
            HasNarrativeFunction = true,
            NarrativeFunction = NarrativeFunction.ThreadOpener
        };
        bool sameCooled = IsRoutineReplayCooled(same);
        bool otherOpen = !IsRoutineReplayCooled(other);
        bool storyOpen = !IsRoutineReplayCooled(love);
        bool ok = sameCooled && otherOpen && storyOpen;
        detail = "same=" + sameCooled + " other=" + otherOpen
                 + " story=" + storyOpen + " pass=" + ok;
        Clear();
        return ok;
    }

    public static bool HarnessProbeFamilyCoalescing(out string detail)
    {
        Clear();
        var birthFact = new InterestCandidate
        {
            SubjectId = 41,
            RelatedId = 43,
            AssetId = "add_child",
            Completion = InterestCompletionKind.FixedDwell
        };
        NoteSelection(birthFact, updateMix: false);

        var sameParentReaction = new InterestCandidate
        {
            SubjectId = 41,
            HappinessEffectId = "just_had_child",
            AssetId = "just_had_child",
            Completion = InterestCompletionKind.FixedDwell
        };
        var otherParentReaction = new InterestCandidate
        {
            SubjectId = 42,
            HappinessEffectId = "just_had_child",
            AssetId = "just_had_child",
            Completion = InterestCompletionKind.FixedDwell
        };

        bool echoCooled = IsBeatCooled(sameParentReaction);
        bool unrelatedOpen = !IsBeatCooled(otherParentReaction);
        bool ok = echoCooled && unrelatedOpen;
        detail = "echo=" + echoCooled
                 + " unrelated=" + unrelatedOpen
                 + " pass=" + ok;
        Clear();
        return ok;
    }

    /// <summary>
    /// Score to subtract when this candidate matches the last shown variety arc.
    /// After one duel show, the next duel pays <c>repeatArcPenaltyPer</c>; a lover resets the streak.
    /// </summary>
    public static float RepeatArcPenalty(InterestCandidate c)
    {
        if (c == null || _arcStreak <= 0 || string.IsNullOrEmpty(_lastArcKey))
        {
            return 0f;
        }

        string arc = VarietyArcKey(c);
        if (string.IsNullOrEmpty(arc)
            || !string.Equals(arc, _lastArcKey, StringComparison.OrdinalIgnoreCase))
        {
            return 0f;
        }

        ScoringWeights w = InterestScoringConfig.W;
        float per = w.repeatArcPenaltyPer > 0f ? w.repeatArcPenaltyPer : 24f;
        float cap = w.repeatArcPenaltyCap > 0f ? w.repeatArcPenaltyCap : 72f;
        return Mathf.Min(cap, _arcStreak * per);
    }

    /// <summary>
    /// Rolling rarity: arcs over-represented in the recent tip window lose score;
    /// absent/rare arcs gain score. Combat as a family gets an extra monopoly penalty.
    /// </summary>
    public static float FrequencyAdjust(InterestCandidate c)
    {
        if (c == null || RecentArcs.Count == 0)
        {
            return 0f;
        }

        string arc = VarietyArcKey(c);
        if (string.IsNullOrEmpty(arc))
        {
            return 0f;
        }

        ScoringWeights w = InterestScoringConfig.W;
        int window = Mathf.Max(4, w.arcFrequencyWindow > 0 ? w.arcFrequencyWindow : 16);
        int sample = Mathf.Min(RecentArcs.Count, window);
        if (sample <= 0)
        {
            return 0f;
        }

        int arcCount = 0;
        int combatCount = 0;
        int start = RecentArcs.Count - sample;
        for (int i = start; i < RecentArcs.Count; i++)
        {
            string a = RecentArcs[i];
            if (string.Equals(a, arc, StringComparison.OrdinalIgnoreCase))
            {
                arcCount++;
            }

            if (IsCombatArc(a))
            {
                combatCount++;
            }
        }

        float share = arcCount / (float)sample;
        float fair = w.arcFairShare > 0.02f ? w.arcFairShare : 0.12f;
        float overMax = w.arcOverSharePenaltyMax > 0f ? w.arcOverSharePenaltyMax : 48f;
        float underMax = w.arcUnderShareBoostMax > 0f ? w.arcUnderShareBoostMax : 22f;

        float adjust = 0f;
        if (share > fair)
        {
            float t = Mathf.Clamp01((share - fair) / Mathf.Max(0.05f, 1f - fair));
            adjust -= t * overMax;
        }
        else
        {
            float t = Mathf.Clamp01((fair - share) / fair);
            adjust += t * underMax;
        }

        if (IsCombatArc(arc))
        {
            float combatShare = combatCount / (float)sample;
            float combatTarget = w.arcCombatShareTarget > 0.05f ? w.arcCombatShareTarget : 0.35f;
            float combatPen = w.arcCombatOverSharePenaltyMax > 0f ? w.arcCombatOverSharePenaltyMax : 36f;
            if (combatShare > combatTarget)
            {
                float t = Mathf.Clamp01((combatShare - combatTarget) / Mathf.Max(0.05f, 1f - combatTarget));
                adjust -= t * combatPen;
            }
        }

        return adjust;
    }

    private static bool IsCombatArc(string arc) =>
        !string.IsNullOrEmpty(arc)
        && (arc.StartsWith("arc:combat:", StringComparison.OrdinalIgnoreCase)
            || string.Equals(arc, "arc:war", StringComparison.OrdinalIgnoreCase));

    /// <summary>
    /// Class-level arc for repeat drop-off (not per unit / pair id).
    /// Duels share one arc so back-to-back scraps lose score; Mass/Battle share another.
    /// </summary>
    public static string VarietyArcKey(InterestCandidate c)
    {
        if (c == null)
        {
            return "";
        }

        if (c.Completion == InterestCompletionKind.WarFront
            || string.Equals(c.AssetId, "live_war", StringComparison.OrdinalIgnoreCase))
        {
            return "arc:war";
        }

        if (string.Equals(c.Category, "Forage", StringComparison.OrdinalIgnoreCase)
            || string.Equals(c.AssetId, "building_consume_fruit", StringComparison.OrdinalIgnoreCase)
            || (!string.IsNullOrEmpty(c.Label)
                && c.Label.IndexOf("foraging", StringComparison.OrdinalIgnoreCase) >= 0))
        {
            return "arc:forage";
        }

        if (c.Completion == InterestCompletionKind.PlotActive
            || string.Equals(c.Category, "Plot", StringComparison.OrdinalIgnoreCase))
        {
            return "arc:plot";
        }

        if (c.Completion == InterestCompletionKind.StatusOutbreak
            || string.Equals(c.AssetId, "live_outbreak", StringComparison.OrdinalIgnoreCase))
        {
            return "arc:outbreak";
        }

        if (c.Completion == InterestCompletionKind.CombatActive
            || string.Equals(c.Category, "Combat", StringComparison.OrdinalIgnoreCase)
            || string.Equals(c.AssetId, "live_battle", StringComparison.OrdinalIgnoreCase)
            || string.Equals(c.AssetId, "live_combat", StringComparison.OrdinalIgnoreCase)
            || string.Equals(c.Verb, "fighting", StringComparison.OrdinalIgnoreCase))
        {
            if (string.Equals(c.AssetId, "live_battle", StringComparison.OrdinalIgnoreCase))
            {
                return "arc:combat:multi";
            }

            ScoringWeights w = InterestScoringConfig.W;
            int sideSum = Mathf.Max(0, c.CombatSideACount) + Mathf.Max(0, c.CombatSideBCount);
            int size = Mathf.Max(Mathf.Max(0, c.ParticipantCount), sideSum);
            int duelMax = Mathf.Max(1, w.duelMaxFighters);
            if (size > 0 && size <= duelMax)
            {
                return "arc:combat:duel";
            }

            return "arc:combat:multi";
        }

        if (StoryReason.IsStoryAsset(c.AssetId)
            || string.Equals(c.Source, "story_planner", StringComparison.OrdinalIgnoreCase)
            || string.Equals(c.Category, "Story", StringComparison.OrdinalIgnoreCase))
        {
            if (!string.IsNullOrEmpty(c.AssetId)
                && c.AssetId.StartsWith("epilogue_", StringComparison.OrdinalIgnoreCase))
            {
                return "arc:life:epilogue";
            }

            return "arc:life:aftermath";
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId))
        {
            string h = c.HappinessEffectId.Trim().ToLowerInvariant();
            if (h.IndexOf("death_", StringComparison.Ordinal) >= 0
                || h.IndexOf("mourn", StringComparison.Ordinal) >= 0
                || h.IndexOf("despair", StringComparison.Ordinal) >= 0
                || h.IndexOf("grief", StringComparison.Ordinal) >= 0)
            {
                return "arc:life:grief";
            }

            if (IsKillLifeHappinessId(h))
            {
                return "arc:life:kill";
            }

            if (h == "just_got_out_of_egg")
            {
                return "arc:life:hatch";
            }

            if (IsIntimacyHappinessId(h))
            {
                return "arc:life:intimacy";
            }

            if (IsCourtshipHappinessId(h)
                || h.IndexOf("lover", StringComparison.Ordinal) >= 0
                || h.IndexOf("love", StringComparison.Ordinal) >= 0
                || h.IndexOf("married", StringComparison.Ordinal) >= 0
                || h.IndexOf("wedding", StringComparison.Ordinal) >= 0)
            {
                return "arc:life:love";
            }

            if (IsFamilyLifeHappinessId(h))
            {
                return "arc:life:family";
            }

            if (IsSettlementHappinessId(h))
            {
                return "arc:life:home";
            }

            if (IsRestLifeId(h))
            {
                return "arc:life:rest";
            }

            return "arc:hap:" + h;
        }

        if (!string.IsNullOrEmpty(c.StatusId))
        {
            if (IsFamilyLifeHappinessId(c.StatusId))
            {
                return "arc:life:family";
            }

            if (IsSettlementHappinessId(c.StatusId))
            {
                return "arc:life:home";
            }

            if (IsCourtshipHappinessId(c.StatusId))
            {
                return "arc:life:love";
            }

            if (IsRestLifeId(c.StatusId))
            {
                return "arc:life:rest";
            }

            if (IsSoftStatusFxId(c.StatusId))
            {
                return "arc:status:fx";
            }

            return "arc:status:" + c.StatusId.Trim().ToLowerInvariant();
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        if (!string.IsNullOrEmpty(asset) && !asset.StartsWith("live_", StringComparison.Ordinal))
        {
            if (IsKillLifeAssetId(asset))
            {
                return "arc:life:kill";
            }

            if (IsCourtshipAssetId(asset))
            {
                return "arc:life:love";
            }

            if (string.Equals(c.Category, "Spectacle", StringComparison.OrdinalIgnoreCase)
                || asset.StartsWith("cast_", StringComparison.Ordinal)
                || asset.StartsWith("summon_", StringComparison.Ordinal))
            {
                return "arc:spectacle";
            }

            if (EventCatalog.Decision.IsLifeIntentDecision(asset)
                || IsLifeIntentDecisionChapter(c))
            {
                return "arc:decision:intent";
            }

            if (IsRestLifeId(asset) || IsRestLifeChapter(c))
            {
                return "arc:life:rest";
            }

            if (IsWorldLogMetaAssetId(asset) || IsWorldLogMetaChapter(c))
            {
                return "arc:worldlog:meta";
            }

            if (IsConstructionChapter(c))
            {
                return "arc:construction";
            }

            if (string.Equals(c.Category, "Politics", StringComparison.OrdinalIgnoreCase)
                || (c.Label != null
                    && c.Label.IndexOf("decides to", StringComparison.OrdinalIgnoreCase) >= 0))
            {
                return "arc:decision";
            }

            return "arc:asset:" + asset;
        }

        if (IsLifeIntentDecisionChapter(c))
        {
            return "arc:decision:intent";
        }

        if (IsRestLifeChapter(c))
        {
            return "arc:life:rest";
        }

        if (IsWorldLogMetaChapter(c))
        {
            return "arc:worldlog:meta";
        }

        if (IsConstructionChapter(c))
        {
            return "arc:construction";
        }

        if (IsSoftStatusFxChapter(c))
        {
            return "arc:status:fx";
        }

        if (IsHatchLifeChapter(c))
        {
            return "arc:life:hatch";
        }

        if (IsKillLifeChapter(c))
        {
            return "arc:life:kill";
        }

        if (IsCourtshipLifeChapter(c))
        {
            return "arc:life:love";
        }

        if (!string.IsNullOrEmpty(c.Category))
        {
            return "arc:cat:" + c.Category.Trim().ToLowerInvariant();
        }

        if (!string.IsNullOrEmpty(c.Verb))
        {
            return "arc:verb:" + c.Verb.Trim().ToLowerInvariant();
        }

        return "";
    }

    private static void NoteVarietyArc(InterestCandidate chosen)
    {
        string arc = VarietyArcKey(chosen);
        if (string.IsNullOrEmpty(arc))
        {
            return;
        }

        if (string.Equals(arc, _lastArcKey, StringComparison.OrdinalIgnoreCase))
        {
            _arcStreak = Mathf.Max(1, _arcStreak + 1);
        }
        else
        {
            _lastArcKey = arc;
            _arcStreak = 1;
        }

        PushArc(arc);
    }

    private static void PushArc(string arc)
    {
        if (string.IsNullOrEmpty(arc))
        {
            return;
        }

        RecentArcs.Add(arc);
        int window = Mathf.Max(4, InterestScoringConfig.W.arcFrequencyWindow > 0
            ? InterestScoringConfig.W.arcFrequencyWindow
            : 16);
        while (RecentArcs.Count > window)
        {
            RecentArcs.RemoveAt(0);
        }
    }

    /// <summary>
    /// True when a FixedDwell / moment beat for this candidate is still hard-cooled.
    /// Sticky combat / war / plot / pack / outbreak scenes are never beat-blocked.
    /// </summary>
    public static bool IsBeatCooled(InterestCandidate c, float now = -1f)
    {
        if (c == null)
        {
            return false;
        }

        if (now < 0f)
        {
            now = Time.unscaledTime;
        }

        string textureFamily = LowInformationTextureFamily(c);
        if (!string.IsNullOrEmpty(textureFamily)
            && c.SubjectId != 0
            && CooldownUntil.TryGetValue(
                "texture:" + c.SubjectId + ":" + textureFamily,
                out float textureUntil)
            && now < textureUntil)
        {
            return true;
        }

        if (!IsMomentBeat(c))
        {
            return false;
        }

        // Synthetic story beats finish the active arc - never hard-skip them for FixedDwell cool.
        // Soft novelty / repeat-arc penalties still apply via RecalcTotal.
        if (StoryReason.IsStoryAsset(c.AssetId)
            || string.Equals(c.Source, "story_planner", StringComparison.OrdinalIgnoreCase))
        {
            return false;
        }

        foreach (string beatKey in EnumerateBeatKeys(c))
        {
            if (CooldownUntil.TryGetValue(beatKey, out float until) && now < until)
            {
                return true;
            }
        }

        return false;
    }

    private static string LowInformationTextureFamily(InterestCandidate c)
    {
        if (c == null)
        {
            return "";
        }

        string text = ((c.AssetId ?? "") + " "
                       + (c.HappinessEffectId ?? "") + " "
                       + (c.StatusId ?? "") + " "
                       + (c.Verb ?? "") + " "
                       + (c.Label ?? "")).ToLowerInvariant();
        if (text.IndexOf("sleep", StringComparison.Ordinal) >= 0
            || text.IndexOf("nap", StringComparison.Ordinal) >= 0)
            return "rest";
        if (text.IndexOf("laugh", StringComparison.Ordinal) >= 0
            || text.IndexOf("play", StringComparison.Ordinal) >= 0)
            return "play";
        if (text.IndexOf("caffeine", StringComparison.Ordinal) >= 0
            || text.IndexOf("coffee", StringComparison.Ordinal) >= 0)
            return "caffeine";
        if (text.IndexOf("find_lover", StringComparison.Ordinal) >= 0
            || text.IndexOf("find a lover", StringComparison.Ordinal) >= 0)
            return "seeking_love";
        if (text.IndexOf("wander", StringComparison.Ordinal) >= 0)
            return "wandering";
        return "";
    }

    /// <summary>
    /// Pick next candidate. Soft 70/30: prefer event-led when below target and pool non-empty.
    /// Empty event pool → character-led without inventing events (mix meter not updated for empty-side windows).
    /// </summary>
    public static InterestCandidate Pick(List<InterestCandidate> pending, InterestCandidate current)
    {
        if (pending == null || pending.Count == 0)
        {
            return null;
        }

        EventPool.Clear();
        CharPool.Clear();
        float now = Time.unscaledTime;
        for (int i = 0; i < pending.Count; i++)
        {
            InterestCandidate c = pending[i];
            if (c == null || !c.HasValidPosition)
            {
                continue;
            }

            if (current != null && c.Key == current.Key)
            {
                continue;
            }

            // Same life beat on the same subject already watched - hard skip.
            if (IsBeatCooled(c, now))
            {
                InterestDropLog.Record("beat_cooldown", BeatDropDetail(c));
                continue;
            }

            if (IsEditorialReplayCooled(c, now))
            {
                InterestDropLog.Record("editorial_replay", c.Label ?? c.Key);
                continue;
            }

            if (IsExactReplayCooled(c, now))
            {
                InterestDropLog.Record("exact_replay", c.Label ?? c.Key);
                continue;
            }

            if (IsRoutineReplayCooled(c, now))
            {
                InterestDropLog.Record("routine_replay", c.Label ?? c.Key);
                continue;
            }

            if (c.LeadKind == InterestLeadKind.CharacterLed)
            {
                CharPool.Add(c);
            }
            else
            {
                EventPool.Add(c);
            }
        }

        bool bothHadCandidates = EventPool.Count > 0 && CharPool.Count > 0;
        bool preferEvent = EventPool.Count > 0;
        if (bothHadCandidates)
        {
            // Empty mix biases event-led; otherwise prefer event until share reaches target.
            preferEvent = MixSampleCount == 0 || EventShare() < EventLedTarget;
        }
        else if (EventPool.Count == 0)
        {
            preferEvent = false;
        }

        // Soft mix: empty event pool → character-led without inventing events.
        // Mix meter is updated in NoteSelection only when both pools were non-empty at pick time.
        LastPickHadBothPools = bothHadCandidates;

        List<InterestCandidate> pool = preferEvent
            ? (EventPool.Count > 0 ? EventPool : CharPool)
            : (CharPool.Count > 0 ? CharPool : EventPool);

        if (pool.Count == 0)
        {
            return null;
        }

        Ranked.Clear();
        for (int i = 0; i < pool.Count; i++)
        {
            InterestCandidate c = pool[i];
            float penalty = NoveltyPenalty(c, now);
            // Epic / favorites bypass most soft novelty - never FixedDwell beat cooldowns
            // (those already hard-skipped above).
            if (InterestScoring.IsHotScore(c.TotalScore) || InterestScoring.IsNotable(c.FollowUnit))
            {
                penalty *= 0.15f;
            }

            c.Novelty = Mathf.Clamp01(1f - penalty);
            InterestScoring.RecalcTotal(c);
            Ranked.Add(c);
        }

        Ranked.Sort(InterestScoring.CompareByUrgencyThenScore);
        InterestScoring.EnrichTopK(Ranked);

        // Prefer active story-owned beats when present.
        for (int i = 1; i < Ranked.Count; i++)
        {
            if (StoryPlanner.PreferOver(Ranked[i], Ranked[0]))
            {
                InterestCandidate owned = Ranked[i];
                Ranked.RemoveAt(i);
                Ranked.Insert(0, owned);
                break;
            }
        }

        int topN = Mathf.Min(3, Ranked.Count);
        if (topN <= 0)
        {
            return null;
        }

        // Deterministic #1 unless near-tie among top scores.
        if (topN == 1)
        {
            return Ranked[0];
        }

        float epsilon = InterestScoringConfig.Story.nearTieEpsilon;
        if (epsilon <= 0f)
        {
            epsilon = 8f;
        }

        float sagaEpsilon = InterestScoringConfig.Story.sagaNearTieEpsilon;
        if (sagaEpsilon <= 0f)
        {
            sagaEpsilon = 20f;
        }

        sagaEpsilon = Mathf.Max(sagaEpsilon, epsilon);

        // Large gap: take #1 unless a Prefer/MC/cast tip sits within the wider saga band.
        if (Ranked[0].TotalScore - Ranked[1].TotalScore >= epsilon)
        {
            InterestCandidate sagaCut = PickBestSagaInBand(Ranked, Ranked.Count, sagaEpsilon);
            if (sagaCut != null)
            {
                return sagaCut;
            }

            return Ranked[0];
        }

        // Near-tie: Prefer'd MC, then any MC, then MC cast, else random among top-N.
        InterestCandidate bestSaga = PickBestSagaInBand(Ranked, topN, epsilon);
        if (bestSaga != null)
        {
            return bestSaga;
        }

        int pick = Rng.Next(topN);
        return Ranked[pick];
    }

    /// <summary>
    /// Prefer (4) > CrossMC (3) > MC (2) > MC cast (1) among candidates within <paramref name="band"/> of #1.
    /// </summary>
    private static InterestCandidate PickBestSagaInBand(
        List<InterestCandidate> ranked,
        int limit,
        float band)
    {
        if (ranked == null || ranked.Count == 0 || band < 0f)
        {
            return null;
        }

        int n = Mathf.Min(limit, ranked.Count);
        float top = ranked[0].TotalScore;
        InterestCandidate bestSaga = null;
        int bestRank = 0;
        for (int i = 0; i < n; i++)
        {
            InterestCandidate c = ranked[i];
            if (c == null)
            {
                continue;
            }

            if (top - c.TotalScore >= band)
            {
                break;
            }

            int rank = LifeSagaRoster.SoftBiasRank(c);
            if (rank > bestRank)
            {
                bestRank = rank;
                bestSaga = c;
            }
        }

        return bestRank > 0 ? bestSaga : null;
    }

    public static float EventShare()
    {
        if (RecentMix.Count == 0)
        {
            return EventLedTarget;
        }

        int events = 0;
        for (int i = 0; i < RecentMix.Count; i++)
        {
            if (RecentMix[i] == InterestLeadKind.EventLed)
            {
                events++;
            }
        }

        return events / (float)RecentMix.Count;
    }

    public static int MixSampleCount => RecentMix.Count;

    private static bool IsMomentBeat(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        switch (c.Completion)
        {
            case InterestCompletionKind.FixedDwell:
            case InterestCompletionKind.Manual:
            case InterestCompletionKind.HappinessGrief:
                // Discrete life / emotion beats (parenthood, grief, catalog moments).
                return true;
            case InterestCompletionKind.StatusPhase:
                // Unit status tips cool by status id; sticky outbreaks are excluded below.
                return string.IsNullOrEmpty(c.AssetId)
                       || !c.AssetId.Equals("live_outbreak", System.StringComparison.OrdinalIgnoreCase);
            default:
                return false;
        }
    }

    private static string EditorialReplayKey(InterestCandidate c)
    {
        if (c == null)
        {
            return "";
        }
        EnsureReplayKeys(c);
        return c.CachedEditorialReplayKey;
    }

    private static string BuildEditorialReplayKey(
        InterestCandidate c,
        string normalizedLabel)
    {

        bool stickyCard = c.Completion == InterestCompletionKind.CombatActive
                          || c.Completion == InterestCompletionKind.WarFront
                          || c.Completion == InterestCompletionKind.PlotActive
                          || c.Completion == InterestCompletionKind.StatusOutbreak
                          || c.Completion == InterestCompletionKind.FamilyPack
                          || StoryReason.IsStoryAsset(c.AssetId)
                          || string.Equals(c.Source, "story_planner", StringComparison.OrdinalIgnoreCase);
        if (!stickyCard)
        {
            return "";
        }

        if (!string.IsNullOrEmpty(normalizedLabel))
        {
            return "replay:label:" + normalizedLabel;
        }

        string key = (c.Key ?? "").Trim().ToLowerInvariant();
        return string.IsNullOrEmpty(key) ? "" : "replay:key:" + key;
    }

    private static string ExactReplayKey(InterestCandidate c)
    {
        if (c == null)
        {
            return "";
        }
        EnsureReplayKeys(c);
        return c.CachedExactReplayKey;
    }

    private static string RoutineReplayKey(InterestCandidate c)
    {
        if (c == null || c.SubjectId == 0)
        {
            return "";
        }
        EnsureReplayKeys(c);
        return c.CachedRoutineReplayKey;
    }

    private static string BuildRoutineReplayKey(InterestCandidate c)
    {

        NarrativeFunction function = NarrativeFunctionPolicy.Classify(c);
        if (function != NarrativeFunction.CharacterTexture
            && !IsRestLifeChapter(c)
            && !IsSoftStatusFxChapter(c))
        {
            return "";
        }

        string family = c.StatusId;
        if (string.IsNullOrEmpty(family)) family = c.HappinessEffectId;
        if (string.IsNullOrEmpty(family)) family = c.NarrativePresentation?.ActionId;
        if (string.IsNullOrEmpty(family)) family = c.AssetId;
        if (string.IsNullOrEmpty(family)) family = NormalizeBeatLabel(c.Label);
        family = (family ?? "").Trim().ToLowerInvariant();
        return string.IsNullOrEmpty(family)
            ? ""
            : "routine:" + c.SubjectId + ":" + family;
    }

    private static void EnsureReplayKeys(InterestCandidate c)
    {
        string label = c.Label ?? "";
        string key = c.Key ?? "";
        string assetId = c.AssetId ?? "";
        string source = c.Source ?? "";
        string statusId = c.StatusId ?? "";
        string happinessId = c.HappinessEffectId ?? "";
        string actionId = c.NarrativePresentation?.ActionId ?? "";
        if (c.ReplayKeysCached
            && c.ReplayCacheSubjectId == c.SubjectId
            && c.ReplayCacheCompletion == c.Completion
            && c.ReplayCacheFunction == c.NarrativeFunction
            && c.ReplayCacheHasFunction == c.HasNarrativeFunction
            && string.Equals(c.ReplayCacheLabel, label, StringComparison.Ordinal)
            && string.Equals(c.ReplayCacheKey, key, StringComparison.Ordinal)
            && string.Equals(c.ReplayCacheAssetId, assetId, StringComparison.Ordinal)
            && string.Equals(c.ReplayCacheSource, source, StringComparison.Ordinal)
            && string.Equals(c.ReplayCacheStatusId, statusId, StringComparison.Ordinal)
            && string.Equals(
                c.ReplayCacheHappinessEffectId, happinessId, StringComparison.Ordinal)
            && string.Equals(c.ReplayCacheActionId, actionId, StringComparison.Ordinal))
        {
            return;
        }

        c.ReplayKeysCached = true;
        c.ReplayCacheLabel = label;
        c.ReplayCacheKey = key;
        c.ReplayCacheAssetId = assetId;
        c.ReplayCacheSource = source;
        c.ReplayCacheStatusId = statusId;
        c.ReplayCacheHappinessEffectId = happinessId;
        c.ReplayCacheActionId = actionId;
        c.ReplayCacheSubjectId = c.SubjectId;
        c.ReplayCacheCompletion = c.Completion;
        c.ReplayCacheFunction = c.NarrativeFunction;
        c.ReplayCacheHasFunction = c.HasNarrativeFunction;

        string normalizedLabel = EventReason.ReplayStructureKey(label);
        c.CachedEditorialReplayKey = BuildEditorialReplayKey(c, normalizedLabel);
        c.CachedExactReplayKey = string.IsNullOrEmpty(normalizedLabel)
            ? ""
            : "exact:label:" + normalizedLabel;
        c.CachedRoutineReplayKey = BuildRoutineReplayKey(c);
    }

    /// <summary>
    /// Parenthood / pregnancy / newborn family chapter - variety + ledger cool as a class.
    /// </summary>
    public static bool IsFamilyLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId)
            && IsFamilyLifeHappinessId(c.HappinessEffectId))
        {
            return true;
        }

        if (!string.IsNullOrEmpty(c.StatusId)
            && IsFamilyLifeHappinessId(c.StatusId))
        {
            return true;
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        return asset.IndexOf("child", StringComparison.Ordinal) >= 0
               || asset.IndexOf("pregnant", StringComparison.Ordinal) >= 0
               || asset.IndexOf("birth", StringComparison.Ordinal) >= 0
               || asset.IndexOf("baby", StringComparison.Ordinal) >= 0
               || asset.IndexOf("newborn", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Kiss / mate / intimacy chapter - same soft-life cool class as family (pair + world).
    /// </summary>
    public static bool IsIntimacyLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId)
            && IsIntimacyHappinessId(c.HappinessEffectId))
        {
            return true;
        }

        if (!string.IsNullOrEmpty(c.StatusId)
            && IsIntimacyHappinessId(c.StatusId))
        {
            return true;
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        if (IsIntimacyHappinessId(asset))
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.IndexOf("shares intimacy", StringComparison.Ordinal) >= 0
               || label.IndexOf("mates with", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// House-found settlement chapter - repeats easily and steals between combat beats.
    /// (House-lost stays camera-worthy without the same soft cool.)
    /// </summary>
    public static bool IsSettlementLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId)
            && IsSettlementHappinessId(c.HappinessEffectId))
        {
            return true;
        }

        if (!string.IsNullOrEmpty(c.StatusId)
            && IsSettlementHappinessId(c.StatusId))
        {
            return true;
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        if (IsSettlementHappinessId(asset))
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.IndexOf("finds a home", StringComparison.Ordinal) >= 0
               || label.IndexOf("settles into a house", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Chronicle / happiness kill crumbs - repeat easily for hunters between combat tips.
    /// </summary>
    public static bool IsKillLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId)
            && IsKillLifeHappinessId(c.HappinessEffectId))
        {
            return true;
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        if (IsKillLifeAssetId(asset))
        {
            return true;
        }

        if (!string.IsNullOrEmpty(c.Key)
            && c.Key.IndexOf("milestone_kill", StringComparison.OrdinalIgnoreCase) >= 0)
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.StartsWith("killed ", StringComparison.Ordinal);
    }

    /// <summary>
    /// Smitten / seeking-lover courtship crumbs (not bond outcomes like set_lover).
    /// </summary>
    public static bool IsCourtshipLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId)
            && IsCourtshipHappinessId(c.HappinessEffectId))
        {
            return true;
        }

        if (!string.IsNullOrEmpty(c.StatusId)
            && IsCourtshipHappinessId(c.StatusId))
        {
            return true;
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        if (IsCourtshipAssetId(asset))
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.IndexOf("is smitten", StringComparison.Ordinal) >= 0
               || label.IndexOf("falls in love", StringComparison.Ordinal) >= 0
               || label.IndexOf("seeking a lover", StringComparison.Ordinal) >= 0
               || label.IndexOf("is seeking a lover", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Decision intent crumbs (reproduce / find lover) - outcomes own the real story.
    /// </summary>
    public static bool IsLifeIntentDecisionChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        string asset = (c.AssetId ?? "").Trim();
        if (EventCatalog.Decision.IsLifeIntentDecision(asset))
        {
            return true;
        }

        // Live decision feed: Source is authoritative even when AssetId was species-clobbered.
        if (string.Equals(c.Source, "decision", StringComparison.OrdinalIgnoreCase)
            && (EventCatalog.Decision.IsLifeIntentDecision(asset)
                || asset.IndexOf("reproduction", StringComparison.OrdinalIgnoreCase) >= 0
                || asset.IndexOf("find_lover", StringComparison.OrdinalIgnoreCase) >= 0
                || asset.IndexOf("baby_make", StringComparison.OrdinalIgnoreCase) >= 0
                || asset.IndexOf("have_child", StringComparison.OrdinalIgnoreCase) >= 0))
        {
            return true;
        }

        // Label-only rebuilds still cool when AssetId was lost.
        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.IndexOf("decides to try to reproduce", StringComparison.Ordinal) >= 0
               || label.IndexOf("decides to find a lover", StringComparison.Ordinal) >= 0
               || label.IndexOf("decides to reproduce", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Ordinary civ construction finishes (tents/houses). Spectacle wonders stay hotter.
    /// </summary>
    public static bool IsConstructionChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        string asset = c.AssetId ?? "";
        bool buildingSource = string.Equals(c.Source, "building", StringComparison.OrdinalIgnoreCase)
                              || (!string.IsNullOrEmpty(c.Key)
                                  && c.Key.StartsWith(
                                      "building:complete:",
                                      StringComparison.OrdinalIgnoreCase));
        if (buildingSource)
        {
            return !LibraryAssetNames.IsSpectacleBuilding(asset, null);
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        if (label.IndexOf(" finishes ", StringComparison.Ordinal) < 0
            && !label.StartsWith("building finished", StringComparison.Ordinal))
        {
            return false;
        }

        // Spectacle prose uses "wonder".
        return label.IndexOf("wonder", StringComparison.Ordinal) < 0;
    }

    /// <summary>
    /// Brief personal status FX (singing, rooting, moods) - not danger/combat statuses.
    /// </summary>
    public static bool IsSoftStatusFxChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        string status = !string.IsNullOrEmpty(c.StatusId) ? c.StatusId : c.AssetId;
        if (string.IsNullOrEmpty(status))
        {
            return false;
        }

        if (c.Completion != InterestCompletionKind.StatusPhase
            && c.Completion != InterestCompletionKind.FixedDwell
            && string.IsNullOrEmpty(c.StatusId))
        {
            return false;
        }

        return IsSoftStatusFxId(status);
    }

    /// <summary>Egg hatch crumbs - common and steals between richer beats.</summary>
    public static bool IsHatchLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId)
            && string.Equals(c.HappinessEffectId, "just_got_out_of_egg", StringComparison.OrdinalIgnoreCase))
        {
            return true;
        }

        string asset = (c.AssetId ?? "").Trim().ToLowerInvariant();
        if (asset == "just_got_out_of_egg")
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.IndexOf("hatches from an egg", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// WorldLog politics meta crumbs (king death, city destroyed, favorite fell).
    /// Sticky and re-fire easily; outcomes stay in Chronicle.
    /// </summary>
    public static bool IsWorldLogMetaChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        bool worldLog = string.Equals(c.Source, "worldlog", StringComparison.OrdinalIgnoreCase)
                        || (!string.IsNullOrEmpty(c.Key)
                            && c.Key.StartsWith("worldlog:", StringComparison.OrdinalIgnoreCase));
        if (!worldLog && string.IsNullOrEmpty(c.AssetId))
        {
            return false;
        }

        if (IsWorldLogMetaAssetId(c.AssetId))
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.StartsWith("king died:", StringComparison.Ordinal)
               || label.StartsWith("king killed:", StringComparison.Ordinal)
               || label.StartsWith("favorite fell:", StringComparison.Ordinal)
               || label.StartsWith("city destroyed:", StringComparison.Ordinal);
    }

    /// <summary>
    /// Family + intimacy + settlement + kill + courtship + intent/construction/status/hatch/meta/rest.
    /// </summary>
    public static bool IsSoftLifeChapter(InterestCandidate c) =>
        IsFamilyLifeChapter(c)
        || IsIntimacyLifeChapter(c)
        || IsSettlementLifeChapter(c)
        || IsKillLifeChapter(c)
        || IsCourtshipLifeChapter(c)
        || IsLifeIntentDecisionChapter(c)
        || IsWorldLogMetaChapter(c)
        || IsConstructionChapter(c)
        || IsSoftStatusFxChapter(c)
        || IsHatchLifeChapter(c)
        || IsRestLifeChapter(c);

    /// <summary>
    /// Sleep / wake / dream cycle crumbs from live status + happiness inventory shape.
    /// One show cools the whole rest class so Falls asleep → ends a rest → dream cannot monopolize.
    /// </summary>
    public static bool IsRestLifeChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        if (IsRestLifeId(c.HappinessEffectId)
            || IsRestLifeId(c.StatusId)
            || IsRestLifeId(c.AssetId))
        {
            return true;
        }

        string label = (c.Label ?? "").Trim().ToLowerInvariant();
        return label.IndexOf("falls asleep", StringComparison.Ordinal) >= 0
               || label.IndexOf("wakes up", StringComparison.Ordinal) >= 0
               || label.IndexOf("ends a rest", StringComparison.Ordinal) >= 0
               || label.IndexOf("finishes sleeping", StringComparison.Ordinal) >= 0
               || label.IndexOf("dreams pleasantly", StringComparison.Ordinal) >= 0
               || label.IndexOf("good dream", StringComparison.Ordinal) >= 0
               || label.IndexOf("bad dream", StringComparison.Ordinal) >= 0
               || label.IndexOf("nightmare", StringComparison.Ordinal) >= 0
               || label.IndexOf("sleep without a house", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Rest-cycle ids: <c>sleeping</c>, <c>just_slept</c>, <c>had_*dream</c>, <c>had_nightmare</c>,
    /// <c>slept_outside</c> - token shape from live libraries, not tip strings alone.
    /// </summary>
    public static bool IsRestLifeId(string id)
    {
        if (string.IsNullOrEmpty(id))
        {
            return false;
        }

        string s = id.Trim().ToLowerInvariant();
        return s.IndexOf("sleep", StringComparison.Ordinal) >= 0
               || s.IndexOf("slept", StringComparison.Ordinal) >= 0
               || s.IndexOf("dream", StringComparison.Ordinal) >= 0
               || s.IndexOf("nightmare", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Death / destruction WorldLog ids from the live library shape
    /// (king_*, favorite_*, city_destroyed, …) - not crowning / founding.
    /// </summary>
    public static bool IsWorldLogMetaAssetId(string assetId)
    {
        if (string.IsNullOrEmpty(assetId))
        {
            return false;
        }

        string s = assetId.Trim().ToLowerInvariant();
        if (s.IndexOf("destroyed", StringComparison.Ordinal) >= 0)
        {
            return true;
        }

        bool deathLike = s.IndexOf("dead", StringComparison.Ordinal) >= 0
                         || s.IndexOf("killed", StringComparison.Ordinal) >= 0
                         || s.IndexOf("_fell", StringComparison.Ordinal) >= 0;
        if (!deathLike)
        {
            return false;
        }

        return s.IndexOf("king", StringComparison.Ordinal) >= 0
               || s.IndexOf("leader", StringComparison.Ordinal) >= 0
               || s.IndexOf("favorite", StringComparison.Ordinal) >= 0;
    }

    /// <summary>
    /// Soft-fill quiet crumbs: soft life chapters, short interrupt FX, and ambient Pack fill.
    /// Pack must not own the camera during quiet (and no longer breaks quiet).
    /// </summary>
    public static bool IsSoftFillQuietCrumb(InterestCandidate c) =>
        c != null
        && (c.Completion == InterestCompletionKind.FamilyPack
            || IsSoftLifeChapter(c)
            || IsShortInterruptFxChapter(c));

    /// <summary>
    /// Brief interrupt FX that should not own AFK during soft-fill quiet.
    /// Kept non-outbreak; real danger statuses stay hot.
    /// </summary>
    public static bool IsShortInterruptFxChapter(InterestCandidate c)
    {
        if (c == null)
        {
            return false;
        }

        string status = !string.IsNullOrEmpty(c.StatusId) ? c.StatusId : c.AssetId;
        if (string.IsNullOrEmpty(status))
        {
            return false;
        }

        if (c.Completion != InterestCompletionKind.StatusPhase
            && c.Completion != InterestCompletionKind.FixedDwell
            && string.IsNullOrEmpty(c.StatusId))
        {
            return false;
        }

        return IsShortInterruptFxId(status);
    }

    public static bool IsShortInterruptFxId(string statusId)
    {
        if (string.IsNullOrEmpty(statusId))
        {
            return false;
        }

        string s = statusId.Trim().ToLowerInvariant();
        return s.IndexOf("stun", StringComparison.Ordinal) >= 0
               || s.IndexOf("invincible", StringComparison.Ordinal) >= 0
               || s == "surprised"
               || s == "confused";
    }

    /// <summary>
    /// Soft personal status FX ids from the live status inventory shape:
    /// mood / life-cycle / brief FX. Danger and combat statuses stay hotter.
    /// </summary>
    public static bool IsSoftStatusFxId(string statusId)
    {
        if (string.IsNullOrEmpty(statusId))
        {
            return false;
        }

        // Short interrupt FX count as soft crumbs for quiet + variety cooling.
        if (IsShortInterruptFxId(statusId))
        {
            return true;
        }

        string s = statusId.Trim().ToLowerInvariant();
        // Danger / combat / possession stay camera-sticky for repeats.
        if (s.IndexOf("burn", StringComparison.Ordinal) >= 0
            || s.IndexOf("poison", StringComparison.Ordinal) >= 0
            || s.IndexOf("drown", StringComparison.Ordinal) >= 0
            || s.IndexOf("starv", StringComparison.Ordinal) >= 0
            || s.IndexOf("possess", StringComparison.Ordinal) >= 0
            || s.IndexOf("soul", StringComparison.Ordinal) >= 0
            || s.IndexOf("curse", StringComparison.Ordinal) >= 0
            || s.IndexOf("rage", StringComparison.Ordinal) >= 0
            || s.IndexOf("frozen", StringComparison.Ordinal) >= 0
            || s.IndexOf("shield", StringComparison.Ordinal) >= 0
            || s.IndexOf("combat", StringComparison.Ordinal) >= 0
            || s == "on_guard"
            || s == "angry"
            || s == "egg")
        {
            return false;
        }

        // Family / courtship / settlement already have dedicated soft chapters.
        if (IsFamilyLifeHappinessId(s) || IsCourtshipHappinessId(s) || IsSettlementHappinessId(s)
            || IsIntimacyHappinessId(s))
        {
            return false;
        }

        // Mood / life-cycle / brief FX tokens (covers unauthored live ids of the same shape).
        return s.IndexOf("sing", StringComparison.Ordinal) >= 0
               || s.IndexOf("laugh", StringComparison.Ordinal) >= 0
               || s.IndexOf("swear", StringComparison.Ordinal) >= 0
               || s.IndexOf("cry", StringComparison.Ordinal) >= 0
               || s.IndexOf("root", StringComparison.Ordinal) >= 0
               || s.IndexOf("budding", StringComparison.Ordinal) >= 0
               || s.IndexOf("dream", StringComparison.Ordinal) >= 0
               || s.IndexOf("nightmare", StringComparison.Ordinal) >= 0
               || s.IndexOf("festive", StringComparison.Ordinal) >= 0
               || s.IndexOf("afterglow", StringComparison.Ordinal) >= 0
               || s.IndexOf("surprised", StringComparison.Ordinal) >= 0
               || s.IndexOf("confused", StringComparison.Ordinal) >= 0
               || s.IndexOf("just_ate", StringComparison.Ordinal) >= 0
               || s.IndexOf("caffeine", StringComparison.Ordinal) >= 0
               || s.IndexOf("cough", StringComparison.Ordinal) >= 0
               || s.IndexOf("tantrum", StringComparison.Ordinal) >= 0
               || s.IndexOf("strange_urge", StringComparison.Ordinal) >= 0
               || s.IndexOf("voices", StringComparison.Ordinal) >= 0
               || s.IndexOf("handsome", StringComparison.Ordinal) >= 0
               || s.IndexOf("flick", StringComparison.Ordinal) >= 0
               || s.IndexOf("ash_fever", StringComparison.Ordinal) >= 0
               || s.IndexOf("motivated", StringComparison.Ordinal) >= 0
               || s.IndexOf("inspired", StringComparison.Ordinal) >= 0
               || s.IndexOf("enchant", StringComparison.Ordinal) >= 0
               || s.IndexOf("powerup", StringComparison.Ordinal) >= 0
               || s.IndexOf("slowness", StringComparison.Ordinal) >= 0
               || s.IndexOf("magnet", StringComparison.Ordinal) >= 0
               || s.IndexOf("dodge", StringComparison.Ordinal) >= 0
               || s.IndexOf("dash", StringComparison.Ordinal) >= 0
               || s.IndexOf("silence", StringComparison.Ordinal) >= 0
               || s.IndexOf("boost", StringComparison.Ordinal) >= 0
               || s.IndexOf("recovery_", StringComparison.Ordinal) >= 0;
    }

    private static bool IsFamilyLifeHappinessId(string happinessId)
    {
        if (string.IsNullOrEmpty(happinessId))
        {
            return false;
        }

        string h = happinessId.Trim().ToLowerInvariant();
        return h == "just_had_child"
               || h.IndexOf("pregnant", StringComparison.Ordinal) >= 0
               || h.IndexOf("newborn", StringComparison.Ordinal) >= 0
               || h.IndexOf("birth", StringComparison.Ordinal) >= 0
               || h.IndexOf("had_child", StringComparison.Ordinal) >= 0
               || h.IndexOf("had_baby", StringComparison.Ordinal) >= 0
               || h.IndexOf("parenthood", StringComparison.Ordinal) >= 0;
    }

    private static bool IsIntimacyHappinessId(string happinessId)
    {
        if (string.IsNullOrEmpty(happinessId))
        {
            return false;
        }

        string h = happinessId.Trim().ToLowerInvariant();
        return h == "just_kissed"
               || h.IndexOf("kissed", StringComparison.Ordinal) >= 0
               || h.IndexOf("intimacy", StringComparison.Ordinal) >= 0
               || h == "mates"
               || h.StartsWith("mate_", StringComparison.Ordinal);
    }

    private static bool IsSettlementHappinessId(string happinessId)
    {
        if (string.IsNullOrEmpty(happinessId))
        {
            return false;
        }

        string h = happinessId.Trim().ToLowerInvariant();
        return h == "just_found_house"
               || h.IndexOf("found_house", StringComparison.Ordinal) >= 0
               || h.IndexOf("find_house", StringComparison.Ordinal) >= 0
               || h.IndexOf("found_home", StringComparison.Ordinal) >= 0;
    }

    private static bool IsKillLifeHappinessId(string happinessId)
    {
        if (string.IsNullOrEmpty(happinessId))
        {
            return false;
        }

        string h = happinessId.Trim().ToLowerInvariant();
        return h == "just_killed"
               || h == "milestone_kill"
               || h.IndexOf("just_killed", StringComparison.Ordinal) >= 0;
    }

    private static bool IsKillLifeAssetId(string assetId)
    {
        if (string.IsNullOrEmpty(assetId))
        {
            return false;
        }

        string a = assetId.Trim().ToLowerInvariant();
        return a == "milestone_kill"
               || a == "just_killed";
    }

    private static bool IsCourtshipHappinessId(string happinessId)
    {
        if (string.IsNullOrEmpty(happinessId))
        {
            return false;
        }

        string h = happinessId.Trim().ToLowerInvariant();
        // Bond outcomes (set_lover / milestone_lover) stay hotter; cool intent + smitten only.
        return h == "fallen_in_love"
               || h == "find_lover"
               || h == "fell_in_love"
               || h.IndexOf("fallen_in_love", StringComparison.Ordinal) >= 0
               || h.IndexOf("find_lover", StringComparison.Ordinal) >= 0;
    }

    private static bool IsCourtshipAssetId(string assetId)
    {
        if (string.IsNullOrEmpty(assetId))
        {
            return false;
        }

        string a = assetId.Trim().ToLowerInvariant();
        return a == "fallen_in_love"
               || a == "find_lover"
               || a == "fell_in_love";
    }

    private static IEnumerable<string> EnumerateBeatKeys(InterestCandidate c)
    {
        if (c == null)
        {
            yield break;
        }

        long subject = c.SubjectId;
        long related = c.RelatedId != 0
            ? c.RelatedId
            : EventFeedUtil.SafeId(c.RelatedUnit);
        if (!string.IsNullOrEmpty(c.HappinessEffectId))
        {
            yield return "beat:hap:" + c.HappinessEffectId + ":" + subject;
            // Family chapters cool the happiness id world-wide so parent A then parent B
            // cannot chain the same parenthood tip across the village cast.
            if (IsFamilyLifeHappinessId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:life:family:" + subject;
            }

            // Intimacy: cool the pair and the happiness id world-wide so one couple
            // cannot keep cutting back in between combat tips.
            if (IsIntimacyHappinessId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:life:intimacy:" + subject;
                if (related != 0)
                {
                    yield return "beat:life:intimacy:" + related;
                    yield return "beat:life:intimacy:pair:"
                                 + EventCatalog.Combat.PairKey(subject, related);
                }
            }

            if (IsSettlementHappinessId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:life:home:" + subject;
            }

            if (IsKillLifeHappinessId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:life:kill:" + subject;
                yield return "beat:life:kill:world";
            }

            if (IsCourtshipHappinessId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:life:love:" + subject;
                yield return "beat:life:love:world";
                if (related != 0)
                {
                    yield return "beat:life:love:" + related;
                    yield return "beat:life:love:pair:"
                                 + EventCatalog.Combat.PairKey(subject, related);
                }
            }

            if (string.Equals(
                    c.HappinessEffectId,
                    "just_got_out_of_egg",
                    StringComparison.OrdinalIgnoreCase))
            {
                yield return "beat:hap:just_got_out_of_egg:world";
                yield return "beat:life:hatch:" + subject;
                yield return "beat:life:hatch:world";
            }

            if (IsRestLifeId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:life:rest:" + subject;
                yield return "beat:life:rest:world";
            }

            // Happiness-path soft FX (dreams without StatusId bind) still cool as a class.
            if (IsSoftStatusFxId(c.HappinessEffectId) && !IsRestLifeId(c.HappinessEffectId))
            {
                yield return "beat:hap:" + c.HappinessEffectId + ":world";
                yield return "beat:status:fx:" + subject;
                yield return "beat:status:fx:world";
            }
        }

        if (!string.IsNullOrEmpty(c.StatusId))
        {
            yield return "beat:status:" + c.StatusId + ":" + subject;
            if (IsFamilyLifeHappinessId(c.StatusId))
            {
                yield return "beat:status:" + c.StatusId + ":world";
            }

            if (IsIntimacyHappinessId(c.StatusId))
            {
                yield return "beat:status:" + c.StatusId + ":world";
                yield return "beat:life:intimacy:" + subject;
            }

            if (IsCourtshipHappinessId(c.StatusId))
            {
                yield return "beat:status:" + c.StatusId + ":world";
                yield return "beat:life:love:" + subject;
                yield return "beat:life:love:world";
            }

            if (IsRestLifeId(c.StatusId))
            {
                yield return "beat:status:" + c.StatusId + ":world";
                yield return "beat:life:rest:" + subject;
                yield return "beat:life:rest:world";
            }

            if (IsSoftStatusFxId(c.StatusId) && !IsRestLifeId(c.StatusId))
            {
                yield return "beat:status:" + c.StatusId + ":world";
                yield return "beat:status:fx:" + subject;
                yield return "beat:status:fx:world";
            }
        }

        // Discrete catalog asset ids (not species / not sticky live_* frames).
        string asset = c.AssetId ?? "";
        if (!string.IsNullOrEmpty(asset)
            && !asset.StartsWith("live_", StringComparison.OrdinalIgnoreCase)
            && !string.Equals(asset, c.SpeciesId, StringComparison.OrdinalIgnoreCase)
            && !string.Equals(asset, "scored_unit", StringComparison.OrdinalIgnoreCase)
            && !string.Equals(asset, "harness", StringComparison.OrdinalIgnoreCase))
        {
            yield return "beat:asset:" + asset + ":" + subject;
            if (IsKillLifeAssetId(asset))
            {
                yield return "beat:asset:" + asset + ":world";
                yield return "beat:life:kill:" + subject;
                yield return "beat:life:kill:world";
            }

            if (IsCourtshipAssetId(asset))
            {
                yield return "beat:asset:" + asset + ":world";
                yield return "beat:life:love:" + subject;
                yield return "beat:life:love:world";
            }

            // The relationship feed reports the concrete birth first ("gains a child");
            // happiness can report the same parent's reaction a frame later. They are one
            // family chapter, so showing the fact suppresses that immediate emotional echo
            // without cooling unrelated parents or later births world-wide.
            if (string.Equals(asset, "add_child", StringComparison.OrdinalIgnoreCase))
            {
                yield return "beat:life:family:" + subject;
            }

            if (EventCatalog.Decision.IsLifeIntentDecision(asset))
            {
                yield return "beat:asset:" + asset + ":world";
                yield return "beat:decision:intent:" + subject;
                yield return "beat:decision:intent:world";
            }

            if (IsRestLifeId(asset))
            {
                yield return "beat:asset:" + asset + ":world";
                yield return "beat:life:rest:" + subject;
                yield return "beat:life:rest:world";
            }

            if (IsWorldLogMetaAssetId(asset))
            {
                yield return "beat:asset:" + asset + ":world";
                yield return "beat:worldlog:meta:" + subject;
                yield return "beat:worldlog:meta:world";
            }

            if (string.Equals(asset, "just_got_out_of_egg", StringComparison.OrdinalIgnoreCase))
            {
                yield return "beat:asset:" + asset + ":world";
                yield return "beat:life:hatch:" + subject;
                yield return "beat:life:hatch:world";
            }
        }

        // Chapter-level world keys (ungated): survive species AssetId / missing StatusId / label rebuilds.
        if (IsLifeIntentDecisionChapter(c))
        {
            yield return "beat:decision:intent:" + subject;
            yield return "beat:decision:intent:world";
        }

        if (IsRestLifeChapter(c))
        {
            yield return "beat:life:rest:" + subject;
            yield return "beat:life:rest:world";
        }

        if (IsConstructionChapter(c))
        {
            yield return "beat:construction:" + subject;
            yield return "beat:construction:world";
        }

        if (IsWorldLogMetaChapter(c) && string.IsNullOrEmpty(asset))
        {
            yield return "beat:worldlog:meta:" + subject;
            yield return "beat:worldlog:meta:world";
        }

        string labelNorm = NormalizeBeatLabel(c.Label);
        if (!string.IsNullOrEmpty(labelNorm))
        {
            yield return "beat:label:" + labelNorm + ":" + subject;
            // Label-only soft chapters (missing HappinessEffectId) still cool as a class.
            if (string.IsNullOrEmpty(c.HappinessEffectId))
            {
                if (IsIntimacyLifeChapter(c)
                    && (labelNorm.IndexOf("intimacy", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("mates with", StringComparison.Ordinal) >= 0))
                {
                    yield return "beat:life:intimacy:" + subject;
                    yield return "beat:life:intimacy:world";
                    if (related != 0)
                    {
                        yield return "beat:life:intimacy:pair:"
                                     + EventCatalog.Combat.PairKey(subject, related);
                    }
                }

                if (IsSettlementLifeChapter(c)
                    && (labelNorm.IndexOf("finds a home", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("settles into", StringComparison.Ordinal) >= 0))
                {
                    yield return "beat:life:home:" + subject;
                    yield return "beat:life:home:world";
                }

                if (IsKillLifeChapter(c)
                    && labelNorm.StartsWith("killed ", StringComparison.Ordinal))
                {
                    yield return "beat:life:kill:" + subject;
                    yield return "beat:life:kill:world";
                }

                if (IsCourtshipLifeChapter(c)
                    && (labelNorm.IndexOf("smitten", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("falls in love", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("seeking a lover", StringComparison.Ordinal) >= 0))
                {
                    yield return "beat:life:love:" + subject;
                    yield return "beat:life:love:world";
                    if (related != 0)
                    {
                        yield return "beat:life:love:pair:"
                                     + EventCatalog.Combat.PairKey(subject, related);
                    }
                }

                if (IsHatchLifeChapter(c)
                    && labelNorm.IndexOf("hatches", StringComparison.Ordinal) >= 0)
                {
                    yield return "beat:life:hatch:" + subject;
                    yield return "beat:life:hatch:world";
                }

                if (IsWorldLogMetaChapter(c))
                {
                    yield return "beat:worldlog:meta:" + subject;
                    yield return "beat:worldlog:meta:world";
                }

                if (IsRestLifeChapter(c)
                    && (labelNorm.IndexOf("asleep", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("rest", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("dream", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("nightmare", StringComparison.Ordinal) >= 0
                        || labelNorm.IndexOf("sleep", StringComparison.Ordinal) >= 0))
                {
                    yield return "beat:life:rest:" + subject;
                    yield return "beat:life:rest:world";
                }
            }
        }
    }

    private static string NormalizeBeatLabel(string label)
    {
        if (string.IsNullOrEmpty(label))
        {
            return "";
        }

        string t = label.Trim().ToLowerInvariant();
        // Drop leading proper name so "Ukalo feels the joy…" and rebuilds share a beat.
        int space = t.IndexOf(' ');
        if (space > 0 && space < t.Length - 1)
        {
            string rest = t.Substring(space + 1).Trim();
            if (rest.StartsWith("feels ", StringComparison.Ordinal)
                || rest.StartsWith("has ", StringComparison.Ordinal)
                || rest.StartsWith("is ", StringComparison.Ordinal)
                || rest.StartsWith("becomes ", StringComparison.Ordinal)
                || rest.StartsWith("gains ", StringComparison.Ordinal)
                || rest.StartsWith("decides ", StringComparison.Ordinal)
                || rest.StartsWith("shares ", StringComparison.Ordinal)
                || rest.StartsWith("mates ", StringComparison.Ordinal)
                || rest.StartsWith("mourns ", StringComparison.Ordinal))
            {
                t = rest;
            }
        }

        return t.Length > 64 ? t.Substring(0, 64) : t;
    }

    private static string BeatDropDetail(InterestCandidate c)
    {
        if (c == null)
        {
            return "beat";
        }

        if (!string.IsNullOrEmpty(c.HappinessEffectId))
        {
            return c.HappinessEffectId;
        }

        if (!string.IsNullOrEmpty(c.StatusId))
        {
            return c.StatusId;
        }

        return c.AssetId ?? c.Key ?? "beat";
    }

    private static float NoveltyPenalty(InterestCandidate c, float now)
    {
        float p = 0f;
        p += CooldownWeight("unit:" + c.SubjectId, now, 0.55f);
        if (!string.IsNullOrEmpty(c.SpeciesId))
        {
            p += CooldownWeight("species:" + c.SpeciesId, now, 0.25f);
        }

        if (!string.IsNullOrEmpty(c.Category))
        {
            p += CooldownWeight("cat:" + c.Category, now, 0.2f);
        }

        if (!string.IsNullOrEmpty(c.CityKey))
        {
            p += CooldownWeight("city:" + c.CityKey, now, 0.2f);
        }

        if (!string.IsNullOrEmpty(c.KingdomKey))
        {
            p += CooldownWeight("kingdom:" + c.KingdomKey, now, 0.2f);
        }

        if (!string.IsNullOrEmpty(c.Verb))
        {
            p += CooldownWeight("verb:" + c.Verb, now, 0.15f);
        }

        return Mathf.Clamp01(p);
    }

    private static float CooldownWeight(string key, float now, float weight)
    {
        if (!CooldownUntil.TryGetValue(key, out float until) || now >= until)
        {
            return 0f;
        }

        float remain = until - now;
        float frac = Mathf.Clamp01(remain / HardCooldownSeconds);
        return weight * frac;
    }

    private static void StampCooldown(string key, float until)
    {
        if (string.IsNullOrEmpty(key))
        {
            return;
        }

        if (CooldownUntil.TryGetValue(key, out float existing))
        {
            CooldownUntil[key] = Mathf.Max(existing, until);
        }
        else
        {
            CooldownUntil[key] = until;
        }
    }
}