feat(notify): Slack message for reconcile-booked closes (realized P&L)

Entries, deferrals and rejections posted to #trading-bot, but exits booked by the reconcile loop (bracket stop/take-profit legs that fill at Alpaca) were silent — the two Jun 9 stop-outs produced no message. Viktor asked for a Slack message on each position execution.

- move SlackNotifier to shared/ (now used by trade-executor AND api-gateway)

- add notify_close (ticker/qty/price/realized P&L/reason, win-loss emoji)

- reconcile loop notifies on each booked close, fail-soft; api-gateway config gains slack fields (channel defaults to trading-bot since the env carries only the bot token; chat:write.public covers posting)

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

tests/shared/test_slack_notifier.py

@@ -0,0 +1,243 @@
+"""Tests for the shared SlackNotifier (trade-executor + reconcile loop)."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from unittest.mock import AsyncMock, patch
+from uuid import uuid4
+
+import pytest
+
+from shared.slack_notifier import SlackNotifier
+from shared.constants.kevin import KEVIN_STRATEGY_UUID
+from shared.schemas.trading import (
+    OrderResult,
+    OrderSide,
+    OrderStatus,
+    SignalDirection,
+    TradeSignal,
+)
+
+
+def _signal(strategy_id=None, target_dollars=None) -> TradeSignal:
+    return TradeSignal(
+        ticker="NVDA",
+        direction=SignalDirection.LONG,
+        strength=0.85,
+        strategy_sources=["meet_kevin:buy:0.85"],
+        timestamp=datetime.now(timezone.utc),
+        strategy_id=strategy_id,
+        target_dollars=target_dollars,
+    )
+
+
+def _filled_order(ticker="NVDA", qty=10, price=217.50) -> OrderResult:
+    return OrderResult(
+        order_id=str(uuid4()),
+        ticker=ticker,
+        side=OrderSide.BUY,
+        qty=qty,
+        filled_price=price,
+        status=OrderStatus.FILLED,
+        timestamp=datetime.now(timezone.utc),
+    )
+
+
+class TestSlackNotifierNoWebhook:
+    """Empty webhook_url -> notifier is a no-op (returns without raising)."""
+
+    @pytest.mark.asyncio
+    async def test_notify_trade_noop(self):
+        notifier = SlackNotifier(webhook_url="")
+        # should not raise even with no mock
+        await notifier.notify_trade(_signal(), _filled_order())
+
+    @pytest.mark.asyncio
+    async def test_notify_rejection_noop(self):
+        notifier = SlackNotifier(webhook_url="")
+        await notifier.notify_rejection(_signal(), "outside_market_hours")
+
+
+class TestSlackNotifierTradePost:
+    @pytest.mark.asyncio
+    async def test_trade_post_calls_webhook(self):
+        notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_post = AsyncMock(return_value=AsyncMock(status_code=200))
+            mock_client.post = mock_post
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await notifier.notify_trade(
+                _signal(strategy_id=KEVIN_STRATEGY_UUID),
+                _filled_order(qty=10, price=217.50),
+            )
+        mock_post.assert_called_once()
+        url, kwargs = mock_post.call_args.args[0], mock_post.call_args.kwargs
+        assert url == "https://hooks.slack.test/abc"
+        payload = kwargs["json"]
+        assert "NVDA" in payload["text"]
+        assert "10" in payload["text"]
+        assert "217.50" in payload["text"]
+
+    @pytest.mark.asyncio
+    async def test_trade_post_strategy_tag_when_kevin(self):
+        notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.post = AsyncMock(return_value=AsyncMock(status_code=200))
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await notifier.notify_trade(
+                _signal(strategy_id=KEVIN_STRATEGY_UUID),
+                _filled_order(),
+            )
+        payload = mock_client.post.call_args.kwargs["json"]
+        assert "Meet Kevin" in payload["text"]
+
+    @pytest.mark.asyncio
+    async def test_trade_post_swallows_http_errors(self):
+        """A failed Slack post must NOT bubble up — the trade already
+        happened; we shouldn't crash the consumer loop because Slack is
+        having a bad day."""
+        notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.post = AsyncMock(side_effect=Exception("network down"))
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            # should NOT raise
+            await notifier.notify_trade(_signal(), _filled_order())
+
+
+class TestSlackNotifierBotToken:
+    @pytest.mark.asyncio
+    async def test_bot_token_calls_chat_postmessage(self):
+        notifier = SlackNotifier(bot_token="xoxb-test", channel="trading-bot")
+        assert notifier.uses_bot_token
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_resp = AsyncMock()
+            mock_resp.json = lambda: {"ok": True, "ts": "1.2"}
+            mock_client.post = AsyncMock(return_value=mock_resp)
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await notifier.notify_trade(_signal(), _filled_order())
+        url = mock_client.post.call_args.args[0]
+        assert url == "https://slack.com/api/chat.postMessage"
+        kwargs = mock_client.post.call_args.kwargs
+        assert kwargs["headers"]["Authorization"] == "Bearer xoxb-test"
+        body = kwargs["json"]
+        assert body["channel"] == "trading-bot"
+        assert "NVDA" in body["text"]
+
+    @pytest.mark.asyncio
+    async def test_bot_token_swallows_channel_not_found(self):
+        """When the user hasn't created #trading-bot yet, the API returns
+        ok=false / error=channel_not_found. We log and continue."""
+        notifier = SlackNotifier(bot_token="xoxb-test", channel="nonexistent")
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_resp = AsyncMock()
+            mock_resp.json = lambda: {"ok": False, "error": "channel_not_found"}
+            mock_client.post = AsyncMock(return_value=mock_resp)
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            # should not raise
+            await notifier.notify_trade(_signal(), _filled_order())
+
+    @pytest.mark.asyncio
+    async def test_bot_token_wins_when_both_set(self):
+        notifier = SlackNotifier(
+            webhook_url="https://hooks.slack.test/abc",
+            bot_token="xoxb-test",
+            channel="trading-bot",
+        )
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.post = AsyncMock(return_value=AsyncMock(json=lambda: {"ok": True}))
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await notifier.notify_trade(_signal(), _filled_order())
+        assert mock_client.post.call_args.args[0] == "https://slack.com/api/chat.postMessage"
+
+
+class TestSlackNotifierRejectionPost:
+    @pytest.mark.asyncio
+    async def test_rejection_post_calls_webhook(self):
+        notifier = SlackNotifier(webhook_url="https://hooks.slack.test/abc")
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.post = AsyncMock(return_value=AsyncMock(status_code=200))
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await notifier.notify_rejection(
+                _signal(strategy_id=KEVIN_STRATEGY_UUID),
+                reason="kevin_daily_trade_cap",
+            )
+        payload = mock_client.post.call_args.kwargs["json"]
+        assert "REJECTED" in payload["text"]
+        assert "kevin_daily_trade_cap" in payload["text"]
+        assert "NVDA" in payload["text"]
+
+    @pytest.mark.asyncio
+    async def test_rejection_post_skips_noise(self):
+        """outside_market_hours fires every minute when the bot tries to
+        trade after-hours — we don't want a Slack barrage. The notifier
+        skips it."""
+        notifier = SlackNotifier(
+            webhook_url="https://hooks.slack.test/abc",
+            quiet_rejections={"outside_market_hours"},
+        )
+        with patch("httpx.AsyncClient") as mock_client_cls:
+            mock_client = AsyncMock()
+            mock_client.post = AsyncMock()
+            mock_client_cls.return_value.__aenter__.return_value = mock_client
+            await notifier.notify_rejection(_signal(), "outside_market_hours")
+        mock_client.post.assert_not_called()
+
+
+class TestSlackNotifierClosePost:
+    """notify_close — reconcile-booked exits (bracket legs that fill at
+    Alpaca without passing through the executor) must reach Slack."""
+
+    @pytest.mark.asyncio
+    async def test_close_posts_loss_with_pnl(self):
+        notifier = SlackNotifier(bot_token="xoxb-test", channel="trading-bot")
+        with patch.object(notifier, "_post", new=AsyncMock()) as post:
+            await notifier.notify_close(
+                ticker="MRVL",
+                qty=9,
+                price=263.61,
+                pnl=-243.87,
+                strategy_id=KEVIN_STRATEGY_UUID,
+                reason="bracket leg filled",
+            )
+        text = post.call_args[0][0]
+        assert "Meet Kevin" in text
+        assert "MRVL" in text
+        assert "263.61" in text
+        assert "-$243.87" in text
+        assert "bracket leg filled" in text
+
+    @pytest.mark.asyncio
+    async def test_close_posts_win_with_positive_pnl(self):
+        notifier = SlackNotifier(bot_token="xoxb-test", channel="trading-bot")
+        with patch.object(notifier, "_post", new=AsyncMock()) as post:
+            await notifier.notify_close(
+                ticker="TSM",
+                qty=6,
+                price=440.0,
+                pnl=83.06,
+                strategy_id=KEVIN_STRATEGY_UUID,
+                reason="take-profit filled",
+            )
+        text = post.call_args[0][0]
+        assert "+$83.06" in text
+
+    @pytest.mark.asyncio
+    async def test_close_noop_when_disabled(self):
+        notifier = SlackNotifier()
+        with patch.object(notifier, "_post", new=AsyncMock()) as post:
+            await notifier.notify_close(
+                ticker="TSM",
+                qty=6,
+                price=440.0,
+                pnl=1.0,
+                strategy_id=None,
+                reason="x",
+            )
+        post.assert_not_called()