feat(battle-engine-port): M7 COMPLETE — targeted destroy resolves headless (follower death / board-removal)

First proof that follower DEATH / board-removal commits in the authoritative
part of PlayCard headless (not the cosmetic post-Process tail). Card 800144120
(cost-0 when_play destroy of a select_count=1 enemy follower) resolves via the
M6 selectedCards path: selected enemy follower removed (board -1 + cemetery +1),
un-selected untouched (routing confirmed load-bearing by swapping the selection).

Shim gap fixed (the predicted M7 cost): SkillProcessor.SelectCardToHaveDestroyVoicePlay's
cosmetic death-voice tail NRE'd on three M1 default!/Null* shadows
(IBattleCardView.VoiceInfo, CardVoiceInfoCache.GetCardVoiceInfoForBattle,
ReadOnlyVoiceInfo.GetDestroyVoice — the last unusable as the interface since
m1_stub_gen dropped its : IReadOnlyVoiceInfo base). Fix = one hand shim
HeadlessVoiceInfo : IReadOnlyVoiceInfo returning the engine's own
VoiceAndWaitTime._nullVoice sentinel, wired into the two generated seams with
// HEADLESS-FIX markers. No Engine/ edit (drift clean).

dotnet test SVSim.BattleEngine.Tests -> 7/7 green; check_drift.py clean; engine 0 Error(s).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

SVSim.BattleEngine.Tests/HeadlessFixture.cs

@@ -69,6 +69,22 @@ namespace SVSim.BattleEngine.Tests
         public const int SelectTargetFollowerId = 900041010;   // neutral 13/13
         public const int UnselectTargetFollowerId = 102011010; // neutral 6/7
 
+        // M7 next milestone: targeted DESTROY — the first card proving follower DEATH / board-removal
+        // resolves in the AUTHORITATIVE (committed) part of PlayCard headless, not the cosmetic
+        // post-Process tail. 800144120 is an ELF (clan 1) cost-0 SPELL whose sole skill is `when_play`
+        // `destroy` of a SELECTED enemy follower
+        // (skill_target=character=op&target=inplay&card_type=unit&select_count=1), ungated
+        // (skill_condition=character=me), no RNG, no dynamic value. `destroy` is UNCONDITIONAL removal
+        // (vs `damage` needing a >=life amount), so the oracle is the cleanest possible "card left the
+        // board": selected follower gone + enemy board count -1 + selected card in CemeteryList, while
+        // the un-selected follower stays (routing, M6's lesson, confirmed load-bearing by swapping the
+        // selection). Reuses the two M2/M6 vanilla followers as the target board (destroy is
+        // unconditional so their stats are irrelevant — distinct ids only so selected vs un-selected
+        // can't be confused). InitCardTemplates is NOT needed (destroy creates no card).
+        public const int DestroySpellId = 800144120;
+        public const int DestroyTargetFollowerId = FollowerId;             // neutral 1/2 (the selected, destroyed one)
+        public const int DestroyOtherFollowerId = UnselectTargetFollowerId; // neutral 6/7 (the un-selected survivor)
+
         private static bool _done;
 
         public static void EnsureInitialized()
@@ -89,7 +105,7 @@ namespace SVSim.BattleEngine.Tests
             // real stats. The summoned token id must be present: Skill_summon_token resolves it
             // through CardMaster.GetCardParameterFromId during creation.
             HeadlessCardMaster.Load(FollowerId, SpellId, BuffFollowerId, TokenSpellId, SummonedTokenId,
-                TargetSpellId, SelectTargetFollowerId, UnselectTargetFollowerId);
+                TargetSpellId, SelectTargetFollowerId, UnselectTargetFollowerId, DestroySpellId);
             // Master reference data (class-character list) for leader/class card resolution.
             HeadlessMasterData.Install();
             // Player/enemy leaders (chara ids must map to a ClassCharacterMasterData in Master).

SVSim.BattleEngine.Tests/TargetedDestroySpellOracleTests.cs

@@ -0,0 +1,110 @@
+using System.Collections.Generic;
+using System.Reflection;
+using NUnit.Framework;
+using Wizard;
+using Wizard.Battle;
+
+namespace SVSim.BattleEngine.Tests
+{
+    // M7 (the first card to prove follower DEATH / board-removal): a when_play TARGETED-DESTROY spell
+    // resolves to correct authoritative state HEADLESS via the same IsForecast/IsRecovery +
+    // ActionProcessor + selectedCards path M6 proved — but for the FIRST time exercising a mechanic
+    // that REMOVES a card from the board. M2-M6 only ever ADDED to / mutated stats of cards already in
+    // play; none proved the engine commits board REMOVAL inside the authoritative part of PlayCard
+    // (rather than the cosmetic post-Process tail the prior docs flag). The new oracle dimension is
+    // BOARD REMOVAL: with TWO followers on the enemy board and ONE passed as `selectedCards`, the
+    // `destroy` must remove exactly the SELECTED follower (enemy board count -1, selected gone, landed
+    // in the enemy CemeteryList) while leaving the un-selected follower on the board. The un-selected-
+    // survives assertion is load-bearing the same way M4's delta-vs-base and M6's differential were:
+    // it distinguishes "the destroy was routed to the selection" from "a blanket board wipe" — and is
+    // confirmed by the routing already proven in M6 (the effect follows the selectedCards entry).
+    [TestFixture]
+    public class TargetedDestroySpellOracleTests
+    {
+        private static void SetPrivateField(object obj, string name, object value)
+        {
+            var t = obj.GetType();
+            var f = t.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
+            while (f == null && t.BaseType != null) { t = t.BaseType; f = t.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic); }
+            Assert.That(f, Is.Not.Null, $"field {name} not found on {obj.GetType().Name}");
+            f.SetValue(obj, value);
+        }
+
+        [Test]
+        public void Targeted_destroy_spell_removes_only_the_selected_enemy_follower()
+        {
+            HeadlessEngineEnv.EnsureInitialized();
+            BattleManagerBase.IsForecast = true;           // suppress VFX registration (F1)
+            var mgr = new SingleBattleMgr(new HeadlessContentsCreator());
+            mgr.IsRecovery = true;                          // collapse wait delays to 0 (F1)
+
+            var player = mgr.BattlePlayer;
+            var enemy = mgr.BattleEnemy;
+
+            // Minimal opponent/turn wiring (see M2-M6 oracles): opponent refs + active turn flag. The
+            // destroy's target resolver walks player -> opponent -> opponent's in-play followers.
+            SetPrivateField(player, "_opponentBattlePlayer", enemy);
+            SetPrivateField(enemy, "_opponentBattlePlayer", player);
+            player.IsSelfTurn = true;
+            enemy.IsSelfTurn = false;
+
+            // Seed leader life so neither leader reads as a 0-life game-over state (blocks plays, M3).
+            HeadlessEngineEnv.InitLeaderLife(mgr);
+
+            // Put TWO vanilla followers on the ENEMY board (the M6 setup). destroy is unconditional, so
+            // their stats are irrelevant — distinct ids only so the selected vs un-selected can't be
+            // confused. The selected one is destroyed; the un-selected one must survive.
+            var selected = HeadlessEngineEnv.PutFollowerInPlay(mgr, HeadlessEngineEnv.DestroyTargetFollowerId, 0, isPlayer: false);
+            var unselected = HeadlessEngineEnv.PutFollowerInPlay(mgr, HeadlessEngineEnv.DestroyOtherFollowerId, 1, isPlayer: false);
+
+            var cardParam = CardMaster.GetInstanceForBattle().GetCardParameterFromId(HeadlessEngineEnv.DestroySpellId);
+
+            // Place the targeted-destroy spell in the active player's hand with PP to spare.
+            var card = HeadlessEngineEnv.CreateHeadlessHandCard(HeadlessEngineEnv.DestroySpellId, 1, isPlayer: true, mgr);
+            player.HandCardList.Add(card);
+            player.Pp = 10;
+
+            // Pre-state snapshot.
+            int ppBefore = player.Pp;
+            int handBefore = player.HandCardList.Count;
+            int playerInplayBefore = player.ClassAndInPlayCardList.Count;
+            int enemyInplayBefore = enemy.ClassAndInPlayCardList.Count;
+            int enemyCemeteryBefore = enemy.CemeteryList.Count;
+            int enemyLeaderLifeBefore = enemy.ClassAndInPlayCardList[0].Life;
+
+            // Resolve the play through the real engine, passing the chosen target via selectedCards.
+            var pair = mgr.GetBattlePlayerPair(isPlayer: true);
+            var ap = new ActionProcessor(pair);
+            Assert.DoesNotThrow(() => ap.PlayCard(card, selectedCards: new List<BattleCardBase> { selected }),
+                "ActionProcessor.PlayCard threw on a targeted-destroy spell");
+
+            // Oracle: board removal is the new M7 dimension; the rest are the §5 spell-shaped invariants.
+            Assert.Multiple(() =>
+            {
+                // PRIMARY M7 assertions: the SELECTED follower is removed from the enemy board...
+                Assert.That(enemy.ClassAndInPlayCardList, Does.Not.Contain(selected),
+                    "selected follower still on the enemy board (destroy did not remove it)");
+                Assert.That(enemy.ClassAndInPlayCardList.Count, Is.EqualTo(enemyInplayBefore - 1),
+                    "enemy board count not -1 (a destroy did not commit, or hit the wrong number of cards)");
+                // ...and it landed in the enemy's CemeteryList (the engine's destroy/death path).
+                Assert.That(enemy.CemeteryList, Contains.Item(selected),
+                    "destroyed follower not in the enemy CemeteryList");
+                Assert.That(enemy.CemeteryList.Count, Is.EqualTo(enemyCemeteryBefore + 1),
+                    "enemy cemetery count not +1");
+                // ...while the UN-SELECTED follower stays on the board (proves routing, not a board wipe).
+                Assert.That(enemy.ClassAndInPlayCardList, Contains.Item(unselected),
+                    "un-selected follower was destroyed (effect not routed to the selection)");
+                // Leader untouched (destroy targets a follower, not the face).
+                Assert.That(enemy.ClassAndInPlayCardList[0].Life, Is.EqualTo(enemyLeaderLifeBefore),
+                    "opponent leader life changed (destroy hit the leader, not the selected follower)");
+                // Cost paid.
+                Assert.That(player.Pp, Is.EqualTo(ppBefore - cardParam.Cost), "PP not reduced by exactly cost");
+                // Spell leaves hand and (being a spell) does NOT occupy the board.
+                Assert.That(player.HandCardList, Does.Not.Contain(card), "spell still in hand");
+                Assert.That(player.HandCardList.Count, Is.EqualTo(handBefore - 1), "hand count not -1");
+                Assert.That(player.ClassAndInPlayCardList, Does.Not.Contain(card), "spell wrongly placed on the board");
+                Assert.That(player.ClassAndInPlayCardList.Count, Is.EqualTo(playerInplayBefore), "player board count changed");
+            });
+        }
+    }
+}

SVSim.BattleEngine/Shim/Generated/CardVoiceInfoCache.g.cs

@@ -10,7 +10,7 @@ public partial class CardVoiceInfoCache
         public static void ClearCardVoiceInfo() { }
         public static void CacheCardVoiceInfoForBattle(IList<int> cardID) { }
         public static void CacheCardVoiceInfo(IList<int> cardID, CardMaster.CardMasterId cardMasterId) { }
-        public static IReadOnlyVoiceInfo GetCardVoiceInfoForBattle(int cardID) => default!;
+        public static IReadOnlyVoiceInfo GetCardVoiceInfoForBattle(int cardID) => HeadlessVoiceInfo.Instance; // HEADLESS-FIX (M7): non-null voice info for the IsRecovery death-voice tail
         public static IReadOnlyVoiceInfo GetCardVoiceInfo(int cardID, CardMaster.CardMasterId cardMasterId) => default!;
 }
 }

SVSim.BattleEngine/Shim/Generated/_IfaceImpl.g.cs

@@ -11,7 +11,7 @@ namespace Wizard.Battle.View {
         float global::Wizard.Battle.View.IBattleCardView.OriginalRootYPosition { get => default!; }
         IReadOnlyBattleCardInfo global::Wizard.Battle.View.IBattleCardView.CardInfo { get => default!; }
         BattlePlayerReadOnlyInfoPair global::Wizard.Battle.View.IBattleCardView.PlayerInfoPair { get => default!; }
-        IReadOnlyVoiceInfo global::Wizard.Battle.View.IBattleCardView.VoiceInfo { get => default!; }
+        IReadOnlyVoiceInfo global::Wizard.Battle.View.IBattleCardView.VoiceInfo { get => global::Wizard.Battle.View.HeadlessVoiceInfo.Instance; } // HEADLESS-FIX (M7): non-null voice info for the death-voice tail
         GameObject global::Wizard.Battle.View.IBattleCardView.GameObject { get => default!; }
         GameObject global::Wizard.Battle.View.IBattleCardView.CardWrapObject { get => default!; }
         Transform global::Wizard.Battle.View.IBattleCardView.Transform { get => default!; }

SVSim.BattleEngine/Shim/View/HeadlessVoiceInfo.cs

@@ -0,0 +1,38 @@
+namespace Wizard.Battle.View
+{
+    // HEADLESS-FIX (M7): a non-null IReadOnlyVoiceInfo singleton for the headless death-voice tail.
+    //
+    // SkillProcessor.SelectCardToHaveDestroyVoicePlay (the cosmetic post-Process step that picks which
+    // destroyed card plays its death voice) unconditionally dereferences
+    // `card.BattleCardView.VoiceInfo.GetDestroyVoice(...).Voice` AND, when IsRecovery is set,
+    // `CardVoiceInfoCache.GetCardVoiceInfoForBattle(id).GetDestroyVoice(...).Voice`. Both seams are
+    // M1 `default!` shadows headless (BattleCardView is a null view; the voice cache is never primed),
+    // so the left operand of that `||` NREs before board-removal can be asserted. The destroy itself
+    // (board removal + cemetery move) already committed in the authoritative part of PlayCard upstream;
+    // this is purely the audio tail.
+    //
+    // The real ReadOnlyVoiceInfo can't be reused here: m1_stub_gen dropped its `: IReadOnlyVoiceInfo`
+    // base (interfaces are stripped to avoid CS0535 on the no-op stub) and its Get*Voice still return
+    // null. So this hand singleton implements the interface directly, returning the engine's own
+    // VoiceAndWaitTime._nullVoice sentinel (Voice == "") from every voice getter — the faithful
+    // "no voice configured" result for a headless run with no audio. With Voice == "" both operands of
+    // the IsNullOrEmpty check are false, the selector returns null, and no voice plays.
+    public sealed class HeadlessVoiceInfo : IReadOnlyVoiceInfo
+    {
+        public static readonly HeadlessVoiceInfo Instance = new HeadlessVoiceInfo();
+
+        public bool HasSummonTokenVoice { get; set; }
+        public string VoiceId { get; set; } = "";
+
+        public VoiceAndWaitTime GetPlayVoice(IReadOnlyBattleCardInfo cardInfo, BattlePlayerReadOnlyInfoPair playerPair, int executedFixedUseCostIndex, int skillVoiceIndex) => VoiceAndWaitTime._nullVoice;
+        public VoiceAndWaitTime GetSummonTokenVoice() => VoiceAndWaitTime._nullVoice;
+        public VoiceAndWaitTime GetEvolutionVoice() => VoiceAndWaitTime._nullVoice;
+        public VoiceAndWaitTime GetAttackVoice(bool isEvolution) => VoiceAndWaitTime._nullVoice;
+        public VoiceAndWaitTime GetDestroyVoice(bool isEvolution, bool isExecutedWhiteRitual) => VoiceAndWaitTime._nullVoice;
+        public VoiceAndWaitTime GetSkillVoice(bool isEvolution, int skillIndex) => VoiceAndWaitTime._nullVoice;
+        public int GetSkillVoiceCount(bool isEvolution) => 0;
+        public void SetDestroyCardId(int id) { }
+        public int AddAttachSkillVoice(string id) => 0;
+        public string GetAttachSkillVoice(int index) => "";
+    }
+}