Micro-Execute: Subagent-Driven Development

Break implementation into 2-3 minute micro-tasks. Each task gets a fresh subagent + two-stage review (spec compliance → code quality). No context pollution between tasks.

Step 1: Validate Input

If args is empty:
  Check for active WORKFLOW_STATE.yaml in .shinchan-docs/
  If found → use PROGRESS.md as plan source
  If not found → Ask: "Which plan file should I execute? (path to PROGRESS.md or plan file)"
  STOP and wait

If args is a file path:
  plan_source = args

If args is a task description:
  Generate micro-task plan inline (see Step 2)

Rubric Override Detection

After parsing args, check for a rubric: field (YAML-style or as part of a plan file frontmatter):

If args contains a `rubric:` field:
  rubric_override = parsed rubric definition
  Announce: "Custom rubric detected: {rubric_override item names}"
Else:
  rubric_override = null  (Action Kamen uses default 3-item rubric)

Step 2: Parse or Generate Micro-Task Plan

If plan_source exists (PROGRESS.md or plan file):

Read the plan and extract all phases. For each phase, break into micro-tasks:

Each micro-task MUST have:
- Title (what to do in 2-3 minutes)
- Files: Create/Modify/Test (exact paths)
- Steps: 2-5 concrete steps
- Verification: command + expected output

If no plan exists (args is a task description):

Task(subagent_type="team-shinchan:nene", model="opus",
  prompt=`Create a MICRO-TASK PLAN for the following request.

## Micro-Task Plan Format

Break the work into tasks that each take 2-3 minutes. Each task MUST follow this format:

### Task N: [Component Name]

**Files:**
- Create: exact/path/to/file
- Modify: exact/path/to/existing.py:line_range
- Test: tests/exact/path/to/test.py

**Step 1: [Action]**
[Complete code or exact instructions]

**Step 2: Verify**
Run: [exact command]
Expected: [exact expected output or behavior]

**Step 3: Commit** (optional)
git add [files] && git commit -m "[message]"

## Rules
- Each task is ONE focused change (2-3 minutes of work)
- Exact file paths always (no "add a file somewhere")
- Complete code in plan (not "add validation" but the actual code)
- Exact verification commands with expected output
- Assume the implementer has NO project context
- Order tasks by dependency (later tasks may depend on earlier ones)

User request: ${args}`)

Store result as {micro_plan}.

Step 2.5: Determine Model Tier per Task

Before execution, score each micro-task with collaboration-score.js and assign a model tier.

For EACH micro-task in the plan:

score_result = node ${CLAUDE_PLUGIN_ROOT}/src/collaboration-score.js \
  --task "{task.title}" \
  --files {len(task.files)} \
  --domains {task.domain_count || 1}

Parse JSON output → output.model_tier
Validate: model_tier must be one of ['haiku', 'sonnet', 'opus']
If unknown value: fallback to 'sonnet'
Store as task.model

Example output from collaboration-score.js:

{ "score": 45, "mode": "delegate", "model_tier": "sonnet", ... }

After scoring all tasks, announce the plan:

Model tier assignment:
  Task 1: {title} → {task.model} (score: {score})
  Task 2: {title} → {task.model} (score: {score})
  ...

Step 3: Execute Micro-Tasks

For EACH micro-task, sequentially (never parallel for implementation):

3a. Dispatch Implementer

Task(
  subagent_type="team-shinchan:{domain_agent}",  // Bo | Aichan | Bunta | Masao
  model="{task.model}",  // haiku | sonnet | opus — set in Step 2.5 via collaboration-score.js
  prompt=`You are implementing a SINGLE micro-task.

## Prompt Template
// See: ${CLAUDE_PLUGIN_ROOT}/agents/_shared/micro-task-prompts/implementer-prompt.md

## Your Task
${task_description}

## Files
${file_list}

## Context
- Project: ${project_context}
- Completed tasks: ${completed_tasks_summary}

## Protocol
1. Read ALL listed files first
2. State what you will change (1-2 sentences)
3. Implement EXACTLY what is specified
4. Run verification command
5. Self-review: Did I implement exactly what was asked?
6. Report: changes, verification result, concerns

## Iron Law
NO COMPLETION CLAIMS WITHOUT RUNNING THE VERIFICATION COMMAND.

## Anti-Rationalizations
- "Test is trivial, skip it" → Run it anyway
- "I'll also fix this nearby issue" → Out of scope
- "This approach is better" → Follow the spec, raise concerns`)

Store result as {implementer_report}.

3b. Dispatch Spec Reviewer

Task(
  subagent_type="team-shinchan:actionkamen",
  model="opus",
  prompt=`You are a SPEC COMPLIANCE REVIEWER for a micro-task.

## Prompt Template
// See: ${CLAUDE_PLUGIN_ROOT}/agents/_shared/micro-task-prompts/spec-reviewer-prompt.md

## The Original Spec
${task_description}

## Expected File Changes
${file_list}

## Rubric Override (optional)
${rubric_override || '(none — use default 3-item rubric from actionkamen.md)'}

## Implementer Report
${implementer_report}

## YOUR MISSION
DO NOT TRUST THE REPORT. The implementer may have:
- Finished suspiciously quickly
- Reported success without testing
- Misunderstood the spec
- Added or missed functionality

You MUST independently verify by READING THE ACTUAL CODE.

## Checklist
1. Completeness: Every spec requirement implemented?
2. Correctness: Matches spec exactly (not "close enough")?
3. Scope: No EXTRA functionality beyond spec?
4. Verification: Was the command actually run? Output matches?

## Output
- Verdict: PASS or FAIL
- Completeness: N/total requirements met
- Issues (if FAIL): what's wrong, spec says X, code does Y, file:line`)

If FAIL: Re-dispatch implementer with spec reviewer's issues → re-run spec review. Max 2 retry loops.

3c. Dispatch Code Quality Reviewer

Only after spec compliance PASS.

Task(
  subagent_type="team-shinchan:actionkamen",
  model="opus",
  prompt=`You are a CODE QUALITY REVIEWER. Spec compliance already PASSED.

## Prompt Template
// See: ${CLAUDE_PLUGIN_ROOT}/agents/_shared/micro-task-prompts/code-quality-reviewer-prompt.md

## Task Context
${task_description}

## Changed Files
${changed_files}

## Rubric Override (optional)
${rubric_override || '(none — use default 3-item rubric from actionkamen.md)'}

## Focus (NOT checking if right thing was built — only if built WELL)
1. Code Quality: naming, DRY, focused functions, error handling
2. Pattern Compliance: follows project conventions?
3. Security: injection, validation, secrets?
4. Testability: covers behavior, not flaky, readable?
5. Maintainability: understandable by new developer?

## Severity
- CRITICAL: Must fix (security, data loss, correctness)
- IMPORTANT: Should fix (quality, tests)
- MINOR: Nice to have (style)

## Output
- Verdict: APPROVED or NEEDS_FIXES
- Strengths: [at least one]
- Issues: [severity] description — file:line
- Assessment: Ready to merge? Yes / Yes with fixes / No`)

If NEEDS_FIXES with CRITICAL issues: Re-dispatch implementer → re-run quality review. Max 1 retry.

3d. Mark Task Complete

After both reviews pass:

1. Update PROGRESS.md (if in workflow) with task status
2. Log completion
3. Output to user:

━━━━━━━━━━━━━━━━━━━━
✅ Task {N}/{total}: {title}
  Spec: PASS | Quality: APPROVED
  Files: {changed_files}
━━━━━━━━━━━━━━━━━━━━

4. Move to next task

Step 4: Final Review

After ALL micro-tasks complete:

Task(
  subagent_type="team-shinchan:actionkamen",
  model="opus",
  prompt=`FINAL REVIEW of entire implementation.

All ${total_tasks} micro-tasks passed individual reviews.
Now verify the WHOLE implementation works together.

## Check
1. All tests pass (run full test suite)
2. No integration issues between tasks
3. No duplicate code across tasks
4. Overall architecture is coherent

## Changed Files (all tasks combined)
${all_changed_files}

## Output
- Overall Verdict: APPROVED / NEEDS_FIXES
- Integration Issues: [any cross-task problems]
- Test Results: [full suite output]`)

Step 5: Complete

Output final summary:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
👦 [Shinnosuke] Micro-Execute Complete
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📊 {total_tasks} tasks | {total_reviews} reviews
✅ All spec compliance checks passed
✅ All code quality checks passed
✅ Final integration review passed

📝 Files changed:
{file_summary}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

---

Agent Routing Table

Domain	Agent	Model
General code	Bo	collaboration-score model_tier
Frontend/UI/CSS	Aichan	collaboration-score model_tier
Backend/API/DB	Bunta	collaboration-score model_tier
DevOps/CI/Docker	Masao	collaboration-score model_tier
All reviews	Action Kamen	opus (fixed)
Plan generation	Nene	opus (fixed)

Execution Rules

1. Sequential tasks: Implementation tasks run one at a time (no parallel). Review subagents for each task also run sequentially.
2. Fresh subagent per task: Each task gets a new subagent. No context pollution.
3. Controller provides full context: The controller reads the plan once and provides full task text to each subagent. Subagents never read the plan file.
4. Two-stage review: Spec compliance BEFORE code quality. Never skip.
5. Retry limits: Max 2 retries for spec compliance, max 1 retry for code quality. If still failing, report to user and pause.
6. Evidence required: No "should work" or "looks correct". Every claim needs a verification command output.