Change Management

#!/usr/bin/env python3
"""
Adoption Tracker - Measure and track change adoption vs compliance.

Tracks usage rates, reversion rates, satisfaction, and support requests
to distinguish real adoption from surface compliance.
"""

import argparse
import json
import sys
from datetime import datetime


def track_adoption(data: dict) -> dict:
    """Track adoption metrics and generate report."""
    change_name = data.get("change_name", "Change Initiative")
    go_live_date = data.get("go_live_date", "")
    weekly_data = data.get("weekly_data", [])
    targets = data.get("targets", {})

    results = {
        "timestamp": datetime.now().isoformat(),
        "change_name": change_name,
        "go_live_date": go_live_date,
        "current_week": len(weekly_data),
        "metrics": {},
        "trend_analysis": [],
        "adoption_vs_compliance": {},
        "at_risk_groups": [],
        "recommendations": [],
    }

    # Default targets
    usage_target = targets.get("usage_rate_pct", 80)
    reversion_target = targets.get("reversion_rate_pct", 10)
    satisfaction_target = targets.get("satisfaction_pct", 60)
    target_week = targets.get("target_week", 8)

    # Current state (latest week)
    if weekly_data:
        latest = weekly_data[-1]
        results["metrics"] = {
            "usage_rate_pct": latest.get("usage_rate_pct", 0),
            "usage_target": usage_target,
            "usage_on_track": latest.get("usage_rate_pct", 0) >= usage_target * (len(weekly_data) / target_week),
            "reversion_rate_pct": latest.get("reversion_rate_pct", 0),
            "reversion_target": reversion_target,
            "reversion_ok": latest.get("reversion_rate_pct", 0) <= reversion_target,
            "satisfaction_pct": latest.get("satisfaction_pct", 0),
            "satisfaction_target": satisfaction_target,
            "satisfaction_met": latest.get("satisfaction_pct", 0) >= satisfaction_target,
            "support_requests": latest.get("support_requests", 0),
            "support_trend": "Declining" if len(weekly_data) > 1 and latest.get("support_requests", 0) < weekly_data[-2].get("support_requests", 0) else "Increasing" if len(weekly_data) > 1 and latest.get("support_requests", 0) > weekly_data[-2].get("support_requests", 0) else "Flat",
            "active_users": latest.get("active_users", 0),
            "total_users": latest.get("total_users", 0),
        }

    # Trend analysis
    for i, week in enumerate(weekly_data):
        week_num = i + 1
        results["trend_analysis"].append({
            "week": week_num,
            "usage_rate_pct": week.get("usage_rate_pct", 0),
            "reversion_rate_pct": week.get("reversion_rate_pct", 0),
            "satisfaction_pct": week.get("satisfaction_pct", 0),
            "support_requests": week.get("support_requests", 0),
        })

    # Adoption vs compliance assessment
    m = results["metrics"]
    if m:
        high_usage = m.get("usage_rate_pct", 0) >= 70
        high_satisfaction = m.get("satisfaction_pct", 0) >= 60
        low_reversion = m.get("reversion_rate_pct", 0) <= 15
        declining_support = m.get("support_trend") == "Declining"

        if high_usage and high_satisfaction and low_reversion:
            adoption_type = "True Adoption"
            description = "People use it because it is better. Sustained without enforcement."
        elif high_usage and not high_satisfaction:
            adoption_type = "Compliance Only"
            description = "High usage but low satisfaction. Will revert when enforcement relaxes."
        elif not high_usage and high_satisfaction:
            adoption_type = "Partial Adoption"
            description = "Those using it like it, but many haven't switched. Training/ability gap."
        else:
            adoption_type = "Failed Adoption"
            description = "Low usage and low satisfaction. Reassess the change itself."

        results["adoption_vs_compliance"] = {
            "type": adoption_type,
            "description": description,
            "high_usage": high_usage,
            "high_satisfaction": high_satisfaction,
            "low_reversion": low_reversion,
            "declining_support": declining_support,
        }

    # At-risk groups
    groups = data.get("group_data", [])
    for group in groups:
        if group.get("usage_rate_pct", 100) < 50:
            results["at_risk_groups"].append({
                "group": group.get("name", "Unknown"),
                "usage_rate_pct": group.get("usage_rate_pct", 0),
                "primary_concern": group.get("primary_concern", "Unknown"),
                "recommended_action": "1:1 with group lead to diagnose ADKAR gap",
            })

    # Recommendations
    if results.get("adoption_vs_compliance", {}).get("type") == "Compliance Only":
        results["recommendations"].append("Compliance without adoption detected. Investigate satisfaction drivers. Don't rely on enforcement alone.")
    if results.get("adoption_vs_compliance", {}).get("type") == "Failed Adoption":
        results["recommendations"].append("Consider rolling back or fundamentally redesigning the change.")
    if m and not m.get("usage_on_track"):
        gap = usage_target - m.get("usage_rate_pct", 0)
        results["recommendations"].append(f"Usage {gap:.0f}pp below target trajectory. Increase training and support.")
    if m and m.get("support_trend") == "Increasing":
        results["recommendations"].append("Support requests increasing. Review training materials and common issues.")
    if results["at_risk_groups"]:
        results["recommendations"].append(f"{len(results['at_risk_groups'])} group(s) at risk of non-adoption. Targeted intervention needed.")
    if len(weekly_data) >= target_week and m and m.get("usage_rate_pct", 0) >= usage_target:
        results["recommendations"].append("Adoption target met. Consider deprecating the old system.")

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    m = results["metrics"]
    avc = results.get("adoption_vs_compliance", {})
    lines = [
        "=" * 60,
        "ADOPTION TRACKER",
        "=" * 60,
        f"Change: {results['change_name']}",
        f"Go-Live: {results['go_live_date']}  |  Current Week: {results['current_week']}",
        "",
    ]

    if m:
        lines.extend([
            "CURRENT METRICS:",
            f"  Usage Rate:      {m.get('usage_rate_pct', 0):>5.0f}% (target: {m.get('usage_target', 0)}%) {'[OK]' if m.get('usage_on_track') else '[BEHIND]'}",
            f"  Reversion Rate:  {m.get('reversion_rate_pct', 0):>5.0f}% (target: <{m.get('reversion_target', 0)}%) {'[OK]' if m.get('reversion_ok') else '[HIGH]'}",
            f"  Satisfaction:    {m.get('satisfaction_pct', 0):>5.0f}% (target: {m.get('satisfaction_target', 0)}%) {'[OK]' if m.get('satisfaction_met') else '[LOW]'}",
            f"  Support Tickets: {m.get('support_requests', 0):>5} ({m.get('support_trend', 'N/A')})",
            f"  Active Users:    {m.get('active_users', 0)}/{m.get('total_users', 0)}",
            "",
        ])

    if avc:
        lines.extend([
            f"ADOPTION TYPE: {avc.get('type', 'N/A')}",
            f"  {avc.get('description', '')}",
            "",
        ])

    if results["trend_analysis"]:
        lines.extend(["WEEKLY TREND:", f"{'Week':>5} {'Usage':>7} {'Revert':>8} {'Satis':>7} {'Support':>8}"])
        for t in results["trend_analysis"]:
            lines.append(f"  W{t['week']:>2}  {t['usage_rate_pct']:>6.0f}% {t['reversion_rate_pct']:>7.0f}% {t['satisfaction_pct']:>6.0f}% {t['support_requests']:>8}")
        lines.append("")

    if results["at_risk_groups"]:
        lines.append("AT-RISK GROUPS:")
        for g in results["at_risk_groups"]:
            lines.append(f"  [!] {g['group']}: {g['usage_rate_pct']}% usage - {g['primary_concern']}")
        lines.append("")

    if results["recommendations"]:
        lines.append("RECOMMENDATIONS:")
        for r in results["recommendations"]:
            lines.append(f"  -> {r}")

    lines.extend(["", "=" * 60])
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Track change adoption metrics")
    parser.add_argument("--input", "-i", help="JSON file with adoption data")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if args.input:
        with open(args.input) as f:
            data = json.load(f)
    else:
        data = {
            "change_name": "New CRM System",
            "go_live_date": "2025-11-01",
            "targets": {"usage_rate_pct": 80, "reversion_rate_pct": 10, "satisfaction_pct": 60, "target_week": 8},
            "weekly_data": [
                {"usage_rate_pct": 25, "reversion_rate_pct": 30, "satisfaction_pct": 40, "support_requests": 45, "active_users": 12, "total_users": 48},
                {"usage_rate_pct": 40, "reversion_rate_pct": 22, "satisfaction_pct": 48, "support_requests": 38, "active_users": 19, "total_users": 48},
                {"usage_rate_pct": 55, "reversion_rate_pct": 18, "satisfaction_pct": 52, "support_requests": 28, "active_users": 26, "total_users": 48},
                {"usage_rate_pct": 62, "reversion_rate_pct": 14, "satisfaction_pct": 55, "support_requests": 20, "active_users": 30, "total_users": 48},
                {"usage_rate_pct": 68, "reversion_rate_pct": 12, "satisfaction_pct": 58, "support_requests": 15, "active_users": 33, "total_users": 48},
            ],
            "group_data": [
                {"name": "Sales Team", "usage_rate_pct": 82, "primary_concern": "None"},
                {"name": "Marketing", "usage_rate_pct": 65, "primary_concern": "Missing integrations"},
                {"name": "Finance", "usage_rate_pct": 35, "primary_concern": "Reporting limitations"},
            ],
        }

    results = track_adoption(data)
    if args.json:
        print(json.dumps(results, indent=2))
    else:
        print(format_text(results))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Change Readiness Assessor - Assess organizational readiness for change using ADKAR.

Evaluates readiness across ADKAR phases, identifies resistance patterns,
measures change fatigue, and generates targeted intervention plans.
"""

import argparse
import json
import sys
from datetime import datetime


ADKAR_PHASES = {
    "awareness": {"weight": 0.20, "failure_symptom": "Nobody told me why", "interventions": ["Re-communicate the WHY with data", "CEO video explaining the change", "FAQ document"]},
    "desire": {"weight": 0.25, "failure_symptom": "I understand but I don't agree", "interventions": ["Address individual concerns in 1:1s", "Involve resisters in HOW", "Show personal benefits"]},
    "knowledge": {"weight": 0.20, "failure_symptom": "I want to but I don't know how", "interventions": ["Training sessions", "Documentation and guides", "Office hours and help desk"]},
    "ability": {"weight": 0.20, "failure_symptom": "I know how but I can't do it yet", "interventions": ["Practice time with reduced workload", "Buddy system", "Support desk"]},
    "reinforcement": {"weight": 0.15, "failure_symptom": "We tried but went back to the old way", "interventions": ["Public wins and recognition", "Remove old system access", "Measure and report adoption"]},
}

RESISTANCE_PATTERNS = {
    "vocal_opposition": {"signal": "I understand but disagree", "phase": "desire", "severity": "medium"},
    "timing_challenge": {"signal": "Why now?", "phase": "awareness", "severity": "low"},
    "process_complaint": {"signal": "I wasn't consulted", "phase": "desire", "severity": "medium"},
    "capacity_excuse": {"signal": "I don't have time", "phase": "ability", "severity": "medium"},
    "historical_reference": {"signal": "We tried this before", "phase": "desire", "severity": "high"},
    "silent_noncompliance": {"signal": "No pushback but doesn't change", "phase": "unknown", "severity": "high"},
    "malicious_compliance": {"signal": "Does it technically but undermines", "phase": "desire", "severity": "critical"},
}

CHANGE_TYPES = {
    "process": {"timeline_weeks": "4-8", "hardest_phase": "ability"},
    "org": {"timeline_weeks": "12-24", "hardest_phase": "desire"},
    "strategy": {"timeline_weeks": "12-48", "hardest_phase": "awareness"},
    "culture": {"timeline_weeks": "48-96", "hardest_phase": "reinforcement"},
}


def assess_readiness(data: dict) -> dict:
    """Assess organizational change readiness."""
    change_type = data.get("change_type", "process")
    adkar_scores = data.get("adkar_scores", {})
    resistance_observed = data.get("resistance_patterns", [])
    active_changes = data.get("active_changes", [])
    stakeholder_count = data.get("affected_stakeholders", 0)

    type_config = CHANGE_TYPES.get(change_type, CHANGE_TYPES["process"])

    results = {
        "timestamp": datetime.now().isoformat(),
        "change_type": change_type,
        "change_description": data.get("change_description", ""),
        "timeline": type_config["timeline_weeks"],
        "hardest_phase": type_config["hardest_phase"],
        "overall_readiness": 0,
        "readiness_label": "",
        "adkar_assessment": {},
        "weakest_phase": "",
        "resistance_analysis": [],
        "fatigue_assessment": {},
        "intervention_plan": [],
        "communication_plan": [],
        "recommendations": [],
    }

    # ADKAR scoring
    total_readiness = 0
    weakest_score = 100
    weakest_phase = ""

    for phase, config in ADKAR_PHASES.items():
        score = adkar_scores.get(phase, 50)  # 0-100
        weighted = score * config["weight"]
        total_readiness += weighted

        if score < weakest_score:
            weakest_score = score
            weakest_phase = phase

        status = "Strong" if score >= 70 else "Adequate" if score >= 50 else "Weak" if score >= 30 else "Critical"
        results["adkar_assessment"][phase] = {
            "score": score,
            "weighted": round(weighted, 1),
            "status": status,
            "failure_symptom": config["failure_symptom"],
            "interventions": config["interventions"] if score < 70 else [],
        }

    results["overall_readiness"] = round(total_readiness, 1)
    results["weakest_phase"] = weakest_phase
    results["readiness_label"] = (
        "Ready" if total_readiness >= 75 else
        "Conditionally Ready" if total_readiness >= 55 else
        "Not Ready" if total_readiness >= 35 else
        "High Risk"
    )

    # Resistance analysis
    for pattern_name in resistance_observed:
        pattern = RESISTANCE_PATTERNS.get(pattern_name, {})
        if pattern:
            results["resistance_analysis"].append({
                "pattern": pattern_name.replace("_", " ").title(),
                "signal": pattern.get("signal", ""),
                "broken_phase": pattern.get("phase", "unknown"),
                "severity": pattern.get("severity", "medium"),
                "recommended_response": ADKAR_PHASES.get(pattern.get("phase", ""), {}).get("interventions", ["Diagnose in 1:1 conversation"])[0],
            })

    # Fatigue assessment
    active_count = len(active_changes)
    avg_absorption = sum(c.get("absorption_pct", 50) for c in active_changes) / max(1, active_count)
    fatigue_level = "Critical" if active_count >= 4 else "High" if active_count >= 3 and avg_absorption < 60 else "Moderate" if active_count >= 2 else "Low"

    results["fatigue_assessment"] = {
        "active_changes": active_count,
        "avg_absorption_pct": round(avg_absorption, 1),
        "fatigue_level": fatigue_level,
        "can_add_change": fatigue_level in ["Low", "Moderate"],
        "recommendation": (
            "Safe to proceed" if fatigue_level == "Low" else
            "Proceed with caution - communicate stability" if fatigue_level == "Moderate" else
            "Pause non-critical changes first" if fatigue_level == "High" else
            "Freeze all new changes. Rebuild trust."
        ),
        "active_change_inventory": active_changes,
    }

    # Intervention plan for weakest phases
    for phase, assessment in results["adkar_assessment"].items():
        if assessment["status"] in ["Weak", "Critical"]:
            for intervention in assessment["interventions"]:
                results["intervention_plan"].append({
                    "phase": phase,
                    "intervention": intervention,
                    "priority": "Immediate" if assessment["status"] == "Critical" else "This week",
                    "owner": "Change sponsor" if phase in ["awareness", "desire"] else "Change team",
                })

    # Communication plan
    results["communication_plan"] = [
        {"audience": "Leadership team", "order": 1, "channel": "In-person meeting", "content": "Full context + their role in rollout"},
        {"audience": "Directly affected employees", "order": 2, "channel": "Manager 1:1 or small group", "content": "Personal impact + support available"},
        {"audience": "All employees", "order": 3, "channel": "All-hands + written Q&A", "content": "WHY + WHAT + timeline + FAQ"},
        {"audience": "External stakeholders", "order": 4, "channel": "Appropriate channel", "content": "Need-to-know only"},
    ]

    # Recommendations
    if results["readiness_label"] == "High Risk":
        results["recommendations"].append("Do not proceed. Address Critical ADKAR gaps first.")
    if results["weakest_phase"]:
        results["recommendations"].append(f"Focus on '{results['weakest_phase']}' phase - scored {weakest_score}/100.")
    if not results["fatigue_assessment"]["can_add_change"]:
        results["recommendations"].append("Change fatigue detected. Complete or pause existing changes before adding new ones.")
    if resistance_observed:
        critical = [r for r in results["resistance_analysis"] if r["severity"] == "critical"]
        if critical:
            results["recommendations"].append(f"URGENT: {len(critical)} critical resistance pattern(s) detected. Address immediately.")

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    lines = [
        "=" * 60,
        "CHANGE READINESS ASSESSMENT",
        "=" * 60,
        f"Change: {results['change_description'] or results['change_type'].title()}",
        f"Type: {results['change_type'].title()}  |  Timeline: {results['timeline']} weeks",
        f"Overall Readiness: {results['overall_readiness']:.0f}/100 ({results['readiness_label']})",
        f"Weakest Phase: {results['weakest_phase'].upper()}",
        "",
        "ADKAR ASSESSMENT:",
        f"{'Phase':<16} {'Score':>6} {'Status':<12} {'Symptom'}",
        "-" * 60,
    ]

    for phase, a in results["adkar_assessment"].items():
        icon = "[G]" if a["status"] == "Strong" else "[Y]" if a["status"] == "Adequate" else "[R]"
        lines.append(f"{phase.title():<16} {a['score']:>5}/100 {icon} {a['status']:<9} {a['failure_symptom']}")

    if results["resistance_analysis"]:
        lines.extend(["", "RESISTANCE PATTERNS:"])
        for r in results["resistance_analysis"]:
            lines.append(f"  [{r['severity'].upper()}] {r['pattern']}: '{r['signal']}' -> Fix: {r['recommended_response']}")

    fa = results["fatigue_assessment"]
    lines.extend([
        "",
        f"CHANGE FATIGUE: {fa['fatigue_level']} ({fa['active_changes']} active changes, {fa['avg_absorption_pct']:.0f}% avg absorption)",
        f"  {fa['recommendation']}",
    ])

    if results["intervention_plan"]:
        lines.extend(["", "INTERVENTION PLAN:"])
        for ip in results["intervention_plan"][:6]:
            lines.append(f"  [{ip['priority']}] {ip['phase'].title()}: {ip['intervention']} (Owner: {ip['owner']})")

    if results["recommendations"]:
        lines.extend(["", "RECOMMENDATIONS:"])
        for r in results["recommendations"]:
            lines.append(f"  -> {r}")

    lines.extend(["", "=" * 60])
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Assess organizational change readiness")
    parser.add_argument("--input", "-i", help="JSON file with assessment data")
    parser.add_argument("--type", choices=["process", "org", "strategy", "culture"], default="process", help="Change type")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if args.input:
        with open(args.input) as f:
            data = json.load(f)
    else:
        data = {
            "change_type": args.type,
            "change_description": "New CRM system rollout",
            "affected_stakeholders": 45,
            "adkar_scores": {"awareness": 70, "desire": 45, "knowledge": 55, "ability": 35, "reinforcement": 60},
            "resistance_patterns": ["process_complaint", "capacity_excuse", "historical_reference"],
            "active_changes": [
                {"name": "Engineering reorg", "absorption_pct": 65},
                {"name": "Values refresh", "absorption_pct": 75},
            ],
        }

    results = assess_readiness(data)
    if args.json:
        print(json.dumps(results, indent=2))
    else:
        print(format_text(results))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Change Communication Planner - Generate sequenced communication plans.

Creates audience-sequenced communication plans with templates, channel
recommendations, and timing for organizational changes.
"""

import argparse
import json
import sys
from datetime import datetime, timedelta


CHANGE_COMM_TEMPLATES = {
    "process": {
        "phases": [
            {"timing": "T-2 weeks", "audience": "Leadership team", "channel": "In-person meeting", "content_type": "Full context briefing"},
            {"timing": "T-1 week", "audience": "Team leads", "channel": "Small group meeting", "content_type": "Heads-up with their role in rollout"},
            {"timing": "T-0 (Go-live)", "audience": "All affected employees", "channel": "Email + all-hands", "content_type": "Announcement with FAQ"},
            {"timing": "T+1 week", "audience": "All affected employees", "channel": "FAQ document + Slack", "content_type": "FAQ published, Q&A channel open"},
            {"timing": "T+4 weeks", "audience": "All affected employees", "channel": "Team meeting", "content_type": "Adoption check + public wins"},
            {"timing": "T+8 weeks", "audience": "All employees", "channel": "Email", "content_type": "Old system deprecated notice"},
        ],
    },
    "org": {
        "phases": [
            {"timing": "T-1 week", "audience": "Most affected individuals", "channel": "1:1 with manager", "content_type": "Personal impact conversation"},
            {"timing": "T-0", "audience": "All affected employees", "channel": "Synchronous meeting (in-person preferred)", "content_type": "WHY announcement with Q&A"},
            {"timing": "T+1 day", "audience": "Directly affected", "channel": "Manager 1:1s", "content_type": "Individual impact and support"},
            {"timing": "T+1 week", "audience": "All employees", "channel": "Written FAQ", "content_type": "Honest FAQ with what you CAN share"},
            {"timing": "T+2-4 weeks", "audience": "New structure", "channel": "Team meetings", "content_type": "New structure operating"},
            {"timing": "T+2 months", "audience": "All affected", "channel": "Retrospective", "content_type": "First retrospective"},
            {"timing": "T+3-6 months", "audience": "All", "channel": "HR check-ins", "content_type": "Regular health check-ins"},
        ],
    },
    "strategy": {
        "phases": [
            {"timing": "T-2 weeks", "audience": "Leadership team", "channel": "Off-site/meeting", "content_type": "Full alignment (everyone on same page)"},
            {"timing": "T-0", "audience": "All employees", "channel": "All-hands (employees BEFORE press)", "content_type": "Internal announcement"},
            {"timing": "T+1 week", "audience": "Each team", "channel": "Team-level meetings", "content_type": "'What does this mean for us' conversations"},
            {"timing": "T+2 weeks", "audience": "All employees", "channel": "CEO update", "content_type": "Resource reallocation announced"},
            {"timing": "T+1 month", "audience": "All employees", "channel": "Company update", "content_type": "First milestone of new direction visible"},
            {"timing": "T+ ongoing", "audience": "All employees", "channel": "Regular updates", "content_type": "Progress on new direction"},
        ],
    },
    "culture": {
        "phases": [
            {"timing": "T-8 weeks", "audience": "Representative sample", "channel": "Workshops", "content_type": "Input gathering on culture change"},
            {"timing": "T-4 weeks", "audience": "Leadership team", "channel": "Workshop", "content_type": "Define observable behaviors"},
            {"timing": "T-0", "audience": "All employees", "channel": "Story-based all-hands", "content_type": "Story-based announcement"},
            {"timing": "T+2 weeks", "audience": "All employees", "channel": "Written + examples", "content_type": "Behavioral anchors published"},
            {"timing": "T+1 month", "audience": "Leadership team", "channel": "Visible modeling", "content_type": "Leaders visibly model new behavior"},
            {"timing": "T+next review", "audience": "All employees", "channel": "Performance system", "content_type": "Behaviors in performance reviews"},
            {"timing": "T+ ongoing", "audience": "All employees", "channel": "Recognition", "content_type": "Public recognition of new behaviors"},
        ],
    },
}

MESSAGE_TEMPLATE = """
COMMUNICATION: {title}

1. WHAT IS CHANGING
   {what_changing}

2. WHY IT IS CHANGING
   {why_changing}

3. WHAT THIS MEANS FOR YOU
   {impact}

4. WHAT IS NOT CHANGING
   {not_changing}

5. TIMELINE
   {timeline}

6. HOW TO ASK QUESTIONS
   {questions_channel}

7. WHAT HAPPENS NEXT
   {next_step}
"""


def generate_plan(data: dict) -> dict:
    """Generate a change communication plan."""
    change_type = data.get("change_type", "process")
    change_name = data.get("change_name", "Change Initiative")
    go_live_date_str = data.get("go_live_date", "")
    message_inputs = data.get("message", {})

    try:
        go_live = datetime.strptime(go_live_date_str, "%Y-%m-%d")
    except (ValueError, TypeError):
        go_live = datetime.now() + timedelta(weeks=2)

    template = CHANGE_COMM_TEMPLATES.get(change_type, CHANGE_COMM_TEMPLATES["process"])

    results = {
        "timestamp": datetime.now().isoformat(),
        "change_name": change_name,
        "change_type": change_type,
        "go_live_date": go_live.strftime("%Y-%m-%d"),
        "communication_phases": [],
        "message_draft": "",
        "anti_patterns": [
            "Do NOT announce on Friday afternoon - people stew over the weekend",
            "Do NOT say 'this is final, questions are not welcome' - creates underground resistance",
            "Do NOT skip the FAQ - concerns go unaddressed",
            "Do NOT let leaders be exempt from the change - destroys credibility",
            "Do NOT communicate via email only for org changes - requires synchronous delivery",
        ],
        "quality_checklist": [
            {"check": "Specific dates included (not 'soon')", "status": False},
            {"check": "Named person for questions", "status": False},
            {"check": "What is NOT changing explicitly stated", "status": False},
            {"check": "FAQ prepared", "status": False},
            {"check": "Leadership aligned before announcement", "status": False},
            {"check": "Affected individuals told before general announcement", "status": False},
            {"check": "Follow-up cadence defined", "status": False},
        ],
        "recommendations": [],
    }

    # Build phases with actual dates
    for phase in template["phases"]:
        timing_str = phase["timing"]
        # Parse timing to compute date
        if timing_str.startswith("T-"):
            parts = timing_str.replace("T-", "").strip()
            if "week" in parts:
                weeks = int(parts.split()[0])
                phase_date = go_live - timedelta(weeks=weeks)
            elif "day" in parts:
                days = int(parts.split()[0])
                phase_date = go_live - timedelta(days=days)
            else:
                phase_date = go_live
        elif timing_str.startswith("T+"):
            parts = timing_str.replace("T+", "").strip()
            if "week" in parts:
                weeks = int(parts.split()[0])
                phase_date = go_live + timedelta(weeks=weeks)
            elif "day" in parts:
                days = int(parts.split()[0])
                phase_date = go_live + timedelta(days=days)
            elif "month" in parts:
                months = int(parts.split()[0])
                phase_date = go_live + timedelta(weeks=months * 4)
            else:
                phase_date = go_live + timedelta(weeks=4)
        else:
            phase_date = go_live

        results["communication_phases"].append({
            "timing": timing_str,
            "date": phase_date.strftime("%Y-%m-%d"),
            "audience": phase["audience"],
            "channel": phase["channel"],
            "content_type": phase["content_type"],
            "is_past_due": datetime.now() > phase_date,
        })

    # Generate message draft
    results["message_draft"] = MESSAGE_TEMPLATE.format(
        title=change_name,
        what_changing=message_inputs.get("what_changing", "[What is changing - 1-2 sentences, direct]"),
        why_changing=message_inputs.get("why_changing", "[The business reason - be honest]"),
        impact=message_inputs.get("impact", "[Practical impact on the audience]"),
        not_changing=message_inputs.get("not_changing", "[Stability anchor - what stays the same]"),
        timeline=message_inputs.get("timeline", "[Specific dates for key milestones]"),
        questions_channel=message_inputs.get("questions_channel", "[Channel, named person, office hours schedule]"),
        next_step=message_inputs.get("next_step", "[The very first concrete step]"),
    ).strip()

    # Recommendations
    past_due = [p for p in results["communication_phases"] if p["is_past_due"]]
    if past_due:
        results["recommendations"].append(f"{len(past_due)} communication phase(s) past due. Catch up immediately.")

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    lines = [
        "=" * 65,
        "CHANGE COMMUNICATION PLAN",
        "=" * 65,
        f"Change: {results['change_name']}",
        f"Type: {results['change_type'].title()}  |  Go-Live: {results['go_live_date']}",
        "",
        "COMMUNICATION SEQUENCE:",
        f"{'Timing':<14} {'Date':<12} {'Audience':<25} {'Channel':<22}",
        "-" * 65,
    ]

    for p in results["communication_phases"]:
        flag = " [PAST DUE]" if p["is_past_due"] else ""
        lines.append(f"{p['timing']:<14} {p['date']:<12} {p['audience']:<25} {p['channel']:<22}{flag}")
        lines.append(f"{'':>14} Content: {p['content_type']}")

    lines.extend(["", "MESSAGE TEMPLATE:", "-" * 40, results["message_draft"], "-" * 40])

    lines.extend(["", "ANTI-PATTERNS TO AVOID:"])
    for ap in results["anti_patterns"]:
        lines.append(f"  [X] {ap}")

    if results["recommendations"]:
        lines.extend(["", "RECOMMENDATIONS:"])
        for r in results["recommendations"]:
            lines.append(f"  -> {r}")

    lines.extend(["", "=" * 65])
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Generate change communication plan")
    parser.add_argument("--input", "-i", help="JSON file with communication data")
    parser.add_argument("--type", choices=["process", "org", "strategy", "culture"], default="process", help="Change type")
    parser.add_argument("--name", help="Change name")
    parser.add_argument("--date", help="Go-live date (YYYY-MM-DD)")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if args.input:
        with open(args.input) as f:
            data = json.load(f)
    else:
        data = {
            "change_type": args.type,
            "change_name": args.name or "New CRM Rollout",
            "go_live_date": args.date or (datetime.now() + timedelta(weeks=3)).strftime("%Y-%m-%d"),
        }

    results = generate_plan(data)
    if args.json:
        print(json.dumps(results, indent=2))
    else:
        print(format_text(results))


if __name__ == "__main__":
    main()