@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/business-analyse-develop/SKILL.md

@@ -1,250 +0,0 @@
----
-name: business-analyse-develop
-description: Autonomous development from PRD — implements the full application with MCP validation, quality gates, and completion guarantees.
-argument-hint: "[-m N] [-c TEXT] [-v] <task description>"
----
-
-<objective>
-Execute the Ralph Weegund technique — module orchestration with autonomous code generation. Ralph reads PRDs from `/business-analyse-handoff`, resolves dependencies, and delegates all code generation to `/apex -d`.
-
-**Key principle:** Ralph ORCHESTRATES (module sequencing, quality gates, reporting). All code generation is delegated to `/apex`.
-</objective>
-
-<quick_start>
-
-**From Business Analysis (RECOMMENDED):**
-```bash
-/business-analyse MyFeature
-# Then: /business-analyse-handoff
-# Then: /business-analyse-develop -r
-```
-
-**Manual start:**
-```bash
-/business-analyse-develop implement user authentication
-/business-analyse-develop -c "COMPLETE" -m 20 refactor cache layer
-/business-analyse-develop -r  # Resume previous
-```
-
-**Flags:** `-m N` (max iterations), `-c TEXT` (completion promise), `-v` (verbose), `-r` (resume), `-p` (parallel)
-
-</quick_start>
-
-<parameters>
-| Short | Long | Description |
-|-------|------|-------------|
-| `-m N` | `--max-iterations N` | Max iterations (default: 50, v4: adaptive) |
-| `-c TEXT` | `--completion-promise TEXT` | Completion signal text |
-| `-v` | `--verbose` | Detailed logging |
-| `-r` | `--resume` | Resume from previous state |
-| `-p` | `--parallel` | Teams mode: Phase 0 sequential, then parallel per module |
-</parameters>
-
-<prd_format_detection>
-
-## PRD Format Detection
-
-Ralph supports two PRD formats:
-
-| | PRD v3 (task-oriented) | PRD v4 (spec-oriented) |
-|---|---|---|
-| **Detection** | `$version === '3.0.0'` + `tasks[]` present | `$version === '4.0.0'` + `objectives[]` present |
-| **Execution model** | Batch iterations (compact-loop) | Continuous session (compaction manages context) |
-| **Context management** | Manual: "Read Once" rule, max 5 tasks/batch | Automatic: server-side compaction |
-| **Progress tracking** | progress.txt as state machine | Optional checkpoints |
-| **Splitting** | By token budget (>4 entities) | By logical feature (by section) |
-| **Steps** | 6 steps + compact-loop.md | 3 steps: init → execute → verify |
-
-**Backward compatibility:** v3 PRDs execute with the EXACT same behavior as before. v4 is opt-in via `/business-analyse-handoff --v4`.
-
-</prd_format_detection>
-
-<workflow>
-
-## v4 Workflow (spec-oriented — RECOMMENDED)
-
-**Single module:**
-1. **Init** (step-00): parse flags, verify MCP, load PRD v4, detect modules
-2. **Execute** (step-01-v4): delegate entire module to `/apex -d` as one continuous session
-   - `/apex` reads the spec (architecture, objectives, acceptance criteria)
-   - `/apex` decides execution order (domain → infra → app → api → seed → frontend → tests)
-   - Ralph intercepts at natural checkpoints for quality gates
-   - Server-side compaction manages context automatically
-3. **Verify + Report** (step-02-v4): run ALL quality gates, generate report
-
-**Multi-module:**
-1. Init: detect prd-*.json files, build topological order
-2. For each module in order → Execute (continuous session per module)
-3. Cross-module verify + final report
-
-**Quality gates (same as v3):**
-- `dotnet build` (BLOCKING)
-- `dotnet test` (BLOCKING after build)
-- `npm test` / `npm run typecheck` (BLOCKING for frontend)
-- MCP `validate_security` + `validate_conventions`
-- BR coverage check (each BR has implementation)
-- File reconciliation (expectedFiles vs disk)
-- Stub test detection (reject empty tests)
-
-## v3 Workflow (task-oriented — LEGACY)
-
-**Single module:**
-1. Init: parse flags, verify MCP, setup .ralph/ (step-00)
-2. Load tasks from prd.json — unified v3 has pre-computed tasks (step-01, step FILE read once)
-3. Execute first task (step-02, step FILE read once)
-4. Commit + update progress (step-03, step FILE read once)
-5. Check completion → enter COMPACT LOOP (step-04)
-6. **COMPACT LOOP** (step-04 → references/compact-loop.md):
-   - Find eligible → batch by category (max 5) → execute → test → commit → loop
-7. Report (step-05)
-
-**Multi-module with `-p` (parallel mode):**
-1. Init: detect prd-*.json, parse `-p` flag (step-00)
-2. **Phase 0 (Ralph sequential):** ALL entities from ALL modules via `/apex --foundation`
-3. **Phase 1-N (Teams parallel):** Spawn teammates per module
-4. Report with per-module aggregation (step-05)
-
-**Multi-module WITHOUT `-p` (sequential — legacy):**
-1. Init: detect prd-*.json, read dependency layers (step-00)
-2. Compact loop per module in topological order
-3. Report with per-module aggregation (step-05)
-
-</workflow>
-
-<state_variables>
-| Variable | Type | v3 | v4 | Description |
-|----------|------|----|----|-------------|
-| `{max_iterations}` | number | Yes | Adaptive | Max iterations |
-| `{current_iteration}` | number | Yes | No | Current iteration counter |
-| `{current_module}` | string | Yes | Yes | Current module being processed |
-| `{modules_queue}` | object | Yes | Yes | Module queue (multi-module) |
-| `{prd_version}` | '3.0.0' \| '4.0.0' | Yes | Yes | Detected PRD format |
-| `{section_split_mode}` | boolean | Yes | No | v3 only: section splitting active |
-| `{parallel_mode}` | boolean | Yes | Yes | Teams mode via `-p` |
-</state_variables>
-
-<mcp_requirements>
-**MANDATORY before any work:**
-1. `mcp__smartstack__validate_conventions` — verify connectivity
-2. `mcp__context7__resolve-library-id` — verify connectivity
-
-**During work:** All MCP tool calls are handled by `/apex` during delegation.
-</mcp_requirements>
-
-<execution_guarantee>
-
-## EXECUTION GUARANTEE — READ THIS FIRST
-
-**Ralph-loop executes ALL work from start to finish. No exceptions.**
-
-When the user invokes `/business-analyse-develop`, they are giving you the instruction to:
-1. Initialize (step-00)
-2. Execute ALL modules autonomously
-3. Run quality gates
-4. Generate the final report
-
-**You MUST NOT:**
-- Stop to "ask for confirmation"
-- Set `max_iterations = 1` or any reduced value
-- Ask the user to choose between supervised/autonomous mode
-- Wait for user input between modules
-- Delegate the loop to sub-agents (except team mode and /apex delegation)
-- Display a progress report then ask "shall I continue?" or present options (1/2/3)
-- Pause because the scope is "large" or "ambitious" — execute ALL of it regardless of size
-
-**The ONLY valid stop conditions are:**
-- ALL objectives met / ALL tasks completed (→ report)
-- `max_iterations` reached (v3 only)
-- Dead-end (all remaining blocked/failed after retries)
-- User Ctrl+C
-
-**If you stop for any other reason, you have VIOLATED this guarantee.**
-
-</execution_guarantee>
-
-<entry_point>
-**FIRST ACTION:** Load `steps/step-00-init.md` — then execute ALL steps through to completion without stopping.
-</entry_point>
-
-<step_files>
-
-### v4 Steps (spec-oriented)
-| Step | File | Purpose |
-|------|------|---------|
-| 00 | `steps/step-00-init.md` | Parse args, verify MCP, detect format, init state |
-| 01-v4 | `steps/step-01-v4-execute.md` | Continuous execution: delegate to /apex, run gates |
-| 02-v4 | `steps/step-02-v4-verify.md` | Final gates, file reconciliation, BR coverage, report |
-
-### v3 Steps (task-oriented — legacy)
-| Step | File | Purpose |
-|------|------|---------|
-| 00 | `steps/step-00-init.md` | Parse args, verify MCP, init state |
-| 01 | `steps/step-01-task.md` | Load/create tasks from prd.json |
-| 02 | `steps/step-02-execute.md` | Delegate module to /apex -d |
-| 03 | `steps/step-03-commit.md` | Commit, update prd.json/progress.txt |
-| 04 | `steps/step-04-check.md` | Check completion, compact loop entry |
-| 05 | `steps/step-05-report.md` | Generate final report |
-
-**v3 "Read Once" rule:** Step files read once, compact-loop.md drives iterations 2+.
-**v4:** No "Read Once" rule needed — compaction manages context automatically.
-
-**Reference files (loaded conditionally):**
-| File | Loaded when |
-|------|-------------|
-| `references/compact-loop.md` | v3 only: Step-04 section 5 |
-| `references/section-splitting.md` | v3 only: >4 entities + >1 section |
-| `references/category-completeness.md` | v3: step-01/step-04; v4: step-02-v4 |
-| `references/init-resume-recovery.md` | Both: Step-00 section 4 (resume mode) |
-| `references/multi-module-queue.md` | Both: multi-module initialization |
-| `references/quality-gates.md` | v4: step-01-v4 and step-02-v4 |
-</step_files>
-
-<file_structure>
-```
-.ralph/
-├── prd.json              # v3: unified task list OR v4: spec document
-├── prd-{module}.json     # Per-module PRDs (from business-analyse-handoff)
-├── progress.txt          # v3: state machine; v4: optional checkpoints
-├── modules-queue.json    # Multi-module tracking
-├── logs/
-└── reports/
-    └── {feature}.md
-```
-</file_structure>
-
-<execution_rules>
-
-### NON-NEGOTIABLE — Autonomous Full Execution
-- **EXECUTE ALL WORK** — from first module to last, no user interaction
-- **NEVER ask the user** — no mode selection, no "shall I continue?"
-- **NEVER stop prematurely** — only valid stops listed in execution_guarantee
-- **VERIFY MCP FIRST** — never skip
-
-### Quality Gates (both v3 and v4)
-- **BUILD GATE** — `dotnet build` must pass (BLOCKING)
-- **BACKEND TEST GATE** — `dotnet test` must pass (BLOCKING)
-- **FRONTEND TEST GATE** — `npm test` / `npm run typecheck` (BLOCKING)
-- **STUB TEST DETECTION** — reject `Assert.True(true)` or empty test methods
-- **MCP SECURITY** — validate_security + validate_conventions
-- **BR COVERAGE** — every business rule has implementation + test
-- **FILE RECONCILIATION** — expectedFiles vs actual files on disk
-- **MIGRATION** — after EF configs, before tests
-
-### Error Recovery
-- **v3:** Failed tasks retry up to 3 times, context NOT enriched
-- **v4:** Failures handled in same session — Claude has full error context via compaction, retries naturally with different approach
-
-</execution_rules>
-
-<success_criteria>
-- All objectives met (v4) / all tasks completed (v3)
-- MCP validations pass (validate_security + validate_conventions)
-- All quality gates pass (build, test, BR coverage, file reconciliation)
-- Git commits atomic with commit_hash tracked
-- Tests pass (dotnet test + npm test)
-- Migrations created and applied
-- Seed data complete (navigation, permissions, roles via MCP)
-- Frontend in correct hierarchy (Context/App/Module)
-- Report generated in .ralph/reports/
-- Multi-module: all modules processed, cross-module report
-</success_criteria>

package/templates/skills/business-analyse-develop/references/category-completeness.md

@@ -1,326 +0,0 @@
-# Category Completeness Check
-
-> **Reference for:** step-01-task.md section 4b and step-04-check.md section 1.7
-> **Purpose:** Ensure PRD contains tasks for ALL required categories before/during execution
-> **Frequency:** On load (step-01) and every iteration (step-04)
-
----
-
-## The Problem
-
-**Test-v4-005 Failure Mode:**
-- PRD generated with only backend categories (domain, infrastructure, application, api, seedData)
-- Frontend and test categories were entirely absent
-- Result: 0 frontend pages, 0 tests generated across 3 modules
-- Root cause: No guardrail detection during load
-
-## The Solution: Required Categories
-
-**CRITICAL:** Every PRD MUST have tasks for these categories:
-
-```javascript
-const REQUIRED_CATEGORIES = ['domain', 'infrastructure', 'application', 'api', 'seedData', 'frontend', 'test'];
-```
-
-> **Why seedData is required:**
-> - Without it: Navigation/Permissions are not seeded
-> - Result: Frontend/test tasks execute against empty database
-> - Guardrail must inject NavigationApplicationSeedData, ApplicationRolesSeedData, etc.
-
----
-
-## Completeness Check Function
-
-```javascript
-function checkCategoryCompleteness(prd) {
-  const presentCategories = new Set(prd.tasks.map(t => t.category));
-  const REQUIRED_CATEGORIES = ['domain', 'infrastructure', 'application', 'api', 'seedData', 'frontend', 'test'];
-  const missingCategories = REQUIRED_CATEGORIES.filter(c => !presentCategories.has(c));
-
-  if (missingCategories.length === 0) {
-    return { missing: [], guardrailsNeeded: [] };
-  }
-
-  console.warn(`⚠ PRD MISSING CATEGORIES: ${missingCategories.join(', ')}`);
-
-  // Calculate max ID for new guardrails
-  let maxIdNum = Math.max(...prd.tasks.map(t => {
-    const num = parseInt(t.id.replace(/[^0-9]/g, ''), 10);
-    return isNaN(num) ? 0 : num;
-  }), 0);
-
-  const prefix = prd.tasks[0]?.id?.replace(/[0-9]+$/, '') || 'GUARD-';
-  const lastApiTask = prd.tasks.filter(t => t.category === 'api').pop()?.id;
-  const lastSeedDataTask = prd.tasks.filter(t => t.category === 'seedData').pop()?.id;
-
-  // Dependency chain: domain → infrastructure → application → api → seedData → frontend → test
-  // Frontend MUST depend on seedData (navigation/permissions must be seeded first)
-  const frontendDep = lastSeedDataTask || lastApiTask;
-
-  const guardrailTasks = [];
-
-  for (const cat of missingCategories) {
-    maxIdNum++;
-    const taskId = `${prefix}${String(maxIdNum).padStart(3, '0')}`;
-
-    // Determine dependencies based on category order
-    let deps;
-    if (cat === 'seedData') {
-      deps = [lastApiTask]; // seedData depends on API infrastructure
-    } else if (cat === 'frontend') {
-      deps = [frontendDep]; // frontend depends on seedData (navigation must be seeded)
-    } else if (cat === 'test') {
-      deps = [frontendDep]; // test depends on seedData too
-    } else {
-      deps = [];
-    }
-
-    const guardrailTask = {
-      id: taskId,
-      description: `[GUARDRAIL] Generate ${cat} layer for ${prd.project?.module || 'module'}`,
-      status: 'pending',
-      category: cat,
-      dependencies: deps,
-      acceptance_criteria: determineAcceptanceCriteria(cat),
-      started_at: null,
-      completed_at: null,
-      iteration: null,
-      commit_hash: null,
-      files_changed: [],
-      validation: null,
-      error: null
-    };
-
-    guardrailTasks.push(guardrailTask);
-  }
-
-  return { missing: missingCategories, guardrailsNeeded: guardrailTasks };
-}
-
-function determineAcceptanceCriteria(category) {
-  const criteria = {
-    domain: 'Entity classes created with required properties',
-    infrastructure: 'EF Core configs, migrations created, dotnet build passes',
-    application: 'Service classes implementing business logic',
-    api: 'REST controllers with [RequirePermission] attributes',
-    seedData: 'NavigationApplicationSeedData + ApplicationRolesSeedData + PermissionsSeedData created, IClientSeedDataProvider wired, startup test passes',
-    frontend: 'React pages created via MCP scaffold_api_client + scaffold_routes, wired to App.tsx, navigation seed data verified in DB',
-    test: 'Unit + Integration test projects created, scaffold_tests MCP called, dotnet test passes'
-  };
-  return criteria[category] || `${category} layer fully implemented per category-rules.md`;
-}
-```
-
-## Application in step-01
-
-```javascript
-// After loading prd.json or generating tasks
-const { missing, guardrailsNeeded } = checkCategoryCompleteness(prd);
-
-if (guardrailsNeeded.length > 0) {
-  console.log(`PRD updated: ${prd.tasks.length} → ${prd.tasks.length + guardrailsNeeded.length} tasks (${guardrailsNeeded.length} guardrails added)`);
-  prd.tasks.push(...guardrailsNeeded);
-
-  // Update frontendDep for any frontend guardrail if seedData was just injected
-  if (missing.includes('seedData')) {
-    const seedDataGuard = guardrailsNeeded.find(t => t.category === 'seedData');
-    const frontendGuard = prd.tasks.find(t => t.category === 'frontend' && t.description.includes('[GUARDRAIL]'));
-    if (frontendGuard && seedDataGuard) {
-      frontendGuard.dependencies = [seedDataGuard.id];
-    }
-  }
-
-  writeJSON(currentPrdPath, prd);
-}
-```
-
-## Application in step-04 (every iteration)
-
-```javascript
-// RUNS EVERY ITERATION — not just once
-const { missing, guardrailsNeeded } = checkCategoryCompleteness(prd);
-
-if (guardrailsNeeded.length > 0) {
-  prd.tasks.push(...guardrailsNeeded);
-  writeJSON(currentPrdPath, prd);
-
-  const newPending = prd.tasks.filter(t => t.status === 'pending').length;
-  console.log(`PRD updated: +${guardrailsNeeded.length} guardrails, ${newPending} pending tasks`);
-}
-```
-
-## Artifact Verification
-
-After category check, verify artifacts actually exist for completed tasks.
-
-> **Patterns read from PRD metadata first** (`prd.metadata.artifactPatterns`), falling back to SmartStack defaults.
-> This allows non-standard project structures to work without hardcoded paths.
-
-```javascript
-const completedCats = new Set(prd.tasks.filter(t => t.status === 'completed').map(t => t.category));
-
-// Read custom patterns from PRD metadata (set by ss business-analyse-handoff based on project structure)
-const customPatterns = prd.metadata?.artifactPatterns || {};
-
-const artifactChecks = {
-  'frontend': () => {
-    const patterns = customPatterns.frontend || ['**/src/pages/**/*.tsx', '**/src/app/**/*.tsx'];
-    return patterns.some(p => glob.sync(p).length > 0);
-  },
-  'test': () => {
-    const patterns = customPatterns.test || ['tests/**/*Tests.cs', '**/*.spec.ts', '**/*.test.ts'];
-    return patterns.some(p => glob.sync(p).length > 0);
-  },
-  'api': () => {
-    const patterns = customPatterns.api || ['src/*/Controllers/**/*Controller.cs', 'src/**/controllers/**/*.ts'];
-    return patterns.some(p => glob.sync(p).length > 0);
-  }
-};
-
-for (const [cat, check] of Object.entries(artifactChecks)) {
-  if (completedCats.has(cat) && !check()) {
-    console.warn(`ARTIFACT MISSING: ${cat} tasks marked completed but no files found — resetting to pending`);
-    prd.tasks.filter(t => t.category === cat && t.status === 'completed')
-      .forEach(t => {
-        t.status = 'pending';
-        t.error = 'Artifacts missing — re-execute';
-        t.completed_at = null;
-      });
-    writeJSON(currentPrdPath, prd);
-  }
-}
-```
-
-## Entity-Level File Completeness Check (BLOCKING)
-
-> **LESSON LEARNED (audit ba-002):** Artifact verification checked "at least one file per category"
-> but never reconciled against the **handoff contract** (`prd.implementation.filesToCreate`).
-> Result: 4/17 API endpoints were missing but the category showed "complete" because *some* controllers existed.
-
-```javascript
-// BLOCKING: Verify EVERY file from prd.implementation.filesToCreate exists on disk
-const filesToCreate = prd.implementation?.filesToCreate;
-if (filesToCreate) {
-  const handoffMissing = [];
-  const handoffPresent = [];
-
-  for (const [category, files] of Object.entries(filesToCreate)) {
-    for (const file of (files || [])) {
-      const filePath = file.path || file;
-      if (fileExists(filePath)) {
-        handoffPresent.push({ category, path: filePath });
-      } else {
-        handoffMissing.push({ category, path: filePath });
-      }
-    }
-  }
-
-  const totalHandoff = handoffPresent.length + handoffMissing.length;
-  const coveragePct = totalHandoff > 0 ? Math.round((handoffPresent.length / totalHandoff) * 100) : 100;
-  console.log(`Handoff file coverage: ${handoffPresent.length}/${totalHandoff} (${coveragePct}%)`);
-
-  if (handoffMissing.length > 0) {
-    console.error(`BLOCKING: ${handoffMissing.length} files from handoff contract missing on disk`);
-
-    // Group missing files by category for targeted remediation
-    const missingByCategory = {};
-    for (const m of handoffMissing) {
-      if (!missingByCategory[m.category]) missingByCategory[m.category] = [];
-      missingByCategory[m.category].push(m.path);
-    }
-
-    // Inject remediation tasks for each missing file
-    let maxIdNum = Math.max(...prd.tasks.map(t => {
-      const num = parseInt(t.id.replace(/[^0-9]/g, ''), 10);
-      return isNaN(num) ? 0 : num;
-    }), 0);
-    const prefix = prd.tasks[0]?.id?.replace(/[0-9]+$/, '') || 'HNDOFF-';
-
-    for (const [cat, paths] of Object.entries(missingByCategory)) {
-      for (const p of paths) {
-        // Skip if a remediation task already exists for this file
-        const alreadyExists = prd.tasks.some(t =>
-          t.description.includes(p) && t.description.includes('[HANDOFF-REMEDIATION]')
-        );
-        if (alreadyExists) continue;
-
-        maxIdNum++;
-        prd.tasks.push({
-          id: `${prefix}${String(maxIdNum).padStart(3, '0')}`,
-          description: `[HANDOFF-REMEDIATION] Create missing file: ${p}`,
-          status: 'pending',
-          category: cat,
-          dependencies: [],
-          acceptance_criteria: `File ${p} exists on disk and compiles`,
-          started_at: null, completed_at: null, iteration: null,
-          commit_hash: null, files_changed: [], validation: null, error: null
-        });
-      }
-      console.error(`  ${cat}: ${paths.length} missing — ${paths.map(p => p.split('/').pop()).join(', ')}`);
-    }
-
-    writeJSON(currentPrdPath, prd);
-  }
-} // end filesToCreate check
-```
-
-## Type Reference Verification (Cross-File Integrity)
-
-> **LESSON LEARNED (audit ba-002):** Artifact verification counted files but didn't check
-> that types referenced in code actually exist. `EmployeeListDto` was used in services
-> but the file was missing — a "phantom reference" that artifact file-counting missed.
-
-```javascript
-// After artifact checks, verify cross-file type references for completed categories
-if (completedCats.has('application') && completedCats.has('api')) {
-  const serviceFiles = glob('src/**/Services/**/*Service.cs');
-  const dtoFiles = glob('src/**/DTOs/**/*.cs');
-  const entityFiles = glob('src/**/Domain/**/*.cs');
-
-  // Extract all DTO type names from actual files
-  const existingTypes = new Set();
-  for (const f of [...dtoFiles, ...entityFiles]) {
-    const content = readFile(f);
-    const typeMatches = content.matchAll(/(?:class|record|struct|enum|interface)\s+(\w+)/g);
-    for (const m of typeMatches) existingTypes.add(m[1]);
-  }
-
-  // Check service files for references to types that don't exist
-  const phantomRefs = [];
-  for (const f of serviceFiles) {
-    const content = readFile(f);
-    // Look for Dto/Entity type references in return types and method params
-    const typeRefs = content.matchAll(/(?:<|,\s*|\(|new\s+)(\w+(?:Dto|Entity|Exception))\b/g);
-    for (const m of typeRefs) {
-      if (!existingTypes.has(m[1]) && !m[1].startsWith('I')) {
-        phantomRefs.push({ file: f, type: m[1] });
-      }
-    }
-  }
-
-  if (phantomRefs.length > 0) {
-    console.error(`PHANTOM TYPE REFERENCES DETECTED (${phantomRefs.length}):`);
-    phantomRefs.forEach(r => console.error(`  ${r.file}: references ${r.type} — TYPE DOES NOT EXIST`));
-
-    // Reset application category tasks to pending — code references non-existent types
-    prd.tasks.filter(t => t.category === 'application' && t.status === 'completed')
-      .forEach(t => {
-        t.status = 'pending';
-        t.error = `Phantom type references: ${phantomRefs.map(r=>r.type).join(', ')}`;
-        t.completed_at = null;
-      });
-    writeJSON(currentPrdPath, prd);
-  }
-}
-```
-
----
-
-## Key Rules
-
-- **Inject EVERY iteration:** Not just once during load
-- **Frontend depends on seedData:** Not just API
-- **Check artifacts:** Mark tasks pending if files don't exist
-- **Check type references:** Verify types used in code actually exist (phantom reference detection)
-- **Check handoff files:** Verify EVERY file from `prd.implementation.filesToCreate` exists on disk
-- **Never skip:** This is the blocker for "missing frontend/test" failures

package/templates/skills/business-analyse-develop/references/category-rules.md

@@ -1,109 +0,0 @@
-# Category Ordering & Dependency Rules
-
-> **Loaded by:** step-02 (task ordering validation) and compact-loop.md (batch grouping)
-> **Purpose:** Defines execution order, dependencies, and batch grouping rules.
-> **Note:** All execution rules, MCP tool usage, conventions, and POST-CHECKs are in `/apex` references.
-
----
-
-## Execution Order
-
-Tasks MUST be executed in this order. Each category depends on the previous ones.
-
-| Order | Category | Depends On | Description |
-|-------|----------|------------|-------------|
-| 0 | `domain` | — | Entities, enums, value objects |
-| 1 | `infrastructure` | domain | EF configs, migrations, seed data |
-| 2 | `application` | infrastructure | Services, DTOs, validators, DI |
-| 3 | `api` | application | Controllers, route attributes |
-| 4 | `seedData` | api | Navigation, permissions, roles, dev data |
-| 5 | `frontend` | seedData | Pages, routes, i18n, components |
-| 6 | `test` | frontend | Unit tests, integration tests, coverage |
-
-> **Key dependency:** `frontend` depends on `seedData` (not just `api`).
-> Navigation seed data drives the menu — without it, frontend routes have no menu entries.
-
----
-
-## Dependency Rules
-
-1. **A task can only start when ALL its dependencies are `completed`**
-2. **If a dependency is `failed` or `blocked`, the task becomes `blocked`**
-3. **Cross-category dependencies are implicit** — domain before infrastructure, etc.
-4. **Same-category tasks MAY run in parallel** (batched together)
-5. **PRD `dependencies[]` array overrides implicit ordering** — explicit deps always checked first
-
----
-
-## Person Role Entities
-
-Entities with `personRoleConfig` (Person Extension Pattern) have a special architectural requirement:
-
-- **ICoreDbContext access required**: Person Extension entities need to read User data from the core schema
-- This is an **exception** to the normal pattern where extension entities only use `IExtensionsDbContext`
-- Service must inject BOTH `IExtensionsDbContext` (for the entity) AND `ICoreDbContext` (for User reads)
-- Service must `Include(x => x.User)` on all queries
-- For mandatory mode: search on `User.FirstName`, `User.LastName`, `User.Email`
-- For optional mode: search with fallback (`User?.FirstName ?? x.FirstName`)
-
----
-
-## Batch Grouping Rules
-
-When selecting tasks for a batch:
-
-1. **Group by category** — take the first eligible category with pending tasks
-2. **Max batch size: 5 tasks** — prevents overloading a single apex invocation
-3. **Same category only** — never mix domain + infrastructure in one batch
-4. **Order within batch: by task ID** (ascending) — preserves PRD creation order
-
-```javascript
-const eligible = prd.tasks.filter(/* pending + deps met */);
-const firstCategory = eligible[0].category;
-const batch = eligible.filter(t => t.category === firstCategory).slice(0, 5);
-```
-
----
-
-## PRD Category Completeness
-
-A valid PRD MUST contain tasks in these categories:
-
-- `domain` — at least 1 entity task
-- `infrastructure` — at least 1 EF config + migration task
-- `application` — at least 1 service task
-- `api` — at least 1 controller task
-- `seedData` — at least 1 navigation/permission task
-- `frontend` — at least 1 page task
-- `test` — at least 1 test task
-
-If any category is missing, ralph step-01 injects a guardrail task.
-
----
-
-## Section-Level Splitting (>4 Entities)
-
-When a module has many entities, a single `/apex -d` call saturates the context window.
-Section-level splitting breaks the module into smaller, manageable phases.
-
-**Activation threshold:** `> 4 domain tasks` AND `> 1 architecture section`
-
-| Phase | Content | Depends On |
-|-------|---------|------------|
-| Phase 0 | ALL domain + infrastructure + migration + module seed data | — |
-| Phase 1 | Section A: services, controllers, section seed, pages, i18n, tests | Phase 0 |
-| Phase 2 | Section B: idem | Phase 0 (+ Phase 1 if FK cross-section) |
-| Phase N | Section N: idem | Phase 0 (+ earlier phases if FK) |
-| Final | Cross-validation (dotnet build, typecheck, MCP validate) | All phases |
-
-**Key rules:**
-- Phase 0 creates ALL entity classes + ALL EF configs + ONE migration (avoids ModelSnapshot conflicts)
-- Section phases NEVER create entities or migrations — only services, controllers, pages on top
-- FK cross-section dependencies determine section execution order (topological sort)
-- Orphan entities (not in any section) are included in Phase 0 with their services/controllers
-- Each phase produces a temporary PRD file: `.ralph/prd-{module}-phase0.json`, `.ralph/prd-{module}-section-{code}.json`
-- Temporary PRD files are cleaned up in step-05 (report)
-
-**Backward compatible:** Modules with `<= 4 domain tasks` or `1 section` → standard execution, zero impact.
-
-See `references/section-splitting.md` for full detection, mapping, and execution logic.