From 32610beb43a0fd9dd3ae71a2e2a151de73ac6e1d Mon Sep 17 00:00:00 2001 From: Ed_ Date: Sun, 5 Jul 2026 13:27:25 -0400 Subject: [PATCH] =?UTF-8?q?conductor(track):=20superpowers=20review=20sect?= =?UTF-8?q?ion=209=20=E2=80=94=20dispatching-parallel-agents=20(brief)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../superpowers_review_20260619/report.md | 57 ++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-) diff --git a/conductor/tracks/superpowers_review_20260619/report.md b/conductor/tracks/superpowers_review_20260619/report.md index 9c79e642..c678de8d 100644 --- a/conductor/tracks/superpowers_review_20260619/report.md +++ b/conductor/tracks/superpowers_review_20260619/report.md @@ -528,7 +528,62 @@ The project follows the executing-plans discipline with three deviations: no `fi ## 9. Dispatching Parallel Agents - +## 9. Dispatching Parallel Agents + +### 9.1 What the skill prescribes + +The `dispatching-parallel-agents` skill is for "2+ independent tasks that can be worked on without shared state or sequential dependencies." Core principle: "Dispatch one agent per independent problem domain. Let them work concurrently." The skill's decision tree: Multiple failures? → Are they independent? → (yes → Can they work in parallel?) → (yes → Parallel dispatch; no → Sequential agents). Use when: 3+ test files failing with different root causes; multiple subsystems broken independently; each problem can be understood without context from others; no shared state between investigations. Don't use when: failures are related; need to understand full system state; agents would interfere. + +The Pattern is 4 steps: (1) Identify Independent Domains — group failures by what's broken; (2) Create Focused Agent Tasks — specific scope + clear goal + constraints + expected output; (3) Dispatch in Parallel — multiple Task tool calls; (4) Review and Integrate — read each summary, verify no conflicts, run full suite, integrate. + +Common Mistakes: Too broad ("Fix all the tests"); No context ("Fix the race condition"); No constraints (agent might refactor everything); Vague output ("Fix it"). The Skill emphasizes that "Agents don't inherit your session's context or history — you construct exactly what they need." + +### 9.2 Mapping to the project's existing pattern + +The project's MMA tier-3 worker dispatch is the closest equivalent, but it's *sequential* per track (not parallel per independent problem). The project's `conductor/workflow.md` §"Conductor Token Firewalling" specifies the "ConductorEngine execution loop" + "WorkerPool (concurrency 4)" pattern in `src/multi_agent_conductor.py`, which IS parallel — but this is the Application domain MMA, not the Meta-Tooling domain dispatch. + +| Skill rule | Project equivalent | Where | +|---|---|---| +| "Dispatch one agent per independent problem domain" | Tier-3 worker dispatch per task (per `conductor/workflow.md` §"Task Workflow" step 4 + step 5); but sequential per track, not parallel | `conductor/workflow.md` | +| "Use when: 3+ test files failing with different root causes" | The "fix_test_failures_20260624" track was a single-agent task with 3 surgical fixes (per chronology); parallel dispatch is not the project's default for fix tracks | `conductor/tracks/fix_test_failures_20260624/` | +| "Use when: multiple subsystems broken independently" | The MMA WorkerPool in `src/multi_agent_conductor.py` handles parallel ticket execution (4 concurrent workers), but this is Application-domain | `src/multi_agent_conductor.py` | +| "Create Focused Agent Tasks: specific scope + clear goal + constraints + expected output" | Tier-3 worker surgical prompt template (per `conductor/workflow.md` §"Task Workflow"): WHERE (file:line) + WHAT (test to create) + HOW (assertions/fixtures) + SAFETY (thread constraints) | `conductor/workflow.md` | +| "Dispatch in Parallel" | Application MMA WorkerPool does parallel execution; Meta-Tooling tier-3 dispatch is sequential per track | `src/multi_agent_conductor.py` | +| "Review and Integrate — read each summary, verify no conflicts" | Tier-2 tech-lead reviews each tier-3 worker's commit before proceeding to next task (per the per-task atomic commit + git note workflow) | `conductor/workflow.md` §"Task Workflow" step 9-10 | +| "Don't use when: agents would interfere" | The project explicitly forbids "Never dispatch multiple implementation subagents in parallel (conflicts)" (per the subagent-driven-development skill analysis in Section 7) | `conductor/workflow.md` | +| "Agents don't inherit your session's context" | The Tier-3 worker is stateless per the MMA pattern: "Tier 3 Worker: Stateless Tier 3 Worker for surgical code implementation and TDD. Operates statelessly (Context Amnesia) but has access to file I/O tools." | `conductor/workflow.md` §"Conductor Token Firewalling" | + +### 9.3 Where the project already follows the discipline + +- **The Tier-3 worker stateless pattern is skill-compliant.** "Context Amnesia" ensures each tier-3 dispatch is a fresh subagent without inherited session context. +- **The "Focused Agent Tasks: WHERE/WHAT/HOW/SAFETY/COMMIT" surgical prompt template** is the project's elaboratation of the skill's "specific scope + clear goal + constraints + expected output". +- **The Application-domain MMA WorkerPool** uses parallel execution (4 concurrent workers) which matches the skill's "dispatch in parallel" pattern. The Application MMA is in `src/multi_agent_conductor.py` (per `docs/guide_multi_agent_conductor.md`). +- **The "Read each summary, verify no conflicts" pattern** is enforced via per-task atomic commits + git notes; the tier-2 reviews each commit before proceeding. + +### 9.4 Where the project doesn't follow the discipline + +- **Meta-Tooling tier-3 dispatch is sequential per track, not parallel per independent problem.** The project's tier-2 tech-lead picks up one task at a time. The skill's "dispatch 3 parallel agents to fix 3 independent test failures" pattern is not used in Meta-Tooling. +- **The Application MMA's WorkerPool (4 concurrent workers)** is the closest equivalent, but it's an execution pattern for application tickets, not for meta-tooling track tasks. +- **"Fix parallelization of independent meta-tooling tasks"** would require a track-design change: the tier-2 would need to dispatch tier-3 workers in parallel and aggregate results. This is technically possible (OpenCode Task tool supports parallel dispatch) but not the project's current practice. + +### 9.5 Recommendations summary + +The project follows the skill's principles (stateless subagents, focused tasks, per-task verification) but applies them sequentially per track. The Application MMA uses parallel execution. The Meta-Tooling tier-3 dispatch is sequential because track tasks are usually sequential (each task depends on the previous one's commit). The deferred rebuild may want to: + +- **LOW:** Document the Meta-Tooling sequential-dispatch pattern vs the Application parallel-dispatch pattern as a deliberate design choice. The skill applies to both; the project uses parallel for one and sequential for the other. + +**Verdict.** + +| Field | Value | +|---|---| +| **Primary** | `PARTIAL` | +| **Integration tag** | `INTEGRATED` | +| **Section size** | brief | +| **Cross-refs** | nagent_review_20260608 §5 (durable work + disposable workers); fable_review_20260617 §3 (cluster-sub-agent dispatch uses the parallel pattern); intent_dsl_survey_20260612 §6 (the project's tier-3 + WorkerPool is documented as "AI-agent properties") | + +**Rationale.** The project's tier-3 worker pattern is skill-compliant (stateless, focused tasks, surgical prompts). The Application MMA's WorkerPool uses the skill's parallel dispatch pattern. The Meta-Tooling tier-3 dispatch is sequential per track (different from the skill's "dispatch 3 parallel agents" pattern). The project uses parallel dispatch where appropriate (Application tickets) and sequential where appropriate (Meta-Tooling track tasks). + +**Recommended change.** *(blank — no rebuild action. The project's deliberate sequential/parallel choice is defensible.)* ## 10. Receiving Code Review