feat(skills): add /aidd-parallel

Concurrent dispatch + delegation skill extracted from PR #168.
Includes the delegate subcommand, prompt generation, evals, and epic.

Author: cursoragent

ai-evals/aidd-parallel/fixtures/add.js

@@ -0,0 +1 @@
+export const add = (a, b) => a - b;

ai-evals/aidd-parallel/fixtures/greet.js

@@ -0,0 +1 @@
+export const greet = (name) => `Hello, ${name}`;

ai-evals/aidd-parallel/prompt-generation-test.sudo

@@ -0,0 +1,21 @@
+import 'ai/skills/aidd-parallel/SKILL.md'
+
+userPrompt = """
+Run /aidd-parallel --branch feature/utils with the following two tasks:
+
+Task 1:
+  File: ai-evals/aidd-parallel/fixtures/add.js, line 1
+  "add() subtracts instead of adding — should use + not -"
+
+Task 2:
+  File: ai-evals/aidd-parallel/fixtures/greet.js, line 1
+  "greet() should include an exclamation mark at the end of the greeting"
+
+Generate delegation prompts for both tasks.
+"""
+
+- Given two tasks and a branch, should generate a separate delegation prompt for each task
+- Given a generated prompt, should start with /aidd-fix
+- Given a generated prompt, should reference the correct branch feature/utils
+- Given a generated prompt, should instruct the sub-agent to commit and push to origin/feature/utils
+- Given a generated prompt, should be wrapped in a markdown codeblock

ai/commands/aidd-parallel.md

@@ -0,0 +1,10 @@
+---
+description: Generate /aidd-fix delegation prompts for a list of tasks and optionally dispatch them to sub-agents in dependency order
+---
+# 🔀 /aidd-parallel
+
+Load and execute the skill at `ai/skills/aidd-parallel/SKILL.md`.
+
+Constraints {
+  Before beginning, read and respect the constraints in /aidd-please.
+}

ai/commands/index.md

@@ -16,6 +16,12 @@ Rank files by hotspot score to identify prime candidates for refactoring before
 
 *No description available*
 
+### 🔀 /aidd-parallel
+
+**File:** `aidd-parallel.md`
+
+Generate /aidd-fix delegation prompts for a list of tasks and optionally dispatch them to sub-agents in dependency order
+
 ### 📋 /aidd-requirements
 
 **File:** `aidd-requirements.md`

ai/skills/aidd-parallel/README.md

@@ -0,0 +1,64 @@
+# aidd-parallel — Parallel Sub-Agent Delegation
+
+`/aidd-parallel` generates focused `/aidd-fix` delegation prompts for a list
+of tasks and can dispatch them to sub-agents in dependency order.
+
+## Usage
+
+```
+/aidd-parallel [--branch <branch>] <tasks>   — generate one /aidd-fix delegation prompt per task
+/aidd-parallel delegate                       — build file list + dep graph, sequence, and dispatch
+```
+
+## Why parallel delegation matters
+
+When a PR review or task breakdown produces multiple independent issues, fixing
+them sequentially in a single agent thread wastes time and dilutes attention.
+`/aidd-parallel` extracts the delegation pattern into a reusable skill so any
+workflow — PR review, task execution, epic delivery — can fan work out to
+focused sub-agents without reimplementing prompt generation logic.
+
+## How it works
+
+### Step 1 — Resolve the branch
+
+If `--branch <branch>` is supplied, use that branch. If omitted, the current
+branch is detected automatically via `git rev-parse --abbrev-ref HEAD`.
+
+### Step 2 — Generate delegation prompts
+
+For each task, one `/aidd-fix` delegation prompt is produced. Every prompt:
+
+- Starts with `/aidd-fix`
+- Contains only the context needed for that single task
+- Instructs the sub-agent to work directly on the target branch and commit and
+  push to `origin/<branch>` — never to `main`, never to a new branch
+- Is wrapped in a fenced markdown codeblock; any nested codeblocks are indented
+  one level to prevent them from breaking the outer fence
+
+### Step 3 (delegate only) — Build the dependency graph
+
+`/aidd-parallel delegate` first builds a list of files each task will change,
+then produces a Mermaid change dependency graph. The graph is used for
+sequencing only — it is not saved or committed.
+
+### Step 4 (delegate only) — Dispatch in dependency order
+
+Prompts are dispatched to sub-agent workers in the order determined by the
+dependency graph: tasks with no dependencies first, dependents after their
+prerequisites are complete.
+
+Post-dispatch callbacks (e.g. resolving PR conversation threads) are the
+caller's responsibility.
+
+## When to use `/aidd-parallel`
+
+- A PR review has multiple independent issues that should be fixed in parallel
+- A task epic has been broken into independent sub-tasks suitable for parallel execution
+- Any workflow that needs to fan work out to multiple `/aidd-fix` sub-agents
+
+## Constraints
+
+- Each prompt must be wrapped in a markdown codeblock
+- Nested codeblocks inside a prompt must be indented to prevent breaking the outer fence
+- Sub-agents are always directed to the supplied branch — never to `main` or a new branch

ai/skills/aidd-parallel/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: aidd-parallel
+description: >
+  Generate /aidd-fix delegation prompts for a list of tasks and optionally dispatch
+  them to sub-agents in dependency order.
+  Use when fanning work out to parallel sub-agents, generating fix delegation prompts
+  for multiple tasks, or coordinating multi-task execution across a shared branch.
+compatibility: Requires git available in the project.
+---
+
+# 🔀 aidd-parallel
+
+Act as a top-tier software engineering lead to generate focused `/aidd-fix`
+delegation prompts and coordinate parallel sub-agent execution.
+
+Competencies {
+  parallel task decomposition
+  dependency graph analysis
+  sub-agent delegation via /aidd-fix
+  branch-targeted prompt generation
+}
+
+Constraints {
+  Put each delegation prompt in a markdown codeblock, indenting any nested codeblocks to prevent breaking the outer block
+  Instruct each sub-agent to work directly on the supplied branch and commit and push to origin on that branch (not to main, not to their own branch)
+  If --branch is omitted, use the current branch (git rev-parse --abbrev-ref HEAD)
+}
+
+## Command: /aidd-parallel [--branch <branch>] <tasks>
+
+generateDelegationPrompts(tasks, branch) => prompts {
+  1. Resolve the branch: if --branch is supplied use it; otherwise run `git rev-parse --abbrev-ref HEAD`
+  2. For each task, generate a focused `/aidd-fix` delegation prompt:
+     - Start the prompt with `/aidd-fix`
+     - Include only the context needed to address that single task
+     - Instruct the sub-agent to work directly on `<branch>`, commit, and push to `origin/<branch>`
+     - Do NOT instruct the sub-agent to create a new branch
+  3. Wrap each prompt in a fenced markdown codeblock; indent any nested codeblocks by one level to prevent them from breaking the outer fence
+  4. Output one codeblock per task
+}
+
+## Command: /aidd-parallel delegate
+
+delegate(tasks, branch) {
+  1. Call generateDelegationPrompts to produce one prompt per task
+  2. Build a list of files that each task will need to change
+  3. Build a Mermaid change dependency graph from the file list
+     - Nodes are files; edges represent "must be complete before" relationships
+     - This graph is for sequencing reference only — do not save or commit it
+  4. Use the dependency graph to determine dispatch order:
+     - Tasks with no dependencies first
+     - Dependent tasks after their prerequisites are complete
+  5. Spawn one sub-agent worker per prompt in dependency order
+  6. Post-dispatch callbacks (e.g. resolving PR threads) are the caller's responsibility
+}
+
+Commands {
+  /aidd-parallel [--branch <branch>] <tasks> - generate one /aidd-fix delegation prompt per task
+  /aidd-parallel delegate [--branch <branch>] <tasks> - build file list + mermaid dep graph, sequence, and dispatch to sub-agents
+}

ai/skills/index.md

@@ -14,6 +14,7 @@
 - aidd-log - Document completed epics in a structured changelog with emoji categorization. Use when the user asks to log changes, update the changelog, or after completing a significant feature or epic.
 - aidd-namespace - Ensures types and related functions are authored and consumed in a modular, discoverable, tree-shakeable pattern. Use when creating types, refactoring type folders, defining schemas, importing types, or when the user mentions type namespaces, constants, or Schema.ToType.
 - aidd-observe - Enforces Observe pattern best practices from @adobe/data/observe. Use when working with Observe, observables, reactive data flow, service Observe properties, or when the user asks about Observe.withMap, Observe.withFilter, Observe.fromConstant, Observe.fromProperties, or similar.
+- aidd-parallel - Generate /aidd-fix delegation prompts for a list of tasks and optionally dispatch them to sub-agents in dependency order. Use when fanning work out to parallel sub-agents, generating fix delegation prompts for multiple tasks, or coordinating multi-task execution across a shared branch.
 - aidd-please - General AI assistant for software development projects. Use when user says "please" or needs general assistance, logging, committing, and proofing tasks.
 - aidd-product-manager - Plan features, user stories, user journeys, and conduct product discovery. Use when building specifications, user journey maps, story maps, personas, or feature PRDs.
 - aidd-react - Enforces React component authoring best practices. Use when creating React components, binding components, presentations, useObservableValues, or when the user asks about React UI patterns, reactive binding, or action callbacks.

tasks/aidd-parallel-skill-epic.md

@@ -0,0 +1,80 @@
+# aidd-parallel Skill Epic
+
+**Status**: 📋 PLANNED
+**Goal**: Extract parallel prompt generation and sub-agent dispatch into a shared `/aidd-parallel` skill, fix the constraint conflation in `/aidd-pr`, and make prompt generation independently unit-testable.
+
+## Overview
+
+The prompt generation and sub-agent dispatch logic in `/aidd-pr` is reusable across any skill that needs to fan work out to sub-agents (PR review, task execution, etc). Extracting it into `/aidd-parallel` gives us a clean unit-testable boundary, fixes the constraint conflation problem in `/aidd-pr` (orchestrator constraints mixed with sub-agent constraints), and makes `/aidd-pr` simpler.
+
+---
+
+## Create the aidd-parallel skill
+
+Add `ai/skills/aidd-parallel/SKILL.md` following the AgentSkills specification.
+
+**Requirements**:
+- Given the agent needs to discover the skill, its name and description should be in the frontmatter
+- Given the agent needs to discover what a skill does, the description should include a very brief description of functionality without delving into implementation details
+- Given the agent needs to discover when to use a skill, the description should include a very brief "Use when..." clause
+- Given a list of tasks, should generate one `/aidd-fix` delegation prompt per task
+- Given a delegation prompt, should start with `/aidd-fix`
+- Given a delegation prompt, should be wrapped in a markdown codeblock, with any nested codeblocks indented to prevent breaking the outer block
+- Given `--branch <branch>` is supplied, should instruct each sub-agent to work directly on `<branch>` and commit and push to origin on `<branch>`
+- Given `--branch` is omitted, should assume the current branch
+- Given `/aidd-parallel delegate`, should first create a list of files that will need to change and a mermaid change dependency graph (for sequencing reference only — do not save or commit)
+- Given `/aidd-parallel delegate`, should use the dependency graph to sequence the prompts before dispatching
+- Given `/aidd-parallel delegate`, should spawn one sub-agent worker per prompt in dependency order
+- Given post-dispatch callbacks are needed (e.g. resolving PR threads), should be the caller's responsibility
+
+Constraints {
+  put the prompt in a markdown codeblock, indenting any nested codeblocks to prevent breaking the outer block
+  instruct the agent to work directly from the supplied branch and commit directly to the supplied branch (not from/to main, not to their own fix branch)
+}
+
+Commands {
+  /aidd-parallel [--branch <branch>] <tasks> - generate one /aidd-fix delegation prompt per task
+  /aidd-parallel delegate - build file list + mermaid dep graph, sequence, and dispatch to sub-agents
+}
+
+---
+
+## Add the aidd-parallel command
+
+Add `ai/commands/aidd-parallel.md` so the skill is invokable and discoverable.
+
+**Requirements**:
+- Given the command file, should load and execute `ai/skills/aidd-parallel/SKILL.md`
+- Given the command file, should respect constraints from `/aidd-please`
+
+---
+
+## Update aidd-pr to use aidd-parallel
+
+Remove the prompt generation and constraint logic from `/aidd-pr` that now belongs in `/aidd-parallel`.
+
+**Requirements**:
+- Given remaining issues after triage, `/aidd-pr` should call `/aidd-parallel` to generate delegation prompts rather than generating them inline
+- Given the inner `Constraints` block in `/aidd-pr` (codeblock format, branch targeting), should be removed from `/aidd-pr` — it belongs in `/aidd-parallel`
+- Given `/aidd-pr delegate`, should call `/aidd-parallel delegate` and then resolve related PR conversation threads via the GitHub GraphQL API
+
+---
+
+## Add aidd-parallel eval
+
+Add `ai-evals/aidd-parallel/` with a unit eval for prompt generation.
+
+**Requirements**:
+- Given a list of tasks and a branch, the eval should assert one prompt is generated per task
+- Given a generated prompt, should assert it starts with `/aidd-fix`
+- Given a generated prompt, should assert it references the correct branch
+- Given a generated prompt, should assert it is wrapped in a markdown codeblock
+
+---
+
+## Update aidd-please discovery
+
+Add `/aidd-parallel` to the Commands block in `ai/skills/aidd-please/SKILL.md`.
+
+**Requirements**:
+- Given the aidd-please Commands block, should list `/aidd-parallel` so agents can discover it