feat(alarm): trex-core 알람 emitter + trex.alerts exchange (dcy-033 BAT-049, Implemented)

AlarmEmitter(application, best-effort 비차단)+trex.alerts topic exchange 가산·격리+8 CRITICAL code 배선. 608 passed, opus QC PASS, 팀장 e2e(텔레그램 HTTP200) 통과. REQ-098~101 Implemented. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01VHtM5Ws1HKCKQ4JGi6GRb5
2026-06-21 19:25:55 +09:00
parent b2165eac25
commit d4c5fcbba1
29 changed files with 1195 additions and 47 deletions
@@ -0,0 +1,120 @@
 # BAT-049 Design
 - Status: confirmed
 - Batch: BAT-049
 ## Architecture Summary
 알람 시스템을 application 레이어의 `AlarmEmitter`(포트 경유) + adapters 레이어의 `publish_alarm_event()` 확장으로 구현한다. 기존 레이어드 아키텍처(domain/application/adapters/runtime)와 의존성 역전 규칙을 그대로 따른다.
 ```
 발생 지점(execution.py 등)
    │ alarm_emitter.publish_alarm(code, title, fields)
    ▼
 AlarmEmitter (application 레이어)
    │ MessagingTransport.publish_alarm_event(routing_key, payload)
    ▼
 RabbitMQTransport.publish_alarm_event() (adapters 레이어)
    │ basic_publish(exchange=trex.alerts, routing_key=alarm.critical.trex-core, mandatory=False)
    ▼
 trex.alerts exchange → (notifier가 alarm.# 패턴으로 바인딩)
 ```
 `AlarmEmitter`는 `MessagingTransport` 포트만 주입받는다. pika 직접 import 없음. domain 레이어 접촉 없음.
 ## Changed Areas
 | 파일 | 변경 유형 | 내용 |
 |---|---|---|
 | `docs/interface-contract.md` | 추가(기존 불변) | `Interface: trex.alerts (알람 채널, dcy-033)` 섹션 신규 |
 | `trex_core/adapters/messaging/topology.py` | 추가 | `ALERTS_EXCHANGE = "trex.alerts"` 상수 추가 |
 | `trex_core/adapters/messaging/rabbitmq.py` | 확장 | `declare_topology()`에 trex.alerts exchange 선언 + `publish_alarm_event()` 메서드 신규 |
 | `trex_core/adapters/messaging/in_memory.py` | 확장 | `publish_alarm_event()` stub 추가 (발행 기록 + unavailable 시 TransportUnavailableError) |
 | `trex_core/application/messaging.py` | 확장 | `MessagingTransport` Protocol에 `publish_alarm_event()` 추가 |
 | `trex_core/application/alarm_emitter.py` | 신규 | `AlarmEmitter` 클래스 구현 |
 | `trex_core/application/execution.py` | 배선 | `fill_price_unresolvable`, `sell_skipped_no_balance` 알람 호출 추가 |
 | `trex_core/application/reconciliation.py` | 배선 | `core_holding_broker_flat` 알람 호출 추가 |
 | `trex_core/application/ledger_outbox.py` | 배선 | `ledger_delivery_failed` 알람 호출 추가 |
 | `trex_core/application/killswitch.py` | 배선 | `kill_switch_fired` 알람 호출 추가 |
 | `trex_core/adapters/broker/rabbitmq.py`(`messaging/rabbitmq.py`) | 배선 | `publish_unavailable_after_reconnect` / `dlq_publish_failed` — 콜백 패턴 |
 | `trex_core/application/portfolio.py` / `snapshot_scheduler.py` | 배선 | `portfolio_hub_unavailable` 알람 호출 추가 |
 | `trex_core/runtime/reset.py` | 배선 | `schema_verification_failed` / `migration_failed` 알람 호출 (transport None 안전) |
 | `trex_core/runtime/daemon.py` | 조립 | `AlarmEmitter` 생성 + 각 서비스에 주입 |
 | `tests/application/test_alarm_emitter.py` | 신규 | AlarmEmitter 단위 테스트 |
 | `tests/adapters/messaging/test_topology.py` | 확장 | declare_topology trex.alerts assertion |
 | `docs/runtime-flows.md` | 추가(기존 불변) | 알람 발신 흐름 섹션 신규 |
 ## Key Decisions
 ### KD-1: publish_unavailable_after_reconnect / dlq_publish_failed — 콜백 패턴 채택
 **문제**: 두 alarm code는 `trex_core/adapters/messaging/rabbitmq.py`(어댑터) 내부에서 발생하지만, `AlarmEmitter`는 application 레이어에 있다. 어댑터가 application을 직접 import하면 의존성이 역전된다.
 **채택 결정: 콜백(callable) 주입**
 - `RabbitMQTransport`에 `alarm_callback: Optional[Callable[[str, str, dict], None]]` 파라미터를 추가한다. 시그니처: `(code: str, title: str, fields: dict) -> None`.
 - `daemon.py`에서 `AlarmEmitter.publish_alarm`을 콜백으로 주입한다.
 - 어댑터는 application 타입을 import하지 않고, callable 타입 힌트(`Optional[Callable]`)만 사용.
 - 콜백 미주입 시(기본값 None): 기존 동작 유지 (로그만).
 - 콜백이 raise하면 어댑터는 except로 삼킨다(best-effort 원칙 일관).
 **기각 대안**:
 - 이벤트 버스/큐: 과도한 복잡성, 결정론적 단위 테스트 어려움.
 - AlarmEmitter를 adapters 레이어로 이동: domain/application 순수성 원칙 위반.
 - Transport 프로토콜에 alarm_callback getter 추가: Protocol 오염 + 테스트 어려움.
 ### KD-2: reset.py transport None 안전 — AlarmEmitter None-guard 패턴
 **문제**: `reset.py`는 CLI 진입점으로 `MessagingTransport`가 없다. AlarmEmitter에 None transport를 전달하면 호출 시 crash.
 **채택 결정**: `AlarmEmitter.__init__`이 `Optional[MessagingTransport]`를 받고, `publish_alarm()` 내부에서 transport가 None이면 WARN 로그 후 skip.
 - `reset.py`는 `AlarmEmitter(transport=None)`로 생성하거나 `publish_alarm()` 호출 전 None 체크.
 - 실제로는 `run_reset()` 함수가 `AlarmEmitter`를 직접 받는 시그니처로 확장하거나, reset 전용 경량 emitter를 분리한다.
 - 가장 단순한 방법: `AlarmEmitter(transport=None)` 허용 + None guard → reset 코드에서 생성 부담 최소화.
 ### KD-3: publish_alarm_event 시그니처 — transport 레이어 알람 전용 메서드
 **결정**: `MessagingTransport` 프로토콜에 `publish_alarm_event(routing_key: str, payload: dict) -> None` 추가.
 - `publish_event()`와 구분하는 이유: alarm은 `trex.alerts` exchange, `mandatory=False`, `delivery_mode=1`(best-effort, 비영속) vs events는 `trex.events`, `mandatory=True`, `delivery_mode=2`.
 - `InMemoryTransport`: 발행된 alarm을 `_alarm_events: list[tuple[str, dict]]`에 기록 + unavailable 시 TransportUnavailableError 발생(호출자가 삼킴).
 - `RabbitMQTransport`: `publish_alarm_event()`는 `basic_publish(exchange=trex.alerts, mandatory=False, delivery_mode=1)`. 연결 실패 시 TransportUnavailableError raise(AlarmEmitter가 삼킴). retry-on-failure 없음(best-effort 원칙).
 ### KD-4: AlarmEmitter 인터페이스
 ```python
 class AlarmEmitter:
    def __init__(self, transport: Optional[MessagingTransport]) -> None: ...
    def publish_alarm(
        self,
        code: str,
        title: str,
        *,
        fields: dict | None = None,
        severity: str = "critical",
    ) -> None:
        """Best-effort 발행. 실패 시 ERROR 로그 후 예외 삼킴."""
        ...
 ```
 - `source="trex-core"`, `schema_version="1"` 상수화.
 - `occurred_at` = 발행 시점 KST ISO-8601.
 - routing key = `alarm.{severity}.trex-core`.
 - 발행 실패(TransportUnavailableError, 기타 모든 예외): ERROR 로그 후 예외 삼킴(re-raise 금지).
 ## Edge Cases
 - **transport disconnect 중 알람 발행**: `publish_alarm_event()` → TransportUnavailableError → AlarmEmitter가 ERROR 로그 후 삼킴. 본업 경로 비차단.
 - **rabbitmq.py 콜백이 None인 경우**: `alarm_callback` guard로 skip. 기존 코드 변경 없이 하위호환.
 - **reset.py에서 AlarmEmitter(transport=None)**: None guard 분기 → INFO 로그("alarm skipped: no transport") 후 skip.
 - **mandatory=False + notifier 미연결**: silent drop. UnroutableError 없음.
 - **8개 code 중 일부 경로에서 AlarmEmitter 미주입**: daemon.py에서 전부 주입. 미주입 시 AttributeError → execution_loop except로 삼킴(기존 보호 패턴).
 - **AlarmEmitter.publish_alarm 내 예외 루프**: 각 호출마다 독립 try/except. 한 코드 발행 실패가 동일 tick의 다른 호출에 영향 없음.
 ## Architecture Impact
 `both` — runtime-flows.md + interface-contract.md 양쪽 업데이트 필요.
 ## Reference Doc Update Plan
 - `docs/interface-contract.md`: `Interface: trex.alerts (알람 채널, dcy-033)` 섹션 추가 + Change Log 갱신 + Last Updated 갱신.
 - `docs/runtime-flows.md`: `Flow: 알람 발신 (trex.alerts, dcy-033)` 섹션 추가. 기존 섹션 불변.
@@ -0,0 +1,92 @@
 # BAT-049 Implementation
 - Status: completed
 - Batch: BAT-049
 ## Plan Summary
 REQ-098(문서) → REQ-099(topology+transport) → REQ-100(AlarmEmitter+배선) → REQ-101(runtime-flows 정합) 순서로 구현.
 design.md의 4개 Key Decision을 그대로 따름.
 ## Changed Files
 | 파일 | 변경 유형 | 내용 |
 |---|---|---|
 | `docs/interface-contract.md` | 섹션 추가 + 헤더 갱신 | `Interface: trex.alerts (알람 채널, dcy-033)` 신규 섹션 (7필드 스키마, routing key, topology, CRITICAL code 목록, Update Trigger). Change Log + Last Updated 갱신. 기존 섹션 불변. |
 | `trex_core/adapters/messaging/topology.py` | 추가 | `ALERTS_EXCHANGE = "trex.alerts"` + `alarm_routing_key()` 함수 |
 | `trex_core/adapters/messaging/rabbitmq.py` | 확장 | `declare_topology()` trex.alerts 선언 추가. `publish_alarm_event()` 신규. `set_alarm_callback()` + `_fire_alarm_callback()` 신규. 콜백 호출 배선 (publish_unavailable_after_reconnect, dlq_publish_failed). `Callable` import 추가. |
 | `trex_core/adapters/messaging/in_memory.py` | 확장 | `_alarm_events` 리스트 추가. `publish_alarm_event()` stub + `alarm_events()` 조회. |
 | `trex_core/application/messaging.py` | 확장 | `MessagingTransport` Protocol에 `publish_alarm_event()` 추가. |
 | `trex_core/application/alarm_emitter.py` | 신규 | `AlarmEmitter` 클래스. envelope 구성, KST occurred_at, 예외 삼킴+ERROR 로그, None transport skip. |
 | `trex_core/application/execution.py` | 배선 | `AlarmEmitter` import + `alarm_emitter` 파라미터 + `sell_skipped_no_balance` + `fill_price_unresolvable` 발행 배선. |
 | `trex_core/application/reconciliation.py` | 배선 | `AlarmEmitter` import + `alarm_emitter` 파라미터 + `core_holding_broker_flat` 발행 배선. |
 | `trex_core/application/ledger_outbox.py` | 배선 | `AlarmEmitter` import + `alarm_emitter` 파라미터 + `ledger_delivery_failed` 3지점(conflict_blocked, permanent_failure, dead_lettered) 배선. |
 | `trex_core/application/killswitch.py` | 배선 | `AlarmEmitter` import + `alarm_emitter` 파라미터 + `kill_switch_fired` 배선. |
 | `trex_core/application/snapshot_scheduler.py` | 배선 | `AlarmEmitter` import + `alarm_emitter` 파라미터 + `portfolio_hub_unavailable` 2지점(whoami_failed, get_portfolios_failed) 배선. `reconcile_core_holdings` 호출에 `alarm_emitter` 전달. |
 | `trex_core/runtime/reset.py` | 배선 | `_emit_reset_alarm()` 헬퍼 추가. `run_reset()` alarm_emitter 파라미터 추가. migration 예외 + schema_ok=False 지점 배선. |
 | `trex_core/runtime/daemon.py` | 조립 | `AlarmEmitter` import. `alarm_emitter` 생성 (event_publisher 이후). `set_alarm_callback()` 주입. `LedgerWriter`, `KillSwitchService`, `SnapshotScheduler`, `ExecutionService` 생성 시 alarm_emitter 주입. 서비스 생성 순서 재배치(alarm_emitter 생성 후 주입 보장). |
 | `tests/application/test_alarm_emitter.py` | 신규 | AlarmEmitter 단위 테스트 29개 (8 code × envelope 검증, 8 code × TransportUnavailableError 삼킴, 8 code × 임의 예외 삼킴, None transport skip, fields default, routing key, pika 미import, TELEGRAM 미참조). |
 | `tests/adapters/messaging/test_topology.py` | 확장 | `test_alerts_exchange_constant`, `test_alarm_routing_key_format` 추가. |
 | `tests/adapters/messaging/test_in_memory_transport.py` | 확장 | `test_publish_alarm_event_records_event`, `test_publish_alarm_event_raises_when_unavailable` 추가. |
 | `docs/runtime-flows.md` | 섹션 추가 + 헤더 갱신 | `Flow: 알람 발신 (trex.alerts, dcy-033)` 신규 섹션 (발행 흐름, best-effort 정책, 8종 code 목록, trex.events 차이표). 기존 섹션 불변. |
 ## Design Decisions Implemented
 **KD-1 (rabbitmq.py 어댑터 alarm 콜백 패턴)**:
 - `RabbitMQTransport.__init__`에 `alarm_callback: Optional[Callable]` 파라미터 추가.
 - `set_alarm_callback()` setter 추가 (늦은 주입 — daemon.py에서 AlarmEmitter 생성 후 바인딩).
 - `_fire_alarm_callback()` 내부 헬퍼: callback None guard + 예외 삼킴.
 - `publish_event()` retry 실패 시 `publish_unavailable_after_reconnect` 콜백 호출.
 - `_publish_dlq()` DLQ 실패 시 `dlq_publish_failed` 콜백 호출.
 **KD-2 (reset.py transport None 안전)**:
 - `_emit_reset_alarm(alarm_emitter, code, title, fields)` 헬퍼: None guard + 예외 삼킴.
 - `run_reset()` 시그니처에 `alarm_emitter: Optional[object] = None` 추가.
 - migration 예외(raise 전)와 schema_ok=False 지점에서 헬퍼 호출.
 **KD-3 (publish_alarm_event 별도 메서드)**:
 - `trex.alerts` exchange, `mandatory=False`, `delivery_mode=1` (non-persistent).
 - `MessagingTransport` Protocol + `RabbitMQTransport` + `InMemoryTransport` 모두 구현.
 **KD-4 (AlarmEmitter 인터페이스)**:
 - `AlarmEmitter(transport: Optional[MessagingTransport])`.
 - `publish_alarm(code, title, *, fields=None, severity="critical")`.
 - `source="trex-core"`, `schema_version="1"` 고정.
 - `occurred_at` = KST ISO-8601.
 ## Execution Log
 1. docs/interface-contract.md — trex.alerts 섹션 추가 (REQ-098 완료)
 2. topology.py — ALERTS_EXCHANGE + alarm_routing_key() (REQ-099 일부)
 3. messaging.py — publish_alarm_event Protocol 추가 (REQ-099 일부)
 4. rabbitmq.py — declare_topology + publish_alarm_event + 콜백 패턴 (REQ-099 완료 + REQ-100 KD-1)
 5. in_memory.py — publish_alarm_event stub (REQ-099 완료)
 6. alarm_emitter.py — AlarmEmitter 신규 (REQ-100 핵심)
 7. execution.py — fill_price_unresolvable + sell_skipped_no_balance (REQ-100 배선)
 8. reconciliation.py — core_holding_broker_flat (REQ-100 배선)
 9. ledger_outbox.py — ledger_delivery_failed (REQ-100 배선)
 10. killswitch.py — kill_switch_fired (REQ-100 배선)
 11. snapshot_scheduler.py — portfolio_hub_unavailable (REQ-100 배선)
 12. reset.py — schema_verification_failed + migration_failed (REQ-100 배선)
 13. daemon.py — AlarmEmitter 생성·주입 + 서비스 생성 순서 재배치 (REQ-100 조립)
 14. runtime-flows.md — 알람 발신 흐름 섹션 추가 (REQ-101 완료)
 15. 테스트 작성 (test_alarm_emitter.py 29개, topology/in_memory 추가)
 ## Validation
 ```
 pytest tests/application/test_alarm_emitter.py -v
 → 29 passed, 0 failed, 0 skipped
 pytest --tb=short -q (전체)
 → 608 passed, 47 skipped, 0 failed
 ruff check trex_core/ tests/
 → All checks passed!
 ```
 ## Remaining Risks
 - R-1(Low): `trex.alerts` exchange 선언은 실 RabbitMQ에서만 검증 가능 (단위에서 mock). 팀장이 실인프라 통합 테스트 수행 예정.
 - R-2(Low): daemon.py에서 event_publisher가 `InMemoryTransport`인 경우 `set_alarm_callback()`이 없어 `hasattr` guard 처리됨 (InMemoryTransport는 콜백 불필요).
 - R-3(Low): reset.py의 `alarm_emitter` 파라미터가 `main()`(CLI 진입점)에서 None으로 실행됨 — 의도된 동작이나 실인프라 CLI 시나리오에서 알람 미발행.
@@ -0,0 +1,52 @@
 # BAT-049: 알람 시스템 — 알람 envelope wire 계약 + trex.alerts exchange + core CRITICAL emitter + baseline 정합 (dcy-033)
 - Status: release-candidate
 - Profile: standard
 - Source Discovery: dcy-033
 - Included REQ: REQ-098 (Interface), REQ-099 (Integration), REQ-100 (Integration), REQ-101 (Documentation)
 - Excluded REQ: 없음
 ## Summary
 - dcy-033(제품군 알람 전달 체계) confirmed Discovery에서 확정된 알람 시스템 1단계 구현.
 - REQ-098: 알람 envelope 표준 JSON 스키마 wire 계약을 `docs/interface-contract.md`에 문서화.
 - REQ-099: `trex.alerts` (topic, durable=True) AMQP exchange를 `declare_topology()`에 멱등 선언 추가.
 - REQ-100: application 레이어 `AlarmEmitter` + CRITICAL code 8종 발생 지점 배선.
 - REQ-101: `docs/runtime-flows.md`에 알람 발신 흐름 섹션 추가 + baseline 문서 정합.
 ## Scope
 - In Scope:
  - `docs/interface-contract.md` — `Interface: trex.alerts (알람 채널, dcy-033)` 신규 섹션 추가(기존 섹션 불변)
  - `trex_core/adapters/messaging/topology.py` — `ALERTS_EXCHANGE` 상수 추가
  - `trex_core/adapters/messaging/rabbitmq.py` — `declare_topology()`에 `trex.alerts` 선언, `publish_alarm_event()` 메서드 추가
  - `trex_core/adapters/messaging/in_memory.py` — `publish_alarm_event()` stub 추가
  - `trex_core/application/messaging.py` — `MessagingTransport` 프로토콜에 `publish_alarm_event()` 추가
  - `trex_core/application/alarm_emitter.py` — `AlarmEmitter` 신규 구현
  - `trex_core/application/execution.py` — `fill_price_unresolvable`, `sell_skipped_no_balance` 배선
  - `trex_core/application/reconciliation.py` — `core_holding_broker_flat` 배선
  - `trex_core/application/ledger_outbox.py` — `ledger_delivery_failed` 배선
  - `trex_core/application/killswitch.py` — `kill_switch_fired` 배선
  - `trex_core/adapters/broker/rabbitmq.py` — `publish_unavailable_after_reconnect` / `dlq_publish_failed` 배선 (콜백 패턴)
  - `trex_core/application/portfolio.py` / `trex_core/application/snapshot_scheduler.py` — `portfolio_hub_unavailable` 배선
  - `trex_core/runtime/reset.py` — `schema_verification_failed` / `migration_failed` 배선 (transport None 안전)
  - `trex_core/runtime/daemon.py` — `AlarmEmitter` 생성·주입
  - `tests/application/test_alarm_emitter.py` — AlarmEmitter 단위 테스트 신규
  - `tests/adapters/messaging/test_topology.py` 또는 `test_in_memory_transport.py` — declare_topology trex.alerts assertion 추가
  - `docs/runtime-flows.md` — 알람 발신 흐름 섹션 추가
 - Out of Scope:
  - trex.events / trex.intent.req / trex.slots.req / trex.control.req 변경 — 가산·격리 불변(REQ-099 AC-2)
  - 텔레그램 봇 토큰·chat_id 등 외부 알람 시크릿 — trex-notifier 담당
  - INFO·WARN code 배선 — CRITICAL 우선(dcy-033 범위 경계)
  - 통합/e2e(실 RabbitMQ) 테스트 — 팀장이 실인프라로 수행
 ## Documents
 - Planning: [planning.md](./planning.md)
 - Design: [design.md](./design.md)
 - Implementation: [implementation.md](./implementation.md)
 - Verification: [verification.md](./verification.md)
 ## Notes
 - 이 batch는 신규 AMQP exchange(`trex.alerts`) 추가이지만 기존 wire 계약(exchange/큐/라우팅)을 변경하지 않는 가산·격리 추가이므로 wire 계약 변경 에스컬레이션 대상이 아님.
 - `publish_unavailable_after_reconnect` / `dlq_publish_failed`는 rabbitmq.py 어댑터에서 발생 → 콜백 패턴으로 상위에 전파. 설계 결정 details는 design.md 참조.
 - `reset.py`는 transport 미연결 가능 → `AlarmEmitter`가 `None` transport를 안전하게 처리.
 - R-1(Low): trex.alerts exchange 선언 후 notifier 미연결 시 알람 발행은 `mandatory=False`로 silent drop — 운영상 무해.
 - R-2(Low): rabbitmq.py 어댑터 콜백 주입 시 생성 시점 의존성 순환 가능성 → daemon.py에서 생성 순서 주의.
@@ -0,0 +1,54 @@
 # BAT-049 Planning
 - Status: confirmed
 - Batch: BAT-049
 - Profile: standard
 ## Included REQ
 - REQ-098: 알람 envelope wire 계약 정의 (Interface — 문서 전용)
 - REQ-099: trex.alerts AMQP exchange 토폴로지 + 가산·격리 불변식 (Integration)
 - REQ-100: trex-core 알람 emitter — CRITICAL code 발신 배선 (Integration)
 - REQ-101: 알람 발신 흐름 baseline 문서 정합 (Documentation)
 ## Delivery Plan
 REQ-098(문서), REQ-099(topology), REQ-100(emitter + 배선), REQ-101(문서 정합)은 단일 인과 사슬을 형성한다:
 - REQ-098 wire 계약 문서가 선행 확정되어야 REQ-100 emitter 구현의 필드/타입 근거가 생긴다.
 - REQ-099 topology 선언이 선행되어야 REQ-100 발행 경로가 확보된다.
 - REQ-101은 REQ-098~100 구현이 완료된 후 baseline 문서를 정합한다.
 구현 순서:
 1. **REQ-098 먼저**: `docs/interface-contract.md`에 `Interface: trex.alerts (알람 채널, dcy-033)` 섹션 추가 (기존 섹션 불변). 이 문서가 이후 구현의 단일 출처.
 2. **REQ-099**: topology 상수 + `declare_topology()` 확장 + `publish_alarm_event()` 포트/어댑터 추가.
 3. **REQ-100**: `AlarmEmitter` 구현 + 8개 CRITICAL 발생 지점 배선. `rabbitmq.py` 콜백 설계 병행.
 4. **REQ-101**: `docs/runtime-flows.md` 알람 발신 섹션 추가 + `docs/interface-contract.md` Change Log + Last Updated 갱신.
 5. **테스트**: AlarmEmitter 단위 테스트(8 code × 2 케이스) + declare_topology assertion + 기존 테스트 회귀.
 ## Dependencies
 - BAT-047(trex.events 재연결 신뢰성): 완료(release-candidate) — `RabbitMQTransport.publish_event()` 재시도 패턴을 `publish_alarm_event()`에서 참조.
 - BAT-048(체결가 백필/알람 스파이크): 완료 — REQ-097 스파이크에서 trex.alerts AMQP 채널이 최우선 채택됨.
 - `MessagingTransport` 포트 (BAT-007): `publish_alarm_event()` 메서드 추가로 확장. 기존 메서드 시그니처 불변.
 ## Design Gate
 **Design 필요: yes (standard — application 레이어 신규 컴포넌트 + 어댑터 확장 + 의존성 역전 설계 결정)**
 - `publish_unavailable_after_reconnect` / `dlq_publish_failed`가 어댑터(`rabbitmq.py`)에서 발생하는데 `AlarmEmitter`는 application에 있다 → 콜백 패턴 vs 이벤트 버스 선택을 design에서 확정해야 함.
 - `reset.py`(CLI 진입점)에서 transport 미연결 가능 → None-safe 처리 방식 설계 필요.
 - `MessagingTransport` 프로토콜 확장이 기존 `InMemoryTransport` 호환성을 유지하는지 확인 필요.
 ## Milestones
 1. REQ-098 문서 완성 (interface-contract.md 신규 섹션)
 2. REQ-099 topology + publish_alarm_event 포트/어댑터 구현
 3. REQ-100 AlarmEmitter + 8개 배선 완성
 4. REQ-101 baseline 문서 정합
 5. 단위 테스트 전부 통과 + ruff clean
 ## Risks
 - R-1(Low): `publish_alarm_event` 시그니처 추가 시 `InMemoryTransport`에 stub 구현 누락 → Protocol mismatch. 완화: design 에서 확인 + test에서 isinstance 체크 추가.
 - R-2(Low): rabbitmq.py 어댑터 콜백 주입 시 daemon.py의 생성 순서 순환 가능성. 완화: design에서 콜백 늦은 주입(setter) 패턴 채택.
 - R-3(Low): 기존 단위 테스트 InMemoryTransport 사용분이 declare_topology 호출 없이 통과해야 함. 완화: in_memory declare_topology는 no-op 유지.
@@ -0,0 +1,102 @@
 # BAT-049 Verification
 - Status: confirmed
 - Ready for Release: true
 ## Human Approval Memo
 - Approved by: 팀장
 - Approved at: 2026-06-21 (KST)
 - Approved scope: BAT-049 confirm-batch-verification 승인 — QC PASS-WITH-NOTES (blocker 0) + 팀장 실인프라 e2e 통과
 - Residual risk accepted:
  - reset.py 2 code(`schema_verification_failed`/`migration_failed`) 간접 검증(기존 reset 테스트 회귀) — 직접 AC 매핑 minor 갭. 정직 공개됨.
  - 배포 시 운영 AMQP 설정은 코드 아닌 ops 항목.
 - Approval rationale:
  - 단위: 608 passed / 47 skipped / 0 fail. 신규 AlarmEmitter 29 테스트 포함. ruff clean.
  - 독립 opus QC=PASS-WITH-NOTES (blocker 0): best-effort 비차단 · 서비스 생성 순서 재배치 안전 · 가산격리(기존 exchange/큐 불변) · domain 순수성 · 시크릿 0 확인.
  - 팀장 실인프라 e2e(2026-06-21): 실 RabbitMQ에 `trex.alerts`(topic,durable) 선언·발행(`alarm.critical.trex-core`) → trex-notifier 수신 → CRITICAL 분류 → 텔레그램 sendMessage HTTP 200. 기존 토폴로지 불변 확인.
 - Batch: BAT-049
 ## Test Execution Results
 ```
 pytest tests/application/test_alarm_emitter.py -v
 → 29 passed, 0 failed, 0 skipped
 pytest --tb=short -q (전체 스위트)
 → 608 passed, 47 skipped, 0 failed
 ruff check trex_core/ tests/
 → All checks passed!
 ```
 실행 환경: Python 3.12.3, pytest 8.4.2, 2026-06-21
 ## Acceptance Criteria Mapping
 ### REQ-098: 알람 envelope wire 계약 정의
 | AC | 검증 방법 | 결과 |
 |---|---|---|
 | AC-1: `docs/interface-contract.md`에 `Interface: trex.alerts` 섹션이 7개 필드 포함 | 수동 확인 | PASS — 섹션 추가됨, 7필드 명시 |
 | AC-2: severity 값이 3 리터럴 제한 + schema_version="1" 명시 | 수동 확인 | PASS — 명시됨 |
 | AC-3: 기존 섹션 내용 불변 (diff=신규 섹션 추가뿐) | 수동 확인 (기존 텍스트 비교) | PASS — 기존 섹션 변경 없음 |
 | AC-4: routing key `alarm.{severity}.{source}` 형식 명시 | 수동 확인 | PASS — 섹션에 명시됨 |
 | AC-5: Update Trigger 포함 | 수동 확인 | PASS — `Update Trigger (알람 envelope 스키마)` 서브섹션 존재 |
 | AC-6: 다른 모듈 개발자가 `trex_core` import 없이 envelope 정보 획득 가능 | 수동 확인 | PASS — 섹션에 모든 필드·타입·routing key 포함 |
 ### REQ-099: trex.alerts AMQP exchange 토폴로지 + 가산·격리 불변식
 | AC | 검증 방법 | 결과 |
 |---|---|---|
 | AC-1: `declare_topology()` 호출 시 `trex.alerts`(topic, durable=True) 선언 | `test_alerts_exchange_constant` + `test_alarm_routing_key_format` (topology 상수 검증) + rabbitmq.py 코드 확인 | PASS (단위) / 미실행 (실 RabbitMQ 통합) |
 | AC-2: 기존 exchange/큐 type·durable·인수 불변 | 기존 테스트 스위트 608 통과 (회귀 없음) | PASS |
 | AC-3: mandatory=False → unroutable 시 silent success | `publish_alarm_event()` 구현 + `test_publish_alarm_event_records_event` (InMemory) | PASS (단위) / 미실행 (실 RabbitMQ 통합) |
 | AC-4: interface-contract.md 토폴로지 명세(exchange명/타입/durable/routing key/발행자/소비자) | 수동 확인 | PASS — 섹션에 모두 명시 |
 | AC-5: 기존 topology 단위 테스트 + 신규 trex.alerts assertion 통과 | `test_topology.py` 5개 테스트 (신규 2개 포함) 통과 | PASS |
 | AC-6: transport disconnect 시 알람 silently skip | `test_publish_alarm_transport_unavailable_no_reraise` 8 code × PASS | PASS |
 ### REQ-100: trex-core 알람 emitter — CRITICAL code 발신 배선
 | AC | 검증 방법 | 결과 |
 |---|---|---|
 | AC-1: 8개 code 각각 올바른 envelope (`source/severity/schema_version`) | `test_publish_alarm_envelope_fields` 8 code parametrize | PASS |
 | AC-2: TransportUnavailableError 시 re-raise 없음 + ERROR 로그 | `test_publish_alarm_transport_unavailable_no_reraise` 8 code | PASS |
 | AC-3: 임의 예외 시 re-raise 없음 + ERROR 로그 | `test_publish_alarm_arbitrary_exception_swallowed` 8 code | PASS |
 | AC-4: 알람 발행 실패가 core 본업 경로 비차단 | 코드 확인: try/except 삼킴 패턴, 기존 execution/killswitch/ledger/reconcile 테스트 모두 통과 | PASS |
 | AC-5: TELEGRAM_* 참조 0건 | `test_alarm_emitter_no_telegram_reference` + `grep -r TELEGRAM trex_core/` → 0건 | PASS |
 | AC-6: 8 code × 2 케이스 (정상 + 예외) 모두 통과 | 29개 test 통과 | PASS |
 | AC-7: pika 직접 import 없음 | `test_alarm_emitter_no_pika_import` | PASS |
 | AC-8: domain 레이어 messaging import 없음 | `test_domain_import_sweep.py` 기존 통과 유지 | PASS |
 ### REQ-101: 알람 발신 흐름 baseline 문서 정합
 | AC | 검증 방법 | 결과 |
 |---|---|---|
 | AC-1: `docs/runtime-flows.md`에 `Flow: 알람 발신 (trex.alerts, dcy-033)` 섹션 존재 | 수동 확인 | PASS |
 | AC-2: AlarmEmitter → MessagingTransport → trex.alerts 흐름 + best-effort 정책 명시 | 수동 확인 | PASS |
 | AC-3: CRITICAL code 8종 + 발생 모듈 경로 기술 | 수동 확인 (표 형식으로 10개 항목 포함 — schema_verification_failed/migration_failed 별도 행) | PASS |
 | AC-4: trex.events와의 차이(독립 exchange, mandatory=False, DLQ 없음) 명시 | 수동 확인 (비교 표 포함) | PASS |
 | AC-5: `docs/interface-contract.md` Change Log에 dcy-033 항목 기록 | 수동 확인 | PASS |
 | AC-6: 두 문서 `Last Updated (KST)` 갱신 | 수동 확인 (2026-06-21 BAT-049) | PASS |
 ## Regression Evidence
 - 기존 608개 테스트 전부 통과 (47 skipped 유지 — DB/Redis/실RabbitMQ 의존 테스트)
 - `tests/domain/test_domain_import_sweep.py` — domain 순수성 불변식 통과
 - execution/reconciliation/killswitch/ledger_outbox 관련 기존 테스트 전부 통과
 ## Missing Evidence (통합 — 팀장 실인프라 수행)
 1. **실 RabbitMQ `trex.alerts` exchange 선언**: `declare_topology()` 호출 후 RabbitMQ 관리 콘솔에서 exchange 존재·속성(topic, durable=True) 확인.
 2. **실 RabbitMQ mandatory=False 발행**: notifier 큐 미바인딩 상태에서 `publish_alarm_event()` 호출 → 예외 없이 성공 확인.
 3. **실 RabbitMQ 기존 topology 불변**: 기존 exchange/큐 목록이 변경 없이 유지되는지 확인.
 ## Blocking Issues
 없음 (단위 테스트 전부 통과, 통합은 팀장 실인프라 수행으로 위임됨).
 ## Notes
 - 이 verification은 단위 테스트 결과와 코드 수동 검토만 포함한다. 실인프라 통합 테스트는 `Missing Evidence` 3건으로 명시했으며 confirm-batch-verification 전에 팀장이 수행한다.
 - `schema_verification_failed` / `migration_failed`는 ALARM-INVENTORY.md §A에 단일 항목(`schema_verification_failed / migration_failed`)으로 기재되어 있으나, 구현에서는 두 개별 code로 분리 배선하고 테스트에서는 `schema_verification_failed`와 `migration_failed` 대신 `CRITICAL_CODES` 리스트 8개만 parametrize했다. reset.py 배선은 `test_reset.py` 기존 테스트 회귀로 간접 검증.
@@ -56,3 +56,4 @@
 | BAT-046 | standard | released | REQ-086, REQ-088, REQ-089, REQ-090 | dcy-029 (issue #29, P1) | [bat-046](./bat-046_20260616_observability-classification-pnl-runbook/) |
 | BAT-047 | standard | release-candidate | REQ-091, REQ-092, REQ-093, REQ-094 | dcy-031 | [bat-047](./bat-047_20260619_event-publisher-connection-reliability/) |
 | BAT-048 | standard | in-delivery | REQ-095, REQ-096, REQ-097 | dcy-032 | [bat-048](./bat-048_20260621_fill-price-backfill-guard-logging-alert-spike/) |
 | BAT-049 | standard | release-candidate | REQ-098, REQ-099, REQ-100, REQ-101 | dcy-033 | [bat-049](./bat-049_20260621_alarm-system-dcy-033/) |
@@ -213,7 +213,7 @@ REQ 초안 작성 인계 시점의 확정 플래그와 섹션 참조만 기록
 ## Freeze 플래그
 - Handoff Decision: REQ Drafting 진행 가능
- Handoff Rationale: confirm-discovery 완료. OQ-1(전송=`trex.alerts` AMQP)·OQ-2(paging=§A 전체) 모두 사장님 확정 → Open OQ 0건. 범위(P1 아웃바운드)·성공기준·리스크 책임자 확정. DATA(텔레그램 봇 토큰)는 delivery 단계 필요(비차단). 단 **구현(delivery)은 첫 tsl REL(M2) 이후 큐잉** — draft-req는 병렬 가능하나 delivery 우선순위는 M2 뒤.
+- Handoff Rationale: confirm-discovery 완료. OQ-1(전송=`trex.alerts` AMQP)·OQ-2(paging=§A 전체) 모두 사장님 확정 → Open OQ 0건. 범위(P1 아웃바운드)·성공기준·리스크 책임자 확정. DATA(텔레그램 봇 토큰)는 e2e 단계 필요(비차단). **알람은 M2 포함 확정(사장님 2026-06-21) — delivery 착수.** (※이전 "M2 이후 큐잉"은 팀장 오판 정정. 원합의=가능하면 M2 포함이었고 BAT-048 완료로 착수 시점 도달. 알람은 best-effort·별도 채널이라 매매 위험 0.)
 - Ready for REQ Drafting: true
 - Confirmed By: 팀장(Claude)
 - Confirmed At (KST): 2026-06-21 (KST)
@@ -4,7 +4,7 @@
 - Baseline Seed: .stage-pilot/bootstrap/baseline.yaml
 - Status: draft
 - Owner: project maintainers
- Last Updated (KST): 2026-06-08 (BAT-023)
+- Last Updated (KST): 2026-06-21 (BAT-049 — dcy-033 알람 채널 trex.alerts 추가)
 - Source Discovery / Batch: bootstrap-baseline (pre-Discovery); HTTP API = dcy-002 / BAT-002
 - Primary Runtime: daemon (HTTP API) + library (slot 도메인)
@@ -459,11 +459,88 @@ resume_kill_switch 요청·응답 (REQ-046):
 - 외부 HTTP API / CLI 표면 없음(trex-orbit 의 `trex slot` CLI 미이식).
 - 패키지 네임스페이스 결정(plan.md OQ-1)에 따라 import 경로 계약이 확정된다.
 ## Interface: `trex.alerts` (알람 채널, dcy-033)
 - Type: amqp-messaging (topic exchange)
 - Consumers / Producers: 모든 모듈(trex-core/orb/tsl/kdh)(발행자) ↔ trex-notifier(단일 소비자)
 - Purpose: 제품군 CRITICAL 알람 발신 전용 채널. `trex.events`와 독립 분리. best-effort 비차단.
 - Stability: experimental (BAT-049)
 ### Exchange 토폴로지
 | 종류 | 이름 | 타입/속성 | 용도 |
 |---|---|---|---|
 | 익스체인지 | `trex.alerts` | topic, durable=True | 알람 envelope 발행 전용 독립 채널 |
 - **발행자**: 모든 모듈(trex-core, trex-orb-v1, trex-tsl-v1, kis-data-hub). 각 모듈이 자신의 RabbitMQ 연결에서 직접 발행.
 - **소비자**: trex-notifier 단독. 자신의 큐를 `alarm.#`(또는 severity별 `alarm.critical.#`) 패턴으로 바인딩. 큐 선언·바인딩은 trex-notifier 소유.
 - **발행 속성**: `mandatory=False` — notifier 큐 미연결(unroutable) 시 silent drop. core 발행 경로 비차단.
 - **기존 exchange 불변**: `trex.events`(topic), `trex.events.dlq`(fanout), `trex.direct`(topic), `trex.broadcast`(fanout) 등 기존 AMQP 엔티티는 이 채널 추가로 변경되지 않는다(가산·격리 원칙).
 ### Routing Key 규약
 ```
 alarm.{severity}.{source}
 ```
 - `severity` ∈ `critical` | `warn` | `info` (소문자 리터럴)
 - `source` = 발신 모듈 식별자 (예: `trex-core`, `trex-orb-v1`, `trex-tsl-v1`, `kis-data-hub`)
 - 예시: `alarm.critical.trex-core`, `alarm.warn.trex-tsl-v1`
 ### Alarm Envelope JSON 스키마 (schema_version="1")
 ```json
 {
  "source":         "trex-core",
  "severity":       "critical",
  "code":           "kill_switch_fired",
  "title":          "긴급 청산 발동: global scope, liquidated=3",
  "fields":         {"scope": "global", "liquidated": 3},
  "occurred_at":    "2026-06-21T09:30:00+09:00",
  "schema_version": "1"
 }
 ```
 | 필드 | 타입 | 필수 | 설명 |
 |---|---|---|---|
 | `source` | str | 필수 | 발신 모듈 식별자. 소비자(trex-notifier)의 연쇄 분석 기준. |
 | `severity` | `"critical"` \| `"warn"` \| `"info"` | 필수 | 등급 (소문자 리터럴 3개). |
 | `code` | str | 필수 | 알람 식별 코드. ALARM-INVENTORY.md의 code 키 채택. |
 | `title` | str | 필수 | 사람이 읽는 1행 요약. 자격증명·내부 예외 본문 제외. |
 | `fields` | dict[str, any] | 선택 | 구조화 컨텍스트. opaque — core/notifier 내용 강제 파싱 없음. 빈 dict `{}` 허용. |
 | `occurred_at` | ISO-8601 datetime | 필수 | 발생 시점. 권장: KST+09:00 offset-aware. UTC도 수용. |
 | `schema_version` | str | 필수 | 현재 `"1"`. 소비자는 미인식 버전 무시·WARN. |
 ### trex-core CRITICAL code 목록 (schema_version="1")
 trex-core가 `source="trex-core"`, `severity="critical"`로 발행하는 초기 배선 code:
 | code | 발생 지점 | 조건 |
 |---|---|---|
 | `fill_price_unresolvable` | `execution.py` | 체결가·지정가 모두 미해결 → 슬롯 PENDING 고착 |
 | `sell_skipped_no_balance` | `execution.py` | 매도 dispatch skip (브로커 잔고 0) |
 | `core_holding_broker_flat` | `reconciliation.py` | 슬롯 보유인데 브로커 잔고 0 (정산 불일치) |
 | `ledger_delivery_failed` | `ledger_outbox.py` | 원장 영구 실패/dead-letter/409 충돌 |
 | `kill_switch_fired` | `killswitch.py` | 긴급 청산 발동 |
 | `publish_unavailable_after_reconnect` | `adapters/messaging/rabbitmq.py` | 재연결 후에도 이벤트 발행 불가 |
 | `dlq_publish_failed` | `adapters/messaging/rabbitmq.py` | DLQ 발행 실패 |
 | `portfolio_hub_unavailable` | `portfolio.py` / `snapshot_scheduler.py` | 포트폴리오/현금 정보 부실화 |
 | `schema_verification_failed` | `reset.py` | 리셋 후 schema 검증 실패 |
 | `migration_failed` | `reset.py` | 마이그레이션 실패 |
 ### Update Trigger (알람 envelope 스키마)
 - 알람 envelope 스키마를 변경(필드 추가 포함)하면 이 섹션을 갱신하고 `schema_version`을 올리거나 additive 변경 여부를 명시한다.
 - breaking 변경은 `schema_version` 주 버전 증가 필수.
 - additive 변경(신규 선택 필드 추가)은 `schema_version` 유지 가능하되 이 섹션에 변경 이력 기술.
 - 다른 모듈(orb/tsl/kdh)은 이 계약 섹션을 단일 출처로 참조한다. `trex_core` import 없이 envelope 구성에 필요한 모든 정보가 이 섹션에 포함된다.
 ## Update Triggers
 - Update this document when an externally visible API, event, CLI, or file contract changes.
 - Update this document when a batch changes compatibility, validation, or error behavior.
 - Update this document when a new external consumer or producer is introduced.
 - **알람 envelope 스키마 변경** 시 `Interface: trex.alerts` 섹션 Update Trigger 참조.
 ## Change Log
@@ -478,4 +555,5 @@ resume_kill_switch 요청·응답 (REQ-046):
 - 2026-06-15 :: BAT-042 (dcy-028) — slot strategy-state 계약: 신규 write RPC `trex.slots.strategy_state.set`(occupancy_seq+version CAS, reject reason 집합 `occupancy_changed`/`version_conflict`/`slot_inactive`/`state_too_large`/`bad_request`), `trex.slots.req` 행에 additive `occupancy_seq`+`strategy_state` 맵(REQ-073 AC-7/REQ-074 AC-6, opaque UTF-8+size cap, strategy_* reasoning 필드와 구분). close(`→INACTIVE`) 시 state 자동 삭제 (REQ-079~082).
 - 2026-06-11 :: BAT-035 (dcy-025) — `trex.snapshot.req` → `trex.slots.req` lockstep 교체: 요청 `{filter, spy}`, 응답 `{slots[], degraded, reason, message}`. 슬롯 row 에 hub `asset_quantity`/`cash_balance` + `warned`/`cash_estimated`/`watchdog`/`paused` 병합(REQ-073/074). `trex.snapshot.req` envelope(`assets[]`/`available_slots`/view enum) 제거(REQ-028 Deprecated). strategy 필드 제거(REQ-074 AC-5). CLI `universe`/`slots` → `trex.slots.req`(spy=true). `trex.direct` channel_type `snapshot` → `slots`.
 - 2026-06-11 :: BAT-036 (dcy-024) — `safety_sell_enabled: bool=True` per-instance TOML 플래그 추가(REQ-048 CHG-01). `false` 시 `trex-safety-sell` worker 미기동 + WARNING 로그(REQ-005 CHG-01).
 - 2026-06-21 :: BAT-049 (dcy-033) — 알람 채널 `trex.alerts` (topic, durable) 신규 추가. 알람 envelope 표준 JSON 스키마(7필드: source/severity/code/title/fields/occurred_at/schema_version, schema_version="1"), routing key `alarm.{severity}.{source}`, 발행자(모든 모듈)/소비자(trex-notifier), mandatory=False best-effort 정책. trex-core CRITICAL code 10종 초기 배선. 기존 wire 계약 불변(가산·격리). (REQ-098~101)
 - 2026-06-10 :: BAT-031 (dcy-021 포지션 사이징) — 매수 intent 가 **holding 슬롯 대상이면 증액**(qty+price 추가 매수; M 캡 미적용); 매도 intent 에 **`qty`(부분 매도, 선택)** 추가 — 지정 시 `min(qty, 브로커잔고)` 부분 매도(잔량 holding), 미지정 시 전량(→inactive). 상태머신 13 전이(holding→pending_buy). avg_price 증액 가중평균·부분 매도 cost basis 유지. (REQ-066/057/061/062)
@@ -4,7 +4,7 @@
 - Baseline Seed: .stage-pilot/bootstrap/baseline.yaml
 - Status: draft
 - Owner: project maintainers
- Last Updated (KST): 2026-06-21 (BAT-048 — dcy-032 체결가 0/None 백필 가드 + WARN 로깅)
+- Last Updated (KST): 2026-06-21 (BAT-049 — dcy-033 알람 발신 흐름 추가)
 - Source Discovery / Batch: bootstrap-baseline (pre-Discovery); 데몬/HTTP 흐름 = dcy-002 / BAT-002
 - Primary Runtime: daemon (HTTP API) + library (slot 도메인)
@@ -382,3 +382,63 @@ timeout 미지정·취소 실패로 잔여 고착된 pending 슬롯을 처분:
 - 2026-06-10 :: BAT-031 (dcy-021) — 포지션 사이징(증액·부분 감액) 흐름 추가, transit 13 전이.
 - 2026-06-12 :: BAT-038 (dcy-026/issue #24) — 매도 증권거래세 누락 정정: `체결 → ledger outbox` flow 의 `tax=0` → `calculate_tax(side, amount)`(매도 0.2%/매수 0) 정책 계산. fee/tax 단일 정책 지점 + env(`TREX_KIS_FEE_BPS`/`TREX_KRX_TAX_SELL_BPS`), paper·KIS 동일 공유, `tax=0.0` 하드코딩 제거 (REQ-018 CHG-20260612-01).
 - 2026-06-12 :: BAT-041 (dcy-027/issue #20 이월) — 중장기 인스턴스 병행 운영 flow 신설: 전용 instance_key 프로파일(`config/longterm.example.toml`), `watchdog_timeout_sec` per-instance TOML(REQ-076, env 폴백), 보호 규칙 경계(전략 모듈 전적 책임 + CLI exit 백스톱, 코어 손절매 미사용), forced_close_at 중장기 미사용 (REQ-076~078).
 - 2026-06-21 :: BAT-049 (dcy-033) — 알람 발신 흐름 신설: `AlarmEmitter` → `MessagingTransport.publish_alarm_event()` → `trex.alerts` exchange, best-effort 비차단 정책, transport None 안전 skip, CRITICAL code 8종 발생 지점 목록.
 ## Flow: 알람 발신 (trex.alerts, dcy-033)
 trex-core가 CRITICAL 조건 발생 시 `trex.alerts` exchange로 표준 alarm envelope을 발행한다.
 ### 발행 흐름
 ```
 발생 지점 (execution.py / killswitch.py / reconciliation.py 등)
    │ alarm_emitter.publish_alarm(code, title, fields=...)
    ▼
 AlarmEmitter.publish_alarm()      [application 레이어]
    │  envelope 구성: source="trex-core", severity="critical",
    │  schema_version="1", occurred_at=KST ISO-8601
    │  routing_key = "alarm.critical.trex-core"
    │  MessagingTransport.publish_alarm_event(routing_key, payload)
    ▼
 RabbitMQTransport.publish_alarm_event()   [adapters 레이어]
    │  basic_publish(exchange=trex.alerts, mandatory=False, delivery_mode=1)
    ▼
 trex.alerts exchange (topic, durable=True)
    │  notifier가 alarm.# 패턴으로 바인딩한 큐
    ▼
 trex-notifier (단일 소비자) → 텔레그램 등 전달
 ```
 ### best-effort 비차단 정책
 - 발행 실패(`TransportUnavailableError`, 임의 예외) 시: ERROR 로그 후 예외 삼킴(re-raise 금지).
 - 슬롯 전이·매매 집행·원장 기록 경로는 알람 발행 실패에 영향받지 않는다.
 - transport 미연결(None) 시: INFO 로그 후 silent skip. `reset.py` 등 CLI 진입점에서 안전.
 - notifier 미연결(unroutable) 시: `mandatory=False` → silent drop. `TransportUnavailableError` 없음.
 ### trex-core CRITICAL code 8종 발생 지점
 | code | 발생 모듈 | 조건 |
 |---|---|---|
 | `fill_price_unresolvable` | `application/execution.py` | 체결가·지정가 모두 0/None → 슬롯 PENDING 고착 위험 |
 | `sell_skipped_no_balance` | `application/execution.py` | 매도 dispatch skip: 브로커 잔고 0 |
 | `core_holding_broker_flat` | `application/reconciliation.py` | 슬롯 HOLDING인데 브로커 잔고 0 (정산 불일치) |
 | `ledger_delivery_failed` | `application/ledger_outbox.py` | 원장 영구 실패 / dead-letter / 409 충돌 |
 | `kill_switch_fired` | `application/killswitch.py` | 긴급 청산 발동 |
 | `publish_unavailable_after_reconnect` | `adapters/messaging/rabbitmq.py` | 재연결 후에도 이벤트 발행 불가 (콜백 패턴) |
 | `dlq_publish_failed` | `adapters/messaging/rabbitmq.py` | DLQ 발행 실패 (콜백 패턴) |
 | `portfolio_hub_unavailable` | `application/snapshot_scheduler.py` | whoami / get_portfolios 실패 → 스냅샷 부실화 |
 | `schema_verification_failed` | `runtime/reset.py` | 리셋 후 daily_slot 컬럼 불일치 |
 | `migration_failed` | `runtime/reset.py` | apply_migrations 예외 |
 ### trex.events와의 차이점
 | 항목 | `trex.events` | `trex.alerts` |
 |---|---|---|
 | 용도 | 체결/슬롯 상태 이벤트 | CRITICAL 알람 envelope |
 | exchange 타입 | topic, durable | topic, durable |
 | mandatory | True (DLQ 라우팅) | **False** (silent drop) |
 | DLQ | 있음 (`trex.events.dlq`) | **없음** |
 | delivery_mode | 2 (persistent) | 1 (non-persistent) |
 | 소비자 | 전략 모듈(strategy_id 필터) | trex-notifier 단독 |
 | 발행 재시도 | 재연결 후 1회 retry | **없음** (best-effort) |
@@ -1,6 +1,6 @@
 # req-101: 알람 발신 흐름 baseline 문서 정합
- Status: Approved
+- Status: Implemented
 - Type: Documentation
 - Priority: Medium
 - Owner: trex-core-dev
@@ -43,6 +43,20 @@
 ## Change Log
 ### CHG-20260621-02
 - Date: 2026-06-21
 - Author: trex-core-dev
 #### Change Summary
 - Status: Approved → Implemented. BAT-049 confirm-batch-verification 팀장 승인(QC PASS-WITH-NOTES blocker 0 + 팀장 실인프라 e2e 통과). docs/runtime-flows.md 알람 발신 흐름 섹션 + docs/interface-contract.md Change Log 추가 확인.
 #### Delivery Trace Delta
 - Batches: BAT-049 (release-candidate)
 - Releases: 미정
 #### Revalidation Impact
 - Reverification Needed: no
 ### CHG-20260621-01
 - Date: 2026-06-21
 - Author: trex-core-dev
@@ -1,6 +1,6 @@
 # req-099: trex.alerts AMQP exchange 토폴로지 + 가산·격리 불변식
- Status: Approved
+- Status: Implemented
 - Type: Integration
 - Priority: High
 - Owner: trex-core-dev
@@ -48,6 +48,20 @@
 ## Change Log
 ### CHG-20260621-02
 - Date: 2026-06-21
 - Author: trex-core-dev
 #### Change Summary
 - Status: Approved → Implemented. BAT-049 confirm-batch-verification 팀장 승인(QC PASS-WITH-NOTES blocker 0 + 팀장 실인프라 e2e 통과). 실 RabbitMQ `trex.alerts`(topic,durable) 선언·기존 topology 불변 확인.
 #### Delivery Trace Delta
 - Batches: BAT-049 (release-candidate)
 - Releases: 미정
 #### Revalidation Impact
 - Reverification Needed: no
 ### CHG-20260621-01
 - Date: 2026-06-21
 - Author: trex-core-dev
@@ -1,6 +1,6 @@
 # req-100: trex-core 알람 emitter — CRITICAL code 발신 배선
- Status: Approved
+- Status: Implemented
 - Type: Integration
 - Priority: High
 - Owner: trex-core-dev
@@ -68,6 +68,20 @@
 ## Change Log
 ### CHG-20260621-02
 - Date: 2026-06-21
 - Author: trex-core-dev
 #### Change Summary
 - Status: Approved → Implemented. BAT-049 confirm-batch-verification 팀장 승인(QC PASS-WITH-NOTES blocker 0 + 팀장 실인프라 e2e 통과). AlarmEmitter 29 단위 테스트 통과(8 code × 정상+예외 케이스). 텔레그램 sendMessage HTTP 200 e2e 확인. 잔여: reset.py 2 code 간접 검증(non-blocker, 정직 공개).
 #### Delivery Trace Delta
 - Batches: BAT-049 (release-candidate)
 - Releases: 미정
 #### Revalidation Impact
 - Reverification Needed: no
 ### CHG-20260621-01
 - Date: 2026-06-21
 - Author: trex-core-dev
@@ -1,6 +1,6 @@
 # req-098: 알람 envelope wire 계약 정의
- Status: Approved
+- Status: Implemented
 - Type: Interface
 - Priority: High
 - Owner: trex-core-dev
@@ -46,6 +46,20 @@
 ## Change Log
 ### CHG-20260621-02
 - Date: 2026-06-21
 - Author: trex-core-dev
 #### Change Summary
 - Status: Approved → Implemented. BAT-049 confirm-batch-verification 팀장 승인(QC PASS-WITH-NOTES blocker 0 + 팀장 실인프라 e2e 통과).
 #### Delivery Trace Delta
 - Batches: BAT-049 (release-candidate)
 - Releases: 미정
 #### Revalidation Impact
 - Reverification Needed: no
 ### CHG-20260621-01
 - Date: 2026-06-21
 - Author: trex-core-dev
@@ -178,30 +178,18 @@
 | REQ-095 | 체결가 0/None 지정가 백필 가드 (슬롯 평단 + 원장 price) | Exception | Implemented | High | trex-core-dev | [req-095](./Exception/req-095_fill-price-zero-backfill-guard.md) |
 | REQ-096 | 체결가 백필·0가격 통과 WARN 로깅 | Exception | Implemented | High | trex-core-dev | [req-096](./Exception/req-096_fill-price-backfill-warn-logging.md) |
 | REQ-097 | 알람(alert) 능력 검토 스파이크 산출물 | Documentation | Implemented | Medium | trex-core-dev | [req-097](./Documentation/req-097_alert-capability-spike.md) |
-| REQ-098 | 알람 envelope wire 계약 정의 | Interface | Approved | High | trex-core-dev | [req-098](./Interface/req-098_alarm-envelope-wire-contract.md) |
+| REQ-098 | 알람 envelope wire 계약 정의 | Interface | Implemented | High | trex-core-dev | [req-098](./Interface/req-098_alarm-envelope-wire-contract.md) |
-| REQ-099 | trex.alerts AMQP exchange 토폴로지 + 가산·격리 불변식 | Integration | Approved | High | trex-core-dev | [req-099](./Integration/req-099_alarm-exchange-topology.md) |
+| REQ-099 | trex.alerts AMQP exchange 토폴로지 + 가산·격리 불변식 | Integration | Implemented | High | trex-core-dev | [req-099](./Integration/req-099_alarm-exchange-topology.md) |
-| REQ-100 | trex-core 알람 emitter — CRITICAL code 발신 배선 | Integration | Approved | High | trex-core-dev | [req-100](./Integration/req-100_core-alarm-emitter.md) |
+| REQ-100 | trex-core 알람 emitter — CRITICAL code 발신 배선 | Integration | Implemented | High | trex-core-dev | [req-100](./Integration/req-100_core-alarm-emitter.md) |
-| REQ-101 | 알람 발신 흐름 baseline 문서 정합 | Documentation | Approved | Medium | trex-core-dev | [req-101](./Documentation/req-101_alarm-baseline-alignment.md) |
+| REQ-101 | 알람 발신 흐름 baseline 문서 정합 | Documentation | Implemented | Medium | trex-core-dev | [req-101](./Documentation/req-101_alarm-baseline-alignment.md) |
 ## Recent Change Log Summary
- 2026-06-21 :: REQ-098·099·100·101 **Proposed → Approved** (confirm-req, 팀장): dcy-033 확정 설계(trex.alerts AMQP·envelope 7필드·core CRITICAL 8종) 충실 반영, AC 측정가능, 가산·격리 불변식(098 AC-3/099 AC-2)·best-effort 비차단(099 AC-6/100 AC-2~4)·시크릿 격리(100 AC-5)·의존성역전/domain 순수성(100 AC-7/8) 강제 확인. emitter-in-adapter 경계·reset.py transport는 batch design 확정. 다음=suggest-batch-reqs→draft-batch. **delivery는 첫 tsl REL(M2) 이후 큐잉.**
+- 2026-06-21 :: REQ-098·099·100·101 **Approved → Implemented** (confirm-req-implemented, BAT-049 release-candidate, dcy-033): 알람 시스템 1단계 구현·검증 완료. 단위 608 passed/47 skipped/0 fail, 신규 AlarmEmitter 29 테스트, ruff clean. 독립 opus QC=PASS-WITH-NOTES(blocker 0) + 팀장 실인프라 e2e(trex.alerts 발행 → trex-notifier → 텔레그램 HTTP 200). 기존 topology 불변 확인. 잔여(non-blocker): reset.py 2 code 간접 검증.
- 2026-06-21 :: REQ-098·099·100·101 신규 생성(Proposed, draft-req dcy-033): 제품군 알람 전달 체계 — trex-core 소유분. REQ-098 알람 envelope wire 계약 정의(Interface, FR-1, dcy-033 S-1/S-3), REQ-099 trex.alerts AMQP exchange 토폴로지+가산·격리 불변식(Integration, NFR-1/S-3), REQ-100 core CRITICAL emitter 8종 배선(Integration, FR-2 core 부분, NFR-2/3, S-1), REQ-101 알람 발신 흐름 baseline 정합(Documentation, FR-3). orb/tsl/kdh emitter·trex-notifier는 각 repo REQ로 별도 진행. delivery는 M2 이후 큐잉.
+- 2026-06-21 :: REQ-098·099·100·101 **Proposed → Approved** (confirm-req, 팀장): dcy-033 확정 설계(trex.alerts AMQP·envelope 7필드·core CRITICAL 8종) 충실 반영, AC 측정가능, 가산·격리 불변식(098 AC-3/099 AC-2)·best-effort 비차단(099 AC-6/100 AC-2~4)·시크릿 격리(100 AC-5)·의존성역전/domain 순수성(100 AC-7/8) 강제 확인. emitter-in-adapter 경계·reset.py transport는 batch design 확정. **delivery는 첫 tsl REL(M2) 이후 큐잉.**
- 2026-06-21 :: **BAT-048 confirm-batch-verification**(팀장): REQ-095·096 **Approved → Implemented**. 구현=`execution.py` `_resolve_fill_price` 단일화(application) + `_record_ledger` resolved_price + skip+강WARN. 검증=신규 21 단위 테스트(매수 16+매도 5), **전체 575 passed/47 skipped/0 fail**(팀장 독립 재실행) + ruff clean. 독립 opus QC=PASS-WITH-NOTES → NOTE-1(ruff 2건)·NOTE-2(매도 경로 테스트) 정정 완료. skip 경로 부분변이 없음·price=0 원장 미생성 QC 확인. wire/LedgerTrade 스키마 불변(AC-5). **통합 3건 미실행 결정**(영속/전송 어댑터 diff 0이라 타 서비스 DB migration/truncate 침습 회피, KIS avg=None은 sandbox 결정적 재현 불가, 실가동 시 REQ-096 WARN으로 탐지). REQ-097=스파이크 Implemented(알람 impl 후속). 다음=커밋(git-ops)→M2.
+- 2026-06-21 :: **BAT-048 confirm-batch-verification**(팀장): REQ-095·096 **Approved → Implemented**. 구현=`execution.py` `_resolve_fill_price` 단일화(application) + `_record_ledger` resolved_price + skip+강WARN. 검증=신규 21 단위 테스트(매수 16+매도 5), **전체 575 passed/47 skipped/0 fail**(팀장 독립 재실행) + ruff clean. 독립 opus QC=PASS-WITH-NOTES → NOTE-1(ruff 2건)·NOTE-2(매도 경로 테스트) 정정 완료. wire/LedgerTrade 스키마 불변(AC-5). REQ-097=스파이크 Implemented.
- 2026-06-21 :: **BAT-048 design review**(팀장+사장님): D-1 백필 지점=application 단일화·D-2 폴백=skip+강WARN **팀장 승인**(REQ-095 AC-6 구체화). **D-3 사장님 결정: 우선 백필+WARN 로깅(REQ-095/096)만 구현, 알람은 BAT-048 완료 후 별도 진행+M2 포함 여부 그때 결정**. REQ-097 스파이크 산출물(design.md) 제출로 **Implemented**(후보 A 권고/B=wire변경 제외/C=M3). BAT-048 구현 범위=REQ-095+096.
+- 2026-06-21 :: **BAT-048 design review**(팀장+사장님): D-1 백필 지점=application 단일화·D-2 폴백=skip+강WARN **팀장 승인**. **D-3 사장님 결정: 우선 백필+WARN 로깅(REQ-095/096)만 구현, 알람은 BAT-048 완료 후 별도 진행**. REQ-097 스파이크 산출물(design.md) 제출로 **Implemented**(후보 A 권고). BAT-048 구현 범위=REQ-095+096.
- 2026-06-21 :: REQ-095·096·097 **Proposed → Approved** (confirm-req, 팀장): 세 REQ가 dcy-032 FR-1~4·NFR-1~3을 충실히 반영, AC 측정 가능, design Deferred 항목(백필 지점·지정가 부재 폴백·알람 채널) 명시 확인. REQ-095 AC-6(지정가 부재 폴백)은 design 확정 후 구체화(사장님 합의 deferral). 다음=suggest-batch-reqs → draft-batch.
+- 2026-06-21 :: REQ-095·096·097 **Proposed → Approved** (confirm-req, 팀장): 세 REQ가 dcy-032 FR-1~4·NFR-1~3을 충실히 반영, AC 측정 가능, design Deferred 항목(백필 지점·지정가 부재 폴백·알람 채널) 명시 확인. REQ-095 AC-6(지정가 부재 폴백)은 design 확정 후 구체화(사장님 합의 deferral).
 - 2026-06-21 :: REQ-095·096·097 신규 생성(Proposed, draft-req dcy-032): 체결가 무결성 가드 — REQ-095 체결가 0/None 지정가 백필(슬롯 평단+원장 price, FR-1/2, wire 계약 불변, design 확정 대상: 백필 지점/지정가 부재 폴백), REQ-096 WARN 로깅(FR-3, 원장 skip 가드 동일 수준, NFR-3 흡수), REQ-097 알람 능력 검토 스파이크 산출물(FR-4, 구현 포함 여부 design review 후 사장님 결정, 조건부). NFR-1(wire 불변) REQ-095 AC-5 흡수, NFR-2(happy path 무영향) REQ-095 AC-4 흡수, NFR-3(백필 추적) REQ-096 AC-4 흡수.
 - 2026-06-19 :: REQ-091·092·093·094 Approved → **Implemented** (confirm-req-implemented, BAT-047 release-candidate, dcy-031/OPS-005): 발행 재시도+강제재연결(091)·idle keepalive(092, execution-loop 단일스레드 틱)·DLQ 가시성+emit ERROR 경보(093, 구조화 로그 dcy-029 재사용)·baseline 정합(094) 구현·검증 완료. 독립 opus QC=PASS-WITH-NOTES→시정 2건(ruff F401·AC-3 프로덕션 경로) 완료, 팀장 재확인 **554 passed/47 skipped/회귀 0/ruff clean**. NFR-1 wire 무회귀(interface-contract diff 0). 수용 한계: half-open/broker재시작/idle=mock unit만(실 broker 통합 skip→운영/CI 위임), NFR-2 ≤5초는 재연결+재시도 구간만 엄밀(1차 socket_timeout 5s 최악 초과 가능). OQ-1/3 design Answered. 다음=draft-release(배포=trex-core 재배포→사장님 결재, tsl 라이브 선행).
 - 2026-06-19 :: REQ-091·092·093·094 Proposed → **Approved** (confirm-req, 팀장): 필수 필드·구체 AC 충족, source dcy-031(confirmed, Open OQ 0) 정합, blocker 없음. 팀장 판정 — FR-4의 REQ-093 흡수 동의, OQ-1/OQ-3 design 인계 확정, NFR-2 타임아웃 수치는 draft-batch-design 확정(비차단). 다음=suggest-batch-reqs + draft-batch(REQ-091~094 단일 batch 편성 예정, 고위험 opus QC).
 - 2026-06-19 :: REQ-091·092·093·094 신규 생성(Proposed, draft-req dcy-031): 이벤트 발행 연결 신뢰성 — REQ-091 발행 재시도+강제 재연결(FR-1/B, S-1·S-2, NFR-1~3 흡수), REQ-092 idle keepalive(FR-2/A, OQ-1 design 인계), REQ-093 DLQ 가시성+emit 경보(FR-3/D + FR-4, OQ-3 design 인계, S-3), REQ-094 baseline 문서 정합(runtime-flows/project-structure/operations, docs전용). NFR-2·NFR-3은 REQ-091~093 AC에 흡수. 고위험(M1 라이브) batch — opus QC 강제(CONFIRM①).
 - 2026-06-16 :: REQ-086·088·089·090 Approved → **Implemented** (confirm-req-implemented, BAT-046 release-candidate, dcy-029 P1/issue #29): 청산 reason+actor 노출 + 운영 조회 CLI(report, 보유·오늘 체결·실현 PnL net·대기) + 운영자 런북 docs/operations.md + baseline 정합. 14 passed(신규 operator_report+safety_sell), 전체 537 passed/47 skipped 회귀 0, ruff clean.
 - 2026-06-16 :: REQ-084·085·087 Approved → **Implemented** (confirm-req-implemented, BAT-045 release-candidate, dcy-029 P0/issue #29): 구조화 로깅 기반(ISO8601 KST·레벨·Loki JSON·correlation id) + 주문 결과 로깅(event=order_submit|fill|reject) + 거부 ERROR 가시화 구현·검증. 35 passed(신규 logging+주문결과), 전체 529 passed/47 skipped 회귀 0, ruff clean.
 - 2026-06-16 :: REQ-084~090 신규 생성(Proposed, draft-req dcy-029): 운영 관측성 — REQ-084 구조화 로깅 기반(ISO8601 KST·레벨·Loki JSON·correlation id, FR-1+7), REQ-085 주문 결과 로깅(FR-2), REQ-086 청산 reason+actor 노출(FR-3, OQ-4 Option A), REQ-087 거부 ERROR 가시성(FR-4), REQ-088 운영 조회 CLI(FR-5, OQ-1 CLI), REQ-089 운영자 런북 docs/operations.md(FR-8), REQ-090 baseline 정합(FR-6). P0=084·085·087(+087은 P1이나 로깅 동반)/ P1=086·088·089·090.
 - 2026-06-16 :: REQ-083·070 Approved → **Implemented** (confirm-req-implemented, BAT-044 release-candidate, dcy-030/issue #28): 슬리피지 KRX 호가단위 스냅 구현·검증 완료 — `domain/pricing.py`(tick 유틸) + `execution.py` 스냅(상한 준수 매수 floor/매도 ceil + band<tick 보장 + epsilon 가드). issue #28 케이스(147700→148400/54500→54700) 단위 검증, 47 passed(신규 pricing+슬리피지 정정), 전체 516 passed/47 skipped 회귀 0, ruff clean.
 - 2026-06-16 :: REQ-083 Proposed → **Approved** (confirm-req): 필수 필드·구체 AC 충족, source dcy-030(confirmed, Open OQ 0) 정합. REQ-070(Approved, CHG)와 함께 dcy-030 단일 batch 편성 예정.
 - 2026-06-16 :: REQ-083 신규 생성(Proposed, draft-req dcy-030): KRX 호가단위(tick) 산출 유틸 — 가격→tick 순수 함수(2023.1.25~ 구간표) + floor/ceil 배수 헬퍼. 주식 전용(OQ-1). REQ-070 슬리피지 스냅이 소비.
 - 2026-06-16 :: REQ-070 change-req (CHG-20260616-01, dcy-030/issue #28): 슬리피지 실효 지정가에 KRX 호가단위 스냅 추가 + 반올림 방향 전환(체결 보장 → **상한 준수**: 매수 내림/매도 올림) + band<1tick 하한/상한 보장. 기존 int(ceil/floor) 무스냅 구현 무효화 → Implemented → **Approved** 되돌림. 신규 AC-7~10, AC-1·2 갱신. dcy-030 batch에서 재구현·검증.
 - 2026-06-15 :: REQ-007 Approved → **Implemented** (confirm-req-implemented, BAT-043 release-candidate, issue #27): rejected SellIntent 응답 additive `retryable` 구현·검증 완료 — core 소유 `_SELL_REJECT_RETRYABLE` 매핑 + helper, 487 passed(+8), ruff clean. issue #27 close.
@@ -1,4 +1,4 @@
-"""InMemoryTransport stub tests (REQ-022 AC-1 + REQ-024 degrade)."""
+"""InMemoryTransport stub tests (REQ-022 AC-1 + REQ-024 degrade + REQ-099 alarm)."""
 from __future__ import annotations
 import threading
@@ -86,3 +86,23 @@ def test_publish_event_with_no_subscriber_routes_to_dlq():
    dlq = t.dlq_messages()
    assert len(dlq) == 1
    assert dlq[0][0] == "slot_filled_buy.A.005930"
 # dcy-033 / REQ-099: alarm channel tests
 def test_publish_alarm_event_records_event():
    """Alarm event is recorded in _alarm_events when transport is available."""
    t = InMemoryTransport()
    t.publish_alarm_event("alarm.critical.trex-core", {"code": "kill_switch_fired"})
    alarms = t.alarm_events()
    assert len(alarms) == 1
    rk, payload = alarms[0]
    assert rk == "alarm.critical.trex-core"
    assert payload["code"] == "kill_switch_fired"
 def test_publish_alarm_event_raises_when_unavailable():
    """Alarm publish raises TransportUnavailableError when transport is down."""
    t = InMemoryTransport()
    t.set_available(False)
    with pytest.raises(TransportUnavailableError):
        t.publish_alarm_event("alarm.critical.trex-core", {"code": "test"})
@@ -1,4 +1,4 @@
-"""Topology constants + routing key builders (REQ-021)."""
+"""Topology constants + routing key builders (REQ-021, REQ-099)."""
 from __future__ import annotations
 from trex_core.adapters.messaging import topology
@@ -12,6 +12,17 @@ def test_topology_constants():
    assert not hasattr(topology, "SNAPSHOT_REQ_QUEUE")
 # dcy-033 / REQ-099: trex.alerts exchange constant + routing key builder
 def test_alerts_exchange_constant():
    assert topology.ALERTS_EXCHANGE == "trex.alerts"
 def test_alarm_routing_key_format():
    assert topology.alarm_routing_key("critical", "trex-core") == "alarm.critical.trex-core"
    assert topology.alarm_routing_key("warn", "trex-orb-v1") == "alarm.warn.trex-orb-v1"
    assert topology.alarm_routing_key("info", "kis-data-hub") == "alarm.info.kis-data-hub"
 def test_event_routing_key_format():
    assert topology.event_routing_key("slot_filled_buy", "A", "005930") == \
        "slot_filled_buy.A.005930"
@@ -0,0 +1,156 @@
 """AlarmEmitter unit tests (dcy-033 / REQ-100).
 Coverage:
  - 8 CRITICAL code × (a) normal publish + envelope validation
                     × (b) TransportUnavailableError → no re-raise + ERROR log
  - arbitrary exception swallowing
  - transport=None skip (reset.py / CLI path)
  - routing key format: alarm.critical.trex-core
 """
 from __future__ import annotations
 import logging
 import pytest
 from trex_core.adapters.messaging.in_memory import InMemoryTransport
 from trex_core.application.alarm_emitter import AlarmEmitter
 # ------------------------------------------------------------------ helpers
 CRITICAL_CODES = [
    "fill_price_unresolvable",
    "sell_skipped_no_balance",
    "core_holding_broker_flat",
    "ledger_delivery_failed",
    "kill_switch_fired",
    "publish_unavailable_after_reconnect",
    "dlq_publish_failed",
    "portfolio_hub_unavailable",
 ]
 _ROUTING_KEY = "alarm.critical.trex-core"
 def _make_emitter() -> tuple[AlarmEmitter, InMemoryTransport]:
    transport = InMemoryTransport()
    return AlarmEmitter(transport), transport
 # ------------------------------------------------------------------ envelope validation
@pytest.mark.parametrize("code", CRITICAL_CODES)
 def test_publish_alarm_envelope_fields(code: str):
    """(a) Normal publish: envelope contains all 7 required fields with correct values."""
    emitter, transport = _make_emitter()
    fields_in = {"slot_id": "abc", "symbol": "005930"}
    emitter.publish_alarm(code, f"Test alarm for {code}", fields=fields_in)
    alarms = transport.alarm_events()
    assert len(alarms) == 1, f"Expected 1 alarm event for code={code}"
    rk, payload = alarms[0]
    assert rk == _ROUTING_KEY, f"routing key mismatch: {rk}"
    # REQ-098: all 7 envelope fields
    assert payload["source"] == "trex-core"
    assert payload["severity"] == "critical"
    assert payload["code"] == code
    assert payload["title"] == f"Test alarm for {code}"
    assert payload["fields"] == fields_in
    assert "occurred_at" in payload
    assert payload["schema_version"] == "1"
@pytest.mark.parametrize("code", CRITICAL_CODES)
 def test_publish_alarm_transport_unavailable_no_reraise(
    code: str, caplog: pytest.LogCaptureFixture
 ):
    """(b) TransportUnavailableError must not propagate; ERROR log must appear."""
    emitter, transport = _make_emitter()
    transport.set_available(False)
    with caplog.at_level(logging.ERROR, logger="trex_core.application.alarm_emitter"):
        # Must NOT raise
        emitter.publish_alarm(code, f"Test alarm for {code}")
    # No alarms recorded (transport was down)
    assert transport.alarm_events() == []
    # ERROR log must have been emitted
    assert any("alarm publish" in r.message for r in caplog.records), (
        f"Expected ERROR log for code={code}"
    )
 # ------------------------------------------------------------------ additional edge cases
@pytest.mark.parametrize("code", CRITICAL_CODES)
 def test_publish_alarm_arbitrary_exception_swallowed(code: str, caplog: pytest.LogCaptureFixture):
    """Any exception (not just TransportUnavailableError) is swallowed + ERROR logged."""
    class BrokenTransport:
        def publish_alarm_event(self, routing_key, payload):
            raise RuntimeError("boom")
        def health(self):
            from trex_core.application.messaging import TransportHealth
            return TransportHealth.CONNECTED
    emitter = AlarmEmitter(BrokenTransport())  # type: ignore[arg-type]
    with caplog.at_level(logging.ERROR, logger="trex_core.application.alarm_emitter"):
        emitter.publish_alarm(code, "boom test")  # Must NOT raise
    assert any("alarm publish" in r.message for r in caplog.records)
 def test_publish_alarm_none_transport_skip(caplog: pytest.LogCaptureFixture):
    """transport=None: publish is skipped with INFO log (reset.py / CLI path, REQ-100 KD-2)."""
    emitter = AlarmEmitter(None)
    with caplog.at_level(logging.INFO, logger="trex_core.application.alarm_emitter"):
        emitter.publish_alarm("kill_switch_fired", "no transport test")
    assert any("alarm skipped" in r.message for r in caplog.records)
 def test_publish_alarm_empty_fields_default():
    """fields defaults to {} when not provided — not None in payload."""
    emitter, transport = _make_emitter()
    emitter.publish_alarm("kill_switch_fired", "no fields")
    _, payload = transport.alarm_events()[0]
    assert payload["fields"] == {}
 def test_publish_alarm_routing_key_format():
    """routing key must be alarm.critical.trex-core for default severity."""
    emitter, transport = _make_emitter()
    emitter.publish_alarm("kill_switch_fired", "routing key test")
    rk, _ = transport.alarm_events()[0]
    assert rk == "alarm.critical.trex-core"
 # ------------------------------------------------------------------ domain purity sweep
 def test_alarm_emitter_no_pika_import():
    """AlarmEmitter module must not import pika (domain/application purity)."""
    import importlib
    import sys
    # Ensure pika is not in alarm_emitter's import chain at module level.
    mod = sys.modules.get("trex_core.application.alarm_emitter")
    if mod is None:
        mod = importlib.import_module("trex_core.application.alarm_emitter")
    # pika should NOT be in the module's global namespace
    assert "pika" not in dir(mod), "alarm_emitter must not import pika directly"
 def test_alarm_emitter_no_telegram_reference():
    """Verify no TELEGRAM_* references in alarm_emitter source (REQ-100 AC-5)."""
    import inspect
    import trex_core.application.alarm_emitter as ae_mod
    source = inspect.getsource(ae_mod)
    assert "TELEGRAM" not in source, "alarm_emitter must not reference TELEGRAM_*"
    assert "telegram" not in source.lower(), "alarm_emitter must not reference telegram"
@@ -29,6 +29,7 @@ class InMemoryTransport:
        self._rpc_handlers: dict[str, RpcHandler] = {}
        self._event_subscribers: list[tuple[str, EventHandler]] = []  # (pattern, handler)
        self._dlq: list[tuple[str, dict]] = []  # (routing_key, payload)
        self._alarm_events: list[tuple[str, dict]] = []  # (routing_key, payload) dcy-033
        self._available = True
        self._health = TransportHealth.CONNECTED
@@ -53,6 +54,21 @@ class InMemoryTransport:
        with self._lock:
            return list(self._dlq)
    def alarm_events(self) -> list[tuple[str, dict]]:
        """Return recorded alarm events (test affordance, dcy-033)."""
        with self._lock:
            return list(self._alarm_events)
    # --- alarm events (dcy-033 / REQ-099) ---
    def publish_alarm_event(self, routing_key: str, payload: dict) -> None:
        """Stub for trex.alerts publish. Records event; raises when unavailable."""
        with self._lock:
            if not self._available:
                raise TransportUnavailableError(
                    "transport disconnected; alarm event dropped"
                )
            self._alarm_events.append((routing_key, dict(payload)))
    # --- events ---
    def publish_event(
        self,
@@ -22,12 +22,13 @@ import json
 import logging
 import threading
 import time
-from typing import Optional
+from typing import Callable, Optional
 import pika
 import pika.exceptions
 from trex_core.adapters.messaging.topology import (
    ALERTS_EXCHANGE,
    BROADCAST_EXCHANGE,
    DEFAULT_INSTANCE_KEY,
    DIRECT_EXCHANGE,
@@ -65,6 +66,7 @@ class RabbitMQTransport:
        timeout: float = 5.0,
        intent_prefetch: int = 1,
        snapshot_prefetch: int = 8,
        alarm_callback: Optional[Callable[[str, str, dict], None]] = None,
    ) -> None:
        self._url = url
        self._timeout = timeout
@@ -74,6 +76,20 @@ class RabbitMQTransport:
        self._conn: Optional[pika.BlockingConnection] = None
        self._channel: Optional[pika.adapters.blocking_connection.BlockingChannel] = None
        self._health = TransportHealth.DISCONNECTED
        # dcy-033 / REQ-100 (KD-1): alarm callback for adapter-layer alarm codes.
        # Injected by daemon.py after AlarmEmitter construction (avoid circular init).
        # Signature: (code: str, title: str, fields: dict) -> None
        self._alarm_callback: Optional[Callable[[str, str, dict], None]] = alarm_callback
    def set_alarm_callback(
        self, callback: Optional[Callable[[str, str, dict], None]]
    ) -> None:
        """Late-bind alarm callback (dcy-033 / REQ-100 KD-1).
        Allows daemon.py to inject the callback after AlarmEmitter is created,
        avoiding circular initialization between transport and emitter.
        """
        self._alarm_callback = callback
    # ------------------------------------------------------------ lifecycle
    def _connect(self, connect_timeout: Optional[float] = None) -> None:
@@ -163,6 +179,9 @@ class RabbitMQTransport:
        # Events topic + DLQ
        ch.exchange_declare(EVENTS_EXCHANGE, exchange_type="topic", durable=True)
        ch.exchange_declare(EVENTS_DLQ_EXCHANGE, exchange_type="fanout", durable=True)
        # dcy-033 / REQ-099: alarm channel — independent of trex.events, no DLQ,
        # mandatory=False (notifier down = silent drop, no core-path blocker).
        ch.exchange_declare(ALERTS_EXCHANGE, exchange_type="topic", durable=True)
        ch.queue_declare(EVENTS_DLQ_QUEUE, durable=True)
        ch.queue_bind(EVENTS_DLQ_QUEUE, EVENTS_DLQ_EXCHANGE)
        # BAT-013 / REQ-050: multi-instance control exchanges.
@@ -259,6 +278,12 @@ class RabbitMQTransport:
                self._publish_dlq(routing_key, payload, reason="unroutable")
            except (pika.exceptions.AMQPError, OSError) as retry_exc:
                self._mark_disconnected()
                # dcy-033 / REQ-100: fire alarm for publish unavailable after reconnect.
                self._fire_alarm_callback(
                    "publish_unavailable_after_reconnect",
                    f"재연결 후에도 이벤트 발행 불가: rk={routing_key}",
                    {"routing_key": routing_key, "error": str(retry_exc)},
                )
                raise TransportUnavailableError(
                    f"publish_event failed after reconnect+retry: "
                    f"{retry_exc.__class__.__name__}: {retry_exc}"
@@ -289,8 +314,59 @@ class RabbitMQTransport:
                    content_type="application/json", delivery_mode=2
                ),
            )
-        except Exception:  # noqa: BLE001 - DLQ best-effort
+        except Exception as dlq_exc:  # noqa: BLE001 - DLQ best-effort
            _log.error("DLQ publish failed (rk=%s)", routing_key, exc_info=True)
            # dcy-033 / REQ-100: fire alarm for DLQ publish failure.
            self._fire_alarm_callback(
                "dlq_publish_failed",
                f"DLQ 발행 실패: rk={routing_key}",
                {"routing_key": routing_key, "error": str(dlq_exc)},
            )
    def publish_alarm_event(self, routing_key: str, payload: dict) -> None:
        """Publish to trex.alerts exchange (dcy-033 / REQ-099).
        Best-effort: mandatory=False, delivery_mode=1 (non-persistent).
        No retry on failure — alarm must never block the execution path.
        Raises TransportUnavailableError on connect failure (caller swallows).
        """
        body = json.dumps(payload).encode("utf-8")
        try:
            self._ensure_connected()
            ch = self._channel
            assert ch is not None
            ch.basic_publish(
                exchange=ALERTS_EXCHANGE,
                routing_key=routing_key,
                body=body,
                properties=pika.BasicProperties(
                    content_type="application/json",
                    delivery_mode=1,  # non-persistent — best-effort alarm
                ),
                mandatory=False,  # silent drop when notifier not bound
            )
        except (pika.exceptions.AMQPError, OSError) as exc:
            self._mark_disconnected()
            raise TransportUnavailableError(
                f"publish_alarm_event failed: {exc.__class__.__name__}: {exc}"
            ) from exc
    def _fire_alarm_callback(
        self, code: str, title: str, fields: dict | None = None
    ) -> None:
        """Invoke the injected alarm callback (dcy-033 / REQ-100 KD-1).
        Used by adapter-layer alarm sources (publish_unavailable_after_reconnect,
        dlq_publish_failed) that cannot call AlarmEmitter directly.
        No-op when callback is not set. Swallows callback exceptions.
        """
        cb = self._alarm_callback
        if cb is None:
            return
        try:
            cb(code, title, fields or {})
        except Exception:  # noqa: BLE001 — callback must never crash the adapter
            _log.debug("alarm callback raised (code=%s)", code, exc_info=True)
    # ------------------------------------------------------------ RPC client
    def call_rpc(
@@ -62,6 +62,20 @@ EVENTS_EXCHANGE = "trex.events"            # topic, durable
 EVENTS_DLQ_EXCHANGE = "trex.events.dlq"    # fanout, durable; receives unroutable/NACKed
 EVENTS_DLQ_QUEUE = "trex.events.dlq"       # one collector queue bound to DLQ exchange
 # --- Alarm channel (dcy-033 / REQ-099) ---
 # Independent of trex.events. mandatory=False (best-effort, notifier down = silent drop).
 ALERTS_EXCHANGE = "trex.alerts"            # topic, durable; alarm envelope channel
 def alarm_routing_key(severity: str, source: str) -> str:
    """Build the routing key for an alarm event (dcy-033 / REQ-098).
    Pattern: alarm.{severity}.{source}  (e.g. alarm.critical.trex-core)
    Severity is always lower-case. Source tokens containing '.' are safe
    because notifier binds with alarm.# pattern (zero-or-more tail words).
    """
    return f"alarm.{severity}.{source}"
 def event_routing_key(event_type: str, strategy_id: str, symbol: str) -> str:
    """Build the routing key for an event (dcy-006 OQ-2 mapping)."""
@@ -0,0 +1,93 @@
 """Alarm emitter — best-effort CRITICAL alarm publisher (dcy-033 / REQ-100).
 Publishes REQ-098 alarm envelopes to the `trex.alerts` exchange via the
 MessagingTransport port.  No pika import here — dependency inversion
 preserved (NFR-1).  Domain layer is never touched.
 Caller contract:
  - Inject into execution / reconciliation / killswitch / ledger_outbox / etc.
  - Call publish_alarm(code, title, fields=...) at each alarm point.
  - publish_alarm() NEVER re-raises.  Alarm failure is ERROR-logged and swallowed
    so the core business path (slot transition / order execution / ledger) is
    never blocked by alarm delivery.
 transport=None is explicitly supported for CLI entry points (e.g. reset.py)
 where no broker connection exists.  In that case publish_alarm() logs and skips.
 """
 from __future__ import annotations
 import logging
 from datetime import datetime, timezone, timedelta
 from typing import Optional
 from trex_core.application.messaging import MessagingTransport, TransportUnavailableError
 from trex_core.adapters.messaging.topology import alarm_routing_key
 _log = logging.getLogger(__name__)
 _KST = timezone(timedelta(hours=9))
 # Wire constants (REQ-098)
 _SOURCE = "trex-core"
 _SCHEMA_VERSION = "1"
 class AlarmEmitter:
    """Application-layer alarm publisher (dcy-033 / REQ-100).
    Wraps MessagingTransport.publish_alarm_event() with:
      - envelope construction (source/severity/occurred_at/schema_version fixed)
      - exception swallowing + ERROR log on failure
      - None-transport guard for non-daemon entry points
    """
    def __init__(self, transport: Optional[MessagingTransport]) -> None:
        self._transport = transport
    def publish_alarm(
        self,
        code: str,
        title: str,
        *,
        fields: Optional[dict] = None,
        severity: str = "critical",
    ) -> None:
        """Publish a single alarm envelope.  Best-effort: never re-raises.
        Args:
            code: Alarm identifier code (see ALARM-INVENTORY.md §A).
            title: Human-readable 1-line summary.  No credentials or raw
                   exception bodies — callers must sanitize.
            fields: Optional structured context dict (opaque, default {}).
            severity: 'critical' | 'warn' | 'info'.  Default 'critical'.
        """
        if self._transport is None:
            _log.info(
                "alarm skipped (no transport): code=%s title=%s",
                code, title,
            )
            return
        routing_key = alarm_routing_key(severity, _SOURCE)
        occurred_at = datetime.now(tz=_KST).isoformat()
        payload = {
            "source": _SOURCE,
            "severity": severity,
            "code": code,
            "title": title,
            "fields": fields or {},
            "occurred_at": occurred_at,
            "schema_version": _SCHEMA_VERSION,
        }
        try:
            self._transport.publish_alarm_event(routing_key, payload)
        except TransportUnavailableError as exc:
            _log.error(
                "alarm publish skipped (transport unavailable): code=%s: %s",
                code, exc,
            )
        except Exception:  # noqa: BLE001 — alarm must never crash the caller
            _log.error(
                "alarm publish failed: code=%s title=%s",
                code, title, exc_info=True,
            )
@@ -27,6 +27,7 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Callable, Optional
 from trex_core.application.alarm_emitter import AlarmEmitter
 from trex_core.application.broker_port import BrokerPort, OrderRequest
 from trex_core.application.ledger_outbox import LedgerOutbox
 from trex_core.application.ledger_port import LedgerTrade
@@ -67,6 +68,7 @@ class ExecutionService:
        event_emitter: Optional[SlotEventEmitter] = None,
        stale_pending_threshold_sec: Optional[int] = None,
        instance_key: str = "default",
        alarm_emitter: Optional[AlarmEmitter] = None,
    ) -> None:
        self._svc = slot_service
        self._repo = repo
@@ -85,6 +87,8 @@ class ExecutionService:
            if stale_pending_threshold_sec and stale_pending_threshold_sec > 0
            else None
        )
        # dcy-033 / REQ-100: best-effort alarm emitter (None = no alarms sent).
        self._alarm_emitter = alarm_emitter
    # ------------------------------------------------------------
    def run_once(self) -> ExecutionResult:
@@ -130,6 +134,13 @@ class ExecutionService:
                        "(divergence — no order submitted; operator/reconcile attention)",
                        slot.slot_id, slot.symbol,
                    )
                    # dcy-033 / REQ-100: CRITICAL alarm — PENDING_SELL may stick.
                    if self._alarm_emitter is not None:
                        self._alarm_emitter.publish_alarm(
                            "sell_skipped_no_balance",
                            f"매도 dispatch skip: 브로커 잔고 0 (slot={slot.slot_id} symbol={slot.symbol})",
                            fields={"slot_id": str(slot.slot_id), "symbol": slot.symbol},
                        )
                    continue
            else:
                qty = int(slot.qty or 0)
@@ -265,6 +276,14 @@ class ExecutionService:
            slot.slot_id, slot.symbol, slot.broker_order_id,
            avg, limit,
        )
        # dcy-033 / REQ-100: CRITICAL alarm — slot stuck in PENDING.
        if self._alarm_emitter is not None:
            self._alarm_emitter.publish_alarm(
                "fill_price_unresolvable",
                f"체결가 미해결: 슬롯 PENDING 고착 위험 (slot={slot.slot_id} symbol={slot.symbol})",
                fields={"slot_id": str(slot.slot_id), "symbol": slot.symbol,
                        "broker_order_id": slot.broker_order_id},
            )
        return None, False
    def _on_filled(self, slot, fs, side: str, r: ExecutionResult) -> None:
@@ -11,7 +11,9 @@ from __future__ import annotations
 import logging
 from datetime import date as date_cls
 from datetime import datetime, timezone
 from typing import Optional
 from trex_core.application.alarm_emitter import AlarmEmitter
 from trex_core.application.portfolio import GLOBAL_KILLSWITCH, KillSwitchStore
 from trex_core.domain.slot import SlotRepository, SlotService
@@ -29,11 +31,14 @@ class KillSwitchService:
        slot_service: SlotService,
        killswitch_store: KillSwitchStore,
        instance_key: str = "default",
        alarm_emitter: Optional[AlarmEmitter] = None,
    ) -> None:
        self._repo = slot_repo
        self._svc = slot_service
        self._store = killswitch_store
        self._instance_key = instance_key  # dcy-020/REQ-056: instance-scoped sweep
        # dcy-033 / REQ-100: best-effort alarm emitter.
        self._alarm_emitter = alarm_emitter
    @staticmethod
    def _trading_date(now: datetime) -> date_cls:
@@ -73,6 +78,14 @@ class KillSwitchService:
            "kill-switch fired: actor=%s scope=%s portfolio_id=%s liquidated=%d",
            actor, scope, portfolio_id, liquidated,
        )
        # dcy-033 / REQ-100: CRITICAL alarm — emergency liquidation fired.
        if self._alarm_emitter is not None:
            self._alarm_emitter.publish_alarm(
                "kill_switch_fired",
                f"긴급 청산 발동: scope={scope} liquidated={liquidated}",
                fields={"scope": scope, "portfolio_id": portfolio_id, "liquidated": liquidated,
                        "actor": actor},
            )
        return liquidated
    def resume(
@@ -30,6 +30,7 @@ from datetime import datetime, timedelta, timezone
 from enum import Enum
 from typing import Callable, Optional, Protocol
 from trex_core.application.alarm_emitter import AlarmEmitter
 from trex_core.application.ledger_port import (
    LedgerConflictError,
    LedgerPermanentError,
@@ -169,6 +170,7 @@ class LedgerWriter:
        max_attempts: int = _DEFAULT_MAX_ATTEMPTS,
        clock: Optional[Callable[[], datetime]] = None,
        rng: Optional[Callable[[], float]] = None,
        alarm_emitter: Optional[AlarmEmitter] = None,
    ) -> None:
        self._outbox = outbox
        self._ledger = ledger
@@ -181,6 +183,8 @@ class LedgerWriter:
        self._max_attempts = max_attempts
        self._clock = clock or (lambda: datetime.now(tz=timezone.utc))
        self._rng = rng or random.random  # jitter source; inject for determinism
        # dcy-033 / REQ-100: best-effort alarm emitter.
        self._alarm_emitter = alarm_emitter
    def enqueue_fill(self, trade: LedgerTrade) -> LedgerWorkItem:
        return self._outbox.enqueue(trade)
@@ -219,6 +223,15 @@ class LedgerWriter:
            self._outbox.mark_outcome(
                item.correlation_id, OutboxOutcome.CONFLICT_BLOCKED, error=str(exc)
            )
            # dcy-033 / REQ-100: CRITICAL alarm — 409 conflict, operator resolution needed.
            if self._alarm_emitter is not None:
                self._alarm_emitter.publish_alarm(
                    "ledger_delivery_failed",
                    f"원장 409 충돌 (conflict_blocked): {item.correlation_id}",
                    fields={"correlation_id": item.correlation_id,
                            "asset_id": item.trade.asset_id,
                            "reason": "conflict_blocked"},
                )
            return OutboxOutcome.CONFLICT_BLOCKED
        except LedgerPermanentError as exc:
            # dcy-015 / REQ-017/018 (issue #13): non-retryable client error →
@@ -230,6 +243,15 @@ class LedgerWriter:
                "ledger delivery_failed (permanent): correlation_id=%s reason=%s",
                item.correlation_id, exc,
            )
            # dcy-033 / REQ-100: CRITICAL alarm — permanent failure, no retry.
            if self._alarm_emitter is not None:
                self._alarm_emitter.publish_alarm(
                    "ledger_delivery_failed",
                    f"원장 영구 실패 (permanent): {item.correlation_id}",
                    fields={"correlation_id": item.correlation_id,
                            "asset_id": item.trade.asset_id,
                            "reason": "permanent_failure"},
                )
            return OutboxOutcome.PERMANENT_FAILURE
        except LedgerRetryableError as exc:
            # dcy-015 / REQ-019: backoff, or dead-letter once max_attempts hit.
@@ -243,6 +265,16 @@ class LedgerWriter:
                    "correlation_id=%s reason=%s",
                    new_attempts, item.correlation_id, exc,
                )
                # dcy-033 / REQ-100: CRITICAL alarm — dead-lettered after max retries.
                if self._alarm_emitter is not None:
                    self._alarm_emitter.publish_alarm(
                        "ledger_delivery_failed",
                        f"원장 데드레터 (attempts={new_attempts}): {item.correlation_id}",
                        fields={"correlation_id": item.correlation_id,
                                "asset_id": item.trade.asset_id,
                                "attempts": new_attempts,
                                "reason": "dead_lettered"},
                    )
                return OutboxOutcome.DEAD_LETTERED
            next_retry_at = self._clock() + timedelta(
                seconds=self._backoff_delay(new_attempts)
@@ -79,6 +79,19 @@ class MessagingTransport(Protocol):
        Raises TransportUnavailableError if not connected."""
        ...
    def publish_alarm_event(
        self,
        routing_key: str,
        payload: dict,
    ) -> None:
        """Publish to the trex.alerts exchange (dcy-033 / REQ-099).
        Best-effort: mandatory=False so an unroutable message (notifier not
        connected) is silently dropped — no DLQ, no retry.
        Raises TransportUnavailableError if not connected (caller must swallow).
        """
        ...
    def call_rpc(
        self,
        queue: str,
@@ -9,7 +9,9 @@ manual holds).
 from __future__ import annotations
 import logging
 from typing import Optional
 from trex_core.application.alarm_emitter import AlarmEmitter
 from trex_core.application.broker_port import BrokerPort
 from trex_core.application.portfolio import SnapshotStore
 from trex_core.domain.slot.state import SlotState
@@ -17,8 +19,14 @@ from trex_core.domain.slot.state import SlotState
 _log = logging.getLogger(__name__)
-def reconcile_core_holdings(*, slot_repo, slot_service, broker: BrokerPort,
+def reconcile_core_holdings(
-                           instance_key: str) -> dict[str, str]:
+    *,
    slot_repo,
    slot_service,
    broker: BrokerPort,
    instance_key: str,
    alarm_emitter: Optional[AlarmEmitter] = None,
 ) -> dict[str, str]:
    """dcy-020 / REQ-062 (BAT-029): surface core-slot holding ↔ broker divergence.
    Broker balance is the reconcile ground truth. Decisions (no silent auto-fix,
@@ -48,6 +56,13 @@ def reconcile_core_holdings(*, slot_repo, slot_service, broker: BrokerPort,
                    "core holding but broker flat: slot=%s symbol=%s -> error",
                    slot.slot_id, sym,
                )
                # dcy-033 / REQ-100: CRITICAL alarm — position mismatch.
                if alarm_emitter is not None:
                    alarm_emitter.publish_alarm(
                        "core_holding_broker_flat",
                        f"슬롯 보유인데 브로커 잔고 0 (slot={slot.slot_id} symbol={sym})",
                        fields={"slot_id": str(slot.slot_id), "symbol": sym},
                    )
            except Exception:  # noqa: BLE001 - never let reconcile crash the loop
                _log.exception("failed to error-quarantine slot %s", slot.slot_id)
        elif slot.qty is not None and int(slot.qty) != bq:  # C — qty mismatch
@@ -12,6 +12,7 @@ import threading
 from datetime import datetime, time, timedelta, timezone
 from typing import Callable, Optional
 from trex_core.application.alarm_emitter import AlarmEmitter
 from trex_core.application.broker_port import BrokerPort
 from trex_core.application.portfolio import (
    DegradedReason,
@@ -40,6 +41,7 @@ class SnapshotScheduler:
        slot_repo=None,
        slot_service=None,
        instance_key: str = "default",
        alarm_emitter: Optional[AlarmEmitter] = None,
    ) -> None:
        self._read = read_port
        self._store = store
@@ -55,6 +57,8 @@ class SnapshotScheduler:
        self._slot_service = slot_service
        self._instance_key = instance_key
        self._last_universe_size: Optional[int] = None
        # dcy-033 / REQ-100: best-effort alarm emitter.
        self._alarm_emitter = alarm_emitter
    # ---- callable from a daemon thread loop --------------------------------
    def run_forever(self, stop: threading.Event, *, tick_sec: float = 60.0) -> None:
@@ -88,6 +92,13 @@ class SnapshotScheduler:
                    DegradedReason.PORTFOLIO_HUB_UNAVAILABLE, str(exc)
                )
                _log.warning("whoami failed: %s", exc)
                # dcy-033 / REQ-100: CRITICAL alarm — portfolio hub unavailable.
                if self._alarm_emitter is not None:
                    self._alarm_emitter.publish_alarm(
                        "portfolio_hub_unavailable",
                        "portfolio-hub whoami 실패: 포트폴리오 정보 부실화",
                        fields={"reason": "whoami_failed"},
                    )
                return False
        try:
            items = self._read.get_portfolios(self._daemon_id)
@@ -96,6 +107,13 @@ class SnapshotScheduler:
                DegradedReason.PORTFOLIO_HUB_UNAVAILABLE, str(exc)
            )
            _log.warning("get_portfolios failed: %s", exc)
            # dcy-033 / REQ-100: CRITICAL alarm — portfolio hub unavailable.
            if self._alarm_emitter is not None:
                self._alarm_emitter.publish_alarm(
                    "portfolio_hub_unavailable",
                    "portfolio-hub get_portfolios 실패: 포트폴리오 정보 부실화",
                    fields={"daemon_id": self._daemon_id, "reason": "get_portfolios_failed"},
                )
            return False
        except Exception as exc:  # noqa: BLE001 - shape/parsing failure
            self._store.set_degraded(
@@ -120,6 +138,7 @@ class SnapshotScheduler:
                    reconcile_core_holdings(
                        slot_repo=self._slot_repo, slot_service=self._slot_service,
                        broker=self._broker, instance_key=self._instance_key,
                        alarm_emitter=self._alarm_emitter,  # dcy-033 / REQ-100
                    )
                except Exception:  # noqa: BLE001
                    _log.exception("core-holding divergence reconcile failed")
@@ -44,6 +44,7 @@ from trex_core.adapters.portfolio import (
    StubPortfolioRead,
 )
 from trex_core.adapters.portfolio.killswitch_store import PostgreSQLKillSwitchStore
 from trex_core.application.alarm_emitter import AlarmEmitter
 from trex_core.application.broker_port import BrokerPort
 from trex_core.application.execution import ExecutionService
 from trex_core.application.intents import IntentService
@@ -169,25 +170,42 @@ class Daemon:
        # BAT-008: portfolio-hub read + snapshot store + durable pause + scheduler.
        # (Created before the ledger writer so option-D write-back can target it.)
        self.snapshot_store = SnapshotStore()
        # BAT-010/011: per-slot watchdog (snapshot RPC writer, safety-sell reader).
        self.watchdog = WatchdogStore()
        self.pause_store = PostgreSQLPauseStore(config.dsn)
        # BAT-012: day-scoped kill-switch exclusion store + service.
        self.killswitch_store = PostgreSQLKillSwitchStore(config.dsn)
        self.portfolio_read = _build_portfolio_read(config)
        # Event publisher transport — one dedicated instance for the
        # execution-loop thread (pika is not thread-safe).
        self.event_publisher: MessagingTransport = _build_transport(config)
        self._transports.append(self.event_publisher)
        # dcy-033 / REQ-100: alarm emitter — shares the event_publisher transport
        # (both run on the execution-loop thread; pika thread-safety rule satisfied).
        # Created before services so all services receive the same emitter instance.
        self.alarm_emitter = AlarmEmitter(self.event_publisher)
        # Late-bind alarm callback into event_publisher for adapter-layer alarm codes
        # (KD-1: publish_unavailable_after_reconnect / dlq_publish_failed).
        if hasattr(self.event_publisher, "set_alarm_callback"):
            self.event_publisher.set_alarm_callback(self.alarm_emitter.publish_alarm)
        self.ledger_writer = LedgerWriter(
            self.outbox, _build_ledger(config),
            snapshot_store=self.snapshot_store,  # dcy-018 / REQ-030: option D write-back
            retry_base_sec=config.ledger_retry_base_sec,
            retry_cap_sec=config.ledger_retry_cap_sec,
            max_attempts=config.ledger_max_attempts,
            alarm_emitter=self.alarm_emitter,  # dcy-033 / REQ-100
        )
        # BAT-010/011: per-slot watchdog (snapshot RPC writer, safety-sell reader).
        self.watchdog = WatchdogStore()
        self.pause_store = PostgreSQLPauseStore(config.dsn)
        # BAT-012: day-scoped kill-switch exclusion store + service.
        self.killswitch_store = PostgreSQLKillSwitchStore(config.dsn)
        self.kill_switch = KillSwitchService(
            slot_repo=self.slot_repo,
            slot_service=self.slot_service,
            killswitch_store=self.killswitch_store,
            instance_key=config.instance_key,
            alarm_emitter=self.alarm_emitter,  # dcy-033 / REQ-100
        )
        self.portfolio_read = _build_portfolio_read(config)
        self.snapshot_scheduler = SnapshotScheduler(
            read_port=self.portfolio_read,
            store=self.snapshot_store,
@@ -199,19 +217,15 @@ class Daemon:
            slot_repo=self.slot_repo,
            slot_service=self.slot_service,
            instance_key=config.instance_key,
            alarm_emitter=self.alarm_emitter,  # dcy-033 / REQ-100
        )
        # Event publisher transport — one dedicated instance for the
        # execution-loop thread (pika is not thread-safe).
        self.event_publisher: MessagingTransport = _build_transport(config)
        self._transports.append(self.event_publisher)
        self.execution = ExecutionService(
            self.slot_service, self.slot_repo, self.broker,
            ledger_outbox=self.outbox,
            event_emitter=self._make_event_emitter(),
            stale_pending_threshold_sec=config.pending_stale_threshold_sec,
            instance_key=config.instance_key,
            alarm_emitter=self.alarm_emitter,  # dcy-033 / REQ-100
        )
        # BAT-011: safety-sell trigger service (forced_close / SL-TP / market-close).
@@ -29,6 +29,21 @@ from typing import Any, Optional
 _log = logging.getLogger(__name__)
 def _emit_reset_alarm(
    alarm_emitter: Optional[object],
    code: str,
    title: str,
    fields: dict | None = None,
 ) -> None:
    """Best-effort alarm from reset.py (transport may be None — dcy-033 / REQ-100 KD-2)."""
    if alarm_emitter is None:
        return
    try:
        alarm_emitter.publish_alarm(code, title, fields=fields)  # type: ignore[union-attr]
    except Exception:  # noqa: BLE001
        _log.debug("reset alarm emit failed (code=%s)", code, exc_info=True)
 # slot-core tables owned by trex-core migrations (drop order irrelevant — no FKs).
 SLOT_CORE_TABLES: tuple[str, ...] = (
    "daily_slot",
@@ -74,6 +89,7 @@ def run_reset(
    *,
    dry_run: bool = True,
    psycopg_module: Any = None,
    alarm_emitter: Optional[object] = None,
 ) -> ResetReport:
    """Wipe the slot-core tables and reapply migrations to the asset-centric schema.
@@ -106,7 +122,17 @@ def run_reset(
    # 010 sets the inactive CHECK, 011 drops the pool-model columns.
    from trex_core.adapters.persistence.migrate import apply_migrations
-    report.migrations_applied = apply_migrations(dsn, psycopg_module=psycopg_module)
+    try:
        report.migrations_applied = apply_migrations(dsn, psycopg_module=psycopg_module)
    except Exception as mig_exc:  # noqa: BLE001
        # dcy-033 / REQ-100: CRITICAL alarm — migration failed.
        _emit_reset_alarm(
            alarm_emitter,
            "migration_failed",
            f"마이그레이션 실패: {mig_exc.__class__.__name__}",
            fields={"error": str(mig_exc)},
        )
        raise
    from trex_core.domain.slot import EXPECTED_SLOT_FIELDS
@@ -118,6 +144,14 @@ def run_reset(
            )
            cols = {r[0] for r in cur.fetchall()}
    report.schema_ok = cols == set(EXPECTED_SLOT_FIELDS)
    if not report.schema_ok:
        # dcy-033 / REQ-100: CRITICAL alarm — schema verification failed post-reset.
        _emit_reset_alarm(
            alarm_emitter,
            "schema_verification_failed",
            "리셋 후 schema 검증 실패: daily_slot 컬럼 불일치",
            fields={"expected": sorted(EXPECTED_SLOT_FIELDS), "actual": sorted(cols)},
        )
    return report