@atlashub/smartstack-cli 3.8.0 → 3.10.0

package/templates/skills/application/steps/step-04-backend.md

@@ -148,79 +148,9 @@ questions:
 
 #### If User Selects YES:
 
-**Reference:** See `templates-seed.md` section "TEMPLATE: ENTITY SEED DATA (SeedData Provider)"
-
-**Generate the following files:**
-
-1. **`Infrastructure/Persistence/Seeding/Data/{Domain}/{EntityName}SeedData.cs`**
-
-   Follow the SmartStack.app pattern (same architecture as core):
-   - Static class with `internal static IEnumerable<{EntityName}SeedItem> GetAll{EntityName}s()`
-   - Use deterministic GUIDs (NEVER `Guid.NewGuid()`)
-   - Include 3-5 sample entities with varied, realistic data
-   - Internal record class `{EntityName}SeedItem` with all entity properties
-   - For multi-tenant entities: organize by tenant using `GetTenant1{EntityName}s()` helper methods
-   - Reference existing tenant/user IDs from `TenantSeedData`/`UserSeedData` for foreign keys
-
-   ```csharp
-   // Infrastructure/Persistence/Seeding/Data/{Domain}/{EntityName}SeedData.cs
-
-   public static class {EntityName}SeedData
-   {
-       public static readonly Guid Sample1Id = Guid.Parse("...");
-       public static readonly Guid Sample2Id = Guid.Parse("...");
-       public static readonly Guid Sample3Id = Guid.Parse("...");
-
-       internal static IEnumerable<{EntityName}SeedItem> GetAll{EntityName}s()
-       {
-           return new[]
-           {
-               new {EntityName}SeedItem { Id = Sample1Id, /* ... */ },
-               new {EntityName}SeedItem { Id = Sample2Id, /* ... */ },
-               new {EntityName}SeedItem { Id = Sample3Id, /* ... */ }
-           };
-       }
-   }
-
-   internal class {EntityName}SeedItem
-   {
-       public Guid Id { get; init; }
-       // ... all required entity properties
-   }
-   ```
-
-2. **Update `Infrastructure/Persistence/Seeding/DevDataSeeder.cs`**
-   - Add `using` for the new SeedData namespace
-   - Add `await Seed{EntityName}sAsync(cancellationToken);` in `SeedAsync()` method
-   - Add private seeding method:
-
-   ```csharp
-   private async Task Seed{EntityName}sAsync(CancellationToken cancellationToken)
-   {
-       _logger.LogInformation("Seeding demo {EntityName}s...");
-
-       var existingCount = await _context.{EntityName}s.CountAsync(cancellationToken);
-       if (existingCount > 0)
-       {
-           _logger.LogWarning("{EntityName}s already seeded ({Count} exist), skipping.", existingCount);
-           return;
-       }
-
-       var createdCount = 0;
-       foreach (var seedItem in {EntityName}SeedData.GetAll{EntityName}s())
-       {
-           var entity = {EntityName}.Create(/* map seedItem properties */);
-           typeof({EntityName}).GetProperty("Id")?.SetValue(entity, seedItem.Id);
-           _context.{EntityName}s.Add(entity);
-           createdCount++;
-       }
-
-       if (createdCount > 0)
-           await _context.SaveChangesAsync(cancellationToken);
-
-       _logger.LogInformation("Created {Count} demo {EntityName}s.", createdCount);
-   }
-   ```
+See [references/backend-entity-seeding.md](../references/backend-entity-seeding.md) for the full seeding pattern:
+1. **SeedData file** (`{EntityName}SeedData.cs`) — static class with deterministic GUIDs, 3-5 samples
+2. **DevDataSeeder update** — add `Seed{EntityName}sAsync()` method with idempotent check
 
 #### If User Selects NO:
 
@@ -246,58 +176,10 @@ Store entity information for frontend generation:
 
 ## CONTROLLER NAVROUTE AND FOLDER HIERARCHY
 
-### Controller File Location
-
-Controllers are organized by **context short name** and **application** (matching SmartStack.app pattern):
-
-```
-Api/Controllers/
-├── Admin/                     ← platform.administration
-│   ├── {Application}/         ← Application sub-folder (e.g., AI/, Communications/, Tenants/)
-│   │   └── {EntityName}Controller.cs
-│   └── {EntityName}Controller.cs  ← Direct controllers (no application sub-folder)
-├── Business/                  ← business.*
-│   └── {EntityName}Controller.cs
-├── Support/                   ← platform.support
-│   └── {EntityName}Controller.cs
-├── User/                      ← personal.*
-│   └── {EntityName}Controller.cs
-└── {SharedControllers}.cs     ← Root-level (Auth, Config, Navigation, etc.)
-```
-
-### Context-to-Folder Mapping
-
-| NavRoute Context | Controller Folder | Example |
-|-----------------|-------------------|---------|
-| `platform.administration` | `Admin` | `Controllers/Admin/TenantsController.cs` |
-| `platform.administration.{app}` | `Admin/{App}` | `Controllers/Admin/AI/AiPromptsController.cs` |
-| `platform.support` | `Support` | `Controllers/Support/TicketsController.cs` |
-| `business.*` | `Business` | `Controllers/Business/MyTicketsController.cs` |
-| `personal.*` | `User` | `Controllers/User/PreferencesController.cs` |
-
-### Controller Attributes
-
-The generated controller uses NavRoute attribute:
-
-```csharp
-[NavRoute("{full_path}")]
-[ApiController]
-[Authorize]
-public class {EntityName}Controller : ControllerBase
-{
-    [HttpGet]
-    [RequirePermission(Permissions.{Context}.{Application}.{Module}.Read)]
-    public async Task<ActionResult<IEnumerable<{EntityName}Dto>>> GetAll() { ... }
-
-    // ... other CRUD methods
-}
-```
-
-This ensures:
-- API route is derived from navigation path
-- Permissions use the constants from Permissions.cs
-- Frontend can discover API path from NavRoute registry
-- Controller file is in the correct context/application folder
+See [references/backend-controller-hierarchy.md](../references/backend-controller-hierarchy.md) for the complete reference:
+- Controller file organization (Admin/Business/Support/User folders)
+- Context-to-folder mapping table
+- NavRoute attribute C# template with RequirePermission
 
 ---
 
@@ -323,234 +205,22 @@ If MCP call fails:
 
 ## POST-GENERATION VERIFICATION (MANDATORY)
 
-**Before proceeding to step-05, run these checks on ALL generated backend files:**
-
-### Check 1: Backend Build (BLOCKING)
-
-```bash
-dotnet build {SolutionName}.sln --no-restore
-```
-
-IF build fails:
-- Read the error output carefully
-- Fix compilation errors in generated files (common: missing `using`, wrong namespace, type mismatch)
-- Re-run build until it succeeds
-- DO NOT proceed to step-05 until the backend builds successfully
-
-### Check 2: DbSet Registration (BLOCKING)
-
-Verify the entity DbSet is registered in the DbContext interface:
-
-```
-Search for: DbSet<{EntityName}>
-In: **/I{DbContextName}.cs or **/{DbContextName}.cs
-```
-
-IF NOT found: Add the DbSet declaration immediately:
-```csharp
-public DbSet<{EntityName}> {EntityName}s => Set<{EntityName}>();
-```
-
-### Check 3: DI Registration (BLOCKING)
+**Before proceeding to step-05, run ALL checks.**
 
-Verify the service is registered in the DI container:
-
-```
-Search for: I{EntityName}Service
-In: **/DependencyInjection.cs
-```
-
-IF NOT found: Add the service registration immediately:
-```csharp
-services.AddScoped<I{EntityName}Service, {EntityName}Service>();
-```
-
-### Check 4: RequirePermission Attributes (BLOCKING)
-
-Verify ALL controller actions have `[RequirePermission]` attributes:
-
-```
-Search for: [HttpGet], [HttpPost], [HttpPut], [HttpDelete]
-In: **/Controllers/**/{EntityName}Controller.cs
-```
-
-Each HTTP action MUST have a corresponding `[RequirePermission(Permissions.{Context}.{Application}.{Module}.{Action})]`.
-IF any action is missing the attribute: Add it immediately.
-
-### Check 5: Entity Configuration (BLOCKING)
-
-Verify the EF Core configuration file exists and has correct structure:
-
-```
-Search for: {EntityName}Configuration
-In: **/Persistence/Configurations/**/*Configuration.cs
-```
-
-Verify:
-- `builder.ToTable("{table_prefix}{EntityName}s")` uses the correct table prefix
-- `builder.HasKey(e => e.Id)` is present
-- `builder.HasIndex` is defined for unique fields (e.g., Code)
-
-IF configuration is incomplete: Fix it before continuing.
-
-### Check 5b: Seeding Infrastructure (BLOCKING - first entity only)
-
-**If this is the FIRST entity created in this project (no existing DevDataSeeder):**
-
-Scaffold the full seeding infrastructure following the SmartStack.app architecture:
-
-1. **Create `Infrastructure/Persistence/Seeding/Data/SeedConstants.cs`**
-
-   ```csharp
-   namespace {BaseNamespace}.Infrastructure.Persistence.Seeding.Data;
-
-   /// <summary>
-   /// Shared constants for seed data across all modules.
-   /// </summary>
-   public static class SeedConstants
-   {
-       public static readonly DateTime SeedDate = new(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-   }
-   ```
-
-2. **Create `Infrastructure/Persistence/Seeding/DevDataSeeder.cs`**
-
-   ```csharp
-   using Microsoft.EntityFrameworkCore;
-   using Microsoft.Extensions.Logging;
-   using SmartStack.Application.Common.Interfaces;
-
-   namespace {BaseNamespace}.Infrastructure.Persistence.Seeding;
-
-   /// <summary>
-   /// Seeds development/demo data at application startup.
-   /// Only runs when EnableDevSeeding = true.
-   /// </summary>
-   public class DevDataSeeder : IDevDataSeeder
-   {
-       private readonly ExtensionsDbContext _context;
-       private readonly ILogger<DevDataSeeder> _logger;
-
-       public DevDataSeeder(ExtensionsDbContext context, ILogger<DevDataSeeder> logger)
-       {
-           _context = context;
-           _logger = logger;
-       }
-
-       public async Task SeedAsync(CancellationToken cancellationToken = default)
-       {
-           _logger.LogInformation("Starting development data seeding...");
-           // Add Seed{Entity}sAsync calls here as entities are created
-           _logger.LogInformation("Development data seeding complete.");
-       }
-   }
-   ```
-
-3. **Register DevDataSeeder in `Infrastructure/DependencyInjection.cs`:**
-   ```csharp
-   services.AddScoped<IDevDataSeeder, DevDataSeeder>();
-   ```
-
-**If DevDataSeeder already exists:** Skip this check.
-
-### Check 5c: SqlObjects Directory (BLOCKING - first entity only)
-
-**If this is the FIRST entity in the project (no existing SqlObjectHelper):**
-
-Scaffold the SQL objects infrastructure:
-
-1. **Create `Infrastructure/Persistence/SqlObjects/SqlObjectHelper.cs`**
-
-   ```csharp
-   using System.Reflection;
-   using Microsoft.EntityFrameworkCore.Migrations;
-
-   namespace {BaseNamespace}.Infrastructure.Persistence.SqlObjects;
-
-   /// <summary>
-   /// Helper for applying SQL objects (Functions, Views, Stored Procedures) from embedded resources.
-   /// SQL files use CREATE OR ALTER for idempotency — safe to re-run on any migration or squash.
-   /// </summary>
-   public static class SqlObjectHelper
-   {
-       private static readonly Assembly Assembly = typeof(SqlObjectHelper).Assembly;
-       private const string ResourcePrefix = "{BaseNamespace}.Infrastructure.Persistence.SqlObjects.";
-
-       public static void ApplyAll(MigrationBuilder migrationBuilder)
-       {
-           ApplyAllFunctions(migrationBuilder);
-       }
-
-       public static void ApplyAllFunctions(MigrationBuilder migrationBuilder)
-       {
-           ApplyCategory(migrationBuilder, "Functions");
-       }
-
-       public static void ApplyOne(MigrationBuilder migrationBuilder, string resourceName)
-       {
-           var sql = ReadSqlObject(resourceName);
-           migrationBuilder.Sql(sql);
-       }
-
-       public static string ReadSqlObject(string resourceName)
-       {
-           var fullName = ResourcePrefix + resourceName;
-           using var stream = Assembly.GetManifestResourceStream(fullName)
-               ?? throw new InvalidOperationException(
-                   $"SQL object resource '{fullName}' not found. " +
-                   $"Ensure the .sql file is marked as EmbeddedResource in the .csproj.");
-           using var reader = new StreamReader(stream);
-           return reader.ReadToEnd();
-       }
-
-       private static void ApplyCategory(MigrationBuilder migrationBuilder, string category)
-       {
-           var prefix = ResourcePrefix + category + ".";
-           var resources = Assembly.GetManifestResourceNames()
-               .Where(n => n.StartsWith(prefix, StringComparison.Ordinal)
-                        && n.EndsWith(".sql", StringComparison.Ordinal))
-               .OrderBy(n => n, StringComparer.Ordinal);
-
-           foreach (var resource in resources)
-           {
-               using var stream = Assembly.GetManifestResourceStream(resource)!;
-               using var reader = new StreamReader(stream);
-               migrationBuilder.Sql(reader.ReadToEnd());
-           }
-       }
-   }
-   ```
-
-2. **Create empty directory `Infrastructure/Persistence/SqlObjects/Functions/`**
-   - Where `.sql` files for TVFs and scalar functions will be stored
-
-3. **Ensure `.csproj` has EmbeddedResource glob for SQL files:**
-   ```xml
-   <ItemGroup>
-     <EmbeddedResource Include="Persistence\SqlObjects\**\*.sql" />
-   </ItemGroup>
-   ```
-
-**If SqlObjectHelper already exists:** Skip this check.
-
-### Check 6: Convention Validation (RECOMMENDED)
-
-Run MCP convention validation on the generated backend code:
-
-```
-Tool: mcp__smartstack__validate_conventions
-Args:
-  target: "backend"
-  scope: "{entity_name}"
-```
+See [references/backend-verification.md](../references/backend-verification.md) for the complete verification checklist:
 
-This verifies:
-- Naming conventions (PascalCase entities, correct prefixes)
-- Architecture layers respected (no cross-layer violations)
-- Required attributes present (NavRoute, RequirePermission)
-- DTO patterns followed
+| Check | Type | What |
+|-------|------|------|
+| 1. Backend Build | BLOCKING | `dotnet build --no-restore` must succeed |
+| 2. DbSet Registration | BLOCKING | `DbSet<{EntityName}>` in DbContext |
+| 3. DI Registration | BLOCKING | `I{EntityName}Service` in DependencyInjection.cs |
+| 4. RequirePermission | BLOCKING | All HTTP actions have `[RequirePermission]` |
+| 5. Entity Configuration | BLOCKING | Table prefix, HasKey, HasIndex |
+| 5b. Seeding Infrastructure | BLOCKING (first entity) | SeedConstants + DevDataSeeder + DI |
+| 5c. SqlObjects Directory | BLOCKING (first entity) | SqlObjectHelper + Functions/ + .csproj EmbeddedResource |
+| 6. Convention Validation | RECOMMENDED | `mcp__smartstack__validate_conventions` |
 
-IF violations found: Fix them before proceeding to step-05.
+IF any BLOCKING check fails: Fix before proceeding to step-05.
 
 ---
 

package/templates/skills/application/steps/step-05-frontend.md

@@ -192,38 +192,9 @@ If the generated translations need customization (e.g., replacing generic title
 
 ## ROUTING RULES
 
-### Rule 1: Routes MUST be inside Layout wrappers
-
-**CRITICAL:** All routes MUST be nested inside the appropriate context layout. This is what provides the SmartStack shell (header with AvatarMenu, sidebar, navigation).
-
-```tsx
-// ✅ CORRECT - Inside BusinessLayout (shell renders: header + AvatarMenu + sidebar)
-<Route path="/business" element={<BusinessLayout />}>
-  <Route path="sales/products" element={<ProductsPage />} />
-</Route>
-
-// ❌ FORBIDDEN - Outside layout (NO shell, NO header, NO AvatarMenu!)
-<Route path="/business/sales/products" element={<ProductsPage />} />
-```
-
-### Rule 2: Use nested routes (not flat)
-
-**CRITICAL:** SmartStack requires NESTED routes within the layout:
-
-```tsx
-// ✅ CORRECT - Nested routes inside layout
-<Route path="/business" element={<BusinessLayout />}>
-  <Route path="sales">
-    <Route index element={<Navigate to="products" replace />} />
-    <Route path="products" element={<ProductsPage />} />
-    <Route path="orders" element={<OrdersPage />} />
-  </Route>
-</Route>
-
-// ❌ FORBIDDEN - Flat routes (cause redirect issues + bypass layout)
-<Route path="/business/sales" element={<Navigate to="products" />} />
-<Route path="/business/sales/products" element={<ProductsPage />} />
-```
+See [references/frontend-verification.md](../references/frontend-verification.md) for detailed routing rules with code examples:
+- **Rule 1:** Routes MUST be inside Layout wrappers (BusinessLayout, AdminLayout, UserLayout)
+- **Rule 2:** Use NESTED routes (not flat) — flat routes bypass layout and break the shell
 
 ---
 
@@ -247,76 +218,16 @@ locales/
 
 ## POST-GENERATION VERIFICATION (MANDATORY)
 
-**Before proceeding to step-06, run these checks on ALL generated frontend files:**
-
-### 1. CSS Variables Check (BLOCKING)
-
-Scan all generated `.tsx` files for hardcoded Tailwind colors:
-
-```
-FORBIDDEN patterns: bg-blue-, bg-red-, bg-green-, bg-gray-, bg-amber-,
-                    text-blue-, text-red-, text-green-, text-gray-, text-amber-,
-                    border-blue-, border-red-, border-green-, border-gray-
-```
-
-If ANY hardcoded color is found → **FIX IT** using CSS variables from style-guide.md before continuing.
+**Before proceeding to step-06, run all 7 checks on generated frontend files.**
 
-### 2. API Client Check (BLOCKING)
-
-Verify all API service files use the configured client:
-- **CORRECT:** `import { api } from '@/services/api/apiClient'` or `import api from '../api'`
-- **FORBIDDEN:** `import axios from 'axios'`
-
-### 3. EntityCard Check
-
-If a grid/card view is generated, verify it uses `EntityCard` component (not custom divs).
-
-### 4. i18n Check (BLOCKING)
-
-Verify exactly **4 language files** exist with identical key structures:
-- `fr/{entityCode}.json`
-- `en/{entityCode}.json`
-- `it/{entityCode}.json`
-- `de/{entityCode}.json`
-
-### 5. Route Check (BLOCKING)
-
-Verify routes are:
-- **INSIDE** the Layout wrapper (`BusinessLayout`, `AdminLayout`, or `UserLayout`)
-- **NESTED** (not flat)
-- Following path convention: `/{context}/{application}/{module}`
-
-### 6. States Check
-
-Verify the list page includes:
-- Loading state (spinner)
-- Error state (icon + message + retry button)
-- Empty state (icon + message)
-
-### 7. TypeScript Build Check (BLOCKING)
-
-Run the frontend type check to verify all generated files compile:
-
-```bash
-cd web && npx tsc --noEmit 2>&1 | head -50
-```
-
-OR if the project uses a build script:
-
-```bash
-cd web && npm run build 2>&1 | head -80
-```
-
-IF type errors exist **in generated files**: Fix them before proceeding.
-Common issues: missing imports, wrong interface names, incorrect prop types, missing hook return types.
-
-IF type errors exist **in other pre-existing files**: NON-BLOCKING. Note them but proceed.
-
-**Focus only on errors in files generated by this step:**
-- `pages/{context}/{application}/{module}/*.tsx`
-- `services/api/{entityCode}Api.ts`
-- `types/{entityName}.types.ts`
-- `hooks/use{EntityName}*.ts`
+See [references/frontend-verification.md](../references/frontend-verification.md) for the complete checklist:
+1. CSS Variables (BLOCKING) — no hardcoded Tailwind colors
+2. API Client (BLOCKING) — use configured client, not raw axios
+3. EntityCard — use EntityCard component for grid/card views
+4. i18n (BLOCKING) — exactly 4 language files with identical keys
+5. Route (BLOCKING) — inside Layout wrapper, nested, correct path convention
+6. States — loading, error, empty states present
+7. TypeScript Build (BLOCKING) — `npx tsc --noEmit` passes for generated files
 
 ---
 

package/templates/skills/application/steps/step-07-tests.md

@@ -47,78 +47,11 @@ From previous steps:
 
 ## PRE-REQUISITES
 
-### 1. Verify Test Project Exists
-
-Check that the solution contains a test project:
-
-```bash
-# Look for existing test project
-ls *Tests*/*.csproj 2>/dev/null || ls tests/*/*.csproj 2>/dev/null
-```
-
-If NO test project exists, create one:
-
-```bash
-dotnet new xunit -n {SolutionName}.Tests -o tests/{SolutionName}.Tests
-dotnet sln add tests/{SolutionName}.Tests/{SolutionName}.Tests.csproj
-```
-
-### 2. Verify Required NuGet Packages
-
-The test project MUST have these packages:
-
-| Package | Purpose |
-|---------|---------|
-| `xunit` | Test framework |
-| `FluentAssertions` | Assertion library |
-| `Moq` | Mocking framework |
-| `Microsoft.AspNetCore.Mvc.Testing` | Integration test support |
-| `Microsoft.EntityFrameworkCore.Sqlite` | SQLite in-memory for REAL integration tests |
-| `Microsoft.Data.Sqlite` | SQLite connection support |
-| `Microsoft.EntityFrameworkCore.InMemory` | In-memory DB for repository tests |
-| `FluentValidation.TestHelper` | Validator testing support |
-
-```bash
-cd tests/{SolutionName}.Tests
-dotnet add package FluentAssertions
-dotnet add package Moq
-dotnet add package Microsoft.AspNetCore.Mvc.Testing
-dotnet add package Microsoft.EntityFrameworkCore.Sqlite
-dotnet add package Microsoft.Data.Sqlite
-dotnet add package Microsoft.EntityFrameworkCore.InMemory
-dotnet add package FluentValidation.TestHelper
-```
-
-### 3. Add Project References
-
-The test project MUST reference the API project (for WebApplicationFactory):
-
-```bash
-cd tests/{SolutionName}.Tests
-dotnet add reference ../../src/{SolutionName}.Api/{SolutionName}.Api.csproj
-dotnet add reference ../../src/{SolutionName}.Application/{SolutionName}.Application.csproj
-dotnet add reference ../../src/{SolutionName}.Domain/{SolutionName}.Domain.csproj
-dotnet add reference ../../src/{SolutionName}.Infrastructure/{SolutionName}.Infrastructure.csproj
-```
-
-### 4. Ensure Program.cs is Accessible (BLOCKING)
-
-The API project's `Program` class must be accessible for `WebApplicationFactory<Program>`.
-
-Check if `Program.cs` ends with `public partial class Program { }`. If not, add it:
-
-```csharp
-// At the very end of Program.cs
-public partial class Program { }
-```
-
-**Alternatively**, add to the API `.csproj`:
-
-```xml
-<ItemGroup>
-  <InternalsVisibleTo Include="{SolutionName}.Tests" />
-</ItemGroup>
-```
+See [references/test-prerequisites.md](../references/test-prerequisites.md) for the complete setup:
+1. Verify test project exists (create xunit project if missing)
+2. Install required NuGet packages (xunit, FluentAssertions, Moq, Mvc.Testing, EF Sqlite, etc.)
+3. Add project references (API, Application, Domain, Infrastructure)
+4. Ensure Program.cs is accessible for WebApplicationFactory (BLOCKING)
 
 ---
 
@@ -343,62 +276,13 @@ dotnet test tests/{SolutionName}.Tests/{SolutionName}.Tests.csproj --no-build --
 
 ## FRONTEND TESTS (React Components)
 
-### 7. Check Frontend Test Infrastructure
+See [references/test-frontend.md](../references/test-frontend.md) for the complete frontend test setup:
 
-Verify that the frontend project has Vitest + Testing Library configured:
-
-```bash
-# Check if vitest.config.ts exists in the web/frontend project
-ls {WebProjectPath}/vitest.config.ts 2>/dev/null
-```
-
-If NOT found, deploy the test infrastructure:
-
-1. **Install packages:**
-
-```bash
-cd {WebProjectPath}
-npm install -D vitest @testing-library/react @testing-library/jest-dom @testing-library/user-event jsdom msw
-```
-
-2. **Copy infrastructure files** from SmartStack templates:
-
-| Template Source | Destination |
-|----------------|-------------|
-| `templates/project/test-frontend/vitest.config.ts` | `{WebProjectPath}/vitest.config.ts` |
-| `templates/project/test-frontend/setup.ts` | `{WebProjectPath}/src/test/setup.ts` |
-| `templates/project/test-frontend/test-utils.tsx` | `{WebProjectPath}/src/test/test-utils.tsx` |
-| `templates/project/test-frontend/msw/server.ts` | `{WebProjectPath}/src/test/msw/server.ts` |
-| `templates/project/test-frontend/msw/handlers.ts` | `{WebProjectPath}/src/test/msw/handlers.ts` |
-
-3. **Add test script** to `package.json` (if missing):
-
-```json
-{
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage"
-  }
-}
-```
-
-### 8. Generate Frontend Tests
-
-```
-Tool: mcp__smartstack__scaffold_frontend_tests
-Args:
-  name: "{entity_name}"
-  components: ["all"]
-  apiRoute: "/api/{entity_code}"
-```
-
-This generates:
-- `src/pages/{context}/{application}/__tests__/{EntityName}Page.test.tsx` - Page rendering, loading, error states
-- `src/pages/{context}/{application}/__tests__/{EntityName}ListView.test.tsx` - List display, pagination, view toggle
-- `src/pages/{context}/{application}/__tests__/{EntityName}DetailPage.test.tsx` - Detail view, tabs, back navigation
-- `src/hooks/__tests__/use{EntityName}Preferences.test.ts` - Preference get/set
-- `src/services/api/__tests__/{entityName}Api.test.ts` - API client calls with MSW
+### 7-8. Infrastructure & Test Generation
+- Check Vitest + Testing Library + MSW configuration
+- Install packages if missing (`vitest`, `@testing-library/react`, `msw`, etc.)
+- Copy infrastructure templates (vitest.config.ts, setup.ts, test-utils.tsx, MSW handlers)
+- Generate tests via `mcp__smartstack__scaffold_frontend_tests` (Page, ListView, DetailPage, Hooks, API)
 
 ### 9. Run Frontend Tests (BLOCKING)
 
@@ -407,11 +291,7 @@ cd {WebProjectPath}
 npx vitest run --reporter=default
 ```
 
-**ALL frontend tests MUST pass.** If tests fail:
-1. Read the failure output carefully
-2. Fix the failing tests or the components they test
-3. Re-run until all tests pass
-4. Do NOT proceed to the next step until all tests are green
+**ALL frontend tests MUST pass.** Fix failures before proceeding.
 
 ---