cm-execution

Execution — Execute Plans at Scale

TL;DR

• Use when running an approved plan from cm-planning
• Modes: A=batch, B=subagent-per-task, C=parallel, D=RARV, E=TRIZ-parallel
• Reads: handoff/plan.json — Writes: handoff/exec.json
• Always: tests pass before reporting done
• Next: cm-code-review

Role: Lead Developer — You execute implementation plans systematically with quality gates at every checkpoint.

Three modes, one skill. Choose based on task structure.

Persona Dispatch (Phase 2)

In Mode B (subagent-per-task) and Mode E (TRIZ-parallel), dispatch the right persona from agents/ based on the task type:

| Task signal | Persona | File | |-------------|---------|------| | "design", "architecture", "trade-off" | architect | agents/architect.md | | "implement", "fix", "refactor" | engineer | agents/engineer.md | | "review", "audit", "verify" | reviewer | agents/reviewer.md | | "secret", "auth", "input validation", "deploy" | security | agents/security.md | | "scope", "intent", "user story" | pm | agents/pm.md |

When dispatching a subagent, pass subagent_type: <persona> (Claude Code agents) or load the persona file as the system prompt for the inner call.

Step 0: Load Working Memory (MANDATORY)

Per _shared/helpers.md#Load-Working-Memory

After EACH completed task: Per _shared/helpers.md#Update-Continuity

Pre-flight: Skill Coverage Audit

Before choosing execution mode, scan plan tasks for technology keywords:

1. Extract technologies/frameworks/tools from ALL task descriptions
2. Cross-reference with cm-skill-index Layer 1 triggers
3. Check installed external skills: npx skills list
4. If gap found → trigger Discovery Loop (cm-skill-mastery Part C)
   → npx skills find "{keyword}" → review → ask user → install
5. Log any installations to .cm-skills-log.json
6. Code Intelligence Context (cm-codeintell):
   → IF codegraph available: codegraph_context(task) for each task
   → IF modifying shared code: codegraph_impact(symbol, depth=2)
   → IF impact > 10 files: WARN "High impact change"
   → Inject context into agent prompts → agents skip grep/glob
7. Only proceed to Mode Selection after all gaps resolved

Mode Selection

Have a plan with independent tasks?
├── Need SPEED + QUALITY on 3+ tasks?
│   └── YES → Mode E: TRIZ-Parallel ⚡ (recommended)
├── Stay in this session?
│   ├── YES → Mode B: Subagent-Driven
│   └── NO → Mode A: Batch Execution
└── Multiple independent failures/problems?
    └── YES → Mode C: Parallel Dispatch

| Mode | When | Strategy | |------|------|----------| | A: Batch | Plan with checkpoints | Execute 3 tasks → report → feedback → next batch | | B: Subagent | Plan with independent tasks, same session | Fresh subagent per task + 2-stage review | | C: Parallel | 2+ independent problems | One agent per problem domain | | E: TRIZ-Parallel ⚡ | 3+ independent tasks, need speed + quality | Dependency-aware parallel dispatch with per-agent quality gates | | F: Party | One non-trivial task, want multi-perspective without subagent cost | Single agent rotates Architect → Engineer → Reviewer (→ Security), append-only .cm/handoff/party.json |

Mode A: Batch Execution

Process

1. Load plan from Fission-AI OpenSpec (openspec/changes/[initiative-name]/tasks.md and design.md) → review critically → raise concerns
2. Execute batch (default: 3 tasks)
3. Mark in_progress → follow steps → verify → mark complete
4. Report → show what was done + verification output
5. Continue → apply feedback → next batch
6. Complete → use cm-code-review to finish
7. Archive → After all tasks complete, manually move the OpenSpec folder to openspec/changes/archive/[date]-[name]/

Rules

• Follow plan steps exactly
• Don't skip verifications
• Between batches: report and wait
• Stop when blocked, don't guess

Mode B: Subagent-Driven Development

Process

1. Read plan from openspec/changes/[initiative-name]/tasks.md → extract ALL tasks with full text
2. Per task:
3. Dispatch implementer subagent with full task text
4. Answer subagent questions if any
5. Subagent implements, tests, commits, self-reviews
6. Dispatch spec reviewer → confirm matches spec
7. Dispatch code quality reviewer → confirm quality
8. If issues → implementer fixes → re-review → repeat
9. After all tasks → final code review → cm-code-review

Prompt Template (Implementer)

Implement [TASK_NAME]:

[Full task text from plan]

Context: [Where this fits in the project]

Rules:
- Follow TDD (cm-tdd)
- Commit when done
- Self-review before reporting
- Ask questions if unclear

Return: Summary of what you did + test results

Red Flags

• Never start on main/master without consent
• Never skip reviews (spec OR quality)
• Never dispatch parallel implementers (conflicts)
• Never accept "close enough" on spec compliance

Mode C: Parallel Dispatch

When

• 3+ test files failing with different root causes
• Multiple subsystems broken independently
• Each problem doesn't need context from others

Process

1. Group failures by independent domain
2. Create focused agent prompt per domain:
3. Specific scope (one file/subsystem)
4. Clear goal
5. Constraints (don't change other code)
6. Expected output format
7. Dispatch in parallel
8. Review + integrate → verify no conflicts → run full suite

Common Mistakes

• ❌ Too broad: "Fix all the tests"
• ✅ Specific: "Fix agent-tool-abort.test.ts"
• ❌ No context: "Fix the race condition"
• ✅ Context: Paste error messages + test names

Mode D: Autonomous RARV

Self-driving execution. Tasks flow through Reason → Act → Reflect → Verify automatically.

When

• User runs /cm-start with a goal
• cm-tasks.json exists with backlog items
• You want continuous autonomous execution

Process (RARV Cycle)

LOOP until backlog empty or user interrupts:
  1. REASON  → Read cm-tasks.json → pick highest-priority backlog task
                Update task status to "in_progress"
                Log: { phase: "REASON", message: "Selected: <title>" }

  2. ACT     → Execute using the task's assigned CM skill
                (cm-tdd, cm-debugging, cm-safe-deploy, etc.)
                Log: { phase: "ACT", message: "<what was done>" }

  3. REFLECT → Update cm-tasks.json with results
                Log: { phase: "REFLECT", message: "<outcome summary>" }

  4. VERIFY  → Run tests/checks (cm-quality-gate)
                If PASS → status = "done", completed_at = now()
                If FAIL → rarv_cycles++, log error, retry from REASON
                If rarv_cycles >= 2 → attempt Skill Discovery Fallback:
                  → npx skills find "{task keywords}"
                  → If skill found + user approves → install, reset rarv_cycles = 0, retry
                  → If NOT found → rarv_cycles >= 3 → status = "blocked"
                Log: { phase: "VERIFY", message: "✅ passed" or "❌ <error>" }

  5. NEXT    → Recalculate stats, pick next task

cm-tasks.json Update Protocol

After EVERY phase, you MUST:

1. Read current cm-tasks.json
2. Sync state from openspec/changes/[initiative-name]/tasks.md (Keep both human-readable MD and AI-executable JSON in parallel sync)
3. Find the active task by id
4. Update status, logs[], timestamps
5. Recalculate stats object:

`` stats.total = tasks.length stats.done = tasks.filter(t => t.status === 'done').length stats.in_progress = tasks.filter(t => t.status === 'in_progress').length stats.blocked = tasks.filter(t => t.status === 'blocked').length stats.backlog = tasks.filter(t => t.status === 'backlog').length stats.rarv_cycles_total = tasks.reduce((sum, t) => sum + (t.rarv_cycles || 0), 0) ``

1. Set updated to current ISO timestamp
2. Write back to cm-tasks.json

Rules

• Max 3 retries per task before marking "blocked"
• **