next-task

What this skill does

### 4. Next task

Implement the next unfinished group of tasks from the tasks list. A group of tasks is a set of tasks that start with the same number like 1.1, 1.2, but NOT 2.1.

**Constraints:**

**Task Retrieval:**
- The model MUST use the rune skill to retrieve the next task(s) to work on
- Use `rune next --format json` to get the next incomplete task. This command will indicate when all tasks are complete
- If the user asks for the entire phase, use `rune next --phase --format json`
- If the retrieved result contains only a single top-level task (without subtasks like "1" instead of "1.1"), rerun with `rune next --phase --format json` to retrieve the full phase of tasks

**Stream Detection for Parallel Execution:**
- When retrieving a phase, the model MUST check for multiple work streams using `rune streams --available --json`
- If multiple streams have ready tasks, parallel execution is possible
- If only one stream has ready tasks, sequential execution within that stream is used

**Task Execution:**
- The model MUST read all files referenced in the front_matter_references
- The selected tasks MUST be added to the internal TODO list for tracking and implemented in the order specified
- The model MUST implement all of the selected tasks, including all subtasks
- Once a subtask or task is completed, use the rune skill to mark it complete (e.g., `rune complete 1.1`)
- The model MUST NOT proceed past the selected task. Once a task is done, it needs to be put up for review by the user
- Use tools and skills as appropriate while implementing the task. For example, if you need to know the capabilities of a library, use context7, and if you want to verify your code is efficient, use the efficiency-optimizer skill

**Parallel Execution with Multiple Streams:**
When a phase is pulled in and multiple streams have ready tasks:
1. The model MUST use `rune streams --available --json` to identify streams with ready work
2. If there are 2 or more streams with ready tasks:
   - The model SHOULD spawn subagents (using the Task tool) to handle each stream in parallel
   - Each subagent receives instructions to:
     - Retrieve all phase tasks for their stream using `rune next --phase --stream N --format json`
     - Read all referenced files from front_matter_references
     - Implement the tasks in dependency order
     - Mark tasks complete as they finish using `rune complete <task-id>`
     - Report back when all tasks in the stream are done or blocked
   - The main agent coordinates by:
     - Monitoring subagent progress
     - Handling any cross-stream dependencies that become unblocked
     - Aggregating results for user review
3. If there is only 1 stream with ready tasks:
   - Execute tasks sequentially within that stream as normal
   - No subagents are needed

**Subagent Instructions Template:**
When spawning a subagent for a stream, provide these instructions:
- Stream number to work on
- Path to the tasks file
- List of front_matter_references to read
- Instruction to use `rune next --phase --stream N --format json` to retrieve all tasks for the stream
- Instruction to mark tasks complete using `rune complete <task-id>`
- Instruction to stop when all tasks in the stream are complete or blocked by tasks in other streams

**Cross-Stream Coordination:**
- When a subagent completes a task that unblocks tasks in another stream, that stream's agent will pick up the newly unblocked work on their next `rune next --phase --stream N` call
- If all streams become blocked waiting on each other, this indicates a circular dependency problem that should be reported to the user
- The main agent should periodically check `rune streams --json` to monitor overall progress

**Specs Overview Update:**
- After completing all tasks in the current group, check if `specs/OVERVIEW.md` exists in the project
- If it exists, update the spec's status in the overview to reflect current progress:
  - If all tasks in the entire spec are now complete: update status to `Done`
  - If some tasks remain: update status to `In Progress` (if currently `Planned`)