@atlashub/smartstack-cli 3.21.0 → 3.22.0

package/templates/skills/business-analyse/steps/step-03d-validate.md

@@ -46,8 +46,8 @@ Validate the module specification for completeness and consistency, write to fea
 | entities | 1 | `analysis.entities.length >= 1` | PASS/FAIL |
 | entitySchemaFormat | attributes[] not fields[] (BLOCKING) | `analysis.entities.every(e => e.attributes?.length > 0)` | PASS/FAIL |
 | entityAttributeTypes | ALL attributes have `type` field (BLOCKING) | `analysis.entities.every(e => e.attributes.every(a => a.type))` | PASS/FAIL |
-| wireframes | 1 per section (BLOCKING) | `specification.wireframes.length >= specification.sections.length` (count REAL elements) | PASS/FAIL |
-| wireframeSchema | All required fields present (BLOCKING) | `specification.wireframes.every(w => w.screen && w.section && (w.mockup \|\| w.content))` | PASS/FAIL |
+| wireframes | 1 per section (BLOCKING) | `(specification.uiWireframes \|\| specification.wireframes \|\| []).length >= (specification.sections \|\| []).length` (count REAL elements, check BOTH key names) | PASS/FAIL |
+| wireframeSchema | All required fields present (BLOCKING) | `(specification.uiWireframes \|\| specification.wireframes \|\| []).every(w => (w.screen \|\| w.title) && w.section && (w.mockup \|\| w.ascii \|\| w.content))` | PASS/FAIL |
 | sections | 1 (BLOCKING) | `specification.sections.length >= 1` (EVERY module needs at least 1 section) | PASS/FAIL |
 | gherkinScenarios | 1 array entry | `Array.isArray(specification.gherkinScenarios) && specification.gherkinScenarios.length >= 1` | PASS/FAIL |
 | gherkinFormat | Array not object (BLOCKING) | `Array.isArray(specification.gherkinScenarios)` (NOT a single object) | PASS/FAIL |
@@ -97,9 +97,74 @@ IF failures.length > 0:
 - Entity names PascalCase
 - Field names camelCase
 - Entity attribute format: `attributes[]` with {name, description}, NOT `fields[]` with {name, type} — entities must NOT have tableName or primaryKey
-- Wireframe structure: `screen` (not `name`), `componentMapping` is array of {wireframeElement, reactComponent} (not plain key-value object), `layout` is object with regions (not string)
+- Wireframe structure: `screen` (not `name`/`title`), `mockup` (not `ascii`/`content`), `componentMapping` is array of {wireframeElement, reactComponent} (not plain key-value object), `layout` is object with regions (not string)
+- Wireframe field naming: uses `screen` (not `title`), `mockup` (not `ascii`) — auto-fix if wrong (see 9c-fix below)
 - Permission paths dot-separated lowercase
 
+#### 9c-fix. Auto-Fix Wireframe Field Names (MANDATORY before writing)
+
+> **CRITICAL:** The agent may use non-canonical field names (`title`, `ascii`, `name`, `content`).
+> These MUST be normalized to canonical names before writing to feature.json.
+
+```javascript
+// AUTO-FIX: Normalize wireframe field names before writing
+const wireframes = specification.uiWireframes || specification.wireframes || [];
+for (const wf of wireframes) {
+  if (wf.title && !wf.screen) { wf.screen = wf.title; delete wf.title; }
+  if (wf.ascii && !wf.mockup) { wf.mockup = wf.ascii; delete wf.ascii; }
+  if (wf.content && !wf.mockup) { wf.mockup = wf.content; delete wf.content; }
+  if (wf.name && !wf.screen) { wf.screen = wf.name; delete wf.name; }
+}
+// Store normalized wireframes back under canonical key
+specification.uiWireframes = wireframes;
+```
+
+#### 9c-fix-entities. Auto-Fix Entity Attribute Types (MANDATORY before writing)
+
+> **DEFENSE-IN-DEPTH:** step-03c POST-CHECK should catch attributes without `type`,
+> but if any slip through to step-03d, auto-fix them here before writing to feature.json.
+> Uses the same type inference algorithm as step-03c POST-CHECK.
+
+```javascript
+// AUTO-FIX: Ensure all entity attributes have structured type
+const entities = analysis.entities || [];
+let entityAutoFixCount = 0;
+for (const entity of entities) {
+  for (const attr of entity.attributes || []) {
+    if (!attr.type) {
+      // Infer type from attribute name pattern
+      if (attr.validation?.match(/max\s*\d+/i) || attr.name.match(/name|title|code|description|label|email|phone|address/i)) {
+        attr.type = "string";
+        const maxMatch = attr.validation?.match(/max\s*(\d+)/i);
+        if (maxMatch) attr.maxLength = parseInt(maxMatch[1]);
+      } else if (attr.name.match(/id$/i)) {
+        attr.type = "Guid";
+      } else if (attr.name.match(/date|At$/i)) {
+        attr.type = "DateTime";
+      } else if (attr.name.match(/is[A-Z]|has[A-Z]|active|enabled/)) {
+        attr.type = "bool";
+      } else if (attr.name.match(/amount|salary|rate|price|total/i)) {
+        attr.type = "decimal";
+      } else if (attr.name.match(/count|number|order|sort|index/i)) {
+        attr.type = "int";
+      } else {
+        attr.type = "string"; // safe default
+      }
+      // Normalize free-text maxLength
+      if (typeof attr.validation === 'string' && !attr.maxLength) {
+        const m = attr.validation.match(/max\s*(\d+)/i);
+        if (m) attr.maxLength = parseInt(m[1]);
+      }
+      if (attr.required === undefined) attr.required = true;
+      entityAutoFixCount++;
+    }
+  }
+}
+if (entityAutoFixCount > 0) {
+  console.warn(`DEFENSE-IN-DEPTH: auto-fixed ${entityAutoFixCount} attributes without type in step-03d`);
+}
+```
+
 #### 9d. Decision
 
 IF validation PASS:
@@ -165,10 +230,10 @@ ba-writer.enrichSection({
 
 **Execute the comprehensive validation checklist:**
 
-Run the 27-check validation process across 10 categories:
+Run the 29-check validation process across 10 categories:
 - Data Model (4 checks) | Business Rules (3 checks) | Use Cases & FRs (4 checks)
 - Permissions (3 checks) | UI & Navigation (4 checks) | I18N & Messages (3 checks)
-- Seed Data (2 checks) | API Endpoints (2 checks) | Validations (1 check) | Gherkin (1 check)
+- Seed Data (2 checks) | API Endpoints (2 checks) | Validations (1 check) | Gherkin (3 checks)
 
 ```javascript
 const blockingFailures = checks.filter(c => c.blocking && c.status === "FAIL");
@@ -243,18 +308,13 @@ Display comprehensive summary:
 
 → Validation: {PASS/FAIL}
 ═══════════════════════════════════════════════════════════
-```
 
-Ask via AskUserQuestion:
+{IF validation PASS}:
+  → Module validé automatiquement
+  → Passage automatique au module suivant (section 12)
 
-```
-question: "Le module {currentModule} est-il correctement spécifié ?"
-header: "Module"
-options:
-  - label: "Validé"
-    description: "Passer au module suivant"
-  - label: "Réviser"
-    description: "Modifier des éléments du module"
+{IF validation FAIL}:
+  → Afficher les erreurs et offrir les options de correction (section 9d)
 ```
 
 ---
@@ -319,7 +379,7 @@ const written = ba-reader.read({module_feature_id});
 const checks = [
   { key: "specification.actors",          actual: written.specification?.actors?.length,          min: 2 },
   { key: "specification.useCases",        actual: written.specification?.useCases?.length,        min: 2 },
-  { key: "specification.wireframes",      actual: written.specification?.wireframes?.length,      min: 1 },
+  { key: "specification.wireframes",      actual: (written.specification?.uiWireframes?.length || written.specification?.wireframes?.length || 0), min: 1 },
   { key: "specification.sections",        actual: written.specification?.sections?.length,        min: 1 },
   { key: "specification.seedDataCore",    actual: Object.keys(written.specification?.seedDataCore || {}).length, min: 7 },
   { key: "specification.lifeCycles",      actual: written.specification?.lifeCycles?.length,      min: 0 },
@@ -334,16 +394,78 @@ IF failures.length > 0:
   → Re-execute section 11 write with ALL specification data
   → DO NOT proceed to next module until ALL checks pass
 
-// SPECIAL CHECK: wireframes content verification
-IF written.specification?.wireframes?.length > 0:
-  const emptyMockups = written.specification.wireframes.filter(wf => !wf.mockup && !wf.content);
+// SPECIAL CHECK: wireframes content verification (check BOTH key names)
+const wireframes = written.specification?.uiWireframes || written.specification?.wireframes || [];
+IF wireframes.length > 0:
+  const emptyMockups = wireframes.filter(wf => !wf.mockup && !wf.ascii && !wf.content);
   IF emptyMockups.length > 0:
     WARNING: "{emptyMockups.length} wireframes have empty mockup content — verify step-03b data"
+
+// SPECIAL CHECK: wireframes >= sections
+const sectionCount = written.specification?.sections?.length || 0;
+IF wireframes.length < sectionCount:
+  BLOCKING ERROR: "{wireframes.length} wireframes < {sectionCount} sections — wireframes MISSING for some sections"
+  → Re-read wireframes from conversation context and re-write to feature.json
 ```
 
-> **WHY:** Step-03b generates wireframes in memory, step-03c only writes seedDataCore explicitly.
-> If the comprehensive write in section 11 is skipped or partial, wireframes/sections are LOST.
-> This POST-CHECK catches the data loss BEFORE advancing to the next module.
+#### 11-POST-CHECK-BASH: Acceptance Criteria Verification (BLOCKING)
+
+> **CRITICAL:** The pseudocode checks above are interpreted by the model — they can be "passed" incorrectly.
+> This bash check reads the REAL file on disk and provides an objective verification.
+> See [references/acceptance-criteria.md](../references/acceptance-criteria.md) for the full acceptance criteria definition.
+
+```bash
+MODULE_JSON="{module_feature_json_path}"
+node -e "
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync(process.argv[1], 'utf-8'));
+const spec = data.specification || {};
+const analysis = data.analysis || {};
+const wf = spec.uiWireframes || spec.wireframes || [];
+const sections = spec.sections || [];
+const checks = [
+  ['entities >= 1',          (analysis.entities||[]).length,          1],
+  ['useCases >= 2',          (spec.useCases||[]).length,              2],
+  ['FRs >= 4',               (spec.functionalRequirements||[]).length,4],
+  ['wireframes >= 1',        wf.length,                               1],
+  ['wireframes >= sections', wf.length,                               sections.length],
+  ['sections >= 1',          sections.length,                          1],
+  ['seedDataCore 7 arrays',  Object.keys(spec.seedDataCore||{}).filter(k=>(spec.seedDataCore||{})[k]&&(spec.seedDataCore||{})[k].length>0).length, 7],
+  ['gherkin is array',       Array.isArray(spec.gherkinScenarios)?1:0, 1],
+  ['apiEndpoints >= 1',      (spec.apiEndpoints||[]).length,           1],
+  ['messages >= 4',          (spec.messages||[]).length,               4],
+  ['validations >= 1',       (spec.validations||[]).length,            1]
+];
+const fails = checks.filter(c => c[1] < c[2]);
+fails.forEach(f => console.error('FAIL: ' + f[0] + ' = ' + f[1] + ' (min: ' + f[2] + ')'));
+// Check wireframe content
+const emptyWf = wf.filter(w => !w.mockup && !w.ascii && !w.content);
+if (emptyWf.length > 0) { fails.push(['wireframe content', 0, 1]); console.error('FAIL: ' + emptyWf.length + ' wireframes have EMPTY content'); }
+// Check entity attribute types
+const badAttrs = (analysis.entities||[]).flatMap(e => (e.attributes||[]).filter(a => !a.type).map(a => e.name+'.'+a.name));
+if (badAttrs.length > 0) { fails.push(['attr.type', 0, 1]); console.error('FAIL: attributes without type: ' + badAttrs.join(', ')); }
+// AC-15: Validation rules format
+const badRules = (spec.validations||[]).filter(v => v.rules && !Array.isArray(v.rules));
+if (badRules.length > 0) { fails.push(['AC-15: rules not array', badRules.length, 0]); console.error('FAIL: AC-15: ' + badRules.length + ' validations have rules as string'); }
+// AC-16: Messages must have message field
+const noMsg = (spec.messages||[]).filter(m => !m.message);
+if (noMsg.length > 0) { fails.push(['AC-16: message missing', noMsg.length, 0]); console.error('FAIL: AC-16: ' + noMsg.length + ' messages missing message field'); }
+// AC-17: Gherkin content structure
+if (Array.isArray(spec.gherkinScenarios)) { const badG = spec.gherkinScenarios.filter(g => !g.feature || !Array.isArray(g.scenarios)); if (badG.length > 0) { fails.push(['AC-17: gherkin content', badG.length, 0]); console.error('FAIL: AC-17: ' + badG.length + ' gherkin entries invalid'); } }
+if (fails.length > 0) { console.error('BLOCKING: ' + fails.length + ' acceptance criteria failed'); process.exit(1); }
+console.log('PASS: All acceptance criteria met');
+" "$MODULE_JSON"
+```
+
+IF this check FAILS:
+- Identify which criteria failed from the output
+- Fix the corresponding data (re-read from conversation context, re-generate, or re-run the step that produces it)
+- Re-write to feature.json
+- Re-run the POST-CHECK until PASS
+
+> **WHY:** Step-03b now writes wireframes intermediately (since fix), but step-03d section 11 does the FULL write.
+> This bash POST-CHECK is the ultimate safety net — it reads the REAL file and verifies ALL acceptance criteria.
+> The pseudocode checks (section 9a) catch issues early; this bash check catches anything the model missed.
 
 ---
 

package/templates/skills/business-analyse/steps/step-05a-handoff.md

@@ -200,6 +200,55 @@ See [references/handoff-file-templates.md](../references/handoff-file-templates.
 | **4.6 SeedData** | `specification.seedDataCore` | 5 CORE + business + IClientSeedDataProvider |
 | **4.7 Tests** | All layers | Unit, Integration, Security tests |
 
+#### Route Convention (CRITICAL)
+
+> **MANDATORY:** All NavigationModule/Section routes MUST use kebab-case transformation.
+> See [references/naming-conventions.md](../references/naming-conventions.md) for complete guide.
+
+**Problem:**
+- Module codes in feature.json are **PascalCase** (e.g., `"HumanResources"`)
+- Routes in seed data MUST be **kebab-case** (e.g., `"/business/human-resources"`)
+- Failing to transform causes 404 when clicking menu items
+
+**Solution:**
+
+When generating `seedDataCore` for handoff, transform PascalCase codes to kebab-case routes:
+
+```javascript
+// Transform module codes to kebab-case routes
+function toKebabCase(code) {
+  return code
+    .replace(/([a-z])([A-Z])/g, '$1-$2')
+    .toLowerCase();
+}
+
+// Example usage in seedDataCore generation
+const moduleCode = "TimeManagement";     // PascalCase (C#)
+const appCode = "HumanResources";       // PascalCase (C#)
+const contextCode = "business";         // lowercase
+
+const route = `/${contextCode}/${toKebabCase(appCode)}/${toKebabCase(moduleCode)}`;
+// Result: "/business/human-resources/time-management"
+```
+
+**Include in task instructions:**
+
+For NavigationSeedData tasks in `handoff.filesToCreate`, add:
+
+```json
+{
+  "path": "Infrastructure/Persistence/Seeding/Data/{Module}/NavigationSeedData.cs",
+  "type": "SeedData",
+  "category": "core",
+  "instructions": "Generate NavigationModule seed data. CRITICAL: Use ToKebabCase() helper for Route property. Example: Route = ToKebabCase($\"/{context}/{app}/{module}\"). See core-seed-data.md template."
+}
+```
+
+**Validation:**
+- ralph-loop POST-CHECK validates routes after generation (see step-02-execute.md)
+- MCP `validate_frontend_routes` detects case mismatches
+- Convention documented in naming-conventions.md
+
 **Critical rules:**
 - All backend paths include `{ContextPascal}/{ApplicationName}/` hierarchy
 - Frontend pages MUST have `linkedWireframes[]` + `wireframeAcceptanceCriteria`
@@ -249,7 +298,7 @@ Additional per-section pages (dashboard, import, etc.) are separate entries.
 
 **Route wiring task (MANDATORY — separate entry):**
 ```json
-{ "path": "src/App.tsx", "type": "RouteWiring", "module": "{moduleCode}", "description": "Wire {module} routes into App.tsx Layout wrappers (standard + tenant-prefixed blocks). BLOCKING: pages without route wiring = blank pages." }
+{ "path": "src/App.tsx", "type": "RouteWiring", "module": "{moduleCode}", "description": "Wire {module} routes into App.tsx (detect pattern: contextRoutes array OR JSX Route wrappers). BLOCKING: pages without route wiring = blank pages." }
 ```
 
 ### 6c. Cross-Module PRD (MANDATORY for multi-module features)
@@ -359,7 +408,43 @@ Add to progress.txt after all module tasks.
 ```
 // Derive seedDataCore from modules[], applicationRoles[], and coverageMatrix[]
 
+// Helper: PascalCase → "Human Readable" (e.g., "HumanResources" → "Human Resources")
+function toHumanReadable(pascalCase) {
+  return pascalCase
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
+}
+
+const contextCode = master.metadata.context || "business";
+const appCode = master.metadata.application;
+const appLabel = toHumanReadable(appCode);
+const appDesc = master.cadrage?.problem?.split('.')[0] || `Gestion ${appLabel}`;
+const lang = master.metadata.language || "fr";
+
 const seedDataCore = {
+  // Application-level navigation (MANDATORY — one entry per application)
+  navigationApplications: [{
+    code: appCode.toLowerCase(),
+    name: appCode,
+    labels: {
+      fr: lang === "fr" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+      en: lang === "en" ? (master.cadrage?.applicationName || appLabel) : appLabel,
+      it: appLabel,
+      de: appLabel
+    },
+    description: {
+      fr: lang === "fr" ? appDesc : `Gestion ${appLabel}`,
+      en: lang === "en" ? appDesc : `${appLabel} management`,
+      it: `Gestione ${appLabel}`,
+      de: `${appLabel} Verwaltung`
+    },
+    icon: inferIconFromApplication(master) || "layout-grid",
+    iconType: "lucide",
+    context: contextCode,
+    route: `/${contextCode}/${toKebabCase(appCode)}`,
+    displayOrder: 1
+  }],
+
   navigationModules: master.modules.map((m, i) => ({
     code: m.code,
     label: m.name || m.code,
@@ -433,6 +518,27 @@ const seedDataCore = {
   )
 };
 
+// Icon inference for APPLICATION level (NEVER leave as null)
+function inferIconFromApplication(master) {
+  const appLC = (master.metadata.application || '').toLowerCase();
+  const iconMap = {
+    'humanresource': 'users', 'rh': 'users', 'hr': 'users', 'personnel': 'users',
+    'sales': 'shopping-cart', 'vente': 'shopping-cart', 'commerce': 'shopping-cart',
+    'finance': 'wallet', 'comptabilite': 'calculator', 'accounting': 'calculator',
+    'inventory': 'warehouse', 'stock': 'package', 'logistic': 'truck',
+    'crm': 'building-2', 'customer': 'building', 'client': 'building-2',
+    'project': 'folder-kanban', 'task': 'check-square', 'gestion': 'layout-grid',
+    'admin': 'shield', 'support': 'headphones', 'maintenance': 'wrench',
+    'production': 'factory', 'quality': 'badge-check', 'document': 'file-text',
+    'fleet': 'car', 'vehicle': 'car', 'transport': 'truck',
+    'education': 'graduation-cap', 'formation': 'graduation-cap', 'training': 'graduation-cap'
+  };
+  for (const [keyword, icon] of Object.entries(iconMap)) {
+    if (appLC.includes(keyword)) return icon;
+  }
+  return "layout-grid";  // fallback — NEVER null
+}
+
 // Icon inference from module context (NEVER leave as null)
 function inferIconFromModule(module) {
   const codeLC = module.code.toLowerCase();
@@ -462,8 +568,14 @@ ba-writer.enrichSection({
 })
 ```
 
-**POST-CHECK (BLOCKING for icons, warning for counts):**
+**POST-CHECK (BLOCKING for icons/application, warning for counts):**
 ```
+IF !seedDataCore.navigationApplications || seedDataCore.navigationApplications.length === 0:
+  BLOCKING ERROR: "navigationApplications is empty — Application navigation will NOT be seeded. Menu will show Context → (nothing) → Modules."
+IF seedDataCore.navigationApplications[0].icon === null || seedDataCore.navigationApplications[0].icon === undefined:
+  BLOCKING ERROR: "Application icon is null — ralph-loop will render empty navigation"
+IF !seedDataCore.navigationApplications[0].labels?.fr || !seedDataCore.navigationApplications[0].labels?.en:
+  BLOCKING ERROR: "Application labels missing fr/en — translations will fail"
 IF seedDataCore.navigationModules.length !== master.modules.length:
   WARNING: seedDataCore has ${seedDataCore.navigationModules.length} nav modules but ${master.modules.length} modules exist
 IF seedDataCore.permissions.length === 0:

package/templates/skills/business-analyse/steps/step-05b-deploy.md

@@ -238,6 +238,34 @@ See [references/deploy-data-build.md](../references/deploy-data-build.md) for:
 
 ---
 
+### 7-bis. Generate SVG Wireframes (Parallel Enrichment)
+
+> **After EMBEDDED_ARTIFACTS is built (sections 5-7) but BEFORE writing the HTML (section 8).**
+> This step enriches each ASCII wireframe with a professional SVG version for dual-view rendering.
+
+See [references/wireframe-svg-style-guide.md](../references/wireframe-svg-style-guide.md) for the complete SVG style specification, prompt template, and orchestration process.
+
+**Process summary:**
+
+1. **Read** `references/wireframe-svg-style-guide.md` to get the prompt template
+2. **Collect** all wireframes across ALL modules in `EMBEDDED_ARTIFACTS.wireframes` where `content` exists and `svgContent` is null
+3. **Spawn parallel Task(sonnet) agents** — ONE per wireframe, ALL in a single message
+4. **Collect and validate** results: strip markdown fences if present, verify SVG starts with `<svg` and contains `</svg>`
+5. **Inject** valid SVGs into `EMBEDDED_ARTIFACTS.wireframes[moduleCode][index].svgContent`
+6. **Display summary:**
+   ```
+   SVG wireframe generation:
+     Total wireframes: {total}
+     SVG generated: {successCount}/{total}
+     Fallback (ASCII only): {failCount}/{total}
+   ```
+
+> **CRITICAL:** This step is NEVER blocking. If all SVG generations fail, deployment
+> continues with ASCII-only wireframes. The HTML renderer checks for `svgContent` before
+> showing the SVG view. SVG is an enhancement, not a requirement.
+
+---
+
 ### 8. Write and Verify
 
 1. Write the populated HTML to the output directory: `docs/business/{app}/business-analyse/v{version}/ba-interactive.html`

package/templates/skills/ralph-loop/references/category-rules.md

@@ -304,7 +304,9 @@ fi
 **Execution sequence (IN ORDER):**
 1. `mcp__smartstack__scaffold_api_client` → API client + types + React Query hook
 2. `mcp__smartstack__scaffold_routes` (with `outputFormat: "clientRoutes"`) → route registry + route fragments
-3. **Wire routes to App.tsx** → insert `<Route>` entries inside correct Layout wrapper (BOTH standard AND tenant-prefixed `/t/:slug/...` blocks)
+3. **Wire routes to App.tsx (detect pattern: `contextRoutes` array OR JSX `<Route>`):**
+   - **Pattern A** (`contextRoutes: ContextRouteExtensions` in App.tsx): add to `contextRoutes.{context}[]` with RELATIVE paths → auto-injected into both standard + tenant trees
+   - **Pattern B** (JSX `<Route>` in App.tsx): insert `<Route>` entries inside correct Layout wrapper (BOTH standard AND tenant-prefixed `/t/:slug/...` blocks)
 4. Create pages using SmartStack components
 5. Create preferences hook: `use{Module}Preferences.ts`
 6. Generate i18n (4 languages: fr, en, it, de)
@@ -348,7 +350,8 @@ import axios from 'axios'                    → use @/services/api/apiClient
 Only fr/en translations                      → MUST have 4 languages
 src/pages/{Module}/                          → MUST be src/pages/{Context}/{App}/{Module}/
 Routes generated but NOT added to App.tsx    → MUST wire routes to App.tsx after scaffold_routes
-Routes in standard block only               → MUST also add to /t/:slug/ tenant block
+Routes in standard block only               → MUST also add to /t/:slug/ tenant block (Pattern B only; Pattern A auto-handles)
+Adding routes to clientRoutes[] instead of contextRoutes.{context}[] → MUST use contextRoutes for business/platform/personal routes
 '00000000-0000-0000-0000-000000000000'       → use dynamic ID from auth context or route params
 const api = axios.create(...)                → use @/services/api/apiClient (single instance)
 useXxx with raw axios inside hooks           → hooks MUST use the shared apiClient from @/services/api

package/templates/skills/ralph-loop/references/compact-loop.md

@@ -110,7 +110,7 @@ Batch: {batch.length} [{firstCategory}] → {batch.map(t => `[${t.id}] ${t.descr
 |----------|--------|
 | `infrastructure` with `_migrationMeta` | Migration sequence: `suggest_migration` MCP → `dotnet ef migrations add` → `dotnet ef database update` → `dotnet build` |
 | `infrastructure` with seed data keywords | **MANDATORY:** Read `references/core-seed-data.md` → implement templates → `dotnet build` |
-| `frontend` | MCP-first: `scaffold_api_client` → `scaffold_routes` (outputFormat: clientRoutes) → **wire to App.tsx (standard + tenant blocks)** → create pages → `npm run typecheck && npm run lint` |
+| `frontend` | MCP-first: `scaffold_api_client` → `scaffold_routes` (outputFormat: clientRoutes) → **wire to App.tsx (detect pattern: `contextRoutes` array OR JSX `<Route>`)** → create pages → `npm run typecheck && npm run lint` |
 | `test` | **Create tests:** `scaffold_tests` MCP → **Run:** `dotnet test --verbosity normal` → **Fix loop:** if fail → fix SOURCE CODE → rebuild → retest → repeat until 100% pass |
 | `validation` | `dotnet clean && dotnet restore && dotnet build` → `dotnet test` (full) → `validate_conventions` MCP |
 
@@ -203,6 +203,57 @@ Batch: {batch.length} [{firstCategory}] → {batch.map(t => `[${t.id}] ${t.descr
    ```
    If FAIL → migration is broken → fix → rebuild → DO NOT commit
 
+5bis. **Core Seed Data Integrity (BLOCKING — if seed data tasks in batch):**
+   ```bash
+   # Verify NavigationApplicationSeedData.cs exists
+   APP_SEED=$(find . -path "*/Seeding/Data/NavigationApplicationSeedData.cs" 2>/dev/null | head -1)
+   if [ -z "$APP_SEED" ]; then
+     echo "❌ BLOCKING: NavigationApplicationSeedData.cs NOT FOUND"
+     echo "Without this: nav_Applications empty → menu invisible → modules inaccessible"
+     echo "Fix: Generate from core-seed-data.md section 1b"
+     # Create fix task
+   fi
+
+   # Verify no hardcoded placeholders in provider
+   PROVIDER=$(find . -path "*/Seeding/*SeedDataProvider.cs" 2>/dev/null | head -1)
+   if [ -n "$PROVIDER" ]; then
+     if grep -qE '\{appLabel_|\{appDesc_|\{appIcon\}|\{ApplicationGuid\}' "$PROVIDER" 2>/dev/null; then
+       echo "❌ BLOCKING: SeedDataProvider has unresolved placeholders"
+       echo "Fix: Use NavigationApplicationSeedData.GetApplicationEntry()"
+     fi
+   fi
+
+   # Verify ApplicationRolesSeedData references real GUID
+   ROLES_SEED=$(find . -path "*/Seeding/Data/ApplicationRolesSeedData.cs" 2>/dev/null | head -1)
+   if [ -n "$ROLES_SEED" ]; then
+     if grep -q '{ApplicationGuid}' "$ROLES_SEED" 2>/dev/null; then
+       echo "❌ BLOCKING: ApplicationRolesSeedData still has {ApplicationGuid} placeholder"
+       echo "Fix: Replace with NavigationApplicationSeedData.ApplicationId"
+     fi
+   fi
+
+   # Quick startup test to verify seed data runs without exceptions
+   API_PROJECT=$(ls src/*Api*/*.csproj 2>/dev/null | head -1)
+   if [ -n "$API_PROJECT" ] && [ -n "$APP_SEED" ]; then
+     echo "Running seed data startup test..."
+     dotnet run --project "$API_PROJECT" --urls "http://localhost:0" -- --environment Development > /tmp/ralph-seed-check.log 2>&1 &
+     SEED_PID=$!
+     sleep 10
+     if ! kill -0 $SEED_PID 2>/dev/null; then
+       SEED_LOG=$(cat /tmp/ralph-seed-check.log 2>/dev/null | tail -20)
+       echo "❌ BLOCKING: Application crashed during startup — seed data likely failed"
+       echo "Last 20 lines: $SEED_LOG"
+       # Do NOT continue to frontend/test — fix seed data first
+     else
+       echo "✓ Seed data startup test passed"
+       kill $SEED_PID 2>/dev/null
+       wait $SEED_PID 2>/dev/null
+     fi
+     rm -f /tmp/ralph-seed-check.log
+   fi
+   ```
+   If FAIL → fix seed data → rebuild → DO NOT continue to frontend/test tasks
+
 **Error resolution cycle:**
 1. Read the FULL error output (not just first line)
 2. Identify root cause: file path + line number