create-ai-project 1.14.6 → 1.14.8

package/.claude/agents-en/task-decomposer.md

@@ -101,46 +101,7 @@ Decompose tasks based on implementation strategy patterns determined in implemen
 
 ## Task File Template
 
-```markdown
-# Task: [Task Name]
-
-Metadata:
-- Dependencies: task-01 → Deliverable: docs/plans/analysis/research-results.md
-- Provides: docs/plans/analysis/api-spec.md (for research/design tasks)
-- Size: Small (1-2 files)
-
-## Implementation Content
-[What this task will achieve]
-*Reference dependency deliverables if applicable
-
-## Target Files
-- [ ] [Implementation file path]
-- [ ] [Test file path]
-
-## Implementation Steps (TDD: Red-Green-Refactor)
-### 1. Red Phase
-- [ ] Review dependency deliverables (if any)
-- [ ] Verify/create type definitions
-- [ ] Write failing tests
-- [ ] Run tests and confirm failure
-
-### 2. Green Phase
-- [ ] Add minimal implementation to pass tests
-- [ ] Run only added tests and confirm they pass
-
-### 3. Refactor Phase
-- [ ] Improve code (maintain passing tests)
-- [ ] Confirm added tests still pass
-
-## Completion Criteria
-- [ ] All added tests pass
-- [ ] Operation verified (select L1/L2/L3, per implementation-approach.md)
-- [ ] Deliverables created (for research/design tasks)
-
-## Notes
-- Impact scope: [Areas where changes may propagate]
-- Constraints: [Areas not to be modified]
-```
+See task template in documentation-criteria skill for details.
 
 ## Overall Design Document Template
 

package/.claude/agents-ja/task-decomposer.md

@@ -101,46 +101,7 @@ implementation-approachスキルで決定された実装戦略パターンに基
 
 ## タスクファイルテンプレート
 
-```markdown
-# タスク: [タスク名]
-
-メタ情報:
-- 依存: task-01 → 成果物: docs/plans/analysis/調査結果.md
-- 提供: docs/plans/analysis/api-spec.md（調査・設計タスクの場合）
-- サイズ: 小規模（1-2ファイル）
-
-## 実装内容
-[このタスクで実現すること]
-※依存成果物がある場合、その内容を参照して実装
-
-## 対象ファイル
-- [ ] [実装ファイルパス]
-- [ ] [テストファイルパス]
-
-## 実装手順（TDD: Red-Green-Refactor）
-### 1. Red Phase
-- [ ] 依存成果物の確認（ある場合）
-- [ ] 型定義の確認/作成
-- [ ] 失敗するテストを作成
-- [ ] テスト実行して失敗を確認
-
-### 2. Green Phase  
-- [ ] テストが通る最小限の実装
-- [ ] 追加したテストのみ実行して通ることを確認
-
-### 3. Refactor Phase
-- [ ] コード改善（テストが通る状態を維持）
-- [ ] 追加したテストが引き続き通ることを確認
-
-## 完了条件
-- [ ] 追加したテストが全てパス
-- [ ] 動作確認完了（L1/L2/L3から選択、implementation-approach.md準拠）
-- [ ] 成果物作成完了（調査・設計タスクの場合）
-
-## 注意事項
-- 影響範囲: [変更が波及する箇所]
-- 制約: [変更禁止箇所]
-```
+詳細はdocumentation-criteriaスキルのタスクテンプレートを参照。
 
 ## 全体設計書テンプレート
 

package/.claude/commands-en/add-integration-tests.md

@@ -0,0 +1,74 @@
+---
+name: add-integration-tests
+description: Add integration/E2E tests to existing backend codebase using Design Doc
+---
+
+**Command Context**: Test addition workflow for existing backend implementations
+
+**Scope**: Backend only (acceptance-test-generator supports backend only)
+
+## Execution Method
+
+- Skeleton generation -> performed by acceptance-test-generator
+- Task file creation -> following task template (see documentation-criteria skill)
+- Test implementation -> performed by task-executor
+- Test review -> performed by integration-test-reviewer
+- Quality checks -> performed by quality-fixer
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
+
+Design Doc path: $ARGUMENTS
+
+**Think deeply** Understand the essence of test addition and execute:
+
+## Prerequisites
+- Design Doc must exist (created manually or via reverse-engineer)
+- Existing implementation to test
+
+## Execution Flow
+
+### 1. Validate Design Doc
+```bash
+# Verify Design Doc exists
+ls $ARGUMENTS || ls docs/design/*.md | grep -v template | tail -1
+```
+
+### 2. Execute acceptance-test-generator
+Generate test skeletons from Design Doc:
+- Extract Acceptance Criteria (AC)
+- Generate integration test skeletons (`*.int.test.ts`)
+- Generate E2E test skeletons if applicable (`*.e2e.test.ts`)
+
+### 3. Create Task File
+Create task file following task template (see documentation-criteria skill):
+- Path: `docs/plans/tasks/integration-tests-YYYYMMDD.md`
+- Content: Test implementation tasks based on generated skeletons
+- Include skeleton file paths in Target Files section
+
+### 4. Execute task-executor
+Implement tests following the task file:
+- Follow TDD principles (Red-Green-Refactor)
+- Implement each skeleton test case
+- Run tests and verify they pass
+
+### 5. Execute integration-test-reviewer
+Review test quality:
+- Verify skeleton compliance
+- Check test coverage
+- If `needs_revision` -> Return to step 4 with `requiredFixes`
+- If `approved` -> Proceed to quality check
+
+### 6. Execute quality-fixer
+Final quality assurance:
+- Run all tests
+- Verify coverage meets requirements
+- Fix any quality issues
+
+### 7. Commit
+Commit test files with appropriate message.
+
+## Delegation
+- acceptance-test-generator: Skeleton generation
+- task-executor: Test implementation
+- integration-test-reviewer: Test quality review
+- quality-fixer: Final quality check

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

@@ -4,7 +4,28 @@ 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 subagents-orchestration-guide skill, execute **from requirement-analyzer to design document creation and approval**.
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+**Execution Protocol**:
+1. **Delegate all work** to sub-agents (NEVER investigate/analyze yourself)
+2. **Follow subagents-orchestration-guide skill design flow exactly**:
+   - Execute: requirement-analyzer → technical-designer → document-reviewer → design-sync
+   - **Stop at every `[Stop: ...]` marker** → Wait for user approval before proceeding
+3. **Scope**: Complete when design documents receive approval
+
+**CRITICAL**: NEVER skip document-reviewer, design-sync, or stopping points defined in subagents-orchestration-guide skill flows.
+
+## Workflow Overview
+
+```
+Requirements → requirement-analyzer → [Stop: Scale determination]
+                                           ↓
+                                   technical-designer → document-reviewer
+                                           ↓
+                                      design-sync → [Stop: Design approval]
+```
 
 Requirements: $ARGUMENTS
 
@@ -17,9 +38,16 @@ Once requirements are moderately clarified, analyze with requirement-analyzer an
 
 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
+## Scope Boundaries
+
+**Included in this command**:
+- Requirement analysis with requirement-analyzer
+- ADR creation (if architecture changes, new technology, or data flow changes)
+- Design Doc creation with technical-designer
+- Document review with document-reviewer
+- Design Doc consistency verification with design-sync
+
+**Responsibility Boundary**: This command completes with design document approval.
 
 ## Execution Flow
 
@@ -31,6 +59,14 @@ Clearly present design alternatives and trade-offs.
    - IF conflicts found → Report to user → Wait for fix instructions → Fix with technical-designer(update)
    - IF no conflicts → End
 
+## Completion Criteria
+
+- [ ] Executed requirement-analyzer and determined scale
+- [ ] Created appropriate design document (ADR or Design Doc) with technical-designer
+- [ ] Executed document-reviewer and addressed feedback
+- [ ] Executed design-sync for consistency verification
+- [ ] Obtained user approval for design document
+
 ## Output Example
 Design phase completed.
 - Design document: docs/design/[document-name].md

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

@@ -8,8 +8,12 @@ Target problem: $ARGUMENTS
 
 **Role**: Orchestrator
 
-**Execution Method**: All work is executed through sub-agents
-- investigator → verifier → solver
+**Execution Method**:
+- Investigation → performed by investigator
+- Verification → performed by verifier
+- Solution derivation → performed by solver
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
 
 **TodoWrite Registration**: Register execution steps in TodoWrite and proceed systematically
 

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

@@ -2,11 +2,23 @@
 description: Execute frontend implementation in autonomous execution mode
 ---
 
-**Command Context**: As orchestrator, autonomously completes frontend implementation in autonomous execution mode.
+## Orchestrator Definition
+
+**Core Identity**: "I am not a worker. I am an orchestrator." (see subagents-orchestration-guide skill)
+
+**Execution Method**:
+- Task decomposition → performed by task-decomposer
+- Frontend implementation → performed by task-executor-frontend
+- Quality checks and fixes → performed by quality-fixer-frontend
+- Commits → performed by orchestrator (Bash tool)
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
+
+**CRITICAL**: Run quality-fixer-frontend before every commit. Obtain batch approval before autonomous mode.
 
 Work plan: $ARGUMENTS
 
-## 📋 Pre-execution Prerequisites
+## Pre-execution Prerequisites
 
 ### Task File Existence Check
 ```bash
@@ -27,7 +39,7 @@ Work plan: $ARGUMENTS
 | 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)
+## Task Decomposition Phase (Conditional)
 
 When task files don't exist:
 
@@ -53,12 +65,11 @@ Generate tasks from the work plan? (y/n):
 ! ls -la docs/plans/tasks/*.md | head -10
 ```
 
-✅ **Recommended**: After task generation, automatically proceed to autonomous execution
-❌ **Avoid**: Starting implementation without task generation
+✅ **Flow**: Task generation → Autonomous execution (in this order)
 
-## 🧠 Metacognition for Each Task - Frontend Specialized
+## Task Execution Cycle (4-Step Cycle) - Frontend Specialized
 
-**Required Execution Cycle**: `task-executor-frontend → quality-fixer-frontend → commit`
+**MANDATORY EXECUTION CYCLE**: `task-executor-frontend → escalation check → quality-fixer-frontend → commit`
 
 ### Sub-agent Invocation Method
 Use Task tool to invoke sub-agents:
@@ -73,21 +84,23 @@ Each sub-agent responds in JSON format:
 
 ### Execution Flow for Each Task
 
-Execute for EACH task:
+For EACH task, YOU MUST:
 
-1. **USE task-executor-frontend**: Execute frontend implementation
+1. **UPDATE TodoWrite**: Register work steps. Always include: first "Confirm skill constraints", final "Verify skill fidelity"
+2. **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)
+3. **CHECK ESCALATION**: Check task-executor-frontend status → If `status: "escalation_needed"` → STOP and escalate to user
+4. **PROCESS structured responses**: When `readyForQualityCheck: true` is detected → EXECUTE quality-fixer-frontend IMMEDIATELY
+5. **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
+6. **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
+- task-executor-frontend execution → escalation check → quality-fixer-frontend execution → **orchestrator executes 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.
+**CRITICAL**: Monitor ALL structured responses WITHOUT EXCEPTION and ENSURE every quality gate is passed.
 
 ! ls -la docs/plans/*.md | head -10
 

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

@@ -4,7 +4,26 @@ description: Execute from requirement analysis to frontend design document creat
 
 **Command Context**: This command is dedicated to the frontend design phase.
 
-Execute **from requirement analysis to frontend design document creation and approval**.
+## Orchestrator Definition
+
+**Role**: Orchestrator
+
+**Execution Method**:
+- Requirement analysis → performed by requirement-analyzer
+- Design document creation → performed by technical-designer-frontend
+- Document review → performed by document-reviewer
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
+
+## Scope Boundaries
+
+**Included in this command**:
+- Requirement analysis with requirement-analyzer
+- ADR creation (if architecture changes, new technology, or data flow changes)
+- Design Doc creation with technical-designer-frontend
+- Document review with document-reviewer
+
+**Responsibility Boundary**: This command completes with design document approval.
 
 Requirements: $ARGUMENTS
 

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

@@ -4,6 +4,24 @@ description: Create frontend work plan from design document and obtain plan appr
 
 **Command Context**: This command is dedicated to the frontend planning phase.
 
+## Orchestrator Definition
+
+**Role**: Orchestrator
+
+**Execution Method**:
+- Work plan creation → performed by work-planner
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
+
+## Scope Boundaries
+
+**Included in this command**:
+- Design document selection
+- Work plan creation with work-planner
+- Plan approval obtainment
+
+**Responsibility Boundary**: This command completes with work plan approval.
+
 Create frontend work plan with the following process:
 
 ## Execution Process
@@ -33,8 +51,3 @@ Frontend planning phase completed.
 
 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/front-reverse-design.md

@@ -0,0 +1,183 @@
+---
+name: front-reverse-design
+description: Generate frontend Design Docs from existing codebase using existing PRD
+---
+
+**Command Context**: Reverse engineering workflow to create frontend Design Docs from existing code
+
+**Prerequisites**: PRD must exist (created via reverse-engineer or manually)
+
+Target PRD: $ARGUMENTS
+
+**TodoWrite**: Register phases first, then steps within each phase as you enter it.
+
+## Step 0: Initial Configuration
+
+### 0.1 Scope Confirmation
+
+Use AskUserQuestion to confirm:
+1. **PRD path**: Which PRD to use as basis
+2. **Target path**: Which frontend directory/module to document
+3. **Human review**: Yes (recommended) / No (fully autonomous)
+
+### 0.2 Output Configuration
+
+- Design Doc output: `docs/design/` or existing design directory
+- Verify directories exist, create if needed
+
+## Workflow Overview
+
+```
+Step 1: Scope Discovery (all frontend components per PRD)
+Step 2-5: Per-component loop (Generation -> Verification -> Review -> Revision)
+```
+
+**Context Passing**: Pass structured JSON output between steps. Use `$STEP_N_OUTPUT` placeholder notation.
+
+## Step 1: Design Doc Scope Discovery
+
+**Task invocation**:
+```
+subagent_type: scope-discoverer
+prompt: |
+  Discover frontend Design Doc targets within PRD scope.
+
+  scope_type: design-doc
+  existing_prd: $USER_PRD_PATH
+  target_path: $USER_TARGET_PATH
+  focus: frontend (React/TypeScript components, hooks, state management)
+```
+
+**Store output as**: `$STEP_1_OUTPUT`
+
+**Quality Gate**:
+- At least one component discovered -> proceed
+- No components -> ask user for hints
+
+**Human Review Point** (if enabled): Present discovered components for confirmation.
+
+## Step 2-5: Per-Component Processing
+
+**Complete Steps 2->3->4->5 for each component before proceeding to the next component.**
+
+### Step 2: Design Doc Generation
+
+**Task invocation**:
+```
+subagent_type: technical-designer-frontend
+prompt: |
+  Create Design Doc for the following frontend component based on existing code.
+
+  Operation Mode: create
+
+  Component: $COMPONENT_NAME (from $STEP_1_OUTPUT)
+  Responsibility: $COMPONENT_RESPONSIBILITY
+  Primary Files: $COMPONENT_PRIMARY_FILES
+  Public Interfaces: $COMPONENT_PUBLIC_INTERFACES
+  Dependencies: $COMPONENT_DEPENDENCIES
+
+  Parent PRD: $USER_PRD_PATH
+
+  Document current architecture. Do not propose changes.
+```
+
+**Store output as**: `$STEP_2_OUTPUT`
+
+### Step 3: Code Verification
+
+**Task invocation**:
+```
+subagent_type: code-verifier
+prompt: |
+  Verify consistency between Design Doc and code implementation.
+
+  doc_type: design-doc
+  document_path: $STEP_2_OUTPUT
+  code_paths: $COMPONENT_PRIMARY_FILES
+  verbose: false
+```
+
+**Store output as**: `$STEP_3_OUTPUT`
+
+**Quality Gate**:
+- consistencyScore >= 70 -> proceed to review
+- consistencyScore < 70 -> flag for detailed review
+
+### Step 4: Review
+
+**Required Input**: $STEP_3_OUTPUT (verification JSON from Step 3)
+
+**Task invocation**:
+```
+subagent_type: document-reviewer
+prompt: |
+  Review the following Design Doc considering code verification findings.
+
+  doc_type: DesignDoc
+  target: $STEP_2_OUTPUT
+  mode: composite
+
+  ## Code Verification Results
+  $STEP_3_OUTPUT
+
+  ## Parent PRD
+  $USER_PRD_PATH
+
+  ## Additional Review Focus
+  - Technical accuracy of documented interfaces
+  - Consistency with parent PRD scope
+  - Completeness of component boundary definitions
+```
+
+**Store output as**: `$STEP_4_OUTPUT`
+
+### Step 5: Revision (conditional)
+
+**Trigger Conditions** (any one of the following):
+- Review status is "Needs Revision" or "Rejected"
+- Critical discrepancies exist in `$STEP_3_OUTPUT`
+- consistencyScore < 70
+
+**Task invocation**:
+```
+subagent_type: technical-designer-frontend
+prompt: |
+  Update Design Doc based on review feedback.
+
+  Operation Mode: update
+  Existing Design Doc: $STEP_2_OUTPUT
+
+  ## Review Feedback
+  $STEP_4_OUTPUT
+
+  ## Discrepancies to Address
+  (Extract critical and major discrepancies from $STEP_3_OUTPUT)
+
+  Apply corrections and improvements.
+```
+
+**Loop Control**: Maximum 2 revision cycles. After 2 cycles, flag for human review regardless of status.
+
+### Component Completion
+
+- [ ] Review status is "Approved" or "Approved with Conditions"
+- [ ] Human review passed (if enabled in Step 0)
+
+**Next**: Proceed to next component. After all components -> Final Report.
+
+## Final Report
+
+Output summary including:
+- Generated documents table (Component, Design Doc Path, Consistency Score, Review Status)
+- Action items (critical discrepancies, undocumented features, flagged items)
+- Next steps checklist
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| PRD not found | Ask user for correct PRD path |
+| Discovery finds nothing | Ask user for project structure hints |
+| Generation fails | Log failure, continue with other components, report in summary |
+| consistencyScore < 50 | Flag for mandatory human review, do not auto-approve |
+| Review rejects after 2 revisions | Stop loop, flag for human intervention |

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

@@ -0,0 +1,89 @@
+---
+name: front-review
+description: Design Doc compliance validation with optional auto-fixes
+---
+
+**Command Context**: Post-implementation quality assurance command for React/TypeScript frontend
+
+## Execution Method
+
+- Compliance validation -> performed by code-reviewer
+- Rule analysis -> performed by rule-advisor
+- Fix implementation -> performed by task-executor-frontend
+- Quality checks -> performed by quality-fixer-frontend
+- Re-validation -> performed by code-reviewer
+
+Orchestrator invokes sub-agents and passes structured JSON between them.
+
+Design Doc (uses most recent if omitted): $ARGUMENTS
+
+**Think deeply** Understand the essence of compliance validation and execute:
+
+## Execution Flow
+
+### 1. Prerequisite Check
+```bash
+# Identify Design Doc
+ls docs/design/*.md | grep -v template | tail -1
+
+# Check implementation files
+git diff --name-only main...HEAD
+```
+
+### 2. Execute code-reviewer
+Validate Design Doc compliance:
+- Acceptance criteria fulfillment
+- Code quality check
+- Implementation completeness assessment
+
+### 3. Verdict and Response
+
+**Criteria (considering project stage)**:
+- Prototype: Pass at 70%+
+- Production: 90%+ recommended
+- Critical items (security, etc.): Required regardless of rate
+
+**Compliance-based response**:
+
+For low compliance (production <90%):
+```
+Validation Result: [X]% compliance
+Unfulfilled items:
+- [item list]
+
+Execute fixes? (y/n):
+```
+
+If user selects `y`:
+
+## Pre-fix Metacognition
+**Required**: `rule-advisor -> TodoWrite -> task-executor-frontend -> quality-fixer-frontend`
+
+1. **Execute rule-advisor**: Understand fix essence (symptomatic treatment vs root solution)
+2. **Update TodoWrite**: Register work steps. Always include: first "Confirm skill constraints", final "Verify skill fidelity". Create task file following task template (see documentation-criteria skill) -> `docs/plans/tasks/review-fixes-YYYYMMDD.md`
+3. **Execute task-executor-frontend**: Staged auto-fixes (stops at 5 files)
+4. **Execute quality-fixer-frontend**: Confirm quality gate passage
+5. **Re-validate**: Measure improvement with code-reviewer
+
+### 4. Final Report
+```
+Initial compliance: [X]%
+Final compliance: [Y]% (if fixes executed)
+Improvement: [Y-X]%
+
+Remaining issues:
+- [items requiring manual intervention]
+```
+
+## Auto-fixable Items
+- Simple unimplemented acceptance criteria
+- Error handling additions
+- Contract definition fixes
+- Function splitting (length/complexity improvements)
+
+## Non-fixable Items
+- Fundamental business logic changes
+- Architecture-level modifications
+- Design Doc deficiencies
+
+**Scope**: Design Doc compliance validation and auto-fixes.