dev-booster 1.0.0

package/README.md

@@ -0,0 +1,203 @@
+# 🦾 Dev Booster
+
+> Drop a production-grade AI governance kit into any project — in one command.
+
+```bash
+npx dev-booster
+```
+
+---
+
+## What it does
+
+**Dev Booster** installs a complete **Agentic Kit** into your project — a structured set of rules, boosters, and skills that supercharge any AI assistant (Gemini, Claude, Copilot, Cursor, etc.) with deep project context and expert behavior.
+
+Unlike generic agent folders, **Dev Booster** uses a manual, activation-first model:
+- boosters are activated intentionally by the user
+- most boosters use lazy loading instead of loading the full kit immediately
+- context is pulled only when the task, artifact, or pain point actually requires it
+- each booster has a distinct operational role, instead of behaving like a generic prompt blob
+
+This gives the kit a stronger product identity and helps avoid unnecessary context bloat.
+
+After running the command, your project gets:
+
+```
+.devbooster/
+├── MANIFEST.md          ← inventory of all agents, skills, and boosters
+├── boosters/            ← 23 expert activators (debug, review, design, deploy...)
+├── hub/                 ← 40+ skills and operational scripts
+└── rules/
+    ├── PROTOCOL.md      ← governance and conduct rules
+    ├── PROJECT.md       ← whitelabel → auto-fills with your architecture
+    ├── FRONTEND.md      ← whitelabel → auto-fills with your frontend stack
+    ├── BACKEND.md       ← whitelabel → auto-fills with your backend stack
+    ├── COMERCIAL.md     ← whitelabel → auto-fills with your business model
+    └── USER_PREFERENCES.md
+DEVBOOSTER_INIT.md                  ← bootstrap orchestrator (read below)
+```
+
+---
+
+## Bootstrap: DEVBOOSTER_INIT.md
+
+After installation, open your AI assistant and say:
+
+> **"Read DEVBOOSTER_INIT.md and execute all bootstrap steps."**
+
+The AI will:
+1. Read your project's architecture, stack, and business logic
+2. Auto-fill all whitelabel rule files with project-specific documentation
+3. Report what it found and flag any gaps it couldn't auto-detect
+
+This process only needs to run once. The `DEVBOOSTER_INIT.md` stays in your project — if you need to re-run after a major architectural change, just ask again.
+
+---
+
+## Boosters
+
+Boosters are expert activators you invoke manually during development.
+
+| Booster | When to use |
+|---|---|
+| `implementation.md` | Selecting the right implementation plan after context is mature |
+| `debug.md` | Systematic root cause analysis |
+| `review.md` | Pre-PR code audit |
+| `design.md` | UI/UX component review |
+| `deploy.md` | Pre-flight deployment checks |
+| `security.md` | Security posture audit |
+| `refactor.md` | Cleaning technical debt |
+| `planning.md` | Validating readiness, risks, and gaps before implementation |
+| `discovery.md` | Product brainstorm |
+| `performance.md` | Core Web Vitals / bundle issues |
+| + 13 more | See `.devbooster/MANIFEST.md` |
+
+The practical activation flow is simple:
+- drag a booster file into the chat
+- send it
+- let the mode activate
+- then send the real task, artifact, or objective
+
+Many boosters now use a two-step flow:
+1. Activate the mode
+2. Provide the real task, context, artifact, or pain point so the booster can load only what it needs
+
+---
+
+## Smart Usage Patterns
+
+One of the main strengths of Dev Booster is that boosters can be used in sequence, not just in isolation.
+
+### 1. Investigate before implementation
+
+Use this when the repository is complex and you do not want the AI to jump straight into coding.
+
+Flow:
+1. `investigation.md`
+2. `planning.md`
+3. `implementation.md`
+4. `review.md`
+
+What this gives you:
+- repository-aware analysis first
+- readiness and risk alignment before execution
+- the right implementation template (`simple`, `standard`, or `heavy`)
+- a stronger validation pass at the end
+
+### 2. Product idea to executable plan
+
+Use this when the idea is still being shaped.
+
+Flow:
+1. `discovery.md`
+2. `planning.md`
+3. `implementation.md`
+
+What this gives you:
+- idea exploration
+- clarification of business rules and gaps
+- a structured path into execution only after the context is mature
+
+### 3. Mature context to technical documentation
+
+Use this after discovery or investigation has already produced enough context.
+
+Flow:
+1. `investigation.md` or `discovery.md`
+2. `documentation.md`
+
+What this gives you:
+- synthesis of the current conversation context
+- confirmation before generation
+- a reusable technical document instead of fragmented chat history
+
+### 4. Safe review in a fresh chat
+
+Use this when you want a stronger validation pass with minimal prior bias.
+
+Flow:
+1. Open a fresh chat
+2. Activate `review.md`
+3. Paste the implementation plan, documentation, diff, or reference
+
+What this gives you:
+- a cleaner validation environment
+- artifact-first review
+- skill/persona loading only after the review target is provided
+
+### 5. Release note generation from real Git state
+
+Use this when you want changelogs based on what actually changed, not on memory.
+
+Flow:
+1. Activate `changelog.md`
+2. If there are uncommitted changes, the booster uses the working tree
+3. If the repo is clean, provide compact input like `3 C`
+
+What this gives you:
+- Git-driven changelog generation
+- three detail levels:
+  - `A` = basic
+  - `B` = hybrid
+  - `C` = technical
+- always includes changed files and changed lines
+
+### 6. Domain mode plus execution mode
+
+Boosters can also be combined by role.
+
+Example flow:
+1. `frontend.md`
+2. `planning.md`
+3. `implementation.md`
+
+This works well when:
+- you know the task belongs to a domain
+- but you still want alignment and execution discipline before building
+
+### 7. Use Advisor when you are unsure
+
+If you do not know which booster should come first:
+1. activate `advisor.md`
+2. describe the task in one message
+3. let it recommend the smallest effective booster path
+
+The advisor recommends boosters only, keeping the path clean and focused.
+
+---
+
+## Requirements
+
+- Node.js >= 20
+
+---
+
+## Credits
+
+Adapted and maintained by [Maikon Rodrigs](https://github.com/MaikonRodrigs).
+
+---
+
+## License
+
+MIT

package/bin/dev-booster.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from '../src/index.js'
+
+run()

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "dev-booster",
+  "version": "1.0.0",
+  "description": "Reusable AI development kit with manual boosters, governance, and project bootstrap",
+  "type": "module",
+  "scripts": {
+    "sync-template": "node ./src/sync-template.js"
+  },
+  "bin": {
+    "dev-booster": "./bin/dev-booster.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "template"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "booster",
+    "agentic",
+    "cursor",
+    "gemini",
+    "claude",
+    "copilot"
+  ],
+  "author": "Maikon Rodrigs",
+  "homepage": "https://github.com/MaikonRodrigs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaikonRodrigs/dev-booster.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MaikonRodrigs/dev-booster/issues"
+  },
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,78 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+// Source: the `template/` folder shipped inside the npm package
+const TEMPLATE_DIR = path.resolve(__dirname, '..', 'template')
+
+// Destination: the user's current working directory (where they ran npx)
+const TARGET_DIR = process.cwd()
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true })
+
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === '.DS_Store') continue
+
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath)
+    } else {
+      fs.copyFileSync(srcPath, destPath)
+    }
+  }
+}
+
+export function run() {
+  console.log(`
+╭──────────────────────────────────────────────╮
+│               DEV BOOSTER                    │
+│        instalador do kit agentico           │
+╰──────────────────────────────────────────────╯
+`)
+
+  // 1. Copy the full .devbooster/ kit to the user's project
+  const agentSrc = path.join(TEMPLATE_DIR, '.devbooster')
+  const agentDest = path.join(TARGET_DIR, '.devbooster')
+
+  if (fs.existsSync(agentDest)) {
+    console.log('▸ .devbooster/')
+    console.log('  status: ja existe no projeto')
+    console.log('  acao: copia ignorada para evitar sobrescrita')
+    console.log('  dica: renomeie ou remova a pasta se quiser reinstalar\n')
+  } else {
+    copyDir(agentSrc, agentDest)
+    console.log('▸ .devbooster/')
+    console.log('  status: instalado com sucesso\n')
+  }
+
+  // 2. Drop DEVBOOSTER_INIT.md at the root of the user's project
+  const initSrc = path.join(TEMPLATE_DIR, 'DEVBOOSTER_INIT.md')
+  const initDest = path.join(TARGET_DIR, 'DEVBOOSTER_INIT.md')
+
+  if (fs.existsSync(initDest)) {
+    console.log('▸ DEVBOOSTER_INIT.md')
+    console.log('  status: ja existe no projeto')
+    console.log('  acao: criacao ignorada\n')
+  } else {
+    fs.copyFileSync(initSrc, initDest)
+    console.log('▸ DEVBOOSTER_INIT.md')
+    console.log('  status: criado na raiz do projeto\n')
+  }
+
+  console.log(`
+╭──────────────────────────────────────────────╮
+│                 PROXIMO PASSO                │
+╰──────────────────────────────────────────────╯
+
+Abra sua LLM / assistente de IA neste projeto e envie:
+
+  "Leia o DEVBOOSTER_INIT.md e execute todos os passos de bootstrap."
+
+O kit vai se configurar com base no stack do projeto.
+`)
+}

package/src/sync-template.js

@@ -0,0 +1,55 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ROOT_DIR = path.resolve(__dirname, '..')
+const SOURCE_DIR = path.join(ROOT_DIR, '.devbooster')
+const TEMPLATE_DIR = path.join(ROOT_DIR, 'template')
+const TEMPLATE_KIT_DIR = path.join(TEMPLATE_DIR, '.devbooster')
+const INIT_FILE = 'DEVBOOSTER_INIT.md'
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true })
+
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === '.DS_Store') continue
+
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath)
+    } else {
+      fs.copyFileSync(srcPath, destPath)
+    }
+  }
+}
+
+function ensureExists(targetPath, label) {
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`${label} not found: ${targetPath}`)
+  }
+}
+
+function run() {
+  ensureExists(SOURCE_DIR, 'Source kit')
+  ensureExists(path.join(ROOT_DIR, INIT_FILE), 'Root init file')
+
+  fs.mkdirSync(TEMPLATE_DIR, { recursive: true })
+  fs.rmSync(TEMPLATE_KIT_DIR, { recursive: true, force: true })
+  copyDir(SOURCE_DIR, TEMPLATE_KIT_DIR)
+  fs.copyFileSync(path.join(ROOT_DIR, INIT_FILE), path.join(TEMPLATE_DIR, INIT_FILE))
+
+  console.log('╭──────────────────────────────────────────────╮')
+  console.log('│          DEV BOOSTER TEMPLATE SYNC          │')
+  console.log('╰──────────────────────────────────────────────╯')
+  console.log('')
+  console.log('▸ origem: .devbooster/')
+  console.log('▸ destino: template/.devbooster/')
+  console.log(`▸ init: template/${INIT_FILE}`)
+  console.log('')
+  console.log('status: sync concluido com sucesso')
+}
+
+run()

package/template/.devbooster/MANIFEST.md

@@ -0,0 +1,177 @@
+# 🦾 MASTER AGENTIC HUB MANIFEST (EXHAUSTIVE V2)
+
+> [!IMPORTANT]
+> **This file is the canonical local inventory for this repository.**
+> Paths below assume the Dev Booster repository structure: `.devbooster/` for runtime rules and `.devbooster/hub/` for reusable assets.
+
+**Inventory File:** `.devbooster/MANIFEST.md`
+**Repository Root:** Use this repository root directly.
+**Role:** Inventory of Dev Booster capabilities — Personas, Skills, Boosters, Workflows, and Scripts.
+**Credits:** Adapted and maintained by [Maikon Rodrigs](https://github.com/MaikonRodrigs).
+
+---
+
+## 👥 1. SPECIALIZED AGENTS (PERSONAS)
+
+### Core Engineering
+- `agent_frontend-specialist`: Next.js, React, UI/UX Logic expert.
+- `agent_backend-specialist`: Node.js, tRPC, PostgreSQL, Prisma architect.
+- `agent_database-architect`: Complex schemas, migrations, query optimization.
+- `agent_debugger`: Deep root cause analysis and logical fix generation.
+- `agent_performance-optimizer`: Core Web Vitals, bundle size, expensive operations.
+- `agent_explorer-agent`: Deep codebase analysis, structural mapping, and reverse engineering.
+
+### Architecture & Strategy
+- `agent_project-planner`: Context consolidation, risk mapping, and readiness validation before implementation.
+- `agent_orchestrator`: Management of multiple agents for high-complexity tasks.
+- `agent_product-owner`: Business rules, user value, and monetization logic.
+- `agent_product-manager`: Product lifecycle, requirements, and discovery.
+
+### Quality & Infrastructure
+- `agent_test-engineer`: Unit/Integration tests, AAA patterns.
+- `agent_qa-automation-engineer`: E2E (Playwright/Cypress) and CI testing.
+- `agent_devops-engineer`: VPS, Linux, Docker, Deployment, Server management.
+- `agent_security-auditor`: Security logic, auth bypass, and PII protection.
+- `agent_penetration-tester`: Vulnerability hunting and red team simulation.
+
+### Specialized Domains
+- `agent_mobile-developer`: React Native, Expo, and Responsive Mobile logic.
+- `agent_game-developer`: Game engines, physics, and gameplay loops.
+- `agent_seo-specialist`: Search engine indexation and semantic HTML.
+- `agent_code-archaeologist`: Legacy code analysis and refactoring safety.
+- `agent_documentation-writer`: Technical manual generation and global docs.
+
+---
+
+## 🛠️ 2. TECHNICAL SKILL MATRIX (DENSE KNOWLEDGE)
+
+### Frontend & UI/UX
+- `skill_ui-ux-pro-max`: Premium UI Bible (50 styles, 21 palettes, 50 fonts).
+- `skill_frontend-design`: The "Anti-Generic" design patterns and system tokens.
+- `skill_react-best-practices`: 57+ Vercel rules for React & Next.js performance.
+- `skill_web-design-guidelines`: UX Audit (100+ rules for accessibility & Web Vitals).
+- `skill_tailwind-patterns`: Atomic CSS v4 and modern utility-first systems.
+- `skill_mobile-design`: Specialized Mobile UX and touch patterns.
+
+### Backend, API & Database
+- `skill_nodejs-best-practices`: Node.js async, modules, and error handling.
+- `skill_api-patterns`: REST, GraphQL, tRPC, and contract-first design.
+- `skill_nestjs-expert`: NestJS modules, DI, and enterprise patterns.
+- `skill_python-patterns`: FastAPI, automation, and AI pipelines.
+- `skill_database-design`: Schema optimization and indexing strategy.
+- `skill_prisma-expert`: Prisma ORM, migrations, and deep relationships.
+
+### Architecture & Quality
+- `skill_architecture`: Clean Architecture, Hexagonal, and SOLID principles.
+- `skill_clean-code`: Global standards for readable/maintainable code.
+- `skill_app-builder`: Full-stack scaffolding and rapid prototyping.
+- `skill_plan-writing` / `skill_brainstorming`: Discovery and Socratic task planning.
+- `skill_testing-patterns`: Jest, Vitest, and AAA testing strategies.
+- `skill_webapp-testing`: E2E mastery (Playwright/Cypress).
+- `skill_tdd-workflow`: Test-driven development implementation.
+- `skill_code-review-checklist`: Code quality standards and PR audit rules.
+- `skill_lint-and-validate`: Universal linting and static analysis.
+
+### Security, DevOps & Cloud
+- `skill_vulnerability-scanner`: OWASP Top 10 auditing and secret detection.
+- `skill_red-team-tactics`: Offensive security and threat modeling.
+- `skill_docker-expert`: Containerization, Compose, and orchestration.
+- `skill_deployment-procedures`: Release safety and CI/CD workflows.
+- `skill_server-management` / `skill_bash-linux`: VPS and Shell mastery.
+
+### Specialized Tools & Growth
+- `skill_intelligent-routing`: Autonomous agent selection and task routing logic.
+- `skill_typescript-expert`: Type-level programming and performance.
+- `skill_rust-pro`: Memory safety and performance-critical module development.
+- `skill_mcp-builder`: Model Context Protocol component mastery.
+- `skill_parallel-agents`: Multi-agent orchestration logic.
+- `skill_seo-fundamentals`: E-E-A-T and semantic HTML compliance.
+- `skill_geo-fundamentals`: GenAI Optimization (AI Citations Readiness).
+- `skill_i18n-localization`: Global strings and internationalization patterns.
+- `skill_game-development`: Mechanics, logic, and state management.
+- `skill_systematic-debugging`: Root cause analysis and hypothesis engine.
+- `skill_doc`: Technical writing standards and semantic documentation guide.
+
+---
+
+## 🚀 3. BOOSTER ACTIVATORS (CURRENT KIT)
+*All boosters live at: `.devbooster/boosters/`*
+
+| Booster | Purpose |
+|---|---|
+| `create.md` | Master Architect — builds new features and apps with structural scaffolding. |
+| `performance.md` | Performance Engineer — optimizes loading speed and Core Web Vitals. |
+| `i18n.md` | Localization Specialist — handles internationalization and translations. |
+| `accessibility.md` | Accessibility Auditor — ensures WCAG compliance and semantic HTML. |
+| `refactor.md` | Quality Lead — refactors code, applies Clean Code/SOLID, and clears technical debt. |
+| `implementation.md` | Reviews context, selects `simple` / `standard` / `heavy`, and asks for confirmation before generating the plan. |
+| `documentation.md` | Generates the 17-section universal technical documentation spec. |
+| `atomic.md` | Surgical, single-step implementation spec (final execution stage). |
+| `advisor.md` | Hub Consultant — recommends the best booster path for the user's task. |
+| `review.md` | Elite Auditor — multi-agent orchestration for plan validation. |
+| `debug.md` | Systematic Root Cause Analysis with hypothesis engine. |
+| `discovery.md` | Strategic Product Consultant — 3-path brainstorm protocol. |
+| `investigation.md` | Context Pre-Orchestrator — no-code analysis before implementation. |
+| `design.md` | UI/UX Design standards and component audit. |
+| `deploy.md` | Pre-flight checks and deployment execution protocol. |
+| `security.md` | Security posture audit and threat modeling. |
+| `testing.md` | Test generation strategy and runner coordination. |
+| `changelog.md` | Structured release note and changelog generation. |
+| `planning.md` | Consolidates context, maps risks/gaps, and validates whether the task is ready for implementation. |
+| `frontend.md` | Frontend specialist activation with stack-specific rules. |
+| `backend.md` | Backend specialist activation with API/DB constraints. |
+| `seo.md` | SEO audit and semantic HTML compliance check. |
+| `mobile.md` | Mobile UX activation (React Native / Expo patterns). |
+
+---
+
+## 🏗️ 4. OPERATIONAL SCRIPTS
+*Canonical path: `.devbooster/hub/scripts/`*
+
+### 🔍 Core Validation & Quality
+- **`checklist.py`**: Priority-based validation (Security, Lint, Schema, UX, SEO). **MANDATORY FOR DEV.**
+- **`verify_all.py`**: The definitive pre-release Master Check (Lighthouse, E2E, i18n).
+- **`react_performance_checker.py`**: Waterfall and barrel import audit.
+- **`lighthouse_audit.py`**: Performance web (LCP, FID, CLS, SEO).
+- **`type_coverage.py`**: Coverage analysis (TS/Python) and `any` detection.
+- **`lint_runner.py`**: Unified interface for ESLint, TSC, Ruff, Mypy.
+- **`test_runner.py`**: Universal executor (Vitest, Jest, Pytest).
+
+### 🎨 UX & Mobile Intelligence
+- **`ux_audit.py`**: Psychology of design audit (Hick, Fitts) and UX rules.
+- **`mobile_audit.py`**: 50+ Mobile-specific checks (Touch targets, haptics).
+- **`accessibility_checker.py`**: WCAG compliance and semantic audit.
+- **`i18n_checker.py`**: Detection of hardcoded strings and missing translations.
+
+### 🛡️ Security & Database
+- **`security_scan.py`**: Secrets, tokens, and dangerous code patterns.
+- **`api_validator.py`**: API contract validation (OpenAPI/Swagger).
+- **`schema_validator.py`**: Database integrity (Prisma/Drizzle/SQL).
+
+### 🤖 AI Ready & Ops
+- **`geo_checker.py`**: "AI Citations Readiness" (Schema.org, FAQ).
+- **`seo_checker.py`**: Deep SEO audit (Meta, Semantics, Indexability).
+- **`playwright_runner.py`**: E2E Health checks with headless screenshots.
+- **`session_manager.py`**: Rapid tech stack analysis and file-level statistics.
+- **`auto_preview.py`**: Automated dev server lifecycle management.
+- **`convert_rules.py`**: Agent rule transformation and standardization.
+
+---
+
+## 📊 5. KIT STATISTICS
+
+| Metric | Value |
+|---|---|
+| **Total Agents** | 20 |
+| **Total Skills** | 40+ |
+| **Master Boosters** | 23 |
+| **Operational Scripts** | 2 (Master) + 21 (Skill-level) |
+| **Coverage** | ~95% Full-stack Web/Mobile |
+
+---
+
+## ⚡ 6. NAVIGATION GUIDELINE
+When the user asks "How can the kit help?", the Advisor MUST:
+1. Scan requirements.
+2. Recommend the best **Booster** entry point for the task.
+3. Suggest supporting boosters only when the task clearly spans multiple phases or domains.

package/template/.devbooster/boosters/accessibility.md

@@ -0,0 +1,63 @@
+# ♿ BOOSTER: ACCESSIBILITY AUDITOR (EXPERT)
+You are the Accessibility Auditor. Your goal is to ensure WCAG compliance and semantic integrity.
+
+## 00. DEV BOOSTER ACTIVATION CONTRACT
+This booster behaves as a Dev Booster mode, not as an automatic execution order.
+
+If the user invokes this booster alone, or uses it only to activate the mode:
+- Do NOT start analysis, planning, implementation, or review automatically.
+- Do NOT assume there is already a task to execute.
+- Do NOT load the full context package yet.
+- Only confirm activation, expose the available mastery domain, and wait for the next instruction.
+- The activation response must follow the global language configured for the active LLM/environment.
+
+Use this activation response format:
+
+```md
+## 🤖 [DEV BOOSTER // ACCESSIBILITY]
+
+[Localized mode label]: Accessibility Auditor
+[Localized status label]: Armed
+
+[Localized master skills label]:
+- Web design guidelines
+- Frontend design
+- Accessibility auditing
+```
+
+Formatting rules for this activation:
+- `Mode` and `Status` must always be rendered on separate lines.
+- Do NOT merge labels into a single sentence or paragraph.
+- Keep each activation block on its own line.
+
+Only switch to execution mode when the user provides a concrete accessibility concern, WCAG issue, audit target, semantic problem, or inclusive UX objective.
+
+## 0.1 INITIAL LOAD STRATEGY
+When the first real accessibility request arrives:
+- Read the user's pain, target, or desired outcome.
+- Infer which minimum set of personas and skills is necessary.
+- Load only the assets required for that first response.
+
+Examples:
+- If the pain is semantics, contrast, or keyboard navigation, prioritize web design guidelines.
+- If the pain is tied to interface composition or interaction states, add frontend design support.
+
+## 0.2 PROGRESSIVE REINFORCEMENT
+This booster may progressively load more assets during execution, but only from its allowed accessibility inventory.
+
+Rules:
+- Start with the minimum viable context.
+- Expand only when the current task clearly demands more depth.
+- Keep the user inside the same booster mode while expanding context.
+
+## 1. ALLOWED INVENTORY
+- `.devbooster/hub/skills/web-design-guidelines`
+- `.devbooster/hub/skills/frontend-design`
+- `agent_frontend-specialist`
+
+## 2. ACCESSIBILITY PROTOCOL
+1.  **Audit**: Check semantic HTML, ARIA labels, and keyboard navigation.
+2.  **Contrast**: Verify color contrast ratios and focus states.
+3.  **Remediation**: Apply fixes for screen reader compatibility and WCAG 2.1 standards.
+
+**Reply:** On activation only, use the armed-mode banner above. On the first real task, load the minimum required accessibility context based on the user's pain, then execute.