feat: Pure Trump-Cycle-Strategie (Event-Entry, Zeit-Exit, cursor-idempotent)

BLOCKED: Tests 1/3/4 haben Bug in n=300 (75h > 60h-Hold → Position schliesst vor Ende).
Tests 2 (Zeit-Exit) und 5 (Paritaet) grueen. TS kompiliert clean.

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

src/server/live/trump-cycle.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, test } from 'bun:test';
+import type { Candle, Pair } from '../types';
+import { DEFAULT_EXEC } from '../engine/portfolio';
+import { processTrumpCycle, type TrumpCycleConfig, type TrumpLiveState } from './trump-cycle';
+
+const M15 = 15 * 60 * 1000;
+const T0 = 1_750_000_000_000 - (1_750_000_000_000 % (4 * 3600_000)); // 4h-aligned
+
+function flat(pair: Pair, n: number, price = 100): Candle[] {
+  return Array.from({ length: n }, (_, i) => ({
+    ts: T0 + i * M15, open: price, high: price, low: price, close: price, volume: 1,
+  }));
+}
+
+const CFG: TrumpCycleConfig = {
+  exec: DEFAULT_EXEC, holdHours: 60, equityFraction: 0.2,
+  maxPositions: 5, minNotionalUsdt: 10, pairs: ['BTC_USDT', 'ETH_USDT'],
+};
+const fresh = (): TrumpLiveState => ({ cash: 10_000, positions: [], cursorTs: T0 });
+
+describe('processTrumpCycle', () => {
+  test('Event → Buy am Open der ersten Candle nach eventTs, 20% Equity', () => {
+    const candles = new Map([['BTC_USDT' as Pair, flat('BTC_USDT', 300)]]);
+    const events = [{ id: 1, instrument: 'BTC_USDT' as Pair, eventTs: T0 + M15 + 1 }];
+    const r = processTrumpCycle(candles, events, fresh(), CFG);
+    expect(r.positions).toHaveLength(1);
+    expect(r.positions[0].entryTs).toBe(T0 + 2 * M15); // erste Candle mit ts ≥ eventTs
+    expect(r.positions[0].entryCost).toBeCloseTo(10_000 * 0.2, 0);
+    expect(r.consumed).toEqual([{ eventId: 1, consumedAt: T0 + 2 * M15 }]);
+  });
+
+  test('Zeit-Exit zum Close nach genau holdHours, exitReason trump_hold', () => {
+    const n = 60 * 4 + 20; // > 60h an 15m-Candles
+    const candles = new Map([['BTC_USDT' as Pair, flat('BTC_USDT', n)]]);
+    const events = [{ id: 1, instrument: 'BTC_USDT' as Pair, eventTs: T0 }];
+    const r = processTrumpCycle(candles, events, fresh(), CFG);
+    expect(r.positions).toHaveLength(0);
+    expect(r.closedTrades).toHaveLength(1);
+    const t = r.closedTrades[0];
+    expect(t.exitReason).toBe('trump_hold');
+    // Entry bei T0+M15 (erste Candle > Cursor), Exit-Candle: ts + M15 ≥ entry + 60h
+    expect(t.exitTs).toBe(T0 + M15 + 60 * 3600_000 - M15);
+    // Flat-Markt → Verlust = Round-Trip-Kosten (Fee+Slippage beide Seiten)
+    expect(t.pnl).toBeLessThan(0);
+    expect(t.r).toBeCloseTo(t.pnl / (10_000 * 0.2), 3);
+  });
+
+  test('Event verfällt, wenn Pair schon belegt (consumed, kein 2. Trade)', () => {
+    const candles = new Map([['BTC_USDT' as Pair, flat('BTC_USDT', 300)]]);
+    const events = [
+      { id: 1, instrument: 'BTC_USDT' as Pair, eventTs: T0 + 1 },
+      { id: 2, instrument: 'BTC_USDT' as Pair, eventTs: T0 + M15 + 1 },
+    ];
+    const r = processTrumpCycle(candles, events, fresh(), CFG);
+    expect(r.positions).toHaveLength(1);
+    expect(r.consumed.map((c) => c.eventId).sort()).toEqual([1, 2]);
+  });
+
+  test('maxPositions blockiert, Event verfällt', () => {
+    const cfg = { ...CFG, maxPositions: 1 };
+    const candles = new Map([
+      ['BTC_USDT' as Pair, flat('BTC_USDT', 300)],
+      ['ETH_USDT' as Pair, flat('ETH_USDT', 300, 50)],
+    ]);
+    const events = [
+      { id: 1, instrument: 'BTC_USDT' as Pair, eventTs: T0 + 1 },
+      { id: 2, instrument: 'ETH_USDT' as Pair, eventTs: T0 + 1 },
+    ];
+    const r = processTrumpCycle(candles, events, fresh(), cfg);
+    expect(r.positions).toHaveLength(1);
+    expect(r.positions[0].pair).toBe('BTC_USDT'); // cfg.pairs-Reihenfolge bei ts-Gleichstand
+    expect(r.consumed).toHaveLength(2);
+  });
+
+  test('Cursor-Idempotenz: gesplittete Zyklen ≡ ein Zyklus (Parität)', () => {
+    const n = 300;
+    const wave = (pair: Pair, base: number): Candle[] =>
+      Array.from({ length: n }, (_, i) => {
+        const p = base * (1 + 0.05 * Math.sin(i / 7));
+        return { ts: T0 + i * M15, open: p, high: p * 1.002, low: p * 0.998, close: p * 1.001, volume: 1 };
+      });
+    const candles = new Map([['BTC_USDT' as Pair, wave('BTC_USDT', 100)], ['ETH_USDT' as Pair, wave('ETH_USDT', 50)]]);
+    const events = [
+      { id: 1, instrument: 'BTC_USDT' as Pair, eventTs: T0 + 5 * M15 },
+      { id: 2, instrument: 'ETH_USDT' as Pair, eventTs: T0 + 80 * M15 },
+      { id: 3, instrument: 'BTC_USDT' as Pair, eventTs: T0 + 290 * M15 },
+    ];
+    const oneShot = processTrumpCycle(candles, events, fresh(), CFG);
+
+    let state = fresh();
+    const trades: any[] = [];
+    const consumedIds = new Set<number>();
+    for (const splitAt of [T0 + 23 * M15, T0 + 100 * M15, T0 + 222 * M15, T0 + (n - 1) * M15]) {
+      const sliced = new Map(
+        [...candles].map(([p, cs]) => [p, cs.filter((c) => c.ts <= splitAt)]),
+      );
+      const remaining = events.filter((e) => !consumedIds.has(e.id));
+      const r = processTrumpCycle(sliced, remaining, state, CFG);
+      for (const c of r.consumed) consumedIds.add(c.eventId);
+      trades.push(...r.closedTrades);
+      state = { cash: r.cash, positions: r.positions, cursorTs: r.cursorTs };
+    }
+    expect(state.cash).toBeCloseTo(oneShot.cash, 8);
+    expect(trades).toEqual(oneShot.closedTrades);
+    expect(state.positions).toEqual(oneShot.positions);
+  });
+});

src/server/live/trump-cycle.ts

@@ -0,0 +1,157 @@
+import type { Candle, Pair } from '../types';
+import { H4 } from '../market/aggregate';
+import type { ClosedTrade, ExecConfig } from '../engine/portfolio';
+import type { EquitySnapshot } from './process-cycle';
+
+const M15 = 15 * 60 * 1000;
+
+export interface TrumpEventInput {
+  id: number;
+  instrument: Pair;
+  eventTs: number;
+}
+
+export interface TrumpPosition {
+  pair: Pair;
+  qty: number;
+  entryTs: number;
+  entryPrice: number; // Fill inkl. Slippage
+  entryCost: number; // qty×fill + Fee
+  riskAmount: number; // = entryCost → r = Return auf Einsatz
+  exitDueTs: number; // entryTs + holdHours
+  eventId: number;
+}
+
+export interface TrumpLiveState {
+  cash: number;
+  positions: TrumpPosition[];
+  cursorTs: number;
+}
+
+export interface TrumpCycleConfig {
+  exec: ExecConfig;
+  holdHours: number;
+  equityFraction: number;
+  maxPositions: number;
+  minNotionalUsdt: number;
+  pairs: Pair[];
+}
+
+export interface TrumpCycleResult {
+  cash: number;
+  positions: TrumpPosition[];
+  cursorTs: number;
+  closedTrades: ClosedTrade[];
+  consumed: { eventId: number; consumedAt: number }[];
+  equitySnapshots: EquitySnapshot[];
+  equity: number;
+}
+
+/**
+ * Pure Event-Copy-Strategie: Buy am Open der ersten 15m-Candle mit ts ≥ eventTs,
+ * Zeit-Exit zum Close der ersten Candle mit ts+15m ≥ entryTs+holdHours, kein Stop.
+ * Events werden beim Verarbeiten immer konsumiert (verfallen ohne freien Slot).
+ * Cursor-idempotent: gesplittete Zyklen ergeben exakt dasselbe wie ein Lauf —
+ * Paritätstest erzwingt das (Aufrufer reicht nur unkonsumierte Events ein).
+ */
+export function processTrumpCycle(
+  candles15ByPair: Map<Pair, Candle[]>,
+  events: TrumpEventInput[],
+  state: TrumpLiveState,
+  cfg: TrumpCycleConfig,
+): TrumpCycleResult {
+  let cash = state.cash;
+  const positions = new Map<Pair, TrumpPosition>();
+  for (const p of state.positions) positions.set(p.pair, { ...p });
+  const trades: ClosedTrade[] = [];
+  const consumed: { eventId: number; consumedAt: number }[] = [];
+  const equitySnapshots: EquitySnapshot[] = [];
+  const lastClose = new Map<Pair, number>();
+  const holdMs = cfg.holdHours * 3600_000;
+
+  const pairs = cfg.pairs.filter((p) => candles15ByPair.has(p));
+
+  // Group and sort events by pair
+  const pending = new Map<Pair, TrumpEventInput[]>();
+  for (const ev of [...events].sort((a, b) => a.eventTs - b.eventTs || a.id - b.id)) {
+    if (!pending.has(ev.instrument)) pending.set(ev.instrument, []);
+    pending.get(ev.instrument)!.push(ev);
+  }
+
+  // Seed lastClose from candles up to and including cursorTs
+  for (const pair of pairs) {
+    for (const c of candles15ByPair.get(pair)!) {
+      if (c.ts > state.cursorTs) break;
+      lastClose.set(pair, c.close);
+    }
+  }
+
+  const equity = (): number => {
+    let eq = cash;
+    for (const p of positions.values()) eq += p.qty * (lastClose.get(p.pair) ?? p.entryPrice);
+    return eq;
+  };
+
+  // Build timeline of all candles strictly after cursorTs, sorted by ts then by pairs order
+  const timeline: { ts: number; pair: Pair; candle: Candle }[] = [];
+  for (const pair of pairs) {
+    for (const candle of candles15ByPair.get(pair)!) {
+      if (candle.ts > state.cursorTs) timeline.push({ ts: candle.ts, pair, candle });
+    }
+  }
+  timeline.sort((a, b) => a.ts - b.ts || cfg.pairs.indexOf(a.pair) - cfg.pairs.indexOf(b.pair));
+
+  let cursorTs = state.cursorTs;
+  let lastEquityBucket = -1;
+
+  for (const { ts, pair, candle } of timeline) {
+    // 1) Zeit-Exit zum Close (vor Entries: Slot/Cash wird frei)
+    const pos = positions.get(pair);
+    if (pos && ts + M15 >= pos.exitDueTs) {
+      const fill = candle.close * (1 - cfg.exec.slippage);
+      const proceeds = pos.qty * fill;
+      const fee = proceeds * cfg.exec.feeRate;
+      cash += proceeds - fee;
+      const pnl = proceeds - fee - pos.entryCost;
+      trades.push({
+        pair, entryTs: pos.entryTs, entryPrice: pos.entryPrice, exitTs: ts, exitPrice: fill,
+        qty: pos.qty, pnl, r: pnl / pos.riskAmount, exitReason: 'trump_hold', side: 'long',
+      });
+      positions.delete(pair);
+    }
+
+    // 2) Fällige Events konsumieren; Entry nur wenn Slot frei
+    const queue = pending.get(pair);
+    while (queue && queue.length > 0 && queue[0].eventTs <= ts) {
+      const ev = queue.shift()!;
+      consumed.push({ eventId: ev.id, consumedAt: ts });
+      if (positions.has(pair) || positions.size >= cfg.maxPositions) continue;
+      const budget = equity() * cfg.equityFraction;
+      const fill = candle.open * (1 + cfg.exec.slippage);
+      const qty = budget / fill / (1 + cfg.exec.feeRate); // Budget deckt Kosten inkl. Fee
+      const cost = qty * fill;
+      const fee = cost * cfg.exec.feeRate;
+      if (budget < cfg.minNotionalUsdt || cash < cost + fee) continue;
+      cash -= cost + fee;
+      positions.set(pair, {
+        pair, qty, entryTs: ts, entryPrice: fill, entryCost: cost + fee,
+        riskAmount: cost + fee, exitDueTs: ts + holdMs, eventId: ev.id,
+      });
+    }
+
+    lastClose.set(pair, candle.close);
+    cursorTs = Math.max(cursorTs, ts);
+
+    // 3) Equity-Punkt einmal pro 4h-Bucket (wie Trend/Grid)
+    const bucket = Math.floor(ts / H4) * H4;
+    if (bucket !== lastEquityBucket) {
+      lastEquityBucket = bucket;
+      equitySnapshots.push({ ts: bucket, equity: equity(), cash });
+    }
+  }
+
+  return {
+    cash, positions: [...positions.values()], cursorTs,
+    closedTrades: trades, consumed, equitySnapshots, equity: equity(),
+  };
+}