create-ai-project 1.11.2

package/.claude/commands-en/build.md

@@ -0,0 +1,77 @@
+---
+description: Execute decomposed tasks in autonomous execution mode
+---
+
+Follow @docs/guides/sub-agents.md strictly and act as the **orchestrator**.
+
+Work plan: $ARGUMENTS
+
+## 📋 Pre-execution Prerequisites
+
+### Task File Existence Check
+```bash
+# Check work plans
+! ls -la docs/plans/*.md | grep -v template | tail -5
+
+# Check task files
+! ls docs/plans/tasks/*.md 2>/dev/null || echo "⚠️ No task files found"
+```
+
+### Task Generation Decision Flow
+
+**Think deeply** Analyze task file existence state and determine the appropriate action:
+
+| State | Criteria | Next Action |
+|-------|----------|-------------|
+| Tasks exist | .md files in tasks/ directory | Proceed to autonomous execution |
+| No tasks + plan exists | Plan exists but no task files | Confirm with user → run task-decomposer |
+| Neither exists | No plan or task files | Error: Prerequisites not met |
+
+## 🔄 Task Decomposition Phase (Conditional)
+
+When task files don't exist:
+
+### 1. User Confirmation
+```
+No task files found.
+Work plan: docs/plans/[plan-name].md
+
+Generate tasks from the work plan? (y/n):
+```
+
+### 2. Task Decomposition (if approved)
+```
+@task-decomposer Read work plan and decompose into atomic tasks:
+- Input: docs/plans/[plan-name].md
+- Output: Individual task files in docs/plans/tasks/
+- Granularity: 1 task = 1 commit = independently executable
+```
+
+### 3. Verify Generation
+```bash
+# Verify generated task files
+! ls -la docs/plans/tasks/*.md | head -10
+```
+
+✅ **Recommended**: After task generation, automatically proceed to autonomous execution
+❌ **Avoid**: Starting implementation without task generation
+
+## 🧠 Task Execution Flow
+Following "Autonomous Execution Task Management" in sub-agents.md, manage 4 steps with TodoWrite:
+1. task-executor execution
+2. Escalation judgment and follow-up
+3. quality-fixer execution
+4. git commit
+
+After approval confirmation, start autonomous execution mode. Stop immediately when requirement changes detected.
+
+## Output Example
+Implementation phase completed.
+- Task decomposition: Generated under docs/plans/tasks/ (if executed)
+- Implemented tasks: [number] tasks
+- Quality checks: All passed
+- Commits: [number] commits created
+
+**Responsibility Boundary**:
+- IN SCOPE: Task decomposition to implementation completion
+- OUT OF SCOPE: Design phase, planning phase

package/.claude/commands-en/design.md

@@ -0,0 +1,39 @@
+---
+description: Execute from requirement analysis to design document creation
+---
+
+**Command Context**: This command is dedicated to the design phase.
+
+Following the design flow described in @docs/guides/sub-agents.md, execute **from requirement-analyzer to design document creation and approval**.
+
+Requirements: $ARGUMENTS
+
+**Think harder** Considering the deep impact on design, first engage in dialogue to understand the background and purpose of requirements:
+- What problems do you want to solve?
+- Expected outcomes and success criteria
+- Relationship with existing systems
+
+Once requirements are moderately clarified, analyze with requirement-analyzer and create appropriate design documents according to scale.
+
+Clearly present design alternatives and trade-offs.
+
+**Scope Boundary**:
+- IN SCOPE: Design document (ADR/Design Doc) approval + Design Doc consistency verification
+- OUT OF SCOPE: Work planning and implementation phases
+
+## Execution Flow
+
+1. requirement-analyzer → Requirement analysis
+2. technical-designer → Design Doc creation
+3. document-reviewer → Single document quality check
+4. User approval (WAIT for approval)
+5. design-sync → Design Doc consistency verification
+   - IF conflicts found → Report to user → Wait for fix instructions → Fix with technical-designer(update)
+   - IF no conflicts → End
+
+## Output Example
+Design phase completed.
+- Design document: docs/design/[document-name].md
+- Consistency: No conflicts with other Design Docs (or fixes completed)
+
+**Important**: This command ends with design approval + consistency verification. Does not propose transition to next phase.

package/.claude/commands-en/front-build.md

@@ -0,0 +1,103 @@
+---
+description: Execute frontend implementation in autonomous execution mode
+---
+
+**Command Context**: As orchestrator, autonomously completes frontend implementation in autonomous execution mode.
+
+Work plan: $ARGUMENTS
+
+## 📋 Pre-execution Prerequisites
+
+### Task File Existence Check
+```bash
+# Check work plans
+! ls -la docs/plans/*.md | grep -v template | tail -5
+
+# Check task files
+! ls docs/plans/tasks/*.md 2>/dev/null || echo "⚠️ No task files found"
+```
+
+### Task Generation Decision Flow
+
+**Think deeply**: Analyze task file existence state and determine the appropriate action:
+
+| State | Criteria | Next Action |
+|-------|----------|-------------|
+| Tasks exist | .md files in tasks/ directory | Proceed to autonomous execution |
+| No tasks + plan exists | Plan exists but no task files | Confirm with user → run task-decomposer |
+| Neither exists | No plan or task files | Error: Prerequisites not met |
+
+## 🔄 Task Decomposition Phase (Conditional)
+
+When task files don't exist:
+
+### 1. User Confirmation
+```
+No task files found.
+Work plan: docs/plans/[plan-name].md
+
+Generate tasks from the work plan? (y/n):
+```
+
+### 2. Task Decomposition (if approved)
+```
+@task-decomposer Read work plan and decompose into atomic tasks:
+- Input: docs/plans/[plan-name].md
+- Output: Individual task files in docs/plans/tasks/
+- Granularity: 1 task = 1 commit = independently executable
+```
+
+### 3. Verify Generation
+```bash
+# Verify generated task files
+! ls -la docs/plans/tasks/*.md | head -10
+```
+
+✅ **Recommended**: After task generation, automatically proceed to autonomous execution
+❌ **Avoid**: Starting implementation without task generation
+
+## 🧠 Metacognition for Each Task - Frontend Specialized
+
+**Required Execution Cycle**: `task-executor-frontend → quality-fixer-frontend → commit`
+
+### Sub-agent Invocation Method
+Use Task tool to invoke sub-agents:
+- `subagent_type`: Agent name
+- `description`: Brief task description (3-5 words)
+- `prompt`: Specific instructions
+
+### Structured Response Specification
+Each sub-agent responds in JSON format:
+- **task-executor-frontend**: status, filesModified, testsAdded, readyForQualityCheck
+- **quality-fixer-frontend**: status, checksPerformed, fixesApplied, approved
+
+### Execution Flow for Each Task
+
+Execute for EACH task:
+
+1. **USE task-executor-frontend**: Execute frontend implementation
+   - Invocation example: `subagent_type: "task-executor-frontend"`, `description: "Task execution"`, `prompt: "Task file: docs/plans/tasks/[filename].md Execute implementation"`
+2. **PROCESS structured responses**: When `readyForQualityCheck: true` is detected → Execute quality-fixer-frontend immediately
+3. **USE quality-fixer-frontend**: Execute all quality checks (Biome, TypeScript build, tests)
+   - Invocation example: `subagent_type: "quality-fixer-frontend"`, `description: "Quality check"`, `prompt: "Execute all frontend quality checks and fixes"`
+4. **EXECUTE commit**: After `approved: true` confirmation, execute git commit immediately
+
+### Quality Assurance During Autonomous Execution (Details)
+- task-executor-frontend execution → quality-fixer-frontend execution → **I (Main AI) execute commit** (using Bash tool)
+- After quality-fixer-frontend's `approved: true` confirmation, execute git commit immediately
+- Use changeSummary for commit message
+
+**Think deeply**: Monitor all structured responses and ensure every quality gate is passed.
+
+! ls -la docs/plans/*.md | head -10
+
+Verify approval status before proceeding. Once confirmed, initiate autonomous execution mode. Stop immediately upon detecting any requirement changes.
+
+## Output Example
+Frontend implementation phase completed.
+- Task decomposition: Generated under docs/plans/tasks/
+- Implemented tasks: [number] tasks
+- Quality checks: All passed (Biome, TypeScript build, tests)
+- Commits: [number] commits created
+
+**Important**: This command manages the entire autonomous execution flow for frontend implementation from task decomposition to completion. Automatically uses frontend-specialized agents (task-executor-frontend, quality-fixer-frontend).

package/.claude/commands-en/front-design.md

@@ -0,0 +1,42 @@
+---
+description: Execute from requirement analysis to frontend design document creation
+---
+
+**Command Context**: This command is dedicated to the frontend design phase.
+
+Execute **from requirement analysis to frontend design document creation and approval**.
+
+Requirements: $ARGUMENTS
+
+## Execution Flow
+
+### 1. Requirement Analysis Phase
+**Think harder**: Considering the deep impact on design, first engage in dialogue to understand the background and purpose of requirements:
+- What problems do you want to solve?
+- Expected outcomes and success criteria
+- Relationship with existing systems
+
+Once requirements are moderately clarified:
+- Invoke **requirement-analyzer** using Task tool
+  - `subagent_type: "requirement-analyzer"`
+  - `description: "Requirement analysis"`
+  - `prompt: "Requirements: [user requirements] Execute requirement analysis and scale determination"`
+- **[STOP]**: Review requirement analysis results and address question items
+
+### 2. Design Document Creation Phase
+Create appropriate design documents according to scale determination:
+- Invoke **technical-designer-frontend** using Task tool
+  - For ADR: `subagent_type: "technical-designer-frontend"`, `description: "ADR creation"`, `prompt: "Create ADR for [technical decision]"`
+  - For Design Doc: `subagent_type: "technical-designer-frontend"`, `description: "Design Doc creation"`, `prompt: "Create Design Doc based on requirements"`
+- Invoke **document-reviewer** to verify consistency
+  - `subagent_type: "document-reviewer"`, `description: "Document review"`, `prompt: "Review [document path] for consistency and completeness"`
+- **[STOP]**: Present design alternatives and trade-offs, obtain user approval
+
+**Scope**: Up to frontend design document (ADR/Design Doc) approval. Work planning and beyond are outside the scope of this command.
+
+## Output Example
+Frontend design phase completed.
+- Design document: docs/design/[document-name].md or docs/adr/[document-name].md
+- Approval status: User approved
+
+**Important**: This command ends with design approval. Does not propose transition to next phase.

package/.claude/commands-en/front-plan.md

@@ -0,0 +1,40 @@
+---
+description: Create frontend work plan from design document and obtain plan approval
+---
+
+**Command Context**: This command is dedicated to the frontend planning phase.
+
+Create frontend work plan with the following process:
+
+## Execution Process
+
+### 1. Design Document Selection
+! ls -la docs/design/*.md | head -10
+- Check for existence of design documents, notify user if none exist
+- Present options if multiple exist (can be specified with $ARGUMENTS)
+
+### 2. Work Plan Creation
+Invoke **work-planner** using Task tool:
+- `subagent_type: "work-planner"`
+- `description: "Work plan creation"`
+- `prompt: "Create work plan from Design Doc at [path]"`
+- Interact with user to complete plan and obtain approval for plan content
+
+**Think deeply** Create a work plan from the selected design document, clarifying specific implementation steps and risks.
+
+**Scope**: Up to work plan creation and obtaining approval for plan content.
+
+## Response at Completion
+✅ **Recommended**: End with the following standard response after plan content approval
+```
+Frontend planning phase completed.
+- Work plan: docs/plans/[plan-name].md
+- Status: Approved
+
+Please provide separate instructions for implementation.
+```
+
+❌ **Avoid**: Additional processing after plan approval (task decomposition, implementation start, etc.)
+- Reason: Exceeds the scope of the planning phase
+
+**Responsibility Boundary**: This command is responsible for the frontend planning phase and completes its responsibility with plan content approval. The implementation phase is outside the scope of responsibility, so quality cannot be guaranteed and automatic transition does not occur.

package/.claude/commands-en/implement.md

@@ -0,0 +1,75 @@
+---
+description: Orchestrate the complete implementation lifecycle from requirements to deployment
+---
+
+**Command Context**: Full-cycle implementation management (Requirements Analysis → Design → Planning → Implementation → Quality Assurance)
+
+Strictly adhere to @docs/guides/sub-agents.md and operate as an orchestrator.
+
+## Execution Decision Flow
+
+### 1. Current Situation Assessment
+Instruction Content: $ARGUMENTS
+
+**Think deeply** Assess the current situation:
+
+| Situation Pattern | Decision Criteria | Next Action |
+|------------------|------------------|-------------|
+| New Requirements | No existing work, new feature/fix request | Start with requirement-analyzer |
+| Flow Continuation | Existing docs/tasks present, continuation directive | Identify next step in sub-agents.md flow |
+| Quality Errors | Error detection, test failures, build errors | Execute quality-fixer |
+| Ambiguous | Intent unclear, multiple interpretations possible | Confirm with user |
+
+### 2. Progress Verification for Continuation
+When continuing existing flow, verify:
+- Latest artifacts (PRD/ADR/Design Doc/Work Plan/Tasks)
+- Current phase position (Requirements/Design/Planning/Implementation/QA)
+- Identify next step in sub-agents.md corresponding flow
+
+### 3. After Scale Determination: Register All Flow Steps to TodoWrite (Required)
+
+After scale determination, **register all steps of the applicable sub-agents.md flow to TodoWrite**. After registration, proceed through the flow referencing TodoWrite.
+
+### 4. Execute Next Action
+
+**Execute the next pending task in TodoWrite**.
+
+## 📋 sub-agents.md Compliance Execution
+
+**Pre-execution Checklist (Required)**:
+- [ ] Confirmed relevant sub-agents.md flow
+- [ ] Identified current progress position
+- [ ] Clarified next step
+- [ ] Recognized stopping points
+- [ ] Understood the 4-step cycle after task execution (task-executor → escalation judgment/follow-up → quality-fixer → commit)
+
+**Flow Adherence**: Follow "Autonomous Execution Task Management" in sub-agents.md, managing 4 steps with TodoWrite
+
+## 🚨 Sub-agent Invocation Constraints
+
+Include the following at the end of prompts when invoking sub-agents, as rule-advisor invocation from sub-agents causes system crash:
+```
+[Constraint] rule-advisor can only be used by Main AI
+```
+
+## 🎯 Mandatory Orchestrator Responsibilities
+
+### Task Execution Flow
+Following "Autonomous Execution Task Management" in sub-agents.md, manage these 4 steps with TodoWrite:
+1. task-executor execution
+2. Escalation judgment and follow-up
+3. quality-fixer execution
+4. git commit
+
+### Test Information Communication
+After acceptance-test-generator execution, when calling work-planner, communicate:
+- Generated integration test file path
+- Generated E2E test file path
+- Explicit note that integration tests run with implementation, E2E tests run after all implementations
+
+## Responsibility Boundaries
+
+**This Command's Responsibility**: Orchestrate sub-agents through the complete implementation lifecycle
+**OUT OF SCOPE**:
+- Direct implementation work (MUST delegate to task-executor)
+- Investigation tasks using Grep/Glob/Read (MUST delegate to subagents)

package/.claude/commands-en/plan.md

@@ -0,0 +1,45 @@
+---
+description: Create work plan from design document and obtain plan approval
+---
+
+**Command Context**: This command is dedicated to the planning phase.
+
+Follow @docs/guides/sub-agents.md strictly and create work plan with the following process:
+
+## Execution Process
+
+1. **Design Document Selection**
+   ! ls -la docs/design/*.md | head -10
+   - Check for existence of design documents, notify user if none exist
+   - Present options if multiple exist (can be specified with $ARGUMENTS)
+
+2. **E2E Test Skeleton Generation Confirmation**
+   - Confirm with user whether to generate E2E test skeleton first
+   - If user wants generation: Generate test skeleton with acceptance-test-generator
+   - Pass generation results to next process according to sub-agents.md coordination specification
+
+3. **Work Plan Creation**
+   - Create work plan with work-planner
+   - Utilize deliverables from previous process according to sub-agents.md coordination specification
+   - Interact with user to complete plan and obtain approval for plan content
+
+**Think deeply** Create a work plan from the selected design document, clarifying specific implementation steps and risks.
+
+**Scope Boundary**:
+- IN SCOPE: Work plan creation and obtaining approval for plan content
+- OUT OF SCOPE: Task decomposition, implementation start
+
+## Response at Completion
+✅ **REQUIRED**: End with the following standard response after plan content approval
+```
+Planning phase completed.
+- Work plan: docs/plans/[plan-name].md
+- Status: Approved
+
+Please provide separate instructions for implementation.
+```
+
+❌ **Avoid**: Additional processing after plan approval (task decomposition, implementation start, etc.)
+- Reason: Exceeds the scope of the planning phase
+
+**Responsibility Boundary**: This command completes with plan content approval. Implementation phase is out of scope. Wait for user instructions after plan approval.

package/.claude/commands-en/project-inject.md

@@ -0,0 +1,76 @@
+---
+description: Inject project-specific context into project-context.md
+---
+
+**Command Context**: When using the boilerplate, collect project-specific context and update project-context.md.
+
+## Execution Process
+
+### 1. Current State Verification
+! ls -la docs/rules/project-context.md
+! cat package.json | grep -E '"name":|"description":'
+
+### 2. Project Context Collection
+
+Interact with the user to collect the following information:
+
+```
+【Core Project Information】
+1. What problem does your project solve?
+   Examples: "Manual time tracking is inefficient" "Inventory management is person-dependent"
+
+2. Who is the system for?
+   Examples: "50-member sales team" "E-commerce site operators"
+
+3. In what situations will it be used?
+   Examples: "Field staff entering daily reports" "Month-end aggregation tasks"
+
+【Development Structure】
+- Individual development / Team development (number of members)
+- Development phase (Prototype / Production development / In operation)
+
+【Critical Business Constraints】(Maximum 3)
+Examples: "7-year audit log retention" "Mandatory approval workflow" "Real-time synchronization"
+```
+
+**Think deeply** From the collected information, understand the project's essence and construct context focused on single responsibility.
+
+### 3. Generate project-context.md
+
+## AI Execution Accuracy Maximization Criteria
+
+Generated project-context.md must follow these criteria:
+
+### Principles of Description
+1. **Minimal yet maximally efficient**: Essential information only, eliminate redundancy
+2. **AI-decidable**: Use only measurable and verifiable criteria ("quickly" → "within 5 seconds")
+3. **Eliminate ambiguity**: Include specific numbers, conditions, and examples
+4. **Preferred format**: Describe in "do this" form rather than "don't do that"
+
+### Responsibility Boundaries
+project-context.md's single responsibility is "project-specific contextual information" only:
+- ✅ Include: Project objectives, target users, business constraints
+- ❌ Exclude: Tech stack (→technical-spec.md), implementation principles (→typescript.md), architecture (→technical-spec.md)
+
+### Structure
+```markdown
+# Project Context
+
+## Project Overview
+- **Problem being solved**: [Specific challenge]
+- **Target users**: [Include number and attributes]
+- **Usage scenarios**: [Specific situations]
+
+## Development Structure
+- **Team composition**: [Number and roles]
+- **Development phase**: [Current stage]
+
+## Business Constraints
+1. [Measurable constraint]
+2. [Verifiable requirement]
+```
+
+### 4. Update rules-index.yaml
+Update the typical-use in the project-context section to match the project.
+
+**Scope**: Update project-context.md only. Technology choices are the responsibility of other rule files.