clavix 4.7.0 → 4.8.0

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

@@ -0,0 +1,292 @@
+---
+name: "Clavix: Verify"
+description: Verify implementation against validation checklist from deep/fast mode
+---
+
+# Clavix: Verify Implementation
+
+Verify that your implementation covers the validation checklist, edge cases, and risks identified by `/clavix:deep` or `/clavix:fast`.
+
+---
+
+## CLAVIX MODE: Verification
+
+**You are in Clavix verification mode. You verify implementations against checklists.**
+
+**YOUR ROLE:**
+- ✓ Load saved prompt and extract validation checklist
+- ✓ Verify each checklist item systematically
+- ✓ Run automated hooks where applicable (test, build, lint)
+- ✓ Report pass/fail/skip for each item with reasoning
+- ✓ Generate verification report
+
+**DO NOT IMPLEMENT. DO NOT MODIFY CODE.**
+- ✗ Writing new code
+- ✗ Fixing issues found during verification
+- ✗ Making changes to implementation
+- Only verify and report. User will fix issues and re-verify.
+
+**MODE ENTRY VALIDATION:**
+Before verifying, confirm:
+1. Prompt was executed via `/clavix:execute`
+2. Implementation is complete (or ready for verification)
+3. Output assertion: "Entering VERIFICATION mode. I will verify, not implement."
+
+---
+
+## Prerequisites
+
+1. Generate optimized prompt with checklist:
+```bash
+/clavix:deep "your requirement"
+```
+
+2. Execute and implement:
+```bash
+/clavix:execute --latest
+# ... implement requirements ...
+```
+
+3. Then verify:
+```bash
+/clavix:verify --latest
+```
+
+---
+
+## Usage
+
+**Verify latest executed prompt (recommended):**
+```bash
+clavix verify --latest
+```
+
+**Verify specific prompt:**
+```bash
+clavix verify --id <prompt-id>
+```
+
+**Show verification status:**
+```bash
+clavix verify --status
+```
+
+**Re-run only failed items:**
+```bash
+clavix verify --retry-failed
+```
+
+**Export verification report:**
+```bash
+clavix verify --export markdown
+clavix verify --export json
+```
+
+---
+
+## Verification Workflow
+
+### Step 1: Load Checklist
+
+1. Locate saved prompt from `.clavix/outputs/prompts/deep/` or `.clavix/outputs/prompts/fast/`
+2. Extract validation checklist, edge cases, and risks sections
+3. If fast mode (no checklist): Generate basic checklist from intent
+
+### Step 2: Run Automated Hooks
+
+For items that can be verified automatically:
+
+| Hook | Verifies |
+|------|----------|
+| `test` | "Tests pass", "All tests", "Test coverage" |
+| `build` | "Compiles", "Builds without errors" |
+| `lint` | "No warnings", "Follows conventions" |
+| `typecheck` | "Type errors", "TypeScript" |
+
+Hooks are auto-detected from `package.json` scripts.
+
+### Step 3: Manual Verification
+
+For each item that requires manual verification:
+
+1. **Display the item:**
+   ```
+   📋 [Item description]
+   Category: [Functionality/Robustness/Quality/etc.]
+   ```
+
+2. **Verify against implementation:**
+   - Review code changes
+   - Test functionality
+   - Check edge cases
+
+3. **Record result:**
+   - ✓ **Passed**: Item is verified (with evidence)
+   - ✗ **Failed**: Item not covered (with reason)
+   - ⏭️ **Skipped**: Will verify later
+   - ➖ **N/A**: Does not apply to this implementation
+
+### Step 4: Generate Report
+
+```
+══════════════════════════════════════════════════════════════════════
+                    VERIFICATION REPORT
+                    [prompt-id]
+══════════════════════════════════════════════════════════════════════
+
+📋 VALIDATION CHECKLIST (X items)
+
+✅ [automated] Code compiles/runs without errors
+   Evidence: npm run build - exit code 0
+   Confidence: HIGH
+
+✅ [manual] All requirements implemented
+   Evidence: Login page with OAuth, callback handling
+   Confidence: MEDIUM
+
+❌ [manual] Keyboard navigation works
+   Status: FAILED
+   Reason: Tab order skips OAuth buttons
+   Confidence: MEDIUM
+
+══════════════════════════════════════════════════════════════════════
+                         SUMMARY
+══════════════════════════════════════════════════════════════════════
+Total:        X items
+Passed:       Y (Z%)
+Failed:       N (requires attention)
+Skipped:      M
+
+⚠️  N item(s) require attention before marking complete
+══════════════════════════════════════════════════════════════════════
+```
+
+---
+
+## Fast Mode Handling
+
+When verifying a fast mode prompt (no checklist):
+
+1. **Detect intent** from original prompt
+2. **Generate basic checklist** based on intent:
+   - `code-generation`: compiles, requirements met, no errors, follows conventions
+   - `testing`: tests pass, coverage acceptable, edge cases tested
+   - `debugging`: bug fixed, no regression, root cause addressed
+   - etc.
+
+3. **Display notice:**
+   ```
+   ⚠️  No checklist found (fast mode prompt)
+   Generating basic checklist based on intent...
+
+   💡 For comprehensive checklists, use /clavix:deep
+   ```
+
+---
+
+## Verification Methods by Category
+
+### Functionality
+- Run the implemented feature
+- Check expected behavior matches requirements
+- Verify all user flows complete successfully
+
+### Testing
+- Run test suite: `npm test`
+- Check coverage report
+- Verify no failing tests
+
+### Robustness/Edge Cases
+- Test with edge case inputs (empty, null, max values)
+- Check error messages are user-friendly
+- Verify system recovers gracefully
+
+### Quality
+- Run linter: `npm run lint`
+- Check for console errors
+- Review code style
+
+### Security (if applicable)
+- Verify authentication required where expected
+- Test input sanitization
+- Check sensitive data handling
+
+---
+
+## After Verification
+
+### If All Items Pass
+```
+✓ Verification complete!
+
+Next steps:
+  /clavix:archive  - Archive completed project
+  clavix prompts clear --executed  - Cleanup prompts
+```
+
+### If Items Fail
+```
+⚠️  Some items require attention.
+
+Fix issues and re-run:
+  clavix verify --retry-failed --id <prompt-id>
+```
+
+---
+
+## Verification Report Storage
+
+Reports are saved alongside prompt files:
+```
+.clavix/
+  outputs/
+    prompts/
+      deep/
+        deep-20250117-143022-a3f2.md              # Prompt
+        deep-20250117-143022-a3f2.verification.json  # Report
+```
+
+---
+
+## Agent Transparency (v4.8)
+
+### Verification Confidence Levels
+
+| Level | Meaning | Example |
+|-------|---------|---------|
+| HIGH | Automated verification passed | npm test exit code 0 |
+| MEDIUM | Agent verified with evidence | Code review confirmed |
+| LOW | Agent verified without clear evidence | General assessment |
+
+### Verification Checkpoint Output
+
+After completing verification:
+```
+VERIFICATION CHECKPOINT (v4.8):
+- Prompt: [id]
+- Total items: [X]
+- Passed: [Y] ([Z]%)
+- Failed: [N]
+- Status: [completed/requires-attention]
+```
+
+### Error Handling
+{{INCLUDE:agent-protocols/error-handling.md}}
+
+### Decision Rules
+{{INCLUDE:agent-protocols/decision-rules.md}}
+
+---
+
+## Workflow Navigation
+
+**You are here:** Verify (Post-Implementation Verification)
+
+**Common workflows:**
+- `/clavix:execute` → **`/clavix:verify`** → Fix issues → Re-verify → `/clavix:archive`
+- `/clavix:implement` → **`/clavix:verify`** → `/clavix:archive`
+
+**Related commands:**
+- `/clavix:execute` - Execute saved prompt (previous step)
+- `/clavix:deep` - Comprehensive analysis with validation checklist
+- `/clavix:archive` - Archive completed project (next step)

package/dist/templates/slash-commands/_components/agent-protocols/verification-methods.md

@@ -0,0 +1,184 @@
+## Verification Methods by Category
+
+### Functionality
+**Checklist items about:** Code works, features implemented, requirements met
+
+**Verification approach:**
+1. Run the implemented code/feature
+2. Check expected behavior matches requirements
+3. Verify all user flows complete successfully
+
+**Commands to use:**
+- Run application: `npm start`, `npm run dev`
+- Execute specific feature manually
+- Check output matches expected
+
+**Evidence examples:**
+- "Feature X works as specified"
+- "Login flow completes successfully"
+- "API returns expected response format"
+
+---
+
+### Testing
+**Checklist items about:** Tests pass, coverage met, test quality
+
+**Verification approach:**
+1. Run test suite
+2. Check coverage report
+3. Verify no failing tests
+
+**Commands to use:**
+- `npm test` or project test command
+- `npm run coverage` for coverage report
+- Look for test output in terminal
+
+**Evidence examples:**
+- "npm test - 47 tests passing, 0 failed"
+- "Coverage: 85% (exceeds 80% threshold)"
+- "All integration tests pass"
+
+---
+
+### Robustness/Edge Cases
+**Checklist items about:** Error handling, edge cases, graceful degradation
+
+**Verification approach:**
+1. Test with edge case inputs (empty, null, max values)
+2. Check error messages are user-friendly
+3. Verify system recovers gracefully
+
+**Manual testing:**
+- Input empty values
+- Input invalid data types
+- Test boundary conditions (min/max values)
+- Test with large datasets
+
+**Evidence examples:**
+- "Empty input shows validation error"
+- "Invalid email format displays helpful message"
+- "System handles 10,000 records without timeout"
+
+---
+
+### Quality
+**Checklist items about:** Code style, conventions, no warnings
+
+**Verification approach:**
+1. Run linter
+2. Check for console errors
+3. Review code style
+
+**Commands to use:**
+- `npm run lint` or equivalent
+- Check browser console for errors
+- Review PR diff for style
+
+**Evidence examples:**
+- "npm run lint - 0 errors, 0 warnings"
+- "No console errors in browser"
+- "Code follows project conventions"
+
+---
+
+### Accessibility
+**Checklist items about:** Keyboard navigation, screen reader, WCAG
+
+**Verification approach:**
+1. Tab through interface
+2. Check color contrast
+3. Verify alt text on images
+
+**Manual testing:**
+- Navigate using only keyboard
+- Check focus indicators visible
+- Test with screen reader (optional)
+
+**Evidence examples:**
+- "All interactive elements keyboard accessible"
+- "Focus order is logical"
+- "Color contrast meets WCAG AA"
+
+---
+
+### Security
+**Checklist items about:** Auth, input sanitization, data protection
+
+**Verification approach:**
+1. Verify authentication required where expected
+2. Test input sanitization
+3. Check sensitive data handling
+
+**Manual testing:**
+- Try accessing protected routes without auth
+- Submit potentially malicious input
+- Check network tab for sensitive data exposure
+
+**Evidence examples:**
+- "Protected routes redirect to login"
+- "SQL injection attempts are sanitized"
+- "Passwords not logged or exposed"
+
+---
+
+### Performance
+**Checklist items about:** Response times, resource usage
+
+**Verification approach:**
+1. Check response times
+2. Monitor memory/CPU usage
+3. Test with realistic data volumes
+
+**Tools:**
+- Browser DevTools Performance tab
+- Network tab for response times
+- Lighthouse performance score
+
+**Evidence examples:**
+- "Page load time < 2s"
+- "API response time < 200ms"
+- "Memory usage stable under load"
+
+---
+
+### Documentation
+**Checklist items about:** Docs updated, comments present
+
+**Verification approach:**
+1. Check README updates
+2. Verify JSDoc/comments on complex functions
+3. Review API documentation
+
+**Commands to use:**
+- `cat README.md` - check for updates
+- Review changed files for comments
+
+**Evidence examples:**
+- "README updated with new feature"
+- "API endpoints documented"
+- "Complex logic has explanatory comments"
+
+---
+
+## Verification Type Detection
+
+**Automated items contain keywords:**
+- compiles, builds, tests pass, lint, typecheck, no errors
+
+**Semi-automated items contain keywords:**
+- renders, displays, console errors, responsive, visual
+
+**Manual items contain keywords:**
+- requirements, edge cases, handles, correctly, properly
+
+---
+
+## Confidence Levels
+
+| Level | When to use | Example |
+|-------|-------------|---------|
+| HIGH | Automated tool verification | npm test exit code 0 |
+| MEDIUM | Manual verification with clear evidence | Code review shows implementation |
+| LOW | General assessment without specific evidence | "Looks correct" |
+
+Always prefer higher confidence verification when possible.

package/dist/types/verification.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Clavix v4.8: Verification System Types
+ *
+ * Type definitions for the checklist verification system that ensures
+ * checklists generated by deep/fast modes are verified after implementation.
+ */
+import { PromptIntent } from '../core/intelligence/types.js';
+/**
+ * Category of checklist item
+ */
+export type ChecklistCategory = 'validation' | 'edge-case' | 'risk';
+/**
+ * How the checklist item can be verified
+ */
+export type VerificationType = 'automated' | 'semi-automated' | 'manual';
+/**
+ * A single item from the checklist
+ */
+export interface ChecklistItem {
+    /** Unique identifier (e.g., "validation-1", "edge-case-2") */
+    id: string;
+    /** Category of the item */
+    category: ChecklistCategory;
+    /** Item description text */
+    content: string;
+    /** Optional grouping (e.g., "Functionality", "Robustness") */
+    group?: string;
+    /** How this item should be verified */
+    verificationType: VerificationType;
+}
+/**
+ * Parsed checklist from a prompt file
+ */
+export interface ParsedChecklist {
+    /** Validation checklist items (☐ items from deep mode) */
+    validationItems: ChecklistItem[];
+    /** Edge cases to consider */
+    edgeCases: ChecklistItem[];
+    /** Risk/what could go wrong items */
+    risks: ChecklistItem[];
+    /** Whether the prompt has any checklist */
+    hasChecklist: boolean;
+    /** Total number of items across all categories */
+    totalItems: number;
+}
+/**
+ * Type of verification hook
+ */
+export type HookType = 'test' | 'build' | 'lint' | 'typecheck' | 'custom';
+/**
+ * A CLI hook for automated verification
+ */
+export interface VerificationHook {
+    /** Hook identifier */
+    name: HookType;
+    /** Display name */
+    displayName: string;
+    /** Command to execute */
+    command: string;
+    /** Regex pattern to match success */
+    successPattern?: RegExp;
+    /** Regex pattern to match failure */
+    failurePattern?: RegExp;
+    /** Timeout in milliseconds */
+    timeout: number;
+}
+/**
+ * Result of running a verification hook
+ */
+export interface HookResult {
+    /** Hook that was run */
+    hook: VerificationHook;
+    /** Whether the hook succeeded */
+    success: boolean;
+    /** Exit code of the command */
+    exitCode: number;
+    /** Command output (stdout + stderr) */
+    output: string;
+    /** Confidence in the result */
+    confidence: VerificationConfidence;
+    /** Execution time in milliseconds */
+    executionTimeMs: number;
+    /** Error message if hook failed to run */
+    error?: string;
+}
+/**
+ * Detected hooks for a project
+ */
+export interface DetectedHooks {
+    /** Available hooks */
+    hooks: VerificationHook[];
+    /** Package manager detected */
+    packageManager: 'npm' | 'yarn' | 'pnpm' | 'unknown';
+    /** Whether a package.json was found */
+    hasPackageJson: boolean;
+}
+/**
+ * Status of a verification item
+ */
+export type VerificationStatus = 'pending' | 'passed' | 'failed' | 'skipped' | 'not-applicable';
+/**
+ * Confidence level in the verification result
+ */
+export type VerificationConfidence = 'high' | 'medium' | 'low';
+/**
+ * Method used for verification
+ */
+export type VerificationMethod = 'automated' | 'semi-automated' | 'manual';
+/**
+ * Result of verifying a single checklist item
+ */
+export interface VerificationResult {
+    /** ID of the checklist item */
+    itemId: string;
+    /** Verification status */
+    status: VerificationStatus;
+    /** Method used for verification */
+    method: VerificationMethod;
+    /** Confidence in the result */
+    confidence: VerificationConfidence;
+    /** Evidence of verification (command output or agent reasoning) */
+    evidence?: string;
+    /** Reason for failed/skipped status */
+    reason?: string;
+    /** Timestamp of verification */
+    verifiedAt: string;
+}
+/**
+ * Overall status of the verification report
+ */
+export type ReportStatus = 'pending' | 'in-progress' | 'completed' | 'requires-attention';
+/**
+ * Summary statistics for verification
+ */
+export interface VerificationSummary {
+    /** Total number of items */
+    total: number;
+    /** Number of passed items */
+    passed: number;
+    /** Number of failed items */
+    failed: number;
+    /** Number of skipped items */
+    skipped: number;
+    /** Number of not-applicable items */
+    notApplicable: number;
+    /** Coverage percentage (passed / (total - skipped - notApplicable)) */
+    coveragePercent: number;
+    /** Number of automated checks */
+    automatedChecks: number;
+    /** Number of manual checks */
+    manualChecks: number;
+}
+/**
+ * Full verification report
+ */
+export interface VerificationReport {
+    /** Report version */
+    version: '1.0';
+    /** ID of the prompt being verified */
+    promptId: string;
+    /** Source of the prompt (fast or deep) */
+    source: 'fast' | 'deep';
+    /** When verification started */
+    startedAt: string;
+    /** When verification completed (all items done) */
+    completedAt?: string;
+    /** Overall status */
+    status: ReportStatus;
+    /** All checklist items */
+    items: ChecklistItem[];
+    /** Verification results for each item */
+    results: VerificationResult[];
+    /** Summary statistics */
+    summary: VerificationSummary;
+    /** Detected hooks used for automated verification */
+    detectedHooks?: DetectedHooks;
+}
+/**
+ * Intent-to-checklist mapping entry
+ */
+export interface IntentChecklist {
+    /** The intent type */
+    intent: PromptIntent;
+    /** Checklist items for this intent */
+    items: Array<{
+        content: string;
+        group?: string;
+        verificationType: VerificationType;
+    }>;
+}
+/**
+ * Additional fields for PromptMetadata to support verification
+ */
+export interface VerificationMetadata {
+    /** Whether verification is required for this prompt */
+    verificationRequired?: boolean;
+    /** Whether the prompt has been verified */
+    verified?: boolean;
+    /** Timestamp of last verification */
+    lastVerifiedAt?: string;
+    /** Path to verification report file */
+    verificationReportPath?: string;
+}
+//# sourceMappingURL=verification.d.ts.map

package/dist/types/verification.js

@@ -0,0 +1,8 @@
+/**
+ * Clavix v4.8: Verification System Types
+ *
+ * Type definitions for the checklist verification system that ensures
+ * checklists generated by deep/fast modes are verified after implementation.
+ */
+export {};
+//# sourceMappingURL=verification.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavix",
-  "version": "4.7.0",
+  "version": "4.8.0",
   "description": "Clavix Intelligence™ for AI coding. Automatically optimizes prompts with intent detection, quality assessment, and adaptive patterns—no framework to learn. Works with Claude Code, Cursor, Windsurf, and 19+ other AI coding tools.",
   "type": "module",
   "main": "dist/index.js",