Parallel work mode - execute independent tasks simultaneously
Execute multiple independent checklist items simultaneously using 2-4 parallel agents for 2-4x faster implementation. Use this when tasks have no dependencies, like building UI components while creating API endpoints.
/plugin marketplace add duongdev/ccpm/plugin install ccpm@duongdev-ccpm-marketplace<issue-id>Execute multiple independent checklist items simultaneously using parallel agent invocation.
This command uses:
helpers/parallel-execution.md - Dependency graph and execution wave managementhelpers/checklist.md - Checklist parsing and progress trackinghelpers/agent-delegation.md - Agent selection for tasks# Auto-detect parallel opportunities
/ccpm:work:parallel PSN-29
# With specific items to parallelize
/ccpm:work:parallel PSN-29 --items 1,2,3
# Maximum parallelism (up to 4 agents)
/ccpm:work:parallel PSN-29 --max 4
| Aspect | /ccpm:work | /ccpm:work:parallel |
|---|---|---|
| Execution | Sequential | Parallel (2-4 agents) |
| Context usage | ~500 tokens | ~800 tokens |
| Speed | 1x | 2-4x faster |
| Best for | Dependent tasks | Independent tasks |
const issueId = args[0];
if (!issueId || !/^[A-Z]+-\d+$/.test(issueId)) {
return error('Usage: /ccpm:work:parallel <issue-id>');
}
console.log('ā” Parallel Work Mode');
console.log(`š Issue: ${issueId}`);
console.log('');
// Fetch issue
const issue = await Task({
subagent_type: 'ccpm:linear-operations',
prompt: `operation: get_issue
params:
issueId: "${issueId}"
context:
cache: true
command: "work:parallel"
`
});
// Fetch recent comments for context (decisions, clarifications)
const commentsResult = await Task({
subagent_type: 'ccpm:linear-operations',
prompt: `operation: list_comments
params:
issueId: "${issueId}"
context:
cache: true
command: "work:parallel"
`
});
// Get last 5 comments for context
issue.recentComments = (commentsResult.comments || []).slice(-5);
// Cache full issue for subagent-context-injector hook
// This allows ANY subagent to receive full issue context automatically
const fs = require('fs');
const issueCache = {
issueId: issue.identifier,
title: issue.title,
description: issue.description,
labels: issue.labels,
priority: issue.priority,
state: issue.state,
attachments: issue.attachments,
recentComments: issue.recentComments,
cachedAt: new Date().toISOString()
};
fs.writeFileSync(`/tmp/ccpm-issue-${issue.identifier}.json`, JSON.stringify(issueCache, null, 2));
console.log(`š¦ Issue context cached for subagents`);
// Parse checklist
const checklistMatch = issue.description.match(/## Implementation Checklist[\s\S]*?(?=\n##|$)/);
const items = [];
if (checklistMatch) {
const lines = checklistMatch[0].split('\n');
for (const line of lines) {
const match = line.match(/^- \[([ x])\] (.+)$/);
if (match) {
items.push({
checked: match[1] === 'x',
content: match[2],
index: items.length
});
}
}
}
const uncheckedItems = items.filter(i => !i.checked);
console.log(`š Found ${uncheckedItems.length} uncompleted items`);
// Identify which items can run in parallel
const analysisResult = await Task({
subagent_type: 'Plan',
model: 'haiku',
prompt: `
Analyze these checklist items for parallel execution:
${uncheckedItems.map((item, i) => `${i+1}. ${item.content}`).join('\n')}
Identify:
1. Which items are INDEPENDENT (can run in parallel)?
2. Which items DEPEND on others (must be sequential)?
Return as JSON:
{
"parallel": [1, 2, 3], // item numbers that can run together
"sequential": [4, 5], // item numbers that must wait
"dependencies": {
"4": [1, 2], // item 4 depends on items 1 and 2
"5": [4] // item 5 depends on item 4
}
}
`
});
const { parallel, sequential, dependencies } = JSON.parse(analysisResult);
console.log(`ā” Parallelizable: ${parallel.length} items`);
console.log(`š Sequential: ${sequential.length} items`);
// Map items to appropriate agents using hook hints or fallback
// Agent names are project-specific - ccpm:* for CCPM, or check hook hints
function selectAgent(itemContent) {
const content = itemContent.toLowerCase();
// Check for hook hint patterns (injected by smart-agent-selector)
// Use ccpm:* namespace for CCPM agents
if (content.match(/\b(ui|component|react|css|tailwind|frontend|page|screen|layout)\b/)) {
return 'ccpm:frontend-developer';
}
if (content.match(/\b(api|endpoint|database|auth|backend|graphql|rest|service|server)\b/)) {
return 'ccpm:backend-architect';
}
if (content.match(/\b(test|spec|jest|vitest|cypress|playwright)\b/)) {
return 'ccpm:tdd-orchestrator';
}
if (content.match(/\b(security|vulnerability|auth|oauth)\b/)) {
return 'ccpm:security-auditor';
}
return 'general-purpose';
}
const parallelTasks = parallel.map(idx => ({
index: idx,
item: uncheckedItems[idx - 1],
agent: selectAgent(uncheckedItems[idx - 1].content)
}));
// NOTE: For other projects, use hook hints to determine agent names:
// const hookHint = context.systemMessages.find(m => m.includes('š”'));
// const suggestedAgent = hookHint?.match(/use `([^`]+)` agent/)?.[1] || 'general-purpose';
console.log('\nš Starting parallel execution...');
console.log('');
// Invoke multiple Task tools in a SINGLE message
// This is critical for true parallelism
const taskPromises = parallelTasks.slice(0, 4).map(task => {
console.log(` ā³ ${task.index}. ${task.item.content} ā ${task.agent}`);
return Task({
subagent_type: task.agent,
prompt: `
## Task
${task.item.content}
## Issue Context
- Issue: ${issueId} - ${issue.title}
- Labels: ${issue.labels?.map(l => l.name).join(', ') || 'none'}
- Priority: ${issue.priority || 'none'}
- Checklist Item: ${task.item.content}
## Requirements & Specifications
${issue.description}
(This is the FULL issue description containing requirements, acceptance criteria,
UI specs, typography, variable naming, copy text, and implementation details.
This is the single source of truth - follow it exactly.)
## Recent Comments (decisions & clarifications)
${issue.recentComments?.map(c => \`- [\${c.createdAt}] \${c.user?.name}: \${c.body}\`).join('\\n') || 'No recent comments'}
## Project Instructions (from CLAUDE.md files)
// Automatically injected by SubagentStart hook
## Visual Context (if UI task)
- Attachments: ${issue.attachments?.map(a => a.url).join(', ') || 'none'}
## Quality Requirements
- Follow existing code patterns
- Use TypeScript strict mode if applicable
- Add necessary imports
- Handle edge cases and errors
- NO placeholder code - implement fully
- Match exact copy/labels from Requirements section
- Use exact variable names if specified
- Follow typography specs (font sizes, weights, colors)
## Expected Output
After making changes, return ONLY:
1. Files modified (list)
2. Summary of changes (2-3 sentences)
3. Any blockers encountered
`
});
});
// Wait for all to complete
const results = await Promise.all(taskPromises);
console.log('');
console.log('ā
Parallel execution complete');
const completedIndices = [];
const blockers = [];
for (let i = 0; i < results.length; i++) {
const task = parallelTasks[i];
const result = results[i];
console.log('');
console.log(`š¦ ${task.index}. ${task.item.content}`);
console.log(` Agent: ${task.agent}`);
console.log(` Files: ${result.files?.join(', ') || 'None'}`);
console.log(` Status: ${result.blocker ? 'ā ļø Blocked' : 'ā
Complete'}`);
if (result.blocker) {
blockers.push({
item: task.item.content,
blocker: result.blocker
});
} else {
completedIndices.push(task.index);
}
}
if (completedIndices.length > 0) {
await Task({
subagent_type: 'ccpm:linear-operations',
prompt: `operation: update_checklist_items
params:
issueId: "${issueId}"
indices: [${completedIndices.join(', ')}]
mark_complete: true
add_comment: false
context:
command: "work:parallel"
`
});
console.log(`\nā
Updated ${completedIndices.length} checklist items`);
}
const gitChanges = await Bash('git diff --stat HEAD');
await Task({
subagent_type: 'ccpm:linear-operations',
prompt: `operation: create_comment
params:
issueId: "${issueId}"
body: |
ā” **Parallel Implementation** | ${await Bash('git rev-parse --abbrev-ref HEAD')}
**Completed**: ${completedIndices.length} items in parallel
**Agents**: ${[...new Set(parallelTasks.map(t => t.agent))].join(', ')}
${blockers.length > 0 ? `**Blockers**: ${blockers.length}` : ''}
+++ š Details
**Parallel Items Completed**:
${completedIndices.map(i => `- ā
${uncheckedItems[i-1].content}`).join('\n')}
${blockers.length > 0 ? `**Blockers**:\n${blockers.map(b => `- ā ļø ${b.item}: ${b.blocker}`).join('\n')}` : ''}
**Git Changes**:
\`\`\`
${gitChanges.trim()}
\`\`\`
+++
context:
command: "work:parallel"
`
});
console.log('ā
Progress synced to Linear');
if (sequential.length > 0) {
console.log('\nš Remaining sequential items:');
for (const idx of sequential) {
const item = uncheckedItems[idx - 1];
const deps = dependencies[idx];
console.log(` ${idx}. ${item.content}`);
if (deps) {
console.log(` ā®” Depends on: ${deps.join(', ')}`);
}
}
console.log('\nš” Run /ccpm:work:parallel again after parallel items are done');
}
console.log('\nāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā');
console.log('ā” Parallel Implementation Complete');
console.log('āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā\n');
console.log(`ā
Completed: ${completedIndices.length} items`);
console.log(`ā ļø Blockers: ${blockers.length}`);
console.log(`ā³ Remaining: ${sequential.length} sequential`);
console.log('');
console.log('š” Next Steps:');
if (blockers.length > 0) {
console.log(' 1. Resolve blockers listed above');
}
if (sequential.length > 0) {
console.log(' 2. /ccpm:work:parallel to continue');
} else {
console.log(' 2. /ccpm:commit to commit changes');
console.log(' 3. /ccpm:verify to run quality checks');
}
ā Good for:
ā Use /ccpm:work instead for:
| Items | /ccpm:work | /ccpm:work:parallel |
|---|---|---|
| 2 items | ~4 min | ~2 min (2x faster) |
| 4 items | ~8 min | ~2-3 min (3x faster) |
| 6 items | ~12 min | ~4-5 min (2.5x faster) |
ā” Parallel Work Mode
š Issue: PSN-29
š Found 6 uncompleted items
ā” Parallelizable: 4 items
š Sequential: 2 items
š Starting parallel execution...
ā³ 1. Create auth endpoints ā ccpm:backend-architect
ā³ 2. Build login form ā ccpm:frontend-developer
ā³ 3. Add JWT middleware ā ccpm:backend-architect
ā³ 4. Create test suite ā ccpm:tdd-orchestrator
ā
Parallel execution complete
š¦ 1. Create auth endpoints
Agent: ccpm:backend-architect
Files: src/api/auth.ts, src/routes/auth.ts
Status: ā
Complete
š¦ 2. Build login form
Agent: ccpm:frontend-developer
Files: src/components/LoginForm.tsx
Status: ā
Complete
...
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā” Parallel Implementation Complete
āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā
ā
Completed: 4 items
ā ļø Blockers: 0
ā³ Remaining: 2 sequential
š” Next Steps:
1. /ccpm:work:parallel to continue
2. /ccpm:commit to commit changes