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:

• The model MUST use rune streams --available --json to identify streams with ready work

• 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

• 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