Board Meeting

#!/usr/bin/env python3
"""
Decision Complexity Scorer - Score decision complexity to determine routing.

Evaluates decisions against domain count, reversibility, financial impact,
team impact, and time pressure. Outputs routing recommendation.
"""

import argparse
import json
import sys
from datetime import datetime


FACTORS = {
    "domain_count": {"weight": 0.25, "scores": {0: "Single domain", 1: "2 domains", 2: "3+ domains"}},
    "reversibility": {"weight": 0.25, "scores": {0: "Easily reversed", 1: "Partially reversible", 2: "Irreversible"}},
    "financial_impact": {"weight": 0.20, "scores": {0: "< 5% of budget", 1: "5-20% of budget", 2: "> 20% of budget"}},
    "team_impact": {"weight": 0.15, "scores": {0: "Single team", 1: "Multiple teams", 2: "Org-wide"}},
    "time_pressure": {"weight": 0.15, "scores": {0: "No urgency", 1: "Days to decide", 2: "Hours to decide"}},
}

MODIFIERS = [
    {"id": "cross_functional", "label": "Affects 2+ functional areas", "add": 1},
    {"id": "irreversible_costly", "label": "Decision is irreversible or very costly to reverse", "add": 1},
    {"id": "disagreement", "label": "Expected disagreement between advisors", "add": 1},
    {"id": "team_10_plus", "label": "Direct impact on 10+ team members", "add": 1},
    {"id": "compliance", "label": "Compliance or regulatory dimension", "add": 1},
    {"id": "external_stakeholders", "label": "Involves external stakeholders (board, investors, partners)", "add": 1},
    {"id": "sets_precedent", "label": "Sets precedent for future decisions", "add": 1},
    {"id": "contradicts_previous", "label": "Contradicts a previous logged decision", "add": 1},
]

ROUTING = [
    {"min": 1, "max": 3, "type": "SINGLE ADVISOR", "description": "Route to primary domain expert. Return answer directly."},
    {"min": 4, "max": 6, "type": "DUAL ADVISOR", "description": "Route to primary + secondary. Synthesize before returning."},
    {"min": 7, "max": 8, "type": "MULTI-ADVISOR", "description": "Route to 3-4 relevant roles. Full synthesis with conflict mapping."},
    {"min": 9, "max": 10, "type": "FULL BOARD MEETING", "description": "Invoke board-meeting protocol. All relevant roles contribute independently."},
]


def score_complexity(data: dict) -> dict:
    """Score decision complexity and determine routing."""
    factor_scores = data.get("factors", {})
    active_modifiers = data.get("modifiers", [])
    topic = data.get("topic", "Unspecified")

    results = {
        "timestamp": datetime.now().isoformat(),
        "topic": topic,
        "factor_scores": {},
        "base_score": 0,
        "modifier_score": 0,
        "total_score": 0,
        "active_modifiers": [],
        "routing": {},
        "recommended_roles": [],
        "rationale": [],
    }

    # Score factors
    base_total = 0
    for factor_name, config in FACTORS.items():
        score = factor_scores.get(factor_name, 1)
        score = min(2, max(0, score))
        weighted = score * config["weight"] * 5  # Scale to contribute to 0-10
        base_total += weighted
        results["factor_scores"][factor_name] = {
            "score": score,
            "label": config["scores"].get(score, "Unknown"),
            "weight": config["weight"],
            "weighted": round(weighted, 2),
        }

    results["base_score"] = round(base_total, 1)

    # Apply modifiers
    modifier_total = 0
    for mod in MODIFIERS:
        if mod["id"] in active_modifiers:
            modifier_total += mod["add"]
            results["active_modifiers"].append(mod["label"])

    results["modifier_score"] = modifier_total
    results["total_score"] = min(10, round(results["base_score"] + modifier_total))

    # Determine routing
    total = results["total_score"]
    for route in ROUTING:
        if route["min"] <= total <= route["max"]:
            results["routing"] = {
                "type": route["type"],
                "description": route["description"],
                "score_range": f"{route['min']}-{route['max']}",
            }
            break

    # Build rationale
    high_factors = [(n, d) for n, d in results["factor_scores"].items() if d["score"] == 2]
    if high_factors:
        results["rationale"].append(
            f"High complexity factors: {', '.join(d['label'] for _, d in high_factors)}"
        )
    if results["active_modifiers"]:
        results["rationale"].append(
            f"Active modifiers (+{modifier_total}): {', '.join(results['active_modifiers'][:3])}"
        )
    results["rationale"].append(
        f"Total score {total}/10 -> {results['routing'].get('type', 'Unknown')}"
    )

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    lines = [
        "=" * 60,
        "DECISION COMPLEXITY ASSESSMENT",
        "=" * 60,
        f"Topic: {results['topic']}",
        f"Complexity Score: {results['total_score']}/10 (base: {results['base_score']:.1f}, modifiers: +{results['modifier_score']})",
        f"Routing: {results['routing'].get('type', 'N/A')}",
        "",
        "FACTOR BREAKDOWN:",
        f"{'Factor':<20} {'Score':>6} {'Description':<30} {'Weighted':>8}",
        "-" * 60,
    ]

    for name, data in results["factor_scores"].items():
        lines.append(f"{name:<20} {data['score']:>5}/2 {data['label']:<30} {data['weighted']:>7.2f}")

    if results["active_modifiers"]:
        lines.extend(["", f"MODIFIERS (+{results['modifier_score']}):"])
        for mod in results["active_modifiers"]:
            lines.append(f"  [+1] {mod}")

    lines.extend(["", "ROUTING DECISION:"])
    r = results["routing"]
    lines.append(f"  {r.get('type', 'N/A')}: {r.get('description', '')}")

    if results["rationale"]:
        lines.extend(["", "RATIONALE:"])
        for rat in results["rationale"]:
            lines.append(f"  {rat}")

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


def main():
    parser = argparse.ArgumentParser(description="Score decision complexity for routing")
    parser.add_argument("--input", "-i", help="JSON file with decision data")
    parser.add_argument("--topic", help="Decision topic")
    parser.add_argument("--domains", type=int, choices=[0, 1, 2], help="Domain count (0=single, 1=two, 2=three+)")
    parser.add_argument("--reversibility", type=int, choices=[0, 1, 2], help="Reversibility (0=easy, 1=partial, 2=irreversible)")
    parser.add_argument("--financial", type=int, choices=[0, 1, 2], help="Financial impact (0=<5%%, 1=5-20%%, 2=>20%%)")
    parser.add_argument("--team", type=int, choices=[0, 1, 2], help="Team impact (0=single, 1=multi, 2=org-wide)")
    parser.add_argument("--urgency", type=int, choices=[0, 1, 2], help="Time pressure (0=none, 1=days, 2=hours)")
    parser.add_argument("--modifiers", nargs="*", choices=[m["id"] for m in MODIFIERS], default=[], help="Active modifiers")
    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 = {
            "topic": args.topic or "Strategic decision",
            "factors": {
                "domain_count": args.domains if args.domains is not None else 1,
                "reversibility": args.reversibility if args.reversibility is not None else 1,
                "financial_impact": args.financial if args.financial is not None else 1,
                "team_impact": args.team if args.team is not None else 1,
                "time_pressure": args.urgency if args.urgency is not None else 0,
            },
            "modifiers": args.modifiers,
        }

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Board Decision Tracker - Track and audit board meeting decisions.

Manages decision logs with ownership, deadlines, review dates,
conflict detection, and DO_NOT_RESURFACE flags. Produces audit reports.
"""

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


def track_decisions(data: dict) -> dict:
    """Analyze decision history and identify issues."""
    decisions = data.get("decisions", [])
    today = datetime.now()

    results = {
        "timestamp": today.isoformat(),
        "total_decisions": len(decisions),
        "summary": {"active": 0, "overdue_review": 0, "overdue_action": 0, "completed": 0, "superseded": 0, "do_not_resurface": 0},
        "decisions": [],
        "overdue_reviews": [],
        "overdue_actions": [],
        "conflicts": [],
        "recurring_topics": {},
        "owner_workload": {},
        "recommendations": [],
    }

    topic_count = {}
    for d in decisions:
        decision_id = d.get("id", "")
        topic = d.get("topic", "")
        status = d.get("status", "active")
        owner = d.get("owner", "Unassigned")
        action_items = d.get("action_items", [])
        review_date_str = d.get("review_date", "")
        decision_date_str = d.get("decision_date", "")
        dnr = d.get("do_not_resurface", False)
        superseded_by = d.get("superseded_by", None)

        # Parse dates
        review_date = None
        decision_date = None
        try:
            if review_date_str:
                review_date = datetime.strptime(review_date_str, "%Y-%m-%d")
            if decision_date_str:
                decision_date = datetime.strptime(decision_date_str, "%Y-%m-%d")
        except ValueError:
            pass

        # Check overdue review
        review_overdue = review_date and today > review_date and status == "active"
        # Check overdue actions
        overdue_items = []
        for ai in action_items:
            due_str = ai.get("due_date", "")
            try:
                due = datetime.strptime(due_str, "%Y-%m-%d")
                if today > due and ai.get("status", "") != "complete":
                    overdue_items.append(ai)
            except ValueError:
                pass

        # Track topics
        topic_key = topic.lower().strip()
        topic_count[topic_key] = topic_count.get(topic_key, 0) + 1

        # Track owner workload
        if owner not in results["owner_workload"]:
            results["owner_workload"][owner] = {"active": 0, "overdue": 0}
        if status == "active":
            results["owner_workload"][owner]["active"] += 1
        if review_overdue or overdue_items:
            results["owner_workload"][owner]["overdue"] += len(overdue_items) + (1 if review_overdue else 0)

        decision_result = {
            "id": decision_id,
            "topic": topic,
            "status": status,
            "owner": owner,
            "decision_date": decision_date_str,
            "review_date": review_date_str,
            "review_overdue": review_overdue,
            "days_since_review_due": (today - review_date).days if review_overdue else 0,
            "action_items_total": len(action_items),
            "action_items_overdue": len(overdue_items),
            "do_not_resurface": dnr,
            "superseded_by": superseded_by,
        }
        results["decisions"].append(decision_result)

        # Summary counts
        if dnr:
            results["summary"]["do_not_resurface"] += 1
        elif superseded_by:
            results["summary"]["superseded"] += 1
        elif status == "completed":
            results["summary"]["completed"] += 1
        else:
            results["summary"]["active"] += 1

        if review_overdue:
            results["summary"]["overdue_review"] += 1
            results["overdue_reviews"].append(decision_result)
        if overdue_items:
            results["summary"]["overdue_action"] += len(overdue_items)
            results["overdue_actions"].extend([
                {"decision_id": decision_id, "topic": topic, **ai}
                for ai in overdue_items
            ])

    # Recurring topics
    for topic, count in topic_count.items():
        if count >= 3:
            results["recurring_topics"][topic] = {
                "count": count,
                "alert": "Same topic discussed 3+ times without resolution. Escalate to board meeting."
            }

    # Conflict detection
    active_decisions = [d for d in decisions if d.get("status") == "active" and not d.get("do_not_resurface")]
    for i, d1 in enumerate(active_decisions):
        for d2 in active_decisions[i+1:]:
            if d1.get("topic", "").lower() == d2.get("topic", "").lower():
                results["conflicts"].append({
                    "decision_1": d1.get("id", ""),
                    "decision_2": d2.get("id", ""),
                    "topic": d1.get("topic", ""),
                    "type": "duplicate_topic",
                    "message": "Two active decisions on the same topic. One should supersede the other."
                })

    # Recommendations
    if results["summary"]["overdue_review"] > 0:
        results["recommendations"].append(
            f"{results['summary']['overdue_review']} decision(s) past review date. Schedule review."
        )
    if results["summary"]["overdue_action"] > 0:
        results["recommendations"].append(
            f"{results['summary']['overdue_action']} action item(s) overdue. Follow up with owners."
        )
    if results["recurring_topics"]:
        results["recommendations"].append(
            f"{len(results['recurring_topics'])} recurring topic(s) need escalation."
        )
    if results["conflicts"]:
        results["recommendations"].append(
            f"{len(results['conflicts'])} conflict(s) detected. Resolve before next meeting."
        )

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    s = results["summary"]
    lines = [
        "=" * 65,
        "BOARD DECISION TRACKER",
        "=" * 65,
        f"Date: {results['timestamp'][:10]}",
        f"Total Decisions: {results['total_decisions']}",
        f"Active: {s['active']} | Completed: {s['completed']} | Superseded: {s['superseded']} | DNR: {s['do_not_resurface']}",
        f"Overdue Reviews: {s['overdue_review']} | Overdue Actions: {s['overdue_action']}",
        "",
    ]

    if results["overdue_reviews"]:
        lines.append("OVERDUE REVIEWS:")
        for d in results["overdue_reviews"]:
            lines.append(f"  [!] {d['id']}: {d['topic']} ({d['owner']}) - {d['days_since_review_due']} days overdue")
        lines.append("")

    if results["overdue_actions"]:
        lines.append("OVERDUE ACTION ITEMS:")
        for a in results["overdue_actions"][:10]:
            lines.append(f"  [!] {a.get('decision_id','')}: {a.get('action','')} ({a.get('owner','')}, due: {a.get('due_date','')})")
        lines.append("")

    if results["conflicts"]:
        lines.append("CONFLICTS:")
        for c in results["conflicts"]:
            lines.append(f"  [!] {c['message']} ({c['decision_1']} vs {c['decision_2']})")
        lines.append("")

    if results["recurring_topics"]:
        lines.append("RECURRING TOPICS (3+ discussions):")
        for topic, info in results["recurring_topics"].items():
            lines.append(f"  [W] '{topic}' discussed {info['count']} times. {info['alert']}")
        lines.append("")

    lines.append("OWNER WORKLOAD:")
    for owner, wl in sorted(results["owner_workload"].items(), key=lambda x: x[1]["overdue"], reverse=True):
        flag = " [!]" if wl["overdue"] > 0 else ""
        lines.append(f"  {owner}: {wl['active']} active, {wl['overdue']} overdue{flag}")

    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="Track and audit board meeting decisions")
    parser.add_argument("--input", "-i", help="JSON file with decisions 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:
        today = datetime.now()
        data = {
            "decisions": [
                {"id": "D-001", "topic": "Series B fundraising", "status": "active", "owner": "CEO", "decision_date": "2025-10-15", "review_date": (today - timedelta(days=15)).strftime("%Y-%m-%d"), "action_items": [{"action": "Engage 3 investment banks", "owner": "CFO", "due_date": (today - timedelta(days=10)).strftime("%Y-%m-%d"), "status": "in_progress"}]},
                {"id": "D-002", "topic": "Engineering reorg", "status": "completed", "owner": "CTO", "decision_date": "2025-09-01", "review_date": "2025-12-01", "action_items": []},
                {"id": "D-003", "topic": "Market expansion EU", "status": "active", "owner": "CMO", "decision_date": "2025-11-01", "review_date": (today + timedelta(days=30)).strftime("%Y-%m-%d"), "action_items": [{"action": "Complete GDPR assessment", "owner": "CISO", "due_date": (today - timedelta(days=5)).strftime("%Y-%m-%d"), "status": "in_progress"}]},
                {"id": "D-004", "topic": "Series B fundraising", "status": "active", "owner": "CFO", "decision_date": "2025-11-15", "review_date": (today + timedelta(days=15)).strftime("%Y-%m-%d"), "action_items": []},
                {"id": "D-005", "topic": "Pricing model change", "status": "active", "owner": "CRO", "decision_date": "2025-10-01", "review_date": (today - timedelta(days=20)).strftime("%Y-%m-%d"), "do_not_resurface": False, "action_items": []},
            ],
        }

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Board Meeting Simulator - Simulate and validate meeting protocol execution.

Validates role activation, contribution completeness, phase sequencing,
and generates meeting readiness assessments. Helps prep for structured
multi-agent board deliberations.
"""

import argparse
import json
import sys
from datetime import datetime


ROLES = ["CEO", "CFO", "CMO", "CPO", "CRO", "COO", "CHRO", "CTO", "CISO"]

TOPIC_ROUTING = {
    "market_expansion": {"required": ["CEO", "CMO", "CFO", "CRO", "COO"], "optional": ["CTO"]},
    "product_direction": {"required": ["CEO", "CPO", "CTO", "CMO"], "optional": ["CFO"]},
    "hiring_org": {"required": ["CEO", "CHRO", "CFO", "COO"], "optional": ["CTO", "CMO"]},
    "pricing": {"required": ["CMO", "CFO", "CRO", "CPO"], "optional": []},
    "technology": {"required": ["CTO", "CPO", "CFO", "CISO"], "optional": []},
    "fundraising": {"required": ["CEO", "CFO", "CRO"], "optional": []},
    "security_incident": {"required": ["CEO", "CTO", "CISO", "COO"], "optional": []},
    "m_and_a": {"required": ["CEO", "CFO", "CTO", "CHRO", "COO"], "optional": []},
    "strategy": {"required": ["CEO", "CFO", "CMO", "CPO", "CRO"], "optional": ["COO"]},
    "cost_reduction": {"required": ["CEO", "CFO", "COO", "CHRO"], "optional": []},
}

PHASES = [
    {"phase": 1, "name": "Context Gathering", "required_outputs": ["agenda", "activated_roles", "context_loaded"]},
    {"phase": 2, "name": "Independent Contributions", "required_outputs": ["isolated_contributions"]},
    {"phase": 3, "name": "Critic Analysis", "required_outputs": ["consensus_assessment", "unvalidated_assumptions", "missing_perspectives", "uncomfortable_truth"]},
    {"phase": 4, "name": "Synthesis", "required_outputs": ["decision_required", "perspectives_summary", "agreements", "disagreements", "recommended_decision", "action_items"]},
    {"phase": 5, "name": "Founder Review", "required_outputs": ["founder_decision"]},
    {"phase": 6, "name": "Decision Extraction", "required_outputs": ["decisions_logged", "action_items_assigned"]},
]


def simulate_meeting(data: dict) -> dict:
    """Simulate and validate meeting protocol."""
    topic = data.get("topic", "strategy")
    topic_type = data.get("topic_type", "strategy")
    activated_roles = data.get("activated_roles", [])
    contributions = data.get("contributions", {})
    phase_status = data.get("phase_status", {})
    complexity_score = data.get("complexity_score", 7)

    routing = TOPIC_ROUTING.get(topic_type, TOPIC_ROUTING["strategy"])

    results = {
        "timestamp": datetime.now().isoformat(),
        "topic": topic,
        "topic_type": topic_type,
        "complexity_score": complexity_score,
        "meeting_type": "Full Board" if complexity_score >= 8 else "Multi-Advisor" if complexity_score >= 5 else "Dual Advisor",
        "role_assessment": {},
        "phase_assessment": [],
        "contribution_quality": {},
        "readiness_score": 0,
        "warnings": [],
        "protocol_violations": [],
        "recommendations": [],
    }

    # Role assessment
    if not activated_roles:
        activated_roles = routing["required"]

    missing_required = [r for r in routing["required"] if r not in activated_roles]
    extra_roles = [r for r in activated_roles if r not in routing["required"] and r not in routing.get("optional", [])]
    recommended_additions = [r for r in routing.get("optional", []) if r not in activated_roles]

    results["role_assessment"] = {
        "activated": activated_roles,
        "required": routing["required"],
        "missing_required": missing_required,
        "extra_roles": extra_roles,
        "recommended_additions": recommended_additions,
        "attendee_count": len(activated_roles),
        "max_recommended": 6,
        "role_count_ok": len(activated_roles) <= 6,
    }

    if missing_required:
        results["warnings"].append(f"Missing required roles: {', '.join(missing_required)}")
    if len(activated_roles) > 6:
        results["warnings"].append(f"Too many attendees ({len(activated_roles)} > 6 max). Reduce to prevent noise.")

    # Phase assessment
    readiness_total = 0
    readiness_count = 0
    for phase_config in PHASES:
        phase_num = phase_config["phase"]
        phase_data = phase_status.get(str(phase_num), {})
        status = phase_data.get("status", "not_started")

        outputs_present = []
        outputs_missing = []
        for output in phase_config["required_outputs"]:
            if phase_data.get(output, False):
                outputs_present.append(output)
            else:
                outputs_missing.append(output)

        completeness = len(outputs_present) / len(phase_config["required_outputs"]) * 100 if phase_config["required_outputs"] else 0

        phase_result = {
            "phase": phase_num,
            "name": phase_config["name"],
            "status": status,
            "completeness_pct": round(completeness),
            "outputs_present": outputs_present,
            "outputs_missing": outputs_missing,
        }
        results["phase_assessment"].append(phase_result)

        if status == "complete":
            readiness_total += 100
        elif status == "in_progress":
            readiness_total += completeness
        readiness_count += 1

    # Contribution quality checks
    for role in activated_roles:
        contrib = contributions.get(role, {})
        quality = {
            "role": role,
            "has_key_points": bool(contrib.get("key_points")),
            "has_recommendation": bool(contrib.get("recommendation")),
            "has_confidence": bool(contrib.get("confidence")),
            "has_key_assumption": bool(contrib.get("key_assumption")),
            "has_change_condition": bool(contrib.get("what_would_change_mind")),
            "points_count": len(contrib.get("key_points", [])),
            "format_compliant": True,
        }

        # Validate format
        violations = []
        if quality["points_count"] > 5:
            violations.append(f"{role}: More than 5 key points ({quality['points_count']})")
            quality["format_compliant"] = False
        if not quality["has_recommendation"]:
            violations.append(f"{role}: Missing recommendation")
            quality["format_compliant"] = False
        if not quality["has_confidence"]:
            violations.append(f"{role}: Missing confidence level")
            quality["format_compliant"] = False

        results["contribution_quality"][role] = quality
        results["protocol_violations"].extend(violations)

    # Cross-pollination check
    if data.get("cross_pollination_detected", False):
        results["protocol_violations"].append("CRITICAL: Cross-pollination detected in Phase 2. Contributions must be isolated.")

    # Overall readiness
    results["readiness_score"] = round(readiness_total / readiness_count) if readiness_count > 0 else 0

    # Recommendations
    if results["readiness_score"] < 50:
        results["recommendations"].append("Meeting not ready. Complete earlier phases before proceeding.")
    if missing_required:
        results["recommendations"].append(f"Activate missing roles before starting: {', '.join(missing_required)}")
    if results["protocol_violations"]:
        results["recommendations"].append(f"Fix {len(results['protocol_violations'])} protocol violations before synthesis.")

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    lines = [
        "=" * 60,
        "BOARD MEETING PROTOCOL ASSESSMENT",
        "=" * 60,
        f"Topic: {results['topic']}",
        f"Type: {results['topic_type']}  |  Complexity: {results['complexity_score']}/10",
        f"Meeting Type: {results['meeting_type']}",
        f"Readiness: {results['readiness_score']}%",
        "",
        "ROLE ACTIVATION:",
        f"  Activated: {', '.join(results['role_assessment']['activated'])} ({results['role_assessment']['attendee_count']})",
        f"  Required:  {', '.join(results['role_assessment']['required'])}",
    ]

    ra = results["role_assessment"]
    if ra["missing_required"]:
        lines.append(f"  MISSING:   {', '.join(ra['missing_required'])}")
    if ra["recommended_additions"]:
        lines.append(f"  Optional:  {', '.join(ra['recommended_additions'])}")

    lines.extend(["", "PHASE STATUS:"])
    for p in results["phase_assessment"]:
        icon = "[x]" if p["status"] == "complete" else "[~]" if p["status"] == "in_progress" else "[ ]"
        lines.append(f"  {icon} Phase {p['phase']}: {p['name']} ({p['completeness_pct']}%)")
        if p["outputs_missing"]:
            lines.append(f"      Missing: {', '.join(p['outputs_missing'])}")

    if results["protocol_violations"]:
        lines.extend(["", "PROTOCOL VIOLATIONS:"])
        for v in results["protocol_violations"]:
            lines.append(f"  [!] {v}")

    if results["warnings"]:
        lines.extend(["", "WARNINGS:"])
        for w in results["warnings"]:
            lines.append(f"  [W] {w}")

    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="Simulate and validate board meeting protocol")
    parser.add_argument("--input", "-i", help="JSON file with meeting data")
    parser.add_argument("--topic", help="Meeting topic")
    parser.add_argument("--type", choices=list(TOPIC_ROUTING.keys()), default="strategy", help="Topic type")
    parser.add_argument("--complexity", type=int, default=7, help="Complexity score (1-10)")
    parser.add_argument("--roles", nargs="*", help="Activated roles")
    parser.add_argument("--list-topics", action="store_true", help="List topic types and required roles")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if args.list_topics:
        print("Topic Types and Required Roles:")
        for topic, routing in TOPIC_ROUTING.items():
            print(f"  {topic}: {', '.join(routing['required'])} (optional: {', '.join(routing.get('optional', []))})")
        return

    if args.input:
        with open(args.input) as f:
            data = json.load(f)
    else:
        data = {
            "topic": args.topic or "Q2 Strategy Review",
            "topic_type": args.type,
            "complexity_score": args.complexity,
            "activated_roles": args.roles or TOPIC_ROUTING.get(args.type, {}).get("required", ["CEO", "CFO"]),
            "contributions": {},
            "phase_status": {
                "1": {"status": "complete", "agenda": True, "activated_roles": True, "context_loaded": True},
                "2": {"status": "in_progress", "isolated_contributions": False},
            },
        }

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


if __name__ == "__main__":
    main()