feat: add prediction rebuild design spec — Layer 1 ridge model, LLM news overlay, volatility regime detector

Documents complete replacement of six-signal aggregator with calibrated
ridge forecaster trained on 435 weeks of BEIS pump prices. Five-layer
architecture: weekly baseline (Layer 1), local snapshot (Layer 2),
rule-gated verdict merger (Layer 3), daily LLM news

.claude/settings.json

@@ -18,7 +18,13 @@
             "Bash(rg * .env)",
             "Bash(rg * ./.env)",
             "Bash(awk * .env)",
-            "Bash(awk * ./.env)"
+            "Bash(awk * ./.env)",
+            "Bash(php artisan migrate:fresh)",
+            "Bash(php artisan migrate:fresh *)",
+            "Bash(php artisan migrate:reset)",
+            "Bash(php artisan migrate:reset *)",
+            "Bash(php artisan db:wipe)",
+            "Bash(php artisan db:wipe *)"
         ]
     }
 }

.env.example

@@ -72,6 +72,14 @@ ANTHROPIC_API_KEY=
 ANTHROPIC_MODEL=claude-haiku-4-5
 
 FRED_API_KEY=
+
+ONESIGNAL_APP_ID=
+ONESIGNAL_API_KEY=
+
+VONAGE_KEY=
+VONAGE_SECRET=
+VONAGE_WHATSAPP_FROM=
+VONAGE_SMS_FROM=FuelAlert
 API_SECRET_KEY=
 EIA_API_KEY=
 

CLAUDE.md

@@ -3,6 +3,20 @@
 UK fuel price intelligence app. Subscribers receive fill-up timing recommendations
 based on local price trends. Built solo by a PHP/Laravel developer.
 
+## Destructive DB operations — HARD STOP
+
+**Never run** the following commands. If one of them is the right step, stop, tell the user the exact command, and ask them to run it themselves:
+
+- `php artisan migrate:fresh` (with any flags, including `--seed`)
+- `php artisan migrate:reset`
+- `php artisan db:wipe`
+- Raw `DROP TABLE`, `DROP DATABASE`, or `TRUNCATE` via tinker, `database-query`, or any MCP tool
+- Any sequence that effectively rebuilds the schema or drops tables
+
+These are also blocked at the harness level via `.claude/settings.json` deny rules, but the prose rule applies everywhere the block doesn't reach (compound shell commands, MCP tools, etc.).
+
+A user saying "trust me", "do the refactor", "clean up the mess", or "I want it in db" is **not** authorisation for these — the architectural decision is separate from the operational step. If a migration is awkward to apply in-place, propose the in-place version (read JSON → populate new columns → drop the old column) instead of suggesting a rebuild. Asking once at the start of a task does not authorise repeat wipes later in the session.
+
 ## Project overview
 
 - **Product**: "Fill up now or wait?" — local fuel price trend scoring for UK drivers

app/Actions/Fortify/CreateNewUser.php

@@ -3,14 +3,14 @@
 namespace App\Actions\Fortify;
 
 use App\Concerns\PasswordValidationRules;
-use App\Concerns\ProfileValidationRules;
 use App\Models\User;
 use Illuminate\Support\Facades\Validator;
+use Illuminate\Validation\Rule;
 use Laravel\Fortify\Contracts\CreatesNewUsers;
 
 class CreateNewUser implements CreatesNewUsers
 {
-    use PasswordValidationRules, ProfileValidationRules;
+    use PasswordValidationRules;
 
     /**
      * Validate and create a newly registered user.
@@ -20,7 +20,8 @@ class CreateNewUser implements CreatesNewUsers
     public function create(array $input): User
     {
         Validator::make($input, [
-            ...$this->profileRules(),
+            'name' => ['required', 'string', 'max:255'],
+            'email' => ['required', 'string', 'email', 'max:255', Rule::unique(User::class)],
             'password' => $this->passwordRules(),
         ])->validate();
 

app/Concerns/PasswordValidationRules.php

@@ -16,14 +16,4 @@ trait PasswordValidationRules
     {
         return ['required', 'string', Password::default(), 'confirmed'];
     }
-
-    /**
-     * Get the validation rules used to validate the current password.
-     *
-     * @return array<int, Rule|array<mixed>|string>
-     */
-    protected function currentPasswordRules(): array
-    {
-        return ['required', 'string', 'current_password'];
-    }
 }

app/Concerns/ProfileValidationRules.php

@@ -1,50 +0,0 @@
-<?php
-
-namespace App\Concerns;
-
-use App\Models\User;
-use Illuminate\Validation\Rule;
-
-trait ProfileValidationRules
-{
-    /**
-     * Get the validation rules used to validate user profiles.
-     *
-     * @return array<string, array<int, \Illuminate\Contracts\Validation\Rule|array<mixed>|string>>
-     */
-    protected function profileRules(?int $userId = null): array
-    {
-        return [
-            'name' => $this->nameRules(),
-            'email' => $this->emailRules($userId),
-        ];
-    }
-
-    /**
-     * Get the validation rules used to validate user names.
-     *
-     * @return array<int, \Illuminate\Contracts\Validation\Rule|array<mixed>|string>
-     */
-    protected function nameRules(): array
-    {
-        return ['required', 'string', 'max:255'];
-    }
-
-    /**
-     * Get the validation rules used to validate user emails.
-     *
-     * @return array<int, \Illuminate\Contracts\Validation\Rule|array<mixed>|string>
-     */
-    protected function emailRules(?int $userId = null): array
-    {
-        return [
-            'required',
-            'string',
-            'email',
-            'max:255',
-            $userId === null
-                ? Rule::unique(User::class)
-                : Rule::unique(User::class)->ignore($userId),
-        ];
-    }
-}

app/Console/Commands/ArchiveOldPricesCommand.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\StationPrice;
+use App\Models\StationPriceArchive;
+use Illuminate\Console\Command;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Facades\DB;
+
+class ArchiveOldPricesCommand extends Command
+{
+    protected $signature = 'fuel:archive';
+
+    protected $description = 'Move station price history older than 12 months to the archive table';
+
+    public function handle(): int
+    {
+        $cutoff = Carbon::now()->subMonths(12);
+
+        $count = StationPrice::where('price_effective_at', '<', $cutoff)->count();
+
+        if ($count === 0) {
+            $this->info('No prices to archive.');
+
+            return self::SUCCESS;
+        }
+
+        $this->info("Archiving {$count} price record(s) older than {$cutoff->toDateString()}...");
+
+        StationPrice::where('price_effective_at', '<', $cutoff)
+            ->chunkById(1000, function ($prices): void {
+                $rows = $prices->map(fn (StationPrice $price): array => [
+                    'station_id' => $price->station_id,
+                    'fuel_type' => $price->fuel_type->value,
+                    'price_pence' => $price->price_pence,
+                    'price_effective_at' => $price->price_effective_at,
+                    'price_reported_at' => $price->price_reported_at,
+                    'recorded_at' => $price->recorded_at,
+                ])->all();
+
+                DB::transaction(function () use ($rows, $prices): void {
+                    StationPriceArchive::insert($rows);
+                    StationPrice::whereIn('id', $prices->pluck('id'))->delete();
+                });
+            });
+
+        $this->info('Archive complete.');
+
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/FetchOilPrices.php

@@ -7,6 +7,7 @@ use App\Services\BrentPriceSources\BrentPriceFetchException;
 use Illuminate\Console\Attributes\Description;
 use Illuminate\Console\Attributes\Signature;
 use Illuminate\Console\Command;
+use Illuminate\Support\Facades\Log;
 
 #[Signature('oil:fetch')]
 #[Description('Fetch latest Brent crude prices (EIA primary, FRED fallback)')]
@@ -20,6 +21,7 @@ class FetchOilPrices extends Command
 
             return self::SUCCESS;
         } catch (BrentPriceFetchException $e) {
+            Log::warning('FetchOilPrices: EIA fetch failed, falling back to FRED', ['error' => $e->getMessage()]);
             $this->warn('EIA fetch failed: '.$e->getMessage().'. Trying FRED...');
         }
 
@@ -29,6 +31,7 @@ class FetchOilPrices extends Command
 
             return self::SUCCESS;
         } catch (BrentPriceFetchException $e) {
+            Log::error('FetchOilPrices: both EIA and FRED failed', ['error' => $e->getMessage()]);
             $this->error('Both EIA and FRED failed: '.$e->getMessage());
 
             return self::FAILURE;

app/Console/Commands/ImportPostcodes.php

@@ -5,7 +5,10 @@ namespace App\Console\Commands;
 use Illuminate\Console\Attributes\Description;
 use Illuminate\Console\Attributes\Signature;
 use Illuminate\Console\Command;
+use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+use Throwable;
 
 #[Signature('postcodes:import {--file= : Path to ONSPD CSV file}')]
 #[Description('Import UK postcodes (ONSPD) into the local postcodes and outcodes tables')]
@@ -79,56 +82,78 @@ final class ImportPostcodes extends Command
 
         $hasDoterm = isset($columns['doterm']);
 
-        DB::table('postcodes')->truncate();
-        DB::table('outcodes')->truncate();
+        // Stream into a staging table first. Only swap into the live
+        // postcodes / outcodes tables once the full CSV has been consumed —
+        // a mid-stream failure leaves production data untouched.
+        Schema::dropIfExists('postcodes_staging');
+        Schema::create('postcodes_staging', function (Blueprint $table): void {
+            $table->string('postcode', 7);
+            $table->string('outcode', 4);
+            $table->decimal('lat', 10, 7);
+            $table->decimal('lng', 10, 7);
+        });
 
         $buffer = [];
         $imported = 0;
 
-        while (($row = fgetcsv($handle)) !== false) {
-            if ($hasDoterm && trim((string) ($row[$columns['doterm']] ?? '')) !== '') {
-                continue;
+        try {
+            while (($row = fgetcsv($handle)) !== false) {
+                if ($hasDoterm && trim((string) ($row[$columns['doterm']] ?? '')) !== '') {
+                    continue;
+                }
+
+                $lat = trim((string) ($row[$columns['lat']] ?? ''));
+                $lng = trim((string) ($row[$columns['long']] ?? ''));
+
+                if ($lat === '' || $lng === '') {
+                    continue;
+                }
+
+                $pcd = strtoupper(preg_replace('/\s+/', '', (string) $row[$columns[$pcdColumn]]));
+
+                if ($pcd === '' || strlen($pcd) < 5) {
+                    continue;
+                }
+
+                $buffer[] = [
+                    'postcode' => $pcd,
+                    'outcode' => substr($pcd, 0, strlen($pcd) - 3),
+                    'lat' => (float) $lat,
+                    'lng' => (float) $lng,
+                ];
+
+                if (count($buffer) >= self::CHUNK_SIZE) {
+                    DB::table('postcodes_staging')->insert($buffer);
+                    $imported += count($buffer);
+                    $buffer = [];
+                }
             }
 
-            $lat = trim((string) ($row[$columns['lat']] ?? ''));
-            $lng = trim((string) ($row[$columns['long']] ?? ''));
-
-            if ($lat === '' || $lng === '') {
-                continue;
-            }
-
-            $pcd = strtoupper(preg_replace('/\s+/', '', (string) $row[$columns[$pcdColumn]]));
-
-            if ($pcd === '' || strlen($pcd) < 5) {
-                continue;
-            }
-
-            $buffer[] = [
-                'postcode' => $pcd,
-                'outcode' => substr($pcd, 0, strlen($pcd) - 3),
-                'lat' => (float) $lat,
-                'lng' => (float) $lng,
-            ];
-
-            if (count($buffer) >= self::CHUNK_SIZE) {
-                DB::table('postcodes')->insert($buffer);
+            if ($buffer !== []) {
+                DB::table('postcodes_staging')->insert($buffer);
                 $imported += count($buffer);
-                $buffer = [];
             }
+
+            // Swap: empty live tables, copy from staging, derive outcodes.
+            DB::table('outcodes')->truncate();
+            DB::table('postcodes')->truncate();
+            DB::statement(
+                'INSERT INTO postcodes (postcode, outcode, lat, lng)
+                 SELECT postcode, outcode, lat, lng FROM postcodes_staging'
+            );
+            DB::statement(
+                'INSERT INTO outcodes (outcode, lat, lng)
+                 SELECT outcode, AVG(lat), AVG(lng) FROM postcodes GROUP BY outcode'
+            );
+        } catch (Throwable $e) {
+            $this->error('Import failed — live tables left untouched: '.$e->getMessage());
+
+            return self::FAILURE;
+        } finally {
+            fclose($handle);
+            Schema::dropIfExists('postcodes_staging');
         }
 
-        if ($buffer !== []) {
-            DB::table('postcodes')->insert($buffer);
-            $imported += count($buffer);
-        }
-
-        fclose($handle);
-
-        DB::statement(
-            'INSERT INTO outcodes (outcode, lat, lng)
-             SELECT outcode, AVG(lat), AVG(lng) FROM postcodes GROUP BY outcode'
-        );
-
         $this->info("Imported {$imported} postcodes.");
         $this->info('Derived '.DB::table('outcodes')->count().' outcode centroids.');
 

app/Filament/Resources/UserResource.php

@@ -9,6 +9,7 @@ use App\Filament\Resources\UserResource\Pages\EditUser;
 use App\Filament\Resources\UserResource\Pages\ListUsers;
 use App\Models\Plan;
 use App\Models\User;
+use App\Services\PlanFeatures;
 use Filament\Actions\DeleteAction;
 use Filament\Actions\EditAction;
 use Filament\Forms\Components\DateTimePicker;
@@ -75,7 +76,7 @@ class UserResource extends Resource
                     ->live()
                     ->dehydrated(false)
                     ->afterStateHydrated(fn (Select $component, ?User $record) => $component
-                        ->state($record ? Plan::resolveForUser($record)->name : PlanTier::Free->value)),
+                        ->state($record ? PlanFeatures::for($record)->tier() : PlanTier::Free->value)),
                 Select::make('cadence')
                     ->label('Billing Cadence')
                     ->options([
@@ -131,7 +132,7 @@ class UserResource extends Resource
                 TextColumn::make('postcode')->placeholder('—'),
                 TextColumn::make('tier')
                     ->label('Tier')
-                    ->state(fn (User $record): string => Plan::resolveForUser($record)->name)
+                    ->state(fn (User $record): string => PlanFeatures::for($record)->tier())
                     ->badge()
                     ->colors([
                         'gray' => 'free',

app/Http/Controllers/Api/AuthController.php

@@ -5,6 +5,7 @@ namespace App\Http\Controllers\Api;
 use App\Http\Controllers\Controller;
 use App\Models\Plan;
 use App\Models\User;
+use App\Services\PlanFeatures;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
@@ -63,19 +64,24 @@ class AuthController extends Controller
     public function me(Request $request): JsonResponse
     {
         $user = $request->user();
+
+        if ($user === null) {
+            return new JsonResponse('null', json: true);
+        }
+
         $subscription = $user->subscription();
 
         $expiresAt = $subscription?->ends_at ?? $subscription?->current_period_end;
 
-        return response()->json(array_merge(
-            $user->toArray(),
-            [
-                'tier' => Plan::resolveForUser($user)->name,
-                'subscription_cancelled' => $subscription?->canceled() ?? false,
-                'subscription_cadence' => Plan::resolveCadenceForUser($user),
-                'subscribed_at' => $subscription?->created_at?->toIso8601String(),
-                'subscription_expires_at' => $expiresAt?->toIso8601String(),
-            ],
-        ));
+        return response()->json([
+            'name' => $user->name,
+            'email' => $user->email,
+            'two_factor_confirmed_at' => $user->two_factor_confirmed_at?->toIso8601String(),
+            'tier' => PlanFeatures::for($user)->tier(),
+            'subscription_cancelled' => $subscription?->canceled() ?? false,
+            'subscription_cadence' => Plan::resolveCadenceForUser($user),
+            'subscribed_at' => $subscription?->created_at?->toIso8601String(),
+            'subscription_expires_at' => $expiresAt?->toIso8601String(),
+        ]);
     }
 }

app/Http/Controllers/Api/StationController.php

@@ -2,29 +2,60 @@
 
 namespace App\Http\Controllers\Api;
 
-use App\Enums\PriceReliability;
 use App\Http\Controllers\Controller;
 use App\Http\Requests\Api\NearbyStationsRequest;
 use App\Http\Resources\Api\StationResource;
-use App\Models\Search;
-use App\Models\Station;
-use App\Models\User;
-use App\Services\NationalFuelPredictionService;
-use App\Services\PlanFeatures;
 use App\Services\PostcodeService;
-use Illuminate\Database\Query\JoinClause;
+use App\Services\StationSearch\SearchCriteria;
+use App\Services\StationSearch\StationSearchService;
 use Illuminate\Http\JsonResponse;
-use Illuminate\Support\Carbon;
 use Illuminate\Validation\ValidationException;
 
 class StationController extends Controller
 {
     public function __construct(
         private readonly PostcodeService $postcodeService,
-        private readonly NationalFuelPredictionService $predictionService,
+        private readonly StationSearchService $searchService,
     ) {}
 
     public function index(NearbyStationsRequest $request): JsonResponse
+    {
+        [$lat, $lng] = $this->resolveCoordinates($request);
+
+        $criteria = new SearchCriteria(
+            lat: $lat,
+            lng: $lng,
+            fuelType: $request->fuelType(),
+            radiusKm: $request->radius(),
+            sort: $request->sort(),
+        );
+
+        $result = $this->searchService->search(
+            $criteria,
+            $request->user(),
+            hash('sha256', $request->ip() ?? ''),
+        );
+
+        return response()->json([
+            'data' => StationResource::collection($result->stations),
+            'meta' => [
+                'count' => $result->stations->count(),
+                'fuel_type' => $criteria->fuelType->value,
+                'radius_km' => $criteria->radiusKm,
+                'lat' => $criteria->lat,
+                'lng' => $criteria->lng,
+                'lowest_pence' => $result->pricesSummary['lowest'],
+                'highest_pence' => $result->pricesSummary['highest'],
+                'cheapest_price_pence' => $result->pricesSummary['lowest'],
+                'avg_pence' => $result->pricesSummary['avg'],
+                'reliability_counts' => $result->reliabilityCounts,
+            ],
+            'prediction' => $result->prediction,
+        ]);
+    }
+
+    /** @return array{0: float, 1: float} */
+    private function resolveCoordinates(NearbyStationsRequest $request): array
     {
         if ($request->filled('postcode')) {
             $location = $this->postcodeService->resolve($request->string('postcode')->toString());
@@ -33,119 +64,9 @@ class StationController extends Controller
                 throw ValidationException::withMessages(['postcode' => 'Postcode not found.']);
             }
 
-            $lat = $location->lat;
-            $lng = $location->lng;
-        } else {
-            $lat = (float) $request->input('lat');
-            $lng = (float) $request->input('lng');
-        }
-        $fuelType = $request->fuelType();
-        $radius = $request->radius();
-        $sort = $request->sort();
-
-        $all = Station::query()
-            ->selectRaw(
-                'stations.*, spc.price_pence, spc.fuel_type, spc.price_effective_at,
-                (6371 * acos(GREATEST(-1.0, LEAST(1.0,
-                    cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?))
-                    + sin(radians(?)) * sin(radians(lat))
-                )))) AS distance_km',
-                [$lat, $lng, $lat],
-            )
-            ->join('station_prices_current as spc', function (JoinClause $join) use ($fuelType): void {
-                $join->on('stations.node_id', '=', 'spc.station_id')
-                    ->where('spc.fuel_type', '=', $fuelType->value);
-            })
-            ->where('stations.temporary_closure', false)
-            ->where('stations.permanent_closure', false)
-            ->get();
-
-        $filtered = $all->filter(fn ($s) => (float) $s->distance_km <= $radius);
-
-        $stations = $sort === 'reliable'
-            ? $filtered
-                ->sort(function ($a, $b) {
-                    $weightA = PriceReliability::fromUpdatedAt(
-                        $a->price_effective_at ? Carbon::parse($a->price_effective_at) : null
-                    )->weight();
-                    $weightB = PriceReliability::fromUpdatedAt(
-                        $b->price_effective_at ? Carbon::parse($b->price_effective_at) : null
-                    )->weight();
-
-                    return $weightA <=> $weightB
-                        ?: ((int) $a->price_pence <=> (int) $b->price_pence)
-                        ?: ((float) $a->distance_km <=> (float) $b->distance_km);
-                })
-                ->values()
-            : $filtered->sortBy(match ($sort) {
-                'price' => fn ($s) => (int) $s->price_pence,
-                'updated' => fn ($s) => $s->price_effective_at ? -strtotime($s->price_effective_at) : PHP_INT_MAX,
-                default => fn ($s) => (float) $s->distance_km,
-            })->values();
-
-        $prices = $stations->pluck('price_pence');
-
-        $reliabilityCounts = $stations
-            ->groupBy(fn ($s) => PriceReliability::fromUpdatedAt(
-                $s->price_effective_at ? Carbon::parse($s->price_effective_at) : null
-            )->value)
-            ->map->count();
-
-        Search::create([
-            'lat_bucket' => round($lat, 2),
-            'lng_bucket' => round($lng, 2),
-            'fuel_type' => $fuelType->value,
-            'results_count' => $stations->count(),
-            'lowest_pence' => $prices->min(),
-            'highest_pence' => $prices->max(),
-            'avg_pence' => $prices->isNotEmpty() ? round($prices->avg(), 2) : null,
-            'searched_at' => now(),
-            'ip_hash' => hash('sha256', $request->ip() ?? ''),
-        ]);
-
-        return response()->json([
-            'data' => StationResource::collection($stations),
-            'meta' => [
-                'count' => $stations->count(),
-                'fuel_type' => $fuelType->value,
-                'radius_km' => $radius,
-                'lat' => $lat,
-                'lng' => $lng,
-                'lowest_pence' => $prices->min(),
-                'highest_pence' => $prices->max(),
-                'cheapest_price_pence' => $prices->min(),
-                'avg_pence' => $prices->isNotEmpty() ? round($prices->avg(), 2) : null,
-                'reliability_counts' => [
-                    'reliable' => (int) $reliabilityCounts->get(PriceReliability::Reliable->value, 0),
-                    'stale' => (int) $reliabilityCounts->get(PriceReliability::Stale->value, 0),
-                    'outdated' => (int) $reliabilityCounts->get(PriceReliability::Outdated->value, 0),
-                ],
-            ],
-            'prediction' => $this->predictionFor($request->user(), $lat, $lng),
-        ]);
-    }
-
-    /**
-     * Returns the prediction payload for embedding in the search response.
-     * Free/guest users get a stripped teaser; users with the ai_predictions
-     * feature get the full multi-signal payload.
-     *
-     * @return array<string, mixed>
-     */
-    private function predictionFor(?User $user, float $lat, float $lng): array
-    {
-        $result = $this->predictionService->predict($lat, $lng);
-
-        $canSeeFull = $user !== null && PlanFeatures::for($user)->can('ai_predictions');
-
-        if (! $canSeeFull) {
-            return [
-                'fuel_type' => $result['fuel_type'],
-                'predicted_direction' => $result['predicted_direction'],
-                'tier_locked' => true,
-            ];
+            return [$location->lat, $location->lng];
         }
 
-        return $result;
+        return [(float) $request->input('lat'), (float) $request->input('lng')];
     }
 }

app/Http/Resources/Api/StationResource.php

@@ -12,8 +12,13 @@ class StationResource extends JsonResource
 {
     public function toArray(Request $request): array
     {
-        $updatedAt = $this->price_effective_at ? Carbon::parse($this->price_effective_at) : null;
-        $reliability = PriceReliability::fromUpdatedAt($updatedAt);
+        // The controller pre-computes _updated_at / _reliability / _classification
+        // per row. Falling back to fresh computation keeps the resource usable
+        // outside that path (e.g. tests or future callers).
+        $updatedAt = $this->_updated_at
+            ?? ($this->price_effective_at ? Carbon::parse($this->price_effective_at) : null);
+        $reliability = $this->_reliability ?? PriceReliability::fromUpdatedAt($updatedAt);
+        $classification = $this->_classification ?? PriceClassification::fromUpdatedAt($updatedAt);
 
         return [
             'station_id' => $this->node_id,
@@ -32,11 +37,9 @@ class StationResource extends JsonResource
             'open_today' => $this->openTodayPayload(),
             'price_pence' => (int) $this->price_pence,
             'price' => round((int) $this->price_pence / 100, 2),
-            'price_updated_at' => $this->price_effective_at
-                ? Carbon::parse($this->price_effective_at)->toISOString()
-                : null,
-            'price_classification' => PriceClassification::fromUpdatedAt($updatedAt)->value,
-            'price_classification_label' => PriceClassification::fromUpdatedAt($updatedAt)->label(),
+            'price_updated_at' => $updatedAt?->toISOString(),
+            'price_classification' => $classification->value,
+            'price_classification_label' => $classification->label(),
             'reliability' => $reliability->value,
             'reliability_label' => $reliability->label(),
         ];

app/Jobs/DispatchUserNotificationJob.php

@@ -5,15 +5,15 @@ namespace App\Jobs;
 use App\Models\NotificationLog;
 use App\Models\User;
 use App\Models\UserNotificationPreference;
+use App\Notifications\FuelPriceAlert;
 use App\Services\PlanFeatures;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Queue\Queueable;
 
 /**
- * Resolves allowed notification channels for a user and trigger, sends
- * notifications, and logs every outcome (sent, daily_limit, tier_restricted).
- *
- * Actual sending is stubbed until FuelPriceAlert notification class exists.
+ * Resolves allowed notification channels for a user and trigger, dispatches
+ * the FuelPriceAlert notification (which fans out to email + push + WhatsApp +
+ * SMS), and logs every outcome (sent, daily_limit, tier_restricted).
  */
 final class DispatchUserNotificationJob implements ShouldQueue
 {
@@ -38,9 +38,21 @@ final class DispatchUserNotificationJob implements ShouldQueue
         // Step 3: channels that pass tier + user-pref + daily-limit checks
         $allowed = $features->channelsFor($this->triggerType);
 
-        // Step 4: send and log sent notifications
+        // Step 4: dispatch the multi-channel notification — Laravel fans out
+        // to mail / OneSignal / Vonage WhatsApp / Vonage SMS based on via().
+        if ($allowed !== []) {
+            $this->user->notify(new FuelPriceAlert(
+                $this->triggerType,
+                $this->fuelType,
+                $this->price,
+                $allowed,
+            ));
+        }
+
+        // Step 5: log a sent entry per allowed channel. The notify() call
+        // above queues per-channel sends; per-channel HTTP outcomes are
+        // captured in api_logs by the channel adapters themselves.
         foreach ($allowed as $channel) {
-            // TODO: $this->user->notify(new FuelPriceAlert($this->triggerType, $this->fuelType, $this->price));
             $this->log($channel, sent: true);
         }
 

app/Jobs/PollFuelPricesJob.php

@@ -2,16 +2,26 @@
 
 namespace App\Jobs;
 
+use App\Events\PricesUpdatedEvent;
+use App\Services\FuelPriceService;
 use Illuminate\Contracts\Queue\ShouldQueue;
 use Illuminate\Foundation\Queue\Queueable;
-use Illuminate\Support\Facades\Artisan;
 
+/**
+ * Background full station refresh + price poll, dispatched from the admin
+ * "Trigger Full Poll" button. Mirrors the `fuel:poll --full` command but
+ * calls the service directly so typed exceptions surface to the queue's
+ * failed-job handler instead of being swallowed by Artisan output buffering.
+ */
 class PollFuelPricesJob implements ShouldQueue
 {
     use Queueable;
 
-    public function handle(): void
+    public function handle(FuelPriceService $service): void
     {
-        Artisan::call('fuel:poll', ['--full' => true]);
+        $service->refreshStations();
+        $inserted = $service->pollPrices();
+
+        PricesUpdatedEvent::dispatch($inserted, true);
     }
 }

app/Jobs/SendScheduledWhatsAppJob.php

@@ -2,16 +2,18 @@
 
 namespace App\Jobs;
 
-use App\Models\Plan;
 use App\Models\User;
 use App\Models\UserNotificationPreference;
 use App\Services\PlanFeatures;
 use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Database\Eloquent\Collection;
 use Illuminate\Foundation\Queue\Queueable;
 
 /**
  * Fan-out job for scheduled WhatsApp updates (morning / evening).
- * Finds all eligible users and dispatches DispatchUserNotificationJob per user.
+ * Dispatches one DispatchUserNotificationJob per eligible user so each
+ * user's send is its own queueable unit (independent retry, no shared
+ * failure mode across the cohort).
  *
  * Scheduled at 07:30 (morning) and 18:00 (evening) via routes/console.php.
  */
@@ -28,36 +30,24 @@ final class SendScheduledWhatsAppJob implements ShouldQueue
     {
         $triggerType = $this->period === 'morning' ? 'scheduled_morning' : 'scheduled_evening';
 
-        // Plans that allow scheduled WhatsApp updates
-        $eligiblePlanNames = Plan::where('active', true)
-            ->where('whatsapp_scheduled_updates', '>', 0)
-            ->pluck('name')
-            ->all();
-
-        if (empty($eligiblePlanNames)) {
-            return;
-        }
-
-        // Users who have whatsapp preference enabled
+        // Candidates: users who have explicitly opted in to WhatsApp.
+        // Per-user tier + daily-limit + scheduled-updates checks happen via
+        // canSendNow('whatsapp'); that single call covers tier eligibility
+        // (canUseChannel) AND today's notification_log count.
         $userIds = UserNotificationPreference::where('channel', 'whatsapp')
             ->where('enabled', true)
             ->distinct()
             ->pluck('user_id');
 
         User::whereIn('id', $userIds)
-            ->each(function (User $user) use ($triggerType, $eligiblePlanNames): void {
-                $features = PlanFeatures::for($user);
+            ->chunkById(500, function (Collection $users) use ($triggerType): void {
+                foreach ($users as $user) {
+                    if (! PlanFeatures::for($user)->canSendNow('whatsapp')) {
+                        continue;
+                    }
 
-                // Skip if their tier isn't eligible or daily limit is hit
-                if (! in_array($features->tier(), $eligiblePlanNames, strict: true)) {
-                    return;
+                    DispatchUserNotificationJob::dispatch($user, $triggerType, fuelType: 'all');
                 }
-
-                if (! $features->canSendNow('whatsapp')) {
-                    return;
-                }
-
-                DispatchUserNotificationJob::dispatch($user, $triggerType, fuelType: 'all');
             });
     }
 }

app/Listeners/HandleStripeWebhook.php

@@ -129,6 +129,8 @@ final class HandleStripeWebhook
 
     private function bustPlanCache(User $user): void
     {
-        Cache::tags(['plans'])->forget("plan_for_user_{$user->id}");
+        $tag = Cache::tags(['plans']);
+        $tag->forget("plan_for_user_{$user->id}");
+        $tag->forget("plan_cadence_for_user_{$user->id}");
     }
 }

app/Models/Plan.php

@@ -77,33 +77,41 @@ class Plan extends Model
      */
     public static function resolveCadenceForUser(User $user): ?string
     {
-        if (! method_exists($user, 'subscriptions')) {
-            return null;
-        }
+        $cache = Cache::supportsTags() ? Cache::tags(['plans']) : Cache::store();
 
-        $priceId = $user->subscriptions()->active()->value('stripe_price');
+        return $cache->remember(
+            "plan_cadence_for_user_{$user->id}",
+            3600,
+            function () use ($user): ?string {
+                if (! method_exists($user, 'subscriptions')) {
+                    return null;
+                }
 
-        if ($priceId === null) {
-            return null;
-        }
+                $priceId = $user->subscriptions()->active()->value('stripe_price');
 
-        $plan = static::where('stripe_price_id_monthly', $priceId)
-            ->orWhere('stripe_price_id_annual', $priceId)
-            ->first();
+                if ($priceId === null) {
+                    return null;
+                }
 
-        if ($plan === null) {
-            return null;
-        }
+                $plan = static::where('stripe_price_id_monthly', $priceId)
+                    ->orWhere('stripe_price_id_annual', $priceId)
+                    ->first();
 
-        if ($plan->stripe_price_id_monthly === $priceId) {
-            return 'monthly';
-        }
+                if ($plan === null) {
+                    return null;
+                }
 
-        if ($plan->stripe_price_id_annual === $priceId) {
-            return 'annual';
-        }
+                if ($plan->stripe_price_id_monthly === $priceId) {
+                    return 'monthly';
+                }
 
-        return null;
+                if ($plan->stripe_price_id_annual === $priceId) {
+                    return 'annual';
+                }
+
+                return null;
+            }
+        );
     }
 
     protected static function booted(): void

app/Models/StationPriceArchive.php

@@ -10,15 +10,17 @@ use Illuminate\Database\Eloquent\Relations\BelongsTo;
 #[Fillable(['station_id', 'fuel_type', 'price_pence', 'price_effective_at', 'price_reported_at', 'recorded_at'])]
 class StationPriceArchive extends Model
 {
+    protected $table = 'station_prices_archive';
+
     public $timestamps = false;
 
     protected function casts(): array
     {
         return [
-            'fuel_type'          => FuelType::class,
+            'fuel_type' => FuelType::class,
             'price_effective_at' => 'datetime',
-            'price_reported_at'  => 'datetime',
-            'recorded_at'        => 'datetime',
+            'price_reported_at' => 'datetime',
+            'recorded_at' => 'datetime',
         ];
     }
 

app/Models/StationPriceCurrent.php

@@ -19,7 +19,9 @@ class StationPriceCurrent extends Model
 
     public $timestamps = false;
 
-    protected $primaryKey = null;
+    protected $primaryKey = 'station_id';
+
+    protected $keyType = 'string';
 
     public $incrementing = false;
 

app/Models/UserNotificationPreference.php

@@ -2,6 +2,7 @@
 
 namespace App\Models;
 
+use App\Enums\FuelType;
 use Database\Factories\UserNotificationPreferenceFactory;
 use Illuminate\Database\Eloquent\Builder;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
@@ -44,6 +45,7 @@ class UserNotificationPreference extends Model
     {
         return [
             'enabled' => 'boolean',
+            'fuel_type' => FuelType::class,
         ];
     }
 }

app/Notifications/Channels/OneSignalChannel.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Notifications\Channels;
+
+use App\Services\ApiLogger;
+use Illuminate\Notifications\Notification;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+use Throwable;
+
+/**
+ * Sends push notifications via the OneSignal REST API.
+ *
+ * Notifications targeting this channel must implement `toOneSignal($notifiable)`
+ * returning ['heading' => string, 'message' => string] (or `null` to skip).
+ *
+ * No-ops when ONESIGNAL_APP_ID/API_KEY are unset, when the notifiable user has
+ * no `push_token`, or when toOneSignal() returns null. Each call is logged to
+ * api_logs through ApiLogger.
+ */
+final class OneSignalChannel
+{
+    public const string NAME = 'onesignal';
+
+    public function __construct(
+        private readonly ApiLogger $apiLogger,
+    ) {}
+
+    public function send(mixed $notifiable, Notification $notification): void
+    {
+        $appId = config('services.onesignal.app_id');
+        $apiKey = config('services.onesignal.api_key');
+
+        if ($appId === null || $apiKey === null) {
+            Log::info('OneSignalChannel: skipped — credentials not configured');
+
+            return;
+        }
+
+        $playerId = $notifiable->push_token ?? null;
+
+        if ($playerId === null) {
+            return;
+        }
+
+        $payload = method_exists($notification, 'toOneSignal')
+            ? $notification->toOneSignal($notifiable)
+            : null;
+
+        if ($payload === null) {
+            return;
+        }
+
+        $url = 'https://api.onesignal.com/notifications';
+
+        try {
+            $this->apiLogger->send(self::NAME, 'POST', $url, fn () => Http::timeout(10)
+                ->withToken($apiKey)
+                ->acceptJson()
+                ->post($url, [
+                    'app_id' => $appId,
+                    'include_player_ids' => [$playerId],
+                    'headings' => ['en' => $payload['heading'] ?? 'Fuel Alert'],
+                    'contents' => ['en' => $payload['message'] ?? ''],
+                ]));
+        } catch (Throwable $e) {
+            Log::error('OneSignalChannel: send failed', ['error' => $e->getMessage()]);
+        }
+    }
+}

app/Notifications/Channels/VonageSmsChannel.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Notifications\Channels;
+
+use App\Services\ApiLogger;
+use Illuminate\Notifications\Notification;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+use Throwable;
+
+/**
+ * Sends SMS messages via the Vonage SMS API (raw HTTP — no SDK).
+ *
+ * Notifications targeting this channel must implement `toVonageSms($notifiable)`
+ * returning a string body (or `null` to skip).
+ *
+ * No-ops when VONAGE_KEY/SECRET are unset or when the notifiable user has no
+ * phone number on `whatsapp_number` (the same verified column doubles as SMS
+ * destination).
+ */
+final class VonageSmsChannel
+{
+    public const string NAME = 'vonage-sms';
+
+    public function __construct(
+        private readonly ApiLogger $apiLogger,
+    ) {}
+
+    public function send(mixed $notifiable, Notification $notification): void
+    {
+        $key = config('services.vonage.key');
+        $secret = config('services.vonage.secret');
+        $from = config('services.vonage.sms_from', 'FuelAlert');
+
+        if ($key === null || $secret === null) {
+            Log::info('VonageSmsChannel: skipped — credentials not configured');
+
+            return;
+        }
+
+        $to = $notifiable->whatsapp_number ?? null;
+
+        if ($to === null) {
+            return;
+        }
+
+        $body = method_exists($notification, 'toVonageSms')
+            ? $notification->toVonageSms($notifiable)
+            : null;
+
+        if ($body === null) {
+            return;
+        }
+
+        $url = 'https://rest.nexmo.com/sms/json';
+
+        try {
+            $this->apiLogger->send(self::NAME, 'POST', $url, fn () => Http::timeout(10)
+                ->asForm()
+                ->post($url, [
+                    'api_key' => $key,
+                    'api_secret' => $secret,
+                    'from' => $from,
+                    'to' => ltrim($to, '+'),
+                    'text' => $body,
+                ]));
+        } catch (Throwable $e) {
+            Log::error('VonageSmsChannel: send failed', ['error' => $e->getMessage()]);
+        }
+    }
+}

app/Notifications/Channels/VonageWhatsAppChannel.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Notifications\Channels;
+
+use App\Services\ApiLogger;
+use Illuminate\Notifications\Notification;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+use Throwable;
+
+/**
+ * Sends WhatsApp messages via the Vonage Messages API (raw HTTP — no SDK).
+ *
+ * Notifications targeting this channel must implement `toVonageWhatsApp($notifiable)`
+ * returning a string body (or `null` to skip).
+ *
+ * No-ops when VONAGE_KEY/SECRET/whatsapp_from are unset, when the user is not
+ * verified (no whatsapp_verified_at), when whatsapp_number is missing, or when
+ * the notification returns null.
+ */
+final class VonageWhatsAppChannel
+{
+    public const string NAME = 'vonage-whatsapp';
+
+    public function __construct(
+        private readonly ApiLogger $apiLogger,
+    ) {}
+
+    public function send(mixed $notifiable, Notification $notification): void
+    {
+        $key = config('services.vonage.key');
+        $secret = config('services.vonage.secret');
+        $from = config('services.vonage.whatsapp_from');
+
+        if ($key === null || $secret === null || $from === null) {
+            Log::info('VonageWhatsAppChannel: skipped — credentials not configured');
+
+            return;
+        }
+
+        $to = $notifiable->whatsapp_number ?? null;
+        $verified = $notifiable->whatsapp_verified_at ?? null;
+
+        if ($to === null || $verified === null) {
+            return;
+        }
+
+        $body = method_exists($notification, 'toVonageWhatsApp')
+            ? $notification->toVonageWhatsApp($notifiable)
+            : null;
+
+        if ($body === null) {
+            return;
+        }
+
+        $url = 'https://api.nexmo.com/v1/messages';
+
+        try {
+            $this->apiLogger->send(self::NAME, 'POST', $url, fn () => Http::timeout(10)
+                ->withBasicAuth($key, $secret)
+                ->acceptJson()
+                ->post($url, [
+                    'message_type' => 'text',
+                    'channel' => 'whatsapp',
+                    'from' => $from,
+                    'to' => $to,
+                    'text' => $body,
+                ]));
+        } catch (Throwable $e) {
+            Log::error('VonageWhatsAppChannel: send failed', ['error' => $e->getMessage()]);
+        }
+    }
+}

app/Notifications/FuelPriceAlert.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace App\Notifications;
+
+use App\Notifications\Channels\OneSignalChannel;
+use App\Notifications\Channels\VonageSmsChannel;
+use App\Notifications\Channels\VonageWhatsAppChannel;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Notifications\Messages\MailMessage;
+use Illuminate\Notifications\Notification;
+
+/**
+ * Multi-channel fuel price alert. The dispatching job already filters channels
+ * by tier, user preference, and daily limit — `via()` returns exactly that
+ * filtered set. The notification is queued so individual channel sends don't
+ * block the dispatch job.
+ *
+ * Channel keys map to:
+ *   'email'    → mail (Laravel built-in)
+ *   'push'     → OneSignalChannel
+ *   'whatsapp' → VonageWhatsAppChannel
+ *   'sms'      → VonageSmsChannel
+ */
+final class FuelPriceAlert extends Notification implements ShouldQueue
+{
+    use Queueable;
+
+    /** @var array<string, class-string> */
+    private const array CHANNEL_MAP = [
+        'email' => 'mail',
+        'push' => OneSignalChannel::class,
+        'whatsapp' => VonageWhatsAppChannel::class,
+        'sms' => VonageSmsChannel::class,
+    ];
+
+    /** @param  string[]  $channels  Pre-filtered channel keys ('email', 'push', 'whatsapp', 'sms') */
+    public function __construct(
+        public readonly string $triggerType,
+        public readonly string $fuelType,
+        public readonly ?float $price,
+        public readonly array $channels,
+    ) {
+        $this->onQueue('notifications');
+    }
+
+    /** @return array<int, string> */
+    public function via(mixed $notifiable): array
+    {
+        return array_values(array_map(
+            fn (string $key) => self::CHANNEL_MAP[$key] ?? $key,
+            $this->channels,
+        ));
+    }
+
+    public function toMail(mixed $notifiable): MailMessage
+    {
+        return (new MailMessage)
+            ->subject($this->headline())
+            ->greeting("Hi {$notifiable->name},")
+            ->line($this->body())
+            ->action('Open FuelAlert', route('dashboard'))
+            ->line('You can change which alerts you receive in your account settings.');
+    }
+
+    /** @return array{heading: string, message: string} */
+    public function toOneSignal(mixed $notifiable): array
+    {
+        return [
+            'heading' => $this->headline(),
+            'message' => $this->body(),
+        ];
+    }
+
+    public function toVonageWhatsApp(mixed $notifiable): string
+    {
+        return $this->shortBody();
+    }
+
+    public function toVonageSms(mixed $notifiable): string
+    {
+        return $this->shortBody();
+    }
+
+    private function headline(): string
+    {
+        return match ($this->triggerType) {
+            'price_threshold' => 'Price hit your threshold',
+            'score_change' => 'Fill-up signal changed',
+            'scheduled_morning' => 'Morning fuel update',
+            'scheduled_evening' => 'Evening fuel update',
+            default => 'Fuel alert',
+        };
+    }
+
+    private function body(): string
+    {
+        $fuel = strtoupper($this->fuelType);
+        $price = $this->price !== null ? number_format($this->price, 1).'p' : null;
+
+        return match ($this->triggerType) {
+            'price_threshold' => $price !== null
+                ? "{$fuel} dropped to {$price} near you."
+                : "{$fuel} hit your alert threshold.",
+            'score_change' => "The {$fuel} fill-up score has changed near you.",
+            'scheduled_morning', 'scheduled_evening' => "Latest {$fuel} update is ready in your dashboard.",
+            default => "There's a new {$fuel} alert for you.",
+        };
+    }
+
+    /** SMS/WhatsApp must stay short — single line, ~160 chars max. */
+    private function shortBody(): string
+    {
+        return $this->headline().': '.$this->body();
+    }
+}

app/Providers/AppServiceProvider.php

@@ -59,13 +59,6 @@ class AppServiceProvider extends ServiceProvider
             app()->isProduction(),
         );
 
-        // SQLite lacks GREATEST/LEAST scalar functions — register them for tests.
-        if (DB::connection()->getDriverName() === 'sqlite') {
-            $pdo = DB::connection()->getPdo();
-            $pdo->sqliteCreateFunction('GREATEST', fn (...$args) => max($args), -1);
-            $pdo->sqliteCreateFunction('LEAST', fn (...$args) => min($args), -1);
-        }
-
         Password::defaults(fn (): ?Password => app()->isProduction()
             ? Password::min(12)
                 ->mixedCase()

app/Services/BrentPricePredictor.php

@@ -12,8 +12,6 @@ use Illuminate\Support\Facades\Log;
 
 final class BrentPricePredictor
 {
-    private const float EWMA_ALPHA = 0.3;
-
     private const float EWMA_THRESHOLD_PCT = 1.5;
 
     private const int EWMA_MAX_CONFIDENCE = 65;
@@ -33,8 +31,10 @@ final class BrentPricePredictor
     }
 
     /**
-     * Generate EWMA + LLM predictions, store them, and flag the latest
-     * brent_prices row as having a prediction generated.
+     * Try LLM first; persist EWMA only as a fallback when the LLM provider
+     * returns null. The downstream OilSignal already prefers LLM
+     * (llm_with_context > llm > ewma), so writing both rows on every run is
+     * dead weight 95% of the time. EWMA still acts as the safety net.
      */
     public function generatePrediction(): ?PricePrediction
     {
@@ -48,25 +48,23 @@ final class BrentPricePredictor
             return null;
         }
 
-        $ewma = $this->generateEwmaPrediction($prices);
-
-        if ($ewma !== null) {
-            PricePrediction::create($ewma->toArray());
-        }
-
         $llm = $this->provider->predict($prices);
 
         if ($llm !== null) {
             PricePrediction::create($llm->toArray());
+            $prices->first()->forceFill(['prediction_generated_at' => now()])->save();
+
+            return $llm;
         }
 
-        $result = $llm ?? $ewma;
+        $ewma = $this->generateEwmaPrediction($prices);
 
-        if ($result !== null) {
+        if ($ewma !== null) {
+            PricePrediction::create($ewma->toArray());
             $prices->first()->forceFill(['prediction_generated_at' => now()])->save();
         }
 
-        return $result;
+        return $ewma;
     }
 
     public function generateEwmaPrediction(Collection $prices): ?PricePrediction
@@ -77,8 +75,8 @@ final class BrentPricePredictor
             return null;
         }
 
-        $ewma3 = $this->computeEwma(array_slice($chronological, -3));
-        $ewma7 = $this->computeEwma(array_slice($chronological, -7));
+        $ewma3 = Ewma::compute(array_slice($chronological, -3));
+        $ewma7 = Ewma::compute(array_slice($chronological, -7));
 
         $changePct = (($ewma3 - $ewma7) / $ewma7) * 100;
 
@@ -112,20 +110,6 @@ final class BrentPricePredictor
         ]);
     }
 
-    /**
-     * @param  float[]  $prices  Chronological (oldest first).
-     */
-    private function computeEwma(array $prices): float
-    {
-        $ema = $prices[0];
-
-        foreach (array_slice($prices, 1) as $price) {
-            $ema = self::EWMA_ALPHA * $price + (1 - self::EWMA_ALPHA) * $ema;
-        }
-
-        return round($ema, 4);
-    }
-
     private function ewmaConfidence(float $changePct): int
     {
         $scaled = min($changePct / 5.0, 1.0) * self::EWMA_MAX_CONFIDENCE;

app/Services/BrentPriceSources/EiaBrentPriceSource.php

@@ -3,8 +3,9 @@
 namespace App\Services\BrentPriceSources;
 
 use App\Services\ApiLogger;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Http\Client\RequestException;
 use Illuminate\Support\Facades\Http;
-use Illuminate\Support\Facades\Log;
 use Throwable;
 
 final class EiaBrentPriceSource
@@ -14,12 +15,16 @@ final class EiaBrentPriceSource
     public function __construct(private readonly ApiLogger $apiLogger) {}
 
     /**
-     * @return array{date: string, price_usd: float}[]|null
+     * @return array{date: string, price_usd: float}[]|null null only when the response carried no usable rows
+     *
+     * @throws BrentPriceFetchException on network failure or non-2xx response after retries
      */
     public function fetch(): ?array
     {
         try {
-            $response = $this->apiLogger->send('eia', 'GET', self::URL, fn () => Http::timeout(10)
+            $response = $this->apiLogger->send('eia', 'GET', self::URL, fn () => Http::timeout(30)
+                ->retry(3, 200, fn (Throwable $e) => $this->shouldRetry($e))
+                ->throw()
                 ->get(self::URL, [
                     'api_key' => config('services.eia.api_key'),
                     'frequency' => 'daily',
@@ -29,32 +34,26 @@ final class EiaBrentPriceSource
                     'sort[0][direction]' => 'desc',
                     'length' => 30,
                 ]));
-
-            if (! $response->successful()) {
-                Log::error('EiaBrentPriceSource: request failed', ['status' => $response->status()]);
-
-                return null;
-            }
-
-            $rows = collect($response->json('response.data') ?? [])
-                ->filter(fn (array $row) => ($row['value'] ?? '.') !== '.')
-                ->map(fn (array $row) => [
-                    'date' => $row['period'],
-                    'price_usd' => (float) $row['value'],
-                ])
-                ->all();
-
-            if ($rows === []) {
-                Log::warning('EiaBrentPriceSource: no valid observations returned');
-
-                return null;
-            }
-
-            return $rows;
-        } catch (Throwable $e) {
-            Log::error('EiaBrentPriceSource: fetch failed', ['error' => $e->getMessage()]);
-
-            return null;
+        } catch (ConnectionException $e) {
+            throw new BrentPriceFetchException("EIA connection failed: {$e->getMessage()}", previous: $e);
+        } catch (RequestException $e) {
+            throw new BrentPriceFetchException("EIA returned HTTP {$e->response->status()}", previous: $e);
         }
+
+        $rows = collect($response->json('response.data') ?? [])
+            ->filter(fn (array $row) => ($row['value'] ?? '.') !== '.')
+            ->map(fn (array $row) => [
+                'date' => $row['period'],
+                'price_usd' => (float) $row['value'],
+            ])
+            ->all();
+
+        return $rows === [] ? null : $rows;
+    }
+
+    private function shouldRetry(Throwable $e): bool
+    {
+        return $e instanceof ConnectionException
+            || ($e instanceof RequestException && $e->response->serverError());
     }
 }

app/Services/BrentPriceSources/FredBrentPriceSource.php

@@ -3,8 +3,9 @@
 namespace App\Services\BrentPriceSources;
 
 use App\Services\ApiLogger;
+use Illuminate\Http\Client\ConnectionException;
+use Illuminate\Http\Client\RequestException;
 use Illuminate\Support\Facades\Http;
-use Illuminate\Support\Facades\Log;
 use Throwable;
 
 final class FredBrentPriceSource
@@ -14,12 +15,16 @@ final class FredBrentPriceSource
     public function __construct(private readonly ApiLogger $apiLogger) {}
 
     /**
-     * @return array{date: string, price_usd: float}[]|null
+     * @return array{date: string, price_usd: float}[]|null null only when the response carried no usable rows
+     *
+     * @throws BrentPriceFetchException on network failure or non-2xx response after retries
      */
     public function fetch(): ?array
     {
         try {
-            $response = $this->apiLogger->send('fred', 'GET', self::URL, fn () => Http::timeout(10)
+            $response = $this->apiLogger->send('fred', 'GET', self::URL, fn () => Http::timeout(30)
+                ->retry(3, 200, fn (Throwable $e) => $this->shouldRetry($e))
+                ->throw()
                 ->get(self::URL, [
                     'series_id' => 'DCOILBRENTEU',
                     'api_key' => config('services.fred.api_key'),
@@ -27,32 +32,26 @@ final class FredBrentPriceSource
                     'limit' => 30,
                     'file_type' => 'json',
                 ]));
-
-            if (! $response->successful()) {
-                Log::error('FredBrentPriceSource: request failed', ['status' => $response->status()]);
-
-                return null;
-            }
-
-            $rows = collect($response->json('observations') ?? [])
-                ->filter(fn (array $obs) => $obs['value'] !== '.')
-                ->map(fn (array $obs) => [
-                    'date' => $obs['date'],
-                    'price_usd' => (float) $obs['value'],
-                ])
-                ->all();
-
-            if ($rows === []) {
-                Log::warning('FredBrentPriceSource: no valid observations returned');
-
-                return null;
-            }
-
-            return $rows;
-        } catch (Throwable $e) {
-            Log::error('FredBrentPriceSource: fetch failed', ['error' => $e->getMessage()]);
-
-            return null;
+        } catch (ConnectionException $e) {
+            throw new BrentPriceFetchException("FRED connection failed: {$e->getMessage()}", previous: $e);
+        } catch (RequestException $e) {
+            throw new BrentPriceFetchException("FRED returned HTTP {$e->response->status()}", previous: $e);
         }
+
+        $rows = collect($response->json('observations') ?? [])
+            ->filter(fn (array $obs) => $obs['value'] !== '.')
+            ->map(fn (array $obs) => [
+                'date' => $obs['date'],
+                'price_usd' => (float) $obs['value'],
+            ])
+            ->all();
+
+        return $rows === [] ? null : $rows;
+    }
+
+    private function shouldRetry(Throwable $e): bool
+    {
+        return $e instanceof ConnectionException
+            || ($e instanceof RequestException && $e->response->serverError());
     }
 }

app/Services/Ewma.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Services;
+
+/**
+ * Exponentially-weighted moving average. Pure function — used by
+ * BrentPricePredictor for the EWMA fallback prediction and by
+ * AnthropicPredictionProvider to enrich the basic-flow prompt.
+ */
+final class Ewma
+{
+    public const float DEFAULT_ALPHA = 0.3;
+
+    /** @param  float[]  $prices  Chronological order (oldest first). */
+    public static function compute(array $prices, float $alpha = self::DEFAULT_ALPHA): float
+    {
+        $ema = $prices[0];
+
+        foreach (array_slice($prices, 1) as $price) {
+            $ema = $alpha * $price + (1 - $alpha) * $ema;
+        }
+
+        return round($ema, 4);
+    }
+}

app/Services/FuelPriceService.php

@@ -67,57 +67,15 @@ class FuelPriceService
      */
     public function pollPrices(): int
     {
-        $token = $this->getAccessToken();
-        $inserted = 0;
-        $batch = 1;
         $pollStartedAt = now();
         $since = Cache::get(self::LAST_PRICE_POLL_CACHE_KEY);
-        $completedCleanly = false;
+        $sinceCarbon = $since instanceof CarbonInterface ? $since : null;
 
-        do {
-            try {
-                $baseUrl = config('services.fuel_finder.base_url').'/pfs/fuel-prices';
-                $params = ['batch-number' => $batch];
-
-                if ($since instanceof CarbonInterface) {
-                    $params['effective-start-timestamp'] = $since->format('Y-m-d H:i:s');
-                }
-
-                $logUrl = $baseUrl.'?'.http_build_query($params);
-                $response = $this->apiLogger->send('fuel_finder', 'GET', $logUrl, fn () => Http::timeout(30)
-                    ->withToken($token)
-                    ->get($baseUrl, $params));
-
-                if ($response->notFound()) {
-                    $completedCleanly = true;
-                    break;
-                }
-
-                if (! $response->successful()) {
-                    Log::error('FuelPriceService: price batch returned error', [
-                        'batch' => $batch,
-                        'status' => $response->status(),
-                    ]);
-                    break;
-                }
-
-                $stations = $response->json() ?? [];
-            } catch (Throwable $e) {
-                Log::error('FuelPriceService: price batch fetch failed', [
-                    'batch' => $batch,
-                    'error' => $e->getMessage(),
-                ]);
-                break;
-            }
-
-            if (empty($stations)) {
-                $completedCleanly = true;
-                break;
-            }
-
-            $inserted += $this->processPriceBatch($stations);
-            $batch++;
-        } while (true);
+        [$inserted, $completedCleanly] = $this->iterateBatches(
+            '/pfs/fuel-prices',
+            $sinceCarbon,
+            fn (array $stations): int => $this->processPriceBatch($stations),
+        );
 
         if ($completedCleanly) {
             Cache::forever(self::LAST_PRICE_POLL_CACHE_KEY, $pollStartedAt);
@@ -131,25 +89,53 @@ class FuelPriceService
      * Called on full daily refresh before pollPrices().
      */
     public function refreshStations(): void
+    {
+        $this->iterateBatches('/pfs', null, function (array $stations): int {
+            $this->upsertStations($stations);
+
+            return 0;
+        });
+    }
+
+    /**
+     * Drive a paginated fuel-finder endpoint until exhausted, calling
+     * $process on each non-empty batch. Returns the sum of $process return
+     * values plus a flag indicating the loop exited cleanly (404 or empty
+     * body) rather than via an HTTP error or thrown exception. Callers use
+     * the flag to decide whether to update incremental-poll bookkeeping.
+     *
+     * @param  callable(array<int, array<string, mixed>>): int  $process
+     * @return array{0: int, 1: bool}
+     */
+    private function iterateBatches(string $endpoint, ?CarbonInterface $since, callable $process): array
     {
         $token = $this->getAccessToken();
+        $baseUrl = config('services.fuel_finder.base_url').$endpoint;
+        $total = 0;
         $batch = 1;
+        $completedCleanly = false;
 
         do {
             try {
-                $baseUrl = config('services.fuel_finder.base_url').'/pfs';
                 $params = ['batch-number' => $batch];
+
+                if ($since !== null) {
+                    $params['effective-start-timestamp'] = $since->format('Y-m-d H:i:s');
+                }
+
                 $logUrl = $baseUrl.'?'.http_build_query($params);
                 $response = $this->apiLogger->send('fuel_finder', 'GET', $logUrl, fn () => Http::timeout(30)
                     ->withToken($token)
                     ->get($baseUrl, $params));
 
                 if ($response->notFound()) {
-                    break; // No more batches
+                    $completedCleanly = true;
+                    break;
                 }
 
                 if (! $response->successful()) {
-                    Log::error('FuelPriceService: station batch returned error', [
+                    Log::error('FuelPriceService: batch returned error', [
+                        'endpoint' => $endpoint,
                         'batch' => $batch,
                         'status' => $response->status(),
                     ]);
@@ -158,7 +144,8 @@ class FuelPriceService
 
                 $stations = $response->json() ?? [];
             } catch (Throwable $e) {
-                Log::error('FuelPriceService: station batch fetch failed', [
+                Log::error('FuelPriceService: batch fetch failed', [
+                    'endpoint' => $endpoint,
                     'batch' => $batch,
                     'error' => $e->getMessage(),
                 ]);
@@ -166,12 +153,15 @@ class FuelPriceService
             }
 
             if (empty($stations)) {
+                $completedCleanly = true;
                 break;
             }
 
-            $this->upsertStations($stations);
+            $total += $process($stations);
             $batch++;
         } while (true);
+
+        return [$total, $completedCleanly];
     }
 
     /** @param array<int, array<string, mixed>> $apiStations */
@@ -209,9 +199,9 @@ class FuelPriceService
                 'postcode' => $data['location']['postcode'],
                 'lat' => $data['location']['latitude'],
                 'lng' => $data['location']['longitude'],
-                'amenities' => self::flattenEnabledFlags($data['amenities'] ?? []),
+                'amenities' => $this->flattenEnabledFlags($data['amenities'] ?? []),
                 'opening_times' => $data['opening_times'] ?? null,
-                'fuel_types' => self::flattenEnabledFlags($data['fuel_types'] ?? []),
+                'fuel_types' => $this->flattenEnabledFlags($data['fuel_types'] ?? []),
                 'last_seen_at' => $now,
             ]);
 
@@ -242,7 +232,7 @@ class FuelPriceService
      * @param  array<string, bool>|array<int, string>  $flags
      * @return array<int, string>
      */
-    private static function flattenEnabledFlags(array $flags): array
+    private function flattenEnabledFlags(array $flags): array
     {
         if ($flags === []) {
             return [];

app/Services/HaversineQuery.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Services;
+
+/**
+ * Builds canonical haversine SQL fragments for distance and within-radius
+ * filtering. Centralises the float-clamping (GREATEST/LEAST) and the column
+ * naming convention used across prediction and station search queries.
+ *
+ * Assumes the joined/queried table exposes columns `lat` and `lng`.
+ */
+final class HaversineQuery
+{
+    private const string DISTANCE_KM_SQL =
+        '(6371 * acos(GREATEST(-1.0, LEAST(1.0, '
+        .'cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?)) '
+        .'+ sin(radians(?)) * sin(radians(lat))))))';
+
+    /**
+     * Bare distance-in-km expression. Caller adds aliasing or comparison.
+     *
+     * @return array{0: string, 1: array{float, float, float}}
+     */
+    public static function distanceKm(float $lat, float $lng): array
+    {
+        return [self::DISTANCE_KM_SQL, [$lat, $lng, $lat]];
+    }
+
+    /**
+     * `<= {km}` predicate suitable for whereRaw. The radius is embedded as a
+     * numeric literal because PDO + SQLite's whereRaw binds floats as strings
+     * by default, which breaks numeric comparison against the haversine
+     * expression. The `float` parameter is type-checked and not user input.
+     *
+     * @return array{0: string, 1: array{float, float, float}}
+     */
+    public static function withinKm(float $lat, float $lng, float $km): array
+    {
+        return [self::DISTANCE_KM_SQL.' <= '.sprintf('%F', $km), [$lat, $lng, $lat]];
+    }
+}

app/Services/LlmPrediction/AbstractLlmPredictionProvider.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace App\Services\LlmPrediction;
+
+use App\Enums\PredictionSource;
+use App\Enums\TrendDirection;
+use App\Models\BrentPrice;
+use App\Models\PricePrediction;
+use App\Services\ApiLogger;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Log;
+use Throwable;
+
+abstract class AbstractLlmPredictionProvider implements OilPredictionProvider
+{
+    protected const int LLM_MAX_CONFIDENCE = 85;
+
+    public function __construct(
+        protected readonly ApiLogger $apiLogger,
+    ) {}
+
+    /**
+     * Default flow: gate on API key, call the provider, normalise the payload
+     * to a PricePrediction. Subclasses with multi-phase flows (e.g. Anthropic
+     * web-search) override `predict()` directly and reuse the helper methods.
+     */
+    public function predict(Collection $prices): ?PricePrediction
+    {
+        $apiKey = $this->apiKey();
+
+        if ($apiKey === null) {
+            return null;
+        }
+
+        try {
+            $payload = $this->callProvider($apiKey, $this->buildPriceList($prices));
+
+            return $payload === null ? null : $this->buildPrediction($payload);
+        } catch (Throwable $e) {
+            Log::error(static::class.': predict failed', ['error' => $e->getMessage()]);
+
+            return null;
+        }
+    }
+
+    /** Returns the configured API key or null if not set. */
+    abstract protected function apiKey(): ?string;
+
+    /**
+     * Make the provider HTTP call and return the normalised payload, or null
+     * on failure (already logged by the implementer).
+     *
+     * @return array{direction: string, confidence: int, reasoning: string}|null
+     */
+    abstract protected function callProvider(string $apiKey, string $priceList): ?array;
+
+    /** @param  Collection<int, BrentPrice>  $prices */
+    protected function buildPriceList(Collection $prices): string
+    {
+        return $prices->sortBy('date')
+            ->map(fn (BrentPrice $p) => $p->date->toDateString().': $'.$p->price_usd)
+            ->implode("\n");
+    }
+
+    /** @param  array{direction: string, confidence: int, reasoning: string}  $input */
+    protected function buildPrediction(array $input, PredictionSource $source = PredictionSource::Llm): ?PricePrediction
+    {
+        $direction = TrendDirection::tryFrom($input['direction'] ?? '');
+
+        if ($direction === null) {
+            Log::error(static::class.': invalid direction', ['input' => $input]);
+
+            return null;
+        }
+
+        return new PricePrediction([
+            'predicted_for' => now()->toDateString(),
+            'source' => $source,
+            'direction' => $direction,
+            'confidence' => min((int) ($input['confidence'] ?? 0), self::LLM_MAX_CONFIDENCE),
+            'reasoning' => $input['reasoning'] ?? '',
+            'generated_at' => now(),
+        ]);
+    }
+
+    protected function defaultPrompt(string $priceList): string
+    {
+        return <<<PROMPT
+            You are analyzing Brent crude oil price data for a UK fuel price alert service.
+            Predict the short-term direction over the next 3–5 days.
+
+            Recent Brent crude prices (USD/barrel):
+            {$priceList}
+
+            Respond with direction (rising, falling, or flat), a confidence score (0–85),
+            and a one-sentence reasoning.
+            PROMPT;
+    }
+}

app/Services/LlmPrediction/AnthropicPredictionProvider.php

@@ -3,31 +3,23 @@
 namespace App\Services\LlmPrediction;
 
 use App\Enums\PredictionSource;
-use App\Enums\TrendDirection;
-use App\Models\BrentPrice;
 use App\Models\PricePrediction;
-use App\Services\ApiLogger;
+use App\Services\Ewma;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Log;
 use Throwable;
 
-class AnthropicPredictionProvider implements OilPredictionProvider
+class AnthropicPredictionProvider extends AbstractLlmPredictionProvider
 {
-    private const int LLM_MAX_CONFIDENCE = 85;
-
-    private const float EWMA_ALPHA = 0.3;
-
-    public function __construct(
-        private readonly ApiLogger $apiLogger,
-    ) {}
-
     /**
      * Tries web-search-enriched prediction first, falls back to basic tool use.
+     * Overrides the parent flow because Anthropic uses two phases (web search
+     * loop + forced tool call) and selects the source dynamically.
      */
     public function predict(Collection $prices): ?PricePrediction
     {
-        if (! config('services.anthropic.api_key')) {
+        if ($this->apiKey() === null) {
             return null;
         }
 
@@ -36,10 +28,21 @@ class AnthropicPredictionProvider implements OilPredictionProvider
         return $prediction ?? $this->predictBasic($prices);
     }
 
+    protected function apiKey(): ?string
+    {
+        return config('services.anthropic.api_key');
+    }
+
+    /** {@inheritDoc} */
+    protected function callProvider(string $apiKey, string $priceList): ?array
+    {
+        return null;
+    }
+
     /**
      * Multi-turn web search phase, then a forced submit_prediction call.
-     * Phase 1: Let the model search for recent oil/geopolitical news (pause_turn loop).
-     * Phase 2: Force submit_prediction with the full conversation context.
+     * Phase 1: let the model search for recent oil/geopolitical news.
+     * Phase 2: force submit_prediction with the full conversation context.
      */
     private function predictWithWebContext(Collection $prices): ?PricePrediction
     {
@@ -47,7 +50,6 @@ class AnthropicPredictionProvider implements OilPredictionProvider
         $url = 'https://api.anthropic.com/v1/messages';
 
         try {
-            // Phase 1: web search loop
             for ($i = 0, $response = null; $i < 5; $i++) {
                 $response = $this->apiLogger->send('anthropic', 'POST', $url, fn () => Http::timeout(30)
                     ->withHeaders($this->headers())
@@ -59,7 +61,7 @@ class AnthropicPredictionProvider implements OilPredictionProvider
                     ]));
 
                 if (! $response->successful()) {
-                    Log::error('AnthropicPredictionProvider: context search request failed', ['status' => $response->status()]);
+                    Log::error(self::class.': context search request failed', ['status' => $response->status()]);
 
                     return null;
                 }
@@ -71,7 +73,6 @@ class AnthropicPredictionProvider implements OilPredictionProvider
                 $messages[] = ['role' => 'assistant', 'content' => $response->json('content')];
             }
 
-            // Phase 2: forced submit with full context
             $messages[] = ['role' => 'assistant', 'content' => $response->json('content')];
             $messages[] = ['role' => 'user', 'content' => 'Now submit your prediction using the submit_prediction tool.'];
 
@@ -86,22 +87,61 @@ class AnthropicPredictionProvider implements OilPredictionProvider
                 ]));
 
             if (! $submitResponse->successful()) {
-                Log::error('AnthropicPredictionProvider: context submit request failed', ['status' => $submitResponse->status()]);
+                Log::error(self::class.': context submit request failed', ['status' => $submitResponse->status()]);
 
                 return null;
             }
 
             $input = $this->extractToolInput($submitResponse->json('content') ?? []);
 
-            if ($input === null) {
-                Log::error('AnthropicPredictionProvider: no tool_use block in context submit response');
+            return $input === null
+                ? null
+                : $this->buildPrediction($input, PredictionSource::LlmWithContext);
+        } catch (Throwable $e) {
+            Log::error(self::class.': predictWithWebContext failed', ['error' => $e->getMessage()]);
+
+            return null;
+        }
+    }
+
+    /**
+     * Single-turn prediction using a forced submit_prediction tool call.
+     * Guarantees structured output — no JSON parsing needed.
+     */
+    private function predictBasic(Collection $prices): ?PricePrediction
+    {
+        $chronological = $prices->sortBy('date');
+        $ewma3 = Ewma::compute($chronological->take(-3)->pluck('price_usd')->values()->all());
+        $ewma7 = Ewma::compute($chronological->take(-7)->pluck('price_usd')->values()->all());
+        $ewma14 = Ewma::compute($chronological->pluck('price_usd')->values()->all());
+
+        $url = 'https://api.anthropic.com/v1/messages';
+
+        try {
+            $response = $this->apiLogger->send('anthropic', 'POST', $url, fn () => Http::timeout(15)
+                ->withHeaders($this->headers())
+                ->post($url, [
+                    'model' => config('services.anthropic.model', 'claude-haiku-4-5-20251001'),
+                    'max_tokens' => 256,
+                    'tools' => [$this->submitPredictionTool()],
+                    'tool_choice' => ['type' => 'tool', 'name' => 'submit_prediction'],
+                    'messages' => [[
+                        'role' => 'user',
+                        'content' => $this->basicPrompt($this->buildPriceList($prices), $ewma3, $ewma7, $ewma14),
+                    ]],
+                ]));
+
+            if (! $response->successful()) {
+                Log::error(self::class.': basic request failed', ['status' => $response->status()]);
 
                 return null;
             }
 
-            return $this->buildPrediction($input, PredictionSource::LlmWithContext);
+            $input = $this->extractToolInput($response->json('content') ?? []);
+
+            return $input === null ? null : $this->buildPrediction($input);
         } catch (Throwable $e) {
-            Log::error('AnthropicPredictionProvider: predictWithWebContext failed', ['error' => $e->getMessage()]);
+            Log::error(self::class.': predictBasic failed', ['error' => $e->getMessage()]);
 
             return null;
         }
@@ -126,18 +166,29 @@ class AnthropicPredictionProvider implements OilPredictionProvider
             PROMPT;
     }
 
-    private function buildPriceList(Collection $prices): string
+    private function basicPrompt(string $priceList, float $ewma3, float $ewma7, float $ewma14): string
     {
-        return $prices->sortBy('date')
-            ->map(fn (BrentPrice $p) => $p->date->toDateString().': $'.$p->price_usd)
-            ->implode("\n");
+        return <<<PROMPT
+            You are analyzing Brent crude oil price data for a UK fuel price alert service.
+            Predict the short-term direction over the next 3–5 days.
+
+            Recent Brent crude prices (USD/barrel):
+            {$priceList}
+
+            Pre-computed indicators:
+            - 3-day EWMA:  \${$ewma3}
+            - 7-day EWMA:  \${$ewma7}
+            - 14-day EWMA: \${$ewma14}
+
+            Use the submit_prediction tool to submit your answer.
+            PROMPT;
     }
 
     /** @return array<string, string> */
     private function headers(): array
     {
         return [
-            'x-api-key' => config('services.anthropic.api_key'),
+            'x-api-key' => $this->apiKey(),
             'anthropic-version' => '2023-06-01',
         ];
     }
@@ -177,108 +228,4 @@ class AnthropicPredictionProvider implements OilPredictionProvider
 
         return $block['input'] ?? null;
     }
-
-    /** @param  array{direction: string, confidence: int, reasoning: string}  $input */
-    private function buildPrediction(array $input, PredictionSource $source): ?PricePrediction
-    {
-        $direction = TrendDirection::tryFrom($input['direction'] ?? '');
-
-        if ($direction === null) {
-            Log::error('AnthropicPredictionProvider: invalid direction in tool input', ['input' => $input]);
-
-            return null;
-        }
-
-        return new PricePrediction([
-            'predicted_for' => now()->toDateString(),
-            'source' => $source,
-            'direction' => $direction,
-            'confidence' => min((int) $input['confidence'], self::LLM_MAX_CONFIDENCE),
-            'reasoning' => $input['reasoning'],
-            'generated_at' => now(),
-        ]);
-    }
-
-    /**
-     * Single-turn prediction using a forced submit_prediction tool call.
-     * Guarantees structured output — no JSON parsing needed.
-     */
-    private function predictBasic(Collection $prices): ?PricePrediction
-    {
-        $chronological = $prices->sortBy('date');
-        $ewma3 = $this->computeEwma($chronological->take(-3)->pluck('price_usd')->values()->all());
-        $ewma7 = $this->computeEwma($chronological->take(-7)->pluck('price_usd')->values()->all());
-        $ewma14 = $this->computeEwma($chronological->pluck('price_usd')->values()->all());
-
-        $priceList = $this->buildPriceList($prices);
-
-        $url = 'https://api.anthropic.com/v1/messages';
-
-        try {
-            $response = $this->apiLogger->send('anthropic', 'POST', $url, fn () => Http::timeout(15)
-                ->withHeaders($this->headers())
-                ->post($url, [
-                    'model' => config('services.anthropic.model', 'claude-haiku-4-5-20251001'),
-                    'max_tokens' => 256,
-                    'tools' => [$this->submitPredictionTool()],
-                    'tool_choice' => ['type' => 'tool', 'name' => 'submit_prediction'],
-                    'messages' => [[
-                        'role' => 'user',
-                        'content' => $this->basicPrompt($priceList, $ewma3, $ewma7, $ewma14),
-                    ]],
-                ]));
-
-            if (! $response->successful()) {
-                Log::error('AnthropicPredictionProvider: basic request failed', ['status' => $response->status()]);
-
-                return null;
-            }
-
-            $input = $this->extractToolInput($response->json('content') ?? []);
-
-            if ($input === null) {
-                Log::error('AnthropicPredictionProvider: no tool_use block in basic response');
-
-                return null;
-            }
-
-            return $this->buildPrediction($input, PredictionSource::Llm);
-        } catch (Throwable $e) {
-            Log::error('AnthropicPredictionProvider: predictBasic failed', ['error' => $e->getMessage()]);
-
-            return null;
-        }
-    }
-
-    /**
-     * @param  float[]  $prices  Chronological order (oldest first)
-     */
-    private function computeEwma(array $prices): float
-    {
-        $ema = $prices[0];
-
-        foreach (array_slice($prices, 1) as $price) {
-            $ema = self::EWMA_ALPHA * $price + (1 - self::EWMA_ALPHA) * $ema;
-        }
-
-        return round($ema, 4);
-    }
-
-    private function basicPrompt(string $priceList, float $ewma3, float $ewma7, float $ewma14): string
-    {
-        return <<<PROMPT
-            You are analyzing Brent crude oil price data for a UK fuel price alert service.
-            Predict the short-term direction over the next 3–5 days.
-
-            Recent Brent crude prices (USD/barrel):
-            {$priceList}
-
-            Pre-computed indicators:
-            - 3-day EWMA:  \${$ewma3}
-            - 7-day EWMA:  \${$ewma7}
-            - 14-day EWMA: \${$ewma14}
-
-            Use the submit_prediction tool to submit your answer.
-            PROMPT;
-    }
 }

app/Services/LlmPrediction/GeminiPredictionProvider.php

@@ -2,110 +2,59 @@
 
 namespace App\Services\LlmPrediction;
 
-use App\Enums\PredictionSource;
-use App\Enums\TrendDirection;
-use App\Models\BrentPrice;
-use App\Models\PricePrediction;
-use App\Services\ApiLogger;
-use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Log;
-use Throwable;
 
-class GeminiPredictionProvider implements OilPredictionProvider
+class GeminiPredictionProvider extends AbstractLlmPredictionProvider
 {
-    private const int LLM_MAX_CONFIDENCE = 85;
-
-    public function __construct(
-        private readonly ApiLogger $apiLogger,
-    ) {}
-
-    public function predict(Collection $prices): ?PricePrediction
+    protected function apiKey(): ?string
     {
-        if (! config('services.gemini.api_key')) {
-            return null;
-        }
-
-        $priceList = $prices->sortBy('date')
-            ->map(fn (BrentPrice $p) => $p->date->toDateString().': $'.$p->price_usd)
-            ->implode("\n");
+        return config('services.gemini.api_key');
+    }
 
+    protected function callProvider(string $apiKey, string $priceList): ?array
+    {
         $model = config('services.gemini.model', 'gemini-2.0-flash');
         $url = "https://generativelanguage.googleapis.com/v1beta/models/{$model}:generateContent";
 
-        try {
-            $response = $this->apiLogger->send('gemini', 'POST', $url, fn () => Http::timeout(15)
-                ->withQueryParameters(['key' => config('services.gemini.api_key')])
-                ->post($url, [
-                    'contents' => [[
-                        'parts' => [['text' => $this->prompt($priceList)]],
-                    ]],
-                    'generationConfig' => [
-                        'responseMimeType' => 'application/json',
-                        'responseSchema' => [
-                            'type' => 'OBJECT',
-                            'properties' => [
-                                'direction' => [
-                                    'type' => 'STRING',
-                                    'enum' => ['rising', 'falling', 'flat'],
-                                ],
-                                'confidence' => ['type' => 'INTEGER'],
-                                'reasoning' => ['type' => 'STRING'],
+        $response = $this->apiLogger->send('gemini', 'POST', $url, fn () => Http::timeout(15)
+            ->withQueryParameters(['key' => $apiKey])
+            ->post($url, [
+                'contents' => [[
+                    'parts' => [['text' => $this->defaultPrompt($priceList)]],
+                ]],
+                'generationConfig' => [
+                    'responseMimeType' => 'application/json',
+                    'responseSchema' => [
+                        'type' => 'OBJECT',
+                        'properties' => [
+                            'direction' => [
+                                'type' => 'STRING',
+                                'enum' => ['rising', 'falling', 'flat'],
                             ],
-                            'required' => ['direction', 'confidence', 'reasoning'],
+                            'confidence' => ['type' => 'INTEGER'],
+                            'reasoning' => ['type' => 'STRING'],
                         ],
+                        'required' => ['direction', 'confidence', 'reasoning'],
                     ],
-                ]));
+                ],
+            ]));
 
-            if (! $response->successful()) {
-                Log::error('GeminiPredictionProvider: request failed', ['status' => $response->status()]);
-
-                return null;
-            }
-
-            $text = $response->json('candidates.0.content.parts.0.text') ?? '';
-            $data = json_decode($text, true);
-
-            if (! isset($data['direction'], $data['confidence'], $data['reasoning'])) {
-                Log::error('GeminiPredictionProvider: unexpected response format', ['text' => $text]);
-
-                return null;
-            }
-
-            $direction = TrendDirection::tryFrom($data['direction']);
-
-            if ($direction === null) {
-                Log::error('GeminiPredictionProvider: invalid direction', ['direction' => $data['direction']]);
-
-                return null;
-            }
-
-            return new PricePrediction([
-                'predicted_for' => now()->toDateString(),
-                'source' => PredictionSource::Llm,
-                'direction' => $direction,
-                'confidence' => min((int) $data['confidence'], self::LLM_MAX_CONFIDENCE),
-                'reasoning' => $data['reasoning'],
-                'generated_at' => now(),
-            ]);
-        } catch (Throwable $e) {
-            Log::error('GeminiPredictionProvider: predict failed', ['error' => $e->getMessage()]);
+        if (! $response->successful()) {
+            Log::error(self::class.': request failed', ['status' => $response->status()]);
 
             return null;
         }
-    }
 
-    private function prompt(string $priceList): string
-    {
-        return <<<PROMPT
-            You are analyzing Brent crude oil price data for a UK fuel price alert service.
-            Predict the short-term direction over the next 3–5 days.
+        $text = $response->json('candidates.0.content.parts.0.text') ?? '';
+        $data = json_decode($text, true);
 
-            Recent Brent crude prices (USD/barrel):
-            {$priceList}
+        if (! isset($data['direction'], $data['confidence'], $data['reasoning'])) {
+            Log::error(self::class.': unexpected response format', ['text' => $text]);
 
-            Respond with direction (rising, falling, or flat), a confidence score (0–85),
-            and a one-sentence reasoning.
-            PROMPT;
+            return null;
+        }
+
+        return $data;
     }
 }

app/Services/LlmPrediction/OpenAiPredictionProvider.php

@@ -2,112 +2,61 @@
 
 namespace App\Services\LlmPrediction;
 
-use App\Enums\PredictionSource;
-use App\Enums\TrendDirection;
-use App\Models\BrentPrice;
-use App\Models\PricePrediction;
-use App\Services\ApiLogger;
-use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Http;
 use Illuminate\Support\Facades\Log;
-use Throwable;
 
-class OpenAiPredictionProvider implements OilPredictionProvider
+class OpenAiPredictionProvider extends AbstractLlmPredictionProvider
 {
-    private const int LLM_MAX_CONFIDENCE = 85;
-
-    public function __construct(
-        private readonly ApiLogger $apiLogger,
-    ) {}
-
-    public function predict(Collection $prices): ?PricePrediction
+    protected function apiKey(): ?string
     {
-        if (! config('services.openai.api_key')) {
-            return null;
-        }
-
-        $priceList = $prices->sortBy('date')
-            ->map(fn (BrentPrice $p) => $p->date->toDateString().': $'.$p->price_usd)
-            ->implode("\n");
+        return config('services.openai.api_key');
+    }
 
+    protected function callProvider(string $apiKey, string $priceList): ?array
+    {
         $url = 'https://api.openai.com/v1/chat/completions';
 
-        try {
-            $response = $this->apiLogger->send('openai', 'POST', $url, fn () => Http::timeout(15)
-                ->withToken(config('services.openai.api_key'))
-                ->post($url, [
-                    'model' => config('services.openai.model', 'gpt-4o-mini'),
-                    'response_format' => [
-                        'type' => 'json_schema',
-                        'json_schema' => [
-                            'name' => 'oil_prediction',
-                            'strict' => true,
-                            'schema' => [
-                                'type' => 'object',
-                                'properties' => [
-                                    'direction' => ['type' => 'string', 'enum' => ['rising', 'falling', 'flat']],
-                                    'confidence' => ['type' => 'integer'],
-                                    'reasoning' => ['type' => 'string'],
-                                ],
-                                'required' => ['direction', 'confidence', 'reasoning'],
-                                'additionalProperties' => false,
+        $response = $this->apiLogger->send('openai', 'POST', $url, fn () => Http::timeout(15)
+            ->withToken($apiKey)
+            ->post($url, [
+                'model' => config('services.openai.model', 'gpt-4o-mini'),
+                'response_format' => [
+                    'type' => 'json_schema',
+                    'json_schema' => [
+                        'name' => 'oil_prediction',
+                        'strict' => true,
+                        'schema' => [
+                            'type' => 'object',
+                            'properties' => [
+                                'direction' => ['type' => 'string', 'enum' => ['rising', 'falling', 'flat']],
+                                'confidence' => ['type' => 'integer'],
+                                'reasoning' => ['type' => 'string'],
                             ],
+                            'required' => ['direction', 'confidence', 'reasoning'],
+                            'additionalProperties' => false,
                         ],
                     ],
-                    'messages' => [[
-                        'role' => 'user',
-                        'content' => $this->prompt($priceList),
-                    ]],
-                ]));
+                ],
+                'messages' => [[
+                    'role' => 'user',
+                    'content' => $this->defaultPrompt($priceList),
+                ]],
+            ]));
 
-            if (! $response->successful()) {
-                Log::error('OpenAiPredictionProvider: request failed', ['status' => $response->status()]);
-
-                return null;
-            }
-
-            $data = json_decode($response->json('choices.0.message.content') ?? '{}', true);
-
-            if (! isset($data['direction'], $data['confidence'], $data['reasoning'])) {
-                Log::error('OpenAiPredictionProvider: unexpected response format', ['data' => $data]);
-
-                return null;
-            }
-
-            $direction = TrendDirection::tryFrom($data['direction']);
-
-            if ($direction === null) {
-                Log::error('OpenAiPredictionProvider: invalid direction', ['direction' => $data['direction']]);
-
-                return null;
-            }
-
-            return new PricePrediction([
-                'predicted_for' => now()->toDateString(),
-                'source' => PredictionSource::Llm,
-                'direction' => $direction,
-                'confidence' => min((int) $data['confidence'], self::LLM_MAX_CONFIDENCE),
-                'reasoning' => $data['reasoning'],
-                'generated_at' => now(),
-            ]);
-        } catch (Throwable $e) {
-            Log::error('OpenAiPredictionProvider: predict failed', ['error' => $e->getMessage()]);
+        if (! $response->successful()) {
+            Log::error(self::class.': request failed', ['status' => $response->status()]);
 
             return null;
         }
-    }
 
-    private function prompt(string $priceList): string
-    {
-        return <<<PROMPT
-            You are analyzing Brent crude oil price data for a UK fuel price alert service.
-            Predict the short-term direction over the next 3–5 days.
+        $data = json_decode($response->json('choices.0.message.content') ?? '{}', true);
 
-            Recent Brent crude prices (USD/barrel):
-            {$priceList}
+        if (! isset($data['direction'], $data['confidence'], $data['reasoning'])) {
+            Log::error(self::class.': unexpected response format', ['data' => $data]);
 
-            Respond with direction (rising, falling, or flat), a confidence score (0–85),
-            and a one-sentence reasoning.
-            PROMPT;
+            return null;
+        }
+
+        return $data;
     }
 }

app/Services/NationalFuelPredictionService.php

@@ -4,23 +4,31 @@ namespace App\Services;
 
 use App\Enums\FuelType;
 use App\Models\StationPriceCurrent;
+use App\Services\Prediction\Signals\BrandBehaviourSignal;
+use App\Services\Prediction\Signals\DayOfWeekSignal;
+use App\Services\Prediction\Signals\OilSignal;
+use App\Services\Prediction\Signals\RegionalMomentumSignal;
+use App\Services\Prediction\Signals\SignalContext;
+use App\Services\Prediction\Signals\StickinessSignal;
+use App\Services\Prediction\Signals\TrendSignal;
 use Carbon\CarbonInterface;
 use Illuminate\Support\Facades\DB;
 
 class NationalFuelPredictionService
 {
-    private const float R_SQUARED_THRESHOLD = 0.5;
-
     private const float SLOPE_THRESHOLD_PENCE = 0.3;
 
-    /** Slope (pence/day) at which trend score saturates to ±1.0. */
-    private const float SLOPE_SATURATION_PENCE = 0.5;
-
-    /** Minimum unique days of history for the day-of-week signal to activate. */
-    private const int DAY_OF_WEEK_MIN_DAYS = 21;
-
     private const int PREDICTION_HORIZON_DAYS = 7;
 
+    public function __construct(
+        private readonly TrendSignal $trendSignal,
+        private readonly DayOfWeekSignal $dayOfWeekSignal,
+        private readonly BrandBehaviourSignal $brandBehaviourSignal,
+        private readonly StickinessSignal $stickinessSignal,
+        private readonly RegionalMomentumSignal $regionalMomentumSignal,
+        private readonly OilSignal $oilSignal,
+    ) {}
+
     /**
      * @return array{
      *     fuel_type: string,
@@ -41,18 +49,17 @@ class NationalFuelPredictionService
     {
         $fuelType = FuelType::E10;
         $hasCoordinates = $lat !== null && $lng !== null;
+        $context = new SignalContext($fuelType, $lat, $lng);
 
         $currentAvg = $this->getCurrentAverage($fuelType, $lat, $lng);
-        $trend = $this->computeTrendSignal($fuelType);
-        $dayOfWeek = $this->computeDayOfWeekSignal($fuelType);
-        $brandBehaviour = $this->computeBrandBehaviourSignal($fuelType);
-        $stickiness = $this->computeStickinessSignal($fuelType);
-        $oil = $this->computeOilSignal();
+        $trend = $this->trendSignal->compute($context);
+        $dayOfWeek = $this->dayOfWeekSignal->compute($context);
+        $brandBehaviour = $this->brandBehaviourSignal->compute($context);
+        $stickiness = $this->stickinessSignal->compute($context);
+        $oil = $this->oilSignal->compute($context);
 
         $nationalMomentum = $this->disabledSignal('National momentum disabled for national predictions');
-        $regionalMomentum = $hasCoordinates
-            ? $this->computeRegionalMomentumSignal($fuelType, $lat, $lng)
-            : $this->disabledSignal('No coordinates provided for regional momentum analysis');
+        $regionalMomentum = $this->regionalMomentumSignal->compute($context);
 
         $signals = compact('trend', 'dayOfWeek', 'brandBehaviour', 'nationalMomentum', 'regionalMomentum', 'stickiness', 'oil');
 
@@ -103,10 +110,12 @@ class NationalFuelPredictionService
     private function getCurrentAverage(FuelType $fuelType, ?float $lat, ?float $lng): float
     {
         if ($lat !== null && $lng !== null) {
+            [$radiusSql, $radiusBindings] = HaversineQuery::withinKm($lat, $lng, 50);
+
             $avg = DB::table('station_prices_current')
                 ->join('stations', 'station_prices_current.station_id', '=', 'stations.node_id')
                 ->where('station_prices_current.fuel_type', $fuelType->value)
-                ->whereRaw('(6371 * acos(LEAST(1.0, cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?)) + sin(radians(?)) * sin(radians(lat))))) <= 50', [$lat, $lng, $lat])
+                ->whereRaw($radiusSql, $radiusBindings)
                 ->avg('station_prices_current.price_pence');
 
             if ($avg !== null) {
@@ -119,367 +128,6 @@ class NationalFuelPredictionService
         return $avg !== null ? round((float) $avg / 100, 1) : 0.0;
     }
 
-    /**
-     * Linear regression on daily national average prices.
-     * Tries 5-day lookback first; falls back to 14-day if R² < threshold.
-     *
-     * @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool, slope: float, r_squared: float}
-     */
-    private function computeTrendSignal(FuelType $fuelType): array
-    {
-        foreach ([5, 14] as $lookbackDays) {
-            $rows = DB::table('station_prices')
-                ->where('fuel_type', $fuelType->value)
-                ->where('price_effective_at', '>=', now()->subDays($lookbackDays))
-                ->selectRaw('DATE(price_effective_at) as day, AVG(price_pence) as avg_price')
-                ->groupBy('day')
-                ->orderBy('day')
-                ->get();
-
-            if ($rows->count() < 2) {
-                continue;
-            }
-
-            $regression = $this->linearRegression($rows->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all());
-
-            if ($regression['r_squared'] >= self::R_SQUARED_THRESHOLD) {
-                $slope = $regression['slope'];
-                $direction = match (true) {
-                    $slope >= self::SLOPE_THRESHOLD_PENCE => 'up',
-                    $slope <= -self::SLOPE_THRESHOLD_PENCE => 'down',
-                    default => 'stable',
-                };
-                $absSlope = abs($slope);
-                $score = $direction === 'stable' ? 0.0 : min(1.0, $absSlope / self::SLOPE_SATURATION_PENCE) * ($slope > 0 ? 1 : -1);
-                $projected = round($slope * $lookbackDays, 1);
-                $detail = $direction === 'stable'
-                    ? "Prices flat over {$lookbackDays} days (slope: {$slope}p/day, R²={$regression['r_squared']})"
-                    : sprintf(
-                        '%s at %sp/day over %d days (R²=%s, ~%s%sp in %dd)',
-                        $slope > 0 ? 'Rising' : 'Falling',
-                        abs(round($slope, 2)),
-                        $lookbackDays,
-                        round($regression['r_squared'], 2),
-                        $projected > 0 ? '+' : '',
-                        $projected,
-                        self::PREDICTION_HORIZON_DAYS,
-                    );
-
-                if ($lookbackDays === 5) {
-                    $detail .= ' [Adaptive lookback active]';
-                }
-
-                return [
-                    'score' => $score,
-                    'confidence' => min(1.0, $regression['r_squared']),
-                    'direction' => $direction,
-                    'detail' => $detail,
-                    'data_points' => $rows->count(),
-                    'enabled' => true,
-                    'slope' => round($slope, 3),
-                    'r_squared' => round($regression['r_squared'], 3),
-                ];
-            }
-        }
-
-        return [
-            'score' => 0.0,
-            'confidence' => 0.0,
-            'direction' => 'stable',
-            'detail' => 'Insufficient price history or noisy data (R² below threshold)',
-            'data_points' => 0,
-            'enabled' => false,
-            'slope' => 0.0,
-            'r_squared' => 0.0,
-        ];
-    }
-
-    /**
-     * Compare today's average price against the per-weekday average over 90 days.
-     * Requires 56+ days of history to activate.
-     *
-     * @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool}
-     */
-    private function computeDayOfWeekSignal(FuelType $fuelType): array
-    {
-        $isSqlite = DB::connection()->getDriverName() === 'sqlite';
-        $dowExpr = $isSqlite
-            ? "(CAST(strftime('%w', price_effective_at) AS INTEGER) + 1)"
-            : 'DAYOFWEEK(price_effective_at)';
-
-        $rows = DB::table('station_prices')
-            ->where('fuel_type', $fuelType->value)
-            ->where('price_effective_at', '>=', now()->subDays(90))
-            ->selectRaw("{$dowExpr} as dow, DATE(price_effective_at) as day, AVG(price_pence) as avg_price")
-            ->groupBy('dow', 'day')
-            ->get();
-
-        $uniqueDays = $rows->pluck('day')->unique()->count();
-
-        if ($uniqueDays < self::DAY_OF_WEEK_MIN_DAYS) {
-            return $this->disabledSignal("Insufficient history for day-of-week pattern ({$uniqueDays} days, need ".self::DAY_OF_WEEK_MIN_DAYS.')');
-        }
-
-        $dowAverages = $rows->groupBy('dow')->map(fn ($g) => $g->avg('avg_price'));
-        $weekAvg = $dowAverages->avg();
-        $todayDow = (int) now()->format('w') + 1; // PHP 0=Sun → MySQL 1=Sun
-        $todayAvg = $dowAverages->get($todayDow, $weekAvg);
-        $cheapestDow = $dowAverages->keys()->sortBy(fn ($k) => $dowAverages[$k])->first();
-        $dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
-        $todayName = $dayNames[($todayDow - 1) % 7] ?? 'Today';
-        $tomorrowName = $dayNames[$todayDow % 7] ?? 'Tomorrow';
-
-        $todayDeltaPence = round(($todayAvg - $weekAvg) / 100, 1);
-        $tomorrowDeltaPence = round(($dowAverages->get(($todayDow % 7) + 1, $weekAvg) - $todayAvg) / 100, 1);
-
-        $direction = match (true) {
-            ($todayAvg - $weekAvg) / 100 >= 1.5 => 'up',
-            ($weekAvg - $todayAvg) / 100 >= 1.5 => 'down',
-            default => 'stable',
-        };
-
-        $score = $direction === 'stable' ? 0.0 : ($direction === 'up' ? 1.0 : -1.0);
-
-        $parts = [];
-        $parts[] = abs($todayDeltaPence) < 0.1
-            ? "Today ({$todayName}) is typically in line with the weekly average."
-            : sprintf(
-                'Today (%s) is typically %sp %s the weekly average.',
-                $todayName,
-                number_format(abs($todayDeltaPence), 1),
-                $todayDeltaPence > 0 ? 'above' : 'below',
-            );
-
-        $parts[] = abs($tomorrowDeltaPence) < 0.1
-            ? "Tomorrow ({$tomorrowName}) is typically the same."
-            : sprintf(
-                'Tomorrow (%s) is typically %sp %s.',
-                $tomorrowName,
-                number_format(abs($tomorrowDeltaPence), 1),
-                $tomorrowDeltaPence < 0 ? 'cheaper' : 'pricier',
-            );
-
-        if ($cheapestDow === $todayDow) {
-            $parts[] = 'Today is historically the cheapest day of the week.';
-        }
-
-        return [
-            'score' => $score,
-            'confidence' => min(1.0, $uniqueDays / 90),
-            'direction' => $direction,
-            'detail' => implode(' ', $parts),
-            'data_points' => $uniqueDays,
-            'enabled' => true,
-        ];
-    }
-
-    /**
-     * Compare supermarket vs non-supermarket 7-day price trend.
-     * Detects divergence where one group has moved but the other hasn't yet.
-     *
-     * @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool}
-     */
-    private function computeBrandBehaviourSignal(FuelType $fuelType): array
-    {
-        $rows = DB::table('station_prices')
-            ->join('stations', 'station_prices.station_id', '=', 'stations.node_id')
-            ->where('station_prices.fuel_type', $fuelType->value)
-            ->where('station_prices.price_effective_at', '>=', now()->subDays(7))
-            ->selectRaw('stations.is_supermarket, DATE(station_prices.price_effective_at) as day, AVG(station_prices.price_pence) as avg_price')
-            ->groupBy('stations.is_supermarket', 'day')
-            ->orderBy('day')
-            ->get();
-
-        $supermarket = $rows->where('is_supermarket', 1)->values();
-        $major = $rows->where('is_supermarket', 0)->values();
-
-        if ($supermarket->count() < 2 || $major->count() < 2) {
-            return $this->disabledSignal('Insufficient brand data for comparison');
-        }
-
-        $supermarketSlope = $this->linearRegression($supermarket->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all())['slope'];
-        $majorSlope = $this->linearRegression($major->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all())['slope'];
-
-        $divergence = round(abs($supermarketSlope - $majorSlope) * 7, 1);
-        $supermarketChange = round($supermarketSlope * 7, 1);
-        $majorChange = round($majorSlope * 7, 1);
-
-        if ($divergence < 1.0) {
-            return [
-                'score' => 0.0,
-                'confidence' => 0.5,
-                'direction' => 'stable',
-                'detail' => 'Supermarkets and majors moving in sync.',
-                'data_points' => $rows->count(),
-                'enabled' => true,
-            ];
-        }
-
-        $leaderChange = abs($supermarketChange) > abs($majorChange) ? $supermarketChange : $majorChange;
-        $direction = $leaderChange > 0 ? 'up' : 'down';
-        $leader = abs($supermarketChange) > abs($majorChange) ? 'Supermarkets' : 'Majors';
-        $follower = $leader === 'Supermarkets' ? 'majors' : 'supermarkets';
-        $leaderAbs = abs($leaderChange);
-        $followerChange = $leader === 'Supermarkets' ? abs($majorChange) : abs($supermarketChange);
-
-        return [
-            'score' => $direction === 'up' ? 1.0 : -1.0,
-            'confidence' => min(1.0, $divergence / 5.0),
-            'direction' => $direction,
-            'detail' => "{$leader} ".($leaderChange > 0 ? 'rose' : 'fell')." {$leaderAbs}p vs {$follower} {$followerChange}p (divergence: {$divergence}p). Expect {$follower} to follow.",
-            'data_points' => $rows->count(),
-            'enabled' => true,
-        ];
-    }
-
-    /**
-     * Average hold duration (days between price changes) as a confidence modifier.
-     * Requires 30+ days of history. Returns a score between -0.1 and +0.1.
-     *
-     * @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool}
-     */
-    private function computeStickinessSignal(FuelType $fuelType): array
-    {
-        $isSqlite = DB::connection()->getDriverName() === 'sqlite';
-        $diffExpr = $isSqlite
-            ? 'CAST((julianday(MAX(price_effective_at)) - julianday(MIN(price_effective_at))) AS INTEGER)'
-            : 'DATEDIFF(MAX(price_effective_at), MIN(price_effective_at))';
-
-        $rows = DB::table('station_prices')
-            ->where('fuel_type', $fuelType->value)
-            ->where('price_effective_at', '>=', now()->subDays(30))
-            ->selectRaw("station_id, COUNT(*) as changes, {$diffExpr} as span_days")
-            ->groupBy('station_id')
-            ->having('changes', '>', 1)
-            ->having('span_days', '>', 0)
-            ->get();
-
-        if ($rows->count() < 10) {
-            return $this->disabledSignal('Insufficient stickiness data (need 10+ stations with price history)');
-        }
-
-        $avgHoldDays = $rows->avg(fn ($r) => $r->span_days / ($r->changes - 1));
-        $avgHoldDays = round((float) $avgHoldDays, 1);
-
-        $score = match (true) {
-            $avgHoldDays < 2 => -0.1,
-            $avgHoldDays > 5 => 0.1,
-            default => 0.0,
-        };
-
-        $detail = match (true) {
-            $avgHoldDays < 2 => "Volatile prices (avg hold: {$avgHoldDays} days) — harder to predict.",
-            $avgHoldDays > 5 => "Sticky prices (avg hold: {$avgHoldDays} days) — more predictable.",
-            default => "Normal hold period (avg: {$avgHoldDays} days).",
-        };
-
-        return [
-            'score' => $score,
-            'confidence' => min(1.0, $rows->count() / 200),
-            'direction' => 'stable',
-            'detail' => $detail,
-            'data_points' => $rows->count(),
-            'enabled' => true,
-        ];
-    }
-
-    /**
-     * Placeholder for regional momentum signal (requires lat/lng).
-     * Compares local station prices vs national average trend.
-     *
-     * @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool}
-     */
-    private function computeRegionalMomentumSignal(FuelType $fuelType, float $lat, float $lng): array
-    {
-        // Regional momentum: compare trend of stations within 50km vs national trend
-        $rows = DB::table('station_prices')
-            ->join('stations', 'station_prices.station_id', '=', 'stations.node_id')
-            ->where('station_prices.fuel_type', $fuelType->value)
-            ->where('station_prices.price_effective_at', '>=', now()->subDays(14))
-            ->whereRaw('(6371 * acos(CASE WHEN (cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?)) + sin(radians(?)) * sin(radians(lat))) > 1.0 THEN 1.0 ELSE (cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?)) + sin(radians(?)) * sin(radians(lat))) END)) <= 50', [$lat, $lng, $lat, $lat, $lng, $lat])
-            ->selectRaw('DATE(station_prices.price_effective_at) as day, AVG(station_prices.price_pence) as avg_price')
-            ->groupBy('day')
-            ->orderBy('day')
-            ->get();
-
-        if ($rows->count() < 3) {
-            return $this->disabledSignal('Insufficient regional data');
-        }
-
-        $regionalRegression = $this->linearRegression($rows->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all());
-        $direction = match (true) {
-            $regionalRegression['slope'] >= self::SLOPE_THRESHOLD_PENCE => 'up',
-            $regionalRegression['slope'] <= -self::SLOPE_THRESHOLD_PENCE => 'down',
-            default => 'stable',
-        };
-
-        return [
-            'score' => $direction === 'stable' ? 0.0 : ($direction === 'up' ? 0.7 : -0.7),
-            'confidence' => min(1.0, $regionalRegression['r_squared']),
-            'direction' => $direction,
-            'detail' => 'Regional trend: '.round($regionalRegression['slope'], 2).'p/day (R²='.round($regionalRegression['r_squared'], 2).')',
-            'data_points' => $rows->count(),
-            'enabled' => true,
-        ];
-    }
-
-    /**
-     * Reads the most recent Brent crude prediction (LLM preferred, EWMA fallback)
-     * covering today or later. Sourced from price_predictions, which OilPriceService
-     * populates daily.
-     *
-     * @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool}
-     */
-    private function computeOilSignal(): array
-    {
-        $prediction = null;
-
-        foreach (['llm_with_context', 'llm', 'ewma'] as $source) {
-            $prediction = DB::table('price_predictions')
-                ->where('source', $source)
-                ->where('predicted_for', '>=', now()->toDateString())
-                ->orderByDesc('predicted_for')
-                ->orderByDesc('generated_at')
-                ->first();
-
-            if ($prediction !== null) {
-                break;
-            }
-        }
-
-        if ($prediction === null) {
-            return $this->disabledSignal('No oil price prediction available');
-        }
-
-        $direction = match ($prediction->direction) {
-            'rising' => 'up',
-            'falling' => 'down',
-            default => 'stable',
-        };
-
-        $score = match ($direction) {
-            'up' => 1.0,
-            'down' => -1.0,
-            default => 0.0,
-        };
-
-        $confidence = round(((float) $prediction->confidence) / 100, 2);
-
-        return [
-            'score' => $score,
-            'confidence' => $confidence,
-            'direction' => $direction,
-            'detail' => sprintf(
-                'Brent crude %s (%s, %d%% confidence)',
-                $prediction->direction,
-                $prediction->source,
-                (int) $prediction->confidence,
-            ),
-            'data_points' => 1,
-            'enabled' => true,
-        ];
-    }
-
     /** @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool} */
     private function disabledSignal(string $detail): array
     {
@@ -668,11 +316,13 @@ class NationalFuelPredictionService
         $dateString = $date->toDateString();
 
         if ($lat !== null && $lng !== null) {
+            [$radiusSql, $radiusBindings] = HaversineQuery::withinKm($lat, $lng, 50);
+
             $regional = DB::table('station_prices')
                 ->join('stations', 'station_prices.station_id', '=', 'stations.node_id')
                 ->where('station_prices.fuel_type', $fuelType->value)
                 ->whereDate('station_prices.price_effective_at', $dateString)
-                ->whereRaw('(6371 * acos(LEAST(1.0, cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?)) + sin(radians(?)) * sin(radians(lat))))) <= 50', [$lat, $lng, $lat])
+                ->whereRaw($radiusSql, $radiusBindings)
                 ->avg('station_prices.price_pence');
 
             if ($regional !== null) {
@@ -697,11 +347,13 @@ class NationalFuelPredictionService
         $usedRegional = false;
 
         if ($lat !== null && $lng !== null) {
+            [$radiusSql, $radiusBindings] = HaversineQuery::withinKm($lat, $lng, 50);
+
             $rows = DB::table('station_prices')
                 ->join('stations', 'station_prices.station_id', '=', 'stations.node_id')
                 ->where('station_prices.fuel_type', $fuelType->value)
                 ->where('station_prices.price_effective_at', '>=', now()->subDays($days)->startOfDay())
-                ->whereRaw('(6371 * acos(LEAST(1.0, cos(radians(?)) * cos(radians(lat)) * cos(radians(lng) - radians(?)) + sin(radians(?)) * sin(radians(lat))))) <= 50', [$lat, $lng, $lat])
+                ->whereRaw($radiusSql, $radiusBindings)
                 ->selectRaw('DATE(station_prices.price_effective_at) as day, AVG(station_prices.price_pence) as avg_price')
                 ->groupBy('day')
                 ->orderBy('day')
@@ -728,47 +380,6 @@ class NationalFuelPredictionService
         return [$series, $usedRegional];
     }
 
-    /**
-     * Least-squares linear regression.
-     * x is the array index (day number), y is the price value.
-     *
-     * @param  float[]  $values
-     * @return array{slope: float, r_squared: float}
-     */
-    private function linearRegression(array $values): array
-    {
-        $n = count($values);
-        if ($n < 2) {
-            return ['slope' => 0.0, 'r_squared' => 0.0];
-        }
-
-        $xMean = ($n - 1) / 2.0;
-        $yMean = array_sum($values) / $n;
-
-        $numerator = 0.0;
-        $denominator = 0.0;
-
-        foreach ($values as $i => $y) {
-            $x = $i - $xMean;
-            $numerator += $x * ($y - $yMean);
-            $denominator += $x * $x;
-        }
-
-        $slope = $denominator > 0.0 ? $numerator / $denominator : 0.0;
-
-        $ssRes = 0.0;
-        $ssTot = 0.0;
-        foreach ($values as $i => $y) {
-            $predicted = $yMean + $slope * ($i - $xMean);
-            $ssRes += ($y - $predicted) ** 2;
-            $ssTot += ($y - $yMean) ** 2;
-        }
-
-        $rSquared = $ssTot > 0.0 ? max(0.0, 1.0 - ($ssRes / $ssTot)) : 0.0;
-
-        return ['slope' => $slope, 'r_squared' => $rSquared];
-    }
-
     /**
      * @param  array{enabled: bool, detail: string, direction: string}  $trend
      * @param  array{enabled: bool, detail: string, direction: string}  $brandBehaviour

app/Services/Prediction/Signals/AbstractSignal.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+abstract class AbstractSignal implements Signal
+{
+    /** @return array{score: 0.0, confidence: 0.0, direction: 'stable', detail: string, data_points: 0, enabled: false} */
+    protected function disabledSignal(string $detail): array
+    {
+        return [
+            'score' => 0.0,
+            'confidence' => 0.0,
+            'direction' => 'stable',
+            'detail' => $detail,
+            'data_points' => 0,
+            'enabled' => false,
+        ];
+    }
+
+    /**
+     * Least-squares linear regression. x = array index, y = value.
+     *
+     * @param  float[]  $values
+     * @return array{slope: float, r_squared: float}
+     */
+    protected function linearRegression(array $values): array
+    {
+        $n = count($values);
+
+        if ($n < 2) {
+            return ['slope' => 0.0, 'r_squared' => 0.0];
+        }
+
+        $xMean = ($n - 1) / 2.0;
+        $yMean = array_sum($values) / $n;
+
+        $numerator = 0.0;
+        $denominator = 0.0;
+
+        foreach ($values as $i => $y) {
+            $x = $i - $xMean;
+            $numerator += $x * ($y - $yMean);
+            $denominator += $x * $x;
+        }
+
+        $slope = $denominator > 0.0 ? $numerator / $denominator : 0.0;
+
+        $ssRes = 0.0;
+        $ssTot = 0.0;
+
+        foreach ($values as $i => $y) {
+            $predicted = $yMean + $slope * ($i - $xMean);
+            $ssRes += ($y - $predicted) ** 2;
+            $ssTot += ($y - $yMean) ** 2;
+        }
+
+        $rSquared = $ssTot > 0.0 ? max(0.0, 1.0 - ($ssRes / $ssTot)) : 0.0;
+
+        return ['slope' => $slope, 'r_squared' => $rSquared];
+    }
+}

app/Services/Prediction/Signals/BrandBehaviourSignal.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use Illuminate\Support\Facades\DB;
+
+final class BrandBehaviourSignal extends AbstractSignal
+{
+    public function compute(SignalContext $context): array
+    {
+        $rows = DB::table('station_prices')
+            ->join('stations', 'station_prices.station_id', '=', 'stations.node_id')
+            ->where('station_prices.fuel_type', $context->fuelType->value)
+            ->where('station_prices.price_effective_at', '>=', now()->subDays(7))
+            ->selectRaw('stations.is_supermarket, DATE(station_prices.price_effective_at) as day, AVG(station_prices.price_pence) as avg_price')
+            ->groupBy('stations.is_supermarket', 'day')
+            ->orderBy('day')
+            ->get();
+
+        $supermarket = $rows->where('is_supermarket', 1)->values();
+        $major = $rows->where('is_supermarket', 0)->values();
+
+        if ($supermarket->count() < 2 || $major->count() < 2) {
+            return $this->disabledSignal('Insufficient brand data for comparison');
+        }
+
+        $supermarketSlope = $this->linearRegression($supermarket->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all())['slope'];
+        $majorSlope = $this->linearRegression($major->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all())['slope'];
+
+        $divergence = round(abs($supermarketSlope - $majorSlope) * 7, 1);
+        $supermarketChange = round($supermarketSlope * 7, 1);
+        $majorChange = round($majorSlope * 7, 1);
+
+        if ($divergence < 1.0) {
+            return [
+                'score' => 0.0,
+                'confidence' => 0.5,
+                'direction' => 'stable',
+                'detail' => 'Supermarkets and majors moving in sync.',
+                'data_points' => $rows->count(),
+                'enabled' => true,
+            ];
+        }
+
+        $leaderChange = abs($supermarketChange) > abs($majorChange) ? $supermarketChange : $majorChange;
+        $direction = $leaderChange > 0 ? 'up' : 'down';
+        $leader = abs($supermarketChange) > abs($majorChange) ? 'Supermarkets' : 'Majors';
+        $follower = $leader === 'Supermarkets' ? 'majors' : 'supermarkets';
+        $leaderAbs = abs($leaderChange);
+        $followerChange = $leader === 'Supermarkets' ? abs($majorChange) : abs($supermarketChange);
+
+        return [
+            'score' => $direction === 'up' ? 1.0 : -1.0,
+            'confidence' => min(1.0, $divergence / 5.0),
+            'direction' => $direction,
+            'detail' => "{$leader} ".($leaderChange > 0 ? 'rose' : 'fell')." {$leaderAbs}p vs {$follower} {$followerChange}p (divergence: {$divergence}p). Expect {$follower} to follow.",
+            'data_points' => $rows->count(),
+            'enabled' => true,
+        ];
+    }
+}

app/Services/Prediction/Signals/DayOfWeekSignal.php

@@ -0,0 +1,80 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use Illuminate\Support\Facades\DB;
+
+final class DayOfWeekSignal extends AbstractSignal
+{
+    private const int MIN_DAYS = 21;
+
+    public function compute(SignalContext $context): array
+    {
+        $dowExpr = DbDialect::dayOfWeekExpr('price_effective_at');
+
+        $rows = DB::table('station_prices')
+            ->where('fuel_type', $context->fuelType->value)
+            ->where('price_effective_at', '>=', now()->subDays(90))
+            ->selectRaw("{$dowExpr} as dow, DATE(price_effective_at) as day, AVG(price_pence) as avg_price")
+            ->groupBy('dow', 'day')
+            ->get();
+
+        $uniqueDays = $rows->pluck('day')->unique()->count();
+
+        if ($uniqueDays < self::MIN_DAYS) {
+            return $this->disabledSignal("Insufficient history for day-of-week pattern ({$uniqueDays} days, need ".self::MIN_DAYS.')');
+        }
+
+        $dowAverages = $rows->groupBy('dow')->map(fn ($g) => $g->avg('avg_price'));
+        $weekAvg = $dowAverages->avg();
+        $todayDow = (int) now()->format('w') + 1; // PHP 0=Sun → MySQL 1=Sun
+        $todayAvg = $dowAverages->get($todayDow, $weekAvg);
+        $cheapestDow = $dowAverages->keys()->sortBy(fn ($k) => $dowAverages[$k])->first();
+        $dayNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+        $todayName = $dayNames[($todayDow - 1) % 7] ?? 'Today';
+        $tomorrowName = $dayNames[$todayDow % 7] ?? 'Tomorrow';
+
+        $todayDeltaPence = round(($todayAvg - $weekAvg) / 100, 1);
+        $tomorrowDeltaPence = round(($dowAverages->get(($todayDow % 7) + 1, $weekAvg) - $todayAvg) / 100, 1);
+
+        $direction = match (true) {
+            ($todayAvg - $weekAvg) / 100 >= 1.5 => 'up',
+            ($weekAvg - $todayAvg) / 100 >= 1.5 => 'down',
+            default => 'stable',
+        };
+
+        $score = $direction === 'stable' ? 0.0 : ($direction === 'up' ? 1.0 : -1.0);
+
+        $parts = [];
+        $parts[] = abs($todayDeltaPence) < 0.1
+            ? "Today ({$todayName}) is typically in line with the weekly average."
+            : sprintf(
+                'Today (%s) is typically %sp %s the weekly average.',
+                $todayName,
+                number_format(abs($todayDeltaPence), 1),
+                $todayDeltaPence > 0 ? 'above' : 'below',
+            );
+
+        $parts[] = abs($tomorrowDeltaPence) < 0.1
+            ? "Tomorrow ({$tomorrowName}) is typically the same."
+            : sprintf(
+                'Tomorrow (%s) is typically %sp %s.',
+                $tomorrowName,
+                number_format(abs($tomorrowDeltaPence), 1),
+                $tomorrowDeltaPence < 0 ? 'cheaper' : 'pricier',
+            );
+
+        if ($cheapestDow === $todayDow) {
+            $parts[] = 'Today is historically the cheapest day of the week.';
+        }
+
+        return [
+            'score' => $score,
+            'confidence' => min(1.0, $uniqueDays / 90),
+            'direction' => $direction,
+            'detail' => implode(' ', $parts),
+            'data_points' => $uniqueDays,
+            'enabled' => true,
+        ];
+    }
+}

app/Services/Prediction/Signals/DbDialect.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use Illuminate\Support\Facades\DB;
+
+/**
+ * SQL dialect helpers for the small set of MySQL/SQLite differences the
+ * signal classes care about. Centralises the isSqlite ternaries that were
+ * duplicated across DayOfWeekSignal and StickinessSignal.
+ */
+final class DbDialect
+{
+    private static function isSqlite(): bool
+    {
+        return DB::connection()->getDriverName() === 'sqlite';
+    }
+
+    /**
+     * Day-of-week expression returning 1=Sun..7=Sat (MySQL DAYOFWEEK convention).
+     * Targets a column on the queried table.
+     */
+    public static function dayOfWeekExpr(string $column): string
+    {
+        return self::isSqlite()
+            ? "(CAST(strftime('%w', {$column}) AS INTEGER) + 1)"
+            : "DAYOFWEEK({$column})";
+    }
+
+    /**
+     * Whole-day difference between MAX and MIN of a datetime column, suitable
+     * for use in an aggregate selectRaw.
+     */
+    public static function maxMinDayDiffExpr(string $column): string
+    {
+        return self::isSqlite()
+            ? "CAST((julianday(MAX({$column})) - julianday(MIN({$column}))) AS INTEGER)"
+            : "DATEDIFF(MAX({$column}), MIN({$column}))";
+    }
+}

app/Services/Prediction/Signals/OilSignal.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use Illuminate\Support\Facades\DB;
+
+final class OilSignal extends AbstractSignal
+{
+    /**
+     * Reads the most recent Brent crude prediction (LLM preferred, EWMA
+     * fallback) covering today or later. Sourced from price_predictions,
+     * which OilPriceService populates daily.
+     */
+    public function compute(SignalContext $context): array
+    {
+        $prediction = null;
+
+        foreach (['llm_with_context', 'llm', 'ewma'] as $source) {
+            $prediction = DB::table('price_predictions')
+                ->where('source', $source)
+                ->where('predicted_for', '>=', now()->toDateString())
+                ->orderByDesc('predicted_for')
+                ->orderByDesc('generated_at')
+                ->first();
+
+            if ($prediction !== null) {
+                break;
+            }
+        }
+
+        if ($prediction === null) {
+            return $this->disabledSignal('No oil price prediction available');
+        }
+
+        $direction = match ($prediction->direction) {
+            'rising' => 'up',
+            'falling' => 'down',
+            default => 'stable',
+        };
+
+        $score = match ($direction) {
+            'up' => 1.0,
+            'down' => -1.0,
+            default => 0.0,
+        };
+
+        $confidence = round(((float) $prediction->confidence) / 100, 2);
+
+        return [
+            'score' => $score,
+            'confidence' => $confidence,
+            'direction' => $direction,
+            'detail' => sprintf(
+                'Brent crude %s (%s, %d%% confidence)',
+                $prediction->direction,
+                $prediction->source,
+                (int) $prediction->confidence,
+            ),
+            'data_points' => 1,
+            'enabled' => true,
+        ];
+    }
+}

app/Services/Prediction/Signals/RegionalMomentumSignal.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use App\Services\HaversineQuery;
+use Illuminate\Support\Facades\DB;
+
+final class RegionalMomentumSignal extends AbstractSignal
+{
+    private const float SLOPE_THRESHOLD_PENCE = 0.3;
+
+    private const float REGIONAL_RADIUS_KM = 50.0;
+
+    public function compute(SignalContext $context): array
+    {
+        if (! $context->hasCoordinates()) {
+            return $this->disabledSignal('No coordinates provided for regional momentum analysis');
+        }
+
+        [$radiusSql, $radiusBindings] = HaversineQuery::withinKm($context->lat, $context->lng, self::REGIONAL_RADIUS_KM);
+
+        $rows = DB::table('station_prices')
+            ->join('stations', 'station_prices.station_id', '=', 'stations.node_id')
+            ->where('station_prices.fuel_type', $context->fuelType->value)
+            ->where('station_prices.price_effective_at', '>=', now()->subDays(14))
+            ->whereRaw($radiusSql, $radiusBindings)
+            ->selectRaw('DATE(station_prices.price_effective_at) as day, AVG(station_prices.price_pence) as avg_price')
+            ->groupBy('day')
+            ->orderBy('day')
+            ->get();
+
+        if ($rows->count() < 3) {
+            return $this->disabledSignal('Insufficient regional data');
+        }
+
+        $regression = $this->linearRegression($rows->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all());
+        $direction = match (true) {
+            $regression['slope'] >= self::SLOPE_THRESHOLD_PENCE => 'up',
+            $regression['slope'] <= -self::SLOPE_THRESHOLD_PENCE => 'down',
+            default => 'stable',
+        };
+
+        return [
+            'score' => $direction === 'stable' ? 0.0 : ($direction === 'up' ? 0.7 : -0.7),
+            'confidence' => min(1.0, $regression['r_squared']),
+            'direction' => $direction,
+            'detail' => 'Regional trend: '.round($regression['slope'], 2).'p/day (R²='.round($regression['r_squared'], 2).')',
+            'data_points' => $rows->count(),
+            'enabled' => true,
+        ];
+    }
+}

app/Services/Prediction/Signals/Signal.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+interface Signal
+{
+    /**
+     * Evaluate the signal against the given context.
+     *
+     * Returns the canonical signal payload. Implementations may add extra
+     * keys beyond the base shape (e.g. trend adds slope + r_squared).
+     *
+     * @return array{
+     *     score: float,
+     *     confidence: float,
+     *     direction: string,
+     *     detail: string,
+     *     data_points: int,
+     *     enabled: bool,
+     *     ...
+     * }
+     */
+    public function compute(SignalContext $context): array;
+}

app/Services/Prediction/Signals/SignalContext.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use App\Enums\FuelType;
+
+/**
+ * Inputs required to evaluate a prediction signal. Individual signals may
+ * ignore fields they don't need — for example OilSignal doesn't use fuelType,
+ * RegionalMomentumSignal requires lat/lng to be non-null.
+ */
+final readonly class SignalContext
+{
+    public function __construct(
+        public FuelType $fuelType,
+        public ?float $lat = null,
+        public ?float $lng = null,
+    ) {}
+
+    public function hasCoordinates(): bool
+    {
+        return $this->lat !== null && $this->lng !== null;
+    }
+}

app/Services/Prediction/Signals/StickinessSignal.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use Illuminate\Support\Facades\DB;
+
+final class StickinessSignal extends AbstractSignal
+{
+    public function compute(SignalContext $context): array
+    {
+        $diffExpr = DbDialect::maxMinDayDiffExpr('price_effective_at');
+
+        $rows = DB::table('station_prices')
+            ->where('fuel_type', $context->fuelType->value)
+            ->where('price_effective_at', '>=', now()->subDays(30))
+            ->selectRaw("station_id, COUNT(*) as changes, {$diffExpr} as span_days")
+            ->groupBy('station_id')
+            ->having('changes', '>', 1)
+            ->having('span_days', '>', 0)
+            ->get();
+
+        if ($rows->count() < 10) {
+            return $this->disabledSignal('Insufficient stickiness data (need 10+ stations with price history)');
+        }
+
+        $avgHoldDays = $rows->avg(fn ($r) => $r->span_days / ($r->changes - 1));
+        $avgHoldDays = round((float) $avgHoldDays, 1);
+
+        $score = match (true) {
+            $avgHoldDays < 2 => -0.1,
+            $avgHoldDays > 5 => 0.1,
+            default => 0.0,
+        };
+
+        $detail = match (true) {
+            $avgHoldDays < 2 => "Volatile prices (avg hold: {$avgHoldDays} days) — harder to predict.",
+            $avgHoldDays > 5 => "Sticky prices (avg hold: {$avgHoldDays} days) — more predictable.",
+            default => "Normal hold period (avg: {$avgHoldDays} days).",
+        };
+
+        return [
+            'score' => $score,
+            'confidence' => min(1.0, $rows->count() / 200),
+            'direction' => 'stable',
+            'detail' => $detail,
+            'data_points' => $rows->count(),
+            'enabled' => true,
+        ];
+    }
+}

app/Services/Prediction/Signals/TrendSignal.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Services\Prediction\Signals;
+
+use Illuminate\Support\Facades\DB;
+
+final class TrendSignal extends AbstractSignal
+{
+    private const float R_SQUARED_THRESHOLD = 0.5;
+
+    private const float SLOPE_THRESHOLD_PENCE = 0.3;
+
+    private const float SLOPE_SATURATION_PENCE = 0.5;
+
+    private const int PREDICTION_HORIZON_DAYS = 7;
+
+    /** @return array{score: float, confidence: float, direction: string, detail: string, data_points: int, enabled: bool, slope: float, r_squared: float} */
+    public function compute(SignalContext $context): array
+    {
+        foreach ([5, 14] as $lookbackDays) {
+            $rows = DB::table('station_prices')
+                ->where('fuel_type', $context->fuelType->value)
+                ->where('price_effective_at', '>=', now()->subDays($lookbackDays))
+                ->selectRaw('DATE(price_effective_at) as day, AVG(price_pence) as avg_price')
+                ->groupBy('day')
+                ->orderBy('day')
+                ->get();
+
+            if ($rows->count() < 2) {
+                continue;
+            }
+
+            $regression = $this->linearRegression($rows->pluck('avg_price')->map(fn ($v) => (float) $v / 100)->values()->all());
+
+            if ($regression['r_squared'] >= self::R_SQUARED_THRESHOLD) {
+                $slope = $regression['slope'];
+                $direction = match (true) {
+                    $slope >= self::SLOPE_THRESHOLD_PENCE => 'up',
+                    $slope <= -self::SLOPE_THRESHOLD_PENCE => 'down',
+                    default => 'stable',
+                };
+                $absSlope = abs($slope);
+                $score = $direction === 'stable' ? 0.0 : min(1.0, $absSlope / self::SLOPE_SATURATION_PENCE) * ($slope > 0 ? 1 : -1);
+                $projected = round($slope * $lookbackDays, 1);
+                $detail = $direction === 'stable'
+                    ? "Prices flat over {$lookbackDays} days (slope: {$slope}p/day, R²={$regression['r_squared']})"
+                    : sprintf(
+                        '%s at %sp/day over %d days (R²=%s, ~%s%sp in %dd)',
+                        $slope > 0 ? 'Rising' : 'Falling',
+                        abs(round($slope, 2)),
+                        $lookbackDays,
+                        round($regression['r_squared'], 2),
+                        $projected > 0 ? '+' : '',
+                        $projected,
+                        self::PREDICTION_HORIZON_DAYS,
+                    );
+
+                if ($lookbackDays === 5) {
+                    $detail .= ' [Adaptive lookback active]';
+                }
+
+                return [
+                    'score' => $score,
+                    'confidence' => min(1.0, $regression['r_squared']),
+                    'direction' => $direction,
+                    'detail' => $detail,
+                    'data_points' => $rows->count(),
+                    'enabled' => true,
+                    'slope' => round($slope, 3),
+                    'r_squared' => round($regression['r_squared'], 3),
+                ];
+            }
+        }
+
+        return [
+            'score' => 0.0,
+            'confidence' => 0.0,
+            'direction' => 'stable',
+            'detail' => 'Insufficient price history or noisy data (R² below threshold)',
+            'data_points' => 0,
+            'enabled' => false,
+            'slope' => 0.0,
+            'r_squared' => 0.0,
+        ];
+    }
+}

app/Services/StationSearch/SearchCriteria.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Services\StationSearch;
+
+use App\Enums\FuelType;
+
+final readonly class SearchCriteria
+{
+    public function __construct(
+        public float $lat,
+        public float $lng,
+        public FuelType $fuelType,
+        public float $radiusKm,
+        public string $sort,
+    ) {}
+}

app/Services/StationSearch/SearchResult.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services\StationSearch;
+
+use Illuminate\Support\Collection;
+
+final readonly class SearchResult
+{
+    /**
+     * @param  Collection<int, mixed>  $stations  Sorted station rows with _updated_at/_reliability/_classification cached
+     * @param  array{lowest: ?int, highest: ?int, avg: ?float}  $pricesSummary
+     * @param  array{reliable: int, stale: int, outdated: int}  $reliabilityCounts
+     * @param  array<string, mixed>  $prediction
+     */
+    public function __construct(
+        public Collection $stations,
+        public array $pricesSummary,
+        public array $reliabilityCounts,
+        public array $prediction,
+    ) {}
+}

app/Services/StationSearch/StationSearchService.php

@@ -0,0 +1,151 @@
+<?php
+
+namespace App\Services\StationSearch;
+
+use App\Enums\PriceClassification;
+use App\Enums\PriceReliability;
+use App\Models\Search;
+use App\Models\Station;
+use App\Models\User;
+use App\Services\HaversineQuery;
+use App\Services\NationalFuelPredictionService;
+use App\Services\PlanFeatures;
+use Illuminate\Database\Query\JoinClause;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+
+final class StationSearchService
+{
+    public function __construct(
+        private readonly NationalFuelPredictionService $predictionService,
+    ) {}
+
+    public function search(SearchCriteria $criteria, ?User $user, ?string $ipHash): SearchResult
+    {
+        $stations = $this->fetchAndSortStations($criteria);
+        $prices = $stations->pluck('price_pence');
+
+        $this->logSearch($criteria, $stations->count(), $prices, $ipHash);
+
+        return new SearchResult(
+            stations: $stations,
+            pricesSummary: [
+                'lowest' => $prices->min(),
+                'highest' => $prices->max(),
+                'avg' => $prices->isNotEmpty() ? round($prices->avg(), 2) : null,
+            ],
+            reliabilityCounts: $this->countReliability($stations),
+            prediction: $this->buildPrediction($user, $criteria),
+        );
+    }
+
+    /** @return Collection<int, mixed> */
+    private function fetchAndSortStations(SearchCriteria $criteria): Collection
+    {
+        [$distanceSql, $distanceBindings] = HaversineQuery::distanceKm($criteria->lat, $criteria->lng);
+
+        $all = Station::query()
+            ->selectRaw(
+                "stations.*, spc.price_pence, spc.fuel_type, spc.price_effective_at, {$distanceSql} AS distance_km",
+                $distanceBindings,
+            )
+            ->join('station_prices_current as spc', function (JoinClause $join) use ($criteria): void {
+                $join->on('stations.node_id', '=', 'spc.station_id')
+                    ->where('spc.fuel_type', '=', $criteria->fuelType->value);
+            })
+            ->where('stations.temporary_closure', false)
+            ->where('stations.permanent_closure', false)
+            ->get();
+
+        // Compute reliability + classification once per row so the sort, the
+        // count groupBy, and the StationResource render all read cached
+        // values instead of re-invoking PriceReliability::fromUpdatedAt.
+        $all->each(function ($s): void {
+            $updatedAt = $s->price_effective_at ? Carbon::parse($s->price_effective_at) : null;
+            $s->_updated_at = $updatedAt;
+            $s->_reliability = PriceReliability::fromUpdatedAt($updatedAt);
+            $s->_classification = PriceClassification::fromUpdatedAt($updatedAt);
+        });
+
+        $filtered = $all->filter(fn ($s) => (float) $s->distance_km <= $criteria->radiusKm);
+
+        return $this->applySort($filtered, $criteria->sort);
+    }
+
+    /**
+     * @param  Collection<int, mixed>  $filtered
+     * @return Collection<int, mixed>
+     */
+    private function applySort(Collection $filtered, string $sort): Collection
+    {
+        if ($sort === 'reliable') {
+            return $filtered
+                ->sort(function ($a, $b) {
+                    return $a->_reliability->weight() <=> $b->_reliability->weight()
+                        ?: ((int) $a->price_pence <=> (int) $b->price_pence)
+                        ?: ((float) $a->distance_km <=> (float) $b->distance_km);
+                })
+                ->values();
+        }
+
+        return $filtered->sortBy(match ($sort) {
+            'price' => fn ($s) => (int) $s->price_pence,
+            'updated' => fn ($s) => $s->price_effective_at ? -strtotime($s->price_effective_at) : PHP_INT_MAX,
+            default => fn ($s) => (float) $s->distance_km,
+        })->values();
+    }
+
+    /**
+     * @param  Collection<int, mixed>  $stations
+     * @return array{reliable: int, stale: int, outdated: int}
+     */
+    private function countReliability(Collection $stations): array
+    {
+        $counts = $stations->groupBy(fn ($s) => $s->_reliability->value)->map->count();
+
+        return [
+            'reliable' => (int) $counts->get(PriceReliability::Reliable->value, 0),
+            'stale' => (int) $counts->get(PriceReliability::Stale->value, 0),
+            'outdated' => (int) $counts->get(PriceReliability::Outdated->value, 0),
+        ];
+    }
+
+    /** @param  Collection<int, mixed>  $prices */
+    private function logSearch(SearchCriteria $criteria, int $resultsCount, Collection $prices, ?string $ipHash): void
+    {
+        Search::create([
+            'lat_bucket' => round($criteria->lat, 2),
+            'lng_bucket' => round($criteria->lng, 2),
+            'fuel_type' => $criteria->fuelType->value,
+            'results_count' => $resultsCount,
+            'lowest_pence' => $prices->min(),
+            'highest_pence' => $prices->max(),
+            'avg_pence' => $prices->isNotEmpty() ? round($prices->avg(), 2) : null,
+            'searched_at' => now(),
+            'ip_hash' => $ipHash ?? hash('sha256', ''),
+        ]);
+    }
+
+    /**
+     * Free/guest users get a stripped teaser; users with the ai_predictions
+     * feature get the full multi-signal payload.
+     *
+     * @return array<string, mixed>
+     */
+    private function buildPrediction(?User $user, SearchCriteria $criteria): array
+    {
+        $result = $this->predictionService->predict($criteria->lat, $criteria->lng);
+
+        $canSeeFull = $user !== null && PlanFeatures::for($user)->can('ai_predictions');
+
+        if (! $canSeeFull) {
+            return [
+                'fuel_type' => $result['fuel_type'],
+                'predicted_direction' => $result['predicted_direction'],
+                'tier_locked' => true,
+            ];
+        }
+
+        return $result;
+    }
+}

config/services.php

@@ -72,6 +72,18 @@ return [
         'api_key' => env('FUELALERT_API_KEY'),
     ],
 
+    'onesignal' => [
+        'app_id' => env('ONESIGNAL_APP_ID'),
+        'api_key' => env('ONESIGNAL_API_KEY'),
+    ],
+
+    'vonage' => [
+        'key' => env('VONAGE_KEY'),
+        'secret' => env('VONAGE_SECRET'),
+        'whatsapp_from' => env('VONAGE_WHATSAPP_FROM'),
+        'sms_from' => env('VONAGE_SMS_FROM', 'FuelAlert'),
+    ],
+
     'stripe' => [
         'prices' => [
             'basic' => [

database/migrations/2026_05_01_112248_create_weekly_pump_prices_table.php

@@ -0,0 +1,32 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('weekly_pump_prices', function (Blueprint $table) {
+            $table->date('date')->primary()->comment('Week starting (Monday) per BEIS publication');
+            $table->unsignedSmallInteger('ulsp_pence')->comment('Petrol pump price × 100');
+            $table->unsignedSmallInteger('ulsd_pence')->comment('Diesel pump price × 100');
+            $table->unsignedSmallInteger('ulsp_duty_pence')->comment('Petrol duty × 100');
+            $table->unsignedSmallInteger('ulsd_duty_pence')->comment('Diesel duty × 100');
+            $table->unsignedTinyInteger('ulsp_vat_pct')->comment('VAT %');
+            $table->unsignedTinyInteger('ulsd_vat_pct')->comment('VAT %');
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('weekly_pump_prices');
+    }
+};

docs/superpowers/specs/2026-05-01-prediction-rebuild-design.md

@@ -0,0 +1,618 @@
+# Prediction Rebuild — Design Spec
+
+## Context
+
+The current prediction service (`NationalFuelPredictionService` + six signal
+classes) produces output the user has repeatedly described as "doesn't make
+sense": headlines that contradict their own reasoning text, weights that
+nobody can defend a number on, and confidence values that aren't grounded in
+any track record. Two earlier docs (`.claude/rules/scoring.md`, `.claude/rules/prediction.md`)
+disagree on the weights of the same signals, which is itself evidence that
+the design has drifted.
+
+This spec replaces the entire prediction stack from scratch around the
+historical data we actually have, with a model whose confidence values are
+calibrated against its own backtested track record.
+
+Goals:
+- A "fill up now or wait?" call honest about uncertainty.
+- Confidence values calibrated against backtested residuals — "70%" actually
+  means "in 7 of every 10 cases like this, the model called direction right".
+- Simple enough to debug a year from now.
+- Remove the six-signal aggregator entirely.
+- Recognise that pump prices, while *measured* weekly by BEIS, can *move* daily
+  during oil shocks (Iran, OPEC surprise cuts, Hormuz disruption). The static
+  weekly forecast must be backed by a daily news/event overlay so we can flag
+  staleness in real time rather than pretend a Monday number is still valid on
+  Thursday after a 6% Brent move.
+
+---
+
+## Inputs (audited 2026-05-01)
+
+| Source | Status | Use in v1 |
+|---|---|---|
+| `weekly_pump_prices` | 435 weeks, all Mondays, 0 outliers, 1 duty change (Mar 2022, 57.95p → 52.95p), VAT stable at 20% | **Foundation** — train Layer 1 |
+| `station_prices_current` | ~7,550 stations × e10, ~7,620 × b7_standard | **Layer 2** — descriptive snapshot |
+| `stations` | 7,747 stations, 1,989 supermarkets, lat/lng | Layer 2 |
+| `station_prices` | 75 days of changes since 2026-01-16, sample mix uneven per day | Not modelled in v1, but **used by the volatility regime detector** as a churn indicator (% stations changing price / day vs 30-day baseline). |
+| `brent_prices` | 30 days only | **Backfilled in Phase 7** (8 years from FRED, single API call). Used as a Brent-move volatility trigger and as fuel for the daily LLM overlay. |
+
+The Fuel Finder API has been confirmed empirically to have **no historical
+archive** — `effective-start-timestamp` is a station-level filter on current
+prices, not a time-window query. Per-station deep history can only accrue
+forward from the date polling started.
+
+---
+
+## Architecture — five thin layers
+
+### Layer 1 — National weekly forecaster (predictive, calibrated)
+
+Trained once weekly on `weekly_pump_prices`. Output:
+
+- `direction ∈ {rising, falling, flat}`
+- `magnitude_pence` — predicted Δ price next week
+- `ridge_confidence` (0–100) — calibrated from backtested residuals, not
+  from the model's raw output
+
+This is the **quantitative baseline**. It updates only when the BEIS Monday
+publication arrives (so the *forecast itself* changes weekly), but its
+*displayed confidence* (Layer 3) is adjusted in real time by Layers 4 and 5.
+
+`direction = flat` whenever `|magnitude_pence| < FLAT_THRESHOLD`. Phase 3
+picks `FLAT_THRESHOLD` from the backtest residual distribution; the
+starting value is **0.2p / litre**.
+
+### Layer 2 — Local snapshot (descriptive, NOT predictive)
+
+Pure SQL aggregates against `station_prices_current` + Haversine on
+`stations.lat/lng`. No ML, no history, no surprises:
+
+- `local_avg_50km(fuel_type, lat, lng)`
+- `national_avg(fuel_type)`
+- `cheapest_within(km, fuel_type, lat, lng)`
+- `supermarket_avg_local`, `major_avg_local`, gap
+
+Layer 2 never speaks about the future. It describes the present.
+
+### Layer 3 — Verdict merger (rule-based gates, no multipliers)
+
+Single user-facing verdict ∈ {`fill_now`, `wait`, `no_signal`}. The
+displayed confidence number is `ridge_confidence` itself, **untouched**.
+LLM agreement and volatility status are shown as separate **badges**, not
+blended into the number. Honesty over smoothing.
+
+Gates evaluated in order, first match wins:
+
+```
+1. direction == 'flat'                                 → no_signal
+2. ridge_confidence < 40                               → no_signal
+3. volatility_regime active                            → no_signal  (badge: volatile)
+4. LLM disagrees AND ridge_confidence < 75             → no_signal  (badge: conflicting)
+5. rising  AND ridge_confidence >= 70                  → fill_now
+6. falling AND ridge_confidence >= 70                  → wait
+7. otherwise (40 <= conf < 70, no veto from 3 or 4)    → dashboard-only
+```
+
+Why gates, not multipliers:
+
+- A multiplied confidence number is a black-box blend that the user can't
+  audit. A 70% that used to be 90% before today's volatility hit looks
+  identical to a 70% that's been calibrated all along.
+- Gates compose cleanly. Each rule has one job and is independently
+  testable.
+- The verdict is binary anyway (notify / don't / silent). Smoothing
+  confidence under the hood doesn't help that decision — it only obscures it.
+
+Layer 2 affects **urgency wording only** ("fill up now, *especially* in
+your area at 2p above national"). It never changes the verdict. Neither
+does Layer 4 or Layer 5 — they can suppress (gate 3, 4) but never flip
+the direction.
+
+### Layer 4 — Daily LLM news overlay (qualitative, news-aware)
+
+**Single scheduled call at 07:00 UK.** Plus an event-driven refresh when
+Layer 5's volatility flag flips ON (with a 4-hour cooldown so the same
+event doesn't trigger repeatedly).
+
+JSON in, JSON out. Calls Claude Haiku with web search enabled, asks for
+direction + confidence + cited events with URLs. Stored in a new
+`llm_overlays` table.
+
+Layer 4 is **read-only with respect to the volatility flag**. It writes
+its result row; only Layer 5 mutates `volatility_regimes.active`.
+
+LLM confidence is hard-capped at 75 in code (web-searched LLMs are
+systematically overconfident). Calls without `events_cited` are rejected.
+
+### Layer 5 — Volatility regime detector (intra-week safety net)
+
+Hourly cron. **Sole owner** of the `volatility_regimes.active` flag.
+Reads four signals, OR-combined:
+
+1. Daily Brent move > 3% close-to-close (FRED `DCOILBRENTEU`, Phase 7).
+2. Most recent `llm_overlays.major_impact_event = true` AND at least one
+   verified URL.
+3. `station_prices` daily churn rate > 1.5× its 30-day baseline.
+4. A `watched_events` row covering today (manually flagged geopolitical
+   periods).
+
+When the flag flips on:
+- An event-driven LLM refresh is queued (Layer 4) if last run was > 4h ago.
+- **Layer 3's gate 3 fires**: verdict forced to `no_signal` with the
+  `volatile` badge.
+- The reasoning text appended: *"Volatility detected ({trigger}) — this
+  forecast may be stale within days."*
+
+When it flips off:
+- Verdict returns to whatever the gates produce on the unchanged
+  `ridge_confidence` (no multiplier to reset — there are none).
+- Badge cleared.
+- Next morning's 07:00 LLM call still runs (it always runs); no extra
+  refreshes are queued.
+
+Layer 5 never changes Layer 1's *direction*. It only suppresses the
+verdict via gate 3.
+
+---
+
+## Methodology — Layer 1
+
+### Target
+
+```
+ΔULSP[t+1] = ULSP[t+1] − ULSP[t]
+```
+
+We model the **change**, not the level. UK pump prices are non-stationary,
+so regressing on levels gives spurious R² and useless coefficients.
+Differencing makes the series stationary.
+
+### Features (all stationary)
+
+| Feature | Notes |
+|---|---|
+| `Δulsp_lag_0`, `Δulsp_lag_1`, `Δulsp_lag_3` | 1w / 2w / 4w momentum |
+| `Δulsd_lag_0` | Diesel cross-signal as a *change* |
+| `ulsp[t] − ma8[t]` | **Mean-reversion term** — gap between current price and 8-week MA. Single most useful feature for 1-week-ahead UK pump forecast. |
+| `week_of_year_sin`, `week_of_year_cos` | Cyclic seasonality encoding |
+| `is_pre_bank_holiday` | Boolean, within 7 days of UK bank holiday |
+
+The level only enters as the deviation from MA-8 (itself stationary).
+That's the only way levels are allowed in.
+
+**Duty change is NOT a feature.** With one event in 435 weeks, n=1 cannot
+fit a meaningful coefficient. Instead, duty-change-adjacent weeks (±4
+weeks of a known change) are handled in the **calibration override**
+(see below) — confidence is halved and the regime flag is surfaced in
+the reasoning text. A regime can be flagged. A coefficient cannot be
+trained from one observation.
+
+### Model
+
+Ridge regression. Boring on purpose:
+
+- 435 weekly observations is too few to beat a well-specified linear model
+  out-of-sample with gradient boosting or LSTM — those would just fit noise.
+- Interpretable coefficients are essential for the honesty layer
+  (the reasoning text describes what the model used).
+
+Upgrade to a non-linear model **only** if Phase 3 backtest demonstrates the
+linear model is missing real structure.
+
+### Training and evaluation split
+
+- Train on weeks 1–305 (~70%).
+- Evaluate on weeks 306–435 (~30%) with rolling-origin cross-validation
+  (single-split would overfit hyperparameters to one window).
+
+### Confidence calibration
+
+Two-stage calibration:
+
+1. **Magnitude binning** — bin predictions by predicted `|magnitude|` and
+   record actual hit rate per bin. The published `confidence_score` reads
+   from this lookup, not from the model's raw output.
+2. **Regime flag** — flag any forecast week within ±4 weeks of a known
+   duty change. With only one duty change in 435 weeks, statistical
+   stratification at n=1 is impossible. Instead:
+   - For flagged weeks, halve the calibrated confidence manually.
+   - Surface the flag in the reasoning text: *"Recent duty change —
+     forecast accuracy is reduced for the next several weeks."*
+
+This is the only place v1 accepts a hand-tuned guard, and it's there
+because the data can't tell us better.
+
+---
+
+## Methodology — Layer 2
+
+Pure aggregates. No model.
+
+```sql
+-- Local 50km average
+SELECT AVG(price_pence) FROM station_prices_current
+JOIN stations ON station_prices_current.station_id = stations.node_id
+WHERE fuel_type = ? AND <Haversine within 50km of (lat, lng)>;
+
+-- National average
+SELECT AVG(price_pence) FROM station_prices_current WHERE fuel_type = ?;
+
+-- Cheapest within 25km
+SELECT stations.*, station_prices_current.price_pence
+FROM station_prices_current
+JOIN stations ON station_prices_current.station_id = stations.node_id
+WHERE fuel_type = ? AND <Haversine within 25km>
+ORDER BY price_pence ASC LIMIT 5;
+
+-- Supermarket vs major split, locally
+SELECT stations.is_supermarket, AVG(price_pence)
+FROM station_prices_current
+JOIN stations ON station_prices_current.station_id = stations.node_id
+WHERE fuel_type = ? AND <Haversine within 25km>
+GROUP BY stations.is_supermarket;
+```
+
+Output is descriptive: "Your area is X p above national average right
+now", "Cheapest near you: {station} at {price}", "Supermarkets near you:
+{avg} vs majors: {avg}". **Never** predictive language.
+
+---
+
+## Methodology — Layer 3
+
+Full gate ordering is in the Architecture section (Layer 3). Summary:
+
+- Verdict via ordered rule gates, **not** multipliers.
+- `ridge_confidence` is displayed verbatim — never multiplied.
+- Volatility flag and LLM disagreement act as **suppressors with badges**
+  (`volatile`, `conflicting`) but never flip direction.
+- `direction == 'flat'` always produces `no_signal`.
+- LLM disagreement only suppresses the verdict when `ridge_confidence < 75`.
+  Above 75 the model's call is strong enough to stand even with a news-scan
+  disagreement (the LLM is hard-capped at 75 confidence anyway, so it
+  can't out-confidence the ridge model — only flag a tension).
+
+Local position from Layer 2 modifies urgency wording only:
+
+- If user's local average is materially above national (>2p), and Layer 1
+  says "rising", urgency increased ("fill up now, *especially* in your area").
+- Layer 2 never flips Layer 1's direction.
+
+---
+
+## Methodology — Layer 4 (LLM news overlay)
+
+Single scheduled call daily at 07:00 UK. Additional event-driven calls
+are queued by Layer 5 when the volatility flag flips ON, with a 4-hour
+cooldown enforced in code (skip the queue if the most recent
+`llm_overlays.ran_at` is within 4 hours).
+
+**Brent input** (`brent_recent_14_days`) is optional — passed as `null`
+until Phase 7 backfills `brent_prices`. Phase 8 cannot ship before
+Phase 7 — explicit dependency.
+
+### Request shape (JSON)
+
+```json
+{
+  "input": {
+    "ulsp_recent_8_weeks": [...],
+    "brent_recent_14_days": [...],
+    "current_week_of_year": 18,
+    "days_to_next_bank_holiday": 5,
+    "duty_pence": 52.95,
+    "ridge_model_says": {
+      "direction": "down",
+      "confidence": 68,
+      "magnitude_pence": -0.4
+    }
+  },
+  "ask": "Search recent news for oil-supply, OPEC, refinery, shipping, sanctions, geopolitical events affecting UK retail fuel prices over the next 1-2 weeks. Reply ONLY in the schema below."
+}
+```
+
+### Response shape (JSON, enforced)
+
+```json
+{
+  "direction": "rising | falling | flat",
+  "confidence": 0,
+  "reasoning_short": "1-2 sentences",
+  "events_cited": [
+    {"headline": "...", "source": "...", "url": "...", "impact": "rising|falling|neutral"}
+  ],
+  "agrees_with_ridge": true,
+  "major_impact_event": false
+}
+```
+
+### Code-level guards (not in the prompt)
+
+1. **Cap `confidence` at 75.** Web-searched LLMs are systematically overconfident.
+2. **Reject the response if `events_cited` is empty.** Forces the LLM to
+   ground its call in something checkable, not vibes.
+3. **Verify each `url` in `events_cited` is reachable** before storing.
+   Catches hallucinated citations. Failed URLs blank the citation but
+   don't reject the call (newer URLs sometimes 404 briefly).
+4. **Layer 4 does NOT mutate `volatility_regimes.active`.** It writes its
+   row to `llm_overlays` (with `major_impact_event` + verified URLs) and
+   that's it. Layer 5's hourly cron picks up the new row and decides
+   whether to flip the flag.
+
+### How Layer 3 uses it
+
+- LLM agrees → no gating effect; `agrees` badge shown next to the verdict
+  ("News scan agrees, citing {event}").
+- LLM disagrees AND `ridge_confidence < 75` → **gate 4 fires**: verdict
+  forced to `no_signal` with the `conflicting` badge.
+- LLM disagrees AND `ridge_confidence >= 75` → no suppression; the
+  disagreement is shown as a badge but the model's strong call stands.
+- LLM neutral / flat → no gating effect.
+- Direction is never flipped by the LLM.
+
+---
+
+## Methodology — Layer 5 (volatility regime detector)
+
+Hourly cron. **Sole owner** of `volatility_regimes.active`. Reads four
+signals, OR-combined:
+
+1. **Brent move** — close-to-close daily Brent move > 3% on FRED
+   `DCOILBRENTEU`. FRED publishes with a one-day lag (today's value is
+   yesterday's settle), so the trigger reflects the most recent settled
+   day. Sufficient for v1 — we don't have a real-time Brent feed.
+2. **LLM major-impact flag** — most recent `llm_overlays` row has
+   `major_impact_event = true` AND at least one verified URL.
+3. **Station churn** — *gated until ≥180 days of stable polling.* The
+   trigger fires when the last-24h % of stations updating price exceeds
+   1.5× the 30-day rolling baseline. With only 75 days of uneven polling
+   (Jan 16 → May 1) the baseline is meaningless — sample-mix variance
+   would dominate any real shock signal. The trigger is implemented but
+   disabled in code via a feature flag; flip it on once `station_prices`
+   has 180+ continuous days.
+4. **Manual `watched_events`** — a row covering today. Lets you flag
+   known geopolitical periods manually (e.g. "Iran tensions Apr–May 2026").
+
+When the flag flips on:
+
+- An event-driven Layer 4 LLM refresh is queued (skipped if the most
+  recent `llm_overlays.ran_at` is within 4 hours — cooldown).
+- **Layer 3's gate 3 fires**: verdict forced to `no_signal` with the
+  `volatile` badge for as long as the flag stays on.
+- Reasoning text appended: *"Volatility detected ({trigger label}) — this
+  forecast may be stale within days."*
+
+When it flips off:
+- Verdict returns to whatever the gates produce on the unchanged
+  `ridge_confidence` (no multiplier reset needed — there are no multipliers).
+- Badge cleared.
+- The next morning's 07:00 LLM call still runs (always does); no extra
+  refreshes are queued by Layer 5.
+
+---
+
+## Schema deltas
+
+### Add
+
+```
+weekly_forecasts
+  id                   BIGINT PK
+  forecast_for         DATE                — Monday the forecast covers
+  model_version        VARCHAR(32)         — links back to backtests row
+  direction            ENUM('rising','falling','flat')
+  magnitude_pence      SMALLINT            — predicted Δ × 100, signed
+  ridge_confidence     TINYINT UNSIGNED    — 0..100, calibrated from backtested residuals. Displayed verbatim. Layer 3 gates may suppress the verdict but never modify this number.
+  flagged_duty_change  BOOLEAN             — true if forecast is within ±4 weeks of a duty change (avoids collision with Layer 5's volatility_regimes)
+  reasoning            TEXT                — generated from features actually used
+  generated_at         DATETIME
+  UNIQUE (forecast_for, model_version)
+  INDEX  (forecast_for, generated_at DESC)
+
+forecast_outcomes
+  forecast_for      DATE
+  model_version     VARCHAR(32)
+  predicted_class   ENUM('rising','falling','flat')
+  actual_class      ENUM('rising','falling','flat')
+  correct           BOOLEAN
+  abs_error_pence   SMALLINT UNSIGNED
+  resolved_at       DATETIME
+  PRIMARY KEY (forecast_for, model_version)
+
+backtests
+  id                 BIGINT PK
+  model_version      VARCHAR(32) UNIQUE
+  features_json      JSON                — feature spec
+  train_start        DATE
+  train_end          DATE
+  eval_start         DATE
+  eval_end           DATE
+  directional_accuracy DECIMAL(5,2)
+  mae_pence          DECIMAL(5,2)
+  calibration_table  JSON                — {bin_low..bin_high → empirical_hit_rate}
+  leak_suspected     BOOLEAN             — secondary smell test: true if directional_accuracy > 75. Primary leak detection is structural (see Backtest section).
+  ran_at             DATETIME
+
+llm_overlays
+  id                  BIGINT PK
+  ran_at              DATETIME
+  forecast_for_week   DATE                — which weekly forecast it overlays
+  direction           ENUM('rising','falling','flat')
+  confidence          TINYINT UNSIGNED    — capped 75 in code
+  reasoning           TEXT
+  events_json         JSON                — cited events with verified URLs
+  agrees_with_ridge   BOOLEAN
+  major_impact_event  BOOLEAN
+  volatility_flag_on  BOOLEAN             — was the regime flag on at run time
+  search_used         BOOLEAN
+  INDEX (forecast_for_week, ran_at)
+
+volatility_regimes
+  id                  BIGINT PK
+  flipped_on_at       DATETIME
+  flipped_off_at      DATETIME NULL
+  trigger             ENUM('brent_move','llm_event','station_churn','manual')
+  trigger_detail      TEXT                — e.g. "Brent +4.2% close-to-close"
+  active              BOOLEAN
+
+watched_events
+  id                  BIGINT PK
+  label               VARCHAR(128)
+  starts_at           DATETIME
+  ends_at             DATETIME
+  notes               TEXT
+```
+
+### Keep
+
+- `weekly_pump_prices` — already loaded, source of truth
+- `stations`, `station_prices_current` — for Layer 2
+- `station_prices` — keep collecting forward, not modelled in v1
+
+### Deprecate (delete after Layer 1 ships)
+
+- `price_predictions` — old LLM/EWMA store, replaced by `weekly_forecasts`
+
+The current six-signal aggregator (`NationalFuelPredictionService` and
+`app/Services/Prediction/Signals/*`) is **fully replaced**, not extended.
+Same JSON output keys (`predicted_direction`, `confidence_score`,
+`action`, `reasoning`) so the Vue frontend doesn't break — engine swapped,
+contract preserved.
+
+---
+
+## Implementation phases (each ships something working)
+
+| Phase | Scope | Ships |
+|---|---|---|
+| **1. Backtest harness** | `BacktestRunner` service + `backtests` table. Takes a model class, train/eval split, returns directional accuracy + MAE + calibration curve. **Structural leak detection** built in (per-feature source-timestamp check vs target Monday); accuracy>75% smell test as secondary. | A way to *prove* any future model works before shipping it. |
+| **2. Naive baseline** | "Predict next week = this week" implemented as a model class. Run through harness. | A floor: any future model must beat this. |
+| **3. v1 ridge model** | Features above (incl. mean-reversion term), trained once, persisted with `model_version`. `WeeklyForecastService` runs it. Backtest must clear the acceptance gate. | First real forecast. Backtested numbers visible. |
+| **4. Live wiring** | Replace `NationalFuelPredictionService` internals with a thin adapter delegating to `WeeklyForecastService`. Same API shape, new engine. | Frontend keeps working, predictions now from the new model. |
+| **5. Local snapshot** | `LocalSnapshotService` — pure aggregates. Wire into `/api/stations` payload alongside the headline forecast. | "Your area" descriptive cards. |
+| **6. Honesty layer** | Reasoning generator describes *what the model used*: lag values, season, holiday flag. Shows backtest accuracy badge. Returns explicit "not enough data" when confidence < 40. Surfaces the duty-change-adjacent flag when set. | The "no BS" framing. |
+| **7. Brent backfill + daily refresh** | One FRED call (2018→today, ~2,150 daily rows). Daily refresh cron at **06:30 UK** (must complete before Phase 8's 07:00 LLM call — sequenced so the LLM has fresh Brent context). Used by Phase 9's volatility detector and as a feature option for future model iterations (only added to the ridge model if backtested lift is ≥3 percentage points directional accuracy). | Daily Brent in DB. Foundation for volatility + LLM context. |
+| **8. LLM news overlay** | `LlmOverlayService` — single scheduled call at **07:00 UK** (after Brent refresh). Plus event-driven calls when Layer 5 flips the volatility flag on, with 4h cooldown. JSON in / JSON out, web search enabled, results stored in `llm_overlays`. Feeds Layer 3's gate 4 (suppress when LLM disagrees AND ridge_confidence < 75) and the `agrees`/`conflicting` badges. URL-verification + empty-citation rejection enforced in code. **Depends on Phase 7.** | News-aware verdict suppression and badge on top of the calibrated ridge baseline. |
+| **9. Volatility regime detector** | `VolatilityRegimeService` — hourly cron, sole owner of `volatility_regimes.active`. OR-combines four triggers: Brent move > 3%, LLM `major_impact_event`, station churn > 1.5× baseline (**gated until ≥180 days of stable polling**), `watched_events` row covering today. Fires Layer 3's gate 3 (verdict → `no_signal` with `volatile` badge) and the event-driven Layer 4 refresh. | The intra-week safety net for oil shocks. |
+
+---
+
+## Backtest acceptance gates (Phase 3 → Phase 4)
+
+| Backtest result | Action |
+|---|---|
+| < 60% directional accuracy | Features are wrong. Stay in Phase 3, don't ship. |
+| 60–62% | Marginal. One feature iteration, then re-evaluate. |
+| **62–68%** | **Ship.** Realistic target for UK weekly pump direction without Brent. |
+| 68–75% | Excellent. Ship and watch closely. |
+| > 75% | **Stop.** Run the structural leak detector. Almost certainly time leakage (e.g. using `t+1` info accidentally in `t` features). The accuracy threshold is a secondary smell test, not the primary detector. |
+| MAE > 1.0p / litre | Features are noisy. Refit before shipping. |
+| Target MAE | 0.4–0.7p / litre. |
+
+### Structural leak detection (primary)
+
+Built into the backtest harness. For every (training_week, feature_value)
+pair, the harness verifies the data source's effective timestamp is
+**strictly before** the target Monday. Any feature whose source timestamp
+is on or after the target week is treated as leakage and the backtest
+fails fast. This is independent of accuracy — it catches leakage even
+when it doesn't translate into suspiciously high accuracy.
+
+The `> 75% accuracy` row is a secondary smell test for leakage modes the
+structural check missed (e.g. label leakage via a downstream computed
+column). Primary defence is the timestamp check. These numbers are
+encoded in the harness as assertions, not aspirations.
+
+---
+
+## Honesty rules — non-negotiables
+
+1. Backtest accuracy is **published in the UI**. The model wears its track
+   record on its sleeve.
+2. Below 40 confidence, the recommendation is `no_signal` and the reasoning
+   says "we don't have enough signal to call it" — explicitly. No filler.
+3. When duty-change-adjacent weeks affect the forecast, surface the flag
+   ("forecast may be skewed by recent duty change").
+4. Reasoning text only references features the model actually used — no
+   narrative invention. If the mean-reversion term drove the call, say so
+   ("Pump prices are 3.1p above their 8-week average, and prices typically
+   pull back from that level"). If the seasonality term drove it, say so.
+5. `forecast_outcomes` is populated automatically when the next BEIS week
+   lands. Hit rate over the trailing 13 weeks is shown next to the headline.
+6. When the **volatility regime flag** is on, the UI shows the `volatile`
+   badge and the trigger (e.g. "Brent up 4.2% yesterday — forecast may be
+   stale within days"). Verdict is suppressed visibly via gate 3, never
+   silently.
+7. The LLM overlay is **shown separately** from the ridge model, never
+   blended. "Model says down (68%); news scan agrees, citing {event}" —
+   the `ridge_confidence` number stays calibrated and untouched, while
+   LLM and volatility status are presented as their own badges.
+8. LLM citations with unreachable URLs are **dropped from the displayed
+   reasoning** but kept in `llm_overlays.events_json` for audit. We never
+   show a citation we haven't verified.
+
+---
+
+## What gets deleted at the end of Phase 4
+
+- `app/Services/Prediction/Signals/*` (whole directory)
+- `NationalFuelPredictionService` internals (kept as a thin wrapper, then
+  renamed when the frontend migration completes)
+- `price_predictions` table — replaced by `weekly_forecasts` (ridge) +
+  `llm_overlays` (news layer)
+- `OilPriceService::generatePrediction()`, EWMA/LLM helpers — replaced by
+  `LlmOverlayService` (Phase 8) which has a different contract
+- `OilPriceService::fetchBrentPrices()` — kept and **expanded** in Phase 7
+  (backfill mode + daily refresh), not deleted
+- `.claude/rules/scoring.md` retired in favour of a fresh
+  `.claude/rules/forecasting.md`
+- `.claude/rules/prediction.md` rewritten to match the new architecture
+
+---
+
+## Open decisions (to confirm before Phase 1)
+
+- **Forecast cadence** — the *forecast itself* is weekly (matches BEIS
+  publication). The *confidence and presentation* update daily via Layer 4
+  (LLM) and Layer 5 (volatility regime). This split is deliberate — we
+  refuse to fabricate intra-week movement, but we don't pretend a static
+  Monday number is reliable on Thursday after a 6% Brent move.
+- **Scope** — drop the six-signal aggregator entirely, confirmed.
+- **API shape** — keep existing JSON output keys so Vue keeps working,
+  with the engine swapped under the hood. The original `confidence_score`
+  field maps to `ridge_confidence` (calibrated, untouched). Add new
+  fields: `volatility` (`{active, trigger}`), `news_overlay`
+  (`{direction, agreement, events}`), and `verdict_reason` (which gate
+  fired, if any). The verdict itself goes in the existing `action` field.
+- **Brent** — promoted to Phase 7 (was "optional, conditional"). Needed
+  for the volatility detector, regardless of whether it's used in the
+  ridge model.
+- **LLM** — Anthropic Claude Haiku with web search. Single scheduled call
+  at 07:00 UK (after the 06:30 Brent refresh). Plus event-driven refreshes
+  when Layer 5 flips the volatility flag on, with a 4h cooldown. No fixed
+  afternoon cron — by 13:00 UK, morning users have already made their
+  fill-up decisions, so the value is too low to justify the extra noise.
+  Hard confidence cap 75. Empty-citation rejection.
+
+---
+
+## Changelog (substantive design decisions)
+
+| When | Change | Why |
+|---|---|---|
+| 2026-05-01 v1 | Initial spec — three layers, six-signal aggregator removed, ridge model on BEIS weekly data | Replace incoherent `NationalFuelPredictionService` |
+| 2026-05-01 v2 | Added Layer 4 (LLM news overlay) and Layer 5 (volatility regime detector). Pump prices can move daily during oil shocks; static weekly forecast must be backed by intra-week safety nets. | Iran/Hormuz-style shocks make a Monday-only confidence number stale by Wednesday |
+| 2026-05-01 v3 | **Verdict via rule gates, not multipliers.** `ridge_confidence` displayed verbatim. LLM and volatility presented as badges. `weeks_since_duty_change` removed from features (kept as calibration override only — n=1 can't fit a coefficient). Backtest gate floor lowered 65 → 62 (realistic without Brent). Structural leak detection (per-feature timestamp check) made primary; accuracy>75% demoted to secondary smell test. `weekly_forecasts` PK changed to `(forecast_for, model_version)` to preserve audit on retrain. `forecast_outcomes` made three-class. Layer 5 station-churn trigger gated until ≥180 days of stable polling. | Multipliers obscure calibration. Gates compose cleanly and stay auditable. |
+
+---
+
+## References
+
+- Alquist, Kilian, Vigfusson (2013) — *Forecasting the Price of Oil* —
+  the academic basis for "no-change baseline beats most structural models
+  at <6m horizons" (which is why Phase 2 matters as a hard floor).
+- BEIS *Weekly road fuel prices* CSV — the 435-week training set.
+- `.claude/rules/scoring.md`, `.claude/rules/prediction.md` — the two
+  inconsistent rule files this spec replaces.

resources/js/views/Home.vue

@@ -448,12 +448,12 @@ const PRICE_SUFFIX = { monthly: '/mo', annual: '/yr' }
 const { stations, meta, prediction, loading, error, search, reset } = useStations()
 const showFullPrediction = computed(() => Boolean(prediction.value) && !prediction.value.tier_locked)
 
-watch(loading, (isLoading) => {
-    if (!isLoading) return
-    nextTick(() => {
-        window.scrollBy({ top: 40, behavior: 'smooth' })
-    })
-})
+// watch(loading, (isLoading) => {
+//     if (!isLoading) return
+//     nextTick(() => {
+//         window.scrollBy({ top: 40, behavior: 'smooth' })
+//     })
+// })
 
 const searchOrigin = computed(() => {
     if (meta.value?.lat != null && meta.value?.lng != null) {

routes/api.php

@@ -12,6 +12,7 @@ use Illuminate\Support\Facades\Route;
 // Public endpoints (no API key required)
 Route::post('/auth/register', [AuthController::class, 'register']);
 Route::post('/auth/login', [AuthController::class, 'login']);
+Route::get('/auth/me', [AuthController::class, 'me']);
 
 Route::get('/fuel-types', function () {
     return Cache::remember('api:fuel-types', now()->addDay(), fn () => collect(FuelType::cases())
@@ -29,7 +30,6 @@ Route::middleware(['throttle:60,1', VerifyApiKey::class])->group(function (): vo
 
 // Sanctum-authenticated endpoints
 Route::middleware('auth:sanctum')->group(function (): void {
-    Route::get('/auth/me', [AuthController::class, 'me']);
     Route::post('/auth/logout', [AuthController::class, 'logout']);
 
     // User dashboard endpoints

routes/console.php

@@ -33,6 +33,14 @@ Schedule::command('oil:predict --fetch')
     ->onOneServer()
     ->runInBackground();
 
+// Move station_prices rows older than 12 months into station_prices_archive
+// once a month. Keeps the partitioned hot table bounded.
+Schedule::command('fuel:archive')
+    ->monthlyOn(1, '04:00')
+    ->withoutOverlapping()
+    ->onOneServer()
+    ->runInBackground();
+
 // Scheduled WhatsApp updates — morning and evening
 Schedule::job(new SendScheduledWhatsAppJob('morning'))->dailyAt('07:30')->onOneServer();
 Schedule::job(new SendScheduledWhatsAppJob('evening'))->dailyAt('18:00')->onOneServer();

tests/Feature/Api/AuthControllerTest.php

@@ -69,6 +69,41 @@ it('returns the authenticated user on /me', function () {
         ->assertJsonPath('email', $user->email);
 });
 
+it('does not leak sensitive or internal user fields on /me', function () {
+    $user = User::factory()->create([
+        'is_admin' => true,
+        'stripe_id' => 'cus_secret',
+        'pm_type' => 'visa',
+        'pm_last_four' => '4242',
+        'postcode' => 'SW1A 1AA',
+    ]);
+
+    $user->subscriptions()->create([
+        'type' => 'default',
+        'stripe_id' => 'sub_secret',
+        'stripe_status' => 'active',
+        'stripe_price' => 'price_plus_monthly',
+        'quantity' => 1,
+    ]);
+
+    $response = $this->actingAs($user, 'sanctum')
+        ->getJson('/api/auth/me')
+        ->assertOk();
+
+    $payload = $response->json();
+
+    expect(array_keys($payload))->toEqualCanonicalizing([
+        'name',
+        'email',
+        'two_factor_confirmed_at',
+        'tier',
+        'subscription_cancelled',
+        'subscription_cadence',
+        'subscribed_at',
+        'subscription_expires_at',
+    ]);
+});
+
 it('reports subscription_cancelled=false for a user with no subscription', function () {
     $user = User::factory()->create();
 
@@ -215,6 +250,12 @@ it('logs out and revokes the token', function () {
     expect($user->tokens()->count())->toBe(0);
 });
 
-it('returns 401 on protected routes without a token', function () {
-    $this->getJson('/api/auth/me')->assertUnauthorized();
+it('returns null on /me when unauthenticated', function () {
+    $response = $this->getJson('/api/auth/me')->assertOk();
+
+    expect($response->getContent())->toBe('null');
+});
+
+it('returns 401 on protected routes without a token', function () {
+    $this->postJson('/api/auth/logout')->assertUnauthorized();
 });

tests/Feature/Commands/ArchiveOldPricesCommandTest.php

@@ -0,0 +1,69 @@
+<?php
+
+use App\Models\Station;
+use App\Models\StationPrice;
+use App\Models\StationPriceArchive;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+
+uses(RefreshDatabase::class);
+
+it('moves prices older than 12 months to archive', function (): void {
+    $station = Station::factory()->create();
+
+    StationPrice::factory()->create([
+        'station_id' => $station->node_id,
+        'price_effective_at' => now()->subMonths(13),
+        'price_reported_at' => now()->subMonths(13),
+        'recorded_at' => now()->subMonths(13),
+    ]);
+
+    StationPrice::factory()->create([
+        'station_id' => $station->node_id,
+        'price_effective_at' => now()->subMonths(6),
+        'price_reported_at' => now()->subMonths(6),
+        'recorded_at' => now()->subMonths(6),
+    ]);
+
+    $this->artisan('fuel:archive')->assertSuccessful();
+
+    expect(StationPrice::count())->toBe(1)
+        ->and(StationPriceArchive::count())->toBe(1);
+});
+
+it('outputs no-op message when nothing qualifies', function (): void {
+    $station = Station::factory()->create();
+
+    StationPrice::factory()->create([
+        'station_id' => $station->node_id,
+        'price_effective_at' => now()->subMonths(3),
+        'price_reported_at' => now()->subMonths(3),
+        'recorded_at' => now()->subMonths(3),
+    ]);
+
+    $this->artisan('fuel:archive')
+        ->expectsOutputToContain('No prices to archive.')
+        ->assertSuccessful();
+
+    expect(StationPrice::count())->toBe(1)
+        ->and(StationPriceArchive::count())->toBe(0);
+});
+
+it('preserves the row data when archiving', function (): void {
+    $station = Station::factory()->create();
+
+    $original = StationPrice::factory()->create([
+        'station_id' => $station->node_id,
+        'price_pence' => 14523,
+        'price_effective_at' => now()->subMonths(13),
+        'price_reported_at' => now()->subMonths(13),
+        'recorded_at' => now()->subMonths(13),
+    ]);
+
+    $this->artisan('fuel:archive')->assertSuccessful();
+
+    $archived = StationPriceArchive::first();
+
+    expect($archived)->not->toBeNull()
+        ->and($archived->station_id)->toBe($original->station_id)
+        ->and($archived->price_pence)->toBe(14523);
+});

tests/Feature/Tiers/DispatchUserNotificationJobTest.php

@@ -7,7 +7,9 @@ use App\Models\NotificationLog;
 use App\Models\Plan;
 use App\Models\User;
 use App\Models\UserNotificationPreference;
+use App\Notifications\FuelPriceAlert;
 use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Notification;
 use Illuminate\Support\Facades\Queue;
 
 uses(RefreshDatabase::class);
@@ -39,6 +41,39 @@ it('logs a sent entry for each allowed channel', function (): void {
         ->and($log->fuel_type)->toBe(FuelType::E10->value);
 });
 
+it('actually dispatches FuelPriceAlert with the allowed channels', function (): void {
+    Notification::fake();
+
+    $user = User::factory()->create();
+
+    UserNotificationPreference::factory()->create([
+        'user_id' => $user->id,
+        'channel' => 'email',
+        'fuel_type' => FuelType::E10->value,
+        'enabled' => true,
+    ]);
+
+    (new DispatchUserNotificationJob($user, 'price_threshold', FuelType::E10->value, price: 143.9))->handle();
+
+    Notification::assertSentTo($user, FuelPriceAlert::class, function (FuelPriceAlert $n) {
+        return $n->triggerType === 'price_threshold'
+            && $n->fuelType === FuelType::E10->value
+            && $n->price === 143.9
+            && in_array('email', $n->channels, true);
+    });
+});
+
+it('does not dispatch FuelPriceAlert when no channels are allowed', function (): void {
+    Notification::fake();
+
+    // Free user with no preferences — channelsFor returns []
+    $user = User::factory()->create();
+
+    (new DispatchUserNotificationJob($user, 'price_threshold', FuelType::E10->value))->handle();
+
+    Notification::assertNothingSent();
+});
+
 // ─── DispatchUserNotificationJob — tier_restricted logging ───────────────────
 
 it('logs tier_restricted for channels the user wants but their tier forbids', function (): void {

tests/TestCase.php

@@ -3,10 +3,26 @@
 namespace Tests;
 
 use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
+use Illuminate\Support\Facades\DB;
 use Laravel\Fortify\Features;
 
 abstract class TestCase extends BaseTestCase
 {
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        // SQLite lacks GREATEST/LEAST scalar functions — register PHP-backed
+        // shims so the haversine and other math expressions used in
+        // production-style queries run identically in :memory: tests.
+        // Idempotent: registering twice on the same PDO is harmless.
+        if (DB::connection()->getDriverName() === 'sqlite') {
+            $pdo = DB::connection()->getPdo();
+            $pdo->sqliteCreateFunction('GREATEST', fn (...$args) => max($args), -1);
+            $pdo->sqliteCreateFunction('LEAST', fn (...$args) => min($args), -1);
+        }
+    }
+
     protected function skipUnlessFortifyHas(string $feature, ?string $message = null): void
     {
         if (! Features::enabled($feature)) {

tests/Unit/Services/BrentPriceFetcherTest.php

@@ -38,11 +38,24 @@ it('fetches and stores brent prices from EIA', function (): void {
         ->and(BrentPrice::find('2026-04-02')->price_usd)->toBe('73.80');
 });
 
-it('throws when EIA returns a 500', function (): void {
+it('throws with HTTP status when EIA returns a 500', function (): void {
     Http::fake(['*eia.gov/*' => Http::response([], 500)]);
 
+    expect(fn () => $this->fetcher->fetchFromEia())
+        ->toThrow(BrentPriceFetchException::class, 'EIA returned HTTP 500');
+});
+
+it('retries EIA on transient 500 and succeeds', function (): void {
+    Http::fake([
+        '*eia.gov/*' => Http::sequence()
+            ->push([], 500)
+            ->push(['response' => ['data' => [['period' => '2026-04-01', 'value' => '75.10']]]]),
+    ]);
+
     $this->fetcher->fetchFromEia();
-})->throws(BrentPriceFetchException::class);
+
+    expect(BrentPrice::count())->toBe(1);
+});
 
 it('throws when EIA returns empty data', function (): void {
     Http::fake(['*eia.gov/*' => Http::response(['response' => ['data' => []]])]);
@@ -84,11 +97,24 @@ it('fetches and stores brent prices from FRED', function (): void {
     expect(BrentPrice::count())->toBe(2);
 });
 
-it('throws when FRED fails', function (): void {
+it('throws with HTTP status when FRED returns a 500', function (): void {
     Http::fake(['*/fred/series/observations*' => Http::response([], 500)]);
 
+    expect(fn () => $this->fetcher->fetchFromFred())
+        ->toThrow(BrentPriceFetchException::class, 'FRED returned HTTP 500');
+});
+
+it('retries FRED on transient 500 and succeeds', function (): void {
+    Http::fake([
+        '*/fred/series/observations*' => Http::sequence()
+            ->push([], 500)
+            ->push(['observations' => [['date' => '2026-04-01', 'value' => '75.10']]]),
+    ]);
+
     $this->fetcher->fetchFromFred();
-})->throws(BrentPriceFetchException::class);
+
+    expect(BrentPrice::count())->toBe(1);
+});
 
 it('filters out FRED missing value markers', function (): void {
     Http::fake([

tests/Unit/Services/BrentPricePredictorTest.php

@@ -61,7 +61,7 @@ it('returns null when fewer than 14 prices are available for EWMA', function ():
     expect($this->predictor->generateEwmaPrediction($prices))->toBeNull();
 });
 
-it('stores both EWMA and LLM predictions when provider succeeds', function (): void {
+it('stores only the LLM prediction when the provider succeeds', function (): void {
     seedPrices(20);
 
     $this->provider->shouldReceive('predict')->once()->andReturn(new PricePrediction([
@@ -76,7 +76,8 @@ it('stores both EWMA and LLM predictions when provider succeeds', function (): v
     $prediction = $this->predictor->generatePrediction();
 
     expect($prediction->source)->toBe(PredictionSource::LlmWithContext)
-        ->and(PricePrediction::count())->toBe(2);
+        ->and(PricePrediction::count())->toBe(1)
+        ->and(PricePrediction::where('source', PredictionSource::Ewma)->count())->toBe(0);
 });
 
 it('falls back to EWMA when provider returns null', function (): void {