liquidification_layer.py

#!/usr/bin/env python3
"""
Liquidification Layer - Finding the practical path to cash.

Liquidification means the product always asks: How does this asset move toward cash?

For each asset, it should generate a route:
- Sell as standalone codebase
- Package as micro-SaaS
- Turn into hosted API
- Turn into Hugging Face Space
- License to strategic buyer
- Sell as data/report package
- Submit to IP broker
- Submit to venture studio
- Submit to accelerator
- Offer to software M&A buyer
- Open-source with paid services
- Bundle with related repos
- Archive as non-financeable

Then it should assign:
- Expected buyer category
- Expected sale difficulty
- Expected sale timeline
- Expected forced-sale range
- Required cleanup before outreach
- Best next action

This is how the system stops being a dashboard and becomes a monetization operator.
"""

from enum import Enum
from typing import Dict, Any, List, Optional, Tuple
from dataclasses import dataclass, field
from datetime import datetime
import json


class LiquidationRoute(Enum):
    """Monetization routes for software assets."""
    STANDALONE_CODEBASE_SALE = "standalone_codebase_sale"
    MICRO_SAAS = "micro_saas"
    HOSTED_API = "hosted_api"
    HUGGING_FACE_SPACE = "hugging_face_space"
    STRATEGIC_LICENSE = "strategic_license"
    DATA_REPORT_PACKAGE = "data_report_package"
    IP_BROKER_SUBMISSION = "ip_broker_submission"
    VENTURE_STUDIO_SUBMISSION = "venture_studio_submission"
    ACCELERATOR_SUBMISSION = "accelerator_submission"
    SOFTWARE_MA_BUYER = "software_ma_buyer"
    OPEN_SOURCE_PAID_SERVICES = "open_source_paid_services"
    BUNDLE_WITH_REPOS = "bundle_with_repos"
    ARCHIVE_NON_FINANCEABLE = "archive_non_financeable"


class BuyerCategory(Enum):
    """Categories of potential buyers."""
    DEVELOPER_TOOLING_BUYERS = "developer_tooling_buyers"
    IP_CONSULTANTS = "ip_consultants"
    VENTURE_STUDIOS = "venture_studios"
    SOFTWARE_MA_ADVISORS = "software_ma_advisors"
    CORPORATE_ACQUIRERS = "corporate_acquirers"
    PRIVATE_EQUITY = "private_equity"
    STRATEGIC_BUYERS = "strategic_buyers"
    MARKETPLACES = "marketplaces"
    BROKERS = "brokers"
    ACCELERATORS = "accelerators"


class SaleDifficulty(Enum):
    """Expected difficulty of sale."""
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    VERY_HIGH = "very_high"


@dataclass
class LiquidificationPlan:
    """
    A complete liquidification plan for an asset.
    
    Answers: How does this asset move toward cash?
    """
    asset_id: str
    primary_route: LiquidationRoute
    alternative_routes: List[LiquidationRoute]
    
    # Buyer information
    expected_buyer_category: BuyerCategory
    buyer_universe: List[str]  # Specific buyer names or types
    
    # Sale expectations
    sale_difficulty: SaleDifficulty
    expected_timeline_days: Tuple[int, int]  # (min, max)
    expected_price_range: Tuple[float, float]  # (min, max) in USD
    
    # Requirements
    required_cleanup: List[str]
    required_packaging: List[str]
    
    # Action
    best_next_action: str
    action_priority: str  # immediate, short_term, long_term
    
    # Metadata
    confidence: float  # 0-1
    generated_at: datetime = field(default_factory=datetime.now)
    
    def to_dict(self) -> Dict[str, Any]:
        return {
            "asset_id": self.asset_id,
            "primary_route": self.primary_route.value,
            "alternative_routes": [route.value for route in self.alternative_routes],
            "expected_buyer_category": self.expected_buyer_category.value,
            "buyer_universe": self.buyer_universe,
            "sale_difficulty": self.sale_difficulty.value,
            "expected_timeline_days": list(self.expected_timeline_days),
            "expected_price_range": list(self.expected_price_range),
            "required_cleanup": self.required_cleanup,
            "required_packaging": self.required_packaging,
            "best_next_action": self.best_next_action,
            "action_priority": self.action_priority,
            "confidence": self.confidence,
            "generated_at": self.generated_at.isoformat(),
        }


class LiquidificationEngine:
    """
    Liquidification Engine - Generates monetization routes.
    
    This is how the system becomes a monetization operator, not just a dashboard.
    """
    
    def __init__(self):
        self.route_criteria = {
            LiquidationRoute.STANDALONE_CODEBASE_SALE: {
                "min_production_grade": "B",
                "min_collateral_grade": "C",
                "requires": ["clear_ownership", "no_secrets", "buildable"],
            },
            LiquidationRoute.MICRO_SAAS: {
                "min_production_grade": "A-",
                "min_commercial_grade": "B",
                "requires": ["api_potential", "scalable", "market_fit"],
            },
            LiquidationRoute.HOSTED_API: {
                "min_production_grade": "B+",
                "min_execution_score": 70,
                "requires": ["api_endpoints", "deployable", "documentation"],
            },
            LiquidationRoute.HUGGING_FACE_SPACE: {
                "min_production_grade": "C",
                "requires": ["ml_model", "demo_ready", "documentation"],
            },
            LiquidationRoute.STRATEGIC_LICENSE: {
                "min_production_grade": "B",
                "min_commercial_grade": "B",
                "requires": ["clear_license", "strategic_value", "ip_clarity"],
            },
            LiquidationRoute.DATA_REPORT_PACKAGE: {
                "min_production_grade": "C",
                "requires": ["data_value", "analysis_capability", "report_generation"],
            },
            LiquidationRoute.IP_BROKER_SUBMISSION: {
                "min_production_grade": "B",
                "min_collateral_grade": "B",
                "requires": ["clear_ownership", "market_value", "documentation"],
            },
            LiquidationRoute.VENTURE_STUDIO_SUBMISSION: {
                "min_production_grade": "B-",
                "min_commercial_grade": "B-",
                "requires": ["growth_potential", "scalable", "market_fit"],
            },
            LiquidationRoute.ACCELERATOR_SUBMISSION: {
                "min_production_grade": "C+",
                "requires": ["prototype", "team", "vision"],
            },
            LiquidationRoute.SOFTWARE_MA_BUYER: {
                "min_production_grade": "A-",
                "min_collateral_grade": "B+",
                "requires": ["production_ready", "revenue", "clear_ownership"],
            },
            LiquidationRoute.OPEN_SOURCE_PAID_SERVICES: {
                "min_production_grade": "B",
                "requires": ["community", "support_model", "documentation"],
            },
            LiquidationRoute.BUNDLE_WITH_REPOS: {
                "min_production_grade": "C",
                "requires": ["related_assets", "synergy", "packaging"],
            },
        }
    
    def generate_liquidification_plan(
        self,
        asset_data: Dict[str, Any],
        grades: Dict[str, Any],
        committee_results: Dict[str, Any],
    ) -> LiquidificationPlan:
        """
        Generate a complete liquidification plan.
        
        Args:
            asset_data: Asset metadata and classification
            grades: Professional grades
            committee_results: Committee evaluation results
        
        Returns:
            LiquidificationPlan with monetization strategy
        """
        # Determine eligible routes
        eligible_routes = self._determine_eligible_routes(asset_data, grades, committee_results)
        
        # Select primary route
        primary_route = self._select_primary_route(eligible_routes, asset_data, grades)
        
        # Determine buyer category
        buyer_category = self._determine_buyer_category(primary_route, asset_data, grades)
        
        # Generate buyer universe
        buyer_universe = self._generate_buyer_universe(buyer_category, asset_data)
        
        # Estimate sale difficulty
        sale_difficulty = self._estimate_sale_difficulty(primary_route, grades, committee_results)
        
        # Estimate timeline
        timeline = self._estimate_timeline(primary_route, sale_difficulty, grades)
        
        # Estimate price range
        price_range = self._estimate_price_range(grades, committee_results, asset_data)
        
        # Determine required cleanup
        required_cleanup = self._determine_required_cleanup(committee_results, asset_data)
        
        # Determine required packaging
        required_packaging = self._determine_required_packaging(primary_route, asset_data)
        
        # Generate best next action
        best_next_action = self._generate_best_next_action(
            primary_route,
            required_cleanup,
            required_packaging,
            grades,
        )
        
        # Determine action priority
        action_priority = self._determine_action_priority(
            primary_route,
            required_cleanup,
            grades,
        )
        
        # Calculate confidence
        confidence = self._calculate_confidence(grades, committee_results)
        
        return LiquidificationPlan(
            asset_id=asset_data.get("asset_id", "unknown"),
            primary_route=primary_route,
            alternative_routes=[r for r in eligible_routes if r != primary_route],
            expected_buyer_category=buyer_category,
            buyer_universe=buyer_universe,
            sale_difficulty=sale_difficulty,
            expected_timeline_days=timeline,
            expected_price_range=price_range,
            required_cleanup=required_cleanup,
            required_packaging=required_packaging,
            best_next_action=best_next_action,
            action_priority=action_priority,
            confidence=confidence,
        )
    
    def _determine_eligible_routes(
        self,
        asset_data: Dict[str, Any],
        grades: Dict[str, Any],
        committee_results: Dict[str, Any],
    ) -> List[LiquidationRoute]:
        """Determine which liquidation routes are eligible."""
        eligible = []
        
        production_grade = grades.get("production_grade", "F")
        commercial_grade = grades.get("commercial_grade", "F")
        collateral_grade = grades.get("collateral_grade", "F")
        execution_score = grades.get("execution_proof", 0)
        
        # Check for risk blocks
        risk_blocked = committee_results.get("committee_report", {}).get("risk_blocked", False)
        
        for route, criteria in self.route_criteria.items():
            # Skip if risk blocked (except archive)
            if risk_blocked and route != LiquidationRoute.ARCHIVE_NON_FINANCEABLE:
                continue
            
            # Check production grade
            min_prod = criteria.get("min_production_grade", "F")
            if not self._grade_meets_minimum(production_grade, min_prod):
                continue
            
            # Check commercial grade if required
            min_comm = criteria.get("min_commercial_grade")
            if min_comm and not self._grade_meets_minimum(commercial_grade, min_comm):
                continue
            
            # Check collateral grade if required
            min_coll = criteria.get("min_collateral_grade")
            if min_coll and not self._grade_meets_minimum(collateral_grade, min_coll):
                continue
            
            # Check execution score if required
            min_exec = criteria.get("min_execution_score")
            if min_exec and execution_score < min_exec:
                continue
            
            # Check asset-specific requirements
            if not self._check_route_requirements(route, asset_data):
                continue
            
            eligible.append(route)
        
        # Always add archive as fallback
        if LiquidationRoute.ARCHIVE_NON_FINANCEABLE not in eligible:
            eligible.append(LiquidationRoute.ARCHIVE_NON_FINANCEABLE)
        
        return eligible
    
    def _grade_meets_minimum(self, grade: str, minimum: str) -> bool:
        """Check if grade meets minimum requirement."""
        grade_order = ["F", "D", "C-", "C", "C+", "B-", "B", "B+", "A-", "A", "A+"]
        
        try:
            grade_idx = grade_order.index(grade)
            min_idx = grade_order.index(minimum)
            return grade_idx >= min_idx
        except ValueError:
            return False
    
    def _check_route_requirements(self, route: LiquidationRoute, asset_data: Dict[str, Any]) -> bool:
        """Check route-specific requirements."""
        criteria = self.route_criteria[route]
        required = criteria.get("requires", [])
        
        for requirement in required:
            if requirement == "clear_ownership":
                if not asset_data.get("has_ownership_clarity", False):
                    return False
            elif requirement == "no_secrets":
                if asset_data.get("secrets_detected", []):
                    return False
            elif requirement == "buildable":
                if asset_data.get("build_status") != "passed":
                    return False
            elif requirement == "api_potential":
                if not asset_data.get("has_api_potential", False):
                    return False
            elif requirement == "scalable":
                if not asset_data.get("is_scalable", False):
                    return False
            elif requirement == "market_fit":
                if not asset_data.get("has_market_fit", False):
                    return False
            elif requirement == "api_endpoints":
                if not asset_data.get("has_endpoints", False):
                    return False
            elif requirement == "deployable":
                if asset_data.get("deployment_status") not in ["deployed", "deployable"]:
                    return False
            elif requirement == "documentation":
                if not asset_data.get("has_documentation", False):
                    return False
            elif requirement == "ml_model":
                if asset_data.get("asset_type") != "model":
                    return False
            elif requirement == "demo_ready":
                if not asset_data.get("has_demo", False):
                    return False
            elif requirement == "clear_license":
                if not asset_data.get("has_license", False):
                    return False
            elif requirement == "strategic_value":
                if not asset_data.get("has_strategic_value", False):
                    return False
            elif requirement == "ip_clarity":
                if not asset_data.get("has_ownership_clarity", False):
                    return False
            elif requirement == "data_value":
                if not asset_data.get("has_data_value", False):
                    return False
            elif requirement == "analysis_capability":
                if not asset_data.get("has_analysis_capability", False):
                    return False
            elif requirement == "report_generation":
                if not asset_data.get("has_report_generation", False):
                    return False
            elif requirement == "market_value":
                if grades := asset_data.get("grades"):
                    if grades.get("commercial_grade") in ["D", "F"]:
                        return False
            elif requirement == "growth_potential":
                if not asset_data.get("has_growth_potential", False):
                    return False
            elif requirement == "revenue":
                if not asset_data.get("revenue_evidence", []):
                    return False
            elif requirement == "community":
                if not asset_data.get("has_community", False):
                    return False
            elif requirement == "support_model":
                if not asset_data.get("has_support_model", False):
                    return False
            elif requirement == "related_assets":
                if not asset_data.get("related_assets", []):
                    return False
            elif requirement == "synergy":
                if not asset_data.get("has_synergy", False):
                    return False
            elif requirement == "packaging":
                if not asset_data.get("is_packagable", False):
                    return False
            elif requirement == "prototype":
                classification = asset_data.get("classification", "")
                if "prototype" not in classification.lower():
                    return False
            elif requirement == "team":
                if not asset_data.get("has_team", False):
                    return False
            elif requirement == "vision":
                if not asset_data.get("has_vision", False):
                    return False
            elif requirement == "production_ready":
                if grades := asset_data.get("grades"):
                    if grades.get("production_grade") not in ["A", "B"]:
                        return False
        
        return True
    
    def _select_primary_route(
        self,
        eligible_routes: List[LiquidationRoute],
        asset_data: Dict[str, Any],
        grades: Dict[str, Any],
    ) -> LiquidationRoute:
        """Select the primary liquidification route."""
        if not eligible_routes:
            return LiquidationRoute.ARCHIVE_NON_FINANCEABLE
        
        # Priority order for route selection
        priority_order = [
            LiquidationRoute.SOFTWARE_MA_BUYER,
            LiquidationRoute.MICRO_SAAS,
            LiquidationRoute.HOSTED_API,
            LiquidationRoute.STRATEGIC_LICENSE,
            LiquidationRoute.STANDALONE_CODEBASE_SALE,
            LiquidationRoute.IP_BROKER_SUBMISSION,
            LiquidationRoute.VENTURE_STUDIO_SUBMISSION,
            LiquidationRoute.HUGGING_FACE_SPACE,
            LiquidationRoute.DATA_REPORT_PACKAGE,
            LiquidationRoute.OPEN_SOURCE_PAID_SERVICES,
            LiquidationRoute.BUNDLE_WITH_REPOS,
            LiquidationRoute.ACCELERATOR_SUBMISSION,
            LiquidationRoute.ARCHIVE_NON_FINANCEABLE,
        ]
        
        # Select highest priority eligible route
        for route in priority_order:
            if route in eligible_routes:
                return route
        
        return eligible_routes[0]
    
    def _determine_buyer_category(
        self,
        route: LiquidationRoute,
        asset_data: Dict[str, Any],
        grades: Dict[str, Any],
    ) -> BuyerCategory:
        """Determine the expected buyer category."""
        route_to_category = {
            LiquidationRoute.STANDALONE_CODEBASE_SALE: BuyerCategory.DEVELOPER_TOOLING_BUYERS,
            LiquidationRoute.MICRO_SAAS: BuyerCategory.STRATEGIC_BUYERS,
            LiquidationRoute.HOSTED_API: BuyerCategory.DEVELOPER_TOOLING_BUYERS,
            LiquidationRoute.HUGGING_FACE_SPACE: BuyerCategory.MARKETPLACES,
            LiquidationRoute.STRATEGIC_LICENSE: BuyerCategory.STRATEGIC_BUYERS,
            LiquidationRoute.DATA_REPORT_PACKAGE: BuyerCategory.IP_CONSULTANTS,
            LiquidationRoute.IP_BROKER_SUBMISSION: BuyerCategory.BROKERS,
            LiquidationRoute.VENTURE_STUDIO_SUBMISSION: BuyerCategory.VENTURE_STUDIOS,
            LiquidationRoute.ACCELERATOR_SUBMISSION: BuyerCategory.ACCELERATORS,
            LiquidationRoute.SOFTWARE_MA_BUYER: BuyerCategory.SOFTWARE_MA_ADVISORS,
            LiquidationRoute.OPEN_SOURCE_PAID_SERVICES: BuyerCategory.DEVELOPER_TOOLING_BUYERS,
            LiquidationRoute.BUNDLE_WITH_REPOS: BuyerCategory.DEVELOPER_TOOLING_BUYERS,
            LiquidationRoute.ARCHIVE_NON_FINANCEABLE: BuyerCategory.DEVELOPER_TOOLING_BUYERS,
        }
        
        return route_to_category.get(route, BuyerCategory.DEVELOPER_TOOLING_BUYERS)
    
    def _generate_buyer_universe(
        self,
        buyer_category: BuyerCategory,
        asset_data: Dict[str, Any],
    ) -> List[str]:
        """Generate a list of potential buyers."""
        category = asset_data.get("category", "unknown")
        
        buyer_universes = {
            BuyerCategory.DEVELOPER_TOOLING_BUYERS: [
                "Developer tooling companies",
                "IDE vendors",
                "Code platform providers",
                "DevOps tool companies",
            ],
            BuyerCategory.IP_CONSULTANTS: [
                "IP consulting firms",
                "Technology transfer offices",
                "Patent licensing firms",
                "IP brokers",
            ],
            BuyerCategory.VENTURE_STUDIOS: [
                "Venture studios",
                "Startup accelerators",
                "Corporate innovation labs",
                "Technology incubators",
            ],
            BuyerCategory.SOFTWARE_MA_ADVISORS: [
                "Software M&A advisors",
                "Technology investment banks",
                "Private equity tech funds",
                "Strategic acquirers",
            ],
            BuyerCategory.CORPORATE_ACQUIRERS: [
                "Fortune 500 tech acquirers",
                "Corporate development teams",
                "Strategic buyers",
            ],
            BuyerCategory.PRIVATE_EQUITY: [
                "Tech-focused PE firms",
                "Growth equity funds",
                "Buyout funds",
            ],
            BuyerCategory.STRATEGIC_BUYERS: [
                "Competitors in adjacent markets",
                "Platform companies",
                "Strategic acquirers",
            ],
            BuyerCategory.MARKETPLACES: [
                "Hugging Face",
                "GitHub Marketplace",
                "NPM/PyPI ecosystem",
                "API marketplaces",
            ],
            BuyerCategory.BROKERS: [
                "IP brokers",
                "Technology brokers",
                "Software asset brokers",
            ],
            BuyerCategory.ACCELERATORS: [
                "Y Combinator",
                "Techstars",
                "Industry-specific accelerators",
                "Corporate accelerators",
            ],
        }
        
        universe = buyer_universes.get(buyer_category, ["General software buyers"])
        
        # Add category-specific buyers
        if category == "machine_learning":
            universe.extend(["ML platform companies", "AI infrastructure firms"])
        elif category == "developer_tools":
            universe.extend(["IDE vendors", "DevOps companies"])
        elif category == "fintech":
            universe.extend(["Fintech acquirers", "Banks"])
        
        return universe
    
    def _estimate_sale_difficulty(
        self,
        route: LiquidationRoute,
        grades: Dict[str, Any],
        committee_results: Dict[str, Any],
    ) -> SaleDifficulty:
        """Estimate the difficulty of sale."""
        financeability = grades.get("financeability_score", 0)
        commercial_grade = grades.get("commercial_grade", "F")
        
        # Check for blockers
        blockers = committee_results.get("committee_report", {}).get("all_blockers", [])
        
        if blockers:
            return SaleDifficulty.VERY_HIGH
        
        if financeability >= 80 and commercial_grade in ["A", "B"]:
            return SaleDifficulty.LOW
        elif financeability >= 60 and commercial_grade in ["B", "C"]:
            return SaleDifficulty.MEDIUM
        elif financeability >= 40:
            return SaleDifficulty.HIGH
        else:
            return SaleDifficulty.VERY_HIGH
    
    def _estimate_timeline(
        self,
        route: LiquidationRoute,
        difficulty: SaleDifficulty,
        grades: Dict[str, Any],
    ) -> Tuple[int, int]:
        """Estimate sale timeline in days."""
        base_timelines = {
            LiquidationRoute.STANDALONE_CODEBASE_SALE: (30, 90),
            LiquidationRoute.MICRO_SAAS: (60, 180),
            LiquidationRoute.HOSTED_API: (30, 60),
            LiquidationRoute.HUGGING_FACE_SPACE: (7, 30),
            LiquidationRoute.STRATEGIC_LICENSE: (60, 180),
            LiquidationRoute.DATA_REPORT_PACKAGE: (14, 45),
            LiquidationRoute.IP_BROKER_SUBMISSION: (30, 90),
            LiquidationRoute.VENTURE_STUDIO_SUBMISSION: (30, 90),
            LiquidationRoute.ACCELERATOR_SUBMISSION: (30, 60),
            LiquidationRoute.SOFTWARE_MA_BUYER: (90, 180),
            LiquidationRoute.OPEN_SOURCE_PAID_SERVICES: (90, 365),
            LiquidationRoute.BUNDLE_WITH_REPOS: (30, 90),
            LiquidationRoute.ARCHIVE_NON_FINANCEABLE: (0, 0),
        }
        
        base_min, base_max = base_timelines.get(route, (30, 90))
        
        # Adjust based on difficulty
        difficulty_multiplier = {
            SaleDifficulty.LOW: 1.0,
            SaleDifficulty.MEDIUM: 1.5,
            SaleDifficulty.HIGH: 2.0,
            SaleDifficulty.VERY_HIGH: 3.0,
        }
        
        multiplier = difficulty_multiplier.get(difficulty, 1.5)
        
        return (int(base_min * multiplier), int(base_max * multiplier))
    
    def _estimate_price_range(
        self,
        grades: Dict[str, Any],
        committee_results: Dict[str, Any],
        asset_data: Dict[str, Any],
    ) -> Tuple[float, float]:
        """Estimate price range in USD."""
        financeability = grades.get("financeability_score", 0)
        
        # Base price ranges based on financeability
        if financeability >= 80:
            base_min, base_max = 50000, 500000
        elif financeability >= 60:
            base_min, base_max = 25000, 250000
        elif financeability >= 40:
            base_min, base_max = 10000, 100000
        elif financeability >= 20:
            base_min, base_max = 5000, 50000
        else:
            base_min, base_max = 0, 10000
        
        # Adjust based on revenue evidence
        revenue_evidence = asset_data.get("revenue_evidence", [])
        if revenue_evidence:
            base_max *= 2
        
        # Adjust based on strategic value
        if asset_data.get("has_strategic_value", False):
            base_max *= 1.5
        
        return (base_min, base_max)
    
    def _determine_required_cleanup(
        self,
        committee_results: Dict[str, Any],
        asset_data: Dict[str, Any],
    ) -> List[str]:
        """Determine required cleanup before monetization."""
        cleanup = []
        
        blockers = committee_results.get("committee_report", {}).get("all_blockers", [])
        
        for blocker in blockers:
            if "secret" in blocker.lower():
                cleanup.append("Remove all secrets and use environment variables")
            elif "private key" in blocker.lower():
                cleanup.append("Remove all private keys")
            elif "ownership" in blocker.lower():
                cleanup.append("Clarify ownership through documentation")
            elif "license" in blocker.lower():
                cleanup.append("Add appropriate license file")
            elif "build" in blocker.lower():
                cleanup.append("Fix build issues")
            elif "scaffold" in blocker.lower():
                cleanup.append("Remove scaffolding and retain custom work")
        
        # Add standard cleanup if needed
        if not asset_data.get("has_documentation", False):
            cleanup.append("Add comprehensive documentation")
        
        if asset_data.get("build_status") != "passed":
            cleanup.append("Ensure build passes")
        
        return cleanup if cleanup else ["No critical cleanup required"]
    
    def _determine_required_packaging(
        self,
        route: LiquidationRoute,
        asset_data: Dict[str, Any],
    ) -> List[str]:
        """Determine required packaging for the route."""
        packaging = []
        
        route_packaging = {
            LiquidationRoute.STANDALONE_CODEBASE_SALE: [
                "Create sale packet with technical documentation",
                "Prepare code transfer documentation",
                "Generate usage examples",
            ],
            LiquidationRoute.MICRO_SAAS: [
                "Package as deployable SaaS",
                "Create pricing model",
                "Prepare hosting infrastructure",
            ],
            LiquidationRoute.HOSTED_API: [
                "Package as API service",
                "Create API documentation",
                "Set up hosting",
            ],
            LiquidationRoute.HUGGING_FACE_SPACE: [
                "Prepare model for Hugging Face",
                "Create demo notebook",
                "Write model card",
            ],
            LiquidationRoute.STRATEGIC_LICENSE: [
                "Prepare licensing terms",
                "Document IP rights",
                "Create license agreement template",
            ],
            LiquidationRoute.DATA_REPORT_PACKAGE: [
                "Package data with documentation",
                "Create report template",
                "Document data sources",
            ],
            LiquidationRoute.IP_BROKER_SUBMISSION: [
                "Create IP summary",
                "Prepare valuation report",
                "Document ownership chain",
            ],
            LiquidationRoute.VENTURE_STUDIO_SUBMISSION: [
                "Create pitch deck",
                "Document growth metrics",
                "Prepare team information",
            ],
            LiquidationRoute.ACCELERATOR_SUBMISSION: [
                "Create application materials",
                "Document prototype status",
                "Prepare team information",
            ],
            LiquidationRoute.SOFTWARE_MA_BUYER: [
                "Create comprehensive diligence packet",
                "Prepare financial documentation",
                "Document technical architecture",
            ],
            LiquidationRoute.OPEN_SOURCE_PAID_SERVICES: [
                "Prepare open-source release",
                "Define support model",
                "Create pricing for services",
            ],
            LiquidationRoute.BUNDLE_WITH_REPOS: [
                "Identify related assets",
                "Create bundle documentation",
                "Define bundle pricing",
            ],
            LiquidationRoute.ARCHIVE_NON_FINANCEABLE: [
                "Document archival decision",
                "Create summary record",
            ],
        }
        
        return route_packaging.get(route, ["Prepare standard packaging"])
    
    def _generate_best_next_action(
        self,
        route: LiquidationRoute,
        required_cleanup: List[str],
        required_packaging: List[str],
        grades: Dict[str, Any],
    ) -> str:
        """Generate the single best next action."""
        # If critical cleanup needed, that's the action
        critical_cleanup = [c for c in required_cleanup if "secret" in c.lower() or "private key" in c.lower()]
        if critical_cleanup:
            return f"CRITICAL: {critical_cleanup[0]}"
        
        # If cleanup needed, do that first
        if required_cleanup and "No critical cleanup required" not in required_cleanup:
            return f"Complete cleanup: {required_cleanup[0]}"
        
        # If packaging needed, do that
        if required_packaging:
            return f"Complete packaging: {required_packaging[0]}"
        
        # Route-specific actions
        route_actions = {
            LiquidationRoute.STANDALONE_CODEBASE_SALE: "Prepare sale packet and begin outreach to developer tooling buyers",
            LiquidationRoute.MICRO_SAAS: "Deploy as SaaS and begin customer acquisition",
            LiquidationRoute.HOSTED_API: "Deploy API and create integration documentation",
            LiquidationRoute.HUGGING_FACE_SPACE: "Upload to Hugging Face and promote in community",
            LiquidationRoute.STRATEGIC_LICENSE: "Identify strategic buyers and prepare licensing terms",
            LiquidationRoute.DATA_REPORT_PACKAGE: "Package data and reach out to IP consultants",
            LiquidationRoute.IP_BROKER_SUBMISSION: "Submit to IP broker with valuation report",
            LiquidationRoute.VENTURE_STUDIO_SUBMISSION: "Apply to venture studios with pitch deck",
            LiquidationRoute.ACCELERATOR_SUBMISSION: "Apply to relevant accelerators",
            LiquidationRoute.SOFTWARE_MA_BUYER: "Engage software M&A advisor and prepare diligence packet",
            LiquidationRoute.OPEN_SOURCE_PAID_SERVICES: "Release as open-source and define support services",
            LiquidationRoute.BUNDLE_WITH_REPOS: "Identify related repos and create bundle package",
            LiquidationRoute.ARCHIVE_NON_FINANCEABLE: "Archive asset and focus on higher-priority projects",
        }
        
        return route_actions.get(route, "Review and refine asset for monetization")
    
    def _determine_action_priority(
        self,
        route: LiquidationRoute,
        required_cleanup: List[str],
        grades: Dict[str, Any],
    ) -> str:
        """Determine action priority."""
        critical_cleanup = [c for c in required_cleanup if "secret" in c.lower() or "private key" in c.lower()]
        if critical_cleanup:
            return "immediate"
        
        if required_cleanup and "No critical cleanup required" not in required_cleanup:
            return "immediate"
        
        financeability = grades.get("financeability_score", 0)
        if financeability >= 70:
            return "immediate"
        elif financeability >= 50:
            return "short_term"
        else:
            return "long_term"
    
    def _calculate_confidence(
        self,
        grades: Dict[str, Any],
        committee_results: Dict[str, Any],
    ) -> float:
        """Calculate confidence in the liquidification plan."""
        financeability = grades.get("financeability_score", 0)
        
        # Higher financeability = higher confidence
        base_confidence = financeability / 100
        
        # Reduce confidence if risk blocked
        if committee_results.get("committee_report", {}).get("risk_blocked", False):
            base_confidence *= 0.5
        
        return min(1.0, max(0.3, base_confidence))