feat(combat): status-instance target selection + remove-selected op (#2 slice 1)

The effect target domain was combatant-only: status ops could name a definition
('remove Poison') or a whole polarity ('remove all buffs') but never a single
status INSTANCE. Add that missing selector, the status-domain analog of card-
instance targeting:

- StatusSelectionSpec (polarity filter x First[index]/Random) + StatusSelection.Resolve,
  a reusable, serializable picker shared by future ops (reduce/copy/steal).
- RemoveStatusInstanceEffectRequest/Handler: removes one instance by StatusInstanceId
  (vs RemoveStatus which clears a whole definition).
- RemoveSelectedStatusNode<T> + executor (registered) consuming the spec per target.

Expresses 'remove a random buff', 'remove the enemy's first debuff'. Random advances
the combat RNG (replay-stable). Core 1355->1361. Follow-ups: CombatJson round-trip,
reduce/copy/steal ops, resource-pool domain.

Author: Paranoidgrinch

src/RogueDeck.Core/Combat/Effects/Programs/EffectProgramContracts.cs

@@ -268,6 +268,15 @@ public interface IRemoveStatusesByPolarityNodeCore : INativeEffectOperationNode
     Type INativeEffectOperationNode.ProducedEffectRequestType => typeof(RemoveStatusesByPolarityEffectRequest);
 }
 
+// Removes ONE selected status instance per target (#3): the target selector picks the combatant(s); the
+// StatusSelectionSpec picks which of that combatant's statuses (a random buff, the first debuff, …).
+public interface IRemoveSelectedStatusNodeCore : INativeEffectOperationNode
+{
+    ICombatantTargetSelector TargetSelector { get; }
+    StatusSelectionSpec Selection { get; }
+    Type INativeEffectOperationNode.ProducedEffectRequestType => typeof(RemoveStatusInstanceEffectRequest);
+}
+
 public interface IModifyStatusStacksNodeCore : INativeEffectOperationNode
 {
     ICombatantTargetSelector TargetSelector { get; }

src/RogueDeck.Core/Combat/Effects/Programs/EffectProgramNativeNodes.cs

@@ -397,6 +397,27 @@ ResultKey is { } key
             : null;
 }
 
+// Removes a single SELECTED status instance from each target (#3): "remove a random buff", "remove the enemy's
+// first debuff". The instance is chosen at execution time by StatusSelection against the live state.
+public sealed class RemoveSelectedStatusNode<TContext> : IRemoveSelectedStatusNodeCore, IEffectNode<TContext>
+    where TContext : class
+{
+    public ICombatantTargetSelector TargetSelector { get; }
+    public IEnumerable<ICombatantTargetSelector> GetTargetSelectors() => [TargetSelector];
+    public StatusSelectionSpec Selection { get; }
+
+    public IReadOnlyList<IEffectNode<TContext>> Children => [];
+
+    public RemoveSelectedStatusNode(ICombatantTargetSelector targetSelector, StatusSelectionSpec selection)
+    {
+        ArgumentNullException.ThrowIfNull(targetSelector);
+        ArgumentNullException.ThrowIfNull(selection);
+
+        TargetSelector = targetSelector;
+        Selection = selection;
+    }
+}
+
 public sealed class RemoveStatusesByPolarityNode<TContext> : IRemoveStatusesByPolarityNodeCore, IEffectNode<TContext>
     where TContext : class
 {

src/RogueDeck.Core/Combat/Effects/Programs/EffectProgramNodeExecutors.cs

@@ -63,6 +63,7 @@ private static EffectNodeExecutorRegistry CreateDefault()
         r.RegisterOpenGeneric(typeof(RefillResourceNode<>), new RefillResourceNodeExecutor());
         r.RegisterOpenGeneric(typeof(ApplyStatusNode<>), new ApplyStatusNodeExecutor());
         r.RegisterOpenGeneric(typeof(RemoveStatusNode<>), new RemoveStatusNodeExecutor());
+        r.RegisterOpenGeneric(typeof(RemoveSelectedStatusNode<>), new RemoveSelectedStatusNodeExecutor());
         r.RegisterOpenGeneric(typeof(RemoveStatusesByPolarityNode<>), new RemoveStatusesByPolarityNodeExecutor());
         r.RegisterOpenGeneric(typeof(ModifyStatusStacksNode<>), new ModifyStatusStacksNodeExecutor());
         r.RegisterOpenGeneric(typeof(ModifyStatusDurationNode<>), new ModifyStatusDurationNodeExecutor());
@@ -906,6 +907,25 @@ public void Execute(IEffectNode node, IEffectExecutionContextCore ctx, CombatSta
     }
 }
 
+internal sealed class RemoveSelectedStatusNodeExecutor : IEffectNodeExecutor
+{
+    public void Execute(IEffectNode node, IEffectExecutionContextCore ctx, CombatState combat,
+        Action<CombatState>? onComplete, Action<IEffectNode, CombatState, Action<CombatState>?> dispatch)
+    {
+        var typed = (IRemoveSelectedStatusNodeCore)node;
+
+        foreach (var target in typed.TargetSelector.ResolveTargetsTraced(ctx, combat))
+        {
+            var statusId = StatusSelection.Resolve(combat, target, typed.Selection);
+            if (statusId is { } id)
+                combat.EnqueueEffect(new RemoveStatusInstanceEffectRequest(target, id));
+        }
+
+        if (onComplete is not null)
+            combat.EnqueueContinuation(onComplete);
+    }
+}
+
 internal sealed class RemoveStatusNodeExecutor : IEffectNodeExecutor
 {
     public void Execute(IEffectNode node, IEffectExecutionContextCore ctx, CombatState combat,

src/RogueDeck.Core/Combat/Effects/StatusEffects.cs

@@ -458,6 +458,48 @@ protected override void Resolve(
     }
 }
 
+// Removes ONE specific status instance (addressed by its StatusInstanceId), unlike RemoveStatusEffectRequest
+// which removes every instance of a definition. Backs the status-instance selection ops (#3): "remove a random
+// buff" resolves an instance id, then this removes exactly it. A no-op (empty outcome) if the instance is gone.
+public sealed record RemoveStatusInstanceEffectRequest(
+    CombatantId TargetCombatantId,
+    StatusInstanceId StatusInstanceId,
+    RemoveStatusOutcomeSlot? OutcomeSlot = null
+) : IEffectRequest;
+
+public sealed class RemoveStatusInstanceEffectHandler : EffectRequestHandler<RemoveStatusInstanceEffectRequest>
+{
+    protected override void Resolve(
+        CombatState combat,
+        CombatDefinitionRegistry registry,
+        RemoveStatusInstanceEffectRequest request)
+    {
+        var target = combat.GetCombatant(request.TargetCombatantId);
+        var status = target.Statuses.FirstOrDefault(s => s.Id == request.StatusInstanceId);
+
+        if (status is null)
+        {
+            if (request.OutcomeSlot is { } emptySlot)
+                emptySlot.Value = new RemoveStatusOutcome(0, []);
+            return;
+        }
+
+        target.RemoveStatus(status);
+
+        if (request.OutcomeSlot is { } slot)
+            slot.Value = new RemoveStatusOutcome(1, [status.Id]);
+
+        combat.AddLogEntry(
+            StandardCombatLogTypes.StatusRemoved,
+            $"Removed status instance '{status.DefinitionId}' from '{request.TargetCombatantId}'.");
+
+        combat.EnqueueEvent(new StatusRemovedCombatEvent(
+            request.TargetCombatantId,
+            [status.Id],
+            status.DefinitionId));
+    }
+}
+
 public sealed record DecreaseStatusChargesEffectRequest(
     CombatantId TargetCombatantId,
     StatusInstanceId StatusInstanceId,

src/RogueDeck.Core/Combat/Effects/StatusSelection.cs

@@ -0,0 +1,65 @@
+namespace RogueDeck.Core.Combat;
+
+// ── Status-instance selection (#3 non-combatant target domains) ────────────────
+//
+// The effect-program target domain has always been the COMBATANT: a node points at combatants and acts on
+// them wholesale. Status operations could only name a status by DEFINITION ("remove Poison", "remove all
+// buffs") — there was no way to point at a single status INSTANCE the way card targeting points at a single
+// card instance. This adds that missing selector: given a combatant, pick ONE of its status instances by a
+// polarity filter + a pick mode, so ops like "remove a RANDOM buff" or "steal the enemy's first debuff" become
+// expressible. It mirrors the card-instance selection family (positional / random) at the status altitude.
+
+// Which statuses on a combatant are eligible to be picked.
+public enum StatusPolarityFilter
+{
+    Any,
+    Buff,
+    Debuff,
+}
+
+// How to pick among the eligible statuses.
+public enum StatusPick
+{
+    First,  // deterministic: the Index-th eligible status in owner order (a pure read)
+    Random, // uniform via the combat RNG (deterministic by seed; advances the RNG step)
+}
+
+// A reusable, serializable description of "which one status instance on a combatant". Shared by every op that
+// consumes a chosen status (remove today; reduce/copy/steal are follow-ups), so the selection logic lives once.
+public sealed record StatusSelectionSpec(
+    StatusPolarityFilter Polarity = StatusPolarityFilter.Any,
+    StatusPick Pick = StatusPick.First,
+    int Index = 0);
+
+public static class StatusSelection
+{
+    private static bool Matches(StatusInstance status, StatusPolarityFilter filter) => filter switch
+    {
+        StatusPolarityFilter.Buff => status.Polarity == StatusPolarity.Buff,
+        StatusPolarityFilter.Debuff => status.Polarity == StatusPolarity.Debuff,
+        _ => true,
+    };
+
+    // Resolves the spec against a combatant's live statuses. Returns null when the combatant is absent or no
+    // status matches the filter. For StatusPick.Random this advances the combat RNG step (like the random card
+    // selector), so a replay reproduces the pick.
+    public static StatusInstanceId? Resolve(CombatState combat, CombatantId owner, StatusSelectionSpec spec)
+    {
+        if (!combat.TryGetCombatant(owner, out var combatant) || combatant is null)
+            return null;
+
+        var matches = combatant.Statuses.Where(s => Matches(s, spec.Polarity)).ToList();
+        if (matches.Count == 0)
+            return null;
+
+        switch (spec.Pick)
+        {
+            case StatusPick.Random:
+                var index = CombatRandom.CreateShuffledIndexes(matches.Count, combat.RandomSeed, combat.RandomStep)[0];
+                combat.AdvanceRandomStep();
+                return matches[index].Id;
+            default: // First
+                return spec.Index >= 0 && spec.Index < matches.Count ? matches[spec.Index].Id : null;
+        }
+    }
+}

src/RogueDeck.Core/Combat/StandardCombatPackage.cs

@@ -71,6 +71,7 @@ public void RegisterDefinitions(CombatDefinitionRegistryBuilder registry)
         registry.RegisterEffectRequestHandler(new ApplyStatusEffectHandler());
         registry.RegisterEffectRequestHandler(new RemoveStatusEffectHandler());
         registry.RegisterEffectRequestHandler(new RemoveStatusesByPolarityEffectHandler());
+        registry.RegisterEffectRequestHandler(new RemoveStatusInstanceEffectHandler());
         registry.RegisterEffectRequestHandler(new ModifyStatusStacksEffectHandler());
         registry.RegisterEffectRequestHandler(new ModifyStatusDurationEffectHandler());
         registry.RegisterEffectRequestHandler(new ModifyStatusChargesEffectHandler());

tests/RogueDeck.Core.Tests/Combat/SelectedStatusTargetingTests.cs

@@ -0,0 +1,149 @@
+using RogueDeck.Core.Combat;
+
+namespace RogueDeck.Core.Tests;
+
+// #3 non-combatant target domains: an effect can now point at a single status INSTANCE on a combatant (not just
+// a status definition or a whole polarity). RemoveSelectedStatusNode + StatusSelectionSpec express "remove a
+// random buff", "remove the enemy's first debuff", etc. — the status-domain analog of card-instance targeting.
+public class SelectedStatusTargetingTests
+{
+    private static readonly CombatantId HeroId = new("hero_001");
+    private static readonly CombatantId GoblinId = new("goblin_001");
+
+    private static readonly StatusDefinitionId StrengthId = new("test.buff_strength");
+    private static readonly StatusDefinitionId DexterityId = new("test.buff_dexterity");
+    private static readonly StatusDefinitionId PoisonId = new("test.debuff_poison");
+    private static readonly StatusDefinitionId BurnId = new("test.debuff_burn");
+
+    private sealed record Ctx;
+
+    [Fact]
+    public void First_pick_removes_the_selected_polarity_and_keeps_the_rest()
+    {
+        var registry = CreateRegistry();
+        var combat = CombatTestFactory.CreateCombatWithHeroAndGoblin();
+        ApplyStatus(combat, registry, GoblinId, StrengthId, 2);
+        ApplyStatus(combat, registry, GoblinId, PoisonId, 3);
+
+        RunRemoveSelected(combat, registry, new StatusSelectionSpec(StatusPolarityFilter.Debuff));
+
+        var remaining = Assert.Single(combat.GetCombatant(GoblinId).Statuses);
+        Assert.Equal(StrengthId, remaining.DefinitionId); // the buff survived; the debuff was removed
+    }
+
+    [Fact]
+    public void Removing_a_random_buff_removes_exactly_one_buff_and_no_debuff()
+    {
+        var registry = CreateRegistry();
+        var combat = CombatTestFactory.CreateCombatWithHeroAndGoblin();
+        ApplyStatus(combat, registry, GoblinId, StrengthId, 2);
+        ApplyStatus(combat, registry, GoblinId, DexterityId, 2);
+        ApplyStatus(combat, registry, GoblinId, PoisonId, 3);
+
+        RunRemoveSelected(combat, registry, new StatusSelectionSpec(StatusPolarityFilter.Buff, StatusPick.Random));
+
+        var statuses = combat.GetCombatant(GoblinId).Statuses;
+        Assert.Equal(2, statuses.Count); // exactly one removed
+        Assert.Equal(1, statuses.Count(s => s.Polarity == StatusPolarity.Buff)); // one buff gone
+        Assert.Contains(statuses, s => s.DefinitionId == PoisonId); // the debuff is untouched
+    }
+
+    [Fact]
+    public void Index_selects_the_nth_matching_status()
+    {
+        var registry = CreateRegistry();
+        var combat = CombatTestFactory.CreateCombatWithHeroAndGoblin();
+        ApplyStatus(combat, registry, GoblinId, PoisonId, 3); // debuff #0
+        ApplyStatus(combat, registry, GoblinId, BurnId, 1);   // debuff #1
+
+        RunRemoveSelected(combat, registry, new StatusSelectionSpec(StatusPolarityFilter.Debuff, Index: 1));
+
+        var remaining = Assert.Single(combat.GetCombatant(GoblinId).Statuses);
+        Assert.Equal(PoisonId, remaining.DefinitionId); // the 2nd debuff (Burn) was removed
+    }
+
+    [Fact]
+    public void No_matching_status_is_a_no_op()
+    {
+        var registry = CreateRegistry();
+        var combat = CombatTestFactory.CreateCombatWithHeroAndGoblin();
+        ApplyStatus(combat, registry, GoblinId, PoisonId, 3); // only a debuff present
+
+        RunRemoveSelected(combat, registry, new StatusSelectionSpec(StatusPolarityFilter.Buff));
+
+        Assert.Single(combat.GetCombatant(GoblinId).Statuses); // nothing removed
+    }
+
+    [Fact]
+    public void The_instance_request_removes_only_the_addressed_instance()
+    {
+        var registry = CreateRegistry();
+        var combat = CombatTestFactory.CreateCombatWithHeroAndGoblin();
+        ApplyStatus(combat, registry, GoblinId, StrengthId, 2);
+        ApplyStatus(combat, registry, GoblinId, PoisonId, 3);
+
+        var poison = combat.GetCombatant(GoblinId).Statuses.Single(s => s.DefinitionId == PoisonId);
+        combat.EnqueueEffect(new RemoveStatusInstanceEffectRequest(GoblinId, poison.Id));
+        new CombatQueueProcessor().ResolvePendingQueues(combat, registry);
+
+        var remaining = Assert.Single(combat.GetCombatant(GoblinId).Statuses);
+        Assert.Equal(StrengthId, remaining.DefinitionId);
+    }
+
+    [Fact]
+    public void Standard_package_registers_the_instance_removal_handler()
+    {
+        var registry = CombatTestFactory.CreateStandardRegistry();
+        Assert.IsType<RemoveStatusInstanceEffectHandler>(
+            registry.GetEffectRequestHandler(typeof(RemoveStatusInstanceEffectRequest)));
+    }
+
+    private static void RunRemoveSelected(
+        CombatState combat, CombatDefinitionRegistry registry, StatusSelectionSpec spec)
+    {
+        var ctx = MakeContext(combat);
+        var program = new EffectProgram<Ctx>(new RemoveSelectedStatusNode<Ctx>(
+            CombatantTargetSelectors.EventTarget, spec));
+        EffectProgramExecutor.Execute(program, ctx, combat);
+        new CombatQueueProcessor().ResolvePendingQueues(combat, registry);
+    }
+
+    private static CombatDefinitionRegistry CreateRegistry()
+    {
+        var builder = CombatTestFactory.CreateStandardBuilder();
+        RegisterStatus(builder, StrengthId, StatusPolarity.Buff);
+        RegisterStatus(builder, DexterityId, StatusPolarity.Buff);
+        RegisterStatus(builder, PoisonId, StatusPolarity.Debuff);
+        RegisterStatus(builder, BurnId, StatusPolarity.Debuff);
+        return builder.Build();
+    }
+
+    private static void RegisterStatus(
+        CombatDefinitionRegistryBuilder builder, StatusDefinitionId id, StatusPolarity polarity) =>
+        builder.RegisterStatus(new StatusDefinition(
+            id,
+            new PackageId("test"),
+            displayNameKey: $"status.{id}.name",
+            descriptionKey: $"status.{id}.desc",
+            polarity: polarity,
+            usesStacks: true,
+            showStacksInUi: true,
+            stackingBehavior: StatusStackingBehavior.MergeWithExistingInstance));
+
+    private static void ApplyStatus(
+        CombatState combat, CombatDefinitionRegistry registry, CombatantId targetId, StatusDefinitionId statusId, int stacks)
+    {
+        combat.EnqueueEffect(new ApplyStatusEffectRequest(
+            TargetCombatantId: targetId, StatusDefinitionId: statusId, Stacks: stacks));
+        new CombatQueueProcessor().ResolvePendingQueues(combat, registry);
+    }
+
+    private static EffectExecutionContext<Ctx> MakeContext(CombatState combat) =>
+        new(new Ctx(),
+            new TriggeredEffectActionBuildContext(
+                new CombatantTargetSelectionContext(
+                    Combat: combat,
+                    Source: combat.GetCombatant(HeroId),
+                    EventTargetId: GoblinId),
+                new TriggeredEffectActionSource(SourceCombatantId: HeroId)));
+}