diff --git a/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.html b/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.html
index 580c480e..2eb0aed1 100644
--- a/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.html
+++ b/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.html
@@ -41,6 +41,7 @@
       class="upgrade-btn"
       *ngIf="towerInfo!.level < MAX_TOWER_LEVEL"
       [class.unaffordable]="gold < upgradeCost"
+      [disabled]="gold < upgradeCost"
       (click)="upgrade.emit()"
       aria-label="Upgrade tower">
       Upgrade ({{ upgradeCost }}g)<span class="upgrade-tile-percent" *ngIf="upgradePercent > 0"> +{{ upgradePercent }}%</span>
diff --git a/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.spec.ts b/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.spec.ts
index 4f188ca7..760fc5b7 100644
--- a/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.spec.ts
+++ b/src/app/game/game-board/components/tower-info-panel/tower-info-panel.component.spec.ts
@@ -142,6 +142,24 @@ describe('TowerInfoPanelComponent', () => {
       expect(btn.classList.contains('unaffordable')).toBeTrue();
     });
 
+    it('should disable the upgrade button when gold is less than upgrade cost', () => {
+      component.towerInfo = makeTower({ level: 1 });
+      component.upgradeCost = 200;
+      component.gold = 50;
+      fixture.detectChanges();
+      const btn: HTMLButtonElement = fixture.nativeElement.querySelector('.upgrade-btn');
+      expect(btn.disabled).toBeTrue();
+    });
+
+    it('should not disable the upgrade button when gold meets the upgrade cost', () => {
+      component.towerInfo = makeTower({ level: 1 });
+      component.upgradeCost = 75;
+      component.gold = 75;
+      fixture.detectChanges();
+      const btn: HTMLButtonElement = fixture.nativeElement.querySelector('.upgrade-btn');
+      expect(btn.disabled).toBeFalse();
+    });
+
     it('should emit upgrade event when upgrade button clicked', () => {
       component.towerInfo = makeTower({ level: 1 });
       fixture.detectChanges();
diff --git a/src/app/game/game-board/game-board.component.html b/src/app/game/game-board/game-board.component.html
index 5dc513a9..0ee2ca64 100644
--- a/src/app/game/game-board/game-board.component.html
+++ b/src/app/game/game-board/game-board.component.html
@@ -29,7 +29,8 @@
               type="button"
               class="hud-relic-peek__item"
               [attr.title]="relic.name + ' — ' + relic.description"
-              [attr.aria-label]="relic.name + ': ' + relic.description">
+              [attr.aria-label]="relic.name + ': ' + relic.description"
+              (click)="togglePause()">
         {{ relic.name.charAt(0) }}
       </button>
     </div>
@@ -43,7 +44,8 @@
               type="button"
               class="hud-ascension-peek__item"
               [attr.title]="mod.label + ' — ' + mod.description"
-              [attr.aria-label]="mod.label + ': ' + mod.description">
+              [attr.aria-label]="mod.label + ': ' + mod.description"
+              (click)="togglePause()">
         {{ mod.label.charAt(0) }}
       </button>
     </div>
@@ -166,16 +168,26 @@
       </ng-template>
     </div>
 
+    <!-- Tile-target mode indicator — shown while a terraform or elevation card awaits a tile click -->
+    <div class="placement-indicator placement-indicator--tile-target"
+         *ngIf="pendingTileTargetCardId !== null"
+         role="status"
+         aria-live="polite">
+      <app-icon name="crosshair" [size]="16" aria-hidden="true"></app-icon>
+      <span class="placement-indicator__text">Click a tile to target</span>
+      <span class="placement-indicator__hint">Right-click to cancel</span>
+    </div>
+
     <!-- Phase 4: End Turn button — only during combat (turn-based). -->
     <button
       class="end-turn-btn"
       *ngIf="gameState.phase === GamePhase.COMBAT"
-      [class.end-turn-btn--stuck]="handStuck && !pendingTowerCardId"
+      [class.end-turn-btn--stuck]="handStuck && !hasPendingCard"
       [class.end-turn-btn--leak-warning]="projectedLeaksNextTurn > 0"
       (click)="endTurn()"
-      [disabled]="!!pendingTowerCardId"
-      [attr.aria-label]="pendingTowerCardId
-        ? 'Place or cancel pending tower card first'
+      [disabled]="hasPendingCard"
+      [attr.aria-label]="hasPendingCard
+        ? 'Place or cancel pending card first'
         : (projectedLeaksNextTurn > 0
             ? 'End turn and resolve combat. Warning: ' + projectedLeakerSummary + ' projected to leak next turn.'
             : 'End turn and resolve combat')"
@@ -185,6 +197,9 @@
       <span class="end-turn-leak-warning"
             *ngIf="projectedLeaksNextTurn > 0"
             aria-hidden="true">⚠ {{ projectedLeaksNextTurn }} leak<ng-container *ngIf="projectedLeaksNextTurn !== 1">s</ng-container></span>
+      <span class="end-turn-stuck-hint"
+            *ngIf="handStuck && !hasPendingCard"
+            aria-hidden="true">No playable cards — end your turn</span>
     </button>
 
     <!-- Boss-intro banner — fires once when a wave containing a boss-tier enemy begins.
@@ -214,6 +229,23 @@
       [records]="recentTurnRecords">
     </app-last-turn-summary>
 
+    <!-- Active card-modifier buffs — persists through combat until each buff expires. -->
+    <aside
+      class="active-buffs"
+      *ngIf="activeBuffs.length > 0"
+      aria-label="Active buffs"
+      aria-live="polite">
+      <h4 class="active-buffs__title">Active Buffs</h4>
+      <ul class="active-buffs__list">
+        <li
+          *ngFor="let chip of activeBuffs; trackBy: trackBuffByIndex; let i = index"
+          class="active-buffs__chip">
+          <span class="active-buffs__label">{{ chip.label }}</span>
+          <span class="active-buffs__remaining">{{ chip.remaining }}</span>
+        </li>
+      </ul>
+    </aside>
+
     <!-- Phase 4: Spawn preview — shows what's coming in the next few turns. -->
     <aside
       class="spawn-preview"
@@ -356,6 +388,7 @@ <h5 class="spawn-preview__subtitle">Scouted</h5>
         [class.toast--challenge]="notification.type === 'challenge'"
         [class.toast--streak]="notification.type === 'streak'"
         [class.toast--info]="notification.type === 'info'"
+        [style.animation-duration.ms]="notification.duration"
         (click)="dismissNotification(notification.id)"
         role="alert"
       >
@@ -372,7 +405,7 @@ <h5 class="spawn-preview__subtitle">Scouted</h5>
     [deckState]="deckState"
     [energy]="energyState"
     [currentGold]="gameState.gold"
-    [pendingCardId]="pendingTowerCardId"
+    [pendingCardId]="pendingTowerCardId ?? pendingTileTargetCardId"
     (pileInspected)="inspectedPile = $event"
     (cardPlayed)="onCardPlayed($event)"
     (cardInspected)="inspectedCard = $event"
diff --git a/src/app/game/game-board/game-board.component.scss b/src/app/game/game-board/game-board.component.scss
index 1c352d21..73f30679 100644
--- a/src/app/game/game-board/game-board.component.scss
+++ b/src/app/game/game-board/game-board.component.scss
@@ -57,6 +57,9 @@
   --shell-recap-top: var(--shell-spawn-top);
   --shell-recap-right: var(--spacing-sm);
   --shell-tower-info-bottom: var(--spacing-sm);
+  // Active-buffs panel sits beneath INCOMING on the left. 14rem clears
+  // a fully-populated spawn-preview (title + 4 turn rows + scouted section).
+  --shell-buffs-top: calc(var(--shell-spawn-top) + 14rem);
 
   // When the wave-preview panel is mounted (INTERMISSION / SETUP phases), it
   // owns the top-right corner. The RECAP sits right under it — max-height of
@@ -318,6 +321,65 @@
     .enemy-dot[data-type='flying']   { background: var(--enemy-color-flying);  box-shadow: 0 0 4px var(--enemy-glow-flying); }
   }
 
+  // --- Active buffs panel ---
+  // Positioned below the INCOMING spawn-preview on the left side. Shares the
+  // glass-panel treatment and font scale of .spawn-preview so the two panels
+  // read as a visual family. Hidden on mobile (same breakpoint as .spawn-preview).
+  .active-buffs {
+    @include glass-panel(rgba(10, 15, 30, 0.82));
+    position: absolute;
+    top: var(--shell-buffs-top);
+    left: var(--shell-spawn-left);
+    padding: var(--spacing-sm) var(--spacing-md);
+    border: var(--border-width-thin) solid var(--panel-blue-border);
+    color: var(--text-color);
+    pointer-events: none;
+    z-index: var(--z-index-overlay);
+
+    @media (max-width: 768px) {
+      display: none;
+    }
+
+    .active-buffs__title {
+      margin: 0 0 var(--spacing-xs) 0;
+      font-size: var(--font-size-xs);
+      text-transform: uppercase;
+      letter-spacing: 0.12em;
+      opacity: 0.7;
+      font-weight: 600;
+    }
+
+    .active-buffs__list {
+      list-style: none;
+      margin: 0;
+      padding: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 0.2rem;
+    }
+
+    .active-buffs__chip {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: var(--spacing-sm);
+      font-size: var(--font-size-xs);
+    }
+
+    .active-buffs__label {
+      font-weight: 700;
+      color: var(--panel-blue-accent);
+    }
+
+    .active-buffs__remaining {
+      font-size: var(--font-size-3xs);
+      font-weight: 500;
+      color: var(--text-muted);
+      opacity: 0.7;
+      letter-spacing: 0.025em;
+    }
+  }
+
   // Colorblind-assist mode: enemy dots switch to the deuteranopia/protanopia-safe
   // palette (mirrored from COLORBLIND_ENEMY_PALETTE in colorblind.constants.ts)
   // and gain a letter-initial shape cue so type is never conveyed by color alone.
@@ -430,6 +492,16 @@
       text-transform: uppercase;
       margin-top: 0.125rem;
     }
+
+    .end-turn-stuck-hint {
+      display: block;
+      font-size: var(--font-size-2xs);
+      font-weight: 400;
+      letter-spacing: 0.04em;
+      color: var(--text-color-muted, rgba(255, 255, 255, 0.55));
+      text-transform: none;
+      margin-top: 0.1rem;
+    }
   }
 
   @keyframes end-turn-stuck-pulse {
@@ -836,16 +908,37 @@ body.reduce-motion .board-container .end-combat-overlay__label { animation: none
   }
 }
 
+// Tile-target mode variant (terraform / elevation cards): cyan instead of gold
+// to distinguish "pick a tile" from "pick a tile to place tower".
+.board-container .placement-indicator--tile-target {
+  background: rgba(0, 220, 220, 0.1);
+  border-color: rgba(0, 220, 220, 0.5);
+  color: var(--theme-cyan, #00dcdc);
+  box-shadow: 0 0 1rem rgba(0, 220, 220, 0.2);
+  animation: tile-target-indicator-pulse 1.6s ease-in-out infinite;
+
+  .placement-indicator__text {
+    color: var(--theme-cyan, #00dcdc);
+  }
+}
+
 @keyframes placement-indicator-pulse {
   0%, 100% { box-shadow: 0 0 1rem rgba(255, 215, 0, 0.2); border-color: rgba(255, 215, 0, 0.5); }
   50%       { box-shadow: 0 0 1.5rem rgba(255, 215, 0, 0.45); border-color: rgba(255, 215, 0, 0.8); }
 }
 
+@keyframes tile-target-indicator-pulse {
+  0%, 100% { box-shadow: 0 0 1rem rgba(0, 220, 220, 0.2); border-color: rgba(0, 220, 220, 0.5); }
+  50%       { box-shadow: 0 0 1.5rem rgba(0, 220, 220, 0.45); border-color: rgba(0, 220, 220, 0.8); }
+}
+
 @media (prefers-reduced-motion: reduce) {
   .board-container .placement-indicator { animation: none; }
+  .board-container .placement-indicator--tile-target { animation: none; }
 }
 
 body.reduce-motion .board-container .placement-indicator { animation: none; }
+body.reduce-motion .board-container .placement-indicator--tile-target { animation: none; }
 
 @media (max-width: 480px) {
   .board-container .placement-indicator {
diff --git a/src/app/game/game-board/game-board.component.spec.ts b/src/app/game/game-board/game-board.component.spec.ts
index 9b284566..9158d44f 100644
--- a/src/app/game/game-board/game-board.component.spec.ts
+++ b/src/app/game/game-board/game-board.component.spec.ts
@@ -62,6 +62,8 @@ import { TutorialFacadeService } from './services/tutorial-facade.service';
 import { ItemCallbacksWiringService } from './services/item-callbacks-wiring.service';
 import { EncounterBootstrapService } from './services/encounter-bootstrap.service';
 import { UI_CONFIG } from './constants/ui.constants';
+import { CardEffectService, ActiveModifier } from '../../run/services/card-effect.service';
+import { MODIFIER_STAT } from '../../run/constants/modifier-stat.constants';
 
 // ---------------------------------------------------------------------------
 // Test-only interfaces — allow typed access to private fields/methods without
@@ -109,6 +111,7 @@ interface TestableGameBoardComponent {
   detectWebgl(): boolean;
   renderGameBoard(): void;
   addGridLines(): void;
+  onTilePlace(row: number, col: number): void;
 }
 
 /** Exposes the internal challengeTrackingService field of TowerInteractionService. */
@@ -3124,5 +3127,63 @@ describe('GameBoardComponent', () => {
     }));
   });
 
+  describe('activeBuffs getter', () => {
+    it('returns an empty array when no modifiers are active', () => {
+      const cardEffect = TestBed.inject(CardEffectService);
+      spyOn(cardEffect, 'getActiveModifiers').and.returnValue([]);
+      expect(component.activeBuffs).toEqual([]);
+    });
+
+    it('maps a damage modifier to a buff chip with percent label', () => {
+      const cardEffect = TestBed.inject(CardEffectService);
+      const modifier: ActiveModifier = {
+        stat: MODIFIER_STAT.DAMAGE,
+        value: 0.25,
+        remainingWaves: 2,
+      };
+      spyOn(cardEffect, 'getActiveModifiers').and.returnValue([modifier]);
+      const chips = component.activeBuffs;
+      expect(chips.length).toBe(1);
+      expect(chips[0].label).toBe('Damage +25%');
+      expect(chips[0].remaining).toBe('2 waves');
+    });
+
+    it('excludes internal sentinel stats from the chips array', () => {
+      const cardEffect = TestBed.inject(CardEffectService);
+      const modifiers: ActiveModifier[] = [
+        // Internal per-turn flag — never surfaced to the player (not in BUFF_META).
+        { stat: MODIFIER_STAT.TERRAFORM_REFUND_USED_THIS_TURN, value: 1, remainingWaves: null, remainingTurns: 1 },
+        { stat: MODIFIER_STAT.RANGE, value: 0.2, remainingWaves: 1 },
+      ];
+      spyOn(cardEffect, 'getActiveModifiers').and.returnValue(modifiers);
+      const chips = component.activeBuffs;
+      expect(chips.length).toBe(1);
+      expect(chips[0].stat).toBe(MODIFIER_STAT.RANGE);
+    });
+  });
+
+  describe('PX-01: onTilePlace routes elevation-target card to resolveTileTarget', () => {
+    it('calls cardPlayService.resolveTileTarget when an elevation-target card is pending and selectedTowerType is null', () => {
+      const cardPlaySvc = fixture.debugElement.injector.get(CardPlayService);
+      // Place an elevation-target card in pending state directly
+      cardPlaySvc['pendingElevationTargetCard'] = {
+        instanceId: 'elev_inst',
+        cardId: CardId.RAISE_PLATFORM,
+        upgraded: false,
+      } as CardInstance;
+      // selectedTowerType must be null for the tile-target branch to fire
+      component.selectedTowerType = null;
+
+      const resolveSpy = spyOn(cardPlaySvc, 'resolveTileTarget').and.returnValue({ ok: true });
+
+      (component as unknown as TestableGameBoardComponent).onTilePlace(2, 3);
+
+      expect(resolveSpy).toHaveBeenCalled();
+      const [row, col] = resolveSpy.calls.mostRecent().args;
+      expect(row).toBe(2);
+      expect(col).toBe(3);
+    });
+  });
+
 });
 
diff --git a/src/app/game/game-board/game-board.component.ts b/src/app/game/game-board/game-board.component.ts
index a617eb63..753bea0c 100644
--- a/src/app/game/game-board/game-board.component.ts
+++ b/src/app/game/game-board/game-board.component.ts
@@ -69,9 +69,11 @@ import { RELIC_DEFINITIONS } from '../../run/models/relic.model';
 import { ItemService } from '../../run/services/item.service';
 import { ItemType, ITEM_DEFINITIONS } from '../../run/models/item.model';
 import { DeckService } from '../../run/services/deck.service';
+import { CardEffectService } from '../../run/services/card-effect.service';
+import { BuffChip, toBuffChips } from './models/buff-display.model';
 import { EncounterResult } from '../../run/models/run-state.model';
 import { CardInstance, DeckState, EnergyState } from '../../run/models/card.model';
-import { getActiveTowerEffect } from '../../run/constants/card-definitions';
+import { getActiveTowerEffect, getCardDefinition } from '../../run/constants/card-definitions';
 import { WaveCombatFacadeService } from './services/wave-combat-facade.service';
 import { TutorialFacadeService } from './services/tutorial-facade.service';
 import { AscensionModifierService } from './services/ascension-modifier.service';
@@ -355,6 +357,16 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
   /** True while inside a run — the pre-run-mode setup panel is never shown in this path. */
   get isInRun(): boolean { return this.runService.isInRun(); }
 
+  /** Active card-modifier buff chips for the persistent HUD panel. Cheap: maps a small readonly array. */
+  get activeBuffs(): BuffChip[] {
+    return toBuffChips(this.cardEffectService.getActiveModifiers());
+  }
+
+  /** trackBy for the active-buffs *ngFor — uses index since chips are regenerated each render. */
+  trackBuffByIndex(index: number): number {
+    return index;
+  }
+
   /** Resolves newly unlocked achievement IDs to their name/description for display. */
   private updateAchievementDetails(): void {
     this.achievementDetails = this.newlyUnlockedAchievements
@@ -411,6 +423,7 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
     private runService: RunService,
     private relicService: RelicService,
     private deckService: DeckService,
+    private cardEffectService: CardEffectService,
     private gameRenderService: GameRenderService,
     private meshRegistry: BoardMeshRegistryService,
     private touchInteraction: TouchInteractionService,
@@ -508,6 +521,8 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
         // checkpoint clear + reward flow already happened inside waveCombat.endTurn();
         // recordEncounterResult above stashes the result for RunService to consume
         // at /run — navigation order does not affect those operations.
+        // Stop combat music immediately so it doesn't play under the victory/defeat overlay.
+        this.musicService.stopMusic(0.8);
         this.showEndOverlay = true;
         this.endOverlayIsVictory = isVictory;
         if (this.endOverlayDwellTimer !== null) {
@@ -811,6 +826,12 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
       onExitTileTargetMode: () => {
         // No tile-target-specific cleanup needed until sprint 23 adds highlights.
       },
+      onNonTowerCardPlayed: (cardName, effectSummary) => {
+        this.notificationService.show(NotificationType.INFO, cardName, effectSummary);
+      },
+      onCardPlayBlocked: (message) => {
+        this.notificationService.show(NotificationType.INFO, 'Cannot play', message);
+      },
     });
 
     this.minimapService.init(this.canvasContainer.nativeElement);
@@ -939,6 +960,24 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
     return this.cardPlayService.getPendingCardId();
   }
 
+  /**
+   * Expose pending tile-target card instanceId to template.
+   * Non-null while a terraform or elevation card awaits a tile click — used by the
+   * tile-target banner and by CardHandComponent [pendingCardId] to dim the active card.
+   */
+  get pendingTileTargetCardId(): string | null {
+    return this.cardPlayService.getPendingTileTargetCardId();
+  }
+
+  /**
+   * True while ANY card is in limbo (tower placement or tile-target mode).
+   * Used to disable End Turn so the first Space press doesn't silently cancel
+   * the pending card and end the turn in a single keypress.
+   */
+  get hasPendingCard(): boolean {
+    return this.cardPlayService.hasPendingCard();
+  }
+
   /**
    * Handle a card played from CardHandComponent.
    * Delegates to CardPlayService which manages placement limbo and spell effects.
@@ -994,7 +1033,10 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
       return;
     }
 
-    if (!result.success) return;
+    if (!result.success) {
+      this.notificationService.show(NotificationType.INFO, 'Cannot upgrade', 'Not enough gold.');
+      return;
+    }
 
     // Successful upgrade is the canonical UPGRADE_TOWER / TIP_UPGRADE dismissal signal.
     this.tutorialService.dismissOnPlayerAction();
@@ -1120,9 +1162,11 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
 
   startWave(): void {
     if (this.isPaused) return;
-    // Starting a wave counts as the START_WAVE tutorial step by definition.
-    this.tutorialService.dismissOnPlayerAction();
     this.waveCombat.startWave();
+    // Dismiss the START_WAVE tutorial step AFTER the wave has started so the
+    // same Space press that triggers the wave does not dismiss the step before
+    // waveCombat.startWave() has a chance to advance it.
+    this.tutorialService.dismissOnPlayerAction();
     // Ensure a turn-history window is open for the new wave's opening turn.
     // endTurn() opens one on COMBAT/INTERMISSION, but guard here so a wave that
     // begins without an open window still tracks cards played on its first turn.
@@ -1232,7 +1276,21 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
 
   /** Use a consumable item from the pause menu. */
   useItem(type: ItemType): void {
-    this.itemService.useItem(type);
+    const def = ITEM_DEFINITIONS[type];
+    const result = this.itemService.useItem(type);
+    if (result.success) {
+      this.notificationService.show(NotificationType.INFO, def.name, def.description);
+      return;
+    }
+    const reasonMessages: Record<string, string> = {
+      no_enemies: 'No enemies on board.',
+      at_max: 'Already at max lives.',
+      wrong_phase: 'Can only use during combat.',
+      wrong_node: 'Can only use at a shop node.',
+      not_owned: 'Item not in inventory.',
+    };
+    const message = (result.reason && reasonMessages[result.reason]) ?? 'Cannot use that item now.';
+    this.notificationService.show(NotificationType.INFO, def.name, message);
   }
 
   /**
@@ -1432,7 +1490,15 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
    * Priority: terraform-target > tower placement (spec §4).
    */
   private onTilePlace(row: number, col: number): void {
-    if (this.cardPlayService.getPendingTileTargetCard()) {
+    // Route BOTH terraform- and elevation-target cards to resolveTileTarget
+    // (it dispatches on whichever pending field is set). A pending TOWER card
+    // sets selectedTowerType, so it skips this branch and falls through to
+    // tryPlaceTower below.
+    if (this.cardPlayService.hasPendingCard() && !this.selectedTowerType) {
+      // Capture the card definition BEFORE resolveTileTarget consumes the pending state.
+      const pendingCard = this.cardPlayService.getAnyPendingTileTargetCard();
+      const pendingDef = pendingCard ? getCardDefinition(pendingCard.cardId) : null;
+
       const scene = this.sceneService.getScene();
       const currentTurn = this.combatLoopService.getTurnNumber();
       const result = this.cardPlayService.resolveTileTarget(row, col, scene, currentTurn);
@@ -1455,6 +1521,13 @@ export class GameBoardComponent implements OnInit, AfterViewInit, OnDestroy {
       } else {
         // Log card-play to turn history — mirrors the path in onCardPlayed.
         this.turnHistoryService.recordCardPlayed();
+        // Confirm the successful tile mutation with the card name and effect summary.
+        if (pendingDef) {
+          const effectSummary = (pendingCard?.upgraded && pendingDef.upgradedDescription)
+            ? pendingDef.upgradedDescription
+            : pendingDef.description;
+          this.notificationService.show(NotificationType.INFO, pendingDef.name, effectSummary);
+        }
       }
       return;
     }
diff --git a/src/app/game/game-board/models/buff-display.model.spec.ts b/src/app/game/game-board/models/buff-display.model.spec.ts
new file mode 100644
index 00000000..9983e81f
--- /dev/null
+++ b/src/app/game/game-board/models/buff-display.model.spec.ts
@@ -0,0 +1,184 @@
+import { MODIFIER_STAT } from '../../../run/constants/modifier-stat.constants';
+import { ActiveModifier } from '../../../run/services/card-effect.service';
+import { BuffChip, toBuffChips } from './buff-display.model';
+
+function makeModifier(
+  stat: ActiveModifier['stat'],
+  value: number,
+  remainingWaves: number | null = 2,
+  remainingTurns?: number,
+): ActiveModifier {
+  return { stat, value, remainingWaves, remainingTurns };
+}
+
+describe('toBuffChips', () => {
+
+  describe('label formatting', () => {
+    it('formats percent stats as "+N%"', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.DAMAGE, 0.25)]);
+      expect(chips.length).toBe(1);
+      expect(chips[0].label).toBe('Damage +25%');
+    });
+
+    it('rounds percent values', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.RANGE, 0.333)]);
+      expect(chips[0].label).toBe('Range +33%');
+    });
+
+    it('formats sniper damage as percent', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.SNIPER_DAMAGE, 0.5)]);
+      expect(chips[0].label).toBe('Sniper Dmg +50%');
+    });
+
+    it('formats fire rate as percent', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.FIRE_RATE, 0.1)]);
+      expect(chips[0].label).toBe('Fire Rate +10%');
+    });
+
+    it('formats chain bounces as flat', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.CHAIN_BOUNCES, 2)]);
+      expect(chips[0].label).toBe('Chain +2');
+    });
+
+    it('formats gold multiplier as percent', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.GOLD_MULTIPLIER, 0.5)]);
+      expect(chips[0].label).toBe('Gold Interest +50%');
+    });
+
+    it('formats enemy slow using absolute value', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.ENEMY_SPEED, -0.3)]);
+      expect(chips[0].label).toBe('Enemy Slow 30%');
+    });
+
+    it('formats leak block label as name only (count goes in remaining)', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.LEAK_BLOCK, 3, null)]);
+      expect(chips[0].label).toBe('Leak Shield');
+    });
+  });
+
+  describe('remaining string', () => {
+    it('shows wave countdown for wave-scoped modifiers', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.DAMAGE, 0.2, 3)]);
+      expect(chips[0].remaining).toBe('3 waves');
+    });
+
+    it('uses singular "wave" for 1 remaining wave', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.DAMAGE, 0.2, 1)]);
+      expect(chips[0].remaining).toBe('1 wave');
+    });
+
+    it('shows turn countdown for turn-scoped modifiers', () => {
+      const mod = makeModifier(MODIFIER_STAT.FIRE_RATE, 0.2, null, 2);
+      const chips = toBuffChips([mod]);
+      expect(chips[0].remaining).toBe('2 turns');
+    });
+
+    it('uses singular "turn" for 1 remaining turn', () => {
+      const mod = makeModifier(MODIFIER_STAT.FIRE_RATE, 0.2, null, 1);
+      const chips = toBuffChips([mod]);
+      expect(chips[0].remaining).toBe('1 turn');
+    });
+
+    it('shows "active" for encounter-scoped modifiers (null waves, no turns)', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.GOLD_MULTIPLIER, 0.5, null)]);
+      expect(chips[0].remaining).toBe('active');
+    });
+
+    it('shows block count for leak block with value > 0', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.LEAK_BLOCK, 2, null)]);
+      expect(chips[0].remaining).toBe('2 blocks');
+    });
+
+    it('uses singular "block" for 1 remaining block', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.LEAK_BLOCK, 1, null)]);
+      expect(chips[0].remaining).toBe('1 block');
+    });
+  });
+
+  describe('charges skip-when-zero', () => {
+    it('skips leak block chip when value is 0', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.LEAK_BLOCK, 0, null)]);
+      expect(chips.length).toBe(0);
+    });
+
+    it('skips leak block chip when value is negative', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.LEAK_BLOCK, -1, null)]);
+      expect(chips.length).toBe(0);
+    });
+  });
+
+  describe('flag format — encounter-scoped archetype chips', () => {
+    it('renders TERRAFORM_ANCHOR as "Cartographer Seal" with remaining "active"', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.TERRAFORM_ANCHOR, 1, null)]);
+      expect(chips.length).toBe(1);
+      expect(chips[0].label).toBe('Cartographer Seal');
+      expect(chips[0].remaining).toBe('active');
+    });
+
+    it('renders LABYRINTH_MIND as "Labyrinth Mind" with remaining "active"', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.LABYRINTH_MIND, 1, null)]);
+      expect(chips.length).toBe(1);
+      expect(chips[0].label).toBe('Labyrinth Mind');
+      expect(chips[0].remaining).toBe('active');
+    });
+
+    it('renders ARCHITECT_CLUSTER_PROPAGATION as "Architect" with remaining "active"', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.ARCHITECT_CLUSTER_PROPAGATION, 1, null)]);
+      expect(chips.length).toBe(1);
+      expect(chips[0].label).toBe('Architect');
+      expect(chips[0].remaining).toBe('active');
+    });
+
+    it('renders HIVE_MIND_CLUSTER_MAX as "Hive Mind" with remaining "active"', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.HIVE_MIND_CLUSTER_MAX, 1, null)]);
+      expect(chips.length).toBe(1);
+      expect(chips[0].label).toBe('Hive Mind');
+      expect(chips[0].remaining).toBe('active');
+    });
+
+    it('flag chips show "active" regardless of the numeric value', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.TERRAFORM_ANCHOR, 2, null)]);
+      expect(chips[0].label).toBe('Cartographer Seal');
+      expect(chips[0].remaining).toBe('active');
+    });
+
+    it('flag chips ignore wave/turn countdown fields and still show "active"', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.HIVE_MIND_CLUSTER_MAX, 1, 3)]);
+      expect(chips[0].remaining).toBe('active');
+    });
+  });
+
+  describe('unmapped stats are excluded', () => {
+    it('drops HANDSHAKE_DAMAGE_BONUS (wave-scoped Conduit stat)', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.HANDSHAKE_DAMAGE_BONUS, 0.2, 2)]);
+      expect(chips.length).toBe(0);
+    });
+
+    it('drops GRAVITY_WELL (mechanic sentinel, not a player buff)', () => {
+      const chips = toBuffChips([makeModifier(MODIFIER_STAT.GRAVITY_WELL, 1, null)]);
+      expect(chips.length).toBe(0);
+    });
+  });
+
+  describe('mixed input', () => {
+    it('returns numeric and flag chips together, drops unmapped stats', () => {
+      const modifiers: ActiveModifier[] = [
+        makeModifier(MODIFIER_STAT.DAMAGE, 0.25, 3),
+        makeModifier(MODIFIER_STAT.HANDSHAKE_DAMAGE_BONUS, 0.2, 2),
+        makeModifier(MODIFIER_STAT.TERRAFORM_ANCHOR, 1, null),
+        makeModifier(MODIFIER_STAT.RANGE, 0.2, 2),
+      ];
+      const chips = toBuffChips(modifiers);
+      expect(chips.length).toBe(3);
+      expect(chips.map((c: BuffChip) => c.stat)).toEqual([
+        MODIFIER_STAT.DAMAGE,
+        MODIFIER_STAT.TERRAFORM_ANCHOR,
+        MODIFIER_STAT.RANGE,
+      ]);
+    });
+
+    it('returns empty array for empty input', () => {
+      expect(toBuffChips([])).toEqual([]);
+    });
+  });
+});
diff --git a/src/app/game/game-board/models/buff-display.model.ts b/src/app/game/game-board/models/buff-display.model.ts
new file mode 100644
index 00000000..4f464fbd
--- /dev/null
+++ b/src/app/game/game-board/models/buff-display.model.ts
@@ -0,0 +1,105 @@
+import { ActiveModifier } from '../../../run/services/card-effect.service';
+import { MODIFIER_STAT, ModifierStat } from '../../../run/constants/modifier-stat.constants';
+
+/** A single rendered buff chip for the active-buffs HUD panel. */
+export interface BuffChip {
+  readonly stat: string;
+  readonly label: string;
+  readonly remaining: string;
+}
+
+/**
+ * 'flag' format: an encounter-scoped on/off stat. The label is just the name;
+ * remaining is always 'active'. No numeric value is displayed.
+ */
+type FormatKind = 'percent' | 'flat' | 'slow' | 'charges' | 'flag';
+
+interface StatMeta {
+  name: string;
+  format: FormatKind;
+}
+
+/**
+ * Maps the subset of ModifierStat values that are player-facing card buffs to
+ * their display name and value format. Includes both numeric stats and
+ * encounter-scoped archetype flag stats that the player should see persistently.
+ */
+const BUFF_META: Partial<Record<ModifierStat, StatMeta>> = {
+  [MODIFIER_STAT.DAMAGE]:          { name: 'Damage',          format: 'percent'  },
+  [MODIFIER_STAT.RANGE]:           { name: 'Range',           format: 'percent'  },
+  [MODIFIER_STAT.SNIPER_DAMAGE]:   { name: 'Sniper Dmg',     format: 'percent'  },
+  [MODIFIER_STAT.FIRE_RATE]:       { name: 'Fire Rate',       format: 'percent'  },
+  [MODIFIER_STAT.CHAIN_BOUNCES]:   { name: 'Chain',           format: 'flat'     },
+  [MODIFIER_STAT.ENEMY_SPEED]:     { name: 'Enemy Slow',      format: 'slow'     },
+  [MODIFIER_STAT.GOLD_MULTIPLIER]: { name: 'Gold Interest',   format: 'percent'  },
+  [MODIFIER_STAT.LEAK_BLOCK]:      { name: 'Leak Shield',     format: 'charges'  },
+
+  // Encounter-scoped archetype flags — rendered as persistent 'active' chips so
+  // the player can see which anchor cards are in effect for the whole encounter.
+  [MODIFIER_STAT.TERRAFORM_ANCHOR]:           { name: 'Cartographer Seal', format: 'flag' },
+  [MODIFIER_STAT.LABYRINTH_MIND]:             { name: 'Labyrinth Mind',    format: 'flag' },
+  [MODIFIER_STAT.ARCHITECT_CLUSTER_PROPAGATION]: { name: 'Architect',      format: 'flag' },
+  [MODIFIER_STAT.HIVE_MIND_CLUSTER_MAX]:      { name: 'Hive Mind',         format: 'flag' },
+};
+
+function formatLabel(meta: StatMeta, value: number): string {
+  switch (meta.format) {
+    case 'percent':  return `${meta.name} +${Math.round(value * 100)}%`;
+    case 'flat':     return `${meta.name} +${value}`;
+    case 'slow':     return `${meta.name} ${Math.round(Math.abs(value) * 100)}%`;
+    case 'charges':  return meta.name;
+    case 'flag':     return meta.name;
+  }
+}
+
+function formatRemaining(meta: StatMeta, m: ActiveModifier): string | null {
+  if (meta.format === 'charges') {
+    if (m.value <= 0) {
+      return null;
+    }
+    return `${m.value} ${m.value === 1 ? 'block' : 'blocks'}`;
+  }
+
+  if (meta.format === 'flag') {
+    return 'active';
+  }
+
+  if (m.remainingTurns !== undefined) {
+    return `${m.remainingTurns} ${m.remainingTurns === 1 ? 'turn' : 'turns'}`;
+  }
+
+  if (m.remainingWaves !== null) {
+    return `${m.remainingWaves} ${m.remainingWaves === 1 ? 'wave' : 'waves'}`;
+  }
+
+  return 'active';
+}
+
+/**
+ * Converts an array of ActiveModifiers from CardEffectService into BuffChips
+ * suitable for display in the active-buffs HUD panel. Unmapped stats and
+ * zero-charge entries are silently dropped.
+ */
+export function toBuffChips(modifiers: ReadonlyArray<ActiveModifier>): BuffChip[] {
+  const chips: BuffChip[] = [];
+
+  for (const m of modifiers) {
+    const meta = BUFF_META[m.stat];
+    if (meta === undefined) {
+      continue;
+    }
+
+    const remaining = formatRemaining(meta, m);
+    if (remaining === null) {
+      continue;
+    }
+
+    chips.push({
+      stat: m.stat,
+      label: formatLabel(meta, m.value),
+      remaining,
+    });
+  }
+
+  return chips;
+}
diff --git a/src/app/game/game-board/models/index.ts b/src/app/game/game-board/models/index.ts
index 05478bc1..1d3b8429 100644
--- a/src/app/game/game-board/models/index.ts
+++ b/src/app/game/game-board/models/index.ts
@@ -1,4 +1,5 @@
 export * from './achievement.model';
+export * from './buff-display.model';
 export * from './combat-frame.model';
 export * from './endless-wave.model';
 export * from './enemy-info.model';
diff --git a/src/app/game/game-board/services/card-play.service.spec.ts b/src/app/game/game-board/services/card-play.service.spec.ts
index 4ec069dd..0a2c2af2 100644
--- a/src/app/game/game-board/services/card-play.service.spec.ts
+++ b/src/app/game/game-board/services/card-play.service.spec.ts
@@ -22,6 +22,7 @@ import { CombatLoopService } from './combat-loop.service';
 import { WavePreviewService } from './wave-preview.service';
 import { TowerType } from '../models/tower.model';
 import { GamePhase, INITIAL_GAME_STATE } from '../models/game-state.model';
+import { StatusEffectType } from '@core/models/status-effect-type.model';
 import {
   CardId,
   CardInstance,
@@ -169,7 +170,9 @@ describe('CardPlayService', () => {
 
     sceneSpy = createSceneServiceSpy();
 
-    statusEffectSpy = jasmine.createSpyObj<StatusEffectService>('StatusEffectService', ['apply']);
+    statusEffectSpy = jasmine.createSpyObj<StatusEffectService>('StatusEffectService', ['apply', 'hasEffect']);
+    // Default: no status effects active. Tests that need specific effects override hasEffect per-test.
+    statusEffectSpy.hasEffect.and.returnValue(false);
     combatLoopSpy = jasmine.createSpyObj<CombatLoopService>('CombatLoopService', ['getTurnNumber']);
     combatLoopSpy.getTurnNumber.and.returnValue(1);
     wavePreviewSpy = jasmine.createSpyObj<WavePreviewService>('WavePreviewService', [
@@ -364,11 +367,16 @@ describe('CardPlayService', () => {
     });
 
     describe('CONDUIT_BRIDGE ("bridge_towers" utility)', () => {
-      it('is a no-op when TowerGraphService is absent (pre-Conduit test beds)', () => {
+      it('is a no-op (no edge) when TowerGraphService is absent (pre-Conduit test beds)', () => {
         // Default TestBed does not provide TowerGraphService, so the @Optional
-        // graphService is undefined. Card still consumes energy (playCard fires),
-        // but no virtual edge is registered.
-        towerCombatSpy.getPlacedTowers.and.returnValue(new Map());
+        // graphService is undefined. Card still consumes energy when ≥2 towers
+        // exist (pre-validation passes), but no virtual edge is registered.
+        const t1 = { row: 0, col: 0, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+        const t2 = { row: 5, col: 5, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+        const placedMap = new Map<string, typeof t1>();
+        placedMap.set('0-0', t1 as never);
+        placedMap.set('5-5', t2 as never);
+        towerCombatSpy.getPlacedTowers.and.returnValue(placedMap as never);
         const card: CardInstance = { instanceId: 'cb-1', cardId: CardId.CONDUIT_BRIDGE, upgraded: false };
         service.onCardPlayed(card);
         // Card consumed (utility cards are instant-resolve via playCard).
@@ -484,6 +492,25 @@ describe('CardPlayService', () => {
     });
   });
 
+  describe('non-tower card play feedback', () => {
+    it('fires onNonTowerCardPlayed with the card name and effect summary when a modifier resolves', () => {
+      const onNonTowerCardPlayed = jasmine.createSpy('onNonTowerCardPlayed');
+      service.init({
+        onEnterPlacementMode: jasmine.createSpy(),
+        onRefreshUI: jasmine.createSpy(),
+        onSalvageComplete: jasmine.createSpy(),
+        onNonTowerCardPlayed,
+      });
+
+      const def = CARD_DEFINITIONS[CardId.DAMAGE_BOOST];
+      const card: CardInstance = { instanceId: 'dmg-1', cardId: CardId.DAMAGE_BOOST, upgraded: false };
+      service.onCardPlayed(card);
+
+      expect(cardEffectSpy.applyModifier).toHaveBeenCalled();
+      expect(onNonTowerCardPlayed).toHaveBeenCalledWith(def.name, def.description);
+    });
+  });
+
   describe('fortify pre-validation', () => {
     it('should NOT consume card or energy when no towers are upgradeable (empty map)', () => {
       towerCombatSpy.getPlacedTowers.and.returnValue(new Map());
@@ -1829,5 +1856,242 @@ describe('CardPlayService', () => {
       expect(() => service['executeUtilityCard'](badEffect)).toThrow();
     });
   });
+
+  // ── onCardPlayBlocked feedback ─────────────────────────────────────────────
+
+  describe('onCardPlayBlocked callback', () => {
+    let blockedSpy: jasmine.Spy;
+
+    beforeEach(() => {
+      blockedSpy = jasmine.createSpy('onCardPlayBlocked');
+      service.init({
+        onEnterPlacementMode: jasmine.createSpy(),
+        onRefreshUI: jasmine.createSpy(),
+        onSalvageComplete: jasmine.createSpy(),
+        onCardPlayBlocked: blockedSpy,
+      });
+    });
+
+    it('fires with intermission message when phase is not COMBAT', () => {
+      gameStateSpy.getState.and.returnValue({ ...INITIAL_GAME_STATE, phase: GamePhase.SETUP });
+      const card: CardInstance = { instanceId: 'c1', cardId: CardId.DRAW_TWO, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('Cards can only be played during combat.');
+    });
+
+    it('does NOT fire when phase is COMBAT and play proceeds normally', () => {
+      gameStateSpy.getState.and.returnValue({ ...INITIAL_GAME_STATE, phase: GamePhase.COMBAT });
+      const card: CardInstance = { instanceId: 'c2', cardId: CardId.DRAW_TWO, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).not.toHaveBeenCalled();
+    });
+
+    it('fires with no-towers message when SALVAGE is played with no towers placed', () => {
+      towerCombatSpy.getPlacedTowers.and.returnValue(new Map());
+      const card: CardInstance = { instanceId: 'sal-blk', cardId: CardId.SALVAGE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('No towers to salvage.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('fires with max-level message when FORTIFY is played and all towers are at max-1', () => {
+      // MAX_TOWER_LEVEL = 3 — level 2 is not auto-upgradeable (requires spec choice)
+      const tower = { row: 0, col: 0, level: 2, type: TowerType.BASIC, totalInvested: 100 };
+      const placedMap = new Map<string, typeof tower>();
+      placedMap.set('0-0', tower as never);
+      towerCombatSpy.getPlacedTowers.and.returnValue(placedMap as never);
+      const card: CardInstance = { instanceId: 'fort-blk', cardId: CardId.FORTIFY, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('All towers are already at max level.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('does NOT fire for SALVAGE when towers exist', () => {
+      const tower = { row: 0, col: 0, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+      const placedMap = new Map<string, typeof tower>();
+      placedMap.set('0-0', tower as never);
+      towerCombatSpy.getPlacedTowers.and.returnValue(placedMap as never);
+      towerCombatSpy.unregisterTower.and.returnValue(tower as never);
+      const mockScene = { remove: jasmine.createSpy('remove') };
+      (sceneSpy.getScene as jasmine.Spy).and.returnValue(mockScene);
+      const card: CardInstance = { instanceId: 'sal-ok', cardId: CardId.SALVAGE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).not.toHaveBeenCalled();
+    });
+
+    it('does NOT fire for FORTIFY when an upgradeable tower exists', () => {
+      const tower = { row: 0, col: 0, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+      const placedMap = new Map<string, typeof tower>();
+      placedMap.set('0-0', tower as never);
+      towerCombatSpy.getPlacedTowers.and.returnValue(placedMap as never);
+      towerCombatSpy.upgradeTower.and.returnValue(tower as never);
+      const card: CardInstance = { instanceId: 'fort-ok', cardId: CardId.FORTIFY, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── DETONATE / EPIDEMIC / CONDUIT_BRIDGE pre-validation ───────────────────
+
+  describe('DETONATE pre-validation', () => {
+    let blockedSpy: jasmine.Spy;
+
+    beforeEach(() => {
+      blockedSpy = jasmine.createSpy('onCardPlayBlocked');
+      service.init({
+        onEnterPlacementMode: jasmine.createSpy(),
+        onRefreshUI: jasmine.createSpy(),
+        onSalvageComplete: jasmine.createSpy(),
+        onCardPlayBlocked: blockedSpy,
+      });
+    });
+
+    it('fires onCardPlayBlocked and does NOT consume energy when no burning enemies exist', () => {
+      // Empty enemy map — no burning enemies.
+      enemySpy.getEnemies.and.returnValue(new Map() as never);
+      const card: CardInstance = { instanceId: 'det-blk', cardId: CardId.DETONATE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('No burning enemies.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('fires onCardPlayBlocked when all enemies with BURN are dying', () => {
+      const statusSpy = TestBed.inject(StatusEffectService) as jasmine.SpyObj<StatusEffectService>;
+      statusSpy.hasEffect.and.callFake((_id: string, type: StatusEffectType) =>
+        type === StatusEffectType.BURN,
+      );
+      const dyingEnemy = { id: 'e-dying', dying: true };
+      enemySpy.getEnemies.and.returnValue(new Map([['e-dying', dyingEnemy]]) as never);
+      const card: CardInstance = { instanceId: 'det-dying', cardId: CardId.DETONATE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('No burning enemies.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('allows play and consumes energy when a non-dying burning enemy exists', () => {
+      const statusSpy = TestBed.inject(StatusEffectService) as jasmine.SpyObj<StatusEffectService>;
+      statusSpy.hasEffect.and.callFake((_id: string, type: StatusEffectType) =>
+        type === StatusEffectType.BURN,
+      );
+      const liveEnemy = { id: 'e-burn', dying: false };
+      enemySpy.getEnemies.and.returnValue(new Map([['e-burn', liveEnemy]]) as never);
+      const card: CardInstance = { instanceId: 'det-ok', cardId: CardId.DETONATE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).not.toHaveBeenCalled();
+      expect(deckSpy.playCard).toHaveBeenCalledWith('det-ok');
+    });
+  });
+
+  describe('EPIDEMIC pre-validation', () => {
+    let blockedSpy: jasmine.Spy;
+
+    beforeEach(() => {
+      blockedSpy = jasmine.createSpy('onCardPlayBlocked');
+      service.init({
+        onEnterPlacementMode: jasmine.createSpy(),
+        onRefreshUI: jasmine.createSpy(),
+        onSalvageComplete: jasmine.createSpy(),
+        onCardPlayBlocked: blockedSpy,
+      });
+    });
+
+    it('fires onCardPlayBlocked and does NOT consume energy when no poisoned enemies exist', () => {
+      enemySpy.getEnemies.and.returnValue(new Map() as never);
+      const card: CardInstance = { instanceId: 'ep-blk', cardId: CardId.EPIDEMIC, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('No poisoned enemies.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('allows play when a non-dying poisoned enemy exists', () => {
+      const statusSpy = TestBed.inject(StatusEffectService) as jasmine.SpyObj<StatusEffectService>;
+      statusSpy.hasEffect.and.callFake((_id: string, type: StatusEffectType) =>
+        type === StatusEffectType.POISON,
+      );
+      const liveEnemy = { id: 'e-poison', dying: false };
+      enemySpy.getEnemies.and.returnValue(new Map([['e-poison', liveEnemy]]) as never);
+      const card: CardInstance = { instanceId: 'ep-ok', cardId: CardId.EPIDEMIC, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).not.toHaveBeenCalled();
+      expect(deckSpy.playCard).toHaveBeenCalledWith('ep-ok');
+    });
+  });
+
+  describe('CONDUIT_BRIDGE pre-validation (bridge_towers utility)', () => {
+    let blockedSpy: jasmine.Spy;
+
+    beforeEach(() => {
+      blockedSpy = jasmine.createSpy('onCardPlayBlocked');
+      service.init({
+        onEnterPlacementMode: jasmine.createSpy(),
+        onRefreshUI: jasmine.createSpy(),
+        onSalvageComplete: jasmine.createSpy(),
+        onCardPlayBlocked: blockedSpy,
+      });
+    });
+
+    it('fires onCardPlayBlocked and does NOT consume energy when fewer than 2 towers exist', () => {
+      towerCombatSpy.getPlacedTowers.and.returnValue(new Map());
+      const card: CardInstance = { instanceId: 'cb-blk', cardId: CardId.CONDUIT_BRIDGE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('Need at least 2 towers to bridge.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('fires onCardPlayBlocked when exactly 1 tower exists', () => {
+      const tower = { row: 0, col: 0, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+      const placedMap = new Map<string, typeof tower>();
+      placedMap.set('0-0', tower as never);
+      towerCombatSpy.getPlacedTowers.and.returnValue(placedMap as never);
+      const card: CardInstance = { instanceId: 'cb-one', cardId: CardId.CONDUIT_BRIDGE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).toHaveBeenCalledOnceWith('Need at least 2 towers to bridge.');
+      expect(deckSpy.playCard).not.toHaveBeenCalled();
+    });
+
+    it('allows play and consumes energy when 2 or more towers exist', () => {
+      const t1 = { row: 0, col: 0, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+      const t2 = { row: 5, col: 5, level: 1, type: TowerType.BASIC, totalInvested: 50 };
+      const placedMap = new Map<string, typeof t1>();
+      placedMap.set('0-0', t1 as never);
+      placedMap.set('5-5', t2 as never);
+      towerCombatSpy.getPlacedTowers.and.returnValue(placedMap as never);
+      const card: CardInstance = { instanceId: 'cb-ok', cardId: CardId.CONDUIT_BRIDGE, upgraded: false };
+      service.onCardPlayed(card);
+      expect(blockedSpy).not.toHaveBeenCalled();
+      expect(deckSpy.playCard).toHaveBeenCalledWith('cb-ok');
+    });
+  });
+
+  // ── getPendingTileTargetCardId ─────────────────────────────────────────────
+
+  describe('getPendingTileTargetCardId', () => {
+    it('returns null when no tile-target card is pending', () => {
+      expect(service.getPendingTileTargetCardId()).toBeNull();
+    });
+
+    it('returns the instanceId of the pending terraform card', () => {
+      service['pendingTileTargetCard'] = { instanceId: 'tf-pending', cardId: CardId.LAY_TILE, upgraded: false };
+      expect(service.getPendingTileTargetCardId()).toBe('tf-pending');
+    });
+
+    it('returns the instanceId of the pending elevation card', () => {
+      service['pendingElevationTargetCard'] = { instanceId: 'elev-pending', cardId: CardId.LAY_TILE, upgraded: false };
+      expect(service.getPendingTileTargetCardId()).toBe('elev-pending');
+    });
+
+    it('returns the terraform card id when both are somehow set (terraform takes precedence via ?? chain)', () => {
+      service['pendingTileTargetCard'] = { instanceId: 'tf-first', cardId: CardId.LAY_TILE, upgraded: false };
+      service['pendingElevationTargetCard'] = { instanceId: 'elev-second', cardId: CardId.LAY_TILE, upgraded: false };
+      // The getter uses (pendingTileTargetCard ?? pendingElevationTargetCard) — terraform wins
+      expect(service.getPendingTileTargetCardId()).toBe('tf-first');
+    });
+
+    it('returns null after reset clears both pending states', () => {
+      service['pendingTileTargetCard'] = { instanceId: 'tf-reset', cardId: CardId.LAY_TILE, upgraded: false };
+      service.reset();
+      expect(service.getPendingTileTargetCardId()).toBeNull();
+    });
+  });
 });
 
diff --git a/src/app/game/game-board/services/card-play.service.ts b/src/app/game/game-board/services/card-play.service.ts
index e123ea7d..6d7e901a 100644
--- a/src/app/game/game-board/services/card-play.service.ts
+++ b/src/app/game/game-board/services/card-play.service.ts
@@ -4,6 +4,7 @@ import * as THREE from 'three';
 import { TowerType, MAX_TOWER_LEVEL } from '../models/tower.model';
 import { DamagePopupService } from './damage-popup.service';
 import { GamePhase } from '../models/game-state.model';
+import { StatusEffectType } from '@core/models/status-effect-type.model';
 import { GameStateService } from './game-state.service';
 import { GameStatsService } from './game-stats.service';
 import { GameBoardService } from '../game-board.service';
@@ -77,6 +78,17 @@ export interface CardPlayCallbacks {
    * a push notification to tear down tile-target highlights and cursor changes.
    */
   onExitTileTargetMode?: () => void;
+  /**
+   * Called after a non-tower card (spell / modifier / utility) resolves so the
+   * UI can confirm what the play did. Modifier cards especially are otherwise
+   * invisible — nothing on the board changes when they apply.
+   */
+  onNonTowerCardPlayed?: (cardName: string, effectSummary: string) => void;
+  /**
+   * Called when a card play is blocked by a pending mode (tower placement or
+   * tile-target) so the UI can surface a toast explaining why the click was ignored.
+   */
+  onCardPlayBlocked?: (message: string) => void;
 }
 
 /**
@@ -202,6 +214,19 @@ export class CardPlayService {
     return this.pendingTowerCard?.instanceId ?? null;
   }
 
+  /**
+   * Returns the instanceId of whichever tile-target card is pending
+   * (terraform or elevation), or null when no tile-target mode is active.
+   *
+   * WHY THIS EXISTS: GameBoardComponent needs to pass the pending tile-target
+   * card id to CardHandComponent ([pendingCardId]) so the active card dims
+   * while the player is choosing a tile — mirroring the existing tower-placement
+   * dimming behaviour.
+   */
+  getPendingTileTargetCardId(): string | null {
+    return (this.pendingTileTargetCard ?? this.pendingElevationTargetCard)?.instanceId ?? null;
+  }
+
   /**
    * Returns the card currently awaiting a tile-target click, or null.
    *
@@ -214,6 +239,19 @@ export class CardPlayService {
     return this.pendingTileTargetCard;
   }
 
+  /**
+   * Returns whichever tile-target card is pending — terraform or elevation —
+   * or null when neither mode is active.
+   *
+   * WHY THIS EXISTS: GameBoardComponent.onTilePlace needs to capture the card
+   * definition BEFORE resolveTileTarget clears the pending state on success,
+   * so it can show a "card played" toast with the correct name and description.
+   * Returning either card from one getter avoids duplicating the access logic.
+   */
+  getAnyPendingTileTargetCard(): CardInstance | null {
+    return this.pendingTileTargetCard ?? this.pendingElevationTargetCard;
+  }
+
   /**
    * Handle a card played from CardHandComponent.
    *
@@ -226,6 +264,7 @@ export class CardPlayService {
     // Card play locked to COMBAT phase.
     const phase = this.gameStateService.getState().phase;
     if (phase !== GamePhase.COMBAT) {
+      this.callbacks?.onCardPlayBlocked?.('Cards can only be played during combat.');
       return;
     }
     // Clicking the pending tower card again cancels placement
@@ -284,11 +323,20 @@ export class CardPlayService {
     }
 
     // Block other card plays while a tower card is awaiting placement
-    if (this.pendingTowerCard) return;
+    if (this.pendingTowerCard) {
+      this.callbacks?.onCardPlayBlocked?.('Place or cancel the pending tower card first.');
+      return;
+    }
     // Block other card plays while a tile-target card is awaiting a tile click
-    if (this.pendingTileTargetCard) return;
+    if (this.pendingTileTargetCard) {
+      this.callbacks?.onCardPlayBlocked?.('Click a tile to apply the pending card first.');
+      return;
+    }
     // Block other card plays while an elevation-target card is awaiting a tile click
-    if (this.pendingElevationTargetCard) return;
+    if (this.pendingElevationTargetCard) {
+      this.callbacks?.onCardPlayBlocked?.('Click a tile to apply the pending card first.');
+      return;
+    }
 
     if (effect.type === 'tower') {
       // Cancel any existing pending tower card first (defensive)
@@ -308,13 +356,46 @@ export class CardPlayService {
     if (effect.type === 'spell') {
       const spellEffect = effect as SpellCardEffect;
       if (spellEffect.spellId === 'salvage') {
-        if (this.towerCombatService.getPlacedTowers().size === 0) return;
+        if (this.towerCombatService.getPlacedTowers().size === 0) {
+          this.callbacks?.onCardPlayBlocked?.('No towers to salvage.');
+          return;
+        }
       } else if (spellEffect.spellId === 'fortify') {
         const towers = Array.from(this.towerCombatService.getPlacedTowers().values());
         // At least one tower must be eligible for an L1→L2 upgrade. We don't gate
         // on the upgraded count (effect.value) — partial fulfilment is allowed
-        // (Sprint 5: upgraded variant upgrades up to 2 but tolerates fewer eligible).
-        if (!towers.some(t => t.level < MAX_TOWER_LEVEL - 1)) return;
+        // (upgraded variant upgrades up to 2 but tolerates fewer eligible).
+        if (!towers.some(t => t.level < MAX_TOWER_LEVEL - 1)) {
+          this.callbacks?.onCardPlayBlocked?.('All towers are already at max level.');
+          return;
+        }
+      } else if (spellEffect.spellId === 'detonate') {
+        // Pre-validate: at least one non-dying burning enemy must exist.
+        const hasBurning = Array.from(this.enemyService.getEnemies().values())
+          .some(e => !e.dying && this.statusEffectService.hasEffect(e.id, StatusEffectType.BURN));
+        if (!hasBurning) {
+          this.callbacks?.onCardPlayBlocked?.('No burning enemies.');
+          return;
+        }
+      } else if (spellEffect.spellId === 'epidemic') {
+        // Pre-validate: at least one non-dying poisoned enemy must exist.
+        const hasPoisoned = Array.from(this.enemyService.getEnemies().values())
+          .some(e => !e.dying && this.statusEffectService.hasEffect(e.id, StatusEffectType.POISON));
+        if (!hasPoisoned) {
+          this.callbacks?.onCardPlayBlocked?.('No poisoned enemies.');
+          return;
+        }
+      }
+    }
+
+    // Pre-validate utility cards that require a minimum tower count.
+    if (effect.type === 'utility') {
+      const utilityEffect = effect as UtilityCardEffect;
+      if (utilityEffect.utilityId === 'bridge_towers') {
+        if (this.towerCombatService.getPlacedTowers().size < 2) {
+          this.callbacks?.onCardPlayBlocked?.('Need at least 2 towers to bridge.');
+          return;
+        }
       }
     }
 
@@ -352,6 +433,12 @@ export class CardPlayService {
           break;
         // 'tower', 'terraform_target', 'elevation_target' return early above.
       }
+      // Confirm the play — non-tower cards (modifiers especially) change nothing
+      // on the board, so without this the player gets no feedback at all.
+      const effectSummary = card.upgraded && def.upgradedDescription
+        ? def.upgradedDescription
+        : def.description;
+      this.callbacks?.onNonTowerCardPlayed?.(def.name, effectSummary);
     } catch (err) {
       console.error('Card effect threw — rolling back play:', err);
       this.deckService.undoPlay(cardInstanceId, energyCost);
diff --git a/src/app/game/game-board/services/combat-loop.service.spec.ts b/src/app/game/game-board/services/combat-loop.service.spec.ts
index d7fdcfa5..576c5682 100644
--- a/src/app/game/game-board/services/combat-loop.service.spec.ts
+++ b/src/app/game/game-board/services/combat-loop.service.spec.ts
@@ -1558,4 +1558,226 @@ describe('CombatLoopService', () => {
       expect(popupSpy.flushOne).toHaveBeenCalledWith('e-kill', scene);
     });
   });
+
+  // ─── feedback toasts — card LeakBlock ────────────────────────────────────────
+
+  describe('feedback toasts — card LeakBlock', () => {
+    let cardEffectSpy: jasmine.SpyObj<CardEffectService>;
+
+    beforeEach(() => {
+      cardEffectSpy = TestBed.inject(CardEffectService) as jasmine.SpyObj<CardEffectService>;
+    });
+
+    it('shows INFO "Leak Blocked" toast when tryConsumeLeakBlock() absorbs a leak', () => {
+      cardEffectSpy.tryConsumeLeakBlock.and.returnValue(true);
+      const enemy = makeEnemy({ id: 'e1' });
+      enemySpy.getEnemies.and.returnValue(new Map([['e1', enemy]]));
+      enemySpy.stepEnemiesOneTurn.and.returnValue(['e1']);
+
+      service.resolveTurn(scene);
+
+      expect(notificationSpy.show).toHaveBeenCalledWith(
+        NotificationType.INFO,
+        'Leak Blocked',
+        'A card effect blocked a leak.',
+      );
+    });
+
+    it('does NOT show "Leak Blocked" toast when tryConsumeLeakBlock() returns false', () => {
+      cardEffectSpy.tryConsumeLeakBlock.and.returnValue(false);
+      const enemy = makeEnemy({ id: 'e1' });
+      enemySpy.getEnemies.and.returnValue(new Map([['e1', enemy]]));
+      enemySpy.stepEnemiesOneTurn.and.returnValue(['e1']);
+
+      service.resolveTurn(scene);
+
+      const leakBlockCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'Leak Blocked');
+      expect(leakBlockCalls.length).toBe(0);
+    });
+
+    it('shows one "Leak Blocked" toast per absorbed leak when multiple enemies exit', () => {
+      let charges = 2;
+      cardEffectSpy.tryConsumeLeakBlock.and.callFake(() => {
+        if (charges > 0) { charges--; return true; }
+        return false;
+      });
+      const e1 = makeEnemy({ id: 'e1' });
+      const e2 = makeEnemy({ id: 'e2' });
+      const e3 = makeEnemy({ id: 'e3', leakDamage: 1 });
+      enemySpy.getEnemies.and.callFake(() => new Map([['e1', e1], ['e2', e2], ['e3', e3]]));
+      enemySpy.stepEnemiesOneTurn.and.returnValue(['e1', 'e2', 'e3']);
+
+      service.resolveTurn(scene);
+
+      const leakBlockCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'Leak Blocked');
+      expect(leakBlockCalls.length).toBe(2);
+    });
+  });
+
+  // ─── feedback toasts — OROGENY relic auto-raise ──────────────────────────────
+
+  describe('feedback toasts — OROGENY relic auto-raise', () => {
+    let relicSpy: jasmine.SpyObj<RelicService>;
+
+    beforeEach(() => {
+      relicSpy = TestBed.inject(RelicService) as jasmine.SpyObj<RelicService>;
+    });
+
+    it('shows INFO "Orogeny" toast when the relic triggers and a tower tile is raised', () => {
+      relicSpy.incrementOrogenyCounter.and.returnValue(1);
+      relicSpy.isOrogenyTrigger.and.returnValue(true);
+
+      // The factory's TowerCombatService spy omits getPlacedTowers and
+      // ElevationService spy omits getElevation/raise. Inject both at the
+      // service-instance level so this test is self-contained.
+      const localCombat = jasmine.createSpyObj<TowerCombatService>('TowerCombatService', [
+        'fireTurn', 'tickMortarZonesForTurn', 'drainAudioEvents', 'getPlacedTowers',
+      ]);
+      localCombat.fireTurn.and.returnValue({ killed: [], fired: [], hitCount: 0, damageDealt: 0 });
+      localCombat.tickMortarZonesForTurn.and.returnValue({ kills: [], damageDealt: 0 });
+      localCombat.drainAudioEvents.and.returnValue([]);
+      localCombat.getPlacedTowers.and.returnValue(
+        new Map([['t1', { row: 2, col: 3 }]]) as ReturnType<TowerCombatService['getPlacedTowers']>,
+      );
+
+      const localElev = jasmine.createSpyObj<ElevationService>('ElevationService', [
+        'tickTurn', 'getElevation', 'raise',
+      ]);
+      localElev.getElevation.and.returnValue(0);
+
+      // Replace the injected services directly on the service instance.
+      (service as unknown as Record<string, unknown>)['towerCombatService'] = localCombat;
+      (service as unknown as Record<string, unknown>)['elevationService'] = localElev;
+
+      service.resolveTurn(scene);
+
+      expect(notificationSpy.show).toHaveBeenCalledWith(
+        NotificationType.INFO,
+        'Orogeny',
+        'A tower tile was raised.',
+      );
+    });
+
+    it('does NOT show "Orogeny" toast when isOrogenyTrigger returns false', () => {
+      relicSpy.incrementOrogenyCounter.and.returnValue(1);
+      relicSpy.isOrogenyTrigger.and.returnValue(false);
+
+      service.resolveTurn(scene);
+
+      const ogenyCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'Orogeny');
+      expect(ogenyCalls.length).toBe(0);
+    });
+
+    it('does NOT show "Orogeny" toast when trigger fires but no towers are placed', () => {
+      relicSpy.incrementOrogenyCounter.and.returnValue(1);
+      relicSpy.isOrogenyTrigger.and.returnValue(true);
+
+      const localCombat = jasmine.createSpyObj<TowerCombatService>('TowerCombatService', [
+        'fireTurn', 'tickMortarZonesForTurn', 'drainAudioEvents', 'getPlacedTowers',
+      ]);
+      localCombat.fireTurn.and.returnValue({ killed: [], fired: [], hitCount: 0, damageDealt: 0 });
+      localCombat.tickMortarZonesForTurn.and.returnValue({ kills: [], damageDealt: 0 });
+      localCombat.drainAudioEvents.and.returnValue([]);
+      localCombat.getPlacedTowers.and.returnValue(
+        new Map() as ReturnType<TowerCombatService['getPlacedTowers']>,
+      );
+      (service as unknown as Record<string, unknown>)['towerCombatService'] = localCombat;
+
+      service.resolveTurn(scene);
+
+      const ogenyCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'Orogeny');
+      expect(ogenyCalls.length).toBe(0);
+    });
+  });
+
+  // ─── feedback toasts — NOVA_SOVEREIGN enrage ─────────────────────────────────
+
+  describe('feedback toasts — NOVA_SOVEREIGN enrage', () => {
+    function makeNovaSovereign(isEnraged: boolean): Enemy {
+      return {
+        id: 'nova1',
+        type: EnemyType.NOVA_SOVEREIGN,
+        dying: false,
+        isEnraged,
+        health: 50,
+        maxHealth: 100,
+        position: { x: 0, y: 0, z: 0 },
+      } as unknown as Enemy;
+    }
+
+    it('shows INFO "NOVA SOVEREIGN ENRAGED" toast on the turn isEnraged flips to true', () => {
+      const nova = makeNovaSovereign(false);
+      enemySpy.getEnemies.and.returnValue(new Map([['nova1', nova]]));
+      enemySpy.tickNovaSovereignEffects.and.callFake(() => {
+        nova.isEnraged = true;
+      });
+
+      service.resolveTurn(scene);
+
+      expect(notificationSpy.show).toHaveBeenCalledWith(
+        NotificationType.INFO,
+        'NOVA SOVEREIGN ENRAGED',
+        'The boss is moving faster.',
+      );
+    });
+
+    it('triggers screen shake on the turn NOVA_SOVEREIGN enrages', () => {
+      const nova = makeNovaSovereign(false);
+      enemySpy.getEnemies.and.returnValue(new Map([['nova1', nova]]));
+      enemySpy.tickNovaSovereignEffects.and.callFake(() => {
+        nova.isEnraged = true;
+      });
+
+      service.resolveTurn(scene);
+
+      expect(screenShakeSpy.trigger).toHaveBeenCalledWith(
+        SCREEN_SHAKE_CONFIG.bossHitIntensity,
+        SCREEN_SHAKE_CONFIG.bossHitDuration,
+      );
+    });
+
+    it('does NOT show enrage toast when NOVA_SOVEREIGN was already enraged before the tick', () => {
+      const nova = makeNovaSovereign(true);
+      enemySpy.getEnemies.and.returnValue(new Map([['nova1', nova]]));
+
+      service.resolveTurn(scene);
+
+      const engageCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'NOVA SOVEREIGN ENRAGED');
+      expect(engageCalls.length).toBe(0);
+    });
+
+    it('does NOT show enrage toast when no NOVA_SOVEREIGN is present', () => {
+      enemySpy.getEnemies.and.returnValue(new Map());
+
+      service.resolveTurn(scene);
+
+      const engageCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'NOVA SOVEREIGN ENRAGED');
+      expect(engageCalls.length).toBe(0);
+    });
+
+    it('does NOT fire enrage toast on subsequent turns after enrage is already set', () => {
+      const nova = makeNovaSovereign(false);
+      enemySpy.getEnemies.and.returnValue(new Map([['nova1', nova]]));
+      enemySpy.tickNovaSovereignEffects.and.callFake(() => {
+        nova.isEnraged = true;
+      });
+
+      // Turn 1 — enrage fires
+      service.resolveTurn(scene);
+      notificationSpy.show.calls.reset();
+
+      // Turn 2 — already enraged, no toast
+      service.resolveTurn(scene);
+
+      const engageCalls = notificationSpy.show.calls.allArgs()
+        .filter(args => args[1] === 'NOVA SOVEREIGN ENRAGED');
+      expect(engageCalls.length).toBe(0);
+    });
+  });
 });
diff --git a/src/app/game/game-board/services/combat-loop.service.ts b/src/app/game/game-board/services/combat-loop.service.ts
index 575cf783..ed68b378 100644
--- a/src/app/game/game-board/services/combat-loop.service.ts
+++ b/src/app/game/game-board/services/combat-loop.service.ts
@@ -14,7 +14,7 @@ import { RunService } from '../../../run/services/run.service';
 import { MODIFIER_STAT } from '../../../run/constants/modifier-stat.constants';
 
 import { GamePhase } from '../models/game-state.model';
-import { ENEMY_STATS, EnemyType } from '../models/enemy.model';
+import { Enemy, ENEMY_STATS, EnemyType } from '../models/enemy.model';
 import { ENEMY_VISUAL_CONFIG } from '../constants/ui.constants';
 import { resolveEnemyColor } from '../constants/colorblind.constants';
 import { SettingsService } from '../../../core/services/settings.service';
@@ -249,7 +249,21 @@ export class CombatLoopService {
     // AFTER all same-turn DoT (mortar zone tick + status effects) so the
     // regenerated shield cannot absorb damage dealt this turn. Resolution order:
     //   tower fire → mortar zone tick → status DoT tick → NOVA regen
+    const novaBefore = this.findNovaSovereign();
+    const wasEnragedBefore = novaBefore?.isEnraged ?? false;
     this.enemyService.tickNovaSovereignEffects();
+    const novaAfter = this.findNovaSovereign();
+    if (!wasEnragedBefore && (novaAfter?.isEnraged ?? false)) {
+      this.notificationService.show(
+        NotificationType.INFO,
+        'NOVA SOVEREIGN ENRAGED',
+        'The boss is moving faster.',
+      );
+      this.screenShakeService.trigger(
+        SCREEN_SHAKE_CONFIG.bossHitIntensity,
+        SCREEN_SHAKE_CONFIG.bossHitDuration,
+      );
+    }
 
     // 6. Process leaks — enemies that reached the exit cost lives
     for (const enemyId of reachedExit) {
@@ -263,6 +277,11 @@ export class CombatLoopService {
         continue;
       }
       if (this.cardEffectService.tryConsumeLeakBlock()) {
+        this.notificationService.show(
+          NotificationType.INFO,
+          'Leak Blocked',
+          'A card effect blocked a leak.',
+        );
         this.enemyService.removeEnemy(enemyId, scene);
         continue;
       }
@@ -496,6 +515,19 @@ export class CombatLoopService {
     this.runEventBus.emit(RunEventType.ENEMY_KILLED, { enemyType: enemy.type, value: enemy.value });
   }
 
+  /**
+   * Return the first living NOVA_SOVEREIGN enemy, or undefined if none is present.
+   * Used to detect the enrage flip: called before and after tickNovaSovereignEffects().
+   */
+  private findNovaSovereign(): Enemy | undefined {
+    for (const enemy of this.enemyService.getEnemies().values()) {
+      if (enemy.type === EnemyType.NOVA_SOVEREIGN && !enemy.dying) {
+        return enemy;
+      }
+    }
+    return undefined;
+  }
+
   /**
    * Sprint 36 OROGENY — pick a random tower and permanently raise its tile by +1.
    * No-op when: no towers exist, all tower tiles are at MAX_ELEVATION, or
@@ -525,5 +557,10 @@ export class CombatLoopService {
       this.turnNumber,
       'relic',
     );
+    this.notificationService.show(
+      NotificationType.INFO,
+      'Orogeny',
+      'A tower tile was raised.',
+    );
   }
 }
diff --git a/src/app/landing/landing.component.scss b/src/app/landing/landing.component.scss
index 84addecb..62365b98 100644
--- a/src/app/landing/landing.component.scss
+++ b/src/app/landing/landing.component.scss
@@ -2,6 +2,14 @@
 // All durations/sizes are named here — no magic numbers per project conventions.
 // CSS :root custom properties for values needed in keyframes (non-SCSS context).
 
+// The component host must be a full-width block: Angular host elements default
+// to display:inline, which lets the container be sized/positioned by content
+// rather than filling the viewport — that offsets the centred content.
+:host {
+  display: block;
+  width: 100%;
+}
+
 :root {
   // Backdrop layers
   --ls-sky-top: #000308;
@@ -66,14 +74,14 @@
 // ── Layout ───────────────────────────────────────────────────────────────────
 
 .landing-container {
-  display: grid;
-  grid-template-rows: 1fr [content] auto 1fr [version] auto;
-  grid-template-columns: 1fr [content] minmax(280px, min(520px, 88vw)) 1fr;
-  grid-template-areas:
-    ".       .       ."
-    ".       content ."
-    ".       .       ."
-    "version version version";
+  // Flex-center the content on both axes so the title + menu sit dead-centre.
+  // The version string is an absolutely-positioned footer (below) so it does
+  // not pull the content block upward.
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
   min-height: 100vh;
   background-color: var(--bg-color);
   color: var(--text-color);
@@ -222,8 +230,15 @@
 // ── Foreground content ────────────────────────────────────────────────────────
 
 .landing-content {
-  grid-area: content;
+  // Constrain the menu column to the prior content width; the wide wordmark
+  // overflows this box symmetrically (centred text) so it reads full-width.
+  width: min(520px, 88vw);
   display: grid;
+  // Pin the single column to the box width. Without an explicit column the
+  // implicit `auto` track grows to the wordmark's intrinsic width and anchors
+  // it at the box's left edge, shoving every row to the right. minmax(0, 1fr)
+  // keeps the column at the box width so justify-items:center truly centres.
+  grid-template-columns: minmax(0, 1fr);
   grid-template-rows: [title] auto [actions] auto [ascension] auto;
   justify-items: center;
   gap: var(--spacing-lg);
@@ -542,15 +557,12 @@
 // ── Version badge ─────────────────────────────────────────────────────────────
 
 .landing-version {
-  grid-area: version;
-  justify-self: end;
-  align-self: end;
-  padding-right: var(--spacing-md);
-  padding-bottom: var(--spacing-md);
+  position: absolute;
+  bottom: var(--spacing-md);
+  right: var(--spacing-md);
   font-size: var(--font-size-xs);
   color: var(--theme-purple-mid);
   opacity: 0.5;
-  position: relative;
   z-index: 1;
 }
 
diff --git a/src/app/run/components/event-screen/event-screen.component.html b/src/app/run/components/event-screen/event-screen.component.html
index b05b72b8..298d421d 100644
--- a/src/app/run/components/event-screen/event-screen.component.html
+++ b/src/app/run/components/event-screen/event-screen.component.html
@@ -49,48 +49,68 @@ <h2 class="event-title">{{ event.title }}</h2>
     <p class="event-outcome__description">{{ currentOutcome.description }}</p>
 
     <div class="event-outcome__deltas">
-      <!-- Gold delta -->
+      <!-- Gold delta (uses resolved gamble value when applicable) -->
       <span
         class="event-outcome__delta event-outcome__delta--gold"
-        *ngIf="currentOutcome.goldDelta !== 0"
-        [class.positive]="currentOutcome.goldDelta > 0"
-        [class.negative]="currentOutcome.goldDelta < 0"
-        [attr.aria-label]="(currentOutcome.goldDelta > 0 ? 'Gained' : 'Lost') + ' ' + (currentOutcome.goldDelta | number) + ' gold'"
+        *ngIf="displayedGoldDelta !== 0"
+        [class.positive]="displayedGoldDelta > 0"
+        [class.negative]="displayedGoldDelta < 0"
+        [attr.aria-label]="(displayedGoldDelta > 0 ? 'Gained' : 'Lost') + ' ' + (displayedGoldDelta | number) + ' gold'"
       >
         <app-icon name="coin" [size]="12"></app-icon>
-        {{ formatDelta(currentOutcome.goldDelta) }}g
+        {{ formatDelta(displayedGoldDelta) }}g
       </span>
 
-      <!-- Lives delta -->
+      <!-- Lives delta (uses resolved gamble value when applicable) -->
       <span
         class="event-outcome__delta event-outcome__delta--lives"
-        *ngIf="currentOutcome.livesDelta !== 0"
-        [class.positive]="currentOutcome.livesDelta > 0"
-        [class.negative]="currentOutcome.livesDelta < 0"
-        [attr.aria-label]="(currentOutcome.livesDelta > 0 ? 'Gained' : 'Lost') + ' ' + (currentOutcome.livesDelta | number) + ' ' + (currentOutcome.livesDelta === 1 || currentOutcome.livesDelta === -1 ? 'life' : 'lives')"
+        *ngIf="displayedLivesDelta !== 0"
+        [class.positive]="displayedLivesDelta > 0"
+        [class.negative]="displayedLivesDelta < 0"
+        [attr.aria-label]="(displayedLivesDelta > 0 ? 'Gained' : 'Lost') + ' ' + (displayedLivesDelta | number) + ' ' + (displayedLivesDelta === 1 || displayedLivesDelta === -1 ? 'life' : 'lives')"
       >
         <app-icon name="heart" [size]="12"></app-icon>
-        {{ formatDelta(currentOutcome.livesDelta) }}
+        {{ formatDelta(displayedLivesDelta) }}
       </span>
 
       <!-- Relic gained -->
       <span
         class="event-outcome__delta event-outcome__delta--relic positive"
         *ngIf="currentOutcome.relicId"
-        [attr.aria-label]="'Gained relic: ' + currentOutcome.relicId"
+        [attr.aria-label]="'Gained relic: ' + getRelicName(currentOutcome.relicId)"
       >
         <app-icon name="diamond" [size]="12"></app-icon>
-        Gained: {{ currentOutcome.relicId }}
+        Gained: {{ getRelicName(currentOutcome.relicId) }}
       </span>
 
       <!-- Relic removed -->
       <span
         class="event-outcome__delta event-outcome__delta--relic negative"
         *ngIf="currentOutcome.removeRelicId"
-        [attr.aria-label]="'Lost relic: ' + currentOutcome.removeRelicId"
+        [attr.aria-label]="'Lost relic: ' + getRelicName(currentOutcome.removeRelicId)"
       >
         <app-icon name="diamond" [size]="12"></app-icon>
-        Lost: {{ currentOutcome.removeRelicId }}
+        Lost: {{ getRelicName(currentOutcome.removeRelicId) }}
+      </span>
+
+      <!-- Item reward -->
+      <span
+        class="event-outcome__delta event-outcome__delta--item positive"
+        *ngIf="currentOutcome.itemReward"
+        [attr.aria-label]="'Gained item: ' + getItemName(currentOutcome.itemReward)"
+      >
+        <app-icon name="diamond" [size]="12"></app-icon>
+        Gained: {{ getItemName(currentOutcome.itemReward) }}
+      </span>
+
+      <!-- Card removed from deck -->
+      <span
+        class="event-outcome__delta event-outcome__delta--card negative"
+        *ngIf="currentOutcome.removeCard"
+        aria-label="A card was removed from your deck"
+      >
+        <app-icon name="card" [size]="12"></app-icon>
+        A card was removed from your deck
       </span>
     </div>
 
diff --git a/src/app/run/components/event-screen/event-screen.component.spec.ts b/src/app/run/components/event-screen/event-screen.component.spec.ts
index a7cd27d7..53de5c02 100644
--- a/src/app/run/components/event-screen/event-screen.component.spec.ts
+++ b/src/app/run/components/event-screen/event-screen.component.spec.ts
@@ -3,6 +3,7 @@ import { CommonModule } from '@angular/common';
 import { EventScreenComponent } from './event-screen.component';
 import { RunEvent, EventOutcome } from '../../models/encounter.model';
 import { RelicId } from '../../models/relic.model';
+import { ItemType } from '../../models/item.model';
 
 // ── Test helpers ─────────────────────────────────────────────────────────────
 
@@ -83,6 +84,33 @@ describe('EventScreenComponent', () => {
       component.makeChoice(1); // second call should be ignored
       expect(component.selectedChoice).toBe(0);
     });
+
+    it('does not emit previewGamble for non-gamble outcomes', () => {
+      const spy = jasmine.createSpy('previewGamble');
+      component.previewGamble.subscribe(spy);
+      component.makeChoice(0);
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('emits previewGamble with the choice index for gamble outcomes', () => {
+      component.event = makeEvent({
+        choices: [
+          {
+            label: 'Gamble',
+            description: 'Roll the dice.',
+            outcome: makeOutcome({
+              gamble: { winGoldDelta: 100, loseGoldDelta: -50, winChance: 0.5 },
+            }),
+          },
+          { label: 'Skip', description: 'Nothing.', outcome: makeOutcome() },
+        ],
+      });
+
+      const spy = jasmine.createSpy('previewGamble');
+      component.previewGamble.subscribe(spy);
+      component.makeChoice(0);
+      expect(spy).toHaveBeenCalledWith(0);
+    });
   });
 
   describe('confirmChoice()', () => {
@@ -122,6 +150,11 @@ describe('EventScreenComponent', () => {
       expect(component.getOutcomeClass(outcome)).toBe('positive');
     });
 
+    it('returns "positive" when itemReward is set', () => {
+      const outcome = makeOutcome({ itemReward: ItemType.BOMB });
+      expect(component.getOutcomeClass(outcome)).toBe('positive');
+    });
+
     it('returns "negative" when goldDelta < 0', () => {
       const outcome = makeOutcome({ goldDelta: -30 });
       expect(component.getOutcomeClass(outcome)).toBe('negative');
@@ -137,6 +170,11 @@ describe('EventScreenComponent', () => {
       expect(component.getOutcomeClass(outcome)).toBe('negative');
     });
 
+    it('returns "negative" when removeCard is true', () => {
+      const outcome = makeOutcome({ removeCard: true });
+      expect(component.getOutcomeClass(outcome)).toBe('negative');
+    });
+
     it('returns "neutral" when all deltas are zero and no relic', () => {
       const outcome = makeOutcome();
       expect(component.getOutcomeClass(outcome)).toBe('neutral');
@@ -180,4 +218,169 @@ describe('EventScreenComponent', () => {
       expect(component.currentOutcome!.relicId).toBe(RelicId.GOLD_MAGNET);
     });
   });
+
+  describe('getRelicName()', () => {
+    it('returns the human-readable name for a known relic id', () => {
+      expect(component.getRelicName(RelicId.QUICK_DRAW)).toBe('Quick Draw');
+    });
+
+    it('returns the human-readable name for IRON_HEART', () => {
+      expect(component.getRelicName(RelicId.IRON_HEART)).toBe('Iron Heart');
+    });
+
+    it('falls back to the raw id for an unknown relic id', () => {
+      expect(component.getRelicName('UNKNOWN_RELIC')).toBe('UNKNOWN_RELIC');
+    });
+  });
+
+  describe('getItemName()', () => {
+    it('returns the human-readable name for a known item type', () => {
+      expect(component.getItemName(ItemType.HEAL_POTION)).toBe('Heal Potion');
+    });
+
+    it('returns the human-readable name for BOMB', () => {
+      expect(component.getItemName(ItemType.BOMB)).toBe('Bomb');
+    });
+
+    it('falls back to the raw id for an unknown item type', () => {
+      expect(component.getItemName('UNKNOWN_ITEM')).toBe('UNKNOWN_ITEM');
+    });
+  });
+
+  describe('gamble outcome resolution', () => {
+    function makeGambleEvent(winChance: number): RunEvent {
+      return makeEvent({
+        choices: [
+          {
+            label: 'Gamble',
+            description: 'Roll the dice.',
+            outcome: makeOutcome({
+              goldDelta: 0,
+              gamble: {
+                winGoldDelta: 100,
+                loseGoldDelta: -50,
+                winChance,
+              },
+            }),
+          },
+          { label: 'Skip', description: 'Nothing.', outcome: makeOutcome() },
+        ],
+      });
+    }
+
+    it('displayedGoldDelta uses resolvedGamble.goldDelta when set (win)', () => {
+      component.event = makeGambleEvent(1);
+      component.resolvedGamble = { goldDelta: 100, livesDelta: 0 };
+      component.makeChoice(0);
+      expect(component.displayedGoldDelta).toBe(100);
+    });
+
+    it('displayedGoldDelta uses resolvedGamble.goldDelta when set (loss)', () => {
+      component.event = makeGambleEvent(0);
+      component.resolvedGamble = { goldDelta: -50, livesDelta: 0 };
+      component.makeChoice(0);
+      expect(component.displayedGoldDelta).toBe(-50);
+    });
+
+    it('displayedGoldDelta defaults to 0 when resolvedGamble is null (gamble outcome)', () => {
+      component.event = makeGambleEvent(0.5);
+      component.resolvedGamble = null;
+      component.makeChoice(0);
+      expect(component.displayedGoldDelta).toBe(0);
+    });
+
+    it('displayedGoldDelta uses static goldDelta when no gamble is present', () => {
+      component.makeChoice(0); // goldDelta: 40 from makeEvent defaults
+      expect(component.displayedGoldDelta).toBe(40);
+    });
+
+    it('displayedLivesDelta includes resolvedGamble.livesDelta for gamble outcomes', () => {
+      component.event = makeEvent({
+        choices: [
+          {
+            label: 'Wager lives',
+            description: 'Risk it.',
+            outcome: makeOutcome({
+              livesDelta: 0,
+              gamble: {
+                winGoldDelta: 0,
+                loseGoldDelta: 0,
+                winChance: 0.5,
+                winLivesDelta: 5,
+                loseLivesDelta: -3,
+              },
+            }),
+          },
+          { label: 'Skip', description: 'Nothing.', outcome: makeOutcome() },
+        ],
+      });
+      component.resolvedGamble = { goldDelta: 0, livesDelta: 5 };
+      component.makeChoice(0);
+      expect(component.displayedLivesDelta).toBe(5);
+    });
+
+    it('displayedLivesDelta uses loss lives delta from resolvedGamble', () => {
+      component.event = makeEvent({
+        choices: [
+          {
+            label: 'Wager lives',
+            description: 'Risk it.',
+            outcome: makeOutcome({
+              livesDelta: 0,
+              gamble: {
+                winGoldDelta: 0,
+                loseGoldDelta: 0,
+                winChance: 0.5,
+                winLivesDelta: 5,
+                loseLivesDelta: -3,
+              },
+            }),
+          },
+          { label: 'Skip', description: 'Nothing.', outcome: makeOutcome() },
+        ],
+      });
+      component.resolvedGamble = { goldDelta: 0, livesDelta: -3 };
+      component.makeChoice(0);
+      expect(component.displayedLivesDelta).toBe(-3);
+    });
+
+    it('displayedLivesDelta sums base livesDelta with resolvedGamble.livesDelta', () => {
+      component.event = makeEvent({
+        choices: [
+          {
+            label: 'Wager',
+            description: 'Risk it.',
+            outcome: makeOutcome({
+              livesDelta: -1,
+              gamble: {
+                winGoldDelta: 0,
+                loseGoldDelta: 0,
+                winChance: 0.5,
+                winLivesDelta: 3,
+              },
+            }),
+          },
+          { label: 'Skip', description: 'Nothing.', outcome: makeOutcome() },
+        ],
+      });
+      component.resolvedGamble = { goldDelta: 0, livesDelta: 3 };
+      component.makeChoice(0);
+      // base -1 + win delta +3 = +2
+      expect(component.displayedLivesDelta).toBe(2);
+    });
+
+    it('getOutcomeClass returns "positive" when resolvedGamble shows a win', () => {
+      component.event = makeGambleEvent(1);
+      component.resolvedGamble = { goldDelta: 100, livesDelta: 0 };
+      component.makeChoice(0);
+      expect(component.getOutcomeClass(component.currentOutcome!)).toBe('positive');
+    });
+
+    it('getOutcomeClass returns "negative" when resolvedGamble shows a loss', () => {
+      component.event = makeGambleEvent(0);
+      component.resolvedGamble = { goldDelta: -50, livesDelta: 0 };
+      component.makeChoice(0);
+      expect(component.getOutcomeClass(component.currentOutcome!)).toBe('negative');
+    });
+  });
 });
diff --git a/src/app/run/components/event-screen/event-screen.component.ts b/src/app/run/components/event-screen/event-screen.component.ts
index fddc30e0..d270ea9d 100644
--- a/src/app/run/components/event-screen/event-screen.component.ts
+++ b/src/app/run/components/event-screen/event-screen.component.ts
@@ -1,5 +1,7 @@
 import { Component, Input, Output, EventEmitter } from '@angular/core';
 import { RunEvent, EventOutcome } from '../../models/encounter.model';
+import { RELIC_DEFINITIONS } from '../../models/relic.model';
+import { ITEM_DEFINITIONS } from '../../models/item.model';
 
 @Component({
   selector: 'app-event-screen',
@@ -8,6 +10,17 @@ import { RunEvent, EventOutcome } from '../../models/encounter.model';
 })
 export class EventScreenComponent {
   @Input() event!: RunEvent;
+
+  /**
+   * Seeded gamble result supplied by the parent (RunComponent) after it calls
+   * RunService.previewEventGamble(). Drives displayedGoldDelta and
+   * displayedLivesDelta so the outcome panel matches what resolveEvent() applies.
+   */
+  @Input() resolvedGamble: { goldDelta: number; livesDelta: number } | null = null;
+
+  /** Emitted when the player picks a choice that has a gamble field, before confirming. */
+  @Output() previewGamble = new EventEmitter<number>();
+
   @Output() choiceMade = new EventEmitter<number>();
 
   selectedChoice: number | null = null;
@@ -18,10 +31,32 @@ export class EventScreenComponent {
     return this.event.choices[this.selectedChoice]?.outcome ?? null;
   }
 
+  /** Displayed gold delta — uses seeded gamble result when outcome is a gamble. */
+  get displayedGoldDelta(): number {
+    if (this.currentOutcome?.gamble) {
+      return this.resolvedGamble?.goldDelta ?? 0;
+    }
+    return this.currentOutcome?.goldDelta ?? 0;
+  }
+
+  /** Displayed lives delta — base livesDelta plus seeded gamble lives delta when applicable. */
+  get displayedLivesDelta(): number {
+    const base = this.currentOutcome?.livesDelta ?? 0;
+    if (this.currentOutcome?.gamble) {
+      return base + (this.resolvedGamble?.livesDelta ?? 0);
+    }
+    return base;
+  }
+
   makeChoice(index: number): void {
     if (this.showOutcome) return;
     this.selectedChoice = index;
     this.showOutcome = true;
+
+    const outcome = this.event.choices[index]?.outcome;
+    if (outcome?.gamble) {
+      this.previewGamble.emit(index);
+    }
   }
 
   confirmChoice(): void {
@@ -31,12 +66,26 @@ export class EventScreenComponent {
   }
 
   getOutcomeClass(outcome: EventOutcome): string {
-    if (outcome.livesDelta > 0 || outcome.goldDelta > 0 || outcome.relicId) return 'positive';
-    if (outcome.livesDelta < 0 || outcome.goldDelta < 0 || outcome.removeRelicId) return 'negative';
+    const effectiveGold = outcome.gamble ? (this.resolvedGamble?.goldDelta ?? 0) : outcome.goldDelta;
+    const effectiveLives = outcome.livesDelta + (outcome.gamble ? (this.resolvedGamble?.livesDelta ?? 0) : 0);
+    if (effectiveLives > 0 || effectiveGold > 0 || outcome.relicId || outcome.itemReward) {
+      return 'positive';
+    }
+    if (effectiveLives < 0 || effectiveGold < 0 || outcome.removeRelicId || outcome.removeCard) {
+      return 'negative';
+    }
     return 'neutral';
   }
 
   formatDelta(value: number): string {
     return value >= 0 ? `+${value}` : `${value}`;
   }
+
+  getRelicName(relicId: string): string {
+    return RELIC_DEFINITIONS[relicId as keyof typeof RELIC_DEFINITIONS]?.name ?? relicId;
+  }
+
+  getItemName(itemType: string): string {
+    return ITEM_DEFINITIONS[itemType as keyof typeof ITEM_DEFINITIONS]?.name ?? itemType;
+  }
 }
diff --git a/src/app/run/components/rest-screen/rest-screen.component.html b/src/app/run/components/rest-screen/rest-screen.component.html
index dda4c5b2..2d52d246 100644
--- a/src/app/run/components/rest-screen/rest-screen.component.html
+++ b/src/app/run/components/rest-screen/rest-screen.component.html
@@ -1,33 +1,34 @@
 <div class="rest-screen"
      [class.rest-screen--upgrading]="activeAction === 'upgrade'"
+     [class.rest-screen--confirmed]="activeAction === 'confirmed'"
      role="main"
      aria-label="Rest site">
 
   <!-- Bonfire ambiance: ambient glow, swaying flame tongue, rising embers -->
-  <!-- Hidden in upgrade mode — the hearth glow bleeds through the card grid -->
-  <div class="rest-hearth" aria-hidden="true" *ngIf="activeAction !== 'upgrade'">
+  <!-- Hidden in upgrade/confirmation mode — the hearth glow bleeds through the card grid -->
+  <div class="rest-hearth" aria-hidden="true" *ngIf="activeAction === 'none'">
     <span class="rest-hearth__glow"></span>
     <span class="rest-hearth__flame"><span class="rest-hearth__flame-inner"></span></span>
     <span class="rest-hearth__embers"></span>
   </div>
 
-  <!-- Rest icon — hidden in upgrade mode to free vertical space for the picker -->
-  <div class="rest-icon" aria-hidden="true" *ngIf="activeAction !== 'upgrade'"><app-icon name="moon" [size]="32"></app-icon></div>
+  <!-- Rest icon — hidden in upgrade/confirmation mode to free vertical space -->
+  <div class="rest-icon" aria-hidden="true" *ngIf="activeAction === 'none'"><app-icon name="moon" [size]="32"></app-icon></div>
 
-  <!-- Title — hidden in upgrade mode -->
-  <h2 class="rest-title" *ngIf="activeAction !== 'upgrade'">Rest Site</h2>
-  <p class="rest-subtitle" *ngIf="activeAction !== 'upgrade'">Take a moment to recover or upgrade a card.</p>
+  <!-- Title — hidden in upgrade/confirmation mode -->
+  <h2 class="rest-title" *ngIf="activeAction === 'none'">Rest Site</h2>
+  <p class="rest-subtitle" *ngIf="activeAction === 'none'">Take a moment to recover or upgrade a card.</p>
 
-  <!-- Lives display — hidden in upgrade mode (irrelevant to the upgrade decision) -->
+  <!-- Lives display — hidden in upgrade/confirmation mode (irrelevant to the upgrade decision) -->
   <div class="rest-lives"
-       *ngIf="activeAction !== 'upgrade'"
+       *ngIf="activeAction === 'none'"
        [attr.aria-label]="'Current lives: ' + currentLives + ' of ' + maxLives">
     <span class="rest-lives__heart" aria-hidden="true"><app-icon name="heart" [size]="16"></app-icon></span>
     <span class="rest-lives__value">{{ currentLives }} / {{ maxLives }}</span>
   </div>
 
   <!-- Heal preview -->
-  <div class="rest-heal-preview" *ngIf="!atFullHealth && activeAction !== 'upgrade'">
+  <div class="rest-heal-preview" *ngIf="!atFullHealth && activeAction === 'none'">
     <span class="rest-heal-preview__amount" [attr.aria-label]="'Healing ' + actualHeal + ' lives'">
       +{{ actualHeal }} lives
     </span>
@@ -35,7 +36,7 @@ <h2 class="rest-title" *ngIf="activeAction !== 'upgrade'">Rest Site</h2>
     <span class="rest-heal-preview__result">{{ livesAfterHeal }} / {{ maxLives }}</span>
   </div>
 
-  <p class="rest-full-notice" *ngIf="atFullHealth && activeAction !== 'upgrade'" aria-live="polite">
+  <p class="rest-full-notice" *ngIf="atFullHealth && activeAction === 'none'" aria-live="polite">
     You are already at full health.
   </p>
 
@@ -71,8 +72,24 @@ <h3 class="rest-upgrade-title">Select a card to upgrade</h3>
     </button>
   </div>
 
-  <!-- Main actions (hidden while selecting upgrade) -->
-  <div class="rest-actions" *ngIf="activeAction !== 'upgrade'">
+  <!-- Upgrade confirmation — shown after a card is upgraded, before returning to the map -->
+  <div class="rest-upgrade-confirmation" *ngIf="activeAction === 'confirmed'" role="region" aria-live="polite" aria-label="Card upgrade confirmation">
+    <span class="rest-upgrade-confirmation__icon" aria-hidden="true">✓</span>
+    <p class="rest-upgrade-confirmation__message">
+      Upgraded <strong>{{ lastUpgradedCardName }}</strong>.
+    </p>
+    <button
+      class="run-btn run-btn--primary rest-btn"
+      type="button"
+      (click)="continueAfterUpgrade()"
+      aria-label="Continue to the node map"
+    >
+      Continue
+    </button>
+  </div>
+
+  <!-- Main actions (hidden while selecting upgrade or showing confirmation) -->
+  <div class="rest-actions" *ngIf="activeAction === 'none'">
     <button
       class="run-btn run-btn--primary rest-btn"
       type="button"
diff --git a/src/app/run/components/rest-screen/rest-screen.component.spec.ts b/src/app/run/components/rest-screen/rest-screen.component.spec.ts
index 059c87c0..9fb9c90e 100644
--- a/src/app/run/components/rest-screen/rest-screen.component.spec.ts
+++ b/src/app/run/components/rest-screen/rest-screen.component.spec.ts
@@ -150,10 +150,27 @@ describe('RestScreenComponent', () => {
       expect(emitted).toEqual(['c42']);
     });
 
-    it('selectCardToUpgrade() resets activeAction to "none"', () => {
+    it('selectCardToUpgrade() switches activeAction to "confirmed"', () => {
       component.showUpgradePanel();
       component.selectCardToUpgrade(makeCard('c0', CardId.GOLD_RUSH, false));
+      expect(component.activeAction).toBe('confirmed');
+    });
+
+    it('selectCardToUpgrade() captures the upgraded card name for the confirmation banner', () => {
+      component.selectCardToUpgrade(makeCard('c0', CardId.GOLD_RUSH, false));
+      expect(component.lastUpgradedCardName).toBe('Gold Rush');
+    });
+
+    it('continueAfterUpgrade() emits upgradeConfirmed and resets to "none"', () => {
+      let emitted = false;
+      component.upgradeConfirmed.subscribe(() => (emitted = true));
+
+      component.selectCardToUpgrade(makeCard('c0', CardId.GOLD_RUSH, false));
+      component.continueAfterUpgrade();
+
+      expect(emitted).toBeTrue();
       expect(component.activeAction).toBe('none');
+      expect(component.lastUpgradedCardName).toBeNull();
     });
 
     it('getUniqueUpgradableCards() deduplicates by CardId', () => {
diff --git a/src/app/run/components/rest-screen/rest-screen.component.ts b/src/app/run/components/rest-screen/rest-screen.component.ts
index ef01c6e9..4d7de615 100644
--- a/src/app/run/components/rest-screen/rest-screen.component.ts
+++ b/src/app/run/components/rest-screen/rest-screen.component.ts
@@ -17,9 +17,17 @@ export class RestScreenComponent {
   @Output() skipChosen = new EventEmitter<void>();
   /** Emits the instanceId of the card chosen for upgrade. */
   @Output() cardUpgraded = new EventEmitter<string>();
+  /** Emits when the player dismisses the upgrade confirmation and is ready to return to the map. */
+  @Output() upgradeConfirmed = new EventEmitter<void>();
 
   /** Tracks which sub-action the player is performing at the rest site. */
-  activeAction: 'none' | 'upgrade' = 'none';
+  activeAction: 'none' | 'upgrade' | 'confirmed' = 'none';
+
+  /**
+   * Name of the card that was just upgraded, captured for the confirmation banner.
+   * Set in selectCardToUpgrade(); cleared when the player leaves the rest site.
+   */
+  lastUpgradedCardName: string | null = null;
 
   get livesAfterHeal(): number {
     return Math.min(this.maxLives, this.currentLives + this.healAmount);
@@ -66,10 +74,18 @@ export class RestScreenComponent {
   }
 
   selectCardToUpgrade(card: CardInstance): void {
-    this.activeAction = 'none';
+    this.lastUpgradedCardName = getCardDefinition(card.cardId).name;
+    this.activeAction = 'confirmed';
     this.cardUpgraded.emit(card.instanceId);
   }
 
+  /** Player dismisses the upgrade confirmation and continues to the map. */
+  continueAfterUpgrade(): void {
+    this.lastUpgradedCardName = null;
+    this.activeAction = 'none';
+    this.upgradeConfirmed.emit();
+  }
+
   /** Returns unique upgrade candidates: at most one entry per CardId. */
   getUniqueUpgradableCards(): CardInstance[] {
     const seen = new Set<CardId>();
diff --git a/src/app/run/run.component.html b/src/app/run/run.component.html
index dd1c12e7..d91c7869 100644
--- a/src/app/run/run.component.html
+++ b/src/app/run/run.component.html
@@ -130,6 +130,7 @@ <h2 class="run-map-title">Choose Your Path</h2>
     (restChosen)="restHeal()"
     (skipChosen)="viewMode = 'map'"
     (cardUpgraded)="onCardUpgraded($event)"
+    (upgradeConfirmed)="onUpgradeConfirmed()"
   ></app-rest-screen>
 
   <!-- ── Shop Screen ─────────────────────────────────────── -->
@@ -152,6 +153,8 @@ <h2 class="run-map-title">Choose Your Path</h2>
   <app-event-screen
     *ngIf="viewMode === 'event' && currentEvent"
     [event]="currentEvent"
+    [resolvedGamble]="eventGambleResult"
+    (previewGamble)="onPreviewGamble($event)"
     (choiceMade)="completeEvent($event)"
   ></app-event-screen>
 
diff --git a/src/app/run/run.component.ts b/src/app/run/run.component.ts
index 97a3742d..4c03c613 100644
--- a/src/app/run/run.component.ts
+++ b/src/app/run/run.component.ts
@@ -280,15 +280,20 @@ export class RunComponent implements OnInit, OnDestroy {
     this.shopDeckSnapshot = this.runService.getDeckCards();
   }
 
-  /** Handle card upgrade selection from rest screen. */
+  /** Handle card upgrade selection from rest screen — applies the upgrade but stays on rest screen to show confirmation. */
   onCardUpgraded(instanceId: string): void {
     this.runService.upgradeCard(instanceId);
+  }
+
+  /** Handle the player dismissing the upgrade confirmation — now transition to the map. */
+  onUpgradeConfirmed(): void {
     this.viewMode = 'map';
   }
 
   /** Complete event choice. */
   completeEvent(choiceIndex: number): void {
     this.runService.resolveEvent(choiceIndex);
+    this.eventGambleResult = null;
     this.viewMode = 'map';
   }
 
@@ -319,6 +324,14 @@ export class RunComponent implements OnInit, OnDestroy {
     return this.runService.getCurrentEvent();
   }
 
+  /** Seeded gamble preview result — set synchronously when the player picks a gamble choice. */
+  eventGambleResult: { goldDelta: number; livesDelta: number } | null = null;
+
+  /** Called by EventScreenComponent when the player picks a gamble choice. Rolls once via seeded RNG. */
+  onPreviewGamble(index: number): void {
+    this.eventGambleResult = this.runService.previewEventGamble(index);
+  }
+
   /** Leave shop, return to map. */
   leaveShop(): void {
     this.runService.leaveShop();
diff --git a/src/app/run/services/run.service.spec.ts b/src/app/run/services/run.service.spec.ts
index 65fc84fc..c35404f4 100644
--- a/src/app/run/services/run.service.spec.ts
+++ b/src/app/run/services/run.service.spec.ts
@@ -836,6 +836,115 @@ describe('RunService', () => {
     }));
   });
 
+  // ── previewEventGamble ──────────────────────────────────────────
+
+  describe('previewEventGamble()', () => {
+    function makeGambleEvent(winChance: number) {
+      return {
+        id: 'gambling_den',
+        title: 'Gambling Den',
+        description: 'Test',
+        choices: [
+          {
+            label: 'Gamble',
+            description: 'Roll the dice.',
+            outcome: {
+              goldDelta: 0,
+              livesDelta: 0,
+              description: 'The cards are dealt.',
+              gamble: { winGoldDelta: 80, loseGoldDelta: -30, winChance },
+            },
+          },
+          {
+            label: 'Leave',
+            description: 'Walk away.',
+            outcome: { goldDelta: 0, livesDelta: 0, description: 'You leave.' },
+          },
+        ],
+      };
+    }
+
+    it('returns null for a non-gamble choice', fakeAsync(() => {
+      service.startNewRun();
+      service.selectNode('node_1_0');
+      svc.currentEvent = makeGambleEvent(0.5);
+
+      const result = service.previewEventGamble(1); // choice 1 has no gamble
+      expect(result).toBeNull();
+    }));
+
+    it('returns null when index is out of range', fakeAsync(() => {
+      service.startNewRun();
+      service.selectNode('node_1_0');
+      svc.currentEvent = makeGambleEvent(0.5);
+
+      expect(service.previewEventGamble(99)).toBeNull();
+    }));
+
+    it('returns null when there is no current event', fakeAsync(() => {
+      service.startNewRun();
+      service.selectNode('node_1_0');
+      svc.currentEvent = null;
+
+      expect(service.previewEventGamble(0)).toBeNull();
+    }));
+
+    it('preview win matches what resolveEvent applies (stash reused, RNG advances only once)', fakeAsync(() => {
+      service.startNewRun();
+      service.selectNode('node_1_0');
+
+      // Sequence: first call → 0.1 (below 0.5 → win), second call would be 0.9.
+      const sequence = [0.1, 0.9];
+      let callCount = 0;
+      svc.runRng = { next: () => sequence[callCount++] ?? 0.5, getState: () => 0, setState: () => {} };
+      svc.currentEvent = makeGambleEvent(0.5);
+
+      const preview = service.previewEventGamble(0);
+      expect(preview).toEqual({ goldDelta: 80, livesDelta: 0 });
+
+      const goldBefore = service.runState!.gold;
+      service.resolveEvent(0); // must reuse the stash, not roll again
+
+      // Only one RNG call should have fired (the preview's), so callCount = 1.
+      expect(callCount).toBe(1);
+      expect(service.runState!.gold).toBe(goldBefore + 80);
+    }));
+
+    it('preview loss matches what resolveEvent applies', fakeAsync(() => {
+      service.startNewRun();
+      service.selectNode('node_1_0');
+
+      svc.runRng = { next: () => 0.9, getState: () => 0, setState: () => {} }; // above winChance → loss
+      svc.currentEvent = makeGambleEvent(0.5);
+
+      const preview = service.previewEventGamble(0);
+      expect(preview).toEqual({ goldDelta: -30, livesDelta: 0 });
+
+      const goldBefore = service.runState!.gold;
+      service.resolveEvent(0);
+      expect(service.runState!.gold).toBe(Math.max(0, goldBefore - 30));
+    }));
+
+    it('stash is cleared after resolveEvent consumes it — second resolveEvent rolls fresh', fakeAsync(() => {
+      service.startNewRun();
+      service.selectNode('node_1_0');
+
+      let callCount = 0;
+      svc.runRng = { next: () => { callCount++; return 0.1; }, getState: () => 0, setState: () => {} };
+
+      // First cycle: preview + resolve (stash consumed)
+      svc.currentEvent = makeGambleEvent(0.5);
+      service.previewEventGamble(0); // roll 1 — stash set
+      service.resolveEvent(0);       // stash reused, stash cleared → callCount = 1
+
+      // Second cycle: resolve without preview — must roll fresh
+      svc.currentEvent = makeGambleEvent(0.5);
+      service.resolveEvent(0); // no stash → fresh roll → callCount = 2
+
+      expect(callCount).toBe(2);
+    }));
+  });
+
   // ── generateRewards — FEWER_RELIC_CHOICES ascension effect ───────
 
   describe('generateRewards — FEWER_RELIC_CHOICES ascension reduction', () => {
diff --git a/src/app/run/services/run.service.ts b/src/app/run/services/run.service.ts
index ecbe877c..5383b2cd 100644
--- a/src/app/run/services/run.service.ts
+++ b/src/app/run/services/run.service.ts
@@ -108,6 +108,13 @@ export class RunService {
   /** Current event (generated on entering event node). */
   private currentEvent: RunEvent | null = null;
 
+  /**
+   * Stash set by previewEventGamble() so resolveEvent() can reuse the same
+   * roll rather than advancing the RNG a second time.
+   * Cleared after resolveEvent() consumes it (or when the choice is not a gamble).
+   */
+  private pendingGambleRoll: { choiceIndex: number; goldDelta: number; livesDelta: number } | null = null;
+
   /** RNG seeded per-run, advanced by each random action. */
   private runRng: SeededRng | null = null;
 
@@ -206,6 +213,33 @@ export class RunService {
     return this.currentEvent;
   }
 
+  /**
+   * Roll the seeded RNG once for a gamble outcome and stash the result so
+   * resolveEvent() can reuse it without rolling again.
+   *
+   * Returns the computed deltas when the choice has a gamble field, or null
+   * when the choice is non-gamble or the index is out of range. The stash is
+   * consumed (and cleared) the next time resolveEvent() runs.
+   */
+  previewEventGamble(choiceIndex: number): { goldDelta: number; livesDelta: number } | null {
+    const event = this.currentEvent;
+    if (!event || choiceIndex < 0 || choiceIndex >= event.choices.length) {
+      this.pendingGambleRoll = null;
+      return null;
+    }
+    const outcome = event.choices[choiceIndex].outcome;
+    if (!outcome.gamble) {
+      this.pendingGambleRoll = null;
+      return null;
+    }
+    const rng = this.getRng();
+    const won = rng() < outcome.gamble.winChance;
+    const goldDelta = won ? outcome.gamble.winGoldDelta : outcome.gamble.loseGoldDelta;
+    const livesDelta = won ? (outcome.gamble.winLivesDelta ?? 0) : (outcome.gamble.loseLivesDelta ?? 0);
+    this.pendingGambleRoll = { choiceIndex, goldDelta, livesDelta };
+    return { goldDelta, livesDelta };
+  }
+
   getRngState(): number | null {
     return this.runRng?.getState() ?? null;
   }
@@ -841,17 +875,25 @@ export class RunService {
 
     const outcome = event.choices[choiceIndex].outcome;
 
-    // Gamble: if the outcome has a gamble field, roll rng to determine gold delta.
+    // Gamble: resolve gold and lives deltas from the seeded RNG.
     // Extended gamble fields winLivesDelta / loseLivesDelta allow lives-wager events
     // (e.g. field_wager) to add or remove lives based on the roll outcome, in addition
     // to the unconditional livesDelta already applied below.
+    // When previewEventGamble() was called first for this choice, reuse its stash
+    // so the display and the actual state change reflect the same roll.
     let resolvedGoldDelta: number;
     let gambleLivesDelta = 0;
     if (outcome.gamble) {
-      const rng = this.getRng();
-      const won = rng() < outcome.gamble.winChance;
-      resolvedGoldDelta = won ? outcome.gamble.winGoldDelta : outcome.gamble.loseGoldDelta;
-      gambleLivesDelta = won ? (outcome.gamble.winLivesDelta ?? 0) : (outcome.gamble.loseLivesDelta ?? 0);
+      if (this.pendingGambleRoll && this.pendingGambleRoll.choiceIndex === choiceIndex) {
+        resolvedGoldDelta = this.pendingGambleRoll.goldDelta;
+        gambleLivesDelta = this.pendingGambleRoll.livesDelta;
+      } else {
+        const rng = this.getRng();
+        const won = rng() < outcome.gamble.winChance;
+        resolvedGoldDelta = won ? outcome.gamble.winGoldDelta : outcome.gamble.loseGoldDelta;
+        gambleLivesDelta = won ? (outcome.gamble.winLivesDelta ?? 0) : (outcome.gamble.loseLivesDelta ?? 0);
+      }
+      this.pendingGambleRoll = null;
     } else {
       resolvedGoldDelta = outcome.goldDelta;
     }
diff --git a/src/styles/_animations.scss b/src/styles/_animations.scss
index e6302878..a6738102 100644
--- a/src/styles/_animations.scss
+++ b/src/styles/_animations.scss
@@ -61,9 +61,12 @@
 }
 
 /* Toast slide in */
-@keyframes toast-slide-in {
-  from { transform: translateX(100%); opacity: 0; }
-  to { transform: translateX(0); opacity: 1; }
+// Card-play / combat toast: rises from above the hand and fades over its life.
+@keyframes toast-rise {
+  0%   { transform: translateY(0.6rem);  opacity: 0; }
+  8%   { transform: translateY(0);       opacity: 1; }
+  82%  { transform: translateY(-0.5rem); opacity: 1; }
+  100% { transform: translateY(-1.6rem); opacity: 0; }
 }
 
 /* Pulse critical — HUD lives / speed-run warning */
diff --git a/src/styles/_game-hud.scss b/src/styles/_game-hud.scss
index 490fdd9e..6536c2cd 100644
--- a/src/styles/_game-hud.scss
+++ b/src/styles/_game-hud.scss
@@ -378,60 +378,90 @@ body.reduce-motion .board-container .game-hud .hud-stat .speed-run-timer.critica
 
 /* ===== Toast notification system ===== */
 .toast-stack {
+  // Rise from just above the card hand — feedback emanates from where the card
+  // was played, then floats up and fades. Off the corners, off the controls.
   position: fixed;
-  bottom: calc(var(--shell-hand-height, 9rem) + var(--spacing-sm));
-  right: 1rem;
+  left: 50%;
+  transform: translateX(-50%);
+  bottom: calc(var(--shell-hand-height) + var(--spacing-sm));
   display: flex;
-  flex-direction: column-reverse;
-  gap: 0.5rem;
+  flex-direction: column-reverse;   // newest nearest the hand, older risen above
+  align-items: center;
+  gap: 0.45rem;
   z-index: calc(var(--z-index-modal) + 50);
   pointer-events: none;
 }
 
+// Card-style frame: a neon accent edge (the type colour) over a dark card
+// interior, with notched top-right / bottom-left corners echoing the game's
+// cards. clip-path forbids box-shadow, so the soft neon edge is a drop-shadow.
 .toast {
-  padding: 0.75rem 1rem;
-  border-radius: var(--border-radius-lg);
-  min-width: 200px;
-  max-width: 320px;
+  --toast-accent: #b46cff;
+  --toast-clip: polygon(
+    0 0, calc(100% - 0.7rem) 0, 100% 0.7rem,
+    100% 100%, 0.7rem 100%, 0 calc(100% - 0.7rem)
+  );
+  position: relative;
+  display: flex;
+  flex-direction: column;
+  min-width: 11rem;
+  max-width: 19rem;
+  padding: 0.5rem 0.95rem;
+  background: var(--toast-accent);              // the neon edge
+  clip-path: var(--toast-clip);
+  filter: drop-shadow(0 0 2px var(--toast-accent));
   pointer-events: auto;
   cursor: pointer;
-  animation: toast-slide-in 0.3s ease-out;
   font-family: 'Orbitron', sans-serif;
   color: var(--text-color);
+  // Rises + fades across its full lifetime; duration is bound per-notification
+  // in the template so the fade lands exactly as the toast is dismissed.
+  animation-name: toast-rise;
+  animation-duration: 3.5s;
+  animation-timing-function: ease-out;
+  animation-fill-mode: forwards;
 }
 
-.toast--achievement {
-  background: var(--game-gold-a15);
-  border: var(--border-width-thin) solid var(--game-gold-a50);
-}
-
-.toast--streak {
-  background: rgba(0, 255, 255, 0.1);
-  border: var(--border-width-thin) solid rgba(0, 255, 255, 0.4);
-}
-
-.toast--challenge {
-  background: rgba(180, 100, 255, 0.15);
-  border: var(--border-width-thin) solid rgba(180, 100, 255, 0.4);
+.toast::before {
+  content: '';
+  position: absolute;
+  inset: 1.5px;
+  background: rgba(10, 5, 20, 0.94);            // dark card interior
+  clip-path: var(--toast-clip);
+  z-index: 0;
 }
 
-.toast--info {
-  background: rgba(200, 200, 255, 0.1);
-  border: var(--border-width-thin) solid rgba(200, 200, 255, 0.3);
-}
+.toast--info { --toast-accent: #b46cff; }
+.toast--achievement { --toast-accent: var(--game-gold); }
+.toast--challenge { --toast-accent: #b46cff; }
+.toast--streak { --toast-accent: var(--theme-cyan); }
 
 .toast__title {
+  position: relative;
+  z-index: 1;
   display: block;
-  font-size: 0.7rem;
+  font-size: 0.72rem;
   font-weight: 700;
-  color: inherit;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--toast-accent);
 }
 
 .toast__message {
+  position: relative;
+  z-index: 1;
   display: block;
-  font-size: 0.6rem;
-  color: rgba(255, 255, 255, 0.8);
-  margin-top: 2px;
+  font-size: 0.64rem;
+  font-weight: 500;
+  color: rgba(255, 255, 255, 0.82);
+  margin-top: 0.15rem;
+}
+
+@media (max-width: 768px) {
+  .toast {
+    min-width: 0;
+    max-width: min(19rem, calc(100vw - 1.5rem));
+  }
 }
 
 @media (prefers-reduced-motion: reduce) {