# SmartStack Skills — Index > Organized by business phase. Each skill has a `SKILL.md` + optionally a `cli/`. > A sub-context loads only the relevant skill + 1-2 JSON spec files. > **Language rule**: All skills must be written in English. ## Scope This directory ships **only the skills deployed by the SmartStack CLI** into `~/.claude/skills/` (or `./.claude/skills/` with `--local`). Each skill exists to **analyze**, **develop**, **audit**, or **validate** a client SmartStack.app project. Skills that operate on the SmartStack.Studio source itself (Studio self-audit, EPCT workflow for Studio features, Electron app debugging, Studio runtime internals) are **not deployed by the CLI** — they live in the Studio repo. ## Architecture — Skills + colocalized CLIs (no MCP) The legacy `SmartStack.mcp` server was removed in v5. Every operation it used to perform is now implemented as a skill with a colocalized CLI: ``` skills/ ├── lib/ # Shared TypeScript utilities (detector, dotnet, fs, git, …) ├── efcore/ # EF Core migrations (6 CLIs) ├── gitflow/ # GitFlow workflow (12 CLIs) ├── external/ # Wrappers around external tools (ctx7, dev-browser) ├── business-analyse/ # 28 BA skills (audit, define, generate, modeling, design, test data) ├── ba-develop/ # PRD-driven phased pipeline (Domain → Data → API → Frontend) ├── ba-develop-plan/ # Multi-module orchestrator over dev-plan.json (preflight + waves) ├── development/ │ ├── backend/ # entity, dto, repository, business-layer, controller, … │ ├── frontend/ # theme, layout, routes, component, api-client, … │ ├── audit-dev-*/ # per-layer audit rule packs │ ├── debug/, run/, testing/ ├── validation/ # validate-conventions, cross-validate, eslint, roslyn, readiness-report, project-inventory ├── conventions/ # SmartStack.app conventions reference ├── init/, upgrade/, review/ # Project lifecycle skills ├── check-version/ # Verify package.json ↔ docs alignment ├── cli-app-sync/ # Detect template drift between SmartStack.app and CLI ├── dev-start/ # `ss dev` orchestrator (backend + frontend + admin credentials) ├── documentation/ # Technical doc generator (extract-doc + scaffold-doc CLIs) ├── external-api/ # /external-api — publish a PUBLIC (third-party, M2M) API from a client extension │ # (derive-external-api-spec, scaffold-external-api, publish-api-contract, │ # provision-external-app) — audited by development/audit-dev-external-api ├── quick-search/ # Fast codebase Q&A ├── smoke-generation/ # Static analysis of CLI templates against SmartStack.app ├── support-report/ # /support-report — verified CLI-failure reports for support@atlashub.ch ├── test-conventions/ # Conventions for WRITING tests in a client extension ├── uat/ # Full UAT pipeline (6 CLIs: plan, provision, api, ui, report, run) ├── utils/ # Utility sub-skills for CLI development └── validate-feature/ # End-to-end validation of a scaffolded feature ``` Internal CLIs are invoked via: ```bash npx --prefer-offline tsx skills///cli//index.ts --spec '' ``` Each CLI returns a JSON envelope on stdout (see `lib/output.ts`). ## Infrastructure skills The following skills provide cross-cutting infrastructure (not a business phase): | Skill | Role | |-------|------| | `efcore` | EF Core migration workflow (`create`, `squash`, `rebase-snapshot`, `apply`, `list`, `status`) | | `external` | Wrappers around external tools (`context7`, `dev-browser`) | | `gitflow` | GitFlow workflow (12 CLIs covering init → finish + update + generate-msg) | | `lib` | Shared TypeScript utilities for CLIs | | `support-report` | `/support-report` — when a colocated CLI fails at a CLIENT site, the sanctioned path instead of "fixing" the deployed copy under `~/.claude` (skills-guard blocks that): the `create` CLI is the FAIL-CLOSED verifier (evidence rule: stack trace inside the skills tree OR ≥ 2 identical-signature runs OR an envelope contradicting ITSELF — a `dedupOf` mirror finding in err while its primary is ok on the same scope, read mechanically from `report.findings[]` (the DemoGestionFlotte XD-005 incident) — OR an argued verdict dispute anchored on `disputedRuleIds` the envelope carries; controlled envelopes, environment, single unproven runs, flaky signatures and unanchored disputes are refused with guidance), checks installed-vs-npm-latest (newer → propose update + retest before transmitting), attaches what the CLI READ (`inputs[]` — traversal-guarded, excluded, scrubbed, capped — lib/support-bundle) and writes the deduplicated French report bundle + `support-.zip` (+ sha256, `repro.md`) to `.smartstack/support//` for the user to send to **support@atlashub.ch** | ## lib (shared utilities) | File | Role | |------|------| | `fs.ts` | File system helpers — findFiles (minimatch-based), read/write, path security | | `ba-rules-rows.ts` | THE first deterministic `règles-métier.md` parser (until it, no .ts read the rules docs — the BR silent-loss root) — `parseRules` (heading `### BR-NNN — Titre` + typed fields Type/Sévérité/Portée/Condition/Expression/Code d'erreur/Cas valides·invalides/Cas d'usage liés + structured `Flow` transitions `from → to (by, guard)`), `loadRulesDoc`, `loadModuleRules` (deepest-scope aggregation module + sections, cross-doc duplicate codes warned — BR codes are DOC-scoped), `enforceableRules` (err+warn). Tolerant (warnings, never throws), drift-tested against the doc-templates + create-business-rules skeletons. Consumers: derive-rule-links (PRD-129/130), DEV-API-008 catch-up, DEV-TEST-009 parity | | `ba-actors.ts` | Shared `acteur.md` parser + actor → seeded-role mapping — `parseActors`/`loadAppActors` (headings `### BA-…-AC-NNN — Label` + **Type**/**Catégorie** fields), `mapRoleCategory` (tolerant FR-label → RoleCategory enum, drift-tested against `_workflow/role-taxonomy.md`; `Global` refused). The role identity rule lives here: `code = slugifyRoleCode(label)`, `name = label` verbatim — what makes `actorMatchesRole` (ba-rbac-rows) hold by construction. Consumed by create-rbac/derive-rbac-grants | | `git.ts` | Git commands — branch, diff, changed/staged files | | `detector.ts` | `findSmartStackStructure()` — locates Domain/Application/Infrastructure/Api/web/migrations | | `dotnet.ts` | `.csproj` parsing, DbContext detection, `detectNamespaces()` | | `navroute-parser.ts` | Extracts `[NavRoute]` attributes from C# controllers | | `string-utils.ts` | kebab/camel/pascal/singular/plural helpers | | `core-catalog.ts` | Canonical SmartStack Core catalogue — V1 whitelist (+FR/EN aliases, e.g. Organisation/Company→TenantOrganisation), reserved names, person triggers, whole-token matchers, `CORE_WHITELIST_V1(_NAMESPACES)`, `CORE_PROJECTABLE_FIELDS`. Drift-tested against the inline tables in the BA SKILL.md files | | `capability-catalog.ts` | Canonical catalogue of transverse platform CAPABILITIES (services, not entities — the axis core/platform-catalog can't index): file-storage (`IFileStorageService` — the "no file mechanism exists" incident closer), global-search, time-entry-refs, code-generation (`AddSmartStackCodeKey` — the "every module re-models its own counter table" incident closer), email-sending. `PLATFORM_CAPABILITIES` + `matchCapabilityTrigger` (whole-token OR trailing-word: `InteractionDocuments` → hit; `Documentation` → no) + `matchCapabilityAttribute` (`binary`/`varbinary`/… → file-storage). Feeds C-6 / DM-019 / CODE-006; drift-tested (`platform-capabilities:v1`) against create-data-model, audit-data-model and audit-cross-ref-code | | `code-pattern-grammar.ts` | The socle's CLOSED code-pattern grammar (mirror of `CodePatternGrammar`/`CodePatternValidator` — tokens `{YYYY\|YY\|MM\|DD\|TENANT\|SEQ:n}` + derived `{FIELD\|UPPER\|LOWER\|SLUG\|INITIALS:Champ}`/`{ABBR:Champ:n}`, `validateFormat` fail-closed, `referencedFields`) + the `**Code pattern**` line contract (`ENT_BLOCK_RE`/`CODE_PATTERN_LINE_RE` + `parseCodePatternLine` — FR/EN facet parsing incl. `libellé « … »`/`label "…"` and `surchargeable à la création`/`supplied on create`, absent facet = null, never a default) + the code-side nets: `findCodePatternNearMisses` (table-cell/wrong-case/unbolded/prose shapes — the green-by-vacuity killer, consumed by derive-code-specs, DEV-API-022, DEV-UI-034, DM-021) with `CODE_PATTERN_CANONICAL_FORM` (the ONE remedy wording), the `code-like-lexicon:v1` (`CODE_LIKE_ATTRIBUTE_WORDS` + `codeLikeWordOf` — Référence/Numéro/Matricule ARE codes, whole-word over the shared `splitWords`, drift-locked against create-data-model attributes.md), and `CODE_SAISI_LINE_RE`/`parseCodeSaisiValue` (the TYPED-species marking). Consumers: scaffold-coded-entity (format gate), scaffold-entity (`GetCodeInputs` emission), audit-dev-api DEV-API-022, audit-dev-frontend DEV-UI-034, derive-code-specs, audit-ba DM-017/DM-021/SCR-015 | | `proposal-tiers.ts` | Canonical 3-tier BA proposal taxonomy (Obligatoire / Suggestion / Élargissement) — `PROPOSAL_TIERS` + the `proposal-tiers:v1` markdown block. Methodology in `business-analyse/_workflow/proposal-method.md`; drift-tested against the inline tables carried by create-menu, create-use-case (discovery), create-business-rules (identify) and create-screen | | `detail-cadence.ts` | Canonical DETAIL CADENCE of the two-pass BA phases — `DETAIL_CADENCES` (**Pas à pas** one gate per item / **Par lot** one gate per batch, the DEFAULT / **Enchaîné** no gate, audit verdict instead), `DETAIL_CADENCE_KEYS` (`step`/`batch`/`chained`), `DEFAULT_DETAIL_CADENCE_KEY` and `NON_INTERACTIVE_DETAIL_CADENCE_KEY` (a `/ba-loop` subagent may not call AskUserQuestion — it would deadlock on a question it is forbidden to put). Answers the question the second pass never asked the user: how many items do you draft before I get a say. Methodology in `business-analyse/_workflow/detail-cadence.md`; drift-tested against the inline tables carried by create-use-case (`levels/detail.md`) and create-business-rules (`levels/elaborate.md`). The worklist it iterates is DERIVED, not stored — `lib/ba-use-cases.undetailedUseCases` | | `page-spec-related-tabs.ts` | Canonical Zod schema of the 360 `relatedTabs[]` (detail pagespec) — `PageRelatedTabSchema` (+ BA aliases `relationship`/`screenTarget`, + `placement: tab\|band` — band rejected on non-summary at the schema), `normalizePageRelatedTab` (labelKey/permission defaults), `relatedTabPlacementOf`/`placementForDisplayMode` (THE derived-placement SSOT: summary → band cartouche row above the strip, else strip trigger — scaffold-component and DEV-UI-031 both resolve here), `parseRelatedTabs`, `relatedPluralOf`, `fkFilterFields` (SSOT of the Guid-FK filter params both backend strata + api-client expose). Invariant: `relationFk` === wire query param === `[FromQuery] Guid?` === `Where(x => x.{Pascal})` | | `page-spec-lifecycle.ts` | Canonical Zod schema + resolver of the first-order `lifecycle` block (FORM pagespecs) — `PageLifecycleSchema` (statusField + phases anchored VERBATIM on the status enum; phases OWN later-phase fields and/or make fields `requiredFields` once a status is reached), `resolveLifecycle` (seeds the `field.phase`/`requiredInPhase` pivots, per-field effects map, pure/identity on absence), `lifecycleVisibleWhen` (compiles a phase's statuses into the `visibleWhen` grammar — `===` / `IN (…)`). Compile-down: create form/payload exclusion + `isEdit && ` on edit (scaffold-component), Create DTO/Command/factory exclusion via the per-field `phase` flag (scaffold-business/controller/entity/api-client — the Create-honnête contract: optional non-phased fields now ride Create as nullable). Written by create-prd, `create-prd/cli/derive-lifecycle` (deterministic backfill + the PRD-120 check engine) and the Phase 3.1 lifecycle leg (`apply-form-directives`, additive); audited by SCR-019 / XD-007 / PRD-120/121 / DEV-UI-044; drift-locked (readers import the lib) | | `pwa-meta.ts` | Canonical Zod schema of the per-page PWA/offline declaration (`pagespec.pwa`) — `PwaMetaSchema` (`support: full\|adapted\|desktop-only`, `offline: read\|write\|bool`), `normalizeOffline` (write ⊇ read), `validatePwaMetaV1` (rejects `full` + desktop-only-offline), `toPageMobileMetaLiteral` (maps onto the socle's `PageMobileMeta` — offline collapses to boolean `offlineCapable`; write-ness is a data-layer fact, never registry metadata). Consumed by scaffold-routes / scaffold-component / scaffold-api-client / derive-pwa-spec / audit-dev-pwa. **Deliberately carries NO shell metadata** (bottom-nav rank, mobile icon…): the mobile shell's palier navigation derives entirely from the DB menu. The file header documents the 6-step cascade any future shell field must follow. | | `permission-actions.ts` | Canonical RBAC action vocabulary + permission FLOOR + path grammar — `PERMISSION_ACTIONS` (12, mirror of the platform `PermissionAction` enum), `PERMISSION_ACTION_ENUM` (action → C#/SQL literal incl. `read.all → Read`), `PERMISSION_DATA_ACTIONS` (scaffold-controller's 10), `PERMISSION_FLOOR_ACTIONS` (the 7 seeded by default: access/lookup/read/create/update/delete/execute), `FLOOR_BY_GRAIN` (app+module = access only; section+resource = full 7), multi-grain `parsePermissionPath` (2..6 segments, `read.all` tier disambiguation, `RESERVED_NODE_CODES` read/all), `floorPathsForNode` (shared by scaffold-core-seed's actual seed AND the BA mirror block). Drift-tested (`permission-actions:v1`, `permission-floor:v1`) against create-rbac, audit-prd PRD-055, access-rules.md, scaffold-controller, derive-seed-delta | | `registry-index.ts` | The TOLERANT PageRegistry parser + layout detector — `buildRegistryIndex(webRoot)` (balanced-argument scanner: canonical per-module const-ref, legacy MCP-era monolith with inline `lazy(() => import(…))`, static imports, verbatim `{ mobile: … }` meta), `detectRegistryLayout` (`per-module \| legacy-monolith \| mixed \| none`), `parseRegistrySource`, `resolveRegistryImport`, `PER_MODULE_REGISTRY_RE`. `lib/routes-registry.PAGE_REGISTER_RE` stays the STRICT emission contract; THIS is what audits (audit-dev-pwa, audit-dev-frontend), the fail-closed layout guards (aggregate-component-registry, scaffold-routes) and split-component-registry read with. Closes the PickEBike fail-open (empty scan on a monolithic app) | | `detail-tab-strip.ts` | SSOT of the RENDERED detail tab bar + the budget thresholds — `resolveDetailStrip` (mirror of scaffold-component render/detail.ts: unified fiche ⇒ field-tab term 0, band cartouches excluded via `relatedTabPlacementOf`, synthetic « info » trigger counted, Zod rejects out), `entityViewsFromPagespecFilenames` (`..md` → per-entity view sets), `DETAIL_TAB_BUDGET_WARN/ERR` (7/9) + `DETAIL_SUMMARY_DEMAND_THRESHOLD` (4). Consumers: derive-related-tabs check (RTV-108/PRD-133), derive-detail-summary (PRD-134), audit-dev-frontend DEV-UI-047 | | `page-spec-coded-entity.ts` | Canonical Zod schema + helpers of the pagespec `codedEntity` flag — `CodedEntityFlagSchema` (legacy boolean OR the enriched object `{label, supplied, codeKey, codeInputFields}`, `.passthrough()` so unknown slots survive any writer), `isCodedEntity` (THE reader that replaced every `=== true`), `isSupplied`, `codedLabelOf` (fr→fr??en, others→en??fr — the « Référence » business label of the code column/field), `withSupplied` (merge-preserving write, canonical collapse to `true`). Written by derive-code-specs (stamps facets + codeKey/codeInputFields so the pagespec is SELF-SUFFICIENT), read by scaffold-component (readonly gate + i18n label + create-only SmartCodeField injection), scaffold-business/controller/api-client (supplied create surface) | | `display-field.ts` | SSOT of "which field NAMES a row" — `PREFERRED_DISPLAY_FIELDS` (stored cascade: Name/Label/Code/Title/Libelle/Titre/Reference/Number/Numero), `LOOKUP_DISPLAY_FIELDS` + `preferredDisplayFieldsFor(classification)` (the same cascade **minus `Code`** on a reference table — Code sits 3rd and Libelle 5th, which is how 11 référentiel services shipped every combobox rendering `A_FAIRE` instead of « À faire » and got fixed BY HAND while the generator kept re-emitting it), `PREFERRED_PROJECTED_DISPLAY_FIELDS` (Person entities), `DISPLAYISH_RE` (kebab/camel key test). Consumed by scaffold-business `pickDisplayField` (which FAILS CLOSED — no silent first-string/GUID label; `**Affichage**` in entité.md is the authoring channel, `: Id` the conscious opt-out, and `classification` selects the cascade) and derive-related-tabs-data | | `ba-referential-codes.ts` | THE shared « a reference value does not carry a code » contract — its LABEL is its identity and its natural key; only the USER may decide a reference table carries one, and that DATED decision (`- **Code décidé** : … — décision utilisateur du AAAA-MM-JJ`) OVERRIDES the rule. `classifyReferentialCode` is the ONE verdict (`clean`/`decided`/`near-miss`/`allocated`/`blocked`/`reprise`) that DM-022, DM-012 and the backfill share, with `allocated` tested BEFORE `decided` on purpose (a decided code is SAISI, never ALLOUÉ — otherwise a decision line would silence a real defect); `citationsFor` + the four source converters (`ruleCitationSources`, `acceptanceCitationSources`, `prdCitationSources`, `initialValuesSources`) build the inventory of what BREAKS if the code goes — code values only, whole-word, accent-folded with a length-preserving fold so excerpts stay verbatim. Lives in lib/ (not beside the CLI) because audit-ba may only import cross-skill from the ENUMERATED installer allowlist. Consumers: `create-data-model/cli/derive-referential-codes`, audit-ba DM-022/DM-012/DM-015 | | `ba-sources.ts` | THE shared contract of the CLIENT-SOURCES registry (`.smartstack/sources/`, SIBLING root of `ba/`, committed) — index.json contract (`SourceEntry`: SRC-NNN codes never renumbered/reused, 12-hex content fingerprint = dedup key, `blocked/*` typed statuses so « ingested, 0 extracts » cannot exist), `parseSourceDoc` (the normalized citable `source.md`: anchor + §n sections + tags + verbatim blockquote extracts + scopeNotes), `loadSourcesRegistry` (index ↔ disk reconciled fail-closed, `controls` anchors-vs-parsed so a mute parser cannot look green), the citation grammar `SRC-NNN [§n]` (`citationsInText`, `resolveCitation` 4 states), and `searchSources` (accent-folded, counts ALWAYS published — the phases' targeted-extraction path, nobody reads raw/). Lives in lib/ because audit-ba may only import cross-skill from the ENUMERATED installer allowlist. Consumers: `create-sources/cli/{ingest,search,status}`, audit-ba SRC-001..007 | | `ba-list-split.ts` | THE top-level splitter for BA markdown lists — the reference grammar puts commas INSIDE parentheses (`code (text, requis)` is ONE field), so a bare `split(',')` double-counts entries and truncates what it cites (the DemoGestionFlotte 2026-09-02 SCR-017/018 false-positive class + SCR-019 corrupted evidence). `splitTopLevel` (separators cut at paren depth 0 only, `«…»`/backtick spans protected, orphan `)` clamped), `splitBaList` (+ trim, ONE trailing-`.` strip, `''`/`—` filter — the shared normalization splitList/pushSplit/traceability each half-had), `enumValuesOf` (a Contraintes cell's `/`-bearing top-level segments only — `draft/submitted/approved, requis` never yields a phantom value). Consumers: audit-ba screen-blocks (Colonnes/Filtres/Indicateurs/Champs/Section-Onglet groups, continuations, action pairs) + xd `stateAttrsOf`, ba-screens kanban fallbacks (dropped tokens now WARNED, never silent), ba-use-cases secondaryActors, ba-entities traceability | | `ba-placeholder.ts` | THE « does this document carry a data model? » predicate — `isPlaceholderEntityDoc` (= NO `### ENT-NNN` block, em-dash or ASCII dash) + `PLACEHOLDER_MARKER_RE` (messages only). Three CLIs used to carry their own `/_À définir lors de la phase/` and test it against the WHOLE file: `/ba-create-menu` writes that marker under every not-yet-authored section, so a fully authored `entité.md` routinely keeps one leftover line — and the document was discarded with every relation, i.e. every foreign key (ba-relations skipped it SILENTLY, create-plan-development fell back to index.md deps, derive-lookup-grants REFUSED a complete model). The cascade was the treacherous part: DM-009/DM-014 cried isolation while DM-004/DM-013/DM-005 went green on an empty graph and control-counts saw nothing (it reconciled headings, never relations). Consumers: ba-relations, create-plan-development/parse, create-rbac/derive-lookup-grants | | `ba-menu-tree.ts` | THE shared contract of the `.smartstack/ba/` MENU TREE as a machine object — the `` anchor (`parseNodeAnchor` / `updateNodeAnchor` preserve `depends=`, `previousCodes=` and every unknown attribute in order — the silent-loss class of the full re-Write), the three spellings of a node code (folder `exchange-history` / long-code `EXCHANGE_HISTORY` / nav `exchange-history` — `sectionCodeToFolder`, `sectionFolderToCode`, `navFormOf`), the long-code engines (`renameCodeSegment` module/section/resource on 3- AND 4-segment codes, `removeCodesFromText` with a module wildcard, `countScopeCodes`), the rbac.md human permission paths (`renamePermissionPaths` / `removePermissionPaths` — machine blocks byte-identical), the pagespec references (`renamePagespecRefs`: exact bounded tokens inside the ```json block, re-serialised like the derive CLIs; `residualTokenScan` PUBLISHES what the token lists miss, machine blocks skipped), `renameCrossModuleScopes` (`scope cross-module (APP/MOD)`), the line-level `spliceEnfants` / `spliceDependances`, `loadMenuTree` / `findNode` (same folder exclusions as audit-ba's corpus), `placeholderDocs` (the six concept docs) and `renderIndexMd` (doc-templates shape, empty marker). Also the SINGLE SOURCE of the mechanical menu/section audit constants (`EMPTY_HP_MARKER`, `CONTEXT_MIN_CHARS`, `CONFIG_APP_RE`, `TECHNICAL_FEATURES_RE`, `EXTENSION_DECLARATION_RE`, `AMBIGUOUS_SECTION_NAMES`, `XAPP_SECTION_PATTERNS`, `MENU_BOUNDS`) that audit-ba `rules/menu.ts` + `rules/sections.ts` AND create-menu `cli/menu-node` apply — a node the CLI accepts is a node the audit accepts. Lives in lib/ because the installer only rewrites cross-BA-skill imports for an ENUMERATED list (create-rbac, create-screen): consumers `create-menu/cli/menu-node` (add/rename/delete) and `reconcile-menu/cli/reconcile-menu` (re-exports for its tests) | | `entity-columns.ts` | THE definition of « which columns an **Index** may name » — `knownIndexColumns({fields, owningFks, extra, coded})` = declared fields ∪ synthesised FK columns (owning `*→1`/`1→1`, and the FK a parent's `1→*` puts on the child) ∪ data-scope columns (scaffold side) ∪ `code` when coded ∪ `TenantId`/`CreatedAt`; `isTenantColumn`. Imported by BOTH scaffold-entity/validate.ts (dev time, hard error inside /ba-develop Phase 2) and audit-ba DM-023 (BA time, the same error six phases earlier) so the two cannot drift; pinned by its own test | | `implicit-suffixes.ts` | SSOT of the DynamicRouter IMPLICIT_SUFFIXES table (25 suffixes + BASE_VIEW_KEYS + `isImplicitSuffix`) — mirrors the socle's `DynamicRouter.tsx`. A componentKey's last segment either matches a suffix or must resolve to a seeded nav node. Consumed by uat-plan (`project-roles.ts` typed wrappers) and audit-dev-frontend DEV-UI-046; prose copy in `development/audit/routing-dynamic/SKILL.md` points here | | `external-api-catalog.ts` | SSOT of the PUBLIC stratum — the surface a THIRD PARTY consumes machine-to-machine. Pins the platform's data seam: `PUBLIC_STRATUM_PREFIX` (`/api/v1/export`, the ONLY prefix the external-app route guard whitelists), the 4th-segment code resolution (`codeFromPublicPath`, mirror of `ResolveEndpointCode`), the code grammar `{app}-{section}[-{op}]` + `validatePublicApiCode` (UNIQUE index, 100 chars, platform-reserved codes → a collision fails the BOOT), `PUBLIC_API_OPERATIONS` (one catalogue code per operation with EXACT permissions — the catalogue holds ONE `RequiredPermission` per code and those strings BECOME the app's claims, so a single all-verb code would force a wildcard that widens every existing grant), `catalogRowsFor` (the derivation the scaffolder, the contract publisher and the audit all share), `permissionMatches` (mirror of the platform `PermissionMatcher` — the difference between 200 and a runtime 403 `permission_mismatch`) and the BA authoring channel `parseExternalApiValue`/`renderExternalApiMarker` (`- **API externe** : read, create` on an ENTITY — a public endpoint has no screen, so no pagespec can declare it). Drift-tested (`external-api-catalog:v1`) against the `/external-api` SKILL.md | | `guarded-rm.ts` | `guardedRm(relPaths, {outdir, dryRun})` — the legacy-cleanup sweep every scaffolder's `rmSync(legacyPaths)` goes through: an `@customised` file is NEVER deleted (bespoke seam), every deletion/preservation is returned for envelope tracing (`data.filesRemoved` + warnings), traversal-safe. Adopted by scaffold-api-client + scaffold-business/controller/entity/screen-controller/tests/tests-from-ac | | `template-loader.ts` | Handlebars wrapper with registered helpers | | `output.ts` | Standardized stdout JSON envelope for dev CLIs | | `rule-contradictions.ts` | An audit envelope disagreeing with ITSELF — `detectRuleContradictions` (a `dedupOf` mirror finding in err while EVERY covering finding of its primary is ok; err mirrors only, a warn twin is `relatedTo`; primary absent = no proof, fail-closed), `mergeContradictions`/`contradictionKey` (union by mirror|primary|scope, sorted), `contradictionSignature` (the RULE PAIR — scopes out: one bug on ten modules = one report), `contradictionExcerpt`, `scopeCovers`/`scopeKey`/`scopeLabel`. ONE detector, two readers: the audit-ba engine runs it on its own findings at the end of every run (`selfContradictionWarnings` → envelope warning `audit.rule-contradiction`), /support-report runs it on a captured envelope's `report.findings[]` (class `rule-contradiction`). Pure, structural over the finding shape; lives in lib/ because audit-ba may only import cross-skill from the enumerated installer allowlist | | `support-report.ts` | The fail-closed verifier behind `/support-report` — `classifyFailure` (evidence rule: envelope-controlled → usage-error / **rule-contradiction** (lib/rule-contradictions over `report.findings[]`, re-exported here) / no-failure (with `envelopeRuleIds`, the anchor a verdict dispute must name), stack frame inside the skills tree → cli-internal with 1 run, else ≥ 2 identical normalized signatures; environment signatures and single/diverging runs refused), `normalizeSignature`/`normalizeCommand` (path-fold + volatile masking + `--spec-file`/inline `--spec` masked)/`fingerprintOf` (one defect = one fingerprint = one report; `contradictionSignature` = the rule PAIR, scopes out), `scrubSecrets` (the report travels by email), `isNewerVersion`, `renderReportMd` (French, addressed to support@atlashub.ch — « Contradiction de règles » table, « Entrées jointes », the zip in the transmission block). Consumed by `support-report/cli/create` | | `support-bundle.ts` | The REPRODUCTION half of a support report — `collectInputs` (spec `inputs[]` relative to the project: `validatePathSecurity` (an escape refuses the whole spec), symlinks never followed, `BUNDLE_DEFAULT_EXCLUDES` (VCS, bin/obj/dist, `.smartstack/support`, `*.Local.json`, `.env*`, key files, client-sources `raw/`), text only (extension allowlist + NUL sniff — a binary cannot be scrubbed, so it is never included), every file through `scrubSecrets`, caps 25 MiB total / 5 MiB per file / 5000 files — over the total cap NOTHING is attached, said out loud), `rewriteCommandForBundle` (absolute project paths → `/inputs`), `renderReproMd` (how support re-runs the verbatim command on the bundled layout), `buildZip` (jszip — sorted entries, one fixed date, UTF-8 names so `entité.md` survives Windows Explorer, built from memory so a re-run never nests the previous archive), `sha256Of`. Consumed by `support-report/cli/create` | | `i18n-keys.ts` | i18n key extraction + resolution shared by validate-page (`i18n-keys-resolve`) and audit-dev-frontend (DEV-UI-038) — `LOCALES` (fr/en/it/de), `extractTCalls` (every `t('…')` of a TSX source, `useTranslation` default ns, `hasDefaultValue` flag), `resolveI18nKey` (3-state `string\|object\|missing` — object = the label/children collision), `flattenI18nLeaves` (key-set parity) | | `frontend-fixers.ts` | Tailwind / theme auto-fix utilities for the frontend audit chain | | `screen-grammar.ts` | THE list of `screen.md` bullets the deterministic parsers actually READ (`screen-grammar:v1`) — `SCREEN_BULLETS` (label, folded key, tolerated aliases, readers, kinds, level file) + `SCREEN_BULLET_KEY` (the constants `audit-ba/rules/screen-blocks.ts` switches on — no string literal allowed there) + `renderScreenGrammarTable`. Carried by `create-screen/references/smartcomponents.md`, drift-locked in BOTH directions (table ⇔ SSOT ⇔ the parsers' source) by `lib/__tests__/screen-grammar-drift.test.ts`: a bullet a level file teaches and nobody reads, or a key a parser reads that no reference teaches, cannot exist. `Segments`/`Tri`/`État vide`/`Résumé`/`Widgets` are explicitly « PRD synthesis only » | | `ba-test-data.ts` | THE shared parser of `jeu-de-test.md` — the module's business TEST DATASET (the SECOND seed tier: dev/test/qual via `SmartStack:EnableDevSeeding`, next to the SETUP tier `**Valeurs initiales**`). `parseTestDataDoc` (marker `ba:jeu-de-test`, `Date de référence`, blocks `### JT-NNN — Entity (ENT-NNN)` — STRICT, nothing after the parenthesis —, `- **Clé**` MANDATORY, one markdown table per block, `Note` reserved), tolerant AND fail-closed on loss (`isTestDataRowLoss`: short row, empty row, second table, near-miss heading are SAID and counted — never « 0 rows »), `loadModuleTestData` (absence = a RESULT), `findTestDataSet`, `dataColumnIndexes`. Consumers: lib/ba-test-data-check, audit-ba corpus (full-tree `testDataUniverse` + `testDataSets` control counter), audit-dev-data DEV-DAT-010 | | `ba-test-data-check.ts` | THE deterministic check + normalization of a module's test dataset — ONE engine, two readers (`create-test-data/cli/derive-test-data` and audit-ba DM-030..032; lives in lib/ because audit-ba may only import cross-skill from the installer's ENUMERATED allowlist). `deriveTestData` resolves every FK cell WHERE THE RELATION SAYS the target lives (`same-module` → this dataset or the target's Valeurs initiales; `cross-module (APP/MOD)` → the OWNER module's dataset; `core` User → an actor of acteur.md; other Core → a literal resolved at seed) — by KEY or display value, never a Guid —, checks columns/key/required/enum (verbatim, near-miss suggested)/unique/number/boolean/calendar dates/coded Code/cycles intra+inter-modules/Flow statuses/reference dates, and in `derive` mode emits `scaffold-seed testData[]` (blocks in topological order, cells typed, `needsTypes` for enums, `{ref, entity, keyField, key}` / `{actor, label}` / `{core, by, value}` cells, module `rank`). An unresolved citation names the OWNER; an absent file is `status: absent`, never an error | | `remediation.ts` | THE shared audit -> correction contract — 5 lanes (`derive` a derive-* CLI in write mode, `scaffold` re-run the generator, `rewrite` an in-place mechanical fix, `authoring` hand off to the create-* skill that owns the document's grammar, `manual`), `EXECUTION_ORDER` = derive -> scaffold -> rewrite (a CONSTRAINT: a rewrite applied before a regeneration is overwritten by it), `REMEDY_REGISTRY` (executable remedies only — every row is a `mode:check` engine that already backs the rule), `DIMENSION_AUTHORING_SKILL` (explicit table: `ba-create-${dimension}` is WRONG — use-cases -> ba-create-use-case, rules -> ba-create-business-rules, cross-dimension -> none; DM-029..032 carry their OWN authoring rows -> ba-create-test-data, the dimension default would route jeu-de-test.md at entité.md's author), `resolveRemedy` (TOTAL — falls back to authoring then manual, never undefined) and `remedyFromDevFinding` (adapts the audit-dev-* `fixSkill`/`autoFixable` fields). cliPaths are CONTIGUOUS literals so the installer's `skills/business-analyse/` -> `skills/ba-*` rewrite catches them. Drift-tested (`remediation:v1`); consumed by audit-ba and by /audit-fix | Import from CLIs via relative path, e.g. `import { … } from '../../../../lib/.js'` — the number of `../` depends on the skill's depth (3 for `/cli//`, 4 for `//cli//`, 5 for `development///cli//`). A wrong count is invisible to the test suite until the CLI is launched — count from the CLI folder up to `skills/`. ## external (external tool wrappers) | Skill | Role | |-------|------| | `context7` | Wraps the `ctx7` CLI (Upstash Context7) — fetches up-to-date library docs via Bash. Replaces the legacy MCP server. | | `dev-browser` | Points to the SawyerHood/dev-browser plugin (browser automation via sandboxed QuickJS WASM). Installed via `/plugin marketplace add sawyerhood/dev-browser`. | ## gitflow (workflow) | Skill | CLI | Role | |-------|-----|------| | `gitflow` | `cli/` (12 colocalized CLIs) | Drives the GitFlow workflow | Sub-files: `_shared.md`, `agents/*.md` (11 agents — `generate-msg` is CLI-only). CLIs: `cli/{init,start,commit,sync,update,pr,merge,finish,status,cleanup,abort,generate-msg}/` — each with `types.ts` (Zod), `validate.ts`, `execute.ts`, `index.ts`. Shared lib: `cli/lib/` — self-contained git utilities. Config stored at `/.gitflow/config.json` (shared across worktrees; legacy `.claude/gitflow/config.json` is auto-migrated). ## efcore (EF Core migrations) | Skill | CLI | Role | |-------|-----|------| | `efcore` | `cli/` (6 colocalized CLIs) | EF Core migration workflow | Sub-files: `_shared.md` (naming, `dotnet-ef` PATH, dual DbContext), `agents/*.md` (list, status, create, squash, rebase-snapshot, db-update, recreate-db — `apply` is CLI-only). CLIs: `cli/{list,status,create,squash,rebase-snapshot,apply}/` — each with `types.ts` (Zod), `validate.ts`, `execute.ts`, `index.ts`. Shared lib: `cli/lib/` — `detect-dbcontexts`, `parse-csproj-version`, `migration-name`, `ef-runner`. Naming convention: `{prefix}_v{version}_{seq3}_{Description}` — computed by `cli/lib/migration-name.ts`. ## business-analyse/ → deployed as top-level `/ba-*` commands File-based business analysis (native Claude Code — **no Studio, no JSON envelopes, no `[ACTION]`/`[QUESTION]` blocks**). Each skill reads/writes the **`.smartstack/ba/` markdown tree** (Application → Module → Section → Resource; each node folder holds `index.md` + `acteur.md`, `entité.md`, `use-case.md`, `règles-métier.md`, `rbac.md`, `screen.md`). The shared file model + doc skeletons live in `_workflow/ba-files.md` and `_workflow/doc-templates.md`; the client-proposal method (mandatory research → internal draft → self-audit → 3-tier presentation Obligatoire / Suggestion / Élargissement) lives in `_workflow/proposal-method.md` (drift-locked via `lib/proposal-tiers.ts`). Authored under `business-analyse//`, the installer **flattens + prefixes** each to `ba-/` so it is invocable as `/ba-` (`_workflow/` and any index are repo-only, not deployed). | Skill (invoked as) | Phase | Writes | |--------------------|-------|--------| | `/ba-create-menu` | 1 menu | the node tree (`index.md` per node) — colocated CLI `cli/menu-node/` (add / rename / delete ONE node, `mode:check` = the plan shown before AskUserQuestion, `mode:write` applies it): the LLM authors label / Contexte / Hors-périmètre / Sources, the CLI does the shape — folder + canonical `index.md` + six placeholders, ONE spliced line in the parent `## Enfants` (its anchor `depends=`/`previousCodes=`, Contexte and `**Sources**` byte-identical — what a full re-Write used to lose); `rename` knows from → to and rewrites deterministically what reconcile-menu would have to GUESS (every long code incl. MODULE renames and 4-segment resource codes, rbac.md human permission paths with machine blocks locked, sibling `depends=` + `## Dépendances`, `scope cross-module (APP/MOD)`, pagespec tokens `section`/`module`/`permission`/`navRoute`/`fkTo`/`relatedModule`/`relatedSection`/`apiEndpoint`/`targetRoute`, folder move, `previousCodes=