sdg-agents 1.0.5

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026 thiagocajadev
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,161 @@
+<div align="center">
+  <img src="https://raw.githubusercontent.com/thiagocajadev/sgd-agents-cli/main/src/assets/img/sdg-agents-icon-light.svg" alt="SDG Agents" width="480" height="480" style="border-radius: 1rem;">
+  <h1 align="center">Spec-Driven Guide — Agents</h1>
+  <p align="center">
+    A CLI that installs a structured instruction set for AI agents into your project.<br>
+    <a href="docs/README.pt-BR.md">Versão em Português (Brasil)</a>
+  </p>
+  <a href="https://nodejs.org"><img src="https://img.shields.io/badge/node-%3E%3D22-brightgreen?style=flat-square&logo=nodedotjs" alt="Node" /></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/badge/license-ISC-blue?style=flat-square" alt="License: ISC" /></a>
+</div>
+
+<br>
+
+<p align="center">
+  <kbd><img src="https://raw.githubusercontent.com/thiagocajadev/sgd-agents-cli/main/src/assets/img/sdg-agents-menu-v1.png" alt="Spec Driven Guide CLI in action" /></kbd>
+</p>
+
+`sdg-agents` installs a set of markdown instruction files into your project. AI agents (Claude Code, Cursor, Windsurf, Copilot, Codex, and others) read these files and follow the defined protocol for every task.
+
+> **Note:** If your agent does not pick up the rules automatically, reference `.ai/skill/AGENTS.md` at the start of the session.
+
+The instruction set covers:
+
+- **Working protocol**: a 5-phase cycle (SPEC → PLAN → CODE → TEST → END) that structures how the agent handles any task
+- **Engineering rules**: naming, code style, clean code standards, security boundaries
+- **Language patterns**: idiomatic conventions for your specific stack
+- **Architectural guidance**: rules for your project's structural pattern (vertical slice, MVC, etc.)
+- **Session memory**: a `.ai-backlog/` folder that persists context and task state across sessions
+
+---
+
+## Quick Start
+
+```bash
+npx sdg-agents
+```
+
+The interactive wizard guides you through selecting an architectural flavor and one or more language idioms. For non-interactive use:
+
+```bash
+# TypeScript + Vertical Slice
+npx sdg-agents init --flavor vertical-slice --idiom typescript
+
+# Multiple idioms
+npx sdg-agents init --flavor mvc --idiom typescript,python
+
+# Preview without writing files
+npx sdg-agents init --flavor mvc --idiom python --dry-run
+```
+
+---
+
+## What Gets Installed
+
+After running `init`, your project receives:
+
+```
+your-project/
+├── .ai/                         ← Instruction set (committed)
+│   ├── skill/
+│   │   └── AGENTS.md            ← Main entry point — auto-loaded by agents
+│   ├── instructions/
+│   │   ├── core/                ← Engineering rules (style, naming, security, testing)
+│   │   ├── flavors/             ← Architectural patterns (vertical-slice, mvc, etc.)
+│   │   ├── idioms/              ← Language-specific conventions (TS, Python, Go, etc.)
+│   │   └── competencies/        ← Layer-specific rules (frontend, backend)
+│   ├── commands/                ← Context files for feat/fix/docs cycles
+│   └── dev-guides/              ← Reference files, spec templates, and guides
+└── .ai-backlog/                 ← Session memory (gitignored)
+    ├── context.md               ← Project brief, decisions, current state
+    └── tasks.md                 ← Task list (TODO / IN_PROGRESS / DONE)
+```
+
+`dev-guides/` is always included. It contains the 5-phase cycle guide, the internal decision-gate flow, SDLC reference, UI prompt guide, and spec templates (`prompt-tracks/`) for authoring the SPEC phase of any task.
+
+Agent-specific entry files (`CLAUDE.md`, `.cursorrules`, `.windsurfrules`, etc.) are also written to the project root.
+
+> For a detailed breakdown of each file's role, see [Project Structure](docs/PROJECT-STRUCTURE.md).
+
+---
+
+## How the Protocol Works
+
+When you prefix a message to the agent, it enters the corresponding cycle:
+
+| Trigger               | Cycle   | What happens                                                                                                  |
+| :-------------------- | :------ | :------------------------------------------------------------------------------------------------------------ |
+| `land: <description>` | Land    | Agent turns a raw vision into a grounded backlog of sequenced `feat:` tasks — runs before any code is written |
+| `feat: <description>` | Feature | Agent runs SPEC → PLAN → CODE → TEST → END                                                                    |
+| `fix: <description>`  | Fix     | Agent runs SPEC → PLAN → CODE → TEST → END with RCA focus                                                     |
+| `docs: <description>` | Docs    | Agent updates changelogs, ADRs, or specs                                                                      |
+| No prefix             | —       | Agent asks: "land, feat, fix, or docs?" — then proceeds                                                       |
+
+The agent **stops and waits for your approval** at SPEC and PLAN before writing any code.
+
+```
+SPEC  →  PLAN  →  CODE  →  TEST  →  END
+  ↑           ↑
+  Wait        Wait        (approval required)
+```
+
+For a detailed walkthrough of each phase and its rules, see [Spec-Driven Development Guide](src/assets/dev-guides/spec-driven-dev-guide.md).
+For a visual breakdown of the internal decision gates and loops, see [Agent Deep-Flow](src/assets/dev-guides/agent-deep-flow.md).
+
+---
+
+## Architectural Flavors
+
+Select the flavor that matches your project's structure:
+
+| Flavor           | Pattern                                 | Use when                     |
+| :--------------- | :-------------------------------------- | :--------------------------- |
+| `vertical-slice` | Feature-driven vertical cuts            | Monorepo or domain-heavy API |
+| `mvc`            | Classic layered (Model-View-Controller) | Standard REST service        |
+| `lite`           | Minimal scaffold                        | Scripts, CLIs, utilities     |
+| `legacy`         | Refactor-safe bridge patterns           | Migrating existing codebases |
+
+For the data flow diagram of each flavor, see [Architectural Pipelines](docs/PIPELINES.md).
+
+---
+
+## Language Idioms
+
+Install language-specific patterns alongside the protocol:
+
+`typescript` · `javascript` · `python` · `csharp` · `java` · `kotlin` · `go` · `rust` · `swift` · `flutter` · `sql` · `vbnet`
+
+```bash
+# Add an idiom to an existing project
+npx sdg-agents add
+```
+
+---
+
+## Maintenance
+
+```bash
+npx sdg-agents review    # Detect drift between local rules and source
+npx sdg-agents sync      # Update rulesets from source
+npx sdg-agents update    # Refresh the LTS version registry
+npx sdg-agents clear     # Remove the .ai/ folder
+```
+
+---
+
+## Reference
+
+- [Quick Reference (CHEATSHEET)](docs/CHEATSHEET.md) — all CLI flags and agent triggers
+- [Project Structure](docs/PROJECT-STRUCTURE.md) — detailed breakdown of every generated file
+- [Architectural Pipelines](docs/PIPELINES.md) — data flow diagrams for each flavor
+- [Engineering Laws (CONSTITUTION)](docs/CONSTITUTION.md) — the principles behind the rules
+- [Roadmap](docs/ROADMAP.md) — planned work
+- [Changelog](CHANGELOG.md) — release history
+
+---
+
+> **Warning:** This project is in early development. Review and adjust the installed rules to fit your team's standards before relying on them.
+
+_Balance is the key._
+
+SDG is in constant evolution. There is no perfect solution, only continuous improvement. Feel free to contribute, fork, and share.

package/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "sdg-agents",
+  "version": "1.0.5",
+  "description": "Agnostic Markdown specs for AI development. Transform your repository into a highly-disciplined environment for AI Agents.",
+  "type": "module",
+  "main": "./src/engine/bin/index.mjs",
+  "bin": {
+    "sdg-agents": "./src/engine/bin/index.mjs"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "dev": "node src/engine/bin/index.mjs",
+    "build": "node src/engine/bin/build-bundle.mjs",
+    "review": "node src/engine/bin/review-bundle.mjs",
+    "bump": "node src/engine/bin/auto-bump.mjs",
+    "add-idiom": "node src/engine/bin/add-idiom.mjs",
+    "clear": "node src/engine/bin/clear-bundle.mjs",
+    "test": "node --test src/engine/lib/*.test.mjs",
+    "test:watch": "node --test --watch src/engine/lib/*.test.mjs",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "prepare": "husky"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "specs",
+    "markdown",
+    "claude",
+    "cursor",
+    "windsurf",
+    "copilot",
+    "codex",
+    "gemini",
+    "rules",
+    "architecture",
+    "cli",
+    "developer-tools"
+  ],
+  "author": "thiagocajadev",
+  "license": "ISC",
+  "files": [
+    "src/engine/bin/index.mjs",
+    "src/engine/bin/add-idiom.mjs",
+    "src/engine/config/",
+    "src/engine/lib/cli-parser.mjs",
+    "src/engine/lib/display-utils.mjs",
+    "src/engine/lib/fs-utils.mjs",
+    "src/engine/lib/instruction-assembler.mjs",
+    "src/engine/lib/manifest-utils.mjs",
+    "src/engine/lib/prompt-utils.mjs",
+    "src/engine/lib/result-utils.mjs",
+    "src/engine/lib/ruleset-injector.mjs",
+    "src/engine/lib/ui-utils.mjs",
+    "src/engine/lib/wizard.mjs",
+    "src/assets/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thiagocajadev/sgd-agents-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/thiagocajadev/sgd-agents-cli/issues"
+  },
+  "homepage": "https://github.com/thiagocajadev/sgd-agents-cli#readme",
+  "dependencies": {
+    "@inquirer/prompts": "^8.3.2",
+    "dedent": "^1.7.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.21.0",
+    "eslint": "^9.21.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.8.1"
+  },
+  "lint-staged": {
+    "**/*.mjs": "eslint --fix",
+    "**/*.{json,md}": "prettier --write"
+  }
+}

package/src/assets/dev-guides/agent-deep-flow.md

@@ -0,0 +1,139 @@
+# Agent Deep-Flow: Under the Hood
+
+This guide provides a detailed visual and technical breakdown of the internal sub-steps that an **SDG-compliant AI Agent** executes during each phase of the task cycle.
+
+## Visualizing the Deep Flow
+
+The following diagram illustrates the transitions, decision gates, and loops that ensure architectural integrity.
+
+<details>
+<summary>Click to visualise the Internal Deep-Flow</summary>
+
+```mermaid
+graph TD
+    Trigger((Request)) --> SPEC
+
+    subgraph SPEC [1. SPEC: The Contract]
+        S1[Intent Classification] --> S2[Goal Definition]
+        S2 --> S3[Domain & Contracts]
+        S3 --> S4[Verification Checklist]
+        S4 --> S5{Approval Gate}
+    end
+
+    S5 -- Approved --> PLAN
+    S5 -- Denied --> SPEC
+
+    subgraph PLAN [2. PLAN: The Strategy]
+        P1[Task Decomposition] --> P2[Logical Sequencing]
+        P2 --> P3[Effort Tagging]
+        P3 --> P4[Sub-task Split]
+        P4 --> P5[Backlog Sync]
+        P5 --> P6{Approval Gate}
+    end
+
+    P6 -- Approved --> CODE
+    P6 -- Denied --> PLAN
+
+    subgraph CODE [3. CODE: The Execution]
+        C1[Context Load] --> C2[Narrative Gate]
+        C2 --> C3[Plan Adherence]
+        C3 --> C4[Blocker Surface]
+    end
+
+    C4 -- Loop / No Progress 3x --> Stop
+    C4 --> TEST
+
+    subgraph TEST [4. TEST: The Verification]
+        T1[Checklist Verification] --> T2[Regression Proof]
+        T2 --> T3{Fix Loop}
+        T3 -- Success --> T4[Lint Fix]
+        T4 --> T5[Report Status]
+    end
+
+    T3 -- Failure (Max 3x) --> CODE
+    T3 -- Blocked --> Stop((STOP & Report))
+
+    T5 --> END
+
+    subgraph END [5. END: The Delivery]
+        E1[Task Summary] --> E2[CHANGELOG]
+        E2 --> E3[Backlog Sync]
+        E3 --> E4[Context & Insights]
+        E4 --> E5[Final Lint]
+        E5 --> E6[Commit Suggestion]
+        E6 --> E7[Next Steps]
+    end
+
+    E7 --> Done((Done))
+
+    style S5 fill:#f96,stroke:#333
+    style P6 fill:#f96,stroke:#333
+    style T3 fill:#f96,stroke:#333
+    style C4 fill:#ffa,stroke:#333
+    style Stop fill:#f66,stroke:#333
+```
+
+</details>
+
+---
+
+## Detailed Phase Breakdown
+
+### 1. Phase: SPEC
+
+> **Role: Planning** _(Claude Code — multi-agent mode)_
+
+The agent defines **what** to build before thinking about **how**.
+
+- **Intent Identification**: Classification as `feat:`, `fix:`, or `docs:`.
+- **Goal**: A one-sentence technical "North Star".
+- **Verification Checklist**: Up to 5 binary criteria used to validate the final delivery.
+- **Approval Gate**: Execution **must stop** here for **Developer verification**.
+
+### 2. Phase: PLAN
+
+> **Role: Planning** _(Claude Code — multi-agent mode)_
+
+The agent sequences the spec into atomic, estimable tasks.
+
+- **Atomic Tasks**: Pattern: `Action Verb + Object`.
+- **Effort Tagging**: Tasks are tagged by size — `[S]` (isolated), `[M]` (cross-layer), `[L]` (complex).
+- **Sub-task Split**: Any `[L]` task is decomposed into smaller steps (`1.1`, `1.2`).
+- **Approval Gate**: Execution **must stop** here to ensure the strategy is sound.
+
+### 3. Phase: CODE
+
+> **Role: Fast** _(Claude Code — multi-agent mode)_
+
+High-density execution following strict architectural standards.
+
+- **Narrative Gate**: Self-check for **Stepdown Rule**, **SLA**, and **Lexical Scoping**.
+- **Plan Adherence**: No "bonus" features or refactors (YAGNI).
+- **Blocker Surface**: The agent flags issues immediately rather than working around them.
+- **Circuit Breaker**: If the same error repeats 3 times, or no physical progress (file writes, commands) is made in 3 consecutive turns, the agent **stops and reports** rather than looping indefinitely.
+
+### 4. Phase: TEST
+
+> **Role: Fast** _(Claude Code — multi-agent mode)_
+
+Verification against the original Spec's checklist.
+
+- **Regression Proof**: For bugs, the agent must prove the fix works without breaking existing logic.
+- **Fix Loop**: A built-in resilience mechanism allowing up to **3 refactor attempts** if tests fail. On the third failure, the Circuit Breaker triggers — the agent stops and reports rather than continuing.
+- **Lint Fix**: Automated resolution of style violations before reporting success.
+
+### 5. Phase: END
+
+> **Role: Planning** _(Claude Code — multi-agent mode)_
+
+Closing the loop and ensuring project observability.
+
+- **Artifact Sync**: Automated updates to `tasks.md` (status DONE) and `context.md` (next objective).
+- **Engineering Insights**: The agent logs research findings, rework patterns, and lessons learned into `context.md ## Engineering Insights`. Stale or irrelevant entries are curated out, keeping the file lean across sessions.
+- **Changelog**: Consistent history following the [Keep a Changelog](https://keepachangelog.com/) standard.
+- **Semantic Commit**: Proposing a commit message that reflects the actual intent and scope.
+
+---
+
+> [!TIP]
+> This deep-flow is the internal model the agent follows on every task cycle. Use it to understand why the agent stops where it does and what it checks at each gate.

package/src/assets/dev-guides/prompt-tracks/00-lite-mode/01-project-scope-and-mvp.md

@@ -0,0 +1,45 @@
+# 01 - Scope and MVP (The Agile Contract / SPEC)
+
+For short, fast-paced projects (MVPs) or Landing Pages, the biggest risk for the Freelancer or lean Squad is not technology, it is **Scope Creep** (the client asking for _just one more little thing_ at the end, consuming your profit margin).
+
+This document establishes the exact boundaries of what will be - and what will NOT be - delivered in the paid project.
+
+## What We Will Do (In-Scope / MVP)
+
+- Executive summary: What problem does the client want to solve? (e.g., "Create a page to collect emails for a digital product launch").
+- Raw list of Features:
+  - Homepage with static copy.
+  - Form capturing Name and Email integrated with Mailchimp.
+- Which Screens (UI) will actually be designed? (Page sizes).
+
+## Out-of-Scope
+
+- What will be left for V2/V3 and charged separately in the future? (This shields you against falsely agreed-upon hours).
+  - Ex: "We will not build an Admin/Login system for the page right now."
+  - Ex: "We will not integrate automatic SMS sending at this time."
+
+---
+
+## Learn by Examples
+
+### ❌ Bad Example
+
+```markdown
+# Scope
+
+Build the institutional website for the dental clinic.
+```
+
+> **Rationale**: Terrible. In the final week of delivery, the dentist asks: "What about the system to schedule patients on WhatsApp via the website like the competitor has? Didn't you build it?". Since the scope didn't exclude this (Out-of-Scope), the client thinks you failed or will do it for free.
+
+### ✅ Good Example
+
+```markdown
+# Happy Smile Clinic Website Scope
+
+- **Business Problem:** The clinic wants digital presence on Google Ads and to collect initial consultation Leads.
+- **In-Scope (Deliverables):** Responsive Landing Page (One-page), email contact form, static clinic photo gallery, and dynamic Links that redirect to the Receptionist's Whatsapp with a pre-filled message.
+- **Out-of-Scope (Deferred to V2):** We will not develop our own Database, we will not develop a CMS Panel (Admin to change photos), and we will not integrate with third-party Medical Scheduling Software in this phase.
+```
+
+> **Rationale**: Absolute defense. The agency knows they will only need to use Netlify and Email. When the client brings up the Scheduling integration, it will be a new budget.

package/src/assets/dev-guides/prompt-tracks/00-lite-mode/02-stack-and-data-model.md

@@ -0,0 +1,56 @@
+# 02 - Technical Stack and Essential Data
+
+In fast-paced projects, you should not waste time justifying complex ADRs. Use whatever allows you to deliver quickly and document here only how the next programmer can run the code.
+
+## Main Technologies
+
+- Frontend Framework / SSR: (Ex: Next.js, Vite + React).
+- Styling: (Ex: TailwindCSS V3, Radix UI).
+- CMS / Backend-As-A-Service (If applicable): (Ex: Supabase, Strapi, Sanity).
+
+## How to Run the Project (Developer Experience - DX)
+
+1. Install package `X`.
+2. Include `.env` (where to get a development one?).
+3. Run `npm run dev`.
+
+## Minimum Viable Data Model (DB Schema)
+
+- If there's a database, paste only a minimalist Schema or text describing the essential collections so developers don't have to "fish blindfolded".
+- If there's a _Headless_ CMS behind it, map the most critical _Types_.
+
+---
+
+## Learn by Examples
+
+### ❌ Bad Example
+
+```markdown
+# Stack
+
+Using React. To turn it on run npm start.
+The database has a `leads` table.
+```
+
+> **Rationale**: Omits dozens of secret libraries. A junior dev clones it, runs npm start, and the screen blinks white because they didn't set the Supabase `.env` and didn't even know you used Vercel.
+
+### ✅ Good Example
+
+```markdown
+# Stack and Environment: Happy Smile LP
+
+## Local Setup
+
+1. `git clone` followed by `npm ci` (we are using `v18.x` in nvm).
+2. Request access to DevSupabase in the slack group.
+3. Copy the `.env.example` file to `.env.local` and run `npm run dev` on port 3000.
+   **Frontend:** Next.js (Pages Router) + TailwindCSS. Form built with `React Hook Form`.
+
+## Supabase Minimal Entities
+
+To strictly focus on contacts, we have only 1 table managed in the Development Supabase Cloud:
+
+- `leads (id: UUID, name: string, email: string, whatsapp: string, created_at: timestamp)`
+```
+
+> **Rationale**: Straight to the point and practical. A second Frontend dev will enter the project, clone it, understand the forms, and run it in less than 10 minutes of reading.

package/src/assets/dev-guides/prompt-tracks/00-lite-mode/03-external-integrations.md

@@ -0,0 +1,44 @@
+# 03 - Third-Party Integrations and Sensitive Keys
+
+Third-party APIs and services are the magical bricks that solve 80% of the business logic in Lite products. Instead of reinventing an email sending server or building a billing system in Java, the Landing Page or MVP will consume ready-made APIs (like Resend, Mailchimp, and Stripe).
+
+## Project Connectors and Environment Variables
+
+- Will you send emails? Which provider? And how will React on Vercel call the API without leaking access data on the Frontend? (Hint: Next.js API Routes).
+- Payment and Checkout: Which Gateway will we use that doesn't demand PCI compliance scope?
+- Is Auth proprietary (e.g., Supabase, Auth0) or will we have Google Login?
+
+## Credentials Mapping (Vault/Env)
+
+- Do NOT store or hardcode ANYTHING in Git. Integrations must use and declare the expected `.env` taxonomy for the project.
+
+---
+
+## Learn by Examples
+
+### ❌ Bad Example
+
+```markdown
+# Integration
+
+We fire the form to the company's mailchimp. The Front-end does a fetch with the token.
+```
+
+> **Rationale**: Severe security danger and lack of maturity. Frontends should not carry Mailchimp keys on the Client-side, otherwise any visitor could grab your Newsletter token and freely delete your customer base.
+
+### ✅ Good Example
+
+```markdown
+# Happy Smile API Integrations
+
+## Transactional Emails (Form to the Clinic)
+
+- **Provider:** We will use the [Resend API](https://resend.com) on the client's domain `docs@sorrisofeliz.com`.
+- **Secure Magic Routes:** We created a Serverless endpoint (Edge API On Vercel) at the `POST /api/leads` route. The React client form calls this endpoint without any tokens. The underlying Node.js will consume the shielded token via Vercel's `.env` and inject it into Resend: `RESEND_API_KEY`.
+
+## Checkout (Planned)
+
+- **Gateway:** When clients pay for direct consultations (Stripe Hosted Checkout), the publishable variables will be inserted into NEXT*PUBLIC_PUBLISHABLE_KEY, but \_webhooks* will return with cryptographic signature `STRIPE_WEBHOOK_SECRET` validated at `/api/stripe-webhook`.
+```
+
+> **Rationale**: Maps exactly which third-party fronts are used, how the keys will be called, and protects the Freelancer against chronic Cybersecurity flaws that could ruin the MVP.

package/src/assets/dev-guides/prompt-tracks/00-lite-mode/04-launch-checklist.md

@@ -0,0 +1,26 @@
+# 04 - Launch Checklist
+
+Launching an MVP/Landing Page quickly doesn't mean just throwing files onto the server. Your client expects polish, speed, and impeccable SEO on WhatsApp. This is the final gateway, your personal one-day Quality Assurance.
+
+## Domain Setup and Security
+
+- [ ] Is the custom domain linked on Vercel/Netlify/Cloudflare?
+- [ ] Is SSL (HTTPS) active (Green Padlock)?
+- [ ] Did you try accessing without 'www' (e.g., `happy-smile.com`) and was the traffic correctly redirected to prevent Google penalties (Duplicate Content)?
+- [ ] Reference: # 01 - Scope and MVP (The Agile Contract / SPEC)
+
+## SEO and Social Sharing (OpenGraph)
+
+- [ ] Have basic `Meta Tags` (Title, Description) been declared for Google?
+- [ ] Are `Og:Image` images hosted so that when the link is posted on WhatsApp or Instagram, the "site thumbnail" appears beautiful and resized?
+- [ ] Is there a real `Favicon` or did you forget the default Vercel logo orbiting?
+
+## Live Integrations & Core Web Vitals Performance
+
+- [ ] Have the Google Analytics (GA4) and Meta Pixel (Facebook) tags been injected so Marketing doesn't complain later?
+- [ ] Does the Chrome Lighthouse score hit 90+ in Performance and Accessibility in a cold Mobile audit? (Use WebP, cut massive JS).
+- [ ] Did the test with real form data ("Mr. John Smith, john@gmail.com") actually land in the client's inbox without a SPAM flag?
+
+---
+
+> **Rationale**: Executing this checklist crowns the relentless quality of the Freelancer/Agency. Your project is only complete when all the boxes above have been checked positively. Nothing sells a fast sprint better than a link without loose error edges and a thumbnail that creates visual pride for the client.

package/src/assets/dev-guides/prompt-tracks/01-new-evolution/00-foundation/01-project-vision.md

@@ -0,0 +1,77 @@
+# 01 - Project Vision
+
+## Description
+
+- What is the primary goal of this project?
+- What does it aim to become in the long term?
+
+## Scale and Magnitude
+
+- What is the estimated number of users (Active/Concurrent)?
+- What is the expected volume of data or transactions (TPS/RPS)?
+- Is there any availability requirement (SLA)?
+
+## Budget and Resources
+
+- What is the approximate available budget (Infra/Services)?
+- What **Developer expertise** is required (Senior, Mid-level, Specialist)?
+
+## Deadlines and Expectations
+
+- What are the main milestones?
+- Is there a critical launch date (Hard deadline)?
+
+## Target Audience
+
+- Who are the primary users?
+- What value are we delivering to them?
+
+## Out of Scope
+
+- What will this project definitely NOT do?
+
+---
+
+## Learn by Examples
+
+### ❌ Bad Example
+
+```markdown
+# 01 - Project Vision
+
+## Description
+
+The project aims to improve the sales system to satisfy the customer.
+
+## Budget and Resources
+
+Whatever it takes to make it good.
+
+## Deadlines and Expectations
+
+As soon as possible.
+```
+
+> **Rationale**: Vague and lack of financial or temporal commitment. "As soon as possible" generates anxiety and lack of planning.
+
+### ✅ Good Example
+
+```markdown
+# 01 - Project Vision
+
+## Description
+
+To be the leading platform for rare automotive parts sales in Latin America by 2027.
+
+## Budget and Resources
+
+- **Infra Budget**: Maximum of $15,000/month.
+- **Team**: 2 Senior Engineers and 1 UX Designer.
+
+## Deadlines and Expectations
+
+- **POC**: Until May 15th.
+- **MVP**: Beta launch on September 1st (Hard deadline for the industry trade show).
+```
+
+> **Rationale**: Defines clear cost limits and fixed dates that allow for team capacity planning.