Task Management

class TaskStatus(str, Enum):
    MARKET = "market"                      # Available for acceptance
    PLANNED = "planned"                    # Accepted, not yet dispatched
    ACTIVE = "active"                      # Work in progress
    COMPLETED_SUCCESS = "completed_success" # Finished on time
    COMPLETED_FAIL = "completed_fail"       # Finished late
    CANCELLED = "cancelled"                 # Cancelled by agent

yc-bench market browse --domain research --limit 20

{
  "count": 20,
  "tasks": [
    {
      "task_id": "a1b2c3d4-...",
      "title": "Implement sparse attention mechanism",
      "required_prestige": 5,
      "reward_funds_cents": 4480000,  // $44,800
      "reward_prestige_delta": 0.12,
      "domains": ["research", "training"],
      "requirements": {
        "research": 3200,
        "training": 1800
      }
    },
    ...
  ]
}

replacement = generate_replacement_task(
    run_seed=sim_state.run_seed,
    replenish_counter=counter,  # Ensures determinism
    replaced_prestige=task.required_prestige,
    cfg=world_config,
)

yc-bench task accept --task-id <UUID>

for req in task.requirements:
    domain_prestige = company.prestige[req.domain]
    if task.required_prestige > domain_prestige:
        raise PrestigeError(f"Insufficient prestige in {req.domain}")

max_domain_qty = max(req.required_qty for req in task.requirements)
biz_days = max(
    deadline_min_biz_days,  # 7 days (default)
    int(max_domain_qty / deadline_qty_per_day)  # 200 units/day (default)
)
deadline = add_business_hours(accepted_at, biz_days * work_hours_per_day)

{
  "task_id": "a1b2c3d4-...",
  "status": "planned",
  "accepted_at": "2025-03-15T10:00:00Z",
  "deadline": "2025-03-29T18:00:00Z",  // 10 business days
  "replacement_task_id": "e5f6g7h8-..."  // New market task
}

yc-bench task assign --task-id <UUID> --employee-id <UUID>

if task.status == ACTIVE:
    # Find all active tasks this employee is assigned to
    impacted_tasks = get_active_tasks_for_employee(employee_id)
    recalculate_etas(db, company_id, sim_time, impacted_tasks)

{
  "task_id": "a1b2c3d4-...",
  "status": "planned",
  "assignments": [
    {
      "employee_id": "emp1-...",
      "assigned_at": "2025-03-15T10:05:00Z"
    },
    {
      "employee_id": "emp2-...",
      "assigned_at": "2025-03-15T10:06:00Z"
    }
  ]
}

yc-bench task dispatch --task-id <UUID>

if assignment_count == 0:
    raise ValidationError("Task has no assignments. Assign employees first.")

# Find all active tasks that share employees with this task
impacted = {task_id}  # Include this task
for assignment in task.assignments:
    for peer_task in get_active_tasks_for_employee(assignment.employee_id):
        impacted.add(peer_task.id)

recalculate_etas(db, company_id, sim_time, impacted)

{
  "task_id": "a1b2c3d4-...",
  "status": "active",
  "assignment_count": 2
}

task_progress_milestones = [0.25, 0.5, 0.75]

def handle_task_half(db, event):
    task_id = event.payload["task_id"]
    milestone_pct = event.payload["milestone_pct"]  # 25, 50, or 75
    
    task.progress_milestone_pct = max(
        task.progress_milestone_pct,
        milestone_pct
    )
    
    # Recalculate ETAs to schedule the next milestone
    recalculate_etas(db, company_id, sim_time)

yc-bench task inspect --task-id <UUID>

{
  "task_id": "a1b2c3d4-...",
  "status": "active",
  "progress_pct": 52.3,
  "requirements": [
    {
      "domain": "research",
      "required_qty": 3200,
      "completed_qty": 1680,
      "remaining_qty": 1520
    },
    {
      "domain": "training",
      "required_qty": 1800,
      "completed_qty": 945,
      "remaining_qty": 855
    }
  ],
  "assignments": [...]
}

max_domain_qty = max(req.required_qty for req in task.requirements)
biz_days = max(
    deadline_min_biz_days,      # 7 (default)
    max_domain_qty / deadline_qty_per_day  # 200 units/day (default)
)
deadline = add_business_hours(accepted_at, biz_days * work_hours_per_day)

deadline_qty_per_day = 200.0
deadline_min_biz_days = 7

success = (completion_time <= task.deadline)

if success:
    task.status = COMPLETED_SUCCESS
    
    # 1. Add reward funds
    company.funds_cents += task.reward_funds_cents
    
    # 2. Add prestige to each required domain
    for domain in task.requirements:
        company.prestige[domain] = min(
            prestige_max,
            company.prestige[domain] + task.reward_prestige_delta
        )
    
    # 3. Skill boost assigned employees (in task's domains)
    for assignment in task.assignments:
        for domain in task.requirements:
            employee.skill_rate[domain] *= (1 + task.skill_boost_pct)
    
    # 4. Salary bump for assigned employees
    for assignment in task.assignments:
        employee.salary_cents *= (1 + salary_bump_pct)  # +1% (default)

if not success:
    task.status = COMPLETED_FAIL
    
    # Apply prestige penalty (1.4× reward delta)
    penalty = penalty_fail_multiplier * task.reward_prestige_delta
    for domain in task.requirements:
        company.prestige[domain] = max(
            prestige_min,
            company.prestige[domain] - penalty
        )
    
    # No funds awarded
    # No skill boost
    # No salary bump

yc-bench task cancel --task-id <UUID> --reason "Deadline at risk"

# 1. Apply prestige penalty (2× reward delta)
penalty = penalty_cancel_multiplier * task.reward_prestige_delta
for domain in task.requirements:
    company.prestige[domain] = max(
        prestige_min,
        company.prestige[domain] - penalty
    )

# 2. Set status to CANCELLED
task.status = CANCELLED

# 3. Drop pending events
for event in get_events_for_task(task_id):
    event.consumed = True

# 4. Recalculate ETAs for tasks sharing freed employees
impacted_tasks = get_active_tasks_sharing_employees(task.assignments)
recalculate_etas(db, company_id, sim_time, impacted_tasks)

penalty_cancel_multiplier = 2.0  # 2× the reward delta

yc-bench task list --status active

{
  "count": 3,
  "tasks": [
    {
      "task_id": "a1b2c3d4-...",
      "title": "Implement sparse attention",
      "status": "active",
      "progress_pct": 52.3,
      "deadline": "2025-03-29T18:00:00Z",
      "at_risk": false
    },
    ...
  ]
}

yc-bench task inspect --task-id <UUID>

{
  "task_id": "a1b2c3d4-...",
  "title": "Implement sparse attention",
  "status": "active",
  "required_prestige": 5,
  "reward_funds_cents": 4480000,
  "reward_prestige_delta": 0.12,
  "skill_boost_pct": 0.15,
  "accepted_at": "2025-03-15T10:00:00Z",
  "deadline": "2025-03-29T18:00:00Z",
  "progress_pct": 52.3,
  "requirements": [
    {
      "domain": "research",
      "required_qty": 3200,
      "completed_qty": 1680,
      "remaining_qty": 1520
    },
    {
      "domain": "training",
      "required_qty": 1800,
      "completed_qty": 945,
      "remaining_qty": 855
    }
  ],
  "assignments": [
    {
      "employee_id": "emp1-...",
      "employee_name": "Alice",
      "assigned_at": "2025-03-15T10:05:00Z"
    }
  ]
}

for domain in task.requirements:
    if company.prestige[domain] < task.required_prestige:
        # Do not accept — prestige gating will fail

required_hours = max_domain_qty / (num_employees × avg_rate)
biz_days = required_hours / 9  # 9 hours/day