Merge pull request 'process: automate backtest gate for PR/push/schedule (#314 )' (#315 ) from feature/issue-314-backtest-gate-automation into feature/v3-session-policy-stream

process: automate backtest gate for PR/push/schedule (#314 )
Merge pull request 'feat: integrate v2 backtest validation pipeline (#305 )' (#313 ) from feature/issue-305-backtest-pipeline-integration into feature/v3-session-policy-stream
2026-02-28 03:25:45 +09:00 · 2026-02-28 03:25:00 +09:00 · 2026-02-27 23:59:34 +09:00 · 2026-02-27 23:58:52 +09:00 · 2026-02-27 23:49:59 +09:00 · 2026-02-27 23:48:52 +09:00
57 changed files with 6220 additions and 84 deletions
--- a/.gitea/ISSUE_TEMPLATE/runtime_verification.md
+++ b/.gitea/ISSUE_TEMPLATE/runtime_verification.md
@@ -0,0 +1,41 @@
 ---
 name: Runtime Verification Incident
 about: 실운영/스테이징 동작 검증 중 발견된 이상 징후 등록
 title: "[RUNTIME-VERIFY][SCN-XXX] "
 labels: runtime, verification
 ---
 ## Summary
 - 현상:
 - 최초 관측 시각(UTC):
 ## Reproduction / Observation
 - 실행 모드(`live`/`paper`):
 - 세션(`NXT`, `US_PRE`, `US_DAY`, `US_AFTER`, ...):
 - 실행 커맨드:
 - 로그 경로:
 ## Expected vs Actual
 - Expected:
 - Actual:
 ## Requirement Mapping
 - REQ:
 - TASK:
 - TEST:
 ## Temporary Mitigation
 - 즉시 완화책:
 ## Close Criteria
 - [ ] Dev 수정 반영
 - [ ] Verifier 재검증 PASS
 - [ ] Runtime Verifier 재관측 PASS
 - [ ] `NOT_OBSERVED = 0`
--- a/.gitea/PULL_REQUEST_TEMPLATE.md
+++ b/.gitea/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,53 @@
 ## Linked Issue
 - Closes #N
 ## Scope
 - REQ: `REQ-...`
 - TASK: `TASK-...`
 - TEST: `TEST-...`
 ## Ticket Stage
 - Current stage: `Implemented` / `Integrated` / `Observed` / `Accepted`
 - Previous stage evidence link:
 ## Main -> Verifier Directive Contract
 - Scope: 대상 요구사항/코드/로그 경로
 - Method: 실행 커맨드 + 관측 포인트
 - PASS criteria:
 - FAIL criteria:
 - NOT_OBSERVED criteria:
 - Evidence format: PR 코멘트 `Coverage Matrix`
 ## Verifier Coverage Matrix (Required)
 | Item | Evidence | Status (PASS/FAIL/NOT_OBSERVED) |
 |---|---|---|
 | REQ-... | 링크/로그 | PASS |
 `NOT_OBSERVED`가 1개라도 있으면 승인/머지 금지.
 ## Gitea Preflight
 - [ ] `docs/commands.md`와 `docs/workflow.md` 트러블슈팅 선확인
 - [ ] `tea` 사용 (`gh` 미사용)
 ## Session Handover Gate
 - [ ] `python3 scripts/session_handover_check.py --strict` 통과
 - [ ] `workflow/session-handover.md` 최신 엔트리가 현재 브랜치/당일(UTC) 기준으로 갱신됨
 - 최신 handover 엔트리 heading:
 ## Runtime Evidence
 - 시스템 실제 구동 커맨드:
 - 모니터링 로그 경로:
 - 이상 징후/이슈 링크:
 ## Approval Gate
 - [ ] Static Verifier approval comment linked
 - [ ] Runtime Verifier approval comment linked
--- a/.gitea/workflows/ci.yml
+++ b/.gitea/workflows/ci.yml
@@ -0,0 +1,38 @@
 name: Gitea CI
 on:
  pull_request:
  push:
    branches:
      - main
      - feature/**
 jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4
      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"
      - name: Install dependencies
        run: pip install ".[dev]"
      - name: Session handover gate
        run: python3 scripts/session_handover_check.py --strict
      - name: Validate governance assets
        run: python3 scripts/validate_governance_assets.py
      - name: Validate Ouroboros docs
        run: python3 scripts/validate_ouroboros_docs.py
      - name: Lint
        run: ruff check src/ tests/
      - name: Run tests with coverage
        run: pytest -v --cov=src --cov-report=term-missing --cov-fail-under=80
--- a/.github/workflows/backtest-gate.yml
+++ b/.github/workflows/backtest-gate.yml
@@ -0,0 +1,66 @@
 name: Backtest Gate
 on:
  pull_request:
    branches: ["**"]
  push:
    branches:
      - "feature/**"
  schedule:
    # Daily scheduled gate (KST 01:20)
    - cron: "20 16 * * *"
  workflow_dispatch:
    inputs:
      mode:
        description: "backtest mode (auto|smoke|full)"
        required: false
        default: "auto"
      base_ref:
        description: "git base ref for changed-file diff"
        required: false
        default: "origin/main"
 jobs:
  backtest-gate:
    runs-on: ubuntu-latest
    concurrency:
      group: backtest-gate-${{ github.ref }}
      cancel-in-progress: true
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - name: Set up Python 3.11
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"
      - name: Install dependencies
        run: pip install ".[dev]"
      - name: Resolve base ref
        id: base
        run: |
          if [ "${{ github.event_name }}" = "pull_request" ]; then
            echo "ref=origin/${{ github.base_ref }}" >> "$GITHUB_OUTPUT"
          elif [ "${{ github.event_name }}" = "workflow_dispatch" ] && [ -n "${{ github.event.inputs.base_ref }}" ]; then
            echo "ref=${{ github.event.inputs.base_ref }}" >> "$GITHUB_OUTPUT"
          else
            echo "ref=origin/main" >> "$GITHUB_OUTPUT"
          fi
      - name: Run backtest gate
        env:
          BASE_REF: ${{ steps.base.outputs.ref }}
          BACKTEST_MODE: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.mode || 'auto' }}
          FORCE_FULL_BACKTEST: ${{ github.event_name == 'schedule' && 'true' || 'false' }}
        run: bash scripts/backtest_gate.sh
      - name: Upload backtest logs
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: backtest-gate-logs
          path: data/backtest-gate/*.log
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,6 +21,15 @@ jobs:
      - name: Install dependencies
        run: pip install ".[dev]"
      - name: Session handover gate
        run: python3 scripts/session_handover_check.py --strict
      - name: Validate governance assets
        run: python3 scripts/validate_governance_assets.py
      - name: Validate Ouroboros docs
        run: python3 scripts/validate_ouroboros_docs.py
      - name: Lint
        run: ruff check src/ tests/
--- a/docs/agent-constraints.md
+++ b/docs/agent-constraints.md
@@ -12,6 +12,8 @@ It is distinct from `docs/requirements-log.md`, which records **project/product
 1. **Workflow enforcement**
   - Follow `docs/workflow.md` for all changes.
   - Before any Gitea issue/PR/comment operation, read `docs/commands.md` and `docs/workflow.md` troubleshooting section.
   - Use `tea` for Gitea operations; do not use GitHub CLI (`gh`) in this repository workflow.
   - Create a Gitea issue before any code or documentation change.
   - Work on a feature branch `feature/issue-{N}-{short-description}` and open a PR.
   - Never commit directly to `main`.
@@ -30,6 +32,16 @@ It is distinct from `docs/requirements-log.md`, which records **project/product
     (or in a dedicated policy doc) and reference it when working.
   - Keep entries short and concrete, with dates.
 5. **Session start handover gate**
   - Before implementation/verification work, run `python3 scripts/session_handover_check.py --strict`.
   - Keep `workflow/session-handover.md` updated with a same-day entry for the active branch.
   - If the check fails, stop and fix handover artifacts first.
 6. **Process-change-first execution gate**
   - If process/governance change is required, merge the process ticket to the feature branch first.
   - Do not start code/test edits for implementation tickets until process merge evidence is confirmed.
   - Subagents must be constrained to read-only exploration until the process gate is satisfied.
 ## Change Control
 - Changes to this file follow the same workflow as code changes.
@@ -43,3 +55,15 @@ It is distinct from `docs/requirements-log.md`, which records **project/product
 - When work requires guidance, consult the relevant `docs/` policies first.
 - Any code change must be accompanied by relevant documentation updates.
 - Persist user constraints across sessions by recording them in this document.
 ### 2026-02-27
 - All agents must pre-read `docs/commands.md` and `docs/workflow.md` troubleshooting before running Gitea issue/PR/comment commands.
 - `gh` CLI is prohibited for repository ticket/PR operations; use `tea` (or documented Gitea API fallback only).
 - Session start must pass `python3 scripts/session_handover_check.py --strict`, with branch-matched entry in `workflow/session-handover.md`.
 ### 2026-02-27
 - Apply process-change-first as an execution gate: process ticket must be merged before implementation ticket coding.
 - Handover entry must record concrete `next_ticket` and `process_gate_checked`; placeholders are not allowed in strict gate.
 - Before process merge confirmation, all subagent tasks must remain read-only (analysis only).
--- a/docs/commands.md
+++ b/docs/commands.md
@@ -4,6 +4,23 @@
 **Critical: Learn from failures. Never repeat the same failed command without modification.**
 ## Repository VCS Rule (Mandatory)
 - 이 저장소의 티켓/PR/코멘트 작업은 Gitea 기준으로 수행한다.
 - `gh`(GitHub CLI) 명령 사용은 금지한다.
 - 기본 도구는 `tea`이며, `tea` 미지원 케이스만 Gitea API를 fallback으로 사용한다.
 - 실행 전 `docs/workflow.md`의 `Gitea CLI Formatting Troubleshooting`을 반드시 확인한다.
 ## Session Handover Preflight (Mandatory)
 - 세션 시작 직후(코드 변경 전) 아래 명령을 먼저 실행한다.
 ```bash
 python3 scripts/session_handover_check.py --strict
 ```
 - 실패 시 `workflow/session-handover.md` 최신 엔트리를 보강한 뒤 재실행한다.
 ### tea CLI (Gitea Command Line Tool)
 #### ❌ TTY Error - Interactive Confirmation Fails
@@ -140,6 +157,15 @@ python -m src.main --mode=paper
 # Run with dashboard enabled
 python -m src.main --mode=paper --dashboard
 # Runtime verification monitor (NOT_OBSERVED detection)
 bash scripts/runtime_verify_monitor.sh
 # Session handover gate (must pass before implementation)
 python3 scripts/session_handover_check.py --strict
 # Follow runtime verification log
 tail -f data/overnight/runtime_verify_*.log
 # Docker
 docker compose up -d ouroboros          # Run agent
 docker compose --profile test up test   # Run tests in container
--- a/docs/ouroboros/00_validation_system.md
+++ b/docs/ouroboros/00_validation_system.md
@@ -0,0 +1,56 @@
 <!--
 Doc-ID: DOC-VAL-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # 문서 검증 시스템
 본 문서는 문서 간 허위 내용, 수치 충돌, 구현 불가능 지시를 사전에 제거하기 위한 검증 규칙이다.
 ## 검증 목표
 - 단일 진실원장 기준으로 모든 지시서의 수치/규칙 정합성 보장
 - 설계 문장과 코드 작업 지시 간 추적성 보장
 - 테스트 미정의 상태에서 구현 착수 금지
 ## 불일치 유형 정의
 - `RULE-DOC-001`: 정의되지 않은 요구사항 ID 사용
 - `RULE-DOC-002`: 동일 요구사항 ID에 상충되는 값(예: 슬리피지 수치) 기술
 - `RULE-DOC-003`: 시간대 미표기 또는 KST/UTC 혼용 지시
 - `RULE-DOC-004`: 주문 정책과 리스크 정책 충돌(예: 저유동 세션 시장가 허용)
 - `RULE-DOC-005`: 구현 태스크에 테스트 ID 미연결
 - `RULE-DOC-006`: 문서 라우팅 링크 깨짐
 ## 검증 파이프라인
 1. 정적 검사 (자동)
 - 대상: `docs/ouroboros/*.md`
 - 검사: 메타데이터, 링크 유효성, ID 정의/참조 일치, REQ-추적성 매핑
 - 도구: `scripts/validate_ouroboros_docs.py`
 2. 추적성 검사 (자동 + 수동)
 - 자동: `REQ-*`가 최소 1개 `TASK-*`와 1개 `TEST-*`에 연결되었는지 확인
 - 수동: 정책 충돌 후보를 PR 체크리스트로 검토
 3. 도메인 무결성 검사 (수동)
 - KIS 점검시간 회피, 주문 유형 강제, Kill Switch 순서, 환율 정책이 동시에 존재하는지 점검
 - 백테스트 체결가가 보수 가정인지 점검
 ## 변경 통제 규칙
 - `REQ-*` 추가/수정 시 반드시 `01_requirements_registry.md` 먼저 변경
 - `TASK-*` 수정 시 반드시 `40_acceptance_and_test_plan.md`의 대응 테스트를 동시 수정
 - 충돌 발생 시 우선순위: `requirements_registry > phase execution > code work order`
 적용 룰셋:
 - `RULE-DOC-001` `RULE-DOC-002` `RULE-DOC-003` `RULE-DOC-004` `RULE-DOC-005` `RULE-DOC-006`
 ## PR 게이트
 - `python3 scripts/validate_ouroboros_docs.py` 성공
 - 신규/변경 `REQ-*`가 테스트 기준(`TEST-*`)과 연결됨
 - 원본 계획(v2/v3)과 모순 없음
--- a/docs/ouroboros/01_requirements_registry.md
+++ b/docs/ouroboros/01_requirements_registry.md
@@ -0,0 +1,39 @@
 <!--
 Doc-ID: DOC-REQ-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # 요구사항 원장 (Single Source of Truth)
 이 문서의 ID가 계획/구현/테스트 전 문서에서 참조되는 유일한 요구사항 집합이다.
 ## v2 핵심 요구사항
 - `REQ-V2-001`: 상태는 `HOLDING`, `BE_LOCK`, `ARMED`, `EXITED` 4단계여야 한다.
 - `REQ-V2-002`: 상태 전이는 매 틱/바 평가 시 최상위 상태로 즉시 승격되어야 한다.
 - `REQ-V2-003`: `EXITED` 조건은 모든 상태보다 우선 평가되어야 한다.
 - `REQ-V2-004`: 청산 로직은 Hard Stop, BE Lock, ATR Trailing, 모델 확률 보조 트리거를 포함해야 한다.
 - `REQ-V2-005`: 라벨링은 Triple Barrier(Upper/Lower/Time) 방식이어야 한다.
 - `REQ-V2-006`: 검증은 Walk-forward + Purge/Embargo를 강제한다.
 - `REQ-V2-007`: 백테스트는 비용/슬리피지/체결실패를 반영하지 않으면 채택 불가다.
 - `REQ-V2-008`: Kill Switch는 신규주문차단 -> 미체결취소 -> 재조회 -> 리스크축소 -> 스냅샷 순서다.
 ## v3 핵심 요구사항
 - `REQ-V3-001`: 모든 신호/주문/로그는 `session_id`를 포함해야 한다.
 - `REQ-V3-002`: 세션 전환 시 리스크 파라미터 재로딩이 수행되어야 한다.
 - `REQ-V3-003`: 브로커 블랙아웃 시간대에는 신규 주문이 금지되어야 한다.
 - `REQ-V3-004`: 블랙아웃 중 신호는 Queue에 적재되고, 복구 후 유효성 재검증을 거친다.
 - `REQ-V3-005`: 저유동 세션(`NXT_AFTER`, `US_PRE`, `US_DAY`, `US_AFTER`)은 시장가 주문 금지다.
 - `REQ-V3-006`: 백테스트 체결가는 불리한 방향 체결 가정을 기본으로 한다.
 - `REQ-V3-007`: US 운용은 환율 손익 분리 추적과 통화 버퍼 정책을 포함해야 한다.
 - `REQ-V3-008`: 마감/오버나잇 규칙은 Kill Switch와 충돌 없이 연동되어야 한다.
 ## 공통 운영 요구사항
 - `REQ-OPS-001`: 타임존은 모든 시간 필드에 명시(KST/UTC)되어야 한다.
 - `REQ-OPS-002`: 문서의 수치 정책은 원장에서만 변경한다.
 - `REQ-OPS-003`: 구현 태스크는 반드시 테스트 태스크를 동반한다.
--- a/docs/ouroboros/10_phase_v2_execution.md
+++ b/docs/ouroboros/10_phase_v2_execution.md
@@ -0,0 +1,63 @@
 <!--
 Doc-ID: DOC-PHASE-V2-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # v2 실행 지시서 (설계 -> 코드)
 참조 요구사항: `REQ-V2-001` `REQ-V2-002` `REQ-V2-003` `REQ-V2-004` `REQ-V2-005` `REQ-V2-006` `REQ-V2-007` `REQ-V2-008` `REQ-OPS-001` `REQ-OPS-002` `REQ-OPS-003`
 ## 단계 1: 도메인 모델 확정
 - `TASK-V2-001`: 상태머신 enum/전이 이벤트/전이 사유 스키마 설계
 - `TASK-V2-002`: `position_state` 스냅샷 구조(현재상태, peak, stops, last_reason) 정의
 - `TASK-V2-003`: 청산 판단 입력 DTO(가격, ATR, pred_prob, liquidity_signal) 정의
 완료 기준:
 - 상태와 전이 사유가 로그/DB에서 재현 가능
 - `REQ-V2-001`~`003`을 코드 타입 수준에서 강제
 ## 단계 2: 청산 엔진 구현
 - `TASK-V2-004`: 우선순위 기반 전이 함수 구현(`evaluate_exit_first` -> `promote_state`)
 - `TASK-V2-005`: Hard Stop/BE Lock/ATR Trailing 결합 로직 구현
 - `TASK-V2-006`: 모델 확률 신호를 보조 트리거로 결합(단독 청산 금지)
 완료 기준:
 - 갭 상황에서 다중 조건 동시 충족 시 최상위 상태로 단번 전이
 - `REQ-V2-004` 준수
 ## 단계 3: 라벨링/학습 데이터 파이프라인
 - `TASK-V2-007`: Triple Barrier 라벨러 구현(장벽 선터치 우선)
 - `TASK-V2-008`: 피처 구간/라벨 구간 분리 검증 유틸 구현
 - `TASK-V2-009`: 라벨 생성 로그(진입시각, 터치장벽, 만기장벽) 기록
 완료 기준:
 - look-ahead 차단 증빙 로그 확보
 - `REQ-V2-005` 충족
 ## 단계 4: 검증 프레임워크
 - `TASK-V2-010`: Walk-forward split + Purge/Embargo 분할기 구현
 - `TASK-V2-011`: 베이스라인(`B0`,`B1`,`M1`) 비교 리포트 포맷 구현
 - `TASK-V2-012`: 체결 비용/슬리피지/실패 반영 백테스트 옵션 강제
 완료 기준:
 - `REQ-V2-006`, `REQ-V2-007` 충족
 ## 단계 5: Kill Switch 통합
 - `TASK-V2-013`: Kill Switch 순차 실행 오케스트레이터 구현 (`src/core/risk_manager.py` 수정 금지)
 - `TASK-V2-014`: 주문 차단 플래그/미체결 취소/재조회 재시도 로직 구현
 - `TASK-V2-015`: 스냅샷/알림/복구 진입 절차 구현
 완료 기준:
 - `REQ-V2-008` 순서 일치
 라우팅:
 - 코드 지시 상세: [30_code_level_work_orders.md](./30_code_level_work_orders.md)
 - 테스트 상세: [40_acceptance_and_test_plan.md](./40_acceptance_and_test_plan.md)
--- a/docs/ouroboros/20_phase_v3_execution.md
+++ b/docs/ouroboros/20_phase_v3_execution.md
@@ -0,0 +1,60 @@
 <!--
 Doc-ID: DOC-PHASE-V3-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # v3 실행 지시서 (세션 확장)
 참조 요구사항: `REQ-V3-001` `REQ-V3-002` `REQ-V3-003` `REQ-V3-004` `REQ-V3-005` `REQ-V3-006` `REQ-V3-007` `REQ-V3-008` `REQ-OPS-001` `REQ-OPS-002` `REQ-OPS-003`
 ## 단계 1: 세션 엔진
 - `TASK-V3-001`: `session_id` 분류기 구현(KR/US 확장 세션)
 - `TASK-V3-002`: 세션 전환 훅에서 리스크 파라미터 재로딩 구현
 - `TASK-V3-003`: 로그/DB 스키마에 `session_id` 필드 강제
 완료 기준:
 - `REQ-V3-001`, `REQ-V3-002` 충족
 ## 단계 2: 블랙아웃/복구 제어
 - `TASK-V3-004`: 블랙아웃 윈도우 정책 로더 구현(설정 기반)
 - `TASK-V3-005`: 블랙아웃 중 신규 주문 차단 + 의도 큐 적재 구현
 - `TASK-V3-006`: 복구 시 동기화(잔고/미체결/체결) 후 큐 재검증 실행
 완료 기준:
 - `REQ-V3-003`, `REQ-V3-004` 충족
 ## 단계 3: 주문 정책 강화
 - `TASK-V3-007`: 세션별 주문 타입 매트릭스 구현
 - `TASK-V3-008`: 저유동 세션 시장가 주문 하드 차단
 - `TASK-V3-009`: 재호가 간격/횟수 제한 및 주문 철회 조건 구현
 완료 기준:
 - `REQ-V3-005` 충족
 ## 단계 4: 비용/체결 모델 정교화
 - `TASK-V3-010`: 세션별 슬리피지/비용 테이블 엔진 반영
 - `TASK-V3-011`: 불리한 체결 가정(상대 호가 방향) 체결기 구현
 - `TASK-V3-012`: 시나리오별 체결 실패/부분체결 모델 반영
 완료 기준:
 - `REQ-V3-006` 충족
 ## 단계 5: 환율/오버나잇/Kill Switch 연동
 - `TASK-V3-013`: 전략 PnL과 FX PnL 분리 회계 구현
 - `TASK-V3-014`: USD/KRW 버퍼 규칙 위반 시 신규 진입 제한 구현
 - `TASK-V3-015`: 오버나잇 예외와 Kill Switch 우선순위 통합
 완료 기준:
 - `REQ-V3-007`, `REQ-V3-008` 충족
 라우팅:
 - 코드 지시 상세: [30_code_level_work_orders.md](./30_code_level_work_orders.md)
 - 테스트 상세: [40_acceptance_and_test_plan.md](./40_acceptance_and_test_plan.md)
--- a/docs/ouroboros/30_code_level_work_orders.md
+++ b/docs/ouroboros/30_code_level_work_orders.md
@@ -0,0 +1,59 @@
 <!--
 Doc-ID: DOC-CODE-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # 코드 레벨 작업 지시서
 본 문서는 파일 단위 구현 지시서다. 모든 작업은 요구사항 ID와 테스트 ID를 포함해야 한다.
 제약:
 - `src/core/risk_manager.py`는 READ-ONLY로 간주하고 수정하지 않는다.
 - Kill Switch는 별도 모듈(예: `src/core/kill_switch.py`)로 추가하고 상위 실행 루프에서 연동한다.
 ## 구현 단위 A: 상태기계/청산
 - `TASK-CODE-001` (`REQ-V2-001`,`REQ-V2-002`,`REQ-V2-003`): `src/strategy/`에 상태기계 모듈 추가
 - `TASK-CODE-002` (`REQ-V2-004`): ATR/BE/Hard Stop 결합 청산 함수 추가
 - `TASK-CODE-003` (`REQ-V2-008`): Kill Switch 오케스트레이터를 `src/core/kill_switch.py`에 추가
 - `TEST-CODE-001`: 갭 점프 시 최고상태 승격 테스트
 - `TEST-CODE-002`: EXIT 우선순위 테스트
 ## 구현 단위 B: 라벨링/검증
 - `TASK-CODE-004` (`REQ-V2-005`): Triple Barrier 라벨러 모듈 추가(`src/analysis/` 또는 `src/strategy/`)
 - `TASK-CODE-005` (`REQ-V2-006`): Walk-forward + Purge/Embargo 분할 유틸 추가
 - `TASK-CODE-006` (`REQ-V2-007`): 백테스트 실행기에서 비용/슬리피지 옵션 필수화
 - `TEST-CODE-003`: 라벨 선터치 우선 테스트
 - `TEST-CODE-004`: 누수 차단 테스트
 ## 구현 단위 C: 세션/주문 정책
 - `TASK-CODE-007` (`REQ-V3-001`,`REQ-V3-002`): 세션 분류/전환 훅을 `src/markets/schedule.py` 연동
 - `TASK-CODE-008` (`REQ-V3-003`,`REQ-V3-004`): 블랙아웃 큐 처리기를 `src/broker/`에 추가
 - `TASK-CODE-009` (`REQ-V3-005`): 세션별 주문 타입 검증기 추가
 - `TEST-CODE-005`: 블랙아웃 신규주문 차단 테스트
 - `TEST-CODE-006`: 저유동 세션 시장가 거부 테스트
 ## 구현 단위 D: 체결/환율/오버나잇
 - `TASK-CODE-010` (`REQ-V3-006`): 불리한 체결가 모델을 백테스트 체결기로 구현
 - `TASK-CODE-011` (`REQ-V3-007`): FX PnL 분리 회계 테이블/컬럼 추가
 - `TASK-CODE-012` (`REQ-V3-008`): 오버나잇 예외와 Kill Switch 충돌 해소 로직 구현
 - `TEST-CODE-007`: 불리한 체결가 모델 테스트
 - `TEST-CODE-008`: FX 버퍼 위반 시 신규진입 제한 테스트
 ## 구현 단위 E: 운영/문서 거버넌스
 - `TASK-OPS-001` (`REQ-OPS-001`): 시간 필드/로그 스키마의 타임존 표기 강제 규칙 구현
 - `TASK-OPS-002` (`REQ-OPS-002`): 정책 수치 변경 시 `01_requirements_registry.md` 선수정 CI 체크 추가
 - `TASK-OPS-003` (`REQ-OPS-003`): `TASK-*` 없는 `REQ-*` 또는 `TEST-*` 없는 `REQ-*`를 차단하는 문서 검증 게이트 유지
 ## 커밋 규칙
 - 커밋 메시지에 `TASK-*` 포함
 - PR 본문에 `REQ-*`, `TEST-*` 매핑 표 포함
 - 변경 파일마다 최소 1개 테스트 연결
--- a/docs/ouroboros/40_acceptance_and_test_plan.md
+++ b/docs/ouroboros/40_acceptance_and_test_plan.md
@@ -0,0 +1,63 @@
 <!--
 Doc-ID: DOC-TEST-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # 수용 기준 및 테스트 계획
 ## 수용 기준
 - `TEST-ACC-000` (`REQ-V2-001`): 상태 enum은 4개(`HOLDING`,`BE_LOCK`,`ARMED`,`EXITED`)만 허용한다.
 - `TEST-ACC-001` (`REQ-V2-002`): 상태 전이는 순차 if-else가 아닌 우선순위 승격으로 동작한다.
 - `TEST-ACC-010` (`REQ-V2-003`): `EXITED` 조건은 어떤 상태보다 먼저 평가된다.
 - `TEST-ACC-011` (`REQ-V2-004`): 청산 판단은 Hard Stop/BE Lock/ATR/모델보조 4요소를 모두 포함한다.
 - `TEST-ACC-012` (`REQ-V2-005`): Triple Barrier 라벨은 first-touch 규칙으로 결정된다.
 - `TEST-ACC-013` (`REQ-V2-006`): 학습/검증 분할은 Walk-forward + Purge/Embargo를 적용한다.
 - `TEST-ACC-014` (`REQ-V2-007`): 비용/슬리피지/체결실패 옵션 비활성 시 백테스트 실행을 거부한다.
 - `TEST-ACC-002` (`REQ-V2-008`): Kill Switch 실행 순서가 고정 순서를 위반하지 않는다.
 - `TEST-ACC-015` (`REQ-V3-001`): 모든 주문/로그 레코드에 `session_id`가 저장된다.
 - `TEST-ACC-016` (`REQ-V3-002`): 세션 전환 이벤트 시 리스크 파라미터가 재로딩된다.
 - `TEST-ACC-003` (`REQ-V3-003`): 블랙아웃 중 신규 주문 API 호출이 발생하지 않는다.
 - `TEST-ACC-017` (`REQ-V3-004`): 블랙아웃 큐는 복구 후 재검증을 통과한 주문만 실행한다.
 - `TEST-ACC-004` (`REQ-V3-005`): 저유동 세션 시장가 주문은 항상 거부된다.
 - `TEST-ACC-005` (`REQ-V3-006`): 백테스트 체결가가 단순 종가 체결보다 보수적 손익을 낸다.
 - `TEST-ACC-006` (`REQ-V3-007`): 전략 손익과 환율 손익이 별도 집계된다.
 - `TEST-ACC-018` (`REQ-V3-008`): 오버나잇 예외 상태에서도 Kill Switch 우선순위가 유지된다.
 - `TEST-ACC-007` (`REQ-OPS-001`): 시간 관련 필드는 타임존(KST/UTC)이 누락되면 검증 실패한다.
 - `TEST-ACC-008` (`REQ-OPS-002`): 정책 수치 변경이 원장 미반영이면 검증 실패한다.
 - `TEST-ACC-009` (`REQ-OPS-003`): `REQ-*`가 `TASK-*`/`TEST-*` 매핑 없이 존재하면 검증 실패한다.
 ## 테스트 계층
 1. 단위 테스트
 - 상태 전이, 주문타입 검증, 큐 복구 로직, 체결가 모델
 2. 통합 테스트
 - 세션 전환 -> 주문 정책 -> 리스크 엔진 연동
 - 블랙아웃 시작/해제 이벤트 연동
 3. 회귀 테스트
 - 기존 `tests/` 스위트 전량 실행
 - 신규 기능 플래그 ON/OFF 비교
 4. 구동/모니터링 검증 (필수)
 - 개발 완료 후 시스템을 실제 구동해 핵심 경로를 관찰
 - 필수 관찰 항목: 주문 차단 정책, Kill Switch 동작, 경보/예외 로그, 세션 전환 로그
 - Runtime Verifier 코멘트로 증적(실행 명령/요약 로그) 첨부
 ## 실행 명령
 ```bash
 pytest -q
 python3 scripts/validate_ouroboros_docs.py
 ```
 ## 실패 처리 규칙
 - 문서 검증 실패 시 구현 PR 병합 금지
 - `REQ-*` 변경 후 테스트 매핑 누락 시 병합 금지
 - 회귀 실패 시 원인 모듈 분리 후 재검증
 - 구동/모니터링 증적 누락 시 검증 승인 금지
--- a/docs/ouroboros/50_scenario_matrix_and_issue_taxonomy.md
+++ b/docs/ouroboros/50_scenario_matrix_and_issue_taxonomy.md
@@ -0,0 +1,68 @@
 <!--
 Doc-ID: DOC-PM-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # 실전 시나리오 매트릭스 + 이슈 분류 체계
 목표: 운영에서 바로 사용할 수 있는 형태로 Happy Path / Failure Path / Ops Incident를 추적 가능한 ID 체계(`REQ-*`, `TASK-*`, `TEST-*`)에 매핑한다.
 ## 1) 시나리오 매트릭스
 | Scenario ID | Type | Trigger | Expected System Behavior | Primary IDs (REQ/TASK/TEST) | Ticket Priority |
 |---|---|---|---|---|---|
 | `SCN-HAPPY-001` | Happy Path | KR 정규 세션에서 진입 신호 발생, 블랙아웃 아님 | 주문/로그에 `session_id` 저장 후 정책에 맞는 주문 전송 | `REQ-V3-001`, `TASK-V3-001`, `TASK-V3-003`, `TEST-ACC-015` | P1 |
 | `SCN-HAPPY-002` | Happy Path | 보유 포지션에서 BE/ATR/Hard Stop 조건 순차 도달 | 상태가 즉시 상위 단계로 승격, `EXITED` 우선 평가 보장 | `REQ-V2-002`, `REQ-V2-003`, `TASK-V2-004`, `TEST-ACC-001`, `TEST-ACC-010` | P0 |
 | `SCN-HAPPY-003` | Happy Path | 세션 전환(KR->US) 이벤트 발생 | 리스크 파라미터 자동 재로딩, 새 세션 정책으로 즉시 전환 | `REQ-V3-002`, `TASK-V3-002`, `TEST-ACC-016` | P0 |
 | `SCN-HAPPY-004` | Happy Path | 백테스트 실행 요청 | 비용/슬리피지/체결실패 옵션 누락 시 실행 거부, 포함 시 실행 | `REQ-V2-007`, `TASK-V2-012`, `TEST-ACC-014` | P1 |
 | `SCN-FAIL-001` | Failure Path | 블랙아웃 중 신규 주문 신호 발생 | 신규 주문 차단 + 주문 의도 큐 적재, API 직접 호출 금지 | `REQ-V3-003`, `REQ-V3-004`, `TASK-V3-005`, `TEST-ACC-003`, `TEST-ACC-017` | P0 |
 | `SCN-FAIL-002` | Failure Path | 저유동 세션에 시장가 주문 요청 | 시장가 하드 거부, 지정가 대체 또는 주문 취소 | `REQ-V3-005`, `TASK-V3-007`, `TASK-V3-008`, `TEST-ACC-004` | P0 |
 | `SCN-FAIL-003` | Failure Path | Kill Switch 트리거(손실/연결/리스크 한도) | 신규주문차단->미체결취소->재조회->리스크축소->스냅샷 순서 강제 | `REQ-V2-008`, `TASK-V2-013`, `TEST-ACC-002` | P0 |
 | `SCN-FAIL-004` | Failure Path | FX 버퍼 부족 상태에서 US 진입 신호 | 전략 PnL/FX PnL 분리 집계 유지, 신규 진입 제한 | `REQ-V3-007`, `TASK-V3-013`, `TASK-V3-014`, `TEST-ACC-006` | P1 |
 | `SCN-OPS-001` | Ops Incident | 브로커 점검/블랙아웃 종료 직후 | 잔고/미체결/체결 동기화 후 큐 재검증 통과 주문만 집행 | `REQ-V3-004`, `TASK-V3-006`, `TEST-ACC-017` | P0 |
 | `SCN-OPS-002` | Ops Incident | 정책 수치가 코드에만 반영되고 원장 미수정 | 문서 검증에서 실패 처리, PR 병합 차단 | `REQ-OPS-002`, `TASK-OPS-002`, `TEST-ACC-008` | P0 |
 | `SCN-OPS-003` | Ops Incident | 타임존 누락 로그/스케줄 데이터 유입 | KST/UTC 미표기 레코드 검증 실패 처리 | `REQ-OPS-001`, `TASK-OPS-001`, `TEST-ACC-007` | P1 |
 | `SCN-OPS-004` | Ops Incident | 신규 REQ 추가 후 TASK/TEST 누락 | 추적성 게이트 실패, 구현 PR 병합 차단 | `REQ-OPS-003`, `TASK-OPS-003`, `TEST-ACC-009` | P0 |
 | `SCN-OPS-005` | Ops Incident | 배포 후 런타임 이상 동작(주문오류/상태전이오류/정책위반) 탐지 | Runtime Verifier가 즉시 이슈 발행, Dev 수정 후 재관측으로 클로즈 판정 | `REQ-V2-008`, `REQ-V3-003`, `REQ-V3-005`, `TEST-ACC-002`, `TEST-ACC-003`, `TEST-ACC-004` | P0 |
 ## 2) 이슈 분류 체계 (Issue Taxonomy)
 | Taxonomy | Definition | Typical Symptoms | Default Owner | Mapping Baseline |
 |---|---|---|---|---|
 | `EXEC-STATE` | 상태기계/청산 우선순위 위반 | EXIT 우선순위 깨짐, 상태 역행, 갭 대응 실패 | Strategy | `REQ-V2-001`~`REQ-V2-004`, `TASK-V2-004`~`TASK-V2-006`, `TEST-ACC-000`,`001`,`010`,`011` |
 | `EXEC-POLICY` | 세션/주문 정책 위반 | 블랙아웃 주문 전송, 저유동 시장가 허용 | Broker/Execution | `REQ-V3-003`~`REQ-V3-005`, `TASK-V3-004`~`TASK-V3-009`, `TEST-ACC-003`,`004`,`017` |
 | `BACKTEST-MODEL` | 백테스트 현실성/검증 무결성 위반 | 비용 옵션 off로 실행, 체결가 과낙관 | Research | `REQ-V2-006`,`REQ-V2-007`,`REQ-V3-006`, `TASK-V2-010`~`012`, `TASK-V3-010`~`012`, `TEST-ACC-013`,`014`,`005` |
 | `RISK-EMERGENCY` | Kill Switch/리스크 비상 대응 실패 | 순서 위반, 차단 누락, 복구 절차 누락 | Risk | `REQ-V2-008`,`REQ-V3-008`, `TASK-V2-013`~`015`, `TASK-V3-015`, `TEST-ACC-002`,`018` |
 | `FX-ACCOUNTING` | 환율/통화 버퍼 정책 위반 | 전략손익/환차손익 혼합 집계, 버퍼 미적용 | Risk + Data | `REQ-V3-007`, `TASK-V3-013`,`014`, `TEST-ACC-006` |
 | `OPS-GOVERNANCE` | 문서/추적성/타임존 거버넌스 위반 | 원장 미수정, TEST 누락, 타임존 미표기 | PM + QA | `REQ-OPS-001`~`003`, `TASK-OPS-001`~`003`, `TEST-ACC-007`~`009` |
 | `RUNTIME-VERIFY` | 실동작 모니터링 검증 | 배포 후 이상 현상, 간헐 오류, 테스트 미포착 회귀 | Runtime Verifier + TPM | 관련 `REQ/TASK/TEST`와 런타임 로그 증적 필수 |
 ## 3) 티켓 생성 규칙 (Implementable)
 1. 모든 이슈는 `taxonomy + scenario_id`를 제목에 포함한다.  
   예: `[EXEC-POLICY][SCN-FAIL-001] blackout 주문 차단 누락`
 2. 본문 필수 항목: 재현절차, 기대결과, 실제결과, 영향범위, 롤백/완화책.
 3. 본문에 최소 1개 `REQ-*`, 1개 `TASK-*`, 1개 `TEST-*`를 명시한다.
 4. 우선순위 기준:
 - P0: 실주문 위험, Kill Switch, 블랙아웃/시장가 정책, 추적성 게이트 실패
 - P1: 손익 왜곡 가능성(체결/FX/시간대), 운영 리스크 증가
 - P2: 보고서/관측성 품질 이슈(거래 안전성 영향 없음)
 5. Runtime Verifier가 발행한 `RUNTIME-VERIFY` 이슈는 Main Agent 확인 전 클로즈 금지.
 ## 4) 즉시 생성 권장 티켓 (초기 백로그)
 - `TKT-P0-001`: `[EXEC-POLICY][SCN-FAIL-001]` 블랙아웃 차단 + 큐적재 + 복구 재검증 e2e 점검 (`REQ-V3-003`,`REQ-V3-004`)
 - `TKT-P0-002`: `[RISK-EMERGENCY][SCN-FAIL-003]` Kill Switch 순서 강제 검증 자동화 (`REQ-V2-008`)
 - `TKT-P0-003`: `[OPS-GOVERNANCE][SCN-OPS-004]` REQ/TASK/TEST 누락 시 PR 차단 게이트 상시 점검 (`REQ-OPS-003`)
 - `TKT-P1-001`: `[FX-ACCOUNTING][SCN-FAIL-004]` FX 버퍼 위반 시 진입 제한 회귀 케이스 보강 (`REQ-V3-007`)
 - `TKT-P1-002`: `[BACKTEST-MODEL][SCN-HAPPY-004]` 비용/슬리피지 미설정 백테스트 거부 UX 명확화 (`REQ-V2-007`)
 - `TKT-P0-004`: `[RUNTIME-VERIFY][SCN-OPS-005]` 배포 후 런타임 이상 탐지/재현/클로즈 판정 절차 자동화
 ## 5) 운영 체크포인트
 - 스프린트 계획 시 `P0` 시나리오 100% 테스트 통과를 출발 조건으로 둔다.
 - 배포 승인 시 `SCN-FAIL-*`, `SCN-OPS-*` 관련 `TEST-ACC-*`를 우선 확인한다.
 - 정책 변경 PR은 반드시 원장(`01_requirements_registry.md`) 선수정 후 진행한다.
--- a/docs/ouroboros/50_tpm_control_protocol.md
+++ b/docs/ouroboros/50_tpm_control_protocol.md
@@ -0,0 +1,223 @@
 <!--
 Doc-ID: DOC-TPM-001
 Version: 1.0.0
 Status: active
 Owner: tpm
 Updated: 2026-02-26
 -->
 # TPM Control Protocol (Main <-> PM <-> TPM <-> Dev <-> Verifier <-> Runtime Verifier)
 목적:
 - PM 시나리오가 구현 가능한 단위로 분해되고, 개발/검증이 동일 ID 체계(`REQ-*`, `TASK-*`, `TEST-*`)로 닫히도록 강제한다.
 - 각 단계는 Entry/Exit gate를 통과해야 다음 단계로 이동 가능하다.
 - 주요 의사결정 포인트마다 Main Agent의 승인/의견 확인을 강제한다.
 ## Team Roles
 - Main Agent: 최종 취합/우선순위/승인 게이트 오너
 - PM Agent: 시나리오/요구사항/티켓 관리
 - TPM Agent: PM-Dev-검증 간 구현 가능성/달성률 통제, 티켓 등록 및 구현 우선순위 지정 오너
 - Dev Agent: 구현 수행, 블로커 발생 시 재계획 요청
 - Verifier Agent: 문서/코드/테스트 산출물 검증
 - Runtime Verifier Agent: 실제 동작 모니터링, 이상 징후 이슈 발행, 수정 후 이슈 클로즈 판정
 Main Agent 아이디에이션 책임:
 - 진행 중 신규 구현 아이디어를 별도 문서에 누적 기록한다.
 - 기록 위치: [70_main_agent_ideation.md](./70_main_agent_ideation.md)
 - 각 항목은 `IDEA-*` 식별자, 배경, 기대효과, 리스크, 후속 티켓 후보를 포함해야 한다.
 ## Main Decision Checkpoints (Mandatory)
 - DCP-01 범위 확정: Phase 0 종료 전 Main Agent 승인 필수
 - DCP-02 요구사항 확정: Phase 1 종료 전 Main Agent 승인 필수
 - DCP-03 구현 착수: Phase 2 종료 전 Main Agent 승인 필수
 - DCP-04 배포 승인: Phase 4 종료 후 Main Agent 최종 승인 필수
 Main/Verifier 사고 재발 방지 규칙:
 - Main Agent는 검증 위임 시 `Directive Contract`를 충족하지 않으면 검증 착수 금지
 - Verifier Agent는 지시 누락/모호성 발견 시 즉시 `BLOCKED`를 선언하고 보완 요청
 - Verifier Agent는 `미관측(NOT_OBSERVED)` 항목을 PASS로 보고할 수 없다
 - Runtime 검증에서 요구 세션 증적이 없으면 "정상"이 아니라 `미검증 이상`으로 이슈화한다
 ## Phase Control Gates
 ### Phase 0: Scenario Intake and Scope Lock
 Entry criteria:
 - PM 시나리오가 사용자 가치, 실패 모드, 우선순위를 포함해 제출됨
 - 영향 범위(모듈/세션/KR-US 시장)가 명시됨
 Exit criteria:
 - 시나리오가 `REQ-*` 후보에 1:1 또는 1:N 매핑됨
 - 모호한 표현("개선", "최적화")은 측정 가능한 조건으로 치환됨
 - 비범위 항목(out-of-scope) 명시
 Control checks:
 - PM/TPM 합의 완료
 - Main Agent 승인(DCP-01)
 - 산출물: 시나리오 카드, 초기 매핑 메모
 ### Phase 1: Requirement Registry Gate
 Entry criteria:
 - Phase 0 산출물 승인
 - 변경 대상 요구사항 문서 식별 완료
 Exit criteria:
 - [01_requirements_registry.md](./01_requirements_registry.md)에 `REQ-*` 정의/수정 반영
 - 각 `REQ-*`가 최소 1개 `TASK-*`, 1개 `TEST-*`와 연결 가능 상태
 - 시간/정책 수치는 원장 단일 소스로 확정(`REQ-OPS-001`,`REQ-OPS-002`)
 Control checks:
 - `python3 scripts/validate_ouroboros_docs.py` 통과
 - Main Agent 승인(DCP-02)
 - 산출물: 업데이트된 요구사항 원장
 ### Phase 2: Design and Work-Order Gate
 Entry criteria:
 - 요구사항 원장 갱신 완료
 - 영향 모듈 분석 완료(상태기계, 주문정책, 백테스트, 세션)
 Exit criteria:
 - [10_phase_v2_execution.md](./10_phase_v2_execution.md), [20_phase_v3_execution.md](./20_phase_v3_execution.md), [30_code_level_work_orders.md](./30_code_level_work_orders.md)에 작업 분해 완료
 - 각 작업은 구현 위치/제약/완료 조건을 가짐
 - 위험 작업(Kill Switch, blackout, session transition)은 별도 롤백 절차 포함
 Control checks:
 - TPM이 `REQ -> TASK` 누락 여부 검토
 - Main Agent 승인(DCP-03)
 - 산출물: 승인된 Work Order 세트
 ### Phase 3: Implementation Gate
 Entry criteria:
 - 승인된 `TASK-*`가 브랜치 작업 단위로 분리됨
 - 변경 범위별 테스트 계획이 PR 본문에 링크됨
 Exit criteria:
 - 코드 변경이 `TASK-*`에 대응되어 추적 가능
 - 제약 준수(`src/core/risk_manager.py` 직접 수정 금지 등) 확인
 - 신규 로직마다 최소 1개 테스트 추가 또는 기존 테스트 확장
 Control checks:
 - PR 템플릿 내 `REQ-*`/`TASK-*`/`TEST-*` 매핑 확인
 - 산출물: 리뷰 가능한 PR
 ### Phase 4: Verification and Acceptance Gate
 Entry criteria:
 - 구현 PR ready 상태
 - 테스트 케이스/픽스처 준비 완료
 Exit criteria:
 - [40_acceptance_and_test_plan.md](./40_acceptance_and_test_plan.md)의 해당 `TEST-ACC-*` 전부 통과
 - 회귀 테스트 통과(`pytest -q`)
 - 문서 검증 통과(`python3 scripts/validate_ouroboros_docs.py`)
 Control checks:
 - Verifier가 테스트 증적(로그/리포트/실행 커맨드) 첨부
 - Verifier가 `Coverage Matrix`(`REQ/TASK/TEST` x `PASS/FAIL/NOT_OBSERVED`) 첨부
 - `NOT_OBSERVED` 항목 수가 0인지 확인(0이 아니면 Gate 실패)
 - Runtime Verifier가 스테이징/실운영 모니터링 계획 승인
 - 정적 Verifier 승인 + Runtime Verifier 승인 2개 모두 확인
 - 산출물: 수용 승인 레코드
 ### Phase 5: Release and Post-Release Control
 Entry criteria:
 - Phase 4 승인
 - 운영 체크리스트 준비(세션 전환, 블랙아웃, Kill Switch)
 Exit criteria:
 - 배포 후 초기 관찰 윈도우에서 치명 경보 없음
 - 신규 시나리오/회귀 이슈는 다음 Cycle의 Phase 0 입력으로 환류
 - 요구사항/테스트 문서 버전 동기화 완료
 Control checks:
 - PM/TPM/Dev 3자 종료 확인
 - Runtime Verifier가 운영 모니터링 이슈 상태(신규/진행/해결)를 리포트
 - Main Agent 최종 승인(DCP-04)
 - 산출물: 릴리즈 노트 + 후속 액션 목록
 ## Replan Protocol (Dev -> TPM)
 - 트리거:
  - 구현 불가능(기술적 제약/외부 API 제약)
  - 예상 대비 개발 리소스 과다(공수/인력/의존성 급증)
 - 절차:
  1) Dev Agent가 `REPLAN-REQUEST` 발행(영향 REQ/TASK, 원인, 대안, 추가 공수 포함)
  2) TPM Agent가 1차 심사(범위 축소/단계 분할/요구사항 조정안)
  3) Verifier/PM 의견 수렴 후 Main Agent 승인으로 재계획 확정
 - 규칙:
  - Main Agent 승인 없는 재계획은 실행 금지
  - 재계획 반영 시 문서(`REQ/TASK/TEST`) 동시 갱신 필수
 TPM 티켓 운영 규칙:
 - TPM은 합의된 변경을 이슈로 등록하고 우선순위(`P0/P1/P2`)를 지정한다.
 - PR 본문에는 TPM이 지정한 우선순위와 범위가 그대로 반영되어야 한다.
 - 우선순위 변경은 TPM 제안 + Main Agent 승인으로만 가능하다.
 - PM/TPM/Dev/Reviewer/Verifier/Runtime Verifier는 주요 의사결정 시점마다 PR 코멘트를 남겨 결정 근거를 추적 가능 상태로 유지한다.
 - PM/TPM/Dev/Reviewer/Verifier/Runtime Verifier는 이슈/PR/코멘트 조작 전에 `docs/commands.md`와 `docs/workflow.md`의 Gitea 트러블슈팅 섹션을 선참조해야 한다.
 - 저장소 협업에서 GitHub CLI(`gh`) 사용은 금지하며, Gitea 작업은 `tea`(필요 시 문서화된 API fallback)만 허용한다.
 - 재발 방지/운영 규칙 변경이 합의되면, 기능 구현 이전에 process 티켓을 먼저 생성/머지해야 한다.
 - process 티켓 미반영 상태에서 구현 티켓 진행 시 TPM이 즉시 `BLOCKED` 처리한다.
 티켓 성숙도 단계 (Mandatory):
 - `Implemented`: 코드/문서 변경 완료
 - `Integrated`: 호출 경로/파이프라인 연결 확인
 - `Observed`: 런타임/실행 증적 확보
 - `Accepted`: Verifier + Runtime Verifier 승인 완료
 - 단계는 순차 전진만 허용되며, 단계 점프는 허용되지 않는다.
 브랜치 운영 규칙:
 - TPM은 각 티켓에 대해 `ticket temp branch -> program feature branch` PR 경로를 지정한다.
 - 티켓 머지 대상은 항상 program feature branch이며, `main`은 최종 통합 단계에서만 사용한다.
 ## Runtime Verification Protocol
 - Runtime Verifier는 테스트 통과 이후 실제 동작(스테이징/실운영)을 모니터링한다.
 - 이상 동작/현상 발견 시 즉시 이슈 발행:
  - 제목 규칙: `[RUNTIME-VERIFY][SCN-*] ...`
  - 본문 필수: 재현조건, 관측 로그, 영향 범위, 임시 완화책, 관련 `REQ/TASK/TEST`
 - 이슈 클로즈 규칙:
  - Dev 수정 완료 + Verifier 재검증 통과 + Runtime Verifier 재관측 정상
  - 최종 클로즈 승인자는 Main Agent
 - 개발 완료 필수 절차:
  - 시스템 실제 구동(스테이징/로컬 실운영 모드) 실행
  - 모니터링 체크리스트(핵심 경보/주문 경로/예외 로그) 수행
  - 결과를 티켓/PR 코멘트에 증적으로 첨부하지 않으면 완료로 간주하지 않음
  - 세션별 필수 관측 포인트(`NXT`, `US_PRE`, `US_DAY`, `US_AFTER` 등) 중 미관측 항목은 `NOT_OBSERVED`로 기록
  - `NOT_OBSERVED` 존재 시 승인 금지 + Runtime 이슈 발행
 ## Server Reflection Rule
 - `ticket temp branch -> program feature branch` 머지는 검증 승인 후 자동/수동 진행 가능하다.
 - `program feature branch -> main` 머지는 사용자 명시 승인 시에만 허용한다.
 - Main 병합 시 Main Agent가 승인 근거를 PR 코멘트에 기록한다.
 ## Acceptance Matrix (PM Scenario -> Dev Tasks -> Verifier Checks)
 | PM Scenario | Requirement Coverage | Dev Tasks (Primary) | Verifier Checks (Must Pass) |
 |---|---|---|---|
 | 갭 급락/급등에서 청산 우선 처리 필요 | `REQ-V2-001`,`REQ-V2-002`,`REQ-V2-003` | `TASK-V2-004`,`TASK-CODE-001` | `TEST-ACC-000`,`TEST-ACC-001`,`TEST-ACC-010`,`TEST-CODE-001`,`TEST-CODE-002` |
 | 하드스탑 + BE락 + ATR + 모델보조를 한 엔진으로 통합 | `REQ-V2-004` | `TASK-V2-005`,`TASK-V2-006`,`TASK-CODE-002` | `TEST-ACC-011` |
 | 라벨 누수 없는 학습데이터 생성 | `REQ-V2-005` | `TASK-V2-007`,`TASK-CODE-004` | `TEST-ACC-012`,`TEST-CODE-003` |
 | 검증 프레임워크를 시계열 누수 방지 구조로 강제 | `REQ-V2-006` | `TASK-V2-010`,`TASK-CODE-005` | `TEST-ACC-013`,`TEST-CODE-004` |
 | 과낙관 백테스트 방지(비용/슬리피지/실패 강제) | `REQ-V2-007` | `TASK-V2-012`,`TASK-CODE-006` | `TEST-ACC-014` |
 | 장애 시 Kill Switch 실행 순서 고정 | `REQ-V2-008` | `TASK-V2-013`,`TASK-V2-014`,`TASK-V2-015`,`TASK-CODE-003` | `TEST-ACC-002`,`TEST-ACC-018` |
 | 세션 전환 단위 리스크/로그 추적 일관화 | `REQ-V3-001`,`REQ-V3-002` | `TASK-V3-001`,`TASK-V3-002`,`TASK-V3-003`,`TASK-CODE-007` | `TEST-ACC-015`,`TEST-ACC-016` |
 | 블랙아웃 중 주문 차단 + 복구 후 재검증 실행 | `REQ-V3-003`,`REQ-V3-004` | `TASK-V3-004`,`TASK-V3-005`,`TASK-V3-006`,`TASK-CODE-008` | `TEST-ACC-003`,`TEST-ACC-017`,`TEST-CODE-005` |
 | 저유동 세션 시장가 주문 금지 | `REQ-V3-005` | `TASK-V3-007`,`TASK-V3-008`,`TASK-CODE-009` | `TEST-ACC-004`,`TEST-CODE-006` |
 | 보수적 체결 모델을 백테스트 기본으로 설정 | `REQ-V3-006` | `TASK-V3-010`,`TASK-V3-011`,`TASK-V3-012`,`TASK-CODE-010` | `TEST-ACC-005`,`TEST-CODE-007` |
 | 전략손익/환율손익 분리 + 통화 버퍼 통제 | `REQ-V3-007` | `TASK-V3-013`,`TASK-V3-014`,`TASK-CODE-011` | `TEST-ACC-006`,`TEST-CODE-008` |
 | 오버나잇 규칙과 Kill Switch 충돌 방지 | `REQ-V3-008` | `TASK-V3-015`,`TASK-CODE-012` | `TEST-ACC-018` |
 | 타임존/정책변경/추적성 문서 거버넌스 | `REQ-OPS-001`,`REQ-OPS-002`,`REQ-OPS-003` | `TASK-OPS-001`,`TASK-OPS-002`,`TASK-OPS-003` | `TEST-ACC-007`,`TEST-ACC-008`,`TEST-ACC-009` |
 ## 운영 규율 (TPM Enforcement Rules)
 - 어떤 PM 시나리오도 `REQ-*` 없는 구현 착수 금지.
 - 어떤 `REQ-*`도 `TASK-*`,`TEST-*` 없는 승인 금지.
 - Verifier는 "코드 리뷰 통과"만으로 승인 불가, 반드시 `TEST-ACC-*` 증적 필요.
 - 배포 승인권자는 Phase 4 체크리스트 미충족 시 릴리즈 보류 권한을 행사해야 한다.
--- a/docs/ouroboros/60_repo_enforcement_checklist.md
+++ b/docs/ouroboros/60_repo_enforcement_checklist.md
@@ -0,0 +1,112 @@
 <!--
 Doc-ID: DOC-OPS-002
 Version: 1.0.0
 Status: active
 Owner: tpm
 Updated: 2026-02-27
 -->
 # 저장소 강제 설정 체크리스트
 목표: "엄격 검증 운영"을 문서가 아니라 저장소 설정으로 강제한다.
 ## 1) main 브랜치 보호 (필수)
 적용 항목:
 - direct push 금지
 - force push 금지
 - branch 삭제 금지
 - merge는 PR 경로만 허용
 검증:
 - `main`에 대해 직접 `git push origin main` 시 거부되는지 확인
 ## 2) 필수 상태 체크 (필수)
 필수 CI 항목:
 - `validate_ouroboros_docs` (명령: `python3 scripts/validate_ouroboros_docs.py`)
 - `test` (명령: `pytest -q`)
 설정 기준:
 - 위 2개 체크가 `success` 아니면 머지 금지
 - 체크 스킵/중립 상태 허용 금지
 ## 3) 필수 리뷰어 규칙 (권장 -> 필수)
 역할 기반 승인:
 - Verifier 1명 승인 필수
 - TPM 또는 PM 1명 승인 필수
 - Runtime Verifier 관련 변경(PR 본문에 runtime 영향 있음) 시 Runtime Verifier 승인 필수
 설정 기준:
 - 최소 승인 수: 2
 - 작성자 self-approval 불가
 - 새 커밋 푸시 시 기존 승인 재검토 요구
 ## 4) 워크플로우 게이트
 병합 전 체크리스트:
 - 이슈 연결(`Closes #N`) 존재
 - PR 본문에 `REQ-*`, `TASK-*`, `TEST-*` 매핑 표 존재
 - Main -> Verifier Directive Contract(범위/방법/합격/실패/미관측/증적 형식) 기재
 - process-change-first 대상이면 process 티켓 PR이 선머지됨
 - `src/core/risk_manager.py` 변경 없음
 - 주요 의사결정 체크포인트(DCP-01~04) 중 해당 단계 Main Agent 확인 기록 존재
 - 주요 의사결정(리뷰 지적/수정 합의/검증 승인)에 대한 에이전트 PR 코멘트 존재
 - 티켓 PR의 base가 `main`이 아닌 program feature branch인지 확인
 자동 점검:
 - 문서 검증 스크립트 통과
 - 테스트 통과
 - `python3 scripts/session_handover_check.py --strict` 통과
 - 개발 완료 시 시스템 구동/모니터링 증적 코멘트 존재
 - 이슈/PR 조작 전에 `docs/commands.md` 및 `docs/workflow.md` 트러블슈팅 확인 코멘트 존재
 - `gh` CLI 미사용, `tea` 사용 증적 존재
 - Verifier `Coverage Matrix` 첨부(PASS/FAIL/NOT_OBSERVED)
 - `NOT_OBSERVED` 항목 0 확인(0이 아니면 머지 금지)
 - 티켓 단계 기록(`Implemented` -> `Integrated` -> `Observed` -> `Accepted`) 존재
 - 정적 Verifier 승인 + Runtime Verifier 승인 2개 확인
 ## 5) 감사 추적
 필수 보존 증적:
 - CI 실행 로그 링크
 - 검증 실패/복구 기록
 - 머지 승인 코멘트(Verifier/TPM)
 분기별 점검:
 - 브랜치 보호 규칙 drift 여부
 - 필수 CI 이름 변경/누락 여부
 ## 6) 적용 순서 (운영 절차)
 1. 브랜치 보호 활성화
 2. 필수 CI 체크 연결
 3. 리뷰어 규칙 적용
 4. 샘플 PR로 거부 시나리오 테스트
 5. 정상 머지 시나리오 테스트
 ## 7) 실패 시 조치
 - 브랜치 보호 미적용 발견 시: 즉시 릴리즈 중지
 - 필수 CI 우회 발견 시: 관리자 권한 점검 및 감사 이슈 발행
 - 리뷰 규칙 무효화 발견 시: 규칙 복구 후 재머지 정책 시행
 - Runtime 이상 이슈 미해결 상태에서 클로즈 시도 발견 시: 즉시 이슈 재오픈 + 릴리즈 중지
 ## 8) 재계획(Dev Replan) 운영 규칙
 - Dev가 `REPLAN-REQUEST` 발행 시 TPM 심사 없이는 스코프/일정 변경 금지
 - `REPLAN-REQUEST`는 Main Agent 승인 전 \"제안\" 상태로 유지
 - 승인된 재계획은 `REQ/TASK/TEST` 문서를 동시 갱신해야 유효
 ## 9) 서버 반영 규칙
 - 티켓 PR(`feature/issue-* -> feature/{stream}`)은 검증 승인 후 머지 가능하다.
 - 최종 통합 PR(`feature/{stream} -> main`)은 사용자 명시 승인 전 `tea pulls merge` 실행 금지.
 - Main 병합 시 승인 근거 코멘트 필수.
 ## 10) 최종 main 병합 조건
 - 모든 티켓이 program feature branch로 병합 완료
 - Runtime Verifier의 구동/모니터링 검증 완료
 - 사용자 최종 승인 코멘트 확인 후에만 `feature -> main` PR 머지 허용
--- a/docs/ouroboros/70_main_agent_ideation.md
+++ b/docs/ouroboros/70_main_agent_ideation.md
@@ -0,0 +1,48 @@
 <!--
 Doc-ID: DOC-IDEA-001
 Version: 1.0.0
 Status: active
 Owner: main-agent
 Updated: 2026-02-26
 -->
 # 메인 에이전트 아이디에이션 백로그
 목적:
 - 구현 진행 중 떠오른 신규 구현 아이디어를 계획 반영 전 임시 저장한다.
 - 본 문서는 사용자 검토 후 다음 계획 포함 여부를 결정하기 위한 검토 큐다.
 운영 규칙:
 - 각 아이디어는 `IDEA-*` 식별자를 사용한다.
 - 필수 필드: 배경, 기대효과, 리스크, 후속 티켓 후보.
 - 상태는 `proposed`, `under-review`, `accepted`, `rejected` 중 하나를 사용한다.
 ## 아이디어 목록
 - `IDEA-001` (status: proposed)
  - 제목: Kill-Switch 전역 상태를 프로세스 단일 전역에서 시장/세션 단위 상태로 분리
  - 배경: 현재는 전역 block 플래그 기반이라 시장별 분리 제어가 제한될 수 있음
  - 기대효과: KR/US 병행 운용 시 한 시장 장애가 다른 시장 주문을 불필요하게 막는 리스크 축소
  - 리스크: 상태 동기화 복잡도 증가, 테스트 케이스 확장 필요
  - 후속 티켓 후보: `TKT-P1-KS-SCOPE-SPLIT`
 - `IDEA-002` (status: proposed)
  - 제목: Exit Engine 입력 계약(ATR/peak/model_prob/liquidity) 표준 DTO를 데이터 파이프라인에 고정
  - 배경: 현재 ATR/모델확률 일부가 fallback 기반이라 운영 일관성이 약함
  - 기대효과: 백테스트-실거래 입력 동형성 강화, 회귀 분석 용이
  - 리스크: 기존 스캐너/시나리오 엔진 연동 작업량 증가
  - 후속 티켓 후보: `TKT-P1-EXIT-CONTRACT`
 - `IDEA-003` (status: proposed)
  - 제목: Runtime Verifier 자동 이슈 생성기(로그 패턴 -> 이슈 템플릿 자동화)
  - 배경: 런타임 이상 리포트가 수동 작성 중심이라 누락 가능성 존재
  - 기대효과: 이상 탐지 후 이슈 등록 리드타임 단축, 증적 표준화
  - 리스크: 오탐 이슈 폭증 가능성, 필터링 룰 필요
  - 후속 티켓 후보: `TKT-P1-RUNTIME-AUTO-ISSUE`
 - `IDEA-004` (status: proposed)
  - 제목: PR 코멘트 워크플로우 자동 점검(리뷰어->개발논의->검증승인 누락 차단)
  - 배경: 현재 절차는 강력하지만 수행 확인이 수동
  - 기대효과: 절차 누락 방지, 감사 추적 자동화
  - 리스크: CLI/API 연동 유지보수 비용
  - 후속 티켓 후보: `TKT-P0-WORKFLOW-GUARD`
--- a/docs/ouroboros/README.md
+++ b/docs/ouroboros/README.md
@@ -0,0 +1,40 @@
 <!--
 Doc-ID: DOC-ROOT-001
 Version: 1.0.0
 Status: active
 Owner: strategy
 Updated: 2026-02-26
 -->
 # The Ouroboros 실행 문서 허브
 이 폴더는 `ouroboros_plan_v2.txt`, `ouroboros_plan_v3.txt`를 구현 가능한 작업 지시서 수준으로 분해한 문서 허브다.
 ## 읽기 순서 (Routing)
 1. 검증 체계부터 확정: [00_validation_system.md](./00_validation_system.md)
 2. 단일 진실원장(요구사항): [01_requirements_registry.md](./01_requirements_registry.md)
 3. v2 실행 지시서: [10_phase_v2_execution.md](./10_phase_v2_execution.md)
 4. v3 실행 지시서: [20_phase_v3_execution.md](./20_phase_v3_execution.md)
 5. 코드 레벨 작업 지시: [30_code_level_work_orders.md](./30_code_level_work_orders.md)
 6. 수용 기준/테스트 계획: [40_acceptance_and_test_plan.md](./40_acceptance_and_test_plan.md)
 7. PM 시나리오/이슈 분류: [50_scenario_matrix_and_issue_taxonomy.md](./50_scenario_matrix_and_issue_taxonomy.md)
 8. TPM 제어 프로토콜/수용 매트릭스: [50_tpm_control_protocol.md](./50_tpm_control_protocol.md)
 9. 저장소 강제 설정 체크리스트: [60_repo_enforcement_checklist.md](./60_repo_enforcement_checklist.md)
 10. 메인 에이전트 아이디에이션 백로그: [70_main_agent_ideation.md](./70_main_agent_ideation.md)
 ## 운영 규칙
 - 계획 변경은 반드시 `01_requirements_registry.md`의 ID 정의부터 수정한다.
 - 구현 문서는 원장 ID만 참조하고 자체 숫자/정책을 새로 만들지 않는다.
 - 문서 품질 룰셋(`RULE-DOC-001` `RULE-DOC-002` `RULE-DOC-003` `RULE-DOC-004` `RULE-DOC-005` `RULE-DOC-006`)은 [00_validation_system.md](./00_validation_system.md)를 기준으로 적용한다.
 - 문서 병합 전 아래 검증을 통과해야 한다.
 ```bash
 python3 scripts/validate_ouroboros_docs.py
 ```
 ## 원본 계획 문서
 - [v2](/home/agentson/repos/The-Ouroboros/ouroboros_plan_v2.txt)
 - [v3](/home/agentson/repos/The-Ouroboros/ouroboros_plan_v3.txt)
--- a/docs/requirements-log.md
+++ b/docs/requirements-log.md
@@ -355,3 +355,36 @@ Order result: 모의투자 매수주문이 완료 되었습니다.  ✓
   - `TestOverseasGhostPositionClose` 2개: ghost-close 로그 확인, 일반 오류 무시
 **이슈/PR:** #235, PR #236
 ---
 ## 2026-02-27
 ### v2 백테스트 파이프라인 통합 (#305)
 **배경:**
 - `TripleBarrier`, `WalkForward`, `BacktestCostGuard`는 개별 모듈로 존재했으나,
  하나의 실행 경로로 연결된 파이프라인이 없어 통합 검증이 불가능했다.
 **구현 내용:**
 1. `src/analysis/backtest_pipeline.py`
   - `run_v2_backtest_pipeline()` 추가:
     - `validate_backtest_cost_model()` 선검증(fail-fast)
     - `label_with_triple_barrier()`로 entry 라벨 생성
     - `generate_walk_forward_splits()`로 fold 생성
     - fold별 baseline(`B0`, `B1`, `M1`) score 산출
   - 결과 아티팩트 계약 구조(`BacktestPipelineResult`) 정의
   - leakage 검사 유틸 `fold_has_leakage()` 제공
 2. `tests/test_backtest_pipeline_integration.py` 신규
   - happy path 통합 검증
   - cost guard 실패 fail-fast 검증
   - purge/embargo 기반 누수 방지 검증
   - 동일 입력 재실행 결정성 검증
 **검증:**
 - `pytest -q tests/test_backtest_pipeline_integration.py tests/test_triple_barrier.py tests/test_walk_forward_split.py tests/test_backtest_cost_guard.py tests/test_backtest_execution_model.py`
 - `ruff check src/analysis/backtest_pipeline.py tests/test_backtest_pipeline_integration.py`
 **이슈/PR:** #305
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -181,6 +181,29 @@ pytest -v --cov=src --cov-report=term-missing
 **Note:** `main.py` has lower coverage as it contains the main loop which is tested via integration/manual testing.
 ## Backtest Automation Gate
 백테스트 관련 검증은 `scripts/backtest_gate.sh`와 `.github/workflows/backtest-gate.yml`로 자동 실행된다.
 - PR: 변경 파일 기준 `auto` 모드
 - `feature/**` push: 변경 파일 기준 `auto` 모드
 - Daily schedule: `full` 강제 실행
 - Manual dispatch: `mode`(`auto|smoke|full`) 지정 가능
 실행 기준:
 - `src/analysis/`, `src/strategy/`, `src/strategies/`, `src/main.py`, `src/markets/`, `src/broker/`
 - 백테스트 핵심 테스트 파일 변경
 - `docs/ouroboros/` 변경
 `auto` 모드에서 백테스트 민감 영역 변경이 없으면 게이트는 `skip` 처리되며 실패로 간주하지 않는다.
 로컬 수동 실행:
 ```bash
 bash scripts/backtest_gate.sh
 BACKTEST_MODE=full bash scripts/backtest_gate.sh
 BASE_REF=origin/feature/v3-session-policy-stream BACKTEST_MODE=auto bash scripts/backtest_gate.sh
 ```
 ## Test Configuration
 ### `pyproject.toml`
--- a/docs/workflow.md
+++ b/docs/workflow.md
@@ -5,14 +5,118 @@
 **CRITICAL: All code changes MUST follow this workflow. Direct pushes to `main` are ABSOLUTELY PROHIBITED.**
 1. **Create Gitea Issue First** — All features, bug fixes, and policy changes require a Gitea issue before any code is written
-2. **Create Feature Branch** — Branch from `main` using format `feature/issue-{N}-{short-description}`
+2. **Create Program Feature Branch** — Branch from `main` for the whole development stream
-   - After creating the branch, run `git pull origin main` and rebase to ensure the branch is up to date
+   - Format: `feature/{epic-or-stream-name}`
-3. **Implement Changes** — Write code, tests, and documentation on the feature branch
+3. **Create Ticket Temp Branch** — Branch from the program feature branch per ticket
-4. **Create Pull Request** — Submit PR to `main` branch referencing the issue number
+   - Format: `feature/issue-{N}-{short-description}`
-5. **Review & Merge** — After approval, merge via PR (squash or merge commit)
+4. **Implement Per Ticket** — Write code, tests, and documentation on the ticket temp branch
 5. **Create Pull Request to Program Feature Branch** — `feature/issue-N-* -> feature/{stream}`
 6. **Review/Verify and Merge into Program Feature Branch** — user approval not required
 7. **Final Integration PR to main** — Only after all ticket stages complete and explicit user approval
 **Never commit directly to `main`.** This policy applies to all changes, no exceptions.
 ## Agent Gitea Preflight (Mandatory)
 Gitea 이슈/PR/코멘트 작업 전에 모든 에이전트는 아래를 먼저 확인해야 한다.
 1. `docs/commands.md`의 `tea CLI` 실패 사례/해결 패턴 확인
 2. 본 문서의 `Gitea CLI Formatting Troubleshooting` 확인
 3. 명령 실행 전 `gh`(GitHub CLI) 사용 금지 확인
 강제 규칙:
 - 이 저장소 협업 명령은 `tea`를 기본으로 사용한다.
 - `gh issue`, `gh pr` 등 GitHub CLI 명령은 사용 금지다.
 - `tea` 실패 시 동일 명령 재시도 전에 원인/수정사항을 PR 코멘트에 남긴다.
 - 필요한 경우에만 Gitea API(`localhost:3000`)를 fallback으로 사용한다.
 ## Session Handover Gate (Mandatory)
 새 세션에서 구현/검증을 시작하기 전에 아래를 선행해야 한다.
 1. `docs/workflow.md`, `docs/commands.md`, `docs/agent-constraints.md` 재확인
 2. `workflow/session-handover.md`에 최신 세션 엔트리 추가
 3. `python3 scripts/session_handover_check.py --strict` 통과 확인
 강제 규칙:
 - handover check 실패 상태에서 코드 수정/이슈 상태 전이/PR 생성 금지
 - 최신 handover 엔트리는 현재 작업 브랜치를 명시해야 한다
 - 최신 handover 엔트리는 당일(UTC) 날짜를 포함해야 한다
 ## Branch Strategy (Mandatory)
 - Team operation default branch is the **program feature branch**, not `main`.
 - Ticket-level development happens only on **ticket temp branches** cut from the program feature branch.
 - Ticket PR merges into program feature branch are allowed after verifier approval.
 - Until final user sign-off, `main` merge is prohibited.
 - 각 에이전트는 주요 의사결정(리뷰 지적, 수정 방향, 검증 승인)마다 PR 코멘트를 적극 작성해 의사결정 과정을 남긴다.
 ## Backtest Gate Policy (Mandatory)
 사람 의존도를 줄이기 위해 백테스트 검증은 자동 게이트를 기본으로 한다.
 - 워크플로우: `.github/workflows/backtest-gate.yml`
 - 실행 스크립트: `scripts/backtest_gate.sh`
 - 기본 모드: `auto` (변경 파일 기반 실행/skip 판정)
 - 정기 스케줄: daily `full` 강제 실행
 - 수동 재실행: workflow dispatch + `mode` 지정
 강제 규칙:
 - 백테스트 민감 변경(PR/feature push)에서 게이트 실패 시 머지 금지
 - 스케줄 게이트 실패 시 이슈 등록 후 원인/복구 계획 기록
 - `python` 대신 `python3` 기준으로 실행한다
 ## Gitea CLI Formatting Troubleshooting
 Issue/PR 본문 작성 시 줄바꿈(`\n`)이 문자열 그대로 저장되는 문제가 반복될 수 있다. 원인은 `-d "...\n..."` 형태에서 쉘/CLI가 이스케이프를 실제 개행으로 해석하지 않기 때문이다.
 권장 패턴:
 ```bash
 ISSUE_BODY=$(cat <<'EOF'
 ## Summary
 - 변경 내용 1
 - 변경 내용 2
 ## Why
 - 배경 1
 - 배경 2
 ## Scope
 - 포함 범위
 - 제외 범위
 EOF
 )
 tea issues create \
  -t "docs: 제목" \
  -d "$ISSUE_BODY"
 ```
 PR도 동일하게 적용:
 ```bash
 PR_BODY=$(cat <<'EOF'
 ## Summary
 - ...
 ## Validation
 - python3 scripts/validate_ouroboros_docs.py
 EOF
 )
 tea pr create \
  --base main \
  --head feature/issue-N-something \
  --title "docs: ... (#N)" \
  --description "$PR_BODY"
 ```
 금지 패턴:
 - `-d "line1\nline2"` (웹 UI에 `\n` 문자 그대로 노출될 수 있음)
 - 본문에 백틱/괄호를 인라인로 넣고 적절한 quoting 없이 즉시 실행
 ## Agent Workflow
 **Modern AI development leverages specialized agents for concurrent, efficient task execution.**
@@ -75,6 +179,57 @@ task_tool(
 Use `run_in_background=True` for independent tasks that don't block subsequent work.
 ### Main -> Verifier Directive Contract (Mandatory)
 메인 에이전트가 검증 에이전트에 작업을 위임할 때, 아래 6개를 누락하면 지시가 무효다.
 1. 검증 대상 범위: `REQ-*`, `TASK-*`, 코드/로그 경로
 2. 검증 방법: 실행 커맨드와 관측 포인트(예: 세션별 로그 키워드)
 3. 합격 기준: PASS 조건을 수치/문구로 명시
 4. 실패 기준: FAIL 조건을 수치/문구로 명시
 5. 미관측 기준: `NOT_OBSERVED` 조건과 즉시 에스컬레이션 규칙
 6. 증적 형식: PR 코멘트에 `Coverage Matrix` 표로 제출
 `NOT_OBSERVED` 처리 규칙:
 - 요구사항 항목이 관측되지 않았으면 PASS로 간주 금지
 - `NOT_OBSERVED`는 운영상 `FAIL`과 동일하게 처리
 - `NOT_OBSERVED`가 하나라도 있으면 승인/머지 금지
 ### Process-Change-First Rule (Mandatory)
 재발 방지/운영 규칙 변경이 결정되면, 기능 구현 티켓보다 먼저 서버(feature branch)에 반영해야 한다.
 - 순서: `process ticket merge` -> `implementation ticket start`
 - process ticket 미반영 상태에서 기능 티켓 코딩/머지 금지
 - 세션 전환 시에도 동일 규칙 유지
 ### Implementation Start Gate (Mandatory)
 구현 티켓을 시작하기 전에 아래 3개를 모두 만족해야 한다.
 1. `process ticket merge` 증적 확인 (feature branch 반영 커밋/PR)
 2. `workflow/session-handover.md` 최신 엔트리에 `next_ticket`과 `process_gate_checked` 기록
 3. `python3 scripts/session_handover_check.py --strict` 통과
 강제 규칙:
 - 위 3개 중 하나라도 불충족이면 코드/테스트 수정 금지
 - 서브에이전트 지시도 동일하게 제한한다 (`process merged 확인 전 read-only 탐색만 허용`)
 - 성급 착수 발견 시 구현 작업을 즉시 중단하고 handover/proces gate부터 복구한다
 ### Ticket Maturity Stages (Mandatory)
 모든 티켓은 아래 4단계를 순서대로 통과해야 한다.
 1. `Implemented`: 코드/문서 변경 완료
 2. `Integrated`: 호출 경로/파이프라인 연결 완료
 3. `Observed`: 런타임/실행 증적 확보 완료
 4. `Accepted`: 정적 Verifier + Runtime Verifier 승인 완료
 강제 규칙:
 - 단계 점프 금지 (예: Implemented -> Accepted 금지)
 - `Observed` 전에는 완료 선언 금지
 - `Accepted` 전에는 머지 금지
 ## Code Review Checklist
 **CRITICAL: Every PR review MUST verify plan-implementation consistency.**
@@ -108,3 +263,10 @@ Before approving any PR, the reviewer (human or agent) must check ALL of the fol
 - [ ] PR references the Gitea issue number
 - [ ] Feature branch follows naming convention (`feature/issue-N-description`)
 - [ ] Commit messages are clear and descriptive
 - [ ] 이슈/PR 작업 전에 `docs/commands.md`와 본 문서 트러블슈팅 섹션을 확인했다
 - [ ] `gh` 명령을 사용하지 않고 `tea`(또는 허용된 Gitea API fallback)만 사용했다
 - [ ] Main -> Verifier 지시가 Directive Contract 6개 항목을 모두 포함한다
 - [ ] Verifier 결과에 `Coverage Matrix`(PASS/FAIL/NOT_OBSERVED)가 있고, `NOT_OBSERVED=0`이다
 - [ ] Process-change-first 대상이면 해당 process PR이 먼저 머지되었다
 - [ ] 티켓 단계가 `Implemented -> Integrated -> Observed -> Accepted` 순서로 기록되었다
 - [ ] 정적 Verifier와 Runtime Verifier 승인 코멘트가 모두 존재한다
--- a/ouroboros_plan_v2.txt
+++ b/ouroboros_plan_v2.txt
@@ -0,0 +1,165 @@
 [The Ouroboros] 운영/전략 계획서 v2
 작성일: 2026-02-26
 상태: 코드 구현 전 설계안(전략/검증 중심)
 ==================================================
 0) 목적
 ==================================================
 고정 익절(+3%) 중심 로직에서 벗어나, 다음을 만족하는 실전형 청산 체계로 전환한다.
 - 수익 구간 보호 (손익 역전 방지)
 - 변동성 적응형 청산
 - 예측 모델의 확률 신호를 보조적으로 결합
 - 과적합 방지를 최우선으로 한 검증 프레임워크
 ==================================================
 1) 핵심 설계 원칙
 ==================================================
 1. 예측 성능과 전략 성능을 분리 평가
 - 예측 성능: PR-AUC, Brier, Calibration
 - 전략 성능: Net PnL, Sharpe, MDD, Profit Factor, Turnover
 2. 시계열 검증 규율 강제
 - Walk-forward 분할
 - Purge/Embargo 적용
 - Random split 금지
 3. 실거래 리얼리즘 우선
 - 거래비용/슬리피지/체결실패 반영 없는 백테스트 결과는 채택 금지
 ==================================================
 2) 매도 상태기계 (State Machine)
 ==================================================
 상태:
 - HOLDING
 - BE_LOCK
 - ARMED
 - EXITED
 정의:
 - HOLDING: 일반 보유 상태
 - BE_LOCK: 일정 수익권 진입 시 손절선을 본전(또는 비용 반영 본전)으로 상향
 - ARMED: 추세 추적(피크 추적) 기반 청산 준비 상태
 - EXITED: 청산 완료
 전이 규칙(개념):
 - HOLDING -> BE_LOCK: unrealized_pnl_pct >= be_arm_pct
 - BE_LOCK -> ARMED: unrealized_pnl_pct >= arm_pct
 - ARMED -> EXITED: 아래 조건 중 하나 충족
  1) hard stop 도달
  2) trailing stop 도달 (peak 대비 하락)
  3) 모델 하락확률 + 유동성 약화 조건 충족
 상태 전이 구현 규칙(필수):
 - 매 틱/바 평가 시 "현재 조건이 허용하는 최상위 상태"로 즉시 승격
 - 순차 if-else로 인한 전이 누락 금지 (예: 갭으로 BE_LOCK/ARMED 동시 충족)
 - EXITED 조건은 모든 상태보다 우선 평가
 - 상태 전이 로그에 이전/이후 상태, 전이 사유, 기준 가격/수익률 기록
 ==================================================
 3) 청산 로직 구성 (4중 안전장치)
 ==================================================
 A. Hard Stop
 - 계좌/포지션 보호용 절대 하한
 - 항상 활성화
 B. Dynamic Stop (Break-even Lock)
 - BE_LOCK 진입 시 손절선을 본전 이상으로 상향
 - "수익 포지션이 손실로 반전"되는 구조적 리스크 차단
 C. ATR 기반 Trailing Stop
 - 고정 trail_pct 대신 변동성 적응형 사용
 - 예시: ExitPrice = PeakPrice - (k * ATR)
 D. 모델 확률 신호
 - 하락전환 확률(pred_prob)이 임계값 이상일 때 청산 가중
 - 단독 트리거가 아닌 trailing/리스크 룰 보조 트리거로 사용
 ==================================================
 4) 라벨링 체계 (Triple Barrier)
 ==================================================
 목표:
 고정 H-window 라벨 편향을 줄이고, 금융 시계열의 경로 의존성을 반영한다.
 라벨 정의:
 - Upper barrier (익절)
 - Lower barrier (손절)
 - Time barrier (만기)
 규칙:
 - 세 장벽 중 "먼저 터치한 장벽"으로 라벨 확정
 - 라벨은 entry 시점 이후 데이터만 사용해 생성
 - 피처 생성 구간과 라벨 구간을 엄격 분리해 look-ahead bias 방지
 ==================================================
 5) 검증 프레임워크
 ==================================================
 5.1 분할 방식
 - Fold 단위 Walk-forward
 - Purge/Embargo로 인접 샘플 누수 차단
 5.2 비교군(Baseline) 구조
 - B0: 기존 고정 손절/익절
 - B1: 모델 없는 trailing only
 - M1: trailing + 모델 확률 결합
 5.3 채택 기준
 - M1이 B0/B1 대비 OOS(Out-of-sample)에서 일관된 우위
 - 단일 구간 성과가 아닌 fold 분포 기준으로 판단
 ==================================================
 6) 실행 아키텍처 원칙
 ==================================================
 1. 저지연 실행 경로
 - 실시간 청산 판단은 경량 엔진(룰/GBDT) 담당
 - LLM은 레짐 판단/비중 조절/상위 의사결정 보조
 2. 체결 현실 반영
 - 세션 유동성에 따른 슬리피지 페널티 차등 적용
 - 미체결/재호가/재접수 시나리오를 백테스트에 반영
 ==================================================
 7) 운영 리스크 관리
 ==================================================
 승격 단계:
 - Offline backtest -> Paper shadow -> Small-capital live
 중단(Kill Switch):
 - rolling Sharpe 악화
 - MDD 한도 초과
 - 체결 실패율/슬리피지 급등
 Kill Switch 실행 순서(원자적):
 1) 모든 신규 주문 차단 플래그 ON
 2) 모든 미체결 주문 취소 요청
 3) 취소 결과 재조회(실패 건 재시도)
 4) 포지션 리스크 재계산 후 강제 축소/청산 판단
 5) 상태/로그 스냅샷 저장 및 운영 경보 발송
 원칙:
 - 모델이 실패해도 hard stop 기반 보수 모드로 즉시 디그레이드 가능해야 함
 ==================================================
 8) 고정 파라미터(초기안)
 ==================================================
 (15분봉 단기 스윙 기준 제안)
 - KR: be_arm_pct=1.2, arm_pct=2.8, atr_period=14, atr_multiplier_k=2.2,
      time_barrier_bars=26, p_thresh=0.62
 - US: be_arm_pct=1.0, arm_pct=2.4, atr_period=14, atr_multiplier_k=2.0,
      time_barrier_bars=32, p_thresh=0.60
 민감도 범위(초기 탐색):
 - be_arm_pct: KR 0.9~1.8 / US 0.7~1.5
 - arm_pct: KR 2.2~3.8 / US 1.8~3.2
 - atr_multiplier_k: KR 1.8~2.8 / US 1.6~2.4
 - time_barrier_bars: KR 20~36 / US 24~48
 - p_thresh: 0.55~0.70
 ==================================================
 9) 구현 전 체크리스트
 ==================================================
 - 파라미터 튜닝 시 nested leakage 방지
 - 수수료/세금/슬리피지 전부 반영 여부 확인
 - 세션/타임존/DST 처리 일관성 확인
 - 모델 버전/설정 해시/실험 로그 재현성 확보
 끝.
--- a/ouroboros_plan_v3.txt
+++ b/ouroboros_plan_v3.txt
@@ -0,0 +1,185 @@
 [The Ouroboros] 운영확장 v3
 작성일: 2026-02-26
 상태: v2 확장판 / 야간·프리마켓 포함 글로벌 세션 운영 설계안
 ==================================================
 0) 목적
 ==================================================
 "24시간 무중단 자산 증식" 비전을 위해 거래 세션 범위를 KR 정규장 중심에서
 NXT/미국 확장 세션까지 확대한다. 핵심은 다음 3가지다.
 - 세션 인지형 의사결정
 - 세션별 리스크/비용 차등 적용
 - 시간장벽의 현실적 재정의
 ==================================================
 1) 세션 모델 (Session-aware Engine)
 ==================================================
 KR 세션:
 - NXT_PRE   : 08:00 ~ 08:50 (KST)
 - KRX_REG   : 09:00 ~ 15:30 (KST)
 - NXT_AFTER : 15:30 ~ 20:00 (KST)
 US 세션(KST 관점 운영):
 - US_DAY    : 10:00 ~ 18:00
 - US_PRE    : 18:00 ~ 23:30
 - US_REG    : 23:30 ~ 06:00
 - US_AFTER  : 06:00 ~ 07:00
 원칙:
 - 모든 피처/신호/주문/로그에 session_id를 명시적으로 포함
 - 세션 전환 시 상태 업데이트 및 리스크 파라미터 재로딩
 ==================================================
 2) 캘린더/휴장/DST 고정 소스
 ==================================================
 KR:
 - 기본: pykrx 또는 FinanceDataReader (KRX 기준)
 - 예외: 연휴/임시 휴장/NXT 특이 운영은 KIS 공지 기반 보완
 US:
 - pandas_market_calendars (NYSE 기준)
 - 2026 DST:
  - 시작: 2026-03-08
  - 종료: 2026-11-01
 정합성 규칙:
 - 스케줄 충돌 시 "거래소 캘린더 > 로컬 추정" 우선
 - 시장 상태(open/close/half-day)는 주문 엔진 진입 전 최종 검증
 KIS 점검시간 회피 정책(필수):
 - 브로커 점검/장애 블랙아웃 윈도우는 운영 설정으로 별도 관리
 - 블랙아웃 구간에는 신규 주문 전송 금지, 취소/정정도 정책적으로 제한
 - 신호는 유지하되 주문 의도는 Queue에 적재, 복구 후 유효성 재검증 뒤 실행
 - 복구 직후에는 잔고/미체결/체결내역을 우선 동기화한 뒤 주문 엔진 재가동
 ==================================================
 3) 시간장벽 재정의
 ==================================================
 v2의 time_barrier_bars 고정값을 v3에서 다음으로 확장:
 - max_holding_minutes (시장별 기본 만기)
 - 봉 개수는 세션 길이/간격으로 동적 계산
 기본값:
 - KR: max_holding_minutes = 2160 (약 3거래일, NXT 포함 관점)
 - US: max_holding_minutes = 4320 (약 72시간)
 운영 주의:
 - 고정 "일중 청산"보다 "포지션 유지 시간" 기준 만기 적용
 - 세션 종료 강제청산 규칙과 충돌 시 우선순위 명시 필요
 ==================================================
 4) 세션별 비용/슬리피지 모델 (보수적)
 ==================================================
 KRX_REG:
 - 슬리피지: 2~3틱 (약 0.05%)
 - 수수료+세금: 0.20% ~ 0.23%
 NXT_AFTER:
 - 슬리피지: 5~8틱 (약 0.15%)
 - 수수료+세금: 0.20% ~ 0.23%
 US_REG:
 - 슬리피지: 2~3틱 (약 0.03%)
 - 수수료+기타 비용: 0.07% ~ 0.15%
 US_PRE / US_DAY:
 - 슬리피지: 10틱+ (약 0.3% ~ 0.5%)
 - 수수료+기타 비용: 0.07% ~ 0.15%
 원칙:
 - 백테스트 체결가는 세션별 보수 가정 적용
 - 저유동 세션은 자동 보수 모드(p_thresh 상향, atr_k 상향) 권장
 - 백테스트 체결가 기본은 "불리한 방향 체결" 가정 (단순 close 체결 금지)
 세션별 주문 유형 강제(필수):
 - KRX_REG / US_REG: 지정가 우선, 시장가 제한적 허용
 - NXT_AFTER / US_PRE / US_DAY / US_AFTER: 시장가 금지
 - 저유동 세션은 최우선 지정가 또는 IOC/FOK(가격 보호 한도 포함)만 허용
 - 주문 실패 시 재호가 간격/횟수 상한을 두고, 초과 시 주문 철회
 ==================================================
 5) 포지션/잔고 통합 규칙 (KIS 특성 반영)
 ==================================================
 문제:
 - KRX/NXT 잔고 조회가 venue 단위로 분리되거나 반영 지연 가능
 규칙:
 - 종목 식별은 동일 종목코드(또는 ISIN) 기준 통합 포지션으로 관리
 - 다만 주문 가능 수량은 venue별 API 응답을 최종 기준으로 사용
 - 매도 가능 수량 검증은 주문 직전 재조회로 확정
 ==================================================
 6) 마감 강제청산/오버나잇 예외 규칙
 ==================================================
 기본 원칙:
 - 모든 포지션에 대해 세션 종료 10분 전 REDUCE_ALL 검토
 오버나잇 예외 허용 (모두 충족 시):
 1) ARMED 상태 (예: +2.8% 이상)
 2) 모델 하락확률 < 0.30
 3) 포트폴리오 현금 비중 >= 50%
 갭 리스크 통제:
 - 다음 개장 시 hard stop를 시가 기준으로 재산정
 - 조건 위반 시 즉시 청산 우선
 Kill Switch 연동:
 - MDD/실패율 임계치 초과 시 "미체결 전량 취소 -> 신규 주문 차단 -> 리스크 축소" 순서 강제
 ==================================================
 7) 데이터 저장/용량 정책
 ==================================================
 핵심 테이블(계획):
 - feature_snapshots
 - position_states
 - model_predictions
 저장 규칙:
 - feature_hash 기반 중복 제거
 - 가격 변화가 작아도 session_id 변경 시 강제 스냅샷
 - 월 단위 DB 로테이션 권장 (예: trading_YYYY_MM.db)
 ==================================================
 8) 환율/정산 리스크 정책 (US 필수)
 ==================================================
 원칙:
 - USD 노출은 전략 손익과 별도로 환율 손익을 분리 추적
 - 원화 주문 서비스 사용 시 가환율 체결/익일 정산 리스크를 예수금 규칙에 반영
 운영 규칙:
 - 환전 시점 정책(사전 환전/수시 환전)을 고정하고 로그에 기록
 - 최소 USD 버퍼와 KRW 버퍼를 각각 설정해 주문 가능금 부족 리스크 완화
 - 환율 급변 구간에는 포지션 한도 축소 또는 신규 진입 제한
 ==================================================
 9) v3 실험 매트릭스 (우선 3선)
 ==================================================
 EXP-KR-01:
 - 시장: KR
 - 포커스: NXT 야간 특화
 - 제안: time barrier 확장(예: 48 bars 상당), p_thresh 상향(0.65)
 EXP-US-01:
 - 시장: US
 - 포커스: 21h 준연속 운용
 - 제안: time barrier 확장(예: 80 bars 상당), atr_k 상향(2.5)
 EXP-HYB-01:
 - 시장: Global
 - 포커스: KR 낮 + US 밤 연계
 - 제안: 레짐 기반 자산배분 자동조절
 ==================================================
 10) 코드 착수 전 최종 확정 체크
 ==================================================
 1) 세션별 공식 캘린더 소스/우선순위
 2) 세션별 슬리피지/비용 테이블 수치
 3) 시장별 max_holding_minutes
 4) 마감 강제청산 예외 조건 임계값
 5) 블랙아웃(점검/장애) 시간대와 주문 큐 처리 규칙
 6) 세션별 허용 주문 유형(시장가 허용 범위 포함)
 7) 환전/정산 정책 및 통화 버퍼 임계값
 모든 항목 확정 후 Step 1 구현(코드)로 이동.
 끝.
--- a/scripts/backtest_gate.sh
+++ b/scripts/backtest_gate.sh
@@ -0,0 +1,106 @@
 #!/usr/bin/env bash
 # Backtest gate for PR/push/scheduled verification.
 set -euo pipefail
 MODE="${BACKTEST_MODE:-auto}"          # auto | smoke | full
 BASE_REF="${BASE_REF:-origin/main}"    # used when MODE=auto
 FORCE_FULL="${FORCE_FULL_BACKTEST:-false}"
 LOG_DIR="${LOG_DIR:-data/backtest-gate}"
 mkdir -p "$LOG_DIR"
 STAMP="$(date -u +%Y%m%d_%H%M%S)"
 LOG_FILE="$LOG_DIR/backtest_gate_${STAMP}.log"
 log() {
  printf '%s %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$1" | tee -a "$LOG_FILE"
 }
 run_cmd() {
  log "[RUN] $*"
  "$@" 2>&1 | tee -a "$LOG_FILE"
 }
 resolve_mode_from_changes() {
  if [ "$FORCE_FULL" = "true" ]; then
    echo "full"
    return
  fi
  if ! git rev-parse --verify "$BASE_REF" >/dev/null 2>&1; then
    log "[WARN] BASE_REF not found: $BASE_REF; fallback to full"
    echo "full"
    return
  fi
  changed_files="$(git diff --name-only "$BASE_REF"...HEAD || true)"
  if [ -z "$changed_files" ]; then
    log "[INFO] no changed files between $BASE_REF...HEAD; skip backtest gate"
    echo "skip"
    return
  fi
  log "[INFO] changed files from $BASE_REF...HEAD:"
  while IFS= read -r line; do
    [ -n "$line" ] && log "  - $line"
  done <<< "$changed_files"
  # Backtest-sensitive areas: analysis/strategy/runtime execution semantics.
  if printf '%s\n' "$changed_files" | rg -q \
    '^(src/analysis/|src/strategy/|src/strategies/|src/main.py|src/markets/|src/broker/|tests/test_backtest_|tests/test_triple_barrier.py|tests/test_walk_forward_split.py|tests/test_main.py|docs/ouroboros/)'
  then
    echo "full"
  else
    echo "skip"
  fi
 }
 SMOKE_TESTS=(
  tests/test_backtest_pipeline_integration.py
  tests/test_triple_barrier.py
  tests/test_walk_forward_split.py
  tests/test_backtest_cost_guard.py
  tests/test_backtest_execution_model.py
 )
 FULL_TESTS=(
  tests/test_backtest_pipeline_integration.py
  tests/test_triple_barrier.py
  tests/test_walk_forward_split.py
  tests/test_backtest_cost_guard.py
  tests/test_backtest_execution_model.py
  tests/test_main.py
 )
 main() {
  log "[INFO] backtest gate started mode=$MODE base_ref=$BASE_REF force_full=$FORCE_FULL"
  selected_mode="$MODE"
  if [ "$MODE" = "auto" ]; then
    selected_mode="$(resolve_mode_from_changes)"
  fi
  case "$selected_mode" in
    skip)
      log "[PASS] backtest gate skipped (no backtest-sensitive changes)"
      exit 0
      ;;
    smoke)
      run_cmd python3 -m pytest -q "${SMOKE_TESTS[@]}"
      log "[PASS] smoke backtest gate passed"
      ;;
    full)
      run_cmd python3 -m pytest -q "${SMOKE_TESTS[@]}"
      # Runtime semantics tied to v2 staged-exit must remain covered in full gate.
      run_cmd python3 -m pytest -q tests/test_main.py -k \
        "staged_exit_override or runtime_exit_cache_cleared or run_daily_session_applies_staged_exit_override_on_hold"
      log "[PASS] full backtest gate passed"
      ;;
    *)
      log "[FAIL] invalid BACKTEST_MODE=$selected_mode (expected auto|smoke|full)"
      exit 2
      ;;
  esac
 }
 main "$@"
--- a/scripts/runtime_verify_monitor.sh
+++ b/scripts/runtime_verify_monitor.sh
@@ -0,0 +1,78 @@
 #!/usr/bin/env bash
 # Runtime verification monitor with NOT_OBSERVED detection.
 set -euo pipefail
 ROOT_DIR="${ROOT_DIR:-/home/agentson/repos/The-Ouroboros}"
 LOG_DIR="${LOG_DIR:-$ROOT_DIR/data/overnight}"
 INTERVAL_SEC="${INTERVAL_SEC:-60}"
 MAX_HOURS="${MAX_HOURS:-24}"
 cd "$ROOT_DIR"
 OUT_LOG="$LOG_DIR/runtime_verify_$(date +%Y%m%d_%H%M%S).log"
 END_TS=$(( $(date +%s) + MAX_HOURS*3600 ))
 log() {
  printf '%s %s\n' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" "$1" | tee -a "$OUT_LOG" >/dev/null
 }
 check_signal() {
  local name="$1"
  local pattern="$2"
  local run_log="$3"
  if rg -q "$pattern" "$run_log"; then
    log "[COVERAGE] ${name}=PASS pattern=${pattern}"
    return 0
  fi
  log "[COVERAGE] ${name}=NOT_OBSERVED pattern=${pattern}"
  return 1
 }
 log "[INFO] runtime verify monitor started interval=${INTERVAL_SEC}s max_hours=${MAX_HOURS}"
 while true; do
  now=$(date +%s)
  if [ "$now" -ge "$END_TS" ]; then
    log "[INFO] monitor completed (time window reached)"
    exit 0
  fi
  latest_run="$(ls -t "$LOG_DIR"/run_*.log 2>/dev/null | head -n1 || true)"
  if [ -z "$latest_run" ]; then
    log "[ANOMALY] no run log found"
    sleep "$INTERVAL_SEC"
    continue
  fi
  # Basic liveness hints.
  app_pid="$(cat "$LOG_DIR/app.pid" 2>/dev/null || true)"
  wd_pid="$(cat "$LOG_DIR/watchdog.pid" 2>/dev/null || true)"
  app_alive=0
  wd_alive=0
  port_alive=0
  [ -n "$app_pid" ] && kill -0 "$app_pid" 2>/dev/null && app_alive=1
  [ -n "$wd_pid" ] && kill -0 "$wd_pid" 2>/dev/null && wd_alive=1
  ss -ltnp 2>/dev/null | rg -q ':8080' && port_alive=1
  log "[HEARTBEAT] run_log=$latest_run app_alive=$app_alive watchdog_alive=$wd_alive port8080=$port_alive"
  # Coverage matrix rows (session paths and policy gate evidence).
  not_observed=0
  check_signal "LIVE_MODE" "Mode: live" "$latest_run" || not_observed=$((not_observed+1))
  check_signal "KR_LOOP" "Processing market: Korea Exchange" "$latest_run" || not_observed=$((not_observed+1))
  check_signal "NXT_PATH" "NXT_PRE|NXT_AFTER|session=NXT_" "$latest_run" || not_observed=$((not_observed+1))
  check_signal "US_PRE_PATH" "US_PRE|session=US_PRE" "$latest_run" || not_observed=$((not_observed+1))
  check_signal "US_DAY_PATH" "US_DAY|session=US_DAY|Processing market: .*NASDAQ|Processing market: .*NYSE|Processing market: .*AMEX" "$latest_run" || not_observed=$((not_observed+1))
  check_signal "US_AFTER_PATH" "US_AFTER|session=US_AFTER" "$latest_run" || not_observed=$((not_observed+1))
  check_signal "ORDER_POLICY_SESSION" "Order policy rejected .*\\[session=" "$latest_run" || not_observed=$((not_observed+1))
  if [ "$not_observed" -gt 0 ]; then
    log "[ANOMALY] coverage_not_observed=$not_observed (treat as FAIL)"
  else
    log "[OK] coverage complete (NOT_OBSERVED=0)"
  fi
  sleep "$INTERVAL_SEC"
 done
--- a/scripts/session_handover_check.py
+++ b/scripts/session_handover_check.py
@@ -0,0 +1,146 @@
 #!/usr/bin/env python3
 """Session handover preflight gate.
 This script enforces a minimal handover record per working branch so that
 new sessions cannot start implementation without reading the required docs
 and recording current intent.
 """
 from __future__ import annotations
 import argparse
 import subprocess
 import sys
 from datetime import UTC, datetime
 from pathlib import Path
 REQUIRED_DOCS = (
    Path("docs/workflow.md"),
    Path("docs/commands.md"),
    Path("docs/agent-constraints.md"),
 )
 HANDOVER_LOG = Path("workflow/session-handover.md")
 def _run_git(*args: str) -> str:
    try:
        return (
            subprocess.check_output(["git", *args], stderr=subprocess.DEVNULL)
            .decode("utf-8")
            .strip()
        )
    except Exception:
        return ""
 def _current_branch() -> str:
    branch = _run_git("branch", "--show-current")
    if branch:
        return branch
    return _run_git("rev-parse", "--abbrev-ref", "HEAD")
 def _latest_entry(text: str) -> str:
    chunks = text.split("\n### ")
    if not chunks:
        return ""
    if chunks[0].startswith("### "):
        chunks[0] = chunks[0][4:]
    latest = chunks[-1].strip()
    if not latest:
        return ""
    if not latest.startswith("### "):
        latest = f"### {latest}"
    return latest
 def _check_required_files(errors: list[str]) -> None:
    for path in REQUIRED_DOCS:
        if not path.exists():
            errors.append(f"missing required document: {path}")
    if not HANDOVER_LOG.exists():
        errors.append(f"missing handover log: {HANDOVER_LOG}")
 def _check_handover_entry(
    *,
    branch: str,
    strict: bool,
    errors: list[str],
 ) -> None:
    if not HANDOVER_LOG.exists():
        return
    text = HANDOVER_LOG.read_text(encoding="utf-8")
    latest = _latest_entry(text)
    if not latest:
        errors.append("handover log has no session entry")
        return
    required_tokens = (
        "- branch:",
        "- docs_checked:",
        "- open_issues_reviewed:",
        "- next_ticket:",
        "- process_gate_checked:",
    )
    for token in required_tokens:
        if token not in latest:
            errors.append(f"latest handover entry missing token: {token}")
    if strict:
        today_utc = datetime.now(UTC).date().isoformat()
        if today_utc not in latest:
            errors.append(
                f"latest handover entry must contain today's UTC date ({today_utc})"
            )
        branch_token = f"- branch: {branch}"
        if branch_token not in latest:
            errors.append(
                "latest handover entry must target current branch "
                f"({branch_token})"
            )
        if "- next_ticket: #TBD" in latest:
            errors.append("latest handover entry must not use placeholder next_ticket (#TBD)")
        if "merged_to_feature_branch=no" in latest:
            errors.append(
                "process gate indicates not merged; implementation must stay blocked "
                "(merged_to_feature_branch=no)"
            )
 def main() -> int:
    parser = argparse.ArgumentParser(
        description="Validate session handover gate requirements."
    )
    parser.add_argument(
        "--strict",
        action="store_true",
        help="Enforce today-date and current-branch match on latest handover entry.",
    )
    args = parser.parse_args()
    errors: list[str] = []
    _check_required_files(errors)
    branch = _current_branch()
    if not branch:
        errors.append("cannot resolve current git branch")
    elif branch in {"main", "master"}:
        errors.append(f"working branch must not be {branch}")
    _check_handover_entry(branch=branch, strict=args.strict, errors=errors)
    if errors:
        print("[FAIL] session handover check failed")
        for err in errors:
            print(f"- {err}")
        return 1
    print("[OK] session handover check passed")
    print(f"[OK] branch={branch}")
    print(f"[OK] handover_log={HANDOVER_LOG}")
    return 0
 if __name__ == "__main__":
    sys.exit(main())
--- a/scripts/validate_governance_assets.py
+++ b/scripts/validate_governance_assets.py
@@ -0,0 +1,95 @@
 #!/usr/bin/env python3
 """Validate persistent governance assets for agent workflow safety."""
 from __future__ import annotations
 import sys
 from pathlib import Path
 def must_contain(path: Path, required: list[str], errors: list[str]) -> None:
    if not path.exists():
        errors.append(f"missing file: {path}")
        return
    text = path.read_text(encoding="utf-8")
    for token in required:
        if token not in text:
            errors.append(f"{path}: missing required token -> {token}")
 def main() -> int:
    errors: list[str] = []
    pr_template = Path(".gitea/PULL_REQUEST_TEMPLATE.md")
    issue_template = Path(".gitea/ISSUE_TEMPLATE/runtime_verification.md")
    workflow_doc = Path("docs/workflow.md")
    commands_doc = Path("docs/commands.md")
    handover_script = Path("scripts/session_handover_check.py")
    handover_log = Path("workflow/session-handover.md")
    must_contain(
        pr_template,
        [
            "Closes #N",
            "Main -> Verifier Directive Contract",
            "Coverage Matrix",
            "NOT_OBSERVED",
            "tea",
            "gh",
            "Session Handover Gate",
            "session_handover_check.py --strict",
        ],
        errors,
    )
    must_contain(
        issue_template,
        [
            "[RUNTIME-VERIFY][SCN-XXX]",
            "Requirement Mapping",
            "Close Criteria",
            "NOT_OBSERVED = 0",
        ],
        errors,
    )
    must_contain(
        workflow_doc,
        [
            "Session Handover Gate (Mandatory)",
            "session_handover_check.py --strict",
        ],
        errors,
    )
    must_contain(
        commands_doc,
        [
            "Session Handover Preflight (Mandatory)",
            "session_handover_check.py --strict",
        ],
        errors,
    )
    must_contain(
        handover_log,
        [
            "Session Handover Log",
            "- branch:",
            "- docs_checked:",
            "- open_issues_reviewed:",
            "- next_ticket:",
        ],
        errors,
    )
    if not handover_script.exists():
        errors.append(f"missing file: {handover_script}")
    if errors:
        print("[FAIL] governance asset validation failed")
        for err in errors:
            print(f"- {err}")
        return 1
    print("[OK] governance assets validated")
    return 0
 if __name__ == "__main__":
    sys.exit(main())
--- a/scripts/validate_ouroboros_docs.py
+++ b/scripts/validate_ouroboros_docs.py
@@ -0,0 +1,140 @@
 #!/usr/bin/env python3
 """Validate Ouroboros planning docs for metadata, links, and ID consistency."""
 from __future__ import annotations
 import re
 import sys
 from pathlib import Path
 DOC_DIR = Path("docs/ouroboros")
 META_PATTERN = re.compile(
    r"<!--\n"
    r"Doc-ID: (?P<doc_id>[^\n]+)\n"
    r"Version: (?P<version>[^\n]+)\n"
    r"Status: (?P<status>[^\n]+)\n"
    r"Owner: (?P<owner>[^\n]+)\n"
    r"Updated: (?P<updated>\d{4}-\d{2}-\d{2})\n"
    r"-->",
    re.MULTILINE,
 )
 ID_PATTERN = re.compile(r"\b(?:REQ|RULE|TASK|TEST|DOC)-[A-Z0-9-]+-\d{3}\b")
 DEF_PATTERN = re.compile(r"^-\s+`(?P<id>(?:REQ|RULE|TASK|TEST|DOC)-[A-Z0-9-]+-\d{3})`", re.MULTILINE)
 LINK_PATTERN = re.compile(r"\[[^\]]+\]\((?P<link>[^)]+)\)")
 LINE_DEF_PATTERN = re.compile(r"^-\s+`(?P<id>(?:REQ|RULE|TASK|TEST|DOC)-[A-Z0-9-]+-\d{3})`.*$", re.MULTILINE)
 def iter_docs() -> list[Path]:
    return sorted([p for p in DOC_DIR.glob("*.md") if p.is_file()])
 def validate_metadata(path: Path, text: str, errors: list[str], doc_ids: dict[str, Path]) -> None:
    match = META_PATTERN.search(text)
    if not match:
        errors.append(f"{path}: missing or malformed metadata block")
        return
    doc_id = match.group("doc_id").strip()
    if doc_id in doc_ids:
        errors.append(f"{path}: duplicate Doc-ID {doc_id} (already in {doc_ids[doc_id]})")
    else:
        doc_ids[doc_id] = path
 def validate_links(path: Path, text: str, errors: list[str]) -> None:
    for m in LINK_PATTERN.finditer(text):
        link = m.group("link").strip()
        if not link or link.startswith("http") or link.startswith("#"):
            continue
        if link.startswith("/"):
            target = Path(link)
        else:
            target = (path.parent / link).resolve()
        if not target.exists():
            errors.append(f"{path}: broken link -> {link}")
 def collect_ids(path: Path, text: str, defs: dict[str, Path], refs: dict[str, set[Path]]) -> None:
    for m in DEF_PATTERN.finditer(text):
        defs[m.group("id")] = path
    for m in ID_PATTERN.finditer(text):
        idv = m.group(0)
        refs.setdefault(idv, set()).add(path)
 def collect_req_traceability(text: str, req_to_task: dict[str, set[str]], req_to_test: dict[str, set[str]]) -> None:
    for m in LINE_DEF_PATTERN.finditer(text):
        line = m.group(0)
        item_id = m.group("id")
        req_ids = [rid for rid in ID_PATTERN.findall(line) if rid.startswith("REQ-")]
        if item_id.startswith("TASK-"):
            for req_id in req_ids:
                req_to_task.setdefault(req_id, set()).add(item_id)
        if item_id.startswith("TEST-"):
            for req_id in req_ids:
                req_to_test.setdefault(req_id, set()).add(item_id)
 def main() -> int:
    if not DOC_DIR.exists():
        print(f"ERROR: missing directory {DOC_DIR}")
        return 1
    docs = iter_docs()
    if not docs:
        print(f"ERROR: no markdown docs found in {DOC_DIR}")
        return 1
    errors: list[str] = []
    doc_ids: dict[str, Path] = {}
    defs: dict[str, Path] = {}
    refs: dict[str, set[Path]] = {}
    req_to_task: dict[str, set[str]] = {}
    req_to_test: dict[str, set[str]] = {}
    for path in docs:
        text = path.read_text(encoding="utf-8")
        validate_metadata(path, text, errors, doc_ids)
        validate_links(path, text, errors)
        collect_ids(path, text, defs, refs)
        collect_req_traceability(text, req_to_task, req_to_test)
    for idv, where_used in sorted(refs.items()):
        if idv.startswith("DOC-"):
            continue
        if idv not in defs:
            files = ", ".join(str(p) for p in sorted(where_used))
            errors.append(f"undefined ID {idv}, used in: {files}")
    for idv in sorted(defs):
        if not idv.startswith("REQ-"):
            continue
        if idv not in req_to_task:
            errors.append(f"REQ without TASK mapping: {idv}")
        if idv not in req_to_test:
            errors.append(f"REQ without TEST mapping: {idv}")
    warnings: list[str] = []
    for idv, where_def in sorted(defs.items()):
        if len(refs.get(idv, set())) <= 1 and (idv.startswith("REQ-") or idv.startswith("RULE-")):
            warnings.append(f"orphan ID {idv} defined in {where_def} (not referenced elsewhere)")
    if errors:
        print("[FAIL] Ouroboros docs validation failed")
        for err in errors:
            print(f"- {err}")
        return 1
    print(f"[OK] validated {len(docs)} docs in {DOC_DIR}")
    print(f"[OK] unique Doc-ID: {len(doc_ids)}")
    print(f"[OK] definitions: {len(defs)}, references: {len(refs)}")
    print(f"[OK] req->task mappings: {len(req_to_task)}")
    print(f"[OK] req->test mappings: {len(req_to_test)}")
    if warnings:
        print(f"[WARN] orphan IDs: {len(warnings)}")
        for w in warnings:
            print(f"- {w}")
    return 0
 if __name__ == "__main__":
    sys.exit(main())
--- a/src/analysis/backtest_cost_guard.py
+++ b/src/analysis/backtest_cost_guard.py
@@ -0,0 +1,52 @@
 """Backtest cost/slippage/failure validation guard."""
 from __future__ import annotations
 from dataclasses import dataclass
 import math
@dataclass(frozen=True)
 class BacktestCostModel:
    commission_bps: float | None = None
    slippage_bps_by_session: dict[str, float] | None = None
    failure_rate_by_session: dict[str, float] | None = None
    unfavorable_fill_required: bool = True
 def validate_backtest_cost_model(
    *,
    model: BacktestCostModel,
    required_sessions: list[str],
 ) -> None:
    """Raise ValueError when required cost assumptions are missing/invalid."""
    if (
        model.commission_bps is None
        or not math.isfinite(model.commission_bps)
        or model.commission_bps < 0
    ):
        raise ValueError("commission_bps must be provided and >= 0")
    if not model.unfavorable_fill_required:
        raise ValueError("unfavorable_fill_required must be True")
    slippage = model.slippage_bps_by_session or {}
    failure = model.failure_rate_by_session or {}
    missing_slippage = [s for s in required_sessions if s not in slippage]
    if missing_slippage:
        raise ValueError(
            f"missing slippage_bps_by_session for sessions: {', '.join(missing_slippage)}"
        )
    missing_failure = [s for s in required_sessions if s not in failure]
    if missing_failure:
        raise ValueError(
            f"missing failure_rate_by_session for sessions: {', '.join(missing_failure)}"
        )
    for sess, bps in slippage.items():
        if not math.isfinite(bps) or bps < 0:
            raise ValueError(f"slippage bps must be >= 0 for session={sess}")
    for sess, rate in failure.items():
        if not math.isfinite(rate) or rate < 0 or rate > 1:
            raise ValueError(f"failure rate must be within [0,1] for session={sess}")
--- a/src/analysis/backtest_execution_model.py
+++ b/src/analysis/backtest_execution_model.py
@@ -0,0 +1,103 @@
 """Conservative backtest execution model."""
 from __future__ import annotations
 from dataclasses import dataclass
 import math
 from random import Random
 from typing import Literal
 OrderSide = Literal["BUY", "SELL"]
@dataclass(frozen=True)
 class ExecutionRequest:
    side: OrderSide
    session_id: str
    qty: int
    reference_price: float
@dataclass(frozen=True)
 class ExecutionAssumptions:
    slippage_bps_by_session: dict[str, float]
    failure_rate_by_session: dict[str, float]
    partial_fill_rate_by_session: dict[str, float]
    partial_fill_min_ratio: float = 0.3
    partial_fill_max_ratio: float = 0.8
    seed: int = 0
@dataclass(frozen=True)
 class ExecutionResult:
    status: Literal["FILLED", "PARTIAL", "REJECTED"]
    filled_qty: int
    avg_price: float
    slippage_bps: float
    reason: str
 class BacktestExecutionModel:
    """Execution simulator with conservative unfavorable fill assumptions."""
    def __init__(self, assumptions: ExecutionAssumptions) -> None:
        self.assumptions = assumptions
        self._rng = Random(assumptions.seed)
        if assumptions.partial_fill_min_ratio <= 0 or assumptions.partial_fill_max_ratio > 1:
            raise ValueError("partial fill ratios must be within (0,1]")
        if assumptions.partial_fill_min_ratio > assumptions.partial_fill_max_ratio:
            raise ValueError("partial_fill_min_ratio must be <= partial_fill_max_ratio")
        for sess, bps in assumptions.slippage_bps_by_session.items():
            if not math.isfinite(bps) or bps < 0:
                raise ValueError(f"slippage_bps must be finite and >= 0 for session={sess}")
        for sess, rate in assumptions.failure_rate_by_session.items():
            if not math.isfinite(rate) or rate < 0 or rate > 1:
                raise ValueError(f"failure_rate must be in [0,1] for session={sess}")
        for sess, rate in assumptions.partial_fill_rate_by_session.items():
            if not math.isfinite(rate) or rate < 0 or rate > 1:
                raise ValueError(f"partial_fill_rate must be in [0,1] for session={sess}")
    def simulate(self, request: ExecutionRequest) -> ExecutionResult:
        if request.qty <= 0:
            raise ValueError("qty must be positive")
        if request.reference_price <= 0:
            raise ValueError("reference_price must be positive")
        slippage_bps = self.assumptions.slippage_bps_by_session.get(request.session_id, 0.0)
        failure_rate = self.assumptions.failure_rate_by_session.get(request.session_id, 0.0)
        partial_rate = self.assumptions.partial_fill_rate_by_session.get(request.session_id, 0.0)
        if self._rng.random() < failure_rate:
            return ExecutionResult(
                status="REJECTED",
                filled_qty=0,
                avg_price=0.0,
                slippage_bps=slippage_bps,
                reason="execution_failure",
            )
        slip_mult = 1.0 + (slippage_bps / 10000.0 if request.side == "BUY" else -slippage_bps / 10000.0)
        exec_price = request.reference_price * slip_mult
        if self._rng.random() < partial_rate:
            ratio = self._rng.uniform(
                self.assumptions.partial_fill_min_ratio,
                self.assumptions.partial_fill_max_ratio,
            )
            filled = max(1, min(request.qty - 1, int(request.qty * ratio)))
            return ExecutionResult(
                status="PARTIAL",
                filled_qty=filled,
                avg_price=exec_price,
                slippage_bps=slippage_bps,
                reason="partial_fill",
            )
        return ExecutionResult(
            status="FILLED",
            filled_qty=request.qty,
            avg_price=exec_price,
            slippage_bps=slippage_bps,
            reason="filled",
        )
--- a/src/analysis/backtest_pipeline.py
+++ b/src/analysis/backtest_pipeline.py
@@ -0,0 +1,187 @@
 """Integrated v2 backtest pipeline.
 Wires TripleBarrier labeling + WalkForward split + CostGuard validation
 into a single deterministic orchestration path.
 """
 from __future__ import annotations
 from collections.abc import Sequence
 from dataclasses import dataclass
 from statistics import mean
 from typing import Literal
 from src.analysis.backtest_cost_guard import BacktestCostModel, validate_backtest_cost_model
 from src.analysis.triple_barrier import TripleBarrierSpec, label_with_triple_barrier
 from src.analysis.walk_forward_split import WalkForwardFold, generate_walk_forward_splits
@dataclass(frozen=True)
 class BacktestBar:
    high: float
    low: float
    close: float
    session_id: str
@dataclass(frozen=True)
 class WalkForwardConfig:
    train_size: int
    test_size: int
    step_size: int | None = None
    purge_size: int = 0
    embargo_size: int = 0
    min_train_size: int = 1
@dataclass(frozen=True)
 class BaselineScore:
    name: Literal["B0", "B1", "M1"]
    accuracy: float
@dataclass(frozen=True)
 class BacktestFoldResult:
    fold_index: int
    train_indices: list[int]
    test_indices: list[int]
    train_label_distribution: dict[int, int]
    test_label_distribution: dict[int, int]
    baseline_scores: list[BaselineScore]
@dataclass(frozen=True)
 class BacktestPipelineResult:
    run_id: str
    n_bars: int
    n_entries: int
    required_sessions: list[str]
    label_distribution: dict[int, int]
    folds: list[BacktestFoldResult]
 def run_v2_backtest_pipeline(
    *,
    bars: Sequence[BacktestBar],
    entry_indices: Sequence[int],
    side: int,
    triple_barrier_spec: TripleBarrierSpec,
    walk_forward: WalkForwardConfig,
    cost_model: BacktestCostModel,
    required_sessions: list[str] | None = None,
 ) -> BacktestPipelineResult:
    """Run v2 integrated pipeline (cost guard -> labels -> walk-forward baselines)."""
    if not bars:
        raise ValueError("bars must not be empty")
    if not entry_indices:
        raise ValueError("entry_indices must not be empty")
    resolved_sessions = (
        sorted(set(required_sessions))
        if required_sessions is not None
        else sorted({bar.session_id for bar in bars})
    )
    validate_backtest_cost_model(model=cost_model, required_sessions=resolved_sessions)
    highs = [float(bar.high) for bar in bars]
    lows = [float(bar.low) for bar in bars]
    closes = [float(bar.close) for bar in bars]
    normalized_entries = sorted(set(int(i) for i in entry_indices))
    if normalized_entries[0] < 0 or normalized_entries[-1] >= len(bars):
        raise IndexError("entry index out of range")
    labels_by_bar_index: dict[int, int] = {}
    for idx in normalized_entries:
        labels_by_bar_index[idx] = label_with_triple_barrier(
            highs=highs,
            lows=lows,
            closes=closes,
            entry_index=idx,
            side=side,
            spec=triple_barrier_spec,
        ).label
    ordered_labels = [labels_by_bar_index[idx] for idx in normalized_entries]
    folds = generate_walk_forward_splits(
        n_samples=len(normalized_entries),
        train_size=walk_forward.train_size,
        test_size=walk_forward.test_size,
        step_size=walk_forward.step_size,
        purge_size=walk_forward.purge_size,
        embargo_size=walk_forward.embargo_size,
        min_train_size=walk_forward.min_train_size,
    )
    fold_results: list[BacktestFoldResult] = []
    for fold_idx, fold in enumerate(folds):
        train_labels = [ordered_labels[i] for i in fold.train_indices]
        test_labels = [ordered_labels[i] for i in fold.test_indices]
        if not test_labels:
            continue
        fold_results.append(
            BacktestFoldResult(
                fold_index=fold_idx,
                train_indices=fold.train_indices,
                test_indices=fold.test_indices,
                train_label_distribution=_label_dist(train_labels),
                test_label_distribution=_label_dist(test_labels),
                baseline_scores=[
                    BaselineScore(name="B0", accuracy=_baseline_b0(train_labels, test_labels)),
                    BaselineScore(name="B1", accuracy=_score_constant(1, test_labels)),
                    BaselineScore(
                        name="M1",
                        accuracy=_score_constant(_m1_pred(train_labels), test_labels),
                    ),
                ],
            )
        )
    return BacktestPipelineResult(
        run_id=_build_run_id(
            n_entries=len(normalized_entries),
            n_folds=len(fold_results),
            sessions=resolved_sessions,
        ),
        n_bars=len(bars),
        n_entries=len(normalized_entries),
        required_sessions=resolved_sessions,
        label_distribution=_label_dist(ordered_labels),
        folds=fold_results,
    )
 def _label_dist(labels: Sequence[int]) -> dict[int, int]:
    dist: dict[int, int] = {-1: 0, 0: 0, 1: 0}
    for val in labels:
        if val in dist:
            dist[val] += 1
    return dist
 def _score_constant(pred: int, actual: Sequence[int]) -> float:
    return mean(1.0 if pred == label else 0.0 for label in actual)
 def _baseline_b0(train_labels: Sequence[int], test_labels: Sequence[int]) -> float:
    if not train_labels:
        return _score_constant(0, test_labels)
    # Majority-class baseline from training fold.
    choices = (-1, 0, 1)
    pred = max(choices, key=lambda c: train_labels.count(c))
    return _score_constant(pred, test_labels)
 def _m1_pred(train_labels: Sequence[int]) -> int:
    if not train_labels:
        return 0
    return train_labels[-1]
 def _build_run_id(*, n_entries: int, n_folds: int, sessions: Sequence[str]) -> str:
    sess_key = "_".join(sessions)
    return f"v2p-e{n_entries}-f{n_folds}-s{sess_key}"
 def fold_has_leakage(fold: WalkForwardFold) -> bool:
    """Utility for tests/verification: True when train/test overlap exists."""
    return bool(set(fold.train_indices).intersection(fold.test_indices))
--- a/src/analysis/triple_barrier.py
+++ b/src/analysis/triple_barrier.py
@@ -0,0 +1,111 @@
 """Triple barrier labeler utilities.
 Implements first-touch labeling with upper/lower/time barriers.
 """
 from __future__ import annotations
 from dataclasses import dataclass
 from typing import Literal, Sequence
 TieBreakMode = Literal["stop_first", "take_first"]
@dataclass(frozen=True)
 class TripleBarrierSpec:
    take_profit_pct: float
    stop_loss_pct: float
    max_holding_bars: int
    tie_break: TieBreakMode = "stop_first"
@dataclass(frozen=True)
 class TripleBarrierLabel:
    label: int  # +1 take-profit first, -1 stop-loss first, 0 timeout
    touched: Literal["take_profit", "stop_loss", "time"]
    touch_bar: int
    entry_price: float
    upper_barrier: float
    lower_barrier: float
 def label_with_triple_barrier(
    *,
    highs: Sequence[float],
    lows: Sequence[float],
    closes: Sequence[float],
    entry_index: int,
    side: int,
    spec: TripleBarrierSpec,
 ) -> TripleBarrierLabel:
    """Label one entry using triple-barrier first-touch rule.
    Args:
        highs/lows/closes: OHLC components with identical length.
        entry_index: Entry bar index in the sequences.
        side: +1 for long, -1 for short.
        spec: Barrier specification.
    """
    if side not in {1, -1}:
        raise ValueError("side must be +1 or -1")
    if len(highs) != len(lows) or len(highs) != len(closes):
        raise ValueError("highs, lows, closes lengths must match")
    if entry_index < 0 or entry_index >= len(closes):
        raise IndexError("entry_index out of range")
    if spec.max_holding_bars <= 0:
        raise ValueError("max_holding_bars must be positive")
    entry_price = float(closes[entry_index])
    if entry_price <= 0:
        raise ValueError("entry price must be positive")
    if side == 1:
        upper = entry_price * (1.0 + spec.take_profit_pct)
        lower = entry_price * (1.0 - spec.stop_loss_pct)
    else:
        # For short side, favorable move is down.
        upper = entry_price * (1.0 + spec.stop_loss_pct)
        lower = entry_price * (1.0 - spec.take_profit_pct)
    last_index = min(len(closes) - 1, entry_index + spec.max_holding_bars)
    for idx in range(entry_index + 1, last_index + 1):
        h = float(highs[idx])
        l = float(lows[idx])
        up_touch = h >= upper
        down_touch = l <= lower
        if not up_touch and not down_touch:
            continue
        if up_touch and down_touch:
            if spec.tie_break == "stop_first":
                touched = "stop_loss"
                label = -1
            else:
                touched = "take_profit"
                label = 1
        elif up_touch:
            touched = "take_profit" if side == 1 else "stop_loss"
            label = 1 if side == 1 else -1
        else:
            touched = "stop_loss" if side == 1 else "take_profit"
            label = -1 if side == 1 else 1
        return TripleBarrierLabel(
            label=label,
            touched=touched,
            touch_bar=idx,
            entry_price=entry_price,
            upper_barrier=upper,
            lower_barrier=lower,
        )
    return TripleBarrierLabel(
        label=0,
        touched="time",
        touch_bar=last_index,
        entry_price=entry_price,
        upper_barrier=upper,
        lower_barrier=lower,
    )
--- a/src/analysis/walk_forward_split.py
+++ b/src/analysis/walk_forward_split.py
@@ -0,0 +1,74 @@
 """Walk-forward splitter with purge/embargo controls."""
 from __future__ import annotations
 from dataclasses import dataclass
@dataclass(frozen=True)
 class WalkForwardFold:
    train_indices: list[int]
    test_indices: list[int]
    @property
    def train_size(self) -> int:
        return len(self.train_indices)
    @property
    def test_size(self) -> int:
        return len(self.test_indices)
 def generate_walk_forward_splits(
    *,
    n_samples: int,
    train_size: int,
    test_size: int,
    step_size: int | None = None,
    purge_size: int = 0,
    embargo_size: int = 0,
    min_train_size: int = 1,
 ) -> list[WalkForwardFold]:
    """Generate chronological folds with purge/embargo leakage controls."""
    if n_samples <= 0:
        raise ValueError("n_samples must be positive")
    if train_size <= 0 or test_size <= 0:
        raise ValueError("train_size and test_size must be positive")
    if purge_size < 0 or embargo_size < 0:
        raise ValueError("purge_size and embargo_size must be >= 0")
    if min_train_size <= 0:
        raise ValueError("min_train_size must be positive")
    step = step_size if step_size is not None else test_size
    if step <= 0:
        raise ValueError("step_size must be positive")
    folds: list[WalkForwardFold] = []
    prev_test_end: int | None = None
    test_start = train_size + purge_size
    while test_start + test_size <= n_samples:
        test_end = test_start + test_size - 1
        train_end = test_start - purge_size - 1
        if train_end < 0:
            break
        train_start = max(0, train_end - train_size + 1)
        train_indices = list(range(train_start, train_end + 1))
        if prev_test_end is not None and embargo_size > 0:
            emb_from = prev_test_end + 1
            emb_to = prev_test_end + embargo_size
            train_indices = [i for i in train_indices if i < emb_from or i > emb_to]
        if len(train_indices) >= min_train_size:
            folds.append(
                WalkForwardFold(
                    train_indices=train_indices,
                    test_indices=list(range(test_start, test_end + 1)),
                )
            )
            prev_test_end = test_end
        test_start += step
    return folds
--- a/src/config.py
+++ b/src/config.py
@@ -59,11 +59,16 @@ class Settings(BaseSettings):
    # KIS VTS overseas balance API returns errors for most accounts.
    # This value is used as a fallback when the balance API returns 0 in paper mode.
    PAPER_OVERSEAS_CASH: float = Field(default=50000.0, ge=0.0)
    USD_BUFFER_MIN: float = Field(default=1000.0, ge=0.0)
    OVERNIGHT_EXCEPTION_ENABLED: bool = True
    # Trading frequency mode (daily = batch API calls, realtime = per-stock calls)
    TRADE_MODE: str = Field(default="daily", pattern="^(daily|realtime)$")
    DAILY_SESSIONS: int = Field(default=4, ge=1, le=10)
    SESSION_INTERVAL_HOURS: int = Field(default=6, ge=1, le=24)
    ORDER_BLACKOUT_ENABLED: bool = True
    ORDER_BLACKOUT_WINDOWS_KST: str = "23:30-00:10"
    ORDER_BLACKOUT_QUEUE_MAX: int = Field(default=500, ge=10, le=5000)
    # Pre-Market Planner
    PRE_MARKET_MINUTES: int = Field(default=30, ge=10, le=120)
--- a/src/core/blackout_manager.py
+++ b/src/core/blackout_manager.py
@@ -0,0 +1,105 @@
 """Blackout policy and queued order-intent manager."""
 from __future__ import annotations
 from collections import deque
 from dataclasses import dataclass
 from datetime import UTC, datetime, time
 from zoneinfo import ZoneInfo
@dataclass(frozen=True)
 class BlackoutWindow:
    start: time
    end: time
    def contains(self, kst_time: time) -> bool:
        if self.start <= self.end:
            return self.start <= kst_time < self.end
        return kst_time >= self.start or kst_time < self.end
@dataclass
 class QueuedOrderIntent:
    market_code: str
    exchange_code: str
    stock_code: str
    order_type: str
    quantity: int
    price: float
    source: str
    queued_at: datetime
    attempts: int = 0
 def parse_blackout_windows_kst(raw: str) -> list[BlackoutWindow]:
    """Parse comma-separated KST windows like '23:30-00:10,11:20-11:30'."""
    windows: list[BlackoutWindow] = []
    for token in raw.split(","):
        span = token.strip()
        if not span or "-" not in span:
            continue
        start_raw, end_raw = [part.strip() for part in span.split("-", 1)]
        try:
            start_h, start_m = [int(v) for v in start_raw.split(":", 1)]
            end_h, end_m = [int(v) for v in end_raw.split(":", 1)]
        except (ValueError, TypeError):
            continue
        if not (0 <= start_h <= 23 and 0 <= end_h <= 23):
            continue
        if not (0 <= start_m <= 59 and 0 <= end_m <= 59):
            continue
        windows.append(BlackoutWindow(start=time(start_h, start_m), end=time(end_h, end_m)))
    return windows
 class BlackoutOrderManager:
    """Tracks blackout mode and queues order intents until recovery."""
    def __init__(
        self,
        *,
        enabled: bool,
        windows: list[BlackoutWindow],
        max_queue_size: int = 500,
    ) -> None:
        self.enabled = enabled
        self._windows = windows
        self._queue: deque[QueuedOrderIntent] = deque()
        self._was_blackout = False
        self._max_queue_size = max_queue_size
    @property
    def pending_count(self) -> int:
        return len(self._queue)
    def in_blackout(self, now: datetime | None = None) -> bool:
        if not self.enabled or not self._windows:
            return False
        now = now or datetime.now(UTC)
        kst_now = now.astimezone(ZoneInfo("Asia/Seoul")).timetz().replace(tzinfo=None)
        return any(window.contains(kst_now) for window in self._windows)
    def enqueue(self, intent: QueuedOrderIntent) -> bool:
        if len(self._queue) >= self._max_queue_size:
            return False
        self._queue.append(intent)
        return True
    def pop_recovery_batch(self, now: datetime | None = None) -> list[QueuedOrderIntent]:
        in_blackout_now = self.in_blackout(now)
        batch: list[QueuedOrderIntent] = []
        if not in_blackout_now and self._queue:
            while self._queue:
                batch.append(self._queue.popleft())
        self._was_blackout = in_blackout_now
        return batch
    def requeue(self, intent: QueuedOrderIntent) -> None:
        if len(self._queue) < self._max_queue_size:
            self._queue.append(intent)
    def clear(self) -> int:
        count = len(self._queue)
        self._queue.clear()
        return count
--- a/src/core/kill_switch.py
+++ b/src/core/kill_switch.py
@@ -0,0 +1,71 @@
 """Kill switch orchestration for emergency risk actions.
 Order is fixed:
 1) block new orders
 2) cancel pending orders
 3) refresh order state
 4) reduce risk
 5) snapshot and notify
 """
 from __future__ import annotations
 import inspect
 from dataclasses import dataclass, field
 from typing import Any, Awaitable, Callable
 StepCallable = Callable[[], Any | Awaitable[Any]]
@dataclass
 class KillSwitchReport:
    reason: str
    steps: list[str] = field(default_factory=list)
    errors: list[str] = field(default_factory=list)
 class KillSwitchOrchestrator:
    def __init__(self) -> None:
        self.new_orders_blocked = False
    async def _run_step(
        self,
        report: KillSwitchReport,
        name: str,
        fn: StepCallable | None,
    ) -> None:
        report.steps.append(name)
        if fn is None:
            return
        try:
            result = fn()
            if inspect.isawaitable(result):
                await result
        except Exception as exc:  # pragma: no cover - intentionally resilient
            report.errors.append(f"{name}: {exc}")
    async def trigger(
        self,
        *,
        reason: str,
        cancel_pending_orders: StepCallable | None = None,
        refresh_order_state: StepCallable | None = None,
        reduce_risk: StepCallable | None = None,
        snapshot_state: StepCallable | None = None,
        notify: StepCallable | None = None,
    ) -> KillSwitchReport:
        report = KillSwitchReport(reason=reason)
        self.new_orders_blocked = True
        report.steps.append("block_new_orders")
        await self._run_step(report, "cancel_pending_orders", cancel_pending_orders)
        await self._run_step(report, "refresh_order_state", refresh_order_state)
        await self._run_step(report, "reduce_risk", reduce_risk)
        await self._run_step(report, "snapshot_state", snapshot_state)
        await self._run_step(report, "notify", notify)
        return report
    def clear_block(self) -> None:
        self.new_orders_blocked = False
--- a/src/core/order_policy.py
+++ b/src/core/order_policy.py
@@ -0,0 +1,93 @@
 """Session-aware order policy guards.
 Default policy:
 - Low-liquidity sessions must reject market orders (price <= 0).
 """
 from __future__ import annotations
 from dataclasses import dataclass
 from datetime import UTC, datetime, time
 from zoneinfo import ZoneInfo
 from src.markets.schedule import MarketInfo
 _LOW_LIQUIDITY_SESSIONS = {"NXT_AFTER", "US_PRE", "US_DAY", "US_AFTER"}
 class OrderPolicyRejected(Exception):
    """Raised when an order violates session policy."""
    def __init__(self, message: str, *, session_id: str, market_code: str) -> None:
        super().__init__(message)
        self.session_id = session_id
        self.market_code = market_code
@dataclass(frozen=True)
 class SessionInfo:
    session_id: str
    is_low_liquidity: bool
 def classify_session_id(market: MarketInfo, now: datetime | None = None) -> str:
    """Classify current session by KST schedule used in v3 docs."""
    now = now or datetime.now(UTC)
    # v3 session tables are explicitly defined in KST perspective.
    kst_time = now.astimezone(ZoneInfo("Asia/Seoul")).timetz().replace(tzinfo=None)
    if market.code == "KR":
        if time(8, 0) <= kst_time < time(8, 50):
            return "NXT_PRE"
        if time(9, 0) <= kst_time < time(15, 30):
            return "KRX_REG"
        if time(15, 30) <= kst_time < time(20, 0):
            return "NXT_AFTER"
        return "KR_OFF"
    if market.code.startswith("US"):
        if time(10, 0) <= kst_time < time(18, 0):
            return "US_DAY"
        if time(18, 0) <= kst_time < time(23, 30):
            return "US_PRE"
        if time(23, 30) <= kst_time or kst_time < time(6, 0):
            return "US_REG"
        if time(6, 0) <= kst_time < time(7, 0):
            return "US_AFTER"
        return "US_OFF"
    return "GENERIC_REG"
 def get_session_info(market: MarketInfo, now: datetime | None = None) -> SessionInfo:
    session_id = classify_session_id(market, now)
    return SessionInfo(session_id=session_id, is_low_liquidity=session_id in _LOW_LIQUIDITY_SESSIONS)
 def validate_order_policy(
    *,
    market: MarketInfo,
    order_type: str,
    price: float,
    now: datetime | None = None,
 ) -> SessionInfo:
    """Validate order against session policy and return resolved session info."""
    info = get_session_info(market, now)
    is_market_order = price <= 0
    if info.is_low_liquidity and is_market_order:
        raise OrderPolicyRejected(
            f"Market order is forbidden in low-liquidity session ({info.session_id})",
            session_id=info.session_id,
            market_code=market.code,
        )
    # Guard against accidental unsupported actions.
    if order_type not in {"BUY", "SELL"}:
        raise OrderPolicyRejected(
            f"Unsupported order_type={order_type}",
            session_id=info.session_id,
            market_code=market.code,
        )
    return info
--- a/src/db.py
+++ b/src/db.py
@@ -31,8 +31,12 @@ def init_db(db_path: str) -> sqlite3.Connection:
            quantity INTEGER,
            price REAL,
            pnl REAL DEFAULT 0.0,
            strategy_pnl REAL DEFAULT 0.0,
            fx_pnl REAL DEFAULT 0.0,
            market TEXT DEFAULT 'KR',
            exchange_code TEXT DEFAULT 'KRX',
            session_id TEXT DEFAULT 'UNKNOWN',
            selection_context TEXT,
            decision_id TEXT,
            mode TEXT DEFAULT 'paper'
        )
@@ -53,6 +57,32 @@ def init_db(db_path: str) -> sqlite3.Connection:
        conn.execute("ALTER TABLE trades ADD COLUMN decision_id TEXT")
    if "mode" not in columns:
        conn.execute("ALTER TABLE trades ADD COLUMN mode TEXT DEFAULT 'paper'")
    session_id_added = False
    if "session_id" not in columns:
        conn.execute("ALTER TABLE trades ADD COLUMN session_id TEXT DEFAULT 'UNKNOWN'")
        session_id_added = True
    if "strategy_pnl" not in columns:
        conn.execute("ALTER TABLE trades ADD COLUMN strategy_pnl REAL DEFAULT 0.0")
    if "fx_pnl" not in columns:
        conn.execute("ALTER TABLE trades ADD COLUMN fx_pnl REAL DEFAULT 0.0")
    # Backfill legacy rows where only pnl existed before split accounting columns.
    conn.execute(
        """
        UPDATE trades
        SET strategy_pnl = pnl, fx_pnl = 0.0
        WHERE pnl != 0.0
          AND strategy_pnl = 0.0
          AND fx_pnl = 0.0
        """
    )
    if session_id_added:
        conn.execute(
            """
            UPDATE trades
            SET session_id = 'UNKNOWN'
            WHERE session_id IS NULL OR session_id = ''
            """
        )
    # Context tree tables for multi-layered memory management
    conn.execute(
@@ -171,8 +201,11 @@ def log_trade(
    quantity: int = 0,
    price: float = 0.0,
    pnl: float = 0.0,
    strategy_pnl: float | None = None,
    fx_pnl: float | None = None,
    market: str = "KR",
    exchange_code: str = "KRX",
    session_id: str | None = None,
    selection_context: dict[str, any] | None = None,
    decision_id: str | None = None,
    mode: str = "paper",
@@ -187,24 +220,37 @@ def log_trade(
        rationale: AI decision rationale
        quantity: Number of shares
        price: Trade price
-        pnl: Profit/loss
+        pnl: Total profit/loss (backward compatibility)
        strategy_pnl: Strategy PnL component
        fx_pnl: FX PnL component
        market: Market code
        exchange_code: Exchange code
        session_id: Session identifier (if omitted, auto-derived from market)
        selection_context: Scanner selection data (RSI, volume_ratio, signal, score)
        decision_id: Unique decision identifier for audit linking
        mode: Trading mode ('paper' or 'live') for data separation
    """
    # Serialize selection context to JSON
    context_json = json.dumps(selection_context) if selection_context else None
    resolved_session_id = _resolve_session_id(market=market, session_id=session_id)
    if strategy_pnl is None and fx_pnl is None:
        strategy_pnl = pnl
        fx_pnl = 0.0
    elif strategy_pnl is None:
        strategy_pnl = pnl - float(fx_pnl or 0.0) if pnl != 0.0 else 0.0
    elif fx_pnl is None:
        fx_pnl = pnl - float(strategy_pnl) if pnl != 0.0 else 0.0
    if pnl == 0.0 and (strategy_pnl or fx_pnl):
        pnl = float(strategy_pnl) + float(fx_pnl)
    conn.execute(
        """
        INSERT INTO trades (
            timestamp, stock_code, action, confidence, rationale,
-            quantity, price, pnl, market, exchange_code, selection_context, decision_id,
+            quantity, price, pnl, strategy_pnl, fx_pnl,
-            mode
+            market, exchange_code, session_id, selection_context, decision_id, mode
        )
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        """,
        (
            datetime.now(UTC).isoformat(),
@@ -215,8 +261,11 @@ def log_trade(
            quantity,
            price,
            pnl,
            strategy_pnl,
            fx_pnl,
            market,
            exchange_code,
            resolved_session_id,
            context_json,
            decision_id,
            mode,
@@ -225,6 +274,21 @@ def log_trade(
    conn.commit()
 def _resolve_session_id(*, market: str, session_id: str | None) -> str:
    if session_id:
        return session_id
    try:
        from src.core.order_policy import classify_session_id
        from src.markets.schedule import MARKETS
        market_info = MARKETS.get(market)
        if market_info is not None:
            return classify_session_id(market_info)
    except Exception:
        pass
    return "UNKNOWN"
 def get_latest_buy_trade(
    conn: sqlite3.Connection, stock_code: str, market: str
 ) -> dict[str, Any] | None:
--- a/src/main.py
+++ b/src/main.py
--- a/src/markets/schedule.py
+++ b/src/markets/schedule.py
@@ -1,7 +1,7 @@
 """Market schedule management with timezone support."""
 from dataclasses import dataclass
-from datetime import datetime, time, timedelta
+from datetime import UTC, datetime, time, timedelta
 from zoneinfo import ZoneInfo
@@ -181,7 +181,10 @@ def is_market_open(market: MarketInfo, now: datetime | None = None) -> bool:
 def get_open_markets(
-    enabled_markets: list[str] | None = None, now: datetime | None = None
+    enabled_markets: list[str] | None = None,
    now: datetime | None = None,
    *,
    include_extended_sessions: bool = False,
 ) -> list[MarketInfo]:
    """
    Get list of currently open markets.
@@ -196,17 +199,31 @@ def get_open_markets(
    if enabled_markets is None:
        enabled_markets = list(MARKETS.keys())
    def is_available(market: MarketInfo) -> bool:
        if not include_extended_sessions:
            return is_market_open(market, now)
        if market.code == "KR" or market.code.startswith("US"):
            # Import lazily to avoid module cycle at import-time.
            from src.core.order_policy import classify_session_id
            session_id = classify_session_id(market, now)
            return session_id not in {"KR_OFF", "US_OFF"}
        return is_market_open(market, now)
    open_markets = [
        MARKETS[code]
        for code in enabled_markets
-        if code in MARKETS and is_market_open(MARKETS[code], now)
+        if code in MARKETS and is_available(MARKETS[code])
    ]
    return sorted(open_markets, key=lambda m: m.code)
 def get_next_market_open(
-    enabled_markets: list[str] | None = None, now: datetime | None = None
+    enabled_markets: list[str] | None = None,
    now: datetime | None = None,
    *,
    include_extended_sessions: bool = False,
 ) -> tuple[MarketInfo, datetime]:
    """
    Find the next market that will open and when.
@@ -233,6 +250,21 @@ def get_next_market_open(
    next_open_time: datetime | None = None
    next_market: MarketInfo | None = None
    def first_extended_open_after(market: MarketInfo, start_utc: datetime) -> datetime | None:
        # Search minute-by-minute for KR/US session transition into active window.
        # Bounded to 7 days to match existing behavior.
        from src.core.order_policy import classify_session_id
        ts = start_utc.astimezone(ZoneInfo("UTC")).replace(second=0, microsecond=0)
        prev_active = classify_session_id(market, ts) not in {"KR_OFF", "US_OFF"}
        for _ in range(7 * 24 * 60):
            ts = ts + timedelta(minutes=1)
            active = classify_session_id(market, ts) not in {"KR_OFF", "US_OFF"}
            if active and not prev_active:
                return ts
            prev_active = active
        return None
    for code in enabled_markets:
        if code not in MARKETS:
            continue
@@ -240,6 +272,13 @@ def get_next_market_open(
        market = MARKETS[code]
        market_now = now.astimezone(market.timezone)
        if include_extended_sessions and (market.code == "KR" or market.code.startswith("US")):
            ext_open = first_extended_open_after(market, now.astimezone(UTC))
            if ext_open and (next_open_time is None or ext_open < next_open_time):
                next_open_time = ext_open
                next_market = market
            continue
        # Calculate next open time for this market
        for days_ahead in range(7):  # Check next 7 days
            check_date = market_now.date() + timedelta(days=days_ahead)
--- a/src/strategy/exit_rules.py
+++ b/src/strategy/exit_rules.py
@@ -0,0 +1,104 @@
 """Composite exit rules: hard stop, break-even lock, ATR trailing, model assist."""
 from __future__ import annotations
 from dataclasses import dataclass
 from src.strategy.position_state_machine import PositionState, StateTransitionInput, promote_state
@dataclass(frozen=True)
 class ExitRuleConfig:
    hard_stop_pct: float = -2.0
    be_arm_pct: float = 1.2
    arm_pct: float = 3.0
    atr_multiplier_k: float = 2.2
    model_prob_threshold: float = 0.62
@dataclass(frozen=True)
 class ExitRuleInput:
    current_price: float
    entry_price: float
    peak_price: float
    atr_value: float = 0.0
    pred_down_prob: float = 0.0
    liquidity_weak: bool = False
@dataclass(frozen=True)
 class ExitEvaluation:
    state: PositionState
    should_exit: bool
    reason: str
    unrealized_pnl_pct: float
    trailing_stop_price: float | None
 def evaluate_exit(
    *,
    current_state: PositionState,
    config: ExitRuleConfig,
    inp: ExitRuleInput,
 ) -> ExitEvaluation:
    """Evaluate composite exit logic and return updated state."""
    if inp.entry_price <= 0 or inp.current_price <= 0:
        return ExitEvaluation(
            state=current_state,
            should_exit=False,
            reason="invalid_price",
            unrealized_pnl_pct=0.0,
            trailing_stop_price=None,
        )
    unrealized = (inp.current_price - inp.entry_price) / inp.entry_price * 100.0
    hard_stop_hit = unrealized <= config.hard_stop_pct
    take_profit_hit = unrealized >= config.arm_pct
    trailing_stop_price: float | None = None
    trailing_stop_hit = False
    if inp.atr_value > 0 and inp.peak_price > 0:
        trailing_stop_price = inp.peak_price - (config.atr_multiplier_k * inp.atr_value)
        trailing_stop_hit = inp.current_price <= trailing_stop_price
    be_lock_threat = current_state in (PositionState.BE_LOCK, PositionState.ARMED) and (
        inp.current_price <= inp.entry_price
    )
    model_exit_signal = inp.pred_down_prob >= config.model_prob_threshold and inp.liquidity_weak
    next_state = promote_state(
        current=current_state,
        inp=StateTransitionInput(
            unrealized_pnl_pct=unrealized,
            be_arm_pct=config.be_arm_pct,
            arm_pct=config.arm_pct,
            hard_stop_hit=hard_stop_hit,
            trailing_stop_hit=trailing_stop_hit,
            model_exit_signal=model_exit_signal,
            be_lock_threat=be_lock_threat,
        ),
    )
    if hard_stop_hit:
        reason = "hard_stop"
    elif trailing_stop_hit:
        reason = "atr_trailing_stop"
    elif be_lock_threat:
        reason = "be_lock_threat"
    elif model_exit_signal:
        reason = "model_liquidity_exit"
    elif take_profit_hit:
        # Backward-compatible immediate profit-taking path.
        reason = "arm_take_profit"
    else:
        reason = "hold"
    should_exit = next_state == PositionState.EXITED or take_profit_hit
    return ExitEvaluation(
        state=next_state,
        should_exit=should_exit,
        reason=reason,
        unrealized_pnl_pct=unrealized,
        trailing_stop_price=trailing_stop_price,
    )
--- a/src/strategy/position_state_machine.py
+++ b/src/strategy/position_state_machine.py
@@ -0,0 +1,70 @@
 """Position state machine for staged exit control.
 State progression is monotonic (promotion-only) except terminal EXITED.
 """
 from __future__ import annotations
 from dataclasses import dataclass
 from enum import Enum
 class PositionState(str, Enum):
    HOLDING = "HOLDING"
    BE_LOCK = "BE_LOCK"
    ARMED = "ARMED"
    EXITED = "EXITED"
 _STATE_RANK: dict[PositionState, int] = {
    PositionState.HOLDING: 0,
    PositionState.BE_LOCK: 1,
    PositionState.ARMED: 2,
    PositionState.EXITED: 3,
 }
@dataclass(frozen=True)
 class StateTransitionInput:
    unrealized_pnl_pct: float
    be_arm_pct: float
    arm_pct: float
    hard_stop_hit: bool = False
    trailing_stop_hit: bool = False
    model_exit_signal: bool = False
    be_lock_threat: bool = False
 def evaluate_exit_first(inp: StateTransitionInput) -> bool:
    """Return True when terminal exit conditions are met.
    EXITED must be evaluated before any promotion.
    """
    return (
        inp.hard_stop_hit
        or inp.trailing_stop_hit
        or inp.model_exit_signal
        or inp.be_lock_threat
    )
 def promote_state(current: PositionState, inp: StateTransitionInput) -> PositionState:
    """Promote to highest admissible state for current tick/bar.
    Rules:
    - EXITED has highest precedence and is terminal.
    - Promotions are monotonic (no downgrade).
    """
    if current == PositionState.EXITED:
        return PositionState.EXITED
    if evaluate_exit_first(inp):
        return PositionState.EXITED
    target = PositionState.HOLDING
    if inp.unrealized_pnl_pct >= inp.arm_pct:
        target = PositionState.ARMED
    elif inp.unrealized_pnl_pct >= inp.be_arm_pct:
        target = PositionState.BE_LOCK
    return target if _STATE_RANK[target] > _STATE_RANK[current] else current
--- a/tests/test_backtest_cost_guard.py
+++ b/tests/test_backtest_cost_guard.py
@@ -0,0 +1,83 @@
 from __future__ import annotations
 import pytest
 from src.analysis.backtest_cost_guard import BacktestCostModel, validate_backtest_cost_model
 def test_valid_backtest_cost_model_passes() -> None:
    model = BacktestCostModel(
        commission_bps=5.0,
        slippage_bps_by_session={"KRX_REG": 10.0, "US_PRE": 50.0},
        failure_rate_by_session={"KRX_REG": 0.01, "US_PRE": 0.08},
        unfavorable_fill_required=True,
    )
    validate_backtest_cost_model(model=model, required_sessions=["KRX_REG", "US_PRE"])
 def test_missing_required_slippage_session_raises() -> None:
    model = BacktestCostModel(
        commission_bps=5.0,
        slippage_bps_by_session={"KRX_REG": 10.0},
        failure_rate_by_session={"KRX_REG": 0.01, "US_PRE": 0.08},
        unfavorable_fill_required=True,
    )
    with pytest.raises(ValueError, match="missing slippage_bps_by_session.*US_PRE"):
        validate_backtest_cost_model(model=model, required_sessions=["KRX_REG", "US_PRE"])
 def test_missing_required_failure_rate_session_raises() -> None:
    model = BacktestCostModel(
        commission_bps=5.0,
        slippage_bps_by_session={"KRX_REG": 10.0, "US_PRE": 50.0},
        failure_rate_by_session={"KRX_REG": 0.01},
        unfavorable_fill_required=True,
    )
    with pytest.raises(ValueError, match="missing failure_rate_by_session.*US_PRE"):
        validate_backtest_cost_model(model=model, required_sessions=["KRX_REG", "US_PRE"])
 def test_invalid_failure_rate_range_raises() -> None:
    model = BacktestCostModel(
        commission_bps=5.0,
        slippage_bps_by_session={"KRX_REG": 10.0},
        failure_rate_by_session={"KRX_REG": 1.2},
        unfavorable_fill_required=True,
    )
    with pytest.raises(ValueError, match="failure rate must be within"):
        validate_backtest_cost_model(model=model, required_sessions=["KRX_REG"])
 def test_unfavorable_fill_requirement_cannot_be_disabled() -> None:
    model = BacktestCostModel(
        commission_bps=5.0,
        slippage_bps_by_session={"KRX_REG": 10.0},
        failure_rate_by_session={"KRX_REG": 0.02},
        unfavorable_fill_required=False,
    )
    with pytest.raises(ValueError, match="unfavorable_fill_required must be True"):
        validate_backtest_cost_model(model=model, required_sessions=["KRX_REG"])
@pytest.mark.parametrize("bad_commission", [float("nan"), float("inf"), float("-inf")])
 def test_non_finite_commission_rejected(bad_commission: float) -> None:
    model = BacktestCostModel(
        commission_bps=bad_commission,
        slippage_bps_by_session={"KRX_REG": 10.0},
        failure_rate_by_session={"KRX_REG": 0.02},
        unfavorable_fill_required=True,
    )
    with pytest.raises(ValueError, match="commission_bps"):
        validate_backtest_cost_model(model=model, required_sessions=["KRX_REG"])
@pytest.mark.parametrize("bad_slippage", [float("nan"), float("inf"), float("-inf")])
 def test_non_finite_slippage_rejected(bad_slippage: float) -> None:
    model = BacktestCostModel(
        commission_bps=5.0,
        slippage_bps_by_session={"KRX_REG": bad_slippage},
        failure_rate_by_session={"KRX_REG": 0.02},
        unfavorable_fill_required=True,
    )
    with pytest.raises(ValueError, match="slippage bps"):
        validate_backtest_cost_model(model=model, required_sessions=["KRX_REG"])
--- a/tests/test_backtest_execution_model.py
+++ b/tests/test_backtest_execution_model.py
@@ -0,0 +1,108 @@
 from __future__ import annotations
 import pytest
 from src.analysis.backtest_execution_model import (
    BacktestExecutionModel,
    ExecutionAssumptions,
    ExecutionRequest,
 )
 def test_buy_uses_unfavorable_slippage_direction() -> None:
    model = BacktestExecutionModel(
        ExecutionAssumptions(
            slippage_bps_by_session={"US_PRE": 50.0},
            failure_rate_by_session={"US_PRE": 0.0},
            partial_fill_rate_by_session={"US_PRE": 0.0},
            seed=1,
        )
    )
    out = model.simulate(
        ExecutionRequest(side="BUY", session_id="US_PRE", qty=10, reference_price=100.0)
    )
    assert out.status == "FILLED"
    assert out.avg_price == pytest.approx(100.5)
 def test_sell_uses_unfavorable_slippage_direction() -> None:
    model = BacktestExecutionModel(
        ExecutionAssumptions(
            slippage_bps_by_session={"US_PRE": 50.0},
            failure_rate_by_session={"US_PRE": 0.0},
            partial_fill_rate_by_session={"US_PRE": 0.0},
            seed=1,
        )
    )
    out = model.simulate(
        ExecutionRequest(side="SELL", session_id="US_PRE", qty=10, reference_price=100.0)
    )
    assert out.status == "FILLED"
    assert out.avg_price == pytest.approx(99.5)
 def test_failure_rate_can_reject_order() -> None:
    model = BacktestExecutionModel(
        ExecutionAssumptions(
            slippage_bps_by_session={"KRX_REG": 10.0},
            failure_rate_by_session={"KRX_REG": 1.0},
            partial_fill_rate_by_session={"KRX_REG": 0.0},
            seed=42,
        )
    )
    out = model.simulate(
        ExecutionRequest(side="BUY", session_id="KRX_REG", qty=10, reference_price=100.0)
    )
    assert out.status == "REJECTED"
    assert out.filled_qty == 0
 def test_partial_fill_applies_when_rate_is_one() -> None:
    model = BacktestExecutionModel(
        ExecutionAssumptions(
            slippage_bps_by_session={"KRX_REG": 0.0},
            failure_rate_by_session={"KRX_REG": 0.0},
            partial_fill_rate_by_session={"KRX_REG": 1.0},
            partial_fill_min_ratio=0.4,
            partial_fill_max_ratio=0.4,
            seed=0,
        )
    )
    out = model.simulate(
        ExecutionRequest(side="BUY", session_id="KRX_REG", qty=10, reference_price=100.0)
    )
    assert out.status == "PARTIAL"
    assert out.filled_qty == 4
    assert out.avg_price == 100.0
@pytest.mark.parametrize("bad_slip", [-1.0, float("nan"), float("inf")])
 def test_invalid_slippage_is_rejected(bad_slip: float) -> None:
    with pytest.raises(ValueError, match="slippage_bps"):
        BacktestExecutionModel(
            ExecutionAssumptions(
                slippage_bps_by_session={"US_PRE": bad_slip},
                failure_rate_by_session={"US_PRE": 0.0},
                partial_fill_rate_by_session={"US_PRE": 0.0},
            )
        )
@pytest.mark.parametrize("bad_rate", [-0.1, 1.1, float("nan")])
 def test_invalid_failure_or_partial_rates_are_rejected(bad_rate: float) -> None:
    with pytest.raises(ValueError, match="failure_rate"):
        BacktestExecutionModel(
            ExecutionAssumptions(
                slippage_bps_by_session={"US_PRE": 10.0},
                failure_rate_by_session={"US_PRE": bad_rate},
                partial_fill_rate_by_session={"US_PRE": 0.0},
            )
        )
    with pytest.raises(ValueError, match="partial_fill_rate"):
        BacktestExecutionModel(
            ExecutionAssumptions(
                slippage_bps_by_session={"US_PRE": 10.0},
                failure_rate_by_session={"US_PRE": 0.0},
                partial_fill_rate_by_session={"US_PRE": bad_rate},
            )
        )
--- a/tests/test_backtest_pipeline_integration.py
+++ b/tests/test_backtest_pipeline_integration.py
@@ -0,0 +1,136 @@
 from __future__ import annotations
 from src.analysis.backtest_cost_guard import BacktestCostModel
 from src.analysis.backtest_pipeline import (
    BacktestBar,
    WalkForwardConfig,
    fold_has_leakage,
    run_v2_backtest_pipeline,
 )
 from src.analysis.triple_barrier import TripleBarrierSpec
 from src.analysis.walk_forward_split import generate_walk_forward_splits
 def _bars() -> list[BacktestBar]:
    closes = [100.0, 101.0, 102.0, 101.5, 103.0, 102.5, 104.0, 103.5, 105.0, 104.5, 106.0, 105.5]
    bars: list[BacktestBar] = []
    for i, close in enumerate(closes):
        bars.append(
            BacktestBar(
                high=close + 1.0,
                low=close - 1.0,
                close=close,
                session_id="KRX_REG" if i % 2 == 0 else "US_PRE",
            )
        )
    return bars
 def _cost_model() -> BacktestCostModel:
    return BacktestCostModel(
        commission_bps=3.0,
        slippage_bps_by_session={"KRX_REG": 10.0, "US_PRE": 50.0},
        failure_rate_by_session={"KRX_REG": 0.01, "US_PRE": 0.08},
        unfavorable_fill_required=True,
    )
 def test_pipeline_happy_path_returns_fold_and_artifact_contract() -> None:
    out = run_v2_backtest_pipeline(
        bars=_bars(),
        entry_indices=[0, 1, 2, 3, 4, 5, 6, 7],
        side=1,
        triple_barrier_spec=TripleBarrierSpec(
            take_profit_pct=0.02,
            stop_loss_pct=0.01,
            max_holding_bars=3,
        ),
        walk_forward=WalkForwardConfig(
            train_size=4,
            test_size=2,
            step_size=2,
            purge_size=1,
            embargo_size=1,
            min_train_size=3,
        ),
        cost_model=_cost_model(),
    )
    assert out.run_id.startswith("v2p-e8-f")
    assert out.n_bars == 12
    assert out.n_entries == 8
    assert out.required_sessions == ["KRX_REG", "US_PRE"]
    assert len(out.folds) > 0
    assert set(out.label_distribution) == {-1, 0, 1}
    for fold in out.folds:
        names = {score.name for score in fold.baseline_scores}
        assert names == {"B0", "B1", "M1"}
        for score in fold.baseline_scores:
            assert 0.0 <= score.accuracy <= 1.0
 def test_pipeline_cost_guard_fail_fast() -> None:
    bad = BacktestCostModel(
        commission_bps=3.0,
        slippage_bps_by_session={"KRX_REG": 10.0},
        failure_rate_by_session={"KRX_REG": 0.01},
        unfavorable_fill_required=True,
    )
    try:
        run_v2_backtest_pipeline(
            bars=_bars(),
            entry_indices=[0, 1, 2, 3],
            side=1,
            triple_barrier_spec=TripleBarrierSpec(
                take_profit_pct=0.02,
                stop_loss_pct=0.01,
                max_holding_bars=3,
            ),
            walk_forward=WalkForwardConfig(train_size=2, test_size=1),
            cost_model=bad,
            required_sessions=["KRX_REG", "US_PRE"],
        )
    except ValueError as exc:
        assert "missing slippage_bps_by_session" in str(exc)
    else:
        raise AssertionError("expected cost guard validation error")
 def test_pipeline_fold_leakage_guard() -> None:
    folds = generate_walk_forward_splits(
        n_samples=12,
        train_size=6,
        test_size=2,
        step_size=2,
        purge_size=1,
        embargo_size=1,
        min_train_size=5,
    )
    assert folds
    for fold in folds:
        assert not fold_has_leakage(fold)
 def test_pipeline_deterministic_seed_free_deterministic_result() -> None:
    cfg = dict(
        bars=_bars(),
        entry_indices=[0, 1, 2, 3, 4, 5, 6, 7],
        side=1,
        triple_barrier_spec=TripleBarrierSpec(
            take_profit_pct=0.02,
            stop_loss_pct=0.01,
            max_holding_bars=3,
        ),
        walk_forward=WalkForwardConfig(
            train_size=4,
            test_size=2,
            step_size=2,
            purge_size=1,
            embargo_size=1,
            min_train_size=3,
        ),
        cost_model=_cost_model(),
    )
    out1 = run_v2_backtest_pipeline(**cfg)
    out2 = run_v2_backtest_pipeline(**cfg)
    assert out1 == out2
--- a/tests/test_blackout_manager.py
+++ b/tests/test_blackout_manager.py
@@ -0,0 +1,81 @@
 from __future__ import annotations
 from datetime import UTC, datetime
 from src.core.blackout_manager import (
    BlackoutOrderManager,
    QueuedOrderIntent,
    parse_blackout_windows_kst,
 )
 def test_parse_blackout_windows_kst() -> None:
    windows = parse_blackout_windows_kst("23:30-00:10,11:20-11:30,invalid")
    assert len(windows) == 2
 def test_blackout_manager_handles_cross_midnight_window() -> None:
    manager = BlackoutOrderManager(
        enabled=True,
        windows=parse_blackout_windows_kst("23:30-00:10"),
        max_queue_size=10,
    )
    # 2026-01-01 23:40 KST = 2026-01-01 14:40 UTC
    assert manager.in_blackout(datetime(2026, 1, 1, 14, 40, tzinfo=UTC))
    # 2026-01-02 00:20 KST = 2026-01-01 15:20 UTC
    assert not manager.in_blackout(datetime(2026, 1, 1, 15, 20, tzinfo=UTC))
 def test_recovery_batch_only_after_blackout_exit() -> None:
    manager = BlackoutOrderManager(
        enabled=True,
        windows=parse_blackout_windows_kst("23:30-00:10"),
        max_queue_size=10,
    )
    intent = QueuedOrderIntent(
        market_code="KR",
        exchange_code="KRX",
        stock_code="005930",
        order_type="BUY",
        quantity=1,
        price=100.0,
        source="test",
        queued_at=datetime.now(UTC),
    )
    assert manager.enqueue(intent)
    # Inside blackout: no pop yet
    inside_blackout = datetime(2026, 1, 1, 14, 40, tzinfo=UTC)
    assert manager.pop_recovery_batch(inside_blackout) == []
    # Outside blackout: pop full batch once
    outside_blackout = datetime(2026, 1, 1, 15, 20, tzinfo=UTC)
    batch = manager.pop_recovery_batch(outside_blackout)
    assert len(batch) == 1
    assert manager.pending_count == 0
 def test_requeued_intent_is_processed_next_non_blackout_cycle() -> None:
    manager = BlackoutOrderManager(
        enabled=True,
        windows=parse_blackout_windows_kst("23:30-00:10"),
        max_queue_size=10,
    )
    intent = QueuedOrderIntent(
        market_code="KR",
        exchange_code="KRX",
        stock_code="005930",
        order_type="BUY",
        quantity=1,
        price=100.0,
        source="test",
        queued_at=datetime.now(UTC),
    )
    manager.enqueue(intent)
    outside_blackout = datetime(2026, 1, 1, 15, 20, tzinfo=UTC)
    first_batch = manager.pop_recovery_batch(outside_blackout)
    assert len(first_batch) == 1
    manager.requeue(first_batch[0])
    second_batch = manager.pop_recovery_batch(outside_blackout)
    assert len(second_batch) == 1
--- a/tests/test_db.py
+++ b/tests/test_db.py
@@ -155,6 +155,9 @@ def test_mode_column_exists_in_schema() -> None:
    cursor = conn.execute("PRAGMA table_info(trades)")
    columns = {row[1] for row in cursor.fetchall()}
    assert "mode" in columns
    assert "session_id" in columns
    assert "strategy_pnl" in columns
    assert "fx_pnl" in columns
 def test_mode_migration_adds_column_to_existing_db() -> None:
@@ -182,6 +185,13 @@ def test_mode_migration_adds_column_to_existing_db() -> None:
                decision_id TEXT
            )"""
        )
        old_conn.execute(
            """
            INSERT INTO trades (
                timestamp, stock_code, action, confidence, rationale, quantity, price, pnl
            ) VALUES ('2026-01-01T00:00:00+00:00', 'AAPL', 'SELL', 90, 'legacy', 1, 100.0, 123.45)
            """
        )
        old_conn.commit()
        old_conn.close()
@@ -190,6 +200,132 @@ def test_mode_migration_adds_column_to_existing_db() -> None:
        cursor = conn.execute("PRAGMA table_info(trades)")
        columns = {row[1] for row in cursor.fetchall()}
        assert "mode" in columns
        assert "session_id" in columns
        assert "strategy_pnl" in columns
        assert "fx_pnl" in columns
        migrated = conn.execute(
            "SELECT pnl, strategy_pnl, fx_pnl, session_id FROM trades WHERE stock_code='AAPL' LIMIT 1"
        ).fetchone()
        assert migrated is not None
        assert migrated[0] == 123.45
        assert migrated[1] == 123.45
        assert migrated[2] == 0.0
        assert migrated[3] == "UNKNOWN"
        conn.close()
    finally:
        os.unlink(db_path)
 def test_log_trade_stores_strategy_and_fx_pnl_separately() -> None:
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="AAPL",
        action="SELL",
        confidence=90,
        rationale="fx split",
        pnl=120.0,
        strategy_pnl=100.0,
        fx_pnl=20.0,
        market="US_NASDAQ",
        exchange_code="NASD",
    )
    row = conn.execute(
        "SELECT pnl, strategy_pnl, fx_pnl FROM trades ORDER BY id DESC LIMIT 1"
    ).fetchone()
    assert row is not None
    assert row[0] == 120.0
    assert row[1] == 100.0
    assert row[2] == 20.0
 def test_log_trade_backward_compat_sets_strategy_pnl_from_pnl() -> None:
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="005930",
        action="SELL",
        confidence=80,
        rationale="legacy",
        pnl=50.0,
        market="KR",
        exchange_code="KRX",
    )
    row = conn.execute(
        "SELECT pnl, strategy_pnl, fx_pnl FROM trades ORDER BY id DESC LIMIT 1"
    ).fetchone()
    assert row is not None
    assert row[0] == 50.0
    assert row[1] == 50.0
    assert row[2] == 0.0
 def test_log_trade_partial_fx_input_does_not_infer_negative_strategy_pnl() -> None:
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="AAPL",
        action="SELL",
        confidence=70,
        rationale="fx only",
        pnl=0.0,
        fx_pnl=10.0,
        market="US_NASDAQ",
        exchange_code="NASD",
    )
    row = conn.execute(
        "SELECT pnl, strategy_pnl, fx_pnl FROM trades ORDER BY id DESC LIMIT 1"
    ).fetchone()
    assert row is not None
    assert row[0] == 10.0
    assert row[1] == 0.0
    assert row[2] == 10.0
 def test_log_trade_persists_explicit_session_id() -> None:
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="AAPL",
        action="BUY",
        confidence=70,
        rationale="session test",
        market="US_NASDAQ",
        exchange_code="NASD",
        session_id="US_PRE",
    )
    row = conn.execute("SELECT session_id FROM trades ORDER BY id DESC LIMIT 1").fetchone()
    assert row is not None
    assert row[0] == "US_PRE"
 def test_log_trade_auto_derives_session_id_when_not_provided() -> None:
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="005930",
        action="BUY",
        confidence=70,
        rationale="auto session",
        market="KR",
        exchange_code="KRX",
    )
    row = conn.execute("SELECT session_id FROM trades ORDER BY id DESC LIMIT 1").fetchone()
    assert row is not None
    assert row[0] != "UNKNOWN"
 def test_log_trade_unknown_market_falls_back_to_unknown_session() -> None:
    conn = init_db(":memory:")
    log_trade(
        conn=conn,
        stock_code="X",
        action="BUY",
        confidence=70,
        rationale="unknown market",
        market="MARS",
        exchange_code="MARS",
    )
    row = conn.execute("SELECT session_id FROM trades ORDER BY id DESC LIMIT 1").fetchone()
    assert row is not None
    assert row[0] == "UNKNOWN"
--- a/tests/test_kill_switch.py
+++ b/tests/test_kill_switch.py
@@ -0,0 +1,55 @@
 import pytest
 from src.core.kill_switch import KillSwitchOrchestrator
@pytest.mark.asyncio
 async def test_kill_switch_executes_steps_in_order() -> None:
    ks = KillSwitchOrchestrator()
    calls: list[str] = []
    async def _cancel() -> None:
        calls.append("cancel")
    def _refresh() -> None:
        calls.append("refresh")
    def _reduce() -> None:
        calls.append("reduce")
    def _snapshot() -> None:
        calls.append("snapshot")
    def _notify() -> None:
        calls.append("notify")
    report = await ks.trigger(
        reason="test",
        cancel_pending_orders=_cancel,
        refresh_order_state=_refresh,
        reduce_risk=_reduce,
        snapshot_state=_snapshot,
        notify=_notify,
    )
    assert report.steps == [
        "block_new_orders",
        "cancel_pending_orders",
        "refresh_order_state",
        "reduce_risk",
        "snapshot_state",
        "notify",
    ]
    assert calls == ["cancel", "refresh", "reduce", "snapshot", "notify"]
    assert report.errors == []
@pytest.mark.asyncio
 async def test_kill_switch_collects_step_errors() -> None:
    ks = KillSwitchOrchestrator()
    def _boom() -> None:
        raise RuntimeError("boom")
    report = await ks.trigger(reason="test", cancel_pending_orders=_boom)
    assert any(err.startswith("cancel_pending_orders:") for err in report.errors)
--- a/tests/test_main.py
+++ b/tests/test_main.py
--- a/tests/test_market_schedule.py
+++ b/tests/test_market_schedule.py
@@ -147,6 +147,24 @@ class TestGetOpenMarkets:
        codes = [m.code for m in open_markets]
        assert codes == sorted(codes)
    def test_get_open_markets_us_pre_extended_session(self) -> None:
        """US premarket should be considered open when extended sessions enabled."""
        # Monday 2026-02-02 08:30 EST = 13:30 UTC (premarket window)
        test_time = datetime(2026, 2, 2, 13, 30, tzinfo=ZoneInfo("UTC"))
        regular = get_open_markets(
            enabled_markets=["US_NASDAQ", "US_NYSE", "US_AMEX"],
            now=test_time,
        )
        assert regular == []
        extended = get_open_markets(
            enabled_markets=["US_NASDAQ", "US_NYSE", "US_AMEX"],
            now=test_time,
            include_extended_sessions=True,
        )
        assert {m.code for m in extended} == {"US_NASDAQ", "US_NYSE", "US_AMEX"}
 class TestGetNextMarketOpen:
    """Test get_next_market_open function."""
@@ -201,6 +219,20 @@ class TestGetNextMarketOpen:
        )
        assert market.code == "KR"
    def test_get_next_market_open_prefers_extended_session(self) -> None:
        """Extended lookup should return premarket open time before regular open."""
        # Monday 2026-02-02 07:00 EST = 12:00 UTC
        # By v3 KST session rules, US is OFF only in KST 07:00-10:00 (UTC 22:00-01:00).
        # At 12:00 UTC market is active, so next OFF->ON transition is 01:00 UTC next day.
        test_time = datetime(2026, 2, 2, 12, 0, tzinfo=ZoneInfo("UTC"))
        market, next_open = get_next_market_open(
            enabled_markets=["US_NASDAQ"],
            now=test_time,
            include_extended_sessions=True,
        )
        assert market.code == "US_NASDAQ"
        assert next_open == datetime(2026, 2, 3, 1, 0, tzinfo=ZoneInfo("UTC"))
 class TestExpandMarketCodes:
    """Test shorthand market expansion."""
--- a/tests/test_order_policy.py
+++ b/tests/test_order_policy.py
@@ -0,0 +1,40 @@
 from datetime import UTC, datetime
 import pytest
 from src.core.order_policy import OrderPolicyRejected, classify_session_id, validate_order_policy
 from src.markets.schedule import MARKETS
 def test_classify_kr_nxt_after() -> None:
    # 2026-02-26 16:00 KST == 07:00 UTC
    now = datetime(2026, 2, 26, 7, 0, tzinfo=UTC)
    assert classify_session_id(MARKETS["KR"], now) == "NXT_AFTER"
 def test_classify_us_pre() -> None:
    # 2026-02-26 19:00 KST == 10:00 UTC
    now = datetime(2026, 2, 26, 10, 0, tzinfo=UTC)
    assert classify_session_id(MARKETS["US_NASDAQ"], now) == "US_PRE"
 def test_reject_market_order_in_low_liquidity_session() -> None:
    now = datetime(2026, 2, 26, 10, 0, tzinfo=UTC)  # 19:00 KST -> US_PRE
    with pytest.raises(OrderPolicyRejected):
        validate_order_policy(
            market=MARKETS["US_NASDAQ"],
            order_type="BUY",
            price=0.0,
            now=now,
        )
 def test_allow_limit_order_in_low_liquidity_session() -> None:
    now = datetime(2026, 2, 26, 10, 0, tzinfo=UTC)  # 19:00 KST -> US_PRE
    info = validate_order_policy(
        market=MARKETS["US_NASDAQ"],
        order_type="BUY",
        price=100.0,
        now=now,
    )
    assert info.session_id == "US_PRE"
--- a/tests/test_strategy_exit_rules.py
+++ b/tests/test_strategy_exit_rules.py
@@ -0,0 +1,38 @@
 from src.strategy.exit_rules import ExitRuleConfig, ExitRuleInput, evaluate_exit
 from src.strategy.position_state_machine import PositionState
 def test_hard_stop_exit() -> None:
    out = evaluate_exit(
        current_state=PositionState.HOLDING,
        config=ExitRuleConfig(hard_stop_pct=-2.0, arm_pct=3.0),
        inp=ExitRuleInput(current_price=97.0, entry_price=100.0, peak_price=100.0),
    )
    assert out.should_exit is True
    assert out.reason == "hard_stop"
 def test_take_profit_exit_for_backward_compatibility() -> None:
    out = evaluate_exit(
        current_state=PositionState.HOLDING,
        config=ExitRuleConfig(hard_stop_pct=-2.0, arm_pct=3.0),
        inp=ExitRuleInput(current_price=104.0, entry_price=100.0, peak_price=104.0),
    )
    assert out.should_exit is True
    assert out.reason == "arm_take_profit"
 def test_model_assist_exit_signal() -> None:
    out = evaluate_exit(
        current_state=PositionState.ARMED,
        config=ExitRuleConfig(model_prob_threshold=0.62, arm_pct=10.0),
        inp=ExitRuleInput(
            current_price=101.0,
            entry_price=100.0,
            peak_price=105.0,
            pred_down_prob=0.8,
            liquidity_weak=True,
        ),
    )
    assert out.should_exit is True
    assert out.reason == "model_liquidity_exit"
--- a/tests/test_strategy_state_machine.py
+++ b/tests/test_strategy_state_machine.py
@@ -0,0 +1,30 @@
 from src.strategy.position_state_machine import (
    PositionState,
    StateTransitionInput,
    promote_state,
 )
 def test_gap_jump_promotes_to_armed_directly() -> None:
    state = promote_state(
        PositionState.HOLDING,
        StateTransitionInput(
            unrealized_pnl_pct=4.0,
            be_arm_pct=1.2,
            arm_pct=2.8,
        ),
    )
    assert state == PositionState.ARMED
 def test_exited_has_priority_over_promotion() -> None:
    state = promote_state(
        PositionState.HOLDING,
        StateTransitionInput(
            unrealized_pnl_pct=5.0,
            be_arm_pct=1.2,
            arm_pct=2.8,
            hard_stop_hit=True,
        ),
    )
    assert state == PositionState.EXITED
--- a/tests/test_triple_barrier.py
+++ b/tests/test_triple_barrier.py
@@ -0,0 +1,131 @@
 from __future__ import annotations
 from src.analysis.triple_barrier import TripleBarrierSpec, label_with_triple_barrier
 def test_long_take_profit_first() -> None:
    highs = [100, 101, 103]
    lows = [100, 99.6, 100]
    closes = [100, 100, 102]
    spec = TripleBarrierSpec(take_profit_pct=0.02, stop_loss_pct=0.01, max_holding_bars=3)
    out = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=1,
        spec=spec,
    )
    assert out.label == 1
    assert out.touched == "take_profit"
    assert out.touch_bar == 2
 def test_long_stop_loss_first() -> None:
    highs = [100, 100.5, 101]
    lows = [100, 98.8, 99]
    closes = [100, 99.5, 100]
    spec = TripleBarrierSpec(take_profit_pct=0.02, stop_loss_pct=0.01, max_holding_bars=3)
    out = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=1,
        spec=spec,
    )
    assert out.label == -1
    assert out.touched == "stop_loss"
    assert out.touch_bar == 1
 def test_time_barrier_timeout() -> None:
    highs = [100, 100.8, 100.7]
    lows = [100, 99.3, 99.4]
    closes = [100, 100, 100]
    spec = TripleBarrierSpec(take_profit_pct=0.02, stop_loss_pct=0.02, max_holding_bars=2)
    out = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=1,
        spec=spec,
    )
    assert out.label == 0
    assert out.touched == "time"
    assert out.touch_bar == 2
 def test_tie_break_stop_first_default() -> None:
    highs = [100, 102.1]
    lows = [100, 98.9]
    closes = [100, 100]
    spec = TripleBarrierSpec(take_profit_pct=0.02, stop_loss_pct=0.01, max_holding_bars=1)
    out = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=1,
        spec=spec,
    )
    assert out.label == -1
    assert out.touched == "stop_loss"
 def test_short_side_inverts_barrier_semantics() -> None:
    highs = [100, 100.5, 101.2]
    lows = [100, 97.8, 98.0]
    closes = [100, 99, 99]
    spec = TripleBarrierSpec(take_profit_pct=0.02, stop_loss_pct=0.01, max_holding_bars=3)
    out = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=-1,
        spec=spec,
    )
    assert out.label == 1
    assert out.touched == "take_profit"
 def test_short_tie_break_modes() -> None:
    highs = [100, 101.1]
    lows = [100, 97.9]
    closes = [100, 100]
    stop_first = TripleBarrierSpec(
        take_profit_pct=0.02,
        stop_loss_pct=0.01,
        max_holding_bars=1,
        tie_break="stop_first",
    )
    out_stop = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=-1,
        spec=stop_first,
    )
    assert out_stop.label == -1
    assert out_stop.touched == "stop_loss"
    take_first = TripleBarrierSpec(
        take_profit_pct=0.02,
        stop_loss_pct=0.01,
        max_holding_bars=1,
        tie_break="take_first",
    )
    out_take = label_with_triple_barrier(
        highs=highs,
        lows=lows,
        closes=closes,
        entry_index=0,
        side=-1,
        spec=take_first,
    )
    assert out_take.label == 1
    assert out_take.touched == "take_profit"
--- a/tests/test_walk_forward_split.py
+++ b/tests/test_walk_forward_split.py
@@ -0,0 +1,92 @@
 from __future__ import annotations
 import pytest
 from src.analysis.walk_forward_split import generate_walk_forward_splits
 def test_generates_sequential_folds() -> None:
    folds = generate_walk_forward_splits(
        n_samples=30,
        train_size=10,
        test_size=5,
    )
    assert len(folds) == 4
    assert folds[0].train_indices == list(range(0, 10))
    assert folds[0].test_indices == list(range(10, 15))
    assert folds[1].train_indices == list(range(5, 15))
    assert folds[1].test_indices == list(range(15, 20))
 def test_purge_removes_boundary_samples_before_test() -> None:
    folds = generate_walk_forward_splits(
        n_samples=25,
        train_size=8,
        test_size=4,
        purge_size=2,
    )
    first = folds[0]
    # test starts at 10, purge=2 => train end must be 7
    assert first.train_indices == list(range(0, 8))
    assert first.test_indices == list(range(10, 14))
 def test_embargo_excludes_post_test_samples_from_next_train() -> None:
    folds = generate_walk_forward_splits(
        n_samples=45,
        train_size=15,
        test_size=5,
        step_size=10,
        embargo_size=3,
    )
    assert len(folds) >= 2
    # Fold1 test: 15..19, next fold train window: 10..24.
    # embargo_size=3 should remove 20,21,22 from fold2 train.
    second_train = folds[1].train_indices
    assert 20 not in second_train
    assert 21 not in second_train
    assert 22 not in second_train
    assert 23 in second_train
 def test_respects_min_train_size_and_returns_empty_when_impossible() -> None:
    folds = generate_walk_forward_splits(
        n_samples=15,
        train_size=5,
        test_size=5,
        min_train_size=6,
    )
    assert folds == []
 def test_embargo_uses_last_accepted_fold_when_intermediate_fold_skips() -> None:
    folds = generate_walk_forward_splits(
        n_samples=30,
        train_size=5,
        test_size=3,
        step_size=5,
        embargo_size=1,
        min_train_size=5,
    )
    # 1st fold accepted, 2nd skipped by min_train_size, subsequent folds still generated.
    assert len(folds) == 3
    assert folds[0].test_indices == [5, 6, 7]
    assert folds[1].test_indices == [15, 16, 17]
    assert folds[2].test_indices == [25, 26, 27]
@pytest.mark.parametrize(
    ("n_samples", "train_size", "test_size"),
    [
        (0, 10, 2),
        (10, 0, 2),
        (10, 5, 0),
    ],
 )
 def test_invalid_args_raise(n_samples: int, train_size: int, test_size: int) -> None:
    with pytest.raises(ValueError):
        generate_walk_forward_splits(
            n_samples=n_samples,
            train_size=train_size,
            test_size=test_size,
        )
--- a/workflow/issue-271-runlog.md
+++ b/workflow/issue-271-runlog.md
@@ -0,0 +1,37 @@
 # Issue #271 Workflow Run Log
 ## 2026-02-26
 ### Step 1: Gitea issue creation
 - Attempt 1: Succeeded, but formatting degraded
  - Command style: `tea issues create -t ... -d "...\n..."`
  - Symptom: Issue body rendered literal `\n` text in web UI instead of line breaks
 - Root cause
  - `tea` does not provide `--description-file`
  - Shell-escaped `\n` inside double quotes is passed as backslash+n text
 - Resolution
  - Build body with heredoc and pass as variable (`-d "$ISSUE_BODY"`)
 ### Step 2: PR description creation
 - Attempt 1: Succeeded, but same newline rendering risk detected
 - Resolution
  - Same heredoc variable pattern applied for PR body (`--description "$PR_BODY"`)
 ### Preventive Action
 - `docs/workflow.md` updated with "Gitea CLI Formatting Troubleshooting" section
 - Standard command templates added for issues and PRs
 ### Reusable Safe Template
 ```bash
 ISSUE_BODY=$(cat <<'EOF'
 ## Summary
 - item A
 - item B
 ## Scope
 - docs only
 EOF
 )
 tea issues create -t "title" -d "$ISSUE_BODY"
 ```
--- a/workflow/session-handover.md
+++ b/workflow/session-handover.md
@@ -0,0 +1,83 @@
 # Session Handover Log
 목적: 세션 시작 시 인수인계 확인을 기록하고, 구현/검증 작업 시작 전에 공통 컨텍스트를 강제한다.
 작성 규칙:
 - 세션 시작마다 최신 엔트리를 맨 아래에 추가한다.
 - `docs/workflow.md`, `docs/commands.md`, `docs/agent-constraints.md`를 먼저 확인한 뒤 기록한다.
 - 각 엔트리는 현재 작업 브랜치 기준으로 작성한다.
 템플릿:
 ```md
 ### YYYY-MM-DD | session=<id or short label>
 - branch: <current-branch>
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #...
 - next_ticket: #...
 - process_gate_checked: process_ticket=#..., merged_to_feature_branch=yes|no|n/a
 - risks_or_notes: ...
 ```
 ### 2026-02-27 | session=handover-gate-bootstrap
 - branch: feature/v3-session-policy-stream
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #304, #305, #306
 - next_ticket: #304
 - risks_or_notes: 세션 시작 게이트를 문서/스크립트/CI로 강제 적용
 ### 2026-02-27 | session=codex-handover-start
 - branch: feature/v3-session-policy-stream
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #306, #308, #309
 - next_ticket: #304
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: 미추적 로컬 파일 존재(문서/DB/lock)로 커밋 범위 분리 필요
 ### 2026-02-27 | session=codex-process-gate-hardening
 - branch: feature/issue-304-runtime-staged-exit-semantics
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #304, #305
 - next_ticket: #304
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: process-change-first 실행 게이트를 문서+스크립트로 강화
 ### 2026-02-27 | session=codex-handover-start-2
 - branch: feature/issue-304-runtime-staged-exit-semantics
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #304, #305
 - next_ticket: #304
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: handover 재시작 요청으로 세션 엔트리 추가, 미추적 산출물(AMS/NAS/NYS, DB, lock, xlsx) 커밋 분리 필요
 ### 2026-02-27 | session=codex-issue305-start
 - branch: feature/v3-session-policy-stream
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #305
 - next_ticket: #305
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: #305 구현을 위해 분석/백테스트 모듈 통합 경로 점검 시작
 ### 2026-02-27 | session=codex-issue305-ticket-branch
 - branch: feature/issue-305-backtest-pipeline-integration
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #305
 - next_ticket: #305
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: 티켓 브랜치 분기 후 strict gate 재통과를 위한 엔트리 추가
 ### 2026-02-27 | session=codex-backtest-gate-automation
 - branch: feature/v3-session-policy-stream
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #304, #305
 - next_ticket: (create) backtest automation gate
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: 백테스트 자동화 누락 재발 방지 위해 이슈/티켓 브랜치/PR 절차로 즉시 정규화
 ### 2026-02-27 | session=codex-issue314-ticket-branch
 - branch: feature/issue-314-backtest-gate-automation
 - docs_checked: docs/workflow.md, docs/commands.md, docs/agent-constraints.md
 - open_issues_reviewed: #314
 - next_ticket: #314
 - process_gate_checked: process_ticket=#306,#308 merged_to_feature_branch=yes
 - risks_or_notes: 백테스트 자동 게이트 도입 티켓 브랜치 strict gate 통과용 엔트리
Author	SHA1	Message	Date
agentson	0542e78f90	Merge pull request 'process: automate backtest gate for PR/push/schedule (#314 )' (#315 ) from feature/issue-314-backtest-gate-automation into feature/v3-session-policy-stream Some checks are pending Gitea CI / test (push) Waiting to run Details	2026-02-28 03:25:45 +09:00
agentson	8396dc1606	process: automate backtest gate for PR/push/schedule (#314 ) Some checks are pending Gitea CI / test (push) Waiting to run Details Gitea CI / test (pull_request) Waiting to run Details	2026-02-28 03:25:00 +09:00
agentson	343631a935	Merge pull request 'feat: integrate v2 backtest validation pipeline (#305 )' (#313 ) from feature/issue-305-backtest-pipeline-integration into feature/v3-session-policy-stream Some checks failed Gitea CI / test (push) Has been cancelled Details	2026-02-27 23:59:34 +09:00
agentson	c00525eb4d	feat: integrate v2 backtest pipeline for triple barrier and walk-forward (#305 ) Some checks are pending Gitea CI / test (push) Waiting to run Details Gitea CI / test (pull_request) Waiting to run Details	2026-02-27 23:58:52 +09:00
agentson	1ae12f92f6	Merge pull request 'fix: runtime staged exit semantics in trading_cycle and run_daily_session (#304 )' (#312 ) from feature/issue-304-runtime-staged-exit-semantics into feature/v3-session-policy-stream Some checks failed Gitea CI / test (push) Has been cancelled Details	2026-02-27 23:49:59 +09:00
agentson	98dab2e06e	fix: apply staged exit semantics in runtime paths (#304 ) Some checks are pending Gitea CI / test (push) Waiting to run Details Gitea CI / test (pull_request) Waiting to run Details	2026-02-27 23:48:52 +09:00
agentson	a63d23fab9	Merge pull request 'process: harden implementation-start gate before coding (#310 )' (#311 ) from feature/issue-310-implementation-start-gate into feature/v3-session-policy-stream Some checks failed Gitea CI / test (push) Has been cancelled Details	2026-02-27 23:24:40 +09:00
agentson	85a59542f8	process: harden implementation-start gate before coding Some checks are pending Gitea CI / test (push) Waiting to run Details Gitea CI / test (pull_request) Waiting to run Details	2026-02-27 23:21:54 +09:00
agentson	5830791355	Merge pull request 'process: enforce session handover gate across sessions (#308 )' (#309 ) from feature/issue-308-session-handover-gate into feature/v3-session-policy-stream Some checks failed Gitea CI / test (push) Has been cancelled Details	2026-02-27 23:09:04 +09:00
agentson	b1610f14c5	process: enforce session handover gate across sessions (#308 ) Some checks are pending Gitea CI / test (push) Waiting to run Details Gitea CI / test (pull_request) Waiting to run Details	2026-02-27 23:08:29 +09:00
agentson	1984065499	Merge pull request 'process: enforce process-change-first and staged acceptance gates (#306 )' (#307 ) from feature/issue-306-process-change-first into feature/v3-session-policy-stream	2026-02-27 22:46:33 +09:00
agentson	d912471d0e	process: enforce process-change-first and staged ticket maturity (#306 )	2026-02-27 22:46:18 +09:00
agentson	5f337e2ebc	Merge pull request 'fix: realtime include extended KR/US sessions (#301 )' (#303 ) from feature/issue-301-extended-session-schedule into feature/v3-session-policy-stream	2026-02-27 22:30:26 +09:00
agentson	4a404875a9	fix: include extended KR/US sessions in realtime market scheduling (#301 )	2026-02-27 22:30:13 +09:00
agentson	cdd3814781	Merge pull request 'governance: enforce runtime NOT_OBSERVED recovery gates (#301 )' (#302 ) from feature/issue-301-runtime-verify-recovery into feature/v3-session-policy-stream	2026-02-27 22:14:03 +09:00
agentson	dbf57b5068	governance: enforce runtime verification coverage gates (#301 )	2026-02-27 22:13:11 +09:00
agentson	7efc254ab5	Merge pull request '[RISK-EMERGENCY] TKT-P1-008 오버나잇 예외 vs Kill Switch 우선순위' (#300 ) from feature/issue-tkt-p1-008-overnight-killswitch-priority into feature/v3-session-policy-stream	2026-02-27 08:57:25 +09:00
agentson	2742628b78	feat: prioritize kill-switch over overnight exception policy (TASK-CODE-012)	2026-02-27 08:55:24 +09:00
agentson	d60fd8947b	Merge pull request '[EXEC-POLICY] TKT-P1-007 session_id 로그 원장 강제' (#298 ) from feature/issue-tkt-p1-007-session-id-ledger into feature/v3-session-policy-stream	2026-02-27 08:51:27 +09:00
agentson	694d73b212	fix: lazy session resolver and one-time session_id backfill	2026-02-27 08:51:00 +09:00
agentson	b2b02b6f57	feat: enforce session_id persistence in trade ledger (TASK-CODE-007)	2026-02-27 08:49:04 +09:00
agentson	2dbe98615d	Merge pull request '[FX-ACCOUNTING] TKT-P1-006 전략/환율 PnL 분리 회계' (#296 ) from feature/issue-tkt-p1-006-fx-pnl-separation into feature/v3-session-policy-stream	2026-02-27 08:46:56 +09:00
agentson	34cf081c96	fix: backfill split pnl migration and harden partial pnl inputs	2026-02-27 08:46:22 +09:00
agentson	7bc4e88335	feat: separate strategy and fx pnl fields in trade logs (TASK-CODE-011)	2026-02-27 08:44:05 +09:00
agentson	386e039ff6	Merge pull request '[BACKTEST-MODEL] TKT-P1-005 보수적 체결 모델 구현' (#294 ) from feature/issue-tkt-p1-005-conservative-fill-model into feature/v3-session-policy-stream	2026-02-27 08:42:22 +09:00
agentson	13ba9e8081	fix: validate execution assumption ranges in backtest model	2026-02-27 08:41:56 +09:00
agentson	5b52f593a8	feat: add conservative backtest execution simulator (TASK-CODE-010)	2026-02-27 08:40:23 +09:00
agentson	2798558bf3	Merge pull request '[BACKTEST-MODEL] TKT-P1-002 백테스트 비용/슬리피지 옵션 필수화' (#292 ) from feature/issue-tkt-p1-002-backtest-cost-mandatory into feature/v3-session-policy-stream	2026-02-27 08:37:15 +09:00
agentson	2331d80915	fix: reject non-finite backtest cost assumptions	2026-02-27 08:36:38 +09:00
agentson	7d72669cb8	feat: enforce mandatory backtest cost assumptions (TASK-CODE-006)	2026-02-27 08:34:44 +09:00
agentson	74a4784b7a	Merge pull request '[BACKTEST-MODEL] TKT-P1-004 Walk-forward + Purge/Embargo 분할 유틸' (#290 ) from feature/issue-tkt-p1-004-walkforward-purge-embargo into feature/v3-session-policy-stream	2026-02-27 08:33:01 +09:00
agentson	dc70311aed	fix: keep embargo tied to accepted folds and enforce PR-comment decision logs	2026-02-27 08:32:09 +09:00
agentson	e56819e9e2	feat: add walk-forward splitter with purge and embargo controls (TASK-CODE-005)	2026-02-27 08:28:11 +09:00
agentson	cfd5351b58	Merge pull request '[FX-ACCOUNTING] TKT-P1-001 USD/KRW 버퍼 진입 제한' (#288 ) from feature/issue-tkt-p1-001-fx-buffer-guard into feature/v3-session-policy-stream	2026-02-27 00:53:21 +09:00
agentson	b206c23fc9	fix: scope USD buffer guard to US markets and add boundary tests	2026-02-27 00:52:44 +09:00
agentson	4d9f3e2cfc	feat: enforce overseas buy guard with USD buffer threshold (TASK-V3-014)	2026-02-27 00:50:12 +09:00
agentson	a93a5c616b	Merge pull request '[BACKTEST-MODEL] TKT-P1-003 Triple Barrier 라벨러 구현' (#286 ) from feature/issue-tkt-p1-003-triple-barrier-labeler into feature/v3-session-policy-stream	2026-02-27 00:47:37 +09:00
agentson	9f64c9944a	fix: correct short-side tie-break semantics in triple barrier	2026-02-27 00:47:09 +09:00
agentson	bb391d502c	feat: add triple barrier labeler with first-touch logic (TASK-CODE-004)	2026-02-27 00:45:18 +09:00
agentson	b0100fde10	Merge pull request '[RISK-EMERGENCY][SCN-FAIL-003] TKT-P0-002 Kill Switch 순서 강제 검증 자동화' (#284 ) from feature/issue-tkt-p0-002-killswitch-ordering into feature/v3-session-policy-stream	2026-02-27 00:42:16 +09:00
agentson	0a4e69d40c	fix: record kill switch cancel failures and add failure-path tests	2026-02-27 00:41:13 +09:00
agentson	25401ac132	feat: enforce operational kill switch callbacks in runtime flow (TASK-CODE-003)	2026-02-27 00:38:26 +09:00
agentson	1381b140ab	Merge pull request '[EXEC-POLICY][SCN-FAIL-001] TKT-P0-001 블랙아웃 차단/큐/복구 재검증' (#282 ) from feature/issue-tkt-p0-001-blackout-queue-revalidate into feature/v3-session-policy-stream	2026-02-27 00:32:59 +09:00
agentson	356d085ab0	feat: implement blackout queue and recovery revalidation (TASK-CODE-008)	2026-02-27 00:31:29 +09:00
agentson	54d6cc3d7c	Merge pull request 'docs: feature-branch 팀 운영 규칙 및 모니터링 검증 게이트 반영 (#279 )' (#280 ) from feature/issue-279-session-order-policy-guard into feature/v3-session-policy-stream	2026-02-27 00:19:55 +09:00
agentson	3ffad58d57	docs: allow ticket->feature merges without user approval; keep main gated (#279 )	2026-02-27 00:19:51 +09:00
agentson	df6baee7f1	feat: add session-aware order policy guard for low-liquidity market-order rejection (#279 )	2026-02-27 00:13:47 +09:00
agentson	c31a6a569d	docs: enforce feature-branch team flow and mandatory runtime monitoring validation (#279 )	2026-02-27 00:05:01 +09:00
agentson	990f9696ab	Merge pull request 'docs: TPM 티켓 우선순위/메인 아이디에이션/무머지 세션 규칙 반영 (#277 )' (#278 ) from feature/issue-277-tpm-priority-main-ideation-no-merge-session into main Some checks failed CI / test (push) Has been cancelled Details	2026-02-26 23:58:03 +09:00
agentson	9bf72c63ec	docs: clarify no-merge-by-default server reflection rule (#277 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:57:58 +09:00
agentson	1399fa4d09	docs: enforce TPM ticket ownership and add main-agent ideation backlog (#277 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:56:25 +09:00
agentson	f63fb53289	Merge pull request 'feat: phase1 상태기계/청산엔진/kill-switch 구현 (#275 )' (#276 ) from feature/issue-275-phase1-state-exit-killswitch into main Some checks failed CI / test (push) Has been cancelled Details	2026-02-26 23:46:11 +09:00
agentson	5050a4cf84	fix: address reviewer feedback for kill-switch enforcement and observability (#275 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:46:02 +09:00
agentson	4987b6393a	feat: implement phase1 state machine, composite exits, and kill-switch orchestration (#275 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:22:58 +09:00
jihoson	8faf974522	Merge pull request 'docs: multi-agent governance 운영 체계 반영 (#273 )' (#274 ) from feature/issue-273-multi-agent-governance-docs into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #274	2026-02-26 23:19:11 +09:00
agentson	d524159ad0	docs: add runtime verifier role and replan escalation protocol (#273 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:16:44 +09:00
agentson	c7c740f446	docs: add repository enforcement checklist for strict governance (#273 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:08:16 +09:00
agentson	1333c65455	docs: add PM/TPM governance artifacts for multi-agent control (#273 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 23:06:51 +09:00
jihoson	9db7f903f8	Merge pull request 'docs: ouroboros 실행 지시서/검증 시스템 반영 (#271 )' (#272 ) from feature/issue-271-docs-routing-validation into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #272	2026-02-26 22:56:17 +09:00
agentson	4660310ee4	docs: add tea newline troubleshooting and runlog (#271 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 22:52:56 +09:00
agentson	c383a411ff	docs: add ouroboros execution routing and validation system (#271 ) Some checks failed CI / test (pull_request) Has been cancelled Details	2026-02-26 22:49:21 +09:00
jihoson	7b3ba27ef7	Merge pull request 'fix: 해외 매수가능금액 ord_psbl_frcr_amt → ovrs_ord_psbl_amt 교체 (#269 )' (#270 ) from feature/issue-269-overseas-cash-ovrs-ord-psbl-amt into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #270	2026-02-26 02:01:57 +09:00
agentson	6ff887c047	fix: 해외 매수가능금액 ord_psbl_frcr_amt → ovrs_ord_psbl_amt 교체 (#269 ) Some checks failed CI / test (pull_request) Has been cancelled Details 외화 예수금만 반영하는 ord_psbl_frcr_amt 대신 미결제 매도 대금(sll_ruse_psbl_amt)을 포함하는 ovrs_ord_psbl_amt (앱 '외화' 기준 통합 주문가능금액)를 사용하도록 수정. 실제 API 응답 확인: ord_psbl_frcr_amt = $139.25 (외화 예수금만) sll_ruse_psbl_amt = $7292.70 (미결제 매도 대금) ovrs_ord_psbl_amt = $7391.30 (합산, 원화 미포함) 원화 환산(frcr_ord_psbl_amt1)은 요구사항에 따라 사용하지 않음. 출처: KIS 공식문서(20260221) '해외주식 매수가능금액조회' 시트. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>	2026-02-26 02:01:13 +09:00
jihoson	219eef6388	Merge pull request 'fix: 로그 WARNING 2종 수정 - scanner 오해 메시지 및 홀딩 종목 rsi 누락 (#267 )' (#268 ) from feature/issue-267-fix-log-warnings into main Some checks failed CI / test (push) Has been cancelled Details Reviewed-on: #268	2026-02-26 01:46:43 +09:00