# Trump-Copy-Strategie Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Dritte Paper-Engine, die „Trump kauft"-Events (on-chain WLFI-Wallet-Käufe + Truth-Social-Erwähnungen) nachkauft, `holdHours` hält und zum Close verkauft — inkl. Event-Backfill und Event-Study vor Paper-Start.

**Architecture:** Spiegelt die GridBot-Integration: pure Cycle-Funktion (`live/trump-cycle.ts`) + DB-Engine-Wrapper (`live/trump-engine.ts`, `bot_state` id=3) + dünner Backtest-Wrapper mit Paritätstest. Neu sind die Signal-Module (`signals/`): on-chain `eth_getLogs` über öffentliche RPCs und trumpstruth.org-RSS, Events landen dedupliziert in `trump_events`.

**Tech Stack:** Bun + TypeScript, Drizzle/Postgres, keine neuen Dependencies (RSS-Parsing per Regex, RPC per `fetch`).

**Spec:** `docs/specs/2026-06-12-trump-copy-strategy-design.md`

**Verifizierte Fakten (2026-06-12, in diesem Plan fest verdrahtet):**
- ERC-20-Contracts on-chain verifiziert (symbol()+decimals() per eth_call): WBTC `0x2260fac5e5542a773aa44fbcfedf7c193bc2c599` (8), WETH `0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2` (18), LINK `0x514910771af9ca656af840dff83e8264ecf986ca` (18), AAVE `0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9` (18), ONDO `0xfaba6f8e4a5e8ab82f62fe7c39859fa577269be3` (18), ENA `0x57e114b691db790c35207b2e685d4a43181e6061` (18)
- Watchlist v1: `0x5be9a4959308a0d0c7bc0870e319314d8d957dbb` — Etherscan-Label „World Liberty: Multisig", hält ONDO (342k) + Restbestände LINK/AAVE/ENA/WBTC
- Crypto.com USDT-Paare vorhanden: LINK, AAVE, ONDO, ENA, SUI, SEI ✓ — TRX, WBTC, MOVE ✗
- trumpstruth.org: RSS `/feed` (100 Items, live), Archiv `/?page=N` (10 Posts/Seite, Markup-Klassen `status`, `status-info__body`), Posts unter `/statuses/<id>`
- Öffentlicher RPC `https://ethereum-rpc.publicnode.com` funktioniert (eth_blockNumber, eth_call)

---

### Task 1: Pair-Typ erweitern

**Files:**
- Modify: `src/server/types.ts`
- Modify: `src/server/scripts/backfill.ts:10`

- [ ] **Step 1: `types.ts` erweitern** — `PAIRS` bleibt das Trend-Universum, `Pair` wird über `ALL_PAIRS` verbreitert:

```ts
export const PAIRS = ['BTC_USDT', 'ETH_USDT', 'SOL_USDT', 'XRP_USDT'] as const;

/** Handels-Universum der Trump-Engine (Schnittmenge Mapping × Crypto.com-USDT-Paare). */
export const TRUMP_PAIRS = [
  'BTC_USDT', 'ETH_USDT', 'SOL_USDT', 'XRP_USDT',
  'LINK_USDT', 'AAVE_USDT', 'ONDO_USDT', 'ENA_USDT', 'SUI_USDT', 'SEI_USDT',
] as const;

export type Pair = (typeof PAIRS)[number] | (typeof TRUMP_PAIRS)[number];

/** Vereinigung beider Universen — für Candle-Backfill. */
export const ALL_PAIRS: readonly Pair[] = [...new Set<Pair>([...PAIRS, ...TRUMP_PAIRS])];
```

- [ ] **Step 2: `backfill.ts` auf `ALL_PAIRS` umstellen** — `import { PAIRS } from '../types'` → `import { ALL_PAIRS } from '../types'` und `for (const pair of PAIRS)` → `for (const pair of ALL_PAIRS)`.

- [ ] **Step 3: Tests laufen lassen**

Run: `bun test`
Expected: alle bestehenden Tests grün (Pair ist nur breiter geworden; Trend-Engine iteriert weiter `PAIRS`).

- [ ] **Step 4: Commit**

```bash
git add src/server/types.ts src/server/scripts/backfill.ts
git commit -m "feat: Pair-Typ um Trump-Universum erweitert (LINK/AAVE/ONDO/ENA/SUI/SEI)"
```

---

### Task 2: DB-Schema — trump_events, trump_positions, trump_signal_state + exitReason

**Files:**
- Modify: `src/server/db/schema.ts`
- Modify: `src/server/engine/portfolio.ts:34` (exitReason-Union)
- Create: Migration via `bun run db:generate`

- [ ] **Step 1: Tabellen in `schema.ts` anhängen**

```ts
/** „Trump kauft"-Events (on-chain Transfers in Watchlist-Wallets, Truth-Social-Erwähnungen). */
export const trumpEvents = pgTable(
  'trump_events',
  {
    id: serial('id').primaryKey(),
    source: text('source').notNull(), // 'onchain' | 'truth'
    token: text('token').notNull(), // Symbol, z. B. 'WBTC', 'TRX'
    instrument: varchar('instrument', { length: 16 }), // null = nicht auf Crypto.com handelbar
    eventTs: timestamp('event_ts', { withTimezone: true }).notNull(),
    ref: text('ref').notNull(), // Tx-Hash bzw. Post-URL
    notionalUsd: doublePrecision('notional_usd'), // nur onchain
    consumedAt: timestamp('consumed_at', { withTimezone: true }), // null = noch nicht von der Engine verarbeitet
    createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
  },
  (t) => [uniqueIndex('trump_events_source_ref_token').on(t.source, t.ref, t.token)],
);

/** Offene Positionen der Trump-Engine (Zeit-Exit, kein Stop). */
export const trumpPositions = pgTable('trump_positions', {
  pair: varchar('pair', { length: 16 }).primaryKey(),
  qty: doublePrecision('qty').notNull(),
  entryTs: timestamp('entry_ts', { withTimezone: true }).notNull(),
  entryPrice: doublePrecision('entry_price').notNull(),
  entryCost: doublePrecision('entry_cost').notNull(),
  riskAmount: doublePrecision('risk_amount').notNull(), // = entryCost → r = Return auf Einsatz
  exitDueTs: timestamp('exit_due_ts', { withTimezone: true }).notNull(),
  eventId: integer('event_id').notNull(),
});

/** Cursor des On-Chain-Pollers (letzter vollständig gescannter Block). */
export const trumpSignalState = pgTable('trump_signal_state', {
  id: integer('id').primaryKey(), // immer 1
  lastBlock: integer('last_block').notNull(),
  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
});
```

- [ ] **Step 2: `exitReason`-Union in `portfolio.ts` erweitern** — Zeile 34:

```ts
  exitReason: 'trailing_stop' | 'end_of_data' | 'rotation' | 'grid_tp' | 'grid_stop' | 'trump_hold';
```

- [ ] **Step 3: Migration generieren und anwenden**

Run: `bun run db:generate && bun run db:migrate`
Expected: neue Migration unter `drizzle/`, Migrate läuft fehlerfrei gegen `localhost:54320/tradekuns`.

- [ ] **Step 4: Tests + Commit**

Run: `bun test`
Expected: grün.

```bash
git add src/server/db/schema.ts src/server/engine/portfolio.ts drizzle/
git commit -m "feat: Schema für Trump-Engine (trump_events, trump_positions, trump_signal_state)"
```

---

### Task 3: signals/watchlist.ts — kuratierte Config

**Files:**
- Create: `src/server/signals/watchlist.ts`
- Test: `src/server/signals/watchlist.test.ts`

- [ ] **Step 1: Failing Test schreiben**

```ts
import { describe, expect, test } from 'bun:test';
import { TRACKED_TOKENS, COIN_KEYWORDS, WATCHED_WALLETS } from './watchlist';
import { TRUMP_PAIRS } from '../types';

describe('watchlist', () => {
  test('alle Token-Instrumente liegen im Trump-Universum', () => {
    for (const t of TRACKED_TOKENS) {
      if (t.instrument) expect(TRUMP_PAIRS).toContain(t.instrument);
    }
  });
  test('Contract-Adressen und Wallets sind lowercase (getLogs-Vergleich)', () => {
    for (const t of TRACKED_TOKENS) expect(t.contract).toBe(t.contract.toLowerCase());
    for (const w of WATCHED_WALLETS) expect(w.address).toBe(w.address.toLowerCase());
  });
  test('Keyword-Instrumente liegen im Trump-Universum oder sind null', () => {
    for (const c of COIN_KEYWORDS) {
      if (c.instrument) expect(TRUMP_PAIRS).toContain(c.instrument);
    }
  });
});
```

- [ ] **Step 2: Test fails** — Run: `bun test src/server/signals/watchlist.test.ts` → FAIL (Modul fehlt).

- [ ] **Step 3: `watchlist.ts` implementieren**

```ts
import type { Pair } from '../types';

/**
 * Kuratierte Trump-Signal-Config. Aufnahme-Kriterium Watchlist:
 * öffentlich dokumentierte Attribution (Etherscan-Label oder Presse mit Tx-Beleg),
 * Quelle als Kommentar an jedem Eintrag. Alle Adressen lowercase.
 */
export interface TrackedToken {
  symbol: string;
  contract: string;
  decimals: number;
  instrument: Pair | null; // null = Event nur loggen, nicht handeln
}

export const WATCHED_WALLETS: { address: string; label: string }[] = [
  // Etherscan-Label „World Liberty: Multisig"; hält ONDO + Reste LINK/AAVE/ENA/WBTC (on-chain verifiziert 2026-06-12)
  { address: '0x5be9a4959308a0d0c7bc0870e319314d8d957dbb', label: 'World Liberty: Multisig' },
];

// Contracts + decimals on-chain verifiziert via eth_call symbol()/decimals() am 2026-06-12
export const TRACKED_TOKENS: TrackedToken[] = [
  { symbol: 'WBTC', contract: '0x2260fac5e5542a773aa44fbcfedf7c193bc2c599', decimals: 8, instrument: 'BTC_USDT' },
  { symbol: 'WETH', contract: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', decimals: 18, instrument: 'ETH_USDT' },
  { symbol: 'LINK', contract: '0x514910771af9ca656af840dff83e8264ecf986ca', decimals: 18, instrument: 'LINK_USDT' },
  { symbol: 'AAVE', contract: '0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9', decimals: 18, instrument: 'AAVE_USDT' },
  { symbol: 'ONDO', contract: '0xfaba6f8e4a5e8ab82f62fe7c39859fa577269be3', decimals: 18, instrument: 'ONDO_USDT' },
  { symbol: 'ENA', contract: '0x57e114b691db790c35207b2e685d4a43181e6061', decimals: 18, instrument: 'ENA_USDT' },
];

export const TOKEN_BY_CONTRACT = new Map(TRACKED_TOKENS.map((t) => [t.contract, t]));

/** Truth-Social-Matching: names case-insensitive, tickers nur in Großschreibung (False-Positive-Schutz). */
export const COIN_KEYWORDS: { symbol: string; instrument: Pair | null; names: string[]; tickers: string[] }[] = [
  { symbol: 'BTC', instrument: 'BTC_USDT', names: ['bitcoin'], tickers: ['BTC'] },
  { symbol: 'ETH', instrument: 'ETH_USDT', names: ['ethereum', 'ether'], tickers: ['ETH'] },
  { symbol: 'XRP', instrument: 'XRP_USDT', names: ['ripple'], tickers: ['XRP'] },
  { symbol: 'SOL', instrument: 'SOL_USDT', names: ['solana'], tickers: ['SOL'] },
  { symbol: 'LINK', instrument: 'LINK_USDT', names: ['chainlink'], tickers: ['LINK'] },
  { symbol: 'AAVE', instrument: 'AAVE_USDT', names: ['aave'], tickers: ['AAVE'] },
  { symbol: 'ONDO', instrument: 'ONDO_USDT', names: ['ondo'], tickers: ['ONDO'] },
  { symbol: 'ENA', instrument: 'ENA_USDT', names: ['ethena'], tickers: ['ENA'] },
  { symbol: 'SUI', instrument: 'SUI_USDT', names: [], tickers: ['SUI'] }, // 'sui' lowercase zu generisch
  { symbol: 'SEI', instrument: 'SEI_USDT', names: [], tickers: ['SEI'] },
  { symbol: 'TRX', instrument: null, names: ['tron'], tickers: ['TRX'] }, // kein USDT-Paar auf Crypto.com
];

/** RPC-Endpunkte ohne Account; Reihenfolge = Priorität. */
export const RPC_URLS = [
  'https://ethereum-rpc.publicnode.com',
  'https://eth.llamarpc.com',
  'https://cloudflare-eth.com',
];

export const TRUTH_FEED_URL = 'https://trumpstruth.org/feed';
export const MIN_NOTIONAL_USD = 50_000; // Spam-/Dust-Schutz on-chain
export const TRUTH_DEDUPE_MS = 72 * 3600_000; // max. 1 Truth-Event je Coin pro 72 h
```

- [ ] **Step 4: Test passes** — Run: `bun test src/server/signals/watchlist.test.ts` → PASS.

- [ ] **Step 5: Commit**

```bash
git add src/server/signals/watchlist.ts src/server/signals/watchlist.test.ts
git commit -m "feat: Trump-Signal-Watchlist (WLFI-Multisig, verifizierte ERC-20-Contracts, Truth-Keywords)"
```

---

### Task 4: signals/onchain.ts — eth_getLogs-Scanner

**Files:**
- Create: `src/server/signals/onchain.ts`
- Test: `src/server/signals/onchain.test.ts`

- [ ] **Step 1: Failing Tests für die puren Teile (Filter-Bau + Log-Decoding)**

```ts
import { describe, expect, test } from 'bun:test';
import { buildLogFilter, decodeTransferLogs, TRANSFER_TOPIC } from './onchain';

const WALLET = '0x5be9a4959308a0d0c7bc0870e319314d8d957dbb';

describe('buildLogFilter', () => {
  test('filtert auf Token-Whitelist + Transfer-Topic + Wallet als Empfänger', () => {
    const f = buildLogFilter(100, 200);
    expect(f.fromBlock).toBe('0x64');
    expect(f.toBlock).toBe('0xc8');
    expect(f.address).toContain('0x514910771af9ca656af840dff83e8264ecf986ca'); // LINK
    expect(f.topics[0]).toBe(TRANSFER_TOPIC);
    expect(f.topics[1]).toBeNull(); // from: beliebig
    expect(f.topics[2]).toContain('0x000000000000000000000000' + WALLET.slice(2));
  });
});

describe('decodeTransferLogs', () => {
  test('dekodiert Token, Menge (decimals-skaliert), Tx-Hash, Block', () => {
    const log = {
      address: '0x514910771af9ca656af840dff83e8264ecf986ca', // LINK, 18 decimals
      topics: [
        TRANSFER_TOPIC,
        '0x000000000000000000000000aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
        '0x000000000000000000000000' + WALLET.slice(2),
      ],
      data: '0x' + (5n * 10n ** 18n).toString(16).padStart(64, '0'), // 5 LINK
      transactionHash: '0xabc',
      blockNumber: '0x64',
    };
    const out = decodeTransferLogs([log]);
    expect(out).toHaveLength(1);
    expect(out[0]).toEqual({ symbol: 'LINK', instrument: 'LINK_USDT', amount: 5, txHash: '0xabc', blockNumber: 100 });
  });
  test('ignoriert Logs unbekannter Token-Contracts', () => {
    const log = {
      address: '0x000000000000000000000000000000000000dead',
      topics: [TRANSFER_TOPIC, '0x0', '0x0'],
      data: '0x1',
      transactionHash: '0xdef',
      blockNumber: '0x65',
    };
    expect(decodeTransferLogs([log])).toHaveLength(0);
  });
});
```

- [ ] **Step 2: Test fails** — Run: `bun test src/server/signals/onchain.test.ts` → FAIL.

- [ ] **Step 3: Implementieren**

```ts
import type { Pair } from '../types';
import { RPC_URLS, TOKEN_BY_CONTRACT, TRACKED_TOKENS, WATCHED_WALLETS } from './watchlist';

/** keccak256("Transfer(address,address,uint256)") */
export const TRANSFER_TOPIC = '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef';

export interface OnchainTransfer {
  symbol: string;
  instrument: Pair | null;
  amount: number; // decimals-skaliert
  txHash: string;
  blockNumber: number;
}

export function buildLogFilter(fromBlock: number, toBlock: number) {
  return {
    fromBlock: '0x' + fromBlock.toString(16),
    toBlock: '0x' + toBlock.toString(16),
    address: TRACKED_TOKENS.map((t) => t.contract),
    topics: [
      TRANSFER_TOPIC,
      null, // from: beliebig
      WATCHED_WALLETS.map((w) => '0x000000000000000000000000' + w.address.slice(2)),
    ] as (string | string[] | null)[],
  };
}

export function decodeTransferLogs(logs: any[]): OnchainTransfer[] {
  const out: OnchainTransfer[] = [];
  for (const log of logs) {
    const token = TOKEN_BY_CONTRACT.get(String(log.address).toLowerCase());
    if (!token) continue;
    const raw = BigInt(log.data === '0x' ? '0x0' : log.data);
    out.push({
      symbol: token.symbol,
      instrument: token.instrument,
      amount: Number(raw) / 10 ** token.decimals,
      txHash: log.transactionHash,
      blockNumber: Number(BigInt(log.blockNumber)),
    });
  }
  return out;
}

/** JSON-RPC mit URL-Fallback (erst alle URLs einmal, dann Fehler). */
export async function rpc(method: string, params: unknown[]): Promise<any> {
  let lastErr: unknown;
  for (const url of RPC_URLS) {
    try {
      const res = await fetch(url, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
        signal: AbortSignal.timeout(15_000),
      });
      if (!res.ok) throw new Error(`HTTP ${res.status} (${url})`);
      const json = await res.json();
      if (json.error) throw new Error(`RPC ${method}: ${json.error.message} (${url})`);
      return json.result;
    } catch (err) {
      lastErr = err;
    }
  }
  throw lastErr;
}

export async function getBlockNumber(): Promise<number> {
  return Number(BigInt(await rpc('eth_blockNumber', [])));
}

/** Block-Timestamp in Unix ms. */
export async function getBlockTs(blockNumber: number): Promise<number> {
  const block = await rpc('eth_getBlockByNumber', ['0x' + blockNumber.toString(16), false]);
  return Number(BigInt(block.timestamp)) * 1000;
}

/** Transfers in Watchlist-Wallets im Blockbereich [fromBlock, toBlock] (inkl.), gechunkt à maxChunk. */
export async function fetchTransfers(fromBlock: number, toBlock: number, maxChunk = 5000): Promise<OnchainTransfer[]> {
  const out: OnchainTransfer[] = [];
  for (let from = fromBlock; from <= toBlock; from += maxChunk) {
    const to = Math.min(from + maxChunk - 1, toBlock);
    const logs = await rpc('eth_getLogs', [buildLogFilter(from, to)]);
    out.push(...decodeTransferLogs(logs));
  }
  return out;
}
```

- [ ] **Step 4: Tests passes** — Run: `bun test src/server/signals/onchain.test.ts` → PASS.

- [ ] **Step 5: Commit**

```bash
git add src/server/signals/onchain.ts src/server/signals/onchain.test.ts
git commit -m "feat: On-Chain-Scanner für Watchlist-Transfers (eth_getLogs, RPC-Fallback, Chunking)"
```

---

### Task 5: signals/truth.ts — RSS-Parser + Coin-Matching

**Files:**
- Create: `src/server/signals/truth.ts`
- Test: `src/server/signals/truth.test.ts`

- [ ] **Step 1: Failing Tests**

```ts
import { describe, expect, test } from 'bun:test';
import { matchCoins, parseTruthFeed } from './truth';

const XML = `<?xml version="1.0"?><rss><channel>
<item><link>https://trumpstruth.org/statuses/1</link><pubDate>Fri, 12 Jun 2026 01:49:56 +0000</pubDate><description><![CDATA[<p>Bitcoin is going to the MOON. Buy BTC!</p>]]></description></item>
<item><link>https://trumpstruth.org/statuses/2</link><pubDate>Thu, 11 Jun 2026 09:00:00 +0000</pubDate><description><![CDATA[Crooked media!]]></description></item>
</channel></rss>`;

describe('parseTruthFeed', () => {
  test('extrahiert URL, Timestamp, Klartext (Tags entfernt)', () => {
    const posts = parseTruthFeed(XML);
    expect(posts).toHaveLength(2);
    expect(posts[0].url).toBe('https://trumpstruth.org/statuses/1');
    expect(posts[0].ts).toBe(Date.parse('Fri, 12 Jun 2026 01:49:56 +0000'));
    expect(posts[0].text).toContain('Bitcoin is going to the MOON');
    expect(posts[0].text).not.toContain('<p>');
  });
});

describe('matchCoins', () => {
  test('Name case-insensitive, Ticker nur exakt groß', () => {
    expect(matchCoins('I love BITCOIN and solana')).toEqual(['BTC', 'SOL']);
    expect(matchCoins('Buy ETH now')).toEqual(['ETH']);
    expect(matchCoins('the ethics committee')).toEqual([]); // 'eth' klein/Teilwort matcht nicht
    expect(matchCoins('Das sei seitwärts')).toEqual([]); // 'SEI' nur in Großschreibung
    expect(matchCoins('THE ARENA IS PACKED')).toEqual([]); // 'ENA' nur mit Wortgrenze
    expect(matchCoins('Tron will be huge')).toEqual(['TRX']); // nicht handelbar, aber Event
  });
  test('dedupliziert Mehrfach-Erwähnungen im selben Text', () => {
    expect(matchCoins('BTC BTC Bitcoin')).toEqual(['BTC']);
  });
});
```

- [ ] **Step 2: Test fails** — Run: `bun test src/server/signals/truth.test.ts` → FAIL.

- [ ] **Step 3: Implementieren**

```ts
import { COIN_KEYWORDS } from './watchlist';

export interface TruthPost {
  url: string;
  ts: number; // Unix ms
  text: string;
}

const esc = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

/** RSS-Items per Regex (kein XML-Parser nötig — Feed ist flach und stabil). */
export function parseTruthFeed(xml: string): TruthPost[] {
  const posts: TruthPost[] = [];
  for (const item of xml.match(/<item>[\s\S]*?<\/item>/g) ?? []) {
    const url = item.match(/<link>([^<]+)<\/link>/)?.[1]?.trim();
    const pubDate = item.match(/<pubDate>([^<]+)<\/pubDate>/)?.[1];
    const descRaw = item.match(/<description>([\s\S]*?)<\/description>/)?.[1] ?? '';
    if (!url || !pubDate) continue;
    const ts = Date.parse(pubDate);
    if (Number.isNaN(ts)) continue;
    const text = descRaw
      .replace(/^<!\[CDATA\[|\]\]>$/g, '')
      .replace(/<[^>]+>/g, ' ')
      .replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"').replace(/&#39;/g, "'")
      .replace(/\s+/g, ' ')
      .trim();
    posts.push({ url, ts, text });
  }
  return posts;
}

/** Erwähnte Coins (Symbole, dedupliziert, in COIN_KEYWORDS-Reihenfolge). */
export function matchCoins(text: string): string[] {
  const hits: string[] = [];
  for (const c of COIN_KEYWORDS) {
    const nameHit = c.names.some((n) => new RegExp(`\\b${esc(n)}\\b`, 'i').test(text));
    const tickerHit = c.tickers.some((t) => new RegExp(`\\b${esc(t)}\\b`).test(text)); // case-sensitive
    if (nameHit || tickerHit) hits.push(c.symbol);
  }
  return hits;
}
```

- [ ] **Step 4: Tests passes** — Run: `bun test src/server/signals/truth.test.ts` → PASS.
  Hinweis: schlägt der `'I love BITCOIN'`-Fall fehl, prüfen ob `\b`+`i`-Flag korrekt kombiniert ist — Namen matchen case-insensitive, Ticker case-sensitive; das ist die gewollte Asymmetrie.

- [ ] **Step 5: Commit**

```bash
git add src/server/signals/truth.ts src/server/signals/truth.test.ts
git commit -m "feat: Truth-Social-RSS-Parser + Coin-Keyword-Matching"
```

---

### Task 6: signals/poller.ts — Events einsammeln und persistieren

**Files:**
- Create: `src/server/signals/poller.ts`
- Test: `src/server/signals/poller.test.ts`

Der Poller ist der einzige unpure Signal-Teil. Die testbare Logik (Notional-Filter, 72h-Dedupe) liegt in exportierten puren Helfern; die DB/HTTP-Orchestrierung bleibt dünn.

- [ ] **Step 1: Failing Tests für die puren Helfer**

```ts
import { describe, expect, test } from 'bun:test';
import { dedupeTruthEvents, passesNotional } from './poller';

describe('passesNotional', () => {
  test('amount × Preis gegen MIN_NOTIONAL_USD (50k)', () => {
    expect(passesNotional(10, 6000)).toBe(true); // 60k
    expect(passesNotional(10, 4000)).toBe(false); // 40k
    expect(passesNotional(10, null)).toBe(false); // kein Preis → kein Event
  });
});

describe('dedupeTruthEvents', () => {
  const H = 3600_000;
  test('max. ein Event je Coin pro 72h, über DB-Bestand + Batch hinweg', () => {
    const existing = new Map([['BTC', 1000 * H]]);
    const batch = [
      { symbol: 'BTC', ts: 1000 * H + 71 * H, url: 'u1' }, // < 72h nach Bestand → raus
      { symbol: 'BTC', ts: 1000 * H + 73 * H, url: 'u2' }, // ≥ 72h → bleibt
      { symbol: 'BTC', ts: 1000 * H + 74 * H, url: 'u3' }, // < 72h nach u2 → raus
      { symbol: 'ETH', ts: 1000 * H, url: 'u4' }, // anderer Coin → bleibt
    ];
    expect(dedupeTruthEvents(batch, existing).map((e) => e.url)).toEqual(['u2', 'u4']);
  });
});
```

- [ ] **Step 2: Test fails** — Run: `bun test src/server/signals/poller.test.ts` → FAIL.

- [ ] **Step 3: Implementieren**

```ts
import { and, desc, eq, inArray } from 'drizzle-orm';
import { db } from '../db/client';
import { trumpEvents, trumpSignalState } from '../db/schema';
import { getCandles } from '../market/candle-store';
import { fetchTransfers, getBlockNumber, getBlockTs } from './onchain';
import { matchCoins, parseTruthFeed } from './truth';
import { COIN_KEYWORDS, MIN_NOTIONAL_USD, TRUTH_DEDUPE_MS, TRUTH_FEED_URL } from './watchlist';

const M15 = 15 * 60 * 1000;
/** Obergrenze Blöcke je Zyklus (~4 getLogs-Calls); Ethereum macht ~25 Blöcke/5min — reichlich Aufholpuffer. */
const MAX_BLOCKS_PER_CYCLE = 20_000;

export function passesNotional(amount: number, price: number | null): boolean {
  return price !== null && amount * price >= MIN_NOTIONAL_USD;
}

/** existing: Coin → eventTs des jüngsten Truth-Events in der DB. Batch muss ts-aufsteigend sein. */
export function dedupeTruthEvents(
  batch: { symbol: string; ts: number; url: string }[],
  existing: Map<string, number>,
): { symbol: string; ts: number; url: string }[] {
  const lastTs = new Map(existing);
  const out: { symbol: string; ts: number; url: string }[] = [];
  for (const e of [...batch].sort((a, b) => a.ts - b.ts)) {
    const prev = lastTs.get(e.symbol);
    if (prev !== undefined && e.ts - prev < TRUTH_DEDUPE_MS) continue;
    lastTs.set(e.symbol, e.ts);
    out.push(e);
  }
  return out;
}

/** Letzter 15m-Close ≤ ts als USD-Proxy (USDT≈USD). null wenn keine Candle vorhanden. */
async function priceAt(instrument: string, ts: number): Promise<number | null> {
  const candles = await getCandles(instrument as any, ts - 24 * 3600_000, ts + M15);
  return candles.length > 0 ? candles[candles.length - 1].close : null;
}

export async function pollOnchain(): Promise<number> {
  const head = await getBlockNumber();
  let [state] = await db.select().from(trumpSignalState).where(eq(trumpSignalState.id, 1));
  if (!state) {
    // Erster Lauf: ab jetzt scannen (Historie macht trump-backfill)
    await db.insert(trumpSignalState).values({ id: 1, lastBlock: head });
    return 0;
  }
  const from = state.lastBlock + 1;
  const to = Math.min(head, state.lastBlock + MAX_BLOCKS_PER_CYCLE);
  if (from > to) return 0;

  const transfers = await fetchTransfers(from, to);
  let inserted = 0;
  const blockTs = new Map<number, number>();
  for (const t of transfers) {
    if (!blockTs.has(t.blockNumber)) blockTs.set(t.blockNumber, await getBlockTs(t.blockNumber));
    const ts = blockTs.get(t.blockNumber)!;
    const price = t.instrument ? await priceAt(t.instrument, ts) : null;
    if (!passesNotional(t.amount, price)) continue;
    await db
      .insert(trumpEvents)
      .values({
        source: 'onchain', token: t.symbol, instrument: t.instrument,
        eventTs: new Date(ts), ref: t.txHash, notionalUsd: t.amount * price!,
      })
      .onConflictDoNothing();
    inserted++;
  }
  await db.update(trumpSignalState).set({ lastBlock: to, updatedAt: new Date() }).where(eq(trumpSignalState.id, 1));
  return inserted;
}

export async function pollTruth(): Promise<number> {
  const res = await fetch(TRUTH_FEED_URL, { signal: AbortSignal.timeout(15_000) });
  if (!res.ok) throw new Error(`trumpstruth HTTP ${res.status}`);
  const posts = parseTruthFeed(await res.text());

  const candidates: { symbol: string; ts: number; url: string }[] = [];
  for (const p of posts) for (const symbol of matchCoins(p.text)) candidates.push({ symbol, ts: p.ts, url: p.url });
  if (candidates.length === 0) return 0;

  const symbols = [...new Set(candidates.map((c) => c.symbol))];
  const existing = new Map<string, number>();
  for (const s of symbols) {
    const [row] = await db
      .select({ eventTs: trumpEvents.eventTs })
      .from(trumpEvents)
      .where(and(eq(trumpEvents.source, 'truth'), eq(trumpEvents.token, s)))
      .orderBy(desc(trumpEvents.eventTs))
      .limit(1);
    if (row) existing.set(s, row.eventTs.getTime());
  }

  let inserted = 0;
  for (const e of dedupeTruthEvents(candidates, existing)) {
    const kw = COIN_KEYWORDS.find((c) => c.symbol === e.symbol)!;
    await db
      .insert(trumpEvents)
      .values({ source: 'truth', token: e.symbol, instrument: kw.instrument, eventTs: new Date(e.ts), ref: e.url })
      .onConflictDoNothing();
    inserted++;
  }
  return inserted;
}

/** Beide Quellen, Fehler isoliert (eine tote Quelle stoppt die andere nicht). */
export async function pollSignals(): Promise<void> {
  const results = await Promise.allSettled([pollOnchain(), pollTruth()]);
  for (const r of results) {
    if (r.status === 'rejected') console.error('Signal-Poller-Fehler:', r.reason);
  }
}
```

- [ ] **Step 4: Tests passes** — Run: `bun test src/server/signals/poller.test.ts` → PASS.

- [ ] **Step 5: Commit**

```bash
git add src/server/signals/poller.ts src/server/signals/poller.test.ts
git commit -m "feat: Signal-Poller (on-chain Cursor-Scan + Truth-RSS, Notional-Filter, 72h-Dedupe)"
```

---

### Task 7: live/trump-cycle.ts — pure Cycle-Funktion (Kernstück)

**Files:**
- Create: `src/server/live/trump-cycle.ts`
- Test: `src/server/live/trump-cycle.test.ts`

Semantik (Spec §4): Event mit `eventTs ≤ candle.ts` → Buy zum Open dieser Candle (= „nächster 15m-Open nach dem Event"). Zeit-Exit zum Close der ersten Candle mit `ts + 15min ≥ entryTs + holdHours`. Events werden beim Verarbeiten immer konsumiert — auch wenn kein Slot frei/Pair belegt (verfallen, kein Nachholen). Exits vor Entries je Candle (Slot/Cash wird frei).

- [ ] **Step 1: Failing Tests**

```ts
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', 200)]]);
    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 / t.qty / 100 / (1 + DEFAULT_EXEC.slippage) / (1 + DEFAULT_EXEC.feeRate), 3);
  });

  test('Event verfällt, wenn Pair schon belegt (consumed, kein 2. Trade)', () => {
    const candles = new Map([['BTC_USDT' as Pair, flat('BTC_USDT', 200)]]);
    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', 200)],
      ['ETH_USDT' as Pair, flat('ETH_USDT', 200, 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);
  });
});
```

- [ ] **Step 2: Test fails** — Run: `bun test src/server/live/trump-cycle.test.ts` → FAIL.

- [ ] **Step 3: Implementieren**

```ts
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));

  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);
  }

  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;
  };

  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(),
  };
}
```

Achtung beim `entryCost`-Test in Step 1: mit der `/(1+feeRate)`-Normierung ist `entryCost` exakt das Budget (= 20 % Equity) — `toBeCloseTo(2000, 0)` muss passen. Falls beim zweiten Test die `r`-Formel zickt: `r = pnl / entryCost`, der Erwartungswert im Test ist äquivalent umgeformt; im Zweifel den Test-Erwartungswert auf `t.pnl / (10_000 * 0.2)` vereinfachen.

- [ ] **Step 4: Tests passes** — Run: `bun test src/server/live/trump-cycle.test.ts` → PASS (insbesondere der Paritätstest).

- [ ] **Step 5: Commit**

```bash
git add src/server/live/trump-cycle.ts src/server/live/trump-cycle.test.ts
git commit -m "feat: Pure Trump-Cycle-Strategie (Event-Entry, Zeit-Exit, cursor-idempotent)"
```

---

### Task 8: backtest/trump.ts — dünner Backtest-Wrapper

**Files:**
- Create: `src/server/backtest/trump.ts`

Kein eigener Test nötig: Der Wrapper ruft `processTrumpCycle` einmal von frischem State auf (DRY — eine Implementierung für Live und Backtest); der Paritätstest in Task 7 deckt die Cursor-Semantik ab.

- [ ] **Step 1: Implementieren**

```ts
import type { Candle, Pair } from '../types';
import { processTrumpCycle, type TrumpCycleConfig, type TrumpCycleResult, type TrumpEventInput } from '../live/trump-cycle';

/** Backtest = ein Cycle-Lauf von frischem State. Gleicher Code-Pfad wie Live (Spec §5). */
export function runTrumpBacktest(
  candles15ByPair: Map<Pair, Candle[]>,
  events: TrumpEventInput[],
  startCapital: number,
  cfg: TrumpCycleConfig,
): TrumpCycleResult {
  let minTs = Infinity;
  for (const cs of candles15ByPair.values()) if (cs.length > 0) minTs = Math.min(minTs, cs[0].ts);
  return processTrumpCycle(candles15ByPair, events, { cash: startCapital, positions: [], cursorTs: minTs - 1 }, cfg);
}
```

- [ ] **Step 2: Typecheck + Commit**

Run: `bunx tsc --noEmit`
Expected: keine Fehler.

```bash
git add src/server/backtest/trump.ts
git commit -m "feat: Trump-Backtest-Wrapper (gleicher Code-Pfad wie Live)"
```

---

### Task 9: live/trump-engine.ts — DB-Wrapper (Engine Nr. 3)

**Files:**
- Create: `src/server/live/trump-engine.ts`

Spiegelt `grid-engine.ts` (`src/server/live/grid-engine.ts` als Vorlage daneben legen). Kein eigener Unit-Test (wie GridEngine: DB-Glue, die pure Logik ist in Task 7 getestet).

- [ ] **Step 1: Implementieren**

```ts
import { eq, inArray, isNull, isNotNull, and } from 'drizzle-orm';
import { db } from '../db/client';
import { botState, equitySnapshots, paperTrades, trumpEvents, trumpPositions } from '../db/schema';
import { getCandles } from '../market/candle-store';
import { DEFAULT_EXEC } from '../engine/portfolio';
import { pollSignals } from '../signals/poller';
import { TRUMP_PAIRS } from '../types';
import type { Candle, Pair } from '../types';
import {
  processTrumpCycle,
  type TrumpCycleConfig,
  type TrumpCycleResult,
  type TrumpEventInput,
  type TrumpLiveState,
} from './trump-cycle';

const M15 = 15 * 60 * 1000;
const BOT_STATE_ID = 3; // 1 = Trend, 2 = Grid
const START_CAPITAL = 10_000;
/** Keine Indikatoren — Warmup nur für lastClose-Seed (Equity offener Positionen). */
const WARMUP_BARS_15M = 8;

export const TRUMP_CYCLE_CONFIG: TrumpCycleConfig = {
  exec: DEFAULT_EXEC,
  holdHours: 60, // Default lt. Spec; finaler Wert kommt aus der Event-Study
  equityFraction: 0.2,
  maxPositions: 5,
  minNotionalUsdt: 10,
  pairs: [...TRUMP_PAIRS],
};

export interface TrumpEngineStatus {
  lastCycleAt: number | null;
  lastCycleOk: boolean;
  lastError: string | null;
  cursorTs: number | null;
}

/**
 * Dritte Paper-Engine (Trump-Copy). Läuft NACH Trend+Grid im Zyklus;
 * holt Candles für die Nicht-Trend-Pairs selbst nach (Gap-Fetch der
 * Trend-Engine deckt nur PAIRS ab) — siehe Task 10.
 */
export class TrumpEngine {
  status: TrumpEngineStatus = { lastCycleAt: null, lastCycleOk: true, lastError: null, cursorTs: null };
  private cycling = false;

  async init(): Promise<void> {
    const [row] = await db.select().from(botState).where(eq(botState.id, BOT_STATE_ID));
    if (row) {
      this.status.cursorTs = row.cursorTs.getTime();
      return;
    }
    const cursor = Math.floor(Date.now() / M15) * M15 - M15;
    await db.insert(botState).values({
      id: BOT_STATE_ID,
      cash: START_CAPITAL,
      startCapital: START_CAPITAL,
      cursorTs: new Date(cursor),
    });
    this.status.cursorTs = cursor;
  }

  async runCycle(): Promise<void> {
    if (this.cycling) return;
    this.cycling = true;
    try {
      await pollSignals(); // non-fatal intern; wirft nicht

      const state = await this.loadState();
      const from = state.cursorTs - WARMUP_BARS_15M * M15;
      const candles15 = new Map<Pair, Candle[]>();
      for (const pair of TRUMP_CYCLE_CONFIG.pairs) {
        candles15.set(pair, await getCandles(pair, from));
      }
      const events = await this.loadOpenEvents();
      const result = processTrumpCycle(candles15, events, state, TRUMP_CYCLE_CONFIG);
      await this.persist(result);
      this.status.lastCycleAt = Date.now();
      this.status.lastCycleOk = true;
      this.status.lastError = null;
      this.status.cursorTs = result.cursorTs;
    } catch (err) {
      this.status.lastCycleAt = Date.now();
      this.status.lastCycleOk = false;
      this.status.lastError = err instanceof Error ? err.message : String(err);
      console.error('Trump-Zyklus fehlgeschlagen:', err);
    } finally {
      this.cycling = false;
    }
  }

  private async loadState(): Promise<TrumpLiveState> {
    const [row] = await db.select().from(botState).where(eq(botState.id, BOT_STATE_ID));
    if (!row) throw new Error('bot_state (trump) fehlt — init() nicht gelaufen?');
    const posRows = await db.select().from(trumpPositions);
    return {
      cash: row.cash,
      cursorTs: row.cursorTs.getTime(),
      positions: posRows.map((p) => ({
        pair: p.pair as Pair,
        qty: p.qty,
        entryTs: p.entryTs.getTime(),
        entryPrice: p.entryPrice,
        entryCost: p.entryCost,
        riskAmount: p.riskAmount,
        exitDueTs: p.exitDueTs.getTime(),
        eventId: p.eventId,
      })),
    };
  }

  private async loadOpenEvents(): Promise<TrumpEventInput[]> {
    const rows = await db
      .select()
      .from(trumpEvents)
      .where(and(isNull(trumpEvents.consumedAt), isNotNull(trumpEvents.instrument)));
    return rows.map((r) => ({ id: r.id, instrument: r.instrument as Pair, eventTs: r.eventTs.getTime() }));
  }

  private async persist(result: TrumpCycleResult): Promise<void> {
    await db.transaction(async (tx) => {
      await tx.delete(trumpPositions);
      for (const p of result.positions) {
        await tx.insert(trumpPositions).values({
          pair: p.pair,
          qty: p.qty,
          entryTs: new Date(p.entryTs),
          entryPrice: p.entryPrice,
          entryCost: p.entryCost,
          riskAmount: p.riskAmount,
          exitDueTs: new Date(p.exitDueTs),
          eventId: p.eventId,
        });
      }
      if (result.closedTrades.length > 0) {
        await tx.insert(paperTrades).values(
          result.closedTrades.map((t) => ({
            bot: 'trump',
            pair: t.pair,
            side: t.side,
            entryTs: new Date(t.entryTs),
            entryPrice: t.entryPrice,
            exitTs: new Date(t.exitTs),
            exitPrice: t.exitPrice,
            qty: t.qty,
            pnl: t.pnl,
            r: t.r,
            exitReason: t.exitReason,
          })),
        );
      }
      for (const c of result.consumed) {
        await tx.update(trumpEvents).set({ consumedAt: new Date(c.consumedAt) }).where(eq(trumpEvents.id, c.eventId));
      }
      for (const s of result.equitySnapshots) {
        const row = { bot: 'trump', ts: new Date(s.ts), equity: s.equity, cash: s.cash };
        await tx
          .insert(equitySnapshots)
          .values(row)
          .onConflictDoUpdate({ target: [equitySnapshots.bot, equitySnapshots.ts], set: row });
      }
      await tx
        .update(botState)
        .set({ cash: result.cash, cursorTs: new Date(result.cursorTs), updatedAt: new Date() })
        .where(eq(botState.id, BOT_STATE_ID));
    });
  }
}
```

(Unbenutzte Importe wie `inArray` entfernen, falls der Linter meckert.)

- [ ] **Step 2: Typecheck + alle Tests**

Run: `bunx tsc --noEmit && bun test`
Expected: grün.

- [ ] **Step 3: Commit**

```bash
git add src/server/live/trump-engine.ts
git commit -m "feat: TrumpEngine als dritte Paper-Engine (bot_state id=3, Poller im Zyklus)"
```

---

### Task 10: Candle-Nachschub für neue Pairs + Loop-Wiring + API

**Files:**
- Modify: `src/server/index.ts`
- Modify: `src/server/api/server.ts`

Die Trend-Engine gap-fetcht nur `PAIRS` — die Trump-Engine braucht 15m-Candles auch für LINK/AAVE/ONDO/ENA/SUI/SEI. Vor dem Wiring prüfen, wie `LiveEngine.runCycle` den Gap-Fetch macht (`src/server/live/engine.ts` lesen) und das Muster für die Trump-Pairs übernehmen — entweder als kleiner Gap-Fetcher in `TrumpEngine.runCycle` (vor `loadState`, per `fetchCandles(pair, '15m', count, …)` + `insertCandles` aus `market/`), oder durch Erweiterung des bestehenden Gap-Fetch auf `ALL_PAIRS`, falls er zentral sitzt. **Entscheidungskriterium:** minimaler Eingriff in die Trend-Engine; im Zweifel eigener Gap-Fetch in der TrumpEngine (Candle-Lücke je Pair seit `cursorTs − Warmup` füllen, wie `backfill.ts` nur vorwärts).

- [ ] **Step 1: Gap-Fetch für Trump-Pairs implementieren** (Muster aus `live/engine.ts` übernehmen, Methode `private async fillCandleGaps()` in `TrumpEngine`, Aufruf zu Beginn von `runCycle` nach `pollSignals`).

- [ ] **Step 2: `index.ts` erweitern**

```ts
import { env } from './config';
import { LiveEngine } from './live/engine';
import { GridEngine } from './live/grid-engine';
import { TrumpEngine } from './live/trump-engine';
import { createServer } from './api/server';

const CYCLE_MS = 5 * 60 * 1000;

const engine = new LiveEngine();
const gridEngine = new GridEngine();
const trumpEngine = new TrumpEngine();
await engine.init();
await gridEngine.init();
await trumpEngine.init();
createServer(engine, gridEngine, trumpEngine, env.PORT);
console.log(`trade-kuns Live-Paper-Engines (trend + grid + trump) laufen auf :${env.PORT}`);

// Grid/Trump laufen nach der Trend-Engine — deren Gap-Fetch füllt die Candle-DB für PAIRS.
const cycle = async () => {
  await engine.runCycle();
  await gridEngine.runCycle();
  await trumpEngine.runCycle();
};
void cycle();
setInterval(() => void cycle(), CYCLE_MS);
```

- [ ] **Step 3: `/api/trump` in `server.ts`** — Signatur `createServer(engine, gridEngine, trumpEngine, port)` erweitern, neuen `case` analog zu `/api/grid` einbauen (bestehendes Muster im File übernehmen):

```ts
case '/api/trump': {
  const [state] = await db.select().from(botState).where(eq(botState.id, 3));
  const positions = await db.select().from(trumpPositions);
  const events = await db.select().from(trumpEvents).orderBy(desc(trumpEvents.eventTs)).limit(50);
  return Response.json({
    status: trumpEngine.status,
    cash: state?.cash ?? null,
    startCapital: state?.startCapital ?? null,
    positions,
    events,
  });
}
```

Trades und Equity-Kurve laufen über die bestehenden Endpunkte (`/api/trades?bot=trump`, Equity-Snapshots `bot='trump'`) — prüfen, dass der `bot`-Queryparameter in `/api/trades` generisch ist (bei Grid funktioniert er bereits).

- [ ] **Step 4: Smoke-Test lokal**

Run: `bun run start` (kurz laufen lassen), dann `curl -s localhost:8080/api/trump`
Expected: JSON mit `status.lastCycleOk: true`, leere `positions`/`events` (Poller startet ab aktuellem Block; ggf. erste Truth-Events, falls der Feed gerade Coins erwähnt). Server wieder stoppen.
Hinweis: Wenn die curl-Sperre des context-mode-Hooks greift, den Check per `mcp execute` (fetch) machen.

- [ ] **Step 5: Alle Tests + Commit**

Run: `bun test`
Expected: grün.

```bash
git add src/server/index.ts src/server/api/server.ts src/server/live/trump-engine.ts
git commit -m "feat: Trump-Engine in Loop und API verdrahtet (/api/trump, Gap-Fetch neue Pairs)"
```

---

### Task 11: Dashboard — dritter Tab „Trump"

**Files:**
- Modify: `public/index.html`

Bestehende Struktur: `<nav class="tabs">` (Zeile ~60), Sections `#tab-trading`/`#tab-grid`, `showTab()` (Zeile ~352), Daten-Loader mit `Promise.all`-fetch (Zeile ~403). Exakt das Grid-Muster kopieren:

- [ ] **Step 1: Tab-Button + Section ergänzen**

```html
<button class="tab" data-tab="trump">Trump</button>
```

```html
<section id="tab-trump" hidden>
  <div class="cards" id="trump-cards"></div>
  <h2>Offene Positionen</h2>
  <div id="trump-positions"></div>
  <h2>Events</h2>
  <div id="trump-events"></div>
  <h2>Trades</h2>
  <div id="trump-trades"></div>
</section>
```

(`.cards`-Markup an die bestehenden Karten im Trading-Tab angleichen — Klassen aus dem File übernehmen.)

- [ ] **Step 2: `showTab` erweitern**

```js
document.getElementById('tab-trump').hidden = name !== 'trump';
```

- [ ] **Step 3: Loader erweitern** — im `Promise.all` zusätzlich `fetch('/api/trump').then(r => r.json())` und `fetch('/api/trades?bot=trump&limit=200').then(r => r.json())`; Render-Code analog Grid-Tab:

```js
// ── Trump-Tab ──
document.getElementById('trump-cards').innerHTML = cards([
  ['Equity', fmtUsd(trump.cash + trumpPositionsValue(trump.positions))],
  ['Cash', fmtUsd(trump.cash)],
  ['Offene Positionen', trump.positions.length],
  ['Events gesamt', trump.events.length >= 50 ? '50+' : trump.events.length],
]);
document.getElementById('trump-positions').innerHTML = table(
  ['Pair', 'Entry', 'Preis', 'Qty', 'Exit fällig'],
  trump.positions.map(p => `<tr><td>${p.pair}</td><td>${fmtTs(p.entryTs)}</td><td>${fmtNum(p.entryPrice)}</td><td>${fmtNum(p.qty)}</td><td>${fmtTs(p.exitDueTs)}</td></tr>`),
  'Keine offenen Positionen',
);
document.getElementById('trump-events').innerHTML = table(
  ['Zeit', 'Quelle', 'Coin', 'Instrument', 'Notional', 'Ref'],
  trump.events.map(e => `<tr><td>${fmtTs(e.eventTs)}</td><td>${e.source}</td><td>${e.token}</td><td>${e.instrument ?? '—'}</td><td>${e.notionalUsd ? fmtUsd(e.notionalUsd) : '—'}</td><td><a href="${e.source === 'onchain' ? 'https://etherscan.io/tx/' + e.ref : e.ref}" target="_blank">↗</a></td></tr>`),
  'Noch keine Events',
);
```

Helfer (`cards`, `table`, `fmtUsd`, `fmtTs`, `fmtNum`) existieren bzw. sind den vorhandenen Funktionen im File nachzubilden — vorhandene Namen verwenden, nichts duplizieren. Trades-Tabelle wie im Grid-Tab aus `/api/trades?bot=trump` rendern.

- [ ] **Step 4: Visuell prüfen** — `bun run start`, Browser/Playwright auf `localhost:8080`, Tab „Trump" öffnen: Karten + leere Tabellen sichtbar, keine JS-Konsole-Fehler.

- [ ] **Step 5: Commit**

```bash
git add public/index.html
git commit -m "feat: Dashboard-Tab Trump (Events, Positionen, Trades)"
```

---

### Task 12: Candle- und Event-Backfill (Phase-1-Daten)

**Files:**
- Create: `src/server/scripts/trump-backfill.ts`
- Modify: `package.json` (Script `trump:backfill`)

- [ ] **Step 1: Candle-Backfill für neue Pairs laufen lassen** (nutzt Task 1)

Run: `bun run backfill`
Expected: Coverage-Zeilen auch für LINK/AAVE/ONDO/ENA/SUI/SEI_USDT (jüngere Coins haben kürzere Historie — ENA/ONDO ab 2024, das ist okay). Dauert wegen Rate-Limit-Sleeps einige Minuten.

- [ ] **Step 2: `trump-backfill.ts` schreiben** — historische Events rekonstruieren:

```ts
import { parseArgs } from 'util';
import { sql, db } from '../db/client';
import { trumpEvents } from '../db/schema';
import { fetchTransfers, getBlockNumber, getBlockTs } from '../signals/onchain';
import { dedupeTruthEvents, passesNotional } from '../signals/poller';
import { matchCoins } from '../signals/truth';
import { COIN_KEYWORDS } from '../signals/watchlist';
import { getCandles } from '../market/candle-store';

const M15 = 15 * 60 * 1000;
const { values: args } = parseArgs({
  options: {
    'from-block': { type: 'string', default: '20600000' }, // ≈ Sep 2024, vor den ersten WLFI-Treasury-Käufen
    'truth-pages': { type: 'string', default: '300' },
  },
});

// ── On-chain ──
const fromBlock = Number(args['from-block']);
const head = await getBlockNumber();
console.log(`On-chain-Scan Block ${fromBlock} → ${head} (${head - fromBlock} Blöcke, ~${Math.ceil((head - fromBlock) / 5000)} Requests)`);
let onchainCount = 0;
const STEP = 5000;
for (let from = fromBlock; from <= head; from += STEP) {
  const to = Math.min(from + STEP - 1, head);
  const transfers = await fetchTransfers(from, to, STEP);
  for (const t of transfers) {
    const ts = await getBlockTs(t.blockNumber);
    let price: number | null = null;
    if (t.instrument) {
      const cs = await getCandles(t.instrument, ts - 24 * 3600_000, ts + M15);
      price = cs.length > 0 ? cs[cs.length - 1].close : null;
    }
    if (!passesNotional(t.amount, price)) continue;
    await db.insert(trumpEvents).values({
      source: 'onchain', token: t.symbol, instrument: t.instrument,
      eventTs: new Date(ts), ref: t.txHash, notionalUsd: t.amount * price!,
    }).onConflictDoNothing();
    onchainCount++;
    console.log(`  ${new Date(ts).toISOString()} ${t.symbol} ${t.amount.toFixed(2)} (~$${Math.round(t.amount * price!)}) ${t.txHash}`);
  }
  if ((from - fromBlock) % (STEP * 20) === 0) console.log(`  … Block ${to}`);
  await Bun.sleep(150);
}
console.log(`On-chain: ${onchainCount} Events`);

// ── Truth (best effort, letzte N Archiv-Seiten à 10 Posts) ──
const pages = Number(args['truth-pages']);
const candidates: { symbol: string; ts: number; url: string }[] = [];
let oldestTs = Infinity;
for (let p = 1; p <= pages; p++) {
  const res = await fetch(`https://trumpstruth.org/?page=${p}`, { signal: AbortSignal.timeout(20_000) });
  if (!res.ok) { console.warn(`Seite ${p}: HTTP ${res.status} — Truth-Scan endet hier`); break; }
  const html = await res.text();
  // Status-Blöcke: Link + Text; Markup-Klassen am 2026-06-12 verifiziert (status, status-info__body)
  const blocks = html.split(/class="status\b/).slice(1);
  for (const block of blocks) {
    const url = block.match(/href="(https:\/\/trumpstruth\.org\/statuses\/\d+)"/)?.[1];
    const timeRaw = block.match(/datetime="([^"]+)"/)?.[1] ?? block.match(/<time[^>]*>([^<]+)<\/time>/)?.[1];
    const body = block.match(/status-info__body[^>]*>([\s\S]*?)<\/div>/)?.[1] ?? '';
    if (!url || !timeRaw) continue;
    const ts = Date.parse(timeRaw);
    if (Number.isNaN(ts)) continue;
    oldestTs = Math.min(oldestTs, ts);
    const text = body.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim();
    for (const symbol of matchCoins(text)) candidates.push({ symbol, ts, url });
  }
  await Bun.sleep(300);
}
console.log(`Truth-Scan: ${candidates.length} Kandidaten, ältester Post ${oldestTs === Infinity ? '—' : new Date(oldestTs).toISOString()}`);
let truthCount = 0;
for (const e of dedupeTruthEvents(candidates, new Map())) {
  const kw = COIN_KEYWORDS.find((c) => c.symbol === e.symbol)!;
  await db.insert(trumpEvents).values({
    source: 'truth', token: e.symbol, instrument: kw.instrument, eventTs: new Date(e.ts), ref: e.url,
  }).onConflictDoNothing();
  truthCount++;
}
console.log(`Truth: ${truthCount} Events (Historie nur letzte ${pages} Seiten — Lücke davor ist bekannt und akzeptiert)`);
await sql.end();
```

**Wichtig:** Die History-Events sind nach dem Backfill `consumedAt = null` — damit die Live-Engine sie nicht alle „nachkauft", direkt nach dem Backfill als konsumiert markieren (Teil von Step 4). Die Event-Study (Task 13) liest Events unabhängig von `consumedAt`.

Falls das Archiv-Markup vom Parser abweicht (Scrape liefert 0 Kandidaten trotz HTTP 200): eine Seite dumpen (`console.log(html.slice(0, 3000))`), Selektoren anpassen — die Klassen `status`, `status-info__body` und `/statuses/<id>`-Links existieren (verifiziert), nur die genaue Verschachtelung kann abweichen.

- [ ] **Step 3: package.json-Script ergänzen**

```json
"trump:backfill": "bun run src/server/scripts/trump-backfill.ts",
```

- [ ] **Step 4: Backfill ausführen + History als konsumiert markieren**

Run: `bun run trump:backfill` (dauert: ~1.1k getLogs-Requests + 300 Archiv-Seiten ≈ 10–20 min)
Expected: On-chain-Events mit plausiblen WLFI-Käufen (ETH/WBTC/LINK/AAVE/ONDO/ENA, Notional ≥ 50k), Truth-Events für BTC etc.
Danach (psql oder bun-Skript-Einzeiler):

```bash
PGPASSWORD=… psql "$DATABASE_URL" -c "UPDATE trump_events SET consumed_at = now() WHERE consumed_at IS NULL AND event_ts < now() - interval '1 hour';"
```

Plausibilitätscheck: 3 Stichproben-Tx-Hashes auf etherscan.io öffnen — sind das echte WLFI-Eingänge? Anzahl Events pro Quelle notieren (fließt in die Study-Doku). **Wenn 0 on-chain Events gefunden werden:** Watchlist zu schmal (Treasury nutzt weitere Wallets) — dann auf Etherscan die eingehenden Token-Tx der Multisig ansehen, dokumentierte Absender-/Schwester-Wallets (z. B. weitere „World Liberty"-Labels) ergänzen und Backfill erneut laufen lassen. Jede Ergänzung mit Label-Quelle als Kommentar in `watchlist.ts`.

- [ ] **Step 5: Commit**

```bash
git add src/server/scripts/trump-backfill.ts package.json
git commit -m "feat: Trump-Event-Backfill (on-chain History + Truth-Archiv best effort)"
```

---

### Task 13: Event-Study + Haltedauer-Entscheid

**Files:**
- Create: `src/server/scripts/trump-event-study.ts`
- Create: `docs/event-study-trump-2026-06-12.md` (Output)
- Modify: `package.json` (Script `trump:study`)
- Modify: `src/server/live/trump-engine.ts` (finales `holdHours`)

- [ ] **Step 1: Study-Skript schreiben**

```ts
import { isNotNull } from 'drizzle-orm';
import { db, sql } from '../db/client';
import { trumpEvents } from '../db/schema';
import { getCandles } from '../market/candle-store';
import { DEFAULT_EXEC } from '../engine/portfolio';
import type { Pair } from '../types';

const M15 = 15 * 60 * 1000;
const HORIZONS_H = [24, 48, 60, 72, 120];
const COST = (1 - DEFAULT_EXEC.slippage) * (1 - DEFAULT_EXEC.feeRate) / ((1 + DEFAULT_EXEC.slippage) * (1 + DEFAULT_EXEC.feeRate)); // Round-Trip-Faktor

const events = await db.select().from(trumpEvents).where(isNotNull(trumpEvents.instrument));
type Row = { source: string; horizon: number; ret: number };
const rows: Row[] = [];
const baselines = new Map<string, Map<number, number>>(); // instrument → horizon → mean ret

for (const ev of events) {
  const instrument = ev.instrument as Pair;
  const evTs = ev.eventTs.getTime();
  const candles = await getCandles(instrument, evTs - M15, evTs + 130 * 3600_000);
  const entryIdx = candles.findIndex((c) => c.ts >= evTs);
  if (entryIdx < 0) continue;
  const entry = candles[entryIdx].open;
  for (const h of HORIZONS_H) {
    const exitTs = candles[entryIdx].ts + h * 3600_000;
    const exit = candles.findLast((c) => c.ts <= exitTs);
    if (!exit || exit.ts < exitTs - 2 * M15) continue; // Horizont nicht abgedeckt
    rows.push({ source: ev.source, horizon: h, ret: (exit.close / entry) * COST - 1 });
  }
  // Baseline je Instrument einmalig: unbedingter Mean-Forward-Return über alle 15m-Starts
  if (!baselines.has(instrument)) {
    const all = await getCandles(instrument);
    const byH = new Map<number, number>();
    for (const h of HORIZONS_H) {
      const stepIdx = (h * 3600_000) / M15;
      let s = 0, n = 0;
      for (let i = 0; i + stepIdx < all.length; i += 16) { // jede 4h ein Sample, deterministisch
        s += (all[i + stepIdx].close / all[i].open) * COST - 1;
        n++;
      }
      byH.set(h, n > 0 ? s / n : NaN);
    }
    baselines.set(instrument, byH);
  }
}

const fmt = (x: number) => (100 * x).toFixed(2) + '%';
const lines: string[] = ['# Event-Study Trump-Copy — ' + new Date().toISOString().slice(0, 10), ''];
for (const source of ['onchain', 'truth']) {
  lines.push(`## Quelle: ${source}`, '', '| Horizont | n | Mean | Median | Hit-Rate |', '|---|---|---|---|---|');
  for (const h of HORIZONS_H) {
    const rs = rows.filter((r) => r.source === source && r.horizon === h).map((r) => r.ret).sort((a, b) => a - b);
    if (rs.length === 0) { lines.push(`| ${h}h | 0 | — | — | — |`); continue; }
    const mean = rs.reduce((a, b) => a + b, 0) / rs.length;
    const median = rs[Math.floor(rs.length / 2)];
    const hit = rs.filter((r) => r > 0).length / rs.length;
    lines.push(`| ${h}h | ${rs.length} | ${fmt(mean)} | ${fmt(median)} | ${(100 * hit).toFixed(0)}% |`);
  }
  lines.push('');
}
lines.push('## Baselines (unbedingter Mean-Forward-Return, gleiche Kosten)', '');
for (const [inst, byH] of baselines) {
  lines.push(`- ${inst}: ` + HORIZONS_H.map((h) => `${h}h ${fmt(byH.get(h)!)}`).join(' · '));
}
const out = lines.join('\n') + '\n';
await Bun.write('docs/event-study-trump-2026-06-12.md', out);
console.log(out);
await sql.end();
```

- [ ] **Step 2: package.json-Script + ausführen**

```json
"trump:study": "bun run src/server/scripts/trump-event-study.ts",
```

Run: `bun run trump:study`
Expected: Markdown-Tabellen je Quelle × Horizont, Baselines je Instrument. Ergebnis ehrlich lesen: kleine n sind indikativ, nicht signifikant.

- [ ] **Step 3: Haltedauer festlegen** — `holdHours` in `TRUMP_CYCLE_CONFIG` (Task 9) auf den Horizont mit dem besten Mean-minus-Baseline setzen (bei Gleichstand oder n < 5: Default 60 behalten). Entscheidung + Begründung als Abschnitt „Entscheid" ans Ende des Study-Docs schreiben.

- [ ] **Step 4: Commit**

```bash
git add src/server/scripts/trump-event-study.ts docs/event-study-trump-2026-06-12.md package.json src/server/live/trump-engine.ts
git commit -m "feat: Event-Study Trump-Copy + Haltedauer-Entscheid"
```

---

### Task 14: Deploy + Doku

**Files:**
- Modify: `CLAUDE.md` (Engine Nr. 3 dokumentieren)

- [ ] **Step 1: CLAUDE.md ergänzen** — bei den Engines:

```markdown
3. **Trump-Copy** (BTC/ETH/SOL/XRP/LINK/AAVE/ONDO/ENA/SUI/SEI_USDT): Event-Copy — on-chain Käufe der WLFI-Watchlist + Truth-Social-Erwähnungen (trumpstruth-RSS), Buy am nächsten 15m-Open, Zeit-Exit nach `holdHours`, kein Stop. State: `bot_state` id=3, `trump_events`/`trump_positions`/`trump_signal_state`. Spec: `docs/specs/2026-06-12-trump-copy-strategy-design.md`, Event-Study: `docs/event-study-trump-2026-06-12.md`.
```

- [ ] **Step 2: Letzter Gesamtlauf**

Run: `bun test && bunx tsc --noEmit`
Expected: alles grün.

- [ ] **Step 3: Commit + Deploy**

```bash
git add CLAUDE.md
git commit -m "docs: Trump-Copy-Engine in CLAUDE.md"
redeploy j7xbvfezctcxmeuon6gh6v5z "feat: Trump-Copy-Strategie als dritte Paper-Engine"
```

- [ ] **Step 4: Prod-Verifikation** — nach dem Coolify-Build: `https://trading.kuns.dev/api/trump` liefert `lastCycleOk: true`; Dashboard-Tab „Trump" lädt. **Achtung:** Prod-DB braucht den Event-Backfill nicht (Live-Poller startet ab aktuellem Block; `consumedAt`-Markierung der History entfällt dort, weil keine History-Events existieren). Die Migration läuft automatisch über `bun run start`.

---

## Offene Risiken (bewusst akzeptiert, Spec §7)

- Wenig historische Events → Study indikativ; Paper-Lauf ist der eigentliche Test.
- trumpstruth.org ist ein Dritt-Mirror; fällt er weg, läuft die Engine onchain-only weiter (Fehler-Isolation in `pollSignals`).
- Watchlist-Kuration manuell; Erweiterung dokumentiert in Task 12 Step 4.