Deliver BAT-002: slot-core daemon + HTTP intent API + PostgreSQL

Implement REQ-005~009 (dcy-002 slice 1) as an onion stack on top of the
BAT-001 pure domain:
- application: IntentService (admission + single-writer transition +
  intent_id idempotency via durable intent_log)
- adapters/persistence: PostgreSQLSlotRepository + PostgreSQLIntentStore +
  trex-core-owned migrations (daily_slot per Appendix A, daily_symbol_entries,
  slot_transition_log, intent_log) + in-memory intent store
- adapters/api: FastAPI /v1 (healthz, intents/buy|sell|{id}, slots, capacity)
- runtime: trex-core-daemon entrypoint with lifespan migrate+preallocate

Verification (against local PostgreSQL 18): 74 passed, ruff clean, domain
import sweep shows zero web/db deps (NFR-1), 20-thread concurrency admits
exactly the idle count (NFR-2), idempotent resubmit causes no double
transition (NFR-3), EXPECTED_SLOT_FIELDS<->information_schema drift test
(realizes dcy-001 OQ-2's deferred DB-side check), and a daemon E2E smoke.

Align all four baseline docs to the new daemon/API/persistence layers.
BAT-002 -> release-candidate; REQ-005~009 -> Implemented. Full async outbox,
broker execution, safety floor, and strategy daemons remain deferred to a
follow-up Discovery.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

trex_core/application/intents.py

@@ -0,0 +1,187 @@
+"""Intent application service (REQ-007).
+
+Turns a buy/sell intent submitted over HTTP into a single-writer slot
+transition, with intent_id idempotency backed by a durable intent_log.
+
+Idempotency model (dcy-002 OQ-1): `intent_store.try_insert` is the dedup
+gate. On a duplicate intent_id it returns the prior decision without
+re-driving any transition (NFR-3). Slot transitions go exclusively through
+SlotService (advisory-lock serialized) so the single-writer invariant
+holds (NFR-2). Concurrency on the last idle slot is resolved by retrying
+on SlotStateMismatchError.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from typing import Any, Optional
+from uuid import UUID
+
+from trex_core.application.ports import IntentStore
+from trex_core.domain.slot import (
+    SlotRepository,
+    SlotService,
+    SlotState,
+    SlotStateMismatchError,
+)
+
+_MAX_IDLE_RETRY = 8
+
+
+@dataclass(frozen=True)
+class IntentDecision:
+    """Result of submitting an intent."""
+
+    intent_id: str
+    status: str  # 'admitted' | 'rejected'
+    slot_id: Optional[UUID] = None
+    reason: Optional[str] = None
+
+    @property
+    def admitted(self) -> bool:
+        return self.status == "admitted"
+
+
+@dataclass(frozen=True)
+class BuyIntent:
+    intent_id: str
+    trading_date: date
+    symbol: str
+    qty: Optional[float] = None
+    allocated_capital: Optional[float] = None
+    entry_price: Optional[float] = None
+    strategy_id: Optional[str] = None
+    sell_strategy_id: Optional[str] = None
+    portfolio_id: Optional[str] = None
+    forced_close_at: Optional[datetime] = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class SellIntent:
+    intent_id: str
+    slot_id: UUID
+    reason: str = "discretionary_sell"
+    sell_strategy_id: Optional[str] = None
+    extra: dict[str, Any] = field(default_factory=dict)
+
+
+class IntentService:
+    """Admission + slot transition for buy/sell intents (single writer)."""
+
+    def __init__(
+        self,
+        slot_service: SlotService,
+        slot_repo: SlotRepository,
+        intent_store: IntentStore,
+    ) -> None:
+        self._svc = slot_service
+        self._repo = slot_repo
+        self._intents = intent_store
+
+    # ------------------------------------------------------------
+    def lookup(self, intent_id: str) -> Optional[IntentDecision]:
+        """Return the recorded decision for an intent_id, or None (re-query)."""
+        rec = self._intents.get(intent_id)
+        if rec is None:
+            return None
+        return IntentDecision(rec.intent_id, rec.status, rec.slot_id, rec.reason)
+
+    def submit_buy(self, intent: BuyIntent) -> IntentDecision:
+        payload = {
+            "trading_date": intent.trading_date.isoformat(),
+            "symbol": intent.symbol,
+            "qty": intent.qty,
+            "allocated_capital": intent.allocated_capital,
+            "entry_price": intent.entry_price,
+            "strategy_id": intent.strategy_id,
+            "sell_strategy_id": intent.sell_strategy_id,
+            "portfolio_id": intent.portfolio_id,
+        }
+        prior = self._dedup(intent.intent_id, "buy", payload)
+        if prior is not None:
+            return prior
+
+        decision = self._admit_buy(intent)
+        self._intents.finalize(
+            intent.intent_id, decision.status, decision.slot_id, decision.reason
+        )
+        return decision
+
+    def submit_sell(self, intent: SellIntent) -> IntentDecision:
+        payload = {
+            "slot_id": str(intent.slot_id),
+            "reason": intent.reason,
+            "sell_strategy_id": intent.sell_strategy_id,
+        }
+        prior = self._dedup(intent.intent_id, "sell", payload)
+        if prior is not None:
+            return prior
+
+        decision = self._admit_sell(intent)
+        self._intents.finalize(
+            intent.intent_id, decision.status, decision.slot_id, decision.reason
+        )
+        return decision
+
+    # ------------------------------------------------------------
+    def _dedup(self, intent_id: str, intent_type: str, payload: dict) -> Optional[IntentDecision]:
+        """Return prior decision if intent_id already seen; else None (and reserve it)."""
+        inserted = self._intents.try_insert(intent_id, intent_type, payload)
+        if inserted:
+            return None
+        rec = self._intents.get(intent_id)
+        if rec is None:  # extremely unlikely race; treat as not-yet-decided
+            return IntentDecision(intent_id, "rejected", None, "duplicate_in_flight")
+        return IntentDecision(intent_id, rec.status, rec.slot_id, rec.reason)
+
+    def _admit_buy(self, intent: BuyIntent) -> IntentDecision:
+        # Retry on the last-idle-slot race: another intent may claim the slot
+        # between our find and transit (SlotStateMismatchError).
+        for _ in range(_MAX_IDLE_RETRY):
+            slot = self._repo.find_idle_slot(intent.trading_date)
+            if slot is None:
+                return IntentDecision(intent.intent_id, "rejected", None, "no_idle_slot")
+            try:
+                updated = self._svc.transit_slot(
+                    slot.slot_id,
+                    SlotState.IDLE,
+                    SlotState.PENDING_BUY,
+                    reason="buy_intent",
+                    actor="intent_api",
+                    symbol=intent.symbol,
+                    qty=intent.qty,
+                    allocated_capital=intent.allocated_capital,
+                    entry_price=intent.entry_price,
+                    strategy_id=intent.strategy_id,
+                    sell_strategy_id=intent.sell_strategy_id,
+                    portfolio_id=intent.portfolio_id,
+                    forced_close_at=intent.forced_close_at,
+                    extra={"intent_id": intent.intent_id, "symbol": intent.symbol},
+                )
+            except SlotStateMismatchError:
+                continue  # slot was claimed concurrently; try another idle slot
+            return IntentDecision(intent.intent_id, "admitted", updated.slot_id, None)
+        return IntentDecision(intent.intent_id, "rejected", None, "idle_slot_contended")
+
+    def _admit_sell(self, intent: SellIntent) -> IntentDecision:
+        slot = self._repo.fetch_slot(intent.slot_id)
+        if slot is None:
+            return IntentDecision(intent.intent_id, "rejected", None, "slot_not_found")
+        if slot.status is not SlotState.HOLDING:
+            return IntentDecision(
+                intent.intent_id, "rejected", None, f"slot_not_holding:{slot.status.value}"
+            )
+        try:
+            updated = self._svc.transit_slot(
+                slot.slot_id,
+                SlotState.HOLDING,
+                SlotState.PENDING_SELL,
+                reason=intent.reason,
+                actor="intent_api",
+                sell_strategy_id=intent.sell_strategy_id,
+                extra={"intent_id": intent.intent_id},
+            )
+        except SlotStateMismatchError:
+            return IntentDecision(intent.intent_id, "rejected", None, "slot_state_changed")
+        return IntentDecision(intent.intent_id, "admitted", updated.slot_id, None)