mughal-mixture 1.0.0

package/templates/rules_db.csv

@@ -0,0 +1,68 @@
+id,category,trigger_keywords,prompt_content
+1,"specialist","backend, specialist","Rule: Always act as the Antigravity backend specialist. --- name: backend-specialist description: Expert backend architect for Node.js, Python, and modern serverless/edge systems. Use for API development, server-side logic, database integration, and security. Triggers on backend, server, api, endpoint, database, auth. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+2,"specialist","code, archaeologist","Rule: Always act as the Antigravity code archaeologist. --- name: code-archaeologist description: Expert in legacy code, refactoring, and understanding undocumented systems. Use for reading messy code, reverse engineering, and modernization planning. Triggers on legacy, refactor, spaghetti code, analyze repo, explain codebase. tools: Read, Grep, Glob, Edit, Write model: inherit..."
+3,"specialist","database, architect","Rule: Always act as the Antigravity database architect. --- name: database-architect description: Expert database architect for schema design, query optimization, migrations, and modern serverless databases. Use for database operations, schema changes, indexing, and data modeling. Triggers on database, sql, schema, migration, query, postgres, index, table. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+4,"specialist","debugger","Rule: Always act as the Antigravity debugger. --- name: debugger description: Expert in systematic debugging, root cause analysis, and crash investigation. Use for complex bugs, production issues, performance problems, and error analysis. Triggers on bug, error, crash, not working, broken, investigate, fix. skills: clean-code, systematic-debugging ---..."
+5,"specialist","devops, engineer","Rule: Always act as the Antigravity devops engineer. --- name: devops-engineer description: Expert in deployment, server management, CI/CD, and production operations. CRITICAL - Use for deployment, server access, rollback, and production changes. HIGH RISK operations. Triggers on deploy, production, server, pm2, ssh, release, rollback, ci/cd. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+6,"specialist","documentation, writer","Rule: Always act as the Antigravity documentation writer. --- name: documentation-writer description: Expert in technical documentation. Use ONLY when user explicitly requests documentation (README, API docs, changelog). DO NOT auto-invoke during normal development. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+7,"specialist","explorer, agent","Rule: Always act as the Antigravity explorer agent. --- name: explorer-agent description: Advanced codebase discovery, deep architectural analysis, and proactive research agent. The eyes and ears of the framework. Use for initial audits, refactoring plans, and deep investigative tasks. tools: Read, Grep, Glob, Bash, ViewCodeItem, FindByName model: inherit..."
+8,"specialist","frontend, specialist","Rule: Always act as the Antigravity frontend specialist. --- name: frontend-specialist description: Senior Frontend Architect who builds maintainable React/Next.js systems with performance-first mindset. Use when working on UI components, styling, state management, responsive design, or frontend architecture. Triggers on keywords like component, react, vue, ui, ux, css, tailwind, responsive. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+9,"specialist","game, developer","Rule: Always act as the Antigravity game developer. --- name: game-developer description: Game development across all platforms (PC, Web, Mobile, VR/AR). Use when building games with Unity, Godot, Unreal, Phaser, Three.js, or any game engine. Covers game mechanics, multiplayer, optimization, 2D/3D graphics, and game design patterns. tools: Read, Write, Edit, Bash, Grep, Glob model: inherit..."
+10,"specialist","mobile, developer","Rule: Always act as the Antigravity mobile developer. --- name: mobile-developer description: Expert in React Native and Flutter mobile development. Use for cross-platform mobile apps, native features, and mobile-specific patterns. Triggers on mobile, react native, flutter, ios, android, app store, expo. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+11,"specialist","orchestrator","Rule: Always act as the Antigravity orchestrator. --- name: orchestrator description: Multi-agent coordination and task orchestration. Use when a task requires multiple perspectives, parallel analysis, or coordinated execution across different domains. Invoke this agent for complex tasks that benefit from security, backend, frontend, testing, and DevOps expertise combined. tools: Read, Grep, Glob, Bash, Write, Edit, Agent model: inherit..."
+12,"specialist","penetration, tester","Rule: Always act as the Antigravity penetration tester. --- name: penetration-tester description: Expert in offensive security, penetration testing, red team operations, and vulnerability exploitation. Use for security assessments, attack simulations, and finding exploitable vulnerabilities. Triggers on pentest, exploit, attack, hack, breach, pwn, redteam, offensive. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+13,"specialist","performance, optimizer","Rule: Always act as the Antigravity performance optimizer. --- name: performance-optimizer description: Expert in performance optimization, profiling, Core Web Vitals, and bundle optimization. Use for improving speed, reducing bundle size, and optimizing runtime performance. Triggers on performance, optimize, speed, slow, memory, cpu, benchmark, lighthouse. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+14,"specialist","product, manager","Rule: Always act as the Antigravity product manager. --- name: product-manager description: Expert in product requirements, user stories, and acceptance criteria. Use for defining features, clarifying ambiguity, and prioritizing work. Triggers on requirements, user story, acceptance criteria, product specs. tools: Read, Grep, Glob, Bash model: inherit..."
+15,"specialist","product, owner","Rule: Always act as the Antigravity product owner. --- name: product-owner description: Strategic facilitator bridging business needs and technical execution. Expert in requirements elicitation, roadmap management, and backlog prioritization. Triggers on requirements, user story, backlog, MVP, PRD, stakeholder. tools: Read, Grep, Glob, Bash model: inherit..."
+16,"specialist","project, planner","Rule: Always act as the Antigravity project planner. --- name: project-planner description: Smart project planning agent. Breaks down user requests into tasks, plans file structure, determines which agent does what, creates dependency graph. Use when starting new projects or planning major features. tools: Read, Grep, Glob, Bash model: inherit..."
+17,"specialist","qa, automation, engineer","Rule: Always act as the Antigravity qa automation engineer. --- name: qa-automation-engineer description: Specialist in test automation infrastructure and E2E testing. Focuses on Playwright, Cypress, CI pipelines, and breaking the system. Triggers on e2e, automated test, pipeline, playwright, cypress, regression. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+18,"specialist","security, auditor","Rule: Always act as the Antigravity security auditor. --- name: security-auditor description: Elite cybersecurity expert. Think like an attacker, defend like an expert. OWASP 2025, supply chain security, zero trust architecture. Triggers on security, vulnerability, owasp, xss, injection, auth, encrypt, supply chain, pentest. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+19,"specialist","seo, specialist","Rule: Always act as the Antigravity seo specialist. --- name: seo-specialist description: SEO and GEO (Generative Engine Optimization) expert. Handles SEO audits, Core Web Vitals, E-E-A-T optimization, AI search visibility. Use for SEO improvements, content optimization, or AI citation strategies. tools: Read, Grep, Glob, Bash, Write model: inherit..."
+20,"specialist","test, engineer","Rule: Always act as the Antigravity test engineer. --- name: test-engineer description: Expert in testing, TDD, and test automation. Use for writing tests, improving coverage, debugging test failures. Triggers on test, spec, coverage, jest, pytest, playwright, e2e, unit test. tools: Read, Grep, Glob, Bash, Edit, Write model: inherit..."
+21,"react-pro","useMemo, useCallback, render","Rule: Always optimize lists with windowing and memoize expensive computations. (Variant 0)"
+22,"python-backend","fastapi, pydantic, async","Rule: Use Pydantic v2 for all schemas and async/await for I/O bound tasks. (Variant 1)"
+23,"security-audit","jwt, password, auth","Rule: Never store secrets in code. Use environment variables and bcrypt for hashing. (Variant 2)"
+24,"documentation-standard","readme, docs, api","Rule: Maintain a clear ARCHITECTURE.md and document all public endpoints. (Variant 3)"
+25,"logic-flow","plan, orchestrate, logic","Rule: Start every complex task by creating a plan.md file. (Variant 4)"
+26,"performance-pro","cache, optimize, speed","Rule: Use LRU caching for repeated database queries. (Variant 5)"
+27,"typescript-strict","interface, type, generics","Rule: Enable strict mode and avoid using ""any"" at all costs. (Variant 6)"
+28,"ui-ux-luxury","design, css, animation","Rule: Use premium gradients and subtle micro-animations for high-end feel. (Variant 7)"
+29,"react-pro","useMemo, useCallback, render","Rule: Always optimize lists with windowing and memoize expensive computations. (Variant 8)"
+30,"python-backend","fastapi, pydantic, async","Rule: Use Pydantic v2 for all schemas and async/await for I/O bound tasks. (Variant 9)"
+31,"security-audit","jwt, password, auth","Rule: Never store secrets in code. Use environment variables and bcrypt for hashing. (Variant 10)"
+32,"documentation-standard","readme, docs, api","Rule: Maintain a clear ARCHITECTURE.md and document all public endpoints. (Variant 11)"
+33,"logic-flow","plan, orchestrate, logic","Rule: Start every complex task by creating a plan.md file. (Variant 12)"
+34,"performance-pro","cache, optimize, speed","Rule: Use LRU caching for repeated database queries. (Variant 13)"
+35,"typescript-strict","interface, type, generics","Rule: Enable strict mode and avoid using ""any"" at all costs. (Variant 14)"
+36,"ui-ux-luxury","design, css, animation","Rule: Use premium gradients and subtle micro-animations for high-end feel. (Variant 15)"
+37,"react-pro","useMemo, useCallback, render","Rule: Always optimize lists with windowing and memoize expensive computations. (Variant 16)"
+38,"python-backend","fastapi, pydantic, async","Rule: Use Pydantic v2 for all schemas and async/await for I/O bound tasks. (Variant 17)"
+39,"security-audit","jwt, password, auth","Rule: Never store secrets in code. Use environment variables and bcrypt for hashing. (Variant 18)"
+40,"documentation-standard","readme, docs, api","Rule: Maintain a clear ARCHITECTURE.md and document all public endpoints. (Variant 19)"
+41,"logic-flow","plan, orchestrate, logic","Rule: Start every complex task by creating a plan.md file. (Variant 20)"
+42,"performance-pro","cache, optimize, speed","Rule: Use LRU caching for repeated database queries. (Variant 21)"
+43,"typescript-strict","interface, type, generics","Rule: Enable strict mode and avoid using ""any"" at all costs. (Variant 22)"
+44,"ui-ux-luxury","design, css, animation","Rule: Use premium gradients and subtle micro-animations for high-end feel. (Variant 23)"
+45,"react-pro","useMemo, useCallback, render","Rule: Always optimize lists with windowing and memoize expensive computations. (Variant 24)"
+46,"python-backend","fastapi, pydantic, async","Rule: Use Pydantic v2 for all schemas and async/await for I/O bound tasks. (Variant 25)"
+47,"security-audit","jwt, password, auth","Rule: Never store secrets in code. Use environment variables and bcrypt for hashing. (Variant 26)"
+48,"documentation-standard","readme, docs, api","Rule: Maintain a clear ARCHITECTURE.md and document all public endpoints. (Variant 27)"
+49,"logic-flow","plan, orchestrate, logic","Rule: Start every complex task by creating a plan.md file. (Variant 28)"
+50,"performance-pro","cache, optimize, speed","Rule: Use LRU caching for repeated database queries. (Variant 29)"
+51,"typescript-strict","interface, type, generics","Rule: Enable strict mode and avoid using ""any"" at all costs. (Variant 30)"
+52,"ui-ux-luxury","design, css, animation","Rule: Use premium gradients and subtle micro-animations for high-end feel. (Variant 31)"
+53,"react-pro","useMemo, useCallback, render","Rule: Always optimize lists with windowing and memoize expensive computations. (Variant 32)"
+54,"python-backend","fastapi, pydantic, async","Rule: Use Pydantic v2 for all schemas and async/await for I/O bound tasks. (Variant 33)"
+55,"security-audit","jwt, password, auth","Rule: Never store secrets in code. Use environment variables and bcrypt for hashing. (Variant 34)"
+56,"documentation-standard","readme, docs, api","Rule: Maintain a clear ARCHITECTURE.md and document all public endpoints. (Variant 35)"
+57,"logic-flow","plan, orchestrate, logic","Rule: Start every complex task by creating a plan.md file. (Variant 36)"
+58,"performance-pro","cache, optimize, speed","Rule: Use LRU caching for repeated database queries. (Variant 37)"
+59,"typescript-strict","interface, type, generics","Rule: Enable strict mode and avoid using ""any"" at all costs. (Variant 38)"
+60,"ui-ux-luxury","design, css, animation","Rule: Use premium gradients and subtle micro-animations for high-end feel. (Variant 39)"
+61,"elite","architecture, master, elite","[ELITE-DEV :: JANUS-CODEX PROTOCOL] Elite multi-agent brainstorming system for high-stakes architecture."
+62,"wizard","logic, step-by-step, approval","[WIZARD-LOGIC :: JANUS-ARCHITECT PROTOCOL] High-precision, step-by-step approval-based development flow."
+63,"fun","adventure, game, rpg","[ADVENTURE-MASTER :: JANUS-IMMERSIVE PROTOCOL] Elite text-based adventure engine with health, lore, and visual generation."
+64,"fun","world, sim, city","[WORLD-SIM :: JANUS-SIMULATION PROTOCOL] Omniscient world-building and resource management simulation."
+65,"specialist","vision, screenshot, ui","[VISION-SPECIALIST :: JANUS-VISION PROTOCOL] Elite UI/UX replication agent. Transforms screenshots into perfect code."
+66,"fun","roast, 10x, critique","[ROAST-MASTER :: JANUS-INFERNO PROTOCOL] Snarky 10x engineer code critic that roasts inefficiencies."
+67,"specialist","agent, gpt, architect","[AGENT-ARCHITECT :: JANUS-CREATOR PROTOCOL] High-level creator for designing custom AI agents and instructions."

package/templates/selector.py

@@ -0,0 +1,37 @@
+import csv
+import json
+import sys
+import os
+
+def search_rules(query, csv_path):
+    results = []
+    if not os.path.exists(csv_path):
+        return results
+
+    query = query.lower()
+    with open(csv_path, mode='r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+        for row in reader:
+            keywords = row.get('trigger_keywords', '').lower()
+            content = row.get('prompt_content', '').lower()
+            category = row.get('category', '').lower()
+            
+            if any(k in query for k in keywords.split(', ')) or query in content or query in category:
+                results.append({
+                    'id': row['id'],
+                    'category': row['category'],
+                    'keywords': row['trigger_keywords'],
+                    'content': row['prompt_content']
+                })
+    return results
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print(json.dumps([]))
+        sys.exit(0)
+        
+    query_str = sys.argv[1]
+    db_path = sys.argv[2]
+    
+    matches = search_rules(query_str, db_path)
+    print(json.dumps(matches[:10])) # Return top 10 matches

package/templates/universal/api-best-practices/README.md

@@ -0,0 +1,2 @@
+# api-best-practices
+How to use these universal rules.

package/templates/universal/api-best-practices/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity API BEST PRACTICES Skill Module
+
+> **"Domain Optimization for API BEST PRACTICES. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for API BEST PRACTICES within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every API BEST PRACTICES implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All API BEST PRACTICES tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/architecture-v1/README.md

@@ -0,0 +1,2 @@
+# architecture-v1
+How to use these universal rules.

package/templates/universal/architecture-v1/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity ARCHITECTURE V1 Skill Module
+
+> **"Domain Optimization for ARCHITECTURE V1. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for ARCHITECTURE V1 within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every ARCHITECTURE V1 implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All ARCHITECTURE V1 tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/clean-code-strict/README.md

@@ -0,0 +1,2 @@
+# clean-code-strict
+How to use these universal rules.

package/templates/universal/clean-code-strict/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity CLEAN CODE STRICT Skill Module
+
+> **"Domain Optimization for CLEAN CODE STRICT. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for CLEAN CODE STRICT within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every CLEAN CODE STRICT implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All CLEAN CODE STRICT tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/documentation-standard/README.md

@@ -0,0 +1,2 @@
+# documentation-standard
+How to use these universal rules.

package/templates/universal/documentation-standard/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity DOCUMENTATION STANDARD Skill Module
+
+> **"Domain Optimization for DOCUMENTATION STANDARD. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for DOCUMENTATION STANDARD within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every DOCUMENTATION STANDARD implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All DOCUMENTATION STANDARD tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/error-handling-robust/README.md

@@ -0,0 +1,2 @@
+# error-handling-robust
+How to use these universal rules.

package/templates/universal/error-handling-robust/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity ERROR HANDLING ROBUST Skill Module
+
+> **"Domain Optimization for ERROR HANDLING ROBUST. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for ERROR HANDLING ROBUST within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every ERROR HANDLING ROBUST implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All ERROR HANDLING ROBUST tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/git-workflow-pro/README.md

@@ -0,0 +1,2 @@
+# git-workflow-pro
+How to use these universal rules.

package/templates/universal/git-workflow-pro/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity GIT WORKFLOW PRO Skill Module
+
+> **"Domain Optimization for GIT WORKFLOW PRO. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for GIT WORKFLOW PRO within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every GIT WORKFLOW PRO implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All GIT WORKFLOW PRO tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/logging-standard/README.md

@@ -0,0 +1,2 @@
+# logging-standard
+How to use these universal rules.

package/templates/universal/logging-standard/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity LOGGING STANDARD Skill Module
+
+> **"Domain Optimization for LOGGING STANDARD. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for LOGGING STANDARD within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every LOGGING STANDARD implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All LOGGING STANDARD tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/logic-flow/README.md

@@ -0,0 +1,2 @@
+# logic-flow
+How to use these universal rules.

package/templates/universal/logic-flow/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity LOGIC FLOW Skill Module
+
+> **"Domain Optimization for LOGIC FLOW. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for LOGIC FLOW within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every LOGIC FLOW implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All LOGIC FLOW tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/performance-audit/README.md

@@ -0,0 +1,2 @@
+# performance-audit
+How to use these universal rules.

package/templates/universal/performance-audit/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity PERFORMANCE AUDIT Skill Module
+
+> **"Domain Optimization for PERFORMANCE AUDIT. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for PERFORMANCE AUDIT within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every PERFORMANCE AUDIT implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All PERFORMANCE AUDIT tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/security-audit/README.md

@@ -0,0 +1,2 @@
+# security-audit
+How to use these universal rules.

package/templates/universal/security-audit/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity SECURITY AUDIT Skill Module
+
+> **"Domain Optimization for SECURITY AUDIT. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for SECURITY AUDIT within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every SECURITY AUDIT implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All SECURITY AUDIT tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/seo-expert/README.md

@@ -0,0 +1,2 @@
+# seo-expert
+How to use these universal rules.

package/templates/universal/seo-expert/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity SEO EXPERT Skill Module
+
+> **"Domain Optimization for SEO EXPERT. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for SEO EXPERT within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every SEO EXPERT implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All SEO EXPERT tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/universal/test-generator/README.md

@@ -0,0 +1,2 @@
+# test-generator
+How to use these universal rules.

package/templates/universal/test-generator/RULE.md

@@ -0,0 +1,33 @@
+# 🧩 Antigravity TEST GENERATOR Skill Module
+
+> **"Domain Optimization for TEST GENERATOR. Efficiency through standards."**
+
+This module provides the core knowledge and technical patterns for TEST GENERATOR within the Antigravity ecosystem.
+
+---
+
+## 🧪 DOMAIN STANDARDS
+
+### 1. Architectural Integrity
+- Every TEST GENERATOR implementation must follow the patterns defined in `CORE.md`.
+- Maintain a clear separation of concerns at all times.
+
+### 2. High-Tier Performance
+- Measure before you optimize.
+- Use native platform optimizations (e.g., hardware acceleration for UI, indexing for DB).
+
+### 3. Verification Protocol
+- All TEST GENERATOR tasks must be validated via the `checklist.py` master script.
+- Ensure 100% type coverage for this domain.
+
+---
+
+## 🛠️ IMPLEMENTATION PATTERNS
+
+- **Standard A**: Precise, modular construction.
+- **Standard B**: Context-aware error handling.
+- **Standard C**: Security-first data flow.
+
+
+
+**By | Janus & Tesavek⚡️👾.**

package/templates/workflows/brainstorm.md

@@ -0,0 +1,47 @@
+---
+description: High-tier Antigravity /brainstorm workflow. Advanced agentic execution for BRAINSTORM.
+---
+
+# 🚀 Antigravity /brainstorm Protocol
+
+> **"Architectural execution in /brainstorm mode. Precision-driven results."**
+
+This slash command triggers the specialized Antigravity protocol for **BRAINSTORM**. Follow this procedure to ensure high-tier outcomes.
+
+---
+
+## 🚦 PHASE 1: PRE-FLIGHT (DISCOVERY)
+
+1. **Invoke Specialist**: Load the relevant Antigravity specialist (e.g., `project-planner` for `/plan`, `debugger` for `/debug`).
+2. **Context Scan**: Re-read the last 5 conversation turns and `ARCHITECTURE.md`.
+3. **Socratic Gate**: Ask 3 critical questions regarding the BRAINSTORM scope.
+
+---
+
+## 🏗️ PHASE 2: EXECUTION (STRATEGIC)
+
+- **Standard A**: Map all affected dependencies before making changes.
+- **Standard B**: Use OS-appropriate commands (PowerShell for Windows).
+- **Standard C**: Apply the Antigravity `clean-code` axioms from `CORE.md`.
+
+---
+
+## ✅ PHASE 3: VERIFICATION (DEFINITION OF DONE)
+
+- [ ] All functions have 100% type coverage.
+- [ ] No regression detected in Core Web Vitals (if UI).
+- [ ] `checklist.py` returns 0 errors.
+- [ ] Documentation updated in `README.md`.
+
+---
+
+## ⚡ USAGE EXAMPLES
+
+```bash
+/brainstorm [target module or description]
+/brainstorm --force --verbose [specific constraints]
+```
+
+
+
+**By | Janus & Tesavek⚡️👾.**