Founder Coach

#!/usr/bin/env python3
"""Founder Wellness Checker - Screen for burnout signals with actionable recommendations.

Evaluates founder wellness across work intensity, sleep, exercise, social connection,
and stress indicators. Maps to Early/Mid/Late burnout stages with specific interventions.

Usage:
    python founder_wellness_checker.py --hours-per-week 65 --sleep-hours 5.5 --exercise-days 1
    python founder_wellness_checker.py --hours-per-week 55 --sleep-hours 7 --exercise-days 3 --has-peer-group --has-coach --json
"""

import argparse
import json
import sys
from datetime import datetime

FACTORS = {
    "work_hours": {
        "name": "Work Intensity",
        "thresholds": {"green": 50, "yellow": 60, "red": 70},
        "direction": "lower_is_better",
        "unit": "hours/week"
    },
    "sleep": {
        "name": "Sleep Quality",
        "thresholds": {"green": 7, "yellow": 6, "red": 5},
        "direction": "higher_is_better",
        "unit": "hours/night"
    },
    "exercise": {
        "name": "Physical Activity",
        "thresholds": {"green": 3, "yellow": 2, "red": 1},
        "direction": "higher_is_better",
        "unit": "days/week"
    },
    "peer_group": {
        "name": "Peer Support",
        "description": "Regular founder peer group or trusted advisor network"
    },
    "professional_support": {
        "name": "Professional Support",
        "description": "Therapist, coach, or similar professional relationship"
    },
    "vacation_days": {
        "name": "Recovery Time",
        "thresholds": {"green": 15, "yellow": 7, "red": 3},
        "direction": "higher_is_better",
        "unit": "days in last 6 months"
    },
    "decision_fatigue": {
        "name": "Decision Fatigue",
        "thresholds": {"green": 3, "yellow": 5, "red": 7},
        "direction": "lower_is_better",
        "unit": "self-rated 1-10"
    }
}

BURNOUT_STAGES = {
    "healthy": {
        "label": "Healthy",
        "description": "Sustainable pace with adequate recovery",
        "color": "GREEN",
        "recommendations": [
            "Maintain current habits -- they are working",
            "Schedule quarterly check-ins to ensure sustainability",
            "Consider helping other founders build similar habits"
        ]
    },
    "early": {
        "label": "Early Warning",
        "description": "Irritability, poor sleep, decisions feel harder than usual",
        "color": "YELLOW",
        "recommendations": [
            "Adjust calendar: protect recovery time this week",
            "Reduce commitments by 20% for the next 2 weeks",
            "Re-establish exercise routine (even 20 min walks count)",
            "Block 'off' hours and communicate them to your team",
            "Schedule 1 social activity unrelated to work this week"
        ]
    },
    "mid": {
        "label": "Mid-Stage Burnout",
        "description": "Physical symptoms, cynicism, priority paralysis, reduced effectiveness",
        "color": "ORANGE",
        "recommendations": [
            "Reduce work hours to < 50 this week (non-negotiable)",
            "Start therapy or coaching if not already active",
            "Delegate 3 responsibilities immediately (use delegation ladder)",
            "Take at least 2 consecutive days off within 2 weeks",
            "Inform a trusted board member or advisor of your state",
            "Audit all commitments and cancel or postpone 30%"
        ]
    },
    "late": {
        "label": "Late-Stage Burnout",
        "description": "Cannot function effectively, decisions stopped, team notices dysfunction",
        "color": "RED",
        "recommendations": [
            "STOP. Get professional support immediately (therapist or doctor)",
            "Inform your co-founder, board chair, or most trusted advisor today",
            "Delegate ALL operational responsibilities for at least 2 weeks",
            "Do not make any major decisions until recovery begins",
            "Consider a structured leave with clear communication to team",
            "This is not weakness -- this is a medical and operational necessity"
        ]
    }
}


def calculate_wellness(hours, sleep, exercise, has_peer_group, has_coach,
                       vacation_days, decision_fatigue):
    scores = {}
    risk_factors = []
    protective_factors = []

    # Work hours
    if hours <= 50:
        scores["work_hours"] = {"score": 9, "status": "green"}
    elif hours <= 60:
        scores["work_hours"] = {"score": 6, "status": "yellow"}
        risk_factors.append(f"Working {hours} hrs/week -- approaching unsustainable")
    elif hours <= 70:
        scores["work_hours"] = {"score": 3, "status": "orange"}
        risk_factors.append(f"Working {hours} hrs/week -- unsustainable pace")
    else:
        scores["work_hours"] = {"score": 1, "status": "red"}
        risk_factors.append(f"Working {hours} hrs/week -- burnout is a when, not if")

    # Sleep
    if sleep >= 7:
        scores["sleep"] = {"score": 9, "status": "green"}
        protective_factors.append("Adequate sleep (7+ hours)")
    elif sleep >= 6:
        scores["sleep"] = {"score": 5, "status": "yellow"}
        risk_factors.append(f"Sleep at {sleep} hrs -- cognitive impairment begins below 7")
    else:
        scores["sleep"] = {"score": 2, "status": "red"}
        risk_factors.append(f"Sleep at {sleep} hrs -- severe cognitive and health impact")

    # Exercise
    if exercise >= 3:
        scores["exercise"] = {"score": 9, "status": "green"}
        protective_factors.append(f"Regular exercise ({exercise} days/week)")
    elif exercise >= 2:
        scores["exercise"] = {"score": 5, "status": "yellow"}
        risk_factors.append("Exercise below recommended minimum (3+ days)")
    elif exercise >= 1:
        scores["exercise"] = {"score": 3, "status": "orange"}
        risk_factors.append("Minimal exercise -- stress relief compromised")
    else:
        scores["exercise"] = {"score": 1, "status": "red"}
        risk_factors.append("No exercise -- critical protective factor missing")

    # Peer group
    if has_peer_group:
        scores["peer_group"] = {"score": 8, "status": "green"}
        protective_factors.append("Active peer support network")
    else:
        scores["peer_group"] = {"score": 3, "status": "orange"}
        risk_factors.append("No peer group -- isolation risk")

    # Professional support
    if has_coach:
        scores["professional_support"] = {"score": 8, "status": "green"}
        protective_factors.append("Professional support (coach/therapist)")
    else:
        scores["professional_support"] = {"score": 4, "status": "yellow"}
        risk_factors.append("No professional support -- the job is isolating")

    # Vacation
    if vacation_days >= 15:
        scores["vacation"] = {"score": 9, "status": "green"}
        protective_factors.append(f"{vacation_days} recovery days in 6 months")
    elif vacation_days >= 7:
        scores["vacation"] = {"score": 5, "status": "yellow"}
        risk_factors.append(f"Only {vacation_days} days off in 6 months -- insufficient recovery")
    else:
        scores["vacation"] = {"score": 2, "status": "red"}
        risk_factors.append(f"Only {vacation_days} days off in 6 months -- no recovery happening")

    # Decision fatigue
    if decision_fatigue <= 3:
        scores["decision_fatigue"] = {"score": 8, "status": "green"}
    elif decision_fatigue <= 5:
        scores["decision_fatigue"] = {"score": 5, "status": "yellow"}
        risk_factors.append("Moderate decision fatigue -- delegate more operational decisions")
    elif decision_fatigue <= 7:
        scores["decision_fatigue"] = {"score": 3, "status": "orange"}
        risk_factors.append("High decision fatigue -- decision quality declining")
    else:
        scores["decision_fatigue"] = {"score": 1, "status": "red"}
        risk_factors.append("Severe decision fatigue -- decisions are being avoided or delayed")

    # Overall wellness score
    total = sum(s["score"] for s in scores.values())
    max_total = len(scores) * 10
    wellness_pct = round(total / max_total * 100)

    # Determine burnout stage
    red_count = sum(1 for s in scores.values() if s["status"] == "red")
    orange_count = sum(1 for s in scores.values() if s["status"] == "orange")

    if red_count >= 3 or (red_count >= 2 and orange_count >= 2):
        stage = "late"
    elif red_count >= 1 or orange_count >= 2:
        stage = "mid"
    elif orange_count >= 1 or len(risk_factors) >= 3:
        stage = "early"
    else:
        stage = "healthy"

    burnout_info = BURNOUT_STAGES[stage]

    return {
        "assessment_date": datetime.now().strftime("%Y-%m-%d"),
        "inputs": {
            "hours_per_week": hours,
            "sleep_hours": sleep,
            "exercise_days": exercise,
            "has_peer_group": has_peer_group,
            "has_professional_support": has_coach,
            "vacation_days_6mo": vacation_days,
            "decision_fatigue": decision_fatigue
        },
        "wellness_score": wellness_pct,
        "burnout_stage": stage,
        "burnout_label": burnout_info["label"],
        "burnout_description": burnout_info["description"],
        "severity": burnout_info["color"],
        "factor_scores": scores,
        "risk_factors": risk_factors,
        "protective_factors": protective_factors,
        "recommendations": burnout_info["recommendations"]
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"FOUNDER WELLNESS CHECK")
    print(f"Date: {result['assessment_date']}")
    print(f"{'='*70}\n")

    print(f"WELLNESS SCORE: {result['wellness_score']}%")
    print(f"BURNOUT STAGE:  [{result['severity']}] {result['burnout_label']}")
    print(f"                {result['burnout_description']}\n")

    print("FACTOR SCORES:")
    print("-" * 50)
    status_icons = {"green": "+", "yellow": "~", "orange": "!", "red": "X"}
    for key, data in result["factor_scores"].items():
        icon = status_icons.get(data["status"], "?")
        print(f"  [{icon}] {key:<25s} {data['score']:>2}/10  ({data['status']})")

    if result["risk_factors"]:
        print(f"\nRISK FACTORS ({len(result['risk_factors'])}):")
        for r in result["risk_factors"]:
            print(f"  [!] {r}")

    if result["protective_factors"]:
        print(f"\nPROTECTIVE FACTORS ({len(result['protective_factors'])}):")
        for p in result["protective_factors"]:
            print(f"  [+] {p}")

    print(f"\nRECOMMENDATIONS:")
    print("-" * 50)
    for r in result["recommendations"]:
        print(f"  -> {r}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Screen for founder burnout signals")
    parser.add_argument("--hours-per-week", type=float, required=True, help="Average work hours per week")
    parser.add_argument("--sleep-hours", type=float, required=True, help="Average sleep hours per night")
    parser.add_argument("--exercise-days", type=int, required=True, help="Exercise days per week (0-7)")
    parser.add_argument("--has-peer-group", action="store_true", help="Has active founder peer group")
    parser.add_argument("--has-coach", action="store_true", help="Has therapist, coach, or professional support")
    parser.add_argument("--vacation-days", type=int, default=5, help="Days off in last 6 months")
    parser.add_argument("--decision-fatigue", type=int, default=5, help="Decision fatigue self-rating (1-10)")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    result = calculate_wellness(
        args.hours_per_week, args.sleep_hours, args.exercise_days,
        args.has_peer_group, args.has_coach,
        args.vacation_days, args.decision_fatigue
    )

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Milestone Tracker - Track founder development milestones across key areas.

Track progress on delegation, leadership evolution, succession readiness, and
personal development milestones. Stored in local JSON for persistence.

Usage:
    python milestone_tracker.py add --category delegation --milestone "Hired first manager"
    python milestone_tracker.py list --category leadership
    python milestone_tracker.py progress
    python milestone_tracker.py report --json
"""

import argparse
import json
import os
import sys
from datetime import datetime

DEFAULT_STORE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "milestones_data.json")

CATEGORIES = {
    "delegation": {
        "name": "Delegation Progress",
        "milestones": [
            "Identified 5 tasks to delegate",
            "Hired first manager",
            "3 tasks at delegation Level 3",
            "Written decision parameters for direct reports",
            "5+ tasks at Level 4-5",
            "Calendar shows < 15% execution time",
            "Team makes decisions without waiting for founder"
        ]
    },
    "leadership": {
        "name": "Leadership Evolution",
        "milestones": [
            "Transitioned from IC to Manager (teaching not doing)",
            "Hired 2+ managers you trust",
            "Leadership team can run company for 2 weeks",
            "Built institutional leadership systems",
            "Potential successor identified",
            "Can articulate leadership style and blind spots",
            "360 feedback shows improving leadership scores"
        ]
    },
    "succession": {
        "name": "Succession Readiness",
        "milestones": [
            "Level 0: Key knowledge documented",
            "Level 1: Processes written down",
            "Level 2: Someone can cover each key function for 2 weeks",
            "Level 3: Leadership team runs company for a quarter",
            "Level 4: Potential successor identified and developing"
        ]
    },
    "wellbeing": {
        "name": "Founder Wellbeing",
        "milestones": [
            "Established exercise routine (3+ days/week)",
            "Sleep consistently 7+ hours",
            "Joined founder peer group",
            "Started therapy or coaching",
            "Protected recovery time on calendar",
            "Took 5+ consecutive days off",
            "Work hours consistently under 55/week"
        ]
    },
    "self_awareness": {
        "name": "Self-Awareness Development",
        "milestones": [
            "Completed founder archetype assessment",
            "Identified top 3 blind spots",
            "Ran first 360 feedback",
            "Created evidence file (wins, mistakes, patterns)",
            "Active mitigation strategy for each blind spot",
            "Re-ran 360 showing improvement",
            "Modeling vulnerability with team"
        ]
    }
}


def load_data(store_path):
    if os.path.exists(store_path):
        with open(store_path, "r") as f:
            return json.load(f)
    return {"milestones": [], "next_id": 1}


def save_data(data, store_path):
    with open(store_path, "w") as f:
        json.dump(data, f, indent=2)


def add_milestone(data, category, milestone_text, notes=""):
    milestone = {
        "id": data["next_id"],
        "category": category,
        "milestone": milestone_text,
        "achieved": True,
        "date_achieved": datetime.now().strftime("%Y-%m-%d"),
        "notes": notes
    }
    data["milestones"].append(milestone)
    data["next_id"] += 1
    return milestone


def list_milestones(data, category=None):
    milestones = data["milestones"]
    if category:
        milestones = [m for m in milestones if m["category"] == category]
    return milestones


def calculate_progress(data):
    progress = {}
    for cat_key, cat_info in CATEGORIES.items():
        total = len(cat_info["milestones"])
        achieved = len([m for m in data["milestones"] if m["category"] == cat_key])
        pct = round(achieved / total * 100) if total > 0 else 0
        progress[cat_key] = {
            "name": cat_info["name"],
            "total_milestones": total,
            "achieved": min(achieved, total),
            "percentage": min(pct, 100),
            "remaining": [
                ms for ms in cat_info["milestones"]
                if not any(m["milestone"] == ms for m in data["milestones"] if m["category"] == cat_key)
            ]
        }
    return progress


def generate_report(data):
    progress = calculate_progress(data)
    recent = sorted(data["milestones"], key=lambda m: m["date_achieved"], reverse=True)[:5]

    total_possible = sum(len(c["milestones"]) for c in CATEGORIES.values())
    total_achieved = len(data["milestones"])
    overall_pct = round(total_achieved / total_possible * 100) if total_possible > 0 else 0

    # Find weakest area
    weakest = min(progress.values(), key=lambda p: p["percentage"])
    strongest = max(progress.values(), key=lambda p: p["percentage"])

    return {
        "report_date": datetime.now().strftime("%Y-%m-%d"),
        "overall_progress": min(overall_pct, 100),
        "total_milestones_achieved": total_achieved,
        "total_milestones_possible": total_possible,
        "category_progress": progress,
        "recent_achievements": [
            {"milestone": m["milestone"], "category": m["category"], "date": m["date_achieved"]}
            for m in recent
        ],
        "weakest_area": {"name": weakest["name"], "percentage": weakest["percentage"]},
        "strongest_area": {"name": strongest["name"], "percentage": strongest["percentage"]},
        "next_recommended": weakest["remaining"][:2] if weakest["remaining"] else []
    }


def print_progress_human(progress):
    print(f"\n{'='*60}")
    print(f"FOUNDER DEVELOPMENT PROGRESS")
    print(f"{'='*60}\n")

    for cat_key, data in progress.items():
        bar_filled = int(data["percentage"] / 5)
        bar = "#" * bar_filled + "." * (20 - bar_filled)
        print(f"  {data['name']:<30s} [{bar}] {data['percentage']:>3}% ({data['achieved']}/{data['total_milestones']})")

        if data["remaining"]:
            print(f"    Next: {data['remaining'][0]}")
    print()


def print_report_human(report):
    print(f"\n{'='*60}")
    print(f"MILESTONE TRACKER REPORT - {report['report_date']}")
    print(f"{'='*60}\n")

    print(f"Overall Progress: {report['overall_progress']}% ({report['total_milestones_achieved']}/{report['total_milestones_possible']})")
    print(f"Strongest: {report['strongest_area']['name']} ({report['strongest_area']['percentage']}%)")
    print(f"Weakest:   {report['weakest_area']['name']} ({report['weakest_area']['percentage']}%)\n")

    print("CATEGORY BREAKDOWN:")
    print("-" * 50)
    for cat_key, data in report["category_progress"].items():
        bar_filled = int(data["percentage"] / 5)
        bar = "#" * bar_filled + "." * (20 - bar_filled)
        print(f"  {data['name']:<30s} [{bar}] {data['percentage']:>3}%")

    if report["recent_achievements"]:
        print(f"\nRECENT ACHIEVEMENTS:")
        for a in report["recent_achievements"]:
            print(f"  [{a['date']}] {a['category']}: {a['milestone']}")

    if report["next_recommended"]:
        print(f"\nNEXT RECOMMENDED MILESTONES:")
        for m in report["next_recommended"]:
            print(f"  [ ] {m}")
    print()


def main():
    parser = argparse.ArgumentParser(description="Track founder development milestones")
    subparsers = parser.add_subparsers(dest="command")

    add_p = subparsers.add_parser("add", help="Record a milestone achievement")
    add_p.add_argument("--category", required=True, choices=list(CATEGORIES.keys()))
    add_p.add_argument("--milestone", required=True, help="Milestone description")
    add_p.add_argument("--notes", default="", help="Additional notes")
    add_p.add_argument("--json", action="store_true")
    add_p.add_argument("--store", default=DEFAULT_STORE)

    list_p = subparsers.add_parser("list", help="List milestones")
    list_p.add_argument("--category", choices=list(CATEGORIES.keys()))
    list_p.add_argument("--json", action="store_true")
    list_p.add_argument("--store", default=DEFAULT_STORE)

    prog_p = subparsers.add_parser("progress", help="Show progress across categories")
    prog_p.add_argument("--json", action="store_true")
    prog_p.add_argument("--store", default=DEFAULT_STORE)

    rep_p = subparsers.add_parser("report", help="Full progress report")
    rep_p.add_argument("--json", action="store_true")
    rep_p.add_argument("--store", default=DEFAULT_STORE)

    args = parser.parse_args()

    if not args.command:
        parser.print_help()
        sys.exit(1)

    data = load_data(args.store)

    if args.command == "add":
        m = add_milestone(data, args.category, args.milestone, args.notes)
        save_data(data, args.store)
        if args.json:
            print(json.dumps(m, indent=2))
        else:
            print(f"Milestone #{m['id']} recorded: {m['milestone']}")

    elif args.command == "list":
        milestones = list_milestones(data, args.category)
        if args.json:
            print(json.dumps(milestones, indent=2))
        else:
            if not milestones:
                print("No milestones recorded.")
            else:
                for m in milestones:
                    print(f"  [{m['date_achieved']}] #{m['id']} {m['category']}: {m['milestone']}")

    elif args.command == "progress":
        progress = calculate_progress(data)
        if args.json:
            print(json.dumps(progress, indent=2))
        else:
            print_progress_human(progress)

    elif args.command == "report":
        report = generate_report(data)
        if args.json:
            print(json.dumps(report, indent=2))
        else:
            print_report_human(report)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Startup Stage Assessor - Assess current startup stage and identify founder growth ceiling.

Evaluates company stage based on headcount, ARR, funding, and operational signals.
Maps the founder to their current growth ceiling and provides development recommendations.

Usage:
    python startup_stage_assessor.py --headcount 35 --arr 1200000 --stage series-a
    python startup_stage_assessor.py --headcount 120 --arr 8000000 --stage series-b --has-exec-team --json
"""

import argparse
import json
import sys
from datetime import datetime

CEILINGS = {
    1: {
        "threshold": 15,
        "name": "Ceiling 1: Direct Leadership Limit (~15 people)",
        "problem": "Can't be in every meeting and still think strategically",
        "solution": "Delegate operational decisions, hire first manager",
        "skill_to_build": "Letting go of execution details",
        "signals": [
            "You attend > 80% of meetings in the company",
            "Every decision waits for your input",
            "You are the only person who talks to customers, investors, AND the team",
            "No written processes exist -- everything is in your head"
        ],
        "actions": [
            "Hire your first manager within 60 days",
            "Document top 5 processes you do repeatedly",
            "Delegate one customer-facing responsibility to a team member",
            "Block 4 hours/week for thinking time (not meetings)"
        ]
    },
    2: {
        "threshold": 50,
        "name": "Ceiling 2: Management Layer (~50 people)",
        "problem": "Your personal style creates culture problems at scale",
        "solution": "Hire executive team, evolve leadership style",
        "skill_to_build": "Leading through others, not doing yourself",
        "signals": [
            "New hires don't understand the culture because it was never written down",
            "You micromanage managers because you don't trust their judgment yet",
            "Team coordination requires you as the hub",
            "Hiring is the biggest bottleneck and you are the only interviewer"
        ],
        "actions": [
            "Hire 2-3 executives who complement your archetype blind spots",
            "Define and document company values with leadership team",
            "Implement manager training for new managers",
            "Establish weekly leadership team cadence"
        ]
    },
    3: {
        "threshold": 150,
        "name": "Ceiling 3: Institutional Leadership (~150 people)",
        "problem": "Need a real executive team or you become the permanent blocker",
        "solution": "Build institutional leadership, not personal leadership",
        "skill_to_build": "System design, not personal contribution",
        "signals": [
            "Company cannot function for 2 weeks without you",
            "Executive team defers to you on all cross-functional decisions",
            "Culture is 'what the founder does' not 'what the company does'",
            "Board interactions consume too much of your time"
        ],
        "actions": [
            "Build leadership team that can run company for a quarter without you",
            "Implement company operating system (planning cadence, review rhythm)",
            "Develop succession plan for your role",
            "Focus your time on vision, board, culture, and external narrative"
        ]
    },
    4: {
        "threshold": 500,
        "name": "Ceiling 4: Organizational Architecture (500+ people)",
        "problem": "You are a symbol, not a manager -- and must embrace that",
        "solution": "Focus on vision, board, culture, and external narrative",
        "skill_to_build": "Organizational architecture and external leadership",
        "signals": [
            "Multiple layers between you and execution teams",
            "Your decisions have weeks of ripple effects across the org",
            "External stakeholders (press, analysts, partners) demand significant time",
            "Internal communications must be carefully crafted, not casual"
        ],
        "actions": [
            "Delegate all internal operations to COO/President",
            "Spend 50%+ of time on external: board, investors, partnerships, vision",
            "Build world-class executive team that operates independently",
            "Focus on 2-3 year strategic horizon, not quarterly execution"
        ]
    }
}

STAGES = {
    "pre-seed": {"arr_range": (0, 100000), "headcount_range": (1, 5), "typical_ceiling": 1},
    "seed": {"arr_range": (0, 500000), "headcount_range": (2, 15), "typical_ceiling": 1},
    "series-a": {"arr_range": (500000, 3000000), "headcount_range": (10, 50), "typical_ceiling": 2},
    "series-b": {"arr_range": (3000000, 15000000), "headcount_range": (30, 150), "typical_ceiling": 3},
    "series-c": {"arr_range": (15000000, 50000000), "headcount_range": (80, 300), "typical_ceiling": 3},
    "growth": {"arr_range": (50000000, 999999999), "headcount_range": (200, 5000), "typical_ceiling": 4},
}


def assess(headcount, arr, stage, has_exec_team, has_documented_processes, founder_in_meetings_pct):
    # Determine current ceiling
    current_ceiling = 1
    for ceiling_num, ceiling_data in CEILINGS.items():
        if headcount <= ceiling_data["threshold"]:
            current_ceiling = ceiling_num
            break
    else:
        current_ceiling = 4

    # Determine approaching ceiling
    approaching = current_ceiling
    for ceiling_num, ceiling_data in CEILINGS.items():
        if headcount >= ceiling_data["threshold"] * 0.7:
            approaching = ceiling_num
            if ceiling_num < 4:
                approaching = ceiling_num + 1

    ceiling_data = CEILINGS[current_ceiling]

    # Stage alignment check
    stage_info = STAGES.get(stage, STAGES["seed"])
    arr_aligned = stage_info["arr_range"][0] <= arr <= stage_info["arr_range"][1]
    headcount_aligned = stage_info["headcount_range"][0] <= headcount <= stage_info["headcount_range"][1]

    # Risk signals
    risks = []
    if founder_in_meetings_pct > 70 and headcount > 15:
        risks.append("Founder in too many meetings for company size -- delegation gap")
    if not has_exec_team and headcount > 30:
        risks.append("No executive team at 30+ headcount -- approaching Ceiling 2 without leaders")
    if not has_documented_processes and headcount > 15:
        risks.append("No documented processes -- knowledge is trapped in founder's head")
    if not arr_aligned:
        risks.append(f"ARR ${arr:,} is outside expected range for {stage} (${stage_info['arr_range'][0]:,}-${stage_info['arr_range'][1]:,})")
    if not headcount_aligned:
        risks.append(f"Headcount {headcount} is outside expected range for {stage} ({stage_info['headcount_range'][0]}-{stage_info['headcount_range'][1]})")

    # Readiness score
    readiness_score = 10
    if not has_exec_team and current_ceiling >= 2:
        readiness_score -= 3
    if not has_documented_processes:
        readiness_score -= 2
    if founder_in_meetings_pct > 60:
        readiness_score -= 2
    if len(risks) > 2:
        readiness_score -= 2
    readiness_score = max(1, readiness_score)

    return {
        "assessment_date": datetime.now().strftime("%Y-%m-%d"),
        "company_metrics": {
            "headcount": headcount,
            "arr": arr,
            "funding_stage": stage,
            "has_exec_team": has_exec_team,
            "has_documented_processes": has_documented_processes,
            "founder_meeting_percentage": founder_in_meetings_pct
        },
        "current_ceiling": {
            "number": current_ceiling,
            "name": ceiling_data["name"],
            "problem": ceiling_data["problem"],
            "solution": ceiling_data["solution"],
            "skill_to_build": ceiling_data["skill_to_build"]
        },
        "ceiling_signals": ceiling_data["signals"],
        "recommended_actions": ceiling_data["actions"],
        "stage_alignment": {
            "arr_aligned": arr_aligned,
            "headcount_aligned": headcount_aligned,
            "expected_arr_range": f"${stage_info['arr_range'][0]:,} - ${stage_info['arr_range'][1]:,}",
            "expected_headcount_range": f"{stage_info['headcount_range'][0]} - {stage_info['headcount_range'][1]}"
        },
        "risks": risks,
        "readiness_score": readiness_score,
        "readiness_label": "Ready" if readiness_score >= 7 else "Preparing" if readiness_score >= 4 else "At Risk"
    }


def print_human(result):
    print(f"\n{'='*70}")
    print(f"STARTUP STAGE ASSESSMENT")
    print(f"Date: {result['assessment_date']}")
    print(f"{'='*70}\n")

    m = result["company_metrics"]
    print(f"COMPANY: {m['headcount']} people | ${m['arr']:,} ARR | {m['funding_stage']}")
    print(f"Exec Team: {'Yes' if m['has_exec_team'] else 'No'} | Documented Processes: {'Yes' if m['has_documented_processes'] else 'No'}")
    print(f"Founder in meetings: {m['founder_meeting_percentage']}%\n")

    c = result["current_ceiling"]
    print(f"CURRENT CEILING: {c['name']}")
    print(f"  Problem:  {c['problem']}")
    print(f"  Solution: {c['solution']}")
    print(f"  Skill:    {c['skill_to_build']}\n")

    print("SIGNALS TO WATCH:")
    for s in result["ceiling_signals"]:
        print(f"  - {s}")

    print("\nRECOMMENDED ACTIONS:")
    for a in result["recommended_actions"]:
        print(f"  [ ] {a}")

    sa = result["stage_alignment"]
    print(f"\nSTAGE ALIGNMENT:")
    print(f"  ARR: {'Aligned' if sa['arr_aligned'] else 'MISALIGNED'} (expected: {sa['expected_arr_range']})")
    print(f"  Headcount: {'Aligned' if sa['headcount_aligned'] else 'MISALIGNED'} (expected: {sa['expected_headcount_range']})")

    if result["risks"]:
        print(f"\nRISKS ({len(result['risks'])}):")
        for r in result["risks"]:
            print(f"  [!] {r}")

    print(f"\nREADINESS: {result['readiness_score']}/10 ({result['readiness_label']})")
    print()


def main():
    parser = argparse.ArgumentParser(description="Assess startup stage and founder growth ceiling")
    parser.add_argument("--headcount", type=int, required=True, help="Current headcount")
    parser.add_argument("--arr", type=float, required=True, help="Annual recurring revenue in dollars")
    parser.add_argument("--stage", required=True, choices=list(STAGES.keys()), help="Funding stage")
    parser.add_argument("--has-exec-team", action="store_true", help="Has executive team in place")
    parser.add_argument("--has-documented-processes", action="store_true", help="Has documented processes")
    parser.add_argument("--founder-meeting-pct", type=int, default=60, help="Percentage of meetings founder attends")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    result = assess(
        args.headcount, args.arr, args.stage,
        args.has_exec_team, args.has_documented_processes,
        args.founder_meeting_pct
    )

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


if __name__ == "__main__":
    main()