Strategy Pivot Designer

#!/usr/bin/env python3
"""Detect backtest iteration stagnation for strategy pivot decisions.

Runs four deterministic triggers against an iteration history file and
returns a diagnosis with a recommendation of *continue*, *pivot*, or
*abandon*.  See ``references/stagnation_triggers.md`` for the full
specification.
"""

from __future__ import annotations

import argparse
import json
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

# ---------------------------------------------------------------------------
# Validation
# ---------------------------------------------------------------------------


def validate_history(history: dict[str, Any]) -> None:
    """Validate iteration history structure.

    Raises ``ValueError`` when required fields are missing or malformed.
    """
    sid = history.get("strategy_id")
    if not sid or not isinstance(sid, str):
        raise ValueError("strategy_id must be a non-empty string")

    iterations = history.get("iterations")
    if not iterations or not isinstance(iterations, list) or len(iterations) == 0:
        raise ValueError("iterations must be a non-empty list")

    for idx, it in enumerate(iterations):
        if "eval" not in it:
            raise ValueError(f"iterations[{idx}] missing 'eval' key")
        ev = it["eval"]

        # total_score is required for trajectory and recommendation logic
        if "total_score" not in ev:
            raise ValueError(f"iterations[{idx}].eval missing 'total_score'")

        if "dimensions" not in ev:
            raise ValueError(f"iterations[{idx}].eval missing 'dimensions' list")

        # Validate each dimension has required name/score keys
        for dim_idx, dim in enumerate(ev["dimensions"]):
            if not isinstance(dim, dict):
                raise ValueError(f"iterations[{idx}].eval.dimensions[{dim_idx}] must be a mapping")
            if "name" not in dim:
                raise ValueError(f"iterations[{idx}].eval.dimensions[{dim_idx}] missing 'name'")
            if "score" not in dim:
                raise ValueError(f"iterations[{idx}].eval.dimensions[{dim_idx}] missing 'score'")

        if "red_flags" not in ev:
            raise ValueError(f"iterations[{idx}].eval missing 'red_flags' list")
        if "inputs" not in ev:
            raise ValueError(f"iterations[{idx}].eval missing 'inputs' dict")


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def get_dimension_score(eval_data: dict[str, Any], name: str) -> int | None:
    """Look up a dimension score by *name*.  Returns ``None`` if not found."""
    for dim in eval_data.get("dimensions", []):
        if dim.get("name") == name:
            return dim.get("score")
    return None


def get_red_flag_ids(eval_data: dict[str, Any]) -> list[str]:
    """Extract red-flag IDs from *eval_data*."""
    return [f["id"] for f in eval_data.get("red_flags", []) if isinstance(f, dict) and "id" in f]


# ---------------------------------------------------------------------------
# Trigger detectors
# ---------------------------------------------------------------------------


def detect_plateau(
    iterations: list[dict],
    k: int = 3,
    threshold: int = 3,
) -> dict | None:
    """Detect improvement plateau over the last *k* iterations.

    Returns a trigger dict when the range of ``total_score`` values in the
    last *k* iterations is strictly less than *threshold*.
    """
    if len(iterations) < k:
        return None

    last_k = [it["eval"]["total_score"] for it in iterations[-k:]]
    score_range = max(last_k) - min(last_k)

    if score_range < threshold:
        return {
            "trigger": "improvement_plateau",
            "severity": "high",
            "evidence": {
                "last_k_scores": last_k,
                "score_range": score_range,
                "threshold": threshold,
            },
            "message": (
                f"{k} consecutive iterations with <{threshold}-point "
                f"score improvement (range: {score_range})"
            ),
        }
    return None


def detect_overfitting_proxy(eval_data: dict[str, Any]) -> dict | None:
    """Detect overfitting proxy.

    Fires when Expectancy >= 15, Risk Management >= 15, Robustness < 10,
    AND red-flags contain ``over_optimized`` or ``short_test_period``.
    """
    exp_score = get_dimension_score(eval_data, "Expectancy")
    risk_score = get_dimension_score(eval_data, "Risk Management")
    rob_score = get_dimension_score(eval_data, "Robustness")
    red_flag_ids = get_red_flag_ids(eval_data)

    if (
        exp_score is not None
        and exp_score >= 15
        and risk_score is not None
        and risk_score >= 15
        and rob_score is not None
        and rob_score < 10
        and ("over_optimized" in red_flag_ids or "short_test_period" in red_flag_ids)
    ):
        return {
            "trigger": "overfitting_proxy",
            "severity": "medium",
            "evidence": {
                "expectancy_score": exp_score,
                "risk_mgmt_score": risk_score,
                "robustness_score": rob_score,
                "red_flag_ids": red_flag_ids,
            },
            "message": ("High in-sample scores with low robustness and curve-fitting red flags"),
        }
    return None


def detect_cost_defeat(eval_data: dict[str, Any]) -> dict | None:
    """Detect cost defeat.

    Fires when ``expectancy < 0.3``, ``profit_factor < 1.3``, and
    ``slippage_tested`` is ``True``.
    """
    expectancy = eval_data.get("expectancy", 999)
    profit_factor = eval_data.get("profit_factor", 999)
    inputs = eval_data.get("inputs", {})
    slippage_tested = inputs.get("slippage_tested", False)

    if expectancy < 0.3 and profit_factor < 1.3 and slippage_tested:
        return {
            "trigger": "cost_defeat",
            "severity": "medium",
            "evidence": {
                "expectancy": expectancy,
                "profit_factor": profit_factor,
                "slippage_tested": slippage_tested,
            },
            "message": (
                f"Edge too thin after costs (expectancy={expectancy:.3f}, PF={profit_factor:.2f})"
            ),
        }
    return None


def detect_tail_risk(eval_data: dict[str, Any]) -> dict | None:
    """Detect tail risk.

    Fires when ``max_drawdown_pct > 35`` OR Risk Management score <= 5.
    """
    inputs = eval_data.get("inputs", {})
    max_dd = inputs.get("max_drawdown_pct", 0)
    risk_score = get_dimension_score(eval_data, "Risk Management")

    reasons: list[str] = []
    if max_dd > 35:
        reasons.append(f"max_drawdown_pct={max_dd}% > 35%")
    if risk_score is not None and risk_score <= 5:
        reasons.append(f"Risk Management score={risk_score} <= 5")

    if reasons:
        return {
            "trigger": "tail_risk",
            "severity": "high",
            "evidence": {
                "max_drawdown_pct": max_dd,
                "risk_mgmt_score": risk_score,
            },
            "message": f"Structural risk: {'; '.join(reasons)}",
        }
    return None


# ---------------------------------------------------------------------------
# Main pipeline
# ---------------------------------------------------------------------------


def _determine_recommendation(
    triggers_fired: list[dict],
    score_trajectory: list[int],
    iteration_count: int,
) -> str:
    """Apply the recommendation decision table (priority order).

    1. ``abandon`` -- iterations >= 3, latest score < 30, last-3 monotonically
       non-increasing.
    2. ``pivot`` -- at least one trigger fired.
    3. ``continue`` -- default.
    """
    # Priority 1: abandon
    if iteration_count >= 3 and score_trajectory[-1] < 30 and len(score_trajectory) >= 3:
        last_3 = score_trajectory[-3:]
        if all(last_3[i] >= last_3[i + 1] for i in range(len(last_3) - 1)):
            return "abandon"

    # Priority 2: pivot
    if triggers_fired:
        return "pivot"

    # Priority 3: continue
    return "continue"


def run_all_triggers(
    history: dict[str, Any],
    plateau_k: int = 3,
    plateau_threshold: int = 3,
) -> dict[str, Any]:
    """Run all stagnation triggers and return a full diagnosis dict."""
    validate_history(history)

    iterations = history["iterations"]
    latest_eval = iterations[-1]["eval"]
    latest_inputs = latest_eval.get("inputs", {})

    triggers_fired: list[dict] = []

    # Plateau -- needs >= k iterations
    plateau = detect_plateau(iterations, k=plateau_k, threshold=plateau_threshold)
    if plateau:
        triggers_fired.append(plateau)

    # Overfitting proxy -- needs >= 2 iterations
    if len(iterations) >= 2:
        overfit = detect_overfitting_proxy(latest_eval)
        if overfit:
            triggers_fired.append(overfit)

    # Cost defeat -- needs >= 2 iterations
    if len(iterations) >= 2:
        cost = detect_cost_defeat(latest_eval)
        if cost:
            triggers_fired.append(cost)

    # Tail risk -- can fire on a single iteration
    tail = detect_tail_risk(latest_eval)
    if tail:
        triggers_fired.append(tail)

    # Score trajectory
    score_trajectory = [it["eval"]["total_score"] for it in iterations]

    # Recommendation
    recommendation = _determine_recommendation(triggers_fired, score_trajectory, len(iterations))

    # Dimension scores summary from latest eval
    dim_scores: dict[str, int] = {}
    for dim in latest_eval.get("dimensions", []):
        dim_scores[dim["name"]] = dim["score"]

    return {
        "strategy_id": history["strategy_id"],
        "stagnation_detected": recommendation != "continue",
        "triggers_fired": triggers_fired,
        "iteration_count": len(iterations),
        "score_trajectory": score_trajectory,
        "latest_eval_summary": {
            "total_score": latest_eval.get("total_score"),
            "verdict": latest_eval.get("verdict"),
            "dimension_scores": dim_scores,
            "red_flag_ids": get_red_flag_ids(latest_eval),
            "expectancy": latest_eval.get("expectancy"),
            "profit_factor": latest_eval.get("profit_factor"),
            "max_drawdown_pct": latest_inputs.get("max_drawdown_pct"),
            "slippage_tested": latest_inputs.get("slippage_tested"),
        },
        "recommendation": recommendation,
        "diagnosed_at_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
    }


# ---------------------------------------------------------------------------
# Append eval
# ---------------------------------------------------------------------------


def append_eval(
    eval_path: Path,
    history_path: Path,
    strategy_id: str,
    changes: str = "",
) -> dict[str, Any]:
    """Append a backtest eval result to an iteration history file.

    Creates the history file if it does not exist.
    """
    eval_data = json.loads(eval_path.read_text())

    if history_path.exists():
        history = json.loads(history_path.read_text())
    else:
        history = {"strategy_id": strategy_id, "iterations": []}

    # Ensure strategy_id matches — refuse to mix histories
    existing_id = history.get("strategy_id")
    if existing_id != strategy_id:
        raise ValueError(
            f"strategy_id mismatch: history has '{existing_id}' "
            f"but --strategy-id is '{strategy_id}'. "
            f"Use a different history file or correct the strategy_id."
        )

    next_iteration = len(history["iterations"]) + 1

    iteration_entry = {
        "iteration": next_iteration,
        "timestamp": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
        "changes_from_previous": changes or f"Iteration {next_iteration}",
        "eval": eval_data,
    }

    history["iterations"].append(iteration_entry)
    history_path.write_text(json.dumps(history, indent=2, default=str))

    return history


# ---------------------------------------------------------------------------
# CLI
# ---------------------------------------------------------------------------


def parse_args() -> argparse.Namespace:
    """Parse command-line arguments."""
    parser = argparse.ArgumentParser(description="Detect stagnation in backtest iteration history.")

    # Detection mode
    parser.add_argument("--history", required=True, help="Path to iteration history JSON")
    parser.add_argument("--output-dir", default="reports/", help="Output directory")

    # Trigger parameters
    parser.add_argument(
        "--plateau-k",
        type=int,
        default=3,
        help="Window size for plateau detection (default: 3)",
    )
    parser.add_argument(
        "--plateau-threshold",
        type=int,
        default=3,
        help="Score range threshold for plateau (default: 3)",
    )

    # Append mode
    parser.add_argument(
        "--append-eval",
        default=None,
        help="Path to backtest eval JSON to append",
    )
    parser.add_argument(
        "--strategy-id",
        default=None,
        help="Strategy ID (required for --append-eval)",
    )
    parser.add_argument(
        "--changes",
        default="",
        help="Description of changes from previous iteration",
    )

    return parser.parse_args()


def main() -> int:
    """Entry point for CLI invocation."""
    args = parse_args()
    history_path = Path(args.history).resolve()

    # --- Append mode ---
    if args.append_eval:
        if not args.strategy_id:
            print("[ERROR] --strategy-id required when using --append-eval")
            return 1
        eval_path = Path(args.append_eval).resolve()
        if not eval_path.exists():
            print(f"[ERROR] eval file not found: {eval_path}")
            return 1
        try:
            history = append_eval(eval_path, history_path, args.strategy_id, args.changes)
        except (ValueError, json.JSONDecodeError) as exc:
            print(f"[ERROR] {exc}")
            return 1
        print(f"[OK] Appended iteration {len(history['iterations'])} to {history_path}")
        return 0

    # --- Detection mode ---
    if not history_path.exists():
        print(f"[ERROR] history file not found: {history_path}")
        return 1

    try:
        history = json.loads(history_path.read_text())
    except json.JSONDecodeError as exc:
        print(f"[ERROR] Invalid JSON in history file: {exc}")
        return 1

    try:
        diagnosis = run_all_triggers(
            history,
            plateau_k=args.plateau_k,
            plateau_threshold=args.plateau_threshold,
        )
    except ValueError as exc:
        print(f"[ERROR] {exc}")
        return 1

    output_dir = Path(args.output_dir).resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    strategy_id = diagnosis["strategy_id"]
    timestamp = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
    filename = f"pivot_diagnosis_{strategy_id}_{timestamp}.json"
    output_path = output_dir / filename

    output_path.write_text(json.dumps(diagnosis, indent=2, default=str))

    print(f"Recommendation: {diagnosis['recommendation']}")
    if diagnosis["triggers_fired"]:
        print(f"Triggers: {len(diagnosis['triggers_fired'])}")
        for t in diagnosis["triggers_fired"]:
            print(f"  [{t['severity'].upper()}] {t['trigger']}: {t['message']}")
    print(f"Output: {output_path}")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Generate strategy pivot proposals from stagnation diagnosis."""

from __future__ import annotations

import argparse
import json
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

import yaml

# --- Constants ---

DEFAULT_EXPORTABLE_FAMILIES = {
    "pivot_breakout",
    "gap_up_continuation",
    "panic_reversal",
    "news_reaction",
}

ARCHETYPE_CATALOG = {
    "trend_following_breakout": {
        "hypothesis_type": "breakout",
        "mechanism_tag": "behavior",
        "entry_family": "pivot_breakout",
        "default_horizon_days": 30,
        "default_stop_loss_pct": 0.08,
        "default_take_profit_rr": 3.0,
        "default_time_stop_days": 20,
        "default_conditions": ["close > high20_prev", "rel_volume >= 1.5", "close > ma50 > ma200"],
        "default_trend_filter": ["price > sma_200", "price > sma_50", "sma_50 > sma_200"],
        "compatible_pivots_from": [
            "mean_reversion_pullback",
            "volatility_contraction",
            "sector_rotation_momentum",
        ],
        "typical_failure_modes": [
            "Whipsaws in range-bound markets",
            "Late entries after extended moves",
            "Gap-downs through stop levels",
        ],
    },
    "mean_reversion_pullback": {
        "hypothesis_type": "mean_reversion",
        "mechanism_tag": "statistical",
        "entry_family": "research_only",
        "default_horizon_days": 7,
        "default_stop_loss_pct": 0.04,
        "default_take_profit_rr": 2.0,
        "default_time_stop_days": 7,
        "default_conditions": ["rsi_14 < 30", "price > sma_200", "price < sma_20"],
        "default_trend_filter": ["sma_50 > sma_200"],
        "compatible_pivots_from": [
            "trend_following_breakout",
            "volatility_contraction",
            "earnings_drift_pead",
        ],
        "typical_failure_modes": [
            "Catching falling knives in trend changes",
            "Insufficient recovery within time stop",
        ],
    },
    "earnings_drift_pead": {
        "hypothesis_type": "earnings_drift",
        "mechanism_tag": "information",
        "entry_family": "gap_up_continuation",
        "default_horizon_days": 20,
        "default_stop_loss_pct": 0.06,
        "default_take_profit_rr": 2.5,
        "default_time_stop_days": 20,
        "default_conditions": [
            "gap_up_detected",
            "close_above_gap_day_high",
            "volume > 2.0 * avg_volume_50",
        ],
        "default_trend_filter": ["price > sma_200", "price > sma_50", "sma_50 > sma_200"],
        "compatible_pivots_from": [
            "event_driven_fade",
            "trend_following_breakout",
            "mean_reversion_pullback",
        ],
        "typical_failure_modes": ["One-day gap fills", "Market-wide selloffs overwhelming drift"],
    },
    "volatility_contraction": {
        "hypothesis_type": "breakout",
        "mechanism_tag": "structural",
        "entry_family": "pivot_breakout",
        "default_horizon_days": 25,
        "default_stop_loss_pct": 0.05,
        "default_take_profit_rr": 3.0,
        "default_time_stop_days": 20,
        "default_conditions": [
            "volatility_contraction_detected",
            "close > pivot_point",
            "rel_volume >= 1.3",
        ],
        "default_trend_filter": ["price > sma_200", "sma_50 > sma_200"],
        "compatible_pivots_from": [
            "trend_following_breakout",
            "mean_reversion_pullback",
            "statistical_pairs",
        ],
        "typical_failure_modes": [
            "False breakouts from contraction zones",
            "Extended contraction draining capital",
        ],
    },
    "regime_conditional_carry": {
        "hypothesis_type": "regime",
        "mechanism_tag": "macro",
        "entry_family": "research_only",
        "default_horizon_days": 60,
        "default_stop_loss_pct": 0.07,
        "default_take_profit_rr": 2.5,
        "default_time_stop_days": 60,
        "default_conditions": ["regime_favorable", "carry_positive", "trend_aligned"],
        "default_trend_filter": ["macro_regime == risk_on"],
        "compatible_pivots_from": [
            "sector_rotation_momentum",
            "event_driven_fade",
            "statistical_pairs",
        ],
        "typical_failure_modes": ["Regime detection lag", "Whipsaws during transitions"],
    },
    "sector_rotation_momentum": {
        "hypothesis_type": "momentum",
        "mechanism_tag": "behavior",
        "entry_family": "research_only",
        "default_horizon_days": 40,
        "default_stop_loss_pct": 0.06,
        "default_take_profit_rr": 2.5,
        "default_time_stop_days": 30,
        "default_conditions": [
            "sector_rs_rank <= 3",
            "sector_momentum_positive",
            "relative_strength > 1.0",
        ],
        "default_trend_filter": ["market_breadth > 50%"],
        "compatible_pivots_from": [
            "trend_following_breakout",
            "regime_conditional_carry",
            "earnings_drift_pead",
        ],
        "typical_failure_modes": [
            "Momentum reversals during rotation shifts",
            "Crowded sector trades",
        ],
    },
    "event_driven_fade": {
        "hypothesis_type": "mean_reversion",
        "mechanism_tag": "information",
        "entry_family": "research_only",
        "default_horizon_days": 5,
        "default_stop_loss_pct": 0.03,
        "default_take_profit_rr": 2.0,
        "default_time_stop_days": 5,
        "default_conditions": [
            "event_overreaction_detected",
            "price_deviation > 2_sigma",
            "volume_spike",
        ],
        "default_trend_filter": ["no_regime_change_confirmed"],
        "compatible_pivots_from": [
            "earnings_drift_pead",
            "mean_reversion_pullback",
            "volatility_contraction",
        ],
        "typical_failure_modes": [
            "Genuine regime changes misread as overreactions",
            "Cascading events",
        ],
    },
    "statistical_pairs": {
        "hypothesis_type": "mean_reversion",
        "mechanism_tag": "statistical",
        "entry_family": "research_only",
        "default_horizon_days": 20,
        "default_stop_loss_pct": 0.06,
        "default_take_profit_rr": 2.0,
        "default_time_stop_days": 20,
        "default_conditions": ["cointegration_pvalue < 0.05", "zscore > 2.0", "half_life < 30"],
        "default_trend_filter": ["sector_correlation > 0.7"],
        "compatible_pivots_from": [
            "mean_reversion_pullback",
            "volatility_contraction",
            "regime_conditional_carry",
        ],
        "typical_failure_modes": ["Cointegration breakdown", "Extended spread divergence"],
    },
}

# Inversion rules: (trigger) -> list of module changes
INVERSION_MAP = {
    "cost_defeat": [
        {
            "module": "horizon",
            "change": "shorten",
            "new_time_stop_days": 7,
            "reason": "Reduce friction exposure",
        },
        {"module": "universe", "change": "high_liquidity", "reason": "Reduce slippage impact"},
    ],
    "tail_risk": [
        {
            "module": "risk",
            "change": "tighten",
            "new_stop_loss_pct": 0.04,
            "new_risk_per_trade": 0.005,
            "reason": "Reduce tail exposure",
        },
        {"module": "structure", "change": "market_neutral", "reason": "Hedge directional risk"},
    ],
    "improvement_plateau": [
        {
            "module": "signal",
            "change": "volume_based",
            "reason": "Change signal source from price to volume",
        },
        {"module": "entry", "change": "timing_shift", "reason": "Change entry timing mechanism"},
    ],
    "overfitting_proxy": [
        {
            "module": "complexity",
            "change": "simplify",
            "reason": "Reduce parameters and model complexity",
        },
        {
            "module": "validation",
            "change": "extend_period",
            "reason": "Extend test period and add regime subsamples",
        },
    ],
}

# Quality potential: (trigger, archetype) -> score 0-1
QUALITY_TABLE = {
    # cost_defeat: shorter horizon / higher liquidity archetypes score well
    ("cost_defeat", "mean_reversion_pullback"): 0.8,
    ("cost_defeat", "event_driven_fade"): 0.75,
    ("cost_defeat", "statistical_pairs"): 0.7,
    ("cost_defeat", "volatility_contraction"): 0.5,
    ("cost_defeat", "trend_following_breakout"): 0.4,
    ("cost_defeat", "earnings_drift_pead"): 0.6,
    ("cost_defeat", "sector_rotation_momentum"): 0.3,
    ("cost_defeat", "regime_conditional_carry"): 0.2,
    # tail_risk: low-risk / hedged archetypes score well
    ("tail_risk", "statistical_pairs"): 0.85,
    ("tail_risk", "event_driven_fade"): 0.7,
    ("tail_risk", "mean_reversion_pullback"): 0.75,
    ("tail_risk", "volatility_contraction"): 0.6,
    ("tail_risk", "trend_following_breakout"): 0.3,
    ("tail_risk", "earnings_drift_pead"): 0.4,
    ("tail_risk", "sector_rotation_momentum"): 0.35,
    ("tail_risk", "regime_conditional_carry"): 0.5,
    # improvement_plateau: structurally different signal sources score well
    ("improvement_plateau", "mean_reversion_pullback"): 0.7,
    ("improvement_plateau", "earnings_drift_pead"): 0.75,
    ("improvement_plateau", "event_driven_fade"): 0.65,
    ("improvement_plateau", "sector_rotation_momentum"): 0.7,
    ("improvement_plateau", "regime_conditional_carry"): 0.6,
    ("improvement_plateau", "statistical_pairs"): 0.65,
    ("improvement_plateau", "volatility_contraction"): 0.5,
    ("improvement_plateau", "trend_following_breakout"): 0.4,
    # overfitting_proxy: simpler / fewer-parameter archetypes score well
    ("overfitting_proxy", "mean_reversion_pullback"): 0.75,
    ("overfitting_proxy", "event_driven_fade"): 0.7,
    ("overfitting_proxy", "trend_following_breakout"): 0.65,
    ("overfitting_proxy", "volatility_contraction"): 0.6,
    ("overfitting_proxy", "earnings_drift_pead"): 0.55,
    ("overfitting_proxy", "statistical_pairs"): 0.4,
    ("overfitting_proxy", "sector_rotation_momentum"): 0.5,
    ("overfitting_proxy", "regime_conditional_carry"): 0.35,
}

# Objective reframe mappings
REFRAME_MAP = {
    "tail_risk": {
        "new_criteria": ["max_drawdown_pct < 25", "expected_value_after_costs > 0"],
        "exit_adjustments": {"stop_loss_pct": 0.04, "take_profit_rr": 1.5},
        "reason": "Reframe from return maximization to drawdown minimization",
    },
    "cost_defeat": {
        "new_criteria": ["win_rate > 55", "expected_value_after_costs > 0"],
        "exit_adjustments": {"stop_loss_pct": 0.03, "take_profit_rr": 1.5, "time_stop_days": 5},
        "reason": "Reframe to win rate maximization with smaller targets",
    },
    "improvement_plateau": {
        "new_criteria": [
            "risk_adjusted_return_per_exposure > 0.5",
            "expected_value_after_costs > 0",
        ],
        "exit_adjustments": {},
        "reason": "Reframe to risk-adjusted return per unit exposure",
    },
    "overfitting_proxy": {
        "new_criteria": ["expected_value_after_costs > 0", "stable across regimes and subperiods"],
        "exit_adjustments": {},
        "reason": "Simplify to fewer optimization targets",
    },
}

DEFAULT_QUALITY = 0.3


# --- ID Sanitization ---


def sanitize_identifier(value: str) -> str:
    """Convert free text into a safe identifier (same as design_strategy_drafts.py:84)."""
    lowered = "".join(ch.lower() if ch.isalnum() else "_" for ch in value)
    compact = "_".join(part for part in lowered.split("_") if part)
    return compact or "pivot"


# --- Archetype Identification ---


def identify_current_archetype(draft: dict[str, Any]) -> str | None:
    """Identify current strategy's archetype from its fields."""
    h_type = draft.get("hypothesis_type", "")
    m_tag = draft.get("mechanism_tag", "")
    e_family = draft.get("entry_family", "")

    # Exact match attempts
    for arch_id, arch in ARCHETYPE_CATALOG.items():
        if (
            arch["hypothesis_type"] == h_type
            and arch["mechanism_tag"] == m_tag
            and arch["entry_family"] == e_family
        ):
            return arch_id

    # Partial match: hypothesis_type + mechanism_tag
    for arch_id, arch in ARCHETYPE_CATALOG.items():
        if arch["hypothesis_type"] == h_type and arch["mechanism_tag"] == m_tag:
            return arch_id

    # Partial match: hypothesis_type only
    for arch_id, arch in ARCHETYPE_CATALOG.items():
        if arch["hypothesis_type"] == h_type:
            return arch_id

    return None


# --- Module Set for Novelty ---


def compute_module_set(draft: dict[str, Any]) -> set[tuple[str, str]]:
    """Build normalized module set for Jaccard distance."""
    modules: set[tuple[str, str]] = set()

    modules.add(("hypothesis_type", str(draft.get("hypothesis_type", ""))))
    modules.add(("mechanism_tag", str(draft.get("mechanism_tag", ""))))
    modules.add(("regime", str(draft.get("regime", ""))))
    modules.add(("entry_family", str(draft.get("entry_family", ""))))

    # Horizon classification
    exit_data = draft.get("exit", {})
    time_stop = exit_data.get("time_stop_days", 20)
    if time_stop <= 7:
        horizon = "short"
    elif time_stop <= 30:
        horizon = "medium"
    else:
        horizon = "long"
    modules.add(("horizon", horizon))

    # Risk style classification
    stop_loss = exit_data.get("stop_loss_pct", 0.07)
    if stop_loss <= 0.04:
        risk_style = "tight"
    elif stop_loss <= 0.08:
        risk_style = "normal"
    else:
        risk_style = "wide"
    modules.add(("risk_style", risk_style))

    return modules


# --- Scoring ---


def score_novelty(source_set: set, target_set: set) -> float:
    """Jaccard distance between module sets (0=identical, 1=no overlap)."""
    if not source_set and not target_set:
        return 0.0
    intersection = source_set & target_set
    union = source_set | target_set
    if not union:
        return 0.0
    return 1.0 - len(intersection) / len(union)


def score_quality_potential(trigger: str, archetype: str) -> float:
    """Look up quality potential from QUALITY_TABLE."""
    return QUALITY_TABLE.get((trigger, archetype), DEFAULT_QUALITY)


def compute_combined_score(quality: float, novelty: float) -> float:
    """Combined score: 0.6 * quality + 0.4 * novelty."""
    return round(0.6 * quality + 0.4 * novelty, 4)


# --- Pivot Generation ---


def generate_inversions(
    draft: dict[str, Any],
    triggers_fired: list[dict],
    source_archetype: str | None,
) -> list[dict[str, Any]]:
    """Generate assumption inversion proposals."""
    proposals: list[dict[str, Any]] = []
    source_id = draft.get("id", "unknown")

    for trigger_info in triggers_fired:
        trigger = trigger_info["trigger"]
        inversions = INVERSION_MAP.get(trigger, [])

        for inv in inversions:
            # For each archetype in the catalog (excluding current)
            for arch_id, arch in ARCHETYPE_CATALOG.items():
                if arch_id == source_archetype:
                    continue

                proposal_id = sanitize_identifier(f"pivot_{source_id}_inv_{trigger}_{arch_id}")

                # Build draft based on archetype defaults with inversion applied
                new_draft = _build_base_draft(draft, arch_id, arch, proposal_id)

                # Apply inversion-specific adjustments
                if inv.get("new_time_stop_days"):
                    new_draft["exit"]["time_stop_days"] = inv["new_time_stop_days"]
                if inv.get("new_stop_loss_pct"):
                    new_draft["exit"]["stop_loss_pct"] = inv["new_stop_loss_pct"]
                if inv.get("new_risk_per_trade"):
                    new_draft["risk"]["risk_per_trade"] = inv["new_risk_per_trade"]

                new_draft["pivot_metadata"] = {
                    "pivot_technique": "assumption_inversion",
                    "source_strategy_id": source_id,
                    "target_archetype": arch_id,
                    "what_changed": {
                        "signal": f"Inversion: {inv['module']} -> {inv['change']}",
                        "horizon": f"{draft.get('exit', {}).get('time_stop_days', '?')}d -> {new_draft['exit']['time_stop_days']}d",
                        "risk": f"stop {draft.get('exit', {}).get('stop_loss_pct', '?')} -> {new_draft['exit']['stop_loss_pct']}",
                    },
                    "why": inv["reason"],
                    "targeted_triggers": [trigger],
                    "expected_failure_modes": arch.get("typical_failure_modes", [])[:2],
                }

                proposals.append(new_draft)

    return proposals


def generate_archetype_switches(
    draft: dict[str, Any],
    source_archetype: str | None,
    triggers_fired: list[dict],
) -> list[dict[str, Any]]:
    """Generate archetype switch proposals."""
    if source_archetype is None or source_archetype not in ARCHETYPE_CATALOG:
        return []

    source_arch = ARCHETYPE_CATALOG[source_archetype]
    compatible = source_arch.get("compatible_pivots_from", [])
    source_id = draft.get("id", "unknown")
    trigger_ids = [t["trigger"] for t in triggers_fired]

    proposals: list[dict[str, Any]] = []
    for target_id in compatible:
        if target_id not in ARCHETYPE_CATALOG:
            continue

        target_arch = ARCHETYPE_CATALOG[target_id]
        proposal_id = sanitize_identifier(f"pivot_{source_id}_switch_{target_id}")

        new_draft = _build_base_draft(draft, target_id, target_arch, proposal_id)

        new_draft["pivot_metadata"] = {
            "pivot_technique": "archetype_switch",
            "source_strategy_id": source_id,
            "target_archetype": target_id,
            "what_changed": {
                "signal": f"Architecture switch: {source_archetype} -> {target_id}",
                "horizon": f"{draft.get('exit', {}).get('time_stop_days', '?')}d -> {new_draft['exit']['time_stop_days']}d",
                "risk": f"stop {draft.get('exit', {}).get('stop_loss_pct', '?')} -> {new_draft['exit']['stop_loss_pct']}",
            },
            "why": f"Structural pivot from {source_archetype} to {target_id} to address {', '.join(trigger_ids)}",
            "targeted_triggers": trigger_ids,
            "expected_failure_modes": target_arch.get("typical_failure_modes", [])[:2],
        }

        proposals.append(new_draft)

    return proposals


def generate_objective_reframes(
    draft: dict[str, Any],
    triggers_fired: list[dict],
    source_archetype: str | None,
) -> list[dict[str, Any]]:
    """Generate objective reframe proposals."""
    proposals: list[dict[str, Any]] = []
    source_id = draft.get("id", "unknown")

    for trigger_info in triggers_fired:
        trigger = trigger_info["trigger"]
        reframe = REFRAME_MAP.get(trigger)
        if not reframe:
            continue

        # Apply reframe to each compatible archetype
        current_arch = source_archetype or "unknown"
        compatible_archetypes: list[str] = []
        if current_arch in ARCHETYPE_CATALOG:
            compatible_archetypes = ARCHETYPE_CATALOG[current_arch].get(
                "compatible_pivots_from", []
            )

        # Also reframe the current archetype
        if current_arch in ARCHETYPE_CATALOG:
            target_archetypes = [current_arch] + compatible_archetypes
        else:
            target_archetypes = list(ARCHETYPE_CATALOG.keys())[:3]

        for arch_id in target_archetypes:
            if arch_id not in ARCHETYPE_CATALOG:
                continue
            arch = ARCHETYPE_CATALOG[arch_id]

            proposal_id = sanitize_identifier(f"pivot_{source_id}_reframe_{trigger}_{arch_id}")
            new_draft = _build_base_draft(draft, arch_id, arch, proposal_id)

            # Apply reframe adjustments
            if reframe.get("exit_adjustments"):
                for k, v in reframe["exit_adjustments"].items():
                    new_draft["exit"][k] = v

            if reframe.get("new_criteria"):
                new_draft["validation_plan"]["success_criteria"] = reframe["new_criteria"]

            new_draft["pivot_metadata"] = {
                "pivot_technique": "objective_reframe",
                "source_strategy_id": source_id,
                "target_archetype": arch_id,
                "what_changed": {
                    "signal": f"Objective reframe for {trigger}",
                    "horizon": f"{draft.get('exit', {}).get('time_stop_days', '?')}d -> {new_draft['exit']['time_stop_days']}d",
                    "risk": f"Criteria: {', '.join(reframe.get('new_criteria', [])[:2])}",
                },
                "why": reframe["reason"],
                "targeted_triggers": [trigger],
                "expected_failure_modes": arch.get("typical_failure_modes", [])[:2],
            }

            proposals.append(new_draft)

    return proposals


def _build_base_draft(
    source_draft: dict[str, Any],
    arch_id: str,
    arch: dict[str, Any],
    proposal_id: str,
) -> dict[str, Any]:
    """Build base pivot draft from archetype defaults."""
    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
    entry_family = arch["entry_family"]
    export_ready = entry_family in DEFAULT_EXPORTABLE_FAMILIES

    return {
        "id": proposal_id,
        "as_of": today,
        "concept_id": source_draft.get("concept_id", ""),
        "variant": "research_probe",
        "name": f"{arch_id.replace('_', ' ').title()} (pivoted from {source_draft.get('id', 'unknown')})",
        "hypothesis_type": arch["hypothesis_type"],
        "mechanism_tag": arch["mechanism_tag"],
        "regime": source_draft.get("regime", "Neutral"),
        "export_ready_v1": export_ready,
        "entry_family": entry_family,
        "entry": {
            "conditions": arch.get("default_conditions", []),
            "trend_filter": arch.get("default_trend_filter", []),
            "note": "Probe setup with small size for hypothesis validation.",
        },
        "exit": {
            "stop_loss_pct": arch.get("default_stop_loss_pct", 0.07),
            "take_profit_rr": arch.get("default_take_profit_rr", 3.0),
            "time_stop_days": arch.get("default_time_stop_days", 20),
        },
        "risk": {
            "position_sizing": "fixed_risk",
            "risk_per_trade": 0.005,
            "max_positions": 5,
            "max_sector_exposure": 0.3,
        },
        "validation_plan": {
            "period": "2016-01-01 to latest",
            "entry_timing": "next_open",
            "hold_days": [3, 7, 14]
            if arch.get("default_time_stop_days", 20) <= 14
            else [5, 20, 60],
            "success_criteria": [
                "expected_value_after_costs > 0",
                "max_drawdown_pct < 25",
            ],
        },
        "thesis": source_draft.get("thesis", ""),
        "invalidation_signals": source_draft.get("invalidation_signals", []),
    }


# --- Ranking & Selection ---


def rank_and_select(
    proposals: list[dict[str, Any]],
    source_draft: dict[str, Any],
    triggers_fired: list[dict],
    max_pivots: int = 3,
) -> list[dict[str, Any]]:
    """Rank proposals and select top candidates with diversity constraint."""
    source_modules = compute_module_set(source_draft)

    scored: list[tuple[float, float, str, dict[str, Any]]] = []
    for p in proposals:
        target_modules = compute_module_set(p)
        novelty = score_novelty(source_modules, target_modules)

        # Average quality across all targeted triggers
        target_arch = p.get("pivot_metadata", {}).get("target_archetype", "")
        targeted = p.get("pivot_metadata", {}).get("targeted_triggers", [])
        if targeted:
            quality = sum(score_quality_potential(t, target_arch) for t in targeted) / len(targeted)
        else:
            quality = DEFAULT_QUALITY

        combined = compute_combined_score(quality, novelty)

        p["pivot_metadata"]["scores"] = {
            "quality_potential": round(quality, 4),
            "novelty": round(novelty, 4),
            "combined": combined,
        }

        scored.append((combined, novelty, p["id"], p))

    # Sort: combined DESC, novelty DESC, id ASC (deterministic tiebreak)
    scored.sort(key=lambda x: (-x[0], -x[1], x[2]))

    # Diversity constraint: max 1 per target_archetype
    seen_archetypes: set[str] = set()
    selected: list[dict[str, Any]] = []

    for _, _, _, proposal in scored:
        target = proposal.get("pivot_metadata", {}).get("target_archetype", "")
        if target in seen_archetypes:
            continue
        seen_archetypes.add(target)
        selected.append(proposal)
        if len(selected) >= max_pivots:
            break

    return selected


# --- Export Ticket ---


def build_export_ticket_if_eligible(draft: dict[str, Any]) -> dict[str, Any] | None:
    """Build export ticket if entry_family is exportable. Returns None otherwise."""
    entry_family = draft.get("entry_family", "")
    if entry_family not in DEFAULT_EXPORTABLE_FAMILIES:
        return None

    ticket_id = sanitize_identifier(draft["id"].replace("pivot_", "edge_"))
    hypothesis_type = str(draft.get("hypothesis_type", "unknown"))

    if entry_family == "pivot_breakout" and hypothesis_type == "unknown":
        hypothesis_type = "breakout"
    if entry_family == "gap_up_continuation" and hypothesis_type == "unknown":
        hypothesis_type = "earnings_drift"

    ticket = {
        "id": ticket_id,
        "name": draft.get("name", ""),
        "description": f"Pivot-derived ticket from {draft.get('pivot_metadata', {}).get('source_strategy_id', 'unknown')}.",
        "hypothesis_type": hypothesis_type,
        "entry_family": entry_family,
        "mechanism_tag": draft.get("mechanism_tag", "uncertain"),
        "regime": draft.get("regime", "Neutral"),
        "holding_horizon": f"{draft.get('exit', {}).get('time_stop_days', 20)}D",
        "entry": {
            "conditions": draft.get("entry", {}).get("conditions", []),
            "trend_filter": draft.get("entry", {}).get("trend_filter", []),
        },
        "risk": draft.get("risk", {}),
        "exit": {
            "stop_loss_pct": draft.get("exit", {}).get("stop_loss_pct", 0.07),
            "take_profit_rr": draft.get("exit", {}).get("take_profit_rr", 3.0),
        },
        "cost_model": {
            "commission_per_share": 0.0,
            "slippage_bps": 5,
        },
    }

    # Minimal validation
    errors = _validate_ticket_minimal(ticket)
    if errors:
        return None

    return ticket


def _validate_ticket_minimal(ticket: dict[str, Any]) -> list[str]:
    """Minimal ticket validation (mirrors candidate_contract.validate_ticket_payload).

    Kept deliberately in sync with ``candidate_contract.py``.  The cross-
    validation test in ``test_generate_pivots.py::TestCrossValidation``
    detects drift between the two implementations.
    """
    errors: list[str] = []
    for key in ("id", "hypothesis_type", "entry_family"):
        value = ticket.get(key)
        if not isinstance(value, str) or not value.strip():
            errors.append(f"ticket.{key} must be a non-empty string")

    entry_family = ticket.get("entry_family")
    if isinstance(entry_family, str) and entry_family not in DEFAULT_EXPORTABLE_FAMILIES:
        errors.append(
            f"ticket.entry_family must be one of: {', '.join(sorted(DEFAULT_EXPORTABLE_FAMILIES))}"
        )

    # Mirror candidate_contract validation constraints
    validation = ticket.get("validation")
    if validation is not None:
        if not isinstance(validation, dict):
            errors.append("ticket.validation must be a mapping when provided")
        else:
            method = validation.get("method", "full_sample")
            if method != "full_sample":
                errors.append("ticket.validation.method must be 'full_sample' for Phase I")
            if validation.get("oos_ratio") is not None:
                errors.append("ticket.validation.oos_ratio must be omitted or null for Phase I")

    return errors


# --- Output ---


def write_outputs(
    selected: list[dict[str, Any]],
    diagnosis: dict[str, Any],
    source_draft: dict[str, Any],
    output_dir: Path,
) -> dict[str, Any]:
    """Write pivot drafts, tickets, report, and manifest."""
    timestamp_str = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
    strategy_id = diagnosis.get("strategy_id", "unknown")

    # Create directory structure
    research_dir = output_dir / "pivot_drafts" / "research_only"
    exportable_dir = output_dir / "pivot_drafts" / "exportable"
    research_dir.mkdir(parents=True, exist_ok=True)
    exportable_dir.mkdir(parents=True, exist_ok=True)

    manifest_drafts: list[dict[str, Any]] = []
    errors: list[str] = []

    for draft in selected:
        entry_family = draft.get("entry_family", "")
        is_exportable = entry_family in DEFAULT_EXPORTABLE_FAMILIES

        # Remove pivot_metadata from the YAML file (store separately)
        pivot_meta = draft.pop("pivot_metadata", {})
        draft_with_meta = {**draft, "pivot_metadata": pivot_meta}

        # Choose directory
        if is_exportable:
            target_dir = exportable_dir
            category = "exportable"
        else:
            target_dir = research_dir
            category = "research_only"

        # Write draft YAML (include timestamp to avoid overwrite on re-run)
        draft_filename = f"{draft['id']}_{timestamp_str}.yaml"
        draft_path = target_dir / draft_filename
        draft_path.write_text(yaml.safe_dump(draft_with_meta, sort_keys=False, allow_unicode=True))

        draft_entry: dict[str, Any] = {
            "id": draft["id"],
            "path": str(draft_path.relative_to(output_dir)),
            "category": category,
            "ticket_path": None,
            "scores": pivot_meta.get("scores", {}),
        }

        # Build ticket if exportable
        if is_exportable:
            ticket = build_export_ticket_if_eligible(draft_with_meta)
            if ticket:
                ticket_filename = f"ticket_{draft['id'].replace('pivot_', '')}_{timestamp_str}.yaml"
                ticket_path = exportable_dir / ticket_filename
                ticket_path.write_text(yaml.safe_dump(ticket, sort_keys=False, allow_unicode=True))
                draft_entry["ticket_path"] = str(ticket_path.relative_to(output_dir))
            else:
                errors.append(f"Ticket validation failed for {draft['id']}")

        # Restore pivot_metadata
        draft["pivot_metadata"] = pivot_meta
        manifest_drafts.append(draft_entry)

    # Write manifest
    manifest = {
        "generated_at_utc": datetime.now(timezone.utc).replace(microsecond=0).isoformat(),
        "strategy_id": strategy_id,
        "diagnosis_file": str(diagnosis.get("_source_path", "")),
        "strategy_file": str(source_draft.get("_source_path", "")),
        "triggers_fired": [t["trigger"] for t in diagnosis.get("triggers_fired", [])],
        "total_pivots_generated": len(selected),
        "exportable_count": sum(1 for d in manifest_drafts if d["category"] == "exportable"),
        "research_only_count": sum(1 for d in manifest_drafts if d["category"] == "research_only"),
        "drafts": manifest_drafts,
        "errors": errors,
    }

    manifest_path = output_dir / f"pivot_manifest_{strategy_id}_{timestamp_str}.json"
    manifest_path.write_text(json.dumps(manifest, indent=2, default=str))

    # Write report
    report = _build_report(selected, diagnosis, source_draft, manifest)
    report_path = output_dir / f"pivot_report_{strategy_id}_{timestamp_str}.md"
    report_path.write_text(report)

    return manifest


def _build_report(
    selected: list[dict[str, Any]],
    diagnosis: dict[str, Any],
    source_draft: dict[str, Any],
    manifest: dict[str, Any],
) -> str:
    """Build markdown report from pivot results."""
    lines = [
        f"# Pivot Report: {diagnosis.get('strategy_id', 'unknown')}",
        "",
        f"**Generated**: {manifest['generated_at_utc']}",
        f"**Source Strategy**: {source_draft.get('id', 'unknown')}",
        f"**Recommendation**: {diagnosis.get('recommendation', 'unknown')}",
        "",
        "---",
        "",
        "## Stagnation Diagnosis",
        "",
        f"**Triggers Fired**: {len(diagnosis.get('triggers_fired', []))}",
        f"**Score Trajectory**: {diagnosis.get('score_trajectory', [])}",
        "",
    ]

    for t in diagnosis.get("triggers_fired", []):
        lines.append(f"- **{t['trigger']}** [{t['severity']}]: {t['message']}")

    lines.extend(["", "---", "", "## Pivot Proposals", ""])

    for i, draft in enumerate(selected, 1):
        meta = draft.get("pivot_metadata", {})
        scores = meta.get("scores", {})
        lines.extend(
            [
                f"### {i}. {draft.get('id', 'unknown')}",
                "",
                f"**Technique**: {meta.get('pivot_technique', 'unknown')}",
                f"**Target Archetype**: {meta.get('target_archetype', 'unknown')}",
                f"**Entry Family**: {draft.get('entry_family', 'unknown')}",
                "",
                "**What Changed**:",
            ]
        )
        for k, v in meta.get("what_changed", {}).items():
            lines.append(f"- {k}: {v}")
        lines.extend(
            [
                "",
                f"**Why**: {meta.get('why', '')}",
                "",
                f"**Scores**: quality={scores.get('quality_potential', 0):.2f}, novelty={scores.get('novelty', 0):.2f}, combined={scores.get('combined', 0):.2f}",
                "",
            ]
        )

    # Summary table
    lines.extend(
        [
            "---",
            "",
            "## Summary",
            "",
            "| Rank | Proposal | Archetype | Combined | Category |",
            "|------|----------|-----------|----------|----------|",
        ]
    )
    for i, draft in enumerate(selected, 1):
        meta = draft.get("pivot_metadata", {})
        scores = meta.get("scores", {})
        category = (
            "exportable"
            if draft.get("entry_family", "") in DEFAULT_EXPORTABLE_FAMILIES
            else "research_only"
        )
        lines.append(
            f"| {i} | {draft['id']} | {meta.get('target_archetype', '')} | {scores.get('combined', 0):.2f} | {category} |"
        )

    lines.append("")
    return "\n".join(lines)


# --- CLI ---


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Generate strategy pivot proposals from stagnation diagnosis."
    )
    parser.add_argument("--diagnosis", required=True, help="Path to pivot_diagnosis JSON")
    parser.add_argument("--strategy", required=True, help="Path to source strategy draft YAML")
    parser.add_argument("--max-pivots", type=int, default=3, help="Maximum pivot proposals")
    parser.add_argument("--output-dir", default="reports/", help="Output directory")
    return parser.parse_args()


def main() -> int:
    args = parse_args()

    diagnosis_path = Path(args.diagnosis).resolve()
    strategy_path = Path(args.strategy).resolve()

    if not diagnosis_path.exists():
        print(f"[ERROR] diagnosis file not found: {diagnosis_path}")
        return 1
    if not strategy_path.exists():
        print(f"[ERROR] strategy file not found: {strategy_path}")
        return 1

    diagnosis = json.loads(diagnosis_path.read_text())
    source_draft = yaml.safe_load(strategy_path.read_text())

    if not isinstance(source_draft, dict):
        print("[ERROR] strategy file must be a YAML mapping")
        return 1

    # Tag source paths for manifest
    diagnosis["_source_path"] = str(diagnosis_path)
    source_draft["_source_path"] = str(strategy_path)

    triggers_fired = diagnosis.get("triggers_fired", [])
    if not triggers_fired:
        print("[INFO] No triggers fired -- no pivots to generate")
        return 0

    source_archetype = identify_current_archetype(source_draft)

    # Generate proposals from all techniques
    all_proposals: list[dict[str, Any]] = []
    all_proposals.extend(generate_inversions(source_draft, triggers_fired, source_archetype))
    all_proposals.extend(
        generate_archetype_switches(source_draft, source_archetype, triggers_fired)
    )
    all_proposals.extend(
        generate_objective_reframes(source_draft, triggers_fired, source_archetype)
    )

    # Rank and select
    selected = rank_and_select(
        all_proposals, source_draft, triggers_fired, max_pivots=args.max_pivots
    )

    # Write outputs
    output_dir = Path(args.output_dir).resolve()
    output_dir.mkdir(parents=True, exist_ok=True)

    manifest = write_outputs(selected, diagnosis, source_draft, output_dir)

    print(f"[OK] Generated {manifest['total_pivots_generated']} pivot proposals")
    print(
        f"  exportable={manifest['exportable_count']} research_only={manifest['research_only_count']}"
    )
    for d in manifest["drafts"]:
        print(f"  - {d['id']} ({d['category']}) combined={d['scores'].get('combined', 0):.2f}")

    return 0


if __name__ == "__main__":
    raise SystemExit(main())

"""Test configuration and shared fixtures for strategy-pivot-designer scripts."""

import os
import sys

import pytest

# Add scripts/ directory to sys.path so detect_stagnation can be imported.
sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))

# Add tests/ directory to sys.path so helpers can be imported by tests.
sys.path.insert(0, os.path.dirname(__file__))

from helpers import make_eval, make_iteration  # noqa: E402

# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------


@pytest.fixture()
def sample_iteration_history() -> dict:
    """Valid history with 5 iterations showing plateau pattern.

    Scores: 45, 62, 72, 73, 72 -- last 3 form a plateau (range=1).
    """
    evals = [
        make_eval(45, expectancy_score=8, robustness_score=12),
        make_eval(62, expectancy_score=12, robustness_score=14),
        make_eval(72, expectancy_score=15, robustness_score=16),
        make_eval(73, expectancy_score=15, robustness_score=16),
        make_eval(72, expectancy_score=15, robustness_score=16),
    ]
    iterations = [make_iteration(i + 1, ev, f"Change {i + 1}") for i, ev in enumerate(evals)]
    return {"strategy_id": "mean_revert_v2", "iterations": iterations}


@pytest.fixture()
def single_iteration_history() -> dict:
    """History with only 1 iteration."""
    return {
        "strategy_id": "single_test",
        "iterations": [
            make_iteration(1, make_eval(45)),
        ],
    }


@pytest.fixture()
def overfitting_history() -> dict:
    """History where overfitting_proxy triggers.

    Conditions: Expectancy >= 15, Risk Mgmt >= 15, Robustness < 10,
    red_flags contain 'over_optimized'.
    """
    ev1 = make_eval(50)
    ev2 = make_eval(
        78,
        expectancy_score=18,
        risk_mgmt_score=17,
        robustness_score=5,
        red_flags=[{"id": "over_optimized", "msg": "Strategy appears over-optimized"}],
    )
    return {
        "strategy_id": "overfit_strat",
        "iterations": [
            make_iteration(1, ev1, "Initial run"),
            make_iteration(2, ev2, "Added many parameters"),
        ],
    }


@pytest.fixture()
def cost_defeat_history() -> dict:
    """History where cost_defeat triggers.

    Conditions: expectancy < 0.3, profit_factor < 1.3, slippage_tested=True.
    """
    ev1 = make_eval(55)
    ev2 = make_eval(
        48,
        expectancy=0.12,
        profit_factor=1.15,
        slippage_tested=True,
    )
    return {
        "strategy_id": "thin_edge",
        "iterations": [
            make_iteration(1, ev1, "Initial run"),
            make_iteration(2, ev2, "Added slippage model"),
        ],
    }


@pytest.fixture()
def tail_risk_history() -> dict:
    """History where tail_risk triggers via high drawdown.

    Condition: max_drawdown_pct > 35.
    """
    ev = make_eval(40, max_drawdown_pct=42.0, risk_mgmt_score=4)
    return {
        "strategy_id": "risky_strat",
        "iterations": [
            make_iteration(1, ev, "Initial run"),
        ],
    }


@pytest.fixture()
def abandon_history() -> dict:
    """History with 3+ iterations, latest score < 30, monotonically non-increasing last 3.

    Scores: 28, 25, 22 -- declining and all below 30.
    """
    evals = [
        make_eval(28),
        make_eval(25),
        make_eval(22),
    ]
    return {
        "strategy_id": "hopeless_strat",
        "iterations": [make_iteration(i + 1, ev, f"Attempt {i + 1}") for i, ev in enumerate(evals)],
    }


@pytest.fixture()
def healthy_history() -> dict:
    """History with no triggers fired -- good scores, improving trajectory.

    Scores: 45, 58, 72 -- clearly improving with good internals.
    """
    evals = [
        make_eval(
            45,
            expectancy_score=10,
            risk_mgmt_score=10,
            robustness_score=12,
            max_drawdown_pct=18.0,
            expectancy=0.8,
            profit_factor=2.0,
        ),
        make_eval(
            58,
            expectancy_score=12,
            risk_mgmt_score=12,
            robustness_score=14,
            max_drawdown_pct=16.0,
            expectancy=0.9,
            profit_factor=2.2,
        ),
        make_eval(
            72,
            expectancy_score=14,
            risk_mgmt_score=14,
            robustness_score=16,
            max_drawdown_pct=14.0,
            expectancy=1.1,
            profit_factor=2.5,
        ),
    ]
    return {
        "strategy_id": "healthy_momentum",
        "iterations": [
            make_iteration(i + 1, ev, f"Improvement {i + 1}") for i, ev in enumerate(evals)
        ],
    }