diff --git a/client/src/components/board/ActionButton.tsx b/client/src/components/board/ActionButton.tsx
index 24fccd507e..c174204463 100644
--- a/client/src/components/board/ActionButton.tsx
+++ b/client/src/components/board/ActionButton.tsx
@@ -278,7 +278,8 @@ export function ActionButton() {
   // grows. Surfaced with the same pulsing cancel affordance as UntilTurnBoundary
   // so the player can revoke it between opponents' windows.
   const isResolvingStack = autoPass?.type === "UntilStackEmpty";
-  const canActDuringAutoPass = mode === "combat-blockers";
+  const canActDuringAutoPass =
+    mode === "combat-attackers" || mode === "combat-blockers";
 
   const actionPending = useMultiplayerStore((s) => s.actionPending);
   const isResolvingAll = useGameStore((s) => s.isResolvingAll);
@@ -293,7 +294,7 @@ export function ActionButton() {
   return (
     <>
       <div className={panelClassName} data-action-button-panel>
-        {mode === "combat-attackers" && !isEndingTurn && (
+        {mode === "combat-attackers" && (
           <>
             <button
               disabled={actionBlocked}
diff --git a/client/src/components/board/__tests__/ActionButton.test.tsx b/client/src/components/board/__tests__/ActionButton.test.tsx
index 6d13aca0db..fcfc1d5591 100644
--- a/client/src/components/board/__tests__/ActionButton.test.tsx
+++ b/client/src/components/board/__tests__/ActionButton.test.tsx
@@ -31,6 +31,19 @@ function blockerPrompt(): WaitingFor {
   };
 }
 
+function attackerPrompt(): WaitingFor {
+  const target = { type: "Player", data: 1 } as const;
+  return {
+    type: "DeclareAttackers",
+    data: {
+      player: 0,
+      valid_attacker_ids: [100],
+      valid_attack_targets: [target],
+      valid_attack_targets_by_attacker: { "100": [target] },
+    },
+  };
+}
+
 function priorityPrompt(player = 0): WaitingFor {
   return buildPriorityWaitingFor({ data: { player } });
 }
@@ -100,6 +113,24 @@ describe("ActionButton", () => {
     expect(screen.queryByText("Auto-Passing to End Step...")).not.toBeInTheDocument();
   });
 
+  it("keeps attacker controls available while pass-until-end-of-turn is armed", () => {
+    const waitingFor = attackerPrompt();
+    useGameStore.setState({
+      gameState: {
+        ...createGameState(waitingFor),
+        phase: "DeclareAttackers",
+        active_player: 0,
+      },
+      waitingFor,
+    });
+
+    render(<ActionButton />);
+
+    expect(screen.getByRole("button", { name: "Attack with All" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Attack with None" })).toBeInTheDocument();
+    expect(screen.queryByText("Auto-Passing to End Step...")).not.toBeInTheDocument();
+  });
+
   it("shows resolve when turn decision controller differs from priority player (issue #1218)", () => {
     useGameStore.setState({
       gameMode: "online",
diff --git a/crates/engine/src/game/engine_phase_trigger_regression_tests.rs b/crates/engine/src/game/engine_phase_trigger_regression_tests.rs
index 6f3835cb45..051617daf1 100644
--- a/crates/engine/src/game/engine_phase_trigger_regression_tests.rs
+++ b/crates/engine/src/game/engine_phase_trigger_regression_tests.rs
@@ -14,6 +14,7 @@ use crate::types::ability::{
 use crate::types::card::CardFace;
 use crate::types::card_type::CoreType;
 use crate::types::format::FormatConfig;
+use crate::types::game_state::{AutoPassMode, TurnBoundary};
 use crate::types::identifiers::{CardId, ObjectId};
 use crate::types::keywords::Keyword;
 use crate::types::mana::{ManaColor, ManaCost, ManaType, ManaUnit};
@@ -156,8 +157,8 @@ fn begin_combat_window_precedes_forced_empty_attacker_declaration() {
     ));
 
     // Submit the only legal declaration through the production action path.
-    // CR 508.8 then skips only DeclareBlockers and CombatDamage, leaving combat
-    // and arriving at PostCombatMain normally.
+    // CR 508.8 skips DeclareBlockers and CombatDamage, but CR 511.1 still
+    // begins EndCombat and grants priority.
     let empty_declaration = apply_as_current(
         &mut state,
         GameAction::DeclareAttackers {
@@ -166,17 +167,154 @@ fn begin_combat_window_precedes_forced_empty_attacker_declaration() {
         },
     )
     .expect("the empty declaration offered by the engine must be submitable");
+    assert_eq!(state.phase, Phase::EndCombat);
+    assert!(matches!(
+        empty_declaration.waiting_for,
+        WaitingFor::Priority {
+            player: PlayerId(0)
+        }
+    ));
+
+    // The normal priority loop ends EndCombat and enters the postcombat main
+    // phase after both players pass.
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    let postcombat = apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     assert_eq!(state.phase, Phase::PostCombatMain);
     assert!(
         state.combat.is_none(),
-        "combat ends after the empty declaration"
+        "combat ends after the EndCombat step"
     );
     assert!(matches!(
-        empty_declaration.waiting_for,
+        postcombat.waiting_for,
+        WaitingFor::Priority {
+            player: PlayerId(0)
+        }
+    ));
+}
+
+/// CR 510.4 + CR 511.1 + CR 117.3a: completed combat-damage and end-of-combat
+/// steps each expose their ordinary active-player priority window. The
+/// turn-boundary auto-pass session is re-armed before each opponent pass so the
+/// phase-stop interruption is exercised through the production `apply` path.
+#[test]
+fn combat_phase_stops_pause_damage_and_end_combat_windows() {
+    let mut state = new_game(42);
+    state.turn_number = 2;
+    state.phase = Phase::DeclareBlockers;
+    state.active_player = PlayerId(0);
+    state.priority_player = PlayerId(0);
+
+    let attacker = create_object(
+        &mut state,
+        CardId(201),
+        PlayerId(0),
+        "Combat Creature".to_string(),
+        Zone::Battlefield,
+    );
+    {
+        let obj = state.objects.get_mut(&attacker).unwrap();
+        obj.card_types.core_types.push(CoreType::Creature);
+        obj.power = Some(2);
+        obj.toughness = Some(2);
+    }
+    state.combat = Some(crate::game::combat::CombatState {
+        attackers: vec![crate::game::combat::AttackerInfo::attacking_player(
+            attacker,
+            PlayerId(1),
+        )],
+        ..Default::default()
+    });
+    state.current_combat_attacker_restriction = Some(TargetFilter::Any);
+    state.current_combat_attacker_restriction_source = Some(attacker);
+    state.waiting_for = WaitingFor::DeclareBlockers {
+        player: PlayerId(1),
+        valid_blocker_ids: Vec::new(),
+        valid_block_targets: Default::default(),
+        block_requirements: Default::default(),
+        blocker_constraints: Default::default(),
+    };
+    state.phase_stops.insert(
+        PlayerId(0),
+        vec![
+            PhaseStop {
+                phase: Phase::CombatDamage,
+                scope: PhaseStopScope::AllTurns,
+            },
+            PhaseStop {
+                phase: Phase::EndCombat,
+                scope: PhaseStopScope::AllTurns,
+            },
+        ],
+    );
+
+    // Finish the blocker declaration, then pass the declare-blockers priority
+    // window. The next pass enters CombatDamage through the normal reducer.
+    apply(
+        &mut state,
+        PlayerId(1),
+        GameAction::DeclareBlockers {
+            assignments: Vec::new(),
+        },
+    )
+    .unwrap();
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    state.auto_pass.insert(
+        PlayerId(0),
+        AutoPassMode::UntilTurnBoundary {
+            until: TurnBoundary::EndOfCurrentTurn,
+        },
+    );
+    let damage_stop = apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    assert_eq!(state.phase, Phase::CombatDamage);
+    assert!(matches!(
+        damage_stop.waiting_for,
+        WaitingFor::Priority {
+            player: PlayerId(0)
+        }
+    ));
+    assert!(
+        !state.auto_pass.contains_key(&PlayerId(0)),
+        "CombatDamage stop must interrupt the armed auto-pass session"
+    );
+
+    // Pass through the damage-step priority window, then repeat the same
+    // production flow for EndCombat.
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    state.auto_pass.insert(
+        PlayerId(0),
+        AutoPassMode::UntilTurnBoundary {
+            until: TurnBoundary::EndOfCurrentTurn,
+        },
+    );
+    let end_combat_stop = apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    assert_eq!(state.phase, Phase::EndCombat);
+    assert!(matches!(
+        end_combat_stop.waiting_for,
         WaitingFor::Priority {
             player: PlayerId(0)
         }
     ));
+    assert!(
+        state.combat.is_some(),
+        "combat remains during EndCombat priority"
+    );
+    assert!(
+        state.current_combat_attacker_restriction.is_some(),
+        "EndCombat restriction remains live during its priority window"
+    );
+    assert!(
+        !state.auto_pass.contains_key(&PlayerId(0)),
+        "EndCombat stop must interrupt the armed auto-pass session"
+    );
+
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    assert_eq!(state.phase, Phase::PostCombatMain);
+    assert!(state.combat.is_none(), "combat clears after EndCombat ends");
+    assert!(
+        state.current_combat_attacker_restriction.is_none(),
+        "EndCombat restriction clears after the step ends"
+    );
 }
 
 /// CR 500.8 + CR 507.2: An inserted combat phase gets the same
@@ -195,12 +333,25 @@ fn inserted_begin_combat_gets_priority_window() {
         });
 
     let mut events = Vec::new();
-    let waiting_for = crate::game::turns::auto_advance(&mut state, &mut events);
+    let end_combat_waiting = crate::game::turns::auto_advance(&mut state, &mut events);
+
+    assert_eq!(state.phase, Phase::EndCombat);
+    assert!(matches!(
+        end_combat_waiting,
+        WaitingFor::Priority {
+            player: PlayerId(0)
+        }
+    ));
+
+    // End Combat is a real priority-bearing step even when no creature
+    // attacked. Passing it lets the inserted phase become the next entry.
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    let waiting_for = apply_as_current(&mut state, GameAction::PassPriority).unwrap();
 
     assert_eq!(state.phase, Phase::BeginCombat);
     assert!(state.combat.is_some());
     assert!(matches!(
-        waiting_for,
+        waiting_for.waiting_for,
         WaitingFor::Priority {
             player: PlayerId(0)
         }
diff --git a/crates/engine/src/game/engine_tests.rs b/crates/engine/src/game/engine_tests.rs
index c665caea18..db8b8ac37f 100644
--- a/crates/engine/src/game/engine_tests.rs
+++ b/crates/engine/src/game/engine_tests.rs
@@ -3974,7 +3974,10 @@ fn integration_full_turn_cycle() {
     assert_eq!(state.phase, Phase::BeginCombat);
 
     // Beginning of combat has its own priority window. With no attackers, the
-    // subsequent forced empty declaration skips only blockers and damage.
+    // subsequent forced empty declaration skips blockers and damage, then
+    // reaches the normal EndCombat priority window.
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     assert_eq!(state.phase, Phase::PostCombatMain);
@@ -5926,8 +5929,10 @@ fn full_turn_integration_with_mulligan() {
     // PreCombatMain: P1 passes -> BeginCombat priority.
     apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     assert_eq!(state.phase, Phase::BeginCombat);
-    // BeginCombat: both pass. No attackers are declared, so only Declare
-    // Blockers and Combat Damage are skipped before PostCombatMain.
+    // BeginCombat: both pass. No attackers are declared, so Declare Blockers
+    // and Combat Damage are skipped before the EndCombat priority window.
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
+    apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     apply_as_current(&mut state, GameAction::PassPriority).unwrap();
     assert_eq!(state.phase, Phase::PostCombatMain);
diff --git a/crates/engine/src/game/turns.rs b/crates/engine/src/game/turns.rs
index 24007e68a1..e4dd2aed51 100644
--- a/crates/engine/src/game/turns.rs
+++ b/crates/engine/src/game/turns.rs
@@ -179,6 +179,12 @@ pub(in crate::game) fn advance_phase_once(
         removed = taken;
     }
 
+    // CR 511.3: End Combat teardown happens when the step ends, after its
+    // priority window, not when the step begins.
+    if leaving == Phase::EndCombat {
+        complete_end_combat_teardown(state);
+    }
+
     // If wrapping from Cleanup to Untap, start next turn. Turn-level skip
     // replacements (CR 614.10) are handled inside `start_next_turn` — the
     // per-phase pipeline below runs only for within-turn phase advances.
@@ -247,18 +253,13 @@ pub fn end_turn_to_cleanup(state: &mut GameState, events: &mut Vec<GameEvent>) {
     enter_phase(state, Phase::Cleanup, events);
 }
 
-/// CR 724.2d: End the current combat phase by removing everything from combat,
-/// expiring "until end of combat" effects, and skipping straight to the
-/// postcombat main phase. Mirrors the end-of-combat teardown the `EndCombat`
-/// step performs (see the `Phase::EndCombat` arm of `advance_phase`), but skips
-/// the intervening end-of-combat step so its "at end of combat" triggers do not
-/// fire (CR 724.2e). Drives `Effect::EndCombatPhase` (Mandate of Peace).
-pub fn end_combat_phase_to_postcombat(state: &mut GameState, events: &mut Vec<GameEvent>) {
-    // CR 724.2d / CR 511.3: Remove all creatures and planeswalkers from combat.
+/// CR 511.2 + CR 511.3: End Combat effects expire and combat objects leave
+/// combat only after the step's priority window has ended. Explicit effects
+/// that skip directly out of combat use the same teardown authority.
+fn complete_end_combat_teardown(state: &mut GameState) {
     state.combat = None;
-    // CR 724.2d: Effects that last "until end of combat" expire — continuous
-    // effects, replacement definitions, and pending damage replacements alike,
-    // matching the normal end-of-combat prune.
+    state.current_combat_attacker_restriction = None;
+    state.current_combat_attacker_restriction_source = None;
     super::layers::prune_end_of_combat_effects(state);
     super::layers::prune_controller_end_combat_step_effects(state, state.active_player);
     for obj in state.objects.iter_mut().map(|(_, v)| v) {
@@ -268,11 +269,19 @@ pub fn end_combat_phase_to_postcombat(state: &mut GameState, events: &mut Vec<Ga
     state
         .pending_damage_replacements
         .retain(|r| !matches!(r.expiry, Some(RestrictionExpiry::EndOfCombat)));
+}
 
-    // CR 511.3 / CR 724.2d: the combat phase is over — clear any active
-    // additional-combat attacker restriction (Last Night Together / Bumi).
-    state.current_combat_attacker_restriction = None;
-    state.current_combat_attacker_restriction_source = None;
+/// CR 724.2d: End the current combat phase by removing everything from combat,
+/// expiring "until end of combat" effects, and skipping straight to the
+/// postcombat main phase. Mirrors the end-of-combat teardown the `EndCombat`
+/// step performs (see the `Phase::EndCombat` arm of `advance_phase`), but skips
+/// the intervening end-of-combat step so its "at end of combat" triggers do not
+/// fire (CR 724.2e). Drives `Effect::EndCombatPhase` (Mandate of Peace).
+pub fn end_combat_phase_to_postcombat(state: &mut GameState, events: &mut Vec<GameEvent>) {
+    // CR 724.2d / CR 511.3: Remove all creatures and planeswalkers from combat.
+    // CR 724.2d: Effects that last "until end of combat" expire through the
+    // same authority as the normal End Combat transition.
+    complete_end_combat_teardown(state);
 
     // CR 724.2d: Skip straight to the postcombat main phase, skipping any
     // intervening steps (including the end-of-combat step — CR 724.2e). Any
@@ -295,22 +304,13 @@ pub(super) fn mark_empty_attackers_end_combat(state: &mut GameState, events: &mu
 }
 
 /// The declaration-continuation form of [`mark_empty_attackers_end_combat`].
-/// It preserves the established ordering that has already processed
-/// declaration triggers and advances past the synthetic marker without
-/// running EndCombat step triggers.
+/// CR 508.8 skips only Declare Blockers and Combat Damage; the normal End
+/// Combat step still begins and must run its triggers and priority window.
 pub(super) fn advance_after_empty_attackers(
     state: &mut GameState,
     events: &mut Vec<GameEvent>,
 ) -> WaitingFor {
     mark_empty_attackers_end_combat(state, events);
-    state.combat = None;
-    // CR 511.3: The synthetic empty-attacker path still ends this combat, so
-    // its extra-combat attacker restriction cannot survive to postcombat main.
-    state.current_combat_attacker_restriction = None;
-    state.current_combat_attacker_restriction_source = None;
-    super::layers::prune_end_of_combat_effects(state);
-    super::layers::prune_controller_end_combat_step_effects(state, state.active_player);
-    let _ = advance_phase_once(state, events);
     auto_advance(state, events)
 }
 
@@ -3006,40 +3006,31 @@ fn auto_advance_once(state: &mut GameState, events: &mut Vec<GameEvent>) -> Auto
                     player: state.active_player,
                 });
             }
-            let _ = advance_phase_once(state, events);
-            // Continue to EndCombat
+            // CR 117.3a: After the combat-damage turn-based action and its
+            // triggered abilities are handled, the active player receives
+            // priority before the step ends. This also gives phase stops a
+            // Priority window in which to interrupt auto-pass.
+            return AutoAdvanceStep::waiting(WaitingFor::Priority {
+                player: state.active_player,
+            });
         }
         Phase::EndCombat => {
             // CR 511.1: "At end of combat" triggers fire here.
             let event_snapshot = events.clone();
             let (triggers_fired, ordering_prompt) =
                 process_phase_triggers(state, &event_snapshot, events);
-            // CR 511.3: At end of combat, all creatures are removed from combat.
-            state.combat = None;
-            // CR 511.3: the combat phase is over — its attacker restriction
-            // (Last Night Together / Bumi) ends with it.
-            state.current_combat_attacker_restriction = None;
-            state.current_combat_attacker_restriction_source = None;
-            super::layers::prune_end_of_combat_effects(state);
-            super::layers::prune_controller_end_combat_step_effects(state, state.active_player);
-            for obj in state.objects.iter_mut().map(|(_, v)| v) {
-                obj.replacement_definitions
-                    .retain(|r| !matches!(r.expiry, Some(RestrictionExpiry::EndOfCombat)));
-            }
-            state
-                .pending_damage_replacements
-                .retain(|r| !matches!(r.expiry, Some(RestrictionExpiry::EndOfCombat)));
             if triggers_fired {
                 // CR 603.3b: surface a same-controller ordering prompt before priority.
                 if let Some(prompt) = ordering_prompt {
                     return AutoAdvanceStep::waiting(prompt);
                 }
-                return AutoAdvanceStep::waiting(WaitingFor::Priority {
-                    player: state.active_player,
-                });
             }
-            let _ = advance_phase_once(state, events);
-            // Continue to PostCombatMain
+            // CR 511.1: The active player receives priority as the End Combat step
+            // begins, even when no ability triggered. Keeping the phase active until
+            // all players pass lets phase stops interrupt auto-pass here.
+            return AutoAdvanceStep::waiting(WaitingFor::Priority {
+                player: state.active_player,
+            });
         }
         Phase::End => {
             // CR 513.1 + CR 611.2a/b: Expire `PlayFromExile { duration:
@@ -3169,7 +3160,14 @@ mod tests {
         state.current_combat_attacker_restriction_source = Some(ObjectId(99));
         let mut events = Vec::new();
 
-        let _ = advance_after_empty_attackers(&mut state, &mut events);
+        let waiting = advance_after_empty_attackers(&mut state, &mut events);
+
+        assert_eq!(state.phase, Phase::EndCombat);
+        assert!(matches!(waiting, WaitingFor::Priority { .. }));
+        assert!(state.current_combat_attacker_restriction.is_some());
+
+        apply(&mut state, PlayerId(0), GameAction::PassPriority).unwrap();
+        apply(&mut state, PlayerId(1), GameAction::PassPriority).unwrap();
 
         assert!(state.current_combat_attacker_restriction.is_none());
         assert!(state.current_combat_attacker_restriction_source.is_none());
@@ -7636,6 +7634,10 @@ mod tests {
         )
         .unwrap();
 
+        // CR 511.1: the empty-attacker path still enters EndCombat, whose
+        // priority window must be passed before PostCombatMain.
+        apply(&mut state, PlayerId(0), GameAction::PassPriority).unwrap();
+        apply(&mut state, PlayerId(1), GameAction::PassPriority).unwrap();
         assert_eq!(state.phase, Phase::PostCombatMain);
     }
 
diff --git a/crates/engine/tests/integration/issue_3279_song_of_dryads.rs b/crates/engine/tests/integration/issue_3279_song_of_dryads.rs
index 6c2cf27f64..8995f32e64 100644
--- a/crates/engine/tests/integration/issue_3279_song_of_dryads.rs
+++ b/crates/engine/tests/integration/issue_3279_song_of_dryads.rs
@@ -108,6 +108,9 @@ fn issue_3279_song_of_dryads_strips_enchanted_permanent_abilities() {
 
     runner.pass_both_players();
     runner.pass_both_players();
+    // CR 511.1: the no-attacker combat still enters EndCombat and exposes its
+    // priority window before PostCombatMain.
+    runner.pass_both_players();
     assert_eq!(runner.state().phase, Phase::PostCombatMain);
     assert!(
         !matches!(
diff --git a/crates/engine/tests/integration/last_night_together_restricted_combat.rs b/crates/engine/tests/integration/last_night_together_restricted_combat.rs
index 8ab9ccb11a..0ef208bcaf 100644
--- a/crates/engine/tests/integration/last_night_together_restricted_combat.rs
+++ b/crates/engine/tests/integration/last_night_together_restricted_combat.rs
@@ -132,6 +132,10 @@ fn last_night_together_restricts_additional_combat_to_chosen_creatures() {
         .expect("declaring the chosen attackers must be accepted");
     let _ = runner.combat_damage();
 
+    // `combat_damage()` intentionally stops when EndCombat opens its priority
+    // window. Pass that window before checking the transition out of combat.
+    runner.pass_both_players();
+
     // CR 511.3: once that combat phase is over, its restriction ends.
     assert!(
         runner.state().current_combat_attacker_restriction.is_none(),
diff --git a/crates/engine/tests/integration/loop_shortcut.rs b/crates/engine/tests/integration/loop_shortcut.rs
index eec0aaeb54..5ce7c08f5b 100644
--- a/crates/engine/tests/integration/loop_shortcut.rs
+++ b/crates/engine/tests/integration/loop_shortcut.rs
@@ -9609,7 +9609,7 @@ fn bloodloop_state(players: u8) -> GameState {
 /// commit CHANGED; pinning it is what stops a later change from moving it silently.
 #[test]
 fn bloodloop_mandatory_draw_cascade_offers_at_2p_3p_and_4p() {
-    for (players, expected_beat, expected_turn) in [(2u8, 33usize, 4u32), (3, 67, 5), (4, 113, 6)] {
+    for (players, expected_beat, expected_turn) in [(2u8, 37usize, 4u32), (3, 76, 5), (4, 129, 6)] {
         let mut state = bloodloop_state(players);
         let beat = drive_to_bounded_offer(&mut state, 400).unwrap_or_else(|| {
             panic!(