// Manual assignment
TaskUpdate({
  taskId: taskId,
  owner: terminalId,
  metadata: {
    hierarchyLevel: 0,
    subOrchestratorMode: isSubOrchestrator,
    canDecompose: isSubOrchestrator
  }
})

// Auto assignment - all tasks get Sub-Orchestrator mode
const unassigned = TaskList().filter(t => !t.owner)
for (let i = 0; i < unassigned.length; i++) {
  TaskUpdate({
    taskId: unassigned[i].id,
    owner: `terminal-${String.fromCharCode(98 + i)}`
  })
}

# Manual assignment
/assign 1 terminal-b              # Assign Task #1 to Terminal B
/assign 2 terminal-c --sub-orchestrator  # With decomposition ability

# Auto assignment (Sub-Orchestrator default)
/assign auto                      # Assigns all unassigned tasks

# Workload-specific
/assign --workload {slug} auto

function manualAssign(taskId, terminalId, options = {}) {
  // 1. Validate task exists
  const task = TaskGet({taskId})
  if (!task) return error(`Task #${taskId} not found`)

  // 2. Check if already assigned
  if (task.owner) {
    const confirm = askUser(`Reassign from ${task.owner}?`)
    if (!confirm) return
  }

  // 3. Warn about blockers (but allow assignment)
  if (task.blockedBy?.length > 0) {
    warn(`Task blocked by: ${task.blockedBy.join(', ')}`)
  }

  // 4. Update task owner
  TaskUpdate({
    taskId: taskId,
    owner: terminalId,
    metadata: {
      subOrchestratorMode: options.subOrchestrator || false
    }
  })

  // 5. Update _progress.yaml
  updateProgressFile(taskId, terminalId, task)
}

function autoAssign() {
  // 1. Get unassigned tasks
  const unassigned = TaskList().filter(t => !t.owner)

  // 2. Prioritize unblocked tasks
  const unblocked = unassigned.filter(t => !t.blockedBy?.length)
  const blocked = unassigned.filter(t => t.blockedBy?.length > 0)

  // 3. Assign to available terminals
  const terminals = ['terminal-b', 'terminal-c', 'terminal-d']
  let assignments = []

  for (let i = 0; i < unblocked.length; i++) {
    assignments.push({
      taskId: unblocked[i].id,
      terminalId: terminals[i % terminals.length],
      canStart: true
    })
  }

  // 4. Execute assignments with Sub-Orchestrator mode
  for (const a of assignments) {
    TaskUpdate({
      taskId: a.taskId,
      owner: a.terminalId,
      metadata: { subOrchestratorMode: true }
    })
  }
}

Level 0 (Main):       /orchestrate by Main Agent
    |
    +-- Task #1 -----> terminal-b (--sub-orchestrator)
        |
        +-- Level 1:  terminal-b runs /orchestrate
            +-- Subtask #1.1
            +-- Subtask #1.2

=== Assignment Summary ===
Total assigned: 3
Can start now: 1
Blocked: 2

Ready to Start:
  terminal-b: /worker start -> Task #1

Blocked:
  terminal-c: Task #2 (blocked by #1)
  terminal-d: Task #3 (blocked by #2)

terminal-b:
  /worker start
  -> Task #1: {subject}

terminal-c:
  (Wait for blockers)
  -> Task #2 blocked by: 1

handoff:
  skill: "assign"
  workload_slug: "{slug}"
  status: "completed"
  next_action:
    skill: "/worker"
    arguments: "start"
    reason: "Tasks assigned, workers can start"