Scenario War Room

#!/usr/bin/env python3
"""Decision Tree Analyzer - Build and evaluate decision trees with expected value calculations.

Models strategic decisions with multiple options, each having probability of success,
upside value, and downside cost. Calculates expected value to guide decision-making.

Usage:
    python decision_tree_analyzer.py --decision "Enter Japan market" --option "Direct:0.6:2000000:-500000" --option "Partnership:0.75:1000000:-200000" --option "Wait:1.0:0:0"
    python decision_tree_analyzer.py --decision "Acquire CompanyX" --option "Full acquisition:0.7:5000000:-2000000" --option "Acqui-hire:0.85:1500000:-500000" --option "Build internally:0.5:3000000:-800000" --json
"""

import argparse
import json
import sys
from datetime import datetime


def parse_option(option_str):
    """Parse option in format 'name:probability_success:upside:downside'."""
    parts = option_str.split(":")
    if len(parts) < 4:
        print(f"Error: Option must be 'name:probability:upside:downside'. Got: {option_str}", file=sys.stderr)
        sys.exit(1)
    return {
        "name": parts[0].strip(),
        "probability_success": float(parts[1]),
        "upside": float(parts[2]),
        "downside": float(parts[3])
    }


def analyze_decision(decision_name, options):
    """Analyze all options and compute expected values."""
    analyzed = []

    for opt in options:
        p_success = opt["probability_success"]
        p_failure = 1 - p_success
        upside = opt["upside"]
        downside = opt["downside"]

        expected_value = round(p_success * upside + p_failure * downside)
        expected_upside = round(p_success * upside)
        expected_downside = round(p_failure * downside)
        risk_reward_ratio = round(abs(upside / downside), 2) if downside != 0 else float('inf')
        max_regret = abs(downside)

        analyzed.append({
            "name": opt["name"],
            "probability_success": f"{int(p_success * 100)}%",
            "probability_success_raw": p_success,
            "upside": upside,
            "downside": downside,
            "expected_value": expected_value,
            "expected_upside": expected_upside,
            "expected_downside": expected_downside,
            "risk_reward_ratio": risk_reward_ratio,
            "max_regret": max_regret,
            "reversible": abs(downside) < 100000  # Heuristic
        })

    # Sort by expected value (best first)
    analyzed.sort(key=lambda x: -x["expected_value"])

    # Determine recommendation
    best_ev = analyzed[0]
    lowest_risk = min(analyzed, key=lambda x: x["max_regret"])
    highest_upside = max(analyzed, key=lambda x: x["upside"])

    # Sensitivity check: how much would probability need to change to change the ranking?
    sensitivity = []
    if len(analyzed) >= 2:
        first = analyzed[0]
        second = analyzed[1]
        # At what probability does the second option become better?
        # EV1 = p1 * up1 + (1-p1) * down1
        # EV2 = p2 * up2 + (1-p2) * down2
        # We vary p1: find p where EV1 = EV2_current
        ev2 = second["expected_value"]
        up1 = first["upside"]
        down1 = first["downside"]
        if up1 != down1:
            breakeven_p = (ev2 - down1) / (up1 - down1)
            if 0 <= breakeven_p <= 1:
                sensitivity.append({
                    "insight": f"If '{first['name']}' success probability drops to {int(breakeven_p * 100)}%, '{second['name']}' becomes the better option",
                    "current_probability": first["probability_success"],
                    "breakeven_probability": f"{int(breakeven_p * 100)}%",
                    "margin": f"{int((first['probability_success_raw'] - breakeven_p) * 100)} percentage points"
                })

    return {
        "analysis_date": datetime.now().strftime("%Y-%m-%d"),
        "decision": decision_name,
        "options_analyzed": len(analyzed),
        "options": analyzed,
        "recommendation": {
            "best_expected_value": {"option": best_ev["name"], "ev": best_ev["expected_value"]},
            "lowest_risk": {"option": lowest_risk["name"], "max_regret": lowest_risk["max_regret"]},
            "highest_upside": {"option": highest_upside["name"], "upside": highest_upside["upside"]}
        },
        "sensitivity": sensitivity,
        "decision_framework": {
            "if_reversible": f"Go with '{best_ev['name']}' (highest EV). Speed matters more than perfection for reversible decisions.",
            "if_irreversible": f"Consider '{lowest_risk['name']}' (lowest regret) unless EV difference with '{best_ev['name']}' justifies the risk.",
            "if_constrained": f"'{lowest_risk['name']}' minimizes downside exposure."
        }
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"DECISION TREE ANALYSIS: {result['decision']}")
    print(f"Date: {result['analysis_date']}")
    print(f"{'='*70}\n")

    print("OPTIONS (ranked by Expected Value):")
    print("-" * 70)
    for i, opt in enumerate(result["options"], 1):
        ev_bar_width = max(0, min(20, int(opt["expected_value"] / max(abs(o["expected_value"]) for o in result["options"]) * 20))) if any(o["expected_value"] != 0 for o in result["options"]) else 0
        ev_bar = "#" * ev_bar_width

        print(f"\n  {i}. {opt['name']}")
        print(f"     Success Probability: {opt['probability_success']}")
        print(f"     Upside:   ${opt['upside']:>12,}")
        print(f"     Downside: ${opt['downside']:>12,}")
        print(f"     Expected Value: ${opt['expected_value']:>10,}  {ev_bar}")
        print(f"     Risk/Reward: {opt['risk_reward_ratio']}x  |  Max Regret: ${opt['max_regret']:,}")

    rec = result["recommendation"]
    print(f"\nRECOMMENDATION:")
    print("-" * 50)
    print(f"  Best EV:       {rec['best_expected_value']['option']} (EV: ${rec['best_expected_value']['ev']:,})")
    print(f"  Lowest Risk:   {rec['lowest_risk']['option']} (Max Regret: ${rec['lowest_risk']['max_regret']:,})")
    print(f"  Highest Upside: {rec['highest_upside']['option']} (${rec['highest_upside']['upside']:,})")

    df = result["decision_framework"]
    print(f"\nDECISION FRAMEWORK:")
    print(f"  If reversible:   {df['if_reversible']}")
    print(f"  If irreversible: {df['if_irreversible']}")
    print(f"  If constrained:  {df['if_constrained']}")

    if result["sensitivity"]:
        print(f"\nSENSITIVITY ANALYSIS:")
        for s in result["sensitivity"]:
            print(f"  {s['insight']}")
            print(f"    Current: {s['current_probability']}  |  Breakeven: {s['breakeven_probability']}  |  Margin: {s['margin']}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Build and evaluate decision trees with expected value")
    parser.add_argument("--decision", required=True, help="Decision being analyzed")
    parser.add_argument("--option", action="append", required=True,
                        help="Option in format 'name:probability_success:upside:downside' (multiple allowed)")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    if len(args.option) < 2:
        print("Error: At least 2 options required for meaningful comparison", file=sys.stderr)
        sys.exit(1)

    options = [parse_option(o) for o in args.option]
    result = analyze_decision(args.decision, options)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Impact Matrix Calculator - Calculate compound impact across multiple risk variables.

Models compound risk when multiple adverse events co-occur. Calculates expected value,
worst-case scenarios, and cascade risk scores for strategic decision-making.

Usage:
    python impact_matrix_calculator.py --variables "churn:500000:0.2" "fundraise_delay:0:0.3" "key_departure:0:0.15" --arr 2000000 --runway-months 14
    python impact_matrix_calculator.py --variables "market_shift:300000:0.25" "pricing_pressure:200000:0.35" --arr 5000000 --runway-months 18 --json
"""

import argparse
import json
import sys
from datetime import datetime
from itertools import combinations


def parse_variable(var_str):
    """Parse 'name:impact:probability' format."""
    parts = var_str.split(":")
    if len(parts) < 3:
        print(f"Error: Variable must be in format 'name:impact:probability'. Got: {var_str}", file=sys.stderr)
        sys.exit(1)
    return {
        "name": parts[0].strip(),
        "impact": float(parts[1]),
        "probability": float(parts[2])
    }


def calculate_combinations(variables):
    """Calculate all possible combinations of variables occurring."""
    combos = []

    # Individual variables
    for v in variables:
        combos.append({
            "variables": [v["name"]],
            "combined_probability": v["probability"],
            "total_impact": v["impact"],
            "severity": "base"
        })

    # Pairs
    if len(variables) >= 2:
        for pair in combinations(variables, 2):
            combined_prob = pair[0]["probability"] * pair[1]["probability"]
            total_impact = sum(p["impact"] for p in pair)
            # Cascade multiplier: compound events are worse than sum of parts
            cascade_multiplier = 1.3
            combos.append({
                "variables": [p["name"] for p in pair],
                "combined_probability": round(combined_prob, 4),
                "total_impact": round(total_impact * cascade_multiplier),
                "cascade_multiplier": cascade_multiplier,
                "severity": "stress"
            })

    # All three
    if len(variables) >= 3:
        combined_prob = 1.0
        for v in variables:
            combined_prob *= v["probability"]
        total_impact = sum(v["impact"] for v in variables)
        cascade_multiplier = 1.6  # Full cascade is significantly worse
        combos.append({
            "variables": [v["name"] for v in variables],
            "combined_probability": round(combined_prob, 4),
            "total_impact": round(total_impact * cascade_multiplier),
            "cascade_multiplier": cascade_multiplier,
            "severity": "severe"
        })

    return combos


def calculate_expected_values(variables, combos, arr, runway_months):
    """Calculate expected values and risk-adjusted impacts."""
    monthly_burn = arr / 12 * 1.5 if arr > 0 else 50000

    # Expected value (probability-weighted average impact)
    expected_value = sum(v["impact"] * v["probability"] for v in variables)

    # Risk-adjusted scenarios
    scenarios = []
    for combo in combos:
        runway_impact = combo["total_impact"] / monthly_burn if monthly_burn > 0 else 0
        new_runway = runway_months - runway_impact

        scenarios.append({
            "variables": combo["variables"],
            "severity": combo["severity"],
            "probability": f"{combo['combined_probability'] * 100:.1f}%",
            "probability_raw": combo["combined_probability"],
            "total_impact": combo["total_impact"],
            "arr_impact_pct": round(combo["total_impact"] / arr * 100, 1) if arr > 0 else 0,
            "runway_change": round(-runway_impact, 1),
            "new_runway": round(new_runway, 1),
            "existential": new_runway < 6,
            "expected_value": round(combo["total_impact"] * combo["combined_probability"])
        })

    # Risk score (0-100)
    max_impact = max(c["total_impact"] for c in combos) if combos else 0
    max_prob = max(v["probability"] for v in variables) if variables else 0
    risk_score = round(min(100, (max_impact / arr * 50 if arr > 0 else 50) + (max_prob * 50)))

    # Determine risk level
    if risk_score >= 70:
        risk_level = "CRITICAL"
    elif risk_score >= 50:
        risk_level = "HIGH"
    elif risk_score >= 30:
        risk_level = "MODERATE"
    else:
        risk_level = "LOW"

    return {
        "calculation_date": datetime.now().strftime("%Y-%m-%d"),
        "inputs": {
            "variables": [{"name": v["name"], "impact": v["impact"], "probability": f"{v['probability']*100:.0f}%"} for v in variables],
            "arr": arr,
            "runway_months": runway_months,
            "estimated_monthly_burn": round(monthly_burn)
        },
        "expected_value": round(expected_value),
        "expected_value_pct_arr": round(expected_value / arr * 100, 1) if arr > 0 else 0,
        "risk_score": risk_score,
        "risk_level": risk_level,
        "worst_case_impact": max_impact,
        "worst_case_pct_arr": round(max_impact / arr * 100, 1) if arr > 0 else 0,
        "scenarios": sorted(scenarios, key=lambda s: -s["total_impact"]),
        "key_insights": generate_insights(variables, scenarios, arr, runway_months, risk_level)
    }


def generate_insights(variables, scenarios, arr, runway_months, risk_level):
    insights = []

    existential = [s for s in scenarios if s.get("existential")]
    if existential:
        insights.append(f"EXISTENTIAL RISK: {len(existential)} scenario(s) reduce runway below 6 months")

    high_prob = [v for v in variables if v["probability"] > 0.25]
    if high_prob:
        insights.append(f"HIGH PROBABILITY: {', '.join(v['name'] for v in high_prob)} have >25% likelihood")

    high_impact = [v for v in variables if arr > 0 and v["impact"] / arr > 0.15]
    if high_impact:
        insights.append(f"HIGH IMPACT: {', '.join(v['name'] for v in high_impact)} would affect >15% of ARR")

    if risk_level in ("CRITICAL", "HIGH"):
        insights.append("Recommend immediate war room session with full leadership team")
        insights.append("Implement hedging strategies before next board meeting")

    return insights


def print_human(result):
    print(f"\n{'='*70}")
    print(f"IMPACT MATRIX ANALYSIS")
    print(f"Date: {result['calculation_date']}")
    print(f"{'='*70}\n")

    inp = result["inputs"]
    print(f"Context: ARR ${inp['arr']:,}  |  Runway: {inp['runway_months']} months  |  Burn: ${inp['estimated_monthly_burn']:,}/mo\n")

    print(f"RISK SCORE: {result['risk_score']}/100 ({result['risk_level']})")
    print(f"Expected Value of Loss: ${result['expected_value']:,} ({result['expected_value_pct_arr']}% of ARR)")
    print(f"Worst Case Impact: ${result['worst_case_impact']:,} ({result['worst_case_pct_arr']}% of ARR)\n")

    print("INPUT VARIABLES:")
    print("-" * 50)
    for v in result["inputs"]["variables"]:
        print(f"  {v['name']:<30s} Impact: ${v['impact']:>10,}  Prob: {v['probability']}")

    print(f"\nSCENARIO MATRIX:")
    print("-" * 70)
    for s in result["scenarios"]:
        existential_flag = " [EXISTENTIAL]" if s.get("existential") else ""
        print(f"  [{s['severity'].upper():<8s}] {' + '.join(s['variables'])}")
        print(f"    Probability: {s['probability']:>6s}  Impact: ${s['total_impact']:>10,}  Runway: {s['new_runway']:>5.1f}mo  EV: ${s['expected_value']:>8,}{existential_flag}")

    if result["key_insights"]:
        print(f"\nKEY INSIGHTS:")
        for i in result["key_insights"]:
            print(f"  -> {i}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Calculate compound risk impact across multiple variables")
    parser.add_argument("--variables", nargs="+", required=True, help="Variables in format 'name:impact:probability'")
    parser.add_argument("--arr", type=float, required=True, help="Current ARR ($)")
    parser.add_argument("--runway-months", type=float, required=True, help="Current runway in months")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    variables = [parse_variable(v) for v in args.variables]
    if len(variables) > 3:
        print("Warning: Maximum 3 variables. Using first 3.", file=sys.stderr)
        variables = variables[:3]

    combos = calculate_combinations(variables)
    result = calculate_expected_values(variables, combos, args.arr, args.runway_months)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Scenario Builder - Build structured scenarios with variables, probabilities, and severity levels.

Creates war room scenarios following the 6-step cascade model with variables,
detection signals, severity matrix, and hedge recommendations.

Usage:
    python scenario_builder.py --name "Customer Concentration Risk" --variable "Top customer churns" --probability 20 --impact 500000 --timeline 90
    python scenario_builder.py --name "Fundraise Risk" --variable "Series A delayed 6 months:0.3:0:180" --variable "Key engineer leaves:0.15:100000:60" --variable "Competitor raises $50M:0.25:0:90" --arr 2000000 --runway-months 14 --json
"""

import argparse
import json
import sys
from datetime import datetime

CASCADE_PATTERNS = {
    "revenue_death_spiral": {
        "name": "Revenue-to-Runway Death Spiral",
        "pattern": "Customer churn -> lower runway -> hiring freeze -> slower product -> more churn",
        "interruption": "Emergency revenue diversification or bridge financing"
    },
    "key_person_cascade": {
        "name": "Key Person Cascade",
        "pattern": "Star leaves -> team morale drops -> followers leave -> velocity collapses",
        "interruption": "Retention bonuses before departure, succession planning"
    },
    "market_squeeze": {
        "name": "Market Squeeze",
        "pattern": "Competitor raises -> price war -> margins compress -> can't invest in product",
        "interruption": "Differentiation (not price matching), niche down"
    },
    "trust_cascade": {
        "name": "Trust Cascade",
        "pattern": "Incident -> customer concern -> churn -> press -> more churn",
        "interruption": "Swift, transparent communication"
    },
    "fundraise_burn_spiral": {
        "name": "Fundraise-Burn Spiral",
        "pattern": "Miss target -> raise delayed -> bridge at bad terms -> burn cuts -> team loss",
        "interruption": "Parallel fundraise tracks, pre-negotiated bridge terms"
    }
}


def parse_variable(var_str, default_probability=0.2, default_impact=0, default_timeline=90):
    """Parse variable string in format 'description:probability:impact:timeline_days' or just 'description'."""
    parts = var_str.split(":")
    desc = parts[0].strip()
    prob = float(parts[1]) if len(parts) > 1 else default_probability
    impact = float(parts[2]) if len(parts) > 2 else default_impact
    timeline = int(parts[3]) if len(parts) > 3 else default_timeline
    return {"description": desc, "probability": prob, "impact": impact, "timeline_days": timeline}


def identify_cascade_patterns(variables):
    """Identify likely cascade patterns based on variable descriptions."""
    patterns = []
    descriptions = " ".join(v["description"].lower() for v in variables)

    if any(word in descriptions for word in ["churn", "customer", "cancel", "terminate"]):
        patterns.append(CASCADE_PATTERNS["revenue_death_spiral"])
    if any(word in descriptions for word in ["leave", "depart", "quit", "engineer", "key person"]):
        patterns.append(CASCADE_PATTERNS["key_person_cascade"])
    if any(word in descriptions for word in ["competitor", "raise", "funding", "market"]):
        patterns.append(CASCADE_PATTERNS["market_squeeze"])
    if any(word in descriptions for word in ["incident", "breach", "security", "trust"]):
        patterns.append(CASCADE_PATTERNS["trust_cascade"])
    if any(word in descriptions for word in ["fundraise", "series", "round", "investor"]):
        patterns.append(CASCADE_PATTERNS["fundraise_burn_spiral"])

    return patterns if patterns else [CASCADE_PATTERNS["revenue_death_spiral"]]


def build_scenario(name, variables, arr, runway_months):
    if len(variables) > 3:
        print("Warning: Maximum 3 variables recommended. Using first 3.", file=sys.stderr)
        variables = variables[:3]

    # Calculate severity levels
    total_impact = sum(v["impact"] for v in variables)
    monthly_burn = arr / 12 * 1.5 if arr > 0 else 50000  # Estimate burn from ARR

    # Base scenario (1 variable hits)
    base = {
        "name": "Base (single shock)",
        "variables_hit": 1,
        "arr_impact": variables[0]["impact"] if variables else 0,
        "arr_impact_pct": round(variables[0]["impact"] / arr * 100, 1) if arr > 0 and variables else 0,
        "runway_impact_months": round(variables[0]["impact"] / monthly_burn, 1) if monthly_burn > 0 and variables else 0,
        "new_runway": round(runway_months - (variables[0]["impact"] / monthly_burn), 1) if monthly_burn > 0 and variables else runway_months,
        "recovery": "Manageable with prepared response"
    }

    # Stress scenario (2 variables)
    stress_impact = sum(v["impact"] for v in variables[:2])
    stress = {
        "name": "Stress (compound shock)",
        "variables_hit": min(2, len(variables)),
        "arr_impact": stress_impact,
        "arr_impact_pct": round(stress_impact / arr * 100, 1) if arr > 0 else 0,
        "runway_impact_months": round(stress_impact / monthly_burn, 1) if monthly_burn > 0 else 0,
        "new_runway": round(runway_months - (stress_impact / monthly_burn), 1) if monthly_burn > 0 else runway_months,
        "recovery": "Requires significant pivot, board involvement"
    }

    # Severe scenario (all variables)
    severe = {
        "name": "Severe (full cascade)",
        "variables_hit": len(variables),
        "arr_impact": total_impact,
        "arr_impact_pct": round(total_impact / arr * 100, 1) if arr > 0 else 0,
        "runway_impact_months": round(total_impact / monthly_burn, 1) if monthly_burn > 0 else 0,
        "new_runway": round(runway_months - (total_impact / monthly_burn), 1) if monthly_burn > 0 else runway_months,
        "existential": severe_new_runway < 6 if (severe_new_runway := round(runway_months - (total_impact / monthly_burn), 1) if monthly_burn > 0 else runway_months) else False,
        "recovery": "Emergency action required, board intervention"
    }

    # Cascade patterns
    cascade_patterns = identify_cascade_patterns(variables)

    # Early warning signals
    signals = []
    for v in variables:
        signals.append({
            "variable": v["description"],
            "signal": f"Monitor for early indicators of: {v['description']}",
            "threshold": f"Probability rises above {int(v['probability'] * 100 + 10)}%",
            "response_window": f"{max(7, v['timeline_days'] // 4)} days to respond"
        })

    # Hedges
    hedges = []
    if any(v["impact"] > 0 for v in variables):
        hedges.append({"hedge": "Establish credit line or bridge financing option", "cost": "$5K-15K/year", "protects_against": "Runway shortfall", "owner": "CFO", "deadline": "60 days"})
    if any("key" in v["description"].lower() or "leave" in v["description"].lower() or "engineer" in v["description"].lower() for v in variables):
        hedges.append({"hedge": "Retention bonuses for critical team members", "cost": "$50K-150K", "protects_against": "Key person departure", "owner": "CHRO", "deadline": "30 days"})
    if any("customer" in v["description"].lower() or "churn" in v["description"].lower() for v in variables):
        hedges.append({"hedge": "Diversify revenue concentration below 20% per customer", "cost": "Sales effort", "protects_against": "Customer concentration risk", "owner": "CRO", "deadline": "2 quarters"})
    if any("fundraise" in v["description"].lower() or "series" in v["description"].lower() for v in variables):
        hedges.append({"hedge": "Pre-negotiate bridge terms with existing investors", "cost": "CEO time", "protects_against": "Fundraise delay", "owner": "CEO", "deadline": "45 days"})
    if not hedges:
        hedges.append({"hedge": "Document contingency response plan", "cost": "Leadership time", "protects_against": "General preparedness", "owner": "COO", "deadline": "30 days"})

    return {
        "scenario_date": datetime.now().strftime("%Y-%m-%d"),
        "scenario_name": name,
        "review_date": (datetime.now().replace(month=datetime.now().month % 12 + 1) if datetime.now().month < 12
                        else datetime.now().replace(year=datetime.now().year + 1, month=1)).strftime("%Y-%m-%d"),
        "company_context": {
            "arr": arr,
            "runway_months": runway_months,
            "estimated_monthly_burn": round(monthly_burn)
        },
        "variables": [
            {
                "id": chr(65 + i),
                "description": v["description"],
                "probability": f"{int(v['probability'] * 100)}%",
                "probability_raw": v["probability"],
                "impact": v["impact"],
                "timeline_days": v["timeline_days"]
            }
            for i, v in enumerate(variables)
        ],
        "severity_matrix": {
            "base": base,
            "stress": stress,
            "severe": severe
        },
        "cascade_patterns": [{"name": p["name"], "pattern": p["pattern"], "interruption_point": p["interruption"]} for p in cascade_patterns],
        "early_warning_signals": signals,
        "hedges": hedges,
        "ground_rules": [
            "Maximum 3 variables per scenario",
            "Quantify everything: dollar amounts, percentages, timelines",
            "Don't stop at first-order effects -- trace the cascade",
            "Every scenario must have a recovery path",
            "Review every 90 days or after any variable shifts"
        ]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"SCENARIO: {result['scenario_name']}")
    print(f"Date: {result['scenario_date']}  |  Review by: {result['review_date']}")
    print(f"{'='*70}\n")

    ctx = result["company_context"]
    print(f"Context: ARR ${ctx['arr']:,}  |  Runway: {ctx['runway_months']} months  |  Burn: ${ctx['estimated_monthly_burn']:,}/mo\n")

    print("VARIABLES:")
    print("-" * 60)
    for v in result["variables"]:
        print(f"  [{v['id']}] {v['description']}")
        print(f"      Probability: {v['probability']}  |  Impact: ${v['impact']:,}  |  Timeline: {v['timeline_days']} days")

    print(f"\nSEVERITY MATRIX:")
    print("-" * 60)
    for level in ["base", "stress", "severe"]:
        s = result["severity_matrix"][level]
        existential = " [EXISTENTIAL]" if s.get("existential") else ""
        print(f"  {s['name'].upper()}: ARR impact -${s['arr_impact']:,} ({s['arr_impact_pct']}%), Runway: {s['new_runway']} months{existential}")
        print(f"    Recovery: {s['recovery']}")

    print(f"\nCASCADE PATTERNS:")
    for cp in result["cascade_patterns"]:
        print(f"  {cp['name']}: {cp['pattern']}")
        print(f"    Interruption: {cp['interruption_point']}")

    print(f"\nEARLY WARNING SIGNALS:")
    for s in result["early_warning_signals"]:
        print(f"  -> {s['variable']}: {s['threshold']} (respond within {s['response_window']})")

    print(f"\nHEDGES (implement now):")
    for h in result["hedges"]:
        print(f"  [{h['deadline']:<10s}] {h['hedge']} (cost: {h['cost']}, owner: {h['owner']})")
    print()


def main():
    parser = argparse.ArgumentParser(description="Build structured war room scenarios")
    parser.add_argument("--name", required=True, help="Scenario name")
    parser.add_argument("--variable", action="append", required=True,
                        help="Variable in format 'description:probability:impact:timeline_days' (multiple allowed)")
    parser.add_argument("--arr", type=float, default=2000000, help="Current ARR ($)")
    parser.add_argument("--runway-months", type=float, default=14, help="Current runway in months")
    # Legacy single-variable args
    parser.add_argument("--probability", type=float, help="Probability (0-1) for single variable mode")
    parser.add_argument("--impact", type=float, help="Impact ($) for single variable mode")
    parser.add_argument("--timeline", type=int, help="Timeline (days) for single variable mode")
    parser.add_argument("--json", action="store_true")
    args = parser.parse_args()

    variables = []
    for var_str in args.variable:
        v = parse_variable(
            var_str,
            default_probability=args.probability or 0.2,
            default_impact=args.impact or 0,
            default_timeline=args.timeline or 90
        )
        variables.append(v)

    result = build_scenario(args.name, variables, args.arr, args.runway_months)

    if args.json:
        print(json.dumps(result, indent=2))
    else:
        print_human(result)


if __name__ == "__main__":
    main()