Chief Of Staff

#!/usr/bin/env python3
"""
C-Suite Ecosystem Mapper - Visualize advisor relationships and coverage.

Maps the C-suite advisory ecosystem, identifies coverage gaps,
tracks cross-functional dependencies, and generates ecosystem health reports.
"""

import argparse
import json
import sys
from datetime import datetime


ECOSYSTEM = {
    "c_suite": {
        "CEO": {"domain": "Vision, strategy, investor relations", "path": "ceo-advisor"},
        "CTO": {"domain": "Technology, architecture, engineering", "path": "cto-advisor"},
        "CFO": {"domain": "Finance, fundraising, budgets", "path": "cfo-advisor"},
        "CMO": {"domain": "Marketing, positioning, brand", "path": "cmo-advisor"},
        "COO": {"domain": "Operations, process, execution", "path": "coo-advisor"},
        "CHRO": {"domain": "People, hiring, org design", "path": "chro-advisor"},
        "CPO": {"domain": "Product, PMF, portfolio", "path": "cpo-advisor"},
        "CRO": {"domain": "Revenue, sales, pricing", "path": "cro-advisor"},
        "CISO": {"domain": "Security, compliance, risk", "path": "ciso-advisor"},
    },
    "orchestration": {
        "Chief of Staff": {"domain": "Routing, synthesis, decision log", "path": "chief-of-staff"},
        "Board Meeting": {"domain": "Multi-agent deliberation protocol", "path": "board-meeting"},
        "Board Deck Builder": {"domain": "Board presentation assembly", "path": "board-deck-builder"},
        "Decision Logger": {"domain": "Two-layer decision memory", "path": "decision-logger"},
    },
    "strategic": {
        "Competitive Intel": {"domain": "Market and competitor tracking", "path": "competitive-intel"},
        "M&A Playbook": {"domain": "Acquisition and merger strategy", "path": "ma-playbook"},
        "Company OS": {"domain": "Operating system design", "path": "company-os"},
        "Change Management": {"domain": "Organizational change rollout", "path": "change-management"},
        "Culture Architect": {"domain": "Culture as operational system", "path": "culture-architect"},
        "Strategic Alignment": {"domain": "Goal cascade and alignment", "path": "strategic-alignment"},
    },
}

CROSS_DEPENDENCIES = [
    {"from": "CEO", "to": "CFO", "on": "Fundraising, board prep"},
    {"from": "CEO", "to": "CHRO", "on": "Org design, culture"},
    {"from": "CFO", "to": "CHRO", "on": "Headcount budget, equity"},
    {"from": "CTO", "to": "CISO", "on": "Security architecture"},
    {"from": "CTO", "to": "CPO", "on": "Technical feasibility"},
    {"from": "CMO", "to": "CRO", "on": "Pipeline, demand gen"},
    {"from": "CRO", "to": "CFO", "on": "Revenue forecasting"},
    {"from": "CISO", "to": "CRO", "on": "Security questionnaires for deals"},
    {"from": "COO", "to": "CHRO", "on": "Process + people alignment"},
    {"from": "Change Management", "to": "COO", "on": "Process change rollout"},
    {"from": "Change Management", "to": "CHRO", "on": "People impact"},
]


def map_ecosystem(data: dict) -> dict:
    """Map the ecosystem and identify gaps."""
    active_skills = data.get("active_skills", [])
    recent_queries = data.get("recent_queries", [])
    decision_count = data.get("decisions_logged", 0)

    results = {
        "timestamp": datetime.now().isoformat(),
        "ecosystem_summary": {
            "total_skills": sum(len(cat) for cat in ECOSYSTEM.values()),
            "active_skills": len(active_skills),
            "categories": {},
        },
        "category_details": {},
        "coverage_gaps": [],
        "dependency_map": CROSS_DEPENDENCIES,
        "utilization": {},
        "recommendations": [],
    }

    # Category breakdown
    for cat_name, skills in ECOSYSTEM.items():
        active_in_cat = [s for s in skills if s in active_skills or skills[s]["path"] in active_skills]
        coverage = len(active_in_cat) / len(skills) * 100 if skills else 0

        results["ecosystem_summary"]["categories"][cat_name] = {
            "total": len(skills),
            "active": len(active_in_cat),
            "coverage_pct": round(coverage),
        }

        results["category_details"][cat_name] = {}
        for skill_name, config in skills.items():
            is_active = skill_name in active_skills or config["path"] in active_skills
            results["category_details"][cat_name][skill_name] = {
                "domain": config["domain"],
                "path": config["path"],
                "active": is_active,
            }
            if not is_active:
                results["coverage_gaps"].append({
                    "skill": skill_name,
                    "category": cat_name,
                    "domain": config["domain"],
                    "path": config["path"],
                })

    # Utilization from recent queries
    role_usage = {}
    for query in recent_queries:
        role = query.get("routed_to", "")
        if role:
            role_usage[role] = role_usage.get(role, 0) + 1

    results["utilization"] = {
        "queries_analyzed": len(recent_queries),
        "by_role": role_usage,
        "most_consulted": max(role_usage.items(), key=lambda x: x[1])[0] if role_usage else "N/A",
        "least_consulted": min(role_usage.items(), key=lambda x: x[1])[0] if role_usage else "N/A",
        "decisions_logged": decision_count,
    }

    # Recommendations
    if results["coverage_gaps"]:
        gap_count = len(results["coverage_gaps"])
        results["recommendations"].append(f"{gap_count} skills inactive. Consider activating for full coverage.")

    c_suite_gaps = [g for g in results["coverage_gaps"] if g["category"] == "c_suite"]
    if c_suite_gaps:
        results["recommendations"].append(f"C-suite gaps: {', '.join(g['skill'] for g in c_suite_gaps)}. These are core advisory roles.")

    if decision_count == 0:
        results["recommendations"].append("No decisions logged. Implement decision logging to prevent repeated debates.")

    return results


def format_text(results: dict) -> str:
    """Format as human-readable ecosystem map."""
    lines = [
        "=" * 60,
        "C-SUITE ECOSYSTEM MAP",
        "=" * 60,
        f"Date: {results['timestamp'][:10]}",
        f"Total Skills: {results['ecosystem_summary']['total_skills']}  |  Active: {results['ecosystem_summary']['active_skills']}",
        "",
    ]

    for cat_name, details in results["category_details"].items():
        cat_summary = results["ecosystem_summary"]["categories"][cat_name]
        lines.append(f"{cat_name.upper().replace('_', ' ')} ({cat_summary['active']}/{cat_summary['total']} active, {cat_summary['coverage_pct']}%)")
        for skill_name, config in details.items():
            icon = "[x]" if config["active"] else "[ ]"
            lines.append(f"  {icon} {skill_name:<20} {config['domain']}")
        lines.append("")

    if results["coverage_gaps"]:
        lines.extend(["COVERAGE GAPS:"])
        for gap in results["coverage_gaps"][:8]:
            lines.append(f"  - {gap['skill']} ({gap['category']}): {gap['domain']}")
        lines.append("")

    lines.extend(["KEY DEPENDENCIES:"])
    for dep in CROSS_DEPENDENCIES[:8]:
        lines.append(f"  {dep['from']} <-> {dep['to']}: {dep['on']}")

    util = results["utilization"]
    if util.get("by_role"):
        lines.extend(["", "UTILIZATION:"])
        for role, count in sorted(util["by_role"].items(), key=lambda x: x[1], reverse=True):
            bar = "#" * min(20, count)
            lines.append(f"  {role:<8} {bar} ({count})")

    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="Map C-suite advisory ecosystem")
    parser.add_argument("--input", "-i", help="JSON file with ecosystem data")
    parser.add_argument("--active", nargs="*", default=[], help="List of active skills")
    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 = {
            "active_skills": args.active or ["CEO", "CFO", "CTO", "CMO", "CHRO", "CISO", "CPO", "CRO", "COO", "Chief of Staff", "Board Meeting"],
            "recent_queries": [
                {"routed_to": "CFO"}, {"routed_to": "CFO"}, {"routed_to": "CEO"},
                {"routed_to": "CTO"}, {"routed_to": "CHRO"}, {"routed_to": "CFO"},
                {"routed_to": "CMO"}, {"routed_to": "CISO"},
            ],
            "decisions_logged": 12,
        }

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Advisory Routing Engine - Route questions to the right C-suite advisor(s).

Analyzes topics, scores complexity, and determines optimal routing path
(single advisor, dual, multi-advisor, or full board meeting).
"""

import argparse
import json
import sys
from datetime import datetime

ROUTING_TABLE = {
    "fundraising": {"primary": "CFO", "secondary": "CEO", "tertiary": None},
    "financial_model": {"primary": "CFO", "secondary": "CEO", "tertiary": None},
    "burn_rate": {"primary": "CFO", "secondary": "COO", "tertiary": None},
    "hiring": {"primary": "CHRO", "secondary": "COO", "tertiary": "CEO"},
    "org_structure": {"primary": "CHRO", "secondary": "COO", "tertiary": "CEO"},
    "performance": {"primary": "CHRO", "secondary": "CEO", "tertiary": None},
    "product_roadmap": {"primary": "CPO", "secondary": "CTO", "tertiary": None},
    "prioritization": {"primary": "CPO", "secondary": "CTO", "tertiary": None},
    "architecture": {"primary": "CTO", "secondary": "CPO", "tertiary": None},
    "tech_debt": {"primary": "CTO", "secondary": "CFO", "tertiary": None},
    "revenue": {"primary": "CRO", "secondary": "CFO", "tertiary": "CMO"},
    "pricing": {"primary": "CMO", "secondary": "CFO", "tertiary": "CRO"},
    "process": {"primary": "COO", "secondary": "CFO", "tertiary": None},
    "okrs": {"primary": "COO", "secondary": "CEO", "tertiary": None},
    "security": {"primary": "CISO", "secondary": "COO", "tertiary": "CTO"},
    "compliance": {"primary": "CISO", "secondary": "CFO", "tertiary": None},
    "direction": {"primary": "CEO", "secondary": None, "tertiary": None},
    "investors": {"primary": "CEO", "secondary": "CFO", "tertiary": None},
    "market_strategy": {"primary": "CMO", "secondary": "CRO", "tertiary": "CPO"},
    "m_and_a": {"primary": "CEO", "secondary": "CFO", "tertiary": "CTO"},
    "culture": {"primary": "CHRO", "secondary": "CEO", "tertiary": None},
    "international": {"primary": "CEO", "secondary": "CFO", "tertiary": "CRO"},
    "competitive": {"primary": "CMO", "secondary": "CPO", "tertiary": "CRO"},
    "change_management": {"primary": "COO", "secondary": "CHRO", "tertiary": None},
    "board_prep": {"primary": "CEO", "secondary": "CFO", "tertiary": None},
}

TOPIC_KEYWORDS = {
    "fundraising": ["fundraise", "raise", "series", "investors", "term sheet", "valuation"],
    "financial_model": ["financial model", "forecast", "projections", "budget"],
    "burn_rate": ["burn", "runway", "cash", "extend runway"],
    "hiring": ["hire", "recruiting", "headcount", "talent", "candidate"],
    "org_structure": ["reorg", "restructure", "org design", "reporting"],
    "performance": ["performance review", "pip", "underperformer", "promotion"],
    "product_roadmap": ["roadmap", "features", "backlog", "product strategy"],
    "architecture": ["architecture", "tech stack", "infrastructure", "platform"],
    "tech_debt": ["tech debt", "technical debt", "refactor", "legacy"],
    "revenue": ["revenue", "sales", "pipeline", "quota", "deals"],
    "pricing": ["pricing", "price", "packaging", "monetization"],
    "security": ["security", "breach", "vulnerability", "zero trust"],
    "compliance": ["compliance", "soc 2", "iso", "gdpr", "hipaa", "audit"],
    "m_and_a": ["acquisition", "merger", "m&a", "buy", "acquire"],
    "market_strategy": ["positioning", "brand", "marketing strategy", "go to market"],
    "culture": ["culture", "values", "engagement", "morale"],
    "direction": ["vision", "strategy", "direction", "pivot"],
}


def detect_topic(question: str) -> str:
    """Detect topic from question text."""
    question_lower = question.lower()
    best_match = "direction"
    best_score = 0

    for topic, keywords in TOPIC_KEYWORDS.items():
        score = sum(1 for kw in keywords if kw in question_lower)
        if score > best_score:
            best_score = score
            best_match = topic

    return best_match


def route_question(data: dict) -> dict:
    """Route a question to the appropriate advisor(s)."""
    question = data.get("question", "")
    topic = data.get("topic") or detect_topic(question)
    complexity = data.get("complexity_score", 5)

    routing = ROUTING_TABLE.get(topic, ROUTING_TABLE["direction"])

    results = {
        "timestamp": datetime.now().isoformat(),
        "question": question,
        "detected_topic": topic,
        "complexity_score": complexity,
        "routing_type": "",
        "primary_advisor": routing["primary"],
        "secondary_advisor": routing.get("secondary"),
        "tertiary_advisor": routing.get("tertiary"),
        "activated_advisors": [],
        "routing_rationale": [],
        "loop_prevention": {
            "max_depth": 2,
            "path": [],
            "loop_detected": False,
        },
        "quality_checks": [],
    }

    # Determine routing type based on complexity
    if complexity <= 3:
        results["routing_type"] = "SINGLE ADVISOR"
        results["activated_advisors"] = [routing["primary"]]
        results["routing_rationale"].append(f"Low complexity ({complexity}/10) - single advisor sufficient")
    elif complexity <= 6:
        results["routing_type"] = "DUAL ADVISOR"
        advisors = [routing["primary"]]
        if routing.get("secondary"):
            advisors.append(routing["secondary"])
        results["activated_advisors"] = advisors
        results["routing_rationale"].append(f"Medium complexity ({complexity}/10) - dual advisor with synthesis")
    elif complexity <= 8:
        results["routing_type"] = "MULTI-ADVISOR"
        advisors = [routing["primary"]]
        if routing.get("secondary"):
            advisors.append(routing["secondary"])
        if routing.get("tertiary"):
            advisors.append(routing["tertiary"])
        results["activated_advisors"] = advisors
        results["routing_rationale"].append(f"High complexity ({complexity}/10) - multi-advisor with full synthesis")
    else:
        results["routing_type"] = "FULL BOARD MEETING"
        results["activated_advisors"] = [routing["primary"]]
        if routing.get("secondary"):
            results["activated_advisors"].append(routing["secondary"])
        if routing.get("tertiary"):
            results["activated_advisors"].append(routing["tertiary"])
        results["routing_rationale"].append(f"Very high complexity ({complexity}/10) - invoke board-meeting protocol")

    # Quality checks
    results["quality_checks"] = [
        {"check": "Company context loaded", "required": True},
        {"check": "Decision history checked for conflicts", "required": complexity >= 5},
        {"check": "Bottom line appears first in output", "required": True},
        {"check": "Actions have owners and deadlines", "required": True},
        {"check": "Conflicts named explicitly", "required": complexity >= 6},
        {"check": "Maximum 5 bullets per section", "required": True},
    ]

    return results


def format_text(results: dict) -> str:
    """Format as human-readable report."""
    lines = [
        "=" * 60,
        "ADVISORY ROUTING",
        "=" * 60,
        f"Question: {results['question'][:80]}{'...' if len(results['question']) > 80 else ''}",
        f"Topic: {results['detected_topic']}",
        f"Complexity: {results['complexity_score']}/10",
        f"Routing: {results['routing_type']}",
        "",
        f"ACTIVATED ADVISORS: {' -> '.join(results['activated_advisors'])}",
        f"  Primary:   {results['primary_advisor']}",
    ]
    if results["secondary_advisor"]:
        lines.append(f"  Secondary: {results['secondary_advisor']}")
    if results["tertiary_advisor"]:
        lines.append(f"  Tertiary:  {results['tertiary_advisor']}")

    lines.extend(["", "RATIONALE:"])
    for r in results["routing_rationale"]:
        lines.append(f"  {r}")

    lines.extend(["", "QUALITY CHECKS:"])
    for qc in results["quality_checks"]:
        req = "[Required]" if qc["required"] else "[Optional]"
        lines.append(f"  {req} {qc['check']}")

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


def main():
    parser = argparse.ArgumentParser(description="Route advisory questions to appropriate C-suite role(s)")
    parser.add_argument("--question", "-q", help="Question to route")
    parser.add_argument("--topic", help="Pre-classified topic")
    parser.add_argument("--complexity", "-c", type=int, default=5, help="Complexity score (1-10)")
    parser.add_argument("--list-topics", action="store_true", help="List all topic routing")
    parser.add_argument("--json", action="store_true", help="Output as JSON")
    args = parser.parse_args()

    if args.list_topics:
        print("Topic Routing Table:")
        for topic, route in sorted(ROUTING_TABLE.items()):
            advisors = [route["primary"]]
            if route.get("secondary"):
                advisors.append(route["secondary"])
            if route.get("tertiary"):
                advisors.append(route["tertiary"])
            print(f"  {topic:<22} -> {' -> '.join(advisors)}")
        return

    data = {
        "question": args.question or "Should we raise a Series B now or wait until next quarter?",
        "topic": args.topic,
        "complexity_score": args.complexity,
    }

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Synthesis Generator - Merge multi-advisor outputs into decision-ready format.

Takes independent advisor contributions, identifies consensus and conflicts,
maps dependencies, and frames the decision for founder review.
"""

import argparse
import json
import sys
from datetime import datetime


def synthesize(data: dict) -> dict:
    """Synthesize multiple advisor contributions."""
    topic = data.get("topic", "")
    contributions = data.get("contributions", {})
    complexity = data.get("complexity_score", 5)

    results = {
        "timestamp": datetime.now().isoformat(),
        "topic": topic,
        "complexity_score": complexity,
        "advisors_consulted": list(contributions.keys()),
        "consensus_points": [],
        "disagreements": [],
        "dependencies": [],
        "action_items": [],
        "decision_frame": {},
        "risk_note": "",
    }

    # Extract all recommendations and key points
    all_recommendations = {}
    all_key_points = {}
    all_concerns = {}
    confidence_map = {}

    for role, contrib in contributions.items():
        recommendation = contrib.get("recommendation", "")
        all_recommendations[role] = recommendation
        all_key_points[role] = contrib.get("key_points", [])
        all_concerns[role] = contrib.get("key_concern", "")
        confidence_map[role] = contrib.get("confidence", "Medium")

    # Find consensus (themes mentioned by 2+ advisors)
    point_themes = {}
    for role, points in all_key_points.items():
        for point in points:
            # Simple theme matching by first 3 words
            theme = " ".join(point.lower().split()[:4])
            if theme not in point_themes:
                point_themes[theme] = []
            point_themes[theme].append({"role": role, "point": point})

    for theme, entries in point_themes.items():
        if len(entries) >= 2:
            roles = [e["role"] for e in entries]
            results["consensus_points"].append({
                "point": entries[0]["point"],
                "agreed_by": roles,
                "strength": "Strong" if len(roles) >= 3 else "Moderate",
            })

    # Find disagreements
    rec_clusters = {}
    for role, rec in all_recommendations.items():
        direction = "proceed" if any(w in rec.lower() for w in ["proceed", "go", "invest", "yes", "approve", "recommend"]) else "wait" if any(w in rec.lower() for w in ["wait", "delay", "defer", "pause"]) else "modify" if any(w in rec.lower() for w in ["modify", "adjust", "change", "alternative"]) else "neutral"
        if direction not in rec_clusters:
            rec_clusters[direction] = []
        rec_clusters[direction].append({"role": role, "recommendation": rec, "confidence": confidence_map.get(role, "Medium")})

    if len(rec_clusters) > 1:
        for direction, members in rec_clusters.items():
            if direction != "neutral":
                results["disagreements"].append({
                    "position": direction,
                    "advisors": [m["role"] for m in members],
                    "reasoning": [m["recommendation"] for m in members],
                })

    # Dependencies
    for role, points in all_key_points.items():
        for point in points:
            if any(w in point.lower() for w in ["depends on", "requires", "contingent", "assuming", "if"]):
                results["dependencies"].append({
                    "from_advisor": role,
                    "dependency": point,
                })

    # Action items (max 5)
    action_count = 0
    for role, contrib in contributions.items():
        for action in contrib.get("action_items", []):
            if action_count < 5:
                results["action_items"].append({
                    "action": action.get("action", ""),
                    "owner": action.get("owner", role),
                    "deadline": action.get("deadline", "TBD"),
                    "success_criteria": action.get("success_criteria", ""),
                })
                action_count += 1

    # Decision frame
    if results["disagreements"]:
        option_a = results["disagreements"][0] if len(results["disagreements"]) > 0 else {}
        option_b = results["disagreements"][1] if len(results["disagreements"]) > 1 else {}
        results["decision_frame"] = {
            "question": f"Regarding {topic}: should we {option_a.get('position', 'proceed')} or {option_b.get('position', 'wait')}?",
            "option_a": {
                "position": option_a.get("position", ""),
                "supported_by": option_a.get("advisors", []),
                "trade_off": f"Gain: execution speed. Risk: {all_concerns.get(option_a.get('advisors', [''])[0], 'unknown')}",
            },
            "option_b": {
                "position": option_b.get("position", ""),
                "supported_by": option_b.get("advisors", []),
                "trade_off": f"Gain: reduced risk. Risk: {all_concerns.get(option_b.get('advisors', [''])[0], 'missed opportunity')}",
            },
        }
    else:
        majority_rec = max(all_recommendations.items(), key=lambda x: confidence_map.get(x[0], "Medium") == "High") if all_recommendations else ("", "")
        results["decision_frame"] = {
            "question": f"Regarding {topic}: advisors are aligned on approach.",
            "recommendation": majority_rec[1] if majority_rec else "No recommendation",
            "confidence": "High" if len(results["consensus_points"]) >= 2 else "Medium",
        }

    # Risk note
    low_confidence = [role for role, conf in confidence_map.items() if conf == "Low"]
    if low_confidence:
        results["risk_note"] = f"Low confidence from {', '.join(low_confidence)}. Key assumption may be unvalidated."
    elif results["disagreements"]:
        results["risk_note"] = f"Fundamental disagreement exists ({len(results['disagreements'])} positions). Founder judgment required."
    else:
        results["risk_note"] = "Advisors aligned. Verify assumptions match current market conditions."

    return results


def format_text(results: dict) -> str:
    """Format synthesis as structured output."""
    lines = [
        "=" * 60,
        f"SYNTHESIS: {results['topic']}",
        "=" * 60,
        f"Date: {results['timestamp'][:10]}",
        f"Advisors Consulted: {', '.join(results['advisors_consulted'])}",
        f"Complexity Score: {results['complexity_score']}/10",
        "",
    ]

    if results["consensus_points"]:
        lines.append("CONSENSUS:")
        for cp in results["consensus_points"]:
            lines.append(f"  [{cp['strength']}] {cp['point']} (agreed: {', '.join(cp['agreed_by'])})")
        lines.append("")

    if results["disagreements"]:
        lines.append("DISAGREEMENTS:")
        for d in results["disagreements"]:
            lines.append(f"  Position '{d['position']}': {', '.join(d['advisors'])}")
            for r in d["reasoning"][:1]:
                lines.append(f"    Reasoning: {r}")
        lines.append("")

    if results["action_items"]:
        lines.append("RECOMMENDED ACTIONS:")
        for i, ai in enumerate(results["action_items"], 1):
            lines.append(f"  {i}. {ai['action']} -- Owner: {ai['owner']} -- By: {ai['deadline']}")
        lines.append("")

    df = results["decision_frame"]
    lines.extend(["YOUR DECISION POINT:", f"  {df.get('question', '')}"])
    if "option_a" in df:
        lines.append(f"  Option A ({df['option_a']['position']}): Supported by {', '.join(df['option_a']['supported_by'])}")
        lines.append(f"    Trade-off: {df['option_a']['trade_off']}")
    if "option_b" in df:
        lines.append(f"  Option B ({df['option_b']['position']}): Supported by {', '.join(df['option_b']['supported_by'])}")
        lines.append(f"    Trade-off: {df['option_b']['trade_off']}")
    if "recommendation" in df:
        lines.append(f"  Recommendation: {df['recommendation']} (Confidence: {df.get('confidence', 'Medium')})")

    lines.extend(["", f"RISK NOTE: {results['risk_note']}", "", "=" * 60])
    return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="Synthesize multi-advisor contributions")
    parser.add_argument("--input", "-i", help="JSON file with advisor contributions")
    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": "Series B timing",
            "complexity_score": 8,
            "contributions": {
                "CFO": {
                    "recommendation": "Proceed with fundraising in Q2. Metrics are strong enough.",
                    "confidence": "High",
                    "key_points": ["Burn multiple at 1.8x is fundable", "Runway covers 15 months", "NRR at 115% is above median"],
                    "key_concern": "Market window may close if we wait",
                    "action_items": [{"action": "Engage 3 investment banks", "owner": "CFO", "deadline": "2 weeks"}],
                },
                "CEO": {
                    "recommendation": "Proceed but improve burn multiple to 1.5x first for better terms.",
                    "confidence": "Medium",
                    "key_points": ["Burn multiple at 1.8x is fundable but not ideal", "Board relationships are warm", "Market conditions favorable"],
                    "key_concern": "Valuation expectations may not match current metrics",
                    "action_items": [{"action": "Schedule board member pre-conversations", "owner": "CEO", "deadline": "1 week"}],
                },
                "CRO": {
                    "recommendation": "Wait until Q3. Pipeline needs one more quarter to show sustained growth.",
                    "confidence": "Medium",
                    "key_points": ["Pipeline is building but not yet mature", "Q2 pipeline depends on new SDR team ramping"],
                    "key_concern": "Pipeline story may not be convincing enough yet",
                    "action_items": [{"action": "Deliver Q1 pipeline targets", "owner": "CRO", "deadline": "End of Q1"}],
                },
            },
        }

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


if __name__ == "__main__":
    main()