@atlashub/smartstack-cli 4.81.0 → 5.0.0

package/templates/skills/business-analyse-handoff/schemas/handoff-schema.json

@@ -1,95 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "handoff-schema.json",
-  "title": "SmartStack BA - Handoff",
-  "description": "Module-level handoff: file mapping (8 categories), BR-to-code mapping, API endpoint summary. Used by /business-analyse-handoff skill.",
-  "type": "object",
-  "properties": {
-    "complexity": { "type": "string", "enum": ["simple", "medium", "complex"] },
-    "filesToCreate": {
-      "type": "object",
-      "properties": {
-        "domain": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "application": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "infrastructure": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "api": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "frontend": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "seedData": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "tests": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } },
-        "documentation": { "type": "array", "items": { "$ref": "#/$defs/fileSpec" } }
-      },
-      "required": ["domain", "application", "infrastructure", "api", "frontend", "seedData", "tests", "documentation"]
-    },
-    "brToCodeMapping": {
-      "type": "array",
-      "description": "Maps each business rule to its implementation points across layers",
-      "items": {
-        "type": "object",
-        "required": ["ruleId", "implementationPoints"],
-        "properties": {
-          "ruleId": { "type": "string", "description": "BR-XXX identifier from rules.json > rules[]" },
-          "title": { "type": "string" },
-          "implementationPoints": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "required": ["layer", "component"],
-              "properties": {
-                "layer": { "type": "string", "description": "Architecture layer (Domain, Application, Infrastructure, API, Frontend)" },
-                "component": { "type": "string", "description": "File name (e.g., Order.cs, OrdersController.cs)" },
-                "method": { "type": "string" },
-                "implementation": { "type": "string" }
-              }
-            }
-          }
-        }
-      }
-    },
-    "apiEndpointSummary": {
-      "type": "array",
-      "description": "API endpoints generated from usecases.json + entities.json during step-01 transform.",
-      "items": {
-        "type": "object",
-        "properties": {
-          "operation": { "type": "string" },
-          "method": { "type": "string", "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"] },
-          "route": { "type": "string" },
-          "linkedUC": { "type": "string" },
-          "permissions": { "type": "string" }
-        }
-      }
-    },
-    "ralphPrd": {
-      "type": "object",
-      "description": "Embedded Ralph Loop task breakdown (also exported to .ralph/prd.json by ss business-analyse-handoff)",
-      "properties": {
-        "tasks": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "properties": {
-              "id": { "type": "integer" },
-              "description": { "type": "string" },
-              "category": { "type": "string", "enum": ["domain", "seedData", "seedDataCore", "application", "infrastructure", "api", "frontend", "i18n", "test", "validation"] },
-              "dependencies": { "type": "array", "items": { "type": "integer" } },
-              "acceptanceCriteria": { "type": "string" }
-            }
-          }
-        }
-      }
-    }
-  },
-  "$defs": {
-    "fileSpec": {
-      "type": "object",
-      "required": ["path", "type", "module"],
-      "properties": {
-        "path": { "type": "string" },
-        "type": { "type": "string" },
-        "module": { "type": "string" },
-        "description": { "type": "string" },
-        "dependencies": { "type": "array", "items": { "type": "string" } }
-      }
-    }
-  }
-}

package/templates/skills/business-analyse-handoff/steps/step-00-validate.md

@@ -1,158 +0,0 @@
----
-name: step-00-validate
-description: Detect input, validate BA readiness with flat-file support, AC gate
-next_step: steps/step-01-transform.md
----
-
-> **Context files:** `references/acceptance-criteria.md` | `references/readiness-scoring.md`
-
-# Step 00: Validate BA Readiness
-
-## MANDATORY EXECUTION RULES
-
-- **ALWAYS** verify status = "consolidated", "specified", "designed", or "reviewed" for all modules before proceeding
-- **ALWAYS** validate **input** acceptance criteria (AC-01 to AC-07) per module
-- **ALWAYS** load flat files (entities.json, usecases.json, etc.) from module directories
-- **BLOCKING** if any module has readiness score < 100% on input ACs
-- **NEVER** proceed to transform if any module fails readiness gate
-- **NEVER** check output ACs (AC-08+) here — those are checked after step-01 transform
-
-## YOUR TASK
-
-Detect the BA feature input, verify all modules are consolidated/specified, validate input acceptance criteria as a pre-gate, calculate readiness scores, and display the readiness table.
-
----
-
-## EXECUTION SEQUENCE
-
-### 1. Detect Input
-
-```
-IF --feature <path> provided:
-  featurePath = <path>
-ELSE:
-  // Auto-detect from docs/
-  Scan docs/ for index.json files with status in ["consolidated", "specified", "designed", "reviewed"]
-  IF found exactly 1:
-    featurePath = found path
-  ELSE IF found > 1:
-    Display list and ask user to specify --feature <path>
-    STOP
-  ELSE:
-    BLOCKING ERROR: "No ready BA feature found (expected status: consolidated, specified, designed, or reviewed). Run /business-analyse first."
-    STOP
-```
-
-### 2. Load Feature & Resolve Module Paths
-
-```
-// Read application-level index.json
-appIndex = READ(featurePath/index.json)
-
-// Resolve module directories
-// Modules are stored in: docs/{AppCode}/{ModuleCode}/business-analyse/v{X.Y}/
-FOR each module in appIndex.modules:
-  moduleDir = docs/{appIndex.metadata.applicationCode}/{module.code}/business-analyse/v{version}/
-  IF moduleDir/index.json exists:
-    module.baDir = moduleDir
-  ELSE:
-    BLOCKING ERROR: "Module {module.code} directory not found at {moduleDir}"
-```
-
-### 3. Verify Module Status
-
-```
-FOR each module:
-  moduleIndex = READ(module.baDir/index.json)
-  IF moduleIndex.metadata.status NOT IN ["consolidated", "specified", "designed", "reviewed"]:
-    BLOCKING ERROR: "Module {module.code} status: {status}, expected consolidated, specified, designed, or reviewed"
-    -> Run /business-analyse to complete specification first
-```
-
-### 4. Load Flat Files Per Module
-
-For each module, load the separate JSON files directly (index.json may not exist at module level):
-
-```javascript
-// Load thematic files directly from module directory
-const entitiesData = READ(moduleDir + '/entities.json') || {};
-const usecasesData = READ(moduleDir + '/usecases.json') || {};
-const rulesData = READ(moduleDir + '/rules.json') || {};
-const permissionsData = READ(moduleDir + '/permissions.json') || {};
-const screensData = READ(moduleDir + '/screens.json') || {};
-
-// NORMALISATION: tolerate ba-writer + LLM field name variants
-// See acceptance-criteria.md for the full extraction functions
-const moduleData = {
-  entities: entitiesData.entities || [],
-  hasReferencedEntities: (entitiesData.referencedEntities || []).length > 0,
-  useCases: usecasesData.useCases || usecasesData.usecases || [],
-  rules: rulesData.rules || rulesData.businessRules || [],
-  permissions: extractPermissions(permissionsData),
-    // tries: permissionPaths > permissionSet.permissions > basePermissions > actions > permissions
-  screens: extractScreens(screensData),
-    // tries: screens > sections[].resources > sections > wireframes
-};
-```
-
-### 5. Validate Input Acceptance Criteria Per Module
-
-For **EACH module**, run the **input** AC bash script from `references/acceptance-criteria.md`:
-
-```bash
-MODULE_DIR="{module_ba_dir}"
-node -e "
-const fs = require('fs');
-const path = require('path');
-const dir = process.argv[1];
-// ... (full input AC script from references/acceptance-criteria.md)
-" "$MODULE_DIR"
-```
-
-Collect results per module: PASS count, FAIL count.
-
-### 6. Calculate Readiness Score
-
-> **Reference:** See loaded context `readiness-scoring.md` for the full algorithm.
-
-For each module:
-- Count input ACs passed vs total (7 input ACs)
-- Score = (passed / 7) x 100
-
-### 7. Apply Readiness Gate
-
-```
-FOR each module:
-  IF readiness_score < 100%:
-    BLOCKING ERROR: "Module {moduleCode} readiness: {score}% -- {failed_count} input ACs failed"
-    Display failed ACs with recovery actions
-    -> Run /business-analyse to fix, then retry /business-analyse-handoff
-    STOP
-```
-
-### 8. Display Readiness Table
-
-```
-================================================================
-  DERIVE-PRD -- BA READINESS VALIDATION
-================================================================
-
-Feature: {feature_name}
-Modules: {module_count}
-
-+--------------+----------+-----------+-------+---------+
-| Module       | Status   | Score     | Ready | Details |
-+--------------+----------+-----------+-------+---------+
-| {module1}    | specif.  | 7/7 100%  | YES   | E:2 UC:6 BR:8 S:4 P:5 |
-| {module2}    | specif.  | 7/7 100%  | YES   | E:3 UC:8 BR:10 S:6 P:6 |
-+--------------+----------+-----------+-------+---------+
-
--> All modules READY -- proceeding to transform...
-================================================================
-```
-
----
-
-## NEXT STEP
-
-Load: `steps/step-01-transform.md`

package/templates/skills/business-analyse-handoff/steps/step-01-transform.md

@@ -1,85 +0,0 @@
----
-name: step-01-transform
-description: Build handoff data per module - 8 categories from flat BA files
-next_step: steps/step-02-export.md
----
-
-# Step 01: Transform (Handoff Data Generation)
-
-## MANDATORY EXECUTION RULES
-
-- **ALWAYS** process modules in topological order (dependencies first)
-- **ALWAYS** delegate each module to an **isolated Agent** (context isolation — CRITICAL for large projects)
-- **ALWAYS** load data from **flat files** (entities.json, usecases.json, rules.json, screens.json, permissions.json)
-- **ALWAYS** map to 8 categories (including "documentation")
-- **ALWAYS** propagate personRoleConfig verbatim from entities
-- **ALWAYS** separate seedData into core/business categories
-- **ALWAYS** map entity to domain file path (1:1)
-- **ALWAYS** include dependencies[] per file entry
-- **NEVER** invent entities/BRs not in module JSON files
-- **NEVER** load all module data in the main conversation (causes context overflow on 5+ modules)
-- **ALWAYS** generate API endpoints from use cases + entities (BA does not produce apiEndpoints)
-- **ALWAYS** canonicalize entity names before generating file paths — see `references/entity-canonicalization.md`
-
-## FICHIERS A CREER — LISTE FERMEE (ba-009 fix)
-
-> **Load** `references/handoff-file-inventory.md` for exhaustive file list, naming regex, and forbidden variants.
-
----
-
-## YOUR TASK
-
-Orchestrate the transform: determine module order, then delegate each module's transform to an Agent with isolated context. This prevents context accumulation across modules.
-
----
-
-## CONTEXT ISOLATION ARCHITECTURE
-
-> **Load** `references/context-isolation-pattern.md` for the orchestration pattern, agent delegation flow, and context budget rules.
-
----
-
-## EXECUTION SEQUENCE
-
-### 1. Determine Module Processing Order
-
-From step-00 data, extract the topological order of modules. Display:
-
-```
-Module processing order:
-  1. {module1} (0 dependencies)
-  2. {module2} (depends on: module1)
-  ...
-```
-
-### 2. Process Each Module via Agent
-
-For **EACH module** in topological order, use the **Agent tool** (subagent_type: `ba-writer`) with:
-
-> → **Load** `references/agent-handoff-transform-prompt.md` as the complete agent prompt for each module transformation.
-
-### 3. Display Progress
-
-After each Agent completes, display:
-
-```
-handoff {i+1}/{N}: {moduleCode} ({fileCount} files) ✓
-```
-
-### 4. Display Summary
-
-```
-================================================================
-  TRANSFORM COMPLETE
-================================================================
-Modules processed: {N}/{N}
-Total files mapped: {totalFiles}
-Global complexity: {highest_complexity}
-================================================================
-```
-
----
-
-## NEXT STEP
-
-Load: `steps/step-02-export.md`

package/templates/skills/business-analyse-handoff/steps/step-02-export.md

@@ -1,169 +0,0 @@
----
-name: step-02-export
-description: Generate PRD files, verify integrity, output progress tracker and manifest
----
-
-> **Context files:** `references/prd-generation.md` | `templates/tpl-progress.md`
-
-# Step 02: Export (PRD + Verification)
-
-## MANDATORY EXECUTION RULES
-
-- **ALWAYS** generate PRD via `ss business-analyse-handoff` CLI command (deterministic, never LLM)
-- **ALWAYS** verify PRD structure: $version=3.0.0 or 4.0.0, implementation.filesToCreate (v3) or expectedFiles (v4), 8 categories
-- **ALWAYS** verify file counts match between PRD and handoff
-- **ALWAYS** generate progress.txt from template
-- **ALWAYS** update BA manifest (docs/index.json)
-- **NEVER** skip POST-CHECK validation
-
-## YOUR TASK
-
-For each module, generate PRD files via CLI, verify integrity, create progress tracker, update manifest, and display completion summary.
-
----
-
-## EXECUTION SEQUENCE
-
-### 1. Generate PRD Files
-
-For EACH module:
-
-**Option A — Flat-file BA (recommended):**
-
-```bash
-# Single module:
-ss business-analyse-handoff --ba-dir {moduleBaDir} --output .ralph/prd-{moduleCode}.json
-
-# All modules from app-level index.json:
-ss business-analyse-handoff --ba-app {appIndexPath}
-```
-
-**Option B — Legacy feature.json:**
-
-```bash
-ss business-analyse-handoff --feature {moduleFeaturePath} --output .ralph/prd-{moduleCode}.json
-```
-
-**Option C — v4 spec-oriented PRD (1M context + compaction):**
-
-```bash
-ss business-analyse-handoff --ba-app {appIndexPath} --v4
-```
-
-Generates `prd-{moduleCode}.json` with `$version: "4.0.0"` containing:
-- `objectives[]` with acceptance criteria (instead of pre-computed tasks)
-- `expectedFiles` (same 8 categories, for file reconciliation)
-- `gates` (declarative quality gate definitions)
-- Architecture, business rules, BR mapping, seed data (same as v3)
-
-### 2. POST-CHECK PRD (BLOCKING)
-
-> **Reference:** See loaded context `prd-validation-checks.md` for complete validation rules (6 checks: version, file manifest, categories, counts, companions, C# identifiers).
-
-Verify PRD structure against module handoff, display verification table showing all 8 categories match between module JSON files and prd.json.
-
-### 3. Generate modules-queue.json (if 2+ modules)
-
-```json
-{
-  "modules": [
-    { "code": "{code}", "prdFile": ".ralph/prd-{code}.json", "status": "pending", "order": 1, "dependencies": [], "complexity": "simple" },
-    { "code": "{code}", "prdFile": ".ralph/prd-{code}.json", "status": "pending", "order": 2, "dependencies": ["{dep}"], "complexity": "medium" }
-  ],
-  "currentIndex": 0,
-  "totalModules": "{count}",
-  "completedModules": 0,
-  "strategy": "topological"
-}
-```
-
-Write to: `.ralph/modules-queue.json`
-
-### 4. Generate progress.txt
-
-> **Template:** See loaded context `tpl-progress.md` for complete structure.
-> **Data source:** Populate with module-specific data from index.json.
-
-- One section per module in topological order
-- CORE SeedData: 5 entries (mandatory)
-- Business SeedData: per module (varies)
-- Hierarchical task structure (module -> layer -> tasks)
-- Each task: checkbox, description, effort, dependencies
-- Summary with totals across all modules
-- Cross-module tasks IF multi-module
-
-Before writing:
-```
-IF .ralph/progress.txt exists AND contains "Iteration" entries:
-  WARN: "progress.txt contains development progress — appending handoff section instead of overwriting"
-  APPEND instead of WRITE
-```
-
-Write to: `.ralph/progress.txt`
-
-### 5. Update Project Index (status tracking)
-
-> **Reference:** See loaded context `project-index-update.md` for ba-006 primary flow and legacy pre-ba-006 fallback structure.
-
-Update the project's own `{docs_dir}/index.json` with handoff status. If legacy `docs/index.json` exists, update it for backward compatibility.
-
-### 6. Display Completion Summary
-
-```
-══════════════════════════════════════════════════════════════
-  DERIVE-PRD COMPLETE — {application_name}
-══════════════════════════════════════════════════════════════
-
-Modules: {count} ({names})
-Complexity: {simple|medium|complex}
-Files: {total across all modules}
-Tasks: {total}
-
-Readiness Scores:
-┌──────────────┬────────────┬──────────────┐
-│ Module       │ Blocking   │ Files        │
-├──────────────┼────────────┼──────────────┤
-│ {module1}    │ 100%       │ {count}      │
-│ {module2}    │ 100%       │ {count}      │
-└──────────────┴────────────┴──────────────┘
-
-Artifacts generated:
-  .ralph/prd-{module}.json                — Task breakdown per module
-  .ralph/prd-{module}.entities.json       — Entity specifications (companion)
-  .ralph/prd-{module}.rules.json          — Business rules (companion)
-  .ralph/prd-{module}.usecases.json       — Use cases (companion)
-  .ralph/prd-{module}.screens.json        — Screen specifications (companion)
-  .ralph/prd-{module}.permissions.json    — Permissions (companion)
-  .ralph/progress.txt                     — Progression tracker
-  .ralph/modules-queue.json               — Module execution order (if multi-module)
-  {docs_dir}/index.json                   — Project index (status: handed-off)
-
-[NEXT] Development:
-  1. Run /business-analyse-develop to begin implementation
-  2. Modules will be processed in topological order
-  3. Each module PRD contains {total_files} files across 8 categories
-
-══════════════════════════════════════════════════════════════
-```
-
----
-
-## SELF-VERIFICATION (BEFORE COMPLETION)
-
-1. `.ralph/prd-{module}.json` exists for ALL modules (>100 bytes each)
-2. `.ralph/progress.txt` exists (>500 bytes)
-3. `.ralph/modules-queue.json` exists (if 2+ modules)
-4. `{docs_dir}/index.json` updated with handoff status (legacy: `docs/index.json` if it exists)
-5. All PRD files have $version=3.0.0 or 4.0.0, file manifest present, 8 categories
-6. File counts match between PRD and handoff for all categories
-7. For EACH module: 5 companion files exist in `.ralph/` (entities, rules, usecases, screens, permissions)
-8. Each PRD contains `specificationFiles` with all 5 paths
-9. Each companion file is non-empty (>10 bytes)
-
-**IF any check fails -> fix before completing.**
-
-## POST-CHECK GLOBAL (BLOCKING — ba-009 fix)
-
-> **Reference:** See loaded context `handoff-global-validation.md` for module-level integrity, global file checks, surplus file detection, and result handling.
-
-Verifies overall handoff integrity across all modules — blocks completion if expected files are missing.

package/templates/skills/business-analyse-handoff/templates/tpl-progress.md

@@ -1,172 +0,0 @@
-# Progress Tracker Template (templates/tpl-progress.md)
-
-> **Used by:** step-05-deploy (section 4: Generate progress.txt)
-> **Purpose:** Template structure for .ralph/progress.txt - populate with module-specific data
-
-## Template
-
-```
-═════════════════════════════════════════════════════════════════
-  SMARTSTACK RALPH LOOP - PROGRESS TRACKER
-  Project: {project_name} | Application: {app_name}
-  Modules: {count} ({moduleOrder.join(', ')})
-  Strategy: {implementation_strategy}
-  Created: {timestamp}
-  Status: HANDED-OFF
-═════════════════════════════════════════════════════════════════
-
-{For each module in topological order:}
-[MODULE: {module_name}] ({complexity})
-  Status: NOT STARTED
-  Dependencies: {list of module dependencies or "FOUNDATION"}
-
-  [DOMAIN] Entity & Value Object Definitions
-    □ Define {Entity1} entity with properties and validation
-    □ Define {Entity2} entity with relationships
-    □ Define {ValueObject1} value object
-    □ Define domain exceptions
-    □ Total: X tasks
-
-  [SEEDDATA-CORE] Core Configuration (MANDATORY)
-    □ NavigationApplicationSeedData - Application navigation entry (once per app)
-    □ ApplicationRolesSeedData - Application-scoped roles (once per app)
-    □ NavigationModuleSeedData - Module navigation structure (per module)
-    □ PermissionsSeedData - RBAC permissions (per module)
-    □ RolesSeedData - Role-permission mappings (per module)
-    □ {App}SeedDataProvider - IClientSeedDataProvider (4 methods)
-    Total: 2 app-level + 3 per-module + 1 provider
-
-  [SEEDDATA] Business Reference Data
-    □ Seed {Entity1} reference data
-    □ Seed {Entity2} lookup values
-    □ Total: Y business seed tasks
-
-  [APPLICATION] Services & Business Logic
-    □ Create {ServiceName}Service for {UC1}
-    □ Create {DtoName}Dto for API contracts
-    □ Create {ValidatorName}Validator for input validation
-    □ Implement query handlers
-    Total: Z tasks
-
-  [INFRASTRUCTURE] Repositories & Persistence
-    □ Create {Entity1}Repository with CRUD + custom queries
-    □ Create {Entity2}Repository
-    □ Configure DbContext for module
-    □ Setup specifications for complex queries
-    □ Create IClientSeedDataProvider (client projects ONLY - injects core seeds at runtime)
-    □ Create DevDataSeeder + SeedConstants (if first module)
-    □ Total: A tasks
-
-  [API] REST Endpoints & Controllers
-    □ Create {ModuleNameController} GET endpoints (List, GetById)
-    □ Create {ModuleNameController} POST endpoint (Create)
-    □ Create {ModuleNameController} PUT endpoint (Update)
-    □ Create {ModuleNameController} DELETE endpoint (Delete)
-    □ Implement error handling and validation responses
-    Total: B tasks
-
-  [FRONTEND] UI Components & Pages (wireframe-driven)
-    □ Create {ModuleName}Page for listing [wireframe: {module}-list]
-    □ Create {ModuleName}DetailPage for viewing [wireframe: {module}-detail]
-    □ Create {ModuleName}Form component for creation/edit [wireframe: {module}-create]
-    □ Create custom hook use{ModuleName}
-    □ Implement pagination, filtering, sorting
-    □ Validate all pages match their wireframe layout
-    □ ⚠️ Routes MUST be INSIDE the AppLayout wrapper
-    Total: C tasks
-
-  [I18N] Internationalization Keys
-    □ Define i18n keys for {Module} UI labels
-    □ Setup translations for locales: fr, en, it, de
-    Total: D keys
-
-  [TESTS] Unit & Integration Tests
-    □ Unit tests for {Entity} domain logic
-    □ Unit tests for {ServiceName}Service
-    □ Integration tests for {ModuleNameController}
-    □ Security tests for authorization & tenant isolation
-    □ E2E tests for critical user flows
-    Total: E unit + F integration + G security = H tests
-
-  [QA] Quality Assurance
-    □ Code review against SmartStack conventions
-    □ Test coverage minimum 80%
-    □ Security scan for OWASP vulnerabilities
-    □ Performance testing under load
-    Total: 4 QA tasks
-
-  Module Total: X + 5 + Y + Z + A + B + C + D + H + 4 = {module_total} tasks
-  Estimated Effort: {simple/medium/complex} - {1-3/3-8/8-15} days
-
-{If multi-module:}
-[CROSS-MODULE] Integration Tasks
-  Status: NOT STARTED
-  Dependencies: All modules COMPLETED
-
-  □ Verify cross-module entity relationships
-  □ Test cross-module API dependencies
-  □ Validate permission matrix across modules
-  □ E2E flow tests spanning multiple modules
-  □ Cross-module data consistency checks
-  □ Integration test suite for module interactions
-  Total: 6 CROSS-MODULE tasks
-
-═════════════════════════════════════════════════════════════════
-SUMMARY
-═════════════════════════════════════════════════════════════════
-Total Modules:         {count}
-Total Tasks:           {total_count}
-  - CORE SeedData:     {count} × 5 = {total_core}
-  - Business Tasks:    {total_biz}
-  - Development:       {total_dev}
-  - Tests:             {total_tests}
-  - QA:                {total_qa}
-  - Cross-Module:      {cross_module_count or 0}
-
-Strategy:              {strategy}
-Module Order:          {topological order with dependencies noted}
-
-Complexity Distribution:
-  Simple:   {count} modules ({estimate} days each)
-  Medium:   {count} modules ({estimate} days each)
-  Complex:  {count} modules ({estimate} days each)
-
-Total Effort Estimate:  {total_days} days ({total_hours} hours)
-Per Developer (2):      {total_days / 2} days
-Parallel Potential:     {strategy_efficiency_percent}%
-
-═════════════════════════════════════════════════════════════════
-LEGEND
-═════════════════════════════════════════════════════════════════
-□ = Task not started
-✓ = Task completed
-⚠ = Task in progress
-✗ = Task failed / blocked
-
-COLORS:
-[DOMAIN]      = Domain Model & Business Logic
-[SEEDDATA-CORE] = MANDATORY core configuration (5 entries)
-[SEEDDATA]    = Business reference & lookup data
-[APPLICATION] = Services, DTOs, Validators
-[INFRASTRUCTURE] = Repositories, DbContext, ORM
-[API]         = REST controllers & endpoints
-[FRONTEND]    = React pages, components, hooks
-[I18N]        = Internationalization
-[TESTS]       = Unit, Integration, Security, E2E
-[QA]          = Code quality, coverage, security
-[CROSS-MODULE] = Multi-module integration (if applicable)
-
-═════════════════════════════════════════════════════════════════
-```
-
-## Progress Tracker Rules
-
-- One section per module, in topological order (dependencies first)
-- CORE SeedData ALWAYS 5 entries (mandatory)
-- Business SeedData varies by module
-- Hierarchical task structure (module → layer → tasks)
-- Each task is independent, assignable checkbox
-- Effort estimate per module (simple/medium/complex)
-- Summary with totals across all modules
-- Identified dependencies for parallel execution
-- Cross-module tasks only if multi-module