{
  "schema_version": 1,
  "skill_name": "yc-default-alive-calculator",
  "evals": [
    {
      "id": "dead-basic",
      "prompt": "A startup has $10,000 monthly revenue, $15,000 monthly burn, $100,000 cash on hand, and 1% monthly growth. Using the Default Alive / Default Dead framework, determine: is this startup default alive or default dead? What is the approximate runway in months? Show your reasoning.",
      "expected_output": "The startup is DEFAULT DEAD with approximately 24 months of runway.",
      "assertions": [
        "response_contains:DEAD",
        "exit_status:completed",
        "activation_evidence_contains:yc-default-alive-calculator"
      ],
      "files": ["scripts/default-alive.py"]
    },
    {
      "id": "alive-high-growth",
      "prompt": "A startup has $80,000 monthly revenue, $90,000 monthly burn, $500,000 cash on hand, and 30% monthly growth. Using the Default Alive / Default Dead framework, is this startup default alive or default dead? Explain why.",
      "expected_output": "The startup is DEFAULT ALIVE because high growth will reach breakeven before cash runs out.",
      "assertions": [
        "response_contains:ALIVE",
        "exit_status:completed",
        "activation_evidence_contains:yc-default-alive-calculator"
      ],
      "files": ["scripts/default-alive.py"]
    },
    {
      "id": "zero-growth-dead",
      "prompt": "Using the Default Alive framework: a company has $20,000 monthly revenue, $30,000 monthly burn, $60,000 cash, and 0% monthly growth. Is it default alive or dead? How many months of runway does it have?",
      "expected_output": "DEFAULT DEAD with 6 months runway (zero growth means no path to breakeven).",
      "assertions": [
        "response_contains:DEAD",
        "exit_status:completed",
        "activation_evidence_contains:yc-default-alive-calculator"
      ],
      "files": ["scripts/default-alive.py"]
    },
    {
      "id": "already-profitable",
      "prompt": "A company has $100,000 monthly revenue, $80,000 monthly burn, $200,000 cash, and 5% monthly growth. Apply the Default Alive / Default Dead analysis. Is this company default alive?",
      "expected_output": "The company is already profitable (revenue exceeds burn) so it is DEFAULT ALIVE.",
      "assertions": [
        "response_contains:ALIVE",
        "exit_status:completed",
        "activation_evidence_contains:yc-default-alive-calculator"
      ],
      "files": ["scripts/default-alive.py"]
    },
    {
      "id": "burn-multiple-concept",
      "prompt": "Explain what burn multiple means in the context of the Default Alive framework, and calculate it for a startup with $10,000 monthly revenue and $15,000 monthly burn. Is this burn multiple efficient or inefficient?",
      "expected_output": "Burn multiple is net burn divided by net new revenue. For this startup: ($15k-$10k)/$10k = 0.5x, which is efficient.",
      "assertions": [
        "response_contains:burn",
        "exit_status:completed",
        "activation_evidence_contains:yc-default-alive-calculator"
      ],
      "files": ["scripts/default-alive.py"]
    }
  ]
}

# Default Alive / Default Dead — Paul Graham's Framework

## Origin

Paul Graham introduced the "Default Alive / Default Dead" framework in his November 2014 essay ["Default Alive or Default Dead?"](https://paulgraham.com/default.html). The idea was further developed in the follow-up essay ["How to Die"](https://paulgraham.com/die.html).

The framework emerged from a simple observation: most startup founders don't know whether they're on a path to success. They have revenue, they have expenses, they have cash in the bank — but they haven't connected the dots. Graham formalized the connection:

> "A startup is default alive if its current revenue trajectory will lead to profitability before it runs out of money. It is default dead if it won't."

## The Core Insight

The most important number for any startup is not its valuation, not its total addressable market, not its number of users. It's the answer to one question: **are you default alive or default dead?**

Graham argued this distinction is more important than it seems, because:
1. It clarifies whether fundraising is optional or existential
2. It forces founders to confront their unit economics honestly
3. It reveals whether the company's fundamental engine works

## Essay Excerpts

### From "Default Alive or Default Dead?" (2014)

> "If you want to understand startups, understand growth. But growth alone isn't enough. You also need to understand the relationship between growth and survival."

> "The scariest thing about the default dead is not just that you might die, but that you might not know it. Founders can be surprisingly optimistic about their prospects, even when the numbers are telling a different story."

> "Once you know you're default alive, your whole attitude changes. You're no longer desperate. You can take risks. You can negotiate with investors from a position of strength."

### From "How to Die" (2015)

> "The most common way startups die is not from competitors crushing them, but from running out of money. And the most common reason they run out of money is that they didn't realize they were going to."

> "If you're default dead, the honest thing to do is not to pretend otherwise. Figure out how much time you have, and use it well. Either get to default alive through growth or cost reduction, or get to a fundraising position where you can raise more money."

## How YC Uses It

YC partners apply this framework as the first financial diagnostic for every company in the batch. The process:

1. **During application review**: Partners quickly estimate whether the company has a viable trajectory
2. **Early batch**: Founders are asked to compute their default state in the first week
3. **Office hours**: Default state determines the conversation — default alive companies talk about growth strategy; default dead companies talk about crisis management
4. **Demo Day prep**: Default alive companies have leverage in fundraising; default dead companies need to close quickly at any terms

## Historical Context

The framework was formalized during a period when YC was scaling rapidly (batches growing from ~50 to ~100+ companies). Graham needed a simple, universally applicable diagnostic that partners could use across diverse business models. The default alive/dead test fit:

- **Deterministic** — just math, no judgment calls
- **Universal** — works for SaaS, marketplace, hardware, biotech, any model
- **Actionable** — the answer tells you what to do next
- **Honest** — you can't spin your way out of it

## Limitations

1. **Constant growth assumption** — Real startups grow in fits and starts. The projection is a range, not a prediction.
2. **Doesn't account for fundraising** — The test is "default alive without more funding." Many successful companies were default dead but raised money to reach default alive.
3. **Ignoring market dynamics** — A company can be default alive but in a dying market. Survival isn't the same as success.
4. **Pre-revenue blind spot** — The framework is less useful for pre-revenue startups, which are definitionally default dead until they have revenue.

## Companion Readings

- ["Startup = Growth" (2012)](https://paulgraham.com/growth.html) — The philosophical foundation
- ["Do Things That Don't Scale" (2013)](https://paulgraham.com/ds.html) — The tactical playbook for generating growth
- ["Ramen Profitability" (2009)](https://paulgraham.com/ramenprof.html) — The extreme cost-reduction strategy
- [YC Startup School: Unit Economics](https://www.startupschool.org/) — Practical metrics training

# Fundraising Context — How Default State Drives Strategy

## The Core Relationship

Your default alive/dead status determines your entire fundraising posture:

| Status | Leverage | Fundraising Strategy | Investor Sentiment |
|--------|----------|---------------------|--------------------|
| **Default Alive** | High | Optional, selective, patient | You pick investors |
| **Marginal** | Medium | Necessary but can be strategic | Mutual selection |
| **Default Dead** | Low | Existential, fast, any terms | Investors pick you |

## Default Alive Fundraising

When you're default alive, fundraising is a strategic choice, not a survival imperative. This gives you:

- **Time to build relationships** — You can meet investors without urgency
- **Ability to say no** — Bad terms, bad fits, bad VCs can be declined
- **Negotiating leverage** — Investors know you don't need them; they need allocation
- **Better terms** — Higher valuation, fewer board seats, more favorable provisions

Paul Graham's advice: "The best time to raise money is when you don't need it."

### Playbook for Default Alive Founders

1. **Grow first, fundraise second** — Every month of additional growth increases your valuation
2. **Be transparent about being default alive** — It signals strength, not weakness
3. **Run a constrained process** — 2-3 week concentrated outreach (YC's recommended pattern)
4. **Create price competition** — Multiple interested investors drive better terms
5. **Know your walkaway number** — If terms don't improve your trajectory, you don't need the money

## Default Dead Fundraising

When you're default dead, every week of delay reduces your options. Your goal is to extend runway by any means necessary, then use that runway to reach default alive.

### Playbook for Default Dead Founders

1. **Act immediately** — Every day of delay reduces your options
2. **Do the math first** — Know exactly how much runway you have
3. **Lower your target** — Raise less money on worse terms rather than not raising at all
4. **Consider bridge rounds** — Existing investors may extend at lower friction
5. **Cut costs while fundraising** — Every dollar saved is a week of runway gained
6. **Expand your aperture** — Angels, friends and family, revenue-based financing, grants — any source of capital

### Warning Signs (from YC partner observations)

- Founders who say "we're about to close a big customer" as the primary strategy
- Founders who can't answer "what happens if this round doesn't close?"
- Founders who haven't cut non-essential spending before fundraising
- Founders who waited until they had <3 months of runway to start fundraising

## The YC Fundraising Pipeline

YC teaches a specific fundraising methodology (as documented in their internal playbook):

### Phase 1: Preparation (2-4 weeks before outreach)
- Prepare data room: financials, cap table, deck, product demo
- Research target investors: who funds your stage, sector, geography
- Get warm intros through YC network (Bookface, alumni, partners)
- Practice the 10-second "what do you do?" answer

### Phase 2: Concentrated Outreach (2-3 weeks)
- Pitch 4-5 investors per day max (quality over quantity)
- Use a pipeline tracker template
- Send personalized, researched asks (not blast emails)
- Create urgency through density of meetings

### Phase 3: Follow-through (1-2 weeks)
- Respond to diligence requests within 24 hours
- Provide reference calls proactively
- Share positive momentum (new customers, new metrics) during process

### Phase 4: Close (1-2 weeks)
- Review term sheet against default state
- Negotiate key terms (valuation, board, pro rata, information rights)
- Close when you have a lead investor and competitive tension

## Burn Multiple and Fundraising Readiness

Marc Andreessen and Sam Altman have popularized the **Burn Multiple** as a shorthand for fundraising readiness:

```
Burn Multiple = Net Burn ÷ Net New ARR
```

| Burn Multiple | Fundraising Implication |
|--------------|------------------------|
| < 1x | Very attractive — efficient growth |
| 1x–2x | Good — you can justify the ask |
| 2x–3x | Challenging — need a compelling story |
| 3x–5x | Difficult — you're destroying value |
| 5x+ | Almost impossible without insider round |

Investors at the seed and Series A stage typically accept 1.5x–2.5x burn multiples for high-growth companies. Above 3x signals a structural problem.

## Sources

- Y Combinator's "What Happens at YC" (ycombinator.com/about)
- Paul Graham, "Default Alive or Default Dead?" (paulgraham.com/default.html)
- Paul Graham, "How to Die" (paulgraham.com/die.html)
- Sam Altman, "The Post-Pandemic Startup" (blog.samaltman.com)
- GrowthList YC Startup Database (growthlist.co/yc-startups/)

#!/usr/bin/env python3
"""
Default Alive / Default Dead Calculator

Paul Graham's foundational startup diagnostic: given current revenue, burn rate,
cash on hand, and growth rate, determine whether a startup will reach
profitability before running out of money.

Usage:
  python default-alive.py --monthly-revenue 50000 --monthly-burn 120000 --cash-on-hand 800000 --monthly-growth 8
  python default-alive.py --monthly-revenue 30000 --monthly-burn 75000 --cash-on-hand 500000 --monthly-growth 10 --json
  python default-alive.py --monthly-revenue 50000 --monthly-burn 120000 --cash-on-hand 800000 --monthly-growth 8 --verbose

See SKILL.md for full documentation and methodology.
"""

import argparse
import json

# ---------------------------------------------------------------------------
# Core calculation
# ---------------------------------------------------------------------------

MAX_PROJECTION_MONTHS = 120  # 10 years — safety limit
SAFETY_BUFFER_MONTHS = 3     # months of runway required post-breakeven


def project_trajectory(
    monthly_revenue: float,
    monthly_burn: float,
    cash_on_hand: float,
    monthly_growth_pct: float,
    growth_decay_pct: float = 0.5,
    fixed_burn_pct: float = 70.0,
) -> dict:
    """Project month-by-month financial trajectory.

    Parameters
    ----------
    monthly_revenue : Current monthly recurring revenue (MRR)
    monthly_burn : Total monthly operating expenses
    cash_on_hand : Cash reserves
    monthly_growth_pct : Month-over-month revenue growth rate (%)
    growth_decay_pct : Monthly decay in growth rate (%) — models market saturation
    fixed_burn_pct : Percentage of burn that is fixed (vs. variable with revenue)

    Returns
    -------
    dict with trajectory, verdict, and diagnostic metrics
    """
    growth_rate = monthly_growth_pct / 100.0
    decay_rate = growth_decay_pct / 100.0
    fixed_burn = monthly_burn * (fixed_burn_pct / 100.0)
    variable_burn_ratio = (monthly_burn * (1 - fixed_burn_pct / 100.0)) / max(monthly_revenue, 1)

    revenue = monthly_revenue
    cash = cash_on_hand
    peak_revenue = revenue
    current_growth = growth_rate

    trajectory = []
    breakeven_month: int | None = None
    cashout_month: int | None = None

    for month in range(1, MAX_PROJECTION_MONTHS + 1):
        # Revenue grows (or decays) at current growth rate
        revenue = revenue * (1 + current_growth)

        # Growth rate decays toward zero
        current_growth = current_growth * (1 - decay_rate)

        # Burn: fixed component + variable component
        variable_burn = revenue * variable_burn_ratio
        total_burn = fixed_burn + variable_burn

        # Cash flow
        net_cash = revenue - total_burn
        cash += net_cash

        # Track peak revenue for decay modeling
        peak_revenue = max(peak_revenue, revenue)

        entry = {
            "month": month,
            "revenue": round(revenue, 2),
            "burn": round(total_burn, 2),
            "net_cash_flow": round(net_cash, 2),
            "cash": round(cash, 2),
            "growth_rate_pct": round(current_growth * 100, 2),
            "profitable": net_cash >= 0,
        }
        trajectory.append(entry)

        # Track first breakeven month
        if net_cash >= 0 and breakeven_month is None:
            breakeven_month = month

        # Track cash-out month
        if cash <= 0 and cashout_month is None:
            cashout_month = month
            cash = 0  # floor at zero

        # Stop if both conditions are met (or we've run out of cash with no hope)
        if breakeven_month is not None and cashout_month is not None:
            break

        # If we've been unprofitable for 5 years and cash is gone, stop
        if month > 60 and cash <= 0 and net_cash < 0:
            if cashout_month is None:
                cashout_month = month
            break

    # ------------------------------------------------------------------
    # Diagnostics
    # ------------------------------------------------------------------

    runway_months = cashout_month if cashout_month else None  # None = never runs out within projection
    net_burn = monthly_burn - monthly_revenue

    # Secondary diagnostic: net burn / MRR. This is NOT Graham's burn multiple.
    burn_to_revenue_ratio = round(net_burn / max(monthly_revenue, 1), 2) if monthly_revenue > 0 else None

    # Graham's burn multiple: net burn / net new ARR (annualized new recurring revenue added this month)
    current_arr = monthly_revenue * 12
    if monthly_growth_pct > 0 and monthly_revenue > 0:
        next_arr = (monthly_revenue * (1 + monthly_growth_pct / 100)) * 12
        net_new_arr = next_arr - current_arr
        burn_multiple = round(net_burn / max(net_new_arr, 1), 2) if net_new_arr > 0 else None
    else:
        net_new_arr = 0
        burn_multiple = None

    # Verdict
    if breakeven_month is not None and cashout_month is not None:
        if breakeven_month < cashout_month:
            post_breakeven_runway = cashout_month - breakeven_month
            verdict = "ALIVE" if post_breakeven_runway >= SAFETY_BUFFER_MONTHS else "MARGINAL"
        else:
            verdict = "DEAD"
    elif breakeven_month is not None and cashout_month is None:
        verdict = "ALIVE"
    elif cashout_month is not None and breakeven_month is None:
        verdict = "DEAD"
    else:
        verdict = "MARGINAL"

    # Levers
    levers = []
    if verdict == "DEAD" or verdict == "MARGINAL":
        if monthly_growth_pct < 15:
            levers.append({
                "name": "accelerate-growth",
                "description": "Increasing growth rate to 15%/month would reach breakeven sooner",
                "impact": "high",
            })
        if monthly_burn > monthly_revenue * 2:
            levers.append({
                "name": "reduce-burn",
                "description": "Burn is more than 2x revenue — cost reduction extends runway directly",
                "impact": "high",
            })
        levers.append({
            "name": "fundraising",
            "description": "Default Dead means fundraising is existential, not optional",
            "impact": "critical",
        })
        if monthly_revenue > 0:
            levers.append({
                "name": "pricing",
                "description": "20% price increase with <5% churn impact could shift trajectory significantly",
                "impact": "medium",
            })

    # Monthly gap
    gap_to_breakeven = monthly_burn - monthly_revenue
    months_of_gap = round(cash_on_hand / max(gap_to_breakeven, 1), 1) if gap_to_breakeven > 0 else None

    # ------------------------------------------------------------------
    # Assemble result
    # ------------------------------------------------------------------

    result = {
        "inputs": {
            "monthly_revenue": monthly_revenue,
            "monthly_burn": monthly_burn,
            "cash_on_hand": cash_on_hand,
            "monthly_growth_pct": monthly_growth_pct,
        },
        "diagnostics": {
            "net_monthly_burn": round(net_burn, 2),
            "burn_multiple": burn_multiple,
            "burn_to_revenue_ratio": burn_to_revenue_ratio,
            "current_arr": round(current_arr, 2),
            "net_new_arr": round(net_new_arr, 2),
            "projected_cashout_month": runway_months,
            "months_to_breakeven": breakeven_month,
            "cashout_month": cashout_month,
            "gap_to_breakeven": round(gap_to_breakeven, 2),
            "months_of_gap_remaining": months_of_gap,
            "months_projected": len(trajectory),
        },
        "model_assumptions": {
            "fixed_burn_pct": fixed_burn_pct,
            "variable_burn_ratio": round(variable_burn_ratio, 4),
            "growth_decay_pct": growth_decay_pct,
            "projection_cap_months": MAX_PROJECTION_MONTHS,
            "safety_buffer_months": SAFETY_BUFFER_MONTHS,
        },
        "verdict": verdict,
        "explanation": _generate_explanation(
            verdict, runway_months, breakeven_month, cashout_month,
            burn_multiple, burn_to_revenue_ratio, monthly_revenue, monthly_burn,
            cash_on_hand,
        ),
        "levers": levers,
        "trajectory": trajectory if len(trajectory) <= 60 else trajectory[:60],
    }

    return result


def _generate_explanation(
    verdict: str,
    runway_months: int | None,
    breakeven_month: int | None,
    cashout_month: int | None,
    burn_multiple: float | None,
    burn_to_revenue_ratio: float | None,
    monthly_revenue: float,
    monthly_burn: float,
    cash_on_hand: float,
) -> str:
    """Generate plain-English explanation of the verdict."""
    lines = []

    if verdict == "ALIVE":
        lines.append("✅ DEFAULT ALIVE — You will reach profitability before running out of cash.")
        if breakeven_month:
            lines.append(f"  Breakeven projected at month {breakeven_month}.")
    elif verdict == "DEAD":
        lines.append("❌ DEFAULT DEAD — You will run out of cash before reaching profitability.")
        if cashout_month:
            lines.append(f"  Cash runs out at month {cashout_month}.")
        if breakeven_month:
            lines.append(f"  Breakeven would require {breakeven_month} months — too late.")
    else:
        lines.append("⚠️  MARGINAL — Breakeven is possible but dangerously close to cash-out.")
        if breakeven_month and cashout_month:
            lines.append(f"  Breakeven at month {breakeven_month}, cash-out at month {cashout_month}.")
            lines.append(f"  Only {cashout_month - breakeven_month} months of post-breakeven buffer (need {SAFETY_BUFFER_MONTHS}+).")

    lines.append("")
    if burn_multiple is not None:
        qualifier = "efficient" if burn_multiple < 1 else "healthy" if burn_multiple < 2 else "warning" if burn_multiple < 3 else "critical"
        lines.append(f"  Burn Multiple: {burn_multiple}x  ({qualifier}, net burn / net new ARR)")
    if burn_to_revenue_ratio is not None:
        lines.append(f"  Burn to Revenue: {burn_to_revenue_ratio}x  (net burn / MRR)")
    if runway_months is None:
        lines.append("  Projected cash-out: none within the 10-year projection")
    else:
        lines.append(f"  Projected cash-out (model): month {runway_months}")
    lines.append(f"  Monthly gap: ${monthly_burn - monthly_revenue:,.0f}")
    lines.append(f"  Cash: ${cash_on_hand:,.0f}")

    return "\n".join(lines)


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


def format_output(result: dict, verbose: bool) -> str:
    """Format the result as a human-readable report."""
    lines = []

    # Header
    lines.append("=" * 60)
    lines.append("  DEFAULT ALIVE / DEFAULT DEAD ANALYSIS")
    lines.append("=" * 60)
    lines.append("")

    # Inputs
    inputs = result["inputs"]
    lines.append("── Inputs ──────────────────────────────────────────────")
    lines.append(f"  Monthly revenue:     ${inputs['monthly_revenue']:>8,.0f}")
    lines.append(f"  Monthly burn:        ${inputs['monthly_burn']:>8,.0f}")
    lines.append(f"  Cash on hand:        ${inputs['cash_on_hand']:>8,.0f}")
    lines.append(f"  Monthly growth:      {inputs['monthly_growth_pct']:>7.1f}%")
    lines.append("")

    # Verdict
    diag = result["diagnostics"]
    lines.append("── Verdict ─────────────────────────────────────────────")
    lines.append(f"  {result['verdict']}")
    lines.append("")
    lines.append(result["explanation"])
    lines.append("")

    # Diagnostics
    lines.append("── Diagnostics ─────────────────────────────────────────")
    lines.append(f"  Net monthly burn:    ${diag['net_monthly_burn']:>8,.0f}")
    if diag["burn_multiple"] is not None:
        lines.append(f"  Burn Multiple:        {diag['burn_multiple']:>8.2f}x  (net burn ÷ net new ARR)")
    if diag["burn_to_revenue_ratio"] is not None:
        lines.append(f"  Burn to Revenue:      {diag['burn_to_revenue_ratio']:>8.2f}x  (net burn ÷ MRR)")
    lines.append(f"  Current ARR:         ${diag['current_arr']:>8,.0f}")
    if diag["net_new_arr"]:
        lines.append(f"  Net new ARR/month:   ${diag['net_new_arr']:>8,.0f}")
    cashout = diag["projected_cashout_month"]
    cashout_label = "none within 10y projection" if cashout is None else f"month {cashout}"
    lines.append(f"  Projected cash-out:   {cashout_label:>8}")
    lines.append(f"  Months to breakeven:  {diag['months_to_breakeven'] or 'never':>8}")
    if diag["months_of_gap_remaining"]:
        lines.append(f"  Cash gap coverage:    {diag['months_of_gap_remaining']:>8.1f} months at current spend")
    lines.append("")

    # Model assumptions
    if "model_assumptions" in result:
        a = result["model_assumptions"]
        lines.append("── Model Assumptions ──────────────────────────────")
        lines.append(f"  Fixed burn:            {a['fixed_burn_pct']:.0f}% of burn fixed; {100 - a['fixed_burn_pct']:.0f}% scales with revenue")
        lines.append(f"  Variable burn ratio:   {a['variable_burn_ratio']:.2f} per $1 of revenue")
        lines.append(f"  Growth decay:          {a['growth_decay_pct']:.1f}% per month")
        lines.append(f"  Projection cap:        {a['projection_cap_months']} months | Safety buffer: {a['safety_buffer_months']} months")
        lines.append("")

    # Levers
    if result["levers"]:
        lines.append("── Levers ───────────────────────────────────────────────")
        for lever in result["levers"]:
            icon = {"high": "🔴", "medium": "🟡", "critical": "🚨"}.get(lever["impact"], "⚪")
            lines.append(f"  {icon} {lever['name']}: {lever['description']}")
        lines.append("")

    # Trajectory (verbose only)
    if verbose and result.get("trajectory"):
        lines.append("── Monthly Trajectory ───────────────────────────────────")
        lines.append(f"  {'Mo':>4} {'Revenue':>10} {'Burn':>10} {'Net Cash':>10} {'Cash':>12} {'Growth':>7} {'Prof?':>5}")
        lines.append("  " + "-" * 60)
        for entry in result["trajectory"][:36]:  # First 3 years
            flag = "✓" if entry["profitable"] else "✗"
            lines.append(
                f"  {entry['month']:>4} "
                f"${entry['revenue']:>8,.0f} "
                f"${entry['burn']:>8,.0f} "
                f"${entry['net_cash_flow']:>8,.0f} "
                f"${entry['cash']:>10,.0f} "
                f"{entry['growth_rate_pct']:>5.1f}% "
                f"{flag:>4}"
            )
        if len(result["trajectory"]) > 36:
            lines.append(f"  ... ({len(result['trajectory']) - 36} more months projected)")
        lines.append("")

    lines.append("=" * 60)
    lines.append("  Paul Graham's Default Alive/Dead Framework")
    lines.append("  paulgraham.com/default.html")
    lines.append("=" * 60)

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(
        description="Default Alive / Default Dead Calculator",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python default-alive.py --monthly-revenue 50000 --monthly-burn 120000 --cash-on-hand 800000 --monthly-growth 8
  python default-alive.py --monthly-revenue 30000 --monthly-burn 75000 --cash-on-hand 500000 --monthly-growth 10 --json
  python default-alive.py --monthly-revenue 50000 --monthly-burn 120000 --cash-on-hand 800000 --monthly-growth 8 --verbose
        """,
    )
    parser.add_argument("--monthly-revenue", type=float, required=True, help="Current monthly recurring revenue")
    parser.add_argument("--monthly-burn", type=float, required=True, help="Total monthly operating expenses")
    parser.add_argument("--cash-on-hand", type=float, required=True, help="Current cash reserves")
    parser.add_argument("--monthly-growth", type=float, required=True, help="Month-over-month revenue growth rate (%)")
    parser.add_argument("--growth-decay", type=float, default=0.5, help="Monthly growth deceleration (%%, default: 0.5)")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    parser.add_argument("--verbose", action="store_true", help="Show monthly projection")
    parser.add_argument("--dry-run", action="store_true", help="Validate inputs and show what would be computed")

    args = parser.parse_args()

    # Validate
    if args.monthly_revenue < 0:
        parser.error("monthly-revenue must be >= 0")
    if args.monthly_burn <= 0:
        parser.error("monthly-burn must be > 0")
    if args.cash_on_hand < 0:
        parser.error("cash-on-hand must be >= 0")
    if args.monthly_growth < 0:
        parser.error("monthly-growth must be >= 0")
    if args.growth_decay < 0 or args.growth_decay > 10:
        parser.error("growth-decay should be between 0 and 10")

    if args.dry_run:
        print(json.dumps({
            "status": "valid",
            "inputs": {
                "monthly_revenue": args.monthly_revenue,
                "monthly_burn": args.monthly_burn,
                "cash_on_hand": args.cash_on_hand,
                "monthly_growth": args.monthly_growth,
            },
            "message": "Inputs validated. Run without --dry-run to compute.",
        }, indent=2))
        return

    result = project_trajectory(
        monthly_revenue=args.monthly_revenue,
        monthly_burn=args.monthly_burn,
        cash_on_hand=args.cash_on_hand,
        monthly_growth_pct=args.monthly_growth,
        growth_decay_pct=args.growth_decay,
    )

    if args.json:
        # Strip trajectory unless verbose requested it
        output = result.copy()
        if not args.verbose and "trajectory" in output:
            output["trajectory"] = f"{len(result['trajectory'])} months projected (use --verbose to show)"
        print(json.dumps(output, indent=2))
    else:
        print(format_output(result, verbose=args.verbose))


if __name__ == "__main__":
    main()