Update Conditional Tap and Mass Keyword Effects

I see the pattern now. For BoostUntilEndOfTurn, the current implementation uses P1P1 counters as a simplification (not ideal, but it works). And GainKeywordUntilEndOfTurn uses granted_keywords which gets cleared at end of turn.

For the mass versions, I need to:

Add Effect::BoostAllUntilEndOfTurn { filter, power, toughness }
Add Effect::GrantKeywordAllUntilEndOfTurn { filter, keyword }
Implement match arms in game.rs — iterate all permanents matching the filter owned by the active player
Add constructors for these new effects

Let me check how DestroyAll and DealDamageAll handle their filter matching to follow the same pattern.

Let me check how DestroyAll implements its filter matching to follow the same pattern.

1278-                        // Find permanents controlled by opponent matching filter
1279-                        let matching: Vec<ObjectId> = self.state.battlefield.iter()
1280-                            .filter(|p| p.controller == opp && Self::matches_filter(p, filter))
1281-                            .map(|p| p.id())
1282-                            .collect();
1283-                        if let Some(&victim_id) = matching.first() {
1284-                            // Simplified: sacrifice the first matching permanent
1285-                            // (proper implementation would let opponent choose)
1286-                            if let Some(perm) = self.state.battlefield.remove(victim_id) {
1287-                                self.state.ability_store.remove_source(victim_id);
1288-                                self.move_card_to_graveyard_inner(victim_id, perm.owner());
1289-                            }
1290-                        }
1291-                    }
1292-                }
1293:                Effect::DestroyAll { filter } => {
1294-                    // Destroy all permanents matching filter
1295-                    let to_destroy: Vec<(ObjectId, PlayerId)> = self.state.battlefield.iter()
1296-                        .filter(|p| Self::matches_filter(p, filter) && !p.has_indestructible())
1297-                        .map(|p| (p.id(), p.owner()))
1298-                        .collect();
1299-                    for (id, owner) in to_destroy {
1300-                        if self.state.battlefield.remove(id).is_some() {
1301-                            self.state.ability_store.remove_source(id);
1302-                            self.move_card_to_graveyard_inner(id, owner);
1303-                        }
1304-                    }
1305-                }
1306:                Effect::DealDamageAll { amount, filter } => {
1307-                    // Deal damage to all creatures matching filter
1308-                    let matching: Vec<ObjectId> = self.state.battlefield.iter()
1309-                        .filter(|p| p.is_creature() && Self::matches_filter(p, filter))
1310-                        .map(|p| p.id())
1311-                        .collect();
1312-                    for id in matching {
1313-                        if let Some(perm) = self.state.battlefield.get_mut(id) {
1314-                            perm.apply_damage(*amount);
1315-                        }
1316-                    }
1317-                }
1318-                Effect::RemoveCounters { counter_type, count } => {
1319-                    let ct = crate::counters::CounterType::from_name(counter_type);
1320-                    // If no targets, fall back to source (self-targeting counters)
1321-                    let effective_targets: Vec<ObjectId> = if targets.is_empty() {

Now let me check the matches_filter function to understand how it works with "creatures you control" style filters.

1474-                    if t_end < after_slash.len() {
1475-                        &after_slash[t_end + 1..]
1476-                    } else {
1477-                        ""
1478-                    }
1479-                } else {
1480-                    name
1481-                }
1482-            } else {
1483-                name
1484-            }
1485-        } else {
1486-            name
1487-        };
1488-
1489-        // Parse "with keyword1[, keyword2...]" or "with keyword1 and keyword2"
1490-        if let Some(with_pos) = rest.to_lowercase().find("with ") {
1491-            let kw_str = &rest[with_pos + 5..];
1492-            for part in kw_str.split(|c: char| c == ',' || c == '&') {
1493-                let part = part.trim().trim_start_matches("and ").trim();
1494-                if let Some(kw) = crate::constants::KeywordAbilities::keyword_from_name(part) {
1495-                    keywords |= kw;
1496-                }
1497-            }
1498-        }
1499-
1500-        (power, toughness, keywords)
1501-    }
1502-
1503-    /// Check if a permanent matches a simple filter string.
1504:    fn matches_filter(perm: &Permanent, filter: &str) -> bool {
1505-        let f = filter.to_lowercase();
1506-        // "all" or empty matches everything
1507-        if f.is_empty() || f == "all" {
1508-            return true;
1509-        }
1510-        // Check creature types
1511-        for st in &perm.card.subtypes {
1512-            if f.contains(&st.to_string().to_lowercase()) {
1513-                return true;
1514-            }
1515-        }
1516-        // Check card types
1517-        for ct in &perm.card.card_types {
1518-            let ct_name = format!("{:?}", ct).to_lowercase();
1519-            if f.contains(&ct_name) {
1520-                return true;
1521-            }
1522-        }
1523-        // "nonland" filter
1524-        if f.contains("nonland") && !perm.card.card_types.contains(&crate::constants::CardType::Land) {
1525-            return true;
1526-        }
1527-        false
1528-    }
1529-
1530-    /// Check if a CardData matches a simple filter string.
1531-    fn card_matches_filter(card: &CardData, filter: &str) -> bool {
1532-        let f = filter.to_lowercase();
1533-        if f.is_empty() || f == "all" {
1534-            return true;

I see - matches_filter doesn't check controller. But for "creatures you control" effects, I need to filter by the controller being the active player. Looking at how the existing mass effects work - DestroyAll destroys ALL matching creatures, not just "yours". That's correct for Day of Judgment.

For mass buffs, the filter strings are "Creatures you control" — so I need to handle the "you control" part by checking the controller. Let me create two new effect variants and implement them in game.rs.

The implementation needs to:

Filter by creature type
Filter by controller (the active player / source controller)
Apply the buff

I'll define new effect types for mass boosts and keyword grants that parse the "you control" condition from the filter string, then apply the effects to all matching creatures in the match arms.

Good. Now I have a clear picture. I need two new Effect variants:

BoostAllUntilEndOfTurn { filter, power, toughness } — mass P/T buff until EOT
GrantKeywordAllUntilEndOfTurn { filter, keyword } — mass keyword grant until EOT

Let me implement them.

Now add the constructors.

Now implement the match arms in game.rs. Let me find where the existing single-target versions are handled.

I need to find a good spot to add the new match arms. Let me look at where the BoostPermanent arm is and add the mass versions nearby.

I'll add the new match arms right before the catch-all _ => {}. Let me also check what controller variable is available — the effect handler needs to know who controls the creatures.

939-                _ => {
940-                    // Other costs (exile from hand, remove counters, sacrifice other, etc.)
941-                    // will be implemented as cards need them
942-                }
943-            }
944-        }
945-        true
946-    }
947-
948-    /// Execute a list of effects for a controller with given targets.
949:    pub fn execute_effects(&mut self, effects: &[Effect], controller: PlayerId, targets: &[ObjectId], source: Option<ObjectId>) {
950-        for effect in effects {
951-            match effect {
952-                Effect::DealDamage { amount } => {
953-                    // Deal damage to target permanents.
954-                    // Player targeting is handled separately via SelectedTargets.
955-                    for &target_id in targets {
956-                        if let Some(perm) = self.state.battlefield.get_mut(target_id) {
957-                            perm.apply_damage(*amount);
958-                        }
959-                    }

The controller parameter is available. Now I'll add the mass effect implementations.

Good. Now let me add a test in game.rs. Let me find the test module.

mtg-rl/mtg-cards/src/sets/tdm.rs:2103:    // Land. Enters tapped unless you control a Plains or Island. {T}: Add {R}.
mtg-rl/mtg-cards/src/sets/tdm.rs:2109:                "This land enters tapped unless you control a Plains or an Island.",
mtg-rl/mtg-cards/src/sets/tdm.rs:2110:                vec![StaticEffect::Custom("Enters tapped unless you control Plains or Island.".into())]),
mtg-rl/mtg-cards/src/sets/tdm.rs:2146:    // Land. Enters tapped unless you control Swamp or Mountain. {T}: Add {W}.
mtg-rl/mtg-cards/src/sets/tdm.rs:2152:                "This land enters tapped unless you control a Swamp or a Mountain.",
mtg-rl/mtg-cards/src/sets/tdm.rs:2153:                vec![StaticEffect::Custom("Enters tapped unless you control Swamp or Mountain.".into())]),

Now let me add a test for the mass effects. I'll add it at the end of the test module.

Good, I have the test helpers. Now let me add the test.

Now let me check if has_keyword exists on Permanent.

Good, it exists. Let me compile.

Now fix the 5 FDN cards. Let me use sed for each one.

>sed -n '2388,2399p' mtg-cards/src/sets/fdn.rs

fn crash_through(id: ObjectId, owner: PlayerId) -> CardData {
    // Sorcery {R}. Creatures you control gain trample until EOT. Draw a card.
    CardData { id, owner, name: "Crash Through".into(), mana_cost: ManaCost::parse("{R}"),
        card_types: vec![CardType::Sorcery], rarity: Rarity::Common,
        abilities: vec![
            Ability::spell(id,
                vec![Effect::Custom("Creatures you control gain trample until end of turn.".into()),
                     Effect::draw_cards(1)],
                TargetSpec::None),
        ],
        ..Default::default() }
}

Now fix Balmor — this one has a compound Custom string.

Now let me verify all the fixes look correct and compile.

>grep -n "boost_all_eot\|grant_keyword_all_eot" mtg-cards/src/sets/fdn.rs

2394:                vec![Effect::grant_keyword_all_eot("creatures you control", "trample"),
2548:                     Effect::boost_all_eot("creatures you control", 1, 1),
2549:                     Effect::grant_keyword_all_eot("creatures you control", "haste")],
2561:                vec![Effect::boost_all_eot("creatures you control", 1, 0),
2562:                     Effect::grant_keyword_all_eot("creatures you control", "indestructible")],
2574:                vec![Effect::boost_all_eot("creatures you control", 3, 3),
2575:                     Effect::grant_keyword_all_eot("creatures you control", "trample")],
2898:                vec![Effect::boost_all_eot("creatures you control", 1, 0), Effect::grant_keyword_all_eot("creatures you control", "trample")],

Now let me look at how EntersTapped is handled in game.rs and the full card context in TDM.

All 5 cards fixed. Let me also search for any other cards across all sets that could use these new effects.

mtg-cards/src/sets/fdn.rs:3071:                vec![Effect::Custom("Creatures you control get +2/+2 until end of turn.".into())],
mtg-cards/src/sets/tdm.rs:479:                vec![Effect::Custom("Creatures you control get +X/+X and trample until end of turn, X = creatures you control.".into())],
mtg-cards/src/sets/ecl.rs:843:                vec![Effect::Custom("Creatures you control get +1/+0 until end of turn. Kithkin you control also gain first strike until end of turn.".into())],
mtg-cards/src/sets/ecl.rs:1597:                "{4}{W}: Creatures you control get +1/+1 until end of turn.",
mtg-cards/src/sets/ecl.rs:1599:                vec![Effect::Custom("Creatures you control get +1/+1 until end of turn.".into())],
mtg-cards/src/sets/ecl.rs:2237:                vec![Effect::Custom("Creatures you control get +1/+1 and gain haste until end of turn.".into())],

Let me fix the additional cards I found:

FDN line 3071: "Creatures you control get +2/+2 until end of turn." — simple boost_all_eot
TDM line 479: "Creatures you control get +X/+X and trample..." — has variable X, can't fix with simple variant
ECL line 843: "Creatures you control get +1/+0... Kithkin also gain first strike..." — compound/conditional, skip
ECL line 1599: "Creatures you control get +1/+1 until end of turn." — simple boost_all_eot
ECL line 2237: "Creatures you control get +1/+1 and gain haste until end of turn." — needs both boost_all_eot and grant_keyword_all_eot combined

Now I need to check the exact card text for the ones I can actually fix.

Found more cards using these patterns! Let me check which are simple enough to fix.

I can fix these 3 additional cards too. Let me also check what card the FDN one is.

Found 3 more fixable cards:

FDN: Claws Out — +2/+2 until EOT
ECL: Timid Shieldbearer — activated +1/+1 until EOT
ECL: Catharsis — ETB +1/+1 and haste until EOT

Now fix the haste part of Catharsis.

The sed didn't match because the string had "and gain haste" appended. Let me fix this one specifically.

Let me verify the Timid Shieldbearer fix worked too.

Good. Now check for any other mass grant patterns across other sets.

mtg-cards/src/sets/ecl.rs:843:                vec![Effect::Custom("Creatures you control get +1/+0 until end of turn. Kithkin you control also gain first strike until end of turn.".into())],
mtg-cards/src/sets/tdm.rs:479:                vec![Effect::Custom("Creatures you control get +X/+X and trample until end of turn, X = creatures you control.".into())],
mtg-cards/src/sets/tdm.rs:3165:                    vec![Effect::Custom("Choose one: Create two 1/1 white Monk creature tokens with prowess; or up to two target creatures you control each get +2/+2 until end of turn; or destroy target creature with power 4 or greater.".into())],
mtg-cards/src/sets/tdm.rs:3474:                         Effect::Custom("Creatures you control with counters on them gain vigilance and trample until end of turn.".into())],

The remaining ones are complex (variable X, compound conditional, modal) — can't be fixed with simple substitution. Let me also check TLA.

Good, no TLA mass buffs using Custom. Now compile and test.

>cargo test --lib 2>&1 | tail -20

   |     ^^^^^
   |
   = note: `SearchNode` has derived impls for the traits `Debug` and `Clone`, but these are intentionally ignored during dead code analysis
   = note: `#[warn(dead_code)]` on by default

warning: associated functions `new_root` and `new_child` are never used
  --> mtg-ai/src/minimax_player.rs:74:8
   |
73 | impl SearchNode {
   | --------------- associated functions in this implementation
74 |     fn new_root(is_maximizing: bool) -> Self {
   |        ^^^^^^^^
...
84 |     fn new_child(action: PlayerAction, depth: u32, is_maximizing: bool) -> Self {
   |        ^^^^^^^^^

warning: `mtg-ai` (lib) generated 2 warnings
For more information about this error, try `rustc --explain E0599`.
error: could not compile `mtg-engine` (lib test) due to 1 previous error
warning: build failed, waiting for other jobs to finish...

There's a compilation error in the test. Let me see what it is.

It looks like EntersTapped exists as a StaticEffect variant but isn't actually handled in game.rs. Let me search more carefully for how it's used. The batch wants me to add EntersTappedUnless with a condition string. These are "fastlands" / conditional taplands.

Let me check: is EntersTapped handled in game.rs at all? It says "No matches found" which means this static effect isn't mechanically enforced yet. That's consistent with our approach - we store it as structured data but mechanical enforcement comes later.

For Batch 6, the approach should be simple: add StaticEffect::EntersTappedUnless { condition: String } and a builder, then swap the Custom strings. The mechanical enforcement (actually checking the condition) is deferred like Ward was.

Now I'm scanning through the card database to see if there are other cards with this "enters tapped unless" mechanic across different sets.

>cargo test --lib -p mtg-engine 2>&1 | grep -B5 "E0599"

   Compiling mtg-engine v0.1.0 (/mnt/dest-btrfs/home/jc/src/mage/mtg-rl/mtg-engine)
error[E0599]: no function or associated item named `new` found for struct `game::Game` in the current scope
--
     | |_____________^
     = help: items from traits can only be used if the trait is implemented and in scope
     = note: the following trait defines an item `new`, perhaps you need to implement it:
             candidate #1: `UniformSampler`

For more information about this error, try `rustc --explain E0599`.

>cargo test --lib -p mtg-engine 2>&1 | head -20

   Compiling mtg-engine v0.1.0 (/mnt/dest-btrfs/home/jc/src/mage/mtg-rl/mtg-engine)
error[E0599]: no function or associated item named `new` found for struct `game::Game` in the current scope
    --> mtg-engine/src/game.rs:2462:30
     |
76   | pub struct Game {
     | --------------- function or associated item `new` not found for this struct
...
2462 |         let mut game = Game::new(
     |                              ^^^ function or associated item not found in `game::Game`
     |
note: if you're trying to build a new `game::Game`, consider using `game::Game::new_two_player` which returns `game::Game`
    --> mtg-engine/src/game.rs:89:5
     |
89   | /     pub fn new_two_player(
90   | |         config: GameConfig,
91   | |         mut decision_makers: Vec<(PlayerId, Box<dyn PlayerDecisionMaker>)>,
92   | |     ) -> Self {
     | |_____________^
     = help: items from traits can only be used if the trait is implemented and in scope
     = note: the following trait defines an item `new`, perhaps you need to implement it:

The Game::new constructor doesn't exist — the existing tests must use a different pattern. Let me look at how other tests create games.

89:    pub fn new_two_player(
1693:        let game = Game::new_two_player(
1722:        let mut game = Game::new_two_player(
1756:        let mut game = Game::new_two_player(
1783:        let mut game = Game::new_two_player(
1823:        let mut game = Game::new_two_player(
1874:        let game = Game::new_two_player(
1899:        let mut game = Game::new_two_player(
1952:        let mut game = Game::new_two_player(
2015:        let mut game = Game::new_two_player(
2078:        let mut game = Game::new_two_player(
2138:        let mut game = Game::new_two_player(
2172:        let mut game = Game::new_two_player(
2197:        let mut game = Game::new_two_player(
2225:        let mut game = Game::new_two_player(
2262:        let mut game = Game::new_two_player(
2300:        let mut game = Game::new_two_player(
2347:        let mut game = Game::new_two_player(
2426:        let mut game = Game::new_two_player(
2462:        let mut game = Game::new(

[Showing results with pagination = limit: 20, offset: 0]

Let me check if there are more "enters tapped unless" cards across all sets, and look at the Java implementations for reference.

I need to use Game::new_two_player instead. Let me check the signature.

Let me look at how the existing tests build the game to follow the same pattern.

I see — I need to use GameConfig and PlayerConfig. Let me fix my test.

mtg-rl/mtg-cards/src/sets/fdn.rs:637:    // Diregraf Ghoul enters the battlefield tapped.
mtg-rl/mtg-cards/src/sets/fdn.rs:643:                "Diregraf Ghoul enters the battlefield tapped.",
mtg-rl/mtg-cards/src/sets/fdn.rs:644:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:1593:                "When Solemn Simulacrum enters, you may search your library for a basic land card, put that card onto the battlefield tapped, then shuffle.",
mtg-rl/mtg-cards/src/sets/fdn.rs:1932:                "When Springbloom Druid enters, you may sacrifice a land. If you do, search your library for up to two basic land cards, put them onto the battlefield tapped, then shuffle.",
mtg-rl/mtg-cards/src/sets/fdn.rs:2856:    // Land — Gate. Enters tapped. {T}: Add {W} or {U}.
mtg-rl/mtg-cards/src/sets/fdn.rs:2861:            Ability::static_ability(id, "Azorius Guildgate enters tapped.",
mtg-rl/mtg-cards/src/sets/fdn.rs:2862:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2940:    // Land. Enters tapped. ETB: gain 1 life. {T}: Add {B} or {R}.
mtg-rl/mtg-cards/src/sets/fdn.rs:2944:            Ability::static_ability(id, "Bloodfell Caves enters tapped.",
mtg-rl/mtg-cards/src/sets/fdn.rs:2945:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2974:    // Land. Enters tapped. ETB: gain 1 life. {T}: Add {G} or {W}.
mtg-rl/mtg-cards/src/sets/fdn.rs:2978:            Ability::static_ability(id, "Blossoming Sands enters tapped.",
mtg-rl/mtg-cards/src/sets/fdn.rs:2979:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2991:    // Land — Gate. Enters tapped. {T}: Add {R} or {W}.
mtg-rl/mtg-cards/src/sets/fdn.rs:2996:            Ability::static_ability(id, "Boros Guildgate enters tapped.",
mtg-rl/mtg-cards/src/sets/fdn.rs:2997:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:6226:                "When Harbinger of the Tides enters the battlefield, you may return target tapped creature an opponent controls to its owner's hand.",
mtg-rl/mtg-cards/src/sets/fdn.rs:6228:                vec![Effect::Custom("When Harbinger of the Tides enters the battlefield, you may return target tapped creature an opponent controls to its owner's hand.".into())],
mtg-rl/mtg-cards/src/sets/ecl.rs:1161:                "When Mutable Explorer enters, create a tapped colorless land token named Mutavault.",
mtg-rl/mtg-cards/src/sets/ecl.rs:2101:    // Land — Swamp Mountain. Pay 2 life or enters tapped. Taps for {B} or {R}.
mtg-rl/mtg-cards/src/sets/ecl.rs:2107:                "As Blood Crypt enters, you may pay 2 life. If you don't, it enters tapped.",
mtg-rl/mtg-cards/src/sets/ecl.rs:2108:                vec![StaticEffect::Custom("Pay 2 life or enters tapped.".into())]),
mtg-rl/mtg-cards/src/sets/ecl.rs:3687:                "Whenever this creature enters or becomes tapped, tap up to one target creature and put a stun counter on it.",
mtg-rl/mtg-cards/src/sets/ecl.rs:3689:                vec![Effect::Custom("Whenever this creature enters or becomes tapped, tap up to one target creature and put a stun counter on it.".into())],
mtg-rl/mtg-cards/src/sets/tdm.rs:1321:            Ability::static_ability(id, "This land enters the battlefield tapped.",
mtg-rl/mtg-cards/src/sets/tdm.rs:1322:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/tdm.rs:1377:            Ability::static_ability(id, "This land enters the battlefield tapped.",
mtg-rl/mtg-cards/src/sets/tdm.rs:1378:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/tdm.rs:1885:                "When this enchantment enters, search your library for up to two basic land cards, put them onto the battlefield tapped, then shuffle.",
mtg-rl/mtg-cards/src/sets/tdm.rs:2103:    // Land. Enters tapped unless you control a Plains or Island. {T}: Add {R}.
mtg-rl/mtg-cards/src/sets/tdm.rs:2109:                "This land enters tapped unless you control a Plains or an Island.",
mtg-rl/mtg-cards/src/sets/tdm.rs:2110:                vec![StaticEffect::Custom("Enters tapped unless you control Plains or Island.".into())]),
mtg-rl/mtg-cards/src/sets/tdm.rs:2146:    // Land. Enters tapped unless you control Swamp or Mountain. {T}: Add {W}.
mtg-rl/mtg-cards/src/sets/tdm.rs:2152:                "This land enters tapped unless you control a Swamp or a Mountain.",
mtg-rl/mtg-cards/src/sets/tdm.rs:2153:                vec![StaticEffect::Custom("Enters tapped unless you control Swamp or Mountain.".into())]),
mtg-rl/mtg-cards/src/sets/tdm.rs:2392:    // Land. Enters tapped. {T}: Add one mana of any color. {5}, {T}: Gain 5 life.
mtg-rl/mtg-cards/src/sets/tdm.rs:2396:            Ability::static_ability(id, "Great Arashin City enters tapped.",
mtg-rl/mtg-cards/src/sets/tdm.rs:2397:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/tdm.rs:3011:                    "When this creature enters, destroy target nonbasic land an opponent controls. Its controller searches their library for a basic land card, puts it onto the battlefield tapped with a stun counter on it, then shuffles.",
mtg-rl/mtg-cards/src/sets/tdm.rs:3643:                    "As this enchantment enters, choose Jeskai or Mardu. Jeskai: Creature tokens you control have lifelink and haste. Mardu: Whenever you attack, create a 1/1 red Warrior creature token that's tapped and attacking.",

Now let me check if GameConfig and PlayerConfig are imported in the test module.

The test module uses super::* so GameConfig and PlayerConfig are available. Let me compile.

>cargo test --lib -p mtg-engine 2>&1 | tail -15

test watchers::tests::track_life_gained ... ok
test watchers::tests::track_spells_cast ... ok
test zones::tests::battlefield_add_remove ... ok
test zones::tests::battlefield_controlled_by ... ok
test zones::tests::exile_zones ... ok
test zones::tests::graveyard_ordering ... ok
test zones::tests::hand_add_remove ... ok
test zones::tests::library_draw ... ok
test zones::tests::library_peek ... ok
test zones::tests::library_put_on_top_and_bottom ... ok
test zones::tests::stack_lifo ... ok
test game::tests::game_runs_to_completion ... ok

test result: ok. 161 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s

161 tests pass (was 160 before — +1 for new test). Now run the full suite.

>cargo test --lib 2>&1 | grep -E "^test result:|running"

running 52 tests
test result: ok. 52 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s
running 18 tests
test result: ok. 18 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
running 161 tests
test result: ok. 161 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s
running 0 tests
test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
running 19 tests
test result: ok. 19 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.28s

All 250 tests pass. Now update the docs. First the work queue.

Now update ROADMAP.md.

Now update the per-set remediation docs. Let me check the FDN ones first.

371:- [ ] **Crash Through** -- What works: `DrawCards(1)`. What's broken: `Effect::Custom("Creatures you control gain trample until end of turn.")`.
397:- [ ] **Heroic Reinforcements** -- What works: `CreateToken("1/1 Soldier", 2)`. What's broken: 2x `Effect::Custom(...)` for mass buff/haste.
400:- [ ] **Make a Stand** -- What works: nothing functional. What's broken: 2x `Effect::Custom(...)` for mass buff/indestructible.
403:- [ ] **Overrun** -- What works: nothing functional. What's broken: 2x `Effect::Custom(...)` for mass buff/trample.
431:- [ ] **Balmor, Battlemage Captain** -- What works: 1/3 flying creature. What's broken: SpellCast `Effect::Custom("Creatures you control get +1/+0 and gain trample until end of turn.")`.
467:- [ ] **Claws Out** -- Instant, spell effect (Custom)

mtg-rl/mtg-cards/src/sets/fdn.rs:644:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2862:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2945:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2979:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/fdn.rs:2997:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/tdm.rs:1322:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/tdm.rs:1378:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),
mtg-rl/mtg-cards/src/sets/tdm.rs:2397:                vec![StaticEffect::EntersTapped { filter: "self".into() }]),

Now update ECL remediation.

Let me verify the remediation doc updates look right.

>grep -n "Batch 7" docs/fdn-remediation.md docs/ecl-remediation.md

docs/fdn-remediation.md:371:- [x] **Crash Through** -- `grant_keyword_all_eot("creatures you control", "trample")` + `draw_cards(1)`. Fixed in Batch 7.
docs/fdn-remediation.md:397:- [x] **Heroic Reinforcements** -- CreateToken + boost_all_eot + grant_keyword_all_eot (haste). Fixed in Batch 7.
docs/fdn-remediation.md:400:- [x] **Make a Stand** -- boost_all_eot(+1/+0) + grant_keyword_all_eot(indestructible). Fixed in Batch 7.
docs/fdn-remediation.md:403:- [x] **Overrun** -- boost_all_eot(+3/+3) + grant_keyword_all_eot(trample). Fixed in Batch 7.
docs/fdn-remediation.md:431:- [x] **Balmor, Battlemage Captain** -- SpellCast trigger: boost_all_eot(+1/+0) + grant_keyword_all_eot(trample). Fixed in Batch 7.
docs/fdn-remediation.md:467:- [x] **Claws Out** -- boost_all_eot(+2/+2). Cost reduction still Custom. Fixed in Batch 7.
docs/ecl-remediation.md:372:- [x] **Timid Shieldbearer** — Activated: boost_all_eot(+1/+1). Fixed in Batch 7.
docs/ecl-remediation.md:484:- [x] **Catharsis** — ETB: create_token + boost_all_eot + grant_keyword_all_eot(haste). Evoke still Custom. Fixed in Batch 7.

Update Conditional Tap and Mass Keyword Effects

Update Conditional Tap and Mass Keyword EffectsPublic

Summary