devendra-skill-package 1.0.2

package/.github/skills/feature-generator/SKILL.MD

@@ -0,0 +1,2741 @@
+# feature-generator
+
+## Skill Metadata
+
+```yaml
+name: feature-generator
+version: 3.1.0
+description: >
+  Supports two generation modes: single-screen and multi-screen module.
+  In both modes: asks 5 mandatory questions (design source, user stories, test
+  cases, business logic, API details + mapping), crawls the repository to build
+  an Architecture Fingerprint, then generates every layer of production-ready
+  React Native TypeScript code that fits the repository as-is.
+  In module mode: collects Q2–Q5 per screen, deduplicates shared entities,
+  generates one DI bootstrap for the whole module, and registers all screens
+  in the navigator in a single pass.
+  After generation, runs a post-completion validation phase that checks file
+  existence, imports, mapping coverage, business logic, test cases, user stories,
+  and code quality — auto-fixing every issue before reporting completion.
+priority: high
+auto-trigger:
+  - "generate feature from spec"
+  - "create feature from md"
+  - "build screen from spec"
+  - "md-driven feature"
+  - "spec to feature"
+  - "generate module from spec"
+  - "build module from md"
+  - "create module"
+  - "multi-screen feature"
+```
+
+---
+
+## Assets and References
+
+| File | Purpose |
+|---|---|
+| `assets/spec-template.md` | Blank fillable spec template for users. Copy and fill before invoking the skill. |
+| `assets/fingerprint-schema.json` | JSON Schema (draft-07) for the Architecture Fingerprint produced in Phase 0.K. Use to validate the fingerprint before proceeding to Phase 1. |
+| `assets/transform-rules.json` | Configurable map of response mapping transform keywords to TypeScript expressions. Read in Phase 7.2. |
+| `references/api-envelope-patterns.md` | Full code templates for every `apiLib` + `envelopeStyle` combination. Read in Phase 4.6. |
+| `references/state-library-patterns.md` | Full code templates for Zustand, MobX, Context API, and RTK direct-import. Read in Phase 5 when `stateLib` is not `redux-toolkit/thunk-extra`. |
+| `references/screen-logic-patterns.md` | React Native JSX implementations for every screen logic pattern. Read in Phase 7.3. |
+
+---
+
+## Overview
+
+This skill turns a human-authored Markdown specification into production-ready
+React Native TypeScript code that fits the repository as-is — not as assumed.
+
+**Core philosophy**: Every decision about folder layout, import paths, state
+management, API calling convention, naming style, and navigation must come from
+reading the actual repository. Nothing is assumed. The skill crawls first and
+codes second.
+
+### Generation Modes
+
+This skill operates in one of two modes, determined during PHASE -1 Q1:
+
+| Mode | When to use | What gets generated |
+|---|---|---|
+| **single** | One screen, one API, self-contained | All layers for one screen |
+| **module** | Multiple screens that share a feature folder (e.g. FD Booking with Details, Payment, Confirmation screens) | All layers for every screen + one shared DI bootstrap for the module + shared entities deduplicated across screens + all screens registered in navigator in one pass |
+
+**Module folder structure (example — `fdBooking` module with 3 screens):**
+```
+features/
+  fdBooking/
+    domain/
+      models/          ← shared entities used by more than one screen live here
+        FdBookingItem.ts
+      repositories/    ← one repo interface per screen
+      useCases/        ← one use case per screen
+    data/
+      dtos/            ← one DTO per screen
+      mappers/         ← one mapper per screen
+      datasources/     ← one datasource per screen + shared endpoints + mockConfig
+    state/             ← one slice per screen (or one shared slice if confirmed by user)
+      store/
+      selectors/
+    presentation/
+      screens/
+        FdDetailsScreen/
+        PaymentScreen/
+        ConfirmationScreen/
+    diBootstrap.ts     ← ONE file for the whole module (not per-screen)
+```
+
+In single mode, the module folder contains exactly one screen and one of each layer file.
+
+### Input
+
+All inputs are collected via the **Mandatory User Interview (PHASE -1)** below.
+Do NOT proceed to PHASE 0 until all 5 questions have been answered and confirmed.
+
+---
+
+## PHASE -1 — Mandatory User Interview
+
+> **This phase is REQUIRED. Do NOT skip or reorder any question.**
+> Do NOT assume, infer, or hallucinate any answer to any question.
+> If the user's answer is incomplete, ambiguous, or missing required fields — ask a targeted follow-up before moving on.
+> All 5 questions MUST be answered before proceeding to PHASE 0.
+> Proceed ONLY after you have explicit answers (or an explicit WARN-acknowledged skip) for every question.
+
+---
+
+### QUESTION 1 — Generation Mode & Design Source
+
+Ask the user:
+
+> "Are you generating a **single screen** or a **module** (multiple screens that belong to the same feature)?
+>
+> - **Single screen** — one screen, one API endpoint
+> - **Module** — multiple screens under one feature folder (e.g. FD Booking: Details screen + Payment screen + Confirmation screen)
+>
+> Please also tell me the name(s):"
+
+---
+
+#### If mode = single:
+
+Ask:
+> "What is the PascalCase name for the new screen? (e.g. `TransactionHistory`, `FundDetail`, `UserProfile`)
+>
+> Also provide the design source:
+>  - **Spec MD files** — file path(s) to filled spec Markdown files
+>  - **Existing screen paths** — relative paths to existing screens to use as UI structure reference
+>
+> Provide at least one source."
+
+**Collect:**
+```
+GENERATION_MODE:    single
+SCREEN_NAME:        <PascalCase name>
+DESIGN_SOURCE_TYPE: md-file | screen-path | mixed
+SPEC_MD_FILES:      [path1, path2, ...] or []
+SCREEN_REF_PATHS:   [path1, path2, ...] or []
+```
+
+Behaviour: proceed through Q2–Q5 once (for this single screen), then PHASE 0 → PHASE 1–9.
+
+---
+
+#### If mode = module:
+
+Ask:
+> "What is the PascalCase name of the module? (e.g. `FdBooking`, `Portfolio`, `Onboarding`)
+>
+> How many screens does this module contain? List each screen name (PascalCase) and its design source.
+> For each screen provide:
+>  - Screen name (PascalCase)
+>  - Spec MD file path (optional)
+>  - Existing screen ref path (optional)
+>
+> You must provide at least one source (MD file or screen ref) per screen."
+
+**Collect:**
+```
+GENERATION_MODE: module
+MODULE_NAME:     <PascalCase module name — e.g. FdBooking>
+SCREENS: [
+  {
+    screenName:      <PascalCase>,
+    specMdFiles:     [path, ...] or [],
+    screenRefPaths:  [path, ...] or []
+  },
+  ...
+]
+```
+
+FATAL if `MODULE_NAME` not provided — re-ask.
+FATAL if `SCREENS` list is empty — re-ask.
+FATAL if any screen has neither `specMdFiles` nor `screenRefPaths` — re-ask for that screen.
+
+Behaviour:
+- **MD spec files**: read in PHASE 1 as the primary spec source per screen. The `Screen Name` field inside the MD overrides the interview screen name only if different.
+- **Screen paths**: read in PHASE 0 step 0.L. Mirror component structure, StyleSheet, imports. Do NOT generate new layout — replicate existing pattern.
+- Q2–Q5 are collected **per screen** (see below).
+
+---
+
+> **IMPORTANT for both modes**: Figma URLs are NOT supported. Do not use any Figma MCP tools.
+> If the user provides a Figma URL, ask them to provide an existing screen path or a filled spec MD file instead.
+
+FATAL if no source provided for any screen — re-ask until resolved.
+
+---
+
+> ### Module mode — Q2 through Q5 are collected PER SCREEN
+>
+> When `GENERATION_MODE = module`, after Q1 you MUST loop through each screen in
+> `SCREENS[]` and ask Q2–Q5 for that screen before moving to the next.
+>
+> Display a clear heading before each screen's questions:
+> ```
+> ─── Screen N / Total: <ScreenName> ────────────────────────────────
+> ```
+>
+> After collecting Q2–Q5 for ALL screens, proceed to the PHASE -1 Completion Gate.
+> Do NOT skip any screen. Do NOT run PHASE 0 until every screen is fully answered.
+
+---
+
+### QUESTION 2 — User Stories
+
+Ask the user:
+
+> "Please provide the user stories for this feature. You can:
+>  - Paste user story text directly (e.g. 'As a user, I want to see my transactions so that I can track my spending')
+>  - Provide a file path to a user stories Markdown file
+>
+> User stories define WHAT the feature must do from the user's perspective and drive screen logic generation."
+
+**Collect:**
+```
+USER_STORIES_SOURCE: inline | file | none
+USER_STORIES_FILE:   <path or null>
+USER_STORIES_TEXT:   <inline text or null>
+```
+
+Parse into structured entries:
+```
+USER_STORIES: [
+  { id: "US-1", role: "<who>", action: "<wants to>", benefit: "<so that>" },
+  ...
+]
+```
+
+Use user stories to:
+- Drive screen logic completeness check in PHASE 7.3
+- Validate implementation coverage in PHASE 10.6
+
+WARN if not provided — log `WARN: No user stories provided. Screen logic will be derived from the spec MD file and Q5 API mapping only.` and continue.
+
+---
+
+### QUESTION 3 — Test Cases
+
+Ask the user:
+
+> "Please provide the test cases for this feature. You can:
+>  - Paste test case descriptions directly (e.g. 'When user has no transactions, show empty state')
+>  - Provide a file path to a test cases Markdown file
+>  - Provide paths to existing test files (*.test.ts, *.spec.ts)
+>
+> Test cases define expected behaviour and edge cases the implementation must satisfy."
+
+**Collect:**
+```
+TEST_CASES_SOURCE:   inline | file | test-files | none
+TEST_CASES_FILE:     <path or null>
+TEST_CASES_TEXT:     <inline text or null>
+TEST_FILE_PATHS:     [path1, ...] or []
+```
+
+Parse into structured entries:
+```
+TEST_CASES: [
+  { id: "TC-1", given: "...", when: "...", then: "...", type: "happy | edge | error" },
+  ...
+]
+```
+
+Use test cases to:
+- Validate business logic guard clauses in PHASE 3.3
+- Validate screen logic completeness in PHASE 7.3
+- Drive PHASE 10.5 post-completion checks
+
+WARN if not provided — log `WARN: No test cases provided. Post-completion validation will skip TC coverage.` and continue.
+
+---
+
+### QUESTION 4 — Business Logic
+
+Ask the user:
+
+> "Please describe ALL business logic rules for this feature. Include:
+>  - Validation rules (e.g. 'Amount must be greater than 0')
+>  - Domain constraints (e.g. 'Only show active accounts')
+>  - Derived values (e.g. 'Calculate net return as current value minus invested amount')
+>  - Error conditions (e.g. 'If Status is not success, treat the response as an error')
+>  - Any conditional behaviour driven by data values
+>
+> Be as specific and exhaustive as possible. Each rule becomes a guard clause in the use case. Do not leave rules implicit — state them explicitly."
+
+**Collect:**
+```
+BUSINESS_LOGIC_RULES: [
+  "<rule 1>",
+  "<rule 2>",
+  ...
+]
+```
+
+FATAL if not provided AND no spec MD file from Q1 contains a Business Logic section. Re-ask until at least one rule is given.
+
+---
+
+### QUESTION 5 — API Details & Response Mapping
+
+Ask the user:
+
+> "Please provide the complete API details for this feature:
+>
+> **A. API Endpoint**
+>  - URL (e.g. `/api/v1/portfolio/transactions`)
+>  - HTTP Method (GET / POST / PUT / PATCH / DELETE)
+>
+> **B. Request Body**
+>  - Paste the exact JSON request body with field names and example values
+>  - Use the EXACT field names the API expects (including casing — PascalCase, camelCase, snake_case)
+>
+> **C. Response Shape**
+>  - Paste the exact JSON response structure with field names and example values
+>  - Include nested objects and arrays exactly as the API returns them
+>
+> **D. Response-to-UI Mapping**
+>  - For each response field you want displayed, describe WHERE and HOW it appears in the UI
+>  - Format: `ResponseField` → description of UI location and any formatting
+>  - Example: `Data[].FundName` → primary title of each list row
+>  - Example: `Data[].Amount` → below title, formatted as Indian currency (₹)
+>  - Example: `Data[].TransactionID` → unique key only, not displayed
+>
+> **E. Screen Logic**
+>  - Describe what happens on screen mount, user interactions, navigation, and conditional rendering
+>  - Example: 'Fetch data on screen mount'
+>  - Example: 'Support pull-to-refresh'
+>  - Example: 'Navigate to DetailScreen when user taps a row'
+>  - Example: 'Show empty state message when list is empty'
+>  - Example: 'Show loading skeleton while fetching'
+>
+> Provide the actual field names from the API exactly as they appear. Do not rename or guess."
+
+**Collect:**
+```
+API_URL:           <endpoint path>
+HTTP_METHOD:       GET | POST | PUT | PATCH | DELETE
+REQUEST_BODY:      <JSON object — exact API field names>
+RESPONSE_SHAPE:    <JSON object — exact API field names and example values>
+RESPONSE_MAPPINGS: [
+  { responseField: "Data[].FundName",  uiLocation: "primary title of each row",  transform: null },
+  { responseField: "Data[].Amount",    uiLocation: "below title",                transform: "format as Indian currency" },
+  ...
+]
+SCREEN_LOGIC: [
+  "<behavior 1>",
+  "<behavior 2>",
+  ...
+]
+```
+
+FATAL if `API_URL` or `HTTP_METHOD` not provided — re-ask until both are given.
+WARN if `RESPONSE_SHAPE` not provided — generate empty entity and log WARN.
+WARN if `RESPONSE_MAPPINGS` not provided — generate screen without field bindings and log WARN.
+WARN if `SCREEN_LOGIC` not provided — generate screen with fetch-on-mount only and log WARN.
+
+---
+
+### PHASE -1 Completion Gate
+
+Before proceeding to PHASE 0, confirm all items:
+
+**Single mode checklist:**
+```
+[ ] Q1: SCREEN_NAME provided AND at least one design source provided (MD spec file or existing screen path — NO Figma)
+[ ] Q2: User stories collected — or WARN logged if skipped
+[ ] Q3: Test cases collected — or WARN logged if skipped
+[ ] Q4: At least one business logic rule provided
+[ ] Q5: API URL, HTTP method, response shape, and mappings provided
+```
+
+**Module mode checklist (repeat per screen):**
+```
+[ ] Q1: MODULE_NAME provided AND SCREENS[] list has at least one entry, each with a design source
+For each screen in SCREENS[]:
+  [ ] Q2: User stories collected for <ScreenName> — or WARN logged
+  [ ] Q3: Test cases collected for <ScreenName> — or WARN logged
+  [ ] Q4: At least one business logic rule for <ScreenName>
+  [ ] Q5: API URL, HTTP method, response shape, and mappings for <ScreenName>
+```
+
+- If any FATAL condition is unmet: stop and re-ask only that specific question (and screen if module mode).
+- If only WARNs are outstanding: proceed with WARN flags recorded.
+- Do NOT proceed if any question is unanswered without a WARN or FATAL resolution.
+
+**Merge all collected answers into FeatureSpec(s)** used in PHASE 1.2.
+
+- In **single** mode: one `FeatureSpec` is built. Interview answers take precedence over spec MD file values.
+- In **module** mode: one `FeatureSpec` is built **per screen**. Each screen's interview answers take precedence over its spec MD file. The module name is stored as `MODULE_NAME` and is shared across all specs.
+
+`SCREEN_LOGIC` from Q5E is merged into `spec.screenLogic[]` and is the primary source for Phases 5 and 7.3.
+`BUSINESS_LOGIC_RULES` from Q4 is merged into `spec.businessLogic[]` and is the primary source for Phase 3.3.
+
+---
+
+## PHASE 0 — Repository Intelligence
+
+> **Run this phase completely before touching the spec file.**
+> Every path, import, and naming decision in all later phases is derived from
+> the fingerprint built here. If detection of any dimension is uncertain,
+> record it as `[INFERRED]` and log a WARN — never silently guess.
+
+---
+
+### 0.A — Locate App Root
+
+Do NOT assume the source lives in `src/`. Crawl the repository root looking
+for the file that anchors the React Native app entry point.
+
+**Algorithm — run in order, stop at first match:**
+
+```
+1. Find files named: App.tsx, App.ts, App.jsx, App.js, index.tsx, index.ts,
+   index.js (in that priority)
+2. Among matches, pick the one whose directory ALSO contains at least one of:
+     package.json  tsconfig.json  babel.config.js  metro.config.js
+3. The directory of that anchor file is APP_ROOT
+4. Walk up from APP_ROOT to find the nearest package.json whose
+   "dependencies" or "devDependencies" contains "react-native"
+5. The directory of that package.json is REPO_ROOT
+```
+
+Record:
+```
+REPO_ROOT: <absolute path>
+APP_ROOT:  <absolute path>  (may equal REPO_ROOT or be a subfolder like src/, app/, mobile/)
+APP_ROOT_RELATIVE: <path relative to REPO_ROOT>
+```
+
+FATAL if no React Native anchor can be found.
+
+---
+
+### 0.B — Detect Feature Organisation Style
+
+Scan every directory under `APP_ROOT` (max depth: 6 levels). Do not look for
+specific folder names — count and classify what actually exists.
+
+**Classification algorithm:**
+
+```
+FEATURE_FIRST clues:
+  - One directory per product feature at the same level
+  - Each feature directory contains at least two of:
+    screens/, components/, hooks/, services/, store/, state/, api/
+  - Examples found: features/, modules/, pages/, domains/
+
+LAYER_FIRST clues:
+  - Root-level directories named after layers, not features
+  - Look for: screens/, components/, redux/, store/, services/, hooks/
+    existing at the same level under APP_ROOT
+  - Features are identified by file name prefix (e.g., AuthScreen.tsx)
+
+EXPO_ROUTER clues:
+  - Directory named: app/ containing (tabs)/ or route files
+  - File-system based routing patterns: [id].tsx, (auth)/ groups
+
+DOMAIN_DRIVEN clues:
+  - Top-level: domain/, data/, presentation/ at same level
+
+ATOMIC clues:
+  - Top-level: atoms/, molecules/, organisms/ at same level
+
+MONOREPO clues:
+  - packages/ directory with multiple sub-packages each containing package.json
+```
+
+If multiple signals are mixed (common in real projects), record the dominant
+one and all secondary patterns:
+
+```
+FEATURE_STYLE: feature-first          ← dominant
+FEATURE_STYLE_SECONDARY: layer-mixed  ← if some layers leak to root
+FEATURES_ROOT: <path relative to APP_ROOT where feature directories live>
+FEATURE_DIR_SAMPLE: [portfolio, auth, dashboard, ...]  ← 3-5 example names
+```
+
+**Greenfield / fallback detection:**
+
+Run the following decision tree after the normal classification above:
+
+```
+STEP 1 — Check for existing layer-first directories under APP_ROOT:
+  Look for ANY of these directory names at the top level of APP_ROOT:
+    screens/, screen/, views/, pages/
+    store/, redux/, state/
+    services/, api/, network/
+
+  If 2 or more of the above exist:
+    → LAYER_FIRST_EXISTING: true
+    → FEATURE_STYLE: layer-first  (override any earlier classification)
+    → GREENFIELD: false
+    Record the actual folder names found:
+      LAYER_FIRST_SCREENS_DIR:  <actual name, e.g. screens/>
+      LAYER_FIRST_SERVICES_DIR: <actual name, e.g. services/>
+      LAYER_FIRST_STATE_DIR:    <actual name, e.g. store/>
+      LAYER_FIRST_STATE_SLICES_DIR: <actual subfolder for slices, e.g. store/slices/ or store/>
+    Log: INFO: Layer-first project structure detected. Files will be placed in existing layer directories.
+
+STEP 2 — If LAYER_FIRST_EXISTING is false AND FEATURE_DIR_SAMPLE is empty:
+    → GREENFIELD: true
+    → FEATURE_STYLE: feature-first
+    → FEATURES_ROOT: features/
+    → FEATURE_DIR_SAMPLE: []
+    Log: INFO: No existing feature structure detected. Falling back to canonical clean-architecture default.
+
+STEP 3 — Otherwise:
+    → GREENFIELD: false
+    → Use FEATURE_STYLE and FEATURES_ROOT as classified above.
+```
+
+In LAYER_FIRST_EXISTING mode:
+- Phase 0.C layer scanning is adapted — scan the detected layer directories, NOT feature sub-folders.
+- Phase 0.K.1 applies the LAYER_FIRST default map.
+- `FEATURES_ROOT` is set to `null` — there is no single features root.
+
+In GREENFIELD mode:
+- Phase 0.C layer scanning is skipped entirely.
+- Phase 0.K.1 applies the FEATURE_FIRST default map.
+- Log: `INFO: No existing feature structure detected. Falling back to canonical default layer map.`
+
+---
+
+### 0.C — Infer Architectural Layers Per Feature
+
+Scan **ALL** detected feature directories, not just one. Walk each and map its
+layer structure. When the same layer uses different folder names across features
+(e.g., `domain/models` vs `domain/entities`), record all variants and emit a WARN.
+
+Also detect the DI wiring pattern used by each feature.
+
+**Layer inference algorithm (run for every feature directory):**
+
+```
+For each subfolder in a feature directory:
+  - Contains interfaces/types only → DOMAIN or TYPES layer
+  - Contains *Repository* files → REPOSITORY layer (domain or data)
+  - Contains *UseCase* or *Service* files → USE_CASE layer
+  - Contains *Slice* or *Store* or *Reducer* → STATE layer
+  - Contains *DataSource* or *Api* or *Remote* → DATA_SOURCE layer
+  - Contains *Screen* or *Page* or *View* → PRESENTATION layer
+  - Contains *Mapper* or *Transformer* → MAPPER layer
+  - Contains *.mock.json* or mock files → MOCK layer
+  - Contains *Selector* or *Query* → SELECTOR layer
+  - Named 'di/' and contains *container* or *bootstrap* → DI layer
+```
+
+**DI pattern detection (run per feature):**
+
+```
+Look for a file at feature root named diBootstrap.ts or diBootstrap.js:
+  → DI_STYLE: per-feature-bootstrap
+    Record: bootstrapFile = "diBootstrap.ts"
+    Note: exports named singleton instances consumed via ThunkExtra or direct import
+
+Look for a directory named di/ whose files contain class.*Container or getInstance(:
+  → DI_STYLE: per-feature-container
+    Record: containerFile  = "di/container.ts" (or actual path)
+    Record: containerClass = detected class name (e.g. "ReportsContainer")
+
+Look for a top-level shared DI / IoC file outside all feature directories:
+  → DI_STYLE: global
+
+If none found:
+  → DI_STYLE: none
+```
+
+If features use different DI styles, record all. When generating, use the style
+of the existing feature most similar to the new one.
+
+Record actual folder names, not assumed names. When names differ across features,
+record the dominant value AND all alternatives:
+
+```
+LAYER_MAP: {
+  domain:       "domain"
+  domainModels: "domain/models"   (variants: ["domain/models","domain/entities"])
+  domainRepo:   "domain/repositories"
+  useCases:     "domain/useCases" (variants: ["domain/usecases","domain/useCases"])
+  data:         "data"
+  dataSource:   "data/datasources" (variants: ["data/datasources","data/api"])
+  repoImpl:     "data/repositories" (variants: ["data/repositories","data/repositoryImpl"])
+  dtos:         "data/dtos"        (or null when absent in all features)
+  mappers:      "data/mappers"
+  mocks:        "data/datasources/__mocks__" (or nearest mock folder)
+  state:        "state"            (or null when absent — e.g. Context-API features)
+  stateStore:   "state/store"      (or null)
+  selectors:    "state/selectors"  (or null)
+  presentation: "presentation"
+  screens:      "presentation/screens"
+  di:           "di"               (or null — only present for per-feature-container style)
+}
+```
+
+If a layer is absent in ALL scanned features, mark it `null` and skip generation.
+
+**Selecting the representative layer map for generation:**
+
+```
+When LAYER_MAP has variants:
+  1. If the new feature name or spec hints at resemblance to an existing feature, use
+     that feature's exact layer paths.
+  2. Otherwise, use the layer paths from the most complete feature (most non-null layers).
+  3. Log a WARN for every layer where a variant was not chosen.
+```
+
+**Greenfield / Layer-first override:**
+
+If `GREENFIELD = true`:
+- Skip all layer scanning above.
+- Set every LAYER_MAP field to `[DEFAULT]` placeholder.
+- Phase 0.K.1-A will replace them with the canonical feature-first defaults.
+- Do NOT emit WARNs for missing layers.
+
+If `LAYER_FIRST_EXISTING = true`:
+- Skip feature-directory layer scanning above (there are no feature sub-folders to scan).
+- Instead, read 2–3 existing files from each detected layer directory
+  (`LAYER_FIRST_SCREENS_DIR`, `LAYER_FIRST_SERVICES_DIR`, `LAYER_FIRST_STATE_DIR`) to
+  detect naming conventions (file name style, export style, import paths).
+- Set LAYER_MAP fields using the detected actual folder names.
+- Phase 0.K.1-B will fill any remaining `[DEFAULT]` placeholders.
+- Do NOT emit WARNs for absent domain/repository/useCase layers — they are intentionally absent.
+
+**Depth calculation:** Count directory segments from `APP_ROOT` to the deepest
+layer folder. This determines the import prefix needed to reach shared
+utilities.
+
+```
+Example:
+  APP_ROOT = src/
+  datasource file = src/features/portfolio/data/datasources/File.ts
+  Depth from APP_ROOT = 4  (features → portfolio → data → datasources)
+  Import prefix to APP_ROOT = ../../../../
+
+Record:
+  MAX_LAYER_DEPTH: 4
+  IMPORT_PREFIX_TO_APP_ROOT: ../../../../
+```
+
+---
+
+### 0.D — Locate Shared / Common Utilities
+
+Do NOT assume a `shared/` folder. Scan for directories used by multiple
+features as imports.
+
+**Algorithm:**
+
+```
+1. Pick 3-5 feature files from Step 0.C
+2. Read their import statements
+3. Identify import paths that:
+   - Appear in more than one feature
+   - Are NOT from node_modules
+   - Point to a common ancestor directory
+4. That common ancestor directory is SHARED_ROOT
+5. Record the actual folder name (shared, common, core, utils, lib, etc.)
+```
+
+Record:
+```
+SHARED_ROOT:          <path relative to APP_ROOT>   e.g. shared/, common/, core/
+SHARED_ROOT_ALIAS:    <alias if used>               e.g. @shared, @/shared, ~/shared, or null
+SHARED_API_DIR:       <subfolder under SHARED_ROOT containing API client>
+SHARED_TYPES_DIR:     <subfolder under SHARED_ROOT containing shared types>
+SHARED_STORE_DIR:     <subfolder under SHARED_ROOT containing store config>
+```
+
+For each layer file generated later, compute:
+```
+IMPORT_PREFIX_TO_SHARED = repeat("../", depth_of_file_from_APP_ROOT) + SHARED_ROOT
+```
+
+If `SHARED_ROOT_ALIAS` is non-null, use the alias directly instead of relative
+path (see 0.G for alias detection).
+
+---
+
+### 0.E — API Layer Discovery
+
+Do NOT look in a specific folder. Search the entire repository.
+
+**Search for API client instantiation patterns:**
+
+```
+Pattern A — Axios:
+  Search: axios.create(
+  Files found → AXIOS_CLIENT_FILES
+
+Pattern B — Fetch wrapper:
+  Search: fetch(  OR  window.fetch(
+  Combined with response.json() → FETCH_WRAPPER_FILES
+
+Pattern C — RTK Query:
+  Search: createApi(
+  Files found → RTK_QUERY_FILES
+
+Pattern D — React Query / TanStack Query:
+  Search: useQuery(  OR  useMutation(  OR  QueryClient
+  Files found → REACT_QUERY_FILES
+
+Pattern E — Apollo / GraphQL:
+  Search: ApolloClient  OR  gql`  OR  useQuery from @apollo
+  Files found → APOLLO_FILES
+
+Pattern F — Other (ky, superagent, got):
+  Search: import ky  OR  require('ky')  etc.
+```
+
+For the detected API library:
+- Record the exact file path(s) of the shared client instance
+- Read those files and extract: base URL, headers, interceptors, retry logic,
+  token injection pattern
+- Record the exact import statement used by existing feature files to reach the
+  client
+
+**Envelope / Request Shape Detection:**
+
+Read 3-5 existing API call sites. Examine the request body structure passed to
+the client:
+
+```
+If body is wrapped: { mb: { operationId, rq: { reqdata: {} } } }
+  → ENVELOPE_STYLE: mb-operationId
+  → ENVELOPE_BUILDER: detect if a buildEnvelope() helper exists or is inlined
+
+If body is plain: { key: value, key2: value2 }
+  → ENVELOPE_STYLE: none
+
+If body follows another wrapper pattern → record exact shape
+```
+
+**Return type pattern detection:**
+
+Read 3–5 existing repository interface files. Examine the return types of their methods:
+
+```
+If return types are Promise<{ ok: boolean; data?: T; error?: string }>
+  → RETURN_TYPE_STYLE: result-wrapper
+    Record: RESULT_TYPE_IMPORT = <exact import string for the Result type>
+
+If return types are Promise<CustomNamedType> where CustomNamedType is defined in the
+same feature's domain layer (e.g. Promise<PortfolioSummaryResult>):
+  → RETURN_TYPE_STYLE: custom-type
+    Record: no shared Result import needed
+
+If return types are direct: Promise<T[]> or Promise<T> with no wrapper:
+  → RETURN_TYPE_STYLE: direct-promise
+    Record: no wrapper — throws on error instead of returning { ok: false }
+```
+
+This field controls how Phase 3.2, 4.7, and 5.1 generate the repository interface,
+implementation, and thunk error handling respectively.
+
+**Mock / Stub Detection:**
+
+```
+Search for: mockEnabled  OR  globalMockEnabled  OR  mock.config  OR  msw  OR  nock
+If found → record file path, exact shape, evaluation order
+```
+
+Record:
+```
+API_LIB:              axios | fetch | rtk-query | react-query | apollo | other
+API_CLIENT_FILE:      <exact path to shared client file>
+API_CLIENT_IMPORT:    <exact import string used by feature files>
+ENVELOPE_STYLE:       mb-operationId | mb-operationid-lowercase | none | <other>
+ENVELOPE_BUILDER:     <function name and file, or "inline">
+MOCK_SYSTEM:          mockConfig | msw | none
+MOCK_CONFIG_FILE:     <path or null>
+MOCK_GLOBAL_FLAG:     globalMockEnabled | <other field name> | null
+MOCK_DELAY_FIELD:     simulatedDelayMs | <other field name> | null
+MOCK_JSON_FOLDER:     <path pattern for mock JSON files, relative to datasource>
+RETURN_TYPE_STYLE:    result-wrapper | custom-type | direct-promise
+RESULT_TYPE_IMPORT:   <exact import string for Result type, or null>
+```
+
+---
+
+### 0.F — State Management Discovery
+
+Search the entire repository (not just specific folders).
+
+**Search for state library signatures:**
+
+```
+createSlice(          → redux-toolkit
+createAsyncThunk(     → redux-toolkit
+configureStore(       → redux-toolkit (store config)
+createReducer(        → redux-toolkit or plain redux
+create(               → zustand (if imported from 'zustand')
+makeAutoObservable(   → mobx
+observable(           → mobx
+useReducer(           → context-api (if paired with createContext)
+createContext(        → context-api
+QueryClient           → react-query / tanstack-query
+```
+
+Record all matches. If multiple libraries exist, note which features use which.
+For the dominant library, detect the injection/sharing pattern:
+
+**For Redux Toolkit — detect thunk injection style:**
+
+```
+Search async thunks for:
+  Pattern A (ThunkExtra): async (params, { extra, rejectWithValue }) => {
+    const { someUseCase } = extra as { ... }
+    → THUNK_PATTERN: thunk-extra
+
+  Pattern B (Direct import): import { someUseCase } from '...'
+    async (params, { rejectWithValue }) => {
+    → THUNK_PATTERN: direct-import
+
+  Pattern C (RTK Query): endpoints builder pattern
+    → THUNK_PATTERN: rtk-query
+```
+
+**For Redux — locate the store configuration:**
+
+```
+Search for configureStore( call
+Read that file to find:
+  - middleware / extra argument → confirm ThunkExtra injection
+  - reducer map keys → these become slice name constraints
+  - The RootState type definition file / export
+```
+
+Record:
+```
+STATE_LIB:            redux-toolkit | zustand | mobx | context-api | react-query | other
+THUNK_PATTERN:        thunk-extra | direct-import | rtk-query | n/a
+STORE_CONFIG_FILE:    <path to configureStore call>
+ROOT_STATE_TYPE_FILE: <path where RootState is exported>
+ROOT_STATE_IMPORT:    <exact import string to reach RootState from a selector file>
+SLICE_NAME_STYLE:     camelCase | kebab-case  (from existing slice name strings)
+REDUCER_MAP_KEYS:     [portfolio, auth, ...]  (existing keys in combineReducers/configureStore)
+```
+
+---
+
+### 0.G — Import Alias Detection
+
+Import aliases are critical — generated code MUST use the same alias style,
+otherwise it will fail to compile.
+
+**Search in order:**
+
+```
+1. tsconfig.json or tsconfig.base.json → paths: { "@/*": ["./src/*"], ... }
+2. babel.config.js or babel.config.ts → module-resolver plugin aliases
+3. metro.config.js → resolver.extraNodeModules or resolver.alias
+4. package.json → imports field (Node.js subpath imports)
+5. jsconfig.json → paths
+```
+
+For each alias found, record:
+```
+ALIAS_MAP: {
+  "@":        "src/",
+  "@shared":  "src/shared/",
+  "~":        "./",
+  "@app":     "app/",
+  ...
+}
+```
+
+Then, for each shared import generated later: prefer the longest matching alias
+over a relative path. If no alias matches, use the computed relative path from
+Step 0.D.
+
+Record:
+```
+ALIASES_DETECTED: true | false
+ALIAS_MAP: { ... } or {}
+PREFER_ALIASES: true | false  (true if existing feature files use aliases)
+```
+
+---
+
+### 0.H — Navigation Discovery
+
+```
+Search for:
+  @react-navigation/native         → REACT_NAVIGATION, detect version from package.json
+  expo-router                      → EXPO_ROUTER
+  react-native-navigation (wix)    → WIX_NAVIGATION
+  react-native-screens             → (supporting library, not primary)
+
+For React Navigation — detect version:
+  package.json "@react-navigation/native": "^6.x" → v6
+  package.json "@react-navigation/native": "^5.x" → v5
+  package.json "@react-navigation/native": "^7.x" → v7
+
+For React Navigation — detect stack type used:
+  Search: createNativeStackNavigator OR createStackNavigator OR createBottomTabNavigator
+  Read 1-2 screen registration files to see how screens are added
+
+For Expo Router — detect routing pattern:
+  Read app/ directory structure to understand route groups
+```
+
+Record:
+```
+NAV_LIB:              react-navigation | expo-router | wix-navigation | none
+NAV_VERSION:          6 | 5 | 7 | n/a
+NAV_STACK_TYPE:       native-stack | stack | bottom-tab | n/a
+NAV_SCREEN_FILE:      <path to main navigator file where screens are registered>
+NAV_PARAMS_PATTERN:   <how params are typed — RootStackParamList, RouteParams, etc.>
+```
+
+---
+
+### 0.I — Type System & Code Quality Discovery
+
+```
+Read tsconfig.json:
+  compilerOptions.strict → TS_STRICT: true | false
+  compilerOptions.noImplicitAny → NO_IMPLICIT_ANY: true | false
+  compilerOptions.strictNullChecks → STRICT_NULL_CHECKS: true | false
+
+Read .eslintrc.* or eslint.config.*:
+  Record any rules that affect generated code:
+  - no-explicit-any
+  - @typescript-eslint/explicit-function-return-type
+  - import/order
+
+Read .prettierrc or prettier.config.*:
+  Record: singleQuote, tabWidth, trailingComma, semi
+
+Read package.json scripts:
+  Detect test runner: jest | vitest | mocha
+  Detect test pattern: *.test.ts | *.spec.ts | __tests__/*.ts
+```
+
+Record:
+```
+TS_STRICT:            true | false
+NO_IMPLICIT_ANY:      true | false
+STRICT_NULL_CHECKS:   true | false
+EXPLICIT_RETURN_TYPE: true | false  (requires function return types)
+QUOTE_STYLE:          single | double
+TRAILING_COMMA:       es5 | all | none
+SEMI:                 true | false
+TAB_WIDTH:            2 | 4
+TEST_RUNNER:          jest | vitest | none
+TEST_FILE_PATTERN:    *.test.ts | *.spec.ts | __tests__/
+```
+
+---
+
+### 0.J — Naming Convention Discovery
+
+Detect naming conventions from existing files — never assume.
+
+```
+Read file names in FEATURES_ROOT:
+  All lowercase + hyphens: portfolioSlice.ts, portfolio-slice.ts
+  → FILE_NAME_STYLE: camelCase | kebab-case | PascalCase
+
+Read class names in datasource files:
+  class PortfolioApiDataSource → CLASS_STYLE: PascalCase
+
+Read interface/type names:
+  interface IPortfolioRepository → INTERFACE_PREFIX: I
+  interface PortfolioRepository  → INTERFACE_PREFIX: none
+
+Read existing operationId strings in envelope calls:
+  'GetPortfolioSummary' → OPERATION_ID_STYLE: PascalCase with Get prefix
+  'portfolio/fetchSummary' → OPERATION_ID_STYLE: path-style
+
+Read mock JSON file names:
+  portfolioSummary.mock.json → MOCK_JSON_STYLE: camelCase.mock.json
+  portfolio_summary_mock.json → MOCK_JSON_STYLE: snake_case_mock.json
+
+Read feature folder names:
+  portfolio/, transactionHistory/ → FEATURE_FOLDER_STYLE: camelCase
+  transaction-history/            → FEATURE_FOLDER_STYLE: kebab-case
+```
+
+Record:
+```
+FILE_NAME_STYLE:      camelCase | kebab-case | PascalCase
+CLASS_STYLE:          PascalCase
+INTERFACE_PREFIX:     I | none
+OPERATION_ID_STYLE:   PascalCase-Get | path-style | camelCase
+MOCK_JSON_STYLE:      <detected pattern>
+FEATURE_FOLDER_STYLE: camelCase | kebab-case
+```
+
+---
+
+### 0.K — Build the Architecture Fingerprint
+
+Consolidate all Phase 0 findings into a single, structured fingerprint. This
+fingerprint is the **only** source of truth for all file paths, import strings,
+naming, and patterns used in Phases 1–7.
+
+```json
+{
+  "repoRoot": "<absolute path>",
+  "appRoot": "<absolute path>",
+  "appRootRelative": "src/",
+
+  "featureStyle": "feature-first | layer-first | expo-router | domain-driven | atomic",
+  "featuresRoot": "<path relative to appRoot where features live>",
+  "featureDirSample": ["portfolio", "auth", "dashboard"],
+
+  "layerMap": {
+    "domain":       "<actual folder name or null>",
+    "domainModels": "<actual path segment or null>",
+    "domainRepo":   "<actual path segment or null>",
+    "useCases":     "<actual path segment or null>",
+    "data":         "<actual folder name or null>",
+    "dataSource":   "<actual path segment or null>",
+    "dtos":         "<actual path segment or null>",
+    "mappers":      "<actual path segment or null>",
+    "mocks":        "<actual path segment or null>",
+    "state":        "<actual folder name or null>",
+    "stateStore":   "<actual path segment or null>",
+    "selectors":    "<actual path segment or null>",
+    "presentation": "<actual folder name or null>",
+    "screens":      "<actual path segment or null>"
+  },
+
+  "maxLayerDepth": 4,
+  "importPrefixToAppRoot": "../../../../",
+
+  "sharedRoot": "<path relative to appRoot>",
+  "sharedRootAlias": "@shared | null",
+  "sharedApiDir": "<path relative to appRoot>",
+  "sharedTypesDir": "<path relative to appRoot>",
+  "sharedStoreDir": "<path relative to appRoot>",
+
+  "aliasesDetected": true,
+  "aliasMap": { "@": "src/", "@shared": "src/shared/" },
+  "preferAliases": true,
+
+  "apiLib": "axios | fetch | rtk-query | react-query | apollo | other",
+  "apiClientFile": "<absolute path>",
+  "apiClientImport": "<exact import string>",
+  "envelopeStyle": "mb-operationId | none | <other>",
+  "envelopeBuilder": "<function name> | inline | null",
+  "mockSystem": "mockConfig | msw | none",
+  "mockConfigFile": "<path or null>",
+  "mockGlobalFlag": "globalMockEnabled | <other> | null",
+  "mockDelayField": "simulatedDelayMs | <other> | null",
+  "mockJsonFolder": "<path pattern relative to datasource file>",
+
+  "stateLib": "redux-toolkit | zustand | mobx | context-api | react-query | other",
+  "thunkPattern": "thunk-extra | direct-import | rtk-query | n/a",
+  "storeConfigFile": "<path>",
+  "rootStateTypeFile": "<path>",
+  "rootStateImport": "<exact import string>",
+  "sliceNameStyle": "camelCase | kebab-case",
+  "reducerMapKeys": ["portfolio", "auth"],
+  "reducerKey": "<sliceName — single mode only; null in module mode (each screen derives its own reducerKey in Phase 1.4)>",
+
+  "navLib": "react-navigation | expo-router | wix-navigation | none",
+  "navVersion": "6 | 5 | 7 | n/a",
+  "navStackType": "native-stack | stack | bottom-tab | n/a",
+  "navScreenFile": "<path>",
+  "navParamsPattern": "<RootStackParamList type name>",
+
+  "tsStrict": true,
+  "noImplicitAny": true,
+  "explicitReturnType": false,
+  "quoteStyle": "single",
+  "trailingComma": "es5",
+  "semi": true,
+  "tabWidth": 2,
+  "testRunner": "jest | vitest | none",
+  "testFilePattern": "*.test.ts",
+
+  "fileNameStyle": "camelCase | kebab-case | PascalCase",
+  "classStyle": "PascalCase",
+  "interfacePrefix": "I | none",
+  "operationIdStyle": "PascalCase-Get | path-style | camelCase",
+  "mockJsonStyle": "<pattern>",
+  "featureFolderStyle": "camelCase | kebab-case",
+
+  "diStyle": "per-feature-bootstrap | per-feature-container | global | none",
+  "diBootstrapFile": "<path relative to feature root, or null>",
+  "diContainerFile": "<path relative to feature root, or null>",
+  "diContainerClass": "<class name, or null>",
+
+  "returnTypeStyle": "result-wrapper | custom-type | direct-promise",
+  "resultTypeImport": "<exact import string for Result type, or null>",
+  "repoReturnWrapper": "<custom type name if returnTypeStyle=custom-type, or null>",
+
+  "layerMapVariants": {
+    "domainModels": ["domain/models"],
+    "dataSource":   ["data/datasources"],
+    "repoImpl":     ["data/repositories"]
+  },
+
+  "screenRefPatterns": [
+    {
+      "file": "<relative path>",
+      "scrollContainer": "FlatList | ScrollView",
+      "styleNames": ["container", "header", "listItem"],
+      "sharedComponents": ["AppHeader", "PrimaryButton"],
+      "navHook": "useNavigation | useRouter | none",
+      "stateHooks": ["useSelector", "useDispatch"],
+      "earlyReturnOrder": ["isLoading", "isAuthError", "error"],
+      "listItemLayout": "<brief description>"
+    }
+  ]
+}
+```
+
+Print the complete fingerprint before proceeding. If any field is `[INFERRED]`,
+it must be visually flagged. Do not proceed to Phase 1 if more than 3
+FATAL-tier fields are unresolved.
+
+---
+
+### 0.K.1 — Default Fingerprint (No Existing Structure)
+
+Apply this section when `GREENFIELD = true` OR `LAYER_FIRST_EXISTING = true`.
+Choose the appropriate sub-section based on the flag.
+
+---
+
+#### A — Feature-First Default (`GREENFIELD = true`)
+
+No project structure exists at all. Generate a canonical clean-architecture
+feature-first layout under a `features/` root.
+
+```json
+{
+  "featuresRoot": "features",
+  "featureFolderStyle": "camelCase",
+  "fileNameStyle": "camelCase",
+  "featureStyle": "feature-first",
+
+  "layerMap": {
+    "domain":       "domain",
+    "domainModels": "domain/models",
+    "domainRepo":   "domain/repositories",
+    "useCases":     "domain/useCases",
+    "data":         "data",
+    "dataSource":   "data/datasources",
+    "dtos":         "data/dtos",
+    "mappers":      "data/mappers",
+    "mocks":        "data/datasources",
+    "repoImpl":     "data/repositories",
+    "state":        "state",
+    "stateStore":   "state/store",
+    "selectors":    "state/selectors",
+    "presentation": "presentation",
+    "screens":      "presentation/screens",
+    "di":           null
+  },
+
+  "diStyle":         "per-feature-bootstrap",
+  "diBootstrapFile": "diBootstrap.ts",
+  "stateLib":        "redux-toolkit",
+  "thunkPattern":    "thunk-extra",
+  "returnTypeStyle": "result-wrapper",
+  "resultTypeImport": null,
+  "sliceNameStyle":  "camelCase",
+  "navLib":          "react-navigation",
+  "navVersion":      "6",
+  "navStackType":    "native-stack",
+  "apiLib":          "axios",
+  "envelopeStyle":   "none",
+  "mockSystem":      "none",
+  "mockGlobalFlag":  null,
+  "mockDelayField":  null,
+  "mockJsonFolder":  "data/datasources",
+  "tsStrict":           true,
+  "noImplicitAny":      true,
+  "explicitReturnType": false,
+  "quoteStyle":         "single",
+  "trailingComma":      "es5",
+  "semi":               true,
+  "tabWidth":           2,
+  "interfacePrefix":    "none",
+  "classStyle":         "PascalCase",
+  "operationIdStyle":   "camelCase",
+  "mockJsonStyle":      "camelCase.mock.json",
+  "aliasesDetected":    false,
+  "aliasMap":           {},
+  "preferAliases":      false
+}
+```
+
+Folder layout produced (example — `fdBooking` module):
+```
+features/
+  fdBooking/
+    domain/
+      models/           ← entity interfaces
+      repositories/     ← repository interfaces
+      useCases/         ← use cases
+    data/
+      dtos/             ← DTOs
+      mappers/          ← mappers
+      datasources/      ← datasources, endpoints, mock JSON
+      repositories/     ← repository implementations
+    state/
+      store/            ← Redux slices
+      selectors/        ← selectors
+    presentation/
+      screens/          ← screen components
+    diBootstrap.ts      ← DI bootstrap (one per module)
+```
+
+Log: `INFO: Greenfield defaults applied. Generated structure will follow canonical clean-architecture layout.`
+
+---
+
+#### B — Layer-First Default (`LAYER_FIRST_EXISTING = true`)
+
+The project already has flat layer directories (e.g. `screens/`, `store/`, `services/`).
+No feature-scoped sub-folders exist. Place every generated file inside the existing
+layer directories, grouped only by a per-screen sub-folder under `screens/`.
+
+All paths below are relative to `APP_ROOT`. Substitute the ACTUAL folder names
+detected in Phase 0.B (e.g. if services is named `api/`, use `api/` not `services/`).
+
+```json
+{
+  "featuresRoot":      null,
+  "featureFolderStyle": "PascalCase",
+  "fileNameStyle":      "PascalCase",
+  "featureStyle":       "layer-first",
+
+  "layerMap": {
+    "domain":       null,
+    "domainModels": null,
+    "domainRepo":   null,
+    "useCases":     null,
+    "data":         null,
+    "dataSource":   "<LAYER_FIRST_SERVICES_DIR>",
+    "dtos":         null,
+    "mappers":      null,
+    "mocks":        null,
+    "repoImpl":     null,
+    "state":        "<LAYER_FIRST_STATE_DIR>",
+    "stateStore":   "<LAYER_FIRST_STATE_SLICES_DIR>",
+    "selectors":    null,
+    "presentation": "<LAYER_FIRST_SCREENS_DIR>",
+    "screens":      "<LAYER_FIRST_SCREENS_DIR>",
+    "di":           null
+  },
+
+  "diStyle":         "none",
+  "diBootstrapFile": null,
+  "stateLib":        "redux-toolkit",
+  "thunkPattern":    "direct-import",
+  "returnTypeStyle": "direct-promise",
+  "resultTypeImport": null,
+  "sliceNameStyle":  "camelCase",
+  "navLib":          "react-navigation",
+  "navVersion":      "6",
+  "navStackType":    "native-stack",
+  "apiLib":          "axios",
+  "envelopeStyle":   "none",
+  "mockSystem":      "none",
+  "mockGlobalFlag":  null,
+  "mockDelayField":  null,
+  "mockJsonFolder":  null,
+  "tsStrict":           true,
+  "noImplicitAny":      true,
+  "explicitReturnType": false,
+  "quoteStyle":         "single",
+  "trailingComma":      "es5",
+  "semi":               true,
+  "tabWidth":           2,
+  "interfacePrefix":    "none",
+  "classStyle":         "PascalCase",
+  "operationIdStyle":   "camelCase",
+  "mockJsonStyle":      null,
+  "aliasesDetected":    false,
+  "aliasMap":           {},
+  "preferAliases":      false
+}
+```
+
+**Layer-first generation rules** (override Phases 3–7 defaults):
+
+```
+Phase 3 (Domain layer) — SKIP entirely. domain*, useCases* paths are null.
+  Do NOT generate entity interfaces, repository interfaces, or use cases.
+
+Phase 4 (Data layer) — Generate ONLY the service file:
+  File: <LAYER_FIRST_SERVICES_DIR>/<featureName>Service.ts
+    (e.g. services/fdBookingService.ts)
+  Pattern: plain async functions exported directly (no class wrapper).
+  Imports the shared API client (detected in Phase 0.E) directly.
+  One exported function per API endpoint in the spec.
+  Response types exported as named TypeScript interfaces in the same file.
+  Skip: DTOs, mappers, mock JSON, endpoint constants, repoImpl.
+
+Phase 5 (State layer) — Generate ONLY the slice file:
+  File: <LAYER_FIRST_STATE_SLICES_DIR>/<featureSliceName>Slice.ts
+    (e.g. store/slices/fdBookingSlice.ts)
+  Thunk pattern: direct-import — import service functions at the top of the
+    slice file, call them directly inside createAsyncThunk (no ThunkExtra).
+  Return type: direct-promise — service throws on error; thunk wraps with
+    rejectWithValue.
+  One slice per module (not per screen). Name: <featureName>Slice.
+  Skip: selectors file (select via useSelector inline in screen).
+
+Phase 6 (DI Bootstrap) — SKIP entirely. diStyle is none.
+
+Phase 7 (Presentation) — Generate screen folder inside existing screens dir:
+  Folder: <LAYER_FIRST_SCREENS_DIR>/<ScreenName>/
+  Files:
+    <ScreenName>.tsx         ← main screen component
+    <ScreenName>Style.ts     ← StyleSheet (if reference screen has a style file)
+    <ScreenName>Tokens.ts    ← design tokens (only if reference screen has one)
+  Import slice from: <relative path to LAYER_FIRST_STATE_SLICES_DIR>/<featureSliceName>Slice
+  Import service types from: <relative path to LAYER_FIRST_SERVICES_DIR>/<featureName>Service
+```
+
+Folder layout produced (example — new `TransactionHistory` screen in this project):
+```
+src/
+  screens/
+    TransactionHistory/
+      TransactionHistory.tsx        ← screen component
+      TransactionHistoryStyle.ts    ← StyleSheet
+  store/
+    slices/
+      transactionHistorySlice.ts    ← Redux slice + thunk
+  services/
+    transactionHistoryService.ts    ← API functions + response types
+```
+
+Log: `INFO: Layer-first project structure detected. Files placed in existing layer directories.`
+
+---
+
+### 0.L — Read Screen Reference Files
+
+*Run this step only if `SCREEN_REF_PATHS` from PHASE -1 Q1 is non-empty.*
+
+For each path in `SCREEN_REF_PATHS`:
+
+1. Read the file
+2. Extract and record:
+   - **Component structure**: function signature, props interface shape, return type
+   - **StyleSheet shape**: names and categories of styles defined (e.g. `container`, `header`, `listItem`)
+   - **Imports used**: which RN components, shared components, hooks, and utilities are imported
+   - **FlatList vs ScrollView**: which scroll container is used; `keyExtractor` pattern
+   - **Navigation pattern**: which hook is imported, how `navigation.navigate()` is called
+   - **State hooks used**: `useSelector`, `useState`, `useMemo`, `useCallback`, `useEffect` patterns
+   - **Conditional renders**: early return pattern for loading, error, auth error
+   - **List item JSX structure**: how each row is laid out (columns, rows, nested Views)
+
+Record as:
+```
+SCREEN_REF_PATTERNS: [
+  {
+    file: "<path>",
+    scrollContainer: "FlatList | ScrollView",
+    styleNames: ["container", "header", ...],
+    sharedComponents: ["AppHeader", "PrimaryButton", ...],
+    navHook: "useNavigation | useRouter | none",
+    stateHooks: ["useSelector", "useDispatch", ...],
+    earlyReturnOrder: ["isLoading", "isAuthError", "error"],
+    listItemLayout: "<brief description>"
+  },
+  ...
+]
+```
+
+Add `screenRefPatterns` to the fingerprint:
+```json
+"screenRefPatterns": [{ "file": "...", "scrollContainer": "...", ... }]
+```
+
+**Use in PHASE 7**: When `screenRefPatterns` is non-empty, the generated screen component MUST:
+- Use the same scroll container type (`FlatList` vs `ScrollView`)
+- Mirror the same early-return order (loading → authError → error)
+- Import and use the same shared components found in the reference screen
+- Apply the same StyleSheet naming conventions
+- Use the same navigation hook and call pattern
+
+If multiple reference screens conflict on any dimension, use the pattern from the first screen and log a WARN.
+
+---
+
+## PHASE 1 — Parse Input Spec Files
+
+### 1.1 — Locate Spec Files
+
+Accept spec files as: file paths, dropped files, or inline Markdown.
+
+**In module mode**: parse one spec file per screen in `SCREENS[]`. The result
+is a list of `FeatureSpec` objects (one per screen). All later phases loop over
+this list.
+
+### 1.2 — Extract Spec Fields
+
+```typescript
+interface FeatureSpec {
+  screenName: string;          // e.g. "TransactionHistory"
+  featureFolderName: string;   // TOP-LEVEL folder: derived from MODULE_NAME (module) or screenName (single)
+  moduleName: string | null;   // MODULE_NAME if mode=module; null if mode=single
+  apiUrl: string;
+  httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+  requestBody: Record<string, unknown>;
+  responseShape: Record<string, unknown>;
+  businessLogic: string[];
+  screenLogic: string[];
+  responseMappings: ResponseMapping[];
+}
+
+interface ResponseMapping {
+  responseField: string;   // dot-notation: "data.user.name"
+  uiLocation: string;      // "displayed in the Name label"
+  transform?: string;      // "format as currency", "show as percentage"
+}
+```
+
+**Precedence rule for `screenName`:**
+1. `SCREEN_NAME` (single) or `SCREENS[N].screenName` (module) from PHASE -1 Q1 — highest priority
+2. `## Screen Name` field inside the spec MD file — used only if Q1 name was not given
+3. FATAL if neither source provides a name for any screen
+
+If a spec MD file's `## Screen Name` conflicts with the Q1 name, use Q1 and log a WARN.
+
+**Merge rule:** PHASE -1 answers (Q2–Q5) for the matching screen are merged into its `FeatureSpec`.
+Interview answers take precedence over MD file values for every matching field.
+
+### 1.3 — Validate Spec
+
+Run for each `FeatureSpec` in the list:
+
+FATAL if missing: `screenName`, `apiUrl`, `httpMethod`.
+WARN if missing: `responseShape` (generate empty entity), `requestBody`
+(assume `{}`), `responseMappings`, `businessLogic`, `screenLogic`.
+
+### 1.4 — Derive Names (using fingerprint conventions)
+
+Run for each `FeatureSpec`. All derived names below are **per screen**:
+
+| Derived value | Rule |
+|---|---|
+| `featureFolderName` | **module mode**: apply `fingerprint.featureFolderStyle` to `MODULE_NAME`. **single mode**: apply to `screenName`. This is the TOP-LEVEL feature folder — shared by all screens in a module. |
+| `EntityName` | `screenName + "Item"` if response is array, else `screenName` |
+| `operationId` | Apply `fingerprint.operationIdStyle` to `screenName` |
+| `sliceName` | Apply `fingerprint.sliceNameStyle` to `screenName` |
+| `reducerKey` | Same value as `sliceName`. Used as the key in the store's reducer map and in selectors (`state.<reducerKey>`). Must not collide with existing keys in `fingerprint.reducerMapKeys` — if it does, append `"Feature"` suffix. |
+| `thunkName` | `"fetch" + screenName + "Thunk"` |
+| `useCaseName` | `"Fetch" + screenName + "UseCase"` |
+| `repoInterfaceName` | `fingerprint.interfacePrefix + screenName + "Repository"` |
+| `dataSourceClassName` | `screenName + "ApiDataSource"` |
+| `repoImplClassName` | `screenName + "RepositoryImpl"` |
+| `mockJsonFileName` | Apply `fingerprint.mockJsonStyle` to camelCase of `screenName` |
+| `endpointConstantName` | SCREAMING_SNAKE_CASE of `screenName` |
+| `screenComponentName` | `screenName + "Screen"` |
+
+All file names: apply `fingerprint.fileNameStyle`.
+
+### 1.5 — Shared Entity Deduplication (module mode only)
+
+*Skip this step in single mode.*
+
+After deriving names for all screens:
+
+1. Compare `EntityName` across all screens in the module.
+2. If two or more screens share the same `EntityName` (same response shape for the same entity):
+   - Mark that entity as **shared**: `EntityName.isShared = true`
+   - Its domain model file path moves from the per-screen layer to the module's shared models folder:
+     `FEATURE_DIR/domain/models/shared/<EntityName>.ts`
+   - All screens that reference it import from that shared path instead of their own domain folder.
+   - Generate the shared entity file **once** — do NOT duplicate it.
+3. Log: `SHARED ENTITY: <EntityName> used by [ScreenA, ScreenB] → generated at shared path`
+
+---
+
+## PHASE 2 — Resolve All Output Paths
+
+Before generating any file, compute every output path using only fingerprint
+values. Store as `OutputPaths`.
+
+**In module mode**, `FEATURE_DIR` is the SAME for all screens:
+```
+FEATURE_DIR = fingerprint.featuresRoot + "/" + featureFolderName  (derived from MODULE_NAME)
+```
+
+All screen-specific files go INSIDE `FEATURE_DIR` using per-screen names.
+The DI bootstrap and mockConfig are module-level — one per module, not per screen.
+
+```
+FEATURE_DIR = fingerprint.featuresRoot + "/" + featureFolderName
+
+# Per-screen paths (resolve once per FeatureSpec):
+PerScreenOutputPaths[screenName] = {
+  domainModel:   (isShared)
+                   FEATURE_DIR + "/" + fingerprint.layerMap.domainModels + "/shared/" + EntityName + ".ts"
+                 (not shared)
+                   FEATURE_DIR + "/" + fingerprint.layerMap.domainModels + "/" + EntityName + ".ts"
+  domainRepo:    FEATURE_DIR + "/" + fingerprint.layerMap.domainRepo   + "/" + repoInterfaceName + ".ts"
+  useCase:       FEATURE_DIR + "/" + fingerprint.layerMap.useCases     + "/Fetch" + screenName + "UseCase.ts"
+  dto:           FEATURE_DIR + "/" + fingerprint.layerMap.dtos         + "/" + screenName + "Dto.ts"
+  mapper:        FEATURE_DIR + "/" + fingerprint.layerMap.mappers      + "/" + screenName + "Mapper.ts"
+  mockJson:      FEATURE_DIR + "/" + fingerprint.layerMap.mocks        + "/" + mockJsonFileName
+  endpoints:     FEATURE_DIR + "/" + fingerprint.layerMap.dataSource   + "/" + screenName + "Endpoints.ts"
+  dataSource:    FEATURE_DIR + "/" + fingerprint.layerMap.dataSource   + "/" + dataSourceClassName + ".ts"
+  repoImpl:      FEATURE_DIR + "/" + fingerprint.layerMap.data         + "/repositories/" + repoImplClassName + ".ts"
+  slice:         FEATURE_DIR + "/" + fingerprint.layerMap.stateStore   + "/" + sliceName + "Slice.ts"
+  selectors:     FEATURE_DIR + "/" + fingerprint.layerMap.selectors    + "/" + screenName + "Selectors.ts"
+  screen:        FEATURE_DIR + "/" + fingerprint.layerMap.screens      + "/" + screenComponentName + "/" + screenComponentName + ".tsx"
+}
+
+# Module-level paths (ONE per module, shared across all screens):
+ModuleOutputPaths = {
+  mockConfig:   FEATURE_DIR + "/" + fingerprint.layerMap.dataSource + "/mockConfig.ts"
+  diBootstrap:  FEATURE_DIR + "/diBootstrap.ts"   (or global DI file if fingerprint shows a global one)
+}
+```
+
+If any `fingerprint.layerMap.*` is `null`, skip that file and log a WARN.
+
+**Import path computation for each file:**
+
+For any file at depth D from `fingerprint.appRoot`, the prefix to reach
+`fingerprint.sharedRoot` is:
+```
+If fingerprint.preferAliases && fingerprint.sharedRootAlias != null:
+  USE alias directly → e.g. "@shared/types/Result"
+Else:
+  prefix = repeat("../", D) + fingerprint.sharedRoot
+  → e.g. "../../../../shared"
+```
+
+Similarly for cross-layer imports within the feature, compute relative paths
+from the actual file depths — never hardcode `../../domain`.
+
+---
+
+> ### Phases 3–7 execution order
+>
+> **Single mode**: run Phases 3 → 4 → 5 → 6 → 7 once.
+>
+> **Module mode**: run the following loop:
+> ```
+> FOR each screen in SCREENS[] (in the order provided by the user):
+>   Run Phase 3 for this screen  (skip 3.1 if EntityName.isShared and already generated)
+>   Run Phase 4 for this screen
+>   Run Phase 5 for this screen
+>   Run Phase 7 for this screen
+> END FOR
+> Then run Phase 6 ONCE for the whole module (all screens wired into one diBootstrap)
+> ```
+>
+> Phase 6 is intentionally **after** the per-screen loop in module mode so that
+> all use-case exports are known before the single DI bootstrap is written.
+
+---
+
+## PHASE 3 — Generate Domain Layer
+
+### 3.1 — Entity Interface
+
+File: `PerScreenOutputPaths[screenName].domainModel`
+
+*In module mode: if `EntityName.isShared = true` and this entity was already generated
+for a previous screen, SKIP this step — do not regenerate the shared entity file.*
+
+- Parse every key from `responseShape` recursively
+- Infer TypeScript types from values
+- All fields `readonly` (if `fingerprint.tsStrict === true`)
+- Optional `?` for fields noted as potentially absent
+- Never `any` — use `unknown` for opaque shapes
+- JSDoc comments for fields referenced in `responseMappings`
+- If `fingerprint.explicitReturnType === true`, add return types to any functions
+
+### 3.2 — Repository Interface
+
+File: `PerScreenOutputPaths[screenName].domainRepo`
+
+- `Fetch<ScreenName>Params` interface: one property per `requestBody` field, camelCased
+- Return type is driven by `fingerprint.returnTypeStyle`:
+
+```
+result-wrapper  → Promise<Result<EntityName[]>>
+                  Import Result from fingerprint.resultTypeImport
+
+custom-type     → Promise<<ScreenName>Result>
+                  Define <ScreenName>Result inline in this file as a named interface
+                  containing the domain entities; match the shape used in existing
+                  repository interfaces in the project
+
+direct-promise  → Promise<EntityName[]>
+                  No wrapper — the implementation throws on error
+```
+
+- Zero framework imports
+
+### 3.3 — Use Case
+
+File: `PerScreenOutputPaths[screenName].useCase`
+
+- Class with `constructor(private readonly repository: <repoInterfaceName>)`
+- `execute(params)` method return type matches the repository interface return type
+- Each `businessLogic` rule from spec → one guard clause before delegation
+- Zero framework imports (no React, Redux, Axios, or any detected API lib)
+- **If `fingerprint.returnTypeStyle = "direct-promise"`**: let errors propagate naturally
+  (no `try/catch` or `{ ok }` wrapping in the use case)
+- **If `fingerprint.returnTypeStyle = "result-wrapper"`**: catch and return
+  `{ ok: false, error: message }`
+
+---
+
+## PHASE 4 — Generate Data Layer
+
+### 4.1 — DTO
+
+File: `PerScreenOutputPaths[screenName].dto`
+
+- Mirror raw API response shape exactly, preserving original casing from spec
+- If spec shows PascalCase keys, generate BOTH PascalCase and camelCase variants as optional fields
+- Mapper will use `??` chaining across both variants
+
+### 4.2 — Mapper
+
+File: `PerScreenOutputPaths[screenName].mapper`
+
+Rules (apply regardless of project):
+- Always generate `map<Entity>FromDto` AND `map<Entity>ListFromDto`
+- Every field: `(dto.PascalCaseKey ?? dto.camelCaseKey) ?? <default>`
+- Defaults: `''` for string, `0` for number, `false` for boolean, `[]` for array, `null` for object
+- One mapper file per entity — never merge unrelated entities into one mapper
+
+### 4.3 — Mock JSON
+
+File: `PerScreenOutputPaths[screenName].mockJson`
+
+- Exact JSON matching the `responseShape` from spec
+- Populated with realistic placeholder values
+- Valid JSON (parseable by `JSON.parse`)
+
+### 4.4 — Endpoint Constants
+
+File: `PerScreenOutputPaths[screenName].endpoints`
+
+```typescript
+export const <endpointConstantName>_ENDPOINTS = {
+  FETCH: '<spec.apiUrl>',
+} as const;
+```
+
+### 4.5 — Mock Config
+
+File: `ModuleOutputPaths.mockConfig` — one file per module (shared by all screens)
+
+In module mode: generate a single mockConfig that includes one entry per screen's `operationId`.
+Do NOT generate separate mockConfig files per screen.
+
+Generate using the **exact shape** detected in `fingerprint.mockSystem`. Copy
+field names from the live mockConfig file detected in Phase 0.E. Do not invent
+field names.
+
+If `fingerprint.mockSystem === "none"` → skip this file, add a TODO comment in
+the datasource.
+
+Rules (apply regardless of shape):
+- `fingerprint.mockGlobalFlag` field always `false`
+- Per-API flag for `operationId` always `false`
+- `fingerprint.mockDelayField` value: copy from existing config or default to 800
+
+### 4.6 — API DataSource
+
+File: `PerScreenOutputPaths[screenName].dataSource`
+
+> See: `references/api-envelope-patterns.md` — full templates for all `apiLib` + `envelopeStyle` combinations.
+> Read the section matching the detected values before generating.
+
+Generate using the pattern matching `fingerprint.apiLib` + `fingerprint.envelopeStyle`.
+
+**If apiLib = axios AND envelopeStyle = mb-operationId:**
+
+```typescript
+import { apiClient } from '<fingerprint.apiClientImport>';
+import { <endpointConstantName>_ENDPOINTS } from './<screenName>Endpoints';  // file name uses screenName, not featureFolderName
+import { mockConfig } from './mockConfig';
+import type { Fetch<ScreenName>Params } from '<relative-path-to-domainRepo>';
+import mockData from '<relative-path-to-mockJson>';
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Replicate envelope builder exactly as detected — do not rename fields
+function buildEnvelope(operationId: string, reqdata: Record<string, unknown>): object {
+  return { mb: { operationId, rq: { reqdata } } };
+}
+
+export class <dataSourceClassName> {
+  async fetch<ScreenName>(params: Fetch<ScreenName>Params): Promise<Record<string, unknown>> {
+    const { <operationId> } = mockConfig.apis;
+    // fingerprint.mockGlobalFlag checked FIRST — always
+    if (mockConfig.<fingerprint.mockGlobalFlag> || <operationId>.mockEnabled) {
+      await delay(mockConfig.<fingerprint.mockDelayField>);
+      return mockData as Record<string, unknown>;
+    }
+    const body = buildEnvelope('<operationId>', {
+      // Map camelCase params → original API casing from spec requestBody
+    });
+    const response = await apiClient.<httpMethod.toLowerCase()><Record<string, unknown>>(
+      <endpointConstantName>_ENDPOINTS.FETCH,
+      body,
+    );
+    return response.data;
+  }
+}
+```
+
+**If apiLib = fetch AND envelopeStyle = none:**
+
+```typescript
+export class <dataSourceClassName> {
+  async fetch<ScreenName>(params: Fetch<ScreenName>Params): Promise<Record<string, unknown>> {
+    const response = await fetch('<spec.apiUrl>', {
+      method: '<spec.httpMethod>',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ /* mapped params */ }),
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return response.json();
+  }
+}
+```
+
+**If apiLib = rtk-query or react-query:** Generate the appropriate endpoint/hook
+definition instead of a class. Adapt to the detected pattern.
+
+**Request body field mapping:**
+- `requestBody` from spec shows API-expected field names and casing
+- `Params` interface uses camelCase
+- Datasource maps camelCase params → spec field names inside the request body
+
+### 4.7 — Repository Implementation
+
+File: `PerScreenOutputPaths[screenName].repoImpl`
+
+> DTO type name rule: The DTO interface inside `<screenName>Dto.ts` is named `<ScreenName>Dto`.
+> The domain entity is `<EntityName>` (= `<ScreenName>Item` when the response is an array).
+> They are NOT the same name. Always cast raw items as `<ScreenName>Dto`, not `<EntityName>Dto`.
+
+The return type of the implementation method is driven by `fingerprint.returnTypeStyle`.
+
+**result-wrapper** (when `fingerprint.returnTypeStyle = "result-wrapper"`):
+
+```typescript
+import type { Result } from '<fingerprint.resultTypeImport>';
+import type { <repoInterfaceName>, Fetch<ScreenName>Params } from '<relative-path-to-domainRepo>';
+import type { <EntityName> } from '<relative-path-to-domainModel>';
+import type { <dataSourceClassName> } from '<relative-path-to-dataSource>';
+import { map<Entity>ListFromDto } from '<relative-path-to-mapper>';
+
+export class <repoImplClassName> implements <repoInterfaceName> {
+  constructor(private readonly dataSource: <dataSourceClassName>) {}
+
+  async fetch<ScreenName>(params: Fetch<ScreenName>Params): Promise<Result<<EntityName>[]>> {
+    try {
+      const raw = await this.dataSource.fetch<ScreenName>(params);
+      const items = (raw.Data ?? raw.data ?? []) as <ScreenName>Dto[];  // cast to DTO, not entity
+      return { ok: true, data: map<Entity>ListFromDto(items) };
+    } catch (err: unknown) {
+      const apiErr = err as { statusCode?: number; message?: string };
+      return { ok: false, error: apiErr.message ?? 'Failed to fetch <featureFolderName>' };
+    }
+  }
+}
+```
+
+**custom-type** (when `fingerprint.returnTypeStyle = "custom-type"`):
+
+```typescript
+import type { <repoInterfaceName>, Fetch<ScreenName>Params, <ScreenName>Result } from '<relative-path-to-domainRepo>';
+import type { <dataSourceClassName> } from '<relative-path-to-dataSource>';
+import { map<Entity>ListFromDto } from '<relative-path-to-mapper>';
+
+export class <repoImplClassName> implements <repoInterfaceName> {
+  constructor(private readonly dataSource: <dataSourceClassName>) {}
+
+  async fetch<ScreenName>(params: Fetch<ScreenName>Params): Promise<<ScreenName>Result> {
+    const raw = await this.dataSource.fetch<ScreenName>(params);
+    const items = (raw.Data ?? raw.data ?? []) as <ScreenName>Dto[];  // cast to DTO, not entity
+    return { <primaryField>: map<Entity>ListFromDto(items) };
+    // Shape must match the custom-type interface defined in the domain repo file
+  }
+}
+```
+
+**direct-promise** (when `fingerprint.returnTypeStyle = "direct-promise"`):
+
+```typescript
+import type { <repoInterfaceName>, Fetch<ScreenName>Params } from '<relative-path-to-domainRepo>';
+import type { <EntityName> } from '<relative-path-to-domainModel>';
+import type { <dataSourceClassName> } from '<relative-path-to-dataSource>';
+import { map<Entity>ListFromDto } from '<relative-path-to-mapper>';
+
+export class <repoImplClassName> implements <repoInterfaceName> {
+  constructor(private readonly dataSource: <dataSourceClassName>) {}
+
+  async fetch<ScreenName>(params: Fetch<ScreenName>Params): Promise<<EntityName>[]> {
+    const raw = await this.dataSource.fetch<ScreenName>(params);
+    const items = (raw.Data ?? raw.data ?? []) as <ScreenName>Dto[];  // cast to DTO, not entity
+    return map<Entity>ListFromDto(items);
+    // Errors propagate as thrown exceptions — caller handles them
+  }
+}
+```
+
+---
+
+## PHASE 5 — Generate State Layer
+
+Generate state files only for the detected `fingerprint.stateLib`.
+
+### 5.1 — Redux Toolkit (stateLib = redux-toolkit)
+
+File: `PerScreenOutputPaths[screenName].slice`
+
+Use `fingerprint.thunkPattern` to determine injection style.
+
+**ThunkExtra pattern** (when `fingerprint.thunkPattern = "thunk-extra"`):
+
+The thunk body structure depends on `fingerprint.returnTypeStyle`.
+
+**result-wrapper** (use case returns `{ ok, data, error }`):
+
+```typescript
+import { createSlice, createAsyncThunk } from '@reduxjs/toolkit';
+import type { PayloadAction } from '@reduxjs/toolkit'; // needed: used in extraReducers fulfilled case
+                                                       // also add if any slice reducer receives a payload
+import type { <EntityName> } from '<relative-path-to-domainModel>';
+
+export interface <ScreenName>State {
+  items: <EntityName>[];
+  isLoading: boolean;
+  isRefreshing: boolean;
+  error: string | null;
+  isAuthError: boolean;
+  // Additional state fields derived from spec.screenLogic
+}
+
+const initialState: <ScreenName>State = {
+  items: [],
+  isLoading: false,
+  isRefreshing: false,
+  error: null,
+  isAuthError: false,
+  // Add any extra fields from spec.screenLogic with appropriate zero-value defaults
+};
+
+export const fetch<ScreenName>Thunk = createAsyncThunk(
+  '<sliceName>/fetch',  // e.g. 'transactionHistory/fetch'
+  async (params: { /* from Fetch<ScreenName>Params */ }, { extra, rejectWithValue }) => {
+    try {
+      const { fetch<ScreenName>UseCase } = extra as {
+        fetch<ScreenName>UseCase: {
+          execute: (p: typeof params) => Promise<{ ok: boolean; data?: <EntityName>[]; error?: string }>;
+        };
+      };
+      const result = await fetch<ScreenName>UseCase.execute(params);
+      if (!result.ok) return rejectWithValue({ message: result.error ?? 'Unknown error', isAuthError: false });
+      return result.data;
+    } catch (err: unknown) {
+      const apiErr = err as { statusCode?: number; message?: string };
+      return rejectWithValue({ message: apiErr.message ?? 'Unexpected error', isAuthError: apiErr.statusCode === 401 });
+    }
+  },
+);
+```
+
+**custom-type** (use case returns a named type — no `.ok` field):
+
+```typescript
+export const fetch<ScreenName>Thunk = createAsyncThunk(
+  '<sliceName>/fetch',  // e.g. 'transactionHistory/fetch'
+  async (params: { /* from Fetch<ScreenName>Params */ }, { extra, rejectWithValue }) => {
+    try {
+      const { fetch<ScreenName>UseCase } = extra as {
+        fetch<ScreenName>UseCase: {
+          execute: (p: typeof params) => Promise<<ScreenName>Result>;
+        };
+      };
+      return await fetch<ScreenName>UseCase.execute(params);
+    } catch (err: unknown) {
+      const apiErr = err as { statusCode?: number; message?: string };
+      return rejectWithValue({ message: apiErr.message ?? 'Unexpected error', isAuthError: apiErr.statusCode === 401 });
+    }
+  },
+);
+```
+
+**direct-promise** (use case returns a plain type and throws on error):
+
+```typescript
+export const fetch<ScreenName>Thunk = createAsyncThunk(
+  '<sliceName>/fetch',  // e.g. 'transactionHistory/fetch'
+  async (params: { /* from Fetch<ScreenName>Params */ }, { extra, rejectWithValue }) => {
+    try {
+      const { fetch<ScreenName>UseCase } = extra as {
+        fetch<ScreenName>UseCase: {
+          execute: (p: typeof params) => Promise<<EntityName>[]>;
+        };
+      };
+      return await fetch<ScreenName>UseCase.execute(params);
+    } catch (err: unknown) {
+      const apiErr = err as { statusCode?: number; message?: string };
+      return rejectWithValue({ message: apiErr.message ?? 'Unexpected error', isAuthError: apiErr.statusCode === 401 });
+    }
+  },
+);
+```
+
+// NOTE: If spec.screenLogic contains "pull to refresh" or "refresh", generate
+// refresh<ScreenName>Thunk as described in the refreshThunk generation section below.
+
+const <sliceName>Slice = createSlice({
+  name: '<sliceName>',
+  initialState,
+  reducers: {
+    reset<ScreenName>: () => initialState,
+    // Reducers derived from spec.screenLogic (filters, sorts, selectedItem, tabs)
+  },
+  extraReducers: builder => {
+    // fetch thunk
+    builder
+      .addCase(fetch<ScreenName>Thunk.pending, (state) => {
+        state.isLoading = true;
+        state.error = null;
+        state.isAuthError = false;
+      })
+      .addCase(fetch<ScreenName>Thunk.fulfilled, (state, action: PayloadAction<<EntityName>[]>) => {
+        state.isLoading = false;
+        state.items = action.payload;
+      })
+      .addCase(fetch<ScreenName>Thunk.rejected, (state, action) => {
+        state.isLoading = false;
+        state.error = action.payload as string ?? 'Failed to load';
+        state.isAuthError = action.payload === 'AUTH_ERROR';
+      });
+    // refresh thunk (if generated)
+    // builder
+    //   .addCase(refresh<ScreenName>Thunk.pending, (state) => { state.isRefreshing = true; state.error = null; })
+    //   .addCase(refresh<ScreenName>Thunk.fulfilled, (state, action) => { state.isRefreshing = false; state.items = action.payload; })
+    //   .addCase(refresh<ScreenName>Thunk.rejected, (state, action) => { state.isRefreshing = false; state.error = action.payload as string ?? 'Failed to refresh'; });
+  },
+});
+```
+
+**Direct import pattern** (when `fingerprint.thunkPattern = "direct-import"`):
+
+Import the use case at the top of the slice file and call it directly without
+`extra`.
+
+**refreshThunk generation (add when spec.screenLogic contains "pull to refresh" or "refresh"):**
+
+Generate a separate `refresh<ScreenName>Thunk` alongside the fetch thunk. It has the
+exact same body as `fetch<ScreenName>Thunk` for the applicable `returnTypeStyle`. The
+only difference is the action type string and which state fields it sets:
+
+```typescript
+export const refresh<ScreenName>Thunk = createAsyncThunk(
+  '<sliceName>/refresh',  // e.g. 'transactionHistory/refresh'
+  async (params: { /* same as fetch params */ }, { extra, rejectWithValue }) => {
+    // identical body to fetch<ScreenName>Thunk
+  },
+);
+
+// In extraReducers:
+.addCase(refresh<ScreenName>Thunk.pending, (state) => {
+  state.isRefreshing = true;   // NOT isLoading — this is the critical difference
+  state.error = null;
+})
+.addCase(refresh<ScreenName>Thunk.fulfilled, (state, action) => {
+  state.isRefreshing = false;
+  state.items = action.payload ?? [];
+})
+.addCase(refresh<ScreenName>Thunk.rejected, (state, action) => {
+  state.isRefreshing = false;
+  const payload = action.payload as { message: string; isAuthError: boolean };
+  state.error = payload?.message ?? 'Failed to refresh';
+});
+```
+
+**State fields from screenLogic:**
+
+| screenLogic phrase | State field | Reducer |
+|---|---|---|
+| "filter by category" | `filter: string` | `setFilter` |
+| "sortable by X" | `sortOrder: 'asc' \| 'desc'` | `setSortOrder` |
+| "selected item detail" | `selectedItemId: string \| null` | `setSelectedItem` |
+| "tab switcher" | `activeTab: string` | `setActiveTab` |
+| "pagination" | `page: number`, `hasMore: boolean` | `setPage`, `setHasMore` |
+
+### 5.2 — Selectors
+
+File: `PerScreenOutputPaths[screenName].selectors`
+
+```typescript
+import type { RootState } from '<fingerprint.rootStateImport>';
+
+export const select<ScreenName>Items = (state: RootState) =>
+  state.<reducerKey>.items;  // reducerKey derived in Phase 1.4 for this specific screen
+
+// One selector per state field in the slice
+```
+
+`reducerKey` is the per-screen derived value from Phase 1.4 — NOT the single `fingerprint.reducerKey`.
+In module mode each screen has its own `reducerKey` and they MUST all be distinct.
+
+### 5.3 — Zustand (stateLib = zustand)
+
+> See: `references/state-library-patterns.md` — Zustand section.
+> Detect zustand version and pattern (single store vs slice) before generating.
+
+Generate a store file using the detected zustand pattern (slice-based or single
+store). Do not use Redux patterns.
+
+### 5.4 — Context API (stateLib = context-api)
+
+> See: `references/state-library-patterns.md` — Context API section.
+
+Generate context + reducer + provider. Do not use Redux patterns.
+
+### 5.5 — MobX (stateLib = mobx)
+
+> See: `references/state-library-patterns.md` — MobX section.
+> Detect MobX version (6+ uses `makeAutoObservable`; 4/5 uses `@observable` decorators).
+
+Generate a MobX store class. Do not generate a Redux slice, selectors file, or thunk.
+The screen component must be wrapped in `observer()` from `mobx-react-lite`.
+Computed values are class getters, not a separate selectors file.
+
+---
+
+## PHASE 6 — Generate DI Wiring
+
+Use `fingerprint.diStyle` to choose the generation path.
+
+**Module mode**: Phase 6 runs ONCE after the per-screen loop (Phases 3–5 and 7).
+One DI file is generated for the ENTIRE module. It imports and instantiates every
+datasource, repository, and use case across ALL screens — not one file per screen.
+
+---
+
+### 6.A — per-feature-bootstrap (diStyle = "per-feature-bootstrap")
+
+File: `ModuleOutputPaths.diBootstrap` — one file for the whole module
+
+**Module mode template** (expand the pattern for each screen in `SCREENS[]`):
+```typescript
+// ─── <ModuleName> DI Bootstrap ───────────────────────────────────────────────
+// Auto-generated. Do not edit manually.
+
+// Screen 1: <ScreenName1>
+import { <DataSourceClassName1> } from '<relative-path>';
+import { <RepoImplClassName1> } from '<relative-path>';
+import { Fetch<ScreenName1>UseCase } from '<relative-path>';
+
+// Screen 2: <ScreenName2>
+import { <DataSourceClassName2> } from '<relative-path>';
+import { <RepoImplClassName2> } from '<relative-path>';
+import { Fetch<ScreenName2>UseCase } from '<relative-path>';
+
+// ... (repeat for each screen)
+
+const <screenName1>DataSource = new <DataSourceClassName1>();
+const <screenName1>Repository = new <RepoImplClassName1>(<screenName1>DataSource);
+export const fetch<ScreenName1>UseCase = new Fetch<ScreenName1>UseCase(<screenName1>Repository);
+
+const <screenName2>DataSource = new <DataSourceClassName2>();
+const <screenName2>Repository = new <RepoImplClassName2>(<screenName2>DataSource);
+export const fetch<ScreenName2>UseCase = new Fetch<ScreenName2>UseCase(<screenName2>Repository);
+
+// ... (repeat for each screen)
+```
+
+**Single mode template** (unchanged behaviour — one screen):
+```typescript
+import { <dataSourceClassName> } from '<relative-path>';
+import { <repoImplClassName> } from '<relative-path>';
+import { Fetch<ScreenName>UseCase } from '<relative-path>';
+
+// <screenNameCamelCase> = camelCase of screenName, e.g. TransactionHistory → transactionHistory
+const <screenNameCamelCase>DataSource = new <dataSourceClassName>();
+const <screenNameCamelCase>Repository = new <repoImplClassName>(<screenNameCamelCase>DataSource);
+export const fetch<ScreenName>UseCase = new Fetch<ScreenName>UseCase(<screenNameCamelCase>Repository);
+```
+
+**If `fingerprint.thunkPattern = "thunk-extra"`**, append a comment:
+```typescript
+// Wire into store extra argument in <fingerprint.storeConfigFile>:
+// { ...existingExtra, fetch<ScreenName>UseCase }
+```
+
+**Store wiring instruction (append to diBootstrap.ts or DI container file):**
+
+After the DI wiring, always add the following comments describing the exact manual steps
+the developer must perform.
+
+*In module mode, list ALL screens in the STORE REDUCER and THUNK EXTRA blocks, and list
+ALL screen registrations in the NAVIGATOR block:*
+
+```typescript
+// ─── MANUAL WIRING REQUIRED ───────────────────────────────────────────────
+//
+// 1. STORE REDUCER — open <fingerprint.storeConfigFile> and add one import + key per screen:
+//
+//      import <sliceName1>Reducer from '<relative-path-to-slice1>';
+//      import <sliceName2>Reducer from '<relative-path-to-slice2>';
+//
+//      reducer: {
+//        ...existingReducers,
+//        <reducerKey1>: <sliceName1>Reducer,
+//        <reducerKey2>: <sliceName2>Reducer,
+//      }
+//
+// 2. THUNK EXTRA (thunk-extra only) — in the same file, add to middleware:
+//
+//      getDefaultMiddleware({ thunk: { extraArgument: {
+//        ...existingExtra,
+//        fetch<ScreenName1>UseCase,
+//        fetch<ScreenName2>UseCase,
+//      }}})
+//
+// 3. NAVIGATOR — open <fingerprint.navScreenFile> and add one import + Stack.Screen per screen:
+//
+//      import <ScreenName1>Screen from '<relative-path-to-screen1>';
+//      import <ScreenName2>Screen from '<relative-path-to-screen2>';
+//
+//      // Inside the navigator stack:
+//      <Stack.Screen name="<ScreenName1>" component={<ScreenName1>Screen} />
+//      <Stack.Screen name="<ScreenName2>" component={<ScreenName2>Screen} />
+//
+//      // Add to <fingerprint.navParamsPattern> type:
+//      <ScreenName1>: { /* params if any */ } | undefined;
+//      <ScreenName2>: { /* params if any */ } | undefined;
+//
+// ─────────────────────────────────────────────────────────────────────────
+```
+
+---
+
+### 6.B — per-feature-container (diStyle = "per-feature-container")
+
+File: `FEATURE_DIR + "/" + fingerprint.layerMap.di + "/" + moduleName + "Container.ts"`
+
+In **module mode**: generate ONE container class for the entire module. It holds one datasource,
+repository, and use-case getter per screen — all wired inside the single class.
+
+In **single mode**: generate one container for the single screen (same as before).
+
+Use the class and method names matching those in `fingerprint.diContainerClass`.
+
+```typescript
+import { <dataSourceClassName> } from '<relative-path>';
+import { <repoImplClassName> } from '<relative-path>';
+import { Fetch<ScreenName>UseCase } from '<relative-path>';
+import type { I<ScreenName>Repository } from '<relative-path>';
+
+class <ScreenName>Container {
+  private static _instance: <ScreenName>Container | null = null;
+
+  private readonly _dataSource: <dataSourceClassName>;
+  private readonly _repository: I<ScreenName>Repository;
+
+  private constructor() {
+    this._dataSource = new <dataSourceClassName>();
+    this._repository = new <repoImplClassName>(this._dataSource);
+  }
+
+  static getInstance(): <ScreenName>Container {
+    if (!<ScreenName>Container._instance) {
+      <ScreenName>Container._instance = new <ScreenName>Container();
+    }
+    return <ScreenName>Container._instance;
+  }
+
+  get fetch<ScreenName>UseCase(): Fetch<ScreenName>UseCase {
+    return new Fetch<ScreenName>UseCase(this._repository);
+  }
+
+  // For testing: reset singleton between test suites
+  static resetInstance(): void {
+    <ScreenName>Container._instance = null;
+  }
+}
+
+export const <featureFolderName>Container = <ScreenName>Container.getInstance();
+```
+
+Consumers call `<featureFolderName>Container.fetch<ScreenName>UseCase.execute(params)`.
+
+---
+
+### 6.C — global (diStyle = "global")
+
+Append the new feature's wiring to the existing global DI file. Never overwrite
+existing entries.
+
+---
+
+### 6.D — none (diStyle = "none")
+
+Skip DI file generation. Components instantiate dependencies inline (rare — log a WARN).
+
+---
+
+## PHASE 7 — Generate Screen Component
+
+File: `PerScreenOutputPaths[screenName].screen`
+
+### 7.1 — Imports
+
+Resolve all imports using the fingerprint:
+- `useDispatch`, `useSelector` from `react-redux` (if redux)
+- `AppDispatch` from fingerprint-resolved store path
+- Thunks from `PerScreenOutputPaths[screenName].slice` (relative import)
+- Selectors from `PerScreenOutputPaths[screenName].selectors` (relative import)
+- Entity type from `PerScreenOutputPaths[screenName].domainModel` (relative import)
+
+For navigation (if spec.screenLogic mentions navigation):
+- Import navigator hook matching `fingerprint.navLib`:
+  - `useNavigation` from `@react-navigation/native`
+  - `useRouter` from `expo-router`
+  - `Navigation` from `react-native-navigation`
+
+### 7.2 — Response Mapping Implementation
+
+> See: `assets/transform-rules.json` — full keyword-to-TypeScript-expression map.
+> Match each transform phrase in the spec against entries in that file (case-insensitive substring match).
+> If no entry matches, render as raw string and log a WARN.
+
+For every `responseMappings` entry in the spec:
+
+1. Trace the dot-notation path through the entity interface using optional chaining
+2. Match the transform keyword against `assets/transform-rules.json`. Use `nullSafe` variant when the field is optional.
+   Quick reference (non-exhaustive — always read the JSON file):
+   - `"formatted as indian currency"` → `toLocaleString('en-IN', { style: 'currency', currency: 'INR' })`
+   - `"formatted as percentage"` → `` `${(value * 100).toFixed(2)}%` ``
+   - `"formatted as date"` → `new Date(value).toLocaleDateString('en-IN', { day: '2-digit', month: 'short', year: 'numeric' })`
+   - `"formatted as boolean badge"` → conditional `<Text style>` with color
+   - `"formatted as compact number"` → Cr/L abbreviation for Indian units
+   - `"unique key"` / `"hidden"` → used as keyExtractor only, not rendered
+3. Add a comment above each JSX element citing the spec mapping instruction
+4. If mapping says "hide when null/empty" → conditional render `{value ? <Text>...</Text> : null}`
+
+### 7.3 — Screen Logic Implementation
+
+> See: `references/screen-logic-patterns.md` — complete JSX implementations for every pattern below.
+> Read the matching section(s) and compose them into the screen component.
+
+| screenLogic type | Implementation |
+|---|---|
+| Navigate to detail on tap | `onPress` → `navigation.navigate(...)` using fingerprint nav style |
+| Filter list | Local or Redux filter state, filtered `FlatList data` |
+| Summary card at top | `ListHeaderComponent` on FlatList |
+| Tab switcher | Tab bar component, state for active tab |
+| Pull to refresh | `RefreshControl` with refresh thunk dispatch |
+| Empty state | `ListEmptyComponent` |
+| Auth error + logout | Check `isAuthError`, render logout UI |
+| Pagination / load more | `onEndReached` with page state |
+| Search / query filter | `TextInput` with `useMemo` filtered array |
+
+---
+
+## PHASE 8 — Validation
+
+> **Module mode**: run Phase 8 in a loop over every screen in `SCREENS[]`.
+> Check `ModuleOutputPaths` (mockConfig, diBootstrap) once after the per-screen loop.
+
+### 8.1 — Mapping Coverage
+
+For every `responseMappings` entry of the current screen: verify it appears in the screen component.
+Missing mapping → FATAL. Fix before output.
+
+### 8.2 — File Checklist
+
+Report a table of all expected files vs. actually generated files. Any layer
+that was `null` in the fingerprint is listed as `SKIPPED (not in project)` —
+not as missing.
+
+### 8.3 — Pattern Consistency
+
+| Check | Rule |
+|---|---|
+| API client import matches fingerprint | No feature-local axios.create |
+| mockGlobalFlag checked before per-API flag | In every datasource method |
+| All mapper fields use `??` chaining | No bare `dto.field` |
+| Thunk uses `rejectWithValue` | Never throws from thunk |
+| Use case has zero framework imports | No React, Redux, or API lib |
+| No `any` (if fingerprint.noImplicitAny) | Use `unknown` |
+| Readonly entity fields (if fingerprint.tsStrict) | Applied |
+| Import aliases match fingerprint.aliasMap | Consistent with project |
+| Quote/semicolon style matches fingerprint | Consistent with prettier config |
+
+### 8.4 — Import Depth Verification
+
+For each generated file: count actual directory depth from `appRoot`. Verify
+that relative imports compute to valid paths. Log any mismatch as FATAL.
+
+---
+
+## PHASE 9 — Output Summary
+
+**Single mode summary:**
+```
+=== feature-generator OUTPUT SUMMARY ===
+Mode:               single
+Architecture Fingerprint: [attached above]
+Screen:             <ScreenName>
+Files generated:    <N>
+Files skipped:      <N>  (layers not present in project)
+Mappings covered:   <N>/<N> ✅
+
+Generated:
+  <list of PerScreenOutputPaths[ScreenName]>
+  <ModuleOutputPaths.mockConfig>
+  <ModuleOutputPaths.diBootstrap>
+
+Skipped (layer not in project):
+  <list of null layers>
+
+Required manual steps:
+  1. Add fetch<ScreenName>UseCase to <fingerprint.storeConfigFile> extra argument
+  2. Register <ScreenName>Screen in <fingerprint.navScreenFile>
+  3. Set <operationId>.mockEnabled = true in mockConfig for local testing
+==================================================
+```
+
+**Module mode summary:**
+```
+=== feature-generator MODULE SUMMARY ===
+Mode:               module
+Module:             <ModuleName>
+Screens:            <N>
+Architecture Fingerprint: [attached above]
+
+Module folder: <FEATURE_DIR>/
+  diBootstrap.ts                         [MODULE-LEVEL]
+  domain/
+    models/
+      shared/
+        <SharedEntityName>.ts            [SHARED — used by: ScreenA, ScreenB]
+      <ScreenName1>Item.ts
+      <ScreenName2>Item.ts
+    repositories/
+      I<ScreenName1>Repository.ts
+      I<ScreenName2>Repository.ts
+    useCases/
+      Fetch<ScreenName1>UseCase.ts
+      Fetch<ScreenName2>UseCase.ts
+  data/
+    datasources/
+      mockConfig.ts                      [MODULE-LEVEL]
+      <ScreenName1>Endpoints.ts
+      <ScreenName2>Endpoints.ts
+      <ScreenName1>ApiDataSource.ts
+      <ScreenName2>ApiDataSource.ts
+    dtos/
+      <ScreenName1>Dto.ts
+      <ScreenName2>Dto.ts
+    mappers/
+      <ScreenName1>Mapper.ts
+      <ScreenName2>Mapper.ts
+    repositories/
+      <ScreenName1>RepositoryImpl.ts
+      <ScreenName2>RepositoryImpl.ts
+  state/
+    store/
+      <screenName1>Slice.ts
+      <screenName2>Slice.ts
+    selectors/
+      <ScreenName1>Selectors.ts
+      <ScreenName2>Selectors.ts
+  presentation/
+    screens/
+      <ScreenName1>Screen/
+        <ScreenName1>Screen.tsx
+      <ScreenName2>Screen/
+        <ScreenName2>Screen.tsx
+
+Files generated:    <N total across all screens>
+Files skipped:      <N>  (layers not present in project)
+Shared entities:    <N>
+
+Per-screen mapping coverage:
+  <ScreenName1>: <N>/<N> mappings ✅
+  <ScreenName2>: <N>/<N> mappings ✅
+
+Required manual steps:
+  1. Add all slice reducers to <fingerprint.storeConfigFile>:
+     <screenName1>: <sliceName1>Reducer
+     <screenName2>: <sliceName2>Reducer
+  2. Add all use cases to store extra argument:
+     fetch<ScreenName1>UseCase, fetch<ScreenName2>UseCase
+  3. Register all screens in <fingerprint.navScreenFile>:
+     <ScreenName1>, <ScreenName2>
+  4. Set mockEnabled = true per screen in mockConfig for local testing
+==================================================
+```
+
+> **Do NOT report completion to the user after PHASE 9.**
+> Proceed immediately to PHASE 10 — Post-Completion Validation.
+
+---
+
+## PHASE 10 — Post-Completion Validation & Auto-Fix
+
+> **Run this phase after all files in PHASE 9 have been generated.**
+> Do NOT report completion to the user until this phase produces a `READY` status.
+> For every failed check: fix the issue, then re-run that specific check before proceeding to the next.
+> Never skip a check. Never mark a check as passed without verifying it.
+>
+> **Module mode**: run checks 10.1–10.7 in a loop over every screen in `SCREENS[]`.
+> Also validate `ModuleOutputPaths` (diBootstrap, mockConfig) once after the per-screen loop.
+> The 10.8 final report aggregates results across all screens.
+
+---
+
+### 10.1 — File Existence Check
+
+For every path in `PerScreenOutputPaths[currentScreen]` AND (after the loop) `ModuleOutputPaths`:
+- Read the file — if it does not exist or is empty, regenerate it using the phase that produces it
+- Log: `MISSING → regenerating <path>`
+
+Pass condition: every non-null path entry exists and has content.
+
+---
+
+### 10.2 — Import Resolution Check
+
+For each generated file:
+- Read every import statement
+- For relative imports: verify the target file exists at the computed path
+- For alias imports: verify the alias prefix exists in `fingerprint.aliasMap`
+- If a broken import is found: correct the path using the fingerprint, rewrite the file
+- Log: `BROKEN IMPORT in <file>: <bad-path> → fixed to <correct-path>`
+
+Pass condition: zero broken imports across all generated files.
+
+---
+
+### 10.3 — Response Mapping Coverage Check
+
+For every entry in `RESPONSE_MAPPINGS` collected in PHASE -1 Q5:
+- Search the generated screen component for the `responseField` value
+- If a field is present in mappings but absent from the screen: add it
+- If a `transform` was specified but not applied: apply it using the matching rule from `assets/transform-rules.json`
+- Log: `UNMAPPED FIELD <responseField> → added to screen with transform: <transform or none>`
+
+Pass condition: every `RESPONSE_MAPPINGS` entry appears in the screen component.
+
+---
+
+### 10.4 — Business Logic Coverage Check
+
+For every rule in `BUSINESS_LOGIC_RULES` collected in PHASE -1 Q4:
+- Read the use case `execute()` method
+- Verify a guard clause or conditional exists that directly implements the rule
+- If a rule has no corresponding guard: add it to the use case
+- Log: `MISSING RULE "<rule>" → added guard clause to <useCase path>`
+
+Pass condition: every business logic rule has a traceable guard clause in the use case.
+
+---
+
+### 10.5 — Test Case Coverage Check
+
+*Skip this check with `N/A` if no test cases were provided in PHASE -1 Q3.*
+
+For each entry in `TEST_CASES`:
+- `type: happy` — verify the primary success path exists: data loads, renders in FlatList/View, no error state shown
+- `type: edge` — verify the edge condition is handled: empty state component, boundary guard in use case, null-safe access
+- `type: error` — verify the error state is rendered: error message in screen, `rejectWithValue` in thunk, error field in state
+- If a scenario is unhandled: add the required handling to the appropriate file (use case, slice, or screen)
+- Log: `UNHANDLED TC-<id> "<description>" → fixed in <file>`
+
+Pass condition: all test case scenarios have implementation coverage.
+
+---
+
+### 10.6 — User Story Coverage Check
+
+*Skip this check with `N/A` if no user stories were provided in PHASE -1 Q2.*
+
+For each entry in `USER_STORIES`:
+- Map the `action` and `benefit` to a feature behaviour (navigation, data display, interaction, feedback)
+- Verify that behaviour is implemented across: screen logic, state slice, or navigation wiring
+- If a story is not covered: identify the phase responsible and regenerate only the affected file(s)
+- Log: `UNCOVERED US-<id> "<story>" → fixed in <file>`
+
+Pass condition: every user story action has a traceable implementation.
+
+---
+
+### 10.7 — Code Quality Check
+
+Read each generated file and verify the following rules. Fix any violation in-place:
+
+| Rule | Check |
+|---|---|
+| R3 — `??` chaining | No bare `dto.field` — must be `(dto.FieldA ?? dto.fieldA) ?? default` |
+| R4 — mockGlobalFlag order | `fingerprint.mockGlobalFlag` checked BEFORE per-operationId `mockEnabled` |
+| R7 — Use case purity | Use case file has zero imports from react, redux, axios, or any detected API lib |
+| R5 — Readonly fields | All entity interface fields are `readonly` when `fingerprint.tsStrict === true` |
+| No `any` | No `any` type used when `fingerprint.noImplicitAny === true` — use `unknown` |
+| R12 — Style consistency | Quote style, semicolons, and tab width match `fingerprint.quoteStyle / semi / tabWidth` |
+
+Log: `CODE QUALITY: <rule> violation in <file> at line <approx> → fixed`
+
+Pass condition: zero unfixed violations.
+
+---
+
+### 10.8 — Final Status Report
+
+After all checks pass (or have been fixed and re-verified):
+
+**Single mode report:**
+```
+=== PHASE 10 VALIDATION REPORT ===
+Mode:                    single
+Screen:                  <ScreenName>
+Files verified:          <N>/<N>
+Imports resolved:        <N>/<N>
+Mappings covered:        <N>/<N>
+Business rules covered:  <N>/<N>
+Test cases handled:      <N>/<N>  (or N/A)
+User stories covered:    <N>/<N>  (or N/A)
+Code quality checks:     <N>/<N>
+
+Auto-fixed issues:
+  <list each MISSING / BROKEN / UNMAPPED / UNHANDLED / CODE QUALITY item that was fixed>
+  ("None" if everything passed on first check)
+
+Status: READY — all checks passed
+     OR BLOCKED — <describe exactly what the user must provide to unblock>
+===================================
+```
+
+**Module mode report:**
+```
+=== PHASE 10 MODULE VALIDATION REPORT ===
+Mode:                    module
+Module:                  <ModuleName>
+Screens validated:       <N>
+
+Per-screen results:
+  <ScreenName1>:
+    Files:           <N>/<N>  Imports: <N>/<N>  Mappings: <N>/<N>  Rules: <N>/<N>
+    TC: <N>/<N>  US: <N>/<N>  Quality: <N>/<N>
+  <ScreenName2>:
+    Files:           <N>/<N>  Imports: <N>/<N>  Mappings: <N>/<N>  Rules: <N>/<N>
+    TC: <N>/<N>  US: <N>/<N>  Quality: <N>/<N>
+
+Module-level files:
+  diBootstrap.ts:  ✅ | ❌
+  mockConfig.ts:   ✅ | ❌
+
+Totals:
+  Files verified:          <N>/<N>
+  Imports resolved:        <N>/<N>
+  Mappings covered:        <N>/<N>
+  Business rules covered:  <N>/<N>
+  Test cases handled:      <N>/<N>  (or N/A)
+  User stories covered:    <N>/<N>  (or N/A)
+  Code quality checks:     <N>/<N>
+
+Auto-fixed issues:
+  <list each MISSING / BROKEN / UNMAPPED / UNHANDLED / CODE QUALITY item with screen name prefix>
+  ("None" if everything passed on first check)
+
+Status: READY — all screens and module-level files passed
+     OR BLOCKED — <describe exactly what input or clarification is needed per screen>
+==========================================
+```
+
+Only report completion to the user after this report shows `READY`.
+If `BLOCKED`, describe exactly what input or clarification is needed and wait for the user.
+
+---
+
+## Universal Rules
+
+### R1 — Zero Hardcoded Paths
+No file, import path, folder name, or alias may be written without first
+deriving it from the Architecture Fingerprint. If the fingerprint cannot resolve
+it, log FATAL.
+
+### R2 — Fingerprint Is the Only Source of Truth
+The spec tells you WHAT to build. The fingerprint tells you HOW (paths, imports,
+patterns, naming). Never override fingerprint values with guesses.
+
+### R3 — Field Casing Always Uses `??` Chaining
+```typescript
+// ✅
+const name = (dto.UserName ?? dto.userName) ?? '';
+// ❌
+const name = dto.UserName;
+```
+
+### R4 — mockGlobalFlag Before Per-API Flag
+```typescript
+// ✅
+if (mockConfig[fingerprint.mockGlobalFlag] || apiConfig.mockEnabled) { ... }
+// ❌
+if (apiConfig.mockEnabled || mockConfig[fingerprint.mockGlobalFlag]) { ... }
+```
+
+### R5 — Entity Immutability
+`readonly` on all entity fields when `fingerprint.tsStrict === true`.
+
+### R6 — Mapping Coverage Is Mandatory
+Every `responseMappings` entry in the spec must appear in the screen. Missing
+entries block output (FATAL).
+
+### R7 — Business Logic Stays in Domain
+All spec `businessLogic` rules → use case `execute()` guard clauses only.
+Never in slice, datasource, or component.
+
+### R8 — Screen Logic Stays in Screen
+All spec `screenLogic` behaviour → screen component only.
+Never in use case or slice.
+
+### R9 — One Mapper Per Entity
+If the response produces two entity types → two mapper files.
+
+### R10 — Append, Never Overwrite DI
+When adding to a global DI file, append new exports only.
+
+### R11 — Skip, Don't Invent Missing Layers
+If a layer is `null` in the fingerprint, skip it with a WARN. Do not invent
+a folder that doesn't exist in the project.
+
+### R12 — Quote/Semicolon/Indent Style Matches Project
+Apply `fingerprint.quoteStyle`, `fingerprint.semi`, `fingerprint.tabWidth` to
+every generated file. Consistency with the existing codebase is non-negotiable.
+
+---
+
+## Decision Points
+
+| Situation | Action |
+|---|---|
+| App root cannot be located | FATAL — ask user to specify |
+| Feature organisation style is ambiguous | Generate to dominant style; WARN about secondary |
+| Detected state lib is not redux-toolkit | Adapt generation to detected lib; do not use RTK patterns |
+| No envelope pattern detected | Generate plain request body without wrapper |
+| No mock system detected | Skip mockConfig; add TODO comment in datasource |
+| Import aliases found but not used in existing features | Set preferAliases = false; use relative paths |
+| Response is single object (not array) | Generate `mapFromDto` only; skip list mapper |
+| Response has deeply nested data | Generate nested sub-entity interfaces and mappers |
+| Multiple spec files provided | In **module mode**: all spec files belong to one shared feature folder. Run Phases 3–5, 7 per screen then Phase 6 once. In **single mode** with multiple files: treat as multiple independent features and run the full pipeline separately for each. |
+| Global DI file exists | Append to it; never overwrite |
+| Screen file already exists | Ask user before overwriting; offer to merge mappings |
+| Navigation not detected | Generate screen component without nav imports; WARN |
+| RootState type not locatable | Generate selector with `any` as state type; mark as FIXME |
+| `dtos` layer is null | Inline DTO type inside mapper file |
+| `selectors` layer is null | Inline selectors at bottom of slice file |
+
+---
+
+## Integration with flutter-rn-orchestrator
+
+When called via the orchestrator:
+- **Skip Phase 0** — use the GSD artifacts (`ARCHITECTURE.md`, `STRUCTURE.md`,
+  `CONVENTIONS.md`, `INTEGRATIONS.md`, `STACK.md`) as the fingerprint source.
+  Parse those files to build the fingerprint instead of crawling.
+- Spec file is derived from the orchestrator's layout and domain analysis artifacts.
+- Output file paths are written to the orchestrator's `artifacts/` inventory.
+
+---
+
+## Example Spec File
+
+```markdown
+# Feature Spec: Transaction History
+
+## Screen Name
+TransactionHistory
+
+## API URL
+/api/v1/portfolio/transactions
+
+## HTTP Method
+POST
+
+## Request Body
+```json
+{
+  "ClientCode": 12345,
+  "SessionID": "abc-session-xyz",
+  "FamilyFlag": 0
+}
+```
+
+## Response Shape
+```json
+{
+  "Status": "success",
+  "Data": [
+    {
+      "TransactionID": "TXN001",
+      "FundName": "SBI Bluechip Fund",
+      "Amount": 5000.00,
+      "TransactionDate": "2024-01-15",
+      "TransactionType": "Purchase",
+      "Units": 12.345,
+      "NAV": 405.23
+    }
+  ]
+}
+```
+
+## Business Logic
+- Only show transactions where Amount > 0
+- Transactions older than 7 years should be marked as "Archived"
+- If Status is not "success", treat the response as an error
+
+## Screen Logic
+- Fetch transaction history on screen mount
+- Support pull-to-refresh
+- Navigate to TransactionDetail screen when user taps a transaction row
+- Show empty state message "No transactions found" when list is empty
+
+## Response Mapping
+- `Data[].TransactionID` → unique key for each list row (not visible to user)
+- `Data[].FundName` → primary title of each row
+- `Data[].Amount` → below FundName, formatted as Indian currency (₹)
+- `Data[].TransactionDate` → subtitle, formatted as "15 Jan 2024"
+- `Data[].TransactionType` → badge: green for Purchase, red for Redemption
+- `Data[].Units` → detail row: "Units: 12.345"
+- `Data[].NAV` → detail row: "NAV: ₹405.23"
+```