/next

name: next
description: Pick or implement the next task or session. Use when continuing work, picking the next task, or implementing tasks from a task list.
argument-hint: [task | session | batch]

**Argument:** $ARGUMENTS

| Argument | Behavior | |----------|----------| | (none) or `task` | Select and implement next task (Section 2) | | `session` | Select and implement next session (Section 3) | | `batch` | Implement all highest-priority unblocked sessions (Section 4) | | `task status` | Select and report next task without implementing (Section 2, stop before implementation) | | `session status` | Select and report next session without implementing (Section 3, stop before implementation) |

**Always start with Section 1 (Find Tasks).**

---

1. Find Tasks

ls .otto/tasks/*.json 2>/dev/null

Read each file, check for pending sessions/tasks. For each task file, also read the corresponding spec file frontmatter to get the spec name.

**If no task files:** "No tasks found. Run `task <spec-name>` to generate."

**If multiple specs have pending work**, use an interactive prompt:

Multiple specs have pending work:
1. {spec-name} ({spec-id}): {n} sessions pending
2. {spec-name} ({spec-id}): {n} sessions pending

Which spec should I work on?

Branch Check (Sections 2, 3, 4)

Before proceeding to any implementation section, check the current branch:

current_branch=$(git branch --show-current)

**If on `main` or `master`**, use an interactive prompt:

You're on '{current_branch}'. Create a feature branch or continue here?

1. Create branch: otto/{spec-id} (recommended)
2. Stay on {current_branch}

If user picks 1, create the branch and continue. If 2, proceed as-is.

---

2. Select Task

Select the next task:

1. Filter to tasks with status "pending" 2. Filter to unblocked tasks (all `depends_on` tasks are "done") 3. Sort by priority (lower number = higher priority) 4. Tie-break by ID (lower ID first)

**If no unblocked tasks:**

| State | Message | |-------|---------| | All tasks "done" | "All tasks complete for {spec-name}!" | | Pending but blocked | "{n} tasks blocked. Waiting on: {blocker-ids}" |

**Report the selected task:**

Next task: {id}
Title: {title}
Priority: {priority}
Session: {session_id}

If invoked with `status` suffix, stop here — do NOT implement.

Implement Task

1. Update task status to "in_progress" 2. Report: "Starting task {id}: {title}"

**Delegate to a subagent:**

• subagent role: `frontend-developer` (frontend tasks) or `backend-architect` (backend tasks), personas defined in `agents/`
• Include in prompt: task context + planning workflow (see below)
• Wait for subagent to complete

**Subagent prompt must include:**

## Task Context
- **Task:** {task title}
- **Description:** {task description}
- **Files:** {file list}
- **Done when:** {done condition}
- **Spec path:** {spec_path from task file}

## Required Workflow

**Always plan before implementing.** Simple tasks get simple plans.

### Phase 1: Plan
1. Read the spec's Technical Design section at {spec_path}
2. Explore relevant files to understand existing patterns
3. Write your implementation plan to `.otto/plans/task-{task_id}.md`:
   - Describe your approach
   - List files to modify and key changes
   - Note any spec decisions that affect implementation

### Phase 2: Implement
4. Implement according to your plan
5. Verify the done condition is met

Keep the plan concise - it's for your reference and audit trail.

**After subagent completes:**

• Update task status to "done"
• Check if all tasks in session are "done"; if so, mark session "done"
• Stage: `git add -u && git add .otto/`
• Commit: `git commit -m "otto: {spec-id} task {id} — {title}"`

Report: "Task {id} complete."

---

3. Select Session

Select the next session:

1. Filter to sessions with status "pending" 2. Filter to unblocked sessions (all `depends_on` sessions are "done") 3. Sort by priority (lower number = higher priority) 4. Tie-break by ID (S1 before S2)

**If no unblocked sessions:**

| State | Message | |-------|---------| | All sessions "done" | "All sessions complete for {spec-name}!" | | Pending but blocked | "{n} sessions blocked. Waiting on: {blocker-ids}" |

**Report the selected session:**

Next session: {id}
Title: {title}
Priority: {priority}
Tasks: {task_count}

If invoked with `status` suffix, stop here — do NOT implement.

Implement Session

1. Update session status to "in_progress" 2. Report: "Starting session {id}: {title} ({n} tasks)"

**Delegate to a subagent:**

• subagent role: `frontend-developer` (frontend tasks) or `backend-architect` (backend tasks), personas defined in `agents/`
• Include in prompt: session context + planning workflow (see below)
• Subagent implements tasks sequentially, marking each "done" as completed
• Wait for subagent to complete

**Subagent prompt must include:**

## Session Context
- **Session:** {session title}
- **Tasks:** {task titles with descriptions}
- **Files:** {file lists from all tasks}
- **Done when:** {done conditions for each task}
- **Spec path:** {spec_path from task file}

## Required Workflow

**Always plan before implementing.** Simple tasks get simple plans.

### Phase 1: Plan
1. Read the spec's Technical Design section at {spec_path}
2. Explore relevant files to understand existing patterns
3. Write your implementation plan to `.otto/plans/{session_id}.md`:
   - List each task you will implement
   - For each task, describe: approach, files to modify, key changes
   - Note any spec decisions that affect implementation

### Phase 2: Implement
4. Implement each task according to your plan
5. After each task: verify the done condition is met
6. Mark each task "done" as completed

Keep the plan concise - it's for your reference and audit trail.

**After subagent completes:**

• Update session status to "done"
• Stage: `git add -u && git add .otto/`
• Commit: `git commit