@atlashub/smartstack-cli 4.81.0 → 5.0.0

package/templates/skills/apex/steps/step-02-plan.md

@@ -1,303 +0,0 @@
----
-name: step-02-plan
-description: Create layer-by-layer execution plan with skill/MCP mapping per file
-model: opus
-prev_step: steps/step-01-analyze.md
-next_step: steps/step-03-execute.md
----
-
-# Step 2: Plan
-
-**ULTRA THINK about the execution strategy. For each file: is it CREATE (new) or MODIFY (exists but needs additions for new sections/entities)? Seed data files are frequently marked "skip" by mistake when they should be "modify" — verify this explicitly.**
-
-**Goal:** Create a precise, file-by-file plan. Each file mapped to a SKILL or MCP tool.
-
-## LOAD CONDITIONALLY
-
-Read `references/smartstack-layers.md` for layer execution rules, skill/MCP mapping, planning templates, and delegate mode fast path.
-> **CONTEXT NOTE:** This file stays in context and is reused by step-03. Do NOT re-read it there.
-
----
-
-## 0. Delegate Mode Fast Path (if delegate_mode)
-
-> **When called via `/business-analyse-develop -d`, PRD tasks already define the scope. Map directly to layers.**
-
-```
-IF delegate_mode:
-  Read PRD from {delegate_prd_path}
-
-  Map each PRD task to a layer based on task.category:
-    domain          → Layer 0
-    infrastructure  → Layer 0
-    seedData        → Layer 1
-    application     → Layer 2
-    api             → Layer 2
-    frontend        → Layer 3
-    test            → inline (Layer 2 backend tests, Layer 3 frontend tests)
-
-  For each task:
-    file_path    = task.files_changed.created[0] (primary file)
-    action       = "create" (default for delegate mode)
-    tool         = infer from category:
-                   domain/infrastructure → MCP scaffold_extension
-                   api → /controller skill or MCP scaffold_extension
-                   seedData → MCP generate_permissions + ref core-seed-data.md
-                   frontend → /ui-components skill + MCP scaffold_api_client + MCP scaffold_routes
-                   test → MCP scaffold_tests
-    acceptance_criteria = task.acceptance_criteria
-
-  Use task._seedDataMeta, _frontendMeta, _migrationMeta for enriched context.
-
-  SKIP: User checkpoint (section 6) — auto_mode implied
-  Jump to section 5 (Estimated Commits) → NEXT STEP
-```
-
----
-
-## 1-3. Layer Mapping, Skill Assignment, Parallelization
-
-> **Reference:** All planning procedures are now in `references/smartstack-layers.md` (already loaded above):
-> - Layer assignment matrix (Domain/Infrastructure/Seed/Application/API/Frontend/DevData)
-> - Entity definition template (tenantMode, codePattern, fkFields, ACs)
-> - Skill/MCP assignment table (per file, per layer)
-> - Layer 0/1/2/3/4 file lists with tools (see "Planning Template" section)
-> - FK field guidance (EntityLookup + backend ?search= parameter)
-> - Parallelization strategy (Agent tool within Layer 2/3 for multi-entity)
-> - Delegate mode fast path (PRD task mapping to layers)
-
-```
-Layer 0: SEQUENTIAL (agent principal)
-  → domain + infra + migration
-  → dotnet build --no-restore (must pass)
-
-Layer 1: SEQUENTIAL (agent principal)
-  → seed data (navigation, permissions, roles)
-  → dotnet build (must pass)
-
-Layer 2: PARALLEL WITHIN LAYER (Agent tool if multi-entity)
-  → services + controllers
-  → dotnet build (must pass)
-  → backend tests inline (scaffold + run + fix max 3)
-
-Layer 3: PARALLEL WITHIN LAYER (Agent tool if multi-entity)
-  → pages + i18n + documentation
-  → compliance gate (must pass)
-  → frontend tests inline (scaffold + run + fix max 3)
-
-Layer 4: OPTIONAL (agent principal)
-  → DevData seeder
-```
-
-If economy_mode: ALL layers sequential, agent principal only.
-
----
-
-## 4. Dependency Validation
-
-Verify the plan respects dependencies:
-
-```
-- Migration AFTER EF configs (always)
-- Seed data AFTER migration (Layer 1 depends on Layer 0 build gate)
-- Application services AFTER domain entities (always)
-- Code generator service AFTER entity + EF config (needs DbSet for sequence query)
-- CreateDto adjustments AFTER code pattern decision (remove Code property if auto-generated)
-- Controllers AFTER application services (always)
-- Backend tests AFTER services + controllers (inline in Layer 2)
-- Frontend AFTER API controllers (API contract needed)
-- Frontend tests AFTER pages created (inline in Layer 3)
-- Build gate between EVERY layer (must pass): Layer 0 → 1 → 2 → 3 → 4
-```
-
-### 4b. Module Code Collision Guard (BLOCKING)
-
-```
-IF appCode == moduleCode:
-  BLOCK — module_code identique à app_code cause des segments doublés (e.g. /hr/hr).
-  Suggestion : "{appCode}-core", "{appCode}-management"
-  ASK user pour un module_code différent.
-```
-
----
-
-## 5. Estimated Commits
-
-```
-feat({module}): [domain+infra] {description}
-feat({module}): [seed] navigation, permissions, roles
-feat({module}): [app+api] {description}
-test({module}): backend unit and integration tests
-feat({module}): [frontend] pages, routes, i18n, documentation
-test({module}): frontend form tests
-feat({module}): [devdata] test data for development  # if applicable
-```
-
-**Maximum 7 commits per module.**
-
----
-
-## 6. User Checkpoint (if NOT auto_mode)
-
-Present the plan and ask for validation:
-
-```yaml
-questions:
-  - header: "Plan"
-    question: "Does this execution plan look correct?"
-    options:
-      - label: "Approve and execute (Recommended)"
-        description: "Proceed with the plan as described"
-      - label: "Modify plan"
-        description: "I want to adjust some items"
-      - label: "Cancel"
-        description: "Abort the workflow"
-    multiSelect: false
-```
-
-If "Modify plan": ask what to change, update plan, re-present.
-If "Cancel": abort workflow.
-
----
-
-## 7. Save Output (if save_mode)
-
-Write to `{output_dir}/02-plan.md` with the complete plan.
-
----
-
-## 8. Create Task List
-
-> **Visibility:** TaskCreate generates the grouped progress UI with checkboxes.
-> This makes APEX execution trackable and predictable for the user.
-
-After plan is finalized (auto_mode or user approved):
-
-### Task Creation Rules
-
-1. Create ONE task per layer (Layer 0-4)
-2. For multi-entity layers (2, 3): create ONE sub-task per entity within the layer
-3. Add build/test gate tasks after each layer
-4. Set dependencies via `addBlockedBy` to enforce layer ordering
-
-### Metadata Schema
-
-> **All APEX tasks use this metadata schema for context recovery after compression:**
-
-```typescript
-// Schema for ALL APEX tasks
-{
-  layer?: number,           // 0-4, absent for meta/examine/finding tasks
-  apex_step?: string,       // "02-plan", "03-execute", etc (meta task only)
-  entities?: string[],      // entities concerned
-  tools?: string[],         // MCP tools/skills used
-  build_gate?: "pending" | "pass" | "fail",
-  files_created?: string[], // updated via TaskUpdate after creation
-  module?: string,          // module code (meta task only)
-  app?: string,             // app name (meta task only)
-  flags?: object            // APEX flags (meta task only)
-}
-```
-
-### Task Template
-
-```
-# APEX Progress Tracker (recovery anchor)
-TaskCreate(subject: "APEX Progress",
-  description: "Module: {module_code}, App: {app_name}, Entities: {entities list}. Current: step-02 (Plan)",
-  activeForm: "Planning execution",
-  metadata: {
-    apex_step: "02-plan",
-    module: "{module_code}",
-    app: "{app_name}",
-    entities: ["{entity1}", "{entity2}"],
-    flags: { auto: {auto_mode}, economy: {economy_mode}, examine: {examine_mode} }
-  })
-
-# Layer 0 — Domain + Infrastructure
-TaskCreate(subject: "Layer 0: Domain + Infrastructure",
-  description: "Entities: {entity1} ({tenantMode}), {entity2} ({tenantMode}).
-Files: Domain/Entities/*.cs, Infrastructure/Persistence/Configs/*.cs, Migration.
-Tools: MCP scaffold_extension (type: entity). EF config: manual per smartstack-api.md. MCP suggest_migration.
-Gate: dotnet build --no-restore. ACs: {relevant ACs}.",
-  activeForm: "Creating domain entities",
-  metadata: { layer: 0, entities: [...], tools: ["scaffold_extension", "suggest_migration"], build_gate: "pending", files_created: [] })
-
-# Layer 1 — Seed Data
-TaskCreate(subject: "Layer 1: Seed Data",
-  description: "Navigation, permissions, roles, provider for {module_code}.
-Files: Seeding/Data/{Module}/*.cs, {App}SeedDataProvider.cs.
-Tools: MCP generate_permissions. Ref: core-seed-data.md.
-Gate: dotnet build. ACs: {relevant ACs}.",
-  activeForm: "Generating seed data",
-  metadata: { layer: 1, entities: [...], tools: ["generate_permissions"], build_gate: "pending", files_created: [] })
-TaskUpdate(taskId: layer1_id, addBlockedBy: [layer0_id])
-
-# Layer 2 — Backend (1 task per entity if multi-entity, 1 task if single)
-IF multi-entity:
-  FOR EACH entity:
-    TaskCreate(subject: "Layer 2: {Entity} backend",
-      description: "Service + DTO + Controller + Validator for {Entity}.
-Files: Application/Services/{Entity}Service.cs, Application/DTOs/{Entity}*.cs, Api/Controllers/{Entity}Controller.cs.
-Tools: MCP scaffold_extension, /controller skill. Gate: dotnet build.
-ACs: {relevant ACs for this entity}.",
-      activeForm: "Building {Entity} backend",
-      metadata: { layer: 2, entities: ["{Entity}"], tools: ["scaffold_extension", "controller"], build_gate: "pending", files_created: [] })
-    TaskUpdate(taskId: entity_task_id, addBlockedBy: [layer1_id])
-
-# Layer 2 Tests
-TaskCreate(subject: "Layer 2: Backend tests",
-  description: "Unit + integration tests for all entities.
-Tools: MCP scaffold_tests (unit + integration). Gate: dotnet test.",
-  activeForm: "Running backend tests",
-  metadata: { layer: 2, tools: ["scaffold_tests"], build_gate: "pending" })
-
-# Layer 3 — Frontend (1 task per entity if multi-entity)
-IF multi-entity:
-  FOR EACH entity:
-    TaskCreate(subject: "Layer 3: {Entity} frontend",
-      description: "API client, pages (List/Detail/Create/Edit), i18n (4 langs), routes for {Entity}.
-Files: src/pages/{App}/{Module}/{Entity}*.tsx, src/i18n/locales/*/{module}.json.
-Tools: MCP scaffold_api_client, MCP scaffold_routes, /ui-components skill.
-Gate: npm run typecheck + 5 compliance gates. ACs: {relevant ACs}.",
-      activeForm: "Building {Entity} frontend",
-      metadata: { layer: 3, entities: ["{Entity}"], tools: ["scaffold_api_client", "scaffold_routes", "ui-components"], build_gate: "pending", files_created: [] })
-    TaskUpdate(taskId: entity_task_id, addBlockedBy: [layer2_tests_id])
-
-# Layer 3 Tests + Compliance
-TaskCreate(subject: "Layer 3: Frontend tests + compliance",
-  description: "Form tests (Create/Edit .test.tsx), typecheck, 5 compliance gates.
-Tools: Vitest + React Testing Library. Gate: npm run test + typecheck.",
-  activeForm: "Running frontend tests",
-  metadata: { layer: 3, tools: ["vitest"], build_gate: "pending" })
-
-# Layer 4 (if applicable)
-IF NOT foundation_mode AND devdata needed:
-  TaskCreate(subject: "Layer 4: DevData",
-    description: "Development test data seeder.
-Files: Infrastructure/Persistence/Seeding/DevData/{Module}DevDataSeeder.cs.
-Gate: dotnet build.",
-    activeForm: "Creating dev data",
-    metadata: { layer: 4, tools: [], build_gate: "pending", files_created: [] })
-
-# Post-execution
-TaskCreate(subject: "eXamine: Validation + POST-CHECKs",
-  description: "MCP validate_conventions, build, POST-CHECKs (see post-checks.md), acceptance criteria.
-Tools: MCP validate_conventions, validate_security, validate_frontend_routes.",
-  activeForm: "Validating conventions",
-  metadata: { tools: ["validate_conventions", "validate_security", "validate_frontend_routes"] })
-```
-
-### Economy Mode
-
-IF economy_mode: Create the SAME tasks (for visibility), but no parallel agents — agent principal executes sequentially.
-
-### Delegate Mode
-
-IF delegate_mode: Create tasks from PRD task list, mapped to layers.
-
----
-
-## NEXT STEP
-
-Load `steps/step-03-execute.md`

package/templates/skills/apex/steps/step-03-execute.md

@@ -1,194 +0,0 @@
----
-name: step-03-execute
-description: Orchestrate code creation via existing skills and MCP tools
-model: opus
-prev_step: steps/step-02-plan.md
-next_step: steps/step-04-examine.md
----
-
-# Step 3: Execute — Orchestrator
-
-**ULTRA THINK about the full execution context. Before dispatching layers, verify: are we creating a NEW module or UPDATING an existing one? This is critical for Layer 1 (seed data) — existing seed files must be MODIFIED, not recreated or skipped.**
-
-/apex ORCHESTRATES. It does not write SmartStack code directly.
-All code goes through skills (/controller, /application, /ui-components, /efcore) or MCP tools.
-
-**This step dispatches to layer-specific sub-steps.** Each sub-step is loaded sequentially.
-
-## LOAD CONDITIONALLY
-
-> CONTEXT REUSE: `smartstack-api.md` (loaded in step-01) and `smartstack-layers.md` (loaded in step-02) are already in context. Do not re-read them.
-
-- Read `references/core-seed-data.md` — comprehensive seed data templates (needed for Layer 1, released after)
-- Defer `references/smartstack-frontend.md` until Layer 3 — lazy loading, i18n, page structure, CSS variables, EntityLookup (sections 1-6)
-- Defer `references/smartstack-frontend-compliance.md` until Layer 3 — documentation, form testing, compliance gates (sections 7-9)
-- If NOT `{economy_mode}` AND a layer has multi-entity work: read `references/parallel-execution.md`
-- If build failure during execution: read `references/error-classification.md` — error diagnosis categories A-F
-
----
-
-## Foundation Mode Detection
-
-**IF `{foundation_mode}` == true:**
-Execute ONLY Layer 0 (domain entities + EF configs + migration). Skip all other layers.
-After Layer 0 completes: commit `chore(foundation): entities for {module_code}`, jump to step-04.
-
-**IF `{foundation_mode}` == false:**
-Execute all layers (Layer 0 → Layer 1 → Layer 2 → Layer 3 → Layer 4).
-
----
-
-## Context Recovery Protocol
-
-> **Run this check BEFORE each layer** to survive context compression.
-
-```
-BEFORE starting Layer N:
-  Verify these variables are still accessible:
-    {app_name}, {module_code}, {sections}, {entities}, {code_patterns}, {entity_section_map}
-    IF delegate_mode: also verify {delegate_prd_path}, {specification_loading_plan}
-
-  IF any variable is missing or empty:
-    1. Read .claude/output/apex/{task_id}/state.json (if exists)
-    2. IF state.json has delegate context:
-       - {delegate_prd_path} = state.delegate_prd_path
-       - {delegate_mode} = state.delegate_mode
-       - Re-read PRD at {delegate_prd_path} to rebuild specification_loading_plan:
-         const prd = readJSON(delegate_prd_path);
-         if (prd.specificationFiles) {
-           specification_loading_plan = {
-             layer0_domain:   [prd.specificationFiles.entities],
-             layer1_seed:     [prd.specificationFiles.entities, prd.specificationFiles.permissions],
-             layer2_backend:  [prd.specificationFiles.rules, prd.specificationFiles.usecases],
-             layer3_frontend: [prd.specificationFiles.screens, prd.specificationFiles.usecases]
-           };
-         }
-       - {app_name} = state.app_name || prd.project?.application || prd.metadata?.applicationCode
-       - {module_code} = state.module_code || prd.project?.module || prd.metadata?.moduleCode
-    3. IF state.json missing OR no delegate context → re-derive from filesystem:
-       - {app_name}: Glob("docs/business/*/") → first directory name
-       - {module_code}: Glob("src/**/Domain/Entities/*/") → target module directory
-       - {entities}: Glob("src/**/Domain/Entities/{module_code}/*.cs") → entity names
-       - {sections}: Glob("src/**/Seeding/Data/{module_code}/*NavigationSeedData.cs") → parse
-       - {code_patterns}: Read state.json or re-derive from DependencyInjection.cs
-       - {entity_section_map}: IF state.json has it → use directly. ELSE re-derive:
-         For each entity, check controllers for [NavRoute] value:
-           Grep("\[NavRoute\(\"", "src/**/Controllers/**/{Entity}*Controller.cs")
-           → extract navRoute segments → determine level (2 seg = module, 3 seg = section)
-         Fallback: re-apply step-00 §4g matching algorithm with {entities} and {sections}
-    4. IF recovered: verify consistency with naming derivation rules (step-00 §4f, §4g)
-    5. IF Layer N-1 already completed: skip to Layer N directly
-
-  Cost: ~5-8 tool calls. Only triggered if context was compressed.
-```
-
----
-
-## Layer Dispatch
-
-> **CRITICAL RULES — LAYER EXECUTION GUARANTEE**
->
-> - **NEVER** stop between layers. NEVER ask the user. NEVER present numbered options between layers.
-> - The pipeline is sequential and mandatory: **0 → 1 → 2 → 3 → 4 → step-04**, with **ZERO pauses**.
-> - After each sub-step completes, IMMEDIATELY load the next one. No summary, no confirmation request.
-> - Stopping between layers is a **VIOLATION** of the execution guarantee defined in SKILL.md.
-
-Load each sub-step sequentially:
-
-| Layer | Sub-step | Content |
-|-------|----------|---------|
-| 0 | `steps/step-03a-layer0-domain.md` | Domain entities, EF configs, migration |
-| 1 | `steps/step-03b-layer1-seed.md` | Seed data (navigation, permissions, roles) |
-| 2 | `steps/step-03c-layer2-backend.md` | Services, controllers, backend tests |
-| 3 | `steps/step-03d-layer3-frontend.md` | Pages, i18n, routes, frontend tests |
-| 4 | `steps/step-03e-layer4-devdata.md` | Development test data (optional) |
-
-**FIRST ACTION:** Load `steps/step-03a-layer0-domain.md`
-
----
-
-## PRD State Update (delegate mode only)
-
-> **After completing EACH layer**, update the PRD file so `/business-analyse-develop` can track progress.
-
-```
-IF delegate_mode:
-  After each layer completes successfully:
-    Read {delegate_prd_path}
-    For each task executed in this layer:
-      task.status = 'completed'  (or 'failed' if errors)
-      task.completed_at = new Date().toISOString()
-      task.iteration = 1  (delegate mode = single iteration)
-      task.commit_hash = $(git rev-parse --short HEAD)
-      task.files_changed = { created: [...], modified: [...] }
-      task.validation = "APEX_PASS" (or error details)
-    prd.updated_at = new Date().toISOString()
-    Write back to {delegate_prd_path}
-```
-
----
-
-## Commits Per Layer
-
-```
-Layer 0: feat({module}): [domain+infra] {short description}
-Layer 1: feat({module}): [seed] navigation, permissions, roles
-Layer 2: feat({module}): [app+api] {short description}
-Layer 2: test({module}): backend unit and integration tests
-Layer 3: feat({module}): [frontend] pages, routes, i18n, documentation
-Layer 3: test({module}): frontend form tests
-Layer 4: feat({module}): [devdata] test data for development  # if applicable
-```
-
-**Maximum 7 commits per module.**
-
----
-
-## State Auto-Save (after each layer)
-
-> **Automatic** — not dependent on `-s` flag. Enables reliable resume after context loss.
-> **CRITICAL (audit ba-003):** Delegate context MUST be persisted for resume to work in delegate mode.
-
-After each layer's build gate passes, write state to `.claude/output/apex/{task_id}/state.json`:
-
-```json
-{
-  "step": 3, "layer": 2,
-  "completed_layers": [0, 1, 2],
-  "completed_entities": ["Employee", "Department"],
-  "files_created": ["Employee.cs", "EmployeeConfiguration.cs", "..."],
-  "build_gates": { "layer0": "pass", "layer1": "pass", "layer2": "pass" },
-  "commits": ["abc1234", "def5678", "ghi9012"],
-  "timestamp": "2026-03-06T14:30:00Z",
-  "delegate_mode": true,
-  "delegate_prd_path": ".ralph/prd-employees.json",
-  "app_name": "HumanResources",
-  "module_code": "employee-management",
-  "sections": ["employees", "departments"],
-  "entities": ["Employee", "Department"],
-  "entity_section_map": [
-    { "entity": "Employee", "level": "module", "navRoute": "human-resources.employee-management", "section_code": null },
-    { "entity": "Department", "level": "section", "navRoute": "human-resources.employee-management.departments", "section_code": "departments" }
-  ]
-}
-```
-
-> **Fields `delegate_mode`, `delegate_prd_path`, `app_name`, `module_code`, `sections`, `entities`, `entity_section_map`**
-> are persisted so that Context Recovery Protocol (above) can restore the full execution context
-> after context compression or resume (`-r`). The `specification_loading_plan` is rebuilt from the
-> PRD file at `delegate_prd_path` — no need to serialize it directly.
-> The `entity_section_map` is critical for Layers 2-3: it determines per-entity NavRoute and
-> section-level permission generation. If lost, it can be re-derived from controller [NavRoute] attributes
-> or by re-applying step-00 §4g matching algorithm.
-
----
-
-## Save Output (if save_mode)
-
-Write to `{output_dir}/03-execute.md` with execution log per layer.
-
----
-
-## NEXT STEP
-
-Load `steps/step-04-examine.md`

package/templates/skills/apex/steps/step-03a-layer0-domain.md

@@ -1,144 +0,0 @@
----
-name: step-03a-layer0-domain
-description: "Layer 0: Domain entities, EF configs, migration"
-model: opus
-parent_step: steps/step-03-execute.md
----
-
-**ULTRA THINK about domain entities: which are NEW (create) vs which EXIST (modify/extend)?**
-
-## Layer 0 — Domain + Infrastructure (sequential, agent principal)
-
-### Companion Specs Loading (delegate mode)
-
-```javascript
-if (delegate_mode && specification_loading_plan) {
-  const specsDir = path.dirname(delegate_prd_path);
-  // Layer 0 loads: entities companion
-  for (const file of specification_loading_plan.layer0_domain) {
-    const specPath = path.join(specsDir, file);
-    if (fileExists(specPath)) {
-      const specData = readJSON(specPath);
-      // specData.entities[] contains full attribute definitions:
-      //   { name, type, required, validation, defaultValue, relationships[] }
-      // Use these for entity scaffolding instead of just entity names
-      console.log(`Loaded ${specPath}: ${(specData.entities || []).length} entities with full attributes`);
-    }
-  }
-}
-```
-
-> When companion specs are loaded, use `specData.entities[].attributes[]` for entity property definitions (type, required, validation, defaultValue) instead of inferring from task descriptions. This ensures oneshot generation with correct types and constraints.
-
-### Task Progress
-TaskUpdate(taskId: layer0_task_id, status: "in_progress")
-TaskUpdate(taskId: progress_tracker_id,
-  description: "Module: {module_code}. Current: step-03 (Execute), Layer 0",
-  activeForm: "Executing Layer 0")
-
-### Domain Entities
-
-```
-For each entity to create/modify:
-  → MCP scaffold_extension (type: "entity", target: entity_name)
-  → Verify: inherits BaseEntity, implements ITenantEntity + IAuditableEntity
-  → Verify entity matches patterns in references/smartstack-api.md
-```
-
-### Code Generation Integration
-
-```
-For each entity with auto-generated code ({code_patterns} from step-00):
-  IF {code_patterns} has entry for this entity AND strategy != "manual":
-    → Pass codePattern in scaffold_extension options:
-      MCP scaffold_extension (type: "entity", target: entity_name, options: {
-        codePattern: {
-          strategy: {code_patterns[entity].strategy},
-          prefix: {code_patterns[entity].prefix},
-          digits: {code_patterns[entity].digits},
-          includeTenantSlug: {code_patterns[entity].includeTenantSlug},
-          separator: {code_patterns[entity].separator}
-        }
-      })
-    → Verify: Code property exists on entity but is NOT in CreateDto
-    → Verify: ICodeGenerator<{Entity}> is ready for DI registration (Layer 2)
-  ELSE:
-    → Default behavior (strategy: "manual", Code in CreateDto)
-```
-
-### Enum Serialization Check
-
-```
-For each enum type created in Domain/Enums/:
-  1. Grep("JsonStringEnumConverter", "src/**/Program.cs")
-  2. IF global config exists → no action
-  3. IF no global config → add [JsonConverter(typeof(JsonStringEnumConverter))] on each enum
-```
-
-### Person Extension Detection
-
-**If entity has personRoleConfig (mandatory or optional UserId link):**
-See `references/person-extension-pattern.md` for full entity, EF config, service, DTO, and frontend patterns.
-
-```
-1. scaffold_extension with options: { isPersonRole: true, userLinkMode: 'mandatory' | 'optional' }
-2. Verify: EF config has unique index on (TenantId, UserId)
-   → Mandatory variant: plain .IsUnique()
-   → Optional variant: .IsUnique().HasFilter("[UserId] IS NOT NULL")
-3. Verify all build checks pass before continuing
-```
-
-### EF Core Configurations
-
-```
-For each entity:
-  → Create IEntityTypeConfiguration<T> manually per smartstack-api.md patterns
-  → Verify: table name, relationships, indexes
-  → Register DbSet in ExtensionsDbContext if new entity
-```
-
-<!-- TODO A6: Replace with MCP scaffold_extension(type: "ef-config") when B2 is ready -->
-
-### Migration
-
-> Migration must cover ALL entities. Root cause (test-apex-007): Migration was created once for 3 entities, then 4 more entities were added later without re-running → 4 entities had no tables. Create/update migration AFTER ALL entities and EF configs are registered in DbContext. If entities are added incrementally, create a new migration for each batch.
-
-```
-1. Verify all entities have been added as DbSet in ExtensionsDbContext
-2. Verify all EF configurations are registered (ApplyConfigurationsFromAssembly or individual)
-3. MCP suggest_migration → get standardized name
-4. dotnet ef migrations add {Name} --project src/{Infra}.csproj --startup-project src/{Api}.csproj -o Persistence/Migrations
-5. dotnet ef database update (if local DB)
-6. dotnet build
-7. Verify: dotnet ef migrations has-pending-model-changes → must report "No pending model changes"
-```
-
-If build fails after migration, fix EF configs before proceeding.
-If `has-pending-model-changes` reports pending changes, entities are missing from the migration — create a new migration.
-
-### Post-Layer 0 Build Gate
-
-```bash
-dotnet build
-# Note: WSL bin\Debug cleanup handled by PostToolUse hook (wsl-dotnet-cleanup.sh)
-```
-
-Must pass before Layer 1. If NuGet error, run `dotnet restore` first. If file lock (MSB3021), use `--output /tmp/{project}_build`.
-
-TaskUpdate(taskId: layer0_task_id, status: "completed",
-  metadata: { build_gate: "pass" })
-
-### Layer 0 Commit
-
-```
-feat({module}): [domain+infra] {short description}
-```
-
----
-
-## NEXT SUB-STEP (MANDATORY — IMMEDIATE)
-
-> **DO NOT STOP.** DO NOT ask the user. DO NOT present options. IMMEDIATELY load the next sub-step.
-> Stopping here is a VIOLATION of the execution guarantee.
-
-Load `steps/step-03b-layer1-seed.md`