next-task

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