# Catalogue complet des skills Complete skill catalogue

SmartStack CLI déploie 84 skills dans `/.claude/skills/`, chacune invocable par Claude Code via `/<nom>`. La liste ci-dessous est générée automatiquement à partir du frontmatter `SKILL.md` de chaque skill — elle est donc toujours synchronisée avec ce qui est réellement déployé. SmartStack CLI deploys 84 skills to `/.claude/skills/`, each invocable from Claude Code via `/<name>`. The list below is auto-generated from each skill's `SKILL.md` frontmatter — always in sync with what is actually deployed.

## Comment lire les cartes How to read the cards

- `/slug` : nom de la slash-command à taper dans Claude Code.`/slug`: slash-command name to type in Claude Code.
- Description : objectif principal (extrait du frontmatter `description:`).Description: primary objective (extracted from `description:` frontmatter).
- args : argument-hint indicatif quand la skill en attend.args: argument hint when the skill expects parameters.
- Tags d'outils : `allowed-tools` qui contraignent l'exécution.Tool tags: `allowed-tools` that constrain execution.

## Table complète des skills

## Complete skill table

Toutes les commandes `/<nom>` déployées par `ss install`, groupées par phase.

All `/<name>` commands deployed by `ss install`, grouped by phase.

### business-analyse (23)

`/ba-audit-actors` business-analyse

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.

Read Write Glob Grep
`/ba-audit-cross-dimension` business-analyse

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.

Read Write Glob Grep
`/ba-audit-cross-ref-code` business-analyse

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.

Read Write Glob Grep Bash
`/ba-audit-data-model` business-analyse

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.

Read Write Glob Grep
`/ba-audit-prd` business-analyse

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

Read Write Glob Grep
`/ba-audit-pre-dev` business-analyse

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.

Read Write Glob Grep
`/ba-audit-rbac` business-analyse

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.

Read Write Glob Grep
`/ba-audit-rules` business-analyse

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.

Read Write Glob Grep
`/ba-audit-screens` business-analyse

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.

Read Write Glob Grep
`/ba-audit-sections` business-analyse

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.

Read Write Glob Grep
`/ba-audit-use-cases` business-analyse

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.

Read Write Glob Grep
`/ba-create-actors` business-analyse

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.

Read Write Edit Glob Grep AskUserQuestion
`/ba-create-business-rules` business-analyse

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.

Read Write Edit Glob Grep AskUserQuestion
`/ba-create-data-model` business-analyse

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

Read Write Edit Glob Grep AskUserQuestion
`/ba-create-plan-development` business-analyse

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.

args: `<APP1> [APP2] …`
Bash Read Glob
`/ba-create-prd` business-analyse

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.

Read Write Edit Glob Grep
`/ba-create-rbac` business-analyse

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

Read Write Edit Glob Grep AskUserQuestion
`/ba-create-screen` business-analyse

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

Read Write Edit Glob Grep AskUserQuestion
`/ba-create-use-case` business-analyse

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

Read Write Edit Glob Grep AskUserQuestion
`/ba-modeling-detail` business-analyse

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.

Read Write Edit Glob Grep
`/ba-modeling-inventory` business-analyse

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

Read Write Glob Grep

### devApi (1)

`/audit-dev-api` devApi

Audit code generated by the API phase against the PRD slice — controllers, routes, HTTP actions, RBAC attributes, DTOs, integration tests

### devCore (1)

`/audit-dev-core` devCore

Audit code generated by Phase 0 (Core Foundation Seed) — every PRD module must have nav + roles + permissions in the 5 Core providers, DI registration must be in place, and the providers must be deterministic (no hand-edits).

### devData (1)

`/audit-dev-data` devData

Audit code generated by the Data phase against the PRD slice — migrations, seed providers, navigation/permissions coverage, FK constraints, drift detection

### devDomain (1)

`/audit-dev-domain` devDomain

Audit code generated by the Domain phase against the PRD slice — entity files, FK pairing, naming, traceability, drift detection

### development (2)

`/development-testing` development

Generates real test suites per architectural layer with business rule coverage, consuming NuGet (xUnit, FluentAssertions, Moq, FluentValidation.TestHelper) and npm (Vitest, Testing Library, React Query) packages.

`/development-workflow` development

Development workflow index — drives module development from PDR to production-ready SmartStack extension (NuGet + npm) with mandatory tests at every layer.

### development/audit (2)

`/audit` development/audit

Audit du code genere contre les conventions SmartStack (i18n, React, structure, routing dynamique, RBAC, securite)

`/audit-routing-dynamic` development/audit

Audit READ-ONLY des skills de developpement SmartStack pour verifier leur conformite a l'architecture de routing dynamique DB-driven (PageRegistry + componentRegistry + DynamicRouter). Produit un rapport textuel sans modifier aucun skill.

### development/backend (6)

`/backend-business-layer` development/backend

Generates full CQRS stack — Commands, Queries, Handlers, DTOs, Validators, Service interface + implementation — on SmartStack NuGet abstractions (ICoreDbContext, MediatR, FluentValidation).

`/backend-controller` development/backend

Generates API controllers with NavRoute, RequirePermission, auto-mapped DTO → Command conversions, and module-scoped permission classes, consuming NuGet packages (SmartStack.Core, SmartStack.Api, MediatR).

`/backend-core-seed` development/backend

Phase 0 of /ba-develop — generates one Core Foundation Seed bundle per declared application (5 IClientSeedDataProvider classes per app covering navigation + roles + permissions + role-permission mappings + dev test users) by invoking the deterministic `scaffold-core-seed` CLI. Zero creative work for the agent: the spec is built by the Studio backend (`prepareCoreSeedContext`) from the BA menu / actors / permissions and dropped to a temp file before this skill runs.

`/backend-data-layer` development/backend

Generates Domain entities with BaseEntity (SmartStack.Core.Domain NuGet), domain events, soft-delete, EF Core configurations with schema targeting, and migrations.

`/backend-seed-data` development/backend

Generates module-scoped IClientSeedDataProvider implementations for reference data (lookup tables, enum codes) and per-module overrides. Cross-app navigation, roles, permissions, and role-permission mappings are NOT this skill's job — they live in scaffold-core-seed (Phase 0). Output goes under Persistence/Seeding/Applications/{AppPascal}/Modules/{ModuleCode}/ to mirror the per-application module layout.

`/dotnet-structure` development/backend

.NET Clean Architecture 4-layer SmartStack

### development/debug (6)

`/audit-bug` development/debug

Refine a user-reported bug — rephrase, classify, and cross-reference the code in the current worktree.

`/debug` development/debug

Diagnose and auto-fix SmartStack dev-runner issues (backend + frontend)

`/debug-backend` development/debug

Diagnose and auto-fix SmartStack .NET backend failures

`/debug-frontend` development/debug

Diagnose and auto-fix SmartStack React+Vite frontend failures

`/discuss-bug` development/debug

Conversational triage on a tracked bug — answer the user, decide whether to reopen the fix or re-audit, never modify code directly.

`/fix-bug` development/debug

Implement a fix for a user-reported bug — edit code, verify, commit atomically with a traceable message.

### development/frontend (7)

`/frontend-api-client` development/frontend

Generates TypeScript service clients + React Query hooks using smartstackClient (shared axios instance from @atlashub/smartstack npm package) and direct REST paths (/api/{module}/{plural}).

`/frontend-auth` development/frontend

Scaffold the per-project useAuth hook + PermissionGuard component

`/frontend-component` development/frontend

Generates React page components (list, detail, form) consuming @atlashub/smartstack npm package: PermissionGuard, Slot, SmartStackProvider. i18n keys are split per entity to prevent concurrent-generation overwrites.

`/frontend-extension-config` development/frontend

Generates ExtensionConfig (@atlashub/smartstack) with slot definitions that mirror the <Slot name="..."> calls emitted by frontend/component.

`/frontend-routes` development/frontend

Generates PageRegistry registrations for SmartStack's DB-driven routing (DynamicRouter). Validates componentKey format before emission and fails loud on bad specs rather than producing silent-spinner registries.

`/frontend-structure` development/frontend

React + Vite + Tailwind + SmartStack frontend structure (npm consumer of @atlashub/smartstack)

`/ui-polish` development/frontend

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). Produces a violation report (audit mode) or applies mechanical fixes (apply mode) based on tokens.json. Invoked after Phase 4 of ba-develop to guarantee visual consistency with the reference app.

### development/run (3)

`/run` development/run

Kill orphans + launch backend + frontend, auto-retry on failure

`/run-backend` development/run

Kill stale .Api processes, launch dotnet run, verify /health — retry loop

`/run-frontend` development/run

Kill stale Vite, npm run dev, verify /, retry loop

### development/smoke-test (1)

`/smoke-test` development/smoke-test

Runtime smoke-test for a freshly-generated SmartStack.app project. Starts the backend (`dotnet run`) and the frontend (`npm run dev`) in the background, waits for both to become reachable, then probes every page route and every API endpoint scaffolded by the pipeline. Fails the run if ANY endpoint returns a 4xx/5xx status code or if any page is missing from disk. Designed to be the final gate of `ba-develop` so cross-stack drift surfaces in CI rather than at the user's first manual `npm run dev`.

### development/testing (3)

`/development-testing-fix-build` development/testing

Auto-correct a SINGLE compilation error surfaced by the Studio's Dev Runner (dotnet CS####, tsc TS####, vite resolve). The caller provides one `BuildError` with file/line/column/code/message. Your job is to apply the MINIMUM patch to make that specific error go away, without refactoring surrounding code. Invoked by `build-fix-runner.ts` in a retry loop (max 15 iterations, convergence guard, rebuild-and-reparse after each attempt).

`/development-testing-ui-test` development/testing

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). Runs after the frontend scaffolders complete (routes + component + api-client + extension-config) and verifies the full backend ↔ frontend round-trip.

`/smoke-http` development/testing

HTTP smoke prober for generated SmartStack applications. Given a list of URLs (frontend routes + backend API endpoints), fetches each one, follows redirects, applies retry-on-startup, and returns a JSON report of 200/non-200 results. Invoked after Phase 4 of ba-develop to detect broken routes and missing API endpoints before the user ever sees a 404 in the browser.

### devFrontend (3)

`/audit-dev-frontend` devFrontend

Audit code generated by the Frontend phase against the PRD slice — page coverage, registry wiring, lazy-import integrity, i18n namespaces, drift detection

`/scaffold-layout` devFrontend

Scaffold the app-level layout shell (PageTemplate + AppShell) reading nav from /api/navigation/menu, honoring per-app branding via @customised marker.

`/scaffold-theme` devFrontend

Bootstrap src/index.css with Tailwind v4 + Shoelace token overrides + design tokens from the PRD theme slice (or SmartStack defaults). Idempotent overwrite.

### infrastructure (6)

`/ba-develop` infrastructure

Consumes a module's PRD on disk (`prd.md` + 3 phase slices + `pagespecs/*.md` under `.smartstack/ba/<APP>/<MODULE>/`) and drives development through 4 sequential phases (Core Foundation Seed → Entities → API → Frontend), each running as a subagent. Phase 0 is deterministic — the agent invokes scaffold-core-seed to write the per-app navigation + roles + permissions in one shot, eliminating the silent empty-module regression. Gates between phases verify compile + tests + per-module coverage before advancing. Invoked after `/ba-create-prd` + `/ba-audit-prd` (dev-ready GO, score ≥ 80).

`/ba-develop-plan` infrastructure

Orchestrates multi-module development across applications by executing the phased plan from /ba-create-plan-development. Reads dev-plan.json, runs a preflight check, then drives wave-by-wave execution: for each wave, launches one /ba-develop subagent per module (parallel within a wave), gates between waves (compile + tests for all modules), and reports unified results.

args: `[--waves 1,2]`
Agent Bash Read Glob Grep Skill
`/context7` infrastructure

Fetches up-to-date library, framework, SDK and API documentation via the ctx7 CLI (Upstash Context7). Prefer this over web search whenever the user asks about a library, framework, SDK, API, CLI tool or cloud service — even well-known ones like React, Next.js, Prisma, Express, Tailwind, EF Core — because training data may lag behind recent releases. Keywords: library, framework, docs, documentation, SDK, API, package, npm, nuget, version, changelog, migration guide.

`/dev-browser` infrastructure

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. The SmartStack Studio uses this skill as the test engine for Phase 5 UI tests. Activate when the user asks to open a URL, click a button, test a web page, verify a rendered layout, reproduce a UI bug, submit a form, or script any browser interaction. Keywords: browser, navigate, click, screenshot, DOM, Chromium, Chrome, webpage, URL, visual test, UI verification, E2E.

`/efcore` infrastructure

EF Core migration workflow — create, squash, rebase-snapshot, apply, list, status. Applies the best practices of the global /efcore agents without MCP or external dependencies. Works against a single-assembly generated app (CoreDbContext + ExtensionsDbContext) or the multi-assembly Studio (StudioDbContext with Sqlite / Postgres / SqlServer migration projects).

`/gitflow` infrastructure

GitFlow workflow — routes to colocated CLI commands (skills/gitflow/cli/) for deterministic execution

args: `[-f|-r|-h] <action> [name]`

### lifecycle (13)

`/check-version` haiku lifecycle

Verify version alignment between package.json and documentation

Read Glob Grep Bash
`/cli-app-sync` sonnet lifecycle

Detect and fix template drift between SmartStack.app (source of truth) and CLI templates

args: `[report|fix|check <file>]`
Read Grep Glob Bash Edit Write
`/conventions` lifecycle

SmartStack global conventions — DB schemas, prefixes, namespaces

`/dev-start` haiku lifecycle

Launch SmartStack dev environment (backend + frontend + admin credentials)

args: `[--stop] [--restart] [--reset] [--backend-only] [--frontend-only]`
Bash BashOutput
`/documentation` sonnet lifecycle

Automatically generates technical documentation for SmartStack. Use this skill when: - User asks to create/generate documentation - User mentions "document", "documentation", "doc", "ERD", "schema" - User wants to document a module, table, tool, or test - After implementing a feature to generate its documentation Types: user module, developer tools, database ERD, testing tools

args: `<module-name> [--type user|developer|database|testing|update]`
`/init` lifecycle

SmartStack project initialization via smartstack-studio init

`/quick-search` haiku lifecycle

Lightning-fast search to answer specific questions - optimized for speed

args: `<question>`
Grep Glob Read
`/review` lifecycle

Multi-category code review — security, architecture, performance

`/smoke-generation` sonnet lifecycle

Validate CLI templates by checking that every imported component, type, and method signature documented in /templates/skills/ actually exists in SmartStack.app (IA-Workflow). Catches the "EntityLookup paradox" class of drift where docs reference things that don't exist in the platform.

args: `[--quick|--full] [--scope=frontend|backend|all] [--app-path=<path>] [--report-only]`
Read Grep Glob Bash Write
`/ui-components` sonnet lifecycle

Verify that a React page (or the whole generated app) respects the SmartStack theme — zero hardcoded colors — and auto-fix the violations. Thin orchestrator over the ui-polish engine: it does NOT reimplement any audit/fix logic, it runs the deterministic ui-polish CLI and then finishes the residual cases (neutral colors with no token) that the CLI cannot map mechanically.

args: `[page-path] [--check|--fix] [--all-rules]`
Read Grep Glob Bash Edit
`/upgrade` lifecycle

SmartStack project upgrade via smartstack-studio upgrade

`/utils` haiku lifecycle

Utility skills for SmartStack CLI development

args: `<subcommand> [options]`
`/validate-feature` lifecycle

Validate that a scaffolded feature works end-to-end (compile, test, API smoke test)

### validation (6)

`/conventions` validation

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). Produces a structured JSON report of findings. Use when the user asks to audit, validate or check a project's conformance with SmartStack conventions. Keywords: audit, conventions, conformance, check project, validate structure, namespace, NavRoute, entity compliance.

`/cross-validate-stack` validation

Cross-stack validation backend .NET / frontend React — 5 coherence checks

`/eslint-validator` validation

Static validation of SmartStack React conventions (5 architecture rules)

`/project-inventory` validation

Deterministic scanner for a generated SmartStack project. Produces a structured JSON manifest of existing entities, migrations, seed providers, controllers, React pages, and extension registries. Consumed by each phase of ba-develop so the Claude subagent can distinguish "already implemented" from "needs to be created" before writing any file. Zero LLM — regex-based scan, runs under 2 seconds on a normal app.

`/readiness-report` validation

SmartStack readiness report — score /100, aggregation roslyn + eslint + cross-validate

`/roslyn-validator` validation

SmartStack C# static analysis — 10 rules (SS001-SS010) per layer