SmartStackDocs v5.24.0

Catalogue complet des skillsComplete skill catalogue

En brefIn short

SmartStack CLI déploie 114 skills dans ~/.claude/skills/. Les skills de premier niveau s'invoquent dans Claude Code via /<nom> ; les sous-skills (par ex. development/backend/*) sont chargés par leur skill parent. La liste ci-dessous est générée automatiquement à partir du frontmatter SKILL.md de chaque skill — toujours synchronisée avec ce qui est réellement déployé.

SmartStack CLI deploys 114 skills to ~/.claude/skills/. Top-level skills are invoked from Claude Code via /<name>; sub-skills (e.g. development/backend/*) are loaded by their parent skill. The list below is auto-generated from each skill's SKILL.md frontmatter — always in sync with what is actually deployed.

ℹ️ Quelques skills sont internes au dépôt de la CLI (maintenance de l'outillage, pas des projets clients) : check-version, cli-app-sync, smoke-generation, utils. Ils apparaissent dans le catalogue mais ne servent pas au développement d'une application. ℹ️ A few skills are internal to the CLI repository (tooling maintenance, not client projects): check-version, cli-app-sync, smoke-generation, utils. They show up in the catalogue but are not used to build an application.

Comment lire la listeHow to read the list

  • /slug : nom de la slash-command à taper dans Claude Code./slug: slash-command name to type in Claude Code.
  • Description : première phrase du frontmatter description: ; le texte complet s'affiche au survol et reste cherchable par le filtre.Description: first sentence of the description: frontmatter; the full text shows on hover and stays searchable through the filter.
  • args : argument-hint indicatif quand la skill en attend.args: argument hint when the skill expects parameters.
114Skills
10Agents
6Hooks
12Commandes CLICLI commands

Tous les skills

All skills

Toutes les commandes /<nom> déployées par ss install, groupées par phase. Le filtre cherche dans le nom, la phase et la description.

Every /<name> command deployed by ss install, grouped by phase. The filter searches the name, the phase and the description.

api 1

  • /backend-core-lookups Scaffold (or retire) the core-lookups BRIDGE of a generated client app — the read-only /api/core/{users,roles,departments,job-titles,offices,languages,groups…

business-analyse 32

  • /ba-audit-actors 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).
  • /ba-audit-cross-dimension 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, that a kanban is a view of its list and not its own section, that transition-captured attributes are not asked at creation, that a dated child can be born, and that a 360 related tab onto a ≥ confidentiel entity (lib/ba-sensitivity) carries its backticked permission AND its list target — the « first 4 attributes » fallback is the leak (XD-001..009).
  • /ba-audit-cross-ref-code 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), and — ownership at the APPLICATION grain (2026-10-03) — reads WHO owns a homonymous class (own module ok, same application other module err, another application warn → reuse) and whether the columns asked of another application are carried by `<APP>/demande-extension.md` (CODE-008, err; pending/refused request = development frozen, warn) — and, data sensitivity at the entity grain (lib/ba-sensitivity), whether REACHING a ≥ confidentiel entity of another application (cross-module FK, 360 tab, 4-segment permission) is carried by an ACCESS request in the same document (CODE-009, err; pending/refused = frozen, warn) (CODE-001..009).
  • /ba-audit-data-model 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 — and, since 2026-10-03, the DEFINITION CARTOUCHE of every entity (**Description** everywhere, **Périmètre** on business entities, **Hors périmètre** optional — DM-033), the cross-APPLICATION equivalence of entity definitions (DM-034, hybrid: candidates by name, by definition, by shared attributes or by the same Core artefact, settled mechanically when a Hors périmètre names the other side, judged otherwise), the intra-application duplicate — one declaring module per application (DM-035, err) — and the DATA SENSITIVITY at the entity grain (lib/ba-sensitivity): the `**Sensibilité**` declaration due where a name or attribute looks sensitive + its near-miss (DM-036), the split doctrine — a sensitive attribute inside an interne entity is a split, never a column tag; `public` on a person / sensitive entity is an err (DM-037), and the public API never carrying a restreint entity nor a confidentiel one without the client's dated decision (DM-038) (DM-001..038).
  • /ba-audit-menu 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).
  • /ba-audit-prd 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`).
  • /ba-audit-pre-dev Pre-development readiness orchestrator for a `.smartstack/ba/` project.
  • /ba-audit-rbac 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, unmaterialized `team`/`custom` Portées said out loud, and — data sensitivity at the entity grain (lib/ba-sensitivity) — the need-to-know on a section bound to a ≥ confidentiel entity (a use case names the actor, or a dated décision client on the row; an external actor on restreint is an err — RBAC-011) and the derived lookup grants a sensitive producer holds for a HUMAN row (RBAC-012) (RBAC-001..012).
  • /ba-audit-rules 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).
  • /ba-audit-run ONE deterministic pass over the whole `.smartstack/ba/` corpus — the audit-ba CLI loads every doc once, runs the ~134 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 »). [APP[/MODULE]] [--strict] [--project-root <dir>]
  • /ba-audit-screens 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).
  • /ba-audit-sections 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).
  • /ba-audit-sources 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).
  • /ba-audit-use-cases 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).
  • /ba-change 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. [<APP>/<MODULE>[/<section>]] [--kind use-case|business-rule|actor|permission|attribute|entity|screen] [--modify <CODE>]
  • /ba-create-actors Phase 2 of business analysis.
  • /ba-create-ba-order 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). [APP1] [APP2] …
  • /ba-create-business-rules Phase 4 of business analysis.
  • /ba-create-data-model Phase 6 of business analysis.
  • /ba-create-menu Phase 1 of business analysis.
  • /ba-create-plan-development Generates a phased development plan ordering modules by their cross-module data-model dependencies. <APP1> [APP2] …
  • /ba-create-prd 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`.
  • /ba-create-rbac Phase 5 of business analysis.
  • /ba-create-screen Phase 7 of business analysis (the LAST BA phase).
  • /ba-create-sources 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.
  • /ba-create-test-data Phase 6.5 of business analysis (OPTIONAL, after the data model).
  • /ba-create-use-case Phase 3 of business analysis.
  • /ba-loop Autonomous BA pipeline orchestrator. [APP1] [APP2] … [--from-phase N] [--module APP/MODULE]
  • /ba-modeling-detail Pass 2 of the optional Two-Pass fast-modeling path.
  • /ba-modeling-inventory Pass 1 of the optional Two-Pass fast-modeling path.
  • /ba-reconcile-menu 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`). [--dry-run] [--app APPCODE]
  • /ba-translate-prd Backfills the i18n translations of an already-written PRD.

devApi 3

  • /audit-dev-api Audit code generated by the API phase against the PRD slice — controllers, routes, HTTP actions, RBAC attributes, DTOs, integration tests
  • /audit-dev-external-api Audit the PUBLIC (third-party, machine-to-machine) API surface of a generated client extension — whitelisted route prefix, seeded catalogue row, catalogue-pe…
  • /audit-dev-wire Static parity gate between the generated frontend service URLs and the generated backend controller routes.

devCore 1

  • /audit-dev-core Audit the Phase 0 (Core Foundation Seed) bundle against what scaffold-core-seed EMITS — deterministic CLI (DEV-CORE-000/001/005/006/008/009/010: the 6 per-app providers under Seeding/Applications/{AppPascal}/Core/, the per-app `<<< CORE-SEED-DI-{AppPascal} >>>` block, test users actually created, the `.smartstack/core-seed/{app}.state.json` snapshot, the CoreSeedScriptRunner + its registration + the csproj EmbeddedResource block, the seed-owned AssignedBy marker, and a scan that inspected something).

devData 1

  • /audit-dev-data Audit the generated persistence layer against the BA data model — deterministic CLI (DEV-DAT-001/002/003/007/008/009/010 — every entity has its migration, table naming, no duplicate CreateTable, migration filenames, every declared relationship a REAL FK constraint in the Configuration AND the migration with the declared cascade, every declared **Index** — non-unique included — present in a migration, the business test dataset `jeu-de-test.md` reached its guarded `{Module}TestDataSeedDataProvider`).

devDomain 1

  • /audit-dev-domain Audit code generated by the Domain phase against the PRD slice — entity files, FK pairing, naming, traceability, drift detection

development 2

  • /development-testing Generates real test suites per architectural layer with business rule coverage, consuming NuGet (xUnit, FluentAssertions, Moq, FluentValidation.TestHelper) a…
  • /development-workflow Development workflow index — how a validated PRD becomes a production-ready SmartStack extension (NuGet + npm): the 6 autonomous phases of `/ba-develop`, the…

development/audit 3

  • /audit Audit of generated code against SmartStack conventions (i18n, React, structure, dynamic routing, RBAC, security)
  • /audit-dev-customised Detects @customised page drift from the regenerated service/hook contract (DRIFT-001/002).
  • /audit-routing-dynamic READ-ONLY audit of the SmartStack development skills to verify their conformance to the DB-driven dynamic routing architecture (PageRegistry + componentRegistry + DynamicRouter).

development/backend 7

  • /backend-business-layer Generates full CQRS stack — Commands, Queries, Handlers, DTOs, Validators, Service interface + implementation — on SmartStack NuGet abstractions (IExtensions…
  • /backend-controller Generates the **integration-strata** API controller (generic CRUD served at /api/{module}/{section} from its [NavRoute], Swagger group "integration") with RequirePermission, auto-mapped DTO → Command conversions, and module-scoped permission classes.
  • /backend-core-seed Phase 0 of /ba-develop — generates one Core Foundation Seed bundle per declared application (6 IClientSeedDataProvider classes per app covering navigation + tenant↔app links + roles + permissions + role-permission mappings + dev test users) by invoking the deterministic `scaffold-core-seed` CLI.
  • /backend-data-layer Generates Domain entities on the project-local ExtensionBaseEntity shim (soft-delete + domain events over SmartStack.Domain.Common.BaseEntity), domain events…
  • /backend-screen-controller Generates the **screen-driven** API stratum: one controller per section exposing one endpoint per screen, payload shaped from the pagespec.
  • /backend-seed-data Generates module-scoped IClientSeedDataProvider implementations for reference data (lookup tables, enum codes — the SETUP tier, every environment), the guarded business TEST DATASET provider (jeu-de-test.md → testData[] — dev, test and qual on demand, never prod) and per-module overrides.
  • /dotnet-structure .NET Clean Architecture 4-layer SmartStack

development/debug 6

  • /audit-bug Refine a user-reported bug — rephrase, classify, and cross-reference the code in the current worktree.
  • /debug Diagnose and auto-fix SmartStack dev-runner issues (backend + frontend)
  • /debug-backend Diagnose and auto-fix SmartStack .NET backend failures
  • /debug-frontend Diagnose and auto-fix SmartStack React+Vite frontend failures
  • /discuss-bug Conversational triage on a tracked bug — answer the user, decide whether to reopen the fix or re-audit, never modify code directly.
  • /fix-bug Implement a fix for a user-reported bug — edit code, verify, commit atomically with a traceable message.

development/frontend 9

  • /dashboard Transverse dashboard reference + scaffolder, consumed DURING development so every dashboard uses the right components, the right UI, and correct theming. [scaffold the dashboard primitives, or ask for the dashboard conventions]
  • /frontend-api-client Generates TypeScript service clients + React hooks (useState/useEffect) using the `api` HTTP client from @atlashub/smartstack (pre-configured, returns unwrap…
  • /frontend-auth Scaffold the per-project useAuth adapter + PermissionGuard
  • /frontend-component Generates React page components (list, detail, form) consuming @atlashub/smartstack npm package: PermissionGuard, Slot, SmartStackProvider.
  • /frontend-extension-config Generates ExtensionConfig (@atlashub/smartstack) with slot definitions that mirror the <Slot name="..."> calls emitted by frontend/component.
  • /frontend-pwa Turns a generated CLIENT SmartStack app (an @atlashub/smartstack consumer) into an installable, offline-capable PWA: faithful socle service worker (tenant/language-isolated API cache), VitePWA injectManifest wiring, web manifest + meta tags, placeholder icons, the registerSW → package update channel bridge, initOutbox() and the offline-write outbox aggregation.
  • /frontend-routes Generates PageRegistry registrations for SmartStack's DB-driven routing (DynamicRouter).
  • /frontend-structure React + Vite + Tailwind + SmartStack frontend structure (npm consumer of @atlashub/smartstack)
  • /ui-polish Audits and auto-fixes React pages in a generated SmartStack frontend against the customisation-ui design system standards (CSS variable tokens, PageTemplate wrapper, DataTable/EntityCard components, lucide-react icons, semantic badges, permission keys, i18n namespaces).

development/run 3

  • /run Kill orphans + launch backend + frontend, auto-retry on failure
  • /run-backend Kill stale .Api processes, launch dotnet run, verify /health — retry loop
  • /run-frontend Kill stale Vite, npm run dev, verify /, retry loop

development/smoke-test 1

  • /smoke-test Runtime smoke-test for a freshly-generated SmartStack.app project.

development/testing 3

  • /development-testing-fix-build Auto-correct a SINGLE compilation error surfaced by the Studio's Dev Runner (dotnet CS####, tsc TS####, vite resolve).
  • /development-testing-ui-test Phase 5 UI tests — drives dev-browser to navigate every scaffolded page, submit forms with role-based seeded users, and auto-correct failures via the existing fix-bug skill loop (max 50 iterations per test).
  • /smoke-http HTTP smoke prober for generated SmartStack applications.

devFrontend 5

  • /audit-dev-frontend Audit code generated by the Frontend phase against the PRD slice — page coverage, registry wiring, lazy-import integrity, i18n namespaces, drift detection
  • /audit-dev-pwa Audit the PWA / offline surface of a generated client app — tenant-isolated service worker markers, manifest icon chain, per-page mobile metadata, offline RE…
  • /scaffold-layout Scaffold the page wrapper (PageTemplate) of the generated client app.
  • /scaffold-theme Bootstrap src/index.css with Tailwind v4 + Shoelace token overrides + design tokens from the PRD theme slice (or SmartStack defaults).
  • /scaffold-ui-primitives Scaffold theme-compliant UI primitives into the client project (EntityLookup combobox, DateInput inline calendar, EnumSelect + MultiSelect dropdowns, SegmentedControl, Textarea, Switch, TruncatedText + the owned base DataTable and its ResponsiveDataTable wrapper for responsive list tables with truncation tooltips, TabStrip scrollable tab bar with arrow nudges, SectionCard titled category card with the read-first per-section edit toggle, plus the modern kit Skeleton, EmptyState, Badge, StatCard, and the URL list-state layer useListState + SavedViewsMenu).

devTests 1

  • /audit-dev-tests Audit acceptance-test coverage of BA Acceptance Criteria (DEV-TEST-001..004 + 008 + 011, BLOCKING — incl.

infrastructure 6

  • /ba-develop Consumes a module's PRD on disk (`prd.md` + 3 phase slices + `pagespecs/*.md` under `.smartstack/ba/<APP>/<MODULE>/`) and drives development through 6 sequential phases (Core → Entities → API Integration → API Screen-driven → Frontend → Acceptance Tests). <APP>/<MODULE> [--force] [--allow-dirty]
  • /ba-develop-plan Orchestrates multi-module development across applications by executing the phased plan from /ba-create-plan-development. [--waves 1,2]
  • /context7 Fetches up-to-date library, framework, SDK and API documentation via the ctx7 CLI (Upstash Context7).
  • /dev-browser Drives a real Chromium browser from Claude Code and from Bash CLI — navigate pages, click elements, read DOM, take screenshots, run end-to-end checks.
  • /efcore EF Core migration workflow — create, squash, rebase-snapshot, apply, list, status. [create|squash|rebase-snapshot|apply|list|status|recreate-db] [-BruteForce]
  • /gitflow GitFlow workflow — routes to colocated CLI commands (skills/gitflow/cli/) for deterministic execution [-a] [-f|-r|-h|-s] <action> [name|version]

lifecycle 13

  • /check-version Verify version alignment between package.json and documentation
  • /cli-app-sync Detect and fix template drift between SmartStack.app (source of truth) and CLI templates [report|fix|check <file>]
  • /conventions SmartStack global conventions — DB schemas, prefixes, namespaces
  • /dev-start Launch SmartStack dev environment (backend + frontend + admin credentials) [--stop] [--restart] [--clean] [--reset] [--backend-only] [--frontend-only]
  • /documentation Automatically generates technical documentation for SmartStack. <module-name> [--type user|developer|database|testing] [--tech]
  • /init SmartStack project initialization via ss init
  • /review Multi-category code review — security, architecture, performance
  • /smoke-generation Validate CLI templates by checking that every imported component, type, and method signature documented in /templates/skills/ actually exists in SmartStack.app (develop). [--quick|--full] [--scope=frontend|backend|all] [--app-path=<path>] [--report-only]
  • /ui-components Verify that a React page (or the whole generated app) conforms to the SmartStack design system — design-system tokens instead of hardcoded colors, the theme's helper classes (.btn .btn-primary, .badge-*) instead of inline re-assembly, and the project's own page anatomy — then auto-fix the violations. [page-path] [--check|--fix] [--theme-only]
  • /upgrade SmartStack project upgrade via ss upgrade
  • /utils Utility skills for SmartStack CLI development <subcommand> [options]
  • /validate-feature Validate that a scaffolded feature works end-to-end (compile, test, API smoke test)

other 9

  • /audit-fix Closes the loop the audits leave open: runs them, attaches each finding's REMEDY from the shared registry (`lib/remediation.ts`), executes the correctors that already exist (the `derive-*` CLIs in write mode, the audit CLIs' own `--mode apply`), re-runs the audits, and reports the delta — closed / persisting / INTRODUCED. [APP/MODULE] [--plan] [--lanes derive,rewrite] [--rules RBAC-008,...]
  • /external-api Publish part of a generated SmartStack client app as a PUBLIC API that THIRD-PARTY systems consume machine-to-machine — the surface an ERP, a partner portal or a nightly batch calls. [what to expose, e.g. 'les factures en lecture + création pour le partenaire logistique']
  • /login-config Customize the login / authentication experience of a generated SmartStack client app, through two complementary levers. [describe the login you want, e.g. 'local + Microsoft, no signup, branded Acme']
  • /pwa Turn a generated SmartStack client app into an installable PWA with offline pages — transform the existing app (service worker, manifest, icons, install/ update banners, outbox bootstrap) and enable offline per page: 'read' (SW GET cache, mutations disabled offline) or 'write' (outbox capture, optimistic 202, idempotent replay, 409 server-wins conflicts). [e.g. 'rends les feuilles de temps saisissables hors ligne']
  • /site-vitrine Scaffold the PUBLIC (pre-auth) surface of a generated SmartStack client app: the home page (the `/` override), presentation pages (about, features, pricing, contact…) and a full marketing "site vitrine". [describe the vitrine, e.g. 'home + about + pricing, branded Acme']
  • /smartstack-entity-audit Audit the GENERATED SmartStack app's LIVE database for referential-integrity gaps — every column ending in `Id` that should be a foreign key but is covered by NO integrity constraint. [project path]
  • /support-report When a colocated SmartStack skill CLI fails unexpectedly at a CLIENT project — a stack trace on stderr, non-JSON stdout, an unexplained non-zero exit — OR when an audit envelope contradicts itself (a `dedupOf` mirror finding in err while its primary rule is ok on the same scope) or renders a verdict you can DEMONSTRATE wrong, you are NOT the CLI's maintainer: the files under ~/.claude are deployed copies (no sources, overwritten on update) and must NEVER be edited. (after a skill CLI crash or a contradictory audit verdict — evidence is gathered from the failing run)
  • /test-conventions Conventions for WRITING tests in a SmartStack client extension, distilled from the SmartStack.app corpus and adapted to the extension context (IExtensionsDbContext, in-memory ExtensionsDbContext + a fake tenant, real SQL Server LocalDB integration).
  • /ui-design Apply DESIGN JUDGMENT to a generated SmartStack form/page that the deterministic scaffolder cannot infer — which FK is the signed-in user (the one-click "Me" shortcut), how to group fields into sections, which date is a primary inline calendar vs a compact popover, the column layout and the field order. [entity|page-path] [--screenshot <path>] [--bespoke]

uat 1

  • /uat Full UAT pipeline for a generated SmartStack client app: generate a deterministic test plan (`.plantest.yml`) from the LIVE surface (SQL nav/RBAC + componentRegistry + controllers), provision a UAT tenant + one user per role through the admin API, execute the plan on BOTH axes — backend (every endpoint × role: expected status, duration, response size) and frontend (a real Chromium driven like a user: login page, sidebar clicks, row clicks, real form submits on UAT-marked data, per-page timings/weight/console) — and render a single-file HTML report with every metric. [run|plan|provision|api|ui|report] [Application[/Module[/Section]]] [--dry-run]

validation 6

  • /cross-validate-stack Cross-stack validation backend .NET / frontend React — 5 coherence checks
  • /eslint-validator Static validation of SmartStack React conventions (5 architecture rules)
  • /project-inventory Deterministic scanner for a generated SmartStack project.
  • /readiness-report LEGACY (hors chaîne BA) — score /100 aggregating roslyn + eslint + cross-validate only.
  • /roslyn-validator SmartStack C# static analysis — 10 rules (SS001-SS010) per layer
  • /validate-conventions Audits a SmartStack project for convention violations — namespace prefixes by Clean Architecture layer, entity patterns (BaseEntity + tenant interfaces + private ctor + factory), and controller routing (NavRoute vs hardcoded Route).