#6217: the other half of Help Desk Settings reaches the Changes log

`registerAuditedModels()` (#4781) declared four models. The Settings page
has seven tabs, and a sweep found Groups and Agents fully audited beside
Priorities, Statuses, Projects, Email connections and Automation writing
nothing at all — zero rows for any of their routes in the whole store.

`PriorityLevel`, `TicketStatus` and `TicketingProject` are now declared,
in the shape the existing four use. `color` and `description` are left
out of all three for the reason the group's colour is.

The Email tab could not be declared. Its mailbox host, port, username and
PASSWORD live in one `config` JSON column, and `Audit::redact()` masks by
top-level field name only — `normalize()` walks into an array and never
redacts inside one — so declaring `config` would write the school's
mailbox credential in clear into a table read under `logs.view` alone.
Declaring only the scalar columns is the other trap: an update that moved
no declared field records nothing, so re-pointing a connection at a
different mailbox would still have been silent, which is the write the
card was filed about. `EmailConnectionAudit` is therefore the one writer
for that tab, flattening `config` into `config.host` / `config.password`
keys — the spelling the central redaction masks — and masking the secret
at source as well, so the credential never reaches the logger at all.
`EmailConnectionAuditLabels` declares the label with no observer, the
shape `PulseAuditLabels` and `GroupAuditLabels` use, so those rows are
not doubled.

The Automation tab writes shell `Setting` rows, which no declaration here
could reach; `AutomationSettingsAudit` records one row per save naming
only what moved.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

database/migrations/2026_10_21_000001_add_recovered_by_to_ticketing_agent_access.php

@@ -0,0 +1,43 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * WHO WROTE THIS ROW AS A RESCUE — [central-ticketing] #5002.
+ *
+ * #4806 let a site admin appoint somebody to a help desk group that has no
+ * manager left who could still act. That write is the only way back into such
+ * a group, and it ENDS the condition that allowed it: appoint a `manager` and
+ * the group has a manager again, so the recovery arm shuts behind the press.
+ * With `destroyAgent()` gated on plain manager rights, a rescuer who named the
+ * wrong person could not take the row back — the only person who could was the
+ * person wrongly appointed.
+ *
+ * `orphanedGroupIds()` cannot tell that case from a healthy group with one
+ * working manager: both are "orphaned if you disregard this row", and allowing
+ * the second would let any site admin strip a manager from a group that is
+ * none of their business (#4710). So the row has to say where it came from.
+ *
+ * Nullable, and null on every row written the ordinary way: this is not
+ * "created_by", it is "this row exists because <user> rescued the group, and
+ * it is theirs to undo". No foreign key — `user_id` on this table has none
+ * either, and a deleted rescuer should leave the row alone, not take it.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('ticketing_agent_access', function (Blueprint $table) {
+            $table->unsignedBigInteger('recovered_by')->nullable()->after('role');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('ticketing_agent_access', function (Blueprint $table) {
+            $table->dropColumn('recovered_by');
+        });
+    }
+};

src/Console/Commands/AutoCloseTickets.php

@@ -22,9 +22,39 @@ class AutoCloseTickets extends Command
 
         $cutoff = now()->subDays($days);
 
-        $count = Ticket::where('status', 'resolved')
+        /*
+         * CLOSED ONE AT A TIME, THROUGH THE MODEL — [central-ticketing] #4781.
+         *
+         * This was a single `->update(['status' => 'closed'])`, which is one
+         * statement and no model events. Since #4781 a ticket's status change is
+         * an audited fact, and a bulk update would have left exactly one way of
+         * closing a ticket invisible: the Changes log would show a ticket going
+         * open → resolved and then nothing, while the row itself said `closed`.
+         * "Who closed this" is the question the audit trail exists to answer,
+         * and "the nightly sweep did, on this date" is a real answer — but only
+         * if the sweep writes it.
+         *
+         * Per-ticket rather than one summary event because the answer has to be
+         * on THE TICKET: the per-record history panel reads rows whose subject
+         * is that ticket, and an aggregate "closed 14 tickets" row would not
+         * appear in any of their histories.
+         *
+         * `chunkById`, so a first sweep over a long backlog does not load every
+         * resolved ticket into memory at once. Paging by id is what makes this
+         * safe while the filtered column is being written: each page continues
+         * from the last id seen rather than from an offset, so rows dropping out
+         * of `status = 'resolved'` cannot cause a page to be skipped.
+         */
+        $count = 0;
+
+        Ticket::where('status', 'resolved')
             ->where('updated_at', '<=', $cutoff)
-            ->update(['status' => 'closed']);
+            ->chunkById(200, function ($tickets) use (&$count) {
+                foreach ($tickets as $ticket) {
+                    $ticket->forceFill(['status' => 'closed'])->save();
+                    $count++;
+                }
+            });
 
         $this->info("Auto-closed {$count} ticket(s) resolved more than {$days} day(s) ago.");
 

src/Http/Controllers/TicketController.php

@@ -5,6 +5,7 @@ namespace Dashboard\Ticketing\Http\Controllers;
 use App\Models\Setting;
 use App\Models\User;
 use App\Support\PersonChip;
+use App\Support\PersonNames;
 use Dashboard\Ticketing\Models\PriorityLevel;
 use Dashboard\Ticketing\Models\Ticket;
 use Dashboard\Ticketing\Models\TicketAttachment;
@@ -1081,9 +1082,17 @@ class TicketController extends Controller
             return $refusal;
         }
 
+        // Fetched and deleted one model at a time rather than as a query-builder
+        // delete, because a builder delete fires no model events — and since
+        // #4781 a TicketParticipant row IS an audited fact (who can see this
+        // ticket's correspondence). Deleting in bulk here would have recorded
+        // every add and no removal, which is a worse trail than none: it reads
+        // as though nobody is ever taken off a ticket. ->get() rather than
+        // ->first(), so a duplicated pair is still fully removed.
         TicketParticipant::where('ticket_id', $ticket->id)
             ->where('user_id', $userId)
-            ->delete();
+            ->get()
+            ->each->delete();
 
         return back()->with('success', 'Participant removed.');
     }
@@ -1134,11 +1143,23 @@ class TicketController extends Controller
      *    operator-precedence hole the same shape opened on [central-inventory]
      *    #1594.
      *
-     * `orderBy('name')` is new and is the only visible difference: the old query
+     * AN ORDER AT ALL is new, and it is `PersonNames::orderUsers()` rather than
-     * had no order at all, so ten rows arrived in whatever order the storage
+     * `orderBy('name')`. The old query had no order, so ten rows arrived in
-     * engine happened to return them and the same two letters could list the
+     * whatever sequence the storage engine happened to return them and the same
-     * same people differently twice running. The reference search orders by
+     * two letters could list the same people differently twice running. But the
-     * name, and "a consistent shape" is what this card is for.
+     * column that makes an order CONSISTENT is not automatically the one that
+     * makes it READABLE: `users.name` is the cached "First Last" ("Andrew Fast")
+     * and these rows are chips, which read "Last, First" ("Fast, Andrew"). A
+     * list labelled one way and collated the other is what an operator calls
+     * unsorted — "Toews, Fast, Ivanov, Mwangi, Bergman" is perfectly ordered by
+     * a string the row no longer shows. `PersonNames::orderUsers()` is the
+     * platform's one answer to that (#524), it is what the reference search
+     * (`admin.settings.users.search`) and the sibling conversions use, and it
+     * honours the operator's `name_format` rather than assuming surname-first.
+     *
+     * It also decides WHICH TEN come back, not merely their sequence, so this is
+     * not cosmetic: on a common surname the limit falls on a different set of
+     * people under the two collations.
      */
     public function searchUsers(Request $request, Ticket $ticket)
     {
@@ -1163,7 +1184,7 @@ class TicketController extends Controller
                       ->orWhere('email', 'like', "%{$q}%");
             })
                 ->whereNotIn('id', $excludeIds)
-                ->orderBy('name')
+                ->tap(fn ($query) => PersonNames::orderUsers($query))
                 ->limit(10)
                 ->get(PersonChip::columns())
         ));

src/Http/Controllers/TicketingSettingsController.php

@@ -3,12 +3,17 @@
 namespace Dashboard\Ticketing\Http\Controllers;
 
 use App\Models\Setting;
+use App\Models\User;
+use App\Support\PersonChip;
+use App\Support\PersonNames;
 use Dashboard\Ticketing\Models\EmailConnection;
 use Dashboard\Ticketing\Models\PriorityLevel;
 use Dashboard\Ticketing\Models\TicketingAgentAccess;
 use Dashboard\Ticketing\Models\TicketingGroup;
 use Dashboard\Ticketing\Models\TicketingProject;
 use Dashboard\Ticketing\Models\TicketStatus;
+use Dashboard\Ticketing\Support\AutomationSettingsAudit;
+use Dashboard\Ticketing\Support\EmailConnectionAudit;
 use Dashboard\Ticketing\Support\MergedTicketRepair;
 use Illuminate\Http\Request;
 use Illuminate\Routing\Controller;
@@ -31,8 +36,21 @@ class TicketingSettingsController extends Controller
      */
     private function isSiteAdmin(): bool
     {
-        $user = Auth::user();
+        return $this->isSiteAdminUser(Auth::user());
-        return $user && ($user->is_super_admin || $user->can('ticketing.settings'));
+    }
+
+    /**
+     * The same question asked about SOMEBODY ELSE — one definition, two callers.
+     *
+     * #4806 needs to know whether the manager a group already has could still
+     * use this page, which is isSiteAdmin()'s test applied to a user who is not
+     * signed in. Two copies of that rule would drift, and the drift would be
+     * invisible: the recovery path below opens exactly when this returns false
+     * for every manager of a group.
+     */
+    private function isSiteAdminUser(?User $user): bool
+    {
+        return $user !== null && ($user->is_super_admin || $user->can('ticketing.settings'));
     }
 
     /**
@@ -54,15 +72,175 @@ class TicketingSettingsController extends Controller
         }
     }
 
+    /**
+     * Require manager rights over one group.
+     *
+     * Deliberately NOT widened to site admins: GroupRetirementTest pins that a
+     * super admin with no agent access is refused here, and #4710 is a
+     * visibility bug, not a licence to hand every `ticketing.settings` holder
+     * manager rights over every group. Seeing a group you do not manage is the
+     * fix; acting on it is a separate decision for a human to make.
+     *
+     * TWO writes do not come through here, and they are the same write in
+     * both directions. `storeAgent()` uses
+     * requireManagerAccessOrOrphanRecovery(), because a group with no manager
+     * left has nobody this gate could ever admit, and the group and its
+     * tickets are frozen for good (#4806); `destroyAgent()` uses
+     * requireRemoveAccess(), so that recovery is not one-way (#5002) — an
+     * appoint that could never be un-appointed froze the group again through
+     * its own cure. Every other write on somebody else's group still ends up
+     * here.
+     */
     private function requireManagerAccess(int $groupId): void
     {
-        $isManager = TicketingAgentAccess::where('user_id', Auth::id())
+        if (!$this->isManagerOf($groupId)) {
+            abort(403);
+        }
+
+        $this->settleRescueStamp($groupId);
+    }
+
+    /**
+     * THE RESCUE STAMP ENDS WHEN THE APPOINTEE USES WHAT IT GAVE THEM — #5008.
+     *
+     * `recovered_by` (#5002) exists so a rescuer can take back an appointment
+     * they got wrong, including a `manager` press that shut the orphan arm
+     * behind it. It was written as an undo and it has to expire like one. As
+     * first built, the only thing that cleared it was the appointee re-saving
+     * their own row — a write nobody makes — so the stamp sat on the row for
+     * good, and a successful rescue left the rescuer a standing lever over a
+     * desk somebody else was now running: strip the manager, then "rescue" the
+     * group that press just orphaned, and a site admin who never ran it
+     * manages it (#5008). That is #4710's line, which the undo must not cross.
+     *
+     * So the stamp settles the moment the appointee ACTS as the manager they
+     * were made: staffs the group, renames it, archives it, gives it a project
+     * or an email connection — anything this file lets a manager do to their
+     * own group. The rescue has been taken up, the group is theirs, and the
+     * rescuer's claim on it is spent. Until then nothing has happened but the
+     * press itself, which is exactly the case the undo is for.
+     *
+     * Called from the gates and not from each action because the gates are
+     * where "this write was authorised by the actor's OWN manager row" is
+     * already decided; a read of the page never comes through them.
+     */
+    private function settleRescueStamp(int $groupId): void
+    {
+        TicketingAgentAccess::where('user_id', Auth::id())
+            ->where('group_id', $groupId)
+            ->whereNotNull('recovered_by')
+            ->update(['recovered_by' => null]);
+    }
+
+    /** Does the signed-in user hold a `manager` row on this group? */
+    private function isManagerOf(int $groupId): bool
+    {
+        return TicketingAgentAccess::where('user_id', Auth::id())
             ->where('group_id', $groupId)
             ->where('role', 'manager')
             ->exists();
-        if (!$isManager) {
+    }
-            abort(403);
+
+    /**
+     * Could this person still administer a help desk group today?
+     *
+     * NOT "do they hold a manager row" — the row is what we are judging. This
+     * asks whether, if they signed in right now, the Agents tab's own POST
+     * would work for them: the account has to still exist, still be active,
+     * and still hold the permission every route in this file sits behind.
+     *
+     * A manager row outlives all three. On dev the sole manager of all 15
+     * groups was a live row pointing at an account that had been rewritten
+     * into an admissions-only applicant (#4202/#4203) — it could not reach
+     * /app/ticketing at all, and the Agents tab was still telling site admins
+     * to go and ask them (#4806).
+     */
+    private function canStillAdminister(?User $user): bool
+    {
+        if ($user === null || !($user->is_active ?? true)) {
+            return false;
         }
+
+        return $this->isSiteAdminUser($user);
+    }
+
+    /**
+     * The groups nobody is left to run — every `manager` row on them points at
+     * somebody canStillAdminister() says no to (or there is no manager row at
+     * all).
+     *
+     * This is the ONLY condition under which a site admin may write an agent
+     * row for a group they do not manage. It is deliberately a property of the
+     * GROUP, not of the caller: an orphaned group cannot be rescued by anyone
+     * else, and a group with a working manager is still none of an admin's
+     * business (#4710).
+     *
+     * `$onlyGroupIds` narrows both queries for the single-group gate; `null`
+     * means "every group", which is what the page's prop needs.
+     *
+     * @param  int[]|null  $onlyGroupIds
+     * @return int[]
+     */
+    private function orphanedGroupIds(?array $onlyGroupIds = null): array
+    {
+        $groupIds = TicketingGroup::when($onlyGroupIds !== null,
+                fn($q) => $q->whereIn('id', $onlyGroupIds))
+            ->pluck('id');
+
+        if ($groupIds->isEmpty()) {
+            return [];
+        }
+
+        $managerRows = TicketingAgentAccess::where('role', 'manager')
+            ->whereIn('group_id', $groupIds)
+            ->get(['group_id', 'user_id']);
+
+        // One can() per distinct manager, not per row: the dev case is one
+        // person holding the manager row on all fifteen groups.
+        $managerIds = $managerRows->pluck('user_id')->unique();
+        $actingIds  = $managerIds->isEmpty()
+            ? collect()
+            : User::whereIn('id', $managerIds)->get()
+                ->filter(fn($u) => $this->canStillAdminister($u))
+                ->pluck('id');
+
+        $covered = $managerRows
+            ->filter(fn($r) => $actingIds->contains($r->user_id))
+            ->pluck('group_id')
+            ->unique();
+
+        return $groupIds->reject(fn($id) => $covered->contains($id))->values()->all();
+    }
+
+    /**
+     * Manager rights over one group, OR a site admin rescuing an orphaned one.
+     *
+     * The second arm is #4806 and nothing wider: the moment a group's last
+     * usable manager leaves, is deactivated or is diverted elsewhere, every
+     * write in this file 403s for everybody — the group cannot be renamed,
+     * archived, given a project or given a single agent, and its tickets can
+     * never be assigned or closed. The documented answer on the Agents tab was
+     * "ask a manager of the group", which on such a group names nobody.
+     *
+     * So: a site admin may appoint somebody to a group that has no manager
+     * left. That one write un-orphans the group, and from the next request on
+     * the ordinary requireManagerAccess() rule governs it again — including
+     * for the admin, who gets no standing rights over it unless they appointed
+     * themselves.
+     */
+    private function requireManagerAccessOrOrphanRecovery(int $groupId): void
+    {
+        if ($this->isManagerOf($groupId)) {
+            $this->settleRescueStamp($groupId);
+
+            return;
+        }
+
+        if ($this->isSiteAdmin() && $this->orphanedGroupIds([$groupId]) !== []) {
+            return;
+        }
+
+        abort(403);
     }
 
     public function index(?string $tab = null): Response
@@ -71,14 +249,38 @@ class TicketingSettingsController extends Controller
 
         $userId = Auth::id();
         $isBootstrap = $this->isBootstrapState();
+        $isSiteAdmin = $this->isSiteAdmin();
         $myGroupIds = TicketingAgentAccess::where('user_id', $userId)->pluck('group_id');
 
+        // The groups this user may actually ACT on — requireManagerAccess() in
+        // prop form. A site admin now sees groups they do not manage (#4710),
+        // so the page has to say which rows its buttons will work on instead
+        // of offering an Edit that 403s.
+        $myManagedGroupIds = TicketingAgentAccess::where('user_id', $userId)
+            ->where('role', 'manager')
+            ->pluck('group_id');
+
+        // What this page is allowed to SHOW — separate from what it lets you
+        // DO, which stays requireManagerAccess() per group. A site admin sees
+        // every group: scoping the list to agent-access rows left an admin
+        // staring at "No groups yet. Create your first group above." with
+        // twelve groups in the database, inviting a duplicate (#4710).
+        // `null` means "no restriction".
+        //
+        // Every one of these routes sits behind `permission:ticketing.settings`
+        // and isSiteAdmin() is `is_super_admin || can('ticketing.settings')`,
+        // so today this is true for anyone who reaches the page at all. The
+        // scoped branch is kept because it is the correct behaviour if that
+        // route gate is ever loosened — it is not load-bearing right now.
+        $visibleGroupIds = $isSiteAdmin ? null : $myGroupIds;
+
         // Archived groups stay in this list — this is the one place they must
         // remain visible, so a manager can see what happened and restore it.
         // Actives first, then archived, each alphabetical.
         $groups = $isBootstrap
             ? collect()
-            : TicketingGroup::whereIn('id', $myGroupIds)
+            : TicketingGroup::when($visibleGroupIds !== null,
+                    fn($q) => $q->whereIn('id', $visibleGroupIds))
                 // tickets_count decides archive-vs-delete, so the UI can warn
                 // the operator which one their click is about to do.
                 ->withCount('tickets')
@@ -88,7 +290,10 @@ class TicketingSettingsController extends Controller
 
         $agents = $isBootstrap
             ? collect()
-            : TicketingAgentAccess::whereIn('group_id', $myGroupIds)->with('group')->get();
+            : TicketingAgentAccess::when($visibleGroupIds !== null,
+                    fn($q) => $q->whereIn('group_id', $visibleGroupIds))
+                ->with('group')
+                ->get();
 
         if ($agents->isNotEmpty()) {
             $agentUserIds = $agents->pluck('user_id')->unique();
@@ -96,19 +301,68 @@ class TicketingSettingsController extends Controller
             $agents->each(fn($a) => $a->user = $agentUsers[$a->user_id] ?? null);
         }
 
+        // #4806 — the groups with no manager left who could still use this
+        // page. Computed once: the page names them in the add form, and #5002
+        // asks the same question again for every Remove button below.
+        $orphanedGroupIds = $isSiteAdmin && !$isBootstrap ? $this->orphanedGroupIds() : [];
+
+        // #5002 — requireRemoveAccess() in prop form, the way myManagedGroupIds
+        // is requireManagerAccess()'s. It cannot be `canManageGroupId(row.group)`
+        // any more: a rescuer may also remove a row on a group that is still
+        // orphaned, and the row their own rescue wrote even after that rescue
+        // un-orphaned the group. A row an administrator can create has to be a
+        // row they can see the Remove on — the list said "Not yours to manage"
+        // over a row the reader had written seconds earlier.
+        $orphanedSet = array_map('intval', $orphanedGroupIds);
+        $removableAgentIds = $agents
+            ->filter(fn ($a) => $myManagedGroupIds->contains($a->group_id)
+                || ($isSiteAdmin && (in_array((int) $a->group_id, $orphanedSet, true)
+                    || ($a->recovered_by !== null && (int) $a->recovered_by === (int) $userId))))
+            ->pluck('id')
+            ->values()
+            ->all();
+
         $priorities = $isBootstrap
             ? collect()
             : PriorityLevel::orderBy('sort_order')->get();
 
         $projects = $isBootstrap
             ? collect()
-            : TicketingProject::whereIn('group_id', $myGroupIds)
+            : TicketingProject::when($visibleGroupIds !== null,
+                    fn($q) => $q->whereIn('group_id', $visibleGroupIds))
                 ->orderBy('name')
                 ->get();
 
-        $emailConnections = $isBootstrap
+        // #6168 — the Email tab's rows. Shaped by hand rather than handed over
+        // as models for one reason: `config` holds the mailbox PASSWORD, and
+        // this prop ships on every settings load, so a credential left in it is
+        // a credential in the page source of everyone who can open Help Desk
+        // Settings. The form asks for a new password instead and
+        // updateEmailConnection() keeps the stored one when the box is blank,
+        // so nothing needs it on the client — `has_password` is all the UI has
+        // to know to say "a password is set".
+        $emailConnections = ($isBootstrap
             ? collect()
-            : EmailConnection::whereIn('group_id', $myGroupIds)->get();
+            : EmailConnection::when($visibleGroupIds !== null,
+                    fn($q) => $q->whereIn('group_id', $visibleGroupIds))
+                ->orderBy('id')
+                ->get())
+            ->map(function (EmailConnection $connection) {
+                $config = $connection->config ?? [];
+                $hasPassword = ($config['password'] ?? '') !== '';
+                unset($config['password']);
+
+                return [
+                    'id'             => $connection->id,
+                    'group_id'       => $connection->group_id,
+                    'type'           => $connection->type,
+                    'active'         => (bool) $connection->active,
+                    'config'         => $config,
+                    'has_password'   => $hasPassword,
+                    'last_polled_at' => $connection->last_polled_at?->toIso8601String(),
+                ];
+            })
+            ->values();
 
         return Inertia::render('Ticketing/Settings', [
             'activeTab'        => $tab,
@@ -119,8 +373,18 @@ class TicketingSettingsController extends Controller
             'ticketStatuses'   => TicketStatus::orderBy('sort_order')->get(),
             'emailConnections' => $emailConnections,
             'myGroupIds'       => $myGroupIds,
+            'myManagedGroupIds' => $myManagedGroupIds,
+            // #4806 — groups with no manager left who could still use this
+            // page. A site admin may add an agent to these and nothing else,
+            // so the Agents tab can offer the recovery instead of printing
+            // "ask a manager of the group" about a group that has none.
+            // Empty for a non-admin: the recovery is not theirs to make.
+            'orphanedGroupIds' => $orphanedGroupIds,
+            // #5002 — the access rows this user may actually remove. Superset
+            // of "rows on a group I manage": see requireRemoveAccess().
+            'removableAgentIds' => $removableAgentIds,
             'isBootstrap'      => $isBootstrap,
-            'isSiteAdmin'      => $this->isSiteAdmin(),
+            'isSiteAdmin'      => $isSiteAdmin,
             'autoCloseDays'    => (int) Setting::get('ticketing.auto_close_days', 0),
             // #938 — the deploy-time repair, and how many rows it would touch. The
             // count is what turns an abstract toggle into a decision somebody can
@@ -293,6 +557,71 @@ class TicketingSettingsController extends Controller
         return $request->expectsJson();
     }
 
+    /**
+     * WHO AM I APPOINTING — the Agents tab's people search ([central-ticketing]
+     * #4926).
+     *
+     * Until this existed the first field of the add-an-agent form was
+     * `<input type="number">` labelled "User ID", with "Find IDs in Admin →
+     * Users" under it. That is a primary key asked of an office administrator,
+     * and on the ONE form the product calls "the only recovery" for a group
+     * with no manager left (#4806): the workflow was to leave the page, search
+     * a name somewhere else, read a number off a URL and type it back in.
+     *
+     * The cost is not only the detour. `storeAgent()` validates
+     * `exists:users,id`, so a NON-existent id is refused cleanly — but 47 typed
+     * for 74 is two real accounts, and the one that gets written is handed
+     * `manager` over a whole help desk queue: every ticket in it, plus the
+     * power to rename, archive and staff it. Nothing on that screen named the
+     * person before the press or after it, so #4781's audit row was the first
+     * place anybody could have found out, after the fact.
+     *
+     * So this is the same search every other Central picker is: `q` over name
+     * and email, answered by `PersonChip::rows()` — the one serializer for a
+     * searchable person (#871) — so the operator's People setting reaches this
+     * picker like the rest, and the page draws `<PersonChip>` rather than a
+     * hand-written name row.
+     *
+     * ── THE GATE IS THE PAGE'S, NOT THE WRITE'S ─────────────────────────────
+     *
+     * requireAgentAccess(), the same one index() uses, and deliberately not a
+     * per-group one: the form picks the PERSON before the GROUP, so there is no
+     * group to scope to yet, and narrowing it afterwards would mean a search
+     * that empties when the picker's second field changes. Nothing is widened
+     * by that — the write itself still goes through
+     * requireManagerAccessOrOrphanRecovery(), so a person found here can only
+     * be appointed to a group the caller manages or is rescuing. Reaching this
+     * route at all already means `permission:ticketing.settings`, which is a
+     * narrower population than TicketController::searchUsers() (any agent on
+     * any one ticket's group) already answers the same question for.
+     */
+    public function searchUsers(Request $request)
+    {
+        $this->requireAgentAccess();
+
+        $q = trim((string) $request->input('q', ''));
+
+        // Two characters, like every other picker on the platform: one letter
+        // is most of the directory, and the dropdown is ten rows. Counted in
+        // CHARACTERS, like admin.settings.users.search, not bytes: an accented
+        // letter is two bytes and a CJK surname is three, so a byte floor lets
+        // a single keystroke answer with the directory on exactly the names a
+        // school has the most trouble typing.
+        if (mb_strlen($q) < 2) {
+            return response()->json([]);
+        }
+
+        return response()->json(PersonChip::rows(
+            User::where(function ($query) use ($q) {
+                $query->where('name', 'like', "%{$q}%")
+                      ->orWhere('email', 'like', "%{$q}%");
+            })
+                ->tap(fn ($query) => PersonNames::orderUsers($query))
+                ->limit(10)
+                ->get(PersonChip::columns())
+        ));
+    }
+
     public function storeAgent(Request $request)
     {
         $this->requireAgentAccess();
@@ -305,25 +634,152 @@ class TicketingSettingsController extends Controller
             'role' => 'required|in:agent,manager',
         ]);
 
-        $this->requireManagerAccess($validated['group_id']);
+        // #4806 — the one way back into a group whose last manager can no
+        // longer act. Asked BEFORE the write, because the write is what ends
+        // the condition: appointing yourself makes isManagerOf() true.
+        $isRecovery = !$this->isManagerOf($validated['group_id'])
+            && $this->orphanedGroupIds([$validated['group_id']]) !== [];
+        $this->requireManagerAccessOrOrphanRecovery($validated['group_id']);
 
         TicketingAgentAccess::updateOrCreate(
             ['user_id' => $validated['user_id'], 'group_id' => $validated['group_id']],
-            ['role' => $validated['role']]
+            [
+                'role' => $validated['role'],
+                // WHO RESCUED THIS GROUP — #5002. A recovery write is the one
+                // write here that can lock its own author out: appoint a
+                // `manager` and the group is no longer orphaned, so the arm
+                // that allowed the press is shut by the press. Stamping the
+                // row is what lets destroyAgent() hand it back.
+                //
+                // Set to null on an ordinary manager's write, including a
+                // manager editing a row an earlier rescue wrote: once the
+                // group has somebody of its own touching the row, it is
+                // theirs and the rescuer has no further claim on it.
+                'recovered_by' => $isRecovery ? Auth::id() : null,
+            ]
         );
 
-        return back()->with('success', 'Agent added.');
+        /*
+         * NAME THE PERSON — [central-ticketing] #4926.
+         *
+         * The flash already went to the trouble of naming the GROUP and saying
+         * it had nobody; naming the appointee is the other half of the same
+         * sentence, and it is the half somebody can check. This write hands a
+         * person read access to every ticket in a queue — and, as a manager,
+         * the power to rename, archive and staff it — so "Agent added." left
+         * the only record of WHO in #4781's audit log, which is somewhere you
+         * go after you already suspect something.
+         *
+         * `PersonNames::display()` and not `$user->name`: the confirmation has
+         * to read the way the rest of the platform writes a name (#524), and
+         * the chip the admin picked from in the form is composed the same way,
+         * so the two agree. A user who vanished between the `exists` rule and
+         * this line leaves `null` and the sentence falls back to exactly what
+         * it printed before — a flash is not where a race should surface.
+         */
+        $person = User::find($validated['user_id']);
+        $who    = $person === null ? null : PersonNames::display($person);
+        $asWhat = $validated['role'] === 'manager' ? 'a manager' : 'an agent';
+        $name   = TicketingGroup::find($validated['group_id'])?->name;
+
+        // Say which group was rescued and that it had nobody: a recovery is a
+        // rare, consequential click and "Agent added." does not describe it.
+        if ($isRecovery) {
+            $added = $who === null ? 'Agent added' : "{$who} added as {$asWhat}";
+
+            return back()->with('success', $name === null
+                ? "{$added} — that group had no manager who could still act."
+                : "{$added} to “{$name}”, which had no manager who could still act.");
+        }
+
+        if ($who === null) {
+            return back()->with('success', 'Agent added.');
+        }
+
+        return back()->with('success', $name === null
+            ? "{$who} added as {$asWhat}."
+            : "{$who} added to “{$name}” as {$asWhat}.");
     }
 
+    /**
+     * REMOVE IS THE SAME DOOR AS ADD — [central-ticketing] #5002.
+     *
+     * This was `requireManagerAccess()` while `storeAgent()` was
+     * requireManagerAccessOrOrphanRecovery(), so the recovery was ONE-WAY: the
+     * site admin who rescued a group could appoint and never un-appoint. The
+     * row they had just written appeared in their own Agents list marked "Not
+     * yours to manage", with no Remove control, and the DELETE answered 403 —
+     * the same person, the same second, the same row.
+     *
+     * Worse for a `manager` press, which is the one the card about the people
+     * search (#4926) called out as the expensive mistake: the write ends the
+     * orphan state, so the admin could not remove the row, could not appoint
+     * anyone else, and could not appoint themselves. The only person left who
+     * could undo it was the person wrongly appointed. That is #4806's frozen
+     * group again, reached through #4806's own cure.
+     *
+     * So two arms beyond an ordinary manager, both narrower than the write
+     * they undo:
+     */
     public function destroyAgent(TicketingAgentAccess $access)
     {
-        $this->requireManagerAccess($access->group_id);
+        $this->requireRemoveAccess($access);
 
         $access->delete();
 
         return back()->with('success', 'Agent removed.');
     }
 
+    /**
+     * May the signed-in user take this agent access row away?
+     *
+     *  1. A manager of the group — the ordinary rule, unchanged.
+     *  2. A site admin, while the group is STILL orphaned. Exactly symmetric
+     *     with storeAgent()'s arm and strictly narrower than it: on a group
+     *     with no manager left, an admin can already appoint themselves
+     *     manager and then remove anything, so this grants nothing new — it
+     *     just does not make them take the group over first to clear a
+     *     dangling row.
+     *  3. A site admin undoing a row THEY wrote as a rescue (`recovered_by`).
+     *     This is the one that reopens the door a mistaken `manager` press
+     *     closed, and it is deliberately not "the group would be orphaned
+     *     without this row": that test cannot tell a mistaken appointment
+     *     from the sole working manager of a healthy group, and admitting the
+     *     second would let any site admin strip a manager from a group that
+     *     is none of their business, then appoint themselves (#4710). A
+     *     rescuer taking back their own appointment claims nothing they did
+     *     not already hold at the moment they made it.
+     *
+     *     And it lasts only until the appointee USES the access — see
+     *     settleRescueStamp(). Otherwise the undo outlives the mistake it is
+     *     for: a rescue that WORKED leaves the stamp on the row of the person
+     *     now running the desk, and arm 3 becomes a permanent lever for
+     *     stripping them and taking the group over (#5008).
+     *
+     * Removing the last manager re-orphans the group, which is the correct
+     * end state: it is recoverable again, by whoever gets there next.
+     */
+    private function requireRemoveAccess(TicketingAgentAccess $access): void
+    {
+        if ($this->isManagerOf($access->group_id)) {
+            $this->settleRescueStamp($access->group_id);
+
+            return;
+        }
+
+        if ($this->isSiteAdmin()) {
+            if ($this->orphanedGroupIds([$access->group_id]) !== []) {
+                return;
+            }
+
+            if ($access->recovered_by !== null && (int) $access->recovered_by === (int) Auth::id()) {
+                return;
+            }
+        }
+
+        abort(403);
+    }
+
     public function storePriority(Request $request)
     {
         if (!$this->isSiteAdmin()) {
@@ -452,13 +908,17 @@ class TicketingSettingsController extends Controller
 
         $this->requireManagerAccess($validated['group_id']);
 
-        EmailConnection::create([
+        $connection = EmailConnection::create([
             'group_id' => $validated['group_id'],
             'type' => $validated['type'],
             'active' => $request->boolean('active', true),
             'config' => $request->input('config', []),
         ]);
 
+        // #6217 — by hand, not by declaration: the password lives in `config`
+        // and the registry would copy it into the log. See EmailConnectionAudit.
+        EmailConnectionAudit::created($connection);
+
         return back()->with('success', 'Email connection saved.');
     }
 
@@ -478,20 +938,62 @@ class TicketingSettingsController extends Controller
             'config.mailbox' => 'nullable|string|max:255',
         ]);
 
+        // #6217 — read BEFORE the save: an update's two sides have to be read
+        // the same way, and after `update()` the old config is gone.
+        $before = EmailConnectionAudit::state($connection);
+
         $connection->update([
             'type' => $request->type,
             'active' => $request->boolean('active', true),
-            'config' => $request->input('config', $connection->config),
+            'config' => $this->mergedConnectionConfig($request, $connection),
         ]);
 
+        EmailConnectionAudit::updated($connection, $before);
+
         return back()->with('success', 'Email connection updated.');
     }
 
+    /**
+     * The config to store for an edited connection.
+     *
+     * #6168 — the page is never sent the stored password (see index()), so the
+     * edit form's password box arrives EMPTY on every save that does not change
+     * it. Taking the request's config as-is would therefore erase the mailbox
+     * credential every time somebody renamed a host or flipped the Active
+     * checkbox. A blank box means "keep the one you have"; typing a new one
+     * replaces it, and the rest of the config is the request's, so a field
+     * cleared on purpose still clears.
+     */
+    private function mergedConnectionConfig(Request $request, EmailConnection $connection): array
+    {
+        $config   = $request->input('config');
+        $existing = $connection->config ?? [];
+
+        if (! is_array($config)) {
+            return $existing;
+        }
+
+        if (($config['password'] ?? '') === '') {
+            unset($config['password']);
+
+            if (($existing['password'] ?? null) !== null) {
+                $config['password'] = $existing['password'];
+            }
+        }
+
+        return $config;
+    }
+
     public function destroyEmailConnection(EmailConnection $connection)
     {
         $this->requireAgentAccess();
         $this->requireManagerAccess($connection->group_id);
         $connection->delete();
+
+        // #6217 — the confirm says the saved credentials go with it. This is
+        // the row that says they were ever there.
+        EmailConnectionAudit::deleted($connection);
+
         return back()->with('success', 'Email connection removed.');
     }
 
@@ -504,7 +1006,7 @@ class TicketingSettingsController extends Controller
         $validated = $request->validate([
             'name'       => 'required|string|max:100',
             'color'      => 'required|string|regex:/^#[0-9a-fA-F]{6}$/',
-            'sort_order' => 'required|integer|min:0',
+            'sort_order' => 'required|integer|min:0|max:65535',
             'is_closed'  => 'boolean',
         ]);
 
@@ -535,7 +1037,7 @@ class TicketingSettingsController extends Controller
         $validated = $request->validate([
             'name'       => 'required|string|max:100',
             'color'      => 'required|string|regex:/^#[0-9a-fA-F]{6}$/',
-            'sort_order' => 'required|integer|min:0',
+            'sort_order' => 'required|integer|min:0|max:65535',
             'is_closed'  => 'boolean',
         ]);
 
@@ -584,6 +1086,9 @@ class TicketingSettingsController extends Controller
             'auto_repair_merged_on_deploy' => 'sometimes|boolean',
         ]);
 
+        // #6217 — both keys as they stand, read before anything writes.
+        $before = AutomationSettingsAudit::snapshot();
+
         Setting::set('ticketing.auto_close_days', $validated['auto_close_days']);
 
         // #938 option A is a behaviour rule, so it is a setting, and it defaults
@@ -595,6 +1100,10 @@ class TicketingSettingsController extends Controller
             );
         }
 
+        // One row for the save, naming only what moved — a tab that re-posts
+        // both boxes every time must not record "somebody pressed Save".
+        AutomationSettingsAudit::record($before);
+
         return back()->with('success', 'Automation settings saved.');
     }
 }

src/Models/TicketingAgentAccess.php

@@ -9,7 +9,13 @@ class TicketingAgentAccess extends Model
 {
     protected $table = 'ticketing_agent_access';
 
-    protected $fillable = ['user_id', 'group_id', 'role'];
+    /**
+     * `recovered_by` is #5002: the site admin who wrote this row as an orphan
+     * recovery (#4806), and may therefore take it back. Null on every row
+     * written by an ordinary manager — see the migration for why this is not
+     * a general-purpose `created_by`.
+     */
+    protected $fillable = ['user_id', 'group_id', 'role', 'recovered_by'];
 
     public function group(): BelongsTo
     {

src/Support/AutomationSettingsAudit.php

@@ -0,0 +1,142 @@
+<?php
+
+namespace Dashboard\Ticketing\Support;
+
+use App\Models\Setting;
+
+/**
+ * THE AUTOMATION TAB, ON THE SHELL'S CHANGES LOG — [central-ticketing] #6217.
+ *
+ * Help Desk Settings → Automation decides two behaviour rules that run with
+ * nobody watching: how many days after a ticket is resolved the nightly sweep
+ * closes it ({@see \Dashboard\Ticketing\Console\Commands\AutoCloseTickets}),
+ * and whether a DEPLOY may rewrite inconsistently-merged rows
+ * ({@see MergedTicketRepair::SETTING}). Both were saved with no trace at all:
+ * `ticketing.settings.automation.update` is not in the census of every
+ * `app=ticketing` row ever written.
+ *
+ * ── WHY THIS IS NOT `registerAuditedModels()` ───────────────────────────────
+ *
+ * The other four tabs this card is about are fixed by declaring models to
+ * `AuditRegistry`. That cannot reach here: this tab writes `App\Models\Setting`
+ * rows, which are SHELL rows and not a ticketing model — declaring a ticketing
+ * model would not pick the path up, and declaring `Setting` itself would put
+ * every platform-wide toggle in Central on the `ticketing` filter and write a
+ * row per KEY. So this half is an explicit domain event, the shape
+ * central-admissions' `SettingsAudit` (#5117) and central-absent-sms' use for
+ * the same kind of panel.
+ *
+ * Three things it exists to get right, and they are that class's three:
+ *
+ *  1. ONE ROW PER SAVE, NOT PER KEY.
+ *  2. ONLY WHAT ACTUALLY MOVED. The tab re-posts both boxes on every save, so
+ *     "somebody pressed Save" is not news.
+ *  3. THE ROW LANDS UNDER `ticketing`. `Audit::appFor()` answers `shell` for
+ *     every non-model subject, and this subject is a string — so without the
+ *     explicit override the row would exist and still be invisible to the
+ *     `App = ticketing` filter, which is the same failure in a smaller package.
+ *
+ * Guarded on `class_exists` throughout: central-logs is optional on any given
+ * host.
+ */
+final class AutomationSettingsAudit
+{
+    /**
+     * The ONE action an automation save is filed under.
+     *
+     * Not the bare `updated` the model-backed tabs use: those rows carry a
+     * subject an operator can click through to, and this one cannot — the
+     * subject is a screen, not a record — so the verb is where the row has to
+     * say what it is about.
+     */
+    public const ACTION = 'ticketing.automation.changed';
+
+    /** The app the row is filed under — see rule 3 in the class docblock. */
+    public const APP = 'ticketing';
+
+    /** The frozen subject label: what an operator would call this screen. */
+    public const SUBJECT = 'Help desk automation settings';
+
+    /**
+     * The settings this tab writes, and what a box reads as when no row exists.
+     *
+     * ABSENT IS NOT BLANK: a school that has never opened this tab is living
+     * under these defaults, and they are what `index()` renders the boxes from
+     * (`Setting::get('ticketing.auto_close_days', 0)` and
+     * `MergedTicketRepair::enabledOnDeploy()`, which defaults `'0'`). Diffing
+     * against `null` instead would call the very first Save a change from
+     * nothing to 0 — the trail's first word about the nightly sweep being a
+     * change nobody made.
+     *
+     * @var array<string,string>
+     */
+    private const DEFAULTS = [
+        'ticketing.auto_close_days' => '0',
+        MergedTicketRepair::SETTING => '0',
+    ];
+
+    /**
+     * The settings as they stand right now. Call BEFORE the writes and hand the
+     * result to {@see record()}.
+     *
+     * ONE query and not one `Setting::get()` apiece, and every key is present in
+     * the answer, so `record()` can read the key list off the snapshot and the
+     * two halves cannot drift apart.
+     *
+     * @return array<string,string>
+     */
+    public static function snapshot(): array
+    {
+        $stored = Setting::query()
+            ->whereIn('key', array_keys(self::DEFAULTS))
+            ->pluck('value', 'key')
+            ->all();
+
+        $out = [];
+        foreach (self::DEFAULTS as $key => $default) {
+            $out[$key] = (string) ($stored[$key] ?? $default);
+        }
+
+        return $out;
+    }
+
+    /**
+     * Diff the snapshot against what is stored now and record one row for what
+     * moved. Call AFTER the writes, with the array `snapshot()` handed back.
+     *
+     * @param  array<string,string>  $before
+     */
+    public static function record(array $before): void
+    {
+        if ($before === [] || ! class_exists(\Central\Logs\Support\Audit::class)) {
+            return;
+        }
+
+        $after   = static::snapshot();
+        $changes = [];
+
+        foreach ($before as $key => $was) {
+            $now = $after[$key] ?? null;
+
+            // Settings are a TEXT column, so everything stored is a string and
+            // the only pair worth special-casing is "no row" against "a row
+            // holding nothing" — both read as the shipped default.
+            if ((string) ($was ?? '') === (string) ($now ?? '')) {
+                continue;
+            }
+
+            $changes[$key] = ['from' => $was, 'to' => $now];
+        }
+
+        if ($changes === []) {
+            return;   // rule 2
+        }
+
+        \Central\Logs\Support\Audit::record(
+            self::ACTION,
+            self::SUBJECT,
+            $changes,
+            ['app' => self::APP],
+        );
+    }
+}

src/Support/EmailConnectionAudit.php

@@ -0,0 +1,225 @@
+<?php
+
+namespace Dashboard\Ticketing\Support;
+
+use Dashboard\Ticketing\Models\EmailConnection;
+
+/**
+ * THE ONE WRITER OF THE EMAIL TAB'S AUDIT TRAIL — [central-ticketing] #6217.
+ *
+ * An email connection is a mailbox the help desk collects FROM: mail that
+ * arrives in it becomes a ticket on the group named beside it. So the row
+ * decides which mailbox the school's help-desk mail is pulled out of, with what
+ * credentials, and whose queue it lands in — and until this class, creating
+ * one, re-pointing one at a different mailbox or deleting one wrote NOTHING to
+ * Admin → Logs → Changes. The delete confirm even says the credentials go
+ * ("Tickets already created from it are kept; the saved credentials are not");
+ * nothing recorded that they had been there.
+ *
+ * ── WHY THIS IS NOT `registerAuditedModels()` ───────────────────────────────
+ *
+ * Its three siblings on the same Settings page — `PriorityLevel`,
+ * `TicketStatus`, `TicketingProject` — ARE declared to `AuditRegistry`, because
+ * every column worth recording on them is a column. This one is different in
+ * exactly one way, and it is the way that matters: the mailbox host, port,
+ * username and PASSWORD all live inside a single `config` JSON column
+ * (`EmailConnection::$casts = ['config' => 'array']`).
+ *
+ *   - Declaring `config` copies the PASSWORD into `audit_events.changes`.
+ *     `Audit::redact()` masks by TOP-LEVEL FIELD NAME, and `normalize()` walks
+ *     into an array without redacting inside it, so a declared `config` is a
+ *     credential written in clear to a table read under `logs.view` alone.
+ *   - Declaring only `group_id` / `type` / `active` — the scalar columns — is
+ *     silent on the write the card is actually about: the observer records
+ *     nothing when no DECLARED field moved, so re-pointing a connection at a
+ *     different host, or changing its password, would still leave no trace.
+ *
+ * So the config is FLATTENED here into `config.host`, `config.username`,
+ * `config.password`, … — which is the spelling `Audit::isSecretField()` masks,
+ * because it matches the substring `password`. {@see write()} masks it at the
+ * source as well, so the real credential is never handed to the logger at all
+ * and the central redaction is the second of two layers rather than the only
+ * one.
+ *
+ * ── THE RULES IT KEEPS, WHICH ARE THE OBSERVER'S OWN ────────────────────────
+ *
+ *  1. ONE ROW PER SAVE. A save that moves the type AND the host is one edit and
+ *     reads as one row, the way an observer-written row would.
+ *  2. NOTHING MOVED, NOTHING RECORDED. The Email tab re-posts every box it
+ *     renders, so "somebody pressed Save" is not news. A blank password box
+ *     means "keep the one you have" ({@see
+ *     \Dashboard\Ticketing\Http\Controllers\TicketingSettingsController::mergedConnectionConfig()}),
+ *     and keeping it is not a change.
+ *  3. THE VERBS ARE `created` / `updated` / `deleted`. Not a private
+ *     `ticketing.email.*` spelling: the other six tabs on this page are
+ *     observer-written under exactly these three, the Changes page's Action
+ *     filter is a SELECT DISTINCT over them, and an operator asking "what was
+ *     deleted in Help Desk today" should not have to know that one tab writes
+ *     its rows by hand.
+ *
+ * The `app` is left to `Audit::appFor()`, which answers `ticketing` from the
+ * `Dashboard\Ticketing\…` namespace of the subject. The subject is the MODEL
+ * and not a string for the same reason: a string subject files under `shell`
+ * and leaves `EmailConnection` out of the Changes log's Subject-type facet,
+ * which is the census the card read the gap off.
+ *
+ * central-logs is optional on any given host — guarded once, in {@see write()},
+ * and not at the three call sites.
+ */
+final class EmailConnectionAudit
+{
+    /**
+     * The config keys the Email tab writes, in the order the form asks for them.
+     *
+     * A fixed list and not `array_keys($config)`: the audit row should say the
+     * same thing about every connection, and an unknown key arriving in the blob
+     * is not something to copy into the log sight-unseen.
+     */
+    private const CONFIG_KEYS = ['host', 'port', 'encryption', 'username', 'password', 'mailbox'];
+
+    public static function created(EmailConnection $connection): void
+    {
+        static::write('created', $connection, static::sided(static::state($connection), 'to'));
+    }
+
+    /**
+     * @param  array<string,mixed>  $before  {@see state()}, taken BEFORE the save
+     */
+    public static function updated(EmailConnection $connection, array $before): void
+    {
+        $changes = [];
+
+        foreach (static::state($connection) as $key => $now) {
+            $was = $before[$key] ?? null;
+
+            if (static::unchanged($was, $now)) {
+                continue;
+            }
+
+            $changes[$key] = ['from' => $was, 'to' => $now];
+        }
+
+        if ($changes === []) {
+            return;   // rule 2
+        }
+
+        static::write('updated', $connection, $changes);
+    }
+
+    public static function deleted(EmailConnection $connection): void
+    {
+        // What the row HELD when it was deleted is usually the whole question
+        // being asked — the same side the observer snapshots on a delete.
+        static::write('deleted', $connection, static::sided(static::state($connection), 'from'));
+    }
+
+    /**
+     * The connection as the log describes it: the scalar columns, plus `config`
+     * flattened one level into dotted keys.
+     *
+     * Public because `updateEmailConnection()` has to take the BEFORE side
+     * itself, before the save — the two halves of an update's diff must be read
+     * the same way or they cannot be compared.
+     *
+     * `last_polled_at` is deliberately absent: it is written by the collector,
+     * not by a person, and a timestamp moving on its own is not a change
+     * anybody made.
+     *
+     * @return array<string,mixed>
+     */
+    public static function state(EmailConnection $connection): array
+    {
+        $config = is_array($connection->config) ? $connection->config : [];
+
+        $state = [
+            'group_id' => $connection->group_id === null ? null : (int) $connection->group_id,
+            'type'     => $connection->type,
+            'active'   => (bool) $connection->active,
+        ];
+
+        foreach (self::CONFIG_KEYS as $key) {
+            $value = $config[$key] ?? null;
+
+            $state['config.'.$key] = ($value === '' ? null : $value);
+        }
+
+        return $state;
+    }
+
+    /**
+     * A whole state as one-sided {from,to} pairs, for a create (`to`) or a
+     * delete (`from`). Unset fields are dropped: an empty box is noise, not
+     * information — `AuditObserver::snapshot()` drops them for the same reason.
+     *
+     * @param  array<string,mixed>  $state
+     * @return array<string, array{from:mixed,to:mixed}>
+     */
+    private static function sided(array $state, string $side): array
+    {
+        $out = [];
+
+        foreach ($state as $key => $value) {
+            if ($value === null) {
+                continue;
+            }
+
+            $out[$key] = $side === 'from'
+                ? ['from' => $value, 'to' => null]
+                : ['from' => null, 'to' => $value];
+        }
+
+        return $out;
+    }
+
+    /**
+     * Did this field move?
+     *
+     * Compared as strings because the two sides come from different places — the
+     * stored JSON on one and a freshly-posted form on the other — so a port that
+     * was saved as `993` and re-posted as `"993"` is the same port, and recording
+     * it as a change would make every Save look like an edit.
+     */
+    private static function unchanged(mixed $was, mixed $now): bool
+    {
+        return static::scalar($was) === static::scalar($now);
+    }
+
+    private static function scalar(mixed $value): string
+    {
+        if (is_bool($value)) {
+            return $value ? '1' : '0';
+        }
+
+        return is_array($value) ? json_encode($value) : (string) ($value ?? '');
+    }
+
+    /**
+     * Write one row, with every secret masked before it leaves this class.
+     *
+     * The mask is `Audit::isSecretField()`'s own answer, applied to the same
+     * flattened key the row will carry, so this and `Audit::redact()` cannot
+     * disagree about what a secret is. NULL is preserved on either side: "was
+     * unset, now set" is information that gives nothing away, and it is the one
+     * thing the trail can honestly say about a credential.
+     *
+     * @param  array<string, array{from:mixed,to:mixed}>  $changes
+     */
+    private static function write(string $action, EmailConnection $connection, array $changes): void
+    {
+        if (! class_exists(\Central\Logs\Support\Audit::class)) {
+            return;
+        }
+
+        foreach ($changes as $key => $pair) {
+            if (! \Central\Logs\Support\Audit::isSecretField((string) $key)) {
+                continue;
+            }
+
+            $mask = fn ($v) => ($v === null || $v === '') ? null : \Central\Logs\Support\Audit::REDACTED;
+
+            $changes[$key] = ['from' => $mask($pair['from'] ?? null), 'to' => $mask($pair['to'] ?? null)];
+        }
+
+        \Central\Logs\Support\Audit::record($action, $connection, $changes);
+    }
+}

src/Support/EmailConnectionAuditLabels.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Dashboard\Ticketing\Support;
+
+use Central\Logs\Support\AuditRegistry;
+use Closure;
+use Dashboard\Ticketing\Models\EmailConnection;
+
+/**
+ * WHAT THE CHANGES LOG CALLS AN EMAIL CONNECTION ROW — [central-ticketing] #6217.
+ *
+ * `Central\Logs\Support\Audit::subjectLabel()` asks
+ * `AuditRegistry::labelClosureFor()` for a label and falls back to
+ * `class_basename().' #'.$key` when there is none. For an email connection that
+ * fallback is `EmailConnection #2`, and the row an auditor most needs to read is
+ * the DELETE — at which point that id names nothing at all. The label is frozen
+ * into the `subject_label` COLUMN at write time, so it is also the only place
+ * the mailbox's name survives the row it described.
+ *
+ * ── WHY THIS DECLARES WITHOUT `AuditRegistry::audit()` ──────────────────────
+ *
+ * `audit()` ATTACHES `AuditObserver` as it declares, and the observer diffs
+ * DECLARED FIELDS by reading them off the model. `EmailConnection`'s mailbox
+ * host, port, username and PASSWORD all live inside one `config` JSON column
+ * (`$casts = ['config' => 'array']`), and `Audit::redact()` masks by TOP-LEVEL
+ * FIELD NAME only — `normalize()` walks into an array but never redacts inside
+ * one. So declaring `config` would copy the mailbox password verbatim into
+ * `audit_events.changes`, and declaring only the scalar columns would say
+ * nothing at all when somebody re-points the connection at a different mailbox,
+ * which is the write this card was filed about.
+ *
+ * {@see EmailConnectionAudit} is therefore the one writer of this trail — it
+ * flattens `config` into `config.host` / `config.password` / … keys, which is
+ * the spelling `Audit::isSecretField()` masks. That leaves only the label to
+ * declare, and it must be declared WITHOUT an observer or every row
+ * `EmailConnectionAudit` writes would be written a second time.
+ *
+ * Same shape and same reason as central-pulse's `PulseAuditLabels` (#5980), the
+ * shell's `App\Support\Groups\GroupAuditLabels` (#6046) and
+ * central-verification's `VerificationAuditLabels` (#5276): `AuditRegistry`
+ * holds its declarations in a `protected static` array and attaches the
+ * observer in the same call, so the only way to put a label closure in front of
+ * `Audit::subjectLabel()` without attaching anything is to subclass the registry
+ * and write the declaration directly — a subclass shares the parent's static
+ * storage, so this IS `AuditRegistry`'s own array and `labelClosureFor()` reads
+ * it back.
+ */
+final class EmailConnectionAuditLabels extends AuditRegistry
+{
+    /**
+     * Declare `EmailConnection`'s label to the Changes log.
+     *
+     * Called from `TicketingServiceProvider::registerAuditedModels()`, behind
+     * the `class_exists()` that method already keeps on the registry —
+     * central-logs is optional on any given host.
+     */
+    public static function register(): void
+    {
+        self::declareLabel(EmailConnection::class, fn (EmailConnection $connection) => static::label($connection));
+    }
+
+    /**
+     * The mailbox, then the host, then the group — the SAME order the Email tab
+     * itself names a row in (`emailConnectionLabel()` in `Settings.vue`), so the
+     * log calls a connection what the page the operator was looking at called it.
+     *
+     * `config['mailbox']` is deliberately NOT in that list: on this form it is
+     * the IMAP FOLDER and defaults to `INBOX`, so falling back to it would label
+     * every half-filled connection "INBOX".
+     *
+     * The group comes second because it is the other half of what the row
+     * decides — which desk's queue this mailbox's mail lands in.
+     */
+    private static function label(EmailConnection $connection): string
+    {
+        $config = is_array($connection->config) ? $connection->config : [];
+
+        $mailbox = (string) ($config['username'] ?? $config['host'] ?? '');
+
+        return ($mailbox !== '' ? $mailbox : 'Mailbox')
+            .' → '.($connection->group?->name ?: 'a help desk group');
+    }
+
+    /**
+     * One label closure, and no observer.
+     *
+     * `fields: []` and `sensitive: false` are stated rather than left out so the
+     * shape of the declaration is the shape `AuditRegistry::audit()` writes —
+     * `fieldsFor()`, `isSensitive()` and `all()` all read this array.
+     */
+    private static function declareLabel(string $modelClass, Closure $label): void
+    {
+        try {
+            static::$models[$modelClass] = [
+                'fields'    => [],
+                'label'     => $label,
+                'sensitive' => false,
+            ];
+        } catch (\Throwable $e) {
+            // The registry changed shape under us. Reported so it is visible,
+            // never rethrown: the cost is the id-label we have always had.
+            report($e);
+        }
+    }
+}

src/Support/MergedTicketRepair.php

@@ -84,17 +84,22 @@ class MergedTicketRepair
      */
     public static function repairAll(string $by): int
     {
-        $numbers = Ticket::query()->inconsistentlyMerged()->pluck('number')->all();
+        $tickets = Ticket::query()->inconsistentlyMerged()->orderBy('id')->get();
 
-        if ($numbers === []) {
+        if ($tickets->isEmpty()) {
             Log::info("[ticketing] #938 merged-ticket repair ({$by}): nothing to repair.");
 
             return 0;
         }
 
-        $changed = Ticket::query()->inconsistentlyMerged()->update([
+        // Per model, not one builder update (#4781/#4807): `merged` makes a ticket
-            'status' => Ticket::STATUS_MERGED,
+        // permanently read-only, and a bulk statement would freeze it with nothing
-        ]);
+        // on the Changes log — while repair() below, the same change one ticket at
+        // a time, is recorded.
+        $tickets->each(fn (Ticket $ticket) => $ticket->forceFill(['status' => Ticket::STATUS_MERGED])->save());
+
+        $numbers = $tickets->pluck('number')->all();
+        $changed = $tickets->count();
 
         // The numbers, not just the count. These rows are being made read-only,
         // and "which ones" is the question the office will ask afterwards.

src/TicketingServiceProvider.php

@@ -2,6 +2,7 @@
 
 namespace Dashboard\Ticketing;
 
+use Illuminate\Console\Scheduling\Schedule;
 use Illuminate\Support\ServiceProvider;
 
 class TicketingServiceProvider extends ServiceProvider
@@ -23,11 +24,288 @@ class TicketingServiceProvider extends ServiceProvider
         // Notifications is absent or dark — the notifier no-ops.
         \Dashboard\Ticketing\Support\TicketingNotifier::registerCategories();
 
+        // Declare this app's models to the shell's audit trail (#4781), so a
+        // ticket, a group retirement and above all an AGENT GRANT are on the
+        // Changes log. Guarded inside — central-logs is optional on a host.
+        $this->registerAuditedModels();
+
         if ($this->app->runningInConsole()) {
             $this->commands([
                 \Dashboard\Ticketing\Console\Commands\AutoCloseTickets::class,
                 \Dashboard\Ticketing\Console\Commands\RepairMergedTickets::class,
             ]);
         }
+
+        $this->scheduleAutoClose();
+    }
+
+    /**
+     * THE NIGHTLY AUTO-CLOSE IS SCHEDULED HERE, BESIDE THE COMMAND IT NAMES
+     * ([central-ticketing] #2980, a spawn of [dashboard-shell] #2965).
+     *
+     * It used to be one line in the shell's routes/console.php — a file that
+     * names commands other repositories define. On 2026-09-26 01:10 PDT that
+     * arrangement cost production a php process a day whose entire output was
+     * *Command "admissions:remind-unconfirmed-links" is not defined*, exit 1: a
+     * schedule had reached a box nine and a half hours ahead of the code it
+     * scheduled, and nothing an operator could press would have fixed it,
+     * because the code was not there to fix.
+     *
+     * Registered from this provider, that is not expressible. The event exists
+     * on exactly the boxes where `AutoCloseTickets` is registered above,
+     * because the same `boot()` does both and both arrive in the same commit.
+     * A shell without central-ticketing simply has no such row in
+     * `schedule:list`, rather than a nightly failure about one.
+     *
+     * ── THE MINUTE IS STILL THE SHELL'S TO DECIDE ──────────────────────────
+     *
+     * `ScheduleStagger` is the one place a start time is chosen, and that is
+     * the whole point of it: a bare `->daily()` is 00:00:00, where every hourly
+     * and every quarter-hourly task on the platform already boots its own PHP
+     * inside the scheduler's one cgroup ([dashboard-shell] #1910). A time typed
+     * in this repository could not know that. Asking `dailyAt()` keeps this job
+     * at 00:12 — exactly where routes/console.php had it — and keeps the shell's
+     * map the single account of the night even for a job it no longer schedules.
+     *
+     * No `withoutOverlapping()`, and deliberately not added here: the shell's
+     * line carried none, and a lock is a behaviour change rather than a move.
+     */
+    private function scheduleAutoClose(): void
+    {
+        $this->callAfterResolving(Schedule::class, function (Schedule $schedule) {
+            $schedule->command('ticketing:auto-close')
+                // …AND THE CLOCK IS THE SCHOOL'S ([dashboard-shell] #3144).
+                // ScheduleStagger decides the MINUTE; `dailyAt()` on its own is
+                // read against config('app.timezone'), which is UTC on every box
+                // here — so 00:12 was landing at 17:12 the previous afternoon,
+                // i.e. the nightly sweep ran in the middle of the school day.
+                ->timezone(\App\Support\Timezone::organisation())
+                ->dailyAt(\App\Support\Ops\ScheduleStagger::dailyAt('ticketing:auto-close'));
+        });
+    }
+
+    /**
+     * HELP DESK WRITES TO THE SHELL'S CHANGES LOG — [central-ticketing] #4781.
+     *
+     * Until this method existed, `ticketing` was not one of the apps
+     * `audit_events` had ever seen: 4,378 rows, fifteen distinct apps, not one
+     * of them this one. A QA sweep signed in as a super admin, created a ticket,
+     * replied to it, and found that the newest row in the table afterwards was
+     * the shell recording the sweep's own visit to the log page. So "who closed
+     * this", "who deleted that group" and — the one that actually matters —
+     * "who gave this person the keys to the HR desk's queue" had no answer
+     * anywhere in Central.
+     *
+     * Nothing in core was wrong. `AuditRegistry`'s own docblock is explicit that
+     * snap-ins register their own models from their own providers and that core
+     * never references a snap-in. Ticketing simply never declared. This is the
+     * declaration, in the shape `FormsServiceProvider::registerAuditedGrants()`
+     * uses for `FormCollaborator` and `FormSharedGroup` — the precedent is exact
+     * and so is the reason: granting somebody access to other people's
+     * correspondence is a permission change, and a permission change belongs on
+     * the record.
+     *
+     * Declaring a model is the whole job. The registry attaches `AuditObserver`
+     * itself, so every create / declared-field update / delete on these seven
+     * classes lands in the Changes tab under app `ticketing` (derived from the
+     * namespace by `Audit::appForClass()`), with the actor and the subject's
+     * label frozen into the row at write time.
+     *
+     * ── HALF A SETTINGS PAGE IS NOT A DECISION — #6217 ───────────────────────
+     *
+     * #4781 declared four models. Help Desk Settings has SEVEN tabs, and a
+     * second sweep a fortnight later found that Groups and Agents were fully
+     * audited while Priorities, Statuses, Projects, Email connections and
+     * Automation — same page, same buttons, same super admin — wrote nothing at
+     * all. The census was flat: zero rows for `settings.priorities.*`,
+     * `settings.statuses.*`, `settings.projects.*`, `settings.email.*` and
+     * `settings.automation.update` in the whole store, and none of those models
+     * in the Changes log's Subject-type facet. QA had driven the Priorities
+     * routes on the box inside 48 hours and the log held none of it.
+     *
+     * `PriorityLevel`, `TicketStatus` and `TicketingProject` join the list
+     * below. The other two could not, and are handled in their own classes for
+     * reasons that are theirs and not an omission — see the next section.
+     *
+     * ── THE FIELD LISTS ARE THE VOLUME CONTROL ───────────────────────────────
+     *
+     * Only declared fields are diffed and an update touching none of them
+     * records nothing at all, so these lists — not the tables' width — decide
+     * what the log costs. Each is the set of columns somebody would ask an
+     * auditor about: where a ticket lives, who is on the hook for it, what state
+     * it is in, and who may see it. `color` on a group and `description` on a
+     * ticket are left out deliberately: a palette tweak is not an audit event,
+     * and the body of a complaint is correspondence we are not copying into a
+     * second table to be kept for seven years.
+     *
+     * ── NOTHING HERE IS `sensitive`, AND THAT IS A DECISION ──────────────────
+     *
+     * `sensitive: true` buys exactly one thing: read-audit. It makes
+     * `RecordSensitiveViews` record a `viewed` row every time a route implicitly
+     * binds the model on a successful GET. For `Ticket` that is every agent
+     * opening every ticket all day — volume that would bury the writes this card
+     * is about, to answer a question nobody asked. It changes no retention
+     * window either (writes are kept on the operator's Changes window
+     * regardless; `sensitive` only lengthens what READ rows get). So: writes,
+     * declared; reads, not. If ticketing ever needs "who read this ticket", that
+     * is its own card and its own conversation about volume.
+     *
+     * ── WHAT IS AUDITED, BUT NOT FROM HERE ───────────────────────────────────
+     *
+     * `EmailConnection` and the Automation tab are both on the record; neither
+     * can be put there by a declaration.
+     *
+     * `EmailConnection` keeps its mailbox host, port, username and PASSWORD in
+     * one `config` JSON column. The registry diffs declared fields by reading
+     * them, and `Audit::redact()` masks by TOP-LEVEL FIELD NAME only — it never
+     * redacts inside an array — so declaring `config` would write the school's
+     * mailbox password in clear into `audit_events.changes`, a table readable
+     * under `logs.view` alone. Declaring only the scalar columns is the other
+     * trap: an update that moved no DECLARED field records nothing, so
+     * re-pointing a connection at a different mailbox would still be silent,
+     * and that is the exact write #6217 was filed about.
+     * {@see Support\EmailConnectionAudit} therefore writes the three verbs by
+     * hand with `config` flattened into `config.host` / `config.password` / …
+     * keys — the spelling the central redaction masks — and
+     * {@see Support\EmailConnectionAuditLabels} declares the LABEL here with no
+     * observer, so the hand-written rows are not doubled.
+     *
+     * The Automation tab writes `App\Models\Setting` rows, which are SHELL rows
+     * and not a ticketing model at all: no declaration here could reach them,
+     * and declaring `Setting` would put every platform-wide toggle in Central
+     * on the `ticketing` filter. {@see Support\AutomationSettingsAudit} records
+     * it as one explicit domain event per save.
+     *
+     * ── WHAT IS DELIBERATELY NOT DECLARED ────────────────────────────────────
+     *
+     * `TicketMessage`. The reporter expected a row for the reply they posted,
+     * and it is the right instinct on the wrong model: a message can only ever
+     * be created (there is no edit route and no delete route — see
+     * `TicketMessageController`, which has one method), so auditing it could
+     * only ever mean one row per message. Every inbound email through an
+     * `EmailConnection` writes one, under `system`, and a merge rewrites whole
+     * runs of them. That is a stream of "a message exists" against the record of
+     * who CHANGED something, which is what the Changes tab is for — and the
+     * messages themselves are already the permanent, readable record of what was
+     * said. The ticket's own row says who opened it and who closed it; the
+     * thread says what was written in between.
+     *
+     * A group hard-delete cascades its agent-access rows in the DATABASE (see
+     * the migration's foreign key), so those grants end without a `deleted` row
+     * of their own. The group's deletion is recorded, which is the question
+     * being asked — but it is worth knowing that the two are one event here and
+     * not several.
+     *
+     * Guarded on the class and wrapped in a catch for the same reason Forms and
+     * Files are: central-logs is optional on any given host, and a declaration
+     * must never be the reason a box fails to boot.
+     */
+    private function registerAuditedModels(): void
+    {
+        if (! class_exists(\Central\Logs\Support\AuditRegistry::class)) {
+            return;
+        }
+
+        try {
+            /*
+             * THE GRANT. The reason this card was filed and the first thing
+             * declared: `ticketing.settings.agents.store` / `.destroy` hand out
+             * and take back a person's access to a help desk group's entire
+             * queue, and did so leaving no trace at all.
+             *
+             * The label is resolved the long way round because this model has no
+             * `user()` relation and must not grow one — `TicketingSettingsController`
+             * HYDRATES `$access->user` as a plain attribute for the Settings page,
+             * and a relation of the same name would fight it.
+             */
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\TicketingAgentAccess::class,
+                fields: ['user_id', 'group_id', 'role'],
+                label: fn ($access) => (\App\Models\User::find($access->user_id)?->name ?? 'Deleted user')
+                    .' on '.($access->group?->name ?? 'a help desk group'),
+            );
+
+            // The desk itself: renamed, re-prefixed, pointed at a different
+            // inbox, archived, restored, or deleted outright. `archived_at` is
+            // what tells archive from delete — one button does both, chosen by
+            // whether the group still owns tickets.
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\TicketingGroup::class,
+                fields: ['name', 'prefix', 'email_address', 'archived_at'],
+                label: fn ($group) => ($group->name ?: 'Help desk group')
+                    .($group->prefix ? ' ('.$group->prefix.')' : ''),
+            );
+
+            // The ticket: created, deleted, moved between desks, re-assigned,
+            // re-prioritised, closed, merged. `merged_into_id` is declared
+            // beside `status` because a merge is a pair of columns moving
+            // together and reading either one alone misreports it.
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\Ticket::class,
+                fields: [
+                    'group_id', 'status', 'assigned_to', 'priority_id',
+                    'project_id', 'due_date', 'merged_into_id', 'title',
+                ],
+                label: fn ($ticket) => trim(($ticket->number ?: 'Ticket').' '.($ticket->title ?? '')),
+            );
+
+            // Participants are the OTHER way somebody comes to see a ticket's
+            // correspondence — narrower than an agent grant (one ticket, not a
+            // whole queue) but the same kind of fact.
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\TicketParticipant::class,
+                fields: ['ticket_id', 'user_id', 'added_by'],
+                label: fn ($participant) => (\App\Models\User::find($participant->user_id)?->name ?? 'Deleted user')
+                    .' on ticket '.($participant->ticket?->number ?? '#'.$participant->ticket_id),
+            );
+
+            // ── THE SETTINGS CATALOGUES ([central-ticketing] #6217) ──────────
+            //
+            // The three tabs below are a shared vocabulary: every ticket in the
+            // school is filed under one of these rows, so renaming, reordering
+            // or removing one re-labels work that is already done. `color` is
+            // left out of all three for the reason the group's is — a palette
+            // tweak is not an audit event — and so is `description`, which is
+            // help text under a box rather than a fact about the desk.
+
+            // What a priority is CALLED and where it RANKS. `sort_order` is
+            // declared because it is the order the pickers and the board read:
+            // moving "Urgent" below "Low" changes what the office sees first.
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\PriorityLevel::class,
+                fields: ['name', 'sort_order'],
+                label: fn ($priority) => 'Priority: '.($priority->name ?: '#'.$priority->getKey()),
+            );
+
+            // `slug` is declared beside `name` and never changes after creation
+            // — which is exactly why it is worth the row: `tickets.status`
+            // stores the SLUG, so the slug on a `deleted` entry is the only
+            // thing that says which tickets' status just stopped resolving to
+            // anything. `is_closed` is behaviour, not decoration: it decides
+            // whether a ticket in this status counts as finished, and the board
+            // reads it to decide which tickets are still open
+            // (`TicketController::index()`'s `$closedSlugs`).
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\TicketStatus::class,
+                fields: ['slug', 'name', 'sort_order', 'is_closed'],
+                label: fn ($status) => 'Status: '.($status->name ?: $status->slug ?: '#'.$status->getKey()),
+            );
+
+            // A project is a folder of tickets on one desk. `group_id` is
+            // declared because it is which desk — the same fact `Ticket`
+            // declares it for.
+            \Central\Logs\Support\AuditRegistry::audit(
+                \Dashboard\Ticketing\Models\TicketingProject::class,
+                fields: ['group_id', 'name', 'status'],
+                label: fn ($project) => 'Project: '.($project->name ?: '#'.$project->getKey())
+                    .' ('.($project->group?->name ?? 'a help desk group').')',
+            );
+
+            // The LABEL only, and deliberately no observer — see the class, and
+            // the "WHAT IS AUDITED, BUT NOT FROM HERE" section above.
+            Support\EmailConnectionAuditLabels::register();
+        } catch (\Throwable) {
+            // Never let a declaration break boot.
+        }
     }
 }

src/routes/ticketing.php

@@ -41,12 +41,25 @@ Route::middleware(['web', 'auth', 'app.access:ticketing'])
         // ── Settings (must be before /{ticket} wildcard) ──────────────────────
         Route::middleware('permission:ticketing.settings')->group(function () {
             Route::get('/settings',                          [TicketingSettingsController::class, 'index'])               ->name('settings');
+            // #6168 — `email` belongs in this list. It was the one tab segment
+            // the whitelist omitted while the page shipped an `emailConnections`
+            // prop on every render and the three write routes below were live, so
+            // the only deep link an admin could guess fell through to the POST-only
+            // `/settings/email` and answered 405. The Vue's TAB_KEYS and this list
+            // are now pinned to each other by
+            // tests/Unit/TicketingSettingsTabsAreOneVocabularyTest.php.
             Route::get('/settings/{tab}',                    [TicketingSettingsController::class, 'index'])
-                ->where('tab', 'groups|agents|priorities|statuses|projects|automation')->name('settings.tab');
+                ->where('tab', 'groups|agents|priorities|statuses|projects|email|automation')->name('settings.tab');
             Route::post('/settings/groups',                  [TicketingSettingsController::class, 'storeGroup'])          ->name('settings.groups.store');
             Route::put('/settings/groups/{group}',           [TicketingSettingsController::class, 'updateGroup'])         ->name('settings.groups.update');
             Route::delete('/settings/groups/{group}',        [TicketingSettingsController::class, 'destroyGroup'])        ->name('settings.groups.destroy');
             Route::post('/settings/groups/{group}/restore',  [TicketingSettingsController::class, 'restoreGroup'])        ->name('settings.groups.restore');
+            // #4926 — the add-an-agent form's people search. Before it the form's
+            // first field was a raw numeric user id with "Find IDs in Admin → Users"
+            // under it, on the one screen that is the only recovery for a help desk
+            // group with no manager left (#4806). Two segments, so it cannot collide
+            // with the single-segment `/settings/{tab}` above.
+            Route::get('/settings/agents/search',            [TicketingSettingsController::class, 'searchUsers'])        ->name('settings.agents.search');
             Route::post('/settings/agents',                  [TicketingSettingsController::class, 'storeAgent'])          ->name('settings.agents.store');
             Route::delete('/settings/agents/{access}',       [TicketingSettingsController::class, 'destroyAgent'])        ->name('settings.agents.destroy');
             Route::post('/settings/priorities',              [TicketingSettingsController::class, 'storePriority'])       ->name('settings.priorities.store');