@atlashub/smartstack-cli 3.8.0 → 3.9.0

package/templates/skills/business-analyse/references/ui-resource-cards.md

@@ -0,0 +1,110 @@
+# UI: Resource Structure Cards
+
+> Reference for step-03b-ui.md — exact JSON formats for section resources (SmartTable, SmartForm) and wireframes.
+
+## specification.sections[] (with resources)
+
+```json
+{
+  "code": "list",
+  "labels": { "fr": "Liste", "en": "List", "it": "Elenco", "de": "Liste" },
+  "route": "/business/{app}/{module}/list",
+  "icon": "list",
+  "permission": "business.{app}.{module}.read",
+  "wireframe": "{module}-list",
+  "useCases": ["UC-{PREFIX}-001", "UC-{PREFIX}-002"],
+  "businessRules": ["BR-VAL-{PREFIX}-001"],
+  "resources": [
+    {
+      "code": "{module}-grid",
+      "type": "SmartTable",
+      "entity": "{MainEntity}",
+      "permission": "business.{app}.{module}.read",
+      "columns": ["name", "status", "createdAt"],
+      "columnDefs": [
+        { "field": "code", "label": {"fr": "Code", "en": "Code"}, "format": "text", "sortable": true, "filterable": true, "clickAction": "navigate:detail" },
+        { "field": "name", "label": {"fr": "Nom", "en": "Name"}, "format": "text", "sortable": true, "filterable": true },
+        { "field": "status", "label": {"fr": "Statut", "en": "Status"}, "format": "badge", "sortable": true, "filterable": true, "colorMap": "stateMachine:{Entity}" },
+        { "field": "createdAt", "label": {"fr": "Créé le", "en": "Created"}, "format": "date-relative", "sortable": true }
+      ],
+      "actions": ["view", "edit", "delete"],
+      "rowActions": [
+        { "action": "view", "icon": "eye", "permission": "business.{app}.{module}.read" },
+        { "action": "edit", "icon": "edit", "permission": "business.{app}.{module}.update", "showWhen": {"status": ["draft"]} },
+        { "action": "delete", "icon": "trash", "permission": "business.{app}.{module}.delete", "confirm": true }
+      ],
+      "filters": ["status", "dateRange"],
+      "defaultSort": { "field": "createdAt", "direction": "desc" },
+      "defaultPageSize": 20,
+      "emptyState": { "icon": "inbox", "message": {"fr": "Aucun enregistrement", "en": "No records"}, "createAction": true }
+    }
+  ]
+}
+```
+
+**MANDATORY for SmartTable:** `columnDefs`, `rowActions`, `defaultSort`, `emptyState`
+
+## SmartForm resource (for create/edit sections)
+
+```json
+{
+  "code": "{module}-form",
+  "type": "SmartForm",
+  "entity": "{MainEntity}",
+  "permission": "business.{app}.{module}.create",
+  "fields": [
+    { "name": "code", "component": "Input", "required": true, "validation": "Unique, auto-generated" },
+    { "name": "name", "component": "Input", "required": true },
+    { "name": "type", "component": "Select", "required": true, "source": "EntityTypeEnum" },
+    { "name": "description", "component": "TextArea", "required": false },
+    { "name": "parentId", "component": "EntitySelect", "source": "ParentEntity", "required": true },
+    { "name": "startDate", "component": "DatePicker", "required": true },
+    { "name": "isActive", "component": "Toggle", "default": true }
+  ],
+  "formLayout": {
+    "type": "tabs",
+    "tabs": [
+      { "code": "general", "label": {"fr": "Général", "en": "General"}, "fields": ["code", "name", "type", "description"] },
+      { "code": "details", "label": {"fr": "Détails", "en": "Details"}, "fields": ["parentId", "startDate", "isActive"] }
+    ]
+  }
+}
+```
+
+**MANDATORY for SmartForm:** `fields` with `component` type, `formLayout`
+
+## specification.uiWireframes[]
+
+```json
+{
+  "screen": "{module}-{section}",
+  "section": "{section}",
+  "description": "Description of the screen",
+  "mockupFormat": "ascii",
+  "mockup": "╔═══...",
+  "elements": ["DataGrid", "FilterBar", "Pagination", "CreateButton"],
+  "actions": ["filter", "sort", "create", "view-detail"],
+  "permissionsRequired": ["business.{app}.{module}.read"],
+  "componentMapping": [
+    { "wireframeElement": "DataGrid", "reactComponent": "SmartTable" },
+    { "wireframeElement": "FilterBar", "reactComponent": "SmartFilter" },
+    { "wireframeElement": "CreateButton", "reactComponent": "Button" }
+  ],
+  "layout": {
+    "type": "page",
+    "regions": [
+      { "id": "toolbar", "position": "top", "components": [
+        { "type": "FilterBar", "resourceRef": "{module}-filters" },
+        { "type": "ActionMenu", "resourceRef": "{module}-actions", "permission": "business.{app}.{module}.create" }
+      ]},
+      { "id": "content", "position": "main", "span": 12, "components": [
+        { "type": "SmartTable", "resourceRef": "{module}-grid" }
+      ]}
+    ]
+  }
+}
+```
+
+**REQUIRED fields:** `screen`, `mockup`, `elements`, `section`, `componentMapping`, `layout` are ALL mandatory.
+A wireframe without `componentMapping` or `layout` will FAIL validation in step 9.
+**layout.regions[].components[].resourceRef** MUST match a `sections[].resources[].code`.

package/templates/skills/business-analyse/references/validate-incremental-html.md

@@ -0,0 +1,55 @@
+# Validate: Incremental Interactive HTML Deployment
+
+> Reference for step-03d-validate.md — section 11-bis incremental HTML deploy after each module.
+
+## Why Incremental?
+
+The client doesn't have to wait until handoff to start reviewing.
+While module 2 is being specified, the client can already give feedback on module 1.
+Each incremental deployment OVERWRITES the previous HTML (latest state always).
+The FINAL deployment at step-05 (handoff) will include consolidation and handoff data.
+
+## Deployment Steps
+
+**Source:** `html/ba-interactive.html` (relative to skill root = `~/.claude/skills/business-analyse/html/`)
+
+**Destination:** `docs/business/{app}/business-analyse/v{version}/ba-interactive.html`
+
+### Step 1: Read Sources
+
+- Read the HTML template from skill directory
+- Read the master feature.json (application level — now updated with current module status)
+- Read EACH completed module's feature.json (including the one just specified)
+
+### Step 2: Build FEATURE_DATA Object
+
+> **Use the EXACT SAME mapping defined in step-05b-deploy.md and references/html-data-mapping.md.**
+> The mapping is identical — the only difference is that `moduleSpecs` only includes completed modules.
+> Modules not yet specified will NOT appear in `moduleSpecs` (their entry in `modules[]` will show `status: "pending"`).
+
+Follow step-05 section 9d "Step 2: Build FEATURE_DATA object" for the complete mapping pseudocode:
+- `metadata`, `cadrage`, `modules[]`, `dependencies[]` → from master feature.json
+- `moduleSpecs[moduleCode]` → only for modules with status "specified" (completed so far)
+- `consolidation` → empty `{ interactions: [], e2eFlows: [] }` (not yet consolidated)
+- `handoff` → empty `{}` (not yet handed off)
+
+### Step 3: Replace Placeholders in Template
+
+- Serialize the FEATURE_DATA object as JSON (2-space indentation)
+- Replace `{{FEATURE_DATA}}` with the serialized JSON
+- Replace `{{APPLICATION_NAME}}` → `{application_name}`
+- Replace `{{APPLICATION_ID}}` → `{feature_id}`
+- Replace `{{VERSION}}` → `{version}`
+- Replace `{{CREATED_AT}}` → `{ISO timestamp}`
+
+### Step 4: Write and Confirm
+
+```
+✓ Interactive HTML updated (incremental):
+  Path: docs/business/{app}/business-analyse/v{version}/ba-interactive.html
+  Modules included: {completedModules.length}/{totalModules} specified
+    - {completedModule1}: {uc_count} UCs, {br_count} BRs, {entity_count} entities
+    - {completedModule2}: ...
+  Remaining: {pendingModules.join(', ')} (will be added after specification)
+  → Client can open in browser to review completed modules now.
+```

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

@@ -69,7 +69,39 @@ mcp__smartstack__validate_conventions({ checks: ["tables"] })
 **DO NOT** continue to any subsequent step.
 **STOP the skill immediately.**
 
-## Step 2: Scan Existing Applications
+## Step 2a: Check for Review Mode
+
+If `{feature_description}` starts with `-review` (with or without extra text):
+
+1. Set `workflow_type = "review"`
+2. Scan `docs/business/` for the most recent application (by updatedAt)
+3. For the latest application version folder, look for `ba-review.json`
+4. If found:
+   - Store `review_json_path` = path to `ba-review.json`
+   - Store `application_name` from the master feature.json metadata
+   - Store `docs_dir` = directory containing `ba-review.json`
+   - Display:
+     ```
+     Review mode: found ba-review.json at {review_json_path}
+     Application: {application_name}
+     ```
+   - **SKIP all remaining steps** → Load `./step-06-review.md` directly
+5. If NOT found:
+   - Display error:
+     ```
+     ERROR: No ba-review.json found in docs/business/
+
+     To create one:
+     1. Open the ba-interactive.html in your browser
+     2. Make your corrections
+     3. Click "Sauvegarder corrections" button
+     4. Save the downloaded ba-review.json in the version folder
+        (e.g., docs/business/{app}/business-analyse/v1.0/ba-review.json)
+     5. Run /business-analyse -review again
+     ```
+   - **STOP EXECUTION**
+
+## Step 2b: Scan Existing Applications
 
 Scan `docs/business/` for existing business analysis features.
 
@@ -86,7 +118,7 @@ Scan `docs/business/` for existing business analysis features.
 existing_apps: array of { app, featureId, description, version }
 ```
 
-## Step 3: Auto-Detect New vs Update
+## Step 3: Auto-Detect New vs Update (skipped in review mode)
 
 Compare the user's `{feature_description}` with existing applications.
 
@@ -243,72 +275,7 @@ docs_dir: "docs/business/{app}/business-analyse/v{version}"
 > **The JSON Schemas MUST be present in the project alongside the generated feature.json files.**
 > Without schemas, feature.json files cannot be validated and have no structural reference.
 
-**Performance optimization:** Use cache file to avoid redundant deployments.
-
-### Cache-based deployment logic:
-
-**Step 1: Check deployment cache**
-
-Cache file location: `docs/business/{app}/business-analyse/.schema-cache.json`
-
-```
-IF EXISTS docs/business/{app}/business-analyse/.schema-cache.json:
-  Read cache file
-  IF cache.version == "{CLI_VERSION}" (from package.json):
-    Display: "Schemas already deployed ({CLI_VERSION}) - skipping"
-    SKIP deployment (trust cache)
-    → Go to Step 9
-  ELSE:
-    Display: "Schema version mismatch (cache: {cache.version}, current: {CLI_VERSION})"
-    Proceed to deployment
-ELSE:
-  Display: "Deploying schemas (first time)..."
-  Proceed to deployment
-```
-
-**Step 2: Deploy schemas (if needed)**
-
-Source: `schemas/` (relative to skill root = `~/.claude/skills/business-analyse/schemas/`)
-Destination: `docs/business/{app}/business-analyse/schemas/`
-
-```
-Read and Write each file (preserving directory structure):
-
-docs/business/{app}/business-analyse/schemas/
-├── feature-schema.json
-├── application-schema.json
-├── sections/
-│   ├── metadata-schema.json
-│   ├── discovery-schema.json
-│   ├── analysis-schema.json
-│   ├── specification-schema.json
-│   ├── validation-schema.json
-│   └── handoff-schema.json
-└── shared/
-    └── common-defs.json
-```
-
-**Total: 9 files to deploy.**
-
-**Step 3: Write cache file (after successful deployment)**
-
-```json
-{
-  "version": "{CLI_VERSION}",
-  "deployedAt": "{ISO timestamp}",
-  "schemas": [
-    "feature-schema.json",
-    "application-schema.json",
-    "sections/metadata-schema.json",
-    "sections/discovery-schema.json",
-    "sections/analysis-schema.json",
-    "sections/specification-schema.json",
-    "sections/validation-schema.json",
-    "sections/handoff-schema.json",
-    "shared/common-defs.json"
-  ]
-}
-```
+See [references/init-schema-deployment.md](../references/init-schema-deployment.md) for cache-based deployment logic (9 schema files, version-checked via `.schema-cache.json`).
 
 ## Step 9: Create Master feature.json
 

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

@@ -92,133 +92,10 @@ ELSE:
 > Skip organizational questions (adoption, change management, governance, KPIs).
 > Focus on functional decisions and technical challenges.
 
-### 3v. Vibe Coding — Lot 1: Problem & Scope
-
-**Goal:** Capture the core need and must-have features in a single batch.
-
-Ask via AskUserQuestion (2 questions):
-```
-question: "Quel est le besoin principal de cette application ?"
-header: "Besoin"
-options:
-  - label: "Automatiser un processus manuel"
-    description: "Remplacer des taches repetitives par une application"
-  - label: "Creer un outil manquant"
-    description: "Construire quelque chose qui n'existe pas encore"
-  - label: "Remplacer un outil existant"
-    description: "Remplacer un logiciel ou tableur qui ne convient plus"
-  - label: "Centraliser des donnees"
-    description: "Rassembler des informations dispersees en un seul endroit"
-```
-
-```
-question: "Quelles fonctionnalites sont indispensables pour la V1 ?"
-header: "Indispensable"
-multiSelect: true
-options:
-  → Generate 4 options dynamically from {feature_description}
-  → Each option = one functional area detected in the description
-  → Example for HR app: "Gestion des employes", "Saisie des heures", "Gestion des conges", "Rapports et exports"
-```
-
-**Store:**
-```yaml
-problem_type: string (from Q1)
-must_have_features: string[] (from Q2)
-```
-
-### 4v. Vibe Coding — Lot 2: Users & Permissions
-
-**Goal:** Determine access model (solo vs multi-user) and roles.
-
-Ask via AskUserQuestion:
-```
-question: "Qui va utiliser cette application ?"
-header: "Utilisateurs"
-options:
-  - label: "Moi seul"
-    description: "Application mono-utilisateur, je suis l'unique admin"
-  - label: "Quelques utilisateurs (2-10)"
-    description: "Petite equipe avec des roles differents"
-  - label: "Organisation (10+)"
-    description: "Deploiement a l'echelle d'une equipe ou entreprise"
-```
-
-```
-IF "Moi seul":
-  Auto-set:
-    applicationRoles = [{ role: "{App} Admin", level: "admin", permissionPattern: "business.{app}.*" }]
-    stakeholders = [{ role: "Developpeur", function: "Product owner et developpeur", involvement: "decision-maker", tasks: ["Toutes les operations"] }]
-  → SKIP role question
-
-IF "Quelques utilisateurs" or "Organisation":
-  Display standard 4-tier roles table, then ask:
-  question: "Ces 4 roles (Admin, Manager, Contributor, Viewer) conviennent-ils ?"
-  header: "Roles"
-  options:
-    - label: "Oui, parfait"
-      description: "Utiliser les 4 roles standards"
-    - label: "Personnaliser"
-      description: "Modifier les roles ou permissions"
-
-  Auto-set stakeholders from user type:
-    IF "Quelques utilisateurs":
-      stakeholders = [
-        { role: "Administrateur", function: "Gere le systeme et les utilisateurs", involvement: "decision-maker", tasks: ["Configuration", "Gestion utilisateurs"] },
-        { role: "Utilisateur", function: "Utilise le systeme au quotidien", involvement: "end-user", tasks: ["Saisie", "Consultation"] }
-      ]
-    IF "Organisation":
-      stakeholders = [
-        { role: "Administrateur", function: "Gere le systeme", involvement: "decision-maker", tasks: ["Configuration", "Gestion"] },
-        { role: "Manager", function: "Supervise et valide", involvement: "approver", tasks: ["Validation", "Reporting"] },
-        { role: "Utilisateur", function: "Operations quotidiennes", involvement: "end-user", tasks: ["Saisie", "Consultation"] }
-      ]
-```
-
-### 5v. Vibe Coding — Lot 3: Technical Challenges
-
-**Goal:** Identify technical risks specific to AI-assisted development.
-
-Ask via AskUserQuestion:
-```
-question: "Quels defis techniques anticipez-vous ?"
-header: "Defis"
-multiSelect: true
-options:
-  - label: "Regles metier complexes"
-    description: "Calculs, validations ou workflows difficiles a specifier"
-  - label: "Volume de donnees"
-    description: "Grandes quantites de donnees a gerer ou migrer"
-  - label: "Integrations externes"
-    description: "APIs, services tiers ou synchronisation avec d'autres systemes"
-  - label: "Interface riche"
-    description: "Ecrans avec beaucoup d'interactions, graphiques ou visualisations"
-```
-
-**Auto-infer cadrage data (DO NOT ask these — derive from answers):**
-
-```yaml
-cadrage.problem: "{feature_description} — {problem_type}"
-cadrage.asIs: "Aucun systeme en place" | "Processus manuel existant" | "Outil existant a remplacer"
-  → Derived from Lot 1 problem_type
-cadrage.toBe: "Application {application_name} couvrant: {must_have_features joined}"
-cadrage.trigger: "Projet vibe coding initie par le developpeur"
-cadrage.risks:
-  → Map each selected technical challenge to a RISK entry:
-    - "Regles metier complexes" → RISK-001, type: "technical", probability: "medium", impact: "high"
-    - "Volume de donnees" → RISK-002, type: "technical", probability: "low", impact: "medium"
-    - "Integrations externes" → RISK-003, type: "technical", probability: "medium", impact: "medium"
-    - "Interface riche" → RISK-004, type: "technical", probability: "low", impact: "low"
-  → Add mitigation for each: "Specification detaillee dans step-03 + generation iterative"
-cadrage.acceptanceCriteria:
-  - { id: "AC-001", criterion: "Toutes les fonctionnalites must-have implementees et fonctionnelles", validated: false }
-  - { id: "AC-002", criterion: "Application deployable et utilisable", validated: false }
-cadrage.globalScope:
-  mustHave: {must_have_features}
-  shouldHave: [] → Determined later in coverage matrix
-  couldHave: [] → Determined later in coverage matrix
-  outOfScope: []
-```
+See [references/cadrage-vibe-coding.md](../references/cadrage-vibe-coding.md) for the complete 3-lot questionnaire:
+- **Lot 1 (3v):** Problem & Scope — capture core need + must-have features
+- **Lot 2 (4v):** Users & Permissions — access model (solo/team/org) + roles
+- **Lot 3 (5v):** Technical Challenges — risks specific to AI-assisted dev + auto-inferred cadrage data
 
 **After Lot 3:** Go directly to **section 9 (Coverage Matrix)**.
 
@@ -389,73 +266,7 @@ If a feature is in mustHave → it MUST have at least one UC in the correspondin
 
 Use ba-writer to enrich master feature.json. **Follow the STRUCTURE CARDS below exactly.**
 
-> **STRUCTURE CARD: cadrage.stakeholders[]**
-> ```json
-> {
->   "role": "Fleet Manager",
->   "function": "Manages daily fleet operations",
->   "involvement": "decision-maker",
->   "tasks": ["Monitor vehicles", "Approve repairs", "Export reports"],
->   "frequency": "Daily",
->   "painPoints": ["Manual tracking in spreadsheets", "No real-time visibility"]
-> }
-> ```
-> **MANDATORY fields:** `role`, `function`, `involvement`, `tasks`
-> **involvement values:** `approver`, `decision-maker`, `consulted`, `informed`, `end-user`
-> **FORBIDDEN fields:** Do NOT use `expertise`, `systemRole`, `description` (use `function` instead).
-
-> **STRUCTURE CARD: cadrage.applicationRoles[]**
-> ```json
-> {
->   "role": "{App} Admin",
->   "description": "Full access to all modules",
->   "level": "admin",
->   "permissionPattern": "business.{app}.*"
-> }
-> ```
-> **MANDATORY fields:** `role`, `level`, `permissionPattern`
-> **level values:** `admin`, `manager`, `contributor`, `viewer`
-> **FORBIDDEN fields:** Do NOT use `permissions` (use `permissionPattern`), `isDefault`.
-
-> **STRUCTURE CARD: cadrage.risks[]**
-> ```json
-> {
->   "id": "RISK-001",
->   "type": "business|technical|organizational",
->   "description": "CSV data may contain duplicates and errors",
->   "probability": "high|medium|low",
->   "impact": "high|medium|low",
->   "priority": "critical|medium|low",
->   "mitigation": "Data cleaning phase before import, detailed error reports"
-> }
-> ```
-> **MANDATORY fields:** `id` (pattern: RISK-NNN), `type`, `description`, `mitigation`
-> **FORBIDDEN fields:** Do NOT use `risk` (name), `severity`. Use `id` + `description` + `priority`.
-
-> **STRUCTURE CARD: cadrage.acceptanceCriteria[]**
-> ```json
-> { "id": "AC-001", "criterion": "All must-have features delivered and tested", "validated": false }
-> ```
-> **MANDATORY:** This section must NOT be omitted.
-
-> **STRUCTURE CARD: cadrage.coverageMatrix[]**
-> ```json
-> {
->   "item": "User management with CRUD",
->   "category": "mustHave|shouldHave|couldHave|outOfScope|implicit",
->   "module": "Users",
->   "ucRef": "UC-UM-001",
->   "notes": "Foundation module, must be implemented first"
-> }
-> ```
-> **MANDATORY fields:** `item`, `category`, `module`
-> **category values:** `mustHave`, `shouldHave`, `couldHave`, `outOfScope`, `implicit` (camelCase)
-> **FORBIDDEN fields:** Do NOT use `id`, `feature`, `priority`. Use `item` + `category`.
-
-> **STRUCTURE CARD: cadrage.codebaseContext** — Must be a string, NOT an object.
-> ```json
-> "codebaseContext": "Greenfield project, no existing entities. SmartStack 2.1.0 with Extensions DbContext."
-> ```
+See [references/cadrage-structure-cards.md](../references/cadrage-structure-cards.md) for exact JSON formats of: `stakeholders[]`, `applicationRoles[]`, `risks[]`, `acceptanceCriteria[]`, `coverageMatrix[]`, `codebaseContext`.
 
 ```
 ba-writer.enrichSection({

package/templates/skills/business-analyse/steps/step-03a-data.md

@@ -245,55 +245,12 @@ Display to client:
 
 **Prerequisites:** Entity attributes must be defined (from step 6) OR anticipated from decomposition.
 
-**Inference rules - Entity attribute → SmartTable column:**
-
-| Attribute Type | Column Format | Sortable | Filterable | Notes |
-|---|---|---|---|---|
-| string + unique | text | yes | yes | clickAction: navigate:detail |
-| string | text | yes | yes | — |
-| enum / status | badge | yes | yes (multi-select) | colorMap from lifeCycles if exists |
-| FK:Entity | text (join .name) | yes | yes (entity-select) | Display related entity name |
-| decimal | currency | yes | no | — |
-| int | number | yes | no | — |
-| datetime | date-relative | yes | yes (date-range) | — |
-| bool | boolean | yes | yes (toggle) | — |
-| text (long) | — | no | no | Hidden in table, visible in detail |
-
-**Inference rules - Entity attribute → SmartForm field:**
-
-| Attribute Type | Component | Required from | Notes |
-|---|---|---|---|
-| string | Input | entity.required | — |
-| string (multiline) | TextArea | entity.required | rows: 4 |
-| enum | Select | entity.required | source: enum name |
-| FK:Entity | EntitySelect | entity.required | source: target entity, searchable |
-| decimal | NumberInput | entity.required | — |
-| int | NumberInput | entity.required | — |
-| datetime | DatePicker | entity.required | — |
-| bool | Toggle | — | default: false |
-
-**Auto-generated sections per featureType:**
-
-| featureType | Sections generated |
-|---|---|
-| data-centric | list, create, detail |
-| workflow | list, create, detail, edit |
-| integration | list, detail, config |
-| reporting | dashboard |
-| full-module | list, create, detail, edit, dashboard |
-
-**For each auto-generated section:**
-
-1. **list section:** SmartTable with all non-long-text attributes as columns (convention or columnDefs based on depth), actions = [view, edit, delete], defaultSort = { createdAt, desc }
-2. **create section:** SmartForm with all writable attributes as fields, component inferred from type
-3. **detail section:** DetailCard with all attributes + child SmartTable for each 1:N relationship
-4. **edit section:** Same as create but pre-filled (mode: edit)
-5. **dashboard section:** Trigger 3d (dashboard specification)
-
-**If entity has a status/enum field AND lifeCycles exists:**
-- list section: status column gets `format: badge`, `colorMap: stateMachine:{Entity}`
-- list section: rowActions get `showWhen` conditions based on state machine transitions
-- detail section: add StatusBadge resource + transition action buttons
+See [references/spec-auto-inference.md](../references/spec-auto-inference.md) for complete inference rules:
+- Entity attribute → SmartTable column mapping (9 type rules)
+- Entity attribute → SmartForm field mapping (8 type rules)
+- Auto-generated sections per featureType (5 types)
+- Section generation rules (list, create, detail, edit, dashboard)
+- Status/lifecycle enhancement rules
 
 Write auto-generated sections to `specification.sections[]` via ba-writer.enrichSection()