Simulation Mechanics

class EventType(str, Enum):
    TASK_HALF_PROGRESS = "task_half_progress"  # Milestone at 25%, 50%, 75%
    TASK_COMPLETED = "task_completed"          # Task finished (check deadline)
    BANKRUPTCY = "bankruptcy"                  # Funds < 0
    HORIZON_END = "horizon_end"                # Simulation time limit reached

while True:
    # 1. Find next action: earliest of (next_event, next_payroll, target_time)
    candidates = []
    if next_payroll <= target_time:
        candidates.append(("payroll", next_payroll))
    if next_event exists:
        candidates.append(("event", next_event.scheduled_at))
    candidates.append(("target", target_time))
    
    # Sort by time, then priority: payroll > event > target
    action_type, action_time = min(candidates)
    
    # 2. Flush progress from current_time → action_time
    flush_progress(db, company_id, current_time, action_time)
    apply_prestige_decay(db, company_id, days_elapsed)
    
    # 3. Execute action
    if action_type == "payroll":
        deduct_salaries()
        if funds < 0:
            insert_bankruptcy_event()
        break  # Return control to agent after payroll
    elif action_type == "event":
        dispatch_event(event)
        consume_event(event)
        if terminal_condition:
            break
    elif action_type == "target":
        break  # Target time reached, nothing due

# 1. Calculate business hours elapsed
hours = business_hours_between(t0, t1)  # Excludes nights/weekends

# 2. Calculate effective rate for this task-domain pair
effective_rate = sum(
    employee.rate_domain_per_hour / count(employee.active_tasks)
    for employee in task.assignments
)

# 3. Calculate progress delta
delta_qty = effective_rate * hours
after_qty = min(req.required_qty, before_qty + delta_qty)

# 4. Update completed_qty in database
req.completed_qty = after_qty

def apply_payroll(db, company_id, time):
    employees = db.query(Employee).filter(company_id).all()
    total_payroll = 0
    
    for emp in employees:
        salary = emp.salary_cents
        total_payroll += salary
        
        # Ledger entry for each employee
        db.add(LedgerEntry(
            category=MONTHLY_PAYROLL,
            amount_cents=-salary,  # negative = expense
            ref_id=emp.id,
        ))
    
    company.funds_cents -= total_payroll
    return company.funds_cents < 0  # bankrupt?

def apply_prestige_decay(db, company_id, days_elapsed):
    decay_per_day = world_config.prestige_decay_per_day  # default: 0.005
    total_decay = decay_per_day * days_elapsed
    floor = world_config.prestige_min  # 1.0
    
    for domain in [research, inference, data_environment, training]:
        prestige.level = max(floor, prestige.level - total_decay)

def dispatch_event(db, event, sim_time, company_id):
    if event.event_type == TASK_HALF_PROGRESS:
        handle_task_half(db, event)
        recalculate_etas(db, company_id, sim_time)  # Update future milestones
        return {"type": "task_half", "milestone_pct": 50}
    
    elif event.event_type == TASK_COMPLETED:
        result = handle_task_complete(db, event, sim_time)
        recalculate_etas(db, company_id, sim_time)  # Freed employees change topology
        return {"type": "task_completed", "success": result.success, ...}
    
    elif event.event_type == HORIZON_END:
        return {"type": "horizon_end", "reached": True}
    
    elif event.event_type == BANKRUPTCY:
        return {"type": "bankruptcy", "bankrupt": True}

def solve_task_completion_time(task_id, now, rates):
    # Find max hours across all domain requirements
    max_hours = 0
    for req in task.requirements:
        remaining = req.required_qty - req.completed_qty
        rate = effective_rate_for_domain(task_id, req.domain, rates)
        if rate <= 0 and remaining > 0:
            return None  # Cannot complete (no employees assigned)
        hours = remaining / rate
        max_hours = max(max_hours, hours)
    
    # Domains are worked in parallel → completion time is the bottleneck domain
    return add_business_hours(now, max_hours)

task_progress_milestones = [0.25, 0.5, 0.75]

for milestone in [0.25, 0.5, 0.75]:
    milestone_pct = int(milestone * 100)  # 25, 50, 75
    if milestone_pct <= task.progress_milestone_pct:
        continue  # Already emitted
    
    milestone_time = solve_task_halfway_time(task_id, now, rates, milestone)
    if milestone_time:
        insert_event(
            event_type=TASK_HALF_PROGRESS,
            scheduled_at=milestone_time,
            payload={"task_id": task_id, "milestone_pct": milestone_pct},
        )
        break  # Only insert the next upcoming milestone