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>

.claude/skills/run-trex-core-daemon/SKILL.md

@@ -19,7 +19,7 @@ The daemon needs three live services. Verify before launching:
 .venv/bin/python - <<'PY'
 import os, psycopg, pika
 from dotenv import load_dotenv
-load_dotenv(".env")
+load_dotenv("config/.env")  # BAT-026: .env lives in the config dir
 psycopg.connect(os.environ["TREX_POSTGRESQL_DSN"], connect_timeout=3).close()
 print("postgres OK")
 p = pika.URLParameters(os.environ["TREX_RABBITMQ_URL"]); p.socket_timeout = 3
@@ -32,28 +32,34 @@ If either fails, fix the infra first — the daemon will not boot without
 `TREX_POSTGRESQL_DSN` and will boot silently degraded if `TREX_RABBITMQ_URL`
 is missing (stub `InMemoryTransport` — strategy modules can't reach it).
 
-### Required env (`.env`, gitignored)
+### Required env (`config/.env`, gitignored) + per-instance TOML
 
 | Variable | Required | Notes |
 |---|---|---|
 | `TREX_POSTGRESQL_DSN` | yes | psycopg DSN |
 | `TREX_RABBITMQ_URL` | yes for real use | e.g. `amqp://admin:admin@localhost:5672/` |
 | `TREX_BROKER` | no | `paper` (default) or `kis` |
-| `TREX_TOTAL_SLOTS` | no | default 10 |
 | `TREX_EXECUTION_INTERVAL_SEC` | no | default 1.0 |
 | `TREX_LEDGER_INTERVAL_SEC` | no | default 1.0 |
-| `TREX_PORTFOLIO_HUB_BASE_URL` | no | if set, real portfolio-hub ledger; else in-memory stub |
+| `TREX_PORTFOLIO_HUB_BASE_URL` | no | if set, real portfolio-hub universe+ledger; else stub universe (pf-005930/pf-000660) + in-memory ledger |
 
-The daemon preallocates slots for **UTC today** (`datetime.now(tz=timezone.utc).date()`).
-KST users near midnight: check `date -u` before driving the daemon — the
-trading_date you query must match what was preallocated.
+`--config <name>` (required since BAT-013) resolves `config/<name>.toml`:
+`instance_key` (queue names: `trex.intent.req.<key>` etc.; `default` keeps
+the literal names) and `max_active_slots` (M cap; unset = no cap).
+
+**BAT-030 (asset-centric)**: there is NO daily preallocation. Permanent asset
+slots (one per universe portfolio, status `inactive`) are created by the
+snapshot scheduler's universe reconcile right after boot. Slot states are
+`inactive / pending_buy / holding / pending_sell / error` — `idle`/`closed`
+no longer exist.
 
 ## Launch
 
-Background, redirect log:
+Background, redirect log (smoke against the test DB: point
+TREX_POSTGRESQL_DSN at `trex_core_test` via `--env-file`, never the live DB):
 
 ```bash
-.venv/bin/trex-core-daemon &> /tmp/trex-core.log &
+.venv/bin/trex-core-daemon --config <instance> &> /tmp/trex-core.log &
 DAEMON_PID=$!
 ```
 
@@ -92,35 +98,40 @@ worked.
 
 The canonical end-to-end smoke is in `smoke.py` — copy/adapt it. It exercises:
 
-1. **snapshot RPC** (view=all) — confirms the daemon answers.
-2. **buy intent RPC** with a fresh `correlation_id` — admitted, slot →
-   `pending_buy`.
-3. **duplicate buy** with the *same* `correlation_id` — identical response,
+1. **snapshot RPC** (view=all) — daemon answers; `slots[]` holds the permanent
+   asset slots from the universe reconcile (status `inactive`).
+2. **buy intent RPC keyed by `slot_id`** (REQ-061 canonical; `portfolio_id`
+   dual-accept) — admitted, slot → `pending_buy`. Rejections: `unknown_slot`,
+   `already_active`, `capacity_full` (M cap).
+3. **duplicate buy** with the *same* `intent_id` — identical response,
    no double transition (intent_log dedup gate, REQ-023 AC-1).
-4. **wait one execution loop tick** — paper broker fills, slot → `holding`,
-   `slot_filled_buy.{strategy_id}.{symbol}` event published.
-5. **sell intent RPC** on the holding slot — slot → `closed`,
-   `slot_filled_sell.{strategy_id}.{symbol}` event published.
+4. **wait one execution loop tick** — paper broker fills, slot → `holding`.
+5. **sell intent RPC** on the holding slot — fill returns the slot to
+   `inactive` (occupancy cleared, asset binding kept — NOT `closed`).
+   Sell dispatch quantity is the **broker balance** (REQ-062); broker flat →
+   the sell is skipped with a WARN.
 
-Run it:
+Run it (instance key optional, default `default`):
 
 ```bash
-.venv/bin/python .claude/skills/run-trex-core-daemon/smoke.py
+.venv/bin/python .claude/skills/run-trex-core-daemon/smoke.py [instance_key]
 ```
 
-Sample output (paper broker, `strategy_id=STRAT-A`):
+Sample output (paper broker, stub universe):
 
 ```
 === 1) snapshot RPC ===
-slots=10 capacity={idle=10, holding=0, pending=0}
-=== 2) buy intent ===
-admitted, slot_id=b2d60fa3-…
-=== 3) duplicate buy ===
+assets=1 slots=2 available_slots=1
+target slot_id=8a160254-… portfolio_id=pf-005930
+=== 2) buy by slot_id ===
+-> admitted reason=None
+=== 3) duplicate buy (same intent_id) ===
 identical: True
 === 4) wait for fill ===
-slot status=holding qty=10 avg_price=60000.0
+slot status=holding qty=10.0 avg_price=1000.0
 === 5) sell intent ===
-admitted; event rk=slot_filled_sell.STRAT-A.005930 status=closed qty=10
+-> admitted
+slot status=inactive qty=None portfolio_id=pf-005930 (asset binding kept)
 DONE
 ```
 
@@ -153,12 +164,12 @@ The daemon's source of truth is PostgreSQL `daily_slot`:
 .venv/bin/python - <<'PY'
 import os, psycopg
 from dotenv import load_dotenv
-load_dotenv(".env")
+load_dotenv("config/.env")
 with psycopg.connect(os.environ["TREX_POSTGRESQL_DSN"]) as c:
     with c.cursor() as cur:
         cur.execute("""
-          SELECT trading_date, status, COUNT(*)
-          FROM daily_slot GROUP BY trading_date, status ORDER BY trading_date DESC, status
+          SELECT instance_key, status, COUNT(*)
+          FROM daily_slot GROUP BY instance_key, status ORDER BY 1, 2
         """)
         for r in cur.fetchall(): print(r)
 PY
@@ -170,7 +181,7 @@ Ledger outbox state (BAT-006):
 .venv/bin/python - <<'PY'
 import os, psycopg
 from dotenv import load_dotenv
-load_dotenv(".env")
+load_dotenv("config/.env")
 with psycopg.connect(os.environ["TREX_POSTGRESQL_DSN"]) as c:
     with c.cursor() as cur:
         cur.execute("SELECT status, last_outcome, COUNT(*) FROM ledger_outbox GROUP BY 1,2 ORDER BY 1,2")
@@ -182,8 +193,10 @@ PY
 
 | Symptom | Cause | Fix |
 |---|---|---|
-| `slots returned: 0` from snapshot | querying wrong `trading_date` | use UTC today, see `date -u` |
-| intent gets `rejected: no_idle_slot` | no preallocated slots for that day OR all 10 in flight | check `daily_slot` rows; restart daemon to repreallocate next UTC day |
+| `slots returned: 0` from snapshot | universe reconcile hasn't run (portfolio-hub down / boot race) | check the scheduler log line `slot reconcile: {'created': N, ...}`; with no hub config the stub universe gives 2 slots |
+| intent gets `rejected: unknown_slot` / `unknown_portfolio` | slot_id/portfolio_id not in this instance's slot set | read `slots[]` from a snapshot RPC first and reuse its `slot_id` |
+| intent gets `rejected: capacity_full` | `max_active_slots` (M) reached — FCFS, no eviction | sell something first or raise M in the instance TOML |
+| sell never dispatches, WARN `sell dispatch skipped` | broker balance 0 for the symbol (REQ-062 divergence) | reconcile the divergence (operator); no mirror fallback by design |
 | `RpcTimeoutError` on the client | daemon not up, or consumer thread crashed | check `/tmp/trex-core.log` for exception trace |
 | `TransportUnavailableError` | RabbitMQ down | the daemon does NOT buffer locally (REQ-024) — fix the broker, then re-issue |
 | fill event missed by ad-hoc subscriber | queue bound *after* publish | bind queue + sleep ≥0.5s before triggering the intent |

.claude/skills/run-trex-core-daemon/smoke.py

@@ -1,186 +1,107 @@
 #!/usr/bin/env python3
-"""End-to-end smoke for trex-core (BAT-007).
+"""End-to-end smoke for trex-core (BAT-030 asset-centric).
 
-Assumes the daemon is already running (`.venv/bin/trex-core-daemon &`).
-Drives it through every RabbitMQ surface:
+Assumes the daemon is already running with `--config <toml>` (see SKILL.md).
+Drives every RabbitMQ surface of the asset-centric model:
 
-  1. snapshot RPC (view=all)             — daemon answers
-  2. buy intent RPC                       — admission + slot transition
-  3. duplicate buy (same correlation_id)  — intent_log dedup gate (REQ-023 AC-1)
-  4. wait for execution tick + fill event
-  5. sell intent RPC                      — slot → closed + sell event
+  1. snapshot RPC (view=all)              — daemon answers; slots[] = permanent
+                                            asset slots created by the universe
+                                            reconcile (status `inactive`)
+  2. buy intent RPC keyed by slot_id      — admission + slot → pending_buy
+     (REQ-061 canonical key; portfolio_id is the legacy dual-accept)
+  3. duplicate buy (same intent_id)       — intent_log dedup gate (REQ-023 AC-1)
+  4. wait for execution tick + fill       — slot → holding
+  5. sell intent RPC                      — slot → pending_sell → fill →
+                                            `inactive` (occupancy cleared,
+                                            asset binding kept; NOT 'closed')
 
-Trading_date defaults to UTC today (matches what the daemon preallocates).
+Pass the instance key as argv[1] (default: "default"). Env from config/.env.
 """
 from __future__ import annotations
 
-import json
 import os
 import sys
-import threading
 import time
 import uuid
-from datetime import date, datetime, timezone
 
 from dotenv import load_dotenv
 
-load_dotenv(".env")
-
-import pika  # noqa: E402
+load_dotenv("config/.env")
 
 from trex_core.adapters.messaging import topology  # noqa: E402
 from trex_core.adapters.messaging.rabbitmq import RabbitMQTransport  # noqa: E402
 
 URL = os.environ.get("TREX_RABBITMQ_URL", "amqp://admin:admin@localhost:5672/")
-TODAY = datetime.now(tz=timezone.utc).date()
-STRATEGY = "STRAT-A"
-SYMBOL = "005930"
-
-
-def _subscribe_events(received: list, stop: threading.Event, queue: str) -> threading.Thread:
-    """Background event consumer bound BEFORE we trigger intents."""
-    def loop() -> None:
-        t = RabbitMQTransport(URL, timeout=5.0)
-        try:
-            t.consume_events_forever(
-                queue,
-                topology.strategy_event_binding_pattern(STRATEGY),
-                lambda rk, p: received.append((rk, p)),
-                stop,
-            )
-        finally:
-            t.close()
-    th = threading.Thread(target=loop, name="smoke-events", daemon=True)
-    th.start()
-    return th
-
-
-def _cleanup_queue(queue: str) -> None:
-    try:
-        c = pika.BlockingConnection(pika.URLParameters(URL))
-        try:
-            c.channel().queue_delete(queue)
-        finally:
-            c.close()
-    except Exception:
-        pass
-
-
-def _print_slots(slots: list) -> None:
-    for s in slots:
-        print(f"  slot {s['slot_id'][:8]}.. status={s['status']:<12} "
-              f"symbol={s['symbol']} strategy_id={s['strategy_id']} qty={s['qty']} "
-              f"avg_price={s['avg_price']}")
+INST = sys.argv[1] if len(sys.argv) > 1 else "default"
 
 
 def main() -> int:
-    ev_queue = f"trex.events.strategy.{STRATEGY}.smoke.{uuid.uuid4().hex[:6]}"
-    ev_received: list[tuple[str, dict]] = []
-    ev_stop = threading.Event()
-    ev_thread = _subscribe_events(ev_received, ev_stop, ev_queue)
-    time.sleep(0.6)  # let queue bind before triggering events
+    mq = RabbitMQTransport(URL, timeout=10.0)
+    snap_q = topology.snapshot_queue(INST)
+    intent_q = topology.intent_queue(INST)
 
-    client = RabbitMQTransport(URL, timeout=5.0)
-    try:
-        # 1) snapshot RPC ---------------------------------------------------
-        print(f"=== 1) snapshot RPC (view=all, day={TODAY.isoformat()}) ===")
-        resp = client.call_rpc(
-            topology.SNAPSHOT_REQ_QUEUE,
-            {"view": "all", "trading_date": TODAY.isoformat()},
-            correlation_id=f"snap-{uuid.uuid4().hex[:8]}",
-            timeout=5.0,
+    def snap():
+        return mq.call_rpc(
+            snap_q,
+            {"view": "all", "actor": "operator", "touch_watchdog": False},
+            correlation_id=str(uuid.uuid4()), timeout=8.0,
         )
-        print(f"slots={len(resp['slots'])} capacity={resp['capacity']}")
-        if resp["capacity"]["idle_count"] == 0:
-            print("\n!! no idle slots for today — restart the daemon to preallocate, "
-                  "or check `date -u`")
-            return 2
 
-        # 2) buy intent RPC ------------------------------------------------
-        print(f"\n=== 2) buy intent RPC ({SYMBOL}, qty=10@60000, "
-              f"strategy={STRATEGY}, portfolio=PF-smoke) ===")
-        cid = f"smoke-buy-{uuid.uuid4().hex[:8]}"
-        resp = client.call_rpc(
-            topology.INTENT_REQ_QUEUE,
-            {
-                "intent_type": "buy", "intent_id": cid,
-                "trading_date": TODAY.isoformat(), "symbol": SYMBOL,
-                "qty": 10, "entry_price": 60000,
-                "strategy_id": STRATEGY, "portfolio_id": "PF-smoke",
-            },
-            correlation_id=cid, timeout=5.0,
-        )
-        print(f"admission: {json.dumps(resp, ensure_ascii=False)}")
-        if resp["status"] != "admitted":
-            print("\n!! buy not admitted — aborting"); return 3
+    def intent(payload):
+        cid = payload.get("intent_id") or str(uuid.uuid4())
+        return mq.call_rpc(intent_q, payload, correlation_id=cid, timeout=8.0)
 
-        # 3) duplicate -----------------------------------------------------
-        print(f"\n=== 3) duplicate buy (same correlation_id={cid[-8:]}…) ===")
-        resp_dup = client.call_rpc(
-            topology.INTENT_REQ_QUEUE,
-            {
-                "intent_type": "buy", "intent_id": cid,
-                "trading_date": TODAY.isoformat(), "symbol": SYMBOL,
-                "qty": 10, "strategy_id": STRATEGY, "portfolio_id": "PF-smoke",
-            },
-            correlation_id=cid, timeout=5.0,
-        )
-        print(f"identical: {resp == resp_dup}  (REQ-023 AC-1 intent_log dedup)")
+    print("=== 1) snapshot RPC ===")
+    s = snap()
+    slots = s["slots"]
+    print(f"assets={len(s['assets'])} slots={len(slots)} "
+          f"available_slots={s['available_slots']}")
+    inactive = [x for x in slots if x["status"] == "inactive"
+                and not x["universe_detached"]]
+    if not inactive:
+        print("no admittable (inactive) asset slot — universe reconcile not "
+              "done yet, or all assets active")
+        return 1
+    target = inactive[0]
+    sid = target["slot_id"]
+    print(f"target slot_id={sid} portfolio_id={target['portfolio_id']}")
 
-        # 4) wait for fill + event -----------------------------------------
-        print(f"\n=== 4) wait for execution tick + fill event (paper broker) ===")
-        deadline = time.monotonic() + 10
-        while time.monotonic() < deadline:
-            resp = client.call_rpc(
-                topology.SNAPSHOT_REQ_QUEUE,
-                {"view": "open", "trading_date": TODAY.isoformat()},
-                correlation_id=f"snap-{uuid.uuid4().hex[:8]}", timeout=5.0,
-            )
-            holdings = [s for s in resp["slots"] if s["status"] == "holding"]
-            if holdings:
-                _print_slots(holdings)
-                break
-            time.sleep(0.5)
-        else:
-            print("\n!! no holding slot appeared in 10s — execution loop stuck?"); return 4
+    print("=== 2) buy by slot_id ===")
+    iid = str(uuid.uuid4())
+    d = intent({"intent_type": "buy", "intent_id": iid, "slot_id": sid,
+                "qty": 10, "entry_price": 1000, "strategy_id": "STRAT-A"})
+    print(f"-> {d['status']} reason={d['reason']}")
+    if d["status"] != "admitted":
+        return 1
 
-        print(f"buy events captured so far: "
-              f"{[rk for rk, _ in ev_received if rk.startswith('slot_filled_buy.')]}")
+    print("=== 3) duplicate buy (same intent_id) ===")
+    d2 = intent({"intent_type": "buy", "intent_id": iid, "slot_id": sid, "qty": 10})
+    print(f"identical: {d2 == d}")
 
-        # 5) sell intent ---------------------------------------------------
-        sid = holdings[0]["slot_id"]
-        scid = f"smoke-sell-{uuid.uuid4().hex[:8]}"
-        print(f"\n=== 5) sell intent on slot {sid[:8]}.. ===")
-        resp_sell = client.call_rpc(
-            topology.INTENT_REQ_QUEUE,
-            {"intent_type": "sell", "intent_id": scid, "slot_id": sid},
-            correlation_id=scid, timeout=5.0,
-        )
-        print(f"admission: {json.dumps(resp_sell, ensure_ascii=False)}")
+    print("=== 4) wait for fill ===")
+    for _ in range(20):
+        time.sleep(0.5)
+        st = next(x for x in snap()["slots"] if x["slot_id"] == sid)
+        if st["status"] == "holding":
+            break
+    print(f"slot status={st['status']} qty={st['qty']} avg_price={st['avg_price']}")
 
-        # Wait for the sell fill event
-        deadline = time.monotonic() + 10
-        while time.monotonic() < deadline and not any(
-            rk.startswith("slot_filled_sell.") for rk, _ in ev_received
-        ):
-            time.sleep(0.3)
+    print("=== 5) sell intent ===")
+    d3 = intent({"intent_type": "sell", "intent_id": str(uuid.uuid4()),
+                 "slot_id": sid})
+    print(f"-> {d3['status']}")
+    for _ in range(20):
+        time.sleep(0.5)
+        st = next(x for x in snap()["slots"] if x["slot_id"] == sid)
+        if st["status"] == "inactive":
+            break
+    print(f"slot status={st['status']} qty={st['qty']} "
+          f"portfolio_id={st['portfolio_id']} (asset binding kept)")
 
-        print(f"\nall events captured ({len(ev_received)}):")
-        for rk, payload in ev_received:
-            print(f"  rk={rk}  status={payload.get('status'):<8} "
-                  f"qty={payload.get('qty')}  sequence_at={payload.get('sequence_at')}")
-
-        print("\nDONE")
-        return 0
-    finally:
-        ev_stop.set()
-        try:
-            client.close()
-        except Exception:
-            pass
-        ev_thread.join(timeout=2.0)
-        _cleanup_queue(ev_queue)
+    mq.close()
+    print("DONE")
+    return 0
 
 
 if __name__ == "__main__":
-    sys.exit(main())
+    raise SystemExit(main())