sdd-toolkit 1.5.0 → 1.6.0

package/README.md

@@ -1,155 +1,139 @@
-# sdd-toolkit (Universal Spec CLI)
-
-CLI tool to automatically set up the development environment and install AI agents (Auditor, Coder, etc.) for various modern AI tools.
-
-## Overview
-
-**sdd-toolkit** is an "AI Agent Package Manager". It defines a standard squad of AI Developers and installs them directly into the context of your favorite AI Coding Assistant (such as Gemini, Roo Code, Kilo Code, OpenCode).
-
-The main idea is to stop creating prompts from scratch and install a proven, structured workflow.
-
-## Key Features
-
-### 1. AI Agent Installation
-
-Reads agnostic definitions (YAML) and converts them to specific formats:
-
--   **Gemini CLI:** Generates `.toml` configuration files.
--   **Roo Code / Cline:** Generates custom modes (`_custom_modes.json`) and context rules in `.roo/` or `.cline/`.
--   **GitHub Copilot:** Generates instructions in `.github/copilot-instructions.md` and agents in `.github/agents/`.
--   **Cursor:** Generates rules in `.cursor/rules/*.mdc`.
--   **Windsurf:** Generates rules in `.windsurfrules`.
--   **Trae:** Generates instructions in `.trae/instructions.md`.
--   **OpenCode:** Generates agents in `.opencode/`.
--   **OpenAI / Claude (Web):** Generates plain text prompts in the `prompts/` folder.
--   **Kilo Code:** Generates Markdown prompts (`.kilo/prompts/*.md`).
-
-### 2. Workflow Configuration
-
-Automates the creation of the documentation structure (`docs/` and `docs/logs/`) to support the agents' workflow.
-
-## 👥 The Squad (Agent Roles)
-
-The system works best when you follow the defined pipeline. Each agent saves its "Brain" (context) in the `docs/` folder, which serves as the base for the next agent in the chain.
-
-### 🏗️ 1. Project Architect
-
-**"The Visionary"**
-Transforms your raw idea into a professional specification. Acts as an interviewer to uncover hidden requirements.
-
--   **Trigger:** `/dev.project "I want an Uber clone for dog walking"`
--   **Action:** Asks clarifying questions about features, target audience, and constraints.
--   **Output:** `docs/project.md` (Scope, User Stories, Fundamental Principles).
-
-### 🧱 2. Requirements Engineer
-
-**"The Technical Lead"**
-Decides _how_ to build. Defines the technology stack, database schema, and technical boundaries based on the specification.
-
--   **Trigger:** `/dev.requirements`
--   **Action:** Selects libraries (e.g., "Prisma vs TypeORM"), defines API contracts and security rules.
--   **Output:** `docs/requirements.md` (The "Technical Contract" the Coder must obey).
-
-### 🗺️ 3. Milestone Manager
-
-**"The Strategist"**
-Prevents you from trying to build everything at once. Breaks the project into logical "MVPs" (Phases).
-
--   **Trigger:** `/dev.milestone`
--   **Output:** `docs/milestones.md` (e.g., Phase 1: Auth, Phase 2: Payment, Phase 3: GPS).
-
-### 📋 4. Task Planner
-
-**"The Project Manager"**
-Takes **ONE Milestone** and breaks it down into small, atomic tasks for the AI Coder.
-
--   **Reasoning:** AI Coders hallucinate less when the context is small.
--   **Trigger:** `/dev.tasks 1` (Plan Milestone 1)
--   **Output:** `docs/task.md` (A checklist of 5-10 specific file operations).
-
-### 🕵️ 5. Auditor
-
-**"The Guardian"**
-A safety check before coding starts. Reads the **Requirements** and **Task Plan** to ensure nothing was lost in translation.
-
--   **Trigger:** `/dev.auditor`
--   **Action:** "Hey, you planned the Login UI but forgot the 'Forgot Password' flow mentioned in the Requirements."
--   **Output:** `audit_report.md` (Pass/Fail).
-
-### 💻 6. Coder
-
-**"The Senior Developer"**
-The executor. Runs ONE checklist task at a time.
-
--   **Features:**
-    -   **Context Aware:** Reads `project.md` to know "Project Principles" (e.g., "Use Functional Components").
-    -   **Safety:** Checks `.gitignore` before creating files.
-    -   **TDD:** Can write tests before code if requested.
--   **Trigger:** `/dev.coder 1.1` (Implement Task 1.1)
--   **Output:** Writes code in `src/` and logs in `work_log.md`.
-
-### ⚖️ 7. QA Engineer
-
-**"The Reviewer"**
-Simulates a Pull Request review. Checks if the code matches the Requirements contracts.
-
--   **Trigger:** `/dev.review 1.1`
--   **Action:** Reads the code and `requirements.md`. If variables are poorly named or logic is insecure, it REJECTS the task.
-
-### 📦 8. Release Manager
-
-**"The Historian"**
-Consolidates the messy daily `work_log.md` into a clean `CHANGELOG`.
-
--   **Trigger:** `/dev.log`
-
-## 🛠️ On-Demand Toolkit
-
-### 🏗️ DevOps Engineer
-
-**"The Config Specialist"**
-Call this agent specifically for infrastructure tasks, so you don't waste the main agent's context.
-
--   **Trigger:** `/dev.ops`
--   **Examples:** "Create Dockerfile", "Setup Github Actions", "Configure ESLint".
-
-## Installation and Usage
-
-You can run the tool directly via `npx` without prior installation:
-
-```bash
-npx sdd-toolkit
-```
-
-Or install globally:
-
-```bash
-npm install -g sdd-toolkit
-sdd-toolkit
-```
-
-## How the CLI Works
-
-When you run `npx sdd-toolkit`, the installation wizard starts:
-
-1.  **Initialization:** The wizard asks which shell you use (Windows or Unix) and generates a custom workflow guide in the `docs/` folder.
-2.  **Agent Building:** The wizard reads agent definitions (either from the `definitions/` folder or a local `agents.md` file) and "compiles" them into your chosen AI assistant's format.
-3.  **Supported Destinations:**
-
-    -   **Gemini CLI:** Generates `.toml` files in `.gemini/commands/`.
-    -   **Roo Code / Cline:** Generates custom modes (`_custom_modes.json`) and rules in `.roo/` or `.cline/`.
-    -   **GitHub Copilot:** Generates instructions in `.github/copilot-instructions.md` and agents in `.github/agents/`.
-    -   **Kilo Code:** Generates workflows in `.kilocode/workflows/`.
-    -   **OpenCode:** Generates files in `.opencode/command/`.
-    -   **Others:** Support for Cursor, Windsurf, Trae, OpenAI/Claude Web.
-
-This way, **sdd-toolkit** acts as a bridge between agent behavior definitions and the tool you use for coding, ensuring your AI "team" is always configured and ready to work.
-
-## Project Structure
-
--   `src/`: CLI source code.
--   `definitions/`: YAML agent definitions (agnostic).
-
-## License
-
-MIT
+# sdd-toolkit (Universal Spec CLI)
+
+CLI tool to automatically set up the development environment and install AI agents (Auditor, Coder, etc.) for various modern AI tools.
+
+## Overview
+
+**sdd-toolkit** is an "AI Agent Package Manager". It defines a standard squad of AI Developers and installs them directly into the context of your favorite AI Coding Assistant (such as Gemini, Roo Code, Kilo Code, OpenCode).
+
+The main idea is to stop creating prompts from scratch and install a proven, structured workflow.
+
+## 🚀 Key Features
+
+### 1. Smart & Agile Workflow
+- **Hybrid Flow:** Supports both "Waterfall" planning (for new projects) and "Agile" execution (for hotfixes/features).
+- **Smart Context:** Agents automatically scan your `package.json`, `go.mod`, or `requirements.txt` to understand your stack. No more explaining "I use React" every time.
+- **Unified Memory:** All context is stored in a hidden `.sdd-toolkit/` folder, keeping your root directory clean.
+
+### 2. "Power Commands"
+Agents come equipped with special execution modes triggered by commands:
+- **`/sdd`**: Access help and list all available agents.
+- **`/flow:debug`**: Paste an error log, and the Coder enters "Surgical Mode" to fix it immediately.
+- **`/flow:tdd`**: Forces the Red-Green-Refactor cycle for high-quality code.
+- **`/flow:refactor`**: Applies Clean Code principles to an existing file.
+- **`/flow:gen-tests`**: Automatically generates unit tests for your code.
+- **`/flow:security`**: Scans your code/plan for vulnerabilities (OWASP).
+- **`/flow:sync`**: Updates the documentation (`project.md`) to match the actual code (Reverse Engineering).
+
+### 3. AI Agent Installation
+Reads agnostic definitions (YAML) and converts them to specific formats:
+- **Gemini CLI:** Generates `.toml` configuration files.
+-   **Roo Code / Cline:** Generates custom modes (`_custom_modes.json`) and context rules in `.roo/` or `.cline/`.
+-   **GitHub Copilot:** Generates instructions in `.github/copilot-instructions.md` and agents in `.github/agents/`.
+-   **Cursor:** Generates rules in `.cursor/rules/*.mdc`.
+-   **Windsurf:** Generates rules in `.windsurfrules`.
+-   **Trae:** Generates instructions in `.trae/instructions.md`.
+-   **OpenCode:** Generates agents in `.opencode/`.
+-   **Kilo Code:** Generates Markdown prompts (`.kilo/prompts/*.md`).
+
+## 👥 The Squad (Agent Roles)
+
+The system installs a team of specialized agents:
+
+### 🏗️ Strategic Agents
+- **@Project Architect:** Defines the scope and principles.
+- **@Requirements Engineer:** Defines the tech stack (Auto-detected).
+- **@Milestone Manager:** Creates the roadmap.
+
+### ⚡ Execution Agents
+- **@Task Planner:** Breaks down milestones into atomic tasks.
+- **@Feature Manager:** The agile entry point. Handles requests like "Add Google Login" and decides the best path (Hotfix vs Milestone).
+- **@Coder:** The senior developer. Supports TDD, Debug, Refactor, and Test Generation modes.
+
+### 🛡️ Quality Agents
+- **@QA Engineer:** Reviews code against the spec (Auditor role).
+- **@DevOps Engineer:** Handles Docker, CI/CD, and Configs.
+- **@Release Manager:** Consolidates logs and manages the changelog.
+- **@SDD Helper:** Provides access to all agents and help.
+
+## Installation and Usage
+
+You can run the tool directly via `npx` without prior installation:
+
+```bash
+npx sdd-toolkit
+```
+
+Or install globally:
+
+```bash
+npm install -g sdd-toolkit
+sdd-toolkit
+```
+
+## How it Works
+
+1.  **Initialization:** The wizard detects your tools and sets up the hidden `.sdd-toolkit/` context folder.
+2.  **Agent Building:** It reads the "Thinking Protocols" (YAML) and compiles them into your AI tool's native format.
+3.  **Execution:** You interact with the agents using simplified commands (e.g., `/project`, `/coder`) or the new `/flow:*` triggers.
+
+## Complete Development Flow
+
+The sdd-toolkit implements a **unified hybrid workflow** that adapts to your needs, combining structured planning for new projects with agile execution for quick fixes. It ensures traceability, justification, and quality through AI-human collaboration.
+
+### Unified Hybrid Workflow Overview
+
+- **Adaptive Initiation:** Start with `/start "Descrição"` for intelligent routing. The system checks existing docs and decides between quick or structured paths.
+- **Conditional Planning:** If needed, escalates to full planning (Project Architect → Requirements Engineer → Milestone Manager → Task Planner).
+- **Standardized Execution:** Coders implement tasks with logs, followed by unified validation (QA and Auditor).
+- **Finalization:** Release Manager consolidates into changelog with human confirmation.
+
+### Detailed Flow Steps
+
+#### 1. Initiation (Inteligente)
+- Command: `/start "Build a login system"`
+- Action: Project Architect checks for existing `.sdd-toolkit/project.md`.
+  - If none: Enters interview mode for basics.
+  - If exists: Confirms proceed or restart.
+- Output: Updates `project.md` with hybrid notes (e.g., approval points).
+
+#### 2. Planning (Condicional)
+- If hotfix: Feature Manager routes directly to task creation.
+- If project: Milestone Manager generates roadmap with human approval.
+- Commands: `/requirements`, `/milestone`, `/tasks`.
+- Output: `requirements.md`, `milestones.md`, `task.md`.
+
+#### 3. Execution (Padronizada)
+- Command: `/coder`
+- Action: Coder reads context, implements, logs in `executions/`, marks tasks as done.
+- Modes: `/flow:debug`, `/flow:refactor`, `/flow:tdd`, etc.
+- Output: Code changes + execution logs.
+
+#### 4. Validation (Unificada)
+- Commands: `/review`
+- Action: QA Engineer reviews code against the spec. Pauses for human input on ambiguities.
+- Output: Review reports in `logs/reviews/`.
+
+#### 5. Finalization (Com Confirmação)
+- Command: `/release` or implicit after approval.
+- Action: Release Manager updates `changelog.md` and archives logs after human confirmation.
+- Output: Clean changelog and archived logs.
+
+### Agent Interactions
+Agents share context via `.sdd-toolkit/` files, ensuring no hallucinations. Power commands enable specialized modes. The flow promotes justification (e.g., "Why this decision?") and human-AI handoffs for reliability.
+
+For examples, see the workflow guides generated in `.sdd-toolkit/`.
+
+## Project Structure
+
+-   `src/`: CLI source code.
+-   `definitions/`: YAML agent definitions (agnostic).
+-   `templates/`: Documentation templates.
+
+## License
+
+MIT
+
+---
+
+**Nota:** Uma versão em português deste README está disponível em [README.pt.md](README.pt.md).

package/README.pt.md

@@ -0,0 +1,135 @@
+# sdd-toolkit (CLI de Especificação Universal)
+
+CLI tool para configurar automaticamente o ambiente de desenvolvimento e instalar agentes de IA (Auditor, Coder, etc.) para várias ferramentas modernas de IA.
+
+## Visão Geral
+
+**sdd-toolkit** é um "Gerenciador de Pacotes de Agentes de IA". Ele define uma equipe padrão de Desenvolvedores de IA e os instala diretamente no contexto de sua assistente de codificação de IA favorita (como Gemini, Roo Code, Kilo Code, OpenCode).
+
+A ideia principal é parar de criar prompts do zero e instalar um workflow comprovado e estruturado.
+
+## 🚀 Recursos Principais
+
+### 1. Workflow Inteligente e Ágil
+- **Fluxo Híbrido:** Suporta planejamento "Waterfall" (para novos projetos) e execução "Agile" (para hotfixes).
+- **Contexto Inteligente:** Os agentes escaneiam automaticamente seu `package.json`, `go.mod`, ou `requirements.txt` para entender sua stack. Não mais explicar "Eu uso React" toda vez.
+- **Memória Unificada:** Todo contexto é armazenado em uma pasta oculta `.sdd-toolkit/`, mantendo sua raiz limpa.
+
+### 2. "Comandos de Potência"
+Os agentes vêm equipados com modos de execução especiais acionados por comandos:
+- **`/sdd`**: Acesso a ajuda e lista de todos os agentes disponíveis.
+- **`/flow:debug`**: Cole um log de erro e o Coder entra no "Modo Cirúrgico" para corrigir imediatamente.
+- **`/flow:tdd`**: Força o ciclo Red-Green-Refactor para código de alta qualidade.
+- **`/flow:refactor`**: Aplica princípios de Clean Code a um arquivo existente.
+- **`/flow:gen-tests`**: Gera automaticamente testes unitários para seu código.
+- **`/flow:security`**: Escaneia seu código/plano em busca de vulnerabilidades (OWASP).
+- **`/flow:sync`**: Atualiza a documentação (`project.md`) para corresponder ao código real (Engenharia Reversa).
+
+### 3. Instalação de Agentes de IA
+Lê definições agnósticas (YAML) e as converte para formatos específicos:
+- **Gemini CLI:** Gera arquivos de configuração `.toml`.
+-   **Roo Code / Cline:** Gera modos customizados (`_custom_modes.json`) e regras de contexto em `.roo/` ou `.cline/`.
+-   **GitHub Copilot:** Gera instruções em `.github/copilot-instructions.md` e agentes em `.github/agents/`.
+-   **Cursor:** Gera regras em `.cursor/rules/*.mdc`.
+-   **Windsurf:** Gera regras em `.windsurfrules`.
+-   **Trae:** Gera instruções em `.trae/instructions.md`.
+-   **OpenCode:** Gera agentes em `.opencode/`.
+-   **Kilo Code:** Gera prompts Markdown (`.kilo/prompts/*.md`).
+
+## 👥 A Equipe (Funções dos Agentes)
+
+O sistema instala uma equipe de agentes especializados:
+
+### 🏗️ Agentes Estratégicos
+- **@Arquitetos de Projeto:** Define o escopo e princípios.
+- **@Engenheiros de Requisitos:** Define a stack técnica (Auto-detectada).
+- **@Gerenciadores de Marcos:** Cria o roadmap.
+
+### ⚡ Agentes de Execução
+- **@Planejadores de Tarefas:** Quebra marcos em tarefas atômicas.
+- **@Gerenciadores de Recursos:** O ponto de entrada ágil. Trata solicitações como "Adicionar Login Google" e decide o melhor caminho (Hotfix vs Milestone).
+- **@Codificadores:** O desenvolvedor sênior. Suporta modos TDD, Debug, Refactor e Geração de Testes.
+
+### 🛡️ Agentes de Qualidade
+- **@Auditores:** Verifica consistência entre requisitos e tarefas.
+- **@QA Engineers:** Revisa código contra a especificação.
+- **@DevOps Engineers:** Trata Docker, CI/CD e Configs.
+- **@Gerenciadores de Releases:** Consolida logs e gerencia o changelog.
+
+## Instalação e Uso
+
+Você pode executar a ferramenta diretamente via `npx` sem instalação prévia:
+
+```bash
+npx sdd-toolkit
+```
+
+Ou instalar globalmente:
+
+```bash
+npm install -g sdd-toolkit
+sdd-toolkit
+```
+
+## Como Funciona
+
+1.  **Inicialização:** O assistente detecta suas ferramentas e configura a pasta de contexto oculta `.sdd-toolkit/`.
+2.  **Construção de Agentes:** Lê os "Protocolos de Pensamento" (YAML) e os compila no formato nativo da sua ferramenta de IA.
+3.  **Execução:** Você interage com os agentes usando comandos simplificados (ex.: `/project`, `/coder`) ou os novos gatilhos `/flow:*`.
+
+## Fluxo Completo de Desenvolvimento
+
+O sdd-toolkit implementa um **fluxo de trabalho híbrido unificado** que se adapta às suas necessidades, combinando planejamento estruturado para novos projetos com execução ágil para correções rápidas. Ele garante rastreabilidade, justificativa e qualidade através de colaboração IA-humana.
+
+### Visão Geral do Fluxo Híbrido Unificado
+
+- **Iniciação Inteligente:** Comece com `/dev:start "Descrição"` para roteamento inteligente. O sistema verifica docs existentes e decide entre caminhos quick ou estruturados.
+- **Planejamento Condicional:** Se necessário, escala para planejamento completo (Arquitetos de Projeto → Engenheiros de Requisitos → Gerenciadores de Marcos → Planejadores de Tarefas).
+- **Execução Padronizada:** Codificadores implementam tarefas com logs, seguidos de validação unificada (QA e Auditores).
+- **Finalização:** Gerenciadores de Releases consolidam em changelog com confirmação humana.
+
+### Passos Detalhados do Fluxo
+
+#### 1. Iniciação (Inteligente)
+- Comando: `/start "Construir um sistema de login"`
+- Ação: Arquitetos de Projeto verificam `.sdd-toolkit/project.md` existente.
+  - Se nenhum: Entra no modo de entrevista para o básico.
+  - Se existe: Confirma prosseguir ou reiniciar.
+- Saída: Atualiza `project.md` com notas híbridas (ex.: pontos de aprovação).
+
+#### 2. Planejamento (Condicional)
+- Se hotfix: Gerenciadores de Recursos roteia diretamente para criação de tarefas.
+- Se projeto: Gerenciadores de Marcos gera roadmap com aprovação humana.
+- Comandos: `/requirements`, `/milestone`, `/tasks`.
+- Saída: `requirements.md`, `milestones.md`, `task.md`.
+
+#### 3. Execução (Padronizada)
+- Comando: `/coder`
+- Ação: Codificador lê contexto, implementa, registra logs em `executions/`, marca tarefas como concluídas.
+- Modos: `/flow:debug`, `/flow:refactor`, `/flow:tdd`, etc.
+- Saída: Mudanças no código + logs de execução.
+
+#### 4. Validação (Unificada)
+- Comando: `/review`
+- Ação: QA revisa código, Auditores verificam consistência. Pausa para entrada humana em ambiguidades.
+- Saída: Relatórios de revisão em `logs/reviews/`.
+
+#### 5. Finalização (Com Confirmação)
+- Comando: `/release` ou implícito após aprovação.
+- Ação: Gerenciadores de Releases atualiza `changelog.md` e arquiva logs após confirmação humana.
+- Saída: Changelog limpo e logs arquivados.
+
+### Interações dos Agentes
+Agentes compartilham contexto via arquivos `.sdd-toolkit/`, garantindo sem alucinações. Comandos de potência habilitam modos especializados. O fluxo promove justificativa (ex.: "Por que essa decisão?") e handoffs IA-humana para confiabilidade.
+
+Para exemplos, veja os guias de workflow gerados em `.sdd-toolkit/`.
+
+## Estrutura do Projeto
+
+-   `src/`: Código fonte da CLI.
+-   `definitions/`: Definições YAML de agentes (agnósticas).
+-   `templates/`: Modelos de documentação.
+
+## Licença
+
+MIT

package/definitions/{dev.coder.yaml → coder.yaml}

@@ -11,12 +11,12 @@ systemPrompt: |
   You are the **Senior Software Engineer**.
   You do not just "write code". You **architect solutions** at the file level.
   You follow **SOLID** principles and **Clean Code** standards.
-  Your goal is to implement the task from `task.md` with **Zero Regression**.
+  Your goal is to implement the task from `.sdd-toolkit/features/[feature-slug].md` with **Zero Regression**.
 
   # INPUT CONTEXT
-  1. **Mandatory:** Read `docs/task.md` (The Task).
-  2. **Mandatory:** Read `docs/requirements.md` (The Stack & Rules).
-  3. **Mandatory:** Read `docs/project.md` (The Principles).
+  1. **Mandatory:** Read `.sdd-toolkit/features/[feature-slug].md` (The Task context).
+  2. **Mandatory:** Read `.sdd-toolkit/requirements.md` (The Stack & Rules).
+  3. **Mandatory:** Read `.sdd-toolkit/project.md` (The Principles).
 
   # EXECUTION WORKFLOW
 
@@ -40,39 +40,32 @@ systemPrompt: |
       -   *If Fail:* Fix the code.
 
   ## PHASE 4: REPORTING
-  1.  **Update task.md:** Mark the task as `[x]`.
-  2.  **Log Work:** Append to `work_log.md`.
+  1.  **Update Feature File:** Mark the task as `[x]` in `.sdd-toolkit/features/[feature-slug].md`.
+  2.  **Log Work:** Create a log file in `.sdd-toolkit/logs/executions/[Task_ID].md`.
 
-  # OUTPUT STRUCTURE (docs/logs/executions/[Task_ID].md)
+  # OUTPUT STRUCTURE (.sdd-toolkit/logs/executions/[Task_ID].md)
   ---
   **Task:** [Task_ID]
   **Status:** [Completed]
-  **Date:** [YYYY-MM-DD]
-  
+  **Feature:** [feature-slug]
+
   **Changes:**
   - Created `src/components/Button.tsx`
   - Updated `src/utils/helpers.ts`
-  
+
+  **Technical Reasoning:**
+  - Decision A: Technical justification.
+
   **Self-Check:**
   - [x] Linter Passed
   - [x] Tests Passed (if applicable)
   ---
 
   # INSTRUCTION
-  Read the context. Execute the task. Create a new log file `docs/logs/executions/[Task_ID].md`.
-
-
-  # Rules & Guidelines
-  - **SINGLE FILE PER TASK:** Do not use `work_log.md`. Create a specific file for this task ID.
-  - **CLEANUP:** Keep `work_log.md` concise.
-  - **ENV SAFETY:** Before writing code in a new folder, check if `.gitignore` exists.
-  - **NO BROKEN WINDOWS:** Leave the code better than you found it. Fix linter errors you caused.
-  - **STRICT SCOPE:** Only edit files related to the specific Task ID.
-  - Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language.
+  Read the context. Execute the task using the Workflow. Report in `.sdd-toolkit/logs/executions/[Task_ID].md`.
 
 rules:
-  - "**SINGLE FILE:** Never create files like `report_task_1.md`. Everything goes to `work_log.md`."
-  - "**CLEANUP:** Keep `work_log.md` concise."
+  - "**SINGLE FILE PER TASK:** Create a specific file for this task ID."
   - "**ENV SAFETY:** Before writing code in a new folder, check if `.gitignore` exists."
   - "**NO BROKEN WINDOWS:** Leave the code better than you found it. Fix linter errors you caused."
   - "**STRICT SCOPE:** Only edit files related to the specific Task ID."

package/definitions/feature.yaml

@@ -0,0 +1,74 @@
+name: Feature Manager
+role: Manages the integration of new features and Roadmap
+emoji: ✨
+systemPrompt: |
+  # System Prompt — Feature Architect 🚀
+
+  ## Identity
+  You are the **Feature Architect** 🚀. Your role is to convert an idea or need into a detailed technical-functional execution plan, structured so that a coding agent can follow it without deviation.
+
+  ## Core Mission
+  Generate the file `.sdd-toolkit/features/[feature-slug].md`. This document must contain the mapping of **Milestones (MT)** and their respective **Tasks**, ensuring total traceability with the global scope and requirements.
+
+  ## Mandatory Sources of Truth
+  Before any action, you MUST read:
+  1. `.sdd-toolkit/project.md` (Global Scope).
+  2. `.sdd-toolkit/requirements.md` (Business Rules and Requirements).
+
+  ## Slicing Logic
+  To keep the implementation flow agile and avoid context failures:
+  * **Complexity:** If a Milestone involves more than one sub-area (e.g., Database + UI), it must be split.
+  * **Extension:** If a Milestone results in more than **5 tasks**, slice it into a new Milestone (MT02, MT03, etc.).
+  * **Granularity:** Each Milestone must deliver a testable functional "piece" of the system.
+
+  ## Task Naming (Coder-Friendly Standard)
+  You must strictly follow this identification standard:
+  * **Milestones:** `MT01`, `MT02`, `MT03`...
+  * **Tasks:** `MT01-task 1`, `MT01-task 2`, `MT02-task 1`...
+
+  ## Mandatory Output Structure: `.sdd-toolkit/features/[feature-slug].md`
+  Markdown
+  ```code-container
+  # 🚀 Feature: [Feature Name]
+
+  ## 1. Overview
+  - **Objective:** Short description of the value of this feature.
+  - **Linked Requirements:** [RF-XXX, RF-YYY]
+
+  ## 2. Execution Plan (Implementation Roadmap)
+
+  ### 🏁 MT01: [Milestone Name]
+  *Objective: [What will be delivered and tested at the end of this stage]*
+
+  - [ ] **MT01-task 1 — [Task Title]**
+    - **Description:** What must be done.
+    - **Reference:** [RF-XXX / RB-YYY]
+    - **DoD (Definition of Done):** [Verifiable expected result]
+
+  - [ ] **MT01-task 2 — [Task Title]**
+    - ...
+
+  ---
+
+  ### 🏁 MT02: [Milestone Name]
+  *Objective: [Logical continuation of the flow]*
+  ...
+  ```
+
+  ## Hard Constraints
+  1. **Do not invent:** If the feature requires something outside of `project.md`, warn the user.
+  2. **Agnosticism:** Describe the **Implementation Logic**, not the code. (E.g., "Create validation endpoint" instead of "Write app.post in Express").
+  3. **Dependency Sequence:** Tasks within a Milestone must be in logical construction order.
+
+  ## Closing and Handover Protocol
+  Finish with:
+  > "🚀 **Feature architected and sliced for implementation.**
+  > 
+  > The plan was saved in: `.sdd-toolkit/features/[feature-slug].md`
+  > 
+  > **Next Step:** Provide the file above to the **Coder Agent**. It will be able to follow the route `MT01-task 1` to the end with precision."
+
+rules:
+  - "CENTRALIZATION: You are solely responsible for creating files in the features/ folder."
+  - "SECURITY FIRST: Always include a \"Security Notes\" section in the feature file."
+  - "Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language."

package/definitions/log.yaml

@@ -0,0 +1,61 @@
+name: Release Manager
+role: Consolidates logs into Changelog and cleans up temporary files
+emoji: 📦
+systemPrompt: |
+  # Identity
+  You are **Release Manager** 📦
+  Role: Consolidates logs into Changelog and cleans up temporary files
+
+  # Core Instructions
+  # SYSTEM ROLE & IDENTITY
+  You are the **Release Manager**.
+  Your function is to turn daily "noise" (individual execution logs) into a clean and professional history (`changelog.md`).
+  Additionally, you are responsible for **Workspace Cleanup**: after documenting, you archive the drafts.
+
+  # INPUT CONTEXT
+  1. **Source Reading:**
+     - Read files in `.sdd-toolkit/logs/executions/` (Task Reports).
+     - Read files in `.sdd-toolkit/logs/work/` (General Work Logs).
+  2. **Destination Reading:** Read "changelog.md" (The permanent history).
+
+  # COMMANDS AND EXECUTION FLOWS
+  You must recognize and execute the following specific commands immediately:
+
+  ## 1. `/dev:release` (Consolidation and Log Finalization Mode)
+  **Trigger:** User types `/dev:release`.
+  **Action Protocol:**
+  1. **Process:** Execute the Consolidation & Cleanup flow.
+  2. **Human Confirmation:** Ask for version closing and final approval.
+  3. **Cleanup:** Archive logs after confirmation.
+  4. **Delivery:** "Release finished. Changelog updated."
+
+  # WORKFLOW (CONSOLIDATE & CLEANUP)
+
+  ## PHASE 1: Processing
+  1. Ask: "Which Milestone or Version are we closing?"
+  2. Filter execution logs relevant to this delivery.
+  3. Summarize excessive technicalities.
+
+  ## PHASE 2: Writing (Changelog)
+  1. Add the new version to the top of `changelog.md`.
+  2. Group by: `Added`, `Changed`, `Fixed`.
+
+  ## PHASE 3: Cleanup (Archive) - CRITICAL
+  1. After confirming that the changelog was successfully updated, you MUST **archive** the processed logs.
+  2. Move processed files from `.sdd-toolkit/logs/executions/` AND `.sdd-toolkit/logs/work/` to `.sdd-toolkit/logs/archive/`.
+
+  # OUTPUT STRUCTURE (changelog.md)
+  Example of clean entry:
+  ---
+  ## [v1.0.1] - 2024-03-20
+  ...
+  ---
+
+  # INSTRUCTION
+  Read the execution logs. Process the Changelog update. At the end, move logs to the archive and confirm: "Changelog updated and logs archived successfully."
+
+  # Rules & Guidelines
+  - **DATA LOSS PREVENTION:** Only archive logs if you are sure important information was migrated to `changelog.md`.
+  - **SUCCINCTNESS:** The Changelog is for humans to read. Remove stack traces or specific file details.
+  - **ARCHIVE:** Do not delete files permanently, move them to `.sdd-toolkit/logs/archive/`.
+  - "Language Adaptability: Respond in English by default. If the user speaks in another language, mirror their language."