Options-Fundament und Kapitalmodell im Core; Modul OptionsWheel

Das OptionsWheel setzt auf Dingen auf, die es im Core nicht gab. Diese
Sitzung baut sie.

#298 Optionen als Instrument. InstrumentKind/OptionSpec und ein
druckbarer Instrumentenschluessel ("AAPL|20260918|C|150"); TradeSignal
und OrderRequest tragen ein optionales OptionSpec, ohne das sich der
Aktienpfad unveraendert verhaelt. Position.Notional rechnet ab jetzt mit
der Kontraktgroesse - vorher war jede Option um Faktor 100 zu klein
bewertet und damit jedes Risikolimit wirkungslos, lautlos und in die
gefaehrliche Richtung. Daneben neu BoundCapital: ein Short Put bindet
Strike x Kontraktgroesse, nicht die vereinnahmte Praemie.

#300 sell-to-open. Jeder Auftrag zerfaellt in einen schliessenden und
einen eroeffnenden Teil; der schliessende wird von keinem Limit
verhindert - auch nicht vom Kaufstopp, denn ein Rueckkauf baut eine
Verpflichtung ab. Deckungspruefung im Core, nicht im Modul: Short Call
nur mit freien Aktien, Short Put nur mit reservierbarem Bargeld.

#302-#305 Kapital- und Buchmodell. Buecher mit reservierten Namen und
Eigentumsregeln, Pool mit Caps und Headroom, Margin-Sperre in vier
Schichten, core_reservation mit Lebenszyklus, Frist, Idempotenz ueber
(SignalId, ContractKey) und Quarantaene beim Start.

#309/#310 Modul OptionsWheel: ow_-Schema mit fuenf Tabellen,
Zustandsautomat, StrikeSelector, RollDecider, PremiumMath - vollstaendig
ohne Broker testbar. Der Handelsbetrieb bleibt gesperrt, solange #299
und #294 fehlen; das Modul sagt das ueber GetActivationBlocker, statt
still nichts zu tun.

#293 --verify-order am Daemon: eine Order durch die vollstaendige Kette
(Buch, Risiko, Bindung, Order, Fill, Buchung, Abschluss). Ohne --confirm
ein Trockenlauf; Abbruch ausserhalb von Paper-Modus UND Paper-Port.

Drei Widersprueche in den Konzepten sind dabei entschieden worden:
Schicht B heisst ab jetzt "kein UNGEDECKTER Short" (der Grund der Regel
war der Kredit, nicht der Short), die Hausreserve wird einmal abgezogen
statt zweimal, und der Positionsschluessel ist eine Spalte statt eines
Sechser-Verbunds (MySQL verlangt NOT NULL fuer Schluesselspalten).
Begruendungen stehen in docs/ROADMAP.md.

Enthaelt ausserdem die noch nicht committete Arbeit aus der vorigen
Sitzung: die Fehlerbehebungen aus Epic X (WorkerBase-Intervall,
BackupWorker, --check gegen die Datenbank, CapitolTrades-429, SIGTERM)
samt DatabaseEndpoint, MysqlDumpTool und der Roadmap-Umstellung. Sie lag
im Arbeitsbaum und liess sich nicht abtrennen, weil beide Staende
dieselben Dateien beruehren.

213 -> 369 Tests, Build ohne Warnung.

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

tests/IBKRTrader.Tests/Trading/ExecutionServiceTests.cs

@@ -1,6 +1,8 @@
 using FluentAssertions;
+using IBKRTrader.Core.Capital;
 using IBKRTrader.Core.Logging;
 using IBKRTrader.Core.Persistence;
+using IBKRTrader.Core.Persistence.Entities;
 using IBKRTrader.Core.Settings;
 using IBKRTrader.Core.Trading;
 using NSubstitute;
@@ -16,9 +18,12 @@ public class ExecutionServiceTests
     private readonly SettingsService   _settings  = new();
     private readonly IDecisionJournal  _journal   = Substitute.For<IDecisionJournal>();
     private readonly IOrderEventLog    _orderLog  = Substitute.For<IOrderEventLog>();
+    private readonly ICapitalService   _capital   = Substitute.For<ICapitalService>();
+
+    private static readonly BookId Book = BookId.ForModule("CT");
 
     private ExecutionService CreateSut() =>
-        new(_broker, _risk, _portfolio, _settings, new LoggingService(), _journal, _orderLog);
+        new(_broker, _risk, _portfolio, _settings, new LoggingService(), _journal, _orderLog, _capital);
 
     private static readonly TradeSignal BuySignal = new()
     {
@@ -27,6 +32,29 @@ public class ExecutionServiceTests
 
     private void EnableTrading() => _settings.Settings.Trading.TradingEnabled = true;
 
+    /// <summary>
+    /// Kapital-Seam im Normalfall: Buch bekannt, Kontext leer, Bindung geht durch. Die Regeln des
+    /// Kapitalmodells werden einzeln in CapitalTests geprueft – hier geht es nur darum, dass der
+    /// Ausfuehrungspfad sie an der richtigen Stelle aufruft.
+    /// </summary>
+    private void ArrangeCapital(long reservationId = 1)
+    {
+        _capital.ResolveBook("CT").Returns(Book);
+        _capital.BuildContextAsync(Arg.Any<BookId>(), Arg.Any<InstrumentRef>(), Arg.Any<decimal>(),
+                                   Arg.Any<AccountState>(), Arg.Any<CancellationToken>())
+                .Returns(ci => Task.FromResult(new RiskContext
+                {
+                    Price          = ci.ArgAt<decimal>(2),
+                    NetLiquidation = ci.ArgAt<AccountState>(3).NetLiquidation
+                }));
+        _capital.ReserveAsync(Arg.Any<BookId>(), Arg.Any<TradeSignal>(), Arg.Any<InstrumentRef>(),
+                              Arg.Any<TradeSide>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<decimal>(),
+                              Arg.Any<OrderType>(), Arg.Any<AccountState>(), Arg.Any<string>(),
+                              Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(new ReservationService.ReserveResult(
+                    new CoreReservation { Id = reservationId }, null, false)));
+    }
+
     private void ArrangeHappyPath()
     {
         EnableTrading();
@@ -36,8 +64,9 @@ public class ExecutionServiceTests
                .Returns(Task.FromResult(new AccountState(10_000m, 10_000m)));
         _portfolio.GetModuleExposureAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
                   .Returns(Task.FromResult(0m));
-        _portfolio.GetPositionQuantityAsync(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<CancellationToken>())
+        _portfolio.GetPositionQuantityAsync(Arg.Any<string>(), Arg.Any<InstrumentRef>(), Arg.Any<CancellationToken>())
                   .Returns(Task.FromResult(0));
+        ArrangeCapital();
         _risk.Evaluate(Arg.Any<TradeSignal>(), Arg.Any<RiskContext>(), Arg.Any<RiskParameters>())
              .Returns(RiskDecision.Approve(5));
         _broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
@@ -75,6 +104,7 @@ public class ExecutionServiceTests
                .Returns(Task.FromResult<Quote?>(new Quote("AAPL", 100m, 99m, 101m)));
         _broker.GetAccountStateAsync(Arg.Any<CancellationToken>())
                .Returns(Task.FromResult(new AccountState(10_000m, 10_000m)));
+        ArrangeCapital();
         _risk.Evaluate(Arg.Any<TradeSignal>(), Arg.Any<RiskContext>(), Arg.Any<RiskParameters>())
              .Returns(RiskDecision.Reject("Modul-Limit überschritten."));
 
@@ -95,7 +125,7 @@ public class ExecutionServiceTests
         result.Executed.Should().BeTrue();
         result.Order!.OrderId.Should().Be("O1");
         await _portfolio.Received(1).RecordFillAsync(
-            "CT", "AAPL", TradeSide.Buy, 5, 100m, "O1", Arg.Any<string?>(), Arg.Any<CancellationToken>());
+            "CT", InstrumentRef.ForStock("AAPL"), TradeSide.Buy, 5, 100m, "O1", Arg.Any<string?>(), Arg.Any<CancellationToken>());
     }
 
     [Fact]
@@ -129,7 +159,7 @@ public class ExecutionServiceTests
         await CreateSut().ExecuteAsync(signal);
 
         await _portfolio.Received(1).RecordFillAsync(
-            "CT", "AAPL", TradeSide.Buy, 5, 100m, "O1", "sig-abc", Arg.Any<CancellationToken>());
+            "CT", InstrumentRef.ForStock("AAPL"), TradeSide.Buy, 5, 100m, "O1", "sig-abc", Arg.Any<CancellationToken>());
         _journal.Received().Write(Arg.Is<IBKRTrader.Core.Persistence.Entities.CoreDecisionRecord>(
             d => d.SignalId == "sig-abc" &&
                  d.Decision == IBKRTrader.Core.Persistence.Entities.TradeDecision.Executed));
@@ -138,6 +168,85 @@ public class ExecutionServiceTests
                  e.EventType == IBKRTrader.Core.Persistence.Entities.OrderEventType.Filled));
     }
 
+    [Fact]
+    public async Task UnknownBook_IsRejected_BeforeAnyOrder()
+    {
+        // SourceModule kommt aus dem Modul und ist kein Ausweis: ein nicht registrierter Name
+        // wuerde ein Buch ohne Cap erzeugen - also ein unbegrenztes.
+        ArrangeHappyPath();
+        _capital.ResolveBook("CT").Returns((BookId?)null);
+
+        var result = await CreateSut().ExecuteAsync(BuySignal);
+
+        result.Action.Should().Be("SKIP");
+        result.Reason.Should().Contain("Unbekanntes Buch");
+        await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task CapitalRejects_NoOrderIsPlaced()
+    {
+        ArrangeHappyPath();
+        _capital.ReserveAsync(Arg.Any<BookId>(), Arg.Any<TradeSignal>(), Arg.Any<InstrumentRef>(),
+                              Arg.Any<TradeSide>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<decimal>(),
+                              Arg.Any<OrderType>(), Arg.Any<AccountState>(), Arg.Any<string>(),
+                              Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(new ReservationService.ReserveResult(
+                    null,
+                    new LimitBreach(LimitKind.CashAvailable, "AAPL", 5000m, 1000m, 10, 1000m),
+                    false)));
+
+        var result = await CreateSut().ExecuteAsync(BuySignal);
+
+        result.Action.Should().Be("SKIP");
+        result.Reason.Should().Contain("Freies Bargeld");
+        await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task ExistingReservationForTheSameSignal_DoesNotPlaceASecondOrder()
+    {
+        // Der Fall, gegen den die Idempotenz gebaut ist: ein Reconnect schickt dasselbe Signal
+        // erneut. Ohne diese Sperre laege dieselbe Order zweimal beim Broker.
+        ArrangeHappyPath();
+        _capital.ReserveAsync(Arg.Any<BookId>(), Arg.Any<TradeSignal>(), Arg.Any<InstrumentRef>(),
+                              Arg.Any<TradeSide>(), Arg.Any<int>(), Arg.Any<int>(), Arg.Any<decimal>(),
+                              Arg.Any<OrderType>(), Arg.Any<AccountState>(), Arg.Any<string>(),
+                              Arg.Any<CancellationToken>())
+                .Returns(Task.FromResult(new ReservationService.ReserveResult(
+                    new CoreReservation { Id = 7 }, null, WasExisting: true)));
+
+        var result = await CreateSut().ExecuteAsync(BuySignal);
+
+        result.Action.Should().Be("SKIP");
+        await _broker.DidNotReceive().PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task FailedOrder_ReleasesTheReservation()
+    {
+        // Sonst bliebe das Geld bis zum Fristablauf gebunden, obwohl gar keine Order existiert.
+        ArrangeHappyPath();
+        _broker.PlaceOrderAsync(Arg.Any<OrderRequest>(), Arg.Any<CancellationToken>())
+               .Returns(Task.FromResult(OrderResult.Fail("Broker abgelehnt")));
+
+        await CreateSut().ExecuteAsync(BuySignal);
+
+        await _capital.Received(1).CancelReservationAsync(1, Arg.Any<string>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task FilledOrder_SettlesTheReservation()
+    {
+        ArrangeHappyPath();
+
+        await CreateSut().ExecuteAsync(BuySignal);
+
+        // Reserviert wurde mit Puffer, ausgefuehrt zum echten Preis: 5 x 100 = 500 fliessen als
+        // tatsaechlicher Bedarf zurueck, der Rest wird freigegeben.
+        await _capital.Received(1).SettleReservationAsync(1, 5, 500m, Arg.Any<CancellationToken>());
+    }
+
     [Fact]
     public async Task OrderFails_ReturnsError_AndDoesNotBook()
     {
@@ -150,7 +259,7 @@ public class ExecutionServiceTests
         result.Action.Should().Be("ERROR");
         result.Reason.Should().Contain("Broker abgelehnt");
         await _portfolio.DidNotReceive().RecordFillAsync(
-            Arg.Any<string>(), Arg.Any<string>(), Arg.Any<TradeSide>(),
+            Arg.Any<string>(), Arg.Any<InstrumentRef>(), Arg.Any<TradeSide>(),
             Arg.Any<int>(), Arg.Any<decimal>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<CancellationToken>());
     }
 }