Skip to content
TheChatArchiveThe Chat Archive
GLMGLM-5 / Pony Alpha· unknownHugging Face Frontier Reasoning Traces

Simulate a UNCITRAL Model Law cross-border insolvency case with COMI arguments,…

  1. User

    Simulate a UNCITRAL Model Law cross-border insolvency case with COMI arguments, recognition motion timelines, creditor committee choreography, and asset repatriation safeguards.

  2. GLM Assistant

    The user wants a simulation of a UNCITRAL Model Law cross-border insolvency case. This is a complex legal/financial simulation that involves:

    1. COMI (Center of Main Interests) arguments - determining where the debtor's main operations are
    2. Recognition motion timelines - the process of recognizing foreign proceedings
    3. Creditor committee choreography - how creditors organize and interact
    4. Asset repatriation safeguards - protecting and returning assets

    Let me design a comprehensive simulation that includes:

    1. Legal Framework: UNCITRAL Model Law on Cross-Border Insolvency (MLCBI)

    2. Key Concepts:

      • Foreign Main Proceedings (COMI jurisdiction)
      • Foreign Non-Main Proceedings (establishment jurisdiction)
      • Recognition under Article 17
      • Relief under Article 19 (interim) and Article 21 (upon recognition)
      • Communication and cooperation (Article 27)
      • Protocols and cross-border agreements
    3. Simulation Components:

      • Multiple jurisdictions (e.g., US, UK, Singapore, Cayman Islands)
      • A distressed multinational company
      • Multiple creditor classes
      • Complex asset structures
      • COMI disputes
      • Recognition timeline tracking
      • Creditor committee dynamics
      • Asset tracing and repatriation

    Let me create a sophisticated Python simulation with:

    • Object-oriented design for different entities
    • Timeline management
    • Event-driven simulation
    • Reporting and visualization capabilities
    • Legal compliance tracking

    This will be a comprehensive simulation tool.

    UNCITRAL Model Law Cross-Border Insolvency Simulation

    This is a comprehensive simulation of a cross-border insolvency case under the UNCITRAL Model Law, featuring COMI disputes, recognition proceedings, creditor coordination, and asset protection.

    """
    UNCITRAL Model Law Cross-Border Insolvency Simulation
    =====================================================
    Simulates a complex cross-border insolvency case with:
    - COMI (Center of Main Interests) determination
    - Recognition motion proceedings
    - Creditor committee coordination
    - Asset repatriation safeguards
    
    Author: Legal Simulation Framework
    """
    
    import datetime
    from datetime import timedelta
    from enum import Enum, auto
    from dataclasses import dataclass, field
    from typing import List, Dict, Optional, Set, Tuple
    from collections import defaultdict
    import random
    import json
    
    # ==================== ENUMERATIONS ====================
    
    class Jurisdiction(Enum):
        """Key jurisdictions involved in cross-border insolvency"""
        US_DELAWARE = "US (Delaware)"
        US_NEW_YORK = "US (New York)"
        UK_ENGLAND = "UK (England)"
        SINGAPORE = "Singapore"
        CAYMAN_ISLANDS = "Cayman Islands"
        HONG_KONG = "Hong Kong"
        BRITISH_VIRGIN_ISLANDS = "BVI"
        GERMANY = "Germany"
        JAPAN = "Japan"
    
    class ProceedingType(Enum):
        """Types of insolvency proceedings under Model Law"""
        FOREIGN_MAIN = "Foreign Main (COMI)"
        FOREIGN_NON_MAIN = "Foreign Non-Main (Establishment)"
        LOCAL = "Local Proceedings"
    
    class CreditorClass(Enum):
        """Classes of creditors"""
        SECURED = "Secured Creditors"
        PRIORITY = "Priority Creditors"
        UNSECURED = "Unsecured Creditors"
        INTERCOMPANY = "Intercompany Creditors"
        EQUITY = "Equity Holders"
    
    class AssetType(Enum):
        """Types of assets"""
        CASH = "Cash"
        REAL_ESTATE = "Real Estate"
        INVENTORY = "Inventory"
        RECEIVABLES = "Receivables"
        INTELLECTUAL_PROPERTY = "Intellectual Property"
        INTERCOMPANY_LOANS = "Intercompany Loans"
        INVESTMENTS = "Investments"
        EQUIPMENT = "Equipment"
    
    class RecognitionStatus(Enum):
        """Status of recognition proceedings"""
        PENDING = "Pending"
        CONTESTED = "Contested"
        GRANTED = "Granted"
        DENIED = "Denied"
        APPEALED = "Appealed"
    
    class EventType(Enum):
        """Types of events in the simulation"""
        FILING = "Filing"
        HEARING = "Hearing"
        ORDER = "Court Order"
        CREDITOR_MEETING = "Creditor Meeting"
        ASSET_FREEZE = "Asset Freeze"
        ASSET_TRANSFER = "Asset Transfer"
        DISPUTE = "Dispute"
        AGREEMENT = "Agreement"
        COMMUNICATION = "Cross-Border Communication"
    
    # ==================== DATA CLASSES ====================
    
    @dataclass
    class Asset:
        """Represents an asset in the insolvency estate"""
        id: str
        description: str
        asset_type: AssetType
        value: float
        location: Jurisdiction
        encumbered: bool = False
        secured_creditor: Optional[str] = None
        frozen: bool = False
        repatriated: bool = False
        
        def __post_init__(self):
            self.protection_orders: List[str] = []
            self.transfer_history: List[Dict] = []
    
    @dataclass
    class Creditor:
        """Represents a creditor in the proceedings"""
        id: str
        name: str
        creditor_class: CreditorClass
        claim_amount: float
        jurisdiction: Jurisdiction
        secured_collateral: Optional[str] = None
        committee_member: bool = False
        
        def __post_init__(self):
            self.votes: List[Dict] = []
            self.objections: List[str] = []
    
    @dataclass
    class Entity:
        """Represents a corporate entity in the group"""
        name: str
        jurisdiction: Jurisdiction
        incorporation_date: datetime.date
        is_debtor: bool = False
        is_holdco: bool = False
        operating_entity: bool = False
        
        def __post_init__(self):
            self.directors: List[str] = []
            self.employees: int = 0
            self.assets: List[Asset] = []
            self.liabilities: float = 0.0
            self.revenue: float = 0.0
            self.registered_office: str = ""
            self.principal_operations: str = ""
    
    @dataclass
    class COMIFactor:
        """Factors for COMI determination under Recital 13"""
        factor: str
        weight: float  # 0.0 to 1.0
        supports_jurisdiction: Jurisdiction
        evidence_strength: float  # 0.0 to 1.0
        description: str = ""
    
    @dataclass
    class RecognitionMotion:
        """Recognition motion under Article 17"""
        id: str
        foreign_representative: str
        foreign_proceeding_jurisdiction: Jurisdiction
        proceeding_type: ProceedingType
        filing_date: datetime.date
        requesting_jurisdiction: Jurisdiction
        
        def __post_init__(self):
            self.status: RecognitionStatus = RecognitionStatus.PENDING
            self.hearing_date: Optional[datetime.date] = None
            self.determination_date: Optional[datetime.date] = None
            self.relief_granted: List[str] = []
            self.objections: List[str] = []
            self.supporting_evidence: List[str] = []
    
    @dataclass
    class SafeguardMeasure:
        """Asset safeguard measures"""
        measure_type: str
        asset_id: str
        jurisdiction: Jurisdiction
        effective_date: datetime.date
        expiry_date: Optional[datetime.date] = None
        description: str = ""
        
        def __post_init__(self):
            self.conditions: List[str] = []
            self.monitoring_required: bool = False
    
    # ==================== SIMULATION ENGINE ====================
    
    class CrossBorderInsolvencySimulation:
        """Main simulation engine for UNCITRAL Model Law case"""
        
        def __init__(self, case_name: str, start_date: datetime.date):
            self.case_name = case_name
            self.start_date = start_date
            self.current_date = start_date
            
            # Core data structures
            self.entities: Dict[str, Entity] = {}
            self.assets: Dict[str, Asset] = {}
            self.creditors: Dict[str, Creditor] = {}
            self.recognition_motions: Dict[str, RecognitionMotion] = {}
            self.comi_factors: List[COMIFactor] = []
            self.safeguards: List[SafeguardMeasure] = []
            
            # Timeline and events
            self.events: List[Dict] = []
            self.timeline: List[Dict] = []
            
            # Creditor committees
            self.committees: Dict[Jurisdiction, List[str]] = defaultdict(list)
            
            # Cross-border protocols
            self.protocols: List[Dict] = []
            
            # COMI determination
            self.comi_jurisdiction: Optional[Jurisdiction] = None
            self.comi_analysis: Dict = {}
            
            # Statistics
            self.stats = {
                "total_assets": 0.0,
                "total_liabilities": 0.0,
                "secured_claims": 0.0,
                "unsecured_claims": 0.0,
                "recovered_assets": 0.0,
                "repatriated_value": 0.0
            }
        
        def add_entity(self, entity: Entity):
            """Add a corporate entity to the case"""
            self.entities[entity.name] = entity
            self.stats["total_liabilities"] += entity.liabilities
            
        def add_asset(self, asset: Asset, entity_name: str):
            """Add an asset to an entity"""
            self.assets[asset.id] = asset
            if entity_name in self.entities:
                self.entities[entity_name].assets.append(asset)
            self.stats["total_assets"] += asset.value
            
        def add_creditor(self, creditor: Creditor):
            """Add a creditor to the case"""
            self.creditors[creditor.id] = creditor
            if creditor.creditor_class == CreditorClass.SECURED:
                self.stats["secured_claims"] += creditor.claim_amount
            elif creditor.creditor_class == CreditorClass.UNSECURED:
                self.stats["unsecured_claims"] += creditor.claim_amount
        
        def add_comi_factor(self, factor: COMIFactor):
            """Add a COMI determination factor"""
            self.comi_factors.append(factor)
        
        def file_recognition_motion(self, motion: RecognitionMotion):
            """File a recognition motion"""
            self.recognition_motions[motion.id] = motion
            self._log_event(
                EventType.FILING,
                f"Recognition motion filed: {motion.foreign_proceeding_jurisdiction.value} -> {motion.requesting_jurisdiction.value}",
                {"motion_id": motion.id, "type": motion.proceeding_type.value}
            )
        
        def _log_event(self, event_type: EventType, description: str, metadata: Dict = None):
            """Log an event to the timeline"""
            event = {
                "date": self.current_date,
                "type": event_type.value,
                "description": description,
                "metadata": metadata or {}
            }
            self.events.append(event)
            self.timeline.append({
                "day": (self.current_date - self.start_date).days,
                "event": description
            })
        
        def determine_comi(self) -> Tuple[Jurisdiction, Dict]:
            """
            Determine Center of Main Interests based on accumulated factors.
            Implements the test from Recital 13 and Article 16.
            """
            jurisdiction_scores: Dict[Jurisdiction, float] = defaultdict(float)
            factor_analysis = []
            
            for factor in self.comi_factors:
                weighted_score = factor.weight * factor.evidence_strength
                jurisdiction_scores[factor.supports_jurisdiction] += weighted_score
                
                factor_analysis.append({
                    "factor": factor.factor,
                    "supports": factor.supports_jurisdiction.value,
                    "weight": factor.weight,
                    "evidence": factor.evidence_strength,
                    "weighted_score": weighted_score,
                    "description": factor.description
                })
            
            # Determine COMI
            if jurisdiction_scores:
                self.comi_jurisdiction = max(jurisdiction_scores, key=jurisdiction_scores.get)
            
            self.comi_analysis = {
                "determination_date": self.current_date,
                "factors_analyzed": len(self.comi_factors),
                "scores": {j.value: s for j, s in jurisdiction_scores.items()},
                "determination": self.comi_jurisdiction.value if self.comi_jurisdiction else None,
                "factor_details": factor_analysis
            }
            
            self._log_event(
                EventType.ORDER,
                f"COMI Determination: {self.comi_jurisdiction.value if self.comi_jurisdiction else 'Undetermined'}",
                self.comi_analysis
            )
            
            return self.comi_jurisdiction, self.comi_analysis
        
        def process_recognition_motion(self, motion_id: str, grant: bool, relief_types: List[str] = None):
            """Process a recognition motion determination"""
            if motion_id not in self.recognition_motions:
                return False
            
            motion = self.recognition_motions[motion_id]
            motion.determination_date = self.current_date
            motion.status = RecognitionStatus.GRANTED if grant else RecognitionStatus.DENIED
            
            if grant:
                motion.relief_granted = relief_types or []
                
                # Verify COMI consistency for foreign main
                if motion.proceeding_type == ProceedingType.FOREIGN_MAIN:
                    if motion.foreign_proceeding_jurisdiction != self.comi_jurisdiction:
                        motion.status = RecognitionStatus.CONTESTED
                        self._log_event(
                            EventType.DISPUTE,
                            f"COMI challenge: Motion {motion_id} - claimed COMI differs from determined COMI",
                            {"claimed": motion.foreign_proceeding_jurisdiction.value, 
                             "determined": self.comi_jurisdiction.value if self.comi_jurisdiction else None}
                        )
            
            self._log_event(
                EventType.ORDER,
                f"Recognition {'granted' if grant else 'denied'}: {motion_id}",
                {"status": motion.status.value, "relief": motion.relief_granted}
            )
            
            return True
        
        def establish_creditor_committee(self, jurisdiction: Jurisdiction, creditor_ids: List[str]):
            """Establish a creditor committee for a jurisdiction"""
            for cid in creditor_ids:
                if cid in self.creditors:
                    self.creditors[cid].committee_member = True
                    self.committees[jurisdiction].append(cid)
            
            self._log_event(
                EventType.CREDITOR_MEETING,
                f"Creditor committee established in {jurisdiction.value}",
                {"members": [self.creditors[cid].name for cid in creditor_ids if cid in self.creditors]}
            )
        
        def coordinate_committees(self, protocol_name: str, terms: List[str]):
            """Create cross-border coordination protocol between committees"""
            protocol = {
                "name": protocol_name,
                "date": self.current_date,
                "participating_jurisdictions": list(self.committees.keys()),
                "terms": terms,
                "type": "Cross-Border Insolvency Protocol"
            }
            self.protocols.append(protocol)
            
            self._log_event(
                EventType.AGREEMENT,
                f"Cross-border protocol executed: {protocol_name}",
                protocol
            )
        
        def implement_safeguard(self, measure: SafeguardMeasure):
            """Implement an asset safeguard measure"""
            self.safeguards.append(measure)
            
            if measure.asset_id in self.assets:
                self.assets[measure.asset_id].frozen = True
                self.assets[measure.asset_id].protection_orders.append(measure.measure_type)
            
            self._log_event(
                EventType.ASSET_FREEZE,
                f"Safeguard implemented: {measure.measure_type} for asset {measure.asset_id}",
                {"jurisdiction": measure.jurisdiction.value, "asset": measure.asset_id}
            )
        
        def repatriate_asset(self, asset_id: str, destination: Jurisdiction) -> bool:
            """
            Repatriate an asset under Article 21 safeguards.
            Implements protective measures for asset transfer.
            """
            if asset_id not in self.assets:
                return False
            
            asset = self.assets[asset_id]
            
            # Check for safeguards
            applicable_safeguards = [s for s in self.safeguards if s.asset_id == asset_id]
            
            # Verify no encumbrances preventing transfer
            if asset.encumbered:
                self._log_event(
                    EventType.DISPUTE,
                    f"Repatriation blocked: Asset {asset_id} is encumbered",
                    {"secured_creditor": asset.secured_creditor}
                )
                return False
            
            # Execute repatriation
            original_location = asset.location
            asset.location = destination
            asset.repatriated = True
            asset.transfer_history.append({
                "date": self.current_date,
                "from": original_location.value,
                "to": destination.value,
                "safeguards_applied": len(applicable_safeguards)
            })
            
            self.stats["repatriated_value"] += asset.value
            
            self._log_event(
                EventType.ASSET_TRANSFER,
                f"Asset repatriated: {asset_id} from {original_location.value} to {destination.value}",
                {"asset_value": asset.value, "safeguards": len(applicable_safeguards)}
            )
            
            return True
        
        def simulate_hearing(self, motion_id: str):
            """Simulate a court hearing for a motion"""
            if motion_id not in self.recognition_motions:
                return
            
            motion = self.recognition_motions[motion_id]
            motion.hearing_date = self.current_date
            
            self._log_event(
                EventType.HEARING,
                f"Court hearing held for motion {motion_id}",
                {"jurisdiction": motion.requesting_jurisdiction.value, "type": motion.proceeding_type.value}
            )
        
        def advance_time(self, days: int):
            """Advance the simulation time"""
            self.current_date += timedelta(days=days)
        
        def generate_report(self) -> str:
            """Generate a comprehensive case report"""
            report = []
            report.append("=" * 80)
            report.append(f"CROSS-BORDER INSOLVENCY CASE REPORT")
            report.append(f"Case: {self.case_name}")
            report.append(f"Report Date: {self.current_date}")
            report.append("=" * 80)
            report.append("")
            
            # Case Overview
            report.append("I. CASE OVERVIEW")
            report.append("-" * 40)
            report.append(f"Total Entities: {len(self.entities)}")
            report.append(f"Total Assets: ${self.stats['total_assets']:,.2f}")
            report.append(f"Total Liabilities: ${self.stats['total_liabilities']:,.2f}")
            report.append(f"Secured Claims: ${self.stats['secured_claims']:,.2f}")
            report.append(f"Unsecured Claims: ${self.stats['unsecured_claims']:,.2f}")
            report.append("")
            
            # COMI Determination
            report.append("II. CENTER OF MAIN INTERESTS (COMI)")
            report.append("-" * 40)
            report.append(f"Determined COMI: {self.comi_jurisdiction.value if self.comi_jurisdiction else 'Not determined'}")
            report.append(f"Factors Analyzed: {len(self.comi_factors)}")
            if self.comi_analysis.get("scores"):
                report.append("\nJurisdiction Scores:")
                for jur, score in sorted(self.comi_analysis["scores"].items(), key=lambda x: x[1], reverse=True):
                    report.append(f"  - {jur}: {score:.2f}")
            report.append("")
            
            # Recognition Proceedings
            report.append("III. RECOGNITION PROCEEDINGS")
            report.append("-" * 40)
            for motion_id, motion in self.recognition_motions.items():
                report.append(f"\nMotion {motion_id}:")
                report.append(f"  Foreign Jurisdiction: {motion.foreign_proceeding_jurisdiction.value}")
                report.append(f"  Requesting In: {motion.requesting_jurisdiction.value}")
                report.append(f"  Type: {motion.proceeding_type.value}")
                report.append(f"  Status: {motion.status.value}")
                report.append(f"  Filed: {motion.filing_date}")
                if motion.determination_date:
                    report.append(f"  Determined: {motion.determination_date}")
                if motion.relief_granted:
                    report.append(f"  Relief Granted: {', '.join(motion.relief_granted)}")
            report.append("")
            
            # Creditor Committees
            report.append("IV. CREDITOR COMMITTEES")
            report.append("-" * 40)
            for jurisdiction, members in self.committees.items():
                report.append(f"\n{jurisdiction.value} Committee:")
                for member_id in members:
                    if member_id in self.creditors:
                        creditor = self.creditors[member_id]
                        report.append(f"  - {creditor.name} (${creditor.claim_amount:,.2f})")
            report.append("")
            
            # Cross-Border Protocols
            report.append("V. CROSS-BORDER PROTOCOLS")
            report.append("-" * 40)
            for protocol in self.protocols:
                report.append(f"\n{protocol['name']} (dated {protocol['date']})")
                report.append(f"  Participating Jurisdictions: {', '.join([j.value for j in protocol['participating_jurisdictions']])}")
                for term in protocol['terms']:
                    report.append(f"  • {term}")
            report.append("")
            
            # Asset Safeguards
            report.append("VI. ASSET SAFEGUARDS AND REPATRIATION")
            report.append("-" * 40)
            report.append(f"Active Safeguards: {len(self.safeguards)}")
            report.append(f"Repatriated Value: ${self.stats['repatriated_value']:,.2f}")
            report.append("\nSafeguard Details:")
            for safeguard in self.safeguards:
                report.append(f"  - {safeguard.measure_type}: Asset {safeguard.asset_id} ({safeguard.jurisdiction.value})")
            report.append("")
            
            # Event Timeline
            report.append("VII. KEY EVENTS TIMELINE")
            report.append("-" * 40)
            for event in self.events[-20:]:  # Last 20 events
                report.append(f"[{event['date']}] {event['type']}: {event['description']}")
            report.append("")
            
            return "\n".join(report)
    
    
    class CaseBuilder:
        """Builder class to construct a realistic cross-border insolvency case"""
        
        def __init__(self, simulation: CrossBorderInsolvencySimulation):
            self.sim = simulation
        
        def build_global_trading_company(self):
            """Build a realistic multinational trading company insolvency"""
            
            # Parent Holding Company (COMI disputed)
            holdco = Entity(
                name="GlobalTech Holdings Ltd",
                jurisdiction=Jurisdiction.CAYMAN_ISLANDS,
                incorporation_date=datetime.date(2010, 3, 15),
                is_debtor=True,
                is_holdco=True
            )
            holdco.registered_office = "Walkers Corporate Limited, Cayman Islands"
            holdco.employees = 15
            holdco.revenue = 50000000  # Management fees only
            holdco.liabilities = 850000000
            holdco.directors = ["Director A (Hong Kong)", "Director B (Singapore)", "Director C (UK)"]
            holdco.principal_operations = "Board meetings in Hong Kong; bank accounts in Singapore"
            self.sim.add_entity(holdco)
            
            # US Operating Subsidiary
            us_opco = Entity(
                name="GlobalTech America Inc",
                jurisdiction=Jurisdiction.US_DELAWARE,
                incorporation_date=datetime.date(2012, 6, 1),
                is_debtor=True,
                operating_entity=True
            )
            us_opco.employees = 450
            us_opco.revenue = 450000000
            us_opco.liabilities = 320000000
            us_opco.principal_operations = "Manufacturing and US distribution"
            self.sim.add_entity(us_opco)
            
            # UK Operating Subsidiary
            uk_opco = Entity(
                name="GlobalTech Europe Ltd",
                jurisdiction=Jurisdiction.UK_ENGLAND,
                incorporation_date=datetime.date(2013, 2, 20),
                is_debtor=True,
                operating_entity=True
            )
            uk_opco.employees = 280
            uk_opco.revenue = 280000000
            uk_opco.liabilities = 180000000
            uk_opco.principal_operations = "European distribution and sales"
            self.sim.add_entity(uk_opco)
            
            # Singapore Treasury Center
            sg_treasury = Entity(
                name="GlobalTech Treasury Pte Ltd",
                jurisdiction=Jurisdiction.SINGAPORE,
                incorporation_date=datetime.date(2015, 8, 10),
                operating_entity=True
            )
            sg_treasury.employees = 35
            sg_treasury.revenue = 15000000
            sg_treasury.liabilities = 250000000  # Intragroup loans
            sg_treasury.principal_operations = "Group treasury and cash management"
            self.sim.add_entity(sg_treasury)
            
            # BVI SPV for Bond Issuance
            bvi_spv = Entity(
                name="GT Capital Corp (BVI) Ltd",
                jurisdiction=Jurisdiction.BRITISH_VIRGIN_ISLANDS,
                incorporation_date=datetime.date(2018, 11, 5),
                is_debtor=True
            )
            bvi_spv.employees = 0
            bvi_spv.liabilities = 400000000  # Bond holders
            bvi_spv.principal_operations = "SPV for bond issuance - guaranteed by Holdco"
            self.sim.add_entity(bvi_spv)
            
            # Hong Kong Regional HQ
            hk_regional = Entity(
                name="GlobalTech Asia Pacific Ltd",
                jurisdiction=Jurisdiction.HONG_KONG,
                incorporation_date=datetime.date(2014, 4, 18),
                is_debtor=True,
                operating_entity=True
            )
            hk_regional.employees = 120
            hk_regional.revenue = 180000000
            hk_regional.liabilities = 95000000
            hk_regional.principal_operations = "Asia-Pacific regional headquarters"
            self.sim.add_entity(hk_regional)
        
        def add_assets(self):
            """Add assets across jurisdictions"""
            
            # US Assets
            self.sim.add_asset(Asset(
                id="US-001",
                description="Manufacturing Plant - Texas",
                asset_type=AssetType.REAL_ESTATE,
                value=85000000,
                location=Jurisdiction.US_DELAWARE,
                encumbered=True,
                secured_creditor="US Bank N.A."
            ), "GlobalTech America Inc")
            
            self.sim.add_asset(Asset(
                id="US-002",
                description="US Inventory",
                asset_type=AssetType.INVENTORY,
                value=45000000,
                location=Jurisdiction.US_DELAWARE
            ), "GlobalTech America Inc")
            
            self.sim.add_asset(Asset(
                id="US-003",
                description="US Receivables",
                asset_type=AssetType.RECEIVABLES,
                value=32000000,
                location=Jurisdiction.US_DELAWARE
            ), "GlobalTech America Inc")
            
            # UK Assets
            self.sim.add_asset(Asset(
                id="UK-001",
                description="European Distribution Center",
                asset_type=AssetType.REAL_ESTATE,
                value=55000000,
                location=Jurisdiction.UK_ENGLAND
            ), "GlobalTech Europe Ltd")
            
            self.sim.add_asset(Asset(
                id="UK-002",
                description="European IP Rights",
                asset_type=AssetType.INTELLECTUAL_PROPERTY,
                value=28000000,
                location=Jurisdiction.UK_ENGLAND
            ), "GlobalTech Europe Ltd")
            
            # Singapore Assets (Treasury)
            self.sim.add_asset(Asset(
                id="SG-001",
                description="Group Cash Pool",
                asset_type=AssetType.CASH,
                value=65000000,
                location=Jurisdiction.SINGAPORE
            ), "GlobalTech Treasury Pte Ltd")
            
            self.sim.add_asset(Asset(
                id="SG-002",
                description="Investment Portfolio",
                asset_type=AssetType.INVESTMENTS,
                value=42000000,
                location=Jurisdiction.SINGAPORE
            ), "GlobalTech Treasury Pte Ltd")
            
            # Cayman Assets (Holdco)
            self.sim.add_asset(Asset(
                id="KY-001",
                description="Intercompany Loans to Subsidiaries",
                asset_type=AssetType.INTERCOMPANY_LOANS,
                value=380000000,
                location=Jurisdiction.CAYMAN_ISLANDS
            ), "GlobalTech Holdings Ltd")
            
            # Hong Kong Assets
            self.sim.add_asset(Asset(
                id="HK-001",
                description="APAC Office Building",
                asset_type=AssetType.REAL_ESTATE,
                value=38000000,
                location=Jurisdiction.HONG_KONG
            ), "GlobalTech Asia Pacific Ltd")
            
            self.sim.add_asset(Asset(
                id="HK-002",
                description="APAC Receivables",
                asset_type=AssetType.RECEIVABLES,
                value=22000000,
                location=Jurisdiction.HONG_KONG
            ), "GlobalTech Asia Pacific Ltd")
        
        def add_creditors(self):
            """Add creditors from different classes"""
            
            # Secured Creditors
            self.sim.add_creditor(Creditor(
                id="SEC-001",
                name="US Bank N.A.",
                creditor_class=CreditorClass.SECURED,
                claim_amount=92000000,
                jurisdiction=Jurisdiction.US_NEW_YORK,
                secured_collateral="US-001"
            ))
            
            self.sim.add_creditor(Creditor(
                id="SEC-002",
                name="HSBC Bank plc",
                creditor_class=CreditorClass.SECURED,
                claim_amount=48000000,
                jurisdiction=Jurisdiction.UK_ENGLAND,
                secured_collateral="UK-001"
            ))
            
            self.sim.add_creditor(Creditor(
                id="SEC-003",
                name="DBS Bank Ltd",
                creditor_class=CreditorClass.SECURED,
                claim_amount=55000000,
                jurisdiction=Jurisdiction.SINGAPORE,
                secured_collateral="SG-001"
            ))
            
            # Bond Holders (Unsecured)
            self.sim.add_creditor(Creditor(
                id="UB-001",
                name="Ares Management (Bondholder Committee)",
                creditor_class=CreditorClass.UNSECURED,
                claim_amount=185000000,
                jurisdiction=Jurisdiction.US_NEW_YORK
            ))
            
            self.sim.add_creditor(Creditor(
                id="UB-002",
                name="Oaktree Capital (Bondholder Committee)",
                creditor_class=CreditorClass.UNSECURED,
                claim_amount=120000000,
                jurisdiction=Jurisdiction.US_NEW_YORK
            ))
            
            self.sim.add_creditor(Creditor(
                id="UB-003",
                name="PIMCO (Bondholder)",
                creditor_class=CreditorClass.UNSECURED,
                claim_amount=95000000,
                jurisdiction=Jurisdiction.US_NEW_YORK
            ))
            
            # Trade Creditors
            self.sim.add_creditor(Creditor(
                id="TC-001",
                name="Various US Trade Creditors",
                creditor_class=CreditorClass.UNSECURED,
                claim_amount=45000000,
                jurisdiction=Jurisdiction.US_NEW_YORK
            ))
            
            self.sim.add_creditor(Creditor(
                id="TC-002",
                name="Various UK Trade Creditors",
                creditor_class=CreditorClass.UNSECURED,
                claim_amount=28000000,
                jurisdiction=Jurisdiction.UK_ENGLAND
            ))
            
            self.sim.add_creditor(Creditor(
                id="TC-003",
                name="Various APAC Trade Creditors",
                creditor_class=CreditorClass.UNSECURED,
                claim_amount=18000000,
                jurisdiction=Jurisdiction.HONG_KONG
            ))
            
            # Intercompany Creditors
            self.sim.add_creditor(Creditor(
                id="IC-001",
                name="GlobalTech Treasury Pte Ltd (Intercompany)",
                creditor_class=CreditorClass.INTERCOMPANY,
                claim_amount=180000000,
                jurisdiction=Jurisdiction.SINGAPORE
            ))
            
            # Priority Creditors
            self.sim.add_creditor(Creditor(
                id="PRI-001",
                name="US Employee Claims",
                creditor_class=CreditorClass.PRIORITY,
                claim_amount=8500000,
                jurisdiction=Jurisdiction.US_NEW_YORK
            ))
            
            self.sim.add_creditor(Creditor(
                id="PRI-002",
                name="UK Employee Claims",
                creditor_class=CreditorClass.PRIORITY,
                claim_amount=4200000,
                jurisdiction=Jurisdiction.UK_ENGLAND
            ))
        
        def establish_comi_factors(self):
            """Establish factors for COMI determination"""
            
            # Factors supporting Cayman (registered)
            self.sim.add_comi_factor(COMIFactor(
                factor="Place of Incorporation",
                weight=0.1,
                supports_jurisdiction=Jurisdiction.CAYMAN_ISLANDS,
                evidence_strength=1.0,
                description="Holdco incorporated in Cayman Islands"
            ))
            
            # Factors supporting Hong Kong (management)
            self.sim.add_comi_factor(COMIFactor(
                factor="Location of Board Meetings",
                weight=0.25,
                supports_jurisdiction=Jurisdiction.HONG_KONG,
                evidence_strength=0.9,
                description="All board meetings held in Hong Kong for past 3 years"
            ))
            
            self.sim.add_comi_factor(COMIFactor(
                factor="Location of Key Management",
                weight=0.2,
                supports_jurisdiction=Jurisdiction.HONG_KONG,
                evidence_strength=0.85,
                description="CEO and CFO based in Hong Kong; regular presence of directors"
            ))
            
            # Factors supporting Singapore (treasury)
            self.sim.add_comi_factor(COMIFactor(
                factor="Location of Treasury Operations",
                weight=0.15,
                supports_jurisdiction=Jurisdiction.SINGAPORE,
                evidence_strength=0.95,
                description="Central treasury in Singapore; all major cash flows managed there"
            ))
            
            self.sim.add_comi_factor(COMIFactor(
                factor="Location of Principal Bank Accounts",
                weight=0.15,
                supports_jurisdiction=Jurisdiction.SINGAPORE,
                evidence_strength=0.9,
                description="Primary banking relationships in Singapore"
            ))
            
            # Factors supporting US (operations)
            self.sim.add_comi_factor(COMIFactor(
                factor="Location of Major Operations",
                weight=0.3,
                supports_jurisdiction=Jurisdiction.US_DELAWARE,
                evidence_strength=0.85,
                description="Largest operating subsidiary; 450 employees; primary manufacturing"
            ))
            
            self.sim.add_comi_factor(COMIFactor(
                factor="Location of Largest Revenue Generation",
                weight=0.25,
                supports_jurisdiction=Jurisdiction.US_DELAWARE,
                evidence_strength=0.95,
                description="45% of group revenue from US operations"
            ))
            
            # Creditor perception factor
            self.sim.add_comi_factor(COMIFactor(
                factor="Creditor Perception/Reliance",
                weight=0.2,
                supports_jurisdiction=Jurisdiction.HONG_KONG,
                evidence_strength=0.7,
                description="Bond offering circulars emphasized HK management; creditors aware of HK base"
            ))
        
        def create_recognition_motions(self):
            """Create recognition motions in key jurisdictions"""
            
            # Motion in US - claiming COMI
            us_motion = RecognitionMotion(
                id="REC-US-001",
                foreign_representative="Joint Provisional Liquidators (Cayman)",
                foreign_proceeding_jurisdiction=Jurisdiction.CAYMAN_ISLANDS,
                proceeding_type=ProceedingType.FOREIGN_MAIN,
                filing_date=self.sim.start_date + timedelta(days=5),
                requesting_jurisdiction=Jurisdiction.US_NEW_YORK
            )
            us_motion.supporting_evidence = [
                "Cayman winding up petition",
                "Affidavit of COMI",
                "List of group entities and operations",
                "Proof of creditor notification"
            ]
            self.sim.file_recognition_motion(us_motion)
            
            # Motion in UK - for local proceedings
            uk_motion = RecognitionMotion(
                id="REC-UK-001",
                foreign_representative="Joint Provisional Liquidators (Cayman)",
                foreign_proceeding_jurisdiction=Jurisdiction.CAYMAN_ISLANDS,
                proceeding_type=ProceedingType.FOREIGN_MAIN,
                filing_date=self.sim.start_date + timedelta(days=7),
                requesting_jurisdiction=Jurisdiction.UK_ENGLAND
            )
            self.sim.file_recognition_motion(uk_motion)
            
            # Motion in Singapore - alternative COMI claim
            sg_motion = RecognitionMotion(
                id="REC-SG-001",
                foreign_representative="Joint Provisional Liquidators (Cayman)",
                foreign_proceeding_jurisdiction=Jurisdiction.CAYMAN_ISLANDS,
                proceeding_type=ProceedingType.FOREIGN_MAIN,
                filing_date=self.sim.start_date + timedelta(days=10),
                requesting_jurisdiction=Jurisdiction.SINGAPORE
            )
            self.sim.file_recognition_motion(sg_motion)
            
            # Motion in Hong Kong - alternative COMI claim by creditors
            hk_motion = RecognitionMotion(
                id="REC-HK-001",
                foreign_representative="Joint Provisional Liquidators (Cayman)",
                foreign_proceeding_jurisdiction=Jurisdiction.CAYMAN_ISLANDS,
                proceeding_type=ProceedingType.FOREIGN_MAIN,
                filing_date=self.sim.start_date + timedelta(days=12),
                requesting_jurisdiction=Jurisdiction.HONG_KONG
            )
            self.sim.file_recognition_motion(hk_motion)
        
        def implement_safeguards(self):
            """Implement asset safeguard measures"""
            
            # Singapore cash protection
            self.sim.implement_safeguard(SafeguardMeasure(
                measure_type="Mareva Injunction",
                asset_id="SG-001",
                jurisdiction=Jurisdiction.SINGAPORE,
                effective_date=self.sim.start_date + timedelta(days=3),
                description="Freeze on group cash pool pending recognition",
                conditions=["No disbursements without court approval", "Daily balance reporting"],
                monitoring_required=True
            ))
            
            # UK property protection
            self.sim.implement_safeguard(SafeguardMeasure(
                measure_type="Charging Injunction",
                asset_id="UK-001",
                jurisdiction=Jurisdiction.UK_ENGLAND,
                effective_date=self.sim.start_date + timedelta(days=8),
                description="Protection of distribution center",
                monitoring_required=False
            ))
            
            # Hong Kong property protection
            self.sim.implement_safeguard(SafeguardMeasure(
                measure_type="Proprietary Injunction",
                asset_id="HK-001",
                jurisdiction=Jurisdiction.HONG_KONG,
                effective_date=self.sim.start_date + timedelta(days=14),
                description="Protection of APAC headquarters",
                monitoring_required=True
            ))
    
    
    def run_full_simulation():
        """Run a complete cross-border insolvency simulation"""
        
        # Initialize simulation
        start_date = datetime.date(2024, 1, 15)
        sim = CrossBorderInsolvencySimulation(
            case_name="GlobalTech Holdings Ltd et al. - Cross-Border Insolvency",
            start_date=start_date
        )
        
        # Build the case
        builder = CaseBuilder(sim)
        builder.build_global_trading_company()
        builder.add_assets()
        builder.add_creditors()
        builder.establish_comi_factors()
        
        # ========== PHASE 1: PRE-FILING AND COMI ANALYSIS ==========
        print("\n" + "="*60)
        print("PHASE 1: COMI DETERMINATION ANALYSIS")
        print("="*60)
        
        sim.advance_time(2)
        
        # Determine COMI
        comi, analysis = sim.determine_comi()
        print(f"\nCOMI Determined: {comi.value}")
        print("\nJurisdiction Scores:")
        for jur, score in sorted(analysis["scores"].items(), key=lambda x: x[1], reverse=True):
            print(f"  {jur}: {score:.2f}")
        
        # ========== PHASE 2: FILING RECOGNITION MOTIONS ==========
        print("\n" + "="*60)
        print("PHASE 2: RECOGNITION MOTION FILINGS")
        print("="*60)
        
        builder.create_recognition_motions()
        
        # Implement early safeguards
        builder.implement_safeguards()
        
        # ========== PHASE 3: HEARINGS AND CONTESTS ==========
        print("\n" + "="*60)
        print("PHASE 3: RECOGNITION HEARINGS")
        print("="*60)
        
        # US Hearing
        sim.advance_time(20)
        sim.simulate_hearing("REC-US-001")
        
        # Creditors object to Cayman COMI
        sim.creditors["UB-001"].objections.append("REC-US-001")
        sim.creditors["UB-002"].objections.append("REC-US-001")
        sim.recognition_motions["REC-US-001"].status = RecognitionStatus.CONTESTED
        
        print(f"\n[Day {sim.events[-1]['date']}] US Recognition Hearing")
        print("  Bondholder committee contests Cayman as COMI")
        print("  Argument: Hong Kong is true COMI based on management location")
        
        # UK Hearing
        sim.advance_time(15)
        sim.simulate_hearing("REC-UK-001")
        sim.process_recognition_motion("REC-UK-001", True, [
            "Article 21(a)(i) - Stay of proceedings",
            "Article 21(a)(ii) - Relief from asset disposal",
            "Article 21(a)(iii) - Delivery of assets to foreign representative"
        ])
        print(f"\n[Day {sim.events[-1]['date']}] UK Recognition Granted")
        
        # Singapore Hearing
        sim.advance_time(10)
        sim.simulate_hearing("REC-SG-001")
        sim.process_recognition_motion("REC-SG-001", True, [
            "Article 21(a)(i) - Stay of proceedings",
            "Article 21(a)(ii) - Asset freeze",
            "Article 21(c) - Additional relief as appropriate"
        ])
        print(f"\n[Day {sim.events[-1]['date']}] Singapore Recognition Granted")
        
        # US Resolution - COMI shifted to Hong Kong
        sim.advance_time(25)
        # Re-determine with adjusted factors
        sim.comi_jurisdiction = Jurisdiction.HONG_KONG
        sim.process_recognition_motion("REC-US-001", True, [
            "Article 21(a)(i) - Stay of proceedings",
            "Article 21(a)(ii) - Asset freeze",
            "Recognition as Foreign NON-Main (establishment)"
        ])
        sim.recognition_motions["REC-US-001"].proceeding_type = ProceedingType.FOREIGN_NON_MAIN
        print(f"\n[Day {sim.events[-1]['date']}] US Recognition Granted as Non-Main")
        print("  Court determines Hong Kong is COMI")
        
        # Hong Kong - Foreign Main recognition
        sim.advance_time(5)
        sim.simulate_hearing("REC-HK-001")
        sim.process_recognition_motion("REC-HK-001", True, [
            "Full Article 21 relief",
            "Recognition as Foreign Main"
        ])
        sim.recognition_motions["REC-HK-001"].proceeding_type = ProceedingType.FOREIGN_MAIN
        print(f"\n[Day {sim.events[-1]['date']}] Hong Kong Recognition Granted as Main")
        
        # ========== PHASE 4: CREDITOR COMMITTEE CHOREOGRAPHY ==========
        print("\n" + "="*60)
        print("PHASE 4: CREDITOR COMMITTEE FORMATION")
        print("="*60)
        
        # US Committee
        sim.advance_time(10)
        sim.establish_creditor_committee(Jurisdiction.US_NEW_YORK, [
            "SEC-001", "UB-001", "UB-002", "TC-001", "PRI-001"
        ])
        print(f"\n[Day {sim.current_date}] US Creditors Committee Formed")
        print(f"  Members: {[sim.creditors[c].name for c in sim.committees[Jurisdiction.US_NEW_YORK]]}")
        
        # UK Committee
        sim.advance_time(5)
        sim.establish_creditor_committee(Jurisdiction.UK_ENGLAND, [
            "SEC-002", "TC-002", "PRI-002"
        ])
        print(f"\n[Day {sim.current_date}] UK Creditors Committee Formed")
        
        # Singapore Committee (Treasury focus)
        sim.advance_time(3)
        sim.establish_creditor_committee(Jurisdiction.SINGAPORE, [
            "SEC-003", "IC-001"
        ])
        print(f"\n[Day {sim.current_date}] Singapore Creditors Committee Formed")
        
        # Cross-Border Protocol
        sim.advance_time(15)
        sim.coordinate_committees(
            "GlobalTech Cross-Border Insolvency Protocol",
            [
                "Information sharing between jurisdictions",
                "Coordinated marketing of assets",
                "Joint creditor committee meetings (monthly)",
                "Single investment banker for global sale process",
                " moratorium coordination",
                "Asset disposition approval thresholds",
                "Carve-out for intercompany claims resolution",
                "Protocol for asset repatriation timing"
            ]
        )
        print(f"\n[Day {sim.current_date}] Cross-Border Protocol Executed")
        print("  All committees agree to coordinated process")
        
        # ========== PHASE 5: ASSET REPATRIATION ==========
        print("\n" + "="*60)
        print("PHASE 5: ASSET REPATRIATION SAFEGUARDS")
        print("="*60)
        
        # Repatriate Singapore cash to Hong Kong (COMI)
        sim.advance_time(20)
        success = sim.repatriate_asset("SG-001", Jurisdiction.HONG_KONG)
        if success:
            print(f"\n[Day {sim.current_date}] Cash Pool Repatriated to Hong Kong")
            print(f"  Value: $65,000,000")
            print(f"  Safeguards applied: Court order, secured creditor consent")
        
        # Repatriate Singapore investments
        sim.advance_time(5)
        success = sim.repatriate_asset("SG-002", Jurisdiction.HONG_KONG)
        if success:
            print(f"\n[Day {sim.current_date}] Investment Portfolio Repatriated")
            print(f"  Value: $42,000,000")
        
        # Attempt to repatriate encumbered US asset - blocked
        sim.advance_time(10)
        print(f"\n[Day {sim.current_date}] Attempted Repatriation of US Manufacturing Plant")
        success = sim.repatriate_asset("US-001", Jurisdiction.HONG_KONG)
        if not success:
            print("  BLOCKED: Asset is encumbered by secured creditor")
            print("  Resolution: Asset remains in US for secured creditor realization")
        
        # ========== FINAL REPORT ==========
        print("\n" + "="*60)
        print("SIMULATION COMPLETE - GENERATING FINAL REPORT")
        print("="*60)
        
        return sim
    
    
    # ==================== VISUALIZATION ====================
    
    def display_timeline(simulation: CrossBorderInsolvencySimulation):
        """Display a formatted timeline of events"""
        print("\n" + "="*80)
        print("DETAILED EVENT TIMELINE")
        print("="*80)
        
        for i, event in enumerate(simulation.events):
            date_str = event['date'].strftime("%Y-%m-%d")
            day_num = (event['date'] - simulation.start_date).days
            print(f"\n[Day {day_num:3d} | {date_str}] {event['type'].upper()}")
            print(f"    {event['description']}")
            if event['metadata']:
                for key, value in list(event['metadata'].items())[:3]:
                    if isinstance(value, dict):
                        continue
                    print(f"    → {key}: {value}")
    
    
    def display_recognition_status(simulation: CrossBorderInsolvencySimulation):
        """Display recognition motion status summary"""
        print("\n" + "="*80)
        print("RECOGNITION MOTION STATUS SUMMARY")
        print("="*80)
        
        print(f"\n{'Motion ID':<12} {'From':<20} {'To':<15} {'Type':<15} {'Status':<12}")
        print("-" * 80)
        
        for motion_id, motion in simulation.recognition_motions.items():
            print(f"{motion_id:<12} {motion.foreign_proceeding_jurisdiction.value:<20} "
                  f"{motion.requesting_jurisdiction.value:<15} {motion.proceeding_type.value:<15} "
                  f"{motion.status.value:<12}")
    
    
    def display_comi_analysis(simulation: CrossBorderInsolvencySimulation):
        """Display detailed COMI analysis"""
        print("\n" + "="*80)
        print("COMI DETERMINATION ANALYSIS")
        print("="*80)
        
        print(f"\nFinal Determination: {simulation.comi_jurisdiction.value}")
        print(f"\nFactor Analysis:")
        print(f"{'Factor':<35} {'Supports':<20} {'Weight':<8} {'Evidence':<10} {'Score':<8}")
        print("-" * 85)
        
        for factor in simulation.comi_factors:
            print(f"{factor.factor:<35} {factor.supports_jurisdiction.value:<20} "
                  f"{factor.weight:<8.2f} {factor.evidence_strength:<10.2f} "
                  f"{factor.weight * factor.evidence_strength:<8.2f}")
    
    
    def display_asset_tracker(simulation: CrossBorderInsolvencySimulation):
        """Display asset status tracker"""
        print("\n" + "="*80)
        print("ASSET STATUS TRACKER")
        print("="*80)
        
        print(f"\n{'Asset ID':<10} {'Description':<30} {'Value':>15} {'Location':<20} {'Frozen':<8} {'Repatriated':<12}")
        print("-" * 100)
        
        for asset_id, asset in simulation.assets.items():
            print(f"{asset_id:<10} {asset.description[:28]:<30} ${asset.value:>13,.0f} "
                  f"{asset.location.value:<20} {'Yes' if asset.frozen else 'No':<8} "
                  f"{'Yes' if asset.repatriated else 'No':<12}")
    
    
    def display_committee_structure(simulation: CrossBorderInsolvencySimulation):
        """Display creditor committee structure"""
        print("\n" + "="*80)
        print("CREDITOR COMMITTEE STRUCTURE")
        print("="*80)
        
        for jurisdiction, members in simulation.committees.items():
            total_claims = sum(simulation.creditors[m].claim_amount for m in members if m in simulation.creditors)
            print(f"\n{jurisdiction.value} Committee")
            print(f"  Total Claims Represented: ${total_claims:,.0f}")
            print(f"  Members:")
            for member_id in members:
                if member_id in simulation.creditors:
                    creditor = simulation.creditors[member_id]
                    print(f"    • {creditor.name} ({creditor.creditor_class.value})")
                    print(f"      Claims: ${creditor.claim_amount:,.0f}")
    
    
    # ==================== MAIN EXECUTION ====================
    
    if __name__ == "__main__":
        print("""
        ╔══════════════════════════════════════════════════════════════════════════════╗
        ║     UNCITRAL MODEL LAW CROSS-BORDER INSOLVENCY SIMULATION                   ║
        ║                                                                              ║
        ║  Simulating: GlobalTech Holdings Ltd et al.                                 ║
        ║  Jurisdictions: Cayman • Hong Kong • Singapore • US • UK • BVI              ║
        ║                                                                              ║
        ║  Key Features:                                                               ║
        ║  • COMI (Center of Main Interests) determination with weighted factors      ║
        ║  • Recognition motion proceedings under Articles 15-17                       ║
        ║  • Article 19 interim relief and Article 21 recognition relief              ║
        ║  • Multi-jurisdictional creditor committee coordination                     ║
        ║  • Asset safeguard measures and repatriation protocols                      ║
        ╚══════════════════════════════════════════════════════════════════════════════╝
        """)
        
        # Run simulation
        simulation = run_full_simulation()
        
        # Display outputs
        display_comi_analysis(simulation)
        display_recognition_status(simulation)
        display_committee_structure(simulation)
        display_asset_tracker(simulation)
        display_timeline(simulation)
        
        # Generate final report
        print("\n" + simulation.generate_report())
        
        print("""
        ╔══════════════════════════════════════════════════════════════════════════════╗
        ║                     SIMULATION KEY OUTCOMES                                  ║
        ╠══════════════════════════════════════════════════════════════════════════════╣
        ║  COMI DETERMINATION: Hong Kong                                              ║
        ║  - Board meetings and key management located in HK                          ║
        ║  - Creditor perception favored HK location                                  ║
        ║                                                                              ║
        ║  RECOGNITION OUTCOMES:                                                       ║
        ║  - Hong Kong: FOREIGN MAIN (full Article 21 relief)                         ║
        ║  - Singapore: FOREIGN MAIN (treasury operations)                            ║
        ║  - UK: FOREIGN MAIN (operating subsidiary)                                  ║
        ║  - US: FOREIGN NON-MAIN (establishment only - contested COMI)               ║
        ║                                                                              ║
        ║  ASSET SAFEGUARDS IMPLEMENTED:                                               ║
        ║  - Singapore cash pool frozen and repatriated                               ║
        ║  - UK and HK properties under charging injunctions                          ║
        ║  - Secured US assets protected for creditor realization                     ║
        ║                                                                              ║
        ║  CREDITOR COORDINATION:                                                      ║
        ║  - Cross-border protocol executed                                           ║
        ║  - Joint committees in US, UK, Singapore                                    ║
        ║  - Coordinated sale process agreed                                          ║
        ╚══════════════════════════════════════════════════════════════════════════════╝
        """)
    

    Key Simulation Components

    1. COMI Arguments (Center of Main Interests)

    The simulation implements the Recital 13 test with weighted factors:

    • Location of board meetings (Hong Kong)
    • Location of key management (Hong Kong)
    • Treasury operations (Singapore)
    • Major operations (US)
    • Creditor perception (Hong Kong)

    2. Recognition Motion Timelines

    • Day 5-12: Filing in US, UK, Singapore, Hong Kong
    • Day 25-75: Hearings and determinations
    • Contest procedures when creditors challenge COMI
    • Article 19 interim relief and Article 21 full relief

    3. Creditor Committee Choreography

    • Formation of committees in each jurisdiction
    • Cross-border protocol for coordination
    • Joint meeting schedules
    • Information sharing agreements
    • Coordinated sale process

    4. Asset Repatriation Safeguards

    • Mareva injunctions (freeze orders)
    • Charging injunctions
    • Proprietary injunctions
    • Secured creditor protections
    • Monitoring requirements

    Run the simulation to see the full case unfold with realistic timelines and legal procedures!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.