Initial commit

This commit is contained in:
Zhongwei Li
2025-11-29 18:09:26 +08:00
commit 71330f5583
76 changed files with 15081 additions and 0 deletions

254
commands/verify.md Normal file
View File

@@ -0,0 +1,254 @@
# Verify
Generic dual-verification dispatcher for high-confidence verification across all verification types.
**Core principle:** Agents cannot be trusted. Two independent agents + systematic collation = confidence.
## Usage
```
/cipherpowers:verify <type> [scope] [--model=<sonnet|opus|haiku>]
```
**Model guidance:**
- `opus` - Deep analysis, security-critical verification, complex codebases
- `sonnet` - Balanced quality/speed (default for most verification types)
- `haiku` - Quick checks, simple verifications, execute adherence checks
## Algorithmic Workflow
**Decision tree (follow exactly, no interpretation):**
1. What verification type is requested?
- code → Dispatch to code verification workflow
- plan → Dispatch to plan verification workflow
- execute → Dispatch to execute verification workflow
- research → Dispatch to research verification workflow
- docs → Dispatch to documentation verification workflow
- OTHER → Error: Unknown verification type. Valid types: code, plan, execute, research, docs
2. **MANDATORY: Skill Activation**
**Load skill context:**
@${CLAUDE_PLUGIN_ROOT}skills/dual-verification/SKILL.md
**Step 1 - EVALUATE:** State YES/NO for skill activation:
- Skill: "cipherpowers:dual-verification"
- Applies to this task: YES/NO (reason)
**Step 2 - ACTIVATE:** If YES, use Skill tool NOW:
```
Skill(skill: "cipherpowers:dual-verification")
```
⚠️ Do NOT proceed without completing skill evaluation and activation.
3. **FOLLOW THE SKILL EXACTLY:**
- Phase 1: Dispatch 2 specialized agents in parallel (see dispatch table)
- Phase 2: Dispatch review-collation-agent to compare findings
- Phase 3: Present collated findings to user with confidence levels
4. **STOP when verification is complete.**
## Dispatch Table
| Type | Agent | Focus | Default Model |
|------|-------|-------|---------------|
| code | cipherpowers:code-review-agent + cipherpowers:code-agent | Heterogeneous review (Standards + Engineering) | sonnet |
| plan | cipherpowers:plan-review-agent + cipherpowers:code-agent | Plan quality + Technical feasibility | sonnet |
| execute | cipherpowers:execute-review-agent ×2 | Plan adherence, implementation match | haiku |
| research | cipherpowers:research-agent ×2 | Information completeness, accuracy | sonnet |
| docs | cipherpowers:technical-writer + cipherpowers:code-agent | Docs structure + Code example accuracy | haiku |
**Model parameter rules:**
- If user specified `--model=X` → pass `model: X` to ALL dispatched agents
- If no model specified → use default model from table above
- Collation agent always uses `haiku` (simple comparison task)
## Verification Types
### Code Verification
**When to use:** Before merging, after significant implementation.
**What it checks:**
- Code quality and standards compliance
- Testing coverage and quality
- Security considerations
- Performance implications
- Maintainability
**Workflow:**
```
/verify code [scope] [--model=<sonnet|opus|haiku>]
→ Dispatches 1 code-review-agent and 1 code-agent in parallel
(with model parameter if specified, otherwise sonnet)
→ Each agent independently reviews:
- Read code changes
- Run tests and checks
- Review against standards
→ Dispatches review-collation-agent (always haiku)
→ Produces collated report with confidence levels
```
### Plan Verification
**When to use:** Before executing implementation plans.
**What it checks:**
- 35 quality criteria (security, testing, architecture, etc.)
- Blocking issues that must be fixed
- Non-blocking improvements to consider
**Workflow:**
```
/verify plan [plan-file] [--model=<sonnet|opus|haiku>]
→ Dispatches 1 plan-review-agent and 1 code-agent in parallel
(with model parameter if specified, otherwise sonnet)
→ Each agent independently evaluates against criteria
→ Dispatches review-collation-agent (always haiku)
→ Produces collated report with confidence levels
```
### Execute Verification
**When to use:** After each batch during /execute workflow.
**What it checks:**
- Each task implemented exactly as plan specified
- No skipped requirements
- No unauthorized deviations
- No incomplete implementations
**What it does NOT check:**
- Code quality (that's code verification)
- Testing strategy (that's code verification)
- Standards compliance (that's code verification)
**Workflow:**
```
/verify execute [batch-number] [plan-file] [--model=<sonnet|opus|haiku>]
→ Dispatches 2 execute-review-agent agents in parallel
(with model parameter if specified, otherwise haiku)
→ Each agent independently verifies:
- Read plan tasks for batch
- Read implementation changes
- Verify each task: COMPLETE / INCOMPLETE / DEVIATED
→ Dispatches review-collation-agent (always haiku)
→ Produces collated report with confidence levels
```
### Research Verification
**When to use:** When exploring unfamiliar topics, APIs, patterns, or codebases.
**What it checks:**
- Information completeness (did we find everything relevant?)
- Accuracy (are findings correct?)
- Multiple perspectives (different angles covered?)
- Gaps identified (what's missing?)
**Examples:**
- "How does authentication work in this codebase?"
- "What are the patterns for Bevy 0.17 picking?"
- "How should we structure the API layer?"
**Workflow:**
```
/verify research [topic] [--model=<sonnet|opus|haiku>]
→ Dispatches 2 research-agent agents in parallel
(with model parameter if specified, otherwise sonnet)
→ Each agent independently explores:
- Different entry points
- Multiple sources (codebase, web, docs)
- Different perspectives
→ Dispatches review-collation-agent (always haiku)
→ Produces collated report:
- Common findings (high confidence)
- Unique insights (worth knowing)
- Divergences (needs clarification)
```
### Documentation Verification
**When to use:** Auditing documentation accuracy.
**What it checks:**
- File paths exist
- Commands work
- Examples accurate
- Structure complete
**Workflow:**
```
/verify docs [files] [--model=<sonnet|opus|haiku>]
→ Dispatches 1 technical-writer and 1 code-agent in parallel
(with model parameter if specified, otherwise haiku)
→ Each agent independently verifies against codebase
→ Dispatches review-collation-agent (always haiku)
→ Produces collated report with confidence levels
```
## Why Dual Verification?
**Problem:** Single agent can miss issues, hallucinate, or confirm biases.
**Solution:** Two independent agents catch what one misses.
**Confidence levels:**
- **VERY HIGH:** Both agents found → Act on this
- **MODERATE:** One agent found → Consider carefully
- **INVESTIGATE:** Agents disagree → User decides
**Example (research):**
```
Agent #1: "Auth uses JWT with 1-hour expiry"
Agent #2: "Auth uses JWT with 24-hour refresh tokens"
→ Collation: Both partially correct (access vs refresh)
→ Higher confidence understanding than single agent
```
## Integration with Other Commands
Execute workflow uses verify for batch verification:
```
/execute workflow:
→ Batch 1 (3 tasks)
→ /verify code (quality/standards)
→ /verify execute (plan adherence)
→ Fix all BLOCKING issues
→ Repeat for next batch
```
## Related Commands
- `/cipherpowers:execute` - Plan execution workflow (uses /cipherpowers:verify for batch verification)
## Related Skills
- `dual-verification` - Core pattern for all dual-verification
- `executing-plans` - Plan execution workflow integrating verification
## Related Agents
- `code-review-agent` & `code-agent` - Code quality verification
- `plan-review-agent` & `code-agent` - Plan quality verification
- `execute-review-agent` - Plan adherence verification
- `research-agent` - Research verification
- `technical-writer` & `code-agent` - Documentation verification
- `review-collation-agent` - Generic collation (works for all types)
## Remember
- All verification types use dual-verification pattern
- Dispatch table determines which agents to use
- Collation agent is always the same (generic)
- Confidence levels guide user decisions
- Agents cannot be trusted - that's why we use two