@fleetbase/fleetops-engine 0.6.68 → 0.6.69

package/server/tests/ModelAccessorContractsTest.php

@@ -130,14 +130,51 @@ class FleetOpsContactSyncUserFake extends Fleetbase\Models\User
         return true;
     }
 
+    public function save(array $options = []): bool
+    {
+        $this->updates[] = $this->getDirty();
+        $this->syncOriginal();
+
+        return true;
+    }
+
     public function delete()
     {
         $this->deleted = true;
+        $this->setAttribute('deleted_at', '2026-01-01 00:00:00');
 
         return true;
     }
 }
 
+function fleetopsModelAccessorsUseProfileAccountTables(): void
+{
+    $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
+    $schema     = $connection->getSchemaBuilder();
+    $schema->create('users', function ($table) {
+        $table->string('uuid')->nullable();
+        $table->string('type')->nullable();
+        $table->string('email')->nullable();
+        $table->string('phone')->nullable();
+        $table->timestamp('deleted_at')->nullable();
+    });
+    foreach (['drivers', 'contacts'] as $profileTable) {
+        $schema->create($profileTable, function ($table) {
+            $table->string('uuid')->nullable();
+            $table->string('user_uuid')->nullable();
+            $table->string('company_uuid')->nullable();
+            $table->timestamp('deleted_at')->nullable();
+        });
+    }
+
+    $resolver = new ConnectionResolver([
+        'default' => $connection,
+        'mysql'   => $connection,
+    ]);
+    $resolver->setDefaultConnection('mysql');
+    EloquentModel::setConnectionResolver($resolver);
+}
+
 class FleetOpsContactAccessorFake extends Contact
 {
     public array $loadedMissing                   = [];
@@ -858,6 +895,8 @@ test('contact accessors imports notifications and customer identity helpers are
 });
 
 test('contact user sync lookup and deletion guards are stable', function () {
+    fleetopsModelAccessorsUseProfileAccountTables();
+
     $user = new FleetOpsContactSyncUserFake();
     $user->setRawAttributes([
         'uuid'  => 'user-uuid',
@@ -868,22 +907,25 @@ test('contact user sync lookup and deletion guards are stable', function () {
     ], true);
 
     $contact           = new FleetOpsContactAccessorFake();
+    $contact->exists   = true;
     $contact->fakeUser = $user;
     $contact->setRawAttributes([
-        'uuid'      => 'contact-uuid',
-        'user_uuid' => 'not-a-uuid',
-        'type'      => 'customer',
-        'name'      => 'Old Name',
-        'email'     => 'old@example.com',
-        'phone'     => '+15550000000',
-        'timezone'  => 'UTC',
+        'uuid'         => 'contact-uuid',
+        'company_uuid' => 'company-uuid',
+        'user_uuid'    => 'not-a-uuid',
+        'type'         => 'customer',
+        'name'         => 'Old Name',
+        'email'        => 'old@example.com',
+        'phone'        => '+15550000000',
+        'timezone'     => 'UTC',
     ], true);
 
     $contact->name     = 'New Name';
-    $contact->email    = 'new@example.com';
-    $contact->phone    = '+15551112222';
+    $contact->email    = 'New@Example.com';
+    $contact->phone    = '+1 555-111-2222';
     $contact->timezone = 'Asia/Singapore';
 
+    // Proxy fields are normalized and pushed to the managed account
     expect($contact->syncWithUser())->toBeTrue()
         ->and($user->updates[0])->toBe([
             'name'     => 'New Name',
@@ -895,26 +937,46 @@ test('contact user sync lookup and deletion guards are stable', function () {
         ->and($contact->hasUser())->toBeTrue()
         ->and($contact->doesntHaveUser())->toBeFalse();
 
-    $deleteContact       = new FleetOpsContactAccessorFake();
-    $deleteContact->type = 'customer';
-    $deleteContact->setRelation('user', $user);
+    // An unsaved contact's account was just resolved from these values
+    $newContact           = new FleetOpsContactAccessorFake();
+    $newContact->fakeUser = $user;
+    $newContact->name     = 'Brand New';
+
+    // A saved contact with no proxy changes has nothing to sync
+    $cleanContact           = new FleetOpsContactAccessorFake();
+    $cleanContact->exists   = true;
+    $cleanContact->fakeUser = $user;
+    $cleanContact->setRawAttributes(['name' => 'New Name', 'type' => 'customer'], true);
+
+    expect($newContact->syncWithUser())->toBeFalse()
+        ->and($cleanContact->syncWithUser())->toBeFalse()
+        ->and($user->updates)->toHaveCount(1);
+
+    // Deleting the only profile holding a managed account deletes the account
+    $deleteContact               = new FleetOpsContactAccessorFake();
+    $deleteContact->type         = 'customer';
+    $deleteContact->company_uuid = 'company-uuid';
+    $deleteContact->fakeUser     = $user;
 
     expect($deleteContact->deleteUser())->toBeTrue()
-        ->and($user->deleted)->toBeTrue()
-        ->and($deleteContact->loadedMissing)->toBe(['user']);
+        ->and($user->deleted)->toBeTrue();
 
-    $mismatchedUser = new FleetOpsContactSyncUserFake();
-    $mismatchedUser->setRawAttributes(['type' => 'admin'], true);
+    // A team member's account linked to the contact is never deleted
+    $staffUser = new FleetOpsContactSyncUserFake();
+    $staffUser->setRawAttributes(['uuid' => 'staff-uuid', 'type' => 'admin'], true);
 
-    $mismatchedContact       = new FleetOpsContactAccessorFake();
-    $mismatchedContact->type = 'customer';
-    $mismatchedContact->setRelation('user', $mismatchedUser);
+    $staffContact           = new FleetOpsContactAccessorFake();
+    $staffContact->type     = 'customer';
+    $staffContact->fakeUser = $staffUser;
 
     $emptyContact           = new FleetOpsContactAccessorFake();
+    $emptyContact->exists   = true;
     $emptyContact->fakeUser = null;
     $emptyContact->setRawAttributes(['user_uuid' => 'not-a-uuid'], true);
+    $emptyContact->name = 'Changed';
 
-    expect($mismatchedContact->deleteUser())->toBeFalse()
+    expect($staffContact->deleteUser())->toBeFalse()
+        ->and($staffUser->deleted)->toBeFalse()
         ->and($emptyContact->syncWithUser())->toBeFalse()
         ->and($emptyContact->getUser())->toBeNull()
         ->and($emptyContact->hasUser())->toBeFalse()

package/server/tests/ObserverContractsTest.php

@@ -263,6 +263,7 @@ class FleetOpsDriverObserverUserFake extends User
     public function delete()
     {
         $this->deleted = true;
+        $this->setAttribute('deleted_at', '2026-01-01 00:00:00');
 
         return true;
     }
@@ -1149,14 +1150,30 @@ test('contact observer prevents changing existing customer contact type', functi
 });
 
 test('driver observer defaults location unassigns related records and deletes driver users', function () {
+    // releaseForProfile looks for the account's remaining driver/contact profiles
+    $connection = new Illuminate\Database\SQLiteConnection(new PDO('sqlite::memory:'));
+    $resolver   = new Illuminate\Database\ConnectionResolver(['default' => $connection, 'mysql' => $connection]);
+    $resolver->setDefaultConnection('mysql');
+    Illuminate\Database\Eloquent\Model::setConnectionResolver($resolver);
+    foreach (['drivers', 'contacts'] as $profileTable) {
+        $connection->getSchemaBuilder()->create($profileTable, function ($table) {
+            $table->string('uuid')->nullable();
+            $table->string('user_uuid')->nullable();
+            $table->string('company_uuid')->nullable();
+            $table->timestamp('deleted_at')->nullable();
+        });
+    }
+
     $driver = new Driver();
     $driver->setRawAttributes([
-        'uuid'      => 'driver-uuid',
-        'user_uuid' => 'user-uuid',
+        'uuid'         => 'driver-uuid',
+        'user_uuid'    => 'user-uuid',
+        'company_uuid' => 'company-uuid',
     ], true);
 
     $observer = new FleetOpsDriverObserverProbe();
     $user     = new FleetOpsDriverObserverUserFake();
+    $user->setRawAttributes(['uuid' => 'user-uuid', 'type' => 'driver'], true);
 
     $observer->user = $user;
     $observer->creating($driver);
@@ -1175,6 +1192,14 @@ test('driver observer defaults location unassigns related records and deletes dr
         ->and($observer->unassigned)->toBe(['driver-uuid'])
         ->and($user->deleted)->toBeTrue();
 
+    // A team member's account linked to the driver is never deleted
+    $staff = new FleetOpsDriverObserverUserFake();
+    $staff->setRawAttributes(['uuid' => 'staff-uuid', 'type' => 'user'], true);
+    $observer->user = $staff;
+    $observer->deleted($driver);
+
+    expect($staff->deleted)->toBeFalse();
+
     $driverWithLocation           = new Driver();
     $location                     = new Fleetbase\LaravelMysqlSpatial\Types\Point(1.3, 103.8);
     $driverWithLocation->location = $location;

package/server/tests/RequestContractsTest.php

@@ -534,10 +534,13 @@ namespace {
         $request     = new InternalCreateDriverRequest();
         $updateProbe = new FleetOpsInternalUpdateDriverRequestProbe();
 
+        // Email/phone availability is decided by ProfileAccountManager (a team
+        // member of the company is linked), so they're optional and not unique here.
         expect(ruleStrings($createRules['name']))->toContain('required', 'nullable', 'string', 'max:255')
-            ->and(ruleStrings($createRules['email']))->toContain('required')
-            ->and(ruleStrings($createRules['phone']))->toContain('required')
-            ->and(ruleStrings($userRules['name']))->not->toContain('required')
+            ->and(ruleStrings($createRules['email']))->toBe(['nullable'])
+            ->and(ruleStrings($createRules['phone']))->toBe(['nullable', 'string'])
+            ->and(ruleStrings($userRules['name']))->toContain('required')
+            ->and(ruleStrings(InternalCreateDriverRequest::create('/fleetops-test', 'POST', ['email' => 'driver@example.test'])->rules()['email']))->toBe(['nullable', 'email'])
             ->and(ruleStrings($patchRules['name']))->not->toContain('required')
             ->and($updateProbe->authorize())->toBeFalse();
 
@@ -556,9 +559,10 @@ namespace {
             ])
             ->and($request->messages())->toMatchArray([
                 'name.required'  => 'Driver name is required.',
-                'email.required' => 'Email address is required.',
+                'email.email'    => 'Please provide a valid email address.',
                 'password.min'   => 'Password must be at least 8 characters.',
-            ]);
+            ])
+            ->and($request->messages())->not->toHaveKeys(['email.required', 'email.unique', 'phone.required', 'phone.unique']);
     });
 
     test('public create order request validates payload alternatives and pod methods', function () {
@@ -929,12 +933,16 @@ namespace {
         expect($request->authorize())->toBeTrue()
             ->and(ruleStrings($createRules['name']))->toContain('required')
             ->and(ruleStrings($patchRules['name']))->not->toContain('required')
-            // Contact details are optional but still validated and still unique:
-            // an operational driver record may legitimately have neither.
-            ->and(ruleStrings($createRules['email']))->toContain('nullable', 'email', 'unique:users')
-            ->and(ruleStrings($createRules['email']))->not->toContain('required')
-            ->and(ruleStrings($createRules['phone']))->toContain('nullable', 'unique:users')
-            ->and(ruleStrings($createRules['phone']))->not->toContain('required')
+            // Contact details are optional but still validated: an operational
+            // driver record may legitimately have neither. On create, availability
+            // is decided by ProfileAccountManager (a team member is linked); on
+            // update they must stay unique among users.
+            ->and(ruleStrings($createRules['email']))->toContain('nullable', 'email')
+            ->and(ruleStrings($createRules['email']))->not->toContain('required', 'unique:users')
+            ->and(ruleStrings($createRules['phone']))->toContain('nullable')
+            ->and(ruleStrings($createRules['phone']))->not->toContain('required', 'unique:users')
+            ->and(ruleStrings($patchRules['email']))->toContain('nullable', 'unique:users')
+            ->and(ruleStrings($patchRules['phone']))->toContain('nullable', 'string', 'unique:users')
             ->and($createRules['password'])->toBe('nullable|string')
             ->and($createRules['country'])->toBe('nullable|size:2')
             ->and(ruleStrings($createRules['vehicle']))->toContain('nullable', 'string', 'starts_with:vehicle_', 'exists:vehicles,public_id')

package/server/tests/SupportJobAndAiCoverageTest.php

@@ -889,8 +889,8 @@ test('search resources capability metadata prompts terms and denied branches are
         ->and($capability->shouldResolve($task))->toBeTrue()
         ->and($capability->promptMatches('tell me about sensor SENSOR-1'))->toBeTrue()
         ->and($capability->promptMatches('compose a friendly email'))->toBeFalse()
-        ->and($capability->termsFor('Find order ORDER-123 for driver driver_456'))->toBe(['ORDER-123', 'for', 'driver_456'])
-        ->and($capability->termsFor('show order'))->toBe(['show order'])
+        ->and($capability->termsFor('Find order ORDER-123 for driver driver_456'))->toBe(['ORDER-123', 'driver_456'])
+        ->and($capability->termsFor('show order'))->toBe([])
         ->and($capability->genericWhenDenied())->toBe([])
         ->and($capability->allResourceBranchesWhenDenied(['needle']))->toBe([
             'orders'       => [],
@@ -903,7 +903,7 @@ test('search resources capability metadata prompts terms and denied branches are
             'telematics'   => [],
         ])
         ->and($capability->resolve($task))->toBe([
-            'query_terms' => ['DRV-123', 'and', 'TRUCK_9'],
+            'query_terms' => ['DRV-123', 'TRUCK_9'],
             'results'     => [],
         ]);
 });

package/server/tests/TelematicControllerContractsTest.php

@@ -159,6 +159,7 @@ test('internal customer controller serializes portal login payloads', function (
     $customer->setRelation('user', (object) [
         'uuid'           => 'user-uuid',
         'public_id'      => 'user-public',
+        'type'           => 'customer',
         'name'           => 'Ada Customer',
         'email'          => 'ada@example.test',
         'phone'          => '+15551234567',
@@ -168,10 +169,12 @@ test('internal customer controller serializes portal login payloads', function (
     ]);
 
     expect($controller->callHelper('customerPayload', $customer))->toBe([
-        'id'        => 'customer-public',
-        'uuid'      => 'customer-uuid',
-        'user_uuid' => 'user-uuid',
-        'user'      => [
+        'id'              => 'customer-public',
+        'uuid'            => 'customer-uuid',
+        'user_uuid'       => 'user-uuid',
+        'is_staff_linked' => false,
+        'login_status'    => 'active',
+        'user'            => [
             'id'             => 'user-public',
             'uuid'           => 'user-uuid',
             'name'           => 'Ada Customer',
@@ -182,4 +185,19 @@ test('internal customer controller serializes portal login payloads', function (
             'avatar_url'     => 'https://example.test/avatar.png',
         ],
     ]);
+
+    // A customer linked to a team member's account is reported as staff-linked
+    $customer->setRelation('user', (object) ['uuid' => 'staff-uuid', 'public_id' => 'staff-public', 'type' => 'user', 'status' => 'inactive']);
+    $staffPayload = $controller->callHelper('customerPayload', $customer);
+
+    expect($staffPayload['is_staff_linked'])->toBeTrue()
+        ->and($staffPayload['login_status'])->toBe('inactive');
+
+    // A customer without a login account is neither
+    $customer->setRelation('user', null);
+    $emptyPayload = $controller->callHelper('customerPayload', $customer);
+
+    expect($emptyPayload['is_staff_linked'])->toBeFalse()
+        ->and($emptyPayload['login_status'])->toBeNull()
+        ->and($emptyPayload['user'])->toBeNull();
 });

package/server/tests/Unit/Models/ContactCustomerUserTest.php

@@ -9,7 +9,7 @@ if (!Illuminate\Support\Str::hasMacro('humanize')) {
 }
 
 use Fleetbase\FleetOps\Exceptions\CustomerUserConflictException;
-use Fleetbase\FleetOps\Exceptions\UserAlreadyExistsException;
+use Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException;
 use Fleetbase\FleetOps\Models\Contact;
 use Fleetbase\Models\User;
 use Illuminate\Database\ConnectionResolver;
@@ -75,9 +75,38 @@ function fleetopsContactCustomerUserBoot(): SQLiteConnection
     });
     Illuminate\Support\Facades\DB::clearResolvedInstance('db');
 
+    app()->instance('hash', new class implements Illuminate\Contracts\Hashing\Hasher {
+        public function info($hashedValue): array
+        {
+            return [];
+        }
+
+        public function make($value, array $options = []): string
+        {
+            return md5((string) $value);
+        }
+
+        public function check($value, $hashedValue, array $options = []): bool
+        {
+            return md5((string) $value) === $hashedValue;
+        }
+
+        public function needsRehash($hashedValue, array $options = []): bool
+        {
+            return false;
+        }
+
+        public function verifyConfiguration($value): bool
+        {
+            return true;
+        }
+    });
+    Illuminate\Support\Facades\Hash::clearResolvedInstance('hash');
+
     $schema = $connection->getSchemaBuilder();
     $tables = [
         'contacts'              => ['uuid', 'public_id', 'company_uuid', 'user_uuid', 'name', 'email', 'phone', 'type', 'title'],
+        'drivers'               => ['uuid', 'public_id', 'company_uuid', 'user_uuid'],
         'users'                 => ['uuid', 'public_id', 'company_uuid', 'name', 'email', 'phone', 'username', 'password', 'timezone', 'status', 'type', 'slug', 'avatar_uuid', 'last_login'],
         'companies'             => ['uuid', 'public_id', 'name', 'timezone', 'owner_uuid'],
         'company_users'         => ['uuid', 'company_uuid', 'user_uuid', 'status'],
@@ -188,24 +217,45 @@ test('create user from contact adopts an existing matching user', function () {
         ->and($connection->table('users')->count())->toBe(1);
 });
 
-test('create user from contact rejects users already linked to another contact', function () {
+test('create user from contact rejects an account that already holds a contact in the company', function () {
     $connection = fleetopsContactCustomerUserBoot();
-    // The contact user() relation constrains users.type against the querying
-    // contact type, which is null in the static whereHas context — a null-typed
-    // user keeps the linked-contact subquery matchable.
-    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'taken@example.com', 'type' => null]);
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'taken@example.com', 'type' => 'contact']);
     $connection->table('contacts')->insert(['uuid' => 'contact-owner', 'company_uuid' => 'company-1', 'user_uuid' => 'user-9', 'name' => 'Owner', 'type' => 'contact']);
     $contact = fleetopsContactCustomerUserContact(['uuid' => 'contact-2', 'email' => 'taken@example.com']);
 
-    expect(fn () => Contact::createUserFromContact($contact))->toThrow(UserAlreadyExistsException::class);
+    expect(fn () => Contact::createUserFromContact($contact))
+        ->toThrow(ProfileIdentityConflictException::class, 'A contact with this email already exists.');
 });
 
-test('create user from contact rejects staff users for customer contacts', function () {
+test('create user from contact rejects staff users of another organization for customer contacts', function () {
     $connection = fleetopsContactCustomerUserBoot();
-    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'staff']);
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-other', 'email' => 'staff@example.com', 'type' => 'user']);
     $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'staff@example.com']);
 
-    expect(fn () => Contact::createUserFromContact($contact))->toThrow(CustomerUserConflictException::class);
+    expect(fn () => Contact::createUserFromContact($contact))
+        ->toThrow(ProfileIdentityConflictException::class, 'This email is already in use by another account.');
+});
+
+test('create user from contact links a staff member of the organization without changing their role', function () {
+    $connection = fleetopsContactCustomerUserBoot();
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'user']);
+    $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'Staff@Example.com']);
+
+    $user = Contact::createUserFromContact($contact);
+
+    expect($user->uuid)->toBe('user-9')
+        ->and($user->type)->toBe('user')
+        ->and($contact->user_uuid)->toBe('user-9')
+        ->and($connection->table('model_has_roles')->count())->toBe(0);
+});
+
+test('create user from contact rejects a managed account of another type', function () {
+    $connection = fleetopsContactCustomerUserBoot();
+    $connection->table('users')->insert(['uuid' => 'user-9', 'company_uuid' => 'company-1', 'phone' => '+6591112222', 'type' => 'driver']);
+    $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'phone' => '+65 9111-2222']);
+
+    expect(fn () => Contact::createUserFromContact($contact))
+        ->toThrow(ProfileIdentityConflictException::class, 'This phone number is already used by a driver.');
 });
 
 test('create user from contact assigns the customer role and persists the link', function () {
@@ -305,17 +355,27 @@ test('identity lookup helpers resolve users by email phone and uuid', function (
 
 test('assert customer identity is available detects staff conflicts', function () {
     $connection = fleetopsContactCustomerUserBoot();
-    $connection->table('users')->insert(['uuid' => 'user-1', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'staff']);
+    $connection->table('users')->insert([
+        ['uuid' => 'user-1', 'company_uuid' => 'company-1', 'email' => 'staff@example.com', 'type' => 'staff'],
+        ['uuid' => 'user-2', 'company_uuid' => 'company-1', 'email' => 'driver@example.com', 'type' => 'driver'],
+    ]);
 
     $nonCustomer = fleetopsContactCustomerUserContact();
     $nonCustomer->assertCustomerIdentityIsAvailable();
 
-    $conflicted = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'staff@example.com']);
-    expect(fn () => $conflicted->assertCustomerIdentityIsAvailable())->toThrow(CustomerUserConflictException::class);
+    // A staff member of the organization can hold a customer profile
+    $staffMember = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'staff@example.com']);
+    $staffMember->assertCustomerIdentityIsAvailable();
+
+    // A driver's managed account cannot
+    $conflicted = fleetopsContactCustomerUserContact(['type' => 'customer', 'email' => 'driver@example.com']);
+    expect(fn () => $conflicted->assertCustomerIdentityIsAvailable())
+        ->toThrow(CustomerUserConflictException::class, 'This email is already used by a driver and cannot be used for a customer account.');
 
     // An already-assigned user is checked ahead of the identity lookup, so a
     // contact whose email matches nothing still trips on its own assignment
-    $connection->table('users')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'company_uuid' => 'company-1', 'email' => 'assigned@example.com', 'type' => 'staff']);
+    // (a staff account of another organization)
+    $connection->table('users')->insert(['uuid' => '33333333-3333-4333-8333-333333333333', 'company_uuid' => 'company-other', 'email' => 'assigned@example.com', 'type' => 'staff']);
     $assigned = fleetopsContactCustomerUserContact([
         'type'      => 'customer',
         'email'     => 'unmatched@example.com',
@@ -368,3 +428,19 @@ test('normalize customer user creates company membership and assigns the custome
     expect($connection->table('company_users')->where('user_uuid', 'user-n1')->count())->toBe(1)
         ->and($connection->table('model_has_roles')->count())->toBeGreaterThanOrEqual(1);
 });
+
+test('normalize customer user keeps a staff member of the organization untouched', function () {
+    $connection = fleetopsContactCustomerUserBoot();
+    $connection->table('companies')->insert(['uuid' => 'company-1', 'name' => 'Acme']);
+    $connection->table('users')->insert(['uuid' => 'user-s1', 'company_uuid' => 'company-1', 'name' => 'Staff', 'email' => 'staff@example.com', 'type' => 'user', 'status' => 'active']);
+
+    $contact = fleetopsContactCustomerUserContact(['type' => 'customer', 'user_uuid' => 'user-s1']);
+    $user    = User::where('uuid', 'user-s1')->first();
+
+    expect($contact->normalizeCustomerUser($user))->toBe($user)
+        ->and($contact->getRelation('user'))->toBe($user)
+        // A team member's account keeps its own organization membership and role
+        ->and($connection->table('company_users')->count())->toBe(0)
+        ->and($connection->table('model_has_roles')->count())->toBe(0)
+        ->and($connection->table('users')->where('uuid', 'user-s1')->value('type'))->toBe('user');
+});

package/server/tests/Unit/Models/ContactTest.php

@@ -25,7 +25,8 @@ class FleetOpsContactUnitCompanyFake extends Company
     public array $addUserCalls                              = [];
     public ?FleetOpsContactUnitCompanyUserFake $companyUser = null;
 
-    public function addUser(User $user, string $role = 'Administrator', string $status = 'active'): CompanyUser
+    // Matches core-api 1.6.63+, where no role is granted unless one is given.
+    public function addUser(User $user, ?string $role = null, string $status = 'active'): CompanyUser
     {
         $this->addUserCalls[] = [$user, $role, $status];
 
@@ -71,9 +72,18 @@ class FleetOpsContactUnitUserFake extends User
         return true;
     }
 
+    public function save(array $options = []): bool
+    {
+        $this->updates[] = $this->getDirty();
+        $this->syncOriginal();
+
+        return true;
+    }
+
     public function delete()
     {
         $this->deleted = true;
+        $this->setAttribute('deleted_at', '2026-01-01 00:00:00');
 
         return true;
     }
@@ -180,6 +190,16 @@ class FleetOpsContactUnitAssignableFake extends FleetOpsContactUnitFake
     }
 }
 
+function fleetopsContactUnitUseProfileTables(): SQLiteConnection
+{
+    $connection = fleetopsContactUnitUseInMemoryConnection();
+    $connection->statement('create table drivers (uuid varchar(64), user_uuid varchar(64) null, company_uuid varchar(64) null, deleted_at datetime null)');
+    $connection->statement('create table contacts (uuid varchar(64), user_uuid varchar(64) null, company_uuid varchar(64) null, deleted_at datetime null)');
+    $connection->statement('create table company_users (uuid varchar(64), user_uuid varchar(64) null, company_uuid varchar(64) null, created_at datetime null, updated_at datetime null, deleted_at datetime null)');
+
+    return $connection;
+}
+
 function fleetopsContactUnitUseInMemoryConnection(): SQLiteConnection
 {
     $connection = new SQLiteConnection(new PDO('sqlite::memory:'));
@@ -496,6 +516,8 @@ test('contact user conflict helpers guard staff users and allow customers', func
 });
 
 test('contact sync delete and user presence helpers use loaded user relations', function () {
+    fleetopsContactUnitUseProfileTables();
+
     $user = new FleetOpsContactUnitUserFake();
     $user->setRawAttributes([
         'uuid' => 'user-uuid',
@@ -521,6 +543,7 @@ test('contact sync delete and user presence helpers use loaded user relations',
     ]);
     $contact->setRelation('user', $user);
     $contact->fakeUser = $user;
+    $contact->exists   = true;
 
     expect($contact->syncWithUser())->toBeTrue()
         ->and($user->updates)->toBe([[
@@ -543,20 +566,40 @@ test('contact sync delete and user presence helpers use loaded user relations',
         ->and($unlinked->doesntHaveUser())->toBeTrue();
 });
 
-test('contact delete user ignores mismatched relation types', function () {
+test('contact delete user leaves team member accounts alone', function () {
     $user = new FleetOpsContactUnitUserFake();
     $user->setRawAttributes([
         'uuid' => 'user-uuid',
-        'type' => 'customer',
+        'type' => 'user',
     ], true);
 
-    $contact = new FleetOpsContactUnitFake(['type' => 'contact']);
-    $contact->setRelation('user', $user);
+    $contact           = new FleetOpsContactUnitFake(['type' => 'customer']);
+    $contact->fakeUser = $user;
 
     expect($contact->deleteUser())->toBeFalse()
         ->and($user->deleted)->toBeFalse();
 });
 
+test('contact delete user keeps a managed account still used by another organization', function () {
+    $connection = fleetopsContactUnitUseProfileTables();
+    $connection->table('drivers')->insert(['uuid' => 'driver-elsewhere', 'user_uuid' => 'user-uuid', 'company_uuid' => 'other-company']);
+    $connection->table('company_users')->insert([
+        ['uuid' => 'cu-1', 'user_uuid' => 'user-uuid', 'company_uuid' => 'company-uuid'],
+        ['uuid' => 'cu-2', 'user_uuid' => 'user-uuid', 'company_uuid' => 'other-company'],
+    ]);
+
+    $user = new FleetOpsContactUnitUserFake();
+    $user->setRawAttributes(['uuid' => 'user-uuid', 'type' => 'driver'], true);
+
+    $contact           = new FleetOpsContactUnitFake(['type' => 'contact', 'company_uuid' => 'company-uuid']);
+    $contact->fakeUser = $user;
+
+    // The account only leaves this organization
+    expect($contact->deleteUser())->toBeFalse()
+        ->and($user->deleted)->toBeFalse()
+        ->and($connection->table('company_users')->whereNull('deleted_at')->pluck('company_uuid')->all())->toBe(['other-company']);
+});
+
 test('contact real user helpers return loaded relations without database lookup', function () {
     $user = new FleetOpsContactUnitUserFake();
     $user->setRawAttributes([

package/server/tests/Unit/Models/SensorTest.php

@@ -116,7 +116,7 @@ test('sensor model exposes relation builders and logging options', function () {
 
     $sensor = new Sensor();
 
-    expect($sensor->getSlugOptions()->generateSlugFrom)->toBe(['name', 'sensor_type'])
+    expect($sensor->getSlugOptions()->generateSlugFrom)->toBe(['name', 'type'])
         ->and($sensor->getSlugOptions()->slugField)->toBe('slug')
         ->and($sensor->getActivitylogOptions()->logOnlyDirty)->toBeTrue()
         ->and($sensor->telematic())->toBeInstanceOf(BelongsTo::class)
@@ -222,7 +222,7 @@ test('sensor scopes write expected query constraints', function () {
             ->and($sensor->scopeActive($query))->toBe($query)
             ->and($sensor->scopeWithRecentReadings($query, 30))->toBe($query)
             ->and($sensor->scopeOutOfThreshold($query))->toBe($query)
-            ->and($query->calls[0])->toBe(['where', ['sensor_type', 'temperature']])
+            ->and($query->calls[0])->toBe(['where', ['type', 'temperature']])
             ->and($query->calls[1])->toBe(['where', ['status', 'active']])
             ->and($query->calls[2][0])->toBe('where')
             ->and($query->calls[2][1][0])->toBe('last_reading_at')