@atlashub/smartstack-cli 3.8.0 → 3.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlashub/smartstack-cli",
-  "version": "3.8.0",
+  "version": "3.9.0",
   "description": "SmartStack Claude Code automation toolkit - GitFlow, EF Core migrations, prompts and more",
   "author": {
     "name": "SmartStack",
@@ -80,6 +80,7 @@
     "test:all": "npm run test:mcp && npm run test:ba"
   },
   "dependencies": {
+    "@atlashub/smartstack-cli": "file:../02-Develop",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "axios": "^1.7.0",
     "bcryptjs": "^2.4.3",

package/templates/agents/action.md

@@ -3,6 +3,7 @@ name: action
 description: Conditional action executor - performs actions only when specific conditions are met
 color: purple
 model: haiku
+tools: Read, Glob, Grep, Bash
 ---
 
 Batch conditional executor. Handle ≤5 tasks. VERIFY INDEPENDENTLY before each action.

package/templates/agents/ba-writer.md

@@ -203,6 +203,39 @@ Create a new version for refactoring or major changes.
 6. Append changelog entry with old and new versions
 7. Return paths of both versions
 
+### applyReview
+Apply corrections from a ba-review.json export to create a new version of the analysis.
+
+**Input:**
+- featureId: FEAT-NNN of the existing application
+- reviewData: parsed content of ba-review.json (with `_reviewMeta` envelope)
+
+**Process:**
+1. Validate `reviewData._reviewMeta` has `sourceVersion` and `sourceApplicationId`
+2. Determine version bump:
+   - If `_reviewMeta.changeSummary.modulesAdded.length > 0` OR `modulesRemoved.length > 0`: major bump (v1.0 → v2.0)
+   - Otherwise: minor bump (v1.0 → v1.1)
+3. Call `createVersion(featureId, "Review corrections applied")`
+4. Read the new version's master feature.json
+5. Apply reverse mapping from review data to feature.json (see `references/review-data-mapping.md`):
+   - `reviewData.cadrage.scope.vital[]` → `cadrage.globalScope.mustHave[]`
+   - `reviewData.cadrage.scope.important[]` → `cadrage.globalScope.shouldHave[]`
+   - `reviewData.cadrage.scope.optional[]` → `cadrage.globalScope.couldHave[]`
+   - `reviewData.cadrage.scope.excluded[]` → `cadrage.globalScope.outOfScope[]`
+   - `reviewData.cadrage.stakeholders[]` → reverse-map access/frequency back to involvement/frequency
+   - `reviewData.cadrage.risks[]` → `cadrage.risks[]`
+   - `reviewData.modules[]` → update `modules[]` (add/remove/modify)
+6. For each module in `reviewData.moduleSpecifications`:
+   - Reverse-map useCases, businessRules, entities, permissions back to module feature.json
+7. Preserve review comments in a new `review` section of the master feature.json:
+   - `review.comments`: all inline comments from `reviewData.comments`
+   - `review.specComments`: text comments from `reviewData.specComments`
+   - `review.wireframeComments`: wireframe feedback from `reviewData.wireframeComments`
+   - `review.appliedAt`: ISO timestamp
+8. Update metadata.updatedAt
+9. Write the updated feature.json
+10. Return confirmation with: new version path, changes applied count, comments preserved count
+
 ## Schema Validation Rules
 
 Perform these structural checks before every write:

package/templates/agents/explore-codebase.md

@@ -3,6 +3,7 @@ name: explore-codebase
 description: Use this agent whenever you need to explore the codebase to implement a feature.
 color: yellow
 model: haiku
+tools: Read, Glob, Grep, Bash
 ---
 
 You are a codebase exploration specialist. Your only job is to find and present ALL relevant code and logic for the requested feature.

package/templates/agents/explore-docs.md

@@ -3,6 +3,7 @@ name: explore-docs
 description: Use this agent IMMEDIATELY when the user asks about library features, implementation methods, "how to do X with Y library", documentation searches, or ANY question about using/implementing specific libraries or frameworks (in any language) - launches Context7 and WebFetch for precise technical information with code examples
 color: yellow
 model: haiku
+tools: Read, Glob, Grep, WebSearch, WebFetch, ToolSearch
 ---
 
 You are a documentation exploration specialist. Your mission is to retrieve precise, actionable documentation with code examples while eliminating superficial content.

package/templates/agents/fix-grammar.md

@@ -3,6 +3,7 @@ name: fix-grammar
 description: Use this agent to fix grammar and spelling errors in a single file while preserving formatting
 color: blue
 model: haiku
+tools: Read, Edit, Write, Glob, Grep
 ---
 
 You are DevProfCorrectorGPT, a professional text corrector. Fix grammar and spelling errors in the specified file while preserving all formatting and meaning.

package/templates/agents/snipper.md

@@ -3,6 +3,7 @@ name: Snipper
 description: Use this agent when you need to modify code. This agent is specialized to be fast. The output is small and optimized to code as fast as agent can.
 color: blue
 model: haiku
+tools: Read, Edit, Write, Glob, Grep
 ---
 
 You are a rapid code modification specialist. No explanations, just execute.

package/templates/skills/admin/SKILL.md

@@ -40,3 +40,9 @@ Manage SmartStack admin accounts. Wraps the `smartstack admin` CLI command with
 4. **Report result** - Show new credentials or error message
 
 </workflow>
+
+<success_criteria>
+- Admin command executed successfully or clear error displayed
+- New credentials shown to user (for reset)
+- SmartStack.app project correctly detected
+</success_criteria>

package/templates/skills/ai-prompt/SKILL.md

@@ -13,12 +13,12 @@ description: |
 
 # Skill AI Prompt SmartStack
 
-> **Architecture:** Prompt + Blocks → Provider + Model → Completion → Schema Validation
+> **Architecture:** Prompt + Blocks -> Provider + Model -> Completion -> Schema Validation
 > Multi-provider: OpenAI, Anthropic (Claude), Azure OpenAI, Google Gemini
 
 **Reference:** [_shared.md](../_shared.md) for common patterns
 
-## WHEN THIS SKILL ACTIVATES
+## When This Skill Activates
 
 | Trigger | Example |
 |---------|---------|
@@ -28,17 +28,17 @@ description: |
 | Text analysis | "Analyze the sentiment of comments" |
 | Keywords | "prompt", "GPT", "Claude", "IA", "completion", "LLM" |
 
-## AI FLOW
+## AI Flow
 
 ```
-Feature → IAiCompletionService.ExecutePromptAsync()
-    ↓
-Prompt + Blocks → Provider Instance → External API (OpenAI/Claude/Azure/Gemini)
-    ↓
-AI Response → OutputSchema Validation → Typed Result<T>
+Feature -> IAiCompletionService.ExecutePromptAsync()
+    |
+Prompt + Blocks -> Provider Instance -> External API (OpenAI/Claude/Azure/Gemini)
+    |
+AI Response -> OutputSchema Validation -> Typed Result<T>
 ```
 
-## MAIN ENTITIES
+## Main Entities
 
 ### AiProvider & AiModel
 - **Providers:** OpenAI, Anthropic, Azure OpenAI, Google
@@ -58,138 +58,27 @@ Configured instance: Code, Name, SystemContext, DefaultModel, MonthlyBudgetLimit
 ### OutputSchema
 JSON Schema for validation: Code, Name, JsonSchema, DotNetType
 
-## WORKFLOW INTEGRATION
+## Implementation
 
-### 1. Define the Use Case
-| Question | Impact |
-|----------|--------|
-| Content type? | Model choice |
-| Structured response? | OutputSchema |
-| Multi-language? | Language variables |
-| Budget limited? | ProviderInstance |
-| Real-time? | Streaming |
+See [steps/step-01-implementation.md](steps/step-01-implementation.md) for:
+- Workflow steps (define use case, create prompt, define schema, execute)
+- AI service interfaces (IAiCompletionService, IPromptService)
+- Frontend integration (API, hooks, components)
+- Advanced patterns (streaming, fallback provider)
 
-### 2. Create the Prompt
-```csharp
-var promptId = await _promptService.CreatePromptAsync(new CreatePromptRequest
-{
-    Code = "ticket-analyzer",
-    Name = "Ticket Analyzer",
-    Blocks = new[] {
-        new CreateBlockRequest {
-            BlockType = PromptBlockType.System,
-            Content = "Instructions...",
-            IsRequired = true
-        },
-        new CreateBlockRequest {
-            BlockType = PromptBlockType.User,
-            Content = "Ticket: {{ticketTitle}}\nDescription: {{ticketDescription}}",
-            IsRequired = true
-        }
-    }
-});
-```
-
-### 3. Define OutputSchema (if structured response)
-```csharp
-var schemaId = await _schemaService.CreateAsync(new CreateSchemaRequest
-{
-    Code = "ticket-analysis-result",
-    JsonSchema = @"{ ""type"": ""object"", ""required"": [""category"", ""priority""], ... }",
-    DotNetType = "SmartStack.Application.AI.TicketAnalysisResult"
-});
-```
-
-### 4. Execute the Prompt
-```csharp
-// Simple execution
-var result = await _aiService.ExecutePromptAsync(promptId, new Dictionary<string, object>
-{
-    ["ticketTitle"] = ticket.Title,
-    ["ticketDescription"] = ticket.Description
-});
-
-// With typed validation
-var typedResult = await _aiService.ExecutePromptWithValidationAsync<TicketAnalysisResult>(
-    promptId, variables);
-if (typedResult.Success && typedResult.IsValid) { /* use typedResult.Data */ }
-```
-
-## AI SERVICES
-
-### IAiCompletionService
-```csharp
-Task<AiCompletionResult> CompleteAsync(AiCompletionRequest request, CancellationToken ct);
-Task<AiCompletionResult> ExecutePromptAsync(Guid promptId, Dictionary<string, object>? variables, ...);
-Task<AiValidatedCompletionResult<T>> ExecutePromptWithValidationAsync<T>(Guid promptId, ...);
-Task<AiValidatedCompletionResult<T>> ExecutePromptByCodeWithValidationAsync<T>(string promptCode, ...);
-```
-
-### IPromptService
-```csharp
-Task<PromptDto> GetPromptByCodeAsync(string code, string? version = null);
-Task<string> RenderPromptAsync(string code, Dictionary<string, object>? variables);
-Task<Guid> CreatePromptAsync(CreatePromptRequest request);
-Task ActivatePromptAsync(Guid promptId);
-// Block management: AddBlockToPromptAsync, UpdateBlockAsync, ReorderBlocksAsync
-```
+## Checklist
 
-## FRONTEND INTEGRATION
-
-### API
-```typescript
-aiApi.getPrompts(status?, isTemplate?)
-aiApi.executePrompt(promptId, variables)
-aiApi.previewPrompt(promptId, variables)
-aiApi.getProviders() / aiApi.getModels(providerId?)
-aiApi.getSchemas() / aiApi.createSchema(data)
-```
-
-### Hook useAiCompletion
-```typescript
-const { execute, loading, error, result } = useAiCompletion<T>(promptCode);
-const data = await execute(variables);
 ```
-
-### Component AiAssistantButton
-```tsx
-<AiAssistantButton
-  promptCode="ticket-analyzer"
-  variables={{ ticketTitle, ticketDescription }}
-  onResult={(result) => handleAnalysis(result)}
-  label="Analyze with AI"
-/>
+- Prompt created (unique Code, Blocks, Variables, Version)
+- OutputSchema if structured response
+- Service with IAiCompletionService injected
+- Error handling + Logging (tokens, time)
+- Frontend: Hook/component, Loading, Error handling
+- ProviderInstance with budget limit
+- Tests: execution, variables, schema validation
 ```
 
-## ADVANCED PATTERNS
-
-### Streaming Response
-```typescript
-const reader = response.body?.getReader();
-while (true) { const { done, value } = await reader.read(); if (done) break; /* append chunk */ }
-```
-
-### Fallback Provider
-```csharp
-foreach (var provider in providers.OrderBy(p => p.Priority)) {
-    var result = await _aiService.ExecutePromptAsync(promptId, variables, providerId: provider.Id);
-    if (result.Success) return result;
-}
-```
-
-## CHECKLIST
-
-```
-□ Prompt created (unique Code, Blocks, Variables, Version)
-□ OutputSchema if structured response
-□ Service with IAiCompletionService injected
-□ Error handling + Logging (tokens, time)
-□ Frontend: Hook/component, Loading, Error handling
-□ ProviderInstance with budget limit
-□ Tests: execution, variables, schema validation
-```
-
-## ABSOLUTE RULES
+## Absolute Rules
 
 | DO | DON'T |
 |----|-------|
@@ -199,7 +88,7 @@ foreach (var provider in providers.OrderBy(p => p.Priority)) {
 | Log executions (tokens, duration) | Hardcode API keys |
 | Variables for dynamic content | Expose system prompts to frontend |
 
-## KEY FILES
+## Key Files
 
 | File | Role |
 |------|------|
@@ -209,3 +98,10 @@ foreach (var provider in providers.OrderBy(p => p.Priority)) {
 | `Application/Common/Interfaces/IAiCompletionService.cs` | Service interface |
 | `Infrastructure/Services/AI/AiCompletionService.cs` | Implementation |
 | `web/src/services/api/aiApi.ts` | Frontend API |
+
+<success_criteria>
+- Prompt entity created with OutputSchema validation
+- IAiCompletionService integration wired correctly
+- Error handling for API failures and quota limits implemented
+- Token usage logged per execution
+</success_criteria>

package/templates/skills/ai-prompt/steps/step-01-implementation.md

@@ -0,0 +1,122 @@
+# AI Prompt - Implementation Workflow
+
+## 1. Define the Use Case
+
+| Question | Impact |
+|----------|--------|
+| Content type? | Model choice |
+| Structured response? | OutputSchema |
+| Multi-language? | Language variables |
+| Budget limited? | ProviderInstance |
+| Real-time? | Streaming |
+
+## 2. Create the Prompt
+
+```csharp
+var promptId = await _promptService.CreatePromptAsync(new CreatePromptRequest
+{
+    Code = "ticket-analyzer",
+    Name = "Ticket Analyzer",
+    Blocks = new[] {
+        new CreateBlockRequest {
+            BlockType = PromptBlockType.System,
+            Content = "Instructions...",
+            IsRequired = true
+        },
+        new CreateBlockRequest {
+            BlockType = PromptBlockType.User,
+            Content = "Ticket: {{ticketTitle}}\nDescription: {{ticketDescription}}",
+            IsRequired = true
+        }
+    }
+});
+```
+
+## 3. Define OutputSchema (if structured response)
+
+```csharp
+var schemaId = await _schemaService.CreateAsync(new CreateSchemaRequest
+{
+    Code = "ticket-analysis-result",
+    JsonSchema = @"{ ""type"": ""object"", ""required"": [""category"", ""priority""], ... }",
+    DotNetType = "SmartStack.Application.AI.TicketAnalysisResult"
+});
+```
+
+## 4. Execute the Prompt
+
+```csharp
+// Simple execution
+var result = await _aiService.ExecutePromptAsync(promptId, new Dictionary<string, object>
+{
+    ["ticketTitle"] = ticket.Title,
+    ["ticketDescription"] = ticket.Description
+});
+
+// With typed validation
+var typedResult = await _aiService.ExecutePromptWithValidationAsync<TicketAnalysisResult>(
+    promptId, variables);
+if (typedResult.Success && typedResult.IsValid) { /* use typedResult.Data */ }
+```
+
+## AI Services
+
+### IAiCompletionService
+```csharp
+Task<AiCompletionResult> CompleteAsync(AiCompletionRequest request, CancellationToken ct);
+Task<AiCompletionResult> ExecutePromptAsync(Guid promptId, Dictionary<string, object>? variables, ...);
+Task<AiValidatedCompletionResult<T>> ExecutePromptWithValidationAsync<T>(Guid promptId, ...);
+Task<AiValidatedCompletionResult<T>> ExecutePromptByCodeWithValidationAsync<T>(string promptCode, ...);
+```
+
+### IPromptService
+```csharp
+Task<PromptDto> GetPromptByCodeAsync(string code, string? version = null);
+Task<string> RenderPromptAsync(string code, Dictionary<string, object>? variables);
+Task<Guid> CreatePromptAsync(CreatePromptRequest request);
+Task ActivatePromptAsync(Guid promptId);
+// Block management: AddBlockToPromptAsync, UpdateBlockAsync, ReorderBlocksAsync
+```
+
+## Frontend Integration
+
+### API
+```typescript
+aiApi.getPrompts(status?, isTemplate?)
+aiApi.executePrompt(promptId, variables)
+aiApi.previewPrompt(promptId, variables)
+aiApi.getProviders() / aiApi.getModels(providerId?)
+aiApi.getSchemas() / aiApi.createSchema(data)
+```
+
+### Hook useAiCompletion
+```typescript
+const { execute, loading, error, result } = useAiCompletion<T>(promptCode);
+const data = await execute(variables);
+```
+
+### Component AiAssistantButton
+```tsx
+<AiAssistantButton
+  promptCode="ticket-analyzer"
+  variables={{ ticketTitle, ticketDescription }}
+  onResult={(result) => handleAnalysis(result)}
+  label="Analyze with AI"
+/>
+```
+
+## Advanced Patterns
+
+### Streaming Response
+```typescript
+const reader = response.body?.getReader();
+while (true) { const { done, value } = await reader.read(); if (done) break; /* append chunk */ }
+```
+
+### Fallback Provider
+```csharp
+foreach (var provider in providers.OrderBy(p => p.Priority)) {
+    var result = await _aiService.ExecutePromptAsync(promptId, variables, providerId: provider.Id);
+    if (result.Success) return result;
+}
+```

package/templates/skills/apex/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: apex
+description: |
+  SmartStack incremental development using APEX methodology (Analyze-Plan-Execute-eXamine).
+  Use this skill when:
+  - Adding a new section/resource to an existing module
+  - Developing feature by feature without /business-analyse
+  - Fixing or extending code generated by /ralph-loop
+  - Any incremental SmartStack development task
+argument-hint: "[-a] [-x] [-s] [-t] [-e] [-r] [-pr] <task description>"
+---
+
+<objective>
+Execute incremental SmartStack development using the APEX methodology. This skill knows the SmartStack hierarchy (context/application/module/section/resource), delegates code creation to existing skills (/controller, /application, /ui-components, /efcore, /notification, /workflow) and MCP tools, and validates via MCP conventions.
+
+**Key principle:** /apex ORCHESTRATES — it never generates SmartStack code directly. All generation goes through skills and MCP tools.
+</objective>
+
+<quick_start>
+
+```bash
+/apex add absence management to HR module           # Add section to module
+/apex -a fix the leave request controller            # Auto fix
+/apex -a -x -s -t -pr add PDF export to Orders      # Full workflow
+/apex -e add status field to Project entity          # Economy (no agents)
+/apex -r                                             # Resume previous
+```
+
+</quick_start>
+
+<parameters>
+
+| Flag | Description |
+|------|-------------|
+| `-a` | Auto mode: skip confirmations |
+| `-x` | Examine mode: adversarial code review |
+| `-s` | Save mode: output to `.claude/output/apex/` |
+| `-t` | Test mode: scaffold + run tests via MCP |
+| `-e` | Economy mode: no subagents |
+| `-r` | Resume: continue from previous state |
+| `-pr` | PR mode: create pull request at end |
+
+</parameters>
+
+<state_variables>
+
+| Variable | Type | Description |
+|----------|------|-------------|
+| `{task_description}` | string | What to implement (flags removed) |
+| `{task_id}` | string | Kebab-case identifier |
+| `{auto_mode}` | boolean | Skip confirmations |
+| `{examine_mode}` | boolean | Adversarial review |
+| `{save_mode}` | boolean | Save outputs to `.claude/output/apex/{task-id}/` |
+| `{test_mode}` | boolean | Include test steps (07-08) |
+| `{economy_mode}` | boolean | No subagents |
+| `{pr_mode}` | boolean | Create PR at end |
+| `{context_code}` | string | "business", "platform", "personal" |
+| `{app_name}` | string | Application name |
+| `{module_code}` | string | Module code |
+| `{sections}` | string[] | Sections being added/modified |
+| `{prd_path}` | string? | `.ralph/prd-{module}.json` if exists |
+| `{feature_path}` | string? | `docs/business/.../feature.json` if exists |
+| `{needs_seed_data}` | boolean | Seed data creation required |
+| `{needs_migration}` | boolean | EF Core migration required |
+</state_variables>
+
+<entry_point>
+
+**FIRST ACTION:** Load `steps/step-00-init.md`
+
+</entry_point>
+
+<step_files>
+**Progressive loading - only load current step:**
+
+| Step | File | Model | Purpose |
+|------|------|-------|---------|
+| 00 | `steps/step-00-init.md` | Sonnet | Parse flags, detect SmartStack context, verify MCP |
+| 01 | `steps/step-01-analyze.md` | Opus | Explore existing code (Agent Teams or direct) |
+| 02 | `steps/step-02-plan.md` | Opus | Layer-by-layer plan with skill/MCP mapping |
+| 03 | `steps/step-03-execute.md` | Opus | Orchestrate execution via skills and MCP |
+| 04 | `steps/step-04-validate.md` | Opus | MCP validation, build, seed data check |
+| 05 | `steps/step-05-examine.md` | Opus | Adversarial review (if -x) |
+| 06 | `steps/step-06-resolve.md` | Opus | Fix BLOCKING findings (if any) |
+| 07 | `steps/step-07-tests.md` | Opus | Scaffold tests via MCP (if -t) |
+| 08 | `steps/step-08-run-tests.md` | Opus | Run tests until 100% pass (if -t) |
+</step_files>
+
+<reference_files>
+**Loaded conditionally by steps that need them:**
+
+| File | Purpose | Loaded by |
+|------|---------|-----------|
+| `references/smartstack-layers.md` | Layer execution rules, skill/MCP mapping, seed data | step-02, step-03 |
+| `references/agent-teams-protocol.md` | TeamCreate, coordination, shutdown protocol | step-01, step-03 |
+</reference_files>
+
+<execution_rules>
+
+- **Load one step at a time** - Progressive loading to manage context
+- **ORCHESTRATE, never generate** - All SmartStack code via skills (/controller, /application, etc.) or MCP tools
+- **MCP-first** - Use MCP scaffold/validate tools before manual approaches
+- **Verify MCP at startup** - step-00 checks MCP availability
+- **Layer order** - domain -> infra -> migration(BLOCKING) -> app -> api -> frontend -> i18n -> tests
+- **Agent Teams** - Parallel execution for scan (step-01) and Layer 1 (step-03), unless economy_mode
+- **Save outputs** if `{save_mode}` = true
+- **Commits per layer** - Atomic commits after each execution layer
+
+</execution_rules>
+
+<success_criteria>
+- SmartStack context detected (context/app/module)
+- Plan validated with skill/MCP mapped for each file
+- Code created/corrected via existing skills and MCP (no direct generation)
+- MCP validate_conventions: 0 errors
+- Build: dotnet build PASS + npm run typecheck PASS (if frontend)
+- Seed data complete (navigation, permissions, roles, provider) if required
+- Tests: 100% pass, >= 80% coverage (if -t)
+- Commits atomic per layer
+</success_criteria>

package/templates/skills/apex/_shared.md

@@ -0,0 +1,86 @@
+# APEX Shared — SmartStack Detection & MCP References
+
+> **Loaded by:** step-00-init (always), other steps as needed
+
+---
+
+## SmartStack Project Detection
+
+### Scan Pattern
+
+1. `*.sln` → .NET backend confirmed
+2. `docs/business/` → BA artifacts exist
+3. `.ralph/prd-*.json` → PRDs exist
+4. `src/pages/` → React frontend exists
+
+### Context-to-Folder Mapping
+
+| Context | Backend | Controller | Frontend Layout |
+|---------|---------|------------|----------------|
+| `business` | `Business` | `Business` | `BusinessLayout` |
+| `platform.administration` | `Platform/Administration` | `Admin` | `AdminLayout` |
+| `platform.support` | `Platform/Support` | `Support` | `AdminLayout` |
+| `personal` | `Personal` | `User` | `UserLayout` |
+
+---
+
+## MCP Tools Reference
+
+### Mandatory (every execution)
+
+| Tool | Purpose | Step |
+|------|---------|------|
+| `validate_conventions` | Validate SmartStack conventions | 00 (check), 04 (validate) |
+
+### Generation (step-03)
+
+| Tool | Purpose | Condition |
+|------|---------|-----------|
+| `scaffold_extension` | Generate entities, services, controllers | New code creation |
+| `suggest_migration` | Get standardized migration name | EF Core changes |
+| `generate_permissions` | Generate RBAC permissions + seed data | New module/section |
+| `scaffold_api_client` | Generate TypeScript API client | Frontend changes |
+| `scaffold_routes` | Generate React Router routes | Frontend changes |
+
+### Validation (step-04)
+
+| Tool | Purpose | Condition |
+|------|---------|-----------|
+| `check_migrations` | Validate EF Core migrations | Migration created |
+| `validate_frontend_routes` | Validate route/layout alignment | Frontend changes |
+| `validate_security` | Check security patterns | API changes |
+
+### Analysis (step-01)
+
+| Tool | Purpose |
+|------|---------|
+| `api_docs` | Existing API documentation |
+| `analyze_extension_points` | React extension points |
+
+### Tests (step-07, if -t)
+
+| Tool | Purpose |
+|------|---------|
+| `scaffold_tests` | Generate tests (domain, app, api, security) |
+| `suggest_test_scenarios` | Suggest test scenarios |
+| `analyze_test_coverage` | Check coverage percentage |
+
+### Review (step-05, if -x)
+
+| Tool | Purpose |
+|------|---------|
+| `review_code` | Adversarial code review |
+| `analyze_code_quality` | Code quality metrics |
+
+---
+
+## Existing Skills Delegation
+
+| Skill | When to delegate |
+|-------|-----------------|
+| `/controller` | Complex controller with custom routes |
+| `/application` | New context/application/module structure |
+| `/ui-components` | Complex React pages (tables, grids, dashboards) |
+| `/efcore` | Complex EF Core configurations |
+| `/notification` | In-app or email notifications |
+| `/workflow` | Automated workflow triggers |