ai-qakit 1.0.0

package/templates/.claude/commands/devkit/spec/implement.md

@@ -0,0 +1,350 @@
+---
+description: Start coding an existing task (use /spec:test for testing)
+argument-hint: [task-id]
+allowed-tools: Read, Write, Edit, Task, Bash, Grep, AskUserQuestion, Skill
+---
+
+<!--
+Usage: /spec:implement [task-id]
+Example: /spec:implement ABC-123
+Example: /spec:implement TICKET-456
+Requires: Task must exist with plan in ./.claude/tasks/[task-id]/plan/
+-->
+
+**MUST READ** `CLAUDE.md` then **THINK HARDER** to start working on the following plan follow the Orchestration Protocol, Core Responsibilities, Subagents Team and Development Rules:
+<task-id>$ARGUMENTS</task-id>
+
+---
+
+## Phase 0: Setup & Validation
+
+### Step 0.1: Sub-Agent Report Preference (MANDATORY)
+
+**Before spawning ANY sub-agent**, you MUST ask user about report preference:
+
+Use `AskUserQuestion` tool:
+```
+question: "How should sub-agent reports be delivered?"
+header: "Report Style"
+options:
+  - label: "Inline Report (Recommended)"
+    description: "Brief summary displayed in conversation, no file saved"
+  - label: "Detailed Report"
+    description: "Full analysis saved to ./.claude/tasks/[TASK-ID]/reports/"
+```
+
+**Pass preference to ALL sub-agent prompts:**
+- Inline selected → Add `generate_report: false` to prompt
+- Detailed selected → Add `generate_report: true` to prompt
+
+**IMPORTANT:** Do NOT spawn any sub-agent until this question is answered.
+
+### Step 0.2: Validate Task
+
+1. If task-id not provided, use `AskUserQuestion` to ask for it
+2. Verify `./.claude/tasks/$ARGUMENTS/` directory exists
+3. If not found, return error: "Task not found. Run `/devkit:spec:task` first."
+4. Verify `./.claude/tasks/$ARGUMENTS/plan/plan.md` exists
+5. If not found, return error: "Plan not found. Run `/devkit:spec:plan` first."
+
+---
+
+## Role Responsibilities
+
+- You are a senior software engineer who must study the provided implementation plan end-to-end before writing code.
+- Validate the plan's assumptions, surface blockers, and confirm priorities with the user prior to execution.
+- Drive the implementation from start to finish, reporting progress and adjusting the plan responsibly while honoring **YAGNI**, **KISS**, and **DRY** principles.
+- **DO NOT create any tests** (unit tests, integration tests, E2E tests). Testing is handled separately via `/devkit:spec:test` command.
+
+**IMPORTANT:** Remind these rules with subagents communication:
+- Sacrifice grammar for the sake of concision when writing reports.
+- In reports, list any unresolved questions at the end, if any.
+
+- **CRITICAL:** You MUST strictly follow `./docs/development-rules.md` in ALL circumstances. If that file doesn't exist, follow `./.claude/doc-templates/development-rules.md` instead. This is NON-NEGOTIABLE.
+- **CRITICAL:** You MUST strictly follow `./.claude/rules/index.md` (Read it carefully first to know clearly about the development rules before starting the implementation, and don't skip any rule, it's very important!!!) in ALL circumstances. This is NON-NEGOTIABLE.
+
+---
+
+## Your Approach
+
+## Step 0: Plan Detection & Phase Selection
+1. **Absorb the Plan**: Read `./.claude/tasks/$ARGUMENTS/plan/plan.md`, map dependencies, and list ambiguities.
+2. Parse plan for phases and status, auto-select next incomplete (prefer IN_PROGRESS or earliest Planned)
+
+**Output:** `✓ Step 0: [Plan Name] - [Phase Name]`
+
+**Subagent Pattern (use throughout):**
+```
+Task(subagent_type="[type]", prompt="[task description]", description="[brief]")
+```
+
+---
+
+## Workflow Sequence
+
+**Rules:** Follow steps 1-6 in order. Each step requires output marker starting with "✓ Step N:". Mark each complete in TodoWrite before proceeding. Do not skip steps. User approval (Step 4) is MANDATORY before finalizing. Step 6 asks user if they want to continue to next phase (skipped if last phase).
+
+**Note:** Testing is handled separately via `/devkit:spec:test` command.
+
+---
+
+## Step 1: Analysis & Task Extraction
+
+Read plan file completely. Map dependencies between tasks. List ambiguities or blockers. Identify required skills/tools and activate from catalog. Parse phase file and extract actionable tasks.
+
+**TodoWrite Initialization & Task Extraction:**
+- Initialize TodoWrite with `Step 0: [Plan Name] - [Phase Name]` and all command steps (Step 1 through Step 5)
+- Read phase file (e.g., phase-01-preparation.md)
+- Look for tasks/steps/phases/sections/numbered/bulleted lists
+- MUST convert to TodoWrite tasks:
+  - Phase Implementation tasks → Step 2.X (Step 2.1, Step 2.2, etc.)
+  - Phase Code Review tasks → Step 3.X (Step 3.1, Step 3.2, etc.)
+- Ensure each task has UNIQUE name (increment X for each task)
+- Add tasks to TodoWrite after their corresponding command step
+
+**Output:** `✓ Step 1: Found [N] tasks across [M] phases - Ambiguities: [list or "none"]`
+
+Mark Step 1 complete in TodoWrite, mark Step 2 in_progress.
+
+---
+
+## Step 2: Implementation
+
+**CRITICAL: Extract plan metadata from frontmatter:**
+   ```yaml
+   platform: frontend | backend | fullstack
+   api-approach: schema-first | code-first | no-api
+   openapi-spec: path/to/spec  # if schema-first
+   generator-config: path/to/config  # if schema-first
+   ```
+
+**Use `coder` sub-agent** with Structured Context Protocol for skill detection:
+
+```
+Task(subagent_type="coder", prompt="
+---
+context:
+  task-id: [task-id]
+  platform: [frontend | backend | fullstack]
+  task-type: [ui, api, database, auth, performance, infrastructure]
+  files: [list of files to create/modify]
+  technologies: [React, TypeScript, PostgreSQL, etc.]
+---
+
+Implement [task-id] phase [phase-name].
+
+Plan: [plan summary]
+Tasks to implement: [task list from Step 2.X]
+
+[task description summary]
+
+SKILL USAGE: Check <available_skills> and use Skill tool for matching tasks.
+", description="Implement phase [phase-name]")
+```
+
+Implement selected plan phase step-by-step following extracted tasks (Step 2.1, Step 2.2, etc.). Mark tasks complete as done. Use `ai-multimodal` skill for image assets, `imagemagick` for editing. Run type checking and compile to verify no syntax errors.
+
+**Output:** `✓ Step 2: Implemented [N] files - [X/Y] tasks complete, compilation passed`
+
+Mark Step 2 complete in TodoWrite, mark Step 3 in_progress.
+
+---
+
+## Step 3: Code Review (ONLY AFTER ALL PHASES COMPLETE)
+
+**CRITICAL:** This step is SKIPPED unless this is the LAST phase of the plan.
+
+**Before proceeding, check:**
+1. Count total phases in the plan
+2. Count completed phases (including current phase being finalized)
+3. If completed phases < total phases → **SKIP Step 3**, go directly to Step 4
+
+**If this is the LAST phase (all phases now complete):**
+
+**MANDATORY: Collect ALL files before review:**
+1. Read the plan file to get the complete list of ALL phases
+2. For EACH phase, collect ALL files that were created or modified
+3. Compile a COMPLETE file list covering the ENTIRE plan (not just 1-2 files)
+4. Pass this COMPLETE list to the code-reviewer
+
+Call `code-reviewer` subagent: "Review ALL code changes for task [task-id] across the ENTIRE plan.
+
+**COMPLETE FILE LIST (all phases):**
+- Phase 1: [list all files from phase 1]
+- Phase 2: [list all files from phase 2]
+- Phase N: [list all files from phase N]
+
+Review ALL [total count] files as a SINGLE batch - NOT one file at a time. Do NOT skip any files. Check security, performance, architecture, YAGNI/KISS/DRY against ./docs/code-standards.md and ./.claude/rules/index.md."
+
+If critical issues found: STOP, fix all, re-run `code-reviewer`. Repeat until no critical issues.
+
+**Critical issues:** Security vulnerabilities (XSS, SQL injection, OWASP), performance bottlenecks, architectural violations, principle violations.
+
+**Output (skipped):** `⏭ Step 3: Skipped - [N] phases remaining`
+**Output (reviewed):** `✓ Step 3: Code reviewed - [0] critical issues`
+
+**Validation:** If critical issues > 0, Step 3 INCOMPLETE - do not proceed.
+
+Mark Step 3 complete (or skipped) in TodoWrite, mark Step 4 in_progress.
+
+---
+
+## Step 4: User Approval
+
+**REQUIRED:** Before finalizing, get explicit user approval for the completed phase.
+
+1. **Present Phase Summary:**
+   - Files created/modified
+   - Key changes implemented
+   - Code review status (if applicable)
+
+2. **Request Approval:**
+   Use `AskUserQuestion`: "Phase [phase-name] implementation complete. Please review the changes and confirm:\n\n**Files Changed:** [list]\n**Key Changes:** [summary]\n**Code Review:** [status]\n\nApprove this phase? (yes/no/feedback)"
+
+3. **Handle Response:**
+   - **"yes" or approval:** Proceed to Step 5
+   - **"no" or rejection:** STOP, ask for specific feedback, return to relevant step (2/3)
+   - **feedback provided:** Address feedback, re-run affected steps, request approval again
+
+**Output:** `✓ Step 4: User approved phase [phase-name]`
+
+**Validation:** User must explicitly approve. Do not proceed without approval.
+**IMPORTANT:** Must use `AskUserQuestion` tool to ask for approval, do not stop the process.
+
+Mark Step 4 complete in TodoWrite, mark Step 5 in_progress.
+
+---
+
+## Step 5: Finalize
+
+1. **STATUS UPDATE:**
+- **Call** `project-manager` sub-agent: "Update plan status in [plan-path]. Mark plan phase [phase-name] as DONE with timestamp. Update roadmap."
+
+2. **ONBOARDING CHECK:** Detect onboarding requirements (API keys, env vars, config) + generate summary report with next steps.
+
+3. Check if this a the last phase of the plan. If it is, **CLEANUP:** Remove `./.claude/active-task` file to mark task as no longer active. (Note that only remove the file incase of all the plan phases are completed, it's **IMPORTANT** to not remove the file in the middle of the workflow.)
+
+**Output:** `✓ Step 5: Finalized - Status updated, roadmap current`
+
+**Validation:** Steps 1 and 2 must complete successfully.
+
+Mark Step 5 complete in TodoWrite.
+
+**Phase workflow finished.**
+
+---
+
+## Step 6: Continue to Next Phase (ONLY IF MORE PHASES REMAIN)
+
+**CRITICAL:** This step is SKIPPED if this was the LAST phase of the plan.
+
+**Check remaining phases:**
+1. Count total phases in the plan
+2. Count completed phases (including current phase just finalized)
+3. If completed phases = total phases → **SKIP Step 6**, go directly to Summary Output
+
+**If more phases remain:**
+
+Use `AskUserQuestion` tool:
+```
+question: "Phase [phase-name] completed successfully. Do you want to proceed to the next phase?"
+header: "Next Phase"
+options:
+  - label: "Yes, continue (Recommended)"
+    description: "Proceed to implement the next phase immediately"
+  - label: "No, stop here"
+    description: "Pause implementation and return later with /devkit:spec:implement"
+```
+
+**Handle Response:**
+- **"Yes, continue":** Loop back to Step 0 and continue with the next incomplete phase
+- **"No, stop here":** Proceed to Summary Output and exit
+
+**Output (skipped - last phase):** `⏭ Step 6: Skipped - All phases complete`
+**Output (continuing):** `✓ Step 6: User chose to continue - Proceeding to next phase`
+**Output (stopping):** `⏸ Step 6: User chose to stop - Pausing implementation`
+
+Mark Step 6 complete in TodoWrite.
+
+---
+
+## Summary Output
+
+**IMPORTANT:** The "NEXT STEPS" section must be conditional:
+- Check if all plan phases are completed (compare completed phases vs total phases in plan)
+- Only show testing recommendation if this was the last phase
+- Otherwise, show continuation message for next phase
+
+```
+════════════════════════════════════════════════════════════════════
+                    ✅ IMPLEMENTATION COMPLETE
+════════════════════════════════════════════════════════════════════
+
+TASK: $ARGUMENTS
+PHASE: [phase-name]
+
+STEPS COMPLETED:
+  ✓ Step 1: Analysis & Task Extraction
+  ✓ Step 2: Implementation
+  ⏭ Step 3: Code Review (skipped - more phases remain)
+     OR ✓ Step 3: Code Review (all phases complete)
+  ✓ Step 4: User Approval
+  ✓ Step 5: Finalize
+  ⏭ Step 6: Continue (skipped - all phases complete)
+     OR ⏸ Step 6: User chose to stop
+
+FILES MODIFIED: [count] files
+TASKS COMPLETED: [X/Y] tasks
+
+NEXT STEPS:
+  [If more phases remain:]
+    → Continue with next phase: /devkit:spec:implement $ARGUMENTS
+
+  [If all phases complete:]
+    → Ready for testing? Run: /devkit:spec:test $ARGUMENTS
+
+════════════════════════════════════════════════════════════════════
+```
+
+---
+
+## Critical Enforcement Rules
+
+**Step outputs must follow unified format:** `✓ Step [N]: [Brief status] - [Key metrics]`
+
+**Examples:**
+- Step 0: `✓ Step 0: [Plan Name] - [Phase Name]`
+- Step 1: `✓ Step 1: Found [N] tasks across [M] phases - Ambiguities: [list]`
+- Step 2: `✓ Step 2: Implemented [N] files - [X/Y] tasks complete`
+- Step 3: `⏭ Step 3: Skipped - [N] phases remaining` (if more phases remain)
+- Step 3: `✓ Step 3: Code reviewed - [0] critical issues` (ONLY after ALL phases complete)
+- Step 4: `✓ Step 4: User approved phase [phase-name]`
+- Step 5: `✓ Step 5: Finalized - Status updated, roadmap current`
+- Step 6: `⏭ Step 6: Skipped - All phases complete` (if last phase)
+- Step 6: `✓ Step 6: User chose to continue - Proceeding to next phase`
+- Step 6: `⏸ Step 6: User chose to stop - Pausing implementation`
+
+**If any "✓ Step N:" output missing, that step is INCOMPLETE.**
+
+**TodoWrite tracking required:** Initialize at Step 0, mark each step complete before next.
+
+**Mandatory subagent calls:**
+- Step 3: `code-reviewer` (ONLY after ALL phases complete - skip if more phases remain)
+- Step 4: `AskUserQuestion` (REQUIRED - user approval)
+- Step 5: `project-manager`
+- Step 6: `AskUserQuestion` (REQUIRED if more phases remain - ask to continue)
+
+**Blocking gates:**
+- Step 3: Critical issues must be 0 (only when code review is executed)
+- Step 4: User must explicitly approve phase
+- Step 5: `project-manager` must complete successfully
+
+**Testing:** Use `/devkit:spec:test` command separately for comprehensive testing with 100% code coverage.
+
+**REMEMBER:**
+- **CRITICAL:** ALWAYS follow `./docs/development-rules.md` (Project specific) and `./.claude/workflows/development-rules.md` (General development rules) - NO EXCEPTIONS.
+- **NO TESTS:** Do not create unit tests, integration tests, or E2E tests. Use `/devkit:spec:test` command for testing.
+- Do not skip steps. Do not proceed if validation fails. Do not assume approval without user response.
+- One plan phase per command run. Command focuses on single plan phase only.
+- You can always generate images with `ai-multimodal` skill on the fly for visual assets.
+- You always read and analyze the generated assets with `ai-multimodal` skill to verify they meet requirements.

package/templates/.claude/commands/devkit/spec/plan.md

@@ -0,0 +1,269 @@
+---
+description: Research, analyze, and create an implementation plan
+argument-hint: [task-id]
+allowed-tools: Read, Write, MultiEdit, Bash, LS, Glob, Grep, WebSearch, WebFetch, Task, AskUserQuestion, Skill
+---
+
+Ultrathink
+Activate `planning` skill.
+NOTE that: You MUST activate the `planning` skill for this command to work.
+IF the `planning` skill is not activated, throw an error.
+
+## Your mission
+
+Create an implementation plan for task: **$ARGUMENTS**
+
+## Pre-Creation Check (Active Task Detection)
+
+**IMPORTANT:** Read and do carefully the following steps.
+
+Before creating plan folder:
+
+**Check state file:** If `./.claude/active-task` exists AND points to valid directory:
+    - Use `AskUserQuestion` tool to ask the user: "Active task found: {path}. Continue with this? [Y/n]"
+    - If Y (default): Pass existing task path to subcommand, skip folder creation
+    - If n:
+        - Write path to `./.claude/active-task` with the current task path (example: `./.claude/tasks/AI-123`)
+        - Proceed to the workflow
+  - If not exists or invalid:
+    - Write path to `./.claude/active-task` with the current task path (example: `./.claude/tasks/AI-123`)
+    - Proceed to the workflow
+
+## Workflow
+
+### Phase 0: Sub-Agent Report Preference (MANDATORY)
+
+**Before spawning ANY sub-agent**, you MUST ask user about report preference:
+
+Use `AskUserQuestion` tool:
+```
+question: "How should sub-agent reports be delivered?"
+header: "Report Style"
+options:
+  - label: "Inline Report (Recommended)"
+    description: "Brief summary displayed in conversation, no file saved"
+  - label: "Detailed Report"
+    description: "Full analysis saved to ./.claude/tasks/[TASK-ID]/reports/"
+```
+
+**Pass preference to ALL sub-agent prompts:**
+- Inline selected → Add `generate_report: false` to prompt
+- Detailed selected → Add `generate_report: true` to prompt
+
+**IMPORTANT:** Do NOT spawn any sub-agent until this question is answered.
+
+---
+
+1. **Validate task exists**
+   - Verify `./.claude/tasks/[task-id]/` directory exists
+   - If not found, return error: "Task not found. Run `/devkit:spec:task` first."
+
+2. **Detect coding platform** (auto-detect, do not ask user)
+   - Analyze source code to determine platform type:
+     - Check `package.json` dependencies (React/Vue/Angular/Next.js = frontend; Express/NestJS/Fastify = backend)
+     - Check for frontend indicators: `src/components/`, `src/pages/`, `vite.config.*`, `next.config.*`, `.tsx/.jsx` files
+     - Check for backend indicators: `src/controllers/`, `src/routes/`, `src/services/`, `Dockerfile`, `docker-compose.*`
+     - Check for Python backend: `requirements.txt`, `pyproject.toml`, FastAPI/Django/Flask imports
+     - Check for Java/Kotlin backend: `pom.xml`, `build.gradle`, Spring Boot annotations
+   - Determine platform: **frontend** | **backend** | **fullstack** (if both indicators present)
+   - Store decision in plan metadata for `/devkit:spec:implement` to use
+
+3. **Detect API development approach** (auto-detect, do not ask user)
+   - Analyze project to determine API approach:
+     - **Schema-first indicators** (OpenAPI/Swagger first, then generate code):
+       - OpenAPI spec files: `openapi.yaml`, `openapi.json`, `swagger.yaml`, `swagger.json`, `api-spec.*`
+       - Code generation config: `openapitools.json`, `.openapi-generator/`, `nswag.json`
+       - Generator dependencies: `@openapitools/openapi-generator-cli`, `openapi-typescript`, `swagger-codegen`, `nswag`
+       - Generated code directories: `generated/`, `api-client/`, `src/generated/`, `__generated__/`
+       - Build scripts containing: `openapi-generator`, `swagger-codegen`, `nswag`
+     - **Code-first indicators** (write code, generate spec from annotations):
+       - Swagger decorators: `@ApiProperty`, `@ApiOperation`, `@ApiResponse` (NestJS)
+       - OpenAPI annotations in code: `@OpenAPI`, `@Schema` (Java/Spring)
+       - Doc generation tools: `swagger-jsdoc`, `tsoa`, `springdoc-openapi`
+   - Determine approach: **schema-first** | **code-first** | **no-api** (if no API indicators)
+   - **CRITICAL**: Store this in plan metadata - implementation MUST respect this approach:
+     - Schema-first: Update OpenAPI spec → Run generator → Use generated DTOs/types
+     - Code-first: Write code with annotations → Generate spec as documentation
+   - Store decision in plan metadata for `/devkit:spec:implement` to use
+
+4. **Read all task requirements**
+   - Read ALL files in `./.claude/tasks/[task-id]/requirement/` directory (Read carefully the content of each file, if any file is missing, ignore it)
+      - `01.funtional.md` to understand the functional requirements (Functional requirements discovered)
+      - `02.non-functional.md` to understand the non-functional requirements (Performance, security, scalability needs)
+      - `03.constraints.md` to understand the Technical constraints and limitations
+      - `04.decisions.md` to understand the Key decisions made with rationale
+      - `05.risks.md` to understand the Identified risks and mitigations
+   - Understand the full scope before planning
+   - If any thing still unclear, use `AskUserQuestion` tool to ask for more details if needed. DO NOT GUESS, DO NOT INVENT.
+
+5. **Review existing research**
+   - Read ALL files in `./.claude/tasks/[task-id]/research/` directory
+   - Research should already exist from `/devkit:spec:capture-requirement` or `/devkit:spec:brainstorm`
+   - If research folder is empty, ignore it and continue with the next step
+   - Synthesize research findings for planning context
+
+6. **Analyze project documentation**
+   - Read core docs: `codebase-summary.md`, `code-standards.md`, `system-architecture.md`, `project-overview-pdr.md`, `technical-documents.md`
+   - Scan and read ALL other documentation found in:
+     - `./docs/` directory (if exists)
+     - `./.claude/docs/` directory (if exists)
+     - Any `*.md` files in project root
+     - Any `README.md` files in key directories
+   - **ONLY IF `codebase-summary.md` unavailable or older than 3 days**: Use `/scout <instructions>` to search codebase
+   - Analyze the given task and use `AskUserQuestion` tool to ask for more details if needed.
+
+7. **CRITICAL - Identify reusable resources**
+   - **Scout for existing code to REUSE** before planning new implementations:
+     - Existing utils, helpers, services that provide similar functionality
+     - Existing components, modules that can be extended
+     - Existing patterns and conventions in the codebase
+   - **DO NOT create duplicates** - if similar code exists, plan to extend/modify it
+   - **Follow existing patterns** - maintain consistency with codebase conventions
+   - Document all reusable resources in the plan for implementers to use
+
+8. **Create plan files**
+   - Save all plan files directly in `./.claude/tasks/[task-id]/plan/`
+   - Pass this directory path to every subagent during the process
+
+9. **Create implementation plan**
+   - Main agent gathers all research and scout report filepaths
+   - Pass them to `planner` subagent to create implementation plan
+   - Follow strictly the "Plan Creation & Organization" rules of `planning` skill
+   - **For schema-first projects**: Ensure API-related phases follow: OpenAPI spec update → Code generation → Implementation using generated types
+   - **For code-first projects**: Ensure implementation includes proper annotations → Spec generation as final step
+   - **NO TESTS**: Do not include unit tests, integration tests, or E2E tests in the plan (testing is handled separately via `/devkit:spec:test`)
+
+10. **Add mandatory code review phase**
+    - Always include a final phase: `phase-XX-code-review.md`
+    - This phase MUST run `/review:code` on ALL files created/modified during implementation
+    - Review against `./.claude/rules/index.md` development rules
+    - Fix ALL violations until code is fully compliant
+    - This phase is NON-NEGOTIABLE and must be the last implementation phase
+
+11. **Use `AskUserQuestion` tool to ask user to review the plan**
+
+## Output Requirements
+
+**Task Directory Structure**
+```
+./.claude/tasks/[task-id]/
+├── README.md
+├── requirement/
+│   └── ...
+├── research/                # Pre-existing from capture-requirement/brainstorm
+│   └── ...                  # (Read-only during planning)
+├── reports/                 # (Reports from all subagents)
+│   └── ...
+└── plan/
+    ├── plan.md
+    ├── phase-01-phase-name.md
+    ├── phase-02-phase-name.md
+    ├── ...
+    └── phase-XX-code-review.md  # MANDATORY final phase
+```
+
+**Note:** Research is conducted during `/devkit:spec:capture-requirement` or `/devkit:spec:brainstorm` phases. Planning uses existing research artifacts - no new research is generated here.
+
+**Plan File Specification**
+- Save the overview at `./.claude/tasks/[task-id]/plan/plan.md`
+  - Keep it generic, under 80 lines
+  - **MUST include metadata section at top**:
+    ```yaml
+    ---
+    platform: frontend | backend | fullstack
+    api-approach: schema-first | code-first | no-api
+    openapi-spec: path/to/openapi.yaml  # if schema-first
+    generator-config: path/to/config    # if schema-first
+    ---
+    ```
+  - List each implementation phase with status and progress
+  - Include links to phase files and requirement docs
+- For each phase, create `phase-XX-phase-name.md` containing:
+  - Context links (reference parent plan, dependencies, requirement docs)
+  - Overview (date, description, priority, implementation status, review status)
+  - Key Insights
+  - Requirements (reference specific files from requirement/ folder)
+  - Architecture
+  - Related code files
+  - Implementation Steps
+  - Todo list
+  - Success Criteria
+  - Risk Assessment
+  - Security Considerations
+  - Next steps
+
+**Schema-First API Implementation Pattern**
+When `api-approach: schema-first`, phases involving API changes MUST follow this order:
+1. **Phase: OpenAPI Spec Update** - Modify the OpenAPI/Swagger spec file first
+   - Add/modify endpoints, request/response schemas
+   - Update DTOs, enums, and type definitions in the spec
+2. **Phase: Code Generation** - Run the code generator
+   - Execute the project's generator command (check `package.json` scripts or generator config)
+   - Verify generated types/DTOs are created correctly
+3. **Phase: Implementation** - Write business logic using generated types
+   - Import and use ONLY the generated DTOs/types
+   - NEVER manually create DTOs that should be generated
+   - Reference generated files in implementation
+
+**Code-First API Implementation Pattern**
+When `api-approach: code-first`, phases involving API changes follow:
+1. **Phase: Implementation** - Write code with proper annotations
+   - Add `@ApiProperty`, `@ApiOperation`, etc. decorators
+   - Define DTOs with validation decorators
+2. **Phase: Spec Generation** - Generate OpenAPI spec from code (if needed)
+   - Run spec generation command to update documentation
+
+**Code Review Phase Template (phase-XX-code-review.md)**
+- This phase is MANDATORY and must always be the final phase
+- Contents must include:
+  - Context: Link to plan.md and list of all files created/modified
+  - Objective: Review all code against `./.claude/rules/index.md`
+  - Command: Run `/review:code` on each file/folder
+  - Checklist: All 15 clean code rules from index.md
+  - Success Criteria: Zero violations, all rules satisfied
+  - Iteration: Fix → Re-review → Repeat until compliant
+
+## Summary Output
+
+```
+════════════════════════════════════════════════════════════════════
+                    📋 PLAN CREATED
+════════════════════════════════════════════════════════════════════
+
+TASK: $ARGUMENTS
+PLATFORM: [frontend | backend | fullstack]
+API APPROACH: [schema-first | code-first | no-api]
+
+PLAN FILES:
+  📄 ./.claude/tasks/$ARGUMENTS/plan/plan.md
+  📄 ./.claude/tasks/$ARGUMENTS/plan/phase-01-*.md
+  📄 ./.claude/tasks/$ARGUMENTS/plan/phase-02-*.md
+  ...
+  📄 ./.claude/tasks/$ARGUMENTS/plan/phase-XX-code-review.md
+
+PHASES: [count] phases planned
+REUSABLE RESOURCES: [count] existing code/patterns identified
+
+NEXT STEPS:
+  1. Review the plan in ./.claude/tasks/$ARGUMENTS/plan/
+  2. If changes needed, run `/devkit:spec:update-plan $ARGUMENTS [description]`
+  3. Run `/devkit:spec:implement $ARGUMENTS` to start implementation
+
+Need to modify the plan? Run:
+  → /devkit:spec:update-plan $ARGUMENTS [describe changes]
+
+Ready to implement? Run:
+  → /devkit:spec:implement $ARGUMENTS
+
+════════════════════════════════════════════════════════════════════
+```
+
+## Important Notes
+- **CRITICAL:** You MUST strictly follow `./docs/development-rules.md` (Project specific) and `./.claude/doc-templates/development-rules.md` (General development rules) IN ALL circumstances. This is NON-NEGOTIABLE.
+- **CRITICAL:** You MUST strictly follow `./.claude/rules/index.md` (Read it carefully first to know clearly about the development rules before starting the implementation, and don't skip any rule, it's very important!!!) in ALL circumstances. This is NON-NEGOTIABLE.
+- **IMPORTANT:** Analyze the skills catalog and activate the skills that are needed for the task during the process.
+- **IMPORTANT:** Ensure token efficiency while maintaining high quality.
+- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+- **IMPORTANT:** Do NOT include tests in the plan - testing is handled separately via `/devkit:spec:test` command.
+- **IMPORTANT**: **Do not** start implementing.