Annuaire des skills Business AnalyseBusiness Analysis skills directory

Audits the actors of a `.smartstack/ba/` project — existence, duplicate names (case-insensitive), missing type (ACT-001..006). Actors are PROJECT-scoped, so it reads every `<APP>/acteur.md` plus the menu tree, applies the rules, and writes a verdict to `_audit/actors.md` at the project root. Run after `/ba-create-actors` or as part of pre-dev readiness.

Cross-dimension coherence audit of one `.smartstack/ba/` module — verifies that data-model fields with state semantics have matching business rules, use cases and screens, that use-case actors exist in RBAC, and that screen entity refs resolve (XD-001..005). Reads the module's `entité.md`, `règles-métier.md`, `use-case.md`, `rbac.md` and its section `screen.md` files together, writes a verdict to `_audit/cross-dimension.md`. Run after the per-dimension audits or as part of pre-dev readiness.

Cross-references the BA data model of a module against the EXISTING project code — detects entities that extend an existing class, reference a Core/existing entity as FK, or duplicate one (CODE-001..004). Reads the module's `entité.md`, scans `src/*.Domain/**/*.cs`, writes a verdict to `_audit/cross-ref-code.md`. Run after `/ba-create-data-model` or as part of pre-dev readiness.

Audits the conceptual data model (MCD) of a `.smartstack/ba/` module — attributes, FK integrity, cycles, naming, orphans, traceability, indexes, implicit FKs, unreferenced lookups, classification conventions, code-pattern numbering (DM-001..017). Reads the module's `entité.md` + `use-case.md` + `règles-métier.md`, writes a verdict to `<MODULE>/_audit/entité.md`. Run after `/ba-create-data-model` or as part of pre-dev readiness.

Audits the menu (Application / Module) of a `.smartstack/ba/` project — module semantics, cross-app duplicates, SmartStack Core collisions, orphans/empty, out-of-scope coherence (MENU-001..005). Reads the tree, writes a verdict to `_audit/menu.md`. Run after `/ba-create-menu` or as part of pre-dev readiness.

Audits the on-disk PRD of ONE module in a `.smartstack/ba/` project — the largest audit (70 checks across 7 dimensions: structure, completeness, clarity, consistency, traceability, feasibility, slices + per-page contract + custom-action contract). Reads `prd.md`, the three `prd.*.md` slices and the `pagespecs/*.md` blocks against the upstream BA docs, then writes a verdict to `_audit/prd.md` carrying the dev-readiness gate (`GO|NO-GO`). GO is the gate `/ba-develop` reads. Run after `/ba-create-prd`.

Pre-development readiness orchestrator for a `.smartstack/ba/` project. Does NOT re-run any dimension's rules — it reads the per-dimension verdicts already written under `_audit/*.md`, aggregates them across every module and the 8 dimensions, and writes a project-readiness summary with an overall GO / NO-GO. Run after the `/ba-audit-*` dimension audits, before `/ba-create-prd` + development.

Audits the RBAC permission matrix of a `.smartstack/ba/` module — minimum permissions, segregation of duties, actor coverage and reference integrity (RBAC-001..005). Reads the module `rbac.md`, the app `acteur.md` and the section `use-case.md`, writes a verdict to `_audit/rbac.md`. Run after `/ba-create-rbac` or as part of pre-dev readiness.

Audits the business rules of a `.smartstack/ba/` module — completeness, conflicts, redundancy, example quality, entity/UC references, per-ruleType edge-case coverage (BR-001..010). Reads `règles-métier.md` plus the module's `use-case.md` and `entité.md`, writes a verdict to `_audit/règles-métier.md`. Run after `/ba-create-business-rules` or as part of pre-dev readiness.

Audits the screen specs of a `.smartstack/ba/` section — coverage, entity refs, SmartComponent coherence, navigation integrity, related-tabs, home-page hierarchy, UC traceability, custom-actions structure (SCR-001..013). Reads the section `screen.md` plus the module `entité.md`/`rbac.md` and the section `use-case.md`, writes a verdict to `_audit/screen.md`. Run after `/ba-create-screen` or as part of pre-dev readiness.

Audits the menu sections of a `.smartstack/ba/` project — module-section coverage, duplicate/ambiguous/empty sections, cross-module and cross-app duplication (SEC-001..006, XAPP-001..003). Reads the section nodes under a module, writes a verdict to `_audit/sections.md`. Run after `/ba-create-menu` or as part of pre-dev readiness.

Audits the use cases of a `.smartstack/ba/` module — completeness, step quality, vague language, scope respect, actor references, redundancy (UC-001..012). Reads the section `use-case.md` files + the app `acteur.md`, writes a verdict to `<MODULE>/_audit/use-case.md`. Run after `/ba-create-use-case` or as part of pre-dev readiness.

Phase 2 of business analysis. Defines the project's actors (roles) that interact with the applications, and writes them to `acteur.md` at the Application level under `.smartstack/ba/`. Conversational: reads the menu tree and existing actors, proposes coverage per app, asks the user to validate, then writes the file. Run after the menu (`/ba-create-menu`), before use cases.

Phase 4 of business analysis. Captures, classifies and elaborates structured business rules (with concrete valid + invalid examples) and writes them to `règles-métier.md` under `.smartstack/ba/`. Conversational: reads the menu tree, actors and use cases, proposes rules, asks the user to validate, then writes the file. Run after use cases (`/ba-create-use-case`), before RBAC.

Phase 6 of business analysis. Builds the conceptual data model (MCD) of each business module — entities, attributes, computed formulas, relationships and indexes — and writes it to `entité.md` at the Module level under `.smartstack/ba/`. Conversational: reads the menu tree plus the module's use cases and business rules, deduces the entities, asks the user to validate, then writes the file. Run after RBAC (`/ba-create-rbac`), before screens (`/ba-create-screen`).

Phase 1 of business analysis. Builds the Application → Module → Section → Resource menu hierarchy for a project as a folder tree of `index.md` files under `.smartstack/ba/`. Conversational: reads the current tree, proposes the next level, asks the user to validate, then writes the files. Run this first, before defining actors, use cases, rules, RBAC, data model, or screens.

Generates a phased development plan ordering modules by their cross-module data-model dependencies. Reads entité.md across selected applications, builds a dependency graph, topological-sorts into parallel development waves, and writes dev-plan.md. Invoke between the BA audit phase and /ba-develop.

Synthesises the upstream BA `.md` tree of ONE module (menu, actors, use cases, business rules, RBAC, data model, screens) into a Product Requirements Document on disk: `prd.md` (framing + user stories), three phase slices, per-screen `pagespecs/*.md` (each carrying a machine spec block), and `claude.md`. The output drives development through `/ba-develop`. Run after the BA phases (and `/ba-audit-pre-dev` GO), before development.

Phase 5 of business analysis. Defines the RBAC permission matrix (who can do what) for each module and writes it to `rbac.md` at the Module level under `.smartstack/ba/`. Conversational: reads the menu tree, actors, use cases and rules, proposes coverage per actor × action, asks the user to validate, then writes the file. Run after business rules (`/ba-create-business-rules`), before the data model (`/ba-create-data-model`).

Phase 7 of business analysis (the LAST BA phase). Designs the UI screens of each section as SmartComponents (SmartListView, SmartForm, SmartDashboard, SmartKanban, SmartSectionHome, …) and writes them to `screen.md`, authoritative at the Section (and Resource) level under `.smartstack/ba/`. Each screen binds one entity, a permission and the use cases it serves. Conversational: reads the section's data model / RBAC / use cases, proposes screens, asks the user to validate, then writes the file. Run after the data model (`/ba-create-data-model`); hands off to PRD generation (`/ba-create-prd`).

Phase 3 of business analysis. Turns each section's scope into Cockburn-style business use cases (primary actor, preconditions, main / alternative / exception flows, postconditions), written to `use-case.md` at the Section level under `.smartstack/ba/`. Conversational: first has the user choose the application → module → section to work on, then reads that section's actors and existing use cases, proposes use cases, asks the user to validate, then writes the file. Run after actors (`/ba-create-actors`), before business rules (`/ba-create-business-rules`).

Pass 2 of the optional Two-Pass fast-modeling path. Take a SINGLE inventory item flagged `moderate` or `complex` (from a scope's `_inventory.md`) and expand it into a fully-detailed use case (Cockburn flows, pre/postconditions) or business rule (expression + concrete valid/invalid examples), then write it into the authoritative doc (`use-case.md` for a UC at its section, `règles-métier.md` for a rule at its scope) under `.smartstack/ba/`. Reads the inventory + the authoritative doc + `acteur.md`; writes by appending/Editing the doc while preserving every existing item.

Pass 1 of the optional Two-Pass fast-modeling path. In ONE fast pass, emit a lightweight inventory of ALL candidate use cases + business rules for a scope (application / module / section), each flagged `simple | moderate | complex` so a detail pass can route effort. Reads the `.smartstack/ba/` menu tree + actors for context and writes a planning checklist to `.smartstack/ba/<scope>/_inventory.md`. Hands off to `/ba-modeling-detail`.