fix(parser): scope count-form "would draw N or more" draw replacements (Alms Collector #5678)

crates/engine/src/game/effects/draw.rs

@@ -215,6 +215,17 @@ pub(crate) fn start_draw_sequence_with_origin(
     origin: DrawSequenceOrigin,
     events: &mut Vec<GameEvent>,
 ) -> replacement::ReplacementResult {
+    // CR 121.2a: A count-form draw replacement ("If [a player] would draw N or
+    // more cards, ...") modifies the draw INSTRUCTION "before considering any of
+    // the individual card draws". Consult those instruction-scoped shields here,
+    // against the whole `count`, before the instruction splits into individual
+    // draws below — the per-unit seam only ever sees `count == 1`, so it can
+    // never enforce a threshold of two or more.
+    let (count, applied) =
+        match replacement::replace_draw_instruction(state, player, count, applied, events) {
+            replacement::DrawInstructionOutcome::Proceed { count, applied } => (count, applied),
+            replacement::DrawInstructionOutcome::Replaced(result) => return result,
+        };
     let frame_id = state.push_draw_sequence_with_origin(player, count, applied, origin);
     resume_draw_sequence(state, frame_id, events)
 }

crates/engine/src/parser/oracle_replacement.rs

@@ -446,20 +446,33 @@ fn parse_replacement_line_inner(text: &str, card_name: &str) -> Option<Replaceme
     // "would draw a card" hooks one individual draw; a count-form "would draw one
     // or more cards" hooks the instruction, which CR 121.2a modifies "before
     // considering any of the individual card draws".
-    let draw_scope = nom_primitives::scan_at_word_boundaries(&lower, |i| {
+    // The count-form arm captures N via `parse_number` (build for the class: any
+    // "<N> or more cards" threshold, not a "two or more" special case). A count
+    // form scopes the whole instruction (InstructionCount); "N >= 2" additionally
+    // carries a typed threshold (Alms Collector) wired below as an OnlyIfQuantity
+    // over the pending draw count. "one or more" (N == 1) is vacuously true, so it
+    // takes no threshold — its InstructionCount comes from the antecedent alone.
+    let draw_antecedent = nom_primitives::scan_at_word_boundaries(&lower, |i| {
         alt((
             value(
-                DrawReplacementScope::IndividualDraw,
+                (DrawReplacementScope::IndividualDraw, None),
                 tag::<_, _, OracleError<'_>>("would draw a card"),
             ),
-            value(
-                DrawReplacementScope::InstructionCount,
-                tag("would draw one or more cards"),
-            ),
+            (
+                tag("would draw "),
+                nom_primitives::parse_number,
+                tag(" or more cards"),
+            )
+                .map(|(_, n, _)| {
+                    (
+                        DrawReplacementScope::InstructionCount,
+                        if n >= 2 { Some(n) } else { None },
+                    )
+                }),
         ))
         .parse(i)
     });
-    if let Some(draw_scope) = draw_scope {
+    if let Some((draw_scope, threshold_n)) = draw_antecedent {
         // CR 614.1a: An "As long as <state>, if you would draw a
         // card, ..." gate (Archmage Ascension) precedes the draw antecedent with
         // its own comma clause. Split it off so effect extraction anchors on the
@@ -581,6 +594,29 @@ fn parse_replacement_line_inner(text: &str, card_name: &str) -> Option<Replaceme
                 WhileAntecedent::Absent => {}
             }
         }
+        // CR 121.2a: a "draw N or more cards" antecedent (N >= 2) gates the
+        // replacement on the pending draw *instruction* being for at least N
+        // cards. Carry N as a typed `OnlyIfQuantity` over the event's draw count
+        // (`EventContextAmount`), evaluated at the instruction stage before the
+        // draw decomposes into individual card draws — composed (And) with any
+        // as-long-as / while / except-first gate already set. Alms Collector:
+        // "If an opponent would draw two or more cards, ...".
+        if let Some(n) = threshold_n {
+            let threshold = ReplacementCondition::OnlyIfQuantity {
+                lhs: QuantityExpr::Ref {
+                    qty: QuantityRef::EventContextAmount,
+                },
+                comparator: Comparator::GE,
+                rhs: QuantityExpr::Fixed { value: n as i32 },
+                active_player_req: None,
+            };
+            def.condition = Some(match def.condition.take() {
+                Some(existing) => ReplacementCondition::And {
+                    conditions: vec![existing, threshold],
+                },
+                None => threshold,
+            });
+        }
         return Some(def);
     }
 
@@ -18765,6 +18801,42 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn alms_collector_count_form_threshold_gates_on_instruction_draw_count() {
+        // #5678 / CR 121.2a: "If an opponent would draw two or more cards, instead
+        // you and that player each draw a card." The count-form antecedent must
+        // (1) scope the whole instruction (InstructionCount), (2) carry N=2 as a
+        // typed OnlyIfQuantity over the pending draw count (EventContextAmount) so
+        // a one-card draw does not match, and (3) apply only to an opponent's draw.
+        let def = parse_replacement_line(
+            "If an opponent would draw two or more cards, instead you and that player each draw a card.",
+            "Alms Collector",
+        )
+        .expect("Alms Collector's count-form antecedent must lower to a Draw replacement");
+        assert_eq!(def.event, ReplacementEvent::Draw);
+        assert_eq!(def.draw_scope, Some(DrawReplacementScope::InstructionCount));
+        assert_eq!(def.valid_player, Some(ReplacementPlayerScope::Opponent));
+        assert_eq!(
+            def.condition,
+            Some(ReplacementCondition::OnlyIfQuantity {
+                lhs: QuantityExpr::Ref {
+                    qty: QuantityRef::EventContextAmount,
+                },
+                comparator: Comparator::GE,
+                rhs: QuantityExpr::Fixed { value: 2 },
+                active_player_req: None,
+            }),
+            "N=2 must lower to OnlyIfQuantity(EventContextAmount >= 2)"
+        );
+        // The substitute is a fixed per-player draw (you + the drawing opponent),
+        // not a count-modifier -- InstructionCount comes from the antecedent
+        // threshold, not the execute shape (the discipline the maintainer required).
+        assert!(matches!(
+            def.execute.as_deref().map(|a| &*a.effect),
+            Some(Effect::Draw { .. })
+        ));
+    }
+
     #[test]
     fn draw_replacement_leading_instead_prefix_blood_scrivener() {
         // CR 614.1a: "instead you draw two cards" — leading "instead" form with

crates/engine/src/types/ability.rs

@@ -19947,6 +19947,30 @@ pub enum PlaneswalkReplacementScope {
     PlanarDieOnly,
 }
 
+/// CR 121.2a + CR 121.6b: which [`DrawReplacementScope`] the in-progress draw
+/// replacement consult is eligible to match. A draw instruction resolves in two
+/// seams — the whole-instruction consult that runs *before* the instruction
+/// splits into individual card draws, and the per-card consult that runs for
+/// each individual draw — and a shield is scoped to exactly one of them.
+///
+/// The default, [`Individual`](Self::Individual), is the per-card seam: an
+/// `IndividualDraw` shield hooks each card, and a count-form
+/// `InstructionCount` shield hooks a non-split whole-count draw (the turn-based
+/// draw step, connive, gift) at or above its printed threshold.
+/// [`Instruction`](Self::Instruction) is set only by
+/// `game::replacement::replace_draw_instruction` for the pre-split consult, so
+/// only `InstructionCount` shields see the whole instruction there — an
+/// `IndividualDraw` shield must wait for its individual card.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
+pub enum DrawConsultScope {
+    /// The per-card / non-split draw seam. See the type-level docs.
+    #[default]
+    Individual,
+    /// The pre-split whole-instruction seam (CR 121.2a). Only `InstructionCount`
+    /// count-form shields are eligible.
+    Instruction,
+}
+
 /// CR 614.1a: Which player(s) a replacement effect applies to, scoped relative
 /// to the replacement source player. For permanents/spells this is the source's
 /// controller; for cards outside the battlefield/stack, CR 109.4 + CR 108.4a

crates/engine/src/types/game_state.rs

@@ -10980,6 +10980,13 @@ impl<'de> Deserialize<'de> for PendingLiminalEntryResume {
     }
 }
 
+/// serde skip predicate for [`GameState::draw_consult_scope`] — the transient
+/// consult scope is only ever `Instruction` mid-consult, which never spans a
+/// serialization boundary, so the `Individual` default is elided.
+fn draw_consult_scope_is_individual(scope: &crate::types::ability::DrawConsultScope) -> bool {
+    matches!(scope, crate::types::ability::DrawConsultScope::Individual)
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GameState {
     pub turn_number: u32,
@@ -11165,6 +11172,13 @@ pub struct GameState {
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub post_replacement_token_substitution_count: Option<i32>,
 
+    /// CR 121.2a: which draw-replacement scope the in-progress replacement
+    /// consult is eligible to match. See [`DrawConsultScope`]. Transient — set to
+    /// `Instruction` only for the duration of the pre-split whole-instruction
+    /// consult in `game::replacement::replace_draw_instruction`, and restored to
+    /// the `Individual` default (skipped by serde) immediately afterward.
+    #[serde(default, skip_serializing_if = "draw_consult_scope_is_individual")]
+    pub draw_consult_scope: crate::types::ability::DrawConsultScope,
     /// CR 614.12a + CR 707.9 + CR 603.2: `ZoneChanged`-to-battlefield events
     /// for an object whose entry is paused mid-resolution awaiting an
     /// interactive choice (e.g. `WaitingFor::CopyTargetChoice`). Per CR
@@ -16071,6 +16085,7 @@ impl GameState {
             replacement_may_cost_paused: false,
             post_replacement_token_choice_applied: None,
             post_replacement_token_substitution_count: None,
+            draw_consult_scope: crate::types::ability::DrawConsultScope::Individual,
             deferred_entry_events: Vec::new(),
             layers_dirty: LayersDirty::full(),
             static_gate_truth: im::HashMap::new(),
@@ -17300,6 +17315,7 @@ fn _gamestate_partition_is_total(s: &GameState) {
         pending_replacement: _,
         replacement_may_cost_paused: _,
         post_replacement_token_choice_applied: _,
+        draw_consult_scope: _,
         deferred_entry_events: _,
         layers_dirty: _,
         static_gate_truth: _,

scripts/draw-replacement-corpus.tsv

@@ -25,6 +25,7 @@
 #
 abundance	Draw	Optional	none	Choose	-	IndividualDraw
 alhammarret's archive	Draw	Mandatory	none	Draw	nested-draw	IndividualDraw
+alms collector	Draw	Mandatory	none	Draw	nested-draw	InstructionCount
 archmage ascension	Draw	Optional	none	SearchLibrary	-	IndividualDraw
 asmodeus the archfiend	Draw	Mandatory	none	ExileTop	-	IndividualDraw
 bard, king of dale	Draw	Mandatory	none	Draw	nested-draw	IndividualDraw

scripts/draw_replacement_census.py

@@ -308,6 +308,15 @@ def classify_scope(card: str, repl: dict) -> str:
             f"(and to KNOWN_QUANTITY_MODIFICATIONS), then re-freeze."
         )
 
+    # CR 121.2a: a typed antecedent threshold -- "draw N or more cards" lowered to
+    # an OnlyIfQuantity gating on the event's own draw count (EventContextAmount) --
+    # modifies the whole instruction before any individual draw, so it is
+    # InstructionCount even when the substitute is a fixed draw (Alms Collector).
+    # The instruction-count signal lives in the condition subtree, not just the
+    # execute's count.
+    condition = repl.get("condition")
+    if condition is not None and reads_event_context_amount(condition):
+        return "InstructionCount"
     effect = ((repl.get("execute") or {}).get("effect")) or {}
     if effect.get("type") == "Draw" and reads_event_context_amount(effect.get("count")):
         return "InstructionCount"