home / skills / shotaiuchi / dotclaude / wf0-nexttask

wf0-nexttask skill

safe

/dotclaude/skills/wf0-nexttask

This skill selects and executes the next scheduled task in order, handling dependencies and optional dry-run or full progression.

npx playbooks add skill shotaiuchi/dotclaude --skill wf0-nexttask

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.9 KB

---
name: wf0-nexttask
description: Execute next task from schedule
argument-hint: "[--dry-run] [--until <phase>] [--all] [--no-branch]"
---

**Always respond in Japanese.**

# /wf0-nexttask

Select and execute the next task from schedule.json, respecting dependency order.

## Options

| Option | Description |
|--------|-------------|
| `--dry-run` | Display task info only, do not execute |
| `--until <phase>` | Auto-execute until specified phase (skip selection) |
| `--all` | Auto-execute all remaining tasks (max 50, safety limit) |
| `--no-branch` | Skip branch creation in wf1-kickoff, use current branch |

## Processing

Parse $ARGUMENTS and execute the following.

### 1. Load Schedule

Read `.wf/schedule.json`. Error if missing (suggest `/wf0-schedule create`). Exit if `.status == "completed"`.

### 2. Get Next Task

From `.works`, find the first pending work (sorted by `.priority`) whose `.dependencies` are all completed. If none found, display blocked tasks and exit.

### 3. Display Task Info

Show: work ID, source type/ID, title, dependencies.

### 4. Dry Run

If `--dry-run`: show progress (completed/total, pending count) and exit.

### 5. Execution Range Selection

If neither `--until` nor `--all` specified, use AskUserQuestion:

```
AskUserQuestion(
  questions: [{
    question: "Where would you like to stop?",
    header: "Execute",
    options: [
      { label: "wf1-kickoff only", description: "Start work, then pause for review" },
      { label: "Until wf3-plan", description: "Complete design phase" },
      { label: "Until wf4-review", description: "Complete review phase" },
      { label: "Until wf6-verify (Recommended)", description: "Complete entire task" },
      { label: "Complete all tasks", description: "Execute all remaining tasks in schedule" }
    ],
    multiSelect: false
  }]
)
```

Selection mapping: 1→wf1-kickoff, 2→wf3-plan, 3→wf4-review, 4→wf6-verify, 5→execute_all.

### 6. Execute Workflow

1. Update schedule: set work status to `"running"`, record `started_at`, update `.progress`
2. Execute `/wf1-kickoff {work_id}` via Skill tool (pass `--no-branch` if specified)
3. If target is beyond wf1-kickoff, loop `/wf0-nextstep {work_id}` until `current == target_phase` or `next == "complete"`

### 7. Mark Complete and Show Remaining

If PR created (`.works[work_id].pr.url` exists in state.json):
- Update schedule: status→`"completed"`, record `completed_at`, update `.progress`

Show remaining task count. If zero, set schedule `.status = "completed"`.

For `--all` / selection 5: loop steps 2-7 for each available task.

## Relationship with wf0-nextstep

| Command | Scope |
|---------|-------|
| `wf0-nextstep` | Phase transition within a single work (wf1→wf2→...→wf6) |
| `wf0-nexttask` | Task selection across multiple works in schedule.json |

## Notes

- Schedule must exist (create with `/wf0-schedule create`)
- Tasks execute in priority order respecting dependencies
- `--all` has a 50-task safety limit per invocation

Overview

This skill selects and executes the next pending task from a schedule stored in .wf/schedule.json, respecting task priorities and dependency order. It can preview a task (--dry-run), auto-run until a specified workflow phase (--until), or execute all remaining tasks (--all) with a safety cap. It updates schedule state (running/completed), records timestamps, and reports remaining work.

How this skill works

The skill loads .wf/schedule.json and finds the first pending work whose dependencies are all completed, sorted by priority. It displays task details, lets you choose an execution range (single kickoff, up to a target phase, or complete all), then runs wf1-kickoff and iteratively calls wf0-nextstep until the target phase or completion. It updates the schedule state (started_at, completed_at, progress) and marks the schedule completed when no tasks remain.

When to use it

Execute the next actionable task from a team schedule while honoring dependencies
Run just the kickoff or advance a task through specific phases without manual step-by-step calls
Perform a dry run to inspect the next task and current progress without making changes
Auto-run multiple tasks in sequence when clearing backlog (use --all with caution)
Integrate into automation to keep schedule.json state consistent with executed workflows

Best practices

Ensure .wf/schedule.json exists and is up-to-date (create with wf0-schedule create if missing)
Use --dry-run before executing unfamiliar tasks to confirm selection and dependencies
Prefer --until wf6-verify for full task completion when you want a single automated flow
Use --no-branch when you must avoid creating feature branches during kickoff
Limit use of --all for large schedules; the command enforces a 50-task safety cap per invocation

Example use cases

Run the next high-priority task that has all dependencies satisfied and record progress automatically
Survey the next task with --dry-run before assigning reviewers or resources
Auto-advance a task to wf4-review to complete design review without manual wf0-nextstep loops
Batch-execute remaining low-risk tasks with --all to clear backlog (within 50-task safety limit)
Start work and pause after kickoff by selecting the wf1-kickoff option during the interactive stop prompt

FAQ

What if .wf/schedule.json is missing?

The skill errors and suggests creating the schedule (use wf0-schedule create) before proceeding.

How does --until map to workflow phases?

Interactive choices map to phases: wf1-kickoff, wf3-plan, wf4-review, wf6-verify; a final option executes all remaining tasks.