docs: architecture diagram (PNG + matplotlib generator)

End-to-end map: external services → providers/news layer → signal core
(engine + factory + aggregator) → SignalReport → four delivery surfaces,
plus the backtester replaying the same core. Regenerate with
venv/bin/python docs/architecture_diagram.py after architecture changes.

Claude-Session: https://claude.ai/code/session_01Aq1jZ6jBsBdEC2xT3u46SA

CLAUDE.md

@@ -4,17 +4,17 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## What this is
 
-Signal-intelligence platform for **XAU/USD (gold — the only supported pair)**. It fetches OHLCV from the active data provider (**Oanda v20 since 2026-07-28**; Twelve Data and Tiingo remain registered fallbacks), scores 9 technical indicators per timeframe with regime-adaptive weights, checks multi-timeframe agreement and news risk, grades the signal (A+…F), and generates a full trade setup (entry, SL, TP1/TP2, trailing plan). Delivery: Telegram bot and CLI. A realism-focused backtester replays history through the *exact same* signal code.
+Signal-intelligence platform for **XAU/USD (gold — the only supported pair)**. It fetches OHLCV from the active data provider (**Oanda v20 since 2026-07-28**; Twelve Data and Tiingo remain registered fallbacks), scores 9 technical indicators per timeframe with regime-adaptive weights, checks multi-timeframe agreement and news risk, grades the signal (A+…F), and generates a full trade setup (entry, SL, TP1/TP2, trailing plan). Delivery: Telegram bot, CLI, and an Oanda practice-account auto-execution daemon. A realism-focused backtester replays history through the *exact same* signal code.
 
 Every numeric threshold in `config.py` and `pair_signals/xauusd.py` was backtested or is load-bearing for a backtested result. Validation evidence lives in the factory/module docstrings and in `~/.claude/projects/.../memory/`.
 
 ## Commands
 
 ```bash
-python test_all.py                      # QA suite: 414 tests, 27 modules, no network (mocked)
+python test_all.py                      # QA suite: 359 tests, 22 modules, no network (mocked)
-python main.py --pair XAUUSD --timeframe H1 --detail   # CLI signal report (--json for full dump,
+python main.py --pair XAUUSD --timeframe H1 --detail   # CLI signal report (--json for full dump)
-                                        #  --panel to run the advisory LLM agent panel on-demand)
 python telegram_bot.py                  # the bot (refuses to boot without credentials)
+python oanda_daemon.py                  # auto-execution daemon on Oanda practice account
 python dashboard_publisher.py --once    # web dashboard: one scan+publish cycle to $DASHBOARD_OUT_DIR
                                         # (omit --once for the candle-close daemon; deploy/README-dashboard.md)
 
@@ -28,13 +28,13 @@ python backtest/gpu_backtest.py --pair XAUUSD --start 2025-01-01 --end 2025-06-0
 #            2026-08-05: NOT shipped — backtest/research/fixedtp_2026-08-05.md)
 ```
 
-**`test_all.py` is NOT pytest** — it uses a custom `@test("name")` decorator that runs each test immediately at import; don't grep for `def test_` or try `pytest test_all.py`. Run the whole file; it prints per-module results and exits non-zero on failure. There is no way to run a single test short of commenting modules out. Tests must stay green; every new gate/knob needs tests. Signal-log fixtures: use a WEEKDAY signal bar when a test exercises candle continuity — the outcome model treats weekend and 21:00 UTC gaps as scheduled, so Saturday-dated bars never produce a gap. `_candles_json` stores `df.tail(14)`, so a test snapshot longer than 14 bars silently drops its head. When patching weekend logic in tests, patch `providers.base._is_forex_weekend` — but know there are THREE independent signal-path weekend implementations (`providers/base.py`, `signal_aggregator.py`, and an inline copy in `backtest/gpu_backtest.py:_is_xau_blocked_by_calendar`) plus the advisory-only continuity copy in `advisory_outcome.py`; patching one does not reach the others.
+**`test_all.py` is NOT pytest** — it uses a custom `@test("name")` decorator that runs each test immediately at import; don't grep for `def test_` or try `pytest test_all.py`. Run the whole file; it prints per-module results and exits non-zero on failure. There is no way to run a single test short of commenting modules out. Tests must stay green; every new gate/knob needs tests. When patching weekend logic in tests, patch `providers.base._is_forex_weekend` — but know there are THREE independent weekend implementations (`providers/base.py`, `signal_aggregator.py`, and an inline copy in `backtest/gpu_backtest.py:_is_xau_blocked_by_calendar`); patching the provider one does not reach the other two.
 
 Python 3.12; a `venv/` exists in-repo. Dependencies in `requirements.txt` (numpy, pandas, requests, twelvedata, python-telegram-bot ≥20, websockets).
 
 ## Configuration & credentials
 
-Precedence for every credential/deployment setting: **env var → config.json → refuse to run** (no hardcoded fallbacks). A gitignored repo-root `.env` is loaded at `app_config` import via `os.environ.setdefault`. `config.json` (gitignored; schema in `config.json.example`) holds secrets plus deployment settings: `data_providers.active` (the live-feed switch), `data_providers.streaming` (optional tick-stream provider for the level-breach monitor), `scanning.pairs`/`timeframes`, per-pair `blocked_hours_utc`, `log_level`. Key env vars: `TELEGRAM_TOKEN`, `TELEGRAM_CHAT_ID`, `TELEGRAM_CHANNEL_ID`, `TWELVE_DATA_API_KEY`, `TIINGO_API_KEY`, `OANDA_ACCOUNT_ID`/`OANDA_API_TOKEN`/`OANDA_BASE_URL`, `DEEPSEEK_API_KEY` (news LLM; the `deepseek` config.json block holds model/enabled/timeout/daily cap). The `agent_panel` config.json block (all-defaults = feature dark) controls the advisory LLM agent panel: `enabled`, per-surface `telegram`/`dashboard` toggles, `min_quality`, `max_panels_per_day`, `reuse_ttl_seconds`, plus the technical-payload enrichment knobs `candles_enabled`/`candle_bars_primary`/`candle_bars_confirm`. The dark-by-default `market_outlook` block controls the hourly advisory market brief: `enabled`, `telegram`, `max_per_day`, `candles_bars`; `MARKET_OUTLOOK_ENABLED` overrides its enabled setting.
+Precedence for every credential/deployment setting: **env var → config.json → refuse to run** (no hardcoded fallbacks). A gitignored repo-root `.env` is loaded at `app_config` import via `os.environ.setdefault`. `config.json` (gitignored; schema in `config.json.example`) holds secrets plus deployment settings: `data_providers.active` (the live-feed switch), `data_providers.streaming` (optional tick-stream provider for the level-breach monitor), `scanning.pairs`/`timeframes`, per-pair `blocked_hours_utc`, `log_level`. Key env vars: `TELEGRAM_TOKEN`, `TELEGRAM_CHAT_ID`, `TELEGRAM_CHANNEL_ID`, `TWELVE_DATA_API_KEY`, `TIINGO_API_KEY`, `OANDA_ACCOUNT_ID`/`OANDA_API_TOKEN`/`OANDA_BASE_URL`, `DEEPSEEK_API_KEY` (news LLM; the `deepseek` config.json block holds model/enabled/timeout/daily cap).
 
 ## Architecture
 
@@ -47,7 +47,7 @@ providers/<active>.fetch_ohlcv()       per TF: single-flight fetch, drop forming
   → signal_aggregator.analyze_pair()   live entry point (weekend/day filters, fetch, staleness)
       └─ analyze_from_dataframes()     replayable core: MTF agreement → news → bonuses/penalties →
                                        final signal + quality grade → gates → trade setup → reasons
-  → SignalReport                       consumed by telegram_bot.py, main.py, backtester
+  → SignalReport                       consumed by telegram_bot.py, main.py, oanda_daemon.py, backtester
 ```
 
 Signal currency everywhere is `SignalStrength` (−2..+2). DataFrames are UTC tz-aware, oldest-first, capitalized OHLCV columns. Everything runs on **closed bars only** — the forming candle is dropped, and session/hour filters evaluate **bar-CLOSE time** (bar label + candle duration) identically in live and backtest.
@@ -57,18 +57,16 @@ Signal currency everywhere is `SignalStrength` (−2..+2). DataFrames are UTC tz
 - **`providers/`** — one class per provider subclassing `BaseDataProvider` (`providers/base.py`), which owns everything the pipeline depends on: TTL+boundary cache, forming-candle drop, freshness check, validate/clean, paginated `fetch_range` (feeds the backtester from any provider), optional tick streaming. Subclasses implement only `_fetch_raw` + symbol/interval maps. Registry + `make_data_provider(config, name=None)` in `providers/__init__.py`; config.json `data_providers.active` selects the live candle feed and the optional `data_providers.streaming` scalar selects a different provider for the tick stream. A test enforces that subclasses don't override shared base methods (`supports_streaming`/`iter_ticks` are the sanctioned streaming override points). Tiingo streams mid-price ticks (`wss://api.tiingo.com/fx`) — do not re-add spread display from its free FX feed (two-tier indicative quotes, removed 2026-07-23); the no-spread rule extends to the WS stream.
 - **`engine.py`** — `TechnicalEngine`: 9 scored indicators (ema_trend, rsi, macd, bollinger, adx, roc, keltner, divergence, candlestick) + ATR as context. Regime classification (trending_up/down, `trending` = mixed/direction-UNKNOWN, transitioning, ranging) drives per-indicator weight multipliers and regime-aware RSI reinterpretation. Compute order matters (ATR first; MACD always computed even when not a pillar — divergence needs the histogram). Private series ride on the result as `_underscore` attrs; scorers/formatters skip anything `_`-prefixed or weight-0.
 - **`signal_aggregator.py`** — MTF agreement, diminishing-decay penalty system, exhaustion hard block, quality grading, then an ordered chain of post-grade gates (session, XAU SELL quality/vol/hour, regime blocks, M5 noise gates), then three setup generators: XAU ATR (A+/A), generic swing-based, plus the M5 pullback (`XAU_PB`) and chart-pattern (`XAU_CP`, `chart_patterns.py`) entry paths. The PB/CP generators run AFTER the gate chain and force quality to "B"; the CP path deliberately accepts grade-F composites and re-checks only session/day/big-candle (via warning prefixes) plus its own SELL/vol/RSI gates — it does NOT re-check exhaustion or the M5 min-score/MTF gates. **This is validated behavior, not a bug** (2026-08-04 audit: 226/586 trades in the shipped M5 12mo book are XAU_CP, +38.9R, 104 of them exhaustion-flagged and net-positive) — changing it is a rule-1 revalidation event. `TradeSetup.strategy` selects trailing params; trail params are stamped on the setup from the *producing* config so per-TF overrides reach formatters.
-- **`pair_signals/`** — per-pair config factories. **Always use the factory (`produce_signal` / `make_config`), never bare `PlatformConfig()`** — the factory applies the config.json overlay first, then the validated per-TF deltas (M5 hour-9 block, M15 trail arm 0.70, M15 SELL-hour block, M5 SELL-in-transitioning block, H1 all-shorts block (2026-09-03), etc.; evidence in the docstring). A test enforces factory ≡ inline-config equivalence. Confirmation map: M5→[M15,H1], M15→[M5,H1], H1→[M15,H4], H4→[H1,D1].
+- **`pair_signals/`** — per-pair config factories. **Always use the factory (`produce_signal` / `make_config`), never bare `PlatformConfig()`** — the factory applies the config.json overlay first, then the validated per-TF deltas (M5 hour-9 block, M15 trail arm 0.70, M15 SELL-hour block, etc.; evidence in the docstring). A test enforces factory ≡ inline-config equivalence. Confirmation map: M5→[M15,H1], M15→[M5,H1], H1→[M15,H4], H4→[H1,D1].
-- **`signal_log.py` / `advisory_outcome.py`** — SQLite signal-history logger (stdlib only). Hooked into `SignalAggregator.analyze_pair` only (the live entry point — the backtester never writes here, preserving parity), so every live scan from every surface (Telegram `telegram`, CLI `cli`, dashboard `dashboard`) lands one row in `logs/signals.db`: signal/grade/price, MTF + trade-setup + reasons JSON, full per-TF indicator snapshots, the last 14 closed OHLCV candles per fetched TF, and the news at scan time (event risk + calendar events + scored headlines, re-fetched via the NewsEngine class-level caches). Config.json `signal_log` block (`enabled`, `path`, `log_blocked_scans`; env `SIGNAL_LOG_ENABLED`/`SIGNAL_LOG_PATH`/`SIGNAL_LOG_BLOCKED_SCANS`). **Fail-safe by contract** — a logging failure can never break a scan. Panel fields arrive post-hoc: `log_signal` stashes the rowid and `agent_panel.attach_panel` writes verdict + creation/cache provenance + payload hash onto the same row. **Advisory outcomes (2026-09):** EVERY row with a trade setup is seeded at log time (not only panel rows); same-setup re-logs within 60 min from any surface (`setup_key` = tf|direction|entry|stop|strategy) are `DUPLICATE` rows pointing at the canonical row via `advisory_event_id`, so sum `advisory_r_multiple` over `RESOLVED` rows only. The versioned model advances from later stored closed-candle snapshots (next-open reanchoring, intrabar peak with close-only ratchet, SL-first, scheduled weekend/21:00-UTC closures allowed, 300-bar timeout, $0.30/$0.65 views); when a snapshot no longer overlaps the outcome's last bar it rebuilds the stream from every stored snapshot of that TF before giving up. It is a cleaned-mid evidence model, not execution P&L. **Post-gate truth columns:** `gate_reason` (the warning that removed the setup), `actionable` (grade ≥ C AND setup — the `action` text is written BEFORE the gate chain and can say "STRONG SELL — High-quality setup" on a D row), `cleaned_warnings_json` (what the XAU_CP acceptance stripped), `bar_range_median` (= the misnamed `spread` column: median High-Low, NOT a broker spread), `scan_kind` (`blocked` weekend/day early returns carry no news/candles), `config_fingerprint` (gate config hash — surfaces config drift between processes). **News is content-addressed:** `headlines_json`/`events_json` are interned into `news_snapshots` (they were 73% of a 667 MB DB); read through the `signals_with_news` view or `signal_log.read_news`. Readers must open with `mode=ro`, never `immutable=1` (blind to WAL rows). Tools: `analyze_signal_log.py` (`--stored-candles` DB-only replay with event/opportunity/one-position books + persona scorecard, `--news` news-sentiment lead/lag + extremes + outcome buckets, `--parity` telegram-vs-dashboard divergence report), `scripts/backfill_signal_outcomes.py` (seed/dedup/advance legacy rows), `scripts/migrate_signal_log_news.py` (intern legacy blobs; `--vacuum` with both writers stopped).
+- **`news_engine.py`** — Forex Factory calendar (MyFXBook RSS fallback) + RSS keyword sentiment with gold-inverse keywords. Class-level caches (fresh engine per scan). Optional DeepSeek enrichment via `llm_client.py` (requests-only, no SDK): batched headline sentiment overriding keyword scores, gold-direction on release surprises, and a market-summary blurb (`SignalReport.news_summary`) — **display/warning-only, keyword fallback on any failure, inert without a key**; prompts are static module constants (DeepSeek prefix-cache pricing) and requests send `thinking: disabled` (V4-Flash reasoning otherwise blows the timeout). By XAU-tuned default, event risk and sentiment **warn but do not gate signals** (`event_risk_caps_signals=False`, `sentiment_affects_signals=False`) — the LLM does not change that.
-- **`news_engine.py`** — Forex Factory calendar (MyFXBook RSS fallback) + RSS keyword sentiment with gold-inverse keywords. Class-level caches (fresh engine per scan). Optional DeepSeek enrichment via `llm_client.py` (requests-only, no SDK): batched headline sentiment overriding keyword scores, gold-direction on release surprises, and a market-summary blurb (`SignalReport.news_summary`) — **display/warning-only, keyword fallback on any failure, inert without a key**; prompts are static module constants (DeepSeek prefix-cache pricing) and requests send `thinking: disabled` (V4-Flash reasoning otherwise blows the timeout). By XAU-tuned default, event risk and sentiment **warn but do not gate signals** (`event_risk_caps_signals=False`, `sentiment_affects_signals=False`) — the LLM does not change that. **Headline pool (2026-09-04):** only headlines ≤ 4 h old with a parsable publish time (`headline_max_age_seconds=14400`, undated items dropped), and `get_fundamental_context` drops headlines whose every relevant score is inside ±0.1 (`_is_neutral_headline`, `NEUTRAL_HEADLINE_THRESHOLD`) before the per-currency mean — so `news_sentiment` from that date is a mean over directional headlines only (bolder values; log comparisons must split at the deploy date). The market summary prompt writes for someone who has never traded (no acronyms), sends headlines newest-first with the platform's own gold direction, and caps at 400 chars. **Verdict 2026-09-04** (`backtest/research/news_sentiment_value_2026-09-04.md`): `news_sentiment` is a trailing-24h echo of price (r≈0.67 with the past day, ≈0.03 with the next; flips 44 h after tops / 16 h after bottoms) — both gating flags stay False; re-check with `analyze_signal_log.py --stored-candles --news`.
+- **`telegram_bot.py`** — owner-locked bot + subscriber channel; candle-boundary auto-scan loops (M5/M15/H1/H4, boundary+10 s), alert quality threshold + fingerprint dedup (committed only after a successful send), 📰 LLM market-context line on alerts when available, WebSocket level-breach monitor fed by the streaming provider (`data_providers.streaming`, falling back to the active provider; auto-disabled when the resolved provider can't stream or has no API key — Oanda does not stream, Tiingo does). Rotating log: `logs/telegram.log`, 3-h rotation × 240 backups.
-- **`agent_panel.py`** — ai-hedge-fund-style advisory panel: 4 DeepSeek persona calls (macro/technical/risk/contrarian, concurrent on a panel-private pool) + 1 synthesizer producing an **ADVISORY-ONLY** consensus (`AGREE/NEUTRAL/OPPOSE` + confidence + rationale) written onto `SignalReport.panel_*` fields. Attached **post-hoc** by consumers (`telegram_bot` alert path, `main --panel`, `dashboard_publisher`) — never runs inside `analyze_from_dataframes` (backtest parity, test-locked) and no gate reads its fields. Persona payloads are role-filtered: macro gets high-impact events plus only code-scored directional news; technical gets strategy/pattern, primary indicators, MTF, levels, and ATR-normalized candles; risk gets setup strategy, strategy cost assumption, trailing semantics, volatility/events/warnings (never the median candle range as spread); contrarian gets directional news, setup, timestamped latest-closed price, indicators, reasons, and warnings. Spend is bounded by exact cache, full-evidence-identity TTL reuse, and `max_panels_per_day`; changed evidence never inherits a direction-only cached verdict (test-locked — which also means TTL reuse effectively never fires live because price/candles change every bar; the daily cap is the real spend bound). Verdict provenance logs creation time, `MISS`/`EXACT_HIT`/`TTL_REUSE`, and a SHA-256 payload hash. Prompts forbid outside knowledge and outputs remain short. **OPPOSE guard (2026-09):** the 3-week signal-log scorecard showed the contrarian/risk/technical personas oppose almost every trend entry (chair said OPPOSE 73% of the time; opposed trades made +30R, PF 2.6) while the macro persona was the only informative voice (macro=support → 88% win). `_apply_oppose_guard` therefore downgrades a chair OPPOSE to NEUTRAL unless macro opposes, or technical opposes while macro is not supportive; the synthesizer prompt states the same rule. Re-score with `analyze_signal_log.py --stored-candles` (persona scorecard) before changing it again. **Verdict source (2026-09-03, owner decision):** all four personas still run and are logged (`panel_takes_json`), but `agent_panel.verdict_source` defaults to `"macro"` — the alert verdict is the macro persona's stance (support/neutral/oppose → AGREE/NEUTRAL/OPPOSE) and the synthesizer call is skipped (4 LLM calls per panel instead of 5); `"chair"` restores the four-voice synthesizer + OPPOSE guard. Re-score personas monthly with `analyze_signal_log.py --stored-candles`; weights are not to be tuned before ~300 graded outcomes with a held-out half.
+- **`oanda_daemon.py` / `oanda_executor.py`** — practice-account auto-execution. Book-parity rules (see daemon docstring): no broker-side TP (trailing model — TP1/TP2 advisory), 5-bar per-TF cooldown (wall-clock approximation, so it expires over weekends where the backtester would still count bars), trail ratchets at bar close once per *observed* bar (a missed/failed cycle skips those bars entirely — the intra-gap high/low never enters the peak). Accepted divergence: one position total; orders send `positionFill=OPEN_ONLY` so a state/broker divergence cancels the order instead of silently netting. State/broker re-sync runs at boot and after any suspicious fill (`_reconcile_positions`).
-- **`market_outlook.py`** — hourly DeepSeek market brief for XAU/USD, using ATR-normalized M15/H1/H4 candles, visible indicator states, levels, news, and recent signal history (read `mode=ro`). It returns a written **ADVISORY-ONLY** bias/setup-forming assessment and persists it independently in `outlooks` within `logs/signals.db` together with the news, indicator/regime/level, and candle evidence sent to the model. It may be sent post-scan by Telegram or requested with `main.py --outlook`; it never imports or runs inside the signal path. Hourly dedup is by UTC hour BUCKET (the old `now − last < 3600` rule dropped every other hour because the H1 loop fires at boundary+10 s+scan time) plus its own UTC-day cap (default 12); every silent early return logs `market outlook: skipped (...)` and an empty LLM reply logs a warning — a dark feature must be visible in `logs/telegram.log`. Provider/news failures leave a safe partial brief while LLM/database failures degrade to no outlook.
+- **`dashboard_publisher.py` / `static/dashboard.html`** — web dashboard as a **static publisher** (live LAMP server): standalone daemon scans at candle closes via `produce_signal` and atomically writes `snapshot.json`/`news.json`/`dashboard.html` to `$DASHBOARD_OUT_DIR` (Apache serves them; page is public by owner decision). **Hard independence rule: never imports, and is never imported by, `telegram_bot`/`oanda_daemon`** — confirmation map and boundary math are deliberate local copies, so a web-side failure can only mean a stale page. Due-TF classification uses the RAW wake time (flooring wake−buffer skips every H1/H4 scan — 2026-08-02 bug). News panel reads `NewsEngine.get_fundamental_context()` plus the additive `get_week_events()` accessor (display-only; no signal path calls it); as a separate process it has its own news caches and DeepSeek daily cap. News/calendar rows are clickable (detail dialog); headlines carry `id` = sha1(headline) in news.json, and exactly one on-demand endpoint exists: `static/news_summary.php` (installed by `install_static`), which serves a DeepSeek gold-impact summary per headline — whitelist-gated against news.json ids, cache-forever in `ai/`, own fail-closed daily cap (150/day, file-based, separate from the publisher's), key at `/etc/gold-dashboard/deepseek.key`, never reads repo config. Deployment checklist: `deploy/README-dashboard.md`.
-- **`telegram_bot.py`** — owner-locked bot + subscriber channel; candle-boundary auto-scan loops (M5/M15/H1/H4, boundary+10 s), alert quality threshold + fingerprint dedup (committed only after a successful send; the fingerprint is signal+direction — grade is NOT part of it, a grade UPGRADE re-alerts, an A↔B flicker does not), 📰 LLM market-context line on alerts when available, WebSocket level-breach monitor fed by the streaming provider (`data_providers.streaming`, falling back to the active provider; auto-disabled when the resolved provider can't stream or has no API key — Oanda does not stream, Tiingo does). The breach handler reuses this bar's M15 report (`_cached_or_scan`, keyed by closed-bar epoch) instead of rescanning — it used to log 3.5 M15 rows per candle. Rotating log: `logs/telegram.log`, 3-h rotation × 240 backups.
-- **`dashboard_publisher.py` / `static/dashboard.html`** — web dashboard as a **static publisher** (live LAMP server): standalone daemon scans at candle closes via `produce_signal` and atomically writes `snapshot.json`/`news.json`/`dashboard.html` to `$DASHBOARD_OUT_DIR` (Apache serves them; page is public by owner decision). **Hard independence rule: never imports, and is never imported by, `telegram_bot`** — confirmation map and boundary math are deliberate local copies, so a web-side failure can only mean a stale page. Due-TF classification uses the RAW wake time (flooring wake−buffer skips every H1/H4 scan — 2026-08-02 bug). News panel reads `NewsEngine.get_fundamental_context()` plus the additive `get_week_events()` accessor (display-only; no signal path calls it); as a separate process it has its own news caches and DeepSeek daily cap. News/calendar rows are clickable (detail dialog); headlines carry `id` = sha1(headline) in news.json, and exactly one on-demand endpoint exists: `static/news_summary.php` (installed by `install_static`), which serves a DeepSeek gold-impact summary per headline — whitelist-gated against news.json ids, cache-forever in `ai/`, own fail-closed daily cap (150/day, file-based, separate from the publisher's), key at `/etc/gold-dashboard/deepseek.key`, never reads repo config. Deployment checklist: `deploy/README-dashboard.md`.
 - **`backtest/gpu_backtest.py`** — bar-by-bar replay through the real `analyze_from_dataframes` (news off). Realism model (do not regress): next-bar-open entries re-anchored to the raw price path, round-trip `--spread` charged per trade, trade resolution on RAW bars (cleaning applies only to signal-side data), same-bar SL+TP tie → SL first, gap fills at bar open, trail ratchet at bar close only. Indicators are precomputed once per TF (CuPy GPU or NumPy fallback — check the `Backend:` log line); replay fans out over worker processes and the 5-bar cooldown is applied in an ordered pass afterwards, so parallel and sequential books are identical. Parquet cache in `backtest/cache/` keyed by provider/symbol/TF/window. `backtest/*.csv` are gitignored pinned trade books from past campaigns — used for manual before/after comparison. `backtest/instructions_for_backtest.txt` lists what every backtest report must record.
 
 ## Rules for making changes (read before editing signal logic)
 
-1. **Never change a tuned value without re-validation.** Acceptance rule: positive total R in BOTH train and validation halves of a ≥12-month window, PF ≥ 1.3, at realistic cost (XAU $0.65 round trip headline; retain $0.30 for TD-era cross-book comparability), trailing exits, next-open fills. `round_trip_cost` stays $0.30 because it also drives the live TP spread gate; changing it is a separate rule-1 event. Marginal edges must additionally pass the 2024-06→2025-03 out-of-sample window — within-year splits alone have approved configs that later failed OOS.
+1. **Never change a tuned value without re-validation.** Acceptance rule: positive total R in BOTH train and validation halves of a ≥12-month window, PF ≥ 1.3, at realistic cost (XAU $0.30 round trip), trailing exits, next-open fills. Marginal edges must additionally pass the 2024-06→2025-03 out-of-sample window — within-year splits alone have approved configs that later failed OOS.
 2. **Per-timeframe overrides live in the pair factory**, never in global defaults — the same knob has opposite effects on different TFs (proven repeatedly: `tp_floor_rr`, hour-9 block, trail params). Document validation evidence in the factory docstring.
 3. **Pair isolation is a hard invariant.** XAU gates in the aggregator are display-name-gated so a future pair port cannot inherit gold-calibrated logic by accident.
 4. **Live == backtest parity.** If you add a live gate, add it to the replay path in the same commit; all time filters evaluate bar-close time in both paths.
@@ -80,17 +78,12 @@ Signal currency everywhere is `SignalStrength` (−2..+2). DataFrames are UTC tz
 
 ## 2026-08-04 QA audit — owner decisions ledger
 
-- **Weekend calendar: FIXED (owner-approved 2026-08-04).** All three signal-path `_is_forex_weekend` copies are NY-anchored (Fri 17:00 → Sun 18:00 ET; during US DST that is Fri 21:00 UTC — measured on 5yr of Oanda bars). Kills the weekly false-"STALE DATA/feed lagging" hours. Book impact at the audit HEAD: M15 byte-identical; M5 12mo dropped exactly ONE trade — a phantom whose signal fired on the final summer-Friday bar (close 21:00 UTC) and "filled" at Sunday's reopen 49 h later (−1.08R, live-impossible), leaving 555 trades / +98.64R / PF≈1.50 @ $0.65 (was 556/+97.56/1.48). The current-HEAD canonical reference is recorded below. A Module 21 test sweeps those copies plus the advisory outcome's continuity copy hourly across both DST transitions.
+- **Weekend calendar: FIXED (owner-approved 2026-08-04).** All three `_is_forex_weekend` copies are NY-anchored (Fri 17:00 → Sun 18:00 ET; during US DST that is Fri 21:00 UTC — measured on 5yr of Oanda bars). Kills the weekly false-"STALE DATA/feed lagging" hours. Book impact, fully accounted: M15 byte-identical; M5 12mo dropped exactly ONE trade — a phantom whose signal fired on the final summer-Friday bar (close 21:00 UTC) and "filled" at Sunday's reopen 49 h later (−1.08R, live-impossible). M5 12mo reference at HEAD: 555 trades, +98.64R PF≈1.50 @ $0.65 (was 556/+97.56/1.48). A Module 21 test sweeps all three copies hourly across both DST transitions.
 - **Spread in exit-trigger detection (rule 6): owner DECLINED 2026-08-04.** Backtest stop triggers stay on raw mid High/Low; the measured optimism (~4–6% of total R: −3.55R @ $0.30, −4.24R @ $0.65 on the M15 12mo book) is accepted and books stay comparable. Re-open only as a conscious re-pin campaign.
 - **`FB2_EMA_LO`: HARDENED 2026-08-04 (delegated).** Research override for the EMA200-proximity band, default = tuned 0.5; an unparseable value now degrades to the default with a warning instead of crashing every scan. Documented here — it is a knob that exists.
-- **H4 seeding divergence: parked.** Live H4 fetches only 380 bars vs the backtest's unbounded history — ~2% of sampled H4 bars flip an indicator signal (composite Δ up to 12.3). M5/M15/H1 clean at their real fetch depths. Fold into any future H4 campaign; H4 remains "unproven".
+- **H4 seeding divergence: parked.** Live H4 fetches only 380 bars vs the backtest's unbounded history — ~2% of sampled H4 bars flip an indicator signal (composite Δ up to 12.3). M5/M15/H1 clean at their real fetch depths. Fold into any future H4 campaign; H4 remains "unproven for auto-execution".
 
-## Current state notes (2026-08-14)
+## Current state notes (2026-07-30)
 
-- Oanda v20 is the live feed (`data_providers.active: "oanda"`). The 2026-08-04 re-pin made the 27 `backtest/oanda_*.csv` books the baseline; all TD-era books are superseded. Current-HEAD M5 canonical book: `backtest/oanda_m5_12mo_065_nopb_20260814.csv`, +106.82R PF 1.51 at $0.65 (both halves positive; PF 1.46 / 1.55). M15 reference: +73.93R PF 1.53. See `backtest/research/repin_verification_2026-08-14.md`.
+- Oanda v20 is the live feed (`data_providers.active: "oanda"`), but the pinned backtest books are still Twelve-Data-pinned and the backtest cost assumption is $0.30 while measured real spreads are ~$0.65–0.72 — re-pin books on Oanda bars before treating feed-switch comparisons as valid (see Oanda/TD divergence study in memory).
-- Cost reporting is dual: $0.65 is the measured-Oanda realistic headline ($0.65-$0.72 round trip), while $0.30 remains for cross-book comparability and as the live TP spread-gate input. Raising `round_trip_cost` from $0.30 would move the TP floor from about $9 to $19.50 and requires full rule-1 revalidation.
-- Twelve Data is signal-incompatible with Oanda (Phase 1: about 19% M5 bar-direction disagreement and a systematic ~$1 high bias; see `backtest/research/feed_divergence_2026-08-14.md`). On an Oanda candle outage, stop scanning rather than switching to TD candles.
-- Tiingo is streaming-only (`data_providers.streaming: "tiingo"`), not a designated candle fallback. Oanda-Tiingo signal parity is documented in `backtest/research/signal_parity_2026-08-14.md`; Phase 4's two-week live shadow scan remains a manual operational step.
 - Human-facing docs in `docs/` (`user_guide.html`, `beginner_guide.html` + PDF builds) must be kept in sync when signal behavior changes.
-- 2026-09-03 signal-log campaign shipped two new per-TF gates (`backtest/research/signal_log_campaign_2026-09.md`): M5 `sell_blocked_regimes=["transitioning"]` and H1 `sell_min_quality=[]` (all H1 shorts blocked). Current-HEAD M5 canonical book is now `backtest/oanda_m5_12mo_065_nopb_20260903.csv` (557 / +112.21R / PF 1.56, halves +55.9/+56.4); H1 reference `backtest/oanda_h1_12mo_065_20260903.csv` (91 / +22.2R / PF 1.79; 5yr +49.1R PF 1.46; OOS +16.7R PF 1.74).
-- Auto-execution (oanda_daemon.py / oanda_executor.py) was removed 2026-09-03 — the owner is not auto-trading; last commit containing it is 31002cb. Book-parity rules that lived in its docstring (no broker TP, 5-bar cooldown, once-per-bar trail) remain the backtester's model.

advisory_outcome.py

@@ -1,354 +0,0 @@
-"""Deterministic advisory trade outcomes from stored closed candles.
-
-This module measures the hypothetical setup reviewed by the LLM panel. It
-never changes a signal, panel verdict, order, or daemon state. The model uses
-the same next-open reanchoring and close-only trailing rules as the backtester,
-but its evidence is the cleaned mid-candle snapshots stored in signals.db.
-"""
-
-from __future__ import annotations
-
-import logging
-import math
-from datetime import datetime, timedelta
-from typing import Any, Dict, Iterable, List, Optional, Tuple
-from zoneinfo import ZoneInfo
-
-logger = logging.getLogger(__name__)
-
-MODEL = "stored-closed-mid-next-open-trail-v1"
-MAX_HOLD_BARS = 300
-REFERENCE_COST = 0.30
-REALISTIC_COST = 0.65
-
-_TF_ALIASES = {
-    "M1": "1min", "1MIN": "1min", "1min": "1min",
-    "M5": "5min", "5MIN": "5min", "5min": "5min",
-    "M15": "15min", "15MIN": "15min", "15min": "15min",
-    "M30": "30min", "30MIN": "30min", "30min": "30min",
-    "H1": "1h", "1H": "1h", "1h": "1h",
-    "H4": "4h", "4H": "4h", "4h": "4h",
-    "D1": "1day", "1D": "1day", "1d": "1day",
-    "1DAY": "1day", "1day": "1day",
-}
-
-_TF_SECONDS = {
-    "1min": 60,
-    "5min": 5 * 60,
-    "15min": 15 * 60,
-    "30min": 30 * 60,
-    "1h": 60 * 60,
-    "4h": 4 * 60 * 60,
-    "1day": 24 * 60 * 60,
-}
-
-_NY_TZ = ZoneInfo("America/New_York")
-
-
-def _is_forex_weekend(now: datetime) -> bool:
-    """NY-anchored XAU weekend closure; test-locked to the signal copies."""
-    ny = now.astimezone(_NY_TZ)
-    weekday = ny.weekday()
-    if weekday == 4:
-        return ny.hour >= 17
-    if weekday == 5:
-        return True
-    if weekday == 6:
-        return ny.hour < 18
-    return False
-
-
-def normalize_timeframe(value: Any) -> str:
-    text = str(getattr(value, "value", value) or "")
-    return _TF_ALIASES.get(text, _TF_ALIASES.get(text.upper(), text))
-
-
-def timeframe_value(mapping: Any, timeframe: Any) -> Any:
-    """Read a timeframe-keyed snapshot regardless of enum/storage alias."""
-    if not isinstance(mapping, dict):
-        return None
-    wanted = normalize_timeframe(timeframe)
-    for key, value in mapping.items():
-        if normalize_timeframe(key) == wanted:
-            return value
-    return None
-
-
-def _finite(value: Any) -> Optional[float]:
-    try:
-        number = float(value)
-    except (TypeError, ValueError):
-        return None
-    return number if math.isfinite(number) else None
-
-
-def _timestamp(value: Any) -> Optional[datetime]:
-    try:
-        return datetime.fromisoformat(str(value).replace(" ", "T"))
-    except (TypeError, ValueError):
-        return None
-
-
-def initial_outcome(
-    setup: Optional[Dict[str, Any]],
-    indicators: Optional[Dict[str, Any]],
-    timeframe: Any,
-) -> Tuple[str, Dict[str, Any]]:
-    """Freeze the setup and deterministic evaluation policy."""
-    if not setup:
-        return "NOT_APPLICABLE", {
-            "model": MODEL,
-            "status": "NOT_APPLICABLE",
-            "reason": "panel row has no trade setup",
-        }
-
-    tf = normalize_timeframe(timeframe)
-    analysis = timeframe_value(indicators, tf)
-    signal_bar = analysis.get("timestamp") if isinstance(analysis, dict) else None
-    direction = str(setup.get("direction", ""))
-    entry = _finite(setup.get("entry"))
-    stop = _finite(setup.get("stop_loss"))
-    tp1 = _finite(setup.get("take_profit_1"))
-    arm = _finite(setup.get("trail_arm_r"))
-    distance = _finite(setup.get("trail_dist_r"))
-    risk = abs(entry - stop) if entry is not None and stop is not None else 0.0
-    if (direction not in ("BUY", "SELL") or not signal_bar
-            or _timestamp(signal_bar) is None or risk <= 0 or tp1 is None
-            or arm is None or distance is None or arm < 0 or distance < 0):
-        return "UNRESOLVABLE", {
-            "model": MODEL,
-            "status": "UNRESOLVABLE",
-            "reason": "invalid or incomplete setup/outcome seed",
-        }
-
-    state = {
-        "model": MODEL,
-        "status": "PENDING",
-        "timeframe": tf,
-        "signal_bar_at": str(signal_bar),
-        "setup": {
-            "direction": direction,
-            "reported_entry": entry,
-            "stop_distance": risk,
-            "tp1_distance": abs(tp1 - entry),
-            "strategy": setup.get("strategy"),
-            "setup_pattern": setup.get("setup_pattern"),
-        },
-        "policy": {
-            "entry": "next_primary_bar_open_reanchored",
-            "max_hold_bars": MAX_HOLD_BARS,
-            "trail_arm_r": arm,
-            "trail_dist_r": distance,
-            "tp1_is_advisory": arm > 0,
-            "reference_cost": REFERENCE_COST,
-            "realistic_cost": REALISTIC_COST,
-        },
-        "progress": {
-            "last_processed_bar": str(signal_bar),
-            "entry_at": None,
-            "entry_price": None,
-            "initial_stop": None,
-            "current_stop": None,
-            "peak": None,
-            "bars_held": 0,
-            "mfe_r": 0.0,
-            "mae_r": 0.0,
-        },
-        "result": None,
-    }
-    return "PENDING", state
-
-
-def _valid_bars(bars: Iterable[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    valid = []
-    for bar in bars:
-        stamp = _timestamp(bar.get("timestamp")) if isinstance(bar, dict) else None
-        values = [_finite(bar.get(key)) for key in ("open", "high", "low", "close")]
-        if stamp is None or any(value is None for value in values):
-            continue
-        valid.append({
-            "timestamp": str(bar["timestamp"]),
-            "_timestamp": stamp,
-            "open": values[0], "high": values[1],
-            "low": values[2], "close": values[3],
-        })
-    valid.sort(key=lambda item: item["_timestamp"])
-    return valid
-
-
-def _has_continuity(
-    bars: List[Dict[str, Any]], last: datetime, timeframe: str
-) -> bool:
-    """Reject missing tradable bars while allowing scheduled XAU closures."""
-    seconds = _TF_SECONDS.get(normalize_timeframe(timeframe))
-    if seconds is None:
-        return False
-    step = timedelta(seconds=seconds)
-    previous = last
-    seen = {last}
-    for bar in bars:
-        stamp = bar["_timestamp"]
-        if stamp <= previous or stamp in seen:
-            continue
-        expected = previous + step
-        while expected < stamp:
-            ny = expected.astimezone(_NY_TZ)
-            daily_maintenance = ny.weekday() < 4 and ny.hour == 17
-            if not (_is_forex_weekend(expected) or daily_maintenance):
-                return False
-            expected += step
-        if expected != stamp:
-            return False
-        previous = stamp
-        seen.add(stamp)
-    return True
-
-
-def _finish(
-    state: Dict[str, Any], reason: str, exit_at: str, exit_price: float
-) -> None:
-    setup = state["setup"]
-    progress = state["progress"]
-    entry = float(progress["entry_price"])
-    risk = float(setup["stop_distance"])
-    pnl = ((exit_price - entry) if setup["direction"] == "BUY"
-           else (entry - exit_price))
-    gross_r = pnl / risk
-    state["status"] = "RESOLVED"
-    state["result"] = {
-        "exit_at": exit_at,
-        "exit_price": exit_price,
-        "exit_reason": reason,
-        "bars_held": progress["bars_held"],
-        "gross_r": gross_r,
-        "net_r_030": (pnl - REFERENCE_COST) / risk,
-        "net_r_065": (pnl - REALISTIC_COST) / risk,
-        "mfe_r": progress["mfe_r"],
-        "mae_r": progress["mae_r"],
-    }
-
-
-def advance_outcome(
-    state: Dict[str, Any], bars: Iterable[Dict[str, Any]]
-) -> Dict[str, Any]:
-    """Advance one pending outcome with overlapping closed-bar snapshots."""
-    if state.get("status") != "PENDING":
-        return state
-    try:
-        progress = state["progress"]
-        setup = state["setup"]
-        policy = state["policy"]
-        last = _timestamp(progress["last_processed_bar"])
-        signal_bar = _timestamp(state["signal_bar_at"])
-        if last is None or signal_bar is None:
-            raise ValueError("invalid progress timestamp")
-
-        buy = setup["direction"] == "BUY"
-        risk = float(setup["stop_distance"])
-        trail_arm = float(policy["trail_arm_r"])
-        trail_distance = float(policy["trail_dist_r"])
-
-        valid_bars = _valid_bars(bars)
-        has_future = any(bar["_timestamp"] > last for bar in valid_bars)
-        has_overlap = any(bar["_timestamp"] == last for bar in valid_bars)
-        if has_future and not has_overlap:
-            state["status"] = "UNRESOLVABLE"
-            state["result"] = None
-            state["reason"] = "stored candle snapshots lost continuity"
-            return state
-        if has_future and not _has_continuity(valid_bars, last,
-                                              state["timeframe"]):
-            state["status"] = "UNRESOLVABLE"
-            state["result"] = None
-            state["reason"] = "stored candle snapshots contain an internal gap"
-            return state
-
-        for bar in valid_bars:
-            stamp = bar["_timestamp"]
-            if stamp <= signal_bar or stamp <= last:
-                continue
-
-            if progress["entry_price"] is None:
-                entry = bar["open"]
-                initial_stop = entry - risk if buy else entry + risk
-                progress.update({
-                    "entry_at": bar["timestamp"],
-                    "entry_price": entry,
-                    "initial_stop": initial_stop,
-                    "current_stop": initial_stop,
-                    "peak": entry,
-                })
-
-            entry = float(progress["entry_price"])
-            current_stop = float(progress["current_stop"])
-            initial_stop = float(progress["initial_stop"])
-            progress["bars_held"] += 1
-            progress["last_processed_bar"] = bar["timestamp"]
-            last = stamp
-
-            if buy:
-                mfe = (bar["high"] - entry) / risk
-                mae = (entry - bar["low"]) / risk
-                stop_hit = bar["low"] <= current_stop
-            else:
-                mfe = (entry - bar["low"]) / risk
-                mae = (bar["high"] - entry) / risk
-                stop_hit = bar["high"] >= current_stop
-            progress["mfe_r"] = max(float(progress["mfe_r"]), max(0.0, mfe))
-            progress["mae_r"] = max(float(progress["mae_r"]), max(0.0, mae))
-
-            if stop_hit:
-                exit_price = current_stop
-                if (buy and bar["open"] < current_stop) or \
-                        (not buy and bar["open"] > current_stop):
-                    exit_price = bar["open"]
-                reason = "SL" if current_stop == initial_stop else "TRAIL"
-                _finish(state, reason, bar["timestamp"], exit_price)
-                return state
-
-            if trail_arm <= 0:
-                target = entry + setup["tp1_distance"] if buy \
-                    else entry - setup["tp1_distance"]
-                target_hit = bar["high"] >= target if buy else bar["low"] <= target
-                if target_hit:
-                    exit_price = target
-                    if (buy and bar["open"] > target) or \
-                            (not buy and bar["open"] < target):
-                        exit_price = bar["open"]
-                    _finish(state, "TP1", bar["timestamp"], exit_price)
-                    return state
-            else:
-                favorable = bar["high"] if buy else bar["low"]
-                peak = max(float(progress["peak"]), favorable) if buy \
-                    else min(float(progress["peak"]), favorable)
-                progress["peak"] = peak
-                excursion = ((peak - entry) if buy else (entry - peak)) / risk
-                if excursion >= trail_arm:
-                    level = peak - trail_distance * risk if buy \
-                        else peak + trail_distance * risk
-                    progress["current_stop"] = max(current_stop, level) if buy \
-                        else min(current_stop, level)
-
-            if progress["bars_held"] >= int(policy["max_hold_bars"]):
-                _finish(state, "TIMEOUT", bar["timestamp"], bar["close"])
-                return state
-        return state
-    except Exception as exc:
-        # Still fail-safe (never raises into a scan), but no longer
-        # SILENT: a real defect here used to be indistinguishable from a
-        # legitimate weekend/downtime gap, discoverable only by grepping
-        # advisory_outcome_json. Callers persist the state either way.
-        logger.exception(
-            "advisory outcome evaluator failed for the %s outcome seeded "
-            "at %s — recorded UNRESOLVABLE",
-            state.get("timeframe"), state.get("signal_bar_at"))
-        state["status"] = "UNRESOLVABLE"
-        state["result"] = None
-        state["reason"] = f"outcome evaluator error: {type(exc).__name__}"
-        return state
-
-
-def canonical_r(state: Dict[str, Any]) -> Optional[float]:
-    result = state.get("result")
-    value = result.get("net_r_065") if isinstance(result, dict) else None
-    return _finite(value)

app_config.py

@@ -86,33 +86,18 @@ _VALID_LOG_LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
 _SCANNABLE_TFS = ("M5", "M15", "H1", "H4")
 
 _KNOWN_TOP = {"telegram", "data_providers", "scanning", "pairs", "log_level",
-               "oanda", "deepseek", "agent_panel", "market_outlook",
+              "oanda", "deepseek"}
-               "signal_log"}
 _KNOWN_OANDA = {
-    "account_id", "api_token", "base_url",
+    "account_id", "api_token", "base_url", "lot_size",
+    "quality_gate", "max_hold_bars",
 }
 _KNOWN_DEEPSEEK = {
     "api_key", "model", "enabled", "timeout_seconds", "daily_request_cap",
 }
-_KNOWN_AGENT_PANEL = {
-    "enabled", "telegram", "dashboard", "min_quality",
-    "max_panels_per_day", "reuse_ttl_seconds",
-    "candles_enabled", "candle_bars_primary", "candle_bars_confirm",
-    "verdict_source",
-}
-_KNOWN_MARKET_OUTLOOK = {"enabled", "telegram", "max_per_day", "candles_bars"}
-_KNOWN_SIGNAL_LOG = {"enabled", "path", "log_blocked_scans"}
 _KNOWN_TELEGRAM = {"token", "chat_id", "channel_id", "alert_min_quality"}
 _KNOWN_SCANNING = {"pairs", "timeframes"}
 _KNOWN_PAIR_KEYS = {"blocked_hours_utc"}
 
-_MARKET_OUTLOOK_DEFAULTS = {
-    "enabled": False,
-    "telegram": False,
-    "max_per_day": 12,
-    "candles_bars": 20,
-}
-
 
 class AppConfigError(Exception):
     """config.json is present but invalid — fail fast at boot."""
@@ -133,10 +118,6 @@ class AppConfig:
     pair_overrides: Dict[str, Dict[str, Any]] = field(default_factory=dict)
     oanda_settings: Dict[str, Any] = field(default_factory=dict)
     deepseek_settings: Dict[str, Any] = field(default_factory=dict)
-    agent_panel_settings: Dict[str, Any] = field(default_factory=dict)
-    market_outlook_settings: Dict[str, Any] = field(
-        default_factory=lambda: dict(_MARKET_OUTLOOK_DEFAULTS))
-    signal_log_settings: Dict[str, Any] = field(default_factory=dict)
     log_level: str = "INFO"
 
 
@@ -256,6 +237,20 @@ def load_app_config(path: str = CONFIG_PATH) -> AppConfig:
 
     oanda = raw.get("oanda", {})
     _check_keys(oanda, _KNOWN_OANDA, '"oanda"')
+    if "lot_size" in oanda:
+        ls = oanda["lot_size"]
+        if not isinstance(ls, int) or isinstance(ls, bool) or ls < 1:
+            raise AppConfigError(
+                "config.json: oanda.lot_size must be a positive integer")
+    if "quality_gate" in oanda and oanda["quality_gate"] not in _VALID_QUALITIES:
+        raise AppConfigError(
+            f'config.json: oanda.quality_gate "{oanda["quality_gate"]}" '
+            f"not in {_VALID_QUALITIES}")
+    if "max_hold_bars" in oanda:
+        mhb = oanda["max_hold_bars"]
+        if not isinstance(mhb, int) or isinstance(mhb, bool) or mhb < 1:
+            raise AppConfigError(
+                "config.json: oanda.max_hold_bars must be a positive integer")
     app.oanda_settings = dict(oanda)
 
     deepseek = raw.get("deepseek", {})
@@ -281,77 +276,6 @@ def load_app_config(path: str = CONFIG_PATH) -> AppConfig:
                 "config.json: deepseek.model must be a non-empty string")
     app.deepseek_settings = dict(deepseek)
 
-    panel = raw.get("agent_panel", {})
-    _check_keys(panel, _KNOWN_AGENT_PANEL, '"agent_panel"')
-    for flag in ("enabled", "telegram", "dashboard"):
-        if flag in panel and not isinstance(panel[flag], bool):
-            raise AppConfigError(
-                f"config.json: agent_panel.{flag} must be true or false")
-    if "min_quality" in panel and panel["min_quality"] not in _VALID_QUALITIES:
-        raise AppConfigError(
-            f'config.json: agent_panel.min_quality "{panel["min_quality"]}" '
-            f"not in {_VALID_QUALITIES}")
-    if "max_panels_per_day" in panel:
-        mpd = panel["max_panels_per_day"]
-        if isinstance(mpd, bool) or not isinstance(mpd, int) or mpd < 1:
-            raise AppConfigError(
-                "config.json: agent_panel.max_panels_per_day must be a "
-                "positive integer")
-    if "reuse_ttl_seconds" in panel:
-        ttl = panel["reuse_ttl_seconds"]
-        if isinstance(ttl, bool) or not isinstance(ttl, (int, float)) \
-                or ttl < 0:
-            raise AppConfigError(
-                "config.json: agent_panel.reuse_ttl_seconds must be a "
-                "non-negative number")
-    if "candles_enabled" in panel \
-            and not isinstance(panel["candles_enabled"], bool):
-        raise AppConfigError(
-            "config.json: agent_panel.candles_enabled must be true or false")
-    for key in ("candle_bars_primary", "candle_bars_confirm"):
-        if key in panel:
-            n = panel[key]
-            if isinstance(n, bool) or not isinstance(n, int) \
-                    or not 1 <= n <= 100:
-                raise AppConfigError(
-                    f"config.json: agent_panel.{key} must be an integer "
-                    "between 1 and 100")
-    if "verdict_source" in panel and panel["verdict_source"] not in \
-            ("macro", "chair"):
-        raise AppConfigError(
-            'config.json: agent_panel.verdict_source must be "macro" or '
-            '"chair"')
-    app.agent_panel_settings = dict(panel)
-
-    outlook = raw.get("market_outlook", {})
-    _check_keys(outlook, _KNOWN_MARKET_OUTLOOK, '"market_outlook"')
-    for flag in ("enabled", "telegram"):
-        if flag in outlook and not isinstance(outlook[flag], bool):
-            raise AppConfigError(
-                f"config.json: market_outlook.{flag} must be true or false")
-    for key in ("max_per_day", "candles_bars"):
-        if key in outlook:
-            value = outlook[key]
-            if isinstance(value, bool) or not isinstance(value, int) or value < 1:
-                raise AppConfigError(
-                    f"config.json: market_outlook.{key} must be a positive integer")
-    app.market_outlook_settings.update(outlook)
-
-    slog = raw.get("signal_log", {})
-    _check_keys(slog, _KNOWN_SIGNAL_LOG, '"signal_log"')
-    if "enabled" in slog and not isinstance(slog["enabled"], bool):
-        raise AppConfigError(
-            "config.json: signal_log.enabled must be true or false")
-    if "path" in slog and (not isinstance(slog["path"], str)
-                           or not slog["path"]):
-        raise AppConfigError(
-            "config.json: signal_log.path must be a non-empty string")
-    if ("log_blocked_scans" in slog
-            and not isinstance(slog["log_blocked_scans"], bool)):
-        raise AppConfigError(
-            "config.json: signal_log.log_blocked_scans must be true or false")
-    app.signal_log_settings = dict(slog)
-
     level = raw.get("log_level", app.log_level)
     if level not in _VALID_LOG_LEVELS:
         raise AppConfigError(
@@ -451,53 +375,6 @@ def deepseek_api_key(app: Optional[AppConfig] = None) -> str:
         app.deepseek_settings.get("api_key", ""))
 
 
-# ── AI market-outlook resolution helper ──────────────────────────────
-
-def market_outlook_enabled(app: Optional[AppConfig] = None) -> bool:
-    """Whether the advisory outlook feature is enabled (env wins)."""
-    env = os.environ.get("MARKET_OUTLOOK_ENABLED")
-    if env:
-        return env.strip().lower() in ("1", "true", "yes", "on")
-    app = app or get_app_config()
-    return bool(app.market_outlook_settings.get("enabled", False))
-
-
-# ── Signal-log resolution helpers (env → config.json → default) ──────
-
-def signal_log_enabled(app: Optional[AppConfig] = None) -> bool:
-    """Default ON — signal history is the platform's audit trail."""
-    env = os.environ.get("SIGNAL_LOG_ENABLED")
-    if env:
-        return env.strip().lower() in ("1", "true", "yes", "on")
-    app = app or get_app_config()
-    return bool(app.signal_log_settings.get("enabled", True))
-
-
-def signal_log_blocked_scans(app: Optional[AppConfig] = None) -> bool:
-    """Whether weekend/day-filter early returns are logged (as minimal
-    rows without news/candles). Default ON — they are liveness evidence;
-    turn off to keep the history table to real scans only."""
-    env = os.environ.get("SIGNAL_LOG_BLOCKED_SCANS")
-    if env:
-        return env.strip().lower() in ("1", "true", "yes", "on")
-    app = app or get_app_config()
-    return bool(app.signal_log_settings.get("log_blocked_scans", True))
-
-
-def signal_log_path(app: Optional[AppConfig] = None) -> str:
-    """Absolute path to the SQLite signal-history DB. A relative config
-    value resolves against the repo root so CWD never matters."""
-    env = os.environ.get("SIGNAL_LOG_PATH")
-    if env:
-        path = env
-    else:
-        app = app or get_app_config()
-        path = str(app.signal_log_settings.get("path", "logs/signals.db"))
-    if not os.path.isabs(path):
-        path = os.path.join(os.path.dirname(os.path.abspath(__file__)), path)
-    return path
-
-
 # ── PlatformConfig overlay ────────────────────────────────────────────
 
 def apply_pair_overrides(

backtest/research/ai_signal_enrichment_2026-08-15.md

@@ -1,116 +0,0 @@
-# AI signal enrichment — analysis + build record (2026-08-15)
-
-Owner questions:
-1. If the AI panel also received indicator values and (limited) candle data, would the system be more accurate?
-2. If AI reviewed every candle alongside the local score system, would prediction accuracy justify the token burn — or is there a middle ground?
-
-## What the panel already received (pre-change baseline)
-
-The four personas (`agent_panel.py`) already got a *distilled* picture:
-per-indicator signal+confidence, MTF signals/scores, key levels,
-exhaustion count, full trade-setup math, warnings, headlines/events/
-sentiment. Missing: raw indicator **values** and any **candle** data.
-
-Cost guardrails already in place: 5 requests/panel, `max_panels_per_day`
-20 (≤100 requests/day), 3600 s reuse-TTL, per-bar exact cache, shared
-500 req/day DeepSeek cap, static prompts on the ~50× prefix cache.
-
-## Evidence used
-
-- **LLM is strong at text, weak at raw numerics** (measured in-repo,
-  `llm_news_eval_2026-08-06.md`): headline sentiment 100% (78/78) vs
-  keyword scorer 31%; but ~11% of event-direction calls misread close
-  numeric comparisons until code pre-computed the comparison
-  (`vs_forecast`) and the model only mapped it to doctrine.
-- **The book any filter would act on** (M5 canonical,
-  `oanda_m5_12mo_065_nopb_20260814.csv`): 577 trades, +106.82R,
-  PF 1.51, win rate 52.9%; A-grade 59.5%, B-grade 51.4% (+67.8R of the
-  total), C-grade 43.8% (−0.23R, 16 trades). Average edge ≈ 0.185R/trade.
-
-## Answer 1 — enrich the existing panel? YES (cheap, safe)
-
-- A compact candle is ~15–25 tokens; 20 primary-TF + 10 confirm-TF bars
-  ≈ 500–1,500 tokens per persona call → cents/day at the 20-panel cap.
-  **Tokens are not the constraint; the request cap is.**
-- Measured after the build (dry-test wire log): enriched technical
-  payload with 20 candles ≈ **~380 tokens**; replies ≈ 25–35 tokens
-  under the new 15-word note cap.
-- Caveats: (a) the panel is advisory-only — richer payloads improve the
-  human's context, not the book's P&L; (b) raw prices are the model's
-  weakest input, so candles are sent **ATR-normalized** (code does the
-  arithmetic, LLM reads the shape) — the same pattern that fixed the
-  event-direction misreads.
-
-## Answer 2 — AI on every candle? NO
-
-- **Feasibility**: M5+M15+H1+H4 ≈ 414 bars/day → one call/bar nearly
-  exhausts the shared 500/day cap (news needs it too); a panel per bar
-  ≈ 2,070/day = 4× over. Most of that spend reviews HOLD bars.
-- **Parity (rule 4)**: an AI gate cannot be replayed by the backtester
-  (news off; no recorded verdicts) — every pinned book becomes
-  non-comparable, and model-version drift silently mutates the strategy.
-- **Edge**: the engine already compresses 380 bars into 9 tuned
-  indicators + regime + MTF validated over 5 years; an LLM's generic
-  prior on raw candles won't beat fitted thresholds, and the margin it
-  would filter is ~0.185R/trade. B-grade holds +67.8R at 51.4% win —
-  a blunt veto is net-negative.
-
-## The middle ground (adopted)
-
-1. **Enrich payloads** (built today, see below) — near-zero cost, no
-   rule-1 exposure.
-2. **Log panel verdicts to signals.db** (built today) — creates the
-   "does OPPOSE predict losers?" dataset with zero behavior change.
-3. **After 4–8 weeks**: join logged verdicts to outcomes; simulate an
-   OPPOSE-veto against the pinned book offline. Only then consider any
-   gating, as a full rule-1 revalidation.
-
-## Build record (2026-08-15, owner-approved)
-
-- `agent_panel.py`
-  - Technical persona payload now carries indicator **values** (units
-    legend added to the prompt) and **ATR-normalized candles** per TF:
-    `{"ref_close", "atr", "bars": [[o,h,l,c]…]}` oldest-first, each price
-    as `(price − ref_close) / atr`, 1 decimal. Window: 20 bars primary /
-    10 per confirmation TF.
-  - New config keys (validated in `app_config.py`, in
-    `config.json.example`): `candles_enabled` (default true),
-    `candle_bars_primary` (20), `candle_bars_confirm` (10).
-  - Panel-private provider singleton (`_dp`, patchable in tests);
-    TTL cache keeps fetches near-free; any failure → candles silently
-    omitted, panel unaffected.
-  - Prompt hardening: training data declared stale and OFF-LIMITS;
-    "if a fact is not in the JSON, treat it as unknown"; thin evidence
-    → neutral < 30 (unchanged); note cap 25→**15 words**, rationale
-    40→**30 words** (output-token savings).
-  - `attach_panel` now calls `signal_log.log_panel_update(report)` after
-    every successful attach (fresh, exact-cache, and reuse-TTL paths).
-- `signal_log.py`
-  - `log()` returns the rowid; `log_signal` stashes it on the report as
-    `_signal_log_rowid`; new `log_panel_update()` fills the 4 panel
-    columns on that row post-hoc. No rowid (backtest replay, logging
-    disabled, other process) → silent no-op. Fail-safe contract kept.
-- Tests: 381 → **388 passed** (7 new: candle normalization math, payload
-  values/candles, context windows + ATR gating + disable flag, attach
-  injection (technical persona only), prompt-contract assertions,
-  panel row update, rowid hand-off + no-op paths). Existing attach tests
-  stub `ap._dp` to stay off the network.
-- **Live dry test** (`panel_payload_drytest_2026-08-15.py`, fabricated
-  numbers only, 13 real DeepSeek requests total): **7/7 probes pass** —
-  coherent-bullish → support@70; bearish-vs-BUY → oppose@85; genuinely
-  mixed → neutral@30; empty payload → neutral@20 (contract); no invented
-  numbers in any note; all notes ≤ 15 words; synthesizer AGREE with a
-  21-word rationale. Raw wire log:
-  `backtest/research/panel_payload_drytest_2026-08-15.jsonl`.
-  - Notable: an early P3 variant with H1 SELL against a BUY brief got
-    oppose@60 — *correct* per the prompt (higher-TF disagreement is a
-    listed conflict), so the probe was tightened to a genuinely mixed
-    scenario. Documented so nobody "fixes" the prompt for it later.
-
-## What this deliberately did NOT change
-
-- No gate reads panel fields; the panel remains advisory-only.
-- No backtest-path change (`analyze_from_dataframes` untouched; parity
-  test still locks panel fields empty in replay).
-- No verdict-based filtering — that decision waits for the signals.db
-  dataset (4–8 weeks) and an offline veto replay against the pinned book.

backtest/research/news_sentiment_value_2026-09-04.md

@@ -1,129 +0,0 @@
-# News sentiment vs. price — does the news score carry information? — 2026-09-04
-
-**Source evidence:** `logs/signals.db` 2026-08-13 → 2026-09-03 (14,683 rows, 13,947 with
-a price; candle snapshots from 08-18, full-shape headline blobs from 08-19), read with
-`mode=ro`. A continuous H1/M15/M5 candle stream was rebuilt from the stored 14-bar
-`candles_json` snapshots (H1: 293 bars, 08-18 05:00 → 09-03 22:00). Headlines were
-resolved through `news_snapshots` (4,054 distinct headlines, 2,024 gold-tagged).
-Outcomes are the repo's own advisory model (`advisory_r_multiple` on the 144 `RESOLVED`
-rows, R at $0.65). One-year context from the Oanda H1 parquet
-(`backtest/cache/oanda_XAU_USD_1h_20250814_20260814.parquet`). No backtest: the
-backtester runs with news off, and no headline history exists beyond these 3 weeks, so a
-replay cannot test news. The same check reruns with
-`python analyze_signal_log.py --stored-candles --news`.
-
-Question asked by the owner: the log reads bullish most of the time — what did the
-indicators and the news say when gold fell, and is news scoring a waste?
-
-## Findings
-
-**The numeric news score is a rear-view mirror.** `news_sentiment` (= mean gold-headline
-score − mean dollar-headline score over the last 12 h) tracks what gold did over the
-*previous* day and says nothing stable about the next one.
-
-| hourly mean sentiment vs. gold return (n≈293 h) | Pearson |
-|---|---|
-| past 24 h | **+0.67** |
-| past 8 h / 4 h / 1 h | +0.32 / +0.20 / +0.07 |
-| next 1 h / 4 h / 8 h / 24 h | +0.05 / +0.10 / +0.21 / +0.14 |
-| next 8 h, first half (08-18→25) / second half (08-26→09-03) | **−0.37 / +0.12** |
-| next 24 h, first half / second half | −0.12 / −0.09 |
-| daily mean vs same-day / previous-day / next-day move | +0.39 / +0.37 / **+0.03** |
-| *change* in sentiment vs next 4 h / 8 h / 24 h | −0.09 / −0.03 / −0.01 |
-
-Partial correlation with the next 8 h after removing the past-24 h return is +0.26 pooled
-but flips sign between halves. Alternative aggregates (gold-specific score only, dropping
-price-report headlines, only headlines < 2 h old) show the same shape: past-24 h
-correlation 0.59–0.82, no stable forward correlation. A naive "hold in the direction of
-sentiment" rule made +$272 over 279 hours vs +$120 buy-and-hold, but trading the *change*
-in sentiment lost −$200: the gain is trend persistence (sentiment ≈ trailing return), not
-news.
-
-**Why the log reads bullish.** 62% of rows have sentiment ≥ +0.1, 21% ≤ −0.1. Component
-means: gold headlines +0.158, dollar headlines +0.048. The window was a 16% August rally,
-so the average headline was bullish because price had been rising. Of the gold-tagged
-headlines, 42% merely restate the chart (price-up reports 489, mean +0.37; price-down 366,
-mean −0.18) and 18% are long-horizon forecast pieces ("$5,400 target", "$50,000/oz"; 60%
-positive, 21% of all positive score mass). The per-headline LLM labels are correct — every
-regex-flagged "mis-score" was a correctly scored "yields fall → gold up" headline — which
-matches the 78/78 golden set of 2026-08-06. The averaging, the 12 h window and the
-headline universe are what destroy the information.
-
-**What news and indicators said on the way down** (top $4,697 on 08-25 00:00 UTC, low
-$4,283 on 09-02 03:00; an 8.8% drop in a week):
-
-| moment | price | news sentiment | engine (M15) |
-|---|---|---|---|
-| top, 08-25 00:00 | 4,697 | +0.30, rising to **+0.44** two hours after the top (window high) | ranging, composite +5.9; 9 BUY setups that day: −7.4R, 11% win |
-| 08-26/27 | −$60 | still +0.15…+0.37; first bearish hour 08-26 20:00, **44 h after the top**, price already −$102 | trending_down 134/138 rows, composite −4.6/−7.8; SELL setups 0/3 on 08-27 |
-| 08-28 Warsh speech 13:00–16:00 | −$122 in 3 h, −$140 day | +0.24…+0.30 overnight, **0.00 at 13:00**, −0.17 only at 16:00; summary all morning: "a hawkish tone could pressure gold, dovish hints may lift it" | composite −6.2; SELL setups 4/4, +3.3R |
-| 09-01 | −$128 day | −0.04…−0.20, "gold under pressure" all day (correct, describing the move) | trending_down 275 rows, composite −12.2, 51 SELL rows; SELL setups 7/7, +3.5R |
-| low, 09-02 03:00 | 4,283 | −0.16 at the low, −0.19 six hours later; first bullish hour 09-02 19:00, **16 h after the low**, price already +$108 | SELL setups at the bottom 0/2, −2.05R |
-
-Sentiment peaked at the top and troughed at the bottom. The engine also lagged (it is
-trend-following) but flipped regime and composite within hours; its SELL setups won on the
-trend days and lost at the turns, the same as its BUYs.
-
-**Outcomes** (144 RESOLVED, +37.8R): BUY 121 / +43.2R / 70% win; SELL 23 / −5.4R / 48%.
-
-| direction × sentiment bucket (≥+0.15 bull, ≤−0.05 bear) | n | R | mean | win |
-|---|---|---|---|---|
-| BUY, bullish news | 81 | +32.0 | +0.40 | 73% |
-| BUY, neutral | 34 | +10.6 | +0.31 | 68% |
-| BUY, bearish news | 6 | +0.65 | +0.11 | 50% |
-| SELL, bearish news | 14 | +0.13 | +0.01 | 71% |
-| SELL, neutral | 5 | −1.46 | −0.29 | 20% |
-| SELL, bullish news | 4 | −4.08 | −1.02 | 0% |
-
-The splits are the trend confound again ("BUY with bullish news" = "BUY in an uptrend").
-Cleanest counter-example: 08-25, the most bullish news day of the drop period (+0.25),
-9 BUYs at the top lost −7.4R. corr(sentiment, R): BUY +0.10, SELL −0.45 (n=23).
-
-**Macro persona** (reads the same headlines plus high-impact events): macro=support 51
-BUYs → +32.6R, 90% win; macro=neutral 16 → −3.2R, 38%. Within bullish-sentiment BUYs:
-support 42 → +25.2R (88%) vs neutral 7 → −2.9R (29%). On 08-25 all 7 panel rows were
-macro=neutral ("awaiting PCE, mixed") while the numeric aggregate said +0.25 bullish.
-Confounded with regime (64 of 84 supports were trending_up) and n≈16 on the informative
-side. Not enough to promote or demote; the standing rule (re-score at ~300 outcomes)
-applies.
-
-**Event risk** cannot be evaluated here: only 4 event windows in the sample
-(08-19 17:00, 08-26 12:00, 08-28 13:00, 09-01 13:00), none produced a setup. The standing
-evidence remains the 2026-07-11 audit (event gates would cost +4.6…+7.2R/yr).
-
-**One-year context:** daily moves ≤ −$100 happened 17 times in the year to 2026-08-14;
-15 of 47 rolling 3-week windows contained a ≥ 8% drawdown. This sample is one ordinary
-rally-then-drop regime.
-
-**Simulated 4 h window + neutral drop** (the change shipped with this note, on 11,136
-full-shape scans): never leaves a scan empty (median 19 directional headlines, 8
-gold-specific; worst hour 02:00 UTC has < 3 gold headlines 28% of the time), the aggregate
-correlates 0.78 with the old one and becomes bolder (share |score| ≥ 0.3 rises 17% → 41%),
-with the same lack of forward information (next-24 h corr +0.20; next-8 h halves
-−0.22 / −0.10).
-
-## Method
-
-- Hourly join convention: a scan in hour H (boundary + 10 s) sees the bar closed at H,
-  i.e. bar H's open; forward returns run from bar H's open, past returns end there.
-- Correlations are Pearson on hourly means (no scipy); halves split at 2026-08-26 00:00.
-- Headline classes by regex on the title (price-up / price-down / forecast-style); the
-  gold-specific score is `score_by_currency.XAU` where present, else `score`.
-- Outcome buckets use the representative row's `news_sentiment`; macro stance from
-  `panel_takes_json`.
-- Everything above reproduces from the DB alone; nothing depends on live feeds.
-
-## Decisions
-
-- `sentiment_affects_signals` and `event_risk_caps_signals` stay `False`. No gate is
-  built in either direction (follow or fade): 3 weeks, one regime.
-- The headline labelling is not the problem; the pool and the averaging are. Shipped the
-  same day: `headline_max_age_seconds` 12 h → 4 h with undated items dropped, and
-  `get_fundamental_context` drops headlines whose every relevant score is inside ±0.1
-  (`_is_neutral_headline`). The market-summary prompt now writes for someone who has
-  never traded, sends headlines newest-first with the platform's own gold direction, and
-  caps at 400 chars. **`news_sentiment` rows from the deploy date onward are a mean over
-  directional ≤ 4 h headlines — log comparisons must split at that date.**
-- Keep the macro persona running and logging; re-check with `--news` and the persona
-  scorecard at ~300 outcomes.
-- Refuted hypothesis, do not re-propose without new data: "news sentiment leads price".

backtest/research/panel_payload_drytest_2026-08-15.jsonl

@@ -1,7 +0,0 @@
-{"probe": "P1 coherent-bullish", "payload": {"brief": {"pair": "XAU/USD", "timeframe": "15min", "direction": "BUY", "quality": "A", "score": 38.5, "confidence": 62, "price": 2000.0, "market_regime": "trending_up", "volatility_regime": "normal", "mtf_agreement": true}, "indicators": {"ema_trend": {"signal": "STRONG_BUY", "confidence": 90, "value": 1.0}, "rsi": {"signal": "BUY", "confidence": 65, "value": 58.0}, "macd": {"signal": "STRONG_BUY", "confidence": 80, "value": 1.25}, "bollinger": {"signal": "BUY", "confidence": 60, "value": 0.7}, "adx": {"signal": "BUY", "confidence": 70, "value": 32.0}, "roc": {"signal": "BUY", "confidence": 55, "value": 0.35}, "keltner": {"signal": "BUY", "confidence": 65, "value": 3.1}, "candlestick": {"signal": "BUY", "confidence": 60, "value": 2.0}}, "mtf": {"5min": {"signal": "BUY", "score": 30.0}, "1h": {"signal": "STRONG_BUY", "score": 45.0}}, "key_levels": {"resistance": 2012.0, "support": 1985.0}, "exhaustion": 0, "candles": {"15min": {"ref_close": 2000.0, "atr": 5.0, "bars": [[-2.4, -2.2, -2.4, -2.3], [-2.3, -2.1, -2.3, -2.2], [-2.2, -2.0, -2.2, -2.0], [-2.0, -1.9, -2.1, -1.9], [-1.9, -1.8, -2.0, -1.8], [-1.8, -1.6, -1.8, -1.7], [-1.7, -1.5, -1.7, -1.6], [-1.6, -1.4, -1.6, -1.4], [-1.4, -1.3, -1.5, -1.3], [-1.3, -1.2, -1.4, -1.2], [-1.2, -1.0, -1.2, -1.1], [-1.1, -0.9, -1.1, -1.0], [-1.0, -0.8, -1.0, -0.8], [-0.8, -0.7, -0.9, -0.7], [-0.7, -0.6, -0.8, -0.6], [-0.6, -0.4, -0.6, -0.5], [-0.5, -0.3, -0.5, -0.4], [-0.4, -0.2, -0.4, -0.2], [-0.2, -0.1, -0.3, -0.1], [-0.1, 0.0, -0.2, 0.0]]}}}, "raw_reply": {"stance": "support", "confidence": 70, "note": "The trend is up and all signs agree, so buying fits the flow."}}
-{"probe": "P2 bearish-vs-BUY-brief", "payload": {"brief": {"pair": "XAU/USD", "timeframe": "15min", "direction": "BUY", "quality": "A", "score": 38.5, "confidence": 62, "price": 2000.0, "market_regime": "trending_down", "volatility_regime": "normal", "mtf_agreement": false}, "indicators": {"ema_trend": {"signal": "STRONG_SELL", "confidence": 85, "value": 0.1}, "rsi": {"signal": "SELL", "confidence": 70, "value": 74.0}, "macd": {"signal": "STRONG_SELL", "confidence": 80, "value": -1.4}, "bollinger": {"signal": "SELL", "confidence": 60, "value": 0.95}, "adx": {"signal": "SELL", "confidence": 70, "value": 35.0}, "roc": {"signal": "SELL", "confidence": 60, "value": -0.5}, "keltner": {"signal": "SELL", "confidence": 65, "value": -2.8}, "candlestick": {"signal": "SELL", "confidence": 55, "value": -2.0}}, "mtf": {"5min": {"signal": "SELL", "score": -28.0}, "1h": {"signal": "STRONG_SELL", "score": -41.0}}, "key_levels": {"resistance": 2012.0, "support": 1985.0}, "exhaustion": 3, "candles": {"15min": {"ref_close": 2000.0, "atr": 5.0, "bars": [[2.4, 2.4, 2.2, 2.3], [2.3, 2.3, 2.1, 2.2], [2.2, 2.2, 2.0, 2.0], [2.0, 2.1, 1.9, 1.9], [1.9, 2.0, 1.8, 1.8], [1.8, 1.8, 1.6, 1.7], [1.7, 1.7, 1.5, 1.6], [1.6, 1.6, 1.4, 1.4], [1.4, 1.5, 1.3, 1.3], [1.3, 1.4, 1.2, 1.2], [1.2, 1.2, 1.0, 1.1], [1.1, 1.1, 0.9, 1.0], [1.0, 1.0, 0.8, 0.8], [0.8, 0.9, 0.7, 0.7], [0.7, 0.8, 0.6, 0.6], [0.6, 0.6, 0.4, 0.5], [0.5, 0.5, 0.3, 0.4], [0.4, 0.4, 0.2, 0.2], [0.2, 0.3, 0.1, 0.1], [0.1, 0.2, -0.0, 0.0]]}}}, "raw_reply": {"stance": "oppose", "confidence": 85, "note": "The price is falling and every indicator says sell, so buying fights the trend."}}
-{"probe": "P3 conflicting", "payload": {"brief": {"pair": "XAU/USD", "timeframe": "15min", "direction": "BUY", "quality": "A", "score": 12.0, "confidence": 35, "price": 2000.0, "market_regime": "ranging", "volatility_regime": "normal", "mtf_agreement": false}, "indicators": {"ema_trend": {"signal": "BUY", "confidence": 55, "value": 0.6}, "rsi": {"signal": "NEUTRAL", "confidence": 40, "value": 51.0}, "macd": {"signal": "SELL", "confidence": 55, "value": -0.3}, "bollinger": {"signal": "NEUTRAL", "confidence": 35, "value": 0.5}, "adx": {"signal": "NEUTRAL", "confidence": 40, "value": 18.0}, "roc": {"signal": "SELL", "confidence": 50, "value": -0.1}, "keltner": {"signal": "BUY", "confidence": 50, "value": 0.8}, "candlestick": {"signal": "NEUTRAL", "confidence": 30, "value": 0.0}}, "mtf": {"5min": {"signal": "NEUTRAL", "score": 4.0}, "1h": {"signal": "NEUTRAL", "score": -3.0}}, "key_levels": {}, "exhaustion": 0, "candles": {"15min": {"ref_close": 2000.0, "atr": 5.0, "bars": [[0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0], [0.0, 0.4, -0.1, 0.3], [0.3, 0.4, -0.1, 0.0]]}}}, "raw_reply": {"stance": "neutral", "confidence": 30, "note": "Mixed signals with no clear direction, so cannot strongly support or oppose."}}
-{"probe": "P4 empty-evidence", "payload": {"brief": {"pair": "XAU/USD", "timeframe": "15min", "direction": "BUY", "quality": "A", "score": 38.5, "confidence": 62, "price": 2000.0, "market_regime": "trending_up", "volatility_regime": "normal", "mtf_agreement": true}, "indicators": {}, "mtf": {}, "key_levels": {}, "exhaustion": 0}, "raw_reply": {"stance": "neutral", "confidence": 20, "note": "Not enough data to judge the trade direction."}}
-{"probe": "P5 hallucination-trap", "payload": {"brief": {"pair": "XAU/USD", "timeframe": "15min", "direction": "BUY", "quality": "A", "score": 38.5, "confidence": 62, "price": 2000.0, "market_regime": "trending_up", "volatility_regime": "normal", "mtf_agreement": true}, "indicators": {"ema_trend": {"signal": "STRONG_BUY", "confidence": 90, "value": 1.0}, "rsi": {"signal": "BUY", "confidence": 65, "value": 58.0}, "macd": {"signal": "STRONG_BUY", "confidence": 80, "value": 1.25}, "bollinger": {"signal": "BUY", "confidence": 60, "value": 0.7}, "adx": {"signal": "BUY", "confidence": 70, "value": 32.0}, "roc": {"signal": "BUY", "confidence": 55, "value": 0.35}, "keltner": {"signal": "BUY", "confidence": 65, "value": 3.1}, "candlestick": {"signal": "BUY", "confidence": 60, "value": 2.0}}, "mtf": {"5min": {"signal": "BUY", "score": 30.0}, "1h": {"signal": "STRONG_BUY", "score": 45.0}}, "key_levels": {}, "exhaustion": 0}, "raw_reply": {"stance": "support", "confidence": 70, "note": "The trend is up and all signs agree, so buying fits the flow."}}
-{"probe": "P6 output-discipline", "payload": {}, "raw_reply": null}
-{"probe": "P7 synthesizer", "payload": {"direction": "BUY", "takes": [{"persona": "macro", "stance": "support", "confidence": 70, "note": "evidence aligned"}, {"persona": "technical", "stance": "support", "confidence": 80, "note": "evidence aligned"}, {"persona": "risk", "stance": "support", "confidence": 65, "note": "evidence aligned"}, {"persona": "contrarian", "stance": "support", "confidence": 60, "note": "evidence aligned"}]}, "raw_reply": {"verdict": "AGREE", "confidence": 85, "rationale": "All four analysts support buying, with high confidence and consistent evidence. No one opposes, so the panel clearly backs the trade."}}

backtest/research/panel_payload_drytest_2026-08-15.py

@@ -1,271 +0,0 @@
-#!/usr/bin/env python3
-"""
-panel_payload_drytest_2026-08-15.py — live DeepSeek validation of the
-enriched agent-panel payloads + hardened prompts (2026-08-15).
-
-Spends ~6 REAL DeepSeek requests (against the shared 500/day cap) with
-FABRICATED payloads — made-up prices/indicators, no real market data —
-to verify the new technical-persona contract end to end:
-
-  P1 coherent bullish evidence       -> technical persona SUPPORTS
-  P2 bearish evidence vs BUY brief   -> technical persona OPPOSES
-  P3 conflicting evidence            -> NEUTRAL or low confidence
-  P4 empty evidence                  -> NEUTRAL with confidence < 30
-                                        (the anti-hallucination contract)
-  P5 hallucination trap              -> note invents no price levels
-  P6 output discipline               -> <=20-word notes, exact JSON keys
-  P7 synthesizer over 4 supports     -> AGREE verdict
-
-Usage:  venv/bin/python backtest/research/panel_payload_drytest_2026-08-15.py
-Exit code 0 = all probes passed. Raw replies land in
-backtest/research/panel_drytest_2026-08-15.jsonl
-"""
-
-import json
-import re
-import sys
-from pathlib import Path
-
-import pandas as pd
-
-REPO_ROOT = Path(__file__).resolve().parents[2]
-sys.path.insert(0, str(REPO_ROOT))
-
-import agent_panel as ap                      # noqa: E402
-from app_config import deepseek_api_key, get_app_config  # noqa: E402
-from llm_client import get_llm_client         # noqa: E402
-
-ARTIFACT = Path(__file__).with_suffix(".jsonl")
-
-
-# ── Fabrication helpers (all numbers are invented) ───────────────────
-
-def _staircase(start: float, step: float, n: int) -> pd.DataFrame:
-    """n synthetic bars drifting `step` per bar; last close = start+n*step."""
-    rows, price = [], start
-    for _ in range(n):
-        o, c = price, price + step
-        rows.append({"Open": o, "Close": c,
-                     "High": max(o, c) + abs(step) * 0.4,
-                     "Low": min(o, c) - abs(step) * 0.4})
-        price = c
-    return pd.DataFrame(rows)
-
-
-def _choppy(center: float, n: int) -> pd.DataFrame:
-    rows, price, sign = [], center, 1
-    for _ in range(n):
-        step = sign * 1.5
-        o, c = price, price + step
-        rows.append({"Open": o, "Close": c,
-                     "High": max(o, c) + 0.6, "Low": min(o, c) - 0.6})
-        price, sign = c, -sign
-    return pd.DataFrame(rows)
-
-
-_FAKE_PRICE = 2000.00          # deliberately made-up
-_FAKE_ATR = 5.0
-
-_BRIEF_BUY = {"pair": "XAU/USD", "timeframe": "15min", "direction": "BUY",
-              "quality": "A", "score": 38.5, "confidence": 62,
-              "price": _FAKE_PRICE, "market_regime": "trending_up",
-              "volatility_regime": "normal", "mtf_agreement": True}
-
-_BULL_INDICATORS = {
-    "ema_trend": {"signal": "STRONG_BUY", "confidence": 90, "value": 1.0},
-    "rsi": {"signal": "BUY", "confidence": 65, "value": 58.0},
-    "macd": {"signal": "STRONG_BUY", "confidence": 80, "value": 1.25},
-    "bollinger": {"signal": "BUY", "confidence": 60, "value": 0.7},
-    "adx": {"signal": "BUY", "confidence": 70, "value": 32.0},
-    "roc": {"signal": "BUY", "confidence": 55, "value": 0.35},
-    "keltner": {"signal": "BUY", "confidence": 65, "value": 3.1},
-    "candlestick": {"signal": "BUY", "confidence": 60, "value": 2.0},
-}
-
-_BEAR_INDICATORS = {
-    "ema_trend": {"signal": "STRONG_SELL", "confidence": 85, "value": 0.1},
-    "rsi": {"signal": "SELL", "confidence": 70, "value": 74.0},
-    "macd": {"signal": "STRONG_SELL", "confidence": 80, "value": -1.4},
-    "bollinger": {"signal": "SELL", "confidence": 60, "value": 0.95},
-    "adx": {"signal": "SELL", "confidence": 70, "value": 35.0},
-    "roc": {"signal": "SELL", "confidence": 60, "value": -0.5},
-    "keltner": {"signal": "SELL", "confidence": 65, "value": -2.8},
-    "candlestick": {"signal": "SELL", "confidence": 55, "value": -2.0},
-}
-
-_MIXED_INDICATORS = {
-    "ema_trend": {"signal": "BUY", "confidence": 55, "value": 0.6},
-    "rsi": {"signal": "NEUTRAL", "confidence": 40, "value": 51.0},
-    "macd": {"signal": "SELL", "confidence": 55, "value": -0.3},
-    "bollinger": {"signal": "NEUTRAL", "confidence": 35, "value": 0.5},
-    "adx": {"signal": "NEUTRAL", "confidence": 40, "value": 18.0},
-    "roc": {"signal": "SELL", "confidence": 50, "value": -0.1},
-    "keltner": {"signal": "BUY", "confidence": 50, "value": 0.8},
-    "candlestick": {"signal": "NEUTRAL", "confidence": 30, "value": 0.0},
-}
-
-
-def _tech_payload(indicators, mtf, candles_df=None, key_levels=None,
-                  brief=None, exhaustion=0):
-    payload = {"brief": brief or dict(_BRIEF_BUY),
-               "indicators": indicators, "mtf": mtf,
-               "key_levels": key_levels or {}, "exhaustion": exhaustion}
-    if candles_df is not None:
-        # the REAL production normalizer, not a hand-rolled copy
-        payload["candles"] = {
-            "15min": ap._normalize_candles(candles_df, _FAKE_ATR,
-                                           len(candles_df))}
-    return payload
-
-
-# ── Probe runner ─────────────────────────────────────────────────────
-
-_RESULTS = []
-
-
-def _record(probe, payload, reply, take, passed, detail):
-    _RESULTS.append({"probe": probe, "pass": bool(passed),
-                     "detail": detail,
-                     "stance": getattr(take, "stance", None),
-                     "confidence": getattr(take, "confidence", None),
-                     "note": getattr(take, "note", None)})
-    with ARTIFACT.open("a") as fh:
-        fh.write(json.dumps({"probe": probe, "payload": payload,
-                             "raw_reply": reply}, default=str) + "\n")
-    mark = "PASS" if passed else "FAIL"
-    print(f"[{mark}] {probe}: {detail}")
-    if take is not None:
-        print(f"       -> {take.stance} @ {take.confidence:.0f} "
-              f"| {take.note}")
-
-
-def _ask(payload):
-    """Real API call through the production client + production
-    validation (the same path run_panel uses)."""
-    reply = get_llm_client().chat_json(ap._TECH_SYSTEM, payload)
-    return reply, ap._validate_take("technical", reply)
-
-
-def _want(probe: str) -> bool:
-    """--only P3 runs just that probe (saves requests on re-runs)."""
-    if "--only" not in sys.argv:
-        return True
-    return sys.argv[sys.argv.index("--only") + 1] == probe
-
-
-def main() -> int:
-    app = get_app_config()
-    if not deepseek_api_key(app):
-        print("ABORT: no DeepSeek API key (env DEEPSEEK_API_KEY / "
-              "config.json deepseek.api_key).")
-        return 2
-    if app.deepseek_settings.get("enabled", True) is False:
-        print("ABORT: deepseek.enabled is false in config.json.")
-        return 2
-    if ARTIFACT.exists() and "--only" not in sys.argv:
-        ARTIFACT.unlink()  # full run = fresh wire log; --only appends
-
-    mtf_agree = {"5min": {"signal": "BUY", "score": 30.0},
-                 "1h": {"signal": "STRONG_BUY", "score": 45.0}}
-    levels = {"resistance": 2012.0, "support": 1985.0}
-
-    # P1 — coherent bullish, with rising ATR staircase (last close 2000)
-    if _want("P1"):
-        p1 = _tech_payload(_BULL_INDICATORS, mtf_agree,
-                           candles_df=_staircase(_FAKE_PRICE - 20 * 0.6,
-                                                 0.6, 20),
-                           key_levels=levels)
-        reply, take = _ask(p1)
-        _record("P1 coherent-bullish", p1, reply, take,
-                take is not None and take.stance == "support"
-                and take.confidence >= 50,
-                "expect support @ conf>=50")
-
-    # P2 — bearish everything against a BUY brief, falling staircase
-    if _want("P2"):
-        brief2 = dict(_BRIEF_BUY, market_regime="trending_down",
-                      mtf_agreement=False)
-        mtf_sell = {"5min": {"signal": "SELL", "score": -28.0},
-                    "1h": {"signal": "STRONG_SELL", "score": -41.0}}
-        p2 = _tech_payload(_BEAR_INDICATORS, mtf_sell, brief=brief2,
-                           candles_df=_staircase(_FAKE_PRICE + 20 * 0.6,
-                                                 -0.6, 20),
-                           key_levels=levels, exhaustion=3)
-        reply, take = _ask(p2)
-        _record("P2 bearish-vs-BUY-brief", p2, reply, take,
-                take is not None and take.stance == "oppose",
-                "expect oppose (BUY brief fights all evidence)")
-
-    # P3 — genuinely mixed evidence: MTF neutral both ways, ranging
-    # regime, choppy candles. (An H1 SELL against a BUY is a *listed
-    # conflict* in the prompt — oppose is correct there, not mixed.)
-    if _want("P3"):
-        brief3 = dict(_BRIEF_BUY, market_regime="ranging", score=12.0,
-                      confidence=35, mtf_agreement=False)
-        mtf_mixed = {"5min": {"signal": "NEUTRAL", "score": 4.0},
-                     "1h": {"signal": "NEUTRAL", "score": -3.0}}
-        p3 = _tech_payload(_MIXED_INDICATORS, mtf_mixed, brief=brief3,
-                           candles_df=_choppy(_FAKE_PRICE, 20))
-        reply, take = _ask(p3)
-        _record("P3 conflicting", p3, reply, take,
-                take is not None and (take.stance == "neutral"
-                                      or take.confidence < 60),
-                "expect neutral or conf<60 on genuinely mixed evidence")
-
-    # P4 — empty evidence: contract demands neutral @ conf<30
-    if _want("P4"):
-        p4 = _tech_payload({}, {}, key_levels=None)
-        reply, take = _ask(p4)
-        _record("P4 empty-evidence", p4, reply, take,
-                take is not None and take.stance == "neutral"
-                and take.confidence < 30,
-                "contract: thin/missing evidence -> neutral, conf<30")
-
-    # P5 — hallucination trap: no key_levels, no candles; the note must
-    # not cite any 3+-digit number absent from the payload
-    if _want("P5"):
-        p5 = _tech_payload(_BULL_INDICATORS, mtf_agree, key_levels=None)
-        reply, take = _ask(p5)
-        invented = []
-        if take is not None:
-            payload_blob = json.dumps(p5)
-            for num in re.findall(r"\d{3,}", take.note):
-                if num not in payload_blob:
-                    invented.append(num)
-        _record("P5 hallucination-trap", p5, reply, take,
-                take is not None and not invented,
-                f"invented numbers in note: {invented or 'none'}")
-
-    # P6 — output discipline across the persona replies gathered above
-    notes = [r for r in _RESULTS if r["note"]]
-    wordy = [r["probe"] for r in notes if len(r["note"].split()) > 20]
-    _record("P6 output-discipline", {}, None, None,
-            notes and not wordy,
-            f"notes >20 words: {wordy or 'none'} "
-            f"(cap is 15; 20 = fail threshold)")
-
-    # P7 — synthesizer over four fabricated SUPPORT takes
-    if _want("P7"):
-        takes = [{"persona": p, "stance": "support", "confidence": c,
-                  "note": "evidence aligned"}
-                 for p, c in (("macro", 70), ("technical", 80),
-                              ("risk", 65), ("contrarian", 60))]
-        synth_payload = {"direction": "BUY", "takes": takes}
-        reply = get_llm_client().chat_json(ap._SYNTH_SYSTEM, synth_payload)
-        verdict = reply.get("verdict") if isinstance(reply, dict) else None
-        rationale = (reply or {}).get("rationale", "")
-        _record("P7 synthesizer", synth_payload, reply, None,
-                verdict == "AGREE" and len(str(rationale).split()) <= 40,
-                f"expect AGREE + <=40-word rationale; got {verdict!r} "
-                f"({len(str(rationale).split())} words)")
-
-    n_pass = sum(1 for r in _RESULTS if r["pass"])
-    n_api = sum(1 for r in _RESULTS if r["probe"] != "P6 output-discipline")
-    print(f"\n{n_pass}/{len(_RESULTS)} probes passed "
-          f"({n_api} API requests spent; "
-          f"raw wire log: {ARTIFACT.name})")
-    return 0 if n_pass == len(_RESULTS) else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

backtest/research/signal_log_campaign_2026-09.md

@@ -1,180 +0,0 @@
-# Signal-log audit → prediction-quality campaign — 2026-09-03
-
-**Source evidence:** `logs/signals.db` 2026-08-13 → 2026-09-03 (14,683 rows, candle
-snapshots from 08-18), replayed with the repo's own advisory outcome model
-(`analyze_signal_log.py --stored-candles`; the replay reproduces
-`advisory_outcome.py` to 5e-17 on the 49 panel-seeded rows), cross-checked
-against the pinned Oanda books (`backtest/oanda_*_065*.csv`).
-
-## Live-log findings that motivated the campaign
-
-| View (3 weeks, $0.65 rt) | n | WR | R | PF |
-|---|---|---|---|---|
-| every unique setup event | 144 | 67% | +37.8 | 1.93 |
-| opportunities (first per tf+direction, 60 min) | 66 | 67% | +18.3 | 1.92 |
-| one-position-per-TF (5-bar cooldown) | 32 | 62% | +6.6 | 1.53 |
-| direction BUY / SELL | 121 / 23 | 70% / 48% | +43.2 / −5.4 | 2.53 / 0.56 |
-
-- Two rally days (08-19, 08-21) contribute essentially all of the R.
-- SELL is negative in every view; in the books SELL is the weakest bucket on
-  every TF (H1 SELL −16.7R/5yr PF 0.77, −11.5R OOS PF 0.30; M15 SELL −11.7R OOS;
-  M5 SELL in `transitioning` −7.9R/12mo PF 0.21, −5.2R/5yr PF 0.49).
-- Bollinger is anti-predictive on all four TFs (forward-return hit 0.26–0.50 at
-  12 bars) and "opposes" 93% of taken book trades; divergence is inverted on
-  M15/H1 live and trades where it opposed outperform in the books.
-- Refuted live hypotheses (books disagree): ADX<20 gate, exhaustion gate,
-  NEAR-EMA200 gate, EXTREME-volatility gate, capping SL/ATR.
-
-## Method (rule 1)
-
-Harness: `backtest/gpu_backtest.py --pair XAUUSD --spread 0.65` on the CPU
-backend (CuPy present but the GPU was not reachable; the M5 12mo control
-reproduces the pinned `oanda_m5_12mo_065_nopb_20260814.csv` trade-for-trade
-except the two trades on the end date, which `--end` excludes). Every candidate
-is compared with a CONTROL produced on the same harness, never with the pinned
-book directly. Windows (cache start = start − 62 days):
-
-| window | `--start` | `--end` |
-|---|---|---|
-| 12mo (M15/H1) | 2025-08-04 | 2026-08-04 |
-| 12mo (M5 canonical) | 2025-08-14 | 2026-08-14 |
-| 5yr | 2021-08-01 | 2026-08-04 |
-| OOS | 2024-06-01 | 2025-03-30 |
-
-Acceptance: positive total R in both 12mo halves, PF ≥ 1.3, OOS not worse
-than control, and a candidate that removes a net-positive bucket for a PF-only
-gain is rejected (big-candle precedent). Runner:
-`<scratchpad>/campaign/run_campaign.sh`; summary: `summarize.py`.
-
-Candidates (all `--set`, no code):
-
-- **B1 SELL gating** — H1 `xau_strategy.sell_min_quality=[]` (block all H1
-  shorts); M5 `xau_strategy.sell_blocked_regimes=["transitioning"]`; M15
-  `xau_strategy.sell_min_quality=["B"]`.
-- **B2 divergence off** — `technical.disabled_indicators=["divergence"]` on
-  M15 and H1 (M5 divergence-down was rejected 2026-08-04; not re-run).
-- **B3 Bollinger weight 0 in trending regimes** — full
-  `technical.regime_weights_override` with bollinger 0.0 in
-  trending_up/trending_down/trending, ranging/transitioning unchanged; M5, M15, H1.
-
-## Results
-
-Every control reproduced its pinned book: M15 12mo (`ctl_m15_12mo`) is exact
-at 397/+73.93R/PF 1.53; all three H1 controls are exact; the M5 12mo control
-(`base_m5_12mo`) is exact except for the two trades that fall on the end
-date, which `--end` excludes on this harness (see Method above).
-
-| book | n | R | PF | DD | H1 | H2 | sellN | sellR | ΔR vs control | ΔPF |
-|---|---|---|---|---|---|---|---|---|---|---|
-| b1_h1_nosell_12mo | 91 | +22.2 | 1.79 | 4.1 | +20.6 | +1.6 | 0 | +0.0 | -1.8 | +0.25 |
-| b1_h1_nosell_5yr | 335 | +49.1 | 1.46 | 13.2 | -5.0 | +54.1 | 0 | +0.0 | +16.7 | +0.28 |
-| b1_h1_nosell_oos | 78 | +16.7 | 1.74 | 3.6 | +7.3 | +9.4 | 0 | +0.0 | +11.5 | +0.61 |
-| b1_m15_sellB_12mo | 341 | +74.6 | 1.62 | 10.8 | +68.4 | +6.2 | 82 | +9.1 | +0.7 | +0.09 |
-| b1_m15_sellB_5yr | 1378 | +119.1 | 1.22 | 41.4 | -21.3 | +140.3 | 335 | +3.7 | -8.9 | +0.02 |
-| b1_m15_sellB_oos | 272 | +47.1 | 1.51 | 13.8 | +12.3 | +34.8 | 59 | -3.4 | +8.3 | +0.15 |
-| b1_m5_selltrans_12mo | 557 | +112.2 | 1.56 | 9.9 | +55.9 | +56.4 | 75 | +14.8 | +7.9 | +0.06 |
-| b1_m5_selltrans_5yr | 889 | +133.7 | 1.41 | 12.8 | -8.3 | +142.0 | 88 | +9.0 | +5.3 | +0.03 |
-| b1_m5_selltrans_oos | 86 | +9.4 | 1.33 | 8.2 | -1.4 | +10.9 | 4 | +1.5 | +0.0 | +0.00 |
-| b2_h1_nodiv_12mo | 149 | +28.6 | 1.62 | 6.5 | +23.6 | +5.0 | 49 | +5.5 | +4.6 | +0.07 |
-| b2_h1_nodiv_5yr | 567 | +40.5 | 1.20 | 14.1 | -5.2 | +45.6 | 203 | -18.2 | +8.1 | +0.02 |
-| b2_h1_nodiv_oos | 119 | +7.6 | 1.17 | 7.7 | -1.9 | +9.5 | 31 | -14.3 | +2.4 | +0.04 |
-| b2_m15_nodiv_12mo | 439 | +81.3 | 1.51 | 13.1 | +72.3 | +8.9 | 147 | +7.0 | +7.4 | -0.02 |
-| b2_m15_nodiv_5yr | 1771 | +139.9 | 1.20 | 47.4 | -16.2 | +156.1 | 578 | +11.7 | +11.9 | -0.01 |
-| b2_m15_nodiv_oos | 341 | +52.3 | 1.43 | 17.1 | +15.6 | +36.7 | 93 | -10.0 | +13.5 | +0.07 |
-| b3_h1_bb0_12mo | 154 | +31.2 | 1.64 | 9.4 | +22.8 | +8.4 | 52 | +6.7 | +7.3 | +0.09 |
-| b3_h1_bb0_5yr | 583 | +37.3 | 1.18 | 18.3 | -7.4 | +44.7 | 206 | -20.4 | +4.9 | +0.00 |
-| b3_h1_bb0_oos | 122 | +5.6 | 1.12 | 8.7 | -2.0 | +7.6 | 32 | -13.8 | +0.4 | -0.01 |
-| b3_m15_bb0_12mo | 439 | +49.9 | 1.29 | 19.4 | +61.6 | -11.8 | 151 | +0.3 | -24.0 | -0.23 |
-| b3_m15_bb0_5yr | 1790 | +126.6 | 1.18 | 42.3 | -1.8 | +128.5 | 592 | +17.4 | -1.3 | -0.03 |
-| b3_m15_bb0_oos | 345 | +55.5 | 1.47 | 12.4 | +18.2 | +37.3 | 94 | -8.4 | +16.7 | +0.11 |
-| b3_m5_bb0_12mo | 621 | +84.0 | 1.35 | 16.6 | +49.3 | +34.7 | 104 | +9.7 | -20.4 | -0.14 |
-| b3_m5_bb0_5yr | 987 | +113.0 | 1.31 | 15.3 | -7.7 | +120.6 | 134 | +12.0 | -15.5 | -0.08 |
-| b3_m5_bb0_oos | 93 | +10.6 | 1.35 | 5.6 | -2.9 | +13.5 | 9 | +3.7 | +1.2 | +0.01 |
-| b12_h1_nosell_nodiv_12mo | 100 | +23.1 | 1.75 | 4.6 | +21.8 | +1.3 | 0 | +0.0 | -0.8 | +0.20 |
-| b12_h1_nosell_nodiv_5yr | 364 | +58.7 | 1.52 | 12.9 | -4.1 | +62.8 | 0 | +0.0 | +26.3 | +0.34 |
-| b12_h1_nosell_nodiv_oos | 88 | +21.9 | 1.92 | 4.8 | +9.4 | +12.5 | 0 | +0.0 | +16.8 | +0.79 |
-| base_m5_12mo | 575 | +104.3 | 1.50 | 10.7 | +50.8 | +53.5 | 93 | +6.9 | — | — |
-| ctl_h1_12mo | 138 | +24.0 | 1.55 | 8.0 | +19.4 | +4.6 | 47 | +1.8 | — | — |
-| ctl_h1_5yr | 515 | +32.4 | 1.18 | 15.2 | -5.9 | +38.3 | 180 | -16.7 | — | — |
-| ctl_h1_oos | 104 | +5.1 | 1.13 | 7.5 | -0.9 | +6.1 | 26 | -11.5 | — | — |
-| ctl_m15_12mo | 397 | +73.9 | 1.53 | 10.8 | +66.7 | +7.2 | 138 | +8.5 | — | — |
-| ctl_m15_5yr | 1578 | +128.0 | 1.21 | 35.8 | -3.4 | +131.4 | 535 | +12.6 | — | — |
-| ctl_m15_oos | 299 | +38.8 | 1.36 | 15.5 | +5.9 | +32.9 | 86 | -11.7 | — | — |
-| ctl_m5_5yr | 911 | +128.4 | 1.39 | 12.8 | -8.3 | +136.7 | 110 | +3.8 | — | — |
-| ctl_m5_oos | 86 | +9.4 | 1.33 | 8.2 | -1.4 | +10.9 | 4 | +1.5 | — | — |
-
-Raw table (n / R / PF / WR% / DD / H1 / H2 / PF-half-1 / PF-half-2 /
-sellN / sellR / ΔR / ΔPF / Δn vs control; control and `base_m5_12mo`
-rows carry no delta):
-
-```
-book                           n        R    PF   WR%    DD      H1      H2   PF1   PF2 sellN   sellR |      ΔR    ΔPF    Δn
-b1_h1_nosell_12mo             91    +22.2  1.79  62.6   4.1   +20.6    +1.6  2.10  1.18     0    +0.0 |    -1.8  +0.25  -47
-b1_h1_nosell_5yr             335    +49.1  1.46  58.2  13.2    -5.0   +54.1  0.87  1.78     0    +0.0 |   +16.7  +0.28 -180
-b1_h1_nosell_oos              78    +16.7  1.74  62.8   3.6    +7.3    +9.4  1.67  1.81     0    +0.0 |   +11.5  +0.61  -26
-b1_m15_sellB_12mo            341    +74.6  1.62  62.8  10.8   +68.4    +6.2  2.15  1.10    82    +9.1 |    +0.7  +0.09  -56
-b1_m15_sellB_5yr            1378   +119.1  1.22  57.0  41.4   -21.3  +140.3  0.91  1.46   335    +3.7 |    -8.9  +0.02 -200
-b1_m15_sellB_oos             272    +47.1  1.51  60.7  13.8   +12.3   +34.8  1.24  1.85    59    -3.4 |    +8.3  +0.15  -27
-b1_m5_selltrans_12mo         557   +112.2  1.56  53.7   9.9   +55.9   +56.4  1.54  1.58    75   +14.8 |    +7.9  +0.06  -18
-b1_m5_selltrans_5yr          889   +133.7  1.41  51.5  12.8    -8.3  +142.0  0.84  1.52    88    +9.0 |    +5.3  +0.03  -22
-b1_m5_selltrans_oos           86     +9.4  1.33  53.5   8.2    -1.4   +10.9  0.91  1.95     4    +1.5 |    +0.0  +0.00   +0
-b2_h1_nodiv_12mo             149    +28.6  1.62  62.4   6.5   +23.6    +5.0  1.93  1.24    49    +5.5 |    +4.6  +0.07  +11
-b2_h1_nodiv_5yr              567    +40.5  1.20  56.3  14.1    -5.2   +45.6  0.93  1.37   203   -18.2 |    +8.1  +0.02  +52
-b2_h1_nodiv_oos              119     +7.6  1.17  56.3   7.7    -1.9    +9.5  0.91  1.44    31   -14.3 |    +2.4  +0.04  +15
-b2_m15_nodiv_12mo            439    +81.3  1.51  60.8  13.1   +72.3    +8.9  1.90  1.11   147    +7.0 |    +7.4  -0.02  +42
-b2_m15_nodiv_5yr            1771   +139.9  1.20  55.8  47.4   -16.2  +156.1  0.94  1.39   578   +11.7 |   +11.9  -0.01 +193
-b2_m15_nodiv_oos             341    +52.3  1.43  59.2  17.1   +15.6   +36.7  1.23  1.68    93   -10.0 |   +13.5  +0.07  +42
-b3_h1_bb0_12mo               154    +31.2  1.64  60.4   9.4   +22.8    +8.4  1.89  1.36    52    +6.7 |    +7.3  +0.09  +16
-b3_h1_bb0_5yr                583    +37.3  1.18  54.5  18.3    -7.4   +44.7  0.90  1.35   206   -20.4 |    +4.9  +0.00  +68
-b3_h1_bb0_oos                122     +5.6  1.12  55.7   8.7    -2.0    +7.6  0.91  1.33    32   -13.8 |    +0.4  -0.01  +18
-b3_m15_bb0_12mo              439    +49.9  1.29  59.0  19.4   +61.6   -11.8  1.77  0.87   151    +0.3 |   -24.0  -0.23  +42
-b3_m15_bb0_5yr              1790   +126.6  1.18  56.1  42.3    -1.8  +128.5  0.99  1.31   592   +17.4 |    -1.3  -0.03 +212
-b3_m15_bb0_oos               345    +55.5  1.47  61.2  12.4   +18.2   +37.3  1.29  1.66    94    -8.4 |   +16.7  +0.11  +46
-b3_m5_bb0_12mo               621    +84.0  1.35  51.4  16.6   +49.3   +34.7  1.43  1.28   104    +9.7 |   -20.4  -0.14  +46
-b3_m5_bb0_5yr                987   +113.0  1.31  50.7  15.3    -7.7  +120.6  0.85  1.38   134   +12.0 |   -15.5  -0.08  +76
-b3_m5_bb0_oos                 93    +10.6  1.35  54.8   5.6    -2.9   +13.5  0.85  2.17     9    +3.7 |    +1.2  +0.01   +7
-b12_h1_nosell_nodiv_12mo     100    +23.1  1.75  63.0   4.6   +21.8    +1.3  2.00  1.15     0    +0.0 |    -0.8  +0.20  -38
-b12_h1_nosell_nodiv_5yr      364    +58.7  1.52  59.6  12.9    -4.1   +62.8  0.90  1.87     0    +0.0 |   +26.3  +0.34 -151
-b12_h1_nosell_nodiv_oos       88    +21.9  1.92  63.6   4.8    +9.4   +12.5  1.93  1.92     0    +0.0 |   +16.8  +0.79  -16
-base_m5_12mo                 575   +104.3  1.50  52.9  10.7   +50.8   +53.5  1.46  1.53    93    +6.9
-ctl_h1_12mo                  138    +24.0  1.55  60.9   8.0   +19.4    +4.6  1.84  1.22    47    +1.8
-ctl_h1_5yr                   515    +32.4  1.18  55.7  15.2    -5.9   +38.3  0.91  1.34   180   -16.7
-ctl_h1_oos                   104     +5.1  1.13  56.7   7.5    -0.9    +6.1  0.95  1.32    26   -11.5
-ctl_m15_12mo                 397    +73.9  1.53  62.2  10.8   +66.7    +7.2  1.95  1.10   138    +8.5
-ctl_m15_5yr                 1578   +128.0  1.21  56.5  35.8    -3.4  +131.4  0.99  1.37   535   +12.6
-ctl_m15_oos                  299    +38.8  1.36  59.2  15.5    +5.9   +32.9  1.10  1.66    86   -11.7
-ctl_m5_5yr                   911   +128.4  1.39  51.3  12.8    -8.3  +136.7  0.84  1.48   110    +3.8
-ctl_m5_oos                    86     +9.4  1.33  53.5   8.2    -1.4   +10.9  0.91  1.95     4    +1.5
-```
-
-## Decisions
-
-- **SHIPPED** — M5 `xau_strategy.sell_blocked_regimes=["transitioning"]`
-  (b1_m5_selltrans): 12mo +7.9R, 5yr +5.3R, OOS unchanged (no such trades
-  in that window); positive in both 12mo halves on every window. H1
-  `xau_strategy.sell_min_quality=[]` (b1_h1_nosell, all H1 shorts blocked):
-  5yr +16.7R and OOS +11.5R more than pay for the 12mo cost of -1.8R; H1
-  shorts were -16.7R/5yr and -11.5R/OOS in the control. Both land in
-  `pair_signals/xauusd.py`.
-- **REJECTED** — M15 `sell_min_quality=["B"]` (b1_m15_sellB): 5yr -8.9R
-  with max DD widening 35.8 -> 41.4R for a marginal +0.7R on 12mo; fails
-  the drawdown clause. All three B3 Bollinger-weight-0-in-trending-regimes
-  runs (b3_h1_bb0, b3_m15_bb0, b3_m5_bb0): negative on M5 (-20.4R/12mo,
-  -15.5R/5yr) and M15 (-24.0R/12mo, PF 1.29 -> still below the 12mo H2
-  going negative at -11.8R); H1's B3 5yr gain (+4.9R) doesn't clear the
-  bar once M5/M15 fail outright — Bollinger's constant-oppose vote stays
-  a load-bearing quality bar, consistent with the 2026-08-04 audit.
-- **DECLINED** — B2-M15 (`technical.disabled_indicators=["divergence"]`
-  on M15, b2_m15_nodiv): R improves on every window (+7.4/+11.9/+13.5R)
-  but 5yr max DD widens 35.8 -> 47.4R while PF stays flat (1.21 -> 1.20) —
-  more risk for no risk-adjusted gain; owner call.
-- **PARKED** — B2-H1 (`technical.disabled_indicators=["divergence"]` on
-  H1, b2_h1_nodiv, standalone: +4.6/+8.1/+2.4R, PF 1.62/1.20/1.17). The
-  combined run with the H1 no-short override (b12_h1_nosell_nodiv) passes
-  rule 1 and beats the no-shorts override alone on both 5yr and OOS: 12mo
-  100/+23.1R PF 1.75 (halves +21.8/+1.3), 5yr 364/+58.7R PF 1.52, OOS
-  88/+21.9R PF 1.92. Not shipped anyway: it would route through
-  `technical.disabled_indicators`, which CLAUDE.md rule 8 reserves for
-  experiments, not production paths. Owner decision; recommended vehicle
-  is an H1-only `regime_weights_override` with divergence weight 0 plus a
-  fresh validation run under that mechanism.

backtest/research/signal_log_eval_2026-08-18.md

@@ -1,113 +0,0 @@
-# Signal-log live performance evaluation — 2026-08-18
-
-**Tool:** `analyze_signal_log.py` (new, repo root). Read-only on
-`logs/signals.db` (sqlite `immutable=1`); replays every logged trade
-setup through the backtester's own `simulate_trades` on the RAW Oanda
-price path (next-open fill, SL/TP distances preserved, SL-first ties,
-gap-at-open fills, close-only trail ratchet with the per-setup stamped
-trail params). Reproduce:
-
-```bash
-python analyze_signal_log.py --csv backtest/signal_log_eval_20260818.csv
-```
-
-## Window & sample
-
-- Log window: **2026-08-13 14:31 → 2026-08-18 14:13 UTC (5 days)** —
-  the entire signal_log history to date.
-- 2,654 rows (telegram 2,180 / dashboard 474); M5 1,308, M15 1,189,
-  H1 119, H4 38.
-- 39 rows carry a `trade_setup` → **17 unique signal events** after
-  dedup (cross-source double-logs + persisting-signal re-fires collapse
-  on (tf, direction, entry, SL, strategy) with a 60-min gap).
-- **No real executions exist** (`oanda_state.json` empty, no
-  `oanda_daemon` rows) — every outcome below is a hypothetical replayed
-  fill, not a broker fill.
-- Cost: dual convention — **$0.65 rt headline**, $0.30 comparative
-  (derived analytically, R is linear in cost).
-
-## Trade replay results
-
-| First logged | TF | Signal | Grade | Strategy | Fill | Exit | Bars | R@0.65 |
-|---|---|---|---|---|---|---|---|---|
-| 08-13 15:30 | 5min | SELL | B | GENERIC | 4365.39 | TRAIL | 19 | −0.20 |
-| 08-13 18:00 | 15min | SELL | B | GENERIC | 4356.05 | TRAIL | 44 | +0.91 |
-| 08-14 07:45 | 5min | BUY | B | XAU_CP | 4339.72 | TRAIL | 60 | +2.56 |
-| 08-14 12:15 | 15min | BUY | B | GENERIC | 4371.91 | TRAIL | 27 | +0.06 |
-| 08-14 12:25 | 5min | STRONG_BUY | A | GENERIC | 4379.12 | TRAIL | 277 | +0.20 |
-| 08-14 12:30 | 5min | STRONG_BUY | A | GENERIC | 4379.87 | TRAIL | 276 | +0.16 |
-| 08-14 12:30 | 15min | BUY | B | GENERIC | 4379.87 | TRAIL | 63 | +0.18 |
-| 08-17 08:00 | 1h | BUY | C | GENERIC | 4405.19 | TRAIL | 18 | −0.13 |
-| 08-17 14:15 | 5min | STRONG_BUY | A | GENERIC | 4412.35 | TRAIL | 46 | −0.10 |
-| 08-17 14:20 | 5min | STRONG_BUY | A | GENERIC | 4418.55 | TRAIL | 125 | −0.23 |
-| 08-17 14:25 | 5min | STRONG_BUY | A | GENERIC | 4424.10 | SL | 151 | −1.02 |
-| 08-17 14:30 | 15min | BUY | A | GENERIC | 4418.23 | SL | 17 | −1.03 |
-| 08-17 14:45 | 15min | STRONG_BUY | A | GENERIC | 4417.49 | SL | 16 | −1.03 |
-| 08-17 15:00 | 15min | STRONG_BUY | A | GENERIC | 4417.48 | SL | 15 | −1.03 |
-| 08-17 15:00 | 5min | NEUTRAL | C | GENERIC | 4417.48 | TRAIL | 117 | −0.16 |
-| 08-17 15:15 | 15min | STRONG_BUY | A | GENERIC | 4421.30 | SL | 14 | −1.04 |
-| 08-17 15:30 | 15min | BUY | B | GENERIC | 4425.70 | SL | 85 | −1.02 |
-
-**Aggregate: 17 closed, 6 wins (35%), total −2.91R @0.65 / −2.67R
-@0.30, PF 0.58.** By grade: A n=9 → −5.12R; B n=6 → +2.50R; C n=2 →
-−0.30R.
-
-Reading: the book is two regimes. Everything through the 08-14 rally
-made money (+4.7R across 8 events, incl. the XAU_CP +2.56R); the 08-17
-afternoon BUY/STRONG_BUY cluster chased the spike to ~4425 and got
-stopped as price faded — 9 events, −7.6R combined. One bad afternoon
-dominates the 5-day sample. Notable: a NEUTRAL-graded row carried a
-setup (post-gate CP/PB-style path) and lost small.
-
-## Advisory panel scorecard
-
-Only **7 verdicts** logged so far (2 NEUTRAL, 5 OPPOSE, 0 AGREE) — the
-panel's min-quality gate + daily budget keep it dark on most scans.
-
-| Row | When | Signal | Verdict | Outcome basis | Impact |
-|---|---|---|---|---|---|
-| #1358 | 08-17 07:40 M5 | BUY B | NEUTRAL @55% | +4h move | −$8.19 in dir (pass was right) |
-| #1361 | 08-17 07:45 M5 | BUY A | NEUTRAL @55% | +4h move | −$12.43 in dir (pass was right) |
-| #1550 | 08-17 14:15 M5 | STRONG_BUY A | OPPOSE @80% | replay | saved 0.10R |
-| #1553 | 08-17 14:25 M5 | STRONG_BUY A | OPPOSE @80% | replay | saved 1.02R |
-| #1555 | 08-17 14:30 M15 | BUY A | OPPOSE @75% | replay | saved 1.03R |
-| #1561 | 08-17 14:45 M15 | STRONG_BUY A | OPPOSE @75% | replay | saved 1.03R |
-| #1588 | 08-17 15:30 M15 | BUY B | OPPOSE @75% | replay | saved 1.02R |
-
-**Every OPPOSE was correct: ≈ +4.2R would have been lost taking those
-five trades.** The panel's rationale ("price climbed too fast, profit
-too small") correctly identified the 08-17 exhaustion spike that the
-composite scored A. Both NEUTRAL passes also preceded adverse moves.
-Caveat: n=7, one market episode, zero AGREE verdicts — the panel has
-only proven itself as a veto so far, never as a confirmation.
-
-## Directional hit-rate (non-setup signals)
-
-27 deduped non-setup BUY/SELL rows, forward close-to-close on M5:
-
-| Horizon | Hit rate | Mean move in direction |
-|---|---|---|
-| +1h | 48% | −$0.72 |
-| +4h | 44% | −$2.30 |
-| +24h | 7% | −$27.45 |
-
-The 24h figure is dominated by the 08-17 buy-cluster reversal; not
-independently meaningful at n=27.
-
-## Method notes / caveats
-
-- **Small sample**: 5 days, 17 events, one trending episode + one
-  reversal. Directional read only; do not tune anything on this.
-- Entry model = next bar open after the scan boundary (live scans run
-  at boundary+10s), SL/TP distances preserved from the logged setup —
-  identical to the backtester replay loop.
-- Cross-source dedup verified: telegram+dashboard double-logs and
-  5-min re-fires of a persisting signal collapse to one event each.
-- The stray repo-root `signals.db` (828 rows, Aug 13–14, pre-panel
-  schema) is an early duplicate subset of `logs/signals.db` — excluded.
-- Tests: Module 25 in `test_all.py` was only added on 2026-09-03 (the
-  2026-08-18 claim of 7 tests was never true at HEAD). It now covers
-  boundary flooring, clustering (shared `signal_log.setup_key`), trade
-  building, the stored-candle replay books, surface parity, WAL-visible
-  loading (`mode=ro`; `immutable=1` missed the newest rows) and hit-rate
-  signing.

config.json.example

@@ -28,7 +28,10 @@
   "oanda": {
     "account_id": "REPLACE_WITH_ACCOUNT_ID",
     "api_token": "REPLACE_WITH_API_TOKEN",
-    "base_url": "https://api-fxpractice.oanda.com"
+    "base_url": "https://api-fxpractice.oanda.com",
+    "lot_size": 1,
+    "quality_gate": "C",
+    "max_hold_bars": 300
   },
   "deepseek": {
     "api_key": "REPLACE_WITH_YOUR_DEEPSEEK_API_KEY_OR_EMPTY",
@@ -37,28 +40,5 @@
     "timeout_seconds": 12,
     "daily_request_cap": 500
   },
-  "agent_panel": {
-    "enabled": false,
-    "telegram": true,
-    "dashboard": false,
-    "min_quality": "B",
-    "max_panels_per_day": 20,
-    "reuse_ttl_seconds": 3600,
-    "candles_enabled": true,
-    "candle_bars_primary": 20,
-    "candle_bars_confirm": 10,
-    "verdict_source": "macro"
-  },
-  "market_outlook": {
-    "enabled": false,
-    "telegram": false,
-    "max_per_day": 12,
-    "candles_bars": 20
-  },
-  "signal_log": {
-    "enabled": true,
-    "path": "logs/signals.db",
-    "log_blocked_scans": true
-  },
   "log_level": "INFO"
 }

config.py

@@ -31,10 +31,8 @@ class SignalStrength(Enum):
 XAUUSD = "XAU/USD"
 
 # price_precision: decimals for SL/TP rounding and display.
-# default_spread: $0.30 round-trip cost retained for TD-era cross-book
+# default_spread: round-trip cost per trade in price units, charged by
-# comparability and used when the backtester receives no --spread override.
+# the backtester when --spread is not given.
-# Oanda's measured round trip is $0.65-$0.72; research reports headline it
-# separately with --spread 0.65.
 PAIR_INFO = {
     XAUUSD: {"display": "XAU/USD", "pip_value": 0.10,
              "price_precision": 2, "default_spread": 0.30},
@@ -112,10 +110,7 @@ class SignalConfig:
     tp_tightening_factor: float = 1.0
 
     # ── Trade geometry ────────────────────────────────────────────
-    # Deliberately $0.30 for TD-era cross-book comparability. Oanda's measured
+    # Round-trip transaction cost estimate in price units (XAU ~$0.30).
-    # round trip is $0.65-$0.72, reported separately in re-pin campaigns.
-    # This is also a LIVE gate input: increasing it to $0.65 raises the TP1
-    # floor from about $9 to $19.50, so it requires rule-1 revalidation.
     round_trip_cost: float = 0.30
     # Spread gate: reject setups whose TP1 distance is below
     # round_trip_cost × this multiple (caps cost at ~3% of target).
@@ -171,13 +166,6 @@ class NewsConfig:
     # Must stay below pre_event_buffer_minutes so an event can't cross
     # into the danger window while a stale cache says it's clear.
     context_cache_ttl_seconds: int = 600
-    # Maximum age of RSS headlines accepted for scoring. Older headlines
-    # (and headlines with no parsable publish time) are discarded before
-    # keyword analysis and LLM enrichment. 12 h → 4 h on 2026-09-04: the
-    # 3-week signal log showed the 12 h mean was a trailing echo of the
-    # previous day's price move (see backtest/research/
-    # news_sentiment_value_2026-09-04.md). Display/warning-only either way.
-    headline_max_age_seconds: int = 14400  # 4 hours
 
     rss_feeds: List[str] = field(default_factory=lambda: [
         "https://investinglive.com/feed/",

dashboard_publisher.py

@@ -11,9 +11,9 @@ can only ever mean a stale page.
 Independence rules (owner requirement — the telegram bot must be
 immune to anything on the web side):
   * Runs as its own process; never imported by, and never imports,
-    `telegram_bot` (telegram_bot resolves credentials at import). The
+    `telegram_bot` / `oanda_daemon` (telegram_bot resolves credentials
-    confirmation map and boundary math are therefore duplicated here
+    at import). The confirmation map and boundary math are therefore
-    as local constants.
+    duplicated here as local constants.
   * The only shared-code dependency beyond the standard signal path is
     the additive `NewsEngine.get_week_events` accessor, which no
     production signal path calls.
@@ -49,7 +49,6 @@ from datetime import datetime, timezone
 from logging.handlers import TimedRotatingFileHandler
 from typing import Dict, List, Optional
 
-from agent_panel import attach_panel
 from config import PlatformConfig, Timeframe, XAUUSD
 from main import report_to_dict
 from news_engine import NewsEngine
@@ -82,7 +81,7 @@ SUMMARY_PHP_FILE = "news_summary.php"
 # Repo files copied into the out dir at daemon start (git pull + restart
 # updates them). The PHP endpoint reads news.json in place, so it lives
 # next to the page.
-STATIC_FILES = [PAGE_FILE, "dashboard.css", "dashboard.js", SUMMARY_PHP_FILE]
+STATIC_FILES = [PAGE_FILE, SUMMARY_PHP_FILE]
 
 
 # ══════════════════════════════════════════════════════════════════
@@ -236,8 +235,8 @@ def due_timeframes(wake_dt: datetime) -> List[Timeframe]:
 
 
 def seconds_until_boundary(interval_minutes: int, buffer: int = 10) -> float:
-    # Same math as telegram_bot.py — kept local so the dashboard never
+    # Same math as telegram_bot.py / oanda_daemon.py — kept local so the
-    # imports bot modules (independence rules above).
+    # dashboard never imports bot modules (independence rules above).
     now = datetime.now(timezone.utc)
     total_minutes = now.hour * 60 + now.minute
     elapsed_minutes = total_minutes % interval_minutes
@@ -322,7 +321,6 @@ class DashboardPublisher:
     def __init__(self, out_dir: str):
         self.out_dir = out_dir
         self.snapshots: Dict[str, dict] = {}
-        self._reports = {}
         self.news_payload: Optional[dict] = None
         self._dp = None
         self._news_engine: Optional[NewsEngine] = None
@@ -359,7 +357,6 @@ class DashboardPublisher:
         try:
             report = produce_signal(XAUUSD, tf, self._provider(),
                                     CONFIRMATIONS[tf])
-            self._reports[tf.value] = report
             self.snapshots[tf.value] = {
                 "status": "ok",
                 "scanned_at": datetime.now(timezone.utc).isoformat(),
@@ -371,41 +368,16 @@ class DashboardPublisher:
             logger.info(f"{tf.value}: {report.final_signal.name} "
                         f"q={report.signal_quality or '-'} "
                         f"({time.time() - started:.1f}s)")
-        except Exception:
+        except Exception as e:
             # Keep the last good report; the page shows it with an
             # error badge instead of going blank.
             logger.exception(f"{tf.value} scan failed")
-            self._reports.pop(tf.value, None)
             entry = self.snapshots.get(tf.value) or _empty_tf_entry()
             entry["status"] = "error"
-            # The public snapshot carries a stable message; exception
+            entry["error"] = f"{type(e).__name__}: {e}"
-            # detail remains in dashboard.log for the operator.
-            entry["error"] = "Scan unavailable"
             entry["error_at"] = datetime.now(timezone.utc).isoformat()
             self.snapshots[tf.value] = entry
 
-    def attach_panels(self, tfs: List[Timeframe]) -> bool:
-        """Add advisory panels after publishing the technical snapshot.
-
-        A panel is display-only and can take tens of seconds on a cold LLM
-        request. Keeping its report object locally lets the page receive the
-        candle-close signal first, then a second atomic snapshot only when a
-        panel produced a result.
-        """
-        updated = False
-        for tf in tfs:
-            report = self._reports.get(tf.value)
-            if report is None:
-                continue
-            if not attach_panel(report, surface="dashboard"):
-                continue
-            entry = self.snapshots.get(tf.value)
-            if entry is None or entry.get("status") != "ok":
-                continue
-            entry["report"] = report_to_webapp_dict(report)
-            updated = True
-        return updated
-
     def refresh_news(self) -> None:
         try:
             ne = self._news()
@@ -432,11 +404,11 @@ class DashboardPublisher:
     def run_cycle(self, tfs: List[Timeframe]) -> None:
         for tf in tfs:  # sequential — see module docstring (cache dedup)
             self.scan_tf(tf)
-        # Technical signals land before any optional slow work. News and the
+        # Snapshot lands BEFORE the news refresh: when the news TTL has
-        # advisory panel are display-only and may take 20-30 seconds cold.
+        # expired, refresh_news does FF + 4 RSS fetches (and possibly
+        # DeepSeek calls) — 20-30 s that must not keep fresh signals off
+        # the page.
         self.publish_snapshot()
-        if self.attach_panels(tfs):
-            self.publish_snapshot()
         self.refresh_news()
         self.publish_news()
 

deploy/README-dashboard.md

@@ -100,11 +100,6 @@ the public page, accepted with these guards baked into the PHP — the id must
 match a headline in the published news.json (arbitrary text can never reach
 the LLM), each headline's summary is cached forever in `ai/` (≤1 API call per
 headline, ever), and a file-based daily cap fails **closed** on I/O errors.
-Since 2026-09-04 the engine publishes only headlines up to 4 h old whose
-score leans one way (neutral items are dropped), so a headline leaves the
-whitelist sooner: a dialog left open past that point returns `unknown_id`
-("This headline has left the live feed"); summaries already cached in `ai/`
-stay reachable.
 
 Requirements: `php` + the curl extension (`php -m | grep curl`).
 

docs/architecture_diagram.py

@@ -130,6 +130,13 @@ box(31, 33.2, 38, 5.2, "SignalReport",
 band(1, 13.2, 98, 17.2, "DELIVERY SURFACES", "#4C8F50")
 box(2.5, 15.0, 12, 12.6, "main.py",
     ["CLI report", "--detail", "--json"], DEL_FC, DEL_EC)
+box(16, 15.0, 24, 12.6, "oanda_daemon.py + executor",
+    ["practice auto-execution",
+     "book-parity rules: no broker TP,",
+     "5-bar cooldown, once-per-bar",
+     "trail, OPEN_ONLY fills,",
+     "boot reconcile · orders → Oanda"],
+    DEL_FC, DEL_EC, title_fs=7.8)
 box(42.5, 15.0, 31, 12.6, "dashboard_publisher.py  →  Apache",
     ["independent daemon · scans at candle closes",
      "atomic publish to /var/www/trade:",
@@ -163,6 +170,7 @@ arrow((55, 69.8), (55, 63.1), label="warn-only context", lx=0, ly=1.0)
 arrow((86, 69.8), (86, 67.3), ls=(0, (3, 2)), lw=1.1)                  # config → core
 arrow((50, 40.5), (50, 38.8))                                          # core → report
 arrow((36, 34.5), (8.5, 27.95), conn="arc3,rad=0.12")                  # report → cli
+arrow((40, 33.2), (28, 27.95), conn="arc3,rad=0.06")                   # report → daemon
 arrow((60, 33.2), (58, 27.95))                                         # report → dashboard
 arrow((66, 34.5), (86.5, 27.95), conn="arc3,rad=-0.12")                # report → telegram
 
@@ -173,6 +181,7 @@ arrow((95, 86.2), (95, 27.95), conn="arc3,rad=0.15", color=HAUL,
 ax.text(99.2, 57, "alerts / commands", fontsize=6.4, color=MUT,
         rotation=90, ha="center", va="center")
 # browser click → news_summary.php → DeepSeek
+# (oanda_daemon's order flow is noted inside its box — no long arc)
 arrow((66, 27.95), (73, 86.2), conn="arc3,rad=-0.18", color=HAUL,
       lw=1.2, ls=(0, (4, 2)),
       label="on-demand AI summary\n(browser click → PHP)", lx=2.5, ly=11.6)

docs/beginner_guide.html

@@ -86,7 +86,6 @@
 <li><b>Grade (A+, A, B, C):</b> the bot's own mark for how clean the setup is. A+ is best. It never sends anything worse than C.</li>
 <li><b>Confidence and the indicator list:</b> extra detail for curious people. You don't need to understand it to trade the signal.</li>
 <li><b>⚠️ Warning lines:</b> things the bot noticed, like high volatility. They are "be aware," not "don't trade."</li>
-<li><b>📰 News line:</b> a short plain-English note on what is moving the gold price right now and why, written from the last few hours of headlines. It is background information, not a reason to trade.</li>
 <li><b>The trade setup at the bottom is the only part you must act on.</b></li>
 </ul>
 
@@ -135,8 +134,6 @@ The message says: <i>"once price hits 4,159, trail SL $33 behind best price."</i
 <ul>
 <li><b>H1 is forgiving.</b> You have up to an hour to act on a message, and small delays barely matter. On the 5-minute signals, being two minutes late already costs real money — they are not for manual beginners.</li>
 <li><b>H1 trades are held longer</b> — often overnight, sometimes over days. That is normal. Your stop loss is working for you while you sleep.</li>
-<li><b>H1 is BUY-only.</b> All H1 SELL signals are blocked (since 2026-09-03) because they were a losing side on this timeframe — expect to see BUY signals here, never SELL.</li>
-<li><b>M5 also holds back some SELL signals</b> — specifically while the market is in a choppy "transitioning" phase, since those shorts tested poorly.</li>
 <li><b>Never take the same signal on two timeframes.</b> They are usually the same gold move seen at different zoom levels. Taking both doubles your risk, not your profit.</li>
 </ul>
 

docs/user_guide.html

@@ -69,7 +69,7 @@
 <tr><td><b>Score / confidence</b></td><td>The regime-weighted composite of all nine indicators. Bigger absolute score = stronger consensus.</td></tr>
 <tr><td><b>MTF aligned</b></td><td>The two confirmation timeframes agree with the trade direction. Signals without alignment are filtered out on M5.</td></tr>
 <tr><td><b>Warnings ⚠️</b></td><td>Context, not veto. Backtesting shows warned trades perform about the same — strong momentum often triggers warnings.</td></tr>
-<tr><td><b>Market context 📰</b></td><td>An AI-written note in plain English on what is moving the gold price right now, why it matters, and the next report to watch. It is built only from headlines published in the last 4 hours that lean one way (neutral items are dropped) plus today's high-impact releases. Informational only — it never blocks or grades a signal.</td></tr>
+<tr><td><b>Market context 📰</b></td><td>An AI-written one-liner summarizing today's macro backdrop (headlines + high-impact releases) and its likely pull on gold. Informational only — it never blocks or grades a signal.</td></tr>
 <tr><td><b>SL / TP1 / RR</b></td><td>Stop loss sits behind the nearest swing level with an ATR buffer. TP1 is the nearest opposing level. <b>1R</b> = the entry-to-SL distance = the amount you risk.</td></tr>
 <tr><td><b>Trail plan 🔄</b></td><td>The real exit. Once price moves +0.6R in your favor, move the stop to trail 0.75R behind the best price and update it at each candle close. <b>TP1 is advisory — let winners run.</b></td></tr>
 </table>
@@ -84,27 +84,27 @@
 </ol>
 
 <h2>4 · Choosing your timeframe</h2>
-<p>Twelve-month Oanda-candle backtest (Aug 2025 – Aug 2026, $0.65 round-trip cost, entry at next candle open):</p>
+<p>Twelve-month backtest (Jul 2025 – Jul 2026, real spreads, entry at next candle open):</p>
 <table>
 <tr><th></th><th>M5</th><th>M15</th><th>H1</th></tr>
-<tr><td>Trades / week</td><td>~11.3</td><td>~7.6</td><td>~2.7</td></tr>
+<tr><td>Trades / week</td><td>~10</td><td>~9.5</td><td>~3</td></tr>
-<tr><td>Total result (12 mo)</td><td>+106.8R</td><td>+73.9R</td><td>+24.0R</td></tr>
+<tr><td>Total result (12 mo)</td><td>+135.6R</td><td>+67.2R</td><td>+49.9R</td></tr>
-<tr><td>Win rate / profit factor</td><td>52.9% / 1.51</td><td>62.2% / 1.53</td><td>60.9% / 1.55</td></tr>
+<tr><td>Win rate / profit factor</td><td>59.7% / 1.81</td><td>55.8% / 1.40</td><td>59.4% / 1.94</td></tr>
-<tr><td>Typical (median) hold</td><td>2.4 h</td><td>7 h</td><td>15.5 h</td></tr>
+<tr><td>Typical (median) hold</td><td>2.4 h</td><td>6 h</td><td>12.5 h</td></tr>
-<tr><td>90% of trades close within</td><td>10.5 h</td><td>29.8 h</td><td>3.2 days</td></tr>
+<tr><td>90% of trades close within</td><td>16 h</td><td>40 h</td><td>3.7 days</td></tr>
-<tr><td>Typical stop distance</td><td>~$21</td><td>~$32</td><td>~$52</td></tr>
+<tr><td>Typical stop distance</td><td>~$19</td><td>~$29</td><td>~$44</td></tr>
-<tr><td>Worst drawdown</td><td>10.7R</td><td>10.8R</td><td>8.0R</td></tr>
+<tr><td>Worst drawdown</td><td>11.2R</td><td>9.4R</td><td>9.5R</td></tr>
 </table>
 <ul>
-<li><b>M5 — intraday, execution-critical.</b> Highest total edge, but stops are tight: a couple of dollars of slippage or a late entry eats a meaningful share of every trade. Suitable only if you can act within a minute or two of the alert (or automate). Trades open and close within a session; you sleep flat. SELL signals are held back while the market regime reads "transitioning" — a validated filter, not a bug if you notice fewer shorts there.</li>
+<li><b>M5 — intraday, execution-critical.</b> Highest total edge, but stops are tight: a couple of dollars of slippage or a late entry eats a meaningful share of every trade. Suitable only if you can act within a minute or two of the alert (or automate). Trades open and close within a session; you sleep flat.</li>
 <li><b>M15 — the middle path.</b> Same frequency as M5, wider stops, up to 15 minutes to act. About half your trades will still be open overnight.</li>
-<li><b>H1 — swing trading around a normal life.</b> Best quality per trade and very forgiving of slow manual execution (you have up to an hour). The costs: positions held for days, through news and overnight sessions, and a <b>lumpy</b> equity curve — one quarter of the test year was negative and most of the profit came in a single quarter. Judge it on quarters, not weeks. H1 no longer issues SELL signals at all (blocked since 2026-09-03) — it is BUY-only on this timeframe.</li>
+<li><b>H1 — swing trading around a normal life.</b> Best quality per trade and very forgiving of slow manual execution (you have up to an hour). The costs: positions held for days, through news and overnight sessions, and a <b>lumpy</b> equity curve — one quarter of the test year was negative and most of the profit came in a single quarter. Judge it on quarters, not weeks.</li>
 </ul>
 <div class="callout"><b>If you trade manually from the Telegram alerts, H1 (or M15) is the honest choice.</b> M5's backtested edge assumes near-instant fills that a human copying signals rarely achieves.</div>
 
 <h2>5 · What to expect (and what not to)</h2>
 <ul>
-<li><b>You will lose roughly 38–47% of trades.</b> A 53–62% win rate means losing streaks of 5+ are routine over a year. The system's edge is the average across hundreds of trades, not any single one.</li>
+<li><b>You will lose ~40% of trades.</b> A 56–60% win rate means losing streaks of 5+ are routine over a year. The system's edge is the average across hundreds of trades, not any single one.</li>
 <li><b>Stops hit fast, winners take time.</b> Losing trades die in roughly half the time winners take. An early stop-out is the system doing its job.</li>
 <li><b>Drawdowns of ~10R are normal.</b> At 1% risk per trade, expect to be ~10% down from a peak at some point in a normal year. This is why risking more than 1% per trade is how accounts die.</li>
 <li><b>Backtest ≠ live.</b> Results above charge real spreads and realistic fills, but cannot model your personal latency, broker slippage, or requotes. Assume live results will be somewhat worse — especially on M5.</li>
@@ -130,7 +130,7 @@
 <tr><td><code>/scan</code></td><td>Run an immediate analysis of the primary timeframe.</td></tr>
 <tr><td><code>/autoscan</code></td><td>Toggle automatic scanning (M5 / M15 / H1 / H4 at each candle close).</td></tr>
 <tr><td><code>/status</code></td><td>Uptime, auto-scan state, WebSocket price-monitor state.</td></tr>
-<tr><td><code>/news</code></td><td>Net XAU/USD news score from the last 4 hours of headlines (neutral headlines are removed before averaging; informational only — never gates signals).</td></tr>
+<tr><td><code>/news</code></td><td>Net XAU/USD news sentiment score (informational only — never gates signals).</td></tr>
 <tr><td><code>/cache</code> · <code>/clearcache</code></td><td>Inspect / reset the market-data cache.</td></tr>
 <tr><td><code>/help</code></td><td>Command reference.</td></tr>
 </table>

llm_client.py

@@ -90,11 +90,7 @@ class DeepSeekClient:
             if self._count_day != today:
                 self._count_day = today
                 self._count = 0
-                # Clear ALL warn-once kinds, not just "cap": the network/
+                self._warned.discard("cap")
-                # http_*/parse flags used to be set once and never reset,
-                # so in a daemon that runs for weeks the second and every
-                # later outage logged at DEBUG only.
-                self._warned.clear()
             if self._count >= self._daily_cap:
                 self._warn_once(
                     "cap", "DeepSeek daily request cap (%d) exhausted — "
@@ -153,14 +149,6 @@ class DeepSeekClient:
                             "expected JSON object — ignoring")
         else:
             self.last_ok = time.time()
-            # A recovered call re-arms the failure warnings so the NEXT
-            # outage is visible at WARNING again. "cap" keeps its own
-            # UTC-day reset in _under_cap. (Taken under the lock; safe
-            # here because chat_json holds no lock — _under_cap has
-            # already returned.)
-            if self._warned - {"cap"}:
-                with self._lock:
-                    self._warned = {k for k in self._warned if k == "cap"}
         return parsed
 
     @staticmethod

llm_provider_switch_plan.txt

@@ -1,252 +0,0 @@
-================================================================================
-MULTI-PROVIDER LLM LAYER - PLAN
-(DeepSeek for news summary, Anthropic Claude for agent panel)
-Written 2026-08-08. Plan only - no code has been changed.
-================================================================================
-
-WHY
----
-Today every LLM feature (news enrichment + agent panel) goes through one
-hardwired client: llm_client.py -> DeepSeekClient, a module singleton reached
-via get_llm_client(). This plan describes how to route different features to
-different providers - e.g. keep DeepSeek for cheap high-volume news scoring,
-put the agent panel on Anthropic Claude for better reasoning.
-
-The repo already solved this problem once for market data: the providers/
-package (BaseDataProvider owns shared machinery, subclasses implement only
-_fetch_raw, a registry + one config knob selects the provider). This plan
-mirrors that proven pattern at the LLM layer, scaled down to a single module.
-
-BLAST RADIUS (verified by grep)
--------------------------------
-get_llm_client() call sites:
-  - news_engine.py ....... 4 sites
-  - agent_panel.py ....... 3 sites (+1 timeout getattr)
-  - telegram_bot.py ...... 1 site (/status health; reads private _count,
-                           _count_day, _daily_cap fields)
-  - test_all.py .......... 41 locations stub via  lc._client = _StubLLM(...)
-Out of scope: static/news_summary.php (own PHP DeepSeek call + key file,
-separate deployment).
-
-DESIGN INVARIANTS (carried over unchanged)
-------------------------------------------
-1. Fail-safe contract: every call returns Optional[Dict]; any failure -> None;
-   callers keep their non-LLM fallbacks; LLM output never gates signals.
-2. Single attempt, no retries (news cache cadence is the retry); per-provider
-   UTC daily cap; warn-once logging; health stamps (last_ok, last_error).
-3. Static system prompts stay byte-identical constants - provider-neutral,
-   and they map to prompt caching on BOTH providers (DeepSeek prefix cache;
-   Anthropic cache_control ephemeral).
-4. Test compatibility: all 41 existing lc._client stub sites keep working
-   with zero edits.
-
-================================================================================
-1. llm_client.py REFACTOR  (~195 -> ~430 lines, no new files)
-================================================================================
-
-1a. BaseLLMClient - shared machinery (extracted from today's DeepSeekClient)
-    - __init__(api_key, model, timeout, daily_cap, enabled)
-    - public: name ("deepseek"/"anthropic"), timeout property,
-      usage() -> (used_today, cap)   # so telegram_bot stops reading privates
-    - owns: available property, _warn_once, _under_cap() (UTC-day counter,
-      lock), health stamps, and the template method:
-
-        def chat_json(self, system_prompt, user_payload):
-            if not self.available or not self._under_cap():
-                return None
-            try:
-                return self._request(system_prompt, user_payload)  # hook
-            except <provider-agnostic error mapping>:
-                # stamps last_error, returns None
-
-    - subclasses implement ONLY _request(system_prompt, payload) -> dict|None.
-
-1b. DeepSeekClient(BaseLLMClient) - behavior-identical move
-    Current requests-based logic relocates into _request: same URL,
-    thinking:disabled, response_format:json_object, temperature 0,
-    max_tokens 2000, sort_keys=True payload, _parse_response.
-    Review criterion: Module 19 tests pass UNMODIFIED (they patch
-    client._session, which stays).
-
-1c. AnthropicClient(BaseLLMClient) - new, official SDK
-    - Official `anthropic` Python SDK (add to requirements.txt), NOT raw
-      requests. LAZY IMPORT inside __init__: package missing -> warn-once +
-      client unavailable, so DeepSeek-only deployments never install it.
-    - Constructor: anthropic.Anthropic(api_key=..., timeout=<configured>,
-      max_retries=0)   # house rule: single attempt
-    - _request:
-        resp = self._client.messages.create(
-            model=self._model,                  # default "claude-opus-5"
-            max_tokens=4000,                    # covers thinking + JSON reply
-            output_config={"effort": "low"},    # cheap structured takes
-            system=[{"type": "text", "text": system_prompt,
-                     "cache_control": {"type": "ephemeral"}}],
-            messages=[{"role": "user",
-                       "content": json.dumps(user_payload, sort_keys=True)}],
-        )
-        if resp.stop_reason == "refusal":       # Opus 5: HTTP 200, check first
-            return None
-        text = first text block in resp.content
-        return self._parse_json(text)   # tolerant: strip ```json fences,
-                                        # json.loads, dict check
-    - DELIBERATELY ABSENT (would 400 on Claude Opus 5): temperature (removed
-      on Opus 5 - do NOT copy from the DeepSeek client), budget_tokens,
-      prefills, response_format.
-    - Error mapping: APIConnectionError -> "network",
-      APIStatusError -> "http_<code>", parse fail -> "parse"
-      (same last_error kinds the /status display already understands).
-    - Defaults: model claude-opus-5 (config-overridable, e.g. claude-haiku-4-5
-      for ~5x cheaper), timeout 30s (Claude slower than V4-Flash), own
-      daily_request_cap 500.
-
-1d. Registry + per-consumer routing
-        _PROVIDERS = {"deepseek": DeepSeekClient, "anthropic": AnthropicClient}
-        LLM_CONSUMERS = ("news", "agent_panel")
-        _clients = {}     # keyed by PROVIDER name -> two consumers on the
-                          # same provider share one instance and one cap
-        _client = None    # kept: GLOBAL TEST OVERRIDE
-
-        def get_llm_client(consumer="news"):
-            if _client is not None:          # tests: lc._client = stub
-                return _client               #   -> shadows ALL consumers
-            name = get_app_config().llm_routing.get(consumer, "deepseek")
-            create-once per provider, return _clients[name]
-
-        def reset_llm_client():              # clears _client AND _clients
-
-    Keeping _client as a documented test-override global is what makes the
-    41 existing stub sites work untouched.
-
-================================================================================
-2. CONFIG  (app_config.py + config.json.example)
-================================================================================
-- New top-level "anthropic" block, mirroring "deepseek":
-    {api_key, model, enabled, timeout_seconds, daily_request_cap}
-  plus anthropic_api_key() resolver: ANTHROPIC_API_KEY env -> config.json -> "".
-- New top-level "llm" ROUTING block:
-    {"news": "deepseek", "agent_panel": "deepseek"}
-  Validation: keys within {news, agent_panel}; values within registered
-  provider names. Absent block -> {} -> everything on DeepSeek (today's
-  behavior; zero-migration default). AppConfig.llm_routing: Dict[str, str].
-
-- The target state is then PURE CONFIG - no code changes on switch day:
-
-    "llm":       { "news": "deepseek", "agent_panel": "anthropic" },
-    "anthropic": { "api_key": "", "model": "claude-opus-5", "enabled": true,
-                   "timeout_seconds": 30, "daily_request_cap": 500 }
-
-================================================================================
-3. CONSUMER EDITS  (mechanical, ~10 lines total)
-================================================================================
-- news_engine.py:  4 call sites -> get_llm_client("news")
-- agent_panel.py:  3 call sites -> get_llm_client("agent_panel");
-                   getattr(client, "_timeout", ...) -> public client.timeout
-- telegram_bot.py _news_health_lines: iterate the DISTINCT providers actually
-  routed (news + panel); per provider print "<name>: used/cap calls today"
-  via the new usage() accessor instead of private fields. DeepSeek keeps its
-  "headlines scored" extra; cap/error warnings work off base-class stamps.
-- NO changes to prompts, payload builders, caches, or the panel's own
-  max_panels_per_day budget - all provider-agnostic already.
-
-================================================================================
-4. TESTS  (new "Module 24: LLM provider routing", ~12 tests, ~200 lines)
-================================================================================
-Reuse _StubLLM; new _FakeAnthropic (fake messages.create returning a stub
-response object) injected as client._client.
-
- 1. app_config: anthropic block parses/validates/defaults empty.
- 2. app_config: llm routing block - valid map round-trips; unknown consumer
-    key, unknown provider name, non-dict -> AppConfigError; absent -> {}.
- 3. anthropic_api_key resolves env -> config.json -> empty.
- 4. Base contract on BOTH subclasses (parametrized): keyless/disabled -> no
-    call; daily cap blocks + UTC-roll reset; failure stamps last_error,
-    success stamps last_ok.
- 5. AnthropicClient parse: clean JSON -> dict; ```json-fenced -> dict;
-    non-JSON -> None; stop_reason "refusal" -> None; no text block -> None.
- 6. AnthropicClient request shape: NO temperature key, max_retries=0,
-    cache_control present on system block (assert on captured kwargs).
- 7. AnthropicClient with `anthropic` package missing (simulated) ->
-    available False, chat_json None, no crash at import.
- 8. Routing: no llm block -> both consumers get the SAME DeepSeek singleton
-    (shared cap); routed config -> news gets DeepSeekClient while
-    agent_panel gets AnthropicClient; same-provider consumers share one
-    instance.
- 9. Global lc._client override shadows BOTH consumers (locks the 41 legacy
-    stub sites' semantics).
-10. reset_llm_client() clears both the override and the per-provider cache.
-11. End-to-end: routing agent_panel->anthropic, attach_panel reaches the
-    anthropic fake (5 calls) while a news call reaches the deepseek stub.
-12. telegram _news_health_lines renders per-provider lines from usage()
-    without touching private fields.
-
-GATE: Modules 19 and 23 must pass UNMODIFIED - the no-regression proof for
-the refactor.
-
-================================================================================
-5. DOCS
-================================================================================
-- CLAUDE.md: llm_client bullet -> provider-abstracted (BaseLLMClient;
-  deepseek + anthropic registered); config.json "llm" block routes consumers;
-  absent = all-DeepSeek. Add ANTHROPIC_API_KEY to env-var list. Test counts.
-- config.json.example: both new blocks.
-
-================================================================================
-COMMIT SEQUENCE  (each commit green)
-================================================================================
-1. llm_client: extract BaseLLMClient; DeepSeekClient unchanged behavior
-   (+ base-contract tests)  - pure refactor, Modules 19/23 green untouched.
-2. config: anthropic block + llm consumer-routing block (+ config tests).
-3. llm_client: AnthropicClient (official SDK, lazy import) + requirements.txt
-   (+ parse/shape tests).
-4. routing: per-consumer get_llm_client + health lines - consumer call-site
-   edits, telegram usage() lines, routing/e2e tests.
-5. docs: CLAUDE.md + example config.
-
-================================================================================
-VERIFICATION
-================================================================================
-- python test_all.py green at every commit (~374 -> ~386).
-- Live smoke A (no behavior change): default config, main.py --panel ->
-  still DeepSeek, /status unchanged.
-- Live smoke B (the goal): llm.agent_panel="anthropic" + real
-  ANTHROPIC_API_KEY, run --panel -> one real Claude panel (5 requests,
-  validates JSON contract + latency + refusal-free path) while a news
-  refresh still hits DeepSeek; /status shows two provider lines.
-- Backtest untouched by construction (no LLM in replay path); one 30-day
-  run as a formality.
-
-================================================================================
-EFFORT ESTIMATE
-================================================================================
-0 new files, 8 modified, ~520 lines, est. 3-5 hours.
-
-  llm_client.py        base class + AnthropicClient + routing   +235
-  test_all.py          Module 24                                +200
-  app_config.py        anthropic + llm blocks, resolver          +55
-  telegram_bot.py      per-provider health lines                 +15
-  news_engine.py       consumer tags on call sites                +4
-  agent_panel.py       consumer tags on call sites                +4
-  config.json.example  blocks                                    +14
-  requirements.txt     anthropic                                  +1
-  CLAUDE.md            docs                                      +10
-
-================================================================================
-KEY DECISIONS EMBEDDED IN THIS PLAN
-================================================================================
-- Official Anthropic SDK, not raw requests (current API guidance for Python;
-  lazy import keeps it optional for DeepSeek-only installs).
-- Default Claude model: claude-opus-5 ($5/$25 per MTok; a full 5-call panel
-  ~ 8k in / 500 out ~ $0.05). Config-overridable to claude-haiku-4-5.
-- Two Claude gotchas handled: temperature is REMOVED on Opus 5 (sending it
-  400s - must not be copied from the DeepSeek request body), and refusals
-  arrive as HTTP 200 with stop_reason "refusal" (checked before parsing,
-  mapped to the normal None/fallback path).
-- Caps are per-provider, not per-consumer: two consumers on one provider
-  share its cap (today's semantics); splitting across two providers doubles
-  total headroom naturally.
-- The panel's own max_panels_per_day budget is untouched - it sits above
-  whichever provider serves it.
-- Not in scope: static/news_summary.php (own PHP client/key), streaming,
-  tool use, per-consumer model overrides (add a "model" key per consumer
-  later if ever needed).
-================================================================================

main.py

@@ -13,7 +13,6 @@ import json
 import logging
 import sys
 from datetime import datetime, timezone
-from typing import Optional
 
 # Force UTF-8 output on Windows so box-drawing chars render
 if hasattr(sys.stdout, "reconfigure"):
@@ -21,9 +20,7 @@ if hasattr(sys.stdout, "reconfigure"):
 if hasattr(sys.stderr, "reconfigure"):
     sys.stderr.reconfigure(encoding="utf-8")
 
-from agent_panel import attach_panel
 from config import PlatformConfig, Timeframe, SignalStrength, XAUUSD
-from market_outlook import OutlookResult, maybe_run_outlook
 from pair_signals import PAIR_PRODUCERS
 from signal_aggregator import SignalAggregator, SignalReport
 
@@ -166,15 +163,6 @@ def print_signal_report(report: SignalReport, detail: bool = False):
         print(f"  {Colors.MAGENTA}📰{Colors.RESET} {report.news_description}")
     if report.news_summary:
         print(f"  {Colors.MAGENTA}🧠{Colors.RESET} {report.news_summary}")
-    if report.panel_verdict:
-        panel_label = ("AI macro view"
-                      if report.panel_verdict_source == "macro" else "AI Panel")
-        print(f"  {Colors.CYAN}🤖{Colors.RESET} {panel_label}: "
-              f"{Colors.BOLD}{report.panel_verdict}{Colors.RESET} "
-              f"({report.panel_confidence:.0f}%) — {report.panel_rationale}")
-        for t in report.panel_takes:
-            print(f"     {Colors.GRAY}{t['persona']:<11} {t['stance']:<8} "
-                  f"{t['note']}{Colors.RESET}")
 
     # ── 6. DETAIL (only with --detail) ─────────────────────────────
     if detail and report.primary_analysis:
@@ -201,24 +189,6 @@ def print_signal_report(report: SignalReport, detail: bool = False):
                     print(f"    {label:>20}  {color}{val:.3f}{Colors.RESET}")
 
 
-def print_market_outlook(outlook: Optional[OutlookResult]) -> None:
-    """Render the independent advisory outlook for explicit CLI use."""
-    print(f"\n  {Colors.BOLD}AI Market Outlook{Colors.RESET}")
-    if outlook is None:
-        print(f"  {Colors.GRAY}Unavailable (disabled, market closed, or no LLM response).{Colors.RESET}")
-        return
-    forming = {
-        "buy": "possible buy forming",
-        "sell": "possible sell forming",
-        "none": "no clear setup forming",
-    }[outlook.setup_forming]
-    print(f"  {outlook.bias.title()} · {forming} · {outlook.confidence:.0f}%")
-    if outlook.watch:
-        print(f"  Watch: {outlook.watch}")
-    if outlook.note:
-        print(f"  {Colors.GRAY}{outlook.note}{Colors.RESET}")
-
-
 def report_to_dict(report: SignalReport) -> dict:
     d = {
         "symbol": report.symbol,
@@ -239,13 +209,6 @@ def report_to_dict(report: SignalReport) -> dict:
         "news_sentiment": round(report.news_sentiment, 3),
         "news_description": report.news_description,
         "news_summary": report.news_summary,
-        "panel_verdict": report.panel_verdict,
-        "panel_confidence": round(report.panel_confidence, 1),
-        "panel_rationale": report.panel_rationale,
-        "panel_takes": report.panel_takes,
-        "panel_created_at": report.panel_created_at,
-        "panel_cache_status": report.panel_cache_status,
-        "panel_payload_hash": report.panel_payload_hash,
         "bullish_reasons": report.bullish_reasons,
         "bearish_reasons": report.bearish_reasons,
         "warnings": report.warnings,
@@ -262,8 +225,6 @@ def report_to_dict(report: SignalReport) -> dict:
             "risk_pips": round(ts.risk_pips, 1),
             "reward_pips": round(ts.reward_pips, 1),
             "strategy": ts.strategy,
-            "setup_pattern": ts.setup_pattern,
-            "round_trip_cost": ts.round_trip_cost,
             "trail_arm_r": ts.trail_arm_r,
             "trail_dist_r": ts.trail_dist_r,
         }
@@ -307,12 +268,6 @@ Examples:
                         help="Primary analysis timeframe (default: H1)")
     parser.add_argument("--detail", action="store_true",
                         help="Show full indicator breakdown")
-    parser.add_argument("--panel", action="store_true",
-                        help="Run the LLM agent panel on the result "
-                             "(advisory only; needs a DeepSeek key)")
-    parser.add_argument("--outlook", action="store_true",
-                        help="Run the hourly AI market outlook now "
-                             "(advisory only; needs a DeepSeek key)")
     parser.add_argument("--json", action="store_true",
                         help="Output as JSON")
     parser.add_argument("--verbose", "-v", action="store_true",
@@ -366,37 +321,14 @@ def build_config(args) -> PlatformConfig:
 def run_live(args, config: PlatformConfig):
     print(f"{Colors.GRAY}  Fetching market data and running analysis...{Colors.RESET}\n")
     aggregator = SignalAggregator(config)
-    report = aggregator.analyze_pair(symbol=config.symbol, log_source="cli")
+    report = aggregator.analyze_pair(symbol=config.symbol)
-
-    # Explicit user intent: force bypasses the enabled/surface/quality
-    # toggles, but the daily panel budget and LLM cap still apply.
-    if getattr(args, "panel", False):
-        attach_panel(report, surface="cli", force=True)
-
-    outlook = None
-    if getattr(args, "outlook", False):
-        outlook = maybe_run_outlook(surface="cli", force=True)
 
     if args.json:
-        payload = report_to_dict(report)
+        print(json.dumps(report_to_dict(report), indent=2))
-        if getattr(args, "outlook", False):
-            payload["market_outlook"] = (
-                None if outlook is None else {
-                    "bias": outlook.bias,
-                    "setup_forming": outlook.setup_forming,
-                    "confidence": outlook.confidence,
-                    "watch": outlook.watch,
-                    "note": outlook.note,
-                    "created_ts": outlook.created_ts,
-                }
-            )
-        print(json.dumps(payload, indent=2))
         return
 
     print_header(f"{config.display_name} SIGNAL INTELLIGENCE")
     print_signal_report(report, detail=args.detail)
-    if getattr(args, "outlook", False):
-        print_market_outlook(outlook)
     print(f"\n{Colors.CYAN}{'═' * 80}{Colors.RESET}")
     print(f"{Colors.GRAY}  Disclaimer: For educational/research purposes only.{Colors.RESET}")
     print(f"{Colors.CYAN}{'═' * 80}{Colors.RESET}\n")

market_outlook.py

@@ -1,442 +0,0 @@
-"""
-ForexBot2 — AI market outlook (advisory hourly assessment)
-===========================================================
-Builds a broad XAU/USD market brief and asks DeepSeek whether a good setup
-appears to be forming. The result is written to the signal-history database
-and may be displayed by consumers, but it is ADVISORY-ONLY: it never changes
-signal scoring, gates, grades, or trade setup generation.
-
-The outlook runs outside the replayable signal path. Individual candle/news
-failures produce a partial brief; an unavailable LLM, malformed reply, or
-locked database never reaches a scan caller as an exception.
-
-The static prompt is intentional: DeepSeek prices byte-identical prompt
-prefixes at its cache-hit rate, so timestamps and all other changing evidence
-live only in the JSON user payload.
-"""
-
-import datetime as _dt
-import logging
-import math
-import os
-import sqlite3
-import threading
-import time
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
-
-from agent_panel import _normalize_candles
-from app_config import (get_app_config, market_outlook_enabled,
-                        signal_log_path)
-from config import PlatformConfig, Timeframe, XAUUSD
-from engine import TechnicalEngine
-from llm_client import get_llm_client
-from providers import base as _provider_base
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_MAX_PER_DAY = 12
-DEFAULT_CANDLE_BARS = 20
-_OUTLOOK_TFS = (Timeframe.M15, Timeframe.H1, Timeframe.H4)
-_VALID_BIASES = ("bullish", "bearish", "neutral")
-_VALID_SETUPS = ("buy", "sell", "none")
-
-
-# STATIC prompt: repeated prompt prefixes are much cheaper with DeepSeek's
-# server-side cache. Variable market evidence belongs exclusively in payload.
-SYSTEM_PROMPT = """\
-You are writing an advisory market outlook for gold (XAU/USD). You receive a
-JSON market brief covering recent candle shape, indicator states, price
-levels, news, and recent technical signals. Assess what may be forming soon;
-you are not a signal generator and must not provide an entry price, stop, or
-target.
-
-Gold doctrine: hawkish Fed / rate hikes / rising real yields / strong
-dollar are gold-bearish; easing / rate cuts / safe-haven flows /
-geopolitical stress / weak dollar are gold-bullish.
-
-Indicator "value" units: rsi 0-100 (above 70 overbought, below 30
-oversold); adx 0-100 (above 25 = strong trend); macd = histogram in
-dollars (momentum); roc = percent; bollinger = position 0-1 (0 = lower
-band, 1 = upper band); keltner = dollar distance from the mid-line;
-ema_trend = 0-1 alignment score; divergence and candlestick = pattern
-counts. "candles" is per timeframe: {"ref_close", "atr", "bars"}; bars
-are oldest-first [open, high, low, close] in ATR units relative to the
-latest close. Read their shape, never quote them as prices.
-
-Hard rules: use ONLY the JSON provided. Do not invent numbers, events, or
-price levels. Your training data about gold, markets, and current events is
-stale and OFF-LIMITS: never use outside knowledge; if a fact is not in the
-JSON, treat it as unknown. If evidence is thin or missing, answer "neutral"
-with confidence below 30. Use plain everyday English for someone unfamiliar
-with markets: short simple sentences, no acronyms or jargon. Keep "watch"
-and "note" to at most 25 words each.
-
-Reply with ONLY JSON:
-{"bias": "bullish"|"bearish"|"neutral",
- "setup_forming": "buy"|"sell"|"none",
- "confidence": 0-100,
- "watch": "<what to watch for, max 25 words>",
- "note": "<plain-English summary, max 25 words>"}
-"""
-
-
-@dataclass
-class OutlookResult:
-    bias: str
-    setup_forming: str
-    confidence: float
-    watch: str
-    note: str
-    created_ts: float
-
-
-def _finite(x: Any) -> Optional[float]:
-    """float(x) or None for non-numeric / non-finite JSON values."""
-    try:
-        value = float(x)
-    except (TypeError, ValueError):
-        return None
-    return value if math.isfinite(value) else None
-
-
-def _round_finite(x: Any, digits: int) -> Optional[float]:
-    value = _finite(x)
-    return round(value, digits) if value is not None else None
-
-
-def _json_safe(value: Any) -> Any:
-    """Replace any accidental NaN/inf nested in provider data with null."""
-    if isinstance(value, dict):
-        return {str(key): _json_safe(item) for key, item in value.items()}
-    if isinstance(value, (list, tuple)):
-        return [_json_safe(item) for item in value]
-    if isinstance(value, bool) or value is None or isinstance(value, str):
-        return value
-    if isinstance(value, (int, float)):
-        return _finite(value)
-    return value
-
-
-def _clamp_confidence(raw: Any) -> Optional[float]:
-    value = _finite(raw)
-    return max(0.0, min(100.0, value)) if value is not None else None
-
-
-def _word_limit(text: Any, words: int = 25) -> str:
-    """Bound a response field by words as well as a practical char limit."""
-    clean = str(text or "").strip()
-    return " ".join(clean.split()[:words])[:200]
-
-
-def _validate_outlook(reply: Any) -> Optional[OutlookResult]:
-    """Validate only model replies that fully match the requested contract."""
-    if not isinstance(reply, dict):
-        return None
-    bias = reply.get("bias")
-    setup_forming = reply.get("setup_forming")
-    confidence = _clamp_confidence(reply.get("confidence"))
-    if (bias not in _VALID_BIASES or setup_forming not in _VALID_SETUPS
-            or confidence is None):
-        return None
-    return OutlookResult(
-        bias=bias,
-        setup_forming=setup_forming,
-        confidence=confidence,
-        watch=_word_limit(reply.get("watch")),
-        note=_word_limit(reply.get("note")),
-        created_ts=time.time(),
-    )
-
-
-# ── Data collection ──────────────────────────────────────────────────
-
-_dp: Any = None  # Patchable singleton, mirroring agent_panel._dp.
-
-
-def _outlook_provider() -> Any:
-    """Lazy provider singleton so its closed-bar cache stays warm hourly."""
-    global _dp
-    if _dp is None:
-        from providers import make_data_provider
-        _dp = make_data_provider(PlatformConfig())
-    return _dp
-
-
-def _indicator_payload(analysis: Any) -> Dict[str, Dict[str, Any]]:
-    """Visible scored indicators with finite, compact values only."""
-    out: Dict[str, Dict[str, Any]] = {}
-    for name, indicator in (getattr(analysis, "indicators", None) or {}).items():
-        if name.startswith("_") or getattr(indicator, "weight", 0) == 0:
-            continue
-        entry: Dict[str, Any] = {
-            "signal": getattr(getattr(indicator, "signal", None), "name", ""),
-            "confidence": _round_finite(
-                getattr(indicator, "confidence", None), 1),
-            "value": _round_finite(getattr(indicator, "value", None), 2),
-        }
-        out[name] = entry
-    return out
-
-
-def _analysis_payload(analyses: Dict[str, Any]) -> Dict[str, Any]:
-    """Pure formatter for the technical portion of the market brief."""
-    indicators: Dict[str, Any] = {}
-    market_regime: Dict[str, Optional[str]] = {}
-    volatility_regime: Dict[str, Optional[str]] = {}
-    key_levels: Dict[str, Dict[str, Optional[float]]] = {}
-    for tf in _OUTLOOK_TFS:
-        name = tf.value
-        analysis = analyses.get(name)
-        indicators[name] = _indicator_payload(analysis)
-        market_regime[name] = getattr(analysis, "market_regime", None)
-        volatility_regime[name] = getattr(analysis, "volatility_regime", None)
-        key_levels[name] = {
-            level: _round_finite(value, 2)
-            for level, value in (getattr(analysis, "key_levels", None) or {}).items()
-        }
-    return {
-        "indicators": indicators,
-        "market_regime": market_regime,
-        "volatility_regime": volatility_regime,
-        "key_levels": key_levels,
-    }
-
-
-def _empty_news_payload() -> Dict[str, Any]:
-    return {
-        "headlines": None,
-        "events": None,
-        "gold_sentiment": None,
-        "remaining_high_impact_events": None,
-    }
-
-
-def _news_payload() -> Dict[str, Any]:
-    """Collect current news without allowing any news failure to block us."""
-    try:
-        from news_engine import NewsEngine
-
-        news = NewsEngine(PlatformConfig().news)
-        context = news.get_fundamental_context()
-        headlines = [str(getattr(h, "headline", ""))
-                     for h in (context.news_headlines or [])[:10]
-                     if getattr(h, "headline", None)]
-        events = [
-            {
-                "event": getattr(event, "event", None),
-                "currency": getattr(event, "currency", None),
-                "actual": getattr(event, "actual", None),
-                "forecast": getattr(event, "forecast", None),
-                "released": not event.is_upcoming,
-            }
-            for event in (context.events_today or [])
-            if event.is_high_impact
-        ][:8]
-        gold_sentiment, _ = news.get_pair_sentiment(XAUUSD, context)
-        remaining = sum(
-            1 for event in news.get_week_events()
-            if event.is_high_impact and event.is_upcoming
-        )
-        return {
-            "headlines": headlines,
-            "events": events,
-            "gold_sentiment": _round_finite(gold_sentiment, 2),
-            "remaining_high_impact_events": remaining,
-        }
-    except Exception as exc:
-        logger.debug("market outlook: news context unavailable: %s", exc)
-        return _empty_news_payload()
-
-
-def _recent_signals() -> List[Dict[str, Any]]:
-    """Read the latest signal history through SQLite's immutable URI."""
-    try:
-        path = os.path.abspath(signal_log_path())
-        # mode=ro (not immutable=1): immutable ignores the WAL, so the
-        # newest rows written by the live loggers were invisible here.
-        uri = f"file:{path}?mode=ro"
-        con = sqlite3.connect(uri, uri=True)
-        try:
-            rows = con.execute(
-                "SELECT logged_at, timeframe, signal, quality, panel_verdict "
-                "FROM signals ORDER BY id DESC LIMIT 10").fetchall()
-        finally:
-            con.close()
-        return [
-            {
-                "logged_at": row[0],
-                "timeframe": row[1],
-                "signal": row[2],
-                "quality": row[3],
-                "panel_verdict": row[4],
-            }
-            for row in reversed(rows)
-        ]
-    except Exception as exc:
-        logger.debug("market outlook: signal history unavailable: %s", exc)
-        return []
-
-
-def _build_payload(
-    analyses: Dict[str, Any],
-    candles: Dict[str, Any],
-    news: Dict[str, Any],
-    recent_signals: List[Dict[str, Any]],
-    as_of: _dt.datetime,
-) -> Dict[str, Any]:
-    """Pure market-brief formatter. Every numeric field is finite or null."""
-    technical = _analysis_payload(analyses)
-    return _json_safe({
-        "as_of": as_of.astimezone(_dt.timezone.utc).isoformat(),
-        "candles": candles,
-        **technical,
-        "news": news,
-        "recent_signals": recent_signals,
-    })
-
-
-def _collect_payload(settings: Dict[str, Any]) -> Dict[str, Any]:
-    """Fetch closed bars and turn them into a structured market brief."""
-    analyses: Dict[str, Any] = {}
-    candles: Dict[str, Any] = {tf.value: None for tf in _OUTLOOK_TFS}
-    bars = int(settings.get("candles_bars", DEFAULT_CANDLE_BARS))
-    provider = _outlook_provider()
-    engine = TechnicalEngine(PlatformConfig().technical)
-
-    for tf in _OUTLOOK_TFS:
-        try:
-            df = provider.fetch_ohlcv(XAUUSD, tf)
-            analysis = engine.analyze(df, XAUUSD, tf.value)
-            analyses[tf.value] = analysis
-            atr = _finite(getattr(
-                (getattr(analysis, "indicators", None) or {}).get("atr"),
-                "value", None))
-            if atr is not None and atr > 0 and df is not None and len(df) >= 2:
-                candles[tf.value] = _normalize_candles(df, atr, bars)
-        except Exception as exc:
-            logger.debug("market outlook: %s data unavailable: %s", tf.value, exc)
-
-    return _build_payload(
-        analyses=analyses,
-        candles=candles,
-        news=_news_payload(),
-        recent_signals=_recent_signals(),
-        as_of=_dt.datetime.now(_dt.timezone.utc),
-    )
-
-
-# ── Orchestration, hourly dedup, and request budget ──────────────────
-
-_state_lock = threading.Lock()
-_last_run_ts: Optional[float] = None
-_last_run_hour: Optional[int] = None   # UTC hour bucket of the last attempt
-_outlook_day: Optional[_dt.date] = None
-_outlook_count = 0
-_warned_budget = False
-
-
-def _skip(reason: str) -> None:
-    """Heartbeat for every silent early return — a dark outlook feature
-    (zero rows for 15 days, 2026-08/09) must be visible in the log."""
-    logger.info("market outlook: skipped (%s)", reason)
-
-
-def reset_outlook_state() -> None:
-    """Drop hourly and daily state (tests / deployment config reloads)."""
-    global _last_run_ts, _last_run_hour, _outlook_day, _outlook_count
-    global _warned_budget
-    with _state_lock:
-        _last_run_ts = None
-        _last_run_hour = None
-        _outlook_day = None
-        _outlook_count = 0
-        _warned_budget = False
-
-
-def _begin_attempt(cap: int, force: bool) -> bool:
-    """Atomically apply hourly dedup, then reserve a daily attempt.
-
-    Hourly dedup is by UTC hour BUCKET, not ``now - last < 3600``: the
-    H1 loop calls this at boundary+10 s+scan time, so consecutive hours
-    were routinely 3,590 s apart and every other hour was dropped."""
-    global _last_run_ts, _last_run_hour, _outlook_day, _outlook_count
-    global _warned_budget
-    now = time.time()
-    hour_bucket = int(now // 3600)
-    today = _dt.datetime.now(_dt.timezone.utc).date()
-    with _state_lock:
-        if not force and _last_run_hour == hour_bucket:
-            _skip(f"hour bucket {hour_bucket} already attempted")
-            return False
-        if _outlook_day != today:
-            _outlook_day = today
-            _outlook_count = 0
-            _warned_budget = False
-        if _outlook_count >= cap:
-            if not _warned_budget:
-                _warned_budget = True
-                logger.warning(
-                    "market outlook: daily budget (%d) exhausted — no more "
-                    "outlooks until UTC midnight", cap)
-            else:
-                _skip("daily budget exhausted")
-            return False
-        _outlook_count += 1
-        _last_run_ts = now
-        _last_run_hour = hour_bucket
-        return True
-
-
-def run_outlook(settings: Dict[str, Any],
-                surface: str = "live") -> Optional[OutlookResult]:
-    """Build, ask, validate, and persist one advisory outlook."""
-    try:
-        payload = _collect_payload(settings)
-        reply = get_llm_client().chat_json(SYSTEM_PROMPT, payload)
-        result = _validate_outlook(reply)
-        if result is None:
-            logger.warning(
-                "market outlook: no outlook produced (%s)",
-                "LLM returned nothing — cap/timeout/disabled" if reply is None
-                else "reply failed validation")
-            return None
-        try:
-            from signal_log import log_outlook
-            log_outlook(result, surface=surface, payload=payload)
-        except Exception:
-            logger.debug("market outlook: persistence unavailable", exc_info=True)
-        return result
-    except Exception:
-        logger.warning("market outlook: run failed", exc_info=True)
-        return None
-
-
-def maybe_run_outlook(surface: str, force: bool = False) -> Optional[OutlookResult]:
-    """Best-effort public entry point. It NEVER raises to a scan caller.
-
-    ``force`` is for explicit CLI use: it bypasses enabled, surface, and
-    hourly gates, but not the independent outlook budget or shared LLM cap.
-    """
-    try:
-        settings = get_app_config().market_outlook_settings
-        if not force:
-            if not market_outlook_enabled():
-                _skip("disabled")
-                return None
-            if surface == "telegram" and not settings.get("telegram", False):
-                _skip("telegram surface off")
-                return None
-        if _provider_base._is_forex_weekend():
-            _skip("weekend")
-            return None
-        cap = int(settings.get("max_per_day", DEFAULT_MAX_PER_DAY))
-        if cap < 1:
-            _skip("max_per_day < 1")
-            return None
-        if not _begin_attempt(cap, force):
-            return None
-        return run_outlook(settings, surface=surface)
-    except Exception:
-        logger.warning("market outlook: unavailable", exc_info=True)
-        return None

news_engine.py

@@ -11,7 +11,6 @@ A perfect technical setup can be destroyed by an unexpected NFP print.
 import hashlib
 import html
 import logging
-import math
 import re
 import threading
 import time
@@ -80,25 +79,13 @@ Reply with ONLY JSON:
 """
 
 _LLM_SUMMARY_SYSTEM = """\
-You write a short news note about the gold price for someone who has
+You are a forex/gold market-context writer. You receive JSON with recent
-never traded. You receive JSON with recent "headlines" (newest first;
+"headlines" and today's high-impact "events" (released: true means the
-each carries "gold": "up" or "down", the platform's own reading of how
+number is out). Write a 1-2 sentence plain-English summary of the
-that story pushes the gold price — trust it) and today's high-impact
+current macro backdrop for a GOLD (XAU/USD) trader: the dominant theme
-"events" (released: true means the number is out).
+and its likely pull on gold. No advice, no hedging boilerplate, max 45
-Say three things, in this order: what is happening to gold right now,
+words.
-why it matters for the gold price, and the next scheduled report to
-watch if one is listed. Use only the headlines and events given; if
-they are thin, say so plainly.
-Style: plain everyday English, short simple sentences, no acronyms, no
-abbreviations, no trader words. Write "the US central bank", not "the
-Fed"; "interest rates", not "yields" or "hawkish"; "a report on US
-prices", not "CPI" or "PCE"; "gold", never "XAU". No advice, no hedging
-boilerplate. 2-3 sentences, max 55 words.
 Reply with ONLY JSON: {"summary": "..."}
-
-Examples:
-{"summary": "Gold is falling today. The US central bank hinted it may raise interest rates, which makes the dollar stronger, and a stronger dollar usually pushes gold down. The next thing to watch is Thursday's report on US prices."}
-{"summary": "Gold is climbing. Fresh fighting in the Middle East has people moving money into gold as a safe place, and a weaker dollar is helping too. No major US reports are due today."}
 """
 
 
@@ -228,48 +215,6 @@ class FundamentalContext:
     llm_summary: str = ""  # DeepSeek market-context blurb (display-only)
 
 
-# Headlines whose every relevant score is inside ±NEUTRAL_HEADLINE_THRESHOLD
-# lean neither way: they carry no direction for display and only dilute the
-# per-currency mean. Same threshold agent_panel uses for its macro payload.
-NEUTRAL_HEADLINE_THRESHOLD = 0.1
-
-
-def _is_neutral_headline(h) -> bool:
-    """True when no per-currency score on the headline leans either way.
-
-    A headline whose overall score is 0.0 but whose gold-specific score is
-    -0.7 is NOT neutral. Missing, empty or non-finite scores count as
-    neutral (they cannot be shown as leaning one way)."""
-    by_currency = getattr(h, "sentiment_by_currency", None) or {}
-    overall = getattr(h, "sentiment_score", None)
-    values = []
-    for currency in (getattr(h, "currencies_mentioned", None) or []):
-        value = by_currency.get(currency, overall)
-        if isinstance(value, (int, float)) and math.isfinite(value):
-            values.append(abs(float(value)))
-    return not values or max(values) < NEUTRAL_HEADLINE_THRESHOLD
-
-
-def _gold_direction_label(h) -> str:
-    """"up" / "down" / "flat" for the market-summary payload — the same
-    XAU-first, USD-inverted reading agent_panel uses for its macro persona."""
-    by_currency = getattr(h, "sentiment_by_currency", None) or {}
-    xau = by_currency.get("XAU")
-    usd = by_currency.get("USD")
-    if isinstance(xau, (int, float)) and math.isfinite(xau):
-        score = float(xau)
-    elif isinstance(usd, (int, float)) and math.isfinite(usd):
-        score = -float(usd)
-    else:
-        raw = getattr(h, "sentiment_score", None)
-        score = float(raw) if isinstance(raw, (int, float)) and math.isfinite(raw) else 0.0
-    if score > 0:
-        return "up"
-    if score < 0:
-        return "down"
-    return "flat"
-
-
 class NewsEngine:
     """
     Economic calendar and news sentiment analyzer.
@@ -430,17 +375,6 @@ class NewsEngine:
         # 2. News sentiment
         try:
             headlines = self._fetch_news_sentiment()
-            # Drop headlines that lean neither way (2026-09-04). Applied
-            # here rather than in the fetch so the class-level cache and
-            # the feed-health counts still describe what the feeds sent;
-            # every consumer (aggregate score, summary, dashboard, panel,
-            # outlook, signal log) reads context.news_headlines.
-            kept = [h for h in headlines if not _is_neutral_headline(h)]
-            if len(kept) != len(headlines):
-                logger.debug(
-                    f"News: dropped {len(headlines) - len(kept)} neutral "
-                    f"headlines, {len(kept)} kept")
-            headlines = kept
             context.news_headlines = headlines
 
             # Aggregate sentiment per currency (per-currency score where
@@ -811,7 +745,6 @@ class NewsEngine:
         headlines = []
         seen_titles = set()
         ok_feeds = 0
-        undated = 0
 
         for feed_url in self.config.rss_feeds:
             host = feed_url.split("/")[2] if "//" in feed_url else feed_url
@@ -837,14 +770,8 @@ class NewsEngine:
                         pub_date_el.text if pub_date_el is not None else None
                     )
 
-                    # Only recent headlines (configurable: headline_max_age_seconds).
+                    # Only recent headlines (last 24h)
-                    # An item without a parsable pubDate cannot be proven
+                    if pub_date and (datetime.now(timezone.utc) - pub_date).total_seconds() > 86400:
-                    # fresh, so it is dropped too — it used to be stamped
-                    # "now" and never aged out (2026-09-04).
-                    if pub_date is None:
-                        undated += 1
-                        continue
-                    if (datetime.now(timezone.utc) - pub_date).total_seconds() > self.config.headline_max_age_seconds:
                         continue
 
                     # Dedup within and across feeds so a syndicated story
@@ -900,8 +827,6 @@ class NewsEngine:
                     f"rss:{host}", False, f"{type(e).__name__}: {e}")
                 logger.debug(f"Failed to fetch RSS from {feed_url}: {e}")
 
-        if undated:
-            logger.debug(f"RSS: dropped {undated} headlines without a publish time")
         self._record_source(
             "headlines", ok_feeds > 0,
             detail="all feeds failed" if ok_feeds == 0 else "",
@@ -1061,11 +986,9 @@ class NewsEngine:
         return text or None
 
     def _llm_market_summary(self, context: FundamentalContext) -> str:
-        """2-3 sentence plain-language news note for alerts; "" when
+        """1-2 sentence macro blurb for alerts; "" when unavailable.
-        unavailable. Headlines go newest-first with the platform's own
+        Cached (success OR failure) for the context-cache TTL so at most
-        gold direction so the note agrees with the score badges. Cached
+        one call is made per window."""
-        (success OR failure) for the context-cache TTL so at most one
-        call is made per window."""
         with NewsEngine._cache_lock:
             ts, cached = NewsEngine._llm_summary_cache
             if time.time() - ts < self.config.context_cache_ttl_seconds:
@@ -1076,17 +999,8 @@ class NewsEngine:
         client = get_llm_client()
         if not client.available:
             return ""
-        oldest = datetime.min.replace(tzinfo=timezone.utc)
-        recent = sorted(
-            context.news_headlines,
-            key=lambda h: getattr(h, "timestamp", None) or oldest,
-            reverse=True,
-        )[:15]
         result = client.chat_json(_LLM_SUMMARY_SYSTEM, {
-            "headlines": [
+            "headlines": [h.headline for h in context.news_headlines[:15]],
-                {"headline": h.headline, "gold": _gold_direction_label(h)}
-                for h in recent
-            ],
             "events": [
                 {"event": e.event, "currency": e.currency,
                  "actual": e.actual, "forecast": e.forecast,
@@ -1096,7 +1010,7 @@ class NewsEngine:
         })
         summary = ""
         if result:
-            summary = str(result.get("summary", "")).strip()[:400]
+            summary = str(result.get("summary", "")).strip()[:300]
         with NewsEngine._cache_lock:
             NewsEngine._llm_summary_cache = (time.time(), summary)
         return summary

oanda_daemon.py

@@ -0,0 +1,854 @@
+"""
+ForexBot2 — Oanda Automated Trading Daemon
+============================================
+Autonomous trading process for XAU/USD on an Oanda practice account.
+Runs candle-boundary scan loops (M5/M15/H1/H4), executes trades via
+the Oanda v20 API, and manages trailing stops at bar close — matching
+the backtested bar-close ratchet model.
+
+Book-parity notes (matching backtest/gpu_backtest.py):
+- No broker-side take-profit: in the trailing model TP1/TP2 are
+  advisory; the only exits are SL (broker), TRAIL (daemon ratchet),
+  and TIMEOUT (max_hold_bars). A hard TP would cap winners the trail
+  lets run and diverge the live book from the backtest.
+- Entry cooldown is 5 bars per timeframe (the backtester's only
+  sequential rule) — not a fingerprint block.
+- The trail ratchets at bar CLOSE only, and each closed bar is
+  processed exactly once (last_bar_ts guard), so weekends and feed
+  lag can't double-count bars or inflate the hold counter.
+
+Divergence from the backtest book (accepted for demo safety): one
+position total. While a trade is open, other signals are logged and
+skipped, so skipped entries can be compared against the book later.
+
+Usage:  python oanda_daemon.py
+Config: env vars OANDA_ACCOUNT_ID, OANDA_API_TOKEN, OANDA_BASE_URL
+        or config.json "oanda" section (env wins).
+"""
+
+import asyncio
+import json
+import logging
+import os
+import signal
+import sys
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime, timezone
+from logging.handlers import TimedRotatingFileHandler
+from typing import Dict, Optional
+
+import pandas as pd
+
+from app_config import (
+    get_app_config, oanda_account_id, oanda_api_token, oanda_base_url,
+)
+from config import PAIR_INFO, PlatformConfig, Timeframe, XAUUSD
+from signal_aggregator import SignalAggregator, SignalReport, SignalStrength
+from pair_signals import PAIR_PRODUCERS
+from providers.oanda import OandaDataProvider
+from oanda_executor import OandaExecutor, OandaAPIError
+
+logger = logging.getLogger(__name__)
+
+# ── Constants ──────────────────────────────────────────────────────────
+
+SYMBOL = XAUUSD
+INSTRUMENT = "XAU_USD"
+
+SCAN_CONFIRMATIONS = {
+    Timeframe.M5:  [Timeframe.M15, Timeframe.H1],
+    Timeframe.M15: [Timeframe.M5, Timeframe.H1],
+    Timeframe.H1:  [Timeframe.M15, Timeframe.H4],
+    Timeframe.H4:  [Timeframe.H1, Timeframe.D1],
+}
+
+TF_INTERVAL_MINUTES = {
+    Timeframe.M5: 5, Timeframe.M15: 15, Timeframe.M30: 30,
+    Timeframe.H1: 60, Timeframe.H4: 240, Timeframe.D1: 1440,
+}
+
+SCAN_TIMEFRAMES = [Timeframe.M5, Timeframe.M15, Timeframe.H1, Timeframe.H4]
+
+QUALITY_RANK = {"A+": 4, "A": 3, "B": 2, "C": 1, "D": 0, "F": -1}
+
+# Matches the backtester's --cooldown-bars default (the only sequential
+# rule in the replay): no new entry within 5 bars of the previous entry
+# on the same timeframe.
+COOLDOWN_BARS = 5
+
+# How often the heartbeat confirms the process is alive and the account
+# is still reachable — independent of the candle-boundary loops, so a
+# wedged scan or mid-run credential expiry still surfaces in the log.
+HEARTBEAT_SECONDS = 3600
+
+STATE_FILE = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "oanda_state.json")
+
+# ── Config resolution (env → config.json → default) ──────────────────
+
+def _oanda_setting_int(env_key: str, json_key: str, default: int) -> int:
+    env = os.environ.get(env_key)
+    if env:
+        try:
+            return int(env)
+        except ValueError:
+            raise SystemExit(
+                f"{env_key}={env!r} is not an integer — refusing to start")
+    try:
+        return int(get_app_config().oanda_settings.get(json_key, default))
+    except (TypeError, ValueError):
+        raise SystemExit(
+            f"config.json oanda.{json_key} is not an integer — "
+            f"refusing to start")
+
+
+def _oanda_setting_str(env_key: str, json_key: str, default: str) -> str:
+    return (os.environ.get(env_key)
+            or str(get_app_config().oanda_settings.get(json_key, default)))
+
+# ── Logging setup ──────────────────────────────────────────────────────
+
+def _setup_logging(level: str = "INFO") -> None:
+    log_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logs")
+    os.makedirs(log_dir, exist_ok=True)
+    log_file = os.path.join(log_dir, "daemon.log")
+
+    fmt = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S")
+
+    file_handler = TimedRotatingFileHandler(
+        log_file, when="h", interval=3, backupCount=240, utc=True)
+    file_handler.setFormatter(fmt)
+
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(fmt)
+
+    logging.basicConfig(
+        level=getattr(logging, level.upper(), logging.INFO),
+        handlers=[file_handler, console_handler],
+        force=True)
+
+# ── Boundary timing (same as telegram_bot.py) ─────────────────────────
+
+def _seconds_until_boundary(interval_minutes: int, buffer: int = 10) -> float:
+    now = datetime.now(timezone.utc)
+    total_minutes = now.hour * 60 + now.minute
+    elapsed_minutes = total_minutes % interval_minutes
+    elapsed_seconds = elapsed_minutes * 60 + now.second + now.microsecond / 1e6
+    interval_seconds = interval_minutes * 60
+    remaining = interval_seconds - elapsed_seconds + buffer
+    # NOTE: remaining > buffer always (elapsed < interval by construction);
+    # a call at the exact boundary instant targets the NEXT boundary —
+    # steady-state loops wake at boundary+buffer, so only a process
+    # started in the boundary microsecond skips one scan (2026-08-04
+    # audit I42; the old `remaining <= buffer` guard was unreachable).
+    return remaining
+
+# ── Trade state persistence ───────────────────────────────────────────
+
+def _load_state() -> Dict:
+    if os.path.exists(STATE_FILE):
+        try:
+            with open(STATE_FILE, encoding="utf-8") as fh:
+                return json.load(fh)
+        except (OSError, json.JSONDecodeError):
+            logger.warning("Could not load state file, starting fresh")
+    return {"trades": {}, "last_entries": {}}
+
+
+def _save_state(state: Dict) -> None:
+    try:
+        tmp = STATE_FILE + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as fh:
+            json.dump(state, fh, indent=2)
+        os.replace(tmp, STATE_FILE)
+    except OSError:
+        logger.exception("Failed to save state file")
+
+# ── Trading Daemon ─────────────────────────────────────────────────────
+
+class TradingDaemon:
+
+    def __init__(self):
+        account_id = oanda_account_id()
+        api_token = oanda_api_token()
+        base_url = oanda_base_url()
+        lot_size = _oanda_setting_int("OANDA_LOT_SIZE", "lot_size", 1)
+        self._quality_gate = _oanda_setting_str(
+            "OANDA_QUALITY_GATE", "quality_gate", "C").strip()
+        if self._quality_gate not in QUALITY_RANK:
+            # Fail CLOSED: an unrecognized gate must never silently fall
+            # back to the most permissive rank (QUALITY_RANK.get default).
+            raise SystemExit(
+                f"OANDA_QUALITY_GATE/quality_gate {self._quality_gate!r} "
+                f"is not one of {sorted(QUALITY_RANK)} — refusing to start")
+        self._max_hold_bars = _oanda_setting_int(
+            "OANDA_MAX_HOLD_BARS", "max_hold_bars", 300)
+        self._price_precision = PAIR_INFO[SYMBOL]["price_precision"]
+
+        if not account_id or not api_token:
+            msg = (
+                "Missing Oanda credentials. Set OANDA_ACCOUNT_ID and "
+                "OANDA_API_TOKEN env vars or config.json oanda section.")
+            logger.critical(msg)
+            raise SystemExit(msg)
+
+        self._provider = OandaDataProvider(
+            PlatformConfig(), api_token, base_url)
+        self._executor = OandaExecutor(
+            account_id, api_token, base_url, lot_size,
+            price_precision=self._price_precision)
+        self._thread_pool = ThreadPoolExecutor(max_workers=4)
+
+        self._state = _load_state()
+        self._state.setdefault("trades", {})
+        self._state.setdefault("last_entries", {})
+        self._state_lock = threading.Lock()
+        # Serializes the position-check + order-placement critical section
+        # across concurrent TF loops (all four fire at aligned boundaries).
+        self._entry_lock = threading.Lock()
+        self._running = True
+
+    # ── Main entry point ───────────────────────────────────────────
+
+    async def run(self) -> None:
+        loop = asyncio.get_running_loop()
+        loop.set_exception_handler(self._asyncio_exception_handler)
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            loop.add_signal_handler(sig, self._request_shutdown)
+
+        logger.info("=== Oanda Trading Daemon starting ===")
+        logger.info(
+            "Quality gate: %s | Max hold: %d bars | Cooldown: %d bars | "
+            "Timeframes: %s",
+            self._quality_gate, self._max_hold_bars, COOLDOWN_BARS,
+            "/".join(tf.name for tf in SCAN_TIMEFRAMES))
+
+        # Credentials first: with a bad token every later call fails, so
+        # refuse to start before touching positions or spawning loops.
+        self._verify_account_access()
+
+        self._discover_existing_positions()
+
+        tasks = []
+        for tf in SCAN_TIMEFRAMES:
+            interval = TF_INTERVAL_MINUTES[tf]
+            tasks.append(asyncio.create_task(
+                self._candle_loop(tf, interval)))
+        tasks.append(asyncio.create_task(self._heartbeat_loop()))
+
+        logger.info("Candle-boundary loops started")
+        try:
+            await asyncio.gather(*tasks)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            self._shutdown()
+
+    def _verify_account_access(self) -> None:
+        """Boot-time credential check. A 4xx here means the token/account
+        id is wrong — that never fixes itself, so refuse to start rather
+        than run a daemon that can't place or manage trades. A connection
+        failure or 5xx is a transient outage: log it and continue, since
+        broker-side stops already protect any open position and the
+        hourly heartbeat will keep reporting account health."""
+        try:
+            self._executor.get_account_summary()
+        except OandaAPIError as e:
+            if 400 <= e.status_code < 500:
+                logger.critical(
+                    "Oanda rejected the account credentials (HTTP %d): "
+                    "%s — refusing to start", e.status_code, e)
+                raise SystemExit(
+                    f"Oanda rejected the account credentials "
+                    f"(HTTP {e.status_code}): {e}")
+            logger.error(
+                "Failed to fetch account summary at boot (HTTP %d): %s",
+                e.status_code, e)
+
+    def _asyncio_exception_handler(self, loop, context) -> None:
+        exc = context.get("exception")
+        if exc is not None:
+            logger.critical(
+                "Uncaught asyncio exception: %s",
+                context.get("message", ""), exc_info=exc)
+        else:
+            logger.critical(
+                "Uncaught asyncio error: %s", context.get("message", ""))
+
+    def _request_shutdown(self) -> None:
+        logger.info("Shutdown requested")
+        self._running = False
+        for task in asyncio.all_tasks():
+            task.cancel()
+
+    def _shutdown(self) -> None:
+        with self._state_lock:
+            _save_state(self._state)
+        self._thread_pool.shutdown(wait=False)
+        logger.info("=== Oanda Trading Daemon stopped ===")
+
+    # ── Position discovery (restart recovery) ──────────────────────
+
+    def _discover_existing_positions(self) -> None:
+        self._reconcile_positions("boot discovery")
+
+    def _reconcile_positions(self, reason: str) -> None:
+        """Re-sync tracked state with the broker's open trades. Safe to
+        call mid-run (lock-guarded); used at boot and whenever a fill or
+        placement error suggests state and broker may have diverged."""
+        try:
+            open_trades = self._executor.get_open_trades(INSTRUMENT)
+        except OandaAPIError:
+            logger.exception(
+                "Failed to query open trades (%s) — reconcile skipped",
+                reason)
+            return
+
+        live_ids = {t["id"] for t in open_trades}
+
+        with self._state_lock:
+            saved = self._state.get("trades", {})
+
+            stale = [tid for tid in saved if tid not in live_ids]
+            for tid in stale:
+                logger.info(
+                    "Stale trade %s in state file (closed on Oanda), "
+                    "removing", tid)
+                del saved[tid]
+
+            for trade in open_trades:
+                tid = trade["id"]
+                if tid in saved:
+                    logger.info(
+                        "Recovered trade %s from state: %s %s @ %.2f, SL %.2f",
+                        tid, saved[tid].get("direction"), INSTRUMENT,
+                        saved[tid].get("entry"), saved[tid].get("current_sl"))
+                    continue
+
+                direction = ("BUY" if float(trade.get("currentUnits", 0)) > 0
+                             else "SELL")
+                entry = float(trade.get("price", 0))
+                sl_order = trade.get("stopLossOrder") or {}
+                sl_price = sl_order.get("price")
+                if sl_price is None:
+                    # No broker-side stop at all: risk is undefined, so the
+                    # trailing model cannot manage this trade. Scream — a
+                    # naked position needs a human (or a policy) to set a
+                    # stop; fabricating one here would invent trading
+                    # behavior the books never validated.
+                    logger.critical(
+                        "Adopted trade %s (%s @ %.2f) has NO STOP LOSS on "
+                        "the broker — it will NOT be trailed. Set a stop "
+                        "manually or close it.", tid, direction, entry)
+                    sl = entry
+                    risk = 0.0
+                else:
+                    sl = float(sl_price)
+                    risk = abs(entry - sl)
+
+                saved[tid] = {
+                    "tf": "H1",
+                    "direction": direction,
+                    "entry": entry,
+                    "sl_initial": sl,
+                    "current_sl": sl,
+                    "risk": risk,
+                    "peak": entry,
+                    "trail_armed": False,
+                    "trail_arm_r": 0.6,
+                    "trail_dist_r": 0.75,
+                    "bars_held": 0,
+                    "last_bar_ts": None,
+                    "signal_bar_ts": None,
+                }
+                logger.info(
+                    "Adopted unknown trade %s: %s @ %.2f, SL %.2f, risk %.2f "
+                    "(conservative defaults)",
+                    tid, direction, entry, sl, risk)
+
+            self._state["trades"] = saved
+            _save_state(self._state)
+        logger.info(
+            "Position reconcile (%s): %d active trade(s)", reason, len(saved))
+
+    # ── Candle-boundary loop ───────────────────────────────────────
+
+    async def _candle_loop(self, tf: Timeframe, interval_minutes: int) -> None:
+        label = tf.value
+        try:
+            while self._running:
+                wait = _seconds_until_boundary(interval_minutes, buffer=10)
+                logger.info("%s loop: next scan in %.0fs", label, wait)
+                await asyncio.sleep(wait)
+                if not self._running:
+                    break
+                logger.info("%s loop: firing scan", label)
+                try:
+                    await self._scan_and_manage(tf)
+                except Exception:
+                    logger.exception("%s loop: cycle failed", label)
+        except asyncio.CancelledError:
+            pass
+        finally:
+            logger.info("%s loop stopped", label)
+
+    async def _scan_and_manage(self, tf: Timeframe) -> None:
+        loop = asyncio.get_running_loop()
+
+        # Trade management FIRST: the SL ratchet must not wait on (or be
+        # starved by) the signal scan — news fetches can take seconds and
+        # a failed scan must never cost an open trade its trail update.
+        try:
+            await loop.run_in_executor(
+                self._thread_pool, self._manage_open_trades, tf)
+        except Exception:
+            logger.exception("%s: trade management failed", tf.value)
+
+        report = await loop.run_in_executor(
+            self._thread_pool, self._run_signal, tf)
+
+        if not self._should_execute(report, tf):
+            return
+
+        await loop.run_in_executor(
+            self._thread_pool, self._execute_trade, report, tf)
+
+    def _manage_open_trades(self, tf: Timeframe) -> None:
+        self._check_closed_trades()
+        self._manage_trailing(tf)
+
+    # ── Heartbeat ─────────────────────────────────────────────────
+
+    def _heartbeat_once(self) -> None:
+        with self._state_lock:
+            n = len(self._state.get("trades", {}))
+        try:
+            self._executor.get_account_summary()
+        except OandaAPIError as e:
+            logger.error("HEARTBEAT: account summary failed: %s", e)
+        # Logged unconditionally — even on a failed summary call the
+        # heartbeat line itself must reach the log, so a wedged process
+        # doesn't look identical to a healthy but silent one.
+        logger.info("HEARTBEAT: alive | tracked trades: %d", n)
+
+    async def _heartbeat_loop(self) -> None:
+        loop = asyncio.get_running_loop()
+        try:
+            while self._running:
+                await asyncio.sleep(HEARTBEAT_SECONDS)
+                if not self._running:
+                    break
+                try:
+                    await loop.run_in_executor(
+                        self._thread_pool, self._heartbeat_once)
+                except Exception:
+                    logger.exception("heartbeat loop: cycle failed")
+        except asyncio.CancelledError:
+            pass
+        finally:
+            logger.info("heartbeat loop stopped")
+
+    # ── Signal pipeline ────────────────────────────────────────────
+
+    def _run_signal(self, tf: Timeframe) -> SignalReport:
+        conf_tfs = SCAN_CONFIRMATIONS.get(
+            tf, [Timeframe.M15, Timeframe.H4])
+        factory = PAIR_PRODUCERS.get(SYMBOL)
+        if factory is not None:
+            config = factory(tf, conf_tfs)
+        else:
+            config = PlatformConfig()
+            config.primary_timeframe = tf
+            config.confirmation_timeframes = conf_tfs
+
+        aggregator = SignalAggregator(config)
+        aggregator.data_provider = self._provider
+        report = aggregator.analyze_pair(symbol=SYMBOL)
+
+        logger.info(
+            "%s scan: signal=%s score=%.1f conf=%.0f quality=%s "
+            "regime=%s vol=%s price=%.2f spread=%.4f",
+            tf.value,
+            report.final_signal.name, report.final_score,
+            report.final_confidence, report.signal_quality,
+            report.market_regime, report.volatility_regime,
+            report.current_price,
+            self._provider.get_spread(SYMBOL))
+
+        # Stale-data/suppression warnings must be visible at WARNING;
+        # routine session-filter notices go to DEBUG — the M5 loop fires
+        # 288x/day and would drown the log at WARNING otherwise.
+        for w in report.warnings:
+            if "STALE" in w.upper() or "FAIL" in w.upper():
+                logger.warning("%s scan: %s", tf.value, w)
+            else:
+                logger.debug("%s scan: %s", tf.value, w)
+
+        return report
+
+    # ── Execution decision ─────────────────────────────────────────
+
+    def _should_execute(self, report: SignalReport, tf: Timeframe) -> bool:
+        if report.final_signal == SignalStrength.NEUTRAL:
+            return False
+
+        if report.trade_setup is None:
+            return False
+
+        quality_rank = QUALITY_RANK.get(report.signal_quality, -1)
+        gate_rank = QUALITY_RANK.get(self._quality_gate, 1)
+        if quality_rank < gate_rank:
+            return False
+
+        if self._in_cooldown(tf):
+            logger.info(
+                "%s: actionable signal (%s %s) but inside %d-bar entry "
+                "cooldown, skipping",
+                tf.value, report.trade_setup.direction,
+                report.signal_quality, COOLDOWN_BARS)
+            return False
+
+        with self._state_lock:
+            if self._state.get("trades"):
+                logger.info(
+                    "%s: actionable signal (%s %s) but position already "
+                    "open, skipping",
+                    tf.value, report.trade_setup.direction,
+                    report.signal_quality)
+                return False
+
+        return True
+
+    def _in_cooldown(self, tf: Timeframe) -> bool:
+        """Backtest parity: no entry within COOLDOWN_BARS bars of the
+        previous entry on the same timeframe (wall-clock approximation)."""
+        with self._state_lock:
+            last = self._state.get("last_entries", {}).get(tf.value)
+        if not last:
+            return False
+        try:
+            last_ts = datetime.fromisoformat(last)
+        except ValueError:
+            return False
+        interval_s = TF_INTERVAL_MINUTES[tf] * 60
+        elapsed = (datetime.now(timezone.utc) - last_ts).total_seconds()
+        return elapsed < COOLDOWN_BARS * interval_s
+
+    # ── Trade execution ────────────────────────────────────────────
+
+    def _execute_trade(self, report: SignalReport, tf: Timeframe) -> None:
+        ts = report.trade_setup
+        if ts is None:
+            return
+
+        # All four TF loops can fire at an aligned boundary (e.g. :00) and
+        # pass _should_execute before any of them has recorded a fill —
+        # re-check under the entry lock so only one order goes out.
+        with self._entry_lock:
+            with self._state_lock:
+                if self._state.get("trades"):
+                    logger.info(
+                        "%s: position opened by a concurrent scan, skipping",
+                        tf.value)
+                    return
+
+            # NO take-profit on the order: the backtested trailing model
+            # exits via SL/TRAIL/TIMEOUT only — a hard TP would cap
+            # winners and diverge the live book from the backtest.
+            try:
+                result = self._executor.place_market_order(
+                    instrument=INSTRUMENT,
+                    direction=ts.direction,
+                    stop_loss=ts.stop_loss,
+                )
+            except OandaAPIError:
+                # The order is never retried (a timeout after a server-side
+                # fill would double-up on retry), but the server MAY have
+                # filled before the error reached us — reconcile so a live
+                # position can't stay untracked until the next restart.
+                logger.exception(
+                    "Failed to place %s order for %s %s — reconciling "
+                    "broker positions",
+                    ts.direction, SYMBOL, tf.value)
+                self._reconcile_positions("order placement error")
+                return
+
+            fill_tx = result.get("orderFillTransaction")
+            if not fill_tx:
+                logger.warning(
+                    "Order not filled for %s %s", SYMBOL, tf.value)
+                return
+
+            trade_opened = fill_tx.get("tradeOpened", {})
+            trade_id = trade_opened.get("tradeID")
+            if not trade_id:
+                # A fill with no tradeOpened means the order interacted
+                # with an existing broker position (tradesClosed /
+                # tradeReduced on a netting account) — state and broker
+                # have diverged. Surface it and re-sync instead of
+                # silently forgetting a real fill.
+                logger.critical(
+                    "Order FILLED but opened no trade (netting close/"
+                    "reduce?) — fill: closed=%s reduced=%s. Reconciling.",
+                    fill_tx.get("tradesClosed"), fill_tx.get("tradeReduced"))
+                self._reconcile_positions("fill without tradeOpened")
+                return
+
+            fill_price = float(fill_tx.get("price", ts.entry_price))
+            risk = abs(fill_price - ts.stop_loss)
+
+            trail_arm = ts.trail_arm_r if ts.trail_arm_r is not None else 0.6
+            trail_dist = ts.trail_dist_r if ts.trail_dist_r is not None else 0.75
+
+            now_iso = datetime.now(timezone.utc).isoformat()
+            trade_state = {
+                "tf": tf.value,
+                "direction": ts.direction,
+                "entry": fill_price,
+                "sl_initial": ts.stop_loss,
+                "current_sl": ts.stop_loss,
+                "tp1": ts.take_profit_1,
+                "tp2": ts.take_profit_2,
+                "risk": risk,
+                "peak": fill_price,
+                "trail_armed": False,
+                "trail_arm_r": trail_arm,
+                "trail_dist_r": trail_dist,
+                "bars_held": 0,
+                # The signal bar is already closed; the first bar this
+                # trade lives through is the one that just started. Guard
+                # so a lagging feed can't trail on the signal bar itself.
+                "signal_bar_ts": report.timestamp,
+                "last_bar_ts": None,
+                "strategy": ts.strategy,
+                "quality": report.signal_quality,
+                "rr": ts.risk_reward,
+                "opened_at": now_iso,
+            }
+
+            with self._state_lock:
+                self._state["trades"][trade_id] = trade_state
+                self._state["last_entries"][tf.value] = now_iso
+                _save_state(self._state)
+
+        logger.info(
+            "TRADE OPENED: %s %s @ %.2f | SL %.2f | TP1 %.2f (advisory) | "
+            "risk $%.2f | RR %.2f | quality %s | strategy %s | TF %s | "
+            "trail arm %.2fR dist %.2fR",
+            ts.direction, SYMBOL, fill_price, ts.stop_loss,
+            ts.take_profit_1,
+            risk, ts.risk_reward, report.signal_quality,
+            ts.strategy, tf.value, trail_arm, trail_dist)
+
+    # ── Trailing stop management ───────────────────────────────────
+
+    def _manage_trailing(self, tf: Timeframe) -> None:
+        # Copy the per-trade dicts too: the loop mutates info (peak,
+        # bars_held, last_bar_ts) and must not touch live state outside
+        # the lock — another thread may be serializing it in _save_state.
+        with self._state_lock:
+            trades = {tid: dict(info)
+                      for tid, info in self._state.get("trades", {}).items()}
+
+        for trade_id, info in trades.items():
+            if info.get("tf") != tf.value:
+                continue
+
+            try:
+                df = self._provider.fetch_ohlcv(SYMBOL, tf)
+            except Exception:
+                logger.exception(
+                    "Failed to fetch candle data for trail update")
+                continue
+
+            if df.empty:
+                logger.warning(
+                    "%s: no candle data for trail update of trade %s",
+                    tf.value, trade_id)
+                continue
+
+            bar_ts = df.index[-1].isoformat()
+
+            # Process each closed bar exactly once. Weekends and feed lag
+            # re-serve the same last bar; without this guard bars_held
+            # inflates (an M5 trade would "time out" over a weekend) and
+            # the peak gets double-counted.
+            if bar_ts == info.get("last_bar_ts"):
+                continue
+            sig_ts = info.get("signal_bar_ts")
+            if sig_ts:
+                try:
+                    if df.index[-1] <= pd.Timestamp(sig_ts):
+                        continue
+                except (ValueError, TypeError):
+                    pass
+            info["last_bar_ts"] = bar_ts
+
+            info["bars_held"] = info.get("bars_held", 0) + 1
+
+            if info["bars_held"] >= self._max_hold_bars:
+                logger.info(
+                    "TIMEOUT: trade %s held %d bars, closing",
+                    trade_id, info["bars_held"])
+                try:
+                    self._executor.close_trade(trade_id)
+                except OandaAPIError:
+                    # Keep tracking — the trade is still live on the
+                    # broker (incl. a 200 whose close order was cancelled,
+                    # e.g. MARKET_HALTED — close_trade raises on no-fill);
+                    # we retry the close at the next bar.
+                    logger.exception(
+                        "Failed to close timed-out trade %s — will retry",
+                        trade_id)
+                    with self._state_lock:
+                        if trade_id in self._state["trades"]:
+                            self._state["trades"][trade_id] = info
+                            _save_state(self._state)
+                    continue
+                with self._state_lock:
+                    self._state["trades"].pop(trade_id, None)
+                    _save_state(self._state)
+                continue
+
+            last_bar = df.iloc[-1]
+            bar_high = float(last_bar["High"])
+            bar_low = float(last_bar["Low"])
+
+            if info.get("risk", 0) <= 0:
+                # Adopted naked position (no broker SL → risk undefined):
+                # never manageable by the trailing model — keep it loud
+                # instead of silently skipping forever.
+                logger.warning(
+                    "Trade %s has risk<=0 (no stop loss) — trailing "
+                    "skipped; set a stop manually", trade_id)
+
+            new_sl = self._compute_trail(info, bar_high, bar_low)
+
+            if new_sl is not None:
+                # Round to instrument precision and track exactly what the
+                # broker holds, so tracked vs broker SL can never drift.
+                new_sl = round(new_sl, self._price_precision)
+                if new_sl != info["current_sl"]:
+                    try:
+                        self._executor.modify_trade_sl(trade_id, new_sl)
+                        info["current_sl"] = new_sl
+                    except OandaAPIError:
+                        logger.exception(
+                            "Failed to update trailing SL for trade %s",
+                            trade_id)
+
+            with self._state_lock:
+                # Write back ONLY if the trade is still tracked — another
+                # loop's _check_closed_trades may have popped it while we
+                # iterated (broker-side close). Re-inserting would create
+                # a ghost that blocks new entries.
+                if trade_id in self._state["trades"]:
+                    self._state["trades"][trade_id] = info
+                    _save_state(self._state)
+
+    def _compute_trail(
+        self, info: Dict, bar_high: float, bar_low: float
+    ) -> Optional[float]:
+        buy = info["direction"] == "BUY"
+        risk = info["risk"]
+        if risk <= 0:
+            return None
+        arm = info.get("trail_arm_r", 0.6)
+        dist = info.get("trail_dist_r", 0.75)
+        if arm <= 0:
+            return None
+
+        fav = bar_high if buy else bar_low
+        if buy:
+            info["peak"] = max(info.get("peak", info["entry"]), fav)
+        else:
+            info["peak"] = min(info.get("peak", info["entry"]), fav)
+
+        exc = ((info["peak"] - info["entry"]) if buy
+               else (info["entry"] - info["peak"])) / risk
+
+        if exc >= arm:
+            if buy:
+                lvl = info["peak"] - dist * risk
+                cur_sl = info.get("current_sl", info["sl_initial"])
+                if lvl > cur_sl:
+                    info["trail_armed"] = True
+                    return lvl
+            else:
+                lvl = info["peak"] + dist * risk
+                cur_sl = info.get("current_sl", info["sl_initial"])
+                if lvl < cur_sl:
+                    info["trail_armed"] = True
+                    return lvl
+
+        return None
+
+    # ── Closed-trade detection ─────────────────────────────────────
+
+    def _check_closed_trades(self) -> None:
+        with self._state_lock:
+            tracked = set(self._state.get("trades", {}).keys())
+
+        if not tracked:
+            return
+
+        try:
+            open_trades = self._executor.get_open_trades(INSTRUMENT)
+        except OandaAPIError:
+            logger.exception("Failed to query open trades")
+            return
+
+        live_ids = {t["id"] for t in open_trades}
+        closed = tracked - live_ids
+
+        for tid in closed:
+            with self._state_lock:
+                info = self._state["trades"].pop(tid, {})
+            entry = info.get("entry", 0)
+            direction = info.get("direction", "?")
+            risk = info.get("risk", 1)
+            sl = info.get("current_sl", 0)
+            was_trailed = info.get("trail_armed", False)
+
+            logger.info(
+                "TRADE CLOSED BY BROKER: %s %s %s | entry %.2f | "
+                "SL was %.2f | risk $%.2f | trailed=%s | bars_held=%d",
+                tid, direction, SYMBOL, entry, sl, risk,
+                was_trailed, info.get("bars_held", 0))
+
+        if closed:
+            with self._state_lock:
+                _save_state(self._state)
+
+# ── Uncaught exception handlers ───────────────────────────────────────
+
+def _excepthook(exc_type, exc_value, exc_tb):
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_tb)
+        return
+    logger.critical(
+        "Uncaught exception", exc_info=(exc_type, exc_value, exc_tb))
+
+def _threading_excepthook(args):
+    logger.critical(
+        "Uncaught exception in thread %s",
+        args.thread.name if args.thread else "?",
+        exc_info=(args.exc_type, args.exc_value, args.exc_traceback))
+
+# ── Entry point ────────────────────────────────────────────────────────
+
+def main() -> None:
+    _setup_logging(
+        os.environ.get("OANDA_LOG_LEVEL") or get_app_config().log_level)
+    sys.excepthook = _excepthook
+    threading.excepthook = _threading_excepthook
+
+    daemon = TradingDaemon()
+    asyncio.run(daemon.run())
+
+
+if __name__ == "__main__":
+    main()

oanda_executor.py

@@ -0,0 +1,230 @@
+"""
+ForexBot2 — Oanda v20 Order Executor
+======================================
+Handles all Oanda account operations: market orders, trade queries,
+SL/TP modification, and trade closure.  Uses raw ``requests`` against
+the Oanda v20 REST API — no extra dependencies.
+"""
+
+import logging
+import time
+from typing import Dict, List, Optional
+
+import requests
+
+logger = logging.getLogger(__name__)
+
+
+class OandaAPIError(Exception):
+    """Raised when an Oanda API call fails."""
+
+    def __init__(self, message: str, status_code: int = 0, body: str = ""):
+        super().__init__(message)
+        self.status_code = status_code
+        self.body = body
+
+
+class OandaExecutor:
+    """Oanda v20 order execution and trade management."""
+
+    MAX_RETRIES = 1
+    RETRY_DELAY = 2.0
+
+    def __init__(
+        self,
+        account_id: str,
+        api_token: str,
+        base_url: str = "https://api-fxpractice.oanda.com",
+        lot_size: int = 1,
+        price_precision: int = 2,
+    ):
+        self._account_id = account_id
+        self._base_url = base_url.rstrip("/")
+        self._lot_size = lot_size
+        self._price_precision = price_precision
+        self._session = requests.Session()
+        self._session.headers.update({
+            "Authorization": f"Bearer {api_token}",
+            "Accept-Datetime-Format": "RFC3339",
+            "Content-Type": "application/json",
+        })
+
+    # ── Order Placement ────────────────────────────────────────────
+
+    def place_market_order(
+        self,
+        instrument: str,
+        direction: str,
+        stop_loss: float,
+        take_profit: Optional[float] = None,
+        units: Optional[int] = None,
+    ) -> Dict:
+        if units is None:
+            units = self._lot_size
+        signed_units = str(units) if direction.upper() == "BUY" else str(-units)
+
+        order_body = {
+            "order": {
+                "type": "MARKET",
+                "instrument": instrument,
+                "units": signed_units,
+                "timeInForce": "FOK",
+                # The book model is one position total; on a netting
+                # account an opposite-side order would silently CLOSE an
+                # existing (possibly untracked) position instead of opening
+                # the signal trade. OPEN_ONLY makes that case fail loudly
+                # (order cancelled) so the divergence surfaces instead of
+                # executing an unintended close.
+                "positionFill": "OPEN_ONLY",
+                "stopLossOnFill": {
+                    "price": self._fmt_price(stop_loss),
+                },
+            }
+        }
+        if take_profit is not None:
+            order_body["order"]["takeProfitOnFill"] = {
+                "price": self._fmt_price(take_profit),
+            }
+
+        url = f"{self._base_url}/v3/accounts/{self._account_id}/orders"
+        # Never retry order placement: a timeout after the server already
+        # filled would open a SECOND position on retry. Fail loudly instead;
+        # the next candle boundary re-evaluates.
+        resp = self._request_with_retry("POST", url, json=order_body, retries=0)
+        data = self._parse_json(resp)
+
+        fill_tx = data.get("orderFillTransaction")
+        if fill_tx:
+            trade_id = fill_tx.get("tradeOpened", {}).get("tradeID", "unknown")
+            fill_price = float(fill_tx.get("price", 0))
+            logger.info(
+                "ORDER FILLED: %s %s %s units @ %.2f — trade %s, SL %.2f%s",
+                direction.upper(), instrument, signed_units, fill_price,
+                trade_id, stop_loss,
+                f", TP {take_profit:.2f}" if take_profit else "")
+        else:
+            cancel_tx = data.get("orderCancelTransaction", {})
+            reason = cancel_tx.get("reason", "unknown")
+            logger.warning(
+                "ORDER NOT FILLED: %s %s — reason: %s",
+                direction.upper(), instrument, reason)
+
+        return data
+
+    # ── Trade Queries ──────────────────────────────────────────────
+
+    def get_open_trades(self, instrument: Optional[str] = None) -> List[Dict]:
+        url = f"{self._base_url}/v3/accounts/{self._account_id}/openTrades"
+        resp = self._request_with_retry("GET", url)
+        trades = self._parse_json(resp).get("trades", [])
+        if instrument:
+            trades = [t for t in trades if t.get("instrument") == instrument]
+        return trades
+
+    def get_trade(self, trade_id: str) -> Dict:
+        url = (f"{self._base_url}/v3/accounts/{self._account_id}"
+               f"/trades/{trade_id}")
+        resp = self._request_with_retry("GET", url)
+        return self._parse_json(resp).get("trade", {})
+
+    def get_account_summary(self) -> Dict:
+        url = f"{self._base_url}/v3/accounts/{self._account_id}/summary"
+        resp = self._request_with_retry("GET", url)
+        account = self._parse_json(resp).get("account", {})
+        logger.info(
+            "Account: balance=%.2f, NAV=%.2f, unrealizedPL=%.2f, openTrades=%s",
+            float(account.get("balance", 0)),
+            float(account.get("NAV", 0)),
+            float(account.get("unrealizedPL", 0)),
+            account.get("openTradeCount", 0))
+        return account
+
+    # ── Trade Modification ─────────────────────────────────────────
+
+    def modify_trade_sl(self, trade_id: str, new_sl: float) -> Dict:
+        url = (f"{self._base_url}/v3/accounts/{self._account_id}"
+               f"/trades/{trade_id}/orders")
+        body = {"stopLoss": {"price": self._fmt_price(new_sl)}}
+        resp = self._request_with_retry("PUT", url, json=body)
+        logger.info(
+            "TRAIL UPDATE: trade %s — new SL %.2f", trade_id, new_sl)
+        return self._parse_json(resp)
+
+    def modify_trade_tp(self, trade_id: str, new_tp: float) -> Dict:
+        url = (f"{self._base_url}/v3/accounts/{self._account_id}"
+               f"/trades/{trade_id}/orders")
+        body = {"takeProfit": {"price": self._fmt_price(new_tp)}}
+        resp = self._request_with_retry("PUT", url, json=body)
+        logger.info("TP UPDATE: trade %s — new TP %.2f", trade_id, new_tp)
+        return self._parse_json(resp)
+
+    def close_trade(self, trade_id: str) -> Dict:
+        url = (f"{self._base_url}/v3/accounts/{self._account_id}"
+               f"/trades/{trade_id}/close")
+        resp = self._request_with_retry("PUT", url, json={"units": "ALL"})
+        data = self._parse_json(resp)
+        close_tx = data.get("orderFillTransaction")
+        if not close_tx:
+            # A 200 whose close order was created but NOT filled (e.g.
+            # cancelled with MARKET_HALTED during the settlement pause)
+            # means the position is STILL OPEN. Raising keeps the caller
+            # tracking it and retrying — silently returning here would
+            # orphan a live position.
+            reason = data.get("orderCancelTransaction", {}).get(
+                "reason", "no orderFillTransaction in response")
+            raise OandaAPIError(
+                f"Close of trade {trade_id} did not fill: {reason}",
+                resp.status_code, str(data)[:300])
+        close_price = float(close_tx.get("price", 0))
+        pl = float(close_tx.get("pl", 0))
+        logger.info(
+            "TRADE CLOSED: trade %s @ %.2f — PL %.2f",
+            trade_id, close_price, pl)
+        return data
+
+    # ── Internals ──────────────────────────────────────────────────
+
+    @staticmethod
+    def _parse_json(resp: requests.Response) -> Dict:
+        try:
+            return resp.json()
+        except ValueError as e:
+            raise OandaAPIError(
+                f"Oanda returned a non-JSON response (HTTP {resp.status_code})",
+                resp.status_code, resp.text[:300]) from e
+
+    def _fmt_price(self, price: float) -> str:
+        # Oanda rejects prices with more decimals than the instrument's
+        # displayPrecision (XAU_USD: sub-cent precision is invalid).
+        return f"{price:.{self._price_precision}f}"
+
+    def _request_with_retry(
+        self, method: str, url: str, retries: Optional[int] = None, **kwargs
+    ) -> requests.Response:
+        if retries is None:
+            retries = self.MAX_RETRIES
+        last_err = None
+        for attempt in range(1 + retries):
+            try:
+                resp = self._session.request(method, url, timeout=15, **kwargs)
+                if resp.status_code >= 500:
+                    raise OandaAPIError(
+                        f"Oanda server error {resp.status_code}",
+                        resp.status_code, resp.text)
+                if resp.status_code >= 400:
+                    raise OandaAPIError(
+                        f"Oanda API error {resp.status_code}: {resp.text}",
+                        resp.status_code, resp.text)
+                return resp
+            except (requests.ConnectionError, requests.Timeout,
+                    OandaAPIError) as e:
+                last_err = e
+                if isinstance(e, OandaAPIError) and 400 <= e.status_code < 500:
+                    raise
+                if attempt < retries:
+                    logger.warning(
+                        "Oanda request failed (attempt %d/%d): %s — retrying in %.0fs",
+                        attempt + 1, 1 + retries, e,
+                        self.RETRY_DELAY)
+                    time.sleep(self.RETRY_DELAY)
+        raise OandaAPIError(f"Oanda request failed after retries: {last_err}")

pair_signals/__init__.py

@@ -30,7 +30,6 @@ def produce_signal(
     primary_tf: Timeframe,
     data_provider: BaseDataProvider,
     confirmation_tfs: Optional[List[Timeframe]] = None,
-    log_source: str = "dashboard",
 ) -> SignalReport:
     config_factory = PAIR_PRODUCERS.get(symbol)
     if config_factory is None:
@@ -42,7 +41,7 @@ def produce_signal(
     config = config_factory(primary_tf, confirmation_tfs)
     aggregator = SignalAggregator(config)
     aggregator.data_provider = data_provider
-    return aggregator.analyze_pair(symbol=symbol, log_source=log_source)
+    return aggregator.analyze_pair(symbol=symbol)
 
 
 from pair_signals import xauusd as _xau_mod

pair_signals/xauusd.py

@@ -141,49 +141,6 @@ validated price of riding trends, exits confirmed NOT the loss
 driver: exit-management accounts for 1-2% of lost R vs 50%
 wrong-direction / 49% entry-timing).
 
-M5 override 6 — SELL block in transitioning regime (validated
-2026-09-03, signal-log campaign, `backtest/research/
-signal_log_campaign_2026-09.md`, $0.65 round trip, same CPU harness
-as its control): sell_blocked_regimes=["transitioning"]. Live
-evidence: M5 SELLs in transitioning were -7.9R/12mo PF 0.21 and
--5.2R/5yr PF 0.49 in the pinned books; the live signal log showed the
-same pocket -7.9R/PF 0.56 over 3 weeks. Blocking: 12mo (2025-08-14 ->
-2026-08-14) 557 trades +112.21R PF 1.56 (halves +55.9/+56.4, PF
-1.54/1.58) vs control 575/+104.34R PF 1.50; 5yr (2021-08-01 ->
-2026-08-04) 889/+133.7R PF 1.41 vs 911/+128.4R PF 1.39; OOS
-2024-06-01 -> 2025-03-30 unchanged (86/+9.45R PF 1.33 — no such
-trades in that window). Removed trades: 18 in 12mo (-7.9R), 22 in
-5yr (-5.3R).
-
-H1 override — all SELL entries blocked (validated 2026-09-03, same
-campaign): sell_min_quality=[] (gate 6e in signal_aggregator.py
-downgrades any actionable-grade SELL whose quality is not in this
-list to D, so an empty list downgrades every H1 short). H1 shorts
-were a structural loser: -16.7R over the 5yr control window and
--11.5R OOS. Blocking: 12mo (2025-08-04 -> 2026-08-04) 91/+22.2R
-PF 1.79 (halves +20.6/+1.6) vs control 138/+24.0R PF 1.55 (12mo cost
--1.8R); 5yr 335/+49.1R PF 1.46 vs 515/+32.4R PF 1.18; OOS 78/+16.7R
-PF 1.74 vs 104/+5.1R PF 1.13. New reference books:
-backtest/oanda_h1_{12mo,5yr,oos}_065_20260903.csv,
-backtest/oanda_m5_12mo_065_nopb_20260903.csv,
-backtest/oanda_m5_5yr_065_nopb_20260903.csv.
-
-Rejected/parked in the same campaign (see the memo for the full
-table): M15 sell_min_quality=["B"] (5yr -8.9R, max DD 35.8 -> 41.4R
-— REJECTED); Bollinger weight 0 in trending regimes on M5, M15, H1
-(M5 -20.4R/12mo, -15.5R/5yr; M15 -24.0R/12mo — REJECTED across the
-board); divergence disabled on M15 (R improves +7.4/+11.9/+13.5R
-across windows but 5yr max DD 35.8 -> 47.4R with PF flat — DECLINED,
-owner call); divergence disabled on H1 (+4.6/+8.1/+2.4R, PF
-1.62/1.20/1.17) — PARKED: it passes rule 1 in combination with the
-H1 no-short override (b12_h1_nosell_nodiv: 12mo 100/+23.1R PF 1.75,
-halves +21.8/+1.3; 5yr 364/+58.7R PF 1.52; OOS 88/+21.9R PF 1.92 —
-better than the no-shorts override alone on both 5yr and OOS), but
-shipping it would route through technical.disabled_indicators, which
-CLAUDE.md rule 8 reserves for experiments; owner decision, recommended
-vehicle is an H1-only regime_weights_override with divergence weight
-0 plus a fresh validation run.
-
 M5 override 5 — EMA partial-alignment squash (validated 2026-08-04,
 Oanda bars, $0.65 real spread): ema_partial_neutral True on M5 —
 partial 4-EMA ribbon alignment (2-3 of 4 checks) scores NEUTRAL
@@ -259,9 +216,6 @@ def make_config(
         # Wider trailing distance on M5 only — see module docstring.
         config.signals.trail_arm_r = 0.60
         config.signals.trail_dist_r = 0.85
-        # Block SELL entries while the regime is "transitioning" on M5
-        # only — see module docstring (M5 override 6).
-        config.xau_strategy.sell_blocked_regimes = ["transitioning"]
     if primary_tf == Timeframe.M15:
         # 1R minimum target on M15 only — see module docstring.
         config.signals.tp_floor_rr = 1.0
@@ -272,10 +226,4 @@ def make_config(
         # Later trailing-stop arm on M15 only — see module docstring.
         config.signals.trail_arm_r = 0.70
         config.signals.trail_dist_r = 0.75
-    if primary_tf == Timeframe.H1:
-        # Block every H1 SELL — the SELL quality gate (6e in
-        # signal_aggregator.py) downgrades any actionable-grade short
-        # to D when its grade is not in this list; an empty list means
-        # no grade qualifies. H1-only — see module docstring.
-        config.xau_strategy.sell_min_quality = []
     return config

providers/tiingo.py

@@ -3,8 +3,6 @@ ForexBot2 — Tiingo data provider
 =================================
 OHLCV candles from Tiingo's FX endpoint
 (`/tiingo/fx/{ticker}/prices`, resampled mid-price bars, no volume).
-Tiingo is streaming-only in production: its REST candles remain available
-for comparison research, but it is not a designated candle fallback.
 All shared behavior (cache, validation, boundary guarantees, range
 pagination) lives in `BaseDataProvider`; this module only maps
 symbols/resample frequencies, sizes the request window, and parses

scripts/backfill_signal_outcomes.py

@@ -1,91 +0,0 @@
-#!/usr/bin/env python3
-"""
-backfill_signal_outcomes.py — seed and advance advisory outcomes for every
-logged trade setup (not only panel rows), one per advisory event.
-
-Pass A (offline, no network): assign setup_key / advisory_event_id to all
-legacy setup rows, mark same-setup re-logs within 60 min as DUPLICATE, and
-seed a PENDING outcome on each canonical row that has none. Existing
-(panel-seeded) outcomes are never overwritten.
-
-Pass B: advance PENDING rows from the closed-candle streams already stored
-in the DB (union across every snapshot of the timeframe — no provider).
-
-Pass C (--reseed-unresolvable): bounded re-seed of continuity-broken rows,
-then Pass B again.
-
-Safe beside the live writers: short per-row transactions with a busy
-timeout. Read-only preview with --dry-run.
-
-    python scripts/backfill_signal_outcomes.py --dry-run
-    python scripts/backfill_signal_outcomes.py
-    python scripts/backfill_signal_outcomes.py --reseed-unresolvable
-"""
-import argparse
-import os
-import sqlite3
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-import app_config  # noqa: E402
-from signal_log import SignalLogger  # noqa: E402
-
-
-def _status_counts(con: sqlite3.Connection) -> dict:
-    return dict(con.execute(
-        "SELECT COALESCE(advisory_outcome_status, 'NULL'), COUNT(*)"
-        " FROM signals WHERE setup_json IS NOT NULL AND setup_json != 'null'"
-        " GROUP BY 1").fetchall())
-
-
-def main(argv=None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__.splitlines()[1])
-    ap.add_argument("--db", default=None, help="defaults to signal_log.path")
-    ap.add_argument("--dry-run", action="store_true")
-    ap.add_argument("--reseed-unresolvable", action="store_true")
-    ap.add_argument("--symbol", default="XAU/USD")
-    args = ap.parse_args(argv)
-    path = args.db or app_config.signal_log_path()
-    if not os.path.exists(path):
-        print(f"no database at {path}")
-        return 1
-    if args.dry_run:
-        con = sqlite3.connect(f"file:{os.path.abspath(path)}?mode=ro", uri=True)
-        print("setup rows by outcome status:", _status_counts(con))
-        have = {r[1] for r in con.execute("PRAGMA table_info(signals)")}
-        if "setup_key" in have:
-            n_keyless = con.execute(
-                "SELECT COUNT(*) FROM signals WHERE setup_json IS NOT NULL"
-                " AND setup_json != 'null' AND setup_key IS NULL").fetchone()[0]
-            print(f"setup rows without setup_key: {n_keyless}")
-        else:
-            print("setup_key column not present yet (schema migrates on"
-                  " the first non-dry run)")
-        con.close()
-        return 0
-    lg = SignalLogger(path)
-    try:
-        print("before:", _status_counts(lg._conn))
-        print("pass A (seed/dedup):", lg.backfill_seeds())
-        total = 0
-        for _ in range(50):
-            n = lg.resolve_from_store(args.symbol)
-            total += n
-            if n == 0:
-                break
-        print(f"pass B (advance from stored bars): {total} rows changed")
-        if args.reseed_unresolvable:
-            reseeded = lg.reseed_unresolvable()
-            print(f"pass C (re-seed): {len(reseeded)} rows re-seeded")
-            for _ in range(50):
-                if lg.resolve_from_store(args.symbol) == 0:
-                    break
-        print("after:", _status_counts(lg._conn))
-    finally:
-        lg.close()
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/compare_oanda_tiingo.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""
-Scratchpad — Oanda vs Tiingo candle parity check
-=================================================
-Fetches the last N closed XAU/USD candles from Oanda and Tiingo for
-M5/M15/H1 via the normal provider stack (make_data_provider →
-fetch_ohlcv: forming-candle drop + validate/clean included, i.e. exactly
-what the signal pipeline consumes) and reports how well they line up:
-
-  * last-bar timestamp per provider (feed-lag check)
-  * timestamp mismatches (bars present in one feed only)
-  * per-bar OHLC diff table for the common tail
-  * max/mean |diff| per column, with the Close diff also in % of price
-
-Both feeds are mid-price (Oanda mid of MBA candles; Tiingo resampled
-mid), so small diffs are expected — this measures how small.
-
-Usage:
-    venv/bin/python scripts/compare_oanda_tiingo.py [--n 10]
-"""
-
-import argparse
-import sys
-from pathlib import Path
-
-import pandas as pd
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from config import PlatformConfig, Timeframe, XAUUSD
-from providers import make_data_provider
-
-TIMEFRAMES = [Timeframe.M5, Timeframe.M15, Timeframe.H1]
-OHLC = ["Open", "High", "Low", "Close"]
-
-
-def fetch_tail(provider, tf, n):
-    """Last n closed bars from one provider, or None on failure."""
-    try:
-        df = provider.fetch_ohlcv(symbol=XAUUSD, timeframe=tf)
-    except Exception as e:  # scratchpad: report, don't crash
-        print(f"  !! {provider.name} {tf.value} fetch failed: {e}")
-        return None
-    return df.tail(n)
-
-
-def compare_tf(tf, oanda_df, tiingo_df, n):
-    print(f"\n{'=' * 78}\n{tf.value} — last {n} closed bars\n{'=' * 78}")
-    if oanda_df is None or tiingo_df is None:
-        print("  skipped (a provider failed)")
-        return
-
-    print(f"  Oanda last bar: {oanda_df.index[-1]}   "
-          f"Tiingo last bar: {tiingo_df.index[-1]}")
-
-    common = oanda_df.index.intersection(tiingo_df.index)
-    only_o = oanda_df.index.difference(tiingo_df.index)
-    only_t = tiingo_df.index.difference(oanda_df.index)
-    if len(only_o):
-        print(f"  bars only in Oanda : {[str(t) for t in only_o]}")
-    if len(only_t):
-        print(f"  bars only in Tiingo: {[str(t) for t in only_t]}")
-    if not len(common):
-        print("  NO common timestamps — feeds are on different bar grids!")
-        return
-
-    o = oanda_df.loc[common, OHLC]
-    t = tiingo_df.loc[common, OHLC]
-    diff = o - t
-
-    print(f"\n  {len(common)}/{n} bars share timestamps "
-          f"(window {common[0]} → {common[-1]})\n")
-
-    # Per-bar Close table — the number that matters most.
-    hdr = f"  {'bar close (UTC)':<20}{'Oanda C':>12}{'Tiingo C':>12}{'ΔC ($)':>10}"
-    print(hdr + f"{'ΔO':>8}{'ΔH':>8}{'ΔL':>8}")
-    for ts in common:
-        row = (f"  {str(ts):<20}{o.loc[ts, 'Close']:>12.2f}"
-               f"{t.loc[ts, 'Close']:>12.2f}{diff.loc[ts, 'Close']:>10.3f}")
-        row += (f"{diff.loc[ts, 'Open']:>8.3f}{diff.loc[ts, 'High']:>8.3f}"
-                f"{diff.loc[ts, 'Low']:>8.3f}")
-        print(row)
-
-    print("\n  summary over common bars:")
-    for col in OHLC:
-        d = diff[col].abs()
-        print(f"    {col:<6} max |Δ| = {d.max():8.4f}   mean |Δ| = {d.mean():8.4f}")
-    px = o["Close"].iloc[-1]
-    dc = diff["Close"].abs()
-    print(f"    Close Δ as % of price: max {dc.max() / px * 100:.4f}%   "
-          f"mean {dc.mean() / px * 100:.4f}%")
-    exact = (diff[OHLC].abs() < 1e-9).all(axis=1).sum()
-    print(f"    bars with identical OHLC: {exact}/{len(common)}")
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--n", type=int, default=10,
-                    help="bars per timeframe to compare (default 10)")
-    args = ap.parse_args()
-
-    cfg = PlatformConfig()
-    oanda = make_data_provider(cfg, "oanda")
-    tiingo = make_data_provider(cfg, "tiingo")
-
-    for tf in TIMEFRAMES:
-        o_df = fetch_tail(oanda, tf, args.n)
-        t_df = fetch_tail(tiingo, tf, args.n)
-        compare_tf(tf, o_df, t_df, args.n)
-
-    print("\nDone. Note: Oanda=mid of MBA candles, Tiingo=resampled mid — "
-          "sub-$1 diffs on gold are normal feed divergence, not a bug.")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/feed_divergence_study.py

@@ -1,259 +0,0 @@
-#!/usr/bin/env python3
-"""
-Phase 1 — historical candle divergence study (data source change test)
-=======================================================================
-Fetches the RAW closed-bar series for XAU/USD from two providers over a
-multi-month window via the normal provider stack (`fetch_range`, which
-paginates under the per-request bar cap and drops the forming candle),
-then quantifies how the feeds diverge:
-
-  * coverage: % shared timestamps, feed-only bars, where they cluster
-  * OHLC |Δ| distribution (mean/median/p90/p95/p99/max, $ and bias)
-  * |ΔClose| vs mean ATR14 (the scale the signal engine cares about)
-  * threshold exceedance (how many bars differ by more than X $)
-  * bar-direction agreement (sign of close−open)
-  * close-return correlation on consecutive bars
-  * per-hour and per-month drift
-
-Both feeds are mid-price (Oanda mid of MBA candles; Tiingo resampled mid;
-Twelve Data its own mid). Frames are cached to parquet so re-runs are
-instant; pass --no-cache to force a fresh fetch.
-
-Usage:
-    venv/bin/python scripts/feed_divergence_study.py --a oanda --b tiingo \
-        --tfs M15,H1,H4 --days 365
-"""
-
-import argparse
-import sys
-import time
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from config import PlatformConfig, Timeframe, XAUUSD
-from providers import make_data_provider
-
-REPO = Path(__file__).resolve().parent.parent
-CACHE_DIR = REPO / "backtest" / "cache"
-RESEARCH_DIR = REPO / "backtest" / "research"
-
-_TF_LOOKUP = {t.value: t for t in Timeframe}
-_TF_LOOKUP.update({
-    "M1": Timeframe.M1, "M5": Timeframe.M5, "M15": Timeframe.M15,
-    "M30": Timeframe.M30, "H1": Timeframe.H1, "H4": Timeframe.H4,
-    "D1": Timeframe.D1, "W1": Timeframe.W1,
-})
-
-
-def wilder_atr(df: pd.DataFrame, period: int = 14) -> pd.Series:
-    hl = df["High"] - df["Low"]
-    hc = (df["High"] - df["Close"].shift(1)).abs()
-    lc = (df["Low"] - df["Close"].shift(1)).abs()
-    tr = pd.concat([hl, hc, lc], axis=1).max(axis=1)
-    return tr.ewm(alpha=1.0 / period, adjust=False).mean()
-
-
-def fmt_stats(name: str, s: pd.Series) -> str:
-    a = s.abs()
-    return (f"  {name:<6} mean ${a.mean():.3f}  med ${a.median():.3f}  "
-            f"p90 ${a.quantile(0.90):.3f}  p95 ${a.quantile(0.95):.3f}  "
-            f"p99 ${a.quantile(0.99):.3f}  max ${a.max():.2f}  "
-            f"bias {s.mean():+.4f}")
-
-
-def cache_path(name: str, tf: Timeframe, start: pd.Timestamp,
-               end: pd.Timestamp) -> Path:
-    return (CACHE_DIR /
-            f"{name}_XAU_USD_{tf.value}_{start:%Y%m%d}_{end:%Y%m%d}.parquet")
-
-
-def load_or_fetch(provider, name: str, tf: Timeframe, start, end,
-                  no_cache: bool):
-    cp = cache_path(name, tf, start, end)
-    if not no_cache and cp.exists():
-        df = pd.read_parquet(cp)
-        print(f"  [{name}] loaded {len(df):,} bars from cache "
-              f"{cp.name}")
-        return df
-    t0 = time.time()
-    print(f"  [{name}] fetching {tf.value} {start.date()} → {end.date()} ...")
-    df = provider.fetch_range(XAUUSD, tf, start, end)
-    print(f"  [{name}] fetched {len(df):,} bars in {time.time() - t0:.1f}s")
-    df.to_parquet(cp)
-    print(f"  [{name}] cached → {cp.name}")
-    return df
-
-
-def compare(tf: Timeframe, a_name: str, b_name: str, a: pd.DataFrame,
-            b: pd.DataFrame):
-    print("\n" + "=" * 80)
-    print(f"{tf.value} — {a_name.upper()} vs {b_name.upper()}, XAU/USD")
-    print("=" * 80)
-
-    common = a.index.intersection(b.index)
-    a_only = a.index.difference(b.index)
-    b_only = b.index.difference(a.index)
-
-    print(f"\nCOVERAGE")
-    print(f"  {a_name} bars : {len(a):>8,}   head {a.index[0]}  tail {a.index[-1]}")
-    print(f"  {b_name} bars : {len(b):>8,}   head {b.index[0]}  tail {b.index[-1]}")
-    print(f"  shared        : {len(common):>8,}  "
-          f"({100 * len(common) / max(len(a.index.union(b.index)), 1):.2f}% of union)")
-    print(f"  {a_name}-only : {len(a_only):>8,}  "
-          f"({100 * len(a_only) / max(len(a), 1):.2f}% of {a_name})")
-    print(f"  {b_name}-only : {len(b_only):>8,}  "
-          f"({100 * len(b_only) / max(len(b), 1):.2f}% of {b_name})")
-
-    if len(common) == 0:
-        print("  !! no shared timestamps — feeds on different bar grids")
-        return
-
-    for label, idx in ((f"{a_name}-only", a_only),
-                       (f"{b_name}-only", b_only)):
-        if not len(idx):
-            continue
-        by_date = pd.Series(1, index=idx).groupby(idx.date).sum()
-        top = by_date.sort_values(ascending=False).head(6)
-        print(f"  {label} clusters on: "
-              + ", ".join(f"{d} ({n})" for d, n in top.items()))
-
-    x = a.loc[common]
-    y = b.loc[common]
-
-    atr = wilder_atr(x).dropna()
-    mean_price = x["Close"].mean()
-    print(f"\nSCALE REFERENCES ({a_name} feed)")
-    print(f"  mean close    : ${mean_price:,.2f}")
-    print(f"  mean bar range: ${(x['High'] - x['Low']).mean():.3f}")
-    print(f"  mean ATR14    : ${atr.mean():.3f}   median ${atr.median():.3f}")
-
-    print(f"\nPER-BAR DIFFS  ({a_name} − {b_name}, $)")
-    diffs = {}
-    for col in ("Open", "High", "Low", "Close"):
-        d = x[col] - y[col]
-        diffs[col] = d
-        print(fmt_stats(col, d))
-
-    dclose = diffs["Close"].abs()
-    print(f"\n  |ΔClose| as % of mean ATR14 : "
-          f"mean {100 * dclose.mean() / atr.mean():.1f}%   "
-          f"p95 {100 * dclose.quantile(0.95) / atr.mean():.1f}%")
-
-    print(f"\nTHRESHOLD EXCEEDANCE  (|ΔClose|)")
-    for thr in (0.10, 0.30, 0.65, 1.00, 2.00, 5.00):
-        pct = 100 * (dclose > thr).mean()
-        print(f"  > ${thr:<5.2f}: {pct:6.2f}% of bars  ({(dclose > thr).sum():,})")
-
-    # direction agreement
-    a_dir = np.sign(x["Close"] - x["Open"])
-    b_dir = np.sign(y["Close"] - y["Open"])
-    both_nonflat = (a_dir != 0) & (b_dir != 0)
-    dir_agree = 100 * (a_dir[both_nonflat] == b_dir[both_nonflat]).mean()
-    print(f"\nAGREEMENT")
-    print(f"  bar direction (sign of close−open) agree: {dir_agree:.2f}%"
-          f"  (n={both_nonflat.sum():,})")
-
-    step = pd.Series(common, index=common).diff().median()
-    a_ret = x["Close"].pct_change()
-    b_ret = y["Close"].pct_change()
-    step_ok = pd.Series(common, index=common).diff().le(step + pd.Timedelta(seconds=1))
-    corr = a_ret[step_ok].corr(b_ret[step_ok])
-    print(f"  close-return correlation (consecutive bars): {corr:.5f}")
-
-    # by-hour
-    hours = common.hour
-    rows = []
-    for h in range(24):
-        m = hours == h
-        if not m.any():
-            continue
-        rows.append({"hour_utc": h, "bars": int(m.sum()),
-                     "mean_abs_dclose": dclose[m].mean(),
-                     "p95_abs_dclose": dclose[m].quantile(0.95)})
-    by_hour = pd.DataFrame(rows)
-    print(f"\nBY UTC HOUR  (mean |ΔClose|, $)")
-    print(by_hour.to_string(index=False,
-                            float_format=lambda v: f"{v:.3f}"))
-
-    print(f"\nBY MONTH  (mean |ΔClose|, $)")
-    months = dclose.groupby(common.tz_localize(None).to_period("M")).mean()
-    for p, v in months.items():
-        print(f"  {p}: {v:.3f}")
-
-    return {
-        "tf": tf.value, "a": a_name, "b": b_name,
-        "a_bars": len(a), "b_bars": len(b), "common": len(common),
-        "a_only": len(a_only), "b_only": len(b_only),
-        "dir_agree_pct": round(dir_agree, 3),
-        "ret_corr": round(corr, 5),
-        "mean_abs_dclose": dclose.mean(),
-        "p95_abs_dclose": dclose.quantile(0.95),
-        "max_abs_dclose": dclose.max(),
-        "dclose_pct_atr_mean": 100 * dclose.mean() / atr.mean(),
-    }
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--a", required=True)
-    ap.add_argument("--b", required=True)
-    ap.add_argument("--tfs", default="M15,H1,H4",
-                    help="comma-separated timeframe values (default M15,H1,H4)")
-    ap.add_argument("--days", type=int, default=365)
-    ap.add_argument("--end", default=None, help="UTC end date (default now)")
-    ap.add_argument("--no-cache", action="store_true")
-    args = ap.parse_args()
-
-    tfs = []
-    for s in args.tfs.split(","):
-        s = s.strip()
-        tf = _TF_LOOKUP.get(s)
-        if tf is None:
-            sys.exit(f"unknown timeframe '{s}'; use one of "
-                     f"{sorted(_TF_LOOKUP)}")
-        tfs.append(tf)
-
-    end = pd.Timestamp(args.end, tz="UTC") if args.end \
-        else pd.Timestamp.now(tz="UTC")
-    start = end - pd.Timedelta(days=args.days)
-
-    cfg = PlatformConfig()
-    pa = make_data_provider(cfg, args.a)
-    pb = make_data_provider(cfg, args.b)
-
-    summary = []
-    for tf in tfs:
-        print(f"\n{'─' * 80}\nWINDOW {start.date()} → {end.date()}  "
-              f"({args.days} days), {tf.value}")
-        try:
-            a = load_or_fetch(pa, args.a, tf, start, end, args.no_cache)
-        except Exception as e:
-            print(f"  !! {args.a} {tf.value} fetch failed: {e}")
-            continue
-        try:
-            b = load_or_fetch(pb, args.b, tf, start, end, args.no_cache)
-        except Exception as e:
-            print(f"  !! {args.b} {tf.value} fetch failed: {e}")
-            continue
-        r = compare(tf, args.a, args.b, a, b)
-        if r:
-            summary.append(r)
-
-    print("\n" + "=" * 80)
-    print("SUMMARY TABLE")
-    print("=" * 80)
-    sdf = pd.DataFrame(summary)
-    print(sdf.to_string(index=False,
-                        float_format=lambda v: f"{v:.4f}"))
-    out = RESEARCH_DIR / f"feed_divergence_{args.a}_vs_{args.b}.csv"
-    if len(sdf):
-        sdf.to_csv(out, index=False, float_format="%.6f")
-        print(f"\nSummary written to {out}")
-
-
-if __name__ == "__main__":
-    main()

scripts/migrate_signal_log_news.py

@@ -1,177 +0,0 @@
-#!/usr/bin/env python3
-"""
-migrate_signal_log_news.py — move inline news blobs into news_snapshots.
-
-Legacy rows store the full RSS headline list (~33 KB) and calendar events
-(~1.2 KB) inline on EVERY scan row; the same blob repeats ~5× because the
-news caches outlive a candle. This script interns each distinct blob once
-(content hash), stamps `headlines_hash` / `events_hash` on the row and
-NULLs the inline columns. Readers use the `signals_with_news` view or
-`signal_log.read_news`.
-
-Idempotent and resumable (batched transactions). Run --vacuum with BOTH
-live writers (telegram bot, dashboard publisher) stopped — VACUUM needs
-exclusive access and ~1× the final size of free disk.
-
-    python scripts/migrate_signal_log_news.py --dry-run
-    python scripts/migrate_signal_log_news.py
-    python scripts/migrate_signal_log_news.py --vacuum      # bots stopped
-"""
-import argparse
-import hashlib
-import os
-import sqlite3
-import sys
-from datetime import datetime, timezone
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-import app_config  # noqa: E402
-from signal_log import SignalLogger  # noqa: E402
-
-
-def _hash(text: str) -> str:
-    return hashlib.sha256(text.encode("utf-8")).hexdigest()
-
-
-def migrate(con: sqlite3.Connection, batch: int = 500) -> dict:
-    """Intern legacy inline blobs; returns counters. Caller owns the
-    connection (schema must already exist — open a SignalLogger once)."""
-    stats = {"rows": 0, "headlines_interned": 0, "events_interned": 0}
-    now = datetime.now(timezone.utc).isoformat()
-    while True:
-        rows = con.execute(
-            "SELECT id, headlines_json, events_json FROM signals"
-            " WHERE (headlines_json IS NOT NULL AND headlines_hash IS NULL)"
-            "    OR (events_json IS NOT NULL AND events_hash IS NULL)"
-            " ORDER BY id LIMIT ?", (batch,)).fetchall()
-        if not rows:
-            break
-        con.execute("BEGIN IMMEDIATE")
-        try:
-            for rowid, headlines, events in rows:
-                sets, params = [], []
-                if headlines is not None:
-                    h = _hash(headlines)
-                    cur = con.execute(
-                        "INSERT OR IGNORE INTO news_snapshots"
-                        " (hash, kind, body, first_seen, last_seen)"
-                        " VALUES (?, 'headlines', ?, ?, ?)",
-                        (h, headlines, now, now))
-                    stats["headlines_interned"] += cur.rowcount
-                    sets += ["headlines_hash=?", "headlines_json=NULL"]
-                    params.append(h)
-                if events is not None:
-                    h = _hash(events)
-                    cur = con.execute(
-                        "INSERT OR IGNORE INTO news_snapshots"
-                        " (hash, kind, body, first_seen, last_seen)"
-                        " VALUES (?, 'events', ?, ?, ?)",
-                        (h, events, now, now))
-                    stats["events_interned"] += cur.rowcount
-                    sets += ["events_hash=?", "events_json=NULL"]
-                    params.append(h)
-                params.append(rowid)
-                con.execute(
-                    f"UPDATE signals SET {', '.join(sets)} WHERE id=?",
-                    params)
-                stats["rows"] += 1
-            con.commit()
-        except Exception:
-            con.rollback()
-            raise
-    return stats
-
-
-def prune_orphans(con: sqlite3.Connection) -> int:
-    cur = con.execute(
-        "DELETE FROM news_snapshots WHERE hash NOT IN"
-        " (SELECT headlines_hash FROM signals WHERE headlines_hash IS NOT NULL"
-        "  UNION SELECT events_hash FROM signals WHERE events_hash IS NOT NULL)")
-    con.commit()
-    return cur.rowcount
-
-
-def prune_news_older_than(con: sqlite3.Connection, days: int) -> int:
-    """Drop the news reference (not the row) from rows older than N days,
-    then delete snapshots nothing references any more."""
-    # logged_at is ISO8601 with a 'T' and a +00:00 offset; SQLite's
-    # datetime() returns 'YYYY-MM-DD HH:MM:SS'. Comparing them as raw
-    # strings put every row from the cutoff CALENDAR DAY on the wrong
-    # side ('T' > ' '), so a full day never pruned. Normalise to the
-    # same shape first — all logged_at values are UTC (see _iso()).
-    cur = con.execute(
-        "UPDATE signals SET headlines_hash=NULL, events_hash=NULL"
-        " WHERE substr(replace(logged_at, 'T', ' '), 1, 19)"
-        " < datetime('now', ?)", (f"-{int(days)} days",))
-    con.commit()
-    prune_orphans(con)
-    return cur.rowcount
-
-
-def main(argv=None) -> int:
-    ap = argparse.ArgumentParser(description=__doc__.splitlines()[1])
-    ap.add_argument("--db", default=None)
-    ap.add_argument("--dry-run", action="store_true")
-    ap.add_argument("--batch", type=int, default=500)
-    ap.add_argument("--prune-news-older-than", type=int, default=None,
-                    metavar="DAYS")
-    ap.add_argument("--prune-orphans", action="store_true")
-    ap.add_argument("--vacuum", action="store_true",
-                    help="checkpoint + VACUUM (all writers must be stopped)")
-    ap.add_argument("--no-backup", action="store_true")
-    args = ap.parse_args(argv)
-    path = args.db or app_config.signal_log_path()
-    if not os.path.exists(path):
-        print(f"no database at {path}")
-        return 1
-    size0 = os.path.getsize(path)
-    if args.dry_run:
-        con = sqlite3.connect(f"file:{os.path.abspath(path)}?mode=ro", uri=True)
-        n = con.execute(
-            "SELECT COUNT(*) FROM signals WHERE headlines_json IS NOT NULL"
-            " OR events_json IS NOT NULL").fetchone()[0]
-        d = con.execute(
-            "SELECT COUNT(DISTINCT headlines_json) FROM signals"
-            " WHERE headlines_json IS NOT NULL").fetchone()[0]
-        print(f"{n} rows carry inline news blobs ({d} distinct headline "
-              f"blobs); file size {size0 / 1e6:.1f} MB")
-        con.close()
-        return 0
-    if not args.no_backup:
-        backup = f"{path}.pre-news-{datetime.now(timezone.utc):%Y%m%d}"
-        if not os.path.exists(backup):
-            src = sqlite3.connect(path)
-            dst = sqlite3.connect(backup)
-            src.backup(dst)
-            dst.close()
-            src.close()
-            print(f"backup written: {backup}")
-    lg = SignalLogger(path)          # applies the additive schema
-    lg.close()
-    con = sqlite3.connect(path)
-    con.execute("PRAGMA busy_timeout=10000")
-    try:
-        print("migrate:", migrate(con, batch=args.batch))
-        if args.prune_news_older_than is not None:
-            print("rows de-referenced:",
-                  prune_news_older_than(con, args.prune_news_older_than))
-        if args.prune_orphans:
-            print("orphan snapshots removed:", prune_orphans(con))
-        if args.vacuum:
-            try:
-                con.execute("PRAGMA wal_checkpoint(TRUNCATE)")
-                con.execute("VACUUM")
-            except sqlite3.OperationalError as exc:
-                print(f"VACUUM failed ({exc}) — stop the bot and dashboard "
-                      "publisher first, then re-run with --vacuum")
-                return 2
-    finally:
-        con.close()
-    print(f"size {size0 / 1e6:.1f} MB -> {os.path.getsize(path) / 1e6:.1f} MB"
-          + ("" if args.vacuum else " (run --vacuum to reclaim space)"))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/shadow_scan.py

@@ -1,194 +0,0 @@
-#!/usr/bin/env python3
-"""
-Phase 4 — live shadow scan (data source change test)
-=====================================================
-Runs TWO data providers side-by-side at every candle close (M5/M15/H1)
-and logs how their signals diverge, so the feed switch can be validated
-under real fetch depths / caching / boundary timing for ≥2 weeks.
-
-Unlike the history studies, this uses the LIVE fetch path (fetch_ohlcv,
-forming-candle drop, freshness checks) for both providers, but calls
-`analyze_from_dataframes(use_news=False)` directly so the (provider-
-independent) news/DeepSeek budget is not burned on shadow scans. The
-weekend filter is applied here (skip the whole cycle), and the session/
-day/hour gates run inside analyze_from_dataframes as in the backtest.
-
-No orders, no Telegram, no signal-log writes — output is a side-by-side
-CSV plus a rolling agreement tally.
-
-Usage:
-    venv/bin/python scripts/shadow_scan.py --a oanda --b tiingo \
-        --tfs M5,M15,H1 --out logs/shadow_oanda_tiingo.csv --once
-    # production (2+ weeks):
-    nohup venv/bin/python scripts/shadow_scan.py --a oanda --b tiingo \
-        --out logs/shadow_oanda_tiingo.csv >> logs/shadow_scan.log 2>&1 &
-
-CSV columns (one row per TF per boundary):
-    ts, tf, a_<field>, b_<field> for direction/grade/setup/tag/entry/sl/tp1,
-    a_price, b_price, a_spread, b_spread, a_warnings, b_warnings,
-    dir_agree, grade_agree, setup_agree
-"""
-
-import argparse
-import csv
-import sys
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-
-import pandas as pd
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from config import PlatformConfig, Timeframe, XAUUSD
-from pair_signals.xauusd import make_config
-from providers import make_data_provider
-from providers.base import _is_forex_weekend
-from signal_aggregator import SignalAggregator, SignalReport
-
-_TF_LOOKUP = {"M5": Timeframe.M5, "M15": Timeframe.M15, "H1": Timeframe.H1,
-              "H4": Timeframe.H4}
-_TF_MINUTES = {Timeframe.M5: 5, Timeframe.M15: 15, Timeframe.H1: 60,
-               Timeframe.H4: 240}
-_CONFIRMS = {Timeframe.M5: [Timeframe.M15, Timeframe.H1],
-             Timeframe.M15: [Timeframe.M5, Timeframe.H1],
-             Timeframe.H1: [Timeframe.M15, Timeframe.H4],
-             Timeframe.H4: [Timeframe.H1, Timeframe.D1]}
-
-FIELDS = ["direction", "grade", "setup", "tag", "entry", "sl", "tp1"]
-
-
-def seconds_until_boundary(interval_minutes: int, buffer: int = 10) -> float:
-    now = datetime.now(timezone.utc)
-    elapsed = (now.minute % interval_minutes) * 60 + now.second \
-        + now.microsecond / 1e6
-    return interval_minutes * 60 - elapsed + buffer
-
-
-def due_timeframes(wake: datetime, tfs) -> list:
-    minutes = wake.hour * 60 + wake.minute
-    floored = minutes - (minutes % 5)
-    return [tf for tf in tfs if floored % _TF_MINUTES[tf] == 0]
-
-
-def tag_of(report) -> str:
-    fb = report.bullish_reasons[0] if report.bullish_reasons else ""
-    fbe = report.bearish_reasons[0] if report.bearish_reasons else ""
-    if "XAU PULLBACK" in fb or "XAU PULLBACK" in fbe:
-        return "XAU_PB"
-    if "XAU CHART PATTERN" in fb or "XAU CHART PATTERN" in fbe:
-        return "XAU_CP"
-    if "XAU STRATEGY" in fb:
-        return "XAU"
-    return "GENERIC"
-
-
-def scan(provider, symbol, tf) -> SignalReport:
-    confirms = _CONFIRMS[tf]
-    cfg = make_config(tf, confirms)
-    agg = SignalAggregator(cfg)
-    agg.data_provider = provider
-    dfs = {}
-    for t in [tf] + confirms:
-        dfs[t] = provider.fetch_ohlcv(symbol, t)
-    return agg.analyze_from_dataframes(symbol, dfs, use_news=False)
-
-
-def extract(provider, report) -> dict:
-    s = report.trade_setup
-    return {
-        "direction": report.final_signal.value,
-        "grade": report.signal_quality,
-        "setup": 1 if s is not None else 0,
-        "tag": tag_of(report) if s else "",
-        "entry": round(s.entry_price, 3) if s else "",
-        "sl": round(s.stop_loss, 3) if s else "",
-        "tp1": round(s.take_profit_1, 3) if s else "",
-        "price": round(report.current_price, 3),
-        "spread": round(provider.get_spread(XAUUSD), 3),
-        "warnings": " | ".join(report.warnings)[:200],
-    }
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--a", default="oanda")
-    ap.add_argument("--b", default="tiingo")
-    ap.add_argument("--tfs", default="M5,M15,H1")
-    ap.add_argument("--out", default="logs/shadow_scan.csv")
-    ap.add_argument("--once", action="store_true",
-                    help="one immediate scan cycle, then exit")
-    args = ap.parse_args()
-
-    tfs = [_TF_LOOKUP[s.strip()] for s in args.tfs.split(",")]
-    pa = make_data_provider(PlatformConfig(), args.a)
-    pb = make_data_provider(PlatformConfig(), args.b)
-
-    out_path = Path(args.out)
-    out_path.parent.mkdir(parents=True, exist_ok=True)
-    new_file = not out_path.exists()
-    tally = {"cycles": 0, "dir": 0, "grade": 0, "setup": 0}
-
-    with open(out_path, "a", newline="") as fh:
-        w = csv.writer(fh)
-        if new_file:
-            w.writerow(["ts", "tf"] + [f"a_{x}" for x in FIELDS + ["price", "spread", "warnings"]]
-                       + [f"b_{x}" for x in FIELDS + ["price", "spread", "warnings"]]
-                       + ["dir_agree", "grade_agree", "setup_agree"])
-
-        while True:
-            if args.once:
-                wake = datetime.now(timezone.utc)
-            else:
-                wait = seconds_until_boundary(5, buffer=10)
-                time.sleep(wait)
-                wake = datetime.now(timezone.utc)
-
-            if _is_forex_weekend():
-                if args.once:
-                    print("weekend — nothing to scan")
-                    return
-                continue
-
-            for tf in due_timeframes(wake, tfs):
-                try:
-                    ra = scan(pa, XAUUSD, tf)
-                except Exception as e:
-                    print(f"[{wake:%H:%M:%S}] {args.a} {tf.value} FAILED: {e}")
-                    continue
-                try:
-                    rb = scan(pb, XAUUSD, tf)
-                except Exception as e:
-                    print(f"[{wake:%H:%M:%S}] {args.b} {tf.value} FAILED: {e}")
-                    continue
-
-                ea, eb = extract(pa, ra), extract(pb, rb)
-                da = ea["direction"] == eb["direction"]
-                ga = ea["grade"] == eb["grade"]
-                sa = ea["setup"] == eb["setup"]
-                tally["cycles"] += 1
-                tally["dir"] += da; tally["grade"] += ga; tally["setup"] += sa
-
-                row = [wake.isoformat(), tf.value]
-                row += [ea[x] for x in FIELDS + ["price", "spread", "warnings"]]
-                row += [eb[x] for x in FIELDS + ["price", "spread", "warnings"]]
-                row += [int(da), int(ga), int(sa)]
-                w.writerow(row)
-                fh.flush()
-
-                print(f"[{wake:%Y-%m-%d %H:%M:%S}] {tf.value:<5} "
-                      f"{args.a}={ea['direction']:+d}/{ea['grade'] or '-':>2} "
-                      f"{args.b}={eb['direction']:+d}/{eb['grade'] or '-':>2} "
-                      f"dir={'OK' if da else 'FLIP'} "
-                      f"| Δprice {abs(ea['price']-eb['price']):.2f} "
-                      f"| agree dir {tally['dir']}/{tally['cycles']} "
-                      f"grade {tally['grade']}/{tally['cycles']} "
-                      f"setup {tally['setup']}/{tally['cycles']}")
-
-            if args.once:
-                print("shadow scan complete (--once)")
-                return
-
-
-if __name__ == "__main__":
-    main()

scripts/signal_parity_study.py

@@ -1,246 +0,0 @@
-#!/usr/bin/env python3
-"""
-Phase 2 — signal-level replay parity (data source change test)
-===============================================================
-Replays the REAL decision core (`SignalAggregator.analyze_from_dataframes`,
-news off, use_news=False) over the same window for two providers and
-compares the *decisions* bar-by-bar: direction, composite/final score,
-quality grade, gate/setup presence, strategy tag, and entry/SL/TP levels.
-
-This turns the Phase-1 price-diff stats into flip rates. Feeds are read
-from the Phase-1 parquet cache (scripts/feed_divergence_study.py writes
-them); pass --no-cache-fetch only if you want to fetch fresh via
-fetch_range first.
-
-Slicing matches gpu_backtest.py exactly: decision at close of bar `pos`,
-each TF sliced to bars fully closed by that decision time, primary at the
-shared grid, so the two feeds are compared on identical timestamps.
-
-Usage:
-    venv/bin/python scripts/signal_parity_study.py --a oanda --b tiingo \
-        --tf M15 --stride 8 --days 365
-"""
-
-import argparse
-import sys
-import time
-from pathlib import Path
-
-import numpy as np
-import pandas as pd
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from config import Timeframe, XAUUSD
-from pair_signals.xauusd import make_config
-from signal_aggregator import SignalAggregator
-
-REPO = Path(__file__).resolve().parent.parent
-CACHE_DIR = REPO / "backtest" / "cache"
-RESEARCH_DIR = REPO / "backtest" / "research"
-
-BAR_SECONDS = {
-    Timeframe.M1: 60, Timeframe.M5: 300, Timeframe.M15: 900,
-    Timeframe.M30: 1800, Timeframe.H1: 3600, Timeframe.H4: 14400,
-    Timeframe.D1: 86400, Timeframe.W1: 604800,
-}
-_TF_LOOKUP = {t.value: t for t in Timeframe}
-_TF_LOOKUP.update({"M1": Timeframe.M1, "M5": Timeframe.M5,
-                   "M15": Timeframe.M15, "M30": Timeframe.M30,
-                   "H1": Timeframe.H1, "H4": Timeframe.H4,
-                   "D1": Timeframe.D1, "W1": Timeframe.W1})
-_CONFIRMS = {
-    Timeframe.M5: [Timeframe.M15, Timeframe.H1],
-    Timeframe.M15: [Timeframe.M5, Timeframe.H1],
-    Timeframe.H1: [Timeframe.M15, Timeframe.H4],
-    Timeframe.H4: [Timeframe.H1, Timeframe.D1],
-}
-
-
-def load_cached(name: str, tf: Timeframe, start: pd.Timestamp,
-                end: pd.Timestamp) -> pd.DataFrame:
-    cp = CACHE_DIR / f"{name}_XAU_USD_{tf.value}_{start:%Y%m%d}_{end:%Y%m%d}.parquet"
-    if not cp.exists():
-        sys.exit(f"missing cache {cp}; run scripts/feed_divergence_study.py "
-                 f"--a oanda --b {name} --tfs {tf.value} --days ... first")
-    return pd.read_parquet(cp)
-
-
-def tag_of(report) -> str:
-    first_bull = report.bullish_reasons[0] if report.bullish_reasons else ""
-    first_bear = report.bearish_reasons[0] if report.bearish_reasons else ""
-    if "XAU PULLBACK" in first_bull or "XAU PULLBACK" in first_bear:
-        return "XAU_PB"
-    if "XAU CHART PATTERN" in first_bull or "XAU CHART PATTERN" in first_bear:
-        return "XAU_CP"
-    if "XAU STRATEGY" in first_bull:
-        return "XAU"
-    return "GENERIC"
-
-
-def decide(agg, dfs, tss, stride, warmup) -> list:
-    """Replay decisions over the shared grid, returning one row per bar."""
-    primary = dfs[agg.config.primary_timeframe]
-    dur = pd.Timedelta(seconds=BAR_SECONDS[agg.config.primary_timeframe])
-
-    # positions of sampled bars in the primary frame
-    primary_pos = primary.index.get_indexer(tss)
-    rows = []
-    for i in range(0, len(tss), stride):
-        ts = tss[i]
-        pos = int(primary_pos[i])
-        if pos < warmup:
-            continue
-        slices = {}
-        for tf, full in dfs.items():
-            cutoff = ts  # decision_time = ts + dur; bars closed by ts
-            cut = int(full.index.searchsorted(cutoff, side="right"))
-            if cut <= 0:
-                continue
-            slices[tf] = full.iloc[:cut]
-        if agg.config.primary_timeframe not in slices:
-            continue
-        r = agg.analyze_from_dataframes(XAUUSD, slices, use_news=False)
-        ts_setup = r.trade_setup
-        rows.append({
-            "ts": ts,
-            "direction": r.final_signal.value,
-            "final_score": r.final_score,
-            "primary_score": r.primary_score,
-            "grade": r.signal_quality,
-            "has_setup": ts_setup is not None,
-            "tag": tag_of(r) if ts_setup else "",
-            "entry": ts_setup.entry_price if ts_setup else np.nan,
-            "sl": ts_setup.stop_loss if ts_setup else np.nan,
-            "tp1": ts_setup.take_profit_1 if ts_setup else np.nan,
-            "tp2": ts_setup.take_profit_2 if ts_setup else np.nan,
-        })
-    return rows
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--a", required=True)
-    ap.add_argument("--b", required=True)
-    ap.add_argument("--tf", default="M15")
-    ap.add_argument("--stride", type=int, default=1,
-                    help="sample every Nth shared bar (default 1)")
-    ap.add_argument("--days", type=int, default=365)
-    ap.add_argument("--end", default=None)
-    ap.add_argument("--warmup", type=int, default=300)
-    args = ap.parse_args()
-
-    tf = _TF_LOOKUP.get(args.tf)
-    if tf is None:
-        sys.exit(f"unknown tf {args.tf}")
-    confirms = _CONFIRMS[tf]
-    tfs = [tf] + confirms
-
-    end = pd.Timestamp(args.end, tz="UTC") if args.end \
-        else pd.Timestamp.now(tz="UTC")
-    start = end - pd.Timedelta(days=args.days)
-
-    cfg = make_config(tf, confirms)
-    agg = SignalAggregator(cfg)
-
-    a_dfs, b_dfs = {}, {}
-    for t in tfs:
-        a_dfs[t] = load_cached(args.a, t, start, end)
-        b_dfs[t] = load_cached(args.b, t, start, end)
-
-    # shared grid = primary timestamps present in both feeds
-    shared = a_dfs[tf].index.intersection(b_dfs[tf].index)
-
-    t0 = time.time()
-    print(f"replaying {len(shared)} shared {tf.value} bars "
-          f"(stride {args.stride} → ~{len(shared)//args.stride}) on {args.a}...")
-    a_rows = decide(agg, a_dfs, shared, args.stride, args.warmup)
-    print(f"  {args.a}: {len(a_rows)} decisions in {time.time()-t0:.1f}s")
-    t0 = time.time()
-    b_rows = decide(agg, b_dfs, shared, args.stride, args.warmup)
-    print(f"  {args.b}: {len(b_rows)} decisions in {time.time()-t0:.1f}s")
-
-    A = pd.DataFrame(a_rows).set_index("ts")
-    B = pd.DataFrame(b_rows).set_index("ts")
-    common = A.index.intersection(B.index)
-    A, B = A.loc[common], B.loc[common]
-    n = len(common)
-
-    print(f"\n{'=' * 78}")
-    print(f"SIGNAL-LEVEL PARITY — {tf.value} — {args.a} vs {args.b} "
-          f"({n:,} bars)")
-    print("=" * 78)
-
-    def pct(x): return f"{100 * x:.2f}%"
-
-    same_dir = (A["direction"] == B["direction"])
-    same_grade = (A["grade"] == B["grade"])
-    same_setup = (A["has_setup"] == B["has_setup"])
-    same_all = same_dir & same_grade & same_setup
-
-    print(f"\nIDENTITY")
-    print(f"  same direction        : {pct(same_dir.mean())}")
-    print(f"  same grade            : {pct(same_grade.mean())}")
-    print(f"  same setup presence   : {pct(same_setup.mean())}")
-    print(f"  same dir+grade+setup  : {pct(same_all.mean())}")
-
-    both_sig = (A["direction"] != 0) & (B["direction"] != 0)
-    flips = both_sig & (A["direction"] != B["direction"])
-    opp = flips & (A["direction"] == -B["direction"])
-    print(f"\nDIRECTION")
-    print(f"  bars both actionable    : {both_sig.sum():,} "
-          f"({pct(both_sig.mean())})")
-    print(f"  direction flips         : {flips.sum():,} "
-          f"({pct(flips.sum()/max(both_sig.sum(),1))} of actionable)")
-    print(f"  opposite-sign flips     : {opp.sum():,}")
-
-    grade_a = set(A.loc[A["has_setup"], "grade"])
-    print(f"\nGRADE (of {args.a} setups, grades seen: {sorted(grade_a)})")
-    changed = A.loc[both_sig, "grade"] != B.loc[both_sig, "grade"]
-    print(f"  grade changed on actionable bars: "
-          f"{changed.sum():,} ({pct(changed.mean())})")
-
-    # score deltas on shared bars
-    ds = (A["final_score"] - B["final_score"]).abs()
-    dp = (A["primary_score"] - B["primary_score"]).abs()
-    print(f"\nSCORE Δ  ({args.a} − {args.b})")
-    print(f"  final_score   mean {ds.mean():6.2f}  p95 {ds.quantile(.95):6.2f}  "
-          f"max {ds.max():6.2f}")
-    print(f"  primary_score mean {dp.mean():6.2f}  p95 {dp.quantile(.95):6.2f}  "
-          f"max {dp.max():6.2f}")
-
-    # setup price diffs on bars where BOTH generated a setup
-    both_setup = A["has_setup"] & B["has_setup"]
-    if both_setup.any():
-        print(f"\nSETUP LEVELS (both-setup bars: {both_setup.sum():,})")
-        for col, label in (("entry", "entry"), ("sl", "SL"), ("tp1", "TP1"),
-                           ("tp2", "TP2")):
-            d = (A.loc[both_setup, col] - B.loc[both_setup, col]).abs()
-            print(f"  {label:<6} mean ${d.mean():6.3f}  p95 ${d.quantile(.95):7.3f}  "
-                  f"max ${d.max():7.2f}")
-
-    # tag disagreement on both-setup bars
-    if both_setup.any():
-        same_tag = (A.loc[both_setup, "tag"] == B.loc[both_setup, "tag"])
-        print(f"  same strategy tag      : {pct(same_tag.mean())}")
-
-    # where do flips cluster (hour)?
-    flip_hours = A.loc[flips].index.hour.value_counts().sort_index()
-    if len(flip_hours):
-        print(f"\nFLIPS BY UTC HOUR")
-        for h, c in flip_hours.items():
-            print(f"  {h:02d}: {c}")
-
-    out = {
-        "tf": tf.value, "a": args.a, "b": args.b, "bars": n,
-        "same_dir": same_dir.mean(), "same_grade": same_grade.mean(),
-        "same_setup": same_setup.mean(), "same_all": same_all.mean(),
-        "flip_rate_actionable": flips.sum() / max(both_sig.sum(), 1),
-        "mean_abs_final_score_delta": ds.mean(),
-        "mean_abs_primary_score_delta": dp.mean(),
-    }
-    print(f"\n{out}")
-
-
-if __name__ == "__main__":
-    main()

signal_aggregator.py

@@ -5,8 +5,6 @@ Combines multi-timeframe technical analysis with optional news context
 into a graded actionable signal.
 """
 
-import hashlib
-import json
 import logging
 import os
 from dataclasses import dataclass, field
@@ -23,7 +21,6 @@ from config import PlatformConfig, SignalStrength, Timeframe
 from providers import BaseDataProvider, make_data_provider
 from engine import TechnicalEngine, TechnicalAnalysis
 from news_engine import NewsEngine, FundamentalContext
-import signal_log
 
 logger = logging.getLogger(__name__)
 
@@ -58,12 +55,8 @@ class TradeSetup:
     risk_pips: float
     reward_pips: float
     pip_value: float
-    # Entry archetype — selects trail params and explains the setup to
+    # Entry archetype ("GENERIC", "XAU_PB") — selects trail params.
-    # advisory consumers. setup_pattern is populated only by XAU_CP.
     strategy: str = "GENERIC"
-    setup_pattern: Optional[str] = None
-    # Strategy cost assumption, not a broker/data-provider quote.
-    round_trip_cost: Optional[float] = None
     # Trailing exit params stamped from the PRODUCING config, so per-TF
     # factory overrides (e.g. M15 arm 0.70, M5 dist 0.85) reach every
     # consumer. None = legacy/unstamped setup — formatters fall back to
@@ -95,19 +88,6 @@ class SignalReport:
     news_description: str = ""
     news_summary: str = ""  # LLM market-context blurb (display-only)
 
-    # LLM agent-panel consensus (advisory/DISPLAY-ONLY). Populated
-    # post-hoc by consumers via agent_panel.attach_panel — NEVER inside
-    # analyze_from_dataframes (backtest parity) and never read by any
-    # gate or scoring path.
-    panel_verdict: str = ""        # "AGREE" / "NEUTRAL" / "OPPOSE" / ""
-    panel_confidence: float = 0.0
-    panel_rationale: str = ""
-    panel_takes: List[Dict] = field(default_factory=list)
-    panel_created_at: str = ""
-    panel_cache_status: str = ""
-    panel_payload_hash: str = ""
-    panel_verdict_source: str = ""  # "macro" / "chair" / ""
-
     final_signal: SignalStrength = SignalStrength.NEUTRAL
     final_score: float = 0.0
     final_confidence: float = 0.0
@@ -119,9 +99,6 @@ class SignalReport:
     bullish_reasons: List[str] = field(default_factory=list)
     bearish_reasons: List[str] = field(default_factory=list)
     warnings: List[str] = field(default_factory=list)
-    # Warnings the XAU_CP acceptance removed from `warnings` (metadata
-    # only — logged so the gates a CP trade bypassed stay auditable).
-    cleaned_warnings: List[str] = field(default_factory=list)
 
     current_price: float = 0.0
     spread_estimate: float = 0.0
@@ -156,14 +133,8 @@ class SignalAggregator:
         self,
         symbol: Optional[str] = None,
         context: Optional[FundamentalContext] = None,
-        log_source: Optional[str] = None,
     ) -> SignalReport:
-        """Live-mode entry: fetch all needed timeframes then delegate.
+        """Live-mode entry: fetch all needed timeframes then delegate."""
-
-        Every report produced here (including weekend/day-filter early
-        returns) is persisted to the signal-history DB via _log_signal —
-        fail-safe, and never reached by the backtester, which calls
-        analyze_from_dataframes directly (live == backtest parity)."""
         if symbol is None:
             symbol = self.config.symbol
 
@@ -184,7 +155,6 @@ class SignalAggregator:
                 report.trade_setup = None
                 report.warnings.append("WEEKEND FILTER: XAU/USD market closed — no liquidity")
                 report.action_recommendation = "NO TRADE — Weekend (market closed)"
-                self._log_signal(report, log_source, blocked=True)
                 return report
 
             if xau_cfg.allowed_weekdays and now_utc.weekday() not in xau_cfg.allowed_weekdays:
@@ -202,7 +172,6 @@ class SignalAggregator:
                     f"DAY FILTER: {day_names.get(now_utc.weekday(), '?')} not in allowed days ({allowed})"
                 )
                 report.action_recommendation = f"NO TRADE — Only trading {allowed}"
-                self._log_signal(report, log_source, blocked=True)
                 return report
 
         timeframes = [self.config.primary_timeframe] + list(
@@ -280,74 +249,8 @@ class SignalAggregator:
                     f"{symbol}: live session filter errored — filter SKIPPED this scan"
                 )
 
-        self._log_signal(report, log_source, dfs)
         return report
 
-    def _log_signal(
-        self, report: SignalReport, source: Optional[str],
-        dataframes: Optional[Dict[Timeframe, pd.DataFrame]] = None,
-        blocked: bool = False,
-    ) -> None:
-        """Persist the scan to the signal-history DB (signal_log.py).
-
-        Fail-safe by contract — a logging failure must never break a
-        live scan. The news context re-fetch rides the NewsEngine's
-        class-level caches, so it costs nothing within a scan and
-        matches the context the signal just used; if it fails, the row
-        is still written, just without the news JSON blobs. ``blocked``
-        marks weekend/day early returns: no news fetch, no snapshots —
-        a ~1 KB liveness row (or nothing, per signal_log.log_blocked_scans)."""
-        context = None
-        if not blocked:
-            try:
-                context = self._get_news_engine().get_fundamental_context()
-            except Exception:
-                logger.debug("signal log: news context unavailable",
-                             exc_info=True)
-        extra = {"scan_kind": "blocked" if blocked else "scan"}
-        try:
-            extra["config_fingerprint"] = self.gate_config_fingerprint()
-        except Exception:
-            logger.debug("signal log: config fingerprint unavailable",
-                         exc_info=True)
-        signal_log.log_signal(
-            report,
-            context=context,
-            source=source or "live",
-            timeframe=self.config.primary_timeframe.value,
-            dataframes=dataframes,
-            extra=extra,
-        )
-
-    def gate_config_fingerprint(self) -> str:
-        """Short hash of the gate configuration this process runs with.
-
-        Logged on every row so two surfaces disagreeing on the same bar
-        (2026-08-19: the dashboard process applied a different blocked-
-        hours list than the bot for a day) is diagnosable from the DB."""
-        xs = self.config.xau_strategy
-        bt = self.config.backtest
-        payload = {
-            "primary": self.config.primary_timeframe.value,
-            "confirm": [tf.value for tf in self.config.confirmation_timeframes],
-            "blocked_hours": list(xs.blocked_hours_utc),
-            "sell_blocked_hours": list(xs.sell_blocked_hours_utc),
-            "allowed_weekdays": list(xs.allowed_weekdays),
-            "blocked_regimes": list(xs.blocked_regimes),
-            "sell_blocked_regimes": list(xs.sell_blocked_regimes),
-            "sell_min_quality": list(xs.sell_min_quality),
-            "sell_vol_regimes": list(xs.sell_vol_regimes),
-            "big_candle": xs.big_candle_atr_multiple,
-            "cp": bool(xs.cp_enabled),
-            "pb": bool(xs.m5_pullback_enabled),
-            "session": [bt.session_filter, bt.session_start_hour,
-                        bt.session_end_hour],
-            "regime_filter": bool(bt.regime_filter),
-        }
-        return hashlib.sha1(
-            json.dumps(payload, sort_keys=True, default=str).encode("utf-8")
-        ).hexdigest()[:12]
-
     def _apply_regime_filter_live(
         self, report: SignalReport, dfs: Dict[Timeframe, pd.DataFrame]
     ) -> None:
@@ -708,7 +611,6 @@ class SignalAggregator:
             reward_pips=1.5 * sl_dist / pip_value,
             pip_value=pip_value,
             strategy="XAU_PB",
-            round_trip_cost=self.config.signals.round_trip_cost,
             trail_arm_r=self.config.signals.pb_trail_arm_r,
             trail_dist_r=self.config.signals.pb_trail_dist_r,
         )
@@ -790,9 +692,9 @@ class SignalAggregator:
                     close_h = None
                     logger.warning(
                         f"{report.symbol}: bar-close hour underivable — "
-                        f"CP SELL hour gate FAILS CLOSED (short rejected)"
+                        f"SELL hour gate skipped"
                     )
-                if close_h is None or close_h in cfg.sell_blocked_hours_utc:
+                if close_h in cfg.sell_blocked_hours_utc:
                     _reject("sell_hour")
                     return
             if self.config.primary_timeframe == Timeframe.M5:
@@ -846,8 +748,6 @@ class SignalAggregator:
             reward_pips=height / pip_value,
             pip_value=pip_value,
             strategy="XAU_CP",
-            setup_pattern=pat["pattern"],
-            round_trip_cost=self.config.signals.round_trip_cost,
             trail_arm_r=self.config.signals.trail_arm_r,
             trail_dist_r=self.config.signals.trail_dist_r,
         )
@@ -863,82 +763,8 @@ class SignalAggregator:
                   f"height {height / atr:.1f} ATR")
         target = report.bullish_reasons if is_buy else report.bearish_reasons
         target.insert(0, marker)
-        self._clean_accepted_cp_warnings(report)
         _reject("accepted")
 
-    @staticmethod
-    def _clean_accepted_cp_warnings(report: SignalReport) -> None:
-        """Drop superseded composite-path warnings after XAU_CP accepts.
-
-        This is metadata-only. Pattern detection, gates, confidence,
-        exhaustion state, setup geometry, and signal selection are already
-        final when this runs.
-        """
-        stale_prefixes = (
-            "SPREAD GATE:",
-            "EXHAUSTION BLOCK",
-            "EXHAUSTED TREND FILTER:",
-            "MTF OPPOSITION:",
-            "SELL FILTER: quality",
-            "SELL FILTER: volatility",
-            "SELL FILTER: regime",
-            "SELL FILTER: ",
-            "M5 FILTER: |score|",
-            "M5 FILTER: no MTF agreement",
-            "M5 FILTER: no confirmation TF",
-            "M5 FILTER: SELL quality",
-            "M5 FILTER: SELL blocked",
-        )
-        extension_prefixes = (
-            "TREND EXHAUSTION",
-            "NO PULLBACK",
-            "FAR FROM EMA200",
-            "Extended — RSI",
-            "Weak pullback",
-        )
-        filtered: List[str] = []
-        dropped: List[str] = []
-        for warning in report.warnings:
-            if warning.startswith(stale_prefixes):
-                dropped.append(warning)
-                continue
-            if (warning.startswith("REGIME FILTER: '")
-                    and warning.endswith("blocked for XAU")):
-                dropped.append(warning)
-                continue
-            if (warning.startswith("M5 FILTER: '")
-                    and "volatility" in warning):
-                dropped.append(warning)
-                continue
-            filtered.append(warning)
-
-        extension_items = [
-            (index, warning)
-            for index, warning in enumerate(filtered)
-            if warning.startswith(extension_prefixes)
-        ]
-        if not extension_items:
-            report.warnings[:] = filtered
-            report.cleaned_warnings.extend(dropped)
-            return
-        first_index = extension_items[0][0]
-        priority = {prefix: rank for rank, prefix in enumerate(extension_prefixes)}
-        strongest = min(
-            (warning for _, warning in extension_items),
-            key=lambda warning: next(
-                rank for prefix, rank in priority.items()
-                if warning.startswith(prefix)),
-        )
-        kept = [
-            warning for warning in filtered
-            if not warning.startswith(extension_prefixes)
-        ]
-        kept.insert(first_index, strongest)
-        dropped.extend(
-            warning for _, warning in extension_items if warning != strongest)
-        report.warnings[:] = kept
-        report.cleaned_warnings.extend(dropped)
-
     # ── Public: bar-replayable entry point ─────────────────────────
 
     def analyze_from_dataframes(
@@ -1170,16 +996,11 @@ class SignalAggregator:
                     close_h = None
                     logger.warning(
                         f"{report.symbol}: bar-close hour underivable — "
-                        f"SELL hour gate FAILS CLOSED (short blocked)"
+                        f"SELL hour gate skipped"
                     )
-                # Fail CLOSED: an underivable close hour blocks the short
+                if close_h in self.config.xau_strategy.sell_blocked_hours_utc:
-                # (`None in [15, 17]` used to pass silently). Never fires
-                # on parseable timestamps, so pinned books are unchanged.
-                if (close_h is None
-                        or close_h in self.config.xau_strategy.sell_blocked_hours_utc):
-                    hour_txt = "??" if close_h is None else f"{close_h:02}"
                     report.warnings.append(
-                        f"SELL FILTER: {hour_txt}:00 UTC entry blocked for shorts"
+                        f"SELL FILTER: {close_h:02}:00 UTC entry blocked for shorts"
                     )
                     report.signal_quality = "D"
                     report.trade_setup = None
@@ -1330,8 +1151,6 @@ class SignalAggregator:
             risk_pips=round(sl_distance / pip_value, 1),
             reward_pips=round(tp_distance / pip_value, 1),
             pip_value=pip_value,
-            strategy="XAU_ATR",
-            round_trip_cost=self.config.signals.round_trip_cost,
             trail_arm_r=self.config.signals.trail_arm_r,
             trail_dist_r=self.config.signals.trail_dist_r,
         )
@@ -1746,7 +1565,6 @@ class SignalAggregator:
             risk_pips=risk_pips,
             reward_pips=reward_pips,
             pip_value=pip_value,
-            round_trip_cost=self.config.signals.round_trip_cost,
             trail_arm_r=self.config.signals.trail_arm_r,
             trail_dist_r=self.config.signals.trail_dist_r,
         )

static/dashboard.css

@@ -1,351 +0,0 @@
-/* Gold Desk — XAU/USD dashboard styles
- *
- * Builds on Bootstrap 5.3 color modes (data-bs-theme). Only app-specific
- * tokens and components live here; layout, typography, tables, badges,
- * cards, alerts, modals, etc. come from Bootstrap.
- */
-
-:root {
-  --xau-font-sans: "Inter", system-ui, -apple-system, "Segoe UI", sans-serif;
-  --xau-font-mono: "JetBrains Mono", ui-monospace, "SF Mono", Consolas, Menlo, monospace;
-  --xau-gold: #f5b301;
-}
-
-/* Forced dark theme (owner decision 2026-08-16): dark background, pure
- * white text (no gray), vivid red/green for data accents. Loaded after
- * Bootstrap so these overrides win. */
-[data-bs-theme="dark"] {
-  --bs-body-bg: #0a0e14;
-  --bs-secondary-bg: #111823;
-  --bs-tertiary-bg: #0e141d;
-  --bs-body-color: #ffffff;
-  --bs-emphasis-color: #ffffff;
-  --bs-heading-color: #ffffff;
-  --bs-secondary-color: rgba(255, 255, 255, 0.92);
-  --bs-tertiary-color: rgba(255, 255, 255, 0.8);
-  --bs-border-color: rgba(255, 255, 255, 0.14);
-  --bs-card-bg: #0e141d;
-  --bs-card-border-color: rgba(255, 255, 255, 0.12);
-  --bs-modal-bg: #0e141d;
-  --bs-success: #22c55e;
-  --bs-success-rgb: 34, 197, 94;
-  --bs-success-text-emphasis: #4ade80;
-  --bs-success-bg-subtle: rgba(34, 197, 94, 0.16);
-  --bs-success-border-subtle: rgba(34, 197, 94, 0.45);
-  --bs-danger: #ef4444;
-  --bs-danger-rgb: 239, 68, 68;
-  --bs-danger-text-emphasis: #f87171;
-  --bs-danger-bg-subtle: rgba(239, 68, 68, 0.16);
-  --bs-danger-border-subtle: rgba(239, 68, 68, 0.45);
-}
-
-html, body {
-  font-family: var(--xau-font-sans);
-  letter-spacing: -0.005em;
-  -webkit-font-smoothing: antialiased;
-  background-color: var(--bs-body-bg);
-  color: var(--bs-body-color);
-}
-
-.num, .xau-price, .xau-symbol {
-  font-family: var(--xau-font-mono);
-  font-variant-numeric: tabular-nums;
-}
-
-.xau-symbol {
-  font-size: 0.95rem;
-  font-weight: 700;
-  letter-spacing: 0.08em;
-  color: var(--xau-gold);
-}
-
-.xau-price {
-  line-height: 1;
-  color: #ffffff;
-}
-
-.live-dot {
-  display: inline-block;
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  background: var(--bs-success);
-  margin-right: 5px;
-  animation: pulse 2.4s ease-in-out infinite;
-}
-
-.live-dot.closed {
-  background: var(--bs-warning);
-  animation: none;
-}
-
-@keyframes pulse {
-  50% { opacity: 0.35; }
-}
-
-/* signal-coloured accents */
-.sig-buy   { --xau-signal: var(--bs-success); }
-.sig-sell  { --xau-signal: var(--bs-danger); }
-.sig-neutral { --xau-signal: var(--bs-secondary); }
-
-.border-signal {
-  border-left: 3px solid var(--xau-signal, var(--bs-secondary)) !important;
-}
-
-.text-signal {
-  color: var(--xau-signal, var(--bs-secondary)) !important;
-}
-
-.tf-name {
-  font-family: var(--xau-font-mono);
-  font-weight: 700;
-  font-size: 1.1rem;
-  color: var(--bs-primary);
-  letter-spacing: 0.05em;
-}
-
-.tf-selector {
-  display: grid;
-  grid-template-columns: repeat(4, minmax(0, 1fr));
-  gap: 0.5rem;
-  margin-bottom: 0.75rem;
-}
-
-.tf-select {
-  min-width: 0;
-  padding: 0.7rem 0.8rem;
-  border: 1px solid var(--bs-border-color);
-  border-radius: var(--bs-border-radius);
-  background: var(--bs-tertiary-bg);
-  color: var(--bs-body-color);
-  text-align: left;
-  transition: border-color 0.15s ease, background-color 0.15s ease, box-shadow 0.15s ease;
-}
-
-.tf-select:hover {
-  border-color: rgba(var(--bs-primary-rgb), 0.65);
-}
-
-.tf-select[aria-pressed="true"] {
-  border-color: var(--xau-gold);
-  background: rgba(245, 179, 1, 0.09);
-  box-shadow: inset 0 0 0 1px rgba(245, 179, 1, 0.16);
-}
-
-.tf-select .tf-name {
-  font-size: 1rem;
-}
-
-.workspace-card {
-  overflow: hidden;
-}
-
-.workspace-signal {
-  font-family: var(--xau-font-mono);
-  font-size: clamp(1.55rem, 3vw, 2.35rem);
-  font-weight: 700;
-  letter-spacing: 0.03em;
-  line-height: 1;
-}
-
-.workspace-meta {
-  min-width: 0;
-}
-
-.workspace-reasons > div + div {
-  margin-top: 0.35rem;
-}
-
-/* score bar: zero-centered diverging with midpoint tick */
-.scorebar {
-  display: flex;
-  align-items: center;
-  gap: 0.75rem;
-}
-
-.scorebar .gauge-container {
-  position: relative;
-  flex: 1;
-  min-width: 60px;
-  height: 10px;
-  border-radius: 5px;
-  background: var(--bs-secondary-bg);
-  overflow: hidden;
-}
-
-.scorebar .gauge-container::after {
-  content: "";
-  position: absolute;
-  left: 50%;
-  top: 0;
-  bottom: 0;
-  width: 2px;
-  background: var(--bs-secondary);
-  transform: translateX(-1px);
-}
-
-.scorebar .fill {
-  position: absolute;
-  top: 0;
-  bottom: 0;
-  border-radius: 4px;
-  width: var(--score-width);
-  transition: width 0.25s ease;
-}
-
-.scorebar .fill.pos {
-  left: 50%;
-  background: var(--bs-success);
-}
-
-.scorebar .fill.neg {
-  right: 50%;
-  background: var(--bs-danger);
-}
-
-.scorebar .val {
-  width: 58px;
-  text-align: right;
-  font-size: 0.95rem;
-  font-weight: 500;
-}
-
-.scorebar .lbl {
-  font-size: 0.8rem;
-  color: var(--bs-secondary);
-  width: 44px;
-}
-
-/* rail chips in hero */
-.rail-chip {
-  border: 1px solid var(--bs-border-color);
-  border-radius: var(--bs-border-radius);
-  background: var(--bs-tertiary-bg);
-  color: var(--bs-body-color);
-  font-family: var(--xau-font-mono);
-  font-size: 0.9rem;
-  line-height: 1.3;
-  padding: 0.3rem 0.5rem;
-}
-
-.rail-chip:hover, .rail-chip[aria-current="true"] {
-  border-color: var(--xau-gold);
-}
-
-.rail-chip:focus-visible, .tf-select:focus-visible, .wire-item:focus-visible,
-.cal-event:focus-visible {
-  outline: 2px solid var(--xau-gold);
-  outline-offset: 2px;
-}
-
-/* detail dialog sections */
-.d-stat .k {
-  display: block;
-  font-size: 0.7rem;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: var(--bs-secondary);
-  font-weight: 600;
-}
-
-.d-stat .v {
-  font-size: 1.15rem;
-  font-weight: 600;
-}
-
-.d-table {
-  font-size: 0.9rem;
-}
-
-.detail-table {
-  overflow-x: auto;
-}
-
-.d-table .ind-k {
-  font-family: var(--xau-font-mono);
-  font-weight: 600;
-  white-space: nowrap;
-}
-
-.wbar {
-  display: block;
-  height: 4px;
-  border-radius: 2px;
-  background: var(--bs-secondary-bg);
-  margin-top: 3px;
-}
-
-.wbar > i {
-  display: block;
-  height: 100%;
-  border-radius: 2px;
-  background: var(--bs-primary);
-}
-
-/* news */
-.wire-item {
-  display: flex;
-  width: 100%;
-  border: 0;
-  border-radius: var(--bs-border-radius);
-  background: transparent;
-  color: inherit;
-  cursor: pointer;
-  font: inherit;
-  text-align: start;
-}
-
-.wire-item:hover {
-  background: rgba(var(--bs-primary-rgb), 0.08);
-}
-
-.cal-event {
-  display: block;
-  width: 100%;
-  padding: 0;
-  border: 0;
-  background: transparent;
-  color: inherit;
-  text-align: inherit;
-}
-
-.cal-event:hover {
-  color: var(--bs-primary);
-  text-decoration: underline;
-}
-
-.wire-score {
-  font-family: var(--xau-font-mono);
-  font-size: 0.85rem;
-  font-weight: 700;
-  padding: 2px 7px;
-  border-radius: 5px;
-  white-space: nowrap;
-}
-
-/* calendar highlight for next upcoming event */
-.cal-next-up td:first-child {
-  box-shadow: inset 4px 0 0 var(--bs-primary);
-  padding-left: 0.75rem !important;
-}
-
-/* reduced motion */
-@media (prefers-reduced-motion: reduce) {
-  .live-dot { animation: none; }
-  .scorebar .fill { transition: none; }
-  * { transition: none !important; }
-}
-
-@media (max-width: 575.98px) {
-  .tf-selector {
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-  }
-
-  .workspace-card .card-body {
-    padding: 1rem;
-  }
-
-  .rail-chip {
-    flex: 1 1 calc(50% - 0.5rem);
-  }
-}

static/dashboard.js

@@ -1,962 +0,0 @@
-"use strict";
-/* Gold Desk — XAU/USD dashboard frontend
- *
- * Reads snapshot.json + news.json published by dashboard_publisher.py and
- * renders a responsive, keyboard-accessible dashboard. Uses Bootstrap 5 for
- * layout/components/modals and a small custom CSS file for app-specific
- * visuals (score bar, signal colours, mono fonts).
- *
- * This file is intentionally self-contained: it mirrors a few constants from
- * the Python signal pipeline so the HTML does not depend on telegram_bot.
- */
-
-const IND_ORDER = ["ema_trend", "rsi", "macd", "bollinger", "adx", "roc", "keltner", "divergence", "candlestick"];
-const IND_SHORT = {
-  ema_trend: "EMA", rsi: "RSI", macd: "MACD", bollinger: "BB",
-  adx: "ADX", roc: "ROC", keltner: "KC", divergence: "Div", candlestick: "Cndl"
-};
-const ARROW = { STRONG_BUY: "⇈", BUY: "↑", NEUTRAL: "→", SELL: "↓", STRONG_SELL: "⇊" };
-const TF_LABEL = { "5min": "M5", "15min": "M15", "1h": "H1", "4h": "H4" };
-const TF_ORDER = ["5min", "15min", "1h", "4h"];
-const TF_SECONDS = { "5min": 300, "15min": 900, "1h": 3600, "4h": 14400 };
-const FALLBACK_POLL_MS = 60000;
-const RETRY_MS = 15000;
-const HIGH_IMPACT_PREF = "goldDeskHighImpactOnly";
-const TIMEFRAME_PREF = "goldDeskSelectedTimeframe";
-
-const LEVEL_LABEL = {
-  ema_fast: "EMA fast", ema_medium: "EMA medium", ema_slow: "EMA slow", ema_trend: "EMA trend",
-  bb_upper: "Bollinger upper", bb_mid: "Bollinger mid", bb_lower: "Bollinger lower",
-  kc_upper: "Keltner upper", kc_mid: "Keltner mid", kc_lower: "Keltner lower",
-  swing_high_1: "Swing high 1", swing_high_2: "Swing high 2", swing_high_3: "Swing high 3",
-  swing_low_1: "Swing low 1", swing_low_2: "Swing low 2", swing_low_3: "Swing low 3"
-};
-
-let snapshot = null, news = null;
-let clockOffset = 0;
-let lastPollOk = null;
-let lastSnapText = null, lastNewsText = null;
-let refetchTimer = null;
-let fallbackTimer = null;
-let pollInFlight = false;
-let pollQueued = false;
-let selectedTf = "5min";
-
-let detailTf = null;
-let ndState = null;
-const aiMemo = new Map();
-const aiErr = new Map();
-const aiPending = new Set();
-
-let tfModal = null;
-let newsModal = null;
-let tfModalOpen = false;
-let newsModalOpen = false;
-
-const $ = id => document.getElementById(id);
-
-/* ── helpers ──────────────────────────────────────────────────── */
-const esc = s => String(s ?? "").replace(/[&<>"']/g,
-  c => ({"&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;"}[c]));
-
-const fmt$ = v => v == null ? "—" : Number(v).toLocaleString("en-US",
-  { minimumFractionDigits: 2, maximumFractionDigits: 2 });
-
-const sigClass = s => s?.includes("BUY") ? "buy" : s?.includes("SELL") ? "sell" : "neutral";
-const sigLabel = s => (s || "NEUTRAL").replace("_", " ");
-const nowServer = () => Date.now() / 1000 + clockOffset;
-
-function localGet(key) {
-  try { return window.localStorage.getItem(key); } catch { return null; }
-}
-
-function localSet(key, value) {
-  try { window.localStorage.setItem(key, value); } catch { /* storage is optional */ }
-}
-
-function announce(message) {
-  const live = $("dashboard-live");
-  if (live) live.textContent = message;
-}
-
-function fmtCountdown(secs) {
-  if (secs == null || !isFinite(secs)) return "--:--";
-  secs = Math.max(0, Math.floor(secs));
-  const h = Math.floor(secs / 3600), m = Math.floor((secs % 3600) / 60), s = secs % 60;
-  const mm = String(m).padStart(2, "0"), ss = String(s).padStart(2, "0");
-  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`;
-}
-
-function fmtAge(iso) {
-  if (!iso) return "";
-  const secs = nowServer() - Date.parse(iso) / 1000;
-  if (secs < 90) return `${Math.max(0, Math.round(secs))}s ago`;
-  if (secs < 5400) return `${Math.round(secs / 60)}m ago`;
-  if (secs < 172800) return `${Math.round(secs / 3600)}h ago`;
-  return `${Math.round(secs / 86400)}d ago`;
-}
-
-const signed = (v, dp = 2) => v == null ? "—" : (v >= 0 ? "+" : "") + Number(v).toFixed(dp);
-const badgeCls = s => s === "buy" ? "bg-success-subtle text-success-emphasis border-success-subtle"
-                 : s === "sell" ? "bg-danger-subtle text-danger-emphasis border-danger-subtle"
-                 : "bg-secondary-subtle text-secondary-emphasis border-secondary-subtle";
-
-/* ── theme ────────────────────────────────────────────────────── */
-// Dark theme is forced site-wide (owner decision 2026-08-16): dark
-// background, pure-white text, red/green data accents.
-document.documentElement.setAttribute("data-bs-theme", "dark");
-
-/* ── hero ─────────────────────────────────────────────────────── */
-function renderHero() {
-  if (!snapshot) return;
-  let price = null;
-  for (const tf of TF_ORDER) {
-    const p = snapshot.timeframes[tf]?.report?.current_price;
-    if (p) { price = p; break; }
-  }
-  $("hero-price").textContent = price ? fmt$(price) : "—";
-
-  $("hero-rail").innerHTML = TF_ORDER.map(tf => {
-    const r = snapshot.timeframes[tf]?.report;
-    const sig = r?.signal || null;
-    const cls = sigClass(sig);
-    const arrow = sig ? (ARROW[sig] || "→") : "·";
-    const score = r?.score != null ? r.score.toFixed(0) : "–";
-    const textColor = cls === "buy" ? "text-success" : cls === "sell" ? "text-danger" : "text-secondary";
-    return `<button type="button" class="rail-chip" data-select-tf="${tf}"
-      aria-current="${tf === selectedTf ? "true" : "false"}"
-      title="${esc(sigLabel(sig))} (score ${esc(score)}) — select ${TF_LABEL[tf]} workspace">
-      <span class="tf-name">${TF_LABEL[tf]}</span>
-      <span class="${textColor} fw-bold">${arrow}</span>
-      <span>${esc(score)}</span>
-    </button>`;
-  }).join("");
-
-  const closed = snapshot.market_closed;
-  $("hero-status").innerHTML =
-    `<span class="live-dot${closed ? " closed" : ""}"></span>${closed ? "CLOSED" : "OPEN"}`;
-  $("banner-closed").classList.toggle("d-none", !closed);
-}
-
-/* ── market context strip ─────────────────────────────────────── */
-function renderContext() {
-  if (!news) return;
-  $("context").classList.remove("d-none");
-  $("ctx-blurb").innerHTML = news.llm_summary
-    ? `<strong>Market context:</strong> ${esc(news.llm_summary)}`
-    : `<strong>Market context:</strong> <span class="text-secondary">no summary available</span>`;
-
-  let chips = "";
-  for (const cur of ["XAU", "USD"]) {
-    const v = news.sentiment?.[cur];
-    if (v == null) continue;
-    const cls = v > 0.05 ? "text-bg-success" : v < -0.05 ? "text-bg-danger" : "text-bg-secondary";
-    chips += `<span class="badge ${cls}" title="Mean headline sentiment for ${cur} (−1…+1)">
-      ${cur} news <span class="num">${v >= 0 ? "+" : ""}${v.toFixed(2)}</span></span>`;
-  }
-  let risk = "clear", riskDesc = "No significant events";
-  if (snapshot) {
-    for (const tf of TF_ORDER) {
-      const r = snapshot.timeframes[tf]?.report;
-      if (r?.event_risk && r.event_risk !== "clear") { risk = r.event_risk; riskDesc = r.event_description; break; }
-      if (r?.event_description) riskDesc = r.event_description;
-    }
-  }
-  if (news.high_impact_warning) { risk = "danger"; riskDesc = news.warning_message || riskDesc; }
-  const riskCls = risk === "clear" ? "text-bg-success"
-                : risk === "danger" ? "text-bg-danger"
-                : "text-bg-warning";
-  chips += `<span class="badge ${riskCls}" title="${esc(riskDesc)}">event risk: ${risk.toUpperCase()}</span>`;
-  $("ctx-chips").innerHTML = chips;
-}
-
-/* ── timeframe cards ──────────────────────────────────────────── */
-function scoreBar(label, score) {
-  const v = Math.max(-100, Math.min(100, score ?? 0));
-  const width = (Math.abs(v) / 2).toFixed(1);
-  return `<div class="scorebar">
-    <span class="lbl">${label}</span>
-    <div class="gauge-container" aria-hidden="true">
-      <i class="fill ${v >= 0 ? "pos" : "neg"}" style="--score-width:${width}%"></i>
-    </div>
-    <span class="val num ${v > 0 ? "text-success" : v < 0 ? "text-danger" : ""}">${v >= 0 ? "+" : ""}${v.toFixed(1)}</span>
-  </div>`;
-}
-
-function setupCard(ts) {
-  if (!ts) return "";
-  const dir = ts.direction === "BUY" ? "buy" : "sell";
-  const dirIcon = ts.direction === "BUY" ? "bi-arrow-up-circle-fill" : "bi-arrow-down-circle-fill";
-  const trail = (ts.trail_arm_r != null && ts.trail_dist_r != null)
-    ? `arm ${ts.trail_arm_r}R · dist ${ts.trail_dist_r}R` : "platform default";
-  return `<div class="card border-signal sig-${dir} bg-body-tertiary">
-    <div class="card-body py-2 px-3">
-      <div class="d-flex align-items-baseline gap-2 mb-2">
-        <span class="fw-bold text-signal sig-${dir}"><i class="bi ${dirIcon} me-1"></i>${ts.direction}</span>
-        <span class="small text-secondary font-monospace">${esc(ts.strategy || "")}</span>
-        <span class="small text-secondary ms-auto font-monospace">R:R ${(+ts.risk_reward).toFixed(1)}</span>
-      </div>
-      <div class="table-responsive"><table class="table table-sm table-borderless mb-0">
-        <tbody><tr><td class="text-secondary"><i class="bi bi-box-arrow-in-right me-1"></i>Entry</td><td class="num">${fmt$(ts.entry)}</td>
-            <td class="text-secondary ps-4"><i class="bi bi-flag-fill me-1 text-success"></i>TP1</td><td class="num text-success">${fmt$(ts.take_profit_1)}</td></tr>
-        <tr><td class="text-secondary"><i class="bi bi-shield-x me-1 text-danger"></i>Stop</td><td class="num text-danger">${fmt$(ts.stop_loss)}</td>
-            <td class="text-secondary ps-4"><i class="bi bi-flag-fill me-1 text-success"></i>TP2</td><td class="num text-success">${fmt$(ts.take_profit_2)}</td></tr>
-        <tr><td class="text-secondary"><i class="bi bi-signpost-split me-1"></i>Trail</td><td class="num" colspan="3">${esc(trail)}</td></tr></tbody>
-      </table></div>
-    </div>
-  </div>`;
-}
-
-function workspacePanel(tf) {
-  const entry = snapshot?.timeframes?.[tf] || {};
-  const r = entry.report;
-  if (!r) {
-    return `<article class="card workspace-card border-signal sig-neutral" id="workspace-panel" aria-labelledby="workspace-panel-heading">
-      <div class="card-body py-4 text-center text-secondary">
-        <h3 class="tf-name mb-2" id="workspace-panel-heading">${TF_LABEL[tf]}</h3>
-        ${entry.status === "error"
-          ? `<span class="badge text-bg-danger">SCAN UNAVAILABLE</span><div class="small mt-2">Showing again when the next scan succeeds.</div>`
-          : "Warming up — no completed scan for this timeframe yet."}
-      </div>
-    </article>`;
-  }
-
-  const cls = sigClass(r.signal);
-  const textCls = cls === "buy" ? "text-success" : cls === "sell" ? "text-danger" : "text-secondary";
-  const qHi = r.quality === "A+" || r.quality === "A";
-  const pa = r.primary_analysis;
-  const meta = [r.market_regime, r.volatility_regime && r.volatility_regime + " volatility",
-    r.mtf_agreement ? "MTF aligned" : "MTF mixed"].filter(Boolean).join(" · ");
-  const facts = `<div class="row row-cols-2 row-cols-md-4 g-2 mt-1">
-    ${tile("Confidence", r.confidence != null ? Math.round(r.confidence) + "%" : "—")}
-    ${tile("Quality", esc(r.quality || "—"), qHi ? "text-primary" : "")}
-    ${tile("Event risk", esc((r.event_risk || "—").toUpperCase()), r.event_risk === "clear" ? "text-success" : r.event_risk ? "text-warning" : "")}
-    ${tile("MTF", r.mtf_agreement ? "aligned" : "mixed", r.mtf_agreement ? "text-success" : "")}
-  </div>`;
-  const setup = r.trade_setup
-    ? setupCard(r.trade_setup)
-    : `<div class="text-secondary small">No setup published. The signal has not cleared its setup gate.</div>`;
-  return `<article class="card workspace-card border-signal sig-${cls}" id="workspace-panel" aria-labelledby="workspace-panel-heading">
-    <div class="card-body p-3 p-lg-4">
-      <div class="row g-4">
-        <div class="col-lg-7 workspace-meta">
-          <div class="d-flex justify-content-between align-items-start gap-3 flex-wrap mb-3">
-            <div>
-              <div class="d-flex align-items-center gap-2 flex-wrap mb-2">
-                <h3 class="tf-name mb-0" id="workspace-panel-heading">${TF_LABEL[tf]} signal</h3>
-                <span class="badge ${badgeCls(cls)}">${esc(sigLabel(r.signal))}</span>
-                ${r.quality ? `<span class="badge ${qHi ? "text-bg-primary" : "text-bg-secondary"}">quality ${esc(r.quality)}</span>` : ""}
-                ${entry.status === "error" ? `<span class="badge text-bg-danger">STALE</span>` : ""}
-              </div>
-              <div class="workspace-signal ${textCls}">${esc(r.action || sigLabel(r.signal))}</div>
-            </div>
-            <button type="button" class="btn btn-sm btn-outline-primary" data-open-detail="${tf}">
-              Full analysis <i class="bi bi-arrow-up-right ms-1"></i>
-            </button>
-          </div>
-          ${scoreBar("score", pa ? pa.composite_score : r.score)}
-          <div class="small text-secondary mt-2">${esc(meta)}</div>
-          ${facts}
-          <div class="workspace-reasons mt-3 pt-3 border-top">${listBlock(r) || "<div class=\"small text-secondary\">No supporting reasons recorded on this scan.</div>"}</div>
-          <div class="small text-secondary mt-3">${entry.scanned_at ? "scanned " + fmtAge(entry.scanned_at) : ""} · closes in <span class="num" data-close="${entry.next_close_epoch || ""}" data-interval="${TF_SECONDS[tf]}">--:--</span></div>
-        </div>
-        <div class="col-lg-5">
-          <div class="small text-uppercase text-secondary fw-bold mb-2">Trade plan</div>
-          ${setup}
-        </div>
-      </div>
-    </div>
-  </article>`;
-}
-
-function renderCards() {
-  if (!snapshot) return;
-  if (!TF_LABEL[selectedTf]) selectedTf = "5min";
-  const selector = TF_ORDER.map(tf => {
-    const entry = snapshot.timeframes[tf] || {};
-    const r = entry.report;
-    const cls = r ? sigClass(r.signal) : "neutral";
-    const arrow = r ? (ARROW[r.signal] || "→") : "·";
-    const score = r?.score != null ? signed(r.score, 0) : "—";
-    const signal = r ? sigLabel(r.signal) : entry.status === "error" ? "UNAVAILABLE" : "WARMING";
-    return `<button type="button" class="tf-select" data-select-tf="${tf}" aria-pressed="${tf === selectedTf}">
-      <span class="d-flex align-items-center justify-content-between gap-2">
-        <span class="tf-name">${TF_LABEL[tf]}</span>
-        <span class="${cls === "buy" ? "text-success" : cls === "sell" ? "text-danger" : "text-secondary"} fw-bold">${arrow}</span>
-      </span>
-      <span class="small ${cls === "buy" ? "text-success" : cls === "sell" ? "text-danger" : "text-secondary"}">${esc(signal)}</span>
-      <span class="small num float-end">${esc(score)}</span>
-    </button>`;
-  }).join("");
-  $("tf-grid").innerHTML = `<div class="tf-selector">${selector}</div>${workspacePanel(selectedTf)}`;
-  tick();
-}
-
-/* ── timeframe detail dialog ──────────────────────────────────── */
-const tile = (k, v, cls = "") =>
-  `<div class="col"><div class="card d-stat bg-body-tertiary h-100"><div class="card-body p-2">
-    <span class="k">${esc(k)}</span>
-    <span class="v ${cls}">${v}</span>
-  </div></div></div>`;
-
-const SEC_ICON = {
-  "At a glance": "bi-speedometer2",
-  "Trade setup": "bi-bullseye",
-  "Why this signal": "bi-lightbulb",
-  "Multi-timeframe confirmation": "bi-layers",
-  "News context": "bi-newspaper",
-  "AI panel (advisory)": "bi-robot",
-  "Scan detail": "bi-clock-history",
-  "Score": "bi-graph-up",
-  "From the source": "bi-quote",
-  "AI gold-impact summary": "bi-stars",
-  "Timing": "bi-alarm",
-  "Numbers": "bi-calculator"
-};
-const sec = (title, html) => {
-  if (!html) return "";
-  const icon = SEC_ICON[title];
-  return `<section class="mb-4"><h6 class="text-uppercase text-secondary small fw-bold mb-2 d-flex align-items-center gap-2">${icon ? `<i class="bi ${icon} text-primary"></i>` : ""}<span>${esc(title)}</span><span class="flex-fill border-bottom"></span></h6>${html}</section>`;
-};
-
-function indTable(src) {
-  const rows = IND_ORDER.map(name => {
-    const i = src?.[name];
-    const k = `<td class="ind-k">${IND_SHORT[name]}</td>`;
-    if (!i) return `<tr>${k}<td class="text-secondary">— absent</td>
-      <td class="num text-end">—</td><td class="num text-end">—</td><td class="num text-end">—</td>
-      <td class="text-secondary small">no signal this scan</td></tr>`;
-    const w = i.weight == null ? null : +i.weight;
-    return `<tr>${k}
-      <td class="fw-bold ${sigClass(i.signal) === "buy" ? "text-success" : sigClass(i.signal) === "sell" ? "text-danger" : "text-secondary"}">${esc(sigLabel(i.signal))}</td>
-      <td class="num text-end">${i.value != null ? (+i.value).toFixed(2) : "—"}</td>
-      <td class="num text-end">${i.confidence != null ? Math.round(i.confidence) : "—"}</td>
-      <td class="num text-end">${w != null ? w.toFixed(1) : "—"}${w != null
-        ? `<i class="wbar"><i style="width:${Math.min(100, w / 2 * 100)}%"></i></i>` : ""}</td>
-      <td class="text-secondary small">${esc(i.description || "")}</td></tr>`;
-  }).join("");
-  return `<div class="detail-table"><table class="table table-sm d-table"><thead><tr>
-    <th>Indicator</th><th>Signal</th><th class="text-end">Value</th><th class="text-end">Conf</th>
-    <th class="text-end">Weight</th><th>Reading</th></tr></thead><tbody>${rows}</tbody></table></div>`;
-}
-
-function ladder(levels, price) {
-  if (!levels) return "";
-  const atr = levels.atr;
-  const rows = Object.keys(LEVEL_LABEL)
-    .filter(k => levels[k] != null)
-    .map(k => ({ label: LEVEL_LABEL[k], v: +levels[k] }));
-  if (!rows.length) return "";
-  if (price != null) rows.push({ here: true, v: +price });
-  rows.sort((a, b) => b.v - a.v);
-  const body = rows.map(row => {
-    if (row.here) return `<tr class="table-primary fw-bold"><td><i class="bi bi-geo-alt-fill me-1"></i>current price</td>
-      <td class="num text-end">${fmt$(row.v)}</td><td class="num text-end">—</td><td class="small text-secondary">spot</td></tr>`;
-    const d = price != null ? row.v - price : null;
-    const cls = d == null ? "" : d > 0 ? "text-danger" : "text-success";
-    const icon = d == null ? "" : d > 0 ? "bi-arrow-up-short" : "bi-arrow-down-short";
-    return `<tr>
-      <td class="text-secondary">${esc(row.label)}</td>
-      <td class="num text-end ${cls}">${fmt$(row.v)}</td>
-      <td class="num text-end ${cls}">${d == null ? "" : signed(d) + (atr ? ` · ${signed(d / atr, 2)} ATR` : "")}</td>
-      <td class="small ${cls}">${d == null ? "" : `<i class="bi ${icon}"></i>${d > 0 ? "resistance" : "support"}`}</td></tr>`;
-  }).join("");
-  return `<div class="detail-table"><table class="table table-sm ladder"><thead><tr><th>Level</th><th class="text-end">Price</th>
-    <th class="text-end">vs. spot</th><th>Role</th></tr></thead><tbody>${body}</tbody></table></div>`;
-}
-
-function analysisBlock(a, price) {
-  if (!a) return "";
-  const pats = a.pattern_signals?.length
-    ? `<div class="d-flex flex-wrap gap-1 mb-2">${a.pattern_signals.map(p =>
-        `<span class="badge text-bg-primary bg-opacity-10">${esc(p)}</span>`).join("")}</div>` : "";
-  const atr = a.atr_context
-    ? `<div class="small text-secondary mb-2">${esc(a.atr_context.description ||
-        "ATR " + (+a.atr_context.value).toFixed(2))}</div>` : "";
-  const lv = ladder(a.key_levels, price);
-  return indTable(a.indicators) + atr + pats +
-    (lv ? `<div class="small text-secondary fw-semibold mt-2 mb-1">Key levels</div>${lv}` : "");
-}
-
-function listBlock(r) {
-  const group = (title, arr, cls, icon) => arr?.length
-    ? `<div class="small text-secondary fw-semibold mt-2 mb-1">${title} (${arr.length})</div>
-       <div class="small">${arr.map(t => `<div class="${cls}"><i class="bi ${icon} me-1"></i>${esc(t)}</div>`).join("")}</div>` : "";
-  return group("Warnings", r.warnings, "text-warning", "bi-exclamation-triangle-fill")
-       + group("Bullish", r.bullish_reasons, "text-success", "bi-arrow-up-circle-fill")
-       + group("Bearish", r.bearish_reasons, "text-danger", "bi-arrow-down-circle-fill");
-}
-
-function detailHTML(tf) {
-  const entry = snapshot?.timeframes?.[tf] || {};
-  const r = entry.report;
-  if (!r) return `<div class="text-center text-secondary py-4">${entry.status === "error"
-    ? `Scan error — ${esc(entry.error || "unknown")}`
-    : "Warming up — no completed scan for this timeframe yet."}</div>`;
-
-  const pa = r.primary_analysis;
-  const price = r.current_price;
-  const cls = sigClass(r.signal);
-  const textCls = cls === "buy" ? "text-success" : cls === "sell" ? "text-danger" : "text-secondary";
-  const borderCls = cls === "buy" ? "border-start border-success border-4"
-                  : cls === "sell" ? "border-start border-danger border-4"
-                  : "border-start border-secondary border-4";
-
-  let out = `<div class="card ${borderCls} mb-3"><div class="card-body">
-    <div class="fw-bold fs-5 ${textCls}">${esc(r.action || sigLabel(r.signal))}</div>
-    ${r.news_description || r.event_description
-      ? `<div class="small text-secondary">${esc([r.event_description, r.news_description].filter(Boolean).join(" · "))}</div>`
-      : ""}
-  </div></div>`;
-
-  const ns = r.news_sentiment;
-  out += sec("At a glance", `<div class="row row-cols-2 row-cols-md-3 row-cols-lg-4 g-2">
-    ${tile("Signal", esc(sigLabel(r.signal)), textCls)}
-    ${tile("Score", signed(r.score, 1), textCls)}
-    ${tile("Confidence", r.confidence != null ? Math.round(r.confidence) + "%" : "—")}
-    ${tile("Quality", esc(r.quality || "—"))}
-    ${tile("Regime", esc(r.market_regime || "—"))}
-    ${tile("Volatility", esc(r.volatility_regime || "—"))}
-    ${tile("Event risk", esc((r.event_risk || "—").toUpperCase()),
-        r.event_risk === "clear" ? "text-success" : r.event_risk ? "text-warning" : "")}
-    ${tile("News sentiment", ns != null ? signed(ns, 2) : "—",
-        ns > 0.05 ? "text-success" : ns < -0.05 ? "text-danger" : "")}
-    ${tile("MTF", r.mtf_agreement ? "aligned" : "mixed", r.mtf_agreement ? "text-success" : "")}
-    ${tile("Primary score", signed(r.primary_score, 1), sigClass(r.primary_signal) === "buy" ? "text-success" : sigClass(r.primary_signal) === "sell" ? "text-danger" : "")}
-    ${tile("Exhaustion", esc(r.exhaustion_count ?? "—"), r.exhaustion_count ? "text-warning" : "")}
-  </div>`);
-
-  out += sec("Trade setup", r.trade_setup
-    ? setupCard(r.trade_setup)
-    : `<div class="text-secondary small">No setup published for this timeframe — the engine only emits entry/stop/target once a signal clears its quality gate.</div>`);
-
-  out += sec("Why this signal", listBlock(r) || `<div class="text-secondary small">No reasons recorded on this scan.</div>`);
-
-  out += sec(`${TF_LABEL[tf]} indicators (primary)`,
-    analysisBlock(pa, price) || indTable(r.indicators) +
-      (r.key_levels ? `<div class="small text-secondary fw-semibold mt-2 mb-1">Key levels</div>${ladder(r.key_levels, price)}` : ""));
-
-  const mtf = Object.entries(r.mtf_signals || {});
-  if (mtf.length) {
-    const chips = mtf.map(([k, sig]) => {
-      const s = r.mtf_scores?.[k];
-      const sc = sigClass(sig);
-      return `<span class="badge ${badgeCls(sc)}">${esc(TF_LABEL[k] || k)}
-        <span class="${sc === "buy" ? "text-success" : sc === "sell" ? "text-danger" : "text-secondary"}">${esc(sigLabel(sig))}</span>
-        <span class="num">${s != null ? signed(s, 1) : ""}</span></span>`;
-    }).join("");
-    const confs = (r.confirmation_analyses || []).filter(Boolean).map(a => {
-      const lbl = TF_LABEL[a.timeframe] || a.timeframe;
-      const sc = sigClass(a.composite_signal);
-      return `<details data-dkey="conf-${esc(a.timeframe)}">
-        <summary><strong>${esc(lbl)}</strong>
-          <span class="${sc === "buy" ? "text-success" : sc === "sell" ? "text-danger" : "text-secondary"} fw-bold">${esc(sigLabel(a.composite_signal))}</span>
-          <span class="text-secondary small">${signed(a.composite_score, 1)} · conf ${a.confidence != null ? Math.round(a.confidence) : "—"} · ${esc(a.market_regime || "")}</span></summary>
-        ${analysisBlock(a, price)}</details>`;
-    }).join("");
-    out += sec("Multi-timeframe confirmation",
-      `<div class="d-flex flex-wrap gap-2 align-items-center mb-2">${chips}
-        <span class="fw-bold ${r.mtf_agreement ? "text-success" : "text-secondary"}">${r.mtf_agreement ? "✓ aligned" : "✗ mixed"}</span></div>${confs}`);
-  }
-
-  if (r.news_summary || r.news_description) {
-    out += sec("News context", `<div class="text-secondary small">
-      ${r.news_description ? `<strong>${esc(r.news_description)}</strong>${ns != null ? ` (${signed(ns, 2)})` : ""}<br>` : ""}
-      ${esc(r.news_summary || "")}</div>`);
-  }
-
-  if (r.panel_verdict) {
-    const vcls = r.panel_verdict === "AGREE" ? "text-success"
-      : r.panel_verdict === "OPPOSE" ? "text-danger" : "text-secondary";
-    const takes = (r.panel_takes || []).map(t =>
-      `<tr><td class="ind-k">${esc(t.persona)}</td>
-        <td>${esc(t.stance)}</td>
-        <td class="num text-end">${t.confidence != null ? Math.round(t.confidence) : "—"}</td>
-        <td class="small text-secondary">${esc(t.note || "")}</td></tr>`).join("");
-    out += sec("AI panel (advisory)", `<div class="text-secondary small mb-2">
-      <strong class="${vcls}">${esc(r.panel_verdict)}</strong> ·
-      conf ${Math.round(r.panel_confidence || 0)}%<br>
-      ${esc(r.panel_rationale || "")}</div>
-      ${takes ? `<div class="detail-table"><table class="table table-sm d-table"><tbody>${takes}</tbody></table></div>` : ""}`);
-  }
-
-  out += sec("Scan detail", `<div class="detail-table"><table class="table table-sm d-table"><tbody>
-    <tr><td class="ind-k">Instrument</td><td colspan="5">${esc(r.display_name || r.symbol || "—")}</td></tr>
-    <tr><td class="ind-k">Candle</td><td colspan="5" class="num">${esc(r.timestamp || "—")}</td></tr>
-    <tr><td class="ind-k">Scanned</td><td colspan="5">${esc(entry.scanned_at || "—")}
-      (${fmtAge(entry.scanned_at)}${entry.scan_seconds ? `, took ${entry.scan_seconds}s` : ""})</td></tr>
-    <tr><td class="ind-k">Status</td><td colspan="5">${esc(entry.status || "—")}${entry.error
-      ? ` — <span class="text-danger">${esc(entry.error)}</span>
-          ${entry.error_at ? `(${fmtAge(entry.error_at)})` : ""}` : ""}</td></tr>
-   </tbody></table></div>`);
-  return out;
-}
-
-function renderDetail() {
-  if (!detailTf || !tfModalOpen) return;
-  const entry = snapshot?.timeframes?.[detailTf] || {};
-  const r = entry.report;
-  const openKeys = new Set([...document.querySelectorAll("#detail-body details[open][data-dkey]")]
-    .map(d => d.dataset.dkey));
-  const scroll = $("detail-body").scrollTop;
-
-  $("detail-title").textContent = TF_LABEL[detailTf] || detailTf;
-  $("detail-price").textContent = r?.current_price ? fmt$(r.current_price) : "—";
-  $("detail-sub").innerHTML = `${snapshot?.symbol ? esc(snapshot.symbol) + " · " : ""}closes in
-    <span class="num" data-close="${entry.next_close_epoch || ""}" data-interval="${TF_SECONDS[detailTf]}">--:--</span>`;
-  $("detail-body").innerHTML = detailHTML(detailTf);
-
-  document.querySelectorAll("#detail-body details[data-dkey]").forEach(d => {
-    if (openKeys.has(d.dataset.dkey)) d.open = true;
-  });
-  $("detail-body").scrollTop = scroll;
-  tick();
-}
-
-function openDetail(tf) {
-  if (!TF_LABEL[tf]) return;
-  detailTf = tf;
-  tfModal.show();
-  renderDetail();
-  $("detail-body").scrollTop = 0;
-  $("detail-close").focus();
-}
-
-$("detail-close")?.addEventListener("click", () => tfModal.hide());
-
-/* ── calendar ─────────────────────────────────────────────────── */
-function renderCalendar() {
-  const body = $("cal-body");
-  if (!news) return;
-  const zone = Intl.DateTimeFormat().resolvedOptions().timeZone || "local time";
-  $("calendar-note").textContent = `times local (${zone}) · USD events${news.generated_at ? " · updated " + fmtAge(news.generated_at) : ""}`;
-  const hiOnly = $("hi-only").checked;
-  let events = (news.events || []);
-  if (hiOnly) events = events.filter(e => e.impact === "high");
-  if (!events.length) {
-    body.innerHTML = `<tr><td colspan="7" class="text-secondary text-center py-3">${
-      news.calendar_available ? "No matching events this week." : "Calendar unavailable — source could not be reached."}</td></tr>`;
-    return;
-  }
-  const now = nowServer();
-  let nextUpMarked = false, lastDay = "", rows = "";
-  for (const e of events) {
-    const t = Date.parse(e.time) / 1000;
-    const d = new Date(t * 1000);
-    const day = d.toLocaleDateString(undefined, { weekday: "short", month: "short", day: "numeric" });
-    if (day !== lastDay) {
-      rows += `<tr class="table-group-divider"><td colspan="7" class="text-primary small fw-bold text-uppercase">${esc(day)}</td></tr>`;
-      lastDay = day;
-    }
-    const past = t < now;
-    const nextUp = !past && !nextUpMarked && (nextUpMarked = true);
-    const time = d.toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" });
-    const surp = e.surprise
-      ? `<span class="${e.surprise === "positive" ? "text-success" : e.surprise === "negative" ? "text-danger" : "text-secondary"}" title="actual ${e.surprise === "positive" ? "above" : e.surprise === "negative" ? "below" : "matches"} forecast (numeric only — not gold direction)">${e.surprise === "positive" ? "▲" : e.surprise === "negative" ? "▼" : "="}</span>` : "";
-    rows += `<tr class="${past ? "text-secondary" : ""}${nextUp ? " cal-next-up" : ""}">
-      <td class="num text-nowrap">${esc(time)}</td>
-      <td class="text-secondary">${esc(e.currency)}</td>
-      <td><span class="badge ${e.impact === "high" ? "text-bg-danger" : e.impact === "medium" ? "text-bg-warning" : "text-bg-secondary"}">${e.impact === "medium" ? "Med" : e.impact.charAt(0).toUpperCase() + e.impact.slice(1)}</span></td>
-      <td><button type="button" class="cal-event" data-ev-key="${esc(evKey(e))}" aria-haspopup="dialog">${esc(e.event)}</button></td>
-      <td class="num text-end">${esc(e.forecast ?? "—")}</td>
-      <td class="num text-end">${esc(e.previous ?? "—")}</td>
-      <td class="num text-end">${esc(e.actual ?? "—")} ${surp}</td></tr>`;
-  }
-  body.innerHTML = rows;
-}
-
-/* ── newswire ─────────────────────────────────────────────────── */
-function renderWireTotal() {
-  const box = $("wire-total");
-  const scored = (news?.headlines || []).filter(h => typeof h.score === "number");
-  if (!scored.length) { box.classList.add("d-none"); return; }
-  box.classList.remove("d-none");
-
-  const sum = scored.reduce((a, h) => a + h.score, 0);
-  const mean = sum / scored.length;
-  const up = scored.filter(h => h.score > 0.05).length;
-  const dn = scored.filter(h => h.score < -0.05).length;
-  const cls = mean > 0.05 ? "text-success" : mean < -0.05 ? "text-danger" : "text-secondary";
-  const dir = mean > 0.05 ? "BULLISH" : mean < -0.05 ? "BEARISH" : "NEUTRAL";
-  const wrapCls = mean > 0.05 ? "bg-success-subtle border-success-subtle"
-                : mean < -0.05 ? "bg-danger-subtle border-danger-subtle"
-                : "bg-body-tertiary";
-
-  box.className = `card mb-3 ${wrapCls}`;
-  box.innerHTML = `<div class="card-body p-2">
-    <div class="d-flex align-items-baseline gap-2 flex-wrap">
-      <span class="small text-secondary text-uppercase fw-bold">Total news score</span>
-      <span class="display-6 fw-bold ${cls}">${signed(mean, 2)}</span>
-      <span class="fw-bold ${cls}">${dir}</span>
-      <span class="ms-auto text-end small text-secondary">${scored.length} headlines · sum ${signed(sum, 1)}<br>
-        ${up} bullish · ${dn} bearish</span>
-    </div>
-  </div>`;
-  box.title = `Mean sentiment of all ${scored.length} scored headlines (−1…+1). Sum ${signed(sum, 1)}. Only headlines from the last 4 hours that lean one way are published (neutral ones are removed before scoring).`;
-}
-
-function renderWire() {
-  if (!news) return;
-  const items = (news.headlines || []).slice(0, 40);
-  $("wire-note").textContent = news.generated_at ? `updated ${fmtAge(news.generated_at)}` : "";
-  renderWireTotal();
-  if (!items.length) {
-    $("wire").innerHTML = `<div class="text-secondary small py-2">No gold or dollar headlines in the last 4 hours.</div>`;
-    return;
-  }
-  const item = h => {
-    const s = h.score;
-    const cls = s == null || Math.abs(s) < 0.05 ? "zero" : s > 0 ? "pos" : "neg";
-    const scoreCls = cls === "pos" ? "bg-success-subtle text-success"
-                   : cls === "neg" ? "bg-danger-subtle text-danger"
-                   : "bg-body-tertiary text-secondary";
-    const scoreTxt = s == null ? "·" : (s > 0 ? "+" : "") + s.toFixed(1);
-    let host = "";
-    try { host = new URL(h.source).hostname.replace(/^www\./, ""); } catch {}
-    const content = `<span class="wire-score ${scoreCls}" title="Headline sentiment ${esc(String(s ?? "n/a"))} (−1…+1)${h.currencies?.length ? " · " + esc(h.currencies.join(", ")) : ""}">${scoreTxt}</span>
-       <span class="small text-secondary flex-fill">${esc(h.headline)}</span>
-       <span class="small text-secondary text-nowrap">${esc(h.publisher || host)}${h.timestamp ? " · " + fmtAge(h.timestamp) : ""}</span>`;
-    if (!h.id) return `<div class="wire-item gap-2 align-items-baseline py-1 px-1">${content}</div>`;
-    return `<button type="button" class="wire-item gap-2 align-items-baseline py-1 px-1" data-news-id="${h.id}" aria-haspopup="dialog">
-      ${content}
-    </button>`;
-  };
-  const head = items.slice(0, 12).map(item).join("");
-  const rest = items.slice(12);
-  const moreOpen = $("wire")?.querySelector("details.more")?.open ?? false;
-  $("wire").innerHTML = head + (rest.length
-    ? `<details class="more mt-1"${moreOpen ? " open" : ""}><summary class="small text-secondary">${rest.length} more headlines…</summary>
-       <div class="mt-1">${rest.map(item).join("")}</div></details>` : "");
-}
-
-/* ── news / calendar detail dialog ────────────────────────────── */
-const evKey = e => `${e.time}|${e.currency}|${e.event}`;
-const findHeadline = id => (news?.headlines || []).find(h => h.id === id);
-const findEvent = key => (news?.events || []).find(e => evKey(e) === key);
-
-const AI_ERR_MSG = {
-  unknown_id: "This headline has left the live feed — no summary available.",
-  cap_exceeded: "Daily AI budget reached — try again tomorrow.",
-  no_key: "AI summaries are not configured on this server."
-};
-
-async function fetchAiSummary(id) {
-  aiPending.add(id);
-  try {
-    const res = await fetch("news_summary.php?id=" + encodeURIComponent(id));
-    const data = await res.json().catch(() => null);
-    if (res.ok && data?.summary) aiMemo.set(id, data);
-    else aiErr.set(id, data?.error || `http_${res.status}`);
-  } catch {
-    aiErr.set(id, "network");
-  } finally {
-    aiPending.delete(id);
-    if (ndState?.kind === "wire" && ndState.id === id) renderNewsDlg();
-  }
-}
-
-function scoreTiles(h) {
-  const cls = v => v > 0.05 ? "text-success" : v < -0.05 ? "text-danger" : "text-secondary";
-  let tiles = tile("Overall sentiment", signed(h.score, 2), cls(h.score));
-  const xau = h.score_by_currency?.XAU;
-  if (xau != null) tiles += tile("Gold (XAU) effect", signed(xau, 2), cls(xau));
-  for (const [cur, v] of Object.entries(h.score_by_currency || {})) {
-    if (cur !== "XAU") tiles += tile(cur, signed(v, 2), cls(v));
-  }
-  let out = `<div class="row row-cols-2 row-cols-md-3 g-2">${tiles}</div>`;
-  if (h.keywords?.length) {
-    out += `<div class="small text-secondary mt-2">Matched keywords: ${esc(h.keywords.join(", "))}</div>`;
-  }
-  out += `<div class="small text-secondary">Scores range −1 (bearish) to +1 (bullish); the gold score flips monetary-policy keywords (hawkish = dollar-bullish, gold-bearish).</div>`;
-  return out;
-}
-
-function aiSection(id) {
-  if (aiMemo.has(id)) {
-    const m = aiMemo.get(id);
-    return `<div class="text-secondary small">${esc(m.summary)}</div>` + (m.generated_at
-      ? `<div class="small text-secondary">generated ${fmtAge(m.generated_at)}</div>` : "");
-  }
-  if (aiPending.has(id)) return `<div class="text-secondary small">Generating gold-impact summary…</div>`;
-  if (aiErr.has(id)) {
-    return `<div class="text-secondary small">${esc(AI_ERR_MSG[aiErr.get(id)] || "AI summary unavailable right now.")}</div>`;
-  }
-  return `<div class="text-secondary small">Generating gold-impact summary…</div>`;
-}
-
-function wireDlgHTML() {
-  const fresh = findHeadline(ndState.id);
-  const h = fresh || ndState.snap;
-  if (!h) return "";
-  let host = "";
-  try { host = new URL(h.source).hostname.replace(/^www\./, ""); } catch {}
-  const when = h.timestamp
-    ? `${new Date(h.timestamp).toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" })} · ${fmtAge(h.timestamp)}` : "";
-  let out = `<div class="fs-5 fw-semibold mb-1">${esc(h.headline)}</div>
-    <div class="small text-secondary mb-3">${esc(h.publisher || host)}${when ? " · " + when : ""}</div>`;
-  if (!fresh) out += `<div class="small text-secondary mb-2">No longer in the live feed — showing saved copy.</div>`;
-  out += sec("Score", scoreTiles(h));
-  if (h.description) out += sec("From the source", `<div class="text-secondary small">${esc(h.description)}</div>`);
-  out += sec("AI gold-impact summary", aiSection(ndState.id));
-  if (h.link && /^https?:\/\//.test(h.link)) {
-    out += `<a class="btn btn-outline-primary" href="${esc(h.link)}" target="_blank" rel="noopener noreferrer">Read full article ↗</a>`;
-  }
-  return out;
-}
-
-function calDlgHTML() {
-  const fresh = findEvent(ndState.key);
-  const e = fresh || ndState.snap;
-  if (!e) return "";
-  const t = Date.parse(e.time) / 1000;
-  const when = new Date(e.time).toLocaleString(undefined, { dateStyle: "full", timeStyle: "short" });
-  const impact = `<span class="badge ${e.impact === "high" ? "text-bg-danger" : e.impact === "medium" ? "text-bg-warning" : "text-bg-secondary"}">${e.impact === "medium" ? "Med" : e.impact.charAt(0).toUpperCase() + e.impact.slice(1)}</span>`;
-  let out = `<div class="fs-5 fw-semibold mb-1">${esc(e.event)}</div>
-    <div class="small text-secondary mb-3">${esc(e.currency)} · ${when}</div>`;
-  const timing = t > nowServer()
-    ? `releases in <span class="num" data-close="${t}">--:--</span>`
-    : `released ${fmtAge(e.time)}`;
-  out += sec("Timing", `<div class="text-secondary small">${impact} impact · ${timing}</div>`);
-  const surpTxt = { positive: "actual above forecast", negative: "actual below forecast", inline: "actual matches forecast" }[e.surprise];
-  out += sec("Numbers", `<div class="row row-cols-3 g-2">${
-      tile("Forecast", esc(e.forecast ?? "—")) +
-      tile("Previous", esc(e.previous ?? "—")) +
-      tile("Actual", esc(e.actual ?? "—"), e.surprise === "positive" ? "text-success" : e.surprise === "negative" ? "text-danger" : "")
-    }</div>` + (surpTxt
-      ? `<div class="small text-secondary mt-2">${surpTxt} (numeric only — not gold direction)</div>` : ""));
-  return out;
-}
-
-function renderNewsDlg() {
-  if (!ndState || !newsModalOpen) return;
-  const scroll = $("nd-body").scrollTop;
-  $("nd-title").textContent = ndState.kind === "wire" ? "Newswire" : "Economic calendar";
-  $("nd-body").innerHTML = ndState.kind === "wire" ? wireDlgHTML() : calDlgHTML();
-  $("nd-body").scrollTop = scroll;
-  tick();
-}
-
-function openNewsDetail(id) {
-  const h = findHeadline(id);
-  if (!h) return;
-  ndState = { kind: "wire", id, snap: h };
-  aiErr.delete(id);
-  newsModal.show();
-  if (!aiMemo.has(id) && !aiPending.has(id)) fetchAiSummary(id);
-  renderNewsDlg();
-  $("nd-body").scrollTop = 0;
-  $("nd-close").focus();
-}
-
-function openCalDetail(key) {
-  const e = findEvent(key);
-  if (!e) return;
-  ndState = { kind: "cal", key, snap: e };
-  newsModal.show();
-  renderNewsDlg();
-  $("nd-body").scrollTop = 0;
-  $("nd-close").focus();
-}
-
-$("nd-close")?.addEventListener("click", () => newsModal.hide());
-
-/* ── polling ──────────────────────────────────────────────────── */
-async function fetchJSON(name) {
-  const res = await fetch(name, { cache: "no-cache" });
-  if (!res.ok) throw new Error(`${name}: HTTP ${res.status}`);
-  const dateHdr = res.headers.get("Date");
-  const text = await res.text();
-  return { text, serverNow: dateHdr ? Date.parse(dateHdr) / 1000 : null };
-}
-
-function tfFingerprint(entry) {
-  if (!entry) return "";
-  return JSON.stringify({
-    status: entry.status,
-    scanned_at: entry.scanned_at,
-    error: entry.error,
-    error_at: entry.error_at,
-    report: entry.report
-  });
-}
-
-function scheduleRefresh(delay) {
-  clearTimeout(refetchTimer);
-  refetchTimer = setTimeout(() => {
-    refetchTimer = null;
-    poll();
-  }, Math.max(0, delay));
-}
-
-function scheduleFallbackRefresh() {
-  clearTimeout(fallbackTimer);
-  fallbackTimer = setTimeout(() => {
-    fallbackTimer = null;
-    poll();
-    scheduleFallbackRefresh();
-  }, FALLBACK_POLL_MS);
-}
-
-function scheduleBoundaryRefresh() {
-  if (!snapshot) return;
-  const nextScan = Math.min(...TF_ORDER.map(tf =>
-    snapshot.timeframes[tf]?.next_scan_epoch || Infinity));
-  if (!isFinite(nextScan)) return;
-  const delay = (nextScan - nowServer() + 2) * 1000;
-  scheduleRefresh(delay > 0 ? delay : RETRY_MS);
-}
-
-async function poll() {
-  if (pollInFlight) {
-    pollQueued = true;
-    return;
-  }
-  pollInFlight = true;
-  try {
-    const [snap, nw] = await Promise.all([
-      fetchJSON("snapshot.json"),
-      fetchJSON("news.json").catch(() => null)
-    ]);
-    const priorSnapshot = snapshot;
-    let snapChanged = false;
-    let selectedChanged = false;
-    let cardsChanged = false;
-    let detailChanged = false;
-    if (snap.text !== lastSnapText) {
-      const incoming = JSON.parse(snap.text);
-      if (!priorSnapshot || incoming.server_time_epoch >= priorSnapshot.server_time_epoch) {
-        snapChanged = true;
-        selectedChanged = tfFingerprint(priorSnapshot?.timeframes?.[selectedTf]) !==
-          tfFingerprint(incoming.timeframes?.[selectedTf]);
-        // renderCards() redraws the selector for EVERY timeframe, so it
-        // must react to any of them changing — not just the selected one.
-        // Gating it on selectedChanged left the other buttons showing a
-        // stale arrow/score (up to 4 h on H4) while renderHero's rail,
-        // which redraws unconditionally, already showed the new value.
-        cardsChanged = TF_ORDER.some(tf =>
-          tfFingerprint(priorSnapshot?.timeframes?.[tf]) !==
-          tfFingerprint(incoming.timeframes?.[tf]));
-        detailChanged = detailTf != null && tfFingerprint(priorSnapshot?.timeframes?.[detailTf]) !==
-          tfFingerprint(incoming.timeframes?.[detailTf]);
-        snapshot = incoming;
-        lastSnapText = snap.text;
-      }
-    }
-    const newsChanged = nw != null && nw.text !== lastNewsText;
-    if (newsChanged) { news = JSON.parse(nw.text); lastNewsText = nw.text; }
-    clockOffset = (snap.serverNow ?? snapshot.server_time_epoch) - Date.now() / 1000;
-    lastPollOk = new Date();
-    $("banner-fail").classList.add("d-none");
-
-    if (snapChanged) {
-      renderHero();
-      if (cardsChanged) renderCards();
-      if (detailChanged) renderDetail();
-      if (selectedChanged) {
-        const signal = snapshot.timeframes[selectedTf]?.report?.signal;
-        if (signal) announce(`${TF_LABEL[selectedTf]} signal updated: ${sigLabel(signal)}.`);
-      }
-    }
-    if (newsChanged) {
-      renderCalendar();
-      renderWire();
-      renderNewsDlg();
-    }
-    if (snapChanged || newsChanged) renderContext();
-    tick();
-    scheduleBoundaryRefresh();
-  } catch (err) {
-    const last = lastPollOk ? ` Last update ${lastPollOk.toLocaleTimeString()}.` : "";
-    const b = $("banner-fail");
-    b.textContent = `Dashboard data is temporarily unavailable.${last} Retrying…`;
-    b.classList.remove("d-none");
-    scheduleRefresh(RETRY_MS);
-  } finally {
-    pollInFlight = false;
-    if (pollQueued) {
-      pollQueued = false;
-      poll();
-    }
-  }
-}
-
-function tick() {
-  if (!snapshot) return;
-  const now = nowServer();
-  document.querySelectorAll("[data-close]").forEach(el => {
-    const t = parseFloat(el.dataset.close);
-    if (!t) return;
-    let secs = t - now;
-    if (secs < 0) {
-      const interval = parseFloat(el.dataset.interval);
-      secs = interval > 0 ? ((secs % interval) + interval) % interval : 0;
-    }
-    el.textContent = fmtCountdown(secs);
-  });
-  const m5 = snapshot.timeframes["5min"]?.next_close_epoch;
-  if (m5) {
-    let secs = m5 - now;
-    if (secs < 0) secs = ((secs % TF_SECONDS["5min"]) + TF_SECONDS["5min"]) % TF_SECONDS["5min"];
-    $("hero-cd").textContent = fmtCountdown(secs);
-  }
-  const pubEpoch = snapshot.server_time_epoch;
-  if (pubEpoch) {
-    const age = now - pubEpoch;
-    const el = $("hero-updated");
-    const stale = !snapshot.market_closed && age > 900;
-    el.textContent = (stale ? "STALE — published " : "published ") +
-      fmtAge(new Date(pubEpoch * 1000).toISOString());
-    el.classList.toggle("text-warning", stale);
-    el.classList.toggle("fw-semibold", stale);
-  }
-}
-
-/* ── boot ─────────────────────────────────────────────────────── */
-document.addEventListener("DOMContentLoaded", () => {
-  tfModal = new bootstrap.Modal($("tf-detail"));
-  newsModal = new bootstrap.Modal($("news-detail"));
-  const storedTf = localGet(TIMEFRAME_PREF);
-  if (TF_LABEL[storedTf]) selectedTf = storedTf;
-  $("hi-only").checked = localGet(HIGH_IMPACT_PREF) === "true";
-
-  $("tf-detail")?.addEventListener("shown.bs.modal", () => { tfModalOpen = true; renderDetail(); });
-  $("tf-detail")?.addEventListener("hidden.bs.modal", () => { tfModalOpen = false; detailTf = null; });
-  $("news-detail")?.addEventListener("shown.bs.modal", () => { newsModalOpen = true; renderNewsDlg(); });
-  $("news-detail")?.addEventListener("hidden.bs.modal", () => { newsModalOpen = false; ndState = null; });
-
-  const selectTf = tf => {
-    if (!TF_LABEL[tf]) return;
-    const changed = selectedTf !== tf;
-    selectedTf = tf;
-    localSet(TIMEFRAME_PREF, tf);
-    renderHero();
-    renderCards();
-    if (changed) announce(`${TF_LABEL[tf]} workspace selected.`);
-  };
-  $("hero-rail")?.addEventListener("click", e => {
-    const button = e.target.closest("[data-select-tf]");
-    if (button) selectTf(button.dataset.selectTf);
-  });
-  $("tf-grid")?.addEventListener("click", e => {
-    const detail = e.target.closest("[data-open-detail]");
-    if (detail) return openDetail(detail.dataset.openDetail);
-    const button = e.target.closest("[data-select-tf]");
-    if (button) selectTf(button.dataset.selectTf);
-  });
-  $("wire")?.addEventListener("click", e => {
-    const button = e.target.closest("[data-news-id]");
-    if (button) openNewsDetail(button.dataset.newsId);
-  });
-  $("cal-body")?.addEventListener("click", e => {
-    const button = e.target.closest("[data-ev-key]");
-    if (button) openCalDetail(button.dataset.evKey);
-  });
-  $("hi-only")?.addEventListener("change", () => {
-    localSet(HIGH_IMPACT_PREF, String($("hi-only").checked));
-    renderCalendar();
-  });
-
-  poll();
-  scheduleFallbackRefresh();
-  setInterval(tick, 1000);
-});

static/news_summary.php

@@ -51,10 +51,7 @@ In 1-2 plain-English sentences (max 45 words) explain what this news
 means for the GOLD (XAU/USD) price and WHY it is bullish, bearish, or
 neutral. If your reading clearly contradicts xau_score, add "(the
 automated score disagrees)". Never write the words "xau_score" or
-"score" — a general reader sees this text. Write for someone who has
+"score" — a general reader sees this text.
-never traded: short simple sentences, no acronyms or abbreviations
-(say "the US central bank", not "the Fed"; "interest rates", not
-"yields").
 Gold doctrine: hawkish Fed / rate hikes / rising real yields / strong
 dollar are gold-bearish; easing / rate cuts / safe-haven flows /
 geopolitical stress / weak dollar are gold-bullish.
@@ -73,12 +70,7 @@ function respond(int $status, array $obj, string $cache = 'no-store'): void
 function atomic_write(string $path, string $data): bool
 {
     $tmp = $path . '.tmp.' . getmypid();
-    $written = @file_put_contents($tmp, $data);
+    if (@file_put_contents($tmp, $data) === false) {
-    // A SHORT write (disk full / quota) returns a byte count, NOT false.
-    // Renaming that into place would publish a truncated JSON body which
-    // the cache-first branch above then serves forever.
-    if ($written === false || $written !== strlen($data)) {
-        @unlink($tmp);
         return false;
     }
     if (!@rename($tmp, $path)) {
@@ -125,14 +117,44 @@ if ($hit === null) {
                   'message' => 'Headline is no longer in the feed.']);
 }
 
-// ── 4. API key ──────────────────────────────────────────────────────
+// ── 4. daily cap (fail closed) ──────────────────────────────────────
+$dailyCap = (int)(getenv('AI_SUMMARY_DAILY_CAP') ?: 150);
+$capFh = @fopen(CAP_FILE, 'c+');
+if ($capFh === false || !flock($capFh, LOCK_EX)) {
+    respond(503, ['error' => 'cap_io']);
+}
+$today = gmdate('Y-m-d');
+$cap = json_decode((string)stream_get_contents($capFh), true);
+if (!is_array($cap) || ($cap['day'] ?? '') !== $today) {
+    $cap = ['day' => $today, 'count' => 0];
+}
+if ($cap['count'] >= $dailyCap) {
+    flock($capFh, LOCK_UN);
+    fclose($capFh);
+    respond(429, ['error' => 'cap_exceeded']);
+}
+// Increment BEFORE the LLM call — attempts count against the cap
+// (same semantics as llm_client._under_cap).
+$cap['count']++;
+rewind($capFh);
+if (ftruncate($capFh, 0) === false
+        || fwrite($capFh, json_encode($cap)) === false) {
+    flock($capFh, LOCK_UN);
+    fclose($capFh);
+    respond(503, ['error' => 'cap_io']);
+}
+fflush($capFh);
+flock($capFh, LOCK_UN);
+fclose($capFh);
+
+// ── 5. API key ──────────────────────────────────────────────────────
 $keyFile = getenv('DEEPSEEK_KEY_FILE') ?: '/etc/gold-dashboard/deepseek.key';
 $apiKey = trim((string)@file_get_contents($keyFile));
 if ($apiKey === '') {
     respond(503, ['error' => 'no_key']);
 }
 
-// ── 5. per-id stampede lock, then re-check the cache ────────────────
+// ── 6. per-id stampede lock, then re-check the cache ────────────────
 $lockFh = @fopen(CACHE_DIR . '/.ht_lock_' . $id, 'c');
 if ($lockFh !== false) {
     flock($lockFh, LOCK_EX);   // blocks while a concurrent winner generates
@@ -147,51 +169,6 @@ if ($lockFh !== false) {
         exit;
     }
 }
-$releaseLock = function () use (&$lockFh) {
-    if ($lockFh !== false) {
-        @flock($lockFh, LOCK_UN);
-        @fclose($lockFh);
-        $lockFh = false;
-    }
-};
-
-// ── 6. daily cap (fail closed) ──────────────────────────────────────
-// Counted HERE, not before the lock: a burst of clicks on one headline
-// makes exactly one DeepSeek call, and the losers are served from the
-// re-checked cache above — charging them against the budget (and
-// charging a request that then found no key) could exhaust the whole
-// 150/day allowance with zero LLM calls made.
-$dailyCap = (int)(getenv('AI_SUMMARY_DAILY_CAP') ?: 150);
-$capFh = @fopen(CAP_FILE, 'c+');
-if ($capFh === false || !flock($capFh, LOCK_EX)) {
-    $releaseLock();
-    respond(503, ['error' => 'cap_io']);
-}
-$today = gmdate('Y-m-d');
-$cap = json_decode((string)stream_get_contents($capFh), true);
-if (!is_array($cap) || ($cap['day'] ?? '') !== $today) {
-    $cap = ['day' => $today, 'count' => 0];
-}
-if ($cap['count'] >= $dailyCap) {
-    flock($capFh, LOCK_UN);
-    fclose($capFh);
-    $releaseLock();
-    respond(429, ['error' => 'cap_exceeded']);
-}
-// Increment BEFORE the LLM call — attempts count against the cap
-// (same semantics as llm_client._under_cap).
-$cap['count']++;
-rewind($capFh);
-if (ftruncate($capFh, 0) === false
-        || fwrite($capFh, json_encode($cap)) === false) {
-    flock($capFh, LOCK_UN);
-    fclose($capFh);
-    $releaseLock();
-    respond(503, ['error' => 'cap_io']);
-}
-fflush($capFh);
-flock($capFh, LOCK_UN);
-fclose($capFh);
 
 // ── 7. DeepSeek call (exact chat_json body shape) ───────────────────
 $userPayload = json_encode([

telegram_bot.py

@@ -71,9 +71,7 @@ from app_config import (
     telegram_channel_id,
 )
 from providers import BaseDataProvider, make_data_provider
-from agent_panel import attach_panel, panel_health
 from llm_client import get_llm_client
-from market_outlook import maybe_run_outlook
 from news_engine import FundamentalContext, NewsEngine
 from pair_signals import PAIR_PRODUCERS
 from signal_aggregator import SignalAggregator, SignalReport
@@ -341,10 +339,7 @@ def format_signal_message(report: SignalReport) -> str:
         f"📊 Regime: {regime_str} · Vol: {vol_str}",
     ]
     if report.action_recommendation:
-        # Pattern identifiers use underscores, which legacy Telegram Markdown
+        lines.append(f"_{_escape_md(report.action_recommendation)}_")
-        # can misparse even when escaped inside this italicized action line.
-        action = report.action_recommendation.replace("_", " ")
-        lines.append(f"_{_escape_md(action)}_")
 
     if report.trade_setup and sig not in (SignalStrength.NEUTRAL,):
         ts = report.trade_setup
@@ -412,19 +407,6 @@ def format_signal_message(report: SignalReport) -> str:
         extra.append(f"⚠️ {_escape_md(w)}")
     if report.news_summary:
         extra.append(f"📰 {_escape_md(report.news_summary)}")
-    if report.panel_verdict:
-        mark = {"AGREE": "✅", "OPPOSE": "⛔", "NEUTRAL": "➖"}.get(
-            report.panel_verdict, "")
-        panel_label = ("AI macro view"
-                      if report.panel_verdict_source == "macro" else "AI Panel")
-        extra.append(
-            f"🤖 {panel_label} {mark} *{_escape_md(report.panel_verdict)}* "
-            f"({report.panel_confidence:.0f}%) — "
-            f"{_escape_md(report.panel_rationale)}")
-        if report.panel_takes:
-            votes = " · ".join(
-                f"{t['persona']}: {t['stance']}" for t in report.panel_takes)
-            extra.append(f"   _{_escape_md(votes)}_")
     if extra:
         lines += [""] + extra
 
@@ -542,7 +524,7 @@ def _run_signal_sync(
         config.confirmation_timeframes = confirmation_tfs
     aggregator = SignalAggregator(config)
     aggregator.data_provider = _get_shared_dp()
-    return aggregator.analyze_pair(symbol=symbol, log_source="telegram")
+    return aggregator.analyze_pair(symbol=symbol)
 
 
 async def run_signal(
@@ -551,50 +533,9 @@ async def run_signal(
     confirmation_tfs: Optional[List[Timeframe]] = None,
 ) -> SignalReport:
     loop = asyncio.get_running_loop()
-    report = await loop.run_in_executor(
+    return await loop.run_in_executor(
         _executor, _run_signal_sync, symbol, timeframe, confirmation_tfs
     )
-    _remember_scan(symbol, timeframe, report)
-    return report
-
-
-# Most recent report per (symbol, timeframe) keyed by the closed-bar epoch
-# it was computed for. Closed-bar inputs are identical within a bar, so a
-# rescan inside the same bar (the WS level-breach handler fired up to
-# ~5 min apart all day, logging 3.5 M15 rows per candle — 2026-09 audit)
-# can reuse it instead of re-fetching, re-scoring and re-logging.
-_last_scan: Dict[str, tuple] = {}
-_TF_SECONDS_CACHE = {
-    Timeframe.M1: 60, Timeframe.M5: 300, Timeframe.M15: 900,
-    Timeframe.M30: 1800, Timeframe.H1: 3600, Timeframe.H4: 14400,
-    Timeframe.D1: 86400,
-}
-
-
-def _bar_epoch(tf: Timeframe, now: Optional[float] = None) -> int:
-    """Epoch of the most recent candle boundary for ``tf`` (UTC-anchored,
-    the same grid _seconds_until_boundary sleeps to)."""
-    secs = _TF_SECONDS_CACHE.get(tf, 900)
-    t = int(time.time() if now is None else now)
-    return t - t % secs
-
-
-def _remember_scan(symbol: str, tf: Timeframe, report: SignalReport) -> None:
-    _last_scan[f"{symbol}_{tf.value}"] = (_bar_epoch(tf), report)
-
-
-async def _cached_or_scan(
-    symbol: str,
-    timeframe: Timeframe,
-    confirmation_tfs: Optional[List[Timeframe]] = None,
-) -> SignalReport:
-    """run_signal, unless this bar already has a report for the key."""
-    cached = _last_scan.get(f"{symbol}_{timeframe.value}")
-    if cached is not None and cached[0] == _bar_epoch(timeframe):
-        logger.info(
-            f"{symbol} {timeframe.value}: reusing this bar's scan — no rescan")
-        return cached[1]
-    return await run_signal(symbol, timeframe, confirmation_tfs)
 
 
 # ── Alert gating (quality threshold + dedup) ─────────────────────────
@@ -615,22 +556,17 @@ def _passes_quality(quality: str) -> bool:
     return _QUALITY_RANK.get(quality, 0) >= _QUALITY_RANK.get(_alert_min_quality, 1)
 
 
-_last_alert_quality: Dict[str, str] = {}   # key → grade of last ALERTED signal
-
-
 def _alert_fingerprint(report: SignalReport) -> tuple:
-    """Alert identity for dedup: signal and setup direction.
+    """Alert identity for dedup: signal, quality, setup direction.
 
     Entry movement is checked separately in _should_alert against the
     last ALERTED entry/risk (a stable reference). Deriving a price bucket
     from the CURRENT SL distance here made the fingerprint churn on
-    normal ATR/anchor drift — near-duplicate alerts every candle. The
+    normal ATR/anchor drift — near-duplicate alerts every candle."""
-    grade is deliberately NOT part of the identity (2026-09 audit: an
-    A↔B flicker on an unchanged idea re-sent the full alert ~4× in 45
-    min); a grade UPGRADE re-alerts via _should_alert instead."""
     setup = report.trade_setup
     return (
         report.final_signal.name,
+        report.signal_quality,
         setup.direction if setup else None,
     )
 
@@ -650,12 +586,6 @@ def _should_alert(key: str, report: SignalReport) -> bool:
         return True
     if time.time() - _last_alert_ts.get(key, 0) >= _ALERT_REARM_SECONDS:
         return True
-    # Same idea at a HIGHER grade than last alerted → worth re-sending;
-    # a downgrade or flicker back is not.
-    last_q = _last_alert_quality.get(key)
-    if last_q is not None and (_QUALITY_RANK.get(report.signal_quality, 0)
-                               > _QUALITY_RANK.get(last_q, 0)):
-        return True
     setup = report.trade_setup
     last = _last_alert_setup.get(key)
     if setup is not None and last is not None:
@@ -668,7 +598,6 @@ def _should_alert(key: str, report: SignalReport) -> bool:
 def _commit_alert(key: str, report: SignalReport) -> None:
     _last_alert_fp[key] = _alert_fingerprint(report)
     _last_alert_ts[key] = time.time()
-    _last_alert_quality[key] = report.signal_quality
     setup = report.trade_setup
     if setup is not None:
         _last_alert_setup[key] = (
@@ -791,13 +720,6 @@ async def _scan_timeframe(
         async with _alert_lock(key):
             if not _should_alert(key, report):
                 continue
-            # Panel AFTER the quality gate + dedup decision so no LLM
-            # spend on suppressed alerts. Runs on the scan executor to
-            # keep the event loop free; this key's alert lock is held
-            # for the panel's wall time (≤~25 s), which only delays a
-            # same-key duplicate that _should_alert would drop anyway.
-            await asyncio.get_running_loop().run_in_executor(
-                _executor, attach_panel, report)
             detail = format_signal_message(report)
             delivered = False
             for chat_id in _signal_targets():
@@ -808,28 +730,6 @@ async def _scan_timeframe(
             if delivered:
                 _commit_alert(key, report)
 
-    # This independent advisory call runs only after the H1 scan completes.
-    # Offloading the LLM request keeps the event loop responsive.
-    if tf == Timeframe.H1:
-        try:
-            outlook = await asyncio.get_running_loop().run_in_executor(
-                _executor, maybe_run_outlook, "telegram")
-            settings = get_app_config().market_outlook_settings
-            if (outlook is not None and settings.get("telegram", False)
-                    and OWNER_ID is not None):
-                forming = {
-                    "buy": "possible buy forming",
-                    "sell": "possible sell forming",
-                    "none": "no clear setup forming",
-                }[outlook.setup_forming]
-                message = (
-                    f"🔭 AI outlook: {outlook.bias}, {forming} "
-                    f"({outlook.confidence:.0f}%) — {_escape_md(outlook.note)}"
-                )
-                await _send_alert(bot, OWNER_ID, message)
-        except Exception:
-            logger.exception("Hourly AI market outlook failed")
-
 
 # ── WebSocket level-breach monitor ──────────────────────────────────
 
@@ -926,7 +826,7 @@ async def _handle_breach(bot, pair_symbol: str, price: float, level_name: str) -
     logger.info(f"Level breach: {display} crossed {label} at {price} — rescanning M15")
 
     try:
-        report = await _cached_or_scan(pair_symbol, Timeframe.M15)
+        report = await run_signal(pair_symbol, Timeframe.M15)
         _update_level_cache([report])
     except Exception:
         logger.exception(f"Breach scan failed for {display}")
@@ -955,10 +855,6 @@ async def _handle_breach(bot, pair_symbol: str, price: float, level_name: str) -
         if not _should_alert(key, report):
             return
 
-        # Same post-gate panel attach as the auto-scan path (see
-        # _scan_timeframe for the spend/lock rationale).
-        await asyncio.get_running_loop().run_in_executor(
-            _executor, attach_panel, report)
         header = (
             f"⚡ *LEVEL BREAK* — {_escape_md(display)} crossed "
             f"*{_escape_md(label)}* @ `{_fmt_price(price)}`\n\n"
@@ -1297,10 +1193,6 @@ def _news_health_lines() -> List[str]:
         else:
             lines.append(f"  ✅ DeepSeek: {used}/{cap} calls today,"
                          f" {scored} headlines scored")
-        if get_app_config().agent_panel_settings.get("enabled", False):
-            ph = panel_health()
-            lines.append(f"  🤖 AI panel: {ph['used_today']}/{ph['cap']}"
-                         " panels today")
     return lines