dev-booster 1.10.0 → 1.11.0

package/README.md

@@ -32,7 +32,7 @@ After running the command, your project gets:
 ```
 .devbooster/
 ├── MANIFEST.md          ← inventory of all agents, skills, and boosters
-├── boosters/            ← 26 expert activators (debug, review, design, deploy...)
+├── boosters/            ← 28 expert activators (debug, review, design, deploy...)
 ├── hub/                 ← 40+ skills and operational scripts
 └── rules/
     ├── PROTOCOL.md      ← governance and conduct rules
@@ -110,7 +110,7 @@ Boosters are expert activators you invoke manually during development.
 | `discovery.md` | Product brainstorm |
 | `performance.md` | Core Web Vitals / bundle issues |
 | `code-audit.md` | Strict Code Auditor (Syntax, React Doctor) before PR |
-| + 14 more | See `.devbooster/MANIFEST.md` |
+| + 16 more | See `.devbooster/MANIFEST.md` |
 
 The practical activation flow is simple:
 - drag a booster file into the chat
@@ -136,13 +136,26 @@ Files are systematically organized in the `@booster-generated/` root directory:
 - `@booster-generated/troubleshooting/` (Systematic RCA and bug fix logs)
 - `@booster-generated/audits/` (Security, accessibility, and performance reports)
 
-### Manual Triggers
+### Manual & Shortcut Triggers
 
-While the AI updates these files automatically, you can also take manual control at any time using explicit Chat Triggers:
+You can take manual control of the kit's governance or instantly route behavior modes at any time using explicit Chat Triggers:
 
-- **`@SaveState`**: Forces the AI to instantly summarize the current conversation context and update the active booster's state file. Perfect for explicitly bookmarking complex decisions before continuing in a fresh chat.
+#### 👥 Governance Triggers
+- **`@SaveState`**: Forces the AI to instantly summarize the current conversation context and update the active booster's state file under `@booster-generated/`.
 - **`@SavePattern`**: Instructs the AI to extract a newly resolved technical rule or code pattern and persist it to `.devbooster/rules/USER_PREFERENCES.md`.
-- **`@LogTask`**: Tells the AI to capture a pending technical task mentioned in the chat and document it systematically in your operational backlog at `@booster-generated/tasks.md`.
+- **`@LogTask`**: Tells the AI to capture a pending technical task and document it systematically in your backlog at `@booster-generated/tasks.md`.
+
+#### ⚡ Booster Shortcut Triggers
+Instead of dragging booster files into the chat, you can instantly activate any booster behavior contract by typing its shortcut trigger:
+- **`@Context`** ➔ Activates `context.md` (Silent Sponge context mapping).
+- **`@Coder`** ➔ Activates `coder.md` (Co-Creative design/writing).
+- **`@Builder`** ➔ Activates `builder.md` (Senior plan audit & execution).
+- **`@Planning`** ➔ Activates `planning.md` (Readiness check).
+- **`@Implementation`** ➔ Activates `implementation.md` (Plan sizing & generation).
+- **`@Atomic`** ➔ Activates `atomic.md` (Surgical step-by-step writing).
+- **`@Review`** ➔ Activates `review.md` (Elite code audit).
+- **`@Advisor`** ➔ Activates `advisor.md` (Kit GPS consultant).
+- *See `.devbooster/rules/TRIGGERS.md` for the complete trigger list.*
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dev-booster",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Reusable AI development kit with manual boosters, governance, and project bootstrap",
   "type": "module",
   "scripts": {

package/src/index.js

@@ -36,6 +36,44 @@ const IDE_BRIDGE_TARGETS = [
   '.github/copilot-instructions.md',
 ]
 
+const PROTECTED_FILES = [
+  'DEVBOOSTER_INIT.md',
+  '.devbooster/rules/PROJECT.md',
+  '.devbooster/rules/FRONTEND.md',
+  '.devbooster/rules/BACKEND.md',
+  '.devbooster/rules/COMMERCIAL.md',
+  '.devbooster/rules/USER_PREFERENCES.md',
+]
+
+function safeCopyFile(src, dest, dryRun = false) {
+  const relativeDest = path.relative(TARGET_DIR, dest)
+  if (fs.existsSync(dest) && PROTECTED_FILES.includes(relativeDest)) {
+    return false // Preserved
+  }
+  if (!dryRun) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true })
+    fs.copyFileSync(src, dest)
+  }
+  return true // Copied/Updated
+}
+
+function copyDirSafe(src, dest, dryRun = false) {
+  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()) {
+      copyDirSafe(srcPath, destPath, dryRun)
+    } else {
+      safeCopyFile(srcPath, destPath, dryRun)
+    }
+  }
+}
+
 function copyDir(src, dest) {
   fs.mkdirSync(dest, { recursive: true })
 
@@ -192,33 +230,47 @@ async function runInstall() {
   printHeader('agentic kit installer')
   if (dryRun) console.log('🔍 [DRY RUN MODE] No real changes will be made.\n')
 
-  // 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: already exists in this project')
-    console.log('  action: copy skipped to avoid overwrite')
-    console.log('  tip: rename or remove the folder if you want a fresh install\n')
+  const boostersCount = fs.existsSync(path.join(agentSrc, 'boosters')) 
+    ? fs.readdirSync(path.join(agentSrc, 'boosters')).filter(f => f !== '.DS_Store' && f !== 'templates').length 
+    : 28
+  const hubCount = fs.existsSync(path.join(agentSrc, 'hub', 'scripts'))
+    ? fs.readdirSync(path.join(agentSrc, 'hub', 'scripts')).filter(f => f !== '.DS_Store').length
+    : 21
+
+  const isOverlap = fs.existsSync(agentDest)
+
+  if (isOverlap) {
+    console.log('▸ Existing Kit Detected:')
+    console.log(`  ├── boosters/     ➔ ${boostersCount} expert activators updated successfully`)
+    console.log(`  ├── hub/          ➔ ${hubCount} operational scripts updated successfully`)
+    console.log('  └── rules/        ➔ Core rules updated, project rules preserved')
+    console.log('                    ✔ PROTOCOL.md  (updated)')
+    console.log('                    ✔ GUIDE.md     (updated)')
+    console.log('                    ✔ TRIGGERS.md  (updated)')
+    console.log('                    ℹ PROJECT.md, FRONTEND.md, BACKEND.md, etc. (preserved)\n')
   } else {
-    if (!dryRun) copyDir(agentSrc, agentDest)
-    console.log('▸ .devbooster/')
-    console.log(`  status: ${dryRun ? 'would be installed' : 'installed successfully'}\n`)
+    console.log('▸ Installing Kit Structure:')
+    console.log(`  ├── boosters/     ➔ ${boostersCount} expert activators created successfully`)
+    console.log(`  ├── hub/          ➔ ${hubCount} operational scripts created successfully`)
+    console.log('  └── rules/        ➔ Core rules and templates initialized')
+    console.log('                    ✔ 8 rules created\n')
   }
 
-  // 2. Drop DEVBOOSTER_INIT.md at the root of the user's project
+  copyDirSafe(agentSrc, agentDest, dryRun)
+
+  // 2. Drop DEVBOOSTER_INIT.md at the root of the user's project safely
   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: already exists in this project')
-    console.log('  action: creation skipped\n')
-  } else {
-    if (!dryRun) fs.copyFileSync(initSrc, initDest)
-    console.log('▸ DEVBOOSTER_INIT.md')
+  const copiedInit = safeCopyFile(initSrc, initDest, dryRun)
+  console.log('▸ DEVBOOSTER_INIT.md')
+  if (copiedInit) {
     console.log(`  status: ${dryRun ? 'would be created' : 'created'} at project root\n`)
+  } else {
+    console.log('  status: already exists (preserved)\n')
   }
 
   await maybeAddDevBoosterToGitignore(dryRun)
@@ -252,40 +304,44 @@ function runUpdate() {
     return
   }
 
+  const boostersCount = fs.existsSync(path.join(templateRoot, 'boosters')) 
+    ? fs.readdirSync(path.join(templateRoot, 'boosters')).filter(f => f !== '.DS_Store' && f !== 'templates').length 
+    : 28
+  const hubCount = fs.existsSync(path.join(templateRoot, 'hub', 'scripts'))
+    ? fs.readdirSync(path.join(templateRoot, 'hub', 'scripts')).filter(f => f !== '.DS_Store').length
+    : 21
+
+  // 1. Sync boosters and hub (fully wiped and overwritten)
   const updateTargets = [
     { name: 'boosters', src: path.join(templateRoot, 'boosters'), dest: path.join(kitRoot, 'boosters') },
     { name: 'hub', src: path.join(templateRoot, 'hub'), dest: path.join(kitRoot, 'hub') },
   ]
 
-  const coreFiles = [
-    { name: 'MANIFEST.md', src: path.join(templateRoot, 'MANIFEST.md'), dest: path.join(kitRoot, 'MANIFEST.md') },
-    { name: 'rules/GUIDE.md', src: path.join(templateRoot, 'rules', 'GUIDE.md'), dest: path.join(kitRoot, 'rules', 'GUIDE.md') },
-    { name: 'rules/PROTOCOL.md', src: path.join(templateRoot, 'rules', 'PROTOCOL.md'), dest: path.join(kitRoot, 'rules', 'PROTOCOL.md') },
-  ]
+  console.log('▸ Updating Kit Core:')
 
   for (const target of updateTargets) {
     if (!dryRun) syncDir(target.src, target.dest)
-    console.log(`▸ .devbooster/${target.name}/`)
-    console.log(`  status: ${dryRun ? 'would be updated' : 'updated successfully'}`)
-  }
-
-  for (const file of coreFiles) {
-    if (!dryRun && fs.existsSync(file.src)) {
-      fs.mkdirSync(path.dirname(file.dest), { recursive: true })
-      fs.copyFileSync(file.src, file.dest)
-    }
-    console.log(`▸ .devbooster/${file.name}`)
-    console.log(`  status: ${dryRun ? 'would be updated' : 'updated successfully'}`)
   }
+  console.log(`  ├── boosters/     ➔ ${boostersCount} expert activators synced & updated`)
+  console.log(`  ├── hub/          ➔ ${hubCount} operational scripts synced & updated`)
+
+  // 2. Safe-copy rules directory recursively (overwriting core rules, preserving custom ones)
+  const rulesSrc = path.join(templateRoot, 'rules')
+  const rulesDest = path.join(kitRoot, 'rules')
+  copyDirSafe(rulesSrc, rulesDest, dryRun)
+  
+  // 3. Safe-copy core files
+  safeCopyFile(path.join(templateRoot, 'MANIFEST.md'), path.join(kitRoot, 'MANIFEST.md'), dryRun)
+  
+  console.log('  ├── MANIFEST.md   ➔ Inventory updated')
+  console.log('  └── rules/        ➔ Core rules updated, customized rules preserved')
+  console.log('                    ✔ PROTOCOL.md  (updated)')
+  console.log('                    ✔ GUIDE.md     (updated)')
+  console.log('                    ✔ TRIGGERS.md  (updated)')
+  console.log('                    ℹ Whitelabel stack rules (preserved)\n')
 
-  console.log('')
-  console.log('▸ rules/ (Whitelabel files)')
-  console.log('  status: preserved')
-  console.log('  action: user-customized rules were not overwritten')
-  console.log('')
   console.log('▸ DEVBOOSTER_INIT.md')
-  console.log('  status: preserved')
-  console.log('  action: no local files were overwritten\n')
+  console.log('  status: preserved (no changes made)\n')
 
   console.log(`
 ╭──────────────────────────────────────────────╮

package/template/.devbooster/MANIFEST.md

@@ -125,6 +125,8 @@
 | `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). |
+| `builder.md` | Builder Specialist — executes implementation plans and writes actual code. |
+| `coder.md` | Co-Creative Coder — debates folder patterns and code design, writes code only under command. |
 
 ---
 
@@ -167,7 +169,7 @@
 |---|---|
 | **Total Agents** | 20 |
 | **Total Skills** | 40+ |
-| **Master Boosters** | 24 |
+| **Master Boosters** | 26 |
 | **Operational Scripts** | 2 (Master) + 21 (Skill-level) |
 | **Coverage** | ~95% Full-stack Web/Mobile |
 
@@ -189,7 +191,8 @@ Dev Booster acts as a continuous document generator. As boosters execute, they M
 ### Artifact Mapping by Domain:
 - `@booster-generated/contexts/` → Managed by `context.md` (Save State for conversation continuity).
 - `@booster-generated/plans/` → Managed by `planning.md` (Implementation roadmap and risk mapping).
-- `@booster-generated/implementations/` → Managed by `frontend.md`, `backend.md`, `mobile.md`, `atomic.md`.
+- `@booster-generated/implementations/` → Managed by `frontend.md`, `backend.md`, `mobile.md`, `atomic.md`, `builder.md`.
+- `@booster-generated/coder/` → Managed by `coder.md` (Design discussions and incremental coding logs).
 - `@booster-generated/advisory/` → Managed by `advisor.md` (Architectural decisions and mentorship notes).
 - `@booster-generated/discoveries/` → Managed by `investigation.md`, `discovery.md` (Brainstorms, flow mapping).
 - `@booster-generated/troubleshooting/` → Managed by `debug.md` (Root Cause Analysis and bug fixes).

package/template/.devbooster/boosters/advisor.md

@@ -62,6 +62,7 @@ Analyze the user's request or the current task and recommend only the best boost
 - Be proactive and strategic.
 - Explain WHY the recommended booster is the right entry point.
 - Respond only with booster recommendations.
+- For every recommended booster, provide both its file path (e.g., `.devbooster/boosters/planning.md`) AND its corresponding shortcut trigger (e.g., `@Planning`) from `.devbooster/rules/TRIGGERS.md` so the developer can choose how to activate it.
 - Do NOT expose skills, personas, or agents in the user-facing answer.
 - Do NOT execute any plan, only advise.
 

package/template/.devbooster/boosters/builder.md

@@ -0,0 +1,65 @@
+# 👷 BOOSTER: BUILDER & SENIOR DEVELOPER (EXECUTION)
+You are the Senior Software Developer (Execution Specialist). Your mission is to audit the provided implementation plan against the codebase for gaps, missing treatments, and edge cases, align with the developer, and then execute the plan step-by-step with absolute technical discipline.
+
+## 0. DEV BOOSTER ACTIVATION CONTRACT
+This booster is an execution engine. It expects a concrete implementation plan, instruction file, or detailed prompt as input.
+
+### ROUTE A: ARMED ACTIVATION (No plan provided yet)
+If invoked alone or without specific implementation instructions:
+- Do NOT start modifying files or analyzing code.
+- Confirm activation using the format below and wait for the target plan or file path to execute.
+
+Use this activation response format:
+
+```md
+## 🤖 [DEV BOOSTER // BUILDER]
+
+Mode: Builder / Senior Developer
+Status: Armed & Awaiting Plan
+
+Capabilities:
+- Audits implementation plans for technical gaps, edge cases, and missing treatments
+- Translates validated plans into production-grade code
+- Enforces strict coding standards and error handling
+```
+
+### ROUTE B: DIRECT EXECUTION (Plan path or contents provided)
+If invoked with a specific plan (e.g., "Execute the plan at implementation/my-task.md"):
+- Ignore the activation response banner.
+- Immediately start the **PRE-EXECUTION SANITY CHECK & AUDIT (Section 1)**.
+
+## 0.1 INITIAL LOAD STRATEGY
+Upon receiving the plan or execution instructions:
+1. Read the plan fully to understand the scope and files involved.
+2. Load stack-specific rules from `.devbooster/rules/` (`rules/PROJECT.md`, `rules/FRONTEND.md`, `rules/BACKEND.md`, and/or `rules/USER_PREFERENCES.md`).
+3. Read the persona inventory in `.devbooster/MANIFEST.md` under Section 1 (Specialized Agents), identify the best-matching specialist personas for the target plan, and load their corresponding files.
+
+## 1. PRE-EXECUTION SANITY CHECK & AUDIT (MANDATORY GATE)
+Before writing ANY code, you must perform a senior audit of the plan against the active codebase:
+1. **Identify Gaps & Edge Cases:** Look for missing UX treatments (e.g., missing loading states, missing toast notifications, missing validation alerts), unhandled errors, database constraint conflicts, or folder pattern mismatches.
+2. **Present the Sanity Audit:** Return a concise, bulleted review of your findings to the user:
+   - **Gaps Detected:** (Specific missing items, e.g., "No error toast defined for route X").
+   - **Risks/Conflicts:** (Potential build or logic breakages).
+   - **Proposed Patches:** (Slight adjustments to fix these gaps during code generation).
+3. **Wait for Approval:** Do NOT write code yet. Ask: *"Would you like me to proceed with the implementation including these senior adjustments?"*.
+
+## 2. CHAT CHECKLIST & IMUTABILITY RULES
+Once the plan is approved by the user:
+- **IMMUTABLE SPECIFICATION:** Treat the approved plan as an immutable specification. Do NOT summarize, paraphrase, or re-explain the plan in the chat.
+- **INTERACTIVE TO-DO CHECKLIST:** At the beginning of the execution phase, output a simple `[ ]` markdown checklist representing the steps of the plan in the chat.
+- **PROGRESS TRACKING:** As you complete each task, output the updated checklist, marking completed tasks with `[x]`. This ensures both you and the developer stay aligned without writing progress files to disk.
+
+## 3. SENIOR CODING STANDARDS & DISCIPLINE (THE DEV BIBLE)
+- **TARGETED FILE READS:** Do NOT read very large files (e.g., 500+ lines) entirely. Use search tools/grep to locate the exact insertion points or code segments, and read only the target sections needed to understand local context.
+- **SURGICAL PRECISION:** Modify only the files listed in the scope. Preserve all existing logic, helpers, hooks, and services unless explicitly instructed to replace them.
+- **NO PLACEHOLDERS:** Write complete, production-ready, clean code. Do NOT leave comments like `// TODO: implement this` or incomplete code blocks.
+- **TYPE SAFETY & QUALITY:** Enforce strict typing (no `any` types), proper error boundaries, sanitization, and async error handling based on the stack guidelines.
+- **SCOPE RESTRICTION:** Implement ONLY what is specified in the plan. Do NOT perform unsolicited refactoring or add out-of-scope files.
+
+## 4. STEP-BY-STEP EXECUTION PROTOCOL
+For each step in the checklist:
+1. **Target Segment Read:** Search and read the target lines of the file to modify.
+2. **Implementation Pass:** Apply the changes surgically. Use the correct project imports and file patterns.
+3. **Internal Verification:** Verify imports, syntax correctness, and structure.
+4. **Update Checklist:** Output the updated checklist in the chat and move to the next item.
+5. **Post-Implementation Verification (Final Step):** After all checklist items are completed, execute or suggest execution of the stack verification commands (e.g., `npm run build`, `npm run lint`, `npx tsc --noEmit` or stack equivalents) to ensure the project has a 100% clean build.

package/template/.devbooster/boosters/coder.md

@@ -0,0 +1,50 @@
+# 💻 BOOSTER: CO-CREATIVE CODER & ARCHITECT
+You are the Co-Creative Coder and Software Architect. Your goal is to debate ideas, discuss folder structures, evaluate separation of concerns, and implement code incrementally and creatively, adapting to the project's stack while keeping full control in the developer's hands.
+
+## 0. DEV BOOSTER ACTIVATION CONTRACT
+This booster uses a lazy loading strategy to prevent context bloat.
+
+### ROUTE A: DISCUSSION ACTIVATION (Only `@Coder` or simple activation)
+If the user invokes this booster to start a conversation or uses the `@Coder` trigger without a direct code modification command:
+- Do NOT load detailed frontend/backend rules or engineering personas yet.
+- Read ONLY `.devbooster/rules/PROJECT.md` to identify the project's basic ecosystem.
+- Confirm activation using the format below and wait for the user's questions or design ideas.
+
+Use this activation response format:
+
+```md
+## 🤖 [DEV BOOSTER // CODER]
+
+Mode: Co-Creative Coder
+Status: Listening & Armed
+
+Capabilities:
+- Debates folder structures, design patterns, and separation of concerns
+- Reads stack definitions from PROJECT.md
+- Awaiting your architectural questions or explicit write instructions
+```
+
+### ROUTE B: DIRECT ACTION ACTIVATION ("change this and use @Coder" or direct command)
+If the user gives an explicit code modification command (e.g. "change this for me and use @Coder", or `@Coder implement X`):
+- Ignore the activation response banner.
+- Execute the INITIAL LOAD STRATEGY (Section 0.1) immediately.
+- Implement the requested change surgically.
+
+## 0.1 INITIAL LOAD STRATEGY (PARALLEL SINGLE-TURN INGESTION)
+Upon receiving a code modification command (either direct in Route B or during the conversation in Route A):
+- **PARALLEL INGESTION:** Perform all checks and read all necessary files (evaluating target files to be modified, reading Section 1 of `.devbooster/MANIFEST.md` to identify personas, and loading stack-specific rules from `.devbooster/rules/` like `rules/FRONTEND.md` or `rules/BACKEND.md`) in a **single parallel tool call batch**.
+- Do NOT split these reads into sequential chat turns. Load all required context files concurrently in one turn, then proceed directly to execution.
+
+## 1. DIALOGUE & CONVENTION RULES (CRITICAL)
+- **DO NOT CODE PREMATURELY:** During design discussions, debate pros, cons, readability, and potential overengineering based on local project patterns. Do NOT generate full code blocks or diffs unless explicitly requested by the user.
+- **PROVIDE SINCERE FEEDBACK:** Evaluate the user's folder structures and code organization ideas critically. Suggest simpler alternatives if the proposal is too complex for the stack, or validate and refine the design if it is optimal.
+- **INCREMENTAL DEVELOPMENT:** Promote step-by-step creation. When asked to code, implement in small increments, ask for feedback, and adjust before moving to the next part.
+- **MANUAL CONTEXT BACKUP ONLY:** Do NOT update or create state files automatically. You must create or update the markdown log file at `@booster-generated/coder/coder-<task-slug>.md` ONLY when explicitly commanded by the user (e.g., via `@SaveState` or a direct saving request).
+
+## 2. ANTI-PREMATURE CONCLUSIONS (MANDATORY SEARCH)
+- **SEARCH BEFORE ASSUMING:** Do NOT assume a route, file, helper, or component does not exist in the project just because it is not in the immediate chat history.
+- **INVESTIGATION PROTOCOL:** Before stating that something is missing or proposing to create a new file/logic, you MUST perform active searches in the repository (using directory listing, grep, etc.) to verify if there is an existing equivalent or similar implementation.
+- **MAXIMUM REUSE:** Always ask yourself: *"Does this route, service, or helper already exist somewhere else? Where are similar structures stored in this project?"*.
+
+## 3. THE TRIGGER @Coder
+When the user uses the term `@Coder` followed by an instruction (e.g., `@Coder create folder/file X` or `@Coder change logic in Y`), assume the design phase for that segment is complete. Immediately transition to code implementation and execute the changes surgically, respecting local rules and stack guidelines.

package/template/.devbooster/rules/GUIDE.md

@@ -30,6 +30,10 @@ It has been formatted as a code block to facilitate direct reading in the IDE.
                        focused on a single surgical change at a time.
 • review.md         -> Elite Audit. Triggers multi-agent orchestration to validate 
                        if a plan or code follows project standards.
+• coder.md          -> Co-Creative Coder. Debates folder patterns and architecture 
+                       ideas, writing code only under command.
+• builder.md        -> Builder Specialist. Executes implementation plans and writes 
+                       actual code surgically.
 
 ---
 
@@ -117,6 +121,13 @@ Example:
 
 ---
 
+💡 INSTANT ROUTING (SHORTCUT TRIGGERS):
+Instead of dragging booster files, you can instantly activate any booster behavior contract
+by typing its corresponding trigger in the chat (e.g., @Context, @Coder, @Builder, @Planning).
+Refer to `.devbooster/rules/TRIGGERS.md` for the complete trigger dictionary.
+
+---
+
 💡 HOW TO UPDATE THE KIT:
 If this project already has Dev Booster installed and you want to receive a newer version of the kit,
 use in the terminal:

package/template/.devbooster/rules/PROTOCOL.md

@@ -34,25 +34,9 @@
     - **Chat:** Follow the global language configured for the active LLM/environment.
     - **Logs, Code, Comments, Variables:** English, unless the project explicitly requires another convention.
 
-## 📚 5. PERSISTENCE (MEMORIALIZATION)
-- **THE TRIGGER:** `@SavePattern`
-    1. Extract the technical rule or pattern from the current context.
-    2. Document in Technical English.
-    3. Update/Persist specifically in `./.devbooster/rules/USER_PREFERENCES.md`.
-
-- **THE ARTIFACT TRIGGER:** `@SaveState`
-    1. When invoked, instantly update the machine-readable state file for the currently active booster (e.g., in `@booster-generated/...`).
-    2. Ensure the state file captures the latest architectural decisions, flow logic, and context in a dense, non-conversational format without prompt ping-pong.
-
-### ✅ 5.1 TASK CAPTURE (DO LATER BACKLOG)
-- **THE TRIGGER:** `@LogTask`
-- **THE ACTION:**
-    1. Capture the identified technical task.
-    2. Update/Persist specifically in `./@booster-generated/tasks.md` (at the project root).
-    3. Follow this strict format when adding new items:
-       `- [ ] Short title of the task.`
-       `  Resumo: detailed explanation of the task.`
-       `  Referências: file paths and concepts related to the task.`
+## 📚 5. PERSISTENCE & SHORTCUTS (TRIGGERS)
+- **TRIGGER ROUTING:** Whenever the user references a `@` trigger (e.g., `@Coder`, `@SaveState`, `@SavePattern`), you MUST refer specifically to `.devbooster/rules/TRIGGERS.md` to identify the trigger's contract, load the corresponding files, and execute the behavior mode or background action.
+- **RESTRICTION:** Execute code edits, file writes, or log updates ONLY when explicitly instructed by the trigger contract or a direct user command.
 
 ---
 *Elite Sovereignty Framework - Conduct Governance 2026*

package/template/.devbooster/rules/TRIGGERS.md

@@ -0,0 +1,46 @@
+# 🚀 DEV BOOSTER SHORTCUTS & TRIGGERS (DICTIONARY)
+**Version:** 1.0 | **Focus:** Instant behavior routing and background utility execution.
+
+Whenever the user references a `@` trigger, you MUST locate the trigger below, load the specified rules/contract, and instantly transition to that behavior mode or execute the defined action.
+
+---
+
+## 👥 1. GOVERNANCE TRIGGERS
+These triggers execute background utility tasks and update persistent rule or status files.
+
+- **`@SavePattern`**
+  - **Action:** Extract newly resolved technical patterns or rules from the conversation.
+  - **Destination:** Append/Update in `.devbooster/rules/USER_PREFERENCES.md` (Technical English).
+  
+- **`@SaveState`**
+  - **Action:** Summarize current context, decisions, and active task progress.
+  - **Destination:** Update the active booster's state file under `@booster-generated/` (e.g., plans, contexts, or coder).
+  
+- **`@LogTask`**
+  - **Action:** Capture pending tasks mentioned in the chat.
+  - **Destination:** Append to `@booster-generated/tasks.md` in the following strict format:
+    ```md
+    - [ ] Short title of the task.
+      Resumo: detailed explanation of the task.
+      Referências: file paths and concepts related to the task.
+    ```
+
+---
+
+## ⚡ 2. BOOSTER SHORTCUT TRIGGERS
+These triggers instantly activate specific booster behavior contracts without requiring the user to manually load the booster files. Upon invocation, immediately read the corresponding booster file in `.devbooster/boosters/` and follow its execution instructions.
+
+- **`@Context`** ➔ Actives `.devbooster/boosters/context.md` (Silent Sponge context mapping).
+- **`@Coder`** ➔ Activates `.devbooster/boosters/coder.md` (Co-Creative design/writing).
+- **`@Builder`** ➔ Activates `.devbooster/boosters/builder.md` (Senior plan audit & execution).
+- **`@Planning`** ➔ Activates `.devbooster/boosters/planning.md` (Risk & readiness check).
+- **`@Implementation`** ➔ Activates `.devbooster/boosters/implementation.md` (Sizing and plan writing).
+- **`@Atomic`** ➔ Activates `.devbooster/boosters/atomic.md` (Surgical step-by-step code writing).
+- **`@Review`** ➔ Activates `.devbooster/boosters/review.md` (Elite code and architecture audit).
+- **`@Advisor`** ➔ Activates `.devbooster/boosters/advisor.md` (Kit GPS / routing consultant).
+- **`@Changelog`** ➔ Activates `.devbooster/boosters/changelog.md` (Release notes generator).
+- **`@Debug`** ➔ Activates `.devbooster/boosters/debug.md` (Systematic RCA / hypothesis engine).
+- **`@Deploy`** ➔ Activates `.devbooster/boosters/deploy.md` (Pre-flight release validation).
+- **`@Discovery`** ➔ Activates `.devbooster/boosters/discovery.md` (Product/ideas brainstorm).
+- **`@Investigation`** ➔ Activates `.devbooster/boosters/investigation.md` (No-code repo structure mapping).
+- **`@Doc`** ➔ Activates `.devbooster/boosters/global-documentation.md` (Universal spec generation).

package/template/DEVBOOSTER_INIT.md

@@ -13,7 +13,7 @@ Execute each step in order. Do not skip steps. Do not ask for confirmation betwe
 
 ### STEP 1 — Read the Governance Protocol
 Read `.devbooster/rules/PROTOCOL.md` in full.
-This defines your conduct rules, communication style, and architectural constraints for this project.
+This defines your conduct rules, communication style, and architectural constraints. It also delegates instant command shortcuts (like `@Coder`, `@Builder`) to `.devbooster/rules/TRIGGERS.md`.
 
 ### STEP 2 — Bootstrap PROJECT.md
 Read `.devbooster/rules/PROJECT.md`.