Upload folder using huggingface_hub

compiler/id_converter.py

@@ -0,0 +1,75 @@
+import json
+import os
+import sys
+
+
+def load_db():
+    compiled_path = "engine/data/cards_compiled.json"
+    if not os.path.exists(compiled_path):
+        print(f"Error: {compiled_path} not found.")
+        return None
+    try:
+        with open(compiled_path, "r", encoding="utf-8-sig") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Load Error: {e}")
+        return None
+
+
+def convert(query):
+    full_db = load_db()
+    if not full_db:
+        return
+
+    # Handle member_db and live_db
+    member_db = full_db.get("member_db", {})
+    live_db = full_db.get("live_db", {})
+    dbs = [member_db, live_db]
+
+    print(f"Total cards loaded: Members {len(member_db)}, Lives {len(live_db)}")
+
+    # Try numeric ID
+    if query.isdigit():
+        for db in dbs:
+            if query in db:
+                card = db[query]
+                print(f"ID {query} -> {card.get('card_no')} ({card.get('name')})")
+                abis = card.get("abilities", [])
+                print(f"Parsed {len(abis)} abilities.")
+                for i, a in enumerate(abis):
+                    print(f"  [{i}] Trig:{a.get('trigger')} | {a.get('raw_text')}")
+                return
+
+    # Try Card No or Search
+    matches = []
+    for db in dbs:
+        for cid, card in db.items():
+            card_no = str(card.get("card_no", ""))
+            name = str(card.get("name", ""))
+
+            if card_no.lower() == query.lower():
+                print(f"Card No {card_no} -> ID {cid} ({name})")
+                abis = card.get("abilities", [])
+                print(f"Parsed {len(abis)} abilities.")
+                for i, a in enumerate(abis):
+                    print(f"  [{i}] Trig:{a.get('trigger')} | {a.get('raw_text')}")
+                return
+
+            if query.lower() in card_no.lower() or query in name:
+                matches.append((cid, card_no, name))
+
+    if matches:
+        print(f"Found {len(matches)} matches:")
+        for m in matches[:15]:
+            print(f"  ID {m[0]} | {m[1]} | {m[2]}")
+        if len(matches) > 15:
+            print("  ...")
+    else:
+        print(f"No matches found for '{query}'.")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: uv run python compiler/id_converter.py <ID or CardNo>")
+    else:
+        convert(sys.argv[1])

compiler/main.py

@@ -0,0 +1,338 @@
+import os
+import sys
+
+# Add project root to path to allow imports if running as script
+if __name__ == "__main__":
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+import argparse
+import json
+
+import numpy as np
+from pydantic import TypeAdapter
+
+# from compiler.parser import AbilityParser
+from engine.models.card import EnergyCard, LiveCard, MemberCard
+
+CHAR_MAP = {
+    "高坂 穂乃果": 1,
+    "絢瀬 絵里": 2,
+    "南 ことり": 3,
+    "園田 海未": 4,
+    "星空 凛": 5,
+    "西木野 真姫": 6,
+    "東條 希": 7,
+    "小泉 花陽": 8,
+    "矢澤 にこ": 9,
+    "高海 千歌": 11,
+    "桜内 梨子": 12,
+    "松浦 果南": 13,
+    "黒澤 ダイヤ": 14,
+    "渡辺 曜": 15,
+    "津島 善子": 16,
+    "国木田 花丸": 17,
+    "小原 鞠莉": 18,
+    "黒澤 ルビィ": 19,
+    "上原 歩夢": 21,
+    "中須 かすみ": 22,
+    "桜坂 しずく": 23,
+    "朝香 果林": 24,
+    "宮下 愛": 25,
+    "近江 彼方": 26,
+    "優木 せつ菜": 27,
+    "エマ・ヴェルデ": 28,
+    "天王寺 璃奈": 29,
+    "三船 栞子": 30,
+    "ミア・テイラー": 31,
+    "鐘 嵐珠": 32,
+    "高咲 侑": 33,
+    "澁谷 かのん": 41,
+    "唐 可可": 42,
+    "嵐 千砂都": 43,
+    "平安名 すみれ": 44,
+    "葉月 恋": 45,
+    "桜小路 きな子": 46,
+    "米女 メイ": 47,
+    "若菜 四季": 48,
+    "鬼塚 夏美": 49,
+    "ウィーン・マルガレーテ": 50,
+    "鬼塚 冬毬": 51,
+    "日野下 花帆": 61,
+    "村野 さやか": 62,
+    "乙宗 梢": 63,
+    "夕霧 綴理": 64,
+    "大沢 瑠璃乃": 65,
+    "藤島 慈": 66,
+    "百生 吟子": 67,
+    "徒町 小鈴": 68,
+    "安養寺 姫芽": 69,
+}
+
+
+def compile_cards(input_path: str, output_path: str):
+    print(f"Loading raw cards from {input_path}...")
+    with open(input_path, "r", encoding="utf-8") as f:
+        raw_data = json.load(f)
+
+    compiled_data = {"member_db": {}, "live_db": {}, "energy_db": {}, "meta": {"version": "1.0", "source": input_path}}
+
+    sorted_keys = sorted(raw_data.keys())
+    m_idx = 0
+    l_idx = 30000
+    e_idx = 40000
+
+    success_count = 0
+    errors = []
+
+    # Pre-create adapters
+    member_adapter = TypeAdapter(MemberCard)
+    live_adapter = TypeAdapter(LiveCard)
+    energy_adapter = TypeAdapter(EnergyCard)
+
+    for key in sorted_keys:
+        item = raw_data[key]
+        ctype = item.get("type", "")
+        # print(f"DEBUG: Processing {key} Type: '{ctype}'")
+        if "ライブ" in ctype or "Live" in ctype:
+            print(f"FOUND LIVE: {key} Type: '{ctype}'")
+        elif "Member" not in ctype and "メンバー" not in ctype and "Energy" not in ctype and "エネルギー" not in ctype:
+            print(f"UNKNOWN TYPE: {key} Type: '{ctype}'")
+
+        # Collect variants from rare_list
+        variants = [{"card_no": key, "name": item.get("name", ""), "data": item}]
+        if "rare_list" in item and isinstance(item["rare_list"], list):
+            for r in item["rare_list"]:
+                v_no = r.get("card_no")
+                if v_no and v_no != key:
+                    print(f"DEBUG: Found variant {v_no} in rare_list of {key}")
+                    # Create a variant that inherits base data but overrides metadata
+                    v_item = item.copy()
+                    v_item.update(r)
+                    variants.append({"card_no": v_no, "name": r.get("name", item.get("name", "")), "data": v_item})
+
+        for v in variants:
+            v_key = v["card_no"]
+            v_data = v["data"]
+            try:
+                if ctype == "メンバー":
+                    m_card = parse_member(m_idx, v_key, v_data)
+                    compiled_item = member_adapter.dump_python(m_card, mode="json")
+                    compiled_data["member_db"][str(m_idx)] = compiled_item
+                    m_idx += 1
+                elif ctype == "ライブ":
+                    l_card = parse_live(l_idx, v_key, v_data)
+                    compiled_data["live_db"][str(l_idx)] = live_adapter.dump_python(l_card, mode="json")
+                    l_idx += 1
+                else:
+                    # Treat everything else (Energy, etc.) as basic cards to preserve IDs for decks
+                    e_card = parse_energy(e_idx, v_key, v_data)
+                    compiled_data["energy_db"][str(e_idx)] = energy_adapter.dump_python(e_card, mode="json")
+                    e_idx += 1
+                success_count += 1
+            except Exception as e:
+                errors.append(f"Error parsing card {v_key}: {e}")
+
+    print(f"Compilation complete. Processed {success_count} cards.")
+    if errors:
+        print(f"Encountered {len(errors)} errors. See compiler_errors.log for details.")
+        with open("compiler_errors.log", "w", encoding="utf-8") as f_err:
+            for err_msg in errors:
+                f_err.write(f"- {err_msg}\n")
+
+    # Write output
+    print(f"Writing compiled data to {output_path}...")
+    with open(output_path, "w", encoding="utf-8") as f:
+        json.dump(compiled_data, f, ensure_ascii=False, indent=2)
+    print("Done.")
+
+
+def _resolve_img_path(data: dict) -> str:
+    # Use cards_webp as the flattened source
+    img_path = str(data.get("_img", ""))
+    if img_path:
+        filename = os.path.basename(img_path)
+        if filename.lower().endswith(".png"):
+            filename = filename[:-4] + ".webp"
+        return f"cards_webp/{filename}"
+
+    raw_url = str(data.get("img", ""))
+    if raw_url:
+        filename = os.path.basename(raw_url)
+        if filename.lower().endswith(".png"):
+            filename = filename[:-4] + ".webp"
+        return f"cards_webp/{filename}"
+
+    return raw_url
+
+
+from compiler.parser_v2 import AbilityParserV2
+
+# Initialize parser globally
+_v2_parser = AbilityParserV2()
+
+# Load manual overrides
+MANUAL_OVERRIDES_PATH = "data/manual_pseudocode.json"
+_manual_overrides = {}
+if os.path.exists(MANUAL_OVERRIDES_PATH):
+    print(f"Loading manual overrides from {MANUAL_OVERRIDES_PATH}")
+    with open(MANUAL_OVERRIDES_PATH, "r", encoding="utf-8") as f:
+        _manual_overrides = json.load(f)
+
+
+def parse_member(card_id: int, card_no: str, data: dict) -> MemberCard:
+    spec = data.get("special_heart", {})
+    # Use manual override if present
+    override_data = _manual_overrides.get(card_no, {})
+
+    # Use manual pseudo/text if available, else raw data
+    if "pseudocode" in override_data:
+        raw_ability = str(override_data["pseudocode"])
+    else:
+        raw_ability = str(data.get("pseudocode", data.get("ability", "")))
+
+    abilities = _v2_parser.parse(raw_ability)
+
+    for ab in abilities:
+        try:
+            ab.bytecode = ab.compile()
+        except Exception as e:
+            print(f"Warning: Failed to compile bytecode for {card_no} ability: {e}")
+
+    return MemberCard(
+        card_id=card_id,
+        card_no=card_no,
+        name=str(data.get("name", "Unknown")),
+        cost=data.get("cost", 0),
+        hearts=parse_hearts(data.get("base_heart", {})),
+        blade_hearts=parse_blade_hearts(data.get("blade_heart", {})),
+        blades=data.get("blade", 0),
+        groups=data.get("series", ""),  # Validator will handle string -> List[Group]
+        units=data.get("unit", ""),  # Validator will handle string -> List[Unit]
+        abilities=abilities,
+        img_path=_resolve_img_path(data),
+        ability_text=raw_ability,
+        original_text=str(data.get("ability", "")),
+        volume_icons=spec.get("score", 0),
+        draw_icons=spec.get("draw", 0),
+        char_id=CHAR_MAP.get(str(data.get("name", "")), 0),
+        faq=data.get("faq", []),
+    )
+
+
+def parse_live(card_id: int, card_no: str, data: dict) -> LiveCard:
+    spec = data.get("special_heart", {})
+    # Use manual override if present
+    override_data = _manual_overrides.get(card_no, {})
+    # Prioritize 'pseudocode' over 'ability'
+    raw_ability = str(override_data.get("pseudocode", data.get("pseudocode", data.get("ability", ""))))
+    abilities = _v2_parser.parse(raw_ability)
+    for ab in abilities:
+        try:
+            ab.bytecode = ab.compile()
+        except Exception as e:
+            print(f"Warning: Failed to compile bytecode for {card_no} ability: {e}")
+
+    return LiveCard(
+        card_id=card_id,
+        card_no=card_no,
+        name=str(data.get("name", "Unknown")),
+        score=data.get("score", 0),
+        required_hearts=parse_live_reqs(data.get("need_heart", {})),
+        abilities=abilities,
+        groups=data.get("series", ""),
+        units=data.get("unit", ""),
+        img_path=_resolve_img_path(data),
+        ability_text=raw_ability,
+        original_text=str(data.get("ability", "")),
+        volume_icons=spec.get("score", 0),
+        draw_icons=spec.get("draw", 0),
+        blade_hearts=parse_blade_hearts(data.get("blade_heart", {})),
+        faq=data.get("faq", []),
+    )
+
+
+def parse_energy(card_id: int, card_no: str, data: dict) -> EnergyCard:
+    return EnergyCard(
+        card_id=card_id,
+        card_no=card_no,
+        name=str(data.get("name", "Energy")),
+        img_path=_resolve_img_path(data),
+        ability_text=str(data.get("ability", "")),
+        original_text=str(data.get("ability", "")),
+        rare=str(data.get("rare", "N")),
+    )
+
+
+def parse_hearts(heart_dict: dict) -> np.ndarray:
+    hearts = np.zeros(7, dtype=np.int32)
+    if not heart_dict:
+        return hearts
+    for k, v in heart_dict.items():
+        if k.startswith("heart"):
+            try:
+                num_str = k.replace("heart", "")
+                if num_str == "0":  # Handle heart0 as ANY/STAR
+                    hearts[6] = int(v)
+                    continue
+                idx = int(num_str) - 1
+                if 0 <= idx < 6:
+                    hearts[idx] = int(v)
+            except ValueError:
+                pass
+        elif k in ["common", "any", "star"]:
+            hearts[6] = int(v)
+    return hearts
+
+
+def parse_blade_hearts(heart_dict: dict) -> np.ndarray:
+    hearts = np.zeros(7, dtype=np.int32)
+    if not heart_dict:
+        return hearts
+    for k, v in heart_dict.items():
+        if k == "b_all":
+            hearts[6] = int(v)
+        elif k.startswith("b_heart"):
+            try:
+                idx = int(k.replace("b_heart", "")) - 1
+                if 0 <= idx < 6:
+                    hearts[idx] = int(v)
+            except ValueError:
+                pass
+    return hearts
+
+
+def parse_live_reqs(req_dict: dict) -> np.ndarray:
+    # Use parse_hearts directly as it now handles 7 elements correctly
+    return parse_hearts(req_dict)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input", default="data/cards.json", help="Path to raw cards.json")
+    parser.add_argument("--output", default="data/cards_compiled.json", help="Output path")
+    args = parser.parse_args()
+
+    # Resolve paths relative to cwd if needed, or assume running from root
+    compile_cards(args.input, args.output)
+
+    # Copy to both data/ and engine/data/ for compatibility with all scripts
+    import shutil
+
+    root_data_path = os.path.join(os.getcwd(), "data", "cards_compiled.json")
+    engine_data_path = os.path.join(os.getcwd(), "engine", "data", "cards_compiled.json")
+
+    # Sync to root data/
+    if os.path.abspath(args.output) != os.path.abspath(root_data_path):
+        try:
+            shutil.copy(args.output, root_data_path)
+            print(f"Copied compiled data to {root_data_path}")
+        except Exception as e:
+            print(f"Warning: Failed to copy to root data directory: {e}")
+
+    # Sync to engine/data/ to keep paths consistent
+    try:
+        os.makedirs(os.path.dirname(engine_data_path), exist_ok=True)
+        shutil.copy(root_data_path, engine_data_path)
+        print(f"Synced compiled data to {engine_data_path}")
+    except Exception as e:
+        print(f"Warning: Failed to sync to engine/data directory: {e}")

compiler/parser.py

@@ -0,0 +1,8 @@
+from .parser_v2 import AbilityParserV2
+from .parser_v2 import parse_ability_text as _parse_ability_text
+
+
+class AbilityParser(AbilityParserV2):
+    @staticmethod
+    def parse_ability_text(text: str):
+        return _parse_ability_text(text)

compiler/parser_v2.py

@@ -0,0 +1,1702 @@
+# -*- coding: utf-8 -*-
+"""New multi-pass ability parser using the pattern registry system.
+
+This parser replaces the legacy 3500-line spaghetti parser with a clean,
+modular architecture based on:
+1. Declarative patterns organized by phase
+2. Multi-pass parsing: Trigger → Conditions → Effects → Modifiers
+3. Proper optionality handling (fixes the is_optional bug)
+"""
+
+import copy
+import json
+import re
+from typing import Any, Dict, List, Match, Optional, Tuple
+
+from engine.models.ability import (
+    Ability,
+    AbilityCostType,
+    Condition,
+    ConditionType,
+    Cost,
+    Effect,
+    EffectType,
+    TargetType,
+    TriggerType,
+)
+
+from .patterns.base import PatternPhase
+from .patterns.registry import PatternRegistry, get_registry
+
+
+class AbilityParserV2:
+    """Multi-pass ability parser using pattern registry."""
+
+    def __init__(self, registry: Optional[PatternRegistry] = None):
+        self.registry = registry or get_registry()
+
+    def parse(self, text: str) -> List[Ability]:
+        """Parse ability text into structured Ability objects."""
+        # Detect pseudocode format
+        triggers = ["TRIGGER:", "CONDITION:", "EFFECT:", "COST:"]
+        if any(text.strip().startswith(kw) for kw in triggers):
+            return self._parse_pseudocode_block(text)
+
+        # Preprocessing
+        text = self._preprocess(text)
+
+        # Split into sentences
+        sentences = self._split_sentences(text)
+
+        # Group sentences into ability blocks
+        blocks = []
+        current_block = []
+        for i, sentence in enumerate(sentences):
+            if i > 0 and self._is_continuation(sentence, i):
+                current_block.append(sentence)
+            else:
+                if current_block:
+                    blocks.append(" ".join(current_block))
+                current_block = [sentence]
+        if current_block:
+            blocks.append(" ".join(current_block))
+
+        abilities = []
+        for block in blocks:
+            ability = self._parse_block(block)
+            if ability:
+                abilities.append(ability)
+
+        return abilities
+
+    def _parse_block(self, block: str) -> Optional[Ability]:
+        """Parse a single combined ability block."""
+        # Split into cost and effect parts
+        colon_idx = block.find("：")
+        if colon_idx == -1:
+            colon_idx = block.find(":")
+
+        if colon_idx != -1:
+            cost_part = block[:colon_idx].strip()
+            effect_part = block[colon_idx + 1 :].strip()
+        else:
+            cost_part = ""
+            effect_part = block
+
+        # === PASS 1: Extract trigger ===
+        trigger, trigger_match = self._extract_trigger(block)
+
+        # Mask trigger text from effect part to avoid double-matching
+        # (e.g. "when placed in discard" shouldn't trigger "place in discard")
+        effective_effect_part = effect_part
+        if trigger_match:
+            # Standard Japanese card formatting: [Trigger/Condition]とき、[Effect]
+            # Or [Trigger/Condition]：[Effect]
+            # If we see "とき", everything before it is usually trigger/condition
+            toki_idx = effective_effect_part.find("とき")
+            if toki_idx == -1:
+                toki_idx = effective_effect_part.find("場合")
+
+            if toki_idx != -1:
+                # Mask everything up to "とき" or "場合" (plus the word itself)
+                # BUT ONLY if it's in the same sentence (no punctuation in between)
+                preceding = effective_effect_part[:toki_idx]
+                if "。" in preceding:
+                    toki_idx = -1
+
+            if toki_idx != -1:
+                mask_end = toki_idx + 2  # Length of "とき" or "場合"
+                effective_effect_part = " " * mask_end + effective_effect_part[mask_end:]
+            else:
+                # Fallback: just mask the trigger match itself
+                start, end = trigger_match.span()
+                if start >= (len(block) - len(effect_part)):
+                    rel_start = start - (len(block) - len(effect_part))
+                    rel_end = end - (len(block) - len(effect_part))
+                    if rel_start >= 0 and rel_end <= len(effect_part):
+                        effective_effect_part = (
+                            effect_part[:rel_start] + " " * (rel_end - rel_start) + effect_part[rel_end:]
+                        )
+
+        # === PASS 2: Extract conditions ===
+        # Scan the entire block for conditions as they can appear anywhere
+        conditions = self._extract_conditions(block)
+
+        # === PASS 3: Extract effects ===
+        # Only extract effects from the masked part to avoid trigger/cost confusion
+        effects = self._extract_effects(effective_effect_part)
+
+        # === PASS 5: Extract costs ===
+        costs = self._extract_costs(cost_part)
+
+        # Determine Trigger and construct Ability
+        if trigger == TriggerType.NONE and not (effects or conditions or costs):
+            return None
+
+        final_trigger = trigger
+        if final_trigger == TriggerType.NONE:
+            # Only default to CONSTANT if we have some indicators of an ability
+            # (to avoid splitting errors defaulting to Constant)
+            has_ability_indicators = any(
+                kw in block
+                for kw in [
+                    "引",
+                    "スコア",
+                    "プラス",
+                    "＋",
+                    "ブレード",
+                    "ハート",
+                    "控",
+                    "戻",
+                    "エネ",
+                    "デッキ",
+                    "山札",
+                    "見る",
+                    "公開",
+                    "選ぶ",
+                    "扱",
+                    "得る",
+                    "移動",
+                ]
+            )
+            if has_ability_indicators:
+                final_trigger = TriggerType.CONSTANT
+            else:
+                return None
+
+        ability = Ability(raw_text=block, trigger=final_trigger, effects=effects, conditions=conditions, costs=costs)
+
+        # === PASS 4: Apply modifiers ===
+        # Scan the entire block for modifiers (OPT, optionality, etc.)
+        modifiers = self._extract_modifiers(block)
+        self._apply_modifiers(ability, modifiers)
+
+        # === PASS 6: Handle "Choose Player" transformation ===
+        # If the ability starts with "自分か相手を選ぶ", transform following effects into SELECT_MODE
+        if "自分か相手を選ぶ" in block and len(ability.effects) > 0:
+            original_effects = []
+            # Find the "choose player" dummy effect (META_RULE) if present and remove it
+            other_effects = []
+            for eff in ability.effects:
+                if eff.effect_type == EffectType.META_RULE and eff.params.get("target") == "PLAYER_SELECT":
+                    continue
+                other_effects.append(eff)
+
+            if other_effects:
+                # Option 1: Yourself
+                self_effects = []
+                for eff in other_effects:
+                    new_eff = copy.deepcopy(eff)
+                    new_eff.target = TargetType.SELF
+                    self_effects.append(new_eff)
+
+                # Option 2: Opponent
+                opp_effects = []
+                for eff in other_effects:
+                    new_eff = copy.deepcopy(eff)
+                    new_eff.target = TargetType.OPPONENT
+                    opp_effects.append(new_eff)
+
+                # Replace effects with a single SELECT_MODE
+                ability.effects = [
+                    Effect(
+                        EffectType.SELECT_MODE,
+                        value=1,
+                        target=TargetType.SELF,
+                        params={"options_text": ["自分", "相手"]},
+                        modal_options=[self_effects, opp_effects],
+                    )
+                ]
+
+        return ability
+
+    # =========================================================================
+    # Preprocessing
+    # =========================================================================
+
+    def _preprocess(self, text: str) -> str:
+        """Normalize text for parsing."""
+        text = text.replace("<br>", "\n")
+        return text
+
+    def _split_sentences(self, text: str) -> List[str]:
+        """Split text into individual sentences."""
+        # Split by newlines first
+        blocks = re.split(r"\\n|\n", text)
+
+        sentences = []
+        for block in blocks:
+            block = block.strip()
+            if not block:
+                continue
+            # Split on Japanese period, keeping the period
+            parts = re.split(r"(。)\s*", block)
+            # Reconstruct sentences with periods
+            current = ""
+            for part in parts:
+                if part == "。":
+                    current += part
+                    if current.strip():
+                        sentences.append(current.strip())
+                    current = ""
+                else:
+                    current = part
+            if current.strip():
+                sentences.append(current.strip())
+
+        return sentences
+
+    def _is_continuation(self, sentence: str, index: int) -> bool:
+        """Check if sentence is a continuation of previous ability."""
+        # First sentence can't be a continuation
+        if index == 0:
+            return False
+
+        # Explicit trigger icons should NEVER be continuations
+        if any(
+            icon in sentence
+            for icon in ["{{live_success", "{{live_start", "{{toujyou", "{{kidou", "{{jyouji", "{{jidou"]
+        ):
+            return False
+
+        # Check for continuation markers
+        continuation_markers = [
+            "・",
+            "-",
+            "－",
+            "回答が",
+            "選んだ場合",
+            "条件が",
+            "それ以外",
+            "その",
+            "それら",
+            "残り",
+            "そし",
+            "その後",
+            "そこから",
+            "山札",
+            "デッキ",
+            "もよい",
+            "を自分",
+            "ライブ終了時まで",
+            "この能力",
+            "この効果",
+            "（",
+            "(",
+            "そうした場合",
+            "」",
+            "』",
+            "）」",
+            "）",
+            ")",
+            "ただし",
+            "かつ",
+            "または",
+            "もしくは",
+            "および",
+            "代わりに",
+            "このメンバー",
+            "そのメンバー",
+            "選んだ",
+            "選んだエリア",
+            "自分は",
+            "相手は",
+        ]
+
+        # Check if it starts with any common phrase that usually continues an ability
+        for marker in continuation_markers:
+            if sentence.startswith(marker):
+                return True
+
+        # Special case: "その" or "プレイヤー" often appears slightly after "自分は"
+        if "その" in sentence[:10] or "プレイヤー" in sentence[:10]:
+            return True
+
+        return False
+
+    def _extend_ability(self, ability: Ability, sentence: str):
+        """Extend an existing ability with content from a continuation sentence."""
+        # Extract additional effects
+        effects = self._extract_effects(sentence)
+        ability.effects.extend(effects)
+
+        # Extract additional conditions
+        conditions = self._extract_conditions(sentence)
+        for cond in conditions:
+            if cond not in ability.conditions:
+                ability.conditions.append(cond)
+
+        # Apply modifiers
+        modifiers = self._extract_modifiers(sentence)
+        self._apply_modifiers(ability, modifiers)
+
+        # Update raw text
+        ability.raw_text += " " + sentence
+
+    # =========================================================================
+    # Pass 1: Trigger Extraction
+    # =========================================================================
+
+    def _extract_trigger(self, sentence: str) -> Tuple[TriggerType, Optional[Match]]:
+        """Extract trigger type and match object from sentence."""
+        result = self.registry.match_first(sentence, PatternPhase.TRIGGER)
+        if result:
+            pattern, match, data = result
+            type_str = data.get("type", "")
+            return self._resolve_trigger_type(type_str), match
+        return TriggerType.NONE, None
+
+    def _resolve_trigger_type(self, type_str: str) -> TriggerType:
+        """Convert type string to TriggerType enum."""
+        mapping = {
+            "TriggerType.ON_PLAY": TriggerType.ON_PLAY,
+            "TriggerType.ON_LIVE_START": TriggerType.ON_LIVE_START,
+            "TriggerType.ON_LIVE_SUCCESS": TriggerType.ON_LIVE_SUCCESS,
+            "TriggerType.ACTIVATED": TriggerType.ACTIVATED,
+            "TriggerType.CONSTANT": TriggerType.CONSTANT,
+            "TriggerType.ON_LEAVES": TriggerType.ON_LEAVES,
+            "TriggerType.ON_REVEAL": TriggerType.ON_REVEAL,
+            "TriggerType.TURN_START": TriggerType.TURN_START,
+            "TriggerType.TURN_END": TriggerType.TURN_END,
+        }
+        return mapping.get(type_str, TriggerType.NONE)
+
+    # =========================================================================
+    # Pass 2: Condition Extraction
+    # =========================================================================
+
+    def _extract_conditions(self, sentence: str) -> List[Condition]:
+        """Extract all conditions from sentence."""
+        conditions = []
+        results = self.registry.match_all(sentence, PatternPhase.CONDITION)
+
+        for pattern, match, data in results:
+            cond_type = self._resolve_condition_type(data.get("type", ""))
+            if cond_type is not None:
+                params = data.get("params", {}).copy()
+
+                # Use extracted value if not already in params
+                if "value" in data and "min" not in params:
+                    params["min"] = data["value"]
+                elif "min" not in params and match.lastindex:
+                    try:
+                        # Fallback for simple numeric patterns with one group
+                        params["min"] = int(match.group(1))
+                    except (ValueError, IndexError):
+                        pass
+
+                conditions.append(Condition(cond_type, params))
+
+        return conditions
+
+    def _resolve_condition_type(self, type_str: str) -> Optional[ConditionType]:
+        """Convert type string to ConditionType enum."""
+        if not type_str:
+            return None
+        name = type_str.replace("ConditionType.", "")
+        print(f"DEBUG_LOUD: Resolving '{type_str}' -> '{name}'")
+
+        # Debug members
+        # if name == "COUNT_STAGE":
+        #    print(f"DEBUG_MEMBERS: {[m.name for m in ConditionType]}")
+
+        try:
+            val = ConditionType[name]
+            print(f"DEBUG_LOUD: SUCCESS {name} -> {val}")
+            return val
+        except KeyError:
+            print(f"DEBUG_LOUD: FAILED {name}")
+            return None
+
+    # =========================================================================
+    # Pass 3: Effect Extraction
+    # =========================================================================
+
+    def _extract_effects(self, sentence: str) -> List[Effect]:
+        """Extract all effects from sentence."""
+        effects = []
+        results = self.registry.match_all(sentence, PatternPhase.EFFECT)
+
+        # Debug: Show what's being parsed
+        if "DRAW(" in sentence:
+            print(f"DEBUG_EFFECTS: Parsing sentence with DRAW: '{sentence[:50]}'")
+            print(f"DEBUG_EFFECTS: Got {len(results)} pattern matches")
+            for pattern, match, data in results:
+                print(f"DEBUG_EFFECTS: Pattern={pattern.name}, Data={data}")
+
+        for pattern, match, data in results:
+            eff_type = self._resolve_effect_type(data.get("type", ""))
+            if eff_type is not None:  # Use 'is not None' because EffectType.DRAW = 0 is falsy
+                value = data.get("value", 1)
+                params = data.get("params", {}).copy()
+
+                # Check for dynamic value condition
+                value_cond = ConditionType.NONE
+                if "value_cond" in data:
+                    vc_str = data["value_cond"]
+                    # If it's a string, try to resolve it
+                    if isinstance(vc_str, str):
+                        resolved_vc = self._resolve_condition_type(vc_str)
+                        if resolved_vc:
+                            value_cond = resolved_vc
+                    elif isinstance(vc_str, int):
+                        value_cond = ConditionType(vc_str)
+
+                # Special case for "一番上" (top of deck) which means 1 card
+                if "一番上" in sentence and value == 1:
+                    pass  # Value 1 is already default
+
+                # Determine target
+                target = self._determine_target(sentence, params)
+
+                effects.append(Effect(eff_type, value, value_cond, target, params))
+
+        return effects
+
+    def _resolve_effect_type(self, type_str: str) -> Optional[EffectType]:
+        """Convert type string to EffectType enum."""
+        if not type_str:
+            return None
+        name = type_str.replace("EffectType.", "")
+        try:
+            return EffectType[name]
+        except KeyError:
+            return None
+
+    def _determine_target(self, sentence: str, params: Dict[str, Any]) -> TargetType:
+        """Determine target type from sentence context."""
+        if "相手" in sentence:
+            return TargetType.OPPONENT
+        if "自分と相手" in sentence:
+            return TargetType.ALL_PLAYERS
+        if "控え室" in sentence:
+            return TargetType.CARD_DISCARD
+        if "手札" in sentence:
+            return TargetType.CARD_HAND
+        return TargetType.PLAYER
+
+    # =========================================================================
+    # Pass 4: Modifier Extraction & Application
+    # =========================================================================
+
+    def _extract_modifiers(self, sentence: str) -> Dict[str, Any]:
+        """Extract all modifiers from sentence."""
+        modifiers = {}
+        results = self.registry.match_all(sentence, PatternPhase.MODIFIER)
+
+        for pattern, match, data in results:
+            params = data.get("params", {})
+
+            # Special handling for target_name accumulation
+            if "target_name" in params:
+                if "target_names" not in modifiers:
+                    modifiers["target_names"] = []
+                modifiers["target_names"].append(params["target_name"])
+                # Remove target_name from params to avoid overwriting invalid data
+                params = {k: v for k, v in params.items() if k != "target_name"}
+
+            # Special handling for group accumulation
+            if "group" in params:
+                if "groups" not in modifiers:
+                    modifiers["groups"] = []
+                modifiers["groups"].append(params["group"])
+                # Note: We do NOT remove "group" from params here because we want the last one
+                # to persist in modifiers["group"] for singular backward compatibility,
+                # which modifiers.update(params) below will handle.
+
+            modifiers.update(params)
+
+            # Extract numeric values if present
+            if match.lastindex:
+                try:
+                    if "cost_max" not in modifiers and "コスト" in pattern.name:
+                        modifiers["cost_max"] = int(match.group(1))
+                    if "multiplier" not in modifiers and "multiplier" in pattern.name:
+                        modifiers["multiplier_value"] = int(match.group(1))
+                except (ValueError, IndexError):
+                    pass
+
+        return modifiers
+
+    def _apply_modifiers(self, ability: Ability, modifiers: Dict[str, Any]):
+        """Apply extracted modifiers to effects and conditions."""
+        target_str = None
+        # Apply optionality
+        is_optional = modifiers.get("is_optional", False) or modifiers.get("cost_is_optional", False)
+        if is_optional:
+            # Apply to all costs if they exist
+            for cost in ability.costs:
+                cost.is_optional = True
+
+            for effect in ability.effects:
+                # Primary effects that are usually optional
+                primary_optional_types = [
+                    EffectType.ADD_TO_HAND,
+                    EffectType.RECOVER_MEMBER,
+                    EffectType.RECOVER_LIVE,
+                    EffectType.PLAY_MEMBER_FROM_HAND,
+                    EffectType.SEARCH_DECK,
+                    EffectType.LOOK_AND_CHOOSE,
+                    EffectType.DRAW,
+                    EffectType.ENERGY_CHARGE,
+                ]
+
+                # Housekeeping effects that are usually NOT optional even if primary is
+                # (unless they contain their own "may" keyword, which _extract_modifiers would catch)
+                housekeeping_types = [
+                    EffectType.SWAP_CARDS,  # Often "discard remainder"
+                    EffectType.MOVE_TO_DECK,
+                    EffectType.ORDER_DECK,
+                ]
+
+                if effect.effect_type in primary_optional_types:
+                    effect.is_optional = True
+                # If it's housekeeping, we check if the SPECIFIC text for this effect has "てもよい"
+                # But since we don't have per-effect text easily here without more refactoring,
+                # we'll stick to the heuristic.
+
+        # Apply usage limits
+        if modifiers.get("is_once_per_turn"):
+            ability.is_once_per_turn = True
+
+        # Apply duration
+        duration = modifiers.get("duration")
+        if duration:
+            for effect in ability.effects:
+                effect.params["until"] = duration
+
+        # Apply target overrides
+        if modifiers.get("target"):
+            target_str = modifiers["target"]
+            target_map = {
+                "OPPONENT": TargetType.OPPONENT,
+                "ALL_PLAYERS": TargetType.ALL_PLAYERS,
+                "OPPONENT_HAND": TargetType.OPPONENT_HAND,
+            }
+            if target_str in target_map:
+                for effect in ability.effects:
+                    effect.target = target_map[target_str]
+
+        # Apply both_players flag
+        if modifiers.get("both_players"):
+            for effect in ability.effects:
+                effect.params["both_players"] = True
+
+        # Apply "all" scope
+        if modifiers.get("all"):
+            for effect in ability.effects:
+                effect.params["all"] = True
+
+        # Apply multiplier flags
+        for key in ["per_member", "per_live", "per_energy", "has_multiplier"]:
+            if modifiers.get(key):
+                for effect in ability.effects:
+                    effect.params[key] = True
+
+        # Apply filters
+        if modifiers.get("cost_max"):
+            for effect in ability.effects:
+                effect.params["cost_max"] = modifiers["cost_max"]
+
+        if modifiers.get("has_ability"):
+            for effect in ability.effects:
+                effect.params["has_ability"] = modifiers["has_ability"]
+
+        # Apply group filter
+        if modifiers.get("group") or modifiers.get("groups"):
+            for effect in ability.effects:
+                # Apply to effects that might need a group filter
+                if effect.effect_type in [
+                    EffectType.ADD_TO_HAND,
+                    EffectType.RECOVER_MEMBER,
+                    EffectType.RECOVER_LIVE,
+                    EffectType.SEARCH_DECK,
+                    EffectType.LOOK_AND_CHOOSE,
+                    EffectType.PLAY_MEMBER_FROM_HAND,
+                    EffectType.ADD_BLADES,
+                    EffectType.ADD_HEARTS,
+                    EffectType.BUFF_POWER,
+                ]:
+                    if "group" not in effect.params and modifiers.get("group"):
+                        effect.params["group"] = modifiers["group"]
+
+                    if "groups" not in effect.params and modifiers.get("groups"):
+                        effect.params["groups"] = modifiers["groups"]
+
+        # Apply name filter
+        if modifiers.get("target_names"):
+            for effect in ability.effects:
+                # Apply to effects that might need a name filter
+                if effect.effect_type in [
+                    EffectType.ADD_TO_HAND,
+                    EffectType.RECOVER_MEMBER,
+                    EffectType.RECOVER_LIVE,
+                    EffectType.SEARCH_DECK,
+                    EffectType.LOOK_AND_CHOOSE,
+                    EffectType.PLAY_MEMBER_FROM_HAND,
+                ]:
+                    if "names" not in effect.params:
+                        effect.params["names"] = modifiers["target_names"]
+
+        # Apply opponent trigger flag to conditions
+        if modifiers.get("opponent_trigger_allowed"):
+            ability.conditions.append(Condition(ConditionType.OPPONENT_HAS, {"opponent_trigger_allowed": True}))
+
+    # =========================================================================
+    # Pass 5: Cost Extraction
+    # =========================================================================
+
+    def _extract_costs(self, cost_part: str) -> List[Cost]:
+        """Extract ability costs from cost text."""
+        costs = []
+        if not cost_part:
+            return costs
+
+        # Extract names if present (e.g. discard specific members)
+        cost_names = re.findall(r"「(?!\{\{)(.*?)」", cost_part)
+
+        # Check for tap self cost
+        if "このメンバーをウェイトにし" in cost_part:
+            costs.append(Cost(AbilityCostType.TAP_SELF))
+
+        # Check for discard cost
+        if "控え室に置" in cost_part and "手札" in cost_part:
+            count = 1
+            if m := re.search(r"(\d+)枚", cost_part):
+                count = int(m.group(1))
+
+            params = {}
+            if cost_names:
+                params["names"] = cost_names
+
+            costs.append(Cost(AbilityCostType.DISCARD_HAND, count, params=params))
+
+        # Check for sacrifice self cost
+        if "このメンバーを" in cost_part and "控え室に置" in cost_part:
+            costs.append(Cost(AbilityCostType.SACRIFICE_SELF))
+
+        # Check for energy cost
+        # Strip potential separators like '、' or '。' that might be between icons
+        clean_cost_part = cost_part.replace("、", "").replace("。", "")
+        energy_icons = len(re.findall(r"\{\{icon_energy.*?\}\}", clean_cost_part))
+        if energy_icons:
+            costs.append(Cost(AbilityCostType.ENERGY, energy_icons))
+
+        # Check for reveal hand cost
+        if "手札" in cost_part and "公開" in cost_part:
+            count = 1
+            if m := re.search(r"(\d+)枚", cost_part):
+                count = int(m.group(1))
+            params = {}
+            if "ライブカード" in cost_part:
+                params["filter"] = "live"
+            elif "メンバー" in cost_part:
+                params["filter"] = "member"
+            costs.append(Cost(AbilityCostType.REVEAL_HAND, count, params))
+
+        return costs
+
+    # =========================================================================
+    # Pseudocode Parsing (Inverse of tools/simplify_cards.py)
+    # =========================================================================
+
+    def _parse_pseudocode_block(self, text: str) -> List[Ability]:
+        """Parse one or more abilities from pseudocode format."""
+        # Split by "TRIGGER:" but respect quotes to support GRANT_ABILITY
+        blocks = []
+        current_block = ""
+        in_quote = False
+        
+        i = 0
+        while i < len(text):
+            if text[i] == '"':
+                in_quote = not in_quote
+            
+            # Check for TRIGGER: start
+            # Ensure we are at start or newline-ish boundary to avoid false positives, 
+            # but main requirement is not in quote.
+            if not in_quote and text[i:].startswith("TRIGGER:"):
+                if current_block.strip():
+                    blocks.append(current_block)
+                    current_block = ""
+                # Append TRIGGER: and Move forward
+                current_block += "TRIGGER:"
+                i += 8
+                continue
+            
+            current_block += text[i]
+            i += 1
+            
+        if current_block.strip():
+            blocks.append(current_block)
+
+        abilities = []
+        for block in blocks:
+            if not block.strip():
+                continue
+            ability = self._parse_single_pseudocode(block)
+            # Default trigger to ACTIVATED if missing but has content
+            if ability.trigger == TriggerType.NONE and (ability.costs or ability.effects):
+                ability.trigger = TriggerType.ACTIVATED
+            abilities.append(ability)
+        return abilities
+
+    def _parse_single_pseudocode(self, text: str) -> Ability:
+        """Parse a single ability from pseudocode format."""
+        # Clean up lines but preserve structure for Options: parsing
+        lines = [line.strip() for line in text.split("\n") if line.strip()]
+
+        trigger = TriggerType.NONE
+        costs = []
+        conditions = []
+        effects = []
+        instructions = []
+        is_once_per_turn = False
+
+        # New: Track nested options for SELECT_MODE
+        # If we see "Options:", the next lines until the next keyword belong to it
+        i = 0
+        last_target = TargetType.PLAYER
+        while i < len(lines):
+            line = lines[i]
+
+            if line.startswith("TRIGGER:"):
+                t_name = line.replace("TRIGGER:", "").strip()
+                if "(Once per turn)" in t_name:
+                    is_once_per_turn = True
+                
+                # Strip all content in parentheses
+                t_name = re.sub(r"\(.*?\)", "", t_name).strip()
+                
+                # Aliases for triggers
+                alias_map = {
+                    "ON_YELL": "ON_REVEAL",
+                    "ON_YELL_SUCCESS": "ON_REVEAL",
+                    "ON_ACTIVATE": "ACTIVATED",
+                    "JIDOU": "ON_REVEAL", # JIDOU often means automatic trigger on reveal
+                    "ON_MEMBER_DISCARD": "ON_LEAVES",
+                    "ON_DISCARDED": "ON_LEAVES",
+                    "ON_REMOVE": "ON_LEAVES",
+                    "ON_SET": "ON_PLAY",
+                    "ON_STAGE_ENTRY": "ON_PLAY",
+                    "ON_PLAY_OTHER": "ON_PLAY",
+                    "ON_REVEAL_OTHER": "ON_REVEAL",
+                    "ON_LIVE_SUCCESS_OTHER": "ON_LIVE_SUCCESS",
+                    "ON_TURN_START": "TURN_START",
+                    "ON_TURN_END": "TURN_END",
+                    "ON_TAP": "ACTIVATED",
+                    "ON_OPPONENT_TAP": "ON_LEAVES", # Approximation
+                    "ON_REVEAL_SELF": "ON_REVEAL",
+                    "ON_LIVE_SUCCESS_SELF": "ON_LIVE_SUCCESS",
+                    "ACTIVATED_FROM_DISCARD": "ACTIVATED",
+                    "ON_ENERGY_CHARGE": "ACTIVATED",
+                    "ON_DRAW": "ACTIVATED",  # Approx
+                }
+                t_name = alias_map.get(t_name, t_name)
+
+                try:
+                    trigger = TriggerType[t_name]
+                except (KeyError, ValueError):
+                    trigger = getattr(TriggerType, t_name, TriggerType.NONE)
+
+            elif "(Once per turn)" in line:
+                is_once_per_turn = True
+
+            elif line.startswith("COST:"):
+                cost_str = line.replace("COST:", "").strip()
+                costs = self._parse_pseudocode_costs(cost_str)
+
+            elif line.startswith("CONDITION:"):
+                cond_str = line.replace("CONDITION:", "").strip()
+                new_conditions = self._parse_pseudocode_conditions(cond_str)
+                conditions.extend(new_conditions)
+                instructions.extend(new_conditions)
+
+            elif line.startswith("EFFECT:"):
+                eff_str = line.replace("EFFECT:", "").strip()
+                new_effects = self._parse_pseudocode_effects(eff_str, last_target=last_target)
+                if new_effects:
+                    last_target = new_effects[-1].target
+                effects.extend(new_effects)
+                instructions.extend(new_effects)
+
+            elif line.startswith("Options:"):
+                # The most recently added effect should be SELECT_MODE
+                if effects and effects[-1].effect_type == EffectType.SELECT_MODE:
+                    # Parse subsequent lines until next major keyword
+                    modal_options = []
+                    i += 1
+                    while i < len(lines) and not any(
+                        lines[i].startswith(kw) for kw in ["TRIGGER:", "COST:", "CONDITION:", "EFFECT:"]
+                    ):
+                        # Format: N: EFFECT1, EFFECT2
+                        option_match = re.match(r"\d+:\s*(.*)", lines[i])
+                        if option_match:
+                            option_text = option_match.group(1)
+                            sub_effects = self._parse_pseudocode_effects_compact(option_text)
+                            modal_options.append(sub_effects)
+                        i += 1
+                    effects[-1].modal_options = modal_options
+                    continue  # Already incremented i
+
+            elif line.startswith("OPTION:"):
+                # Format: OPTION: Description | EFFECT: Effect1; Effect2
+                if effects and effects[-1].effect_type == EffectType.SELECT_MODE:
+                    # Parse the option line
+                    parts = line.replace("OPTION:", "").split("|")
+                    opt_desc = parts[0].strip()
+
+                    # Store description in select_mode effect params
+                    if "options" not in effects[-1].params:
+                        effects[-1].params["options"] = []
+                    effects[-1].params["options"].append(opt_desc)
+
+                    eff_part = next((p.strip() for p in parts if p.strip().startswith("EFFECT:")), None)
+                    if eff_part:
+                        eff_str = eff_part.replace("EFFECT:", "").strip()
+                        # Use standard effect parser as these can be complex
+                        sub_effects = self._parse_pseudocode_effects(eff_str)
+
+                        # Initialize modal_options if needed
+                        if not hasattr(effects[-1], "modal_options") or effects[-1].modal_options is None:
+                            effects[-1].modal_options = []
+
+                        effects[-1].modal_options.append(sub_effects)
+
+            i += 1
+
+        return Ability(
+            raw_text=text,
+            trigger=trigger,
+            costs=costs,
+            conditions=conditions,
+            effects=effects,
+            is_once_per_turn=is_once_per_turn,
+            instructions=instructions,
+        )
+
+    def _parse_pseudocode_effects_compact(self, text: str) -> List[Effect]:
+        """Special parser for compact effects in Options list (comma separated)."""
+        # Format example: DRAW(1)->SELF {PARAMS}, MOVE_TO_DECK(1)->SELF {PARAMS}
+        # Split by comma but not inside {}
+        parts = []
+        current = ""
+        depth = 0
+        for char in text:
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+            elif char == "," and depth == 0:
+                parts.append(current.strip())
+                current = ""
+                continue
+            current += char
+        if current:
+            parts.append(current.strip())
+
+        effects = []
+        for p in parts:
+            # Format: NAME(VAL)->TARGET {PARAMS}
+            m = re.match(r"(\w+)\((.*?)\)\s*->\s*(\w+)(.*)", p)
+            if m:
+                name, val, target_name, rest = m.groups()
+                etype = getattr(EffectType, name, EffectType.DRAW)
+                target = getattr(TargetType, target_name, TargetType.PLAYER)
+                params = self._parse_pseudocode_params(rest)
+
+                val_int = 0
+                val_cond = ConditionType.NONE
+
+                # Check if val is a condition type
+                if hasattr(ConditionType, val):
+                    val_cond = getattr(ConditionType, val)
+                else:
+                    try:
+                        val_int = int(val)
+                    except ValueError:
+                        val_int = 1
+
+                effects.append(Effect(etype, val_int, val_cond, target, params))
+        return effects
+
+    def _parse_pseudocode_params(self, param_str: str) -> Dict[str, Any]:
+        """Parse parameters in {KEY=VAL, ...} format."""
+        if not param_str or "{" not in param_str:
+            return {}
+
+        # Extract content between { and }
+        match = re.search(r"\{(.*)\}", param_str)
+        if not match:
+            return {}
+
+        content = match.group(1)
+        params = {}
+
+        # Simple parser for KEY=VAL or KEY=["a", "b"] or FLAG
+        parts = []
+        current = ""
+        depth = 0
+        in_quotes = False
+        for char in content:
+            if char == '"' and (not current or (current and current[-1] != "\\")):
+                in_quotes = not in_quotes
+            if not in_quotes:
+                if char in "[{":
+                    depth += 1
+                elif char in "}]":
+                    depth -= 1
+                elif char == "," and depth == 0:
+                    parts.append(current.strip())
+                    current = ""
+                    continue
+            current += char
+        if current:
+            parts.append(current.strip())
+
+        for part in parts:
+            if "=" in part:
+                k, v = part.split("=", 1)
+                k = k.strip().lower()
+                v = v.strip()
+                # Try to parse as JSON for lists/objects
+                try:
+                    val = json.loads(v)
+                    # Normalize common ENUM string values
+                    if k in ["until", "from", "to", "target", "type"]:
+                        if isinstance(val, str):
+                            params[k] = val.lower()
+                        elif isinstance(val, list):
+                            params[k] = [x.lower() if isinstance(x, str) else x for x in val]
+                        else:
+                            params[k] = val
+                    elif k == "cost_max" or k == "cost_min":
+                        params[k] = val
+                    elif k == "cost<= ":  # Support legacy/alternative
+                        params["cost_max"] = val
+                    elif k == "cost>= ":
+                        params["cost_min"] = val
+                    else:
+                        params[k] = val
+                except:
+                    # Fallback
+                    if v.startswith('"') and v.endswith('"'):
+                        v = v[1:-1]
+
+                    if v.isdigit():
+                        params[k] = int(v)
+                    elif k in ["until", "from", "to", "target", "type"]:
+                        params[k] = v.lower()
+                    else:
+                        params[k] = v
+            elif part.startswith("{") and part.endswith("}"):
+                # Merge embedded JSON
+                try:
+                    embedded = json.loads(part)
+                    if isinstance(embedded, dict):
+                        params.update(embedded)
+                except:
+                    pass
+            elif part.startswith("(") and part.endswith(")"):
+                # Handle (VAL) shorthand
+                params["val"] = part[1:-1]
+            else:
+                # Flag
+                params[part.lower()] = True
+
+        return params
+
+    def _parse_pseudocode_costs(self, text: str) -> List[Cost]:
+        costs = []
+        # Split by ' OR ' first, but for now we might just take the first one or treat as optional?
+        # Actually, let's treat 'OR' as splitting into separate options if needed,
+        # but the Cost model is AND-only.
+        # We'll split by comma AND ' OR ' for now and mark them all.
+        parts = []
+        current = ""
+        depth = 0
+        i = 0
+        while i < len(text):
+            char = text[i]
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+            elif depth == 0:
+                if text[i : i + 4] == " OR ":
+                    parts.append(current.strip())
+                    current = ""
+                    i += 4
+                    continue
+                elif char == "," or char == ";":
+                    parts.append(current.strip())
+                    current = ""
+                    i += 1
+                    continue
+            current += char
+            i += 1
+        if current:
+            parts.append(current.strip())
+
+        for p in parts:
+            if not p:
+                continue
+            # Format: NAME(VAL) {PARAMS} (Optional)
+            m = re.match(r"(\w+)(?:\((.*?)\))?(.*)", p)
+            if m:
+                name, val_str, rest = m.groups()
+
+                # Manual Mapping for specific cost names
+                if name == "MOVE_TO_DECK":
+                    if 'from="discard"' in rest.lower() or "from='discard'" in rest.lower():
+                        name = "RETURN_DISCARD_TO_DECK"
+                    else:
+                        name = "RETURN_MEMBER_TO_DECK"
+
+                cost_name = name.upper()
+                if cost_name == "REMOVE_SELF":
+                    cost_name = "SACRIFICE_SELF"
+                ctype = getattr(AbilityCostType, cost_name, AbilityCostType.NONE)
+                try:
+                    val = int(val_str) if val_str else 0
+                except ValueError:
+                    val = 0
+                is_opt = "(Optional)" in rest or " OR " in text  # OR implies selectivity
+                params = self._parse_pseudocode_params(rest)
+                costs.append(Cost(ctype, val, is_optional=is_opt, params=params))
+        return costs
+
+    def _parse_pseudocode_conditions(self, text: str) -> List[Condition]:
+        conditions = []
+        parts = []
+        current = ""
+        depth = 0
+        i = 0
+        while i < len(text):
+            char = text[i]
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+            elif depth == 0:
+                if text[i : i + 4] == " OR ":
+                    parts.append(current.strip())
+                    current = ""
+                    i += 4
+                    continue
+                elif char == "," or char == ";":
+                    parts.append(current.strip())
+                    current = ""
+                    i += 1
+                    continue
+            current += char
+            i += 1
+        if current:
+            parts.append(current.strip())
+
+        for p in parts:
+            if not p:
+                continue
+            negated = p.startswith("NOT ")
+            name_part = p[4:] if negated else p
+            
+            # Support ! as prefix for negation
+            if not negated and name_part.startswith("!"):
+                negated = True
+                name_part = name_part[1:]
+
+            # Match name and params
+            m = re.match(r"(\w+)(.*)", name_part)
+            if m:
+                name, rest = m.groups()
+                ctype = getattr(ConditionType, name.upper(), ConditionType.NONE)
+
+                # Robust parameter parsing
+                params = self._parse_pseudocode_params(rest)
+                if not params or "val" not in params:
+                    # Check for (VAL)
+                    p_m = re.search(r"\((.*?)\)", rest)
+                    if p_m:
+                        params["val"] = p_m.group(1)
+                    else:
+                        # Check for =VAL
+                        e_m = re.search(r"=\s*[\"']?(.*?)[\"']?$", rest.strip())
+                        if e_m and "{" not in rest:
+                            params["val"] = e_m.group(1)
+                            
+                params["raw_cond"] = name
+                if name == "COST_LEAD":
+                    ctype = ConditionType.SCORE_COMPARE
+                    params["type"] = "cost"
+                    params["target"] = "opponent"
+                    params["comparison"] = "GT"
+                    if params.get("area") == "CENTER":
+                        params["zone"] = "CENTER_STAGE"
+                        del params["area"]
+
+                # Fix for SCORE_LEAD -> SCORE_COMPARE
+                if name == "SCORE_LEAD":
+                    ctype = ConditionType.SCORE_COMPARE
+                    params["type"] = "score"
+                    # Default comparison GT (Lead)
+                    if "comparison" not in params:
+                        params["comparison"] = "GT"
+                    # If target is opponent, it implies checking relative to opponent
+                    if "target" not in params:
+                        params["target"] = "opponent"
+
+                # TYPE_MEMBER/TYPE_LIVE -> TYPE_CHECK
+                if name == "TYPE_MEMBER":
+                    ctype = ConditionType.TYPE_CHECK
+                    params["card_type"] = "member"
+                if name == "TYPE_LIVE":
+                    ctype = ConditionType.TYPE_CHECK
+                    params["card_type"] = "live"
+
+                # Fix for COUNT_LIVE -> COUNT_LIVE_ZONE
+                if name == "COUNT_LIVE":
+                    ctype = ConditionType.COUNT_LIVE_ZONE
+
+                # ENERGY_LAGGING / ENERGY_LEAD -> OPPONENT_ENERGY_DIFF
+                if name == "ENERGY_LAGGING":
+                    ctype = ConditionType.OPPONENT_ENERGY_DIFF
+                    params["comparison"] = "GE"
+                    if "diff" not in params:
+                        params["diff"] = 1
+                if name == "ENERGY_LEAD":
+                    ctype = ConditionType.OPPONENT_ENERGY_DIFF
+                    params["comparison"] = "LE"
+                    if "diff" not in params:
+                        params["diff"] = 0
+
+                # Aliases
+                if name == "SUM_SCORE":
+                    ctype = ConditionType.SCORE_COMPARE
+                    params["type"] = "score"
+                    if "comparison" not in params:
+                        params["comparison"] = "GE"
+                    if "min" in params and "value" not in params:
+                        # Map min to value for SCORE_COMPARE absolute check?
+                        # Assuming SCORE_COMPARE supports absolute value if target is set?
+                        # Actually logic.rs might compare vs opponent score if no value is set?
+                        # If value IS set, it might compare vs value?
+                        # I'll rely on value mapping logic.
+                        pass
+
+                if name == "COUNT_PLAYED_THIS_TURN":
+                    # Pending engine support, use HAS_KEYWORD to silence linter
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "PLAYED_THIS_TURN"
+                
+                if name == "SUM_COST":
+                    ctype = ConditionType.SCORE_COMPARE
+                    params["type"] = "cost"
+                    if "comparison" not in params:
+                        params["comparison"] = "GE"
+                    # Default target to ME if not specified? 
+                    # If params has TARGET="OPPONENT", it will be parsed.
+                
+                if name == "REVEALED_CONTAINS":
+                    # No generic HAS_CARD_IN_ZONE condition yet
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "REVEALED_CONTAINS"
+                    if "TYPE_LIVE" in params:
+                        params["value"] = "live"
+                    if "TYPE_MEMBER" in params:
+                        params["value"] = "member"
+
+                if name == "ZONE":
+                    # Heuristic for ZONE condition (e.g. ZONE="YELL_REVEALED")
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "ZONE_CHECK"
+                    params["value"] = params.get("val", "Unknown") # Default param processing might put it in val?
+                    # The parser puts the value in params based on default logic?
+                    # Actually _parse_pseudocode_conditions logic puts keys in params.
+                    # params is passed in? No, params is dict.
+                    # We rely on default param parsing for the "YELL_REVEALED" value which should be in params?
+                    # Actually parsing of condition params happens AFTER this block usually?
+                    # No, this block converts Name to Params.
+                    # If ZONE="YELL_REVEALED", input `name` is "ZONE".
+                    # params is empty.
+                    pass
+                
+                if name == "IS_MAIN_PHASE" or name == "MAIN_PHASE":
+                    # Implicit in activated abilities usually, map to NONE to ignore
+                    ctype = ConditionType.NONE
+
+                if name == "COUNT_SUCCESS_LIVES" or name == "COUNT_SUCCESS_LIVE":
+                    ctype = ConditionType.COUNT_SUCCESS_LIVE
+                    # Handle PLAYER=0/1 param mapping
+                    if "PLAYER" in params:
+                        pval = params["PLAYER"]
+                        if str(pval) == "1":
+                            params["target"] = "opponent"
+                        else:
+                            params["target"] = "self"
+                        del params["PLAYER"]
+                    if "COUNT" in params:
+                        params["value"] = params["COUNT"]
+                        params["comparison"] = "EQ"
+                        del params["COUNT"]
+                
+                if name == "HAS_SUCCESS_LIVE":
+                    ctype = ConditionType.COUNT_SUCCESS_LIVE
+
+                if name == "SUM_ENERGY":
+                    ctype = ConditionType.COUNT_ENERGY
+                
+                if name == "BATON_FROM_NAME":
+                    ctype = ConditionType.BATON
+                
+                if name == "MOVED_THIS_TURN":
+                    ctype = ConditionType.HAS_MOVED
+                
+                if name == "DECK_REFRESHED_THIS_TURN":
+                    ctype = ConditionType.DECK_REFRESHED
+                
+                if name == "HAND_SIZE_DIFF":
+                    ctype = ConditionType.OPPONENT_HAND_DIFF
+
+                if name == "COST_LE_9":
+                    ctype = ConditionType.COST_CHECK
+                    params["comparison"] = "LE"
+                    params["value"] = 9
+
+                if name == "TARGET":
+                    # Data error where params separated by comma
+                    ctype = ConditionType.NONE
+                
+                if name.startswith("MATCH_"):
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = name
+                
+                if name.startswith("DID_ACTIVATE_"):
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = name
+                
+                if name == "SUCCESS_LIVES_CONTAINS":
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "SUCCESS_LIVES_CONTAINS"
+                
+                if name == "YELL_COUNT" or name == "COUNT_YELL_REVEALED":
+                    # Pending engine support for Yell Count
+                    ctype = ConditionType.HAS_KEYWORD
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "YELL_COUNT"
+
+                if name == "HAS_REMAINING_HEART":
+                    ctype = ConditionType.COUNT_HEARTS
+                    params["min"] = 1
+                
+                if name == "COUNT_CHARGED_ENERGY":
+                    ctype = ConditionType.COUNT_ENERGY
+                
+                if name == "SUM_SUCCESS_LIVE":
+                    ctype = ConditionType.COUNT_SUCCESS_LIVE # Approx
+                
+                if name == "SUM_HEARTS":
+                    ctype = ConditionType.COUNT_HEARTS
+
+                if name == "SCORE_EQUAL_OPPONENT":
+                    ctype = ConditionType.SCORE_COMPARE
+                    params["comparison"] = "EQ"
+                    params["target"] = "opponent"
+
+                if name == "AREA":
+                    ctype = ConditionType.HAS_KEYWORD # Likely filtering by area
+                    params["keyword"] = "AREA_CHECK"
+                
+                if name == "EFFECT_NEGATED_THIS_TURN":
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "EFFECT_NEGATED"
+                
+                if name == "HIGHEST_COST_ON_STAGE":
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "HIGHEST_COST"
+                
+                if name == "BATON_TOUCH":
+                    ctype = ConditionType.BATON
+                
+                if name == "HAND_SIZE":
+                    ctype = ConditionType.COUNT_HAND
+                
+                if name == "COUNT_UNIQUE_NAMES":
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "UNIQUE_NAMES"
+                
+                if name == "HAS_TYPE_LIVE":
+                    ctype = ConditionType.TYPE_CHECK
+                    params["card_type"] = "live"
+
+                if name == "OPPONENT_EXTRA_HEARTS":
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "OPPONENT_EXTRA_HEARTS"
+
+                if name == "EXTRA_HEARTS":
+                    ctype = ConditionType.COUNT_HEARTS
+                    # Typically means checking if we have extra hearts
+                    if "min" not in params:
+                        params["min"] = 1
+                
+                if name == "BLADES":
+                    ctype = ConditionType.COUNT_BLADES
+                
+                if name == "AREA_IN" or name == "AREA":
+                    val = params.get("val", "").upper().strip('"')
+                    if val == "CENTER" or params.get("zone") == "CENTER" or params.get("area") == "CENTER":
+                        ctype = ConditionType.IS_CENTER
+                    else:
+                        ctype = ConditionType.GROUP_FILTER
+                        params["keyword"] = "AREA_CHECK"
+                
+                if name == "BATON_COUNT" or name == "BATON" or name == "BATON_TOUCH":
+                    ctype = ConditionType.BATON
+
+                if name == "HAS_ACTIVE_ENERGY":
+                    ctype = ConditionType.COUNT_ENERGY
+                    params["filter"] = "active"
+                    if "min" not in params:
+                        params["min"] = 1
+                
+                if name == "HAS_LIVE_SET":
+                    ctype = ConditionType.HAS_KEYWORD
+                    params["keyword"] = "HAS_LIVE_SET"
+                
+                if name == "ALL_ENERGY_ACTIVE":
+                    ctype = ConditionType.COUNT_ENERGY
+                    params["filter"] = "active"
+                    params["comparison"] = "ALL" # Custom logic in engine likely
+
+                if name == "ENERGY":
+                    ctype = ConditionType.COUNT_ENERGY
+
+                # Aliases
+                if name == "ON_YELL" or name == "ON_YELL_SUCCESS":
+                    ctype = ConditionType.NONE # Triggers handled separately, but avoid ERROR
+                
+                if name == "CHECK_GROUP_FILTER":
+                    ctype = ConditionType.GROUP_FILTER
+                
+                if name == "FILTER":
+                    ctype = ConditionType.GROUP_FILTER
+
+                if name == "TOTAL_BLADES":
+                    ctype = ConditionType.COUNT_BLADES
+                
+                if name == "HEART_LEAD":
+                    ctype = ConditionType.COUNT_HEARTS
+                    if "comparison" not in params:
+                        params["comparison"] = "GE"
+                    if "min" not in params and "value" not in params:
+                        params["min"] = 1
+                
+                if name == "SCORE_TOTAL":
+                    ctype = ConditionType.SCORE_COMPARE
+                    params["type"] = "score"
+                    if "comparison" not in params:
+                        params["comparison"] = "GE"
+                
+                if name == "COUNT_ACTIVATED":
+                    ctype = ConditionType.COUNT_STAGE
+                    params["filter"] = "ACTIVATED"
+                
+                if name == "OPPONENT_HAS_WAIT":
+                    ctype = ConditionType.COUNT_STAGE
+                    params["target"] = "opponent"
+                    params["filter"] = "tapped"
+                    if "min" not in params:
+                        params["min"] = 1
+                
+                if name == "CHECK_IS_IN_DISCARD":
+                    ctype = ConditionType.IS_IN_DISCARD
+
+                if name == "HAS_EXCESS_HEART":
+                    ctype = ConditionType.COUNT_HEARTS
+                    params["context"] = "excess"
+                    if "min" not in params:
+                        params["min"] = 1
+
+                if name == "COUNT_MEMBER":
+                    ctype = ConditionType.COUNT_STAGE
+                
+                if name == "TOTAL_HEARTS":
+                    ctype = ConditionType.COUNT_HEARTS
+                
+                if name == "ALL_MEMBER":
+                    ctype = ConditionType.GROUP_FILTER
+                
+                if name == "MEMBER_AT_SLOT":
+                    ctype = ConditionType.GROUP_FILTER
+                
+                if name == "SUCCESS":
+                    ctype = ConditionType.MODAL_ANSWER
+                
+                if name == "HAS_LIVE_HEART_COLORS":
+                    ctype = ConditionType.HAS_COLOR
+                
+                if name == "COUNT_REVEALED":
+                    ctype = ConditionType.COUNT_HAND # Approximate or META_RULE
+                
+                if name == "COUNT_DISCARDED_THIS_TURN":
+                    ctype = ConditionType.COUNT_DISCARD
+                
+                if name == "IS_MAIN_PHASE":
+                    ctype = ConditionType.NONE
+                
+                if name == "MATCH_PREVIOUS":
+                    ctype = ConditionType.MODAL_ANSWER # Heuristic
+                
+                if name == "NOT_MOVED_THIS_TURN":
+                    ctype = ConditionType.HAS_MOVED
+                    negated = True
+                
+                if name == "NAME_MATCH":
+                    ctype = ConditionType.GROUP_FILTER
+                    params["filter"] = "NAME_MATCH"
+
+                conditions.append(Condition(ctype, params, is_negated=negated))
+        return conditions
+
+    def _parse_pseudocode_effects(self, text: str, last_target: TargetType = TargetType.PLAYER) -> List[Effect]:
+        effects = []
+        # Split by semicolon but not inside {}
+        parts = []
+        current = ""
+        depth = 0
+        for char in text:
+            if char == "{":
+                depth += 1
+            elif char == "}":
+                depth -= 1
+            elif char == ";" and depth == 0:
+                parts.append(current.strip())
+                current = ""
+                continue
+            current += char
+        if current:
+            parts.append(current.strip())
+
+        for p in parts:
+            if not p:
+                continue
+            # Format: NAME(VAL) -> TARGET {PARAMS} (Optional)
+            # Support optional -> TARGET
+            # Improved regex to handle optional {PARAMS} before -> TARGET
+            m = re.match(r"(\w+)(?:\((.*?)\))?(?:\s*\{.*?\}\s*)?(?:\s*->\s*([\w, ]+))?(.*)", p)
+            if m:
+                name, val, target_name, rest = m.groups()
+
+                # Extract params from the whole string 'p' since {} might be anywhere
+                params = self._parse_pseudocode_params(p)
+
+                # Aliases from parser_pseudocode
+                if name == "TAP_PLAYER":
+                    name = "TAP_MEMBER"
+                if name == "CHARGE_SELF":
+                    name = "ENERGY_CHARGE"
+                    target_name = "MEMBER_SELF"
+                if name == "CHARGE_ENERGY":
+                    name = "ENERGY_CHARGE"
+                if name == "MOVE_DISCARD":
+                    name = "MOVE_TO_DISCARD"
+                if name == "REMOVE_SELF":
+                    name = "MOVE_TO_DISCARD"
+                    target_name = "MEMBER_SELF"
+                if name == "SWAP_SELF":
+                    name = "SWAP_ZONE"
+                    target_name = "MEMBER_SELF"
+                if name == "MOVE_HAND" or name == "MOVE_TO_HAND":
+                    name = "ADD_TO_HAND"
+                if name == "ADD_HAND":
+                    name = "ADD_TO_HAND"
+                if name == "TRIGGER_YELL_AGAIN":
+                    name = "META_RULE"
+                    params["meta_type"] = "TRIGGER_YELL_AGAIN"
+                if name == "DISCARD_HAND":
+                    name = "LOOK_AND_CHOOSE"
+                    params["source"] = "HAND"
+                    params["destination"] = "discard"
+                if name == "RECOVER_LIVE":
+                    # Usually means from discard
+                    params["source"] = "discard"
+                if name == "RECOVER_MEMBER":
+                    # Usually means from discard
+                    params["source"] = "discard"
+                if name == "SELECT_LIMIT":
+                    name = "REDUCE_LIVE_SET_LIMIT"
+                if name == "POWER_UP":
+                    name = "BUFF_POWER"
+                if name == "REDUCE_SET_LIMIT":
+                    name = "REDUCE_LIVE_SET_LIMIT"
+                if name == "REDUCE_LIMIT":
+                    name = "REDUCE_LIVE_SET_LIMIT"
+                if name == "REDUCE_HEART":
+                    name = "REDUCE_HEART_REQ"
+                if name == "ADD_TAG":
+                    name = "META_RULE"
+                    params["tag"] = val
+                if name == "PREVENT_LIVE":
+                    name = "RESTRICTION"
+                    params["type"] = "no_live"
+                if name == "PREVENT_SET_TO_SUCCESS_PILE":
+                    name = "META_RULE"
+                    params["meta_type"] = "PREVENT_SET_TO_SUCCESS_PILE"
+                if name == "MOVE_DECK":
+                    name = "MOVE_TO_DECK"
+                if name == "OPPONENT_CHOICE":
+                    etype = EffectType.OPPONENT_CHOOSE
+                    # OPPONENT_CHOICE implies complex options which parse_pseudocode_block/effects handles?
+                    # Actually SELECT_MODE handles options. OPPONENT_CHOICE likely structured similarly.
+                if name == "RESET_YELL_HEARTS":
+                    name = "META_RULE"
+                    params["meta_type"] = "RESET_YELL_HEARTS"
+                if name == "TRIGGER_YELL_AGAIN":
+                    name = "META_RULE"
+                    params["meta_type"] = "TRIGGER_YELL_AGAIN"
+                if name == "ADD_HAND":
+                    name = "ADD_TO_HAND"
+                if name == "ACTION_YELL_MULLIGAN":
+                    name = "META_RULE"
+                    params["meta_type"] = "ACTION_YELL_MULLIGAN"
+                if name == "OPPONENT_CHOICE":
+                    name = "OPPONENT_CHOOSE"
+                if name == "SET_BASE_BLADES":
+                    name = "SET_BLADES"
+                if name == "GRANT_HEARTS" or name == "GRANT_HEART":
+                    name = "ADD_HEARTS"
+                if name == "SELECT_REVEALED":
+                    name = "LOOK_AND_CHOOSE"
+                    params["source"] = "revealed"
+                if name == "LOOK_AND_CHOOSE_REVEALED":
+                    name = "LOOK_AND_CHOOSE"
+                    params["source"] = "revealed"
+                if name == "TAP_SELF":
+                    name = "TAP_MEMBER"
+                    target_name = "SELF"
+                if name == "CHANGE_BASE_HEART":
+                    name = "TRANSFORM_HEART"
+                if name == "SELECT_LIVE_CARD":
+                    name = "SELECT_LIVE"
+                if name == "MOVE_TO_HAND":
+                    name = "ADD_TO_HAND"
+                if name == "POSITION_CHANGE":
+                    name = "MOVE_MEMBER"
+                if name == "INCREASE_HEART":
+                    name = "INCREASE_HEART_COST"
+                if name == "CHANGE_YELL_BLADE_COLOR":
+                    name = "TRANSFORM_COLOR"
+                if name == "MOVE_SUCCESS":
+                    name = "META_RULE"
+                    params["meta_type"] = "MOVE_SUCCESS" # Use meta_type to silence linter
+                if name.startswith("PLAY_MEMBER"):
+                    # Heuristic: if params has 'discard', use PLAY_MEMBER_FROM_DISCARD
+                    if params.get("zone") == "DISCARD" or "DISCARD" in p.upper():
+                        name = "PLAY_MEMBER_FROM_DISCARD"
+                    else:
+                        name = "PLAY_MEMBER_FROM_HAND"
+                if name == "PREVENT_ACTIVATE":
+                    name = "META_RULE" # No opcode yet
+
+                etype = getattr(EffectType, name.upper(), None)
+                if name.upper() == "LOOK_AND_CHOOSE_ORDER":
+                    etype = EffectType.ORDER_DECK
+                if name.upper() == "LOOK_AND_CHOOSE_REVEAL":
+                    etype = EffectType.LOOK_AND_CHOOSE
+
+                if name.upper() == "DISCARD_HAND":
+                    etype = EffectType.LOOK_AND_CHOOSE
+                    params["source"] = "HAND"
+                    params["destination"] = "discard"
+
+                if target_name:
+                    target_name_up = target_name.upper()
+                    if "CARD_HAND" in target_name_up:
+                        target = TargetType.CARD_HAND
+                    elif "CARD_DISCARD" in target_name_up:
+                        target = TargetType.CARD_DISCARD
+                    else:
+                        t_part = target_name.split(",")[0].strip()
+                        target = getattr(TargetType, t_part.upper(), TargetType.PLAYER)
+
+                    if "DISCARD_REMAINDER" in target_name_up:
+                        params["destination"] = "discard"
+                    
+                    # Variable targeting support: if target is "TARGET" or "TARGET_MEMBER", use last_target
+                    if target_name_up in ["TARGET", "TARGET_MEMBER"]:
+                        target = last_target
+                    elif target_name_up == "ACTIVATE_AND_SELF":
+                        # Special case for "activate and self" -> targets player but implied multi-target
+                        # For now default to player or member self
+                        target = TargetType.PLAYER
+                else:
+                    target = TargetType.PLAYER
+
+                if name.upper() == "LOOK_AND_CHOOSE_REVEAL" and "DISCARD_REMAINDER" in p.upper():
+                    params["destination"] = "discard"
+
+                if etype is None:
+                    etype = EffectType.META_RULE
+                    params["raw_effect"] = name.upper()
+
+                if target_name and target_name.upper() == "SLOT" and params.get("self"):
+                    target = TargetType.MEMBER_SELF
+                is_opt = "(Optional)" in rest or "(Optional)" in p
+
+                val_int = 0
+                val_cond = ConditionType.NONE
+
+                # Check if val is a condition type (e.g. COUNT_STAGE)
+                if val and hasattr(ConditionType, val):
+                    val_cond = getattr(ConditionType, val)
+                elif etype == EffectType.REVEAL_UNTIL and val:
+                    # Special parsing for REVEAL_UNTIL(CONDITION)
+                    if "TYPE_LIVE" in val:
+                        val_cond = ConditionType.TYPE_CHECK
+                        params["card_type"] = "live"
+                    elif "TYPE_MEMBER" in val:
+                        val_cond = ConditionType.TYPE_CHECK
+                        params["card_type"] = "member"
+                    
+                    # Handle COST_GE/LE in REVEAL_UNTIL
+                    if "COST_" in val:
+                        # Extract COST_GE=10 or COST_LE=X
+                        cost_match = re.search(r"COST_(GE|LE|GT|LT|EQ)=(\d+)", val)
+                        if cost_match:
+                            comp, cval = cost_match.groups()
+                            # If we also have TYPE check, we need to combine them?
+                            # Bytecode only supports one condition on REVEAL_UNTIL.
+                            # We'll prioritize COST check if present, or maybe the engine supports compound?
+                            # For now, map to COST_CHECK condition.
+                            val_cond = ConditionType.COST_CHECK
+                            params["comparison"] = comp
+                            params["value"] = int(cval)
+
+                    if "COST_GE" in val:
+                        val_cond = ConditionType.COST_CHECK
+                        m_cost = re.search(r"COST_GE=(\d+)", val)
+                        if m_cost:
+                            params["min"] = int(m_cost.group(1))
+
+                    if val_cond == ConditionType.NONE:
+                        try:
+                            val_int = int(val)
+                        except ValueError:
+                            val_int = 1
+                else:
+                    try:
+                        val_int = int(val) if val else 1
+                    except ValueError:
+                        val_int = 1  # Fallback for non-numeric val (e.g. "ALL")
+                        if val == "ALL":
+                            val_int = 99
+
+                effects.append(Effect(etype, val_int, val_cond, target, params, is_optional=is_opt))
+                last_target = target
+        return effects
+
+
+# Convenience function
+def parse_ability_text(text: str) -> List[Ability]:
+    """Parse ability text using the V2 parser."""
+    parser = AbilityParserV2()
+    return parser.parse(text)

compiler/patterns/__init__.py

@@ -0,0 +1 @@
+# Pattern Registry System for Ability Parser

compiler/patterns/base.py

@@ -0,0 +1,158 @@
+"""Base pattern definitions for the ability parser."""
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, List, Match, Optional, Tuple
+
+
+class PatternPhase(Enum):
+    """Phases of parsing, executed in order."""
+
+    TRIGGER = 1  # Determine when ability activates
+    CONDITION = 2  # Extract gating conditions
+    EFFECT = 3  # Extract effects/actions
+    MODIFIER = 4  # Apply flags (optional, once per turn, duration)
+
+
+@dataclass
+class Pattern:
+    """A declarative pattern definition for ability text parsing.
+
+    Patterns are matched in priority order within each phase.
+    Lower priority number = higher precedence.
+    """
+
+    name: str
+    phase: PatternPhase
+    priority: int = 100
+
+    # Matching criteria (at least one must be specified)
+    regex: Optional[str] = None  # Regex pattern to search for
+    keywords: List[str] = field(default_factory=list)  # Must contain ALL keywords
+    any_keywords: List[str] = field(default_factory=list)  # Must contain ANY keyword
+
+    # Filter conditions
+    requires: List[str] = field(default_factory=list)  # Context must contain ALL
+    excludes: List[str] = field(default_factory=list)  # Context must NOT contain ANY
+    look_ahead_excludes: List[str] = field(default_factory=list)  # Text after match must NOT contain
+
+    # Behavior
+    exclusive: bool = False  # If True, stops further matching in this phase
+    consumes: bool = False  # If True, removes matched text from further processing
+
+    # Output specification
+    output_type: Optional[str] = None  # e.g., "TriggerType.ON_PLAY", "EffectType.DRAW"
+    output_value: Optional[Any] = None  # Default value for effect
+    output_params: Dict[str, Any] = field(default_factory=dict)  # Additional parameters
+
+    # Custom extraction (for complex patterns)
+    extractor: Optional[Callable[[str, Match], Dict[str, Any]]] = None
+
+    def __post_init__(self):
+        """Compile regex if provided."""
+        self._compiled_regex = re.compile(self.regex) if self.regex else None
+
+    def matches(self, text: str, context: Optional[str] = None) -> Optional[Match]:
+        """Check if pattern matches the text.
+
+        Args:
+            text: The text to match against
+            context: Full sentence context for requires/excludes checks
+
+        Returns:
+            Match object if pattern matches, None otherwise
+        """
+        ctx = context or text
+
+        # Check requires
+        if self.requires and not all(kw in ctx for kw in self.requires):
+            return None
+
+        # Check excludes
+        if self.excludes and any(kw in ctx for kw in self.excludes):
+            return None
+
+        # Check keywords (must contain ALL)
+        if self.keywords and not all(kw in text for kw in self.keywords):
+            return None
+
+        # Check any_keywords (must contain ANY)
+        if self.any_keywords and not any(kw in text for kw in self.any_keywords):
+            return None
+
+        # Check regex
+        if self._compiled_regex:
+            m = self._compiled_regex.search(text)
+            if m:
+                # Check look-ahead excludes
+                if self.look_ahead_excludes:
+                    look_ahead = text[m.start() : m.start() + 20]
+                    if any(kw in look_ahead for kw in self.look_ahead_excludes):
+                        return None
+                return m
+            return None
+
+        # If no regex but keywords matched, return a pseudo-match
+        if self.keywords or self.any_keywords:
+            # Find first keyword position
+            for kw in self.keywords or self.any_keywords:
+                if kw in text:
+                    idx = text.find(kw)
+                    # Create a fake match-like object
+                    return _KeywordMatch(kw, idx)
+
+        return None
+
+    def extract(self, text: str, match: Match) -> Dict[str, Any]:
+        """Extract structured data from a match.
+
+        Returns dict with:
+            - 'type': output_type if specified
+            - 'value': extracted value or output_value
+            - 'params': output_params merged with any extracted params
+        """
+        if self.extractor:
+            return self.extractor(text, match)
+
+        result = {}
+        if self.output_type:
+            result["type"] = self.output_type
+        if self.output_value is not None:
+            result["value"] = self.output_value
+        if self.output_params:
+            result["params"] = self.output_params.copy()
+
+        # Try to extract numeric value from match groups
+        if match.lastindex and match.lastindex >= 1:
+            try:
+                result["value"] = int(match.group(1))
+            except (ValueError, TypeError):
+                # Don't assign non-numeric strings to 'value' as it breaks bytecode compilation
+                pass
+
+        return result
+
+
+class _KeywordMatch:
+    """Fake match object for keyword-based patterns."""
+
+    def __init__(self, keyword: str, start: int):
+        self._keyword = keyword
+        self._start = start
+        self.lastindex = None
+
+    def start(self) -> int:
+        return self._start
+
+    def end(self) -> int:
+        return self._start + len(self._keyword)
+
+    def span(self) -> Tuple[int, int]:
+        return (self.start(), self.end())
+
+    def group(self, n: int = 0) -> str:
+        return self._keyword if n == 0 else ""
+
+    def groups(self) -> Tuple:
+        return ()

compiler/patterns/conditions.py

@@ -0,0 +1,257 @@
+"""Condition patterns.
+
+Conditions are gating requirements that must be met for an ability to activate.
+Examples: COUNT_GROUP, SCORE_COMPARE, HAS_MEMBER, etc.
+"""
+
+from .base import Pattern, PatternPhase
+
+
+# Helper function for extracting Japanese numbers
+def _extract_number(text: str, match) -> int:
+    """Extract a number from match, handling full-width and kanji numerals."""
+    val_map = {
+        "１": 1,
+        "２": 2,
+        "３": 3,
+        "４": 4,
+        "５": 5,
+        "６": 6,
+        "７": 7,
+        "８": 8,
+        "９": 9,
+        "０": 0,
+        "一": 1,
+        "二": 2,
+        "三": 3,
+        "四": 4,
+        "五": 5,
+        "六": 6,
+        "七": 7,
+        "八": 8,
+        "九": 9,
+        "〇": 0,
+    }
+    if match.lastindex and match.lastindex >= 1:
+        val = match.group(1)
+        return int(val_map.get(val, val)) if not str(val).isdigit() else int(val)
+    return 1
+
+
+CONDITION_PATTERNS = [
+    # ==========================================================================
+    # Count conditions
+    # ==========================================================================
+    Pattern(
+        name="count_group",
+        phase=PatternPhase.CONDITION,
+        regex=r"『(.*?)』.*?(\d+)(枚|人)以上",
+        priority=20,
+        output_type="ConditionType.COUNT_GROUP",
+        extractor=lambda text, match: {
+            "type": "ConditionType.COUNT_GROUP",
+            "value": int(match.group(2)),
+            "params": {"group": match.group(1), "min": int(match.group(2))},
+        },
+    ),
+    Pattern(
+        name="count_stage",
+        phase=PatternPhase.CONDITION,
+        regex=r"(\d+)(枚|人)以上",
+        priority=50,
+        requires=["ステージ"],
+        output_type="ConditionType.COUNT_STAGE",
+    ),
+    Pattern(
+        name="count_energy",
+        phase=PatternPhase.CONDITION,
+        regex=r"エネルギーが(\d+)枚以上",
+        priority=30,
+        output_type="ConditionType.COUNT_ENERGY",
+    ),
+    Pattern(
+        name="count_success_live",
+        phase=PatternPhase.CONDITION,
+        regex=r"成功ライブカード置き場.*?(\d+)枚以上",
+        priority=20,
+        output_type="ConditionType.COUNT_SUCCESS_LIVE",
+    ),
+    Pattern(
+        name="count_live_zone",
+        phase=PatternPhase.CONDITION,
+        regex=r"ライブ中のカード.*?(\d+)枚以上",
+        priority=20,
+        output_type="ConditionType.COUNT_LIVE_ZONE",
+    ),
+    Pattern(
+        name="count_hearts",
+        phase=PatternPhase.CONDITION,
+        regex=r"(?:ハート|heart).*?(\d+)(つ|個)以上",
+        priority=30,
+        output_type="ConditionType.COUNT_HEARTS",
+    ),
+    Pattern(
+        name="count_blades",
+        phase=PatternPhase.CONDITION,
+        regex=r"ブレード.*?(\d+)(つ|個)以上",
+        priority=30,
+        output_type="ConditionType.COUNT_BLADES",
+    ),
+    # ==========================================================================
+    # Comparison conditions
+    # ==========================================================================
+    Pattern(
+        name="score_compare_gt",
+        phase=PatternPhase.CONDITION,
+        regex=r"(?:スコア|コスト).*?相手.*?より(?:高い|多い)",
+        priority=25,
+        output_type="ConditionType.SCORE_COMPARE",
+        output_params={"comparison": "GT", "target": "opponent"},
+    ),
+    Pattern(
+        name="score_compare_ge",
+        phase=PatternPhase.CONDITION,
+        regex=r"(?:スコア|コスト).*?同じか(?:高い|多い)",
+        priority=25,
+        output_type="ConditionType.SCORE_COMPARE",
+        output_params={"comparison": "GE", "target": "opponent"},
+    ),
+    Pattern(
+        name="score_compare_lt",
+        phase=PatternPhase.CONDITION,
+        regex=r"(?:スコア|コスト).*?相手.*?より(?:低い|少ない)",
+        priority=25,
+        output_type="ConditionType.SCORE_COMPARE",
+        output_params={"comparison": "LT", "target": "opponent"},
+    ),
+    Pattern(
+        name="score_compare_eq",
+        phase=PatternPhase.CONDITION,
+        regex=r"(?:スコア|コスト).*?同じ(?:場合|なら|とき)",
+        priority=25,
+        output_type="ConditionType.SCORE_COMPARE",
+        output_params={"comparison": "EQ", "target": "opponent"},
+    ),
+    Pattern(
+        name="opponent_hand_diff",
+        phase=PatternPhase.CONDITION,
+        regex=r"相手の手札(?:の枚数)?が自分より(\d+)?枚?以上?多い",
+        priority=25,
+        output_type="ConditionType.OPPONENT_HAND_DIFF",
+    ),
+    Pattern(
+        name="opponent_energy_diff",
+        phase=PatternPhase.CONDITION,
+        regex=r"相手のエネルギーが自分より(?:(\d+)枚以上)?多い",
+        priority=25,
+        output_type="ConditionType.OPPONENT_ENERGY_DIFF",
+    ),
+    Pattern(
+        name="life_lead_gt",
+        phase=PatternPhase.CONDITION,
+        regex=r"ライフが相手より多い",
+        priority=25,
+        output_type="ConditionType.LIFE_LEAD",
+        output_params={"comparison": "GT", "target": "opponent"},
+    ),
+    Pattern(
+        name="life_lead_lt",
+        phase=PatternPhase.CONDITION,
+        regex=r"ライフが相手より少ない",
+        priority=25,
+        output_type="ConditionType.LIFE_LEAD",
+        output_params={"comparison": "LT", "target": "opponent"},
+    ),
+    Pattern(
+        name="opponent_choice_select",
+        phase=PatternPhase.CONDITION,
+        keywords=["相手", "選ぶ"],
+        excludes=["自分か相手"],
+        priority=30,
+        output_type="ConditionType.OPPONENT_CHOICE",
+        output_params={"type": "select"},
+    ),
+    Pattern(
+        name="opponent_choice_discard",
+        phase=PatternPhase.CONDITION,
+        keywords=["相手", "手札", "捨て"],
+        priority=30,
+        output_type="ConditionType.OPPONENT_CHOICE",
+        output_params={"type": "discard"},
+    ),
+    # ==========================================================================
+    # State conditions
+    # ==========================================================================
+    Pattern(
+        name="is_center",
+        phase=PatternPhase.CONDITION,
+        keywords=["センターエリア", "場合"],
+        priority=40,
+        output_type="ConditionType.IS_CENTER",
+    ),
+    Pattern(
+        name="has_moved",
+        phase=PatternPhase.CONDITION,
+        keywords=["移動している場合"],
+        priority=30,
+        output_type="ConditionType.HAS_MOVED",
+    ),
+    Pattern(
+        name="has_live_card",
+        phase=PatternPhase.CONDITION,
+        keywords=["ライブカードがある場合"],
+        priority=30,
+        output_type="ConditionType.HAS_LIVE_CARD",
+    ),
+    Pattern(
+        name="has_choice",
+        phase=PatternPhase.CONDITION,
+        regex=r"(?:1つを選ぶ|どちらか.*?選ぶ|選んでもよい|のうち.*?選ぶ)",
+        priority=40,
+        output_type="ConditionType.HAS_CHOICE",
+    ),
+    Pattern(
+        name="group_filter",
+        phase=PatternPhase.CONDITION,
+        regex=r"『(.*?)』",
+        priority=60,
+        requires=["場合", "なら", "がいる"],
+        output_type="ConditionType.GROUP_FILTER",
+    ),
+    Pattern(
+        name="has_member",
+        phase=PatternPhase.CONDITION,
+        regex=r"「(.*?)」.*?(?:がある|がいる|登場している)場合",
+        priority=30,
+        output_type="ConditionType.HAS_MEMBER",
+    ),
+    # ==========================================================================
+    # Once per turn / Turn restrictions
+    # ==========================================================================
+    Pattern(
+        name="turn_1",
+        phase=PatternPhase.CONDITION,
+        regex=r"\[Turn 1\]|1ターン目|ターン1(?!回)",
+        priority=20,
+        output_type="ConditionType.TURN_1",
+        output_params={"turn": 1},
+    ),
+    # ==========================================================================
+    # Revealed/Milled card conditions
+    # ==========================================================================
+    Pattern(
+        name="all_revealed_are_members",
+        phase=PatternPhase.CONDITION,
+        regex=r"それらがすべてメンバーカード.*?場合",
+        priority=15,
+        output_type="ConditionType.GROUP_FILTER",
+        output_params={"filter_type": "all_revealed", "card_type": "member"},
+    ),
+    Pattern(
+        name="is_in_discard",
+        phase=PatternPhase.CONDITION,
+        regex=r"この(カード|メンバー)が控え室にある場合のみ起動できる",
+        priority=10,
+        output_type="ConditionType.IS_IN_DISCARD",
+    ),
+]

compiler/patterns/effects.py

@@ -0,0 +1,644 @@
+# -*- coding: utf-8 -*-
+"""Effect patterns.
+
+Effects are the actions that occur when an ability activates.
+Examples: DRAW, ADD_BLADES, RECOVER_MEMBER, etc.
+"""
+
+from .base import Pattern, PatternPhase
+
+EFFECT_PATTERNS = [
+    # ==========================================================================
+    # Card manipulation effects
+    # ==========================================================================
+    Pattern(
+        name="draw_cards",
+        phase=PatternPhase.EFFECT,
+        regex=r"カード.*?(\d+)枚.*?引",
+        priority=20,
+        excludes=["引き入れ"],  # "bring under" is not draw
+        consumes=True,
+        output_type="EffectType.DRAW",
+    ),
+    Pattern(
+        name="draw_pseudocode",
+        phase=PatternPhase.EFFECT,
+        regex=r"DRAW\((.*?)\)",
+        priority=5,
+        consumes=True,
+        output_type="EffectType.DRAW",
+        extractor=lambda text, m: {
+            "type": "EffectType.DRAW",
+            "value": int(m.group(1)) if m.group(1).isdigit() else 0,
+            "value_cond": m.group(1) if not m.group(1).isdigit() else None,
+        },
+    ),
+    Pattern(
+        name="draw_one",
+        phase=PatternPhase.EFFECT,
+        regex=r"引く",
+        priority=50,
+        excludes=["引き入れ", "置いた枚数分"],
+        consumes=True,
+        output_type="EffectType.DRAW",
+        output_value=1,
+    ),
+    Pattern(
+        name="look_deck_top",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:デッキ|山札)の一番上.*?見る",
+        priority=19,
+        output_type="EffectType.LOOK_DECK",
+        output_value=1,
+    ),
+    Pattern(
+        name="look_deck",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:デッキ|山札).*?(\d+)枚.*?(?:見る|見て)",
+        priority=20,
+        output_type="EffectType.LOOK_DECK",
+    ),
+    Pattern(
+        name="search_deck",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["探", "サーチ"],
+        requires=["デッキ"],
+        priority=30,
+        output_type="EffectType.SEARCH_DECK",
+        output_value=1,
+    ),
+    Pattern(
+        name="search_deck_from",
+        phase=PatternPhase.EFFECT,
+        # "デッキから...手札に加える" (search deck for card, add to hand)
+        regex=r"(?:デッキ|山札)から.*?手札に加",
+        priority=5,  # Very high priority to catch before ADD_TO_HAND
+        consumes=True,
+        output_type="EffectType.SEARCH_DECK",
+        output_value=1,
+        output_params={"to": "hand"},
+    ),
+    Pattern(
+        name="reveal_cards",
+        phase=PatternPhase.EFFECT,
+        regex=r"(\d+)枚.*?公開",
+        priority=30,
+        excludes=["エール"],  # Not cheer-based reveal
+        output_type="EffectType.REVEAL_CARDS",
+    ),
+    Pattern(
+        name="reveal_top",
+        phase=PatternPhase.EFFECT,
+        regex=r"デッキの一番上.*?公開",
+        priority=20,
+        output_type="EffectType.REVEAL_CARDS",
+        output_value=1,
+    ),
+    Pattern(
+        name="choose_heart_icons",
+        phase=PatternPhase.EFFECT,
+        regex=r"({{heart_.*?}}か{{heart_.*?}}).*?選ぶ",
+        priority=15,
+        output_type="EffectType.COLOR_SELECT",
+    ),
+    Pattern(
+        name="return_discard_to_deck_bottom",
+        phase=PatternPhase.EFFECT,
+        regex=r"デッキの一番下に置く",
+        priority=15,
+        output_type="EffectType.MOVE_TO_DECK",
+        output_params={"to": "deck_bottom"},
+    ),
+    Pattern(
+        name="add_hearts_color_text",
+        phase=PatternPhase.EFFECT,
+        regex=r"［(赤|青|黄|緑|紫|桃)ハート］.*?得る",
+        priority=15,
+        output_type="EffectType.ADD_HEARTS",
+        extractor=lambda text, m: {"type": "EffectType.ADD_HEARTS", "value": 1, "params": {"color_text": m.group(1)}},
+    ),
+    Pattern(
+        name="look_and_choose_order",
+        phase=PatternPhase.EFFECT,
+        regex=r"LOOK_AND_CHOOSE_ORDER\((\d+)\)",
+        priority=20,
+        output_type="EffectType.ORDER_DECK",
+        extractor=lambda text, m: {
+            "type": "EffectType.ORDER_DECK",
+            "value": int(m.group(1)),
+        },
+    ),
+    Pattern(
+        name="select_from_pool",
+        phase=PatternPhase.EFFECT,
+        regex=r"の中から.*?(\d+)?(枚|人).*?選ぶ",
+        priority=20,
+        output_type="EffectType.LOOK_AND_CHOOSE",
+        extractor=lambda text, m: {
+            "type": "EffectType.LOOK_AND_CHOOSE",
+            "value": int(m.group(1)) if m.group(1) else 1,
+        },
+    ),
+    # ==========================================================================
+    # Recovery effects
+    # ==========================================================================
+    Pattern(
+        name="add_self_to_hand",
+        phase=PatternPhase.EFFECT,
+        regex=r"この(カード|メンバー)を手札に加",
+        priority=15,
+        output_type="EffectType.ADD_TO_HAND",
+        output_params={"target": "self", "to": "hand"},
+    ),
+    Pattern(
+        name="place_member_to_hand",
+        phase=PatternPhase.EFFECT,
+        regex=r"メンバーを?.*?手札に加",
+        priority=30,  # Lower precedence
+        consumes=True,
+        output_type="EffectType.ADD_TO_HAND",
+        output_params={"to": "hand"},
+    ),
+    Pattern(
+        name="recover_member",
+        phase=PatternPhase.EFFECT,
+        regex=r"控え室から.*?メンバーを?.*?手札に加",
+        priority=10,  # High precedence to consume early
+        consumes=True,
+        output_type="EffectType.RECOVER_MEMBER",
+        output_value=1,
+        output_params={"from": "discard", "to": "hand"},
+    ),
+    Pattern(
+        name="recover_from_success",
+        phase=PatternPhase.EFFECT,
+        regex=r"成功ライブカード(?:置き場)?[\s\S]*?手札に加",
+        priority=20,
+        output_type="EffectType.RECOVER_LIVE",
+        output_value=1,
+        output_params={"from": "success_zone", "to": "hand"},
+    ),
+    Pattern(
+        name="recover_live",
+        phase=PatternPhase.EFFECT,
+        regex=r"控え室から.*?ライブカードを?.*?手札に加",
+        priority=10,
+        consumes=True,
+        output_type="EffectType.RECOVER_LIVE",
+        output_value=1,
+        output_params={"from": "discard", "to": "hand"},
+    ),
+    Pattern(
+        name="add_to_hand_from_deck",
+        phase=PatternPhase.EFFECT,
+        keywords=["デッキ", "手札に加え"],
+        excludes=["見る", "選"],  # Not look and choose
+        priority=25,
+        consumes=True,
+        output_type="EffectType.ADD_TO_HAND",
+        output_params={"from": "deck"},
+    ),
+    Pattern(
+        name="look_and_choose",
+        phase=PatternPhase.EFFECT,
+        # Relaxed regex to allow filters between "look" and "choose"
+        regex=r"(?:カードを?|[\{\[].*?[\}\]])?(\d+)枚(見て|見る).*?(?:その中から|その中にある|公開された).*?(?:カードを?)?(\d+)?(?:枚|つ)?.*?手札に加",
+        priority=10,  # High priority to catch before LOOK_DECK
+        consumes=True,
+        output_type="EffectType.LOOK_AND_CHOOSE",
+        extractor=lambda text, m: {
+            "type": "EffectType.LOOK_AND_CHOOSE",
+            "value": int(m.group(3)) if m.group(3) else 1,
+            "params": {"look_count": int(m.group(1))},
+        },
+    ),
+    Pattern(
+        name="discard_looked",
+        phase=PatternPhase.EFFECT,
+        # "そのカードを控え室に置く" (referring to looked card)
+        regex=r"(?:その|公開した|見た)カードを?.*?控え室に置",
+        priority=25,
+        consumes=True,
+        output_type="EffectType.LOOK_AND_CHOOSE",
+        output_value=1,
+        output_params={"look_count": 1, "destination": "discard"},
+    ),
+    Pattern(
+        name="mill_to_discard",
+        phase=PatternPhase.EFFECT,
+        # "デッキの上からカードをX枚控え室に置く"
+        regex=r"(?:デッキ|山札).*?(\d+)枚.*?控え室に置",
+        priority=15,  # Higher priority than generic swap_to_discard
+        consumes=True,
+        output_type="EffectType.SWAP_CARDS",
+        extractor=lambda text, m: {
+            "type": "EffectType.SWAP_CARDS",
+            "value": int(m.group(1)),
+            "params": {"from": "deck", "target": "discard"},
+        },
+    ),
+    Pattern(
+        name="discard_remainder",
+        phase=PatternPhase.EFFECT,
+        regex=r"残りを?控え室に",
+        priority=20,
+        consumes=True,
+        output_type="EffectType.SWAP_CARDS",
+        output_params={"target": "discard"},
+    ),
+    Pattern(
+        name="choose_player",
+        phase=PatternPhase.EFFECT,
+        regex=r"自分か相手を選",
+        priority=5,  # Very high priority
+        output_type="EffectType.META_RULE",
+        output_params={"target": "PLAYER_SELECT"},
+    ),
+    # ==========================================================================
+    # Stat modification effects
+    # ==========================================================================
+    Pattern(
+        name="add_blades",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:{{icon_blade.*?}})?ブレード[^スコア場合]*?[+＋](\d+|１|２|３)",
+        priority=20,
+        output_type="EffectType.ADD_BLADES",
+    ),
+    Pattern(
+        name="add_blades_gain",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:{{icon_blade.*?}})?ブレード.*?を得る",
+        priority=30,
+        output_type="EffectType.ADD_BLADES",
+        output_value=1,
+    ),
+    Pattern(
+        name="add_hearts",
+        phase=PatternPhase.EFFECT,
+        regex=r"ハート[^スコア場合]*?[+＋](\d+|１|２|３)",
+        priority=20,
+        output_type="EffectType.ADD_HEARTS",
+    ),
+    Pattern(
+        name="add_hearts_gain",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:{{(?:heart_\d+|icon_heart).*?}})?ハートを?(\d+|１|２|３)?(つ|個|枚)?(を)?得る",
+        priority=20,
+        output_type="EffectType.ADD_HEARTS",
+        extractor=lambda text, m: {
+            "type": "EffectType.ADD_HEARTS",
+            "value": int(m.group(1)) if m.group(1) else 1,
+        },
+    ),
+    Pattern(
+        name="add_hearts_icon",
+        phase=PatternPhase.EFFECT,
+        # Heart icons: {{heart_XX.png|heartXX}}を得る
+        regex=r"({{heart_\d+\.png\|heart\d+}})+(を)?得る",
+        priority=10,  # Very high priority
+        consumes=True,
+        output_type="EffectType.ADD_HEARTS",
+        extractor=lambda text, m: {
+            "type": "EffectType.ADD_HEARTS",
+            "value": text[: m.end()].count("{{heart_"),  # Count heart icons
+            "params": {},
+        },
+    ),
+    Pattern(
+        name="boost_score",
+        phase=PatternPhase.EFFECT,
+        regex=r"スコア.*?[+＋](\d+|１|２|３)",
+        priority=20,
+        output_type="EffectType.BOOST_SCORE",
+    ),
+    Pattern(
+        name="reduce_heart_req",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["必要ハート", "ハート条件"],
+        requires=["減", "少なく"],
+        priority=25,
+        output_type="EffectType.REDUCE_HEART_REQ",
+    ),
+    # ==========================================================================
+    # Energy effects
+    # ==========================================================================
+    Pattern(
+        name="energy_charge",
+        phase=PatternPhase.EFFECT,
+        regex=r"エネルギー(?:カード)?を?(\d+)?枚.*?(?:置く|加える|チャージ)",
+        priority=25,
+        excludes=["控え室", "の上から", "を公開", "公開された"],
+        output_type="EffectType.ENERGY_CHARGE",
+    ),
+    # ==========================================================================
+    # Movement/Position effects
+    # ==========================================================================
+    Pattern(
+        name="move_member",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["ポジションチェンジ", "移動させ", "移動する", "場所を入れ替える"],
+        priority=25,
+        output_type="EffectType.MOVE_MEMBER",
+        output_value=1,
+    ),
+    Pattern(
+        name="tap_opponent",
+        phase=PatternPhase.EFFECT,
+        regex=r"相手.*?(\d+)?人?.*?(?:ウェイト|休み)",
+        priority=25,
+        output_type="EffectType.TAP_OPPONENT",
+    ),
+    Pattern(
+        name="activate_member",
+        phase=PatternPhase.EFFECT,
+        keywords=["アクティブに"],
+        excludes=["手札", "加え"],  # Not "add card with active ability"
+        priority=25,
+        output_type="EffectType.ACTIVATE_MEMBER",
+        output_value=1,
+    ),
+    # ==========================================================================
+    # Zone transfer effects
+    # ==========================================================================
+    Pattern(
+        name="swap_to_discard",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["控え室に置", "控え室に送"],
+        priority=30,
+        output_type="EffectType.SWAP_CARDS",
+        output_params={"target": "discard"},
+        extractor=lambda text, m: {
+            "type": "EffectType.SWAP_CARDS",
+            "params": {"target": "discard", "from": "deck" if "デッキ" in text or "山札" in text else "field"},
+        },
+    ),
+    Pattern(
+        name="move_to_deck",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["デッキに戻す", "山札に置く"],
+        priority=30,
+        output_type="EffectType.MOVE_TO_DECK",
+    ),
+    Pattern(
+        name="return_discard_to_deck",
+        phase=PatternPhase.EFFECT,
+        # "控え室にある...デッキの一番上に置く" (place from discard to top of deck)
+        regex=r"控え室.*?(\d+)枚.*?(?:デッキ|山札).*?一番上に置",
+        priority=15,
+        consumes=True,
+        output_type="EffectType.MOVE_TO_DECK",
+        extractor=lambda text, m: {
+            "type": "EffectType.MOVE_TO_DECK",
+            "value": int(m.group(1)),
+            "params": {"from": "discard", "to": "deck_top"},
+        },
+    ),
+    Pattern(
+        name="place_under",
+        phase=PatternPhase.EFFECT,
+        keywords=["の下に置"],
+        excludes=["コスト", "払"],  # Not cost
+        priority=30,
+        output_type="EffectType.PLACE_UNDER",
+    ),
+    # ==========================================================================
+    # Meta/Rule effects
+    # ==========================================================================
+    Pattern(
+        name="select_mode",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:以下から|のうち、)(\d+|１|２|３)(つ|枚|回)?を選ぶ",
+        priority=20,
+        output_type="EffectType.SELECT_MODE",
+    ),
+    Pattern(
+        name="color_select",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["ハートの色を1つ指定", "好きなハートの色を"],
+        priority=25,
+        output_type="EffectType.COLOR_SELECT",
+        output_value=1,
+    ),
+    Pattern(
+        name="negate_effect",
+        phase=PatternPhase.EFFECT,
+        any_keywords=["無効", "キャンセル"],
+        priority=25,
+        output_type="EffectType.NEGATE_EFFECT",
+        output_value=1,
+    ),
+    Pattern(
+        name="shuffle_deck",
+        phase=PatternPhase.EFFECT,
+        keywords=["シャッフル"],
+        priority=40,
+        output_type="EffectType.META_RULE",
+        output_params={"type": "shuffle", "deck": True},
+    ),
+    Pattern(
+        name="play_member_from_hand",
+        phase=PatternPhase.EFFECT,
+        regex=r"手札から.*?登場させ",
+        priority=15,
+        output_type="EffectType.PLAY_MEMBER_FROM_HAND",
+        output_value=1,
+    ),
+    Pattern(
+        name="play_member_from_discard",
+        phase=PatternPhase.EFFECT,
+        regex=r"控え室から.*?登場させ",
+        priority=15,
+        output_type="EffectType.PLAY_MEMBER_FROM_DISCARD",
+        output_value=1,
+    ),
+    Pattern(
+        name="tap_self",
+        phase=PatternPhase.EFFECT,
+        regex=r"このメンバーをウェイトにする",
+        priority=20,
+        output_type="EffectType.TAP_MEMBER",
+        output_params={"target": "self"},
+    ),
+    Pattern(
+        name="card_selection",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:控え室にある|デッキにある|ステージにいる)?.*?(\d+)枚選ぶ",
+        priority=50,  # Low priority
+        output_type="EffectType.LOOK_AND_CHOOSE",
+    ),
+    # ==========================================================================
+    # Cost/Constant modifiers parsed as effects
+    # ==========================================================================
+    Pattern(
+        name="reduce_cost_self",
+        phase=PatternPhase.EFFECT,
+        # "コストは...X少なくなる" OR "コストはX減る" (cost is reduced by X)
+        regex=r"コストは.*?(\d+)(?:少なく|減る|減)",
+        priority=15,
+        consumes=True,
+        output_type="EffectType.REDUCE_COST",
+    ),
+    Pattern(
+        name="reduce_cost_per_card",
+        phase=PatternPhase.EFFECT,
+        # "手札1枚につき、1少なくなる" (reduced by 1 per card in hand)
+        regex=r"手札.*?(\d+)枚につき.*?(\d+)少なく",
+        priority=10,  # Higher than reduce_cost_self
+        consumes=True,
+        output_type="EffectType.REDUCE_COST",
+        extractor=lambda text, m: {
+            "type": "EffectType.REDUCE_COST",
+            "value": int(m.group(2)),
+            "params": {"per_card": int(m.group(1)), "zone": "hand"},
+        },
+    ),
+    Pattern(
+        name="grant_ability",
+        phase=PatternPhase.EFFECT,
+        # Ability granting: "能力を得る" / "」を得る"
+        regex=r"(?:」|{{.*?}}).*?を得る",
+        priority=25,
+        consumes=False,  # Allow inner effects to be parsed
+        output_type="EffectType.BUFF_POWER",
+        output_value=1,
+    ),
+    Pattern(
+        name="grant_stat_buff",
+        phase=PatternPhase.EFFECT,
+        # "ブレード+X」を得る" / "ハート+X」を得る" (gain Blade+X / Heart+X)
+        regex=r"(ブレード|ハート)[+＋](\d+)[」」].*?得る",
+        priority=15,
+        consumes=True,
+        output_type="EffectType.BUFF_POWER",
+        extractor=lambda text, m: {
+            "type": "EffectType.BUFF_POWER" if "ブレード" in m.group(1) else "EffectType.ADD_HEARTS",
+            "value": int(m.group(2)),
+            "params": {"stat": "blade" if "ブレード" in m.group(1) else "heart"},
+        },
+    ),
+    Pattern(
+        name="tap_member_cost",
+        phase=PatternPhase.EFFECT,
+        # Tap member as cost/effect: "メンバーXをウェイトにしてもよい"
+        regex=r"メンバー.*?(\d+)人?.*?ウェイトにして",
+        priority=25,
+        consumes=True,
+        output_type="EffectType.TAP_MEMBER",
+        extractor=lambda text, m: {"type": "EffectType.TAP_MEMBER", "value": int(m.group(1)), "params": {"cost": True}},
+    ),
+    Pattern(
+        name="draw_equal_to_discarded",
+        phase=PatternPhase.EFFECT,
+        regex=r"置いた枚数分カードを引く",
+        priority=15,
+        consumes=True,
+        output_type="EffectType.DRAW",
+        output_params={"multiplier": "discarded_count"},
+    ),
+    Pattern(
+        name="trigger_ability",
+        phase=PatternPhase.EFFECT,
+        regex=r"(能力1つ)?を?発動させる",
+        priority=20,
+        consumes=True,
+        output_type="EffectType.TRIGGER_REMOTE",
+    ),
+    Pattern(
+        name="treat_as_all_colors",
+        phase=PatternPhase.EFFECT,
+        regex=r"属性を全ての属性として扱う",
+        priority=20,
+        output_type="EffectType.META_RULE",
+        output_params={"type": "all_colors"},
+    ),
+    Pattern(
+        name="transform_base_hearts",
+        phase=PatternPhase.EFFECT,
+        regex=r"元々持つハートはすべて.*?({{heart_.*?}})?になる",
+        priority=20,
+        output_type="EffectType.TRANSFORM_COLOR",
+        output_params={"target": "base_hearts"},
+    ),
+    Pattern(
+        name="add_from_reveal_to_hand",
+        phase=PatternPhase.EFFECT,
+        regex=r"(?:公開された|公開される).*?手札に加",
+        priority=20,
+        output_type="EffectType.ADD_TO_HAND",
+        output_params={"from": "reveal_zone", "to": "hand"},
+    ),
+    Pattern(
+        name="recover_live_to_zone",
+        phase=PatternPhase.EFFECT,
+        regex=r"控え室からライブカードを.*?ライブカード置き場に置",
+        priority=20,
+        output_type="EffectType.PLAY_LIVE_FROM_DISCARD",
+        output_value=1,
+    ),
+    Pattern(
+        name="increase_cost",
+        phase=PatternPhase.EFFECT,
+        regex=r"コストを?[+＋](\d+)する",
+        priority=20,
+        output_type="EffectType.REDUCE_COST",  # Use negative for increase in engine or separate Opcode
+        extractor=lambda text, m: {
+            "type": "EffectType.REDUCE_COST",
+            "value": -int(m.group(1)),
+        },
+    ),
+    Pattern(
+        name="increase_heart_req",
+        phase=PatternPhase.EFFECT,
+        regex=r"必要ハートが.*?多くなる",
+        priority=20,
+        output_type="EffectType.REDUCE_HEART_REQ",
+        output_value=1,  # Default increase by 1 if value not specified
+    ),
+    Pattern(
+        name="modify_cheer_count",
+        phase=PatternPhase.EFFECT,
+        regex=r"エールによって公開される.*?枚数が.*?(\d+)枚(減る|増える)",
+        priority=20,
+        output_type="EffectType.META_RULE",
+        extractor=lambda text, m: {
+            "type": "EffectType.META_RULE",
+            "params": {"type": "cheer_mod"},
+            "value": -int(m.group(1)) if m.group(2) == "減る" else int(m.group(1)),
+        },
+    ),
+    Pattern(
+        name="play_member_from_discard",
+        phase=PatternPhase.EFFECT,
+        regex=r"控え室(?:にある|から).*?登場させ",
+        priority=15,
+        output_type="EffectType.PLAY_MEMBER_FROM_DISCARD",
+        output_value=1,
+    ),
+    Pattern(
+        name="baton_touch_mod",
+        phase=PatternPhase.EFFECT,
+        regex=r"(\d+)人のメンバーとバトンタッチ",
+        priority=20,
+        output_type="EffectType.BATON_TOUCH_MOD",
+        extractor=lambda text, m: {
+            "type": "EffectType.BATON_TOUCH_MOD",
+            "value": int(m.group(1)),
+        },
+    ),
+    Pattern(
+        name="rule_equivalence",
+        phase=PatternPhase.EFFECT,
+        regex=r"についても同じこと(として扱う|を行う)",
+        priority=20,
+        output_type="EffectType.META_RULE",
+        output_params={"type": "rule_equivalence"},
+    ),
+    Pattern(
+        name="restriction_no_live",
+        phase=PatternPhase.EFFECT,
+        regex=r"自分はライブ(できない|出来ません)",
+        priority=20,
+        output_type="EffectType.RESTRICTION",
+        output_params={"type": "no_live"},
+    ),
+]

compiler/patterns/modifiers.py

@@ -0,0 +1,176 @@
+"""Modifier patterns.
+
+Modifiers apply flags and adjustments to parsed abilities:
+- is_optional: Whether the effect can be declined
+- is_once_per_turn: Usage limit
+- duration: How long effects last
+- target: Who is affected
+"""
+
+from .base import Pattern, PatternPhase
+
+MODIFIER_PATTERNS = [
+    # ==========================================================================
+    # Optionality (key fix for the bug in legacy parser)
+    # ==========================================================================
+    Pattern(
+        name="optional_may",
+        phase=PatternPhase.MODIFIER,
+        regex=r"てもよい",
+        priority=10,
+        output_params={"is_optional": True},
+    ),
+    Pattern(
+        name="optional_can",
+        phase=PatternPhase.MODIFIER,
+        regex=r"てよい",
+        priority=10,
+        output_params={"is_optional": True},
+    ),
+    Pattern(
+        name="optional_cost",
+        phase=PatternPhase.MODIFIER,
+        regex=r"(?:支払うことで|支払えば)",
+        priority=15,
+        output_params={"cost_is_optional": True},
+    ),
+    # ==========================================================================
+    # Usage limits
+    # ==========================================================================
+    Pattern(
+        name="once_per_turn",
+        phase=PatternPhase.MODIFIER,
+        regex=r"1ターンに1回|ターン終了時まで1回|に限る|ターン1回|［ターン1回］|【ターン1回】",
+        priority=10,
+        output_params={"is_once_per_turn": True},
+    ),
+    # ==========================================================================
+    # Duration modifiers
+    # ==========================================================================
+    Pattern(
+        name="until_live_end",
+        phase=PatternPhase.MODIFIER,
+        keywords=["ライブ終了時まで"],
+        priority=20,
+        output_params={"duration": "live_end"},
+    ),
+    Pattern(
+        name="until_turn_end",
+        phase=PatternPhase.MODIFIER,
+        regex=r"ターン終了まで|終了時まで",
+        priority=20,
+        excludes=["ライブ終了時まで"],  # More specific pattern takes precedence
+        output_params={"duration": "turn_end"},
+    ),
+    # ==========================================================================
+    # Target modifiers
+    # ==========================================================================
+    Pattern(
+        name="target_all_players",
+        phase=PatternPhase.MODIFIER,
+        any_keywords=["自分と相手", "自分も相手も", "全員", "自分および相手"],
+        priority=20,
+        output_params={"target": "ALL_PLAYERS", "both_players": True},
+    ),
+    Pattern(
+        name="target_opponent",
+        phase=PatternPhase.MODIFIER,
+        regex=r"相手は.*?(?:する|引く|置く)",
+        priority=25,
+        excludes=["自分は", "自分を"],
+        output_params={"target": "OPPONENT"},
+    ),
+    Pattern(
+        name="target_opponent_hand",
+        phase=PatternPhase.MODIFIER,
+        keywords=["相手の手札"],
+        priority=20,
+        output_params={"target": "OPPONENT_HAND"},
+    ),
+    # ==========================================================================
+    # Scope modifiers
+    # ==========================================================================
+    Pattern(
+        name="scope_all",
+        phase=PatternPhase.MODIFIER,
+        keywords=["すべての"],
+        priority=30,
+        output_params={"all": True},
+    ),
+    # ==========================================================================
+    # Multiplier modifiers
+    # ==========================================================================
+    Pattern(
+        name="multiplier_per_unit",
+        phase=PatternPhase.MODIFIER,
+        regex=r"(\d+)(枚|人)につき",
+        priority=20,
+        output_params={"has_multiplier": True},
+    ),
+    Pattern(
+        name="multiplier_per_member",
+        phase=PatternPhase.MODIFIER,
+        keywords=["人につき"],
+        priority=25,
+        output_params={"per_member": True},
+    ),
+    Pattern(
+        name="multiplier_per_live",
+        phase=PatternPhase.MODIFIER,
+        any_keywords=["成功ライブカード", "ライブカード"],
+        requires=["につき", "枚数"],
+        priority=25,
+        output_params={"per_live": True},
+    ),
+    Pattern(
+        name="multiplier_per_energy",
+        phase=PatternPhase.MODIFIER,
+        keywords=["エネルギー"],
+        requires=["につき"],
+        priority=25,
+        output_params={"per_energy": True},
+    ),
+    # ==========================================================================
+    # Filter modifiers (for effect targets)
+    # ==========================================================================
+    Pattern(
+        name="filter_cost_max",
+        phase=PatternPhase.MODIFIER,
+        regex=r"コスト(\d+)以下",
+        priority=25,
+        output_params={"has_cost_filter": True},
+    ),
+    Pattern(
+        name="filter_group",
+        phase=PatternPhase.MODIFIER,
+        regex=r"『(.*?)』",
+        priority=30,
+        consumes=True,
+        extractor=lambda text, m: {"params": {"group": m.group(1)}},
+    ),
+    Pattern(
+        name="filter_names",
+        phase=PatternPhase.MODIFIER,
+        regex=r"「(?!\{\{)(.*?)」",
+        priority=30,
+        consumes=True,
+        extractor=lambda text, m: {"params": {"target_name": m.group(1)}},
+    ),
+    Pattern(
+        name="filter_has_ability",
+        phase=PatternPhase.MODIFIER,
+        any_keywords=["アクティブにする」を持つ", "【起動】"],
+        priority=25,
+        output_params={"has_ability": "active"},
+    ),
+    # ==========================================================================
+    # Meta modifiers
+    # ==========================================================================
+    Pattern(
+        name="opponent_trigger_allowed",
+        phase=PatternPhase.MODIFIER,
+        keywords=["対戦相手のカードの効果でも発動する"],
+        priority=10,
+        output_params={"opponent_trigger_allowed": True},
+    ),
+]

compiler/patterns/registry.py

@@ -0,0 +1,130 @@
+"""Pattern registry for managing and matching patterns."""
+
+from typing import Any, Dict, List, Match, Optional, Tuple
+
+from .base import Pattern, PatternPhase
+
+
+class PatternRegistry:
+    """Central registry for all parsing patterns.
+
+    Patterns are organized by phase and sorted by priority.
+    Lower priority number = higher precedence.
+    """
+
+    def __init__(self):
+        self._patterns: Dict[PatternPhase, List[Pattern]] = {phase: [] for phase in PatternPhase}
+        self._frozen = False
+
+    def register(self, pattern: Pattern) -> "PatternRegistry":
+        """Register a pattern. Returns self for chaining."""
+        if self._frozen:
+            raise RuntimeError("Cannot register patterns after registry is frozen")
+        self._patterns[pattern.phase].append(pattern)
+        return self
+
+    def register_all(self, patterns: List[Pattern]) -> "PatternRegistry":
+        """Register multiple patterns. Returns self for chaining."""
+        for p in patterns:
+            self.register(p)
+        return self
+
+    def freeze(self) -> "PatternRegistry":
+        """Freeze the registry and sort patterns by priority."""
+        for phase in PatternPhase:
+            self._patterns[phase].sort(key=lambda p: p.priority)
+        self._frozen = True
+        return self
+
+    def match_all(
+        self, text: str, phase: PatternPhase, context: Optional[str] = None
+    ) -> List[Tuple[Pattern, Match, Dict[str, Any]]]:
+        """Find all matching patterns for a phase.
+
+        Args:
+            text: Text to match against
+            phase: Which parsing phase to match
+            context: Full sentence context for requires/excludes
+
+        Returns:
+            List of (pattern, match, extracted_data) tuples
+        """
+        results = []
+        working_text = text
+
+        for pattern in self._patterns[phase]:
+            # Loop to find all matches for this pattern
+            while True:
+                # Always check against original context but match against working_text
+                m = pattern.matches(working_text, context or text)
+                if not m:
+                    break
+
+                data = pattern.extract(working_text, m)
+                results.append((pattern, m, data))
+
+                # If pattern consumes, mask out the matched text
+                if pattern.consumes:
+                    start, end = m.start(), m.end()
+                    working_text = working_text[:start] + " " * (end - start) + working_text[end:]
+                    # Continue looking for more matches of this pattern
+                    continue
+
+                # If pattern doesn't consume, we stop after first match to prevent infinite loop
+                break
+
+            if pattern.exclusive and any(r[0] == pattern for r in results):
+                break
+
+        # Sort results by match position to maintain text order
+        results.sort(key=lambda x: x[1].start())
+        return results
+
+    def match_first(
+        self, text: str, phase: PatternPhase, context: Optional[str] = None
+    ) -> Optional[Tuple[Pattern, Match, Dict[str, Any]]]:
+        """Find the first (highest priority) matching pattern.
+
+        Returns:
+            (pattern, match, extracted_data) tuple or None
+        """
+        for pattern in self._patterns[phase]:
+            if m := pattern.matches(text, context):
+                data = pattern.extract(text, m)
+                return (pattern, m, data)
+        return None
+
+    def get_patterns(self, phase: PatternPhase) -> List[Pattern]:
+        """Get all patterns for a phase (for debugging/testing)."""
+        return list(self._patterns[phase])
+
+    def stats(self) -> Dict[str, int]:
+        """Get pattern counts per phase."""
+        return {phase.name: len(patterns) for phase, patterns in self._patterns.items()}
+
+
+# Global registry instance
+_global_registry: Optional[PatternRegistry] = None
+
+
+def get_registry() -> PatternRegistry:
+    """Get the global pattern registry, creating if needed."""
+    global _global_registry
+    if _global_registry is None:
+        _global_registry = PatternRegistry()
+        _load_all_patterns(_global_registry)
+        _global_registry.freeze()
+    return _global_registry
+
+
+def _load_all_patterns(registry: PatternRegistry):
+    """Load all patterns from pattern definition modules."""
+    from .conditions import CONDITION_PATTERNS
+    from .effects import EFFECT_PATTERNS
+    from .modifiers import MODIFIER_PATTERNS
+    from .triggers import TRIGGER_PATTERNS
+
+    registry.register_all(TRIGGER_PATTERNS)
+    registry.register_all(CONDITION_PATTERNS)
+    registry.register_all(EFFECT_PATTERNS)
+    registry.register_all(MODIFIER_PATTERNS)

compiler/patterns/triggers.py

@@ -0,0 +1,158 @@
+"""Trigger detection patterns.
+
+Triggers determine WHEN an ability activates:
+- ON_PLAY: When member enters the stage
+- ON_LIVE_START: When a live begins
+- ON_LIVE_SUCCESS: When a live succeeds
+- ACTIVATED: Manual activation
+- CONSTANT: Always active
+- etc.
+
+Patterns are organized in tiers:
+- Tier 1 (priority 10-19): Icon filenames (most reliable)
+- Tier 2 (priority 20-29): Specific phrases
+- Tier 3 (priority 30-39): Generic kanji keywords
+"""
+
+from .base import Pattern, PatternPhase
+
+TRIGGER_PATTERNS = [
+    # ==========================================================================
+    # TIER 1: Icon-based triggers (highest priority)
+    # ==========================================================================
+    Pattern(
+        name="on_play_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"toujyou",
+        priority=10,
+        output_type="TriggerType.ON_PLAY",
+    ),
+    Pattern(
+        name="on_live_start_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"live_start",
+        priority=10,
+        output_type="TriggerType.ON_LIVE_START",
+    ),
+    Pattern(
+        name="on_live_success_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"live_success",
+        priority=10,
+        # Skip if "この能力は...のみ発動する" (activation restriction, not trigger)
+        excludes=["この能力は"],
+        output_type="TriggerType.ON_LIVE_SUCCESS",
+    ),
+    Pattern(
+        name="activated_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"kidou",
+        priority=10,
+        output_type="TriggerType.ACTIVATED",
+    ),
+    Pattern(
+        name="constant_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"jyouji",
+        priority=10,
+        output_type="TriggerType.CONSTANT",
+    ),
+    Pattern(
+        name="on_leaves_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"jidou",
+        priority=10,
+        output_type="TriggerType.ON_LEAVES",
+    ),
+    Pattern(
+        name="live_end_icon",
+        phase=PatternPhase.TRIGGER,
+        regex=r"live_end",
+        priority=10,
+        output_type="TriggerType.TURN_END",
+    ),
+    # ==========================================================================
+    # TIER 2: Specific phrase triggers
+    # ==========================================================================
+    Pattern(
+        name="on_reveal_cheer",
+        phase=PatternPhase.TRIGGER,
+        regex=r"エールにより公開|エールで公開",
+        priority=20,
+        output_type="TriggerType.ON_REVEAL",
+    ),
+    Pattern(
+        name="constant_yell_reveal",
+        phase=PatternPhase.TRIGGER,
+        keywords=["エールで出た"],
+        priority=20,
+        output_type="TriggerType.CONSTANT",
+    ),
+    # ==========================================================================
+    # TIER 3: Kanji keyword triggers
+    # ==========================================================================
+    Pattern(
+        name="on_play_kanji",
+        phase=PatternPhase.TRIGGER,
+        regex=r"登場",
+        priority=30,
+        # Filter: Not when describing "has [Play] ability" etc
+        look_ahead_excludes=["能力", "スキル", "を持つ", "を持たない", "がない"],
+        output_type="TriggerType.ON_PLAY",
+    ),
+    Pattern(
+        name="on_live_start_kanji",
+        phase=PatternPhase.TRIGGER,
+        regex=r"ライブ開始|ライブの開始",
+        priority=30,
+        look_ahead_excludes=["能力", "スキル", "を持つ"],
+        output_type="TriggerType.ON_LIVE_START",
+    ),
+    Pattern(
+        name="on_live_success_kanji",
+        phase=PatternPhase.TRIGGER,
+        regex=r"ライブ成功",
+        priority=30,
+        look_ahead_excludes=["能力", "スキル", "を持つ"],
+        output_type="TriggerType.ON_LIVE_SUCCESS",
+    ),
+    Pattern(
+        name="activated_kanji",
+        phase=PatternPhase.TRIGGER,
+        keywords=["起動"],
+        priority=30,
+        look_ahead_excludes=["能力", "スキル", "を持つ"],
+        output_type="TriggerType.ACTIVATED",
+    ),
+    Pattern(
+        name="constant_kanji",
+        phase=PatternPhase.TRIGGER,
+        keywords=["常時"],
+        priority=30,
+        look_ahead_excludes=["能力", "スキル", "を持つ"],
+        output_type="TriggerType.CONSTANT",
+    ),
+    Pattern(
+        name="on_leaves_kanji",
+        phase=PatternPhase.TRIGGER,
+        keywords=["自動"],
+        priority=30,
+        look_ahead_excludes=["能力", "スキル", "を持つ"],
+        output_type="TriggerType.ON_LEAVES",
+    ),
+    Pattern(
+        name="turn_start",
+        phase=PatternPhase.TRIGGER,
+        keywords=["ターン開始"],
+        priority=30,
+        output_type="TriggerType.TURN_START",
+    ),
+    Pattern(
+        name="turn_end_kanji",
+        phase=PatternPhase.TRIGGER,
+        regex=r"ターン終了|ライブ終了",
+        priority=30,
+        look_ahead_excludes=["まで"],  # "Until end of turn" is duration, not trigger
+        output_type="TriggerType.TURN_END",
+    ),
+]

compiler/search_cards_improved.py

@@ -0,0 +1,17 @@
+import json
+
+
+def search_cards():
+    cards_path = "engine/data/cards.json"
+    with open(cards_path, "r", encoding="utf-8") as f:
+        cards = json.load(f)
+
+    print("Searching for Life Lead patterns...")
+    for cid, card in cards.items():
+        text = card.get("ability", "")
+        if "ライフ" in text or "Life" in text:
+            print(f"[{card.get('card_no')}] {text[:50]}...")
+
+
+if __name__ == "__main__":
+    search_cards()

compiler/tests/debug_clean.py

@@ -0,0 +1,42 @@
+from compiler.parser_v2 import AbilityParserV2
+
+
+def run_debug():
+    with open("debug_output.txt", "w", encoding="utf-8") as f:
+        parser = AbilityParserV2()
+        text = "自分の成功ライブカード置き場にあるカードを1枚手札に加える。"
+
+        f.write(f"Input text repr: {repr(text)}\n")
+
+        # Manually invoke extraction to test registry
+        results = parser.registry.match_all(
+            text,
+            parser.registry.get_patterns(parser.registry._patterns[list(parser.registry._patterns.keys())[2]].phase)[
+                0
+            ].phase,
+        )
+        # Accessing PatternPhase.EFFECT safely
+
+        from compiler.patterns.base import PatternPhase
+
+        results = parser.registry.match_all(text, PatternPhase.EFFECT)
+
+        f.write(f"Matches found: {len(results)}\n")
+        for p, m, d in results:
+            f.write(f"Matched: {p.name}\n")
+
+        # Check specific pattern
+        patterns = parser.registry.get_patterns(PatternPhase.EFFECT)
+        target = next((p for p in patterns if p.name == "recover_from_success"), None)
+        if target:
+            f.write(f"Target pattern found: {target.name}\n")
+            f.write(f"Target keywords: {target.keywords}\n")
+            f.write(f"Target regex: {target.regex}\n")
+            m = target.matches(text)
+            f.write(f"Target match result: {m}\n")
+        else:
+            f.write("Target pattern NOT found in registry.\n")
+
+
+if __name__ == "__main__":
+    run_debug()

compiler/tests/debug_sd1_parsing.py

@@ -0,0 +1,30 @@
+from compiler.parser_v2 import AbilityParserV2
+
+
+def debug_sd1_006():
+    parser = AbilityParserV2()
+    text = "{{toujyou.png|登場}}手札のライブカードを1枚公開してもよい：自分の成功ライブカード置き場にあるカードを1枚手札に加える。そうした場合、これにより公開したカードを自分の成功ライブカード置き場に置く。"
+
+    print(f"Parsing: {text}")
+    print("-" * 50)
+
+    # Manually split to see what parser_v2 sees
+    sentences = parser._split_sentences(parser._preprocess(text))
+    print(f"Sentences: {sentences}")
+
+    parsed = parser.parse(text)
+
+    print("\nParsed Abilities:")
+    for i, ab in enumerate(parsed):
+        print(f"Ability {i}:")
+        print(f"  Raw: {ab.raw_text}")
+        print(f"  Trigger: {ab.trigger}")
+        print(f"  Effects: {len(ab.effects)}")
+        for eff in ab.effects:
+            print(f"    - Type: {eff.effect_type}")
+            print(f"      Val: {eff.value}")
+            print(f"      Params: {eff.params}")
+
+
+if __name__ == "__main__":
+    debug_sd1_006()

compiler/tests/reproduce_bp2_008_p.py

@@ -0,0 +1,30 @@
+from compiler.parser_v2 import AbilityParserV2
+from engine.models.ability import EffectType, TriggerType
+
+
+def test_bp2_008_p_repro_v2():
+    text = "{{kidou.png|起動}}{{turn1.png|ターン1回}}{{icon_energy.png|E}}：このメンバーがいるエリアとは別の自分のエリア1つを選ぶ。このメンバーをそのエリアに移動する。選んだエリアにメンバーがいる場合、そのメンバーは、このメンバーがいたエリアに移動させる。"
+    parser = AbilityParserV2()
+    abilities = parser.parse(text)
+
+    print(f"Parsed {len(abilities)} abilities with V2:")
+    for i, abi in enumerate(abilities):
+        print(f"  Ability {i}: Trigger={abi.trigger.name}, Text='{abi.raw_text}'")
+        for j, eff in enumerate(abi.effects):
+            print(f"    Effect {j}: {eff.effect_type.name}")
+
+    # The goal is to have only 1 ability (ACTIVATED)
+    assert len(abilities) == 1, f"Expected 1 ability, got {len(abilities)}"
+    assert abilities[0].trigger == TriggerType.ACTIVATED
+
+    # It should have the MOVE_MEMBER effects
+    has_move = any(e.effect_type == EffectType.MOVE_MEMBER for e in abilities[0].effects)
+    assert has_move, "Should have MOVE_MEMBER effect"
+
+
+if __name__ == "__main__":
+    try:
+        test_bp2_008_p_repro_v2()
+        print("Test PASSED!")
+    except Exception as e:
+        print(f"Test FAILED: {e}")

compiler/tests/reproduce_failures.py

@@ -0,0 +1,156 @@
+import os
+import sys
+from dataclasses import dataclass
+from typing import List
+
+# Add project root to path
+if __name__ == "__main__":
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+
+from compiler.parser_v2 import AbilityParserV2
+
+
+@dataclass
+class ExpectedAbility:
+    trigger: str
+    effects: List[str]  # Just types for simple check, or dicts for detailed
+    costs: List[str] = None
+    conditions: List[str] = None
+    effect_values: List[int] = None  # Optional: check values of effects in order
+
+
+def check_parser_strict(text: str, expected: ExpectedAbility, name: str = "") -> bool:
+    parser = AbilityParserV2()
+    print(f"Test: {name}")
+    try:
+        abilities = parser.parse(text)
+        if not abilities:
+            print("  FAILURE: No abilities parsed")
+            return False
+
+        ab = abilities[0]  # Assuming single ability
+
+        # Verify Trigger
+        if ab.trigger.name != expected.trigger:
+            print(f"  FAILURE: Trigger mismatch. Expected {expected.trigger}, got {ab.trigger.name}")
+            return False
+
+        # Verify Effects
+        actual_effects = [e.effect_type.name for e in ab.effects]
+        missing_effects = [e for e in expected.effects if e not in actual_effects]
+        if missing_effects:
+            print(f"  FAILURE: Missing effects. Expected {expected.effects}, got {actual_effects}")
+            return False
+
+        # Verify Effect Values
+        if expected.effect_values:
+            actual_values = [e.value for e in ab.effects]
+            # Check length first
+            if len(actual_values) < len(expected.effect_values):
+                print(
+                    f"  FAILURE: Effect value count mismatch. Expected {len(expected.effect_values)}, got {len(actual_values)}"
+                )
+                return False
+
+            for i, val in enumerate(expected.effect_values):
+                if actual_values[i] != val:
+                    print(f"  FAILURE: Effect value mismatch at index {i}. Expected {val}, got {actual_values[i]}")
+                    return False
+
+        # Verify Costs
+        if expected.costs:
+            actual_costs = [c.type.name for c in ab.costs]
+            missing_costs = [c for c in expected.costs if c not in actual_costs]
+            if missing_costs:
+                print(f"  FAILURE: Missing costs. Expected {expected.costs}, got {actual_costs}")
+                return False
+
+        print("  SUCCESS")
+        return True
+
+    except Exception as e:
+        import traceback
+
+        traceback.print_exc()
+        print(f"  ERROR: {e}")
+        return False
+
+
+def run_tests():
+    tests = [
+        (
+            "Mill Effect (PL!-sd1-007-SD)",
+            "{{toujyou.png|登場}}自分のデッキの上からカードを5枚控え室に置く。",
+            ExpectedAbility(
+                trigger="ON_PLAY",
+                effects=["SWAP_CARDS"],
+                effect_values=[5],  # Should be 5
+            ),
+        ),
+        (
+            "Reveal Cost (PL!-sd1-006-SD)",
+            "{{toujyou.png|登場}}手札のライブカードを1枚公開してもよい：自分の成功ライブカード置き場にあるカードを1枚手札に加える。",
+            ExpectedAbility(trigger="ON_PLAY", effects=["RECOVER_LIVE"], costs=["REVEAL_HAND"]),
+        ),
+        (
+            "Optional Cost (PL!-sd1-003-SD)",
+            "{{live_start.png|ライブ開始時}}手札を1枚控え室に置いてもよい：{{heart_01.png|heart01}}か{{heart_03.png|heart03}}か{{heart_06.png|heart06}}のうち、1つを選ぶ。",
+            ExpectedAbility(trigger="ON_LIVE_START", effects=["SELECT_MODE"], costs=["DISCARD_HAND"]),
+        ),
+        (
+            "Swap 10 Cards (PL!-sd1-008-SD)",
+            "{{kidou.png|起動}}{{turn1.png|ターン1回}}{{icon_energy.png|E}}{{icon_energy.png|E}}：自分のデッキの上からカードを10枚控え室に置く。",
+            ExpectedAbility(trigger="ACTIVATED", effects=["SWAP_CARDS"], costs=["ENERGY"], effect_values=[10]),
+        ),
+        (
+            "Search Deck (Generic)",
+            "{{toujyou.png|登場}}自分のデッキから『μ's』のメンバーカードを1枚まで手札に加える。デッキをシャッフルする。",
+            ExpectedAbility(
+                trigger="ON_PLAY",
+                effects=["SEARCH_DECK", "META_RULE"],
+            ),
+        ),
+        (
+            "Score Boost",
+            "{{jyouji.png|常時}}ライブの合計スコアを＋1する。",
+            ExpectedAbility(trigger="CONSTANT", effects=["BOOST_SCORE"], effect_values=[1]),
+        ),
+        (
+            "Add Blades",
+            "{{live_start.png|ライブ開始時}}{{icon_blade.png|ブレード}}を1つ得る。",
+            ExpectedAbility(trigger="ON_LIVE_START", effects=["ADD_BLADES"], effect_values=[1]),
+        ),
+        (
+            "Recover Member",
+            "{{toujyou.png|登場}}自分の控え室からメンバーカードを1枚まで手札に加える。",
+            ExpectedAbility(trigger="ON_PLAY", effects=["RECOVER_MEMBER"], effect_values=[1]),
+        ),
+        (
+            "Recover Live",
+            "{{toujyou.png|登場}}自分の控え室からライブカードを1枚まで手札に加える。",
+            ExpectedAbility(trigger="ON_PLAY", effects=["RECOVER_LIVE"], effect_values=[1]),
+        ),
+    ]
+
+    print(f"Running {len(tests)} parser tests...")
+    print("=" * 60)
+
+    passed = 0
+    failed = 0
+
+    for name, text, expected in tests:
+        if check_parser_strict(text, expected, name):
+            passed += 1
+        else:
+            failed += 1
+
+    print("=" * 60)
+    print(f"Passed: {passed}")
+    print(f"Failed: {failed}")
+
+    if failed > 0:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run_tests()

compiler/tests/reproduce_sd1_006.py

@@ -0,0 +1,30 @@
+from compiler.parser_v2 import AbilityParserV2
+from engine.models.ability import EffectType
+
+
+def test_sd1_006():
+    parser = AbilityParserV2()
+    text = "{{toujyou.png|登場}}手札のライブカードを1枚公開してもよい：自分の成功ライブカード置き場にあるカードを1枚手札に加える。そうした場合、これにより公開したカードを自分の成功ライブカード置き場に置く。"
+
+    print(f"Parsing: {text}")
+    print("-" * 50)
+
+    parsed = parser.parse(text)
+
+    print("\nParsed Effects:")
+    for ability in parsed:
+        for effect in ability.effects:
+            print(f"Effect: {effect.effect_type}")
+            print(f"Params: {effect.params}")
+            print("-" * 30)
+
+    # Check if RECOVER_LIVE is present
+    has_recover = any(e.effect_type == EffectType.RECOVER_LIVE for ab in parsed for e in ab.effects)
+    if has_recover:
+        print("\nSUCCESS: RECOVER_LIVE found.")
+    else:
+        print("\nFAILURE: RECOVER_LIVE not found.")
+
+
+if __name__ == "__main__":
+    test_sd1_006()

compiler/tests/test_card_parsing.py

@@ -0,0 +1,85 @@
+from compiler.parser import AbilityParser
+from engine.models.ability import (
+    AbilityCostType,
+    ConditionType,
+    EffectType,
+    TriggerType,
+)
+
+
+def test_nico_dual_trigger():
+    """Test PL!-PR-009-PR: Dual trigger ON_PLAY / ON_LIVE_START"""
+    text = "{{toujyou.png|登場}}/{{live_start.png|ライブ開始時}}このメンバーをウェイトにしてもよい：相手のステージにいるコスト4以下のメンバー1人をウェイトにする。"
+    abilities = AbilityParser.parse_ability_text(text)
+
+    assert len(abilities) == 2, "Should parse into 2 abilities"
+    assert abilities[0].trigger == TriggerType.ON_PLAY
+    assert abilities[1].trigger == TriggerType.ON_LIVE_START
+
+    for abi in abilities:
+        assert len(abi.costs) == 1
+        assert abi.costs[0].type == AbilityCostType.TAP_SELF
+        assert len(abi.effects) == 1
+        assert abi.effects[0].effect_type == EffectType.TAP_OPPONENT
+
+
+def test_kanata_reveal_hand():
+    """Test PL!N-PR-008-PR: Reveal hand cost + condition"""
+    text = "{{kidou.png|起動}}{{turn1.png|ターン1回}}手札をすべて公開する：自分のステージにほかのメンバーがおり、かつこれにより公開した手札の中にライブカードがない場合、自分のデッキの上からカードを5枚見る。その中からライブカードを1枚公開して手札に加えてもよい。残りを控え室に置く。"
+    abilities = AbilityParser.parse_ability_text(text)
+
+    assert len(abilities) == 1
+    abi = abilities[0]
+
+    # Check Cost
+    assert any(c.type == AbilityCostType.REVEAL_HAND_ALL for c in abi.costs), "Should have REVEAL_HAND_ALL cost"
+
+    # Check Condition
+    assert any(c.type == ConditionType.HAND_HAS_NO_LIVE for c in abi.conditions), (
+        "Should have HAND_HAS_NO_LIVE condition"
+    )
+
+    # Check Effect
+    assert abi.effects[0].effect_type == EffectType.LOOK_DECK
+    assert abi.effects[0].value == 5
+
+
+def test_ginko_parsing():
+    """Test PL!N-PR-012-PR: Look 5, Choose 1 Member"""
+    text = "【登場時】手札を1枚捨ててもよい：そうしたら、デッキの上から5枚見る。その中からメンバーを1枚まで公開し、手札に加える。残りを山札の一番下に望む順番で置く。"
+    abilities = AbilityParser.parse_ability_text(text)
+    assert len(abilities) == 1
+    abi = abilities[0]
+
+    # Check Effects chain
+    # 1. Look Deck 5
+    assert abi.effects[0].effect_type == EffectType.LOOK_DECK
+    assert abi.effects[0].value == 5
+    # 2. Look and Choose (Member)
+    assert abi.effects[1].effect_type == EffectType.LOOK_AND_CHOOSE
+    assert abi.effects[1].params.get("filter") == "member", "Should capture member filter"
+    # 3. Order Deck (Remainder to bottom)
+    assert any(e.effect_type in (EffectType.ORDER_DECK, EffectType.MOVE_TO_DECK) for e in abi.effects), (
+        "Should handle remainder"
+    )
+
+
+def test_honoka_parsing():
+    """Test PL!-sd1-001-SD: Count Success Live Condition & Recover Live Effect"""
+    text = "【登場時】自分の成功ライブカード置き場にカードが2枚以上ある場合、自分の控え室からライブカードを1枚手札に加える。"
+    abilities = AbilityParser.parse_ability_text(text)
+    print(f"DEBUG: Honoka abilities: {abilities}")
+    assert len(abilities) == 1
+    abi = abilities[0]
+
+    # Verify Trigger
+    assert abi.trigger == TriggerType.ON_PLAY
+
+    # Verify Condition
+    assert len(abi.conditions) == 1, f"Expected 1 condition, found {len(abi.conditions)}: {abi.conditions}"
+    assert abi.conditions[0].type == ConditionType.COUNT_SUCCESS_LIVE
+    assert abi.conditions[0].params.get("min") == 2
+
+    # Verify Effect
+    assert len(abi.effects) == 1, f"Expected 1 effect, found {len(abi.effects)}: {abi.effects}"
+    assert abi.effects[0].effect_type == EffectType.RECOVER_LIVE

compiler/tests/test_pseudocode_parsing.py

@@ -0,0 +1,153 @@
+import pytest
+
+from compiler.parser_v2 import AbilityParserV2
+from engine.models.ability import AbilityCostType, ConditionType, EffectType, TargetType, TriggerType
+
+
+@pytest.fixture
+def parser():
+    return AbilityParserV2()
+
+
+def test_basic_trigger(parser):
+    text = "TRIGGER: ON_PLAY\nEFFECT: DRAW(1) -> PLAYER"
+    abilities = parser.parse(text)
+    assert len(abilities) == 1
+    assert abilities[0].trigger == TriggerType.ON_PLAY
+    assert abilities[0].effects[0].effect_type == EffectType.DRAW
+
+
+def test_once_per_turn(parser):
+    text = "TRIGGER: ACTIVATED\n(Once per turn)\nEFFECT: DRAW(1) -> PLAYER"
+    abilities = parser.parse(text)
+    assert abilities[0].is_once_per_turn == True
+
+    # Alternative format (same line)
+    text2 = "TRIGGER: ACTIVATED (Once per turn)\nEFFECT: DRAW(1) -> PLAYER"
+    abilities2 = parser.parse(text2)
+    assert abilities2[0].is_once_per_turn == True
+
+
+def test_costs(parser):
+    text = "TRIGGER: ACTIVATED\nCOST: ENERGY(2), TAP_SELF(0) (Optional)\nEFFECT: DRAW(1) -> PLAYER"
+    abilities = parser.parse(text)
+    costs = abilities[0].costs
+    assert len(costs) == 2
+    assert costs[0].type == AbilityCostType.ENERGY
+    assert costs[0].value == 2
+    assert costs[1].type == AbilityCostType.TAP_SELF
+    assert costs[1].is_optional == True
+
+
+def test_conditions(parser):
+    text = "TRIGGER: ON_PLAY\nCONDITION: COUNT_STAGE {MIN=3}, NOT HAS_COLOR {COLOR=1}\nEFFECT: DRAW(1) -> PLAYER"
+    abilities = parser.parse(text)
+    conds = abilities[0].conditions
+    assert len(conds) == 2
+    assert conds[0].type == ConditionType.COUNT_STAGE
+    assert conds[0].params["min"] == 3
+    assert conds[1].type == ConditionType.HAS_COLOR
+    assert conds[1].params["color"] == 1
+    assert conds[1].is_negated == True
+
+
+def test_effects_with_params(parser):
+    text = 'TRIGGER: ON_PLAY\nEFFECT: RECOVER_MEMBER(1) -> CARD_DISCARD {GROUP="μ\'s", FROM=DISCARD, TO=HAND}'
+    abilities = parser.parse(text)
+    eff = abilities[0].effects[0]
+    assert eff.effect_type == EffectType.RECOVER_MEMBER
+    assert eff.target == TargetType.CARD_DISCARD
+    assert eff.params["group"] == "μ's"
+    assert eff.params["from"] == "discard"
+    assert eff.params["to"] == "hand"
+
+
+def test_case_normalization(parser):
+    # Enums should be case-insensitive in parameters where it makes sense
+    text = "TRIGGER: ON_LIVE_START\nEFFECT: BOOST_SCORE(3) -> PLAYER {UNTIL=LIVE_END}"
+    abilities = parser.parse(text)
+    assert abilities[0].effects[0].params["until"] == "live_end"
+
+
+def test_embedded_json_params(parser):
+    # Some legacy/complex params might be stored as raw JSON in pseudocode
+    text = 'TRIGGER: ON_PLAY\nEFFECT: LOOK_AND_CHOOSE(1) -> CARD_DISCARD {GROUP="Liella!", {"look_count": 5}}'
+    abilities = parser.parse(text)
+    params = abilities[0].effects[0].params
+    assert params["group"] == "Liella!"
+    assert params["look_count"] == 5
+
+
+def test_multiple_abilities(parser):
+    text = """TRIGGER: ON_PLAY
+EFFECT: DRAW(1) -> PLAYER
+
+TRIGGER: TURN_START
+EFFECT: ADD_BLADES(1) -> PLAYER"""
+    abilities = parser.parse(text)
+    assert len(abilities) == 2
+    assert abilities[0].trigger == TriggerType.ON_PLAY
+    assert abilities[1].trigger == TriggerType.TURN_START
+
+
+def test_numeric_parsing(parser):
+    # Ensure values and params handle numbers correctly
+    text = "TRIGGER: ACTIVATED\nCOST: DISCARD_HAND(3)\nCONDITION: COUNT_ENERGY {MIN=5}\nEFFECT: ADD_HEARTS(2) -> PLAYER"
+    abilities = parser.parse(text)
+    ab = abilities[0]
+    assert ab.costs[0].value == 3
+    assert ab.conditions[0].params["min"] == 5
+    assert ab.effects[0].value == 2
+
+
+def test_optional_effect(parser):
+    text = "TRIGGER: ON_PLAY\nEFFECT: SEARCH_DECK(1) -> CARD_HAND {FROM=DECK} (Optional)"
+    abilities = parser.parse(text)
+    assert abilities[0].effects[0].is_optional == True
+
+
+def test_robust_param_splitting(parser):
+    # Mixed spaces and commas
+    text = (
+        'TRIGGER: ON_PLAY\nEFFECT: RECOVER_LIVE(1) -> CARD_DISCARD {GROUP="BiBi",GROUPS=["BiBi","BiBi"], FROM=DISCARD }'
+    )
+    abilities = parser.parse(text)
+    params = abilities[0].effects[0].params
+    assert params["group"] == "BiBi"
+    assert params["groups"] == ["BiBi", "BiBi"]
+    assert params["from"] == "discard"
+
+
+def test_bytecode_compilation(parser):
+    # This is the ultimate proof that the code "works" in the engine
+    text = """TRIGGER: ON_LIVE_START
+COST: DISCARD_HAND(3) {NAMES=["上原歩夢", "澁谷かのん", "日野下花帆"]} (Optional)
+EFFECT: BOOST_SCORE(3) -> PLAYER {UNTIL=LIVE_END}"""
+
+    abilities = parser.parse(text)
+    ab = abilities[0]
+
+    # Compile to bytecode
+    bytecode = ab.compile()
+
+    # Bytecode should:
+    # 1. Be a list of integers
+    # 2. Have length that is multiple of 4
+    # 3. End with the RETURN opcode (usually 0 in some engines, but let's check length)
+    assert isinstance(bytecode, list)
+    assert len(bytecode) > 0
+    assert len(bytecode) % 4 == 0
+
+    print(f"Compiled Bytecode: {bytecode}")
+
+
+def test_complex_condition_compilation(parser):
+    text = 'TRIGGER: ON_PLAY\nCONDITION: COUNT_GROUP {GROUP="μ\'s", MIN=2}\nEFFECT: DRAW(1) -> PLAYER'
+    abilities = parser.parse(text)
+    ab = abilities[0]
+    bytecode = ab.compile()
+
+    assert len(bytecode) % 4 == 0
+    # First chunk should be a check for group count
+    # Opcode.CHECK_COUNT_GROUP is 1000 + enum value or similar
+    assert bytecode[0] > 0

compiler/tests/test_regex_direct.py

@@ -0,0 +1,11 @@
+import re
+
+text = "自分の成功ライブカード置き場にあるカードを1枚手札に加える"
+regex = r"成功ライブカード.*?手札に加"
+
+match = re.search(regex, text)
+print(f"Text: {text}")
+print(f"Regex: {regex}")
+print(f"Match: {match}")
+if match:
+    print(f"Matched: {match.group(0)}")

compiler/tests/test_robustness.py

@@ -0,0 +1,23 @@
+from compiler.parser import AbilityParser
+
+
+def test_debug_parser():
+    parser = AbilityParser()
+
+    cases = [
+        ("Slash", "{{toujyou.png|登場}}/{{live_start.png|ライブ開始時}} カードを1枚引く。"),
+        ("Parens", "{{toujyou.png|登場}} カードを1枚引く。（これは説明文です。）"),
+        ("Modal-", "以下から1回を選ぶ。\\n- カードを1枚引く。\\n- スコア+1。"),
+        ("Choose2", "以下から2つを選ぶ。\\n・カードを1枚引く。\\n・スコア+1。\\n・エネチャージ。"),
+    ]
+
+    # Just verify that parsing these strings produces valid non-empty ability lists
+    # without crashing.
+    for name, text in cases:
+        print(f"Testing case: {name}")
+        abs_list = parser.parse_ability_text(text)
+        assert len(abs_list) > 0, f"Failed to parse {name}"
+
+        # Additional sanity checks depending on expected logic
+        for a in abs_list:
+            assert a.trigger is not None, f"Trigger is None for {name}"

compiler/tests/verify_parser_fixes.py

@@ -0,0 +1,49 @@
+import sys
+import os
+
+# Add project root to sys.path
+sys.path.append(os.getcwd())
+
+from compiler.parser_v2 import AbilityParserV2
+from engine.models.ability import TriggerType, EffectType, TargetType, ConditionType
+
+def test_negation():
+    parser = AbilityParserV2()
+    text = "TRIGGER: ON_PLAY\nCONDITION: !MOVED_THIS_TURN\nEFFECT: DRAW(1)"
+    abilities = parser.parse(text)
+    ability = abilities[0]
+    condition = ability.conditions[0]
+    print(f"Condition: {condition.type.name}, Negated: {condition.is_negated}")
+    assert condition.is_negated == True
+
+def test_variable_targeting():
+    parser = AbilityParserV2()
+    # Sequence: Look Deck to Hand -> Draw for Target
+    text = "TRIGGER: ON_PLAY\nEFFECT: LOOK_DECK(3) -> CARD_HAND; DRAW(1) -> TARGET"
+    abilities = parser.parse(text)
+    effects = abilities[0].effects
+    print(f"Effect 0 Target: {effects[0].target.name}")
+    print(f"Effect 1 Target: {effects[1].target.name}")
+    assert effects[1].target == TargetType.CARD_HAND
+    
+def test_aliases():
+    parser = AbilityParserV2()
+    text = "TRIGGER: ON_YELL_SUCCESS\nEFFECT: CHARGE_SELF(1)"
+    abilities = parser.parse(text)
+    ability = abilities[0]
+    print(f"Trigger: {ability.trigger.name}")
+    print(f"Effect: {ability.effects[0].effect_type.name}, Target: {ability.effects[0].target.name}")
+    assert ability.trigger == TriggerType.ON_REVEAL
+    assert ability.effects[0].effect_type == EffectType.ENERGY_CHARGE
+    assert ability.effects[0].target == TargetType.MEMBER_SELF
+
+if __name__ == "__main__":
+    try:
+        test_negation()
+        test_variable_targeting()
+        test_aliases()
+        print("All tests passed!")
+    except Exception as e:
+        print(f"Test failed: {e}")
+        import traceback
+        traceback.print_exc()