// Find and start assigned task
const myTasks = TaskList().filter(t => t.owner === workerId)
const taskToStart = myTasks.find(t =>
  t.status === "pending" &&
  (!t.blockedBy || t.blockedBy.length === 0)
)

TaskUpdate({
  taskId: taskToStart.id,
  status: "in_progress"
})

// Mark task as completed
TaskUpdate({
  taskId: currentTask.id,
  status: "completed"
})

// Move prompt file: pending -> completed
movePromptFile(taskId, "pending", "completed")

// Generate completion manifest with SHA256 hashes
generateCompletionManifest(taskId, workerId)

// When task.metadata.subOrchestratorMode === true
// Worker can create subtasks
TaskCreate({
  subject: "Subtask 1.1",
  metadata: {
    hierarchyLevel: task.metadata.hierarchyLevel + 1,
    parentTaskId: task.id
  }
})

/worker start b           # Start as terminal-b
/worker start b 16        # Start terminal-b on task #16
/worker done              # Mark current task complete
/worker status            # Show progress
/worker status b --all    # Show all terminal-b tasks
/worker block "reason"    # Report blocker

/worker orchestrate b     # Decompose current task
/worker delegate b        # Delegate subtasks
/worker collect-sub b     # Collect sub-results

function workerStart(terminalId, specificTaskId = null) {
  // 1. Set worker identity
  setWorkerId(terminalId)

  // 2. Get my tasks
  const myTasks = getMyTasks()
  if (myTasks.length === 0) {
    return { status: "no_tasks", message: "No tasks assigned" }
  }

  // 3. Find task to start (unblocked, pending)
  let taskToStart = specificTaskId
    ? myTasks.find(t => t.id === specificTaskId)
    : myTasks.find(t => t.status === "pending" && isUnblocked(t))

  // 4. Check blockers
  if (taskToStart.blockedBy?.length > 0) {
    const allComplete = taskToStart.blockedBy.every(id =>
      TaskGet({taskId: id}).status === "completed"
    )
    if (!allComplete) return { status: "blocked" }
  }

  // 5. Update status
  TaskUpdate({ taskId: taskToStart.id, status: "in_progress" })

  // 6. Display task details and prompt
  const promptFile = findPromptFile(taskToStart.id)
  displayTaskDetails(taskToStart, promptFile)

  // 7. Update _progress.yaml
  updateProgressFile(workerId, taskToStart.id, "in_progress")
}

function workerDone(specificTaskId = null) {
  // 1. Find current task
  const currentTask = myTasks.find(t => t.status === "in_progress")

  // 2. Mark completed
  TaskUpdate({ taskId: currentTask.id, status: "completed" })

  // 3. Move prompt file
  movePromptFile(currentTask.id, "pending", "completed")

  // 4. Generate manifest with integrity hashes
  generateCompletionManifest(currentTask.id, workerId)

  // 5. Update progress
  updateProgressFile(workerId, currentTask.id, "completed")

  // 6. Show next task
  const nextTask = myTasks.find(t => t.status === "pending")
  if (nextTask) {
    console.log(`Next: Task #${nextTask.id}`)
  } else {
    console.log("All tasks complete! Ready for /collect")
  }
}

function workerStatus(showAll = false) {
  const myTasks = getMyTasks()
  const completed = myTasks.filter(t => t.status === "completed")
  const inProgress = myTasks.filter(t => t.status === "in_progress")
  const pending = myTasks.filter(t => t.status === "pending")

  console.log(`
=== Worker Status: ${workerId} ===
Current: ${inProgress[0]?.subject || "None"}
Progress: ${completed.length}/${myTasks.length} (${percent}%)
Blockers: ${blockers.length}
  `)
}

function workerBlock(reason, taskId = null) {
  const task = taskId ? TaskGet({taskId}) : getCurrentTask()

  // Record blocker
  const blocker = {
    taskId: task.id,
    worker: workerId,
    reason: reason,
    reportedAt: new Date().toISOString()
  }

  // Save to progress file and blocker notification
  addBlockerToProgress(blocker)
  writeBlockerNotification(blocker)
}

// Parent task at level 0
task.metadata.hierarchyLevel = 0

// Subtasks at level 1
TaskCreate({
  metadata: {
    hierarchyLevel: 1,
    parentTaskId: task.id
  }
})

const L1_MAX_TOKENS = 500
const L1_MAX_CHARS = 2000

function validateL1Summary(l1Summary) {
  if (l1Summary.length > L1_MAX_CHARS) {
    return { isValid: false, reason: "exceeds size limit" }
  }
  // Check for L2/L3 content patterns
  // ...
}

function sanitizeL1Summary(l1Summary) {
  // Truncate large code blocks
  // Remove file content dumps
  // Limit total length
}