just-do-it
Execute all remaining tasks in sequence until completion. Usage /groundwork:just-do-it
etr · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add etr/groundwork --skill just-do-it技能说明
name: just-do-it description: Execute all remaining tasks in sequence until completion. Usage /groundwork:just-do-it allowed-tools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep", "Task", "AskUserQuestion", "Skill"] disable-model-invocation: true
Just Do It - Batch Task Execution
Executes all remaining tasks in sequence until completion, stopping on first failure.
Pre-flight: Model Recommendation
Your current effort level is {{effort_level}}.
Skip this step silently if effort is high, xhigh, or max (the scale is low < medium < high < xhigh < max, so xhigh and max are already above high) AND you are Sonnet or Opus.
If effort is low or medium (i.e. below high), you MUST show the recommendation prompt — regardless of model.
If you are not Sonnet or Opus, you MUST show the recommendation prompt - regardless of effort level.
Otherwise → use AskUserQuestion:
{
"questions": [{
"question": "Do you want to switch? Batch orchestration with dependency ordering and failure handling benefits from consistent reasoning.\n\nTo switch: cancel, run `/effort high` (and `/model sonnet` if on Haiku), then re-invoke this skill.",
"header": "Recommended: Sonnet or Opus at high effort",
"options": [
{ "label": "Continue" },
{ "label": "Cancel — I'll switch first" }
],
"multiSelect": false
}]
}
If the user selects "Cancel — I'll switch first": output the switching commands above and stop. Do not proceed with the skill.
Workflow
Step 0: Resolve Project Context
Before loading tasks, ensure project context is resolved:
- Monorepo check: Does
.groundwork.ymlexist at the repo root?- If yes → Is
{{project_name}}non-empty?- If empty → Invoke
Skill(skill="groundwork:select-project")to select a project, then restart this skill. - If set → Project is
{{project_name}}, specs at{{specs_dir}}/.
- If empty → Invoke
- If no → Continue (single-project repo).
- If yes → Is
- CWD mismatch check (monorepo only):
- Skip if not in monorepo mode or if the project was just selected in item 1 above.
- If CWD is the repo root → fine, proceed.
- Check which project's path CWD falls inside (compare against all projects in
.groundwork.yml). - If CWD is inside the selected project's path → fine, proceed.
- If CWD is inside a different project's path → warn via
AskUserQuestion:"You're working from
<cwd>(inside [cwd-project]), but the selected Groundwork project is [selected-project] ([selected-project-path]/). What would you like to do?"- "Switch to [cwd-project]"
- "Stay with [selected-project]"
If the user switches, invoke
Skill(skill="groundwork:select-project").
- If CWD doesn't match any project → proceed without warning (shared directory).
- Proceed with the resolved project context. All
{{specs_dir}}/paths will resolve to the correct location.
Step 1: Load and Analyze Tasks
-
Read the tasks file to find all tasks:
- Single file:
{{specs_dir}}/tasks.md - Directory:
{{specs_dir}}/tasks/(aggregated in sorted order)
- Single file:
-
Parse all tasks and extract:
- Task ID (e.g.,
TASK-001) - Title
- Status (
Not Started,In Progress,Complete,Blocked) - Dependencies (
Blocked by:field)
- Task ID (e.g.,
-
Build dependency graph and calculate execution order:
- Topological sort respecting dependencies
- Blocked tasks cannot execute until dependencies complete
Detection: Check for file first (takes precedence), then directory.
Step 2: Present Summary and Confirm
Present a summary to the user:
Batch Task Execution Summary
Total tasks: X Already complete: Y Remaining: Z
Worktree Isolation
Each task will execute in an isolated git worktree:
- Branch:
task/TASK-NNNcreated from current HEAD - Working directory:
.worktrees/TASK-NNN - Changes merged automatically after each task completes successfully
- Worktrees cleaned up after successful merge
This ensures each task starts from a clean baseline and changes are integrated incrementally.
Execution Order
- TASK-NNN: [Title]
- TASK-NNN: [Title] ...
Blocked Tasks (will execute after dependencies complete)
- TASK-NNN: [Title] (blocked by TASK-XXX)
Ask for confirmation before proceeding.
If user declines, stop and suggest alternatives:
/groundwork:work-on Nto work on a specific task/groundwork:work-on-next-taskto work on just the next available task
Step 3: Execute Loop (Direct Orchestration)
Each task is executed through 5 phases orchestrated directly from this conversation. This avoids nested sub-tasks (sub-tasks cannot spawn other sub-tasks). The main loop holds only: task list + per-task plan summary, IMPLEMENTED result, validation verdicts, and merge result.
For each remaining task in dependency order:
-
Read the task section from
{{specs_dir}}/tasks.md(or aggregated from{{specs_dir}}/tasks/) to extract the full task definition (goal, action items, acceptance criteria, dependencies). -
Announce start: "Starting TASK-NNN: [Title]"
-
Update task status to
**Status:** In Progressin the tasks file.
Phase A: Plan
Agent(
subagent_type="Plan",
description="Plan TASK-NNN",
prompt="Create implementation plan for TASK-NNN: [task title]
Task definition:
[goal, action items, acceptance criteria from task file]
Relevant product specs:
[extracted from {{specs_dir}}/product_specs.md or {{specs_dir}}/product_specs/]
Relevant architecture:
[extracted from {{specs_dir}}/architecture.md or {{specs_dir}}/architecture/]
REQUIREMENTS FOR THE PLAN:
1. All work happens in worktree .worktrees/TASK-NNN (not main workspace)
2. Must follow TDD: write test → implement → verify cycle
3. Plan covers implementation only — validation and merge are handled separately by the caller
"
)
If the plan does not mention worktree or TDD, reject it and re-invoke the Plan agent.
After validation, per
阅读完整来源 ↗