Cursor rule

1# 🚦 Quality Gates for CursorRIPER Σ
2# Symbol: Κ (Kappa)
3# Version: 1.0.0
4 
5## 📋 Gate System Definition
6```
7service = "Enterprise Quality Gate System"
8symbol = "Κ"
9enforcement = "Sequential gate progression with approvals"
10```
11 
12## 🎯 Gate Definitions
13```
14Κ = {
15  Κ₁: {
16    name: "PRD Approval Gate",
17    phase: "Requirements",
18    blockers: {
19      prd_completeness: 100%,
20      objectives_clear: validated(Ρ₁),
21      requirements_complete: validated(Ρ₂),
22      stories_estimated: all(Ρ₄.estimation > 0),
23      acceptance_defined: all(Ρ₅.criteria.length > 0)
24    },
25    approvers: [Β₁],
26    artifacts_required: [
27      "Complete PRD document",
28      "User story backlog",
29      "Success metrics defined"
30    ],
31    next: Κ₂,
32    rollback: draft_state
33  },
34  
35  Κ₂: {
36    name: "Design Review Gate",
37    phase: "Architecture",
38    blockers: {
39      architecture_documented: exists(tech_spec),
40      api_contracts_defined: validated(api_spec),
41      security_review_passed: security_score > 80,
42      performance_targets_set: defined(sla_metrics),
43      database_design_complete: exists(data_model)
44    },
45    approvers: [Β₂],
46    artifacts_required: [
47      "Technical specification",
48      "Architecture diagrams",
49      "API documentation",
50      "Security assessment"
51    ],
52    next: Κ₃,
53    rollback: Κ₁
54  },
55  
56  Κ₃: {
57    name: "Code Review Gate",
58    phase: "Implementation",
59    blockers: {
60      tests_passing: test_suite.pass_rate === 100%,
61      coverage_threshold: code_coverage > 80%,
62      linting_passed: lint_errors === 0,
63      no_security_vulnerabilities: security_scan.critical === 0,
64      documentation_complete: api_docs_generated()
65    },
66    approvers: [Β₃, Β₄],
67    artifacts_required: [
68      "Source code",
69      "Unit tests",
70      "Integration tests",
71      "Code documentation"
72    ],
73    next: Κ₄,
74    rollback: development_branch
75  },
76  
77  Κ₄: {
78    name: "QA Signoff Gate",
79    phase: "Testing",
80    blockers: {
81      acceptance_tests_passed: acceptance_suite.pass_rate === 100%,
82      regression_suite_clean: regression_failures === 0,
83      performance_benchmarks_met: all(perf_metrics < threshold),
84      accessibility_compliant: a11y_score > 90,
85      browser_compatibility: all(browsers.tested)
86    },
87    approvers: [Β₄],
88    artifacts_required: [
89      "Test execution reports",
90      "Bug tracking status",
91      "Performance reports",
92      "QA signoff document"
93    ],
94    next: Κ₅,
95    rollback: Κ₃
96  },
97  
98  Κ₅: {
99    name: "Deployment Approval Gate",
100    phase: "Release",
101    blockers: {
102      staging_validation_complete: staging_tests.passed,
103      rollback_plan_documented: exists(rollback_procedure),
104      monitoring_configured: all(alerts.configured),
105      runbooks_updated: documentation.current,
106      change_approval_obtained: change_ticket.approved
107    },
108    approvers: [Β₅],
109    artifacts_required: [
110      "Deployment plan",
111      "Rollback procedures",
112      "Monitoring configuration",
113      "Release notes"
114    ],
115    next: production_release,
116    rollback: Κ₄
117  }
118}
119```
120 
121## 🔐 Gate Enforcement
122```
123enforce_gate(Κᵢ) = {
124  current_gate: get_active_gate(),
125  
126  # Check sequential progression
127  validate_sequence: Κᵢ === current_gate.next ? 
128    proceed : deny("Must complete " + current_gate.name),
129  
130  # Check blockers
131  check_blockers: Κᵢ.blockers.map(b => ({
132    blocker: b.name,
133    status: evaluate(b.condition),
134    details: b.status ? "✓ Passed" : "✗ " + b.failure_reason
135  })),
136  
137  # Check artifacts
138  check_artifacts: Κᵢ.artifacts_required.map(a => ({
139    artifact: a,
140    exists: find_artifact(a),
141    valid: validate_artifact(a)
142  })),
143  
144  # Require approval
145  get_approval: {
146    eligible_approvers: Κᵢ.approvers ∩ available_approvers(),
147    request_approval: send_approval_request(eligible_approvers),
148    wait_for_approval: blocking_wait(timeout: 48h)
149  },
150  
151  # Log completion
152  complete_gate: {
153    log: record_gate_completion(Κᵢ, approvals, timestamp),
154    transition: move_to_next_phase(Κᵢ.next),
155    notify: broadcast_gate_completion(Κᵢ)
156  }
157}
158```
159 
160## 📋 Gate Checklists
161```
162generate_checklist(Κᵢ) = {
163  metadata: {
164    gate: Κᵢ.name,
165    phase: Κᵢ.phase,
166    generated: timestamp()
167  },
168  
169  blockers_checklist: Κᵢ.blockers.map(b => 
170    "[ ] " + b.description + " (" + b.condition + ")"
171  ),
172  
173  artifacts_checklist: Κᵢ.artifacts_required.map(a =>
174    "[ ] " + a + " - uploaded and validated"
175  ),
176  
177  approval_checklist: Κᵢ.approvers.map(role =>
178    "[ ] Approval from " + Β_roles[role].name
179  ),
180  
181  format: markdown_checklist()
182}
183```
184 
185## 🚨 Gate Violations
186```
187handle_gate_violation(violation_type, Κᵢ) = {
188  bypassed_gate: {
189    severity: "CRITICAL",
190    action: rollback_to_gate(Κᵢ),
191    notify: escalate_to_management(),
192    audit: log_security_event()
193  },
194  
195  incomplete_artifacts: {
196    severity: "HIGH",
197    action: block_progression(),
198    notify: remind_artifact_owners(),
199    timeout: 24h
200  },
201  
202  failed_blockers: {
203    severity: "MEDIUM",
204    action: return_to_previous_phase(),
205    notify: assigned_teams(),
206    guidance: suggest_remediation()
207  },
208  
209  missing_approval: {
210    severity: "HIGH", 
211    action: halt_until_approved(),
212    notify: ping_approvers(),
213    escalate: after_48h
214  }
215}
216```
217 
218## ⚡ Gate Commands
219```
220S_gates = {
221  !kg: "check_current_gate",
222  !kga: "approve_gate",
223  !kgc: "view_gate_checklist",
224  !kgb: "show_gate_blockers",
225  !kgh: "gate_history",
226  !kgr: "request_gate_approval",
227  !kgs: "skip_gate (emergency only)"
228}
229```
230 
231## 📊 Gate Metrics
232```
233track_gate_metrics() = {
234  cycle_time_per_gate: {
235    Κ₁: avg_days(start → approval),
236    Κ₂: avg_days(approval → design_complete),
237    Κ₃: avg_days(design → code_complete),
238    Κ₄: avg_days(code → qa_signoff),
239    Κ₅: avg_days(qa → deployment)
240  },
241  
242  blocker_frequency: count_by_blocker_type(),
243  approval_delays: avg_approval_time_by_role(),
244  rollback_rate: rollbacks / total_attempts,
245  
246  quality_impact: {
247    defect_escape_rate: bugs_in_prod / total_bugs,
248    gate_effectiveness: prevented_issues / total_gates
249  }
250}
251```
252 
253## 🔄 Gate Automation
254```
255automate_gate_checks() = {
256  continuous_validation: {
257    run_every: 15_minutes,
258    check: current_gate.blockers,
259    notify: on_status_change
260  },
261  
262  artifact_monitoring: {
263    watch: artifact_directories,
264    validate: on_new_upload,
265    update: checklist_status
266  },
267  
268  approval_reminders: {
269    initial: after_24h,
270    followup: every_12h,
271    escalate: after_72h
272  }
273}
274```
275 
276## 🔗 Gate Integration
277```
278# Gate + Mode enforcement
279gate_mode_requirements = {
280  Κ₁: requires(Ω₁ ∨ Ω₂),  # Research or Innovate
281  Κ₂: requires(Ω₂ ∨ Ω₃),  # Innovate or Plan
282  Κ₃: requires(Ω₄),       # Execute only
283  Κ₄: requires(Ω₄ ∨ Ω₅),  # Execute or Review
284  Κ₅: requires(Ω₅)        # Review only
285}
286 
287# Gate + Role validation
288gate_role_matrix = {
289  (Κ₁, Β₁): can_approve,
290  (Κ₂, Β₂): can_approve,
291  (Κ₃, Β₃): can_request,
292  (Κ₃, Β₄): can_approve,
293  (Κ₄, Β₄): can_approve,
294  (Κ₅, Β₅): can_approve
295}
296```
297