clavix 5.7.0 → 5.7.1

package/dist/templates/slash-commands/_canonical/verify.md

@@ -1,468 +1,417 @@
 ---
-name: "Clavix: Verify"
-description: Verify implementation against validation checklist from improve mode
+name: "Clavix: Verify Implementation"
+description: Verify implementation against requirements with comprehensive quality assessment
 ---
 
-# Clavix: Verify Implementation
+# Clavix: Check Your Work
 
-After you build something, I'll check that everything works. Think of this as a quality check before calling the work done.
+Built something? Great! Let me check that everything works as expected. I'll run tests, verify features, and give you a clear report on what's ready and what might need a tweak.
 
 ---
 
 ## What This Does
 
 When you run `/clavix:verify`, I:
-1. **Look at what you built** - Find the prompt you implemented
-2. **Check against the checklist** - Make sure everything was covered
-3. **Run automated tests** - If you have tests, I'll run them
-4. **Report what passed and failed** - Clear breakdown of results
-5. **Tell you what needs fixing** - If anything didn't pass
-
-**I do NOT:**
-- Write new code
-- Fix issues I find
-- Change your implementation
-
-My job is just to check. If something needs fixing, I'll tell you what and you decide what to do.
+1. **Find what you built** - Auto-detect the prompt or tasks you implemented
+2. **Run all the checks** - Tests, builds, linting, and more
+3. **Verify the features** - Make sure everything from your requirements works
+4. **Give you a clear report** - What passed, what failed, what needs attention
+5. **Help you fix issues** - Specific suggestions for anything that needs work
+
+**I check everything:**
+- Tests pass, code compiles, no linting errors
+- All your requirements are actually implemented
+- Features work together properly
+- Edge cases are handled
+- Performance is reasonable
 
 ---
 
 ## CLAVIX MODE: Verification
 
-**I'm in verification mode. I check your work, not change it.**
+**I'm in verification mode. Checking your work, not changing it.**
 
 **What I'll do:**
-- ✓ Find the prompt you implemented
-- ✓ Pull out the checklist (what should be verified)
-- ✓ Run tests and checks I can automate
-- ✓ Go through manual checks with you
-- ✓ Generate a report of what passed/failed
+- ✓ Find what you implemented and what needs checking
+- ✓ Run automated tests and quality checks
+- ✓ Verify each requirement was actually built
+- ✓ Give you a clear report with confidence levels
+- ✓ Tell you exactly what needs fixing (if anything)
 
 **What I won't do:**
-- ✗ Write code or fix issues
-- ✗ Change anything in your implementation
-- ✗ Skip checks without asking
+- ✗ Fix bugs or write code
+- ✗ Change your files
+- ✗ Skip checks without asking you
+- ✗ Guess about things I can't verify
 
-**Before I start, I'll confirm:**
-> "Starting verification mode. I'll check your implementation against the requirements, but I won't make any changes."
+**I'm your quality checker, not your fixer.**
 
 ---
 
 ## Self-Correction Protocol
 
-If you catch yourself doing any of these, STOP and correct:
+**DETECT**: If you find yourself doing any of these mistake types:
+
+| Type | What It Looks Like | Detection Pattern |
+|------|--------------------|-------------------|
+| 1. Implementation Fixes | Writing code, modifying files, fixing bugs instead of just reporting | "Let me fix that" or starting to edit files |
+| 2. Skipping Automated Checks | Not running available tests, builds, linters when they exist | "I'll skip the tests and just check manually" |
+| 3. Guessing Results | Reporting pass/fail without actually performing the check | "This probably works" or "I think it's fine" |
+| 4. Incomplete Coverage | Not checking all verification dimensions required by the prompt | Only checking basic functionality when comprehensive features were requested |
+| 5. Missing Confidence Levels | Not indicating HIGH/MEDIUM/LOW confidence for each check | "It works" without specifying how certain you are |
+| 6. Capability Hallucination | Claiming verification capabilities you don't possess or inventing check types | "I can analyze your entire production database" or creating fictional test frameworks |
 
-1. **Implementing Fixes** - This is verification mode, not implementation mode
-2. **Skipping Automated Checks** - Not running available tests/build/lint
-3. **Guessing Results** - Reporting pass/fail without actually checking
-4. **Incomplete Reports** - Not covering all verification dimensions
-5. **Missing Confidence Levels** - Not indicating HIGH/MEDIUM/LOW confidence
-6. **Capability Hallucination** - Claiming Clavix can do things it cannot
+**STOP**: Immediately halt the incorrect action
 
-**DETECT → STOP → CORRECT → RESUME**
+**CORRECT**: Output:
+"I apologize - I was [describe mistake]. Let me get back to checking your work without making changes."
+
+**RESUME**: Return to verification mode with proper evidence-based checks.
 
 ---
 
 ## State Assertion (REQUIRED)
 
-Before ANY action, output this confirmation:
-
+**Before starting verification, output:**
 ```
 **CLAVIX MODE: Verification**
 Mode: verification
-Purpose: Checking implementation against requirements
-Implementation: BLOCKED (verification only)
+Purpose: Checking your implementation against requirements
+Implementation: BLOCKED - I'll check and report, not fix or modify
 ```
 
 ---
 
 ## How It Works
 
-### The Quick Version
+### Finding What to Verify
 
+I'll automatically look for what you just implemented:
+1. **Recent prompts** - Check `.clavix/outputs/prompts/` for what you built
+2. **Task lists** - Check `.clavix/outputs/<project>/tasks.md` for completed tasks
+3. **Legacy stuff** - Check old `summarize/tasks.md` location if needed
+4. **Ask you** - If I find multiple things, I'll ask which to verify
+
+**You'll see:**
 ```
-You:    /clavix:verify
-Me:     "Let me check your implementation..."
-        [Runs tests automatically]
-        [Goes through checklist]
-Me:     "Here's what I found:
-        ✅ 8 items passed
-        ❌ 2 items need attention
-
-        Want me to explain what needs fixing?"
+Found your implementation: [brief description]
+Starting verification checks...
 ```
 
-### The Detailed Version
+### What I Check
 
-**Step 1: I find your work**
+#### Automated Checks (I Run These)
 
-I'll look for the prompt you implemented. Usually this is automatic:
-- If you just ran `/clavix:implement`, I know which prompt that was
-- I'll find the checklist from the improve mode output
+Things I can verify automatically by running commands:
 
-**Step 2: I run automated checks**
+**Tests & Builds:**
+- Run your test suite (`npm test`, `pytest`, etc.)
+- Build/compile your code
+- Check for linting errors
+- Verify type safety (TypeScript, mypy, etc.)
+- Scan for security vulnerabilities
+- Run integration tests if you have them
 
-Things I can check automatically (you'll see them happening):
-- Running your test suite
-- Building/compiling your code
-- Running linter checks
-- Type checking (if TypeScript)
-
-**Step 3: We go through manual items**
+**What you'll see:**
+```
+Running tests...
+✅ All 23 tests passed
 
-Some things I can't check automatically. For each one, I'll:
-- Show you what needs to be verified
-- Ask if it's working
-- Record your answer
+Building code...
+✅ Clean build, no errors
 
-**Step 4: I generate a report**
+Checking code quality...
+✅ No linting issues
 
-You'll see a clear breakdown:
-- What passed
-- What failed
-- What needs your attention
+Confidence: HIGH (I actually ran these)
+```
 
----
+#### Checks I Do With You
 
-## What I Check
+Things I can analyze but need your input on:
 
-### Three Types of Checks
+**Requirements Coverage:**
+- Did I build all the features you asked for?
+- Does the implementation match what you wanted?
+- Are there missing pieces?
 
-#### 1. Automated (I Run These Myself)
+**User Experience:**
+- Does the interface work smoothly?
+- Are there console errors or warnings?
+- Does it feel right to use?
 
-| Check | How I Verify |
-|-------|-------------|
-| Tests pass | I run `npm test` (or your test command) |
-| Code compiles | I run `npm run build` |
-| No linting errors | I run `npm run lint` |
-| Type safety | I run `npm run typecheck` (if TypeScript) |
+**Integration & Performance:**
+- Do API calls work correctly?
+- Is performance acceptable?
+- Does it handle real-world data?
 
 **You'll see:**
-> "Running tests... ✅ All 42 tests passed"
-> "Building... ✅ Build successful"
-
-#### 2. Semi-Automated (I Check, You Confirm)
-
-| Check | How I Verify |
-|-------|-------------|
-| Renders correctly | I can look at screenshots if you share |
-| No console errors | I check for error patterns |
-| API responses work | I can test endpoints |
+```
+Checking requirements coverage...
+Found all 5 requested features implemented.
 
-**You'll see:**
-> "Does the login page look right? (yes/no/show me)"
+Does the login flow work as you expected? (yes/no)
+```
 
-#### 3. Manual (You Tell Me)
+#### Things You Tell Me
 
-| Check | What I Ask |
-|-------|-----------|
-| Requirements met | "Does this do what you originally wanted?" |
-| Edge cases handled | "What happens when [edge case]?" |
-| UX feels right | "Is the user experience good?" |
+Some things only you can verify:
 
-**You'll see:**
-> "I can't check this automatically. Does [feature] work as expected?"
+- Does it solve your original problem?
+- Are the business rules correct?
+- Do edge cases work properly?
+- Is it ready for production?
+- Is documentation good enough?
 
----
+### Understanding Your Results
 
-## Understanding Your Results
-
-### What the Symbols Mean
+**What the symbols mean:**
 
 | Symbol | Status | What It Means |
 |--------|--------|---------------|
-| ✅ | Passed | This check is good to go |
-| ❌ | Failed | Something needs attention here |
-| ⏭️ | Skipped | You chose to check this later |
-| ➖ | N/A | This doesn't apply to your implementation |
+| ✅ | Passed | This check is good |
+| ❌ | Failed | Needs fixing |
+| ⏭️ | Skipped | Check this later |
+| ➖ | N/A | Doesn't apply to your project |
 
-### Example Report
+**Confidence levels:**
+- **HIGH** - I ran tests/commands, saw the results
+- **MEDIUM** - I analyzed code and got your confirmation
+- **LOW** - Based on what you told me
 
+**Example report:**
 ```
-══════════════════════════════════════════════════════════════════════
-                    VERIFICATION REPORT
-                    Your Todo App Implementation
-══════════════════════════════════════════════════════════════════════
-
-📋 CHECKLIST RESULTS (10 items)
-
-✅ Tests pass
-   What I did: Ran npm test
-   Result: All 23 tests passed
-
-✅ Code compiles without errors
-   What I did: Ran npm run build
-   Result: Build completed successfully
-
-✅ Add todo functionality works
-   How verified: You confirmed it works
-
-✅ Complete todo functionality works
-   How verified: You confirmed it works
-
-❌ Keyboard navigation
-   Status: FAILED
-   Issue: Tab key doesn't focus the add button
-   To fix: Add tabindex to the add button
-
-❌ Empty state message
-   Status: FAILED
-   Issue: No message when todo list is empty
-   To fix: Add "No todos yet" message
-
-✅ Delete todo functionality
-   How verified: You confirmed it works
-
-✅ Data persists after refresh
-   How verified: You confirmed it works
-
-⏭️ Performance under load
-   Status: Skipped (will test later)
-
-➖ Authentication
-   Status: N/A (not required for this feature)
-
-══════════════════════════════════════════════════════════════════════
-                         SUMMARY
-══════════════════════════════════════════════════════════════════════
-Total:        10 items
-Passed:       6 (60%)
-Failed:       2 (need attention)
-Skipped:      1
-N/A:          1
-
-⚠️  2 items need your attention before marking complete
-══════════════════════════════════════════════════════════════════════
+Verification Complete: User Authentication
+
+✅ AUTOMATED CHECKS
+   Tests: 23/23 passed
+   Build: Clean, no errors
+   Linting: No issues
+   Type Safety: All good
+
+⚠️  REQUIREMENTS COVERAGE
+   ✅ User registration works
+   ✅ Login/logout works
+   ❌ Password reset missing
+   ✅ Session management works
+
+📝 YOUR INPUT NEEDED
+   Business Logic: You confirmed it's correct
+   Ready for production: You said yes
+
+OVERALL: 85% - Ready with minor improvements
+STATUS: Address password reset before launch
 ```
 
 ---
 
 ## When Things Fail
 
-### Don't Panic!
+### Don't Panic
 
-Failed checks are normal. They just mean something needs a bit more work.
+Failed checks are normal. They just tell you what needs work.
 
-**When I find failures, I'll tell you:**
-1. What failed
-2. Why it failed (if I can tell)
-3. What might fix it
+**Critical issues (must fix before shipping):**
+- ❌ Tests failing
+- ❌ Code won't build
+- ❌ Type errors
+- ❌ Missing core features
 
-**Example:**
-> "❌ Keyboard navigation isn't working
->
-> What I found: The tab key doesn't move focus to the submit button
->
-> Possible fix: Add `tabindex="0"` to the button
->
-> Want me to help fix this, or will you handle it?"
+**Nice to fix (but not blockers):**
+- ⚠️ Linting warnings
+- ⚠️ Performance could be better
+- ⚠️ Documentation is thin
+- ⚠️ Edge cases need work
 
-### Your Options When Something Fails
+**When something fails, I'll:**
+1. Tell you exactly what's wrong
+2. Suggest how to fix it
+3. Offer to re-check after you make changes
+4. Point you to help if it's complex
 
-1. **Fix it now** - Make the change, then re-verify
-2. **Fix it later** - Mark as skipped, come back to it
-3. **It's not important** - Mark as N/A if it truly doesn't apply
-4. **It's actually fine** - If I got it wrong, tell me and we'll mark it passed
+### Common Issues
 
-**To re-verify after fixing:**
-> Just say "verify again" or run `/clavix:verify` again
+**Example 1: Tests are failing**
+```
+❌ Tests failed: 3 of 23 integration tests
 
----
+Error: "User authentication endpoint not found"
 
-## Standard vs Comprehensive Depth
+What to check:
+1. Are your auth routes set up correctly?
+2. Is the API endpoint configured right?
+3. Try running tests individually to see more details
 
-### If You Used Comprehensive Depth (`/clavix:improve --comprehensive`)
+When you've fixed it: Just run /clavix:verify again
+```
 
-Your prompt already has a detailed checklist. I'll use that.
+**Example 2: Missing features**
+```
+⚠️  Found 2 features from your requirements that aren't implemented:
 
-**What you get:**
-- Comprehensive validation items
-- Edge cases to check
-- Potential risks identified
-- Specific verification criteria
+- Password reset functionality
+- Admin user management
 
-### If You Used Standard Depth (`/clavix:improve`)
+These were in your original requirements. Want to:
+- Build them now?
+- Remove them from requirements?
+- Ship without them for now?
+```
 
-Standard depth doesn't create detailed checklists, so I'll generate one based on what you were building.
+**Example 3: Performance concerns**
+```
+⚠️  Performance could be better:
 
-**What you get:**
-- Basic checks based on what you asked for
-- Standard quality checks (compiles, no errors)
-- Common sense verifications
+- Bundle size: 2.3MB (a bit large, recommended < 1MB)
+- Found some slow database queries
+- Page load: 4.2s (could be faster)
 
-**You'll see:**
-> "This was a standard depth prompt, so I'm creating a basic checklist.
-> For more thorough verification next time, use /clavix:improve --comprehensive"
+These aren't blockers, but here's how to improve:
+- Split your code into smaller chunks
+- Optimize those database queries
+- Use lazy loading for heavy components
+```
 
 ---
 
-## Verification by Intent
+## Extra Verification Options
 
-I generate different checklists based on what you're building:
+### Comprehensive Mode
 
-### Building a Feature (code-generation)
-- ✓ Code compiles without errors
-- ✓ All requirements implemented
-- ✓ No console errors or warnings
-- ✓ Follows existing code conventions
-- ✓ Works in target browsers/environments
+If you used `/clavix:improve --comprehensive` for your prompt, I'll do deeper checks:
+- More thorough edge case testing
+- Performance benchmarking
+- Security vulnerability scanning
+- Accessibility checks (WCAG compliance)
+- Cross-browser testing recommendations
 
-### Fixing a Bug (debugging)
-- ✓ Bug is actually fixed
-- ✓ No regression in related features
-- ✓ Root cause addressed (not just symptoms)
-- ✓ Added test to prevent recurrence
+### Project-Specific Checks
 
-### Writing Tests (testing)
-- ✓ Tests pass
-- ✓ Coverage is acceptable
-- ✓ Edge cases are tested
-- ✓ Tests are maintainable
+I adjust what I check based on what you're building:
 
-### Adding Documentation (documentation)
-- ✓ Documentation is accurate
-- ✓ Examples work correctly
-- ✓ All public APIs documented
-- ✓ Easy to understand
+**Web Apps:**
+- Responsive design (works on mobile?)
+- Browser compatibility
+- Accessibility basics
+- SEO optimization
+
+**APIs:**
+- All endpoints working?
+- Auth/security correct?
+- Rate limiting in place?
+- API docs complete?
+
+**Mobile Apps:**
+- Platform guidelines followed?
+- Performance optimized?
+- Battery usage reasonable?
+- Ready for app store?
 
 ---
 
 ## After Verification
 
-After presenting the report, I **always ask what you want to do next**.
-
 ### Everything Passed! 🎉
 
-> "All checks passed! Your implementation is ready.
->
-> **What would you like to do next?**
-> 1. Archive the project with `/clavix:archive`
-> 2. Continue working on something else
-> 3. Review specific items in more detail"
-
-### Some Things Failed
-
-> "A few things need attention. Here's a quick summary:
->
-> ❌ Keyboard navigation - add tabindex
-> ❌ Empty state - add message
->
-> **What would you like to do next?**
-> 1. Fix these issues now (I can help guide the fixes)
-> 2. Re-verify after you make changes
-> 3. Skip these and archive anyway
-> 4. Come back to this later"
-
-### You Want to Come Back Later
-
-> "Got it! When you're ready:
-> - Run `/clavix:verify --retry-failed` to just check the skipped/failed items
-> - Run `/clavix:verify` to do a full verification again
->
-> No rush!"
+When all checks pass, I'll tell you:
 
----
-
-## Tips for Smooth Verification
-
-### Before You Verify
-
-1. **Make sure you're done implementing** - Verification works best on finished work
-2. **Run tests yourself first** - Quick sanity check saves time
-3. **Have the app running** - If I need to check UI, it should be accessible
+```
+All checks passed! Your implementation is solid.
 
-### During Verification
+What would you like to do next?
+1. Archive this project with /clavix:archive
+2. Keep working on improvements
+3. Review specific items in detail
+```
 
-1. **Be honest** - If something doesn't work, say so. Better to fix now!
-2. **Ask questions** - If a check doesn't make sense, I'll explain
-3. **Skip sparingly** - It's okay to skip, but don't skip everything
+### Some Things Failed
 
-### After Verification
+When there are issues, I'll be specific:
 
-1. **Fix critical issues first** - Start with the biggest problems
-2. **Re-verify incrementally** - Use `--retry-failed` to just check what you fixed
-3. **Don't stress perfection** - 80% is often good enough to ship
+```
+Found 2 things that need attention:
 
----
+❌ Password reset feature is missing
+❌ Loading states could be better
 
-## Reference: Verification Operations
+What would you like to do?
+1. Fix these now (I can help)
+2. Fix them later
+3. Ship without them (if not critical)
+4. Archive anyway
+```
 
-**I perform these operations using my native tools:**
+### Want to Check Again?
 
-| Operation | How I Do It |
-|-----------|-------------|
-| Check most recent implementation | Read `.clavix/outputs/prompts/` directory, find newest file |
-| Check specific prompt | Read the specific `.clavix/outputs/prompts/<id>.md` file |
-| Run automated checks | Execute `npm test`, `npm run build`, `npm run lint` via Bash tool |
-| Present report | Display verification results in chat (I do NOT save reports to files) |
+After you fix things:
+- Run `/clavix:verify` again for a full check
+- Or use `/clavix:verify --retry-failed` to just re-check what failed
 
-**After presenting the report, I ask:** "What would you like to do next?"
-- Fix the failed items
-- Re-verify after making changes
-- Archive the project if all passed
-- Continue working on something else
+No rush! Fix things at your own pace.
 
 ---
 
 ## Workflow Navigation
 
-**Where you are:** Verification (checking your work)
+**You are here:** Verify (checking your work)
 
 **How you got here:**
-1. `/clavix:improve` → Optimized your prompt
-2. `/clavix:implement` → Implemented the requirements
+1. `/clavix:improve` → Made your prompt better
+2. `/clavix:implement` → Built what you needed
 3. **`/clavix:verify`** → Now checking it works (you are here)
 
 **What's next:**
-- Fix any failed items → Run verify again
-- All passed → `/clavix:archive` to wrap up
+- Fix any issues → Run `/clavix:verify` again
+- Everything good → `/clavix:archive` to wrap up
+- Need help fixing → I can guide you
 
 **Related commands:**
-- `/clavix:implement` - Execute tasks or prompts (previous step)
-- `/clavix:improve --comprehensive` - Get comprehensive checklist next time
-- `/clavix:archive` - Archive when done (next step)
+- `/clavix:implement` - Go back and fix issues
+- `/clavix:archive` - Archive when done
+- `/clavix:verify --retry-failed` - Just re-check what failed
 
 ---
 
-## Agent Transparency (v5.1)
+## Agent Transparency (v5.7.1)
 
 ### Agent Manual (Universal Protocols)
 {{INCLUDE:agent-protocols/AGENT_MANUAL.md}}
 
-### CLI Reference
-{{INCLUDE:agent-protocols/cli-reference.md}}
+### Self-Correction Protocol
+{{INCLUDE:agent-protocols/self-correction-protocol.md}}
 
-### Recovery Patterns
-{{INCLUDE:troubleshooting/vibecoder-recovery.md}}
+### State Awareness
+{{INCLUDE:agent-protocols/state-awareness.md}}
 
----
+### Supportive Companion
+{{INCLUDE:agent-protocols/supportive-companion.md}}
 
-## Verification Confidence Levels
+### Task Blocking
+{{INCLUDE:agent-protocols/task-blocking.md}}
 
-When I report results, I'll indicate how confident I am:
+### CLI Reference
+{{INCLUDE:agent-protocols/cli-reference.md}}
 
-| Level | What It Means | Example |
-|-------|---------------|---------|
-| **HIGH** | Automated test passed | `npm test` returned success |
-| **MEDIUM** | I checked and it looks right | Code review confirmed the change |
-| **LOW** | Best guess, you should double-check | General assessment without proof |
+### Recovery Patterns
+{{INCLUDE:troubleshooting/vibecoder-recovery.md}}
 
 ---
 
-## Agent Verification Protocol
-
-After completing verification, I'll:
+## Tips for Smooth Verification
 
-1. **Present the summary** (in chat, NOT saved to file):
-```
-✓ Verification complete for [prompt-id]
+**Before you verify:**
+- Make sure you're actually done building
+- Run tests yourself first (quick sanity check)
+- Have your app running if I need to check the UI
 
-Results:
-- Total: [X] items checked
-- Passed: [Y] ([Z]%)
-- Failed: [N] items need attention
+**During verification:**
+- Be honest - if something doesn't work, say so
+- Ask questions if a check doesn't make sense
+- It's okay to skip some checks and come back later
 
-Status: [All clear! / X items need fixing]
-```
+**After verification:**
+- Fix critical stuff first (tests, builds, core features)
+- Use `--retry-failed` to just re-check what you fixed
+- Don't stress perfection - good enough is often good enough to ship
 
-2. **Ask what the user wants to do next** - I do NOT proceed without user input
+**Remember:** I'm just checking, not judging. Failed checks help you ship better work!