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/adapters/persistence/postgresql.py

@@ -0,0 +1,260 @@
+"""PostgreSQL persistence adapters (REQ-006).
+
+- PostgreSQLSlotRepository: implements the domain SlotRepository protocol
+  (single-writer, pg_advisory_xact_lock serialization).
+- PostgreSQLIntentStore: implements the application IntentStore port
+  (intent_log dedup gate + audit).
+
+psycopg (v3) is imported lazily so the domain/test paths that use the
+in-memory adapters don't require it. External I/O lives here, never in the
+domain layer (NFR-1).
+"""
+from __future__ import annotations
+
+import json
+from contextlib import contextmanager
+from datetime import date, datetime, timezone
+from typing import Any, Iterator, Optional
+from uuid import UUID, uuid4
+
+from trex_core.application.ports import IntentRecord
+from trex_core.domain.slot import Slot, SlotNotFoundError, SlotState, SlotTransitionRecord
+
+_SLOT_COLUMNS = (
+    "slot_id, trading_date, status, symbol, qty, avg_price, entry_price, "
+    "allocated_capital, order_id, strategy_id, broker_order_id, portfolio_id, "
+    "sell_strategy_id, forced_close_at, created_at, updated_at"
+)
+
+
+def _require_psycopg(module: Any = None) -> Any:
+    if module is not None:
+        return module
+    try:
+        import psycopg  # type: ignore[import-not-found]
+    except ImportError as exc:  # pragma: no cover - environment guard
+        raise RuntimeError(
+            "psycopg is required for PostgreSQL adapters. Install 'trex-core[postgres]'."
+        ) from exc
+    return psycopg
+
+
+class PostgreSQLSlotRepository:
+    """psycopg-backed SlotRepository. Connection-per-call (orbit-proven)."""
+
+    def __init__(self, dsn: str, *, psycopg_module: Any = None) -> None:
+        self._psycopg = _require_psycopg(psycopg_module)
+        self._dsn = dsn
+
+    @contextmanager
+    def transactional_advisory_lock(self, lock_id: int) -> Iterator[None]:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            try:
+                with conn.cursor() as cur:
+                    cur.execute("SELECT pg_advisory_xact_lock(%s)", (lock_id,))
+                yield
+                conn.commit()
+            except BaseException:
+                conn.rollback()
+                raise
+
+    def pre_allocate_slots(self, trading_date: date, count: int) -> int:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "SELECT COUNT(*) FROM daily_slot WHERE trading_date = %s", (trading_date,)
+                )
+                row = cur.fetchone()
+                if row and row[0] > 0:
+                    conn.commit()
+                    return 0
+                now = datetime.now(tz=timezone.utc)
+                rows = [
+                    (uuid4(), trading_date, SlotState.IDLE.value, now, now) for _ in range(count)
+                ]
+                cur.executemany(
+                    "INSERT INTO daily_slot (slot_id, trading_date, status, created_at, updated_at) "
+                    "VALUES (%s, %s, %s, %s, %s)",
+                    rows,
+                )
+                conn.commit()
+                return count
+
+    def list_slots(self, trading_date: date) -> list[Slot]:
+        with self._psycopg.connect(self._dsn) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    f"SELECT {_SLOT_COLUMNS} FROM daily_slot WHERE trading_date = %s",
+                    (trading_date,),
+                )
+                return [self._row_to_slot(r) for r in cur.fetchall()]
+
+    def fetch_slot(self, slot_id: UUID) -> Optional[Slot]:
+        with self._psycopg.connect(self._dsn) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    f"SELECT {_SLOT_COLUMNS} FROM daily_slot WHERE slot_id = %s", (slot_id,)
+                )
+                row = cur.fetchone()
+                return self._row_to_slot(row) if row else None
+
+    def find_idle_slot(self, trading_date: date) -> Optional[Slot]:
+        with self._psycopg.connect(self._dsn) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    f"SELECT {_SLOT_COLUMNS} FROM daily_slot "
+                    "WHERE trading_date = %s AND status = 'idle' LIMIT 1",
+                    (trading_date,),
+                )
+                row = cur.fetchone()
+                return self._row_to_slot(row) if row else None
+
+    def update_slot(self, slot: Slot) -> None:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "UPDATE daily_slot SET status=%s, symbol=%s, qty=%s, avg_price=%s, "
+                    "entry_price=%s, allocated_capital=%s, order_id=%s, strategy_id=%s, "
+                    "broker_order_id=%s, portfolio_id=%s, sell_strategy_id=%s, "
+                    "forced_close_at=%s, updated_at=%s WHERE slot_id=%s",
+                    (
+                        slot.status.value, slot.symbol, slot.qty, slot.avg_price,
+                        slot.entry_price, slot.allocated_capital, slot.order_id,
+                        slot.strategy_id, slot.broker_order_id, slot.portfolio_id,
+                        slot.sell_strategy_id, slot.forced_close_at,
+                        slot.updated_at or datetime.now(tz=timezone.utc), slot.slot_id,
+                    ),
+                )
+                if cur.rowcount == 0:
+                    conn.rollback()
+                    raise SlotNotFoundError(f"slot not found: {slot.slot_id}")
+                conn.commit()
+
+    def append_transition_log(self, record: SlotTransitionRecord) -> None:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "INSERT INTO slot_transition_log "
+                    "(slot_id, from_state, to_state, ts, reason, actor, extra) "
+                    "VALUES (%s, %s, %s, %s, %s, %s, %s)",
+                    (
+                        record.slot_id, record.from_state.value, record.to_state.value,
+                        record.ts, record.reason, record.actor, json.dumps(record.extra),
+                    ),
+                )
+                conn.commit()
+
+    def increment_symbol_entry(self, trading_date: date, symbol: str) -> int:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "INSERT INTO daily_symbol_entries (trading_date, symbol, entry_count, last_entry_at) "
+                    "VALUES (%s, %s, 1, %s) "
+                    "ON CONFLICT (trading_date, symbol) DO UPDATE "
+                    "SET entry_count = daily_symbol_entries.entry_count + 1, "
+                    "    last_entry_at = EXCLUDED.last_entry_at RETURNING entry_count",
+                    (trading_date, symbol, datetime.now(tz=timezone.utc)),
+                )
+                row = cur.fetchone()
+                conn.commit()
+                return int(row[0]) if row else 0
+
+    def get_symbol_entry_count(self, trading_date: date, symbol: str) -> int:
+        with self._psycopg.connect(self._dsn) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "SELECT entry_count FROM daily_symbol_entries "
+                    "WHERE trading_date = %s AND symbol = %s",
+                    (trading_date, symbol),
+                )
+                row = cur.fetchone()
+                return int(row[0]) if row else 0
+
+    def count_slots_by_status(self, trading_date: date) -> dict[SlotState, int]:
+        with self._psycopg.connect(self._dsn) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "SELECT status, COUNT(*) FROM daily_slot WHERE trading_date = %s GROUP BY status",
+                    (trading_date,),
+                )
+                return {SlotState(r[0]): int(r[1]) for r in cur.fetchall()}
+
+    @staticmethod
+    def _row_to_slot(row: tuple) -> Slot:
+        f = lambda v: float(v) if v is not None else None  # noqa: E731
+        return Slot(
+            slot_id=row[0] if isinstance(row[0], UUID) else UUID(str(row[0])),
+            trading_date=row[1],
+            status=SlotState(row[2]),
+            symbol=row[3],
+            qty=f(row[4]),
+            avg_price=f(row[5]),
+            entry_price=f(row[6]),
+            allocated_capital=f(row[7]),
+            order_id=row[8],
+            strategy_id=row[9],
+            broker_order_id=row[10],
+            portfolio_id=row[11],
+            sell_strategy_id=row[12],
+            forced_close_at=row[13],
+            created_at=row[14],
+            updated_at=row[15],
+        )
+
+
+class PostgreSQLIntentStore:
+    """intent_log-backed IntentStore. intent_id UNIQUE is the dedup gate."""
+
+    def __init__(self, dsn: str, *, psycopg_module: Any = None) -> None:
+        self._psycopg = _require_psycopg(psycopg_module)
+        self._dsn = dsn
+
+    def try_insert(self, intent_id: str, intent_type: str, payload: dict) -> bool:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "INSERT INTO intent_log (intent_id, intent_type, payload, status) "
+                    "VALUES (%s, %s, %s, 'processing') ON CONFLICT (intent_id) DO NOTHING",
+                    (intent_id, intent_type, json.dumps(payload)),
+                )
+                inserted = cur.rowcount == 1
+                conn.commit()
+                return inserted
+
+    def get(self, intent_id: str) -> Optional[IntentRecord]:
+        with self._psycopg.connect(self._dsn) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "SELECT intent_id, intent_type, status, slot_id, reason "
+                    "FROM intent_log WHERE intent_id = %s",
+                    (intent_id,),
+                )
+                row = cur.fetchone()
+                if row is None:
+                    return None
+                return _PgIntentRecord(
+                    intent_id=row[0], intent_type=row[1], status=row[2],
+                    slot_id=(row[3] if isinstance(row[3], UUID) or row[3] is None else UUID(str(row[3]))),
+                    reason=row[4],
+                )
+
+    def finalize(
+        self, intent_id: str, status: str, slot_id: Optional[UUID], reason: Optional[str]
+    ) -> None:
+        with self._psycopg.connect(self._dsn, autocommit=False) as conn:
+            with conn.cursor() as cur:
+                cur.execute(
+                    "UPDATE intent_log SET status=%s, slot_id=%s, reason=%s, updated_at=%s "
+                    "WHERE intent_id=%s",
+                    (status, slot_id, reason, datetime.now(tz=timezone.utc), intent_id),
+                )
+                conn.commit()
+
+
+class _PgIntentRecord:
+    def __init__(self, intent_id, intent_type, status, slot_id, reason):
+        self.intent_id = intent_id
+        self.intent_type = intent_type
+        self.status = status
+        self.slot_id = slot_id
+        self.reason = reason