Culture Architect

#!/usr/bin/env python3
"""
Culture Survey Analyzer - Analyze culture health survey results across 8 dimensions.

Calculates dimension scores, overall health rating, identifies strengths and risks,
segments by department/tenure, and generates action recommendations.

Usage:
    python culture_survey_analyzer.py --input survey_data.json
    python culture_survey_analyzer.py --input survey_data.json --json
"""

import argparse
import json
import sys
from datetime import datetime
from statistics import mean, stdev


DIMENSIONS = [
    "psychological_safety", "clarity", "fairness", "growth",
    "trust_in_leadership", "recognition", "belonging", "autonomy"
]

DIMENSION_LABELS = {
    "psychological_safety": "Psychological Safety",
    "clarity": "Clarity",
    "fairness": "Fairness",
    "growth": "Growth",
    "trust_in_leadership": "Trust in Leadership",
    "recognition": "Recognition",
    "belonging": "Belonging",
    "autonomy": "Autonomy",
}


def load_data(path):
    with open(path, "r") as f:
        return json.load(f)


def get_health_label(score):
    if score >= 80:
        return "Healthy"
    elif score >= 65:
        return "Warning"
    elif score >= 50:
        return "Damaged"
    else:
        return "Crisis"


def get_action_timeline(label):
    return {"Healthy": "Maintain", "Warning": "30 days", "Damaged": "14 days", "Crisis": "Immediate"}.get(label, "Review")


def analyze_dimension(responses, dimension):
    """Analyze a single dimension across all responses."""
    scores = []
    for r in responses:
        val = r.get("scores", {}).get(dimension)
        if val is not None:
            scores.append(val)

    if not scores:
        return {"score": 0, "label": "No data", "responses": 0}

    avg = round(mean(scores), 1)
    label = get_health_label(avg)

    result = {
        "score": avg,
        "label": label,
        "action_timeline": get_action_timeline(label),
        "responses": len(scores),
        "min": min(scores),
        "max": max(scores),
    }

    if len(scores) >= 3:
        result["stdev"] = round(stdev(scores), 1)

    return result


def segment_analysis(responses, segment_key):
    """Analyze scores segmented by a key (department, tenure, etc.)."""
    segments = {}
    for r in responses:
        seg = r.get(segment_key, "unknown")
        if seg not in segments:
            segments[seg] = []
        segments[seg].append(r)

    results = {}
    for seg_name, seg_responses in segments.items():
        dim_scores = {}
        for dim in DIMENSIONS:
            scores = [r.get("scores", {}).get(dim, 0) for r in seg_responses if r.get("scores", {}).get(dim) is not None]
            if scores:
                dim_scores[dim] = round(mean(scores), 1)

        overall = round(mean(dim_scores.values()), 1) if dim_scores else 0
        results[seg_name] = {
            "respondents": len(seg_responses),
            "overall_score": overall,
            "health": get_health_label(overall),
            "dimension_scores": dim_scores,
        }

    return results


def calculate_enps(responses):
    """Calculate eNPS from responses."""
    enps_scores = [r.get("enps_score") for r in responses if r.get("enps_score") is not None]
    if not enps_scores:
        return None

    promoters = sum(1 for s in enps_scores if s >= 9) / len(enps_scores) * 100
    detractors = sum(1 for s in enps_scores if s <= 6) / len(enps_scores) * 100
    enps = round(promoters - detractors, 1)

    if enps > 50:
        label = "Exceptional"
    elif enps > 30:
        label = "Good"
    elif enps > 10:
        label = "Acceptable"
    elif enps > 0:
        label = "Concerning"
    else:
        label = "Crisis"

    return {
        "score": enps,
        "label": label,
        "promoters_pct": round(promoters, 1),
        "detractors_pct": round(detractors, 1),
        "passives_pct": round(100 - promoters - detractors, 1),
        "total_responses": len(enps_scores),
    }


def analyze_survey(data):
    """Run full survey analysis."""
    responses = data.get("responses", [])
    org_name = data.get("organization", "Organization")
    survey_date = data.get("survey_date", datetime.now().strftime("%Y-%m-%d"))

    results = {
        "timestamp": datetime.now().isoformat(),
        "organization": org_name,
        "survey_date": survey_date,
        "total_responses": len(responses),
        "participation_rate_pct": data.get("participation_rate_pct", 0),
        "overall_health_score": 0,
        "overall_health_label": "",
        "dimension_results": {},
        "strengths": [],
        "risks": [],
        "enps": None,
        "department_analysis": {},
        "tenure_analysis": {},
        "recommendations": [],
    }

    # Analyze each dimension
    dim_scores = []
    for dim in DIMENSIONS:
        result = analyze_dimension(responses, dim)
        results["dimension_results"][dim] = result
        if result["score"] > 0:
            dim_scores.append(result["score"])

    # Overall score
    if dim_scores:
        results["overall_health_score"] = round(mean(dim_scores), 1)
        results["overall_health_label"] = get_health_label(results["overall_health_score"])

    # Identify strengths and risks
    sorted_dims = sorted(results["dimension_results"].items(), key=lambda x: x[1]["score"], reverse=True)
    results["strengths"] = [
        {"dimension": DIMENSION_LABELS.get(d, d), "score": info["score"]}
        for d, info in sorted_dims[:3] if info["score"] >= 65
    ]
    results["risks"] = [
        {"dimension": DIMENSION_LABELS.get(d, d), "score": info["score"], "action_timeline": info["action_timeline"]}
        for d, info in sorted_dims if info["score"] < 65
    ]

    # eNPS
    results["enps"] = calculate_enps(responses)

    # Segment analysis
    if any(r.get("department") for r in responses):
        results["department_analysis"] = segment_analysis(responses, "department")
    if any(r.get("tenure") for r in responses):
        results["tenure_analysis"] = segment_analysis(responses, "tenure")

    # Recommendations
    recs = results["recommendations"]
    participation = results["participation_rate_pct"]
    if participation > 0 and participation < 50:
        recs.append(f"Low participation ({participation}%) -- results may not be representative; address trust in anonymity")

    for risk in results["risks"][:3]:
        recs.append(f"Address {risk['dimension']} (score: {risk['score']}) within {risk['action_timeline']}")

    if results["enps"] and results["enps"]["score"] < 10:
        recs.append(f"eNPS at {results['enps']['score']} ({results['enps']['label']}) -- investigate detractor feedback")

    # Department-level risks
    for dept, info in results.get("department_analysis", {}).items():
        if info["overall_score"] < 50:
            recs.append(f"Department '{dept}' in crisis (score: {info['overall_score']}) -- targeted intervention needed")

    return results


def format_text(results):
    lines = [
        "=" * 60,
        "CULTURE HEALTH SURVEY ANALYSIS",
        "=" * 60,
        f"Organization: {results['organization']}",
        f"Survey Date: {results['survey_date']}",
        f"Responses: {results['total_responses']} (participation: {results['participation_rate_pct']}%)",
        "",
        f"OVERALL HEALTH: {results['overall_health_score']}/100 ({results['overall_health_label']})",
    ]

    if results["enps"]:
        lines.append(f"eNPS: {results['enps']['score']} ({results['enps']['label']}) -- "
                      f"Promoters: {results['enps']['promoters_pct']}%, Detractors: {results['enps']['detractors_pct']}%")

    lines.append("")
    lines.append("DIMENSION SCORES")
    for dim in DIMENSIONS:
        info = results["dimension_results"].get(dim, {})
        label = DIMENSION_LABELS.get(dim, dim)
        lines.append(f"  {label}: {info.get('score', 0)}/100 ({info.get('label', 'N/A')}) [{info.get('action_timeline', '')}]")

    if results["strengths"]:
        lines.append("")
        lines.append("STRENGTHS")
        for s in results["strengths"]:
            lines.append(f"  + {s['dimension']}: {s['score']}/100")

    if results["risks"]:
        lines.append("")
        lines.append("RISKS")
        for r in results["risks"]:
            lines.append(f"  ! {r['dimension']}: {r['score']}/100 (action: {r['action_timeline']})")

    if results["department_analysis"]:
        lines.append("")
        lines.append("BY DEPARTMENT")
        for dept, info in sorted(results["department_analysis"].items(), key=lambda x: x[1]["overall_score"]):
            lines.append(f"  {dept}: {info['overall_score']}/100 ({info['health']}) -- {info['respondents']} responses")

    if results["recommendations"]:
        lines.append("")
        lines.append("RECOMMENDATIONS")
        for rec in results["recommendations"]:
            lines.append(f"  * {rec}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Analyze culture health survey results across 8 dimensions")
    parser.add_argument("--input", required=True, help="Path to JSON survey data file")
    parser.add_argument("--json", action="store_true", help="Output in JSON format")
    args = parser.parse_args()

    try:
        data = load_data(args.input)
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Error loading input file: {e}", file=sys.stderr)
        sys.exit(1)

    results = analyze_survey(data)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Engagement Tracker - Track employee engagement metrics over time.

Tracks eNPS, survey scores, participation rates, and retention correlation.
Detects trends, flags declining dimensions, and generates quarterly engagement reports.

Usage:
    python engagement_tracker.py --input engagement_data.json
    python engagement_tracker.py --input engagement_data.json --json
"""

import argparse
import json
import sys
from datetime import datetime


def load_data(path):
    with open(path, "r") as f:
        return json.load(f)


def classify_enps(score):
    if score > 50:
        return "Exceptional"
    elif score > 30:
        return "Good"
    elif score > 10:
        return "Acceptable"
    elif score > 0:
        return "Concerning"
    else:
        return "Crisis"


def detect_trend(values):
    """Detect trend from a list of values (oldest to newest)."""
    if len(values) < 2:
        return "insufficient_data"

    recent = values[-1]
    previous = values[-2]

    if len(values) >= 3:
        avg_earlier = sum(values[:-1]) / len(values[:-1])
        if recent > avg_earlier * 1.05:
            return "improving"
        elif recent < avg_earlier * 0.95:
            return "declining"
        return "stable"
    else:
        if recent > previous * 1.05:
            return "improving"
        elif recent < previous * 0.95:
            return "declining"
        return "stable"


def calculate_correlation(engagement_scores, attrition_rates):
    """Simple correlation indicator between engagement and attrition."""
    if len(engagement_scores) < 3 or len(attrition_rates) < 3:
        return None

    n = min(len(engagement_scores), len(attrition_rates))
    eng = engagement_scores[:n]
    att = attrition_rates[:n]

    # Check if engagement drops precede attrition increases
    lag_matches = 0
    for i in range(1, n):
        if eng[i] < eng[i - 1] and att[i] > att[i - 1]:
            lag_matches += 1
        elif eng[i] > eng[i - 1] and att[i] < att[i - 1]:
            lag_matches += 1

    correlation_strength = round(lag_matches / max(n - 1, 1), 2)

    if correlation_strength >= 0.7:
        return {"strength": "strong", "score": correlation_strength, "insight": "Engagement changes strongly predict attrition changes"}
    elif correlation_strength >= 0.4:
        return {"strength": "moderate", "score": correlation_strength, "insight": "Some relationship between engagement and attrition"}
    else:
        return {"strength": "weak", "score": correlation_strength, "insight": "Engagement and attrition may be driven by different factors"}


def analyze_engagement(data):
    """Run full engagement analysis."""
    org_name = data.get("organization", "Organization")
    periods = data.get("periods", [])

    results = {
        "timestamp": datetime.now().isoformat(),
        "organization": org_name,
        "periods_analyzed": len(periods),
        "current_state": {},
        "period_results": [],
        "trends": {},
        "alerts": [],
        "attrition_correlation": None,
        "recommendations": [],
    }

    enps_values = []
    overall_scores = []
    participation_values = []
    attrition_values = []

    for period in periods:
        period_name = period.get("period", "Unknown")
        enps = period.get("enps_score", 0)
        overall = period.get("overall_engagement_score", 0)
        participation = period.get("participation_rate_pct", 0)
        attrition = period.get("attrition_rate_pct", 0)
        dimension_scores = period.get("dimension_scores", {})

        enps_values.append(enps)
        overall_scores.append(overall)
        participation_values.append(participation)
        if attrition > 0:
            attrition_values.append(attrition)

        period_result = {
            "period": period_name,
            "enps": enps,
            "enps_label": classify_enps(enps),
            "overall_score": overall,
            "participation_rate": participation,
            "attrition_rate": attrition,
            "dimension_scores": dimension_scores,
            "respondents": period.get("respondents", 0),
        }
        results["period_results"].append(period_result)

    # Current state (latest period)
    if results["period_results"]:
        latest = results["period_results"][-1]
        results["current_state"] = {
            "enps": latest["enps"],
            "enps_label": latest["enps_label"],
            "overall_score": latest["overall_score"],
            "participation_rate": latest["participation_rate"],
            "attrition_rate": latest["attrition_rate"],
        }

    # Trends
    results["trends"] = {
        "enps": detect_trend(enps_values),
        "overall_score": detect_trend(overall_scores),
        "participation": detect_trend(participation_values),
    }

    # Dimension trends (if available across periods)
    all_dim_names = set()
    for p in periods:
        all_dim_names.update(p.get("dimension_scores", {}).keys())

    dimension_trends = {}
    for dim in all_dim_names:
        dim_values = [p.get("dimension_scores", {}).get(dim) for p in periods]
        dim_values = [v for v in dim_values if v is not None]
        if dim_values:
            trend = detect_trend(dim_values)
            dimension_trends[dim] = {
                "latest": dim_values[-1] if dim_values else 0,
                "trend": trend,
            }
            if trend == "declining":
                results["alerts"].append({
                    "dimension": dim,
                    "severity": "high" if dim_values[-1] < 50 else "medium",
                    "message": f"{dim} declining (latest: {dim_values[-1]})",
                })

    results["trends"]["dimensions"] = dimension_trends

    # Attrition correlation
    if overall_scores and attrition_values:
        results["attrition_correlation"] = calculate_correlation(overall_scores, attrition_values)

    # Alerts
    if results["current_state"].get("enps", 0) < 10:
        results["alerts"].append({
            "dimension": "eNPS",
            "severity": "high",
            "message": f"eNPS at {results['current_state']['enps']} -- investigate detractor feedback",
        })

    if results["current_state"].get("participation_rate", 0) < 50:
        results["alerts"].append({
            "dimension": "Participation",
            "severity": "high",
            "message": f"Participation at {results['current_state']['participation_rate']}% -- trust in anonymity may be low",
        })

    if results["trends"]["enps"] == "declining":
        results["alerts"].append({
            "dimension": "eNPS Trend",
            "severity": "high",
            "message": "eNPS declining -- pattern requires root cause analysis",
        })

    # Recommendations
    recs = results["recommendations"]
    for alert in results["alerts"]:
        if alert["severity"] == "high":
            recs.append(f"URGENT: {alert['message']}")

    if results["attrition_correlation"] and results["attrition_correlation"]["strength"] == "strong":
        recs.append("Strong engagement-attrition correlation -- engagement improvements will likely reduce attrition")

    if results["trends"]["overall_score"] == "declining":
        recs.append("Overall engagement declining -- conduct focused listening sessions to identify root causes")

    declining_dims = [d for d, info in dimension_trends.items() if info["trend"] == "declining"]
    if declining_dims:
        recs.append(f"Declining dimensions: {', '.join(declining_dims)} -- prioritize these in next action plan")

    return results


def format_text(results):
    lines = [
        "=" * 60,
        "ENGAGEMENT TRACKING REPORT",
        "=" * 60,
        f"Organization: {results['organization']}",
        f"Periods Analyzed: {results['periods_analyzed']}",
        f"Report Date: {results['timestamp'][:10]}",
    ]

    cs = results["current_state"]
    if cs:
        lines.extend([
            "",
            "CURRENT STATE",
            f"  eNPS: {cs.get('enps', 0)} ({cs.get('enps_label', 'N/A')})",
            f"  Overall Score: {cs.get('overall_score', 0)}/100",
            f"  Participation: {cs.get('participation_rate', 0)}%",
            f"  Attrition: {cs.get('attrition_rate', 0)}%",
        ])

    lines.append("")
    lines.append("TRENDS")
    for metric, trend in results["trends"].items():
        if isinstance(trend, dict):
            continue  # Skip nested dimension trends
        arrow = {"improving": "+", "declining": "-", "stable": "=", "insufficient_data": "?"}
        lines.append(f"  [{arrow.get(trend, '?')}] {metric}: {trend}")

    dim_trends = results["trends"].get("dimensions", {})
    if dim_trends:
        lines.append("")
        lines.append("DIMENSION TRENDS")
        for dim, info in sorted(dim_trends.items(), key=lambda x: x[1]["latest"]):
            arrow = {"improving": "+", "declining": "-", "stable": "=", "insufficient_data": "?"}
            lines.append(f"  [{arrow.get(info['trend'], '?')}] {dim}: {info['latest']}/100 ({info['trend']})")

    lines.append("")
    lines.append("PERIOD HISTORY")
    for p in results["period_results"]:
        lines.append(f"  {p['period']}: eNPS={p['enps']} ({p['enps_label']}), score={p['overall_score']}, "
                      f"participation={p['participation_rate']}%, attrition={p['attrition_rate']}%")

    if results["attrition_correlation"]:
        ac = results["attrition_correlation"]
        lines.extend([
            "",
            "ENGAGEMENT-ATTRITION CORRELATION",
            f"  Strength: {ac['strength']} (score: {ac['score']})",
            f"  Insight: {ac['insight']}",
        ])

    if results["alerts"]:
        lines.append("")
        lines.append("ALERTS")
        for a in results["alerts"]:
            lines.append(f"  [{a['severity'].upper()}] {a['message']}")

    if results["recommendations"]:
        lines.append("")
        lines.append("RECOMMENDATIONS")
        for rec in results["recommendations"]:
            lines.append(f"  * {rec}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Track employee engagement metrics over time with trend detection")
    parser.add_argument("--input", required=True, help="Path to JSON engagement data file")
    parser.add_argument("--json", action="store_true", help="Output in JSON format")
    args = parser.parse_args()

    try:
        data = load_data(args.input)
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Error loading input file: {e}", file=sys.stderr)
        sys.exit(1)

    results = analyze_engagement(data)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Values Alignment Scorer - Score alignment between stated values and observed behaviors.

Uses Competing Values Framework (CVF) quadrants (Clan, Adhocracy, Market, Hierarchy).
Detects gaps between current and desired culture, identifies value-washing risks,
and recommends alignment actions.

Usage:
    python values_alignment_scorer.py --input values_data.json
    python values_alignment_scorer.py --input values_data.json --json
"""

import argparse
import json
import sys
from datetime import datetime


CVF_QUADRANTS = {
    "clan": {
        "label": "Clan (Collaborate)",
        "focus": "Internal focus + Flexibility",
        "traits": ["teamwork", "mentoring", "participation", "loyalty", "morale"],
    },
    "adhocracy": {
        "label": "Adhocracy (Create)",
        "focus": "External focus + Flexibility",
        "traits": ["innovation", "risk-taking", "agility", "experimentation", "entrepreneurship"],
    },
    "market": {
        "label": "Market (Compete)",
        "focus": "External focus + Stability",
        "traits": ["competition", "results", "achievement", "market_share", "goal_setting"],
    },
    "hierarchy": {
        "label": "Hierarchy (Control)",
        "focus": "Internal focus + Stability",
        "traits": ["efficiency", "consistency", "process", "compliance", "predictability"],
    },
}


def load_data(path):
    with open(path, "r") as f:
        return json.load(f)


def score_value_alignment(stated, observed):
    """Score alignment between stated and observed behavioral evidence."""
    if observed >= stated * 0.9:
        return {"score": round((observed / max(stated, 1)) * 100, 1), "status": "Aligned"}
    elif observed >= stated * 0.6:
        gap = round(stated - observed, 1)
        return {"score": round((observed / max(stated, 1)) * 100, 1), "status": "Gap", "gap": gap}
    else:
        gap = round(stated - observed, 1)
        return {"score": round((observed / max(stated, 1)) * 100, 1), "status": "Value-washing risk", "gap": gap}


def analyze_cvf(cvf_data):
    """Analyze Competing Values Framework quadrant distribution."""
    if not cvf_data:
        return None

    current = cvf_data.get("current", {})
    desired = cvf_data.get("desired", {})

    # Validate totals should be ~100
    current_total = sum(current.values())
    desired_total = sum(desired.values())

    quadrant_analysis = {}
    for q_key, q_info in CVF_QUADRANTS.items():
        curr = current.get(q_key, 0)
        des = desired.get(q_key, 0)
        shift = round(des - curr, 1)

        quadrant_analysis[q_key] = {
            "label": q_info["label"],
            "current_pct": curr,
            "desired_pct": des,
            "shift_needed": shift,
            "direction": "increase" if shift > 0 else ("decrease" if shift < 0 else "maintain"),
        }

    # Dominant culture
    dominant_current = max(current, key=current.get) if current else None
    dominant_desired = max(desired, key=desired.get) if desired else None

    return {
        "quadrants": quadrant_analysis,
        "dominant_current": CVF_QUADRANTS.get(dominant_current, {}).get("label", "Unknown"),
        "dominant_desired": CVF_QUADRANTS.get(dominant_desired, {}).get("label", "Unknown"),
        "culture_shift_needed": dominant_current != dominant_desired,
    }


def analyze_values(data):
    """Run full values alignment analysis."""
    org_name = data.get("organization", "Organization")
    values = data.get("values", [])
    cvf_data = data.get("cvf_assessment", {})

    results = {
        "timestamp": datetime.now().isoformat(),
        "organization": org_name,
        "values_count": len(values),
        "overall_alignment_score": 0,
        "overall_alignment_label": "",
        "value_assessments": [],
        "aligned_values": [],
        "gap_values": [],
        "washing_risks": [],
        "cvf_analysis": None,
        "recommendations": [],
    }

    alignment_scores = []

    for val in values:
        name = val.get("name", "Unnamed")
        stated_importance = val.get("stated_importance", 10)  # 1-10
        behavioral_evidence = val.get("behavioral_evidence_score", 0)  # 1-10
        behaviors = val.get("observable_behaviors", [])
        violations = val.get("observed_violations", [])
        trade_off = val.get("trade_off", "Not defined")

        alignment = score_value_alignment(stated_importance, behavioral_evidence)
        has_trade_off = trade_off != "Not defined" and trade_off != ""

        assessment = {
            "name": name,
            "stated_importance": stated_importance,
            "behavioral_evidence": behavioral_evidence,
            "alignment_score": alignment["score"],
            "alignment_status": alignment["status"],
            "gap": alignment.get("gap", 0),
            "observable_behaviors": behaviors,
            "violations_observed": violations,
            "trade_off_defined": has_trade_off,
            "trade_off": trade_off,
        }

        # Flag platitudes (no trade-off defined)
        if not has_trade_off:
            assessment["warning"] = "No trade-off defined -- may be a platitude, not a real value"

        results["value_assessments"].append(assessment)
        alignment_scores.append(alignment["score"])

        if alignment["status"] == "Aligned":
            results["aligned_values"].append(name)
        elif alignment["status"] == "Gap":
            results["gap_values"].append({"name": name, "gap": alignment.get("gap", 0)})
        elif alignment["status"] == "Value-washing risk":
            results["washing_risks"].append({"name": name, "gap": alignment.get("gap", 0)})

    # Overall alignment
    if alignment_scores:
        results["overall_alignment_score"] = round(sum(alignment_scores) / len(alignment_scores), 1)
        score = results["overall_alignment_score"]
        if score >= 80:
            results["overall_alignment_label"] = "Strong alignment"
        elif score >= 60:
            results["overall_alignment_label"] = "Moderate alignment -- gaps to address"
        elif score >= 40:
            results["overall_alignment_label"] = "Weak alignment -- significant gaps"
        else:
            results["overall_alignment_label"] = "Values are performative -- rebuild from reality"

    # CVF analysis
    if cvf_data:
        results["cvf_analysis"] = analyze_cvf(cvf_data)

    # Recommendations
    recs = results["recommendations"]
    if results["washing_risks"]:
        names = ", ".join(w["name"] for w in results["washing_risks"])
        recs.append(f"VALUE-WASHING RISK: {names} -- stated importance far exceeds behavioral evidence")
        recs.append("Either invest in making these values real or rewrite values to match actual culture")

    platitudes = [a for a in results["value_assessments"] if not a["trade_off_defined"]]
    if platitudes:
        recs.append(f"{len(platitudes)} values have no defined trade-off -- run values-to-behaviors workshop")

    if len(values) > 5:
        recs.append(f"{len(values)} values defined -- reduce to 3-5 maximum for memorability")

    if results["cvf_analysis"] and results["cvf_analysis"]["culture_shift_needed"]:
        recs.append(
            f"Culture shift needed: {results['cvf_analysis']['dominant_current']} -> "
            f"{results['cvf_analysis']['dominant_desired']} -- plan for 12-24 month transition"
        )

    return results


def format_text(results):
    lines = [
        "=" * 60,
        "VALUES ALIGNMENT SCORECARD",
        "=" * 60,
        f"Organization: {results['organization']}",
        f"Values Assessed: {results['values_count']}",
        f"Analysis Date: {results['timestamp'][:10]}",
        "",
        f"OVERALL ALIGNMENT: {results['overall_alignment_score']}% ({results['overall_alignment_label']})",
        "",
        "VALUE ASSESSMENTS",
    ]

    for v in results["value_assessments"]:
        status_icon = {"Aligned": "+", "Gap": "~", "Value-washing risk": "!!"}.get(v["alignment_status"], "?")
        lines.append(f"\n  [{status_icon}] {v['name']}")
        lines.append(f"      Stated: {v['stated_importance']}/10 | Evidence: {v['behavioral_evidence']}/10 | Alignment: {v['alignment_score']}%")
        lines.append(f"      Status: {v['alignment_status']}")
        if v.get("trade_off_defined"):
            lines.append(f"      Trade-off: {v['trade_off']}")
        else:
            lines.append(f"      Trade-off: NOT DEFINED (may be a platitude)")
        if v.get("warning"):
            lines.append(f"      WARNING: {v['warning']}")

    if results["aligned_values"]:
        lines.append("")
        lines.append(f"ALIGNED VALUES: {', '.join(results['aligned_values'])}")

    if results["washing_risks"]:
        lines.append("")
        lines.append("VALUE-WASHING RISKS")
        for w in results["washing_risks"]:
            lines.append(f"  !! {w['name']} (gap: {w['gap']})")

    if results["cvf_analysis"]:
        cvf = results["cvf_analysis"]
        lines.append("")
        lines.append("COMPETING VALUES FRAMEWORK")
        lines.append(f"  Dominant Culture: {cvf['dominant_current']}")
        lines.append(f"  Desired Culture: {cvf['dominant_desired']}")
        lines.append(f"  Shift Needed: {'Yes' if cvf['culture_shift_needed'] else 'No'}")
        for q, info in cvf["quadrants"].items():
            lines.append(f"    {info['label']}: {info['current_pct']}% -> {info['desired_pct']}% ({info['direction']})")

    if results["recommendations"]:
        lines.append("")
        lines.append("RECOMMENDATIONS")
        for rec in results["recommendations"]:
            lines.append(f"  * {rec}")

    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Score values alignment using CVF and behavioral evidence")
    parser.add_argument("--input", required=True, help="Path to JSON values data file")
    parser.add_argument("--json", action="store_true", help="Output in JSON format")
    args = parser.parse_args()

    try:
        data = load_data(args.input)
    except (FileNotFoundError, json.JSONDecodeError) as e:
        print(f"Error loading input file: {e}", file=sys.stderr)
        sys.exit(1)

    results = analyze_values(data)

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


if __name__ == "__main__":
    main()