Stanley Druckenmiller Investment

#!/usr/bin/env python3
"""
Strategy Synthesizer - Allocation Engine

Generates target asset allocation based on conviction score, pattern,
and macro regime. Provides position sizing guidance.

Asset classes: equity, bonds, alternatives (gold/commodities), cash
All allocations sum to 100%.
"""


# ---------------------------------------------------------------------------
# Base allocations by conviction zone (sum to 100%)
# ---------------------------------------------------------------------------

ZONE_BASE_ALLOCATIONS = {
    "Maximum Conviction": {
        "equity": 90,
        "bonds": 0,
        "alternatives": 5,
        "cash": 5,
    },
    "High Conviction": {
        "equity": 75,
        "bonds": 5,
        "alternatives": 5,
        "cash": 15,
    },
    "Moderate Conviction": {
        "equity": 55,
        "bonds": 10,
        "alternatives": 10,
        "cash": 25,
    },
    "Low Conviction": {
        "equity": 30,
        "bonds": 15,
        "alternatives": 15,
        "cash": 40,
    },
    "Capital Preservation": {
        "equity": 10,
        "bonds": 20,
        "alternatives": 20,
        "cash": 50,
    },
}

# ---------------------------------------------------------------------------
# Regime adjustments (additive shifts)
# ---------------------------------------------------------------------------

REGIME_ADJUSTMENTS = {
    "broadening": {"equity": +5, "bonds": 0, "alternatives": 0, "cash": -5},
    "concentration": {"equity": +3, "bonds": 0, "alternatives": 0, "cash": -3},
    "transitional": {"equity": 0, "bonds": 0, "alternatives": 0, "cash": 0},
    "inflationary": {"equity": -5, "bonds": -5, "alternatives": +10, "cash": 0},
    "contraction": {"equity": -10, "bonds": +5, "alternatives": 0, "cash": +5},
}

# ---------------------------------------------------------------------------
# Pattern adjustments (additive shifts)
# ---------------------------------------------------------------------------

PATTERN_ADJUSTMENTS = {
    "policy_pivot_anticipation": {"equity": +5, "bonds": +3, "alternatives": -3, "cash": -5},
    "unsustainable_distortion": {"equity": -10, "bonds": 0, "alternatives": +5, "cash": +5},
    "extreme_sentiment_contrarian": {"equity": +10, "bonds": -5, "alternatives": 0, "cash": -5},
    "wait_and_observe": {"equity": -5, "bonds": 0, "alternatives": 0, "cash": +5},
}


# ---------------------------------------------------------------------------
# Public API
# ---------------------------------------------------------------------------


def generate_allocation(
    conviction_score: float,
    zone: str,
    pattern: str,
    regime: str,
) -> dict:
    """
    Generate target allocation based on conviction, pattern, and regime.

    Returns dict with equity, bonds, alternatives, cash (sum = 100).
    """
    # Start with zone base allocation
    base = dict(ZONE_BASE_ALLOCATIONS.get(zone, ZONE_BASE_ALLOCATIONS["Moderate Conviction"]))

    # Apply regime adjustment
    regime_adj = REGIME_ADJUSTMENTS.get(regime, REGIME_ADJUSTMENTS["transitional"])
    for asset, shift in regime_adj.items():
        base[asset] += shift

    # Apply pattern adjustment
    pattern_adj = PATTERN_ADJUSTMENTS.get(pattern, PATTERN_ADJUSTMENTS["wait_and_observe"])
    for asset, shift in pattern_adj.items():
        base[asset] += shift

    # Clamp all to non-negative
    for asset in base:
        base[asset] = max(0, base[asset])

    # Re-normalize to 100%
    total = sum(base.values())
    if total > 0:
        for asset in base:
            base[asset] = round(base[asset] / total * 100, 1)
    else:
        base = {"equity": 0, "bonds": 0, "alternatives": 0, "cash": 100}

    # Fix rounding to exactly 100
    diff = 100 - sum(base.values())
    if abs(diff) > 0:
        # Add/subtract from largest allocation
        largest = max(base, key=base.get)
        base[largest] = round(base[largest] + diff, 1)

    return base


def calculate_position_sizing(
    conviction_score: float,
    zone: str,
) -> dict:
    """
    Calculate position sizing parameters based on conviction level.

    Returns:
        max_single_position: Max % of portfolio in one position
        daily_vol_target: Target daily portfolio volatility %
        max_positions: Max number of open positions
    """
    sizing_map = {
        "Maximum Conviction": {
            "max_single_position": 25,
            "daily_vol_target": 0.4,
            "max_positions": 8,
        },
        "High Conviction": {
            "max_single_position": 15,
            "daily_vol_target": 0.3,
            "max_positions": 12,
        },
        "Moderate Conviction": {
            "max_single_position": 10,
            "daily_vol_target": 0.25,
            "max_positions": 15,
        },
        "Low Conviction": {
            "max_single_position": 5,
            "daily_vol_target": 0.15,
            "max_positions": 20,
        },
        "Capital Preservation": {
            "max_single_position": 3,
            "daily_vol_target": 0.1,
            "max_positions": 25,
        },
    }

    return sizing_map.get(zone, sizing_map["Moderate Conviction"])

#!/usr/bin/env python3
"""
Strategy Synthesizer - Report Generator

Generates JSON and Markdown reports for the Druckenmiller strategy analysis.

The Markdown output structure follows the specification defined in:
    assets/strategy_report_template.md
"""

import json


def generate_json_report(analysis: dict, output_file: str):
    """Save full analysis as JSON."""
    with open(output_file, "w") as f:
        json.dump(analysis, f, indent=2, default=str)
    print(f"JSON report saved to: {output_file}")


def generate_markdown_report(analysis: dict, output_file: str):
    """Generate comprehensive Markdown report."""
    lines = []
    metadata = analysis.get("metadata", {})
    conviction = analysis.get("conviction", {})
    pattern = analysis.get("pattern", {})
    allocation = analysis.get("allocation", {})
    sizing = analysis.get("position_sizing", {})
    input_summary = analysis.get("input_summary", {})
    component_scores = conviction.get("component_scores", {})

    score = conviction.get("conviction_score", 0)
    zone = conviction.get("zone", "Unknown")
    zone_color = conviction.get("zone_color", "")

    # ================================================================
    # Header
    # ================================================================
    lines.append("# Druckenmiller Strategy Synthesizer Report")
    lines.append("")
    lines.append(f"**Generated:** {metadata.get('generated_at', 'N/A')}")
    lines.append(
        f"**Input Skills:** {metadata.get('skills_loaded', 0)} loaded "
        f"({metadata.get('required_count', 0)} required + "
        f"{metadata.get('optional_count', 0)} optional)"
    )
    lines.append("")

    # ================================================================
    # Section 1: Conviction Dashboard
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 1. Conviction Dashboard")
    lines.append("")

    zone_emoji = _zone_emoji(zone_color)

    lines.append("| Metric | Value |")
    lines.append("|--------|-------|")
    lines.append(f"| **Conviction Score** | {zone_emoji} **{score}/100** |")
    lines.append(f"| **Zone** | {zone} |")
    lines.append(f"| **Recommended Exposure** | {conviction.get('exposure_range', 'N/A')} |")
    strongest = conviction.get("strongest_component", {})
    weakest = conviction.get("weakest_component", {})
    lines.append(
        f"| **Strongest Component** | {strongest.get('label', 'N/A')} ({strongest.get('score', 0)}) |"
    )
    lines.append(
        f"| **Weakest Component** | {weakest.get('label', 'N/A')} ({weakest.get('score', 0)}) |"
    )
    lines.append("")

    lines.append(f"> **Guidance:** {conviction.get('guidance', '')}")
    lines.append("")

    # Actions
    actions = conviction.get("actions", [])
    if actions:
        lines.append("**Recommended Actions:**")
        lines.append("")
        for action in actions:
            lines.append(f"- {action}")
        lines.append("")

    # ================================================================
    # Section 2: Pattern Classification
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 2. Pattern Classification")
    lines.append("")

    pattern_label = pattern.get("label", "Unknown")
    match_strength = pattern.get("match_strength", 0)
    lines.append(f"**Detected Pattern:** {pattern_label} (match: {match_strength}%)")
    lines.append("")
    lines.append(f"> {pattern.get('description', '')}")
    lines.append("")

    # All pattern scores
    all_scores = pattern.get("all_pattern_scores", {})
    if all_scores:
        lines.append("| Pattern | Match Score |")
        lines.append("|---------|-----------|")
        for p_name, p_score in sorted(all_scores.items(), key=lambda x: -x[1]):
            marker = " **DETECTED**" if p_name == pattern.get("pattern") else ""
            lines.append(f"| {p_name.replace('_', ' ').title()} | {p_score}{marker} |")
        lines.append("")

    # ================================================================
    # Section 3: Component Scores
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 3. Component Scores (7 Components)")
    lines.append("")
    lines.append("| # | Component | Weight | Eff. Weight | Score | Weighted |")
    lines.append("|---|-----------|--------|-------------|-------|----------|")

    for i, (key, comp) in enumerate(component_scores.items(), 1):
        comp_score = comp.get("score", 0)
        weight = comp.get("weight", 0)
        eff_weight = comp.get("effective_weight", weight)
        available = comp.get("available", True)
        weighted = comp.get("weighted_contribution", 0)
        label = comp.get("label", key)
        if not available:
            label = f"{label} (N/A)"
        bar = _score_bar(comp_score)
        lines.append(
            f"| {i} | {label} | {weight * 100:.0f}% | {eff_weight * 100:.1f}% | {bar} {comp_score} | {weighted} |"
        )

    lines.append(f"| | **TOTAL** | **100%** | **100%** | | **{score}** |")
    lines.append("")

    # ================================================================
    # Section 4: Input Skills Summary
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 4. Input Skills Summary")
    lines.append("")

    required_keys = [
        "market_breadth",
        "uptrend_analysis",
        "market_top",
        "macro_regime",
        "ftd_detector",
    ]
    optional_keys = ["vcp_screener", "theme_detector", "canslim_screener"]

    lines.append("### Required Skills")
    lines.append("")
    lines.append("| Skill | Score | Zone/State | Key Signal |")
    lines.append("|-------|-------|-----------|------------|")
    for key in required_keys:
        sig = input_summary.get(key, {})
        sig_score = sig.get("composite_score", sig.get("quality_score", "N/A"))
        zone_or_state = sig.get("zone", sig.get("state", "N/A"))
        key_signal = _format_key_signal(key, sig)
        lines.append(
            f"| {key.replace('_', ' ').title()} | {sig_score} | {zone_or_state} | {key_signal} |"
        )
    lines.append("")

    lines.append("### Optional Skills")
    lines.append("")
    lines.append("| Skill | Score | Key Signal |")
    lines.append("|-------|-------|------------|")
    for key in optional_keys:
        sig = input_summary.get(key, {})
        if sig:
            sig_score = sig.get("derived_score", "N/A")
            key_signal = _format_key_signal(key, sig)
            lines.append(f"| {key.replace('_', ' ').title()} | {sig_score} | {key_signal} |")
        else:
            lines.append(f"| {key.replace('_', ' ').title()} | -- | Not available |")
    lines.append("")

    # ================================================================
    # Section 5: Target Allocation
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 5. Target Allocation")
    lines.append("")

    target = allocation.get("target", {})
    lines.append("| Asset Class | Allocation |")
    lines.append("|-------------|-----------|")
    for asset in ["equity", "bonds", "alternatives", "cash"]:
        pct = target.get(asset, 0)
        bar = _alloc_bar(pct)
        lines.append(f"| {asset.title()} | {bar} {pct}% |")
    lines.append("")

    # ================================================================
    # Section 6: Position Sizing & Risk
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 6. Position Sizing & Risk")
    lines.append("")

    lines.append("| Parameter | Value |")
    lines.append("|-----------|-------|")
    lines.append(f"| Max Single Position | {sizing.get('max_single_position', 'N/A')}% |")
    lines.append(f"| Daily Volatility Target | {sizing.get('daily_vol_target', 'N/A')}% |")
    lines.append(f"| Max Open Positions | {sizing.get('max_positions', 'N/A')} |")
    lines.append("")

    # ================================================================
    # Section 7: Druckenmiller Principle
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## 7. Druckenmiller Principle")
    lines.append("")

    principle = _select_principle(zone, pattern.get("pattern", ""))
    lines.append(f'> *"{principle["quote"]}"*')
    lines.append(">")
    lines.append("> — Stanley Druckenmiller")
    lines.append("")
    lines.append(f"**Application:** {principle['application']}")
    lines.append("")

    # ================================================================
    # Methodology
    # ================================================================
    lines.append("---")
    lines.append("")
    lines.append("## Methodology")
    lines.append("")
    lines.append(
        "This report synthesizes outputs from 8 upstream analysis skills "
        "(5 required + 3 optional) into a single conviction score using "
        "Stanley Druckenmiller's investment philosophy."
    )
    lines.append("")
    lines.append("**7 Components** (weighted 0-100):")
    lines.append("")
    lines.append("1. Market Structure (18%): Breadth + Uptrend health")
    lines.append("2. Distribution Risk (18%): Market Top risk (inverted)")
    lines.append("3. Bottom Confirmation (12%): FTD Detector re-entry signal")
    lines.append("4. Macro Alignment (18%): Macro Regime positioning")
    lines.append("5. Theme Quality (12%): Theme Detector momentum")
    lines.append("6. Setup Availability (10%): VCP + CANSLIM setups")
    lines.append("7. Signal Convergence (12%): Cross-skill agreement")
    lines.append("")
    lines.append(
        "**4 Patterns:** Policy Pivot Anticipation, Unsustainable Distortion, "
        "Extreme Sentiment Contrarian, Wait & Observe"
    )
    lines.append("")

    # Disclaimer
    lines.append("---")
    lines.append("")
    lines.append(
        "**Disclaimer:** This analysis is for educational and informational purposes only. "
        "Not investment advice. Past performance does not guarantee future results. "
        "Conduct your own research and consult a financial advisor before making "
        "investment decisions."
    )
    lines.append("")

    with open(output_file, "w") as f:
        f.write("\n".join(lines))

    print(f"Markdown report saved to: {output_file}")


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


def _zone_emoji(color: str) -> str:
    mapping = {
        "green": "🟢",
        "light_green": "🟢",
        "yellow": "🟡",
        "orange": "🟠",
        "red": "🔴",
    }
    return mapping.get(color, "⚪")


def _score_bar(score: float) -> str:
    if score >= 80:
        return "████"
    elif score >= 60:
        return "███░"
    elif score >= 40:
        return "██░░"
    elif score >= 20:
        return "█░░░"
    else:
        return "░░░░"


def _alloc_bar(pct: float) -> str:
    filled = int(pct / 10)
    empty = 10 - filled
    return "█" * filled + "░" * empty


def _format_key_signal(skill: str, sig: dict) -> str:
    """Format a one-line key signal per skill."""
    if skill == "market_breadth":
        return f"Zone: {sig.get('zone', 'N/A')}"
    elif skill == "uptrend_analysis":
        return f"Zone: {sig.get('zone', 'N/A')}"
    elif skill == "market_top":
        return f"Risk: {sig.get('zone', 'N/A')}"
    elif skill == "macro_regime":
        return f"Regime: {sig.get('regime', 'N/A')} ({sig.get('confidence', 'N/A')})"
    elif skill == "ftd_detector":
        return f"State: {sig.get('state', 'N/A')}, Quality: {sig.get('quality_score', 0)}"
    elif skill == "vcp_screener":
        return f"Textbook: {sig.get('textbook_count', 0)}, Strong: {sig.get('strong_count', 0)}"
    elif skill == "theme_detector":
        return f"Hot: {sig.get('hot_count', 0)}, Exhausting: {sig.get('exhaustion_count', 0)}"
    elif skill == "canslim_screener":
        return (
            f"M Score: {sig.get('m_score', 'N/A')}, Exceptional: {sig.get('exceptional_count', 0)}"
        )
    return "N/A"


def _select_principle(zone: str, pattern: str) -> dict:
    """Select a relevant Druckenmiller quote for the current situation."""
    if zone == "Maximum Conviction":
        return {
            "quote": "The way to build long-term returns is through preservation of "
            "capital and home runs. When you have tremendous conviction on a "
            "trade, you have to go for the jugular.",
            "application": "All signals aligned. This is the moment to concentrate "
            "positions and size up aggressively.",
        }
    elif pattern == "extreme_sentiment_contrarian":
        return {
            "quote": "I've made most of my money in bear markets. The biggest "
            "opportunities come when everyone is running for the exits.",
            "application": "FTD confirmed after extreme pessimism. Consider aggressive "
            "re-entry as the bottom forms.",
        }
    elif pattern == "unsustainable_distortion":
        return {
            "quote": "It's not whether you're right or wrong that's important, "
            "but how much money you make when you're right and how much "
            "you lose when you're wrong.",
            "application": "Distribution signals mounting. Reduce exposure, tighten "
            "stops, and preserve capital for the next opportunity.",
        }
    elif zone == "Capital Preservation":
        return {
            "quote": "The first thing I heard when I got in the business was bulls "
            "make money, bears make money, and pigs get slaughtered. "
            "I'm here to tell you I was a pig.",
            "application": "Conditions are hostile. Sit on the sidelines and wait. "
            "The best trade is sometimes no trade.",
        }
    elif pattern == "policy_pivot_anticipation":
        return {
            "quote": "Earnings don't move the overall market; it's the Federal "
            "Reserve Board... focus on the central banks, and focus on "
            "the movement of liquidity.",
            "application": "Macro regime is transitioning. Position ahead of the "
            "policy pivot for asymmetric upside.",
        }
    else:
        return {
            "quote": "Don't invest in the present; invest in what you think the "
            "world will look like in 18 months.",
            "application": "Signals are mixed. Maintain discipline, stay patient, "
            "and wait for a clearer setup.",
        }

#!/usr/bin/env python3
"""
Strategy Synthesizer - Report Loader

Discovers, loads, and normalizes JSON output from 8 upstream skills.
5 required + 3 optional.

Required: market_breadth, uptrend_analysis, market_top, macro_regime, ftd_detector
Optional: vcp_screener, theme_detector, canslim_screener
"""

import glob
import json
import os
from datetime import datetime
from typing import Optional

# ---------------------------------------------------------------------------
# Skill definitions
# ---------------------------------------------------------------------------

REQUIRED_SKILLS = {
    "market_breadth": {"prefix": "market_breadth_", "role": "Market participation breadth"},
    "uptrend_analysis": {"prefix": "uptrend_analysis_", "role": "Sector uptrend ratios"},
    "market_top": {"prefix": "market_top_", "role": "Distribution / top risk (defense)"},
    "macro_regime": {"prefix": "macro_regime_", "role": "Macro regime transition (1-2Y structure)"},
    "ftd_detector": {"prefix": "ftd_detector_", "role": "Bottom confirmation / re-entry (offense)"},
}

OPTIONAL_SKILLS = {
    "vcp_screener": {"prefix": "vcp_screener_", "role": "Momentum stock setups (VCP)"},
    "theme_detector": {"prefix": "theme_detector_", "role": "Theme / sector momentum"},
    "canslim_screener": {
        "prefix": "canslim_screener_",
        "role": "Growth stock setups + M(Market Direction)",
    },
}

ALL_SKILLS = {**REQUIRED_SKILLS, **OPTIONAL_SKILLS}


# ---------------------------------------------------------------------------
# Public API
# ---------------------------------------------------------------------------


def find_latest_report(
    reports_dir: str,
    prefix: str,
    max_age_hours: float = 0,
) -> Optional[tuple[str, dict]]:
    """
    Find the most recent JSON report matching *prefix* in *reports_dir*.

    Returns (file_path, parsed_data) or None if no qualifying file found.
    Files are matched by glob and sorted by filename (timestamp order).
    If max_age_hours > 0, files older than that threshold are rejected.
    """
    pattern = os.path.join(reports_dir, f"{prefix}*.json")
    matches = sorted(glob.glob(pattern))
    if not matches:
        return None

    # Most recent = last in sorted list (filenames contain timestamps)
    for path in reversed(matches):
        if max_age_hours > 0:
            mtime = os.path.getmtime(path)
            file_age_hours = (datetime.now().timestamp() - mtime) / 3600
            if file_age_hours > max_age_hours:
                continue
        try:
            with open(path) as f:
                data = json.load(f)
            return (path, data)
        except (json.JSONDecodeError, OSError):
            continue

    return None


def load_all_reports(
    reports_dir: str,
    max_age_hours: float = 72,
) -> dict[str, dict]:
    """
    Load all upstream skill JSON reports from *reports_dir*.

    Returns dict mapping skill_name -> parsed JSON data.
    Raises ValueError if any required skill report is missing or stale.
    """
    reports = {}
    missing_required = []

    for skill_name, info in ALL_SKILLS.items():
        result = find_latest_report(reports_dir, info["prefix"], max_age_hours)
        if result is not None:
            _path, data = result
            reports[skill_name] = data
        elif skill_name in REQUIRED_SKILLS:
            missing_required.append(skill_name)

    if missing_required:
        raise ValueError(
            f"Missing required skill reports: {', '.join(missing_required)}. "
            f"Run these skills first or increase --max-age. "
            f"Searched in: {reports_dir}"
        )

    return reports


def extract_signal(skill_name: str, report_data: dict) -> dict:
    """
    Extract a normalized signal dict from a skill's JSON output.

    Each skill has its own extraction logic. For skills without a native
    composite_score (VCP, Theme, CANSLIM), a derived score is calculated.
    """
    extractors = {
        "market_breadth": _extract_breadth,
        "uptrend_analysis": _extract_uptrend,
        "market_top": _extract_market_top,
        "macro_regime": _extract_macro_regime,
        "ftd_detector": _extract_ftd,
        "vcp_screener": _extract_vcp,
        "theme_detector": _extract_theme,
        "canslim_screener": _extract_canslim,
    }
    extractor = extractors.get(skill_name)
    if extractor is None:
        raise ValueError(f"Unknown skill: {skill_name}")
    return extractor(report_data)


# ---------------------------------------------------------------------------
# Per-skill extractors
# ---------------------------------------------------------------------------


def _extract_breadth(data: dict) -> dict:
    composite = data.get("composite", {})
    return {
        "source": "market_breadth",
        "composite_score": composite.get("composite_score", 0),
        "zone": composite.get("zone", "Unknown"),
        "zone_color": composite.get("zone_color", ""),
        "exposure_guidance": composite.get("exposure_guidance", ""),
    }


def _extract_uptrend(data: dict) -> dict:
    composite = data.get("composite", {})
    warnings = composite.get("active_warnings", [])
    return {
        "source": "uptrend_analysis",
        "composite_score": composite.get("composite_score", 0),
        "zone": composite.get("zone", "Unknown"),
        "zone_color": composite.get("zone_color", ""),
        "exposure_guidance": composite.get("exposure_guidance", ""),
        "warning_flags": [w.get("flag", "") for w in warnings],
    }


def _extract_market_top(data: dict) -> dict:
    composite = data.get("composite", {})
    return {
        "source": "market_top",
        "composite_score": composite.get("composite_score", 0),
        "zone": composite.get("zone", "Unknown"),
        "zone_color": composite.get("zone_color", ""),
        "risk_budget": composite.get("risk_budget", ""),
        "strongest_warning": composite.get("strongest_warning", {}),
    }


def _extract_macro_regime(data: dict) -> dict:
    composite = data.get("composite", {})
    regime = data.get("regime", {})
    transition = regime.get("transition_probability", {})
    return {
        "source": "macro_regime",
        "composite_score": composite.get("composite_score", 0),
        "zone": composite.get("zone", "Unknown"),
        "regime": regime.get("current_regime", "unknown"),
        "regime_label": regime.get("regime_label", "Unknown"),
        "confidence": regime.get("confidence", "unknown"),
        "transition_level": transition.get("level", "unknown"),
        "transition_range": transition.get("probability_range", ""),
    }


def _extract_ftd(data: dict) -> dict:
    market_state = data.get("market_state", {})
    quality = data.get("quality_score", {})
    post_ftd = data.get("post_ftd_distribution", {})
    return {
        "source": "ftd_detector",
        "state": market_state.get("combined_state", "NO_SIGNAL"),
        "dual_confirmation": market_state.get("dual_confirmation", False),
        "ftd_index": market_state.get("ftd_index"),
        "quality_score": quality.get("total_score", 0),
        "signal": quality.get("signal", "No FTD"),
        "exposure_range": quality.get("exposure_range", "0-25%"),
        "post_ftd_distribution_count": post_ftd.get("distribution_count", 0),
    }


def _extract_vcp(data: dict) -> dict:
    """
    VCP screener lacks a composite_score. Derive one from:
    - Rating distribution: textbook*25 + strong*15 + good*10 + developing*3
    - Funnel health: trend_template_passed / universe ratio
    """
    results = data.get("results", [])
    funnel = data.get("metadata", {}).get("funnel", {})

    # Count by rating
    counts = {"textbook": 0, "strong": 0, "good": 0, "developing": 0}
    for r in results:
        rating = (r.get("rating") or "").lower()
        if "textbook" in rating:
            counts["textbook"] += 1
        elif "strong" in rating:
            counts["strong"] += 1
        elif "good" in rating:
            counts["good"] += 1
        elif "developing" in rating:
            counts["developing"] += 1

    # Weighted quality score (raw points, capped at 100)
    quality_raw = (
        counts["textbook"] * 25
        + counts["strong"] * 15
        + counts["good"] * 10
        + counts["developing"] * 3
    )
    quality_score = min(quality_raw, 100)

    # Funnel health: what % of universe passed trend template
    universe = funnel.get("universe", 1)
    tt_passed = funnel.get("trend_template_passed", 0)
    funnel_ratio = tt_passed / max(universe, 1)
    # Map funnel_ratio to 0-100: 20% pass rate = 100
    funnel_score = min(funnel_ratio / 0.20 * 100, 100)

    derived = round(quality_score * 0.6 + funnel_score * 0.4, 1)

    return {
        "source": "vcp_screener",
        "derived_score": min(derived, 100),
        "quality_score": quality_score,
        "funnel_score": round(funnel_score, 1),
        "textbook_count": counts["textbook"],
        "strong_count": counts["strong"],
        "good_count": counts["good"],
        "developing_count": counts["developing"],
        "total_candidates": len(results),
    }


def _extract_theme(data: dict) -> dict:
    """
    Theme detector lacks a composite_score. Derive one from:
    - Hot theme count (heat >= 70)
    - Early stage bonus
    - Exhaustion penalty
    """
    themes = data.get("themes", {}).get("all", [])
    summary = data.get("summary", {})
    bullish_count = summary.get("bullish_count", 0)

    hot_count = 0
    early_count = 0
    exhaustion_count = 0
    total_heat = 0

    for t in themes:
        heat = t.get("heat", 0)
        stage = (t.get("stage") or "").lower()
        direction = (t.get("direction") or "").lower()

        if direction == "bullish" and heat >= 70:
            hot_count += 1
        if stage == "early":
            early_count += 1
        if stage in ("exhausting", "exhaustion"):
            exhaustion_count += 1
        if direction == "bullish":
            total_heat += heat

    # Base score from average heat of bullish themes
    avg_heat = total_heat / max(bullish_count, 1)
    base_score = avg_heat * 0.7  # Scale to ~70 max from heat alone

    # Bonuses and penalties
    early_bonus = early_count * 5  # Up to ~25
    hot_bonus = hot_count * 3  # Up to ~15
    exhaustion_penalty = exhaustion_count * 8  # Up to ~40

    derived = round(base_score + early_bonus + hot_bonus - exhaustion_penalty, 1)
    derived = max(0, min(derived, 100))

    return {
        "source": "theme_detector",
        "derived_score": derived,
        "hot_count": hot_count,
        "early_count": early_count,
        "exhaustion_count": exhaustion_count,
        "bullish_count": bullish_count,
        "avg_heat": round(avg_heat, 1),
    }


def _extract_canslim(data: dict) -> dict:
    """
    CANSLIM screener has composite_score per stock.
    Derive overall score from top candidates + M component.
    """
    results = data.get("results", [])
    market = data.get("metadata", {}).get("market_condition", {})

    m_score = market.get("M_score", 50)
    m_trend = market.get("trend", "unknown")

    # Average composite of top 5 stocks (or fewer)
    top_scores = sorted(
        [r.get("composite_score", 0) for r in results],
        reverse=True,
    )[:5]
    avg_top = sum(top_scores) / max(len(top_scores), 1) if top_scores else 0

    # Count by quality tier
    exceptional_count = sum(1 for r in results if r.get("composite_score", 0) >= 90)
    strong_count = sum(1 for r in results if 80 <= r.get("composite_score", 0) < 90)

    # Derived score: average top quality + quality tier bonus
    tier_bonus = exceptional_count * 3 + strong_count * 1.5
    derived = round(min(avg_top * 0.7 + tier_bonus + m_score * 0.15, 100), 1)

    return {
        "source": "canslim_screener",
        "derived_score": derived,
        "m_score": m_score,
        "m_trend": m_trend,
        "top_avg_score": round(avg_top, 1),
        "exceptional_count": exceptional_count,
        "strong_count": strong_count,
        "total_candidates": len(results),
    }

#!/usr/bin/env python3
"""
Strategy Synthesizer - Conviction Scoring Engine

Combines 7 component scores into a weighted composite conviction score (0-100).
Maps to conviction zones and classifies into 4 Druckenmiller patterns.

Component Weights:
1. Market Structure:      18%  (Breadth + Uptrend)
2. Distribution Risk:     18%  (Market Top - inverted)
3. Bottom Confirmation:   12%  (FTD Detector)
4. Macro Alignment:       18%  (Macro Regime)
5. Theme Quality:         12%  (Theme Detector)
6. Setup Availability:    10%  (VCP + CANSLIM)
7. Signal Convergence:    12%  (Cross-skill agreement)
Total: 100%

Conviction Zones:
  80-100: Maximum Conviction  - Exposure: 90-100%
  60-79:  High Conviction     - Exposure: 70-90%
  40-59:  Moderate Conviction - Exposure: 50-70%
  20-39:  Low Conviction      - Exposure: 20-50%
   0-19:  Capital Preservation - Exposure: 0-20%
"""

from typing import Optional

COMPONENT_WEIGHTS = {
    "market_structure": 0.18,
    "distribution_risk": 0.18,
    "bottom_confirmation": 0.12,
    "macro_alignment": 0.18,
    "theme_quality": 0.12,
    "setup_availability": 0.10,
    "signal_convergence": 0.12,
}

COMPONENT_LABELS = {
    "market_structure": "Market Structure (Breadth + Uptrend)",
    "distribution_risk": "Distribution Risk (Market Top, inverted)",
    "bottom_confirmation": "Bottom Confirmation (FTD Detector)",
    "macro_alignment": "Macro Alignment (Regime)",
    "theme_quality": "Theme Quality (Theme Detector)",
    "setup_availability": "Setup Availability (VCP + CANSLIM)",
    "signal_convergence": "Signal Convergence (Cross-Skill Agreement)",
}


# ---------------------------------------------------------------------------
# Component calculators
# ---------------------------------------------------------------------------


def calculate_market_structure(signals: dict) -> float:
    """Breadth health * 0.5 + Uptrend health * 0.5, with divergence adjustment."""
    breadth = signals.get("market_breadth", {})
    uptrend = signals.get("uptrend_analysis", {})

    b_score = breadth.get("composite_score", 50)
    u_score = uptrend.get("composite_score", 50)

    base = b_score * 0.5 + u_score * 0.5

    # Divergence penalty: if breadth and uptrend disagree significantly
    divergence = abs(b_score - u_score)
    if divergence > 30:
        base -= (divergence - 30) * 0.3

    return max(0, min(round(base, 1), 100))


def calculate_distribution_risk(signals: dict) -> float:
    """Inverted market top score: high top risk = low conviction."""
    top = signals.get("market_top", {})
    top_score = top.get("composite_score", 0)
    return round(max(0, min(100 - top_score, 100)), 1)


def calculate_bottom_confirmation(signals: dict) -> float:
    """FTD state-based scoring for bottom confirmation / re-entry signal."""
    ftd = signals.get("ftd_detector", {})
    state = ftd.get("state", "NO_SIGNAL")
    quality = ftd.get("quality_score", 0)
    dual = ftd.get("dual_confirmation", False)
    dist_count = ftd.get("post_ftd_distribution_count", 0)

    state_scores = {
        "FTD_CONFIRMED": 80,
        "FTD_WINDOW": 60,
        "RALLY_ATTEMPT": 55,
        "NO_SIGNAL": 40,
        "CORRECTION": 35,
        "FTD_INVALIDATED": 15,
        "RALLY_FAILED": 10,
    }

    base = state_scores.get(state, 40)

    # Quality bonus for confirmed FTD
    if state == "FTD_CONFIRMED":
        quality_bonus = (quality - 50) * 0.2  # -10 to +10
        base += quality_bonus
        if dual:
            base += 5
        # Post-FTD distribution penalty
        base -= dist_count * 5

    return round(max(0, min(base, 100)), 1)


def calculate_macro_alignment(signals: dict) -> float:
    """Regime-based conviction scoring."""
    macro = signals.get("macro_regime", {})
    regime = macro.get("regime", "unknown")
    composite = macro.get("composite_score", 50)
    confidence = macro.get("confidence", "unknown")

    regime_base = {
        "broadening": 85,
        "concentration": 65,
        "transitional": 50,
        "inflationary": 35,
        "contraction": 20,
    }

    base = regime_base.get(regime, 50)

    # Adjust by transition score
    transition_adj = (composite - 50) * 0.2
    base += transition_adj

    # Confidence modifier
    confidence_mult = {"high": 1.1, "medium": 1.0, "low": 0.9}
    base *= confidence_mult.get(confidence, 1.0)

    return round(max(0, min(base, 100)), 1)


def calculate_theme_quality(signals: dict) -> float:
    """Theme-derived score with lifecycle adjustment."""
    theme = signals.get("theme_detector", {})
    derived = theme.get("derived_score", 50)
    return round(max(0, min(derived, 100)), 1)


def calculate_setup_availability(signals: dict) -> float:
    """
    VCP + CANSLIM derived scores averaged when both available.
    Fat pitch detection: exceptional setups = bonus.
    """
    vcp = signals.get("vcp_screener", {})
    canslim = signals.get("canslim_screener", {})

    scores = []
    fat_pitch_bonus = 0

    if vcp:
        scores.append(vcp.get("derived_score", 0))
        if vcp.get("textbook_count", 0) >= 2:
            fat_pitch_bonus += 10

    if canslim:
        scores.append(canslim.get("derived_score", 0))
        if canslim.get("exceptional_count", 0) >= 3:
            fat_pitch_bonus += 10

    if not scores:
        return 50.0  # Neutral default when no setup data

    base = sum(scores) / len(scores) + fat_pitch_bonus
    return round(max(0, min(base, 100)), 1)


def calculate_signal_convergence(signals: dict) -> float:
    """
    Measure agreement among the 5 required skills.
    "Ducks in a row" - Druckenmiller's key conviction criterion.
    """
    required_scores = []

    # Collect normalized bullish scores (higher = more bullish)
    breadth = signals.get("market_breadth", {})
    if breadth:
        required_scores.append(breadth.get("composite_score", 50))

    uptrend = signals.get("uptrend_analysis", {})
    if uptrend:
        required_scores.append(uptrend.get("composite_score", 50))

    top = signals.get("market_top", {})
    if top:
        # Invert: low top risk = bullish
        required_scores.append(100 - top.get("composite_score", 50))

    macro = signals.get("macro_regime", {})
    if macro:
        required_scores.append(macro.get("composite_score", 50))

    ftd = signals.get("ftd_detector", {})
    if ftd:
        required_scores.append(ftd.get("quality_score", 50))

    if len(required_scores) < 3:
        return 50.0  # Insufficient data

    # Calculate agreement: low standard deviation = high convergence
    mean = sum(required_scores) / len(required_scores)
    variance = sum((s - mean) ** 2 for s in required_scores) / len(required_scores)
    std_dev = variance**0.5

    # Convert std_dev to convergence score
    # std_dev 0 -> 100 (perfect agreement)
    # std_dev 30+ -> 0 (complete disagreement)
    convergence = max(0, 100 - std_dev * 3.33)

    # Directional adjustment based on consensus
    all_bullish = all(s > 55 for s in required_scores)
    all_bearish = all(s < 45 for s in required_scores)
    if all_bullish:
        convergence = min(convergence + 15, 100)
    elif all_bearish:
        convergence = max(convergence - 15, 0)

    return round(convergence, 1)


# ---------------------------------------------------------------------------
# Composite scorer
# ---------------------------------------------------------------------------


def calculate_composite_conviction(
    signals: dict,
    data_availability: Optional[dict[str, bool]] = None,
) -> dict:
    """
    Calculate weighted composite conviction score from extracted signals.

    Args:
        signals: Dict mapping skill_name -> extracted signal dict
        data_availability: Optional dict mapping component -> bool

    Returns:
        Dict with conviction_score, zone, exposure, guidance, etc.
    """
    if data_availability is None:
        data_availability = {}

    # Determine which optional components have real data
    has_theme = "theme_detector" in signals
    has_setup = "vcp_screener" in signals or "canslim_screener" in signals

    # Calculate each component
    raw_scores = {
        "market_structure": calculate_market_structure(signals),
        "distribution_risk": calculate_distribution_risk(signals),
        "bottom_confirmation": calculate_bottom_confirmation(signals),
        "macro_alignment": calculate_macro_alignment(signals),
        "theme_quality": calculate_theme_quality(signals),
        "setup_availability": calculate_setup_availability(signals),
        "signal_convergence": calculate_signal_convergence(signals),
    }

    # Determine availability per component
    availability = {k: True for k in COMPONENT_WEIGHTS}
    if not has_theme:
        availability["theme_quality"] = False
    if not has_setup:
        availability["setup_availability"] = False

    # Weight redistribution: proportionally allocate unavailable weight
    available_components = {k for k, v in availability.items() if v}
    base_weight_sum = sum(COMPONENT_WEIGHTS[k] for k in available_components)

    effective_weights = {}
    for k in COMPONENT_WEIGHTS:
        if k in available_components and base_weight_sum > 0:
            effective_weights[k] = COMPONENT_WEIGHTS[k] / base_weight_sum
        else:
            effective_weights[k] = 0.0

    # Weighted composite using effective weights
    composite = 0.0
    for key in COMPONENT_WEIGHTS:
        composite += raw_scores[key] * effective_weights[key]

    composite = round(composite, 1)

    # Zone interpretation
    zone_info = _interpret_conviction_zone(composite)

    # Strongest / weakest from available components only
    available_scores = {k: v for k, v in raw_scores.items() if availability[k]}
    strongest = max(available_scores, key=available_scores.get)
    weakest = min(available_scores, key=available_scores.get)

    # Data quality
    available_count = sum(1 for v in availability.values() if v)

    return {
        "conviction_score": composite,
        "zone": zone_info["zone"],
        "zone_color": zone_info["color"],
        "exposure_range": zone_info["exposure"],
        "guidance": zone_info["guidance"],
        "actions": zone_info["actions"],
        "strongest_component": {
            "component": strongest,
            "label": COMPONENT_LABELS.get(strongest, strongest),
            "score": raw_scores[strongest],
        },
        "weakest_component": {
            "component": weakest,
            "label": COMPONENT_LABELS.get(weakest, weakest),
            "score": raw_scores[weakest],
        },
        "data_quality": {
            "available_count": available_count,
            "total_components": len(COMPONENT_WEIGHTS),
        },
        "component_scores": {
            k: {
                "score": raw_scores.get(k, 0),
                "weight": w,
                "effective_weight": round(effective_weights[k], 4),
                "available": availability[k],
                "weighted_contribution": round(raw_scores.get(k, 0) * effective_weights[k], 1),
                "label": COMPONENT_LABELS[k],
            }
            for k, w in COMPONENT_WEIGHTS.items()
        },
    }


def _interpret_conviction_zone(composite: float) -> dict:
    """Map composite conviction to zone."""
    if composite >= 80:
        return {
            "zone": "Maximum Conviction",
            "color": "green",
            "exposure": "90-100%",
            "guidance": "All signals aligned. Druckenmiller 'fat pitch' - swing hard.",
            "actions": [
                "Maximum equity exposure (90-100%)",
                "Concentrated positions in strongest setups",
                "Aggressive position sizing on breakouts",
                "Use leverage selectively on highest-conviction ideas",
            ],
        }
    elif composite >= 60:
        return {
            "zone": "High Conviction",
            "color": "light_green",
            "exposure": "70-90%",
            "guidance": "Multiple signals confirm. Strong equity posture, standard risk management.",
            "actions": [
                "Above-average equity allocation (70-90%)",
                "Standard position sizing on quality setups",
                "New entries on VCP/CANSLIM signals",
                "Maintain stop-losses at normal levels",
            ],
        }
    elif composite >= 40:
        return {
            "zone": "Moderate Conviction",
            "color": "yellow",
            "exposure": "50-70%",
            "guidance": "Mixed signals. Maintain exposure but reduce position sizes.",
            "actions": [
                "Moderate equity allocation (50-70%)",
                "Reduced position sizes (half normal)",
                "Only A-grade setups",
                "Tighter stop-losses",
                "Raise cash allocation to 30-50%",
            ],
        }
    elif composite >= 20:
        return {
            "zone": "Low Conviction",
            "color": "orange",
            "exposure": "20-50%",
            "guidance": "Unclear outlook. Preserve capital, minimal new risk.",
            "actions": [
                "Defensive posture (20-50% equity)",
                "No new entries except rare opportunities",
                "Profit-taking on weaker positions",
                "High cash allocation (50-80%)",
                "Monitor for signal improvement",
            ],
        }
    else:
        return {
            "zone": "Capital Preservation",
            "color": "red",
            "exposure": "0-20%",
            "guidance": "Extreme caution. Druckenmiller: 'When you don't see it, don't swing.'",
            "actions": [
                "Maximum defensive posture (0-20% equity)",
                "Close most positions",
                "High cash / Treasuries / Gold",
                "Watch for FTD signal for re-entry",
                "Preserve capital as primary objective",
            ],
        }


# ---------------------------------------------------------------------------
# Pattern classification
# ---------------------------------------------------------------------------

PATTERN_DEFINITIONS = {
    "policy_pivot_anticipation": {
        "label": "Policy Pivot Anticipation",
        "description": "Central bank policy at inflection point. Market hasn't priced the turn.",
    },
    "unsustainable_distortion": {
        "label": "Unsustainable Distortion",
        "description": "Market structure is fragile. Distribution signals + macro contraction.",
    },
    "extreme_sentiment_contrarian": {
        "label": "Extreme Sentiment Contrarian",
        "description": "Bottom confirmed after extreme bearishness. Druckenmiller's bear market profit.",
    },
    "wait_and_observe": {
        "label": "Wait & Observe",
        "description": "Mixed signals, unclear direction. Preserve capital, wait for clarity.",
    },
}


def classify_pattern(signals: dict, component_scores: dict, conviction_score: float) -> dict:
    """
    Classify the current market into one of 4 Druckenmiller patterns.
    Returns the best-matching pattern with match strength.
    """
    macro = signals.get("macro_regime", {})
    top = signals.get("market_top", {})
    ftd = signals.get("ftd_detector", {})
    breadth = signals.get("market_breadth", {})

    regime = macro.get("regime", "unknown")
    transition_level = macro.get("transition_level", "unknown")
    top_score = top.get("composite_score", 0)
    ftd_state = ftd.get("state", "NO_SIGNAL")
    ftd_quality = ftd.get("quality_score", 0)
    breadth_score = breadth.get("composite_score", 50)

    pattern_scores = {}

    # Pattern 1: Policy Pivot Anticipation
    p1 = 0
    if regime == "transitional":
        p1 += 40
    if transition_level in ("high", "moderate"):
        p1 += 25
    if top_score < 40:  # No imminent top
        p1 += 15
    macro_composite = macro.get("composite_score", 0)
    if macro_composite >= 50:
        p1 += 20
    pattern_scores["policy_pivot_anticipation"] = min(p1, 100)

    # Pattern 2: Unsustainable Distortion
    p2 = 0
    if top_score >= 60:
        p2 += 35
    if regime in ("contraction", "inflationary"):
        p2 += 30
    theme = signals.get("theme_detector", {})
    if theme.get("exhaustion_count", 0) >= 2:
        p2 += 20
    if breadth_score < 40:
        p2 += 15
    pattern_scores["unsustainable_distortion"] = min(p2, 100)

    # Pattern 3: Extreme Sentiment Contrarian (FTD-driven)
    p3 = 0
    if ftd_state == "FTD_CONFIRMED":
        p3 += 40
        if ftd_quality >= 70:
            p3 += 15
    if top_score >= 70:
        p3 += 20  # Came from high top risk
    if breadth_score < 35:
        p3 += 15  # Extreme pessimism in breadth
    convergence = component_scores.get("signal_convergence", {})
    conv_score = convergence.get("score", 50) if isinstance(convergence, dict) else convergence
    if conv_score < 30:  # Bearish convergence that's now reversing
        p3 += 10
    pattern_scores["extreme_sentiment_contrarian"] = min(p3, 100)

    # Pattern 4: Wait & Observe (default when nothing strong)
    p4 = 0
    if conviction_score < 40:
        p4 += 40
    # Mixed signals indicator
    scores_list = [
        v.get("score", 50) if isinstance(v, dict) else 50 for v in component_scores.values()
    ]
    if scores_list:
        spread = max(scores_list) - min(scores_list)
        if spread > 40:
            p4 += 30
    if regime == "transitional" and top_score >= 40 and top_score <= 60:
        p4 += 20
    pattern_scores["wait_and_observe"] = min(p4, 100)

    # Select best pattern
    best_pattern = max(pattern_scores, key=pattern_scores.get)
    best_score = pattern_scores[best_pattern]

    # If no strong match, default to wait_and_observe
    if best_score < 40:
        best_pattern = "wait_and_observe"
        best_score = max(best_score, 50)

    definition = PATTERN_DEFINITIONS[best_pattern]

    return {
        "pattern": best_pattern,
        "label": definition["label"],
        "description": definition["description"],
        "match_strength": best_score,
        "all_pattern_scores": pattern_scores,
    }

#!/usr/bin/env python3
"""
Druckenmiller Strategy Synthesizer - Main Orchestrator

Integrates outputs from 8 upstream analysis skills (5 required + 3 optional)
into a unified conviction score, pattern classification, and allocation
recommendation based on Stanley Druckenmiller's investment philosophy.

Usage:
    python3 strategy_synthesizer.py --reports-dir reports/
    python3 strategy_synthesizer.py --reports-dir reports/ --output-dir reports/ --max-age 72

Output:
    - JSON: druckenmiller_strategy_YYYY-MM-DD_HHMMSS.json
    - Markdown: druckenmiller_strategy_YYYY-MM-DD_HHMMSS.md
"""

import argparse
import os
import sys
from datetime import datetime

# Add parent directory to path for imports
sys.path.insert(0, os.path.dirname(__file__))

from allocation_engine import calculate_position_sizing, generate_allocation
from report_generator import generate_json_report, generate_markdown_report
from report_loader import OPTIONAL_SKILLS, REQUIRED_SKILLS, extract_signal, load_all_reports
from scorer import calculate_composite_conviction, classify_pattern


def parse_arguments():
    parser = argparse.ArgumentParser(
        description="Druckenmiller Strategy Synthesizer - Meta-Skill Orchestrator"
    )
    parser.add_argument(
        "--reports-dir",
        default="reports/",
        help="Directory containing upstream skill JSON reports (default: reports/)",
    )
    parser.add_argument(
        "--output-dir", default="reports/", help="Directory for output reports (default: reports/)"
    )
    parser.add_argument(
        "--max-age",
        type=float,
        default=72,
        help="Maximum age (hours) for input reports (default: 72)",
    )
    return parser.parse_args()


def main():
    args = parse_arguments()

    print("=" * 70)
    print("Druckenmiller Strategy Synthesizer")
    print("8-Skill Integration | Conviction Scoring | Pattern Classification")
    print("=" * 70)
    print()

    # Ensure output directory exists
    os.makedirs(args.output_dir, exist_ok=True)

    # ========================================================================
    # Step 1: Load Input Reports
    # ========================================================================
    print("Step 1: Loading Input Reports")
    print("-" * 70)

    try:
        reports = load_all_reports(args.reports_dir, max_age_hours=args.max_age)
    except ValueError as e:
        print(f"ERROR: {e}", file=sys.stderr)
        sys.exit(1)

    required_count = sum(1 for k in reports if k in REQUIRED_SKILLS)
    optional_count = sum(1 for k in reports if k in OPTIONAL_SKILLS)
    print(
        f"  Loaded {len(reports)} reports ({required_count} required + {optional_count} optional)"
    )

    for skill_name in reports:
        marker = "REQ" if skill_name in REQUIRED_SKILLS else "OPT"
        print(f"  [{marker}] {skill_name}")
    print()

    # ========================================================================
    # Step 2: Extract Signals
    # ========================================================================
    print("Step 2: Extracting Normalized Signals")
    print("-" * 70)

    signals = {}
    for skill_name, report_data in reports.items():
        sig = extract_signal(skill_name, report_data)
        signals[skill_name] = sig

        # Print key metric per skill
        if "composite_score" in sig:
            print(f"  {skill_name}: score={sig['composite_score']}")
        elif "derived_score" in sig:
            print(f"  {skill_name}: derived={sig['derived_score']}")
        elif "quality_score" in sig:
            print(
                f"  {skill_name}: quality={sig['quality_score']}, state={sig.get('state', 'N/A')}"
            )

    print()

    # ========================================================================
    # Step 3: Calculate Composite Conviction
    # ========================================================================
    print("Step 3: Calculating Composite Conviction")
    print("-" * 70)

    conviction = calculate_composite_conviction(signals)
    score = conviction["conviction_score"]
    zone = conviction["zone"]

    print(f"  Conviction Score: {score}/100")
    print(f"  Zone: {zone}")
    print(f"  Exposure Range: {conviction['exposure_range']}")
    print(
        f"  Strongest: {conviction['strongest_component']['label']} "
        f"({conviction['strongest_component']['score']})"
    )
    print(
        f"  Weakest: {conviction['weakest_component']['label']} "
        f"({conviction['weakest_component']['score']})"
    )
    print()

    # ========================================================================
    # Step 4: Classify Pattern
    # ========================================================================
    print("Step 4: Pattern Classification")
    print("-" * 70)

    pattern = classify_pattern(signals, conviction["component_scores"], score)
    print(f"  Pattern: {pattern['label']} (match: {pattern['match_strength']}%)")
    print(f"  Description: {pattern['description']}")
    print()

    # ========================================================================
    # Step 5: Generate Allocation
    # ========================================================================
    print("Step 5: Generating Target Allocation")
    print("-" * 70)

    regime = signals.get("macro_regime", {}).get("regime", "transitional")
    target_alloc = generate_allocation(
        conviction_score=score,
        zone=zone,
        pattern=pattern["pattern"],
        regime=regime,
    )
    sizing = calculate_position_sizing(conviction_score=score, zone=zone)

    print(f"  Equity: {target_alloc['equity']}%")
    print(f"  Bonds: {target_alloc['bonds']}%")
    print(f"  Alternatives: {target_alloc['alternatives']}%")
    print(f"  Cash: {target_alloc['cash']}%")
    print(f"  Max Single Position: {sizing['max_single_position']}%")
    print()

    # ========================================================================
    # Step 6: Generate Reports
    # ========================================================================
    print("Step 6: Generating Reports")
    print("-" * 70)

    analysis = {
        "metadata": {
            "generated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "reports_dir": args.reports_dir,
            "max_age_hours": args.max_age,
            "skills_loaded": len(reports),
            "required_count": required_count,
            "optional_count": optional_count,
            "skills_list": list(reports.keys()),
        },
        "conviction": conviction,
        "pattern": pattern,
        "allocation": {
            "target": target_alloc,
            "regime": regime,
            "pattern": pattern["pattern"],
            "zone": zone,
        },
        "position_sizing": sizing,
        "input_summary": signals,
    }

    timestamp = datetime.now().strftime("%Y-%m-%d_%H%M%S")
    json_file = os.path.join(args.output_dir, f"druckenmiller_strategy_{timestamp}.json")
    md_file = os.path.join(args.output_dir, f"druckenmiller_strategy_{timestamp}.md")

    generate_json_report(analysis, json_file)
    generate_markdown_report(analysis, md_file)

    print()
    print("=" * 70)
    print("Strategy Synthesis Complete")
    print("=" * 70)
    print(f"  Conviction: {score}/100 ({zone})")
    print(f"  Pattern: {pattern['label']}")
    print(f"  Equity Target: {target_alloc['equity']}%")
    print(f"  JSON: {json_file}")
    print(f"  Markdown: {md_file}")
    print()


if __name__ == "__main__":
    main()