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, ACT-002, ACT-006 — ACT-003..005 retired). 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, that screen entity refs resolve, and that a kanban is a view of its list and not its own section (XD-001..006). 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, duplicate one, collide with the SmartStack Core catalogue, re-implement a platform capability (file storage, search, …), or model a PERSON without the auth_Users extension link (CODE-007, err — fail-closed mirror of C-4/DM-018c) (CODE-001..007). Reads the module's `entité.md`, scans `src/*.Domain/**/*.cs`, checks the static Core + capability catalogues (no scan needed), 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, Core-entity duplication, platform-capability steering, no file content in the MCD, derived declarations, and code-like classification — near-miss Code-pattern declarations + unclassified synonym attributes (Référence/Numéro/Matricule…) — plus, moved LEFT of the readiness GO: index integrity (every **Index** column exists, never TenantId in a unique — the scaffolder's own error, six phases earlier), complete attribute types (string maxLength, decimal precision/scale, enum values), no framework field listed, tenancy declared (**Portée** → tenantMode), and the model retaining what the BA no longer uses — dead columns (attribute grain) and leftover state values (value grain), and the business TEST DATASET `jeu-de-test.md` — present where the module carries business entities, coherent with the MCD, the rules, the actors and the cited modules' datasets, never on a reference table, every Flow status represented (DM-001..032). Reads the module's `entité.md` + `use-case.md` + `règles-métier.md` (+ `jeu-de-test.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, hierarchy code distinctness (MENU-001..008). 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 — checks across 7 dimensions: structure, completeness, clarity, consistency, traceability, feasibility, slices + per-page contract + custom-action contract + related-tabs contract (PRD-103..105 + PRD-108 route families, the 360 view) + the file-upload guard (PRD-107 — no `type:file` custom action; attachments pattern instead) + list elegance (PRD-109 column visibility budget, PRD-110 filter tiers) + form/detail sections (PRD-111 well-formed `sections[]`, PRD-112 grouping authored where warranted) + view-set completeness (PRD-114 a mutable list declares its form/detail siblings) + cards representation folding (PRD-117 viewModes on the list pagespec, never a standalone SmartCard pagespec) + quick segments (PRD-116 cohort tabs: labelled, defaulted, wirable) + sort/density/empty-state coherence (PRD-118) + detail summary integrity (PRD-119) + form lifecycle (PRD-120 well-formed status-anchored `lifecycle` block — CLI `create-prd/cli/derive-lifecycle --mode check`; PRD-121 lifecycle authored where the entity lives one) + action-permission binding (PRD-128 — a kind:api action's permission roots at its OWN module.section, section grain; engine = derive-action-specs' blocking rejected[]) + business-rule links (PRD-129 every enforceable rule linked / PRD-130 cited codes resolve — CLI `create-prd/cli/derive-rule-links --mode check`) + use-case coverage (PRD-131 every user-goal UC reaches the pagespecs — CLI `create-screen/cli/derive-uc-coverage`) + coded-entity parity (PRD-132 entité.md `**Code pattern**` ⇔ pagespec `codedEntity` flag both ways — facets `label`/`supplied` included, unusable line = err, unparsable near-miss declaration (table cell / wrong casing) = err, supplied+{SEQ} = warn — CLI `ba-develop/cli/derive-code-specs --mode check`) + tab budget (PRD-133 — rendered strip ≤ 7 warn / ≤ 9 err, band cartouches excluded, unified fiche honoured; same derive-related-tabs run, RTV-108) + summary demanded (PRD-134 — ≥ 4 rendered strip triggers and no `summary` = warn, CLI `create-prd/cli/derive-detail-summary --mode check`) + kanban representation (PRD-135 — the `kanban` block folded on the LIST pagespec: columns ⊆ status enum verbatim, BR Flow ⇄ transitions parity both ways, viewModes coherence, no standalone kanban pagespec, labels seeded — CLI `create-prd/cli/derive-kanban-spec --mode check`). 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. User Story / Acceptance Criteria checks live in `/ba-audit-use-cases` (UC-012..018) — the PRD no longer carries US/AC sections; AC live under each UC in `use-case.md`. 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 9 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, reference integrity, data-scope coherence, derived-lookup freshness, permission-floor mirror freshness, and unmaterialized `team`/`custom` Portées said out loud (RBAC-001..010). Reads the module `rbac.md`, the app `acteur.md` and the section `use-case.md`; RBAC-008/009 reuse the `derive-lookup-grants` and `derive-permission-floor` engines by direct import (their shared source factories + drift layer, never a spawn), 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, and — at app/project scope only — cross-application similarity (warn) (BR-001..012). 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.

ONE deterministic pass over the whole `.smartstack/ba/` corpus — the audit-ba CLI loads every doc once, runs the ~115 MECHANICAL audit rules of all 11 dimensions (menu, sections, actors, use-cases, rules, rbac, data-model, screens, cross-dimension, cross-ref-code, sources), publishes the parse totals, writes every `_audit/<dim>.md` verdict and `_audit/audit-ba.json`, and FAILS CLOSED on parser/control divergence (exit 3 « parsing suspect »). The LLM's only job here is arbitrating the compact `judgmentNeeded[]` excerpts (~9 judgment rules + hybrid arbitrations) — NEVER re-reading the corpus. Use for « audite le BA », « audit complet », « relance l'audit après mise à jour des skills ». Replaces the per-module LLM audit campaign (394M tokens on ImmoHub) for every mechanical rule.

Audits the screen specs of a `.smartstack/ba/` section — coverage, entity refs, SmartComponent coherence, navigation integrity, related-tabs (360 view), home-page hierarchy, UC traceability, custom-actions structure, coded-entity code fields, attachment screens bound to a metadata entity, list column/filter inflation, form field grouping (Section/Onglet), create-form phase discipline, mandatory SmartSectionHome on multi-resource sections, observable action results, dashboard/entity binding, instance-verb confirmation, use-case coverage — every user-goal UC served by a surface, and the shared tab-bar budget — inner + related tabs ≤ 7/9, band cartouches excluded (SCR-001..025). Reads the section `screen.md` plus the module `entité.md`/`rbac.md` and the section `use-case.md`; the related-tab rules (SCR-009/014) and the tab-bar budget (SCR-025 ← RTV-009) run DETERMINISTICALLY through the derive-related-tabs CLI, the UC-coverage rule (SCR-024) through the derive-uc-coverage CLI. 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 sections, sibling state-variant sections (same primary subject), cross-module and cross-app duplication (SEC-001..008 — SEC-006 retired, 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 client-sources registry (`.smartstack/sources/`, SIBLING root of the BA tree) and the `SRC-NNN §n` citations the BA specs carry — registry coherence, source completeness, web-extract contract, citation resolution, scope coverage, dead and superseded sources (SRC-001..007, all mechanical, fail-closed: « no citation » is only acceptable when no in-scope source exists). Reads the registry through the shared engine, writes verdicts to `_audit/sources.md` (project root) and `<APP>/<MODULE>/_audit/sources.md`. Run after `/ba-create-sources` 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, acceptance-criteria contract, exception ↔ AC parity, and — at app/project scope only — cross-application similarity (warn) (UC-001..023). Reads the section `use-case.md` files + the app `acteur.md` + the module `entité.md` (for AC entity refs); the exception-parity rule (UC-022) runs DETERMINISTICALLY through the derive-uc-coverage CLI. Writes a verdict to `<MODULE>/_audit/use-case.md`. Run after `/ba-create-use-case` or as part of pre-dev readiness.

Change request on a FINISHED business-analysis scope — add or modify ONE element after the fact (a use case, a business rule, an actor, a permission row, an entity attribute, an entity, a screen) without re-running a whole phase. Router + one playbook per artefact (kinds/<kind>.md — analyse the request, challenge it, author, verify, propagate, audit). Runs the read-only derive-change-impact CLI, which allocates the next free code, detects near-duplicates, fails closed on missing prerequisites and returns the ORDERED downstream checklist (rules, RBAC, screens, pagespec deltas, derive CLIs, audits, /ba-develop re-entries), then re-parses the owner document after the Write. Never deletes (that is /ba-reconcile-menu), never re-runs /ba-create-prd on a module that already has a PRD, never invents a code.

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.

After Phase 1 (menu), produces a BA creation order plan — a topologically-sorted ordering of modules showing which modules to work on first across all BA phases (actors → use cases → rules → RBAC → data model → screens). Conversational: reads module contexts, infers inter-module dependencies, asks the user to validate, then writes the plan. Run after /ba-create-menu, before /ba-create-actors.

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: first has the user choose the application → module to work on, then reads that scope's menu context, actors and use cases, proposes rules, asks the user to validate, then writes the file. Writes stay inside the selected application; similar rules found in other applications are reported, never modified. 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, researches the domain, drafts the next level, self-audits the draft, then proposes it in 3 tiers (Obligatoire / Suggestion / Élargissement), asks the user to validate, and persists every node through the colocated `menu-node` CLI (add / rename / delete — deterministic: folder + `index.md` + six placeholders, the parent `## Enfants` spliced with its anchor intact, the downstream codes, permission paths and pagespec references rewritten on a rename, `previousCodes=` recorded). Also the ENRICH entry point for one node added to a finished menu. 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` (product framing: context, goals, non-goals, MoSCoW, technical constraints), three phase slices, per-screen `pagespecs/*.md` (each carrying a machine spec block), and `claude.md`. User stories and acceptance criteria are NOT in the PRD — they live under each UC in `<section>/use-case.md` as the test-scaffolder's input. 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: first has the user choose the application → module to work on, then reads that scope's menu context, actors, use cases and rules, proposes coverage per actor × action, asks the user to validate, then writes the file. Writes stay inside the selected scope. 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: first has the user choose the application → module (→ section) to work on, then reads the section's data model / RBAC / use cases, proposes screens, asks the user to validate, then writes the file. Writes stay inside the selected scope. Run after the data model (`/ba-create-data-model`); hands off to PRD generation (`/ba-create-prd`).

Ingests the CLIENT-PROVIDED source material of a project (cahiers des charges, PDF, Word/Excel, notes, emails, screenshots — and RETAINED web findings) into the committed registry `.smartstack/sources/`: each source gets a stable greppable code `SRC-NNN`, judgment tags, a precise summary and §-anchored extracts, so every BA phase can pull exactly what it needs and CITE it (`- **Sources** : SRC-001 §2`) in the written spec. Conversational: the CLI fingerprints/dedups/extracts deterministically, the model reads and judges, the user validates tags and scope. Run any time — before or during the BA phases; the audit dimension `sources` (SRC-001..007) keeps the registry and the citations honest.

Phase 6.5 of business analysis (OPTIONAL, after the data model). Authors the module's business TEST DATASET — `jeu-de-test.md` — 5 to 8 realistic, FICTITIOUS rows per business entity, validated by the client with THEIR vocabulary (their vehicles, sites, statuses). One dataset, every consumer — the seed of dev/test/qual (the second seed tier, next to the setup rows of `**Valeurs initiales**`), the fixtures of the acceptance tests, the UAT, and a BA simulator that shows the client's own rows instead of hash noise. Conversational — reads entité.md, use-case.md, règles-métier.md and the client sources, proposes rows in 3 tiers, the client corrects, the skill writes the file and runs the deterministic checker. Rows are cited across modules by KEY, never copied. Run after `/ba-create-data-model`, before or after `/ba-create-screen`; audited by `/ba-audit-data-model` (DM-029..032).

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. Writes stay inside the pinned scope; similar UCs found in other applications are reported, never modified. Run after actors (`/ba-create-actors`), before business rules (`/ba-create-business-rules`).

Autonomous BA pipeline orchestrator. Chains phases 2-7 (actors → use cases → rules → RBAC → data model → screens) module by module in wave order, each phase running as a subagent with the create → audit → fix cycle. Reads ba-order.json for wave ordering. Run after /ba-create-ba-order (Phase 1.5).

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`.

Reconciles the `.smartstack/ba/` menu tree (sections/modules currently in `index.md`) against the codes embedded in downstream documents (`use-case.md`, `screen.md`, `règles-métier.md`, `rbac.md`). Detects RENAMES (heuristic) and DELETIONS, asks the user to validate the diff, then rewrites the downstream docs (drops stranded UC/SCR/BR/RBAC blocks, scrubs body references, renames codes in place). Idempotent. Run AUTOMATICALLY as Phase 0.5 of `/ba-loop` whenever the menu was modified after content was created — never skip a modified menu, always audit and correct.

Backfills the i18n translations of an already-written PRD. Scans a module's `pagespecs/*.md` for untranslated `i18nKeys` placeholders of the form `"[en] <fr>"` / `"[it] <fr>"` / `"[de] <fr>"` (the abandoned "author FR, defer the rest" convention), translates each from its authoritative FR sibling into idiomatic en/it/de, and rewrites the JSON blocks in place — preserving every other value. Also fills FR-only `form.section.*` labels (the derive-form-sections backfill seeds fr and leaves en/it/de absent — PRD-111). Conversational: reports what it found, asks the user to validate the translations (Swiss house terms), then writes. Run when `/ba-audit-prd` PRD-089/PRD-111 or `DEV-UI-029` flags placeholders in an existing PRD; re-scaffold the Frontend afterwards to regenerate the shipped bundle.