feat(slot): BAT-030 — 자산 중심 cutover 완성 (dcy-020 BAT-δ, REQ-056·057·062·064·065)

M1 literal inactive 전면화: SlotState 5-state(idle/closed 별칭 제거),
마이그레이션 010(CHECK 교체+행 rewrite), ops_checks 를 transition_log 기반 재작성.
M2 집행 매도 수량 브로커 정본(D3): dispatch 매도 qty=broker hldg_qty,
미러 fallback 없음, 브로커 0 → skip+WARN, 리스트 기반 dispatch(head-block 방지).
M3 컬럼 drop + legacy pool 제거: 마이그레이션 011(trading_date·entry_count DROP),
repo 계약 instance 스코프 개편(집행 큐 포함), preallocation 폐기(데몬 7스레드),
admission 자산 중심 단일 경로(slot_id 정본), capacity 재정의(available=M−active),
daily_symbol_entries 코드 경로 제거.
M4 cutover 도구(D1·D4): trex-core-cutover(전체 rebuild, preflight/브로커 carry-over/
--allow-unmapped/--promote-unique/dry-run) + PG 리허설 테스트 8건.
M5 baseline 마감: data-model/runtime-flows/project-structure/interface-contract
자산 중심 최종 갱신 + run-trex-core-daemon 스킬 정합.

검증: 단위 367 passed + ruff clean; PG-gated 29 passed(010/011 round-trip·드리프트
가드·cutover 리허설); RabbitMQ 21 passed; run-the-app e2e(test DB+실 MQ, M=1):
reconcile 슬롯 생성→slot_id 매수→dedup→capacity_full→fill→already_active→
매도→inactive(자산 바인딩 보존)→영구 슬롯 재활성 전 구간 green.
실 cutover 는 운영자 실행(REL 단계, D4).

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

trex_core/runtime/cli.py

@@ -135,7 +135,9 @@ def _cmd_slots(args, cfg, rpc) -> int:
     if status in ("holding", "held"):
         slots = [s for s in slots if s.get("status") == "holding"]
     elif status == "buyable":
-        slots = [s for s in slots if s.get("status") == "idle"]
+        # dcy-020 (BAT-030): admittable = inactive, not universe-detached.
+        slots = [s for s in slots
+                 if s.get("status") == "inactive" and not s.get("universe_detached")]
     elif status == "pending":
         slots = [s for s in slots if s.get("status") in ("pending_buy", "pending_sell")]
     # dcy-017: holding-slot watchdog state (strategy-absent ownership).
@@ -203,7 +205,7 @@ def _cmd_enter(args, cfg, rpc, confirm) -> int:
         return short
     payload = {
         "intent_type": "buy", "intent_id": str(uuid.uuid4()),
-        "trading_date": _today_iso(cfg), "portfolio_id": args.portfolio_id,
+        "portfolio_id": args.portfolio_id,
         "qty": args.qty, "allocated_capital": args.capital,
         "entry_price": args.entry_price, "strategy_id": args.strategy_id,
         "sell_strategy_id": args.sell_strategy_id,

trex_core/runtime/config.py

@@ -139,13 +139,11 @@ class DaemonInstanceConfig:
 
     instance_key: str
     portfolio_hub_token: str = ""
-    # dcy-014 / REQ-048: trading_date timezone + daily preallocation trigger.
-    # Optional — absent keys fall back to KST / midnight defaults.
+    # dcy-014 / REQ-048: operator-local timezone (CLI date display etc.).
     trading_timezone: str = "Asia/Seoul"
-    daily_preallocation_time: str = "00:00"
-    # dcy-020 / REQ-060 (BAT-028): max concurrent active (holding) slots, M.
-    # Presence is the asset-centric mode gate: set -> universe reconcile + FCFS/M
-    # admission; absent -> legacy pool model (preallocation + find_allocatable).
+    # dcy-020 / REQ-060: max concurrent active (holding) slots, M — the FCFS
+    # admission capacity cap. BAT-030: asset-centric is the only model; absent
+    # means no cap (operators are expected to set it in production).
     max_active_slots: Optional[int] = None
 
     @staticmethod
@@ -169,7 +167,6 @@ class DaemonInstanceConfig:
             instance_key=str(instance_key),
             portfolio_hub_token=str(data.get("portfolio_hub_token") or ""),
             trading_timezone=str(data.get("trading_timezone") or "Asia/Seoul"),
-            daily_preallocation_time=str(data.get("daily_preallocation_time") or "00:00"),
             max_active_slots=max_active,
         )
 
@@ -177,14 +174,13 @@ class DaemonInstanceConfig:
 @dataclass(frozen=True)
 class DaemonConfig:
     dsn: str
-    total_slots: int
     broker: str                      # 'paper' | 'kis'
     execution_interval_sec: float
     # BAT-013 / REQ-049: instance identity for multi-instance queue naming.
     # "default" keeps legacy literal queue names (backward-compat).
     instance_key: str = "default"
-    # dcy-020 / REQ-060 (BAT-028): M (max concurrent active slots) + asset-centric
-    # mode gate. None -> legacy pool model.
+    # dcy-020 / REQ-060: M (max concurrent active slots) — FCFS admission cap.
+    # BAT-030: asset-centric is the only model; None = no cap.
     max_active_slots: Optional[int] = None
     kis: Optional[KISConfig] = None
     # REQ-011: paper broker tuning (only consulted when broker == 'paper').
@@ -204,11 +200,9 @@ class DaemonConfig:
     # threshold in seconds. 0 disables (default). When >0, dispatched-pending
     # slots older than this are surfaced (WARN + counter) without state change.
     pending_stale_threshold_sec: int = 0
-    # dcy-014 / REQ-005 (BAT-018): trading_date timezone (default KST) + daily
-    # preallocation trigger time (HH:MM, TZ-local). Operative surface is the
-    # per-instance TOML (REQ-048); these are the env-only defaults.
+    # dcy-014 / REQ-048: operator-local timezone (CLI date display etc.). The
+    # daily preallocation trigger was removed with the pool model (BAT-030).
     trading_timezone: str = "Asia/Seoul"
-    daily_preallocation_time: str = "00:00"
     # dcy-015 / REQ-019 (BAT-019): ledger outbox retry backoff. base*2^(n-1)
     # capped at cap (+jitter); after max_attempts a retryable row dead-letters.
     ledger_retry_base_sec: float = 1.0
@@ -283,7 +277,6 @@ class DaemonConfig:
         )
         return DaemonConfig(
             dsn=dsn,
-            total_slots=int(os.environ.get("TREX_TOTAL_SLOTS", "10")),
             broker=broker,
             execution_interval_sec=float(os.environ.get("TREX_EXECUTION_INTERVAL_SEC", "1.0")),
             kis=kis,
@@ -323,12 +316,10 @@ class DaemonConfig:
         pf = base.portfolio_hub
         if inst.portfolio_hub_token and pf is not None:
             pf = replace(pf, token=inst.portfolio_hub_token)
-        # dcy-014 / REQ-048: trading_date TZ + daily trigger come from TOML.
         return replace(
             base,
             instance_key=inst.instance_key,
             portfolio_hub=pf,
             trading_timezone=inst.trading_timezone,
-            daily_preallocation_time=inst.daily_preallocation_time,
             max_active_slots=inst.max_active_slots,
         )

trex_core/runtime/cutover.py

@@ -0,0 +1,235 @@
+"""Asset-centric cutover tool (dcy-020 / REQ-064, BAT-030).
+
+Full rebuild (design D1): wipe this instance's daily_slot rows and recreate
+them from the portfolio-hub universe + the broker balance, with the broker as
+the single source of truth for carried-over holdings (consistent with D3).
+
+Procedure (one transaction):
+  1. preflight — abort if any pending_buy/pending_sell rows exist for the
+     instance (in-flight orders must converge first; run outside the trading
+     session).
+  2. DELETE all of the instance's slot rows.
+  3. one permanent slot per universe asset, status `inactive`.
+  4. each broker holding (symbol, qty) is mapped symbol→portfolio_id via the
+     universe and its slot is set to `holding` (qty = broker quantity;
+     avg_price is left NULL — the balance API does not carry it — WARN).
+  5. a broker holding whose symbol is NOT in the universe aborts the cutover
+     (operator decision; `--allow-unmapped` downgrades to WARN+skip).
+  6. audit rows in slot_transition_log (reason `cutover_rebuild`).
+  7. optional `--promote-unique`: portfolio_id SET NOT NULL (only after ALL
+     instances sharing the DB have been cut over).
+
+The real cutover is OPERATOR-RUN (design D4): `trex-core-cutover --config
+<instance> --yes` after a rehearsal against a test DB. Rollback = restore the
+pre-cutover backup + previous release (BAT-030 design §4).
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Iterable, Optional
+from uuid import uuid4
+
+_log = logging.getLogger(__name__)
+
+
+class CutoverAbort(RuntimeError):
+    """Preflight/mapping condition that must stop the cutover."""
+
+
+@dataclass
+class CutoverReport:
+    instance_key: str
+    deleted: int = 0
+    created: int = 0
+    holdings: int = 0
+    unmapped: list[str] = field(default_factory=list)
+    promoted_unique: bool = False
+    dry_run: bool = False
+
+    def summary(self) -> str:
+        return (
+            f"cutover[{self.instance_key}] deleted={self.deleted} "
+            f"created={self.created} holdings={self.holdings} "
+            f"unmapped={self.unmapped or '[]'} "
+            f"promote_unique={self.promoted_unique} dry_run={self.dry_run}"
+        )
+
+
+def run_cutover(
+    dsn: str,
+    instance_key: str,
+    universe: Iterable[tuple[str, str]],
+    balances: Iterable[tuple[str, int]],
+    *,
+    allow_unmapped: bool = False,
+    promote_unique: bool = False,
+    dry_run: bool = False,
+    psycopg_module: Any = None,
+) -> CutoverReport:
+    """Rebuild the instance's slots from `universe` + `balances` atomically.
+
+    universe:  iterable of (portfolio_id, symbol).
+    balances:  iterable of (symbol, hldg_qty) — broker ground truth.
+    Raises CutoverAbort on in-flight pending rows or unmapped broker holdings
+    (unless allow_unmapped). dry_run rolls the transaction back at the end.
+    """
+    if psycopg_module is None:
+        import psycopg  # type: ignore[import-not-found]
+        psycopg_module = psycopg
+
+    uni = [(str(pid), str(sym)) for pid, sym in universe if pid]
+    by_symbol = {sym: pid for pid, sym in uni}
+    held = [(str(sym), int(qty)) for sym, qty in balances if int(qty) > 0]
+    report = CutoverReport(instance_key=instance_key, dry_run=dry_run)
+
+    # mapping check before touching the DB (step 5)
+    unmapped = [sym for sym, _ in held if sym not in by_symbol]
+    if unmapped:
+        if not allow_unmapped:
+            raise CutoverAbort(
+                f"broker holds symbols outside the universe: {unmapped} "
+                "(resolve in portfolio-hub or pass --allow-unmapped to skip them)"
+            )
+        report.unmapped = unmapped
+        for sym in unmapped:
+            _log.warning(
+                "cutover: broker holding %s has no universe portfolio — SKIPPED "
+                "(unmanaged position; operator attention)", sym,
+            )
+
+    now = datetime.now(tz=timezone.utc)
+    with psycopg_module.connect(dsn, autocommit=False) as conn:
+        try:
+            with conn.cursor() as cur:
+                # 1. preflight: no in-flight pending rows for this instance
+                cur.execute(
+                    "SELECT count(*) FROM daily_slot WHERE instance_key = %s "
+                    "AND status IN ('pending_buy','pending_sell')",
+                    (instance_key,),
+                )
+                pending = int(cur.fetchone()[0])
+                if pending:
+                    raise CutoverAbort(
+                        f"{pending} in-flight pending slot(s) for instance "
+                        f"{instance_key!r} — wait for convergence (run outside "
+                        "the trading session) and retry"
+                    )
+
+                # 2. wipe the instance's rows (full rebuild, D1)
+                cur.execute(
+                    "DELETE FROM daily_slot WHERE instance_key = %s", (instance_key,)
+                )
+                report.deleted = cur.rowcount
+
+                # 3+4. recreate: one permanent slot per universe asset
+                holding_pids = {}
+                for sym, qty in held:
+                    pid = by_symbol.get(sym)
+                    if pid is not None:
+                        holding_pids[pid] = (sym, qty)
+                for pid, sym in uni:
+                    sid = uuid4()
+                    if pid in holding_pids:
+                        h_sym, h_qty = holding_pids[pid]
+                        cur.execute(
+                            "INSERT INTO daily_slot (slot_id, status, symbol, qty, "
+                            "instance_key, portfolio_id, created_at, updated_at) "
+                            "VALUES (%s, 'holding', %s, %s, %s, %s, %s, %s)",
+                            (sid, h_sym, h_qty, instance_key, pid, now, now),
+                        )
+                        report.holdings += 1
+                        _log.warning(
+                            "cutover: %s carried over as holding qty=%d "
+                            "avg_price=NULL (balance API has no cost basis)",
+                            pid, h_qty,
+                        )
+                    else:
+                        cur.execute(
+                            "INSERT INTO daily_slot (slot_id, status, symbol, "
+                            "instance_key, portfolio_id, created_at, updated_at) "
+                            "VALUES (%s, 'inactive', %s, %s, %s, %s, %s)",
+                            (sid, sym, instance_key, pid, now, now),
+                        )
+                    report.created += 1
+                    # 6. audit trail
+                    cur.execute(
+                        "INSERT INTO slot_transition_log "
+                        "(slot_id, from_state, to_state, ts, reason, actor) "
+                        "VALUES (%s, 'inactive', %s, %s, 'cutover_rebuild', 'cutover')",
+                        (sid, "holding" if pid in holding_pids else "inactive", now),
+                    )
+
+                # 7. optional promotion (all instances cut over)
+                if promote_unique:
+                    cur.execute(
+                        "ALTER TABLE daily_slot ALTER COLUMN portfolio_id SET NOT NULL"
+                    )
+                    report.promoted_unique = True
+
+            if dry_run:
+                conn.rollback()
+            else:
+                conn.commit()
+        except BaseException:
+            conn.rollback()
+            raise
+    return report
+
+
+def main(argv: Optional[list[str]] = None) -> int:  # pragma: no cover - CLI shell
+    import argparse
+
+    from trex_core.adapters.persistence.migrate import apply_migrations
+    from trex_core.runtime.config import DaemonConfig, resolve_config_toml
+    from trex_core.runtime.daemon import _build_broker, _build_portfolio_read
+
+    logging.basicConfig(level=logging.INFO)
+    parser = argparse.ArgumentParser(
+        prog="trex-core-cutover",
+        description="dcy-020/REQ-064: pool→asset-centric full-rebuild cutover "
+                    "(operator-run; rehearse on a test DB first).",
+    )
+    parser.add_argument("--config", required=True, help="instance TOML name/path")
+    parser.add_argument("--config-path", default=None)
+    parser.add_argument("--env-file", default=None)
+    parser.add_argument("--yes", action="store_true",
+                        help="actually apply (otherwise dry-run + rollback)")
+    parser.add_argument("--allow-unmapped", action="store_true",
+                        help="skip (WARN) broker holdings outside the universe "
+                             "instead of aborting")
+    parser.add_argument("--promote-unique", action="store_true",
+                        help="portfolio_id SET NOT NULL (only after ALL "
+                             "instances sharing this DB are cut over)")
+    args = parser.parse_args(argv)
+
+    toml_path = resolve_config_toml(args.config, args.config_path)
+    config = DaemonConfig.from_config(toml_path, env_file=args.env_file)
+    apply_migrations(config.dsn)
+
+    read = _build_portfolio_read(config)
+    daemon_id = read.whoami()
+    items = read.get_portfolios(daemon_id)
+    universe = [(it.portfolio_id, it.symbol) for it in items]
+    broker = _build_broker(config)
+    balances = [(b.symbol, b.hldg_qty) for b in broker.get_balance()]
+
+    try:
+        report = run_cutover(
+            config.dsn, config.instance_key, universe, balances,
+            allow_unmapped=args.allow_unmapped,
+            promote_unique=args.promote_unique and args.yes,
+            dry_run=not args.yes,
+        )
+    except CutoverAbort as exc:
+        _log.error("cutover ABORTED: %s", exc)
+        return 2
+    _log.info("%s", report.summary())
+    if not args.yes:
+        _log.info("dry-run only — re-run with --yes to apply")
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

trex_core/runtime/daemon.py

@@ -9,8 +9,8 @@ Threads (started in `run()`):
   - control RPC consumer    — `trex.control.req` (pause/resume/list + kill_switch/resume_kill_switch, REQ-032/043)
   - execution loop         — broker dispatch + poll + slot transitions + event emit
   - ledger writer          — ledger outbox drain (REQ-019)
-  - snapshot scheduler      — daily portfolio-hub snapshot refresh (REQ-030)
-  - preallocation scheduler — daily slot preallocation in trading TZ (REQ-005, dcy-014)
+  - snapshot scheduler      — daily portfolio-hub snapshot refresh + universe
+                              slot reconcile (REQ-030, dcy-020/REQ-058)
   - safety-sell worker      — forced_close / stop-loss·take-profit / market-close (REQ-037/038/039)
 
 Each consumer/publisher uses its OWN RabbitMQTransport instance because
@@ -22,9 +22,7 @@ from __future__ import annotations
 import logging
 import signal
 import threading
-from datetime import datetime
 from datetime import time as time_cls
-from zoneinfo import ZoneInfo
 
 from trex_core.adapters.broker.paper import PaperBroker
 from trex_core.adapters.ledger import InMemoryLedger, PortfolioHubLedger
@@ -63,7 +61,6 @@ from trex_core.application.portfolio import (
     SnapshotStore,
 )
 from trex_core.application.safety_sell import SafetySellService
-from trex_core.application.preallocation_scheduler import DailyPreallocationScheduler
 from trex_core.application.snapshot_scheduler import SnapshotScheduler
 from trex_core.application.watchdog import WatchdogStore
 from trex_core.domain.slot import SlotService
@@ -169,6 +166,7 @@ class Daemon:
             slot_repo=self.slot_repo,
             slot_service=self.slot_service,
             killswitch_store=self.killswitch_store,
+            instance_key=config.instance_key,
         )
         self.portfolio_read = _build_portfolio_read(config)
         self.snapshot_scheduler = SnapshotScheduler(
@@ -176,22 +174,12 @@ class Daemon:
             store=self.snapshot_store,
             broker=self.broker,
             schedule_kst=_parse_kst_time(config.snapshot_schedule.kst_time),
-            # dcy-020 / REQ-058·062 (BAT-028/029): asset-centric slot reconcile +
-            # core-holding divergence reconcile when M set.
+            # dcy-020 / REQ-058·062 (BAT-030): universe slot reconcile (creates/
+            # retires the permanent asset slots) + core-holding divergence
+            # reconcile — always on (asset-centric is the only model).
             slot_repo=self.slot_repo,
             slot_service=self.slot_service,
             instance_key=config.instance_key,
-            reconcile_enabled=config.max_active_slots is not None,
-            trading_date_fn=(lambda: datetime.now(ZoneInfo(config.trading_timezone)).date()),
-        )
-        # dcy-014 / REQ-005: daily slot preallocation in the configured
-        # trading timezone (default KST), so trading_date matches the local
-        # calendar and the next day's slots appear without a restart.
-        self.preallocation_scheduler = DailyPreallocationScheduler(
-            slot_service=self.slot_service,
-            total_slots=config.total_slots,
-            tz=ZoneInfo(config.trading_timezone),
-            schedule_time=_parse_kst_time(config.daily_preallocation_time),
         )
 
         # Event publisher transport — one dedicated instance for the
@@ -204,6 +192,7 @@ class Daemon:
             ledger_outbox=self.outbox,
             event_emitter=self._make_event_emitter(),
             stale_pending_threshold_sec=config.pending_stale_threshold_sec,
+            instance_key=config.instance_key,
         )
 
         # BAT-011: safety-sell trigger service (forced_close / SL-TP / market-close).
@@ -278,9 +267,10 @@ class Daemon:
             pass
         handler = make_snapshot_rpc_handler(
             self.slot_repo, self.slot_service,
+            instance_key=self.config.instance_key,
             snapshot_store=self.snapshot_store,
             pause_store=self.pause_store,
-            default_total_slots=self.config.total_slots,
+            max_active_slots=self.config.max_active_slots,
             watchdog_store=self.watchdog,
             watchdog_timeout_sec=self.config.safety_sell.watchdog_timeout_sec,
             killswitch_store=self.killswitch_store,
@@ -319,19 +309,12 @@ class Daemon:
         except Exception:  # noqa: BLE001
             _log.exception("snapshot scheduler loop crashed")
 
-    def _preallocation_loop(self) -> None:
-        try:
-            self.preallocation_scheduler.run_forever(self.stop, tick_sec=60.0)
-        except Exception:  # noqa: BLE001
-            _log.exception("preallocation scheduler loop crashed")
-
     # ------------------------------------------------------------ lifecycle
     def setup(self) -> None:
         apply_migrations(self.config.dsn)
-        # dcy-014 / REQ-005: preallocate against the configured trading timezone
-        # (default KST), not the system UTC date. Boot-time run_once ensures the
-        # current TZ-day's slots exist immediately (idempotent).
-        self.preallocation_scheduler.run_once()
+        # dcy-020 (BAT-030): the daily pool preallocation is gone — permanent
+        # asset slots are created/retired by the snapshot scheduler's universe
+        # reconcile (boot fetch runs immediately in its thread).
         self.execution.reconcile()  # REQ-014 restart recovery
         try:
             self.event_publisher.declare_topology(self.config.instance_key)
@@ -346,7 +329,6 @@ class Daemon:
             ("trex-snapshot-rpc", self._snapshot_rpc_loop),
             ("trex-control-rpc", self._control_rpc_loop),
             ("trex-snapshot-scheduler", self._snapshot_scheduler_loop),
-            ("trex-preallocation", self._preallocation_loop),
             ("trex-safety-sell", self._safety_sell_loop),
         ]
         for name, target in workers: