@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/lib/template-loader.ts

@@ -0,0 +1,115 @@
+/**
+ * lib/template-loader.ts — Handlebars template loader for dev CLIs.
+ *
+ * Loads a .hbs file from a directory, registers a small set of helpers used by
+ * SmartStack scaffolders (case conversions, join, eq), and returns a render function.
+ *
+ * Usage:
+ *   import { loadTemplate } from '../../../../lib/template-loader.js';
+ *   const render = await loadTemplate('entity.cs.hbs', import.meta.url);
+ *   const rendered = render({ name: 'Employee', module: 'HR' });
+ */
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
+import { readText } from './fs.js';
+import {
+  toKebabCase,
+  toCamelCase,
+  toPascalCase,
+  capitalize,
+  singularize,
+  pluralize,
+} from './string-utils.js';
+
+// ─── Shared helper registration (runs once per process) ───────────────────
+
+let helpersRegistered = false;
+
+function registerHelpers(): void {
+  if (helpersRegistered) return;
+
+  Handlebars.registerHelper('kebab', (s: unknown) => toKebabCase(String(s ?? '')));
+  Handlebars.registerHelper('camel', (s: unknown) => toCamelCase(String(s ?? '')));
+  Handlebars.registerHelper('pascal', (s: unknown) => toPascalCase(String(s ?? '')));
+  Handlebars.registerHelper('capitalize', (s: unknown) => capitalize(String(s ?? '')));
+  Handlebars.registerHelper('singular', (s: unknown) => singularize(String(s ?? '')));
+  Handlebars.registerHelper('plural', (s: unknown) => pluralize(String(s ?? '')));
+
+  Handlebars.registerHelper('eq', (a: unknown, b: unknown) => a === b);
+  Handlebars.registerHelper('neq', (a: unknown, b: unknown) => a !== b);
+
+  Handlebars.registerHelper('join', (arr: unknown, sep: unknown) => {
+    if (!Array.isArray(arr)) return '';
+    return arr.join(String(sep ?? ', '));
+  });
+
+  Handlebars.registerHelper('includes', (arr: unknown, value: unknown) => {
+    if (!Array.isArray(arr)) return false;
+    return arr.includes(value);
+  });
+
+  helpersRegistered = true;
+}
+
+// ─── Public API ────────────────────────────────────────────────────────────
+
+/**
+ * Load a Handlebars template by name from a directory.
+ *
+ * @param templateFile - The .hbs filename (e.g. "entity.cs.hbs")
+ * @param dirHint      - Either a directory path, a file path, or an import.meta.url.
+ *                       If the hint is a URL or a file path, the loader resolves
+ *                       the containing directory and looks for `templates/<name>`
+ *                       inside it.
+ * @returns A function that takes a data object and returns the rendered string.
+ */
+export async function loadTemplate(
+  templateFile: string,
+  dirHint: string,
+): Promise<(data: Record<string, unknown>) => string> {
+  registerHelpers();
+
+  const baseDir = resolveTemplatesDir(dirHint);
+  const templatePath = path.join(baseDir, templateFile);
+  const source = await readText(templatePath);
+  return Handlebars.compile(source, { noEscape: true });
+}
+
+/**
+ * Synchronous variant — load and compile several templates at once.
+ * Returns a map { templateFile → render function }.
+ */
+export async function loadTemplates(
+  templateFiles: string[],
+  dirHint: string,
+): Promise<Map<string, (data: Record<string, unknown>) => string>> {
+  const map = new Map<string, (data: Record<string, unknown>) => string>();
+  for (const file of templateFiles) {
+    map.set(file, await loadTemplate(file, dirHint));
+  }
+  return map;
+}
+
+// ─── Internals ─────────────────────────────────────────────────────────────
+
+function resolveTemplatesDir(hint: string): string {
+  // import.meta.url → file:// URL
+  if (hint.startsWith('file:')) {
+    const dir = path.dirname(fileURLToPath(hint));
+    return path.join(dir, 'templates');
+  }
+
+  // Absolute path
+  if (path.isAbsolute(hint)) {
+    // If hint ends with .ts/.js assume it's a file → use its parent dir
+    if (hint.endsWith('.ts') || hint.endsWith('.js') || hint.endsWith('.mjs')) {
+      return path.join(path.dirname(hint), 'templates');
+    }
+    // Otherwise assume it's a directory → append templates/
+    return path.join(hint, 'templates');
+  }
+
+  // Relative path → resolve from cwd
+  return path.resolve(process.cwd(), hint, 'templates');
+}

package/templates/skills/lib/url-conventions.ts

@@ -0,0 +1,151 @@
+/**
+ * lib/url-conventions.ts — Single source of truth for the bi-strata API URL
+ * conventions. Imported by BOTH backend scaffolders (`scaffold-controller`,
+ * `scaffold-screen-controller`) AND the frontend `scaffold-api-client`, plus
+ * the static parity audit `audit-dev-wire`.
+ *
+ * Two strata exist; nothing else is legal:
+ *   - **Integration**  /api/v1/integration/{plural-kebab}     (machine-to-machine CRUD)
+ *   - **Screen-driven** /api/screens/{plural-kebab}/{view}    (UI-facing, shaped by pagespec)
+ *
+ * Centralising the two prefixes here makes drift mathematically impossible —
+ * the route emitted by the C# controller and the URL called by the TS service
+ * derive from the same constant.
+ */
+
+import { toKebabCase } from './string-utils.js'
+
+export const INTEGRATION_STRATUM_PREFIX = '/api/v1/integration'
+export const SCREEN_STRATUM_PREFIX = '/api/screens'
+
+export type Stratum = 'direct' | 'integration' | 'screens' | 'unknown'
+
+/**
+ * Build the direct-mode base path for an entity — the standard SmartStack
+ * controller route: `/api/{appCode}/{module}/{section}`.
+ *
+ *   buildDirectRoute('gaf', 'referentiels', 'employes')
+ *     → '/api/gaf/referentiels/employes'
+ */
+export function buildDirectRoute(appCode: string, module: string, sectionKebab: string): string {
+  return `/api/${appCode.toLowerCase()}/${module}/${sectionKebab}`
+}
+
+/**
+ * Build the integration-stratum base path for an entity.
+ * Used by `scaffold-controller` and by `scaffold-api-client` in legacy mode.
+ *
+ *   buildIntegrationRoute('demandes')      → '/api/v1/integration/demandes'
+ *   buildIntegrationRoute('multi-words')   → '/api/v1/integration/multi-words'
+ */
+export function buildIntegrationRoute(pluralKebab: string): string {
+  return `${INTEGRATION_STRATUM_PREFIX}/${pluralKebab}`
+}
+
+/**
+ * Build the screen-driven base path for an entity.
+ * Used by `scaffold-screen-controller` and by `scaffold-api-client` in
+ * `useScreens=true` mode.
+ *
+ *   buildScreenRoute('demandes')           → '/api/screens/demandes'
+ */
+export function buildScreenRoute(pluralKebab: string): string {
+  return `${SCREEN_STRATUM_PREFIX}/${pluralKebab}`
+}
+
+/**
+ * Per-view suffix appended to a screen-driven base path.
+ * Used by both sides so that the controller's `[HttpVerb("<suffix>")]` and
+ * the api-client's URL string come from the same lookup.
+ *
+ *   buildScreenViewPath('list')      → '/list'
+ *   buildScreenViewPath('detail')    → '/detail/{id:guid}'
+ *   buildScreenViewPath('form')      → '/form'
+ *   buildScreenViewPath('dashboard') → '/dashboard/consolidated'
+ *
+ * Hub views (`section-home`, `app-home`, `module-home`) deliberately have no
+ * suffix — they are Slot containers that emit no API call.
+ */
+export type ScreenView = 'list' | 'detail' | 'form' | 'dashboard'
+export function buildScreenViewPath(view: ScreenView): string {
+  switch (view) {
+    case 'list':
+      return '/list'
+    case 'detail':
+      return '/detail/{id:guid}'
+    case 'form':
+      return '/form'
+    case 'dashboard':
+      return '/dashboard/consolidated'
+  }
+}
+
+/**
+ * Compute the URL-segment plural for an entity name. PascalCase → kebab-case
+ * with proper handling of consecutive uppercase letters (`HRDepartment` →
+ * `hr-department`). Equivalent across all scaffolders — never reimplement.
+ */
+export function pluralSegment(pluralName: string): string {
+  return toKebabCase(pluralName)
+}
+
+/**
+ * Canonicalise an arbitrary route literal (as emitted on either side) into its
+ * stratum + remainder. Used by `audit-dev-wire` to compare frontend calls and
+ * backend routes on equal ground.
+ *
+ *   canonicaliseRoute('/api/v1/integration/demandes/lookup')
+ *     → { stratum: 'integration', rest: 'demandes/lookup' }
+ *   canonicaliseRoute('/api/screens/demandes/dashboard/consolidated')
+ *     → { stratum: 'screens', rest: 'demandes/dashboard/consolidated' }
+ *   canonicaliseRoute('/api/affaires/accueil/dashboard')
+ *     → { stratum: 'unknown', rest: 'affaires/accueil/dashboard' }
+ *
+ * The `unknown` stratum is the early-warning signal that something has drifted
+ * — every legal URL in the generated app falls under one of the two known
+ * prefixes.
+ */
+export function canonicaliseRoute(raw: string): { stratum: Stratum; rest: string } {
+  const trimmed = raw.replace(/^\/+/, '/')
+  if (trimmed.startsWith(`${INTEGRATION_STRATUM_PREFIX}/`)) {
+    return { stratum: 'integration', rest: trimmed.slice(INTEGRATION_STRATUM_PREFIX.length + 1) }
+  }
+  if (trimmed === INTEGRATION_STRATUM_PREFIX) {
+    return { stratum: 'integration', rest: '' }
+  }
+  if (trimmed.startsWith(`${SCREEN_STRATUM_PREFIX}/`)) {
+    return { stratum: 'screens', rest: trimmed.slice(SCREEN_STRATUM_PREFIX.length + 1) }
+  }
+  if (trimmed === SCREEN_STRATUM_PREFIX) {
+    return { stratum: 'screens', rest: '' }
+  }
+  return { stratum: 'unknown', rest: trimmed.replace(/^\/?(?:api\/)?/, '') }
+}
+
+/**
+ * Build the route segment for a single custom action on either stratum.
+ * The screen-driven controller emits this same segment under its
+ * `[Route("api/screens/{plural}")]` class-level attribute.
+ *
+ *   buildCustomActionPath({ scope: 'row',    code: 'archive' })           → 'detail/{id:guid}/archive'
+ *   buildCustomActionPath({ scope: 'bulk',   code: 'export' })            → 'bulk/export'
+ *   buildCustomActionPath({ scope: 'header', code: 'sync-from-pce' })     → 'sync-from-pce'
+ *
+ * The `stratum` parameter only affects the row-scope segment — the integration
+ * stratum uses `{id:guid}/<code>` (no `detail` prefix) while the screen
+ * stratum prefixes with `detail/` so the URL grouping mirrors the GET detail
+ * endpoint. This matches what `scaffold-controller` and
+ * `scaffold-screen-controller` already emit today.
+ */
+export function buildCustomActionPath(args: {
+  scope: 'row' | 'bulk' | 'header'
+  code: string
+  stratum?: Stratum
+}): string {
+  const { scope, code, stratum = 'integration' } = args
+  if (scope === 'row') {
+    return stratum === 'screens' ? `detail/{id:guid}/${code}` : `{id:guid}/${code}`
+  }
+  if (scope === 'bulk') return `bulk/${code}`
+  return code
+}

package/templates/skills/package.json

@@ -0,0 +1,5 @@
+{
+  "private": true,
+  "type": "module",
+  "description": "ESM marker for the whole SmartStack skills tree. The CLIs are authored ESM (top-level await, import.meta.url, .js import specifiers) but the host CLI repo is type:commonjs; tsx derives module format from the nearest package.json, so without this marker `npx tsx skills/<phase>/<skill>/cli/<cli>/index.ts` compiles to CJS and crashes on top-level await. Deploys to ~/.claude/skills/package.json via the installer (getTemplateFiles copies non-dotfiles; remapSkillPath passes it through). Do not remove."
+}

package/templates/skills/quick-search/SKILL.md

@@ -1,99 +1,99 @@
----
-name: quick-search
-description: Lightning-fast search to answer specific questions - optimized for speed
-argument-hint: <question>
-context: fork
-agent: Explore
-model: haiku
-allowed-tools: Grep, Glob, Read
----
-
-## Question
-$ARGUMENTS
-
-<objective>
-Answer questions at maximum speed using direct search tools. No agents, no deep analysis - just fast answers with citations.
-
-**Note:** This skill runs in an isolated context. Use Grep, Glob, and Read directly.
-</objective>
-
-<quick_start>
-```bash
-/quick-search where is LoginForm defined?
-/quick-search find all API routes
-/quick-search what config files exist?
-```
-</quick_start>
-
-<workflow>
-
-## 1. Identify
-
-Parse the question:
-- Extract key search terms
-- Determine target file types or patterns
-- **CRITICAL**: Be surgical - know exactly what to search
-
-## 2. Search (Direct Tools Only)
-
-Use direct tools - **NO AGENTS**:
-- `Grep` for code content search with specific patterns
-- `Glob` for file name/path patterns
-- Launch searches **in parallel** when possible
-
-**SPEED RULE**: Max 2-3 search iterations total
-
-## 3. Read (Targeted)
-
-- `Read` only the most relevant files found
-- **CRITICAL**: Max 3-5 files - be selective
-- Scan for the specific answer needed
-
-## 4. Answer
-
-Direct response:
-- Immediate answer to the question
-- Include file references with line numbers (`file.ts:42`)
-- **NO**: Long explanations or architectural context
-- **YES**: Concise answer with evidence
-
-</workflow>
-
-<search_patterns>
-
-**Finding implementations:**
-```
-Grep: pattern="class FooBar" or "function fooBar"
-```
-
-**Finding configs:**
-```
-Glob: pattern="**/config.{js,ts,json}"
-```
-
-**Finding imports/usage:**
-```
-Grep: pattern="from ['\"].*moduleName['\"]"
-```
-
-</search_patterns>
-
-<execution_rules>
-
-- **SPEED FIRST**: Answer in under 30 seconds
-- **NO AGENTS**: Use direct tools only (Grep, Glob, Read)
-- **PARALLEL SEARCH**: Run independent searches simultaneously
-- **MINIMAL READING**: Read only what's absolutely necessary
-- **NO DEEP ANALYSIS**: Surface-level answers with citations
-- **STOP EARLY**: Once you have the answer, respond immediately
-
-</execution_rules>
-
-<priority>
-Speed > Completeness. Fast answers beat perfect answers.
-</priority>
-
-<success_criteria>
-- Question answered with file path and line number citations
-- Response delivered within 2-3 search iterations
-</success_criteria>
+---
+name: quick-search
+description: Lightning-fast search to answer specific questions - optimized for speed
+argument-hint: <question>
+context: fork
+agent: Explore
+model: haiku
+allowed-tools: Grep, Glob, Read
+---
+
+## Question
+$ARGUMENTS
+
+<objective>
+Answer questions at maximum speed using direct search tools. No agents, no deep analysis - just fast answers with citations.
+
+**Note:** This skill runs in an isolated context. Use Grep, Glob, and Read directly.
+</objective>
+
+<quick_start>
+```bash
+/quick-search where is LoginForm defined?
+/quick-search find all API routes
+/quick-search what config files exist?
+```
+</quick_start>
+
+<workflow>
+
+## 1. Identify
+
+Parse the question:
+- Extract key search terms
+- Determine target file types or patterns
+- **CRITICAL**: Be surgical - know exactly what to search
+
+## 2. Search (Direct Tools Only)
+
+Use direct tools - **NO AGENTS**:
+- `Grep` for code content search with specific patterns
+- `Glob` for file name/path patterns
+- Launch searches **in parallel** when possible
+
+**SPEED RULE**: Max 2-3 search iterations total
+
+## 3. Read (Targeted)
+
+- `Read` only the most relevant files found
+- **CRITICAL**: Max 3-5 files - be selective
+- Scan for the specific answer needed
+
+## 4. Answer
+
+Direct response:
+- Immediate answer to the question
+- Include file references with line numbers (`file.ts:42`)
+- **NO**: Long explanations or architectural context
+- **YES**: Concise answer with evidence
+
+</workflow>
+
+<search_patterns>
+
+**Finding implementations:**
+```
+Grep: pattern="class FooBar" or "function fooBar"
+```
+
+**Finding configs:**
+```
+Glob: pattern="**/config.{js,ts,json}"
+```
+
+**Finding imports/usage:**
+```
+Grep: pattern="from ['\"].*moduleName['\"]"
+```
+
+</search_patterns>
+
+<execution_rules>
+
+- **SPEED FIRST**: Answer in under 30 seconds
+- **NO AGENTS**: Use direct tools only (Grep, Glob, Read)
+- **PARALLEL SEARCH**: Run independent searches simultaneously
+- **MINIMAL READING**: Read only what's absolutely necessary
+- **NO DEEP ANALYSIS**: Surface-level answers with citations
+- **STOP EARLY**: Once you have the answer, respond immediately
+
+</execution_rules>
+
+<priority>
+Speed > Completeness. Fast answers beat perfect answers.
+</priority>
+
+<success_criteria>
+- Question answered with file path and line number citations
+- Response delivered within 2-3 search iterations
+</success_criteria>

package/templates/skills/review/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: review
+description: Multi-category code review — security, architecture, performance
+group: E
+allowed-tools: [Read, Glob, Grep]
+---
+
+# Skill: Code Review
+
+> Multi-category code review guide.
+
+## 9 Review Categories
+
+### 1. Security (OWASP Top 10)
+- No hardcoded secrets (CWE-798)
+- No SQL injection (CWE-89)
+- Tenant isolation (CWE-639)
+- Authorization on each controller (CWE-862)
+
+### 2. Architecture (Clean Architecture)
+- Controller → Service → Repository (no layer skipping)
+- DTOs only at boundaries
+
+### 3. Hardcoded Values
+- No connection strings, URLs, credentials in code
+
+### 4. Test Coverage
+- Each branch has a test
+- Naming: `{Method}_When{Condition}_Should{Result}`
+
+### 5. Performance
+- No N+1 queries
+- `AsNoTracking()` for read-only queries
+- `CancellationToken` propagated everywhere
+
+### 6. Dead Code
+- No unused private methods
+
+### 7. Quality Metrics
+- Cognitive complexity < 15, cyclomatic < 10
+- Function size < 50 lines, nesting < 3
+
+### 8. i18n
+- No hardcoded UI strings
+
+### 9. Accessibility
+- Labels, alt text, keyboard navigation
+
+## Severities
+
+| Level | Meaning |
+|-------|---------|
+| blocking | Must be fixed before merge |
+| critical | Immediate correction recommended |
+| warning | Best practice |
+| info | Suggestion |

package/templates/skills/smoke-generation/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: smoke-generation
-description: 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.
+description: 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 "documented-but-missing-symbol" class of drift (e.g. the historical EntityLookup paradox, now resolved by the ui-primitives scaffolder).
 argument-hint: "[--quick|--full] [--scope=frontend|backend|all] [--app-path=<path>] [--report-only]"
 model: sonnet
 allowed-tools: Read, Grep, Glob, Bash, Write
@@ -14,7 +14,7 @@ allowed-tools: Read, Grep, Glob, Bash, Write
 - Last smoke run: !`cat .claude/cache/smoke-generation.json 2>/dev/null | head -5 || echo "no previous run"`
 
 <objective>
-Detect "documentation lies": patterns/imports/types that the CLI documents as canonical (and may even enforce via post-checks) but that do NOT exist in SmartStack.app. The canonical example is `EntityLookup`: documented in 4 CLI files and enforced by check C7, but the component does not exist in `web/smartstack-web/src/components/ui/`. This skill would have caught that on day 1.
+Detect "documentation lies": patterns/imports/types that the CLI documents as canonical (and may even enforce via post-checks) but that do NOT exist in SmartStack.app. The historical canonical example was `EntityLookup` (documented in 4 CLI files and enforced by check C7, while the component existed nowhere); that one is now resolved — `scaffold-ui-primitives` scaffolds `src/components/ui/EntityLookup.tsx` into the client project at Phase 3.0, and audit DEV-UI-022 enforces its usage on FK fields. The skill still detects future paradoxes of the same shape: any new `import { Foo } from '@/…'` that resolves nowhere — neither in `SmartStack.app` (npm SDK) nor in the CLI's `templates/skills/development/frontend/ui-primitives/` (scaffolded primitives) — is flagged.
 
 Two modes :
 - **`--quick` (default)** — pure static analysis (~30s). Greps imports / types / method signatures in `templates/skills/**/*.md`, verifies each one resolves to a real file or symbol in `D:/01 - projets/SmartStack.app/features/IA-Workflow/`.
@@ -40,8 +40,8 @@ APP_ROOT      = D:/01 - projets/SmartStack.app/features/IA-Workflow   # default
 APP_FRONTEND  = $APP_ROOT/web/smartstack-web/src
 APP_BACKEND   = $APP_ROOT/src/SmartStack.Domain   (+ Application + Infrastructure + Api)
 
-CLI_TEMPLATES = D:/01 - projets/SmartStack.cli/02-Develop/templates/skills
-CACHE_FILE    = D:/01 - projets/SmartStack.cli/02-Develop/.claude/cache/smoke-generation.json
+CLI_TEMPLATES = D:/01 - projets/SmartStack.cli/features/version-5-optimisation/templates/skills
+CACHE_FILE    = D:/01 - projets/SmartStack.cli/features/version-5-optimisation/.claude/cache/smoke-generation.json
 ```
 
 If `--app-path=<path>` is provided, override `APP_ROOT`.
@@ -56,7 +56,7 @@ If `--app-path=<path>` is provided, override `APP_ROOT`.
 APP_ROOT="${APP_PATH:-D:/01 - projets/SmartStack.app/features/IA-Workflow}"
 [ -d "$APP_ROOT/src/SmartStack.Domain" ] || { echo "ERROR: APP_ROOT not found at $APP_ROOT"; exit 1; }
 [ -d "$APP_ROOT/web/smartstack-web/src" ] || { echo "ERROR: app frontend not found"; exit 1; }
-mkdir -p "D:/01 - projets/SmartStack.cli/02-Develop/.claude/cache"
+mkdir -p "D:/01 - projets/SmartStack.cli/features/version-5-optimisation/.claude/cache"
 ```
 
 ## Step 1 — Frontend static checks (`--scope=frontend|all`)
@@ -66,7 +66,7 @@ mkdir -p "D:/01 - projets/SmartStack.cli/02-Develop/.claude/cache"
 Grep all `import { X } from '@/components/...'` (and similar) across `templates/skills/**/*.md` :
 
 ```bash
-TEMPLATES_ROOT="D:/01 - projets/SmartStack.cli/02-Develop/templates/skills"
+TEMPLATES_ROOT="D:/01 - projets/SmartStack.cli/features/version-5-optimisation/templates/skills"
 APP_FRONTEND="$APP_ROOT/web/smartstack-web/src"
 
 # Collect imports of the form: import { Foo, Bar } from '@/{path}'
@@ -159,7 +159,7 @@ Critical method signatures to cross-check :
 ### 3.1 i18n namespace consistency
 Already covered by `frontend-checks.sh` C28 — call it directly :
 ```bash
-bash "$TEMPLATES_ROOT/apex/references/checks/frontend-checks.sh" 2>&1 | grep -E "C28|i18n"
+# frontend-checks.sh was removed in v5 — use /audit-dev-frontend DEV-UI-004 instead
 ```
 
 ### 3.2 Theme tokens documented vs exposed
@@ -199,12 +199,14 @@ SCOPE : {scope}   MODE : {quick|full}
 DETAILED ISSUES
 --------------------------------------------------------------------------------
 
-[BROKEN] @/components/ui/EntityLookup
+[BROKEN] @/components/ui/SomeMissingPrimitive
   → Referenced in :
-    - templates/skills/ui-components/SKILL.md:64
-    - templates/skills/apex/references/smartstack-frontend.md:6 (multiple)
-    - templates/skills/apex/references/checks/frontend-checks.sh:147 (C7 enforcement)
-  → Action : either scaffold the component in app, OR remove from CLI doc.
+    - templates/skills/development/frontend/component/cli/scaffold-component/generate.ts:NNN
+    - (apex/references removed in v5 — check development/frontend/*/SKILL.md)
+  → Action : either add the component to SmartStack.app SDK,
+             OR scaffold it into the client project via a new
+             primitive in templates/skills/development/frontend/ui-primitives/,
+             OR remove the dead reference from the CLI templates.
 
 [DRIFT] NavigationApplication.Create signature
   → CLI docs : Create(code, label, ..., isOpen=false, isPersonal=false)
@@ -253,7 +255,7 @@ This mode is documented for completeness but is OPTIONAL — `--quick` covers ~8
 
 1. Create a sandbox under `~/.smartstack-smoke/run-{timestamp}/`
 2. Run `ss init smoke-test --provider=azure-devops --no-prompt` in the sandbox
-3. Generate a representative module via MCP : 1 entity (`Product`), 1 FK (`CategoryId`), one CRUD page set (List, Detail, Create, Edit)
+3. Generate a representative module via the development skills (`/development/backend/entity`, `/development/backend/controller`, …) : 1 entity (`Product`), 1 FK (`CategoryId`), one CRUD page set (List, Detail, Create, Edit)
 4. Run :
    - `cd src/SmartStack.Api && dotnet restore && dotnet build`
    - `cd web/smartstack-web && npm install && npm run build`
@@ -263,7 +265,7 @@ This mode is documented for completeness but is OPTIONAL — `--quick` covers ~8
 ### When to prefer `--full` over `--quick`
 
 - Before publishing a new CLI version (release gate)
-- After a non-trivial refactor of MCP scaffolding
+- After a non-trivial refactor of the scaffolding CLIs in `templates/skills/development/`
 - When `--quick` reports 0 issues but you suspect a runtime-only problem
 
 ### Cost
@@ -299,13 +301,13 @@ bash -c '/smoke-generation --quick --report-only' && exit 0 || {
 - **Quick mode misses runtime-only errors** : a bad TS generic, a wrong async return shape, a missing CSS class — `--full` mode is needed for these.
 - **Heuristic regex** : may produce false positives on unusual import syntaxes (rare in practice). Verify each `[BROKEN]` manually if in doubt.
 - **Single source of truth** : assumes the IA-Workflow branch IS the source of truth for v3.46+. Override via `--app-path` if testing against a different branch (e.g. for forward-compat testing on a feature branch).
-- **Does not check MCP scaffolders** : the C# code emitted by MCP tools (`scaffold_extension`, `scaffold_routes`, …) is not validated by this skill. Use `--full` for that path.
+- **Does not check scaffolder output** : the C# / TS code emitted by `templates/skills/development/**/cli/scaffold-*/` CLIs is not validated by this skill. Use `--full` for that path.
 
 </known_limitations>
 
 <success_criteria>
 - Quick mode runs in < 60 seconds on a clean install
-- Detects the "EntityLookup class of drift" reliably (documented import not present in app)
+- Detects the "documented-but-missing-symbol class of drift" reliably (any import that resolves nowhere — neither in `SmartStack.app` SDK nor in `templates/skills/development/frontend/ui-primitives/`). EntityLookup was the historical exemplar; the same detector now catches its successors.
 - Detects method signature drift (parameters added/removed in app but doc not updated)
 - Detects missing CSS theme variables (doc claims a token, app doesn't expose it)
 - Reports are deterministic, scannable, and actionable