validate

/validate — Canonical Validator Skill

Role: validator. Input = artifact (plan, spec, code, PR, fitness gate). Output = verdict.v1 (PASS / WARN / FAIL with rationale + findings).

Status (2026-05-08): introduced ADDITIVE in Phase 1 (m6v5.D.1 / soc-78s2v). Existing validators (council/vibe/pre-mortem/red-team/pr-validate/validation/review/scenario) stay until Phase 2 shim conversion (m6v5.D.2). Fix-C smoke (soc-wb2aa) gates Phase 2.

/validate is a driving adapter for the validate_acceptance port in the [Intent-to-Loop Hexagon](../../docs/architecture/intent-to-loop-hexagon.md). When the artifact contains a hexagon: block, preserve the bounded context, context packet, guard adapters, and done state in the verdict. When the artifact claims DONE/closed/green, apply the [Completion-Claim Kernel](../shared/validation-contract.md#completion-claim-kernel) before returning PASS.

Modes (≤8 per Fix-F mode-flag budget)

| Mode | Purpose | Replaces (post-Phase 2) | |---|---|---| | (default) | 2-judge multi-judge consensus on any artifact | /council default | | --quick | Inline single-agent structured review | /council --quick | | --deep | 4-judge thorough review | /council --deep | | --mixed | Cross-vendor (Claude + Codex), N×2 judges | /council --mixed | | --debate | Adversarial 2-round refinement | /council --debate, /red-team | | --mode=post-impl | Code-readiness pipeline (complexity → bug-hunt → council) | /vibe | | --mode=pre-impl [--target=X] | Plan/spec validation; target ∈ {scenario,fitness,ratchet,scope,skill,health} | /pre-mortem, /scenario, /goals measure, /ratchet, /scope, /skill-auditor, ao doctor | | --mode=pr | PR-shape verdict (diff review + acceptance check) | /pr-validate, /review |

Mode-budget assertion: 8 modes. Adding a 9th requires demoting an existing one OR refusing the addition (per Fix-F § continuous CI gate).

Quick Start

/validate path/to/plan.md                  # default 2-judge consensus
/validate --quick path/to/plan.md          # inline single-agent
/validate --deep path/to/spec.md           # 4-judge thorough
/validate --mode=pre-impl path/to/plan.md  # pre-mortem mode
/validate --mode=post-impl recent          # vibe mode (post-implement)
/validate --mode=pr 123                    # PR review by PR number
/validate --mode=pre-impl --target=fitness # fitness gate against GOALS.md

Default uses runtime-native subagent spawning. Falls back to --quick (inline) when no multi-agent capability detected.

Execution

Step 1: Resolve mode + target

Parse --mode and --target. Default mode is multi-judge. Validate combinations:

| Mode | Allowed --target | |---|---| | default, --quick, --deep, --mixed, --debate | n/a | | --mode=post-impl | n/a (pipeline scope is recent code changes) | | --mode=pre-impl | scenario, fitness, ratchet, scope, skill, health (default: pre-mortem on plan) | | --mode=pr | n/a (PR ID/path is positional) |

Reject invalid combinations (e.g., --mode=pr --target=fitness).

Step 2: Load artifact + context

# resolve artifact:
ARTIFACT="${1:-recent}"  # path, PR ID, or "recent"

# load FAIL patterns:
# (folded into skill body; not a separate hook)

For --mode=pre-impl, also load:

• .agents/planning-rules/*.md (compiled planning rules)
• .agents/findings/registry.jsonl (active findings)
• .agents/pre-mortem-checks/*.md (compiled prevention)

For --mode=post-impl, run pre-checks:

• complexity audit (radon for python, gocyclo for go)
• bug-hunt sweep (skill-body convention; no /bug-hunt skill needed)

For --mode=pr, fetch the PR diff (gh pr diff <id> or path).

Step 3: Determine spawn backend

1. spawn_agent available → Codex sub-agent
2. TeamCreate available → Claude native team
3. task (read-only skill tool, OpenCode) → opencode subagent
4. None → fall back to --quick (inline single-agent)

Log selected backend in the verdict frontmatter.

Step 4: Run judges

| Mode | Judges | Perspectives | |---|---|---| | default | 2 | independent (no labeled perspectives) | | --deep | 4 | missing-requirements, feasibility, scope, spec-completeness | | --mixed | 2N (default N=3) | same N perspectives across Claude + Codex | | --debate | 2+ rounds | adversarial; 2 rounds with critique-rebuttal | | --quick | 0 (inline self) | structured review | | --mode=post-impl | 2 + pipeline | complexity → bug-hunt → 2-judge council | | --mode=pre-impl | 2-4 | per target preset | | --mode=pr | 2 | diff-review + acceptance-check |

Each judge gets:

• artifact path
• relevant context (planning rules, findings)
• council FAIL pattern check prompt (top 8)
• temporal interrogation prompt (--deep + --target=plan)

Step 5: Mandatory checks (auto-trigger)

For --mode=pre-impl --target=plan:

• temporal interrogation (auto for plans with 5+ files or 3+ deps)
• error & rescue map
• council FAIL pattern check (top 8)
• test pyramid coverage check
• input validation check (enum-like fields)

For --mode=post-impl:

• L0/L1/L2 coverage check on changed files

For --mode=pre-impl --target=fitness:

• read GOALS.md
• evaluate each gate against current state
• report PASS/WARN/FAIL per gate + aggregate

Step 6: Consolidate to verdict

Each judge returns a per-judge result. Consolidate:

• PASS only if all judges PASS (or majority for --deep)
• WARN if any judge raises a warning the others don't dispute
• FAIL if any judge raises a blocker the others don't override

Step 7: Write verdict

Output path: .agents/council/YYYY-MM-DD-validate-<topic-slug>.md

---
id: validate-YYYY-MM-DD-<slug>
type: verdict
date: YYYY-MM-DD
mode: <mode>
target: <target or n/a>
artifact: <path>
backend: <codex-subagents | claude-teams | opencode | inline>
---

# Validate Verdict — <topic>

## Council Verdict: PASS / WARN / FAIL

| Failure mode | Risk | Severity | Addressed? |
|---|---|---|---|
| ... | ... | ... | ... |

## Pseudocode Fixes (when WARN/FAIL)
(copy-pastable into affected issues per pre-mortem 4.6 contract)

## FAIL Pattern Check
(top 8 patterns — status per pattern)

## Verdict
PASS — proceed
WARN — review concerns, accept risk, or apply fixes
FAIL — block; revise artifact and rerun

The exact heading ## Council Verdict: PASS / WARN / FAIL is mandatory — ao rpi phased (when present) parses with anchored regex.

Step 8: Persist findings (when applicable)

For --mode=pre-impl reusable findings: append to .agents/findings/registry.jsonl (atomic temp+rename).

Step 9: Report

1. Verdict (PASS/WARN/FAIL).
2. Key concerns (when not PASS).
3. Output path.
4. Recommended next action.

--target taxonomy (pre-impl)

| --target | What gets graded | Replaces | |---|---|---| | (default) | Plan/spec for an upcoming /implement | /pre-mortem | | scenario | Holdout scenario gate | /scenario | | fitness | GOALS.md fitness gates | /goals measure, ao goals measure | | ratchet | Brownian Ratchet checkpoint | /ratchet, ao ratchet status | | scope | Frozen-dirs declaration | /scope | | skill | SKILL.md hygiene + audit | /skill-auditor, /heal-skill (audit half) | | health | Repo health probe | ao doctor |

Each target has its own inline check rubric until Phase 2 extraction.

Constraints (one-role-per-skill)

• One role: validator. Output is always a verdict. Never mutates code (delegates to /implement for fixes).
• No new modes without dropping/merging an existing one (Fix-F mode-budget cap = 8).
• Verdict heading is regex-anchored — do not alter the ## Council Verdict: ... text format.

See Also

• skills/rpi/SKILL.md — orchestrator that fires /validate --mode=pre-impl after /plan
• skills/curate/SKILL.md — miner role (paired canonical skill)
• schemas/verdict.v1.schema.json — output contract

Reference Documents

• [references/validate.feature](references/validate.feature) — Executable spec: verdict.v1 PASS/WARN/FAIL for any artifa