@fleetbase/fleetops-engine 0.6.68 → 0.6.70

package/addon/templates/settings/telematics.hbs

@@ -0,0 +1,70 @@
+<Layout::Section::Header @title={{t "settings.telematics.telematics-settings"}}>
+    <Button
+        @type="primary"
+        @size="sm"
+        @icon="save"
+        @text={{t "common.save-changes"}}
+        @onClick={{perform this.saveSettings}}
+        @disabled={{or this.saveSettings.isRunning this.getSettings.isRunning (not this.settingsLoaded)}}
+        @isLoading={{or this.saveSettings.isRunning this.getSettings.isRunning}}
+        @permission="fleet-ops update telematics-settings"
+    />
+</Layout::Section::Header>
+<Layout::Section::Body class="overflow-y-scroll-i h-full">
+    <div class="container mx-auto">
+        <div class="max-w-3xl my-10 mx-auto space-y-6">
+            <InfoBlock @type="info" @icon="circle-info">
+                {{t "settings.telematics.intro"}}
+            </InfoBlock>
+
+            <ContentPanel @title={{t "settings.telematics.device-events"}} @open={{true}} @wrapperClass="bordered-classic">
+                <InputGroup>
+                    <Toggle
+                        @label={{t "settings.telematics.use-system-default"}}
+                        @isToggled={{this.useDefaultEventRetention}}
+                        @onToggle={{this.setUseDefaultEventRetention}}
+                        @disabled={{not this.settingsLoaded}}
+                    />
+                </InputGroup>
+                <InputGroup @name={{t "settings.telematics.event-retention-days"}} @helpText={{t "settings.telematics.event-retention-days-help"}}>
+                    <Input
+                        @type="number"
+                        @value={{this.eventRetentionDays}}
+                        min={{this.eventRetentionMinimum}}
+                        max={{this.eventRetentionMaximum}}
+                        disabled={{or this.useDefaultEventRetention (not this.settingsLoaded)}}
+                        class="w-full form-input"
+                    />
+                </InputGroup>
+                {{#if this.settingsLoaded}}
+                    <p class="text-xs text-gray-500 dark:text-gray-400">{{this.eventRetentionPolicyHelp}}</p>
+                {{/if}}
+            </ContentPanel>
+
+            <ContentPanel @title={{t "settings.telematics.positions"}} @open={{true}} @wrapperClass="bordered-classic">
+                <InputGroup>
+                    <Toggle
+                        @label={{t "settings.telematics.use-system-default"}}
+                        @isToggled={{this.useDefaultPositionRetention}}
+                        @onToggle={{this.setUseDefaultPositionRetention}}
+                        @disabled={{not this.settingsLoaded}}
+                    />
+                </InputGroup>
+                <InputGroup @name={{t "settings.telematics.position-retention-days"}} @helpText={{t "settings.telematics.position-retention-days-help"}}>
+                    <Input
+                        @type="number"
+                        @value={{this.positionRetentionDays}}
+                        min={{this.positionRetentionMinimum}}
+                        max={{this.positionRetentionMaximum}}
+                        disabled={{or this.useDefaultPositionRetention (not this.settingsLoaded)}}
+                        class="w-full form-input"
+                    />
+                </InputGroup>
+                {{#if this.settingsLoaded}}
+                    <p class="text-xs text-gray-500 dark:text-gray-400">{{this.positionRetentionPolicyHelp}}</p>
+                {{/if}}
+            </ContentPanel>
+        </div>
+    </div>
+    <Spacer @height="200px" />
+</Layout::Section::Body>

package/addon/utils/profile-login-actions.js

@@ -0,0 +1,172 @@
+import { get } from '@ember/object';
+
+/**
+ * Shared helpers for the login account behind a driver, contact or customer
+ * profile. The account itself is created, updated and removed by the server
+ * from the profile's name/email/phone; the console only offers the account
+ * actions (reset password, send credentials, deactivate/reactivate login).
+ *
+ * A profile owned by a staff member (`is_staff_linked`) has its login
+ * managed from IAM, so no account actions are offered for it here.
+ */
+
+export const INTERNAL_NAMESPACE = 'int/v1';
+export const INACTIVE_LOGIN_STATUSES = ['inactive', 'disabled', 'suspended'];
+
+function read(subject, key) {
+    if (!subject) {
+        return undefined;
+    }
+
+    try {
+        return get(subject, key);
+    } catch {
+        return subject[key];
+    }
+}
+
+/**
+ * The linked user record when it is already loaded, without triggering a
+ * fetch for an async relationship.
+ */
+export function loadedUser(profile) {
+    if (typeof profile?.belongsTo === 'function') {
+        try {
+            return profile.belongsTo('user').value();
+        } catch {
+            return null;
+        }
+    }
+
+    const user = read(profile, 'user');
+    if (!user) {
+        return null;
+    }
+
+    return typeof user.then === 'function' ? (read(user, 'content') ?? null) : user;
+}
+
+export function isStaffLinked(profile) {
+    return Boolean(read(profile, 'is_staff_linked'));
+}
+
+export function hasLinkedUser(profile) {
+    if (!profile) {
+        return false;
+    }
+
+    if (read(profile, 'user_uuid') || read(profile, 'login_status')) {
+        return true;
+    }
+
+    const user = loadedUser(profile);
+    return Boolean(user && (read(user, 'id') || read(user, 'uuid')));
+}
+
+/**
+ * True when the profile has a login account that is managed from Fleet-Ops,
+ * i.e. a linked user which is not a staff member's account.
+ */
+export function hasManagedLogin(profile) {
+    return hasLinkedUser(profile) && !isStaffLinked(profile);
+}
+
+/**
+ * The login status, preferring the server-provided `login_status` over the
+ * embedded user's status.
+ */
+export function linkedUserStatus(profile) {
+    const loginStatus = read(profile, 'login_status');
+    if (loginStatus) {
+        return loginStatus;
+    }
+
+    const user = loadedUser(profile);
+    return (user ? (read(user, 'status') ?? read(user, 'session_status')) : null) ?? 'active';
+}
+
+export function hasInactiveLogin(profile) {
+    return INACTIVE_LOGIN_STATUSES.includes(linkedUserStatus(profile));
+}
+
+export function withoutIdentityFields(payload = {}) {
+    const attributes = { ...payload };
+
+    delete attributes.id;
+    delete attributes.uuid;
+    delete attributes.public_id;
+
+    return attributes;
+}
+
+/**
+ * Applies the profile payload returned by an account action endpoint
+ * (`{ driver: {...} }`, `{ customer: {...} }` or `{ contact: {...} }`).
+ */
+export function updateProfileFromResponse(profile, response = {}) {
+    const payload = response?.driver ?? response?.customer ?? response?.contact;
+
+    if (!payload || typeof profile?.setProperties !== 'function') {
+        return;
+    }
+
+    const attributes = {};
+    if ('user_uuid' in payload) {
+        attributes.user_uuid = payload.user_uuid;
+    }
+    if ('is_staff_linked' in payload) {
+        attributes.is_staff_linked = Boolean(payload.is_staff_linked);
+    }
+    if ('login_status' in payload) {
+        attributes.login_status = payload.login_status;
+    } else if (payload.user && 'status' in payload.user) {
+        attributes.login_status = payload.user.status;
+    }
+
+    profile.setProperties(attributes);
+
+    if (payload.user) {
+        const user = loadedUser(profile);
+
+        if (typeof user?.setProperties === 'function') {
+            user.setProperties(withoutIdentityFields(payload.user));
+        }
+    }
+}
+
+/**
+ * Opens a confirm modal which POSTs to an account action endpoint and applies
+ * the response to the profile.
+ *
+ * @param {Object} services { modalsManager, fetch, notifications }
+ * @param {Object} profile the driver or contact record
+ * @param {Object} options { title, body, acceptButtonText, acceptButtonScheme, endpoint, payload, successMessage, onSuccess }
+ */
+export function confirmLoginAction({ modalsManager, fetch, notifications }, profile, options = {}) {
+    const { title, body, acceptButtonText, acceptButtonScheme, endpoint, payload = {}, successMessage, onSuccess } = options;
+
+    return modalsManager.confirm({
+        title,
+        body,
+        acceptButtonText,
+        acceptButtonScheme,
+        confirm: async (modal) => {
+            modal.startLoading();
+
+            try {
+                const response = await fetch.post(endpoint, payload, { namespace: INTERNAL_NAMESPACE });
+                updateProfileFromResponse(profile, response);
+                notifications.success(successMessage);
+
+                if (typeof onSuccess === 'function') {
+                    onSuccess(response);
+                }
+
+                modal.done();
+            } catch (error) {
+                notifications.serverError(error);
+                modal.stopLoading();
+            }
+        },
+    });
+}

package/app/components/admin/telematics-settings.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/admin/telematics-settings';

package/app/components/{modals/reset-customer-credentials.js → map/marker-card/driver.js}

@@ -1 +1 @@
-export { default } from '@fleetbase/fleetops-engine/components/modals/reset-customer-credentials';
+export { default } from '@fleetbase/fleetops-engine/components/map/marker-card/driver';

package/app/components/map/marker-card/vehicle.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/map/marker-card/vehicle';

package/app/components/modals/reset-profile-credentials.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/modals/reset-profile-credentials';

package/app/components/profile-identity-hint.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/components/profile-identity-hint';

package/app/controllers/settings/telematics.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/controllers/settings/telematics';

package/app/routes/settings/telematics.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/routes/settings/telematics';

package/app/templates/settings/telematics.js

@@ -0,0 +1 @@
+export { default } from '@fleetbase/fleetops-engine/templates/settings/telematics';

package/composer.json

@@ -1,6 +1,6 @@
 {
     "name": "fleetbase/fleetops-api",
-    "version": "0.6.68",
+    "version": "0.6.70",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "keywords": [
         "fleetbase-extension",
@@ -25,7 +25,7 @@
         "barryvdh/laravel-dompdf": "^3.1",
         "brick/geo": "0.7.2",
         "cknow/laravel-money": "^7.1",
-        "fleetbase/core-api": "*",
+        "fleetbase/core-api": ">=1.6.65",
         "geocoder-php/google-maps-places-provider": "^1.4",
         "giggsey/libphonenumber-for-php": "^8.13",
         "league/geotools": "^1.1.0",

package/docs/AFAQY.md

@@ -57,7 +57,7 @@ Existing provider interfaces and vehicle/trailer event names remain compatible.
 
 The public receiver remains `POST webhooks/telematics/afaqy?telematic=...&key=...` under the application's API prefix. A new `device.telemetry_updated` broadcast identifies the device; an open device panel reloads its authorized resource and refetches after socket reconnection. Company broadcast identity comes from the persisted asset, not a worker session. Map movement uses the existing vehicle/trailer events, rejects older source timestamps, and reloads visible telemetry assets after socket reconnection with at most five concurrent requests.
 
-Configure shared queues, retention, limits, and freshness under `telematics.telemetry` using `server/config/telemetry.php`. `TELEMATICS_BATCH_SIZE` controls units per ingestion delivery (default 100); `TELEMATICS_REQUEST_TIMEOUT_SECONDS` controls the bounded polling request timeout (default 45 seconds). AFAQY's adapter switches and optional queue overrides remain under `telematics.afaqy` in `server/config/afaqy.php`. Defaults: two MiB per webhook, 10,000 pending deliveries per connection, processed payload retention 24 hours, quarantine retention seven days, stale-position thresholds 120 seconds with ignition on and 600 seconds with ignition off/unknown. Each device's metadata records the effective threshold. Connection status categories remain unchanged.
+Configure shared queues, retention, limits, and freshness under `telematics.telemetry` using `server/config/telemetry.php`. `TELEMATICS_BATCH_SIZE` controls units per ingestion delivery (default 100); `TELEMATICS_REQUEST_TIMEOUT_SECONDS` controls the bounded polling request timeout (default 45 seconds). AFAQY's adapter switches and optional queue overrides remain under `telematics.afaqy` in `server/config/afaqy.php`. Defaults: two MiB per webhook, 10,000 pending deliveries per connection, stale-position thresholds 120 seconds with ignition on and 600 seconds with ignition off/unknown. Retention (processed payloads 24 hours, quarantined deliveries seven days, device events 30 days, positions 90 days) is applied by `fleetops:prune-telematics-data`. Administrators configure retention policy, logging, system storage diagnostics and system cleanup in Admin → Fleet-Ops Config → Telematics. Organizations choose only event and position history preferences within those limits in Fleet-Ops → Settings → Telematics; config values are the fallback. See `docs/TELEMETRY_ARCHITECTURE.md` § Retention. Each device's metadata records the effective threshold. Connection status categories remain unchanged.
 
 ## Incident verification
 

package/docs/TELEMATICS_QUEUES.md

@@ -14,7 +14,7 @@ nothing changes: every job and broadcast stays on the same queue as before.
 | Setting | Default | Work routed |
 | --- | --- | --- |
 | `TELEMATICS_POLL_QUEUE` | `default` | Scheduled and manual polls (`PollTelematicTelemetry`), legacy device discovery (`SyncTelematicDevicesJob`), and queued connection tests (`TestTelematicConnectionJob`). |
-| `TELEMATICS_INGESTION_QUEUE` | `default` | Applying polled or pushed positions (`ProcessTelematicDelivery`), including jobs re-queued by `fleetops:drain-telematic-inbox` and manual replays. |
+| `TELEMATICS_INGESTION_QUEUE` | `default` | Applying polled or pushed positions (`ProcessTelematicDelivery`), including jobs re-queued by `fleetops:drain-telematic-inbox` and manual replays, and on-demand retention runs (`PruneTelematicsDataJob`, queued by "Run system cleanup" in Admin → Fleet-Ops Config → Telematics). |
 | `TELEMATICS_BROADCAST_QUEUE` | unset | Live-map broadcasts created by telematics ingestion: `DeviceTelemetryUpdated`, and `VehicleLocationChanged` / `TrailerLocationChanged` when a device is attached. When unset, broadcasts use the queue connection's default queue. |
 
 `TELEMATICS_BROADCAST_QUEUE` affects only broadcasts that telematics ingestion

package/docs/TELEMETRY_ARCHITECTURE.md

@@ -48,11 +48,82 @@ persistence. The performance requirement did not justify those dependencies.
 ## Tradeoffs
 
 Three shared tables separate run-level diagnostics, high-volume delivery retention,
-and connection-level secrets with different lifetimes. Provider-specific protocol
+and connection-level secrets with different lifetimes (see Retention below). Provider-specific protocol
 classes remain appropriate. Capability opt-in avoids silently changing every
 existing integration's ingestion or webhook behavior. Production throughput and
 real AFAQY payload verification remain separate deployment gates.
 
+## Retention
+
+Every poll writes one `device_events` row, one `positions` row and a delivery
+envelope per batch for each reporting device. Without a ceiling those tables grow
+until the disk fills, so retention is enforced by `fleetops:prune-telematics-data`
+(scheduled every fifteen minutes, `withoutOverlapping(14)`) using a per-company
+policy resolved by `Support\Telematics\Retention\RetentionPolicy`:
+
+| Layer | Source | Where it is edited |
+|---|---|---|
+| Package config | `server/config/telemetry.php` | deployment |
+| System policy | setting `fleet-ops.telematics-settings` | Admin console → Fleet-Ops Config → Telematics |
+| Company history preferences | `company.<uuid>.fleet-ops.telematics-settings` | Fleet-Ops → Settings → Telematics |
+
+Defaults: device events 30 days, raw payload/meta stripped ("compacted") after
+7 days, positions 90 days, processed deliveries 24 hours, quarantined deliveries
+7 days, sync runs 7 days. Organizations can choose only device event and position
+history retention, or inherit the system defaults. Administrators own raw payload,
+delivery, sync-run retention and telemetry activity logging.
+
+`max_event_retention_days` and `max_position_retention_days` constrain every
+organization's history, including inherited defaults. A maximum of `0` allows
+unlimited history; a history preference of `0` keeps records forever only while
+that maximum is unset. Setting a finite maximum replaces saved unlimited or longer
+preferences with that maximum. Missing preferences continue to inherit. Values
+are also clamped to `RetentionPolicy::LIMITS`.
+
+Admin storage diagnostics cover the entire system, including organizations the
+administrator does not belong to. System cleanup queues work for every
+organization plus orphaned records, with each organization's effective policy
+applied independently. Storage sizes include table data and indexes; database row
+estimates are labeled. Cleanup is asynchronous, so refreshing usage does not mean
+all queued work has finished.
+
+Manual system cleanup requires an asynchronous queue connection and a worker for
+`telematics.telemetry.ingestion_queue`. A synchronous or disabled queue is rejected
+instead of running every organization's cleanup inside the HTTP request.
+
+Deploy the frontend and backend together and reload Octane and queue workers after
+updating the backend. In linked development checkouts, Octane's watch paths must
+include `packages/fleetops/server`; watching only the host API directory leaves
+previously loaded controllers and policies running.
+
+Rules the sweep follows:
+
+- Hard deletes only. The models soft-delete, so `delete()` would grow the table;
+  rows already soft-deleted are purged regardless of age.
+- Bounded work: at most `--max-batches` (default 50) statements of `--batch-size`
+  (default 1000) rows per table per company per run. A capped run is normal; the
+  next tick continues. Operators can catch up faster off-peak with
+  `php artisan fleetops:prune-telematics-data --max-batches=500 --no-lock`.
+- Compaction keeps the event (type, severity, location, normalized `data`) and
+  nulls `payload` and `meta`, which hold the bulk of each row.
+- `telematic_deliveries` and `telematic_sync_runs` carry no company; they are
+  resolved through the company's connections (including trashed ones). In-flight
+  sync runs (`fetching`, `ingesting`) are recovered by the drain, never expired.
+- Rows whose company or connection no longer exists are swept with the system
+  defaults.
+- Migrations add `(company_uuid, created_at)` on `device_events` and `positions`
+  and `(telematic_uuid, updated_at)` on `telematic_sync_runs`; on multi-GB tables
+  run them in a maintenance window.
+- Deleting rows frees space inside InnoDB files, not on disk. Run
+  `OPTIMIZE TABLE device_events` (requires `innodb_file_per_table`) off-peak to
+  return it to the operating system.
+
+Two write-amplification fixes accompany the sweep: `device_events.meta` stores only
+the normalized block (the raw unit lives once, in `payload`), and telemetry-driven
+saves run inside `activity()->withoutLogs()` unless the system administrator enables
+"Log telemetry activity". `DrainTelematicInbox` now only recovers deliveries and
+finishes interrupted runs.
+
 ## Adding an adapter
 
 Implement `TelemetryProviderInterface` alongside the existing provider contract.

package/extension.json

@@ -1,6 +1,6 @@
 {
     "name": "Fleet-Ops",
-    "version": "0.6.68",
+    "version": "0.6.70",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "repository": "https://github.com/fleetbase/fleetops",
     "license": "AGPL-3.0-or-later",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fleetbase/fleetops-engine",
-    "version": "0.6.68",
+    "version": "0.6.70",
     "description": "Fleet & Transport Management Extension for Fleetbase",
     "fleetbase": {
         "route": "fleet-ops"
@@ -45,8 +45,8 @@
     "dependencies": {
         "@babel/core": "^7.23.2",
         "@fleetbase/ember-core": "^0.3.24",
-        "@fleetbase/ember-ui": "^0.4.1",
-        "@fleetbase/fleetops-data": "^0.2.1",
+        "@fleetbase/ember-ui": "^0.4.3",
+        "@fleetbase/fleetops-data": "^0.2.2",
         "@fleetbase/leaflet-routing-machine": "^3.2.17",
         "@fortawesome/ember-fontawesome": "^2.0.0",
         "@fortawesome/fontawesome-svg-core": "6.4.0",

package/scripts/pest-bootstrap.php

@@ -382,6 +382,18 @@ if (!interface_exists('Fleetbase\Ai\Contracts\AIActionCapabilityInterface')) {
     eval('namespace Fleetbase\Ai\Contracts; interface AIActionCapabilityInterface {}');
 }
 
+if (!interface_exists('Fleetbase\Ai\Contracts\AIToolCapabilityInterface')) {
+    eval('namespace Fleetbase\Ai\Contracts; interface AIToolCapabilityInterface {}');
+}
+
+if (!class_exists('Fleetbase\Ai\Support\AiAudience')) {
+    eval('namespace Fleetbase\Ai\Support; class AiAudience { public function __construct(public bool $isSystemAdmin = false, public array $granted = []) {} public function can(string $permission): bool { return $this->isSystemAdmin || in_array($permission, $this->granted, true); } public function canAll(array $permissions): bool { foreach ($permissions as $permission) { if (!$this->can($permission)) { return false; } } return true; } }');
+}
+
+if (!class_exists('Fleetbase\Ai\Support\AiToolContext')) {
+    eval('namespace Fleetbase\Ai\Support; class AiToolContext { public array $actionPreviews = []; public array $uiActions = []; public function __construct(public $task, public $audience) {} public function addActionPreview($capability, array $preview): array { $preview = array_merge(["preview_id" => "preview-" . (count($this->actionPreviews) + 1), "key" => $capability->key()], $preview); $this->actionPreviews[] = $preview; return $preview; } }');
+}
+
 if (!class_exists('Fleetbase\Ai\Models\AiTask')) {
     eval('namespace Fleetbase\Ai\Models; class AiTask { public function __construct(array $attributes = []) { foreach ($attributes as $key => $value) { $this->{$key} = $value; } } }');
 }

package/server/config/telemetry.php

@@ -13,8 +13,20 @@ return [
     'batch_size'                => env('TELEMATICS_BATCH_SIZE', 100),
     'max_payload_bytes'         => 2097152,
     'max_pending_deliveries'    => 10000,
+    // Administrators control infrastructure retention and activity logging.
+    // Companies may choose event/position history retention within the maximums.
+    // A maximum of 0 imposes no cap and permits unlimited history (retention 0).
     'processed_retention_hours' => 24,
     'quarantine_retention_days' => 7,
+    'sync_run_retention_days'   => 7,
+    'event_retention_days'      => 30,
+    'event_compact_after_days'  => 7,
+    'position_retention_days'   => 90,
+    'max_event_retention_days'  => 0,
+    'max_position_retention_days' => 0,
+    'log_telemetry_activity'    => false,
+    'prune_batch_size'          => 1000,
+    'prune_max_batches'         => 50,
     'stale_engine_on_seconds'   => 120,
     'stale_engine_off_seconds'  => 600,
 ];

package/server/migrations/2026_09_21_000001_convert_profile_only_users_to_managed_accounts.php

@@ -0,0 +1,132 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+/*
+ * Driver and customer login accounts are now managed by their FleetOps
+ * profile (user type `driver` or `customer`) instead of in IAM.
+ *
+ * Before this change the driver form created plain `user` accounts holding only
+ * the Driver role, so these accounts show up in IAM and can sign in to the
+ * console. This converts them to managed accounts. An account is converted only
+ * when it is clearly a profile login and nothing else: it has a driver or
+ * customer profile, every organization role it holds is the profile's role, it
+ * has no direct permissions or policies, and it owns no organization. Anything
+ * else is left as a team member.
+ *
+ * The previous type is kept in `meta.previous_type` so down() can revert it.
+ */
+return new class extends Migration {
+    private const PROFILE_ROLES = [
+        'driver'   => 'Driver',
+        'customer' => 'Fleet-Ops Customer',
+    ];
+
+    public function up(): void
+    {
+        if (!$this->hasRequiredTables()) {
+            return;
+        }
+
+        DB::table('users')
+            ->select(['uuid', 'meta'])
+            ->where('type', 'user')
+            ->whereNull('deleted_at')
+            ->where(function ($query) {
+                $query->whereExists(function ($query) {
+                    $query->selectRaw(1)->from('drivers')->whereColumn('drivers.user_uuid', 'users.uuid')->whereNull('drivers.deleted_at');
+                })->orWhereExists(function ($query) {
+                    $query->selectRaw(1)->from('contacts')->whereColumn('contacts.user_uuid', 'users.uuid')->where('contacts.type', 'customer')->whereNull('contacts.deleted_at');
+                });
+            })
+            ->whereNotExists(function ($query) {
+                $query->selectRaw(1)->from('companies')->whereColumn('companies.owner_uuid', 'users.uuid');
+            })
+            ->orderBy('uuid')
+            ->chunk(500, function ($users) {
+                foreach ($users as $user) {
+                    $type = $this->managedTypeFor($user->uuid);
+                    if (!$type) {
+                        continue;
+                    }
+
+                    $meta                  = json_decode($user->meta ?? '', true);
+                    $meta                  = is_array($meta) ? $meta : [];
+                    $meta['previous_type'] = 'user';
+
+                    DB::table('users')->where('uuid', $user->uuid)->update(['type' => $type, 'meta' => json_encode($meta)]);
+                }
+            });
+    }
+
+    public function down(): void
+    {
+        if (!Schema::hasTable('users')) {
+            return;
+        }
+
+        DB::table('users')
+            ->select(['uuid', 'meta'])
+            ->whereIn('type', array_keys(self::PROFILE_ROLES))
+            ->where('meta', 'like', '%"previous_type"%')
+            ->orderBy('uuid')
+            ->chunk(500, function ($users) {
+                foreach ($users as $user) {
+                    $meta = json_decode($user->meta ?? '', true);
+                    if (!is_array($meta) || ($meta['previous_type'] ?? null) !== 'user') {
+                        continue;
+                    }
+
+                    unset($meta['previous_type']);
+                    DB::table('users')->where('uuid', $user->uuid)->update(['type' => 'user', 'meta' => json_encode($meta)]);
+                }
+            });
+    }
+
+    /**
+     * The managed type for the account, or null when it should stay a team member.
+     */
+    private function managedTypeFor(string $userUuid): ?string
+    {
+        $hasDriver   = DB::table('drivers')->where('user_uuid', $userUuid)->whereNull('deleted_at')->exists();
+        $hasCustomer = DB::table('contacts')->where('user_uuid', $userUuid)->where('type', 'customer')->whereNull('deleted_at')->exists();
+
+        // An account holding both kinds of profile is a person the organization
+        // relates to in two ways; leave it for an administrator to decide.
+        if ($hasDriver === $hasCustomer) {
+            return null;
+        }
+
+        $type             = $hasDriver ? 'driver' : 'customer';
+        $companyUserUuids = DB::table('company_users')->where('user_uuid', $userUuid)->whereNull('deleted_at')->pluck('uuid');
+        $modelUuids       = $companyUserUuids->push($userUuid)->all();
+
+        $roles = DB::table('model_has_roles')
+            ->join('roles', 'roles.id', '=', 'model_has_roles.role_id')
+            ->whereIn('model_has_roles.model_uuid', $modelUuids)
+            ->pluck('roles.name')
+            ->unique();
+
+        if ($roles->isEmpty() || $roles->contains(fn ($role) => $role !== self::PROFILE_ROLES[$type])) {
+            return null;
+        }
+
+        $hasPermissions = DB::table('model_has_permissions')->whereIn('model_uuid', $modelUuids)->exists();
+        $hasPolicies    = DB::table('model_has_policies')->whereIn('model_uuid', $modelUuids)->exists();
+
+        return $hasPermissions || $hasPolicies ? null : $type;
+    }
+
+    private function hasRequiredTables(): bool
+    {
+        foreach (['users', 'drivers', 'contacts', 'companies', 'company_users', 'roles', 'model_has_roles', 'model_has_permissions', 'model_has_policies'] as $table) {
+            if (!Schema::hasTable($table)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};

package/server/migrations/2026_09_23_000001_add_retention_index_to_device_events.php

@@ -0,0 +1,40 @@
+<?php
+
+use Fleetbase\FleetOps\Support\Database\TableIndexes;
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Supports the bounded retention sweep in fleetops:prune-telematics-data,
+ * which ranges over these columns for every company on every run.
+ */
+return new class extends Migration {
+    private const TABLE   = 'device_events';
+    private const INDEX   = 'device_events_company_created_at_index';
+    private const COLUMNS = ['company_uuid', 'created_at'];
+
+    public function up(): void
+    {
+        if (!Schema::hasTable(self::TABLE) || !Schema::hasColumns(self::TABLE, self::COLUMNS)) {
+            return;
+        }
+
+        if (TableIndexes::covers(self::TABLE, self::COLUMNS)) {
+            return;
+        }
+
+        Schema::table(self::TABLE, fn (Blueprint $table) => $table->index(self::COLUMNS, self::INDEX));
+    }
+
+    public function down(): void
+    {
+        if (!Schema::hasTable(self::TABLE)) {
+            return;
+        }
+
+        if ((TableIndexes::for(self::TABLE)[self::INDEX] ?? null) === self::COLUMNS) {
+            Schema::table(self::TABLE, fn (Blueprint $table) => $table->dropIndex(self::INDEX));
+        }
+    }
+};