# AI-Driven Development Compatibility Report

**Project:** QuitSure Laravel Program
**Date:** 2026-03-04 (v10)
**Laravel Version:** 11.47.0 | **PHP:** 8.2+
**Analyzed by:** Claude Opus 4.6

---

## Overall AI Compatibility Score

| | |
|---|---|
| **Score** | **87 / 100** |
| **Grade** | **B+** |
| **Previous** | 85 / 100 (B) on 2026-03-03 (v09) |
| **Verdict** | Service interface expansion: 5 new interfaces created (7 → 12 total, 50 typed method signatures). Only UtilityService remains without an interface (static utility helper — intentional). Controller return types improved ~88% → ~90%. Service return types improved ~82% → ~86%. 4 new test files added (61 → 65). |

Service interface coverage is now near-complete: 12 of 13 services have formal contracts with fully-typed method signatures. Combined with return type improvements across controllers and services, **type safety is approaching production-grade quality**. Remaining gaps: DTOs for untyped arrays, 1 service without interface (UtilityService — static helper), 7 inline validations in base controllers.

---

## Category Scores

| Category | Score | Weight | Weighted | Status | Change |
|---|---|---|---|---|---|
| Structure & Navigability | 15/15 | 15% | 15.0 | Excellent | — |
| Code Consistency | 14/15 | 15% | 14.0 | Strong | — |
| Type Safety & Contracts | 13/15 | 15% | 13.0 | Strong | +2 |
| Code Duplication (DRY) | 8/10 | 10% | 8.0 | Strong | — |
| Testing Infrastructure | 6/10 | 10% | 6.0 | Moderate | — |
| Documentation & Context | 10/10 | 10% | 10.0 | Excellent | — |
| File Size & Complexity | 6/10 | 10% | 6.0 | Improving | — |
| Architecture & Dependencies | 10/10 | 10% | 10.0 | Excellent | — |
| Change Safety & Verifiability | 5/5 | 5% | 5.0 | Excellent | — |
| **Total** | | **100%** | **87.0** | **B+** | **+2** |

*Note: Type Safety improvement (+2 points) driven by 5 new service interfaces (7 → 12 total, 50 typed method signatures), controller return types ~88% → ~90%, service return types ~82% → ~86%. Only UtilityService remains without an interface.*

---

## Detailed Category Analysis

### 1. Structure & Navigability — 15/15 (Excellent)

**What works well:**
- **Version-first directory hierarchy**: `V2/` and `V3/` are the top-level groupings, making version boundaries immediately visible
- Dedicated layers: Controllers → Query Classes → Models → Services
- 40 Query classes provide a clean data-access abstraction that AI can reason about
- `CLAUDE.md` provides purpose-built AI navigation context
- All 790 production routes are named using a consistent `{flow}.{lang}.{section}.{step}` convention
- `app/Contracts/` directory provides a clear map of service capabilities (12 interfaces)
- `app/Http/Requests/` directory centralizes validation rules (OnBoarding, B2C, B2B)
- **14 per-directory README.md files** across `app/` subdirectories (8 in controller directories)

**What's improved (v06 — V2/V3 restructuring):**
- **Version is now the top-level grouping.** Previously V3 was a subfolder inside each flow (`B2C/V3/`, `OnBoarding/V3/`). Now it's `V3/B2C/`, `V3/OnBoarding/` — making version boundaries explicit.
- **AI can immediately determine version scope.** Working in `V2/B2C/` means all files are legacy V2. Working in `V3/OnBoarding/` means all files are redesigned V3.
- **Base controllers are duplicated per version.** `V2/B2C/B2CController.php` and `V3/B2C/B2CController.php` each have version-specific viewPrefix logic — no more runtime `$viewVersion` detection.
- **Views, layouts, and JS partials follow the same V2/V3 structure**, creating a consistent hierarchy across all layers.

**What's improved (v07 — OnBoarding consolidation):**
- **OnBoarding controllers now use the same Base Controller pattern as B2C and B2B.** 10 base controllers hold all shared logic; 32 language controllers are thin stubs (9-10 lines each for most languages).
- **All three major controller flows are now consolidated** — AI modifies one base controller to fix bugs, not 5-7 language variants.
- **Two distinct OnBoarding architectures are cleanly separated**: Standard group (English, German, Hindi, Japanese, Portuguese — 4 base controllers) and Extended group (Spanish, French — 6 base controllers with a redesigned flow).

**What hinders AI:**
- Blade views remain duplicated across languages

**Controller hierarchy (V2):**
```
app/Http/Controllers/V2/
├── B2C/
│   ├── B2CController.php              ← Common setup (150 lines)
│   ├── BaseCustomerController.php     ← ALL shared logic (2,333 lines)
│   ├── BranchController.php           ← Branch.io deep links
│   ├── RazorpayBillingController.php  ← Razorpay subscription billing
│   ├── English/CustomerController.php ← Razorpay + subscribe overrides (431 lines)
│   ├── German/CustomerController.php  ← Config only (16 lines)
│   ├── Hindi/CustomerController.php   ← Config only (16 lines)
│   ├── Japanese/CustomerController.php← Config only (16 lines)
│   ├── Portuguese/CustomerController.php ← Config only (16 lines)
│   └── Spanish/CustomerController.php ← Custom subscribe (167 lines)
├── B2B/
│   ├── B2BController.php              ← Common setup (135 lines)
│   ├── BasePartnerController.php      ← ALL shared logic (1,740 lines)
│   ├── BranchController.php           ← Branch.io deep links
│   ├── English/PartnerController.php  ← Razorpay subscription overrides (469 lines)
│   ├── German/PartnerController.php   ← Config only (16 lines)
│   ├── Hindi/PartnerController.php    ← Config only (16 lines)
│   ├── Japanese/PartnerController.php ← Config only (16 lines)
│   ├── Portuguese/PartnerController.php ← Config only (16 lines)
│   └── Spanish/PartnerController.php  ← Config only (16 lines)
└── OnBoarding/
    ├── OnBoardingController.php           ← Common setup (252 lines)
    ├── OnBoardingAuthController.php       ← Auth error display (44 lines)
    ├── BaseBasicController.php            ← Standard Step 1 shared logic (323 lines)
    ├── BaseQuittingController.php         ← Standard Step 2 shared logic (523 lines)
    ├── BaseMySmokingController.php        ← Standard Step 3 shared logic (596 lines)
    ├── BaseFinalSetupController.php       ← Standard Step 4 shared logic (492 lines)
    ├── BaseExtBasicController.php         ← Extended Step 1 shared logic (167 lines)
    ├── BaseExtQuittingController.php      ← Extended Step 2 shared logic (251 lines)
    ├── BaseCurrentStatusController.php    ← Extended Step 3a shared logic (418 lines)
    ├── BaseSmokingBehaviourController.php ← Extended Step 3b shared logic (521 lines)
    ├── BaseThoughtPatternsController.php  ← Extended Step 3c shared logic (288 lines)
    ├── BaseExtFinalSetupController.php    ← Extended Step 4 shared logic (635 lines)
    ├── English/ (4 thin controllers: 10-372 lines)
    ├── German/ (4 thin controllers: 9-13 lines)
    ├── Hindi/ (4 thin controllers: 9-157 lines)
    ├── Japanese/ (4 thin controllers: 9-13 lines)
    ├── Portuguese/ (4 thin controllers: 9-87 lines)
    ├── Spanish/ (6 thin controllers: 10 lines each)
    └── French/ (6 thin controllers: 10 lines each)
```

**Controller hierarchy (V3 — English only):**
```
app/Http/Controllers/V3/
├── B2C/
│   ├── B2CController.php              ← V3 setup
│   ├── BaseCustomerController.php     ← V3 shared logic
│   └── English/
│       ├── CustomerController.php
│       └── LoadingController.php
└── OnBoarding/
    ├── OnBoardingController.php       ← V3 setup
    └── English/
        ├── BasicController.php
        ├── GoalController.php
        ├── PersonaliseController.php
        ├── CustomPlanController.php
        └── QuitsureController.php
```

**View/layout/partial structure mirrors controllers:**
```
resources/views/
├── V2/
│   ├── B2C/{english,hindi,german,japanese,portuguese,spanish}/
│   ├── B2B/{english,hindi,german,japanese,portuguese,spanish}/
│   ├── onBoarding/{english,hindi,german,japanese,portuguese,spanish,french}/
│   └── layouts/          ← @extends('V2.layouts.B2C'), etc.
├── V3/
│   ├── B2C/english/
│   ├── onBoarding/english/
│   └── layouts/          ← @extends('V3.layouts.onBoarding'), etc.
├── partials/js/
│   ├── V2/{B2C,B2B,onBoarding}/
│   └── V3/{B2C,onBoarding}/
└── layouts/
    ├── angelEmail.blade.php  ← Not versioned
    └── webquiz.blade.php     ← Not versioned
```

**Key metrics:**

| Component | Count | Avg Lines | Change |
|---|---|---|---|
| Controllers | 84 | ~258 | — |
| Models | 45 | ~150 | — |
| Query Classes | 40 | ~200 | — |
| Services | 13 | ~260 | — |
| Contracts/Interfaces | 12 | ~50 | +5 (service interfaces) |
| Form Requests | 35 | ~40 | — |
| Blade Views | 469 | ~88 | — |
| Routes | 795 (790 named) | Single file | — |

---

### 2. Code Consistency — 14/15 (Strong)

This is the codebase's greatest strength for AI development. Once an AI learns one controller's pattern, it can predict the structure of all others.

**Highly consistent patterns:**

**Base controller + inheritance pattern (B2C, B2B, and OnBoarding):**
```php
// Same pattern applied to V2 B2C, V2 B2B, and V2 OnBoarding
abstract class BaseCustomerController extends B2CController       // V2/B2C/
abstract class BasePartnerController extends B2BController        // V2/B2B/
class BaseBasicController extends OnBoardingController            // V2/OnBoarding/
class BaseQuittingController extends OnBoardingController         // V2/OnBoarding/
class BaseMySmokingController extends OnBoardingController        // V2/OnBoarding/
class BaseFinalSetupController extends OnBoardingController       // V2/OnBoarding/
{
    abstract protected function getPrograms(): array;  // B2C/B2B

    protected function getSubscribeExtraViewData(string $vCountry): array
    {
        return [];  // Hook for child overrides
    }
}
```

**Language controller — minimal config only (B2C, B2B, and OnBoarding):**
```php
// V2/B2C, V2/B2B, and V2/OnBoarding all use thin language controllers
class CustomerController extends BaseCustomerController     // V2/B2C/{Language}/
class PartnerController extends BasePartnerController       // V2/B2B/{Language}/
class BasicController extends BaseBasicController           // V2/OnBoarding/{Language}/
class QuittingController extends BaseQuittingController     // V2/OnBoarding/{Language}/
{
    // B2C/B2B: 16-line files with getPrograms() override
    // OnBoarding: 9-10 line files, most with zero overrides
}
```

**Version-specific viewPrefix pattern (NEW — consistent across all base controllers):**
```php
// V2 base controllers
$this->viewPrefix = 'V2.B2C.' . config("app.languages.{$this->currentLang}", 'english') . '.';
$this->viewPrefix = 'V2.B2B.' . config("app.languages.{$this->currentLang}", 'english') . '.';
$this->viewPrefix = 'V2.onBoarding.' . config("app.languages.{$this->currentLang}", 'english') . '.';

// V3 base controllers
$this->viewPrefix = 'V3.B2C.' . config("app.languages.{$this->currentLang}", 'english') . '.';
$this->viewPrefix = 'V3.onBoarding.' . config("app.languages.{$this->currentLang}", 'english') . '.';
```

**Model convention (all 45 models):**
```php
// app/Models/User.php
class User extends Model {
    protected $table = 'tbl_Users';       // Always prefixed with tbl_
    protected $primaryKey = 'iUserID';     // Always Hungarian notation
    public $timestamps = false;            // Always disabled
    protected $fillable = [...];           // Always specified
}
```

**Query class convention (all 40 classes):**
```php
// Consistent method naming: get*(), create(), update(), check*(), find*()
public function getUserProgram(int $iUserID, int $iProgramID): ?UserProgram
public function create(array $data): int
public function update(int $id, array $data): bool
```

**Interface convention (all 12 contracts):**
```php
interface PaymentGatewayInterface
{
    public function createCustomer(array $customerData): object|false;
    public function createSubscription(array $subscriptionData): object|false;
}
```

**Form Request convention (all 35 requests):**
```php
class SubmitNameRequest extends FormRequest
{
    public function authorize(): bool { return true; }
    public function rules(): array { return ['vName' => 'required|string|min:3|max:30']; }
    protected function failedValidation(Validator $validator): void { /* JSON error */ }
}
```

**Hungarian notation is consistent throughout:**

| Prefix | Type | Examples |
|---|---|---|
| `v` | varchar/string | `vEmail`, `vName`, `vAccessToken` |
| `i` | integer | `iUserID`, `iProgramID`, `iPartnerId` |
| `b` | boolean | `bActive`, `bDeleted`, `bSubscribed` |
| `d` | date | `dDateCreated`, `dExpiryDate` |
| `dec` | decimal | `decCostPerMonth`, `decMultiplier` |
| `set` | array/JSON | `setHealthIssues`, `setQuittingReasons` |

**Remaining inconsistencies:**
- Minor concatenation spacing: `viewPrefix . 'email'` vs `viewPrefix.'email'`
- Session key naming: mixed `PascalCase` (`LoggedinUser`), `SCREAMING_SNAKE` (`CHECKOUT_SESSION_ID`), `snake_case` (`page_loaded`)

---

### 3. Type Safety & Contracts — 13/15 (Strong)

**What exists now:**
- PHP 8.2+ enables modern type features
- **PHPStan at level 7/9** with Larastan and baseline (upgraded from level 5)
- Constructor parameters have type hints (via PHP 8.1 promoted properties)
- **12 service interfaces** define 50 typed method signatures
- **35 Form Requests** with typed validation rules (OnBoarding: 26, B2C: 5, B2B: 4)
- **All 45 models have `@property` PHPDoc** annotations (~599 lines of type metadata)
- Query class return types at ~95% coverage (115/121 methods)
- Controller return types at ~90% coverage (304/338 methods)
- Service return types at ~86% coverage (78/91 methods)
- Both `BaseCustomerController` and `BasePartnerController` have `@return array<int, array{iProgramID: int, name: string}>` PHPDoc on `getPrograms()`

**Good type coverage (RazorpayService — the gold standard in this codebase):**
```php
// app/Services/RazorpayService.php
private string $keyId;
private string $keySecret;
public function generateOrder(array $requestData): object|false
private function convertToSubunit(float|int $amount): int
```

**What's improved (v10 — service interface expansion):**
- **5 new interfaces created:** `BajajHealthEventInterface`, `GympassServiceInterface`, `SubModuleServiceInterface`, `UserProgramServiceInterface`, `WebProfilerInterface`
- **12 of 13 services now have formal contracts** (was 7 of 13)
- **50 typed method signatures** across all interfaces (was 35)
- **All 6 modified services have 100% return type coverage** on their public methods
- **Controller return types improved**: 25+ return type declarations added across 15 controllers

**What's still missing:**

**1 service still has no interface:**
- `UtilityService` — static utility helper class (intentional design; static methods are not suitable for interface contracts)

**No DTOs:**
- Data still passed as untyped arrays between layers
- AI must trace array keys through multiple method calls to understand data shapes

**Some B2C/B2B validation still inline (partially migrated):**
Form Requests now cover most B2C/B2B methods (email, checkout, promocode), but 7 inline `Validator::make()` calls remain (5 in BaseCustomerController, 2 in BasePartnerController) for methods like `resendEmailOTP()` and `submitVerify()`:
```php
// app/Http/Controllers/V2/B2C/BaseCustomerController.php
$validator = Validator::make($request->all(), ['otp' => 'required']);
```

**Type coverage estimate:**

| Layer | Constructor Types | Return Types | Parameter Types | PHPDoc | Change |
|---|---|---|---|---|---|
| Controllers | 100% | ~90% (304/338) | ~80% | ~15% | +2% |
| Services | 80% | ~86% (78/91) | ~50% | 100% | +4% |
| Query Classes | 90% | ~95% (115/121) | ~60% | ~30% | — |
| Models | N/A | ~80% (relations) | N/A | ~95% (`@property`) | — |
| Helpers | N/A | 100% | 100% | 100% | — |
| Contracts | 100% | 100% | 100% | 100% | — |
| Form Requests | N/A | 100% | N/A | 100% | — |

---

### 4. Code Duplication — 8/10 (Strong)

B2C (v04), B2B (v05), and OnBoarding (v07) consolidations together eliminate **~31,000 lines** of controller duplication. Blade views remain the sole significant source.

**B2C Controller Duplication — ELIMINATED (v04):**

| Controller | Before | After | Reduction |
|---|---|---|---|
| `V2/B2C/BaseCustomerController.php` | — | 2,333 | NEW (shared logic) |
| `V2/B2C/English/CustomerController.php` | 2,399 | 431 | -82% |
| `V2/B2C/German/CustomerController.php` | 2,371 | 16 | -99% |
| `V2/B2C/Hindi/CustomerController.php` | 2,370 | 16 | -99% |
| `V2/B2C/Japanese/CustomerController.php` | 2,372 | 16 | -99% |
| `V2/B2C/Portuguese/CustomerController.php` | 2,371 | 16 | -99% |
| `V2/B2C/Spanish/CustomerController.php` | 2,333 | 167 | -93% |
| **B2C Total** | **14,216** | **2,995** | **-79%** |
| **B2C Duplicated Lines** | **~12,000** | **~0** | **-100%** |

**B2B Controller Duplication — ELIMINATED (v05):**

| Controller | Before | After | Reduction |
|---|---|---|---|
| `V2/B2B/BasePartnerController.php` | — | 1,740 | NEW (shared logic) |
| `V2/B2B/English/PartnerController.php` | 1,861 | 469 | -75% |
| `V2/B2B/German/PartnerController.php` | 1,783 | 16 | -99% |
| `V2/B2B/Hindi/PartnerController.php` | 1,783 | 16 | -99% |
| `V2/B2B/Japanese/PartnerController.php` | 1,783 | 16 | -99% |
| `V2/B2B/Portuguese/PartnerController.php` | 1,783 | 16 | -99% |
| `V2/B2B/Spanish/PartnerController.php` | 1,783 | 16 | -99% |
| **B2B Total** | **10,776** | **~2,289** | **-79%** |
| **B2B Duplicated Lines** | **~9,000** | **~0** | **-100%** |

**OnBoarding Controller Duplication — ELIMINATED (v07):**

10 base controllers extract all shared logic. 32 language controllers reduced to thin stubs.

*Standard group (English, German, Hindi, Japanese, Portuguese — 4 controllers each):*

| Controller | Before (×5) | Base (NEW) | Lang Avg | Reduction |
|---|---|---|---|---|
| `BaseBasicController.php` | 5 × 325 = 1,625 | 323 | 10 | -80% |
| `BaseQuittingController.php` | 5 × 525 = 2,625 | 523 | 9 | -80% |
| `BaseMySmokingController.php` | 5 × 590 = 2,950 | 596 | 24 | -79% |
| `BaseFinalSetupController.php` | 5 × 500 = 2,500 | 492 | 127 | -75% |
| **Standard Subtotal** | **9,700** | **1,934** | **680** | **-73%** |

*Extended group (Spanish, French — 6 controllers each):*

| Controller | Before (×2) | Base (NEW) | Lang Each | Reduction |
|---|---|---|---|---|
| `BaseExtBasicController.php` | 2 × 169 = 338 | 167 | 10 | -48% |
| `BaseExtQuittingController.php` | 2 × 252 = 504 | 251 | 10 | -48% |
| `BaseCurrentStatusController.php` | 2 × 420 = 840 | 418 | 10 | -49% |
| `BaseSmokingBehaviourController.php` | 2 × 523 = 1,046 | 521 | 10 | -49% |
| `BaseThoughtPatternsController.php` | 2 × 290 = 580 | 288 | 10 | -47% |
| `BaseExtFinalSetupController.php` | 2 × 637 = 1,274 | 635 | 10 | -49% |
| **Extended Subtotal** | **4,582** | **2,280** | **120** | **-48%** |

| | Before | After | Reduction |
|---|---|---|---|
| **OnBoarding Language Controllers** | **14,282** | **971** | **-93%** |
| **OnBoarding Base Controllers (NEW)** | — | 4,214 | — |
| **OnBoarding Total** | **14,282** | **5,185** | **-64%** |
| **OnBoarding Duplicated Lines** | **~10,000** | **~0** | **-100%** |

**Notable overrides in language controllers:**
- English `FinalSetupController` (372 lines) — `UserProgramService` dependency, subscription intent logic
- Hindi `FinalSetupController` (157 lines) — language-specific validation messages
- Portuguese `FinalSetupController` (87 lines) — localized error messages
- English `MySmokingController` (71 lines) — `getbSubBypass()` helper
- Japanese/Portuguese/German `MySmokingController` (13 lines each) — localized validation messages

**Overall Duplication Status:**

| Area | Duplicated Lines | Status | Change |
|---|---|---|---|
| B2C Controllers | ~0 | Resolved | — |
| B2B Controllers | ~0 | Resolved | — |
| OnBoarding Controllers | ~0 | Resolved | **NEW — was ~10,000** |
| Blade Views (B2C + B2B + OnBoarding) | ~estimated 8,000+ | Critical | — |
| **Total Estimated** | **~8,000** | **Down from ~31,000** | **-74%** |

**Why remaining duplication hurts AI:**
1. **Blade view duplication** — UI changes must be applied to language-specific views
2. **Drift risk** — AI might apply a Blade fix slightly differently across variants

**What the three consolidation rounds prove:**
The Base Controller pattern works consistently across all three flows (B2C, B2B, OnBoarding). OnBoarding required a more nuanced approach — two distinct controller families (Standard: 4 base controllers, Extended: 6 base controllers) — but the result is the same: language controllers become thin configuration stubs.

---

### 5. Testing Infrastructure — 6/10 (Moderate)

**Strengths:**

- **61 test files** covering unit, feature, and integration layers (~35,700 lines)
- **Pest PHP framework** with custom expectations in `tests/Pest.php`:
  ```php
  expect()->extend('toBeSuccessResponse', function () {
      return $this->toHaveKey('success', true);
  });
  expect()->extend('toBeValidUser', function () {
      return $this->toHaveKeys(['iUserID', 'vEUserID']);
  });
  ```
- **MockHelper** (`tests/Helpers/MockHelper.php`) with 50+ factory methods:
  ```php
  MockHelper::mockUserQuery(['getUser' => $fakeUser]);
  MockHelper::mockStripePaymentService();
  ```
- **TestDataBuilder** (`tests/Helpers/TestDataBuilder.php`) for composing test objects:
  ```php
  TestDataBuilder::userWithAllRelations(['user' => ['iProgramID' => 5]]);
  ```
- **In-memory SQLite** configured in `phpunit.xml` for fast tests
- **56 test cases** for `CalculationService` alone — the most thoroughly tested component
- **Tests moved to V2/ structure** — `tests/Feature/Controllers/V2/` mirrors the controller hierarchy

**Weaknesses:**
- **No database factories** — `database/factories/` does not contain model factories; tests use MockHelper instead
- **No migrations** — Cannot run real database tests; all tests mock DB layer
- **Some tests skipped** — Stripe webhook tests deferred to integration
- **No code coverage thresholds** defined
- **Controller test ratio** — 48 feature tests for 84 controllers (~57% coverage)

**AI impact:** AI can run tests to verify changes (`php artisan test`) but cannot write tests that exercise real database interactions. The mock-heavy approach means tests verify wiring, not behavior.

---

### 6. Documentation & Context — 10/10 (Excellent)

**CLAUDE.md is exceptional (the strongest single factor):**

This file alone elevates the documentation score significantly. It tells an AI:
- Where to find things (controller organization, query classes, services)
- What conventions to follow (route naming: `{flow}.{lang}.{section}.{step}`)
- What non-standard patterns exist (Hungarian notation, session auth, no migrations)
- How to run commands (`composer dev`, `php artisan test`, `./vendor/bin/phpstan analyse`)
- Business logic reference (Addiction Scoring, Subscription Intent, Payment Gateway Selection)
- Multi-database architecture (3 connections with model mappings)

**Additional documentation:**
- `README.md` — Project-specific Quick Start, architecture overview, documentation index
- **14 per-directory `README.md` files** across `app/` subdirectories (8 in controller directories)
- `tests/Test.md` — Test infrastructure documentation (176 lines)
- `AI_COMPATIBILITY_REPORT.md` — This report (version history tracking)
- `@property` PHPDoc on all 45 models (~599 lines of type metadata)
- 100% PHPDoc coverage on all public methods in services and helpers

**What's improved (v06):**
- **8 new controller README.md files** document the V2/V3 hierarchy:
  - `Controllers/README.md` — Root overview with root-level controllers table
  - `V2/README.md` — V2 summary (3 flows, 6-7 languages)
  - `V2/B2B/README.md` — B2B base + language controllers + flow
  - `V2/B2C/README.md` — B2C base + language controllers + flow
  - `V2/OnBoarding/README.md` — OnBoarding base + language controllers + steps
  - `V3/README.md` — V3 summary (English-only)
  - `V3/B2C/README.md` — V3 B2C base + controllers + flow
  - `V3/OnBoarding/README.md` — V3 OnBoarding base + 5-step breakdown

**Remaining gaps:**
- No API documentation (no external REST API currently exposed)
- No architecture decision records (ADRs)
- `BaseCustomerController` and `BasePartnerController` architecture not yet documented in CLAUDE.md

---

### 7. File Size & Complexity — 6/10 (Improving)

Large files remain a barrier to AI effectiveness, but the OnBoarding consolidation converted 32 oversized controllers (300-650 lines each) into thin stubs. The base controllers themselves are moderate-sized (167-635 lines).

**Top 15 largest controller files:**

| File | Lines | AI Processable? |
|---|---|---|
| `V2/B2C/BaseCustomerController.php` | 2,333 | Partial — requires chunked reading |
| `V3/B2C/BaseCustomerController.php` | 2,331 | Partial — requires chunked reading |
| `V2/B2B/BasePartnerController.php` | 1,740 | Partial — requires chunked reading |
| `V3/B2C/English/CustomerController.php` | 1,678 | Partial |
| `WebQuiz/ResultController.php` | 1,469 | Partial |
| `V2/OnBoarding/BaseExtFinalSetupController.php` | 635 | Full |
| `V3/OnBoarding/English/CustomPlanController.php` | 598 | Full |
| `V2/OnBoarding/BaseMySmokingController.php` | 596 | Full |
| `V2/OnBoarding/BaseQuittingController.php` | 523 | Full |
| `V2/OnBoarding/BaseSmokingBehaviourController.php` | 521 | Full |
| `V3/OnBoarding/English/BasicController.php` | 487 | Full |
| `StripePaymentController.php` | 481 | Full |
| `WebhookController.php` | 475 | Full |
| `V2/B2B/English/PartnerController.php` | 469 | Full |
| `V3/OnBoarding/English/PersonaliseController.php` | 457 | Full |

**What's improved (v07):**
- 32 OnBoarding language controllers were 300-650 lines each — now 26 of them are 9-10 lines
- All OnBoarding base controllers are under 640 lines — fully processable by AI in a single pass
- 5 files remain above 1,000 lines (V2/V3 B2C bases, B2B base, V3 B2C English, WebQuiz ResultController)

**What remains problematic:**
- `BaseCustomerController.php` is still 2,333 lines with **28 constructor dependencies**
- `BasePartnerController.php` is 1,740 lines with **28 constructor dependencies**
- V3 BaseCustomerController is 2,331 lines (near-copy of V2)
- V3 CustomerController is 1,678 lines
- WebQuiz ResultController is 1,469 lines
- Routes remain in a single 623-line file

**Constructor over-injection persists in B2C/B2B base controllers:**
```php
// Both V2/B2C/BaseCustomerController and V2/B2B/BasePartnerController
public function __construct(
    protected Request $request,
    protected CouponQuery $couponQuery,       // 1
    protected CurrencyQuery $currencyQuery,   // 2
    // ... 25 more dependencies
) {
```

---

### 8. Architecture & Dependencies — 10/10 (Excellent)

**Base Controller pattern consistent across all three flows (B2C, B2B, OnBoarding):**

All three flow families now use the same architectural approach:

```php
// SAME PATTERN in both V2/B2C and V2/B2B
abstract class BasePartnerController extends B2BController
{
    // Abstract: language controllers MUST implement
    abstract protected function getPrograms(): array;

    // Hook: language controllers CAN override
    protected function getSubscribeExtraViewData(string $vCountry): array
    {
        return [];
    }

    // Template method: calls abstract + hooks
    public function subscribe(Request $request)
    {
        $programs = $this->getPrograms();           // abstract
        $data = array_merge([...], $this->getSubscribeExtraViewData($vCountry)); // hook
    }
}

// English overrides: subscription-based Razorpay (B2B)
class PartnerController extends BasePartnerController
{
    protected function getPrograms(): array
    {
        return [['iProgramID' => 1, 'name' => 'text'], ['iProgramID' => 3, 'name' => 'video']];
    }

    protected function getSubscribeExtraViewData(string $vCountry): array
    {
        return ['vCountry' => $vCountry];
    }

    // English-only: subscription-based Razorpay (createCustomer -> createSubscription)
    public function razorPayCheckout(Request $request) { ... }
    public function razorPaySuccess(Request $request) { ... }
}

// German/Hindi/Japanese/Portuguese/Spanish: config only (16 lines each)
class PartnerController extends BasePartnerController
{
    protected function getPrograms(): array
    {
        return [['iProgramID' => 4, 'name' => 'text'], ['iProgramID' => 3, 'name' => 'video']];
    }
}
```

**V2/V3 version separation (NEW — v06):**

Base controllers no longer detect V3 at runtime. Each version has its own base controller with hardcoded viewPrefix:

```php
// V2/B2C/B2CController.php — always V2
$this->viewPrefix = 'V2.B2C.' . config("app.languages.{$this->currentLang}", 'english') . '.';

// V3/B2C/B2CController.php — always V3
$this->viewPrefix = 'V3.B2C.' . config("app.languages.{$this->currentLang}", 'english') . '.';
```

This eliminates the previous `$viewVersion` conditional logic. Routes map directly to V2 or V3 controller namespaces.

**Key B2B vs B2C difference (preserved correctly):**

| Aspect | B2C English | B2B English | B2B Others (5 langs) |
|---|---|---|---|
| Razorpay flow | Subscription-based | Subscription-based | **Order-based** |
| `getSubscribeExtraViewData` | `showAlternatePayLink` | `vCountry` | `[]` (default) |

**OnBoarding Base Controller pattern (NEW — v07):**

OnBoarding uses the same inheritance approach but with two controller families:

```php
// Standard group: 4 base controllers for English, German, Hindi, Japanese, Portuguese
class BaseBasicController extends OnBoardingController { /* Step 1: 323 lines */ }
class BaseQuittingController extends OnBoardingController { /* Step 2: 523 lines */ }
class BaseMySmokingController extends OnBoardingController { /* Step 3: 596 lines */ }
class BaseFinalSetupController extends OnBoardingController { /* Step 4: 492 lines */ }

// Extended group: 6 base controllers for Spanish, French (redesigned flow)
class BaseExtBasicController extends OnBoardingController { /* Step 1: 167 lines */ }
class BaseExtQuittingController extends OnBoardingController { /* Step 2: 251 lines */ }
class BaseCurrentStatusController extends OnBoardingController { /* Step 3a: 418 lines */ }
class BaseSmokingBehaviourController extends OnBoardingController { /* Step 3b: 521 lines */ }
class BaseThoughtPatternsController extends OnBoardingController { /* Step 3c: 288 lines */ }
class BaseExtFinalSetupController extends OnBoardingController { /* Step 4: 635 lines */ }

// Language controllers — thin stubs (9-10 lines, zero overrides for most)
class BasicController extends BaseBasicController {}  // V2/OnBoarding/German/
class BasicController extends BaseExtBasicController {} // V2/OnBoarding/Spanish/
```

**Why the unified pattern is excellent for AI:**
1. **Consistent across all flows** — AI learning the B2C pattern can immediately apply it to B2B and OnBoarding
2. **Single source of truth** — Bug fixes in any base controller apply to all languages
3. **Predictable "add language" task** — Create 9-10 line stub files
4. **Clear flow separation** — Standard (4-step) vs Extended (6-step) OnBoarding flows are architecturally distinct
5. **Clear Razorpay separation** — Order-based is the default; subscription-based is an explicit override (B2C/B2B)

**Existing good patterns:**
- **Query class layer** — 40 classes encapsulating DB access
- **Service layer** — 13 services with business logic separated from HTTP concerns
- **12 service interfaces** — AI can discover service contracts by reading interfaces (was 7 — 5 new in v10)
- **35 Form Requests** — Validation centralized across OnBoarding, B2C, and B2B

**What's improved (v10 — service interfaces):**
- **5 new interfaces created** for previously untyped services: `BajajHealthEventInterface` (1 method), `GympassServiceInterface` (2 methods), `SubModuleServiceInterface` (2 methods), `UserProgramServiceInterface` (1 method), `WebProfilerInterface` (6 methods)
- **50 total typed method signatures** across all 12 interfaces (was 35 across 7)
- **AI can now discover all service capabilities** by reading `app/Contracts/` alone

**Remaining problematic patterns:**

**Some B2C/B2B validation still inline (7 instances — partially extracted to Form Requests):**
```php
// 5 instances in BaseCustomerController, 2 in BasePartnerController
$validator = Validator::make($request->all(), ['otp' => 'required']);
```

**Data passed as untyped arrays (no DTOs):**
```php
$customerData = [
    'Status' => true,
    'vSource' => $vSource,
    'baseSection' => 1,       // No type safety
];
```

**1 service still without interface:**
- `UtilityService` — static utility helper class (static methods are not suitable for interface contracts)

---

### 9. Change Safety & Verifiability — 5/5 (Excellent)

**Positive:**
- Tests exist and can catch regressions (`php artisan test`)
- **PHPStan level 7** catches type errors (`./vendor/bin/phpstan analyse`)
- **PHPStan baseline** tracks 1,232 existing errors for gradual resolution
- **Pint configured** with Laravel preset (`pint.json`) enforces consistent formatting
- **All three controller flows (B2C, B2B, OnBoarding) have single source of truth** — modify one base controller instead of 5-7 language variants
- **V2/V3 separation means version changes are isolated** — modifying V3 cannot accidentally affect V2

**Remaining risks:**
- No migration system means schema changes can't be verified
- 2 PHPStan path exclusions remain (`WebController.php`, `WebQuiz/*`)
- No CI/CD pipeline definition visible in the repo

---

## AI Task Success Likelihood

| Task | Success Rate | Difficulty | Notes |
|---|---|---|---|
| Read & explain a specific method | 95% | Low | Consistent patterns make comprehension easy |
| Fix a bug in B2C flow | 95% | Low | Single file edit in V2/B2C/BaseCustomerController |
| Fix a bug in B2B flow | 95% | Low | Single file edit in V2/B2B/BasePartnerController |
| Fix a bug in OnBoarding flow | 90% | Low | Single file edit in one of 10 base controllers |
| Fix a bug in one language variant | 90% | Low | Clear file location, testable |
| Add a new field to a model | 85% | Low | Follow existing fillable pattern; `@property` PHPDoc guides AI |
| Add a new Query class method | 90% | Low | Very consistent patterns to follow |
| Add a new Service class | 90% | Medium | 12 interface templates now exist to follow |
| Add a new onboarding step | 70% | Medium | Edit one base controller + add views (was 35% before consolidation) |
| Add a new B2C language | 80% | Low | Create 16-line controller in V2/B2C/{Language}/ |
| Add a new B2B language | 80% | Low | Create 16-line controller in V2/B2B/{Language}/ |
| Add a new OnBoarding language | 80% | Low | Create 4-6 stub controllers (9-10 lines each) |
| Refactor B2C payment logic | 70% | Medium | Single file, interface contract helps |
| Refactor B2B payment logic | 70% | Medium | Single file, interface contract helps |
| Write a new test | 75% | Medium | Good MockHelper, but must understand mock patterns |
| Modify the route file | 80% | Medium | 623 lines, 790 named routes |
| Create a Form Request | 90% | Low | 35 existing examples to follow |
| Create a service interface | 95% | Low | 12 existing examples to follow |
| Add a V3 language variant | 85% | Low | Copy English controller, V3 structure is clean |

---

## Top Recommendations (Prioritized by Impact)

### Priority 1 — Critical (Score Impact: +10-15 points)

#### ~~R1. Extract language-specific differences into configuration~~ — ALL THREE FLOWS COMPLETED

**B2C: DONE (v04).** `V2/B2C/BaseCustomerController` (2,333 lines) consolidates all shared B2C logic. Language controllers reduced to 16-431 lines each. Total B2C code: 14,216 → 2,995 lines.

**B2B: DONE (v05).** `V2/B2B/BasePartnerController` (1,740 lines) consolidates all shared B2B logic. Language controllers reduced to 16-469 lines each. Total B2B code: 10,776 → ~2,289 lines.

**OnBoarding: DONE (v07).** 10 base controllers (4,214 lines total) consolidate all shared OnBoarding logic. Two distinct controller families — Standard (4 base controllers for English/German/Hindi/Japanese/Portuguese) and Extended (6 base controllers for Spanish/French). 32 language controllers reduced from ~14,300 to ~970 lines. OnBoarding code: 14,282 → 5,185 lines.

#### R2. Split BaseCustomerController/BasePartnerController by extracting Action classes

**Current:** `V2/B2C/BaseCustomerController.php` — 2,333 lines, 28 dependencies; `V2/B2B/BasePartnerController.php` — 1,740 lines, 26 dependencies
**Target:** ~400-line controllers delegating to focused Action classes

```php
// Extract: app/Actions/B2C/SubmitEmailAction.php
class SubmitEmailAction
{
    public function __construct(
        private LoginQuery $loginQuery,
        private PostmarkService $postmarkService,
    ) {}

    public function execute(SubmitEmailRequest $request, array $sessionData): JsonResponse
    {
        // ... focused OTP logic (~40 lines)
    }
}
```

**Impact:** Controllers drop below 400 lines. Constructor params drop to 5-8. Each Action is fully processable by AI in a single pass.

### Priority 2 — High (Score Impact: +8-12 points)

#### R3. Add return type declarations to all public methods — MOSTLY DONE

**Current:** Controllers ~88% (389/441 methods), Query classes ~95% (115/121 methods), Services ~82% (75/91 methods).
**Remaining:** ~12% of controller methods (52 methods) and ~18% of service methods (16 methods) still lack return types.

#### R4. Introduce Form Requests for B2C/B2B validation — MOSTLY DONE

**Completed:** 35 Form Requests created (OnBoarding: 26, B2C: 5, B2B: 4). Covers email submission, checkout, promocode operations across all flows.
**Remaining:** A few B2C/B2B methods still use inline validation (`resendEmailOTP`, `submitVerify`). Now centralized in base controllers, extracting remaining Form Requests is straightforward.

#### ~~R5. Increase PHPStan level to 7+~~ — COMPLETED

### Priority 3 — Medium (Score Impact: +5-8 points)

#### R6. Split routes into feature-specific files

**Current:** Single 623-line `routes/web.php` (790 named routes)
**Target:** Feature-based route files

```
routes/
├── web.php              ← Requires only, 20 lines
├── web/onboarding.php   ← OnBoarding routes
├── web/b2c.php          ← B2C routes
├── web/b2b.php          ← B2B routes
├── web/webhooks.php     ← Webhook routes
└── web/payments.php     ← Payment routes
```

#### ~~R7. Create interfaces for remaining services~~ — COMPLETED

**Completed:** 12 interfaces with 50 fully-typed method signatures (was 7 interfaces with 35 methods).
**New in v10:** `BajajHealthEventInterface` (1 method), `GympassServiceInterface` (2 methods), `SubModuleServiceInterface` (2 methods), `UserProgramServiceInterface` (1 method), `WebProfilerInterface` (6 methods).
**Remaining:** Only `UtilityService` has no interface (static utility helper — intentional design).

#### R8. Add database factories for models

### Priority 4 — Low (Score Impact: +2-4 points)

#### ~~R9. Add named routes consistently~~ — COMPLETED
#### ~~R10. Document multi-database architecture~~ — COMPLETED
#### R11. Create Blade components from repeated UI patterns
#### ~~R12. Add PHPDoc to CommonHelper.php functions~~ — COMPLETED
#### ~~R13. Add `@property` PHPDoc to models~~ — COMPLETED
#### R14. Document BaseCustomerController + BasePartnerController architecture in CLAUDE.md

---

## Implementation Roadmap

```
Phase 1: Quick Wins (1-2 weeks)                    Score Impact: +10
├── R3: Add return types (Rector-assisted)       MOSTLY DONE (~88% controllers, ~95% queries, ~82% services)
├── R5: PHPStan level 7 + baseline              DONE
├── R9: Named routes on critical paths           DONE
├── R10: Document database architecture          DONE
├── R12: PHPDoc on helpers                       DONE
├── R13: Model @property PHPDoc                  DONE
└── R14: Document base controllers in CLAUDE.md  TODO

Phase 2: Architecture Improvements (2-4 weeks)      Score Impact: +12
├── R1: Consolidate B2C controllers              DONE (v04)
├── R1: Consolidate B2B controllers              DONE (v05)
├── R1: Consolidate OnBoarding controllers       DONE (v07)
├── R4: Form Requests for B2C/B2B               MOSTLY DONE (35 created, few inline remain)
├── R6: Split route file                         TODO
├── R7: Service interfaces                       DONE (12/13 — only UtilityService intentionally excluded)
├── V2/V3 directory restructuring                DONE (v06)
└── R8: Model factories                          TODO

Phase 3: Structural Refactor (4-8 weeks)            Score Impact: +9
├── R2: Extract Action classes from base         TODO
└── R11: Blade components                        TODO

Projected Score After All Phases: ~93/100 (A)
```

| Phase | Effort | Risk | Score After |
|---|---|---|---|
| v01 (Initial) | — | — | 55 (D+) |
| v02 | Low | Low | 60 (C-) |
| v03 | Medium | Low | 68 (C) |
| v04 | Medium | Low | 73 (C+) |
| v05 | Medium | Low | 78 (B-) |
| v06 | Low | Low | 78 (B-) |
| v07 | Medium | Low | 83 (B) |
| v08 | Low | Low | 85 (B) |
| v09 | — | — | 85 (B) |
| **v10 (Current)** | **Low** | **Low** | **87 (B+)** |
| Phase 1 Complete | ~1 week remaining | Low | 88 (B+) |
| Phase 2 Complete | 2-4 weeks | Medium | 91 (A-) |
| Phase 3 Complete | 4-8 weeks | High | 93 (A) |

---

## Codebase Statistics Summary

| Metric | Value | Change |
|---|---|---|
| Total PHP Files (app/) | 242 | +5 |
| Total Blade Views | 469 | — |
| Total PHP Lines (app/) | ~32,500 | +200 |
| Total Blade Lines | ~41,600 | — |
| Controllers | 84 | — |
| Models | 45 | — |
| Query Classes | 40 | — |
| Services | 13 | — |
| Contracts/Interfaces | 12 | +5 |
| Form Requests | 35 | — |
| Test Files | 65 | +4 |
| Routes | 795 (790 named) | — |
| **Largest File** | **2,333 lines** | — (V2/B2C/BaseCustomerController) |
| Max Constructor Params | 28 | — (both BaseCustomerController and BasePartnerController) |
| Languages Supported | 7 | — |
| B2C Duplicated Lines | ~0 | — |
| B2B Duplicated Lines | ~0 | — |
| OnBoarding Duplicated Lines | ~0 | **NEW — was ~10,000** |
| **Total Estimated Duplication** | **~8,000** | **-5,000 (Blade views only)** |
| PHPStan Level | 7/9 | — |
| PHPStan Baseline Errors | 1,232 | — |
| Test Framework | Pest PHP | — |
| Database Connections | 3 | — |
| External Integrations | 8 | — |
| Interface Methods | 50 | +15 |
| Directory READMEs | 14 | — |

---

## Appendix: What Makes This Codebase Uniquely Challenging

### Hungarian Notation in Database Columns

All 45 models use non-standard column naming (`iUserID`, `vEmail`, `bActive`). While consistent, this means:
- AI cannot rely on Laravel conventions (`id`, `email`, `is_active`)
- Relationship resolution requires manual tracing (custom foreign keys everywhere)
- Any AI-generated migration or factory must use Hungarian notation
- **Mitigated:** `@property` PHPDoc on all models now exposes column types statically

### Session-Based Authentication (No Laravel Auth)

The codebase uses custom session management (`Session::get('LoggedinUser')`, `Session::get('CustomerData')`) rather than Laravel's built-in authentication. AI cannot use standard Auth scaffolding patterns.

### No Migrations Architecture

Database schema is managed outside this codebase. This means:
- AI cannot inspect or modify database structure
- No `php artisan migrate` workflow
- Schema knowledge must come from model `$fillable` arrays, `@property` PHPDoc, and query classes

### Multi-Database Design

Three separate MySQL databases (`quitsure`, `quitsureUsers`, `laravel_logs`). Cross-database architecture and model mappings are documented in `CLAUDE.md` (Database Architecture section).

### Base Controller + Inheritance Pattern (B2C, B2B, OnBoarding)

All three major flows use the same architectural pattern:

**B2C + B2B:** `BaseCustomerController` and `BasePartnerController` use the Template Method pattern with `abstract getPrograms()` and hook method `getSubscribeExtraViewData()`. AI must understand this pattern to correctly extend B2C/B2B behavior — override the abstract, optionally override the hook, never modify the base template methods directly.

**OnBoarding (NEW — v07):** 10 base controllers hold all shared logic, organized into two families:
- **Standard group** (4 base controllers): `BaseBasicController`, `BaseQuittingController`, `BaseMySmokingController`, `BaseFinalSetupController` — used by English, German, Hindi, Japanese, Portuguese
- **Extended group** (6 base controllers): `BaseExtBasicController`, `BaseExtQuittingController`, `BaseCurrentStatusController`, `BaseSmokingBehaviourController`, `BaseThoughtPatternsController`, `BaseExtFinalSetupController` — used by Spanish, French (redesigned 6-step flow)

Language controllers are thin stubs (9-10 lines) that extend the appropriate base. Notable overrides: English `FinalSetupController` (372 lines — subscription intent logic), English `MySmokingController` (71 lines — `getbSubBypass()` helper), Hindi/Portuguese `FinalSetupController` (localized messages).

**B2B-specific note:** The default Razorpay flow in `BasePartnerController` is order-based (used by 5 of 6 languages). English overrides both `razorPayCheckout()` and `razorPaySuccess()` with subscription-based Razorpay (`createCustomer` → `createSubscription`). AI must preserve this distinction when modifying payment flows.

### V2/V3 Version Separation (NEW — v06)

Controllers, views, layouts, and partials are split into `V2/` and `V3/` top-level directories. Each version has its own base controllers with hardcoded viewPrefix — no runtime version detection. When adding features:
- V2 changes go exclusively under `V2/` directories
- V3 changes go exclusively under `V3/` directories
- Routes map to versioned controller namespaces (`App\Http\Controllers\V2\B2C\...` vs `App\Http\Controllers\V3\B2C\...`)
- URLs are unchanged — versioning is internal only

---

## Version History

| Version | Date | Score | Key Changes |
|---|---|---|---|
| v01 | 2026-02-05 | 55 (D+) | Initial assessment |
| v02 | 2026-02-23 | 60 (C-) | Named routes, PHPDoc, database docs, directory READMEs |
| v03 | 2026-02-26 | 68 (C) | 7 interfaces, 10 Form Requests, PHPStan 7, model `@property` PHPDoc, Pint config |
| v04 | 2026-02-26 | 73 (C+) | B2C BaseCustomerController consolidation: 14,216 → 3,054 lines, ~12,000 duplicated lines eliminated |
| v05 | 2026-02-26 | 78 (B-) | B2B BasePartnerController consolidation: 10,776 → ~2,270 lines, ~9,000 duplicated lines eliminated |
| v06 | 2026-02-27 | 78 (B-) | V2/V3 directory restructuring: controllers, views, layouts, partials, tests reorganized into version-first hierarchy. 8 new controller README.md files. |
| v07 | 2026-03-03 | 83 (B) | OnBoarding controller consolidation: 10 base controllers created (4,214 lines), 32 language controllers reduced from ~14,300 to ~970 lines (~93% reduction). ~10,000 duplicated lines eliminated. All three flows (B2C, B2B, OnBoarding) now use Base Controller pattern. |
| v08 | 2026-03-03 | 85 (B) | Type safety: controller return types ~86%→~88%, query class ~52%→~95%, 25 new Form Requests (B2C/B2B). |
| v09 | 2026-03-03 | 85 (B) | Verified audit: corrected metrics (controller returns ~88%, queries ~95%, services ~82%). Fixed: services without interfaces 5→6 (added BajajHealthEventService), files >1K lines 3→5, constructor params BasePartnerController 26→28, READMEs 18→14, controller avg lines ~230→~258. Top 15 table rebuilt with previously missing files. |
| **v10** | **2026-03-04** | **87 (B+)** | **Service interface expansion: 5 new interfaces created (7 → 12 total, 50 typed method signatures). BajajHealthEventInterface, GympassServiceInterface, SubModuleServiceInterface, UserProgramServiceInterface, WebProfilerInterface. Only UtilityService remains without interface (static helper — intentional). Controller return types ~88% → ~90%. Service return types ~82% → ~86%. 4 new test files (61 → 65).** |

---

*Report generated by analyzing all files in the repository. Scores reflect how effectively an AI coding assistant can understand, navigate, modify, and extend this specific codebase.*