"""Deterministic CS Major autochess rules for the reviewed local service."""

from __future__ import annotations

import hashlib
import json
import re
from importlib import resources
from typing import Any


DATA_FILES = ("rules.json", "players.json", "coaches.json", "narratives.json")
DATA_ROOT = "data/cs_autochess"
MIN_NARRATIVE_FRAGMENTS = 120
MULTI_REPLY_MARKER = "\x1eJWEBOT_MULTI_REPLY_V1\x1e"


def _load_json_file(filename: str) -> dict[str, Any]:
    if filename not in DATA_FILES:
        raise ValueError(f"unknown CS autochess data file: {filename}")
    path = resources.files(__package__).joinpath(DATA_ROOT, filename)
    with path.open("r", encoding="utf-8") as handle:
        payload = json.load(handle)
    if not isinstance(payload, dict):
        raise ValueError(f"{filename} must contain a JSON object")
    if int(payload.get("schema_version", 0)) != 1:
        raise ValueError(f"{filename} has unsupported schema_version")
    return payload


def _mapping(value: Any, context: str) -> dict[str, Any]:
    if not isinstance(value, dict):
        raise ValueError(f"{context} must be an object")
    return dict(value)


def _sequence(value: Any, context: str) -> list[Any]:
    if not isinstance(value, list):
        raise ValueError(f"{context} must be a list")
    return list(value)


def _text(value: Any, context: str) -> str:
    result = str(value).strip()
    if not result:
        raise ValueError(f"{context} must be a non-empty string")
    return result


def _int_value(value: Any, context: str) -> int:
    if isinstance(value, bool):
        raise ValueError(f"{context} must be an integer")
    try:
        return int(value)
    except (TypeError, ValueError) as exc:
        raise ValueError(f"{context} must be an integer") from exc


def _float_value(value: Any, context: str) -> float:
    if isinstance(value, bool):
        raise ValueError(f"{context} must be a number")
    try:
        return float(value)
    except (TypeError, ValueError) as exc:
        raise ValueError(f"{context} must be a number") from exc


def _int_key_int_dict(value: Any, context: str) -> dict[int, int]:
    return {
        _int_value(key, f"{context}.key"): _int_value(item, f"{context}.{key}")
        for key, item in _mapping(value, context).items()
    }


def _str_key_int_dict(value: Any, context: str) -> dict[str, int]:
    return {
        _text(key, f"{context}.key"): _int_value(item, f"{context}.{key}")
        for key, item in _mapping(value, context).items()
    }


def _section(rules: dict[str, Any], key: str) -> dict[str, Any]:
    if key not in rules:
        raise ValueError(f"rules.json missing {key}")
    return _mapping(rules[key], f"rules.{key}")


def _load_rules() -> dict[str, Any]:
    rules = _load_json_file("rules.json")
    for key in (
        "tournament",
        "ai",
        "roster",
        "economy",
        "coach",
        "shop",
        "draft",
        "tactics",
        "battle",
        "pve_events",
        "special_events",
    ):
        _section(rules, key)
    return rules


def _load_player_pool() -> tuple[dict[str, Any], ...]:
    payload = _load_json_file("players.json")
    players = _sequence(payload.get("players"), "players.players")
    required = {
        "id",
        "name",
        "cost",
        "role",
        "nation",
        "team",
        "teams",
        "firepower",
        "stability",
        "clutch",
        "leadership",
    }
    seen: set[str] = set()
    normalized: list[dict[str, Any]] = []
    for index, raw_item in enumerate(players, start=1):
        item = _mapping(raw_item, f"players[{index}]")
        missing = sorted(required - item.keys())
        if missing:
            raise ValueError(f"players[{index}] missing {', '.join(missing)}")
        card_id = _text(item["id"], f"players[{index}].id")
        if card_id in seen:
            raise ValueError(f"duplicate player id: {card_id}")
        seen.add(card_id)
        team = _text(item["team"], f"players[{index}].team")
        teams = [
            _text(team_name, f"players[{index}].teams")
            for team_name in _sequence(item["teams"], f"players[{index}].teams")
        ]
        if team not in teams:
            teams.insert(0, team)
        teams = [team, *[team_name for team_name in teams if team_name != team]][:3]
        cost = _int_value(item["cost"], f"players[{index}].cost")
        if not 1 <= cost <= 5:
            raise ValueError(f"players[{index}].cost must be 1..5")
        normalized.append(
            {
                "id": card_id,
                "name": _text(item["name"], f"players[{index}].name"),
                "cost": cost,
                "role": _text(item["role"], f"players[{index}].role"),
                "nation": _text(item["nation"], f"players[{index}].nation"),
                "team": team,
                "teams": teams,
                "firepower": _int_value(item["firepower"], f"players[{index}].firepower"),
                "stability": _int_value(item["stability"], f"players[{index}].stability"),
                "clutch": _int_value(item["clutch"], f"players[{index}].clutch"),
                "leadership": _int_value(item["leadership"], f"players[{index}].leadership"),
            }
        )
    if len(normalized) < 100:
        raise ValueError("CS autochess player pool must contain at least 100 cards")
    return tuple(normalized)


def _load_coach_pool() -> tuple[dict[str, Any], ...]:
    payload = _load_json_file("coaches.json")
    coaches = _sequence(payload.get("coaches"), "coaches.coaches")
    required = {"id", "name", "level", "style", "firepower", "stability", "clutch", "bonus"}
    seen: set[str] = set()
    normalized: list[dict[str, Any]] = []
    for index, raw_item in enumerate(coaches, start=1):
        item = _mapping(raw_item, f"coaches[{index}]")
        missing = sorted(required - item.keys())
        if missing:
            raise ValueError(f"coaches[{index}] missing {', '.join(missing)}")
        coach_id = _text(item["id"], f"coaches[{index}].id")
        if coach_id in seen:
            raise ValueError(f"duplicate coach id: {coach_id}")
        seen.add(coach_id)
        normalized.append(
            {
                "id": coach_id,
                "name": _text(item["name"], f"coaches[{index}].name"),
                "level": _int_value(item["level"], f"coaches[{index}].level"),
                "style": _text(item["style"], f"coaches[{index}].style"),
                "firepower": _int_value(item["firepower"], f"coaches[{index}].firepower"),
                "stability": _int_value(item["stability"], f"coaches[{index}].stability"),
                "clutch": _int_value(item["clutch"], f"coaches[{index}].clutch"),
                "bonus": _int_value(item["bonus"], f"coaches[{index}].bonus"),
            }
        )
    if len(normalized) < 10:
        raise ValueError("CS autochess coach pool must contain at least 10 coaches")
    return tuple(normalized)


def _load_narratives() -> dict[str, tuple[str, ...]]:
    payload = _load_json_file("narratives.json")
    fragments = _mapping(payload.get("fragments"), "narratives.fragments")
    normalized: dict[str, tuple[str, ...]] = {}
    for category, raw_items in fragments.items():
        key = _text(category, "narratives category")
        items = tuple(
            _text(item, f"narratives.{key}")
            for item in _sequence(raw_items, f"narratives.{key}")
        )
        if not items:
            raise ValueError(f"narratives.{key} must not be empty")
        normalized[key] = items
    total = sum(len(items) for items in normalized.values())
    if total < MIN_NARRATIVE_FRAGMENTS:
        raise ValueError(
            f"CS autochess needs at least {MIN_NARRATIVE_FRAGMENTS} narrative fragments"
        )
    return normalized


def _synergy_rule(value: Any, context: str) -> dict[str, Any]:
    raw = _mapping(value, context)
    thresholds = []
    for index, item in enumerate(_sequence(raw.get("thresholds"), f"{context}.thresholds"), start=1):
        rule = _mapping(item, f"{context}.thresholds[{index}]")
        thresholds.append(
            {
                "min_count": _int_value(rule.get("min_count"), f"{context}.thresholds[{index}].min_count"),
                "bonus": _int_value(rule.get("bonus"), f"{context}.thresholds[{index}].bonus"),
            }
        )
    thresholds.sort(key=lambda item: int(item["min_count"]), reverse=True)
    return {
        "max_sources": _int_value(raw.get("max_sources"), f"{context}.max_sources"),
        "thresholds": thresholds,
    }


_RULES = _load_rules()
_TOURNAMENT_RULES = _section(_RULES, "tournament")
_AI_RULES = _section(_RULES, "ai")
_ROSTER_RULES = _section(_RULES, "roster")
_ECONOMY_RULES = _section(_RULES, "economy")
_COACH_RULES = _section(_RULES, "coach")
_SHOP_RULES = _section(_RULES, "shop")
_DRAFT_RULES = _section(_RULES, "draft")
_TACTIC_RULES = _section(_RULES, "tactics")
_BATTLE_RULES = _section(_RULES, "battle")

MIN_PLAYERS = _int_value(_TOURNAMENT_RULES.get("min_players"), "rules.tournament.min_players")
MAX_PLAYERS = _int_value(_TOURNAMENT_RULES.get("max_players"), "rules.tournament.max_players")
HOST_NAME = _text(_TOURNAMENT_RULES.get("host_name"), "rules.tournament.host_name")
EVENT_TITLE_TEMPLATE = _text(
    _TOURNAMENT_RULES.get("event_title_template"),
    "rules.tournament.event_title_template",
)
AI_PERSON_KEY = _text(_AI_RULES.get("primary_person_key"), "rules.ai.primary_person_key")
AI_DISPLAY_NAME = _text(_AI_RULES.get("primary_display_name"), "rules.ai.primary_display_name")
AI_SECOND_PERSON_KEY = _text(_AI_RULES.get("secondary_person_key"), "rules.ai.secondary_person_key")
AI_SECOND_DISPLAY_NAME = _text(_AI_RULES.get("secondary_display_name"), "rules.ai.secondary_display_name")
AI_POWER_MULTIPLIER = _float_value(_AI_RULES.get("power_multiplier"), "rules.ai.power_multiplier")

STARTING_GOLD = _int_value(_ECONOMY_RULES.get("starting_gold"), "rules.economy.starting_gold")
STARTING_HP = _int_value(_ECONOMY_RULES.get("starting_hp"), "rules.economy.starting_hp")
_ROUND_INCOME_RULES = _mapping(_ECONOMY_RULES.get("round_income"), "rules.economy.round_income")
ROUND_INCOME_BASE = _int_value(_ROUND_INCOME_RULES.get("base"), "rules.economy.round_income.base")
ROUND_INTEREST_DIVISOR = _int_value(_ROUND_INCOME_RULES.get("interest_divisor"), "rules.economy.round_income.interest_divisor")
ROUND_INTEREST_CAP = _int_value(_ROUND_INCOME_RULES.get("interest_cap"), "rules.economy.round_income.interest_cap")
_TRAINING_REWARDS = _mapping(_ECONOMY_RULES.get("training_rewards"), "rules.economy.training_rewards")
TRAINING_WIN_GOLD = _int_value(_TRAINING_REWARDS.get("win_gold"), "rules.economy.training_rewards.win_gold")
TRAINING_LOSS_GOLD = _int_value(_TRAINING_REWARDS.get("loss_gold"), "rules.economy.training_rewards.loss_gold")
TRAINING_BYE_GOLD = _int_value(_TRAINING_REWARDS.get("bye_gold"), "rules.economy.training_rewards.bye_gold")
_SERIES_REWARDS = _mapping(_ECONOMY_RULES.get("series_rewards"), "rules.economy.series_rewards")
GROUP_SERIES_WIN_GOLD = _int_value(_SERIES_REWARDS.get("group_win_gold"), "rules.economy.series_rewards.group_win_gold")
PLAYOFF_SERIES_WIN_GOLD = _int_value(_SERIES_REWARDS.get("playoff_win_gold"), "rules.economy.series_rewards.playoff_win_gold")

STARTER_COUNT = _int_value(_ROSTER_RULES.get("starter_count"), "rules.roster.starter_count")
BENCH_LIMIT = _int_value(_ROSTER_RULES.get("bench_limit"), "rules.roster.bench_limit")
STAR_MULTIPLIERS = {
    _int_value(star, "rules.roster.star_multipliers.key"): _float_value(multiplier, f"rules.roster.star_multipliers.{star}")
    for star, multiplier in _mapping(_ROSTER_RULES.get("star_multipliers"), "rules.roster.star_multipliers").items()
}
POWER_WEIGHTS = _mapping(_ROSTER_RULES.get("unit_power_weights"), "rules.roster.unit_power_weights")
POWER_FIREPOWER_WEIGHT = _float_value(POWER_WEIGHTS.get("firepower"), "rules.roster.unit_power_weights.firepower")
POWER_STABILITY_WEIGHT = _float_value(POWER_WEIGHTS.get("stability"), "rules.roster.unit_power_weights.stability")
POWER_CLUTCH_WEIGHT = _float_value(POWER_WEIGHTS.get("clutch"), "rules.roster.unit_power_weights.clutch")
POWER_LEADERSHIP_THRESHOLD = _int_value(POWER_WEIGHTS.get("leadership_threshold"), "rules.roster.unit_power_weights.leadership_threshold")
POWER_LEADERSHIP_SCALE = _float_value(POWER_WEIGHTS.get("leadership_scale"), "rules.roster.unit_power_weights.leadership_scale")
TEAM_SYNERGY_RULE = _synergy_rule(_ROSTER_RULES.get("team_synergy"), "rules.roster.team_synergy")
NATION_SYNERGY_RULE = _synergy_rule(_ROSTER_RULES.get("nation_synergy"), "rules.roster.nation_synergy")

COACH_UPGRADE_COSTS = _int_key_int_dict(_COACH_RULES.get("upgrade_costs"), "rules.coach.upgrade_costs")
COACH_BONUSES = _int_key_int_dict(_COACH_RULES.get("fallback_bonuses"), "rules.coach.fallback_bonuses")

SHOP_SIZE = _int_value(_SHOP_RULES.get("size"), "rules.shop.size")
REFRESH_COST = _int_value(_SHOP_RULES.get("refresh_cost"), "rules.shop.refresh_cost")
COST_POOL_COPIES = _int_key_int_dict(_SHOP_RULES.get("cost_pool_copies"), "rules.shop.cost_pool_copies")
SHOP_ODDS = {
    _int_value(tier, "rules.shop.odds.tier"): _int_key_int_dict(costs, f"rules.shop.odds.{tier}")
    for tier, costs in _mapping(_SHOP_RULES.get("odds"), "rules.shop.odds").items()
}

DRAFT_ROUNDS = _int_value(_DRAFT_RULES.get("rounds"), "rules.draft.rounds")
DRAFT_COACH_ROUND = _int_value(_DRAFT_RULES.get("coach_round"), "rules.draft.coach_round")
DRAFT_COACH_CHOICE_COUNT = _int_value(_DRAFT_RULES.get("coach_choice_count"), "rules.draft.coach_choice_count")
DRAFT_PLAYER_CHOICE_COUNT = _int_value(_DRAFT_RULES.get("player_choice_count"), "rules.draft.player_choice_count")
DRAFT_PLAYER_COPY_COUNT = _int_value(_DRAFT_RULES.get("player_copy_count"), "rules.draft.player_copy_count")
DRAFT_ROUND_TWO_PREFERRED_COSTS = tuple(
    _int_value(item, "rules.draft.round_two_preferred_costs")
    for item in _sequence(_DRAFT_RULES.get("round_two_preferred_costs"), "rules.draft.round_two_preferred_costs")
)
DRAFT_LATER_ROUND_PREFERRED_COSTS = tuple(
    _int_value(item, "rules.draft.later_round_preferred_costs")
    for item in _sequence(_DRAFT_RULES.get("later_round_preferred_costs"), "rules.draft.later_round_preferred_costs")
)

TACTICS = tuple(
    _text(item, "rules.tactics.names")
    for item in _sequence(_TACTIC_RULES.get("names"), "rules.tactics.names")
)
TACTIC_COUNTERS = {
    _text(key, "rules.tactics.counters.key"): _text(value, f"rules.tactics.counters.{key}")
    for key, value in _mapping(_TACTIC_RULES.get("counters"), "rules.tactics.counters").items()
}
ATTRIBUTE_COUNTERS = tuple(
    (
        _text(pair[0], "rules.tactics.attribute_counters.strong"),
        _text(pair[1], "rules.tactics.attribute_counters.weak"),
    )
    for pair in _sequence(_TACTIC_RULES.get("attribute_counters"), "rules.tactics.attribute_counters")
)
ROLE_COUNTERS = {
    _text(key, "rules.tactics.role_counters.key"): _text(value, f"rules.tactics.role_counters.{key}")
    for key, value in _mapping(_TACTIC_RULES.get("role_counters"), "rules.tactics.role_counters").items()
}
TACTIC_AXIS_MULTIPLIER = _float_value(_TACTIC_RULES.get("selected_axis_multiplier"), "rules.tactics.selected_axis_multiplier")
TACTIC_AXIS_PERCENT_DIVISOR = _float_value(_TACTIC_RULES.get("axis_percent_divisor"), "rules.tactics.axis_percent_divisor")
TACTIC_AXIS_PERCENT_CAP = _float_value(_TACTIC_RULES.get("axis_percent_cap"), "rules.tactics.axis_percent_cap")
TACTIC_ROLE_PERCENT_SCALE = _float_value(_TACTIC_RULES.get("role_percent_scale"), "rules.tactics.role_percent_scale")
TACTIC_ROLE_PERCENT_CAP = _float_value(_TACTIC_RULES.get("role_percent_cap"), "rules.tactics.role_percent_cap")
TACTIC_COUNTER_PERCENT = _float_value(_TACTIC_RULES.get("tactic_counter_percent"), "rules.tactics.tactic_counter_percent")
TACTIC_TOTAL_PERCENT_CAP = _float_value(_TACTIC_RULES.get("total_percent_cap"), "rules.tactics.total_percent_cap")

MAP_POOL = tuple(
    _text(item, "rules.battle.maps")
    for item in _sequence(_BATTLE_RULES.get("maps"), "rules.battle.maps")
)
_BATTLE_DAMAGE = _mapping(_BATTLE_RULES.get("damage"), "rules.battle.damage")
BATTLE_BO5_SWEEP_DAMAGE = _int_value(_BATTLE_DAMAGE.get("bo5_sweep"), "rules.battle.damage.bo5_sweep")
BATTLE_SWEEP_DAMAGE = _int_value(_BATTLE_DAMAGE.get("sweep"), "rules.battle.damage.sweep")
BATTLE_NON_SWEEP_DAMAGE = _int_value(_BATTLE_DAMAGE.get("non_sweep"), "rules.battle.damage.non_sweep")
BATTLE_MR_ROUNDS = _int_value(_BATTLE_RULES.get("mr_rounds"), "rules.battle.mr_rounds")
BATTLE_TARGET_SCORE = _int_value(_BATTLE_RULES.get("target_score"), "rules.battle.target_score")
BATTLE_OVERTIME_START_SCORE = _int_value(_BATTLE_RULES.get("overtime_start_score"), "rules.battle.overtime_start_score")
BATTLE_OVERTIME_TARGET_SCORE = _int_value(_BATTLE_RULES.get("overtime_target_score"), "rules.battle.overtime_target_score")
BATTLE_OVERTIME_WIN_BY = _int_value(_BATTLE_RULES.get("overtime_win_by"), "rules.battle.overtime_win_by")
BATTLE_OVERTIME_SAFETY_CAP = _int_value(_BATTLE_RULES.get("overtime_safety_cap", 72), "rules.battle.overtime_safety_cap")
BATTLE_OVERTIME_SEGMENT_ROUNDS = _int_value(_BATTLE_RULES.get("overtime_segment_rounds"), "rules.battle.overtime_segment_rounds")
MATCH_BEST_OF = _str_key_int_dict(_BATTLE_RULES.get("match_best_of"), "rules.battle.match_best_of")
_ROUND_PROBABILITY_RULES = _mapping(_BATTLE_RULES.get("round_probability"), "rules.battle.round_probability")
ROUND_PROBABILITY_BASE = _float_value(_ROUND_PROBABILITY_RULES.get("base"), "rules.battle.round_probability.base")
ROUND_PROBABILITY_MIN = _float_value(_ROUND_PROBABILITY_RULES.get("min"), "rules.battle.round_probability.min")
ROUND_PROBABILITY_MAX = _float_value(_ROUND_PROBABILITY_RULES.get("max"), "rules.battle.round_probability.max")
ROUND_POWER_EDGE_CAP = _float_value(_ROUND_PROBABILITY_RULES.get("power_edge_cap"), "rules.battle.round_probability.power_edge_cap")
ROUND_POWER_EDGE_SCALE = _float_value(_ROUND_PROBABILITY_RULES.get("power_edge_scale"), "rules.battle.round_probability.power_edge_scale")
ROUND_PRESSURE_CAP = _float_value(_ROUND_PROBABILITY_RULES.get("pressure_cap"), "rules.battle.round_probability.pressure_cap")
ROUND_PRESSURE_SCALE = _float_value(_ROUND_PROBABILITY_RULES.get("pressure_scale"), "rules.battle.round_probability.pressure_scale")
ROUND_FIRST_HALF_SIDE_SWING = _float_value(_ROUND_PROBABILITY_RULES.get("first_half_side_swing"), "rules.battle.round_probability.first_half_side_swing")
ROUND_SECOND_HALF_SIDE_SWING = _float_value(_ROUND_PROBABILITY_RULES.get("second_half_side_swing"), "rules.battle.round_probability.second_half_side_swing")
ROUND_JITTER_MOD = _int_value(_ROUND_PROBABILITY_RULES.get("jitter_mod"), "rules.battle.round_probability.jitter_mod")
ROUND_JITTER_CENTER = _int_value(_ROUND_PROBABILITY_RULES.get("jitter_center"), "rules.battle.round_probability.jitter_center")
ROUND_JITTER_DIVISOR = _float_value(_ROUND_PROBABILITY_RULES.get("jitter_divisor"), "rules.battle.round_probability.jitter_divisor")
SCORE_BANDS = tuple(
    {
        "max_loser_score": _int_value(item.get("max_loser_score"), "rules.battle.score_bands.max_loser_score"),
        "label": _text(item.get("label"), "rules.battle.score_bands.label"),
    }
    for item in (
        _mapping(raw_item, "rules.battle.score_bands.item")
        for raw_item in _sequence(_BATTLE_RULES.get("score_bands"), "rules.battle.score_bands")
    )
)

PVE_EVENTS = {
    key: (
        _text(item.get("name"), f"rules.pve_events.{key}.name"),
        _int_value(item.get("target"), f"rules.pve_events.{key}.target"),
        _int_value(item.get("win_gold"), f"rules.pve_events.{key}.win_gold"),
        _int_value(item.get("loss_gold"), f"rules.pve_events.{key}.loss_gold"),
    )
    for key, item in (
        (str(name), _mapping(value, f"rules.pve_events.{name}"))
        for name, value in _section(_RULES, "pve_events").items()
    )
}
SPECIAL_EVENTS = {
    key: (
        _text(item.get("name"), f"rules.special_events.{key}.name"),
        _int_value(item.get("target"), f"rules.special_events.{key}.target"),
        _int_value(item.get("win_gold"), f"rules.special_events.{key}.win_gold"),
        _int_value(item.get("loss_gold"), f"rules.special_events.{key}.loss_gold"),
    )
    for key, item in (
        (str(name), _mapping(value, f"rules.special_events.{name}"))
        for name, value in _section(_RULES, "special_events").items()
    )
}

PLAYER_POOL = _load_player_pool()
CARD_BY_ID = {card["id"]: card for card in PLAYER_POOL}
COACH_POOL = _load_coach_pool()
COACH_BY_ID = {coach["id"]: coach for coach in COACH_POOL}
NARRATIVE_FRAGMENTS = _load_narratives()

def _hash_int(seed: str) -> int:
    return int.from_bytes(
        hashlib.sha256(seed.encode("utf-8", "replace")).digest()[:8],
        "big",
    )


def _pick_fragment(category: str, seed: str, **values: Any) -> str:
    fragments = tuple(NARRATIVE_FRAGMENTS.get(category, ()))
    if not fragments:
        return ""
    template = fragments[_hash_int(f"{category}|{seed}") % len(fragments)]
    return template.format(**values)


def _narrative_inventory_size() -> int:
    return sum(len(items) for items in NARRATIVE_FRAGMENTS.values())


def _pack_response_parts(parts: list[str]) -> str:
    cleaned = [part.strip() for part in parts if part.strip()]
    if len(cleaned) <= 1:
        return cleaned[0] if cleaned else "没有可发送内容"
    return MULTI_REPLY_MARKER + json.dumps(
        cleaned,
        ensure_ascii=False,
        separators=(",", ":"),
    )


def _unpack_response_parts(value: str) -> list[str]:
    if not value.startswith(MULTI_REPLY_MARKER):
        return [value]
    try:
        payload = json.loads(value[len(MULTI_REPLY_MARKER) :])
    except json.JSONDecodeError:
        return [value]
    if not isinstance(payload, list):
        return [value]
    parts = [str(item).strip() for item in payload if str(item).strip()]
    return parts or [value]


def _round_robin_rounds(keys: list[str]) -> list[list[list[str]]]:
    rotation: list[str | None] = list(keys)
    if len(rotation) % 2:
        rotation.append(None)
    rounds: list[list[list[str]]] = []
    for _ in range(len(rotation) - 1):
        pairs: list[list[str]] = []
        for index in range(len(rotation) // 2):
            first = rotation[index]
            second = rotation[-index - 1]
            if first is not None and second is not None:
                pairs.append([first, second])
        rounds.append(pairs)
        rotation = [rotation[0], rotation[-1], *rotation[1:-1]]
    return rounds


def build_round_plan(keys: list[str]) -> list[dict[str, Any]]:
    if not MIN_PLAYERS <= len(keys) <= MAX_PLAYERS:
        raise ValueError("参赛人数必须为 2～8 人")
    plan: list[dict[str, Any]] = [
        {
            "kind": "pve",
            "phase": "pve_training",
            "name": PVE_EVENTS["pve_training"][0],
        }
    ]
    group_rounds = _round_robin_rounds(keys)
    challenge_after = 1 if len(group_rounds) <= 2 else 2
    for day, pairs in enumerate(group_rounds, start=1):
        plan.append(
            {
                "kind": "group",
                "phase": f"group_{day}",
                "name": f"小组赛第 {day} 轮",
                "day": day,
                "pairs": pairs,
                "last_group_day": day == len(group_rounds),
            }
        )
        if day == challenge_after:
            phase = "pve_media" if len(keys) % 2 == 0 else "pve_sponsor"
            plan.append(
                {
                    "kind": "pve",
                    "phase": phase,
                    "name": PVE_EVENTS[phase][0],
                }
            )
    if len(keys) >= 4:
        plan.append(
            {
                "kind": "semifinal",
                "phase": "semifinal",
                "name": "淘汰赛半决赛（1v4、2v3）",
                "pairs": [[keys[0], keys[3]], [keys[1], keys[2]]]
                if len(keys) == 4
                else [],
                "pairing": "standings",
            }
        )
    plan.append(
        {
            "kind": "final",
            "phase": "final",
            "name": "总决赛",
        }
    )
    return plan


def _current_stage(state: dict[str, Any]) -> dict[str, Any]:
    round_number = int(state["round_number"])
    plan = state.get("round_plan", [])
    if not isinstance(plan, list) or not 1 <= round_number <= len(plan):
        return {"kind": "complete", "phase": "complete", "name": "赛事结束"}
    stage = plan[round_number - 1]
    return stage if isinstance(stage, dict) else {
        "kind": "complete",
        "phase": "complete",
        "name": "赛事结束",
    }


def _host_text(text: str) -> str:
    return text if text.startswith(f"{HOST_NAME}：") else f"{HOST_NAME}：{text}"


def _human_keys(state: dict[str, Any]) -> list[str]:
    return [
        key
        for key in state["seed_order"]
        if not state["players"][key].get("is_ai")
    ]


def _reset_preparation(state: dict[str, Any]) -> None:
    human_keys = _human_keys(state)
    if not human_keys:
        state["preparation_order"] = []
        state["preparation_cursor"] = 0
        return
    offset = (int(state["round_number"]) - 1) % len(human_keys)
    order = [*human_keys[offset:], *human_keys[:offset]]
    state["preparation_order"] = order
    state["preparation_cursor"] = 0
    for key in state["join_order"]:
        state["players"][key]["ready"] = bool(
            state["players"][key].get("is_ai")
        )


def _current_preparer(state: dict[str, Any]) -> str | None:
    order = state.get("preparation_order", [])
    cursor = int(state.get("preparation_cursor", 0))
    if not isinstance(order, list) or not 0 <= cursor < len(order):
        return None
    return str(order[cursor])


def _preparation_prompt(state: dict[str, Any]) -> str:
    current = _current_preparer(state)
    if current is None:
        return _host_text("全员准备完毕，主持人可以发送 /自走棋结算。")
    name = state["players"][current]["display_name"]
    return _host_text(
        f"{name}，请做好赛前准备；完成后发送 /结束回合。"
    )


def _format_description(state: dict[str, Any]) -> str:
    team_count = len(state["join_order"])
    if state.get("ai_test_variant") == "two_plus_two":
        return (
            "本届采用 2 人+2 AI 测试赛：报名种子 1v4、2v3 进行 BO5 "
            "半决赛，胜者进入 BO5 总决赛"
        )
    if state.get("ai_test_mode"):
        return (
            "本届采用 3 人+1 AI 测试赛：报名种子 1v4、2v3 进行 BO5 "
            "半决赛，胜者进入 BO5 总决赛"
        )
    if team_count == 2:
        return "本届两队在三轮赛前活动后直接进行 BO5 总决赛"
    if team_count == 3:
        return "本届三队进行 BO3 单循环，前两名进入 BO5 总决赛"
    if team_count == 4:
        return "本届按报名种子 1v4、2v3 进行 BO5 半决赛和总决赛"
    return (
        f"本届 {team_count} 队进行 BO3 单循环，前四名按 1v4、2v3 "
        "进入 BO5 淘汰赛"
    )


def _shop_tier(state: dict[str, Any]) -> int:
    round_number = int(state["round_number"])
    total_rounds = max(1, len(state.get("round_plan", [])))
    if total_rounds == 1:
        return 5
    return min(5, 1 + (round_number - 1) * 5 // total_rounds)


def _new_unit(card_id: str, copies: int = 1) -> dict[str, Any]:
    return {
        "card_id": card_id,
        "copies": copies,
        "star": 3 if copies >= 9 else 2 if copies >= 3 else 1,
    }


def _normalize_unit(unit: dict[str, Any]) -> None:
    copies = int(unit.get("copies", 1))
    unit["copies"] = copies
    unit["star"] = 3 if copies >= 9 else 2 if copies >= 3 else 1


def _unit_power(unit: dict[str, Any]) -> float:
    card = CARD_BY_ID[str(unit["card_id"])]
    base = (
        card["firepower"] * POWER_FIREPOWER_WEIGHT
        + card["stability"] * POWER_STABILITY_WEIGHT
        + card["clutch"] * POWER_CLUTCH_WEIGHT
    )
    if card["role"] == "指挥":
        base += (
            max(0, card["leadership"] - POWER_LEADERSHIP_THRESHOLD)
            * POWER_LEADERSHIP_SCALE
        )
    multiplier = STAR_MULTIPLIERS[int(unit["star"])]
    return base * multiplier


def _synergy_values(
    counts: dict[str, int],
    rules: dict[str, Any],
) -> list[tuple[int, int, str]]:
    values: list[tuple[int, int, str]] = []
    thresholds = list(rules["thresholds"])
    for name, count in counts.items():
        bonus = 0
        for rule in thresholds:
            if count >= int(rule["min_count"]):
                bonus = int(rule["bonus"])
                break
        if bonus:
            values.append((bonus, count, name))
    values.sort(reverse=True)
    return values[: int(rules["max_sources"])]


def lineup_power(player: dict[str, Any]) -> dict[str, Any]:
    board = player.get("board", [])
    if len(board) != STARTER_COUNT:
        raise ValueError("比赛阵容必须正好有 5 名首发")
    base = sum(_unit_power(unit) for unit in board)
    teams: dict[str, int] = {}
    nations: dict[str, int] = {}
    axes = {"火力": 0.0, "稳定": 0.0, "残局": 0.0}
    roles = {"步枪手": 0, "狙击手": 0, "指挥": 0}
    for unit in board:
        card = CARD_BY_ID[str(unit["card_id"])]
        multiplier = STAR_MULTIPLIERS[int(unit["star"])]
        axes["火力"] += float(card["firepower"]) * multiplier
        axes["稳定"] += float(card["stability"]) * multiplier
        axes["残局"] += float(card["clutch"]) * multiplier
        roles[str(card["role"])] += 1
        nations[card["nation"]] = nations.get(card["nation"], 0) + 1
        for team in card["teams"]:
            teams[team] = teams.get(team, 0) + 1
    team_values = _synergy_values(teams, TEAM_SYNERGY_RULE)
    team_bonus = sum(item[0] for item in team_values)
    nation_values = _synergy_values(nations, NATION_SYNERGY_RULE)
    nation_bonus = sum(item[0] for item in nation_values)
    coach_id = str(player.get("coach_id", ""))
    coach = COACH_BY_ID.get(coach_id)
    if coach is not None:
        axes["火力"] += float(coach["firepower"])
        axes["稳定"] += float(coach["stability"])
        axes["残局"] += float(coach["clutch"])
        coach_bonus = int(coach["bonus"])
        coach_label = f"{coach['name']}+{coach_bonus}%"
    else:
        coach_level = int(player.get("coach_level") or 1)
        coach_bonus = COACH_BONUSES.get(coach_level, 0)
        coach_label = f"教练+{coach_bonus}%"
    total = base * (100 + team_bonus + nation_bonus + coach_bonus) / 100
    if player.get("is_ai"):
        total *= AI_POWER_MULTIPLIER
    labels = [
        *(f"{name}{count}" for _, count, name in team_values[:2]),
        *(f"{name}{count}" for _, count, name in nation_values[:1]),
        coach_label,
    ]
    return {
        "power": round(total, 1),
        "base": round(base, 1),
        "team_bonus": team_bonus,
        "nation_bonus": nation_bonus,
        "coach_bonus": coach_bonus,
        "synergies": labels,
        "axes": {name: round(value, 1) for name, value in axes.items()},
        "roles": roles,
    }


def matchup_modifier(
    player_a: dict[str, Any],
    player_b: dict[str, Any],
) -> dict[str, Any]:
    info_a = lineup_power(player_a)
    info_b = lineup_power(player_b)
    axes_a = dict(info_a["axes"])
    axes_b = dict(info_b["axes"])
    tactic_a = str(player_a.get("tactic", "稳定"))
    tactic_b = str(player_b.get("tactic", "稳定"))
    axes_a[tactic_a] *= TACTIC_AXIS_MULTIPLIER
    axes_b[tactic_b] *= TACTIC_AXIS_MULTIPLIER

    def pressure(
        own: dict[str, float],
        opponent: dict[str, float],
    ) -> float:
        return sum(
            max(0.0, own[strong] - opponent[weak])
            for strong, weak in ATTRIBUTE_COUNTERS
        )

    axis_net = pressure(axes_a, axes_b) - pressure(axes_b, axes_a)
    axis_percent = max(
        -TACTIC_AXIS_PERCENT_CAP,
        min(TACTIC_AXIS_PERCENT_CAP, axis_net / TACTIC_AXIS_PERCENT_DIVISOR),
    )
    roles_a = info_a["roles"]
    roles_b = info_b["roles"]
    role_edge_a = sum(
        int(roles_a[strong]) * int(roles_b[weak])
        for strong, weak in ROLE_COUNTERS.items()
    )
    role_edge_b = sum(
        int(roles_b[strong]) * int(roles_a[weak])
        for strong, weak in ROLE_COUNTERS.items()
    )
    role_percent = max(
        -TACTIC_ROLE_PERCENT_CAP,
        min(
            TACTIC_ROLE_PERCENT_CAP,
            (role_edge_a - role_edge_b) * TACTIC_ROLE_PERCENT_SCALE,
        ),
    )
    tactic_percent = 0.0
    if TACTIC_COUNTERS[tactic_a] == tactic_b:
        tactic_percent = TACTIC_COUNTER_PERCENT
    elif TACTIC_COUNTERS[tactic_b] == tactic_a:
        tactic_percent = -TACTIC_COUNTER_PERCENT
    total = max(
        -TACTIC_TOTAL_PERCENT_CAP,
        min(TACTIC_TOTAL_PERCENT_CAP, axis_percent + role_percent + tactic_percent),
    )
    return {
        "a_total_percent": round(total, 2),
        "b_total_percent": round(-total, 2),
        "axis_percent": round(axis_percent, 2),
        "role_percent": round(role_percent, 2),
        "tactic_percent": round(tactic_percent, 2),
        "tactic_a": tactic_a,
        "tactic_b": tactic_b,
    }


def _draw_shop(state: dict[str, Any], seed: str) -> list[str]:
    tier = _shop_tier(state)
    odds = SHOP_ODDS[tier]
    selected: list[str] = []
    for slot in range(SHOP_SIZE):
        available_costs = [
            cost
            for cost, weight in odds.items()
            if weight > 0
            and any(
                card["cost"] == cost
                and int(state["pool"].get(card["id"], 0)) > 0
                and card["id"] not in selected
                for card in PLAYER_POOL
            )
        ]
        if not available_costs:
            break
        total_weight = sum(odds[cost] for cost in available_costs)
        roll = _hash_int(f"{seed}|cost|{slot}") % total_weight
        chosen_cost = available_costs[-1]
        for cost in available_costs:
            if roll < odds[cost]:
                chosen_cost = cost
                break
            roll -= odds[cost]
        candidates = [
            card["id"]
            for card in PLAYER_POOL
            if card["cost"] == chosen_cost
            and int(state["pool"].get(card["id"], 0)) > 0
            and card["id"] not in selected
        ]
        candidates.sort(
            key=lambda card_id: _hash_int(f"{seed}|card|{slot}|{card_id}")
        )
        selected.append(candidates[0])
    return selected


def _story(
    state: dict[str, Any],
    story_type: str,
    text: str,
    facts: dict[str, Any] | None = None,
) -> dict[str, Any]:
    state["story_sequence"] = int(state.get("story_sequence", 0)) + 1
    story_text = str(text).strip()
    item = {
        "story_id": f"story_{state['story_sequence']:04d}",
        "round_number": int(state.get("round_number", 0)),
        "phase": str(state.get("phase", "registration")),
        "story_type": story_type,
        "text": story_text,
        "facts": facts or {},
    }
    state.setdefault("stories", []).append(item)
    return item


def _battle_record(
    state: dict[str, Any],
    *,
    battle_type: str,
    player_a: str,
    player_b: str,
    result: dict[str, Any],
) -> dict[str, Any]:
    state["battle_sequence"] = int(state.get("battle_sequence", 0)) + 1
    item = {
        "battle_id": f"battle_{state['battle_sequence']:04d}",
        "round_number": int(state["round_number"]),
        "phase": str(state["phase"]),
        "battle_type": battle_type,
        "player_a": player_a,
        "player_b": player_b,
        "result": result,
    }
    state.setdefault("battles", []).append(item)
    return item


def _result(
    state: dict[str, Any] | None,
    response: str,
    *,
    stories: list[dict[str, Any]] | None = None,
    battles: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
    return {
        "state": state,
        "response": response,
        "stories": stories or [],
        "battles": battles or [],
    }


def _participant(
    person_key: str,
    display_name: str,
    *,
    is_ai: bool = False,
) -> dict[str, Any]:
    return {
        "person_key": person_key,
        "display_name": display_name,
        "hp": STARTING_HP,
        "gold": STARTING_GOLD,
        "team_name": f"Team {display_name}" if not is_ai else display_name,
        "coach_id": "",
        "coach_level": 0,
        "coach_bonus": 0,
        "coach_style": "",
        "board": [],
        "bench": [],
        "shop": [],
        "shop_locked": False,
        "ready": False,
        "wins": 0,
        "losses": 0,
        "byes": 0,
        "streak": 0,
        "opponents": [],
        "placement": None,
        "tactic": "稳定",
        "is_ai": is_ai,
    }


def _assign_starters(state: dict[str, Any], player: dict[str, Any]) -> None:
    candidates = [
        card["id"]
        for card in PLAYER_POOL
        if card["cost"] == 1 and int(state["pool"].get(card["id"], 0)) > 0
    ]
    candidates.sort(
        key=lambda card_id: _hash_int(
            f"{state['run_id']}|starter|{player['person_key']}|{card_id}"
        )
    )
    if len(candidates) < STARTER_COUNT:
        raise ValueError("低费选手池不足，无法生成完整首发")
    for card_id in candidates[:STARTER_COUNT]:
        state["pool"][card_id] -= 1
        player["board"].append(_new_unit(card_id))


def _player_prefix(state: dict[str, Any], player: dict[str, Any]) -> str:
    return f"{player['display_name']} #{state['season_number']}："


def _card_line(slot: int, card_id: str | None) -> str:
    if card_id is None:
        return f"{slot}. 已购买"
    card = CARD_BY_ID[card_id]
    history = [team for team in card["teams"] if team != card["team"]]
    history_text = "/".join(history) if history else "无"
    leadership = (
        f" 指挥{card['leadership']}" if card["role"] == "指挥" else ""
    )
    return (
        f"{slot}. {card['name']}｜{card['cost']}费 {card['role']}｜"
        f"{card['nation']}｜{card['team']}（历史 {history_text}）｜"
        f"火{card['firepower']} 稳{card['stability']} 残{card['clutch']}"
        f"{leadership}"
    )


def _shop_text(state: dict[str, Any], player: dict[str, Any]) -> str:
    phase_name = str(_current_stage(state)["name"])
    power = lineup_power(player)
    lock = "已锁" if player["shop_locked"] else "未锁"
    lines = [
        (
            f"{_player_prefix(state, player)}第 {state['round_number']} 回合"
            f" {phase_name}；摩拉 {player['gold']}；生命 {player['hp']}；"
            f"教练 {player['coach_level']} 级；战术{player['tactic']}；"
            f"阵容 {power['power']:.1f}；商店{lock}"
        )
    ]
    lines.extend(
        _card_line(index, card_id)
        for index, card_id in enumerate(player["shop"], start=1)
    )
    lines.append("操作：/选1～/选6；/战术 火力|稳定|残局；/阵容；/结束回合")
    return "\n".join(lines)


def _roster_entries(player: dict[str, Any]) -> list[tuple[str, int, dict[str, Any]]]:
    return [
        *(("首发", index, unit) for index, unit in enumerate(player["board"], 1)),
        *(("备战", index, unit) for index, unit in enumerate(player["bench"], 6)),
    ]


def _lineup_text(state: dict[str, Any], player: dict[str, Any]) -> str:
    power = lineup_power(player)
    lines = [
        (
            f"{_player_prefix(state, player)}固定 5 人首发 + 教练；"
            f"战力 {power['power']:.1f}（基础 {power['base']:.1f}）；"
            f"战术 {player['tactic']}；羁绊 {'、'.join(power['synergies'])}；"
            f"属性 火{power['axes']['火力']:.0f}/稳{power['axes']['稳定']:.0f}/"
            f"残{power['axes']['残局']:.0f}"
        )
    ]
    for scope, index, unit in _roster_entries(player):
        card = CARD_BY_ID[str(unit["card_id"])]
        lines.append(
            f"{index}. [{scope}] {card['name']} {unit['star']}星×{unit['copies']} "
            f"{card['cost']}费 {card['role']} {card['team']}/{card['nation']} "
            f"单卡{_unit_power(unit):.1f}"
        )
    if not player["bench"]:
        lines.append("备战席为空")
    lines.append("替换：/上阵 备战编号 [首发位]；出售仅限备战席：/出售 编号")
    return "\n".join(lines)


def _find_unit(
    player: dict[str, Any],
    index: int,
) -> tuple[str, int, dict[str, Any]] | None:
    for scope, display_index, unit in _roster_entries(player):
        if display_index == index:
            internal = display_index - 1 if scope == "首发" else display_index - 6
            return scope, internal, unit
    return None


def _merge_purchase(player: dict[str, Any], card_id: str) -> tuple[int, bool]:
    for unit in [*player["board"], *player["bench"]]:
        if unit["card_id"] == card_id:
            old_star = int(unit["star"])
            unit["copies"] = int(unit["copies"]) + 1
            _normalize_unit(unit)
            return int(unit["star"]), int(unit["star"]) > old_star
    if len(player["bench"]) >= BENCH_LIMIT:
        return 0, False
    player["bench"].append(_new_unit(card_id))
    return 1, False


def _ai_opponent(state: dict[str, Any], ai_key: str) -> str | None:
    stage = _current_stage(state)
    pairs = [
        (str(pair[0]), str(pair[1]))
        for pair in stage.get("pairs", [])
    ]
    if stage.get("kind") == "semifinal" and not pairs:
        qualifiers = list(state.get("qualifiers") or _rankings(state)[:4])
        if len(qualifiers) == 4:
            pairs = [
                (qualifiers[0], qualifiers[3]),
                (qualifiers[1], qualifiers[2]),
            ]
    if stage.get("kind") == "final":
        finalists = list(state.get("finalists", []))
        if len(finalists) != 2:
            finalists = list(state.get("qualifiers", []))[:2]
        if len(finalists) == 2:
            pairs = [(finalists[0], finalists[1])]
    for first, second in pairs:
        if first == ai_key:
            return second
        if second == ai_key:
            return first
    return None


def _auto_manage_ai(
    state: dict[str, Any],
) -> list[dict[str, Any]]:
    stories: list[dict[str, Any]] = []
    for ai_key in state["join_order"]:
        player = state["players"][ai_key]
        if not player.get("is_ai"):
            continue
        actions: list[str] = []
        opponent_key = _ai_opponent(state, ai_key)
        if opponent_key is not None:
            opponent_tactic = str(
                state["players"][opponent_key].get("tactic", "稳定")
            )
            player["tactic"] = next(
                tactic
                for tactic, target in TACTIC_COUNTERS.items()
                if target == opponent_tactic
            )
            actions.append(f"战术{player['tactic']}")
        else:
            player["tactic"] = TACTICS[
                (int(state["round_number"]) - 1) % len(TACTICS)
            ]
            actions.append(f"战术{player['tactic']}")

        level = int(player["coach_level"])
        if level < 5:
            upgrade_cost = COACH_UPGRADE_COSTS[level]
            if int(player["gold"]) >= upgrade_cost + REFRESH_COST:
                player["gold"] -= upgrade_cost
                player["coach_level"] = level + 1
                actions.append(f"教练{level + 1}级")

        candidates = []
        owned = {
            str(unit["card_id"])
            for unit in [*player["board"], *player["bench"]]
        }
        for slot, card_id in enumerate(player["shop"]):
            if card_id is None:
                continue
            card = CARD_BY_ID[str(card_id)]
            if (
                int(card["cost"]) <= int(player["gold"])
                and int(state["pool"].get(card_id, 0)) > 0
                and (card_id in owned or len(player["bench"]) < BENCH_LIMIT)
            ):
                candidates.append(
                    (
                        card_id in owned,
                        int(card["cost"]),
                        int(card["firepower"])
                        + int(card["stability"])
                        + int(card["clutch"]),
                        -slot,
                        slot,
                        str(card_id),
                    )
                )
        if candidates:
            *_, slot, card_id = max(candidates)
            card = CARD_BY_ID[card_id]
            player["gold"] -= int(card["cost"])
            state["pool"][card_id] -= 1
            star, _ = _merge_purchase(player, card_id)
            player["shop"][slot] = None
            actions.append(f"签下{card['name']}({star}星)")

        if player["bench"]:
            strongest_index = max(
                range(len(player["bench"])),
                key=lambda index: _unit_power(player["bench"][index]),
            )
            weakest_index = min(
                range(len(player["board"])),
                key=lambda index: _unit_power(player["board"][index]),
            )
            if (
                _unit_power(player["bench"][strongest_index])
                > _unit_power(player["board"][weakest_index])
            ):
                incoming = player["bench"][strongest_index]
                outgoing = player["board"][weakest_index]
                player["board"][weakest_index] = incoming
                player["bench"][strongest_index] = outgoing
                actions.append(
                    "换上"
                    + CARD_BY_ID[str(incoming["card_id"])]["name"]
                )
        text = (
            f"{player['display_name']} 自动运营：{'、'.join(actions)}；"
            f"摩拉 {player['gold']}，五人首发战力 "
            f"{lineup_power(player)['power']:.1f}。"
        )
        stories.append(
            _story(
                state,
                "ai_operation",
                text,
                {
                    "person_key": ai_key,
                    "actions": actions,
                    "gold": player["gold"],
                    "tactic": player["tactic"],
                },
            )
        )
    return stories



def _round_probability(
    adjusted_a: float,
    adjusted_b: float,
    seed: str,
    round_index: int,
    score_a: int,
    score_b: int,
) -> float:
    average = max(1.0, (adjusted_a + adjusted_b) / 2)
    power_edge = max(
        -ROUND_POWER_EDGE_CAP,
        min(
            ROUND_POWER_EDGE_CAP,
            (adjusted_a - adjusted_b) / average * ROUND_POWER_EDGE_SCALE,
        ),
    )
    pressure = max(
        -ROUND_PRESSURE_CAP,
        min(ROUND_PRESSURE_CAP, (score_b - score_a) * ROUND_PRESSURE_SCALE),
    )
    side_swing = (
        ROUND_FIRST_HALF_SIDE_SWING
        if round_index <= BATTLE_MR_ROUNDS // 2
        else ROUND_SECOND_HALF_SIDE_SWING
    )
    if round_index > BATTLE_MR_ROUNDS:
        side_swing = 0.0
    jitter = (
        (_hash_int(f"{seed}|prob|{round_index}") % ROUND_JITTER_MOD)
        - ROUND_JITTER_CENTER
    ) / ROUND_JITTER_DIVISOR
    return max(
        ROUND_PROBABILITY_MIN,
        min(
            ROUND_PROBABILITY_MAX,
            ROUND_PROBABILITY_BASE + power_edge + pressure + side_swing + jitter,
        ),
    )


def _simulate_map(
    state: dict[str, Any],
    key_a: str,
    key_b: str,
    seed: str,
    map_index: int,
    adjusted_a: float,
    adjusted_b: float,
) -> dict[str, Any]:
    score_a = 0
    score_b = 0
    rounds: list[str] = []
    current_key = ""
    current_run = 0
    best_run_key = ""
    best_run = 0

    def record_round(round_index: int) -> None:
        nonlocal score_a, score_b, current_key, current_run
        nonlocal best_run_key, best_run
        probability_a = _round_probability(
            adjusted_a,
            adjusted_b,
            seed,
            round_index,
            score_a,
            score_b,
        )
        roll = (_hash_int(f"{seed}|round|{round_index}") % 10_000) / 10_000
        winner_key = key_a if roll < probability_a else key_b
        if winner_key == key_a:
            score_a += 1
        else:
            score_b += 1
        rounds.append(winner_key)
        if winner_key == current_key:
            current_run += 1
        else:
            current_key = winner_key
            current_run = 1
        if current_run > best_run:
            best_run = current_run
            best_run_key = winner_key

    for round_index in range(1, BATTLE_MR_ROUNDS + 1):
        record_round(round_index)
        if score_a >= BATTLE_TARGET_SCORE or score_b >= BATTLE_TARGET_SCORE:
            break
    round_index = len(rounds)
    if (
        score_a == BATTLE_OVERTIME_START_SCORE
        and score_b == BATTLE_OVERTIME_START_SCORE
    ):
        while (
            max(score_a, score_b) < BATTLE_OVERTIME_TARGET_SCORE
            or abs(score_a - score_b) < BATTLE_OVERTIME_WIN_BY
        ):
            round_index += 1
            record_round(round_index)
            if round_index > BATTLE_OVERTIME_SAFETY_CAP:
                break

    winner_key = key_a if score_a > score_b else key_b
    loser_key = key_b if winner_key == key_a else key_a
    winner_score = score_a if winner_key == key_a else score_b
    loser_score = score_b if winner_key == key_a else score_a
    overtime_rounds = max(0, len(rounds) - BATTLE_MR_ROUNDS)
    overtime_count = (
        overtime_rounds + BATTLE_OVERTIME_SEGMENT_ROUNDS - 1
    ) // BATTLE_OVERTIME_SEGMENT_ROUNDS
    if overtime_count:
        band = "加时险胜"
    else:
        band = next(
            str(item["label"])
            for item in SCORE_BANDS
            if loser_score <= int(item["max_loser_score"])
        )
    map_name = MAP_POOL[(map_index - 1) % len(MAP_POOL)]
    winner_team = _team_name(state["players"][winner_key])
    loser_team = _team_name(state["players"][loser_key])
    best_run_team = (
        _team_name(state["players"][best_run_key]) if best_run_key else winner_team
    )
    opening_team = _team_name(
        state["players"][key_a if _hash_int(seed + "|open") % 2 == 0 else key_b]
    )
    actor = _key_player_name(state, winner_key, map_index)
    pause = _pick_fragment("pauses", f"{seed}|pause")
    run_text = (
        _pick_fragment(
            "runs",
            f"{seed}|run",
            team=best_run_team,
            count=best_run,
        )
        if best_run >= 4
        else pause
    )
    overtime_story = ""
    if overtime_count:
        overtime_story = (
            f"{map_name} 常规时间战成 15-15。{winner_team} 在加时第 "
            f"{overtime_count} 段抓住 {loser_team} 的转点空隙，以 "
            f"{winner_score}-{loser_score} 收下地图。"
        )
    return {
        "map_index": map_index,
        "map_name": map_name,
        "winner_key": winner_key,
        "winner": state["players"][winner_key]["display_name"],
        "loser_key": loser_key,
        "loser": state["players"][loser_key]["display_name"],
        "score": f"{winner_score}-{loser_score}",
        "score_a": score_a,
        "score_b": score_b,
        "band": band,
        "overtime_count": overtime_count,
        "overtime_story": overtime_story,
        "rounds_played": len(rounds),
        "best_run_key": best_run_key,
        "best_run": best_run,
        "opening_text": _pick_fragment("openings", f"{seed}|opening", team=opening_team),
        "run_text": run_text,
        "pause_text": pause,
        "clutch_text": _pick_fragment("clutches", f"{seed}|clutch", player=actor),
        "economy_text": _pick_fragment("economy", f"{seed}|economy", team=loser_team),
        "closer_text": _pick_fragment("closers", f"{seed}|closer", team=winner_team),
        "adjusted_a": round(adjusted_a, 2),
        "adjusted_b": round(adjusted_b, 2),
    }


def _battle(
    state: dict[str, Any],
    key_a: str,
    key_b: str,
    seed: str,
    *,
    best_of: int,
) -> dict[str, Any]:
    player_a = state["players"][key_a]
    player_b = state["players"][key_b]
    raw_a = lineup_power(player_a)["power"]
    raw_b = lineup_power(player_b)["power"]
    matchup = matchup_modifier(player_a, player_b)
    target_maps = best_of // 2 + 1
    wins_a = 0
    wins_b = 0
    maps: list[dict[str, Any]] = []
    for map_index in range(1, best_of + 1):
        fluct_a = _hash_int(f"{seed}|map|{map_index}|{key_a}") % 401 - 200
        fluct_b = _hash_int(f"{seed}|map|{map_index}|{key_b}") % 401 - 200
        adjusted_a = (
            raw_a
            * (100 + float(matchup["a_total_percent"]))
            / 100
            * (10_000 + fluct_a)
            / 10_000
        )
        adjusted_b = (
            raw_b
            * (100 + float(matchup["b_total_percent"]))
            / 100
            * (10_000 + fluct_b)
            / 10_000
        )
        item = _simulate_map(
            state,
            key_a,
            key_b,
            f"{seed}|map|{map_index}",
            map_index,
            adjusted_a,
            adjusted_b,
        )
        winner_key = str(item["winner_key"])
        if winner_key == key_a:
            wins_a += 1
        else:
            wins_b += 1
        item["fluctuation_a_bps"] = fluct_a
        item["fluctuation_b_bps"] = fluct_b
        maps.append(item)
        if wins_a == target_maps or wins_b == target_maps:
            break
    winner_key, loser_key = (
        (key_a, key_b) if wins_a > wins_b else (key_b, key_a)
    )
    winner_maps = max(wins_a, wins_b)
    loser_maps = min(wins_a, wins_b)
    sweep = loser_maps == 0
    damage = (
        BATTLE_BO5_SWEEP_DAMAGE
        if sweep and best_of == 5
        else BATTLE_SWEEP_DAMAGE
        if sweep
        else BATTLE_NON_SWEEP_DAMAGE
    )
    return {
        "winner_key": winner_key,
        "loser_key": loser_key,
        "player_a": player_a["display_name"],
        "player_b": player_b["display_name"],
        "winner": state["players"][winner_key]["display_name"],
        "loser": state["players"][loser_key]["display_name"],
        "best_of": best_of,
        "series_format": f"BO{best_of}",
        "score": f"{winner_maps}-{loser_maps}",
        "band": "横扫" if sweep else "鏖战",
        "damage": damage,
        "power_a": round(raw_a, 1),
        "power_b": round(raw_b, 1),
        "matchup": matchup,
        "maps": maps,
    }


def _apply_match_result(
    state: dict[str, Any],
    key_a: str,
    key_b: str,
    result: dict[str, Any],
    *,
    group_stage: bool,
) -> None:
    winner_key = str(result["winner_key"])
    loser_key = str(result["loser_key"])
    winner = state["players"][winner_key]
    loser = state["players"][loser_key]
    loser["hp"] = max(0, int(loser["hp"]) - int(result["damage"]))
    winner["streak"] = max(1, int(winner["streak"]) + 1)
    loser["streak"] = min(-1, int(loser["streak"]) - 1)
    if group_stage:
        winner["wins"] = int(winner["wins"]) + 1
        loser["losses"] = int(loser["losses"]) + 1
        state.setdefault("group_results", []).append(
            {
                "winner_key": winner_key,
                "loser_key": loser_key,
                "score": str(result["score"]),
            }
        )
    for owner, opponent in ((key_a, key_b), (key_b, key_a)):
        state["players"][owner].setdefault("opponents", []).append(opponent)


def _rankings(state: dict[str, Any]) -> list[str]:
    keys = list(state["join_order"])
    seed_order = {
        key: index
        for index, key in enumerate(state.get("seed_order", keys), start=1)
    }
    wins_by_key = {
        key: int(state["players"][key]["wins"])
        for key in keys
    }

    def head_to_head_wins(key: str) -> int:
        tied = {
            other
            for other in keys
            if wins_by_key[other] == wins_by_key[key]
        }
        return sum(
            1
            for result in state.get("group_results", [])
            if result.get("winner_key") == key
            and result.get("loser_key") in tied
        )

    keys.sort(
        key=lambda key: (
            -wins_by_key[key],
            -head_to_head_wins(key),
            -lineup_power(state["players"][key])["power"],
            -int(state["players"][key]["hp"]),
            seed_order.get(key, 999),
        )
    )
    return keys


def _battle_story(result: dict[str, Any]) -> str:
    map_scores = "、".join(
        f"{item['map_name']} {item['score']}"
        for item in result["maps"]
    )
    matchup = result["matchup"]
    tactic_note = (
        "战术克制明显"
        if abs(float(matchup["a_total_percent"])) >= 5.5
        else "战术拉扯接近"
    )
    return _host_text(
        f"{result['winner']} 在 {result['series_format']} 以 {result['score']} "
        f"击败 {result['loser']}（{map_scores}）。"
        f"战术面是 {matchup['tactic_a']} 对 {matchup['tactic_b']}，{tactic_note}。"
    )


def _append_overtime_stories(
    state: dict[str, Any],
    result: dict[str, Any],
    stories: list[dict[str, Any]],
) -> None:
    for item in result["maps"]:
        if int(item["overtime_count"]) <= 0:
            continue
        stories.append(
            _story(
                state,
                "overtime",
                str(item["overtime_story"]),
                {
                    "map_name": item["map_name"],
                    "score": item["score"],
                    "overtime_count": item["overtime_count"],
                    "winner_key": item["winner_key"],
                    "loser_key": item["loser_key"],
                },
            )
        )


def _settle_pve(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    stage = _current_stage(state)
    event_name, target, win_gold, loss_gold = PVE_EVENTS[str(stage["phase"])]
    lines: list[str] = []
    stories: list[dict[str, Any]] = []
    battles: list[dict[str, Any]] = []
    for key in state["join_order"]:
        player = state["players"][key]
        raw_power = lineup_power(player)["power"]
        fluctuation = _hash_int(
            f"{state['run_id']}|{state['round_number']}|{event_id}|{key}|pve"
        ) % 401 - 200
        adjusted = raw_power * (10_000 + fluctuation) / 10_000
        won = adjusted >= target
        reward = win_gold if won else loss_gold
        player["gold"] = int(player["gold"]) + reward
        result = {
            "winner_key": key if won else "event",
            "loser_key": "event" if won else key,
            "winner": player["display_name"] if won else "赛事活动",
            "loser": "赛事活动" if won else player["display_name"],
            "score": "达标" if won else "未达标",
            "band": "资源挑战",
            "damage": 0,
            "player_power": round(adjusted, 2),
            "target_power": target,
            "reward": reward,
            "fluctuation_bps": fluctuation,
        }
        battles.append(
            _battle_record(
                state,
                battle_type="pve",
                player_a=key,
                player_b="event",
                result=result,
            )
        )
        text = (
            f"{player['display_name']} {'完成' if won else '未完成'}"
            f"{event_name}目标 {adjusted:.1f}/{target}，获得 {reward} 摩拉。"
        )
        stories.append(_story(state, "pve_result", text, result))
        lines.append(_host_text(text))
    return lines, stories, battles


def _settle_group(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    stage = _current_stage(state)
    pairs = [
        (str(pair[0]), str(pair[1]))
        for pair in stage.get("pairs", [])
    ]
    paired = {key for pair in pairs for key in pair}
    bye = next(
        (key for key in state["join_order"] if key not in paired),
        None,
    )
    lines: list[str] = []
    stories: list[dict[str, Any]] = []
    battles: list[dict[str, Any]] = []
    if bye is not None:
        player = state["players"][bye]
        player["byes"] = int(player["byes"]) + 1
        text = f"{player['display_name']} 本轮轮空休整，不增加小组胜场。"
        stories.append(_story(state, "group_bye", text, {"person_key": bye}))
        lines.append(text)
    for index, (key_a, key_b) in enumerate(pairs, start=1):
        result = _battle(
            state,
            key_a,
            key_b,
            f"{state['run_id']}|group|{stage['day']}|{event_id}|{index}",
            best_of=MATCH_BEST_OF["group"],
        )
        _apply_match_result(
            state,
            key_a,
            key_b,
            result,
            group_stage=True,
        )
        battles.append(
            _battle_record(
                state,
                battle_type="group_bo3",
                player_a=key_a,
                player_b=key_b,
                result=result,
            )
        )
        text = _battle_story(result)
        stories.append(_story(state, "group_result", text, result))
        _append_overtime_stories(state, result, stories)
        lines.append(text)
        lines.extend(
            _host_text(str(item["overtime_story"]))
            for item in result["maps"]
            if int(item["overtime_count"]) > 0
        )
    if stage.get("last_group_day"):
        ranking = _rankings(state)
        qualifier_count = 2 if len(ranking) == 3 else 4
        state["qualifiers"] = ranking[:qualifier_count]
        names = "、".join(
            state["players"][key]["display_name"]
            for key in state["qualifiers"]
        )
        text = f"小组单循环结束，晋级淘汰赛：{names}。"
        stories.append(
            _story(
                state,
                "group_complete",
                text,
                {
                    "ranking": ranking,
                    "qualifiers": list(state["qualifiers"]),
                },
            )
        )
        lines.append(text)
    return lines, stories, battles


def _settle_semifinal(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    stage = _current_stage(state)
    if stage.get("pairing") == "seed":
        pairs = [
            (str(pair[0]), str(pair[1]))
            for pair in stage.get("pairs", [])
        ]
        state["qualifiers"] = list(state["seed_order"])
    else:
        qualifiers = list(state.get("qualifiers") or _rankings(state)[:4])
        pairs = [
            (qualifiers[0], qualifiers[3]),
            (qualifiers[1], qualifiers[2]),
        ]
    lines: list[str] = []
    stories: list[dict[str, Any]] = []
    battles: list[dict[str, Any]] = []
    finalists: list[str] = []
    for index, (key_a, key_b) in enumerate(pairs, start=1):
        result = _battle(
            state,
            key_a,
            key_b,
            f"{state['run_id']}|semifinal|{event_id}|{index}",
            best_of=MATCH_BEST_OF["semifinal"],
        )
        _apply_match_result(
            state,
            key_a,
            key_b,
            result,
            group_stage=False,
        )
        finalists.append(str(result["winner_key"]))
        battles.append(
            _battle_record(
                state,
                battle_type="semifinal_bo5",
                player_a=key_a,
                player_b=key_b,
                result=result,
            )
        )
        text = _battle_story(result)
        stories.append(_story(state, "semifinal_result", text, result))
        _append_overtime_stories(state, result, stories)
        lines.append(text)
        lines.extend(
            _host_text(str(item["overtime_story"]))
            for item in result["maps"]
            if int(item["overtime_count"]) > 0
        )
    state["finalists"] = finalists
    return lines, stories, battles


def _settle_final(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    finalists = list(state.get("finalists", []))
    if len(finalists) != 2:
        if len(state["join_order"]) == 2:
            finalists = list(state["seed_order"])
        else:
            finalists = list(state.get("qualifiers") or _rankings(state)[:2])[:2]
    key_a, key_b = finalists
    result = _battle(
        state,
        key_a,
        key_b,
        f"{state['run_id']}|final|{event_id}",
        best_of=MATCH_BEST_OF["final"],
    )
    _apply_match_result(
        state,
        key_a,
        key_b,
        result,
        group_stage=False,
    )
    champion_key = str(result["winner_key"])
    state["champion_key"] = champion_key
    state["status"] = "completed"
    battles = [
        _battle_record(
            state,
            battle_type="final_bo5",
            player_a=key_a,
            player_b=key_b,
            result=result,
        )
    ]
    stories = [_story(state, "final_result", _battle_story(result), result)]
    _append_overtime_stories(state, result, stories)
    champion = state["players"][champion_key]
    power = lineup_power(champion)
    title = state["event_title"]
    record = (
        f"小组赛 {champion['wins']}-{champion['losses']}"
        if state.get("group_results")
        else f"报名种子 #{champion.get('seed', 0)}"
    )
    text = (
        f"{champion['display_name']} 夺得{title}冠军；最终阵容战力 "
        f"{power['power']:.1f}，{record}。"
    )
    stories.append(
        _story(
            state,
            "champion",
            text,
            {
                "champion_key": champion_key,
                "power": power["power"],
                "wins": champion["wins"],
                "losses": champion["losses"],
            },
        )
    )
    overtime_lines = [
        _host_text(str(item["overtime_story"]))
        for item in result["maps"]
        if int(item["overtime_count"]) > 0
    ]
    return [
        _battle_story(result),
        *overtime_lines,
        _host_text(text),
    ], stories, battles


def _settle_round(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    ai_stories = _auto_manage_ai(state)
    stage = _current_stage(state)
    kind = str(stage["kind"])
    if kind == "pve":
        lines, stories, battles = _settle_pve(state, event_id)
    elif kind == "group":
        lines, stories, battles = _settle_group(state, event_id)
    elif kind == "semifinal":
        lines, stories, battles = _settle_semifinal(state, event_id)
    elif kind == "final":
        lines, stories, battles = _settle_final(state, event_id)
    else:
        raise ValueError("赛事轮次无效")
    stories = [*ai_stories, *stories]
    round_intro = _host_text(
        f"第 {state['round_number']} 回合{stage['name']}结算开始。"
    )
    lines = [
        round_intro,
        *(str(item["text"]) for item in ai_stories),
        *lines,
    ]
    if state["status"] == "completed":
        return lines, stories, battles
    for key in state["join_order"]:
        player = state["players"][key]
        income = ROUND_INCOME_BASE + min(
            ROUND_INTEREST_CAP,
            int(player["gold"]) // ROUND_INTEREST_DIVISOR,
        )
        player["gold"] = int(player["gold"]) + income
        player["ready"] = False
    state["round_number"] = int(state["round_number"]) + 1
    next_stage = _current_stage(state)
    state["phase"] = str(next_stage["phase"])
    _reset_preparation(state)
    public_shop = _draw_shop(
        state,
        f"{state['run_id']}|round|{state['round_number']}|public",
    )
    state["public_shop"] = public_shop
    for key in state["join_order"]:
        player = state["players"][key]
        if not player["shop_locked"]:
            player["shop"] = list(public_shop)
    next_text = _host_text(
        f"第 {state['round_number']} 回合{next_stage['name']}开始；"
        "全员获得基础收入和利息。"
    )
    stories.append(_story(state, "round_start", next_text, {"shop": public_shop}))
    lines.append(next_text)
    prompt = _preparation_prompt(state)
    stories.append(
        _story(
            state,
            "preparation_prompt",
            prompt,
            {
                "person_key": _current_preparer(state),
                "order": list(state["preparation_order"]),
            },
        )
    )
    lines.append(prompt)
    return lines, stories, battles


def _schedule_text(state: dict[str, Any]) -> str:
    current = int(state.get("round_number", 0))
    if state["status"] == "registration":
        joined = "、".join(
            state["players"][key]["display_name"] for key in state["join_order"]
        )
        return (
            f"{state['event_title']} 报名中；{len(state['join_order'])}/{MAX_PLAYERS} 人："
            f"{joined}。主持人发送 /自走棋开赛"
        )
    ranking = _rankings(state)
    stage = _current_stage(state)
    stage_label = (
        "已结束"
        if state["status"] == "completed"
        else f"第 {current} 回合 {stage['name']}"
    )
    lines = [
        f"{state['event_title']}｜{stage_label}"
    ]
    for index, key in enumerate(ranking, start=1):
        player = state["players"][key]
        marker = " *" if key in state.get("qualifiers", []) else ""
        lines.append(
            f"{index}. {player['display_name']} {player['wins']}-{player['losses']} "
            f"HP{player['hp']} 战力{lineup_power(player)['power']:.1f} "
            f"战术{player.get('tactic', '稳定')}{marker}"
        )
    plan_text = " > ".join(
        f"{index}{item['name']}"
        for index, item in enumerate(state.get("round_plan", []), start=1)
    )
    lines.append("赛程：" + plan_text)
    return "\n".join(lines)


def _archive_text(state: dict[str, Any], page: int) -> str:
    stories = list(state.get("stories", []))
    page_size = 7
    pages = max(1, (len(stories) + page_size - 1) // page_size)
    page = min(max(1, page), pages)
    start = (page - 1) * page_size
    selected = stories[start : start + page_size]
    lines = [
        f"{state['event_title']} 档案 {page}/{pages}；共 {len(stories)} 段剧情"
    ]
    for item in selected:
        lines.append(
            f"R{item['round_number']} {item['story_type']}：{item['text']}"
        )
    if not selected:
        lines.append("暂无剧情")
    return "\n".join(lines)


def _parse_indices(value: str) -> list[int]:
    value = value.strip()
    if not value:
        return []
    tokens = re.findall(r"\d{1,2}", value)
    return [int(token) for token in tokens]


def parse_autochess_action(question: str) -> tuple[str, str]:
    raw = question.lstrip()
    if raw.startswith("/"):
        raw = raw[1:].lstrip()
    folded = raw.casefold()
    for prefix in ("cs自走棋", "autochess", "自走棋"):
        if folded.startswith(prefix.casefold()):
            body = raw[len(prefix) :].strip()
            compact = re.sub(r"\s+", "", body.casefold())
            if not compact:
                return "status", ""
            actions = (
                ("强制结算", "force_settle"),
                ("结束回合", "ready"),
                ("升级教练", "coach"),
                ("加ai战队", "add_ai"),
                ("当前状态", "status"),
                ("开始", "create"),
                ("报名", "join"),
                ("开赛", "launch"),
                ("商店", "status"),
                ("状态", "status"),
                ("刷新", "refresh"),
                ("锁定", "lock"),
                ("战术", "tactic"),
                ("阵容", "lineup"),
                ("赛程", "schedule"),
                ("结算", "settle"),
                ("档案", "archive"),
                ("取消", "cancel"),
                ("start", "create"),
                ("join", "join"),
                ("launch", "launch"),
                ("addai", "add_ai"),
                ("shop", "status"),
                ("status", "status"),
                ("refresh", "refresh"),
                ("lock", "lock"),
                ("tactic", "tactic"),
                ("coach", "coach"),
                ("lineup", "lineup"),
                ("schedule", "schedule"),
                ("ready", "ready"),
                ("settle", "settle"),
                ("archive", "archive"),
                ("cancel", "cancel"),
            )
            for token, action in actions:
                if compact.startswith(token):
                    return action, compact[len(token) :]
            if compact.startswith("选") or compact.startswith("buy"):
                token = "选" if compact.startswith("选") else "buy"
                return "buy", compact[len(token) :]
            for token, action in (("上阵", "field"), ("下阵", "bench"), ("出售", "sell")):
                if compact.startswith(token):
                    return action, body[len(token) :].strip()
            return "unknown", body
    direct = (
        ("升级教练", "coach"),
        ("结束回合", "ready"),
        ("刷新", "refresh"),
        ("锁定", "lock"),
        ("战术", "tactic"),
        ("阵容", "lineup"),
        ("赛程", "schedule"),
        ("上阵", "field"),
        ("下阵", "bench"),
        ("出售", "sell"),
        ("选", "buy"),
    )
    for token, action in direct:
        if folded.startswith(token.casefold()):
            return action, raw[len(token) :].strip()
    return "unknown", raw


def _coach_line(slot: int, coach_id: str) -> str:
    coach = COACH_BY_ID[coach_id]
    return (
        f"{slot}. {coach['name']}｜{coach['level']}级教练｜{coach['style']}｜"
        f"火{coach['firepower']} 稳{coach['stability']} 残{coach['clutch']}｜"
        f"全队+{coach['bonus']}%"
    )


def _team_name(player: dict[str, Any]) -> str:
    if player.get("is_ai"):
        return str(player["display_name"])
    return f"Team {player['display_name']}"


def _seed_lines(state: dict[str, Any]) -> str:
    return "、".join(
        f"{state['players'][key]['seed']}号{state['players'][key]['display_name']}"
        for key in state["seed_order"]
    )


def _draft_order(state: dict[str, Any], round_number: int) -> list[str]:
    order = list(state["seed_order"])
    if round_number == 2:
        order.reverse()
    return order


def _draft_candidate_cards(state: dict[str, Any], round_number: int) -> list[str]:
    cards = [
        card["id"]
        for card in PLAYER_POOL
        if int(state["pool"].get(card["id"], 0)) > 0
    ]
    cards.sort(
        key=lambda card_id: _hash_int(
            f"{state['run_id']}|draft|{round_number}|{card_id}"
        )
    )
    selected: list[str] = []
    preferred_costs = (
        DRAFT_ROUND_TWO_PREFERRED_COSTS
        if round_number == 2
        else DRAFT_LATER_ROUND_PREFERRED_COSTS
    )
    for cost in preferred_costs:
        for card_id in cards:
            if (
                card_id not in selected
                and CARD_BY_ID[card_id]["cost"] == cost
                and len(selected) < DRAFT_PLAYER_CHOICE_COUNT
            ):
                selected.append(card_id)
        if len(selected) >= DRAFT_PLAYER_CHOICE_COUNT:
            break
    for card_id in cards:
        if len(selected) >= DRAFT_PLAYER_CHOICE_COUNT:
            break
        if card_id not in selected:
            selected.append(card_id)
    return selected[:DRAFT_PLAYER_CHOICE_COUNT]


def _start_draft_round(state: dict[str, Any], round_number: int) -> None:
    draft_type = "coach" if round_number == DRAFT_COACH_ROUND else "player"
    candidates = (
        [coach["id"] for coach in COACH_POOL[:DRAFT_COACH_CHOICE_COUNT]]
        if draft_type == "coach"
        else _draft_candidate_cards(state, round_number)
    )
    state["phase"] = f"draft_{draft_type}_{round_number}"
    state["draft"] = {
        "round": round_number,
        "type": draft_type,
        "order": _draft_order(state, round_number),
        "cursor": 0,
        "candidates": candidates,
    }


def _draft_round_title(draft: dict[str, Any]) -> str:
    number = int(draft["round"])
    return (
        "第一轮选秀，本轮选教练"
        if number == DRAFT_COACH_ROUND
        else f"第 {number} 轮选秀，本轮选选手"
    )


def _draft_board_part(state: dict[str, Any]) -> str:
    draft = state["draft"]
    order_names = "、".join(
        state["players"][key]["display_name"]
        for key in draft["order"]
    )
    lines = [
        f"欢迎来到{_draft_round_title(draft)}。",
        f"选择顺序：{order_names}",
    ]
    if draft["type"] == "coach":
        lines.extend(
            _coach_line(index, coach_id)
            for index, coach_id in enumerate(draft["candidates"], start=1)
        )
        lines.append(f"操作：轮到你时发送 /选1～/选{DRAFT_COACH_CHOICE_COUNT}。")
    else:
        lines.extend(
            _card_line(index, card_id)
            for index, card_id in enumerate(draft["candidates"], start=1)
        )
        lines.append("操作：轮到你时发送 /选1～/选6。")
    return "\n".join(lines)


def _draft_prompt_part(state: dict[str, Any]) -> str:
    draft = state["draft"]
    cursor = int(draft.get("cursor", 0))
    order = list(draft.get("order", []))
    if cursor >= len(order):
        return "本轮选秀已完成。"
    key = str(order[cursor])
    name = state["players"][key]["display_name"]
    command = (
        f"/选1～/选{DRAFT_COACH_CHOICE_COUNT}"
        if draft["type"] == "coach"
        else f"/选1～/选{DRAFT_PLAYER_CHOICE_COUNT}"
    )
    return f"现在轮到 @{name} 做出选择，使用 {command}。"


def _add_unit_to_roster(
    player: dict[str, Any],
    card_id: str,
    *,
    copies: int = 1,
) -> None:
    unit = _new_unit(card_id, copies=copies)
    if len(player["board"]) < STARTER_COUNT:
        player["board"].append(unit)
    else:
        player["bench"].append(unit)


def _apply_draft_choice(
    state: dict[str, Any],
    person_key: str,
    slot: int,
) -> str:
    draft = state["draft"]
    candidates = list(draft["candidates"])
    player = state["players"][person_key]
    if not 1 <= slot <= len(candidates):
        raise ValueError("选秀编号无效")
    choice_id = str(candidates[slot - 1])
    if draft["type"] == "coach":
        coach = COACH_BY_ID[choice_id]
        player["coach_id"] = choice_id
        player["coach_level"] = int(coach["level"])
        player["coach_bonus"] = int(coach["bonus"])
        player["coach_style"] = str(coach["style"])
        text = (
            f"{player['display_name']} 选择了教练 {coach['name']}！"
            f"{coach['level']}级，{coach['style']}，全队+{coach['bonus']}%。"
        )
    else:
        card = CARD_BY_ID[choice_id]
        draft_copies = DRAFT_PLAYER_COPY_COUNT
        if int(state["pool"].get(choice_id, 0)) < draft_copies:
            raise ValueError("这名选手已经被选走")
        state["pool"][choice_id] -= draft_copies
        _add_unit_to_roster(player, choice_id, copies=draft_copies)
        text = (
            f"{player['display_name']} 选择了 {card['name']}！"
            f"{card['cost']}费 {card['role']}，{card['team']}/{card['nation']}，"
            "以 2 星素材加入阵容。"
        )
    candidates.pop(slot - 1)
    draft["candidates"] = candidates
    draft["cursor"] = int(draft.get("cursor", 0)) + 1
    return text


def _auto_pick_slot(state: dict[str, Any], ai_key: str) -> int:
    draft = state["draft"]
    candidates = list(draft["candidates"])
    if draft["type"] == "coach":
        values = [
            (
                int(COACH_BY_ID[str(coach_id)]["bonus"]),
                -int(COACH_BY_ID[str(coach_id)]["level"]),
                index,
            )
            for index, coach_id in enumerate(candidates, start=1)
        ]
        return min(values)[2]
    values = []
    for index, card_id in enumerate(candidates, start=1):
        card = CARD_BY_ID[str(card_id)]
        values.append(
            (
                int(card["cost"]),
                int(card["firepower"]) + int(card["stability"]) + int(card["clutch"]),
                _hash_int(f"{state['run_id']}|ai|{ai_key}|{card_id}"),
                index,
            )
        )
    return min(values)[3]


def _auto_advance_draft(state: dict[str, Any]) -> list[str]:
    parts: list[str] = []
    while state.get("phase", "").startswith("draft_"):
        draft = state["draft"]
        order = list(draft["order"])
        cursor = int(draft.get("cursor", 0))
        if cursor >= len(order):
            break
        key = str(order[cursor])
        if not state["players"][key].get("is_ai"):
            break
        slot = _auto_pick_slot(state, key)
        parts.append(_apply_draft_choice(state, key, slot))
    return parts


def _finish_draft_round_if_needed(state: dict[str, Any]) -> list[str]:
    parts: list[str] = []
    while state.get("phase", "").startswith("draft_"):
        draft = state["draft"]
        if int(draft.get("cursor", 0)) < len(draft.get("order", [])):
            break
        round_number = int(draft["round"])
        if round_number < DRAFT_ROUNDS:
            _start_draft_round(state, round_number + 1)
            parts.append(_draft_board_part(state))
            parts.extend(_auto_advance_draft(state))
            continue
        _ensure_full_rosters(state)
        state["phase"] = "lineup_prep"
        state.pop("draft", None)
        _reset_ready(state, _human_keys(state))
        parts.append(
            "三轮选秀结束。每队已经整理为 5 名首发、1 名教练和 3 个备战席。"
        )
        parts.append(
            "请各位玩家使用 /阵容 查看队伍，使用 /上阵 备战编号 [首发位] 调整首发；准备完成后发送 /结束回合。"
        )
        break
    return parts


def _ensure_full_rosters(state: dict[str, Any]) -> None:
    for key in state["join_order"]:
        player = state["players"][key]
        if not player.get("coach_id"):
            fallback = COACH_POOL[-1] if player.get("is_ai") else COACH_POOL[0]
            player["coach_id"] = fallback["id"]
            player["coach_level"] = int(fallback["level"])
            player["coach_bonus"] = int(fallback["bonus"])
            player["coach_style"] = str(fallback["style"])
        owned = {
            str(unit["card_id"])
            for unit in [*player.get("board", []), *player.get("bench", [])]
        }
        target_total = STARTER_COUNT + BENCH_LIMIT
        while len(player["board"]) + len(player["bench"]) < target_total:
            candidates = [
                card["id"]
                for card in PLAYER_POOL
                if card["id"] not in owned and int(state["pool"].get(card["id"], 0)) > 0
            ]
            candidates.sort(
                key=lambda card_id: (
                    CARD_BY_ID[card_id]["cost"]
                    if player.get("is_ai")
                    else abs(int(CARD_BY_ID[card_id]["cost"]) - 2),
                    int(CARD_BY_ID[card_id]["cost"]),
                    _hash_int(f"{state['run_id']}|fill|{key}|{card_id}"),
                )
            )
            if not candidates:
                break
            card_id = candidates[0]
            state["pool"][card_id] -= 1
            owned.add(card_id)
            _add_unit_to_roster(player, card_id)
        units = [*player.get("board", []), *player.get("bench", [])]
        units.sort(key=_unit_power, reverse=True)
        player["board"] = units[:STARTER_COUNT]
        player["bench"] = units[STARTER_COUNT : STARTER_COUNT + BENCH_LIMIT]
        player["shop"] = _draw_shop(
            state,
            f"{state['run_id']}|lineup|{key}",
        )


def _reset_ready(state: dict[str, Any], keys: list[str]) -> None:
    ready_keys = set(keys)
    state["ready_keys"] = list(keys)
    for key in state["join_order"]:
        player = state["players"][key]
        player["ready"] = bool(player.get("is_ai") or key not in ready_keys)


def _ready_waiting(state: dict[str, Any]) -> list[str]:
    return [
        key
        for key in state.get("ready_keys", [])
        if not state["players"][key].get("ready")
    ]


def _team_power_line(state: dict[str, Any], key: str) -> str:
    player = state["players"][key]
    power = lineup_power(player)
    coach = COACH_BY_ID.get(str(player.get("coach_id", "")))
    coach_text = (
        f"{coach['name']} {coach['level']}级"
        if coach is not None
        else f"{player.get('coach_level', 1)}级"
    )
    return (
        f"{player['display_name']} #{state['season_number']}：摩拉 {player['gold']}；"
        f"生命 {player['hp']}；教练 {coach_text}；战术{player['tactic']}；"
        f"阵容 {power['power']:.1f}；商店{'已锁' if player['shop_locked'] else '未锁'}"
    )


def _full_lineup_text(state: dict[str, Any], player: dict[str, Any]) -> str:
    if len(player.get("board", [])) != STARTER_COUNT:
        drafted = [
            CARD_BY_ID[str(unit["card_id"])]["name"]
            for unit in [*player.get("board", []), *player.get("bench", [])]
        ]
        coach = COACH_BY_ID.get(str(player.get("coach_id", "")))
        return "\n".join(
            [
                f"{player['display_name']} #{state['season_number']}：选秀中阵容",
                f"教练：{coach['name'] if coach else '未选择'}",
                "已选选手：" + ("、".join(drafted) if drafted else "暂无"),
            ]
        )
    return _lineup_text(state, player)


def _shop_status_text(state: dict[str, Any], player: dict[str, Any]) -> str:
    if len(player.get("board", [])) != STARTER_COUNT:
        return _full_lineup_text(state, player)
    return _team_power_line(state, player) + "\n" + "\n".join(
        _card_line(index, card_id)
        for index, card_id in enumerate(player.get("shop", []), start=1)
    ) + "\n操作：/选1～/选6；/刷新；/锁定；/阵容；/战术 火力|稳定|残局；/结束回合"


def _training_schedule(state: dict[str, Any]) -> list[dict[str, Any]]:
    rounds: list[dict[str, Any]] = []
    keys = list(state["seed_order"])
    for round_index, pairs in enumerate(_round_robin_rounds(keys), start=1):
        paired = {key for pair in pairs for key in pair}
        bye = next((key for key in keys if key not in paired), "")
        rounds.append(
            {
                "round": round_index,
                "pairs": [[str(pair[0]), str(pair[1])] for pair in pairs],
                "bye": bye,
            }
        )
    return rounds


def _ensure_training_schedule(state: dict[str, Any]) -> None:
    if state.get("training_rounds"):
        return
    state["training_rounds"] = _training_schedule(state)
    state["training_round_cursor"] = 0


def _training_pairing_line(state: dict[str, Any], round_item: dict[str, Any]) -> str:
    rendered = [
        f"{_team_name(state['players'][pair[0]])} vs {_team_name(state['players'][pair[1]])}"
        for pair in round_item.get("pairs", [])
    ]
    bye = str(round_item.get("bye") or "")
    if bye:
        rendered.append(f"{_team_name(state['players'][bye])} vs 本地陪练队")
    return "；".join(rendered)


def _training_match_part(
    state: dict[str, Any],
    result: dict[str, Any],
    round_number: int,
) -> str:
    item = result["maps"][0]
    winner_key = str(result["winner_key"])
    loser_key = str(result["loser_key"])
    winner = state["players"][winner_key]
    loser = state["players"][loser_key]
    return "\n".join(
        [
            (
                f"训练赛第 {round_number} 轮：{_team_name(winner)} "
                f"vs {_team_name(loser)}"
            ),
            (
                f"{item['map_name']}：{item['opening_text']}"
                f"{item['run_text']}"
            ),
            (
                f"{item['clutch_text']}{item['closer_text']}"
                f"{_team_name(winner)} 以 {item['score']} 拿下本图。"
            ),
            (
                f"摩拉：{_team_name(winner)} +{TRAINING_WIN_GOLD}，"
                f"{_team_name(loser)} +{TRAINING_LOSS_GOLD}。"
            ),
        ]
    )


def _training_bye_part(state: dict[str, Any], key: str, round_number: int) -> str:
    player = state["players"][key]
    player["gold"] = int(player["gold"]) + TRAINING_BYE_GOLD
    hook = _pick_fragment(
        "training_hooks",
        f"{state['run_id']}|training|bye|{round_number}|{key}",
    )
    return (
        f"训练赛第 {round_number} 轮：{_team_name(player)} 与本地陪练队完成热身。\n"
        f"{hook}\n摩拉：{_team_name(player)} +{TRAINING_BYE_GOLD}。"
    )


def _settle_training_round(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    _ensure_training_schedule(state)
    rounds = list(state.get("training_rounds", []))
    cursor = int(state.get("training_round_cursor", 0))
    if cursor >= len(rounds):
        state["phase"] = "training_complete_manage"
        _prepare_new_shops(state, "training-complete")
        _reset_ready(state, _human_keys(state))
        return [
            "训练赛已经全部结束。可以最后 D 牌、调阵容；所有真人发送 /结束回合 后进入小组赛。"
        ], [], []

    round_item = rounds[cursor]
    round_number = int(round_item["round"])
    state["round_number"] = round_number
    parts: list[str] = []
    stories: list[dict[str, Any]] = []
    battles: list[dict[str, Any]] = []
    if cursor == 0:
        intro = (
            f"欢迎来到{state['event_title']}！你们已经到达酒店宾馆，"
            f"训练赛共 {len(rounds)} 轮。训练赛不扣生命，只产出运营摩拉。"
        )
        parts.append(intro)
        stories.append(_story(state, "training_open", intro))
    hook = _pick_fragment(
        "training_hooks",
        f"{state['run_id']}|training|hook|{round_number}",
    )
    parts.append(
        f"训练赛第 {round_number}/{len(rounds)} 轮对阵："
        f"{_training_pairing_line(state, round_item)}\n{hook}"
    )
    for match_index, pair in enumerate(round_item.get("pairs", []), start=1):
        key_a, key_b = str(pair[0]), str(pair[1])
        result = _battle(
            state,
            key_a,
            key_b,
            f"{state['run_id']}|training|{round_number}|{match_index}|{event_id}",
            best_of=MATCH_BEST_OF["training"],
        )
        winner_key = str(result["winner_key"])
        loser_key = str(result["loser_key"])
        state["players"][winner_key]["gold"] = (
            int(state["players"][winner_key]["gold"]) + TRAINING_WIN_GOLD
        )
        state["players"][loser_key]["gold"] = (
            int(state["players"][loser_key]["gold"]) + TRAINING_LOSS_GOLD
        )
        result["training_rewards"] = {
            winner_key: TRAINING_WIN_GOLD,
            loser_key: TRAINING_LOSS_GOLD,
        }
        battle = _battle_record(
            state,
            battle_type="training_bo1",
            player_a=key_a,
            player_b=key_b,
            result=result,
        )
        text = _training_match_part(state, result, round_number)
        parts.append(text)
        stories.append(_story(state, "training_result", text, result))
        battles.append(battle)
    bye = str(round_item.get("bye") or "")
    if bye:
        text = _training_bye_part(state, bye, round_number)
        parts.append(text)
        stories.append(_story(state, "training_bye", text, {"person_key": bye}))
    state["training_round_cursor"] = cursor + 1
    _prepare_new_shops(state, f"training-{round_number}")
    _reset_ready(state, _human_keys(state))
    if cursor + 1 < len(rounds):
        state["phase"] = "training_manage"
        parts.append(
            "本轮训练结束。现在是运营窗口：/刷新 是 D 牌，/选1～/选6 是买店内选手，"
            "/锁定 可保留商店，/上阵 可调整首发；所有真人发送 /结束回合 后进入下一轮训练。"
        )
    else:
        state["phase"] = "training_complete_manage"
        parts.append(
            "训练赛全部结束。可以最后 D 牌、调阵容；所有真人发送 /结束回合 后进入小组赛。"
        )
    return parts, stories, battles


def _prepare_new_shops(state: dict[str, Any], reason: str) -> None:
    for key in state["join_order"]:
        player = state["players"][key]
        if not player.get("shop_locked"):
            player["shop"] = _draw_shop(
                state,
                f"{state['run_id']}|{reason}|{key}|{state.get('match_sequence', 0)}",
            )


def _group_schedule(state: dict[str, Any]) -> list[dict[str, Any]]:
    matches: list[dict[str, Any]] = []
    for round_index, pairs in enumerate(_round_robin_rounds(list(state["seed_order"])), start=1):
        paired = {key for pair in pairs for key in pair}
        bye = next((key for key in state["seed_order"] if key not in paired), "")
        for match_index, pair in enumerate(pairs, start=1):
            matches.append(
                {
                    "stage": "group",
                    "round": round_index,
                    "match": match_index,
                    "pair": [str(pair[0]), str(pair[1])],
                    "best_of": MATCH_BEST_OF["group"],
                    "bye": bye,
                }
            )
    return matches


def _match_title(state: dict[str, Any], match: dict[str, Any]) -> str:
    key_a, key_b = match["pair"]
    player_a = state["players"][key_a]
    player_b = state["players"][key_b]
    if match["stage"] == "group":
        return (
            f"小组赛第 {match['round']} 轮第 {match['match']} 场："
            f"{_team_name(player_a)} vs {_team_name(player_b)}（BO{match['best_of']}）"
        )
    label = "淘汰赛半决赛" if match["stage"] == "semifinal" else "总决赛"
    return f"{label}：{_team_name(player_a)} vs {_team_name(player_b)}（BO{match['best_of']}）"


def _match_ready_keys(state: dict[str, Any], match: dict[str, Any]) -> list[str]:
    if match.get("stage") == "group":
        return _human_keys(state)
    return [
        key
        for key in match.get("pair", [])
        if not state["players"][key].get("is_ai")
    ]


def _set_current_match(state: dict[str, Any], match: dict[str, Any]) -> list[str]:
    state["current_match"] = match
    state["phase"] = f"{match['stage']}_ready"
    keys = _match_ready_keys(state, match)
    _reset_ready(state, keys)
    parts = [_match_title(state, match)]
    if keys:
        names = "、".join(state["players"][key]["display_name"] for key in keys)
        parts.append(f"{names}，请确认阵容；准备完成发送 /结束回合。")
    else:
        parts.append("本场为 AI 内战，将自动结算。")
    return parts


def _start_group_parts(state: dict[str, Any]) -> list[str]:
    state["group_matches"] = _group_schedule(state)
    state["group_match_cursor"] = 0
    state["match_sequence"] = 0
    pair_lines = []
    rounds = _round_robin_rounds(list(state["seed_order"]))
    for round_index, pairs in enumerate(rounds, start=1):
        rendered = []
        paired = {key for pair in pairs for key in pair}
        bye = next((key for key in state["seed_order"] if key not in paired), "")
        for match_index, pair in enumerate(pairs, start=1):
            rendered.append(
                f"第 {round_index} 轮第 {match_index} 场 "
                f"{_team_name(state['players'][pair[0]])} vs {_team_name(state['players'][pair[1]])}"
            )
        if bye:
            rendered.append(f"{state['players'][bye]['display_name']} 轮空")
        pair_lines.append("；".join(rendered))
    parts = [
        (
            f"欢迎来到{state['event_title']}正赛小组赛！"
            f"小组赛采用单循环 BO{MATCH_BEST_OF['group']}。"
        ),
        "本阶段对阵：\n" + "\n".join(pair_lines),
    ]
    if state["group_matches"]:
        parts.extend(_set_current_match(state, state["group_matches"][0]))
    return parts


def _key_player_name(state: dict[str, Any], key: str, offset: int) -> str:
    board = state["players"][key].get("board", [])
    if not board:
        return state["players"][key]["display_name"]
    unit = board[offset % len(board)]
    return str(CARD_BY_ID[str(unit["card_id"])]["name"])


def _series_report_parts(
    state: dict[str, Any],
    match: dict[str, Any],
    result: dict[str, Any],
) -> list[str]:
    key_a, key_b = match["pair"]
    matchup = result["matchup"]
    parts = [
        (
            f"{_match_title(state, match)} 开始。"
            f"战术面是 {matchup['tactic_a']} 对 {matchup['tactic_b']}，"
            "本场按逐回合模拟推进。"
        )
    ]
    wins: dict[str, int] = {key_a: 0, key_b: 0}
    for index, item in enumerate(result["maps"], start=1):
        winner_key = str(item["winner_key"])
        loser_key = str(item["loser_key"])
        wins[winner_key] += 1
        lead_text = (
            f"{_team_name(state['players'][winner_key])} 在系列赛中 "
            f"{wins[winner_key]}-{wins[loser_key]} {'领先' if wins[winner_key] > wins[loser_key] else '追平'}"
        )
        parts.append(
            f"图{index} {item['map_name']}：{item['opening_text']}"
            f"{item['run_text']}{item['clutch_text']}"
            f"{item['economy_text']}{item['closer_text']}"
            f"{_team_name(state['players'][winner_key])} 以 {item['score']} 拿下地图；{lead_text}。"
        )
    winner_key = str(result["winner_key"])
    loser_key = str(result["loser_key"])
    reward = (
        GROUP_SERIES_WIN_GOLD
        if match["stage"] == "group"
        else PLAYOFF_SERIES_WIN_GOLD
    )
    state["players"][winner_key]["gold"] = int(state["players"][winner_key]["gold"]) + reward
    final_text = (
        f"系列赛结束，{_team_name(state['players'][winner_key])} 以 {result['score']} 击败 "
        f"{_team_name(state['players'][loser_key])}，获得 {reward} 摩拉。"
        "这笔钱可以马上用于 /刷新、/选1～/选6 或锁店等下一轮运营。"
    )
    parts[-1] = parts[-1] + "\n" + final_text
    if len(parts) <= 5:
        return parts
    return [parts[0], parts[1], parts[2], "\n".join(parts[3:-1]), parts[-1]]


def _settle_current_match(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]], list[dict[str, Any]]]:
    match = dict(state["current_match"])
    key_a, key_b = match["pair"]
    state["match_sequence"] = int(state.get("match_sequence", 0)) + 1
    result = _battle(
        state,
        key_a,
        key_b,
        f"{state['run_id']}|{match['stage']}|{state['match_sequence']}|{event_id}",
        best_of=int(match["best_of"]),
    )
    _apply_match_result(
        state,
        key_a,
        key_b,
        result,
        group_stage=match["stage"] == "group",
    )
    battle_type = "group_bo3" if match["stage"] == "group" else f"{match['stage']}_bo5"
    battle = _battle_record(
        state,
        battle_type=battle_type,
        player_a=key_a,
        player_b=key_b,
        result=result,
    )
    parts = _series_report_parts(state, match, result)
    story = _story(state, f"{match['stage']}_result", "\n".join(parts), result)
    return parts, [story], [battle]


def _standings_part(state: dict[str, Any]) -> str:
    lines = ["小组赛排名："]
    for index, key in enumerate(_rankings(state), start=1):
        player = state["players"][key]
        total = max(1, int(player["wins"]) + int(player["losses"]))
        rate = int(player["wins"]) / total
        lines.append(
            f"{index}. {_team_name(player)} {player['wins']}胜{player['losses']}负 胜率{rate:.0%}"
        )
    return "\n".join(lines)


def _special_event_parts(
    state: dict[str, Any],
    event_id: str,
) -> tuple[list[str], list[dict[str, Any]]]:
    event_key = "media" if _hash_int(state["run_id"] + event_id) % 2 == 0 else "sponsor"
    event_kind, target, win_gold, loss_gold = SPECIAL_EVENTS[event_key]
    parts = [f"{event_kind}突然插入。本届只会出现一次这种挑战；完成后继续小组赛。"]
    stories: list[dict[str, Any]] = []
    for key in state["join_order"]:
        player = state["players"][key]
        power = lineup_power(player)["power"]
        won = power >= target
        reward = win_gold if won else loss_gold
        player["gold"] = int(player["gold"]) + reward
        hook = _pick_fragment(
            "challenges",
            f"{state['run_id']}|{event_kind}|{event_id}|{key}",
        )
        text = (
            f"{_team_name(player)} {'完成' if won else '勉强应付'}{event_kind}："
            f"{hook}获得 {reward} 摩拉。"
        )
        parts.append(text)
        stories.append(_story(state, "special_event", text, {"person_key": key}))
    state["special_event_done"] = True
    state["phase"] = "special_manage"
    _prepare_new_shops(state, event_kind)
    _reset_ready(state, _human_keys(state))
    parts.append("挑战结束。可以继续 D 牌和调整阵容；所有真人发送 /结束回合 后继续小组赛。")
    return parts, stories


def _playoff_matches_from_rankings(state: dict[str, Any]) -> list[dict[str, Any]]:
    ranking = _rankings(state)
    if len(ranking) >= 4:
        qualifiers = ranking[:4]
        state["qualifiers"] = qualifiers
        return [
            {
                "stage": "semifinal",
                "round": 1,
                "match": 1,
                "pair": [qualifiers[0], qualifiers[3]],
                "best_of": MATCH_BEST_OF["semifinal"],
            },
            {
                "stage": "semifinal",
                "round": 1,
                "match": 2,
                "pair": [qualifiers[1], qualifiers[2]],
                "best_of": MATCH_BEST_OF["semifinal"],
            },
        ]
    finalists = ranking[:2]
    state["finalists"] = finalists
    return [
        {
            "stage": "final",
            "round": 1,
            "match": 1,
            "pair": finalists,
            "best_of": MATCH_BEST_OF["final"],
        }
    ]


def _playoff_pairings_part(state: dict[str, Any]) -> str:
    lines = ["淘汰赛对阵："]
    for match in state.get("playoff_matches", []):
        key_a, key_b = match["pair"]
        seed_a = state["players"][key_a].get("seed", "?")
        seed_b = state["players"][key_b].get("seed", "?")
        label = "半决赛" if match["stage"] == "semifinal" else "总决赛"
        lines.append(
            f"{label}：{_team_name(state['players'][key_a])}({seed_a}) vs {_team_name(state['players'][key_b])}({seed_b})"
        )
    return "\n".join(lines)


def _finish_tournament_parts(state: dict[str, Any]) -> list[str]:
    champion_key = str(state["champion_key"])
    champion = state["players"][champion_key]
    power = lineup_power(champion)
    state["status"] = "completed"
    state["phase"] = "completed"
    return [
        f"{state['event_title']} 全部比赛结束！",
        (
            f"冠军：{_team_name(champion)}。最终阵容战力 {power['power']:.1f}，"
            f"小组赛 {champion['wins']}胜{champion['losses']}负。"
        ),
        "颁奖：MVP 给到本届决赛关键先生；所有赛报已经写入自走棋档案，可用 /自走棋档案 查看。",
    ]


class CsMajorAutochess:
    """Command facade; persistence remains behind the Kernel Ledger service."""

    def __init__(self, ledger: Any) -> None:
        self.ledger = ledger

    @staticmethod
    def rules() -> str:
        return (
            "CS自走棋：/自走棋开始 创建报名；/自走棋报名；主持人 /自走棋开赛。\n"
            "两名或三名真人报名后，主持人可用 /自走棋加AI战队，"
            "分别开启 2 人+2 AI 或 3 人+1 AI 测试模式。\n"
            f"开赛后 {DRAFT_ROUNDS} 轮选秀：第一轮固定 {DRAFT_COACH_CHOICE_COUNT} 名教练，"
            "后续轮次选选手。"
            "选秀完成后每队 5 名首发、1 名教练、3 个备战席。\n"
            "/选1～/选6；/阵容；/刷新；/锁定；/上阵 备战编号 [首发位]；/出售 备战编号。"
            "/战术 火力|稳定|残局，稳定克火力、火力克残局、残局克稳定。\n"
            "训练赛按参赛人数生成多轮真实对阵，每轮结束后可 D 牌和调阵容；"
            f"随后进入 BO{MATCH_BEST_OF['group']} 单循环小组赛，"
            f"半决赛/决赛 BO{MATCH_BEST_OF['final']}。"
            "所有需要推进的阶段由相关真人发送 /结束回合，满足条件后自动进入下一步。"
        )

    def handle(self, row: dict[str, Any]) -> str:
        return "\n".join(self.handle_parts(row))

    def handle_parts(self, row: dict[str, Any]) -> list[str]:
        action_kind, arguments = parse_autochess_action(str(row["question"]))
        group = str(row["group_fingerprint"])
        sender = str(row["sender"])
        event_id = str(row["event_id"])
        command = f"autochess:{action_kind}:{arguments}"

        def execute(
            state: dict[str, Any] | None,
            person: dict[str, str],
            next_season: int,
        ) -> dict[str, Any]:
            result = self._execute(
                state,
                person,
                next_season,
                action_kind,
                arguments,
                event_id,
            )
            parts = result.pop("response_parts", None)
            if isinstance(parts, list):
                result["response"] = _pack_response_parts(
                    [str(part) for part in parts]
                )
            return result

        packed = self.ledger.apply_autochess_action(
            group,
            sender,
            event_id,
            command,
            execute,
        )
        return _unpack_response_parts(packed)

    def _execute(
        self,
        state: dict[str, Any] | None,
        person: dict[str, str],
        next_season: int,
        action: str,
        arguments: str,
        event_id: str,
    ) -> dict[str, Any]:
        person_key = str(person["person_key"])
        display_name = str(person["display_name"])

        def respond(
            current: dict[str, Any] | None,
            parts: list[str] | str,
            *,
            stories: list[dict[str, Any]] | None = None,
            battles: list[dict[str, Any]] | None = None,
        ) -> dict[str, Any]:
            normalized = [parts] if isinstance(parts, str) else parts
            normalized = [str(part) for part in normalized if str(part).strip()]
            if not normalized:
                normalized = ["没有可发送内容"]
            return {
                "state": current,
                "response": normalized[0],
                "response_parts": normalized,
                "stories": stories or [],
                "battles": battles or [],
            }

        if action == "unknown":
            return respond(state, self.rules())
        if action == "create":
            legacy_active = (
                state is not None
                and state.get("status") in {"registration", "active"}
                and int(state.get("schema_version") or 0) < 3
            )
            if (
                state is not None
                and state.get("status") in {"registration", "active"}
                and not legacy_active
            ):
                return respond(
                    state,
                    f"{state['event_title']} 已在进行中；发送 /自走棋状态 查看",
                )
            season = next_season
            state = {
                "schema_version": 3,
                "run_id": f"major_{season:04d}",
                "season_number": season,
                "event_title": EVENT_TITLE_TEMPLATE.format(season=season),
                "status": "registration",
                "host_person_key": person_key,
                "host_display_name": display_name,
                "round_number": 1,
                "phase": "registration",
                "players": {person_key: _participant(person_key, display_name)},
                "join_order": [person_key],
                "pool": {
                    card["id"]: COST_POOL_COPIES[int(card["cost"])]
                    for card in PLAYER_POOL
                },
                "public_shop": [],
                "seed_order": [],
                "round_plan": [],
                "group_results": [],
                "ai_test_mode": False,
                "ai_test_variant": "",
                "ready_keys": [],
                "qualifiers": [],
                "finalists": [],
                "champion_key": "",
                "stories": [],
                "battles": [],
                "story_sequence": 0,
                "battle_sequence": 0,
                "special_event_done": False,
                "training_rounds": [],
                "training_round_cursor": 0,
            }
            text = (
                f"{state['event_title']} 开放报名；主持人 {display_name} 已自动加入。"
                "支持 2～8 人；发送 /自走棋报名，主持人发送 /自走棋开赛。"
            )
            if legacy_active:
                text = "已保留旧版未完成赛事档案，并开启新版赛季。" + text
            story = _story(state, "registration_open", text, {"host_person_key": person_key})
            return respond(state, text, stories=[story])
        if state is None:
            return respond(None, "当前没有自走棋赛事；发送 /自走棋开始")
        if action == "join":
            if state["status"] != "registration":
                return respond(state, "本届赛事已停止报名")
            if state.get("ai_test_mode"):
                return respond(state, "AI 测试模式已经锁定参赛名单，不能再加入真人。")
            if person_key in state["players"]:
                return respond(state, f"{display_name} 已经报名。")
            if len(state["join_order"]) >= MAX_PLAYERS:
                return respond(state, f"本届赛事已满 {MAX_PLAYERS} 人")
            state["players"][person_key] = _participant(person_key, display_name)
            state["join_order"].append(person_key)
            text = f"{display_name} 加入赛事，当前 {len(state['join_order'])}/{MAX_PLAYERS} 人。"
            story = _story(state, "player_joined", text, {"person_key": person_key})
            return respond(state, text, stories=[story])
        if action == "add_ai":
            if state["status"] != "registration":
                return respond(state, "AI 战队只能在报名阶段加入")
            if person_key != state["host_person_key"]:
                return respond(state, f"只有主持人 {state['host_display_name']} 可以加入 AI 战队")
            if any(player.get("is_ai") for player in state["players"].values()):
                return respond(state, "AI 测试战队已经加入")
            human_keys = [
                key for key in state["join_order"]
                if not state["players"][key].get("is_ai")
            ]
            if len(human_keys) not in {2, 3}:
                return respond(state, "AI 测试模式要求先有且仅有 2 名或 3 名真人报名")
            if len(human_keys) == 2:
                ai_teams = (
                    (AI_PERSON_KEY, "AI 战队 A"),
                    (AI_SECOND_PERSON_KEY, AI_SECOND_DISPLAY_NAME),
                )
                variant = "two_plus_two"
                text = "AI 战队 A、AI 战队 B 已作为第 3、4 种子加入；2 人+2 AI 测试赛已锁定。"
            else:
                ai_teams = ((AI_PERSON_KEY, AI_DISPLAY_NAME),)
                variant = "three_plus_one"
                text = "AI 战队已作为第 4 种子加入；3 人+1 AI 测试赛已锁定。"
            for ai_key, ai_name in ai_teams:
                state["players"][ai_key] = _participant(ai_key, ai_name, is_ai=True)
                state["join_order"].append(ai_key)
            state["ai_test_mode"] = True
            state["ai_test_variant"] = variant
            story = _story(state, "ai_team_joined", text, {"variant": variant})
            return respond(state, text, stories=[story])
        if action == "launch":
            if state["status"] != "registration":
                return respond(state, "本届赛事已经开赛或结束")
            if person_key != state["host_person_key"]:
                return respond(state, f"只有主持人 {state['host_display_name']} 可以开赛")
            if len(state["join_order"]) < MIN_PLAYERS:
                return respond(state, f"至少需要 {MIN_PLAYERS} 人才能开赛")
            state["status"] = "active"
            state["seed_order"] = list(state["join_order"])
            state["round_plan"] = build_round_plan(list(state["join_order"]))
            for seed, key in enumerate(state["seed_order"], start=1):
                state["players"][key]["seed"] = seed
            _start_draft_round(state, 1)
            names = "、".join(
                state["players"][key]["display_name"] for key in state["join_order"]
            )
            mode = (
                "2 人+2 AI 测试赛"
                if state.get("ai_test_variant") == "two_plus_two"
                else "3 人+1 AI 测试赛"
                if state.get("ai_test_variant") == "three_plus_one"
                else f"{len(state['join_order'])} 队赛"
            )
            parts = [
                f"欢迎大家来到{state['event_title']}！",
                f"参赛者：{names}。",
                (
                    f"种子顺序：{_seed_lines(state)}。本届采用 {mode}："
                    f"先进行 {DRAFT_ROUNDS} 轮选秀，随后按轮次训练赛、"
                    f"小组赛 BO{MATCH_BEST_OF['group']} 单循环，"
                    f"淘汰赛 BO{MATCH_BEST_OF['final']}；单图 MR15，"
                    f"常规时间 {BATTLE_OVERTIME_START_SCORE}-{BATTLE_OVERTIME_START_SCORE} 进入加时。"
                ),
                _draft_board_part(state),
            ]
            parts.extend(_auto_advance_draft(state))
            parts.extend(_finish_draft_round_if_needed(state))
            if state.get("phase", "").startswith("draft_"):
                parts.append(_draft_prompt_part(state))
            story = _story(
                state,
                "tournament_started",
                "\n".join(parts),
                {"players": list(state["join_order"])},
            )
            return respond(state, parts, stories=[story])

        if action == "archive":
            page_values = _parse_indices(arguments)
            return respond(state, _archive_text(state, page_values[0] if page_values else 1))
        if action == "schedule":
            return respond(state, _schedule_text(state))
        if state["status"] == "registration":
            return respond(state, _schedule_text(state))
        if state["status"] in {"completed", "cancelled"}:
            if action in {"status", "lineup"}:
                return respond(state, _schedule_text(state))
            return respond(state, f"{state['event_title']} 已结束；发送 /自走棋开始 创建下一届")
        player = state["players"].get(person_key)
        if player is None:
            return respond(state, "你没有参加本届赛事，只能查看 /自走棋赛程")
        if action == "status":
            return respond(state, _shop_status_text(state, player))
        if action == "lineup":
            return respond(state, _full_lineup_text(state, player))

        if state.get("phase", "").startswith("draft_"):
            if action != "buy":
                return respond(state, _draft_prompt_part(state))
            draft = state["draft"]
            order = list(draft["order"])
            cursor = int(draft.get("cursor", 0))
            if cursor >= len(order):
                return respond(state, "本轮选秀已经完成，请稍等主持进入下一轮。")
            current_key = str(order[cursor])
            if current_key != person_key:
                return respond(
                    state,
                    f"当前选择的是 @{state['players'][current_key]['display_name']}，请等待。",
                )
            values = _parse_indices(arguments)
            if len(values) != 1:
                return respond(
                    state,
                    (
                        f"用法：/选1～/选{DRAFT_COACH_CHOICE_COUNT}（教练）"
                        f"或 /选1～/选{DRAFT_PLAYER_CHOICE_COUNT}（选手）"
                    ),
                )
            try:
                text = _apply_draft_choice(state, person_key, values[0])
            except ValueError as error:
                return respond(state, str(error))
            parts = [text]
            parts.extend(_auto_advance_draft(state))
            parts.extend(_finish_draft_round_if_needed(state))
            if state.get("phase", "").startswith("draft_"):
                parts.append(_draft_prompt_part(state))
            story = _story(state, "draft_pick", text, {"person_key": person_key})
            return respond(state, parts, stories=[story])

        if action == "tactic":
            value = re.sub(r"\s+", "", arguments.casefold())
            aliases = {
                "火力": "火力",
                "fire": "火力",
                "稳定": "稳定",
                "stable": "稳定",
                "残局": "残局",
                "clutch": "残局",
            }
            if not value:
                return respond(state, f"当前战术 {player['tactic']}；用法：/战术 火力|稳定|残局")
            tactic = aliases.get(value)
            if tactic is None:
                return respond(state, "战术只能选择：火力、稳定、残局")
            player["tactic"] = tactic
            text = f"{display_name} 将战术设为 {tactic}。"
            story = _story(state, "tactic_selected", text, {"person_key": person_key, "tactic": tactic})
            return respond(state, text, stories=[story])
        if action == "coach":
            return respond(state, "教练现在由第一轮选秀决定，本届不能用摩拉升级教练。")
        if action == "buy":
            values = _parse_indices(arguments)
            if len(values) != 1 or not 1 <= values[0] <= SHOP_SIZE:
                return respond(state, "用法：/选1 到 /选6")
            slot = values[0] - 1
            card_id = player["shop"][slot] if slot < len(player.get("shop", [])) else None
            if card_id is None:
                return respond(state, "这个商店位置已经购买或没有候选")
            card = CARD_BY_ID[str(card_id)]
            if int(player["gold"]) < int(card["cost"]):
                return respond(state, f"摩拉不足：{card['name']} 需要 {card['cost']}，当前 {player['gold']}")
            existing = any(
                unit["card_id"] == card_id
                for unit in [*player["board"], *player["bench"]]
            )
            if not existing and len(player["bench"]) >= BENCH_LIMIT:
                return respond(state, f"备战席已满 {BENCH_LIMIT} 格，请先出售")
            if int(state["pool"].get(card_id, 0)) <= 0:
                return respond(state, "共享卡池中的这名选手已被拿完，请刷新")
            player["gold"] -= int(card["cost"])
            state["pool"][card_id] -= 1
            star, upgraded = _merge_purchase(player, str(card_id))
            player["shop"][slot] = None
            text = (
                f"{display_name} 签下 {card['name']}，花费 {card['cost']} 摩拉；"
                f"当前 {star} 星，余额 {player['gold']}。"
            )
            if upgraded:
                text += f"{card['name']} 完成升星。"
            story = _story(state, "shop_purchase", text, {"person_key": person_key, "card_id": card_id})
            return respond(state, text, stories=[story])
        if action == "refresh":
            if int(player["gold"]) < REFRESH_COST:
                return respond(state, f"刷新需要 {REFRESH_COST} 摩拉，当前 {player['gold']}")
            player["gold"] -= REFRESH_COST
            player["shop"] = _draw_shop(
                state,
                f"{state['run_id']}|{state.get('phase')}|{event_id}|{person_key}|refresh",
            )
            return respond(state, _shop_status_text(state, player))
        if action == "lock":
            player["shop_locked"] = not bool(player["shop_locked"])
            return respond(state, f"{display_name} {'锁定' if player['shop_locked'] else '解锁'}了商店。")
        if action in {"field", "bench"}:
            values = _parse_indices(arguments)
            if not values:
                return respond(state, "用法：/上阵 备战编号 [首发位]，例如 /上阵 6 2")
            found = _find_unit(player, values[0])
            if found is None or found[0] != "备战":
                return respond(state, "第一个编号必须是 /阵容 中的备战席编号")
            bench_index = found[1]
            board_index = (
                values[1] - 1
                if len(values) >= 2 and 1 <= values[1] <= STARTER_COUNT
                else min(range(STARTER_COUNT), key=lambda index: _unit_power(player["board"][index]))
            )
            incoming = player["bench"][bench_index]
            outgoing = player["board"][board_index]
            player["board"][board_index] = incoming
            player["bench"][bench_index] = outgoing
            text = (
                f"{display_name} 用 {CARD_BY_ID[str(incoming['card_id'])]['name']} "
                f"替换首发 {board_index + 1} 的 {CARD_BY_ID[str(outgoing['card_id'])]['name']}。"
            )
            story = _story(state, "lineup_change", text, {"person_key": person_key})
            return respond(state, text, stories=[story])
        if action == "sell":
            values = _parse_indices(arguments)
            if len(values) != 1:
                return respond(state, "用法：/出售 备战编号")
            found = _find_unit(player, values[0])
            if found is None:
                return respond(state, "没有这个阵容编号")
            if found[0] == "首发":
                return respond(state, "首发必须保持 5 人；先用 /上阵 备战编号 首发位 完成替换")
            unit = player["bench"].pop(found[1])
            card = CARD_BY_ID[str(unit["card_id"])]
            refund = int(card["cost"]) * int(unit["copies"])
            player["gold"] += refund
            state["pool"][card["id"]] += int(unit["copies"])
            return respond(state, f"{display_name} 出售 {card['name']}，返还 {refund} 摩拉。")

        if action == "ready":
            if person_key not in state.get("ready_keys", []):
                if state.get("phase") in {"semifinal_ready", "final_ready"}:
                    return respond(state, f"{display_name} 已不在当前淘汰赛对阵中，不需要准备。")
                return respond(state, "当前阶段不需要你确认 /结束回合。")
            player["ready"] = True
            waiting = _ready_waiting(state)
            if waiting:
                names = "、".join(state["players"][key]["display_name"] for key in waiting)
                return respond(state, f"{display_name} 准备完成；仍在等待：{names}。")

            phase = str(state.get("phase"))
            stories: list[dict[str, Any]] = []
            battles: list[dict[str, Any]] = []
            if phase in {"lineup_prep", "training_manage"}:
                parts, stories, battles = _settle_training_round(state, event_id)
                return respond(state, parts, stories=stories, battles=battles)
            if phase == "training_complete_manage":
                parts = _start_group_parts(state)
                return respond(state, parts)
            if phase == "group_ready":
                parts, stories, battles = _settle_current_match(state, event_id)
                state["group_match_cursor"] = int(state.get("group_match_cursor", 0)) + 1
                state["last_completed_group_round"] = int(state["current_match"]["round"])
                state["phase"] = "group_manage"
                _prepare_new_shops(state, "group")
                _reset_ready(state, _human_keys(state))
                parts.append("本场结束。可以 D 牌、调阵容；所有真人发送 /结束回合 后进入下一场。")
                return respond(state, parts, stories=stories, battles=battles)
            if phase == "group_manage":
                cursor = int(state.get("group_match_cursor", 0))
                matches = list(state.get("group_matches", []))
                last_round = int(state.get("last_completed_group_round", 0))
                next_round = int(matches[cursor]["round"]) if cursor < len(matches) else 999
                if (
                    not state.get("special_event_done")
                    and last_round in {1, 2}
                    and next_round > last_round
                ):
                    parts, stories = _special_event_parts(state, event_id)
                    return respond(state, parts, stories=stories)
                if cursor < len(matches):
                    parts = _set_current_match(state, matches[cursor])
                    return respond(state, parts)
                state["playoff_matches"] = _playoff_matches_from_rankings(state)
                state["playoff_cursor"] = 0
                parts = [_standings_part(state), _playoff_pairings_part(state)]
                if state["playoff_matches"]:
                    parts.extend(_set_current_match(state, state["playoff_matches"][0]))
                return respond(state, parts)
            if phase == "special_manage":
                cursor = int(state.get("group_match_cursor", 0))
                matches = list(state.get("group_matches", []))
                if cursor < len(matches):
                    return respond(state, _set_current_match(state, matches[cursor]))
                return respond(state, "挑战结束，但没有后续小组赛对阵。")
            if phase in {"semifinal_ready", "final_ready"}:
                parts, stories, battles = _settle_current_match(state, event_id)
                match = dict(state["current_match"])
                winner_key = str(
                    battles[0]["result"]["winner_key"]
                    if battles else state["current_match"]["pair"][0]
                )
                if match["stage"] == "final":
                    state["champion_key"] = winner_key
                    parts.extend(_finish_tournament_parts(state))
                    return respond(state, parts, stories=stories, battles=battles)
                winners = list(state.get("semifinal_winners", []))
                winners.append(winner_key)
                state["semifinal_winners"] = winners
                state["playoff_cursor"] = int(state.get("playoff_cursor", 0)) + 1
                cursor = int(state["playoff_cursor"])
                playoff_matches = list(state.get("playoff_matches", []))
                if cursor < len(playoff_matches):
                    parts.extend(_set_current_match(state, playoff_matches[cursor]))
                    return respond(state, parts, stories=stories, battles=battles)
                final_match = {
                    "stage": "final",
                    "round": 1,
                    "match": 1,
                    "pair": winners[:2],
                    "best_of": MATCH_BEST_OF["final"],
                }
                state["finalists"] = winners[:2]
                parts.append(
                    f"半决赛全部结束，胜者进入 BO{MATCH_BEST_OF['final']} 总决赛。"
                )
                parts.extend(_set_current_match(state, final_match))
                if not state.get("ready_keys"):
                    final_parts, final_stories, final_battles = _settle_current_match(
                        state,
                        event_id + "-auto-final",
                    )
                    final_winner = str(final_battles[0]["result"]["winner_key"])
                    state["champion_key"] = final_winner
                    final_parts.extend(_finish_tournament_parts(state))
                    parts.extend(final_parts)
                    stories.extend(final_stories)
                    battles.extend(final_battles)
                return respond(state, parts, stories=stories, battles=battles)
            return respond(state, "当前阶段已经准备完成，请等待下一步。")

        if action in {"settle", "force_settle"}:
            return respond(state, "0.6.6 起赛事由 /结束回合 自动推进，不再需要主持人手动结算。")
        if action == "cancel":
            if person_key != state["host_person_key"]:
                return respond(state, f"只有主持人 {state['host_display_name']} 可以取消赛事")
            state["status"] = "cancelled"
            state["phase"] = "cancelled"
            text = f"{state['event_title']} 已由主持人取消；已完成剧情仍保留在档案。"
            story = _story(state, "tournament_cancelled", text)
            return respond(state, text, stories=[story])
        return respond(state, self.rules())