Use when recursive-mode work may benefit from delegated audit, review, or bounded implementation support. This skill prioritizes phase-auditor, traceability-auditor, code-reviewer, memory-auditor, and test-reviewer roles, with mandatory self-audit fallback when subagents are unavailable.
Instalación
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Use when recursive-mode work may benefit from delegated audit, review, or bounded implementation support. This skill prioritizes phase-auditor, traceability-auditor, code-reviewer, memory-auditor, and test-reviewer roles, with mandatory self-audit fallback when subagents are unavailable.
recursive-subagent
Use this skill to decide whether subagents help a recursive-mode phase and to enforce the handoff contract when they do.
This skill does not relax the canonical workflow. The main agent remains responsible for:
one active recursive phase at a time
full audit rigor before lock
rejecting incomplete or context-free subagent output
falling back to self-audit when subagents are unavailable
Priority Of Use
Use subagents in this order of value:
phase auditor
traceability auditor
code reviewer
memory auditor
test reviewer
bounded implementer for truly disjoint write scopes
Do not treat subagents as required infrastructure. They are optional infrastructure, but delegated audit/review is the preferred default when subagents are available and the context bundle is complete.
Capability Detection Is A Hard Control Point
At the start of a phase where delegation is being considered, determine whether the environment actually supports subagents/tasks.
If subagents are unavailable:
record Subagent Availability: unavailable
record Audit Execution Mode: self-audit
perform the same audit locally
If subagents are available:
record Subagent Availability: available
delegate by default for audit/review work when the context bundle is complete
if the controller still chooses self-audit, record a concrete Delegation Override Reason
keep the same audit checklist and acceptance standard
Before delegating, read /.recursive/memory/skills/SKILLS.md plus the relevant skill-memory shards for delegated review, review-bundle fit, and stale-context risks.
Never skip or weaken an audit because delegation is unavailable.
Canonical Constraints
Recursive phases stay sequential. There is exactly one active phase per run.
Subagents may help inside the active phase; they do not authorize parallel phase work.
Parallel write-capable implementation is allowed only for explicitly independent sub-phases with disjoint write scopes and no blocking dependency chain.
Audit, review, and read-only verification are the safest default delegation modes.
Delegated Audit Contract
A delegated audit is valid only when the controller passes a complete context bundle. Prefer a canonical review bundle file under /.recursive/run/<run-id>/evidence/review-bundles/ so the handoff is durable and repeatable.
The controller must pass all of:
phase name and artifact path
current phase draft
exact upstream artifact paths that must be reread
relevant addendum paths
relevant prior recursive evidence and memory refs
diff basis from 00-worktree.md
changed file list
targeted code file paths or file groups to inspect
relevant control-plane docs when needed
exact audit questions/checklist for the phase
required output shape including findings and verdict
Vague delegation such as "review this phase" or "audit implementation" is invalid.
If any required item is missing, do not delegate. Perform the audit yourself.
If repairs materially change reviewed scope, changed files, or evidence, refresh the bundle before re-audit.
Controller Checklist
Before dispatch:
Confirm delegation is optional, not required
Confirm the phase is still the single active phase
Confirm the handoff bundle is complete
Confirm the canonical review bundle path exists when delegation is being recorded in a phase artifact
Confirm a durable subagent action record will be written under /.recursive/run/<run-id>/subagents/
Confirm the target subagent role matches the task
Confirm write scopes are disjoint before any write-capable delegation
Before accepting a result:
Verify the subagent read the named upstream artifacts
Verify the subagent read the review bundle or its full equivalent
Verify the subagent returned enough detail to populate the action record fields
Verify Current Artifact points at a stable reviewed artifact or refresh the record after any material draft edits
Verify the output cites the diff basis and changed files
Verify the bundle still matches the current artifact hash after any repairs
Verify the output contains concrete findings or an explicit no-findings conclusion
Verify the output includes requirement/plan alignment comments where relevant
Verify the output ends with a clear verdict
Verify any claimed file impact, artifact impact, or findings against the actual worktree diff, actual artifacts, and earlier locked recursive docs before acceptance
Verify the phase artifact records Reviewed Action Records, Main-Agent Verification Performed, Acceptance Decision, Refresh Handling, and Repair Performed After Verification
Reject action records that leave claimed file impact or claimed artifact impact as none for materially contributing work
Reject the output if it is context-free, hand-wavy, or missing required checks
Recommended Roles
Phase Auditor
Use for audited phases that need an independent pass over:
current draft
upstream locked artifacts
git diff vs recorded baseline
requirement coverage
gaps, drift, and repair needs
Traceability Auditor
Use when checking that downstream artifacts explicitly cover every in-scope R# and do not hide behind vague summaries.
Code Reviewer
Use for Phase 3.5 or high-risk Phase 3/4 audits.
Expected checks:
requirements vs implementation
plan vs implementation
git diff vs claimed scope
code quality and maintainability
test adequacy and TDD compliance
Memory Auditor
Use in Phase 8 to verify that touched paths, memory status transitions, and router updates match the final validated repo state.
Test Reviewer
Use in Phase 4 to audit test adequacy, exact commands, evidence capture, and whether the implementation is truly complete before test results are trusted.
Implementer
Use only when Phase 2 defines truly independent sub-phases with concrete file ownership.
The controller must assign ownership explicitly and must not present this as broad "parallel mode" by default.
Handoff Template
Use this structure whenever you delegate an audit or review. Prefer generating the bundle with recursive-review-bundle and then passing the bundle path plus any phase-specific instructions:
Review Bundle Path: `/.recursive/run/<run-id>/evidence/review-bundles/<bundle>.md`
Phase: `03.5 Code Review`
Artifact path: `/.recursive/run/<run-id>/03.5-code-review.md`
Role: `phase-auditor`
Audit execution expectation: return findings plus `Audit: PASS` or `Audit: FAIL`
Bundle freshness check:
- confirm changed files, evidence refs, and audit questions still match the latest repaired draft
- confirm relevant addenda are included; do not hand-wave plan or requirement amendments that live in addenda
Additional audit questions:
- Which `R#` are still incomplete?
- Which changed files drift from the plan?
- Is required evidence missing?
- Is repair required before lock?
Action-record expectation:
- return enough structured detail for `recursive-subagent-action`- prefer the stable reviewed artifact for `Current Artifact` when recording review/audit work
- cite upstream artifacts reread, relevant addenda, prior recursive evidence, changed files or code refs reviewed, claimed findings, and verification handoff items
Self-Audit Fallback Pattern
When subagents are unavailable, reuse the same checklist in the phase artifact and record:
