thanh-kit 2.5.0

package/templates/commands/code/auto.md

@@ -0,0 +1,170 @@
+---
+description: ⚡⚡⚡ [AUTO] Start coding & testing an existing plan ("trust me bro")
+argument-hint: [plan] [all-phases-yes-or-no] (default: yes)
+---
+
+**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:
+<plan>$ARGUMENTS</plan>
+
+## Arguments
+- $PLAN: $1 (Mention specific plan or auto detected, default: latest plan)
+- $ALL_PHASES: $2 (`Yest` to finish all phases in one run or `No` to implement phase-by-phase and wait for confirmation, default is `Yes`)
+
+---
+
+## 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.
+
+**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.
+- Ensure token efficiency while maintaining high quality.
+
+---
+
+## Step 0: Plan Detection & Phase Selection
+
+**If `$PLAN` is empty:**
+1. Find latest `plan.md` in `./plans` | `find ./plans -name "plan.md" -type f -exec stat -f "%m %N" {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-`
+2. Parse plan for phases and status, auto-select next incomplete (prefer IN_PROGRESS or earliest Planned)
+
+**If `$PLAN` provided:** Use that plan and detect which phase to work on (auto-detect or use argument like "phase-2").
+
+**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-5 in order. Each step requires output marker starting with "✓ Step N:". Mark each complete in `TodoWrite` before proceeding. Do not skip steps.
+
+---
+
+## Step 1: Analysis & Task Extraction
+Use `project-manager` agent to 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:**
+`project-manager` agent must respond back with:
+- 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 Testing tasks → Step 3.X (Step 3.1, Step 3.2, etc.)
+  - Phase Code Review tasks → Step 4.X (Step 4.1, Step 4.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
+
+Implement selected plan phase step-by-step following extracted tasks (Step 2.1, Step 2.2, etc.). Mark tasks complete as done. For UI work, call `ui-ux-designer` subagent: "Implement [feature] UI per ./docs/design-guidelines.md". Use `ai-multimodal` skill for image assets, imagemagick in `media-processing` skill 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: Testing
+
+Write tests covering happy path, edge cases, and error cases. Call `tester` subagent: "Run test suite for plan phase [phase-name]". If ANY tests fail: STOP, call `debugger` subagent: "Analyze failures: [details]", fix all issues, re-run `tester`. Repeat until 100% pass.
+
+**Testing standards:** Unit tests may use mocks for external dependencies (APIs, DB). Integration tests use test environment. E2E tests use real but isolated data. Forbidden: commenting out tests, changing assertions to pass, TODO/FIXME to defer fixes.
+
+**Output:** `✓ Step 3: Tests [X/X passed] - All requirements met`
+
+**Validation:** If X ≠ total, Step 3 INCOMPLETE - do not proceed.
+
+Mark Step 3 complete in `TodoWrite`, mark Step 4 in_progress.
+
+---
+
+## Step 4: Code Review
+
+Call `code-reviewer` subagent: "Review code changes in **Step 2** of plan phase [phase-name]. Check security, performance, architecture, YAGNI/KISS/DRY". If critical issues found: **STOP**, fix all, re-run `tester` to verify, re-run `code-reviewer`. Repeat until no critical issues.
+
+**Critical issues:** Security vulnerabilities (XSS, SQL injection, OWASP), performance bottlenecks, architectural violations, principle violations.
+
+**Output:** `✓ Step 4: Code reviewed - [0] critical issues`
+
+**Validation:** If critical issues > 0, Step 4 INCOMPLETE - do not proceed.
+
+Mark Step 4 complete in TodoWrite, mark Step 5 in_progress.
+
+---
+
+## Step 5: Finalize
+
+1. **STATUS UPDATE - BOTH MANDATORY - PARALLEL EXECUTION:**
+- **Call** `project-manager` sub-agent: "Update plan status in [plan-path]. Mark plan phase [phase-name] as DONE with timestamp. Update roadmap."
+- **Call** `docs-manager` sub-agent: "Update docs for plan phase [phase-name]. Changed files: [list]."
+
+2. **ONBOARDING CHECK:** Detect onboarding requirements (API keys, env vars, config) + generate summary report with next steps.
+- If this is the last phase: use `AskUserQuestion` tool to ask if user wants to set up onboarding requirements.
+
+3. **AUTO-COMMIT (after steps 1 and 2 completes):**
+- **Call** `git-manager` subagent to handle git operation.
+- Run only if: Steps 1 and 2 successful + Tests passed
+- Auto-stage, commit with message [phase - plan] and push
+
+**Validation:** Steps 1 and 2 must complete successfully. Step 3 (auto-commit) runs only if conditions met.
+
+Mark Step 5 complete in `TodoWrite`.
+
+**Important:**
+If $ALL_PHASES is `Yes`, proceed to the next phase automatically.
+If $ALL_PHASES is `No`, wait for user confirmation before proceeding to the next phase:
+- Use `AskUserQuestion` tool to ask if user wants to proceed to the next phase: "**Phase workflow finished. Ready for next plan phase.**"
+
+## Summary report
+If this is the last phase, generate a concise summary report.
+Use `AskUserQuestion` tool to ask these questions:
+- If user wants to preview the report with `/preview` slash command.
+- If user wants to archive the plan with `/plan:archive` slash command.
+
+---
+
+## 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: Tests [X/X passed] - All requirements met`
+- Step 4: `✓ Step 4: Code reviewed - [0] critical issues`
+- Step 5: `✓ Step 5: Finalize - Status updated - Git committed`
+
+**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: `tester`
+- Step 4: `code-reviewer`
+- Step 5: `project-manager` AND `docs-manager` AND `git-manager`
+
+**Blocking gates:**
+- Step 3: Tests must be 100% passing
+- Step 4: Critical issues must be 0
+
+**REMEMBER:**
+- Do not skip steps. Do not proceed if validation fails.
+- 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.
+- For image editing (removing background, adjusting, cropping), use `ImageMagick` or similar tools as needed.

package/templates/commands/code/no-test.md

@@ -0,0 +1,158 @@
+---
+description: ⚡⚡ Start coding an existing plan (no testing)
+argument-hint: [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:
+<plan>$ARGUMENTS</plan>
+
+---
+
+## 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.
+
+**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.
+- Ensure token efficiency while maintaining high quality.
+
+---
+
+## Step 0: Plan Detection & Phase Selection
+
+**If `$ARGUMENTS` is empty:**
+1. Find latest `plan.md` in `./plans` | `find ./plans -name "plan.md" -type f -exec stat -f "%m %N" {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-`
+2. Parse plan for phases and status, auto-select next incomplete (prefer IN_PROGRESS or earliest Planned)
+
+**If `$ARGUMENTS` provided:** Use that plan and detect which phase to work on (auto-detect or use argument like "phase-2").
+
+**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.
+
+---
+
+## 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 6)
+- 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
+
+Implement selected plan phase step-by-step following extracted tasks (Step 2.1, Step 2.2, etc.). Mark tasks complete as done. For UI work, call `ui-ux-designer` subagent: "Implement [feature] UI per ./docs/design-guidelines.md". 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
+
+Call `code-reviewer` subagent: "Review changes for plan phase [phase-name]. Check security, performance, architecture, YAGNI/KISS/DRY". If critical issues found: STOP, fix all, re-run `tester` to verify, re-run `code-reviewer`. Repeat until no critical issues.
+
+**Critical issues:** Security vulnerabilities (XSS, SQL injection, OWASP), performance bottlenecks, architectural violations, principle violations.
+
+**Output:** `✓ Step 3: Code reviewed - [0] critical issues`
+
+**Validation:** If critical issues > 0, Step 3 INCOMPLETE - do not proceed.
+
+Mark Step 3 complete in TodoWrite, mark Step 4 in_progress.
+
+---
+
+## Step 4: User Approval ⏸ BLOCKING GATE
+
+Present summary (3-5 bullets): what implemented, code review outcome.
+
+**Ask user explicitly:** "Phase implementation complete. Code reviewed. Approve changes?"
+
+**Stop and wait** - do not output Step 5 content until user responds.
+
+**Output (while waiting):** `⏸ Step 4: WAITING for user approval`
+
+**Output (after approval):** `✓ Step 4: User approved - Ready to complete`
+
+Mark Step 4 complete in TodoWrite, mark Step 5 in_progress.
+
+---
+
+## Step 5: Finalize
+
+**Prerequisites:** User approved in Step 4 (verified above).
+
+1. **STATUS UPDATE - BOTH MANDATORY - PARALLEL EXECUTION:**
+- **Call** `project-manager` sub-agent: "Update plan status in [plan-path]. Mark plan phase [phase-name] as DONE with timestamp. Update roadmap."
+- **Call** `docs-manager` sub-agent: "Update docs for plan phase [phase-name]. Changed files: [list]."
+
+2. **ONBOARDING CHECK:** Detect onboarding requirements (API keys, env vars, config) + generate summary report with next steps.
+
+3. **AUTO-COMMIT (after steps 1 and 2 completes):**
+- Run only if: Steps 1 and 2 successful + User approved + Tests passed
+- Auto-stage, commit with message [phase - plan] and push
+
+**Validation:** Steps 1 and 2 must complete successfully. Step 3 (auto-commit) runs only if conditions met.
+
+Mark Step 5 complete in TodoWrite.
+
+**Phase workflow finished. Ready for next plan phase.**
+
+---
+
+## 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: Code reviewed - [0] critical issues`
+- Step 4: `✓ Step 4: User approved - Ready to complete`
+- Step 5: `✓ Step 5: Finalize - Status updated - Git committed`
+
+**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`
+- Step 4: `project-manager` AND `docs-manager` (when user approves)
+
+**Blocking gates:**
+- Step 3: Critical issues must be 0
+- Step 4: User must explicitly approve
+- Step 5: Both `project-manager` and `docs-manager` must complete successfully
+
+**REMEMBER:**
+- 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.
+- For image editing (removing background, adjusting, cropping), use `media-processing` skill or similar tools as needed.

package/templates/commands/code/parallel.md

@@ -0,0 +1,55 @@
+---
+description: ⚡ Execute parallel or sequential phases based on plan structure
+argument-hint: [plan-path]
+---
+
+Execute plan: <plan>$ARGUMENTS</plan>
+
+**IMPORTANT:** Activate needed skills. Ensure token efficiency. Sacrifice grammar for concision.
+
+## Workflow
+
+### 1. Plan Analysis
+- Read `plan.md` from given path
+- **Check for:** Dependency graph, Execution strategy, Parallelization Info, File Ownership matrix
+- **Decision:** IF parallel-executable → Step 2A, ELSE → Step 2B
+
+### 2A. Parallel Execution
+1. Parse execution strategy (which phases concurrent/sequential, file ownership)
+2. Launch multiple `fullstack-developer` agents simultaneously for parallel phases
+   - Pass: phase file path, environment info, file ownership boundaries
+3. Wait for parallel group completion, verify no conflicts
+4. Execute sequential phases (one agent per phase after dependencies)
+5. Proceed to Step 3
+
+### 2B. Sequential Execution
+Follow `./.claude/workflows/primary-workflow.md`:
+1. Use main agent step by step
+2. Read `plan.md`, implement phases one by one
+3. Use `project-manager` for progress updates
+4. Use `ui-ux-designer` for frontend
+5. Run type checking after each phase
+6. Proceed to Step 3
+
+### 3. Testing
+- Use `tester` for full suite (NO fake data/mocks)
+- If fail: `debugger` → fix → repeat
+
+### 4. Code Review
+- Use `code-reviewer` for all changes
+- If critical: fix → retest
+
+### 5. Project Management & Docs
+- If approved: `project-manager` + `docs-manager` in parallel (update plans, docs, roadmap)
+- If rejected: fix → repeat
+
+### 6. Onboarding
+- Guide user step by step (1 question at a time)
+
+### 7. Final Report
+- Summary, guide, next steps
+- Ask to commit (use `git-manager` if yes)
+
+**Examples:**
+- Parallel: "Phases 1-3 parallel, then 4" → Launch 3 agents → Wait → Launch 1 agent
+- Sequential: "Phase 1 → 2 → 3" → Main agent implements each phase

package/templates/commands/code-simplifier.md

@@ -0,0 +1,71 @@
+Simplify and refine code for clarity, consistency, and maintainability.
+
+## Scope
+
+**Target:** $ARGUMENTS (default: recently modified files)
+
+## Simplification Actions
+
+| Action | Description |
+|--------|-------------|
+| Reduce nesting | Flatten deep if/else chains with guard clauses |
+| Extract methods | Break long methods into focused units |
+| Simplify conditionals | Use early returns, named booleans |
+| Remove duplication | Apply DRY, use platform patterns |
+| Improve naming | Make code self-documenting |
+
+## Workflow
+
+1. **Identify targets**
+   - If no arguments: `git diff --name-only HEAD~1` for recent changes
+   - If arguments provided: use specified files/patterns
+   - Skip: generated code, migrations, vendor files
+
+2. **Analyze each file**
+   - Identify complexity hotspots (nesting > 3, methods > 20 lines)
+   - Find duplicated code patterns
+   - Check naming clarity
+
+3. **Apply simplifications**
+   - One refactoring type at a time
+   - Preserve all functionality
+   - Follow platform patterns
+
+4. **Verify**
+   - Run related tests if available
+   - Confirm no behavior changes
+
+## Platform Patterns to Apply
+
+### Backend (C#)
+- Extract to `Entity.XxxExpr()` static expressions
+- Use fluent helpers: `.With()`, `.Then()`, `.PipeIf()`
+- Move mapping to DTO `MapToObject()` / `MapToEntity()`
+
+### Frontend (TypeScript)
+- Use `PlatformVmStore` for state
+- Apply `untilDestroyed()` to subscriptions
+- Ensure BEM class naming
+
+## Constraints
+
+- **Preserve functionality** - No behavior changes
+- **Keep tests passing** - Verify after changes
+- **Follow patterns** - Use platform conventions
+- **Document intent** - Add comments only where non-obvious
+
+## Example
+
+```
+User: /code-simplifier src/Domain/Entities/Employee.cs
+
+Claude:
+1. Analyzed Employee.cs (145 lines)
+2. Found: 2 nested conditionals, 1 duplicated expression
+3. Applied:
+   - Extracted IsActiveInCompanyExpr() static expression
+   - Replaced nested if with guard clause in Validate()
+   - Renamed `x` to `employee` in lambda
+4. Tests: All passing
+5. Complexity reduced: 145 → 128 lines
+```

package/templates/commands/code.md

@@ -0,0 +1,176 @@
+---
+description: ⚡⚡⚡ Start coding & testing an existing plan
+argument-hint: [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:
+<plan>$ARGUMENTS</plan>
+
+---
+
+## 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.
+
+**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.
+- Ensure token efficiency while maintaining high quality.
+
+---
+
+## Step 0: Plan Detection & Phase Selection
+
+**If `$ARGUMENTS` is empty:**
+1. Find latest `plan.md` in `./plans` | `find ./plans -name "plan.md" -type f -exec stat -f "%m %N" {} \; 2>/dev/null | sort -rn | head -1 | cut -d' ' -f2-`
+2. Parse plan for phases and status, auto-select next incomplete (prefer IN_PROGRESS or earliest Planned)
+
+**If `$ARGUMENTS` provided:** Use that plan and detect which phase to work on (auto-detect or use argument like "phase-2").
+
+**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.
+
+---
+
+## 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 6)
+- 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 Testing tasks → Step 3.X (Step 3.1, Step 3.2, etc.)
+  - Phase Code Review tasks → Step 4.X (Step 4.1, Step 4.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
+
+Implement selected plan phase step-by-step following extracted tasks (Step 2.1, Step 2.2, etc.). Mark tasks complete as done. For UI work, call `ui-ux-designer` subagent: "Implement [feature] UI per ./docs/design-guidelines.md". 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: Testing
+
+Write tests covering happy path, edge cases, and error cases. Call `tester` subagent: "Run test suite for plan phase [phase-name]". If ANY tests fail: STOP, call `debugger` subagent: "Analyze failures: [details]", fix all issues, re-run `tester`. Repeat until 100% pass.
+
+**Testing standards:** Unit tests may use mocks for external dependencies (APIs, DB). Integration tests use test environment. E2E tests use real but isolated data. Forbidden: commenting out tests, changing assertions to pass, TODO/FIXME to defer fixes.
+
+**Output:** `✓ Step 3: Tests [X/X passed] - All requirements met`
+
+**Validation:** If X ≠ total, Step 3 INCOMPLETE - do not proceed.
+
+Mark Step 3 complete in TodoWrite, mark Step 4 in_progress.
+
+---
+
+## Step 4: Code Review
+
+Call `code-reviewer` subagent: "Review changes for plan phase [phase-name]. Check security, performance, architecture, YAGNI/KISS/DRY". If critical issues found: STOP, fix all, re-run `tester` to verify, re-run `code-reviewer`. Repeat until no critical issues.
+
+**Critical issues:** Security vulnerabilities (XSS, SQL injection, OWASP), performance bottlenecks, architectural violations, principle violations.
+
+**Output:** `✓ Step 4: Code reviewed - [0] critical issues`
+
+**Validation:** If critical issues > 0, Step 4 INCOMPLETE - do not proceed.
+
+Mark Step 4 complete in TodoWrite, mark Step 5 in_progress.
+
+---
+
+## Step 5: User Approval ⏸ BLOCKING GATE
+
+Present summary (3-5 bullets): what implemented, tests [X/X passed], code review outcome.
+
+**Ask user explicitly:** "Phase implementation complete. All tests pass, code reviewed. Approve changes?"
+
+**Stop and wait** - do not output Step 6 content until user responds.
+
+**Output (while waiting):** `⏸ Step 5: WAITING for user approval`
+
+**Output (after approval):** `✓ Step 5: User approved - Ready to complete`
+
+Mark Step 5 complete in TodoWrite, mark Step 6 in_progress.
+
+---
+
+## Step 6: Finalize
+
+**Prerequisites:** User approved in Step 5 (verified above).
+
+1. **STATUS UPDATE - BOTH MANDATORY - PARALLEL EXECUTION:**
+- **Call** `project-manager` sub-agent: "Update plan status in [plan-path]. Mark plan phase [phase-name] as DONE with timestamp. Update roadmap."
+- **Call** `docs-manager` sub-agent: "Update docs for plan phase [phase-name]. Changed files: [list]."
+
+2. **ONBOARDING CHECK:** Detect onboarding requirements (API keys, env vars, config) + generate summary report with next steps.
+
+3. **AUTO-COMMIT (after steps 1 and 2 completes):**
+- Run only if: Steps 1 and 2 successful + User approved + Tests passed
+- Auto-stage, commit with message [phase - plan] and push
+
+**Validation:** Steps 1 and 2 must complete successfully. Step 3 (auto-commit) runs only if conditions met.
+
+Mark Step 6 complete in TodoWrite.
+
+**Phase workflow finished. Ready for next plan phase.**
+
+---
+
+## 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: Tests [X/X passed] - All requirements met`
+- Step 4: `✓ Step 4: Code reviewed - [0] critical issues`
+- Step 5: `✓ Step 5: User approved - Ready to complete`
+- Step 6: `✓ Step 6: Finalize - Status updated - Git committed`
+
+**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: `tester`
+- Step 4: `code-reviewer`
+- Step 6: `project-manager` AND `docs-manager` (when user approves)
+
+**Blocking gates:**
+- Step 3: Tests must be 100% passing
+- Step 4: Critical issues must be 0
+- Step 5: User must explicitly approve
+- Step 6: Both `project-manager` and `docs-manager` must complete successfully
+
+**REMEMBER:**
+- 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.
+- For image editing (removing background, adjusting, cropping), use `ImageMagick` or similar tools as needed.

package/templates/commands/coding-level.md

@@ -0,0 +1,48 @@
+Set your coding experience level for tailored explanations and output format.
+
+## Usage
+
+`/coding-level [0-5]`
+
+## Levels
+
+| Level | Name | Description |
+|-------|------|-------------|
+| 0 | ELI5 | Zero coding experience - analogies, no jargon, step-by-step |
+| 1 | Junior | 0-2 years - concepts explained, WHY not just HOW |
+| 2 | Mid-Level | 3-5 years - design patterns, system thinking |
+| 3 | Senior | 5-8 years - trade-offs, business context, architecture |
+| 4 | Tech Lead | 8-10 years - risk assessment, business impact, strategy |
+| 5 | God Mode | Expert - default behavior, maximum efficiency (default) |
+
+## How It Works
+
+1. Set `codingLevel` in `.claude/.ck.json`
+2. Guidelines are **automatically injected** on every session start
+3. No manual activation needed - it just works!
+
+## Example
+
+Set level 1 in `.claude/.ck.json`:
+```json
+{
+  "codingLevel": 1,
+  ...
+}
+```
+
+Next session, Claude will automatically:
+- Explain concepts and techniques clearly
+- Always explain WHY, not just HOW
+- Point out common mistakes
+- Add "Key Takeaways" after implementations
+
+## Optional: Manual Output Styles
+
+For finer control, you can also use `/output-style` with these styles:
+- `coding-level-0-eli5`
+- `coding-level-1-junior`
+- `coding-level-2-mid`
+- `coding-level-3-senior`
+- `coding-level-4-lead`
+- `coding-level-5-god`